commit 5cbd3f29e354b221bffa639efeed491ea6036d5d
Author: wehub-resource-sync <resource-sync@wehub.local>
Date:   Mon Jul 13 12:41:19 2026 +0800

    chore: import upstream snapshot with attribution

diff --git a/.agents/skills/add-function-body/SKILL.md b/.agents/skills/add-function-body/SKILL.md
new file mode 100644
index 0000000..21ee68d
--- /dev/null
+++ b/.agents/skills/add-function-body/SKILL.md
@@ -0,0 +1,120 @@
+---
+name: add-function-body
+description: Add a function body definition to an ONNX operator, defining how it decomposes into simpler ops. Use when asked to make an op decomposable, add a FunctionBody, implement SetContextDependentFunctionBodyBuilder, or express an op in terms of other ONNX operators.
+---
+
+Follow the full guide in [docs/AddFunctionBody.md](../../../docs/AddFunctionBody.md).
+
+## File Locations
+
+| Component | File |
+|-----------|------|
+| Function body definition | `onnx/defs/<domain>/defs.cc` (inline with schema) |
+| FunctionBuilder utilities | `onnx/defs/function.h` |
+| Function tests | `onnx/test/cpp/function_get_test.cc`, `onnx/test/cpp/function_verify_test.cc` |
+
+## Method 1: Simple String-Based Function Body
+
+```cpp
+ONNX_OPERATOR_SET_SCHEMA(
+    LessOrEqual, 16,
+    OpSchema()
+        // ... inputs, outputs, type constraints ...
+        .TypeAndShapeInferenceFunction(inferenceFunction)
+        .FunctionBody(R"ONNX(
+        {
+            O1 = Less (A, B)
+            O2 = Equal (A, B)
+            C = Or (O1, O2)
+        }
+        )ONNX"));
+```
+
+With explicit opset version:
+```cpp
+        .FunctionBody(R"ONNX(...)ONNX", 18)  // Valid from opset 18
+```
+
+Referencing attributes with `@attr_name`:
+```cpp
+        .FunctionBody(R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            ...
+          }
+        )ONNX")
+```
+
+## Method 2: Context-Dependent Function Body
+
+For ops whose decomposition varies based on attributes or optional inputs:
+
+```cpp
+static bool BuildFunctionBodyMyOp(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  FunctionBuilder builder(functionProto);
+  // Build graph based on ctx.hasInput(), ctx.getAttribute(), etc.
+  builder.Add("output = SomeOp (input)");
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+// Register:
+    .SetContextDependentFunctionBodyBuilder(BuildFunctionBodyMyOp)
+```
+
+## FunctionBuilder API
+
+```cpp
+FunctionBuilder builder(functionProto);
+builder.Add("Y = Relu (X)");                          // Add node
+builder.Const("alpha", std::vector<float>{0.01f});    // Constant tensor
+builder.Const1D("axes", int64_t(1));                  // 1-D constant
+builder.Add(R"(                                       // Multi-line
+    X_Sub = Sub (X, X_Max)
+    X_Exp = Exp (X_Sub)
+)");
+builder.AddOpset("", 18);                             // Opset dependency
+schema.BuildFunction(functionProto);                  // Finalize
+return true;
+```
+
+## Multiple Opset Versions
+
+```cpp
+    .SetContextDependentFunctionBodyBuilder(builderForOpset13)
+    .SetContextDependentFunctionBodyBuilder(builderForOpset18, 18)
+```
+
+## ONNX Function Body Syntax
+
+Function body strings use the ONNX text format ("onnxtxt"). See the [`onnxtxt`](../onnxtxt/SKILL.md) skill for the full syntax cheat sheet, attribute references (`@attr_name`), `Constant <value = ...>` forms, `CastLike` vs `Cast`, body-subgraph idioms, and parser tests. Quick reminders specific to function bodies:
+
+- Variable names are local intermediates; input/output names must match the schema's declared names.
+- Reference enclosing-op attributes with `@attr_name` — and only those declared in `.Attr(...)` calls.
+- Use `CastLike` (not `Cast`) when the target type depends on another input.
+
+## Code Style: Prefer Named Functions
+
+Define context-dependent function body builders as **separate named functions** rather than inline lambdas within `ONNX_OPERATOR_SET_SCHEMA`. The macro expansion makes setting breakpoints on inline lambdas unreliable in debuggers.
+
+Simple string-based `.FunctionBody(R"ONNX(...)ONNX")` definitions don't have this issue.
+
+## After Making Changes
+
+```bash
+python onnx/defs/gen_doc.py
+lintrunner -a --output oneline
+```
+
+## Common Mistakes
+
+- Forgetting `schema.BuildFunction(functionProto)` at end of context-dependent builders
+- Forgetting to `return true` from the builder function
+- Variable names conflicting with input/output names
+- Using `Cast` instead of `CastLike` for dynamic type matching
+- Function body not producing all declared outputs
+- Using `@attr_name` for an attribute not declared in `.Attr()` calls
diff --git a/.agents/skills/add-op/SKILL.md b/.agents/skills/add-op/SKILL.md
new file mode 100644
index 0000000..952b682
--- /dev/null
+++ b/.agents/skills/add-op/SKILL.md
@@ -0,0 +1,99 @@
+---
+name: add-op
+description: Add a new ONNX operator or update an existing operator to a new opset version. Use when asked to define an operator schema, register an op, add inputs/outputs/attributes to an op, move an op to old.cc, or bump an op's opset version.
+---
+
+Follow the full procedure in [docs/AddNewOp.md](../../../docs/AddNewOp.md).
+
+## Files to Modify
+
+| Component | File |
+|-----------|------|
+| Schema definition | `onnx/defs/<domain>/defs.cc` |
+| Operator set registration | `onnx/defs/operator_sets.h` |
+| Type/shape inference | Inline in schema via `.TypeAndShapeInferenceFunction(...)` |
+| Function body (if applicable) | Inline in schema via `.FunctionBody(...)` |
+| Reference implementation | `onnx/reference/ops/op_<lowercase_name>.py` |
+| Node tests | `onnx/backend/test/case/node/<lowercase_name>.py` |
+| Shape inference tests | `onnx/test/shape_inference_test.py` |
+| Version converter adapter (if behavior changed) | `onnx/version_converter/adapters/<name>_<from>_<to>.h` |
+| Upgrade/downgrade tests | `onnx/test/version_converter/automatic_upgrade_test.py` and `automatic_downgrade_test.py` |
+
+Domain subdirectories under `onnx/defs/`: `math/`, `nn/`, `tensor/`, `logical/`, `reduction/`, `rnn/`, `sequence/`, `image/`, `text/`, `quantization/`, `controlflow/`, `optional/`, `traditionalml/`, `training/`
+
+## Schema Registration Pattern
+
+```cpp
+ONNX_OPERATOR_SET_SCHEMA(
+    OperatorName,
+    OPSET_VERSION,
+    OpSchema()
+        .SetDoc(OperatorName_verN_doc)
+        .Input(0, "X", "Description", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Description", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Attr("attr_name", "Description", AttributeProto::FLOAT, default_value)
+        .TypeConstraint("T", {"tensor(float)", "tensor(double)", ...}, "Description")
+        .TypeAndShapeInferenceFunction(InferShapeForOperatorName)
+        // Function body uses ONNX text format — see the onnxtxt skill for syntax/conventions.
+        .FunctionBody(R"ONNX(
+          {
+            ...
+          }
+        )ONNX", FUNCTION_OPSET_VERSION));
+```
+
+## Updating an Existing Operator
+
+1. Move current schema from `defs.cc` to `old.cc` in the same domain directory
+2. Create new version in `defs.cc` with the new opset version number
+3. Update `onnx/defs/operator_sets.h`
+4. Add a version converter adapter if behavior changed
+5. Add upgrade/downgrade tests
+
+### Avoiding duplication between defs.cc and old.cc
+
+When moving a schema to `old.cc`, avoid significant code/documentation duplication:
+
+- Extract common logic (doc strings, type constraint lists, shape inference helpers) into shared functions in the domain's header or utils file.
+- Use parameterized helpers when versions differ only slightly (e.g., expanded type list, additional optional input).
+- Some duplication is acceptable when sharing would create overly complicated logic. Prefer clarity over DRY when the alternative makes either version harder to understand independently.
+
+## Code Style: Prefer Named Functions
+
+Define shape inference functions and function body builders as **separate named functions** rather than inline lambdas within `ONNX_OPERATOR_SET_SCHEMA`. The macro expansion makes setting breakpoints on inline lambdas unreliable in debuggers.
+
+```cpp
+// PREFERRED: named function — easy to set breakpoints
+static void InferShapeForMyOp(InferenceContext& ctx) {
+    propagateElemTypeFromInputToOutput(ctx, 0, 0);
+    // ...
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MyOp, 21,
+    OpSchema()
+        // ...
+        .TypeAndShapeInferenceFunction(InferShapeForMyOp));
+```
+
+## Writing Tests
+
+For test fixtures, prefer the ONNX text format via `onnx.parser` / C++ `OnnxParser`. See the [`onnxtxt`](../onnxtxt/SKILL.md) skill for the per-file recommendations table, body-subgraph idioms, the argument-order convention, and the `unk__*` materialization gotcha. (Empirical: PR #7962 cut ~58–70% of test LOC by switching.)
+
+## After Making Changes
+
+```bash
+python onnx/defs/gen_doc.py
+python onnx/backend/test/stat_coverage.py
+python onnx/gen_proto.py  # only if proto changed
+lintrunner -a --output oneline
+```
+
+## References
+
+- [docs/AddNewOp.md](../../../docs/AddNewOp.md) — Full procedure for adding/updating ops
+- [docs/AddFunctionBody.md](../../../docs/AddFunctionBody.md) — Function body guide
+- [docs/ShapeInference.md](../../../docs/ShapeInference.md) — Shape inference guide
+- [../onnxtxt/SKILL.md](../onnxtxt/SKILL.md) — ONNX text format ("onnxtxt") for tests and function bodies
+- [references/node-test-pattern.md](references/node-test-pattern.md) — Node test example
+- [references/reference-impl-pattern.md](references/reference-impl-pattern.md) — Reference implementation example
diff --git a/.agents/skills/add-op/references/node-test-pattern.md b/.agents/skills/add-op/references/node-test-pattern.md
new file mode 100644
index 0000000..d432c9a
--- /dev/null
+++ b/.agents/skills/add-op/references/node-test-pattern.md
@@ -0,0 +1,39 @@
+# Node Test Pattern
+
+Example test file at `onnx/backend/test/case/node/<name>.py`:
+
+```python
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class OpName(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "OpName",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.some_operation(x)
+        expect(node, inputs=[x], outputs=[y], name="test_opname")
+
+    @staticmethod
+    def export_with_broadcasting() -> None:
+        node = onnx.helper.make_node(
+            "OpName",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(5).astype(np.float32)
+        expect(node, inputs=[x, y], outputs=[x + y], name="test_opname_bcast")
+```
+
+Each `export*` static method becomes a separate test case. The `expect` helper validates the reference implementation output matches.
diff --git a/.agents/skills/add-op/references/reference-impl-pattern.md b/.agents/skills/add-op/references/reference-impl-pattern.md
new file mode 100644
index 0000000..6ec0480
--- /dev/null
+++ b/.agents/skills/add-op/references/reference-impl-pattern.md
@@ -0,0 +1,56 @@
+# Reference Implementation Pattern
+
+Example at `onnx/reference/ops/op_<name>.py`:
+
+```python
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class OpName(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.some_operation(x),)
+```
+
+## Base Classes
+
+| Base class | Use case |
+|-----------|----------|
+| `OpRun` | General-purpose (any signature) |
+| `OpRunUnary` | Single input, single output |
+| `OpRunUnaryNum` | Single numeric input, validates output dtype matches |
+| `OpRunBinary` | Two inputs |
+| `OpRunBinaryNumpy` | Two inputs using a numpy function directly |
+
+## Binary Op Example
+
+```python
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryNumpy
+
+
+class Add(OpRunBinaryNumpy):
+    def __init__(self, onnx_node, run_params):
+        OpRunBinaryNumpy.__init__(self, np.add, onnx_node, run_params)
+```
+
+## General Op Example
+
+```python
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Concat(OpRun):
+    def _run(self, *inputs, axis=None):
+        return (np.concatenate(inputs, axis=axis),)
+```
diff --git a/.agents/skills/add-shape-inference/SKILL.md b/.agents/skills/add-shape-inference/SKILL.md
new file mode 100644
index 0000000..92601ac
--- /dev/null
+++ b/.agents/skills/add-shape-inference/SKILL.md
@@ -0,0 +1,140 @@
+---
+name: add-shape-inference
+description: Add or update type and shape inference for an ONNX operator. Use when asked to implement TypeAndShapeInferenceFunction, propagate shapes, add shape inference tests, fix shape inference bugs, or handle broadcasting logic.
+---
+
+See also: [docs/ShapeInference.md](../../../docs/ShapeInference.md)
+
+## File Locations
+
+| Component | File |
+|-----------|------|
+| Inference function | `onnx/defs/<domain>/defs.cc` (inline with schema) |
+| Utility functions | `onnx/defs/shape_inference.h` |
+| Tests | `onnx/test/shape_inference_test.py` |
+
+## Type Inference vs. Shape Inference
+
+**Type inference** (element type) is often handled automatically by type constraints. When `"T"` is shared between input and output, the framework infers output type automatically.
+
+However, many existing ops still explicitly call `propagateElemTypeFromInputToOutput` as a best practice for robustness.
+
+Explicit type inference logic is only needed when:
+- Output type is determined by an **attribute** (e.g., `Cast`)
+- Output type differs from all inputs in a way not expressible via type constraints
+- The operator uses **heterogeneous** variadic inputs/outputs
+
+### Homogeneous vs. Heterogeneous
+
+Applies only to variadic (repeated) inputs/outputs:
+- **Homogeneous** (default): All repeated arguments share the same type. Framework propagates automatically.
+- **Heterogeneous**: Each argument can differ. Used by `Loop`/`Scan`. The inference method must explicitly propagate types for each argument.
+
+## Common Patterns
+
+### Unary Element-wise
+
+```cpp
+.TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+```
+
+### Binary with Broadcasting
+
+```cpp
+static void InferShapeForBinaryOp(InferenceContext& ctx) {
+    propagateElemTypeFromInputToOutput(ctx, 0, 0);
+    if (hasNInputShapes(ctx, 2))
+        bidirectionalBroadcastShapeInference(
+            ctx.getInputType(0)->tensor_type().shape(),
+            ctx.getInputType(1)->tensor_type().shape(),
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+}
+```
+
+### Shape-Changing Op
+
+```cpp
+static void InferShapeForTranspose(InferenceContext& ctx) {
+    propagateElemTypeFromInputToOutput(ctx, 0, 0);
+    if (!hasNInputShapes(ctx, 1)) return;
+
+    auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+    int rank = input_shape.dim_size();
+    std::vector<int64_t> perm;
+    getRepeatedAttribute(ctx, "perm", perm);
+
+    auto* output_shape = getOutputShape(ctx, 0);
+    for (int i = 0; i < rank; ++i) {
+        *output_shape->add_dim() = input_shape.dim(perm[i]);
+    }
+}
+```
+
+## Key Utility Functions
+
+| Function | Purpose |
+|----------|---------|
+| `propagateElemTypeFromInputToOutput(ctx, in, out)` | Copy element type |
+| `propagateShapeFromInputToOutput(ctx, in, out)` | Copy entire shape |
+| `propagateShapeAndTypeFromFirstInput(ctx)` | Both type and shape from input 0 |
+| `hasNInputShapes(ctx, n)` | Check first n inputs have shapes |
+| `getOutputShape(ctx, out)` | Get mutable output shape |
+| `bidirectionalBroadcastShapeInference(L, R, out)` | Numpy broadcasting |
+| `getRepeatedAttribute(ctx, "name", vec)` | Get repeated attr values |
+| `getAttribute(ctx, "name", default)` | Get single attr value |
+| `mergeInDimensionInfo(src, dst, dim_idx)` | Merge dimension info |
+| `fail_shape_inference("msg")` | Throw inference error |
+
+## Dimension Arithmetic
+
+```cpp
+Dim operator*(const Dim& a, const Dim& b);
+Dim operator*(const Dim& a, int64_t val);
+Dim operator/(const Dim& a, int64_t divisor);
+Dim multiplyDims(const TensorShapeProto& shape, int from, int upto);
+```
+
+## Writing Tests
+
+The `_make_graph` / `_assert_inferred` helpers are right for parameterized op-version sweeps:
+
+```python
+@pytest.mark.parametrize("version", all_versions_for("OpName"))
+def test_opname(self, version) -> None:
+    graph = self._make_graph(
+        [("X", TensorProto.FLOAT, (2, 3, 4))],
+        [make_node("OpName", ["X"], ["Y"], attr_name=attr_value)],
+        [],
+    )
+    self._assert_inferred(
+        graph,
+        [make_tensor_value_info("Y", TensorProto.FLOAT, expected_shape)],
+        opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+    )
+```
+
+For one-off fixtures — anything with attributes, body subgraphs, or non-trivial type info — prefer the [`onnxtxt`](../onnxtxt/SKILL.md) skill's parser-based fixtures (it also covers the C++ `unk__*` materialization gotcha for free dims).
+
+Cover: known shapes, partial shapes (`None`), rank inference, error cases, broadcasting, attribute-dependent shapes.
+
+## Code Style: Prefer Named Functions
+
+Define inference functions as **separate named functions** rather than inline lambdas. The macro expansion makes breakpoints on inline lambdas unreliable.
+
+Short one-liners (e.g., `propagateShapeAndTypeFromFirstInput`) are fine as direct references.
+
+## Rules for Robust Inference
+
+1. Always check `hasNInputShapes(ctx, n)` before accessing shapes
+2. Always check `has_dim_value()` before using `dim_value()`
+3. Handle unknown dimensions gracefully — leave unset, don't fail
+4. At minimum provide rank inference (correct number of output dims)
+5. Propagate symbolic dimensions (`dim_param`) when possible
+
+## After Making Changes
+
+```bash
+pytest onnx/test/shape_inference_test.py -k "test_opname" -x
+python onnx/defs/gen_doc.py
+lintrunner -a --output oneline
+```
diff --git a/.agents/skills/onnxtxt/SKILL.md b/.agents/skills/onnxtxt/SKILL.md
new file mode 100644
index 0000000..78e569f
--- /dev/null
+++ b/.agents/skills/onnxtxt/SKILL.md
@@ -0,0 +1,121 @@
+---
+name: onnxtxt
+description: Read or write ONNX text format ("onnxtxt"). Use when authoring `.FunctionBody(R"ONNX(...)")` blocks, writing tests with `onnx.parser.parse_model` / `parse_graph`, using the C++ `OnnxParser`, debugging parser errors, or interpreting `Constant <value = ...>` and body-subgraph syntax.
+---
+
+ONNX has a compact text format implemented by `onnx/parser.py` (Python) and `onnx/defs/parser.{h,cc}` (C++). The formal grammar lives in [docs/Syntax.md](../../../docs/Syntax.md); this skill captures the practical conventions, idioms, and gotchas that matter when authoring or reviewing code that uses it.
+
+## Where the format appears
+
+| Surface | API |
+|---|---|
+| C++ function bodies | `.FunctionBody(R"ONNX( ... )ONNX")` and `FunctionBuilder::Add(...)` |
+| Python test fixtures | `onnx.parser.parse_model("...")`, `onnx.parser.parse_graph("...")` |
+| C++ tests | `OnnxParser` in `onnx/defs/parser.h` — parse a model, then call `shape_inference::InferShapes` |
+
+## Core syntax
+
+```
+<var> = <OpName> <attr1 = value, attr2 = value> (<input1>, <input2>)
+```
+
+- Variables on the LHS are local to the surrounding graph (function body, subgraph, or model main graph).
+- Inputs/outputs of a function body must match the names declared in the schema's `.Input(...)` / `.Output(...)`.
+- Constants: `Const = Constant <value = float {0.0}>()` or `Alpha = Constant <value_float: float = @alpha>()`.
+- Use `CastLike` (not `Cast`) when the target dtype depends on another input.
+- Reference enclosing-op attributes with `@attr_name` (only inside function bodies, and only for attributes declared on the schema).
+
+## Argument-order convention
+
+**Simple scalar/tensor attributes** — keep the conventional `Op<attrs>(inputs)` form; reads well on one line:
+
+```
+Y = Transpose<perm = [2, 0, 1]>(X)
+```
+
+**Subgraph attributes** (Scan, Loop, If, ScanVarLen, …) — prefer `Op(inputs)<body = ...>`. The body spans multiple lines, so putting inputs first keeps the call site readable:
+
+```
+so, xo = Scan (s, x) <
+    num_scan_inputs = 1,
+    body = scan_body (float[1] s_in, float[1] x_in) => (float[1] s_out, float[1] x_out) {
+        s_out = Add(s_in, x_in)
+        x_out = Identity(x_in)
+    }
+>
+```
+
+## Testing idioms
+
+| Test file | Recommendation |
+|---|---|
+| `onnx/test/shape_inference_test.py`, `onnx/test/reference_evaluator_test.py` | Use `onnx.parser.parse_model(...)` for one-off fixtures. |
+| `onnx/backend/test/case/node/<op>.py` | Keep the outer `helper.make_node` + `expect(...)` (it drives data generation). For body-subgraph ops, build the body with `onnx.parser.parse_graph`. |
+| `onnx/test/cpp/shape_inference_test.cc` | Use `OnnxParser` (`onnx/defs/parser.h`); pair with `shape_inference::InferShapes`. |
+| `onnx/test/version_converter/automatic_upgrade_test.py` and similar harnesses | Keep the established `_test_op_upgrade` / `_test_op_downgrade` style — do not rewrite. |
+
+Empirical: PR #7962 (ScanVarLen) cut ~58–70% of test LOC by switching to parser-based fixtures.
+
+### Python example — shape inference fixture
+
+```python
+import onnx
+import onnx.parser
+import onnx.shape_inference
+
+model = onnx.parser.parse_model("""
+    <ir_version: 8, opset_import: ["" : 18]>
+    g (float[2, 3, 4] X) => (float[4, 2, 3] Y) {
+        Y = Transpose<perm = [2, 0, 1]>(X)
+    }
+""")
+inferred = onnx.shape_inference.infer_shapes(model, strict_mode=True)
+```
+
+### Python example — body subgraph for a node test
+
+```python
+body = onnx.parser.parse_graph("""
+    b (float[1] s, float[1] xi) => (float[1] so, float[1] xo) {
+        so = Identity(s)
+        xo = Identity(xi)
+    }
+""")
+node = onnx.helper.make_node("Scan", ["s", "x"], ["so", "xo"], body=body, num_scan_inputs=1)
+```
+
+### C++ example — shape inference test
+
+```cpp
+#include "onnx/defs/parser.h"
+#include "onnx/shape_inference/implementation.h"
+
+ModelProto model;
+OnnxParser parser(R"ONNX(
+    <ir_version: 8, opset_import: ["" : 18]>
+    g (float[2, 3, 4] X) => (Y) {
+        Y = Transpose<perm = [2, 0, 1]>(X)
+    }
+)ONNX");
+auto status = parser.Parse(model);
+ASSERT_TRUE(status.IsOK()) << status.ErrorMessage();
+shape_inference::InferShapes(model);
+```
+
+## Gotchas
+
+- **`unk__*` materialization in C++ shape-inference tests.** Under `InferShapes`, unset output dims are materialized by `MaterializeSymbolicShape` into `dim_param` names like `unk__0`, `unk__1`, … Assertions on free dims must accept either an unset dim or an `unk__*` placeholder — write (or use) a helper that treats both forms as equivalent.
+- **Variable-name collisions.** Local variables in a function body must not reuse declared input/output names of the enclosing op.
+- **`@attr_name` scope.** Only valid inside a function body, and only for attributes declared on the enclosing schema's `.Attr(...)` calls.
+- **`CastLike` vs `Cast`.** Use `CastLike` when the desired target dtype is determined by another input; `Cast` requires a static `to` attribute.
+
+## References
+
+| Resource | Path |
+|---|---|
+| Formal grammar | [docs/Syntax.md](../../../docs/Syntax.md) |
+| C++ parser | `onnx/defs/parser.h`, `onnx/defs/parser.cc` |
+| Python parser | `onnx/parser.py` |
+| C++ parser tests | `onnx/test/cpp/parser_test.cc` |
+| Python parser tests | `onnx/test/parser_test.py` |
+| Empirical LOC win | PR #7962 (ScanVarLen test rewrite) |
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..c085b7b
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,94 @@
+---
+Language: Cpp
+BasedOnStyle: Google
+AccessModifierOffset: -1
+AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Left
+AlignOperands:   false
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakStringLiterals: false
+ColumnLimit:     120
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - FOR_EACH_RANGE
+  - FOR_EACH
+  - BOOST_FOREACH
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: true
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+StatementMacros:    [define_data, ONNX_ASSERT, ONNX_ASSERTM, TENSOR_ASSERTM]
+TabWidth:        8
+UseTab:          Never
diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 0000000..ac277c7
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,86 @@
+Checks: >-
+  -*,
+  bugprone-*,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-exception-escape,
+  -bugprone-derived-method-shadowing-base-method,
+  -bugprone-lambda-function-name,
+  -bugprone-narrowing-conversions,
+  -bugprone-reserved-identifier,
+  -bugprone-throwing-static-initialization,
+  clang-diagnostic-*,
+  clang-analyzer-*,
+  cppcoreguidelines-*,
+  -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-avoid-const-or-ref-data-members,
+  -cppcoreguidelines-avoid-do-while,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
+  -cppcoreguidelines-pro-bounds-constant-array-index,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-const-cast,
+  -cppcoreguidelines-pro-type-cstyle-cast,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-use-enum-class,
+  performance-*,
+  -performance-enum-size,
+  google-default-arguments,
+  google-global-names-in-headers,
+  google-explicit-constructor,
+  google-readability-casting,
+  misc-*,
+  -misc-const-correctness,
+  -misc-include-cleaner,
+  -misc-override-with-different-visibility,
+  -misc-no-recursion,
+  -misc-non-private-member-variables-in-classes,
+  -misc-use-anonymous-namespace,
+  modernize-*,
+  -modernize-avoid-c-arrays,
+  -modernize-concat-nested-namespaces,
+  -modernize-pass-by-value,
+  -modernize-return-braced-init-list,
+  -modernize-use-auto,
+  -modernize-use-constraints,
+  -modernize-use-integer-sign-comparison,
+  -modernize-use-ranges,
+  -modernize-use-trailing-return-type,
+  -modernize-use-nodiscard,
+  readability-*,
+  -readability-braces-around-statements,
+  -readability-container-contains,
+  -readability-convert-member-functions-to-static,
+  -readability-else-after-return,
+  -readability-function-cognitive-complexity,
+  -readability-identifier-length,
+  -readability-implicit-bool-conversion,
+  -readability-inconsistent-declaration-parameter-name,
+  -readability-isolate-declaration,
+  -readability-magic-numbers,
+  -readability-math-missing-parentheses,
+  -readability-redundant-access-specifiers,
+  -readability-redundant-typename,
+  -readability-uppercase-literal-suffix,
+  -readability-use-anyofallof,
+
+# Lint ONNX headers; exclude generated *.pb.h, third_party, deps, and hidden build/env dirs.
+HeaderFilterRegex: 'onnx/'
+ExcludeHeaderFilterRegex: '(\.pb\.h$|/third_party/|/_deps/|/\.)'
+
+CheckOptions:
+  # `cppcoreguidelines-special-member-functions` is enabled, refer to https://en.cppreference.com/w/cpp/language/rule_of_three
+  - key:             cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor
+    value:           True
+  - key:             performance-move-const-arg.CheckTriviallyCopyableMove
+    value:           False
+  - key:             cppcoreguidelines-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted
+    value:           True
+  - key:             modernize-use-scoped-lock.WarnOnSingleLocks
+    value:           False
diff --git a/.claude/instructions/add-function-body.md b/.claude/instructions/add-function-body.md
new file mode 100644
index 0000000..f02c3de
--- /dev/null
+++ b/.claude/instructions/add-function-body.md
@@ -0,0 +1,13 @@
+# Adding a Function Body Definition for an Operator
+
+Canonical guide: [`.agents/skills/add-function-body/SKILL.md`](../../.agents/skills/add-function-body/SKILL.md). Background: [`docs/AddFunctionBody.md`](../../docs/AddFunctionBody.md). For the ONNX text format itself (syntax, `Constant <value = ...>`, body subgraphs, `@attr_name`, parser tests), see [`.agents/skills/onnxtxt/SKILL.md`](../../.agents/skills/onnxtxt/SKILL.md).
+
+## Workflow-specific reminders
+
+- Function body lives inline in the schema in `onnx/defs/<domain>/defs.cc` via `.FunctionBody(R"ONNX(...)")` (simple) or `.SetContextDependentFunctionBodyBuilder(...)` (context-dependent).
+- For context-dependent builders, always finalize with `schema.BuildFunction(functionProto)` and `return true`.
+- The body must produce all declared outputs. Variable names must not collide with declared input/output names. Use `CastLike` (not `Cast`) when the target dtype depends on another input. Reference enclosing-op attributes with `@attr_name` — only for attributes declared in `.Attr(...)` calls.
+- Prefer named `static bool` builder functions over inline lambdas (macro expansion breaks debugger breakpoints). Simple string-based `.FunctionBody(R"ONNX(...)")` is fine as-is.
+
+General build/lint/DCO/copyright conventions live in [`CLAUDE.md`](../../CLAUDE.md).
+
diff --git a/.claude/instructions/add-op.md b/.claude/instructions/add-op.md
new file mode 100644
index 0000000..8af3354
--- /dev/null
+++ b/.claude/instructions/add-op.md
@@ -0,0 +1,12 @@
+# Adding or Updating an ONNX Operator
+
+Canonical guide: [`.agents/skills/add-op/SKILL.md`](../../.agents/skills/add-op/SKILL.md). Full procedure: [`docs/AddNewOp.md`](../../docs/AddNewOp.md). For tests using the ONNX text format / `onnx.parser`, see [`.agents/skills/onnxtxt/SKILL.md`](../../.agents/skills/onnxtxt/SKILL.md).
+
+## Workflow-specific reminders
+
+- Schema definition lives in `onnx/defs/<domain>/defs.cc`; register in `onnx/defs/operator_sets.h`.
+- Updating an op: move the old schema to `<domain>/old.cc` *before* adding the new version. Add a version-converter adapter in `onnx/version_converter/adapters/<name>_<from>_<to>.h` if behavior changed, plus upgrade/downgrade tests.
+- After schema changes regenerate docs: `python onnx/defs/gen_doc.py && python onnx/backend/test/stat_coverage.py`. Do not edit `docs/Operators.md` / `docs/Changelog.md` directly.
+
+General build/lint/DCO/copyright conventions live in [`CLAUDE.md`](../../CLAUDE.md).
+
diff --git a/.claude/instructions/add-shape-inference.md b/.claude/instructions/add-shape-inference.md
new file mode 100644
index 0000000..56e939d
--- /dev/null
+++ b/.claude/instructions/add-shape-inference.md
@@ -0,0 +1,14 @@
+# Adding Type and Shape Inference for an Operator
+
+Canonical guide: [`.agents/skills/add-shape-inference/SKILL.md`](../../.agents/skills/add-shape-inference/SKILL.md). Background: [`docs/ShapeInference.md`](../../docs/ShapeInference.md). For test fixtures using `onnx.parser`, see [`.agents/skills/onnxtxt/SKILL.md`](../../.agents/skills/onnxtxt/SKILL.md) (also covers the C++ `unk__*` materialization gotcha for free dims).
+
+## Workflow-specific reminders
+
+- Inference function is inline in the schema via `.TypeAndShapeInferenceFunction(...)` in `onnx/defs/<domain>/defs.cc`. Utility helpers live in `onnx/defs/shape_inference.h`.
+- Always check `hasNInputShapes(ctx, n)` before accessing shapes and `has_dim_value()` before reading dim values. Leave unknown dims unset rather than failing.
+- At minimum, provide rank inference; propagate symbolic dimensions (`dim_param`) when possible.
+- Prefer named `static` inference functions over inline lambdas in `ONNX_OPERATOR_SET_SCHEMA` (macro expansion breaks debugger breakpoints).
+- Tests: `onnx/test/shape_inference_test.py`. The `_make_graph` / `_assert_inferred` helpers fit parameterized op-version sweeps; for one-off fixtures prefer `onnx.parser.parse_model`.
+
+General build/lint/DCO/copyright conventions live in [`CLAUDE.md`](../../CLAUDE.md).
+
diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..16df8da
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,7 @@
+root = true
+
+[*]
+
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 0000000..5af302e
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,8 @@
+# Python clean up #3982
+35092895d9bf3592e58f4710d098f8131afef259
+# Apply clang-format #4084
+a525f98d5ed31660b629bab90c680a39658a5c08
+# Upgrade python syntax with pyupgrade #4212
+529f7cab88eed143fc9f0126147e9732585e4c5e
+# Format all python code with black and isort #4427
+fddb2b6d4ea3fb3dba751d884865042503260899
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..255168e
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,7 @@
+# Set the default behavior
+* text=auto eol=auto
+*.bat text eol=crlf
+# Shell scripts must keep LF endings on all platforms; a CRLF checkout breaks
+# shellcheck (SC1017) and execution under Unix shells.
+*.sh text eol=lf
+*.pb -linguist-detectable
diff --git a/.github/ISSUE_TEMPLATE/bug.md b/.github/ISSUE_TEMPLATE/bug.md
new file mode 100644
index 0000000..b35b41f
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug.md
@@ -0,0 +1,42 @@
+---
+name: Bug report
+about: Create a bug report to help improve the ONNX.
+title: ''
+labels: 'bug'
+assignees: ''
+
+---
+# Bug Report
+
+### Is the issue related to model conversion?
+<!-- If the ONNX checker reports issues with this model then this is most probably related to the converter used to convert the original framework model to ONNX. Please create this bug in the appropriate converter's GitHub repo (pytorch, tensorflow-onnx, sklearn-onnx, keras-onnx, onnxmltools) to get the best help. -->
+
+### Describe the bug
+<!-- Please describe the bug clearly and concisely -->
+
+### System information
+<!--
+- OS Platform and Distribution (*e.g. Linux Ubuntu 20.04*):
+- ONNX version (*e.g. 1.13*):
+- Python version:
+- GCC/Compiler version (if compiling from source):
+- CMake version:
+- Protobuf version:
+- Visual Studio version (if applicable):-->
+
+
+### Reproduction instructions
+<!--
+- Describe the code to reproduce the behavior.
+```
+import onnx
+model = onnx.load('model.onnx')
+...
+```
+- Attach the ONNX model to the issue (where applicable)-->
+
+### Expected behavior
+<!-- A clear and concise description of what you expected to happen. -->
+
+### Notes
+<!-- Any additional information -->
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000..8a5e0c8
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,14 @@
+blank_issues_enabled: true
+contact_links:
+  - name: ONNX Runtime Issues
+    url: https://github.com/microsoft/onnxruntime/issues
+    about: issues/questions related to ONNX Runtime
+  - name: ONNX Model Zoo Issues
+    url: https://github.com/onnx/models/issues
+    about: issues/questions related to ONNX Model Zoo
+  - name: PyTorch-ONNX exporters Issues
+    url: https://github.com/pytorch/pytorch/issues
+    about: issues/questions related to PyTorch-ONNX exporters (torch.onnx.export)
+  - name: TensorFlow Converter Issues
+    url: https://github.com/onnx/tensorflow-onnx
+    about: issues/questions converting TensorFlow models to ONNX (tf2onnx)
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
new file mode 100644
index 0000000..e943212
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -0,0 +1,71 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Feature request
+description: Create a feature request for a functionality that does not currently exist in the ONNX.
+title: "[Feature request] "
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: Thanks for taking the time to create a feature request!
+  - type: textarea
+    id: system-info
+    attributes:
+      label: System information
+      description: "ONNX version (you are using):"
+    validations:
+      required: false
+  - type: textarea
+    id: solves-problem
+    attributes:
+      label: What is the problem that this feature solves?
+      description: Please detail the discrepancy with our current functionality.
+    validations:
+      required: false
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Alternatives considered
+      description: Describe the alternatives you have considered
+      placeholder: A clear and concise description of any alternative solutions or features you've considered.
+    validations:
+      required: false
+  - type: textarea
+    id: feature
+    attributes:
+      label: Describe the feature
+      description: Why is this feature necessary? What does it accomplish?
+    validations:
+      required: false
+  - type: textarea
+    id: api-impact
+    attributes:
+      label: Will this influence the current api (Y/N)?
+      placeholder: If yes, how?
+    validations:
+      required: false
+  - type: textarea
+    id: feature-area
+    attributes:
+      label: Feature Area
+      description: Which area in ONNX does this impact?  e.g., model usage, backend, best practices, converters, shape_inference, version_converter, training, test, operators, IR, ONNX Hub, data preprocessing, CI pipelines.
+    validations:
+      required: false
+  - type: dropdown
+    id: contribute
+    attributes:
+      label: "Are you willing to contribute it (Y/N)"
+      options:
+        - "Yes"
+        - "No"
+    validations:
+      required: false
+  - type: textarea
+    id: notes
+    attributes:
+      label: Notes
+      description: Any additional information
+    validations:
+      required: false
diff --git a/.github/ISSUE_TEMPLATE/operator.md b/.github/ISSUE_TEMPLATE/operator.md
new file mode 100644
index 0000000..968a2be
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/operator.md
@@ -0,0 +1,24 @@
+---
+name: New Operator
+about: Create a new operator that does not currently exist in the ONNX.
+title: ''
+labels: 'operator'
+assignees: ''
+
+
+
+---
+# New Operator
+
+### Describe the operator
+<!-- Why is this operator necessary? What does it accomplish? -->
+
+### Can this operator be constructed using existing onnx operators?
+<!-- If so, why not add it as a function? -->
+
+### Is this operator used by any model currently? Which one?
+
+### Are you willing to contribute it? (Y/N)
+
+### Notes
+<!-- Any additional information -->
diff --git a/.github/ISSUE_TEMPLATE/question.md b/.github/ISSUE_TEMPLATE/question.md
new file mode 100644
index 0000000..186afc8
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/question.md
@@ -0,0 +1,24 @@
+---
+name: Question
+about: Ask a question about the ONNX.
+title: ''
+labels: 'question'
+assignees: ''
+
+
+
+---
+# Ask a Question
+
+### Question
+<!-- Explain your question here. -->
+
+### Further information
+- Relevant Area: <!--e.g., model usage, backend, best practices, converters, shape_inference, version_converter, training, test, operators, IR, ONNX Hub, data preprocessing, CI pipelines. -->
+
+- Is this issue related to a specific model?
+**Model name**: <!-- *e.g. mnist* -->
+**Model opset**: <!-- *e.g. 17* -->
+
+### Notes
+<!-- Any additional information, code snippets. -->
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000..5bafbfd
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,17 @@
+We use lintrunner as the linter:
+
+```sh
+# Display all lints and apply the fixes
+lintrunner -a --output oneline
+# Or apply fixes only (faster)
+lintrunner f --output oneline
+```
+
+To build ONNX:
+
+```sh
+python -m pip install --quiet --upgrade pip setuptools wheel
+export ONNX_BUILD_TESTS=0
+export ONNX_ML=1
+python -m pip install .
+```
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..c634e4c
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,40 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "pip" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "monthly"
+    cooldown:
+      default-days: 7
+    ignore:
+      # Only update them manually since updating them might break compatibility
+      - dependency-name: "numpy"
+      - dependency-name: "protobuf"
+      - dependency-name: "typing_extensions"
+      - dependency-name: "ml_dtypes"
+    open-pull-requests-limit: 10
+    labels:
+      - "python"
+      - "run release CIs"
+
+  - package-ecosystem: "github-actions"
+    # Workflow files stored in the
+    # default location of `.github/workflows`
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    cooldown:
+      default-days: 7
+    open-pull-requests-limit: 20
+    labels:
+      - "github_actions"
+      - "run release CIs"
diff --git a/.github/install_test.yml b/.github/install_test.yml
new file mode 100644
index 0000000..27241db
--- /dev/null
+++ b/.github/install_test.yml
@@ -0,0 +1,44 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Test (pip install -e .)
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  test-install:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-24.04]
+        python-version: ['3.13']
+      fail-fast: false
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies, build ONNX
+        run: |
+          python -m pip install -q --upgrade pip
+          python -m pip install scikit-build-core "protobuf==4.25.1"
+          pip install -e .
+
diff --git a/.github/instructions/onnx-defs.instructions.md b/.github/instructions/onnx-defs.instructions.md
new file mode 100644
index 0000000..b049a1e
--- /dev/null
+++ b/.github/instructions/onnx-defs.instructions.md
@@ -0,0 +1,28 @@
+---
+applyTo: "onnx/defs/**"
+---
+
+# ONNX `onnx/defs/` Quick Reference
+
+When working in `onnx/defs/**`, follow the relevant agent skill — these contain the full, canonical guidance:
+
+| Task | Skill |
+|---|---|
+| Add a new op or bump an opset | [`.agents/skills/add-op/SKILL.md`](../../.agents/skills/add-op/SKILL.md) |
+| Implement type/shape inference | [`.agents/skills/add-shape-inference/SKILL.md`](../../.agents/skills/add-shape-inference/SKILL.md) |
+| Add a function body decomposition | [`.agents/skills/add-function-body/SKILL.md`](../../.agents/skills/add-function-body/SKILL.md) |
+| Write or interpret ONNX text format / `.FunctionBody(R"ONNX(...)")` / `onnx.parser.parse_model` | [`.agents/skills/onnxtxt/SKILL.md`](../../.agents/skills/onnxtxt/SKILL.md) |
+
+## Critical reminders (apply to all `onnx/defs/` work)
+
+- **Do not edit generated files** directly: `docs/Operators.md`, `docs/Changelog.md`, `docs/TestCoverage.md`, `*_pb2.py`, `onnx-*.in.proto`-derived `.proto` files. Edit the source, then regenerate.
+- **After schema changes:** `python onnx/defs/gen_doc.py && python onnx/backend/test/stat_coverage.py`.
+- **After proto changes:** `python onnx/gen_proto.py` (edit the `.in.proto` files, not the `.proto` files).
+- **Lint before pushing:** `lintrunner -a --output oneline`.
+- **DCO sign-off** on every commit: `git commit -s`.
+- **New Python files** need `from __future__ import annotations` and the standard copyright header (`# Copyright (c) ONNX Project Contributors` + `# SPDX-License-Identifier: Apache-2.0`).
+- **Updating an op:** move the old schema to `<domain>/old.cc` before adding the new version to `defs.cc`; update `onnx/defs/operator_sets.h`; add upgrade/downgrade tests.
+- **Prefer named functions** over inline lambdas in `ONNX_OPERATOR_SET_SCHEMA` (macro expansion makes breakpoints on lambdas unreliable).
+- **Context-dependent function bodies:** always finalize the builder with `schema.BuildFunction(functionProto)` and `return true`.
+
+For the full procedures (file locations, registration patterns, common idioms, test recipes), open the skills above.
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 0000000..3123b55
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,5 @@
+
+
+### Motivation and Context
+
+Fixes #
diff --git a/.github/release.yml b/.github/release.yml
new file mode 100644
index 0000000..ad3de36
--- /dev/null
+++ b/.github/release.yml
@@ -0,0 +1,43 @@
+changelog:
+  exclude:
+    authors:
+      - dependabot
+  categories:
+    - title: Breaking Changes and Deprecations
+      labels:
+        - "topic: bc breaking"
+        - "topic: deprecation"
+    - title: Spec and Operator
+      labels:
+        - "module: spec"
+        - "topic: spec clarification"
+        - "topic: operator"
+        - "module: schema"
+    - title: Reference Implementation
+      labels:
+        - "module: reference implementation"
+    - title: Utilities and Tools
+      labels:
+        - "module: checker"
+        - "module: parser"
+        - "module: inliner"
+        - "module: utility"
+        - "module: optimizer"
+        - "module: version converter"
+        - "module: shape inference"
+        - "topic: partial data propagation"
+    - title: ONNX Hub
+      labels:
+        - "module: hub"
+    - title: Build, CI and Tests
+      labels:
+        - "topic: build"
+        - "module: CI pipelines"
+        - "topic: test"
+        - "topic: compiler warning"
+    - title: Documentation
+      labels:
+        - "topic: documentation"
+    - title: Other Changes
+      labels:
+        - "*"
diff --git a/.github/workflows/check_pr_label.yml b/.github/workflows/check_pr_label.yml
new file mode 100644
index 0000000..3ad545e
--- /dev/null
+++ b/.github/workflows/check_pr_label.yml
@@ -0,0 +1,43 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Require topic/module label (prefix-only)
+
+on:
+  pull_request:
+    types: [opened, labeled, unlabeled, synchronize, reopened, ready_for_review]
+
+permissions:
+  contents: read
+  pull-requests: read
+  actions: read
+
+jobs:
+  check-label:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Ensure PR has topic/module label
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          script: |
+            const author = context.payload.pull_request.user.login;
+            const prLabels = context.payload.pull_request.labels.map(l => l.name);
+
+            if (author === "dependabot[bot]") {
+              core.info("Skipping check for dependabot");
+              return;
+            }
+
+            if (prLabels.length === 0) {
+              core.setFailed("❌ Add at least one label (topic:/module:).");
+              return;
+            }
+
+            const hasRequired = prLabels.some(l => l.startsWith("topic:") || l.startsWith("module:"));
+
+            if (!hasRequired) {
+              core.setFailed("❌ Add a 'topic:' or 'module:' label.");
+            } else {
+              core.info("✅ Label check passed");
+            }
diff --git a/.github/workflows/check_urls.yml b/.github/workflows/check_urls.yml
new file mode 100644
index 0000000..ead7ff6
--- /dev/null
+++ b/.github/workflows/check_urls.yml
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Check URLs
+
+on:
+  push:
+    branches:  [ "main", rel-* ]
+  pull_request:
+    paths:
+      - "**/*.md"
+      - ".github/workflows/check_urls.yml"
+  schedule:
+    # Run every month
+    - cron:  '0 0 1 * *'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      with:
+        persist-credentials: false
+    - name: Set up pixi
+      uses: prefix-dev/setup-pixi@5185adfbffb4bd703da3010310260805d89ebb11 # v0.9.6
+      with:
+        environments: link-checker
+
+    - name: Restore lychee cache
+      id: restore-cache
+      uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+      with:
+        path: .lycheecache
+        # We don't hit the 'key' directly in subsequent
+        # commits. Instead we fall back to the latest 'restore-key'
+        # match and will store a new cached file when done.
+        key: cache-lychee-${{ github.sha }}
+        restore-keys: cache-lychee-
+
+    - name: Check links
+      run: pixi run -e link-checker lychee --root-dir . --cache-exclude-status=400..599 --cache .
diff --git a/.github/workflows/clang-tidy.yml b/.github/workflows/clang-tidy.yml
new file mode 100644
index 0000000..9e6f2a3
--- /dev/null
+++ b/.github/workflows/clang-tidy.yml
@@ -0,0 +1,40 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: clang-tidy
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  clang-tidy:
+    name: clang-tidy
+    runs-on: ubuntu-24.04-arm
+    strategy:
+      fail-fast: false
+    steps:
+      - name: Checkout branch
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          submodules: recursive
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Set up pixi
+        uses: prefix-dev/setup-pixi@5185adfbffb4bd703da3010310260805d89ebb11 # v0.9.6
+        with:
+          environments: default clang-tools
+      - name: Install repository
+        run: pixi run install
+      - name: Run clang-tidy
+        run: pixi run run-clang-tidy
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 0000000..0c67efc
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,88 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "main" ]
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  pull_request:
+    branches: [ "main" ]
+    paths-ignore:
+      - 'docs/**'
+      - '**/*.md'
+  schedule:
+    - cron: '33 6 * * 5'
+  workflow_dispatch:
+
+permissions:  # set top-level default permissions as security best practice
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name == 'workflow_dispatch' }}
+  cancel-in-progress: true
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'actions', 'cpp', 'python' ]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      with:
+        submodules: recursive
+        persist-credentials: false
+
+    - name: Set up Python
+      if: matrix.language != 'actions'
+      uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+      with:
+        python-version: '3.11'
+
+    - name: Upgrade pip
+      if: matrix.language != 'actions'
+      run: python -m pip install --upgrade pip
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+      with:
+        languages: ${{ matrix.language }}
+        config: |
+          queries:
+            - uses: security-extended
+            - uses: security-and-quality
+          paths-ignore:
+            - '.setuptools-cmake-build/**'
+            - 'build/**'
+            - 'onnx/**/*_pb2.py'
+            - 'onnx/**/*_pb2.pyi'
+            - '**/*.pb.cc'
+            - '**/*.pb.h'
+            - 'onnx/backend/test/data/**'
+          query-filters:
+            - exclude:
+                id: py/import-and-import-from
+
+    # Install onnx so that it is found by the linters
+    - name: Install ONNX
+      if: matrix.language != 'actions'
+      run: |
+        export ONNX_ML=1
+        export ONNX_BUILD_TESTS=1
+        pip install .
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
+      with:
+        category: "/language:${{matrix.language}}"
diff --git a/.github/workflows/copilot-setup-steps.yml b/.github/workflows/copilot-setup-steps.yml
new file mode 100644
index 0000000..8e298fc
--- /dev/null
+++ b/.github/workflows/copilot-setup-steps.yml
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: "Copilot Setup Steps"
+
+# Automatically run the setup steps when they are changed to allow for easy validation, and
+# allow manual testing through the repository's "Actions" tab
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+  pull_request:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+
+permissions:
+  contents: read
+
+jobs:
+  # The job MUST be called `copilot-setup-steps` or it will not be picked up by Copilot.
+  copilot-setup-steps:
+    runs-on: ubuntu-latest
+
+    # Set the permissions to the lowest permissions possible needed for your steps.
+    # Copilot will be given its own token for its operations.
+    permissions:
+      # If you want to clone the repository as part of your setup steps, for example to install dependencies, you'll need the `contents: read` permission. If you don't clone the repository in your setup steps, Copilot will do this for you automatically after the steps complete.
+      contents: read
+    # You can define any steps you want, and they will run before the agent starts.
+    # If you do not check out your code, Copilot will do this for you.
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Setup Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: "3.13"
+      - name: Install dependencies
+        run: |
+          python -m pip install lintrunner>=0.10.7
+          python -m pip install -r requirements-release_test.txt
+          python -m pip install -r requirements-lintrunner.txt
+          lintrunner init
diff --git a/.github/workflows/create_release.yml b/.github/workflows/create_release.yml
new file mode 100644
index 0000000..ef5b909
--- /dev/null
+++ b/.github/workflows/create_release.yml
@@ -0,0 +1,437 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Create Releases
+on:
+  schedule:
+    # Run weekly on Monday 00:00 UTC
+    - cron:  '0 0 * * MON'
+
+  push:
+    branches: [main, rel-*]
+  pull_request:
+    branches: [main, rel-*]
+    types:
+      - labeled
+      - synchronize
+  workflow_dispatch:
+    inputs:
+      publish_pypi_weekly: # only from main branch it is possible to publish to pypi-weekly (official weekly preview build)
+        description: 'Publish to pypi-weekly'
+        required: true
+        type: choice
+        options:
+          - 'yes'
+          - 'no'
+        default: 'no'
+      publish_testpypi_weekly: # only from main branch it is possible to publish to testpypi-weekly
+        description: 'Publish to testpypi-weekly'
+        required: true
+        type: choice
+        options:
+          - 'yes'
+          - 'no'
+        default: 'no'
+      publish_testpypi_release: # only from rel branch it is possible to publish to test-pypi (for rc1, rc2, etc.)
+        description: 'Publish to testpypi-release'
+        required: true
+        type: choice
+        options:
+          - 'yes'
+          - 'no'
+        default: 'no'
+      publish_pypi_release:
+        description: 'Caution: Publish to pypi-release'
+        required: true
+        type: choice
+        options:
+          - 'yes'
+          - 'no'
+        default: 'no'
+      build_mode:
+        description: 'Specify the build mode (release or preview)'
+        required: true
+        type: choice
+        options:
+          - 'release'
+          - 'preview'
+        default: 'preview'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name == 'workflow_dispatch' }}
+  cancel-in-progress: true
+
+jobs:
+
+  call-linux:
+    if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'run release CIs') || contains(github.event.pull_request.labels.*.name, 'ci-slsa-provenance')
+    uses: ./.github/workflows/release_linux_cibw.yml
+    with:
+      build_mode: ${{ github.event.inputs.build_mode || 'preview' }}
+
+  call-win:
+    if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'run release CIs') || contains(github.event.pull_request.labels.*.name, 'ci-slsa-provenance')
+    uses: ./.github/workflows/release_windows_cibw.yml
+    with:
+      build_mode: ${{ github.event.inputs.build_mode || 'preview' }}
+
+  call-mac:
+    if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'run release CIs') || contains(github.event.pull_request.labels.*.name, 'ci-slsa-provenance')
+    uses: ./.github/workflows/release_macos_cibw.yml
+    with:
+      build_mode: ${{ github.event.inputs.build_mode || 'preview' }}
+
+  call-pyodide:
+    if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'run release CIs') || contains(github.event.pull_request.labels.*.name, 'ci-slsa-provenance')
+    uses: ./.github/workflows/release_pyodide_cibw.yml
+    with:
+      build_mode: ${{ github.event.inputs.build_mode || 'preview' }}
+
+  call-sdist:
+    if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'run release CIs') || contains(github.event.pull_request.labels.*.name, 'ci-slsa-provenance')
+    uses: ./.github/workflows/release_sdist.yml
+    with:
+      os: "macos"
+      build_mode: ${{ github.event.inputs.build_mode || 'preview' }}
+
+  attest_ci_build_artifacts:
+    name: Attest CI build artifacts
+    runs-on: ubuntu-latest
+    needs: [call-linux, call-mac, call-win, call-pyodide, call-sdist]
+    if: >-
+      (!contains(join(needs.*.result, ' '), 'skipped')) &&
+      (github.repository_owner == 'onnx') &&
+      (
+        (github.event_name == 'push') ||
+        (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'ci-slsa-provenance')) ||
+        (
+          (github.event_name == 'workflow_dispatch') &&
+          (github.event.inputs.publish_pypi_weekly != 'yes') &&
+          (github.event.inputs.publish_testpypi_weekly != 'yes') &&
+          (github.event.inputs.publish_testpypi_release != 'yes') &&
+          (github.event.inputs.publish_pypi_release != 'yes')
+        )
+      )
+
+    permissions:
+      contents: read
+      id-token: write
+      attestations: write
+
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+        with:
+          pattern: wheels*
+          path: dist
+          merge-multiple: true
+
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+        with:
+          pattern: sdist
+          path: dist
+          merge-multiple: true
+
+      - name: Generate SLSA Build Provenance attestations
+        if: hashFiles('dist/**') != ''
+        id: attest
+        uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
+        with:
+          subject-path: dist/**
+
+      - name: Upload attestation bundle
+        if: hashFiles('dist/**') != ''
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: attestation-bundle-ci
+          path: ${{ steps.attest.outputs.bundle-path }}
+
+  check_for_publish_release_build_to_pypi:
+    name: Check for Publish release build to pypi
+    runs-on: ubuntu-latest
+
+    needs: [call-linux, call-mac, call-win, call-pyodide, call-sdist]
+    if: (!contains(join(needs.*.result, ' '), 'skipped')) && (github.event.inputs.publish_pypi_release == 'yes') && (github.repository_owner == 'onnx') && startsWith(github.ref, 'refs/heads/rel-') && (github.event_name == 'workflow_dispatch')
+
+    steps:
+
+      - name: Ensure build mode is release
+        run: |
+          if [ "$BUILD_MODE" != "release" ]; then
+            echo "Error: build_mode must be set to 'release' to proceed."
+            exit 1
+          fi
+        env:
+          BUILD_MODE: ${{ github.event.inputs.build_mode }}
+
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+          submodules: true
+
+      - name: Check if package_version matches branch
+        run: |
+          branch_version=${GITHUB_REF#refs/heads/rel-}
+          package_version=$(cat VERSION_NUMBER)
+          echo "Branch version: $branch_version"
+          echo "Package version: $package_version"
+
+          if [[ "$package_version" != "$branch_version" && "$package_version" != "$branch_version"rc* ]]; then
+            echo "Error: Package version ($package_version) does not match branch version ($branch_version) or expected RC format."
+            exit 1
+          fi
+
+  check_for_publish_preview_build_to_testpypi_weekly:
+    name: Check for Publish preview build to test.pypi-weekly
+    runs-on: ubuntu-latest
+
+    needs: [call-linux, call-mac, call-win, call-pyodide, call-sdist]
+    if: (!contains(join(needs.*.result, ' '), 'skipped')) && (github.event.inputs.publish_testpypi_weekly == 'yes') && (github.ref == 'refs/heads/main') && (github.repository_owner == 'onnx') && (github.event_name == 'workflow_dispatch')
+
+    steps:
+      - name: Confirm preview publish request
+        run: echo "Proceeding with test.pypi-weekly publish checks."
+
+
+  publish_preview_build_to_testpypi_weekly:
+    name: Publish preview build to test.pypi-weekly
+    runs-on: ubuntu-latest
+    needs: [check_for_publish_preview_build_to_testpypi_weekly]
+
+    environment:
+      name: testpypi-weekly
+      url: https://test.pypi.org/p/onnx-weekly
+
+    permissions:
+      contents: read
+      id-token: write
+      attestations: write
+
+    steps:
+
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+        if: (github.event_name == 'workflow_dispatch' )
+        with:
+          pattern: wheels*
+          path: dist
+          merge-multiple: true
+
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+        if: (github.event_name == 'workflow_dispatch' )
+        with:
+          pattern: sdist
+          path: dist
+          merge-multiple: true
+
+      - name: Generate SLSA Build Provenance attestations
+        if: hashFiles('dist/**') != ''
+        id: attest
+        uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
+        with:
+          subject-path: dist/**
+
+      - name: Upload attestation bundle
+        if: hashFiles('dist/**') != ''
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: attestation-bundle-testpypi-weekly
+          path: ${{ steps.attest.outputs.bundle-path }}
+
+      - name: Upload preview build to test.pypi
+        if: (github.ref == 'refs/heads/main') && (github.event.inputs.publish_testpypi_weekly == 'yes') && (github.repository_owner == 'onnx')
+        id: upload_preview_build_to_testpypi_weekly
+
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          verbose: true
+          print-hash: true
+
+  check_for_publish_release_build_to_testpypi:
+    name: Check for Publish release build to test.pypi (rc-candidates)
+    runs-on: ubuntu-latest
+
+    needs: [call-linux, call-mac, call-win, call-pyodide, call-sdist]
+    if: (!contains(join(needs.*.result, ' '), 'skipped')) && (github.event.inputs.publish_testpypi_release == 'yes') && startsWith(github.ref, 'refs/heads/rel') && (github.repository_owner == 'onnx') && (github.event_name == 'workflow_dispatch')
+
+    steps:
+      - name: Confirm release publish request
+        run: echo "Proceeding with test.pypi release publish checks."
+
+  publish_release_build_to_testpypi:
+      name: Publish release build to test.pypi
+      runs-on: ubuntu-latest
+      needs: [check_for_publish_release_build_to_testpypi]
+
+      environment:
+        name: testpypi-release
+        url: https://test.pypi.org/p/onnx
+
+      permissions:
+        contents: read
+        id-token: write
+        attestations: write
+
+      steps:
+
+        - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+          if: (github.event_name == 'workflow_dispatch' )
+          with:
+            pattern: wheels*
+            path: dist
+            merge-multiple: true
+
+        - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+          if: (github.event_name == 'workflow_dispatch' )
+          with:
+            pattern: sdist
+            path: dist
+            merge-multiple: true
+
+        - name: Generate SLSA Build Provenance attestations
+          if: hashFiles('dist/**') != ''
+          id: attest
+          uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
+          with:
+            subject-path: dist/**
+
+        - name: Upload attestation bundle
+          if: hashFiles('dist/**') != ''
+          uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+          with:
+            name: attestation-bundle-testpypi-release
+            path: ${{ steps.attest.outputs.bundle-path }}
+
+        - name: Upload release build to test.pypi
+          id: upload_release_build_to_testpypi
+
+          uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b
+          with:
+            repository-url: https://test.pypi.org/legacy/
+            verbose: true
+            print-hash: true
+
+
+  check_for_publish_preview_build_to_pypi_weekly:
+    name: Check for Publish preview build to pypi-weekly
+    runs-on: ubuntu-latest
+
+    needs: [call-linux, call-mac, call-win, call-pyodide, call-sdist]
+    if: (!contains(join(needs.*.result, ' '), 'skipped')) && (github.event_name == 'schedule' || github.event.inputs.publish_pypi_weekly == 'yes') && (github.repository_owner == 'onnx')
+
+    steps:
+      - name: Confirm weekly publish request
+        run: echo "Proceeding with pypi-weekly publish checks."
+
+  publish_preview_build_to_pypi_weekly:
+    name: Publish preview build to pypi-weekly
+    runs-on: ubuntu-latest
+    needs: [check_for_publish_preview_build_to_pypi_weekly]
+
+    environment:
+      name: pypi-weekly
+      url: https://pypi.org/p/onnx-weekly
+
+    permissions:
+      contents: read
+      id-token: write
+      attestations: write
+
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+        if: (github.event_name == 'schedule' || github.event_name == 'workflow_dispatch')
+        with:
+          pattern: wheels*
+          path: dist
+          merge-multiple: true
+
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+        if: (github.event_name == 'schedule' || github.event_name == 'workflow_dispatch')
+        with:
+          pattern: sdist
+          path: dist
+          merge-multiple: true
+
+      - name: Generate SLSA Build Provenance attestations
+        if: hashFiles('dist/**') != ''
+        id: attest
+        uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
+        with:
+          subject-path: dist/**
+
+      - name: Upload attestation bundle
+        if: hashFiles('dist/**') != ''
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: attestation-bundle-weekly
+          path: ${{ steps.attest.outputs.bundle-path }}
+
+      - name: Upload preview_build to pypi-weekly
+        id: upload_preview_build_to_pypi_weekly
+        if: (github.ref == 'refs/heads/main')
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b
+        with:
+          repository-url: https://upload.pypi.org/legacy/
+          verbose: true
+          print-hash: true
+
+
+  publish_release_build_to_pypi:
+    name: Publish release build to pypi
+    runs-on: ubuntu-latest
+    needs: [check_for_publish_release_build_to_pypi]
+
+    environment:
+      name: pypi-release
+      url: https://pypi.org/p/onnx
+
+    permissions:
+      contents: read
+      id-token: write
+      attestations: write
+
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+        if: (github.event_name == 'workflow_dispatch')
+        with:
+          pattern: wheels*
+          path: dist
+          merge-multiple: true
+
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c
+        if: (github.event_name == 'workflow_dispatch')
+        with:
+          pattern: sdist
+          path: dist
+          merge-multiple: true
+
+      - name: Generate SLSA Build Provenance attestations
+        if: hashFiles('dist/**') != ''
+        id: attest
+        uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
+        with:
+          subject-path: dist/**
+
+      - name: Upload attestation bundle
+        if: hashFiles('dist/**') != ''
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: attestation-bundle-release
+          path: ${{ steps.attest.outputs.bundle-path }}
+
+      - name: Publish release_build to pypi
+        if: (github.repository_owner == 'onnx')
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b
+        with:
+          repository-url: https://upload.pypi.org/legacy/
+          verbose: true
+          print-hash: true
+
+  test_source_dist:
+    name: test source distribution
+    needs: [publish_preview_build_to_pypi_weekly, publish_release_build_to_testpypi]
+    if: (needs.publish_preview_build_to_pypi_weekly.result == 'success' || needs.publish_release_build_to_testpypi.result == 'success')
+    uses: ./.github/workflows/preview_source_dist_test.yml
diff --git a/.github/workflows/dco_merge_group.yml b/.github/workflows/dco_merge_group.yml
new file mode 100644
index 0000000..9719eca
--- /dev/null
+++ b/.github/workflows/dco_merge_group.yml
@@ -0,0 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: DCO
+on:
+  merge_group:
+
+permissions:  # set top-level default permissions as security best practice
+  contents: read # Check https://github.com/ossf/scorecard/blob/7ce8609469289d5f3b1bf5ee3122f42b4e3054fb/docs/checks.md#token-permissions
+
+jobs:
+  DCO:
+    runs-on: ubuntu-latest
+    if: ${{ github.actor != 'dependabot[bot]' }}
+    steps:
+      - run: echo "dummy DCO workflow (it won't run any check actually) to trigger by merge_group in order to enable merge queue"
diff --git a/.github/workflows/dependency-review.yml b/.github/workflows/dependency-review.yml
new file mode 100644
index 0000000..50acb44
--- /dev/null
+++ b/.github/workflows/dependency-review.yml
@@ -0,0 +1,22 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: 'Dependency Review'
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  dependency-review:
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Checkout Repository'
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0
+        with:
+          submodules: recursive
+          persist-credentials: false
+
+      - name: 'Dependency Review'
+        uses: actions/dependency-review-action@dcd589ca9f7a6ded22e224ca2e288beb6bf9846b
diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
new file mode 100644
index 0000000..80783c1
--- /dev/null
+++ b/.github/workflows/fuzz.yml
@@ -0,0 +1,129 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# Runs the OSS-Fuzz harnesses under onnx/fuzz/ directly (not via OSS-Fuzz
+# infrastructure) as a regression check. This is deliberately not a
+# replacement for OSS-Fuzz's own continuous, long-running campaigns
+# (see google/oss-fuzz#15382) — it exists to catch harness regressions
+# (import errors, API drift, a harness file going missing) at PR time
+# instead of silently, since OSS-Fuzz failures are not surfaced here.
+#
+# atheris only ships wheels for Linux and macOS, so this does not run on
+# Windows. See https://github.com/onnx/onnx/blob/main/onnx/fuzz/README.md
+# for the harness/toggle-byte details.
+
+name: Fuzz
+
+on:
+  pull_request:
+    paths:
+      - 'onnx/**'
+      - 'pyproject.toml'
+      - '.github/workflows/fuzz.yml'
+  push:
+    branches:
+      - main
+    paths:
+      - 'onnx/**'
+      - 'pyproject.toml'
+      - '.github/workflows/fuzz.yml'
+  schedule:
+    - cron: '0 6 * * *'  # nightly: run each harness for longer than the PR smoke test
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  fuzz:
+    name: Run fuzz harnesses (${{ github.event_name == 'schedule' && 'nightly' || 'smoke' }})
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          submodules: recursive
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: '3.12'
+
+      - name: Build and install ONNX
+        run: pip install -e ".[reference]" -v
+        env:
+          ONNX_ML: 1
+
+      - name: Install atheris
+        run: pip install atheris
+
+      - name: Generate seed corpora
+        run: |
+          mkdir -p corpus
+          python onnx/fuzz/make_seed_corpus.py \
+            corpus/version_converter.zip corpus/parser.zip \
+            corpus/checker.zip corpus/shape_inference.zip corpus/compose.zip
+          for name in version_converter parser checker shape_inference compose; do
+            mkdir -p "corpus/$name"
+            python -m zipfile -e "corpus/$name.zip" "corpus/$name/"
+          done
+          # fuzz_model_loader.py has no dedicated seeds; it exercises the same
+          # load+check path as fuzz_checker.py, so reuse that corpus.
+          mkdir -p corpus/model_loader
+          cp corpus/checker/* corpus/model_loader/
+
+      - name: Set fuzz duration
+        id: duration
+        run: |
+          if [ "${{ github.event_name }}" = "schedule" ]; then
+            echo "seconds=300" >> "$GITHUB_OUTPUT"
+          else
+            echo "seconds=60" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Run fuzz_checker.py
+        run: python onnx/fuzz/fuzz_checker.py -max_total_time="$FUZZ_SECONDS" -timeout=20 corpus/checker
+        env:
+          FUZZ_SECONDS: ${{ steps.duration.outputs.seconds }}
+
+      - name: Run fuzz_model_loader.py
+        run: python onnx/fuzz/fuzz_model_loader.py -max_total_time="$FUZZ_SECONDS" -timeout=20 corpus/model_loader
+        env:
+          FUZZ_SECONDS: ${{ steps.duration.outputs.seconds }}
+
+      - name: Run fuzz_parser.py
+        run: python onnx/fuzz/fuzz_parser.py -max_total_time="$FUZZ_SECONDS" -timeout=20 corpus/parser
+        env:
+          FUZZ_SECONDS: ${{ steps.duration.outputs.seconds }}
+
+      - name: Run fuzz_shape_inference.py
+        run: python onnx/fuzz/fuzz_shape_inference.py -max_total_time="$FUZZ_SECONDS" -timeout=20 corpus/shape_inference
+        env:
+          FUZZ_SECONDS: ${{ steps.duration.outputs.seconds }}
+
+      - name: Run fuzz_version_converter.py
+        run: python onnx/fuzz/fuzz_version_converter.py -max_total_time="$FUZZ_SECONDS" -timeout=20 corpus/version_converter
+        env:
+          FUZZ_SECONDS: ${{ steps.duration.outputs.seconds }}
+
+      - name: Run fuzz_compose.py
+        run: python onnx/fuzz/fuzz_compose.py -max_total_time="$FUZZ_SECONDS" -timeout=20 corpus/compose
+        env:
+          FUZZ_SECONDS: ${{ steps.duration.outputs.seconds }}
+
+      - name: Upload crash artifacts
+        if: failure()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: fuzz-crashes
+          path: |
+            crash-*
+            timeout-*
+            oom-*
+          if-no-files-found: ignore
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
new file mode 100644
index 0000000..35e5af4
--- /dev/null
+++ b/.github/workflows/lint.yml
@@ -0,0 +1,117 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Lint
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  merge_group:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name == 'workflow_dispatch' }}
+  cancel-in-progress: true
+
+jobs:
+  validate-sbom:
+    name: Validate SBOM
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: '3.12'
+      - run: |
+          pip install -q check-jsonschema
+          python -m check_jsonschema --schemafile "https://cyclonedx.org/schema/bom-1.7.schema.json" sbom.cdx.json
+
+  enforce-style:
+    name: Enforce style
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Setup Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: "3.13"
+      - name: Install ONNX
+        run: |
+          source workflow_scripts/protobuf/build_protobuf_unix.sh $(nproc)
+
+          python -m pip install --quiet --upgrade pip setuptools wheel
+
+          export ONNX_BUILD_TESTS=0
+          export ONNX_ML=1
+          export CMAKE_ARGS="-DONNXIFI_DUMMY_BACKEND=ON -DONNX_WERROR=ON"
+          export ONNX_NAMESPACE=ONNX_NAMESPACE_FOO_BAR_FOR_CI
+
+          python -m pip install .
+      - name: Install dependencies
+        run: |
+          python -m pip install lintrunner>=0.10.7
+          # Use release_test to pin package versions
+          python -m pip install -r requirements-release_test.txt
+          python -m pip install -r requirements-lintrunner.txt
+          lintrunner init
+      - name: Run lintrunner on all files
+        run: |
+          set +e
+          if ! lintrunner --force-color --all-files --tee-json=lint.json -v; then
+              echo ""
+              echo -e "\e[1m\e[36mYou can reproduce these results locally by using \`lintrunner\`.\e[0m"
+              echo -e "\e[1m\e[36mSee https://github.com/onnx/onnx/blob/main/CONTRIBUTING.md#coding-style for setup instructions.\e[0m"
+              exit 1
+          fi
+      - name: Produce SARIF
+        if: always()
+        run: |
+          python -m lintrunner_adapters to-sarif lint.json lintrunner.sarif
+      - name: Upload SARIF file
+        # Use always() to always upload SARIF even if lintrunner returns with error code
+        # To toggle linter comments in the files page, press `i` on the keyboard
+        if: always()
+        continue-on-error: true
+        uses: github/codeql-action/upload-sarif@8aad20d150bbac5944a9f9d289da16a4b0d87c1e
+        with:
+          # Path to SARIF file relative to the root of the repository
+          sarif_file: lintrunner.sarif
+          category: lintrunner
+          checkout_path: ${{ github.workspace }}
+      - name: Upload lint results as artifacts
+        if: always()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a
+        with:
+          name: lint-results
+          path: |
+            lint.json
+            lintrunner.sarif
+          retention-days: 30
+      - name: Check auto-gen files are up-to-date
+        run: |
+          echo -e "\n::group:: ===> check auto-gen files are up-to-date..."
+
+          ONNX_ML=1 python onnx/defs/gen_doc.py
+          python onnx/gen_proto.py -l
+          python onnx/gen_proto.py -l --ml
+          python onnx/backend/test/stat_coverage.py
+
+          git status
+          git diff --exit-code -- . ':(exclude)onnx/onnx-data.proto' ':(exclude)onnx/onnx-data.proto3'
+          if [ $? -ne 0 ]; then
+            echo "git diff returned failures"
+            exit 1
+          fi
+          echo -e "::endgroup::"
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
new file mode 100644
index 0000000..d9d25a8
--- /dev/null
+++ b/.github/workflows/main.yml
@@ -0,0 +1,280 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: CI
+
+env:
+  ASAN_OPTIONS: detect_leaks=0:symbolize=1:detect_stack_use_after_return=true:strict_init_order=true:detect_odr_violation=1:detect_container_overflow=0:check_initialization_order=true:debug=true:fast_unwind_on_malloc=1:verify_asan_link_order=0
+  UBSAN_OPTIONS: print_stacktrace=1
+
+on:
+  schedule:
+    - cron: '0 0 * * *'  # every day at midnight for reporting code coverage to codecov
+  push:
+    branches:
+      - main
+  pull_request:
+  merge_group:
+  workflow_dispatch:
+
+permissions:  # set top-level default permissions as security good practice
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name == 'workflow_dispatch' }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: Test ${{ matrix.os }}, ${{ matrix.python_version }}, ${{ matrix.protobuf_type }}, debug=${{ matrix.debug_build }}, unity_build=${{ matrix.unity_build }}, onnx_ml=${{ matrix.onnx_ml }}, autogen=${{ matrix.autogenerate_files }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, windows-latest, macos-latest]
+        # Test on the oldest and latest supported Python versions
+        autogenerate_files: [0]
+        debug_build: [0]
+        onnx_ml: [1]
+        protobuf_type: ['Internal']
+        python_version: ['3.14t', '3.14', '3.10']
+        unity_build: [0]
+
+        include:
+          # Ubuntu debug build runs with sanitizer
+          - python_version: "3.14"
+            autogenerate_files: 0
+            debug_build: 1
+            onnx_ml: 1
+            os: "ubuntu-24.04"
+            protobuf_type: 'Internal'
+            unity_build: 0
+
+          # Test compilation with dynamically linked protobuf.
+          # This is actually redundant with the pixi-tests which
+          # also use dynamic linking.
+          - python_version: "3.14"
+            autogenerate_files: 0
+            debug_build: 0
+            onnx_ml: 1
+            os: "ubuntu-24.04"
+            protobuf_type: 'External'
+            unity_build: 0
+          - python_version: "3.14"
+            autogenerate_files: 0
+            debug_build: 0
+            onnx_ml: 1
+            os: "windows-2022"
+            protobuf_type: 'External'
+            unity_build: 0
+          # build_protobuf_unix.sh appears broken on macos-arm64
+          # - python_version: "3.14"
+          #   debug_build: 0
+          #   unity_build: 0
+          #   autogenerate_files: 0
+          #   protobuf_type: 'External'
+          #   os: "macos-latest"
+
+          # Unity build AND autogenerated files
+          # The unity build may surface name clashes at compile time
+          # but produces functionally identical binaries. We can
+          # therefore safely reuse this build to test the
+          # autogenerated files.
+          - python_version: '3.14'
+            autogenerate_files: 1
+            debug_build: 0
+            onnx_ml: 1
+            os: "ubuntu-24.04"
+            protobuf_type: 'External'
+            unity_build: 1
+
+          # Toggling onnx_ml should be additive. There is likely very
+          # different signal in testing it in relation with other
+          # parameters.
+          - python_version: '3.14'
+            autogenerate_files: 0
+            debug_build: 0
+            onnx_ml: 0
+            os: "ubuntu-24.04"
+            protobuf_type: 'External'
+            unity_build: 0
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0
+        with:
+          submodules: recursive
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: ${{ matrix.python_version }}
+
+      - name: Show versions
+        run: |
+          python --version
+          cmake --version
+
+      - name: Install external protobuf - Linux
+        if: matrix.protobuf_type == 'External' && startsWith(matrix.os,'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install libprotobuf-dev protobuf-compiler
+
+      - name: Install external protobuf - MacOS
+        if: matrix.protobuf_type == 'External' && matrix.os == 'macos-latest'
+        run: |
+          source workflow_scripts/protobuf/build_protobuf_unix.sh 3 $(pwd)/protobuf/protobuf_install
+
+      - name: Set up MSBuild (x64)
+        if: startsWith(matrix.os,'windows')
+        uses: microsoft/setup-msbuild@30375c66a4eea26614e0d39710365f22f8b0af57 # v3.0.0
+        with:
+          msbuild-architecture: x64
+
+      - name: Install external protobuf - Windows
+        if: matrix.protobuf_type == 'External' && startsWith(matrix.os, 'windows')
+        run: |
+          if ($matrix.os -like "windows-11-arm*") {
+              $cmake_arch = "ARM64"
+          } else {
+              $cmake_arch = "x64"
+          }
+
+          workflow_scripts/protobuf/build_protobuf_win.ps1 -cmake_arch $cmake_arch
+        shell: pwsh
+
+      - name: Build and install ONNX - Linux
+        if: startsWith(matrix.os,'ubuntu')
+        run: |
+          export SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)
+          if [ "${{ matrix.python_version }}" == "3.14" ]; then
+            sudo apt-get update
+            sudo apt-get install libjpeg-dev zlib1g-dev libpng-dev
+          fi
+
+          if [ "${{ matrix.protobuf_type }}" == "External" ]; then
+            export CMAKE_ARGS="$CMAKE_ARGS -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DONNX_USE_PROTOBUF_SHARED_LIBS=ON"
+          fi
+          pip install -e ".[reference]" -v
+        env:
+          DEBUG: ${{ matrix.debug_build }}
+          ONNX_ML: ${{ matrix.onnx_ml }}
+          ONNX_BUILD_TESTS: 1
+          CMAKE_ARGS: "-DONNX_WERROR=ON -DONNX_USE_ASAN=${{ matrix.debug_build }} -DONNX_USE_UNITY_BUILD=${{ matrix.unity_build }} -DONNX_HARDENING=ON"
+
+      - name: Build and install ONNX - MacOS
+        if: matrix.os == 'macos-latest'
+        run: |
+          pip install -e ".[reference]" -v
+        env:
+          DEBUG: ${{ matrix.debug_build }}
+          ONNX_ML: ${{ matrix.onnx_ml }}
+          ONNX_BUILD_TESTS: 1
+          CMAKE_ARGS: "-DONNX_WERROR=ON -DONNX_USE_UNITY_BUILD=${{ matrix.unity_build }} -DONNX_HARDENING=ON"
+
+      - name: Build and install ONNX - Windows
+        if: startsWith(matrix.os,'windows')
+        run: |
+          pip install -e . -v
+        env:
+          DEBUG: ${{ matrix.debug_build }}
+          ONNX_ML: ${{ matrix.onnx_ml }}
+          ONNX_BUILD_TESTS: 1
+          CMAKE_ARGS: "-DONNX_WERROR=ON -DONNX_USE_PROTOBUF_SHARED_LIBS=OFF -DONNX_USE_LITE_PROTO=ON -DONNX_USE_UNITY_BUILD=${{ matrix.unity_build }} -DONNX_HARDENING=ON"
+
+      - name: pip freeze
+        run: |
+          pip freeze
+
+      - name: Setup GCC ASAN LD_PRELOAD
+        if: startsWith(matrix.os,'ubuntu') && (matrix.python_version != '3.13t')
+        run: |
+          export LD_PRELOAD="$(/usr/bin/c++ -print-file-name=libasan.so):$LD_PRELOAD"
+
+      - name: Install test dependencies
+        run: |
+          python -m pip install -r requirements-release_test.txt
+
+      - name: Run Python tests
+        # Prohibitively slow for Windows debug builds
+        if: ${{ !(startsWith(matrix.os, 'windows') && matrix.debug_build == 1) }}
+        run: |
+          pytest -sv --cov=onnx --cov-report=xml --cov-append --cov-branch --junitxml junit.xml -n auto --dist loadscope
+      - name: Run C++ tests
+        if: startsWith(matrix.os,'ubuntu') || matrix.os == 'macos-latest'
+        run: |
+          export LD_LIBRARY_PATH="./.setuptools-cmake-build/:$LD_LIBRARY_PATH"
+          ./.setuptools-cmake-build/onnx_gtests
+
+      - name: Run C++ extension test
+        if: (startsWith(matrix.os,'ubuntu') || matrix.os == 'macos-latest') && matrix.debug_build == 0 && matrix.protobuf_type == 'External'
+        run: |
+          cmake -S . -B build_for_install \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_INSTALL_PREFIX=/usr/local \
+            -DONNX_ML=${{ matrix.onnx_ml }} \
+            -DONNX_USE_PROTOBUF_SHARED_LIBS=ON
+          cmake --build build_for_install --parallel
+          sudo cmake --install build_for_install
+
+          cmake -S onnx/test/cmake -B onnx/test/cmake/build \
+            -DONNX_ML=${{ matrix.onnx_ml }}
+          cmake --build onnx/test/cmake/build
+          ./onnx/test/cmake/build/main
+
+      - name: Upload coverage to Codecov
+        if: github.repository_owner == 'onnx'
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Upload test results to Codecov
+        if: github.repository_owner == 'onnx' && !cancelled()
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          report_type: test_results
+
+      # Note that the test data should be generated with numpy>=2.0.
+      # numpy 1.x and numpy 2.0 produce slightly different numerical values.
+      - name: Test backend test data
+        if: matrix.autogenerate_files == 1 && startsWith(matrix.os,'ubuntu')
+        run: |
+          python onnx/backend/test/cmd_tools.py generate-data --clean
+          git status
+          git diff --exit-code -- . ':!onnx/onnx-data.proto' ':!onnx/onnx-data.proto3' ':!*output_*.pb' ':!*input_*.pb'
+          if [ $? -ne 0 ]; then
+            echo "git diff for test generation returned failures. Please check updated node test files"
+            exit 1
+          fi
+          git diff --exit-code --diff-filter=ADR -- . ':!onnx/onnx-data.proto' ':!onnx/onnx-data.proto3'
+          if [ $? -ne 0 ]; then
+            echo "Test generation returned failures. Please check the number of node test files (input_*.pb or output_*.pb)"
+            exit 1
+          fi
+          pip uninstall -y pillow
+          python onnx/backend/test/cmd_tools.py generate-data --clean
+          git status
+          git diff --exit-code -- . ':!onnx/onnx-data.proto' ':!onnx/onnx-data.proto3' ':!*output_*.pb' ':!*input_*.pb'
+          if [ $? -ne 0 ]; then
+            echo "git diff for test generation without pillow returned failures. Please check updated node test files"
+            exit 1
+          fi
+
+      - name: Run Python tests with numpy<2.0 (win, mac)
+        if: (matrix.python_version == '3.10') && (matrix.os == 'windows-latest' || matrix.os == 'macos-latest') && (matrix.debug_build != 1)
+        run: |
+          pip install "numpy<2.0" pillow
+          pytest -s
+
+      - name: Run Python tests with numpy<2.0 (ubuntu, python<3.13)
+        if: (matrix.python_version == '3.10') && startsWith(matrix.os,'ubuntu')
+        run: |
+          # 2024.10.15: Error message: The headers or library files could not be found for jpeg, a required dependency when compiling Pillow from source.
+          sudo apt-get update
+          sudo apt-get install libjpeg-dev zlib1g-dev libpng-dev
+          pip install --prefer-binary "numpy<2.0" pillow
+          pytest -s
diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml
new file mode 100644
index 0000000..6450945
--- /dev/null
+++ b/.github/workflows/pages.yml
@@ -0,0 +1,55 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Generate and publish ONNX docs
+
+on:
+  pull_request:
+    branches: ["main"]
+  # Runs on pushes targeting the default branch
+  push:
+    branches: ["main"]
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+      - name: Set up pixi
+        uses: prefix-dev/setup-pixi@5185adfbffb4bd703da3010310260805d89ebb11 # v0.9.6
+        with:
+          environments: docs
+      - name: Install repository
+        run: pixi run -e docs install
+      - name: Build Docs
+        run: pixi run -e docs docs-build
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
+        with:
+          path: 'docs/docsgen/build/html'
+  deploy:
+    needs: 'build'
+    if: github.event_name != 'pull_request'
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Pages
+        uses: actions/configure-pages@45bfe0192ca1faeb007ade9deae92b16b8254a0d # v6.0.0
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@cd2ce8fcbc39b97be8ca5fce6e763baed58fa128 # v5.0.0
diff --git a/.github/workflows/pixi_build.yml b/.github/workflows/pixi_build.yml
new file mode 100644
index 0000000..d31195e
--- /dev/null
+++ b/.github/workflows/pixi_build.yml
@@ -0,0 +1,124 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Pixi CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  pre-commit-hooks:
+    name: Install and lint (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-24.04-arm
+          - windows-2022
+    steps:
+      - name: Checkout branch
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Set up pixi
+        uses: prefix-dev/setup-pixi@5185adfbffb4bd703da3010310260805d89ebb11 # v0.9.6
+        with:
+          environments: default reuse
+      - name: Install repository
+        run: pixi run install
+      - name: Lint
+        run: pixi run lint --show-diff-on-failure
+
+  xcode-build:
+    # Guards against regressions in CMake's Xcode generator (issue #8053), which
+    # downstream consumers such as onnxruntime use for their iOS/macOS framework
+    # builds. The other jobs build with Ninja and so do not exercise the
+    # Xcode-specific code paths.
+    name: Xcode generator build
+    runs-on: macos-latest
+    steps:
+      - name: Checkout branch
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Set up pixi
+        uses: prefix-dev/setup-pixi@5185adfbffb4bd703da3010310260805d89ebb11 # v0.9.6
+        with:
+          environments: default
+      - name: Build with the Xcode generator
+        run: |
+          pixi run cmake -G Xcode -B .xcode-cmake-build -S . -DONNX_BUILD_PYTHON=ON -DONNX_USE_PROTOBUF_SHARED_LIBS=ON
+          pixi run cmake --build .xcode-cmake-build
+
+  install-and-test:
+    name: Install and test (${{ matrix.os }}, ${{ matrix.environment }})
+    runs-on: ${{ matrix.os }}
+    permissions:
+      contents: read
+      issues: write  # Needed to create an issue on failure
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-24.04-arm
+          - ubuntu-latest
+          - macos-latest
+          - windows-2022
+        environment:
+          - default
+          - oldies
+    steps:
+      - name: Checkout branch
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Set up pixi
+        uses: prefix-dev/setup-pixi@5185adfbffb4bd703da3010310260805d89ebb11 # v0.9.6
+        with:
+          environments: ${{ matrix.environment }}
+      - name: Install repository
+        run: pixi run -e ${{ matrix.environment }} install
+      - name: pip check installation
+        run: pixi run -e ${{ matrix.environment }} pip check
+      - name: gtests
+        run: pixi run -e ${{ matrix.environment }} gtest
+      - name: pytest
+        run: pixi run -e ${{ matrix.environment }} pytest
+      - name: Issue on failure
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        if: ${{ failure() && github.ref == 'refs/heads/main' }}
+        with:
+          script: |
+            github.rest.issues.listForRepo({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: "open",
+              labels: "[bot] pixi CI"
+            }).then((issues) => {
+              if (issues.data.length === 0){
+                github.rest.issues.create({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  title: "Scheduled pixi CI failed",
+                  body: "The scheduled pixi-based CI failed. See https://github.com/${{ github.repository }}/actions/runs/${{github.run_id}} for details.",
+                  assignees: ["cbourjau"],
+                  labels: ["[bot] pixi CI"]
+                })
+              }
+            });
diff --git a/.github/workflows/preview_source_dist_test.yml b/.github/workflows/preview_source_dist_test.yml
new file mode 100644
index 0000000..b08bccb
--- /dev/null
+++ b/.github/workflows/preview_source_dist_test.yml
@@ -0,0 +1,43 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Test source dist of preview build at onnx-weekly
+
+on:
+  schedule:
+    - cron:  '0 0 * * 2'
+  workflow_call:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+
+  test_sdist_preview:
+
+    strategy:
+      matrix:
+        os: [ubuntu-24.04, windows-latest]
+        python-version: ['3.10', '3.12', '3.13']
+      fail-fast: false
+    runs-on: ${{ matrix.os }}
+
+    steps:
+
+        - name: Checkout repository
+          uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0
+          with:
+            persist-credentials: false
+
+        - name: Set up Python ${{ matrix.python-version }}
+          uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+          with:
+            python-version: ${{ matrix.python-version }}
+
+        - name: Test preview build source distribution from PyPI
+          run: |
+            python -m pip install --no-binary onnx-weekly onnx-weekly
+            python -m pip install pytest ml_dtypes pillow
+            pytest
diff --git a/.github/workflows/release_linux_cibw.yml b/.github/workflows/release_linux_cibw.yml
new file mode 100644
index 0000000..07e2ea9
--- /dev/null
+++ b/.github/workflows/release_linux_cibw.yml
@@ -0,0 +1,101 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Linux Release
+
+on:
+  workflow_call:
+    inputs:
+      build_mode:
+        required: false
+        type: string
+        default: "preview"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: linux-release-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        build:
+          - "cp310-manylinux_x86_64"
+          - "cp310-manylinux_aarch64"
+          - "cp311-manylinux_x86_64"
+          - "cp311-manylinux_aarch64"
+          - "cp312-manylinux_x86_64"
+          - "cp312-manylinux_aarch64"
+          - "cp314t-manylinux_x86_64"
+          - "cp314t-manylinux_aarch64"
+
+    runs-on: ${{ contains(matrix.build, 'aarch64') && 'ubuntu-24.04-arm' || 'ubuntu-24.04' }}
+
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Read protobuf version from sbom.cdx.json
+        run: echo "PROTOBUF_VERSION=$(jq -r '.components[] | select(.name=="protobuf") | .version' sbom.cdx.json)" >> $GITHUB_ENV
+
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: "3.12"
+
+      - name: Set preview version
+        if: inputs.build_mode != 'release'
+        shell: bash
+        run: |
+          sed -i'' 's/name = "onnx"/name = "onnx-weekly"/' pyproject.toml
+          echo "$(cat VERSION_NUMBER).dev$(date -u +%Y%m%d)" > VERSION_NUMBER
+
+      - name: Download protoc
+        run: |
+          ARCH=${{ contains(matrix.build, 'aarch64') && 'aarch_64' || 'x86_64' }}
+          curl -sSL "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOBUF_VERSION}/protoc-${PROTOBUF_VERSION}-linux-${ARCH}.zip" -o protoc.zip
+          unzip -q protoc.zip -d protoc-host
+          chmod +x protoc-host/bin/protoc
+
+      - name: Download protobuf source
+        run: |
+          curl -sSL "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOBUF_VERSION}/protobuf-${PROTOBUF_VERSION}.tar.gz" -o protobuf.tar.gz
+          tar -xf protobuf.tar.gz
+
+      - name: Set SOURCE_DATE_EPOCH for reproducible builds
+        run: echo "SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)" >> $GITHUB_ENV
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@294735312765b09d24a2fbec22660ce817587d55  # v4.1.0
+        with:
+          output-dir: dist/
+          only: ${{ matrix.build }}
+        env:
+          CIBW_ENVIRONMENT: >-
+            CMAKE_ARGS="
+            -DFETCHCONTENT_SOURCE_DIR_PROTOBUF=/project/protobuf-${{ env.PROTOBUF_VERSION }}
+            -DONNX_CUSTOM_PROTOC_EXECUTABLE=/project/protoc-host/bin/protoc
+            -DONNX_HARDENING=ON
+            -DONNX_USE_LITE_PROTO=ON
+            -DONNX_WERROR=ON
+            "
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: wheels-linux-${{ matrix.build }}
+          path: dist/*.whl
+
+      - name: Validate wheel
+        run: |
+          python -m pip install -q abi3audit check-wheel-contents
+          for whl in dist/*.whl; do
+            echo "Checking $whl"
+            check-wheel-contents "$whl"
+            python -m abi3audit -v "$whl"
+          done
diff --git a/.github/workflows/release_macos_cibw.yml b/.github/workflows/release_macos_cibw.yml
new file mode 100644
index 0000000..339c226
--- /dev/null
+++ b/.github/workflows/release_macos_cibw.yml
@@ -0,0 +1,97 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: macOS Release
+
+on:
+  workflow_call:
+    inputs:
+      build_mode:
+        required: false
+        type: string
+        default: "preview"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: macos-release-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        build:
+          - "cp310-macosx_universal2"
+          - "cp311-macosx_universal2"
+          - "cp312-macosx_universal2"
+          - "cp314t-macosx_universal2"
+
+    runs-on: macos-14
+
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Read protobuf version from sbom.cdx.json
+        run: echo "PROTOBUF_VERSION=$(jq -r '.components[] | select(.name=="protobuf") | .version' sbom.cdx.json)" >> $GITHUB_ENV
+
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: "3.12"
+
+      - name: Set preview version
+        if: inputs.build_mode != 'release'
+        shell: bash
+        run: |
+          sed -i '' 's/name = "onnx"/name = "onnx-weekly"/' pyproject.toml
+          echo "$(cat VERSION_NUMBER).dev$(date -u +%Y%m%d)" > VERSION_NUMBER
+
+      - name: Download protoc
+        run: |
+          curl -sSL "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOBUF_VERSION}/protoc-${PROTOBUF_VERSION}-osx-universal_binary.zip" -o protoc.zip
+          unzip -q protoc.zip -d protoc-host
+          chmod +x protoc-host/bin/protoc
+
+      - name: Download protobuf source
+        run: |
+          curl -sSL "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOBUF_VERSION}/protobuf-${PROTOBUF_VERSION}.tar.gz" -o protobuf.tar.gz
+          tar -xf protobuf.tar.gz
+
+      - name: Set SOURCE_DATE_EPOCH for reproducible builds
+        run: echo "SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)" >> $GITHUB_ENV
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@294735312765b09d24a2fbec22660ce817587d55  # v4.1.0
+        with:
+          output-dir: dist/
+          only: ${{ matrix.build }}
+        env:
+          CIBW_ENVIRONMENT: >-
+            MACOSX_DEPLOYMENT_TARGET=12.0
+            CMAKE_ARGS="
+            -DFETCHCONTENT_SOURCE_DIR_PROTOBUF=${{ github.workspace }}/protobuf-${{ env.PROTOBUF_VERSION }}
+            -DONNX_CUSTOM_PROTOC_EXECUTABLE=${{ github.workspace }}/protoc-host/bin/protoc
+            -DONNX_HARDENING=ON
+            -DONNX_USE_LITE_PROTO=ON
+            -DONNX_WERROR=ON
+            "
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: wheels-macos-${{ matrix.build }}
+          path: dist/*.whl
+
+      - name: Validate wheel
+        run: |
+          python -m pip install -q abi3audit check-wheel-contents
+          for whl in dist/*.whl; do
+            echo "Checking $whl"
+            check-wheel-contents "$whl"
+            python -m abi3audit -v "$whl"
+          done
diff --git a/.github/workflows/release_pyodide_cibw.yml b/.github/workflows/release_pyodide_cibw.yml
new file mode 100644
index 0000000..8aaaaac
--- /dev/null
+++ b/.github/workflows/release_pyodide_cibw.yml
@@ -0,0 +1,83 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Pyodide Build
+
+on:
+  workflow_call:
+    inputs:
+      build_mode:
+        required: false
+        type: string
+        default: "preview"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: pyodide-release-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Read protobuf version from sbom.cdx.json
+        run: echo "PROTOBUF_VERSION=$(jq -r '.components[] | select(.name=="protobuf") | .version' sbom.cdx.json)" >> $GITHUB_ENV
+
+      - name: Set up Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: "3.12"
+
+      - name: Set preview version
+        if: inputs.build_mode != 'release'
+        shell: bash
+        run: |
+          sed -i'' 's/name = "onnx"/name = "onnx-weekly"/' pyproject.toml
+          echo "$(cat VERSION_NUMBER).dev$(date -u +%Y%m%d)" > VERSION_NUMBER
+
+      - name: Download protoc for host
+        run: |
+          curl -sSL "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOBUF_VERSION}/protoc-${PROTOBUF_VERSION}-linux-x86_64.zip" -o protoc.zip
+          unzip -q protoc.zip -d protoc-host
+          chmod +x protoc-host/bin/protoc
+
+      - name: Download protobuf source
+        run: |
+          curl -sSL "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOBUF_VERSION}/protobuf-${PROTOBUF_VERSION}.tar.gz" -o protobuf.tar.gz
+          tar -xf protobuf.tar.gz
+
+      - name: Set SOURCE_DATE_EPOCH for reproducible builds
+        run: echo "SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)" >> $GITHUB_ENV
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@294735312765b09d24a2fbec22660ce817587d55  # v4.1.0
+        with:
+          output-dir: dist/
+        env:
+          CIBW_PLATFORM: pyodide
+          CIBW_TEST_COMMAND: >-
+            python -c "from onnx import NodeProto; n = NodeProto(); n.op_type = 'Add'; print(n)"
+          CIBW_ENVIRONMENT: >-
+            CMAKE_ARGS="
+            -DFETCHCONTENT_SOURCE_DIR_PROTOBUF=${{ github.workspace }}/protobuf-${{ env.PROTOBUF_VERSION }}
+            -DONNX_CUSTOM_PROTOC_EXECUTABLE=${{ github.workspace }}/protoc-host/bin/protoc
+            -DONNX_HARDENING=ON
+            -DONNX_PYODIDE_BUILD=ON
+            -DONNX_USE_LITE_PROTO=ON
+            -DONNX_WERROR=ON
+            -DCMAKE_CXX_FLAGS='-Wno-error=deprecated-builtins'
+            "
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: wheels-pyodide
+          path: dist/*.whl
diff --git a/.github/workflows/release_sdist.yml b/.github/workflows/release_sdist.yml
new file mode 100644
index 0000000..08b5de0
--- /dev/null
+++ b/.github/workflows/release_sdist.yml
@@ -0,0 +1,66 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: sdistRelease
+
+on:
+  workflow_call:
+    inputs:
+      os:
+        required: true
+        type: string
+      build_mode:
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+concurrency:
+  group: sdist-release-${{ github.workflow }}-${{ github.ref }}
+
+jobs:
+  build:
+    if: github.event_name != 'pull_request' || startsWith( github.base_ref, 'rel-') || contains( github.event.pull_request.labels.*.name, 'run release CIs')
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        python-version: ['3.10']
+        target-architecture: ['arm64']
+
+    steps:
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      with:
+        persist-credentials: false
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install Python dependencies
+      run: |
+        python -m pip install -q --upgrade pip
+        python -m pip install -q build scikit-build-core
+
+    - name: Build source distribution (preview build / weekly)
+      if: ${{ inputs.build_mode != 'release' }}
+      run: |
+        git clean -xdf
+        sed -i 's/name = "onnx"/name = "onnx-weekly"/' 'pyproject.toml'
+        echo "$(cat VERSION_NUMBER).dev$(date -u +%Y%m%d)" > VERSION_NUMBER
+        python -m build --sdist
+
+    - name: Build source distribution (for release)
+      if: ${{ inputs.build_mode == 'release' }}
+      run: |
+        git clean -xdf
+        python -m build --sdist
+
+    - name: Upload sdist
+      uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a
+      with:
+        name: sdist
+        path: |
+            ./dist/*.tar.gz
diff --git a/.github/workflows/release_windows_cibw.yml b/.github/workflows/release_windows_cibw.yml
new file mode 100644
index 0000000..e7f877f
--- /dev/null
+++ b/.github/workflows/release_windows_cibw.yml
@@ -0,0 +1,108 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Windows Release
+
+on:
+  workflow_call:
+    inputs:
+      build_mode:
+        required: false
+        type: string
+        default: "preview"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: windows-release-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        build:
+          - "cp310-win_amd64"
+          - "cp310-win32"
+          - "cp311-win_amd64"
+          - "cp311-win32"
+          - "cp311-win_arm64"
+          - "cp312-win_amd64"
+          - "cp312-win32"
+          - "cp312-win_arm64"
+          - "cp314t-win_amd64"
+          - "cp314t-win_arm64"
+    runs-on: ${{ contains(matrix.build, 'arm64') && 'windows-11-arm' || 'windows-2022' }}
+
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Read protobuf version from sbom.cdx.json
+        shell: bash
+        run: echo "PROTOBUF_VERSION=$(jq -r '.components[] | select(.name=="protobuf") | .version' sbom.cdx.json)" >> $GITHUB_ENV
+
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: "3.12"
+
+      - name: Set preview version
+        if: inputs.build_mode != 'release'
+        shell: bash
+        run: |
+          sed -i'' 's/name = "onnx"/name = "onnx-weekly"/' pyproject.toml
+          echo "$(cat VERSION_NUMBER).dev$(date -u +%Y%m%d)" > VERSION_NUMBER
+
+      - name: Download protoc
+        run: |
+          curl -sSL "https://github.com/protocolbuffers/protobuf/releases/download/v${env:PROTOBUF_VERSION}/protoc-${env:PROTOBUF_VERSION}-win64.zip" -o protoc.zip
+          Expand-Archive protoc.zip -DestinationPath protoc-host
+
+      - name: Download protobuf source
+        run: |
+          curl -sSL "https://github.com/protocolbuffers/protobuf/releases/download/v${env:PROTOBUF_VERSION}/protobuf-${env:PROTOBUF_VERSION}.tar.gz" -o protobuf.tar.gz
+          tar -xf protobuf.tar.gz
+
+      - name: Set paths
+        shell: bash
+        run: |
+          echo "PROTOC_PATH=$(cygpath -m "${{ github.workspace }}/protoc-host/bin/protoc.exe")" >> $GITHUB_ENV
+          echo "PROTOBUF_SRC=$(cygpath -m "${{ github.workspace }}/protobuf-${PROTOBUF_VERSION}")" >> $GITHUB_ENV
+
+      - name: Set SOURCE_DATE_EPOCH for reproducible builds
+        shell: bash
+        run: echo "SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)" >> $GITHUB_ENV
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@294735312765b09d24a2fbec22660ce817587d55  # v4.1.0
+        with:
+          output-dir: dist/
+          only: ${{ matrix.build }}
+        env:
+          CIBW_ENVIRONMENT: >-
+            CMAKE_ARGS="
+            -DFETCHCONTENT_SOURCE_DIR_PROTOBUF=${{ env.PROTOBUF_SRC }}
+            -DONNX_CUSTOM_PROTOC_EXECUTABLE=${{ env.PROTOC_PATH }}
+            -DONNX_HARDENING=ON
+            -DONNX_USE_LITE_PROTO=ON
+            -DONNX_WERROR=ON
+            "
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: wheels-windows-${{ matrix.build }}
+          path: dist/*.whl
+
+      - name: Validate wheel
+        run: |
+          python -m pip install -q abi3audit check-wheel-contents
+          Get-ChildItem -Path dist/*.whl | ForEach-Object {
+            echo "Checking $($_.Name)"
+            check-wheel-contents $_.FullName
+            python -m abi3audit -v $_.FullName
+          }
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
new file mode 100644
index 0000000..af9ab3b
--- /dev/null
+++ b/.github/workflows/scorecard.yml
@@ -0,0 +1,48 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Scorecard supply-chain security
+on:
+  branch_protection_rule:
+  schedule:
+    - cron: '24 10 * * 6'
+  push:
+    branches: [ "main" ]
+
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          publish_results: true
+
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard.
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@8aad20d150bbac5944a9f9d289da16a4b0d87c1e
+        with:
+          sarif_file: results.sarif
diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
new file mode 100644
index 0000000..a74e97c
--- /dev/null
+++ b/.github/workflows/stale.yml
@@ -0,0 +1,38 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
+#
+# You can adjust the behavior by modifying this file.
+# For more information, see:
+# https://github.com/actions/stale
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: '39 6 * * *'
+
+permissions:  # set top-level default permissions as security best practice
+  contents: read
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+    - uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        days-before-stale: 365
+        days-before-close: 21
+        ascending: true
+        exempt-issue-labels: bug,no-stale
+        exempt-pr-labels: no-stale,contributions welcome
+        remove-issue-stale-when-updated: true
+        remove-pr-stale-when-updated: true
+        exempt-all-milestones: true
diff --git a/.github/workflows/win_no_exception_ci.yml b/.github/workflows/win_no_exception_ci.yml
new file mode 100644
index 0000000..c9ddd85
--- /dev/null
+++ b/.github/workflows/win_no_exception_ci.yml
@@ -0,0 +1,81 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+name: Windows_No_Exception_CI
+
+on:
+   push:
+    branches: [ main, rel-* ]
+   pull_request:
+    branches: [ main, rel-* ]
+
+permissions:  # set top-level default permissions as security best practice
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_name == 'workflow_dispatch' }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: windows-2022
+    strategy:
+      matrix:
+        python-version: ['3.10']
+        architecture: ['x64']
+    steps:
+    - name: Checkout ONNX
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      with:
+         path: ./onnx
+         submodules: 'recursive'
+         persist-credentials: false
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+      with:
+        python-version: ${{ matrix.python-version }}
+        architecture: ${{ matrix.architecture }}
+        cache: 'pip'
+
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@30375c66a4eea26614e0d39710365f22f8b0af57 # v3.0.0
+      with:
+        msbuild-architecture: ${{ matrix.architecture }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install cmake
+
+    - name: Build and test ONNX binaries
+      run: |
+        . .\onnx\workflow_scripts\protobuf\build_protobuf_win.ps1 -cmake_arch ${{ matrix.architecture }}
+
+        cd onnx
+        echo "Build ONNX"
+        cmake -G "Visual Studio 17 2022" -A ${{ matrix.architecture }} -DONNX_USE_PROTOBUF_SHARED_LIBS=OFF -DONNX_USE_LITE_PROTO=ON -DONNX_WERROR=ON -DONNX_DISABLE_EXCEPTIONS=ON -DCMAKE_BUILD_TYPE=Release -DONNX_USE_MSVC_STATIC_RUNTIME=OFF -DONNX_ML=1 -DONNX_BUILD_TESTS=ON -S . -B .setuptools-cmake-build\
+        cd .setuptools-cmake-build\
+        cmake --build . --config Release
+
+        echo "Run gtests"
+        Release\onnx_gtests.exe
+        if($lastexitcode -ne 0) {
+          EXIT 1
+        }
+
+        cd ..
+        git clean -xdf
+        set ONNX_BUILD_TESTS=1
+        echo "Build ONNX with non-static registration for testing selective ONNX schema loading"
+        cmake -G "Visual Studio 17 2022" -A ${{ matrix.architecture }} -DONNX_USE_PROTOBUF_SHARED_LIBS=OFF -DONNX_USE_LITE_PROTO=ON -DONNX_WERROR=ON -DCMAKE_BUILD_TYPE=Release -DONNX_USE_MSVC_STATIC_RUNTIME=OFF -DONNX_ML=1 -DONNX_BUILD_TESTS=ON -DONNX_DISABLE_STATIC_REGISTRATION=ON -S . -B .setuptools-cmake-build\
+
+        cd .setuptools-cmake-build\
+        cmake --build . --config Release
+
+        echo "Only test selective ONNX schema loading"
+        Release\onnx_gtests.exe --gtest_filter="SchemaRegistrationTest*"
+        if($lastexitcode -ne 0) {
+          EXIT 1
+        }
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..15aa2af
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,118 @@
+## General
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.cuo
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.pyd
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+
+# Compiled protocol buffers
+*.pb.h
+*.pb.cc
+onnx/*_pb2.py
+onnx/*_pb.py
+onnx/*_pb2.pyi
+onnx/*_pb.pyi
+
+# Compiled python
+*.pyc
+
+# Compiled MATLAB
+*.mex*
+
+# IPython notebook checkpoints
+.ipynb_checkpoints
+
+# Editor temporaries
+*.swn
+*.swo
+*.swp
+*~
+
+# Sublime Text settings
+*.sublime-workspace
+*.sublime-project
+
+# Eclipse Project settings
+*.*project
+.settings
+
+# QtCreator files
+*.user
+
+# PyCharm files
+.idea
+
+# Visual Studio Code files
+.vscode
+!/.vscode/settings.json
+
+# OSX dir files
+.DS_Store
+
+## ONNX
+
+# build, distribute, and bins (+ python proto bindings)
+build
+build_*
+.build_debug/*
+.build_release/*
+.setuptools-cmake-build/*
+
+# setup.py intermediates
+.eggs
+dist
+onnx.egg-info
+*.ninja
+.ninja_deps
+.ninja_log
+compile_commands.json
+
+# generated files
+compile_commands.json
+
+# test generated files
+.cache
+.coverage
+onnx/examples/.coverage.nbval
+.pytest_cache
+test_report
+test-output.xml
+
+# autocomplete
+.ycm_extra_conf.py
+
+# test coverage data files
+*.gcov
+
+.mypy_cache
+virtualenv
+venv
+
+# direnv, posh-direnv
+.envrc
+.psenvrc
+
+# documentation
+docs/docsgen/source/onnx-api/modules/
+docs/docsgen/source/operators/
+docs/docsgen/**/*.onnx
+docs/docsgen/**/*.pb
+
+# PyEnv files
+.python-version
+.pixi/**
+=0.*
+_codeql_build_dir/
+_codeql_detected_source_root
+/.lycheecache
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..e69de29
diff --git a/.lintrunner.toml b/.lintrunner.toml
new file mode 100644
index 0000000..6dcc689
--- /dev/null
+++ b/.lintrunner.toml
@@ -0,0 +1,221 @@
+# Configuration for lintrunner https://github.com/suo/lintrunner
+# You can install the dependencies and initialize with
+#
+# ```sh
+# pip install lintrunner lintrunner-adapters
+# lintrunner init
+# ```
+#
+# This will install lintrunner on your system and download all the necessary
+# dependencies to run linters locally.
+# If you want to see what lintrunner init will install, run
+# `lintrunner init --dry-run`.
+#
+# To lint local changes:
+#
+# ```bash
+# lintrunner
+# ```
+#
+# To lint all files:
+#
+# ```bash
+# lintrunner --all-files
+# ```
+#
+# To format files:
+#
+# ```bash
+# lintrunner -a
+# ```
+#
+# To read more about lintrunner, see [wiki](https://github.com/pytorch/pytorch/wiki/lintrunner).
+# To update an existing linting rule or create a new one, modify this file or create a
+# new adapter following examples in https://github.com/justinchuby/lintrunner-adapters.
+merge_base_with = 'main'
+
+[[linter]]
+code = 'RUFF'
+include_patterns = [
+    '**/*.py',
+    '**/*.pyi',
+]
+exclude_patterns = [
+    '*_pb2*',
+    '.setuptools-cmake-build/*',
+    'docs/**',
+]
+command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'ruff_linter',
+    '--config=pyproject.toml',
+    '@{{PATHSFILE}}'
+]
+init_command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'pip_init',
+    '--dry-run={{DRYRUN}}',
+    '--requirement=requirements-lintrunner.txt',
+]
+is_formatter = true
+
+[[linter]]
+code = 'MYPY'
+include_patterns = [
+    'onnx/**/*.py',
+    'tools/**/*.py',
+]
+exclude_patterns = [
+    'onnx/backend/test/**',
+    'onnx/reference/ops/**',  # FIXME: Enable this once typing is fixed
+    'onnx/test/**',  # Disable mypy for tests
+    'onnx/reference/reference_evaluator.py',
+]
+command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'mypy_linter',
+    '--config=pyproject.toml',
+    '--show-disable',
+    '--',
+    '@{{PATHSFILE}}'
+]
+init_command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'pip_init',
+    '--dry-run={{DRYRUN}}',
+    '--requirement=requirements-lintrunner.txt',
+]
+
+[[linter]]
+code = 'RUFF-FORMAT'
+include_patterns = [
+    '**/*.py',
+]
+exclude_patterns = [
+    '*_pb2*',
+    '.setuptools-cmake-build/*',
+    'cmake/**',
+    'docs/**',
+]
+command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'ruff_format_linter',
+    '--',
+    '@{{PATHSFILE}}'
+]
+init_command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'pip_init',
+    '--dry-run={{DRYRUN}}',
+    '--requirement=requirements-lintrunner.txt',
+]
+is_formatter = true
+
+[[linter]]
+code = 'NAMESPACE'
+include_patterns = ['**/*.cc', '**/*.h']
+exclude_patterns = []
+command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'grep_linter',
+    '--pattern=namespace onnx|onnx::',
+    '--linter-name=NAMESPACE',
+    '--error-name=hardcoded onnx namespace',
+    """--error-description=\
+        Do not hardcode onnx's namespace in the c++ source code, so that \
+        other libraries that statically link with onnx can hide onnx symbols \
+        in a private namespace.\
+    """,
+    '--',
+    '@{{PATHSFILE}}'
+]
+
+[[linter]]
+code = 'CLANGFORMAT'
+include_patterns = [
+    'onnx/**/*.h',
+    'onnx/**/*.cc',
+]
+exclude_patterns = [
+]
+command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'clangformat_linter',
+    '--binary=clang-format',
+    '--fallback',
+    '--',
+    '@{{PATHSFILE}}'
+]
+init_command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'pip_init',
+    '--dry-run={{DRYRUN}}',
+    '--requirement=requirements-lintrunner.txt',
+]
+is_formatter = true
+
+[[linter]]
+code = 'EDITORCONFIG-CHECKER'
+include_patterns=[
+    '**/*.py',
+    '**/*.pyi',
+    '**/*.cc',
+    '**/*.h',
+    '**/*.md',
+    '**/*.cpp',
+    '**/*.yml',
+]
+exclude_patterns = [
+    '*_pb2*',
+    '.setuptools-cmake-build/*',
+    'cmake/**',
+    'docs/Changelog*',
+    'docs/Operators*',
+    'docs/TestCoverage*',
+    'community/sc-election-guidelines.md',
+]
+command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'editorconfig_checker_linter',
+    '--',
+    '@{{PATHSFILE}}'
+]
+init_command = [
+    'python',
+    '-m',
+    'lintrunner_adapters',
+    'run',
+    'pip_init',
+    '--dry-run={{DRYRUN}}',
+    '--requirement=requirements-lintrunner.txt',
+]
diff --git a/.lycheeignore b/.lycheeignore
new file mode 100644
index 0000000..8ad34aa
--- /dev/null
+++ b/.lycheeignore
@@ -0,0 +1,15 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# Used in RFC template as an example
+https://github.com/onnx/onnx/pull/0000
+
+# Behind cloudflare
+https://trademarks.justia.com/877/25/onnx-87725026.html
+https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
+
+# slack blocks automated requests. This is problematic since the invites expire after ~30 days, but lychee is not going to fix that
+https://join.slack.com/t/lfaifoundation/shared_invite/zt-3wx5vohc3-MeSYi3_dscb~u~cqs7zlPg
+# Also blocked:
+https://en.cppreference.com/c/language/identifier
\ No newline at end of file
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..e6552c3
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,102 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# Dependencies are centrally managed by Pixi. Using Pixi is the
+# recommended way to obtain linter-results that match what runs on
+# CI. A fall-back that looks for the tools in PATH is provided, but
+# not recommended.
+#
+# The fall-back logic hinges on the assumption that every supported
+# system provides a `python3` interpreter in PATH. The executed script
+# then looks for Pixi. If found the hooks are executed through its
+# default environment. Otherwise, they are looked for in PATH directly
+# (user-managed).
+repos:
+  - repo: builtin
+    hooks:
+      - id: trailing-whitespace
+        exclude: "^docs/docsgen/source/_static/diff2html"
+      # TODO: Enable this step which creates some churn
+      # - id: end-of-file-fixer
+      #   exclude: "^docs/docsgen/source/_static/diff2html"
+      - id: check-merge-conflict
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: local
+    hooks:
+      - id: ruff-lint
+        name: ruff lint
+        entry: python3 tools/pixi-shim.py ruff check --force-exclude --fix
+        language: system
+        types_or: [python, pyi]
+        exclude: '(_pb2|\.setuptools-cmake-build/|^docs/)'
+        require_serial: true
+
+      - id: ruff-format
+        name: ruff format
+        entry: python3 tools/pixi-shim.py ruff format --force-exclude
+        language: system
+        types_or: [python, pyi]
+        exclude: '(_pb2|\.setuptools-cmake-build/|^cmake/|^docs/)'
+        require_serial: true
+
+      - id: mypy
+        name: mypy
+        entry: python3 tools/pixi-shim.py mypy --config-file=pyproject.toml
+        language: system
+        types: [python]
+        files: "^(onnx|tools)/"
+        exclude: '(^onnx/backend/test/|^onnx/reference/ops/|^onnx/test/|^onnx/reference/reference_evaluator\.py)'
+        require_serial: true
+
+      - id: clang-format
+        name: clang-format
+        entry: python3 tools/pixi-shim.py clang-format -i
+        language: system
+        types_or: [c, c++]
+        files: "^onnx/"
+
+      - id: namespace-check
+        name: namespace check (no hardcoded onnx namespace)
+        entry: python3 tools/pixi-shim.py python tools/check_namespace.py
+        language: system
+        types_or: [c, c++]
+        exclude: "^third_party/"
+
+      # TODO: Enable this step which creates some churn
+      # - id: prettier
+      #   name: prettier
+      #   entry: pixi run prettier --write --list-different
+      #   language: system
+      #   types: [text]
+      #   files: \.(md|yml|yaml)$
+
+      - id: typos
+        name: typos
+        entry: python3 tools/pixi-shim.py typos --force-exclude
+        language: system
+        types: [text]
+        require_serial: true
+        exclude: "^docs/docsgen/"
+
+      # REUSE license compliance
+      - id: reuse
+        name: reuse lint
+        entry: python3 tools/pixi-shim.py reuse lint
+        language: system
+        pass_filenames: false
+
+      - id: shellcheck
+        name: shellcheck
+        entry: python3 tools/pixi-shim.py shellcheck
+        language: system
+        types: [shell]
+
+      - id: zizmor
+        name: zizmor
+        entry: python3 tools/pixi-shim.py zizmor --fix .
+        language: system
+        types: [yaml]
+        pass_filenames: false
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..d06cf00
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,81 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# CLAUDE.md — ONNX Project Guide
+
+ONNX (Open Neural Network Exchange) — open-source standard format for AI models. Python + C++ codebase using protobuf for serialization. Builds and runs on **Linux, macOS, and Windows** — keep all three platforms in mind when making changes.
+
+Also follow the shared AI assistant guidelines in `.github/copilot-instructions.md`.
+
+## Project Norms
+
+- Follow the [ONNX Code of Conduct](https://onnx.ai/codeofconduct.html). All generated code, comments, commit messages, and PR descriptions must be professional, welcoming, and free of hostile, discriminatory, or demeaning language.
+- ONNX is an **open standard** — changes to operator definitions, proto schemas, or the IR spec affect the entire ML ecosystem. Be conservative and deliberate with spec-level changes.
+- Stay **vendor-neutral**. Do not favor any specific framework, runtime, or hardware in code or comments.
+- Preserve **backward compatibility**. Breaking changes to the spec or public API have outsized impact across the ecosystem.
+- Match existing code patterns and conventions — read surrounding code before making changes.
+- Keep PRs focused. Do not bundle unrelated changes or refactor code outside the scope of the task.
+- New operators must follow the process in `docs/AddNewOp.md`.
+
+## Build
+
+```bash
+pip install -e . -v                        # Development install
+ONNX_BUILD_TESTS=1 pip install -e . -v     # With C++ tests
+```
+
+Pure Python changes take effect immediately in editable installs. C++ changes require rebuild.
+
+## Testing
+
+```bash
+pytest                                      # All Python tests
+
+# C++ tests (build with ONNX_BUILD_TESTS=1 first)
+# Linux/macOS:
+LD_LIBRARY_PATH=./.setuptools-cmake-build/ .setuptools-cmake-build/onnx_gtests
+# Windows:
+.setuptools-cmake-build\Release\onnx_gtests.exe
+```
+
+Tests live in `onnx/test/` with `*_test.py` naming.
+
+## Linting
+
+```bash
+lintrunner init    # First-time setup
+lintrunner         # Lint changed files
+lintrunner -a      # Auto-fix
+```
+
+Runs ruff, mypy, clang-format, editorconfig-checker, and a namespace checker.
+
+## Code Conventions
+
+- All Python files require `from __future__ import annotations`
+- No relative imports — use absolute imports from `onnx`
+- Copyright header on all files: `# Copyright (c) ONNX Project Contributors` + `# SPDX-License-Identifier: Apache-2.0`
+- DCO sign-off required on all commits (`git commit -s`)
+
+## Auto-Generated Files (Do Not Edit)
+
+Edit the source, then regenerate. CI verifies these are up to date.
+
+| Generated files | Source of truth | Regenerate with |
+|---|---|---|
+| `docs/Operators.md`, `docs/Changelog.md`, `docs/TestCoverage.md` | Op schemas in `onnx/defs/` | `python onnx/defs/gen_doc.py` |
+| `onnx/*_pb2.py`, `onnx/*_pb.h`, `onnx/onnx_data.proto` | `onnx/onnx.in.proto`, `onnx/onnx-ml.in.proto` | `python onnx/gen_proto.py` |
+| `onnx/backend/test/data/` node tests | Op schemas + reference impl | `python onnx/backend/test/stat_coverage.py` |
+
+Edit `.in.proto` files, **not** `.proto` files. When adding/changing operator schemas, run all three scripts.
+
+## C++/Python Boundary
+
+Core validation (`checker`), shape inference, and version conversion are C++ exposed via nanobind (`onnx_cpp2py_export/`). Operator schemas are defined in C++ under `onnx/defs/`. Helper utilities, reference implementation, parser, and compose are pure Python.
+
+**ONNX_ML flag** (on by default): controls traditional ML types (sequences, maps, sparse tensors). When enabled, builds use `onnx-ml.in.proto` instead of `onnx.in.proto`.
+
+Build artifacts go to `.setuptools-cmake-build/`.
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..6f02a5a
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,681 @@
+# Minimum CMake required
+cmake_minimum_required(VERSION 3.26)
+# Project
+project(onnx LANGUAGES CXX)
+
+include(cmake/Utils.cmake)
+# Honor visibility properties for all target types.
+cmake_policy(SET CMP0063 NEW)
+# Modules FindPython3 and FindPython use LOCATION for lookup strategy.
+cmake_policy(SET CMP0094 NEW)
+
+# Set default build type
+get_property(isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(NOT isMultiConfig AND NOT CMAKE_BUILD_TYPE)
+  message(STATUS "Build type not set - defaulting to Release")
+  set(
+    CMAKE_BUILD_TYPE "Release"
+    CACHE
+      STRING
+      "Choose the type of build from: Debug Release RelWithDebInfo MinSizeRel Coverage."
+    FORCE)
+endif()
+
+# https://reproducible-builds.org/docs/source-date-epoch/
+# cmake's string(TIMESTAMP ...) command reads SOURCE_DATE_EPOCH automatically,
+# which avoids shelling out to `date` (whose flags differ between GNU and BSD).
+string(TIMESTAMP BUILD_DATE "%Y-%m-%d" UTC)
+
+if(NOT BUILD_SHARED_LIBS)
+  # by default, cmake builds static libraries
+  set(BUILD_SHARED_LIBS OFF)
+endif()
+
+
+option(ONNX_BUILD_PYTHON "Build Python binaries" OFF)
+option(ONNX_BUILD_CUSTOM_PROTOBUF "Build and use ONNX's own protobuf" OFF)
+option(ONNX_USE_PROTOBUF_SHARED_LIBS "Build ONNX using protobuf shared library." OFF)
+option(ONNX_GEN_PB_TYPE_STUBS "Generate protobuf python type stubs" ON)
+option(ONNX_WERROR "Build with Werror" OFF)
+option(ONNX_COVERAGE "Build with coverage instrumentation" OFF)
+option(ONNX_BUILD_TESTS "Build ONNX C++ APIs Tests" OFF)
+option(ONNX_USE_ASAN "Build ONNX with ASAN" OFF)
+option(ONNX_HARDENING "Build with compiler hardening flags (OpenSSF guidelines)" OFF)
+option(ONNX_USE_LITE_PROTO "Use lite protobuf instead of full." OFF)
+option(ONNX_DISABLE_EXCEPTIONS "Disable exception handling." OFF)
+option(ONNX_DISABLE_STATIC_REGISTRATION "Disable static registration for ONNX operator schemas." OFF)
+option(ONNX_USE_UNITY_BUILD "Enable Unity (Jumbo) build for" OFF)
+option(ONNX_PYODIDE_BUILD "Build ONNX for Pyodide/Emscripten (wasm32)." OFF)
+option(ONNX_INSTALL "Install ONNX targets, headers, and CMake config files" ON)
+if(WIN32)
+  option(ONNX_USE_MSVC_STATIC_RUNTIME "Build with MSVC static runtime. Ignored if CMAKE_MSVC_RUNTIME_LIBRARY is defined." OFF)
+endif()
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+if(NOT DEFINED ONNX_ML)
+  if(DEFINED ENV{ONNX_ML})
+    set(DEFAULT_ONNX_ML $ENV{ONNX_ML})
+  else()
+    set(DEFAULT_ONNX_ML ON)
+  endif()
+  option(ONNX_ML "Enable traditional ML API." ${DEFAULT_ONNX_ML})
+endif()
+
+if(NOT DEFINED ONNX_VERIFY_PROTO3)
+  if(DEFINED ENV{ONNX_VERIFY_PROTO3})
+    set(PROTO3_ENABLED $ENV{ONNX_VERIFY_PROTO3})
+  else()
+    set(PROTO3_ENABLED OFF)
+  endif()
+  option(ONNX_VERIFY_PROTO3 "Generate code by proto3" ${PROTO3_ENABLED})
+endif()
+
+if(NOT DEFINED CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 17)
+else()
+  if(CMAKE_CXX_STANDARD VERSION_LESS 17)
+    message(FATAL_ERROR "At least C++17 is required.")
+  endif()
+endif()
+
+include(GNUInstallDirs)
+
+set(ONNX_ROOT ${onnx_SOURCE_DIR})
+
+# Read ONNX version
+file(READ "${ONNX_ROOT}/VERSION_NUMBER" ONNX_VERSION)
+string(STRIP "${ONNX_VERSION}" ONNX_VERSION)
+
+# Parse version components for version macros (strip any pre-release suffix like "rc1")
+string(REGEX MATCH "^([0-9]+)\\.([0-9]+)\\.([0-9]+)" _ ${ONNX_VERSION})
+set(ONNX_VERSION_MAJOR ${CMAKE_MATCH_1})
+set(ONNX_VERSION_MINOR ${CMAKE_MATCH_2})
+set(ONNX_VERSION_PATCH ${CMAKE_MATCH_3})
+
+if(NOT MSVC)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor")
+  set(CMAKE_C_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0")
+  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0")
+  if(ONNX_COVERAGE)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+  endif()
+endif()
+
+if(NOT ONNX_NAMESPACE)
+  set(ONNX_NAMESPACE "onnx")
+endif()
+
+if(MSVC)
+  if(NOT ONNX_DISABLE_EXCEPTIONS)
+    string(APPEND CMAKE_CXX_FLAGS " /EHsc /wd26812")
+    string(APPEND CMAKE_C_FLAGS " /EHsc /wd26812")
+  endif()
+  add_compile_options(/MP /utf-8 /nologo)
+  add_compile_options(
+    /wd5287  # https://developercommunity.visualstudio.com/t/warning-C5287:-operands-are-different-e/10877942?sort=newest
+    /Zc:lambda  # https://developercommunity.visualstudio.com/t/fatal--error-C1001:-Internal-compiler-er/10906076
+  )
+endif()
+
+if(ONNX_DISABLE_EXCEPTIONS)
+  add_compile_definitions("ONNX_NO_EXCEPTIONS")
+  # Disable C++ exceptions.
+  if(MSVC)
+    string(REGEX REPLACE "/EHsc" "/EHs-c-" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    add_definitions(-D_HAS_EXCEPTIONS=0)
+  else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables")
+  endif()
+endif()
+
+if(ONNX_BUILD_PYTHON AND ONNX_DISABLE_EXCEPTIONS)
+  message(FATAL_ERROR
+    "ONNX_DISABLE_EXCEPTIONS=ON is incompatible with ONNX_BUILD_PYTHON=ON. "
+    "The Python binding requires exceptions to be enabled.")
+endif()
+
+if(ONNX_BUILD_PYTHON)
+  set(python_dev_component Development.Module Development.SABIModule)
+endif()
+
+if(CMAKE_CROSSCOMPILING)
+  # When cross-compiling, the interpreter and the compiling/linking steps
+  # must use a different package. See the discussion about this at
+  # https://gitlab.kitware.com/cmake/cmake/-/issues/25145
+  if(ONNX_BUILD_PYTHON)
+    find_package(Python3 REQUIRED COMPONENTS ${python_dev_component})
+  endif()
+  find_package(Python REQUIRED COMPONENTS Interpreter)
+  set(ONNX_PYTHON_INTERPRETER Python::Interpreter)
+  if(ONNX_BUILD_PYTHON)
+    # nanobind >= 2.13 only auto-runs its own find_package(Python ...) when
+    # neither Python::Interpreter nor Python::Module exist yet. Since
+    # Python::Interpreter is already provided above (host interpreter, while
+    # Python3::Module above is the cross-compilation target's dev libs),
+    # nanobind would otherwise skip that step and fail to find Python::Module.
+    if(NOT TARGET Python::Module)
+      add_library(Python::Module ALIAS Python3::Module)
+    endif()
+    if(TARGET Python3::SABIModule AND NOT TARGET Python::SABIModule)
+      add_library(Python::SABIModule ALIAS Python3::SABIModule)
+    endif()
+  endif()
+else()
+  find_package(Python3 REQUIRED COMPONENTS Interpreter ${python_dev_component})
+  # Find Python for nanobind
+  set(Python_EXECUTABLE ${Python3_EXECUTABLE})
+  find_package(Python REQUIRED COMPONENTS Interpreter ${python_dev_component})
+  set(ONNX_PYTHON_INTERPRETER Python3::Interpreter)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "AIX")
+  set(CMAKE_NO_SYSTEM_FROM_IMPORTED 1)
+endif()
+
+# Build the libraries with -fPIC including the protobuf lib.
+if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
+  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
+
+list(APPEND CMAKE_MODULE_PATH ${ONNX_ROOT}/cmake/external)
+if(NOT ONNX_BUILD_CUSTOM_PROTOBUF)
+  if((ONNX_USE_LITE_PROTO AND TARGET protobuf::libprotobuf-lite) OR ((NOT ONNX_USE_LITE_PROTO) AND TARGET protobuf::libprotobuf))
+    # Sometimes we need to use protoc compiled for host architecture while linking
+    # libprotobuf against target architecture. See https://github.com/caffe2/caffe
+    # 2/blob/96f35ad75480b25c1a23d6e9e97bccae9f7a7f9c/cmake/ProtoBuf.cmake#L92-L99
+    if(EXISTS "${ONNX_CUSTOM_PROTOC_EXECUTABLE}")
+      message(STATUS "Using custom protoc executable")
+      set(ONNX_PROTOC_EXECUTABLE ${ONNX_CUSTOM_PROTOC_EXECUTABLE})
+    else()
+      if(TARGET protobuf::protoc)
+        set(ONNX_PROTOC_EXECUTABLE $<TARGET_FILE:protobuf::protoc>)
+      endif()
+    endif()
+  else()
+    # Customized version of find Protobuf. We need to avoid situations mentioned
+    # in https://github.com/caffe2/caffe2/blob/b7d983f255ef5496474f1ea188edb5e0ac4
+    # 42761/cmake/ProtoBuf.cmake#L82-L92 The following section is stolen from
+    # cmake/ProtoBuf.cmake in Caffe2
+    find_program(Protobuf_PROTOC_EXECUTABLE
+                NAMES protoc
+                DOC "The Google Protocol Buffers Compiler")
+
+    # Only if protoc was found, seed the include directories and libraries. We
+    # assume that protoc is installed at PREFIX/bin. We use get_filename_component
+    # to resolve PREFIX.
+    if(Protobuf_PROTOC_EXECUTABLE)
+      set(ONNX_PROTOC_EXECUTABLE ${Protobuf_PROTOC_EXECUTABLE})
+      get_filename_component(_PROTOBUF_INSTALL_PREFIX
+                            ${Protobuf_PROTOC_EXECUTABLE} DIRECTORY)
+      get_filename_component(_PROTOBUF_INSTALL_PREFIX
+                            ${_PROTOBUF_INSTALL_PREFIX}/.. REALPATH)
+      find_library(Protobuf_PROTOC_LIBRARY
+                  NAMES protoc
+                  PATHS ${_PROTOBUF_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}
+                  NO_DEFAULT_PATH)
+      if(ONNX_USE_LITE_PROTO)
+        find_library(Protobuf_LITE_LIBRARY
+          NAMES protobuf-lite
+          PATHS ${_PROTOBUF_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}
+          NO_DEFAULT_PATH)
+      else()
+        find_library(Protobuf_LIBRARY
+          NAMES protobuf
+          PATHS ${_PROTOBUF_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}
+          NO_DEFAULT_PATH)
+      endif(ONNX_USE_LITE_PROTO)
+      find_path(Protobuf_INCLUDE_DIR google/protobuf/service.h
+                PATHS ${_PROTOBUF_INSTALL_PREFIX}/include
+                NO_DEFAULT_PATH)
+      if(ONNX_USE_PROTOBUF_SHARED_LIBS)
+        set(Protobuf_USE_STATIC_LIBS OFF)
+      else()
+        set(Protobuf_USE_STATIC_LIBS ON)
+      endif()
+      find_package(Protobuf)
+      if(Protobuf_FOUND)
+        set(PROTOBUF_DIR "${_PROTOBUF_INSTALL_PREFIX}")
+        set(Build_Protobuf OFF)
+        if("${Protobuf_VERSION}" VERSION_GREATER_EQUAL "4.22.0")
+          # There are extra dependencies for protobuf.
+          find_package(absl REQUIRED)
+          find_package(utf8_range)
+          message(STATUS "absl_VERSION: ${absl_VERSION}")
+          set(protobuf_ABSL_USED_TARGETS
+            absl::absl_check
+            absl::absl_log
+            absl::algorithm
+            absl::base
+            absl::bind_front
+            absl::bits
+            absl::btree
+            absl::cleanup
+            absl::cord
+            absl::core_headers
+            absl::debugging
+            absl::die_if_null
+            absl::dynamic_annotations
+            absl::flags
+            absl::flat_hash_map
+            absl::flat_hash_set
+            absl::function_ref
+            absl::hash
+            absl::layout
+            absl::log_initialize
+            absl::log_severity
+            absl::memory
+            absl::node_hash_map
+            absl::node_hash_set
+            absl::optional
+            absl::span
+            absl::status
+            absl::statusor
+            absl::strings
+            absl::synchronization
+            absl::time
+            absl::type_traits
+            absl::utility
+            absl::variant
+            utf8_range::utf8_range
+            utf8_range::utf8_validity
+          )
+        endif()
+      endif()
+    endif()
+  endif()
+endif()
+
+if(ONNX_PYODIDE_BUILD)
+    # Prevent absl from using EM_JS-based symbolize_emscripten.inc which is
+    # incompatible with Emscripten SIDE_MODULE builds (Pyodide).
+    add_compile_definitions(STANDALONE_WASM)
+endif()
+
+if(NOT ONNX_PROTOC_EXECUTABLE)
+    set(Build_Protobuf ON)
+    set(protobuf_MSVC_STATIC_RUNTIME ${ONNX_USE_MSVC_STATIC_RUNTIME})
+
+    include(FetchContent)
+    set(ABSL_PROPAGATE_CXX_STD 1)
+    set(ONNX_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
+    set(ONNX_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+    # Use this setting to build third-party libs.
+    set(BUILD_SHARED_LIBS ${ONNX_USE_PROTOBUF_SHARED_LIBS})
+    # Read dependency URLs/hashes from sbom.cdx.json (single source of truth).
+    sbom_get_dep("abseil-cpp" _absl)
+    sbom_get_dep("protobuf" _protobuf)
+    # Assign ${Protobuf_VERSION} to the version read from sbom.cdx.json like `find_package(Protobuf)` would do.
+    set(Protobuf_VERSION ${_protobuf_VERSION})
+    if(NOT DEFINED ABSL_ENABLE_INSTALL)
+      if(ONNX_BUILD_PYTHON)
+        set(ABSL_ENABLE_INSTALL OFF CACHE BOOL "Enable installation of Abseil targets")
+      else()
+        set(ABSL_ENABLE_INSTALL ON CACHE BOOL "Enable installation of Abseil targets")
+      endif()
+    endif()
+    FetchContent_Declare(
+      absl
+      URL ${_absl_URL}
+      URL_HASH SHA256=${_absl_SHA256}
+    )
+    FetchContent_MakeAvailable(absl)
+    FetchContent_Declare(
+      Protobuf
+      URL ${_protobuf_URL}
+      URL_HASH SHA256=${_protobuf_SHA256}
+    )
+    if(NOT DEFINED protobuf_BUILD_TESTS)
+      set(protobuf_BUILD_TESTS OFF CACHE BOOL "Build protobuf tests")
+    endif()
+    if(EXISTS "${ONNX_CUSTOM_PROTOC_EXECUTABLE}")
+      # We already have a host protoc binary; skip building libprotoc and protoc
+      # (saves compiling code generators for Java, C#, Kotlin, ObjC, etc.)
+      set(protobuf_BUILD_PROTOC_BINARIES OFF CACHE BOOL "Skip building protoc")
+      # libupb is only needed by protoc's code generators; skip it too.
+      set(protobuf_BUILD_LIBUPB OFF CACHE BOOL "Skip building libupb")
+    endif()
+    set(protobuf_WITH_ZLIB OFF CACHE BOOL "Skip zlib support")
+    if(ONNX_BUILD_PYTHON)
+      set(protobuf_INSTALL OFF CACHE BOOL "Skip protobuf install rules")
+    endif()
+    message(STATUS "Download and build Protobuf from ${_protobuf_URL}")
+    FetchContent_MakeAvailable(Protobuf)
+    # utf8_validity.h is included by protobuf headers but its include dir
+    # is only added via include_directories() inside protobuf's directory scope.
+    # Attach it to the protobuf target so ONNX targets can compile .pb.cc files
+    # without introducing a global include path.
+    if(EXISTS "${protobuf_SOURCE_DIR}/third_party/utf8_range")
+      # protobuf::libprotobuf and protobuf::libprotobuf-lite are ALIAS targets
+      # and CMake does not allow target_include_directories on aliases;
+      # resolve to the real targets before adding the utf8_range include path.
+      foreach(_pb_alias libprotobuf libprotobuf-lite)
+        if(TARGET protobuf::${_pb_alias})
+          get_target_property(_pb_real protobuf::${_pb_alias} ALIASED_TARGET)
+          if(NOT _pb_real)
+            set(_pb_real protobuf::${_pb_alias})
+          endif()
+          target_include_directories(
+            ${_pb_real}
+            INTERFACE
+              $<BUILD_INTERFACE:${protobuf_SOURCE_DIR}/third_party/utf8_range>
+          )
+        endif()
+      endforeach()
+    endif()
+    if(EXISTS "${ONNX_CUSTOM_PROTOC_EXECUTABLE}")
+      set(ONNX_PROTOC_EXECUTABLE ${ONNX_CUSTOM_PROTOC_EXECUTABLE})
+    else()
+      set(ONNX_PROTOC_EXECUTABLE $<TARGET_FILE:protobuf::protoc>)
+    endif()
+    # Change back the BUILD_SHARED_LIBS to control the onnx project.
+    set(BUILD_SHARED_LIBS ${ONNX_BUILD_SHARED_LIBS})
+    set(PROTOBUF_DIR "${protobuf_BINARY_DIR}")
+    set(CMAKE_CXX_FLAGS ${ONNX_CMAKE_CXX_FLAGS})
+endif()
+message(STATUS "ONNX_PROTOC_EXECUTABLE: ${ONNX_PROTOC_EXECUTABLE}")
+
+# function(RELATIVE_PROTOBUF_GENERATE_CPP SRCS HDRS ROOT_DIR) from
+# https://github.com/tensorflow/tensorflow/blob/d2c3b873/tensorflow/contrib/cmake/tf_core_framework.cmake
+# to solve the problem that customized dir can't be specified when
+# calling PROTOBUF_GENERATE_CPP.
+function(RELATIVE_PROTOBUF_GENERATE_CPP SRCS)
+  if(NOT ARGN)
+    message(
+      SEND_ERROR
+        "Error: RELATIVE_PROTOBUF_GENERATE_CPP() called without any proto files"
+      )
+    return()
+  endif()
+
+  set(${SRCS})
+  set(_py_files)
+
+  set(GEN_PROTO_PY "${ONNX_ROOT}/onnx/gen_proto.py")
+  set(GENERATED_FILES)
+  foreach(INFILE ${ARGN})
+    set(ABS_FILE "${ONNX_ROOT}/${INFILE}")
+    get_filename_component(FILE_DIR ${ABS_FILE} DIRECTORY)
+    get_filename_component(FILE_WE ${INFILE} NAME_WE)
+    # "onnx-data" check is because we do not want to create/compile an "onnx-data-ml.proto" file
+    if(ONNX_ML AND NOT(FILE_WE STREQUAL "onnx-data"))
+      if(ONNX_NAMESPACE STREQUAL "onnx")
+        set(GENERATED_FILE_WE "${FILE_WE}-ml")
+      else()
+        set(GENERATED_FILE_WE "${FILE_WE}_${ONNX_NAMESPACE}-ml")
+      endif()
+    else()
+      if(ONNX_NAMESPACE STREQUAL "onnx")
+        set(GENERATED_FILE_WE "${FILE_WE}")
+      else()
+        set(GENERATED_FILE_WE "${FILE_WE}_${ONNX_NAMESPACE}")
+      endif()
+    endif()
+    file(RELATIVE_PATH REL_DIR "${ONNX_ROOT}" "${FILE_DIR}")
+    set(OUTPUT_PROTO_DIR "${CMAKE_CURRENT_BINARY_DIR}/${REL_DIR}")
+
+    set(OUTPUT_PB_SRC "${OUTPUT_PROTO_DIR}/${GENERATED_FILE_WE}.pb.cc")
+    set(GENERATED_PROTO "${OUTPUT_PROTO_DIR}/${GENERATED_FILE_WE}.proto")
+    list(APPEND ${SRCS} "${OUTPUT_PB_SRC}")
+
+    if(NOT EXISTS "${OUTPUT_PROTO_DIR}")
+      file(MAKE_DIRECTORY "${OUTPUT_PROTO_DIR}")
+    endif()
+
+    set(GEN_PROTO_ARGS
+        -p
+        "${ONNX_NAMESPACE}"
+        -o
+        "${OUTPUT_PROTO_DIR}"
+        "${FILE_WE}")
+    if(ONNX_ML)
+      list(APPEND GEN_PROTO_ARGS -m)
+    endif()
+    if(ONNX_USE_LITE_PROTO)
+      list(APPEND GEN_PROTO_ARGS -l)
+    endif()
+    if(ONNX_VERIFY_PROTO3)
+        if(NOT ONNX_PROTOC_EXECUTABLE)
+          message(FATAL_ERROR "Protobuf compiler not found")
+        endif()
+        list(APPEND GEN_PROTO_ARGS --protoc_path)
+        list(APPEND GEN_PROTO_ARGS "${ONNX_PROTOC_EXECUTABLE}")
+    endif()
+
+    # Use add_custom_command to avoid re-generate of PROTO files
+    set(deps ${INFILE})
+    if(TARGET protobuf::protoc)
+      list(APPEND deps protobuf::protoc)
+    endif()
+    set(_gen_proto_outputs "${GENERATED_PROTO}")
+    if(ONNX_BUILD_PYTHON)
+      # gen_proto.py also produces a _pb.py re-export wrapper
+      string(REPLACE "-" "_" _stem_py "${FILE_WE}")
+      set(_pb_py "${OUTPUT_PROTO_DIR}/${_stem_py}_pb.py")
+      list(APPEND _gen_proto_outputs "${_pb_py}")
+      list(APPEND _py_files "${_pb_py}")
+    endif()
+
+    add_custom_command(OUTPUT ${_gen_proto_outputs}
+        COMMAND ${ONNX_PYTHON_INTERPRETER} "${GEN_PROTO_PY}" ${GEN_PROTO_ARGS}
+        DEPENDS ${deps}
+        COMMENT "Running gen_proto.py on ${INFILE}")
+    message("Generated: ${GENERATED_PROTO}")
+
+    set(PROTOC_ARGS
+        ${GENERATED_PROTO}
+        -I
+        ${CMAKE_CURRENT_BINARY_DIR}
+        --cpp_out
+        ${CMAKE_CURRENT_BINARY_DIR})
+    if(ONNX_BUILD_PYTHON)
+      list(APPEND PROTOC_ARGS --python_out)
+      if(ONNX_GEN_PB_TYPE_STUBS)
+        list(APPEND PROTOC_ARGS pyi_out:${CMAKE_CURRENT_BINARY_DIR})
+      else()
+        list(APPEND PROTOC_ARGS ${CMAKE_CURRENT_BINARY_DIR})
+      endif()
+    endif()
+    list(APPEND GENERATED_FILES "${GENERATED_PROTO}")
+
+    set(_protoc_outputs "${OUTPUT_PB_SRC}")
+    if(ONNX_BUILD_PYTHON)
+      string(REPLACE "-" "_" _py_stem "${GENERATED_FILE_WE}")
+      set(_pb2_py "${OUTPUT_PROTO_DIR}/${_py_stem}_pb2.py")
+      list(APPEND _protoc_outputs "${_pb2_py}")
+      list(APPEND _py_files "${_pb2_py}")
+      if(ONNX_GEN_PB_TYPE_STUBS)
+        set(_pb2_pyi "${OUTPUT_PROTO_DIR}/${_py_stem}_pb2.pyi")
+        list(APPEND _protoc_outputs "${_pb2_pyi}")
+        list(APPEND _py_files "${_pb2_pyi}")
+      endif()
+    endif()
+
+    add_custom_command(OUTPUT ${_protoc_outputs}
+        COMMAND "${ONNX_PROTOC_EXECUTABLE}" ${PROTOC_ARGS}
+        DEPENDS ${GENERATED_FILES}
+        COMMENT "Running C++ protocol buffer compiler on ${GENERATED_PROTO}")
+  endforeach()
+
+  set(${SRCS} ${${SRCS}} PARENT_SCOPE)
+  set(ONNX_PROTO_PY_FILES ${_py_files} PARENT_SCOPE)
+  set(ONNX_GENERATED_PROTO_FILES ${GENERATED_FILES} PARENT_SCOPE)
+endfunction()
+
+relative_protobuf_generate_cpp(ONNX_PROTO_SRCS
+                               onnx/onnx.in.proto
+                               onnx/onnx-operators.in.proto
+                               onnx/onnx-data.in.proto)
+
+# Serialises the gen_proto.py step so parallel builds don't race writing the
+# generated .proto files; protoc and C++ compilation still overlap afterwards.
+add_custom_target(onnx_proto_gen DEPENDS ${ONNX_GENERATED_PROTO_FILES})
+
+set(LINKED_PROTOBUF_TARGET protobuf::libprotobuf)
+if(ONNX_USE_LITE_PROTO)
+  if(TARGET protobuf::libprotobuf-lite)
+    set(LINKED_PROTOBUF_TARGET protobuf::libprotobuf-lite)
+  endif()
+endif()
+
+# Compile the generated .pb.cc sources in exactly one target: Xcode's build
+# system rejects a protoc custom command shared across several targets.
+add_library(onnx_proto ${ONNX_PROTO_SRCS})
+add_onnx_global_defines(onnx_proto)
+add_dependencies(onnx_proto onnx_proto_gen)
+
+# Core library. Hand-written sources come from target_sources(onnx ...) in the
+# subdirectories; the protobuf objects are pulled in from onnx_proto.
+add_library(onnx $<TARGET_OBJECTS:onnx_proto>)
+add_subdirectory(onnx)
+add_dependencies(onnx onnx_proto)
+set_target_properties(onnx PROPERTIES CXX_VISIBILITY_PRESET hidden)
+add_onnx_global_defines(onnx)
+
+if(ONNX_BUILD_PYTHON)
+  if(BUILD_SHARED_LIBS)
+    # The extension links ONNX internals not on the public ONNX_API surface,
+    # which a hidden-visibility shared libonnx does not export. The wheel always
+    # builds onnx statically; a shared libonnx is for C++ use only.
+    message(FATAL_ERROR
+      "ONNX_BUILD_PYTHON=ON requires a static onnx; do not combine it with "
+      "BUILD_SHARED_LIBS=ON. Use ONNX_BUILD_PYTHON=OFF to build a shared libonnx.")
+  endif()
+  # find system nanobind
+  if(NOT DEFINED nanobind_DIR OR "${nanobind_DIR}" STREQUAL "")
+    execute_process(
+      COMMAND ${Python_EXECUTABLE} -m nanobind --cmake_dir
+      RESULT_VARIABLE NANOBIND_CMAKE_RESULT
+      OUTPUT_VARIABLE NANOBIND_CMAKE_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    if(NANOBIND_CMAKE_RESULT EQUAL 0 AND EXISTS "${NANOBIND_CMAKE_DIR}")
+      set(nanobind_DIR "${NANOBIND_CMAKE_DIR}")
+    endif()
+  endif()
+  find_package(nanobind CONFIG QUIET)
+  if(NOT nanobind_FOUND)
+    if(FETCHCONTENT_FULLY_DISCONNECTED)
+      message(FATAL_ERROR
+        "nanobind not found while FETCHCONTENT_FULLY_DISCONNECTED is ON. "
+        "Provide nanobind locally (nanobind_DIR/CMAKE_PREFIX_PATH) or use a "
+        "FetchContent dependency provider for first-run offline builds.")
+    endif()
+    include(FetchContent)
+    sbom_get_dep("nanobind" _nanobind)
+    FetchContent_Declare(
+      nanobind
+      GIT_REPOSITORY ${_nanobind_URL}
+      GIT_TAG v${_nanobind_VERSION}
+      GIT_SHALLOW TRUE
+    )
+    FetchContent_MakeAvailable(nanobind)
+  endif()
+
+  # Configure nanobind: https://nanobind.readthedocs.io/en/latest/api_cmake.html
+  nanobind_add_module(
+    onnx_cpp2py_export
+    NB_STATIC NB_DOMAIN onnx STABLE_ABI FREE_THREADED LTO
+    "${ONNX_ROOT}/onnx/cpp2py_export.cc")
+  # Force-load the whole (static) archive so the operator schemas' static
+  # initializers are not dropped as apparently-unused. $<LINK_LIBRARY:WHOLE_ARCHIVE,...>
+  # is the portable --whole-archive / -force_load / /WHOLEARCHIVE spelling.
+  target_link_libraries(onnx_cpp2py_export PRIVATE
+    $<LINK_LIBRARY:WHOLE_ARCHIVE,onnx>)
+endif()
+
+add_onnx_compile_options(onnx_proto)
+add_onnx_compile_options(onnx)
+if(TARGET onnx_cpp2py_export)
+  add_onnx_global_defines(onnx_cpp2py_export)
+  add_onnx_compile_options(onnx_cpp2py_export)
+endif()
+if(ONNX_USE_ASAN AND NOT MSVC)
+  find_package(Sanitizer REQUIRED)
+  if(TARGET Sanitizer::address)
+    target_link_libraries(onnx PRIVATE Sanitizer::address)
+    message(STATUS "Use ASAN")
+  endif()
+  if(TARGET Sanitizer::undefined)
+    target_link_libraries(onnx PRIVATE Sanitizer::undefined)
+    message(STATUS "Use UBSAN")
+  endif()
+endif()
+
+if(ONNX_INSTALL)
+  install(DIRECTORY ${ONNX_ROOT}/onnx
+          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+          FILES_MATCHING
+          PATTERN "*.h"
+          PATTERN "backend/test/case" EXCLUDE
+          PATTERN "backend/test/data" EXCLUDE)
+  install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/onnx
+          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+          FILES_MATCHING
+          PATTERN "*.h")
+endif()
+
+configure_file(
+  ${PROJECT_SOURCE_DIR}/cmake/ONNXConfigVersion.cmake.in
+  ${PROJECT_BINARY_DIR}/ONNXConfigVersion.cmake
+  @ONLY)
+configure_file(
+  ${PROJECT_SOURCE_DIR}/cmake/ONNXConfig.cmake.in
+  ${PROJECT_BINARY_DIR}/ONNXConfig.cmake
+  @ONLY)
+if(ONNX_INSTALL)
+  install(FILES
+    ${PROJECT_BINARY_DIR}/ONNXConfigVersion.cmake
+    ${PROJECT_BINARY_DIR}/ONNXConfig.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/ONNX
+    COMPONENT dev)
+endif()
+
+if(ONNX_USE_UNITY_BUILD)
+  # If ONNX_USE_UNITY_BUILD is set to ON, set onnx to use Unity builds.
+  set_target_properties(onnx
+    PROPERTIES
+      UNITY_BUILD ON
+  )
+
+  # With unity build object file could get big, need this switch in MSVC.
+  if(MSVC)
+    target_compile_options(onnx PRIVATE /bigobj)
+  endif()
+# should be enabled for onnx_proto when protobuf can support Unity builds
+endif()
+
+if(ONNX_BUILD_TESTS)
+  find_package(GTest)
+  if(NOT GTest_FOUND)
+    include(googletest)
+  endif()
+endif()
+
+if(ONNX_INSTALL)
+  install(TARGETS
+    onnx onnx_proto
+    EXPORT ONNXTargets DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+  install(EXPORT ONNXTargets
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/ONNX"
+    NAMESPACE ONNX::
+  )
+endif()
+
+if(ONNX_BUILD_PYTHON)
+  install(TARGETS onnx_cpp2py_export LIBRARY DESTINATION onnx)
+  install(FILES ${ONNX_PROTO_PY_FILES} DESTINATION onnx)
+  # PEP 770: embed SBOM in dist-info/sboms/ inside the wheel.
+  if(DEFINED SKBUILD_METADATA_DIR)
+    install(FILES "${CMAKE_SOURCE_DIR}/sbom.cdx.json" DESTINATION "${SKBUILD_METADATA_DIR}/sboms")
+  endif()
+endif()
+
+if(ONNX_BUILD_TESTS)
+  include(${ONNX_ROOT}/cmake/unittest.cmake)
+endif()
+
+include(cmake/summary.cmake)
+onnx_print_configuration_summary()
diff --git a/CODEOWNERS b/CODEOWNERS
new file mode 100644
index 0000000..3379773
--- /dev/null
+++ b/CODEOWNERS
@@ -0,0 +1,18 @@
+# ONNX Project Code Owners
+# See https://github.com/orgs/onnx/teams for team structure
+#
+# https://github.com/onnx/sigs/blob/main/CONTRIBUTORS
+
+* @onnx/sig-archinfra-approvers
+/community  @onnx/steering-committee
+/onnx/defs  @onnx/sig-operators-approvers
+/onnx/defs/parser.* @onnx/sig-archinfra-approvers
+/onnx/defs/printer.* @onnx/sig-archinfra-approvers
+/onnx/backend/test  @onnx/sig-operators-approvers
+/onnx/reference/ops @onnx/sig-operators-approvers
+/docs/AddNewOp.md @onnx/sig-operators-approvers
+/docs/TestCoverage*.md  @onnx/sig-operators-approvers
+/docs/Operators*.md @onnx/sig-operators-approvers
+/docs/OpConventions.md @onnx/sig-operators-approvers
+/docs/Broadcasting.md @onnx/sig-operators-approvers
+/docs/Changelog*.md @onnx/sig-operators-approvers
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..f282992
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1 @@
+The ONNX Code Of Conduct is described at https://onnx.ai/codeofconduct.html
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..d8a0d47
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,271 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Community Involvement and Contribution Guidelines
+
+ONNX is a community project and we welcome your contributions! In addition to contributing code, you can also contribute in many other ways:
+
+- Meetings and Discussions
+
+    Join SIGS, Working Groups, Community meetings to learn about what is needed and then where there is a good fit to interest and areas of expertise, find ways to actively contribute.  Participate in [ONNX technical discussions](https://github.com/onnx/onnx/discussions) on GitHub.  Join the ONNX Slack channels at LF AI and Data, help answer questions and welcome new members.
+
+- Use Cases and Tools
+
+    Develop use cases for ONNX and advocate for ONNX in developer conferences and meetups.  Develop tools that import and export using the ONNX spec, and help grow the community of ONNX users.  Become a champion for ONNX in your company or organization.
+
+- Roadmap and Features
+
+    Understand the ONNX roadmap document, feature priorities, and help implement them.  Become an ONNX code and documentation contributor, and work towards committer status on important repos.
+
+- Releases and Model Zoo
+
+    Help in achieving a release of ONNX, including increasing the number of models in the ONNX Model Zoo that exercise ONNX features.
+
+- Publications and Blogs
+
+    Add to the growing number of arXiv papers that refer to ONNX.  Create blogs, presentations, books, articles and other materials that help increase the adoption of ONNX, and grow the community of users and contributors.
+
+- Steering Committee
+
+    Attend ONNX Steering Committee meetings - they are open to all in the community. Help out where needed and appropriate on SC to-do items. Note that SIG and Working Groups leaders as well as others with demonstrated commitment and contributions to ONNX community may want to self-nominate during the annual SC election cycle.
+
+## Adding a new operator or creating a new version of an existing operator
+
+ONNX is an open standard, and we encourage developers to contribute high
+quality operators to ONNX specification.
+
+Before proposing a new operator, please read [the tutorial](docs/AddNewOp.md).
+
+## Contributing code
+
+You can submit a pull request (PR) with your code. The [SIG](community/sigs.md) or [Working Group](community/working-groups.md) that is responsible for the area of the project your PR touches will review it and merge once any comments are addressed.
+
+### Pixi-based development
+
+The easiest and most reproducible developer experience for this project is provided through [Pixi](https://pixi.prefix.dev/latest/) - a cross-platform package manager based on conda-forge.
+
+Running
+
+```bash
+pixi run install
+```
+
+In the root of this repository compiles and installs the onnx package editably in a pixi-managed environment.
+Optionally, users may subsequently call `ln -s .setuptools-cmake-build/compile_commands.json` on Unix systems to create a `compile_commands.json` symlink where tools such as `clangd` (code navigation) and `clang-tidy` expect it.
+
+Pre-commit hooks, that are identical to those run on CI, can be installed by running:
+
+```bash
+pixi run pre-commit-install
+```
+
+A list of all pixi task is available by running `pixi run`.
+The following is a list of the most common ones:
+
+- `pixi run gen-all` to regenerate all auto-generated files
+- `pixi run gtest` to run the googletest suite
+- `pixi run pytest` to run the Python test suite
+- `pixi run lint` to run the pre-commit hooks on all files
+- `pixi run docs-build` to build the documentation locally (may require a prior `rm -rf .setuptools-cmake-build && pixi run -e docs install`)
+
+The following section provide guidance for developing onnx without Pixi and is not relevant to Pixi users.
+
+### Development
+
+To build ONNX from source please follow the instructions listed [here](https://github.com/onnx/onnx/blob/main/INSTALL.md#build-onnx-from-source).
+
+Then, after you have made changes to Python and C++ files:
+
+- `Python files`: The changes are effective immediately in your installation. You don't need to install these again.
+- `C++ files`: You need to install these again to trigger the native extension build.
+
+Assuming build succeed in the initial step, simply running
+
+```sh
+pip install -e . -v
+```
+
+from onnx root dir should work.
+
+### Folder structure
+
+- `onnx/`: the main folder that all code lies under
+  - `onnx.proto`: the protobuf that contains all the structures
+  - `checker.py`: a utility to check whether a serialized ONNX proto is legal
+  - `shape_inference.py`: a utility to infer types and shapes for ONNX models
+  - `version_converter.py`: a utility to upgrade or downgrade version for ONNX models
+  - `parser.py`: a utility to create an ONNX model or graph from a textual representation
+  - `compose.py`: a utility to merge ONNX models
+  - `helper.py`: tools for graph operation
+  - `defs/`: a subfolder that defines the ONNX operators
+  - `test/`: test files
+
+### Auto generated files
+
+Various files in this project are auto generated and may have to be updated in a PR.
+
+#### Generate operator documentation
+
+Operator docs ([Operators.md](docs/Operators.md), [Operators-ml.md](docs/Operators-ml.md)) and Changelog docs ([Changelog.md](docs/Changelog.md), [Changelog-ml.md](docs/Changelog-ml.md)) are automatically generated based on C++ operator definitions and backend Python snippets. To refresh all these docs, run the following commands from the repo root and commit the results by setting "ONNX_ML=1". By contrast, setting `ONNX_ML=0` will only update `Operators.md` and `Changelog.md`.
+
+```pwsh
+# Windows
+set ONNX_ML=1
+```
+
+```sh
+# UNIX
+export ONNX_ML=1
+pip install -e . -v
+python onnx/defs/gen_doc.py
+```
+
+#### Generate test coverage report
+
+<!-- TODO(justinchuby): Get rid of the need for manually running stat_coverage -->
+
+The test coverage report can be generated by running:
+
+```sh
+python onnx/backend/test/stat_coverage.py
+```
+
+#### Generate protobuf definitions
+
+Variants of the `.proto` files are generated for the default and ml opset using the following commands:
+
+```
+python onnx/gen_proto.py -l
+python onnx/gen_proto.py -l --ml
+```
+
+#### Generate test data
+
+Test ONNX models, their inputs, and expected outputs can be regenerated after updating test cases by running:
+
+```
+python onnx/backend/test/cmd_tools.py generate-data --diff
+```
+
+This will only re-generate test data for test cases that were updated in the current feature branch compared to main.
+
+
+### Coding style
+
+We adopted the [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html) and [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) for this project.
+
+We use `lintrunner` to drive multiple linters defined in `.lintrunner.toml` to lint the codebase.
+
+To run these checks locally, install `lintrunner` and the linters with
+
+```sh
+pip install lintrunner lintrunner-adapters
+lintrunner init
+```
+
+Then lint with
+
+```sh
+lintrunner
+```
+
+format with
+
+```sh
+# Display all lints and apply the fixes
+lintrunner -a
+# Or apply fixes only (faster)
+lintrunner f
+```
+
+Run `lintrunner --help` and see the `.lintrunner.toml` file for more usage examples, as well as instructions on how to adopt new linters.
+
+#### Naming for legacy helper functions in `onnx/defs/*/old.cc`
+
+When adding or renaming helper functions in legacy schema files (`old.cc`), prefer explicit opset-based names over numeric suffixes. This keeps intent clear and avoids ambiguity.
+
+- Prefer `..._opsetN` for a single opset.
+- Prefer `..._opsetN_to_M` for helpers shared across a contiguous opset range.
+- Avoid names like `...1`, `...2`, `..._9`, or `...Opset9`.
+
+Examples: `RNNShapeInference_opset7_to_13`, `PoolOpSchemaGenerator_opset10_to_11`.
+
+### Testing
+
+ONNX uses [pytest](https://docs.pytest.org) as a test driver. To run tests, you'll first need to install pytest:
+
+```sh
+pip install pytest
+```
+
+After installing pytest, run from the root of the repo:
+
+```sh
+pytest
+```
+
+to run the tests.
+
+#### Cpp tests (googletest)
+
+Some functionalities are tested with googletest. Those tests are listed in `test/cpp`, and include tests for shape inference, data propagation, parser, and others.
+
+To run them, first build ONNX with `-DONNX_BUILD_TESTS=1` or `ONNX_BUILD_TESTS=1 pip install -e . -v`.
+
+##### Linux and MacOS
+
+The cpp tests require dynamically linking to built libraries.
+
+```sh
+export LD_LIBRARY_PATH="./.setuptools-cmake-build/:$LD_LIBRARY_PATH"
+.setuptools-cmake-build/onnx_gtests
+```
+
+##### Windows
+
+```pwsh
+# If you set DEBUG=1, use `.setuptools-cmake-build\Debug\onnx_gtests.exe` instead
+.setuptools-cmake-build\Release\onnx_gtests.exe
+```
+
+## DCO
+
+ONNX has adopted the [DCO](https://en.wikipedia.org/wiki/Developer_Certificate_of_Origin). All code repositories under ONNX require a DCO. (ONNX previously used a CLA, which is being replaced with the DCO.)
+
+DCO is provided by including a sign-off-by line in commit messages. Using the `-s` flag for `git commit` will automatically append this line. For example, running `git commit -s -m 'commit info.'` it will produce a commit that has the message `commit info. Signed-off-by: My Name <my_email@my_company.com>`. The DCO bot will ensure commits are signed with an email address that matches the commit author before they are eligible to be merged.
+
+If you are using a GUI like the GitHub web site or GitHub Desktop, you'll need to append the `Signed-off-by: My Name <my_email@my_company.com>` manually to each commit message. For the onnx organization [sign-off](https://github.blog/changelog/2022-06-08-admins-can-require-sign-off-on-web-based-commits/) for web based commits is enabled. When this is activated you will see "Sign off and propose changes" instead of "Propose changes" when you are editing files directly at github. It is recommended to set this setting for your own fork as well. Since in the review process commits are made on this fork.
+
+NOTE: the sign-off is needed for each commit in the PR, not at the PR level.
+
+If you have old commits that are not signed, use the following commands to squash the old PR (original branch) into a single commit. This is an easier way to signoff old commits in old PR.
+
+```bash
+git checkout main
+git checkout -b temporary_patch              # create a new branch as temporary
+git merge --squash original_patch            # copy from old branch
+git branch -d original_patch                 # remove old branch
+git checkout -b original_patch               # create a new branch with the same name (override)
+git commit -m 'type your own commit msg' -s  # signoff that single commit
+git push origin original_patch -f            # forcibly override the old branch`
+```
+
+## CI Pipelines
+
+Every PR needs to pass CIs before merge. CI pipelines details are [here](docs/CIPipelines.md).
+
+## Other developer documentation
+
+- [How to implement ONNX backend (ONNX to something converter)](docs/ImplementingAnOnnxBackend.md)
+- [Backend test infrastructure and how to add tests](docs/OnnxBackendTest.md)
+
+## License
+
+[Apache License v2.0](/LICENSE)
+
+## Code of Conduct
+
+[ONNX Open Source Code of Conduct](http://onnx.ai/codeofconduct.html)
diff --git a/INSTALL.md b/INSTALL.md
new file mode 100644
index 0000000..fa71def
--- /dev/null
+++ b/INSTALL.md
@@ -0,0 +1,261 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Installation
+
+## Official Python packages
+
+ONNX released packages are published in PyPi.
+
+```sh
+pip install onnx  # or pip install onnx[reference] for optional reference implementation dependencies
+```
+
+[ONNX weekly packages](https://pypi.org/project/onnx-weekly/) are published in PyPI to enable experimentation and early testing.
+
+## vcpkg packages
+
+ONNX is in the maintenance list of [vcpkg](https://github.com/microsoft/vcpkg), you can easily use vcpkg to build and install it.
+
+```sh
+git clone https://github.com/microsoft/vcpkg.git
+cd vcpkg
+./bootstrap-vcpkg.bat # For powershell
+./bootstrap-vcpkg.sh # For bash
+./vcpkg install onnx
+```
+
+## Conda packages
+
+A binary build of ONNX is available from [Conda](https://conda.io), in [conda-forge](https://conda-forge.org/):
+
+```sh
+conda install -c conda-forge onnx
+```
+
+### Building ONNX from source in a conda-forge-based environment
+
+A conda-forge-based development environment is provided through the cross-platform [Pixi package manager](https://prefix.dev/).
+The `pixi.toml` file in the root directory defines various tasks for common development workflows.
+Running
+```sh
+pixi run install
+```
+builds the C++ component and installs it as an editable Python package.
+
+After the installation has completed one can run the gtest and pytest suites via the pixi-tasks of the same name:
+
+```sh
+pixi run gtest
+```
+
+and
+
+```sh
+pixi run pytest
+```
+
+
+## Build ONNX from Source with manually managed dependencies
+
+Before building from source uninstall any existing versions of ONNX via `pip uninstall onnx`.
+
+C++17 or higher C++ compiler version is required to build ONNX from source. Still, users can specify their own `CMAKE_CXX_STANDARD` version for building ONNX.
+
+Protobuf is required for ONNX. If you don't have Protobuf installed, ONNX will internally download and build Protobuf for ONNX build.
+
+Or, you can manually install [Protobuf C/C++ libraries and tools](https://github.com/protocolbuffers/protobuf) with specified version before proceeding forward. Then depending on how you installed Protobuf, you need to set environment variable CMAKE_ARGS to "-DONNX_USE_PROTOBUF_SHARED_LIBS=ON" or "-DONNX_USE_PROTOBUF_SHARED_LIBS=OFF". For example, you may need to run the following command:
+
+Linux or Mac:
+
+```sh
+export CMAKE_ARGS="-DONNX_USE_PROTOBUF_SHARED_LIBS=ON"
+```
+
+Windows:
+
+```bat
+set CMAKE_ARGS="-DONNX_USE_PROTOBUF_SHARED_LIBS=ON"
+```
+
+The ON/OFF depends on what kind of Protobuf library you have. Shared libraries are files ending with \*.dll/\*.so/\*.dylib. Static libraries are files ending with \*.a/\*.lib. This option depends on how you get your Protobuf library and how it was built. Because its default value is OFF, you don't need to run the commands above if you'd prefer to use a static Protobuf library.
+
+### Windows
+
+```
+git clone https://github.com/onnx/onnx.git
+cd onnx
+git submodule update --init --recursive
+# prefer lite proto
+set CMAKE_ARGS='-DONNX_USE_LITE_PROTO=ON -DONNX_USE_PROTOBUF_SHARED_LIBS=ON'
+pip install -e . -v
+```
+
+
+#### Old instructions
+
+If you are building ONNX from source, it is recommended that you also build Protobuf locally as a static library. The version distributed with conda-forge is a DLL, but ONNX expects it to be a static library. Building Protobuf locally also lets you control the version of Protobuf. The tested and recommended version is 5.29.2.
+
+The instructions in this README assume you are using Visual Studio 2019. It is recommended that you run all the commands from a shell started from "x64 Native Tools Command Prompt for VS 2019" and keep the build system generator for cmake (e.g., cmake -G "Visual Studio 16 2019") consistent while building Protobuf as well as ONNX.
+
+You can build Protobuf from source by running the following commands:
+
+```bat
+git clone https://github.com/protocolbuffers/protobuf.git
+cd protobuf
+git checkout v5.29.2
+git submodule update --init --recursive
+cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_INSTALL_PREFIX=<protobuf_install_dir> -Dprotobuf_MSVC_STATIC_RUNTIME=OFF -Dprotobuf_BUILD_SHARED_LIBS=OFF -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_BUILD_EXAMPLES=OFF
+cmake --build . --config Release --target install
+```
+
+Then it will be built as a static library and installed to <protobuf_install_dir>. Please add the bin directory(which contains protoc.exe) to your PATH.
+
+```bat
+set CMAKE_PREFIX_PATH=<protobuf_install_dir>;%CMAKE_PREFIX_PATH%
+```
+
+Please note: if your protobuf_install_dir contains spaces, **do not** add quotation marks around it.
+
+Alternative: if you have local Protobuf executable and want to use it for ONNX, you can set ONNX_PROTOC_EXECUTABLE instead.
+
+```bat
+set CMAKE_ARGS=-DONNX_PROTOC_EXECUTABLE=<full_path_to_protoc.exe>
+```
+
+Then you can build ONNX as:
+
+```
+git clone https://github.com/onnx/onnx.git
+cd onnx
+git submodule update --init --recursive
+# prefer lite proto
+set CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON
+pip install -e . -v
+```
+
+### Linux
+
+First, you need to install Protobuf. The minimum Protobuf compiler (protoc) version required by ONNX is 6.31.1.
+
+Ubuntu 20.04 (and newer) users may choose to install Protobuf (which is usually lower than required) via
+
+```sh
+apt-get install python3-pip python3-dev libprotobuf-dev protobuf-compiler
+```
+In this case, ONNX is able to detect and use the system Profobuf. Users of other Linux distributions can use their system package manager to install Profobuf libraries similarly.
+
+A better way is to build and install the required Protobuf version from source. See the instructions below for more details.
+
+<details>
+  <summary> Installing Protobuf from source </summary>
+
+```sh
+  git clone https://github.com/protocolbuffers/protobuf.git
+  cd protobuf
+  git checkout v5.29.2
+  git submodule update --init --recursive
+  mkdir build_source && cd build_source
+  cmake -Dprotobuf_BUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX=/usr -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_POSITION_INDEPENDENT_CODE=ON ..
+  cmake --build . --target install
+```
+
+  Here "-DCMAKE_POSITION_INDEPENDENT_CODE=ON" is crucial. By default static libraries are built without "-fPIC" flag, they are not position independent code. But shared libraries must be position independent code. Python C/C++ extensions(like ONNX) are shared libraries. So if a static library was not built with "-fPIC", it can't be linked to such a shared library.
+
+  Once build is successful, update PATH to include Protobuf paths so that ONNX can find Protobuf.
+
+</details>
+
+Then you can build ONNX as:
+
+```sh
+git clone https://github.com/onnx/onnx.git
+cd onnx
+git submodule update --init --recursive
+# Optional: prefer lite proto
+export CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON
+pip install -e . -v
+```
+
+### Mac
+
+```sh
+brew update
+brew install cmake
+git clone https://github.com/protocolbuffers/protobuf.git
+cd protobuf
+git checkout v5.29.2
+git submodule update --init --recursive
+mkdir build_source && cd build_source
+cmake -Dprotobuf_BUILD_SHARED_LIBS=OFF -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_POSITION_INDEPENDENT_CODE=ON ..
+cmake --build . --target install
+```
+
+Once build is successful, update PATH to include Protobuf paths so that ONNX can find Protobuf.
+
+Then you can build ONNX as:
+
+```sh
+git clone --recursive https://github.com/onnx/onnx.git
+cd onnx
+# Optional: prefer lite proto
+set CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON
+pip install -e . -v
+```
+
+## Verify Installation
+
+After installation, run
+
+```sh
+python -c "import onnx"
+```
+
+to verify it works.
+
+## Common Build Options
+
+For full list refer to CMakeLists.txt
+
+### Environment variables
+
+* `USE_MSVC_STATIC_RUNTIME` should be 1 or 0, not ON or OFF. When set to 1 ONNX links statically to runtime library.
+**Default**: `USE_MSVC_STATIC_RUNTIME=0`
+
+* `DEBUG` should be 0 or 1. When set to 1 ONNX is built in debug mode. For debug versions of the dependencies, you need to open the [CMakeLists file](https://github.com/onnx/onnx/blob/main/CMakeLists.txt) and append a letter `d` at the end of the package name lines. For example, `NAMES protobuf-lite` would become `NAMES protobuf-lited`.
+**Default**: `Debug=0`
+
+### CMake variables
+
+* `ONNX_USE_PROTOBUF_SHARED_LIBS` should be `ON` or `OFF`.
+**Default**: `ONNX_USE_PROTOBUF_SHARED_LIBS=OFF USE_MSVC_STATIC_RUNTIME=0`
+`ONNX_USE_PROTOBUF_SHARED_LIBS` determines how ONNX links to Protobuf libraries.
+  * When set to `ON` - ONNX will dynamically link to Protobuf shared libs, PROTOBUF_USE_DLLS will be defined as described [here](https://github.com/protocolbuffers/protobuf/blob/main/cmake/README.md#dlls-vs-static-linking).
+  * When set to `OFF` - ONNX will link statically to Protobuf.
+
+* `ONNX_USE_LITE_PROTO` should be `ON` or `OFF`. When set to `ON` ONNX uses lite Protobuf instead of full Protobuf.
+**Default**: `ONNX_USE_LITE_PROTO=OFF`
+
+* `ONNX_WERROR` should be `ON` or `OFF`. When set to `ON` warnings are treated as errors.
+**Default**: `ONNX_WERROR=OFF` in local builds, `ON` in CI and release pipelines.
+
+* `nanobind_DIR` can be set to the directory that contains `nanobindConfig.cmake` (for example,
+  `python -m nanobind --cmake_dir`) if CMake cannot find nanobind. You can also set
+  `CMAKE_PREFIX_PATH` instead.
+
+* `FETCHCONTENT_FULLY_DISCONNECTED` is intended for subsequent re-configures after
+  dependencies are already populated. It does not prevent network access on the initial
+  configure; for fully offline first-run builds, prefer a
+  [dependency provider](https://cmake.org/cmake/help/latest/module/FetchContent.html#dependency-providers)
+  or provide dependencies locally (for example, via `nanobind_DIR` or `CMAKE_PREFIX_PATH`).
+
+## Common Errors
+
+* Note: the `import onnx` command does not work from the source checkout directory; in this case you'll see `ModuleNotFoundError: No module named 'onnx.onnx_cpp2py_export'`. Change into another directory to fix this error.
+
+* If you run into any issues while building Protobuf as a static library, please ensure that shared Protobuf libraries, like libprotobuf, are not installed on your device or in the conda environment. If these shared libraries exist, either remove them to build Protobuf from source as a static library, or skip the Protobuf build from source to use the shared version directly.
+
+* If you run into any issues while building ONNX from source, and your error message reads, `Could not find pythonXX.lib`, ensure that you have consistent Python versions for common commands, such as `python` and `pip`. Clean all existing build files and rebuild ONNX again.
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/LICENSES/Apache-2.0.txt b/LICENSES/Apache-2.0.txt
new file mode 100644
index 0000000..137069b
--- /dev/null
+++ b/LICENSES/Apache-2.0.txt
@@ -0,0 +1,73 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+     (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+     (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+     (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+     (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+     You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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.
diff --git a/LICENSES/BSD-2-Clause.txt b/LICENSES/BSD-2-Clause.txt
new file mode 100644
index 0000000..eb3c575
--- /dev/null
+++ b/LICENSES/BSD-2-Clause.txt
@@ -0,0 +1,9 @@
+Copyright (c) <year> <owner>
+
+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.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000..07e3d4e
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,59 @@
+ONNX is licensed under the Apache License, Version 2.0 (see LICENSE).
+
+This product includes software from the following third-party projects, which
+are linked into ONNX wheel builds. Their copyright notices are reproduced below.
+
+---
+
+## abseil-cpp
+
+Copyright 2017 The Abseil Authors.
+
+Version: 20250127.0
+Source: https://github.com/abseil/abseil-cpp
+License: Apache-2.0 (see LICENSE)
+
+---
+
+## protobuf
+
+Copyright 2008 Google Inc.
+
+Version: 25.1
+Source: https://github.com/protocolbuffers/protobuf
+License: Apache-2.0 (see LICENSE)
+
+---
+
+## nanobind
+
+Copyright (c) 2022 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+Version: 2.12.0
+Source: https://github.com/wjakob/nanobind
+License: BSD-3-Clause
+
+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 copyright holder 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..24b9fa4
--- /dev/null
+++ b/README.md
@@ -0,0 +1,141 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+<p align="center"><img width="40%" src="https://github.com/onnx/onnx/raw/main/docs/onnx-horizontal-color.png" /></p>
+
+[![PyPI - Version](https://img.shields.io/pypi/v/onnx.svg)](https://pypi.org/project/onnx)
+[![CI](https://github.com/onnx/onnx/actions/workflows/main.yml/badge.svg)](https://github.com/onnx/onnx/actions/workflows/main.yml)
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/3313/badge)](https://bestpractices.coreinfrastructure.org/projects/3313)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/onnx/onnx/badge)](https://api.securityscorecards.dev/projects/github.com/onnx/onnx)
+[![SLSA 2](https://slsa.dev/images/gh-badge-level2.svg)](https://slsa.dev)
+[![REUSE compliant](https://api.reuse.software/badge/github.com/onnx/onnx)](https://api.reuse.software/info/github.com/onnx/onnx)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![abi3 compatible](https://img.shields.io/badge/abi3-compatible-brightgreen)](https://docs.python.org/3/c-api/stable.html)
+
+[Open Neural Network Exchange (ONNX)](https://onnx.ai) is an open ecosystem that empowers AI developers
+to choose the right tools as their project evolves. ONNX provides an open source format for AI models, both deep learning and traditional ML. It defines an extensible computation graph model, as well as definitions of built-in operators and standard
+data types. Currently we focus on the capabilities needed for inferencing (scoring).
+
+ONNX is [widely supported](http://onnx.ai/supported-tools) and can be found in many frameworks, tools, and hardware. Enabling interoperability between different frameworks and streamlining the path from research to production helps increase the speed of innovation in the AI community. We invite the community to join us and further evolve ONNX.
+
+
+# Use ONNX
+
+* [Documentation of ONNX Python Package](https://onnx.ai/onnx/)
+* [Tutorials for creating ONNX models](https://github.com/onnx/tutorials)
+* [Pre-trained ONNX models](https://github.com/onnx/models)
+
+# Learn about the ONNX spec
+
+* [Overview](https://github.com/onnx/onnx/blob/main/docs/Overview.md)
+* [ONNX intermediate representation spec](https://github.com/onnx/onnx/blob/main/docs/IR.md)
+* [Versioning principles of the spec](https://github.com/onnx/onnx/blob/main/docs/Versioning.md)
+* [Operators documentation](https://github.com/onnx/onnx/blob/main/docs/Operators.md)
+* [Operators documentation](https://onnx.ai/onnx/operators/index.html) (latest release)
+* [Python API Overview](https://github.com/onnx/onnx/blob/main/docs/PythonAPIOverview.md)
+
+# Programming utilities for working with ONNX Graphs
+
+* [Shape and Type Inference](https://github.com/onnx/onnx/blob/main/docs/ShapeInference.md)
+* [Graph Optimization](https://github.com/onnx/optimizer)
+* [Opset Version Conversion](https://github.com/onnx/onnx/blob/main/docs/docsgen/source/api/version_converter.md)
+
+# Contribute
+
+ONNX is a community project and the open governance model is described [here](https://github.com/onnx/onnx/blob/main/community/readme.md). We encourage you to join the effort and contribute feedback, ideas, and code. You can participate in the [Special Interest Groups](https://github.com/onnx/onnx/blob/main/community/sigs.md) and [Working Groups](https://github.com/onnx/onnx/blob/main/community/working-groups.md) to shape the future of ONNX.
+
+Check out our [contribution guide](https://github.com/onnx/onnx/blob/main/CONTRIBUTING.md) to get started.
+
+If you think some operator should be added to ONNX specification, please read
+[this document](https://github.com/onnx/onnx/blob/main/docs/AddNewOp.md).
+
+# Community meetings
+
+The schedules of the regular meetings of the Steering Committee, the working groups and the SIGs can be found [here](https://onnx.ai/calendar)
+
+Community Meetups are held at least once a year. Content from previous community meetups are at:
+
+* 2020.04.09 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14091402/LF+AI+Day+-ONNX+Community+Virtual+Meetup+-+Silicon+Valley+-+2020+April+9>
+* 2020.10.14 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14092138/LF+AI+Day+-+ONNX+Community+Workshop+-+2020+October+14>
+* 2021.03.24 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14092424/Instructions+for+Event+Hosts+-+LF+AI+Data+Day+-+ONNX+Virtual+Community+Meetup+-+March+2021>
+* 2021.10.21 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14093194/LF+AI+Data+Day+ONNX+Community+Virtual+Meetup+-+October+2021>
+* 2022.06.24 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14093969/ONNX+Community+Day+-+2022+June+24>
+* 2023.06.28 <https://lf-aidata.atlassian.net/wiki/spaces/DL/pages/14094507/ONNX+Community+Day+2023+-+June+28>
+
+# Discuss
+
+We encourage you to open [Issues](https://github.com/onnx/onnx/issues), or use [Slack](https://lfaifoundation.slack.com/) (If you have not joined yet, please use this [link](https://join.slack.com/t/lfaifoundation/shared_invite/zt-3wx5vohc3-MeSYi3_dscb~u~cqs7zlPg) to join the group) for more real-time discussion.
+
+# Follow Us
+
+Stay up to date with the latest ONNX news. [[Facebook](https://www.facebook.com/onnxai/)] [[Twitter/X](https://twitter.com/onnxai)]
+
+# Roadmap
+
+A roadmap process takes place every year. More details can be found [here](https://github.com/onnx/steering-committee/tree/main/roadmap)
+
+# Installation
+
+ONNX released packages are published in PyPi.
+
+```sh
+pip install onnx # or pip install onnx[reference] for optional reference implementation dependencies
+```
+
+[ONNX weekly packages](https://pypi.org/project/onnx-weekly/) are published in PyPI to enable experimentation and early testing.
+
+Detailed install instructions, including Common Build Options and Common Errors can be found [here](https://github.com/onnx/onnx/blob/main/INSTALL.md)
+
+# Python ABI3 Compatibility
+
+This package provides [abi3](https://docs.python.org/3/c-api/stable.html)-compatible wheels, allowing a single binary wheel to work across multiple Python versions (from 3.12 onwards).
+
+
+# Testing
+
+ONNX uses [pytest](https://docs.pytest.org) as test driver. In order to run tests, you will first need to install `pytest`:
+
+```sh
+pip install pytest
+```
+
+After installing pytest, use the following command to run tests.
+
+```sh
+pytest
+```
+
+# Development
+
+Check out the [contributor guide](https://github.com/onnx/onnx/blob/main/CONTRIBUTING.md) for instructions.
+
+# Reproducible Builds (Linux)
+
+This project provides reproducible builds for Linux.
+
+A *reproducible build* means that the same source code will always produce identical binary outputs, no matter who builds it or where it is built.
+
+To achieve this, we use the [`SOURCE_DATE_EPOCH`](https://reproducible-builds.org/docs/source-date-epoch/) standard. This ensures that build timestamps and other time-dependent information are fixed, making the output bit-for-bit identical across different environments.
+
+### Why this matters
+- **Transparency**: Anyone can verify that the distributed binaries were created from the published source code.
+- **Security**: Prevents tampering or hidden changes in the build process.
+- **Trust**: Users can be confident that the binaries they download are exactly what the maintainers intended.
+
+If you prefer, you can use the prebuilt reproducible binaries instead of building from source yourself.
+
+# License
+
+[Apache License v2.0](LICENSE)
+
+# Trademark
+Checkout [https://trademarks.justia.com](https://trademarks.justia.com/877/25/onnx-87725026.html) for the trademark.
+
+[General rules of the Linux Foundation on Trademark usage](https://www.linuxfoundation.org/legal/trademark-usage)
+
+# Code of Conduct
+
+[ONNX Open Source Code of Conduct](https://onnx.ai/codeofconduct.html)
diff --git a/README.wehub.md b/README.wehub.md
new file mode 100644
index 0000000..7d52a62
--- /dev/null
+++ b/README.wehub.md
@@ -0,0 +1,7 @@
+# WeHub 来源说明
+
+- 原始项目：`onnx/onnx`
+- 原始仓库：https://github.com/onnx/onnx
+- 导入方式：上游默认分支的最新快照
+- 原作者、版权和许可证信息以原始仓库及本仓库 LICENSE 为准
+- 本文件仅用于记录来源，不代表 WeHub 是原项目作者
diff --git a/RELEASE-MANAGEMENT.md b/RELEASE-MANAGEMENT.md
new file mode 100644
index 0000000..473621a
--- /dev/null
+++ b/RELEASE-MANAGEMENT.md
@@ -0,0 +1,129 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX release management
+
+This describes the process by which versions of ONNX are officially released to the public.
+
+Release Cadence
+---------------
+
+Branch cuts for a new release are planned every 3 months. However, the times can be changed as required.
+
+| Minor Version | Release branch cut | Release date | First patch release date |
+| --- | --- | --- | --- |
+| 1.17.0 | XYZ | XYZ | Not planned |
+| 1.18.0 | Mar 2025 | May 2025 | Not planned |
+| 1.19.0 | 31. July 2025 | 27. August 2025 | 9. October 2025 |
+| 1.20.0  | 31. October 2025 | November 2025 | January 2026 |
+| 1.21.0  | 25. February 2026 | 28. March 2026 | - |
+| 1.22.0 (tbd) | 1st June 2026 | June 2026 | tbd |
+
+## Long-Term Support (LTS)
+
+ONNX does not currently maintain LTS branches. Each minor release is superseded by the next; only the latest release receives ongoing attention. If your environment cannot upgrade and you need a backported security or bug fix, please
+[open an issue](https://github.com/onnx/onnx/issues/new) describing your situation — we will assess feasibility on a case-by-case basis. Community contributions for backport PRs are welcome and will be reviewed.
+
+Release Compatibility Matrix
+----------------------------
+
+*Support for a Python version that went eol will be discontinued in the following ONNX release.*
+*ONNX does NOT follow https://scientific-python.org/specs/spec-0000/ or https://protobuf.dev/support/version-support/*
+
+Changes are discussed in the community. Please do not hesitate to contact us if you have any requests.
+Planned changes for future releases as listed in the table below are subject to change.
+
+|ONNX version	| Python wheels | C++ | Min CMake Version | Min Protobuf | manylinux |
+| --- | --- | --- | --- | --- | --- |
+| 1.10 | 3.6-3.9 | 11 | 3.1 | --- | manylinux2010 |
+| 1.11 | 3.6-3.9 | 11 | 3.1 | 3.12.2 | manylinux2010 |
+| 1.12 | 3.7-3.10 | 11 | 3.1 | 3.12.2 | manylinux2014 |
+| 1.13 | 3.7-3.11 | 11 | 3.1 | 3.20.2 | manylinux2014 |
+| 1.14 | 3.7-3.11 | 11 | 3.1 | 3.20.2 | manylinux2014 |
+| 1.15 | 3.8-3.11 | 14 | 3.1 | 3.20.2 | manylinux2014 |
+| 1.16 | 3.8-3.12 | 17 | 3.1 | 3.20.2 | manylinux2014 |
+| 1.17 | 3.8-3.12 | 17 | 3.14 | 3.20.2 | manylinux2014 |
+| 1.18 | 3.9-3.13, 3.13t (win, mac) | 17 | 3.18 | v25.1 | manylinux2014 |
+| 1.19 | 3.9-3.13, 3.13t (win, mac, linux) | 17 | 3.24 | v25.1 | manylinux2014 |
+| 1.19.1 | 3.9-3.13, 3.13t (win, mac, linux) | 17 | 3.24 | v25.1 | manylinux2014 |
+| 1.20 | 3.10-3.13, 3.13t (win, mac, linux), 3.14 (mac) | 17 | 3.26 | v25.1 | manylinux_2_28 |
+| 1.21 | 3.10-3.13, 3.13t, 3.14, 3.14t | 17 | 3.26 | v25.1 | manylinux_2_28 |
+| *1.22* | 3.10, 3.11, 3.12-abi3, 3.14 (win, mac, linux), 3.14 pyodide | 17 | 3.24 | v25.1 | manylinux_2_28 |
+
+
+Releases
+--------
+
+Releases are versioned according to [ONNX Versioning](docs/Versioning.md). This describes IR and operator versioning policies, as well as propose how models themselves should be versioned.
+
+On a regular basis, new versions of ONNX are published, representing the aggregate of changes in the IR and operator sets. Such releases use semantic versioning to describe the progression of the standard.
+
+The GitHub repo for ONNX provides release branches where the project is stabilized as per the process described here. Release notes are used to communicate the stability and status of a release. The main branch will be used to continue work for subsequent releases.
+
+Major, minor and patch releases will have branch names and version numbers reflecting the nature of the change as per semantic versioning definitions.
+
+Workflow
+--------
+
+The following workflow describes the steps taken to release an update of ONNX,
+and can be undertaken regardless of whether a major, minor or patch release is
+to be produced.
+
+- The trigger for the workflow will typically be a time-based trigger based on
+  elapsed time (say every three months).
+
+- The release manager will announce the intent of the process (to produce
+  major, minor or patch update) and the overall timeline (documented in our
+  wiki: [example](https://github.com/onnx/onnx/wiki/Logistics-for-ONNX-Release-1.19.0).
+  A release branch is created with the name rel-major#.minor#(.patch#), and any version
+  references in build scripts or version checks are updated.
+
+- The release manager announces the initial commit for testing. The first
+  period lasts two weeks; any regressions found should be fixed, typically via
+  the main branch. Incomplete features should be done or excised during this
+  period. A distribution can be made available with an -RC1 suffix.
+
+- The release manager announces a second round of testing (unless it's only a
+  patch update with no regressions found). Only critical bugs are fixed at
+  this point, or those introduced by patches from the first week. A third
+  week may be introduced at the release manager's discretion if significant
+  fixes need to be taken. Distributions with -RCn suffixes can be made
+  available if convenient.
+
+- Release notes are updated with final changes, and a file with sources is
+  provided along with a release on the GitHub project page.
+
+Testing
+-------
+
+The release process really consists of communicating, testing to establish a
+known state of the project, and distributing files. This section deals with
+the second task.
+
+At the very least, the tests that are part of the /test folder should be run
+under a variety of configurations. Issues fixed should ensure coverage in this
+suite to avoid regressions.
+
+Send a Pull Request for updates to this section to include a configuration you
+can help test if you care about one that's missing.
+
+The community is encouraged to perform additional testing during the test
+periods. Bugs and issues should be filed in the ONNX GitHub repo.
+
+# ONNX Weekly Builds on PyPI
+
+In addition to stable releases, we publish **weekly development builds** to a separate PyPI package: [`onnx-weekly`](https://pypi.org/project/onnx-weekly/).
+
+## Why a Separate Package?
+
+- **Avoid accidental installs:** Pre-release versions can be installed unintentionally; `onnx-weekly` ensures stable users are unaffected.
+- **Enable safe testing:** Try upcoming features without impacting stable installs. Both packages can coexist.
+- **Simplify automation:** Weekly builds are pushed automatically from `main` without polluting the main release history.
+
+## Installation
+
+```bash
+pip install onnx-weekly
diff --git a/REUSE.toml b/REUSE.toml
new file mode 100644
index 0000000..7abf599
--- /dev/null
+++ b/REUSE.toml
@@ -0,0 +1,236 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+version = 1
+SPDX-PackageName = "onnx"
+SPDX-PackageSupplier = "onnx-technical-discuss@lists.lfaidata.foundation"
+SPDX-PackageDownloadLocation = "onnx.ai"
+
+[[annotations]]
+path = "codecov.yml"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = [".github/**/**.md", ".github/pull_request_template.md"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ".github/**/**.yml"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/simple/**/test_data_set_0/**pb"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/node/**/test_data_set_0/**.pb"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/simple/**/**.onnx"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/pytorch-operator/**/test_data_set_0/**.pb"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/pytorch-operator/**/**.onnx"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/pytorch-operator/**/**.pb"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/node/**/**.onnx"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/pytorch-converted/**/test_data_set_0/**.pb"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/light/**.onnx"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/light/**.pb"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/real/**/**.json"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/pytorch-converted/**/**.onnx"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/backend/test/data/light/light/**.onnx"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["onnx/onnx-operators**", "onnx/onnx-ml**", "onnx/onnx-data**", "onnx/onnx**"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["docs/docsgen/source/api/**md", "docs/docsgen/source/_static/**", "docs/docsgen/source/onnx-favicon.png"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["onnx/backend/test/stat_coverage.py", "onnx/defs/gen_doc.py"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "docs/Change**.md"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "docs/Test**.md"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "docs/Operator**.md"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = [".gitignore", "**/**/.gitignore", ".gitmodules", ".lintrunner.toml", ".gitattributes", ".git-blame-ignore-revs", ".clang**", ".editorconfig"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["docs/docsgen/source/intro/images/**", "docs/docsgen/source/intro/**md"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["MANIFEST.in", "VERSION_NUMBER", "CODE_OF_CONDUCT.md", "CODEOWNERS", "NOTICE", "pyproject**.toml", "requirements**.txt"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["onnx/onnx_cpp2py_export/**pyi", "onnx/py.typed"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["onnx/defs/**/**.cc", "onnx/defs/**/**.h"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "onnx/reference/ops/aionnxml/**py"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["onnx/defs/**.cc", "onnx/defs/**.h"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["cmake/ONNXConfig**.in", "CMakeLists.txt", "cmake/**cmake", "cmake/", "onnx/test/cmake/CMakeLists.txt"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = [".vscode/settings.json", "docs/docsgen/source/_templates/layout.html", "docs/docsgen/source/_templates/sidebar-nav-bs.html", "docs/images/onnx_hub_arch.svg", "docs/onnx-horizontal-color.png", "tools/protoc-gen-mypy.sh.in"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["onnx/gen_proto.py", "tools/protoc-gen-mypy.bat", "onnx/reference/op_run.py"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["onnx/backend/sample/ops/abs.py", "onnx/gen_proto.py"]
+precedence = "override"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["docs/proposals/images/composing_broadcast_axes.png"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = ["pixi.lock"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "docs/docsgen/source/technical/**.png"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = [".agents/**", ".claude/**", "uv.lock"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
+
+[[annotations]]
+path = "sbom.cdx.json"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "Copyright (c) ONNX Project Contributors"
+SPDX-License-Identifier = "Apache-2.0"
diff --git a/ROADMAP.md b/ROADMAP.md
new file mode 100644
index 0000000..bb88a3e
--- /dev/null
+++ b/ROADMAP.md
@@ -0,0 +1,141 @@
+<!--
+SPDX-FileCopyrightText: Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX 12-Month Roadmap (Q3 2026 – Q2 2027)
+
+> This is a living document and a starting point — not yet a complete picture of all ONNX SIGs and Working Groups.
+> Every group is invited to add or update their milestones below.
+> Milestones are **estimations**, not commitments, unless stated otherwise.
+
+---
+
+## How to contribute
+
+1. Find your SIG/WG section below (or add a new one following the template).
+2. Fill in your objectives per quarter.
+3. Submit a PR or send your input to the roadmap coordinator.
+
+---
+
+## SIGs & Working Groups
+
+---
+
+### SIG Architecture & Infrastructure
+
+**Lead(s):** Andreas Fehlner (TRUMPF Laser), Christian Bourjau (QuantCo)
+
+**Last updated:** 2026-06-24
+
+#### Q3 2026
+- Remove test files from release packages (reduce package size and install surface)
+- Automate and improve SBOM generation and publication
+- Immutable releases (tamper-evident, verifiable artifacts)
+- Convert deprecated branch protection rules to Rules within Github
+- Newer minimal protobuf
+
+#### Q4 2026
+- Move to C++20
+- Begin C++ hardening (compiler flags, static analysis integration)
+- Integrate fuzz testing into CI
+- Define a stable C-API
+
+#### Q1 2027
+- OpenSSF Gold Badge
+- Achieve SLSA Build Level 3 compliance
+
+#### Q2 2027
+- Improved conformance test suite (parameterized, filterable, usable from non-Python runtimes)
+- Continued C++ hardening improvements
+
+---
+
+### Operator SIG
+
+**Lead(s):** G. Ramalingam, Michal Karzynski
+
+**Last updated:** 2026-06-08
+
+Note: The items below may be reprioritized as needed. It may be better to view the following as
+an unprioritized list of items for the next year.
+
+#### Q3 2026:
+- ~~Attention op (fix causal-mask position-anchoring issue)~~ (landing in [#8068](https://github.com/onnx/onnx/pull/8068))
+- Attention op (add support for local window)
+- Attention op (add support for pre-softcap additive bias)
+- Support symbolic shape inference
+
+#### Q4 2026:
+- Variable length scan support
+- LinearAttention (support for Gated DeltaNet-2)
+
+#### Q1 2027:
+- Support Mixture-of-Exports (possibly via Grouped MatMul operator)
+- RotaryEmbedding for visual models (2D)
+
+#### Q2 2027:
+- Support for ternary-value quantization and single-bit quantization
+- FlexAttention
+
+### SONNX Working Group
+
+**Lead(s):** Eric JENN, Jean SOUYRIS
+**Last updated:** 2026-06-01
+
+#### Q3 2026
+- First subset of ONNX operators (i) fully specified in compliance with the SONNX guidelines, (ii) fully formally specified and proved, (iii) implemented, (iv) tested and (v) integrated in the AIDGE framework.
+- Final version of the informal specification guidelines.
+- First version of the formal specification guidelines.
+- First version of the verification guidelines (testing).
+- First version of the graph execution semantics formally specified (excluding control flow ops).
+
+#### Q4 2026
+- Second subset of ONNX operators (i) fully specified in compliance with the SONNX guidelines, (ii) fully formally specified and proved, (iii) implemented, (iv) tested and (v) integrated in the AIDGE framework.
+- Final version of the formal specification guidelines.
+- First version of the numerical accuracy analysis guidelines.
+
+#### Q1 2027
+- Third subset of ONNX operators (i) fully specified in compliance with the SONNX guidelines, (ii) fully formally specified and proved, (iii) implemented, (iv) tested and (v) integrated in the AIDGE framework.
+- Final version of the numerical accuracy analysis guidelines.
+- Final version of the verification guidelines (all techniques).
+- First subset of operators with numerical accuracy analysis.
+- Final version of the graph execution formal specification (including control flow ops).
+
+#### Q2 2027
+- Fourth subset of ONNX operators (i) fully specified in compliance with the SONNX guidelines, (ii) fully formally specified and proved, (iii) implemented, (iv) tested and (v) integrated in the AIDGE framework.
+- Second subset of operators with numerical accuracy analysis.
+
+---
+
+
+### [SIG/WG Name]
+
+**Lead(s):** _TBD_
+**Last updated:** _YYYY-MM-DD_
+
+#### Q3 2026
+- _Objective 1_
+- _Objective 2_
+- _Objective 3_
+
+#### Q4 2026
+- _Objective 1_
+- _Objective 2_
+- _Objective 3_
+
+#### Q1 2027
+- _Objective 1_
+- _Objective 2_
+- _Objective 3_
+
+#### Q2 2027
+- _Objective 1_
+- _Objective 2_
+- _Objective 3_
+
+---
+
+<!-- Add additional SIG/WG sections by copying the template block above -->
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000..344a0db
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,73 @@
+<!--
+SPDX-FileCopyrightText: Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Security Policy
+
+## Reporting a Vulnerability
+
+Bugs, even safety-critical ones, that are easily discovered using widely available tooling are considered publicly known.
+Please open a public issue or PR if you discovered an issue in this manner.
+If you believe you have discovered a non-trivial security vulnerability in ONNX that does not fall into the above category, please report it privately using GitHub Security Advisories.
+
+👉 Open a private report: https://github.com/onnx/onnx/security/advisories/new
+
+This allows maintainers to triage the issue, collaborate on a fix, and coordinate disclosure.
+
+If you are unable to use GitHub for reporting, you may contact the maintainers at onnx-security@lists.lfaidata.foundation as a fallback.
+
+After your report is received, a maintainer will acknowledge it, work with you to understand impact and remediation, and keep you informed about progress toward a fix and public disclosure. We aim to provide an initial response within 14 business days. ONNX is a volunteer-driven open-source project, so response times may vary.
+
+Please do not disclose the vulnerability publicly until a fix and advisory have been released.
+
+Reporters are credited in the published advisory unless they request to remain anonymous.
+
+## Response Process
+
+Once a report is received, maintainers follow this process:
+
+1. **Confirm.** Verify the report describes a genuine security issue (not an ordinary bug or feature request) and assign an incident lead from the security team (the GitHub team with access to private advisories). The GitHub Security Advisory draft serves as the private coordination channel.
+2. **Triage.** Assess severity case by case using [CVSS](https://www.first.org/cvss/) (v3.1 is preferred, but v4.0 is also accepted).
+The security team decides per incident whether the fix warrants an out-of-cycle patch release or can be included in the next scheduled release. Not every report results in a CVE — a CVE is issued only when there is a confirmed, exploitable vulnerability with real-world impact.
+Reports describing expected behavior, unrealistic preconditions, or issues outside the project's threat model may be closed without a CVE.
+3. **Fix.** A patch is developed in a private fork or Security Advisory draft and reviewed by a second maintainer.
+4. **Disclose.** Merge the fix and release the patched version, then publish the GitHub Security Advisory — this requests a CVE if applicable and serves as the public announcement.
+
+Out-of-cycle releases are triggered for confirmed Critical/High vulnerabilities or active exploitation.
+
+## Security announcements
+
+Security advisories are published via GitHub Security Advisories. Users depending on ONNX will be notified automatically via GitHub's dependency graph.
+
+## Security Requirements
+
+Open Neural Network Exchange (ONNX) manages reported vulnerabilities according to its documented security policy and delivers remediations in maintained releases. The project employs established secure development practices such as automated testing, continuous integration, and tooling intended to identify defects during development. Third-party dependencies and build components are periodically reviewed and updated to address known issues and to mitigate supply-chain risk. ONNX does not guarantee that models or inputs are trustworthy, and operators are responsible for validating provenance and applying appropriate isolation, resource limits, and runtime safeguards when executing untrusted workloads.
+
+For the project's threat model, secure design principles, and the weaknesses they mitigate, see the [Security Assurance Case](docs/AssuranceCase.md).
+
+## Supply Chain Security
+
+ONNX release artifacts (wheels and source distributions) meet [SLSA Build Level 2](https://slsa.dev/spec/v1.0/levels#build-l2). Artifacts published to PyPI from this repository's GitHub Actions workflows have a corresponding signed provenance attestation generated by GitHub Actions and stored in GitHub's attestation store.
+
+### Verifying attestations
+
+Install the [GitHub CLI](https://cli.github.com/) and run:
+
+```bash
+gh attestation verify <artifact> --owner onnx
+```
+
+For example:
+
+```bash
+pip download onnx --no-deps -d ./dist
+gh attestation verify ./dist/onnx-*.whl --owner onnx
+```
+
+A successful verification confirms that the artifact was built by GitHub Actions in the `onnx/onnx` repository and has not been tampered with since it was built.
+
+### Software Bill of Materials (SBOM)
+
+Each wheel also embeds a [CycloneDX 1.7](https://cyclonedx.org/) SBOM (`.cdx.json`) listing the bundled third-party components shipped inside the wheel (e.g. statically linked C++ libraries).
diff --git a/VERSION_NUMBER b/VERSION_NUMBER
new file mode 100644
index 0000000..a6c2798
--- /dev/null
+++ b/VERSION_NUMBER
@@ -0,0 +1 @@
+1.23.0
diff --git a/cmake/ONNXConfig.cmake.in b/cmake/ONNXConfig.cmake.in
new file mode 100644
index 0000000..aa1ef47
--- /dev/null
+++ b/cmake/ONNXConfig.cmake.in
@@ -0,0 +1,12 @@
+# - Config file for the ONNX package
+# It defines ONNX targets for other cmake libraries to use.
+
+# library version information
+set(ONNX_VERSION "@ONNX_VERSION@")
+
+if(NOT @ONNX_USE_PROTOBUF_SHARED_LIBS@)
+  find_package(Protobuf REQUIRED CONFIG)
+endif()
+
+# import targets
+include ("${CMAKE_CURRENT_LIST_DIR}/ONNXTargets.cmake")
diff --git a/cmake/ONNXConfigVersion.cmake.in b/cmake/ONNXConfigVersion.cmake.in
new file mode 100644
index 0000000..a25c168
--- /dev/null
+++ b/cmake/ONNXConfigVersion.cmake.in
@@ -0,0 +1,11 @@
+set(PACKAGE_VERSION "@ONNX_VERSION@")
+
+# Check whether the requested PACKAGE_FIND_VERSION is compatible
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  if (PACKAGE_VERSION VERSION_EQUAL PACKAGE_FIND_VERSION)
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()
diff --git a/cmake/Utils.cmake b/cmake/Utils.cmake
new file mode 100644
index 0000000..44e306a
--- /dev/null
+++ b/cmake/Utils.cmake
@@ -0,0 +1,208 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Look up a dependency by name in sbom.cdx.json and set URL, SHA256, and VERSION
+# variables in the caller's scope. For example:
+#   sbom_get_dep("abseil-cpp" _absl)
+# sets _absl_URL, _absl_SHA256, _absl_VERSION.
+function(sbom_get_dep dep_name prefix)
+  file(READ "${CMAKE_CURRENT_SOURCE_DIR}/sbom.cdx.json" _sbom)
+  string(JSON _count LENGTH "${_sbom}" "components")
+  foreach(_i RANGE 0 ${_count})
+    if(_i EQUAL _count)
+      break()
+    endif()
+    string(JSON _name GET "${_sbom}" "components" ${_i} "name")
+    if(_name STREQUAL "${dep_name}")
+      string(JSON _url GET "${_sbom}" "components" ${_i} "externalReferences" 0 "url")
+      string(JSON _version GET "${_sbom}" "components" ${_i} "version")
+      set(${prefix}_URL "${_url}" PARENT_SCOPE)
+      set(${prefix}_VERSION "${_version}" PARENT_SCOPE)
+      # SHA256 is optional (e.g. git-only deps like nanobind).
+      string(JSON _hash_count ERROR_VARIABLE _err LENGTH "${_sbom}" "components" ${_i} "hashes")
+      if(_hash_count AND _hash_count GREATER 0)
+        string(JSON _sha256 GET "${_sbom}" "components" ${_i} "hashes" 0 "content")
+        set(${prefix}_SHA256 "${_sha256}" PARENT_SCOPE)
+      else()
+        set(${prefix}_SHA256 "" PARENT_SCOPE)
+      endif()
+      return()
+    endif()
+  endforeach()
+  message(FATAL_ERROR "Dependency '${dep_name}' not found in sbom.cdx.json")
+endfunction()
+
+# Compiler hardening flags based on OpenSSF guidelines:
+# https://best.openssf.org/Compiler-Hardening-Guides/Compiler-Options-Hardening-Guide-for-C-and-C++.html
+function(add_onnx_hardening_flags target)
+  if(NOT ONNX_HARDENING)
+    return()
+  endif()
+
+  if(MSVC)
+    # MSVC hardening compile flags
+    target_compile_options(${target} PRIVATE
+      /GS        # Buffer security checks
+      /guard:cf  # Control Flow Guard
+      /sdl       # Security Development Lifecycle checks
+    )
+    # MSVC hardening linker flags
+    target_link_options(${target} PRIVATE
+      /DYNAMICBASE  # ASLR
+      /NXCOMPAT     # Data Execution Prevention
+      /guard:cf     # Control Flow Guard (linker side)
+    )
+    # CET shadow stack requires VS 2019 (MSVC 19.20+) and is x86/x64 only
+    if(MSVC_VERSION GREATER_EQUAL 1920 AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86|x64|X86|AMD64")
+      target_link_options(${target} PRIVATE /CETCOMPAT)
+    endif()
+  else()
+    # GCC/Clang hardening compile flags
+    target_compile_options(${target} PRIVATE
+      -Wformat
+      -Wformat=2
+      -Wimplicit-fallthrough
+      -Werror=format-security
+      -fstack-protector-strong
+      -fno-delete-null-pointer-checks
+      -fno-strict-overflow
+      -fno-strict-aliasing
+    )
+
+    # Zero-initialize uninitialized stack variables (requires compiler support)
+    include(CheckCXXCompilerFlag)
+    check_cxx_compiler_flag(-ftrivial-auto-var-init=zero COMPILER_SUPPORTS_AUTO_VAR_INIT)
+    if(COMPILER_SUPPORTS_AUTO_VAR_INIT)
+      target_compile_options(${target} PRIVATE -ftrivial-auto-var-init=zero)
+    endif()
+
+    # _FORTIFY_SOURCE requires optimization and conflicts with sanitizers
+    if(NOT ONNX_USE_ASAN)
+      target_compile_options(${target} PRIVATE
+        -U_FORTIFY_SOURCE
+        -D_FORTIFY_SOURCE=3
+      )
+    endif()
+
+    # C++ standard library assertions
+    target_compile_definitions(${target} PRIVATE _GLIBCXX_ASSERTIONS)
+
+    # Stack clash protection (Linux only - not supported on macOS)
+    if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+      include(CheckCXXCompilerFlag)
+      check_cxx_compiler_flag(-fstack-clash-protection COMPILER_SUPPORTS_STACK_CLASH)
+      if(COMPILER_SUPPORTS_STACK_CLASH)
+        target_compile_options(${target} PRIVATE -fstack-clash-protection)
+      endif()
+    endif()
+
+    # Control-flow protection for x86_64 (Linux only - not supported on macOS)
+    if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64")
+      include(CheckCXXCompilerFlag)
+      check_cxx_compiler_flag(-fcf-protection=full COMPILER_SUPPORTS_CF_PROTECTION)
+      if(COMPILER_SUPPORTS_CF_PROTECTION)
+        target_compile_options(${target} PRIVATE -fcf-protection=full)
+      endif()
+    endif()
+
+    # Branch protection for AArch64 (Linux only - macOS uses different mechanism)
+    if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
+      include(CheckCXXCompilerFlag)
+      check_cxx_compiler_flag(-mbranch-protection=standard COMPILER_SUPPORTS_BRANCH_PROTECTION)
+      if(COMPILER_SUPPORTS_BRANCH_PROTECTION)
+        target_compile_options(${target} PRIVATE -mbranch-protection=standard)
+      endif()
+    endif()
+
+    # Linker hardening flags (Linux only, not macOS)
+    if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+      target_link_options(${target} PRIVATE
+        -Wl,-z,noexecstack
+        -Wl,-z,relro
+        -Wl,-z,now
+      )
+    endif()
+  endif()
+endfunction()
+
+# Adjusts the MSVC_RUNTIME_LIBRARY property for a given target.
+# If CMAKE_MSVC_RUNTIME_LIBRARY is defined, we assume the user wants to explicitly use that value.
+# If not, we respect ONNX_USE_MSVC_STATIC_RUNTIME and delegate to the static/dynamic lib respectively,
+# with Debug builds using the debug libs.
+function(add_msvc_runtime_flag lib)
+  if(DEFINED CMAKE_MSVC_RUNTIME_LIBRARY)
+    # Don't do anything here and respect parent-project provided value.
+    # CMake will have already associated the default value with our target.
+    message(STATUS "Ignoring ONNX_USE_MSVC_STATIC_RUNTIME since CMAKE_MSVC_RUNTIME_LIBRARY is defined.")
+  else()
+    if(ONNX_USE_MSVC_STATIC_RUNTIME)
+      set_target_properties(${lib} PROPERTIES
+        MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+      )
+    else()
+      set_target_properties(${lib} PROPERTIES
+        MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL"
+      )
+    endif()
+  endif()
+endfunction()
+
+function(add_onnx_global_defines target)
+  target_compile_definitions(${target}
+                             PUBLIC "ONNX_NAMESPACE=${ONNX_NAMESPACE}")
+
+  if(ONNX_ML)
+    target_compile_definitions(${target} PUBLIC "ONNX_ML=1")
+  endif()
+
+  if(ONNX_USE_LITE_PROTO)
+    target_compile_definitions(${target} PUBLIC "ONNX_USE_LITE_PROTO=1")
+  endif()
+
+  if(ONNX_DISABLE_STATIC_REGISTRATION)
+    target_compile_definitions(${target}
+                               PUBLIC "__ONNX_DISABLE_STATIC_REGISTRATION")
+  endif()
+endfunction()
+
+function(add_onnx_compile_options target)
+  if(MSVC)
+    add_msvc_runtime_flag(${target})
+    if(ONNX_WERROR)
+      target_compile_options(${target} PRIVATE "/WX")
+    endif()
+  else()
+    target_compile_options(${target} PRIVATE -Wall -Wextra)
+    if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION
+                                    VERSION_GREATER_EQUAL 13)
+      target_compile_options(${target} PRIVATE "-Wno-stringop-overflow")
+    endif()
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+      target_compile_options(${target} PRIVATE "-Wno-shorten-64-to-32")
+    endif()
+    if(ONNX_WERROR)
+      target_compile_options(${target} PRIVATE "-Werror")
+    endif()
+  endif()
+  target_include_directories(
+    ${target}
+    PUBLIC $<BUILD_INTERFACE:${ONNX_ROOT}> $<INSTALL_INTERFACE:include>
+           $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+  target_link_libraries(${target} PUBLIC ${LINKED_PROTOBUF_TARGET})
+  get_target_property(_onnx_linked_protobuf_is_imported ${LINKED_PROTOBUF_TARGET} IMPORTED)
+  foreach(ABSL_USED_TARGET IN LISTS protobuf_ABSL_USED_TARGETS)
+    if(TARGET ${ABSL_USED_TARGET})
+      target_link_libraries(${target} PUBLIC ${ABSL_USED_TARGET})
+      if(NOT _onnx_linked_protobuf_is_imported)
+        add_dependencies(${LINKED_PROTOBUF_TARGET} ${ABSL_USED_TARGET})
+      endif()
+    endif()
+  endforeach()
+  # Prevent "undefined symbol: _ZNSt10filesystem7__cxx114path14_M_split_cmptsEv"
+  # (std::filesystem::__cxx11::path::_M_split_cmpts()) on gcc 8
+  if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
+    target_link_libraries(${target} PRIVATE "-lstdc++fs")
+  endif()
+
+  # Apply hardening flags if enabled
+  add_onnx_hardening_flags(${target})
+endfunction()
diff --git a/cmake/external/FindSanitizer.cmake b/cmake/external/FindSanitizer.cmake
new file mode 100644
index 0000000..56be1aa
--- /dev/null
+++ b/cmake/external/FindSanitizer.cmake
@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Find sanitizers
+#
+# This module sets the following targets:
+#  Sanitizer::address
+#  Sanitizer::thread
+#  Sanitizer::undefined
+#  Sanitizer::memory
+include_guard(GLOBAL)
+
+option(UBSAN_FLAGS "additional UBSAN flags" OFF)
+option(MSAN_FLAGS "additional MSAN flags" OFF)
+
+get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
+
+set(_source_code
+    [==[
+  #include <stdio.h>
+  int main() {
+  printf("hello world!");
+  return 0;
+  }
+  ]==])
+
+set(_bug_address_code
+    [==[
+#include <stdlib.h>
+int main(int argc, char **argv) {
+  int *array = (int*)malloc(100*sizeof(int));
+  array[0] = 0;
+  int res = array[argc + 100];  // BOOM
+  free(array);
+  return res;
+}
+]==])
+
+set(_bug_undefined_code
+    [==[
+int main(int argc, char **argv) {
+  int k = 0x7fffffff;
+  k += argc;
+  return 0;
+}
+]==])
+
+include(CMakePushCheckState)
+foreach(lang IN LISTS languages)
+  if(lang STREQUAL C)
+    include(CheckCSourceCompiles)
+    include(CheckCSourceRuns)
+  elseif(lang STREQUAL CXX)
+    include(CheckCXXSourceCompiles)
+    include(CheckCXXSourceRuns)
+  else()
+    continue()
+  endif()
+  foreach(sanitizer_name IN ITEMS address thread undefined memory)
+    if(TARGET Sanitizer::${sanitizer_name}_${lang})
+      continue()
+    endif()
+    if(CMAKE_${lang}_COMPILER_ID STREQUAL "MSVC")
+      if(sanitizer_name STREQUAL "address")
+        set(SANITIZER_FLAGS "/fsanitize=${sanitizer_name}")
+      else()
+        continue()
+      endif()
+    else()
+      set(SANITIZER_FLAGS
+          "-fsanitize=${sanitizer_name};-fno-omit-frame-pointer")
+    endif()
+    if(sanitizer_name STREQUAL "undefined" AND UBSAN_FLAGS)
+      list(APPEND SANITIZER_FLAGS "${UBSAN_FLAGS}")
+    endif()
+    if(sanitizer_name STREQUAL "memory")
+      list(APPEND SANITIZER_FLAGS "-fsanitize-memory-track-origins=2")
+      if(MSAN_FLAGS)
+        list(APPEND SANITIZER_FLAGS "${MSAN_FLAGS}")
+      endif()
+    endif()
+    cmake_push_check_state(RESET)
+    set(CMAKE_REQUIRED_QUIET ON)
+    string(REPLACE ";" " " CMAKE_REQUIRED_FLAGS "${SANITIZER_FLAGS}")
+
+    set(SANITIZER_LINK_FLAGS)
+    if(CMAKE_${lang}_COMPILER_ID STREQUAL "MSVC")
+      list(APPEND SANITIZER_LINK_FLAGS "/INCREMENTAL:NO")
+    else()
+      list(APPEND SANITIZER_LINK_FLAGS "-fsanitize=${sanitizer_name}")
+    endif()
+    set(CMAKE_REQUIRED_LINK_OPTIONS "${SANITIZER_LINK_FLAGS}")
+
+    unset(__res CACHE)
+    if(lang STREQUAL C)
+      if(CMAKE_${lang}_COMPILER_ID STREQUAL "MSVC")
+        check_c_source_compiles("${_source_code}" __res)
+      else()
+        check_c_source_runs("${_source_code}" __res)
+      endif()
+    else()
+      if(CMAKE_${lang}_COMPILER_ID STREQUAL "MSVC")
+        check_cxx_source_compiles("${_source_code}" __res)
+      else()
+        check_cxx_source_runs("${_source_code}" __res)
+      endif()
+    endif()
+    if(NOT __res)
+      message(WARNING "Can't find ${sanitizer_name} in ${lang}")
+      cmake_pop_check_state()
+      continue()
+    endif()
+
+    unset(__res CACHE)
+    if(NOT CMAKE_${lang}_COMPILER_ID STREQUAL "MSVC" AND (sanitizer_name STREQUAL "address") OR (sanitizer_name STREQUAL "undefined"))
+      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fno-sanitize-recover=all")
+      if(lang STREQUAL C)
+        check_c_source_runs("${_bug_${sanitizer_name}_code}" __res)
+      else()
+        check_cxx_source_runs("${_bug_${sanitizer_name}_code}" __res)
+      endif()
+      if(__res)
+        message(WARNING "Buffer overflow bug is not detected in ${lang} ${sanitizer_name}")
+        cmake_pop_check_state()
+        continue()
+      endif()
+    endif()
+
+    add_library(Sanitizer::${sanitizer_name}_${lang} INTERFACE IMPORTED GLOBAL)
+    if(NOT TARGET Sanitizer::${sanitizer_name})
+      add_library(Sanitizer::${sanitizer_name} INTERFACE IMPORTED GLOBAL)
+    endif()
+    target_link_libraries(Sanitizer::${sanitizer_name}
+                          INTERFACE Sanitizer::${sanitizer_name}_${lang})
+    foreach(SANITIZER_FLAG IN LISTS SANITIZER_FLAGS)
+      target_compile_options(
+        Sanitizer::${sanitizer_name}_${lang}
+        INTERFACE $<$<COMPILE_LANGUAGE:${lang}>:${SANITIZER_FLAG}>)
+    endforeach()
+    foreach(SANITIZER_FLAG IN LISTS SANITIZER_LINK_FLAGS)
+      target_link_options(Sanitizer::${sanitizer_name}_${lang} INTERFACE
+                          $<$<COMPILE_LANGUAGE:${lang}>:${SANITIZER_FLAG}>)
+    endforeach()
+
+    if(CMAKE_${lang}_COMPILER_ID STREQUAL "Clang")
+      target_compile_options(
+        Sanitizer::${sanitizer_name}_${lang}
+        INTERFACE $<$<COMPILE_LANGUAGE:${lang}>:-shared-libsan>)
+    endif()
+
+    if(sanitizer_name STREQUAL "address" AND lang STREQUAL CXX)
+      if(CMAKE_${lang}_COMPILER_ID STREQUAL "MSVC")
+        target_compile_definitions(
+          Sanitizer::${sanitizer_name}_${lang}
+          INTERFACE $<$<COMPILE_LANGUAGE:${lang}>:_DISABLE_VECTOR_ANNOTATION>
+                    $<$<COMPILE_LANGUAGE:${lang}>:_DISABLE_STRING_ANNOTATION>)
+      else()
+        target_compile_definitions(
+          Sanitizer::${sanitizer_name}_${lang}
+          INTERFACE
+            $<$<COMPILE_LANGUAGE:${lang}>:_GLIBCXX_SANITIZE_VECTOR>
+            $<$<COMPILE_LANGUAGE:${lang}>:_GLIBCXX_SANITIZE_STD_ALLOCATOR>)
+      endif()
+    endif()
+    cmake_pop_check_state()
+  endforeach()
+endforeach()
diff --git a/cmake/external/googletest.cmake b/cmake/external/googletest.cmake
new file mode 100644
index 0000000..b984283
--- /dev/null
+++ b/cmake/external/googletest.cmake
@@ -0,0 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+include(FetchContent)
+FetchContent_Declare(
+  googletest
+  # Specify the commit you depend on and update it regularly.
+  URL https://github.com/google/googletest/releases/download/v1.17.0/googletest-1.17.0.tar.gz
+  URL_HASH SHA256=65fab701d9829d38cb77c14acdc431d2108bfdbf8979e40eb8ae567edf10b27c
+)
+# For Windows: Prevent overriding the parent project's compiler/linker settings
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
diff --git a/cmake/summary.cmake b/cmake/summary.cmake
new file mode 100644
index 0000000..f262a3b
--- /dev/null
+++ b/cmake/summary.cmake
@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Prints accumulated ONNX configuration summary
+function(onnx_print_configuration_summary)
+  message(STATUS "")
+  message(STATUS "******** Summary ********")
+  message(STATUS "  CMake version                     : ${CMAKE_VERSION}")
+  message(STATUS "  CMake command                     : ${CMAKE_COMMAND}")
+  message(STATUS "  System                            : ${CMAKE_SYSTEM_NAME}")
+  message(STATUS "  C++ compiler                      : ${CMAKE_CXX_COMPILER}")
+  message(STATUS "  C++ compiler version              : ${CMAKE_CXX_COMPILER_VERSION}")
+  message(STATUS "  Build type                        : ${CMAKE_BUILD_TYPE}")
+  message(STATUS "  CMAKE_INSTALL_PREFIX              : ${CMAKE_INSTALL_PREFIX}")
+  if(CMAKE_MODULE_PATH)
+    message(STATUS "  CMAKE_MODULE_PATH                 : ${CMAKE_MODULE_PATH}")
+  endif()
+  message(STATUS "")
+  message(STATUS "  ONNX version                      : ${ONNX_VERSION}")
+  message(STATUS "  ONNX NAMESPACE                    : ${ONNX_NAMESPACE}")
+  message(STATUS "  ONNX_USE_LITE_PROTO               : ${ONNX_USE_LITE_PROTO}")
+  message(STATUS "  ONNX_USE_PROTOBUF_SHARED_LIBS     : ${ONNX_USE_PROTOBUF_SHARED_LIBS}")
+  message(STATUS "  ONNX_DISABLE_EXCEPTIONS           : ${ONNX_DISABLE_EXCEPTIONS}")
+  message(STATUS "  ONNX_DISABLE_STATIC_REGISTRATION  : ${ONNX_DISABLE_STATIC_REGISTRATION}")
+  message(STATUS "  ONNX_WERROR                       : ${ONNX_WERROR}")
+  message(STATUS "  ONNX_HARDENING                    : ${ONNX_HARDENING}")
+  message(STATUS "  ONNX_BUILD_TESTS                  : ${ONNX_BUILD_TESTS}")
+  message(STATUS "  ONNX_USE_UNITY_BUILD              : ${ONNX_USE_UNITY_BUILD}")
+  message(STATUS "  BUILD_SHARED_LIBS                 : ${BUILD_SHARED_LIBS}")
+  message(STATUS "")
+
+  get_target_property(tmp onnx COMPILE_OPTIONS)
+  message(STATUS "  onnx compile options              : ${tmp}")
+  get_target_property(tmp onnx_proto COMPILE_OPTIONS)
+  if(tmp)
+    message(STATUS "  onnx_proto compile options        : ${tmp}")
+  endif()
+  get_target_property(tmp onnx COMPILE_DEFINITIONS)
+  message(STATUS "  onnx compile definitions          : ${tmp}")
+  get_target_property(tmp onnx_proto COMPILE_DEFINITIONS)
+  message(STATUS "  onnx_proto compile definitions    : ${tmp}")
+  get_target_property(tmp onnx LINK_OPTIONS)
+  if(tmp)
+    message(STATUS "  onnx link options                 : ${tmp}")
+  endif()
+  get_target_property(tmp onnx_proto LINK_OPTIONS)
+  if(tmp)
+    message(STATUS "  onnx_proto link options           : ${tmp}")
+  endif()
+  get_target_property(tmp onnx LINK_LIBRARIES)
+  if(tmp)
+    message(STATUS "  onnx link libraries               : ${tmp}")
+  endif()
+  get_target_property(tmp onnx_proto LINK_LIBRARIES)
+  if(tmp)
+    message(STATUS "  onnx_proto link libraries         : ${tmp}")
+  endif()
+
+  message(STATUS "")
+  message(STATUS "  Protobuf version                  : ${Protobuf_VERSION}")
+  if(EXISTS "${ONNX_PROTOC_EXECUTABLE}")
+    message(STATUS "  Protobuf compiler                 : ${ONNX_PROTOC_EXECUTABLE}")
+  else()
+    if(TARGET protobuf::protoc)
+      get_target_property(tmp protobuf::protoc IMPORTED_LOCATION)
+      if(tmp)
+        message(STATUS "  Protobuf compiler                 : ${tmp}")
+      endif()
+    endif()
+  endif()
+  if(TARGET ${LINKED_PROTOBUF_TARGET})
+    get_target_property(tmp ${LINKED_PROTOBUF_TARGET} IMPORTED_LOCATION)
+    if(tmp)
+      message(STATUS "  Protobuf libraries                : ${tmp}")
+    endif()
+  endif()
+  message(STATUS "  ONNX_BUILD_PYTHON                 : ${ONNX_BUILD_PYTHON}")
+  if(ONNX_BUILD_PYTHON)
+    message(STATUS "    Python3 version                : ${Python3_VERSION}")
+    message(STATUS "    Python3 executable             : ${Python3_EXECUTABLE}")
+    message(STATUS "    Python3 includes               : ${Python3_INCLUDE_DIRS}")
+    message(STATUS "    Python3 libraries              : ${Python3_LIBRARIES}")
+    if(Python3_PyPy_VERSION)
+      message(STATUS "    Python3 PyPy version          : ${Python3_PyPy_VERSION}")
+    endif()
+    message(STATUS "    Python3 interpreter ID        : ${Python3_INTERPRETER_ID}")
+    if(Python_SOABI)
+      message(STATUS "    Python SOABI                  : ${Python_SOABI}")
+    endif()
+  endif()
+endfunction()
diff --git a/cmake/unittest.cmake b/cmake/unittest.cmake
new file mode 100644
index 0000000..13aa74d
--- /dev/null
+++ b/cmake/unittest.cmake
@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: Apache-2.0
+
+include(CTest)
+
+set(ONNX_ROOT ${PROJECT_SOURCE_DIR})
+set(UT_NAME ${PROJECT_NAME}_gtests)
+set(test_src
+    ${ONNX_ROOT}/onnx/test/cpp/checker_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/data_propagation_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/function_context_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/function_get_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/function_verify_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/inliner_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/ir_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/op_reg_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/parser_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/schema_registration_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/shape_inference_test.cc
+    ${ONNX_ROOT}/onnx/test/cpp/test_main.cc
+    ${ONNX_ROOT}/onnx/test/cpp/utf8_conversion_test.cc
+)
+add_executable(${UT_NAME} ${test_src})
+find_package(Threads REQUIRED)
+target_link_libraries(${UT_NAME} PRIVATE onnx Threads::Threads)
+if(TARGET GTest::gtest)
+  target_link_libraries(${UT_NAME} PRIVATE GTest::gtest)
+else()
+  target_link_libraries(${UT_NAME} PRIVATE gtest)
+endif()
+set(TEST_ARGS)
+if(ONNX_GENERATE_TEST_REPORTS)
+  # generate a report file next to the test program
+  list(
+      APPEND
+        TEST_ARGS
+        "--gtest_output=xml:$<SHELL_PATH:$<TARGET_FILE:${UT_NAME}>.$<CONFIG>.results.xml>")
+endif()
+
+add_test(NAME ${UT_NAME} COMMAND ${UT_NAME} ${TEST_ARGS})
diff --git a/codecov.yml b/codecov.yml
new file mode 100644
index 0000000..bfdc987
--- /dev/null
+++ b/codecov.yml
@@ -0,0 +1,8 @@
+coverage:
+  status:
+    project:
+      default:
+        informational: true
+    patch:
+      default:
+        informational: true
diff --git a/community/logo_request.md b/community/logo_request.md
new file mode 100644
index 0000000..3fe317e
--- /dev/null
+++ b/community/logo_request.md
@@ -0,0 +1,16 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+## Member Company logos
+
+Member Companies as defined [here](readme.md#community-roles) can request their logo be displayed on https://onnx.ai and other materials.
+
+To have your logo displayed, submit a PR to https://github.com/onnx/onnx.github.io with the following:
+1. Text of the PR must include written permission indicating the logo can be used on the onnx.ai website as well as in presentations showing ONNX Member Companies
+2. A high quality logo file with transparent background needs to be committed in the "assets" directory. The image file should be 300dpi (best if physical printing is ever required) or a vector file which can be saved in any resolution.
+3. The URL of your company or product web page. Ideally the page mentions ONNX.
+
+Member Companies may ask for their logo to be removed at any time and their status as Member Company rescinded. The Steering Committee also can vote to remove a Member Company of their status.
diff --git a/community/readme.md b/community/readme.md
new file mode 100644
index 0000000..0e690fc
--- /dev/null
+++ b/community/readme.md
@@ -0,0 +1,168 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Open Governance
+
+## TL;DR
+
+ONNX is rolling out open governance to encourage broader participation beyond the founding companies. We hope this will make the decision making process more transparent, enable better technical decisions with consideration of more viewpoints, and share the work of maintenance. We want ONNX to be the standard the whole community rallies to without reservations.
+
+ONNX open governance creates 3 roles: Member, Contributor and Approver. 3 structures are also created: Steering Committee, Special Interest Groups (SIGs), Working Groups. Contributors and Approvers can vote for the Steering Committee members. The Steering Committee charters SIGs and appoints SIG chairs. Every piece of ONNX belongs to some SIG. Contributors and Approvers participate in one or more SIGs. Our governance structure is based on the successful model of Kubernetes.
+
+The effort is bootstrapped with an initial Steering Committee and set of SIGs with the first elections to occur after 1 year.
+
+## Principles
+
+The ONNX community adheres to the following principles:
+
+* __Open__: ONNX is open source. See repository guidelines and DCO, below.
+* __Welcoming and respectful__: See Code of Conduct, below.
+* __Transparent and accessible__: Work and collaboration should be done in public. See SIG governance, below.
+* __Merit__: Ideas and contributions are accepted according to their technical merit and alignment with project objectives, scope and design principles. Engineering investment >> corporate sponsorship
+* __Speed__: Contributing the time and effort to ensure fast decision-making is key to ensuring that the specifications produced is aligned to the fast iteration of machine learning technologies.
+
+## Community Roles
+
+### Members
+Members are individuals who are interested in or participate in the ONNX community. Members are able to follow and participate in all public modes of communication used by the ONNX community including but not limited to GitHub, Slack, Stack Overflow, email announcements and discussion aliases. Members are expected to adhere to the Code of Conduct but do not have any specific responsibilities.
+
+### Contributors
+Contributors are Members who are active contributors to the community. They can have issues and PRs assigned to them. They also have voting privileges. Contributors can be active in many ways including but not limited to:
+
+* Authoring or reviewing PRs on GitHub
+* Filing or commenting on issues on GitHub
+* Contributing to SIG, subproject, or community discussions (e.g. Slack, meetings, email discussion forums, Stack Overflow, etc)
+* Creator of content, promoting and advocating the ONNX specification
+
+A Member can become a Contributor by being sponsored by 2 existing Approvers from different companies. Contributors who are not active in the last 12 months will be removed.
+
+### Approvers
+Approvers are Contributors who are experienced with some aspect of the project and with general software engineering principles. Approvers are responsible for reviewing contributions for acceptance by considering not just code quality but also holistic impact of the contribution including compatibility, performance, and interactions with other areas.
+
+Approvers need to be active Contributors for at least 3 months and be sponsored by a SIG chair with no objections from other SIG chairs.
+
+### Member Companies
+Member Companies are organizations that support ONNX in one or more of the following ways:
+* Having employees participate in SIGs, Working Groups, or the Steering Committee
+* Hosting a workshop or meetup for ONNX
+* Providing resources for building or hosting ONNX assets
+* Doing media or PR activities to promote ONNX
+* Shipping a product that supports ONNX
+
+Member Companies do not have any voting rights, except via their employees who are Contributors. Affiliates and subsidiaries are considered part of the Member Company and not as separate organizations. Being a Member Company does not by itself confer any compliance or certification to the Member Company's products.
+
+Member Companies can request their logo be displayed on the website and other materials by following these [instructions](logo_request.md).
+
+## Organizational Structure
+
+The ONNX community is organized in the following manner, with all governance and execution being planned and coordinated as follows:
+
+* **Steering Committee** is made up of a set number of people whose charter it is to define and iterate on the vision, goals, and governance process of the ONNX community.
+* **Special Interest Groups (SIGs)** are persistent groups that are responsible for specific parts of the project. SIGs must have open and transparent proceedings. Anyone is welcome to participate and contribute provided they follow the Code of Conduct. The purpose of a SIG is to develop a set of goals to be achieved over a set period of time, and then to gather input, drive consensus and closure, implement code contributions, and other related activities to achieve the goal. SIGs are also responsible for ongoing maintenance of the code in their areas.
+* **Working Groups** are temporary groups that are formed to address issues that cross SIG boundaries. Working groups do not own any code ownership or other long term artifacts. Working groups can report back and act through involved SIGs.
+
+### Steering Committee
+
+#### Role
+
+The Steering Committee has a set of rights and responsibilities including the following:
+
+* Define, evolve, and defend the vision, values, mission, and scope of the project.
+* Define, evolve, and defend a Code of Conduct,  which must include a neutral, unbiased process for resolving conflicts.
+* Define and evolve project governance structures and policies, including how members become contributors, approvers, SIG chairs, etc.
+* Charter and refine policy for defining new community groups (Special Interest Groups, Working Groups, and any future possible defined structure), and establish transparency and accountability policies for such groups.
+* Decide, for the purpose of elections, who is a  member of standing of the ONNX project, and what privileges that entails.
+* Decide which functional areas and scope are part of the ONNX project, including accepting new or pruning old SIGs and Working Groups.
+* Decide how and when official releases of ONNX artifacts are made and what they include.
+* Declare releases when quality/feature/other requirements are met.
+* Control access to, establish processes regarding, and provide a final escalation path for any ONNX repository, which currently includes all repositories under the ONNX GitHub organizations
+* Control and delegate access to and establish processes regarding other project resources/assets, including artifact repositories, build and test infrastructure, web sites and their domains, blogs, social-media accounts, etc.
+* Define any certification process.
+* Manage the ONNX brand and any outbound marketing.
+* Make decisions by majority vote if consensus cannot be reached.
+
+#### Structure
+
+The Steering Committee consists of 5 individuals. No single Member Company may have more than 1 representative. Members serve 1 year terms.
+
+The starting composition will be individuals from Microsoft, Facebook, Amazon, and 2 other Member Companies, who have been picked by the three founding members based on contributions and experience.
+
+After the initial term of each Steering Committee representative is completed, their seat will be open for any contributor in the community to be elected into the seat via a community vote. Only contributors may vote, but would be restricted to one vote per Member Company.
+
+If a member of the Steering Committee changes companies, by default they retain and may continue on with the role. If the employment change results in a single Member Company having more than one representative, then one of them must resign. When there is a vacancy on the Steering Committee, the remaining members can appoint a new representative for the remainder of the term until the next election.
+
+The Steering Committee will decide on and publish an election process within 3 months of formalizing this organizational structure. This will cover voting eligibility, eligibility for candidacy, election process and schedule. During this time period, the Steering Committee will also establish SIGs and Working Groups.
+
+A Steering Committee member can be removed due to Code of Conduct violations.
+
+### SIG - Special Interest Groups
+
+#### Role
+
+The ONNX project is organized primarily into Special Interest Groups, or SIGs. Each SIG is comprised of individuals from multiple companies and organizations, with a common purpose of advancing the project with respect to a specific topic.
+
+Our goal is to enable a distributed decision structure and code ownership, as well as providing focused forums for getting work done, making decisions, and on-boarding new contributors. Every identifiable part of the project (e.g., repository, subdirectory, API, test, issue, PR, Slack channel) is intended to be owned by some SIG. At the time of inception of this organizational structure, the following SIGs will be present:
+
+* Architecture & Infra
+    * This SIG is responsible for defining and maintaining the core ONNX format, the build and CI/CD systems for ONNX repositories, publishing release packages for ONNX, and creating tools to help integrate with and test against the ONNX standard. This SIG is also the defacto owner of files in the main ONNX repository unless explicitly owned by another SIG.
+* Operator Standardization
+    * This SIG is responsible for determining the operators that are part of the ONNX spec (ONNX and ONNX-ML domains), ensuring high quality operator definitions and documentation, establishing criteria for adding new operators, managing ops domains and compliance tiers, and enforcing versioning mechanisms.
+* Converters
+    * This SIG is responsible for developing and maintaining the various converter repositories under ONNX.
+* Model zoo and tutorials
+    * This SIG is responsible for the respective repositories with the charter of providing a comprehensive collection of state of the art ONNX models from a variety of sources and making it easy for users to get started with ONNX and the ecosystem around it.
+
+#### Structure
+
+SIGs must have at least one, and may have up to two SIG chairs at any given time. SIG chairs are intended to be organizers and facilitators, responsible for the operation of the SIG and for communication and coordination with the other SIGs, the Steering Committee, and the broader community. All SIG chairs are appointed by the Steering Committee. If there are more than two contributors being considered for a particular SIG, the Steering Committee will vote on and resolve who the chairs would be. Candidates need to be Approvers.
+
+Each SIG must have a charter that specifies its scope (topics, subsystems, code repos and directories), responsibilities, and areas of authority. Charters are submitted to the ONNX GitHub via PR for review and approval by the Steering Committee who will be looking to ensure the scope of the SIG as represented in the charter is reasonable. All SIGs are expected to follow the standards established by the Steering Committee for how Contributors are roles of authority/leadership are selected/granted, how decisions are made, and how conflicts are resolved.
+
+A primary reason that SIGs exist is as forums for collaboration. Much work in a SIG should stay local within that SIG. However, SIGs must communicate in the open, ensure other SIGs and community members can find meeting notes, discussions, designs, and decisions, and periodically communicate a high-level summary of the SIG's work to the community. SIGs are also responsible to:
+
+* Meet regularly, at least monthly
+* Keep up-to-date meeting notes, linked from the SIG's page in the community repo
+* Announce meeting agenda and minutes after each meeting, on their SIG mailing list and/or Slack channel
+* Ensure the SIG's mailing list is archived (i.e on GitHub)
+* Report activity in overall ONNX community meetings
+* Participate in release planning meetings, retrospectives, etc (if relevant)
+* Actively triage issues, PRs, test failures, etc. related to code and tests owned by the SIG
+* Use the above forums as the primary means of working, communicating, and collaborating, as opposed to private emails and meetings
+
+#### Decision making
+
+When it is time to formalize the work-product from a SIG, votes are taken from every contributor who participates in the SIG. The list of active contributors is determined by the one (or two) SIG leads to ensure that only those who have actively participated in the SIG can vote. At this time there are no restrictions on how many contributors from any one Member Company can participate (and hence vote). The Steering Committee will monitor how the community behaves and apply constraints if needed in the future.
+
+While most work shouldn’t require expensive coordination with other SIGs, there will be efforts (features, refactoring, etc.) that cross SIG boundaries. In this case, it is expected that the SIGs coordinate with each other and come to mutually agreed solutions. In some cases, it may make sense to form a Working Group for joint work. Cross-SIG coordination will naturally require more time and implies a certain amount of overhead. This is intentional to encourage changes to be well encapsulated whenever possible.
+
+### WG - Working Groups
+
+Working Groups (WGs) are primarily used to facilitate topics of discussion that cross SIG lines, or are topics which are short-lived and require a limited set of decisions to be agreed upon. Working groups:
+
+* do not own code
+* have a clear goal measured through specific deliverables
+* will be disbanded after the goal is achieved
+
+Working Groups can create specifications, recommendations, or implementations for submission to the relevant SIGs for approval and acceptance.
+
+A list of all active, inactive, and completed working groups can be found in the [working-groups repository](https://github.com/onnx/working-groups)
+
+Working Groups are formed by submitting a proposal via PR to the Steering Committee. The proposal should cover:
+
+* what is the exact problem being worked on
+* what are the exit criteria
+* who are the chairs (up to 2)
+* what are the meeting and discussion mechanics
+
+Working Groups are disbanded when there is no activity for more than *3 months* or when the chair informs the Steering Committee.
+
+## Repository Guidelines
+
+The current guidelines for all repos under ONNX github.org could be found [here](repo_guidelines.md).
+
+## CLA / DCO
+
+As of October 2020, the CLA (https://cla-assistant.io/onnx/onnx) has been retired. All commits are subject to the DCO (https://www.developercertificate.com/) and need to be signed.
diff --git a/community/repo_guidelines.md b/community/repo_guidelines.md
new file mode 100644
index 0000000..99f9d87
--- /dev/null
+++ b/community/repo_guidelines.md
@@ -0,0 +1,40 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Repositories under ONNX GitHub organization
+
+The ONNX GitHub organization contains a number of repositories. Every repository is owned by a SIG and the Steering Committee is responsible for managing these repos. Requests for creating, transferring, modifying, or archiving repositories can be made by filing an issue a request against https://github.com/onnx/steering-committee.
+
+## Rules for all repos
+
+* Must be owned and managed by one of the ONNX SIGs or the Steering Committee
+* Must be actively maintained
+* Must adopt the ONNX Code of Conduct
+* Must adopt the standard ONNX license(s) [All code projects use the Apache 2.0 license. Documentation repositories must use the Creative Commons License version 4.0.]
+* Must adopt the ONNX DCO bot
+* Must adopt all ONNX automation (like static code analysis)
+* Must have CI or other automation in place for repos containing code to ensure quality
+* All OWNERS must be members of standing as defined by ability to vote in Steering Committee elections.
+
+## Requirements for new, contributed repos
+
+We are happy to accept contributions as repos under the ONNX organization of new projects that meet the following requirements:
+
+* Project is closely related to ONNX
+* Adds value to the ONNX ecosystem
+* Determined to need a new repo rather than a folder in an existing repo
+* Applicable and usable by a wide set of ONNX users (for example, implemented support for multiple hardware backends at time of contribution or commitment to do so soon after)
+* All contributors must have signed the ONNX DCO
+* Licenses of dependencies must be acceptable
+* Commitment to maintain the repo
+* Approval of the SIG that will own the repo
+* Approval of the Steering Committee
+
+If you want to contribute a repository, you should first work with the SIG that will own it. Then the SIG can work with the Steering Committee to finalize.
+
+## Archiving repos
+
+Repositories that are inactive or unneeded will be archived. The SIG that owns the repo is responsible for deciding when it should be archived. SIGs should regularly validate the repos they own are still active and necessary.
diff --git a/community/sc-election-guidelines.md b/community/sc-election-guidelines.md
new file mode 100644
index 0000000..09146ba
--- /dev/null
+++ b/community/sc-election-guidelines.md
@@ -0,0 +1,71 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Steering Committee election guideline
+
+## Introduction
+
+To encourage community participation and wider adoption in the industry, ONNX has introduced [open governance](https://github.com/onnx/onnx/wiki/Expanded-ONNX-Steering-Committee-Announced!) in March 2018. The governance has three defined structures to propel the development of ONNX project forward: [Steering Committee](/community/readme.md#steering-committee), [Special Interest Groups (SIGs)](/community/readme.md#sig---special-interest-groups), and [Working Groups (WGs)](/community/readme.md#wg---working-groups). While SIGs and WGs primarily focus on the technical roadmap of ONNX, the Steering Committee is responsible for setting the vision and governance process of the ONNX community.
+
+For the first year of its ONNX open governance, representatives from Facebook, Microsoft, AWS, Intel and Nvidia are chosen to serve as the ONNX Steering Committee to help guide the project. The Steering Committee will be elected by the [Contributors](/community/readme.md#community-roles) in its second year and will be re-elected every year.
+
+This document is created to provide guidelines for the election process to ensure maximum transparency and fairness.
+
+
+## Timeline
+
+Candidate applications will be accepted in April, and the election will be held in May. The new term for Steering Committee begins on June 1st of the corresponding year. The following table outlines the schedule for the election process.
+
+| Schedule     | Event               |
+|:-------------|:--------------------|
+| 1st Monday of April| Application for Steering Committee candidates open. |
+| 3rd Monday of April| Candidates and their applications posted on github.|
+| 1st Monday of May| Election begins.     |
+| 2nd Monday of May| Election closes, and votes counted. Election results announced in the same week.|
+| 3rd Monday of May| Previous Steering Committee to meet the newly elected Committee for official transition.|
+| June 1 | New term begins with elected Steering Committee. Steering Committee Emeritus members help with the transition for the month of June.      |
+
+
+## Eligibility
+
+### Eligibility for Steering Committee candidacy
+Candidates will be self-nominated, and they do not necessarily need to be a [Contributor](/community/readme.md#community-roles) to the ONNX project. The duties of the Steering Committee extend beyond simply contributing code to the ONNX project.
+
+
+### Eligibility for voting
+
+To participate in the Steering committee election, you must be a Contributor to the ONNX project. As defined in the community guideline, Contributor is sponsored by 2 approvers from different companies.
+
+Contributors are further required to submit their github handle, email address, and affiliated company name to be eligible for voting. Any Contributor who has not submitted their information by before April 31st will not be able to participate in the election. The Steering Committee is currently reviewing options for collecting contributor information, and the best option will be notified to the Contributors shortly.
+
+## Candidacy process
+
+## Voting process
+
+### General election procedure
+In order to promote fairness, the Steering Committee has decided to limit 1 vote per Member Company. Contributors will be able to vote individually, but their votes will be rolled up to represent the vote of associated Member Company. This procedure will prevent large companies with lots of Contributors from dominating the election results.
+
+### Voting mechanics and algorithm
+
+The election will use [Condorcet ranking](https://en.wikipedia.org/wiki/Condorcet_method) with [Schulze method](https://en.wikipedia.org/wiki/Schulze_method). Condorcet ranking allows voters to indicate ranked preference for candidates, and Schultz method provides an algorithm to tally the overall preference.
+
+For ONNX Steering Committee election, the Condorcet ranking with Schulze method will be performed twice. The individual Contributor votes gets tallied first to Member Companies, and the results of the Member Company votes are ranked again using the same method.
+
+### Voting platform
+We will use Condorcet Internet Voting Service ([civs.cs.cornell.edu](http://civs1.civs.us/)) to collect votes from Contributors.
+
+After votes are casted, the results of individual votes will be uploaded to ONNX Github election directory to ensure transparency.
+
+## Election officers and Steering Committee emeritus members
+
+### Election officers
+Two election officers will be chosen from the current Steering committee to oversee the election process. They are responsible for overseeing the progress of the election and ensure the process is correctly implemented. Their duties include coordinating election as shown in the timeline above, tallying votes and announcing results for the ONNX community.
+
+### Steering Committee emeritus members
+Two Steering Committee members will remain as emeritus members for the newly elected Committee to help with transition process for 1 month. If previous Steering Committee members are reelected, then they will guide the transition for the new members, and there will not be a separate Steering Committee emeritus members.
+
+
+
diff --git a/community/sigs.md b/community/sigs.md
new file mode 100644
index 0000000..f8b38b1
--- /dev/null
+++ b/community/sigs.md
@@ -0,0 +1,19 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# SIGs - Special Interest Groups
+
+As described in the ONNX [governance](/community/readme.md#sig---special-interest-groups), Special Interest Groups (SIGs) are persistent groups responsible for specific parts of the project. SIGs have open and transparent proceedings to develop goals and implement code contributions. SIGs are also responsible for ongoing maintenance of the code in their areas.
+
+## Joining a SIG
+
+If you are interested in participating, please [join the discussion](https://join.slack.com/t/lfaifoundation/shared_invite/zt-3wx5vohc3-MeSYi3_dscb~u~cqs7zlPg) in the respective Slack channels. Details about any upcoming meetings will also be shared in the Slack channels. SIG artifacts can be found in the [sigs repository](https://github.com/onnx/sigs).
+
+You can find the schedule of SIG meetings on the [LFX calendar](https://zoom-lfx.platform.linuxfoundation.org/meetings/lfai-onnx?view=month)
+
+## Current SIGs
+
+The list of current sig is found [here](https://github.com/onnx/sigs#current-sigs).
diff --git a/community/working-groups.md b/community/working-groups.md
new file mode 100644
index 0000000..29e9ea3
--- /dev/null
+++ b/community/working-groups.md
@@ -0,0 +1,29 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Working Groups
+
+As described in the ONNX [governance](/community/readme.md#wg---working-groups), Working Groups (WGs) are temporary groups formed to address issues that cross SIG boundaries. Working Groups have a have a clear goal measured through specific deliverables and disband after the goal is achieved. Working groups do not own artifacts long term; they create specifications, recommendations, and/or code implementations for submission to the relevant SIGs for approval and acceptance.
+
+## Proposing a new working group
+New Working Groups are created when there is sufficient interest in a topic area and someone volunteers to be the chair for the group and submits a proposal to the steering committee. The chair facilitates the discussion and helps synthesize proposals and decisions.
+
+## Joining a working group
+Working Groups have most of their discussions on Slack. If you are interested in participating, please join the discussion in the respective Slack channels. Details about any upcoming meetings will also be shared in the Slack channel. Working Group artifacts can be found in the [working-groups repository](https://github.com/onnx/working-groups).
+
+You can find the schedule of meetings on the [ONNX calendar](https://onnx.ai/calendar)
+
+## Active working groups
+
+The list of active working group is found [here](https://github.com/onnx/working-groups#active-working-groups).
+
+## Completed working groups
+
+The list of completed working group is found [here](https://github.com/onnx/working-groups#completed-working-groups).
+
+## Inactive working groups
+
+The list of inactive working group is found [here](https://github.com/onnx/working-groups#inactive-working-groups).
diff --git a/docs/AddFunctionBody.md b/docs/AddFunctionBody.md
new file mode 100644
index 0000000..a1ab573
--- /dev/null
+++ b/docs/AddFunctionBody.md
@@ -0,0 +1,263 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Adding a Function Body Definition for an Operator
+
+A function body defines how an ONNX operator can be decomposed into simpler ONNX operators. This enables runtimes that don't natively support the operator to still execute it by expanding it into its constituent operations.
+
+## Table of Contents
+
+- [Adding a Function Body Definition for an Operator](#adding-a-function-body-definition-for-an-operator)
+  - [Table of Contents](#table-of-contents)
+  - [When to use a function body](#when-to-use-a-function-body)
+  - [File locations](#file-locations)
+  - [Simple function body (string-based)](#simple-function-body-string-based)
+  - [Referencing attributes](#referencing-attributes)
+  - [Context-dependent function body](#context-dependent-function-body)
+  - [FunctionBuilder API](#functionbuilder-api)
+  - [Multiple opset versions](#multiple-opset-versions)
+  - [ONNX function body syntax](#onnx-function-body-syntax)
+  - [Testing](#testing)
+
+## When to use a function body
+
+- The operator can be expressed in terms of other ONNX operators
+- You want to provide a reference decomposition that any runtime can use
+- The operator is being proposed as a "function" rather than a new primitive (see [Adding New Operator](AddNewOp.md) Step 1)
+
+If an operator can be split into new primitives, prefer proposing those primitives and making the operator a function.
+
+## File locations
+
+| Component | File |
+|-----------|------|
+| Function body definition | `onnx/defs/<domain>/defs.cc` (inline with the schema) |
+| FunctionBuilder utilities | `onnx/defs/function.h` |
+| Function tests (C++) | `onnx/test/cpp/function_get_test.cc`, `onnx/test/cpp/function_verify_test.cc` |
+
+## Simple function body (string-based)
+
+For operators whose decomposition is the same regardless of attributes or optional inputs, use the `.FunctionBody()` method with an ONNX-format string:
+
+```cpp
+ONNX_OPERATOR_SET_SCHEMA(
+    LessOrEqual,
+    16,
+    OpSchema()
+        .SetDoc(LessOrEqual_ver16_doc)
+        .Input(0, "A", "First input", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Input(1, "B", "Second input", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "C", "Result", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "...")
+        .TypeConstraint("T1", {"tensor(bool)"}, "...")
+        .TypeAndShapeInferenceFunction(binaryLogicOpInference)
+        .FunctionBody(R"ONNX(
+        {
+            O1 = Less (A, B)
+            O2 = Equal (A, B)
+            C = Or (O1, O2)
+        }
+        )ONNX"));
+```
+
+You can optionally specify the minimum opset version for which the function body is valid:
+
+```cpp
+        .FunctionBody(R"ONNX(
+          {
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            Y = Max (X, ZeroCast)
+          }
+        )ONNX", 18)  // This function body is valid from opset 18 onward
+```
+
+## Referencing attributes
+
+Use `@attr_name` syntax to reference the operator's declared attributes inside the function body:
+
+```cpp
+ONNX_OPERATOR_SET_SCHEMA(
+    LeakyRelu,
+    16,
+    OpSchema()
+        .Attr("alpha", "Coefficient of leakage.", AttributeProto::FLOAT, 0.01f)
+        .SetDoc(LeakyRelu_ver16_doc)
+        .Input(0, "X", "Input tensor", "T", ...)
+        .Output(0, "Y", "Output tensor", "T", ...)
+        .TypeConstraint("T", {"tensor(bfloat16)", "tensor(float16)", "tensor(float)", "tensor(double)"}, "...")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike(Zero, X)
+            XLessThanZero = Less(X, ZeroCast)
+            AlphaMulX = Mul (AlphaCast, X)
+            Y = Where (XLessThanZero, AlphaMulX, X)
+          }
+        )ONNX"));
+```
+
+The attribute must be declared in the schema's `.Attr()` call for `@attr_name` to work.
+
+## Context-dependent function body
+
+When the decomposition depends on which optional inputs are present, attribute values, or input types, use a context-dependent function body builder:
+
+```cpp
+static bool BuildContextDependentFunctionBodyClip(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  bool has_min = ctx.hasInput(1);
+  bool has_max = ctx.hasInput(2);
+
+  FunctionBuilder builder(functionProto);
+  if (!has_min && !has_max) {
+    builder.Add("output = Identity (input)");
+  } else if (has_min && !has_max) {
+    builder.Add("input_less_than_min = Less (input, min)");
+    builder.Add("output = Where (input_less_than_min, min, input)");
+  } else if (!has_min && has_max) {
+    builder.Add("input_large_than_max = Less (max, input)");
+    builder.Add("output = Where (input_large_than_max, max, input)");
+  } else {
+    builder.Add("input_less_than_min = Less (input, min)");
+    builder.Add("tmp = Where (input_less_than_min, min, input)");
+    builder.Add("output_large_than_max = Less (max, tmp)");
+    builder.Add("output = Where (output_large_than_max, max, tmp)");
+  }
+
+  schema.BuildFunction(functionProto);
+  return true;
+}
+```
+
+Register it with the schema:
+
+```cpp
+ONNX_OPERATOR_SET_SCHEMA(
+    Clip, 13,
+    OpSchema()
+        .Input(0, "input", "...", "T", OpSchema::Single, ...)
+        .Input(1, "min", "...", "T", OpSchema::Optional, ...)
+        .Input(2, "max", "...", "T", OpSchema::Optional, ...)
+        .Output(0, "output", "...", "T", OpSchema::Single, ...)
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "...")
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBodyClip)
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+```
+
+### FunctionBodyBuildContext API
+
+The context object provides information about the specific instantiation:
+
+```cpp
+struct FunctionBodyBuildContext {
+  const AttributeProto* getAttribute(const std::string& name) const;  // nullptr if not set
+  bool hasInput(int inputIndex) const;     // Is optional input present?
+  bool hasOutput(int outputIndex) const;   // Is optional output present?
+  const TypeProto* getInputType(int inputIndex) const;  // Input type info
+};
+```
+
+## FunctionBuilder API
+
+The `FunctionBuilder` class (from `onnx/defs/function.h`) provides a fluent API for constructing function bodies:
+
+```cpp
+FunctionBuilder builder(functionProto);
+
+// Add nodes using ONNX text format
+builder.Add("Y = Relu (X)");
+
+// Add with inline attributes
+builder.Add("X_ReduceMax = ReduceMax <keepdims = 1> (input, axes)");
+
+// Add constants
+builder.Const("alpha", std::vector<float>{0.01f});   // Tensor constant
+builder.Const1D("axes", int64_t(1));                 // 1-D tensor constant
+
+// Multi-line additions
+builder.Add(R"(
+    X_Sub = Sub (input, X_ReduceMax)
+    X_Exp = Exp (X_Sub)
+    X_ReduceSum = ReduceSum <keepdims = 1> (X_Exp, axes)
+    output = Div (X_Exp, X_ReduceSum)
+)");
+
+// Add opset dependency
+builder.AddOpset("", 18);  // default domain, version 18
+
+// Always finalize with:
+schema.BuildFunction(functionProto);
+return true;
+```
+
+## Multiple opset versions
+
+When the function body must change across opset versions (e.g., because a sub-op's signature changed), register multiple builders with explicit version numbers:
+
+```cpp
+ONNX_OPERATOR_SET_SCHEMA(
+    Softmax, 13,
+    OpSchema()
+        // ...
+        .SetContextDependentFunctionBodyBuilder(builderForOpset13)      // default (since_version)
+        .SetContextDependentFunctionBodyBuilder(builderForOpset18, 18)  // opset 18+
+);
+```
+
+The runtime selects the appropriate function body based on the opset version in the model.
+
+## ONNX function body syntax
+
+The text format for function bodies uses this grammar:
+
+```
+output_var = OpName <attr_name = value, ...> (input1, input2, ...)
+```
+
+Rules:
+- **Variable names** are local intermediates within the function
+- **Input/output names** must match the schema's declared `.Input()` and `.Output()` names exactly
+- **Constants** are created with the `Constant` op (e.g., `Constant <value = float {0.0}>()`)
+- **Type matching** — use `CastLike` instead of `Cast` when the target type depends on an input
+- **Attributes** are referenced with `@attr_name` for the enclosing op's attributes
+
+For the formal grammar, see [Syntax.md](Syntax.md). The parser implementation and its tests provide additional examples:
+
+| Resource | File |
+|----------|------|
+| Formal syntax specification | [docs/Syntax.md](Syntax.md) |
+| C++ parser implementation | `onnx/defs/parser.h`, `onnx/defs/parser.cc` |
+| Python parser | `onnx/parser.py` |
+| C++ parser tests | `onnx/test/cpp/parser_test.cc` |
+| Python parser tests | `onnx/test/parser_test.py` |
+
+## Testing
+
+Function bodies are tested in the C++ test suite:
+
+- **`onnx/test/cpp/function_get_test.cc`** — verifies `HasFunction()` and `GetFunction()` return correct results
+- **`onnx/test/cpp/function_verify_test.cc`** — verifies function body type constraints and correctness
+
+To run:
+
+```bash
+# Build with tests enabled
+ONNX_BUILD_TESTS=1 pip install -e . -v
+
+# Run C++ tests (Linux/macOS)
+LD_LIBRARY_PATH=./.setuptools-cmake-build/ .setuptools-cmake-build/onnx_gtests --gtest_filter="*Function*"
+
+# Run C++ tests (Windows)
+.setuptools-cmake-build\Release\onnx_gtests.exe --gtest_filter="*Function*"
+```
+
+The node backend tests (in `onnx/backend/test/case/node/`) also implicitly test function body correctness when the reference implementation uses function expansion.
diff --git a/docs/AddNewOp.md b/docs/AddNewOp.md
new file mode 100644
index 0000000..eac4188
--- /dev/null
+++ b/docs/AddNewOp.md
@@ -0,0 +1,190 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Adding New Operator or Function to ONNX
+
+Or updating an existing operator to a new Opset version.
+
+## Table of Contents
+
+- [Adding New Operator or Function to ONNX](#adding-new-operator-or-function-to-onnx)
+  - [Table of Contents](#table-of-contents)
+  - [Proposing and submitting a new operator or function to ONNX](#proposing-and-submitting-a-new-operator-or-function-to-onnx)
+  - [4 steps to add an operator](#4-steps-to-add-an-operator)
+    - [Step 1: Proposing a new operator/function](#step-1-proposing-a-new-operatorfunction)
+    - [Step 2: Submit PR](#step-2-submit-pr)
+      - [Example to Follow](#example-to-follow)
+    - [Step 3: PR Review by Operators SIG](#step-3-pr-review-by-operators-sig)
+      - [Sign-off](#sign-off)
+    - [Step 4: ONNX release](#step-4-onnx-release)
+  - [Updating an existing operator](#updating-an-existing-operator)
+    - [Checklist](#checklist)
+  - [Removing operator or function](#removing-operator-or-function)
+    - [Removing operator](#removing-operator)
+    - [Removing function](#removing-function)
+    - [Document removing operator or function](#document-removing-operator-or-function)
+
+## Proposing and submitting a new operator or function to ONNX
+
+Operators are the basic building blocks used to define ONNX models. With a rich set of operators, ONNX can describe most DNN and ML models from various frameworks. Functions enable expressing complex operators in terms of more primitive operators. The ONNX specification includes a core set of operators that enable many models. It is a non-goal to add all possible operators, however more operators are added as needed to cover evolving needs.
+
+In this document, we describe the process of accepting a new proposed operator and how to properly submit a new operator as part of ONNX standard. The goal is to improve on what we currently have based on our experience, learning and feedbacks we gathered from the community.
+
+## 4 steps to add an operator
+
+1. Decide what to propose
+2. Submit PR for new operator/function
+3. Review of PR by Operators SIG
+4. Merging of PR and inclusion in next ONNX release
+
+### Step 1: Proposing a new operator/function
+
+In order to propose a new operator/function, the following is needed:
+
+1. If the operator can be expressed in terms of other ONNX operators, then it should be a function and not an operator (we have a function in ONNX : MeanVarianceNormalization).
+2. If the operators can be split to new primitives, propose those primitives instead and make the operator a function.
+3. Based on a model. This will help us understand the usage and that it solves an actual problem. For the case of the model being private or IP and can't be shared, the operator doesn't belong to the standard and should be implemented as custom OP.
+4. The operator needs to be implemented by at-least one (well-known) framework. This help us to understand the actual behavior of the operator and its usage.
+5. Operator signature and behavior:
+    1. If the operator is available in numpy, prefer numpy semantics.
+    2. If the operator is available in more than one frameworks, make sure that your design is general and cover those frameworks.
+6. Prefer attributes over inputs.
+7. The operator should not be made more complex than is required by the use-cases. However, the operator
+should be made as general as possible, as long as it does not make the implementation more complex.
+This requires carefully balancing generality and complexity. For example, generalizing from 3-D tensors to
+N-D tensors is straight-forward (implementation-wise) for some operators, but complex for other operators.
+The choice in such cases will be made based on the complexity of such a generalization.
+
+### Step 2: Submit PR
+
+Once the criteria of proposing new operator/function has been satisfied, you will need to submit a PR for the new operator/function. Here the expectation of what the PR should include. The reviewer is expected to verify the completeness of the PR before signoff.
+
+#### Files to modify
+
+| Component | File location |
+|-----------|--------------|
+| Schema definition | `onnx/defs/<domain>/defs.cc` |
+| Operator set registration | `onnx/defs/operator_sets.h` |
+| Type/shape inference | Inline in schema via `.TypeAndShapeInferenceFunction(...)` |
+| Function body (if applicable) | Inline in schema via `.FunctionBody(...)` — see [AddFunctionBody.md](AddFunctionBody.md) |
+| Reference implementation | `onnx/reference/ops/op_<lowercase_name>.py` |
+| Node tests | `onnx/backend/test/case/node/<lowercase_name>.py` |
+| Shape inference tests | `onnx/test/shape_inference_test.py` |
+| Upgrade/downgrade tests | `onnx/test/version_converter/automatic_upgrade_test.py` and `automatic_downgrade_test.py` |
+
+Domain subdirectories under `onnx/defs/`: `math/`, `nn/`, `tensor/`, `logical/`, `reduction/`, `rnn/`, `sequence/`, `image/`, `text/`, `quantization/`, `controlflow/`, `optional/`, `traditionalml/`, `training/`
+
+1. Description:
+    1. Write a detailed description about the operator, and its expected behavior. Pretty much, the description should be clear enough to avoid confusion between implementors.
+    2. Add an example in the description to illustrate the usage.
+    3. Add reference to the source of the operator in the corresponding framework in the description (if possible).
+    4. Write the mathematical formula or a pseudocode in the description. The core algorithm needs to be very clear.
+2. Write a reference implementation in Python, this reference implementation should cover all the expected behavior of the operator. Only in extremely rare case, we will waive this requirement.
+3. Operator version: check out our
+[versioning doc](/docs/Versioning.md#operator-versioning)
+4. Write unit test, that cover main usage and corner cases.
+    1. The testing examples will be extracted to the doc.
+    2. We also generate binary data for it.
+    3. Example: [onnx/backend/test/case/node/abs.py](/onnx/backend/test/case/node/abs.py)
+5. Write upgrade and downgrade tests:
+    1. Add at least one automatic upgrade test for your operator in [onnx/test/version_converter/automatic_upgrade_test.py](/onnx/test/version_converter/automatic_upgrade_test.py) using `_test_op_upgrade`. These tests create a given operator at a given opset version (usually the version the operator was introduced in) and test that the version converter is able to convert them to the highest available version. So for a new operator `_test_op_upgrade` will not test anything, but as soon as the operator gets updated in a future opset the test will automatically become nontrivial.
+    2. Similarly add at least one automatic downgrade test for your operator in [onnx/test/version_converter/automatic_downgrade_test.py](/onnx/test/version_converter/automatic_downgrade_test.py) using `_test_op_downgrade`. Specifying the current version so that once the op is updated at a higher opset version the test will ensure downward conversion is validated.
+
+6. Update the documentation and generate the test data.
+    1. Running [the script](/tools/update_doc.sh). If you have files under `onnx/backend/test/data/node` which cannot be generated by the scripts from `onnx/backend/test/case/node`, please further use `python onnx/backend/test/cmd_tools.py generate-data --clean` to cleanup the directory and only preserve needed test data.
+to update the doc and generate the test data.
+7. Shape Inference function
+    1. Please provide a shape inference function in cases where it is meaningful and applicable.
+    2. In cases where shape inference is not possible, it must have logic to perform
+rank inference at the very least (adding right amount of dimensions to the output shape)
+    3. Shape inference functions must be accompanied by unit tests ([onnx/test/shape_inference_test.py](/onnx/test/shape_inference_test.py)).
+    4. You can refer to the shape inference function for the `TopK` operator while implementing your own function ([onnx/defs/math/defs.cc](/onnx/defs/math/defs.cc))
+    5. See [ShapeInference.md](ShapeInference.md) for details on the shape inference API and utility functions.
+8. Function body (if applicable)
+    1. If the operator can be expressed in terms of other ONNX operators, provide a function body definition.
+    2. See [AddFunctionBody.md](AddFunctionBody.md) for the full guide on defining function bodies.
+
+#### Example to Follow
+
+[PR 1959](https://github.com/onnx/onnx/pull/1959) is a good example to follow.
+
+### Step 3: PR Review by Operators SIG
+
+The [Operators SIG](https://github.com/onnx/sigs/tree/main/operators) is responsible for the operators/functions in the ONNX specification. The SIG regularly meets and reviews PRs.
+
+#### Sign-off
+
+At least two sign-off from the Operators SIG [contributors](https://github.com/onnx/onnx/tree/main/community#community-roles).
+
+### Step 4: ONNX release
+
+Once the PR is reviewed and signed off by the Operators SIG, it will be merged. Your new operator/function will be part of the main branch and available to anyone building from source. These are not official releases. ONNX periodically releases official new versions that are a snapshot of the main branch. Your new operator/function will be part of that release.
+
+## Updating an existing operator
+
+The definition of an existing operator may need to be updated when e.g. there are new scenarios or input types to support. The process is largely similar to that for creating a new operator.
+
+### Steps for updating
+
+1. **Move the current schema** from `onnx/defs/<domain>/defs.cc` to `onnx/defs/<domain>/old.cc`. This preserves the previous version for the version converter.
+2. **Create the new version** in `defs.cc` using `ONNX_OPERATOR_SET_SCHEMA(OpName, NEW_VERSION, ...)` with the new opset version number.
+3. **Update operator set registration** in `onnx/defs/operator_sets.h` to reference the new version.
+4. **Add a version converter adapter** if the behavior or signature changed (see `onnx/version_converter/adapters/` for examples).
+5. **Update the reference implementation** in `onnx/reference/ops/op_<name>.py` if behavior changed.
+6. **Add upgrade/downgrade tests** using `_test_op_upgrade` and `_test_op_downgrade`.
+7. **Regenerate documentation** by running `python onnx/defs/gen_doc.py`.
+
+### Avoiding duplication between defs.cc and old.cc
+
+When moving an operator schema to `old.cc`, avoid significant duplication of code or documentation between the old and new versions. Use these strategies:
+
+- **Shared utility functions**: Extract common logic (e.g., doc strings, type constraint lists, shape inference helpers) into shared functions in the domain's `utils.cc`/`utils.h` or a `defs.h` header.
+- **Parameterized functions**: When the old and new versions differ only slightly (e.g., an expanded type list or an additional optional input), use parameterized helper functions that accept the differences as arguments.
+- **Use judgment**: Some duplication is acceptable when the alternative would be overly complicated shared logic. If sharing the code makes it harder to understand either version independently, prefer clarity over DRY.
+
+### Additional files for updates
+
+| Component | File location |
+|-----------|--------------|
+| Previous schema version | `onnx/defs/<domain>/old.cc` |
+| Version converter adapter | `onnx/version_converter/adapters/<name>_<from>_<to>.h` |
+| Upgrade tests | `onnx/test/version_converter/automatic_upgrade_test.py` |
+| Downgrade tests | `onnx/test/version_converter/automatic_downgrade_test.py` |
+
+### Checklist
+
+Use this checklist when updating an existing operator: https://github.com/onnx/onnx/wiki/Checklist-for-updating-an-existing-operator
+
+## Removing operator or function
+
+There are a lot of reasons for removing existing ONNX operator or function, such us being replaced with different operator or can be decomposed by a set of other operators. This document describes the criteria of removing an existing ONNX operator from the standard.
+
+### Removing operator
+
+Any operator in ONNX was added because it was required by a model and/or framework. In order to deprecate such an operator we need to do the following.
+
+- Operator can’t be deprecated unless there is a replacement.
+  - Replacement can be a more general operator that supersedes the old one.
+  - Or a set of primitive operators that together can implement the same functionality and behavior of the deprecated operator (Function).
+- If the deprecated operator can be decomposed by existing operators then it must be converted to a function.
+- If replacement isn’t in ONNX standard yet, then add the replacement operator or set of operators first.
+- Add a version adapter which turns the operator into its replacement for the version converter. Example: [onnx/version_converter/adapters/upsample_9_10.h](/onnx/version_converter/adapters/upsample_9_10.h)
+- No grace period is needed for deprecated operators.
+
+### Removing function
+
+Function, by definition, is composed of ONNX primitives; however, function could have been accelerated by framework or runtime that support ONNX. So, removing function is not recommended, with the exception of adding another single function which supersedes its functionality.
+
+### Document removing operator or function
+
+To make sure everyone is aware of the deprecation, the following need to happen:
+
+- Any removed operator or function from ONNX need to be mentioned in the release note.
+- Their old documentation needs to be updated to show the new replacement and the mapping between the old to the new.
+  - Only `def.cc` need to be remove, `old.cc` will remain.
+  - `old.cc` need to be updated with the mapping to the replacement.
+- ONNX checker need to be updated to error with a proper message.
+- All removed operators need to be appended at the end of the `operator.md` file.
diff --git a/docs/AssuranceCase.md b/docs/AssuranceCase.md
new file mode 100644
index 0000000..18d3df4
--- /dev/null
+++ b/docs/AssuranceCase.md
@@ -0,0 +1,111 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Security Assurance Case
+
+**Version:** 1.1
+**Date:** June 2026
+**Project:** ONNX (Open Neural Network Exchange)
+**Scope:** ONNX Core (`onnx/onnx`) and the produced Python wheel
+
+This document provides the security assurance case for ONNX Core, supporting the OpenSSF Best Practices Badge application.
+
+## General scope and assurances
+
+The onnx package aims to provide memory-safe parsing of untrusted protobuf bytes.
+Using shape/type inference, version update utilities, and model validation is also considered memory-safe.
+Resource exhaustion, however, may be triggered from within these utilities and users are advised to guard against this accordingly.
+
+Validation utilities such as `onnx.checker.check_model` are provided on a best-effort basis (e.g. a validated `ModelProto` object may contain `NodeProto` objects that do not adhere to the ONNX specification).
+
+The onnx reference implementation is not yet considered safe for production use on untrusted inputs.
+
+
+## Threat Model
+
+### Malicious model file
+
+The attacker supplies a malicious ONNX/protobuf file to a user who parses, validates, or runs type/shape inference or version-conversion on it.
+
+- **In scope:** memory safety while parsing, type/shape inference, version conversion, and validation of untrusted model bytes.
+- **Out of scope:** resource exhaustion (DoS) from those utilities, and the reference runtime executing untrusted models.
+
+### Supply chain
+
+The attacker compromises a dependency, the build pipeline, or the published artifact — so that a user installing `onnx` (e.g. from PyPI) receives malicious code.
+
+- **In scope:** integrity of the published wheels and statically compiled dependencies.
+- **Out of scope:** compromise of a user's own machine or CI, and vulnerabilities in transitive dependencies' upstream code itself.
+
+### External data references
+
+A malicious model references external tensor data via attacker-controlled file paths, attempting to read files outside the model's directory.
+
+- **In scope:** external-data paths are validated and normalized; no resolution outside the model directory.
+- **Out of scope:** files the user has explicitly granted the model directory access to.
+
+
+## Secure Design Principles (Saltzer & Schroeder)
+
+| Principle | Application in ONNX Core |
+|-----------|--------------------------|
+| Economy of Mechanism | Protocol Buffers for serialization; validation centralized in checker.cc; minimal dependencies |
+| Fail-Safe Defaults | Validation on by default; must opt out with `check_model=False`; unknown protobuf fields rejected |
+| Complete Mediation | Every model load goes through the validation pipeline; all operator inputs are type- and shape-checked |
+| Least Privilege | No elevated privileges required; no network access; file I/O restricted to explicitly specified paths |
+| Separation of Privilege | External data loading requires both model reference and file system access; releases require SLSA attestation |
+| Least Common Mechanism | No global mutable state; validation is stateless; each API call operates independently |
+| Psychological Acceptability | Secure defaults need no configuration; clear validation error messages; type-annotated Python API |
+
+
+## Common Weaknesses Mitigated
+
+| CWE | Mitigation |
+|-----|-----------|
+| CWE-787/125 Out-of-bounds R/W | Modern C++ (std::vector, RAII); ASan in CI |
+| CWE-20 Input Validation | Comprehensive model validation on load; protobuf schema enforcement; operator shape/type checking |
+| CWE-416 Use After Free | RAII/smart pointers (unique_ptr, shared_ptr); ASan in CI; code review |
+| CWE-190 Integer Overflow | Checked size arithmetic in tensor allocation; UBSan in CI |
+| CWE-22 Path Traversal | External data paths validated and normalized; no auto-resolution outside model directory |
+| CWE-78 Command Injection | No shell execution in ONNX Core; no system()/exec() usage; enforced by code review and static analysis |
+| OWASP A06 Supply Chain | Dependabot; Sigstore signing; minimal dependency footprint; SBOM generation |
+| CWE-79/89/352/434 | Not applicable — ONNX Core is not a web application or database |
+
+
+## Security Testing
+
+| Method | Details |
+|--------|---------|
+| Static analysis | CodeQL (GitHub Advanced Security), Clang Static Analyzer, sonarcloud |
+| Dynamic analysis | ASan, MSan, UBSan, TSan in CI build matrix |
+| Fuzzing | Early stage — OSS-Fuzz harnesses ([onnx/fuzz](https://github.com/onnx/onnx/tree/main/onnx/fuzz)) cover the checker, model loader, text parser, shape inference, version converter, and compose; reference evaluator and external-data parsing are not yet covered. A short smoke run of these harnesses is part of this repo's CI ([fuzz.yml](https://github.com/onnx/onnx/blob/main/.github/workflows/fuzz.yml)); the full OSS-Fuzz continuous campaigns run separately and are not surfaced here |
+| Dependency scanning | Dependabot, OpenSSF Scorecard |
+
+
+## Security Processes
+
+**Vulnerability disclosure**: Reports via GitHub Security Advisories (preferred) or onnx-security@lists.lfaidata.foundation as a fallback; CVE assignment through Linux Foundation CNA. See [SECURITY.md](https://github.com/onnx/onnx/blob/main/SECURITY.md).
+
+**Code review**: All changes require maintainer review; security-sensitive changes require Architecture SIG review; one approval for dependency updates; automated checks must pass before merge ([CODEOWNERS](https://github.com/onnx/onnx/blob/main/CODEOWNERS)).
+
+**Build & distribution**: artifacts signed with Sigstore; PyPI Trusted Publishing with 2FA required for maintainers; SHA256 checksums published; actions pinned to SHA in CI.
+
+
+## References
+
+- ONNX Security Policy: https://github.com/onnx/onnx/blob/main/SECURITY.md
+- ONNX IR Spec: https://github.com/onnx/onnx/blob/main/docs/IR.md
+- Model Checker: https://github.com/onnx/onnx/blob/main/onnx/checker.cc
+- OpenSSF Best Practices: https://bestpractices.coreinfrastructure.org/
+- SLSA Framework: https://slsa.dev/
+- CWE Top 25: https://cwe.mitre.org/top25/
+- Saltzer & Schroeder Principles: https://web.mit.edu/Saltzer/www/publications/protection/
+
+---
+
+**Document Maintainer**: ONNX Architecture & Infrastructure SIG
+**Last Updated**: June 2026
+**Review Cycle**: Annual (or upon significant architectural changes)
diff --git a/docs/Broadcasting.md b/docs/Broadcasting.md
new file mode 100644
index 0000000..9541972
--- /dev/null
+++ b/docs/Broadcasting.md
@@ -0,0 +1,79 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Broadcasting in ONNX
+
+In ONNX, element-wise operators can take inputs with different shape,
+as long as the input tensors are broadcastable to the same shape.
+ONNX supports two types of broadcasting: multidirectional broadcasting and
+unidirectional broadcasting. We will introduce these two types of broadcasting
+respectively in the following sections.
+
+## Multidirectional Broadcasting
+
+In ONNX, a set of tensors are multidirectional broadcastable to the same shape
+if one of the following is true:
+
+- The tensors all have exactly the same shape.
+- The tensors all have the same number of dimensions and the length of
+each dimensions is either a common length or 1.
+- The tensors that have too few dimensions can have their shapes prepended
+with a dimension of length 1 to satisfy property 2.
+
+For example, the following tensor shapes are supported by multidirectional broadcasting:
+
+- shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar ==> shape(result) = (2, 3, 4, 5)
+- shape(A) = (2, 3, 4, 5), shape(B) = (5,), ==> shape(result) = (2, 3, 4, 5)
+- shape(A) = (4, 5), shape(B) = (2, 3, 4, 5), ==> shape(result) = (2, 3, 4, 5)
+- shape(A) = (1, 4, 5), shape(B) = (2, 3, 1, 1), ==> shape(result) = (2, 3, 4, 5)
+- shape(A) = (3, 4, 5), shape(B) = (2, 1, 1, 1), ==> shape(result) = (2, 3, 4, 5)
+
+Multidirectional broadcasting is the same as [Numpy's broadcasting](https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html#general-broadcasting-rules).
+
+Multidirectional broadcasting is supported by the following operators in ONNX:
+
+- [Add](Operators.md#Add)
+- [And](Operators.md#And)
+- [Div](Operators.md#Div)
+- [Equal](Operators.md#Equal)
+- [Greater](Operators.md#Greater)
+- [Less](Operators.md#Less)
+- [Max](Operators.md#Max)
+- [Mean](Operators.md#Mean)
+- [Min](Operators.md#Min)
+- [Mul](Operators.md#Mul)
+- [Or](Operators.md#Or)
+- [Pow](Operators.md#Pow)
+- [Sub](Operators.md#Sub)
+- [Sum](Operators.md#Sum)
+- [Where](Operators.md#Where)
+- [Xor](Operators.md#Xor)
+
+## Unidirectional Broadcasting
+
+In ONNX, tensor B is unidirectional broadcastable to tensor A
+if one of the following is true:
+
+- Tensor A and B both have exactly the same shape.
+- Tensor A and B all have the same number of dimensions and the length of
+each dimensions is either a common length or B's length is 1.
+- Tensor B has too few dimensions, and B can have its shapes prepended
+with a dimension of length 1 to satisfy property 2.
+
+When unidirectional broadcasting happens, the output's shape is the same as
+the shape of A (i.e., the larger shape of two input tensors).
+
+In the following examples, tensor B is unidirectional broadcastable to tensor A:
+
+- shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar ==> shape(result) = (2, 3, 4, 5)
+- shape(A) = (2, 3, 4, 5), shape(B) = (5,), ==> shape(result) = (2, 3, 4, 5)
+- shape(A) = (2, 3, 4, 5), shape(B) = (2, 1, 1, 5), ==> shape(result) = (2, 3, 4, 5)
+- shape(A) = (2, 3, 4, 5), shape(B) = (1, 3, 1, 5), ==> shape(result) = (2, 3, 4, 5)
+
+Unidirectional broadcasting is supported by the following operators in ONNX:
+
+- [Gemm](Operators.md#Gemm)
+- [PRelu](Operators.md#PRelu)
diff --git a/docs/CIPipelines.md b/docs/CIPipelines.md
new file mode 100644
index 0000000..0eb8b5e
--- /dev/null
+++ b/docs/CIPipelines.md
@@ -0,0 +1,59 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX CI Pipelines
+
+## Core CI
+
+| Workflow | When it runs | What it does |
+|---|---|---|
+| [CI](/.github/workflows/main.yml) | Every PR, merge_group, push to main, daily (midnight UTC) | C++ and Python tests across Linux, Windows, macOS; Python 3.10–3.14 (including free-threading variants); doc generation; proto generation; node test generation; daily run reports code coverage to Codecov |
+| [Windows\_No\_Exception\_CI](/.github/workflows/win_no_exception_ci.yml) | Push and PR to main and rel-\* | C++ tests compiled without exceptions; selective schema loading |
+| [Lint / Enforce style](/.github/workflows/lint.yml) | Every PR | Required — runs lintrunner (ruff, mypy, clang-format, etc.) and verifies auto-generated files are up to date |
+| [Require label](/.github/workflows/check_pr_label.yml) | Every PR | Requires at least one `topic:` or `module:` label (skipped for Dependabot PRs) |
+| [DCO](/.github/workflows/dco_merge_group.yml) | merge\_group | Placeholder DCO job required to enable the GitHub merge queue |
+
+## Release Builds (1)
+
+| Workflow | When it runs | What it does |
+|---|---|---|
+| [Create Releases](/.github/workflows/create_release.yml) | Push to main/rel-\*, PRs targeting rel-\* or labeled "run release CIs", weekly (Monday 00:00 UTC), workflow\_dispatch | Orchestrator — calls WindowsRelease, LinuxRelease, MacRelease, PyodideRelease, and sdistRelease as reusable workflows |
+| [WindowsRelease](/.github/workflows/release_windows_cibw.yml) | Called by Create Releases | Builds Windows wheels for x64, x86, and arm64; verifies with minimum supported packages (2)(3) |
+| [LinuxRelease](/.github/workflows/release_linux_cibw.yml) | Called by Create Releases | Builds Linux wheels for x86\_64 (manylinux\_2\_28) and aarch64; verifies with minimum supported packages (3) |
+| [MacRelease](/.github/workflows/release_macos_cibw.yml) | Called by Create Releases | Builds macOS wheels (macos-14, MACOSX\_DEPLOYMENT\_TARGET=12.0); verifies with minimum supported packages (3) |
+| [PyodideRelease](/.github/workflows/release_pyodide_cibw.yml) | Called by Create Releases and on every push | Builds a Pyodide (WebAssembly) wheel on Ubuntu using `cibuildwheel` with a pre-downloaded host `protoc` and protobuf source; runs a basic import test (3) |
+| [sdistRelease](/.github/workflows/release_sdist.yml) | Called by Create Releases | Builds and tests source distribution |
+
+## Security and Supply Chain
+
+| Workflow | When it runs | What it does |
+|---|---|---|
+| [CodeQL](/.github/workflows/codeql.yml) | Every PR, push to main/rel-\*, weekly (Friday) | Static analysis of C++ and Python for security vulnerabilities |
+| [Scorecard](/.github/workflows/scorecard.yml) | Push to main, weekly (Saturday) | OpenSSF supply-chain security scorecard; publishes results to code-scanning dashboard |
+| [Dependency Review](/.github/workflows/dependency-review.yml) | Every PR | Flags vulnerable or license-incompatible dependencies introduced by a PR |
+
+## Documentation and Maintenance
+
+| Workflow | When it runs | What it does |
+|---|---|---|
+| [Pages](/.github/workflows/pages.yml) | PRs to main, push to main | Builds and publishes ONNX documentation to GitHub Pages |
+| [Pixi CI](/.github/workflows/pixi_build.yml) | Weekly (Sunday 23:59 UTC) and on PRs | Builds, lints, and tests with the [pixi](https://pixi.sh/) environment manager on Linux, macOS, and Windows; opens an issue on failure when scheduled |
+| [Check URLs](/.github/workflows/check_urls.yml) | Push to main/rel-\*, monthly | Checks for broken URLs in the codebase |
+| [Stale](/.github/workflows/stale.yml) | Daily | Warns and eventually closes stale issues and PRs |
+| [Dependabot](/.github/dependabot.yml) | Monthly | Creates PRs for updated dependency versions |
+
+---
+
+* **(1)** Release CIs run when:
+  * A PR is merged into main or a rel-\* branch
+  * Weekly (Monday 00:00 UTC) — publishes a Python wheel to the [onnx-weekly](https://pypi.org/project/onnx-weekly/) package on PyPI
+  * Any PR targeting a rel-\* branch
+  * Any PR labeled "run release CIs" (maintainers only)
+  * Manually via workflow\_dispatch
+
+* **(2)** Minimum supported dependency versions are listed in `[project.dependencies]` in [pyproject.toml](/pyproject.toml).
+
+* **(3)** The [PEP 770](https://peps.python.org/pep-0770/) SBOM (`dist-info/sboms/sbom.cdx.json`) is embedded in any wheel build where `SKBUILD_METADATA_DIR` is set (including local `pip wheel` builds). Only the cibuildwheel release pipeline patches the SBOM to reflect the actual protobuf tarball version, URL, and SHA-256 used for that specific build; other wheel builds embed the template values from `sbom.cdx.json`.
diff --git a/docs/Changelog-ml.md b/docs/Changelog-ml.md
new file mode 100644
index 0000000..e6bd0e5
--- /dev/null
+++ b/docs/Changelog-ml.md
@@ -0,0 +1,1349 @@
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+## Operator Changelog
+*This file is automatically generated from the
+            [def files](/onnx/defs) via [this script](/onnx/defs/gen_doc.py).
+            Do not modify directly and instead edit operator definitions.*
+
+For an operator input/output's differentiability, it can be differentiable,
+            non-differentiable, or undefined. If a variable's differentiability
+            is not specified, that variable has undefined differentiability.
+
+# ai.onnx.ml
+## Version 1 of the 'ai.onnx.ml' operator set
+### <a name="ai.onnx.ml.ArrayFeatureExtractor-1"></a>**ai.onnx.ml.ArrayFeatureExtractor-1**</a>
+
+  Select elements of the input tensor based on the indices passed.<br>
+      The indices are applied to the last axes of the tensor.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be selected</dd>
+<dt><tt>Y</tt> : tensor(int64)</dt>
+<dd>The indices, based on 0 as the first index of any dimension.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> : T</dt>
+<dd>Selected output data as an array</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32), tensor(string)</dt>
+<dd>The input must be a tensor of a numeric type or string. The output will be of the same tensor type.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.Binarizer-1"></a>**ai.onnx.ml.Binarizer-1**</a>
+
+  Maps the values of the input tensor to either 0 or 1, element-wise, based on the outcome of a comparison against a threshold value.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>threshold</tt> : float (default is 0.0)</dt>
+<dd>Values greater than this are mapped to 1, others to 0.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be binarized</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Binarized output data</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type. The output will be of the same tensor type.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.CastMap-1"></a>**ai.onnx.ml.CastMap-1**</a>
+
+  Converts a map to a tensor.<br>The map key must be an int64 and the values will be ordered
+      in ascending order based on this key.<br>The operator supports dense packing or sparse packing.
+      If using sparse packing, the key cannot exceed the max_map-1 value.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>cast_to</tt> : string (default is TO_FLOAT)</dt>
+<dd>A string indicating the desired element type of the output tensor, one of 'TO_FLOAT', 'TO_STRING', 'TO_INT64'.</dd>
+<dt><tt>map_form</tt> : string (default is DENSE)</dt>
+<dd>Indicates whether to only output as many values as are in the input (dense), or position the input based on using the key of the map as the index of the output (sparse).<br>One of 'DENSE', 'SPARSE'.</dd>
+<dt><tt>max_map</tt> : int (default is 1)</dt>
+<dd>If the value of map_form is 'SPARSE,' this attribute indicates the total length of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>The input map that is to be cast to a tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>A tensor representing the same data as the input map, ordered by their keys</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : map(int64, string), map(int64, float)</dt>
+<dd>The input must be an integer map to either string or float.</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(float), tensor(int64)</dt>
+<dd>The output is a 1-D tensor of string, float, or integer.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.CategoryMapper-1"></a>**ai.onnx.ml.CategoryMapper-1**</a>
+
+  Converts strings to integers and vice versa.<br>
+      Two sequences of equal length are used to map between integers and strings,
+      with strings and integers at the same index detailing the mapping.<br>
+      Each operator converts either integers to strings or strings to integers, depending
+      on which default value attribute is provided. Only one default value attribute
+      should be defined.<br>
+      If the string default value is set, it will convert integers to strings.
+      If the int default value is set, it will convert strings to integers.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>cats_int64s</tt> : list of ints</dt>
+<dd>The integers of the map. This sequence must be the same length as the 'cats_strings' sequence.</dd>
+<dt><tt>cats_strings</tt> : list of strings</dt>
+<dd>The strings of the map. This sequence must be the same length as the 'cats_int64s' sequence</dd>
+<dt><tt>default_int64</tt> : int (default is -1)</dt>
+<dd>An integer to use when an input string value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.</dd>
+<dt><tt>default_string</tt> : string (default is _Unused)</dt>
+<dd>A string to use when an input integer value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Output data. If strings are input, the output values are integers, and vice versa.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string), tensor(int64)</dt>
+<dd>The input must be a tensor of strings or integers, either [N,C] or [C].</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64)</dt>
+<dd>The output is a tensor of strings or integers. Its shape will be the same as the input shape.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.DictVectorizer-1"></a>**ai.onnx.ml.DictVectorizer-1**</a>
+
+  Uses an index mapping to convert a dictionary to an array.<br>
+      Given a dictionary, each key is looked up in the vocabulary attribute corresponding to
+      the key type. The index into the vocabulary array at which the key is found is then
+      used to index the output 1-D tensor 'Y' and insert into it the value found in the dictionary 'X'.<br>
+      The key type of the input map must correspond to the element type of the defined vocabulary attribute.
+      Therefore, the output array will be equal in length to the index mapping vector parameter.
+      All keys in the input dictionary must be present in the index mapping vector.
+      For each item in the input dictionary, insert its value in the output array.
+      Any keys not present in the input dictionary, will be zero in the output array.<br>
+      For example: if the ``string_vocabulary`` parameter is set to ``["a", "c", "b", "z"]``,
+      then an input of ``{"a": 4, "c": 8}`` will produce an output of ``[4, 8, 0, 0]``.
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>int64_vocabulary</tt> : list of ints</dt>
+<dd>An integer vocabulary array.<br>One and only one of the vocabularies must be defined.</dd>
+<dt><tt>string_vocabulary</tt> : list of strings</dt>
+<dd>A string vocabulary array.<br>One and only one of the vocabularies must be defined.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>A dictionary.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>A 1-D tensor holding values from the input dictionary.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : map(string, int64), map(int64, string), map(int64, float), map(int64, double), map(string, float), map(string, double)</dt>
+<dd>The input must be a map from strings or integers to either strings or a numeric type. The key and value types cannot be the same.</dd>
+<dt><tt>T2</tt> : tensor(int64), tensor(float), tensor(double), tensor(string)</dt>
+<dd>The output will be a tensor of the value type of the input map. It's shape will be [1,C], where C is the length of the input dictionary.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.FeatureVectorizer-1"></a>**ai.onnx.ml.FeatureVectorizer-1**</a>
+
+  Concatenates input tensors into one continuous output.<br>
+      All input shapes are 2-D and are concatenated along the second dimension. 1-D tensors are treated as [1,C].
+      Inputs are copied to the output maintaining the order of the input arguments.<br>
+      All inputs must be integers or floats, while the output will be all floating point values.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>inputdimensions</tt> : list of ints</dt>
+<dd>The size of each input in the input list</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>X</tt> (variadic) : T1</dt>
+<dd>An ordered collection of tensors, all with the same element type.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>The output array, elements ordered as the inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64), tensor(float), tensor(double)</dt>
+<dd>The input type must be a tensor of a numeric type.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.Imputer-1"></a>**ai.onnx.ml.Imputer-1**</a>
+
+  Replaces inputs that equal one value with another, leaving all other elements alone.<br>
+      This operator is typically used to replace missing values in situations where they have a canonical
+      representation, such as -1, 0, NaN, or some extreme value.<br>
+      One and only one of imputed_value_floats or imputed_value_int64s should be defined -- floats if the input tensor
+      holds floats, integers if the input tensor holds integers. The imputed values must all fit within the
+      width of the tensor element type. One and only one of the replaced_value_float or replaced_value_int64 should be defined,
+      which one depends on whether floats or integers are being processed.<br>
+      The imputed_value attribute length can be 1 element, or it can have one element per input feature.<br>In other words, if the input tensor has the shape [*,F], then the length of the attribute array may be 1 or F. If it is 1, then it is broadcast along the last dimension and applied to each feature.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>imputed_value_floats</tt> : list of floats</dt>
+<dd>Value(s) to change to</dd>
+<dt><tt>imputed_value_int64s</tt> : list of ints</dt>
+<dd>Value(s) to change to.</dd>
+<dt><tt>replaced_value_float</tt> : float (default is 0.0)</dt>
+<dd>A value that needs replacing.</dd>
+<dt><tt>replaced_value_int64</tt> : int (default is 0)</dt>
+<dd>A value that needs replacing.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be processed.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Imputed output data</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input type must be a tensor of a numeric type, either [N,C] or [C]. The output type will be of the same tensor type and shape.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.LabelEncoder-1"></a>**ai.onnx.ml.LabelEncoder-1**</a>
+
+  Converts strings to integers and vice versa.<br>
+      If the string default value is set, it will convert integers to strings.
+      If the int default value is set, it will convert strings to integers.<br>
+      Each operator converts either integers to strings or strings to integers, depending
+      on which default value attribute is provided. Only one default value attribute
+      should be defined.<br>
+      When converting from integers to strings, the string is fetched from the
+      'classes_strings' list, by simple indexing.<br>
+      When converting from strings to integers, the string is looked up in the list
+      and the index at which it is found is used as the converted value.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>classes_strings</tt> : list of strings</dt>
+<dd>A list of labels.</dd>
+<dt><tt>default_int64</tt> : int (default is -1)</dt>
+<dd>An integer to use when an input string value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.</dd>
+<dt><tt>default_string</tt> : string (default is _Unused)</dt>
+<dd>A string to use when an input integer value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Output data. If strings are input, the output values are integers, and vice versa.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string), tensor(int64)</dt>
+<dd>The input type must be a tensor of integers or strings, of any shape.</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64)</dt>
+<dd>The output type will be a tensor of strings or integers, and will have the same shape as the input.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.LinearClassifier-1"></a>**ai.onnx.ml.LinearClassifier-1**</a>
+
+  Linear classifier
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>classlabels_ints</tt> : list of ints</dt>
+<dd>Class labels when using integer labels. One and only one 'classlabels' attribute must be defined.</dd>
+<dt><tt>classlabels_strings</tt> : list of strings</dt>
+<dd>Class labels when using string labels. One and only one 'classlabels' attribute must be defined.</dd>
+<dt><tt>coefficients</tt> : list of floats (required)</dt>
+<dd>A collection of weights of the model(s).</dd>
+<dt><tt>intercepts</tt> : list of floats</dt>
+<dd>A collection of intercepts.</dd>
+<dt><tt>multi_class</tt> : int (default is 0)</dt>
+<dd>Indicates whether to do OvR or multinomial (0=OvR is the default).</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the scores vector.<br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Data to be classified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Classification outputs (one class per example).</dd>
+<dt><tt>Z</tt> : tensor(float)</dt>
+<dd>Classification scores ([N,E] - one score for each class and example</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type, and of shape [N,C] or [C]. In the latter case, it will be treated as [1,C]</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64)</dt>
+<dd>The output will be a tensor of strings or integers.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.LinearRegressor-1"></a>**ai.onnx.ml.LinearRegressor-1**</a>
+
+  Generalized linear regression evaluation.<br>
+      If targets is set to 1 (default) then univariate regression is performed.<br>
+      If targets is set to M then M sets of coefficients must be passed in as a sequence
+      and M results will be output for each input n in N.<br>
+      The coefficients array is of length n, and the coefficients for each target are contiguous.
+      Intercepts are optional but if provided must match the number of targets.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>coefficients</tt> : list of floats</dt>
+<dd>Weights of the model(s).</dd>
+<dt><tt>intercepts</tt> : list of floats</dt>
+<dd>Weights of the intercepts, if used.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the regression output vector.<br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'</dd>
+<dt><tt>targets</tt> : int (default is 1)</dt>
+<dd>The total number of regression targets, 1 if not defined.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be regressed.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Regression outputs (one per target, per example).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.Normalizer-1"></a>**ai.onnx.ml.Normalizer-1**</a>
+
+  Normalize the input.  There are three normalization modes, which have the corresponding formulas,
+      defined using element-wise infix operators '/' and '^' and tensor-wide functions 'max' and 'sum':<br>
+  <br>
+      Max: Y = X / max(X)<br>
+      L1:  Y = X / sum(X)<br>
+      L2:  Y = sqrt(X^2 / sum(X^2)}<br>
+      In all modes, if the divisor is zero, Y == X.
+  <br>
+      For batches, that is, [N,C] tensors, normalization is done along the C axis. In other words, each row
+      of the batch is normalized independently.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>norm</tt> : string (default is MAX)</dt>
+<dd>One of 'MAX,' 'L1,' 'L2'</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be encoded, a tensor of shape [N,C] or [C]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Encoded output data</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.OneHotEncoder-1"></a>**ai.onnx.ml.OneHotEncoder-1**</a>
+
+  Replace each input element with an array of ones and zeros, where a single
+      one is placed at the index of the category that was passed in. The total category count
+      will determine the size of the extra dimension of the output array Y.<br>
+      For example, if we pass a tensor with a single value of 4, and a category count of 8,
+      the output will be a tensor with ``[0,0,0,0,1,0,0,0]``.<br>
+      This operator assumes every input feature is from the same set of categories.<br>
+      If the input is a tensor of float, int32, or double, the data will be cast
+      to integers and the cats_int64s category list will be used for the lookups.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>cats_int64s</tt> : list of ints</dt>
+<dd>List of categories, ints.<br>One and only one of the 'cats_*' attributes must be defined.</dd>
+<dt><tt>cats_strings</tt> : list of strings</dt>
+<dd>List of categories, strings.<br>One and only one of the 'cats_*' attributes must be defined.</dd>
+<dt><tt>zeros</tt> : int (default is 1)</dt>
+<dd>If true and category is not present, will return all zeros; if false and a category if not found, the operator will fail.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be encoded.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Encoded output data, having one more dimension than X.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(string), tensor(int64), tensor(int32), tensor(float), tensor(double)</dt>
+<dd>The input must be a tensor of a numeric type.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.SVMClassifier-1"></a>**ai.onnx.ml.SVMClassifier-1**</a>
+
+  Support Vector Machine classifier
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>classlabels_ints</tt> : list of ints</dt>
+<dd>Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>classlabels_strings</tt> : list of strings</dt>
+<dd>Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>coefficients</tt> : list of floats</dt>
+<dd></dd>
+<dt><tt>kernel_params</tt> : list of floats</dt>
+<dd>List of 3 elements containing gamma, coef0, and degree, in that order. Zero if unused for the kernel.</dd>
+<dt><tt>kernel_type</tt> : string (default is LINEAR)</dt>
+<dd>The kernel type, one of 'LINEAR,' 'POLY,' 'RBF,' 'SIGMOID'.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'</dd>
+<dt><tt>prob_a</tt> : list of floats</dt>
+<dd>First set of probability coefficients.</dd>
+<dt><tt>prob_b</tt> : list of floats</dt>
+<dd>Second set of probability coefficients. This array must be same size as prob_a.<br>If these are provided then output Z are probability estimates, otherwise they are raw scores.</dd>
+<dt><tt>rho</tt> : list of floats</dt>
+<dd></dd>
+<dt><tt>support_vectors</tt> : list of floats</dt>
+<dd></dd>
+<dt><tt>vectors_per_class</tt> : list of ints</dt>
+<dd></dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Data to be classified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Classification outputs (one class per example).</dd>
+<dt><tt>Z</tt> : tensor(float)</dt>
+<dd>Class scores (one per class per example), if prob_a and prob_b are provided they are probabilities for each class, otherwise they are raw scores.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type, either [C] or [N,C].</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64)</dt>
+<dd>The output type will be a tensor of strings or integers, depending on which of the classlabels_* attributes is used. Its size will match the batch size of the input.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.SVMRegressor-1"></a>**ai.onnx.ml.SVMRegressor-1**</a>
+
+  Support Vector Machine regression prediction and one-class SVM anomaly detection.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>coefficients</tt> : list of floats</dt>
+<dd>Support vector coefficients.</dd>
+<dt><tt>kernel_params</tt> : list of floats</dt>
+<dd>List of 3 elements containing gamma, coef0, and degree, in that order. Zero if unused for the kernel.</dd>
+<dt><tt>kernel_type</tt> : string (default is LINEAR)</dt>
+<dd>The kernel type, one of 'LINEAR,' 'POLY,' 'RBF,' 'SIGMOID'.</dd>
+<dt><tt>n_supports</tt> : int (default is 0)</dt>
+<dd>The number of support vectors.</dd>
+<dt><tt>one_class</tt> : int (default is 0)</dt>
+<dd>Flag indicating whether the regression is a one-class SVM or not.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT.'</dd>
+<dt><tt>rho</tt> : list of floats</dt>
+<dd></dd>
+<dt><tt>support_vectors</tt> : list of floats</dt>
+<dd>Chosen support vectors</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be regressed.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Regression outputs (one score per target per example).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input type must be a tensor of a numeric type, either [C] or [N,C].</dd>
+</dl>
+
+### <a name="ai.onnx.ml.Scaler-1"></a>**ai.onnx.ml.Scaler-1**</a>
+
+  Rescale input data, for example to standardize features by removing the mean and scaling to unit variance.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>offset</tt> : list of floats</dt>
+<dd>First, offset by this.<br>Can be length of features in an [N,F] tensor or length 1, in which case it applies to all features, regardless of dimension count.</dd>
+<dt><tt>scale</tt> : list of floats</dt>
+<dd>Second, multiply by this.<br>Can be length of features in an [N,F] tensor or length 1, in which case it applies to all features, regardless of dimension count.<br>Must be same length as 'offset'</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be scaled.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Scaled output data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.TreeEnsembleClassifier-1"></a>**ai.onnx.ml.TreeEnsembleClassifier-1**</a>
+
+  Tree Ensemble classifier.  Returns the top class for each of N inputs.<br>
+      The attributes named 'nodes_X' form a sequence of tuples, associated by
+      index into the sequences, which must all be of equal length. These tuples
+      define the nodes.<br>
+      Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves.
+      A leaf may have multiple votes, where each vote is weighted by
+      the associated class_weights index.<br>
+      One and only one of classlabels_strings or classlabels_int64s
+      will be defined. The class_ids are indices into this list.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>base_values</tt> : list of floats</dt>
+<dd>Base values for classification, added to final class score; the size must be the same as the classes or can be left unassigned (assumed 0)</dd>
+<dt><tt>class_ids</tt> : list of ints</dt>
+<dd>The index of the class list that each weight is for.</dd>
+<dt><tt>class_nodeids</tt> : list of ints</dt>
+<dd>node id that this weight is for.</dd>
+<dt><tt>class_treeids</tt> : list of ints</dt>
+<dd>The id of the tree that this node is in.</dd>
+<dt><tt>class_weights</tt> : list of floats</dt>
+<dd>The weight for the class in class_id.</dd>
+<dt><tt>classlabels_int64s</tt> : list of ints</dt>
+<dd>Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>classlabels_strings</tt> : list of strings</dt>
+<dd>Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>nodes_falsenodeids</tt> : list of ints</dt>
+<dd>Child node if expression is false.</dd>
+<dt><tt>nodes_featureids</tt> : list of ints</dt>
+<dd>Feature id for each node.</dd>
+<dt><tt>nodes_hitrates</tt> : list of floats</dt>
+<dd>Popularity of each node, used for performance and may be omitted.</dd>
+<dt><tt>nodes_missing_value_tracks_true</tt> : list of ints</dt>
+<dd>For each node, define what to do in the presence of a missing value: if a value is missing (NaN), use the 'true' or 'false' branch based on the value in this array.<br>This attribute may be left undefined, and the default value is false (0) for all nodes.</dd>
+<dt><tt>nodes_modes</tt> : list of strings</dt>
+<dd>The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'</dd>
+<dt><tt>nodes_nodeids</tt> : list of ints</dt>
+<dd>Node id for each node. Ids may restart at zero for each tree, but it not required to.</dd>
+<dt><tt>nodes_treeids</tt> : list of ints</dt>
+<dd>Tree id for each node.</dd>
+<dt><tt>nodes_truenodeids</tt> : list of ints</dt>
+<dd>Child node if expression is true.</dd>
+<dt><tt>nodes_values</tt> : list of floats</dt>
+<dd>Thresholds to do the splitting on for each node.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the score. <br> One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT.'</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input of shape [N,F]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>N, Top class for each point</dd>
+<dt><tt>Z</tt> : tensor(float)</dt>
+<dd>The class score for each class, for each point, a tensor of shape [N,E].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input type must be a tensor of a numeric type.</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64)</dt>
+<dd>The output type will be a tensor of strings or integers, depending on which of the classlabels_* attributes is used.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.TreeEnsembleRegressor-1"></a>**ai.onnx.ml.TreeEnsembleRegressor-1**</a>
+
+  Tree Ensemble regressor.  Returns the regressed values for each input in N.<br>
+      All args with nodes_ are fields of a tuple of tree nodes, and
+      it is assumed they are the same length, and an index i will decode the
+      tuple across these inputs.  Each node id can appear only once
+      for each tree id.<br>
+      All fields prefixed with target_ are tuples of votes at the leaves.<br>
+      A leaf may have multiple votes, where each vote is weighted by
+      the associated target_weights index.<br>
+      All trees must have their node ids start at 0 and increment by 1.<br>
+      Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>aggregate_function</tt> : string (default is SUM)</dt>
+<dd>Defines how to aggregate leaf values within a target. <br>One of 'AVERAGE,' 'SUM,' 'MIN,' 'MAX.'</dd>
+<dt><tt>base_values</tt> : list of floats</dt>
+<dd>Base values for classification, added to final class score; the size must be the same as the classes or can be left unassigned (assumed 0)</dd>
+<dt><tt>n_targets</tt> : int</dt>
+<dd>The total number of targets.</dd>
+<dt><tt>nodes_falsenodeids</tt> : list of ints</dt>
+<dd>Child node if expression is false</dd>
+<dt><tt>nodes_featureids</tt> : list of ints</dt>
+<dd>Feature id for each node.</dd>
+<dt><tt>nodes_hitrates</tt> : list of floats</dt>
+<dd>Popularity of each node, used for performance and may be omitted.</dd>
+<dt><tt>nodes_missing_value_tracks_true</tt> : list of ints</dt>
+<dd>For each node, define what to do in the presence of a NaN: use the 'true' (if the attribute value is 1) or 'false' (if the attribute value is 0) branch based on the value in this array.<br>This attribute may be left undefined and the default value is false (0) for all nodes.</dd>
+<dt><tt>nodes_modes</tt> : list of strings</dt>
+<dd>The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'</dd>
+<dt><tt>nodes_nodeids</tt> : list of ints</dt>
+<dd>Node id for each node. Node ids must restart at zero for each tree and increase sequentially.</dd>
+<dt><tt>nodes_treeids</tt> : list of ints</dt>
+<dd>Tree id for each node.</dd>
+<dt><tt>nodes_truenodeids</tt> : list of ints</dt>
+<dd>Child node if expression is true</dd>
+<dt><tt>nodes_values</tt> : list of floats</dt>
+<dd>Thresholds to do the splitting on for each node.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'</dd>
+<dt><tt>target_ids</tt> : list of ints</dt>
+<dd>The index of the target that each weight is for</dd>
+<dt><tt>target_nodeids</tt> : list of ints</dt>
+<dd>The node id of each weight</dd>
+<dt><tt>target_treeids</tt> : list of ints</dt>
+<dd>The id of the tree that each node is in.</dd>
+<dt><tt>target_weights</tt> : list of floats</dt>
+<dd>The weight for each target</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input of shape [N,F]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>N classes</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input type must be a tensor of a numeric type.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.ZipMap-1"></a>**ai.onnx.ml.ZipMap-1**</a>
+
+  Creates a map from the input and the attributes.<br>
+      The values are provided by the input tensor, while the keys are specified by the attributes.
+      Must provide keys in either classlabels_strings or classlabels_int64s (but not both).<br>
+      The columns of the tensor correspond one-by-one to the keys specified by the attributes. There must be as many columns as keys.<br>
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>classlabels_int64s</tt> : list of ints</dt>
+<dd>The keys when using int keys.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>classlabels_strings</tt> : list of strings</dt>
+<dd>The keys when using string keys.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : tensor(float)</dt>
+<dd>The input values</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> : T</dt>
+<dd>The output map</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : seq(map(string, float)), seq(map(int64, float))</dt>
+<dd>The output will be a sequence of string or integer maps to float.</dd>
+</dl>
+
+## Version 2 of the 'ai.onnx.ml' operator set
+### <a name="ai.onnx.ml.LabelEncoder-2"></a>**ai.onnx.ml.LabelEncoder-2**</a>
+
+  Maps each element in the input tensor to another value.<br>
+      The mapping is determined by the two parallel attributes, 'keys_*' and
+      'values_*' attribute. The i-th value in the specified 'keys_*' attribute
+      would be mapped to the i-th value in the specified 'values_*' attribute. It
+      implies that input's element type and the element type of the specified
+      'keys_*' should be identical while the output type is identical to the
+      specified 'values_*' attribute. If an input element can not be found in the
+      specified 'keys_*' attribute, the 'default_*' that matches the specified
+      'values_*' attribute may be used as its output value.<br>
+      Let's consider an example which maps a string tensor to an integer tensor.
+      Assume and 'keys_strings' is ["Amy", "Sally"], 'values_int64s' is [5, 6],
+      and 'default_int64' is '-1'.  The input ["Dori", "Amy", "Amy", "Sally",
+      "Sally"] would be mapped to [-1, 5, 5, 6, 6].<br>
+      Since this operator is an one-to-one mapping, its input and output shapes
+      are the same. Notice that only one of 'keys_*'/'values_*' can be set.<br>
+      For key look-up, bit-wise comparison is used so even a float NaN can be
+      mapped to a value in 'values_*' attribute.<br>
+
+#### Version
+
+This version of the operator has been available since version 2 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>default_float</tt> : float (default is -0.0)</dt>
+<dd>A float.</dd>
+<dt><tt>default_int64</tt> : int (default is -1)</dt>
+<dd>An integer.</dd>
+<dt><tt>default_string</tt> : string (default is _Unused)</dt>
+<dd>A string.</dd>
+<dt><tt>keys_floats</tt> : list of floats</dt>
+<dd>A list of floats.</dd>
+<dt><tt>keys_int64s</tt> : list of ints</dt>
+<dd>A list of ints.</dd>
+<dt><tt>keys_strings</tt> : list of strings</dt>
+<dd>A list of strings. One and only one of 'keys_*'s should be set.</dd>
+<dt><tt>values_floats</tt> : list of floats</dt>
+<dd>A list of floats.</dd>
+<dt><tt>values_int64s</tt> : list of ints</dt>
+<dd>A list of ints.</dd>
+<dt><tt>values_strings</tt> : list of strings</dt>
+<dd>A list of strings. One and only one of 'value_*'s should be set.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data. It can be either tensor or scalar.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Output data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string), tensor(int64), tensor(float)</dt>
+<dd>The input type is a tensor of any shape.</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64), tensor(float)</dt>
+<dd>Output type is determined by the specified 'values_*' attribute.</dd>
+</dl>
+
+## Version 3 of the 'ai.onnx.ml' operator set
+### <a name="ai.onnx.ml.TreeEnsembleClassifier-3"></a>**ai.onnx.ml.TreeEnsembleClassifier-3**</a>
+
+  Tree Ensemble classifier. Returns the top class for each of N inputs.<br>
+      The attributes named 'nodes_X' form a sequence of tuples, associated by
+      index into the sequences, which must all be of equal length. These tuples
+      define the nodes.<br>
+      Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves.
+      A leaf may have multiple votes, where each vote is weighted by
+      the associated class_weights index.<br>
+      One and only one of classlabels_strings or classlabels_int64s
+      will be defined. The class_ids are indices into this list.
+      All fields ending with <i>_as_tensor</i> can be used instead of the
+      same parameter without the suffix if the element type is double and not float.
+
+#### Version
+
+This version of the operator has been available since version 3 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>base_values</tt> : list of floats</dt>
+<dd>Base values for classification, added to final class score; the size must be the same as the classes or can be left unassigned (assumed 0)</dd>
+<dt><tt>base_values_as_tensor</tt> : tensor</dt>
+<dd>Base values for classification, added to final class score; the size must be the same as the classes or can be left unassigned (assumed 0)</dd>
+<dt><tt>class_ids</tt> : list of ints</dt>
+<dd>The index of the class list that each weight is for.</dd>
+<dt><tt>class_nodeids</tt> : list of ints</dt>
+<dd>node id that this weight is for.</dd>
+<dt><tt>class_treeids</tt> : list of ints</dt>
+<dd>The id of the tree that this node is in.</dd>
+<dt><tt>class_weights</tt> : list of floats</dt>
+<dd>The weight for the class in class_id.</dd>
+<dt><tt>class_weights_as_tensor</tt> : tensor</dt>
+<dd>The weight for the class in class_id.</dd>
+<dt><tt>classlabels_int64s</tt> : list of ints</dt>
+<dd>Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>classlabels_strings</tt> : list of strings</dt>
+<dd>Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>nodes_falsenodeids</tt> : list of ints</dt>
+<dd>Child node if expression is false.</dd>
+<dt><tt>nodes_featureids</tt> : list of ints</dt>
+<dd>Feature id for each node.</dd>
+<dt><tt>nodes_hitrates</tt> : list of floats</dt>
+<dd>Popularity of each node, used for performance and may be omitted.</dd>
+<dt><tt>nodes_hitrates_as_tensor</tt> : tensor</dt>
+<dd>Popularity of each node, used for performance and may be omitted.</dd>
+<dt><tt>nodes_missing_value_tracks_true</tt> : list of ints</dt>
+<dd>For each node, define what to do in the presence of a missing value: if a value is missing (NaN), use the 'true' or 'false' branch based on the value in this array.<br>This attribute may be left undefined, and the default value is false (0) for all nodes.</dd>
+<dt><tt>nodes_modes</tt> : list of strings</dt>
+<dd>The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'</dd>
+<dt><tt>nodes_nodeids</tt> : list of ints</dt>
+<dd>Node id for each node. Ids may restart at zero for each tree, but it not required to.</dd>
+<dt><tt>nodes_treeids</tt> : list of ints</dt>
+<dd>Tree id for each node.</dd>
+<dt><tt>nodes_truenodeids</tt> : list of ints</dt>
+<dd>Child node if expression is true.</dd>
+<dt><tt>nodes_values</tt> : list of floats</dt>
+<dd>Thresholds to do the splitting on for each node.</dd>
+<dt><tt>nodes_values_as_tensor</tt> : tensor</dt>
+<dd>Thresholds to do the splitting on for each node.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the score. <br> One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT.'</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input of shape [N,F]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>N, Top class for each point</dd>
+<dt><tt>Z</tt> : tensor(float)</dt>
+<dd>The class score for each class, for each point, a tensor of shape [N,E].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input type must be a tensor of a numeric type.</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64)</dt>
+<dd>The output type will be a tensor of strings or integers, depending on which of the classlabels_* attributes is used.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.TreeEnsembleRegressor-3"></a>**ai.onnx.ml.TreeEnsembleRegressor-3**</a>
+
+  Tree Ensemble regressor.  Returns the regressed values for each input in N.<br>
+      All args with nodes_ are fields of a tuple of tree nodes, and
+      it is assumed they are the same length, and an index i will decode the
+      tuple across these inputs.  Each node id can appear only once
+      for each tree id.<br>
+      All fields prefixed with target_ are tuples of votes at the leaves.<br>
+      A leaf may have multiple votes, where each vote is weighted by
+      the associated target_weights index.<br>
+      All fields ending with <i>_as_tensor</i> can be used instead of the
+      same parameter without the suffix if the element type is double and not float.
+      All trees must have their node ids start at 0 and increment by 1.<br>
+      Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF
+
+#### Version
+
+This version of the operator has been available since version 3 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>aggregate_function</tt> : string (default is SUM)</dt>
+<dd>Defines how to aggregate leaf values within a target. <br>One of 'AVERAGE,' 'SUM,' 'MIN,' 'MAX.'</dd>
+<dt><tt>base_values</tt> : list of floats</dt>
+<dd>Base values for regression, added to final prediction after applying aggregate_function; the size must be the same as the classes or can be left unassigned (assumed 0)</dd>
+<dt><tt>base_values_as_tensor</tt> : tensor</dt>
+<dd>Base values for regression, added to final prediction after applying aggregate_function; the size must be the same as the classes or can be left unassigned (assumed 0)</dd>
+<dt><tt>n_targets</tt> : int</dt>
+<dd>The total number of targets.</dd>
+<dt><tt>nodes_falsenodeids</tt> : list of ints</dt>
+<dd>Child node if expression is false</dd>
+<dt><tt>nodes_featureids</tt> : list of ints</dt>
+<dd>Feature id for each node.</dd>
+<dt><tt>nodes_hitrates</tt> : list of floats</dt>
+<dd>Popularity of each node, used for performance and may be omitted.</dd>
+<dt><tt>nodes_hitrates_as_tensor</tt> : tensor</dt>
+<dd>Popularity of each node, used for performance and may be omitted.</dd>
+<dt><tt>nodes_missing_value_tracks_true</tt> : list of ints</dt>
+<dd>For each node, define what to do in the presence of a NaN: use the 'true' (if the attribute value is 1) or 'false' (if the attribute value is 0) branch based on the value in this array.<br>This attribute may be left undefined and the default value is false (0) for all nodes.</dd>
+<dt><tt>nodes_modes</tt> : list of strings</dt>
+<dd>The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'</dd>
+<dt><tt>nodes_nodeids</tt> : list of ints</dt>
+<dd>Node id for each node. Node ids must restart at zero for each tree and increase sequentially.</dd>
+<dt><tt>nodes_treeids</tt> : list of ints</dt>
+<dd>Tree id for each node.</dd>
+<dt><tt>nodes_truenodeids</tt> : list of ints</dt>
+<dd>Child node if expression is true</dd>
+<dt><tt>nodes_values</tt> : list of floats</dt>
+<dd>Thresholds to do the splitting on for each node.</dd>
+<dt><tt>nodes_values_as_tensor</tt> : tensor</dt>
+<dd>Thresholds to do the splitting on for each node.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'</dd>
+<dt><tt>target_ids</tt> : list of ints</dt>
+<dd>The index of the target that each weight is for</dd>
+<dt><tt>target_nodeids</tt> : list of ints</dt>
+<dd>The node id of each weight</dd>
+<dt><tt>target_treeids</tt> : list of ints</dt>
+<dd>The id of the tree that each node is in.</dd>
+<dt><tt>target_weights</tt> : list of floats</dt>
+<dd>The weight for each target</dd>
+<dt><tt>target_weights_as_tensor</tt> : tensor</dt>
+<dd>The weight for each target</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input of shape [N,F]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>N classes</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input type must be a tensor of a numeric type.</dd>
+</dl>
+
+## Version 4 of the 'ai.onnx.ml' operator set
+### <a name="ai.onnx.ml.LabelEncoder-4"></a>**ai.onnx.ml.LabelEncoder-4**</a>
+
+  Maps each element in the input tensor to another value.<br>
+      The mapping is determined by the two parallel attributes, 'keys_*' and
+      'values_*' attribute. The i-th value in the specified 'keys_*' attribute
+      would be mapped to the i-th value in the specified 'values_*' attribute. It
+      implies that input's element type and the element type of the specified
+      'keys_*' should be identical while the output type is identical to the
+      specified 'values_*' attribute. Note that the 'keys_*' and 'values_*' attributes
+      must have the same length. If an input element can not be found in the
+      specified 'keys_*' attribute, the 'default_*' that matches the specified
+      'values_*' attribute may be used as its output value. The type of the 'default_*'
+      attribute must match the 'values_*' attribute chosen. <br>
+      Let's consider an example which maps a string tensor to an integer tensor.
+      Assume and 'keys_strings' is ["Amy", "Sally"], 'values_int64s' is [5, 6],
+      and 'default_int64' is '-1'.  The input ["Dori", "Amy", "Amy", "Sally",
+      "Sally"] would be mapped to [-1, 5, 5, 6, 6].<br>
+      Since this operator is an one-to-one mapping, its input and output shapes
+      are the same. Notice that only one of 'keys_*'/'values_*' can be set.<br>
+      Float keys with value 'NaN' match any input 'NaN' value regardless of bit
+      value. If a key is repeated, the last key takes precedence.
+
+#### Version
+
+This version of the operator has been available since version 4 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>default_float</tt> : float (default is -0.0)</dt>
+<dd>A float.</dd>
+<dt><tt>default_int64</tt> : int (default is -1)</dt>
+<dd>An integer.</dd>
+<dt><tt>default_string</tt> : string (default is _Unused)</dt>
+<dd>A string.</dd>
+<dt><tt>default_tensor</tt> : tensor</dt>
+<dd>A default tensor. {"_Unused"} if values_* has string type, {-1} if values_* has integral type, and {-0.f} if values_* has float type.</dd>
+<dt><tt>keys_floats</tt> : list of floats</dt>
+<dd>A list of floats.</dd>
+<dt><tt>keys_int64s</tt> : list of ints</dt>
+<dd>A list of ints.</dd>
+<dt><tt>keys_strings</tt> : list of strings</dt>
+<dd>A list of strings.</dd>
+<dt><tt>keys_tensor</tt> : tensor</dt>
+<dd>Keys encoded as a 1D tensor. One and only one of 'keys_*'s should be set.</dd>
+<dt><tt>values_floats</tt> : list of floats</dt>
+<dd>A list of floats.</dd>
+<dt><tt>values_int64s</tt> : list of ints</dt>
+<dd>A list of ints.</dd>
+<dt><tt>values_strings</tt> : list of strings</dt>
+<dd>A list of strings.</dd>
+<dt><tt>values_tensor</tt> : tensor</dt>
+<dd>Values encoded as a 1D tensor. One and only one of 'values_*'s should be set.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data. It must have the same element type as the keys_* attribute set.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Output data. This tensor's element type is based on the values_* attribute set.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string), tensor(int64), tensor(float), tensor(int32), tensor(int16), tensor(double)</dt>
+<dd>The input type is a tensor of any shape.</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64), tensor(float), tensor(int32), tensor(int16), tensor(double)</dt>
+<dd>Output type is determined by the specified 'values_*' attribute.</dd>
+</dl>
+
+## Version 5 of the 'ai.onnx.ml' operator set
+### <a name="ai.onnx.ml.TreeEnsemble-5"></a>**ai.onnx.ml.TreeEnsemble-5**</a>
+
+  Tree Ensemble operator.  Returns the regressed values for each input in a batch.
+      Inputs have dimensions `[N, F]` where `N` is the input batch size and `F` is the number of input features.
+      Outputs have dimensions `[N, num_targets]` where `N` is the batch size and `num_targets` is the number of targets, which is a configurable attribute.
+
+      The encoding of this attribute is split along interior nodes and the leaves of the trees. Notably, attributes with the prefix `nodes_*` are associated with interior nodes, and attributes with the prefix `leaf_*` are associated with leaves.
+      The attributes `nodes_*` must all have the same length and encode a sequence of tuples, as defined by taking all the `nodes_*` fields at a given position.
+
+      All fields prefixed with `leaf_*` represent tree leaves, and similarly define tuples of leaves and must have identical length.
+
+      This operator can be used to implement both the previous `TreeEnsembleRegressor` and `TreeEnsembleClassifier` nodes.
+      The `TreeEnsembleRegressor` node maps directly to this node and requires changing how the nodes are represented.
+      The `TreeEnsembleClassifier` node can be implemented by adding a `ArgMax` node after this node to determine the top class.
+      To encode class labels, a `LabelEncoder` or `GatherND` operator may be used.
+
+#### Version
+
+This version of the operator has been available since version 5 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>aggregate_function</tt> : int (default is 1)</dt>
+<dd>Defines how to aggregate leaf values within a target. <br>One of 'AVERAGE' (0) 'SUM' (1) 'MIN' (2) 'MAX (3) defaults to 'SUM' (1)</dd>
+<dt><tt>leaf_targetids</tt> : list of ints (required)</dt>
+<dd>The index of the target that this leaf contributes to (this must be in range `[0, n_targets)`).</dd>
+<dt><tt>leaf_weights</tt> : tensor (required)</dt>
+<dd>The weight for each leaf.</dd>
+<dt><tt>membership_values</tt> : tensor</dt>
+<dd>Members to test membership of for each set membership node. List all of the members to test again in the order that the 'BRANCH_MEMBER' mode appears in `node_modes`, delimited by `NaN`s. Will have the same number of sets of values as nodes with mode 'BRANCH_MEMBER'. This may be omitted if the node doesn't contain any 'BRANCH_MEMBER' nodes.</dd>
+<dt><tt>n_targets</tt> : int</dt>
+<dd>The total number of targets.</dd>
+<dt><tt>nodes_falseleafs</tt> : list of ints (required)</dt>
+<dd>1 if false branch is leaf for each node and 0 if an interior node. To represent a tree that is a leaf (only has one node), one can do so by having a single `nodes_*` entry with true and false branches referencing the same `leaf_*` entry</dd>
+<dt><tt>nodes_falsenodeids</tt> : list of ints (required)</dt>
+<dd>If `nodes_falseleafs` is false at an entry, this represents the position of the false branch node. This position can be used to index into a `nodes_*` entry. If `nodes_falseleafs` is false, it is an index into the leaf_* attributes.</dd>
+<dt><tt>nodes_featureids</tt> : list of ints (required)</dt>
+<dd>Feature id for each node.</dd>
+<dt><tt>nodes_hitrates</tt> : tensor</dt>
+<dd>Popularity of each node, used for performance and may be omitted.</dd>
+<dt><tt>nodes_missing_value_tracks_true</tt> : list of ints</dt>
+<dd>For each node, define whether to follow the true branch (if attribute value is 1) or false branch (if attribute value is 0) in the presence of a NaN input feature. This attribute may be left undefined and the default value is false (0) for all nodes.</dd>
+<dt><tt>nodes_modes</tt> : tensor (required)</dt>
+<dd>The comparison operation performed by the node. This is encoded as an enumeration of 0 ('BRANCH_LEQ'), 1 ('BRANCH_LT'), 2 ('BRANCH_GTE'), 3 ('BRANCH_GT'), 4 ('BRANCH_EQ'), 5 ('BRANCH_NEQ'), and 6 ('BRANCH_MEMBER'). Note this is a tensor of type uint8.</dd>
+<dt><tt>nodes_splits</tt> : tensor (required)</dt>
+<dd>Thresholds to do the splitting on for each node with mode that is not 'BRANCH_MEMBER'.</dd>
+<dt><tt>nodes_trueleafs</tt> : list of ints (required)</dt>
+<dd>1 if true branch is leaf for each node and 0 an interior node. To represent a tree that is a leaf (only has one node), one can do so by having a single `nodes_*` entry with true and false branches referencing the same `leaf_*` entry</dd>
+<dt><tt>nodes_truenodeids</tt> : list of ints (required)</dt>
+<dd>If `nodes_trueleafs` is false at an entry, this represents the position of the true branch node. This position can be used to index into a `nodes_*` entry. If `nodes_trueleafs` is false, it is an index into the leaf_* attributes.</dd>
+<dt><tt>post_transform</tt> : int (default is 0)</dt>
+<dd>Indicates the transform to apply to the score. <br>One of 'NONE' (0), 'SOFTMAX' (1), 'LOGISTIC' (2), 'SOFTMAX_ZERO' (3) or 'PROBIT' (4), defaults to 'NONE' (0)</dd>
+<dt><tt>tree_roots</tt> : list of ints (required)</dt>
+<dd>Index into `nodes_*` for the root of each tree. The tree structure is derived from the branching of each node.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input of shape [Batch Size, Number of Features]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output of shape [Batch Size, Number of targets]</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(float16)</dt>
+<dd>The input type must be a tensor of a numeric type.</dd>
+</dl>
+
+### <a name="ai.onnx.ml.TreeEnsembleClassifier-5"></a>**ai.onnx.ml.TreeEnsembleClassifier-5** (deprecated)</a>
+
+  This operator is DEPRECATED. Please use TreeEnsemble with provides similar functionality.
+      In order to determine the top class, the ArgMax node can be applied to the output of TreeEnsemble.
+      To encode class labels, use a LabelEncoder operator.
+      Tree Ensemble classifier. Returns the top class for each of N inputs.<br>
+      The attributes named 'nodes_X' form a sequence of tuples, associated by
+      index into the sequences, which must all be of equal length. These tuples
+      define the nodes.<br>
+      Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves.
+      A leaf may have multiple votes, where each vote is weighted by
+      the associated class_weights index.<br>
+      One and only one of classlabels_strings or classlabels_int64s
+      will be defined. The class_ids are indices into this list.
+      All fields ending with <i>_as_tensor</i> can be used instead of the
+      same parameter without the suffix if the element type is double and not float.
+
+#### Version
+
+This version of the operator has been deprecated since version 5 of the 'ai.onnx.ml' operator set.
+
+### <a name="ai.onnx.ml.TreeEnsembleRegressor-5"></a>**ai.onnx.ml.TreeEnsembleRegressor-5** (deprecated)</a>
+
+  This operator is DEPRECATED. Please use TreeEnsemble instead which provides the same
+      functionality.<br>
+      Tree Ensemble regressor.  Returns the regressed values for each input in N.<br>
+      All args with nodes_ are fields of a tuple of tree nodes, and
+      it is assumed they are the same length, and an index i will decode the
+      tuple across these inputs.  Each node id can appear only once
+      for each tree id.<br>
+      All fields prefixed with target_ are tuples of votes at the leaves.<br>
+      A leaf may have multiple votes, where each vote is weighted by
+      the associated target_weights index.<br>
+      All fields ending with <i>_as_tensor</i> can be used instead of the
+      same parameter without the suffix if the element type is double and not float.
+      All trees must have their node ids start at 0 and increment by 1.<br>
+      Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF
+
+#### Version
+
+This version of the operator has been deprecated since version 5 of the 'ai.onnx.ml' operator set.
+
diff --git a/docs/Changelog.md b/docs/Changelog.md
new file mode 100644
index 0000000..198aa0b
--- /dev/null
+++ b/docs/Changelog.md
@@ -0,0 +1,33668 @@
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+## Operator Changelog
+*This file is automatically generated from the
+            [def files](/onnx/defs) via [this script](/onnx/defs/gen_doc.py).
+            Do not modify directly and instead edit operator definitions.*
+
+For an operator input/output's differentiability, it can be differentiable,
+            non-differentiable, or undefined. If a variable's differentiability
+            is not specified, that variable has undefined differentiability.
+
+# ai.onnx (default)
+## Version 1 of the default ONNX operator set
+### <a name="Abs-1"></a>**Abs-1**</a>
+
+  Absolute takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the absolute is, y = abs(x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Add-1"></a>**Add-1**</a>
+
+  Performs element-wise binary addition (with limited broadcast support).
+
+  If necessary the right-hand-side argument will be broadcasted to match the
+  shape of left-hand-side argument. When broadcasting is specified, the second
+  tensor can either be of element size 1 (including a scalar tensor and any
+  tensor with rank equal to or smaller than the first tensor), or having its
+  shape as a contiguous subset of the first tensor's shape. The starting of the
+  mutually equal shape is specified by the argument "axis", and if it is not set,
+  suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+  For example, the following tensor shapes are supported (with broadcast=1):
+
+    shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+    shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+    shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+    shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+  Attribute `broadcast=1` needs to be passed to enable broadcasting.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions. See doc for details.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Pass 1 to enable broadcasting</dd>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand, should share the type with the second operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same dimensions and type as A</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="And-1"></a>**And-1**</a>
+
+  Returns the tensor resulted from performing the `and` logical operation
+  elementwise on the input tensors `A` and `B`.
+
+  If broadcasting is enabled, the right-hand-side argument will be broadcasted
+  to match the shape of left-hand-side argument. See the doc of `Add` for a
+  detailed description of the broadcasting rules.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Left input tensor for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Right input tensor for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input to boolean tensor.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="ArgMax-1"></a>**ArgMax-1**</a>
+
+  Computes the indices of the max elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equal 0, then the resulted tensor have the reduced dimension pruned.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="ArgMin-1"></a>**ArgMin-1**</a>
+
+  Computes the indices of the min elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equal 0, then the resulted tensor have the reduced dimension pruned.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="AveragePool-1"></a>**AveragePool-1**</a>
+
+  AveragePool consumes an input tensor X and applies average pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   average pooling consisting of computing the average on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - kernel_spatial_shape[i]) / strides_spatial_shape[i] + 1)
+
+   * pad_shape[i] is sum of pads along axis i
+   ```
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - kernel_spatial_shape[i] + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + kernel_spatial_shape[i] - input_spatial_shape[i]
+   ```
+   The output of each pooling window is divided by the number of elements exclude pad.
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="BatchNormalization-1"></a>**BatchNormalization-1**</a>
+
+  Carries out batch normalization as described in the paper
+  https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+  there are multiple cases for the number of outputs, which we list below:
+
+  Output case #1: Y, mean, var, saved_mean, saved_var (training mode)
+  Output case #2: Y (test mode)
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints (required)</dt>
+<dd>legacy optimization attribute.</dd>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero, default is 1e-5f.</dd>
+<dt><tt>is_test</tt> : int (default is 0)</dt>
+<dd>If set to nonzero, run spatial batch normalization in test mode, default is 0.</dd>
+<dt><tt>momentum</tt> : float (default is 0.9)</dt>
+<dd>Factor used in computing the running mean and variance.e.g., running_mean = running_mean * momentum + mean * (1 - momentum), default is 0.9f.</dd>
+<dt><tt>spatial</tt> : int (default is 1)</dt>
+<dd>If true, compute the mean and variance across all spatial elements If false, compute the mean and variance across per feature.Default is 1.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input 4-dimensional tensor of shape NCHW.</dd>
+<dt><tt>scale</tt> : T</dt>
+<dd>The scale as a 1-dimensional tensor of size C to be applied to the output.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>The bias as a 1-dimensional tensor of size C to be applied to the output.</dd>
+<dt><tt>mean</tt> : T</dt>
+<dd>The running mean (training) or the estimated mean (testing) as a 1-dimensional tensor of size C.</dd>
+<dt><tt>var</tt> : T</dt>
+<dd>The running variance (training) or the estimated variance (testing) as a 1-dimensional tensor of size C.</dd>
+</dl>
+
+#### Outputs (1 - 5)
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>The output 4-dimensional tensor of the same shape as X.</dd>
+<dt><tt>mean</tt> (optional) : T</dt>
+<dd>The running mean after the BatchNormalization operator. Must be in-place with the input mean. Should not be used for testing.</dd>
+<dt><tt>var</tt> (optional) : T</dt>
+<dd>The running variance after the BatchNormalization operator. Must be in-place with the input var. Should not be used for testing.</dd>
+<dt><tt>saved_mean</tt> (optional) : T</dt>
+<dd>Saved mean used during training to speed up gradient computation. Should not be used for testing.</dd>
+<dt><tt>saved_var</tt> (optional) : T</dt>
+<dd>Saved variance used during training to speed up gradient computation. Should not be used for testing.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Cast-1"></a>**Cast-1**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+  NOTE: Casting to and from strings is not supported yet.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>to</tt> : string (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool)</dt>
+<dd>Constrain input types. Casting from strings and complex are not supported.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool)</dt>
+<dd>Constrain output types. Casting to strings and complex are not supported.</dd>
+</dl>
+
+### <a name="Ceil-1"></a>**Ceil-1**</a>
+
+  Ceil takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the ceil is, y = ceil(x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Clip-1"></a>**Clip-1**</a>
+
+  Clip operator limits the given input within an interval. The interval is
+  specified with arguments 'min' and 'max'. They default to
+  numeric_limits::lowest() and numeric_limits::max() respectively.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+<dt><tt>max</tt> : float</dt>
+<dd>Maximum value, above which element is replaced by max</dd>
+<dt><tt>min</tt> : float</dt>
+<dd>Minimum value, under which element is replaced by min</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor whose elements to be clipped</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor with clipped input elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Concat-1"></a>**Concat-1**</a>
+
+  Concatenate a list of tensors into a single tensor
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>Which axis to concat on.  Default value is 1.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>inputs</tt> (variadic) : T</dt>
+<dd>List of tensors for concatenation</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>concat_result</tt> : T</dt>
+<dd>Concatenated tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+### <a name="Constant-1"></a>**Constant-1**</a>
+
+  A constant tensor.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>value</tt> : tensor (required)</dt>
+<dd>The value for the elements of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Conv-1"></a>**Conv-1**</a>
+
+  The convolution operator consumes an input tensor and a filter, and
+  computes the output.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input W.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn). Optionally, if dimension denotation is in effect, the operation expects input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (M x C/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the kernel shape will be (M x C/group x k1 x k2 x ... x kn), where (k1 x k2 x ... kn) is the dimension of the kernel. Optionally, if dimension denotation is in effect, the operation expects the weight tensor to arrive with the dimension denotation of [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. X.shape[1] == (W.shape[1] * group) == C (assuming zero based indices for the shape array). Or in other words FILTER_IN_CHANNEL should be equal to DATA_CHANNEL. </dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, and pad lengths.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="ConvTranspose-1"></a>**ConvTranspose-1**</a>
+
+  The convolution transpose operator consumes an input tensor and a filter,
+  and computes the output.
+
+  If the pads parameter is provided the shape of the output is calculated via the following equation:
+
+    output_shape[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - pads[start_i] - pads[end_i]
+
+  output_shape can also be explicitly specified in which case pads values are auto generated using these equations:
+
+    total_padding[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - output_shape[i]
+    If (auto_pads != SAME_UPPER): pads[start_i] = total_padding[i]/2; pads[end_i] = total_padding[i] - (total_padding[i]/2)
+    Else: pads[start_i] = total_padding[i] - (total_padding[i]/2); pads[end_i] = (total_padding[i]/2).
+
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input W.</dd>
+<dt><tt>output_padding</tt> : list of ints</dt>
+<dd>The zero-padding added to one side of the output. This is also called adjs/adjustment in some frameworks.</dd>
+<dt><tt>output_shape</tt> : list of ints</dt>
+<dd>The shape of the output can be explicitly set which will cause pads values to be auto generated. If output_shape is specified pads values are ignored. See doc for details for equations to generate pads</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn)</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (C x M/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the weight shape will be (C x M/group x k1 x k2 x ... x kn), where (k1 x k2 x ... x kn) is the dimension of the kernel. The number of channels in the output should be equal to W.shape[1] * group (assuming zero based indices of the shape array)</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, pad lengths and group count. The number of channels in the output should be equal to W.shape[1] * group (assuming zero based indices of the shape array)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="DepthToSpace-1"></a>**DepthToSpace-1**</a>
+
+  DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
+  This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
+  the input tensor where values from the depth dimension are moved in spatial blocks to the height
+  and width dimensions.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>blocksize</tt> : int (required)</dt>
+<dd>Blocks of [blocksize, blocksize] are moved.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Div-1"></a>**Div-1**</a>
+
+  Performs element-wise binary division (with limited broadcast support).
+
+  If necessary the right-hand-side argument will be broadcasted to match the
+  shape of left-hand-side argument. When broadcasting is specified, the second
+  tensor can either be of element size 1 (including a scalar tensor and any
+  tensor with rank equal to or smaller than the first tensor), or having its
+  shape as a contiguous subset of the first tensor's shape. The starting of the
+  mutually equal shape is specified by the argument "axis", and if it is not set,
+  suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+  For example, the following tensor shapes are supported (with broadcast=1):
+
+    shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+    shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+    shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+    shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+  Attribute `broadcast=1` needs to be passed to enable broadcasting.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions. See doc for details.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Pass 1 to enable broadcasting</dd>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand, should share the type with the second operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same dimensions and type as A</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Dropout-1"></a>**Dropout-1**</a>
+
+  Dropout takes one input data (Tensor<float>) and produces two Tensor outputs,
+  output (Tensor<float>) and mask (Tensor<bool>). Depending on whether it is in
+  test mode or not, the output Y will either be a random dropout, or a simple
+  copy of the input. Note that our implementation of Dropout does scaling in
+  the training phase, so during testing nothing needs to be done.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+<dt><tt>is_test</tt> : int (default is 0)</dt>
+<dd>(int, default 0) if nonzero, run dropout in test mode where the output is simply Y = X.</dd>
+<dt><tt>ratio</tt> : float (default is 0.5)</dt>
+<dd>(float, default 0.5) the ratio of random dropout</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>The input data as Tensor.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output.</dd>
+<dt><tt>mask</tt> (optional) : T</dt>
+<dd>The output mask. If is_test is nonzero, this output is not filled.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Elu-1"></a>**Elu-1**</a>
+
+  Elu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the function `f(x) = alpha * (exp(x) - 1.) for x <
+  0`, `f(x) = x for x >= 0`., is applied to the tensor elementwise.
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Coefficient of ELU default to 1.0.</dd>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Equal-1"></a>**Equal-1**</a>
+
+  Returns the tensor resulted from performing the `equal` logical operation
+  elementwise on the input tensors `A` and `B`.
+
+  If broadcasting is enabled, the right-hand-side argument will be broadcasted
+  to match the shape of left-hand-side argument. See the doc of `Add` for a
+  detailed description of the broadcasting rules.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Left input tensor for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Right input tensor for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input to integral tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Exp-1"></a>**Exp-1**</a>
+
+  Calculates the exponential of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The exponential of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Flatten-1"></a>**Flatten-1**</a>
+
+  Flattens the input tensor into a 2D matrix. If input tensor has shape
+  (d_0, d_1, ... d_n) then the output will have shape
+  (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Indicate up to which input dimensions (exclusive) should be flattened to the outer dimension of the output. The value for axis must be in the range [0, R], where R is the rank of the input tensor. When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), where the shape of the input tensor is (d_0, d_1, ... d_n). </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>A tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>A 2D tensor with the contents of the input tensor, with input dimensions up to axis flattened to the outer dimension of the output and remaining input dimensions flattened into the inner dimension of the output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Floor-1"></a>**Floor-1**</a>
+
+  Floor takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the floor is, y = floor(x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="GRU-1"></a>**GRU-1**</a>
+
+  Computes an one-layer GRU. This operator is usually supported via some custom
+  implementation such as CuDNN.
+
+  Notations:
+
+  `X` - input tensor
+
+  `z` - update gate
+
+  `r` - reset gate
+
+  `h` - hidden gate
+
+  `t` - time step (t-1 means previous time step)
+
+  `W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+
+  `R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+
+  `Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+
+  `Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+
+  `WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+
+  `RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+
+  `WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+
+  `RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+
+  `H` - Hidden state
+
+  `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+    Relu(x)                - max(0, x)
+
+    Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+    Sigmoid(x)             - 1/(1 + e^{-x})
+
+    (NOTE: Below are optional)
+
+    Affine(x)              - alpha*x + beta
+
+    LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+    ThresholdedRelu(x)     - x if x >= alpha else 0
+
+    ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+    HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+    Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+    Softsign(x)            - x/(1 + |x|)
+
+    Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh):
+
+    - zt = f(Xt*(Wz^T) + Ht-1*Rz + Wbz + Rbz)
+
+    - rt = f(Xt*(Wr^T) + Ht-1*Rr + Wbr + Rbr)
+
+    - ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*Rh + Rbh + Wbh) # default, when linear_before_reset = 0
+
+    - ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*Rh + Rbh) + Wbh) # when linear_before_reset != 0
+
+    - Ht = (1 - zt) (.) ht + zt (.) Ht-1
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 2 (or 4 if bidirectional) activation functions for update, reset, and hidden gates. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is foward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>output_sequence</tt> : int (default is 0)</dt>
+<dd>The sequence output for the hidden is optional if 0. Default 0.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and `[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 6*hidden_size]`. Optional: If not specified - assumed to be 0</dd>
+<dt><tt>sequence_lens</tt> (optional) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (optional) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. It is optional if `output_sequence` is 0.</dd>
+<dt><tt>Y_h</tt> : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="Gather-1"></a>**Gather-1**</a>
+
+  Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
+  entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
+  them in an output tensor of rank q + (r - 1).
+  Example 1:
+  ```
+    data = [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+    indices = [
+        [0, 1],
+        [1, 2],
+    ]
+    output = [
+        [
+            [1.0, 1.2],
+            [2.3, 3.4],
+        ],
+        [
+            [2.3, 3.4],
+            [4.5, 5.7],
+        ],
+    ]
+  ```
+  Example 2:
+  ```
+    data = [
+        [1.0, 1.2, 1.9],
+        [2.3, 3.4, 3.9],
+        [4.5, 5.7, 5.9],
+    ]
+    indices = [
+        [0, 2],
+    ]
+    axis = 1,
+    output = [
+        [[1.0, 1.9]],
+        [[2.3, 3.9]],
+        [[4.5, 5.9]],
+    ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to gather on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1]</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> : Tind</dt>
+<dd>Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor of rank q + (r - 1).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="Gemm-1"></a>**Gemm-1**</a>
+
+  General Matrix multiplication:
+  https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+  Compute Y = alpha * A * B + beta * C, where input tensor A has
+  dimension (M X K), input tensor B has dimension (K X N), input tensor C and
+  output tensor Y have dimension (M X N).
+  If attribute broadcast is non-zero, input tensor C will be broadcasted to match
+  the dimension requirement. A will be transposed before doing the computation
+  if attribute transA is non-zero, same for B and transB.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for the product of input tensors A * B, the default value is 1.0.</dd>
+<dt><tt>beta</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for input tensor C, the default value is 1.0.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Whether C should be broadcasted</dd>
+<dt><tt>transA</tt> : int (default is 0)</dt>
+<dd>Whether A should be transposed</dd>
+<dt><tt>transB</tt> : int (default is 0)</dt>
+<dd>Whether B should be transposed</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Input tensor A</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Input tensor B</dd>
+<dt><tt>C</tt> : T</dt>
+<dd>Input tensor C, can be inplace.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="GlobalAveragePool-1"></a>**GlobalAveragePool-1**</a>
+
+  GlobalAveragePool consumes an input tensor X and applies average pooling across
+   the values in the same channel. This is equivalent to AveragePool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from pooling across the input tensor. The output tensor has the same rank as the input. The first two dimensions of output shape are the same as the input (N x C), while the other dimensions are all 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="GlobalLpPool-1"></a>**GlobalLpPool-1**</a>
+
+  GlobalLpPool consumes an input tensor X and applies lp pool pooling across the
+   the values in the same channel. This is equivalent to LpPool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>p</tt> : float (default is 2.0)</dt>
+<dd>p value of the Lp norm used to pool over the input data, default is 2.0.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimension are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from pooling across the input tensor. Dimensions will be N x C x 1 x 1</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="GlobalMaxPool-1"></a>**GlobalMaxPool-1**</a>
+
+  GlobalMaxPool consumes an input tensor X and applies max pooling across
+   the values in the same channel. This is equivalent to MaxPool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from pooling across the input tensor. The output tensor has the same rank as the input. The first two dimensions of output shape are the same as the input (N x C), while the other dimensions are all 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Greater-1"></a>**Greater-1**</a>
+
+  Returns the tensor resulted from performing the `greater` logical operation
+  elementwise on the input tensors `A` and `B`.
+
+  If broadcasting is enabled, the right-hand-side argument will be broadcasted
+  to match the shape of left-hand-side argument. See the doc of `Add` for a
+  detailed description of the broadcasting rules.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Left input tensor for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Right input tensor for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="HardSigmoid-1"></a>**HardSigmoid-1**</a>
+
+  HardSigmoid takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the HardSigmoid function, y = max(0, min(1, alpha * x + beta)),
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.2)</dt>
+<dd>Value of alpha default to 0.2</dd>
+<dt><tt>beta</tt> : float (default is 0.5)</dt>
+<dd>Value of beta default to 0.5</dd>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Hardmax-1"></a>**Hardmax-1**</a>
+
+  The operator computes the hardmax (1 for the first maximum value, and 0 for all others) values for each layer in the batch
+   of the given input. The input is a 2-D tensor (Tensor<float>) of size
+  (batch_size x input_feature_dimensions). The output tensor has the same shape
+  and contains the hardmax values of the corresponding input.
+
+  Input does not need to explicitly be a 2D vector; rather, it will be
+  coerced into one. For an arbitrary n-dimensional tensor
+  input \in [a_0, a_1, ..., a_{k-1}, a_k, ..., a_{n-1}] and k is
+  the axis provided, then input will be coerced into a 2-dimensional tensor with
+  dimensions [a_0 * ... * a_{k-1}, a_k * ... * a_{n-1}]. For the default
+  case where axis=1, this means the input tensor will be coerced into a 2D tensor
+  of dimensions [a_0, a_1 * ... * a_{n-1}], where a_0 is often the batch size.
+  In this situation, we must have a_0 = N and a_1 * ... * a_{n-1} = D.
+  Each of these dimensions must be matched correctly, or else the operator
+  will throw errors.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Describes the axis of the inputs when coerced to 2D; defaults to one because the 0th axis most likely describes the batch_size</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The input tensor that's coerced into a 2D matrix of size (NxD) as described above.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output values with the same shape as input tensor (the original size without coercion).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Identity-1"></a>**Identity-1**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="If-1"></a>**If-1**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same shape and same data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>All Tensor types</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+### <a name="InstanceNormalization-1"></a>**InstanceNormalization-1**</a>
+
+  Carries out instance normalization as described in the paper
+  https://arxiv.org/abs/1607.08022.
+
+  y = scale * (x - mean) / sqrt(variance + epsilon) + B,
+  where mean and variance are computed per instance per channel.
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero, default is 1e-5f.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The input 4-dimensional tensor of shape NCHW.</dd>
+<dt><tt>scale</tt> : T</dt>
+<dd>The input 1-dimensional scale tensor of size C.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>The input 1-dimensional bias tensor of size C.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output 4-dimensional tensor of the same shape as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LRN-1"></a>**LRN-1**</a>
+
+  Local Response Normalization proposed in the [AlexNet paper](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf).
+  It normalizes over local input regions.
+  The local region is defined across the channels. For an element X[n, c, d1, ..., dk] in a tensor
+  of shape (N x C x D1 x D2, ..., Dk), its region is
+  {X[n, i, d1, ..., dk] | max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))}.
+
+  square_sum[n, c, d1, ..., dk] = sum(X[n, i, d1, ..., dk] ^ 2),
+  where max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2)).
+
+  Y[n, c, d1, ..., dk] = X[n, c, d1, ..., dk] / (bias + alpha / size * square_sum[n, c, d1, ..., dk] ) ^ beta
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.0001)</dt>
+<dd>Scaling parameter.</dd>
+<dt><tt>beta</tt> : float (default is 0.75)</dt>
+<dd>The exponent.</dd>
+<dt><tt>bias</tt> : float (default is 1.0)</dt>
+<dd></dd>
+<dt><tt>size</tt> : int (required)</dt>
+<dd>The number of channels to sum over</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor, which has the shape and type as input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output  types to float tensors.</dd>
+</dl>
+
+### <a name="LSTM-1"></a>**LSTM-1**</a>
+
+  Computes an one-layer LSTM. This operator is usually supported via some
+  custom implementation such as CuDNN.
+
+  Notations:
+
+  `X` - input tensor
+
+  `i` - input gate
+
+  `o` - output gate
+
+  `f` - forget gate
+
+  `c` - cell gate
+
+  `t` - time step (t-1 means previous time step)
+
+  `W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
+
+  `R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
+
+  `Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
+
+  `Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
+
+  `P[iof]`  - P peephole weight vector for input, output, and forget gates
+
+  `WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
+
+  `RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
+
+  `WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
+
+  `RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
+
+  `PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
+
+  `H` - Hidden state
+
+  `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+    Relu(x)                - max(0, x)
+
+    Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+    Sigmoid(x)             - 1/(1 + e^{-x})
+
+    (NOTE: Below are optional)
+
+    Affine(x)              - alpha*x + beta
+
+    LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+    ThresholdedRelu(x)     - x if x >= alpha else 0
+
+    ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+    HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+    Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+    Softsign(x)            - x/(1 + |x|)
+
+    Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh, h=Tanh):
+
+    - it = f(Xt*(Wi^T) + Ht-1*Ri + Pi (.) Ct-1 + Wbi + Rbi)
+
+    - ft = f(Xt*(Wf^T) + Ht-1*Rf + Pf (.) Ct-1 + Wbf + Rbf)
+
+    - ct = g(Xt*(Wc^T) + Ht-1*Rc + Wbc + Rbc)
+
+    - Ct = ft (.) Ct-1 + it (.) ct
+
+    - ot = f(Xt*(Wo^T) + Ht-1*Ro + Po (.) Ct + Wbo + Rbo)
+
+    - Ht = ot (.) h(Ct)
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 3 (or 6 if bidirectional) activation functions for input, output, forget, cell, and hidden. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>input_forget</tt> : int (default is 0)</dt>
+<dd>Couple the input and forget gates if 1, default 0.</dd>
+<dt><tt>output_sequence</tt> : int (default is 0)</dt>
+<dd>The sequence output for the hidden is optional if 0. Default 0.</dd>
+</dl>
+
+#### Inputs (3 - 8)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[iofc]` and `WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape `[num_directions, 4*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[iofc]` and `RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 4*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>initial_c</tt> (optional) : T</dt>
+<dd>Optional initial value of the cell. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>P</tt> (optional) : T</dt>
+<dd>The weight tensor for peepholes. Concatenation of `P[iof]` and `PB[iof]` (if bidirectional) along dimension 0. It has shape `[num_directions, 3*hidde_size]`. Optional: If not specified - assumed to be 0.</dd>
+</dl>
+
+#### Outputs (0 - 3)
+
+<dl>
+<dt><tt>Y</tt> (optional) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. It is optional if `output_sequence` is 0.</dd>
+<dt><tt>Y_h</tt> (optional) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>Y_c</tt> (optional) : T</dt>
+<dd>The last output value of the cell. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="LeakyRelu-1"></a>**LeakyRelu-1**</a>
+
+  LeakyRelu takes input data (Tensor<T>) and an argument alpha, and produces one
+  output data (Tensor<T>) where the function `f(x) = alpha * x for x < 0`,
+  `f(x) = x for x >= 0`, is applied to the data tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.01)</dt>
+<dd>Coefficient of leakage default to 0.01.</dd>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Less-1"></a>**Less-1**</a>
+
+  Returns the tensor resulted from performing the `less` logical operation
+  elementwise on the input tensors `A` and `B`.
+
+  If broadcasting is enabled, the right-hand-side argument will be broadcasted
+  to match the shape of left-hand-side argument. See the doc of `Add` for a
+  detailed description of the broadcasting rules.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Left input tensor for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Right input tensor for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Log-1"></a>**Log-1**</a>
+
+  Calculates the natural log of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The natural log of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LogSoftmax-1"></a>**LogSoftmax-1**</a>
+
+  The operator computes the logsoftmax (log of softmax) values for each layer in the batch
+   of the given input. The input is a 2-D tensor (Tensor<float>) of size
+  (batch_size x input_feature_dimensions). The output tensor has the same shape
+  and contains the logsoftmax values of the corresponding input.
+
+  Input does not need to explicitly be a 2D vector; rather, it will be
+  coerced into one. For an arbitrary n-dimensional tensor
+  input \in [a_0, a_1, ..., a_{k-1}, a_k, ..., a_{n-1}] and k is
+  the axis provided, then input will be coerced into a 2-dimensional tensor with
+  dimensions [a_0 * ... * a_{k-1}, a_k * ... * a_{n-1}]. For the default
+  case where axis=1, this means the input tensor will be coerced into a 2D tensor
+  of dimensions [a_0, a_1 * ... * a_{n-1}], where a_0 is often the batch size.
+  In this situation, we must have a_0 = N and a_1 * ... * a_{n-1} = D.
+  Each of these dimensions must be matched correctly, or else the operator
+  will throw errors.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Describes the axis of the inputs when coerced to 2D; defaults to one because the 0th axis most likely describes the batch_size</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The input tensor that's coerced into a 2D matrix of size (NxD) as described above.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output values with the same shape as input tensor (the original size without coercion).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Loop-1"></a>**Loop-1**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+      input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+      input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+      input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+      input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+      input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]
+        %keepgoing[BOOL, scalar]
+        %b[INT32, scalar]
+      ) {
+        %my_local = Add(%a, %b)
+        %b_out = Sub(%a, %b)
+        %keepgoing_out = Greater(%my_local, %b_out)
+        %user_defined_vals = Add(%b, %b)
+        return %keepgoing_out, %b_out, %user_defined_vals
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        for (int i=0; i < max_trip_count && keepgoing; ++i) {
+          /* User-defined code (loop body) */
+          int my_local = a + b; // Reading values in the enclosing scope is fine
+          b = a - b; // writes fine if we specify b as a loop-carried dependency
+          keepgoing = my_local > b; // keepgoing is a loop-carried dependency
+          user_defined_vals[i] = b + b;
+          /* End user-defined code */
+        }
+        // my_local = 123; // Can't do this. my_local was defined in the body
+
+        // These below values are live-out from the loop and therefore accessible
+        b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable a here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any variables which you wish to make available in the enclosing scope (i.e.
+     the variables b and keepgoing) must be declared as either loop-carried
+     dependencies (both at the op inputs and output and at the body net input and
+     output) or scan_outputs.
+  3) Values created in the body cannot be accessed in the enclosing scope.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (3 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>All Tensor types</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+### <a name="LpNormalization-1"></a>**LpNormalization-1**</a>
+
+  Given a matrix, apply Lp-normalization along the provided axis.
+  The output is computed as: `output = input / Lp_norm(input, axis)`.
+  When the Lp norm is zero (i.e., all elements along the axis are zero),
+  the output is defined to be zero to avoid division by zero.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>The axis on which to apply normalization, -1 mean last axis.</dd>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>The order of the normalization, only 1 or 2 are supported.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input matrix</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Matrix after normalization</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LpPool-1"></a>**LpPool-1**</a>
+
+  LpPool consumes an input tensor X and applies Lp pooling across the
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   Lp pooling consisting of computing the Lp norm on all values of a subset
+   of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding. DEPRECATION NOTE: auto_pad is only intended to support legacy uses, and for framework authors, one is explicitly encouraged to use explicit padding specified in the pads attribute.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>p</tt> : float (default is 2.0)</dt>
+<dd>p value of the Lp norm used to pool over the input data, default is 2.0.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimension are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="MatMul-1"></a>**MatMul-1**</a>
+
+  Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>N-dimensional matrix A</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>N-dimensional matrix B</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Matrix multiply results from A * B</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Max-1"></a>**Max-1**</a>
+
+  Element-wise max of each of the input tensors. All inputs and outputs must
+  have the same shape and data type.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for Max.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>max</tt> : T</dt>
+<dd>Output tensor. Same dimension as inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="MaxPool-1"></a>**MaxPool-1**</a>
+
+  MaxPool consumes an input tensor X and applies max pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   max pooling consisting of computing the max on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - kernel_spatial_shape[i]) / strides_spatial_shape[i] + 1)
+
+   * pad_shape[i] is sum of pads along axis i
+   ```
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - kernel_spatial_shape[i] + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + kernel_spatial_shape[i] - input_spatial_shape[i]
+   ```
+   The output of each pooling window is maximum number of elements exclude pad.
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="MaxRoiPool-1"></a>**MaxRoiPool-1**</a>
+
+  ROI max pool consumes an input tensor X and region of interests (RoIs) to
+   apply max pooling across each RoI, to produce output 4-D tensor of shape
+   (num_rois, channels, pooled_shape[0], pooled_shape[1]).
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>pooled_shape</tt> : list of ints (required)</dt>
+<dd>ROI pool output shape (height, width).</dd>
+<dt><tt>spatial_scale</tt> : float (default is 1.0)</dt>
+<dd>Multiplicative spatial scale factor to translate ROI coordinates from their input scale to the scale used when pooling.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data.</dd>
+<dt><tt>rois</tt> (non-differentiable) : T</dt>
+<dd>RoIs (Regions of Interest) to pool over. Should be a 2-D tensor of shape (num_rois, 5) given as [[batch_id, x1, y1, x2, y2], ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>RoI pooled output 4-D tensor of shape (num_rois, channels, pooled_shape[0], pooled_shape[1]).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Mean-1"></a>**Mean-1**</a>
+
+  Element-wise mean of each of the input tensors. All inputs and outputs must
+  have the same shape and data type.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for Mean.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>mean</tt> : T</dt>
+<dd>Output tensor. Same dimension as inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Min-1"></a>**Min-1**</a>
+
+  Element-wise min of each of the input tensors. All inputs and outputs must
+  have the same shape and data type.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for Min</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>min</tt> : T</dt>
+<dd>Output tensor. Same dimension as inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Mul-1"></a>**Mul-1**</a>
+
+  Performs element-wise binary multiplication (with limited broadcast support).
+
+  If necessary the right-hand-side argument will be broadcasted to match the
+  shape of left-hand-side argument. When broadcasting is specified, the second
+  tensor can either be of element size 1 (including a scalar tensor and any
+  tensor with rank equal to or smaller than the first tensor), or having its
+  shape as a contiguous subset of the first tensor's shape. The starting of the
+  mutually equal shape is specified by the argument "axis", and if it is not set,
+  suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+  For example, the following tensor shapes are supported (with broadcast=1):
+
+    shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+    shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+    shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+    shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+  Attribute `broadcast=1` needs to be passed to enable broadcasting.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions. See doc for details.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Pass 1 to enable broadcasting</dd>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand, should share the type with the second operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same dimensions and type as A</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Neg-1"></a>**Neg-1**</a>
+
+  Neg takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where each element flipped sign, y = -x, is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Not-1"></a>**Not-1**</a>
+
+  Returns the negation of the input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input/output to boolean tensors.</dd>
+</dl>
+
+### <a name="Or-1"></a>**Or-1**</a>
+
+  Returns the tensor resulted from performing the `or` logical operation
+  elementwise on the input tensors `A` and `B`.
+
+  If broadcasting is enabled, the right-hand-side argument will be broadcasted
+  to match the shape of left-hand-side argument. See the doc of `Add` for a
+  detailed description of the broadcasting rules.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Left input tensor for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Right input tensor for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input to boolean tensor.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="PRelu-1"></a>**PRelu-1**</a>
+
+  PRelu takes input data (Tensor<T>) and slope tensor as input, and produces one
+  output data (Tensor<T>) where the function `f(x) = slope * x for x < 0`,
+  `f(x) = x for x >= 0`., is applied to the data tensor elementwise.
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+<dt><tt>slope</tt> : T</dt>
+<dd>Slope tensor. If `Slope` is of size 1, the value is sharedacross different channels</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Pad-1"></a>**Pad-1**</a>
+
+  Given `data` tensor, paddings, mode, and value.
+  Example:
+    Insert 0 paddings to the beginning of the second dimension.
+    data = [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+    paddings = [0, 0, 2, 0]
+    output = [
+        [
+            [0.0, 0.0, 1.0, 1.2],
+            [0.0, 0.0, 2.3, 3.4],
+            [0.0, 0.0, 4.5, 5.7],
+        ],
+    ]
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Three modes: constant(default), reflect, edge</dd>
+<dt><tt>paddings</tt> : list of ints (required)</dt>
+<dd>List of integers indicate the padding element count at the beginning and end of each axis, for 2D it is the number of pixel. `paddings` rank should be double of the input's rank. `paddings` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`.</dd>
+<dt><tt>value</tt> : float (default is 0.0)</dt>
+<dd>One float, indicates the value to be filled, default is 0</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Pow-1"></a>**Pow-1**</a>
+
+  Pow takes input data (Tensor<T>) and exponent Tensor, and
+  produces one output data (Tensor<T>) where the function `f(x) = x^exponent`,
+  is applied to the data tensor elementwise.
+
+  If necessary the right-hand-side argument will be broadcasted to match the
+  shape of left-hand-side argument. When broadcasting is specified, the second
+  tensor can either be of element size 1 (including a scalar tensor and any
+  tensor with rank equal to or smaller than the first tensor), or having its
+  shape as a contiguous subset of the first tensor's shape. The starting of the
+  mutually equal shape is specified by the argument "axis", and if it is not set,
+  suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+  For example, the following tensor shapes are supported (with broadcast=1):
+
+    shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+    shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+    shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+    shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+  Attribute `broadcast=1` needs to be passed to enable broadcasting.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions. See doc for details.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Pass 1 to enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor of any shape, base of the exponent.</dd>
+<dt><tt>Y</tt> : T</dt>
+<dd>Input tensor of any shape broadcastable to X shape, the exponent component.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> : T</dt>
+<dd>Output tensor (same size as X)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="RNN-1"></a>**RNN-1**</a>
+
+  Computes an one-layer simple RNN. This operator is usually supported
+  via some custom implementation such as CuDNN.
+
+  Notations:
+
+  `X` - input tensor
+
+  `i` - input gate
+
+  `t` - time step (t-1 means previous time step)
+
+  `Wi` - W parameter weight matrix for input gate
+
+  `Ri` - R recurrence weight matrix for input gate
+
+  `Wbi` - W parameter bias vector for input gate
+
+  `Rbi` - R parameter bias vector for input gate
+
+  `WBi` - W parameter weight matrix for backward input gate
+
+  `RBi` - R recurrence weight matrix for backward input gate
+
+  `WBbi` - WR bias vectors for backward input gate
+
+  `RBbi` - RR bias vectors for backward input gate
+
+  `H` - Hidden state
+
+  `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+    Relu(x)                - max(0, x)
+
+    Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+    Sigmoid(x)             - 1/(1 + e^{-x})
+
+    (NOTE: Below are optional)
+
+    Affine(x)              - alpha*x + beta
+
+    LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+    ThresholdedRelu(x)     - x if x >= alpha else 0
+
+    ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+    HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+    Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+    Softsign(x)            - x/(1 + |x|)
+
+    Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Tanh):
+
+    - Ht = f(Xt*(Wi^T) + Ht-1*Ri + Wbi + Rbi)
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings (default is ['Tanh', 'Tanh'])</dt>
+<dd>One (or two if bidirectional) activation function for input gate. The activation function must be one of the activation functions specified above. Optional: Default `Tanh` if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>output_sequence</tt> : int (default is 0)</dt>
+<dd>The sequence output for the hidden is optional if 0. Default 0.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>The weight tensor for input gate. Concatenation of `Wi` and `WBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `Ri` and `RBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` and `[WBbi, RBbi]` (if bidirectional). The tensor has shape `[num_directions, 2*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. It is optional if `output_sequence` is 0.</dd>
+<dt><tt>Y_h</tt> (optional) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="RandomNormal-1"></a>**RandomNormal-1**</a>
+
+  Generate a tensor with random values drawn from a normal distribution. The shape
+  of the tensor is specified by the `shape` argument and the parameter of the normal distribution
+  specified by `mean` and `scale`.
+
+  The data type is specified by the 'dtype' argument. The 'dtype' argument must
+  be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int (default is 1)</dt>
+<dd>The data type for the elements of the output tensor. Default is TensorProto::FLOAT.</dd>
+<dt><tt>mean</tt> : float (default is 0.0)</dt>
+<dd>The mean of the normal distribution.</dd>
+<dt><tt>scale</tt> : float (default is 1.0)</dt>
+<dd>The standard deviation of the normal distribution.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+<dt><tt>shape</tt> : list of ints (required)</dt>
+<dd>The shape of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of random values drawn from normal distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+### <a name="RandomNormalLike-1"></a>**RandomNormalLike-1**</a>
+
+  Generate a tensor with random values drawn from a normal distribution.
+  The shape of the output tensor is copied from the shape of the input tensor,
+  and the parameters of the normal distribution are specified by `mean` and `scale`.
+
+  The data type is specified by the 'dtype' argument, or copied from the input tensor if not provided.
+  The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message, and be valid as an output type.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type for the elements of the output tensor, if not specified, we will use the data type of the input tensor.</dd>
+<dt><tt>mean</tt> : float (default is 0.0)</dt>
+<dd>The mean of the normal distribution.</dd>
+<dt><tt>scale</tt> : float (default is 1.0)</dt>
+<dd>The standard deviation of the normal distribution.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor to copy shape and optionally type information from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of random values drawn from normal distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+### <a name="RandomUniform-1"></a>**RandomUniform-1**</a>
+
+  Generate a tensor with random values drawn from a uniform distribution. The shape
+  of the tensor is specified by the `shape` argument and the range by `low` and `high`.
+
+  The data type is specified by the 'dtype' argument. The 'dtype' argument must
+  be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int (default is 1)</dt>
+<dd>The data type for the elements of the output tensor. If not specified, default is TensorProto::FLOAT.</dd>
+<dt><tt>high</tt> : float (default is 1.0)</dt>
+<dd>Upper boundary of the output values.</dd>
+<dt><tt>low</tt> : float (default is 0.0)</dt>
+<dd>Lower boundary of the output values.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+<dt><tt>shape</tt> : list of ints (required)</dt>
+<dd>The shape of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of random values drawn from uniform distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+### <a name="RandomUniformLike-1"></a>**RandomUniformLike-1**</a>
+
+  Generate a tensor with random values drawn from a uniform distribution.
+  The shape of the output tensor is copied from the shape of the input tensor,
+  and the parameters of the uniform distribution are specified by `low` and `high`.
+
+  The data type is specified by the 'dtype' argument, or copied from the input tensor if not provided.
+  The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message and be valid as an output type.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type for the elements of the output tensor, if not specified, we will use the data type of the input tensor.</dd>
+<dt><tt>high</tt> : float (default is 1.0)</dt>
+<dd>Upper boundary of the output values.</dd>
+<dt><tt>low</tt> : float (default is 0.0)</dt>
+<dd>Lower boundary of the output values.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor to copy shape and optionally type information from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of random values drawn from uniform distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+### <a name="Reciprocal-1"></a>**Reciprocal-1**</a>
+
+  Reciprocal takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the reciprocal is, y = 1/x, is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="ReduceL1-1"></a>**ReduceL1-1**</a>
+
+  Computes the L1 norm of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceL2-1"></a>**ReduceL2-1**</a>
+
+  Computes the L2 norm of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceLogSum-1"></a>**ReduceLogSum-1**</a>
+
+  Computes the log sum of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or undefined otherwise.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceLogSumExp-1"></a>**ReduceLogSumExp-1**</a>
+
+  Computes the log sum exponent of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or undefined otherwise.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMax-1"></a>**ReduceMax-1**</a>
+
+  Computes the max of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or the minimum value of the data type otherwise.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMean-1"></a>**ReduceMean-1**</a>
+
+  Computes the mean of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields undefined.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMin-1"></a>**ReduceMin-1**</a>
+
+  Computes the min of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields plus infinity (if supported by the datatype) or the maximum value of the data type otherwise.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceProd-1"></a>**ReduceProd-1**</a>
+
+  Computes the product of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 1.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceSum-1"></a>**ReduceSum-1**</a>
+
+  Computes the sum of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceSumSquare-1"></a>**ReduceSumSquare-1**</a>
+
+  Computes the sum square of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor.</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Relu-1"></a>**Relu-1**</a>
+
+  Relu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the rectified linear function, y = max(0, x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Reshape-1"></a>**Reshape-1**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  It takes a tensor as input and an argument `shape`. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+<dt><tt>shape</tt> : list of ints</dt>
+<dd>New shape</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Selu-1"></a>**Selu-1**</a>
+
+  Selu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the scaled exponential linear unit function,
+  `y = gamma * (alpha * e^x - alpha) for x <= 0`, `y = gamma * x for x > 0`,
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.6732)</dt>
+<dd>Coefficient of SELU default to 1.6732.</dd>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+<dt><tt>gamma</tt> : float (default is 1.0507)</dt>
+<dd>Coefficient of SELU default to 1.0507.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Shape-1"></a>**Shape-1**</a>
+
+  Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>shape</tt> : T1</dt>
+<dd>Shape of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor.</dd>
+</dl>
+
+### <a name="Sigmoid-1"></a>**Sigmoid-1**</a>
+
+  Sigmoid takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the sigmoid function, y = 1 / (1 + exp(-x)), is applied to the
+  tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Size-1"></a>**Size-1**</a>
+
+  Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>size</tt> : T1</dt>
+<dd>Total number of elements of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor, which should be a scalar though.</dd>
+</dl>
+
+### <a name="Slice-1"></a>**Slice-1**</a>
+
+  Produces a slice of the input tensor along multiple axes. Similar to numpy:
+  https://numpy.org/doc/stable/reference/routines.indexing.html
+  Slices uses `axes`, `starts` and `ends` attributes to specify the start and end
+  dimension for each axis in the list of axes, it uses this information to
+  slice the input `data` tensor. If a negative value is passed for any of the
+  start or end indices, it represent number of elements before the end of that
+  dimension. If the value passed to start or end is larger than the `n` (the
+  number of elements in this dimension), it represents `n`. For slicing to the
+  end of a dimension with unknown size, it is recommended to pass in `INT_MAX`.
+  If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
+  Example 1:
+    data = [
+        [1, 2, 3, 4],
+        [5, 6, 7, 8],
+    ]
+    axes = [0, 1]
+    starts = [1, 0]
+    ends = [2, 3]
+    result = [
+        [5, 6, 7],
+    ]
+  Example 2:
+    data = [
+        [1, 2, 3, 4],
+        [5, 6, 7, 8],
+    ]
+    starts = [0, 1]
+    ends = [-1, 1000]
+    result = [
+        [2, 3, 4],
+    ]
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>Axes that `starts` and `ends` apply to. It's optional. If not present, will be treated as [0, 1, ..., len(`starts`) - 1].</dd>
+<dt><tt>ends</tt> : list of ints (required)</dt>
+<dd>Ending indices (exclusive) of corresponding axis in axes`</dd>
+<dt><tt>starts</tt> : list of ints (required)</dt>
+<dd>Starting indices of corresponding axis in `axes`</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of data to extract slices from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Sliced data tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Softmax-1"></a>**Softmax-1**</a>
+
+  The operator computes the softmax (normalized exponential) values for each layer in the batch
+   of the given input. The input is a 2-D tensor (Tensor<float>) of size
+  (batch_size x input_feature_dimensions). The output tensor has the same shape
+  and contains the softmax values of the corresponding input.
+
+  Input does not need to explicitly be a 2D vector; rather, it will be
+  coerced into one. For an arbitrary n-dimensional tensor
+  input \in [a_0, a_1, ..., a_{k-1}, a_k, ..., a_{n-1}] and k is
+  the axis provided, then input will be coerced into a 2-dimensional tensor with
+  dimensions [a_0 * ... * a_{k-1}, a_k * ... * a_{n-1}]. For the default
+  case where axis=1, this means the input tensor will be coerced into a 2D tensor
+  of dimensions [a_0, a_1 * ... * a_{n-1}], where a_0 is often the batch size.
+  In this situation, we must have a_0 = N and a_1 * ... * a_{n-1} = D.
+  Each of these dimensions must be matched correctly, or else the operator
+  will throw errors.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Describes the axis of the inputs when coerced to 2D; defaults to one because the 0th axis most likely describes the batch_size</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The input tensor that's coerced into a 2D matrix of size (NxD) as described above.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output values with the same shape as input tensor (the original size without coercion).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Softplus-1"></a>**Softplus-1**</a>
+
+  Softplus takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the softplus function, y = ln(exp(x) + 1), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Softsign-1"></a>**Softsign-1**</a>
+
+  Calculates the softsign (x/(1+|x|)) of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The softsign (x/(1+|x|)) values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="SpaceToDepth-1"></a>**SpaceToDepth-1**</a>
+
+  SpaceToDepth rearranges blocks of spatial data into depth. More specifically,
+  this op outputs a copy of the input tensor where values from the height and width dimensions
+  are moved to the depth dimension.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>blocksize</tt> : int (required)</dt>
+<dd>Blocks of [blocksize, blocksize] are moved.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of [N, C * blocksize * blocksize, H/blocksize, W/blocksize].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Split-1"></a>**Split-1**</a>
+
+  Split a tensor into a list of tensors, along the specified
+  'axis'. The lengths of the split can be specified using argument 'axis' or
+  optional second input blob to the operator. Otherwise, the tensor is split
+  to equal sized parts.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>Which axis to split on</dd>
+<dt><tt>split</tt> : list of ints</dt>
+<dd>length of each output</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The tensor to split</dd>
+<dt><tt>split</tt> (optional) : T</dt>
+<dd>Optional list of output lengths (see also arg 'split')</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs...</tt> (variadic) : T</dt>
+<dd>One or more outputs forming list of tensors after splitting</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+</dl>
+
+### <a name="Sqrt-1"></a>**Sqrt-1**</a>
+
+  Square root takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the square root is, y = x^0.5, is applied to
+  the tensor elementwise. If x is negative, then it will return NaN.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Squeeze-1"></a>**Squeeze-1**</a>
+
+  Remove single-dimensional entries from the shape of a tensor.
+  Takes a  parameter `axes` with a list of axes to squeeze.
+  If `axes` is not provided, all the single dimensions will be removed from
+  the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>List of non-negative integers, indicate the dimensions to squeeze.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensors with at least max(dims) dimensions.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>squeezed</tt> : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Sub-1"></a>**Sub-1**</a>
+
+  Performs element-wise binary subtraction (with limited broadcast support).
+
+  If necessary the right-hand-side argument will be broadcasted to match the
+  shape of left-hand-side argument. When broadcasting is specified, the second
+  tensor can either be of element size 1 (including a scalar tensor and any
+  tensor with rank equal to or smaller than the first tensor), or having its
+  shape as a contiguous subset of the first tensor's shape. The starting of the
+  mutually equal shape is specified by the argument "axis", and if it is not set,
+  suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+  For example, the following tensor shapes are supported (with broadcast=1):
+
+    shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+    shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+    shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+    shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+  Attribute `broadcast=1` needs to be passed to enable broadcasting.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions. See doc for details.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Pass 1 to enable broadcasting</dd>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand, should share the type with the second operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same dimensions and type as A</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Sum-1"></a>**Sum-1**</a>
+
+  Element-wise sum of each of the input tensors. All inputs and outputs must
+  have the same shape and data type.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for Sum.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>sum</tt> : T</dt>
+<dd>Output tensor. Same dimension as inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Tanh-1"></a>**Tanh-1**</a>
+
+  Calculates the hyperbolic tangent of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>consumed_inputs</tt> : list of ints</dt>
+<dd>legacy optimization attribute.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>1-D input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The hyperbolic tangent values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Tile-1"></a>**Tile-1**</a>
+
+  Repeat the elements of a tensor along an axis.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor of any shape.</dd>
+<dt><tt>tiles</tt> : T</dt>
+<dd>Number of repeated copies to make of the input tensor.</dd>
+<dt><tt>axis</tt> : T</dt>
+<dd>Axis along which to repeat.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of same shape and type as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain tiles and axis's type to int64 tensors.</dd>
+</dl>
+
+### <a name="TopK-1"></a>**TopK-1**</a>
+
+  Retrieve the top-K elements along a specified axis. Given an input tensor of
+  shape [a_0, a_1, ..., a_{n-1}] and integer argument k, return two outputs:
+    -Value tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}]
+      which contains the values of the top k elements along the specified axis
+    -Index tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] which
+     contains the indices of the top k elements (original indices from the input
+     tensor).
+  Given two equivalent values, this operator uses the indices along the axis  as
+   a tiebreaker. That is, the element with the lower index will appear first.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>Dimension on which to do the sort.</dd>
+<dt><tt>k</tt> : int (required)</dt>
+<dd>Number of top elements to retrieve</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{n-1}]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Values</tt> : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing top K values from the input tensor</dd>
+<dt><tt>Indices</tt> : I</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing the corresponding input tensor indices for the top K values.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="Transpose-1"></a>**Transpose-1**</a>
+
+  Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+  The optional attribute `perm` must be a permutation of the dimensions of
+  the input tensor. Axis `i` of the output tensor corresponds to the axis
+  `perm[i]` of the input tensor.
+  For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 1, 3).
+  When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 3, 1).
+  If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+  where `n` is the rank of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>perm</tt> : list of ints</dt>
+<dd>A list of integers. By default, reverse the dimensions, otherwise permute the axes according to the values given.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>transposed</tt> : T</dt>
+<dd>Transposed output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Unsqueeze-1"></a>**Unsqueeze-1**</a>
+
+  Insert single-dimensional entries to the shape of a tensor.
+  Takes one required argument `axes`, a list of dimensions that will be inserted.
+  Dimension indices in `axes` are as seen in the output tensor. For example:
+    Given a tensor such that tensor with shape [3, 4, 5], then
+    Unsqueeze(tensor, axes=[0, 4]) has shape [1, 3, 4, 5, 1]
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints (required)</dt>
+<dd>List of non-negative integers, indicate the dimensions to be inserted</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Original tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>expanded</tt> : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Upsample-1"></a>**Upsample-1**</a>
+
+  Upsample the input tensor.
+  The width and height of the output tensor are:
+    output_width = floor(input_width * width_scale),
+    output_height = floor(input_height * height_scale).
+  Example:
+    Given `data` tensor, width_scale, height_scale, mode,
+    Upsample the input 4-D tensor in nearest mode:
+    data = [[[
+        [1, 2],
+        [3, 4]
+    ]]]
+    width_scale = 2
+    height_scale = 2
+    mode = "nearest"
+    output = [[[
+        [1, 1, 2, 2],
+        [1, 1, 2, 2],
+        [3, 3, 4, 4],
+        [3, 3, 4, 4]
+    ]]]
+
+#### Version
+
+No versioning maintained for experimental ops.
+#### Attributes
+
+<dl>
+<dt><tt>height_scale</tt> : float (required)</dt>
+<dd>The scale along height dimension. It takes value greater than or equal to 1.</dd>
+<dt><tt>mode</tt> : string (default is nearest)</dt>
+<dd>Two interpolation modes: nearest(default), bilinear</dd>
+<dt><tt>width_scale</tt> : float (required)</dt>
+<dd>The scale along width dimension. It takes value greater than or equal to 1.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>4-D tensor, [N,C,H,W]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>4-D tensor after resizing, [N,C,H,W]</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to bool, int32, int64, float16, float, double tensors.</dd>
+</dl>
+
+### <a name="Xor-1"></a>**Xor-1**</a>
+
+  Returns the tensor resulted from performing the `xor` logical operation
+  elementwise on the input tensors `A` and `B`.
+
+  If broadcasting is enabled, the right-hand-side argument will be broadcasted
+  to match the shape of left-hand-side argument. See the doc of `Add` for a
+  detailed description of the broadcasting rules.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Left input tensor for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Right input tensor for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input to boolean tensor.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+## Version 2 of the default ONNX operator set
+### <a name="GlobalLpPool-2"></a>**GlobalLpPool-2**</a>
+
+  GlobalLpPool consumes an input tensor X and applies lp pool pooling across
+   the values in the same channel. This is equivalent to LpPool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 2 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>p value of the Lp norm used to pool over the input data.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from pooling across the input tensor. The output tensor has the same rank as the input. The first two dimensions of output shape are the same as the input (N x C), while the other dimensions are all 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LpPool-2"></a>**LpPool-2**</a>
+
+  LpPool consumes an input tensor X and applies Lp pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   Lp pooling consisting of computing the Lp norm on all values of a subset
+   of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing.
+
+#### Version
+
+This version of the operator has been available since version 2 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>p value of the Lp norm used to pool over the input data.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Pad-2"></a>**Pad-2**</a>
+
+  Given `data` tensor, pads, mode, and value.
+  Example:
+    Insert 0 pads to the beginning of the second dimension.
+    data = [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+    pads = [0, 2, 0, 0]
+    output = [
+        [
+            [0.0, 0.0, 1.0, 1.2],
+            [0.0, 0.0, 2.3, 3.4],
+            [0.0, 0.0, 4.5, 5.7],
+        ],
+    ]
+
+#### Version
+
+This version of the operator has been available since version 2 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Three modes: constant(default), reflect, edge</dd>
+<dt><tt>pads</tt> : list of ints (required)</dt>
+<dd>List of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D it is the number of pixels. `pads` rank should be double of the input's rank. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`.</dd>
+<dt><tt>value</tt> : float (default is 0.0)</dt>
+<dd>One float, indicates the value to be filled.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Split-2"></a>**Split-2**</a>
+
+  Split a tensor into a list of tensors, along the specified
+  'axis'. Lengths of the parts can be specified using argument 'split'.
+  Otherwise, the tensor is split to equal sized parts.
+
+#### Version
+
+This version of the operator has been available since version 2 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to split on. </dd>
+<dt><tt>split</tt> : list of ints</dt>
+<dd>length of each output</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The tensor to split</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic) : T</dt>
+<dd>One or more outputs forming list of tensors after splitting</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+## Version 3 of the default ONNX operator set
+### <a name="GRU-3"></a>**GRU-3**</a>
+
+  Computes an one-layer GRU. This operator is usually supported via some custom
+  implementation such as CuDNN.
+
+  Notations:
+
+  `X` - input tensor
+
+  `z` - update gate
+
+  `r` - reset gate
+
+  `h` - hidden gate
+
+  `t` - time step (t-1 means previous time step)
+
+  `W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+
+  `R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+
+  `Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+
+  `Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+
+  `WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+
+  `RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+
+  `WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+
+  `RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+
+  `H` - Hidden state
+
+  `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+    Relu(x)                - max(0, x)
+
+    Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+    Sigmoid(x)             - 1/(1 + e^{-x})
+
+    (NOTE: Below are optional)
+
+    Affine(x)              - alpha*x + beta
+
+    LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+    ThresholdedRelu(x)     - x if x >= alpha else 0
+
+    ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+    HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+    Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+    Softsign(x)            - x/(1 + |x|)
+
+    Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh):
+
+    - zt = f(Xt*(Wz^T) + Ht-1*Rz + Wbz + Rbz)
+
+    - rt = f(Xt*(Wr^T) + Ht-1*Rr + Wbr + Rbr)
+
+    - ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*Rh + Rbh + Wbh) # default, when linear_before_reset = 0
+
+    - ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*Rh + Rbh) + Wbh) # when linear_before_reset != 0
+
+    - Ht = (1 - zt) (.) ht + zt (.) Ht-1
+
+#### Version
+
+This version of the operator has been available since version 3 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 2 (or 4 if bidirectional) activation functions for update, reset, and hidden gates. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>linear_before_reset</tt> : int (default is 0)</dt>
+<dd>When computing the output of the hidden gate, apply the linear transformation before multiplying by the output of the reset gate.</dd>
+<dt><tt>output_sequence</tt> : int (default is 0)</dt>
+<dd>The sequence output for the hidden is optional if 0. Default 0.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and `[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 6*hidden_size]`. Optional: If not specified - assumed to be 0</dd>
+<dt><tt>sequence_lens</tt> (optional) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. It is optional if `output_sequence` is 0.</dd>
+<dt><tt>Y_h</tt> (optional) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+## Version 4 of the default ONNX operator set
+### <a name="Concat-4"></a>**Concat-4**</a>
+
+  Concatenate a list of tensors into a single tensor
+
+#### Version
+
+This version of the operator has been available since version 4 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (required)</dt>
+<dd>Which axis to concat on</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>inputs</tt> (variadic) : T</dt>
+<dd>List of tensors for concatenation</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>concat_result</tt> : T</dt>
+<dd>Concatenated tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+## Version 5 of the default ONNX operator set
+### <a name="Reshape-5"></a>**Reshape-5**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+#### Version
+
+This version of the operator has been available since version 5 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>shape</tt> : tensor(int64)</dt>
+<dd>Specified shape for output.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+## Version 6 of the default ONNX operator set
+### <a name="Abs-6"></a>**Abs-6**</a>
+
+  Absolute takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the absolute is, y = abs(x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Add-6"></a>**Add-6**</a>
+
+  Performs element-wise binary addition (with limited broadcast support).
+
+  If necessary the right-hand-side argument will be broadcasted to match the
+  shape of left-hand-side argument. When broadcasting is specified, the second
+  tensor can either be of element size 1 (including a scalar tensor and any
+  tensor with rank equal to or smaller than the first tensor), or having its
+  shape as a contiguous subset of the first tensor's shape. The starting of the
+  mutually equal shape is specified by the argument "axis", and if it is not set,
+  suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+  For example, the following tensor shapes are supported (with broadcast=1):
+
+    shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+    shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+    shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+    shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+  Attribute `broadcast=1` needs to be passed to enable broadcasting.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions. See doc for details.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Pass 1 to enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand, should share the type with the second operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same dimensions and type as A</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="BatchNormalization-6"></a>**BatchNormalization-6**</a>
+
+  Carries out batch normalization as described in the paper
+  https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+  there are multiple cases for the number of outputs, which we list below:
+
+  Output case #1: Y, mean, var, saved_mean, saved_var (training mode)
+  Output case #2: Y (test mode)
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero, default is 1e-5f.</dd>
+<dt><tt>is_test</tt> : int (default is 0)</dt>
+<dd>If set to nonzero, run spatial batch normalization in test mode, default is 0.</dd>
+<dt><tt>momentum</tt> : float (default is 0.9)</dt>
+<dd>Factor used in computing the running mean and variance.e.g., running_mean = running_mean * momentum + mean * (1 - momentum), default is 0.9f.</dd>
+<dt><tt>spatial</tt> : int (default is 1)</dt>
+<dd>If true, compute the mean and variance across all spatial elements If false, compute the mean and variance across per feature.Default is 1.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+<dt><tt>scale</tt> : T</dt>
+<dd>The scale as a 1-dimensional tensor of size C to be applied to the output.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>The bias as a 1-dimensional tensor of size C to be applied to the output.</dd>
+<dt><tt>mean</tt> : T</dt>
+<dd>The running mean (training) or the estimated mean (testing) as a 1-dimensional tensor of size C.</dd>
+<dt><tt>var</tt> : T</dt>
+<dd>The running variance (training) or the estimated variance (testing) as a 1-dimensional tensor of size C.</dd>
+</dl>
+
+#### Outputs (1 - 5)
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>The output tensor of the same shape as X.</dd>
+<dt><tt>mean</tt> (optional) : T</dt>
+<dd>The running mean after the BatchNormalization operator. Must be in-place with the input mean. Should not be used for testing.</dd>
+<dt><tt>var</tt> (optional) : T</dt>
+<dd>The running variance after the BatchNormalization operator. Must be in-place with the input var. Should not be used for testing.</dd>
+<dt><tt>saved_mean</tt> (optional) : T</dt>
+<dd>Saved mean used during training to speed up gradient computation. Should not be used for testing.</dd>
+<dt><tt>saved_var</tt> (optional) : T</dt>
+<dd>Saved variance used during training to speed up gradient computation. Should not be used for testing.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Cast-6"></a>**Cast-6**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+  NOTE: Casting to and from strings is not supported yet.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool)</dt>
+<dd>Constrain input types. Casting from strings and complex are not supported.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool)</dt>
+<dd>Constrain output types. Casting to strings and complex are not supported.</dd>
+</dl>
+
+### <a name="Ceil-6"></a>**Ceil-6**</a>
+
+  Ceil takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the ceil is, y = ceil(x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Clip-6"></a>**Clip-6**</a>
+
+  Clip operator limits the given input within an interval. The interval is
+  specified with arguments 'min' and 'max'. They default to
+  numeric_limits::lowest() and numeric_limits::max() respectively.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>max</tt> : float (default is (3.402823e+38))</dt>
+<dd>Maximum value, above which element is replaced by max</dd>
+<dt><tt>min</tt> : float (default is (-3.402823e+38))</dt>
+<dd>Minimum value, under which element is replaced by min</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor whose elements to be clipped</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor with clipped input elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Div-6"></a>**Div-6**</a>
+
+  Performs element-wise binary division (with limited broadcast support).
+
+  If necessary the right-hand-side argument will be broadcasted to match the
+  shape of left-hand-side argument. When broadcasting is specified, the second
+  tensor can either be of element size 1 (including a scalar tensor and any
+  tensor with rank equal to or smaller than the first tensor), or having its
+  shape as a contiguous subset of the first tensor's shape. The starting of the
+  mutually equal shape is specified by the argument "axis", and if it is not set,
+  suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+  For example, the following tensor shapes are supported (with broadcast=1):
+
+    shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+    shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+    shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+    shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+  Attribute `broadcast=1` needs to be passed to enable broadcasting.
+
+
+  For integer inputs, the result is computed using truncating division (rounding toward zero).
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions. See doc for details.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Pass 1 to enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand, should share the type with the second operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same dimensions and type as A</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Dropout-6"></a>**Dropout-6**</a>
+
+  Dropout takes one input data (Tensor<float>) and produces two Tensor outputs,
+  output (Tensor<float>) and mask (Tensor<bool>). Depending on whether it is in
+  test mode or not, the output Y will either be a random dropout, or a simple
+  copy of the input. Note that our implementation of Dropout does scaling in
+  the training phase, so during testing nothing needs to be done.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>is_test</tt> : int (default is 0)</dt>
+<dd>(int, default 0) if nonzero, run dropout in test mode where the output is simply Y = X.</dd>
+<dt><tt>ratio</tt> : float (default is 0.5)</dt>
+<dd>(float, default 0.5) the ratio of random dropout</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>The input data as Tensor.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output.</dd>
+<dt><tt>mask</tt> (optional) : T</dt>
+<dd>The output mask. If is_test is nonzero, this output is not filled.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Elu-6"></a>**Elu-6**</a>
+
+  Elu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the function `f(x) = alpha * (exp(x) - 1.) for x <
+  0`, `f(x) = x for x >= 0`., is applied to the tensor elementwise.
+
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Coefficient of ELU.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Exp-6"></a>**Exp-6**</a>
+
+  Calculates the exponential of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The exponential of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Floor-6"></a>**Floor-6**</a>
+
+  Floor takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the floor is, y = floor(x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Gemm-6"></a>**Gemm-6**</a>
+
+  General Matrix multiplication:
+  https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+  Compute Y = alpha * A * B + beta * C, where input tensor A has
+  dimension (M X K), input tensor B has dimension (K X N), input tensor C and
+  output tensor Y have dimension (M X N).
+  If attribute broadcast is non-zero, input tensor C will be broadcasted to match
+  the dimension requirement. A will be transposed before doing the computation
+  if attribute transA is non-zero, same for B and transB.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for the product of input tensors A * B, the default value is 1.0.</dd>
+<dt><tt>beta</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for input tensor C, the default value is 1.0.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Whether C should be broadcasted</dd>
+<dt><tt>transA</tt> : int (default is 0)</dt>
+<dd>Whether A should be transposed</dd>
+<dt><tt>transB</tt> : int (default is 0)</dt>
+<dd>Whether B should be transposed</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Input tensor A</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Input tensor B</dd>
+<dt><tt>C</tt> : T</dt>
+<dd>Input tensor C</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="HardSigmoid-6"></a>**HardSigmoid-6**</a>
+
+  HardSigmoid takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the HardSigmoid function, y = max(0, min(1, alpha * x + beta)),
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.2)</dt>
+<dd>Value of alpha.</dd>
+<dt><tt>beta</tt> : float (default is 0.5)</dt>
+<dd>Value of beta.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="InstanceNormalization-6"></a>**InstanceNormalization-6**</a>
+
+  Carries out instance normalization as described in the paper
+  https://arxiv.org/abs/1607.08022.
+
+  y = scale * (x - mean) / sqrt(variance + epsilon) + B,
+  where mean and variance are computed per instance per channel.
+
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+<dt><tt>scale</tt> (differentiable) : T</dt>
+<dd>The input 1-dimensional scale tensor of size C.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>The input 1-dimensional bias tensor of size C.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output tensor of the same shape as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LeakyRelu-6"></a>**LeakyRelu-6**</a>
+
+  LeakyRelu takes input data (Tensor<T>) and an argument alpha, and produces one
+  output data (Tensor<T>) where the function `f(x) = alpha * x for x < 0`,
+  `f(x) = x for x >= 0`, is applied to the data tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.01)</dt>
+<dd>Coefficient of leakage.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Log-6"></a>**Log-6**</a>
+
+  Calculates the natural log of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The natural log of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Max-6"></a>**Max-6**</a>
+
+  Element-wise max of each of the input tensors. All inputs and outputs must
+  have the same shape and data type.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for Max.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>max</tt> : T</dt>
+<dd>Output tensor. Same dimension as inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Mean-6"></a>**Mean-6**</a>
+
+  Element-wise mean of each of the input tensors. All inputs and outputs must
+  have the same shape and data type.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for Mean.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>mean</tt> : T</dt>
+<dd>Output tensor. Same dimension as inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Min-6"></a>**Min-6**</a>
+
+  Element-wise min of each of the input tensors. All inputs and outputs must
+  have the same shape and data type.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for Min</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>min</tt> : T</dt>
+<dd>Output tensor. Same dimension as inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Mul-6"></a>**Mul-6**</a>
+
+  Performs element-wise binary multiplication (with limited broadcast support).
+
+  If necessary the right-hand-side argument will be broadcasted to match the
+  shape of left-hand-side argument. When broadcasting is specified, the second
+  tensor can either be of element size 1 (including a scalar tensor and any
+  tensor with rank equal to or smaller than the first tensor), or having its
+  shape as a contiguous subset of the first tensor's shape. The starting of the
+  mutually equal shape is specified by the argument "axis", and if it is not set,
+  suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+  For example, the following tensor shapes are supported (with broadcast=1):
+
+    shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+    shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+    shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+    shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+  Attribute `broadcast=1` needs to be passed to enable broadcasting.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions. See doc for details.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Pass 1 to enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand, should share the type with the second operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same dimensions and type as A</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Neg-6"></a>**Neg-6**</a>
+
+  Neg takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where each element flipped sign, y = -x, is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(int32), tensor(int8), tensor(int16), tensor(int64), tensor(float16), tensor(double)</dt>
+<dd>Constrain input and output types to signed numeric tensors.</dd>
+</dl>
+
+### <a name="PRelu-6"></a>**PRelu-6**</a>
+
+  PRelu takes input data (Tensor<T>) and slope tensor as input, and produces one
+  output data (Tensor<T>) where the function `f(x) = slope * x for x < 0`,
+  `f(x) = x for x >= 0`., is applied to the data tensor elementwise.
+
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+<dt><tt>slope</tt> : T</dt>
+<dd>Slope tensor. If `Slope` is of size 1, the value is sharedacross different channels</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Reciprocal-6"></a>**Reciprocal-6**</a>
+
+  Reciprocal takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the reciprocal is, y = 1/x, is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Relu-6"></a>**Relu-6**</a>
+
+  Relu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the rectified linear function, y = max(0, x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Selu-6"></a>**Selu-6**</a>
+
+  Selu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the scaled exponential linear unit function,
+  `y = gamma * (alpha * e^x - alpha) for x <= 0`, `y = gamma * x for x > 0`,
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.67326)</dt>
+<dd>Coefficient of SELU default to 1.67326319217681884765625 (i.e., float32 approximation of 1.6732632423543772848170429916717).</dd>
+<dt><tt>gamma</tt> : float (default is 1.0507)</dt>
+<dd>Coefficient of SELU default to 1.05070102214813232421875 (i.e., float32 approximation of 1.0507009873554804934193349852946).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Sigmoid-6"></a>**Sigmoid-6**</a>
+
+  Sigmoid takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the sigmoid function, y = 1 / (1 + exp(-x)), is applied to the
+  tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Sqrt-6"></a>**Sqrt-6**</a>
+
+  Square root takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the square root is, y = x^0.5, is applied to
+  the tensor elementwise. If x is negative, then it will return NaN.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Sub-6"></a>**Sub-6**</a>
+
+  Performs element-wise binary subtraction (with limited broadcast support).
+
+  If necessary the right-hand-side argument will be broadcasted to match the
+  shape of left-hand-side argument. When broadcasting is specified, the second
+  tensor can either be of element size 1 (including a scalar tensor and any
+  tensor with rank equal to or smaller than the first tensor), or having its
+  shape as a contiguous subset of the first tensor's shape. The starting of the
+  mutually equal shape is specified by the argument "axis", and if it is not set,
+  suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+  For example, the following tensor shapes are supported (with broadcast=1):
+
+    shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+    shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+    shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+    shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+    shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+  Attribute `broadcast=1` needs to be passed to enable broadcasting.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>If set, defines the broadcast dimensions. See doc for details.</dd>
+<dt><tt>broadcast</tt> : int (default is 0)</dt>
+<dd>Pass 1 to enable broadcasting</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand, should share the type with the second operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand. With broadcasting can be of smaller size than A. If broadcasting is disabled it should be of the same size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same dimensions and type as A</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Sum-6"></a>**Sum-6**</a>
+
+  Element-wise sum of each of the input tensors. All inputs and outputs must
+  have the same shape and data type.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for Sum.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>sum</tt> : T</dt>
+<dd>Output tensor. Same dimension as inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Tanh-6"></a>**Tanh-6**</a>
+
+  Calculates the hyperbolic tangent of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The hyperbolic tangent values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Tile-6"></a>**Tile-6**</a>
+
+  Constructs a tensor by tiling a given tensor.
+  This is the same as function `tile` in Numpy, but no broadcast.
+  For example A = [[1, 2], [3, 4]], B = [1, 2], tile(A, B) = [[1, 2, 1, 2], [3, 4, 3, 4]]
+
+#### Version
+
+This version of the operator has been available since version 6 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor of any shape.</dd>
+<dt><tt>repeats</tt> : T1</dt>
+<dd>1D int64 tensor of the same length as input's dimension number, includes numbers of repeated copies along input's dimensions.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of the same dimensions and type as tensor input. output_dim[i] = input_dim[i] * repeats[i]</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain repeat's type to int64 tensors.</dd>
+</dl>
+
+## Version 7 of the default ONNX operator set
+### <a name="Acos-7"></a>**Acos-7**</a>
+
+  Calculates the arccosine (inverse of cosine) of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The arccosine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Add-7"></a>**Add-7**</a>
+
+  Performs element-wise binary addition (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="And-7"></a>**And-7**</a>
+
+  Returns the tensor resulted from performing the `and` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input to boolean tensor.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Asin-7"></a>**Asin-7**</a>
+
+  Calculates the arcsine (inverse of sine) of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The arcsine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Atan-7"></a>**Atan-7**</a>
+
+  Calculates the arctangent (inverse of tangent) of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The arctangent of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="AveragePool-7"></a>**AveragePool-7**</a>
+
+  AveragePool consumes an input tensor X and applies average pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   average pooling consisting of computing the average on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - kernel_spatial_shape[i]) / strides_spatial_shape[i] + 1)
+
+   * pad_shape[i] is sum of pads along axis i
+   ```
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - kernel_spatial_shape[i] + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + kernel_spatial_shape[i] - input_spatial_shape[i]
+   ```
+   The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).
+
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>count_include_pad</tt> : int (default is 0)</dt>
+<dd>Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="BatchNormalization-7"></a>**BatchNormalization-7**</a>
+
+  Carries out batch normalization as described in the paper
+      https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+      there are multiple cases for the number of outputs, which we list below:
+
+      Output case #1: Y, mean, var, saved_mean, saved_var (training mode)
+      Output case #2: Y (test mode)
+          This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>momentum</tt> : float (default is 0.9)</dt>
+<dd>Factor used in computing the running mean and variance.e.g., running_mean = running_mean * momentum + mean * (1 - momentum).</dd>
+<dt><tt>spatial</tt> : int (default is 1)</dt>
+<dd>If true, compute the mean and variance across per activation. If false, compute the mean and variance across per feature over each mini-batch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+<dt><tt>scale</tt> : T</dt>
+<dd>If spatial is true, the dimension of scale is (C). If spatial is false, the dimensions of scale are (C x D1 x ... x Dn)</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>If spatial is true, the dimension of bias is (C). If spatial is false, the dimensions of bias are (C x D1 x ... x Dn)</dd>
+<dt><tt>mean</tt> : T</dt>
+<dd>If spatial is true, the dimension of the running mean (training) or the estimated mean (testing) is (C). If spatial is false, the dimensions of the running mean (training) or the estimated mean (testing) are (C x D1 x ... x Dn).</dd>
+<dt><tt>var</tt> : T</dt>
+<dd>If spatial is true, the dimension of the running variance(training) or the estimated variance (testing) is (C). If spatial is false, the dimensions of the running variance(training) or the estimated variance (testing) are (C x D1 x ... x Dn).</dd>
+</dl>
+
+#### Outputs (1 - 5)
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>The output tensor of the same shape as X</dd>
+<dt><tt>mean</tt> (optional) : T</dt>
+<dd>The running mean after the BatchNormalization operator.</dd>
+<dt><tt>var</tt> (optional) : T</dt>
+<dd>The running variance after the BatchNormalization operator.</dd>
+<dt><tt>saved_mean</tt> (optional) : T</dt>
+<dd>Saved mean used during training to speed up gradient computation.</dd>
+<dt><tt>saved_var</tt> (optional) : T</dt>
+<dd>Saved variance used during training to speed up gradient computation.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Cos-7"></a>**Cos-7**</a>
+
+  Calculates the cosine of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The cosine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Div-7"></a>**Div-7**</a>
+
+  Performs element-wise binary division (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  For integer inputs, the result is computed using truncating division (rounding toward zero).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Dropout-7"></a>**Dropout-7**</a>
+
+  Dropout takes one input data (Tensor<float>) and produces two Tensor outputs,
+  output (Tensor<float>) and mask (Tensor<bool>). Depending on whether it is in
+  test mode or not, the output Y will either be a random dropout, or a simple
+  copy of the input. Note that our implementation of Dropout does scaling in
+  the training phase, so during testing nothing needs to be done.
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>ratio</tt> : float (default is 0.5)</dt>
+<dd>The ratio of random dropout</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>The input data as Tensor.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output.</dd>
+<dt><tt>mask</tt> (optional) : T</dt>
+<dd>The output mask.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Equal-7"></a>**Equal-7**</a>
+
+  Returns the tensor resulted from performing the `equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input to integral tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="GRU-7"></a>**GRU-7**</a>
+
+  Computes an one-layer GRU. This operator is usually supported via some custom
+  implementation such as CuDNN.
+
+  Notations:
+
+  `X` - input tensor
+
+  `z` - update gate
+
+  `r` - reset gate
+
+  `h` - hidden gate
+
+  `t` - time step (t-1 means previous time step)
+
+  `W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+
+  `R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+
+  `Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+
+  `Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+
+  `WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+
+  `RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+
+  `WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+
+  `RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+
+  `H` - Hidden state
+
+  `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+    Relu(x)                - max(0, x)
+
+    Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+    Sigmoid(x)             - 1/(1 + e^{-x})
+
+    (NOTE: Below are optional)
+
+    Affine(x)              - alpha*x + beta
+
+    LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+    ThresholdedRelu(x)     - x if x >= alpha else 0
+
+    ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+    HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+    Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+    Softsign(x)            - x/(1 + |x|)
+
+    Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh):
+
+    - zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz)
+
+    - rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr)
+
+    - ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # default, when linear_before_reset = 0
+
+    - ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset != 0
+
+    - Ht = (1 - zt) (.) ht + zt (.) Ht-1
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 2 (or 4 if bidirectional) activation functions for update, reset, and hidden gates. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>linear_before_reset</tt> : int (default is 0)</dt>
+<dd>When computing the output of the hidden gate, apply the linear transformation before multiplying by the output of the reset gate.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and `[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 6*hidden_size]`. Optional: If not specified - assumed to be 0</dd>
+<dt><tt>sequence_lens</tt> (optional) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="Gemm-7"></a>**Gemm-7**</a>
+
+  General Matrix multiplication:
+  https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+
+  A' = transpose(A) if transA else A
+
+  B' = transpose(B) if transB else B
+
+  Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M),
+  input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N),
+  and output tensor Y has shape (M, N). A will be transposed before doing the
+  computation if attribute transA is non-zero, same for B and transB.
+  This operator supports **unidirectional broadcasting** (tensor C should be unidirectional broadcastable to tensor A * B); for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for the product of input tensors A * B.</dd>
+<dt><tt>beta</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for input tensor C.</dd>
+<dt><tt>transA</tt> : int (default is 0)</dt>
+<dd>Whether A should be transposed</dd>
+<dt><tt>transB</tt> : int (default is 0)</dt>
+<dd>Whether B should be transposed</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Input tensor A. The shape of A should be (M, K) if transA is 0, or (K, M) if transA is non-zero.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Input tensor B. The shape of B should be (K, N) if transB is 0, or (N, K) if transB is non-zero.</dd>
+<dt><tt>C</tt> : T</dt>
+<dd>Input tensor C. The shape of C should be unidirectional broadcastable to (M, N).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor of shape (M, N).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Greater-7"></a>**Greater-7**</a>
+
+  Returns the tensor resulted from performing the `greater` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="LSTM-7"></a>**LSTM-7**</a>
+
+  Computes an one-layer LSTM. This operator is usually supported via some
+  custom implementation such as CuDNN.
+
+  Notations:
+
+  `X` - input tensor
+
+  `i` - input gate
+
+  `o` - output gate
+
+  `f` - forget gate
+
+  `c` - cell gate
+
+  `t` - time step (t-1 means previous time step)
+
+  `W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
+
+  `R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
+
+  `Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
+
+  `Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
+
+  `P[iof]`  - P peephole weight vector for input, output, and forget gates
+
+  `WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
+
+  `RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
+
+  `WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
+
+  `RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
+
+  `PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
+
+  `H` - Hidden state
+
+  `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+    Relu(x)                - max(0, x)
+
+    Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+    Sigmoid(x)             - 1/(1 + e^{-x})
+
+    (NOTE: Below are optional)
+
+    Affine(x)              - alpha*x + beta
+
+    LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+    ThresholdedRelu(x)     - x if x >= alpha else 0
+
+    ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+    HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+    Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+    Softsign(x)            - x/(1 + |x|)
+
+    Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh, h=Tanh):
+
+    - it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi)
+
+    - ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf)
+
+    - ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc)
+
+    - Ct = ft (.) Ct-1 + it (.) ct
+
+    - ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.) Ct + Wbo + Rbo)
+
+    - Ht = ot (.) h(Ct)
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 3 (or 6 if bidirectional) activation functions for input, output, forget, cell, and hidden. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>input_forget</tt> : int (default is 0)</dt>
+<dd>Couple the input and forget gates if 1.</dd>
+</dl>
+
+#### Inputs (3 - 8)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[iofc]` and `WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape `[num_directions, 4*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[iofc]` and `RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 4*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>initial_c</tt> (optional) : T</dt>
+<dd>Optional initial value of the cell. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>P</tt> (optional) : T</dt>
+<dd>The weight tensor for peepholes. Concatenation of `P[iof]` and `PB[iof]` (if bidirectional) along dimension 0. It has shape `[num_directions, 3*hidde_size]`. Optional: If not specified - assumed to be 0.</dd>
+</dl>
+
+#### Outputs (0 - 3)
+
+<dl>
+<dt><tt>Y</tt> (optional) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>Y_c</tt> (optional) : T</dt>
+<dd>The last output value of the cell. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="Less-7"></a>**Less-7**</a>
+
+  Returns the tensor resulted from performing the `less` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Mul-7"></a>**Mul-7**</a>
+
+  Performs element-wise binary multiplication (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Multinomial-7"></a>**Multinomial-7**</a>
+
+  Generate a tensor of samples from a multinomial distribution according to the probabilities
+  of each of the possible outcomes.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int (default is 6)</dt>
+<dd>(Optional) The data type for the elements of the output tensor, if not specified, we will use int32.</dd>
+<dt><tt>sample_size</tt> : int (default is 1)</dt>
+<dd>Number of times to sample.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor with shape [batch_size, class_size], where class_size is the number of all possible outcomes. Each value along the axis zero represents the unnormalized log-probability of each corresponding outcome in a batch.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor with shape [batch_size, sample_size], where sample_size is the number of times to sample. Each value along the axis zero represents the outcome of the corresponding sample in a batch.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain output types to integral tensors.</dd>
+</dl>
+
+### <a name="Or-7"></a>**Or-7**</a>
+
+  Returns the tensor resulted from performing the `or` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input to boolean tensor.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="PRelu-7"></a>**PRelu-7**</a>
+
+  PRelu takes input data (Tensor<T>) and slope tensor as input, and produces one
+  output data (Tensor<T>) where the function `f(x) = slope * x for x < 0`,
+  `f(x) = x for x >= 0`., is applied to the data tensor elementwise.
+
+  This operator supports **unidirectional broadcasting** (tensor slope should be unidirectional broadcastable to input tensor X); for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+<dt><tt>slope</tt> : T</dt>
+<dd>Slope tensor. The shape of slope can be smaller than first input X; if so, its shape must be unidirectional broadcastable to X</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor (same size as X)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Pow-7"></a>**Pow-7**</a>
+
+  Pow takes input data (Tensor<T>) and exponent Tensor, and
+  produces one output data (Tensor<T>) where the function `f(x) = x^exponent`,
+  is applied to the data tensor elementwise.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>First operand, base of the exponent.</dd>
+<dt><tt>Y</tt> : T</dt>
+<dd>Second operand, power of the exponent.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="RNN-7"></a>**RNN-7**</a>
+
+  Computes an one-layer simple RNN. This operator is usually supported
+  via some custom implementation such as CuDNN.
+
+  Notations:
+
+  `X` - input tensor
+
+  `i` - input gate
+
+  `t` - time step (t-1 means previous time step)
+
+  `Wi` - W parameter weight matrix for input gate
+
+  `Ri` - R recurrence weight matrix for input gate
+
+  `Wbi` - W parameter bias vector for input gate
+
+  `Rbi` - R parameter bias vector for input gate
+
+  `WBi` - W parameter weight matrix for backward input gate
+
+  `RBi` - R recurrence weight matrix for backward input gate
+
+  `WBbi` - WR bias vectors for backward input gate
+
+  `RBbi` - RR bias vectors for backward input gate
+
+  `H` - Hidden state
+
+  `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+    Relu(x)                - max(0, x)
+
+    Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+    Sigmoid(x)             - 1/(1 + e^{-x})
+
+    (NOTE: Below are optional)
+
+    Affine(x)              - alpha*x + beta
+
+    LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+    ThresholdedRelu(x)     - x if x >= alpha else 0
+
+    ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+    HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+    Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+    Softsign(x)            - x/(1 + |x|)
+
+    Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Tanh):
+
+    - Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi)
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings (default is ['Tanh', 'Tanh'])</dt>
+<dd>One (or two if bidirectional) activation function for input gate. The activation function must be one of the activation functions specified above. Optional: Default `Tanh` if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>The weight tensor for input gate. Concatenation of `Wi` and `WBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `Ri` and `RBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` and `[WBbi, RBbi]` (if bidirectional). The tensor has shape `[num_directions, 2*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="Sin-7"></a>**Sin-7**</a>
+
+  Calculates the sine of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The sine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Sub-7"></a>**Sub-7**</a>
+
+  Performs element-wise binary subtraction (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Tan-7"></a>**Tan-7**</a>
+
+  Calculates the tangent of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The tangent of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Upsample-7"></a>**Upsample-7**</a>
+
+  Upsample the input tensor.
+  Each dimension value of the output tensor is:
+    output_dimension = floor(input_dimension * scale).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is nearest)</dt>
+<dd>Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)</dd>
+<dt><tt>scales</tt> : list of floats (required)</dt>
+<dd>The scale array along each dimension. It takes value greater than or equal to 1. The number of elements of 'scales' should be the same as the rank of input 'X'.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>N-D tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>N-D tensor after resizing</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Xor-7"></a>**Xor-7**</a>
+
+  Returns the tensor resulted from performing the `xor` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input to boolean tensor.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+## Version 8 of the default ONNX operator set
+### <a name="Expand-8"></a>**Expand-8**</a>
+
+  Broadcast the input tensor following the given shape and the broadcast rule.
+  The broadcast rule is similar to numpy.array(input) * numpy.ones(shape):
+  Dimensions are right alignment;
+  Two corresponding dimensions must have the same value, or one of them is equal to 1.
+  Also, this operator is similar to numpy.broadcast_to(input, shape),
+  but the major difference is numpy.broadcast_to() does not allow shape to be smaller than input.size().
+  It is possible that the output.shape is not equal to shape, when some dimensions in shape is equal to 1,
+  or the shape.ndim < input.shape.ndim.
+
+#### Version
+
+This version of the operator has been available since version 8 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor</dd>
+<dt><tt>shape</tt> : tensor(int64)</dt>
+<dd>A 1-D tensor indicates the shape you want to expand to, following the broadcast rule</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensors.</dd>
+</dl>
+
+### <a name="Max-8"></a>**Max-8**</a>
+
+  Element-wise max of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 8 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for max.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>max</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="MaxPool-8"></a>**MaxPool-8**</a>
+
+  MaxPool consumes an input tensor X and applies max pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   max pooling consisting of computing the max on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - kernel_spatial_shape[i]) / strides_spatial_shape[i] + 1)
+
+   * pad_shape[i] is sum of pads along axis i
+   ```
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - kernel_spatial_shape[i] + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + kernel_spatial_shape[i] - input_spatial_shape[i]
+   ```
+   The output of each pooling window is maximum number of elements exclude pad.
+
+
+#### Version
+
+This version of the operator has been available since version 8 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>storage_order</tt> : int (default is 0)</dt>
+<dd>The storage order of the tensor. 0 is row major, and 1 is column major.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+<dt><tt>Indices</tt> (optional) : I</dt>
+<dd>Indices tensor from max pooling across the input tensor. The dimensions of indices are the same as output tensor. The values in indices of are the indices of the selected values during pooling. The indices are computed as flatten 1-D tensor, and the indices do not consider padding. So the values in indices are in [0, N x C x D1 x ... x Dn).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="Mean-8"></a>**Mean-8**</a>
+
+  Element-wise mean of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 8 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for mean.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>mean</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Min-8"></a>**Min-8**</a>
+
+  Element-wise min of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 8 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for min.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>min</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Scan-8"></a>**Scan-8**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops). All these tensors are required to
+  have the same shape in each iteration of the loop (a restriction imposed to enable efficient
+  memory allocation). Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs).
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The operation supports batching, and the batch-axis is required to be 0.
+  When multiple scan_input tensors are used, they must all have the same batch-size,
+  and they must all have the same maximum-sequence-length (the dimensionality of the
+  sequence axis or scan axis). The sequence axis or scan axis is required to be 1.
+
+  The operation has an optional sequence_lens input (of shape [BATCH_SIZE]) to
+  allow variable length sequences of length <= the maximum-sequence-length. If this
+  input is not specified, all sequences are assumed to be of length equal to
+  maximum-sequence-length. For variable length input sequences, the scan_outputs
+  will consist of a sequence of same length as the input, padded to the
+  maximum-sequence-length.
+
+  The optional attribute directions can be used to scan a sequence in the reverse direction.
+  If this attribute is omitted, all sequences are scanned in the forward direction.
+  A bidirectional scan be performed by specifying the same tensor input twice in the
+  scan_inputs, once with a forward direction, and once with a backward direction.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body
+      > (sequence_lengths, init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // T.shape[0] denotes the batch-size of T
+      // The batch-size of scan_1, ..., scan_m are all required to be equal
+      batch_size = scan_1.shape[0];
+
+      // scan_i.shape[1] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[1] is required to be equal to scan_j.shape[1] for all i,j.
+      max_sequence_length = scan_1.shape[1];
+
+      for (int batch = 0; batch < batch_size; ++batch) {
+          // initialize state-variables
+          st_1 = init_1; ... st_n = init_n;
+          // initialize scan-output variables: [] denotes an empty tensor
+          scan_out_1 = []; ...; scan_out_k = [];
+          // identify number of iterations:
+          N = (sequence_lengths specified) ? sequence_lengths[batch] : max_sequence_length;
+
+          // execute loop
+          for (int t = 0; t < N; ++t) {
+              // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+              // of rank one less than T obtained by indexing T at position t along axis k.
+              si_1 = (scan_1<axis=0>[batch])<axis=1>[t];
+              ... ;
+              si_m = (scan_m<axis=0>[batch])<axis=1>[t];
+              // execute loop-body
+              st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+              // accumulate the scan-output elements
+              scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+          }
+          // accumulate the outputs for this batch:
+          bst_1[batch] = st_1; ..., bst_n[batch] = st_n;
+          // Note scan-outputs will have size max_sequence_length, but only first N values will be meaningful.
+          // The remaining values have an undefined value.
+          b_scan_out_1[batch] = scan_out_1; ...; b_scan_out_k[batch] = scan_out_k;
+      }
+      return bst_1, ..., bst_n, b_scan_out_1, ..., b_scan_out_k;
+
+
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1]("", %H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 8 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>sequence_lens</tt> (optional) : I</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If this input is not specified, all sequences are assumed to be of the maximum sequence length (the dimension of the sequence axis of the scan_input tensors).</dd>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Int64 tensor</dd>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>All Tensor types</dd>
+</dl>
+
+### <a name="Sum-8"></a>**Sum-8**</a>
+
+  Element-wise sum of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 8 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for sum.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>sum</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+## Version 9 of the default ONNX operator set
+### <a name="Acosh-9"></a>**Acosh-9**</a>
+
+  Calculates the hyperbolic arccosine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic arccosine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Asinh-9"></a>**Asinh-9**</a>
+
+  Calculates the hyperbolic arcsine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic arcsine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Atanh-9"></a>**Atanh-9**</a>
+
+  Calculates the hyperbolic arctangent of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic arctangent values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="BatchNormalization-9"></a>**BatchNormalization-9**</a>
+
+  Carries out batch normalization as described in the paper
+  https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+  there are multiple cases for the number of outputs, which we list below:
+
+  Output case #1: Y, mean, var, saved_mean, saved_var (training mode)
+  Output case #2: Y (test mode)
+
+  For previous (depreciated) non-spatial cases, implementors are suggested
+  to flatten the input shape to (N x C*D1*D2 ..*Dn) before a BatchNormalization Op.
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>momentum</tt> : float (default is 0.9)</dt>
+<dd>Factor used in computing the running mean and variance.e.g., running_mean = running_mean * momentum + mean * (1 - momentum).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size, C is the number of channels. Statistics are computed for every channel of C over N and D1 to Dn dimensions. For image data, input dimensions become (N x C x H x W). The op also accepts single dimension input of size N in which case C is assumed to be 1</dd>
+<dt><tt>scale</tt> (differentiable) : T</dt>
+<dd>Scale tensor of shape (C).</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Bias tensor of shape (C).</dd>
+<dt><tt>mean</tt> (differentiable) : T</dt>
+<dd>running (training) or estimated (testing) mean tensor of shape (C).</dd>
+<dt><tt>var</tt> (differentiable) : T</dt>
+<dd>running (training) or estimated (testing) variance tensor of shape (C).</dd>
+</dl>
+
+#### Outputs (1 - 5)
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>The output tensor of the same shape as X</dd>
+<dt><tt>mean</tt> (optional, non-differentiable) : T</dt>
+<dd>The running mean after the BatchNormalization operator.</dd>
+<dt><tt>var</tt> (optional, non-differentiable) : T</dt>
+<dd>The running variance after the BatchNormalization operator.</dd>
+<dt><tt>saved_mean</tt> (optional, non-differentiable) : T</dt>
+<dd>Saved mean used during training to speed up gradient computation.</dd>
+<dt><tt>saved_var</tt> (optional, non-differentiable) : T</dt>
+<dd>Saved variance used during training to speed up gradient computation.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Cast-9"></a>**Cast-9**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+
+  Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+  (e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+  yield result 100. There are some string literals reserved for special floating-point values;
+  "+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+  Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+  this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+  to string tensors, plain floating-point representation (such as "314.15926") would be used.
+  Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+  of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+  Conversion from a numerical type to any numerical type is always allowed.
+  User must be aware of precision loss and value change caused by range difference between two types.
+  For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+  an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="Compress-9"></a>**Compress-9**</a>
+
+  Selects slices from an input tensor along a given axis where condition evaluates to True for each axis index.
+      In case axis is not provided, input is flattened before elements are selected.
+      Compress behaves like numpy.compress: https://docs.scipy.org/doc/numpy/reference/generated/numpy.compress.html
+
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>(Optional) Axis along which to take slices. If not specified, input is flattened before elements being selected.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>condition</tt> : T1</dt>
+<dd>Rank 1 tensor of booleans to indicate which slices or data elements to be selected. Its length can be less than the input length alone the axis or the flattened input size if axis is not specified. In such cases data slices or elements exceeding the condition length are discarded.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor of rank r if axis is specified. Otherwise output is a Tensor of rank 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain to boolean tensors.</dd>
+</dl>
+
+### <a name="Constant-9"></a>**Constant-9**</a>
+
+  A constant tensor.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>value</tt> : tensor (required)</dt>
+<dd>The value for the elements of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="ConstantOfShape-9"></a>**ConstantOfShape-9**</a>
+
+  Generate a tensor with given value and shape.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>value</tt> : tensor</dt>
+<dd>(Optional) The value of the output elements.Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar. All values must be >= 0.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of shape specified by 'input'.If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'.If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype defaults to float32.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain input types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool)</dt>
+<dd>Constrain output types to be numerics.</dd>
+</dl>
+
+### <a name="Cosh-9"></a>**Cosh-9**</a>
+
+  Calculates the hyperbolic cosine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic cosine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Erf-9"></a>**Erf-9**</a>
+
+  Computes the error function of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The error function of the input tensor computed element-wise. It has the same shape and type of the input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="EyeLike-9"></a>**EyeLike-9**</a>
+
+  Generate a 2D tensor (matrix) with ones on the diagonal and zeros everywhere else. Only 2D
+  tensors are supported, i.e. input T1 must be of rank 2. The shape of the output tensor is the
+  same as the input tensor. The data type can be specified by the 'dtype' argument. If
+  'dtype' is not specified, then the type of input tensor is used. By default, the main diagonal
+  is populated with ones, but attribute 'k' can be used to populate upper or lower diagonals.
+  The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message and be valid as an output type.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type for the elements of the output tensor. If not specified,the data type of the input tensor T1 is used. If input tensor T1 is also notspecified, then type defaults to 'float'.</dd>
+<dt><tt>k</tt> : int (default is 0)</dt>
+<dd>(Optional) Index of the diagonal to be populated with ones. Default is 0. If T2 is the output, this op sets T2[i, i+k] = 1. k = 0 populates the main diagonal, k > 0 populates an upper diagonal,  and k < 0 populates a lower diagonal.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>2D input tensor to copy shape, and optionally, type information from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor, same shape as input tensor T1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool)</dt>
+<dd>Constrain input types. Strings and complex are not supported.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool)</dt>
+<dd>Constrain output types. Strings and complex are not supported.</dd>
+</dl>
+
+### <a name="Flatten-9"></a>**Flatten-9**</a>
+
+  Flattens the input tensor into a 2D matrix. If input tensor has shape
+  (d_0, d_1, ... d_n) then the output will have shape
+  (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Indicate up to which input dimensions (exclusive) should be flattened to the outer dimension of the output. The value for axis must be in the range [0, R], where R is the rank of the input tensor. When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), where the shape of the input tensor is (d_0, d_1, ... d_n). </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>A tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>A 2D tensor with the contents of the input tensor, with input dimensions up to axis flattened to the outer dimension of the output and remaining input dimensions flattened into the inner dimension of the output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output to all tensor types.</dd>
+</dl>
+
+### <a name="Gemm-9"></a>**Gemm-9**</a>
+
+  General Matrix multiplication:
+  https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+
+  A' = transpose(A) if transA else A
+
+  B' = transpose(B) if transB else B
+
+  Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M),
+  input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N),
+  and output tensor Y has shape (M, N). A will be transposed before doing the
+  computation if attribute transA is non-zero, same for B and transB.
+  This operator supports **unidirectional broadcasting** (tensor C should be unidirectional broadcastable to tensor A * B); for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for the product of input tensors A * B.</dd>
+<dt><tt>beta</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for input tensor C.</dd>
+<dt><tt>transA</tt> : int (default is 0)</dt>
+<dd>Whether A should be transposed</dd>
+<dt><tt>transB</tt> : int (default is 0)</dt>
+<dd>Whether B should be transposed</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Input tensor A. The shape of A should be (M, K) if transA is 0, or (K, M) if transA is non-zero.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Input tensor B. The shape of B should be (K, N) if transB is 0, or (N, K) if transB is non-zero.</dd>
+<dt><tt>C</tt> : T</dt>
+<dd>Input tensor C. The shape of C should be unidirectional broadcastable to (M, N).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor of shape (M, N).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+### <a name="Greater-9"></a>**Greater-9**</a>
+
+  Returns the tensor resulted from performing the `greater` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="IsNaN-9"></a>**IsNaN-9**</a>
+
+  Returns which elements of the input are NaN.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output types to boolean tensors.</dd>
+</dl>
+
+### <a name="Less-9"></a>**Less-9**</a>
+
+  Returns the tensor resulted from performing the `less` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="MatMul-9"></a>**MatMul-9**</a>
+
+  Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>N-dimensional matrix A</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>N-dimensional matrix B</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Matrix multiply results from A * B</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+### <a name="MaxUnpool-9"></a>**MaxUnpool-9**</a>
+
+  MaxUnpool essentially computes the partial inverse of the MaxPool op.
+   The input information to this op is typically the output information from a MaxPool op. The first
+   input tensor X is the tensor that needs to be unpooled, which is typically the pooled tensor (first output)
+   from MaxPool. The second input tensor, I, contains the indices to the (locally maximal) elements corresponding
+   to the elements in the first input tensor X. Input tensor I is typically the second output of the MaxPool op.
+   The third (optional) input is a tensor that specifies the output size of the unpooling operation.
+
+  MaxUnpool is intended to do 'partial' inverse of the MaxPool op. 'Partial' because all the non-maximal
+   values from the original input to MaxPool are set to zero in the output of the MaxUnpool op. Pooling
+   the result of an unpooling operation should give back the original input to the unpooling op.
+
+  MaxUnpool can produce the same output size for several input sizes, which makes unpooling op ambiguous.
+   The third input argument, output_size, is meant to disambiguate the op and produce output tensor of
+   known/predictable size.
+
+  In addition to the inputs, MaxUnpool takes three attributes, namely kernel_shape, strides, and pads,
+   which define the exact unpooling op. The attributes typically have the same values as the corresponding
+   pooling op that the unpooling op is trying to invert.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data tensor that has to be unpooled. This tensor is typically the first output of the MaxPool op.Dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non-image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>I</tt> : T2</dt>
+<dd>Input data tensor containing the indices corresponding to elements in the first input tensor X.This tensor is typically the second output of the MaxPool op.Dimensions must be the same as input tensor X. The indices are linear, i.e. computed considering the tensor as flattened 1-D tensor, assuming row-major storage. Also, the linear indices should not consider padding. So the values in indices are in the range [0, N x C x D1 x ... x Dn).</dd>
+<dt><tt>output_shape</tt> (optional) : T2</dt>
+<dd>The shape of the output can be explicitly set which will cause pads values to be auto generated. If 'output_shape' is specified, 'pads' values are ignored.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T1</dt>
+<dd>Output data tensor that contains the result of the unpooling.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="MeanVarianceNormalization-9"></a>**MeanVarianceNormalization-9**</a>
+
+  A MeanVarianceNormalization Function: Perform mean variance normalization
+        on the input tensor X using formula: <br/> ``` (X-EX)/sqrt(E(X-EX)^2) ```
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints (default is ['0', '2', '3'])</dt>
+<dd>A list of integers, along which to reduce. The default is to calculate along axes [0,2,3] for calculating mean and variance along each channel. Two variables with the same C-coordinate are associated with the same mean and variance.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="NonZero-9"></a>**NonZero-9**</a>
+
+  Returns the indices of the elements that are non-zero
+      (in row-major order - by dimension).
+      NonZero behaves similar to numpy.nonzero:
+      https://docs.scipy.org/doc/numpy/reference/generated/numpy.nonzero.html,
+      but for scalar input, NonZero produces output shape (0, N) instead of (1, N), which is different from Numpy's behavior.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(int64)</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to all tensor types.</dd>
+</dl>
+
+### <a name="OneHot-9"></a>**OneHot-9**</a>
+
+  Produces a one-hot tensor based on inputs.
+      The locations represented by the index values in the 'indices' input tensor will have 'on_value'
+      and the other locations will have 'off_value' in the output tensor, where 'on_value' and 'off_value'
+      are specified as part of required input argument 'values', which is a two-element tensor of format
+      [off_value, on_value]. The rank of the output tensor will be one greater than the rank of the
+      input tensor. The additional dimension is for one-hot representation. The additional dimension will
+      be inserted at the position specified by 'axis'. If 'axis' is not specified then then additional
+      dimension will be inserted as the innermost dimension, i.e. axis=-1. The size of the additional
+      dimension is specified by required scalar input 'depth'. The type of the output tensor is the same
+      as the type of the 'values' input. Any entries in the 'indices' input tensor with values outside
+      the range [0, depth) will result in one-hot representation with all 'off_value' values in the
+      output tensor.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>(Optional) Axis along which one-hot representation in added. Default: axis=-1. axis=-1 means that the additional dimension will be inserted as the innermost/last dimension in the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>indices</tt> : T1</dt>
+<dd>Input tensor containing indices. The values must be non-negative integers. Any entries in the 'indices' input tensor with values outside the range [0, depth) will result in one-hot representation with all 'off_value' values in the output tensor.In case 'indices' is of non-integer type, the values will be casted to int64 before use.</dd>
+<dt><tt>depth</tt> : T2</dt>
+<dd>Scalar or rank 1 tensor containing exactly one element, specifying the number of classes in one-hot tensor. This is also the size of the one-hot dimension (specified by 'axis' attribute) added on in the output tensor. The values in the 'indices' input tensor are expected to be in the range [0, depth). In case 'depth' is of non-integer type, it will be casted to int64 before use.</dd>
+<dt><tt>values</tt> : T3</dt>
+<dd>Rank 1 tensor containing exactly two elements, in the format [off_value, on_value], where 'on_value' is the value used for filling locations specified in 'indices' input tensor, and 'off_value' is the value used for filling locations other than those specified in 'indices' input tensor. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T3</dt>
+<dd>Tensor of rank one greater than input tensor 'indices', i.e. rank(output) = rank(indices) + 1. The data type for the elements of the output tensor is the same as the type of input 'values' is used.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to only numeric types.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to only numeric types.</dd>
+<dt><tt>T3</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type.</dd>
+</dl>
+
+### <a name="PRelu-9"></a>**PRelu-9**</a>
+
+  PRelu takes input data (Tensor<T>) and slope tensor as input, and produces one
+  output data (Tensor<T>) where the function `f(x) = slope * x for x < 0`,
+  `f(x) = x for x >= 0`., is applied to the data tensor elementwise.
+
+  This operator supports **unidirectional broadcasting** (tensor slope should be unidirectional broadcastable to input tensor X); for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+<dt><tt>slope</tt> (differentiable) : T</dt>
+<dd>Slope tensor. The shape of slope can be smaller than first input X; if so, its shape must be unidirectional broadcastable to X</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor (same size as X)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+### <a name="Scan-9"></a>**Scan-9**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops).
+  Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+  well as scan_output_element tensors) are required to have the same shape in each iteration
+  of the loop (a restriction imposed to enable efficient memory allocation).
+
+  Note that the iterated element passed to the body subgraph does not have a sequence
+  axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The optional attribute scan_input_directions specifies the direction (forward or backward)
+  for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+  direction. A bidirectional scan may be performed by specifying the same tensor input twice
+  in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+  The scan_output of the operation is produced by concatenating the scan_output_element
+  values produced by the body in each iteration.  The optional attribute scan_output_directions
+  specifies the direction in which scan_output is constructed (by appending or prepending the
+  scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+  is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+  The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+  If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+  batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+  Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+  The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+  are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+  scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+  value of 1.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body,
+          scan_input_axes = [axis_1, ..., axis_m]
+      > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+      sequence_length = scan_1.shape[axis_1];
+
+      // initialize state-variables
+      st_1 = init_1; ... st_n = init_n;
+      // initialize scan-output variables: [] denotes an empty tensor
+      scan_out_1 = []; ...; scan_out_k = [];
+      // identify number of iterations:
+
+      // execute loop
+      for (int t = 0; t < sequence_length; ++t) {
+          // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+          // of rank one less than T obtained by indexing T at position t along axis k.
+          si_1 = scan_1<axis=axis_1>[t];
+          ... ;
+          si_m = scan_m<axis=axis_m>[t];
+          // execute loop-body
+          st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+          // accumulate the scan-output elements
+          scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+      }
+
+      return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+<dt><tt>scan_input_axes</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the axis to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will be used as the scan axis for every scan_input.</dd>
+<dt><tt>scan_input_directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>scan_output_axes</tt> : list of ints</dt>
+<dd>An optional list of K flags. The i-th element of the list specifies the axis for the i-th scan_output. The scan outputs are accumulated along the specified axis. If omitted, 0 will be used as the scan axis for every scan_output.</dd>
+<dt><tt>scan_output_directions</tt> : list of ints</dt>
+<dd>An optional list of K flags, one for each scan_output. The i-th element of the list specifies whether the i-th scan_output should be constructed by appending or prepending a new value in each iteration: 0 indicates appending and 1 indicates prepending. If omitted, all scan_output tensors will be produced by appending a value in each iteration.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>All Tensor types</dd>
+</dl>
+
+### <a name="Scatter-9"></a>**Scatter-9**</a>
+
+  Given `data`, `updates` and `indices` input tensors of rank r >= 1, write the values provided by `updates`
+  into the first input, `data`, along `axis` dimension of `data` (by default outer-most one as axis=0) at corresponding `indices`.
+  For each entry in `updates`, the target index in `data` is specified by corresponding entry in `indices`
+  for dimension = axis, and index in source for dimension != axis. For instance, in a 2-D tensor case,
+  data[indices[i][j]][j] = updates[i][j] if axis = 0, or data[i][indices[i][j]] = updates[i][j] if axis = 1,
+  where i and j are loop counters from 0 up to the respective size in `updates` - 1.
+  Example 1:
+    data = [
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+    ]
+    indices = [
+        [1, 0, 2],
+        [0, 2, 1],
+    ]
+    updates = [
+        [1.0, 1.1, 1.2],
+        [2.0, 2.1, 2.2],
+    ]
+    output = [
+        [2.0, 1.1, 0.0]
+        [1.0, 0.0, 2.2]
+        [0.0, 2.1, 1.2]
+    ]
+  Example 2:
+    data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+    indices = [[1, 3]]
+    updates = [[1.1, 2.1]]
+    axis = 1
+    output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1]</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> : Tind</dt>
+<dd>Tensor of int32/int64 indices, of r >= 1 (same rank as input).</dd>
+<dt><tt>updates</tt> : T</dt>
+<dd>Tensor of rank r >=1 (same rank and shape as indices)</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor of rank r >= 1 (same rank as input).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input and output types can be of any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="Shrink-9"></a>**Shrink-9**</a>
+
+  Shrink takes one input data (Tensor<numeric>) and produces one Tensor output,
+  having same datatype and shape with input. It has two attributes, lambd and
+  bias. The formula of this operator is: If x < -lambd, y = x + bias;
+  If x > lambd, y = x - bias; Otherwise, y = 0.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>bias</tt> : float (default is 0.0)</dt>
+<dd>The bias value added to output. Default is 0.</dd>
+<dt><tt>lambd</tt> : float (default is 0.5)</dt>
+<dd>The lambd value for the Shrink formulation. Default is 0.5.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The input data as Tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to only numeric types.</dd>
+</dl>
+
+### <a name="Sign-9"></a>**Sign-9**</a>
+
+  Calculate the sign of the given input tensor element-wise.
+  If input > 0, output 1. if input < 0, output -1. if input == 0, output 0.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The sign of the input tensor computed element-wise. It has the same shape and type of the input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Sinh-9"></a>**Sinh-9**</a>
+
+  Calculates the hyperbolic sine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic sine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="TfIdfVectorizer-9"></a>**TfIdfVectorizer-9**</a>
+
+  This transform extracts n-grams from the input sequence and save them as a vector. Input can
+  be either a 1-D or 2-D tensor. For 1-D input, output is the n-gram representation of that input.
+  For 2-D input, the output is also a  2-D tensor whose i-th row is the n-gram representation of the i-th input row.
+  More specifically, if input shape is [C], the corresponding output shape would be [max(ngram_indexes) + 1].
+  If input shape is [N, C], this operator produces a [N, max(ngram_indexes) + 1]-tensor.
+
+  In contrast to standard n-gram extraction, here, the indexes of extracting an n-gram from the original
+  sequence are not necessarily consecutive numbers. The discontinuity between indexes are controlled by the number of skips.
+  If the number of skips is 2, we should skip two tokens when scanning through the original sequence.
+  Let's consider an example. Assume that input sequence is [94, 17, 36, 12, 28] and the number of skips is 2.
+  The associated 2-grams are [94, 12] and [17, 28] respectively indexed by [0, 3] and [1, 4].
+  If the number of skips becomes 0, the 2-grams generated are [94, 17], [17, 36], [36, 12], [12, 28]
+  indexed by [0, 1], [1, 2], [2, 3], [3, 4], respectively.
+
+  The output vector (denoted by Y) stores the count of each n-gram;
+  Y[ngram_indexes[i]] indicates the times that the i-th n-gram is found. The attribute ngram_indexes is used to determine the mapping
+  between index i and the corresponding n-gram's output coordinate. If pool_int64s is [94, 17, 17, 36], ngram_indexes is [1, 0],
+  ngram_counts=[0, 0], then the Y[0] (first element in Y) and Y[1] (second element in Y) are the counts of [17, 36] and [94, 17],
+  respectively. An n-gram which cannot be found in pool_strings/pool_int64s should be ignored and has no effect on the output.
+  Note that we may consider all skips up to S when generating the n-grams.
+
+  The examples used above are true if mode is "TF". If mode is "IDF", all the counts larger than 1 would be truncated to 1 and
+  the i-th element in weights would be used to scale (by multiplication) the count of the i-th n-gram in pool. If mode is "TFIDF",
+  this operator first computes the counts of all n-grams and then scale them by the associated values in the weights attribute.
+
+  Only one of pool_strings and pool_int64s can be set. If pool_int64s is set, the input should be an integer tensor.
+  If pool_strings is set, the input must be a string tensor.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>max_gram_length</tt> : int (required)</dt>
+<dd>Maximum n-gram length. If this value is 3, 3-grams will be used to generate the output.</dd>
+<dt><tt>max_skip_count</tt> : int (required)</dt>
+<dd>Maximum number of items (integers/strings) to be skipped when constructing an n-gram from X. If max_skip_count=1, min_gram_length=2, max_gram_length=3, this operator may generate 2-grams with skip_count=0 and skip_count=1, and 3-grams with skip_count=0 and skip_count=1</dd>
+<dt><tt>min_gram_length</tt> : int (required)</dt>
+<dd>Minimum n-gram length. If this value is 2 and max_gram_length is 3, output may contain counts of 2-grams and 3-grams.</dd>
+<dt><tt>mode</tt> : string (required)</dt>
+<dd>The weighting criteria. It can be one of "TF" (term frequency), "IDF" (inverse document frequency), and "TFIDF" (the combination of TF and IDF)</dd>
+<dt><tt>ngram_counts</tt> : list of ints (required)</dt>
+<dd>The starting indexes of 1-grams, 2-grams, and so on in pool. It is useful when determining the boundary between two consecutive collections of n-grams. For example, if ngram_counts is [0, 17, 36], the first index (zero-based) of 1-gram/2-gram/3-gram in pool are 0/17/36. This format is essentially identical to CSR (or CSC) sparse matrix format, and we choose to use this due to its popularity.</dd>
+<dt><tt>ngram_indexes</tt> : list of ints (required)</dt>
+<dd>list of int64s (type: AttributeProto::INTS). This list is parallel to the specified 'pool_*' attribute. The i-th element in ngram_indexes indicate the coordinate of the i-th n-gram in the output tensor.</dd>
+<dt><tt>pool_int64s</tt> : list of ints</dt>
+<dd>List of int64 n-grams learned from the training set. Either this or pool_strings attributes must be present but not both. It's an 1-D tensor starting with the collections of all 1-grams and ending with the collections of n-grams. The i-th element in pool stores the n-gram that should be mapped to coordinate ngram_indexes[i] in the output vector.</dd>
+<dt><tt>pool_strings</tt> : list of strings</dt>
+<dd>List of strings n-grams learned from the training set. Either this or pool_int64s attributes must be present but not both. It's an 1-D tensor starting with the collections of all 1-grams and ending with the collections of n-grams. The i-th element in pool stores the n-gram that should be mapped to coordinate ngram_indexes[i] in the output vector.</dd>
+<dt><tt>weights</tt> : list of floats</dt>
+<dd>list of floats. This attribute stores the weight of each n-gram in pool. The i-th element in weights is the weight of the i-th n-gram in pool. Its length equals to the size of ngram_indexes. By default, weights is an all-one tensor.This attribute is used when mode is "IDF" or "TFIDF" to scale the associated word counts.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input for n-gram extraction</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T1</dt>
+<dd>Ngram results</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(string), tensor(int32), tensor(int64)</dt>
+<dd>Input is either string UTF-8 or int32/int64</dd>
+<dt><tt>T1</tt> : tensor(float)</dt>
+<dd>1-D tensor of floats</dd>
+</dl>
+
+### <a name="Upsample-9"></a>**Upsample-9**</a>
+
+  Upsample the input tensor.
+  Each dimension value of the output tensor is:
+    output_dimension = floor(input_dimension * scale).
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is nearest)</dt>
+<dd>Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>N-D tensor</dd>
+<dt><tt>scales</tt> : tensor(float)</dt>
+<dd>The scale array along each dimension. It takes value greater than or equal to 1. The number of elements of 'scales' should be the same as the rank of input 'X'.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>N-D tensor after resizing</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input 'X' and output 'Y' to all tensor types.</dd>
+</dl>
+
+### <a name="Where-9"></a>**Where-9**</a>
+
+  Return elements, either from X or Y, depending on condition.
+  Where behaves like
+  [numpy.where](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html)
+  with three parameters.
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>condition</tt> (non-differentiable) : B</dt>
+<dd>When True (nonzero), yield X, otherwise yield Y</dd>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>values selected at indices where condition is True</dd>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>values selected at indices where condition is False</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of shape equal to the broadcasted shape of condition, X, and Y.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Constrain to boolean tensors.</dd>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+## Version 10 of the default ONNX operator set
+### <a name="AveragePool-10"></a>**AveragePool-10**</a>
+
+  AveragePool consumes an input tensor X and applies average pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   average pooling consisting of computing the average on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - kernel_spatial_shape[i]) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - kernel_spatial_shape[i]) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled
+
+   ```
+   * pad_shape[i] is sum of pads along axis i
+   ```
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - kernel_spatial_shape[i] + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + kernel_spatial_shape[i] - input_spatial_shape[i]
+   ```
+   The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).
+
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>count_include_pad</tt> : int (default is 0)</dt>
+<dd>Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="ConvInteger-10"></a>**ConvInteger-10**</a>
+
+  The integer convolution operator consumes an input tensor, its zero-point, a filter, and its zero-point,
+  and computes the output. The production MUST never overflow. The accumulation may overflow if and only if in 32 bits.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into. default is 1.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input 'w'.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0.The value represent the number of pixels added to the beginning and end part of the corresponding axis.`pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number ofpixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`.This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaultsto 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each axis.</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn). Optionally, if dimension denotation is in effect, the operation expects input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>w</tt> : T2</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (M x C/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the kernel shape will be (M x C/group x k1 x k2 x ... x kn), where (k1 x k2 x ... kn) is the dimension of the kernel. Optionally, if dimension denotation is in effect, the operation expects the weight tensor to arrive with the dimension denotation of [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. X.shape[1] == (W.shape[1] * group) == C (assuming zero based indices for the shape array). Or in other words FILTER_IN_CHANNEL should be equal to DATA_CHANNEL. </dd>
+<dt><tt>x_zero_point</tt> (optional) : T1</dt>
+<dd>Zero point tensor for input 'x'. It's optional and default value is 0. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>w_zero_point</tt> (optional) : T2</dt>
+<dd>Zero point tensor for input 'w'. It's optional and default value is 0.  It could be a scalar or a 1-D tensor, which means a per-tensor/layer or per output channel quantization. If it's a 1-D tensor, its number of elements should be equal to the number of output channels (M)</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, and pad lengths.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input x and its zero point data type to 8-bit integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input w and its zero point data type to 8-bit integer tensor.</dd>
+<dt><tt>T3</tt> : tensor(int32)</dt>
+<dd>Constrain output y data type to 32-bit integer tensor.</dd>
+</dl>
+
+### <a name="DequantizeLinear-10"></a>**DequantizeLinear-10**</a>
+
+  The linear dequantization operator. It consumes a quantized tensor, a scale, a zero point to compute the full precision tensor.
+  The dequantization formula is y = (x - x_zero_point) * x_scale. 'x_scale' and 'x_zero_point' are both scalars.
+  'x_zero_point' and 'x' must have same type. 'x' and 'y' must have same shape. In the case of dequantizing int32,
+  there's no zero point (zero point is supposed to be 0).
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T</dt>
+<dd>N-D quantized input tensor to be de-quantized.</dd>
+<dt><tt>x_scale</tt> : tensor(float)</dt>
+<dd>Scale for input 'x'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>x_zero_point</tt> (optional) : T</dt>
+<dd>Zero point for input 'x'. It's a scalar, which means a per-tensor/layer quantization. It's optional. 0 is the default value when it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : tensor(float)</dt>
+<dd>N-D full precision output tensor. It has same shape as input 'x'.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(int8), tensor(uint8), tensor(int32)</dt>
+<dd>Constrain 'x_zero_point' and 'x' to 8-bit/32-bit integer tensor.</dd>
+</dl>
+
+### <a name="Dropout-10"></a>**Dropout-10**</a>
+
+  Dropout takes one input floating tensor and produces two tensor outputs,
+  output (floating tensor) and mask (`Tensor<bool>`). Depending on whether it is
+  in test mode or not, the output Y will either be a random dropout, or a simple
+  copy of the input. Note that our implementation of Dropout does scaling in
+  the training phase, so during testing nothing needs to be done.
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>ratio</tt> : float (default is 0.5)</dt>
+<dd>The ratio of random dropout</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>The input data as Tensor.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output.</dd>
+<dt><tt>mask</tt> (optional) : T1</dt>
+<dd>The output mask.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output mask types to boolean tensors.</dd>
+</dl>
+
+### <a name="IsInf-10"></a>**IsInf-10**</a>
+
+  Map infinity to true and other values to false.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>detect_negative</tt> : int (default is 1)</dt>
+<dd>(Optional) Whether map negative infinity to true. Default to 1 so that negative infinity induces true. Set this attribute to 0 if negative infinity should be mapped to false.</dd>
+<dt><tt>detect_positive</tt> : int (default is 1)</dt>
+<dd>(Optional) Whether map positive infinity to true. Default to 1 so that positive infinity induces true. Set this attribute to 0 if positive infinity should be mapped to false.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output types to boolean tensors.</dd>
+</dl>
+
+### <a name="MatMulInteger-10"></a>**MatMulInteger-10**</a>
+
+  Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+  The production MUST never overflow. The accumulation may overflow if and only if in 32 bits.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T1</dt>
+<dd>N-dimensional matrix A</dd>
+<dt><tt>B</tt> (non-differentiable) : T2</dt>
+<dd>N-dimensional matrix B</dd>
+<dt><tt>a_zero_point</tt> (optional, non-differentiable) : T1</dt>
+<dd>Zero point tensor for input 'A'. It's optional and default value is 0. It could be a scalar or N-D tensor. Scalar refers to per tensor quantization whereas N-D refers to per row quantization. If the input is 2D of shape [M, K] then zero point tensor may be an M element vector [zp_1, zp_2, ..., zp_M]. If the input is N-D tensor with shape [D1, D2, M, K] then zero point tensor may have shape [D1, D2, M, 1]. </dd>
+<dt><tt>b_zero_point</tt> (optional, non-differentiable) : T2</dt>
+<dd>Zero point tensor for input 'B'. It's optional and default value is 0. It could be a scalar or a N-D tensor, Scalar refers to per tensor quantization whereas N-D refers to per col quantization. If the input is 2D of shape [K, N] then zero point tensor may be an N element vector [zp_1, zp_2, ..., zp_N]. If the input is N-D tensor with shape [D1, D2, K, N] then zero point tensor may have shape [D1, D2, 1, N]. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T3</dt>
+<dd>Matrix multiply results from A * B</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input A data type to 8-bit integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input B data type to 8-bit integer tensor.</dd>
+<dt><tt>T3</tt> : tensor(int32)</dt>
+<dd>Constrain output Y data type as 32-bit integer tensor.</dd>
+</dl>
+
+### <a name="MaxPool-10"></a>**MaxPool-10**</a>
+
+  MaxPool consumes an input tensor X and applies max pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   max pooling consisting of computing the max on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled
+
+   ```
+   * pad_shape[i] is sum of pads along axis i
+   ```
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
+   ```
+   The output of each pooling window is maximum number of elements exclude pad.
+
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of filter.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>storage_order</tt> : int (default is 0)</dt>
+<dd>The storage order of the tensor. 0 is row major, and 1 is column major.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+<dt><tt>Indices</tt> (optional) : I</dt>
+<dd>Indices tensor from max pooling across the input tensor. The dimensions of indices are the same as output tensor. The values in indices of are the indices of the selected values during pooling. The indices are computed as flatten 1-D tensor, and the indices do not consider padding. So the values in indices are in [0, N x C x D1 x ... x Dn).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="Mod-10"></a>**Mod-10**</a>
+
+  Performs element-wise binary modulus (with Numpy-style broadcasting support).
+      The sign of the remainder is the same as that of the Divisor.
+
+      Mod operator can also behave like C fmod() or numpy.fmod. In this case, the sign of the remainder however, will be the same as the Dividend
+      (in contrast to integer mod). To force a behavior like numpy.fmod() an 'fmod' Attribute is provided.
+      This attribute is set to 0 by default causing the behavior to be like integer mod.
+      Setting this attribute to 1 causes the remainder to be calculated similar to that of numpy.fmod().
+
+      If the input type is floating point, then `fmod` attribute must be set to 1.
+
+      In case of dividend being zero, the results will be platform dependent.
+
+    This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>fmod</tt> : int (default is 0)</dt>
+<dd>Whether the operator should behave like fmod (default=0 meaning it will do integer mods); Set this to 1 to force fmod treatment</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Dividend tensor</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Divisor tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T</dt>
+<dd>Remainder tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="NonMaxSuppression-10"></a>**NonMaxSuppression-10**</a>
+
+  Filter out boxes that have high intersection-over-union (IOU) overlap with previously selected boxes.
+  Bounding boxes with score less than score_threshold are removed. Bounding box format is indicated by attribute center_point_box.
+  Boxes are suppressed if their IOU with a previously selected box is strictly greater than iou_threshold (i.e., boxes with IOU exactly equal to the threshold are kept).
+  Note that this algorithm is agnostic to where the origin is in the coordinate system and more generally is invariant to
+  orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system
+  result in the same boxes being selected by the algorithm.
+  The selected_indices output is a set of integers indexing into the input collection of bounding boxes representing the selected boxes.
+  The bounding box coordinates corresponding to the selected indices can then be obtained using the Gather or GatherND operation.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>center_point_box</tt> : int (default is 0)</dt>
+<dd>Integer indicate the format of the box data. The default is 0. 0 - the box data is supplied as [y1, x1, y2, x2] where (y1, x1) and (y2, x2) are the coordinates of any diagonal pair of box corners and the coordinates can be provided as normalized (i.e., lying in the interval [0, 1]) or absolute. Mostly used for TF models. 1 - the box data is supplied as [x_center, y_center, width, height]. Mostly used for Pytorch models.</dd>
+</dl>
+
+#### Inputs (2 - 5)
+
+<dl>
+<dt><tt>boxes</tt> : tensor(float)</dt>
+<dd>An input tensor with shape [num_batches, spatial_dimension, 4]. The single box data format is indicated by center_point_box.</dd>
+<dt><tt>scores</tt> : tensor(float)</dt>
+<dd>An input tensor with shape [num_batches, num_classes, spatial_dimension]</dd>
+<dt><tt>max_output_boxes_per_class</tt> (optional) : tensor(int64)</dt>
+<dd>Integer representing the maximum number of boxes to be selected per batch per class. It is a scalar. Default to 0, which means no output.</dd>
+<dt><tt>iou_threshold</tt> (optional) : tensor(float)</dt>
+<dd>Float representing the threshold for deciding whether boxes overlap too much with respect to IOU. It is scalar. Value range [0, 1]. Default to 0.</dd>
+<dt><tt>score_threshold</tt> (optional) : tensor(float)</dt>
+<dd>Float representing the threshold for deciding when to remove boxes based on score. It is a scalar.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>selected_indices</tt> : tensor(int64)</dt>
+<dd>selected indices from the boxes tensor. [num_selected_indices, 3], the selected index format is [batch_index, class_index, box_index].</dd>
+</dl>
+
+#### Type Constraints
+
+
+### <a name="QLinearConv-10"></a>**QLinearConv-10**</a>
+
+  The convolution operator consumes a quantized input tensor, its scale and zero point,
+  a quantized filter, its scale and zero point, and output's scale and zero point,
+  and computes the quantized output. Each scale and zero-point pair must have same shape.
+  It means they must be either scalars (per tensor) or 1-D tensors (per output channel).
+  Each input or output and its related zero point must have same type.
+  When bias is present it must be quantized using scale = input scale * weight scale and
+  zero point as 0.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into. default is 1.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input 'w'.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0.The value represent the number of pixels added to the beginning and end part of the corresponding axis.`pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number ofpixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`.This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaultsto 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (8 - 9)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn). Optionally, if dimension denotation is in effect, the operation expects input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>x_scale</tt> : tensor(float)</dt>
+<dd>Scale tensor for input 'x'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>x_zero_point</tt> : T1</dt>
+<dd>Zero point tensor for input 'x'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>w</tt> : T2</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (M x C/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the kernel shape will be (M x C/group x k1 x k2 x ... x kn), where (k1 x k2 x ... kn) is the dimension of the kernel. Optionally, if dimension denotation is in effect, the operation expects the weight tensor to arrive with the dimension denotation of [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. X.shape[1] == (W.shape[1] * group) == C (assuming zero based indices for the shape array). Or in other words FILTER_IN_CHANNEL should be equal to DATA_CHANNEL. </dd>
+<dt><tt>w_scale</tt> : tensor(float)</dt>
+<dd>Scale tensor for input 'w'. It could be a scalar or a 1-D tensor, which means a per-tensor/layer or per output channel quantization. If it's a 1-D tensor, its number of elements should be equal to the number of output channels (M).</dd>
+<dt><tt>w_zero_point</tt> : T2</dt>
+<dd>Zero point tensor for input 'w'. It could be a scalar or a 1-D tensor, which means a per-tensor/layer or per output channel quantization. If it's a 1-D tensor, its number of elements should be equal to the number of output channels (M).</dd>
+<dt><tt>y_scale</tt> : tensor(float)</dt>
+<dd>Scale tensor for output 'y'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>y_zero_point</tt> : T3</dt>
+<dd>Zero point tensor for output 'y'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>B</tt> (optional) : T4</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M. Bias must be quantized using scale = x_scale * w_scale and zero_point = 0</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, and pad lengths.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input type to 8-bit integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain filter type to 8-bit integer tensor.</dd>
+<dt><tt>T3</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain output type to 8-bit integer tensor.</dd>
+<dt><tt>T4</tt> : tensor(int32)</dt>
+<dd>Constrain bias type to 32-bit integer tensor.</dd>
+</dl>
+
+### <a name="QLinearMatMul-10"></a>**QLinearMatMul-10**</a>
+
+  Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+  It consumes two quantized input tensors, their scales and zero points, scale and zero point of output,
+  and computes the quantized output. The quantization formula is y = saturate((x / y_scale) + y_zero_point).
+  For (x / y_scale), it is rounding to nearest ties to even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+  Scale and zero point must have same shape. They must be either scalar (per tensor) or N-D tensor
+  (per row for 'a' and per column for 'b'). Scalar refers to per tensor quantization whereas N-D refers to per row
+  or per column quantization. If the input is 2D of shape [M, K] then zero point and scale tensor may be
+  an M element vector [v_1, v_2, ..., v_M] for per row quantization and K element vector of shape [v_1, v_2, ..., v_K]
+  for per column quantization. If the input is N-D tensor with shape [D1, D2, M, K] then zero point and scale tensor may
+  have shape [D1, D2, M, 1] for per row quantization and shape [D1, D2, 1, K] for per column quantization.
+  Production must never overflow, and accumulation may overflow if and only if in 32 bits.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>a</tt> (non-differentiable) : T1</dt>
+<dd>N-dimensional quantized matrix a</dd>
+<dt><tt>a_scale</tt> (non-differentiable) : tensor(float)</dt>
+<dd>scale of quantized input a</dd>
+<dt><tt>a_zero_point</tt> (non-differentiable) : T1</dt>
+<dd>zero point of quantized input a</dd>
+<dt><tt>b</tt> (non-differentiable) : T2</dt>
+<dd>N-dimensional quantized matrix b</dd>
+<dt><tt>b_scale</tt> (non-differentiable) : tensor(float)</dt>
+<dd>scale of quantized input b</dd>
+<dt><tt>b_zero_point</tt> (non-differentiable) : T2</dt>
+<dd>zero point of quantized input b</dd>
+<dt><tt>y_scale</tt> (non-differentiable) : tensor(float)</dt>
+<dd>scale of quantized output y</dd>
+<dt><tt>y_zero_point</tt> (non-differentiable) : T3</dt>
+<dd>zero point of quantized output y</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> (non-differentiable) : T3</dt>
+<dd>Quantized matrix multiply results from a * b</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input a and its zero point data type to 8-bit integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input b and its zero point data type to 8-bit integer tensor.</dd>
+<dt><tt>T3</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain output y and its zero point data type to 8-bit integer tensor.</dd>
+</dl>
+
+### <a name="QuantizeLinear-10"></a>**QuantizeLinear-10**</a>
+
+  The linear per-tensor/layer quantization operator. It consumes a high precision tensor, a scale, a zero point to compute the low precision / quantized tensor.
+  The quantization formula is y = saturate ((x / y_scale) + y_zero_point). For saturation, it saturates to [0, 255] if it's uint8, or [-128, 127] if it's int8.
+  For (x / y_scale), it's rounding to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details. 'y_zero_point' and 'y' must have same type.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D full precision Input tensor to be quantized.</dd>
+<dt><tt>y_scale</tt> : tensor(float)</dt>
+<dd>Scale for doing quantization to get 'y'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>y_zero_point</tt> (optional) : T2</dt>
+<dd>Zero point for doing quantization to get 'y'. It's a scalar, which means a per-tensor/layer quantization. Default value is uint8 typed 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T2</dt>
+<dd>N-D quantized output tensor. It has same shape as input 'x'.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(int32)</dt>
+<dd>Constrain 'x' to float or int32 tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain 'y_zero_point' and 'y' to 8-bit integer tensor.</dd>
+</dl>
+
+### <a name="Resize-10"></a>**Resize-10**</a>
+
+  Resize the input tensor.
+  Each dimension value of the output tensor is:
+    output_dimension = floor(input_dimension * scale).
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is nearest)</dt>
+<dd>Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>N-D tensor</dd>
+<dt><tt>scales</tt> : tensor(float)</dt>
+<dd>The scale array along each dimension. It takes value greater than 0. If it's less than 1, it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should be the same as the rank of input 'X'.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>N-D tensor after resizing</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input 'X' and output 'Y' to all tensor types.</dd>
+</dl>
+
+### <a name="ReverseSequence-10"></a>**ReverseSequence-10**</a>
+
+  Reverse batch of sequences having different lengths specified by `sequence_lens`.
+
+  For each slice i iterating on batch axis, the operator reverses the first sequence_lens[i] elements on time axis,
+  and copies elements whose index's beyond sequence_lens[i] to the output. So the output slice i contains reversed
+  sequences on the first sequence_lens[i] elements, then have original values copied for the other elements.
+
+  Example 1:
+    input = [[0.0, 4.0, 8.0,  12.0],
+             [1.0, 5.0, 9.0,  13.0],
+             [2.0, 6.0, 10.0, 14.0],
+             [3.0, 7.0, 11.0, 15.0]]
+    sequence_lens = [4, 3, 2, 1]
+    time_axis = 0
+    batch_axis = 1
+
+    output = [[3.0, 6.0, 9.0,  12.0],
+              [2.0, 5.0, 8.0,  13.0],
+              [1.0, 4.0, 10.0, 14.0],
+              [0.0, 7.0, 11.0, 15.0]]
+
+  Example 2:
+    input = [[0.0,  1.0,  2.0,  3.0 ],
+             [4.0,  5.0,  6.0,  7.0 ],
+             [8.0,  9.0,  10.0, 11.0],
+             [12.0, 13.0, 14.0, 15.0]]
+    sequence_lens = [1, 2, 3, 4]
+    time_axis = 1
+    batch_axis = 0
+
+    output = [[0.0,  1.0,  2.0,  3.0 ],
+              [5.0,  4.0,  6.0,  7.0 ],
+              [10.0, 9.0,  8.0,  11.0],
+              [15.0, 14.0, 13.0, 12.0]]
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>batch_axis</tt> : int (default is 1)</dt>
+<dd>(Optional) Specify which axis is batch axis. Must be one of 1 (default), or 0.</dd>
+<dt><tt>time_axis</tt> : int (default is 0)</dt>
+<dd>(Optional) Specify which axis is time axis. Must be one of 0 (default), or 1.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Tensor of rank r >= 2.</dd>
+<dt><tt>sequence_lens</tt> : tensor(int64)</dt>
+<dd>Tensor specifying lengths of the sequences in a batch. It has shape `[batch_size]`.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Tensor with same shape of input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input and output types can be of any tensor type.</dd>
+</dl>
+
+### <a name="RoiAlign-10"></a>**RoiAlign-10**</a>
+
+  Region of Interest (RoI) align operation described in the
+  [Mask R-CNN paper](https://arxiv.org/abs/1703.06870).
+  RoiAlign consumes an input tensor X and region of interests (rois)
+  to apply pooling across each RoI; it produces a 4-D tensor of shape
+  (num_rois, C, output_height, output_width).
+
+  RoiAlign is proposed to avoid the misalignment by removing
+  quantizations while converting from original image into feature
+  map and from feature map into RoI feature; in each ROI bin,
+  the value of the sampled locations are computed directly
+  through bilinear interpolation.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is avg)</dt>
+<dd>The pooling method. Two modes are supported: 'avg' and 'max'. Default is 'avg'.</dd>
+<dt><tt>output_height</tt> : int (default is 1)</dt>
+<dd>default 1; Pooled output Y's height.</dd>
+<dt><tt>output_width</tt> : int (default is 1)</dt>
+<dd>default 1; Pooled output Y's width.</dd>
+<dt><tt>sampling_ratio</tt> : int (default is 0)</dt>
+<dd>Number of sampling points in the interpolation grid used to compute the output value of each pooled output bin. If > 0, then exactly sampling_ratio x sampling_ratio grid points are used. If == 0, then an adaptive number of grid points are used (computed as ceil(roi_width / output_width), and likewise for height). Default is 0.</dd>
+<dt><tt>spatial_scale</tt> : float (default is 1.0)</dt>
+<dd>Multiplicative spatial scale factor to translate ROI coordinates from their input spatial scale to the scale used when pooling, i.e., spatial scale of the input feature map X relative to the input image. E.g.; default is 1.0f. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data tensor from the previous operator; 4-D feature map of shape (N, C, H, W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data.</dd>
+<dt><tt>rois</tt> : T1</dt>
+<dd>RoIs (Regions of Interest) to pool over; rois is 2-D input of shape (num_rois, 4) given as [[x1, y1, x2, y2], ...]. The RoIs' coordinates are in the coordinate system of the input image. Each coordinate set has a 1:1 correspondence with the 'batch_indices' input.</dd>
+<dt><tt>batch_indices</tt> : T2</dt>
+<dd>1-D tensor of shape (num_rois,) with each element denoting the index of the corresponding image in the batch.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>RoI pooled output, 4-D tensor of shape (num_rois, C, output_height, output_width). The r-th batch element Y[r-1] is a pooled feature map corresponding to the r-th RoI X[r-1].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain types to int tensors.</dd>
+</dl>
+
+### <a name="Slice-10"></a>**Slice-10**</a>
+
+  Produces a slice of the input tensor along multiple axes. Similar to numpy:
+  https://numpy.org/doc/stable/reference/routines.indexing.html
+  Slices uses `starts`, `ends`, `axes` and `steps` inputs to specify the start and end
+  dimension and step for each axis in the list of axes, it uses this information to
+  slice the input `data` tensor. If a negative value is passed for any of the
+  start or end indices, it represent number of elements before the end of that
+  dimension. If the value passed to start or end is larger than the `n` (the
+  number of elements in this dimension), it represents `n`. For slicing to the
+  end of a dimension with unknown size, it is recommended to pass in `INT_MAX`.
+  If a negative value is passed for step, it represents slicing backward.
+  If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
+  If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
+  Example 1:
+    data = [
+        [1, 2, 3, 4],
+        [5, 6, 7, 8],
+    ]
+    axes = [0, 1]
+    starts = [1, 0]
+    ends = [2, 3]
+    steps = [1, 2]
+    result = [
+        [5, 7],
+    ]
+  Example 2:
+    data = [
+        [1, 2, 3, 4],
+        [5, 6, 7, 8],
+    ]
+    starts = [0, 1]
+    ends = [-1, 1000]
+    result = [
+        [2, 3, 4],
+    ]
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Inputs (3 - 5)
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of data to extract slices from.</dd>
+<dt><tt>starts</tt> : Tind</dt>
+<dd>1-D tensor of starting indices of corresponding axis in `axes`</dd>
+<dt><tt>ends</tt> : Tind</dt>
+<dd>1-D tensor of ending indices (exclusive) of corresponding axis in `axes`</dd>
+<dt><tt>axes</tt> (optional) : Tind</dt>
+<dd>1-D tensor of axes that `starts` and `ends` apply to.</dd>
+<dt><tt>steps</tt> (optional) : Tind</dt>
+<dd>1-D tensor of slice step of corresponding axis in `axes`. Default to 1. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Sliced data tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="StringNormalizer-10"></a>**StringNormalizer-10**</a>
+
+  StringNormalization performs string operations for basic cleaning.
+  This operator has only one input (denoted by X) and only one output
+  (denoted by Y). This operator first examines the elements in the X,
+  and removes elements specified in "stopwords" attribute.
+  After removing stop words, the intermediate result can be further lowercased,
+  uppercased, or just returned depending the "case_change_action" attribute.
+  This operator only accepts [C]- and [1, C]-tensor.
+  If all elements in X are dropped, the output will be the empty value of string tensor with shape [1]
+  if input shape is [C] and shape [1, 1] if input shape is [1, C].
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>case_change_action</tt> : string (default is NONE)</dt>
+<dd>string enum that cases output to be lowercased/uppercases/unchanged. Valid values are "LOWER", "UPPER", "NONE". Default is "NONE"</dd>
+<dt><tt>is_case_sensitive</tt> : int (default is 0)</dt>
+<dd>Boolean. Whether the identification of stop words in X is case-sensitive. Default is false</dd>
+<dt><tt>locale</tt> : string</dt>
+<dd>Environment dependent string that denotes the locale according to which output strings needs to be upper/lowercased.Default en_US or platform specific equivalent as decided by the implementation.</dd>
+<dt><tt>stopwords</tt> : list of strings</dt>
+<dd>List of stop words. If not set, no word would be removed from X.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : tensor(string)</dt>
+<dd>UTF-8 strings to normalize</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(string)</dt>
+<dd>UTF-8 Normalized strings</dd>
+</dl>
+
+#### Type Constraints
+
+
+### <a name="ThresholdedRelu-10"></a>**ThresholdedRelu-10**</a>
+
+  ThresholdedRelu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the rectified linear function, y = x for x > alpha, y = 0 otherwise,
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Threshold value</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="TopK-10"></a>**TopK-10**</a>
+
+  Retrieve the top-K elements along a specified axis. Given an input tensor of
+  shape [a_0, a_1, ..., a_{n-1}] and integer argument k, return two outputs:
+    -Value tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}]
+      which contains the values of the top k elements along the specified axis
+    -Index tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] which
+     contains the indices of the top k elements (original indices from the input
+     tensor).
+
+  Given two equivalent values, this operator uses the indices along the axis  as
+   a tiebreaker. That is, the element with the lower index will appear first.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>Dimension on which to do the sort.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{n-1}]</dd>
+<dt><tt>K</tt> : tensor(int64)</dt>
+<dd>A 1-D tensor containing a single positive value corresponding to the number of top elements to retrieve</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Values</tt> : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing top K values from the input tensor</dd>
+<dt><tt>Indices</tt> : I</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing the corresponding input tensor indices for the top K values.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="Upsample-10"></a>**Upsample-10** (deprecated)</a>
+
+  Upsample the input tensor.
+  Each dimension value of the output tensor is:
+    output_dimension = floor(input_dimension * scale).
+
+#### Version
+
+This version of the operator has been deprecated since version 10 of the default ONNX operator set.
+
+## Version 11 of the default ONNX operator set
+### <a name="ArgMax-11"></a>**ArgMax-11**</a>
+
+  Computes the indices of the max elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equal 0, then the resulting tensor has the reduced dimension pruned.
+  The input tensor must not be empty.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="ArgMin-11"></a>**ArgMin-11**</a>
+
+  Computes the indices of the min elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equal 0, then the resulting tensor has the reduced dimension pruned.
+  The input tensor must not be empty.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="AveragePool-11"></a>**AveragePool-11**</a>
+
+  AveragePool consumes an input tensor X and applies average pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   average pooling consisting of computing the average on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled
+
+   ```
+   * pad_shape[i] is sum of pads along axis i
+   ```
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+  or when ceil_mode is disabled:
+   ```
+   VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
+   ```
+   The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>count_include_pad</tt> : int (default is 0)</dt>
+<dd>Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="BitShift-11"></a>**BitShift-11**</a>
+
+  Bitwise shift operator performs element-wise operation. For each input element, if the
+  attribute "direction" is "RIGHT", this operator moves its binary representation toward
+  the right side so that the input value is effectively decreased. If the attribute "direction"
+  is "LEFT", bits of binary representation moves toward the left side, which results the
+  increase of its actual value. The input X is the tensor to be shifted and another input
+  Y specifies the amounts of shifting. For example, if "direction" is "Right", X is [1, 4],
+  and S is [1, 1], the corresponding output Z would be [0, 2]. If "direction" is "LEFT" with
+  X=[1, 2] and S=[1, 2], the corresponding output Y would be [2, 8].
+
+  Because this operator supports Numpy-style broadcasting, X's and Y's shapes are
+  not necessarily identical.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>direction</tt> : string (required)</dt>
+<dd>Direction of moving bits. It can be either "RIGHT" (for right shift) or "LEFT" (for left shift).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>First operand, input to be shifted.</dd>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Second operand, amounts of shift.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64)</dt>
+<dd>Constrain input and output types to integer tensors.</dd>
+</dl>
+
+### <a name="Clip-11"></a>**Clip-11**</a>
+
+  Clip operator limits the given input within an interval. The interval is
+  specified by the inputs 'min' and 'max'. They default to
+  numeric_limits::lowest() and numeric_limits::max(), respectively.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor whose elements to be clipped</dd>
+<dt><tt>min</tt> (optional) : T</dt>
+<dd>Minimum value, under which element is replaced by min. It must be a scalar(tensor of empty shape).</dd>
+<dt><tt>max</tt> (optional) : T</dt>
+<dd>Maximum value, above which element is replaced by max. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor with clipped input elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Compress-11"></a>**Compress-11**</a>
+
+  Selects slices from an input tensor along a given axis where condition evaluates to True for each axis index.
+      In case axis is not provided, input is flattened before elements are selected.
+      Compress behaves like numpy.compress: https://docs.scipy.org/doc/numpy/reference/generated/numpy.compress.html
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>(Optional) Axis along which to take slices. If not specified, input is flattened before elements being selected. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>condition</tt> (non-differentiable) : T1</dt>
+<dd>Rank 1 tensor of booleans to indicate which slices or data elements to be selected. Its length can be less than the input length along the axis or the flattened input size if axis is not specified. In such cases data slices or elements exceeding the condition length are discarded.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r if axis is specified. Otherwise output is a Tensor of rank 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain to boolean tensors.</dd>
+</dl>
+
+### <a name="Concat-11"></a>**Concat-11**</a>
+
+  Concatenate a list of tensors into a single tensor. All input tensors must have the same shape, except for the dimension size of the axis to concatenate on.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (required)</dt>
+<dd>Which axis to concat on. A negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(inputs)..</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>inputs</tt> (variadic) : T</dt>
+<dd>List of tensors for concatenation</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>concat_result</tt> : T</dt>
+<dd>Concatenated tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+### <a name="ConcatFromSequence-11"></a>**ConcatFromSequence-11**</a>
+
+  Concatenate a sequence of tensors into a single tensor.
+  All input tensors must have the same shape, except for the dimension size of the axis to concatenate on.
+  By default 'new_axis' is 0, the behavior is similar to numpy.concatenate.
+  When 'new_axis' is 1, the behavior is similar to numpy.stack.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (required)</dt>
+<dd>Which axis to concat on. Accepted range in `[-r, r - 1]`, where `r` is the rank of input tensors. When `new_axis` is 1, accepted range is `[-r - 1, r]`. </dd>
+<dt><tt>new_axis</tt> : int (default is 0)</dt>
+<dd>Insert and concatenate on a new axis or not, default 0 means do not insert new axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Sequence of tensors for concatenation</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>concat_result</tt> : T</dt>
+<dd>Concatenated tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input types to any tensor type.</dd>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+### <a name="Constant-11"></a>**Constant-11**</a>
+
+  A constant tensor. Exactly one of the two attributes, either value or sparse_value,
+  must be specified.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>sparse_value</tt> : sparse_tensor</dt>
+<dd>The value for the elements of the output tensor in sparse format.</dd>
+<dt><tt>value</tt> : tensor</dt>
+<dd>The value for the elements of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Conv-11"></a>**Conv-11**</a>
+
+  The convolution operator consumes an input tensor and a filter, and
+  computes the output.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input W.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults is 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn). Optionally, if dimension denotation is in effect, the operation expects input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (M x C/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the kernel shape will be (M x C/group x k1 x k2 x ... x kn), where (k1 x k2 x ... kn) is the dimension of the kernel. Optionally, if dimension denotation is in effect, the operation expects the weight tensor to arrive with the dimension denotation of [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. Assuming zero based indices for the shape array, X.shape[1] == (W.shape[1] * group) == C and W.shape[0] mod G == 0. Or in other words FILTER_IN_CHANNEL multiplied by the number of groups should be equal to DATA_CHANNEL and the number of feature maps M should be a multiple of the number of groups G.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, and pad lengths.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="ConvTranspose-11"></a>**ConvTranspose-11**</a>
+
+  The convolution transpose operator consumes an input tensor and a filter,
+  and computes the output.
+
+  If the pads parameter is provided the shape of the output is calculated via the following equation:
+
+    output_shape[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - pads[start_i] - pads[end_i]
+
+  output_shape can also be explicitly specified in which case pads values are auto generated using these equations:
+
+    total_padding[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - output_shape[i]
+    If (auto_pads == SAME_UPPER): pads[start_i] = total_padding[i]/2; pads[end_i] = total_padding[i] - (total_padding[i]/2)
+    Else: pads[start_i] = total_padding[i] - (total_padding[i]/2); pads[end_i] = (total_padding[i]/2).
+
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = input_shape[i] * strides[i]` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input W.</dd>
+<dt><tt>output_padding</tt> : list of ints</dt>
+<dd>Additional elements added to the side with higher coordinate indices in the output. Each padding value in "output_padding" must be less than the corresponding stride/dilation dimension. By default, this attribute is a zero vector. Note that this attribute doesn't directly affect the computed output values. It only controls the selection of the computed values, so changing this attribute only adds or removes output elements. If "output_shape" is explicitly provided, "output_padding" does not contribute additional size to "output_shape" but participates in the computation of the needed padding amount. This is also called adjs or adjustment in some frameworks.</dd>
+<dt><tt>output_shape</tt> : list of ints</dt>
+<dd>The shape of the output can be explicitly set which will cause pads values to be auto generated. If output_shape is specified pads values are ignored. See doc for details for equations to generate pads. Note that the output_shape attribute value should not include dimensions for batch size and channels, which are automatically inferred.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn)</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (C x M/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the weight shape will be (C x M/group x k1 x k2 x ... x kn), where (k1 x k2 x ... x kn) is the dimension of the kernel. The number of channels in the output should be equal to W.shape[1] * group (assuming zero based indices of the shape array)</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, pad lengths and group count. The number of channels in the output should be equal to W.shape[1] * group (assuming zero based indices of the shape array)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="CumSum-11"></a>**CumSum-11**</a>
+
+  Performs cumulative sum of the input elements along the given axis.
+  By default, it will do the sum inclusively meaning the first element is copied as is.
+  Through an `exclusive` attribute, this behavior can change to exclude the first element.
+  It can also perform summation in the opposite direction of the axis. For that, set `reverse` attribute to 1.
+
+  Example:
+  ```
+  input_x = [1, 2, 3]
+  axis=0
+  output = [1, 3, 6]
+  exclusive=1
+  output = [0, 1, 3]
+  exclusive=0
+  reverse=1
+  output = [6, 5, 3]
+  exclusive=1
+  reverse=1
+  output = [5, 3, 0]
+  ```
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>exclusive</tt> : int (default is 0)</dt>
+<dd>If set to 1 will return exclusive sum in which the top element is not included. In other terms, if set to 1, the j-th output element would be the sum of the first (j-1) elements. Otherwise, it would be the sum of the first j elements.</dd>
+<dt><tt>reverse</tt> : int (default is 0)</dt>
+<dd>If set to 1 will perform the sums in reverse direction.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>x</tt> (differentiable) : T</dt>
+<dd>An input tensor that is to be processed.</dd>
+<dt><tt>axis</tt> (non-differentiable) : T2</dt>
+<dd>A 0-D tensor. Must be in the range [-rank(x), rank(x)-1]. Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> (differentiable) : T</dt>
+<dd>Output tensor of the same type as 'x' with cumulative sums of the x's elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float), tensor(double)</dt>
+<dd>Input can be of any tensor type.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>axis tensor can be int32 or int64 only</dd>
+</dl>
+
+### <a name="DepthToSpace-11"></a>**DepthToSpace-11**</a>
+
+  DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
+  This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
+  the input tensor where values from the depth dimension are moved in spatial blocks to the height
+  and width dimensions. By default, `mode` = `DCR`.
+  In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the
+  following order: depth, column, and then row. The output y is computed from the input x as below:
+
+  b, c, h, w = x.shape
+
+  tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])
+
+  tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])
+
+  y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])
+
+
+  In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the
+  following order: column, row, and the depth. The output y is computed from the input x as below:
+
+  b, c, h, w = x.shape
+
+  tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])
+
+  tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])
+
+  y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>blocksize</tt> : int (required)</dt>
+<dd>Blocks of [blocksize, blocksize] are moved.</dd>
+<dt><tt>mode</tt> : string (default is DCR)</dt>
+<dd>DCR (default) for depth-column-row order re-arrangement. Use CRD for column-row-depth order.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Det-11"></a>**Det-11**</a>
+
+  Det calculates determinant of a square matrix or batches of square matrices.
+  Det takes one input tensor of shape `[*, M, M]`, where `*` is zero or more batch dimensions,
+  and the inner-most 2 dimensions form square matrices.
+  The output is a tensor of shape `[*]`, containing the determinants of all input submatrices.
+  e.g., When the input is 2-D, the output is a scalar(shape is empty: `[]`).
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to floating-point tensors.</dd>
+</dl>
+
+### <a name="DynamicQuantizeLinear-11"></a>**DynamicQuantizeLinear-11**</a>
+
+  A Function to fuse calculation for Scale, Zero Point and FP32->8Bit conversion of FP32 Input data.
+  Outputs Scale, ZeroPoint and Quantized Input for a given FP32 Input.
+  Scale is calculated as:
+  ```
+  y_scale = (maximum(0, max(x)) - minimum(0, min(x))) / (qmax - qmin)
+  ```
+
+  * where qmax and qmin are max and min values for quantization range i.e. [0, 255] in case of uint8
+  * data range is adjusted to include 0.
+
+  Zero point is calculated as:
+  ```
+  intermediate_zero_point = qmin - min(x)/y_scale
+  y_zero_point = cast(round(saturate(intermediate_zero_point)))
+  ```
+
+  * where qmax and qmin are max and min values for quantization range .i.e [0, 255] in case of uint8
+  * for saturation, it saturates to [0, 255] if it's uint8, or [-127, 127] if it's int8. Right now only uint8 is supported.
+  * rounding to nearest ties to even.
+
+  Data quantization formula is:
+  ```
+  y = saturate (round (x / y_scale) + y_zero_point)
+  ```
+
+  * for saturation, it saturates to [0, 255] if it's uint8, or [-127, 127] if it's int8. Right now only uint8 is supported.
+  * rounding to nearest ties to even.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T2</dt>
+<dd>Quantized output tensor</dd>
+<dt><tt>y_scale</tt> : tensor(float)</dt>
+<dd>Output scale. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>y_zero_point</tt> : T2</dt>
+<dd>Output zero point. It's a scalar, which means a per-tensor/layer quantization.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float)</dt>
+<dd>Constrain 'x' to float tensor.</dd>
+<dt><tt>T2</tt> : tensor(uint8)</dt>
+<dd>Constrain 'y_zero_point' and 'y' to 8-bit unsigned integer tensor.</dd>
+</dl>
+
+### <a name="Equal-11"></a>**Equal-11**</a>
+
+  Returns the tensor resulted from performing the `equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Flatten-11"></a>**Flatten-11**</a>
+
+  Flattens the input tensor into a 2D matrix. If input tensor has shape
+  (d_0, d_1, ... d_n) then the output will have shape
+  (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Indicate up to which input dimensions (exclusive) should be flattened to the outer dimension of the output. The value for axis must be in the range [-r, r], where r is the rank of the input tensor. Negative value means counting dimensions from the back. When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), where the shape of the input tensor is (d_0, d_1, ... d_n). </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>A tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>A 2D tensor with the contents of the input tensor, with input dimensions up to axis flattened to the outer dimension of the output and remaining input dimensions flattened into the inner dimension of the output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output to all tensor types.</dd>
+</dl>
+
+### <a name="Gather-11"></a>**Gather-11**</a>
+
+  Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
+  entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
+  them in an output tensor of rank q + (r - 1).
+
+  axis = 0 :
+
+  Let
+  k = indices[i_{0}, ..., i_{q-1}]
+  Then
+  output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[k , j_{0}, ..., j_{r-2}]
+
+  ```
+    data = [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+    indices = [
+        [0, 1],
+        [1, 2],
+    ]
+    output = [
+        [
+            [1.0, 1.2],
+            [2.3, 3.4],
+        ],
+        [
+            [2.3, 3.4],
+            [4.5, 5.7],
+        ],
+    ]
+  ```
+  axis = 1 :
+
+  Let
+  k = indices[i_{0}, ..., i_{q-1}]
+  Then
+  output[j_{0}, i_{0}, ..., i_{q-1}, j_{1}, ..., j_{r-2}] = input[j_{0}, k, j_{1}, ..., j_{r-2}]
+
+  ```
+    data = [
+        [1.0, 1.2, 1.9],
+        [2.3, 3.4, 3.9],
+        [4.5, 5.7, 5.9],
+    ]
+    indices = [
+        [0, 2],
+    ]
+    axis = 1,
+    output = [
+        [[1.0, 1.9]],
+        [[2.3, 3.9]],
+        [[4.5, 5.9]],
+    ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to gather on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> : Tind</dt>
+<dd>Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor of rank q + (r - 1).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="GatherElements-11"></a>**GatherElements-11**</a>
+
+  GatherElements takes two inputs `data` and `indices` of the same rank r >= 1
+  and an optional attribute `axis` that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). It is an indexing operation
+  that produces its output by indexing into the input data tensor at index
+  positions determined by elements of the `indices` tensor.
+  Its output shape is the same as the shape of `indices` and consists of one value
+  (gathered from the `data`) for each element in `indices`.
+
+  For instance, in the 3-D case (r = 3), the output produced is determined
+  by the following equations:
+  ```
+    out[i][j][k] = input[index[i][j][k]][j][k] if axis = 0,
+    out[i][j][k] = input[i][index[i][j][k]][k] if axis = 1,
+    out[i][j][k] = input[i][j][index[i][j][k]] if axis = 2,
+  ```
+
+  This operator is also the inverse of ScatterElements. It is similar to Torch's gather operation.
+
+  Example 1:
+  ```
+    data = [
+        [1, 2],
+        [3, 4],
+    ]
+    indices = [
+        [0, 0],
+        [1, 0],
+    ]
+    axis = 1
+    output = [
+        [
+          [1, 1],
+          [4, 3],
+        ],
+    ]
+  ```
+  Example 2:
+  ```
+    data = [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+    ]
+    indices = [
+        [1, 2, 0],
+        [2, 0, 0],
+    ]
+    axis = 0
+    output = [
+        [
+          [4, 8, 3],
+          [7, 2, 3],
+        ],
+    ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to gather on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> : Tind</dt>
+<dd>Tensor of int32/int64 indices, with the same rank r as the input. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor of the same shape as indices.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="GatherND-11"></a>**GatherND-11**</a>
+
+  Given `data` tensor of rank `r` >= 1, and `indices` tensor of rank `q` >= 1, this operator gathers
+  slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1`.
+
+  `indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
+  where each element defines a slice of `data`
+
+  Some salient points about the inputs' rank and shape:
+
+  1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`
+
+  2) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r` (inclusive)
+
+  3) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
+     It is an error if any of the index values are out of bounds.
+
+  The output is computed as follows:
+
+  The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.
+
+  1) If `indices_shape[-1] > r` => error condition
+
+  2) If `indices_shape[-1] == r`, since the rank of `indices` is `q`, `indices` can be thought of as a `(q-1)`-dimensional tensor
+     containing 1-D tensors of dimension `r`. Let us think of each such `r` ranked tensor as `indices_slice`.
+     Each *scalar value* corresponding to `data[indices_slice]` is filled into the corresponding location of the `(q-1)`-dimensional tensor
+     to form the `output` tensor (Example 1 below)
+
+  3) If `indices_shape[-1] < r`, since the rank of `indices` is `q`, `indices` can be thought of as a `(q-1)`-dimensional tensor
+     containing 1-D tensors of dimension `< r`. Let us think of each such tensors as `indices_slice`.
+     Each *tensor slice* corresponding to `data[indices_slice , :]` is filled into the corresponding location of the `(q-1)`-dimensional tensor
+     to form the `output` tensor (Examples 2, 3, and 4 below)
+
+  This operator is the inverse of `ScatterND`.
+
+  `Example 1`
+
+    data    = [[0,1],[2,3]]   # data_shape = [2, 2]
+
+    indices = [[0,0],[1,1]]   # indices_shape = [2, 2]
+
+    output  = [0,3]           # output_shape = [2]
+
+  `Example 2`
+
+    data    = [[0,1],[2,3]]  # data_shape = [2, 2]
+
+    indices = [[1],[0]]      # indices_shape = [2, 1]
+
+    output  = [[2,3],[0,1]]  # output_shape = [2, 2]
+
+  `Example 3`
+
+    data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+    indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]
+
+    output  = [[2,3],[4,5]]                 # output_shape = [2, 2]
+
+  `Example 4`
+
+    data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+    indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]
+
+    output  = [[[2,3]],[[4,5]]]             # output_shape = [2, 1, 2]
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> : tensor(int64)</dt>
+<dd>Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor of rank q + r - indices_shape[-1] - 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+### <a name="Gemm-11"></a>**Gemm-11**</a>
+
+  General Matrix multiplication:
+  https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+
+  A' = transpose(A) if transA else A
+
+  B' = transpose(B) if transB else B
+
+  Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M),
+  input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N),
+  and output tensor Y has shape (M, N). A will be transposed before doing the
+  computation if attribute transA is non-zero, same for B and transB.
+  This operator supports **unidirectional broadcasting** (tensor C should be unidirectional broadcastable to tensor A * B); for more details please check [the doc](Broadcasting.md).
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for the product of input tensors A * B.</dd>
+<dt><tt>beta</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for input tensor C.</dd>
+<dt><tt>transA</tt> : int (default is 0)</dt>
+<dd>Whether A should be transposed</dd>
+<dt><tt>transB</tt> : int (default is 0)</dt>
+<dd>Whether B should be transposed</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>A</tt> : T</dt>
+<dd>Input tensor A. The shape of A should be (M, K) if transA is 0, or (K, M) if transA is non-zero.</dd>
+<dt><tt>B</tt> : T</dt>
+<dd>Input tensor B. The shape of B should be (K, N) if transB is 0, or (N, K) if transB is non-zero.</dd>
+<dt><tt>C</tt> (optional) : T</dt>
+<dd>Optional input tensor C. If not specified, the computation is done as if C is a scalar 0. The shape of C should be unidirectional broadcastable to (M, N).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output tensor of shape (M, N).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+### <a name="Hardmax-11"></a>**Hardmax-11**</a>
+
+  The operator computes the hardmax (1 for the first maximum value, and 0 for all others) values for each layer in the batch
+   of the given input.
+
+  The input does not need to explicitly be a 2D vector; rather, it will be
+  coerced into one. For an arbitrary n-dimensional tensor
+  input \in [a_0, a_1, ..., a_{k-1}, a_k, ..., a_{n-1}] and k is
+  the axis provided, then input will be coerced into a 2-dimensional tensor with
+  dimensions [a_0 * ... * a_{k-1}, a_k * ... * a_{n-1}]. For the default
+  case where axis=1, this means the input tensor will be coerced into a 2D tensor
+  of dimensions [a_0, a_1 * ... * a_{n-1}], where a_0 is often the batch size.
+  In this situation, we must have a_0 = N and a_1 * ... * a_{n-1} = D.
+  Each of these dimensions must be matched correctly, or else the operator
+  will throw errors. The output tensor has the same shape
+  and contains the hardmax values of the corresponding input.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Describes the axis of the inputs when coerced to 2D; defaults to one because the 0th axis most likely describes the batch_size. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The input tensor that's coerced into a 2D matrix of size (NxD) as described above.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output values with the same shape as input tensor (the original size without coercion).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="If-11"></a>**If-11**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same data type. The `then_branch` and `else_branch` may produce tensors with the same element type and different shapes. If corresponding outputs from the then-branch and the else-branch have static shapes S1 and S2, then the shape of the corresponding output variable of the if-node (if present) must be compatible with both S1 and S2 as it represents the union of both possible shapes.For example, if in a model file, the first output of `then_branch` is typed float tensor with shape [2] and the first output of `else_branch` is another float tensor with shape [3], If's first output should have (a) no shape set, or (b) a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) a shape of rank 1 with a unique `dim_param`. In contrast, the first output cannot have the shape [2] since [2] and [3] are not compatible.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>All Tensor types</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+### <a name="LogSoftmax-11"></a>**LogSoftmax-11**</a>
+
+  The operator computes the logsoftmax (log of softmax) values for each layer in the batch
+   of the given input.
+
+  The input does not need to explicitly be a 2D vector; rather, it will be
+  coerced into one. For an arbitrary n-dimensional tensor
+  input \in [a_0, a_1, ..., a_{k-1}, a_k, ..., a_{n-1}] and k is
+  the axis provided, then input will be coerced into a 2-dimensional tensor with
+  dimensions [a_0 * ... * a_{k-1}, a_k * ... * a_{n-1}]. For the default
+  case where axis=1, this means the input tensor will be coerced into a 2D tensor
+  of dimensions [a_0, a_1 * ... * a_{n-1}], where a_0 is often the batch size.
+  In this situation, we must have a_0 = N and a_1 * ... * a_{n-1} = D.
+  Each of these dimensions must be matched correctly, or else the operator
+  will throw errors. The output tensor has the same shape
+  and contains the logsoftmax values of the corresponding input.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Describes the axis of the inputs when coerced to 2D; defaults to one because the 0th axis most likely describes the batch_size. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The input tensor that's coerced into a 2D matrix of size (NxD) as described above.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output values with the same shape as input tensor (the original size without coercion).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Loop-11"></a>**Loop-11**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+      input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+      input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+      input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+      input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+      input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]           // iteration number
+        %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+        %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+      ) {
+        %my_local = Add(%a, %b_in)
+        %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+        %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+        %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+        return %keepgoing_out, %b_out, %user_defined_val
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        /* initialize loop-carried variables and scan-output variables */
+        bool keepgoing_out = keepgoing
+        int b_out = b
+
+        for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+          /* Implicitly-defined code: bind actual parameter values
+             to formal parameter variables of loop-body */
+          bool keepgoing_in = keepgoing_out;
+          bool b_in = b_out;
+
+          /* User-defined code (loop body) */
+          int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+          b_out = a - b_in;
+          keepgoing_out = my_local > b_out;
+          user_defined_val = b_in + b_in; // b_in and b_out are different variables
+          /* End user-defined code */
+
+          /* Implicitly defined-code */
+          user_defined_vals[i] = user_defined_val // accumulate scan-output values
+        }
+        // int t = my_local; // Can't do this. my_local is not accessible here.
+
+        // The values below are bound to the output variables of the loop and therefore accessible
+        // b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any values computed in the loop body that needs to be used in a subsequent
+     iteration or after the loop are modeled using a pair of variables in the loop-body,
+     consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+     These are referred to as loop-carried dependences. The loop operation node
+     supplies the input value of the input variable for the first iteration, and
+     returns the output value of the output variable produced by the final
+     iteration.
+  3) Scan_output variables are used to implicitly concatenate values computed across
+     all the iterations. In the above example, the value of user_defined_val computed
+     over all iterations are concatenated and returned as the value of user_defined_vals
+     after the loop.
+  4) Values created in the body cannot be accessed in the enclosing scope,
+     except using the mechanism described above.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>All Tensor types</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+### <a name="LpPool-11"></a>**LpPool-11**</a>
+
+  LpPool consumes an input tensor X and applies Lp pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   Lp pooling consisting of computing the Lp norm on all values of a subset
+   of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>p value of the Lp norm used to pool over the input data.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="MaxPool-11"></a>**MaxPool-11**</a>
+
+  MaxPool consumes an input tensor X and applies max pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   max pooling consisting of computing the max on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled
+
+   ```
+   * pad_shape[i] is sum of pads along axis i
+   ```
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
+   ```
+   The output of each pooling window is maximum number of elements exclude pad.
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input.In case of odd number add the extra padding at the end for SAME_UPPER and at the beginning for SAME_LOWER. VALID mean no padding.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>storage_order</tt> : int (default is 0)</dt>
+<dd>The storage order of the tensor. 0 is row major, and 1 is column major.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+<dt><tt>Indices</tt> (optional) : I</dt>
+<dd>Indices tensor from max pooling across the input tensor. The dimensions of indices are the same as output tensor. The values in indices of are the indices of the selected values during pooling. The indices are computed as flatten 1-D tensor, and the indices do not consider padding. So the values in indices are in [0, N x C x D1 x ... x Dn).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="MaxUnpool-11"></a>**MaxUnpool-11**</a>
+
+  MaxUnpool essentially computes the partial inverse of the MaxPool op.
+   The input information to this op is typically the output information from a MaxPool op. The first
+   input tensor X is the tensor that needs to be unpooled, which is typically the pooled tensor (first output)
+   from MaxPool. The second input tensor, I, contains the indices to the (locally maximal) elements corresponding
+   to the elements in the first input tensor X. Input tensor I is typically the second output of the MaxPool op.
+   The third (optional) input is a tensor that specifies the output size of the unpooling operation.
+
+  MaxUnpool is intended to do 'partial' inverse of the MaxPool op. 'Partial' because all the non-maximal
+   values from the original input to MaxPool are set to zero in the output of the MaxUnpool op. Pooling
+   the result of an unpooling operation should give back the original input to the unpooling op.
+
+  MaxUnpool can produce the same output size for several input sizes, which makes unpooling op ambiguous.
+   The third input argument, output_size, is meant to disambiguate the op and produce output tensor of
+   known/predictable size.
+
+  In addition to the inputs, MaxUnpool takes three attributes, namely kernel_shape, strides, and pads,
+   which define the exact unpooling op. The attributes typically have the same values as the corresponding
+   pooling op that the unpooling op is trying to invert.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>Input data tensor that has to be unpooled. This tensor is typically the first output of the MaxPool op.Dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non-image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>I</tt> (non-differentiable) : T2</dt>
+<dd>Input data tensor containing the indices corresponding to elements in the first input tensor X.This tensor is typically the second output of the MaxPool op.Dimensions must be the same as input tensor X. The indices are linear, i.e. computed considering the tensor as flattened 1-D tensor, assuming row-major storage. Also, the linear indices should not consider padding. So the values in indices are in the range [0, N x C x D1 x ... x Dn).</dd>
+<dt><tt>output_shape</tt> (optional, non-differentiable) : T2</dt>
+<dd>The shape of the output can be explicitly set which will cause pads values to be auto generated. If 'output_shape' is specified, 'pads' values are ignored.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T1</dt>
+<dd>Output data tensor that contains the result of the unpooling.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="NonMaxSuppression-11"></a>**NonMaxSuppression-11**</a>
+
+  Filter out boxes that have high intersection-over-union (IOU) overlap with previously selected boxes.
+  Bounding boxes with score less than score_threshold are removed. Bounding box format is indicated by attribute center_point_box.
+  Boxes are suppressed if their IOU with a previously selected box is strictly greater than iou_threshold (i.e., boxes with IOU exactly equal to the threshold are kept).
+  Note that this algorithm is agnostic to where the origin is in the coordinate system and more generally is invariant to
+  orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system
+  result in the same boxes being selected by the algorithm.
+  The selected_indices output is a set of integers indexing into the input collection of bounding boxes representing the selected boxes.
+  The bounding box coordinates corresponding to the selected indices can then be obtained using the Gather or GatherND operation.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>center_point_box</tt> : int (default is 0)</dt>
+<dd>Integer indicate the format of the box data. The default is 0. 0 - the box data is supplied as [y1, x1, y2, x2] where (y1, x1) and (y2, x2) are the coordinates of any diagonal pair of box corners and the coordinates can be provided as normalized (i.e., lying in the interval [0, 1]) or absolute. Mostly used for TF models. 1 - the box data is supplied as [x_center, y_center, width, height]. Mostly used for Pytorch models.</dd>
+</dl>
+
+#### Inputs (2 - 5)
+
+<dl>
+<dt><tt>boxes</tt> : tensor(float)</dt>
+<dd>An input tensor with shape [num_batches, spatial_dimension, 4]. The single box data format is indicated by center_point_box.</dd>
+<dt><tt>scores</tt> : tensor(float)</dt>
+<dd>An input tensor with shape [num_batches, num_classes, spatial_dimension]</dd>
+<dt><tt>max_output_boxes_per_class</tt> (optional) : tensor(int64)</dt>
+<dd>Integer representing the maximum number of boxes to be selected per batch per class. It is a scalar. Default to 0, which means no output.</dd>
+<dt><tt>iou_threshold</tt> (optional) : tensor(float)</dt>
+<dd>Float representing the threshold for deciding whether boxes overlap too much with respect to IOU. Boxes with IoU strictly greater than this threshold are suppressed. It is scalar. Value range [0, 1]. Default to 0.</dd>
+<dt><tt>score_threshold</tt> (optional) : tensor(float)</dt>
+<dd>Float representing the threshold for deciding when to remove boxes based on score. It is a scalar.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>selected_indices</tt> : tensor(int64)</dt>
+<dd>selected indices from the boxes tensor. [num_selected_indices, 3], the selected index format is [batch_index, class_index, box_index].</dd>
+</dl>
+
+#### Type Constraints
+
+
+### <a name="OneHot-11"></a>**OneHot-11**</a>
+
+  Produces a one-hot tensor based on inputs.
+      The locations represented by the index values in the 'indices' input tensor will have 'on_value'
+      and the other locations will have 'off_value' in the output tensor, where 'on_value' and 'off_value'
+      are specified as part of required input argument 'values', which is a two-element tensor of format
+      [off_value, on_value]. The rank of the output tensor will be one greater than the rank of the
+      input tensor. The additional dimension is for one-hot representation. The additional dimension will
+      be inserted at the position specified by 'axis'. If 'axis' is not specified then then additional
+      dimension will be inserted as the innermost dimension, i.e. axis=-1. The size of the additional
+      dimension is specified by required scalar input 'depth'. The type of the output tensor is the same
+      as the type of the 'values' input. Any entries in the 'indices' input tensor with values outside
+      the range [-depth, depth-1] will result in one-hot representation with all 'off_value' values in the
+      output tensor.
+
+      when axis = 0:
+      output[input[i, j, k], i, j, k] = 1 for all i, j, k and 0 otherwise.
+
+      when axis = -1:
+      output[i, j, k, input[i, j, k]] = 1 for all i, j, k and 0 otherwise.
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>(Optional) Axis along which one-hot representation in added. Default: axis=-1. axis=-1 means that the additional dimension will be inserted as the innermost/last dimension in the output tensor. Negative value means counting dimensions from the back. Accepted range is [-r-1, r] where r = rank(indices).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>indices</tt> (non-differentiable) : T1</dt>
+<dd>Input tensor containing indices. Any entries in the 'indices' input tensor with values outside the range [-depth, depth-1] will result in one-hot representation with all 'off_value' values in the output tensor.In case 'indices' is of non-integer type, the values will be casted to int64 before use.</dd>
+<dt><tt>depth</tt> (non-differentiable) : T2</dt>
+<dd>Scalar or Rank 1 tensor containing exactly one element, specifying the number of classes in one-hot tensor. This is also the size of the one-hot dimension (specified by 'axis' attribute) added on in the output tensor. The values in the 'indices' input tensor are expected to be in the range [-depth, depth-1]. In case 'depth' is of non-integer type, it will be casted to int64 before use.</dd>
+<dt><tt>values</tt> (non-differentiable) : T3</dt>
+<dd>Rank 1 tensor containing exactly two elements, in the format [off_value, on_value], where 'on_value' is the value used for filling locations specified in 'indices' input tensor, and 'off_value' is the value used for filling locations other than those specified in 'indices' input tensor. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T3</dt>
+<dd>Tensor of rank one greater than input tensor 'indices', i.e. rank(output) = rank(indices) + 1. The data type for the elements of the output tensor is the same as the type of input 'values' is used.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to only numeric types.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to only numeric types.</dd>
+<dt><tt>T3</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type.</dd>
+</dl>
+
+### <a name="Pad-11"></a>**Pad-11**</a>
+
+  Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+  a padded tensor (`output`) is generated.
+
+  The three supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+  1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0)
+
+  2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+  3) `edge` - pads with the edge values of array
+
+
+  Example 1 (`constant` mode):
+    Insert 0 pads to the beginning of the second dimension.
+
+    data =
+    [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+
+    pads = [0, 2, 0, 0]
+
+    mode = 'constant'
+
+    constant_value = 0.0
+
+    output =
+    [
+        [0.0, 0.0, 1.0, 1.2],
+        [0.0, 0.0, 2.3, 3.4],
+        [0.0, 0.0, 4.5, 5.7],
+    ]
+
+
+  Example 2 (`reflect` mode):
+    data =
+    [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+
+    pads = [0, 2, 0, 0]
+
+    mode = 'reflect'
+
+    output =
+    [
+        [1.0, 1.2, 1.0, 1.2],
+        [2.3, 3.4, 2.3, 3.4],
+        [4.5, 5.7, 4.5, 5.7],
+    ]
+
+
+  Example 3 (`edge` mode):
+    data =
+    [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+
+    pads = [0, 2, 0, 0]
+
+    mode = 'edge'
+
+    output =
+    [
+        [1.0, 1.0, 1.0, 1.2],
+        [2.3, 2.3, 2.3, 3.4],
+        [4.5, 4.5, 4.5, 5.7],
+    ]
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Supported modes: `constant`(default), `reflect`, `edge`</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Input tensor.</dd>
+<dt><tt>pads</tt> : tensor(int64)</dt>
+<dd>Tensor of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. `pads` should be a 1D tensor of shape [2 * input_rank]. `pads` format should be: [x1_begin, x2_begin,...,x1_end, x2_end,...], where xi_begin is the number of pad values added at the beginning of axis `i` and xi_end, the number of pad values added at the end of axis `i`.</dd>
+<dt><tt>constant_value</tt> (optional) : T</dt>
+<dd>(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output to only numeric types.</dd>
+</dl>
+
+### <a name="Range-11"></a>**Range-11**</a>
+
+  Generate a tensor containing a sequence of numbers that begin at `start` and extends by increments of `delta`
+  up to `limit` (exclusive).
+
+  The number of elements in the output of range is computed as below:
+  ```
+  number_of_elements = max( ceil( (limit - start) / delta ) , 0 )
+  ```
+  The pseudocode determining the contents of the output is shown below:
+  ```
+  for(int i=0; i<number_of_elements; ++i) {
+    output[i] =  start + (i * delta);
+  }
+  ```
+  Example 1:
+  ```
+  Inputs: start = 3, limit = 9, delta = 3
+  Output: [3, 6]
+  ```
+  Example 2:
+  ```
+  Inputs: start = 10, limit = 4, delta = -2
+  Output: [10, 8, 6]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>start</tt> : T</dt>
+<dd>Scalar. First entry for the range of output values.</dd>
+<dt><tt>limit</tt> : T</dt>
+<dd>Scalar. Exclusive upper limit for the range of output values.</dd>
+<dt><tt>delta</tt> : T</dt>
+<dd>Scalar. Value to step by.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>A 1-D tensor with same type as the inputs containing generated range of values.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int16), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input types to common numeric type tensors.</dd>
+</dl>
+
+### <a name="ReduceL1-11"></a>**ReduceL1-11**</a>
+
+  Computes the L1 norm of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceL2-11"></a>**ReduceL2-11**</a>
+
+  Computes the L2 norm of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceLogSum-11"></a>**ReduceLogSum-11**</a>
+
+  Computes the log sum of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceLogSumExp-11"></a>**ReduceLogSumExp-11**</a>
+
+  Computes the log sum exponent of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMax-11"></a>**ReduceMax-11**</a>
+
+  Computes the max of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or the minimum value of the data type otherwise.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMean-11"></a>**ReduceMean-11**</a>
+
+  Computes the mean of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMin-11"></a>**ReduceMin-11**</a>
+
+  Computes the min of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields plus infinity (if supported by the datatype) or the maximum value of the data type otherwise.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceProd-11"></a>**ReduceProd-11**</a>
+
+  Computes the product of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceSum-11"></a>**ReduceSum-11**</a>
+
+  Computes the sum of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceSumSquare-11"></a>**ReduceSumSquare-11**</a>
+
+  Computes the sum square of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Resize-11"></a>**Resize-11**</a>
+
+  Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
+  Each dimension value of the output tensor is:
+    output_dimension = floor(input_dimension * (roi_end - roi_start) * scale) if input \"sizes\" is not specified.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>coordinate_transformation_mode</tt> : string (default is half_pixel)</dt>
+<dd>
+This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. <br/>
+
+The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
+Denote x_resized as the coordinate of axis x in the resized tensor, x_original as the coordinate of axis x in the original tensor, length_original as the length of the original tensor in axis x, length_resized as the length of the resized tensor in axis x, roi_x = (start_x, end_x) of the axis x in input "roi", scale = length_resized / length_original, <br/>
+
+if coordinate_transformation_mode is "half_pixel", <br/>
+x_original = (x_resized + 0.5) / scale - 0.5, <br/>
+
+if coordinate_transformation_mode is "pytorch_half_pixel", <br/>
+x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0, <br/>
+
+if coordinate_transformation_mode is "align_corners", <br/>
+x_original = x_resized * (length_original - 1) / (length_resized - 1), <br/>
+
+if coordinate_transformation_mode is "asymmetric", <br/>
+x_original = x_resized / scale, <br/>
+
+if coordinate_transformation_mode is "tf_half_pixel_for_nn", <br/>
+x_original = (x_resized + 0.5) / scale, <br/>
+
+if coordinate_transformation_mode is "tf_crop_and_resize", <br/>
+x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1).</dd>
+<dt><tt>cubic_coeff_a</tt> : float (default is -0.75)</dt>
+<dd>The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75 (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. This attribute is valid only if "mode" is "cubic".</dd>
+<dt><tt>exclude_outside</tt> : int (default is 0)</dt>
+<dd>If set to 1, the weight of sampling locations outside the tensor will be set to 0 and the weight will be renormalized so that their sum is 1.0. The default value is 0.</dd>
+<dt><tt>extrapolation_value</tt> : float (default is 0.0)</dt>
+<dd>When coordinate_transformation_mode is "tf_crop_and_resize" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f.</dd>
+<dt><tt>mode</tt> : string (default is nearest)</dt>
+<dd>Three interpolation modes: nearest (default), linear and cubic. The "linear" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). The "cubic" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor).</dd>
+<dt><tt>nearest_mode</tt> : string (default is round_prefer_floor)</dt>
+<dd>Four modes: round_prefer_floor (default, as known as round half down), round_prefer_ceil (as known as round half up), floor, ceil. Only used by nearest interpolation. It indicates how to get "nearest" pixel in input tensor from x_original, so this attribute is valid only if "mode" is "nearest".</dd>
+</dl>
+
+#### Inputs (3 - 4)
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>N-D tensor</dd>
+<dt><tt>roi</tt> : T2</dt>
+<dd>1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is "tf_crop_and_resize"</dd>
+<dt><tt>scales</tt> : tensor(float)</dt>
+<dd>The scale array along each dimension. It takes value greater than 0. If it's less than 1, it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should be the same as the rank of input 'X'. If 'size' is needed, the user must set 'scales' to an empty tensor.</dd>
+<dt><tt>sizes</tt> (optional) : tensor(int64)</dt>
+<dd>The size of the output tensor. The number of elements of 'sizes' should be the same as the rank of input 'X'. May only be set if 'scales' is set to an empty tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>N-D tensor after resizing</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input 'X' and output 'Y' to all tensor types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain roi type to float or double.</dd>
+</dl>
+
+### <a name="Round-11"></a>**Round-11**</a>
+
+  Round takes one input Tensor and rounds the values, element-wise, meaning
+  it finds the nearest integer for each value.
+  In case of halves, the rule is to round them to the nearest even integer.
+  If input x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+  The output tensor has the same shape and type as the input.
+
+  Examples:
+  ```
+  round([0.9]) = [1.0]
+  round([2.5]) = [2.0]
+  round([2.3]) = [2.0]
+  round([1.5]) = [2.0]
+  round([-4.5]) = [-4.0]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Scan-11"></a>**Scan-11**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops).
+  Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+  well as scan_output_element tensors) are required to have the same shape in each iteration
+  of the loop (a restriction imposed to enable efficient memory allocation).
+
+  Note that the iterated element passed to the body subgraph does not have a sequence
+  axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The optional attribute scan_input_directions specifies the direction (forward or backward)
+  for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+  direction. A bidirectional scan may be performed by specifying the same tensor input twice
+  in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+  The scan_output of the operation is produced by concatenating the scan_output_element
+  values produced by the body in each iteration.  The optional attribute scan_output_directions
+  specifies the direction in which scan_output is constructed (by appending or prepending the
+  scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+  is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+  The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+  If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+  batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+  Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+  The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+  are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+  scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+  value of 1.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body,
+          scan_input_axes = [axis_1, ..., axis_m]
+      > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+      sequence_length = scan_1.shape[axis_1];
+
+      // initialize state-variables
+      st_1 = init_1; ... st_n = init_n;
+      // initialize scan-output variables: [] denotes an empty tensor
+      scan_out_1 = []; ...; scan_out_k = [];
+      // identify number of iterations:
+
+      // execute loop
+      for (int t = 0; t < sequence_length; ++t) {
+          // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+          // of rank one less than T obtained by indexing T at position t along axis k.
+          si_1 = scan_1<axis=axis_1>[t];
+          ... ;
+          si_m = scan_m<axis=axis_m>[t];
+          // execute loop-body
+          st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+          // accumulate the scan-output elements
+          scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+      }
+
+      return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+<dt><tt>scan_input_axes</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the axis to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will be used as the scan axis for every scan_input. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>scan_input_directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>scan_output_axes</tt> : list of ints</dt>
+<dd>An optional list of K flags. The i-th element of the list specifies the axis for the i-th scan_output. The scan outputs are accumulated along the specified axis. If omitted, 0 will be used as the scan axis for every scan_output. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1].</dd>
+<dt><tt>scan_output_directions</tt> : list of ints</dt>
+<dd>An optional list of K flags, one for each scan_output. The i-th element of the list specifies whether the i-th scan_output should be constructed by appending or prepending a new value in each iteration: 0 indicates appending and 1 indicates prepending. If omitted, all scan_output tensors will be produced by appending a value in each iteration.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>All Tensor types</dd>
+</dl>
+
+### <a name="Scatter-11"></a>**Scatter-11** (deprecated)</a>
+
+  This operator is deprecated. Please use ScatterElements, which provides the same functionality.
+
+  Scatter takes three inputs `data`, `updates`, and `indices` of the same
+  rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value
+  to values specified by `updates` at specific index positions specified by
+  `indices`. Its output shape is the same as the shape of `data`.
+
+  For each entry in `updates`, the target index in `data` is obtained by combining
+  the corresponding entry in `indices` with the index of the entry itself: the
+  index-value for dimension = axis is obtained from the value of the corresponding
+  entry in `indices` and the index-value for dimension != axis is obtained from the
+  index of the entry itself.
+
+  For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
+  is performed as below:
+  ```
+    output[indices[i][j]][j] = updates[i][j] if axis = 0,
+    output[i][indices[i][j]] = updates[i][j] if axis = 1,
+  ```
+
+  This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+
+  Example 1:
+  ```
+    data = [
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+    ]
+    indices = [
+        [1, 0, 2],
+        [0, 2, 1],
+    ]
+    updates = [
+        [1.0, 1.1, 1.2],
+        [2.0, 2.1, 2.2],
+    ]
+    output = [
+        [2.0, 1.1, 0.0]
+        [1.0, 0.0, 2.2]
+        [0.0, 2.1, 1.2]
+    ]
+  ```
+  Example 2:
+  ```
+    data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+    indices = [[1, 3]]
+    updates = [[1.1, 2.1]]
+    axis = 1
+    output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+  ```
+
+#### Version
+
+This version of the operator has been deprecated since version 11 of the default ONNX operator set.
+
+### <a name="ScatterElements-11"></a>**ScatterElements-11**</a>
+
+  ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
+  rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value
+  to values specified by `updates` at specific index positions specified by
+  `indices`. Its output shape is the same as the shape of `data`.
+
+  For each entry in `updates`, the target index in `data` is obtained by combining
+  the corresponding entry in `indices` with the index of the entry itself: the
+  index-value for dimension = axis is obtained from the value of the corresponding
+  entry in `indices` and the index-value for dimension != axis is obtained from the
+  index of the entry itself.
+
+  For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
+  is performed as below:
+  ```
+    output[indices[i][j]][j] = updates[i][j] if axis = 0,
+    output[i][indices[i][j]] = updates[i][j] if axis = 1,
+  ```
+
+  This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+
+  Example 1:
+  ```
+    data = [
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+    ]
+    indices = [
+        [1, 0, 2],
+        [0, 2, 1],
+    ]
+    updates = [
+        [1.0, 1.1, 1.2],
+        [2.0, 2.1, 2.2],
+    ]
+    output = [
+        [2.0, 1.1, 0.0]
+        [1.0, 0.0, 2.2]
+        [0.0, 2.1, 1.2]
+    ]
+  ```
+  Example 2:
+  ```
+    data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+    indices = [[1, 3]]
+    updates = [[1.1, 2.1]]
+    axis = 1
+    output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> : Tind</dt>
+<dd>Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+<dt><tt>updates</tt> : T</dt>
+<dd>Tensor of rank r >=1 (same rank and shape as indices)</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor of rank r >= 1 (same rank as input).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input and output types can be of any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="ScatterND-11"></a>**ScatterND-11**</a>
+
+  ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
+  and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value to values
+  specified by `updates` at specific index positions specified by `indices`. Its output shape
+  is the same as the shape of `data`. Note that `indices` should not have duplicate entries.
+  That is, two or more `updates` for the same index-location is not supported.
+
+  `indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
+   `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
+  Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
+  update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
+  update to a slice of the tensor. Index values are allowed to be negative, as per the usual
+  convention for counting backwards from the end, but are expected in the valid range.
+
+  `updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
+  first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
+  The remaining dimensions of `updates` correspond to the dimensions of the
+  replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
+  corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
+  must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
+  of shapes.
+
+  The `output` is calculated via the following equation:
+
+      output = np.copy(data)
+      update_indices = indices.shape[:-1]
+      for idx in np.ndindex(update_indices):
+          output[tuple(indices[idx])] = updates[idx]
+
+  The order of iteration in the above loop is not specified.
+  In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
+  This ensures that the output value does not depend on the iteration order.
+
+  This operator is the inverse of GatherND.
+
+  Example 1:
+  ```
+    data    = [1, 2, 3, 4, 5, 6, 7, 8]
+    indices = [[4], [3], [1], [7]]
+    updates = [9, 10, 11, 12]
+    output  = [1, 11, 3, 10, 9, 6, 7, 12]
+  ```
+
+  Example 2:
+  ```
+    data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+               [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+               [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+               [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+    indices = [[0], [2]]
+    updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+               [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
+    output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+               [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+               [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+               [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> : tensor(int64)</dt>
+<dd>Tensor of rank q >= 1.</dd>
+<dt><tt>updates</tt> : T</dt>
+<dd>Tensor of rank q + r - indices_shape[-1] - 1.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+### <a name="SequenceAt-11"></a>**SequenceAt-11**</a>
+
+  Outputs a tensor copy from the tensor at 'position' in 'input_sequence'.
+  Accepted range for 'position' is in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'.
+  Negative value means counting positions from the back.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+<dt><tt>position</tt> : I</dt>
+<dd>Position of the tensor in the sequence. Negative value means counting positions from the back. Accepted range in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'. It is an error if any of the index values are out of bounds. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>tensor</tt> : T</dt>
+<dd>Output tensor at the specified position in the input sequence.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>I</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain position to integral tensor. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+### <a name="SequenceConstruct-11"></a>**SequenceConstruct-11**</a>
+
+  Construct a tensor sequence containing 'inputs' tensors.
+  All tensors in 'inputs' must have the same data type.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>inputs</tt> (variadic) : T</dt>
+<dd>Tensors.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_sequence</tt> : S</dt>
+<dd>Sequence enclosing the input tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input types to any tensor type.</dd>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+### <a name="SequenceEmpty-11"></a>**SequenceEmpty-11**</a>
+
+  Construct an empty tensor sequence, with given data type.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type of the tensors in the output sequence. The default type is 'float'.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : S</dt>
+<dd>Empty sequence.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+### <a name="SequenceErase-11"></a>**SequenceErase-11**</a>
+
+  Outputs a tensor sequence that removes the tensor at 'position' from 'input_sequence'.
+  Accepted range for 'position' is in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'.
+  Negative value means counting positions from the back.
+  'position' is optional, by default it erases the last tensor from 'input_sequence'.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+<dt><tt>position</tt> (optional) : I</dt>
+<dd>Position of the tensor in the sequence. Negative value means counting positions from the back. Accepted range in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'. It is an error if any of the index values are out of bounds. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_sequence</tt> : S</dt>
+<dd>Output sequence that has the tensor at the specified position removed.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>I</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain position to integral tensor. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+### <a name="SequenceInsert-11"></a>**SequenceInsert-11**</a>
+
+  Outputs a tensor sequence that inserts 'tensor' into 'input_sequence' at 'position'.
+  'tensor' must have the same data type as 'input_sequence'.
+  Accepted range for 'position' is in `[-n, n]`, where `n` is the number of tensors in 'input_sequence'.
+  Negative value means counting positions from the back.
+  'position' is optional, by default it inserts 'tensor' to the back of 'input_sequence'.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+<dt><tt>tensor</tt> : T</dt>
+<dd>Input tensor to be inserted into the input sequence.</dd>
+<dt><tt>position</tt> (optional) : I</dt>
+<dd>Position in the sequence where the new tensor is inserted. It is optional and default is to insert to the back of the sequence. Negative value means counting positions from the back. Accepted range in `[-n, n]`, where `n` is the number of tensors in 'input_sequence'. It is an error if any of the index values are out of bounds. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_sequence</tt> : S</dt>
+<dd>Output sequence that contains the inserted tensor at given position.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>I</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain position to integral tensor. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+### <a name="SequenceLength-11"></a>**SequenceLength-11**</a>
+
+  Produces a scalar(tensor of empty shape) containing the number of tensors in 'input_sequence'.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>length</tt> : I</dt>
+<dd>Length of input sequence. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain output to integral tensor. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+### <a name="Slice-11"></a>**Slice-11**</a>
+
+  Produces a slice of the input tensor along multiple axes. Similar to numpy:
+  https://numpy.org/doc/stable/reference/routines.indexing.html
+  Slices uses `starts`, `ends`, `axes` and `steps` inputs to specify the start and end
+  dimension and step for each axis in the list of axes, it uses this information to
+  slice the input `data` tensor. If a negative value is passed for any of the
+  start or end indices, it represents number of elements before the end of that
+  dimension. If the value passed to start or end is larger than the `n` (the
+  number of elements in this dimension), it represents `n`. For slicing to the
+  end of a dimension with unknown size, it is recommended to pass in `INT_MAX`
+  when slicing forward and 'INT_MIN' when slicing backward.
+  If a negative value is passed for step, it represents slicing backward.
+  However step value cannot be 0.
+  If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
+  If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
+  Example 1:
+    data = [
+        [1, 2, 3, 4],
+        [5, 6, 7, 8],
+    ]
+    axes = [0, 1]
+    starts = [1, 0]
+    ends = [2, 3]
+    steps = [1, 2]
+    result = [
+        [5, 7],
+    ]
+  Example 2:
+    data = [
+        [1, 2, 3, 4],
+        [5, 6, 7, 8],
+    ]
+    starts = [0, 1]
+    ends = [-1, 1000]
+    result = [
+        [2, 3, 4],
+    ]
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs (3 - 5)
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of data to extract slices from.</dd>
+<dt><tt>starts</tt> : Tind</dt>
+<dd>1-D tensor of starting indices of corresponding axis in `axes`</dd>
+<dt><tt>ends</tt> : Tind</dt>
+<dd>1-D tensor of ending indices (exclusive) of corresponding axis in `axes`</dd>
+<dt><tt>axes</tt> (optional) : Tind</dt>
+<dd>1-D tensor of axes that `starts` and `ends` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>steps</tt> (optional) : Tind</dt>
+<dd>1-D tensor of slice step of corresponding axis in `axes`. Negative value means slicing backward. 'steps' cannot be 0. Defaults to 1.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Sliced data tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="Softmax-11"></a>**Softmax-11**</a>
+
+  The operator computes the softmax (normalized exponential) values for each layer in the batch
+   of the given input.
+
+  The input does not need to explicitly be a 2D vector; rather, it will be
+  coerced into one. For an arbitrary n-dimensional tensor
+  input \in [a_0, a_1, ..., a_{k-1}, a_k, ..., a_{n-1}] and k is
+  the axis provided, then input will be coerced into a 2-dimensional tensor with
+  dimensions [a_0 * ... * a_{k-1}, a_k * ... * a_{n-1}]. For the default
+  case where axis=1, this means the input tensor will be coerced into a 2D tensor
+  of dimensions [a_0, a_1 * ... * a_{n-1}], where a_0 is often the batch size.
+  In this situation, we must have a_0 = N and a_1 * ... * a_{n-1} = D.
+  Each of these dimensions must be matched correctly, or else the operator
+  will throw errors. The output tensor has the same shape
+  and contains the softmax values of the corresponding input.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Describes the axis of the inputs when coerced to 2D; defaults to one because the 0th axis most likely describes the batch_size. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The input tensor that's coerced into a 2D matrix of size (NxD) as described above.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output values with the same shape as input tensor (the original size without coercion).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Split-11"></a>**Split-11**</a>
+
+  Split a tensor into a list of tensors, along the specified
+  'axis'. Lengths of the parts can be specified using argument 'split'.
+  Otherwise, the tensor is split to equal sized parts.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to split on. A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] where r = rank(input).</dd>
+<dt><tt>split</tt> : list of ints</dt>
+<dd>length of each output. Values should be >= 0.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The tensor to split</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic) : T</dt>
+<dd>One or more outputs forming list of tensors after splitting</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="SplitToSequence-11"></a>**SplitToSequence-11**</a>
+
+  Split a tensor into a sequence of tensors, along the specified 'axis'.
+  Lengths of the parts can be specified using the optional argument 'split'.
+  If the argument `split' is not specified, a default scalar value of 1
+  is used as the value of `split'.
+  'split' must contain only positive numbers.
+  'split' is either a scalar (tensor of empty shape), or a 1-D tensor.
+  If 'split' is a scalar, then 'input' will be split into chunks all of size 'split'
+  if possible. The last chunk alone may be smaller than 'split' if the 'input' size
+  along the given axis 'axis' is not divisible by 'split'.
+  If 'split' is a 1-dimensional tensor, the input tensor is split into 'size(split)' chunks,
+  with lengths of the parts on 'axis' specified in 'split'. In this scenario, the sum of entries
+  in 'split' must be equal to the dimension size of input tensor on 'axis'.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to split on. A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1].</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the split dimension or not. Default 1, which means we keep split dimension. If input 'split' is specified, this attribute is ignored.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The tensor to split</dd>
+<dt><tt>split</tt> (optional) : I</dt>
+<dd>Length of each output. It can be either a scalar(tensor of empty shape), or a 1-D tensor. All values must be >= 0. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_sequence</tt> : S</dt>
+<dd>One or more outputs forming a sequence of tensors after splitting</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input types to all tensor types.</dd>
+<dt><tt>I</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain split size to integral tensor.</dd>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output types to all tensor types.</dd>
+</dl>
+
+### <a name="Squeeze-11"></a>**Squeeze-11**</a>
+
+  Remove single-dimensional entries from the shape of a tensor.
+  Takes a  parameter `axes` with a list of axes to squeeze.
+  If `axes` is not provided, all the single dimensions will be removed from
+  the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>List of integers indicating the dimensions to squeeze. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensors with at least max(dims) dimensions.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>squeezed</tt> : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="TopK-11"></a>**TopK-11**</a>
+
+  Retrieve the top-K largest or smallest elements along a specified axis. Given an input tensor of
+  shape [a_0, a_1, ..., a_{n-1}] and integer argument k, return two outputs:
+
+  * Value tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}]
+    which contains the values of the top k elements along the specified axis
+  * Index tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] which
+    contains the indices of the top k elements (original indices from the input
+    tensor).
+
+  * If "largest" is 1 (the default value) then the k largest elements are returned.
+  * If "sorted" is 1 (the default value) then the resulting k elements will be sorted.
+  * If "sorted" is 0, order of returned 'Values' and 'Indices' are undefined.
+
+  Given two equivalent values, this operator uses the indices along the axis as
+  a tiebreaker. That is, the element with the lower index will appear first.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>Dimension on which to do the sort. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>largest</tt> : int (default is 1)</dt>
+<dd>Whether to return the top-K largest or smallest elements.</dd>
+<dt><tt>sorted</tt> : int (default is 1)</dt>
+<dd>Whether to return the elements in sorted order.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{n-1}]</dd>
+<dt><tt>K</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D tensor containing a single positive value corresponding to the number of top elements to retrieve</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Values</tt> (differentiable) : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing top K values from the input tensor</dd>
+<dt><tt>Indices</tt> (non-differentiable) : I</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing the corresponding input tensor indices for the top K values.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="Unique-11"></a>**Unique-11**</a>
+
+  Find the unique elements of a tensor. When an optional attribute 'axis' is provided, unique subtensors sliced along the 'axis' are returned.
+  Otherwise the input tensor is flattened and unique values of the flattened tensor are returned.
+
+  This operator returns the unique values or sliced unique subtensors of the input tensor and three optional outputs.
+  The first output tensor 'Y' contains all unique values or subtensors of the input.
+  The second optional output tensor 'indices' contains indices of 'Y' elements' first occurrence in 'X'.
+  The third optional output tensor 'inverse_indices' contains, for elements of 'X', its corresponding indices in 'Y'.
+  The fourth optional output tensor 'counts' contains the count of each element of 'Y' in the input.
+
+  Outputs are either sorted in ascending order or optionally in the order of the first occurrence of the values in the input.
+
+  https://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
+
+  Example 1:
+  ```
+  input_X = [2, 1, 1, 3, 4, 3]
+  attribute_sorted = 0
+  attribute_axis = None
+  output_Y = [2, 1, 3, 4]
+  output_indices = [0, 1, 3, 4]
+  output_inverse_indices = [0, 1, 1, 2, 3, 2]
+  output_counts = [1, 2, 2, 1]
+  ```
+
+  Example 2:
+  ```
+  input_X = [[1, 3], [2, 3]]
+  attribute_sorted = 1
+  attribute_axis = None
+  output_Y = [1, 2, 3]
+  output_indices = [0, 2, 1]
+  output_inverse_indices = [0, 2, 1, 2]
+  output_counts = [1, 1, 2]
+  ```
+
+  Example 3:
+  ```
+  input_X = [[1, 0, 0], [1, 0, 0], [2, 3, 4]]
+  attribute_sorted = 1
+  attribute_axis = 0
+  output_Y = [[1, 0, 0], [2, 3, 4]]
+  output_indices = [0, 2]
+  output_inverse_indices = [0, 0, 1]
+  output_counts = [2, 1]
+  ```
+
+  Example 4:
+  ```
+  input_x = [[[1., 1.], [0., 1.], [2., 1.], [0., 1.]],
+              [[1., 1.], [0., 1.], [2., 1.], [0., 1.]]]
+  attribute_sorted = 1
+  attribute_axis = 1
+  ```
+
+  intermediate data are presented below for better understanding:
+  there are 4 subtensors sliced along axis 1 of input_x (shape = (2, 4, 2)):
+  ```
+  A: [[1, 1], [1, 1]],
+     [[0, 1], [0, 1]],
+     [[2, 1], [2, 1]],
+     [[0, 1], [0, 1]].
+  ```
+
+  there are 3 unique subtensors:
+  ```
+  [[1, 1], [1, 1]],
+  [[0, 1], [0, 1]],
+  [[2, 1], [2, 1]].
+  ```
+
+  sorted unique subtensors:
+  ```
+  B: [[0, 1], [0, 1]],
+     [[1, 1], [1, 1]],
+     [[2, 1], [2, 1]].
+  ```
+
+  output_Y is constructed from B:
+  ```
+  [[[0. 1.], [1. 1.], [2. 1.]],
+   [[0. 1.], [1. 1.], [2. 1.]]]
+  ```
+
+  output_indices is to map from B to A:
+  ```
+  [1, 0, 2]
+  ```
+
+  output_inverse_indices is to map from A to B:
+  ```
+  [1, 0, 2, 0]
+  ```
+
+  output_counts:
+  ```
+  [2, 1, 1]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>(Optional) The dimension to apply unique. If not specified, the unique elements of the flattened input are returned. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>sorted</tt> : int (default is 1)</dt>
+<dd>(Optional) Whether to sort the unique elements in ascending order before returning as output. Must be one of 0, or 1 (default).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>A N-D input tensor that is to be processed.</dd>
+</dl>
+
+#### Outputs (1 - 4)
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>A tensor of the same type as 'X' containing all the unique values or subtensors sliced along a provided 'axis' in 'X', either sorted or maintained in the same order they occur in input 'X'</dd>
+<dt><tt>indices</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D INT64 tensor containing indices of 'Y' elements' first occurrence in 'X'. When 'axis' is provided, it contains indices to subtensors in input 'X' on the 'axis'. When 'axis' is not provided, it contains indices to values in the flattened input tensor. </dd>
+<dt><tt>inverse_indices</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D INT64 tensor containing, for elements of 'X', its corresponding indices in 'Y'. When 'axis' is provided, it contains indices to subtensors in output 'Y' on the 'axis'. When 'axis' is not provided, it contains indices to values in output 'Y'. </dd>
+<dt><tt>counts</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D INT64 tensor containing the count of each element of 'Y' in input 'X'</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input can be of any tensor type.</dd>
+</dl>
+
+### <a name="Unsqueeze-11"></a>**Unsqueeze-11**</a>
+
+  Insert single-dimensional entries to the shape of an input tensor (`data`).
+  Takes one required argument `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).
+
+  For example:
+    Given an input tensor (`data`) of shape [3, 4, 5], then
+    Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].
+
+  The attribute `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
+  The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
+  Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
+  The order of values in `axes` does not matter and can come in any order.
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints (required)</dt>
+<dd>List of integers indicating the dimensions to be inserted. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(expanded).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Original tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>expanded</tt> : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+## Version 12 of the default ONNX operator set
+### <a name="ArgMax-12"></a>**ArgMax-12**</a>
+
+  Computes the indices of the max elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equal 0, then the resulting tensor has the reduced dimension pruned.
+  If select_last_index is True (default False), the index of the last occurrence of the max
+  is selected if the max appears more than once in the input. Otherwise the index of the
+  first occurrence is selected.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>select_last_index</tt> : int (default is 0)</dt>
+<dd>Whether to select the last index or the first index if the {name} appears in multiple indices, default is False (first index).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="ArgMin-12"></a>**ArgMin-12**</a>
+
+  Computes the indices of the min elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equal 0, then the resulting tensor has the reduced dimension pruned.
+  If select_last_index is True (default False), the index of the last occurrence of the min
+  is selected if the min appears more than once in the input. Otherwise the index of the
+  first occurrence is selected.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>select_last_index</tt> : int (default is 0)</dt>
+<dd>Whether to select the last index or the first index if the {name} appears in multiple indices, default is False (first index).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Celu-12"></a>**Celu-12**</a>
+
+  Continuously Differentiable Exponential Linear Units:
+  Perform the linear unit element-wise on the input tensor X
+  using formula:
+
+  ```
+  max(0,x) + min(0,alpha*(exp(x/alpha)-1))
+  ```
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>The Alpha value in Celu formula which control the shape of the unit. The default value is 1.0.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float)</dt>
+<dd>Constrain input and output types to float32 tensors.</dd>
+</dl>
+
+### <a name="Clip-12"></a>**Clip-12**</a>
+
+  Clip operator limits the given input within an interval. The interval is
+  specified by the inputs 'min' and 'max'. They default to
+  numeric_limits::lowest() and numeric_limits::max(), respectively.
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor whose elements to be clipped</dd>
+<dt><tt>min</tt> (optional) : T</dt>
+<dd>Minimum value, under which element is replaced by min. It must be a scalar(tensor of empty shape).</dd>
+<dt><tt>max</tt> (optional) : T</dt>
+<dd>Maximum value, above which element is replaced by max. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor with clipped input elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Constant-12"></a>**Constant-12**</a>
+
+  This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+  or value_* must be specified.
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>sparse_value</tt> : sparse_tensor</dt>
+<dd>The value for the elements of the output tensor in sparse format.</dd>
+<dt><tt>value</tt> : tensor</dt>
+<dd>The value for the elements of the output tensor.</dd>
+<dt><tt>value_float</tt> : float</dt>
+<dd>The value for the sole element for the scalar, float32, output tensor.</dd>
+<dt><tt>value_floats</tt> : list of floats</dt>
+<dd>The values for the elements for the 1D, float32, output tensor.</dd>
+<dt><tt>value_int</tt> : int</dt>
+<dd>The value for the sole element for the scalar, int64, output tensor.</dd>
+<dt><tt>value_ints</tt> : list of ints</dt>
+<dd>The values for the elements for the 1D, int64, output tensor.</dd>
+<dt><tt>value_string</tt> : string</dt>
+<dd>The value for the sole element for the scalar, UTF-8 string, output tensor.</dd>
+<dt><tt>value_strings</tt> : list of strings</dt>
+<dd>The values for the elements for the 1D, UTF-8 string, output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Dropout-12"></a>**Dropout-12**</a>
+
+  Dropout takes an input floating-point tensor, an optional input ratio (floating-point scalar) and an optional input training_mode (boolean scalar). It produces two tensor outputs,
+  output (floating-point tensor) and mask (optional `Tensor<bool>`). If `training_mode` is true then the output Y will be a random dropout;
+  Note that this Dropout scales the masked input data by the following equation, so to convert the trained model into inference mode,
+  the user can simply not pass `training_mode` input or set it to false.
+  ```
+  output = scale * data * mask,
+  ```
+  where
+  ```
+  scale = 1. / (1. - ratio).
+  ```
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>seed</tt> : int</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>The input data as Tensor.</dd>
+<dt><tt>ratio</tt> (optional) : T1</dt>
+<dd>The ratio of random dropout, with value in [0, 1). If this input was not set, or if it was set to 0, the output would be a simple copy of the input. If it's non-zero, output will be a random dropout of the scaled input, which is typically the case during training. It is an optional value, if not specified it will default to 0.5.</dd>
+<dt><tt>training_mode</tt> (optional) : T2</dt>
+<dd>If set to true then it indicates dropout is being used for training. It is an optional value hence unless specified explicitly, it is false. If it is false, ratio is ignored and the operation mimics inference mode where nothing will be dropped from the input data and if mask is requested as output it will contain all ones.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>The output.</dd>
+<dt><tt>mask</tt> (optional) : T2</dt>
+<dd>The output mask.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input 'ratio' types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output 'mask' types to boolean tensors.</dd>
+</dl>
+
+### <a name="Einsum-12"></a>**Einsum-12**</a>
+
+  An einsum of the form `term1, term2 -> output-term` produces an output tensor using the following equation
+
+  ```
+  output[output-term] = reduce-sum( input1[term1] * input2[term2] )
+  ```
+
+  where the reduce-sum performs a summation over all the indices occurring in the input terms (term1, term2)
+  that do not occur in the output-term.
+
+  The Einsum operator evaluates algebraic tensor operations on a sequence of tensors, using the Einstein summation
+  convention. The equation string contains a comma-separated sequence of lower case letters. Each term corresponds to
+  an operand tensor, and the characters within the terms correspond to operands dimensions.
+
+  This sequence may be followed by "->" to separate the left and right hand side of the equation.
+  If the equation contains "->" followed by the right-hand side, the explicit (not classical) form of the Einstein
+  summation is performed, and the right-hand side indices indicate output tensor dimensions. In other cases,
+  output indices are (implicitly) set to the alphabetically sorted sequence of indices appearing exactly once in the
+  equation.
+
+  When a dimension character is repeated in the left-hand side, it represents summation along the dimension.
+
+  The equation may contain ellipsis ("...") to enable broadcasting. Ellipsis must indicate a fixed number of dimensions.
+  Specifically, every occurrence of ellipsis in the equation must represent the same number of dimensions.
+  The right-hand side may contain exactly one ellipsis. In implicit mode, the ellipsis dimensions are set to the
+  beginning of the output. The equation string may contain space (U+0020) character.
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>equation</tt> : string (required)</dt>
+<dd>Einsum expression string.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>Inputs</tt> (variadic, differentiable) : T</dt>
+<dd>Operands</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Output</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numerical tensor types.</dd>
+</dl>
+
+### <a name="GatherND-12"></a>**GatherND-12**</a>
+
+  Given `data` tensor of rank `r` >= 1, `indices` tensor of rank `q` >= 1, and `batch_dims` integer `b`, this operator gathers
+  slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1 - b`.
+
+  `indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
+  where each element defines a slice of `data`
+
+  `batch_dims` (denoted as `b`) is an integer indicating the number of batch dimensions, i.e the leading `b` number of dimensions of
+  `data` tensor and `indices` are representing the batches, and the gather starts from the `b+1` dimension.
+
+  Some salient points about the inputs' rank and shape:
+
+  1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`
+
+  2) The first `b` dimensions of the shape of `indices` tensor and `data` tensor must be equal.
+
+  3) b < min(q, r) is to be honored.
+
+  4) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r-b` (inclusive)
+
+  5) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
+     It is an error if any of the index values are out of bounds.
+
+  The output is computed as follows:
+
+  The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.
+
+  1) If `indices_shape[-1] > r-b` => error condition
+
+  2) If `indices_shape[-1] == r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensors
+     containing 1-D tensors of dimension `r-b`, where `N` is an integer equals to the product of 1 and all the elements in the batch dimensions
+     of the indices_shape. Let us think of each such `r-b` ranked tensor as `indices_slice`. Each *scalar value* corresponding to `data[0:b-1,indices_slice]`
+     is filled into the corresponding location of the `(q-b-1)`-dimensional tensor to form the `output` tensor (Example 1 below)
+
+  3) If `indices_shape[-1] < r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensor
+     containing 1-D tensors of dimension `< r-b`. Let us think of each such tensors as `indices_slice`. Each *tensor slice* corresponding
+     to `data[0:b-1, indices_slice , :]` is filled into the corresponding location of the `(q-b-1)`-dimensional tensor
+     to form the `output` tensor (Examples 2, 3, 4 and 5 below)
+
+  This operator is the inverse of `ScatterND`.
+
+  `Example 1`
+
+    batch_dims = 0
+
+    data    = [[0,1],[2,3]]   # data_shape = [2, 2]
+
+    indices = [[0,0],[1,1]]   # indices_shape = [2, 2]
+
+    output  = [0,3]           # output_shape = [2]
+
+  `Example 2`
+
+    batch_dims = 0
+
+    data    = [[0,1],[2,3]]  # data_shape = [2, 2]
+
+    indices = [[1],[0]]      # indices_shape = [2, 1]
+
+    output  = [[2,3],[0,1]]  # output_shape = [2, 2]
+
+  `Example 3`
+
+    batch_dims = 0
+
+    data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+    indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]
+
+    output  = [[2,3],[4,5]]                 # output_shape = [2, 2]
+
+  `Example 4`
+
+    batch_dims = 0
+
+    data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+    indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]
+
+    output  = [[[2,3]],[[4,5]]]             # output_shape = [2, 1, 2]
+
+  `Example 5`
+
+    batch_dims = 1
+
+    data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+    indices = [[1],[0]]             # indices_shape = [2, 1]
+
+    output  = [[2,3],[4,5]]             # output_shape = [2, 2]
+
+
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>batch_dims</tt> : int (default is 0)</dt>
+<dd>The number of batch dimensions. The gather of indexing starts from dimension of data[batch_dims:]</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> : tensor(int64)</dt>
+<dd>Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Tensor of rank q + r - indices_shape[-1] - 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+### <a name="GreaterOrEqual-12"></a>**GreaterOrEqual-12**</a>
+
+  Returns the tensor resulted from performing the `greater_equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="LessOrEqual-12"></a>**LessOrEqual-12**</a>
+
+  Returns the tensor resulted from performing the `less_equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Max-12"></a>**Max-12**</a>
+
+  Element-wise max of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for max.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>max</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="MaxPool-12"></a>**MaxPool-12**</a>
+
+  MaxPool consumes an input tensor X and applies max pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   max pooling consisting of computing the max on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape is calculated differently
+   depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
+   With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`.
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):
+   ```
+   VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
+   ```
+   The output of each pooling window is maximum number of elements exclude pad.
+
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>storage_order</tt> : int (default is 0)</dt>
+<dd>The storage order of the tensor. 0 is row major, and 1 is column major. This attribute is used only to convert an n-tuple index value into a single integer value for producing the second output. </dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+<dt><tt>Indices</tt> (optional, non-differentiable) : I</dt>
+<dd>Indices tensor from max pooling across the input tensor. The dimensions of indices are the same as output tensor. The values in indices of are the indices of the selected values during pooling. The indices are computed as flatten 1-D tensor, and the indices do not consider padding. So the values in indices are in [0, N x C x D1 x ... x Dn).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input and output types to float and 8 bit tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="Min-12"></a>**Min-12**</a>
+
+  Element-wise min of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic) : T</dt>
+<dd>List of tensors for min.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>min</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="NegativeLogLikelihoodLoss-12"></a>**NegativeLogLikelihoodLoss-12**</a>
+
+  A NegativeLogLikelihoodLoss operator computes (weighted) negative log likelihood loss.
+  Its "input" tensor has the shape of (N, C, d1, d2, ..., dk) where k >= 0.
+  The "input" tensor contains log-probabilities for input[n, :, d_1, d_2,..., d_k] being in a class of [0, C).
+  The operator's "target" input tensor has the shape of (N, d1, d2, ..., dk). It encodes class labels (one of C classes)
+  or it may contain a special value (indicated by an attribute ignore_index) for N x d1 x d2 x ... x dk samples.
+  The loss value for input[n, :, d_1, d_2,...d_k] being classified as class c = target[n][d_1][d_2]...[d_k] is computed as:
+      loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k].
+  When an optional "weight" is provided, the sample loss is calculated as:
+      loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k] * weight[c].
+  loss is zero for the case when target-value equals ignore_index.
+
+      loss[n][d_1][d_2]...[d_k] = 0, when target[n][d_1][d_2]...[d_k] = ignore_index
+  If "reduction" attribute is set to "none", the operator's output will be the above loss with shape (N, d1, d2, ..., dk).
+  If "reduction" attribute is set to "mean" (the default attribute value), the output loss is (weight) averaged:
+      mean(loss), if "weight" is not provided,
+  or if weight is provided,
+      sum(loss) / sum(weight[target[n][d_1][d_2]...[d_k]]]), for all samples.
+  If "reduction" attribute is set to "sum", the output is a scalar:
+      sum(loss).
+  See also https://pytorch.org/docs/stable/nn.html#torch.nn.NLLLoss.
+  Example 1:
+      // negative log likelihood loss, "none" reduction
+      N, C, d1 = 2, 3, 2
+      input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+               [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+      target = [[2, 1], [0, 2]]
+      loss = np.zeros((N, d1))
+      for n in range(N):
+          for d_1 in range(d1):
+              c = target[n][d_1]
+              loss[n][d_1] = -input[n][c][d_1]
+      // print(loss)
+      // [[-3. -2.]
+      //  [-0. -2.]]
+  Example 2:
+      // weighted negative log likelihood loss, sum reduction
+      N, C, d1 = 2, 3, 2
+      input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+              [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+      target = [[2, 1], [0, 2]]
+      weight = [0.2, 0.3, 0.1]
+      loss = np.zeros((N, d1))
+      for n in range(N):
+          for d_1 in range(d1):
+              c = target[n][d_1]
+              loss[n][d_1] = -input[n][c][d_1] * weight[c]
+      loss = np.sum(loss)
+      // print(loss)
+      // -1.1
+  Example 3:
+      // weighted negative log likelihood loss, mean reduction
+      N, C, d1 = 2, 3, 2
+      input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+              [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+      target = [[2, 1], [0, 2]]
+      weight = [0.2, 0.3, 0.1]
+      loss = np.zeros((N, d1))
+      weight_total = 0
+      for n in range(N):
+          for d_1 in range(d1):
+              c = target[n][d_1]
+              loss[n][d_1] = -input[n][c][d_1] * weight[c]
+              weight_total = weight_total + weight[c]
+      loss = np.sum(loss) / weight_total
+      // print(loss)
+      // -1.57
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>ignore_index</tt> : int</dt>
+<dd>Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.</dd>
+<dt><tt>reduction</tt> : string (default is mean)</dt>
+<dd>Type of reduction to apply to loss: none, sum, mean (default). 'none': the output is the loss for each sample. 'sum': the output will be summed. 'mean': the sum of the output will be divided by the sum of applied weights.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Input tensor of shape (N, C) or (N, C, d1, d2, ..., dk).</dd>
+<dt><tt>target</tt> : Tind</dt>
+<dd>Target tensor of shape (N) or (N, d1, d2, ..., dk). Target element value shall be in range of [0, C). If ignore_index is specified, it may have a value outside [0, C) and the target values should either be in the range [0, C) or have the value ignore_index.</dd>
+<dt><tt>weight</tt> (optional) : T</dt>
+<dd>Optional rescaling weight tensor. If given, it has to be a tensor of size C. Otherwise, it is treated as if having all ones.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>loss</tt> : T</dt>
+<dd>The negative log likelihood loss</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input, weight, and output types to floating-point tensors.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain target to integer types</dd>
+</dl>
+
+### <a name="Pow-12"></a>**Pow-12**</a>
+
+  Pow takes input data (Tensor<T>) and exponent Tensor, and
+  produces one output data (Tensor<T>) where the function `f(x) = x^exponent`,
+  is applied to the data tensor elementwise.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>First operand, base of the exponent.</dd>
+<dt><tt>Y</tt> : T1</dt>
+<dd>Second operand, power of the exponent.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input X and output types to float/int tensors.</dd>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input Y types to float/int tensors.</dd>
+</dl>
+
+### <a name="ReduceMax-12"></a>**ReduceMax-12**</a>
+
+  Computes the max of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(uint8), tensor(int8)</dt>
+<dd>Constrain input and output types to high-precision and 8 bit numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMin-12"></a>**ReduceMin-12**</a>
+
+  Computes the min of the input tensor's element along the provided axes. The resulting
+  tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+  the resulted tensor have the reduced dimension pruned.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+  False instead of True.
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(uint8), tensor(int8)</dt>
+<dd>Constrain input and output types to high-precision and 8 bit numeric tensors.</dd>
+</dl>
+
+### <a name="SoftmaxCrossEntropyLoss-12"></a>**SoftmaxCrossEntropyLoss-12**</a>
+
+  Loss function that measures the softmax cross entropy
+  between 'scores' and 'labels'.
+  This operator first computes a loss tensor whose shape is identical to the labels input.
+  If the input is 2-D with shape (N, C), the loss tensor may be a N-element vector L = (l_1, l_2, ..., l_N).
+  If the input is N-D tensor with shape (N, C, D1, D2, ..., Dk),
+  the loss tensor L may have (N, D1, D2, ..., Dk) as its shape and L[i,][j_1][j_2]...[j_k] denotes a scalar element in L.
+  After L is available, this operator can optionally do a reduction operator.
+
+  shape(scores): (N, C) where C is the number of classes, or (N, C, D1, D2,..., Dk),
+          with K >= 1 in case of K-dimensional loss.
+  shape(labels): (N) where each value is 0 <= labels[i] <= C-1, or (N, D1, D2,..., Dk),
+          with K >= 1 in case of K-dimensional loss.
+
+  The loss for one sample, l_i, can calculated as follows:
+      l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk], where i is the index of classes.
+  or
+      l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk] * weights[c], if 'weights' is provided.
+
+  loss is zero for the case when label-value equals ignore_index.
+      l[i][d1][d2]...[dk]  = 0, when labels[n][d1][d2]...[dk] = ignore_index
+
+  where:
+      p = Softmax(scores)
+      y = Log(p)
+      c = labels[i][d1][d2]...[dk]
+
+  Finally, L is optionally reduced:
+  If reduction = 'none', the output is L with shape (N, D1, D2, ..., Dk).
+  If reduction = 'sum', the output is scalar: Sum(L).
+  If reduction = 'mean', the output is scalar: ReduceMean(L), or if weight is provided: ReduceSum(L) / ReduceSum(W),
+  where tensor W is of shape (N, D1, D2, ..., Dk) and W[n][d1][d2]...[dk] = weights[labels[i][d1][d2]...[dk]].
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>ignore_index</tt> : int</dt>
+<dd>Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.</dd>
+<dt><tt>reduction</tt> : string (default is mean)</dt>
+<dd>Type of reduction to apply to loss: none, sum, mean(default). 'none': no reduction will be applied, 'sum': the output will be summed. 'mean': the sum of the output will be divided by the number of elements in the output.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>scores</tt> : T</dt>
+<dd>The predicted outputs with shape [batch_size, class_size], or [batch_size, class_size, D1, D2 , ..., Dk], where K is the number of dimensions.</dd>
+<dt><tt>labels</tt> : Tind</dt>
+<dd>The ground truth output tensor, with shape [batch_size], or [batch_size, D1, D2, ..., Dk], where K is the number of dimensions. Labels element value shall be in range of [0, C). If ignore_index is specified, it may have a value outside [0, C) and the label values should either be in the range [0, C) or have the value ignore_index.</dd>
+<dt><tt>weights</tt> (optional) : T</dt>
+<dd>A manual rescaling weight given to each class. If given, it has to be a 1D Tensor assigning weight to each of the classes. Otherwise, it is treated as if having all ones.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Weighted loss float Tensor. If reduction is 'none', this has the shape of [batch_size], or [batch_size, D1, D2, ..., Dk] in case of K-dimensional loss. Otherwise, it is a scalar.</dd>
+<dt><tt>log_prob</tt> (optional) : T</dt>
+<dd>Log probability tensor. If the output of softmax is prob, its value is log(prob).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain target to integer types</dd>
+</dl>
+
+## Version 13 of the default ONNX operator set
+### <a name="Abs-13"></a>**Abs-13**</a>
+
+  Absolute takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where absolute value, y = abs(x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Add-13"></a>**Add-13**</a>
+
+  Performs element-wise binary addition (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="ArgMax-13"></a>**ArgMax-13**</a>
+
+  Computes the indices of the max elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equals 0, then the resulting tensor has the reduced dimension pruned.
+  If select_last_index is True (default False), the index of the last occurrence of the max
+  is selected if the max appears more than once in the input. Otherwise the index of the
+  first occurrence is selected.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>select_last_index</tt> : int (default is 0)</dt>
+<dd>Whether to select the last index or the first index if the {name} appears in multiple indices, default is False (first index).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="ArgMin-13"></a>**ArgMin-13**</a>
+
+  Computes the indices of the min elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equals 0, then the resulting tensor has the reduced dimension pruned.
+  If select_last_index is True (default False), the index of the last occurrence of the min
+  is selected if the min appears more than once in the input. Otherwise the index of the
+  first occurrence is selected.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>select_last_index</tt> : int (default is 0)</dt>
+<dd>Whether to select the last index or the first index if the {name} appears in multiple indices, default is False (first index).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Cast-13"></a>**Cast-13**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+
+  Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+  (e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+  yield result 100. There are some string literals reserved for special floating-point values;
+  "+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+  Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+  this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+  to string tensors, plain floating-point representation (such as "314.15926") would be used.
+  Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+  of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+  Conversion from a numerical type to any numerical type is always allowed.
+  User must be aware of precision loss and value change caused by range difference between two types.
+  For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+  an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+  In more detail, the conversion among numerical types should follow these rules:
+
+  * Casting from floating point to:
+    * floating point: +/- infinity if OOR (out of range).
+    * fixed point: undefined if OOR.
+    * bool: +/- 0.0 to False; all else to True.
+  * Casting from fixed point to:
+    * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+    * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+      signed types). For example, 200 (int16) -> -56 (int8).
+    * bool: zero to False; nonzero to True.
+  * Casting from bool to:
+    * floating point: `{1.0, 0.0}`.
+    * fixed point: `{1, 0}`.
+    * bool: no change.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="Ceil-13"></a>**Ceil-13**</a>
+
+  Ceil takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the ceil is, y = ceil(x), is applied to
+  the tensor elementwise. If x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Clip-13"></a>**Clip-13**</a>
+
+  Clip operator limits the given input within an interval. The interval is
+  specified by the inputs 'min' and 'max'. They default to
+  numeric_limits::lowest() and numeric_limits::max(), respectively.
+  When 'min' is greater than 'max', the clip operator sets all the 'input' values to
+  the value of 'max'. Thus, this is equivalent to 'Min(max, Max(input, min))'.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor whose elements to be clipped</dd>
+<dt><tt>min</tt> (optional, non-differentiable) : T</dt>
+<dd>Minimum value, under which element is replaced by min. It must be a scalar(tensor of empty shape).</dd>
+<dt><tt>max</tt> (optional, non-differentiable) : T</dt>
+<dd>Maximum value, above which element is replaced by max. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor with clipped input elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Concat-13"></a>**Concat-13**</a>
+
+  Concatenate a list of tensors into a single tensor. All input tensors must have the same shape, except for the dimension size of the axis to concatenate on.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (required)</dt>
+<dd>Which axis to concat on. A negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(inputs)..</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>inputs</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for concatenation</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>concat_result</tt> (differentiable) : T</dt>
+<dd>Concatenated tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+### <a name="Constant-13"></a>**Constant-13**</a>
+
+  This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+  or value_* must be specified.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>sparse_value</tt> : sparse_tensor</dt>
+<dd>The value for the elements of the output tensor in sparse format.</dd>
+<dt><tt>value</tt> : tensor</dt>
+<dd>The value for the elements of the output tensor.</dd>
+<dt><tt>value_float</tt> : float</dt>
+<dd>The value for the sole element for the scalar, float32, output tensor.</dd>
+<dt><tt>value_floats</tt> : list of floats</dt>
+<dd>The values for the elements for the 1D, float32, output tensor.</dd>
+<dt><tt>value_int</tt> : int</dt>
+<dd>The value for the sole element for the scalar, int64, output tensor.</dd>
+<dt><tt>value_ints</tt> : list of ints</dt>
+<dd>The values for the elements for the 1D, int64, output tensor.</dd>
+<dt><tt>value_string</tt> : string</dt>
+<dd>The value for the sole element for the scalar, UTF-8 string, output tensor.</dd>
+<dt><tt>value_strings</tt> : list of strings</dt>
+<dd>The values for the elements for the 1D, UTF-8 string, output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="DepthToSpace-13"></a>**DepthToSpace-13**</a>
+
+  DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
+  This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
+  the input tensor where values from the depth dimension are moved in spatial blocks to the height
+  and width dimensions. By default, `mode` = `DCR`.
+  In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the
+  following order: depth, column, and then row. The output y is computed from the input x as below:
+
+  ```
+  b, c, h, w = x.shape
+  tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])
+  tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])
+  y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])
+  ```
+
+  In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the
+  following order: column, row, and the depth. The output y is computed from the input x as below:
+
+  ```
+  b, c, h, w = x.shape
+  tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])
+  tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])
+  y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>blocksize</tt> : int (required)</dt>
+<dd>Blocks of [blocksize, blocksize] are moved.</dd>
+<dt><tt>mode</tt> : string (default is DCR)</dt>
+<dd>DCR (default) for depth-column-row order re-arrangement. Use CRD for column-row-depth order.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="DequantizeLinear-13"></a>**DequantizeLinear-13**</a>
+
+  The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the full precision tensor.
+  The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point` must have same shape, and can be either a scalar
+  for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+  `x_zero_point` and `x` must have same type. `x` and `y` must have same shape. In the case of dequantizing int32,
+  there's no zero point (zero point is supposed to be 0).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T</dt>
+<dd>N-D quantized input tensor to be de-quantized.</dd>
+<dt><tt>x_scale</tt> : tensor(float)</dt>
+<dd>Scale for input 'x'. It can be a scalar, which means a per-tensor/layer dequantization, or a 1-D tensor for per-axis dequantization.</dd>
+<dt><tt>x_zero_point</tt> (optional) : T</dt>
+<dd>Zero point for input 'x'. Shape must match x_scale. It's optional. Zero point is 0 when it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : tensor(float)</dt>
+<dd>N-D full precision output tensor. It has same shape as input 'x'.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(int8), tensor(uint8), tensor(int32)</dt>
+<dd>Constrain 'x_zero_point' and 'x' to 8-bit/32-bit integer tensor.</dd>
+</dl>
+
+### <a name="Div-13"></a>**Div-13**</a>
+
+  Performs element-wise binary division (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  For integer inputs, the result is computed using truncating division (rounding toward zero).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Dropout-13"></a>**Dropout-13**</a>
+
+  Dropout takes an input floating-point tensor, an optional input ratio (floating-point scalar) and an optional input training_mode (boolean scalar). It produces two tensor outputs,
+  output (floating-point tensor) and mask (optional `Tensor<bool>`). If `training_mode` is true then the output Y will be a random dropout;
+  Note that this Dropout scales the masked input data by the following equation, so to convert the trained model into inference mode,
+  the user can simply not pass `training_mode` input or set it to false.
+  ```
+  output = scale * data * mask,
+  ```
+  where
+  ```
+  scale = 1. / (1. - ratio).
+  ```
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>seed</tt> : int</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>The input data as Tensor.</dd>
+<dt><tt>ratio</tt> (optional, non-differentiable) : T1</dt>
+<dd>The ratio of random dropout, with value in [0, 1). If this input was not set, or if it was set to 0, the output would be a simple copy of the input. If it's non-zero, output will be a random dropout of the scaled input, which is typically the case during training. It is an optional value, if not specified it will default to 0.5.</dd>
+<dt><tt>training_mode</tt> (optional, non-differentiable) : T2</dt>
+<dd>If set to true then it indicates dropout is being used for training. It is an optional value hence unless specified explicitly, it is false. If it is false, ratio is ignored and the operation mimics inference mode where nothing will be dropped from the input data and if mask is requested as output it will contain all ones.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output.</dd>
+<dt><tt>mask</tt> (optional, non-differentiable) : T2</dt>
+<dd>The output mask.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input 'ratio' types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output 'mask' types to boolean tensors.</dd>
+</dl>
+
+### <a name="Equal-13"></a>**Equal-13**</a>
+
+  Returns the tensor resulted from performing the `equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Erf-13"></a>**Erf-13**</a>
+
+  Computes the error function of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The error function of the input tensor computed element-wise. It has the same shape and type of the input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Exp-13"></a>**Exp-13**</a>
+
+  Calculates the exponential of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The exponential of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Expand-13"></a>**Expand-13**</a>
+
+  Broadcast the input tensor following the given shape and the broadcast rule.
+  The broadcast rule is similar to numpy.array(input) * numpy.ones(shape):
+  Dimensions are right alignment;
+  Two corresponding dimensions must have the same value, or one of them is equal to 1.
+  Also, this operator is similar to numpy.broadcast_to(input, shape),
+  but the major difference is numpy.broadcast_to() does not allow shape to be smaller than input.size().
+  It is possible that the output.shape is not equal to shape, when some dimensions in shape is equal to 1,
+  or the shape.ndim < input.shape.ndim.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D tensor indicates the shape you want to expand to, following the broadcast rule</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensors.</dd>
+</dl>
+
+### <a name="Flatten-13"></a>**Flatten-13**</a>
+
+  Flattens the input tensor into a 2D matrix. If input tensor has shape
+  (d_0, d_1, ... d_n) then the output will have shape
+  (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Indicate up to which input dimensions (exclusive) should be flattened to the outer dimension of the output. The value for axis must be in the range [-r, r], where r is the rank of the input tensor. Negative value means counting dimensions from the back. When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), where the shape of the input tensor is (d_0, d_1, ... d_n). </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>A tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>A 2D tensor with the contents of the input tensor, with input dimensions up to axis flattened to the outer dimension of the output and remaining input dimensions flattened into the inner dimension of the output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output to all tensor types.</dd>
+</dl>
+
+### <a name="Floor-13"></a>**Floor-13**</a>
+
+  Floor takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the floor is, y = floor(x), is applied to
+  the tensor elementwise. If x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Gather-13"></a>**Gather-13**</a>
+
+  Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
+  entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
+  them in an output tensor of rank q + (r - 1).
+
+  It is an indexing operation that indexes into the input `data` along a single (specified) axis.
+  Each entry in `indices` produces a `r-1` dimensional slice of the input tensor.
+  The entire operation produces, conceptually, a `q`-dimensional tensor of `r-1` dimensional slices,
+  which is arranged into a `q + (r-1)`-dimensional tensor, with the `q` dimensions taking the
+  place of the original `axis` that is being indexed into.
+
+  The following few examples illustrate how `Gather` works for specific shapes of `data`,
+  `indices`, and given value of `axis`:
+  | data shape | indices shape | axis | output shape | output equation |
+  | --- | --- | --- | --- | --- |
+  | (P, Q) | ( )  (a scalar)   | 0 | (Q)       | output[q] = data[indices, q] |
+  | (P, Q, R) | ( )  (a scalar)   | 1 | (P, R)       | output[p, r] = data[p, indices, r] |
+  | (P, Q) | (R, S) | 0 | (R, S, Q) | output[r, s, q] = data[ [indices[r, s], q] |
+  | (P, Q) | (R, S) | 1 | (P, R, S) | output[p, r, s] = data[ p, indices[r, s]] |
+
+  More generally, if `axis = 0`, let `k = indices[i_{0}, ..., i_{q-1}]`
+  then `output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[k , j_{0}, ..., j_{r-2}]`:
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+  indices = [
+      [0, 1],
+      [1, 2],
+  ]
+  output = [
+      [
+          [1.0, 1.2],
+          [2.3, 3.4],
+      ],
+      [
+          [2.3, 3.4],
+          [4.5, 5.7],
+      ],
+  ]
+  ```
+
+  If `axis = 1`, let `k = indices[i_{0}, ..., i_{q-1}]`
+  then `output[j_{0}, i_{0}, ..., i_{q-1}, j_{1}, ..., j_{r-2}] = input[j_{0}, k, j_{1}, ..., j_{r-2}]`:
+
+  ```
+  data = [
+      [1.0, 1.2, 1.9],
+      [2.3, 3.4, 3.9],
+      [4.5, 5.7, 5.9],
+  ]
+  indices = [
+      [0, 2],
+  ]
+  axis = 1,
+  output = [
+          [[1.0, 1.9]],
+          [[2.3, 3.9]],
+          [[4.5, 5.9]],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to gather on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : Tind</dt>
+<dd>Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank q + (r - 1).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="GatherElements-13"></a>**GatherElements-13**</a>
+
+  GatherElements takes two inputs `data` and `indices` of the same rank r >= 1
+  and an optional attribute `axis` that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). It is an indexing operation
+  that produces its output by indexing into the input data tensor at index
+  positions determined by elements of the `indices` tensor.
+  Its output shape is the same as the shape of `indices` and consists of one value
+  (gathered from the `data`) for each element in `indices`.
+
+  For instance, in the 3-D case (r = 3), the output produced is determined
+  by the following equations:
+  ```
+  out[i][j][k] = input[index[i][j][k]][j][k] if axis = 0,
+  out[i][j][k] = input[i][index[i][j][k]][k] if axis = 1,
+  out[i][j][k] = input[i][j][index[i][j][k]] if axis = 2,
+  ```
+
+  This operator is also the inverse of ScatterElements. It is similar to Torch's gather operation.
+
+  Example 1:
+  ```
+  data = [
+      [1, 2],
+      [3, 4],
+  ]
+  indices = [
+      [0, 0],
+      [1, 0],
+  ]
+  axis = 1
+  output = [
+      [1, 1],
+      [4, 3],
+  ]
+  ```
+  Example 2:
+  ```
+  data = [
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9],
+  ]
+  indices = [
+      [1, 2, 0],
+      [2, 0, 0],
+  ]
+  axis = 0
+  output = [
+      [4, 8, 3],
+      [7, 2, 3],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to gather on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : Tind</dt>
+<dd>Tensor of int32/int64 indices, with the same rank r as the input. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of the same shape as indices.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="GatherND-13"></a>**GatherND-13**</a>
+
+  Given `data` tensor of rank `r` >= 1, `indices` tensor of rank `q` >= 1, and `batch_dims` integer `b`, this operator gathers
+  slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1 - b`.
+
+  `indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
+  where each element defines a slice of `data`
+
+  `batch_dims` (denoted as `b`) is an integer indicating the number of batch dimensions, i.e the leading `b` number of dimensions of
+  `data` tensor and `indices` are representing the batches, and the gather starts from the `b+1` dimension.
+
+  Some salient points about the inputs' rank and shape:
+
+  1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`
+
+  2) The first `b` dimensions of the shape of `indices` tensor and `data` tensor must be equal.
+
+  3) b < min(q, r) is to be honored.
+
+  4) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r-b` (inclusive)
+
+  5) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
+     It is an error if any of the index values are out of bounds.
+
+  The output is computed as follows:
+
+  The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.
+
+  1) If `indices_shape[-1] > r-b` => error condition
+
+  2) If `indices_shape[-1] == r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensors
+     containing 1-D tensors of dimension `r-b`, where `N` is an integer equals to the product of 1 and all the elements in the batch dimensions
+     of the indices_shape. Let us think of each such `r-b` ranked tensor as `indices_slice`. Each *scalar value* corresponding to `data[0:b-1,indices_slice]`
+     is filled into the corresponding location of the `(q-b-1)`-dimensional tensor to form the `output` tensor (Example 1 below)
+
+  3) If `indices_shape[-1] < r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensor
+     containing 1-D tensors of dimension `< r-b`. Let us think of each such tensors as `indices_slice`. Each *tensor slice* corresponding
+     to `data[0:b-1, indices_slice , :]` is filled into the corresponding location of the `(q-b-1)`-dimensional tensor
+     to form the `output` tensor (Examples 2, 3, 4 and 5 below)
+
+  This operator is the inverse of `ScatterND`.
+
+  **Example 1**
+
+  ```
+  batch_dims = 0
+  data    = [[0,1],[2,3]]   # data_shape    = [2, 2]
+  indices = [[0,0],[1,1]]   # indices_shape = [2, 2]
+  output  = [0,3]           # output_shape  = [2]
+  ```
+
+  **Example 2**
+
+  ```
+  batch_dims = 0
+  data    = [[0,1],[2,3]]  # data_shape    = [2, 2]
+  indices = [[1],[0]]      # indices_shape = [2, 1]
+  output  = [[2,3],[0,1]]  # output_shape  = [2, 2]
+  ```
+
+  **Example 3**
+
+  ```
+  batch_dims = 0
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
+  indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]
+  output  = [[2,3],[4,5]]                 # output_shape  = [2, 2]
+  ```
+
+  **Example 4**
+
+  ```
+  batch_dims = 0
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
+  indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]
+  output  = [[[2,3]],[[4,5]]]             # output_shape  = [2, 1, 2]
+  ```
+
+  **Example 5**
+
+  ```
+  batch_dims = 1
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
+  indices = [[1],[0]]                     # indices_shape = [2, 1]
+  output  = [[2,3],[4,5]]                 # output_shape  = [2, 2]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>batch_dims</tt> : int (default is 0)</dt>
+<dd>The number of batch dimensions. The gather of indexing starts from dimension of data[batch_dims:]</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank q + r - indices_shape[-1] - 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+### <a name="Gemm-13"></a>**Gemm-13**</a>
+
+  General Matrix multiplication:
+  https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+
+  * A' = transpose(A) if transA else A
+  * B' = transpose(B) if transB else B
+
+  Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M),
+  input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N),
+  and output tensor Y has shape (M, N). A will be transposed before doing the
+  computation if attribute transA is non-zero, same for B and transB.
+  This operator supports **unidirectional broadcasting** (tensor C should be unidirectional broadcastable to tensor A * B); for more details please check [the doc](Broadcasting.md).
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for the product of input tensors A * B.</dd>
+<dt><tt>beta</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for input tensor C.</dd>
+<dt><tt>transA</tt> : int (default is 0)</dt>
+<dd>Whether A should be transposed</dd>
+<dt><tt>transB</tt> : int (default is 0)</dt>
+<dd>Whether B should be transposed</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>Input tensor A. The shape of A should be (M, K) if transA is 0, or (K, M) if transA is non-zero.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Input tensor B. The shape of B should be (K, N) if transB is 0, or (N, K) if transB is non-zero.</dd>
+<dt><tt>C</tt> (optional, differentiable) : T</dt>
+<dd>Optional input tensor C. If not specified, the computation is done as if C is a scalar 0. The shape of C should be unidirectional broadcastable to (M, N).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor of shape (M, N).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+### <a name="Greater-13"></a>**Greater-13**</a>
+
+  Returns the tensor resulted from performing the `greater` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Hardmax-13"></a>**Hardmax-13**</a>
+
+  The operator computes the hardmax values for the given input:
+
+   Hardmax(element in input, axis) = 1 if the element is the first maximum value along the specified axis, 0 otherwise
+
+  The "axis" attribute indicates the dimension along which Hardmax
+  will be performed. The output tensor has the same shape
+  and contains the Hardmax values of the corresponding input.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>
+Describes the dimension Hardmax will be performed on.
+Negative value means counting dimensions
+from the back. Accepted range is [-r, r-1] where r = rank(input).
+</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The input tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output values with the same shape as the input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Identity-13"></a>**Identity-13**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="If-13"></a>**If-13**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same data type. The `then_branch` and `else_branch` may produce tensors with the same element type and different shapes. If corresponding outputs from the then-branch and the else-branch have static shapes S1 and S2, then the shape of the corresponding output variable of the if-node (if present) must be compatible with both S1 and S2 as it represents the union of both possible shapes.For example, if in a model file, the first output of `then_branch` is typed float tensor with shape [2] and the first output of `else_branch` is another float tensor with shape [3], If's first output should have (a) no shape set, or (b) a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) a shape of rank 1 with a unique `dim_param`. In contrast, the first output cannot have the shape [2] since [2] and [3] are not compatible.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>All Tensor and Sequence types</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+### <a name="IsNaN-13"></a>**IsNaN-13**</a>
+
+  Returns which elements of the input are NaN.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output types to boolean tensors.</dd>
+</dl>
+
+### <a name="LRN-13"></a>**LRN-13**</a>
+
+  Local Response Normalization proposed in the [AlexNet paper](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf).
+  It normalizes over local input regions.
+  The local region is defined across the channels. For an element `X[n, c, d1, ..., dk]` in a tensor
+  of shape `(N x C x D1 x D2, ..., Dk)`, its region is
+  `{X[n, i, d1, ..., dk] | max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))}`.
+
+  `square_sum[n, c, d1, ..., dk] = sum(X[n, i, d1, ..., dk] ^ 2)`,
+  where `max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))`.
+
+  `Y[n, c, d1, ..., dk] = X[n, c, d1, ..., dk] / (bias + alpha / size * square_sum[n, c, d1, ..., dk] ) ^ beta`
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.0001)</dt>
+<dd>Scaling parameter.</dd>
+<dt><tt>beta</tt> : float (default is 0.75)</dt>
+<dd>The exponent.</dd>
+<dt><tt>bias</tt> : float (default is 1.0)</dt>
+<dd></dd>
+<dt><tt>size</tt> : int (required)</dt>
+<dd>The number of channels to sum over</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor, which has the shape and type as input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output  types to float tensors.</dd>
+</dl>
+
+### <a name="Less-13"></a>**Less-13**</a>
+
+  Returns the tensor resulted from performing the `less` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Log-13"></a>**Log-13**</a>
+
+  Calculates the natural log of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The natural log of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LogSoftmax-13"></a>**LogSoftmax-13**</a>
+
+  The operator computes the log of softmax values for the given input:
+
+   LogSoftmax(input, axis) = Log(Softmax(input, axis=axis))
+
+  The "axis" attribute indicates the dimension along which LogSoftmax
+  will be performed. The output tensor has the same shape
+  and contains the LogSoftmax values of the corresponding input.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>
+Describes the dimension LogSoftmax will be performed on.
+Negative value means counting dimensions
+from the back. Accepted range is [-r, r-1] where r = rank(input).
+</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The input tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output values with the same shape as the input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Loop-13"></a>**Loop-13**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+      input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+      input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+      input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+      input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+      input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]           // iteration number
+        %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+        %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+      ) {
+        %my_local = Add(%a, %b_in)
+        %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+        %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+        %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+        return %keepgoing_out, %b_out, %user_defined_val
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        /* initialize loop-carried variables and scan-output variables */
+        bool keepgoing_out = keepgoing
+        int b_out = b
+
+        for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+          /* Implicitly-defined code: bind actual parameter values
+             to formal parameter variables of loop-body */
+          bool keepgoing_in = keepgoing_out;
+          bool b_in = b_out;
+
+          /* User-defined code (loop body) */
+          int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+          b_out = a - b_in;
+          keepgoing_out = my_local > b_out;
+          user_defined_val = b_in + b_in; // b_in and b_out are different variables
+          /* End user-defined code */
+
+          /* Implicitly defined-code */
+          user_defined_vals[i] = user_defined_val // accumulate scan-output values
+        }
+        // int t = my_local; // Can't do this. my_local is not accessible here.
+
+        // The values below are bound to the output variables of the loop and therefore accessible
+        // b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any values computed in the loop body that needs to be used in a subsequent
+     iteration or after the loop are modeled using a pair of variables in the loop-body,
+     consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+     These are referred to as loop-carried dependences. The loop operation node
+     supplies the input value of the input variable for the first iteration, and
+     returns the output value of the output variable produced by the final
+     iteration.
+  3) Scan_output variables are used to implicitly concatenate values computed across
+     all the iterations. In the above example, the value of user_defined_val computed
+     over all iterations are concatenated and returned as the value of user_defined_vals
+     after the loop.
+  4) Values created in the body cannot be accessed in the enclosing scope,
+     except using the mechanism described above.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+  The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs. Scan outputs must be Tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>All Tensor and Sequence types</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+### <a name="MatMul-13"></a>**MatMul-13**</a>
+
+  Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>N-dimensional matrix A</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>N-dimensional matrix B</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Matrix multiply results from A * B</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+### <a name="Max-13"></a>**Max-13**</a>
+
+  Element-wise max of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for max.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>max</tt> (differentiable) : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="Mean-13"></a>**Mean-13**</a>
+
+  Element-wise mean of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for mean.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>mean</tt> (differentiable) : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="MeanVarianceNormalization-13"></a>**MeanVarianceNormalization-13**</a>
+
+  A MeanVarianceNormalization Function: Perform mean variance normalization
+        on the input tensor X using formula: `(X-EX)/sqrt(E(X-EX)^2)`
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints (default is ['0', '2', '3'])</dt>
+<dd>A list of integers, along which to reduce. The default is to calculate along axes [0,2,3] for calculating mean and variance along each channel. Two variables with the same C-coordinate are associated with the same mean and variance.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Min-13"></a>**Min-13**</a>
+
+  Element-wise min of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for min.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>min</tt> (differentiable) : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="Mod-13"></a>**Mod-13**</a>
+
+  Performs an element-wise binary modulo operation.
+  The semantics and supported data types depend on the value of the `fmod` attribute which must be `0` (default), or `1`.
+
+  If the `fmod` attribute is set to `0`, `T` is constrained to integer data types and the semantics follow that of the Python `%`-operator.
+  The sign of the result is that of the divisor.
+
+  If `fmod` is set to `1`, the behavior of this operator follows that of the `fmod` function in C and `T` is constrained to floating point data types.
+  The result of this operator is the remainder of the division operation `x / y` where `x` and `y` are respective elements of `A` and `B`. The result is exactly the value `x - n * y`, where `n` is `x / y` with its fractional part truncated.
+  The returned value has the same sign as `x` (except if `x` is `-0`) and is less or equal to `|y|` in magnitude.
+  The following special cases apply when `fmod` is set to `1`:
+  - If `x` is `-0` and `y` is greater than zero, either `+0` or `-0` may be returned.
+  - If `x` is `±∞` and `y` is not `NaN`, `NaN` is returned.
+  - If `y` is `±0` and `x` is not `NaN`, `NaN` should be returned.
+  - If `y` is `±∞` and `x` is finite, `x` is returned.
+  - If either argument is `NaN`, `NaN` is returned.
+
+  This operator supports **multidirectional (i.e., NumPy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>fmod</tt> : int (default is 0)</dt>
+<dd>Whether the operator should behave like fmod (default=0 meaning it will do integer mods); Set this to 1 to force fmod treatment</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>Dividend tensor</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Divisor tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Remainder tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Mul-13"></a>**Mul-13**</a>
+
+  Performs element-wise binary multiplication (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Neg-13"></a>**Neg-13**</a>
+
+  Neg takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where each element flipped sign, y = -x, is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(int32), tensor(int8), tensor(int16), tensor(int64), tensor(float16), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to signed numeric tensors.</dd>
+</dl>
+
+### <a name="NegativeLogLikelihoodLoss-13"></a>**NegativeLogLikelihoodLoss-13**</a>
+
+  A NegativeLogLikelihoodLoss operator computes (weighted) negative log likelihood loss.
+  Its "input" tensor has the shape of (N, C, d1, d2, ..., dk) where k >= 0.
+  The "input" tensor contains log-probabilities for input[n, :, d_1, d_2,..., d_k] being in a class of [0, C).
+  The operator's "target" input tensor has the shape of (N, d1, d2, ..., dk). It encodes class labels (one of C classes)
+  or it may contain a special value (indicated by an attribute ignore_index) for N x d1 x d2 x ... x dk samples.
+  The loss value for input[n, :, d_1, d_2,...d_k] being classified as class c = target[n][d_1][d_2]...[d_k] is computed as:
+
+  ```
+  loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k].
+  ```
+
+  When an optional "weight" is provided, the sample loss is calculated as:
+
+  ```
+  loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k] * weight[c].
+  ```
+
+  loss is zero for the case when target-value equals ignore_index.
+
+  ```
+  loss[n][d_1][d_2]...[d_k] = 0, when target[n][d_1][d_2]...[d_k] = ignore_index
+  ```
+
+  If "reduction" attribute is set to "none", the operator's output will be the above loss with shape (N, d1, d2, ..., dk).
+  If "reduction" attribute is set to "mean" (the default attribute value), the output loss is (weight) averaged:
+
+  ```
+  mean(loss), if "weight" is not provided,
+  ```
+
+  or if weight is provided,
+
+  ```
+  sum(loss) / sum(weight[target[n][d_1][d_2]...[d_k]]]), for all samples.
+  ```
+
+  If "reduction" attribute is set to "sum", the output is a scalar: `sum(loss)`.
+
+  See also https://pytorch.org/docs/stable/nn.html#torch.nn.NLLLoss.
+
+  Example 1:
+
+  ```
+  // negative log likelihood loss, "none" reduction
+  N, C, d1 = 2, 3, 2
+  input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+            [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+  target = [[2, 1], [0, 2]]
+
+  loss = np.zeros((N, d1))
+  for n in range(N):
+      for d_1 in range(d1):
+          c = target[n][d_1]
+          loss[n][d_1] = -input[n][c][d_1]
+
+  // print(loss)
+  // [[-3. -2.]
+  //  [-0. -2.]]
+  ```
+
+  Example 2:
+
+  ```
+  // weighted negative log likelihood loss, sum reduction
+  N, C, d1 = 2, 3, 2
+  input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+          [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+  target = [[2, 1], [0, 2]]
+  weight = [0.2, 0.3, 0.1]
+  loss = np.zeros((N, d1))
+  for n in range(N):
+      for d_1 in range(d1):
+          c = target[n][d_1]
+          loss[n][d_1] = -input[n][c][d_1] * weight[c]
+
+  loss = np.sum(loss)
+  // print(loss)
+  // -1.1
+  ```
+
+  Example 3:
+
+  ```
+  // weighted negative log likelihood loss, mean reduction
+  N, C, d1 = 2, 3, 2
+  input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+          [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+  target = [[2, 1], [0, 2]]
+  weight = [0.2, 0.3, 0.1]
+  loss = np.zeros((N, d1))
+  weight_total = 0
+  for n in range(N):
+      for d_1 in range(d1):
+          c = target[n][d_1]
+          loss[n][d_1] = -input[n][c][d_1] * weight[c]
+          weight_total = weight_total + weight[c]
+
+  loss = np.sum(loss) / weight_total
+  // print(loss)
+  // -1.57
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>ignore_index</tt> : int</dt>
+<dd>Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.</dd>
+<dt><tt>reduction</tt> : string (default is mean)</dt>
+<dd>Type of reduction to apply to loss: none, sum, mean (default). 'none': the output is the loss for each sample. 'sum': the output will be summed. 'mean': the sum of the output will be divided by the sum of applied weights.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of shape (N, C) or (N, C, d1, d2, ..., dk).</dd>
+<dt><tt>target</tt> (non-differentiable) : Tind</dt>
+<dd>Target tensor of shape (N) or (N, d1, d2, ..., dk). Target element value shall be in range of [0, C). If ignore_index is specified, it may have a value outside [0, C) and the target values should either be in the range [0, C) or have the value ignore_index.</dd>
+<dt><tt>weight</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional rescaling weight tensor. If given, it has to be a tensor of size C. Otherwise, it is treated as if having all ones.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>loss</tt> (differentiable) : T</dt>
+<dd>The negative log likelihood loss</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input, weight, and output types to floating-point tensors.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain target to integer types</dd>
+</dl>
+
+### <a name="NonZero-13"></a>**NonZero-13**</a>
+
+  Returns the indices of the elements that are non-zero
+      (in row-major order - by dimension).
+      NonZero behaves similar to numpy.nonzero:
+      https://docs.scipy.org/doc/numpy/reference/generated/numpy.nonzero.html,
+      but for scalar input, NonZero produces output shape (0, N) instead of (1, N), which is different from Numpy's behavior.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to all tensor types.</dd>
+</dl>
+
+### <a name="Pad-13"></a>**Pad-13**</a>
+
+  Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+  a padded tensor (`output`) is generated.
+
+  The three supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+  1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+  2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+  3) `edge` - pads with the edge values of array
+
+
+  Example 1 (`constant` mode):
+    Insert 0 pads to the beginning of the second dimension.
+
+    data =
+    [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+
+    pads = [0, 2, 0, 0]
+
+    mode = 'constant'
+
+    constant_value = 0.0
+
+    output =
+    [
+        [0.0, 0.0, 1.0, 1.2],
+        [0.0, 0.0, 2.3, 3.4],
+        [0.0, 0.0, 4.5, 5.7],
+    ]
+
+
+  Example 2 (`reflect` mode):
+    data =
+    [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+
+    pads = [0, 2, 0, 0]
+
+    mode = 'reflect'
+
+    output =
+    [
+        [1.0, 1.2, 1.0, 1.2],
+        [2.3, 3.4, 2.3, 3.4],
+        [4.5, 5.7, 4.5, 5.7],
+    ]
+
+
+  Example 3 (`edge` mode):
+    data =
+    [
+        [1.0, 1.2],
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ]
+
+    pads = [0, 2, 0, 0]
+
+    mode = 'edge'
+
+    output =
+    [
+        [1.0, 1.0, 1.0, 1.2],
+        [2.3, 2.3, 2.3, 3.4],
+        [4.5, 4.5, 4.5, 5.7],
+    ]
+
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Supported modes: `constant`(default), `reflect`, `edge`</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Input tensor.</dd>
+<dt><tt>pads</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. `pads` should be a 1D tensor of shape [2 * input_rank]. `pads` format should be: [x1_begin, x2_begin,...,x1_end, x2_end,...], where xi_begin is the number of pad values added at the beginning of axis `i` and xi_end, the number of pad values added at the end of axis `i`.</dd>
+<dt><tt>constant_value</tt> (optional, non-differentiable) : T</dt>
+<dd>(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, empty string or False).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Pow-13"></a>**Pow-13**</a>
+
+  Pow takes input data (Tensor<T>) and exponent Tensor, and
+  produces one output data (Tensor<T>) where the function `f(x) = x^exponent`,
+  is applied to the data tensor elementwise.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>First operand, base of the exponent.</dd>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>Second operand, power of the exponent.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input X and output types to float/int tensors.</dd>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input Y types to float/int tensors.</dd>
+</dl>
+
+### <a name="QuantizeLinear-13"></a>**QuantizeLinear-13**</a>
+
+  The linear quantization operator. It consumes a high precision tensor, a scale, and a zero point to compute the low precision / quantized tensor.
+  The scale factor and zero point must have same shape, and can be either a scalar for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+  The quantization formula is y = saturate ((x / y_scale) + y_zero_point).
+  For saturation, it saturates to [0, 255] if it's uint8, or [-128, 127] if it's int8.
+  For (x / y_scale), it's rounding to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details. 'y_zero_point' and 'y' must have same type.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the quantization dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D full precision Input tensor to be quantized.</dd>
+<dt><tt>y_scale</tt> : tensor(float)</dt>
+<dd>Scale for doing quantization to get 'y'. It can be a scalar, which means per-tensor/layer quantization, or a 1-D Tensor for per-axis quantization.</dd>
+<dt><tt>y_zero_point</tt> (optional) : T2</dt>
+<dd>Zero point for doing quantization to get 'y'. Shape must match y_scale. Default is uint8 with zero point of 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T2</dt>
+<dd>N-D quantized output tensor. It has same shape as input 'x'.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(int32)</dt>
+<dd>Constrain 'x' to float or int32 tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain 'y_zero_point' and 'y' to 8-bit integer tensor.</dd>
+</dl>
+
+### <a name="Reciprocal-13"></a>**Reciprocal-13**</a>
+
+  Reciprocal takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the reciprocal is, y = 1/x, is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="ReduceL1-13"></a>**ReduceL1-13**</a>
+
+  Computes the L1 norm of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceL2-13"></a>**ReduceL2-13**</a>
+
+  Computes the L2 norm of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceLogSum-13"></a>**ReduceLogSum-13**</a>
+
+  Computes the log sum of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or undefined otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceLogSumExp-13"></a>**ReduceLogSumExp-13**</a>
+
+  Computes the log sum exponent of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or undefined otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMax-13"></a>**ReduceMax-13**</a>
+
+  Computes the max of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or the minimum value of the data type otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(uint8), tensor(int8)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMean-13"></a>**ReduceMean-13**</a>
+
+  Computes the mean of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields undefined.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMin-13"></a>**ReduceMin-13**</a>
+
+  Computes the min of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields plus infinity (if supported by the datatype) or the maximum value of the data type otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(uint8), tensor(int8)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceProd-13"></a>**ReduceProd-13**</a>
+
+  Computes the product of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 1.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceSum-13"></a>**ReduceSum-13**</a>
+
+  Computes the sum of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceSumSquare-13"></a>**ReduceSumSquare-13**</a>
+
+  Computes the sum square of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>A list of integers, along which to reduce. The default is to reduce over all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="Relu-13"></a>**Relu-13**</a>
+
+  Relu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the rectified linear function, y = max(0, x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Reshape-13"></a>**Reshape-13**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Specified shape for output.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> (differentiable) : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Resize-13"></a>**Resize-13**</a>
+
+  Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
+  Each dimension value of the output tensor is:
+    output_dimension = floor(input_dimension * (roi_end - roi_start) * scale) if input \"sizes\" is not specified.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>coordinate_transformation_mode</tt> : string (default is half_pixel)</dt>
+<dd>
+This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. <br/>
+
+The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
+Denote x_resized as the coordinate of axis x in the resized tensor, x_original as the coordinate of axis x in the original tensor, length_original as the length of the original tensor in axis x, length_resized as the length of the resized tensor in axis x, roi_x = (start_x, end_x) of the axis x in input "roi", scale = length_resized / length_original, <br/>
+
+if coordinate_transformation_mode is "half_pixel", <br/>
+x_original = (x_resized + 0.5) / scale - 0.5, <br/>
+
+if coordinate_transformation_mode is "pytorch_half_pixel", <br/>
+x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0, <br/>
+
+if coordinate_transformation_mode is "align_corners", <br/>
+x_original = x_resized * (length_original - 1) / (length_resized - 1), <br/>
+
+if coordinate_transformation_mode is "asymmetric", <br/>
+x_original = x_resized / scale, <br/>
+
+if coordinate_transformation_mode is "tf_crop_and_resize", <br/>
+x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1).</dd>
+<dt><tt>cubic_coeff_a</tt> : float (default is -0.75)</dt>
+<dd>The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75 (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. This attribute is valid only if "mode" is "cubic".</dd>
+<dt><tt>exclude_outside</tt> : int (default is 0)</dt>
+<dd>If set to 1, the weight of sampling locations outside the tensor will be set to 0 and the weight will be renormalized so that their sum is 1.0. The default value is 0.</dd>
+<dt><tt>extrapolation_value</tt> : float (default is 0.0)</dt>
+<dd>When coordinate_transformation_mode is "tf_crop_and_resize" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f.</dd>
+<dt><tt>mode</tt> : string (default is nearest)</dt>
+<dd>Three interpolation modes: nearest (default), linear and cubic. The "linear" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). The "cubic" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor).</dd>
+<dt><tt>nearest_mode</tt> : string (default is round_prefer_floor)</dt>
+<dd>Four modes: round_prefer_floor (default, as known as round half down), round_prefer_ceil (as known as round half up), floor, ceil. Only used by nearest interpolation. It indicates how to get "nearest" pixel in input tensor from x_original, so this attribute is valid only if "mode" is "nearest".</dd>
+</dl>
+
+#### Inputs (1 - 4)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>N-D tensor</dd>
+<dt><tt>roi</tt> (optional, non-differentiable) : T2</dt>
+<dd>1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is "tf_crop_and_resize"</dd>
+<dt><tt>scales</tt> (optional, non-differentiable) : tensor(float)</dt>
+<dd>The scale array along each dimension. It takes value greater than 0. If it's less than 1, it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should be the same as the rank of input 'X'. One of 'scales' and 'sizes' MUST be specified and it is an error if both are specified. If 'sizes' is needed, the user can use an empty string as the name of 'scales' in this operator's input list.</dd>
+<dt><tt>sizes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>The size of the output tensor. The number of elements of 'sizes' should be the same as the rank of input 'X'. Only one of 'scales' and 'sizes' can be specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>N-D tensor after resizing</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input 'X' and output 'Y' to all tensor types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain roi type to float or double.</dd>
+</dl>
+
+### <a name="ScatterElements-13"></a>**ScatterElements-13**</a>
+
+  ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
+  rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value
+  to values specified by `updates` at specific index positions specified by
+  `indices`. Its output shape is the same as the shape of `data`.
+
+  For each entry in `updates`, the target index in `data` is obtained by combining
+  the corresponding entry in `indices` with the index of the entry itself: the
+  index-value for dimension = axis is obtained from the value of the corresponding
+  entry in `indices` and the index-value for dimension != axis is obtained from the
+  index of the entry itself.
+
+  For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
+  is performed as below:
+  ```
+    output[indices[i][j]][j] = updates[i][j] if axis = 0,
+    output[i][indices[i][j]] = updates[i][j] if axis = 1,
+  ```
+
+  This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+
+  Example 1:
+  ```
+    data = [
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+    ]
+    indices = [
+        [1, 0, 2],
+        [0, 2, 1],
+    ]
+    updates = [
+        [1.0, 1.1, 1.2],
+        [2.0, 2.1, 2.2],
+    ]
+    output = [
+        [2.0, 1.1, 0.0]
+        [1.0, 0.0, 2.2]
+        [0.0, 2.1, 1.2]
+    ]
+  ```
+  Example 2:
+  ```
+    data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+    indices = [[1, 3]]
+    updates = [[1.1, 2.1]]
+    axis = 1
+    output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : Tind</dt>
+<dd>Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+<dt><tt>updates</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >=1 (same rank and shape as indices)</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1 (same rank as input).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input and output types can be of any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="ScatterND-13"></a>**ScatterND-13**</a>
+
+  ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
+  and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value to values
+  specified by `updates` at specific index positions specified by `indices`. Its output shape
+  is the same as the shape of `data`. Note that `indices` should not have duplicate entries.
+  That is, two or more `updates` for the same index-location is not supported.
+
+  `indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
+   `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
+  Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
+  update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
+  update to a slice of the tensor. Index values are allowed to be negative, as per the usual
+  convention for counting backwards from the end, but are expected in the valid range.
+
+  `updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
+  first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
+  The remaining dimensions of `updates` correspond to the dimensions of the
+  replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
+  corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
+  must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
+  of shapes.
+
+  The `output` is calculated via the following equation:
+
+      output = np.copy(data)
+      update_indices = indices.shape[:-1]
+      for idx in np.ndindex(update_indices):
+          output[tuple(indices[idx])] = updates[idx]
+
+  The order of iteration in the above loop is not specified.
+  In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
+  This ensures that the output value does not depend on the iteration order.
+
+  This operator is the inverse of GatherND.
+
+  Example 1:
+  ```
+    data    = [1, 2, 3, 4, 5, 6, 7, 8]
+    indices = [[4], [3], [1], [7]]
+    updates = [9, 10, 11, 12]
+    output  = [1, 11, 3, 10, 9, 6, 7, 12]
+  ```
+
+  Example 2:
+  ```
+    data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+               [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+               [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+               [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+    indices = [[0], [2]]
+    updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+               [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
+    output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+               [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+               [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+               [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of rank q >= 1.</dd>
+<dt><tt>updates</tt> (differentiable) : T</dt>
+<dd>Tensor of rank q + r - indices_shape[-1] - 1.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+### <a name="Shape-13"></a>**Shape-13**</a>
+
+  Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>shape</tt> (non-differentiable) : T1</dt>
+<dd>Shape of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor.</dd>
+</dl>
+
+### <a name="Sigmoid-13"></a>**Sigmoid-13**</a>
+
+  Sigmoid takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the sigmoid function, y = 1 / (1 + exp(-x)), is applied to the
+  tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Sign-13"></a>**Sign-13**</a>
+
+  Calculate the sign of the given input tensor element-wise.
+  If input > 0, output 1. if input < 0, output -1. if input == 0, output 0.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T</dt>
+<dd>The sign of the input tensor computed element-wise. It has the same shape and type of the input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Size-13"></a>**Size-13**</a>
+
+  Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>Total number of elements of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor, which should be a scalar though.</dd>
+</dl>
+
+### <a name="Slice-13"></a>**Slice-13**</a>
+
+  Produces a slice of the input tensor along multiple axes. Similar to numpy:
+  https://numpy.org/doc/stable/user/basics.indexing.html?highlight=slice#slicing-and-striding
+
+  Slice uses the `starts`, `ends`, `axes` and `steps` inputs to select a sub-tensor
+  of its input `data` tensor.
+
+  An effective `starts[i]`, `ends[i]`, and `steps[i]` must be computed for each `i`
+  in `[0, ... r-1]` where `r = rank(input)` as follows:
+
+  If `axes` are omitted, they are set to `[0, ..., r-1]`.
+  If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
+
+  The effective values are initialized as `start[i] = 0`, `ends[i] = dims[i]` where
+  `dims` are the dimensions of `input` and `steps[i] = 1`.
+
+  All negative elements of `axes` are made non-negative by adding `r` to them, where
+  `r =rank(input)`.
+
+  All negative values in `starts[i]` and `ends[i]` have `dims[axes[i]]` added to them,
+  where `dims` are the dimensions of `input`. Then `start[axes[i]]` is the adjusted
+  `starts[i]` is clamped into the range `[0, dims[axes[i]]]` for positive stepping
+  and `[0, dims[axes[i]]-1]` for negative stepping.
+
+  The clamping for the adjusted `ends[i]` depends on the sign of `steps[i]` and must
+  accommodate copying 0 through `dims[axes[i]]` elements, so for positive stepping
+  `ends[axes[i]]` is clamped to `[0, dims[axes[i]]]`, while for negative stepping it
+  is clamped to `[-1, dims[axes[i]]-1]`.
+
+  Finally, `steps[axes[i]] = steps[i]`.
+
+  For slicing to the end of a dimension with unknown size, it is recommended to pass
+  in `INT_MAX` when slicing forward and 'INT_MIN' when slicing backward.
+
+  Example 1:
+
+  ```
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  axes = [0, 1]
+  starts = [1, 0]
+  ends = [2, 3]
+  steps = [1, 2]
+  result = [
+      [5, 7],
+  ]
+  ```
+
+  Example 2:
+
+  ```
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  starts = [0, 1]
+  ends = [-1, 1000]
+  result = [
+      [2, 3, 4],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs (3 - 5)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of data to extract slices from.</dd>
+<dt><tt>starts</tt> (non-differentiable) : Tind</dt>
+<dd>1-D tensor of starting indices of corresponding axis in `axes`</dd>
+<dt><tt>ends</tt> (non-differentiable) : Tind</dt>
+<dd>1-D tensor of ending indices (exclusive) of corresponding axis in `axes`</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of axes that `starts` and `ends` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated.</dd>
+<dt><tt>steps</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of slice step of corresponding axis in `axes`. Negative value means slicing backward. 'steps' cannot be 0. Defaults to 1s.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Sliced data tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="Softmax-13"></a>**Softmax-13**</a>
+
+  The operator computes the normalized exponential values for the given input:
+
+   Softmax(input, axis) = Exp(input) / ReduceSum(Exp(input), axis=axis, keepdims=1)
+
+  The "axis" attribute indicates the dimension along which Softmax
+  will be performed. The output tensor has the same shape
+  and contains the Softmax values of the corresponding input.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>
+Describes the dimension Softmax will be performed on.
+Negative value means counting dimensions
+from the back. Accepted range is [-r, r-1] where r = rank(input).
+</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The input tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output values with the same shape as the input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="SoftmaxCrossEntropyLoss-13"></a>**SoftmaxCrossEntropyLoss-13**</a>
+
+  Loss function that measures the softmax cross entropy
+  between 'scores' and 'labels'.
+  This operator first computes a loss tensor whose shape is identical to the labels input.
+  If the input is 2-D with shape (N, C), the loss tensor may be a N-element vector L = (l_1, l_2, ..., l_N).
+  If the input is N-D tensor with shape (N, C, D1, D2, ..., Dk),
+  the loss tensor L may have (N, D1, D2, ..., Dk) as its shape and L[i,][j_1][j_2]...[j_k] denotes a scalar element in L.
+  After L is available, this operator can optionally do a reduction operator.
+
+  * shape(scores): (N, C) where C is the number of classes, or (N, C, D1, D2,..., Dk),
+    with K >= 1 in case of K-dimensional loss.
+  * shape(labels): (N) where each value is 0 <= labels[i] <= C-1, or (N, D1, D2,..., Dk),
+    with K >= 1 in case of K-dimensional loss.
+
+  The loss for one sample, l_i, can calculated as follows:
+  ```
+  l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk], where i is the index of classes.
+  ```
+  or
+  ```
+  l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk] * weights[c], if 'weights' is provided.
+  ```
+
+  loss is zero for the case when label-value equals ignore_index.
+  ```
+  l[i][d1][d2]...[dk]  = 0, when labels[n][d1][d2]...[dk] = ignore_index
+  ```
+
+  where:
+  ```
+  p = Softmax(scores)
+  y = Log(p)
+  c = labels[i][d1][d2]...[dk]
+  ```
+
+  Finally, L is optionally reduced:
+
+  * If reduction = 'none', the output is L with shape (N, D1, D2, ..., Dk).
+  * If reduction = 'sum', the output is scalar: Sum(L).
+  * If reduction = 'mean', the output is scalar: ReduceMean(L), or if weight is provided: `ReduceSum(L) / ReduceSum(W)`,
+    where tensor W is of shape `(N, D1, D2, ..., Dk)` and `W[n][d1][d2]...[dk] = weights[labels[i][d1][d2]...[dk]]`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>ignore_index</tt> : int</dt>
+<dd>Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.</dd>
+<dt><tt>reduction</tt> : string (default is mean)</dt>
+<dd>Type of reduction to apply to loss: none, sum, mean(default). 'none': no reduction will be applied, 'sum': the output will be summed. 'mean': the sum of the output will be divided by the number of elements in the output.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>scores</tt> (differentiable) : T</dt>
+<dd>The predicted outputs with shape [batch_size, class_size], or [batch_size, class_size, D1, D2 , ..., Dk], where K is the number of dimensions.</dd>
+<dt><tt>labels</tt> (non-differentiable) : Tind</dt>
+<dd>The ground truth output tensor, with shape [batch_size], or [batch_size, D1, D2, ..., Dk], where K is the number of dimensions. Labels element value shall be in range of [0, C). If ignore_index is specified, it may have a value outside [0, C) and the label values should either be in the range [0, C) or have the value ignore_index.</dd>
+<dt><tt>weights</tt> (optional, non-differentiable) : T</dt>
+<dd>A manual rescaling weight given to each class. If given, it has to be a 1D Tensor assigning weight to each of the classes. Otherwise, it is treated as if having all ones.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Weighted loss float Tensor. If reduction is 'none', this has the shape of [batch_size], or [batch_size, D1, D2, ..., Dk] in case of K-dimensional loss. Otherwise, it is a scalar.</dd>
+<dt><tt>log_prob</tt> (optional, differentiable) : T</dt>
+<dd>Log probability tensor. If the output of softmax is prob, its value is log(prob).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain target to integer types</dd>
+</dl>
+
+### <a name="SpaceToDepth-13"></a>**SpaceToDepth-13**</a>
+
+  SpaceToDepth rearranges blocks of spatial data into depth. More specifically,
+  this op outputs a copy of the input tensor where values from the height and width dimensions
+  are moved to the depth dimension.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>blocksize</tt> : int (required)</dt>
+<dd>Blocks of [blocksize, blocksize] are moved.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor of [N, C * blocksize * blocksize, H/blocksize, W/blocksize].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Split-13"></a>**Split-13**</a>
+
+  Split a tensor into a list of tensors, along the specified
+  'axis'. Lengths of the parts can be specified using input 'split'.
+  Otherwise, the tensor is split to equal sized parts.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to split on. A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] where r = rank(input).</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The tensor to split</dd>
+<dt><tt>split</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional length of each output. Values should be >= 0.Sum of the values must be equal to the dim value at 'axis' specified.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, differentiable) : T</dt>
+<dd>One or more outputs forming list of tensors after splitting</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Sqrt-13"></a>**Sqrt-13**</a>
+
+  Square root takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the square root is, y = x^0.5, is applied to
+  the tensor elementwise. If x is negative, then it will return NaN.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Squeeze-13"></a>**Squeeze-13**</a>
+
+  Remove single-dimensional entries from the shape of a tensor.
+  Takes an input `axes` with a list of axes to squeeze.
+  If `axes` is not provided, all the single dimensions will be removed from
+  the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensors with at least max(dims) dimensions.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>List of integers indicating the dimensions to squeeze. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>squeezed</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Sub-13"></a>**Sub-13**</a>
+
+  Performs element-wise binary subtraction (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+### <a name="Sum-13"></a>**Sum-13**</a>
+
+  Element-wise sum of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for sum.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>sum</tt> (differentiable) : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Tanh-13"></a>**Tanh-13**</a>
+
+  Calculates the hyperbolic tangent of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic tangent values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Tile-13"></a>**Tile-13**</a>
+
+  Constructs a tensor by tiling a given tensor.
+  This is the same as function `tile` in Numpy, but no broadcast.
+  For example A = [[1, 2], [3, 4]], B = [1, 2], tile(A, B) = [[1, 2, 1, 2], [3, 4, 3, 4]]
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of any shape.</dd>
+<dt><tt>repeats</tt> (non-differentiable) : T1</dt>
+<dd>1D int64 tensor of the same length as input's dimension number, includes numbers of repeated copies along input's dimensions.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor of the same dimensions and type as tensor input. output_dim[i] = input_dim[i] * repeats[i]</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain repeat's type to int64 tensors.</dd>
+</dl>
+
+### <a name="Transpose-13"></a>**Transpose-13**</a>
+
+  Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+  The optional attribute `perm` must be a permutation of the dimensions of
+  the input tensor. Axis `i` of the output tensor corresponds to the axis
+  `perm[i]` of the input tensor.
+  For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 1, 3).
+  When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 3, 1).
+  If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+  where `n` is the rank of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>perm</tt> : list of ints</dt>
+<dd>A list of integers. By default, reverse the dimensions, otherwise permute the axes according to the values given.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>transposed</tt> (differentiable) : T</dt>
+<dd>Transposed output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Unsqueeze-13"></a>**Unsqueeze-13**</a>
+
+  Insert single-dimensional entries to the shape of an input tensor (`data`).
+  Takes one required input `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).
+
+  For example, given an input tensor (`data`) of shape [3, 4, 5], then
+  Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].
+
+  The input `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
+  The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
+  Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
+  The order of values in `axes` does not matter and can come in any order.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Original tensor</dd>
+<dt><tt>axes</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>List of integers indicating the dimensions to be inserted. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(expanded).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>expanded</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+## Version 14 of the default ONNX operator set
+### <a name="Add-14"></a>**Add-14**</a>
+
+  Performs element-wise binary addition (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="BatchNormalization-14"></a>**BatchNormalization-14**</a>
+
+  Carries out batch normalization as described in the paper
+  https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+  There are five required inputs 'X', 'scale', 'B', 'input_mean' and
+  'input_var'.
+  Note that 'input_mean' and 'input_var' are expected to be the estimated
+  statistics in inference mode (training_mode=False, default),
+  and the running statistics in training mode (training_mode=True).
+  There are multiple cases for the number of outputs, which we list below:
+
+  Output case #1: Y, running_mean, running_var (training_mode=True)
+  Output case #2: Y (training_mode=False)
+
+  When training_mode=False, extra outputs are invalid.
+  The outputs are updated as follows when training_mode=True:
+  ```
+  running_mean = input_mean * momentum + current_mean * (1 - momentum)
+  running_var = input_var * momentum + current_var * (1 - momentum)
+
+  Y = (X - current_mean) / sqrt(current_var + epsilon) * scale + B
+
+  where:
+
+  current_mean = ReduceMean(X, axis=all_except_channel_index)
+  current_var =  ReduceVar(X, axis=all_except_channel_index)
+
+  Notice that ReduceVar refers to the population variance, and it equals to
+  sum(sqrd(x_i - x_avg)) / N
+  where N is the population size (this formula does not use sample size N - 1).
+
+  ```
+
+  When training_mode=False:
+  ```
+  Y = (X - input_mean) / sqrt(input_var + epsilon) * scale + B
+  ```
+
+  For previous (depreciated) non-spatial cases, implementors are suggested
+  to flatten the input shape to (N x C * D1 * D2 * ... * Dn) before a BatchNormalization Op.
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>momentum</tt> : float (default is 0.9)</dt>
+<dd>Factor used in computing the running mean and variance.e.g., running_mean = running_mean * momentum + mean * (1 - momentum).</dd>
+<dt><tt>training_mode</tt> : int (default is 0)</dt>
+<dd>If set to true, it indicates BatchNormalization is being used for training, and outputs 1, 2, 3, and 4 would be populated.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size, C is the number of channels. Statistics are computed for every channel of C over N and D1 to Dn dimensions. For image data, input dimensions become (N x C x H x W). The op also accepts single dimension input of size N in which case C is assumed to be 1</dd>
+<dt><tt>scale</tt> (differentiable) : T</dt>
+<dd>Scale tensor of shape (C).</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Bias tensor of shape (C).</dd>
+<dt><tt>input_mean</tt> (differentiable) : U</dt>
+<dd>running (training) or estimated (testing) mean tensor of shape (C).</dd>
+<dt><tt>input_var</tt> (differentiable) : U</dt>
+<dd>running (training) or estimated (testing) variance tensor of shape (C).</dd>
+</dl>
+
+#### Outputs (1 - 3)
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>The output tensor of the same shape as X</dd>
+<dt><tt>running_mean</tt> (optional, non-differentiable) : U</dt>
+<dd>The running mean after the BatchNormalization operator.</dd>
+<dt><tt>running_var</tt> (optional, non-differentiable) : U</dt>
+<dd>The running variance after the BatchNormalization operator. This op uses the population size (N) for calculating variance, and not the sample size N-1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>U</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain mean and variance types to float tensors. It allows all float type for U.</dd>
+</dl>
+
+### <a name="CumSum-14"></a>**CumSum-14**</a>
+
+  Performs cumulative sum of the input elements along the given axis.
+  By default, it will do the sum inclusively meaning the first element is copied as is.
+  Through an `exclusive` attribute, this behavior can change to exclude the first element.
+  It can also perform summation in the opposite direction of the axis. For that, set `reverse` attribute to 1.
+
+  Example:
+  ```
+  input_x = [1, 2, 3]
+  axis=0
+  output = [1, 3, 6]
+  exclusive=1
+  output = [0, 1, 3]
+  exclusive=0
+  reverse=1
+  output = [6, 5, 3]
+  exclusive=1
+  reverse=1
+  output = [5, 3, 0]
+  ```
+
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>exclusive</tt> : int (default is 0)</dt>
+<dd>If set to 1 will return exclusive sum in which the top element is not included. In other terms, if set to 1, the j-th output element would be the sum of the first (j-1) elements. Otherwise, it would be the sum of the first j elements.</dd>
+<dt><tt>reverse</tt> : int (default is 0)</dt>
+<dd>If set to 1 will perform the sums in reverse direction.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>x</tt> (differentiable) : T</dt>
+<dd>An input tensor that is to be processed.</dd>
+<dt><tt>axis</tt> (non-differentiable) : T2</dt>
+<dd>A 0-D tensor. Must be in the range [-rank(x), rank(x)-1]. Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> (differentiable) : T</dt>
+<dd>Output tensor of the same type as 'x' with cumulative sums of the x's elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>axis tensor can be int32 or int64 only</dd>
+</dl>
+
+### <a name="Div-14"></a>**Div-14**</a>
+
+  Performs element-wise binary division (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  For integer inputs, the result is computed using truncating division (rounding toward zero).
+  (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="GRU-14"></a>**GRU-14**</a>
+
+  Computes an one-layer GRU. This operator is usually supported via some custom
+  implementation such as CuDNN.
+
+  Notations:
+
+  * `X` - input tensor
+  * `z` - update gate
+  * `r` - reset gate
+  * `h` - hidden gate
+  * `t` - time step (t-1 means previous time step)
+  * `W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+  * `R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+  * `Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+  * `Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+  * `WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+  * `RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+  * `WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+  * `RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+  * `H` - Hidden state
+  * `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+  * Relu(x)                - max(0, x)
+  * Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+  * Sigmoid(x)             - 1/(1 + e^{-x})
+
+  NOTE:
+    Below are optional
+
+  * Affine(x)              - alpha * x + beta
+  * LeakyRelu(x)           - x if x >= 0 else alpha * x
+  * ThresholdedRelu(x)     - x if x >= alpha else 0
+  * ScaledTanh(x)          - alpha * Tanh(beta * x)
+  * HardSigmoid(x)         - min(max(alpha * x + beta, 0), 1)
+  * Elu(x)                 - x if x >= 0 else alpha * (e^x - 1)
+  * Softsign(x)            - x/(1 + |x|)
+  * Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh):
+
+  * zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz)
+  * rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr)
+  * ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # default, when linear_before_reset = 0
+  * ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset != 0
+  * Ht = (1 - zt) (.) ht + zt (.) Ht-1
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 2 (or 4 if bidirectional) activation functions for update, reset, and hidden gates. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>layout</tt> : int (default is 0)</dt>
+<dd>The shape format of inputs X, initial_h and outputs Y, Y_h. If 0, the following shapes are expected: X.shape = [seq_length, batch_size, input_size], Y.shape = [seq_length, num_directions, batch_size, hidden_size], initial_h.shape = Y_h.shape = [num_directions, batch_size, hidden_size]. If 1, the following shapes are expected: X.shape = [batch_size, seq_length, input_size], Y.shape = [batch_size, seq_length, num_directions, hidden_size], initial_h.shape = Y_h.shape = [batch_size, num_directions, hidden_size].</dd>
+<dt><tt>linear_before_reset</tt> : int (default is 0)</dt>
+<dd>When computing the output of the hidden gate, apply the linear transformation before multiplying by the output of the reset gate.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> (differentiable) : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and `[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 6*hidden_size]`. Optional: If not specified - assumed to be 0</dd>
+<dt><tt>sequence_lens</tt> (optional, non-differentiable) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional, differentiable) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="HardSwish-14"></a>**HardSwish-14**</a>
+
+  HardSwish takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where
+  the HardSwish function, y = x * max(0, min(1, alpha * x + beta)) = x * HardSigmoid<alpha, beta>(x),
+  where alpha = 1/6 and beta = 0.5, is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Identity-14"></a>**Identity-14**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : V</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : V</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input and output types to all tensor and sequence types.</dd>
+</dl>
+
+### <a name="LSTM-14"></a>**LSTM-14**</a>
+
+  Computes an one-layer LSTM. This operator is usually supported via some
+  custom implementation such as CuDNN.
+
+  Notations:
+
+  * `X` - input tensor
+  * `i` - input gate
+  * `o` - output gate
+  * `f` - forget gate
+  * `c` - cell gate
+  * `t` - time step (t-1 means previous time step)
+  * `W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
+  * `R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
+  * `Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
+  * `Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
+  * `P[iof]`  - P peephole weight vector for input, output, and forget gates
+  * `WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
+  * `RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
+  * `WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
+  * `RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
+  * `PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
+  * `H` - Hidden state
+  * `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+  * Relu(x)                - max(0, x)
+  * Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+  * Sigmoid(x)             - 1/(1 + e^{-x})
+
+  NOTE: Below are optional
+
+  * Affine(x)              - alpha*x + beta
+  * LeakyRelu(x)           - x if x >= 0 else alpha * x
+  * ThresholdedRelu(x)     - x if x >= alpha else 0
+  * ScaledTanh(x)          - alpha*Tanh(beta*x)
+  * HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+  * Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+  * Softsign(x)            - x/(1 + |x|)
+  * Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh, h=Tanh):
+
+  * it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi)
+  * ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf)
+  * ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc)
+  * Ct = ft (.) Ct-1 + it (.) ct
+  * ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.) Ct + Wbo + Rbo)
+  * Ht = ot (.) h(Ct)
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 3 (or 6 if bidirectional) activation functions for input, output, forget, cell, and hidden. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>input_forget</tt> : int (default is 0)</dt>
+<dd>Couple the input and forget gates if 1.</dd>
+<dt><tt>layout</tt> : int (default is 0)</dt>
+<dd>The shape format of inputs X, initial_h, initial_c and outputs Y, Y_h, Y_c. If 0, the following shapes are expected: X.shape = [seq_length, batch_size, input_size], Y.shape = [seq_length, num_directions, batch_size, hidden_size], initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = [num_directions, batch_size, hidden_size]. If 1, the following shapes are expected: X.shape = [batch_size, seq_length, input_size], Y.shape = [batch_size, seq_length, num_directions, hidden_size], initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = [batch_size, num_directions, hidden_size].</dd>
+</dl>
+
+#### Inputs (3 - 8)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[iofc]` and `WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape `[num_directions, 4*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> (differentiable) : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[iofc]` and `RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 4*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional, non-differentiable) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>initial_c</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the cell. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>P</tt> (optional, differentiable) : T</dt>
+<dd>The weight tensor for peepholes. Concatenation of `P[iof]` and `PB[iof]` (if bidirectional) along dimension 0. It has shape `[num_directions, 3*hidde_size]`. Optional: If not specified - assumed to be 0.</dd>
+</dl>
+
+#### Outputs (0 - 3)
+
+<dl>
+<dt><tt>Y</tt> (optional, differentiable) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>Y_c</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the cell. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="Mul-14"></a>**Mul-14**</a>
+
+  Performs element-wise binary multiplication (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="RNN-14"></a>**RNN-14**</a>
+
+  Computes an one-layer simple RNN. This operator is usually supported
+  via some custom implementation such as CuDNN.
+
+  Notations:
+
+  * `X` - input tensor
+  * `i` - input gate
+  * `t` - time step (t-1 means previous time step)
+  * `Wi` - W parameter weight matrix for input gate
+  * `Ri` - R recurrence weight matrix for input gate
+  * `Wbi` - W parameter bias vector for input gate
+  * `Rbi` - R parameter bias vector for input gate
+  * `WBi` - W parameter weight matrix for backward input gate
+  * `RBi` - R recurrence weight matrix for backward input gate
+  * `WBbi` - WR bias vectors for backward input gate
+  * `RBbi` - RR bias vectors for backward input gate
+  * `H` - Hidden state
+  * `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+  * Relu(x)                - max(0, x)
+  * Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+  * Sigmoid(x)             - 1/(1 + e^{-x})
+
+  NOTE: Below are optional
+
+  * Affine(x)              - alpha*x + beta
+  * LeakyRelu(x)           - x if x >= 0 else alpha * x
+  * ThresholdedRelu(x)     - x if x >= alpha else 0
+  * ScaledTanh(x)          - alpha*Tanh(beta*x)
+  * HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+  * Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+  * Softsign(x)            - x/(1 + |x|)
+  * Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Tanh):
+
+  * Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi)
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings (default is ['Tanh', 'Tanh'])</dt>
+<dd>One (or two if bidirectional) activation function for input gate. The activation function must be one of the activation functions specified above. Optional: Default `Tanh` if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>layout</tt> : int (default is 0)</dt>
+<dd>The shape format of inputs X, initial_h and outputs Y, Y_h. If 0, the following shapes are expected: X.shape = [seq_length, batch_size, input_size], Y.shape = [seq_length, num_directions, batch_size, hidden_size], initial_h.shape = Y_h.shape = [num_directions, batch_size, hidden_size]. If 1, the following shapes are expected: X.shape = [batch_size, seq_length, input_size], Y.shape = [batch_size, seq_length, num_directions, hidden_size], initial_h.shape = Y_h.shape = [batch_size, num_directions, hidden_size].</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor for input gate. Concatenation of `Wi` and `WBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> (differentiable) : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `Ri` and `RBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` and `[WBbi, RBbi]` (if bidirectional). The tensor has shape `[num_directions, 2*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional, non-differentiable) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional, differentiable) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="Relu-14"></a>**Relu-14**</a>
+
+  Relu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the rectified linear function, y = max(0, x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(int32), tensor(int8), tensor(int16), tensor(int64), tensor(float16), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to signed numeric tensors.</dd>
+</dl>
+
+### <a name="Reshape-14"></a>**Reshape-14**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). If 'allowzero' is set, and the new shape includes 0, the
+  dimension will be set explicitly to zero (i.e. not taken from input tensor).
+  Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+  If the attribute 'allowzero' is set, it is invalid for the specified shape to
+  contain both a zero value and -1, as the value of the dimension corresponding
+  to -1 cannot be determined uniquely.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>allowzero</tt> : int (default is 0)</dt>
+<dd>(Optional) By default, when any value in the 'shape' input is equal to zero the corresponding dimension value is copied from the input tensor dynamically. allowzero=1 indicates that if any value in the 'shape' input is set to zero, the zero value is honored, similar to NumPy.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Specified shape for output.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> (differentiable) : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Sub-14"></a>**Sub-14**</a>
+
+  Performs element-wise binary subtraction (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+### <a name="Trilu-14"></a>**Trilu-14**</a>
+
+  Given a 2-D matrix or batches of 2-D matrices, returns the upper or lower triangular part of the tensor(s).
+  The attribute "upper" determines whether the upper or lower part is retained. If set to true,
+  the upper triangular matrix is retained. Lower triangular matrix is retained otherwise.
+  Default value for the "upper" attribute is true.
+  Trilu takes one input tensor of shape [*, N, M], where * is zero or more batch dimensions. The upper triangular part consists
+  of the elements on and above the given diagonal (k). The lower triangular part consists of elements on and below the diagonal.
+  All other elements in the matrix are set to zero.
+  If k = 0, the triangular part on and above/below the main diagonal is retained.
+  If upper is set to true, a positive k retains the upper triangular matrix excluding the main diagonal and (k-1) diagonals above it.
+  A negative k value retains the main diagonal and |k| diagonals below it.
+  If upper is set to false, a positive k retains the lower triangular matrix including the main diagonal and k diagonals above it.
+  A negative k value excludes the main diagonal and (|k|-1) diagonals below it.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>upper</tt> : int (default is 1)</dt>
+<dd>Boolean. Indicates whether upper or lower part of matrix is retained. Default is true.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of rank 2 or higher.</dd>
+<dt><tt>k</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>A 0-D tensor containing a single value corresponding to the number diagonals above or below the main diagonal to exclude or include. Default value is 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor of the same type and shape as the input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+## Version 15 of the default ONNX operator set
+### <a name="BatchNormalization-15"></a>**BatchNormalization-15**</a>
+
+  Carries out batch normalization as described in the paper
+  https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+  There are five required inputs 'X', 'scale', 'B', 'input_mean' and
+  'input_var'.
+  Note that 'input_mean' and 'input_var' are expected to be the estimated
+  statistics in inference mode (training_mode=False, default),
+  and the running statistics in training mode (training_mode=True).
+  There are multiple cases for the number of outputs, which we list below:
+
+  * Output case #1: Y, running_mean, running_var (training_mode=True)
+  * Output case #2: Y (training_mode=False)
+
+  When training_mode=False, extra outputs are invalid.
+  The outputs are updated as follows when training_mode=True:
+  ```
+  running_mean = input_mean * momentum + current_mean * (1 - momentum)
+  running_var = input_var * momentum + current_var * (1 - momentum)
+
+  Y = (X - current_mean) / sqrt(current_var + epsilon) * scale + B
+  ```
+  where:
+  ```
+  current_mean = ReduceMean(X, axis=all_except_channel_index)
+  current_var =  ReduceVar(X, axis=all_except_channel_index)
+  ```
+  Notice that `ReduceVar` refers to the population variance, and it equals to
+  `sum(sqrd(x_i - x_avg)) / N`
+  where `N` is the population size (this formula does not use sample size `N - 1`).
+
+  The computation of ReduceMean and ReduceVar uses float to avoid overflow for float16 inputs.
+
+  When training_mode=False:
+  ```
+  Y = (X - input_mean) / sqrt(input_var + epsilon) * scale + B
+  ```
+
+  For previous (depreciated) non-spatial cases, implementors are suggested
+  to flatten the input shape to (N x C * D1 * D2 * ... * Dn) before a BatchNormalization Op.
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>momentum</tt> : float (default is 0.9)</dt>
+<dd>Factor used in computing the running mean and variance.e.g., running_mean = running_mean * momentum + mean * (1 - momentum).</dd>
+<dt><tt>training_mode</tt> : int (default is 0)</dt>
+<dd>If set to true, it indicates BatchNormalization is being used for training, and outputs 1 and 2 are to be computed.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size, C is the number of channels. Statistics are computed for every channel of C over N and D1 to Dn dimensions. For image data, input dimensions become (N x C x H x W). The op also accepts single dimension input of size N in which case C is assumed to be 1</dd>
+<dt><tt>scale</tt> (differentiable) : T1</dt>
+<dd>Scale tensor of shape (C).</dd>
+<dt><tt>B</tt> (differentiable) : T1</dt>
+<dd>Bias tensor of shape (C).</dd>
+<dt><tt>input_mean</tt> (differentiable) : T2</dt>
+<dd>running (training) or estimated (testing) mean tensor of shape (C).</dd>
+<dt><tt>input_var</tt> (differentiable) : T2</dt>
+<dd>running (training) or estimated (testing) variance tensor of shape (C).</dd>
+</dl>
+
+#### Outputs (1 - 3)
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>The output tensor of the same shape as X</dd>
+<dt><tt>running_mean</tt> (optional, non-differentiable) : T2</dt>
+<dd>The running mean after the BatchNormalization operator.</dd>
+<dt><tt>running_var</tt> (optional, non-differentiable) : T2</dt>
+<dd>The running variance after the BatchNormalization operator. This op uses the population size (N) for calculating variance, and not the sample size N-1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain scale and bias types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain mean and variance types to float tensors.</dd>
+</dl>
+
+### <a name="Bernoulli-15"></a>**Bernoulli-15**</a>
+
+  Draws binary random numbers (0 or 1) from a Bernoulli distribution. The input tensor should be a tensor
+  containing probabilities p (a value in the range [0,1]) to be used for drawing the binary random number,
+  where an output of 1 is produced with probability p and an output of 0 is produced with probability (1-p).
+
+  This operator is non-deterministic and may not produce the same values in different
+  implementations (even if a seed is specified).
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>The data type for the elements of the output tensor. if not specified, we will use the data type of the input tensor.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>All values in input have to be in the range:[0, 1].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>The returned output tensor only has values 0 or 1, same shape as input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bool)</dt>
+<dd>Constrain output types to all numeric tensors and bool tensors.</dd>
+</dl>
+
+### <a name="CastLike-15"></a>**CastLike-15**</a>
+
+  The operator casts the elements of a given input tensor (the first input) to
+  the same data type as the elements of the second input tensor.
+  See documentation of the Cast operator for further details.
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+<dt><tt>target_type</tt> (non-differentiable) : T2</dt>
+<dd>The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor produced by casting the first input tensor to have the same type as the second input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="Optional-15"></a>**Optional-15**</a>
+
+  Constructs an optional-type value containing either an empty optional of a certain type specified by the attribute,
+  or a non-empty value containing the input element.
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>type</tt> : type_proto</dt>
+<dd>Type of the element in the optional output</dd>
+</dl>
+
+#### Inputs (0 - 1)
+
+<dl>
+<dt><tt>input</tt> (optional) : V</dt>
+<dd>The input element.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : O</dt>
+<dd>The optional output enclosing the input element.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input type to all tensor and sequence types.</dd>
+<dt><tt>O</tt> : optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain output type to all optional tensor or optional sequence types.</dd>
+</dl>
+
+### <a name="OptionalGetElement-15"></a>**OptionalGetElement-15**</a>
+
+  Outputs the element in the optional-type input. It is an error if the input value does not have an element
+  and the behavior is undefined in this case.
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : O</dt>
+<dd>The optional input.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : V</dt>
+<dd>Output element in the optional input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>O</tt> : optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain input type to optional tensor and optional sequence types.</dd>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output type to all tensor or sequence types.</dd>
+</dl>
+
+### <a name="OptionalHasElement-15"></a>**OptionalHasElement-15**</a>
+
+  Returns true if the optional-type input contains an element. If it is an empty optional-type, this op returns false.
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : O</dt>
+<dd>The optional input.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : B</dt>
+<dd>A scalar boolean tensor. If true, it indicates that optional-type input contains an element. Otherwise, it is empty.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>O</tt> : optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain input type to optional tensor and optional sequence types.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Constrain output to a boolean tensor.</dd>
+</dl>
+
+### <a name="Pow-15"></a>**Pow-15**</a>
+
+  Pow takes input data (Tensor<T>) and exponent Tensor, and
+  produces one output data (Tensor<T>) where the function `f(x) = x^exponent`,
+  is applied to the data tensor elementwise.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>First operand, base of the exponent.</dd>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>Second operand, power of the exponent.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input X and output types to float/int tensors.</dd>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input Y types to float/int tensors.</dd>
+</dl>
+
+### <a name="Shape-15"></a>**Shape-15**</a>
+
+  Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+  Optional attributes start and end can be used to compute a slice of the input tensor's shape.
+  If start axis is omitted, the slice starts from axis 0.
+  The end axis, if specified, is exclusive (and the returned value will not include the size of that axis).
+  If the end axis is omitted, the axes upto the last one will be included.
+  Negative axes indicate counting back from the last axis.
+  Note that axes will be clamped to the range [0, r], where r is the
+  rank of the input tensor if they are out-of-range (after adding r in the case of
+  negative axis). Thus, specifying any end value > r is equivalent to specifying an end
+  value of r, and specifying any start value < -r is equivalent to specifying a start
+  value of 0. If start > end, the result will be an empty shape.
+
+  Examples:
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  No attributes specified.
+  Output: [2, 3, 4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: -1
+  Output: [4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  end: -1
+  Output: [2, 3]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: 1
+  end: 2
+  Output: [3]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>end</tt> : int</dt>
+<dd>(Optional) Ending axis for slicing the shape. Negative value means counting dimensions from the back. If omitted, sizes of all axes upto (including) the last one will be included.</dd>
+<dt><tt>start</tt> : int (default is 0)</dt>
+<dd>(Optional) Starting axis for slicing the shape. Default value is 0.Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>shape</tt> (non-differentiable) : T1</dt>
+<dd>Shape of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor.</dd>
+</dl>
+
+## Version 16 of the default ONNX operator set
+### <a name="GreaterOrEqual-16"></a>**GreaterOrEqual-16**</a>
+
+  Returns the tensor resulted from performing the `greater_equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="GridSample-16"></a>**GridSample-16**</a>
+
+  Given an input `X` and a flow-field `grid`, computes the output `Y` using `X` values and pixel locations from `grid`.
+  Currently, only spatial (4-D) inputs are supported. For input `X` with shape (N, C, H, W) and `grid` with shape (N, H_out, W_out, 2),
+  the output `Y` will have shape (N, C, H_out, W_out).
+
+  The tensor `X` contains values at centers of square pixels in a H by W 2-dimensional image.
+  The tensor `grid` describes normalized positions where the output `Y` is to be computed
+  using a specified interpolation method (the mode) and a padding mode (for grid positions falling outside the 2-dimensional image).
+
+  Elements in `grid[N, H_out, W_out]` are size-2 vectors specifying positions in the 2-dimensional space of `X`.
+  They are used to interpolate output values of `Y[N, C, H_out, W_out]`.
+
+  The GridSample operator is often used in doing grid generator and sampler in the [Spatial Transformer Networks](https://arxiv.org/abs/1506.02025).
+  See also in [torch.nn.functional.grid_sample](https://pytorch.org/docs/master/generated/torch.nn.functional.grid_sample.html#torch-nn-functional-grid-sample).
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>align_corners</tt> : int (default is 0)</dt>
+<dd>If align_corners=1, the extrema (-1 and 1) are considered as referring to the center points of the input's corner pixels. If align_corners=0, they are instead considered as referring to the corner points of the input's corner pixels, making the sampling more resolution agnostic.</dd>
+<dt><tt>mode</tt> : string (default is bilinear)</dt>
+<dd>Three interpolation modes: bilinear (default), nearest and bicubic.</dd>
+<dt><tt>padding_mode</tt> : string (default is zeros)</dt>
+<dd>Support padding modes for outside grid values: `zeros`(default), `border`, `reflection`. zeros: use 0 for out-of-bound grid locations, border: use border values for out-of-bound grid locations, reflection: use values at locations reflected by the border for out-of-bound grid locations. If index 0 represents the margin pixel, the reflected value at index -1 will be the same as the value at index 1. For location far away from the border, it will keep being reflected until becoming in bound. If pixel location x = -3.5 reflects by border -1 and becomes x' = 1.5, then reflects by border 1 and becomes x'' = 0.5.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>4-D tensor of shape (N, C, H, W), where N is the batch size, C is the numbers of channels, H and W are the height and width of the input data.</dd>
+<dt><tt>grid</tt> (non-differentiable) : T2</dt>
+<dd>Input offset, 4-D tensor of shape (N, H_out, W_out, 2), where H_out and W_out are the height and width of grid and output, Grid specifies the sampling pixel locations normalized by the input spatial dimensions. Therefore, it should have most values in the range of [-1, 1]. If grid has values outside the range of [-1, 1], the corresponding outputs will be handled as defined by padding_mode.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>4-D tensor of shape (N, C, H_out, W_out) of sampled values. For integer input types, intermediate values are computed as floating point and cast to integer at the end.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input `X` and output `Y` types to all tensor types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain grid types to float tensors.</dd>
+</dl>
+
+### <a name="Identity-16"></a>**Identity-16**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : V</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : V</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain input and output types to all tensor, sequence, and optional types.</dd>
+</dl>
+
+### <a name="If-16"></a>**If-16**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same data type. The `then_branch` and `else_branch` may produce tensors with the same element type and different shapes. If corresponding outputs from the then-branch and the else-branch have static shapes S1 and S2, then the shape of the corresponding output variable of the if-node (if present) must be compatible with both S1 and S2 as it represents the union of both possible shapes.For example, if in a model file, the first output of `then_branch` is typed float tensor with shape [2] and the first output of `else_branch` is another float tensor with shape [3], If's first output should have (a) no shape set, or (b) a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) a shape of rank 1 with a unique `dim_param`. In contrast, the first output cannot have the shape [2] since [2] and [3] are not compatible.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv4.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+### <a name="LeakyRelu-16"></a>**LeakyRelu-16**</a>
+
+  LeakyRelu takes input data (Tensor<T>) and an argument alpha, and produces one
+  output data (Tensor<T>) where the function `f(x) = alpha * x for x < 0`,
+  `f(x) = x for x >= 0`, is applied to the data tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.01)</dt>
+<dd>Coefficient of leakage.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LessOrEqual-16"></a>**LessOrEqual-16**</a>
+
+  Returns the tensor resulted from performing the `less_equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Loop-16"></a>**Loop-16**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+  * input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+  * input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+  * input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]           // iteration number
+        %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+        %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+      ) {
+        %my_local = Add(%a, %b_in)
+        %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+        %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+        %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+        return %keepgoing_out, %b_out, %user_defined_val
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        /* initialize loop-carried variables and scan-output variables */
+        bool keepgoing_out = keepgoing
+        int b_out = b
+
+        for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+          /* Implicitly-defined code: bind actual parameter values
+             to formal parameter variables of loop-body */
+          bool keepgoing_in = keepgoing_out;
+          bool b_in = b_out;
+
+          /* User-defined code (loop body) */
+          int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+          b_out = a - b_in;
+          keepgoing_out = my_local > b_out;
+          user_defined_val = b_in + b_in; // b_in and b_out are different variables
+          /* End user-defined code */
+
+          /* Implicitly defined-code */
+          user_defined_vals[i] = user_defined_val // accumulate scan-output values
+        }
+        // int t = my_local; // Can't do this. my_local is not accessible here.
+
+        // The values below are bound to the output variables of the loop and therefore accessible
+        // b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any values computed in the loop body that needs to be used in a subsequent
+     iteration or after the loop are modeled using a pair of variables in the loop-body,
+     consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+     These are referred to as loop-carried dependences. The loop operation node
+     supplies the input value of the input variable for the first iteration, and
+     returns the output value of the output variable produced by the final
+     iteration.
+  3) Scan_output variables are used to implicitly concatenate values computed across
+     all the iterations. In the above example, the value of user_defined_val computed
+     over all iterations are concatenated and returned as the value of user_defined_vals
+     after the loop.
+  4) Values created in the body cannot be accessed in the enclosing scope,
+     except using the mechanism described above.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+  The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs. Scan outputs must be Tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv4.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+### <a name="PRelu-16"></a>**PRelu-16**</a>
+
+  PRelu takes input data (Tensor<T>) and slope tensor as input, and produces one
+  output data (Tensor<T>) where the function `f(x) = slope * x for x < 0`,
+  `f(x) = x for x >= 0`., is applied to the data tensor elementwise.
+  This operator supports **unidirectional broadcasting** (tensor slope should be unidirectional broadcastable to input tensor X); for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+<dt><tt>slope</tt> (differentiable) : T</dt>
+<dd>Slope tensor. The shape of slope can be smaller than first input X; if so, its shape must be unidirectional broadcastable to X</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor (same size as X)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+### <a name="RoiAlign-16"></a>**RoiAlign-16**</a>
+
+  Region of Interest (RoI) align operation described in the
+  [Mask R-CNN paper](https://arxiv.org/abs/1703.06870).
+  RoiAlign consumes an input tensor X and region of interests (rois)
+  to apply pooling across each RoI; it produces a 4-D tensor of shape
+  (num_rois, C, output_height, output_width).
+
+  RoiAlign is proposed to avoid the misalignment by removing
+  quantizations while converting from original image into feature
+  map and from feature map into RoI feature; in each ROI bin,
+  the value of the sampled locations are computed directly
+  through bilinear interpolation.
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>coordinate_transformation_mode</tt> : string (default is half_pixel)</dt>
+<dd>Allowed values are 'half_pixel' and 'output_half_pixel'. Use the value 'half_pixel' to pixel shift the input coordinates by -0.5 (the recommended behavior). Use the value 'output_half_pixel' to omit the pixel shift for the input (use this for a backward-compatible behavior).</dd>
+<dt><tt>mode</tt> : string (default is avg)</dt>
+<dd>The pooling method. Two modes are supported: 'avg' and 'max'. Default is 'avg'.</dd>
+<dt><tt>output_height</tt> : int (default is 1)</dt>
+<dd>default 1; Pooled output Y's height.</dd>
+<dt><tt>output_width</tt> : int (default is 1)</dt>
+<dd>default 1; Pooled output Y's width.</dd>
+<dt><tt>sampling_ratio</tt> : int (default is 0)</dt>
+<dd>Number of sampling points in the interpolation grid used to compute the output value of each pooled output bin. If > 0, then exactly sampling_ratio x sampling_ratio grid points are used. If == 0, then an adaptive number of grid points are used (computed as ceil(roi_width / output_width), and likewise for height). Default is 0.</dd>
+<dt><tt>spatial_scale</tt> : float (default is 1.0)</dt>
+<dd>Multiplicative spatial scale factor to translate ROI coordinates from their input spatial scale to the scale used when pooling, i.e., spatial scale of the input feature map X relative to the input image. E.g.; default is 1.0f. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data tensor from the previous operator; 4-D feature map of shape (N, C, H, W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data.</dd>
+<dt><tt>rois</tt> : T1</dt>
+<dd>RoIs (Regions of Interest) to pool over; rois is 2-D input of shape (num_rois, 4) given as [[x1, y1, x2, y2], ...]. The RoIs' coordinates are in the coordinate system of the input image. Each coordinate set has a 1:1 correspondence with the 'batch_indices' input.</dd>
+<dt><tt>batch_indices</tt> : T2</dt>
+<dd>1-D tensor of shape (num_rois,) with each element denoting the index of the corresponding image in the batch.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>RoI pooled output, 4-D tensor of shape (num_rois, C, output_height, output_width). The r-th batch element Y[r-1] is a pooled feature map corresponding to the r-th RoI X[r-1].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain types to int tensors.</dd>
+</dl>
+
+### <a name="Scan-16"></a>**Scan-16**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops).
+  Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+  well as scan_output_element tensors) are required to have the same shape in each iteration
+  of the loop (a restriction imposed to enable efficient memory allocation).
+
+  Note that the iterated element passed to the body subgraph does not have a sequence
+  axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The optional attribute scan_input_directions specifies the direction (forward or backward)
+  for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+  direction. A bidirectional scan may be performed by specifying the same tensor input twice
+  in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+  The scan_output of the operation is produced by concatenating the scan_output_element
+  values produced by the body in each iteration.  The optional attribute scan_output_directions
+  specifies the direction in which scan_output is constructed (by appending or prepending the
+  scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+  is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+  The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+  If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+  batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+  Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+  The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+  are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+  scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+  value of 1.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body,
+          scan_input_axes = [axis_1, ..., axis_m]
+      > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+      sequence_length = scan_1.shape[axis_1];
+
+      // initialize state-variables
+      st_1 = init_1; ... st_n = init_n;
+      // initialize scan-output variables: [] denotes an empty tensor
+      scan_out_1 = []; ...; scan_out_k = [];
+      // identify number of iterations:
+
+      // execute loop
+      for (int t = 0; t < sequence_length; ++t) {
+          // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+          // of rank one less than T obtained by indexing T at position t along axis k.
+          si_1 = scan_1<axis=axis_1>[t];
+          ... ;
+          si_m = scan_m<axis=axis_m>[t];
+          // execute loop-body
+          st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+          // accumulate the scan-output elements
+          scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+      }
+
+      return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+<dt><tt>scan_input_axes</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the axis to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will be used as the scan axis for every scan_input. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>scan_input_directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>scan_output_axes</tt> : list of ints</dt>
+<dd>An optional list of K flags. The i-th element of the list specifies the axis for the i-th scan_output. The scan outputs are accumulated along the specified axis. If omitted, 0 will be used as the scan axis for every scan_output. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1].</dd>
+<dt><tt>scan_output_directions</tt> : list of ints</dt>
+<dd>An optional list of K flags, one for each scan_output. The i-th element of the list specifies whether the i-th scan_output should be constructed by appending or prepending a new value in each iteration: 0 indicates appending and 1 indicates prepending. If omitted, all scan_output tensors will be produced by appending a value in each iteration.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>All Tensor types up to IRv4.</dd>
+</dl>
+
+### <a name="ScatterElements-16"></a>**ScatterElements-16**</a>
+
+  ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
+  rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value
+  to values specified by `updates` at specific index positions specified by
+  `indices`. Its output shape is the same as the shape of `data`.
+  For each entry in `updates`, the target index in `data` is obtained by combining
+  the corresponding entry in `indices` with the index of the entry itself: the
+  index-value for dimension = axis is obtained from the value of the corresponding
+  entry in `indices` and the index-value for dimension != axis is obtained from the
+  index of the entry itself.
+  `reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+  tensor into `output` at the specified `indices`.
+  In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+  then indices[idx1] != indices[idx2]. For instance, in a 2-D tensor case, the update
+  corresponding to the [i][j] entry is performed as below:
+  ```
+    output[indices[i][j]][j] = updates[i][j] if axis = 0,
+    output[i][indices[i][j]] = updates[i][j] if axis = 1,
+  ```
+  When `reduction` is set to "add", the update corresponding to the [i][j] entry is performed as below:
+  ```
+    output[indices[i][j]][j] += updates[i][j] if axis = 0,
+    output[i][indices[i][j]] += updates[i][j] if axis = 1,
+  ```
+  When `reduction` is set to "mul", the update corresponding to the [i][j] entry is performed as below:
+  ```
+    output[indices[i][j]][j] *= updates[i][j] if axis = 0,
+    output[i][indices[i][j]] *= updates[i][j] if axis = 1,
+  ```
+  This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+  Example 1:
+  ```
+    data = [
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+    ]
+    indices = [
+        [1, 0, 2],
+        [0, 2, 1],
+    ]
+    updates = [
+        [1.0, 1.1, 1.2],
+        [2.0, 2.1, 2.2],
+    ]
+    output = [
+        [2.0, 1.1, 0.0]
+        [1.0, 0.0, 2.2]
+        [0.0, 2.1, 1.2]
+    ]
+  ```
+  Example 2:
+  ```
+    data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+    indices = [[1, 3]]
+    updates = [[1.1, 2.1]]
+    axis = 1
+    output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>reduction</tt> : string (default is none)</dt>
+<dd>Type of reduction to apply: none (default), add, mul. 'none': no reduction applied. 'add':  reduction using the addition operation. 'mul': reduction using the multiplication operation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : Tind</dt>
+<dd>Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+<dt><tt>updates</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >=1 (same rank and shape as indices)</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1 (same rank as input).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input and output types can be of any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="ScatterND-16"></a>**ScatterND-16**</a>
+
+  ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
+  and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value to values
+  specified by `updates` at specific index positions specified by `indices`. Its output shape
+  is the same as the shape of `data`.
+
+  `indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
+   `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
+  Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
+  update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
+  update to a slice of the tensor. Index values are allowed to be negative, as per the usual
+  convention for counting backwards from the end, but are expected in the valid range.
+
+  `updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
+  first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
+  The remaining dimensions of `updates` correspond to the dimensions of the
+  replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
+  corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
+  must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
+  of shapes.
+
+  The `output` is calculated via the following equation:
+      output = np.copy(data)
+      update_indices = indices.shape[:-1]
+      for idx in np.ndindex(update_indices):
+          output[tuple(indices[idx])] = updates[idx]
+  The order of iteration in the above loop is not specified.
+  In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
+  This ensures that the output value does not depend on the iteration order.
+
+  `reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+  tensor into `output` at the specified `indices`.
+  In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+  then indices[idx1] != indices[idx2]. This ensures that the output value does not depend on the iteration order.
+  When `reduction` is set to "add", `output` is calculated as follows:
+      output = np.copy(data)
+      update_indices = indices.shape[:-1]
+      for idx in np.ndindex(update_indices):
+          output[tuple(indices[idx])] += updates[idx]
+  When `reduction` is set to "mul", `output` is calculated as follows:
+      output = np.copy(data)
+      update_indices = indices.shape[:-1]
+      for idx in np.ndindex(update_indices):
+          output[tuple(indices[idx])] *= updates[idx]
+  This operator is the inverse of GatherND.
+  Example 1:
+  ```
+    data    = [1, 2, 3, 4, 5, 6, 7, 8]
+    indices = [[4], [3], [1], [7]]
+    updates = [9, 10, 11, 12]
+    output  = [1, 11, 3, 10, 9, 6, 7, 12]
+  ```
+  Example 2:
+  ```
+    data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+               [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+               [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+               [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+    indices = [[0], [2]]
+    updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+               [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
+    output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+               [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+               [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+               [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>reduction</tt> : string (default is none)</dt>
+<dd>Type of reduction to apply: none (default), add, mul. 'none': no reduction applied. 'add':  reduction using the addition operation. 'mul': reduction using the multiplication operation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of rank q >= 1.</dd>
+<dt><tt>updates</tt> (differentiable) : T</dt>
+<dd>Tensor of rank q + r - indices_shape[-1] - 1.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+### <a name="Where-16"></a>**Where-16**</a>
+
+  Return elements, either from X or Y, depending on condition.
+  Where behaves like
+  [numpy.where](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html)
+  with three parameters.
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>condition</tt> (non-differentiable) : B</dt>
+<dd>When True (nonzero), yield X, otherwise yield Y</dd>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>values selected at indices where condition is True</dd>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>values selected at indices where condition is False</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of shape equal to the broadcasted shape of condition, X, and Y.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Constrain to boolean tensors.</dd>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types (including bfloat).</dd>
+</dl>
+
+## Version 17 of the default ONNX operator set
+### <a name="BlackmanWindow-17"></a>**BlackmanWindow-17**</a>
+
+  Generates a Blackman window as described in the paper https://ieeexplore.ieee.org/document/1455106.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>output_datatype</tt> : int (default is 1)</dt>
+<dd>The data type of the output tensor. Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T2. The default value is 1 = FLOAT. </dd>
+<dt><tt>periodic</tt> : int (default is 1)</dt>
+<dd>If 1, returns a window to be used as periodic function. If 0, return a symmetric window. When 'periodic' is specified, hann computes a window of length size + 1 and returns the first size points. The default value is 1. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>A scalar value indicating the length of the window.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T2</dt>
+<dd>A Blackman window with length: size. The output has the shape: [size].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain the input size to int32_t or int64_t.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain output types to numeric tensors.</dd>
+</dl>
+
+### <a name="DFT-17"></a>**DFT-17**</a>
+
+  Computes the discrete Fourier transform of input.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>The axis on which to perform the DFT. By default this value is set to 1, which corresponds to the first dimension after the batch index. Negative value means counting dimensions from the back. Accepted range is $[-r, -2] \cup [0, r-2]$ where `r = rank(input)`. The last dimension is for representing complex numbers and thus is an invalid axis.</dd>
+<dt><tt>inverse</tt> : int (default is 0)</dt>
+<dd>Whether to perform the inverse discrete fourier transform. By default this value is set to 0, which corresponds to false.</dd>
+<dt><tt>onesided</tt> : int (default is 0)</dt>
+<dd>If onesided is 1, only values for w in [0, 1, 2, ..., floor(n_fft/2) + 1] are used or returned because the real-to-complex Fourier transform satisfies the conjugate symmetry, i.e., X[m, w] = X[m, n_fft-w]*. When onesided=1 and inverse=0 (forward DFT), only real input is supported and a one-sided complex spectrum is returned (RFFT). When onesided=1 and inverse=1 (inverse DFT), only complex input is supported and a full real signal is returned (IRFFT). When invoked with real or complex valued input, the default value is 0. Values can be 0 or 1.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> (non-differentiable) : T1</dt>
+<dd>For real input, the following shape is expected: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][1]. For complex input, the following shape is expected: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][2]. The first dimension is the batch dimension. The following N dimensions correspond to the signal's dimensions. The final dimension represents the real and imaginary parts of the value in that order.</dd>
+<dt><tt>dft_length</tt> (optional, non-differentiable) : T2</dt>
+<dd>The length of the signal as a scalar. If greater than the axis dimension, the signal will be zero-padded up to dft_length. If less than the axis dimension, only the first dft_length values will be used as the signal. If not provided, the default dft_length = signal_dim_axis, except for the IRFFT case (onesided=1, inverse=1), in which case the default dft_length is 2 * (signal_dim_axis - 1). It's an optional value.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T1</dt>
+<dd>The Fourier Transform of the input vector. For standard DFT (onesided=0), the output shape is: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][2] (complex), with signal_dim_axis = dft_length. For RFFT (onesided=1, inverse=0), the output shape is: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][2] (one-sided complex), with signal_dim_axis = floor(dft_length/2) + 1. For IRFFT (onesided=1, inverse=1), the output shape is: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][1] (real), where signal_dim_axis = dft_length.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain scalar length types to int64_t.</dd>
+</dl>
+
+### <a name="HammingWindow-17"></a>**HammingWindow-17**</a>
+
+  Generates a Hamming window as described in the paper https://ieeexplore.ieee.org/document/1455106.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>output_datatype</tt> : int (default is 1)</dt>
+<dd>The data type of the output tensor. Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T2. The default value is 1 = FLOAT. </dd>
+<dt><tt>periodic</tt> : int (default is 1)</dt>
+<dd>If 1, returns a window to be used as periodic function. If 0, return a symmetric window. When 'periodic' is specified, hann computes a window of length size + 1 and returns the first size points. The default value is 1. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>A scalar value indicating the length of the window.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T2</dt>
+<dd>A Hamming window with length: size. The output has the shape: [size].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain the input size to int32_t or int64_t.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain output types to numeric tensors.</dd>
+</dl>
+
+### <a name="HannWindow-17"></a>**HannWindow-17**</a>
+
+  Generates a Hann window as described in the paper https://ieeexplore.ieee.org/document/1455106.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>output_datatype</tt> : int (default is 1)</dt>
+<dd>The data type of the output tensor. Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T2. The default value is 1 = FLOAT. </dd>
+<dt><tt>periodic</tt> : int (default is 1)</dt>
+<dd>If 1, returns a window to be used as periodic function. If 0, return a symmetric window. When 'periodic' is specified, hann computes a window of length size + 1 and returns the first size points. The default value is 1. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>A scalar value indicating the length of the window.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T2</dt>
+<dd>A Hann window with length: size. The output has the shape: [size].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain the input size to int32_t or int64_t.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain output types to numeric tensors.</dd>
+</dl>
+
+### <a name="LayerNormalization-17"></a>**LayerNormalization-17**</a>
+
+  This is layer normalization defined in ONNX as function.
+        The overall computation can be split into two stages.
+        The first stage is standardization, which makes the
+        normalized elements have zero mean and unit variances.
+        The computation required by standardization can be
+        described by the following equations.
+        ```
+        Mean = ReduceMean<axes=normalized_axes>(X)
+        D = Sub(X, Mean)
+        DD = Mul(D, D)
+        Var = ReduceMean<axes=normalized_axes>(DD)
+        VarEps = Add(Var, epsilon)
+        StdDev = Sqrt(VarEps)
+        InvStdDev = Reciprocal(StdDev)
+        Normalized = Mul(D, InvStdDev)
+        ```
+        where `normalized_axes` is `[axis, ..., rank of X - 1]`.
+        The variables `Var` and `StdDev` stand for variance and
+        standard deviation, respectively. The second output is
+        `Mean` and the last one is `InvStdDev`.
+        Depending on `stash_type` attribute, the actual computation
+        must happen in different floating-point precision.
+        For example, if `stash_type` is 1, this operator casts
+        all input variables to 32-bit float, perform the computation, and
+        finally cast `Normalized` back to the original type of `X`.
+        The second stage then scales and shifts the outcome of the
+        first stage using
+        ```
+        NormalizedScaled = Mul(Normalized, Scale)
+        Y = Add(NormalizedScaled, B)
+        ```
+        The second stage doesn't depends on `stash_type`.
+        All equations are in [this syntax](https://github.com/onnx/onnx/blob/main/docs/Syntax.md).
+        The same variable (i.e., input, output, and attribute) uses
+        the same name in the equations above and this operator's definition.
+        Let `d[i]` indicate the i-th dimension of `X`.
+        If `X`'s shape is `[d[0], ..., d[axis-1], d[axis], ..., d[rank-1]]`,
+        the shape of `Mean` and `InvStdDev` is `[d[0], ..., d[axis-1], 1, ..., 1]`.
+        `Y` and `X` have the same shape. This operator supports unidirectional broadcasting
+        (tensors `Scale` and `B` should be unidirectional broadcastable to tensor `X`);
+        for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>The first normalization dimension. If rank(X) is r, axis' allowed range is [-r, r). Negative value means counting dimensions from the back.</dd>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>stash_type</tt> : int (default is 1)</dt>
+<dd>Type of Mean and InvStdDev. This also specifies stage one's computation precision.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Tensor to be normalized.</dd>
+<dt><tt>Scale</tt> : T</dt>
+<dd>Scale tensor.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>Bias tensor.</dd>
+</dl>
+
+#### Outputs (1 - 3)
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Normalized tensor.</dd>
+<dt><tt>Mean</tt> (optional) : U</dt>
+<dd>Saved mean used during training to speed up gradient computation</dd>
+<dt><tt>InvStdDev</tt> (optional) : U</dt>
+<dd>Saved inverse standard deviation used during training to speed up gradient computation.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types and output Y type to float tensors.</dd>
+<dt><tt>U</tt> : tensor(float), tensor(bfloat16)</dt>
+<dd>Type of Mean and InvStdDev tensors.</dd>
+</dl>
+
+### <a name="MelWeightMatrix-17"></a>**MelWeightMatrix-17**</a>
+
+  Generate a MelWeightMatrix that can be used to re-weight a Tensor containing a linearly sampled frequency spectra (from DFT or STFT) into num_mel_bins frequency information based on the [lower_edge_hertz, upper_edge_hertz] range on the mel scale.
+  This function defines the mel scale in terms of a frequency in hertz according to the following formula:
+
+      mel(f) = 2595 * log10(1 + f/700)
+
+  In the returned matrix, all the triangles (filterbanks) have a peak value of 1.0.
+
+  The returned MelWeightMatrix can be used to right-multiply a spectrogram S of shape [frames, num_spectrogram_bins] of linear scale spectrum values (e.g. STFT magnitudes) to generate a "mel spectrogram" M of shape [frames, num_mel_bins].
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>output_datatype</tt> : int (default is 1)</dt>
+<dd>The data type of the output tensor. Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T3. The default value is 1 = FLOAT. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>num_mel_bins</tt> (non-differentiable) : T1</dt>
+<dd>The number of bands in the mel spectrum.</dd>
+<dt><tt>dft_length</tt> (non-differentiable) : T1</dt>
+<dd>The size of the original DFT. The size of the original DFT is used to infer the size of the onesided DFT, which is understood to be floor(dft_length/2) + 1, i.e. the spectrogram only contains the nonredundant DFT bins.</dd>
+<dt><tt>sample_rate</tt> (non-differentiable) : T1</dt>
+<dd>Samples per second of the input signal used to create the spectrogram. Used to figure out the frequencies corresponding to each spectrogram bin, which dictates how they are mapped into the mel scale.</dd>
+<dt><tt>lower_edge_hertz</tt> (non-differentiable) : T2</dt>
+<dd>Lower bound on the frequencies to be included in the mel spectrum. This corresponds to the lower edge of the lowest triangular band.</dd>
+<dt><tt>upper_edge_hertz</tt> (non-differentiable) : T2</dt>
+<dd>The desired top edge of the highest frequency band.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T3</dt>
+<dd>The Mel Weight Matrix. The output has the shape: [floor(dft_length/2) + 1][num_mel_bins].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain to integer tensors.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain to float tensors</dd>
+<dt><tt>T3</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain to any numerical types.</dd>
+</dl>
+
+### <a name="STFT-17"></a>**STFT-17**</a>
+
+  Computes the Short-time Fourier Transform of the signal.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>onesided</tt> : int (default is 1)</dt>
+<dd>If onesided is 1, only values for w in [0, 1, 2, ..., floor(n_fft/2) + 1] are returned because the real-to-complex Fourier transform satisfies the conjugate symmetry, i.e., X[m, w] = X[m,w]=X[m,n_fft-w]*. Note if the input or window tensors are complex, then onesided output is not possible. Enabling onesided with real inputs performs a Real-valued fast Fourier transform (RFFT).When invoked with real or complex valued input, the default value is 1. Values can be 0 or 1.</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>signal</tt> (non-differentiable) : T1</dt>
+<dd>Input tensor representing a real or complex valued signal. For real input, the following shape is expected: [batch_size][signal_length][1]. For complex input, the following shape is expected: [batch_size][signal_length][2], where [batch_size][signal_length][0] represents the real component and [batch_size][signal_length][1] represents the imaginary component of the signal.</dd>
+<dt><tt>frame_step</tt> (non-differentiable) : T2</dt>
+<dd>The number of samples to step between successive DFTs.</dd>
+<dt><tt>window</tt> (optional, non-differentiable) : T1</dt>
+<dd>A tensor representing the window that will be slid over the signal.The window must have rank 1 with shape: [window_shape]. It's an optional value. </dd>
+<dt><tt>frame_length</tt> (optional, non-differentiable) : T2</dt>
+<dd>A scalar representing the size of the DFT. It's an optional value.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T1</dt>
+<dd>The Short-time Fourier Transform of the signals.If onesided is 1, the output has the shape: [batch_size][frames][dft_unique_bins][2], where dft_unique_bins is frame_length // 2 + 1 (the unique components of the DFT) If onesided is 0, the output has the shape: [batch_size][frames][frame_length][2], where frame_length is the length of the DFT.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(float16), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain signal and output to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain scalar length types to int64_t.</dd>
+</dl>
+
+### <a name="SequenceMap-17"></a>**SequenceMap-17**</a>
+
+  Applies a sub-graph to each sample in the input sequence(s).
+
+  Inputs can be either tensors or sequences, with the exception of the first input which must
+  be a sequence. The length of the first input sequence will determine the number of samples in the
+  outputs. Any other sequence inputs should have the same number of samples. The number of inputs
+  and outputs, should match the one of the subgraph.
+
+  For each i-th element in the output, a sample will be extracted from the input sequence(s) at
+  the i-th position and the sub-graph will be applied to it.
+  The outputs will contain the outputs of the sub-graph for each sample, in the same order as in
+  the input.
+
+  This operator assumes that processing each sample is independent and could executed in parallel
+  or in any order. Users cannot expect any specific ordering in which each subgraph is computed.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph to be run for each sample in the sequence(s). It should have as many inputs and outputs as inputs and outputs to the SequenceMap function.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+<dt><tt>additional_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Additional inputs to the graph</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>out_sequence</tt> (variadic, heterogeneous) : S</dt>
+<dd>Output sequence(s)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input types to any sequence type.</dd>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor or sequence type.</dd>
+</dl>
+
+## Version 18 of the default ONNX operator set
+### <a name="BitwiseAnd-18"></a>**BitwiseAnd-18**</a>
+
+  Returns the tensor resulting from performing the bitwise `and` operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the bitwise operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the bitwise operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input to integer tensors.</dd>
+</dl>
+
+### <a name="BitwiseNot-18"></a>**BitwiseNot-18**</a>
+
+  Returns the bitwise not of the input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input/output to integer tensors.</dd>
+</dl>
+
+### <a name="BitwiseOr-18"></a>**BitwiseOr-18**</a>
+
+  Returns the tensor resulting from performing the bitwise `or` operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the bitwise operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the bitwise operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input to integer tensors.</dd>
+</dl>
+
+### <a name="BitwiseXor-18"></a>**BitwiseXor-18**</a>
+
+  Returns the tensor resulting from performing the bitwise `xor` operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the bitwise operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the bitwise operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input to integer tensors.</dd>
+</dl>
+
+### <a name="CenterCropPad-18"></a>**CenterCropPad-18**</a>
+
+  Center crop or pad an input to given dimensions.
+
+  The crop/pad dimensions can be specified for a subset of the `axes`; unspecified dimensions will remain unchanged.
+
+  If the input dimensions are larger than the target crop dimensions, a centered cropping window will be extracted
+  from the input. The starting value for the cropping window is rounded down, which means that if the difference
+  between the input shape and the crop shape is odd, the cropping window will be shifted half a pixel to the left
+  of the input center.
+
+  If the input dimensions are smaller than the target crop dimensions, the input will be padded equally on both sides
+  to center it in the output. In cases where the total number of padding pixels is odd, an additional pixel will be
+  added to the right side.
+
+  The padding value used is zero.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>If provided, it specifies a subset of axes that 'shape' refer to. If not provided, all axes are assumed [0, 1, ..., r-1], where r = rank(data). Negative value means counting dimensions from the back. Accepted range is [-r, r-1], where r = rank(data). Behavior is undefined if an axis is repeated.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input_data</tt> (differentiable) : T</dt>
+<dd>Input to extract the centered crop from.</dd>
+<dt><tt>shape</tt> (non-differentiable) : Tind</dt>
+<dd>1-D tensor representing the cropping window dimensions.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_data</tt> (differentiable) : T</dt>
+<dd>Output data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="Col2Im-18"></a>**Col2Im-18**</a>
+
+  The operator rearranges column blocks back into a multidimensional image
+
+  Col2Im behaves similarly to PyTorch's fold https://pytorch.org/docs/stable/generated/torch.nn.Fold.html,
+  but it only supports *batched* multi-dimensional image tensors.
+  Another implementation in Python with N-dimension support can be found at https://github.com/f-dangel/unfoldNd/.
+
+  NOTE:
+    Although specifying image_shape looks redundant because it could be calculated from
+    convolution formulas, it is required as input for more advanced scenarios as explained
+    at PyTorch's implementation (https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/Col2Im.cpp#L10)
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>1-dimensional tensor with dilation value along each spatial axis of the image. If not present, the dilation defaults to 1 along each spatial axis of the image.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>1-dimensional tensor with padding value for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin is the number of pixels added at the beginning of axis `i` and xi_end is the number of pixels added at the end of axis `i`. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>1-dimensional tensor with stride value along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input data tensor to be rearranged from column blocks back into an image. This is a 3-dimensional tensor containing [N, C * n-ary-product(block_shape), L], where N is batch dimension, C is image channel dimension and L is number of blocks.The blocks are enumerated in increasing lexicographic-order of their indices.For example, with an image-size 10*20 and block-size 9*18, there would be 2*3 blocks, enumerated in the order block(0, 0), block(0, 1), block(0, 2), block(1, 0), block(1, 1), block(1, 2).</dd>
+<dt><tt>image_shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>The shape of the spatial dimensions of the image after rearranging the column blocks.This is a 1-dimensional tensor with size of at least 2, containing the value [H_img, W_img]  for a 2-D image or [dim_i1, dim_i2, ..., dim_iN] for a N-D image.</dd>
+<dt><tt>block_shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>The shape of the block to apply on the input.This is a 1-dimensional tensor of size of at least 2, containing the value [H_block, W_block]  for a 2-D image or [dim_b1, dim_b2, ..., dim_bN] for a N-D block.This is the block-shape before dilation is applied to it.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor produced by rearranging blocks into an image.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all numeric tensor types.</dd>
+</dl>
+
+### <a name="GroupNormalization-18"></a>**GroupNormalization-18** (deprecated)</a>
+
+  A GroupNormalization function. Carries out group normalization as described in
+  the paper https://arxiv.org/abs/1803.08494
+
+  This operator transforms input according to
+  ```
+  y = scale * (x - mean) / sqrt(variance + epsilon) + bias,
+  ```
+  where the mean and variance are computed per instance per group of channels, and
+  `scale` and `bias` should be specified for each group of channels. The number of
+  groups `num_groups` should be divisible by the number of channels so that there are
+  an equal number of channels per group.
+
+  When the number of groups is the same as the number of channels, this operator is
+  equivalent to InstanceNormalization. When there is only one group, this operator
+  is equivalent to LayerNormalization.
+
+#### Version
+
+This version of the operator has been deprecated since version 18 of the default ONNX operator set.
+
+### <a name="LpPool-18"></a>**LpPool-18**</a>
+
+  LpPool consumes an input tensor X and applies Lp pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   Lp pooling consisting of computing the Lp norm on all values of a subset
+   of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled `pad_shape[i]` is the sum of pads along axis `i`.
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]
+   ```
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>p value of the Lp norm used to pool over the input data.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Mish-18"></a>**Mish-18**</a>
+
+  Mish: A Self Regularized Non-Monotonic Neural Activation Function.
+
+  Perform the linear unit element-wise on the input tensor X using formula:
+
+  ```
+  mish(x) = x * tanh(softplus(x)) = x * tanh(ln(1 + e^{x}))
+  ```
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input X and output types to float tensors.</dd>
+</dl>
+
+### <a name="OptionalGetElement-18"></a>**OptionalGetElement-18**</a>
+
+  If the input is a tensor or sequence type, it returns the input.
+  If the input is an optional type, it outputs the element in the input.
+  It is an error if the input is an empty optional-type (i.e. does not have an element) and the behavior is undefined in this case.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : O</dt>
+<dd>The optional input.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : V</dt>
+<dd>Output element in the optional input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>O</tt> : optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input type to optional tensor and optional sequence types.</dd>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output type to all tensor or sequence types.</dd>
+</dl>
+
+### <a name="OptionalHasElement-18"></a>**OptionalHasElement-18**</a>
+
+  Returns true if (1) the input is an optional-type and contains an element,
+  or, (2) the input is a tensor or sequence type.
+  If the input is not provided or is an empty optional-type, this op returns false.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs (0 - 1)
+
+<dl>
+<dt><tt>input</tt> (optional) : O</dt>
+<dd>The optional input.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : B</dt>
+<dd>A scalar boolean tensor. If true, it indicates that optional-type input contains an element. Otherwise, it is empty.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>O</tt> : optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input type to optional tensor and optional sequence types.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Constrain output to a boolean tensor.</dd>
+</dl>
+
+### <a name="Pad-18"></a>**Pad-18**</a>
+
+  Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+  a padded tensor (`output`) is generated.
+
+  The three supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+  1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+  2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+  3) `edge` - pads with the edge values of array
+
+
+  Example 1 (`constant` mode):
+
+  Insert 0 pads to the beginning of the second dimension.
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'constant'
+
+  constant_value = 0.0
+
+  output = [
+      [0.0, 0.0, 1.0, 1.2],
+      [0.0, 0.0, 2.3, 3.4],
+      [0.0, 0.0, 4.5, 5.7],
+  ]
+  ```
+
+  Example 2 (`reflect` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'reflect'
+
+  output = [
+      [1.0, 1.2, 1.0, 1.2],
+      [2.3, 3.4, 2.3, 3.4],
+      [4.5, 5.7, 4.5, 5.7],
+  ]
+  ```
+
+  Example 3 (`edge` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'edge'
+
+  output = [
+      [1.0, 1.0, 1.0, 1.2],
+      [2.3, 2.3, 2.3, 3.4],
+      [4.5, 4.5, 4.5, 5.7],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Supported modes: `constant`(default), `reflect`, `edge`</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Input tensor.</dd>
+<dt><tt>pads</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. `pads` should be a 1D tensor of shape [2 * num_axes] where `num_axes` refers to the number of elements in the `axes` input or the input rank if `axes` are not provided explicitly. `pads` format should be: [x1_begin, x2_begin, ..., x1_end, x2_end,...], where xi_begin is the number of pad values added at the beginning of axis `axes[i]` and xi_end, the number of pad values added at the end of axis `axes[i]`.</dd>
+<dt><tt>constant_value</tt> (optional, non-differentiable) : T</dt>
+<dd>(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, empty string or False).</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of axes that `pads` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated. If not provided, all axes are assumed (`[0, 1, ..., input_rank-1]`).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="ReduceL1-18"></a>**ReduceL1-18**</a>
+
+  Computes the L1 norm of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceL2-18"></a>**ReduceL2-18**</a>
+
+  Computes the L2 norm of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceLogSum-18"></a>**ReduceLogSum-18**</a>
+
+  Computes the log sum of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or undefined otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceLogSumExp-18"></a>**ReduceLogSumExp-18**</a>
+
+  Computes the log sum exponent of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or undefined otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMax-18"></a>**ReduceMax-18**</a>
+
+  Computes the max of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or the minimum value of the data type otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(uint8), tensor(int8)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMean-18"></a>**ReduceMean-18**</a>
+
+  Computes the mean of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields undefined.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceMin-18"></a>**ReduceMin-18**</a>
+
+  Computes the min of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields plus infinity (if supported by the datatype) or the maximum value of the data type otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(uint8), tensor(int8)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceProd-18"></a>**ReduceProd-18**</a>
+
+  Computes the product of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 1.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="ReduceSumSquare-18"></a>**ReduceSumSquare-18**</a>
+
+  Computes the sum square of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+### <a name="Resize-18"></a>**Resize-18**</a>
+
+  Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
+  Each dimension value of the output tensor is: <br/>
+    `output_dimension = floor(input_dimension * (roi_end - roi_start) * scale)` <br/>
+  if input \"sizes\" is not specified.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>antialias</tt> : int (default is 0)</dt>
+<dd>If set to 1, "linear" and "cubic" interpolation modes will use an antialiasing filter when downscaling. Antialiasing is achieved by stretching the resampling filter by a factor max(1, 1 / scale), which means that when downsampling, more input pixels contribute to an output pixel.</dd>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>If provided, it specifies a subset of axes that 'roi', 'scales' and 'sizes' refer to. If not provided, all axes are assumed [0, 1, ..., r-1], where r = rank(data). Non-specified dimensions are interpreted as non-resizable. Negative value means counting dimensions from the back. Accepted range is [-r, r-1], where r = rank(data). Behavior is undefined if an axis is repeated.</dd>
+<dt><tt>coordinate_transformation_mode</tt> : string (default is half_pixel)</dt>
+<dd>
+This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. <br/>
+
+The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
+Denote x_resized as the coordinate of axis x in the resized tensor, x_original as the coordinate of axis x in the original tensor, `length_original` as the length of the original tensor in axis x, length_resized as the length of the resized tensor in axis x, roi_x = (start_x, end_x) of the axis x in input "roi", `scale = length_resized / length_original`, <br/>
+
+if coordinate_transformation_mode is `"half_pixel"`, <br/>
+`x_original = (x_resized + 0.5) / scale - 0.5` <br/>
+
+if coordinate_transformation_mode is `"pytorch_half_pixel"`, <br/>
+`x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0` <br/>
+
+if coordinate_transformation_mode is `"align_corners"`, <br/>
+`x_original = x_resized * (length_original - 1) / (length_resized - 1)` <br/>
+
+if coordinate_transformation_mode is `"asymmetric"`, <br/>
+`x_original = x_resized / scale` <br/>
+
+if coordinate_transformation_mode is `"tf_crop_and_resize"`, <br/>
+`x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1)`
+.</dd>
+<dt><tt>cubic_coeff_a</tt> : float (default is -0.75)</dt>
+<dd>The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75 (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. This attribute is valid only if mode is "cubic".</dd>
+<dt><tt>exclude_outside</tt> : int (default is 0)</dt>
+<dd>If set to 1, the weight of sampling locations outside the tensor will be set to 0 and the weight will be renormalized so that their sum is 1.0. The default value is 0.</dd>
+<dt><tt>extrapolation_value</tt> : float (default is 0.0)</dt>
+<dd>When coordinate_transformation_mode is "tf_crop_and_resize" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f.</dd>
+<dt><tt>keep_aspect_ratio_policy</tt> : string (default is stretch)</dt>
+<dd>
+This attribute describes how to interpret the `sizes` input with regard to keeping the original aspect ratio of the input, and it is not applicable when
+the `scales` input is used. <br/>
+
+Given a set of `sizes`, associated with a subset of `axes` (explicitly provided or default), and assuming `d = axes[i]`, with `i` being the index of the provided `sizes`. <br/>
+
+If `keep_aspect_ratio_policy` is `"stretch"`, the original aspect ratio is disregarded, and the input is resized to the specified size: <br/>
+`out_size[d] = sizes[i]` <br/>
+
+If `keep_aspect_ratio_policy` is `"not_larger"`, the sizes are adjusted so that no extent of the output is larger than the specified size, while keeping the original aspect ratio: <br/>
+`scale = Min(sizes[i] / in_size[d])` <br/>
+`out_size[d] = round_int(scale * in_size[d])` <br/>
+
+If `keep_aspect_ratio_policy` is `"not_smaller"`, the sizes are adjusted so that no extent of the output is smaller than the specified size, while keeping the original aspect ratio: <br/>
+`scale = Max(sizes[i] / in_size[d])` <br/>
+`out_size[d] = round_int(scale * in_size[d])` <br/>
+
+For non-resizable axes (those not specified in `axes`), the output size will be equal to the input size.
+
+Note: `round_int` stands for computing the nearest integer value, rounding halfway cases up.</dd>
+<dt><tt>mode</tt> : string (default is nearest)</dt>
+<dd>Three interpolation modes: "nearest" (default), "linear" and "cubic". The "linear" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). The "cubic" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor).</dd>
+<dt><tt>nearest_mode</tt> : string (default is round_prefer_floor)</dt>
+<dd>Four modes: "round_prefer_floor" (default, as known as round half down), "round_prefer_ceil" (as known as round half up), "floor", "ceil". Only used by nearest interpolation. It indicates how to get "nearest" pixel in input tensor from x_original, so this attribute is valid only if "mode" is "nearest".</dd>
+</dl>
+
+#### Inputs (1 - 4)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>N-D tensor</dd>
+<dt><tt>roi</tt> (optional, non-differentiable) : T2</dt>
+<dd>1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X or the length of axes, if provided. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is "tf_crop_and_resize"</dd>
+<dt><tt>scales</tt> (optional, non-differentiable) : tensor(float)</dt>
+<dd>The scale array along each dimension. It takes value greater than 0. If it's less than 1, it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should be the same as the rank of input 'X' or the length of 'axes', if provided. One of 'scales' and 'sizes' MUST be specified and it is an error if both are specified. If 'sizes' is needed, the user can use an empty string as the name of 'scales' in this operator's input list.</dd>
+<dt><tt>sizes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Target size of the output tensor. Its interpretation depends on the 'keep_aspect_ratio_policy' value.The number of elements of 'sizes' should be the same as the rank of input 'X', or the length of 'axes', if provided. Only one of 'scales' and 'sizes' can be specified. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>N-D tensor after resizing</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input 'X' and output 'Y' to all tensor types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain roi type to float or double.</dd>
+</dl>
+
+### <a name="ScatterElements-18"></a>**ScatterElements-18**</a>
+
+  ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
+  rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value
+  to values specified by `updates` at specific index positions specified by
+  `indices`. Its output shape is the same as the shape of `data`.
+
+  For each entry in `updates`, the target index in `data` is obtained by combining
+  the corresponding entry in `indices` with the index of the entry itself: the
+  index-value for dimension = axis is obtained from the value of the corresponding
+  entry in `indices` and the index-value for dimension != axis is obtained from the
+  index of the entry itself.
+
+  `reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+  tensor into `output` at the specified `indices`.
+  In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+  then indices[idx1] != indices[idx2]. For instance, in a 2-D tensor case, the update
+  corresponding to the [i][j] entry is performed as below:
+  ```
+  output[indices[i][j]][j] = updates[i][j] if axis = 0,
+  output[i][indices[i][j]] = updates[i][j] if axis = 1,
+  ```
+  When `reduction` is set to some reduction function `f`, the update corresponding to the [i][j] entry is performed as below:
+  ```
+  output[indices[i][j]][j] = f(output[indices[i][j]][j], updates[i][j]) if axis = 0,
+  output[i][indices[i][j]] = f(output[i][indices[i][j]], updates[i][j]) if axis = 1,
+  ```
+  where the `f` is `+`, `*`, `max` or `min` as specified.
+
+  This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+
+  (Opset 18 change): Adds max/min to the set of allowed reduction ops.
+
+  Example 1:
+  ```
+  data = [
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+  ]
+  indices = [
+      [1, 0, 2],
+      [0, 2, 1],
+  ]
+  updates = [
+      [1.0, 1.1, 1.2],
+      [2.0, 2.1, 2.2],
+  ]
+  output = [
+      [2.0, 1.1, 0.0]
+      [1.0, 0.0, 2.2]
+      [0.0, 2.1, 1.2]
+  ]
+  ```
+  Example 2:
+  ```
+  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+  indices = [[1, 3]]
+  updates = [[1.1, 2.1]]
+  axis = 1
+  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>reduction</tt> : string (default is none)</dt>
+<dd>Type of reduction to apply: none (default), add, mul, max, min. 'none': no reduction applied. 'add':  reduction using the addition operation. 'mul': reduction using the multiplication operation.'max': reduction using the maximum operation.'min': reduction using the minimum operation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : Tind</dt>
+<dd>Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+<dt><tt>updates</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >=1 (same rank and shape as indices)</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1 (same rank as input).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input and output types can be of any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="ScatterND-18"></a>**ScatterND-18**</a>
+
+  ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
+  and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value to values
+  specified by `updates` at specific index positions specified by `indices`. Its output shape
+  is the same as the shape of `data`.
+
+  `indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
+  `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
+  Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
+  update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
+  update to a slice of the tensor. Index values are allowed to be negative, as per the usual
+  convention for counting backwards from the end, but are expected in the valid range.
+
+  `updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
+  first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
+  The remaining dimensions of `updates` correspond to the dimensions of the
+  replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
+  corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
+  must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
+  of shapes.
+
+  The `output` is calculated via the following equation:
+
+  ```
+  output = np.copy(data)
+  update_indices = indices.shape[:-1]
+  for idx in np.ndindex(update_indices):
+      output[tuple(indices[idx])] = updates[idx]
+  ```
+
+  The order of iteration in the above loop is not specified.
+  In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
+  This ensures that the output value does not depend on the iteration order.
+
+  `reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+  tensor into `output` at the specified `indices`.
+  In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+  then indices[idx1] != indices[idx2]. This ensures that the output value does not depend on the iteration order.
+  When `reduction` is set to some reduction function `f`, `output` is calculated as follows:
+
+  ```
+  output = np.copy(data)
+  update_indices = indices.shape[:-1]
+  for idx in np.ndindex(update_indices):
+      output[tuple(indices[idx])] = f(output[tuple(indices[idx])], updates[idx])
+  ```
+
+  where the `f` is `+`, `*`, `max` or `min` as specified.
+
+  This operator is the inverse of GatherND.
+
+  (Opset 18 change): Adds max/min to the set of allowed reduction ops.
+
+  Example 1:
+  ```
+  data    = [1, 2, 3, 4, 5, 6, 7, 8]
+  indices = [[4], [3], [1], [7]]
+  updates = [9, 10, 11, 12]
+  output  = [1, 11, 3, 10, 9, 6, 7, 12]
+  ```
+
+  Example 2:
+  ```
+  data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+              [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+              [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+              [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+  indices = [[0], [2]]
+  updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+              [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
+  output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+              [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+              [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+              [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>reduction</tt> : string (default is none)</dt>
+<dd>Type of reduction to apply: none (default), add, mul, max, min. 'none': no reduction applied. 'add':  reduction using the addition operation. 'mul':  reduction using the addition operation. 'max': reduction using the maximum operation.'min': reduction using the minimum operation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of rank q >= 1.</dd>
+<dt><tt>updates</tt> (differentiable) : T</dt>
+<dd>Tensor of rank q + r - indices_shape[-1] - 1.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+### <a name="Split-18"></a>**Split-18**</a>
+
+  Split a tensor into a list of tensors, along the specified 'axis'.
+  Either input 'split' or the attribute 'num_outputs' should be specified, but not both.
+  If the attribute 'num_outputs' is specified, then the tensor is split into equal sized parts.
+  If the tensor is not evenly splittable into `num_outputs`, the last chunk will be smaller.
+  If the input 'split' is specified, it indicates the sizes of each output in the split.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to split on. A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] where r = rank(input).</dd>
+<dt><tt>num_outputs</tt> : int</dt>
+<dd>Number of outputs to split parts of the tensor into. If the tensor is not evenly splittable the last chunk will be smaller.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The tensor to split</dd>
+<dt><tt>split</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional length of each output. Values should be >= 0.Sum of the values must be equal to the dim value at 'axis' specified.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, differentiable) : T</dt>
+<dd>One or more outputs forming list of tensors after splitting</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+## Version 19 of the default ONNX operator set
+### <a name="AveragePool-19"></a>**AveragePool-19**</a>
+
+  AveragePool consumes an input tensor X and applies average pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   average pooling consisting of computing the average on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape is calculated differently
+   depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
+   With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`.
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):
+   ```
+   VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
+   ```
+   The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).
+
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>count_include_pad</tt> : int (default is 0)</dt>
+<dd>Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Cast-19"></a>**Cast-19**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+
+  Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+  (e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+  yield result 100. There are some string literals reserved for special floating-point values;
+  "+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+  Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+  this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+  to string tensors, plain floating-point representation (such as "314.15926") would be used.
+  Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+  of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+  Conversion from a numerical type to any numerical type is always allowed.
+  User must be aware of precision loss and value change caused by range difference between two types.
+  For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+  an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+  In more detail, the conversion among numerical types should follow these rules
+  if the destination type is not a float 8 type.
+
+  * Casting from floating point to:
+    * floating point: +/- infinity if OOR (out of range).
+    * fixed point: undefined if OOR.
+    * bool: +/- 0.0 to False; all else to True.
+  * Casting from fixed point to:
+    * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+    * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+      signed types). For example, 200 (int16) -> -56 (int8).
+    * bool: zero to False; nonzero to True.
+  * Casting from bool to:
+    * floating point: `{1.0, 0.0}`.
+    * fixed point: `{1, 0}`.
+    * bool: no change.
+
+  Float 8 type were introduced to speed up the training of
+  deep models. By default the conversion of a float *x* obeys
+  to the following rules. `[x]` means the value rounded to
+  the target mantissa width.
+
+  | x                 | E4M3FN   | E4M3FNUZ | E5M2     | E5M2FNUZ |
+  | ----------------- | -------- | -------- | -------- | -------- |
+  | 0                 | 0        | 0        | 0        | 0        |
+  | -0                | -0       | 0        | -0       | 0        |
+  | NaN               | NaN      | NaN      | NaN      | NaN      |
+  | Inf               | FLT_MAX  | NaN      | FLT_MAX  | NaN      |
+  | -Inf              | -FLT_MAX | NaN      | -FLT_MAX | NaN      |
+  | \[x\] > FLT_MAX   | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+  | \[x\] \< -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+  | else              | RNE      | RNE      | RNE      | RNE      |
+
+  The behavior changes if the parameter 'saturate' is set to False.
+  The rules then become:
+
+  | x                 | E4M3FN | E4M3FNUZ | E5M2 | E5M2FNUZ |
+  | ----------------- | ------ | -------- | ---- | -------- |
+  | 0                 | 0      | 0        | 0    | 0        |
+  | -0                | -0     | 0        | -0   | 0        |
+  | NaN               | NaN    | NaN      | NaN  | NaN      |
+  | -NaN              | -NaN   | NaN      | -NaN | NaN      |
+  | Inf               | NaN    | NaN      | Inf  | NaN      |
+  | -Inf              | -NaN   | NaN      | -Inf | NaN      |
+  | \[x\] > FLT_MAX   | NaN    | NaN      | Inf  | NaN      |
+  | \[x\] \< -FLT_MAX | NaN    | NaN      | -Inf | NaN      |
+  | else              | RNE    | RNE      | RNE  | RNE      |
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. All cases are fully described in two tables inserted in the operator description.</dd>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="CastLike-19"></a>**CastLike-19**</a>
+
+  The operator casts the elements of a given input tensor (the first input) to
+  the same data type as the elements of the second input tensor.
+  See documentation of the Cast operator for further details.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. Please refer to operator Cast description for further details.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+<dt><tt>target_type</tt> (non-differentiable) : T2</dt>
+<dd>The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor produced by casting the first input tensor to have the same type as the second input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="Constant-19"></a>**Constant-19**</a>
+
+  This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+  or value_* must be specified.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>sparse_value</tt> : sparse_tensor</dt>
+<dd>The value for the elements of the output tensor in sparse format.</dd>
+<dt><tt>value</tt> : tensor</dt>
+<dd>The value for the elements of the output tensor.</dd>
+<dt><tt>value_float</tt> : float</dt>
+<dd>The value for the sole element for the scalar, float32, output tensor.</dd>
+<dt><tt>value_floats</tt> : list of floats</dt>
+<dd>The values for the elements for the 1D, float32, output tensor.</dd>
+<dt><tt>value_int</tt> : int</dt>
+<dd>The value for the sole element for the scalar, int64, output tensor.</dd>
+<dt><tt>value_ints</tt> : list of ints</dt>
+<dd>The values for the elements for the 1D, int64, output tensor.</dd>
+<dt><tt>value_string</tt> : string</dt>
+<dd>The value for the sole element for the scalar, UTF-8 string, output tensor.</dd>
+<dt><tt>value_strings</tt> : list of strings</dt>
+<dd>The values for the elements for the 1D, UTF-8 string, output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="DeformConv-19"></a>**DeformConv-19**</a>
+
+  Performs deformable convolution as described in https://arxiv.org/abs/1703.06211 and https://arxiv.org/abs/1811.11168.
+  This operator specification supports the general N-D case. Note that most common use cases have 2D or 3D data.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of the kernel. Default is 1 along each axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>Number of groups the input and output channels, C and oC, are divided into. C and oC must both be divisible by group. Default is 1.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>Shape of the convolution kernel. If not present, it is inferred from the shape of input W.</dd>
+<dt><tt>offset_group</tt> : int (default is 1)</dt>
+<dd>Number of groups of offset. C must be divisible by offset_group. Default is 1.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and end along each spatial axis. The values represent the number of pixels added to the beginning and end of the corresponding axis and can take any nonnegative value. The format should be as follows: [x1_begin, x2_begin, ..., x1_end, x2_end, ...], where xi_begin is the number of pixels added at the beginning of axis `i` and xi_end is the number of pixels added at the end of axis `i`. Default is 0 along each axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. Default is 1 along each axis.</dd>
+</dl>
+
+#### Inputs (3 - 5)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor. For 2D image data, it has shape (N, C, H, W) where N is the batch size, C is the number of input channels, and H and W are the height and width. In general, the shape is (N, C, D1, D2, ... , Dn) for n-dimensional data, where D1 to Dn are the spatial dimension sizes. Most common use cases have n = 2 or 3.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>Weight tensor that will be used in the convolutions. It has shape (oC, C/group, kH, kW), where oC is the number of output channels and kH and kW are the kernel height and width. For more than 2 dimensions, it has shape (oC, C/group, k1, k2, ... , kn).</dd>
+<dt><tt>offset</tt> : T</dt>
+<dd>Offset tensor denoting the offset for the sampling locations in the convolution kernel. It has shape (N, offset_group * kH * kW * 2, oH, oW) for 2D data or (N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Use linear interpolationfor fractional offset values. Sampling locations outside of the padded input tensor gives zero.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>Optional 1D bias of length oC to be added to the convolution. Default is a tensor of zeros.</dd>
+<dt><tt>mask</tt> (optional) : T</dt>
+<dd>The mask tensor to be applied to each position in the convolution kernel. It has shape (N, offset_group * kH * kW, oH, oW) for 2D data or (N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Default is a tensor of ones.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor that contains the result of convolution. It has shape (N, oC, oH, oW) for 2D data or (N, oC, o1, o2, ..., on) for nD data</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="DequantizeLinear-19"></a>**DequantizeLinear-19**</a>
+
+  The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the full precision tensor.
+  The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point` must have same shape, and can be either a scalar
+  for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+  `x_zero_point` and `x` must have same type. `x` and `y` must have same shape. In the case of dequantizing int32,
+  there's no zero point (zero point is supposed to be 0).
+  `zero-point` is usually not used in the case of float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz quantization,
+  but the dequantization formula remains the same for consistency and 'x_scale' still determines the output type.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, rendering the axis unnecessary in this scenario.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D quantized input tensor to be de-quantized.</dd>
+<dt><tt>x_scale</tt> : T2</dt>
+<dd>Scale for input 'x'. It can be a scalar, which means a per-tensor/layer dequantization, or a 1-D tensor for per-axis dequantization.</dd>
+<dt><tt>x_zero_point</tt> (optional) : T1</dt>
+<dd>Zero point for input 'x'. Shape must match x_scale. It's optional. Zero point is 0 when it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T2</dt>
+<dd>N-D full precision output tensor. It has same shape as input 'x'.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8), tensor(int32), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain 'x_zero_point' and 'x' to 8-bit integer or float, or /32-bit integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>'x_scale' determines the output type.</dd>
+</dl>
+
+### <a name="Equal-19"></a>**Equal-19**</a>
+
+  Returns the tensor resulted from performing the `equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(string)</dt>
+<dd>Constrain input types to all (non-complex) tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+### <a name="Identity-19"></a>**Identity-19**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : V</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : V</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain input and output types to all tensor, sequence, and optional types.</dd>
+</dl>
+
+### <a name="If-19"></a>**If-19**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same data type. The `then_branch` and `else_branch` may produce tensors with the same element type and different shapes. If corresponding outputs from the then-branch and the else-branch have static shapes S1 and S2, then the shape of the corresponding output variable of the if-node (if present) must be compatible with both S1 and S2 as it represents the union of both possible shapes.For example, if in a model file, the first output of `then_branch` is typed float tensor with shape [2] and the first output of `else_branch` is another float tensor with shape [3], If's first output should have (a) no shape set, or (b) a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) a shape of rank 1 with a unique `dim_param`. In contrast, the first output cannot have the shape [2] since [2] and [3] are not compatible.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv9.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+### <a name="Loop-19"></a>**Loop-19**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+  * input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+  * input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+  * input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]           // iteration number
+        %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+        %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+      ) {
+        %my_local = Add(%a, %b_in)
+        %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+        %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+        %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+        return %keepgoing_out, %b_out, %user_defined_val
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        /* initialize loop-carried variables and scan-output variables */
+        bool keepgoing_out = keepgoing
+        int b_out = b
+
+        for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+          /* Implicitly-defined code: bind actual parameter values
+             to formal parameter variables of loop-body */
+          bool keepgoing_in = keepgoing_out;
+          bool b_in = b_out;
+
+          /* User-defined code (loop body) */
+          int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+          b_out = a - b_in;
+          keepgoing_out = my_local > b_out;
+          user_defined_val = b_in + b_in; // b_in and b_out are different variables
+          /* End user-defined code */
+
+          /* Implicitly defined-code */
+          user_defined_vals[i] = user_defined_val // accumulate scan-output values
+        }
+        // int t = my_local; // Can't do this. my_local is not accessible here.
+
+        // The values below are bound to the output variables of the loop and therefore accessible
+        // b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any values computed in the loop body that needs to be used in a subsequent
+     iteration or after the loop are modeled using a pair of variables in the loop-body,
+     consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+     These are referred to as loop-carried dependences. The loop operation node
+     supplies the input value of the input variable for the first iteration, and
+     returns the output value of the output variable produced by the final
+     iteration.
+  3) Scan_output variables are used to implicitly concatenate values computed across
+     all the iterations. In the above example, the value of user_defined_val computed
+     over all iterations are concatenated and returned as the value of user_defined_vals
+     after the loop.
+  4) Values created in the body cannot be accessed in the enclosing scope,
+     except using the mechanism described above.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+  The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs. Scan outputs must be Tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv9.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+### <a name="Pad-19"></a>**Pad-19**</a>
+
+  Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+  a padded tensor (`output`) is generated.
+
+  The four supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+  1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+  2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+  3) `edge` - pads with the edge values of array
+
+  4) `wrap` - wrap-around padding as if the data tensor forms a torus
+
+
+  Example 1 (`constant` mode):
+
+  Insert 0 pads to the beginning of the second dimension.
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'constant'
+
+  constant_value = 0.0
+
+  output = [
+      [0.0, 0.0, 1.0, 1.2],
+      [0.0, 0.0, 2.3, 3.4],
+      [0.0, 0.0, 4.5, 5.7],
+  ]
+  ```
+
+  Example 2 (`reflect` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'reflect'
+
+  output = [
+      [1.0, 1.2, 1.0, 1.2],
+      [2.3, 3.4, 2.3, 3.4],
+      [4.5, 5.7, 4.5, 5.7],
+  ]
+  ```
+
+  Example 3 (`edge` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'edge'
+
+  output = [
+      [1.0, 1.0, 1.0, 1.2],
+      [2.3, 2.3, 2.3, 3.4],
+      [4.5, 4.5, 4.5, 5.7],
+  ]
+  ```
+
+  Example 4 (`wrap` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [2, 1, 1, 1]
+
+  mode = 'wrap'
+
+  output = [
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Supported modes: `constant`(default), `reflect`, `edge`, `wrap`</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Input tensor.</dd>
+<dt><tt>pads</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. `pads` should be a 1D tensor of shape [2 * num_axes] where `num_axes` refers to the number of elements in the `axes` input or the input rank if `axes` are not provided explicitly. `pads` format should be: [x1_begin, x2_begin, ..., x1_end, x2_end,...], where xi_begin is the number of pad values added at the beginning of axis `axes[i]` and xi_end, the number of pad values added at the end of axis `axes[i]`.</dd>
+<dt><tt>constant_value</tt> (optional, non-differentiable) : T</dt>
+<dd>(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, empty string or False).</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of axes that `pads` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated. If not provided, all axes are assumed (`[0, 1, ..., input_rank-1]`).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="QuantizeLinear-19"></a>**QuantizeLinear-19**</a>
+
+  The linear quantization operator. It consumes a high precision tensor, a scale, and a zero point to compute the low precision / quantized tensor.
+  The scale factor and zero point must have same shape, and can be either a scalar for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+  The quantization formula is `y = saturate ((x / y_scale) + y_zero_point)`.
+  For saturation, it saturates to [0, 255] if it's uint8, or [-128, 127] if it's int8.
+  For (x / y_scale), it's rounding to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+  'y_zero_point' and 'y' must have same type.
+  'y_zero_point' is usually not used for quantization to float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz,
+  but the quantization formula remains the same for consistency and
+  the type of the attribute 'y_zero_point' still determines the quantization type.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the quantization dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 quantization (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. All cases are fully described in two tables inserted in the operator description.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D full precision Input tensor to be quantized.</dd>
+<dt><tt>y_scale</tt> : T1</dt>
+<dd>Scale for doing quantization to get 'y'. It can be a scalar, which means per-tensor/layer quantization, or a 1-D Tensor for per-axis quantization.</dd>
+<dt><tt>y_zero_point</tt> (optional) : T2</dt>
+<dd>Zero point for doing quantization to get 'y'. Shape must match y_scale. Default is uint8 with zero point of 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T2</dt>
+<dd>N-D quantized output tensor. It has same shape as input 'x'.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32)</dt>
+<dd>Constrain 'x' to float, float16, bfloat16 or int32 tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain 'y_zero_point' and 'y' to 8-bit integer/float tensor.</dd>
+</dl>
+
+### <a name="Reshape-19"></a>**Reshape-19**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). If 'allowzero' is set, and the new shape includes 0, the
+  dimension will be set explicitly to zero (i.e. not taken from input tensor).
+  Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+  If the attribute 'allowzero' is set, it is invalid for the specified shape to
+  contain both a zero value and -1, as the value of the dimension corresponding
+  to -1 cannot be determined uniquely.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>allowzero</tt> : int (default is 0)</dt>
+<dd>(Optional) By default, when any value in the 'shape' input is equal to zero the corresponding dimension value is copied from the input tensor dynamically. allowzero=1 indicates that if any value in the 'shape' input is set to zero, the zero value is honored, similar to NumPy.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Specified shape for output.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> (differentiable) : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Resize-19"></a>**Resize-19**</a>
+
+  Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
+  Each dimension value of the output tensor is:
+  ```
+  output_dimension = floor(input_dimension * (roi_end - roi_start) * scale)
+  ```
+  if input \"sizes\" is not specified.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>antialias</tt> : int (default is 0)</dt>
+<dd>If set to 1, "linear" and "cubic" interpolation modes will use an antialiasing filter when downscaling. Antialiasing is achieved by stretching the resampling filter by a factor max(1, 1 / scale), which means that when downsampling, more input pixels contribute to an output pixel.</dd>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>If provided, it specifies a subset of axes that 'roi', 'scales' and 'sizes' refer to. If not provided, all axes are assumed [0, 1, ..., r-1], where r = rank(data). Non-specified dimensions are interpreted as non-resizable. Negative value means counting dimensions from the back. Accepted range is [-r, r-1], where r = rank(data). Behavior is undefined if an axis is repeated.</dd>
+<dt><tt>coordinate_transformation_mode</tt> : string (default is half_pixel)</dt>
+<dd>
+This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor.
+
+The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
+Denote `x_resized` as the coordinate of axis x in the resized tensor,
+ `x_original` as the coordinate of axis x in the original tensor,
+ `length_original` as the length of the original tensor in axis x,
+ `length_resized` as the length of the resized tensor in axis x,
+ `scale = length_resized / length_original`,
+ `output_width` the target length on the axis x which can be a fractional number when it is calculated out of a scale factor,
+ and `output_width_int` the effective output width as an integer.
+
+if coordinate_transformation_mode is `"half_pixel"`,
+```
+x_original = (x_resized + 0.5) / scale - 0.5
+```
+
+if coordinate_transformation_mode is `"half_pixel_symmetric"`,
+```
+adjustment = output_width_int / output_width
+center = input_width / 2
+offset = center * (1 - adjustment)
+x_ori = offset + (x + 0.5) / scale - 0.5
+```
+
+if coordinate_transformation_mode is `"pytorch_half_pixel"`,
+```
+x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0
+```
+
+if coordinate_transformation_mode is `"align_corners"`,
+```
+x_original = x_resized * (length_original - 1) / (length_resized - 1)
+```
+
+if coordinate_transformation_mode is `"asymmetric"`,
+```
+x_original = x_resized / scale
+```
+
+if coordinate_transformation_mode is `"tf_crop_and_resize"`,
+```
+x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1)
+```
+.</dd>
+<dt><tt>cubic_coeff_a</tt> : float (default is -0.75)</dt>
+<dd>The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75 (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. This attribute is valid only if mode is "cubic".</dd>
+<dt><tt>exclude_outside</tt> : int (default is 0)</dt>
+<dd>If set to 1, the weight of sampling locations outside the tensor will be set to 0 and the weight will be renormalized so that their sum is 1.0. The default value is 0.</dd>
+<dt><tt>extrapolation_value</tt> : float (default is 0.0)</dt>
+<dd>When coordinate_transformation_mode is "tf_crop_and_resize" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f.</dd>
+<dt><tt>keep_aspect_ratio_policy</tt> : string (default is stretch)</dt>
+<dd>
+This attribute describes how to interpret the `sizes` input with regard to keeping the original aspect ratio of the input, and it is not applicable when
+the `scales` input is used.
+
+Given a set of `sizes`, associated with a subset of `axes` (explicitly provided or default), and assuming `d = axes[i]`, with `i` being the index of the provided `sizes`.
+
+If `keep_aspect_ratio_policy` is `"stretch"`, the original aspect ratio is disregarded, and the input is resized to the specified size:
+`out_size[d] = sizes[i]`
+
+If `keep_aspect_ratio_policy` is `"not_larger"`, the sizes are adjusted so that no extent of the output is larger than the specified size, while keeping the original aspect ratio:
+```
+scale = Min(sizes[i] / in_size[d])
+out_size[d] = round_int(scale * in_size[d])
+```
+
+If `keep_aspect_ratio_policy` is `"not_smaller"`, the sizes are adjusted so that no extent of the output is smaller than the specified size, while keeping the original aspect ratio:
+```
+scale = Max(sizes[i] / in_size[d])
+out_size[d] = round_int(scale * in_size[d])
+```
+
+For non-resizable axes (those not specified in `axes`), the output size will be equal to the input size.
+
+Note: `round_int` stands for computing the nearest integer value, rounding halfway cases up.</dd>
+<dt><tt>mode</tt> : string (default is nearest)</dt>
+<dd>Three interpolation modes: "nearest" (default), "linear" and "cubic". The "linear" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). The "cubic" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor).</dd>
+<dt><tt>nearest_mode</tt> : string (default is round_prefer_floor)</dt>
+<dd>Four modes: "round_prefer_floor" (default, as known as round half down), "round_prefer_ceil" (as known as round half up), "floor", "ceil". Only used by nearest interpolation. It indicates how to get "nearest" pixel in input tensor from x_original, so this attribute is valid only if "mode" is "nearest".</dd>
+</dl>
+
+#### Inputs (1 - 4)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>N-D tensor</dd>
+<dt><tt>roi</tt> (optional, non-differentiable) : T2</dt>
+<dd>1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X or the length of axes, if provided. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is "tf_crop_and_resize"</dd>
+<dt><tt>scales</tt> (optional, non-differentiable) : tensor(float)</dt>
+<dd>The scale array along each dimension. It takes value greater than 0. If it's less than 1, it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should be the same as the rank of input 'X' or the length of 'axes', if provided. One of 'scales' and 'sizes' MUST be specified and it is an error if both are specified. If 'sizes' is needed, the user can use an empty string as the name of 'scales' in this operator's input list.</dd>
+<dt><tt>sizes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Target size of the output tensor. Its interpretation depends on the 'keep_aspect_ratio_policy' value.The number of elements of 'sizes' should be the same as the rank of input 'X', or the length of 'axes', if provided. Only one of 'scales' and 'sizes' can be specified. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>N-D tensor after resizing</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input 'X' and output 'Y' to all tensor types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain roi type to float or double.</dd>
+</dl>
+
+### <a name="Scan-19"></a>**Scan-19**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops).
+  Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+  well as scan_output_element tensors) are required to have the same shape in each iteration
+  of the loop (a restriction imposed to enable efficient memory allocation).
+
+  Note that the iterated element passed to the body subgraph does not have a sequence
+  axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The optional attribute scan_input_directions specifies the direction (forward or backward)
+  for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+  direction. A bidirectional scan may be performed by specifying the same tensor input twice
+  in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+  The scan_output of the operation is produced by concatenating the scan_output_element
+  values produced by the body in each iteration.  The optional attribute scan_output_directions
+  specifies the direction in which scan_output is constructed (by appending or prepending the
+  scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+  is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+  The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+  If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+  batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+  Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+  The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+  are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+  scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+  value of 1.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body,
+          scan_input_axes = [axis_1, ..., axis_m]
+      > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+      sequence_length = scan_1.shape[axis_1];
+
+      // initialize state-variables
+      st_1 = init_1; ... st_n = init_n;
+      // initialize scan-output variables: [] denotes an empty tensor
+      scan_out_1 = []; ...; scan_out_k = [];
+      // identify number of iterations:
+
+      // execute loop
+      for (int t = 0; t < sequence_length; ++t) {
+          // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+          // of rank one less than T obtained by indexing T at position t along axis k.
+          si_1 = scan_1<axis=axis_1>[t];
+          ... ;
+          si_m = scan_m<axis=axis_m>[t];
+          // execute loop-body
+          st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+          // accumulate the scan-output elements
+          scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+      }
+
+      return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+<dt><tt>scan_input_axes</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the axis to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will be used as the scan axis for every scan_input. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>scan_input_directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>scan_output_axes</tt> : list of ints</dt>
+<dd>An optional list of K flags. The i-th element of the list specifies the axis for the i-th scan_output. The scan outputs are accumulated along the specified axis. If omitted, 0 will be used as the scan axis for every scan_output. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1].</dd>
+<dt><tt>scan_output_directions</tt> : list of ints</dt>
+<dd>An optional list of K flags, one for each scan_output. The i-th element of the list specifies whether the i-th scan_output should be constructed by appending or prepending a new value in each iteration: 0 indicates appending and 1 indicates prepending. If omitted, all scan_output tensors will be produced by appending a value in each iteration.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>All Tensor types up to IRv9.</dd>
+</dl>
+
+### <a name="Shape-19"></a>**Shape-19**</a>
+
+  Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+  Optional attributes start and end can be used to compute a slice of the input tensor's shape.
+  If start axis is omitted, the slice starts from axis 0.
+  The end axis, if specified, is exclusive (and the returned value will not include the size of that axis).
+  If the end axis is omitted, the axes upto the last one will be included.
+  Negative axes indicate counting back from the last axis.
+  Note that axes will be clamped to the range [0, r], where r is the
+  rank of the input tensor if they are out-of-range (after adding r in the case of
+  negative axis). Thus, specifying any end value > r is equivalent to specifying an end
+  value of r, and specifying any start value < -r is equivalent to specifying a start
+  value of 0. If start > end, the result will be an empty shape.
+
+  Examples:
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  No attributes specified.
+  Output: [2, 3, 4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: -1
+  Output: [4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  end: -1
+  Output: [2, 3]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: 1
+  end: 2
+  Output: [3]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>end</tt> : int</dt>
+<dd>(Optional) Ending axis for slicing the shape. Negative value means counting dimensions from the back. If omitted, sizes of all axes upto (including) the last one will be included.</dd>
+<dt><tt>start</tt> : int (default is 0)</dt>
+<dd>(Optional) Starting axis for slicing the shape. Default value is 0.Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>shape</tt> (non-differentiable) : T1</dt>
+<dd>Shape of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor.</dd>
+</dl>
+
+### <a name="Size-19"></a>**Size-19**</a>
+
+  Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>Total number of elements of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor, which should be a scalar though.</dd>
+</dl>
+
+## Version 20 of the default ONNX operator set
+### <a name="AffineGrid-20"></a>**AffineGrid-20**</a>
+
+  Generates a 2D or 3D flow field (sampling grid), given a batch of affine matrices theta
+  (https://pytorch.org/docs/stable/generated/torch.nn.functional.affine_grid.html).
+  An affine matrix `theta` is applied to a position tensor represented in its homogeneous expression. Here is an example in 3D:
+  ```
+  [r00, r01, r02, t0]   [x]   [x']
+  [r10, r11, r12, t1] * [y] = [y']
+  [r20, r21, r22, t2]   [z]   [z']
+  [0,   0,   0,   1 ]   [1]   [1 ]
+  ```
+  where `(x, y, z)` is the position in the original space, `(x', y', z')` is the position in the output space.
+  The last row is always `[0, 0, 0, 1]` and is not stored in the affine matrix. Therefore we have `theta` of shape `(N, 2, 3)` for 2D or `(N, 3, 4)` for 3D.
+
+  Input `size` is used to define grid of positions evenly spaced in the original 2D or 3D space, with dimensions ranging from `-1` to `1`.
+  The output `grid` contains positions in the output space.
+
+  When `align_corners=1`, consider `-1` and `1` to refer to the centers of the corner pixels (mark `v` in illustration).
+  ```
+  v            v            v            v
+  |-------------------|------------------|
+  -1                  0                  1
+  ```
+  When `align_corners=0`, consider `-1` and `1` to refer to the outer edge of the corner pixels.
+  ```
+      v        v         v         v
+  |------------------|-------------------|
+  -1                 0                   1
+  ```
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>align_corners</tt> : int (default is 0)</dt>
+<dd>if align_corners=1, consider -1 and 1 to refer to the centers of the corner pixels. if align_corners=0, consider -1 and 1 to refer to the outer edge the corner pixels.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>theta</tt> (non-differentiable) : T1</dt>
+<dd>input batch of affine matrices with shape (N, 2, 3) for 2D or (N, 3, 4) for 3D</dd>
+<dt><tt>size</tt> (non-differentiable) : T2</dt>
+<dd>the target output image size (N, C, H, W) for 2D or (N, C, D, H, W) for 3D</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>grid</tt> (differentiable) : T1</dt>
+<dd>output tensor of shape (N, H, W, 2) of 2D sample coordinates or (N, D, H, W, 3) of 3D sample coordinates.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain grid types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain size's type to int64 tensors.</dd>
+</dl>
+
+### <a name="ConstantOfShape-20"></a>**ConstantOfShape-20**</a>
+
+  Generate a tensor with given value and shape.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>value</tt> : tensor</dt>
+<dd>(Optional) The value of the output elements.Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar. All values must be >= 0.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of shape specified by 'input'.If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'.If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype defaults to float32.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain input types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain output types to be numerics.</dd>
+</dl>
+
+### <a name="DFT-20"></a>**DFT-20**</a>
+
+  Computes the discrete Fourier Transform (DFT) of the input.
+
+  Assuming the input has shape `[M, N]`, where `N` is the dimension over which the
+  DFT is computed and `M` denotes the conceptual "all other dimensions,"
+  the DFT `y[m, k]` of shape `[M, N]` is defined as
+
+  $$y[m, k] = \sum_{n=0}^{N-1} e^{-2 \pi j \frac{k n}{N} } x[m, n] ,$$
+
+  and the inverse transform is defined as
+
+  $$x[m, n] = \frac{1}{N} \sum_{k=0}^{N-1} e^{2 \pi j \frac{k n}{N} } y[m, k] ,$$
+
+  where $j$ is the imaginary unit.
+
+  The actual shape of the output is specified in the "output" section.
+
+  Reference: https://docs.scipy.org/doc/scipy/tutorial/fft.html
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>inverse</tt> : int (default is 0)</dt>
+<dd>Whether to perform the inverse discrete Fourier Transform. Default is 0, which corresponds to `false`.</dd>
+<dt><tt>onesided</tt> : int (default is 0)</dt>
+<dd>If `onesided` is `1`, only values for `k` in `[0, 1, 2, ..., floor(n_fft/2) + 1]` are used or returned because the real-to-complex Fourier transform satisfies the conjugate symmetry, i.e., `X[m, k] = X[m, n_fft-k]*`, where `m` denotes "all other dimensions" DFT was not applied on. When `onesided=1` and `inverse=0` (forward DFT), only real input is supported and a one-sided complex spectrum is returned (RFFT). When `onesided=1` and `inverse=1` (inverse DFT), only complex input is supported and a full real signal is returned (IRFFT). Value can be `0` or `1`. Default is `0`.</dd>
+</dl>
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>input</tt> (non-differentiable) : T1</dt>
+<dd>For real input, the following shape is expected: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][1]`. For complex input, the following shape is expected: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][2]`. The final dimension represents the real and imaginary parts of the value in that order.</dd>
+<dt><tt>dft_length</tt> (optional, non-differentiable) : T2</dt>
+<dd>The length of the signal as a scalar. If greater than the axis dimension, the signal will be zero-padded up to `dft_length`. If less than the axis dimension, only the first `dft_length` values will be used as the signal. If not provided, the default `dft_length = signal_dim_axis`, except for the IRFFT case (`onesided=1`, `inverse=1`), in which case the default dft_length is `2 * (signal_dim_axis - 1)`.</dd>
+<dt><tt>axis</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>The axis as a scalar on which to perform the DFT. Default is `-2` (last signal axis). Negative value means counting dimensions from the back. Accepted range is $[-r, -2] \cup [0, r-2]$ where `r = rank(input)`. The last dimension is for representing complex numbers and thus is an invalid axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T1</dt>
+<dd>The Fourier Transform of the input vector. For standard DFT (`onesided=0`), the output shape is: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][2]` (complex), with `signal_dim_axis = dft_length`. For RFFT (`onesided=1`, `inverse=0`), the output shape is: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][2]` (one-sided complex), with `signal_dim_axis = floor(dft_length/2) + 1`. For IRFFT (`onesided=1`, `inverse=1`), the output shape is: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][1]` (real), where `signal_dim_axis = dft_length`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain scalar length types to integers.</dd>
+</dl>
+
+### <a name="Gelu-20"></a>**Gelu-20**</a>
+
+  Gelu takes one input data (Tensor<T>) and produces one
+  output data (Tensor<T>) where the gaussian error linear units function,
+  $y = 0.5 * x * (1 + erf(x/sqrt(2)))$ is applied to the tensor elementwise.
+  If the attribute "approximate" is set to "tanh", the function estimation,
+  $y = 0.5 * x * (1 + Tanh(sqrt(2/\pi) * (x + 0.044715 * x^3)))$ is used and applied
+  to the tensor elementwise.
+
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>approximate</tt> : string (default is none)</dt>
+<dd>Gelu approximation algorithm: `"tanh"`, `"none"`(default).`"none"`: do not use approximation.`"tanh"`: use tanh approximation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="GridSample-20"></a>**GridSample-20**</a>
+
+  Given an input `X` and a flow-field `grid`, computes the output `Y` using `X` values and pixel locations from the `grid`.
+  For spatial input `X` with shape (N, C, H, W), the `grid` will have shape (N, H_out, W_out, 2),
+  the output `Y` will have shape (N, C, H_out, W_out). For volumetric input `X` with shape (N, C, D, H, W),
+  the `grid` will have shape (N, D_out, H_out, W_out, 3), the output `Y` will have shape (N, C, D_out, H_out, W_out).
+  More generally, for an input `X` of rank r+2 with shape (N, C, d1, d2, ..., dr),
+  the `grid` will have shape (N, D1_out, D2_out, ..., Dr_out, r), the output `Y` will have shape (N, C, D1_out, D2_out, ..., Dr_out).
+
+  The tensor `X` contains values at centers of square pixels (voxels, etc) locations such as (n, c, d1_in, d2_in, ..., dr_in).
+  The (n, d1_out, d2_out, ..., dr_out, :) values from the tensor `grid` are the normalized positions for interpolating the values
+  at the (n, c, d1_out, d2_out, ..., dr_out) locations from the output tensor `Y` using a specified interpolation method (the mode)
+  and a padding mode (for `grid` positions falling outside the 2-dimensional image).
+
+  For example, the values in `grid[n, h_out, w_out, :]` are size-2 vectors specifying normalized positions in the 2-dimensional space of `X`.
+  They are used to interpolate output values of `Y[n, c, h_out, w_out]`.
+
+  The GridSample operator is often used in doing grid generator and sampler in the
+  [Spatial Transformer Networks](https://arxiv.org/abs/1506.02025).
+  See also in [torch.nn.functional.grid_sample](https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html).
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>align_corners</tt> : int (default is 0)</dt>
+<dd>If align_corners=1, the extrema (-1 and 1) are considered as referring to the center points of the input's corner pixels (voxels, etc.). If align_corners=0, they are instead considered as referring to the corner points of the input's corner pixels (voxels, etc.), making the sampling more resolution agnostic.</dd>
+<dt><tt>mode</tt> : string (default is linear)</dt>
+<dd>Three interpolation modes: linear (default), nearest and cubic. The "linear" mode includes linear and N-linear interpolation modes depending on the number of spatial dimensions of the input tensor (i.e. linear for 1 spatial dimension, bilinear for 2 spatial dimensions, etc.). The "cubic" mode also includes N-cubic interpolation modes following the same rules. The "nearest" mode rounds to the nearest even index when the sampling point falls halfway between two indices.</dd>
+<dt><tt>padding_mode</tt> : string (default is zeros)</dt>
+<dd>Support padding modes for outside grid values: `zeros`(default), `border`, `reflection`. zeros: use 0 for out-of-bound grid locations, border: use border values for out-of-bound grid locations, reflection: use values at locations reflected by the border for out-of-bound grid locations. If index 0 represents the margin pixel, the reflected value at index -1 will be the same as the value at index 1. For location far away from the border, it will keep being reflected until becoming in bound. If pixel location x = -3.5 reflects by border -1 and becomes x' = 1.5, then reflects by border 1 and becomes x'' = 0.5.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>Input tensor of rank r+2 that has shape (N, C, D1, D2, ..., Dr), where N is the batch size, C is the number of channels, D1, D2, ..., Dr are the spatial dimensions.</dd>
+<dt><tt>grid</tt> (non-differentiable) : T2</dt>
+<dd>Input offset of shape (N, D1_out, D2_out, ..., Dr_out, r), where D1_out, D2_out, ..., Dr_out are the spatial dimensions of the grid and output, and r is the number of spatial dimensions. Grid specifies the sampling locations normalized by the input spatial dimensions. Therefore, it should have most values in the range of [-1, 1]. If the grid has values outside the range of [-1, 1], the corresponding outputs will be handled as defined by padding_mode. Following computer vision convention, the coordinates in the length-r location vector are listed from the innermost tensor dimension to the outermost, the opposite of regular tensor indexing.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>Output tensor of rank r+2 that has shape (N, C, D1_out, D2_out, ..., Dr_out) of the sampled values. For integer input types, intermediate values are computed as floating point and cast to integer at the end.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input `X` and output `Y` types to all tensor types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain grid types to float tensors.</dd>
+</dl>
+
+### <a name="ImageDecoder-20"></a>**ImageDecoder-20**</a>
+
+  Loads and decodes and image from a file. If it can't decode for any reason (e.g. corrupted encoded
+  stream, invalid format, it will return an empty matrix).
+  The following image formats are supported:
+  * BMP
+  * JPEG (note: Lossless JPEG support is optional)
+  * JPEG2000
+  * TIFF
+  * PNG
+  * WebP
+  * Portable image format (PBM, PGM, PPM, PXM, PNM)
+  Decoded images follow a channel-last layout: (Height, Width, Channels).
+  **JPEG chroma upsampling method:**
+  When upsampling the chroma components by a factor of 2, the pixels are linearly interpolated so that the
+  centers of the output pixels are 1/4 and 3/4 of the way between input pixel centers.
+  When rounding, 0.5 is rounded down and up at alternative pixels locations to prevent bias towards
+  larger values (ordered dither pattern).
+  Considering adjacent input pixels A, B, and C, B is upsampled to pixels B0 and B1 so that
+  ```
+  B0 = round_half_down((1/4) * A + (3/4) * B)
+  B1 = round_half_up((3/4) * B + (1/4) * C)
+  ```
+  This method,  is the default chroma upsampling method in the well-established libjpeg-turbo library,
+  also referred as "smooth" or "fancy" upsampling.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>pixel_format</tt> : string (default is RGB)</dt>
+<dd>Pixel format. Can be one of "RGB", "BGR", or "Grayscale".</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>encoded_stream</tt> (non-differentiable) : T1</dt>
+<dd>Encoded stream</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>image</tt> (non-differentiable) : T2</dt>
+<dd>Decoded image</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8)</dt>
+<dd>Constrain input types to 8-bit unsigned integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(uint8)</dt>
+<dd>Constrain output types to 8-bit unsigned integer tensor.</dd>
+</dl>
+
+### <a name="IsInf-20"></a>**IsInf-20**</a>
+
+  Map infinity to true and other values to false.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>detect_negative</tt> : int (default is 1)</dt>
+<dd>(Optional) Whether map negative infinity to true. Default to 1 so that negative infinity induces true. Set this attribute to 0 if negative infinity should be mapped to false.</dd>
+<dt><tt>detect_positive</tt> : int (default is 1)</dt>
+<dd>(Optional) Whether map positive infinity to true. Default to 1 so that positive infinity induces true. Set this attribute to 0 if positive infinity should be mapped to false.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output types to boolean tensors.</dd>
+</dl>
+
+### <a name="IsNaN-20"></a>**IsNaN-20**</a>
+
+  Returns which elements of the input are NaN.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output types to boolean tensors.</dd>
+</dl>
+
+### <a name="ReduceMax-20"></a>**ReduceMax-20**</a>
+
+  Computes the max of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or the minimum value of the data type otherwise.
+
+
+  If the input data type is Boolean, the comparison should consider `False < True`.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(uint8), tensor(int8), tensor(bool)</dt>
+<dd>Constrain input and output types to numeric and Boolean tensors.</dd>
+</dl>
+
+### <a name="ReduceMin-20"></a>**ReduceMin-20**</a>
+
+  Computes the min of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields plus infinity (if supported by the datatype) or the maximum value of the data type otherwise.
+
+
+  If the input data type is Boolean, the comparison should consider `False < True`.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(uint8), tensor(int8), tensor(bool)</dt>
+<dd>Constrain input and output types to numeric and Boolean tensors.</dd>
+</dl>
+
+### <a name="RegexFullMatch-20"></a>**RegexFullMatch-20**</a>
+
+  RegexFullMatch performs a full regex match on each element of the input tensor. If an element fully matches the regex pattern specified as an attribute, the corresponding element in the output is True and it is False otherwise. [RE2](https://github.com/google/re2/wiki/Syntax) regex syntax is used.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>pattern</tt> : string</dt>
+<dd>Regex pattern to match on. This must be valid RE2 syntax.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>Tensor with strings to match on.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>Tensor of bools indicating if each input string fully matches the regex pattern specified.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string)</dt>
+<dd>Inputs must be UTF-8 strings</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Outputs are bools and are True where there is a full regex match and False otherwise.</dd>
+</dl>
+
+### <a name="StringConcat-20"></a>**StringConcat-20**</a>
+
+  StringConcat concatenates string tensors elementwise (with NumPy-style broadcasting support)
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Tensor to prepend in concatenation</dd>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Tensor to append in concatenation</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> (non-differentiable) : T</dt>
+<dd>Concatenated string tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(string)</dt>
+<dd>Inputs and outputs must be UTF-8 strings</dd>
+</dl>
+
+### <a name="StringSplit-20"></a>**StringSplit-20**</a>
+
+  StringSplit splits a string tensor's elements into substrings based on a delimiter attribute and a maxsplit attribute.
+
+  The first output of this operator is a tensor of strings representing the substrings from splitting each input string on the `delimiter` substring. This tensor has one additional rank compared to the input tensor in order to store the substrings for each input element (where the input tensor is not empty). Note that, in order to ensure the same number of elements are present in the final dimension, this tensor will pad empty strings as illustrated in the examples below. Consecutive delimiters are not grouped together and are deemed to delimit empty strings, except if the `delimiter` is unspecified or is the empty string (""). In the case where the `delimiter` is unspecified or the empty string, consecutive whitespace characters are regarded as a single separator and leading or trailing whitespace is removed in the output.
+
+  The second output tensor represents the number of substrings generated. `maxsplit` can be used to limit the number of splits performed - after the `maxsplit`th split if the string is not fully split, the trailing suffix of input string after the final split point is also added. For elements where fewer splits are possible than specified in `maxsplit`, it has no effect.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>delimiter</tt> : string</dt>
+<dd>Delimiter to split on. If left unset or set to the empty string (""), the input is split on consecutive whitespace.</dd>
+<dt><tt>maxsplit</tt> : int</dt>
+<dd>Maximum number of splits (from left to right). If left unset (or if the number of possible splits are less than maxsplit), it will make as many splits as possible. Note that the maximum possible number of substrings returned with `maxsplit` specified is `maxsplit+1` since the remaining suffix after the `maxsplit`th split is included in the output.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>Tensor of strings to split.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>Tensor of substrings representing the outcome of splitting the strings in the input on the delimiter. Note that to ensure the same number of elements are present in the final rank, this tensor will pad any necessary empty strings.</dd>
+<dt><tt>Z</tt> (non-differentiable) : T3</dt>
+<dd>The number of substrings generated for each input element.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string)</dt>
+<dd>The input must be a UTF-8 string tensor</dd>
+<dt><tt>T2</tt> : tensor(string)</dt>
+<dd>Tensor of substrings.</dd>
+<dt><tt>T3</tt> : tensor(int64)</dt>
+<dd>The number of substrings generated.</dd>
+</dl>
+
+## Version 21 of the default ONNX operator set
+### <a name="Cast-21"></a>**Cast-21**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+
+  Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+  (e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+  yield result 100. There are some string literals reserved for special floating-point values;
+  "+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+  Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+  this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+  to string tensors, plain floating-point representation (such as "314.15926") would be used.
+  Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+  of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+  Conversion from a numerical type to any numerical type is always allowed.
+  User must be aware of precision loss and value change caused by range difference between two types.
+  For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+  an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+  In more detail, the conversion among numerical types should follow these rules
+  if the destination type is not a float 8 type.
+
+  * Casting from floating point to:
+    * floating point: +/- infinity if OOR (out of range).
+    * fixed point: undefined if OOR.
+    * bool: +/- 0.0 to False; all else to True.
+  * Casting from fixed point to:
+    * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+    * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+      signed types). For example, 200 (int16) -> -56 (int8).
+    * bool: zero to False; nonzero to True.
+  * Casting from bool to:
+    * floating point: `{1.0, 0.0}`.
+    * fixed point: `{1, 0}`.
+    * bool: no change.
+
+  Float 8 type were introduced to speed up the training of
+  deep models. By default the conversion of a float *x* obeys
+  to the following rules. `[x]` means the value rounded to
+  the target mantissa width.
+
+  | x                 | E4M3FN   | E4M3FNUZ | E5M2     | E5M2FNUZ |
+  | ----------------- | -------- | -------- | -------- | -------- |
+  | 0                 | 0        | 0        | 0        | 0        |
+  | -0                | -0       | 0        | -0       | 0        |
+  | NaN               | NaN      | NaN      | NaN      | NaN      |
+  | Inf               | FLT_MAX  | NaN      | FLT_MAX  | NaN      |
+  | -Inf              | -FLT_MAX | NaN      | -FLT_MAX | NaN      |
+  | \[x\] > FLT_MAX   | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+  | \[x\] \< -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+  | else              | RNE      | RNE      | RNE      | RNE      |
+
+  The behavior changes if the parameter 'saturate' is set to False.
+  The rules then become:
+
+  | x                 | E4M3FN | E4M3FNUZ | E5M2 | E5M2FNUZ |
+  | ----------------- | ------ | -------- | ---- | -------- |
+  | 0                 | 0      | 0        | 0    | 0        |
+  | -0                | -0     | 0        | -0   | 0        |
+  | NaN               | NaN    | NaN      | NaN  | NaN      |
+  | -NaN              | -NaN   | NaN      | -NaN | NaN      |
+  | Inf               | NaN    | NaN      | Inf  | NaN      |
+  | -Inf              | -NaN   | NaN      | -Inf | NaN      |
+  | \[x\] > FLT_MAX   | NaN    | NaN      | Inf  | NaN      |
+  | \[x\] \< -FLT_MAX | NaN    | NaN      | -Inf | NaN      |
+  | else              | RNE    | RNE      | RNE  | RNE      |
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. All cases are fully described in two tables inserted in the operator description.</dd>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(bool), tensor(string), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="CastLike-21"></a>**CastLike-21**</a>
+
+  The operator casts the elements of a given input tensor (the first input) to
+  the same data type as the elements of the second input tensor.
+  See documentation of the Cast operator for further details.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. Please refer to operator Cast description for further details.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+<dt><tt>target_type</tt> (non-differentiable) : T2</dt>
+<dd>The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor produced by casting the first input tensor to have the same type as the second input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="Constant-21"></a>**Constant-21**</a>
+
+  This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+  or value_* must be specified.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>sparse_value</tt> : sparse_tensor</dt>
+<dd>The value for the elements of the output tensor in sparse format.</dd>
+<dt><tt>value</tt> : tensor</dt>
+<dd>The value for the elements of the output tensor.</dd>
+<dt><tt>value_float</tt> : float</dt>
+<dd>The value for the sole element for the scalar, float32, output tensor.</dd>
+<dt><tt>value_floats</tt> : list of floats</dt>
+<dd>The values for the elements for the 1D, float32, output tensor.</dd>
+<dt><tt>value_int</tt> : int</dt>
+<dd>The value for the sole element for the scalar, int64, output tensor.</dd>
+<dt><tt>value_ints</tt> : list of ints</dt>
+<dd>The values for the elements for the 1D, int64, output tensor.</dd>
+<dt><tt>value_string</tt> : string</dt>
+<dd>The value for the sole element for the scalar, UTF-8 string, output tensor.</dd>
+<dt><tt>value_strings</tt> : list of strings</dt>
+<dd>The values for the elements for the 1D, UTF-8 string, output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="ConstantOfShape-21"></a>**ConstantOfShape-21**</a>
+
+  Generate a tensor with given value and shape.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>value</tt> : tensor</dt>
+<dd>(Optional) The value of the output elements.Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar. All values must be >= 0.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of shape specified by 'input'.If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'.If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype defaults to float32.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain input types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint4), tensor(int4), tensor(bool), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain output types to be numerics or boolean.</dd>
+</dl>
+
+### <a name="DequantizeLinear-21"></a>**DequantizeLinear-21**</a>
+
+  The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the
+  full-precision tensor. The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point`
+  must have the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
+  a 1-D tensor for per-axis quantization, or have a rank identical to the input for blocked quantization.
+  See QuantizeLinear for details on quantization granularity.
+  `x_zero_point` and `x` must have the same type. `x` and `y` must have the same shape. In the case of dequantizing
+  `int32`, there's no zero point (zero point is supposed to be 0).
+  `zero-point` is usually not used in the case of float8 types quantization, but the dequantization formula remains the same
+  for consistency, and `x_scale` still determines the output type.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D quantized input tensor to be de-quantized.</dd>
+<dt><tt>x_scale</tt> : T2</dt>
+<dd>Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>x_zero_point</tt> (optional) : T1</dt>
+<dd>Zero point for input `x`. Shape must match x_scale. It's optional. Zero point is 0 when it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T2</dt>
+<dd>N-D full precision output tensor. It has same shape as input `x`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(int32), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>The type of the inputs 'x_zero_point' and 'x'.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>'x_scale' determines the output type.</dd>
+</dl>
+
+### <a name="Flatten-21"></a>**Flatten-21**</a>
+
+  Flattens the input tensor into a 2D matrix. If input tensor has shape
+  (d_0, d_1, ... d_n) then the output will have shape
+  (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Indicate up to which input dimensions (exclusive) should be flattened to the outer dimension of the output. The value for axis must be in the range [-r, r], where r is the rank of the input tensor. Negative value means counting dimensions from the back. When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), where the shape of the input tensor is (d_0, d_1, ... d_n). </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>A tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>A 2D tensor with the contents of the input tensor, with input dimensions up to axis flattened to the outer dimension of the output and remaining input dimensions flattened into the inner dimension of the output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain input and output to all tensor types up to IRv10.</dd>
+</dl>
+
+### <a name="GroupNormalization-21"></a>**GroupNormalization-21**</a>
+
+  A GroupNormalization function. Carries out group normalization as described in
+  the paper https://arxiv.org/abs/1803.08494
+
+  This operator transforms input according to
+  ```
+  y = scale * (x - mean) / sqrt(variance + epsilon) + bias,
+  ```
+  where the mean and variance are computed per instance per group of channels, and
+  `scale` and `bias` should be specified for each channel. The number of
+  groups `num_groups` should be divisible by the number of channels so that there are
+  an equal number of channels per group.
+
+  The overall computation has two stages: the first stage normalizes the elements to
+  have zero mean and unit variance for each instance in each group, and the second
+  stage scales and shifts the results of the first stage. The floating-point precision
+  used in the first stage is determined by the `stash_type` attribute. For example,
+  if `stash_type` is 1, the operator casts all input variables to 32-bit float,
+  performs the computation, and finally casts the normalized results back to the
+  original type of `X`. The second stage does not depend on `stash_type`.
+
+  When the number of groups is the same as the number of channels, this operator is
+  equivalent to InstanceNormalization. When there is only one group, this operator
+  is equivalent to LayerNormalization.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>num_groups</tt> : int (required)</dt>
+<dd>The number of groups of channels. It should be a divisor of the number of channels `C`.</dd>
+<dt><tt>stash_type</tt> : int (default is 1)</dt>
+<dd>The floating-point precision used in stage one of the computation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor. Dimensions for image cases are `(N x C x H x W)`, where `N` is the batch size, `C` is the number of channels, and `H` and `W` are the height and width of the data. Statistics are computed for every group of channels over `C`, `H`, and `W`. For non-image cases, the dimensions are in the form of `(N x C x D1 x D2 ... Dn)`.</dd>
+<dt><tt>scale</tt> (differentiable) : T</dt>
+<dd>Scale tensor of shape `(C)`.</dd>
+<dt><tt>bias</tt> (differentiable) : T</dt>
+<dd>Bias tensor of shape `(C)`.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>The output tensor of the same shape as `X`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Identity-21"></a>**Identity-21**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : V</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : V</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain input and output types to all tensor, sequence, and optional types.</dd>
+</dl>
+
+### <a name="If-21"></a>**If-21**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same data type. The `then_branch` and `else_branch` may produce tensors with the same element type and different shapes. If corresponding outputs from the then-branch and the else-branch have static shapes S1 and S2, then the shape of the corresponding output variable of the if-node (if present) must be compatible with both S1 and S2 as it represents the union of both possible shapes.For example, if in a model file, the first output of `then_branch` is typed float tensor with shape [2] and the first output of `else_branch` is another float tensor with shape [3], If's first output should have (a) no shape set, or (b) a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) a shape of rank 1 with a unique `dim_param`. In contrast, the first output cannot have the shape [2] since [2] and [3] are not compatible.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv10.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+### <a name="Loop-21"></a>**Loop-21**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+  * input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+  * input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+  * input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]           // iteration number
+        %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+        %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+      ) {
+        %my_local = Add(%a, %b_in)
+        %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+        %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+        %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+        return %keepgoing_out, %b_out, %user_defined_val
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        /* initialize loop-carried variables and scan-output variables */
+        bool keepgoing_out = keepgoing
+        int b_out = b
+
+        for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+          /* Implicitly-defined code: bind actual parameter values
+             to formal parameter variables of loop-body */
+          bool keepgoing_in = keepgoing_out;
+          bool b_in = b_out;
+
+          /* User-defined code (loop body) */
+          int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+          b_out = a - b_in;
+          keepgoing_out = my_local > b_out;
+          user_defined_val = b_in + b_in; // b_in and b_out are different variables
+          /* End user-defined code */
+
+          /* Implicitly defined-code */
+          user_defined_vals[i] = user_defined_val // accumulate scan-output values
+        }
+        // int t = my_local; // Can't do this. my_local is not accessible here.
+
+        // The values below are bound to the output variables of the loop and therefore accessible
+        // b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any values computed in the loop body that needs to be used in a subsequent
+     iteration or after the loop are modeled using a pair of variables in the loop-body,
+     consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+     These are referred to as loop-carried dependences. The loop operation node
+     supplies the input value of the input variable for the first iteration, and
+     returns the output value of the output variable produced by the final
+     iteration.
+  3) Scan_output variables are used to implicitly concatenate values computed across
+     all the iterations. In the above example, the value of user_defined_val computed
+     over all iterations are concatenated and returned as the value of user_defined_vals
+     after the loop.
+  4) Values created in the body cannot be accessed in the enclosing scope,
+     except using the mechanism described above.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+  The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs. Scan outputs must be Tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv10.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+### <a name="Pad-21"></a>**Pad-21**</a>
+
+  Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+  a padded tensor (`output`) is generated.
+
+  The four supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+  1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+  2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+  3) `edge` - pads with the edge values of array
+
+  4) `wrap` - wrap-around padding as if the data tensor forms a torus
+
+
+  Example 1 (`constant` mode):
+
+  Insert 0 pads to the beginning of the second dimension.
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'constant'
+
+  constant_value = 0.0
+
+  output = [
+      [0.0, 0.0, 1.0, 1.2],
+      [0.0, 0.0, 2.3, 3.4],
+      [0.0, 0.0, 4.5, 5.7],
+  ]
+  ```
+
+  Example 2 (`reflect` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'reflect'
+
+  output = [
+      [1.0, 1.2, 1.0, 1.2],
+      [2.3, 3.4, 2.3, 3.4],
+      [4.5, 5.7, 4.5, 5.7],
+  ]
+  ```
+
+  Example 3 (`edge` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'edge'
+
+  output = [
+      [1.0, 1.0, 1.0, 1.2],
+      [2.3, 2.3, 2.3, 3.4],
+      [4.5, 4.5, 4.5, 5.7],
+  ]
+  ```
+
+  Example 4 (`wrap` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [2, 1, 1, 1]
+
+  mode = 'wrap'
+
+  output = [
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Supported modes: `constant`(default), `reflect`, `edge`, `wrap`</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Input tensor.</dd>
+<dt><tt>pads</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. `pads` should be a 1D tensor of shape [2 * num_axes] where `num_axes` refers to the number of elements in the `axes` input or the input rank if `axes` are not provided explicitly. `pads` format should be: [x1_begin, x2_begin, ..., x1_end, x2_end,...], where xi_begin is the number of pad values added at the beginning of axis `axes[i]` and xi_end, the number of pad values added at the end of axis `axes[i]`.</dd>
+<dt><tt>constant_value</tt> (optional, non-differentiable) : T</dt>
+<dd>(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, empty string or False).</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of axes that `pads` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated. If not provided, all axes are assumed (`[0, 1, ..., input_rank-1]`).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv10.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="QLinearMatMul-21"></a>**QLinearMatMul-21**</a>
+
+  Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+  It consumes two quantized input tensors, their scales and zero points, scale and zero point of output,
+  and computes the quantized output. The quantization formula is y = saturate((x / y_scale) + y_zero_point).
+  For (x / y_scale), it is rounding to nearest ties to even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+  Scale and zero point must have same shape. They must be either scalar (per tensor) or N-D tensor
+  (per row for 'a' and per column for 'b'). Scalar refers to per tensor quantization whereas N-D refers to per row
+  or per column quantization. If the input is 2D of shape [M, K] then zero point and scale tensor may be
+  an M element vector [v_1, v_2, ..., v_M] for per row quantization and K element vector of shape [v_1, v_2, ..., v_K]
+  for per column quantization. If the input is N-D tensor with shape [D1, D2, M, K] then zero point and scale tensor may
+  have shape [D1, D2, M, 1] for per row quantization and shape [D1, D2, 1, K] for per column quantization.
+  Production must never overflow, and accumulation may overflow if and only if in 32 bits.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>a</tt> (non-differentiable) : T1</dt>
+<dd>N-dimensional quantized matrix a</dd>
+<dt><tt>a_scale</tt> (non-differentiable) : TS</dt>
+<dd>scale of quantized input a</dd>
+<dt><tt>a_zero_point</tt> (non-differentiable) : T1</dt>
+<dd>zero point of quantized input a</dd>
+<dt><tt>b</tt> (non-differentiable) : T2</dt>
+<dd>N-dimensional quantized matrix b</dd>
+<dt><tt>b_scale</tt> (non-differentiable) : TS</dt>
+<dd>scale of quantized input b</dd>
+<dt><tt>b_zero_point</tt> (non-differentiable) : T2</dt>
+<dd>zero point of quantized input b</dd>
+<dt><tt>y_scale</tt> (non-differentiable) : TS</dt>
+<dd>scale of quantized output y</dd>
+<dt><tt>y_zero_point</tt> (non-differentiable) : T3</dt>
+<dd>zero point of quantized output y</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> (non-differentiable) : T3</dt>
+<dd>Quantized matrix multiply results from a * b</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>TS</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>Constrain scales.</dd>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>The type of input a and its zeropoint.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>The type of input b and its zeropoint.</dd>
+<dt><tt>T3</tt> : tensor(int8), tensor(uint8), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>The type of the output and its zeropoint.</dd>
+</dl>
+
+### <a name="QuantizeLinear-21"></a>**QuantizeLinear-21**</a>
+
+  The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
+  low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
+  granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
+  Saturation is done according to:
+  - uint16: [0, 65535]
+  - int16: [-32768, 32767]
+  - uint8: [0, 255]
+  - int8: [-128, 127]
+  - uint4: [0, 15]
+  - int4: [-8, 7]
+  For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+  `y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 types, but the quantization
+  formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+  There are three supported quantization granularities, determined by the shape of `y_scale`.
+  In all cases, `y_zero_point` must have the same shape as `y_scale`.
+  - Per-tensor (per-layer) quantization: `y_scale` is a scalar.
+  - Per-axis quantization: The scale must be a 1-D tensor, with the length of the quantization axis. For an input shape
+   `(D0, ..., Di, ..., Dn)` and `axis=i`, `y_scale` is a 1-D tensor of length `Di`.
+  - Blocked quantization: The scale's shape is identical to the input's shape, except for one dimension, in which
+    blocking is performed. Given `x` shape `(D0, ..., Di, ..., Dn)`, `axis=i`, and block size `B`: `y_scale` shape is
+    `(D0, ..., ceil(Di/B), ..., Dn)`.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, rendering the axis unnecessary in this scenario.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+<dt><tt>output_dtype</tt> : int (default is 0)</dt>
+<dd>(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T2`). If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T2`.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 quantization (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. All cases are fully described in two tables inserted in the operator description.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D full precision Input tensor to be quantized.</dd>
+<dt><tt>y_scale</tt> : T1</dt>
+<dd>Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>y_zero_point</tt> (optional) : T2</dt>
+<dd>Zero point for doing quantization to get `y`. Shape must match `y_scale`.Default is uint8 with zero point of 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T2</dt>
+<dd>N-D quantized output tensor. It has same shape as input `x`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32)</dt>
+<dd>The type of the input 'x'.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>The type of the input `y_zero_point` and the output `y`.</dd>
+</dl>
+
+### <a name="Reshape-21"></a>**Reshape-21**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). If 'allowzero' is set, and the new shape includes 0, the
+  dimension will be set explicitly to zero (i.e. not taken from input tensor).
+  Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+  If the attribute 'allowzero' is set, it is invalid for the specified shape to
+  contain both a zero value and -1, as the value of the dimension corresponding
+  to -1 cannot be determined uniquely.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>allowzero</tt> : int (default is 0)</dt>
+<dd>(Optional) By default, when any value in the 'shape' input is equal to zero the corresponding dimension value is copied from the input tensor dynamically. allowzero=1 indicates that if any value in the 'shape' input is set to zero, the zero value is honored, similar to NumPy.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Specified shape for output.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> (differentiable) : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Scan-21"></a>**Scan-21**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops).
+  Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+  well as scan_output_element tensors) are required to have the same shape in each iteration
+  of the loop (a restriction imposed to enable efficient memory allocation).
+
+  Note that the iterated element passed to the body subgraph does not have a sequence
+  axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The optional attribute scan_input_directions specifies the direction (forward or backward)
+  for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+  direction. A bidirectional scan may be performed by specifying the same tensor input twice
+  in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+  The scan_output of the operation is produced by concatenating the scan_output_element
+  values produced by the body in each iteration.  The optional attribute scan_output_directions
+  specifies the direction in which scan_output is constructed (by appending or prepending the
+  scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+  is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+  The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+  If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+  batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+  Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+  The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+  are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+  scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+  value of 1.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body,
+          scan_input_axes = [axis_1, ..., axis_m]
+      > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+      sequence_length = scan_1.shape[axis_1];
+
+      // initialize state-variables
+      st_1 = init_1; ... st_n = init_n;
+      // initialize scan-output variables: [] denotes an empty tensor
+      scan_out_1 = []; ...; scan_out_k = [];
+      // identify number of iterations:
+
+      // execute loop
+      for (int t = 0; t < sequence_length; ++t) {
+          // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+          // of rank one less than T obtained by indexing T at position t along axis k.
+          si_1 = scan_1<axis=axis_1>[t];
+          ... ;
+          si_m = scan_m<axis=axis_m>[t];
+          // execute loop-body
+          st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+          // accumulate the scan-output elements
+          scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+      }
+
+      return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+<dt><tt>scan_input_axes</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the axis to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will be used as the scan axis for every scan_input. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>scan_input_directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>scan_output_axes</tt> : list of ints</dt>
+<dd>An optional list of K flags. The i-th element of the list specifies the axis for the i-th scan_output. The scan outputs are accumulated along the specified axis. If omitted, 0 will be used as the scan axis for every scan_output. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1].</dd>
+<dt><tt>scan_output_directions</tt> : list of ints</dt>
+<dd>An optional list of K flags, one for each scan_output. The i-th element of the list specifies whether the i-th scan_output should be constructed by appending or prepending a new value in each iteration: 0 indicates appending and 1 indicates prepending. If omitted, all scan_output tensors will be produced by appending a value in each iteration.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>All Tensor types up to IRv10.</dd>
+</dl>
+
+### <a name="Shape-21"></a>**Shape-21**</a>
+
+  Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+  Optional attributes start and end can be used to compute a slice of the input tensor's shape.
+  If start axis is omitted, the slice starts from axis 0.
+  The end axis, if specified, is exclusive (and the returned value will not include the size of that axis).
+  If the end axis is omitted, the axes upto the last one will be included.
+  Negative axes indicate counting back from the last axis.
+  Note that axes will be clamped to the range [0, r], where r is the
+  rank of the input tensor if they are out-of-range (after adding r in the case of
+  negative axis). Thus, specifying any end value > r is equivalent to specifying an end
+  value of r, and specifying any start value < -r is equivalent to specifying a start
+  value of 0. If start > end, the result will be an empty shape.
+
+  Examples:
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  No attributes specified.
+  Output: [2, 3, 4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: -1
+  Output: [4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  end: -1
+  Output: [2, 3]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: 1
+  end: 2
+  Output: [3]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>end</tt> : int</dt>
+<dd>(Optional) Ending axis for slicing the shape. Negative value means counting dimensions from the back. If omitted, sizes of all axes upto (including) the last one will be included.</dd>
+<dt><tt>start</tt> : int (default is 0)</dt>
+<dd>(Optional) Starting axis for slicing the shape. Default value is 0.Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>shape</tt> (non-differentiable) : T1</dt>
+<dd>Shape of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor.</dd>
+</dl>
+
+### <a name="Size-21"></a>**Size-21**</a>
+
+  Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>Total number of elements of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor, which should be a scalar though.</dd>
+</dl>
+
+### <a name="Squeeze-21"></a>**Squeeze-21**</a>
+
+  Remove single-dimensional entries from the shape of a tensor.
+  Takes an input `axes` with a list of axes to squeeze.
+  If `axes` is not provided, all the single dimensions will be removed from
+  the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensors with at least max(dims) dimensions.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>List of integers indicating the dimensions to squeeze. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>squeezed</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv10.</dd>
+</dl>
+
+### <a name="Transpose-21"></a>**Transpose-21**</a>
+
+  Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+  The optional attribute `perm` must be a permutation of the dimensions of
+  the input tensor. Axis `i` of the output tensor corresponds to the axis
+  `perm[i]` of the input tensor.
+  For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 1, 3).
+  When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 3, 1).
+  If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+  where `n` is the rank of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>perm</tt> : list of ints</dt>
+<dd>A list of integers. By default, reverse the dimensions, otherwise permute the axes according to the values given. Its length must be equal to the rank of the input.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>transposed</tt> (differentiable) : T</dt>
+<dd>Transposed output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Unsqueeze-21"></a>**Unsqueeze-21**</a>
+
+  Insert single-dimensional entries to the shape of an input tensor (`data`).
+  Takes one required input `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).
+
+  For example, given an input tensor (`data`) of shape [3, 4, 5], then
+  Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].
+
+  The input `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
+  The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
+  Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
+  The order of values in `axes` does not matter and can come in any order.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Original tensor</dd>
+<dt><tt>axes</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>List of integers indicating the dimensions to be inserted. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(expanded).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>expanded</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv10.</dd>
+</dl>
+
+## Version 22 of the default ONNX operator set
+### <a name="Acos-22"></a>**Acos-22**</a>
+
+  Calculates the arccosine (inverse of cosine) of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The arccosine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Acosh-22"></a>**Acosh-22**</a>
+
+  Calculates the hyperbolic arccosine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic arccosine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Asin-22"></a>**Asin-22**</a>
+
+  Calculates the arcsine (inverse of sine) of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The arcsine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Asinh-22"></a>**Asinh-22**</a>
+
+  Calculates the hyperbolic arcsine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic arcsine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Atan-22"></a>**Atan-22**</a>
+
+  Calculates the arctangent (inverse of tangent) of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The arctangent of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Atanh-22"></a>**Atanh-22**</a>
+
+  Calculates the hyperbolic arctangent of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic arctangent values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="AveragePool-22"></a>**AveragePool-22**</a>
+
+  AveragePool consumes an input tensor X and applies average pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   average pooling consisting of computing the average on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape is calculated differently
+   depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
+   With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`. Sliding windows that would start in the right padded region are ignored.
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):
+   ```
+   VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
+   ```
+   The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>count_include_pad</tt> : int (default is 0)</dt>
+<dd>Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Bernoulli-22"></a>**Bernoulli-22**</a>
+
+  Draws binary random numbers (0 or 1) from a Bernoulli distribution. The input tensor should be a tensor
+  containing probabilities p (a value in the range [0,1]) to be used for drawing the binary random number,
+  where an output of 1 is produced with probability p and an output of 0 is produced with probability (1-p).
+
+  This operator is non-deterministic and may not produce the same values in different
+  implementations (even if a seed is specified).
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>The data type for the elements of the output tensor. if not specified, we will use the data type of the input tensor.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>All values in input have to be in the range:[0, 1].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>The returned output tensor only has values 0 or 1, same shape as input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool)</dt>
+<dd>Constrain output types to all numeric tensors and bool tensors.</dd>
+</dl>
+
+### <a name="Conv-22"></a>**Conv-22**</a>
+
+  The convolution operator consumes an input tensor and a filter, and
+  computes the output.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input W.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults is 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn). Optionally, if dimension denotation is in effect, the operation expects input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (M x C/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the kernel shape will be (M x C/group x k1 x k2 x ... x kn), where (k1 x k2 x ... kn) is the dimension of the kernel. Optionally, if dimension denotation is in effect, the operation expects the weight tensor to arrive with the dimension denotation of [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. Assuming zero based indices for the shape array, X.shape[1] == (W.shape[1] * group) == C and W.shape[0] mod G == 0. Or in other words FILTER_IN_CHANNEL multiplied by the number of groups should be equal to DATA_CHANNEL and the number of feature maps M should be a multiple of the number of groups G.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, and pad lengths.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="ConvTranspose-22"></a>**ConvTranspose-22**</a>
+
+  The convolution transpose operator consumes an input tensor and a filter,
+  and computes the output.
+
+  If the pads parameter is provided the shape of the output is calculated via the following equation:
+
+    output_shape[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - pads[start_i] - pads[end_i]
+
+  output_shape can also be explicitly specified in which case pads values are auto generated using these equations:
+
+    total_padding[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - output_shape[i]
+    If (auto_pads == SAME_UPPER): pads[start_i] = total_padding[i]/2; pads[end_i] = total_padding[i] - (total_padding[i]/2)
+    Else: pads[start_i] = total_padding[i] - (total_padding[i]/2); pads[end_i] = (total_padding[i]/2).
+
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = input_shape[i] * strides[i]` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input W.</dd>
+<dt><tt>output_padding</tt> : list of ints</dt>
+<dd>Additional elements added to the side with higher coordinate indices in the output. Each padding value in "output_padding" must be less than the corresponding stride/dilation dimension. By default, this attribute is a zero vector. Note that this attribute doesn't directly affect the computed output values. It only controls the selection of the computed values, so changing this attribute only adds or removes output elements. If "output_shape" is explicitly provided, "output_padding" does not contribute additional size to "output_shape" but participates in the computation of the needed padding amount. This is also called adjs or adjustment in some frameworks.</dd>
+<dt><tt>output_shape</tt> : list of ints</dt>
+<dd>The shape of the output can be explicitly set which will cause pads values to be auto generated. If output_shape is specified pads values are ignored. See doc for details for equations to generate pads. Note that the output_shape attribute value should not include dimensions for batch size and channels, which are automatically inferred.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn)</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (C x M/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the weight shape will be (C x M/group x k1 x k2 x ... x kn), where (k1 x k2 x ... x kn) is the dimension of the kernel. The number of channels in the output should be equal to W.shape[1] * group (assuming zero based indices of the shape array)</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, pad lengths and group count. The number of channels in the output should be equal to W.shape[1] * group (assuming zero based indices of the shape array)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Cos-22"></a>**Cos-22**</a>
+
+  Calculates the cosine of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The cosine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Cosh-22"></a>**Cosh-22**</a>
+
+  Calculates the hyperbolic cosine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic cosine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="DeformConv-22"></a>**DeformConv-22**</a>
+
+  Performs deformable convolution as described in https://arxiv.org/abs/1703.06211 and https://arxiv.org/abs/1811.11168.
+  This operator specification supports the general N-D case. Note that most common use cases have 2D or 3D data.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of the kernel. Default is 1 along each axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>Number of groups the input and output channels, C and oC, are divided into. C and oC must both be divisible by group. Default is 1.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>Shape of the convolution kernel. If not present, it is inferred from the shape of input W.</dd>
+<dt><tt>offset_group</tt> : int (default is 1)</dt>
+<dd>Number of groups of offset. C must be divisible by offset_group. Default is 1.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and end along each spatial axis. The values represent the number of pixels added to the beginning and end of the corresponding axis and can take any nonnegative value. The format should be as follows: [x1_begin, x2_begin, ..., x1_end, x2_end, ...], where xi_begin is the number of pixels added at the beginning of axis `i` and xi_end is the number of pixels added at the end of axis `i`. Default is 0 along each axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. Default is 1 along each axis.</dd>
+</dl>
+
+#### Inputs (3 - 5)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor. For 2D image data, it has shape (N, C, H, W) where N is the batch size, C is the number of input channels, and H and W are the height and width. In general, the shape is (N, C, D1, D2, ... , Dn) for n-dimensional data, where D1 to Dn are the spatial dimension sizes. Most common use cases have n = 2 or 3.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>Weight tensor that will be used in the convolutions. It has shape (oC, C/group, kH, kW), where oC is the number of output channels and kH and kW are the kernel height and width. For more than 2 dimensions, it has shape (oC, C/group, k1, k2, ... , kn).</dd>
+<dt><tt>offset</tt> : T</dt>
+<dd>Offset tensor denoting the offset for the sampling locations in the convolution kernel. It has shape (N, offset_group * kH * kW * 2, oH, oW) for 2D data or (N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Use linear interpolationfor fractional offset values. Sampling locations outside of the padded input tensor gives zero.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>Optional 1D bias of length oC to be added to the convolution. Default is a tensor of zeros.</dd>
+<dt><tt>mask</tt> (optional) : T</dt>
+<dd>The mask tensor to be applied to each position in the convolution kernel. It has shape (N, offset_group * kH * kW, oH, oW) for 2D data or (N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Default is a tensor of ones.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor that contains the result of convolution. It has shape (N, oC, oH, oW) for 2D data or (N, oC, o1, o2, ..., on) for nD data</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Det-22"></a>**Det-22**</a>
+
+  Det calculates determinant of a square matrix or batches of square matrices.
+  Det takes one input tensor of shape `[*, M, M]`, where `*` is zero or more batch dimensions,
+  and the inner-most 2 dimensions form square matrices.
+  The output is a tensor of shape `[*]`, containing the determinants of all input submatrices.
+  e.g., When the input is 2-D, the output is a scalar(shape is empty: `[]`).
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to floating-point tensors.</dd>
+</dl>
+
+### <a name="Dropout-22"></a>**Dropout-22**</a>
+
+  Dropout takes an input floating-point tensor, an optional input ratio (floating-point scalar) and an optional input training_mode (boolean scalar). It produces two tensor outputs,
+  output (floating-point tensor) and mask (optional `Tensor<bool>`). If `training_mode` is true then the output Y will be a random dropout;
+  Note that this Dropout scales the masked input data by the following equation, so to convert the trained model into inference mode,
+  the user can simply not pass `training_mode` input or set it to false.
+  ```
+  output = scale * data * mask,
+  ```
+  where
+  ```
+  scale = 1. / (1. - ratio).
+  ```
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>seed</tt> : int</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>The input data as Tensor.</dd>
+<dt><tt>ratio</tt> (optional, non-differentiable) : T1</dt>
+<dd>The ratio of random dropout, with value in [0, 1). If set to 0, the output would be a simple copy of the input. If it's non-zero, output will be a random dropout of the scaled input, which is typically the case during training. It is an optional value, if not specified it will default to 0.5.</dd>
+<dt><tt>training_mode</tt> (optional, non-differentiable) : T2</dt>
+<dd>If set to true then it indicates dropout is being used for training. It is an optional value hence unless specified explicitly, it is false. If it is false, ratio is ignored and the operation mimics inference mode where nothing will be dropped from the input data and if mask is requested as output it will contain all ones.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output.</dd>
+<dt><tt>mask</tt> (optional, non-differentiable) : T2</dt>
+<dd>The output mask.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input 'ratio' types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output 'mask' types to boolean tensors.</dd>
+</dl>
+
+### <a name="Elu-22"></a>**Elu-22**</a>
+
+  Elu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the function `f(x) = alpha * (exp(x) - 1.) for x <
+  0`, `f(x) = x for x >= 0`., is applied to the tensor elementwise.
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Coefficient of ELU.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="EyeLike-22"></a>**EyeLike-22**</a>
+
+  Generate a 2D tensor (matrix) with ones on the diagonal and zeros everywhere else. Only 2D
+  tensors are supported, i.e. input T1 must be of rank 2. The shape of the output tensor is the
+  same as the input tensor. The data type can be specified by the 'dtype' argument. If
+  'dtype' is not specified, then the type of input tensor is used. By default, the main diagonal
+  is populated with ones, but attribute 'k' can be used to populate upper or lower diagonals.
+  The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message and be valid as an output type.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type for the elements of the output tensor. If not specified, the data type of the input tensor T1 is used.</dd>
+<dt><tt>k</tt> : int (default is 0)</dt>
+<dd>(Optional) Index of the diagonal to be populated with ones. Default is 0. If T2 is the output, this op sets T2[i, i+k] = 1. k = 0 populates the main diagonal, k > 0 populates an upper diagonal,  and k < 0 populates a lower diagonal.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>2D input tensor to copy shape, and optionally, type information from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor, same shape as input tensor T1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool)</dt>
+<dd>Constrain input types. Strings and complex are not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool)</dt>
+<dd>Constrain output types. Strings and complex are not supported.</dd>
+</dl>
+
+### <a name="GRU-22"></a>**GRU-22**</a>
+
+  Computes an one-layer GRU. This operator is usually supported via some custom
+  implementation such as CuDNN.
+
+  Notations:
+
+  * `X` - input tensor
+  * `z` - update gate
+  * `r` - reset gate
+  * `h` - hidden gate
+  * `t` - time step (t-1 means previous time step)
+  * `W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+  * `R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+  * `Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+  * `Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+  * `WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+  * `RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+  * `WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+  * `RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+  * `H` - Hidden state
+  * `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+  * Relu(x)                - max(0, x)
+  * Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+  * Sigmoid(x)             - 1/(1 + e^{-x})
+
+  NOTE:
+    Below are optional
+
+  * Affine(x)              - alpha * x + beta
+  * LeakyRelu(x)           - x if x >= 0 else alpha * x
+  * ThresholdedRelu(x)     - x if x >= alpha else 0
+  * ScaledTanh(x)          - alpha * Tanh(beta * x)
+  * HardSigmoid(x)         - min(max(alpha * x + beta, 0), 1)
+  * Elu(x)                 - x if x >= 0 else alpha * (e^x - 1)
+  * Softsign(x)            - x/(1 + |x|)
+  * Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh):
+
+  * zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz)
+  * rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr)
+  * ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # default, when linear_before_reset = 0
+  * ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset != 0
+  * Ht = (1 - zt) (.) ht + zt (.) Ht-1
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 2 (or 4 if bidirectional) activation functions for update, reset, and hidden gates. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>layout</tt> : int (default is 0)</dt>
+<dd>The shape format of inputs X, initial_h and outputs Y, Y_h. If 0, the following shapes are expected: X.shape = [seq_length, batch_size, input_size], Y.shape = [seq_length, num_directions, batch_size, hidden_size], initial_h.shape = Y_h.shape = [num_directions, batch_size, hidden_size]. If 1, the following shapes are expected: X.shape = [batch_size, seq_length, input_size], Y.shape = [batch_size, seq_length, num_directions, hidden_size], initial_h.shape = Y_h.shape = [batch_size, num_directions, hidden_size].</dd>
+<dt><tt>linear_before_reset</tt> : int (default is 0)</dt>
+<dd>When computing the output of the hidden gate, apply the linear transformation before multiplying by the output of the reset gate.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> (differentiable) : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and `[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 6*hidden_size]`. Optional: If not specified - assumed to be 0</dd>
+<dt><tt>sequence_lens</tt> (optional, non-differentiable) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional, differentiable) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="GlobalAveragePool-22"></a>**GlobalAveragePool-22**</a>
+
+  GlobalAveragePool consumes an input tensor X and applies average pooling across
+   the values in the same channel. This is equivalent to AveragePool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from pooling across the input tensor. The output tensor has the same rank as the input. The first two dimensions of output shape are the same as the input (N x C), while the other dimensions are all 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="GlobalLpPool-22"></a>**GlobalLpPool-22**</a>
+
+  GlobalLpPool consumes an input tensor X and applies lp pool pooling across
+   the values in the same channel. This is equivalent to LpPool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>p value of the Lp norm used to pool over the input data.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from pooling across the input tensor. The output tensor has the same rank as the input. The first two dimensions of output shape are the same as the input (N x C), while the other dimensions are all 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="GlobalMaxPool-22"></a>**GlobalMaxPool-22**</a>
+
+  GlobalMaxPool consumes an input tensor X and applies max pooling across
+   the values in the same channel. This is equivalent to MaxPool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from pooling across the input tensor. The output tensor has the same rank as the input. The first two dimensions of output shape are the same as the input (N x C), while the other dimensions are all 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="GridSample-22"></a>**GridSample-22**</a>
+
+  Given an input `X` and a flow-field `grid`, computes the output `Y` using `X` values and pixel locations from the `grid`.
+  For spatial input `X` with shape (N, C, H, W), the `grid` will have shape (N, H_out, W_out, 2),
+  the output `Y` will have shape (N, C, H_out, W_out). For volumetric input `X` with shape (N, C, D, H, W),
+  the `grid` will have shape (N, D_out, H_out, W_out, 3), the output `Y` will have shape (N, C, D_out, H_out, W_out).
+  More generally, for an input `X` of rank r+2 with shape (N, C, d1, d2, ..., dr),
+  the `grid` will have shape (N, D1_out, D2_out, ..., Dr_out, r), the output `Y` will have shape (N, C, D1_out, D2_out, ..., Dr_out).
+
+  The tensor `X` contains values at centers of square pixels (voxels, etc) locations such as (n, c, d1_in, d2_in, ..., dr_in).
+  The (n, d1_out, d2_out, ..., dr_out, :) values from the tensor `grid` are the normalized positions for interpolating the values
+  at the (n, c, d1_out, d2_out, ..., dr_out) locations from the output tensor `Y` using a specified interpolation method (the mode)
+  and a padding mode (for `grid` positions falling outside the 2-dimensional image).
+
+  For example, the values in `grid[n, h_out, w_out, :]` are size-2 vectors specifying normalized positions in the 2-dimensional space of `X`.
+  They are used to interpolate output values of `Y[n, c, h_out, w_out]`.
+
+  The GridSample operator is often used in doing grid generator and sampler in the
+  [Spatial Transformer Networks](https://arxiv.org/abs/1506.02025).
+  See also in [torch.nn.functional.grid_sample](https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html).
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>align_corners</tt> : int (default is 0)</dt>
+<dd>If align_corners=1, the extrema (-1 and 1) are considered as referring to the center points of the input's corner pixels (voxels, etc.). If align_corners=0, they are instead considered as referring to the corner points of the input's corner pixels (voxels, etc.), making the sampling more resolution agnostic.</dd>
+<dt><tt>mode</tt> : string (default is linear)</dt>
+<dd>Three interpolation modes: linear (default), nearest and cubic. The "linear" mode includes linear and N-linear interpolation modes depending on the number of spatial dimensions of the input tensor (i.e. linear for 1 spatial dimension, bilinear for 2 spatial dimensions, etc.). The "cubic" mode also includes N-cubic interpolation modes following the same rules. The "nearest" mode rounds to the nearest even index when the sampling point falls halfway between two indices.</dd>
+<dt><tt>padding_mode</tt> : string (default is zeros)</dt>
+<dd>Support padding modes for outside grid values: `zeros`(default), `border`, `reflection`. zeros: use 0 for out-of-bound grid locations, border: use border values for out-of-bound grid locations, reflection: use values at locations reflected by the border for out-of-bound grid locations. If index 0 represents the margin pixel, the reflected value at index -1 will be the same as the value at index 1. For location far away from the border, it will keep being reflected until becoming in bound. If pixel location x = -3.5 reflects by border -1 and becomes x' = 1.5, then reflects by border 1 and becomes x'' = 0.5.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>Input tensor of rank r+2 that has shape (N, C, D1, D2, ..., Dr), where N is the batch size, C is the number of channels, D1, D2, ..., Dr are the spatial dimensions.</dd>
+<dt><tt>grid</tt> (non-differentiable) : T2</dt>
+<dd>Input offset of shape (N, D1_out, D2_out, ..., Dr_out, r), where D1_out, D2_out, ..., Dr_out are the spatial dimensions of the grid and output, and r is the number of spatial dimensions. Grid specifies the sampling locations normalized by the input spatial dimensions. Therefore, it should have most values in the range of [-1, 1]. If the grid has values outside the range of [-1, 1], the corresponding outputs will be handled as defined by padding_mode. Following computer vision convention, the coordinates in the length-r location vector are listed from the innermost tensor dimension to the outermost, the opposite of regular tensor indexing.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>Output tensor of rank r+2 that has shape (N, C, D1_out, D2_out, ..., Dr_out) of the sampled values. For integer input types, intermediate values are computed as floating point and cast to integer at the end.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input `X` and output `Y` types to all tensor types.</dd>
+<dt><tt>T2</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain grid types to float tensors.</dd>
+</dl>
+
+### <a name="HardSigmoid-22"></a>**HardSigmoid-22**</a>
+
+  HardSigmoid takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the HardSigmoid function, y = max(0, min(1, alpha * x + beta)),
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.2)</dt>
+<dd>Value of alpha.</dd>
+<dt><tt>beta</tt> : float (default is 0.5)</dt>
+<dd>Value of beta.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="HardSwish-22"></a>**HardSwish-22**</a>
+
+  HardSwish takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where
+  the HardSwish function, y = x * max(0, min(1, alpha * x + beta)) = x * HardSigmoid<alpha, beta>(x),
+  where alpha = 1/6 and beta = 0.5, is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="InstanceNormalization-22"></a>**InstanceNormalization-22**</a>
+
+  Carries out instance normalization as described in the paper
+  https://arxiv.org/abs/1607.08022.
+
+  y = scale * (x - mean) / sqrt(variance + epsilon) + B,
+  where mean and variance are computed per instance per channel.
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+<dt><tt>scale</tt> (differentiable) : T</dt>
+<dd>The input 1-dimensional scale tensor of size C.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>The input 1-dimensional bias tensor of size C.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output tensor of the same shape as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LSTM-22"></a>**LSTM-22**</a>
+
+  Computes an one-layer LSTM. This operator is usually supported via some
+  custom implementation such as CuDNN.
+
+  Notations:
+
+  * `X` - input tensor
+  * `i` - input gate
+  * `o` - output gate
+  * `f` - forget gate
+  * `c` - cell gate
+  * `t` - time step (t-1 means previous time step)
+  * `W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
+  * `R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
+  * `Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
+  * `Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
+  * `P[iof]`  - P peephole weight vector for input, output, and forget gates
+  * `WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
+  * `RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
+  * `WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
+  * `RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
+  * `PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
+  * `H` - Hidden state
+  * `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+  * Relu(x)                - max(0, x)
+  * Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+  * Sigmoid(x)             - 1/(1 + e^{-x})
+
+  NOTE: Below are optional
+
+  * Affine(x)              - alpha*x + beta
+  * LeakyRelu(x)           - x if x >= 0 else alpha * x
+  * ThresholdedRelu(x)     - x if x >= alpha else 0
+  * ScaledTanh(x)          - alpha*Tanh(beta*x)
+  * HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+  * Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+  * Softsign(x)            - x/(1 + |x|)
+  * Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh, h=Tanh):
+
+  * it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi)
+  * ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf)
+  * ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc)
+  * Ct = ft (.) Ct-1 + it (.) ct
+  * ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.) Ct + Wbo + Rbo)
+  * Ht = ot (.) h(Ct)
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 3 (or 6 if bidirectional) activation functions for input, output, forget, cell, and hidden. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>input_forget</tt> : int (default is 0)</dt>
+<dd>Couple the input and forget gates if 1.</dd>
+<dt><tt>layout</tt> : int (default is 0)</dt>
+<dd>The shape format of inputs X, initial_h, initial_c and outputs Y, Y_h, Y_c. If 0, the following shapes are expected: X.shape = [seq_length, batch_size, input_size], Y.shape = [seq_length, num_directions, batch_size, hidden_size], initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = [num_directions, batch_size, hidden_size]. If 1, the following shapes are expected: X.shape = [batch_size, seq_length, input_size], Y.shape = [batch_size, seq_length, num_directions, hidden_size], initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = [batch_size, num_directions, hidden_size].</dd>
+</dl>
+
+#### Inputs (3 - 8)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[iofc]` and `WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape `[num_directions, 4*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> (differentiable) : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[iofc]` and `RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 4*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional, non-differentiable) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>initial_c</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the cell. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>P</tt> (optional, differentiable) : T</dt>
+<dd>The weight tensor for peepholes. Concatenation of `P[iof]` and `PB[iof]` (if bidirectional) along dimension 0. It has shape `[num_directions, 3*hidde_size]`. Optional: If not specified - assumed to be 0.</dd>
+</dl>
+
+#### Outputs (0 - 3)
+
+<dl>
+<dt><tt>Y</tt> (optional, differentiable) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>Y_c</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the cell. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="LpNormalization-22"></a>**LpNormalization-22**</a>
+
+  Given a matrix, apply Lp-normalization along the provided axis.
+  The output is computed as: `output = input / Lp_norm(input, axis)`.
+  When the Lp norm is zero (i.e., all elements along the axis are zero),
+  the output is defined to be zero to avoid division by zero.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>The axis on which to apply normalization, -1 mean last axis.</dd>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>The order of the normalization, only 1 or 2 are supported.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input matrix</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Matrix after normalization</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LpPool-22"></a>**LpPool-22**</a>
+
+  LpPool consumes an input tensor X and applies Lp pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   Lp pooling consisting of computing the Lp norm on all values of a subset
+   of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled `pad_shape[i]` is the sum of pads along axis `i`.
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]
+   ```
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>p value of the Lp norm used to pool over the input data.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="MaxPool-22"></a>**MaxPool-22**</a>
+
+  MaxPool consumes an input tensor X and applies max pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   max pooling consisting of computing the max on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape is calculated differently
+   depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
+   With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`. Sliding windows that would start in the right padded region are ignored.
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):
+   ```
+   VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
+   ```
+   The output of each pooling window is maximum number of elements exclude pad.
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>storage_order</tt> : int (default is 0)</dt>
+<dd>The storage order of the tensor. 0 is row major, and 1 is column major. This attribute is used only to convert an n-tuple index value into a single integer value for producing the second output. </dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+<dt><tt>Indices</tt> (optional, non-differentiable) : I</dt>
+<dd>Indices tensor from max pooling across the input tensor. The dimensions of indices are the same as output tensor. The values in indices of are the indices of the selected values during pooling. The indices are computed as flatten 1-D tensor, and the indices do not consider padding. So the values in indices are in [0, N x C x D1 x ... x Dn).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input and output types to float and 8 bit tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="MaxRoiPool-22"></a>**MaxRoiPool-22**</a>
+
+  ROI max pool consumes an input tensor X and region of interests (RoIs) to
+   apply max pooling across each RoI, to produce output 4-D tensor of shape
+   (num_rois, channels, pooled_shape[0], pooled_shape[1]).
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>pooled_shape</tt> : list of ints (required)</dt>
+<dd>ROI pool output shape (height, width).</dd>
+<dt><tt>spatial_scale</tt> : float (default is 1.0)</dt>
+<dd>Multiplicative spatial scale factor to translate ROI coordinates from their input scale to the scale used when pooling.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data.</dd>
+<dt><tt>rois</tt> (non-differentiable) : T</dt>
+<dd>RoIs (Regions of Interest) to pool over. Should be a 2-D tensor of shape (num_rois, 5) given as [[batch_id, x1, y1, x2, y2], ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>RoI pooled output 4-D tensor of shape (num_rois, channels, pooled_shape[0], pooled_shape[1]).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="MaxUnpool-22"></a>**MaxUnpool-22**</a>
+
+  MaxUnpool essentially computes the partial inverse of the MaxPool op.
+   The input information to this op is typically the output information from a MaxPool op. The first
+   input tensor X is the tensor that needs to be unpooled, which is typically the pooled tensor (first output)
+   from MaxPool. The second input tensor, I, contains the indices to the (locally maximal) elements corresponding
+   to the elements in the first input tensor X. Input tensor I is typically the second output of the MaxPool op.
+   The third (optional) input is a tensor that specifies the output size of the unpooling operation.
+
+  MaxUnpool is intended to do 'partial' inverse of the MaxPool op. 'Partial' because all the non-maximal
+   values from the original input to MaxPool are set to zero in the output of the MaxUnpool op. Pooling
+   the result of an unpooling operation should give back the original input to the unpooling op.
+
+  MaxUnpool can produce the same output size for several input sizes, which makes unpooling op ambiguous.
+   The third input argument, output_size, is meant to disambiguate the op and produce output tensor of
+   known/predictable size.
+
+  In addition to the inputs, MaxUnpool takes three attributes, namely kernel_shape, strides, and pads,
+   which define the exact unpooling op. The attributes typically have the same values as the corresponding
+   pooling op that the unpooling op is trying to invert.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>Input data tensor that has to be unpooled. This tensor is typically the first output of the MaxPool op.Dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non-image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>I</tt> (non-differentiable) : T2</dt>
+<dd>Input data tensor containing the indices corresponding to elements in the first input tensor X.This tensor is typically the second output of the MaxPool op.Dimensions must be the same as input tensor X. The indices are linear, i.e. computed considering the tensor as flattened 1-D tensor, assuming row-major storage. Also, the linear indices should not consider padding. So the values in indices are in the range [0, N x C x D1 x ... x Dn).</dd>
+<dt><tt>output_shape</tt> (optional, non-differentiable) : T2</dt>
+<dd>The shape of the output can be explicitly set which will cause pads values to be auto generated. If 'output_shape' is specified, 'pads' values are ignored.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T1</dt>
+<dd>Output data tensor that contains the result of the unpooling.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="Mish-22"></a>**Mish-22**</a>
+
+  Mish: A Self Regularized Non-Monotonic Neural Activation Function.
+
+  Perform the linear unit element-wise on the input tensor X using formula:
+
+  ```
+  mish(x) = x * tanh(softplus(x)) = x * tanh(ln(1 + e^{x}))
+  ```
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input X and output types to float tensors.</dd>
+</dl>
+
+### <a name="Multinomial-22"></a>**Multinomial-22**</a>
+
+  Generate a tensor of samples from a multinomial distribution according to the probabilities
+  of each of the possible outcomes.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int (default is 6)</dt>
+<dd>(Optional) The data type for the elements of the output tensor, if not specified, we will use int32.</dd>
+<dt><tt>sample_size</tt> : int (default is 1)</dt>
+<dd>Number of times to sample.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor with shape [batch_size, class_size], where class_size is the number of all possible outcomes. Each value along the axis zero represents the unnormalized log-probability of each corresponding outcome in a batch.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor with shape [batch_size, sample_size], where sample_size is the number of times to sample. Each value along the axis zero represents the outcome of the corresponding sample in a batch.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain output types to integral tensors.</dd>
+</dl>
+
+### <a name="NegativeLogLikelihoodLoss-22"></a>**NegativeLogLikelihoodLoss-22**</a>
+
+  A NegativeLogLikelihoodLoss operator computes (weighted) negative log likelihood loss.
+  Its "input" tensor has the shape of (N, C, d1, d2, ..., dk) where k >= 0.
+  The "input" tensor contains log-probabilities for input[n, :, d_1, d_2,..., d_k] being in a class of [0, C).
+  The operator's "target" input tensor has the shape of (N, d1, d2, ..., dk). It encodes class labels (one of C classes)
+  or it may contain a special value (indicated by an attribute ignore_index) for N x d1 x d2 x ... x dk samples.
+  The loss value for input[n, :, d_1, d_2,...d_k] being classified as class c = target[n][d_1][d_2]...[d_k] is computed as:
+
+  ```
+  loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k].
+  ```
+
+  When an optional "weight" is provided, the sample loss is calculated as:
+
+  ```
+  loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k] * weight[c].
+  ```
+
+  loss is zero for the case when target-value equals ignore_index.
+
+  ```
+  loss[n][d_1][d_2]...[d_k] = 0, when target[n][d_1][d_2]...[d_k] = ignore_index
+  ```
+
+  If "reduction" attribute is set to "none", the operator's output will be the above loss with shape (N, d1, d2, ..., dk).
+  If "reduction" attribute is set to "mean" (the default attribute value), the output loss is (weight) averaged:
+
+  ```
+  mean(loss), if "weight" is not provided,
+  ```
+
+  or if weight is provided,
+
+  ```
+  sum(loss) / sum(weight[target[n][d_1][d_2]...[d_k]]]), for all samples.
+  ```
+
+  If "reduction" attribute is set to "sum", the output is a scalar: `sum(loss)`.
+
+  See also https://pytorch.org/docs/stable/nn.html#torch.nn.NLLLoss.
+
+  Example 1:
+
+  ```
+  // negative log likelihood loss, "none" reduction
+  N, C, d1 = 2, 3, 2
+  input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+            [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+  target = [[2, 1], [0, 2]]
+
+  loss = np.zeros((N, d1))
+  for n in range(N):
+      for d_1 in range(d1):
+          c = target[n][d_1]
+          loss[n][d_1] = -input[n][c][d_1]
+
+  // print(loss)
+  // [[-3. -2.]
+  //  [-0. -2.]]
+  ```
+
+  Example 2:
+
+  ```
+  // weighted negative log likelihood loss, sum reduction
+  N, C, d1 = 2, 3, 2
+  input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+          [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+  target = [[2, 1], [0, 2]]
+  weight = [0.2, 0.3, 0.1]
+  loss = np.zeros((N, d1))
+  for n in range(N):
+      for d_1 in range(d1):
+          c = target[n][d_1]
+          loss[n][d_1] = -input[n][c][d_1] * weight[c]
+
+  loss = np.sum(loss)
+  // print(loss)
+  // -1.1
+  ```
+
+  Example 3:
+
+  ```
+  // weighted negative log likelihood loss, mean reduction
+  N, C, d1 = 2, 3, 2
+  input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+          [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+  target = [[2, 1], [0, 2]]
+  weight = [0.2, 0.3, 0.1]
+  loss = np.zeros((N, d1))
+  weight_total = 0
+  for n in range(N):
+      for d_1 in range(d1):
+          c = target[n][d_1]
+          loss[n][d_1] = -input[n][c][d_1] * weight[c]
+          weight_total = weight_total + weight[c]
+
+  loss = np.sum(loss) / weight_total
+  // print(loss)
+  // -1.57
+  ```
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>ignore_index</tt> : int</dt>
+<dd>Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.</dd>
+<dt><tt>reduction</tt> : string (default is mean)</dt>
+<dd>Type of reduction to apply to loss: none, sum, mean (default). 'none': the output is the loss for each sample. 'sum': the output will be summed. 'mean': the sum of the output will be divided by the sum of applied weights.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of shape (N, C) or (N, C, d1, d2, ..., dk).</dd>
+<dt><tt>target</tt> (non-differentiable) : Tind</dt>
+<dd>Target tensor of shape (N) or (N, d1, d2, ..., dk). Target element value shall be in range of [0, C). If ignore_index is specified, it may have a value outside [0, C) and the target values should either be in the range [0, C) or have the value ignore_index.</dd>
+<dt><tt>weight</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional rescaling weight tensor. If given, it has to be a tensor of size C. Otherwise, it is treated as if having all ones.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>loss</tt> (differentiable) : T</dt>
+<dd>The negative log likelihood loss</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input, weight, and output types to floating-point tensors.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain target to integer types</dd>
+</dl>
+
+### <a name="RNN-22"></a>**RNN-22**</a>
+
+  Computes an one-layer simple RNN. This operator is usually supported
+  via some custom implementation such as CuDNN.
+
+  Notations:
+
+  * `X` - input tensor
+  * `i` - input gate
+  * `t` - time step (t-1 means previous time step)
+  * `Wi` - W parameter weight matrix for input gate
+  * `Ri` - R recurrence weight matrix for input gate
+  * `Wbi` - W parameter bias vector for input gate
+  * `Rbi` - R parameter bias vector for input gate
+  * `WBi` - W parameter weight matrix for backward input gate
+  * `RBi` - R recurrence weight matrix for backward input gate
+  * `WBbi` - WR bias vectors for backward input gate
+  * `RBbi` - RR bias vectors for backward input gate
+  * `H` - Hidden state
+  * `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+  * Relu(x)                - max(0, x)
+  * Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+  * Sigmoid(x)             - 1/(1 + e^{-x})
+
+  NOTE: Below are optional
+
+  * Affine(x)              - alpha*x + beta
+  * LeakyRelu(x)           - x if x >= 0 else alpha * x
+  * ThresholdedRelu(x)     - x if x >= alpha else 0
+  * ScaledTanh(x)          - alpha*Tanh(beta*x)
+  * HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+  * Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+  * Softsign(x)            - x/(1 + |x|)
+  * Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Tanh):
+
+  * Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi)
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings (default is ['Tanh', 'Tanh'])</dt>
+<dd>One (or two if bidirectional) activation function for input gate. The activation function must be one of the activation functions specified above. Optional: Default `Tanh` if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>layout</tt> : int (default is 0)</dt>
+<dd>The shape format of inputs X, initial_h and outputs Y, Y_h. If 0, the following shapes are expected: X.shape = [seq_length, batch_size, input_size], Y.shape = [seq_length, num_directions, batch_size, hidden_size], initial_h.shape = Y_h.shape = [num_directions, batch_size, hidden_size]. If 1, the following shapes are expected: X.shape = [batch_size, seq_length, input_size], Y.shape = [batch_size, seq_length, num_directions, hidden_size], initial_h.shape = Y_h.shape = [batch_size, num_directions, hidden_size].</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor for input gate. Concatenation of `Wi` and `WBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> (differentiable) : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `Ri` and `RBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` and `[WBbi, RBbi]` (if bidirectional). The tensor has shape `[num_directions, 2*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional, non-differentiable) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional, differentiable) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+### <a name="RandomNormal-22"></a>**RandomNormal-22**</a>
+
+  Generate a tensor with random values drawn from a normal distribution. The shape
+  of the tensor is specified by the `shape` argument and the parameter of the normal distribution
+  specified by `mean` and `scale`.
+
+  The data type is specified by the 'dtype' argument. The 'dtype' argument must
+  be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int (default is 1)</dt>
+<dd>The data type for the elements of the output tensor. Default is TensorProto::FLOAT.</dd>
+<dt><tt>mean</tt> : float (default is 0.0)</dt>
+<dd>The mean of the normal distribution.</dd>
+<dt><tt>scale</tt> : float (default is 1.0)</dt>
+<dd>The standard deviation of the normal distribution.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+<dt><tt>shape</tt> : list of ints (required)</dt>
+<dd>The shape of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of random values drawn from normal distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+### <a name="RandomNormalLike-22"></a>**RandomNormalLike-22**</a>
+
+  Generate a tensor with random values drawn from a normal distribution.
+  The shape of the output tensor is copied from the shape of the input tensor,
+  and the parameters of the normal distribution are specified by `mean` and `scale`.
+
+  The data type is specified by the 'dtype' argument, or copied from the input tensor if not provided.
+  The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message, and be valid as an output type.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type for the elements of the output tensor, if not specified, we will use the data type of the input tensor.</dd>
+<dt><tt>mean</tt> : float (default is 0.0)</dt>
+<dd>The mean of the normal distribution.</dd>
+<dt><tt>scale</tt> : float (default is 1.0)</dt>
+<dd>The standard deviation of the normal distribution.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor to copy shape and optionally type information from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of random values drawn from normal distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.</dd>
+<dt><tt>T2</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+### <a name="RandomUniform-22"></a>**RandomUniform-22**</a>
+
+  Generate a tensor with random values drawn from a uniform distribution. The shape
+  of the tensor is specified by the `shape` argument and the range by `low` and `high`.
+
+  The data type is specified by the 'dtype' argument. The 'dtype' argument must
+  be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int (default is 1)</dt>
+<dd>The data type for the elements of the output tensor. If not specified, default is TensorProto::FLOAT.</dd>
+<dt><tt>high</tt> : float (default is 1.0)</dt>
+<dd>Upper boundary of the output values.</dd>
+<dt><tt>low</tt> : float (default is 0.0)</dt>
+<dd>Lower boundary of the output values.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+<dt><tt>shape</tt> : list of ints (required)</dt>
+<dd>The shape of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of random values drawn from uniform distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+### <a name="RandomUniformLike-22"></a>**RandomUniformLike-22**</a>
+
+  Generate a tensor with random values drawn from a uniform distribution.
+  The shape of the output tensor is copied from the shape of the input tensor,
+  and the parameters of the uniform distribution are specified by `low` and `high`.
+
+  The data type is specified by the 'dtype' argument, or copied from the input tensor if not provided.
+  The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message and be valid as an output type.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type for the elements of the output tensor, if not specified, we will use the data type of the input tensor.</dd>
+<dt><tt>high</tt> : float (default is 1.0)</dt>
+<dd>Upper boundary of the output values.</dd>
+<dt><tt>low</tt> : float (default is 0.0)</dt>
+<dd>Lower boundary of the output values.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor to copy shape and optionally type information from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of random values drawn from uniform distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.</dd>
+<dt><tt>T2</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+### <a name="RoiAlign-22"></a>**RoiAlign-22**</a>
+
+  Region of Interest (RoI) align operation described in the
+  [Mask R-CNN paper](https://arxiv.org/abs/1703.06870).
+  RoiAlign consumes an input tensor X and region of interests (rois)
+  to apply pooling across each RoI; it produces a 4-D tensor of shape
+  (num_rois, C, output_height, output_width).
+
+  RoiAlign is proposed to avoid the misalignment by removing
+  quantizations while converting from original image into feature
+  map and from feature map into RoI feature; in each ROI bin,
+  the value of the sampled locations are computed directly
+  through bilinear interpolation.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>coordinate_transformation_mode</tt> : string (default is half_pixel)</dt>
+<dd>Allowed values are 'half_pixel' and 'output_half_pixel'. Use the value 'half_pixel' to pixel shift the input coordinates by -0.5 (the recommended behavior). Use the value 'output_half_pixel' to omit the pixel shift for the input (use this for a backward-compatible behavior).</dd>
+<dt><tt>mode</tt> : string (default is avg)</dt>
+<dd>The pooling method. Two modes are supported: 'avg' and 'max'. Default is 'avg'.</dd>
+<dt><tt>output_height</tt> : int (default is 1)</dt>
+<dd>default 1; Pooled output Y's height.</dd>
+<dt><tt>output_width</tt> : int (default is 1)</dt>
+<dd>default 1; Pooled output Y's width.</dd>
+<dt><tt>sampling_ratio</tt> : int (default is 0)</dt>
+<dd>Number of sampling points in the interpolation grid used to compute the output value of each pooled output bin. If > 0, then exactly sampling_ratio x sampling_ratio grid points are used. If == 0, then an adaptive number of grid points are used (computed as ceil(roi_width / output_width), and likewise for height). Default is 0.</dd>
+<dt><tt>spatial_scale</tt> : float (default is 1.0)</dt>
+<dd>Multiplicative spatial scale factor to translate ROI coordinates from their input spatial scale to the scale used when pooling, i.e., spatial scale of the input feature map X relative to the input image. E.g.; default is 1.0f. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data tensor from the previous operator; 4-D feature map of shape (N, C, H, W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data.</dd>
+<dt><tt>rois</tt> : T1</dt>
+<dd>RoIs (Regions of Interest) to pool over; rois is 2-D input of shape (num_rois, 4) given as [[x1, y1, x2, y2], ...]. The RoIs' coordinates are in the coordinate system of the input image. Each coordinate set has a 1:1 correspondence with the 'batch_indices' input.</dd>
+<dt><tt>batch_indices</tt> : T2</dt>
+<dd>1-D tensor of shape (num_rois,) with each element denoting the index of the corresponding image in the batch.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>RoI pooled output, 4-D tensor of shape (num_rois, C, output_height, output_width). The r-th batch element Y[r-1] is a pooled feature map corresponding to the r-th RoI X[r-1].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain types to int tensors.</dd>
+</dl>
+
+### <a name="Round-22"></a>**Round-22**</a>
+
+  Round takes one input Tensor and rounds the values, element-wise, meaning
+  it finds the nearest integer for each value.
+  In case of halves, the rule is to round them to the nearest even integer.
+  If input x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+  The output tensor has the same shape and type as the input.
+
+  Examples:
+  ```
+  round([0.9]) = [1.0]
+  round([2.5]) = [2.0]
+  round([2.3]) = [2.0]
+  round([1.5]) = [2.0]
+  round([-4.5]) = [-4.0]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Selu-22"></a>**Selu-22**</a>
+
+  Selu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the scaled exponential linear unit function,
+  `y = gamma * (alpha * e^x - alpha) for x <= 0`, `y = gamma * x for x > 0`,
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.67326)</dt>
+<dd>Coefficient of SELU default to 1.67326319217681884765625 (i.e., float32 approximation of 1.6732632423543772848170429916717).</dd>
+<dt><tt>gamma</tt> : float (default is 1.0507)</dt>
+<dd>Coefficient of SELU default to 1.05070102214813232421875 (i.e., float32 approximation of 1.0507009873554804934193349852946).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Sin-22"></a>**Sin-22**</a>
+
+  Calculates the sine of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The sine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Sinh-22"></a>**Sinh-22**</a>
+
+  Calculates the hyperbolic sine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic sine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Softplus-22"></a>**Softplus-22**</a>
+
+  Softplus takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the softplus function, y = ln(exp(x) + 1), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Softsign-22"></a>**Softsign-22**</a>
+
+  Calculates the softsign (x/(1+|x|)) of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The softsign (x/(1+|x|)) values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="Tan-22"></a>**Tan-22**</a>
+
+  Calculates the tangent of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The tangent of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="ThresholdedRelu-22"></a>**ThresholdedRelu-22**</a>
+
+  ThresholdedRelu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the rectified linear function, y = x for x > alpha, y = 0 otherwise,
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Threshold value</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+## Version 23 of the default ONNX operator set
+### <a name="Attention-23"></a>**Attention-23**</a>
+
+  Computes scaled dot product attention on query, key and value tensors, using an optional attention mask if passed.
+
+  This operator covers self and cross variants of the attention operation based on sequence lengths of K, Q and V.
+
+  For self attention, `kv_sequence_length` equals to `q_sequence_length`.
+
+  For cross attention, query and key might have different lengths.
+
+  This operator also covers the 3 following variants based on the number of heads:
+  1) Multi-headed Attention (MHA): Described in the paper https://arxiv.org/pdf/1706.03762, `q_num_heads = kv_num_heads`.
+  2) Group-query Attention (GQA): Described in the paper https://arxiv.org/pdf/2305.13245, `q_num_heads > kv_num_heads`, `q_num_heads % kv_num_heads == 0`.
+  3) Multi-query Attention (MQA): Described in the paper https://arxiv.org/pdf/1911.02150, `q_num_heads > kv_num_heads`, `kv_num_heads=1`.
+
+  Attention bias to be added is calculated based on `attn_mask` input and `is_causal` attribute:
+  1) `attn_mask`: A boolean mask where a value of `True` indicates that the element should take part in attention or a float mask of the same type as query, key, value that is added to the attention score.
+  2) If `is_causal` is set to `1`, causal masking is applied with bottom-right (offset-aware) alignment: query `i` attends key `j` iff `j <= i + past_sequence_length` (the count of cached keys in `past_key`); for a square Q/K this is the standard lower-triangular mask. The causal frontier is computed independently of the `attn_mask` input and is then composed with it additively, by summing their attention biases: a boolean `attn_mask` intersects the allowed set (its disallowed positions contribute `-inf` to the bias), while a float `attn_mask` is added to the attention scores rather than disabling positions. A fully-masked query row (every key's combined additive bias is `-inf`, e.g. an all-`False` boolean `attn_mask` row) produces a zero output row (matching prevailing runtime practice), not `NaN`.
+
+  Errata (in-place behavioral correction, no opset bump): a fully-masked query row (e.g. an all-`False` boolean `attn_mask` row) now produces a zero output row instead of `NaN`, and the same zero-row guard applies to the mode-`3` `qk_matmul_output` debug output; this only replaces previously-`NaN` outputs. The mode-`3` `qk_matmul_output` is also now emitted at the operator's output precision (`T1`), matching the reference implementation, which affects only its dtype and only when `softmax_precision` differs from `T1`. No numerically useful, well-defined result of the released opset is otherwise changed.
+
+  Both past and present state key/values are optional. They shall be used together, and not allowed to use only one of them.
+  The following pattern is applied to the Q, K and V inputs after appropriate reshaping of K and V inputs based on sequence lengths and num heads provided:
+
+  ```
+    The following pattern is applied by this operator:
+        Q          K          V
+        |          |          |
+  Q*sqrt(scale) K*sqrt(scale) |
+        |          |          |
+        |       Transpose     |
+        |          |          |
+        ---MatMul---          |
+              |               |
+    softcap (if provided)     |
+              |               |
+   at_mask---Add              |
+              |               |
+           Softmax            |
+              |               |
+              -----MatMul------
+                     |
+                     Y
+  ```
+
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>is_causal</tt> : int (default is 0)</dt>
+<dd>If set to `1`, causal masking is applied with bottom-right (offset-aware) alignment: query `i` attends key `j` iff `j <= i + past_sequence_length` (the count of cached keys in `past_key`); for a square Q/K this is the standard lower-triangular mask.</dd>
+<dt><tt>kv_num_heads</tt> : int</dt>
+<dd>Number of heads of key and value. Must be used with 3D inputs of Q, K and V. </dd>
+<dt><tt>q_num_heads</tt> : int</dt>
+<dd>Number of heads of query. Must be used with 3D inputs of Q, K and V. </dd>
+<dt><tt>qk_matmul_output_mode</tt> : int (default is 0)</dt>
+<dd>If set to `0`, qk_matmul_output is the output of qk matmul. If set to `1`, qk_matmul_output is the output after the softcap operation (before mask addition). If set to `2`, qk_matmul_output includes the attention mask and softcap (if provided) applied to the output of qk matmul. If set to `3`, qk_matmul_output is the output after the softmax operation. In mode `3`, a fully-masked query row (every key disallowed, e.g. an all-`False` boolean `attn_mask` row) is a zero row, consistent with the corresponding row of the primary output `Y`: the fully-masked-row guard is applied before this output is produced. The mode-`3` output is emitted at the operator's output precision (`T1`); when `softmax_precision` differs from `T1` this is a cast of the softmax result to `T1`. Default value is 0.</dd>
+<dt><tt>scale</tt> : float</dt>
+<dd>Scaling factor applied to $Q*K^T$. Default value is `1/sqrt(head_size)`. To prevent [numerical overflow](https://tinyurl.com/sudb9s96), scale `Q`, `K` by `sqrt(scale)` before matmul.</dd>
+<dt><tt>softcap</tt> : float (default is 0.0)</dt>
+<dd>Softcap value for attention weights. Default value is 0.</dd>
+<dt><tt>softmax_precision</tt> : int</dt>
+<dd>The floating-point precision used in softmax computation. If softmax precision is not provided, the same precision as the input of softmax (Q and K) is used.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>Q</tt> : T1</dt>
+<dd>Query tensor. 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, q_hidden_size)`. For cases with a 3D input tensor, `q_hidden_size = q_num_heads * head_size`</dd>
+<dt><tt>K</tt> : T1</dt>
+<dd>Key tensor. 4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, k_hidden_size)`. For cases with a 3D input tensor, `k_hidden_size = kv_num_heads * head_size`</dd>
+<dt><tt>V</tt> : T2</dt>
+<dd>Value tensor. 4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, v_hidden_size)`. For cases with a 3D input tensor, `v_hidden_size = kv_num_heads * v_head_size`</dd>
+<dt><tt>attn_mask</tt> (optional) : U</dt>
+<dd>Attention mask. Shape must be broadcastable to 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` where `total_sequence_length = past_sequence_length + kv_sequence_length.` Two types of masks are supported. A boolean mask where a value of `True` indicates that the element should take part in attention. Also supports a float mask of the same type as query, key, value that is added to the attention score.</dd>
+<dt><tt>past_key</tt> (optional) : T1</dt>
+<dd>past state cache for key with shape `(batch_size, kv_num_heads, past_sequence_length, head_size)`</dd>
+<dt><tt>past_value</tt> (optional) : T2</dt>
+<dd>past state cache for value with shape `(batch_size, kv_num_heads, past_sequence_length, v_head_size)`</dd>
+</dl>
+
+#### Outputs (1 - 4)
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>The output tensor . 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, hidden_size)`. For cases with a 3D input tensor, `hidden_size = q_num_heads * v_head_size`</dd>
+<dt><tt>present_key</tt> (optional) : T1</dt>
+<dd>Updated key cache with shape `(batch_size, kv_num_heads, total_sequence_length, head_size)` where `total_sequence_length = past_sequence_length + kv_sequence_length`.</dd>
+<dt><tt>present_value</tt> (optional) : T2</dt>
+<dd>Updated value cache with shape `(batch_size, kv_num_heads, total_sequence_length, v_head_size)` where `total_sequence_length = past_sequence_length + kv_sequence_length`.</dd>
+<dt><tt>qk_matmul_output</tt> (optional) : T1</dt>
+<dd>The output of QK matmul. 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` where `total_sequence_length = past_sequence_length + kv_sequence_length`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain Q and K inputs types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain V input types to float tensors.</dd>
+<dt><tt>U</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool)</dt>
+<dd>Constrain output 'mask' types to boolean tensors and input types.</dd>
+</dl>
+
+### <a name="Cast-23"></a>**Cast-23**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+
+  Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+  (e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+  yield result 100. There are some string literals reserved for special floating-point values;
+  "+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+  Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+  this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+  to string tensors, plain floating-point representation (such as "314.15926") would be used.
+  Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+  of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+  Conversion from a numerical type to any numerical type is always allowed.
+  User must be aware of precision loss and value change caused by range difference between two types.
+  For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+  an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+  In more detail, the conversion among numerical types should follow these rules
+  if the destination type is not a float 8 type.
+
+  * Casting from floating point to:
+    * floating point: +/- infinity if OOR (out of range).
+    * fixed point: undefined if OOR.
+    * bool: +/- 0.0 to False; all else to True.
+  * Casting from fixed point to:
+    * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+    * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+      signed types). For example, 200 (int16) -> -56 (int8).
+    * bool: zero to False; nonzero to True.
+  * Casting from bool to:
+    * floating point: `{1.0, 0.0}`.
+    * fixed point: `{1, 0}`.
+    * bool: no change.
+
+  Float 8 type were introduced to speed up the training of
+  deep models. By default the conversion of a float *x* obeys
+  to the following rules. `[x]` means the value rounded to
+  the target mantissa width.
+
+  | x                 | E4M3FN   | E4M3FNUZ | E5M2     | E5M2FNUZ |
+  | ----------------- | -------- | -------- | -------- | -------- |
+  | 0                 | 0        | 0        | 0        | 0        |
+  | -0                | -0       | 0        | -0       | 0        |
+  | NaN               | NaN      | NaN      | NaN      | NaN      |
+  | Inf               | FLT_MAX  | NaN      | FLT_MAX  | NaN      |
+  | -Inf              | -FLT_MAX | NaN      | -FLT_MAX | NaN      |
+  | \[x\] > FLT_MAX   | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+  | \[x\] \< -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+  | else              | RNE      | RNE      | RNE      | RNE      |
+
+  The behavior changes if the parameter 'saturate' is set to False.
+  The rules then become:
+
+  | x                 | E4M3FN | E4M3FNUZ | E5M2 | E5M2FNUZ |
+  | ----------------- | ------ | -------- | ---- | -------- |
+  | 0                 | 0      | 0        | 0    | 0        |
+  | -0                | -0     | 0        | -0   | 0        |
+  | NaN               | NaN    | NaN      | NaN  | NaN      |
+  | -NaN              | -NaN   | NaN      | -NaN | NaN      |
+  | Inf               | NaN    | NaN      | Inf  | NaN      |
+  | -Inf              | -NaN   | NaN      | -Inf | NaN      |
+  | \[x\] > FLT_MAX   | NaN    | NaN      | Inf  | NaN      |
+  | \[x\] \< -FLT_MAX | NaN    | NaN      | -Inf | NaN      |
+  | else              | RNE    | RNE      | RNE  | RNE      |
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. All cases are fully described in two tables inserted in the operator description.</dd>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="CastLike-23"></a>**CastLike-23**</a>
+
+  The operator casts the elements of a given input tensor (the first input) to
+  the same data type as the elements of the second input tensor.
+  See documentation of the Cast operator for further details.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. Please refer to operator Cast description for further details.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+<dt><tt>target_type</tt> (non-differentiable) : T2</dt>
+<dd>The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor produced by casting the first input tensor to have the same type as the second input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="Constant-23"></a>**Constant-23**</a>
+
+  This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+  or value_* must be specified.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>sparse_value</tt> : sparse_tensor</dt>
+<dd>The value for the elements of the output tensor in sparse format.</dd>
+<dt><tt>value</tt> : tensor</dt>
+<dd>The value for the elements of the output tensor.</dd>
+<dt><tt>value_float</tt> : float</dt>
+<dd>The value for the sole element for the scalar, float32, output tensor.</dd>
+<dt><tt>value_floats</tt> : list of floats</dt>
+<dd>The values for the elements for the 1D, float32, output tensor.</dd>
+<dt><tt>value_int</tt> : int</dt>
+<dd>The value for the sole element for the scalar, int64, output tensor.</dd>
+<dt><tt>value_ints</tt> : list of ints</dt>
+<dd>The values for the elements for the 1D, int64, output tensor.</dd>
+<dt><tt>value_string</tt> : string</dt>
+<dd>The value for the sole element for the scalar, UTF-8 string, output tensor.</dd>
+<dt><tt>value_strings</tt> : list of strings</dt>
+<dd>The values for the elements for the 1D, UTF-8 string, output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="ConstantOfShape-23"></a>**ConstantOfShape-23**</a>
+
+  Generate a tensor with given value and shape.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>value</tt> : tensor</dt>
+<dd>(Optional) The value of the output elements.Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar. All values must be >= 0.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of shape specified by 'input'.If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'.If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype defaults to float32.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain input types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint4), tensor(int4), tensor(bool), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(float4e2m1)</dt>
+<dd>Constrain output types to be numerics or boolean.</dd>
+</dl>
+
+### <a name="DequantizeLinear-23"></a>**DequantizeLinear-23**</a>
+
+  The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the
+  full-precision tensor. The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point`
+  must have the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
+  a 1-D tensor for per-axis quantization, or have a rank identical to the input for blocked quantization.
+  See QuantizeLinear for details on quantization granularity.
+
+  `x_zero_point` and `x` must have the same type. `x` and `y` must have the same shape. In the case of dequantizing
+  `int32`, there's no zero point (zero point is supposed to be 0).
+  `zero-point` is usually not used in the case of float8 and 4-bit types quantization, but the dequantization formula remains the same
+  for consistency. The output type is determined by the attribute `output_dtype`. If `output_dtype` is not supplied then the output type
+  is the same as `x_scale`. The output type also determines the precision of the multiplication operation.
+
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+<dt><tt>output_dtype</tt> : int (default is 0)</dt>
+<dd>(Optional) The output data type. If not supplied, the output data type is inferred from `x_scale` data type (`T2`)</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D quantized input tensor to be de-quantized.</dd>
+<dt><tt>x_scale</tt> : T2</dt>
+<dd>Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>x_zero_point</tt> (optional) : T1</dt>
+<dd>Zero point for input `x`. Shape must match x_scale. It's optional. Zero point is 0 when it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>N-D full precision output tensor. It has the same shape as input `x`. The data type is specified by the `output_dtype` attribute or, in its absence, the type of `x_scale`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(int32), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>The type of the inputs 'x_zero_point' and 'x'.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>The type of the input 'x_scale'.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>The type of the output 'y'.</dd>
+</dl>
+
+### <a name="Flatten-23"></a>**Flatten-23**</a>
+
+  Flattens the input tensor into a 2D matrix. If input tensor has shape
+  (d_0, d_1, ... d_n) then the output will have shape
+  (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Indicate up to which input dimensions (exclusive) should be flattened to the outer dimension of the output. The value for axis must be in the range [-r, r], where r is the rank of the input tensor. Negative value means counting dimensions from the back. When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), where the shape of the input tensor is (d_0, d_1, ... d_n). </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>A tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>A 2D tensor with the contents of the input tensor, with input dimensions up to axis flattened to the outer dimension of the output and remaining input dimensions flattened into the inner dimension of the output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain input and output to all tensor types up to IRv10.</dd>
+</dl>
+
+### <a name="Identity-23"></a>**Identity-23**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : V</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : V</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain input and output types to all tensor, sequence, and optional types.</dd>
+</dl>
+
+### <a name="If-23"></a>**If-23**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same data type. The `then_branch` and `else_branch` may produce tensors with the same element type and different shapes. If corresponding outputs from the then-branch and the else-branch have static shapes S1 and S2, then the shape of the corresponding output variable of the if-node (if present) must be compatible with both S1 and S2 as it represents the union of both possible shapes.For example, if in a model file, the first output of `then_branch` is typed float tensor with shape [2] and the first output of `else_branch` is another float tensor with shape [3], If's first output should have (a) no shape set, or (b) a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) a shape of rank 1 with a unique `dim_param`. In contrast, the first output cannot have the shape [2] since [2] and [3] are not compatible.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), seq(tensor(float4e2m1)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4)), optional(tensor(float4e2m1))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+### <a name="Loop-23"></a>**Loop-23**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+  * input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+  * input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+  * input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]           // iteration number
+        %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+        %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+      ) {
+        %my_local = Add(%a, %b_in)
+        %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+        %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+        %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+        return %keepgoing_out, %b_out, %user_defined_val
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        /* initialize loop-carried variables and scan-output variables */
+        bool keepgoing_out = keepgoing
+        int b_out = b
+
+        for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+          /* Implicitly-defined code: bind actual parameter values
+             to formal parameter variables of loop-body */
+          bool keepgoing_in = keepgoing_out;
+          bool b_in = b_out;
+
+          /* User-defined code (loop body) */
+          int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+          b_out = a - b_in;
+          keepgoing_out = my_local > b_out;
+          user_defined_val = b_in + b_in; // b_in and b_out are different variables
+          /* End user-defined code */
+
+          /* Implicitly defined-code */
+          user_defined_vals[i] = user_defined_val // accumulate scan-output values
+        }
+        // int t = my_local; // Can't do this. my_local is not accessible here.
+
+        // The values below are bound to the output variables of the loop and therefore accessible
+        // b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any values computed in the loop body that needs to be used in a subsequent
+     iteration or after the loop are modeled using a pair of variables in the loop-body,
+     consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+     These are referred to as loop-carried dependences. The loop operation node
+     supplies the input value of the input variable for the first iteration, and
+     returns the output value of the output variable produced by the final
+     iteration.
+  3) Scan_output variables are used to implicitly concatenate values computed across
+     all the iterations. In the above example, the value of user_defined_val computed
+     over all iterations are concatenated and returned as the value of user_defined_vals
+     after the loop.
+  4) Values created in the body cannot be accessed in the enclosing scope,
+     except using the mechanism described above.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+  The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs. Scan outputs must be Tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), seq(tensor(float4e2m1)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4)), optional(tensor(float4e2m1))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+### <a name="Pad-23"></a>**Pad-23**</a>
+
+  Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+  a padded tensor (`output`) is generated.
+
+  The four supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+  1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+  2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+  3) `edge` - pads with the edge values of array
+
+  4) `wrap` - wrap-around padding as if the data tensor forms a torus
+
+
+  Example 1 (`constant` mode):
+
+  Insert 0 pads to the beginning of the second dimension.
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'constant'
+
+  constant_value = 0.0
+
+  output = [
+      [0.0, 0.0, 1.0, 1.2],
+      [0.0, 0.0, 2.3, 3.4],
+      [0.0, 0.0, 4.5, 5.7],
+  ]
+  ```
+
+  Example 2 (`reflect` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'reflect'
+
+  output = [
+      [1.0, 1.2, 1.0, 1.2],
+      [2.3, 3.4, 2.3, 3.4],
+      [4.5, 5.7, 4.5, 5.7],
+  ]
+  ```
+
+  Example 3 (`edge` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'edge'
+
+  output = [
+      [1.0, 1.0, 1.0, 1.2],
+      [2.3, 2.3, 2.3, 3.4],
+      [4.5, 4.5, 4.5, 5.7],
+  ]
+  ```
+
+  Example 4 (`wrap` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [2, 1, 1, 1]
+
+  mode = 'wrap'
+
+  output = [
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Supported modes: `constant`(default), `reflect`, `edge`, `wrap`</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Input tensor.</dd>
+<dt><tt>pads</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. `pads` should be a 1D tensor of shape [2 * num_axes] where `num_axes` refers to the number of elements in the `axes` input or the input rank if `axes` are not provided explicitly. `pads` format should be: [x1_begin, x2_begin, ..., x1_end, x2_end,...], where xi_begin is the number of pad values added at the beginning of axis `axes[i]` and xi_end, the number of pad values added at the end of axis `axes[i]`.</dd>
+<dt><tt>constant_value</tt> (optional, non-differentiable) : T</dt>
+<dd>(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, empty string or False).</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of axes that `pads` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated. If not provided, all axes are assumed (`[0, 1, ..., input_rank-1]`).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv11.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="QuantizeLinear-23"></a>**QuantizeLinear-23**</a>
+
+  The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
+  low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
+  granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
+
+  Saturation is done according to:
+  - uint16: [0, 65535]
+  - int16: [-32768, 32767]
+  - uint8: [0, 255]
+  - int8: [-128, 127]
+  - uint4: [0, 15]
+  - int4: [-8, 7]
+
+  For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+
+  `y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 and 4bit types, but the quantization
+  formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+  `x` and `y_scale` are allowed to have different types. The type of `y_scale` determines the precision of the division operation between `x` and
+  `y_scale`, unless the `precision` attribute is specified.
+
+  There are three supported quantization granularities, determined by the shape of `y_scale`.
+  In all cases, `y_zero_point` must have the same shape as `y_scale`.
+  - Per-tensor (per-layer) quantization: `y_scale` is a scalar.
+  - Per-axis quantization: The scale must be a 1-D tensor, with the length of the quantization axis. For an input shape
+   `(D0, ..., Di, ..., Dn)` and `axis=i`, `y_scale` is a 1-D tensor of length `Di`.
+  - Blocked quantization: The scale's shape is identical to the input's shape, except for one dimension, in which
+    blocking is performed. Given `x` shape `(D0, ..., Di, ..., Dn)`, `axis=i`, and block size `B`: `y_scale` shape is
+    `(D0, ..., ceil(Di/B), ..., Dn)`.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, rendering the axis unnecessary in this scenario.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+<dt><tt>output_dtype</tt> : int (default is 0)</dt>
+<dd>(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T3`). If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T3`.</dd>
+<dt><tt>precision</tt> : int (default is 0)</dt>
+<dd>(Optional) The precision of the division operation between `x` and `y_scale`. If not provided, it will be the same as the type of `y_scale`.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 quantization (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. All cases are fully described in two tables inserted in the operator description.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D full precision Input tensor to be quantized.</dd>
+<dt><tt>y_scale</tt> : T2</dt>
+<dd>Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>y_zero_point</tt> (optional) : T3</dt>
+<dd>Zero point for doing quantization to get `y`. Shape must match `y_scale`.Default is uint8 with zero point of 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>N-D quantized output tensor. It has same shape as input `x`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32)</dt>
+<dd>The type of the input 'x'.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32)</dt>
+<dd>The type of the input 'y_scale'.</dd>
+<dt><tt>T3</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>The type of the input `y_zero_point` and the output `y`.</dd>
+</dl>
+
+### <a name="RMSNormalization-23"></a>**RMSNormalization-23**</a>
+
+  This is RMS normalization defined in ONNX as function as described in the paper https://arxiv.org/pdf/1910.07467.
+        The overall computation can be split into two stages. The root mean squared norm is taken over the last D dimensions,
+        where D is the dimension of normalized_shape. For example, if normalized_shape is (3, 5) (a 2-dimensional shape),
+        the rms norm is computed over the last 2 dimensions of the input. The computation required by standardization can be
+        described by the following equations.
+        ```
+        XSquared = Mul(X, X)
+        XSquaredMean = ReduceMean<axes=normalized_axes>(XSquared)
+        MeanSquareEpsilon = Add(XSquaredMean, epsilon)
+        RMS = Sqrt(MeanSquareEpsilon)
+        Normalized = Div(X, RMS)
+        ```
+        where `normalized_axes` is `[axis, ..., rank of X - 1]`. The variables `RMS` stand for root mean square,
+        Depending on `stash_type` attribute, the actual computation
+        must happen in different floating-point precision.
+        For example, if `stash_type` is 1, this operator casts
+        all input variables to 32-bit float, perform the computation, and
+        finally cast `Normalized` back to the original type of `X`.
+        The second stage then scales the outcome of the first stage using:
+        ```
+        Y= Mul(Normalized, Scale)
+        ```
+        Let `d[i]` indicate the i-th dimension of `X`.
+        If `X`'s shape is `[d[0], ..., d[axis-1], d[axis], ..., d[rank-1]]`,
+        the shape of `RMS` is `[d[0], ..., d[axis-1], 1, ..., 1]`.
+        `Y` and `X` have the same shape. This operator supports unidirectional broadcasting
+        (`Scale` should be unidirectional broadcastable to tensor `X`);
+        for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>The first normalization dimension. If rank(X) is r, axis' allowed range is [-r, r). Negative value means counting dimensions from the back.</dd>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>stash_type</tt> : int (default is 1)</dt>
+<dd>The floating-point precision used in stage one of the computation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input tensor to be normalized. In general, the shape is (D1, D2, ... , Dn) for n-dimensional data, where the root mean squared norm is taken over the last D dimensions, D is determined by the axis attribute.</dd>
+<dt><tt>scale</tt> : V</dt>
+<dd>Scale tensor. Scale tensor shape should be broadcastable to the normalized shape.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : V</dt>
+<dd>Output data tensor. Same shape as X</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input X type to float tensors.</dd>
+<dt><tt>V</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain output Y and scale type to float tensors.</dd>
+</dl>
+
+### <a name="Reshape-23"></a>**Reshape-23**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). If 'allowzero' is set, and the new shape includes 0, the
+  dimension will be set explicitly to zero (i.e. not taken from input tensor).
+  Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+  If the attribute 'allowzero' is set, it is invalid for the specified shape to
+  contain both a zero value and -1, as the value of the dimension corresponding
+  to -1 cannot be determined uniquely.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>allowzero</tt> : int (default is 0)</dt>
+<dd>(Optional) By default, when any value in the 'shape' input is equal to zero the corresponding dimension value is copied from the input tensor dynamically. allowzero=1 indicates that if any value in the 'shape' input is set to zero, the zero value is honored, similar to NumPy.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Specified shape for output.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> (differentiable) : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="RotaryEmbedding-23"></a>**RotaryEmbedding-23**</a>
+
+  RotaryEmbedding is the implementation of rotary positional embeddings (RoPE) based on the paper https://arxiv.org/pdf/2104.09864.
+  The key advantage of RoPE is that it allows the model to understand both the absolute position of a token and the relative distances
+  between tokens. This is achieved through a rotational mechanism where the extent of rotation is computed based on the token's absolute position (position_ids).
+
+  The rotational mechanism is defined by sine and cosine functions that are used to represent the rotation angles.
+  For each token in the sequence, its positional embedding is computed by rotating its embedding vector. This is done by splitting the
+  embedding vector either into two halves or interleaving every alternate token and applying the rotation matrix to each half of the embedding vector.
+  The rotation matrix is parameterized by the token's position in the sequence. The rotated halves of the embedding vector are concatenated
+  to form the final positional embedding for each token. The rotated positional embeddings are used in the self-attention mechanism.
+  The rotation ensures that the model captures both absolute and relative positional information.
+
+  Rotary embeddings are defined using the following algorithm:
+
+  ```python
+  def rotary_embedding(
+      input: np.ndarray,
+      cos_cache: np.ndarray,
+      sin_cache: np.ndarray,
+      position_ids: np.ndarray | None = None,
+      interleaved=None,
+      rotary_embedding_dim=None,
+      num_heads=None,
+  ) -> np.ndarray:
+      original_input_shape = input.shape
+      # First ensure input to be processed has shape [batch_size, seq_len, num_heads, head_size]
+      if len(input.shape) == 4:
+          input = np.transpose(input, (0, 2, 1, 3))
+      batch_size = input.shape[0]
+      sequence_length = input.shape[1]
+      if len(input.shape) == 3:
+          hidden_size = input.shape[2]
+          assert num_heads != 0
+          head_size = int(hidden_size / num_heads)
+          new_shape = [batch_size, sequence_length, num_heads, head_size]
+          input = np.reshape(input, new_shape)
+      assert len(input.shape) == 4
+      head_size = input.shape[3]
+
+      # Fully or partially perform rotation on input based on rotary_embedding_dim attribute
+      if rotary_embedding_dim is None or rotary_embedding_dim == 0:
+          # If rotary_embedding_dim not provided, perform full rotation by using head_size
+          rotary_embedding_dim = head_size
+      x_rotate = input[:, :, :, :rotary_embedding_dim]
+      x_not_rotate = input[:, :, :, rotary_embedding_dim:]
+      rotary_embedding_dim_half = int(rotary_embedding_dim / 2)
+
+      # Retrieve sin and cos caches using position ids
+      if position_ids is not None:
+          cos_cache = cos_cache[
+              position_ids
+          ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+          sin_cache = sin_cache[
+              position_ids
+          ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+
+      # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+      if cos_cache.shape[-1] != rotary_embedding_dim_half:
+          raise ValueError(
+              f"Last dimension of cos cache ({cos_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+          )
+      if sin_cache.shape[-1] != rotary_embedding_dim_half:
+          raise ValueError(
+              f"Last dimension of sin cache ({sin_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+          )
+
+      cos_cache = np.expand_dims(
+          cos_cache, axis=2
+      )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
+      sin_cache = np.expand_dims(
+          sin_cache, axis=2
+      )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
+
+      # Either divide the input in halves or interleave (based on interleaved attribute)
+      if interleaved:
+          x1 = x_rotate[:, :, :, 0::2]
+          x2 = x_rotate[:, :, :, 1::2]
+      else:
+          x1, x2 = np.split(x_rotate, 2, axis=-1)
+
+      # Calculate real and imaginary values
+      real = (cos_cache * x1) - (sin_cache * x2)
+      imag = (sin_cache * x1) + (cos_cache * x2)
+
+      # Inserted rotated embeddings back to the original input
+      if interleaved:
+          # x_rotate[:, :, :, 0::2] = real
+          # x_rotate[:, :, :, 1::2] = imag
+          real = np.expand_dims(real, axis=-1)
+          imag = np.expand_dims(imag, axis=-1)
+          x_rotate_concat = np.concatenate((real, imag), axis=-1)
+          x_rotate = np.reshape(x_rotate_concat, x_rotate.shape)
+      else:
+          x_rotate = np.concatenate((real, imag), axis=-1)
+      output = np.concatenate((x_rotate, x_not_rotate), axis=-1)
+      if len(original_input_shape) == 3:
+          output = np.reshape(output, original_input_shape)
+      else:
+          output = np.transpose(output, (0, 2, 1, 3))
+      return output
+  ```
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>interleaved</tt> : int (default is 0)</dt>
+<dd>Rotate using interleaved pattern. Default value is 0 (False).</dd>
+<dt><tt>num_heads</tt> : int</dt>
+<dd>Number of attention heads. Must be provided when input is a 3D tensor. </dd>
+<dt><tt>rotary_embedding_dim</tt> : int (default is 0)</dt>
+<dd>Rotary embedding dimension used to apply partial rotary embeddings.</dd>
+</dl>
+
+#### Inputs (3 - 4)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input tensor representing the token embeddings. 4D tensor with shape `(batch_size, num_heads, sequence_length, head_size)` or 3D tensor with shape `(batch_size, sequence_length, hidden_size)`. For cases with a 4D input tensor, `head_size` has to be even. For cases with a 3D input tensor, `num_heads` attribute must be provided and `hidden_size` must be an even multiple of `num_heads` where `hidden_size = num_heads * head_size`</dd>
+<dt><tt>cos_cache</tt> : T</dt>
+<dd>The cosine values for the rotation. 2D tensor with shape `(max_position_id_plus_1, head_size / 2)` for full rotation or `(max_position_id_plus_1, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are provided. 3D tensor with shape `(batch_size, sequence_length, head_size / 2)` for full rotation or `(batch_size, sequence_length, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are not provided. `max_position_id_plus_1` is a parameter to the model.</dd>
+<dt><tt>sin_cache</tt> : T</dt>
+<dd>The sine values for the rotation. 2D tensor with shape `(max_position_id_plus_1, head_size / 2)` for full rotation or `(max_position_id_plus_1, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are provided. 3D tensor with shape `(batch_size, sequence_length, head_size / 2)` for full rotation or `(batch_size, sequence_length, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are not provided. `max_position_id_plus_1` is a parameter to the model.</dd>
+<dt><tt>position_ids</tt> (optional) : M</dt>
+<dd>The position indices for the tokens. 2D tensor with shape `(batch_size, sequence_length)`</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Tensor with same shape as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>M</tt> : tensor(int64)</dt>
+<dd>Constrain input and output types to integer tensors.</dd>
+</dl>
+
+### <a name="Scan-23"></a>**Scan-23**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops).
+  Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+  well as scan_output_element tensors) are required to have the same shape in each iteration
+  of the loop (a restriction imposed to enable efficient memory allocation).
+
+  Note that the iterated element passed to the body subgraph does not have a sequence
+  axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The optional attribute scan_input_directions specifies the direction (forward or backward)
+  for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+  direction. A bidirectional scan may be performed by specifying the same tensor input twice
+  in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+  The scan_output of the operation is produced by concatenating the scan_output_element
+  values produced by the body in each iteration.  The optional attribute scan_output_directions
+  specifies the direction in which scan_output is constructed (by appending or prepending the
+  scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+  is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+  The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+  If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+  batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+  Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+  The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+  are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+  scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+  value of 1.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body,
+          scan_input_axes = [axis_1, ..., axis_m]
+      > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+      sequence_length = scan_1.shape[axis_1];
+
+      // initialize state-variables
+      st_1 = init_1; ... st_n = init_n;
+      // initialize scan-output variables: [] denotes an empty tensor
+      scan_out_1 = []; ...; scan_out_k = [];
+      // identify number of iterations:
+
+      // execute loop
+      for (int t = 0; t < sequence_length; ++t) {
+          // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+          // of rank one less than T obtained by indexing T at position t along axis k.
+          si_1 = scan_1<axis=axis_1>[t];
+          ... ;
+          si_m = scan_m<axis=axis_m>[t];
+          // execute loop-body
+          st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+          // accumulate the scan-output elements
+          scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+      }
+
+      return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+<dt><tt>scan_input_axes</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the axis to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will be used as the scan axis for every scan_input. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>scan_input_directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>scan_output_axes</tt> : list of ints</dt>
+<dd>An optional list of K flags. The i-th element of the list specifies the axis for the i-th scan_output. The scan outputs are accumulated along the specified axis. If omitted, 0 will be used as the scan axis for every scan_output. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1].</dd>
+<dt><tt>scan_output_directions</tt> : list of ints</dt>
+<dd>An optional list of K flags, one for each scan_output. The i-th element of the list specifies whether the i-th scan_output should be constructed by appending or prepending a new value in each iteration: 0 indicates appending and 1 indicates prepending. If omitted, all scan_output tensors will be produced by appending a value in each iteration.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>All Tensor types up to IRv11.</dd>
+</dl>
+
+### <a name="Shape-23"></a>**Shape-23**</a>
+
+  Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+  Optional attributes start and end can be used to compute a slice of the input tensor's shape.
+  If start axis is omitted, the slice starts from axis 0.
+  The end axis, if specified, is exclusive (and the returned value will not include the size of that axis).
+  If the end axis is omitted, the axes upto the last one will be included.
+  Negative axes indicate counting back from the last axis.
+  Note that axes will be clamped to the range [0, r], where r is the
+  rank of the input tensor if they are out-of-range (after adding r in the case of
+  negative axis). Thus, specifying any end value > r is equivalent to specifying an end
+  value of r, and specifying any start value < -r is equivalent to specifying a start
+  value of 0. If start > end, the result will be an empty shape.
+
+  Examples:
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  No attributes specified.
+  Output: [2, 3, 4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: -1
+  Output: [4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  end: -1
+  Output: [2, 3]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: 1
+  end: 2
+  Output: [3]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>end</tt> : int</dt>
+<dd>(Optional) Ending axis for slicing the shape. Negative value means counting dimensions from the back. If omitted, sizes of all axes upto (including) the last one will be included.</dd>
+<dt><tt>start</tt> : int (default is 0)</dt>
+<dd>(Optional) Starting axis for slicing the shape. Default value is 0.Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>shape</tt> (non-differentiable) : T1</dt>
+<dd>Shape of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor.</dd>
+</dl>
+
+### <a name="Size-23"></a>**Size-23**</a>
+
+  Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>Total number of elements of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor, which should be a scalar though.</dd>
+</dl>
+
+### <a name="Squeeze-23"></a>**Squeeze-23**</a>
+
+  Remove single-dimensional entries from the shape of a tensor.
+  Takes an input `axes` with a list of axes to squeeze.
+  If `axes` is not provided, all the single dimensions will be removed from
+  the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensors with at least max(dims) dimensions.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>1D tensor of integers indicating the dimensions to squeeze. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>squeezed</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv11.</dd>
+</dl>
+
+### <a name="Transpose-23"></a>**Transpose-23**</a>
+
+  Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+  The optional attribute `perm` must be a permutation of the dimensions of
+  the input tensor. Axis `i` of the output tensor corresponds to the axis
+  `perm[i]` of the input tensor.
+  For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 1, 3).
+  When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 3, 1).
+  If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+  where `n` is the rank of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>perm</tt> : list of ints</dt>
+<dd>A list of integers. By default, reverse the dimensions, otherwise permute the axes according to the values given. Its length must be equal to the rank of the input.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>transposed</tt> (differentiable) : T</dt>
+<dd>Transposed output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Unsqueeze-23"></a>**Unsqueeze-23**</a>
+
+  Insert single-dimensional entries to the shape of an input tensor (`data`).
+  Takes one required input `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).
+
+  For example, given an input tensor (`data`) of shape [3, 4, 5], then
+  Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].
+
+  The input `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
+  The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
+  Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
+  The order of values in `axes` does not matter and can come in any order.
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Original tensor</dd>
+<dt><tt>axes</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>1D tensor of integers indicating the dimensions to be inserted. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(expanded).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>expanded</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv11.</dd>
+</dl>
+
+## Version 24 of the default ONNX operator set
+### <a name="Attention-24"></a>**Attention-24**</a>
+
+  Computes scaled dot product attention on query, key and value tensors, using an optional attention mask if passed.
+
+  This operator covers self and cross variants of the attention operation based on sequence lengths of K, Q and V.
+
+  For self attention, `kv_sequence_length` equals to `q_sequence_length`.
+
+  For cross attention, query and key might have different lengths.
+
+  This operator also covers the 3 following variants based on the number of heads:
+  1) Multi-headed Attention (MHA): Described in the paper https://arxiv.org/pdf/1706.03762, `q_num_heads = kv_num_heads`.
+  2) Group-query Attention (GQA): Described in the paper https://arxiv.org/pdf/2305.13245, `q_num_heads > kv_num_heads`, `q_num_heads % kv_num_heads == 0`.
+  3) Multi-query Attention (MQA): Described in the paper https://arxiv.org/pdf/1911.02150, `q_num_heads > kv_num_heads`, `kv_num_heads=1`.
+
+  Attention bias to be added is calculated based on `attn_mask` input and `is_causal` attribute:
+  1) `attn_mask`: A boolean mask where a value of `True` indicates that the element should take part in attention or a float mask of the same type as query, key, value that is added to the attention score.
+  2) If `is_causal` is set to `1`, causal masking is applied with bottom-right (offset-aware) alignment: query `i` attends key `j` iff `j <= i + offset`, as illustrated below.
+
+  ```
+    2D causal mask for Attention (PR onnx/onnx#8068)
+     S_q=4 queries, S_k=8 keys
+     Rule: query i attends key j iff j <= i + offset
+           offset = nonpad_kv_seqlen - S_q
+
+     nonpad_kv_seqlen=4, offset=4-4=0
+
+            k0  k1  k2  k3  k4  k5  k6  k7
+           +----+----+----+----+----+----+----+----+
+      q0   | ## |    |    |    |    |    |    |    |
+           +----+----+----+----+----+----+----+----+
+      q1   | ## | ## |    |    |    |    |    |    |
+           +----+----+----+----+----+----+----+----+
+      q2   | ## | ## | ## |    |    |    |    |    |
+           +----+----+----+----+----+----+----+----+
+      q3   | ## | ## | ## | ## |    |    |    |    |
+           +----+----+----+----+----+----+----+----+
+
+
+     nonpad_kv_seqlen=8, offset=8-4=4
+
+            k0  k1  k2  k3  k4  k5  k6  k7
+           +----+----+----+----+----+----+----+----+
+      q0   | ## | ## | ## | ## | ## |    |    |    |
+           +----+----+----+----+----+----+----+----+
+      q1   | ## | ## | ## | ## | ## | ## |    |    |
+           +----+----+----+----+----+----+----+----+
+      q2   | ## | ## | ## | ## | ## | ## | ## |    |
+           +----+----+----+----+----+----+----+----+
+      q3   | ## | ## | ## | ## | ## | ## | ## | ## |
+           +----+----+----+----+----+----+----+----+
+  ```
+
+  With `nonpad_kv_seqlen=4` (offset=0), the mask is the standard lower-triangular. With `nonpad_kv_seqlen=8` (offset=4), the diagonal shifts right by 4, so each query sees the 4 additional valid cached keys.
+
+  `offset` is the count of valid keys preceding the current query block: `offset = past_sequence_length` when `past_key` is provided; `offset = nonpad_kv_seqlen - q_sequence_length` (per batch) when an external cache is indicated by `nonpad_kv_seqlen` without `past_key`; `offset = 0` when neither is provided (the no-cache case, which reduces to the standard lower-triangular mask). When `offset < 0` (`nonpad_kv_seqlen < q_sequence_length`, i.e. more query tokens than cached keys) the leading query rows have an empty key set (no key satisfies `j <= i + offset`) and are fully masked. The causal frontier is computed independently of `attn_mask` and is then composed with it additively: a boolean `attn_mask` intersects the allowed set (its disallowed positions contribute `-inf` to the bias), while a float `attn_mask` is added to the attention scores rather than disabling positions. A fully-masked query row (no key attended, including the negative-offset leading rows) produces a zero output row, not `NaN`, for both `Y` and the mode-`3` `qk_matmul_output` debug output; the mode-`3` `qk_matmul_output` is emitted at the operator's output precision (`T1`).
+
+  Errata (in-place behavioral correction, no opset bump): the reference implementation and backend tests were incorrect when `nonpad_kv_seqlen != q_sequence_length` (nonzero bottom-right offset, top-left instead of bottom-right causal alignment) and produced `NaN` for fully-masked rows; corrected in version 1.23. This fixed three behaviors described above: external-cache bottom-right causal alignment (`offset = nonpad_kv_seqlen - q_sequence_length`), zero (non-`NaN`) output for fully-masked rows including the mode-`3` `qk_matmul_output`, and the mode-`3` `qk_matmul_output` precision (`T1`).
+
+  With respect to KV cache update, this operator allows the following two use cases:
+
+  1) Cache update happens inside the Attention operator. In this case, the `K` and `V` inputs contain only the incoming
+  tokens for the current autoregressive step, and the four optional inputs/outputs past and present key and value are
+  all needed. The Attention op performs a Concat operation on the past and incoming key and value to form the present
+  key and value, respectively. Note that this only works correctly for the special case where the past key and value
+  do not contain padded tokens.
+  2) Cache update happens outside the Attention operator (for example, through the `TensorScatter` operator). In this
+  case, the `K` and `V` inputs correspond to the entire cache tensor, so the four optional inputs/outputs past and
+  present key and value should not be used. An additional input `nonpad_kv_seqlen` of shape (batch_size,) may be
+  provided to indicate the number of non-padding tokens in each sample of the batch to save unnecessary computation.
+  Here, the kv_sequence dimension of `attn_mask` can be shorter than `K` and `V`, but still needs to be at least as long
+  as the maximum value of `nonpad_kv_seqlen`.
+
+  Both past and present state key/values are optional. They shall be used together, and not allowed to use only one of them.
+  The following pattern is applied to the Q, K and V inputs after appropriate reshaping of K and V inputs based on sequence lengths and num heads provided:
+
+  ```
+    The following pattern is applied by this operator:
+        Q          K          V
+        |          |          |
+  Q*sqrt(scale) K*sqrt(scale) |
+        |          |          |
+        |       Transpose     |
+        |          |          |
+        ---MatMul---          |
+              |               |
+    softcap (if provided)     |
+              |               |
+   at_mask---Add              |
+              |               |
+           Softmax            |
+              |               |
+              -----MatMul------
+                     |
+                     Y
+  ```
+
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>is_causal</tt> : int (default is 0)</dt>
+<dd>If set to `1`, causal masking is applied. For a square Q/K (no cache offset) this is a lower-triangular matrix. In general the mask is bottom-right (offset-aware): query in-block index `i` attends key `j` iff `j <= i + offset`, where `offset` is the count of valid keys preceding the query block (`past_sequence_length` for an internal `past_key` cache, or `nonpad_kv_seqlen - q_sequence_length` per batch for an external cache). When `offset = 0` this reduces to the lower-triangular (top-left) mask.</dd>
+<dt><tt>kv_num_heads</tt> : int</dt>
+<dd>Number of heads of key and value. Must be used with 3D inputs of Q, K and V. </dd>
+<dt><tt>q_num_heads</tt> : int</dt>
+<dd>Number of heads of query. Must be used with 3D inputs of Q, K and V. </dd>
+<dt><tt>qk_matmul_output_mode</tt> : int (default is 0)</dt>
+<dd>If set to `0`, qk_matmul_output is the output of qk matmul. If set to `1`, qk_matmul_output is the output after the softcap operation (before mask addition). If set to `2`, qk_matmul_output includes the attention mask and softcap (if provided) applied to the output of qk matmul. If set to `3`, qk_matmul_output is the output after the softmax operation. In mode `3`, a fully-masked query row (every key disallowed) is a zero row, consistent with the corresponding row of the primary output `Y`: the fully-masked-row guard is applied before this output is produced. The mode-`3` output is emitted at the operator's output precision (`T1`); when `softmax_precision` differs from `T1` this is a cast of the softmax result to `T1`. Default value is 0.</dd>
+<dt><tt>scale</tt> : float</dt>
+<dd>Scaling factor applied to $Q*K^T$. Default value is `1/sqrt(head_size)`. To prevent [numerical overflow](https://tinyurl.com/sudb9s96), scale `Q`, `K` by `sqrt(scale)` before matmul.</dd>
+<dt><tt>softcap</tt> : float (default is 0.0)</dt>
+<dd>Softcap value for attention weights. Default value is 0.</dd>
+<dt><tt>softmax_precision</tt> : int</dt>
+<dd>The floating-point precision used in softmax computation. If softmax precision is not provided, the same precision as the input of softmax (Q and K) is used.</dd>
+</dl>
+
+#### Inputs (3 - 7)
+
+<dl>
+<dt><tt>Q</tt> : T1</dt>
+<dd>Query tensor. 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, q_hidden_size)`. For cases with a 3D input tensor, `q_hidden_size = q_num_heads * head_size`</dd>
+<dt><tt>K</tt> : T1</dt>
+<dd>Key tensor. 4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, k_hidden_size)`. For cases with a 3D input tensor, `k_hidden_size = kv_num_heads * head_size`</dd>
+<dt><tt>V</tt> : T2</dt>
+<dd>Value tensor. 4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, v_hidden_size)`. For cases with a 3D input tensor, `v_hidden_size = kv_num_heads * v_head_size`</dd>
+<dt><tt>attn_mask</tt> (optional) : U</dt>
+<dd>Attention mask. Shape must be broadcastable to `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` where `total_sequence_length = past_sequence_length + kv_sequence_length.` The last dimension can also be shorter than `total_sequence_length` and will be padded to `total_sequence_length` with negative infinity. Two types of masks are supported: a boolean mask where a value of `True` indicates that the element should take part in attention, or a float mask of the same type as query, key, value that is added to the attention score.</dd>
+<dt><tt>past_key</tt> (optional) : T1</dt>
+<dd>past state cache for key with shape `(batch_size, kv_num_heads, past_sequence_length, head_size)`</dd>
+<dt><tt>past_value</tt> (optional) : T2</dt>
+<dd>past state cache for value with shape `(batch_size, kv_num_heads, past_sequence_length, v_head_size)`</dd>
+<dt><tt>nonpad_kv_seqlen</tt> (optional) : tensor(int64)</dt>
+<dd>A vector of integers of shape `(batch_size,)` that indicates the number of valid (ie, non-padding) tokens in each sample. A padding mask can be derived from this. This should not be used together with `past_key` and `past_value` inputs or `present_key` and `present_value` outputs (See the KV cache use cases in the operator description).</dd>
+</dl>
+
+#### Outputs (1 - 4)
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>The output tensor . 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, hidden_size)`. For cases with a 3D input tensor, `hidden_size = q_num_heads * v_head_size`</dd>
+<dt><tt>present_key</tt> (optional) : T1</dt>
+<dd>Updated key cache with shape `(batch_size, kv_num_heads, total_sequence_length, head_size)` where `total_sequence_length = past_sequence_length + kv_sequence_length`.</dd>
+<dt><tt>present_value</tt> (optional) : T2</dt>
+<dd>Updated value cache with shape `(batch_size, kv_num_heads, total_sequence_length, v_head_size)` where `total_sequence_length = past_sequence_length + kv_sequence_length`.</dd>
+<dt><tt>qk_matmul_output</tt> (optional) : T1</dt>
+<dd>The output of QK matmul. 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` where `total_sequence_length = past_sequence_length + kv_sequence_length`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain Q and K inputs types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain V input types to float tensors.</dd>
+<dt><tt>U</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool)</dt>
+<dd>Constrain output 'mask' types to boolean tensors and input types.</dd>
+</dl>
+
+### <a name="Cast-24"></a>**Cast-24**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+
+  Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+  (e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+  yield result 100. There are some string literals reserved for special floating-point values;
+  "+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+  Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+  this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+  to string tensors, plain floating-point representation (such as "314.15926") would be used.
+  Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+  of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+  Conversion from a numerical type to any numerical type is always allowed.
+  User must be aware of precision loss and value change caused by range difference between two types.
+  For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+  an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+  In more detail, the conversion among numerical types should follow these rules
+  if the destination type is not a float 8 type.
+
+  * Casting from floating point to:
+    * floating point: +/- infinity if OOR (out of range).
+    * fixed point: undefined if OOR.
+    * bool: +/- 0.0 to False; all else to True.
+  * Casting from fixed point to:
+    * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+    * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+      signed types). For example, 200 (int16) -> -56 (int8).
+    * bool: zero to False; nonzero to True.
+  * Casting from bool to:
+    * floating point: `{1.0, 0.0}`.
+    * fixed point: `{1, 0}`.
+    * bool: no change.
+
+  Float 8 types (E4M3FN, E4M3FNUZ, E5M2, E5M2FNUZ) were introduced to speed up the training of
+  deep models. By default the conversion of a float *x* obeys
+  to the following rules. `[x]` means the value rounded to
+  the target mantissa width.
+
+  | x                 | E4M3FN   | E4M3FNUZ | E5M2     | E5M2FNUZ |
+  | ----------------- | -------- | -------- | -------- | -------- |
+  | 0                 | 0        | 0        | 0        | 0        |
+  | -0                | -0       | 0        | -0       | 0        |
+  | NaN               | NaN      | NaN      | NaN      | NaN      |
+  | Inf               | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+  | -Inf              | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+  | \[x\] > FLT_MAX   | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+  | \[x\] \< -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+  | else              | RNE      | RNE      | RNE      | RNE      |
+
+  The behavior changes if the parameter 'saturate' is set to False.
+  The rules then become:
+
+  | x                 | E4M3FN | E4M3FNUZ | E5M2 | E5M2FNUZ |
+  | ----------------- | ------ | -------- | ---- | -------- |
+  | 0                 | 0      | 0        | 0    | 0        |
+  | -0                | -0     | 0        | -0   | 0        |
+  | NaN               | NaN    | NaN      | NaN  | NaN      |
+  | -NaN              | -NaN   | NaN      | -NaN | NaN      |
+  | Inf               | NaN    | NaN      | Inf  | NaN      |
+  | -Inf              | -NaN   | NaN      | -Inf | NaN      |
+  | \[x\] > FLT_MAX   | NaN    | NaN      | Inf  | NaN      |
+  | \[x\] \< -FLT_MAX | NaN    | NaN      | -Inf | NaN      |
+  | else              | RNE    | RNE      | RNE  | RNE      |
+
+  FLOAT8E8M0 type was introduced to enable [Microscaling (MX) formats](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf).
+  When casting to FLOAT8E8M0, the rounding behavior can be specified using the `round_mode` and `saturate` attributes.
+  The current CUDA behavior is to round up and saturate. Casting negative values to FLOAT8E8M0 gives undefined behavior.
+  The following table describes the casting behavior of special values to FLOAT8E8M0 in the two most common cases.
+
+  | x                 | saturate + up | non-saturate + nearest |
+  | ----------------- | ------------- | ---------------------  |
+  | 0                 | 0             | NaN                    |
+  | -0                | Unspecified   | Unspecified            |
+  | NaN               | NaN           | NaN                    |
+  | Inf               | E8M0_MAX      | NaN                    |
+  | x > E8M0_MAX      | E8M0_MAX      | NaN                    |
+  | x < E8M0_MIN      | E8M0_MIN      | NaN                    |
+  | x < 0             | Unspecified   | Unspecified            |
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>round_mode</tt> : string (default is up)</dt>
+<dd>Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. `up`: round to nearest value away from zero, `down`: round to nearest value towards zero, `nearest`: round to nearest value and ties round up.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. All cases are fully described in the tables inserted in the operator description.</dd>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="CastLike-24"></a>**CastLike-24**</a>
+
+  The operator casts the elements of a given input tensor (the first input) to
+  the same data type as the elements of the second input tensor.
+  See documentation of the Cast operator for further details.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>round_mode</tt> : string (default is up)</dt>
+<dd>Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. `up`: round to nearest value away from zero, `down`: round to nearest value towards zero, `nearest`: round to nearest value and ties round up. Please refer to operator Cast description for further details.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. Please refer to operator Cast description for further details.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+<dt><tt>target_type</tt> (non-differentiable) : T2</dt>
+<dd>The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor produced by casting the first input tensor to have the same type as the second input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="Constant-24"></a>**Constant-24**</a>
+
+  This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+  or value_* must be specified.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>sparse_value</tt> : sparse_tensor</dt>
+<dd>The value for the elements of the output tensor in sparse format.</dd>
+<dt><tt>value</tt> : tensor</dt>
+<dd>The value for the elements of the output tensor.</dd>
+<dt><tt>value_float</tt> : float</dt>
+<dd>The value for the sole element for the scalar, float32, output tensor.</dd>
+<dt><tt>value_floats</tt> : list of floats</dt>
+<dd>The values for the elements for the 1D, float32, output tensor.</dd>
+<dt><tt>value_int</tt> : int</dt>
+<dd>The value for the sole element for the scalar, int64, output tensor.</dd>
+<dt><tt>value_ints</tt> : list of ints</dt>
+<dd>The values for the elements for the 1D, int64, output tensor.</dd>
+<dt><tt>value_string</tt> : string</dt>
+<dd>The value for the sole element for the scalar, UTF-8 string, output tensor.</dd>
+<dt><tt>value_strings</tt> : list of strings</dt>
+<dd>The values for the elements for the 1D, UTF-8 string, output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="ConstantOfShape-24"></a>**ConstantOfShape-24**</a>
+
+  Generate a tensor with given value and shape.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>value</tt> : tensor</dt>
+<dd>(Optional) The value of the output elements.Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar. All values must be >= 0.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of shape specified by 'input'.If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'.If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype defaults to float32.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain input types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint4), tensor(int4), tensor(bool), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain output types to be numerics or boolean.</dd>
+</dl>
+
+### <a name="DequantizeLinear-24"></a>**DequantizeLinear-24**</a>
+
+  The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the
+  full-precision tensor. The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point`
+  must have the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
+  a 1-D tensor for per-axis quantization, or have a rank identical to the input for blocked quantization.
+  See QuantizeLinear for details on quantization granularity.
+
+  `x_zero_point` and `x` must have the same type. `x` and `y` must have the same shape. In the case of dequantizing
+  `int32`, there's no zero point (zero point is supposed to be 0).
+  `zero-point` is usually not used in the case of float8 and 4-bit types quantization, but the dequantization formula remains the same
+  for consistency. The output type is determined by the attribute `output_dtype`. If `output_dtype` is not supplied then the output type
+  is the same as `x_scale`. The output type also determines the precision of the multiplication operation.
+
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+<dt><tt>output_dtype</tt> : int (default is 0)</dt>
+<dd>(Optional) The output data type. If not supplied, the output data type is inferred from `x_scale` data type (`T2`)</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D quantized input tensor to be de-quantized.</dd>
+<dt><tt>x_scale</tt> : T2</dt>
+<dd>Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>x_zero_point</tt> (optional) : T1</dt>
+<dd>Zero point for input `x`. Shape must match x_scale. It's optional. Zero point is 0 when it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>N-D full precision output tensor. It has the same shape as input `x`. The data type is specified by the `output_dtype` attribute or, in its absence, the type of `x_scale`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(int32), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>The type of the inputs 'x_zero_point' and 'x'.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(float8e8m0)</dt>
+<dd>The type of the input 'x_scale'.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>The type of the output 'y'.</dd>
+</dl>
+
+### <a name="Flatten-24"></a>**Flatten-24**</a>
+
+  Flattens the input tensor into a 2D matrix. If input tensor has shape
+  (d_0, d_1, ... d_n) then the output will have shape
+  (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Indicate up to which input dimensions (exclusive) should be flattened to the outer dimension of the output. The value for axis must be in the range [-r, r], where r is the rank of the input tensor. Negative value means counting dimensions from the back. When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), where the shape of the input tensor is (d_0, d_1, ... d_n). </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>A tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>A 2D tensor with the contents of the input tensor, with input dimensions up to axis flattened to the outer dimension of the output and remaining input dimensions flattened into the inner dimension of the output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input and output to all tensor types up to IRv12.</dd>
+</dl>
+
+### <a name="Identity-24"></a>**Identity-24**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : V</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : V</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain input and output types to all tensor, sequence, and optional types.</dd>
+</dl>
+
+### <a name="If-24"></a>**If-24**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same data type. The `then_branch` and `else_branch` may produce tensors with the same element type and different shapes. If corresponding outputs from the then-branch and the else-branch have static shapes S1 and S2, then the shape of the corresponding output variable of the if-node (if present) must be compatible with both S1 and S2 as it represents the union of both possible shapes.For example, if in a model file, the first output of `then_branch` is typed float tensor with shape [2] and the first output of `else_branch` is another float tensor with shape [3], If's first output should have (a) no shape set, or (b) a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) a shape of rank 1 with a unique `dim_param`. In contrast, the first output cannot have the shape [2] since [2] and [3] are not compatible.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), seq(tensor(float4e2m1)), seq(tensor(float8e8m0)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4)), optional(tensor(float4e2m1)), optional(tensor(float8e8m0))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+### <a name="Loop-24"></a>**Loop-24**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+  * input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+  * input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+  * input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]           // iteration number
+        %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+        %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+      ) {
+        %my_local = Add(%a, %b_in)
+        %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+        %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+        %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+        return %keepgoing_out, %b_out, %user_defined_val
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        /* initialize loop-carried variables and scan-output variables */
+        bool keepgoing_out = keepgoing
+        int b_out = b
+
+        for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+          /* Implicitly-defined code: bind actual parameter values
+             to formal parameter variables of loop-body */
+          bool keepgoing_in = keepgoing_out;
+          bool b_in = b_out;
+
+          /* User-defined code (loop body) */
+          int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+          b_out = a - b_in;
+          keepgoing_out = my_local > b_out;
+          user_defined_val = b_in + b_in; // b_in and b_out are different variables
+          /* End user-defined code */
+
+          /* Implicitly defined-code */
+          user_defined_vals[i] = user_defined_val // accumulate scan-output values
+        }
+        // int t = my_local; // Can't do this. my_local is not accessible here.
+
+        // The values below are bound to the output variables of the loop and therefore accessible
+        // b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any values computed in the loop body that needs to be used in a subsequent
+     iteration or after the loop are modeled using a pair of variables in the loop-body,
+     consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+     These are referred to as loop-carried dependences. The loop operation node
+     supplies the input value of the input variable for the first iteration, and
+     returns the output value of the output variable produced by the final
+     iteration.
+  3) Scan_output variables are used to implicitly concatenate values computed across
+     all the iterations. In the above example, the value of user_defined_val computed
+     over all iterations are concatenated and returned as the value of user_defined_vals
+     after the loop.
+  4) Values created in the body cannot be accessed in the enclosing scope,
+     except using the mechanism described above.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+  The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs. Scan outputs must be Tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), seq(tensor(float4e2m1)), seq(tensor(float8e8m0)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4)), optional(tensor(float4e2m1)), optional(tensor(float8e8m0))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+### <a name="Pad-24"></a>**Pad-24**</a>
+
+  Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+  a padded tensor (`output`) is generated.
+
+  The four supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+  1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+  2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+  3) `edge` - pads with the edge values of array
+
+  4) `wrap` - wrap-around padding as if the data tensor forms a torus
+
+
+  Example 1 (`constant` mode):
+
+  Insert 0 pads to the beginning of the second dimension.
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'constant'
+
+  constant_value = 0.0
+
+  output = [
+      [0.0, 0.0, 1.0, 1.2],
+      [0.0, 0.0, 2.3, 3.4],
+      [0.0, 0.0, 4.5, 5.7],
+  ]
+  ```
+
+  Example 2 (`reflect` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'reflect'
+
+  output = [
+      [1.0, 1.2, 1.0, 1.2],
+      [2.3, 3.4, 2.3, 3.4],
+      [4.5, 5.7, 4.5, 5.7],
+  ]
+  ```
+
+  Example 3 (`edge` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'edge'
+
+  output = [
+      [1.0, 1.0, 1.0, 1.2],
+      [2.3, 2.3, 2.3, 3.4],
+      [4.5, 4.5, 4.5, 5.7],
+  ]
+  ```
+
+  Example 4 (`wrap` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [2, 1, 1, 1]
+
+  mode = 'wrap'
+
+  output = [
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Supported modes: `constant`(default), `reflect`, `edge`, `wrap`</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Input tensor.</dd>
+<dt><tt>pads</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. `pads` should be a 1D tensor of shape [2 * num_axes] where `num_axes` refers to the number of elements in the `axes` input or the input rank if `axes` are not provided explicitly. `pads` format should be: [x1_begin, x2_begin, ..., x1_end, x2_end,...], where xi_begin is the number of pad values added at the beginning of axis `axes[i]` and xi_end, the number of pad values added at the end of axis `axes[i]`.</dd>
+<dt><tt>constant_value</tt> (optional, non-differentiable) : T</dt>
+<dd>(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, empty string or False).</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of axes that `pads` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated. If not provided, all axes are assumed (`[0, 1, ..., input_rank-1]`).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv12.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="QuantizeLinear-24"></a>**QuantizeLinear-24**</a>
+
+  The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
+  low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
+  granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
+
+  Saturation is done according to:
+  - uint16: [0, 65535]
+  - int16: [-32768, 32767]
+  - uint8: [0, 255]
+  - int8: [-128, 127]
+  - uint4: [0, 15]
+  - int4: [-8, 7]
+
+  For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+
+  `y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 and 4bit types, but the quantization
+  formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+  `x` and `y_scale` are allowed to have different types. The type of `y_scale` determines the precision of the division operation between `x` and
+  `y_scale`, unless the `precision` attribute is specified.
+
+  There are three supported quantization granularities, determined by the shape of `y_scale`.
+  In all cases, `y_zero_point` must have the same shape as `y_scale`.
+  - Per-tensor (per-layer) quantization: `y_scale` is a scalar.
+  - Per-axis quantization: The scale must be a 1-D tensor, with the length of the quantization axis. For an input shape
+   `(D0, ..., Di, ..., Dn)` and `axis=i`, `y_scale` is a 1-D tensor of length `Di`.
+  - Blocked quantization: The scale's shape is identical to the input's shape, except for one dimension, in which
+    blocking is performed. Given `x` shape `(D0, ..., Di, ..., Dn)`, `axis=i`, and block size `B`: `y_scale` shape is
+    `(D0, ..., ceil(Di/B), ..., Dn)`.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, rendering the axis unnecessary in this scenario.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+<dt><tt>output_dtype</tt> : int (default is 0)</dt>
+<dd>(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T3`). If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T3`.</dd>
+<dt><tt>precision</tt> : int (default is 0)</dt>
+<dd>(Optional) The precision of the division operation between `x` and `y_scale`. If not provided, it will be the same as the type of `y_scale`.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 quantization (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. All cases are fully described in two tables inserted in the operator description.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D full precision Input tensor to be quantized.</dd>
+<dt><tt>y_scale</tt> : T2</dt>
+<dd>Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>y_zero_point</tt> (optional) : T3</dt>
+<dd>Zero point for doing quantization to get `y`. Shape must match `y_scale`. Default is uint8 with zero point of 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>N-D quantized output tensor. It has same shape as input `x`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32)</dt>
+<dd>The type of the input 'x'.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32), tensor(float8e8m0)</dt>
+<dd>The type of the input 'y_scale'.</dd>
+<dt><tt>T3</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1)</dt>
+<dd>The type of the input `y_zero_point` and the output `y`.</dd>
+</dl>
+
+### <a name="Reshape-24"></a>**Reshape-24**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). If 'allowzero' is set, and the new shape includes 0, the
+  dimension will be set explicitly to zero (i.e. not taken from input tensor).
+  Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+  If the attribute 'allowzero' is set, it is invalid for the specified shape to
+  contain both a zero value and -1, as the value of the dimension corresponding
+  to -1 cannot be determined uniquely.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>allowzero</tt> : int (default is 0)</dt>
+<dd>(Optional) By default, when any value in the 'shape' input is equal to zero the corresponding dimension value is copied from the input tensor dynamically. allowzero=1 indicates that if any value in the 'shape' input is set to zero, the zero value is honored, similar to NumPy.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Specified shape for output.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> (differentiable) : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Scan-24"></a>**Scan-24**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops).
+  Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+  well as scan_output_element tensors) are required to have the same shape in each iteration
+  of the loop (a restriction imposed to enable efficient memory allocation).
+
+  Note that the iterated element passed to the body subgraph does not have a sequence
+  axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The optional attribute scan_input_directions specifies the direction (forward or backward)
+  for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+  direction. A bidirectional scan may be performed by specifying the same tensor input twice
+  in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+  The scan_output of the operation is produced by concatenating the scan_output_element
+  values produced by the body in each iteration.  The optional attribute scan_output_directions
+  specifies the direction in which scan_output is constructed (by appending or prepending the
+  scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+  is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+  The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+  If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+  batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+  Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+  The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+  are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+  scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+  value of 1.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body,
+          scan_input_axes = [axis_1, ..., axis_m]
+      > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+      sequence_length = scan_1.shape[axis_1];
+
+      // initialize state-variables
+      st_1 = init_1; ... st_n = init_n;
+      // initialize scan-output variables: [] denotes an empty tensor
+      scan_out_1 = []; ...; scan_out_k = [];
+      // identify number of iterations:
+
+      // execute loop
+      for (int t = 0; t < sequence_length; ++t) {
+          // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+          // of rank one less than T obtained by indexing T at position t along axis k.
+          si_1 = scan_1<axis=axis_1>[t];
+          ... ;
+          si_m = scan_m<axis=axis_m>[t];
+          // execute loop-body
+          st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+          // accumulate the scan-output elements
+          scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+      }
+
+      return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+<dt><tt>scan_input_axes</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the axis to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will be used as the scan axis for every scan_input. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>scan_input_directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>scan_output_axes</tt> : list of ints</dt>
+<dd>An optional list of K flags. The i-th element of the list specifies the axis for the i-th scan_output. The scan outputs are accumulated along the specified axis. If omitted, 0 will be used as the scan axis for every scan_output. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1].</dd>
+<dt><tt>scan_output_directions</tt> : list of ints</dt>
+<dd>An optional list of K flags, one for each scan_output. The i-th element of the list specifies whether the i-th scan_output should be constructed by appending or prepending a new value in each iteration: 0 indicates appending and 1 indicates prepending. If omitted, all scan_output tensors will be produced by appending a value in each iteration.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>All Tensor types up to IRv12.</dd>
+</dl>
+
+### <a name="Shape-24"></a>**Shape-24**</a>
+
+  Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+  Optional attributes start and end can be used to compute a slice of the input tensor's shape.
+  If start axis is omitted, the slice starts from axis 0.
+  The end axis, if specified, is exclusive (and the returned value will not include the size of that axis).
+  If the end axis is omitted, the axes upto the last one will be included.
+  Negative axes indicate counting back from the last axis.
+  Note that axes will be clamped to the range [0, r], where r is the
+  rank of the input tensor if they are out-of-range (after adding r in the case of
+  negative axis). Thus, specifying any end value > r is equivalent to specifying an end
+  value of r, and specifying any start value < -r is equivalent to specifying a start
+  value of 0. If start > end, the result will be an empty shape.
+
+  Examples:
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  No attributes specified.
+  Output: [2, 3, 4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: -1
+  Output: [4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  end: -1
+  Output: [2, 3]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: 1
+  end: 2
+  Output: [3]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>end</tt> : int</dt>
+<dd>(Optional) Ending axis for slicing the shape. Negative value means counting dimensions from the back. If omitted, sizes of all axes upto (including) the last one will be included.</dd>
+<dt><tt>start</tt> : int (default is 0)</dt>
+<dd>(Optional) Starting axis for slicing the shape. Default value is 0.Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>shape</tt> (non-differentiable) : T1</dt>
+<dd>Shape of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor.</dd>
+</dl>
+
+### <a name="Size-24"></a>**Size-24**</a>
+
+  Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>Total number of elements of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor, which should be a scalar though.</dd>
+</dl>
+
+### <a name="SplitToSequence-24"></a>**SplitToSequence-24**</a>
+
+  Split a tensor into a sequence of tensors, along the specified 'axis'.
+  Lengths of the parts can be specified using the optional argument 'split'.
+  If the argument `split' is not specified, a default scalar value of 1
+  is used as the value of `split'.
+  'split' must contain only positive numbers.
+  'split' is either a scalar (tensor of empty shape), or a 1-D tensor.
+  If 'split' is a scalar, then 'input' will be split into chunks all of size 'split'
+  if possible. The last chunk alone may be smaller than 'split' if the 'input' size
+  along the given axis 'axis' is not divisible by 'split'.
+  If 'split' is a 1-dimensional tensor, the input tensor is split into 'size(split)' chunks,
+  with lengths of the parts on 'axis' specified in 'split'. In this scenario, the sum of entries
+  in 'split' must be equal to the dimension size of input tensor on 'axis'.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to split on. A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1].</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the split dimension or not. Default 1, which means we keep split dimension. If input 'split' is specified, this attribute is ignored.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The tensor to split</dd>
+<dt><tt>split</tt> (optional) : I</dt>
+<dd>Length of each output. It can be either a scalar(tensor of empty shape), or a 1-D tensor. All values must be >= 0. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_sequence</tt> : S</dt>
+<dd>One or more outputs forming a sequence of tensors after splitting</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input types to all tensor types.</dd>
+<dt><tt>I</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain split size to integral tensor.</dd>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output types to all tensor types.</dd>
+</dl>
+
+### <a name="Squeeze-24"></a>**Squeeze-24**</a>
+
+  Remove single-dimensional entries from the shape of a tensor.
+  Takes an input `axes` with a list of axes to squeeze.
+  If `axes` is not provided, all the single dimensions will be removed from
+  the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensors with at least max(dims) dimensions.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>1D tensor of integers indicating the dimensions to squeeze. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>squeezed</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv12.</dd>
+</dl>
+
+### <a name="Swish-24"></a>**Swish-24**</a>
+
+  Swish function takes one input data (Tensor<T>) and produces one output data (Tensor<T>) of the same shape,
+  where $Swish(x) = x * sigmoid(alpha * x)$.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Coefficient to multiply with input before sigmoid.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(bfloat16), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="TensorScatter-24"></a>**TensorScatter-24**</a>
+
+  TensorScatter is a generic tensor update operation, motivated by the requirements for KV cache updates for Attention
+  ops commonly found in LLMs. It is a functional operation that models an in-place update to a KV cache buffer.
+
+  The past and present cache tensors have the same shape (batch_size, D1, D2, ..., max_sequence_length, ..., Dn), with
+  the sequence dimension (indicated by the `axis` attribute) being max_sequence_length, so the sizes of these tensors do
+  not need to grow between iterations. The `update` tensor's shape only differs from the cache tensors in the sequence
+  dimension: (batch_size, D1, D2, ..., sequence_length, ..., Dn), where sequence_length <= max_sequence_length.
+
+  The optional `write_indices` input indicates the write index for each sample in the batch, assumed to be zero
+  if not provided. When the `mode` attribute is set to "circular", the write index is modulo max_sequence_length.
+  The operation can be described using the following pseudocode:
+
+  ```
+  for prefix_idx in np.ndindex(past_cache.shape[:axis]):
+      batch_idx = prefix_idx[0]
+      for sequence_idx in range(sequence_length):
+          cache_idx = (*prefix_idx, write_indices[batch_idx] + sequence_idx)
+          if mode == "circular":
+              cache_idx = tuple(np.mod(np.asarray(cache_idx), max_sequence_length))
+          update_idx = (*prefix_idx, sequence_idx)
+          present_cache[cache_idx] = update[update_idx]
+  ```
+
+  During the prefill phase of attention, only the first two inputs are needed. During the decode phase, `write_indices`
+  is also needed so that the incoming key or value update can be appended after the last valid token for each sample
+  in the batch.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -2)</dt>
+<dd>Sequence dimension of the `past_cache` and `update` tensors. It cannot be 0 (the batch dimension). Default is -2.</dd>
+<dt><tt>mode</tt> : string (default is linear)</dt>
+<dd>Write mode of cache update. Supported modes include `linear` and `circular`. `linear` mode requires write_indices+sequence_length<=max_sequence_length. For `circular` mode, the updates happen in wrap-around fashion, ie, the update index is modulo `max_sequence_length`</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>past_cache</tt> (differentiable) : T</dt>
+<dd>Past state cache for key or value with shape `(batch_size, D1, D2, ..., max_sequence_length, ..., Dn)`.</dd>
+<dt><tt>update</tt> (differentiable) : T</dt>
+<dd>New update tensor with shape `(batch_size, D1, D2, ..., sequence_length, ..., Dn)`.</dd>
+<dt><tt>write_indices</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Write indices for the incoming update tensor in the cache. Shape is `(batch_size,)`. Assumed to be all zeros if not provided.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>present_cache</tt> (differentiable) : T</dt>
+<dd>Updated cache. Same shape as `past_cache`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+### <a name="TopK-24"></a>**TopK-24**</a>
+
+  Retrieve the top-K largest or smallest elements along a specified axis. Given an input tensor of
+  shape [a_0, a_1, ..., a_{n-1}] and integer argument k, return two outputs:
+
+  * Value tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}]
+    which contains the values of the top k elements along the specified axis
+  * Index tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] which
+    contains the indices of the top k elements (original indices from the input
+    tensor).
+
+  * If "largest" is 1 (the default value) then the k largest elements are returned.
+  * If "sorted" is 1 (the default value) then the resulting k elements will be sorted.
+  * If "sorted" is 0, order of returned 'Values' and 'Indices' are undefined.
+
+  Given two equivalent values, this operator uses the indices along the axis as
+  a tiebreaker. That is, the element with the lower index will appear first.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>Dimension on which to do the sort. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>largest</tt> : int (default is 1)</dt>
+<dd>Whether to return the top-K largest or smallest elements.</dd>
+<dt><tt>sorted</tt> : int (default is 1)</dt>
+<dd>Whether to return the elements in sorted order.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{n-1}]</dd>
+<dt><tt>K</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D tensor containing a single positive value corresponding to the number of top elements to retrieve</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Values</tt> (differentiable) : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing top K values from the input tensor</dd>
+<dt><tt>Indices</tt> (non-differentiable) : I</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing the corresponding input tensor indices for the top K values.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+### <a name="Transpose-24"></a>**Transpose-24**</a>
+
+  Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+  The optional attribute `perm` must be a permutation of the dimensions of
+  the input tensor. Axis `i` of the output tensor corresponds to the axis
+  `perm[i]` of the input tensor.
+  For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 1, 3).
+  When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 3, 1).
+  If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+  where `n` is the rank of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>perm</tt> : list of ints</dt>
+<dd>A list of integers. By default, reverse the dimensions, otherwise permute the axes according to the values given. Its length must be equal to the rank of the input.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>transposed</tt> (differentiable) : T</dt>
+<dd>Transposed output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Unsqueeze-24"></a>**Unsqueeze-24**</a>
+
+  Insert single-dimensional entries to the shape of an input tensor (`data`).
+  Takes one required input `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).
+
+  For example, given an input tensor (`data`) of shape [3, 4, 5], then
+  Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].
+
+  The input `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
+  The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
+  Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
+  The order of values in `axes` does not matter and can come in any order.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Original tensor</dd>
+<dt><tt>axes</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>1D tensor of integers indicating the dimensions to be inserted. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(expanded).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>expanded</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv12.</dd>
+</dl>
+
+## Version 25 of the default ONNX operator set
+### <a name="Cast-25"></a>**Cast-25**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+
+  Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+  (e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+  yield result 100. There are some string literals reserved for special floating-point values;
+  "+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+  Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+  this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+  to string tensors, plain floating-point representation (such as "314.15926") would be used.
+  Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+  of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+  Conversion from a numerical type to any numerical type is always allowed.
+  User must be aware of precision loss and value change caused by range difference between two types.
+  For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+  an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+  In more detail, the conversion among numerical types should follow these rules
+  if the destination type is not a float 8 type.
+
+  * Casting from floating point to:
+    * floating point: +/- infinity if OOR (out of range).
+    * fixed point: undefined if OOR.
+    * bool: +/- 0.0 to False; all else to True.
+  * Casting from fixed point to:
+    * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+    * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+      signed types). For example, 200 (int16) -> -56 (int8).
+    * bool: zero to False; nonzero to True.
+  * Casting from bool to:
+    * floating point: `{1.0, 0.0}`.
+    * fixed point: `{1, 0}`.
+    * bool: no change.
+
+  Float 8 types (E4M3FN, E4M3FNUZ, E5M2, E5M2FNUZ) were introduced to speed up the training of
+  deep models. By default the conversion of a float *x* obeys
+  to the following rules. `[x]` means the value rounded to
+  the target mantissa width.
+
+  | x                 | E4M3FN   | E4M3FNUZ | E5M2     | E5M2FNUZ |
+  | ----------------- | -------- | -------- | -------- | -------- |
+  | 0                 | 0        | 0        | 0        | 0        |
+  | -0                | -0       | 0        | -0       | 0        |
+  | NaN               | NaN      | NaN      | NaN      | NaN      |
+  | Inf               | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+  | -Inf              | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+  | \[x\] > FLT_MAX   | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+  | \[x\] \< -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+  | else              | RNE      | RNE      | RNE      | RNE      |
+
+  The behavior changes if the parameter 'saturate' is set to False.
+  The rules then become:
+
+  | x                 | E4M3FN | E4M3FNUZ | E5M2 | E5M2FNUZ |
+  | ----------------- | ------ | -------- | ---- | -------- |
+  | 0                 | 0      | 0        | 0    | 0        |
+  | -0                | -0     | 0        | -0   | 0        |
+  | NaN               | NaN    | NaN      | NaN  | NaN      |
+  | -NaN              | -NaN   | NaN      | -NaN | NaN      |
+  | Inf               | NaN    | NaN      | Inf  | NaN      |
+  | -Inf              | -NaN   | NaN      | -Inf | NaN      |
+  | \[x\] > FLT_MAX   | NaN    | NaN      | Inf  | NaN      |
+  | \[x\] \< -FLT_MAX | NaN    | NaN      | -Inf | NaN      |
+  | else              | RNE    | RNE      | RNE  | RNE      |
+
+  FLOAT8E8M0 type was introduced to enable [Microscaling (MX) formats](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf).
+  When casting to FLOAT8E8M0, the rounding behavior can be specified using the `round_mode` and `saturate` attributes.
+  The current CUDA behavior is to round up and saturate. Casting negative values to FLOAT8E8M0 gives undefined behavior.
+  The following table describes the casting behavior of special values to FLOAT8E8M0 in the two most common cases.
+
+  | x                 | saturate + up | non-saturate + nearest |
+  | ----------------- | ------------- | ---------------------  |
+  | 0                 | 0             | NaN                    |
+  | -0                | Unspecified   | Unspecified            |
+  | NaN               | NaN           | NaN                    |
+  | Inf               | E8M0_MAX      | NaN                    |
+  | x > E8M0_MAX      | E8M0_MAX      | NaN                    |
+  | x < E8M0_MIN      | E8M0_MIN      | NaN                    |
+  | x < 0             | Unspecified   | Unspecified            |
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>round_mode</tt> : string (default is up)</dt>
+<dd>Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. `up`: round to nearest value away from zero, `down`: round to nearest value towards zero, `nearest`: round to nearest value and ties round up.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. All cases are fully described in the tables inserted in the operator description.</dd>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="CastLike-25"></a>**CastLike-25**</a>
+
+  The operator casts the elements of a given input tensor (the first input) to
+  the same data type as the elements of the second input tensor.
+  See documentation of the Cast operator for further details.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>round_mode</tt> : string (default is up)</dt>
+<dd>Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. `up`: round to nearest value away from zero, `down`: round to nearest value towards zero, `nearest`: round to nearest value and ties round up. Please refer to operator Cast description for further details.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. Please refer to operator Cast description for further details.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+<dt><tt>target_type</tt> (non-differentiable) : T2</dt>
+<dd>The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor produced by casting the first input tensor to have the same type as the second input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+### <a name="Constant-25"></a>**Constant-25**</a>
+
+  This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+  or value_* must be specified.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>sparse_value</tt> : sparse_tensor</dt>
+<dd>The value for the elements of the output tensor in sparse format.</dd>
+<dt><tt>value</tt> : tensor</dt>
+<dd>The value for the elements of the output tensor.</dd>
+<dt><tt>value_float</tt> : float</dt>
+<dd>The value for the sole element for the scalar, float32, output tensor.</dd>
+<dt><tt>value_floats</tt> : list of floats</dt>
+<dd>The values for the elements for the 1D, float32, output tensor.</dd>
+<dt><tt>value_int</tt> : int</dt>
+<dd>The value for the sole element for the scalar, int64, output tensor.</dd>
+<dt><tt>value_ints</tt> : list of ints</dt>
+<dd>The values for the elements for the 1D, int64, output tensor.</dd>
+<dt><tt>value_string</tt> : string</dt>
+<dd>The value for the sole element for the scalar, UTF-8 string, output tensor.</dd>
+<dt><tt>value_strings</tt> : list of strings</dt>
+<dd>The values for the elements for the 1D, UTF-8 string, output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="ConstantOfShape-25"></a>**ConstantOfShape-25**</a>
+
+  Generate a tensor with given value and shape.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>value</tt> : tensor</dt>
+<dd>(Optional) The value of the output elements.Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar. All values must be >= 0.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of shape specified by 'input'.If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'.If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype defaults to float32.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain input types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint4), tensor(int4), tensor(bool), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain output types to be numerics or boolean.</dd>
+</dl>
+
+### <a name="DequantizeLinear-25"></a>**DequantizeLinear-25**</a>
+
+  The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the
+  full-precision tensor. The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point`
+  must have the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
+  a 1-D tensor for per-axis quantization, or have a rank identical to the input for blocked quantization.
+  See QuantizeLinear for details on quantization granularity.
+
+  `x_zero_point` and `x` must have the same type. `x` and `y` must have the same shape. In the case of dequantizing
+  `int32`, there's no zero point (zero point is supposed to be 0).
+  `zero-point` is usually not used in the case of float8 and 4-bit types quantization, but the dequantization formula remains the same
+  for consistency. The output type is determined by the attribute `output_dtype`. If `output_dtype` is not supplied then the output type
+  is the same as `x_scale`. The output type also determines the precision of the multiplication operation.
+
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+<dt><tt>output_dtype</tt> : int (default is 0)</dt>
+<dd>(Optional) The output data type. If not supplied, the output data type is inferred from `x_scale` data type (`T2`)</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D quantized input tensor to be de-quantized.</dd>
+<dt><tt>x_scale</tt> : T2</dt>
+<dd>Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>x_zero_point</tt> (optional) : T1</dt>
+<dd>Zero point for input `x`. Shape must match x_scale. It's optional. Zero point is 0 when it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>N-D full precision output tensor. It has the same shape as input `x`. The data type is specified by the `output_dtype` attribute or, in its absence, the type of `x_scale`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(int32), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(uint2), tensor(int2)</dt>
+<dd>The type of the inputs 'x_zero_point' and 'x'.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(float8e8m0)</dt>
+<dd>The type of the input 'x_scale'.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>The type of the output 'y'.</dd>
+</dl>
+
+### <a name="Flatten-25"></a>**Flatten-25**</a>
+
+  Flattens the input tensor into a 2D matrix. If input tensor has shape
+  (d_0, d_1, ... d_n) then the output will have shape
+  (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Indicate up to which input dimensions (exclusive) should be flattened to the outer dimension of the output. The value for axis must be in the range [-r, r], where r is the rank of the input tensor. Negative value means counting dimensions from the back. When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), where the shape of the input tensor is (d_0, d_1, ... d_n). </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>A tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>A 2D tensor with the contents of the input tensor, with input dimensions up to axis flattened to the outer dimension of the output and remaining input dimensions flattened into the inner dimension of the output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output to all tensor types up to IRv13.</dd>
+</dl>
+
+### <a name="Identity-25"></a>**Identity-25**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : V</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : V</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain input and output types to all tensor, sequence, and optional types.</dd>
+</dl>
+
+### <a name="If-25"></a>**If-25**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same data type. The `then_branch` and `else_branch` may produce tensors with the same element type and different shapes. If corresponding outputs from the then-branch and the else-branch have static shapes S1 and S2, then the shape of the corresponding output variable of the if-node (if present) must be compatible with both S1 and S2 as it represents the union of both possible shapes.For example, if in a model file, the first output of `then_branch` is typed float tensor with shape [2] and the first output of `else_branch` is another float tensor with shape [3], If's first output should have (a) no shape set, or (b) a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) a shape of rank 1 with a unique `dim_param`. In contrast, the first output cannot have the shape [2] since [2] and [3] are not compatible.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), seq(tensor(float4e2m1)), seq(tensor(float8e8m0)), seq(tensor(uint2)), seq(tensor(int2)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4)), optional(tensor(float4e2m1)), optional(tensor(float8e8m0)), optional(tensor(uint2)), optional(tensor(int2))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv13.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+### <a name="Loop-25"></a>**Loop-25**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+  * input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+  * input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+  * input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]           // iteration number
+        %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+        %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+      ) {
+        %my_local = Add(%a, %b_in)
+        %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+        %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+        %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+        return %keepgoing_out, %b_out, %user_defined_val
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        /* initialize loop-carried variables and scan-output variables */
+        bool keepgoing_out = keepgoing
+        int b_out = b
+
+        for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+          /* Implicitly-defined code: bind actual parameter values
+             to formal parameter variables of loop-body */
+          bool keepgoing_in = keepgoing_out;
+          bool b_in = b_out;
+
+          /* User-defined code (loop body) */
+          int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+          b_out = a - b_in;
+          keepgoing_out = my_local > b_out;
+          user_defined_val = b_in + b_in; // b_in and b_out are different variables
+          /* End user-defined code */
+
+          /* Implicitly defined-code */
+          user_defined_vals[i] = user_defined_val // accumulate scan-output values
+        }
+        // int t = my_local; // Can't do this. my_local is not accessible here.
+
+        // The values below are bound to the output variables of the loop and therefore accessible
+        // b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any values computed in the loop body that needs to be used in a subsequent
+     iteration or after the loop are modeled using a pair of variables in the loop-body,
+     consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+     These are referred to as loop-carried dependences. The loop operation node
+     supplies the input value of the input variable for the first iteration, and
+     returns the output value of the output variable produced by the final
+     iteration.
+  3) Scan_output variables are used to implicitly concatenate values computed across
+     all the iterations. In the above example, the value of user_defined_val computed
+     over all iterations are concatenated and returned as the value of user_defined_vals
+     after the loop.
+  4) Values created in the body cannot be accessed in the enclosing scope,
+     except using the mechanism described above.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+  The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs. Scan outputs must be Tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), seq(tensor(float4e2m1)), seq(tensor(float8e8m0)), seq(tensor(uint2)), seq(tensor(int2)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4)), optional(tensor(float4e2m1)), optional(tensor(float8e8m0)), optional(tensor(uint2)), optional(tensor(int2))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv13.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+### <a name="Pad-25"></a>**Pad-25**</a>
+
+  Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+  a padded tensor (`output`) is generated.
+
+  The four supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+  1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+  2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+  3) `edge` - pads with the edge values of array
+
+  4) `wrap` - wrap-around padding as if the data tensor forms a torus
+
+
+  Example 1 (`constant` mode):
+
+  Insert 0 pads to the beginning of the second dimension.
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'constant'
+
+  constant_value = 0.0
+
+  output = [
+      [0.0, 0.0, 1.0, 1.2],
+      [0.0, 0.0, 2.3, 3.4],
+      [0.0, 0.0, 4.5, 5.7],
+  ]
+  ```
+
+  Example 2 (`reflect` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'reflect'
+
+  output = [
+      [1.0, 1.2, 1.0, 1.2],
+      [2.3, 3.4, 2.3, 3.4],
+      [4.5, 5.7, 4.5, 5.7],
+  ]
+  ```
+
+  Example 3 (`edge` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'edge'
+
+  output = [
+      [1.0, 1.0, 1.0, 1.2],
+      [2.3, 2.3, 2.3, 3.4],
+      [4.5, 4.5, 4.5, 5.7],
+  ]
+  ```
+
+  Example 4 (`wrap` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [2, 1, 1, 1]
+
+  mode = 'wrap'
+
+  output = [
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Supported modes: `constant`(default), `reflect`, `edge`, `wrap`</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Input tensor.</dd>
+<dt><tt>pads</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. `pads` should be a 1D tensor of shape [2 * num_axes] where `num_axes` refers to the number of elements in the `axes` input or the input rank if `axes` are not provided explicitly. `pads` format should be: [x1_begin, x2_begin, ..., x1_end, x2_end,...], where xi_begin is the number of pad values added at the beginning of axis `axes[i]` and xi_end, the number of pad values added at the end of axis `axes[i]`.</dd>
+<dt><tt>constant_value</tt> (optional, non-differentiable) : T</dt>
+<dd>(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, empty string or False).</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of axes that `pads` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated. If not provided, all axes are assumed (`[0, 1, ..., input_rank-1]`).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv13.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+### <a name="QuantizeLinear-25"></a>**QuantizeLinear-25**</a>
+
+  The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
+  low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
+  granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
+
+  Saturation is done according to:
+  - uint16: [0, 65535]
+  - int16: [-32768, 32767]
+  - uint8: [0, 255]
+  - int8: [-128, 127]
+  - uint4: [0, 15]
+  - int4: [-8, 7]
+  - uint2: [0, 3]
+  - int2: [-2, 1]
+
+  For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+
+  `y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 and 4bit types, but the quantization
+  formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+  `x` and `y_scale` are allowed to have different types. The type of `y_scale` determines the precision of the division operation between `x` and
+  `y_scale`, unless the `precision` attribute is specified.
+
+  There are three supported quantization granularities, determined by the shape of `y_scale`.
+  In all cases, `y_zero_point` must have the same shape as `y_scale`.
+  - Per-tensor (per-layer) quantization: `y_scale` is a scalar.
+  - Per-axis quantization: The scale must be a 1-D tensor, with the length of the quantization axis. For an input shape
+   `(D0, ..., Di, ..., Dn)` and `axis=i`, `y_scale` is a 1-D tensor of length `Di`.
+  - Blocked quantization: The scale's shape is identical to the input's shape, except for one dimension, in which
+    blocking is performed. Given `x` shape `(D0, ..., Di, ..., Dn)`, `axis=i`, and block size `B`: `y_scale` shape is
+    `(D0, ..., ceil(Di/B), ..., Dn)`.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, rendering the axis unnecessary in this scenario.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+<dt><tt>output_dtype</tt> : int (default is 0)</dt>
+<dd>(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T3`). If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T3`.</dd>
+<dt><tt>precision</tt> : int (default is 0)</dt>
+<dd>(Optional) The precision of the division operation between `x` and `y_scale`. If not provided, it will be the same as the type of `y_scale`.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 quantization (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. All cases are fully described in two tables inserted in the operator description.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D full precision Input tensor to be quantized.</dd>
+<dt><tt>y_scale</tt> : T2</dt>
+<dd>Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>y_zero_point</tt> (optional) : T3</dt>
+<dd>Zero point for doing quantization to get `y`. Shape must match `y_scale`. Default is uint8 with zero point of 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>N-D quantized output tensor. It has same shape as input `x`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32)</dt>
+<dd>The type of the input 'x'.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32), tensor(float8e8m0)</dt>
+<dd>The type of the input 'y_scale'.</dd>
+<dt><tt>T3</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(uint2), tensor(int2)</dt>
+<dd>The type of the input `y_zero_point` and the output `y`.</dd>
+</dl>
+
+### <a name="Reshape-25"></a>**Reshape-25**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). If 'allowzero' is set, and the new shape includes 0, the
+  dimension will be set explicitly to zero (i.e. not taken from input tensor).
+  Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+  If the attribute 'allowzero' is set, it is invalid for the specified shape to
+  contain both a zero value and -1, as the value of the dimension corresponding
+  to -1 cannot be determined uniquely.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>allowzero</tt> : int (default is 0)</dt>
+<dd>(Optional) By default, when any value in the 'shape' input is equal to zero the corresponding dimension value is copied from the input tensor dynamically. allowzero=1 indicates that if any value in the 'shape' input is set to zero, the zero value is honored, similar to NumPy.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Specified shape for output.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> (differentiable) : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Scan-25"></a>**Scan-25**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops).
+  Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+  well as scan_output_element tensors) are required to have the same shape in each iteration
+  of the loop (a restriction imposed to enable efficient memory allocation).
+
+  Note that the iterated element passed to the body subgraph does not have a sequence
+  axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The optional attribute scan_input_directions specifies the direction (forward or backward)
+  for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+  direction. A bidirectional scan may be performed by specifying the same tensor input twice
+  in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+  The scan_output of the operation is produced by concatenating the scan_output_element
+  values produced by the body in each iteration.  The optional attribute scan_output_directions
+  specifies the direction in which scan_output is constructed (by appending or prepending the
+  scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+  is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+  The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+  If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+  batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+  Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+  The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+  are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+  scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+  value of 1.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body,
+          scan_input_axes = [axis_1, ..., axis_m]
+      > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+      sequence_length = scan_1.shape[axis_1];
+
+      // initialize state-variables
+      st_1 = init_1; ... st_n = init_n;
+      // initialize scan-output variables: [] denotes an empty tensor
+      scan_out_1 = []; ...; scan_out_k = [];
+      // identify number of iterations:
+
+      // execute loop
+      for (int t = 0; t < sequence_length; ++t) {
+          // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+          // of rank one less than T obtained by indexing T at position t along axis k.
+          si_1 = scan_1<axis=axis_1>[t];
+          ... ;
+          si_m = scan_m<axis=axis_m>[t];
+          // execute loop-body
+          st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+          // accumulate the scan-output elements
+          scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+      }
+
+      return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+<dt><tt>scan_input_axes</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the axis to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will be used as the scan axis for every scan_input. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>scan_input_directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>scan_output_axes</tt> : list of ints</dt>
+<dd>An optional list of K flags. The i-th element of the list specifies the axis for the i-th scan_output. The scan outputs are accumulated along the specified axis. If omitted, 0 will be used as the scan axis for every scan_output. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1].</dd>
+<dt><tt>scan_output_directions</tt> : list of ints</dt>
+<dd>An optional list of K flags, one for each scan_output. The i-th element of the list specifies whether the i-th scan_output should be constructed by appending or prepending a new value in each iteration: 0 indicates appending and 1 indicates prepending. If omitted, all scan_output tensors will be produced by appending a value in each iteration.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>All Tensor types up to IRv13.</dd>
+</dl>
+
+### <a name="Shape-25"></a>**Shape-25**</a>
+
+  Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+  Optional attributes start and end can be used to compute a slice of the input tensor's shape.
+  If start axis is omitted, the slice starts from axis 0.
+  The end axis, if specified, is exclusive (and the returned value will not include the size of that axis).
+  If the end axis is omitted, the axes upto the last one will be included.
+  Negative axes indicate counting back from the last axis.
+  Note that axes will be clamped to the range [0, r], where r is the
+  rank of the input tensor if they are out-of-range (after adding r in the case of
+  negative axis). Thus, specifying any end value > r is equivalent to specifying an end
+  value of r, and specifying any start value < -r is equivalent to specifying a start
+  value of 0. If start > end, the result will be an empty shape.
+
+  Examples:
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  No attributes specified.
+  Output: [2, 3, 4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: -1
+  Output: [4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  end: -1
+  Output: [2, 3]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: 1
+  end: 2
+  Output: [3]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>end</tt> : int</dt>
+<dd>(Optional) Ending axis for slicing the shape. Negative value means counting dimensions from the back. If omitted, sizes of all axes upto (including) the last one will be included.</dd>
+<dt><tt>start</tt> : int (default is 0)</dt>
+<dd>(Optional) Starting axis for slicing the shape. Default value is 0.Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>shape</tt> (non-differentiable) : T1</dt>
+<dd>Shape of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor.</dd>
+</dl>
+
+### <a name="Size-25"></a>**Size-25**</a>
+
+  Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>Total number of elements of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor, which should be a scalar though.</dd>
+</dl>
+
+### <a name="Squeeze-25"></a>**Squeeze-25**</a>
+
+  Remove single-dimensional entries from the shape of a tensor.
+  Takes an input `axes` with a list of axes to squeeze.
+  If `axes` is not provided, all the single dimensions will be removed from
+  the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensors with at least max(dims) dimensions.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>1D tensor of integers indicating the dimensions to squeeze. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>squeezed</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv13.</dd>
+</dl>
+
+### <a name="Transpose-25"></a>**Transpose-25**</a>
+
+  Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+  The optional attribute `perm` must be a permutation of the dimensions of
+  the input tensor. Axis `i` of the output tensor corresponds to the axis
+  `perm[i]` of the input tensor.
+  For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 1, 3).
+  When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 3, 1).
+  If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+  where `n` is the rank of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>perm</tt> : list of ints</dt>
+<dd>A list of integers. By default, reverse the dimensions, otherwise permute the axes according to the values given. Its length must be equal to the rank of the input.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>transposed</tt> (differentiable) : T</dt>
+<dd>Transposed output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+### <a name="Unsqueeze-25"></a>**Unsqueeze-25**</a>
+
+  Insert single-dimensional entries to the shape of an input tensor (`data`).
+  Takes one required input `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).
+
+  For example, given an input tensor (`data`) of shape [3, 4, 5], then
+  Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].
+
+  The input `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
+  The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
+  Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
+  The order of values in `axes` does not matter and can come in any order.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Original tensor</dd>
+<dt><tt>axes</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>1D tensor of integers indicating the dimensions to be inserted. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(expanded).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>expanded</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv13.</dd>
+</dl>
+
+## Version 26 of the default ONNX operator set
+### <a name="BitCast-26"></a>**BitCast-26**</a>
+
+  Reinterprets the binary representation of a tensor as a different data type,
+  specified by the 'to' attribute. Unlike Cast, BitCast preserves the exact bit
+  pattern without any value conversion.
+
+  The target data type must have the same bit-width as the input data type.
+  The output tensor has the same shape as the input tensor.
+  All types except string are supported. Implementations must treat the
+  underlying bytes as little endian.
+
+#### Version
+
+This version of the operator has been available since version 26 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the input tensor is bitwise reinterpreted. Must be one of the non-string types from DataType enum in TensorProto. The target type must have the same bit-width as the input type.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (non-differentiable) : T1</dt>
+<dd>Input tensor to be bitcast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T2</dt>
+<dd>Output tensor with the same shape as the input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input types. Bitcasting from string is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain output types. Bitcasting to string is not supported.</dd>
+</dl>
+
+### <a name="CumProd-26"></a>**CumProd-26**</a>
+
+  Performs cumulative product of the input elements along the given axis.
+  By default, it will do the product inclusively meaning the first element is copied as is.
+  Through an `exclusive` attribute, this behavior can change to exclude the first element.
+  It can also perform product in the opposite direction of the axis. For that, set `reverse` attribute to 1.
+
+  Example:
+  ```
+  input_x = [1, 2, 3]
+  axis=0
+  output = [1, 2, 6]
+  exclusive=1
+  output = [1, 1, 2]
+  exclusive=0
+  reverse=1
+  output = [6, 6, 3]
+  exclusive=1
+  reverse=1
+  output = [6, 3, 1]
+  ```
+
+
+#### Version
+
+This version of the operator has been available since version 26 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>exclusive</tt> : int (default is 0)</dt>
+<dd>If set to 1 will return exclusive product in which the top element is not included. In other terms, if set to 1, the j-th output element would be the product of the first (j-1) elements. Otherwise, it would be the product of the first j elements.</dd>
+<dt><tt>reverse</tt> : int (default is 0)</dt>
+<dd>If set to 1 will perform the products in reverse direction.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>x</tt> (differentiable) : T</dt>
+<dd>An input tensor that is to be processed.</dd>
+<dt><tt>axis</tt> (non-differentiable) : T2</dt>
+<dd>A 0-D tensor. Must be in the range [-rank(x), rank(x)-1]. Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> (differentiable) : T</dt>
+<dd>Output tensor of the same type as 'x' with cumulative products of the x's elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>axis tensor can be int32 or int64 only</dd>
+</dl>
+
+## Version 27 of the default ONNX operator set
+### <a name="CausalConvWithState-27"></a>**CausalConvWithState-27**</a>
+
+  Stateful causal 1D depthwise convolution.
+
+  Used by Gated DeltaNet (Qwen3.5) and Mamba (Jamba, FalconMamba) as a preprocessing step.
+  Replaces the 3-op pattern (Concat + Conv + Slice) with a single fused operation.
+
+  The convolution is causal (looks only at current and past positions) and depthwise
+  (each channel is convolved independently with its own kernel).
+
+  The input, weight, past_state, output, and present_state tensors are rank-3 with
+  shape (batch_size, channels, length). The optional bias input is rank-1 with
+  shape (channels). For higher-dimensional data, use Reshape nodes before and
+  after this operator to pack extra dimensions into the batch or channel axis.
+
+  Weight layout: (channels, 1, k) for depthwise convolution.
+  The carry state stores the last (k-1) positions for incremental decode.
+
+  The optional activation attribute supports fused SiLU/Swish activation.
+
+
+#### Version
+
+This version of the operator has been available since version 27 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation</tt> : string (default is none)</dt>
+<dd>Fused activation function. One of: 'silu', 'swish', 'none'. Default is 'none'.</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor with shape (batch_size, channels, length). Channels-first layout.</dd>
+<dt><tt>weight</tt> (differentiable) : T</dt>
+<dd>Depthwise convolution kernel with shape (channels, 1, k) where k is the kernel size. The middle dim of size 1 follows the ONNX `Conv` weight layout `(M, C/group, k1, ..., kn)`: since this op is always depthwise, `group = channels`, so `C/group = 1`. Keeping this layout makes the weight tensor a drop-in for a depthwise `Conv(group=channels)` weight, so `Conv` <-> `CausalConvWithState` rewrites require no reshape.</dd>
+<dt><tt>bias</tt> (optional, differentiable) : T</dt>
+<dd>Optional per-channel bias with shape (channels).</dd>
+<dt><tt>past_state</tt> (optional, non-differentiable) : T</dt>
+<dd>Carry state from previous step with shape (batch_size, channels, k - 1). If not provided, padding is zero.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Convolution output with same shape as input.</dd>
+<dt><tt>present_state</tt> (non-differentiable) : T</dt>
+<dd>Updated carry state with shape (batch_size, channels, k - 1). Contains the last (k - 1) values of the effective padded/concatenated sequence along the causal axis, including any values from past_state or zero-padding when the current input is shorter than k - 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="LinearAttention-27"></a>**LinearAttention-27**</a>
+
+  Unified linear attention operator for autoregressive decoding (T=1) and prefill (T>1).
+
+  The query, key, value, and (where applicable) decay/beta inputs use 3D packed format
+  [B, T, H*D], where heads are flattened into the last dimension; q_num_heads and
+  kv_num_heads are always required and are used to unpack to 4D internally for computation.
+  The optional past_state and present_state are 4D with shape (B, H_kv, d_k, d_v).
+
+  Group-query attention (GQA) is supported: q_num_heads must be a positive multiple of
+  kv_num_heads. When q_num_heads == kv_num_heads this reduces to multi-headed linear
+  attention; when q_num_heads > kv_num_heads each KV head (and its recurrent state) is
+  shared by `q_num_heads / kv_num_heads` query heads (multi-query attention is the
+  special case kv_num_heads == 1).
+
+  The update_rule attribute selects the recurrence type:
+  - "linear": S_t = S_{t-1} + k_t ⊗ v_t; o_t = scale * q_t^T S_t
+  - "gated": S_t = exp(g_t) * S_{t-1} + k_t ⊗ v_t; o_t = scale * q_t^T S_t
+  - "delta": S_t = S_{t-1} + β_t * k_t ⊗ (v_t - S_{t-1}^T k_t); o_t = scale * q_t^T S_t
+  - "gated_delta": S_t = exp(g_t) * S_{t-1} + β_t * k_t ⊗ (v_t - exp(g_t) * S_{t-1}^T k_t); o_t = scale * q_t^T S_t
+
+  where g_t is the decay (in log-space), β_t is the update rate, and ⊗ denotes outer product.
+
+  Semantics: Equivalent to running the recurrent update sequentially for each token,
+  but may be implemented using chunk-parallel algorithms for GPU efficiency.
+
+
+#### Version
+
+This version of the operator has been available since version 27 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>chunk_size</tt> : int (default is 64)</dt>
+<dd>Chunk size for the chunk-parallel WY decomposition during prefill (T>1). Tuning hint; does not affect output correctness.</dd>
+<dt><tt>kv_num_heads</tt> : int (required)</dt>
+<dd>Number of key/value heads. Always required.</dd>
+<dt><tt>q_num_heads</tt> : int (required)</dt>
+<dd>Number of query heads. Always required.</dd>
+<dt><tt>scale</tt> : float (default is 0.0)</dt>
+<dd>Output scaling factor. When 0.0 (default), derives d_k = query.shape[-1] / q_num_heads and uses 1/sqrt(d_k). Set explicitly to override.</dd>
+<dt><tt>update_rule</tt> : string (default is gated_delta)</dt>
+<dd>The update rule for the linear attention recurrence. One of: 'linear', 'gated', 'delta', 'gated_delta'. Default is 'gated_delta'.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>query</tt> (differentiable) : T</dt>
+<dd>Query vectors with 3D packed shape (B, T, H_q * d_k). Heads are packed into the last dimension.</dd>
+<dt><tt>key</tt> (differentiable) : T</dt>
+<dd>Key vectors with 3D packed shape (B, T, H_kv * d_k). Should be L2-normalized for delta/gated_delta modes.</dd>
+<dt><tt>value</tt> (differentiable) : T</dt>
+<dd>Value vectors with 3D packed shape (B, T, H_kv * d_v).</dd>
+<dt><tt>past_state</tt> (optional, non-differentiable) : S</dt>
+<dd>Recurrent state from previous step with shape (B, H_kv, d_k, d_v). Always 4D. If not provided, defaults to zeros.</dd>
+<dt><tt>decay</tt> (optional, differentiable) : T</dt>
+<dd>Exponential decay gate in log-space. 3D packed shape: (B, T, H_kv * d_k) for per-key-dimension decay (GLA/RWKV-6), or (B, T, H_kv) for per-head scalar decay (DeltaNet/RetNet). Required for 'gated' and 'gated_delta' modes.</dd>
+<dt><tt>beta</tt> (optional, differentiable) : T</dt>
+<dd>Update rate (sigmoid output). 3D packed shape: (B, T, H_kv) or (B, T, 1). Required for 'delta' and 'gated_delta' modes.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Attention output with 3D packed shape (B, T, H_q * d_v).</dd>
+<dt><tt>present_state</tt> (non-differentiable) : S</dt>
+<dd>Updated recurrent state with shape (B, H_kv, d_k, d_v). Always 4D.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(bfloat16), tensor(float)</dt>
+<dd>Constrain activation input and output types to float16, bfloat16, or float32 tensors.</dd>
+<dt><tt>S</tt> : tensor(float16), tensor(bfloat16), tensor(float)</dt>
+<dd>Constrain state types to float16, bfloat16, or float32 tensors. Should be float32 or the same as T for numerical stability on long sequences.</dd>
+</dl>
+
+### <a name="Range-27"></a>**Range-27**</a>
+
+  Generate a tensor containing a sequence of numbers that begin at `start` and extends by increments of `delta`
+  up to `limit` (exclusive).
+
+  The number of elements in the output of range is computed as below:
+  ```
+  number_of_elements = max( ceil( (limit - start) / delta ) , 0 )
+  ```
+  The pseudocode determining the contents of the output is shown below:
+  ```
+  for(int i=0; i<number_of_elements; ++i) {
+    output[i] =  start + (i * delta);
+  }
+  ```
+  Example 1:
+  ```
+  Inputs: start = 3, limit = 9, delta = 3
+  Output: [3, 6]
+  ```
+  Example 2:
+  ```
+  Inputs: start = 10, limit = 4, delta = -2
+  Output: [10, 8, 6]
+  ```
+
+  For `float16` and `bfloat16` inputs, the `stash_type` attribute controls the precision used for
+  intermediate accumulation. Setting `stash_type` to `1` (float) causes `start`, `limit`, and
+  `delta` to be cast to 32-bit float before the loop, with the output cast back to the original
+  type. This avoids precision loss for large ranges where successive additions in float16 or
+  bfloat16 would otherwise be inexact (e.g. `x + 1 == x` for large `x`).
+
+#### Version
+
+This version of the operator has been available since version 27 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>stash_type</tt> : int (default is 1)</dt>
+<dd>The data type used for intermediate computation when T is float16 or bfloat16. Defaults to 1 (float). Has no effect for other types.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>start</tt> : T</dt>
+<dd>Scalar. First entry for the range of output values.</dd>
+<dt><tt>limit</tt> : T</dt>
+<dd>Scalar. Exclusive upper limit for the range of output values.</dd>
+<dt><tt>delta</tt> : T</dt>
+<dd>Scalar. Value to step by.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>A 1-D tensor with same type as the inputs containing generated range of values.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(bfloat16)</dt>
+<dd>Constrain input types to common numeric type tensors.</dd>
+</dl>
+
+## Version 28 of the default ONNX operator set
+### <a name="Celu-28"></a>**Celu-28**</a>
+
+  Continuously Differentiable Exponential Linear Units:
+  Perform the linear unit element-wise on the input tensor X
+  using formula:
+
+  ```
+  max(0,x) + min(0,alpha*(exp(x/alpha)-1))
+  ```
+
+#### Version
+
+This version of the operator has been available since version 28 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>The Alpha value in Celu formula which control the shape of the unit. The default value is 1.0.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+# ai.onnx.preview
+## Version 1 of the 'ai.onnx.preview' operator set
+### <a name="ai.onnx.preview.FlexAttention-1"></a>**ai.onnx.preview.FlexAttention-1**</a>
+
+  Computes scaled dot-product attention over rank-4 (batched, multi-head) inputs,
+  with optional user-provided customization subgraphs at two stages:
+
+  1. score_mod: Modify the attention score tensor after Q·K^T
+  2. prob_mod: Modify the probability tensor after Softmax
+
+  This operator mirrors the capabilities of PyTorch's flex_attention:
+  https://docs.pytorch.org/docs/stable/nn.attention.flex_attention.html
+
+  Input Shapes (MUST be rank-4 tensors):
+  - Q: `(batch_size, q_num_heads, q_sequence_length, head_size)`
+  - K: `(batch_size, kv_num_heads, kv_sequence_length, head_size)`
+  - V: `(batch_size, kv_num_heads, kv_sequence_length, v_head_size)`
+
+  Output Shape:
+  - Y: `(batch_size, q_num_heads, q_sequence_length, v_head_size)`
+
+  FlexAttention Computation:
+  ```
+  Scores = (Q @ K^T) * scale
+  Scores = score_mod(Scores)             # if 'score_mod' is provided
+  Probs = Softmax(Scores, axis=-1)
+  Probs = prob_mod(Probs)                # if 'prob_mod' is provided
+  Y = Probs @ V
+  ```
+
+  Grouped Query Attention (GQA):
+  When `q_num_heads != kv_num_heads`, each K/V head is shared by a contiguous
+  group of query heads in head-index order. Let
+  `group_size = q_num_heads / kv_num_heads`; then query head `h` uses K/V head
+  `floor(h / group_size)`. `q_num_heads` must be a multiple of
+  `kv_num_heads`.
+
+  Modifier Subgraphs (score_mod, prob_mod):
+  Each modifier subgraph takes exactly one rank-4 tensor input and must produce
+  exactly one rank-4 tensor output of the same shape and element type.
+  - score_mod input/output shape: `(batch_size, q_num_heads, q_sequence_length, kv_sequence_length)`
+  - prob_mod  input/output shape: `(batch_size, q_num_heads, q_sequence_length, kv_sequence_length)`
+  The element type is determined by softmax_precision (defaults to float32 for
+  non-double inputs, otherwise double).
+
+  Masking can be expressed in score_mod by writing masked positions as -inf (or a
+  large negative value appropriate for the target precision).
+
+#### Version
+
+No versioning maintained for experimental ops.
+#### Attributes
+
+<dl>
+<dt><tt>prob_mod</tt> : graph</dt>
+<dd>Optional probability modifier subgraph with 1 rank-4 tensor input and 1 rank-4 tensor output of the same shape and element type: (probs) -> probs_out. probs has softmax_precision element type and shape (B, Hq, L, S). The output must preserve the input shape.</dd>
+<dt><tt>scale</tt> : float</dt>
+<dd>Scaling factor for Q*K^T. Defaults to 1/sqrt(head_size).</dd>
+<dt><tt>score_mod</tt> : graph</dt>
+<dd>Optional score modifier subgraph with 1 rank-4 tensor input and 1 rank-4 tensor output of the same shape and element type: (scores) -> scores_out. scores has softmax_precision element type and shape (B, Hq, L, S). The output must preserve the input shape.</dd>
+<dt><tt>softmax_precision</tt> : int</dt>
+<dd>Floating-point precision for softmax computation. Defaults to float32 for non-double inputs, otherwise uses double. Must be explicitly specified for non-float types.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>Q</tt> : T1</dt>
+<dd>Query tensor with shape `(batch_size, q_num_heads, q_seq_len, head_size)`.</dd>
+<dt><tt>K</tt> : T1</dt>
+<dd>Key tensor with shape `(batch_size, kv_num_heads, kv_seq_len, head_size)`.</dd>
+<dt><tt>V</tt> : T1</dt>
+<dd>Value tensor with shape `(batch_size, kv_num_heads, kv_seq_len, v_head_size)`.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>Output tensor with shape `(batch_size, q_num_heads, q_seq_len, v_head_size)`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain Q, K, V to float tensors.</dd>
+</dl>
+
+# ai.onnx.preview.training
+## Version 1 of the 'ai.onnx.preview.training' operator set
+### <a name="ai.onnx.preview.training.Adagrad-1"></a>**ai.onnx.preview.training.Adagrad-1**</a>
+
+  Compute one iteration of ADAGRAD, a stochastic gradient based optimization
+      algorithm. This operator can conduct the optimization of multiple tensor variables.
+
+      Let's define the behavior of this operator. As you can imagine, ADAGRAD requires
+      some parameters:
+
+       - The initial learning-rate "R".
+       - The update count "T". That is, the number of training iterations conducted.
+       - A L2-norm regularization coefficient "norm_coefficient".
+       - A learning-rate decay factor "decay_factor".
+       - A small constant "epsilon" to avoid dividing-by-zero.
+
+      At each ADAGRAD iteration, the optimized tensors are moved along a direction
+      computed based on their estimated gradient and accumulated squared gradient. Assume
+      that only a single tensor "X" is updated by this operator. We need the value of "X",
+      its gradient "G", and its accumulated squared gradient "H". Therefore, variables in
+      this operator's input list are sequentially "R", "T", "X", "G", and "H". Other
+      parameters are given as attributes because they are usually constants. Also, the
+      corresponding output tensors are the new value of "X" (called "X_new"), and then
+      the new accumulated squared gradient (called "H_new"). Those outputs are computed
+      from the given inputs following the pseudo code below.
+
+      Let "+", "-", "*", and "/" are all element-wise arithmetic operations with
+      numpy-style broadcasting support. The pseudo code to compute those outputs is:
+
+        // Compute a scalar learning-rate factor. At the first update of X, T is generally
+        // 0 (0-based update index) or 1 (1-based update index).
+        r = R / (1 + T * decay_factor);
+
+        // Add gradient of 0.5 * norm_coefficient * ||X||_2^2, where ||X||_2 is the 2-norm.
+        G_regularized = norm_coefficient * X + G;
+
+        // Compute new accumulated squared gradient.
+        H_new = H + G_regularized * G_regularized;
+
+        // Compute the adaptive part of per-coordinate learning rate. Note that Sqrt(...)
+        // computes element-wise square-root.
+        H_adaptive = Sqrt(H_new) + epsilon
+
+        // Compute the new value of "X".
+        X_new = X - r * G_regularized / H_adaptive;
+
+      If one assign this operators to optimize multiple inputs, for example, "X_1" and "X_2", the same
+      pseudo code may be extended to handle all tensors jointly. More specifically, we can view "X" as a
+      concatenation of "X_1" and "X_2" (of course, their gradient and accumulate gradient should
+      be concatenated too) and then just reuse the entire pseudo code.
+
+      Note that ADAGRAD was first proposed in http://jmlr.org/papers/volume12/duchi11a/duchi11a.pdf.
+      In that reference paper, this operator is a special case of the Figure 1's composite mirror
+      descent update.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.preview.training' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>decay_factor</tt> : float (default is 0.0)</dt>
+<dd>The decay factor of learning rate after one update.The effective learning rate is computed by r = R / (1 + T * decay_factor). Default to 0 so that increasing update counts doesn't reduce the learning rate.</dd>
+<dt><tt>epsilon</tt> : float (default is 0.0)</dt>
+<dd>Small scalar to avoid dividing by zero.</dd>
+<dt><tt>norm_coefficient</tt> : float (default is 0.0)</dt>
+<dd>Regularization coefficient in 0.5 * norm_coefficient * ||X||_2^2. Default to 0, which means no regularization.</dd>
+</dl>
+
+#### Inputs (3 - &#8734;)
+
+<dl>
+<dt><tt>R</tt> : T1</dt>
+<dd>The initial learning rate.</dd>
+<dt><tt>T</tt> : T2</dt>
+<dd>The update count of "X". It should be a scalar.</dd>
+<dt><tt>inputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>The current values of optimized tensors, followed by their respective gradients, followed by their respective accumulated squared gradients.For example, if two tensor "X_1" and "X_2" are optimized, The input list would be ["X_1", "X_2", gradient of "X_1", gradient of "X_2", accumulated squared gradient of "X_1", accumulated squared gradient of "X_2"].</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>Updated values of optimized tensors, followed by their updated values of accumulated squared gradients. For example, if two tensor "X_1" and "X_2" are optimized, the output list would be [new value of "X_1," new value of "X_2" new accumulated squared gradient of "X_1", new accumulated squared gradient of "X_2"].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float scalars.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain input types to 64-bit integer scalars.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="ai.onnx.preview.training.Adam-1"></a>**ai.onnx.preview.training.Adam-1**</a>
+
+  Compute one iteration of Adam, a stochastic gradient based optimization
+      algorithm. This operator can conduct the optimization of multiple tensor variables.
+
+      Let's define the behavior of this operator. First of all, Adam requires
+      some parameters:
+
+       - The learning-rate "R".
+       - The update count "T". That is, the number of training iterations conducted.
+       - A L2-norm regularization coefficient "norm_coefficient".
+       - A small constant "epsilon" to avoid dividing-by-zero.
+       - Two coefficients, "alpha" and "beta".
+
+      At each Adam iteration, the optimized tensors are moved along a direction
+      computed based on their exponentially-averaged historical gradient and
+      exponentially-averaged historical squared gradient. Assume that only a tensor
+      "X" is being optimized. The rest of required information is
+
+       - the value of "X",
+       - "X"'s gradient (denoted by "G"),
+       - "X"'s exponentially-averaged historical gradient (denoted by "V"), and
+       - "X"'s exponentially-averaged historical squared gradient (denoted by "H").
+
+      Some of those parameters are passed into this operator as input tensors and others
+      are stored as this operator's attributes. Specifically, this operator's input tensor
+      list is ["R", "T", "X", "G", "V", "H"]. That is, "R" is the first input, "T" is
+      the second input, and so on. Other parameters are given as attributes because they
+      are constants. Moreover, the corresponding output tensors are
+
+       - the new value of "X" (called "X_new"),
+       - the new exponentially-averaged historical gradient (denoted by "V_new"), and
+       - the new exponentially-averaged historical squared gradient (denoted by "H_new").
+
+      Those outputs are computed following the pseudo code below.
+
+      Let "+", "-", "*", and "/" are all element-wise arithmetic operations with
+      numpy-style broadcasting support. The pseudo code to compute those outputs is:
+
+        // Add gradient of 0.5 * norm_coefficient * ||X||_2^2, where ||X||_2 is the 2-norm.
+        G_regularized = norm_coefficient * X + G
+
+        // Update exponentially-averaged historical gradient.
+        V_new = alpha * V + (1 - alpha) * G_regularized
+
+        // Update exponentially-averaged historical squared gradient.
+        H_new = beta * H + (1 - beta) * G_regularized * G_regularized
+
+        // Compute the element-wise square-root of H_new. V_new will be element-wisely
+        // divided by H_sqrt for a better update direction.
+        H_sqrt = Sqrt(H_new) + epsilon
+
+        // Compute learning-rate. Note that "alpha**T"/"beta**T" is alpha's/beta's T-th power.
+        R_adjusted = T > 0 ? R * Sqrt(1 - beta**T) / (1 - alpha**T) : R
+
+        // Compute new value of "X".
+        X_new = X - R_adjusted * V_new / H_sqrt
+
+        // Post-update regularization.
+        X_final = (1 - norm_coefficient_post) * X_new
+
+      If there are multiple inputs to be optimized, the pseudo code will be applied
+      independently to each of them.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.preview.training' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.9)</dt>
+<dd>Coefficient of previously accumulated gradient in running average. Default to 0.9.</dd>
+<dt><tt>beta</tt> : float (default is 0.999)</dt>
+<dd>Coefficient of previously accumulated squared-gradient in running average. Default to 0.999.</dd>
+<dt><tt>epsilon</tt> : float (default is 0.0)</dt>
+<dd>Small scalar to avoid dividing by zero.</dd>
+<dt><tt>norm_coefficient</tt> : float (default is 0.0)</dt>
+<dd>Regularization coefficient of 0.5 * norm_coefficient * ||X||_2^2. Default to 0, which means no regularization.</dd>
+<dt><tt>norm_coefficient_post</tt> : float (default is 0.0)</dt>
+<dd>Regularization coefficient of 0.5 * norm_coefficient * ||X||_2^2. Default to 0, which means no regularization.</dd>
+</dl>
+
+#### Inputs (3 - &#8734;)
+
+<dl>
+<dt><tt>R</tt> : T1</dt>
+<dd>The initial learning rate.</dd>
+<dt><tt>T</tt> : T2</dt>
+<dd>The update count of "X". It should be a scalar.</dd>
+<dt><tt>inputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>The tensors to be optimized, followed by their respective gradients, followed by their respective accumulated gradients (aka momentum), followed by their respective accumulated squared gradients. For example, to optimize tensors "X_1" and "X_2,", the input list would be ["X_1", "X_2", gradient of "X_1", gradient of "X_2", accumulated gradient of "X_1", accumulated gradient of "X_2", accumulated squared gradient of "X_1", accumulated squared gradient of "X_2"].</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>New values of optimized tensors, followed by their respective new accumulated gradients, followed by their respective new accumulated squared gradients. For example, if two tensors "X_1" and "X_2" are optimized, the outputs list would be [new value of "X_1", new value of "X_2", new accumulated gradient of "X_1", new accumulated gradient of "X_2", new accumulated squared gradient of "X_1", new accumulated squared gradient of "X_2"].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float scalars.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain input types to 64-bit integer scalars.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+### <a name="ai.onnx.preview.training.Gradient-1"></a>**ai.onnx.preview.training.Gradient-1**</a>
+
+  Gradient operator computes the partial derivatives of a specific tensor w.r.t.
+  some other tensors. This operator is widely used in gradient-based training
+  algorithms. To illustrate its use, let's consider a computation graph,
+
+  ```
+  X -----.
+         |
+         v
+  W --> Conv --> H --> Gemm --> Y
+                        ^
+                        |
+                        Z
+  ```
+
+  , where W and Z are trainable tensors. Note that operators' attributes are
+  omitted for the sake of simplicity. Let dY/dW (dY/dZ) be the gradient of
+  Y with respect to W (Z). The user can compute gradient by inserting Gradient
+  operator to form another graph shown below.
+
+  ```
+  W --> Conv --> H --> Gemm --> Y
+  |      ^              ^
+  |      |              |
+  |      X              Z
+  |      |              |
+  |      |   .----------'
+  |      |   |  (W/Z/X is the 1st/2nd/3rd input of Gradient as shown in
+  |      |   |   "xs" followed by "zs")
+  |      v   v
+  '---> Gradient(xs=["W", "Z"], zs=["X"], y="Y")
+         |   |
+         |   '-----------------------------------> dY/dW (1st output of Gradient)
+         |
+         '---------------------------------------> dY/dZ (2nd output of Gradient)
+  ```
+
+  By definition, the tensor "y" is a function of independent variables in "xs"
+  and "zs". Since we only compute the gradient of "y" w.r.t. the differentiable
+  variables in "xs", this Gradient only outputs dY/dW and dY/dZ. Note that "H"
+  cannot appear in "xs" and "zs". The reason is that "H" can be determined by
+  tensors "W" and "X" and therefore "H" is not an independent variable.
+
+  All outputs are optional. If needed, for example, user can assign an empty
+  string to the 1st output name of that Gradient to skip the generation of dY/dW.
+  Note that the concept of optional outputs can also be found in ONNX's RNN, GRU,
+  and LSTM.
+
+  Gradient operator can compute derivative against intermediate tensors. For
+  example, the gradient of Y with respect to H can be done via
+
+  ```
+  W --> Conv --> H --> Gemm --> Y
+         ^       |      ^
+         |       |      |
+         X       |      Z
+         .-------'      |
+         |   .----------'
+         |   | (H/Z is the 1st/2nd input of Gradient as shown in "xs")
+         v   v
+        Gradient(xs=["H", "Z"], y="Y")
+         |   |
+         |   '-----------------------------------> dY/dH (1st output of Gradient)
+         |
+         '---------------------------------------> dY/dZ (2nd output of Gradient)
+  ```
+
+  It is possible to represent high-order differentiation using Gradient operators.
+  For example, given the following linear model:
+
+  ```
+  W --> Gemm --> Y --> Loss --> O
+         ^              ^
+         |              |
+         X              L
+  ```
+
+  To compute the 2nd order derivative of O with respect to W (denoted by
+  d^2O/dW^2), one can do
+
+  ```
+  W --> Gemm --> Y --> Loss --> O
+  |      ^              ^
+  |      |              |
+  |      X .------------L
+  |      | |            |
+  |      | |            v
+  +------+-+> Gradient(xs=["X", "W"], zs=["L"], y="O") ---> dO/dX (1st output of Gradient)
+  |      | |    |
+  |      | |    '---> dO/dW (2nd output of Gradient)
+  |      v v
+  '---> Gradient(xs=["X", "W"], zs=["L"], y="dO/dW") ---> d(dO/dW)dX (1st output of
+         |                                                  Gradient)
+         |
+         |
+         '---> d^2O/dW^2 (2nd output of Gradient)
+  ```
+
+  The tensors named in attributes "xs", "zs", and "y" define the differentiated
+  computation graph, and the inputs to Gradient node define the values at
+  which the gradient is computed. We can feed different tensors to the identified
+  graph. For example, one can compute the gradient of Y with respect to H at
+  a specific value of H, H_1, by providing that value as an input to the Gradient
+  node.
+
+  ```
+  W --> Conv --> H --> Gemm --> Y
+         ^              ^
+         |              |
+         X              Z
+
+            Z_1 (2nd input of Gradient)
+             |
+             v
+  H_1 --> Gradient(xs=["H", "Z"], y="Y") ---> dY/dH when H = H_1 and Y = Y_1.
+             |
+             '------------------------------> dY/dZ (2nd output of Gradient)
+  ```
+
+  When the inputs of Gradient are the tensors named in "xs" and "zs", the
+  computation can be optimized. More specifically, intermediate variables in
+  forward pass can be reused if the gradient is computed via reverse-mode
+  auto-differentiation.
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.preview.training' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>xs</tt> : list of strings (required)</dt>
+<dd>Input tensor names of the differentiated sub-graph. It contains only the necessary differentiated inputs of a (sub-)graph. Variables (usually called intermediate variables) that can be generated from inputs cannot be included in this attribute.</dd>
+<dt><tt>y</tt> : string (required)</dt>
+<dd>The targeted tensor. It can be viewed as the output of the differentiated function. The attribute "xs" and attribute "zs" are the minimal independent variable set that determines the value of "y".</dd>
+<dt><tt>zs</tt> : list of strings</dt>
+<dd>Input tensor names of the differentiated sub-graph. It contains only the necessary non-differentiated inputs of a (sub-)graph. Variables (usually called intermediate variables) that can be generated from inputs cannot be included in this attribute.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>Inputs</tt> (variadic, heterogeneous) : T1</dt>
+<dd>The values fed into graph identified by the attributes. The i-th input is the value of the i-th tensor specified in the concatenated list of the attribute "xs" and the attribute  "zs". For example, if xs=["A", "B"] and zs=["C"], the first input is used as the value of symbol "A" and the 3rd input is substituted for all the occurrences of "C".</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>Outputs</tt> (variadic, heterogeneous) : T2</dt>
+<dd>The gradient of the tensor specified by the attribute "y" with respect to each of tensors specified in the attribute "xs". The i-th output is the gradient of "y" with respect to the i-th tensor specified in the attribute "xs".</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Allow outputs to be any kind of tensor.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Allow inputs to be any kind of floating-point tensor.</dd>
+</dl>
+
+### <a name="ai.onnx.preview.training.Momentum-1"></a>**ai.onnx.preview.training.Momentum-1**</a>
+
+  Compute one iteration of stochastic gradient update with momentum.
+      This operator can conduct the optimization of multiple tensor variables.
+
+      Let's define the behavior of this operator. As you can imagine, SG with momentum requires
+      several parameters:
+
+       - The learning-rate "R".
+       - The update count "T". That is, the number of conducted training iterations. It should
+         be zero in the first training iteration.
+       - A L2-norm regularization coefficient "norm_coefficient".
+       - A decay coefficient of previous accumulated gradient (i.e., momentum) "alpha".
+       - The scaling coefficient of current gradient "beta".
+       - An attribute to choose either standard momentum or Nesterov's momentum "mode" should
+         be used.
+
+      For the sake of simplicity, assume that there is only one tensor (called "X") to be optimized.
+      Other necessary inputs are "X"'s gradient (called "G") and "X"'s momentum (called "V"). This
+      Momentum operator maps all these inputs to the new value of "X" (called "X_new") and its new
+      momentum (called "V_new").
+
+      This operator supports two different momentum algorithms. Set the attribute "mode" to
+      "nesterov" if Nesterov's momentum is desired. Otherwise, set the attribute "model" to
+      "standard" to use standard momentum. Computation details are described subsequently.
+
+      Let "+", "-", "*", and "/" are all element-wise operations with numpy-style broadcasting.
+
+      Pseudo code for SG with standard momentum:
+
+        // Add gradient of 0.5 * norm_coefficient * ||X||^2, where ||X|| is the sum of squared
+        // values of all elements in X.
+        G_regularized = norm_coefficient * X + G
+
+        // In the first training iteration, beta should always be 1.
+        beta_adjusted = T > 0 ? beta : 1
+
+        // Compute the current momentum based on previous momentum and the current gradient.
+        V_new = alpha * V + beta_adjusted * G_regularized
+
+        // Update X.
+        X_new = X - R * V_new
+
+      Pseudo code for SG with Nesterov's momentum:
+
+        // Add gradient of 0.5 * norm_coefficient * ||X||^2, where ||X|| is the sum of squared
+        // values of all elements in X.
+        G_regularized = norm_coefficient * X + G;
+
+        // In the first training iteration, beta should always be 1.
+        beta_adjusted = T > 0 ? beta : 1
+
+        // Compute the current momentum based on previous momentum and the current gradient.
+        V_new = alpha * V + beta_adjusted * G_regularized;
+
+        // Compute final update direction and then update X.
+        X_new = X - R * (G_regularized + alpha * V_new)
+
+      If one assign this operators to optimize multiple inputs, for example, "X_1" and "X_2". The same
+      pseudo code would be extended to handle all tensors jointly. More specifically, we can view "X" as a
+      concatenation of "X_1" and "X_2" (of course, their gradient and accumulate gradient should
+      be concatenated too) and then our pseudo code becomes applicable.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.preview.training' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (required)</dt>
+<dd>The decay factor of momentum. It should be a scalar.</dd>
+<dt><tt>beta</tt> : float (required)</dt>
+<dd>The coefficient of gradient in computing new momentum. It should be a scalar.</dd>
+<dt><tt>mode</tt> : string (required)</dt>
+<dd>Its value should be either "nesterov" or "standard". The value "nesterov" leads to the use of Nesterov's momentum while "standard" invokes stochastic gradient method using standard momentum</dd>
+<dt><tt>norm_coefficient</tt> : float (required)</dt>
+<dd>Coefficient of 0.5 * norm_coefficient * ||X||^2.</dd>
+</dl>
+
+#### Inputs (3 - &#8734;)
+
+<dl>
+<dt><tt>R</tt> : T1</dt>
+<dd>The learning rate.</dd>
+<dt><tt>T</tt> : T2</dt>
+<dd>Update count of "X". It should be a scalar.</dd>
+<dt><tt>inputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>It sequentially contains the current values of optimized tensors, then their gradient tensors, and finally their momentum tensors. For example, if two tensors "X_1" and "X_2" are optimized, The expected input list would be ["X_1", "X_2", gradient of "X_1", gradient of "X_2", momentum of "X_1", momentum of "X_2"].</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>It sequentially contains the new values of optimized tensors and then the new values of their momentum tensors. For example, if two tensors "X_1" and "X_2" are optimized, the output list would be [new value of "X_1," new value of "X_2" new momentum of "X_1", new momentum of "X_2"].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float scalars.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain input types to 64-bit integer scalars.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+</dl>
+
diff --git a/docs/DefineDifferentiability.md b/docs/DefineDifferentiability.md
new file mode 100644
index 0000000..1128f7d
--- /dev/null
+++ b/docs/DefineDifferentiability.md
@@ -0,0 +1,126 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# A Short Guide on the Differentiability Tag for ONNX Operators
+
+## Differentiability Tag
+
+The ONNX operator schema for each operator includes a differentiability tag for each input and output.
+In this document, we explain the meaning of this tag and how to ensure the correctness of the tags.
+Briefly, the tag identifies the set of differentiable inputs and differentiable outputs of an operator.
+The meaning of the tag is that the partial derivative of each differentiable output is defined with respect to each differentiable output.
+
+## Ways to Define Differentiability Tag
+
+The differentiability definition of an operator consists of several aspects.
+
+- Differentiable inputs, which can be referenced in Gradient's `xs` attribute.
+- Differentiable outputs, which can be referenced in Gradient's `y` attribute.
+- The math equation to compute the Jacobian matrix (or tensor). If a variable (input or output) is differentiable or not is judged by math. If the Jacobian matrix (or tensor) exists, then the considered operator has some differentiable inputs and outputs.
+
+There are several strategies to implement auto-differentiation such as forward accumulation, backward accumulation, and dual variable.
+Because most deep learning frameworks are backward-based, the reviewers should ensure the PR authors of tags provide enough details on that.
+We present a couple of methods below to verify the differentiability for ONNX operator.
+
+### Method 1: Reuse Existing Deep Learning Frameworks
+
+The first way is to show that the considered operator's backward operation exists in an existing framework such as Pytorch or Tensorflow. In this case, the author should provide a runnable python script which computes the backward pass of the considered operator. The author should also point out how to map the Pytorch or Tensor code to ONNX format (for example, the author can call `torch.onnx.export` to save an ONNX model). The following script shows the differentiability of ONNX Reshape using  Pytorch.
+
+```python
+import torch
+import torch.nn as nn
+
+# A single-operator model. It's literally a Pytorch Reshape.
+# Note that Pytorch Reshape can be directly mapped to ONNX Reshape.
+class MyModel(nn.Module):
+  def __init__(self):
+    super(MyModel, self).__init__()
+
+  def forward(self, x):
+    y = torch.reshape(x, (x.numel(),))
+    y.retain_grad()
+    return y
+
+model = MyModel()
+
+x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
+y = model(x)
+dy = torch.tensor([1., 2., 3., 4.])
+
+torch.autograd.backward([y],
+  grad_tensors=[dy],
+  retain_graph=True,
+  create_graph=True,
+  grad_variables=None)
+
+# This example shows the input and the output in Pytorch are differentiable.
+# From the exported ONNX model below, we also see that "x" is the first input
+# of ONNX Reshape and "y" the output of ONNX Reshape. Therefore, we can say
+# the first input and the output of ONNX Reshape are differentiable.
+print(x.grad)
+print(y.grad)
+
+with open('model.onnx', 'wb') as f:
+  torch.onnx.export(model, x, f)
+```
+
+### Method 2: Manually Do the Math
+
+The second way is formally proving the existence of the Jacobian matrix (or tensor) from outputs to inputs with at least two numerical examples. In this case, the reviewer should go through the math and confirm if the numerical result is correct. The author should add enough details so that any STEM graduated student can easily review it.
+
+For example, to show the differentiability of Add, the author may first write down its equation:
+
+```
+C = A + B
+```
+
+For the sake of simplicity, assume `A` and `B` are same-shape vector.
+
+```
+A = [a1, a2]^T
+B = [b1, b2]^T
+C = [c1, c2]^T
+```
+
+Here we use the symbol `^T` to denote transpose of the attached matrix or vector.
+Let `X = [a1, a2, b1, b2]^T` and `Y = [c1, c2]^T` and consider Add as a function which maps `X` to `Y`.
+Then, this function's Jacobian matrix is a 4-by-2 matrix,
+
+```
+J = [[dc1/da1, dc2/da1],
+     [dc1/da2, dc2/da2],
+     [dc1/db1, dc2/db1],
+     [dc1/db2, dc2/db2]]
+  = [[1, 0],
+     [0, 1],
+     [1, 0],
+     [0, 1]]
+```
+
+If
+
+```
+dL/dC = [dL/dc1, dL/dc2]^T,
+```
+
+then `dL/dA = [dL/da1, dL/da2]^T` and `dL/dB = [dL/db1, dL/db2]^T` can be computed from elements in
+
+```
+  [[dL/da1], [dL/da2], [dL/db1], [dL/db2]]
+= J * dL/dC
+= [[dL/dc1], [dL/dc2], [dL/dc1], [dL/dc2]]
+```
+
+where `*` is standard matrix multiplication.
+If `dL/dC = [0.2, 0.8]^T`, then `dL/dA = [0.2, 0.8]^T` and `dL/dB = [0.2, 0.8]^T`.
+Notice that the procedure to compute `dL/dA` and `dL/dB` from `dL/dC` is usually called backward of an operator.
+We can see backward operator of Add takes `dL/dC` as an input and produces two outputs `dL/dA` and `dL/dB`.
+Consequently, all of `A`, `B`, and `C` are differentiable.
+By flattening tensor into 1-D vector, this example can be extended to cover all tensors when shape broadcasting is not needed.
+If broadcasting happens, the broadcasted element's gradient is the sum of all associated elements' gradient in its **non-broadcasting** case.
+Let's consider the above example again.
+If `B = [b]^T` becomes an 1-element vector, `B` may be broadcasted to `[b1, b2]^T` and `dL/dB = [dL/ db]^T = [dL/db1 + dL/db2]^T`.
+For high-dimensional tensors, this is in fact a ReduceSum operation along all expanded axes.
diff --git a/docs/DimensionDenotation.md b/docs/DimensionDenotation.md
new file mode 100644
index 0000000..26edc2b
--- /dev/null
+++ b/docs/DimensionDenotation.md
@@ -0,0 +1,56 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Dimension Denotation
+
+Dimension Denotation is an experimental attempt to give tensor axis semantic descriptions and thus types and perform verification steps based on them subsequently.
+
+## Motivation
+
+The motivation of such a mechanism can be illustrated via a simple example. In the linear neural network specification below, we assume a NCHW model input:
+
+```
+input_in_NCHW -> Transpose(input, perm=[0, 2, 1, 3]) -> AveragePool(input, ...)
+```
+
+In this neural network, a user mistakenly constructed a neural network that transposes an NCHW input to a weird NHCW format and pass through spatial pooling that assumes a NCHW input format. As clearly a mistake as it is, no existing infrastructure will report an error to the user. This is should be deeply unnerving to programmers who rely heavily on type checking as an integral part of program correctness guarantee. This proposal seeks to resolve this vacuum of proper type-checking inherent in the current paradigm of neural network specification.
+
+This proposal consists of three key components: Denotation Definition, Denotation Propagation and Denotation Verification, each of which will be discussed in detail.
+
+## Denotation Definition
+
+To begin with, we define a set of types for tensor types. Such types are defined based on the following principles:
+
+1. Be fine grain enough to eliminate potential pitfalls. For instance, the above example illustrated in the motivation section mandates that we distinguish between a channel dimension and a spatial feature dimension to ensure the correctness of execution of the AveragePool op.
+2. Be coarse grain enough to alleviate the mental burden of users. For instance, in the above example, there is significantly less need to distinguish between a width dimension and a height dimension because operations like pooling and convolution often do not draw a distinction between various spatial dimensions. Thus, we summarize all the spatial dimensions as feature dimensions.
+3. As an important corollary of 2, be model agnostic. For instance, the semantics of feature dimensions in recurrent neural networks (RNN) and the semantics of spatial dimensions in convolutional neural network (CNN) are almost indistinguishable and therefore we permit users and developers to describe either as a feature dimension.
+
+Specifically, in our first proposal, we define the following set of standard denotations:
+
+1. `DATA_BATCH` describes a batch dimension of the training data. This corresponds to the `N` dimension in the more commonly used tensor format notation `NCHW`.
+2. `DATA_CHANNEL` describes a channel dimension of the training data. This corresponds to the `C` dimension.
+3. `DATA_TIME` describes a time dimension.
+4. `DATA_FEATURE` describes a feature dimension. This corresponds to the `H`, `W` dimension or the feature dimension in RNN.
+5. `FILTER_IN_CHANNEL` describes a filter in-channel dimension. This is the dimension that is identical (in size) to the channel dimension of the input image feature maps.
+6. `FILTER_OUT_CHANNEL` describes a filter out-channel dimension. This is the dimension that is identical (in size) to the channel dimension of the output image feature maps.
+7. `FILTER_SPATIAL` describes a filter spatial dimension.
+
+## Denotation Propagation
+
+Denotation Propagation happens when an operation permutes, destroys or creates dimensions with respect to its input tensor. In such scenarios, we will implement customized, operation-specific functions to infer the output tensor dimension denotation based on the input tensor dimension denotation. An example operation where denotation propagation happens is Transpose operation where the pseudocode for output dimension denotation inference can be formulated as a function of the input dimension denotation:
+
+```
+for i, j in enumerate(perm):
+    out_dim_denotaion[i] = in_dim_denotation[j]
+```
+
+## Denotation Verification
+
+Denotation Verification happens when an operation expects its input to arrive in a particular format. An example operation where denotation verification happens is AveragePool operation where the input, if annotated with dimension denotation, in the 2D case should have the denotation [`DATA_BATCH`, `DATA_CHANNEL`, `DATA_FEATURE`, `DATA_FEATURE`]. If there is a mismatch between the expected dimension denotation and the actual dimension denotation, an error should be reported.
+
+## Type Denotation
+
+See the [type denotation documentation](TypeDenotation.md) for more details on how to describe images and other types.
diff --git a/docs/ExternalData.md b/docs/ExternalData.md
new file mode 100644
index 0000000..156ac82
--- /dev/null
+++ b/docs/ExternalData.md
@@ -0,0 +1,101 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# External Data
+
+## Loading an ONNX Model with External Data
+
+* [Default] If the external data is under the same directory of the model, simply use `onnx.load()`
+
+```python
+import onnx
+
+onnx_model = onnx.load("path/to/the/model.onnx")
+```
+
+* If the external data is under another directory, use `load_external_data_for_model()` to specify the directory path and load after using `onnx.load()`
+
+```python
+import onnx
+from onnx.external_data_helper import load_external_data_for_model
+
+onnx_model = onnx.load("path/to/the/model.onnx", load_external_data=False)
+load_external_data_for_model(onnx_model, "data/directory/path/")
+# Then the onnx_model has loaded the external data from the specific directory
+```
+
+## Converting an ONNX Model to External Data
+
+```python
+import onnx
+from onnx.external_data_helper import convert_model_to_external_data
+
+onnx_model = ... # Your model in memory as ModelProto
+convert_model_to_external_data(onnx_model, all_tensors_to_one_file=True, location="filename", size_threshold=1024, convert_attribute=False)
+# Must be followed by save_model to save the converted model to a specific path
+onnx.save_model(onnx_model, "path/to/save/the/model.onnx")
+# Then the onnx_model has converted raw data as external data and saved to specific directory
+```
+
+## Converting and Saving an ONNX Model to External Data
+
+```python
+import onnx
+
+onnx_model = ... # Your model in memory as ModelProto
+onnx.save_model(onnx_model, "path/to/save/the/model.onnx", save_as_external_data=True, all_tensors_to_one_file=True, location="filename", size_threshold=1024, convert_attribute=False)
+# Then the onnx_model has converted raw data as external data and saved to specific directory
+```
+
+## onnx.checker for Models with External Data
+
+### Models with External Data (<2GB)
+
+Current checker supports checking models with external data. Specify either loaded onnx model or model path to the checker.
+
+### Large models >2GB
+
+However, for those models larger than 2GB, please use the model path for onnx.checker and the external data needs to be under the same directory.
+
+```python
+import onnx
+
+onnx.checker.check_model("path/to/the/model.onnx")
+# onnx.checker.check_model(loaded_onnx_model) will fail if given >2GB model
+```
+
+## TensorProto: data_location and external_data fields
+
+There are two fields related to the external data in TensorProto message type.
+
+### data_location field
+
+`data_location` field stores the location of data for this tensor. Value MUST be one of:
+
+* `DEFAULT` - data stored inside the protobuf message. Data is stored in raw_data (if set) otherwise in type-specific field.
+* `EXTERNAL` - data stored in an external location as described by external_data field.
+
+If not set, behaves as if the value was `DEFAULT`.
+
+### external_data field
+
+`external_data` field stores key-value pairs of strings describing data location
+
+Recognized keys are:
+
+* `"location"` (required) - file path relative to the filesystem directory where the ONNX protobuf model was stored. Up-directory path components such as .. are disallowed and should be stripped when parsing.
+* `"offset"` (optional) - position of byte at which stored data begins. Integer stored as string. Offset values SHOULD be multiples of the page size (usually 4kb) to enable mmap support. On Windows, offset values SHOULD be multiples of the VirtualAlloc [allocation granularity](https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info) (usually 64kb) to enable [memory mapping](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-mapviewoffile).
+* `"length"` (optional) - number of bytes containing data. Integer stored as string.
+* `"checksum"` (optional) - SHA1 digest of file specified in under 'location' key.
+
+After an ONNX file is loaded, all `external_data` fields may be updated with an additional key `("basepath")`, which stores the path to the directory from which he ONNX model file was loaded.
+
+### External data files
+
+Data stored in external data files will be in the same binary bytes string format as is used by the `raw_data` field in current ONNX implementations.
+
+Reference
+https://github.com/onnx/onnx/pull/678
diff --git a/docs/ExternalDataSecurity.md b/docs/ExternalDataSecurity.md
new file mode 100644
index 0000000..1d11456
--- /dev/null
+++ b/docs/ExternalDataSecurity.md
@@ -0,0 +1,163 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# External Data Security
+
+This document describes the security model for loading and saving external data files in ONNX models. It is intended for maintainers working on the external data code paths.
+
+## Threat Model
+
+When an ONNX model references external data files via relative paths, an attacker who controls the model file can attempt:
+
+- **Symlink traversal**: A final-component symlink in the external data path pointing to a sensitive file (e.g., `/etc/shadow`), causing ONNX to read or overwrite arbitrary files.
+- **Parent-directory symlink**: A symlink in a parent directory component of the external data path, bypassing a check that only inspects the final component.
+- **Hardlink attacks**: A hardlink to a sensitive file appearing as a normal file, bypassing symlink-only checks while still exposing unintended data.
+- **Path traversal**: Using `..` segments or absolute paths to escape the model directory.
+
+## Defense Layers
+
+We use a 4-layer defense-in-depth approach. Each entry point applies the layers appropriate to its context (see the table below).
+
+### Layer 1: Canonical Path Containment
+
+- **C++**: `std::filesystem::weakly_canonical()` resolves the path, then verifies it starts with the canonical base directory.
+
+This catches `..` traversal and symlinks in any path component (not just the final one).
+
+### Layer 2: Symlink Detection
+
+- **C++**: `std::filesystem::is_symlink(data_path)` rejects the final-component symlink.
+
+This is a belt-and-suspenders check alongside containment. It provides a clear, specific error message when the final path component is a symlink.
+
+### Layer 3: Secure File Open with Post-Open Verification
+
+Three platform-specific strategies, in order of preference:
+
+- **Linux 5.6+**: `openat2(RESOLVE_BENEATH | RESOLVE_NO_SYMLINKS)` — atomic kernel containment. No TOCTOU. Falls back on `ENOSYS`.
+- **FreeBSD 13+ / macOS 15+**: `openat(O_RESOLVE_BENEATH | O_NOFOLLOW)` — equivalent BSD-style containment.
+- **POSIX fallback**: `open(O_NOFOLLOW)` + post-open inode comparison (`fstat` fd vs `stat` canonical path).
+- **Windows**: `CreateFileW(FILE_FLAG_OPEN_REPARSE_POINT)` + reparse point attribute check + inode comparison. Converted to CRT fd via `_open_osfhandle()` before returning.
+
+All POSIX fds are opened with `O_CLOEXEC`. All platforms return a CRT file descriptor.
+
+Hardlinks are detected via `fstat()` link count (POSIX) or `GetFileInformationByHandle()` (Windows), always fail closed.
+
+### Layer 4: Pre-Open Hardlink Count Check
+
+- **C++**: `std::filesystem::hard_link_count(data_path) > 1` rejects files with multiple hardlinks before opening.
+
+This is defense-in-depth alongside Layer 3's post-open hardlink check. It provides a clear error message at the path level before any file I/O occurs.
+
+## Protected Entry Points
+
+All Python entry points use the C++ `open_external_data()` function. In **read mode** it applies all four layers (pre-open validation via `resolve_external_data_location` for Layers 1, 2, 4, then Layer 3 post-open). In **write mode** it applies Layers 1 and 3 only — Layers 2 and 4 are skipped because the file may not yet exist. The C++ checker calls `resolve_external_data_location` directly without opening files, so Layer 3 does not apply there.
+
+| Entry Point | File | Mode | Layers |
+|---|---|---|---|
+| `resolve_external_data_location` | `onnx/checker.cc` | read | 1, 2, 4 |
+| `open_external_data` | `onnx/checker.cc` | read | 1, 2, 3, 4 |
+| `open_external_data` | `onnx/checker.cc` | write | 1, 3 |
+| `load_external_data_for_tensor` | `onnx/external_data_helper.py` | read | 1, 2, 3, 4 (via `open_external_data`) |
+| `save_external_data` | `onnx/external_data_helper.py` | write | 1, 3 (via `open_external_data`) |
+| `ModelContainer._load_large_initializers` | `onnx/model_container.py` | read | 1, 2, 3, 4 (via `open_external_data`) |
+
+## Known Limitations
+
+### Windows
+
+- Reparse points (symlinks, junctions) are rejected via `FILE_FLAG_OPEN_REPARSE_POINT` + attribute check.
+- Symlink and hardlink tests are skipped on Windows in the test suite.
+
+### Case-Insensitive Filesystems
+
+The canonical path containment checks (Layers 1 and 3) use string comparison. On case-insensitive filesystems (Windows NTFS, macOS HFS+), paths with different casing may incorrectly fail containment. This fails closed (false rejection, not a bypass).
+
+## Testing
+
+Test coverage is in:
+
+- **C++**: `onnx/test/cpp/checker_test.cc` — `*SymLink*` tests for symlink detection and containment, `OpenExternalData*` for secure open and verification.
+- **Python**: `onnx/test/test_external_data.py`:
+  - `TestSaveExternalDataSymlinkProtection` — save-side symlink rejection.
+  - `TestLoadExternalDataSymlinkProtection` — load-side symlink rejection, parent-directory symlink, `load_external_data_for_model` rejection.
+  - `TestLoadExternalDataHardlinkProtection` — load-side hardlink rejection.
+  - `TestSaveExternalDataAbsolutePathValidation` — absolute path rejection.
+
+Symlink and hardlink tests are skipped on Windows (`os.name == "nt"`).
+
+---
+
+## External Data Attribute Validation
+
+This section describes the security model for validating external data attributes in `ExternalDataInfo`. It covers defenses against attribute injection (CWE-915) and resource exhaustion (CWE-400) via crafted `external_data` entries in `TensorProto`.
+
+**Advisory:** [GHSA-538c-55jv-c5g9](https://github.com/onnx/onnx/security/advisories/GHSA-538c-55jv-c5g9)
+
+### Threat Model
+
+An attacker provides a malicious ONNX model with crafted `external_data` entries in `TensorProto`. The `external_data` field is a repeated `StringStringEntryProto` — a key-value store that accepts arbitrary strings for both key and value.
+
+The attack is triggered during `onnx.load()` with no explicit checker invocation required. `ExternalDataInfo.__init__` processes these key-value pairs to populate object attributes.
+
+Attack vectors:
+
+- **Arbitrary attribute injection**: Setting unknown keys (e.g. `evil_attr`) causes `setattr()` to create arbitrary attributes on the `ExternalDataInfo` object. While no current consumer iterates over attributes, injected attributes create latent risk for future code.
+- **Dunder attribute injection**: Setting keys like `__class__` or `__dict__` corrupts the Python object's internal state, enabling type confusion attacks.
+- **Negative offset/length**: Negative values for `offset` cause `file.seek()` to raise `OSError`. Negative `length` causes `file.read(-1)` to read the entire file to EOF, bypassing intended size limits.
+- **Resource exhaustion (DoS)**: Setting `length` to a multi-petabyte value causes unbounded memory allocation when reading external data, even if the actual data file is small.
+
+Four Python consumers of `ExternalDataInfo` exist: `load_external_data_for_tensor`, `set_external_data` / `write_external_data_tensors`, `ModelContainer._load_large_initializers`, and `ReferenceEvaluator` (in `onnx/reference/reference_evaluator.py`). (The C++ checker validates paths but does not use the Python `ExternalDataInfo` class.)
+
+## Defense Layers
+
+We use a 3-layer defense-in-depth approach. Each layer addresses a different class of attack and operates at a different point in the processing pipeline.
+
+### Layer 1: Attribute Whitelist (CWE-915 Mitigation)
+
+`ExternalDataInfo.__init__` only accepts keys in `_ALLOWED_EXTERNAL_DATA_KEYS`: `location`, `offset`, `length`, `checksum`, `basepath`. Unknown keys are warned via `warnings.warn()` and ignored — this prevents arbitrary attribute injection.
+
+This also blocks dunder attribute injection (e.g. `__class__`, `__dict__`) that could cause object type confusion.
+
+**Rationale**: While we cannot prevent someone from constructing malicious protobuf directly, rejecting unknown keys at the Python object level is defense-in-depth that limits the attack surface. The whitelist is a `frozenset` to prevent runtime mutation.
+
+### Layer 2: Bounds Validation at Parse Time (CWE-400 Mitigation)
+
+`offset` and `length` must be non-negative integers. Non-numeric strings raise `ValueError`. This catches obviously invalid values early, before any file I/O occurs.
+
+**Rationale**: Negative `offset` causes `file.seek(-1)` to raise `OSError`; negative `length` causes `file.read(-1)` to read the entire file, bypassing intended size limits. Validating at parse time provides a clear error message at the point closest to the malicious input.
+
+### Layer 3: File-Size Validation at Consumption Time (CWE-400 Mitigation, Defense-in-Depth)
+
+In `load_external_data_for_tensor()` and `ModelContainer._load_large_initializers`, before reading: `offset <= file_size` and `offset + length <= file_size` are verified. A 1KB data file cannot cause a multi-petabyte memory allocation.
+
+**Rationale**: This is the critical safety net. It prevents memory exhaustion regardless of how the model was constructed — even via direct protobuf APIs that bypass Python-level parsing entirely. Validation happens at the point of actual file I/O, the last opportunity before harm occurs.
+
+## Why Layered Defense
+
+- **Layer 1 (whitelist)** catches the broadest class of attacks at parse time. It blocks attribute injection, dunder corruption, and any future unknown-key attack vector.
+- **Layer 2 (bounds validation)** catches obviously invalid numeric values at parse time, providing clear error messages.
+- **Layer 3 (file-size validation)** is the critical safety net that prevents actual harm at the I/O boundary. This layer cannot be bypassed even if an attacker crafts a model using protobuf APIs directly, because validation happens at the point of actual file read.
+
+## Protected Entry Points
+
+| Entry Point | File | Layers |
+|---|---|---|
+| `ExternalDataInfo.__init__` | `onnx/external_data_helper.py` | 1, 2 |
+| `load_external_data_for_tensor` | `onnx/external_data_helper.py` | 1, 2, 3 |
+| `set_external_data` | `onnx/external_data_helper.py` | 1 (whitelist by overwrite) |
+| `ModelContainer._load_large_initializers` | `onnx/model_container.py` | 1, 2, 3 |
+
+## Testing
+
+Test coverage is in `onnx/test/test_external_data.py`:
+
+- `TestExternalDataInfoSecurity`:
+  - **CWE-915 (attribute injection):** `test_unknown_key_rejected`, `test_dunder_key_rejected`, `test_multiple_unknown_keys_all_rejected`, `test_allowed_keys_constant_is_frozen`
+  - **CWE-400 (bounds/DoS):** `test_negative_offset_rejected`, `test_negative_length_rejected`, `test_non_numeric_offset_raises`, `test_non_numeric_length_raises`
+  - **Regression guards:** `test_valid_external_data_accepted`, `test_zero_offset_and_length_accepted`
+- `TestLoadExternalDataFileSizeValidation`:
+  - **File-size validation:** `test_offset_exceeds_file_size_raises`, `test_length_exceeds_available_data_raises`, `test_valid_offset_and_length_load_correctly`
diff --git a/docs/IR.md b/docs/IR.md
new file mode 100644
index 0000000..42cdd5a
--- /dev/null
+++ b/docs/IR.md
@@ -0,0 +1,628 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Open Neural Network Exchange Intermediate Representation (ONNX IR) Specification
+
+__Purpose__
+
+This document contains the normative specification of the semantics of ONNX.
+
+The `.proto` and `.proto3` files found under the [onnx folder](/onnx/) form the normative specification of its syntax authored in the [Protocol Buffers](https://developers.google.com/protocol-buffers) definition language. Commentary found in the `.proto` and `.proto3` files are intended to improve readability of those files, but are not normative if they conflict with this document. Such conflicts should be reported as documentation bugs.
+
+__Notes on model validation__
+
+A [tool](../onnx/checker.py) is available to perform general validation of models against this specification. It is implemented in C++ with a Python command-line wrapper.
+
+__Notes on language in this and all related documents__:
+
+1. The use of SHOULD, MUST, MAY and so on in this document is consistent with [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt).
+
+2. The use of 'list' shall denote an ordered collection of items, 'set' shall denote an unordered collection of unique elements, and 'bag' an unordered collection of possibly non-unique elements.
+
+## Components
+
+ONNX is an open specification that consists of the following components:
+
+1) A definition of an extensible computation graph model.
+
+2) Definitions of standard data types.
+
+3) Definitions of built-in operators.
+
+#1 and #2 together make up the ONNX Intermediate Representation, or 'IR', specification which is covered herein; the built-in operators are covered in documents listed at the end. Specifically, built-in operators are divided into a set of primitive operators and functions. A function is an operator whose semantics is formally expressed via expansion into a sub-graph (called the function body) using other operators (and functions). Functionality-wise, an ONNX compatible framework or runtime may inline a function body to execute it if it does not have corresponding implementation of the function.
+
+There are two official ONNX variants; the main distinction between the two is found in the default operator sets. __ONNX-ML__ extends the __ONNX__ operator set with ML algorithms that are not based on neural networks.
+
+Up to IR version 6, the ONNX specification and model format addressed only inference (also known as scoring). Starting from IR version 7, the ONNX specification and model format also support training. An ONNX training model is an extension of the inference-model. An inference-only runtime can consume a training model ignoring the training-related extensions. However, an inference-only model may enable a representation that is more optimal for inference purposes than a training model.
+
+## Runtime Agnostic
+
+ONNX does not pre-suppose or imply any particular method of runtime implementation.
+
+For example, an implementation may consist of a rich runtime which interprets the model; it may be a code generator that translates the model in its entirety to executable code for some target programming language; it may be a hardware implementation; it may be a combination of two or three of those.
+
+Nothing in this specification should be construed as advocating one implementation approach over any other; any comments on the inner workings of concrete implementations are to be interpreted as examples.
+
+## ONNX Versioning
+
+The IR specification, individual models, and operator sets are all versioned. Furthermore, each individual operator indicates which version of its containing operator set it was introduced or stabilized in.
+
+Version numbers can be used as a simple number, or used to encode [semantic versions](https://semver.org/)(AKA SemVer). If using semantic versions, the convention is to use the two most significant bytes for the major number, the next two bytes for the minor number, and the least significant four bytes for the patch/build/bugfix number. When using semantic versioning, at least one of the major/minor numbers MUST be non-zero.
+
+The IR specification uses simple monotonically increasing numbers for its versions. The valid IR versions are defined by the `onnx.Version` enumeration in [onnx.proto](/onnx/onnx.proto).
+
+Operator sets use a simple version number. Each operator set version represents a snapshot of the set of operators, and their semantics at a particular point in time.
+
+This specification does not provide guidance on what versioning scheme model producers should be using.
+
+More details on conventions and best practices for versioning of IR, operator sets, and models can be found in [Versioning](Versioning.md).
+
+## Extensible computation graph model
+
+ONNX specifies the portable, serialized format of a computation graph. It does not have to be the form a framework chooses to use internally. For example, an implementation may represent the model differently in memory if it is more efficient to manipulate during optimization passes.
+
+An implementation MAY extend ONNX by adding operators expressing semantics beyond the standard set of operators that all implementations MUST support. The mechanism for this is adding operator sets to the `opset_import` property in a model that depends on the extension operators.
+
+### Models
+
+The top-level ONNX construct is a ‘Model.’, and is represented in protocol buffers as the type `onnx.ModelProto`
+
+The main purpose of the model structure is to associate metadata with a graph which contains all the executable elements. The metadata is used when first reading the model file, giving an implementation the information it needs in order to determine whether it will be able to execute the model, generate logging messages, error reports, etc. Further, the metadata is useful to tools, such as IDEs and model galleries, which need it for informing humans about a given model’s purpose and characteristics.
+
+Each model has the following components:
+
+|Name|Type|Description|
+|---|---|---|
+|ir_version|int64|The ONNX version assumed by the model.|
+|opset_import|OperatorSetId|A collection of operator set identifiers made available to the model. An implementation must support all operators in the set or reject the model.|
+|producer_name|string|The name of the tool used to generate the model.|
+|producer_version|string|The version of the generating tool.|
+|domain|string|A reverse-DNS name to indicate the model namespace or domain, for example, 'org.onnx'|
+|model_version|int64|The version of the model itself, encoded in an integer.|
+|doc_string|string|Human-readable documentation for this model. Markdown is allowed.|
+|graph|Graph|The parameterized graph that is evaluated to execute the model.|
+|metadata_props|map<string,string>|Named metadata values; keys should be distinct.|
+|training_info|TrainingInfoProto[]|An optional extension that contains information for training.|
+|functions|FunctionProto[]|An optional list of functions local to the model.|
+|configuration|DeviceConfigurationProto[]|(IR version >= 11) An optional list of multi-device configurations for distributed execution.|
+
+ Models SHOULD specify a domain and use reverse domain names based on the responsible organization's identity, the same convention that is used for [naming Java packages](https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html).
+
+__Note: Exploring an ONNX file__
+
+You can use the `protoc` tool that is part of the Protocol Buffers distribution to examine the contents of an ONNX file, you do so like this:
+
+```bash
+protoc --decode=onnx.ModelProto onnx.proto < yourfile.onnx
+```
+
+Where [onnx.proto](/onnx/onnx.proto) is the file that is part of this repository.
+
+Alternatively, you can use a tool like [Netron](https://github.com/lutzroeder/netron) to explore the ONNX file.
+
+### Model Semantics
+
+The semantics of an inference-model is a _stateless function_ (except possibly for the state used for random-number generation). Thus, whenever an inference-model (without random-generator operations) is used to perform inference on the same input, it is expected to produce the same output.
+
+The semantics of a training model is that of a _stateful object_, with the state consisting of the current values of trained-weights (and any other auxiliary state required, such as momentum, for example, used by the learning algorithm). Specifically, its semantics is captured via three methods: an initialization method (which is used to initialize or reset the values of state variables), a training step method (to train using a batch of input-output pairs), and an inference method to perform inference using the current values of the learned weights. The first two methods update the state of the object, while the third method is side-effect-free.
+
+### Optional Metadata
+
+The 'metadata_props' field in the model is available for any kind of optional metadata that a tool or model developer chooses to place there. The following are the defined “standard” optional metadata properties of a model.
+
+Name|Type|Format|Description
+|---|---|---|---|
+model_author|string|A comma-separated list of names.|The personal name of the author(s) of the model, and/or their organizations.
+model_license|string|Name or URL.|The well-known name or URL of the license under which the model is made available.
+
+### Operator Set Identifiers
+
+Each operator set is uniquely identified by a (domain, version) pair.
+
+Name|Type|Description
+|---|---|---|
+domain|string|The domain of the operator set being identified.
+version|int64|The version of the operator set being identified. Same as 'opset_version' in the operator set.
+
+The operator set version is a simple integer value that is monotonically increased as new versions of the operator set are published.
+
+Operator sets other than the default operator set MUST specify a domain and SHOULD use reverse domain names based on the responsible organization's identity, the same convention that is used for [naming Java packages](https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html).
+
+### Operator Sets
+
+Each model MUST explicitly name the operator sets that it relies on for its functionality. Operator sets define the available operators and their version. Each model defines the imported operator sets by their domains. All models implicitly import the default ONNX operator set.
+
+Each operator set SHALL be defined in a separate document, also using protobuf as the serialization format. How operator set documents are found at runtime is implementation-dependent.
+
+__Note: As of the publication of this document, no ONNX implementation is known to process operator set documents.__
+
+The properties of an operator set are:
+
+Name|Type|Description
+|---|---|---|
+magic|string|The value ‘ONNXOPSET’
+ir_version|int32|The ONNX version corresponding to the operators.
+ir_version_prerelease|string|The prerelease component of the SemVer of the IR.
+ir_build_metadata|string|The build metadata of this version of the operator set.
+domain|string|The domain of the operator set. Must be unique among all sets.
+opset_version|int64|The version of the operator set.
+doc_string|string|Human-readable documentation for this operator set. Markdown is allowed.
+operator|Operator[]|The operators contained in this operator set.
+
+The operator set version is a simple integer value that is monotonically increased as new versions of the operator set are published.
+
+Operator sets other than the default operator set MUST specify a domain and SHOULD use reverse domain names based on the responsible organization's identity, the same convention that is used for [naming Java packages](https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html).
+
+### Operators
+
+Each operator used within a graph MUST be explicitly declared by one of the operator sets imported by the model.
+
+The properties of an operator definition are:
+
+Name|Type|Description
+|---|---|---|
+op_type|string|The name of the operator (case sensitive), as used in graph nodes. MUST be unique within the operator set’s domain.
+since_version|int64|The version of the operator set when this operator was introduced.
+status|OperatorStatus|One of ‘EXPERIMENTAL’ or ‘STABLE.’
+doc_string|string|A human-readable documentation string for this operator. Markdown is allowed.
+
+The version value MUST be the same value as the operator set version when the operator was first published. Subsequent versions of the operator set MUST NOT alter the signature or semantics of the operator once published as STABLE.
+
+The ‘status’ property indicates whether the syntax, semantics, or presence of the operator is in an experimental or stable stage. Once an operator is published as STABLE, it’s syntax and semantics MUST NOT change in subsequent versions of the operator set.
+
+There are two distinct ways to pass information to operators – inputs and attributes. Inputs represent graph inputs or values computed elsewhere in the graph, while attributes are used for values that are constants in the graph. This distinction may be highly relevant to achieving good performance for some implementations, while completely irrelevant to others.
+
+### Functions
+
+A _function_ may be thought of as an operator combined with an implementation of the operator using
+other, more primitive, ops, referred to as the _function body_. The function body consists of a
+topologically sorted list of nodes that form a graph. Thus, a function combines aspects of both
+an operator as well a graph (described below).
+
+Each function contained in a Model (also referred to as a model-local function) serves
+as a default or fallback implementation of the corresponding operator. A runtime, however,
+may choose to use an alternative implementation of the operator (usually as an optimized kernel).
+As such, the unique name of a function is significant as it is implicitly associated with a
+semantic specification.
+
+A serialized function (a _FunctionProto_) has the following properties:
+
+|Name|Type|Description|
+|---|---|---|
+name|string|The name of the function
+domain|string|The domain to which this function belongs
+overload|string|Part of unique id of function (added in IR version 10)
+doc_string|string|Human-readable documentation for this function. Markdown is allowed.
+attribute|string[]|The attribute parameters of the function
+attribute_proto|Attribute[]| (IR version 9+) The attribute parameters with default values of the function. A function attribute shall be represented either as a string attribute or an Attribute, not both.
+input|string[]|The input parameters of the function
+output|string[]|The output parameters of the function.
+node|Node[]|A list of nodes, forming a partially ordered computation graph. It must be in topological order.
+|opset_import|OperatorSetId|A collection of operator set identifiers used by the function implementation.
+|value_info|ValueInfo[]| (IR version >= 10) Used to store the type and shape information of values used in the function.
+|metadata_props|map<string,string>|(IR version >= 10) Named metadata values; keys should be distinct.
+
+The name and domain serve to identify the operator uniquely in IR versions upto 9. IR version 10 adds the
+field overload, and the triple (name, domain, overload) acts as a unique-id across functions stored in
+a model. This is intended to support cases where distinct function-bodies are required for distinct
+calls to the function within the model.
+An opset version is not explicitly identified in a FunctionProto, but it is implicitly determined by
+the opset version of the domain included in the model.
+
+The input, output, attribute, and attribute_proto (added in IR version 9) constitute the signature part of the operator. No type information
+is explicitly included in the signature. The attribute_proto field describes attribute parameters of the function along with their default-value (when not specified by an call-site node), while the attribute field lists attribute parameters without a default-value. The names in these two lists must be distinct. When an attribute-parameter of the function is used in a node within the function, it is replaced by the actual parameter value specified for the attribute at a call-site node (of the function) when such a attribute is specified, and it is replaced by the default-value if the attribute has a default-value specified, and it is omitted otherwise.
+
+The opset_import and node fields describe the implementation of the function.
+
+The value_info field (added in IR version 10) allows a model to store type and shape information about the values used in a function, including its inputs and outputs. Note that this is optional, and ONNX allows functions to be polymorphic.
+
+### Graphs
+
+A graph is used to describe a side-effect-free computation (function).
+A serialized graph is comprised of a set of metadata fields, a list of model parameters, and a list of computation nodes.
+
+Each computation dataflow graph is structured as a topologically sorted list of nodes that form a graph, which MUST be free of cycles. Each node represents a call to an operator or a model local function. Each node has zero or more inputs and one or more outputs.
+
+Graphs have the following properties:
+
+|Name|Type|Description|
+|---|---|---|
+name|string|The name of the model graph.
+node|Node[]|A list of nodes, forming a partially ordered computation graph based on input/output data dependencies. It is in topological order.
+initializer|Tensor[]|A list of named tensor values. When an initializer has the same name as a graph input, it specifies a default value for that input. When an initializer has a name different from all graph inputs, it specifies a constant value. The order of the list is unspecified.
+doc_string|string|Human-readable documentation for this model. Markdown is allowed.
+input|ValueInfo[]|The input parameters of the graph, possibly initialized by a default value found in ‘initializer.’
+output|ValueInfo[]|The output parameters of the graph. Once all output parameters have been written to by a graph execution, the execution is complete.
+value_info|ValueInfo[]|Used to store the type and shape information of values that are not inputs or outputs.
+|metadata_props|map<string,string>|(IR version >= 10) Named metadata values; keys should be distinct.
+
+ValueInfo has the following properties:
+
+Name|Type|Description
+|---|---|---|
+name|string|The name of the value/parameter.
+type|Type|The type of the value **including shape information**.
+doc_string|string|Human-readable documentation for this value. Markdown is allowed.
+
+Each main (top-level) graph MUST define the names, types and shapes of its inputs and outputs, which are specified as ‘value info’ structures. The main graph inputs and outputs are required to have a shape, indicating the rank, even though the exact dimensions need not be specified.
+
+Nested subgraphs (specified as attribute values) MUST define the names of its inputs and outputs
+and MAY define the types of its inputs and outputs.
+
+Each graph MUST specify a name.
+
+The graph MUST adhere to single static assignment (SSA) for all node outputs; this means that all node output names MUST be unique within a graph.
+
+Graphs SHOULD be populated with documentation strings, which MAY be interpreted using GitHub-style markdown syntax. HTML and other text-markup languages MAY NOT be used in documentation strings.
+
+### Names Within a Graph
+
+All names SHOULD adhere to [C90 identifier syntax rules](https://en.cppreference.com/c/language/identifier).
+
+Names of nodes, inputs, outputs, initializers, and attributes are organized into several namespaces. Within a namespace, each name MUST be unique for each given graph. Please see below for further clarification in the case where a graph contains nested subgraphs (as attribute values).
+
+The namespaces are:
+
+Namespace|Description
+|---|---|
+Attribute|The names of attributes of an operator. Unique for each operator.
+Value|The names of values – node inputs & outputs, tensor values (if named), graph inputs, outputs.
+Node|The names of graph nodes.
+Graph|The names of graphs within a domain, unique within the model domain.
+Operator|The names of operators within a domain.
+Shape|The names of tensor shape variables – scoped to the value information records of a graph, which is where shape variables occur.
+
+### Nodes
+
+Computation nodes are comprised of a name, the name of an operator that it invokes, a list of named inputs, a list of named outputs, and a list of attributes.
+
+Input and outputs are positionally associated with operator inputs and outputs. Attributes are associated with operator attributes by name.
+
+They have the following properties:
+
+Name|Type|Description
+|---|---|---|
+name|string|An optional name of the node, used for diagnostic purposes only.
+input|string[]|Names of the values used by the node to propagate input values to the node operator. It must refer to either a graph input, a graph initializer or a node output.
+output|string[]|Names of the outputs used by the node to capture data from the operator invoked by the node. It either introduces a  value in the graph or refers to a graph output.
+op_type|string|The symbolic identifier of the operator to invoke.
+domain|string|The domain of the operator set that contains the operator named by the op_type.
+attribute|Attribute[]|Named attributes, another form of operator parameterization, used for constant values rather than propagated values.
+doc_string|string|Human-readable documentation for this value. Markdown is allowed.
+overload|string|Part of unique id of function (added in IR version 10)
+|metadata_props|map<string,string>|(IR version >= 10) Named metadata values; keys should be distinct.
+|device_configurations|NodeDeviceConfigurationProto[]|(IR version >= 11) Multi-device execution configurations for this node.
+
+A name belonging to the Value namespace may appear in multiple places, namely as a graph input, a graph initializer, a graph output, a node input, or a node output. The occurrence of a name as a graph input, a graph initializer, or as a node output is said to be a definition and the occurrence of a name as a node input or as a graph output is said to be a use.
+
+A value name used in a graph must have a unique definition, with the exception that the same name MAY appear in both the graph input list and graph initializer list. (Further exceptions apply in the presence of nested subgraphs, as described later.)
+
+When a name appears in both the initializer list and the graph input list, a runtime MAY allow a caller to specify a value for this (input) name overriding the value specified in the initializer and a runtime MAY allow users to omit specifying a value for this (input) name, choosing the value specified in the initializer. Names of constants that are not meant to be overridden by the caller should appear only in the initializer list and not in the graph input list. In models with IR version >= 4, in nested subgraphs used as attribute values, users MUST NOT use the same name as both a subgraph initializer and subgraph input unless the corresponding op's specification explicitly allows it. In models with IR version <= 3, users MAY use the same name as both a subgraph initializer and subgraph input, but this is restricted to support constants via initializers that are not intended to correspond to any actual inputs passed from the node into the subgraph. In particular, the control-flow operator semantics determines the set of inputs supplied to the execution of the subgraph, and these input names MUST NOT appear as subgraph initializers. Subgraph initializer names must appear in the graph input list _after_ the actual inputs. This allows the actual inputs and formal inputs to be matched positionally.
+
+Edges in the computation graph are established by outputs of one node being referenced by name in the inputs of a subsequent node.
+
+The outputs of a given node introduce new names into the graph. The values of node outputs are computed by the node's operator. Node inputs MAY refer to node outputs, graph inputs, and graph initializers. When the name of a node output coincides with the name of a graph output, the graph output's value is the corresponding output value computed by that node. A node input in a nested subgraph MAY refer to names introduced in outer graphs (as node outputs, graph inputs, or graph initializers).
+
+The graph MUST use single static assignment for all node outputs, which means that all node output names MUST be unique within a graph. In the case of a nested subgraph, a node output name and names of inputs and initializers of the subgraph MUST be distinct from the names from the outer scopes that are visible in the nested subgraph. That is, variable shadowing is not allowed.
+
+Node dependencies MUST NOT create cycles in the computation graph.
+
+The number of inputs and outputs in a node, their types, the set of attributes specified in a node and their types MUST satisfy the constraints imposed by the signature of the node’s operator.
+
+The list of nodes defining the top-level computation graph MUST be ordered topologically; that is, if node K follows node N in the graph, none of the data inputs of N may refer to outputs of K.
+
+Node attributes are used to pass literal (static) values to operators.
+
+#### Input and Output Values
+
+The representation distinguishes between two kinds of values: attribute values, which are statically known, and input/output values. The types of values permitted in the two cases are different.
+
+Input and output values are found as graph inputs, outputs, and initializers, and as node inputs and outputs. Their values are determined at runtime, either by the code that initiates model execution, or by operators computing output values.
+
+#### Attributes
+
+Attribute values are only found in nodes, passed to operators by name association. Attribute values are runtime constants, in that their values are determined when a model graph is constructed and therefore not computed at runtime. A common use for attributes is to represent coefficients established during model training.
+
+Attributes have the following properties:
+
+Name|Type|Description
+|---|---|---|
+name|string|The name of the attribute. Must be unique among attributes, inputs, and outputs for any given operator and node.
+doc_string|string|Human-readable documentation for this value. Markdown is allowed.
+type|AttributeType|The type of the attribute, determining which of the remaining fields is used to hold the value of the attribute.
+f|float|A 32-bit floating-point value.
+i|int64|A 64-bit integer value.
+s|byte[]|UTF-8 string.
+t|Tensor|A tensor value.
+g|Graph|A graph.
+floats|float[]|A list of 32-bit floating-point values.
+ints|int64[]|A list of 64-bit integer values.
+strings|byte[][]|A list of UTF-8 strings.
+tensors|Tensor[]|A list of tensor values.
+graphs|Graph[]|A list of graphs.
+ref_attr_name|string|The name of a parent function's attribute.
+
+The properties ‘name’ and ‘type’ are required on all attributes, and ‘doc_string’ SHOULD be used on all attributes. An attribute MUST have only one of the value-carrying properties.
+
+In case ‘ref_attr_name’ is set, this attribute does not contain data, and instead it's a reference to the parent function's attribute of the given name. Can only be used within the function body.
+
+#### Variadic Inputs and Outputs
+
+The last input or output of an operator MAY be marked as variadic. For example, the operator 'Max()' can be used to compute the maximum of a varying number of input values. A variadic operator has a minimum arity, which specifies the minimum number of operands that must be specified.
+
+For each variadic operator input, N or more node inputs must be specified where N is the minimum arity of the operator. For each variadic operator output, N or more node outputs must be specified where N is the minimum arity of the operator.
+
+#### Optional Inputs and Outputs
+
+##### Static Optional
+
+Some operators have inputs that are marked as optional, which means that a referring node MAY forgo providing values for such inputs.
+
+Some operators have outputs that are optional. When an actual output parameter of an operator is not specified, the operator implementation MAY forgo computing values for such outputs.
+
+There are two ways to leave an optional input or output unspecified: the first, available only for trailing inputs and outputs, is to simply not provide that input or output; the second method is to use an empty string in place of an input or output name.
+
+Each node referring to an operator with optional outputs MUST provide a name for each output that is computed and MUST NOT provide names for outputs that are not computed.
+
+Optional inputs and outputs of the above kind are referred to as _static-optional_.
+
+##### Dynamic Optional (since IR-8)
+
+**IR-8 Version** introduced a new type-constructor to represent _dynamic-optional_ inputs and outputs,
+in addition to the earlier static-optional version described above. A dynamic-optional INT64
+tensor is a distinct type from an INT64 tensor type. In contrast, a static-optional INT64
+tensor does not have a distinct type, it has the same type as a INT64 tensor.
+The operators `Optional` and `OptionalGetElement` MUST be explicitly used to convert between
+the dynamic-optional type and the underlying non-optional type.
+The dynamic-optional allows for more expressiveness than static-optional.
+
+#### External Tensor Data
+
+The raw data for large constant tensors, such as initializers, MAY be serialized in a separate file. In such a case, the tensor MUST provide the filename relative to the model file and MUST NOT use the value fields. It MAY provide a byte offset and length within that file. It MAY also specify a SHA1 digest of the file. One file MAY contain the data for multiple tensors.
+
+More details can be found in [External Data](ExternalData.md).
+
+## Standard data types
+
+There are two official ONNX variants; the main distinction between the two is found in the supported types and the supported operators.
+
+With respect to supported types, both __ONNX__ and __ONNX-ML__ definition recognize tensors, sparse tensors, sequences, maps, and optionals as input and output types. Sequences and maps were supported from the IR version 6 (ONNX 1.6.0 release). Optional type was supported from IR version 8 (ONNX 1.10.0 release).
+
+The following data types are supported by ONNX for inputs and outputs of graphs and nodes as well as the initializers of a graph.
+
+Primitive numeric, string, and Boolean types MUST be used as elements of tensors.
+
+### Tensor Definition
+
+Tensors are a generalization of vectors and matrices; whereas vectors have one dimension, and matrices two, tensors can have any number of dimensions, including zero. A zero-dimensional tensor is logically equivalent to a scalar value.
+
+Mathematically, a tensor can be defined as a pair of sequences/lists (V, S) where S is the shape of the tensor (a list of non-negative integers) and V is a list of values with length equal to the product of the dimensions in S. Two tensors (V, S) and (V', S') are equal if and only if V = V' and S = S'. The length of S is referred to as the rank.
+
+- If S has length 0, V must have length 1, since the empty product is defined to be 1. In this case, the tensor represents a scalar.
+- S can contain dimensions of value 0. If any dimensions are 0, V must have length 0.
+- If S has length 1, V has length equal to the single dimension in S. In this case, the tensor represents a vector.
+- A tensor representing a vector of length 1 has shape [1], while a tensor representing a scalar has shape []. They both have a single element, but scalars are _not_ vectors of length 1.
+
+A tensor's shape S is a list but can be represented as a tensor with values S and shape [R] where R is the rank of the tensor.
+
+- For a tensor (V, S), the tensor representing its shape is (S, [R]).
+- The shape of a scalar is []. Represented as a tensor, [] has shape [0].
+
+#### Representation
+
+It is common to represent a tensor as a nested list. This generally works fine, but is problematic when zero dimensions are involved. A tensor of shape (5, 0) can be represented as [[], [], [], [], []], but (0, 5) is represented as [] which loses the information that the second dimension is 5.
+
+- A nested list is not a complete representation of a tensor with dimensions of value zero.
+
+### Tensor Element Types
+
+|Group|Types|Description|
+|---|---|---|
+Floating Point Types|float16, float32, float64, bfloat16, float8e4m3fn, float8e5m2, float8e4m3fnuz, float8e5m2fnuz, float4e2m1|Values adhering to the IEEE 754-2008 standard representation of floating-point data or defined in papers [FP8 Formats for Deep Learning](https://arxiv.org/abs/2209.05433), [8-bit Numerical Formats for Deep Neural Networks](https://arxiv.org/abs/2206.02915), and the [Open Compute Project](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf)
+Signed Integer Types|int2, int4, int8, int16, int32, int64|Signed integers are supported for 2-64 bit widths.
+Unsigned Integer Types|uint2, uint4, uint8, uint16, uint32, uint64|Unsigned integers are supported for 2-64 bit widths.
+Complex Types|complex64, complex128|A complex number with either 32- or 64-bit real and imaginary parts.
+Other|string|Strings represent textual data. All strings are encoded using UTF-8.
+Other|bool|Boolean values represent data with only two values, typically true and false.
+
+### Input / Output Data Types
+
+The following types are used to define the types of graph and node inputs and outputs.
+
+|Variant | Type | Description |
+|---|---|---|
+ONNX|dense tensors|Represents a Tensor. See definition above.
+ONNX|sequence|Sequences are dense, ordered, collections of elements that are of homogeneous types.
+ONNX|map|Maps are associative tables, defined by a key type and a value type.
+ONNX|optional|Optionals are wrappers that may contain an element of tensor, sequence, or map type, or may be empty (containing none). [Details](ONNXTypes.md)
+
+#### Static tensor shapes
+
+In addition to element type, tensor types have a **static** shape. The static shape of a tensor variable is related to, but different from, the runtime (dynamic) shape of a tensor value. A static tensor shape is a list of records that indicates whether the tensor is a vector, a matrix, or a higher-dimensional value. For example, a 100x100 matrix has the shape [100,100].
+
+The static shape is defined by 'TensorShapeProto':
+
+```proto
+message TensorShapeProto {
+  message Dimension {
+    oneof value {
+      int64 dim_value = 1;
+      string dim_param = 2;
+    };
+  };
+  repeated Dimension dim = 1;
+}
+```
+
+Which is referenced by the Tensor type message:
+
+```proto
+  message Tensor {
+    optional TensorProto.DataType elem_type = 1;
+    optional TensorShapeProto shape = 2;
+  }
+```
+
+The empty list of dimension sizes, [], is a valid tensor shape, denoting a zero-dimension (scalar) value. A zero-dimension tensor is distinct from a tensor of unknown dimensionality, which is indicated by an absent 'shape' property in the Tensor message. When the shape property is absent in the type of a value (including node input),
+it indicates that the corresponding runtime value may have any shape. This sub-section describes how to interpret a missing-shape or a shape with missing dimensions etc. However, specific usage contexts may impose further constraints on a type and shape.
+For example, the inputs and outputs of a model (top-level graph) are required to *have* a shape, indicating the rank of inputs and outputs,
+even though the exact dimensions need not be specified.
+
+Each size in the list MAY be expressed as an integral value or as a "dimension variable," a string denoting that the actual size of the dimension is not statically constrained to a particular number. This is useful for declaring interfaces that care about the number of dimensions, but not the exact size of each dimension. A dimension MAY have neither dim_value nor dim_param set. Such a dimension represents an unknown dimension unrelated to other unknown dimensions.
+
+For example, a NxM matrix would have the shape list [N,M].
+
+The name of each dimension variable SHOULD adhere to [C90 identifier syntax rules](https://en.cppreference.com/c/language/identifier).
+
+Currently, dimension variables are not scoped. A dimension variable "N" represents the same value across the entire graph in a model. For example, if the graph has two inputs X and Y each with shape ["N"], then at runtime the values passed in for X and Y MUST be tensors of rank 1 with the same dimension. Nested sub-graphs currently share the same scope for dimension variables as the main-graph. This allows a model to relate the dimensions of tensors inside the subgraph to the dimensions of tensors in the outer graph.
+
+ONNX supports types such as Sequences of Tensors. The global scoping of dimension variables means that a variable with type "Sequence<Tensor<float, [M,N]>" represents a sequence of tensors that *all have the same shape*. The dimension variables M or N must be omitted from the above type if that dimension does not have a fixed size across all tensors in the sequence. The entire shape must be omitted from the type if different tensors in the sequence may have different ranks.
+
+For example, a graph that performs matrix cross-product may be defined as taking two inputs of shape [K,M] and [M,N], and producing an output of shape [K,N].
+
+Shapes MAY be defined using a combination of integers and variables.
+
+_Historical Notes_: The following extensions were considered early on, but were never implemented or supported.
+
+* The use of an empty string (as a dimension variable) to denote an unknown dimension not related to any other dimension. This was discarded in favor of using a Dimension with neither dim_value nor dim_param set.
+* The use of the string "\*" (as a dimension variable) to denote a sequence of zero or more dimensions of unknown cardinality. This is not supported. In the current implementation, the number of dimensions in a shape MUST represent the rank of the tensor. A tensor of unknown rank is represented using a TypeProto::Tensor object with no shape, which is legal.
+* A scoping mechanism to allow dimension variables that are local to a sub-graph (such as the body of a loop) may be useful, but is not currently supported.
+* ONNX supports types such as Sequences of Tensors. A scoping mechanism for the dimension variables local to a type may be useful to distinguish between the following two types: a sequence of square matrices (of differing sizes) vs a sequence of square matrices (all of same size). This is not currently supported.
+
+### Attribute Types
+
+The type system used for attributes is related to but slightly different from that used for of inputs and outputs. Attribute values may be a dense tensor, sparse tensor, a scalar numerical value, a string, a graph, or repeated values of one of the above mentioned types.
+
+## Other Metadata
+
+The ModelProto structure, and in IR versions >= 10, various other structures (GraphProto, FunctionProto, NodeProto)
+contain a metadata_props field allowing users to store other metadata in the form of key-value pairs.
+It is recommended that users use key names qualified with a reverse-DNS name as prefix
+(such as "ai.onnxruntime.key1") to avoid conflicts between different uses.
+Unqualified names may be used in the future by the ONNX standard.
+
+## Training Related Information
+
+Training related information is described by one or more instances of _TrainingInfoProto_ contained in a model. Each TrainingInfoProto contains information describing both an initialization step and a training step.
+
+The initialization step is described using a Graph (TrainingInfoProto.initialization) and an initialization-binding map (TrainingInfoProto.initialization_binding). The initialization step is performed by evaluating the Graph, and assigning the outputs produced by the Graph to the _state variables_ of the training model as specified in the initialization-binding. The initialization-binding is conceptually a map, specified as a list of key-value pairs, where each key is the name of a state variable, and the value is the name of an output of the (initialization) Graph. Each name specified as a key in the binding MUST be the name of an initializer that appears in the main inference graph (i.e., in ModelProto.graph.initializer) or the name of an initializer that appears in TrainingInfoProto.algorithm.initializer. Each name specified as a value in the binding MUST be the name of an output of the TrainingInfoProto.initialization graph. Key values specified in the repeated initialization_binding field MUST be unique.
+
+The training step is similarly described using a Graph (TrainingInfoProto.algorithm) and an update-binding map (TrainingInfoProto.update_binding). The training step is performed by evaluating the Graph and assigning the outputs produced by the Graph to the state variables as specified in the update-binding. The constraints and description presented above for the initialization apply to the training step as well.
+
+Thus, the state variables of the training model consist of a subset of the initializers of the main inference graph (i.e., ModelProto.graph.initializer) and the training-algorithm graph (TrainingInfoProto.algorithm.initializer) as identified by the keys of the bindings (in TrainingInfoProto.initialization_binding and TrainingInfoProto.update_binding). Note that the state variables are not constant values in the context of training. They represent mutable variables shared by multiple graphs (implicitly declared in the top-level training model scope). This implicit declaration of shared mutable variables is used instead of an explicit declaration for purposes of backward compatibility with the inference graph representation.
+
+All state variables are pre-initialized to the value specified in the corresponding initializer. A subsequent call to perform the initialization step (using the appropriate API exposed by a runtime) updates the values of the state variables as described above. If the training model has more than one instance of TrainingInfoProto, the initialization step corresponding to each is performed in order. A TrainingInfoProto.initialization MAY be omitted (only if there are no initialization_bindings). For the training step, a runtime MAY allow users to invoke any one of the TrainingInfoProto.algorithm, allowing the training process to interleave the different algorithms as desired. The order in which the different TrainingProto.algorithms are called affects the training result, and it is the callers responsibility to call them in the correct order.
+
+## Multi-Device Configuration (IR version >= 11)
+
+ONNX supports multi-device execution through device configuration specifications that enable distributed inference and training. This includes support for tensor parallelism (sharding tensors across multiple devices) and pipeline parallelism (distributing different subgraphs to different devices).
+
+### Device Configurations
+
+A model MAY specify one or more multi-device configurations using _DeviceConfigurationProto_ contained in the model. Each configuration describes a specific arrangement of devices that can be used for model execution.
+
+The properties of a device configuration are:
+
+|Name|Type|Description|
+|---|---|---|
+|name|string|The name of the configuration. This field MUST be present for this version of the IR.|
+|num_devices|int32|Number of devices in this configuration. This field MUST be present for this version of the IR.|
+|device|string[]|Optional names of the devices. MUST be length of num_devices if provided.|
+
+### Node Device Configuration
+
+Individual nodes can specify device-specific execution information through _NodeDeviceConfigurationProto_. This allows fine-grained control over how computation is distributed across devices.
+
+The properties of a node device configuration are:
+
+|Name|Type|Description|
+|---|---|---|
+|configuration_id|string|ID of the configuration. MUST match the name of a DeviceConfigurationProto. This field MUST be present for this version of the IR.|
+|sharding_spec|ShardingSpecProto[]|Sharding specifications for the node's inputs and outputs.|
+|pipeline_stage|int32|Optional pipeline stage identifier for this node.|
+
+### Sharding Specification
+
+Sharding describes how tensors are partitioned or replicated across multiple devices. A _ShardingSpecProto_ defines the sharding behavior for a specific input or output tensor of a node.
+
+The properties of a sharding specification are:
+
+|Name|Type|Description|
+|---|---|---|
+|tensor_name|string|Identifies the input or output tensor being sharded. Must match a name in the node's input or output list. This field MUST be present for this version of the IR.|
+|device|int64[]|List of devices across which the tensor is sharded or replicated.|
+|index_to_device_group_map|IntIntListEntryProto[]|Optional map indicating device groups when a device ID represents multiple physical devices.|
+|sharded_dim|ShardedDimProto[]|Sharding specification for each axis of the tensor.|
+
+### Sharded Dimension
+
+A _ShardedDimProto_ describes how a single axis of a tensor is sharded across devices.
+
+The properties of a sharded dimension are:
+
+|Name|Type|Description|
+|---|---|---|
+|axis|int64|The tensor axis being sharded. Must be in range [-r, r-1] where r is tensor rank. This field MUST be present for this version of the IR.|
+|simple_sharding|SimpleShardedDimProto[]|Describes how the axis is divided into shards.|
+
+### Simple Sharded Dimension
+
+A _SimpleShardedDimProto_ specifies that N blocks are divided into M shards, where N may be symbolic but M must be constant.
+
+The properties of a simple sharded dimension are:
+
+|Name|Type|Description|
+|---|---|---|
+|dim_value|int64|Dimension value to be sharded (alternative to dim_param).|
+|dim_param|string|Symbolic dimension parameter to be sharded (alternative to dim_value).|
+|num_shards|int64|Number of shards to split the dimension into. This field MUST be present for this version of the IR.|
+
+### Multi-Device Execution Semantics
+
+The multi-device annotations are hints to execution backends and do not affect the computational semantics of the model. Backends MAY ignore these annotations if the specified configurations are not supported or available. All communication operations required for multi-device execution (such as data transfers between devices) are implicit and handled by the runtime.
+
+For tensor parallelism, tensors can be:
+
+- **Split** across devices along specified axes, distributing different portions of the data to different devices
+- **Replicated** across devices, where the same tensor data is duplicated on multiple devices
+
+Pipeline parallelism is indicated through optional pipeline stage identifiers that suggest how to distribute subgraphs across devices for pipelined execution.
+
+For more detailed information about multi-device execution patterns and examples, see the [Multi-Device Proposal](proposals/0006-ONNXMultiDeviceProposal.md).
+
+## Other Specification Documents
+
+The ONNX specification is comprised of this document, which defines the semantics of the IR and the standard data types, and the following documents defining standard operator semantics and the IR syntax. The latter is specified as Protobuf v2 and v3 schema files.
+
+See the [metadata category documentation](MetadataProps.md) for more details.
+
+### Operators
+
+[Neural Network Operators](Operators.md)
+
+[Classical Machine Learning operators](Operators-ml.md)
+
+### Syntax
+
+[ONNX Models and Graphs - protobuf v2](../onnx/onnx.proto)
+
+[ONNX Models and Graphs - protobuf v3](../onnx/onnx.proto3)
+
+[ONNX-ML Models and Graphs - protobuf v2](../onnx/onnx-ml.proto)
+
+[ONNX-ML Models and Graphs - protobuf v3](../onnx/onnx-ml.proto3)
+
+[ONNX Operator Sets - protobuf v2](../onnx/onnx-operators.proto)
+
+[ONNX Operator Sets - protobuf v3](../onnx/onnx-operators.proto3)
+
+[ONNX-ML Operator Sets - protobuf v2](../onnx/onnx-operators-ml.proto)
+
+[ONNX-ML Operator Sets - protobuf v3](../onnx/onnx-operators-ml.proto3)
+
+### Versioning Conventions and Best Practices
+
+[Versioning](Versioning.md)
diff --git a/docs/ImplementingAnOnnxBackend.md b/docs/ImplementingAnOnnxBackend.md
new file mode 100644
index 0000000..c5aa5b5
--- /dev/null
+++ b/docs/ImplementingAnOnnxBackend.md
@@ -0,0 +1,127 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Implementing an ONNX backend
+
+## What is an ONNX backend
+
+An ONNX backend is a library that can run ONNX models. Since many deep learning frameworks already exist, you likely won't need to create everything from scratch. Rather, you'll likely create a converter that converts ONNX models to the corresponding framework specific representation and then delegate the execution to the framework. For example, [onnx-caffe2 (as part of caffe2)](https://github.com/pytorch/pytorch/tree/v2.3.1/caffe2/python/onnx) , [onnx-coreml](https://github.com/onnx/onnx-coreml), and [onnx-tensorflow](https://github.com/onnx/onnx-tensorflow) are all implemented as converters.
+
+## Unified backend interface
+
+ONNX has defined a unified (Python) backend interface at [onnx/backend/base.py](/onnx/backend/base.py).
+
+There are three core concepts in this interface: `Device`, `Backend` and `BackendRep`.
+
+- `Device` is a lightweight abstraction over various hardware, e.g., CPU, GPU, etc.
+
+- `Backend` is the entity that will take an ONNX model with inputs, perform a computation, and then return the output.
+
+  For one-off execution, users can use `run_node` and `run_model` to obtain results quickly.
+
+  For repeated execution, users should use `prepare`, in which the `Backend` does all of the preparation work for executing the model repeatedly (e.g., loading initializers), and returns a `BackendRep` handle.
+
+- `BackendRep` is the handle that a `Backend` returns after preparing to execute a model repeatedly. Users will then pass inputs to the `run` function of `BackendRep` to retrieve the corresponding results.
+
+Note that even though the ONNX unified backend interface is defined in Python, your backend does not need to be implemented in Python. For example, yours can be created in C++, and tools such as [pybind11](https://github.com/pybind/pybind11) or [cython](http://cython.org/) can be used to fulfill the interface.
+
+## ONNX backend test
+
+ONNX provides a standard backend test suite to assist backend implementation verification. It's strongly encouraged that each ONNX backend runs this test.
+
+Integrating the ONNX Backend Test suite into your CI is simple. The following are some examples demonstrating how a backend performs the integration:
+
+- [onnx-caffe2 onnx backend test](https://github.com/pytorch/pytorch/blob/v2.3.1/caffe2/python/onnx/tests/onnx_backend_test.py)
+
+- [onnx-tensorflow onnx backend test](https://github.com/onnx/onnx-tensorflow/blob/main/test/backend/test_onnx_backend.py)
+
+- [onnx-coreml onnx backend test](https://github.com/onnx/onnx-coreml/blob/master/tests/onnx_backend_models_test.py)
+
+If you have [pytest](https://docs.pytest.org/en/latest/) installed, you can get a coverage report after running the ONNX backend test to see how well your backend is doing:
+
+```
+---------- onnx coverage: ----------
+Operators (passed/loaded/total): 21/21/70
+------------------------------------
+╒════════════════════╤════════════════════╕
+│ Operator           │ Attributes         │
+│                    │ (name: #values)    │
+╞════════════════════╪════════════════════╡
+│ Slice              │ axes: 2            │
+│                    │ ends: 3            │
+│                    │ starts: 3          │
+├────────────────────┼────────────────────┤
+│ Constant           │ value: 1           │
+├────────────────────┼────────────────────┤
+│ Concat             │ axis: 0            │
+├────────────────────┼────────────────────┤
+│ Conv               │ group: 6           │
+│                    │ kernel_shape: 5    │
+│                    │ pads: 4            │
+│                    │ strides: 3         │
+│                    │ auto_pad: 0        │
+│                    │ dilations: 0       │
+├────────────────────┼────────────────────┤
+│ Reshape            │ shape: 9           │
+├────────────────────┼────────────────────┤
+│ BatchNormalization │ consumed_inputs: 1 │
+│                    │ epsilon: 2         │
+│                    │ is_test: 1         │
+│                    │ momentum: 0        │
+│                    │ spatial: 0         │
+├────────────────────┼────────────────────┤
+│ Dropout            │ is_test: 1         │
+│                    │ ratio: 2           │
+├────────────────────┼────────────────────┤
+│ MaxPool            │ kernel_shape: 2    │
+│                    │ pads: 3            │
+│                    │ strides: 2         │
+│                    │ auto_pad: 0        │
+│                    │ dilations: 0       │
+├────────────────────┼────────────────────┤
+│ Transpose          │ perm: 1            │
+├────────────────────┼────────────────────┤
+│ MatMul             │ No attributes      │
+├────────────────────┼────────────────────┤
+│ Relu               │ No attributes      │
+├────────────────────┼────────────────────┤
+│ LRN                │ alpha: 2           │
+│                    │ beta: 1            │
+│                    │ bias: 2            │
+│                    │ size: 1            │
+├────────────────────┼────────────────────┤
+│ Add                │ axis: 1            │
+│                    │ broadcast: 1       │
+├────────────────────┼────────────────────┤
+│ Abs                │ No attributes      │
+├────────────────────┼────────────────────┤
+│ Pad                │ mode: 3            │
+│                    │ paddings: 2        │
+│                    │ value: 1           │
+├────────────────────┼────────────────────┤
+│ Softmax            │ axis: 0            │
+├────────────────────┼────────────────────┤
+│ GlobalAveragePool  │ No attributes      │
+├────────────────────┼────────────────────┤
+│ Mul                │ axis: 1            │
+│                    │ broadcast: 1       │
+├────────────────────┼────────────────────┤
+│ Sum                │ No attributes      │
+├────────────────────┼────────────────────┤
+│ Gemm               │ broadcast: 1       │
+│                    │ transB: 1          │
+│                    │ alpha: 0           │
+│                    │ beta: 0            │
+│                    │ transA: 0          │
+├────────────────────┼────────────────────┤
+│ AveragePool        │ kernel_shape: 3    │
+│                    │ pads: 3            │
+│                    │ strides: 2         │
+│                    │ auto_pad: 0        │
+╘════════════════════╧════════════════════╛
+```
+
+The numbers in the line `Operators (passed/loaded/total): 21/21/70` indicate 21 operators covered in all test cases of your backend have passed, 21 operators were covered in all test cases of the ONNX backend test, and ONNX has a total of 70 operators.
diff --git a/docs/ManagingExperimentalOps.md b/docs/ManagingExperimentalOps.md
new file mode 100644
index 0000000..17b1e8e
--- /dev/null
+++ b/docs/ManagingExperimentalOps.md
@@ -0,0 +1,42 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Managing Experimental Operators
+
+## Deprecated Experimental Operators
+
+The following experimental operators were deprecated and removed from ONNX. They should be removed from models, either substituted with newer superseding operators or decomposed into functionally equivalent operators:
+
+Old operator        |New Operator
+--------------------|--------------------------
+`ATen`              |NA
+`Affine`            |`Add(Mul(X, alpha), beta)`
+`ConstantFill`      |`ConstantOfShape`
+`Crop`              |`Slice-1`
+`DynamicSlice`      |`Slice-10`
+`GRUUnit`           |NA
+`GivenTensorFill`   |`Const` or `ConstantOfShape`
+`ImageScaler`       |`Add(Mul(X, scale), Unsqueeze(bias, axes=[0, 2, 3]))`
+`ParametricSoftplus`|`Mul(alpha, Softplus(Mul(beta, X)))`
+`Scale`             |`Mul(X, scale)`
+`ScaledTanh`        |`Mul(Tanh(Mul(X, beta)), alpha)`
+
+## Adding Experimental Operators [Deprecated - as of v1.5 experimental ops are no longer supported]
+
+The experimental flag in ONNX operator definitions indicates that a customer of ONNX may not be able to take a long term dependency on that op. Ops in the ONNX namespace (ai.onnx) in the _main_ branch, whether experimental or not, go through the regular review process.
+
+Experimental ops that are being worked on that do not have consensus yet can be managed in one of 2 ways:
+
+1. Use a fork or branch – what you do in the fork or branch is entirely up to you. When you are ready, you can submit a PR using the normal process. This is the recommended way.
+2. If a fork/branch is not workable (for example due to complexity of mapping different branches between multiple repos), put the experimental ops in a custom namespace in the main branch.
+The specific process for this is:
+
+* Submit an Issue with a proposal explaining the motivation and plan. It does not need to include detailed technical design. Issues will be tagged as "experimental op".
+* Reviewers will generally approve by default unless the proposal directly conflicts with existing ops or somehow goes against general ONNX strategy. Approval is indicated by adding the "experiment approved" tag.
+* The approval is good for 3 months, but can be renewed if needed.
+* Experimental ops should be submitted in a PR in a custom namespace that is the name of the proposal, i.e. “proposal.controlflow”. The name should be descriptive rather than a company or entity name. These PRs will be approved by default as long as the parent proposal is approved and active.
+* Once experimentation is done, the ops can be submitted for addition to the ONNX namespace via the regular process. The owner can also choose to end the experiment without promoting the ops.
+* Either way, the custom namespace is deleted once experimentation is complete or when the approval expires.
diff --git a/docs/MetadataProps.md b/docs/MetadataProps.md
new file mode 100644
index 0000000..5b9fe62
--- /dev/null
+++ b/docs/MetadataProps.md
@@ -0,0 +1,35 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Metadata
+
+In addition to the core metadata recommendations listed in the [extensibility documentation](IR.md#optional-metadata) there is additional experimental metadata to help provide information for model inputs and outputs.
+
+This metadata applies to all input and output tensors of a given category.  The first such category we define is: `Image`.
+
+## Motivation
+
+The motivation of such a mechanism is to allow model authors to convey to model consumers enough information for them to consume the model.
+
+In the case of images there are many option for providing valid image data.  However a model which consumes images was trained with a particular set of these options which must
+be used during inferencing.
+
+The goal is this proposal is to provide enough metadata that the model consumer can perform their own featurization prior to running the model and provide a compatible input or retrieve an output and know what its format is.
+
+## Image Category Definition
+
+For every tensor in this model that uses [Type Denotation](TypeDenotation.md) to declare itself an `IMAGE`, you SHOULD provide metadata to assist the model consumer.  Note that any metadata provided using this mechanism is global to ALL types
+with the accompanying denotation.
+
+Keys and values are case insensitive.
+
+Specifically, we define here the following set image metadata:
+
+|Key|Value|Description|
+|-----|----|-----------|
+|`Image.BitmapPixelFormat`|__string__|Specifies the format of pixel data. Each enumeration value defines a channel ordering and bit depth. Possible values: <ul><li>`Gray8`: 1 channel image, the pixel data is 8 bpp grayscale.</li><li>`Rgb8`: 3 channel image, channel order is RGB, pixel data is 8bpp (No alpha)</li><li>`Bgr8`: 3 channel image, channel order is BGR, pixel data is 8bpp (No alpha)</li><li>`Rgba8`: 4 channel image, channel order is RGBA, pixel data is 8bpp (Straight alpha)</li><li>`Bgra8`: 4 channel image, channel order is BGRA, pixel data is 8bpp (Straight alpha)</li></ul>|
+|`Image.ColorSpaceGamma`|__string__|Specifies the gamma color space used. Possible values:<ul><li>`Linear`: Linear color space, gamma == 1.0</li><li>`SRGB`: sRGB color space, gamma == 2.2</li></ul>|
+|`Image.NominalPixelRange`|__string__|Specifies the range that pixel values are stored. Possible values: <ul><li>`NominalRange_0_255`:  [0...255] for 8bpp samples</li><li>`Normalized_0_1`: [0...1] pixel data is stored normalized</li><li>`Normalized_1_1`: [-1...1] pixel data is stored normalized</li><li>`NominalRange_16_235`: [16...235] for 8bpp samples</li></ul>|
diff --git a/docs/ONNXTypes.md b/docs/ONNXTypes.md
new file mode 100644
index 0000000..f59cbc6
--- /dev/null
+++ b/docs/ONNXTypes.md
@@ -0,0 +1,105 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Types
+
+## Optional Type
+
+An optional type represents a reference to either an element (could be Tensor, Sequence, Map, or Sparse Tensor) or a null value. The optional type appears in model inputs, outputs, as well as intermediate values.
+
+### Use-cases
+
+Optional type enables users to represent more dynamic typing scenarios in ONNX. Similar to Optional[X] type hint in Python typing which is equivalent to Union[None, X], Optional types in ONNX may reference a single element, or null.
+
+### Examples in PyTorch
+
+Optional type only appears in TorchScript graphs generated by jit script compiler. Scripting a model captures dynamic types where an optional value can be assigned either None or a value.
+
+- Example 1
+
+        class Model(torch.nn.Module):
+            def forward(self, x, y:Optional[Tensor]=None):
+                if y is not None:
+                    return x + y
+                return x
+
+    Corresponding TorchScript graph:
+
+        Graph(
+            %self : __torch__.Model,
+            %x.1 : Tensor,
+            %y.1 : Tensor?
+        ):
+            %11 : int = prim::Constant[value=1]()
+            %4 : None = prim::Constant()
+            %5 : bool = aten::__isnot__(%y.1, %4)
+            %6 : Tensor = prim::If(%5)
+                block0():
+                    %y.4 : Tensor = prim::unchecked_cast(%y.1)
+                    %12 : Tensor = aten::add(%x.1, %y.4, %11)
+                -> (%12)
+                block1():
+                -> (%x.1)
+            return (%6)
+
+    ONNX graph:
+
+        Graph(
+            %x.1 : Float(2, 3),
+            %y.1 : Float(2, 3)
+        ):
+            %2 : Bool(1) = onnx::OptionalHasElement(%y.1)
+            %5 : Float(2, 3) = onnx::If(%2)
+                block0():
+                    %3 : Float(2, 3) = onnx::OptionalGetElement(%y.1)
+                    %4 : Float(2, 3) = onnx::Add(%x.1, %3)
+                -> (%4)
+                block1():
+                    %x.2 : Float(2, 3) = onnx::Identity(%x.1)
+                -> (%x.2)
+            return (%5)
+
+- Example 2
+
+        class Model(torch.nn.Module):
+            def forward(
+                    self,
+                    src_tokens,
+                    return_all_hiddens=torch.tensor([False]),
+            ):
+                encoder_states: Optional[Tensor] = None
+                if return_all_hiddens:
+                    encoder_states = src_tokens
+
+                return src_tokens, encoder_states
+
+    Corresponding TorchScript graph:
+
+        Graph(
+            %src_tokens.1 : Float(3, 2, 4,),
+            %return_all_hiddens.1 : Bool(1)
+        ):
+            %3 : None = prim::Constant()
+            %encoder_states : Tensor? = prim::If(%return_all_hiddens.1)
+                block0():
+                -> (%src_tokens.1)
+                block1():
+                -> (%3)
+            return (%src_tokens.1, %encoder_states)
+
+    ONNX graph:
+
+        Graph(
+            %src_tokens.1 : Float(3, 2, 4),
+            %return_all_hiddens.1 : Bool(1)
+        ):
+            %2 : Float(3, 2, 4) = onnx::Optional[type=tensor(float)]()
+            %3 : Float(3, 2, 4) = onnx::If(%return_all_hiddens.1)
+                block0():
+                -> (%src_tokens.1)
+                block1():
+                -> (%2)
+            return (%3)
diff --git a/docs/OnnxBackendTest.md b/docs/OnnxBackendTest.md
new file mode 100644
index 0000000..51490c4
--- /dev/null
+++ b/docs/OnnxBackendTest.md
@@ -0,0 +1,24 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Backend Test
+
+## What is ONNX Backend Test
+
+ONNX Backend Test is a test suite that each ONNX backend should run to verify whether it fulfills ONNX's standard. It serves both as a verification tool for backend implementations and one of the two ways to define each operator's expected behavior (the other way is to add it to the documentation).
+
+There are two types of tests in this suite – Node Tests and Model Tests:
+
+- **Node Tests** verify whether a backend is performing the correct computation, having the expected behavior of handling various attributes for each individual operator. In each test case, the backend will be given a node with some input, and the returned output will be compared with an expected output.
+- **Model Tests** verify the backend at the model level. The test cases are similar to those of Node Tests', but instead of a node, the backend will be given an ONNX model.
+
+## Contributing
+
+As ONNX aims to become the spec of deep learning models format, it's important to ensure that there is no ambiguity in each ONNX operator's definition; adding more test cases is the only way to enforce this.
+
+Node Tests are created as Python/Numpy code in [onnx/backend/test/case/node](/onnx/backend/test/case/node), and then exported to protobuf files to [onnx/backend/test/data/node](/onnx/backend/test/data/node) as the source of truth by invoking the shell command `backend-test-tools generate-data`. Test cases of each operator lives in one standalone file, e.g. for the operator [Add](/docs/Operators.md#Add), its test cases are in [add.py](/onnx/backend/test/case/node/add.py), and each `expect(...)` statement in the code corresponds to one test case. The source code of all `export.*` functions will be also embedded as example code snippets in the [Operators documentation page](/docs/Operators.md). You are contributing to both the test and the documentation!
+
+For Model Tests, since each model protobuf file can be large in size, we don't place the file directly in the repo. Rather, we upload them to the cloud, and download them on demand when running the tests. Each test case consists of one model definition protobuf file, and several pairs of input and output files. Adding a new test case involves some manual work from admins (like uploading the files to the cloud), so if you have an ONNX model that you would like to contribute, please contact us.
diff --git a/docs/OnnxReleases.md b/docs/OnnxReleases.md
new file mode 100644
index 0000000..1e41117
--- /dev/null
+++ b/docs/OnnxReleases.md
@@ -0,0 +1,182 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Releases
+
+The ONNX project, going forward, will plan to release roughly on a four month cadence. We follow the [Semver](https://semver.org/) versioning approach and will make decisions as a community on a release by release basis on whether to do a major or minor release.
+
+## Preparation
+
+* Reach out to the SIG Arch/Infra leads to confirm whether the required status checks for the release branches are still valid and up to date, and whether any rely on outdated hardcoded runner image versions that may need updatingCheck whether the 'required checks' for the release branches are still up to date or need to be adjusted: 'Branches' -> 'Branch protection rules'
+* Determine version (X.Y.Z) for the new release
+    * Discuss in Slack channel for Releases (https://lfaifoundation.slack.com/archives/C018VGGJUGK)
+    * For (v.X.Y.Z), if release is to be 1.16.0,
+        * X=1, Y=16, Z=0
+        * The new branch will be `rel-1.16.0`
+            * Branch protections rules are automatically applied to branches following this format.
+        * The new tag will be `v1.16.0`
+* Create new page for the release in [Release logistics wiki](https://github.com/onnx/onnx/wiki) (Add the release manager to the ONNX organization, if not already seen, so that the manager has write permissions in the wiki.)
+* Before creating a release branch, it is highly recommended to have in mind to compile **preliminary release notes** — ideally maintained in a shared location such as the **release wiki page**. These notes should include a clear summary of the **new features**, a list of **bug fixes**, any **known issues**, and especially any **deprecations or removals**, with links to relevant tickets or documentation where applicable. Having this information ready ensures that the team can confidently and promptly create a `rc1` (release candidate 1) immediately after the branch is cut, without delays. Acting quickly at this stage also helps to **reduce the need for parallel work on both the main and release branches**, minimizing merge conflicts, duplicated effort, and coordination overhead. This practice supports a smoother, more transparent release process.
+   * To generate good release notes, it is helpful if pull requests have meaningful names and corresponding labels. Labels can also be added retrospectively to PRs that have already been merged.
+   * The labels used can be found [here](https://github.com/onnx/onnx/blob/main/.github/release.yml)
+   * The preliminary release notes one gets if one drafts a release on GitHub.
+
+## Create Release Branch
+
+* In `main` branch, before creating the release branch:
+    1. Make sure the release version ([/VERSION_NUMBER](/VERSION_NUMBER)), IR version, ai.onnx opset version, ai.onnx.ml opset version, and ai.onnx.training opset version are correct for the new release in [ONNX proto files](/onnx/onnx.in.proto), [Versioning.md](Versioning.md), [schema.h](/onnx/defs/schema.h), [helper.py](/onnx/helper.py), and [helper_test.py](/onnx/test/helper_test.py).
+
+* Create a release branch
+    1. Click "New branch" from [branches](https://github.com/onnx/onnx/branches) and choose `main` as Source.
+    1. Make sure all tests pass on the new branch.
+
+* After cutting the release branch:
+    1. Create PR to set [VERSION_NUMBER](/VERSION_NUMBER) file in `main` to the next future release, `X.Y+1.0`.
+    1. Create PR to set `VERSION_NUMBER` file in the new release's branch to `X.Y.Zrc1`.
+        * For example the first release candidate for 1.16.0 would be `1.16.0rc1`
+    1. Bump opset version for ai.onnx domain in `onnx/defs/operator_sets.h` and `onnx/defs/schema.h` for use by future operator additions and changes.
+        * For example, this [demo PR](https://github.com/onnx/onnx/pull/6001).
+
+## Upload release candidate to PyPI
+
+* Go to "Actions" -> select ["Create Releases"](https://github.com/onnx/onnx/actions/workflows/create_release.yml) -> Push the button "Run workflow" with the following config:
+
+<img width="339" height="586" alt="make-release-config" src="https://github.com/user-attachments/assets/9e2ab1df-3db5-4161-9d2e-fa95153e189a" />
+
+RC-Candidates
+
+* Published to https://pypi.org/ (starting with onnx 1.19.2 before it was test.pypi.org)
+* Build-mode: Release
+
+* This button triggers the build of the different OS
+
+<img width="1059" height="755" alt="create_releases_overview_jobs" src="https://github.com/user-attachments/assets/d56018f4-a26e-4a38-af0f-6d34f36510c7" />
+
+* All artifacts of the single runs could be found associated to the job
+
+<img width="1556" height="335" alt="create_releases_artifact_overview" src="https://github.com/user-attachments/assets/5f1cb1db-9a22-4a15-84bf-bb68c488898a" />
+
+* Before the final merge, it must be confirmed manually via the set up deployment environments.
+
+## Package verification
+
+**Partner Validation**
+
+ * User should install the rc-packages with `pip install onnx=={rc version}`
+ * Open Issues for external repos:
+     * Create GitHub issues in converters' repos to provide them the package links and oppuruntity to test the release before it goes public.
+        * https://github.com/microsoft/onnxruntime
+            * Example: https://github.com/microsoft/onnxruntime/issues/19783
+            * Note: [How_To_Update_ONNX_Dev_Notes](https://github.com/microsoft/onnxruntime/blob/main/docs/How_To_Update_ONNX_Dev_Notes.md) exists in their repo documenting how to pull in new ONNX releases.
+        * https://github.com/pytorch/pytorch
+            * Example: https://github.com/pytorch/pytorch/issues/121258
+        * https://github.com/onnx/tensorflow-onnx
+            * Example: https://github.com/onnx/tensorflow-onnx/issues/2310
+        * https://github.com/onnx/onnx-tensorrt
+            * Example: https://github.com/onnx/onnx-tensorrt/issues/956
+        * https://github.com/onnx/sklearn-onnx
+            * Example: https://github.com/onnx/sklearn-onnx/issues/1079
+        * https://github.com/microsoft/onnxconverter-common
+            * Example: https://github.com/microsoft/onnxconverter-common/issues/277
+        * https://github.com/onnx/onnxmltools
+            * Example: https://github.com/onnx/onnxmltools/issues/685
+        * https://github.com/Quantco/spox
+        * https://github.com/openvinotoolkit/openvino
+        * https://github.com/conda-forge/onnx-feedstock
+
+ * If issues are found, the bugs are to be fixed in the onnx `main` branch and then cherry-picked into the release branch.
+    * Follow up with reporter to ensure issues are resolved (and validated in a new rc) or deferred to a new release.
+
+# Official Release
+
+Validation steps must be completed before this point! This is the point of new return.
+
+* git tags should not be changed once published
+* Once pushed to PyPI there is no way to update the release. A new release must be made instead
+
+## Set final version number
+
+* Create PR to remove "`rcX`" suffix from `VERSION_NUMBER` file in the new release's branch.
+
+## Create release tag
+
+* [Draft a release](https://github.com/onnx/onnx/releases/new) based on the release branch:
+    * DO NOT click `Publish release` until you are sure no more changes are needed.
+        * Use `Save Draft` if need to save and update more later.
+        * Publishing will create the new git tag
+    * Tag: See top of [Preparation](#Preparation) for tag to create.
+    * Target: The release branch that was just cut
+    * Previous tag: Select the previous release.
+    * Write:
+        * Use [previous releases](https://github.com/onnx/onnx/releases) as a template
+        * Use information from [Release logistics wiki](https://github.com/onnx/onnx/wiki) which should have been created prior to branch cut.
+        * Add any additional commits that merged into the release in since wiki was written.
+    * .tar.gz and .zip will be auto-generated after publishing the release.
+
+## Upload to Official PyPI
+
+* Starting with the release of 1.19, the final release will also be pushed to pypi via Github “Action" -> "Create releases" (see above). Use the following config for official release:
+
+<img width="548" height="749" alt="RunWorkflow_Final" src="https://github.com/user-attachments/assets/d836d0b8-b033-4317-aa21-2aeed3c74d05" />
+
+### NOTES:
+
+* Once the packages are uploaded to PyPI, **you cannot overwrite it on the same PyPI instance**.
+  * Please make sure everything is good on TestPyPI before uploading to PyPI**
+* PyPI has separate logins, passwords, and API tokens from TestPyPI but the process is the same. An ONNX PyPI owner will need to grant access, etc.
+
+## After PyPI Release
+
+**Announce**
+
+* Slack:
+    * Post in the [onnx-release](https://lfaifoundation.slack.com/archives/C018VGGJUGK) and [onnx-general](https://lfaifoundation.slack.com/archives/C016UBNDBL2) channels.
+* Notify ONNX partners via email lists:
+    * onnxdiscussions@service.microsoft.com
+    * onnxconverterteam@service.microsoft.com
+    * onnxruntimeteam@microsoft.com
+* [ONNX News](https://onnx.ai/news.html) Post
+    * Update [news.json](https://github.com/onnx/onnx.github.io/blob/main/js/news.json), see [example news.json PR](https://github.com/onnx/onnx.github.io/pull/197)
+
+**Update conda-forge package with the new ONNX version**
+
+Conda builds of ONNX are done via [conda-forge/onnx-feedstock](https://github.com/conda-forge/onnx-feedstock), which runs infrastructure for building packages and uploading them to conda-forge.
+
+* A PR should be created automatically by `regro-cf-autotick-bot` a few hours after the release is available at https://github.com/onnx/onnx/releases.
+
+* If the automatic PR has build failures:
+    1. Make a personal fork of conda-forge/onnx-feedstock
+    1. Create a personal branch based on the automated PR branch
+    1. Resolve the build issue
+    1. Submit a replacement PR based on your branch
+
+    * Example: https://github.com/conda-forge/onnx-feedstock/pull/116
+
+* If the automatic PR is not created, you need to submit a PR manually
+    * Example: https://github.com/conda-forge/onnx-feedstock/pull/50
+    * Note: Use the sha256 hash (`sha256sum onnx-X.Y.Z.tar.gz`) of the release's tar.gz file from https://github.com/onnx/onnx/releases.
+
+**Merge into main branch**
+
+* Check which changes to the release branch are also relevant for main:
+   * If urgent changes were made directly into the release branch, merge the release branch back into main branch.
+   * If all PRs merged into the release branch (after it was cut) were cherry-picks from main, the merge PR will show as empty and this step is not needed.
+
+**Remove old onnx-weekly packages on PyPI**
+
+* Remove all [onnx-weekly packages](https://pypi.org/project/onnx-weekly/#history) from PyPI for the just released version to save space.
+* Steps:
+    * Go to [PyPI onnx-weekly/releases](https://pypi.org/manage/project/onnx-weekly/releases/)
+        * This is a separate project than the onnx releases so you may need to request access from an owner
+    * Click target package -> Options -> Delete.
+
+**Remove old release-candidate packages on PyPI**
+
+* Remove [onnx-release-candidate packages](https://test.pypi.org/project/onnx/#history) from PyPI up to at least the time specified by the previous release version to save space.
+* Steps:
+    * Go to [PyPI onnx-weekly/releases](https://test.pypi.org/manage/project/onnx/releases/)
+       * This is a separate project than the onnx releases so you may need to request access from an owner
+   * Click target package -> Options -> Delete.
diff --git a/docs/OpConventions.md b/docs/OpConventions.md
new file mode 100644
index 0000000..aa721d3
--- /dev/null
+++ b/docs/OpConventions.md
@@ -0,0 +1,17 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Operator Conventions
+
+To maintain consistency in operator signatures, we use the following principles:
+
+- All attribute names should be lower case and use underscores when it helps with readability
+- Any input/output represented by a single letter is capitalized (i.e. X)
+- Any input/output represented by a full word or multiple words is all lower case and uses underscores when it helps with readability
+- Any input/output representing a bias tensor will utilize the name "B"
+- Any input/output representing a weight tensor will utilize the name “W”
+- “axes” is used when an input, output or attribute is representing multiple axes
+- “axis” is used when an input, output or attribute is representing a single axis
diff --git a/docs/Operators-ml.md b/docs/Operators-ml.md
new file mode 100644
index 0000000..abcdff0
--- /dev/null
+++ b/docs/Operators-ml.md
@@ -0,0 +1,1214 @@
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+## Operator Schemas
+*This file is automatically generated from the
+            [def files](/onnx/defs) via [this script](/onnx/defs/gen_doc.py).
+            Do not modify directly and instead edit operator definitions.*
+
+For an operator input/output's differentiability, it can be differentiable,
+            non-differentiable, or undefined. If a variable's differentiability
+            is not specified, that variable has undefined differentiability.
+
+### ai.onnx.ml
+|**Operator**|**Since version**||
+|-|-|-|
+|<a href="#ai.onnx.ml.ArrayFeatureExtractor">ai.onnx.ml.ArrayFeatureExtractor</a>|<a href="Changelog-ml.md#ai.onnx.ml.ArrayFeatureExtractor-1">1</a>|
+|<a href="#ai.onnx.ml.Binarizer">ai.onnx.ml.Binarizer</a>|<a href="Changelog-ml.md#ai.onnx.ml.Binarizer-1">1</a>|
+|<a href="#ai.onnx.ml.CastMap">ai.onnx.ml.CastMap</a>|<a href="Changelog-ml.md#ai.onnx.ml.CastMap-1">1</a>|
+|<a href="#ai.onnx.ml.CategoryMapper">ai.onnx.ml.CategoryMapper</a>|<a href="Changelog-ml.md#ai.onnx.ml.CategoryMapper-1">1</a>|
+|<a href="#ai.onnx.ml.DictVectorizer">ai.onnx.ml.DictVectorizer</a>|<a href="Changelog-ml.md#ai.onnx.ml.DictVectorizer-1">1</a>|
+|<a href="#ai.onnx.ml.FeatureVectorizer">ai.onnx.ml.FeatureVectorizer</a>|<a href="Changelog-ml.md#ai.onnx.ml.FeatureVectorizer-1">1</a>|
+|<a href="#ai.onnx.ml.Imputer">ai.onnx.ml.Imputer</a>|<a href="Changelog-ml.md#ai.onnx.ml.Imputer-1">1</a>|
+|<a href="#ai.onnx.ml.LabelEncoder">ai.onnx.ml.LabelEncoder</a>|<a href="Changelog-ml.md#ai.onnx.ml.LabelEncoder-4">4</a>, <a href="Changelog-ml.md#ai.onnx.ml.LabelEncoder-2">2</a>, <a href="Changelog-ml.md#ai.onnx.ml.LabelEncoder-1">1</a>|
+|<a href="#ai.onnx.ml.LinearClassifier">ai.onnx.ml.LinearClassifier</a>|<a href="Changelog-ml.md#ai.onnx.ml.LinearClassifier-1">1</a>|
+|<a href="#ai.onnx.ml.LinearRegressor">ai.onnx.ml.LinearRegressor</a>|<a href="Changelog-ml.md#ai.onnx.ml.LinearRegressor-1">1</a>|
+|<a href="#ai.onnx.ml.Normalizer">ai.onnx.ml.Normalizer</a>|<a href="Changelog-ml.md#ai.onnx.ml.Normalizer-1">1</a>|
+|<a href="#ai.onnx.ml.OneHotEncoder">ai.onnx.ml.OneHotEncoder</a>|<a href="Changelog-ml.md#ai.onnx.ml.OneHotEncoder-1">1</a>|
+|<a href="#ai.onnx.ml.SVMClassifier">ai.onnx.ml.SVMClassifier</a>|<a href="Changelog-ml.md#ai.onnx.ml.SVMClassifier-1">1</a>|
+|<a href="#ai.onnx.ml.SVMRegressor">ai.onnx.ml.SVMRegressor</a>|<a href="Changelog-ml.md#ai.onnx.ml.SVMRegressor-1">1</a>|
+|<a href="#ai.onnx.ml.Scaler">ai.onnx.ml.Scaler</a>|<a href="Changelog-ml.md#ai.onnx.ml.Scaler-1">1</a>|
+|<a href="#ai.onnx.ml.TreeEnsemble">ai.onnx.ml.TreeEnsemble</a>|<a href="Changelog-ml.md#ai.onnx.ml.TreeEnsemble-5">5</a>|
+|<a href="#ai.onnx.ml.TreeEnsembleClassifier">ai.onnx.ml.TreeEnsembleClassifier</a> (deprecated)|<a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleClassifier-5">5</a>, <a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleClassifier-3">3</a>, <a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleClassifier-1">1</a>|
+|<a href="#ai.onnx.ml.TreeEnsembleRegressor">ai.onnx.ml.TreeEnsembleRegressor</a> (deprecated)|<a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleRegressor-5">5</a>, <a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleRegressor-3">3</a>, <a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleRegressor-1">1</a>|
+|<a href="#ai.onnx.ml.ZipMap">ai.onnx.ml.ZipMap</a>|<a href="Changelog-ml.md#ai.onnx.ml.ZipMap-1">1</a>|
+
+
+## ai.onnx.ml
+### <a name="ai.onnx.ml.ArrayFeatureExtractor"></a><a name="ai.onnx.ml.arrayfeatureextractor">**ai.onnx.ml.ArrayFeatureExtractor**</a>
+
+  Select elements of the input tensor based on the indices passed.<br>
+      The indices are applied to the last axes of the tensor.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be selected</dd>
+<dt><tt>Y</tt> : tensor(int64)</dt>
+<dd>The indices, based on 0 as the first index of any dimension.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> : T</dt>
+<dd>Selected output data as an array</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32), tensor(string)</dt>
+<dd>The input must be a tensor of a numeric type or string. The output will be of the same tensor type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>arrayfeatureextractor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ArrayFeatureExtractor",
+    inputs=["x", "y"],
+    outputs=["z"],
+    domain="ai.onnx.ml",
+)
+
+x = np.arange(12).reshape((3, 4)).astype(np.float32)
+y = np.array([0, 1], dtype=np.int64)
+z = np.array([[0, 4, 8], [1, 5, 9]], dtype=np.float32).T
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[z],
+    name="test_ai_onnx_ml_array_feature_extractor",
+)
+```
+
+</details>
+
+
+### <a name="ai.onnx.ml.Binarizer"></a><a name="ai.onnx.ml.binarizer">**ai.onnx.ml.Binarizer**</a>
+
+  Maps the values of the input tensor to either 0 or 1, element-wise, based on the outcome of a comparison against a threshold value.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>threshold</tt> : float (default is 0.0)</dt>
+<dd>Values greater than this are mapped to 1, others to 0.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be binarized</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Binarized output data</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type. The output will be of the same tensor type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>binarizer</summary>
+
+```python
+threshold = 1.0
+node = onnx.helper.make_node(
+    "Binarizer",
+    inputs=["X"],
+    outputs=["Y"],
+    threshold=threshold,
+    domain="ai.onnx.ml",
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = compute_binarizer(x, threshold)[0]
+
+expect(node, inputs=[x], outputs=[y], name="test_ai_onnx_ml_binarizer")
+```
+
+</details>
+
+
+### <a name="ai.onnx.ml.CastMap"></a><a name="ai.onnx.ml.castmap">**ai.onnx.ml.CastMap**</a>
+
+  Converts a map to a tensor.<br>The map key must be an int64 and the values will be ordered
+      in ascending order based on this key.<br>The operator supports dense packing or sparse packing.
+      If using sparse packing, the key cannot exceed the max_map-1 value.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>cast_to</tt> : string (default is TO_FLOAT)</dt>
+<dd>A string indicating the desired element type of the output tensor, one of 'TO_FLOAT', 'TO_STRING', 'TO_INT64'.</dd>
+<dt><tt>map_form</tt> : string (default is DENSE)</dt>
+<dd>Indicates whether to only output as many values as are in the input (dense), or position the input based on using the key of the map as the index of the output (sparse).<br>One of 'DENSE', 'SPARSE'.</dd>
+<dt><tt>max_map</tt> : int (default is 1)</dt>
+<dd>If the value of map_form is 'SPARSE,' this attribute indicates the total length of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>The input map that is to be cast to a tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>A tensor representing the same data as the input map, ordered by their keys</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : map(int64, string), map(int64, float)</dt>
+<dd>The input must be an integer map to either string or float.</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(float), tensor(int64)</dt>
+<dd>The output is a 1-D tensor of string, float, or integer.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.CategoryMapper"></a><a name="ai.onnx.ml.categorymapper">**ai.onnx.ml.CategoryMapper**</a>
+
+  Converts strings to integers and vice versa.<br>
+      Two sequences of equal length are used to map between integers and strings,
+      with strings and integers at the same index detailing the mapping.<br>
+      Each operator converts either integers to strings or strings to integers, depending
+      on which default value attribute is provided. Only one default value attribute
+      should be defined.<br>
+      If the string default value is set, it will convert integers to strings.
+      If the int default value is set, it will convert strings to integers.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>cats_int64s</tt> : list of ints</dt>
+<dd>The integers of the map. This sequence must be the same length as the 'cats_strings' sequence.</dd>
+<dt><tt>cats_strings</tt> : list of strings</dt>
+<dd>The strings of the map. This sequence must be the same length as the 'cats_int64s' sequence</dd>
+<dt><tt>default_int64</tt> : int (default is -1)</dt>
+<dd>An integer to use when an input string value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.</dd>
+<dt><tt>default_string</tt> : string (default is _Unused)</dt>
+<dd>A string to use when an input integer value is not found in the map.<br>One and only one of the 'default_*' attributes must be defined.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Output data. If strings are input, the output values are integers, and vice versa.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string), tensor(int64)</dt>
+<dd>The input must be a tensor of strings or integers, either [N,C] or [C].</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64)</dt>
+<dd>The output is a tensor of strings or integers. Its shape will be the same as the input shape.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.DictVectorizer"></a><a name="ai.onnx.ml.dictvectorizer">**ai.onnx.ml.DictVectorizer**</a>
+
+  Uses an index mapping to convert a dictionary to an array.<br>
+      Given a dictionary, each key is looked up in the vocabulary attribute corresponding to
+      the key type. The index into the vocabulary array at which the key is found is then
+      used to index the output 1-D tensor 'Y' and insert into it the value found in the dictionary 'X'.<br>
+      The key type of the input map must correspond to the element type of the defined vocabulary attribute.
+      Therefore, the output array will be equal in length to the index mapping vector parameter.
+      All keys in the input dictionary must be present in the index mapping vector.
+      For each item in the input dictionary, insert its value in the output array.
+      Any keys not present in the input dictionary, will be zero in the output array.<br>
+      For example: if the ``string_vocabulary`` parameter is set to ``["a", "c", "b", "z"]``,
+      then an input of ``{"a": 4, "c": 8}`` will produce an output of ``[4, 8, 0, 0]``.
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>int64_vocabulary</tt> : list of ints</dt>
+<dd>An integer vocabulary array.<br>One and only one of the vocabularies must be defined.</dd>
+<dt><tt>string_vocabulary</tt> : list of strings</dt>
+<dd>A string vocabulary array.<br>One and only one of the vocabularies must be defined.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>A dictionary.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>A 1-D tensor holding values from the input dictionary.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : map(string, int64), map(int64, string), map(int64, float), map(int64, double), map(string, float), map(string, double)</dt>
+<dd>The input must be a map from strings or integers to either strings or a numeric type. The key and value types cannot be the same.</dd>
+<dt><tt>T2</tt> : tensor(int64), tensor(float), tensor(double), tensor(string)</dt>
+<dd>The output will be a tensor of the value type of the input map. It's shape will be [1,C], where C is the length of the input dictionary.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.FeatureVectorizer"></a><a name="ai.onnx.ml.featurevectorizer">**ai.onnx.ml.FeatureVectorizer**</a>
+
+  Concatenates input tensors into one continuous output.<br>
+      All input shapes are 2-D and are concatenated along the second dimension. 1-D tensors are treated as [1,C].
+      Inputs are copied to the output maintaining the order of the input arguments.<br>
+      All inputs must be integers or floats, while the output will be all floating point values.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>inputdimensions</tt> : list of ints</dt>
+<dd>The size of each input in the input list</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>X</tt> (variadic) : T1</dt>
+<dd>An ordered collection of tensors, all with the same element type.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>The output array, elements ordered as the inputs.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64), tensor(float), tensor(double)</dt>
+<dd>The input type must be a tensor of a numeric type.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.Imputer"></a><a name="ai.onnx.ml.imputer">**ai.onnx.ml.Imputer**</a>
+
+  Replaces inputs that equal one value with another, leaving all other elements alone.<br>
+      This operator is typically used to replace missing values in situations where they have a canonical
+      representation, such as -1, 0, NaN, or some extreme value.<br>
+      One and only one of imputed_value_floats or imputed_value_int64s should be defined -- floats if the input tensor
+      holds floats, integers if the input tensor holds integers. The imputed values must all fit within the
+      width of the tensor element type. One and only one of the replaced_value_float or replaced_value_int64 should be defined,
+      which one depends on whether floats or integers are being processed.<br>
+      The imputed_value attribute length can be 1 element, or it can have one element per input feature.<br>In other words, if the input tensor has the shape [*,F], then the length of the attribute array may be 1 or F. If it is 1, then it is broadcast along the last dimension and applied to each feature.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>imputed_value_floats</tt> : list of floats</dt>
+<dd>Value(s) to change to</dd>
+<dt><tt>imputed_value_int64s</tt> : list of ints</dt>
+<dd>Value(s) to change to.</dd>
+<dt><tt>replaced_value_float</tt> : float (default is 0.0)</dt>
+<dd>A value that needs replacing.</dd>
+<dt><tt>replaced_value_int64</tt> : int (default is 0)</dt>
+<dd>A value that needs replacing.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be processed.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Imputed output data</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input type must be a tensor of a numeric type, either [N,C] or [C]. The output type will be of the same tensor type and shape.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.LabelEncoder"></a><a name="ai.onnx.ml.labelencoder">**ai.onnx.ml.LabelEncoder**</a>
+
+  Maps each element in the input tensor to another value.<br>
+      The mapping is determined by the two parallel attributes, 'keys_*' and
+      'values_*' attribute. The i-th value in the specified 'keys_*' attribute
+      would be mapped to the i-th value in the specified 'values_*' attribute. It
+      implies that input's element type and the element type of the specified
+      'keys_*' should be identical while the output type is identical to the
+      specified 'values_*' attribute. Note that the 'keys_*' and 'values_*' attributes
+      must have the same length. If an input element can not be found in the
+      specified 'keys_*' attribute, the 'default_*' that matches the specified
+      'values_*' attribute may be used as its output value. The type of the 'default_*'
+      attribute must match the 'values_*' attribute chosen. <br>
+      Let's consider an example which maps a string tensor to an integer tensor.
+      Assume and 'keys_strings' is ["Amy", "Sally"], 'values_int64s' is [5, 6],
+      and 'default_int64' is '-1'.  The input ["Dori", "Amy", "Amy", "Sally",
+      "Sally"] would be mapped to [-1, 5, 5, 6, 6].<br>
+      Since this operator is an one-to-one mapping, its input and output shapes
+      are the same. Notice that only one of 'keys_*'/'values_*' can be set.<br>
+      Float keys with value 'NaN' match any input 'NaN' value regardless of bit
+      value. If a key is repeated, the last key takes precedence.
+
+#### Version
+
+This version of the operator has been available since version 4 of the 'ai.onnx.ml' operator set.
+
+Other versions of this operator: <a href="Changelog-ml.md#ai.onnx.ml.LabelEncoder-1">1</a>, <a href="Changelog-ml.md#ai.onnx.ml.LabelEncoder-2">2</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>default_float</tt> : float (default is -0.0)</dt>
+<dd>A float.</dd>
+<dt><tt>default_int64</tt> : int (default is -1)</dt>
+<dd>An integer.</dd>
+<dt><tt>default_string</tt> : string (default is _Unused)</dt>
+<dd>A string.</dd>
+<dt><tt>default_tensor</tt> : tensor</dt>
+<dd>A default tensor. {"_Unused"} if values_* has string type, {-1} if values_* has integral type, and {-0.f} if values_* has float type.</dd>
+<dt><tt>keys_floats</tt> : list of floats</dt>
+<dd>A list of floats.</dd>
+<dt><tt>keys_int64s</tt> : list of ints</dt>
+<dd>A list of ints.</dd>
+<dt><tt>keys_strings</tt> : list of strings</dt>
+<dd>A list of strings.</dd>
+<dt><tt>keys_tensor</tt> : tensor</dt>
+<dd>Keys encoded as a 1D tensor. One and only one of 'keys_*'s should be set.</dd>
+<dt><tt>values_floats</tt> : list of floats</dt>
+<dd>A list of floats.</dd>
+<dt><tt>values_int64s</tt> : list of ints</dt>
+<dd>A list of ints.</dd>
+<dt><tt>values_strings</tt> : list of strings</dt>
+<dd>A list of strings.</dd>
+<dt><tt>values_tensor</tt> : tensor</dt>
+<dd>Values encoded as a 1D tensor. One and only one of 'values_*'s should be set.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data. It must have the same element type as the keys_* attribute set.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Output data. This tensor's element type is based on the values_* attribute set.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string), tensor(int64), tensor(float), tensor(int32), tensor(int16), tensor(double)</dt>
+<dd>The input type is a tensor of any shape.</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64), tensor(float), tensor(int32), tensor(int16), tensor(double)</dt>
+<dd>Output type is determined by the specified 'values_*' attribute.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>string_int_label_encoder</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LabelEncoder",
+    inputs=["X"],
+    outputs=["Y"],
+    domain="ai.onnx.ml",
+    keys_strings=["a", "b", "c"],
+    values_int64s=[0, 1, 2],
+    default_int64=42,
+)
+x = np.array(["a", "b", "d", "c", "g"]).astype(object)
+y = np.array([0, 1, 42, 2, 42]).astype(np.int64)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_label_encoder_string_int",
+)
+
+node = onnx.helper.make_node(
+    "LabelEncoder",
+    inputs=["X"],
+    outputs=["Y"],
+    domain="ai.onnx.ml",
+    keys_strings=["a", "b", "c"],
+    values_int64s=[0, 1, 2],
+)
+x = np.array(["a", "b", "d", "c", "g"]).astype(object)
+y = np.array([0, 1, -1, 2, -1]).astype(np.int64)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_label_encoder_string_int_no_default",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tensor_based_label_encoder</summary>
+
+```python
+tensor_keys = make_tensor(
+    "keys_tensor", onnx.TensorProto.STRING, (3,), ["a", "b", "c"]
+)
+repeated_string_keys = ["a", "b", "c"]
+x = np.array(["a", "b", "d", "c", "g"]).astype(object)
+y = np.array([0, 1, 42, 2, 42]).astype(np.int16)
+
+node = onnx.helper.make_node(
+    "LabelEncoder",
+    inputs=["X"],
+    outputs=["Y"],
+    domain="ai.onnx.ml",
+    keys_tensor=tensor_keys,
+    values_tensor=make_tensor(
+        "values_tensor", onnx.TensorProto.INT16, (3,), [0, 1, 2]
+    ),
+    default_tensor=make_tensor(
+        "default_tensor", onnx.TensorProto.INT16, (1,), [42]
+    ),
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_label_encoder_tensor_mapping",
+)
+
+node = onnx.helper.make_node(
+    "LabelEncoder",
+    inputs=["X"],
+    outputs=["Y"],
+    domain="ai.onnx.ml",
+    keys_strings=repeated_string_keys,
+    values_tensor=make_tensor(
+        "values_tensor", onnx.TensorProto.INT16, (3,), [0, 1, 2]
+    ),
+    default_tensor=make_tensor(
+        "default_tensor", onnx.TensorProto.INT16, (1,), [42]
+    ),
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_label_encoder_tensor_value_only_mapping",
+)
+```
+
+</details>
+
+
+### <a name="ai.onnx.ml.LinearClassifier"></a><a name="ai.onnx.ml.linearclassifier">**ai.onnx.ml.LinearClassifier**</a>
+
+  Linear classifier
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>classlabels_ints</tt> : list of ints</dt>
+<dd>Class labels when using integer labels. One and only one 'classlabels' attribute must be defined.</dd>
+<dt><tt>classlabels_strings</tt> : list of strings</dt>
+<dd>Class labels when using string labels. One and only one 'classlabels' attribute must be defined.</dd>
+<dt><tt>coefficients</tt> : list of floats (required)</dt>
+<dd>A collection of weights of the model(s).</dd>
+<dt><tt>intercepts</tt> : list of floats</dt>
+<dd>A collection of intercepts.</dd>
+<dt><tt>multi_class</tt> : int (default is 0)</dt>
+<dd>Indicates whether to do OvR or multinomial (0=OvR is the default).</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the scores vector.<br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Data to be classified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Classification outputs (one class per example).</dd>
+<dt><tt>Z</tt> : tensor(float)</dt>
+<dd>Classification scores ([N,E] - one score for each class and example</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type, and of shape [N,C] or [C]. In the latter case, it will be treated as [1,C]</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64)</dt>
+<dd>The output will be a tensor of strings or integers.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.LinearRegressor"></a><a name="ai.onnx.ml.linearregressor">**ai.onnx.ml.LinearRegressor**</a>
+
+  Generalized linear regression evaluation.<br>
+      If targets is set to 1 (default) then univariate regression is performed.<br>
+      If targets is set to M then M sets of coefficients must be passed in as a sequence
+      and M results will be output for each input n in N.<br>
+      The coefficients array is of length n, and the coefficients for each target are contiguous.
+      Intercepts are optional but if provided must match the number of targets.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>coefficients</tt> : list of floats</dt>
+<dd>Weights of the model(s).</dd>
+<dt><tt>intercepts</tt> : list of floats</dt>
+<dd>Weights of the intercepts, if used.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the regression output vector.<br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'</dd>
+<dt><tt>targets</tt> : int (default is 1)</dt>
+<dd>The total number of regression targets, 1 if not defined.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be regressed.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Regression outputs (one per target, per example).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.Normalizer"></a><a name="ai.onnx.ml.normalizer">**ai.onnx.ml.Normalizer**</a>
+
+  Normalize the input.  There are three normalization modes, which have the corresponding formulas,
+      defined using element-wise infix operators '/' and '^' and tensor-wide functions 'max' and 'sum':<br>
+  <br>
+      Max: Y = X / max(X)<br>
+      L1:  Y = X / sum(X)<br>
+      L2:  Y = sqrt(X^2 / sum(X^2)}<br>
+      In all modes, if the divisor is zero, Y == X.
+  <br>
+      For batches, that is, [N,C] tensors, normalization is done along the C axis. In other words, each row
+      of the batch is normalized independently.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>norm</tt> : string (default is MAX)</dt>
+<dd>One of 'MAX,' 'L1,' 'L2'</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be encoded, a tensor of shape [N,C] or [C]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Encoded output data</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.OneHotEncoder"></a><a name="ai.onnx.ml.onehotencoder">**ai.onnx.ml.OneHotEncoder**</a>
+
+  Replace each input element with an array of ones and zeros, where a single
+      one is placed at the index of the category that was passed in. The total category count
+      will determine the size of the extra dimension of the output array Y.<br>
+      For example, if we pass a tensor with a single value of 4, and a category count of 8,
+      the output will be a tensor with ``[0,0,0,0,1,0,0,0]``.<br>
+      This operator assumes every input feature is from the same set of categories.<br>
+      If the input is a tensor of float, int32, or double, the data will be cast
+      to integers and the cats_int64s category list will be used for the lookups.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>cats_int64s</tt> : list of ints</dt>
+<dd>List of categories, ints.<br>One and only one of the 'cats_*' attributes must be defined.</dd>
+<dt><tt>cats_strings</tt> : list of strings</dt>
+<dd>List of categories, strings.<br>One and only one of the 'cats_*' attributes must be defined.</dd>
+<dt><tt>zeros</tt> : int (default is 1)</dt>
+<dd>If true and category is not present, will return all zeros; if false and a category if not found, the operator will fail.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be encoded.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Encoded output data, having one more dimension than X.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(string), tensor(int64), tensor(int32), tensor(float), tensor(double)</dt>
+<dd>The input must be a tensor of a numeric type.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.SVMClassifier"></a><a name="ai.onnx.ml.svmclassifier">**ai.onnx.ml.SVMClassifier**</a>
+
+  Support Vector Machine classifier
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>classlabels_ints</tt> : list of ints</dt>
+<dd>Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>classlabels_strings</tt> : list of strings</dt>
+<dd>Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>coefficients</tt> : list of floats</dt>
+<dd></dd>
+<dt><tt>kernel_params</tt> : list of floats</dt>
+<dd>List of 3 elements containing gamma, coef0, and degree, in that order. Zero if unused for the kernel.</dd>
+<dt><tt>kernel_type</tt> : string (default is LINEAR)</dt>
+<dd>The kernel type, one of 'LINEAR,' 'POLY,' 'RBF,' 'SIGMOID'.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'</dd>
+<dt><tt>prob_a</tt> : list of floats</dt>
+<dd>First set of probability coefficients.</dd>
+<dt><tt>prob_b</tt> : list of floats</dt>
+<dd>Second set of probability coefficients. This array must be same size as prob_a.<br>If these are provided then output Z are probability estimates, otherwise they are raw scores.</dd>
+<dt><tt>rho</tt> : list of floats</dt>
+<dd></dd>
+<dt><tt>support_vectors</tt> : list of floats</dt>
+<dd></dd>
+<dt><tt>vectors_per_class</tt> : list of ints</dt>
+<dd></dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Data to be classified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T2</dt>
+<dd>Classification outputs (one class per example).</dd>
+<dt><tt>Z</tt> : tensor(float)</dt>
+<dd>Class scores (one per class per example), if prob_a and prob_b are provided they are probabilities for each class, otherwise they are raw scores.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type, either [C] or [N,C].</dd>
+<dt><tt>T2</tt> : tensor(string), tensor(int64)</dt>
+<dd>The output type will be a tensor of strings or integers, depending on which of the classlabels_* attributes is used. Its size will match the batch size of the input.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.SVMRegressor"></a><a name="ai.onnx.ml.svmregressor">**ai.onnx.ml.SVMRegressor**</a>
+
+  Support Vector Machine regression prediction and one-class SVM anomaly detection.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>coefficients</tt> : list of floats</dt>
+<dd>Support vector coefficients.</dd>
+<dt><tt>kernel_params</tt> : list of floats</dt>
+<dd>List of 3 elements containing gamma, coef0, and degree, in that order. Zero if unused for the kernel.</dd>
+<dt><tt>kernel_type</tt> : string (default is LINEAR)</dt>
+<dd>The kernel type, one of 'LINEAR,' 'POLY,' 'RBF,' 'SIGMOID'.</dd>
+<dt><tt>n_supports</tt> : int (default is 0)</dt>
+<dd>The number of support vectors.</dd>
+<dt><tt>one_class</tt> : int (default is 0)</dt>
+<dd>Flag indicating whether the regression is a one-class SVM or not.</dd>
+<dt><tt>post_transform</tt> : string (default is NONE)</dt>
+<dd>Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT.'</dd>
+<dt><tt>rho</tt> : list of floats</dt>
+<dd></dd>
+<dt><tt>support_vectors</tt> : list of floats</dt>
+<dd>Chosen support vectors</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be regressed.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Regression outputs (one score per target per example).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input type must be a tensor of a numeric type, either [C] or [N,C].</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.Scaler"></a><a name="ai.onnx.ml.scaler">**ai.onnx.ml.Scaler**</a>
+
+  Rescale input data, for example to standardize features by removing the mean and scaling to unit variance.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>offset</tt> : list of floats</dt>
+<dd>First, offset by this.<br>Can be length of features in an [N,F] tensor or length 1, in which case it applies to all features, regardless of dimension count.</dd>
+<dt><tt>scale</tt> : list of floats</dt>
+<dd>Second, multiply by this.<br>Can be length of features in an [N,F] tensor or length 1, in which case it applies to all features, regardless of dimension count.<br>Must be same length as 'offset'</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Data to be scaled.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(float)</dt>
+<dd>Scaled output data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int64), tensor(int32)</dt>
+<dd>The input must be a tensor of a numeric type.</dd>
+</dl>
+
+
+### <a name="ai.onnx.ml.TreeEnsemble"></a><a name="ai.onnx.ml.treeensemble">**ai.onnx.ml.TreeEnsemble**</a>
+
+  Tree Ensemble operator.  Returns the regressed values for each input in a batch.
+      Inputs have dimensions `[N, F]` where `N` is the input batch size and `F` is the number of input features.
+      Outputs have dimensions `[N, num_targets]` where `N` is the batch size and `num_targets` is the number of targets, which is a configurable attribute.
+
+      The encoding of this attribute is split along interior nodes and the leaves of the trees. Notably, attributes with the prefix `nodes_*` are associated with interior nodes, and attributes with the prefix `leaf_*` are associated with leaves.
+      The attributes `nodes_*` must all have the same length and encode a sequence of tuples, as defined by taking all the `nodes_*` fields at a given position.
+
+      All fields prefixed with `leaf_*` represent tree leaves, and similarly define tuples of leaves and must have identical length.
+
+      This operator can be used to implement both the previous `TreeEnsembleRegressor` and `TreeEnsembleClassifier` nodes.
+      The `TreeEnsembleRegressor` node maps directly to this node and requires changing how the nodes are represented.
+      The `TreeEnsembleClassifier` node can be implemented by adding a `ArgMax` node after this node to determine the top class.
+      To encode class labels, a `LabelEncoder` or `GatherND` operator may be used.
+
+#### Version
+
+This version of the operator has been available since version 5 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>aggregate_function</tt> : int (default is 1)</dt>
+<dd>Defines how to aggregate leaf values within a target. <br>One of 'AVERAGE' (0) 'SUM' (1) 'MIN' (2) 'MAX (3) defaults to 'SUM' (1)</dd>
+<dt><tt>leaf_targetids</tt> : list of ints (required)</dt>
+<dd>The index of the target that this leaf contributes to (this must be in range `[0, n_targets)`).</dd>
+<dt><tt>leaf_weights</tt> : tensor (required)</dt>
+<dd>The weight for each leaf.</dd>
+<dt><tt>membership_values</tt> : tensor</dt>
+<dd>Members to test membership of for each set membership node. List all of the members to test again in the order that the 'BRANCH_MEMBER' mode appears in `node_modes`, delimited by `NaN`s. Will have the same number of sets of values as nodes with mode 'BRANCH_MEMBER'. This may be omitted if the node doesn't contain any 'BRANCH_MEMBER' nodes.</dd>
+<dt><tt>n_targets</tt> : int</dt>
+<dd>The total number of targets.</dd>
+<dt><tt>nodes_falseleafs</tt> : list of ints (required)</dt>
+<dd>1 if false branch is leaf for each node and 0 if an interior node. To represent a tree that is a leaf (only has one node), one can do so by having a single `nodes_*` entry with true and false branches referencing the same `leaf_*` entry</dd>
+<dt><tt>nodes_falsenodeids</tt> : list of ints (required)</dt>
+<dd>If `nodes_falseleafs` is false at an entry, this represents the position of the false branch node. This position can be used to index into a `nodes_*` entry. If `nodes_falseleafs` is false, it is an index into the leaf_* attributes.</dd>
+<dt><tt>nodes_featureids</tt> : list of ints (required)</dt>
+<dd>Feature id for each node.</dd>
+<dt><tt>nodes_hitrates</tt> : tensor</dt>
+<dd>Popularity of each node, used for performance and may be omitted.</dd>
+<dt><tt>nodes_missing_value_tracks_true</tt> : list of ints</dt>
+<dd>For each node, define whether to follow the true branch (if attribute value is 1) or false branch (if attribute value is 0) in the presence of a NaN input feature. This attribute may be left undefined and the default value is false (0) for all nodes.</dd>
+<dt><tt>nodes_modes</tt> : tensor (required)</dt>
+<dd>The comparison operation performed by the node. This is encoded as an enumeration of 0 ('BRANCH_LEQ'), 1 ('BRANCH_LT'), 2 ('BRANCH_GTE'), 3 ('BRANCH_GT'), 4 ('BRANCH_EQ'), 5 ('BRANCH_NEQ'), and 6 ('BRANCH_MEMBER'). Note this is a tensor of type uint8.</dd>
+<dt><tt>nodes_splits</tt> : tensor (required)</dt>
+<dd>Thresholds to do the splitting on for each node with mode that is not 'BRANCH_MEMBER'.</dd>
+<dt><tt>nodes_trueleafs</tt> : list of ints (required)</dt>
+<dd>1 if true branch is leaf for each node and 0 an interior node. To represent a tree that is a leaf (only has one node), one can do so by having a single `nodes_*` entry with true and false branches referencing the same `leaf_*` entry</dd>
+<dt><tt>nodes_truenodeids</tt> : list of ints (required)</dt>
+<dd>If `nodes_trueleafs` is false at an entry, this represents the position of the true branch node. This position can be used to index into a `nodes_*` entry. If `nodes_trueleafs` is false, it is an index into the leaf_* attributes.</dd>
+<dt><tt>post_transform</tt> : int (default is 0)</dt>
+<dd>Indicates the transform to apply to the score. <br>One of 'NONE' (0), 'SOFTMAX' (1), 'LOGISTIC' (2), 'SOFTMAX_ZERO' (3) or 'PROBIT' (4), defaults to 'NONE' (0)</dd>
+<dt><tt>tree_roots</tt> : list of ints (required)</dt>
+<dd>Index into `nodes_*` for the root of each tree. The tree structure is derived from the branching of each node.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input of shape [Batch Size, Number of Features]</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output of shape [Batch Size, Number of targets]</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(float16)</dt>
+<dd>The input type must be a tensor of a numeric type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>tree_ensemble_set_membership</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TreeEnsemble",
+    ["X"],
+    ["Y"],
+    domain="ai.onnx.ml",
+    n_targets=4,
+    aggregate_function=1,
+    membership_values=make_tensor(
+        "membership_values",
+        onnx.TensorProto.FLOAT,
+        (8,),
+        [1.2, 3.7, 8, 9, np.nan, 12, 7, np.nan],
+    ),
+    nodes_missing_value_tracks_true=None,
+    nodes_hitrates=None,
+    post_transform=0,
+    tree_roots=[0],
+    nodes_modes=make_tensor(
+        "nodes_modes",
+        onnx.TensorProto.UINT8,
+        (3,),
+        np.array([0, 6, 6], dtype=np.uint8),
+    ),
+    nodes_featureids=[0, 0, 0],
+    nodes_splits=make_tensor(
+        "nodes_splits",
+        onnx.TensorProto.FLOAT,
+        (3,),
+        np.array([11, 232344.0, np.nan], dtype=np.float32),
+    ),
+    nodes_trueleafs=[0, 1, 1],
+    nodes_truenodeids=[1, 0, 1],
+    nodes_falseleafs=[1, 0, 1],
+    nodes_falsenodeids=[2, 2, 3],
+    leaf_targetids=[0, 1, 2, 3],
+    leaf_weights=make_tensor(
+        "leaf_weights", onnx.TensorProto.FLOAT, (4,), [1, 10, 1000, 100]
+    ),
+)
+
+x = np.array([1.2, 3.4, -0.12, np.nan, 12, 7], np.float32).reshape(-1, 1)
+expected = np.array(
+    [
+        [1, 0, 0, 0],
+        [0, 0, 0, 100],
+        [0, 0, 0, 100],
+        [0, 0, 1000, 0],
+        [0, 0, 1000, 0],
+        [0, 10, 0, 0],
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[x],
+    outputs=[expected],
+    name="test_ai_onnx_ml_tree_ensemble_set_membership",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tree_ensemble_single_tree</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TreeEnsemble",
+    ["X"],
+    ["Y"],
+    domain="ai.onnx.ml",
+    n_targets=2,
+    membership_values=None,
+    nodes_missing_value_tracks_true=None,
+    nodes_hitrates=None,
+    aggregate_function=1,
+    post_transform=0,
+    tree_roots=[0],
+    nodes_modes=make_tensor(
+        "nodes_modes",
+        onnx.TensorProto.UINT8,
+        (3,),
+        np.array([0, 0, 0], dtype=np.uint8),
+    ),
+    nodes_featureids=[0, 0, 0],
+    nodes_splits=make_tensor(
+        "nodes_splits",
+        onnx.TensorProto.DOUBLE,
+        (3,),
+        np.array([3.14, 1.2, 4.2], dtype=np.float64),
+    ),
+    nodes_truenodeids=[1, 0, 1],
+    nodes_trueleafs=[0, 1, 1],
+    nodes_falsenodeids=[2, 2, 3],
+    nodes_falseleafs=[0, 1, 1],
+    leaf_targetids=[0, 1, 0, 1],
+    leaf_weights=make_tensor(
+        "leaf_weights",
+        onnx.TensorProto.DOUBLE,
+        (4,),
+        np.array([5.23, 12.12, -12.23, 7.21], dtype=np.float64),
+    ),
+)
+
+x = np.array([1.2, 3.4, -0.12, 1.66, 4.14, 1.77], np.float64).reshape(3, 2)
+y = np.array([[5.23, 0], [5.23, 0], [0, 12.12]], dtype=np.float64)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_tree_ensemble_single_tree",
+)
+```
+
+</details>
+
+
+### <a name="ai.onnx.ml.TreeEnsembleClassifier"></a><a name="ai.onnx.ml.treeensembleclassifier">**ai.onnx.ml.TreeEnsembleClassifier** (deprecated)</a>
+
+  This operator is DEPRECATED. Please use TreeEnsemble with provides similar functionality.
+      In order to determine the top class, the ArgMax node can be applied to the output of TreeEnsemble.
+      To encode class labels, use a LabelEncoder operator.
+      Tree Ensemble classifier. Returns the top class for each of N inputs.<br>
+      The attributes named 'nodes_X' form a sequence of tuples, associated by
+      index into the sequences, which must all be of equal length. These tuples
+      define the nodes.<br>
+      Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves.
+      A leaf may have multiple votes, where each vote is weighted by
+      the associated class_weights index.<br>
+      One and only one of classlabels_strings or classlabels_int64s
+      will be defined. The class_ids are indices into this list.
+      All fields ending with <i>_as_tensor</i> can be used instead of the
+      same parameter without the suffix if the element type is double and not float.
+
+#### Version
+
+This version of the operator has been deprecated since version 5 of the 'ai.onnx.ml' operator set.
+
+Other versions of this operator: <a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleClassifier-1">1</a>, <a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleClassifier-3">3</a>
+
+
+### <a name="ai.onnx.ml.TreeEnsembleRegressor"></a><a name="ai.onnx.ml.treeensembleregressor">**ai.onnx.ml.TreeEnsembleRegressor** (deprecated)</a>
+
+  This operator is DEPRECATED. Please use TreeEnsemble instead which provides the same
+      functionality.<br>
+      Tree Ensemble regressor.  Returns the regressed values for each input in N.<br>
+      All args with nodes_ are fields of a tuple of tree nodes, and
+      it is assumed they are the same length, and an index i will decode the
+      tuple across these inputs.  Each node id can appear only once
+      for each tree id.<br>
+      All fields prefixed with target_ are tuples of votes at the leaves.<br>
+      A leaf may have multiple votes, where each vote is weighted by
+      the associated target_weights index.<br>
+      All fields ending with <i>_as_tensor</i> can be used instead of the
+      same parameter without the suffix if the element type is double and not float.
+      All trees must have their node ids start at 0 and increment by 1.<br>
+      Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF
+
+#### Version
+
+This version of the operator has been deprecated since version 5 of the 'ai.onnx.ml' operator set.
+
+Other versions of this operator: <a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleRegressor-1">1</a>, <a href="Changelog-ml.md#ai.onnx.ml.TreeEnsembleRegressor-3">3</a>
+
+
+### <a name="ai.onnx.ml.ZipMap"></a><a name="ai.onnx.ml.zipmap">**ai.onnx.ml.ZipMap**</a>
+
+  Creates a map from the input and the attributes.<br>
+      The values are provided by the input tensor, while the keys are specified by the attributes.
+      Must provide keys in either classlabels_strings or classlabels_int64s (but not both).<br>
+      The columns of the tensor correspond one-by-one to the keys specified by the attributes. There must be as many columns as keys.<br>
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.ml' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>classlabels_int64s</tt> : list of ints</dt>
+<dd>The keys when using int keys.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+<dt><tt>classlabels_strings</tt> : list of strings</dt>
+<dd>The keys when using string keys.<br>One and only one of the 'classlabels_*' attributes must be defined.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : tensor(float)</dt>
+<dd>The input values</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> : T</dt>
+<dd>The output map</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : seq(map(string, float)), seq(map(int64, float))</dt>
+<dd>The output will be a sequence of string or integer maps to float.</dd>
+</dl>
+
+
diff --git a/docs/Operators.md b/docs/Operators.md
new file mode 100644
index 0000000..0ee4ec6
--- /dev/null
+++ b/docs/Operators.md
@@ -0,0 +1,44256 @@
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+## Operator Schemas
+*This file is automatically generated from the
+            [def files](/onnx/defs) via [this script](/onnx/defs/gen_doc.py).
+            Do not modify directly and instead edit operator definitions.*
+
+For an operator input/output's differentiability, it can be differentiable,
+            non-differentiable, or undefined. If a variable's differentiability
+            is not specified, that variable has undefined differentiability.
+
+### ai.onnx (default)
+|**Operator**|**Since version**||
+|-|-|-|
+|<a href="#Abs">Abs</a>|<a href="Changelog.md#Abs-13">13</a>, <a href="Changelog.md#Abs-6">6</a>, <a href="Changelog.md#Abs-1">1</a>|
+|<a href="#Acos">Acos</a>|<a href="Changelog.md#Acos-22">22</a>, <a href="Changelog.md#Acos-7">7</a>|
+|<a href="#Acosh">Acosh</a>|<a href="Changelog.md#Acosh-22">22</a>, <a href="Changelog.md#Acosh-9">9</a>|
+|<a href="#Add">Add</a>|<a href="Changelog.md#Add-14">14</a>, <a href="Changelog.md#Add-13">13</a>, <a href="Changelog.md#Add-7">7</a>, <a href="Changelog.md#Add-6">6</a>, <a href="Changelog.md#Add-1">1</a>|
+|<a href="#And">And</a>|<a href="Changelog.md#And-7">7</a>, <a href="Changelog.md#And-1">1</a>|
+|<a href="#ArgMax">ArgMax</a>|<a href="Changelog.md#ArgMax-13">13</a>, <a href="Changelog.md#ArgMax-12">12</a>, <a href="Changelog.md#ArgMax-11">11</a>, <a href="Changelog.md#ArgMax-1">1</a>|
+|<a href="#ArgMin">ArgMin</a>|<a href="Changelog.md#ArgMin-13">13</a>, <a href="Changelog.md#ArgMin-12">12</a>, <a href="Changelog.md#ArgMin-11">11</a>, <a href="Changelog.md#ArgMin-1">1</a>|
+|<a href="#Asin">Asin</a>|<a href="Changelog.md#Asin-22">22</a>, <a href="Changelog.md#Asin-7">7</a>|
+|<a href="#Asinh">Asinh</a>|<a href="Changelog.md#Asinh-22">22</a>, <a href="Changelog.md#Asinh-9">9</a>|
+|<a href="#Atan">Atan</a>|<a href="Changelog.md#Atan-22">22</a>, <a href="Changelog.md#Atan-7">7</a>|
+|<a href="#Atanh">Atanh</a>|<a href="Changelog.md#Atanh-22">22</a>, <a href="Changelog.md#Atanh-9">9</a>|
+|<a href="#AveragePool">AveragePool</a>|<a href="Changelog.md#AveragePool-22">22</a>, <a href="Changelog.md#AveragePool-19">19</a>, <a href="Changelog.md#AveragePool-11">11</a>, <a href="Changelog.md#AveragePool-10">10</a>, <a href="Changelog.md#AveragePool-7">7</a>, <a href="Changelog.md#AveragePool-1">1</a>|
+|<a href="#BatchNormalization">BatchNormalization</a>|<a href="Changelog.md#BatchNormalization-15">15</a>, <a href="Changelog.md#BatchNormalization-14">14</a>, <a href="Changelog.md#BatchNormalization-9">9</a>, <a href="Changelog.md#BatchNormalization-7">7</a>, <a href="Changelog.md#BatchNormalization-6">6</a>, <a href="Changelog.md#BatchNormalization-1">1</a>|
+|<a href="#BitCast">BitCast</a>|<a href="Changelog.md#BitCast-26">26</a>|
+|<a href="#BitShift">BitShift</a>|<a href="Changelog.md#BitShift-11">11</a>|
+|<a href="#BitwiseAnd">BitwiseAnd</a>|<a href="Changelog.md#BitwiseAnd-18">18</a>|
+|<a href="#BitwiseNot">BitwiseNot</a>|<a href="Changelog.md#BitwiseNot-18">18</a>|
+|<a href="#BitwiseOr">BitwiseOr</a>|<a href="Changelog.md#BitwiseOr-18">18</a>|
+|<a href="#BitwiseXor">BitwiseXor</a>|<a href="Changelog.md#BitwiseXor-18">18</a>|
+|<a href="#Cast">Cast</a>|<a href="Changelog.md#Cast-25">25</a>, <a href="Changelog.md#Cast-24">24</a>, <a href="Changelog.md#Cast-23">23</a>, <a href="Changelog.md#Cast-21">21</a>, <a href="Changelog.md#Cast-19">19</a>, <a href="Changelog.md#Cast-13">13</a>, <a href="Changelog.md#Cast-9">9</a>, <a href="Changelog.md#Cast-6">6</a>, <a href="Changelog.md#Cast-1">1</a>|
+|<a href="#Ceil">Ceil</a>|<a href="Changelog.md#Ceil-13">13</a>, <a href="Changelog.md#Ceil-6">6</a>, <a href="Changelog.md#Ceil-1">1</a>|
+|<a href="#Col2Im">Col2Im</a>|<a href="Changelog.md#Col2Im-18">18</a>|
+|<a href="#Compress">Compress</a>|<a href="Changelog.md#Compress-11">11</a>, <a href="Changelog.md#Compress-9">9</a>|
+|<a href="#Concat">Concat</a>|<a href="Changelog.md#Concat-13">13</a>, <a href="Changelog.md#Concat-11">11</a>, <a href="Changelog.md#Concat-4">4</a>, <a href="Changelog.md#Concat-1">1</a>|
+|<a href="#ConcatFromSequence">ConcatFromSequence</a>|<a href="Changelog.md#ConcatFromSequence-11">11</a>|
+|<a href="#Constant">Constant</a>|<a href="Changelog.md#Constant-25">25</a>, <a href="Changelog.md#Constant-24">24</a>, <a href="Changelog.md#Constant-23">23</a>, <a href="Changelog.md#Constant-21">21</a>, <a href="Changelog.md#Constant-19">19</a>, <a href="Changelog.md#Constant-13">13</a>, <a href="Changelog.md#Constant-12">12</a>, <a href="Changelog.md#Constant-11">11</a>, <a href="Changelog.md#Constant-9">9</a>, <a href="Changelog.md#Constant-1">1</a>|
+|<a href="#ConstantOfShape">ConstantOfShape</a>|<a href="Changelog.md#ConstantOfShape-25">25</a>, <a href="Changelog.md#ConstantOfShape-24">24</a>, <a href="Changelog.md#ConstantOfShape-23">23</a>, <a href="Changelog.md#ConstantOfShape-21">21</a>, <a href="Changelog.md#ConstantOfShape-20">20</a>, <a href="Changelog.md#ConstantOfShape-9">9</a>|
+|<a href="#Conv">Conv</a>|<a href="Changelog.md#Conv-22">22</a>, <a href="Changelog.md#Conv-11">11</a>, <a href="Changelog.md#Conv-1">1</a>|
+|<a href="#ConvInteger">ConvInteger</a>|<a href="Changelog.md#ConvInteger-10">10</a>|
+|<a href="#ConvTranspose">ConvTranspose</a>|<a href="Changelog.md#ConvTranspose-22">22</a>, <a href="Changelog.md#ConvTranspose-11">11</a>, <a href="Changelog.md#ConvTranspose-1">1</a>|
+|<a href="#Cos">Cos</a>|<a href="Changelog.md#Cos-22">22</a>, <a href="Changelog.md#Cos-7">7</a>|
+|<a href="#Cosh">Cosh</a>|<a href="Changelog.md#Cosh-22">22</a>, <a href="Changelog.md#Cosh-9">9</a>|
+|<a href="#CumProd">CumProd</a>|<a href="Changelog.md#CumProd-26">26</a>|
+|<a href="#CumSum">CumSum</a>|<a href="Changelog.md#CumSum-14">14</a>, <a href="Changelog.md#CumSum-11">11</a>|
+|<a href="#DFT">DFT</a>|<a href="Changelog.md#DFT-20">20</a>, <a href="Changelog.md#DFT-17">17</a>|
+|<a href="#DeformConv">DeformConv</a>|<a href="Changelog.md#DeformConv-22">22</a>, <a href="Changelog.md#DeformConv-19">19</a>|
+|<a href="#DepthToSpace">DepthToSpace</a>|<a href="Changelog.md#DepthToSpace-13">13</a>, <a href="Changelog.md#DepthToSpace-11">11</a>, <a href="Changelog.md#DepthToSpace-1">1</a>|
+|<a href="#DequantizeLinear">DequantizeLinear</a>|<a href="Changelog.md#DequantizeLinear-25">25</a>, <a href="Changelog.md#DequantizeLinear-24">24</a>, <a href="Changelog.md#DequantizeLinear-23">23</a>, <a href="Changelog.md#DequantizeLinear-21">21</a>, <a href="Changelog.md#DequantizeLinear-19">19</a>, <a href="Changelog.md#DequantizeLinear-13">13</a>, <a href="Changelog.md#DequantizeLinear-10">10</a>|
+|<a href="#Det">Det</a>|<a href="Changelog.md#Det-22">22</a>, <a href="Changelog.md#Det-11">11</a>|
+|<a href="#Div">Div</a>|<a href="Changelog.md#Div-14">14</a>, <a href="Changelog.md#Div-13">13</a>, <a href="Changelog.md#Div-7">7</a>, <a href="Changelog.md#Div-6">6</a>, <a href="Changelog.md#Div-1">1</a>|
+|<a href="#Dropout">Dropout</a>|<a href="Changelog.md#Dropout-22">22</a>, <a href="Changelog.md#Dropout-13">13</a>, <a href="Changelog.md#Dropout-12">12</a>, <a href="Changelog.md#Dropout-10">10</a>, <a href="Changelog.md#Dropout-7">7</a>, <a href="Changelog.md#Dropout-6">6</a>, <a href="Changelog.md#Dropout-1">1</a>|
+|<a href="#Einsum">Einsum</a>|<a href="Changelog.md#Einsum-12">12</a>|
+|<a href="#Equal">Equal</a>|<a href="Changelog.md#Equal-19">19</a>, <a href="Changelog.md#Equal-13">13</a>, <a href="Changelog.md#Equal-11">11</a>, <a href="Changelog.md#Equal-7">7</a>, <a href="Changelog.md#Equal-1">1</a>|
+|<a href="#Erf">Erf</a>|<a href="Changelog.md#Erf-13">13</a>, <a href="Changelog.md#Erf-9">9</a>|
+|<a href="#Exp">Exp</a>|<a href="Changelog.md#Exp-13">13</a>, <a href="Changelog.md#Exp-6">6</a>, <a href="Changelog.md#Exp-1">1</a>|
+|<a href="#Expand">Expand</a>|<a href="Changelog.md#Expand-13">13</a>, <a href="Changelog.md#Expand-8">8</a>|
+|<a href="#EyeLike">EyeLike</a>|<a href="Changelog.md#EyeLike-22">22</a>, <a href="Changelog.md#EyeLike-9">9</a>|
+|<a href="#Flatten">Flatten</a>|<a href="Changelog.md#Flatten-25">25</a>, <a href="Changelog.md#Flatten-24">24</a>, <a href="Changelog.md#Flatten-23">23</a>, <a href="Changelog.md#Flatten-21">21</a>, <a href="Changelog.md#Flatten-13">13</a>, <a href="Changelog.md#Flatten-11">11</a>, <a href="Changelog.md#Flatten-9">9</a>, <a href="Changelog.md#Flatten-1">1</a>|
+|<a href="#Floor">Floor</a>|<a href="Changelog.md#Floor-13">13</a>, <a href="Changelog.md#Floor-6">6</a>, <a href="Changelog.md#Floor-1">1</a>|
+|<a href="#GRU">GRU</a>|<a href="Changelog.md#GRU-22">22</a>, <a href="Changelog.md#GRU-14">14</a>, <a href="Changelog.md#GRU-7">7</a>, <a href="Changelog.md#GRU-3">3</a>, <a href="Changelog.md#GRU-1">1</a>|
+|<a href="#Gather">Gather</a>|<a href="Changelog.md#Gather-13">13</a>, <a href="Changelog.md#Gather-11">11</a>, <a href="Changelog.md#Gather-1">1</a>|
+|<a href="#GatherElements">GatherElements</a>|<a href="Changelog.md#GatherElements-13">13</a>, <a href="Changelog.md#GatherElements-11">11</a>|
+|<a href="#GatherND">GatherND</a>|<a href="Changelog.md#GatherND-13">13</a>, <a href="Changelog.md#GatherND-12">12</a>, <a href="Changelog.md#GatherND-11">11</a>|
+|<a href="#Gemm">Gemm</a>|<a href="Changelog.md#Gemm-13">13</a>, <a href="Changelog.md#Gemm-11">11</a>, <a href="Changelog.md#Gemm-9">9</a>, <a href="Changelog.md#Gemm-7">7</a>, <a href="Changelog.md#Gemm-6">6</a>, <a href="Changelog.md#Gemm-1">1</a>|
+|<a href="#GlobalAveragePool">GlobalAveragePool</a>|<a href="Changelog.md#GlobalAveragePool-22">22</a>, <a href="Changelog.md#GlobalAveragePool-1">1</a>|
+|<a href="#GlobalLpPool">GlobalLpPool</a>|<a href="Changelog.md#GlobalLpPool-22">22</a>, <a href="Changelog.md#GlobalLpPool-2">2</a>, <a href="Changelog.md#GlobalLpPool-1">1</a>|
+|<a href="#GlobalMaxPool">GlobalMaxPool</a>|<a href="Changelog.md#GlobalMaxPool-22">22</a>, <a href="Changelog.md#GlobalMaxPool-1">1</a>|
+|<a href="#Greater">Greater</a>|<a href="Changelog.md#Greater-13">13</a>, <a href="Changelog.md#Greater-9">9</a>, <a href="Changelog.md#Greater-7">7</a>, <a href="Changelog.md#Greater-1">1</a>|
+|<a href="#GridSample">GridSample</a>|<a href="Changelog.md#GridSample-22">22</a>, <a href="Changelog.md#GridSample-20">20</a>, <a href="Changelog.md#GridSample-16">16</a>|
+|<a href="#Hardmax">Hardmax</a>|<a href="Changelog.md#Hardmax-13">13</a>, <a href="Changelog.md#Hardmax-11">11</a>, <a href="Changelog.md#Hardmax-1">1</a>|
+|<a href="#Identity">Identity</a>|<a href="Changelog.md#Identity-25">25</a>, <a href="Changelog.md#Identity-24">24</a>, <a href="Changelog.md#Identity-23">23</a>, <a href="Changelog.md#Identity-21">21</a>, <a href="Changelog.md#Identity-19">19</a>, <a href="Changelog.md#Identity-16">16</a>, <a href="Changelog.md#Identity-14">14</a>, <a href="Changelog.md#Identity-13">13</a>, <a href="Changelog.md#Identity-1">1</a>|
+|<a href="#If">If</a>|<a href="Changelog.md#If-25">25</a>, <a href="Changelog.md#If-24">24</a>, <a href="Changelog.md#If-23">23</a>, <a href="Changelog.md#If-21">21</a>, <a href="Changelog.md#If-19">19</a>, <a href="Changelog.md#If-16">16</a>, <a href="Changelog.md#If-13">13</a>, <a href="Changelog.md#If-11">11</a>, <a href="Changelog.md#If-1">1</a>|
+|<a href="#ImageDecoder">ImageDecoder</a>|<a href="Changelog.md#ImageDecoder-20">20</a>|
+|<a href="#InstanceNormalization">InstanceNormalization</a>|<a href="Changelog.md#InstanceNormalization-22">22</a>, <a href="Changelog.md#InstanceNormalization-6">6</a>, <a href="Changelog.md#InstanceNormalization-1">1</a>|
+|<a href="#IsInf">IsInf</a>|<a href="Changelog.md#IsInf-20">20</a>, <a href="Changelog.md#IsInf-10">10</a>|
+|<a href="#IsNaN">IsNaN</a>|<a href="Changelog.md#IsNaN-20">20</a>, <a href="Changelog.md#IsNaN-13">13</a>, <a href="Changelog.md#IsNaN-9">9</a>|
+|<a href="#LRN">LRN</a>|<a href="Changelog.md#LRN-13">13</a>, <a href="Changelog.md#LRN-1">1</a>|
+|<a href="#LSTM">LSTM</a>|<a href="Changelog.md#LSTM-22">22</a>, <a href="Changelog.md#LSTM-14">14</a>, <a href="Changelog.md#LSTM-7">7</a>, <a href="Changelog.md#LSTM-1">1</a>|
+|<a href="#Less">Less</a>|<a href="Changelog.md#Less-13">13</a>, <a href="Changelog.md#Less-9">9</a>, <a href="Changelog.md#Less-7">7</a>, <a href="Changelog.md#Less-1">1</a>|
+|<a href="#Log">Log</a>|<a href="Changelog.md#Log-13">13</a>, <a href="Changelog.md#Log-6">6</a>, <a href="Changelog.md#Log-1">1</a>|
+|<a href="#Loop">Loop</a>|<a href="Changelog.md#Loop-25">25</a>, <a href="Changelog.md#Loop-24">24</a>, <a href="Changelog.md#Loop-23">23</a>, <a href="Changelog.md#Loop-21">21</a>, <a href="Changelog.md#Loop-19">19</a>, <a href="Changelog.md#Loop-16">16</a>, <a href="Changelog.md#Loop-13">13</a>, <a href="Changelog.md#Loop-11">11</a>, <a href="Changelog.md#Loop-1">1</a>|
+|<a href="#LpNormalization">LpNormalization</a>|<a href="Changelog.md#LpNormalization-22">22</a>, <a href="Changelog.md#LpNormalization-1">1</a>|
+|<a href="#LpPool">LpPool</a>|<a href="Changelog.md#LpPool-22">22</a>, <a href="Changelog.md#LpPool-18">18</a>, <a href="Changelog.md#LpPool-11">11</a>, <a href="Changelog.md#LpPool-2">2</a>, <a href="Changelog.md#LpPool-1">1</a>|
+|<a href="#MatMul">MatMul</a>|<a href="Changelog.md#MatMul-13">13</a>, <a href="Changelog.md#MatMul-9">9</a>, <a href="Changelog.md#MatMul-1">1</a>|
+|<a href="#MatMulInteger">MatMulInteger</a>|<a href="Changelog.md#MatMulInteger-10">10</a>|
+|<a href="#Max">Max</a>|<a href="Changelog.md#Max-13">13</a>, <a href="Changelog.md#Max-12">12</a>, <a href="Changelog.md#Max-8">8</a>, <a href="Changelog.md#Max-6">6</a>, <a href="Changelog.md#Max-1">1</a>|
+|<a href="#MaxPool">MaxPool</a>|<a href="Changelog.md#MaxPool-22">22</a>, <a href="Changelog.md#MaxPool-12">12</a>, <a href="Changelog.md#MaxPool-11">11</a>, <a href="Changelog.md#MaxPool-10">10</a>, <a href="Changelog.md#MaxPool-8">8</a>, <a href="Changelog.md#MaxPool-1">1</a>|
+|<a href="#MaxRoiPool">MaxRoiPool</a>|<a href="Changelog.md#MaxRoiPool-22">22</a>, <a href="Changelog.md#MaxRoiPool-1">1</a>|
+|<a href="#MaxUnpool">MaxUnpool</a>|<a href="Changelog.md#MaxUnpool-22">22</a>, <a href="Changelog.md#MaxUnpool-11">11</a>, <a href="Changelog.md#MaxUnpool-9">9</a>|
+|<a href="#Mean">Mean</a>|<a href="Changelog.md#Mean-13">13</a>, <a href="Changelog.md#Mean-8">8</a>, <a href="Changelog.md#Mean-6">6</a>, <a href="Changelog.md#Mean-1">1</a>|
+|<a href="#MelWeightMatrix">MelWeightMatrix</a>|<a href="Changelog.md#MelWeightMatrix-17">17</a>|
+|<a href="#Min">Min</a>|<a href="Changelog.md#Min-13">13</a>, <a href="Changelog.md#Min-12">12</a>, <a href="Changelog.md#Min-8">8</a>, <a href="Changelog.md#Min-6">6</a>, <a href="Changelog.md#Min-1">1</a>|
+|<a href="#Mod">Mod</a>|<a href="Changelog.md#Mod-13">13</a>, <a href="Changelog.md#Mod-10">10</a>|
+|<a href="#Mul">Mul</a>|<a href="Changelog.md#Mul-14">14</a>, <a href="Changelog.md#Mul-13">13</a>, <a href="Changelog.md#Mul-7">7</a>, <a href="Changelog.md#Mul-6">6</a>, <a href="Changelog.md#Mul-1">1</a>|
+|<a href="#Multinomial">Multinomial</a>|<a href="Changelog.md#Multinomial-22">22</a>, <a href="Changelog.md#Multinomial-7">7</a>|
+|<a href="#Neg">Neg</a>|<a href="Changelog.md#Neg-13">13</a>, <a href="Changelog.md#Neg-6">6</a>, <a href="Changelog.md#Neg-1">1</a>|
+|<a href="#NonMaxSuppression">NonMaxSuppression</a>|<a href="Changelog.md#NonMaxSuppression-11">11</a>, <a href="Changelog.md#NonMaxSuppression-10">10</a>|
+|<a href="#NonZero">NonZero</a>|<a href="Changelog.md#NonZero-13">13</a>, <a href="Changelog.md#NonZero-9">9</a>|
+|<a href="#Not">Not</a>|<a href="Changelog.md#Not-1">1</a>|
+|<a href="#OneHot">OneHot</a>|<a href="Changelog.md#OneHot-11">11</a>, <a href="Changelog.md#OneHot-9">9</a>|
+|<a href="#Optional">Optional</a>|<a href="Changelog.md#Optional-15">15</a>|
+|<a href="#OptionalGetElement">OptionalGetElement</a>|<a href="Changelog.md#OptionalGetElement-18">18</a>, <a href="Changelog.md#OptionalGetElement-15">15</a>|
+|<a href="#OptionalHasElement">OptionalHasElement</a>|<a href="Changelog.md#OptionalHasElement-18">18</a>, <a href="Changelog.md#OptionalHasElement-15">15</a>|
+|<a href="#Or">Or</a>|<a href="Changelog.md#Or-7">7</a>, <a href="Changelog.md#Or-1">1</a>|
+|<a href="#Pad">Pad</a>|<a href="Changelog.md#Pad-25">25</a>, <a href="Changelog.md#Pad-24">24</a>, <a href="Changelog.md#Pad-23">23</a>, <a href="Changelog.md#Pad-21">21</a>, <a href="Changelog.md#Pad-19">19</a>, <a href="Changelog.md#Pad-18">18</a>, <a href="Changelog.md#Pad-13">13</a>, <a href="Changelog.md#Pad-11">11</a>, <a href="Changelog.md#Pad-2">2</a>, <a href="Changelog.md#Pad-1">1</a>|
+|<a href="#Pow">Pow</a>|<a href="Changelog.md#Pow-15">15</a>, <a href="Changelog.md#Pow-13">13</a>, <a href="Changelog.md#Pow-12">12</a>, <a href="Changelog.md#Pow-7">7</a>, <a href="Changelog.md#Pow-1">1</a>|
+|<a href="#QLinearConv">QLinearConv</a>|<a href="Changelog.md#QLinearConv-10">10</a>|
+|<a href="#QLinearMatMul">QLinearMatMul</a>|<a href="Changelog.md#QLinearMatMul-21">21</a>, <a href="Changelog.md#QLinearMatMul-10">10</a>|
+|<a href="#QuantizeLinear">QuantizeLinear</a>|<a href="Changelog.md#QuantizeLinear-25">25</a>, <a href="Changelog.md#QuantizeLinear-24">24</a>, <a href="Changelog.md#QuantizeLinear-23">23</a>, <a href="Changelog.md#QuantizeLinear-21">21</a>, <a href="Changelog.md#QuantizeLinear-19">19</a>, <a href="Changelog.md#QuantizeLinear-13">13</a>, <a href="Changelog.md#QuantizeLinear-10">10</a>|
+|<a href="#RNN">RNN</a>|<a href="Changelog.md#RNN-22">22</a>, <a href="Changelog.md#RNN-14">14</a>, <a href="Changelog.md#RNN-7">7</a>, <a href="Changelog.md#RNN-1">1</a>|
+|<a href="#RandomNormal">RandomNormal</a>|<a href="Changelog.md#RandomNormal-22">22</a>, <a href="Changelog.md#RandomNormal-1">1</a>|
+|<a href="#RandomNormalLike">RandomNormalLike</a>|<a href="Changelog.md#RandomNormalLike-22">22</a>, <a href="Changelog.md#RandomNormalLike-1">1</a>|
+|<a href="#RandomUniform">RandomUniform</a>|<a href="Changelog.md#RandomUniform-22">22</a>, <a href="Changelog.md#RandomUniform-1">1</a>|
+|<a href="#RandomUniformLike">RandomUniformLike</a>|<a href="Changelog.md#RandomUniformLike-22">22</a>, <a href="Changelog.md#RandomUniformLike-1">1</a>|
+|<a href="#Reciprocal">Reciprocal</a>|<a href="Changelog.md#Reciprocal-13">13</a>, <a href="Changelog.md#Reciprocal-6">6</a>, <a href="Changelog.md#Reciprocal-1">1</a>|
+|<a href="#ReduceMax">ReduceMax</a>|<a href="Changelog.md#ReduceMax-20">20</a>, <a href="Changelog.md#ReduceMax-18">18</a>, <a href="Changelog.md#ReduceMax-13">13</a>, <a href="Changelog.md#ReduceMax-12">12</a>, <a href="Changelog.md#ReduceMax-11">11</a>, <a href="Changelog.md#ReduceMax-1">1</a>|
+|<a href="#ReduceMean">ReduceMean</a>|<a href="Changelog.md#ReduceMean-18">18</a>, <a href="Changelog.md#ReduceMean-13">13</a>, <a href="Changelog.md#ReduceMean-11">11</a>, <a href="Changelog.md#ReduceMean-1">1</a>|
+|<a href="#ReduceMin">ReduceMin</a>|<a href="Changelog.md#ReduceMin-20">20</a>, <a href="Changelog.md#ReduceMin-18">18</a>, <a href="Changelog.md#ReduceMin-13">13</a>, <a href="Changelog.md#ReduceMin-12">12</a>, <a href="Changelog.md#ReduceMin-11">11</a>, <a href="Changelog.md#ReduceMin-1">1</a>|
+|<a href="#ReduceProd">ReduceProd</a>|<a href="Changelog.md#ReduceProd-18">18</a>, <a href="Changelog.md#ReduceProd-13">13</a>, <a href="Changelog.md#ReduceProd-11">11</a>, <a href="Changelog.md#ReduceProd-1">1</a>|
+|<a href="#ReduceSum">ReduceSum</a>|<a href="Changelog.md#ReduceSum-13">13</a>, <a href="Changelog.md#ReduceSum-11">11</a>, <a href="Changelog.md#ReduceSum-1">1</a>|
+|<a href="#RegexFullMatch">RegexFullMatch</a>|<a href="Changelog.md#RegexFullMatch-20">20</a>|
+|<a href="#Reshape">Reshape</a>|<a href="Changelog.md#Reshape-25">25</a>, <a href="Changelog.md#Reshape-24">24</a>, <a href="Changelog.md#Reshape-23">23</a>, <a href="Changelog.md#Reshape-21">21</a>, <a href="Changelog.md#Reshape-19">19</a>, <a href="Changelog.md#Reshape-14">14</a>, <a href="Changelog.md#Reshape-13">13</a>, <a href="Changelog.md#Reshape-5">5</a>, <a href="Changelog.md#Reshape-1">1</a>|
+|<a href="#Resize">Resize</a>|<a href="Changelog.md#Resize-19">19</a>, <a href="Changelog.md#Resize-18">18</a>, <a href="Changelog.md#Resize-13">13</a>, <a href="Changelog.md#Resize-11">11</a>, <a href="Changelog.md#Resize-10">10</a>|
+|<a href="#ReverseSequence">ReverseSequence</a>|<a href="Changelog.md#ReverseSequence-10">10</a>|
+|<a href="#RoiAlign">RoiAlign</a>|<a href="Changelog.md#RoiAlign-22">22</a>, <a href="Changelog.md#RoiAlign-16">16</a>, <a href="Changelog.md#RoiAlign-10">10</a>|
+|<a href="#Round">Round</a>|<a href="Changelog.md#Round-22">22</a>, <a href="Changelog.md#Round-11">11</a>|
+|<a href="#STFT">STFT</a>|<a href="Changelog.md#STFT-17">17</a>|
+|<a href="#Scan">Scan</a>|<a href="Changelog.md#Scan-25">25</a>, <a href="Changelog.md#Scan-24">24</a>, <a href="Changelog.md#Scan-23">23</a>, <a href="Changelog.md#Scan-21">21</a>, <a href="Changelog.md#Scan-19">19</a>, <a href="Changelog.md#Scan-16">16</a>, <a href="Changelog.md#Scan-11">11</a>, <a href="Changelog.md#Scan-9">9</a>, <a href="Changelog.md#Scan-8">8</a>|
+|<a href="#Scatter">Scatter</a> (deprecated)|<a href="Changelog.md#Scatter-11">11</a>, <a href="Changelog.md#Scatter-9">9</a>|
+|<a href="#ScatterElements">ScatterElements</a>|<a href="Changelog.md#ScatterElements-18">18</a>, <a href="Changelog.md#ScatterElements-16">16</a>, <a href="Changelog.md#ScatterElements-13">13</a>, <a href="Changelog.md#ScatterElements-11">11</a>|
+|<a href="#ScatterND">ScatterND</a>|<a href="Changelog.md#ScatterND-18">18</a>, <a href="Changelog.md#ScatterND-16">16</a>, <a href="Changelog.md#ScatterND-13">13</a>, <a href="Changelog.md#ScatterND-11">11</a>|
+|<a href="#SequenceAt">SequenceAt</a>|<a href="Changelog.md#SequenceAt-11">11</a>|
+|<a href="#SequenceConstruct">SequenceConstruct</a>|<a href="Changelog.md#SequenceConstruct-11">11</a>|
+|<a href="#SequenceEmpty">SequenceEmpty</a>|<a href="Changelog.md#SequenceEmpty-11">11</a>|
+|<a href="#SequenceErase">SequenceErase</a>|<a href="Changelog.md#SequenceErase-11">11</a>|
+|<a href="#SequenceInsert">SequenceInsert</a>|<a href="Changelog.md#SequenceInsert-11">11</a>|
+|<a href="#SequenceLength">SequenceLength</a>|<a href="Changelog.md#SequenceLength-11">11</a>|
+|<a href="#Shape">Shape</a>|<a href="Changelog.md#Shape-25">25</a>, <a href="Changelog.md#Shape-24">24</a>, <a href="Changelog.md#Shape-23">23</a>, <a href="Changelog.md#Shape-21">21</a>, <a href="Changelog.md#Shape-19">19</a>, <a href="Changelog.md#Shape-15">15</a>, <a href="Changelog.md#Shape-13">13</a>, <a href="Changelog.md#Shape-1">1</a>|
+|<a href="#Sigmoid">Sigmoid</a>|<a href="Changelog.md#Sigmoid-13">13</a>, <a href="Changelog.md#Sigmoid-6">6</a>, <a href="Changelog.md#Sigmoid-1">1</a>|
+|<a href="#Sign">Sign</a>|<a href="Changelog.md#Sign-13">13</a>, <a href="Changelog.md#Sign-9">9</a>|
+|<a href="#Sin">Sin</a>|<a href="Changelog.md#Sin-22">22</a>, <a href="Changelog.md#Sin-7">7</a>|
+|<a href="#Sinh">Sinh</a>|<a href="Changelog.md#Sinh-22">22</a>, <a href="Changelog.md#Sinh-9">9</a>|
+|<a href="#Size">Size</a>|<a href="Changelog.md#Size-25">25</a>, <a href="Changelog.md#Size-24">24</a>, <a href="Changelog.md#Size-23">23</a>, <a href="Changelog.md#Size-21">21</a>, <a href="Changelog.md#Size-19">19</a>, <a href="Changelog.md#Size-13">13</a>, <a href="Changelog.md#Size-1">1</a>|
+|<a href="#Slice">Slice</a>|<a href="Changelog.md#Slice-13">13</a>, <a href="Changelog.md#Slice-11">11</a>, <a href="Changelog.md#Slice-10">10</a>, <a href="Changelog.md#Slice-1">1</a>|
+|<a href="#SpaceToDepth">SpaceToDepth</a>|<a href="Changelog.md#SpaceToDepth-13">13</a>, <a href="Changelog.md#SpaceToDepth-1">1</a>|
+|<a href="#Split">Split</a>|<a href="Changelog.md#Split-18">18</a>, <a href="Changelog.md#Split-13">13</a>, <a href="Changelog.md#Split-11">11</a>, <a href="Changelog.md#Split-2">2</a>, <a href="Changelog.md#Split-1">1</a>|
+|<a href="#SplitToSequence">SplitToSequence</a>|<a href="Changelog.md#SplitToSequence-24">24</a>, <a href="Changelog.md#SplitToSequence-11">11</a>|
+|<a href="#Sqrt">Sqrt</a>|<a href="Changelog.md#Sqrt-13">13</a>, <a href="Changelog.md#Sqrt-6">6</a>, <a href="Changelog.md#Sqrt-1">1</a>|
+|<a href="#Squeeze">Squeeze</a>|<a href="Changelog.md#Squeeze-25">25</a>, <a href="Changelog.md#Squeeze-24">24</a>, <a href="Changelog.md#Squeeze-23">23</a>, <a href="Changelog.md#Squeeze-21">21</a>, <a href="Changelog.md#Squeeze-13">13</a>, <a href="Changelog.md#Squeeze-11">11</a>, <a href="Changelog.md#Squeeze-1">1</a>|
+|<a href="#StringConcat">StringConcat</a>|<a href="Changelog.md#StringConcat-20">20</a>|
+|<a href="#StringNormalizer">StringNormalizer</a>|<a href="Changelog.md#StringNormalizer-10">10</a>|
+|<a href="#StringSplit">StringSplit</a>|<a href="Changelog.md#StringSplit-20">20</a>|
+|<a href="#Sub">Sub</a>|<a href="Changelog.md#Sub-14">14</a>, <a href="Changelog.md#Sub-13">13</a>, <a href="Changelog.md#Sub-7">7</a>, <a href="Changelog.md#Sub-6">6</a>, <a href="Changelog.md#Sub-1">1</a>|
+|<a href="#Sum">Sum</a>|<a href="Changelog.md#Sum-13">13</a>, <a href="Changelog.md#Sum-8">8</a>, <a href="Changelog.md#Sum-6">6</a>, <a href="Changelog.md#Sum-1">1</a>|
+|<a href="#Tan">Tan</a>|<a href="Changelog.md#Tan-22">22</a>, <a href="Changelog.md#Tan-7">7</a>|
+|<a href="#Tanh">Tanh</a>|<a href="Changelog.md#Tanh-13">13</a>, <a href="Changelog.md#Tanh-6">6</a>, <a href="Changelog.md#Tanh-1">1</a>|
+|<a href="#TensorScatter">TensorScatter</a>|<a href="Changelog.md#TensorScatter-24">24</a>|
+|<a href="#TfIdfVectorizer">TfIdfVectorizer</a>|<a href="Changelog.md#TfIdfVectorizer-9">9</a>|
+|<a href="#Tile">Tile</a>|<a href="Changelog.md#Tile-13">13</a>, <a href="Changelog.md#Tile-6">6</a>, <a href="Changelog.md#Tile-1">1</a>|
+|<a href="#TopK">TopK</a>|<a href="Changelog.md#TopK-24">24</a>, <a href="Changelog.md#TopK-11">11</a>, <a href="Changelog.md#TopK-10">10</a>, <a href="Changelog.md#TopK-1">1</a>|
+|<a href="#Transpose">Transpose</a>|<a href="Changelog.md#Transpose-25">25</a>, <a href="Changelog.md#Transpose-24">24</a>, <a href="Changelog.md#Transpose-23">23</a>, <a href="Changelog.md#Transpose-21">21</a>, <a href="Changelog.md#Transpose-13">13</a>, <a href="Changelog.md#Transpose-1">1</a>|
+|<a href="#Trilu">Trilu</a>|<a href="Changelog.md#Trilu-14">14</a>|
+|<a href="#Unique">Unique</a>|<a href="Changelog.md#Unique-11">11</a>|
+|<a href="#Unsqueeze">Unsqueeze</a>|<a href="Changelog.md#Unsqueeze-25">25</a>, <a href="Changelog.md#Unsqueeze-24">24</a>, <a href="Changelog.md#Unsqueeze-23">23</a>, <a href="Changelog.md#Unsqueeze-21">21</a>, <a href="Changelog.md#Unsqueeze-13">13</a>, <a href="Changelog.md#Unsqueeze-11">11</a>, <a href="Changelog.md#Unsqueeze-1">1</a>|
+|<a href="#Upsample">Upsample</a> (deprecated)|<a href="Changelog.md#Upsample-10">10</a>, <a href="Changelog.md#Upsample-9">9</a>, <a href="Changelog.md#Upsample-7">7</a>|
+|<a href="#Where">Where</a>|<a href="Changelog.md#Where-16">16</a>, <a href="Changelog.md#Where-9">9</a>|
+|<a href="#Xor">Xor</a>|<a href="Changelog.md#Xor-7">7</a>, <a href="Changelog.md#Xor-1">1</a>|
+|**Function**|**Since version**|**Function version**|
+|<a href="#AffineGrid">AffineGrid</a>|<a href="Changelog.md#AffineGrid-20">20</a>|20|
+|<a href="#Attention">Attention</a>|<a href="Changelog.md#Attention-24">24</a>, <a href="Changelog.md#Attention-23">23</a>|24|
+|<a href="#Bernoulli">Bernoulli</a>|<a href="Changelog.md#Bernoulli-22">22</a>, <a href="Changelog.md#Bernoulli-15">15</a>|22|
+|<a href="#BlackmanWindow">BlackmanWindow</a>|<a href="Changelog.md#BlackmanWindow-17">17</a>|17|
+|<a href="#CastLike">CastLike</a>|<a href="Changelog.md#CastLike-25">25</a>, <a href="Changelog.md#CastLike-24">24</a>, <a href="Changelog.md#CastLike-23">23</a>, <a href="Changelog.md#CastLike-21">21</a>, <a href="Changelog.md#CastLike-19">19</a>, <a href="Changelog.md#CastLike-15">15</a>|25|
+|<a href="#CausalConvWithState">CausalConvWithState</a>|<a href="Changelog.md#CausalConvWithState-27">27</a>|27|
+|<a href="#Celu">Celu</a>|<a href="Changelog.md#Celu-28">28</a>, <a href="Changelog.md#Celu-12">12</a>|28|
+|<a href="#CenterCropPad">CenterCropPad</a>|<a href="Changelog.md#CenterCropPad-18">18</a>|18|
+|<a href="#Clip">Clip</a>|<a href="Changelog.md#Clip-13">13</a>, <a href="Changelog.md#Clip-12">12</a>, <a href="Changelog.md#Clip-11">11</a>, <a href="Changelog.md#Clip-6">6</a>, <a href="Changelog.md#Clip-1">1</a>|13|
+|<a href="#DynamicQuantizeLinear">DynamicQuantizeLinear</a>|<a href="Changelog.md#DynamicQuantizeLinear-11">11</a>|11|
+|<a href="#Elu">Elu</a>|<a href="Changelog.md#Elu-22">22</a>, <a href="Changelog.md#Elu-6">6</a>, <a href="Changelog.md#Elu-1">1</a>|18|
+|<a href="#Gelu">Gelu</a>|<a href="Changelog.md#Gelu-20">20</a>|20|
+|<a href="#GreaterOrEqual">GreaterOrEqual</a>|<a href="Changelog.md#GreaterOrEqual-16">16</a>, <a href="Changelog.md#GreaterOrEqual-12">12</a>|16|
+|<a href="#GroupNormalization">GroupNormalization</a>|<a href="Changelog.md#GroupNormalization-21">21</a>, <a href="Changelog.md#GroupNormalization-18">18</a>|21|
+|<a href="#HammingWindow">HammingWindow</a>|<a href="Changelog.md#HammingWindow-17">17</a>|17|
+|<a href="#HannWindow">HannWindow</a>|<a href="Changelog.md#HannWindow-17">17</a>|17|
+|<a href="#HardSigmoid">HardSigmoid</a>|<a href="Changelog.md#HardSigmoid-22">22</a>, <a href="Changelog.md#HardSigmoid-6">6</a>, <a href="Changelog.md#HardSigmoid-1">1</a>|18|
+|<a href="#HardSwish">HardSwish</a>|<a href="Changelog.md#HardSwish-22">22</a>, <a href="Changelog.md#HardSwish-14">14</a>|22|
+|<a href="#LayerNormalization">LayerNormalization</a>|<a href="Changelog.md#LayerNormalization-17">17</a>|17, 18|
+|<a href="#LeakyRelu">LeakyRelu</a>|<a href="Changelog.md#LeakyRelu-16">16</a>, <a href="Changelog.md#LeakyRelu-6">6</a>, <a href="Changelog.md#LeakyRelu-1">1</a>|16|
+|<a href="#LessOrEqual">LessOrEqual</a>|<a href="Changelog.md#LessOrEqual-16">16</a>, <a href="Changelog.md#LessOrEqual-12">12</a>|16|
+|<a href="#LinearAttention">LinearAttention</a>|<a href="Changelog.md#LinearAttention-27">27</a>|27|
+|<a href="#LogSoftmax">LogSoftmax</a>|<a href="Changelog.md#LogSoftmax-13">13</a>, <a href="Changelog.md#LogSoftmax-11">11</a>, <a href="Changelog.md#LogSoftmax-1">1</a>|13, 18|
+|<a href="#MeanVarianceNormalization">MeanVarianceNormalization</a>|<a href="Changelog.md#MeanVarianceNormalization-13">13</a>, <a href="Changelog.md#MeanVarianceNormalization-9">9</a>|13, 18|
+|<a href="#Mish">Mish</a>|<a href="Changelog.md#Mish-22">22</a>, <a href="Changelog.md#Mish-18">18</a>|22|
+|<a href="#NegativeLogLikelihoodLoss">NegativeLogLikelihoodLoss</a>|<a href="Changelog.md#NegativeLogLikelihoodLoss-22">22</a>, <a href="Changelog.md#NegativeLogLikelihoodLoss-13">13</a>, <a href="Changelog.md#NegativeLogLikelihoodLoss-12">12</a>|22|
+|<a href="#PRelu">PRelu</a>|<a href="Changelog.md#PRelu-16">16</a>, <a href="Changelog.md#PRelu-9">9</a>, <a href="Changelog.md#PRelu-7">7</a>, <a href="Changelog.md#PRelu-6">6</a>, <a href="Changelog.md#PRelu-1">1</a>|16|
+|<a href="#RMSNormalization">RMSNormalization</a>|<a href="Changelog.md#RMSNormalization-23">23</a>|23|
+|<a href="#Range">Range</a>|<a href="Changelog.md#Range-27">27</a>, <a href="Changelog.md#Range-11">11</a>|27|
+|<a href="#ReduceL1">ReduceL1</a>|<a href="Changelog.md#ReduceL1-18">18</a>, <a href="Changelog.md#ReduceL1-13">13</a>, <a href="Changelog.md#ReduceL1-11">11</a>, <a href="Changelog.md#ReduceL1-1">1</a>|18|
+|<a href="#ReduceL2">ReduceL2</a>|<a href="Changelog.md#ReduceL2-18">18</a>, <a href="Changelog.md#ReduceL2-13">13</a>, <a href="Changelog.md#ReduceL2-11">11</a>, <a href="Changelog.md#ReduceL2-1">1</a>|18|
+|<a href="#ReduceLogSum">ReduceLogSum</a>|<a href="Changelog.md#ReduceLogSum-18">18</a>, <a href="Changelog.md#ReduceLogSum-13">13</a>, <a href="Changelog.md#ReduceLogSum-11">11</a>, <a href="Changelog.md#ReduceLogSum-1">1</a>|18|
+|<a href="#ReduceLogSumExp">ReduceLogSumExp</a>|<a href="Changelog.md#ReduceLogSumExp-18">18</a>, <a href="Changelog.md#ReduceLogSumExp-13">13</a>, <a href="Changelog.md#ReduceLogSumExp-11">11</a>, <a href="Changelog.md#ReduceLogSumExp-1">1</a>|18|
+|<a href="#ReduceSumSquare">ReduceSumSquare</a>|<a href="Changelog.md#ReduceSumSquare-18">18</a>, <a href="Changelog.md#ReduceSumSquare-13">13</a>, <a href="Changelog.md#ReduceSumSquare-11">11</a>, <a href="Changelog.md#ReduceSumSquare-1">1</a>|18|
+|<a href="#Relu">Relu</a>|<a href="Changelog.md#Relu-14">14</a>, <a href="Changelog.md#Relu-13">13</a>, <a href="Changelog.md#Relu-6">6</a>, <a href="Changelog.md#Relu-1">1</a>|18|
+|<a href="#RotaryEmbedding">RotaryEmbedding</a>|<a href="Changelog.md#RotaryEmbedding-23">23</a>|23|
+|<a href="#Selu">Selu</a>|<a href="Changelog.md#Selu-22">22</a>, <a href="Changelog.md#Selu-6">6</a>, <a href="Changelog.md#Selu-1">1</a>|18|
+|<a href="#SequenceMap">SequenceMap</a>|<a href="Changelog.md#SequenceMap-17">17</a>|17|
+|<a href="#Shrink">Shrink</a>|<a href="Changelog.md#Shrink-9">9</a>|18|
+|<a href="#Softmax">Softmax</a>|<a href="Changelog.md#Softmax-13">13</a>, <a href="Changelog.md#Softmax-11">11</a>, <a href="Changelog.md#Softmax-1">1</a>|13, 18|
+|<a href="#SoftmaxCrossEntropyLoss">SoftmaxCrossEntropyLoss</a>|<a href="Changelog.md#SoftmaxCrossEntropyLoss-13">13</a>, <a href="Changelog.md#SoftmaxCrossEntropyLoss-12">12</a>|13|
+|<a href="#Softplus">Softplus</a>|<a href="Changelog.md#Softplus-22">22</a>, <a href="Changelog.md#Softplus-1">1</a>|18|
+|<a href="#Softsign">Softsign</a>|<a href="Changelog.md#Softsign-22">22</a>, <a href="Changelog.md#Softsign-1">1</a>|18|
+|<a href="#Swish">Swish</a>|<a href="Changelog.md#Swish-24">24</a>|24|
+|<a href="#ThresholdedRelu">ThresholdedRelu</a>|<a href="Changelog.md#ThresholdedRelu-22">22</a>, <a href="Changelog.md#ThresholdedRelu-10">10</a>|18|
+
+### ai.onnx.preview
+|**Operator**|**Since version**||
+|-|-|-|
+|**Function**|**Since version**|**Function version**|
+|<sub>experimental</sub> <a href="#ai.onnx.preview.FlexAttention">ai.onnx.preview.FlexAttention</a>|<a href="Changelog.md#ai.onnx.preview.FlexAttention-1">1</a>|1|
+
+### ai.onnx.preview.training
+|**Operator**|**Since version**||
+|-|-|-|
+|<a href="#ai.onnx.preview.training.Adagrad">ai.onnx.preview.training.Adagrad</a>|<a href="Changelog.md#ai.onnx.preview.training.Adagrad-1">1</a>|
+|<a href="#ai.onnx.preview.training.Adam">ai.onnx.preview.training.Adam</a>|<a href="Changelog.md#ai.onnx.preview.training.Adam-1">1</a>|
+|<a href="#ai.onnx.preview.training.Gradient">ai.onnx.preview.training.Gradient</a>|<a href="Changelog.md#ai.onnx.preview.training.Gradient-1">1</a>|
+|<a href="#ai.onnx.preview.training.Momentum">ai.onnx.preview.training.Momentum</a>|<a href="Changelog.md#ai.onnx.preview.training.Momentum-1">1</a>|
+
+
+## ai.onnx (default)
+### <a name="Abs"></a><a name="abs">**Abs**</a>
+
+  Absolute takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where absolute value, y = abs(x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Abs-1">1</a>, <a href="Changelog.md#Abs-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>abs</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Abs",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.abs(x)
+
+expect(node, inputs=[x], outputs=[y], name="test_abs")
+```
+
+</details>
+
+
+#### Sample Implementation
+
+<details>
+<summary>Abs</summary>
+
+```python
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+
+def abs(input: np.ndarray) -> np.ndarray:  # noqa: A001
+    return np.abs(input)  # type: ignore[no-any-return]
+
+```
+
+</details>
+
+
+### <a name="Acos"></a><a name="acos">**Acos**</a>
+
+  Calculates the arccosine (inverse of cosine) of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Acos-7">7</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The arccosine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>acos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Acos",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-0.5, 0, 0.5]).astype(np.float32)
+y = np.arccos(x)
+expect(node, inputs=[x], outputs=[y], name="test_acos_example")
+
+x = np.random.rand(3, 4, 5).astype(np.float32)
+y = np.arccos(x)
+expect(node, inputs=[x], outputs=[y], name="test_acos")
+```
+
+</details>
+
+
+### <a name="Acosh"></a><a name="acosh">**Acosh**</a>
+
+  Calculates the hyperbolic arccosine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Acosh-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic arccosine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>acosh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Acosh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([10, np.e, 1]).astype(np.float32)
+y = np.arccosh(x)  # expected output [2.99322295,  1.65745449,  0.]
+expect(node, inputs=[x], outputs=[y], name="test_acosh_example")
+
+x = np.random.uniform(1.0, 10.0, (3, 4, 5)).astype(np.float32)
+y = np.arccosh(x)
+expect(node, inputs=[x], outputs=[y], name="test_acosh")
+```
+
+</details>
+
+
+### <a name="Add"></a><a name="add">**Add**</a>
+
+  Performs element-wise binary addition (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Add-1">1</a>, <a href="Changelog.md#Add-6">6</a>, <a href="Changelog.md#Add-7">7</a>, <a href="Changelog.md#Add-13">13</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>add</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Add",
+    inputs=["x", "y"],
+    outputs=["sum"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_int8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>add_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Add",
+    inputs=["x", "y"],
+    outputs=["sum"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_bcast")
+```
+
+</details>
+
+
+### <a name="AffineGrid"></a><a name="affinegrid">**AffineGrid**</a>
+
+  Generates a 2D or 3D flow field (sampling grid), given a batch of affine matrices theta
+  (https://pytorch.org/docs/stable/generated/torch.nn.functional.affine_grid.html).
+  An affine matrix `theta` is applied to a position tensor represented in its homogeneous expression. Here is an example in 3D:
+  ```
+  [r00, r01, r02, t0]   [x]   [x']
+  [r10, r11, r12, t1] * [y] = [y']
+  [r20, r21, r22, t2]   [z]   [z']
+  [0,   0,   0,   1 ]   [1]   [1 ]
+  ```
+  where `(x, y, z)` is the position in the original space, `(x', y', z')` is the position in the output space.
+  The last row is always `[0, 0, 0, 1]` and is not stored in the affine matrix. Therefore we have `theta` of shape `(N, 2, 3)` for 2D or `(N, 3, 4)` for 3D.
+
+  Input `size` is used to define grid of positions evenly spaced in the original 2D or 3D space, with dimensions ranging from `-1` to `1`.
+  The output `grid` contains positions in the output space.
+
+  When `align_corners=1`, consider `-1` and `1` to refer to the centers of the corner pixels (mark `v` in illustration).
+  ```
+  v            v            v            v
+  |-------------------|------------------|
+  -1                  0                  1
+  ```
+  When `align_corners=0`, consider `-1` and `1` to refer to the outer edge of the corner pixels.
+  ```
+      v        v         v         v
+  |------------------|-------------------|
+  -1                 0                   1
+  ```
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>align_corners</tt> : int (default is 0)</dt>
+<dd>if align_corners=1, consider -1 and 1 to refer to the centers of the corner pixels. if align_corners=0, consider -1 and 1 to refer to the outer edge the corner pixels.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>theta</tt> (non-differentiable) : T1</dt>
+<dd>input batch of affine matrices with shape (N, 2, 3) for 2D or (N, 3, 4) for 3D</dd>
+<dt><tt>size</tt> (non-differentiable) : T2</dt>
+<dd>the target output image size (N, C, H, W) for 2D or (N, C, D, H, W) for 3D</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>grid</tt> (differentiable) : T1</dt>
+<dd>output tensor of shape (N, H, W, 2) of 2D sample coordinates or (N, D, H, W, 3) of 3D sample coordinates.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain grid types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain size's type to int64 tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>2d_no_reference_evaluator</summary>
+
+```python
+theta_2d = create_theta_2d()
+N, C, H, W = len(theta_2d), 3, 5, 6
+data_size = (H, W)
+for align_corners in (0, 1):
+    node = onnx.helper.make_node(
+        "AffineGrid",
+        inputs=["theta", "size"],
+        outputs=["grid"],
+        align_corners=align_corners,
+    )
+
+    original_grid = construct_original_grid(data_size, align_corners)
+    grid = apply_affine_transform(theta_2d, original_grid)
+
+    test_name = "test_affine_grid_2d"
+    if align_corners == 1:
+        test_name += "_align_corners"
+    expect(
+        node,
+        inputs=[theta_2d, np.array([N, C, H, W], dtype=np.int64)],
+        outputs=[grid],
+        name=test_name,
+    )
+```
+
+</details>
+
+
+<details>
+<summary>3d_no_reference_evaluator</summary>
+
+```python
+theta_3d = create_theta_3d()
+N, C, D, H, W = len(theta_3d), 3, 4, 5, 6
+data_size = (D, H, W)
+for align_corners in (0, 1):
+    node = onnx.helper.make_node(
+        "AffineGrid",
+        inputs=["theta", "size"],
+        outputs=["grid"],
+        align_corners=align_corners,
+    )
+
+    original_grid = construct_original_grid(data_size, align_corners)
+    grid = apply_affine_transform(theta_3d, original_grid)
+
+    test_name = "test_affine_grid_3d"
+    if align_corners == 1:
+        test_name += "_align_corners"
+    expect(
+        node,
+        inputs=[theta_3d, np.array([N, C, D, H, W], dtype=np.int64)],
+        outputs=[grid],
+        name=test_name,
+    )
+```
+
+</details>
+
+
+### <a name="And"></a><a name="and">**And**</a>
+
+  Returns the tensor resulted from performing the `and` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#And-1">1</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input to boolean tensor.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>and</summary>
+
+```python
+node = onnx.helper.make_node(
+    "And",
+    inputs=["x", "y"],
+    outputs=["and"],
+)
+
+# 2d
+x = (np.random.randn(3, 4) > 0).astype(bool)
+y = (np.random.randn(3, 4) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and2d")
+
+# 3d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and3d")
+
+# 4d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and4d")
+```
+
+</details>
+
+
+<details>
+<summary>and_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "And",
+    inputs=["x", "y"],
+    outputs=["and"],
+)
+
+# 3d vs 1d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(5) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v1d")
+
+# 3d vs 2d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(4, 5) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v2d")
+
+# 4d vs 2d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(5, 6) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v2d")
+
+# 4d vs 3d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(4, 5, 6) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v3d")
+
+# 4d vs 4d
+x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool)
+y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v4d")
+```
+
+</details>
+
+
+### <a name="ArgMax"></a><a name="argmax">**ArgMax**</a>
+
+  Computes the indices of the max elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equals 0, then the resulting tensor has the reduced dimension pruned.
+  If select_last_index is True (default False), the index of the last occurrence of the max
+  is selected if the max appears more than once in the input. Otherwise the index of the
+  first occurrence is selected.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ArgMax-1">1</a>, <a href="Changelog.md#ArgMax-11">11</a>, <a href="Changelog.md#ArgMax-12">12</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>select_last_index</tt> : int (default is 0)</dt>
+<dd>Whether to select the last index or the first index if the {name} appears in multiple indices, default is False (first index).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax", inputs=["data"], outputs=["result"], keepdims=keepdims
+)
+
+# result: [[1, 1]]
+result = argmax_use_numpy(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_default_axis_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [1, 3, 4]
+result = argmax_use_numpy(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_default_axis_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_axes_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax",
+    inputs=["data"],
+    outputs=["result"],
+    keepdims=keepdims,
+    select_last_index=True,
+)
+
+# result: [[1, 1]]
+result = argmax_use_numpy_select_last_index(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_default_axis_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [1, 3, 4]
+result = argmax_use_numpy_select_last_index(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_default_axis_random_select_last_index",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# result: [[0], [1]]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmax_keepdims_example"
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 1, 4]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmax_keepdims_random"
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1], [1]]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 1, 4]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_keepdims_random_select_last_index",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axis_keepdims</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = -1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# result: [[0], [1]]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_negative_axis_keepdims_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 3, 1]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_negative_axis_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axis_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = -1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1], [1]]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_negative_axis_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 3, 1]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_negative_axis_keepdims_random_select_last_index",
+)
+```
+
+</details>
+
+
+<details>
+<summary>no_keepdims</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 0
+node = onnx.helper.make_node(
+    "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# result: [0, 1]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_no_keepdims_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 4]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmax_no_keepdims_random"
+)
+```
+
+</details>
+
+
+<details>
+<summary>no_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 0
+node = onnx.helper.make_node(
+    "ArgMax",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [1, 1]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_no_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 4]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_no_keepdims_random_select_last_index",
+)
+```
+
+</details>
+
+
+### <a name="ArgMin"></a><a name="argmin">**ArgMin**</a>
+
+  Computes the indices of the min elements of the input tensor's element along the
+  provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+  If keepdims equals 0, then the resulting tensor has the reduced dimension pruned.
+  If select_last_index is True (default False), the index of the last occurrence of the min
+  is selected if the min appears more than once in the input. Otherwise the index of the
+  first occurrence is selected.
+  The type of the output tensor is integer.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ArgMin-1">1</a>, <a href="Changelog.md#ArgMin-11">11</a>, <a href="Changelog.md#ArgMin-12">12</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>select_last_index</tt> : int (default is 0)</dt>
+<dd>Whether to select the last index or the first index if the {name} appears in multiple indices, default is False (first index).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Reduced output tensor with integer data type.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin", inputs=["data"], outputs=["result"], keepdims=keepdims
+)
+
+# The content of result is : [[0], [0]]
+result = argmin_use_numpy(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_default_axis_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [1, 3, 4]
+result = argmin_use_numpy(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_default_axis_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_axes_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin",
+    inputs=["data"],
+    outputs=["result"],
+    keepdims=keepdims,
+    select_last_index=True,
+)
+
+# result: [[0, 0]]
+result = argmin_use_numpy_select_last_index(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_default_axis_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [1, 3, 4]
+result = argmin_use_numpy_select_last_index(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_default_axis_random_select_last_index",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# The content of result is : [[1], [0]]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmin_keepdims_example"
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 1, 4]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmin_keepdims_random"
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1], [0]]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 1, 4]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_keepdims_random_select_last_index",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axis_keepdims</summary>
+
+```python
+data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+axis = -1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# The content of result is : [[1], [0]]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_negative_axis_keepdims_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 3, 1]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_negative_axis_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axis_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = -1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1], [0]]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_negative_axis_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 3, 1]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_negative_axis_keepdims_random_select_last_index",
+)
+```
+
+</details>
+
+
+<details>
+<summary>no_keepdims</summary>
+
+```python
+data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 0
+node = onnx.helper.make_node(
+    "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# The content of result is : [[1, 0]]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_no_keepdims_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 4]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmin_no_keepdims_random"
+)
+```
+
+</details>
+
+
+<details>
+<summary>no_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 0
+node = onnx.helper.make_node(
+    "ArgMin",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1, 0]]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_no_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 4]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_no_keepdims_random_select_last_index",
+)
+```
+
+</details>
+
+
+### <a name="Asin"></a><a name="asin">**Asin**</a>
+
+  Calculates the arcsine (inverse of sine) of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Asin-7">7</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The arcsine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>asin</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Asin",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-0.5, 0, 0.5]).astype(np.float32)
+y = np.arcsin(x)
+expect(node, inputs=[x], outputs=[y], name="test_asin_example")
+
+x = np.random.rand(3, 4, 5).astype(np.float32)
+y = np.arcsin(x)
+expect(node, inputs=[x], outputs=[y], name="test_asin")
+```
+
+</details>
+
+
+### <a name="Asinh"></a><a name="asinh">**Asinh**</a>
+
+  Calculates the hyperbolic arcsine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Asinh-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic arcsine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>asinh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Asinh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.arcsinh(x)  # expected output [-0.88137358,  0.,  0.88137358]
+expect(node, inputs=[x], outputs=[y], name="test_asinh_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.arcsinh(x)
+expect(node, inputs=[x], outputs=[y], name="test_asinh")
+```
+
+</details>
+
+
+### <a name="Atan"></a><a name="atan">**Atan**</a>
+
+  Calculates the arctangent (inverse of tangent) of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Atan-7">7</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The arctangent of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>atan</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Atan",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.arctan(x)
+expect(node, inputs=[x], outputs=[y], name="test_atan_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.arctan(x)
+expect(node, inputs=[x], outputs=[y], name="test_atan")
+```
+
+</details>
+
+
+### <a name="Atanh"></a><a name="atanh">**Atanh**</a>
+
+  Calculates the hyperbolic arctangent of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Atanh-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic arctangent values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>atanh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Atanh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-0.5, 0, 0.5]).astype(np.float32)
+y = np.arctanh(x)  # expected output [-0.54930615,  0.,  0.54930615]
+expect(node, inputs=[x], outputs=[y], name="test_atanh_example")
+
+x = np.random.uniform(0.0, 1.0, (3, 4, 5)).astype(np.float32)
+y = np.arctanh(x)
+expect(node, inputs=[x], outputs=[y], name="test_atanh")
+```
+
+</details>
+
+
+### <a name="Attention"></a><a name="attention">**Attention**</a>
+
+  Computes scaled dot product attention on query, key and value tensors, using an optional attention mask if passed.
+
+  This operator covers self and cross variants of the attention operation based on sequence lengths of K, Q and V.
+
+  For self attention, `kv_sequence_length` equals to `q_sequence_length`.
+
+  For cross attention, query and key might have different lengths.
+
+  This operator also covers the 3 following variants based on the number of heads:
+  1) Multi-headed Attention (MHA): Described in the paper https://arxiv.org/pdf/1706.03762, `q_num_heads = kv_num_heads`.
+  2) Group-query Attention (GQA): Described in the paper https://arxiv.org/pdf/2305.13245, `q_num_heads > kv_num_heads`, `q_num_heads % kv_num_heads == 0`.
+  3) Multi-query Attention (MQA): Described in the paper https://arxiv.org/pdf/1911.02150, `q_num_heads > kv_num_heads`, `kv_num_heads=1`.
+
+  Attention bias to be added is calculated based on `attn_mask` input and `is_causal` attribute:
+  1) `attn_mask`: A boolean mask where a value of `True` indicates that the element should take part in attention or a float mask of the same type as query, key, value that is added to the attention score.
+  2) If `is_causal` is set to `1`, causal masking is applied with bottom-right (offset-aware) alignment: query `i` attends key `j` iff `j <= i + offset`, as illustrated below.
+
+  ```
+    2D causal mask for Attention (PR onnx/onnx#8068)
+     S_q=4 queries, S_k=8 keys
+     Rule: query i attends key j iff j <= i + offset
+           offset = nonpad_kv_seqlen - S_q
+
+     nonpad_kv_seqlen=4, offset=4-4=0
+
+            k0  k1  k2  k3  k4  k5  k6  k7
+           +----+----+----+----+----+----+----+----+
+      q0   | ## |    |    |    |    |    |    |    |
+           +----+----+----+----+----+----+----+----+
+      q1   | ## | ## |    |    |    |    |    |    |
+           +----+----+----+----+----+----+----+----+
+      q2   | ## | ## | ## |    |    |    |    |    |
+           +----+----+----+----+----+----+----+----+
+      q3   | ## | ## | ## | ## |    |    |    |    |
+           +----+----+----+----+----+----+----+----+
+
+
+     nonpad_kv_seqlen=8, offset=8-4=4
+
+            k0  k1  k2  k3  k4  k5  k6  k7
+           +----+----+----+----+----+----+----+----+
+      q0   | ## | ## | ## | ## | ## |    |    |    |
+           +----+----+----+----+----+----+----+----+
+      q1   | ## | ## | ## | ## | ## | ## |    |    |
+           +----+----+----+----+----+----+----+----+
+      q2   | ## | ## | ## | ## | ## | ## | ## |    |
+           +----+----+----+----+----+----+----+----+
+      q3   | ## | ## | ## | ## | ## | ## | ## | ## |
+           +----+----+----+----+----+----+----+----+
+  ```
+
+  With `nonpad_kv_seqlen=4` (offset=0), the mask is the standard lower-triangular. With `nonpad_kv_seqlen=8` (offset=4), the diagonal shifts right by 4, so each query sees the 4 additional valid cached keys.
+
+  `offset` is the count of valid keys preceding the current query block: `offset = past_sequence_length` when `past_key` is provided; `offset = nonpad_kv_seqlen - q_sequence_length` (per batch) when an external cache is indicated by `nonpad_kv_seqlen` without `past_key`; `offset = 0` when neither is provided (the no-cache case, which reduces to the standard lower-triangular mask). When `offset < 0` (`nonpad_kv_seqlen < q_sequence_length`, i.e. more query tokens than cached keys) the leading query rows have an empty key set (no key satisfies `j <= i + offset`) and are fully masked. The causal frontier is computed independently of `attn_mask` and is then composed with it additively: a boolean `attn_mask` intersects the allowed set (its disallowed positions contribute `-inf` to the bias), while a float `attn_mask` is added to the attention scores rather than disabling positions. A fully-masked query row (no key attended, including the negative-offset leading rows) produces a zero output row, not `NaN`, for both `Y` and the mode-`3` `qk_matmul_output` debug output; the mode-`3` `qk_matmul_output` is emitted at the operator's output precision (`T1`).
+
+  Errata (in-place behavioral correction, no opset bump): the reference implementation and backend tests were incorrect when `nonpad_kv_seqlen != q_sequence_length` (nonzero bottom-right offset, top-left instead of bottom-right causal alignment) and produced `NaN` for fully-masked rows; corrected in version 1.23. This fixed three behaviors described above: external-cache bottom-right causal alignment (`offset = nonpad_kv_seqlen - q_sequence_length`), zero (non-`NaN`) output for fully-masked rows including the mode-`3` `qk_matmul_output`, and the mode-`3` `qk_matmul_output` precision (`T1`).
+
+  With respect to KV cache update, this operator allows the following two use cases:
+
+  1) Cache update happens inside the Attention operator. In this case, the `K` and `V` inputs contain only the incoming
+  tokens for the current autoregressive step, and the four optional inputs/outputs past and present key and value are
+  all needed. The Attention op performs a Concat operation on the past and incoming key and value to form the present
+  key and value, respectively. Note that this only works correctly for the special case where the past key and value
+  do not contain padded tokens.
+  2) Cache update happens outside the Attention operator (for example, through the `TensorScatter` operator). In this
+  case, the `K` and `V` inputs correspond to the entire cache tensor, so the four optional inputs/outputs past and
+  present key and value should not be used. An additional input `nonpad_kv_seqlen` of shape (batch_size,) may be
+  provided to indicate the number of non-padding tokens in each sample of the batch to save unnecessary computation.
+  Here, the kv_sequence dimension of `attn_mask` can be shorter than `K` and `V`, but still needs to be at least as long
+  as the maximum value of `nonpad_kv_seqlen`.
+
+  Both past and present state key/values are optional. They shall be used together, and not allowed to use only one of them.
+  The following pattern is applied to the Q, K and V inputs after appropriate reshaping of K and V inputs based on sequence lengths and num heads provided:
+
+  ```
+    The following pattern is applied by this operator:
+        Q          K          V
+        |          |          |
+  Q*sqrt(scale) K*sqrt(scale) |
+        |          |          |
+        |       Transpose     |
+        |          |          |
+        ---MatMul---          |
+              |               |
+    softcap (if provided)     |
+              |               |
+   at_mask---Add              |
+              |               |
+           Softmax            |
+              |               |
+              -----MatMul------
+                     |
+                     Y
+  ```
+
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Attention-23">23</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>is_causal</tt> : int (default is 0)</dt>
+<dd>If set to `1`, causal masking is applied. For a square Q/K (no cache offset) this is a lower-triangular matrix. In general the mask is bottom-right (offset-aware): query in-block index `i` attends key `j` iff `j <= i + offset`, where `offset` is the count of valid keys preceding the query block (`past_sequence_length` for an internal `past_key` cache, or `nonpad_kv_seqlen - q_sequence_length` per batch for an external cache). When `offset = 0` this reduces to the lower-triangular (top-left) mask.</dd>
+<dt><tt>kv_num_heads</tt> : int</dt>
+<dd>Number of heads of key and value. Must be used with 3D inputs of Q, K and V. </dd>
+<dt><tt>q_num_heads</tt> : int</dt>
+<dd>Number of heads of query. Must be used with 3D inputs of Q, K and V. </dd>
+<dt><tt>qk_matmul_output_mode</tt> : int (default is 0)</dt>
+<dd>If set to `0`, qk_matmul_output is the output of qk matmul. If set to `1`, qk_matmul_output is the output after the softcap operation (before mask addition). If set to `2`, qk_matmul_output includes the attention mask and softcap (if provided) applied to the output of qk matmul. If set to `3`, qk_matmul_output is the output after the softmax operation. In mode `3`, a fully-masked query row (every key disallowed) is a zero row, consistent with the corresponding row of the primary output `Y`: the fully-masked-row guard is applied before this output is produced. The mode-`3` output is emitted at the operator's output precision (`T1`); when `softmax_precision` differs from `T1` this is a cast of the softmax result to `T1`. Default value is 0.</dd>
+<dt><tt>scale</tt> : float</dt>
+<dd>Scaling factor applied to $Q*K^T$. Default value is `1/sqrt(head_size)`. To prevent [numerical overflow](https://tinyurl.com/sudb9s96), scale `Q`, `K` by `sqrt(scale)` before matmul.</dd>
+<dt><tt>softcap</tt> : float (default is 0.0)</dt>
+<dd>Softcap value for attention weights. Default value is 0.</dd>
+<dt><tt>softmax_precision</tt> : int</dt>
+<dd>The floating-point precision used in softmax computation. If softmax precision is not provided, the same precision as the input of softmax (Q and K) is used.</dd>
+</dl>
+
+#### Inputs (3 - 7)
+
+<dl>
+<dt><tt>Q</tt> : T1</dt>
+<dd>Query tensor. 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, q_hidden_size)`. For cases with a 3D input tensor, `q_hidden_size = q_num_heads * head_size`</dd>
+<dt><tt>K</tt> : T1</dt>
+<dd>Key tensor. 4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, k_hidden_size)`. For cases with a 3D input tensor, `k_hidden_size = kv_num_heads * head_size`</dd>
+<dt><tt>V</tt> : T2</dt>
+<dd>Value tensor. 4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, v_hidden_size)`. For cases with a 3D input tensor, `v_hidden_size = kv_num_heads * v_head_size`</dd>
+<dt><tt>attn_mask</tt> (optional) : U</dt>
+<dd>Attention mask. Shape must be broadcastable to `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` where `total_sequence_length = past_sequence_length + kv_sequence_length.` The last dimension can also be shorter than `total_sequence_length` and will be padded to `total_sequence_length` with negative infinity. Two types of masks are supported: a boolean mask where a value of `True` indicates that the element should take part in attention, or a float mask of the same type as query, key, value that is added to the attention score.</dd>
+<dt><tt>past_key</tt> (optional) : T1</dt>
+<dd>past state cache for key with shape `(batch_size, kv_num_heads, past_sequence_length, head_size)`</dd>
+<dt><tt>past_value</tt> (optional) : T2</dt>
+<dd>past state cache for value with shape `(batch_size, kv_num_heads, past_sequence_length, v_head_size)`</dd>
+<dt><tt>nonpad_kv_seqlen</tt> (optional) : tensor(int64)</dt>
+<dd>A vector of integers of shape `(batch_size,)` that indicates the number of valid (ie, non-padding) tokens in each sample. A padding mask can be derived from this. This should not be used together with `past_key` and `past_value` inputs or `present_key` and `present_value` outputs (See the KV cache use cases in the operator description).</dd>
+</dl>
+
+#### Outputs (1 - 4)
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>The output tensor . 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, hidden_size)`. For cases with a 3D input tensor, `hidden_size = q_num_heads * v_head_size`</dd>
+<dt><tt>present_key</tt> (optional) : T1</dt>
+<dd>Updated key cache with shape `(batch_size, kv_num_heads, total_sequence_length, head_size)` where `total_sequence_length = past_sequence_length + kv_sequence_length`.</dd>
+<dt><tt>present_value</tt> (optional) : T2</dt>
+<dd>Updated value cache with shape `(batch_size, kv_num_heads, total_sequence_length, v_head_size)` where `total_sequence_length = past_sequence_length + kv_sequence_length`.</dd>
+<dt><tt>qk_matmul_output</tt> (optional) : T1</dt>
+<dd>The output of QK matmul. 4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` where `total_sequence_length = past_sequence_length + kv_sequence_length`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain Q and K inputs types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain V input types to float tensors.</dd>
+<dt><tt>U</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool)</dt>
+<dd>Constrain output 'mask' types to boolean tensors and input types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>attention</summary>
+
+```python
+node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_23_boolmask_fullymasked_row_nan_robustness</summary>
+
+```python
+"""Opset-23 fully-masked boolean ``attn_mask`` row -> zero (not ``NaN``).
+
+This locks the opset-23 / ``old.cc`` function-body fully-masked-row guard
+against future regressions. In opset 23 the only in-contract fully-masked
+row comes from an all-``False`` boolean ``attn_mask`` row (``is_causal`` is
+not set here): every key for that query is disallowed, so ``softmax`` over an
+all-``-inf`` bias row is ``NaN``. The guard zeros that row's probabilities
+before the ``P @ V`` contraction so the output row is exactly ``0``, while
+rows with at least one allowed key are unchanged.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(4)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(B, H, S, D).astype(np.float32)
+K = np.random.rand(B, H, S, D).astype(np.float32)
+V = np.random.rand(B, H, S, D).astype(np.float32)
+# Row 0: no key allowed -> fully masked (Bug-2 empty row). Row 1: both keys
+# allowed -> finite, unchanged by the guard.
+attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask)
+
+# Fully-masked row 0 is exactly zero (not NaN); every other cell is finite.
+assert np.all(np.isfinite(Y)), "non-masked rows must be finite"
+assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+    "fully-masked row must be zero (Bug-2)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_23_boolmask_fullymasked_row_nan_robustness",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_23_fullymasked_qk_matmul_output_mode3_zero</summary>
+
+```python
+"""Opset-23 ``qk_matmul_output_mode=3`` fully-masked row is a zero row.
+
+Mode ``3`` exposes the post-softmax matrix as the optional
+``qk_matmul_output``.  For a fully-masked query row (all-``False`` boolean
+``attn_mask`` row), the fully-masked-row guard is applied before this output
+is produced, so the mode-3 row is zeroed, consistent with the primary output
+``Y`` row (both are ``0``).  This pins the mandated agreement between the
+guarded primary output and the mode-3 output at opset 23.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(13)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=3,
+)
+
+Q = np.random.rand(B, H, S, D).astype(np.float32)
+K = np.random.rand(B, H, S, D).astype(np.float32)
+V = np.random.rand(B, H, S, D).astype(np.float32)
+# Row 0: no key allowed -> fully masked. Row 1: both keys allowed -> finite.
+attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=3,
+)
+
+# Primary output row 0 and the mode-3 row 0 are both guarded to zero.
+assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+    "fully-masked primary output row must be zero"
+)
+assert np.array_equal(
+    qk_matmul_output[:, :, 0, :], np.zeros_like(qk_matmul_output[:, :, 0, :])
+), "mode-3 output row for a fully-masked query must be zero (consistent with Y)"
+assert np.all(np.isfinite(qk_matmul_output)), (
+    "all mode-3 rows are finite (the fully-masked row is guarded to 0.0)"
+)
+assert np.all(np.isfinite(Y)), (
+    "all Y rows are finite (the fully-masked row is guarded to 0.0)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_23_fullymasked_qk_matmul_output_mode3_zero",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_24_fullymasked_qk_matmul_output_mode3_zero</summary>
+
+```python
+"""Opset-24 ``qk_matmul_output_mode=3`` fully-masked row is a zero row.
+
+The opset-24 twin of
+``export_attention_23_fullymasked_qk_matmul_output_mode3_zero``.  Mode ``3``
+exposes the post-softmax matrix as the optional ``qk_matmul_output``.  For a
+fully-masked query row (all-``False`` boolean ``attn_mask`` row), the
+fully-masked-row guard is applied before this output is produced, so the
+mode-3 row is zeroed, consistent with the primary output ``Y`` row (both are
+``0``).  This pins the mandated agreement between the guarded primary output
+and the mode-3 output at opset 24.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(13)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=3,
+)
+
+Q = np.random.rand(B, H, S, D).astype(np.float32)
+K = np.random.rand(B, H, S, D).astype(np.float32)
+V = np.random.rand(B, H, S, D).astype(np.float32)
+# Row 0: no key allowed -> fully masked. Row 1: both keys allowed -> finite.
+attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=3,
+)
+
+# Primary output row 0 and the mode-3 row 0 are both guarded to zero.
+assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+    "fully-masked primary output row must be zero"
+)
+assert np.array_equal(
+    qk_matmul_output[:, :, 0, :], np.zeros_like(qk_matmul_output[:, :, 0, :])
+), "mode-3 output row for a fully-masked query must be zero (consistent with Y)"
+assert np.all(np.isfinite(qk_matmul_output)), (
+    "all mode-3 rows are finite (the fully-masked row is guarded to 0.0)"
+)
+assert np.all(np.isfinite(Y)), (
+    "all Y rows are finite (the fully-masked row is guarded to 0.0)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_24_fullymasked_qk_matmul_output_mode3_zero",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_24_qk_matmul_output_mode3_softmax_precision</summary>
+
+```python
+"""Mode-3 ``qk_matmul_output`` is emitted at the output precision ``T1``.
+
+``qk_matmul_output_mode=3`` exposes the post-softmax probabilities.  When
+``softmax_precision`` differs from the operator's output type ``T1`` (here
+``T1 = float16`` with softmax computed in ``float32``), the mode-3 output is
+cast back to ``T1`` -- matching the reference implementation, which casts the
+exposed matrix to ``Q.dtype``.  This locks both the dtype contract and the
+fully-masked-row zeroing under a non-default ``softmax_precision``.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(17)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=3,
+    softmax_precision=int(onnx.TensorProto.FLOAT),
+)
+
+# T1 = float16; softmax runs in float32, so the mode-3 output is cast back to
+# float16 on emission.
+Q = np.random.rand(B, H, S, D).astype(np.float16)
+K = np.random.rand(B, H, S, D).astype(np.float16)
+V = np.random.rand(B, H, S, D).astype(np.float16)
+# Row 0: fully masked. Row 1: both keys allowed -> finite.
+attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=3,
+    softmax_precision=int(onnx.TensorProto.FLOAT),
+)
+
+# The mode-3 output is emitted at T1 (float16), not the float32 softmax
+# precision, matching the operator's output type.
+assert qk_matmul_output.dtype == np.float16, (
+    "mode-3 qk_matmul_output must be emitted at the output precision T1 (float16)"
+)
+# The fully-masked row is still guarded to zero, consistent with Y.
+assert np.array_equal(
+    qk_matmul_output[:, :, 0, :], np.zeros_like(qk_matmul_output[:, :, 0, :])
+), "mode-3 output row for a fully-masked query must be zero (consistent with Y)"
+assert np.all(np.isfinite(qk_matmul_output)), (
+    "all mode-3 rows are finite (the fully-masked row is guarded to 0.0)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_24_qk_matmul_output_mode3_softmax_precision",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_attn_mask</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_3d_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_causal</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_diff_head_sizes</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_diff_head_sizes_attn_mask</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_diff_head_sizes_causal</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_diff_head_sizes_scaled</summary>
+
+```python
+scale = 1e-2
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_diff_head_sizes_softcap</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_diff_head_sizes_with_past_and_present</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_3d_diff_heads_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_gqa</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_gqa",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_gqa_attn_mask</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_3d_gqa_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_gqa_causal</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_gqa_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_gqa_scaled</summary>
+
+```python
+scale = 1e-2
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_gqa_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_gqa_softcap</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_gqa_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_gqa_with_past_and_present</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_3d_gqa_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_scaled</summary>
+
+```python
+scale = 1e-2
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_softcap</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_transpose_verification</summary>
+
+```python
+"""Test case to verify correct 3D to 4D transpose behavior.
+
+This test verifies that 3D inputs are correctly reshaped and transposed
+according to the ONNX specification:
+[batch_size, seq_length, hidden_size] ->
+[batch_size, seq_length, num_heads, head_size] ->
+[batch_size, num_heads, seq_length, head_size]
+"""
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+# Test inputs that will clearly demonstrate the transpose behavior
+batch_size = 1
+q_seq_length = 2
+kv_seq_length = 2
+head_size = 4
+q_hidden_size = q_num_heads * head_size  # 3 * 4 = 12
+kv_hidden_size = kv_num_heads * head_size  # 3 * 4 = 12
+
+# Create structured inputs to verify correct transpose behavior
+# Q has a pattern where each position in hidden dimension has a specific value
+Q = np.zeros((batch_size, q_seq_length, q_hidden_size), dtype=np.float32)
+# Fill Q with pattern: head0=[1,1,1,1], head1=[2,2,2,2], head2=[3,3,3,3]
+for head in range(q_num_heads):
+    start_idx = head * head_size
+    end_idx = start_idx + head_size
+    Q[0, :, start_idx:end_idx] = float(head + 1)
+
+K = np.ones((batch_size, kv_seq_length, kv_hidden_size), dtype=np.float32) * 0.1
+V = np.ones((batch_size, kv_seq_length, kv_hidden_size), dtype=np.float32) * 0.1
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_transpose_verification",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_with_past_and_present</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_3d_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_with_past_and_present_qk_matmul</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_3d_with_past_and_present_qk_matmul",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_with_past_and_present_qk_matmul_bias</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    qk_matmul_output_mode=2,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_3d_with_past_and_present_qk_matmul_bias",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_with_past_and_present_qk_matmul_softcap</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    softcap=2.0,
+    qk_matmul_output_mode=1,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    softcap=2.0,
+    qk_matmul_output_mode=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_3d_with_past_and_present_qk_matmul_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_3d_with_past_and_present_qk_matmul_softmax</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    qk_matmul_output_mode=3,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    qk_matmul_output_mode=3,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_3d_with_past_and_present_qk_matmul_softmax",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_4d_causal_nonpad_attn_mask_composition</summary>
+
+```python
+"""Compose ``is_causal`` + ``nonpad_kv_seqlen`` + boolean ``attn_mask``.
+
+The existing nonpad tests use no ``attn_mask`` and the existing mask tests
+use no ``nonpad_kv_seqlen``; this is the first to activate all three
+constraints together on the external-cache path with ``batch > 1``.  The
+three biases are summed additively and a key is attended only if allowed by
+all three.  Crucially the inputs are designed so that **each constraint is
+independently necessary** -- removing any one changes the golden -- to avoid a
+degenerate test that a backend ignoring ``is_causal`` and/or
+``nonpad_kv_seqlen`` could still pass:
+
+* **``is_causal`` binds.**  Each batch has a key that the boolean mask allows
+  (``True``) but the bottom-right causal frontier disallows
+  (``j > i + offset``); only ``is_causal`` masks it (batch 0 row 0 key 2,
+  batch 1 row 0 key 3).
+* **``attn_mask`` binds.**  Each batch has a key the causal frontier and the
+  padding bound both allow but the boolean mask sets ``False`` (batch 0 row 2
+  key 1, batch 1 row 2 key 2); only the mask masks it.
+* **``nonpad_kv_seqlen`` binds.**  ``nonpad_kv_seqlen`` sets the per-batch
+  causal *offset* (``offset = nonpad_kv_seqlen - q_sequence_length``), so
+  dropping it collapses the frontier to top-left (``offset = 0``) and shifts
+  which keys are attended.  (Under ``is_causal=1`` the causal frontier already
+  subsumes the ``j < nonpad`` padding bound, so ``nonpad_kv_seqlen`` binds
+  through the offset it induces rather than through a redundant padding cut.)
+
+The mask is chosen to leave at least one allowed key on every query row, so
+this exercises the *intersection* of the three constraints with finite outputs
+(the fully-masked-row guard is covered by
+``test_attention_4d_causal_nonpad_negative_offset_structural_empty`` and
+``test_attention_24_fullymasked_qk_matmul_output_mode3_zero``).
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(11)
+B, H, L, D = 2, 2, 6, 8
+S_q = 3
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, L, D).astype(np.float32)
+V = np.random.rand(B, H, L, D).astype(np.float32)
+nonpad_kv_seqlen = np.array([4, 5], dtype=np.int64)  # offsets [1, 2]
+# Per-batch (B, 1, S_q, L) bool mask. Each batch is laid out so all three
+# constraints uniquely bind (see the docstring): a causal-only-masked key
+# (mask True, j > i + offset), a mask-only-masked key (mask False, causal +
+# nonpad allow it), and >=1 allowed key per row.
+attn_mask = np.array(
+    [
+        [
+            [
+                [True, True, True, False, False, False],
+                [True, True, True, False, False, False],
+                [True, False, True, True, False, False],
+            ]
+        ],
+        [
+            [
+                [True, True, True, True, False, False],
+                [True, True, True, True, False, False],
+                [True, True, False, True, True, False],
+            ]
+        ],
+    ],
+    dtype=np.bool_,
+)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+# The chosen mask leaves >=1 allowed key per row, so the composition stays
+# finite (no fully-masked row in this case).
+assert np.all(np.isfinite(Y)), "composed-constraint output must be finite"
+
+# Non-degeneracy: each constraint is independently necessary. Removing any one
+# of the three (is_causal, attn_mask, nonpad_kv_seqlen) must change the result,
+# so a backend that ignores is_causal or nonpad_kv_seqlen cannot reproduce the
+# golden by applying only the most restrictive mask.
+y_no_causal, _, _, _ = _compute_attention(
+    Q, K, V, attn_mask=attn_mask, nonpad_kv_seqlen=nonpad_kv_seqlen, is_causal=0
+)
+y_no_mask, _, _, _ = _compute_attention(
+    Q, K, V, nonpad_kv_seqlen=nonpad_kv_seqlen, is_causal=1
+)
+y_no_nonpad, _, _, _ = _compute_attention(
+    Q, K, V, attn_mask=attn_mask, is_causal=1
+)
+assert not np.allclose(Y, y_no_causal, equal_nan=True), (
+    "is_causal must bind: dropping it changes the result"
+)
+assert not np.allclose(Y, y_no_mask, equal_nan=True), (
+    "attn_mask must bind: dropping it changes the result"
+)
+assert not np.allclose(Y, y_no_nonpad, equal_nan=True), (
+    "nonpad_kv_seqlen must bind (via the causal offset): dropping it changes the result"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_causal_nonpad_attn_mask_composition",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_4d_causal_nonpad_batch_prefill</summary>
+
+```python
+"""Batch>1 continued prefill with distinct per-batch bottom-right offsets.
+
+The batched generalization of the ``batch == 1`` continued-prefill case: with
+``nonpad_kv_seqlen = [4, 5, 6]`` and ``S_q = 2`` the per-batch bottom-right
+offsets are ``[2, 3, 4]`` (all ``>= 0``), so each batch realigns its causal
+frontier to its own valid-key prefix.  This pins that the per-batch offset is
+applied independently across the batch dimension.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(12)
+B, H, L, D = 3, 2, 6, 8
+S_q = 2
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, L, D).astype(np.float32)
+V = np.random.rand(B, H, L, D).astype(np.float32)
+nonpad_kv_seqlen = np.array([4, 5, 6], dtype=np.int64)  # offsets [2, 3, 4]
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+assert np.all(np.isfinite(Y)), "per-batch prefill output must be finite"
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_causal_nonpad_batch_prefill",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_4d_causal_nonpad_continued_prefill</summary>
+
+```python
+"""Continued / chunked prefill (S_q=2) into a partially-filled static cache.
+
+With ``nonpad_kv_seqlen = [4]`` and ``S_q = 2`` the bottom-right offset is
+``4 - 2 = 2``: query 0 attends keys ``{0,1,2}`` and query 1 attends
+``{0,1,2,3}``.  The old top-left alignment would mask everything past the
+diagonal (``{0}`` and ``{0,1}``), so this test fails pre-fix.
+"""
+np.random.seed(1)
+B, H, L, D = 1, 2, 4, 8
+S_q = 2
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, L, D).astype(np.float32)
+V = np.random.rand(B, H, L, D).astype(np.float32)
+nonpad_kv_seqlen = np.array([4], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_causal_nonpad_continued_prefill",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_4d_causal_nonpad_negative_offset_structural_empty</summary>
+
+```python
+"""Negative bottom-right offset: structurally-empty early query rows -> zero.
+
+This is the onnx-node twin of the ORT gtest
+``Attention_Causal_NonPadKVSeqLen_StructuralEmptyRow_Zero`` /
+``StructuralEmptyRows_Zero_CUDA``.  With ``nonpad_kv_seqlen = [2]`` and
+``S_q = 4`` the bottom-right offset is ``2 - 4 = -2``: query row ``sq``
+attends keys ``0..(sq - 2)``, so rows 0 and 1 have an empty key set.  Their
+``softmax`` over an all-``-inf`` bias row is ``NaN``; the fully-masked-row
+guard zeros those rows before the ``P @ V`` contraction so the output rows are
+exactly ``0``, while rows 2 and 3 (attending keys ``{0}`` and ``{0,1}``) stay finite
+and nonzero.  A ``nonpad_kv_seqlen[b] < q_sequence_length`` input is out of
+the contract's intended use, but its result is still well-defined (zeroed
+rows) rather than ``NaN``; this test pins that defined behavior.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(7)
+B, H, L, D = 1, 2, 4, 8
+S_q = 4
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, L, D).astype(np.float32)
+V = np.random.rand(B, H, L, D).astype(np.float32)
+# offset = nonpad - S_q = 2 - 4 = -2 -> rows 0,1 structurally empty.
+nonpad_kv_seqlen = np.array([2], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+# Structurally-empty early rows are exactly zero (not NaN); later rows finite.
+assert np.all(np.isfinite(Y)), "all output rows must be finite"
+assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+    "structurally-empty row 0 must be zero"
+)
+assert np.array_equal(Y[:, :, 1, :], np.zeros_like(Y[:, :, 1, :])), (
+    "structurally-empty row 1 must be zero"
+)
+assert np.any(Y[:, :, 2, :] != 0) and np.any(Y[:, :, 3, :] != 0), (
+    "rows with a non-empty key set must be nonzero"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_causal_nonpad_negative_offset_structural_empty",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_4d_causal_with_past_and_present</summary>
+
+```python
+"""Regression guard: internal (past_key) cache + is_causal.
+
+This exercises the unchanged scalar bottom-right path (offset =
+past_sequence_length).  Its golden output must remain identical to the
+pre-fix behavior, proving the external-cache change does not touch the
+past_key path.
+"""
+np.random.seed(2)
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+    is_causal=1,
+)
+
+past_sequence_length = 3
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 4, 8).astype(np.float32)
+V = np.random.rand(2, 3, 4, 8).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    past_key=past_key,
+    past_value=past_value,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_causal_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_4d_diff_heads_mask4d_padded_kv</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 4).astype(np.float32)
+nonpad_kv_seqlen = np.array([3, 4], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_mask4d_padded_kv",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_4d_gqa_causal_nonpad_decode</summary>
+
+```python
+"""External/static-cache decode (S_q=1) with per-batch valid lengths.
+
+K/V are the full static cache buffer; ``nonpad_kv_seqlen`` marks how many
+leading keys are valid per batch.  With bottom-right (offset-aware) causal
+masking the single decode query attends keys ``0..nonpad[b]-1``.  Under the
+old top-left alignment it would attend only key 0, so this test fails
+pre-fix and passes post-fix.
+"""
+np.random.seed(0)
+B, H_q, H_kv, L, D = 2, 4, 2, 8, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H_q, 1, D).astype(np.float32)
+K = np.random.rand(B, H_kv, L, D).astype(np.float32)
+V = np.random.rand(B, H_kv, L, D).astype(np.float32)
+# Batch 0 has all 8 keys valid, batch 1 only the first 5.
+nonpad_kv_seqlen = np.array([8, 5], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_gqa_causal_nonpad_decode",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_4d_gqa_causal_nonpad_decode_fp16</summary>
+
+```python
+"""fp16 variant of the external-cache decode case (locks -inf dtype handling)."""
+np.random.seed(0)
+B, H_q, H_kv, L, D = 2, 4, 2, 8, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H_q, 1, D).astype(np.float16)
+K = np.random.rand(B, H_kv, L, D).astype(np.float16)
+V = np.random.rand(B, H_kv, L, D).astype(np.float16)
+nonpad_kv_seqlen = np.array([8, 5], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_gqa_causal_nonpad_decode_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_attn_3d_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_3d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_attn_3d_mask_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_3d_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_attn_4d_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_4d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_attn_4d_mask_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_4d_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_attn_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_attn_mask_bool</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(bool)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_bool",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_attn_mask_bool_4d</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6).astype(bool)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_bool_4d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, is_causal=1)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_causal_boolmask_nan_robustness</summary>
+
+```python
+"""Composed ``is_causal`` + boolean ``attn_mask`` NaN-robustness.
+
+The causal frontier (lower-triangular here, offset 0) and the boolean
+``attn_mask`` are intersected: a key is attended only if allowed by both.
+This exercises two pre-fix NaN sources on the same forward pass:
+
+* **Bug-1 (allowed cells stay finite).**  Query 0 is allowed key 0 by both
+  the causal frontier (``{0}``) and the mask (``True`` at key 0).  The old
+  ``(1 - attn_mask) * -inf`` conversion computes ``0 * -inf = NaN`` at that
+  allowed cell, poisoning the row.  The select conversion
+  ``where(attn_mask, 0, -inf)`` keeps it finite.
+* **Bug-2 (fully-masked row -> 0).**  Query 1 is allowed keys ``{0, 1}`` by
+  the causal frontier but the mask is ``False`` at both, so the combined
+  constraint allows no key.  ``softmax`` of an all-``-inf`` row is ``NaN``;
+  the fully-masked-row guard zeros it before the ``P @ V`` contraction so
+  the output row is ``0``.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(3)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S, D).astype(np.float32)
+K = np.random.rand(B, H, S, D).astype(np.float32)
+V = np.random.rand(B, H, S, D).astype(np.float32)
+# Row 0: key 0 allowed (Bug-1 allowed cell). Row 1: no key allowed -> fully
+# masked once intersected with the causal frontier (Bug-2 empty row).
+attn_mask = np.array([[True, False], [False, False]], dtype=np.bool_)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    is_causal=1,
+)
+
+# Bug-1: allowed cells are finite (no NaN anywhere). Bug-2: the fully-masked
+# query row is exactly zero, not NaN.
+assert np.all(np.isfinite(Y)), "allowed cells must be finite (Bug-1)"
+assert np.array_equal(Y[:, :, 1, :], np.zeros_like(Y[:, :, 1, :])), (
+    "fully-masked row must be zero (Bug-2)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_causal_boolmask_nan_robustness",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_diff_head_sizes</summary>
+
+```python
+node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_diff_head_sizes_attn_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_diff_head_sizes_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_diff_head_sizes_scaled</summary>
+
+```python
+scale = 1e-2
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, scale=scale)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_diff_head_sizes_softcap</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=2.0,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    softcap=2.0,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_diff_head_sizes_with_past_and_present</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_diff_heads_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_diff_head_sizes_with_past_and_present_mask3D</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_diff_heads_with_past_and_present_mask3d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_diff_head_sizes_with_past_and_present_mask4D</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_diff_heads_with_past_and_present_mask4d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_fp16</summary>
+
+```python
+node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float16)
+K = np.random.rand(2, 3, 6, 8).astype(np.float16)
+V = np.random.rand(2, 3, 6, 8).astype(np.float16)
+
+Y, _, _, _ = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_gqa</summary>
+
+```python
+node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_gqa",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_gqa_attn_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_gqa_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_gqa_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, is_causal=1)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_gqa_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_gqa_scaled</summary>
+
+```python
+scale = 1e-2
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+)
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, scale=scale)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_gqa_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_gqa_softcap</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=2.0,
+)
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, softcap=2.0)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_gqa_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_gqa_with_past_and_present</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_gqa_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_gqa_with_past_and_present_fp16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 9, 4, 8).astype(np.float16)
+K = np.random.rand(2, 3, 6, 8).astype(np.float16)
+V = np.random.rand(2, 3, 6, 8).astype(np.float16)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float16)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float16)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float16)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_gqa_with_past_and_present_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_scaled</summary>
+
+```python
+scale = 1e-2
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, scale=scale)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_softcap</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=2.0,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, softcap=2.0)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_softcap_with_neginf_mask</summary>
+
+```python
+"""Softcap + -inf mask: verifies softcap is applied BEFORE mask/bias.
+
+If ordering were wrong (mask then softcap), tanh(-inf/softcap) = -1,
+so softcap * tanh(-inf/softcap) = -softcap (finite).  That leaks
+probability to masked positions.  With correct ordering (softcap then
+mask), the -inf mask values survive to softmax and yield zero weight.
+"""
+np.random.seed(42)
+B, H, S_q, S_kv, D = 1, 1, 4, 6, 8
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, S_kv, D).astype(np.float32)
+V = np.random.rand(B, H, S_kv, D).astype(np.float32)
+
+# All Q positions are blocked from KV positions 4 and 5.
+attn_mask = np.zeros((S_q, S_kv), dtype=np.float32)
+attn_mask[:, 4:] = -np.inf
+
+softcap = 0.5
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    softcap=softcap,
+)
+
+Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask, softcap=softcap)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_softcap_neginf_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_softcap_with_neginf_mask_poison</summary>
+
+```python
+"""Softcap + -inf mask + poison values at masked KV positions.
+
+V has value 1000 at the masked positions (4 and 5).  With correct
+ordering the output stays in [0, 1] because the mask zeros out those
+positions.  With wrong ordering the output explodes (> 50), making
+the failure obvious even with loose tolerances.
+"""
+np.random.seed(42)
+B, H, S_q, S_kv, D = 1, 1, 4, 6, 8
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, S_kv, D).astype(np.float32)
+V = np.random.rand(B, H, S_kv, D).astype(np.float32)
+
+# Block all Q positions from KV positions 4 and 5.
+attn_mask = np.zeros((S_q, S_kv), dtype=np.float32)
+attn_mask[:, 4:] = -np.inf
+
+# Poison: if attention leaks to masked positions, output >> 1.
+V[:, :, 4:, :] = 1000.0
+
+softcap = 0.5
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    softcap=softcap,
+)
+
+Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask, softcap=softcap)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_softcap_neginf_mask_poison",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_past_and_present</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_past_and_present_qk_matmul</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias_3d_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias_3d_mask_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+    is_causal=1,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias_4d_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias_4d_mask_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+    is_causal=1,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_qk_matmul</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, qk_matmul_output = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_4d_with_qk_matmul",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_qk_matmul_bias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_4d_with_qk_matmul_bias",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_qk_matmul_softcap</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    softcap=2.0,
+    qk_matmul_output_mode=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    softcap=2.0,
+    qk_matmul_output_mode=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_4d_with_qk_matmul_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>attention_with_qk_matmul_softmax</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=3,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=3,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_4d_with_qk_matmul_softmax",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+### <a name="AveragePool"></a><a name="averagepool">**AveragePool**</a>
+
+  AveragePool consumes an input tensor X and applies average pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   average pooling consisting of computing the average on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape is calculated differently
+   depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
+   With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`. Sliding windows that would start in the right padded region are ignored.
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):
+   ```
+   VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
+   ```
+   The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#AveragePool-1">1</a>, <a href="Changelog.md#AveragePool-7">7</a>, <a href="Changelog.md#AveragePool-10">10</a>, <a href="Changelog.md#AveragePool-11">11</a>, <a href="Changelog.md#AveragePool-19">19</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>count_include_pad</tt> : int (default is 0)</dt>
+<dd>Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>averagepool_1d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32]
+output_shape: [1, 3, 31]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2],
+)
+x = np.random.randn(1, 3, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2]
+strides = [1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG")
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_1d_default")
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_ceil</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+    ceil_mode=True,
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[6, 7.5], [12, 13.5]]]]).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_ceil")
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_ceil_last_window_starts_on_pad</summary>
+
+```python
+"""input_shape: [1, 3, 2, 2]
+output_shape: [1, 3, 1, 1]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[3, 3],
+    pads=[1, 1, 1, 1],
+    ceil_mode=True,
+    count_include_pad=1,
+)
+x = np.array(
+    [
+        [
+            [[0.8580, 0.0786], [0.2692, 0.1537]],
+            [[0.8816, 0.4353], [0.5772, 0.6623]],
+            [[0.9067, 0.9483], [0.5970, 0.7630]],
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[0.1511]], [[0.2841]], [[0.3572]]]]).astype(np.float32)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_ceil_last_window_starts_on_pad",
+)
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 31, 31]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG")
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_default")
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[1, 1],
+    dilations=[2, 2],
+    ceil_mode=True,
+)
+
+# input shape: [1, 1, 4, 4]
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+y = np.array([[[[6, 7], [10, 11]]]]).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_dilations")
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_pads</summary>
+
+```python
+"""input_shape: [1, 3, 28, 28]
+output_shape: [1, 3, 30, 30]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[2, 2, 2, 2],
+)
+x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (3, 3)
+strides = (1, 1)
+pad_bottom = 2
+pad_top = 2
+pad_right = 2
+pad_left = 2
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+out_shape, extra_pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides, ceil_mode=False
+)
+padded = np.pad(
+    x,
+    (
+        (0, 0),
+        (0, 0),
+        (extra_pads[0], extra_pads[2]),
+        (extra_pads[1], extra_pads[3]),
+    ),
+    mode="constant",
+    constant_values=np.nan,
+)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=extra_pads,
+    pads=pads,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_pads")
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_pads_count_include_pad</summary>
+
+```python
+"""input_shape: [1, 3, 28, 28]
+output_shape: [1, 3, 30, 30]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[2, 2, 2, 2],
+    count_include_pad=1,
+)
+x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+x_shape = np.shape(x)
+dilations = (1, 1)
+kernel_shape = (3, 3)
+strides = (1, 1)
+pad_bottom = 2
+pad_top = 2
+pad_right = 2
+pad_left = 2
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+out_shape, extra_pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides, dilations, ceil_mode=False
+)
+padded = np.pad(
+    x,
+    (
+        (0, 0),
+        (0, 0),
+        (extra_pads[0], extra_pads[2]),
+        (extra_pads[1], extra_pads[3]),
+    ),
+    mode="constant",
+    constant_values=0,
+)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=extra_pads,
+    pads=pads,
+    count_include_pad=1,
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_pads_count_include_pad",
+)
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_precomputed_pads</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array(
+    [
+        [
+            [
+                [7, 7.5, 8, 8.5, 9],
+                [9.5, 10, 10.5, 11, 11.5],
+                [12, 12.5, 13, 13.5, 14],
+                [14.5, 15, 15.5, 16, 16.5],
+                [17, 17.5, 18, 18.5, 19],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_averagepool_2d_precomputed_pads"
+)
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_precomputed_pads_count_include_pad</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+    count_include_pad=1,
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array(
+    [
+        [
+            [
+                [2.5200, 3.6000, 4.8000, 4.0800, 3.2400],
+                [4.5600, 6.4000, 8.4000, 7.0400, 5.5200],
+                [7.2000, 10.0000, 13.0000, 10.8000, 8.4000],
+                [6.9600, 9.6000, 12.4000, 10.2400, 7.9200],
+                [6.1200, 8.4000, 10.8000, 8.8800, 6.8400],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_precomputed_pads_count_include_pad",
+)
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_precomputed_same_upper</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 3, 3]
+pad_shape: [2, 2] -> [1, 1, 1, 1] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+    auto_pad="SAME_UPPER",
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[4, 5.5, 7], [11.5, 13, 14.5], [19, 20.5, 22]]]]).astype(
+    np.float32
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_precomputed_same_upper",
+)
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_precomputed_strides</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[4, 6], [14, 16]]]]).astype(np.float32)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_precomputed_strides",
+)
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_same_lower</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_LOWER",
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_bottom = pad_shape[0] // 2
+pad_top = pad_shape[0] - pad_bottom
+pad_right = pad_shape[1] // 2
+pad_left = pad_shape[1] - pad_right
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+pads = (pad_top, pad_left, pad_bottom, pad_right)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=pads,
+    pads=pads,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_lower")
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_same_upper</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_UPPER",
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_top = pad_shape[0] // 2
+pad_bottom = pad_shape[0] - pad_top
+pad_left = pad_shape[1] // 2
+pad_right = pad_shape[1] - pad_left
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+pads = (pad_top, pad_left, pad_bottom, pad_right)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=pads,
+    pads=pads,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_upper")
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_2d_strides</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 10, 10]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    strides=[3, 3],
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (5, 5)
+strides = (3, 3)
+out_shape, pads = get_output_shape_explicit_padding(
+    None, x_shape[2:], kernel_shape, strides, ceil_mode=False
+)
+padded = x
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=pads,
+    pads=None,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_strides")
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_3d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32, 32]
+output_shape: [1, 3, 31, 31, 31]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+)
+x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2, 2, 2]
+strides = [1, 1, 1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG")
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_3d_default")
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_3d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+    strides=[1, 1, 1],
+    dilations=[2, 2, 2],
+    ceil_mode=True,
+)
+
+# input shape: [1, 1, 4, 4, 4]
+x = np.array(
+    [
+        [
+            [
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+y = np.array([[[[[6, 7], [10, 11]], [[6, 7], [10, 11]]]]]).astype(np.float32)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_averagepool_3d_dilations_small"
+)
+```
+
+</details>
+
+
+<details>
+<summary>averagepool_3d_dilations_large</summary>
+
+```python
+x_shape = (32, 32, 32)
+dilations = (2, 2, 2)
+kernel_shape = (5, 5, 5)
+strides = (3, 3, 3)
+count_include_pad = 0
+
+for count_include_pad in (0, 1):
+    for ceil_mode in (True, False):
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=kernel_shape,
+            strides=strides,
+            dilations=dilations,
+            count_include_pad=count_include_pad,
+            ceil_mode=ceil_mode,
+        )
+
+        x = np.random.randn(1, 1, *x_shape).astype(np.float32)
+        out_shape, extra_pads = get_output_shape_explicit_padding(
+            None,
+            x_shape,
+            kernel_shape,
+            strides,
+            dilations=dilations,
+            ceil_mode=ceil_mode,
+        )
+        padded = np.pad(
+            x,
+            (
+                (0, 0),
+                (0, 0),
+                (extra_pads[0], extra_pads[3]),
+                (extra_pads[1], extra_pads[4]),
+                (extra_pads[2], extra_pads[5]),
+            ),
+            mode="constant",
+            constant_values=0 if count_include_pad == 1 else np.nan,
+        )
+        y = pool(
+            padded,
+            (1, 1, *x_shape),
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=extra_pads,
+            pads=None,
+            dilations=dilations,
+            count_include_pad=count_include_pad,
+        )
+
+        test_name = f"test_averagepool_3d_dilations_large_count_include_pad_is_{count_include_pad}_ceil_mode_is_{ceil_mode}"
+        expect(node, inputs=[x], outputs=[y], name=test_name)
+```
+
+</details>
+
+
+### <a name="BatchNormalization"></a><a name="batchnormalization">**BatchNormalization**</a>
+
+  Carries out batch normalization as described in the paper
+  https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+  There are five required inputs 'X', 'scale', 'B', 'input_mean' and
+  'input_var'.
+  Note that 'input_mean' and 'input_var' are expected to be the estimated
+  statistics in inference mode (training_mode=False, default),
+  and the running statistics in training mode (training_mode=True).
+  There are multiple cases for the number of outputs, which we list below:
+
+  * Output case #1: Y, running_mean, running_var (training_mode=True)
+  * Output case #2: Y (training_mode=False)
+
+  When training_mode=False, extra outputs are invalid.
+  The outputs are updated as follows when training_mode=True:
+  ```
+  running_mean = input_mean * momentum + current_mean * (1 - momentum)
+  running_var = input_var * momentum + current_var * (1 - momentum)
+
+  Y = (X - current_mean) / sqrt(current_var + epsilon) * scale + B
+  ```
+  where:
+  ```
+  current_mean = ReduceMean(X, axis=all_except_channel_index)
+  current_var =  ReduceVar(X, axis=all_except_channel_index)
+  ```
+  Notice that `ReduceVar` refers to the population variance, and it equals to
+  `sum(sqrd(x_i - x_avg)) / N`
+  where `N` is the population size (this formula does not use sample size `N - 1`).
+
+  The computation of ReduceMean and ReduceVar uses float to avoid overflow for float16 inputs.
+
+  When training_mode=False:
+  ```
+  Y = (X - input_mean) / sqrt(input_var + epsilon) * scale + B
+  ```
+
+  For previous (depreciated) non-spatial cases, implementors are suggested
+  to flatten the input shape to (N x C * D1 * D2 * ... * Dn) before a BatchNormalization Op.
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#BatchNormalization-1">1</a>, <a href="Changelog.md#BatchNormalization-6">6</a>, <a href="Changelog.md#BatchNormalization-7">7</a>, <a href="Changelog.md#BatchNormalization-9">9</a>, <a href="Changelog.md#BatchNormalization-14">14</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>momentum</tt> : float (default is 0.9)</dt>
+<dd>Factor used in computing the running mean and variance.e.g., running_mean = running_mean * momentum + mean * (1 - momentum).</dd>
+<dt><tt>training_mode</tt> : int (default is 0)</dt>
+<dd>If set to true, it indicates BatchNormalization is being used for training, and outputs 1 and 2 are to be computed.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size, C is the number of channels. Statistics are computed for every channel of C over N and D1 to Dn dimensions. For image data, input dimensions become (N x C x H x W). The op also accepts single dimension input of size N in which case C is assumed to be 1</dd>
+<dt><tt>scale</tt> (differentiable) : T1</dt>
+<dd>Scale tensor of shape (C).</dd>
+<dt><tt>B</tt> (differentiable) : T1</dt>
+<dd>Bias tensor of shape (C).</dd>
+<dt><tt>input_mean</tt> (differentiable) : T2</dt>
+<dd>running (training) or estimated (testing) mean tensor of shape (C).</dd>
+<dt><tt>input_var</tt> (differentiable) : T2</dt>
+<dd>running (training) or estimated (testing) variance tensor of shape (C).</dd>
+</dl>
+
+#### Outputs (1 - 3)
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>The output tensor of the same shape as X</dd>
+<dt><tt>running_mean</tt> (optional, non-differentiable) : T2</dt>
+<dd>The running mean after the BatchNormalization operator.</dd>
+<dt><tt>running_var</tt> (optional, non-differentiable) : T2</dt>
+<dd>The running variance after the BatchNormalization operator. This op uses the population size (N) for calculating variance, and not the sample size N-1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain scale and bias types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain mean and variance types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>batchnormalization</summary>
+
+```python
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+mean = np.random.randn(3).astype(np.float32)
+var = np.random.rand(3).astype(np.float32)
+y = _batchnorm_test_mode(x, s, bias, mean, var).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "BatchNormalization",
+    inputs=["x", "s", "bias", "mean", "var"],
+    outputs=["y"],
+)
+
+# output size: (2, 3, 4, 5)
+expect(
+    node,
+    inputs=[x, s, bias, mean, var],
+    outputs=[y],
+    name="test_batchnorm_example",
+)
+
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+mean = np.random.randn(3).astype(np.float32)
+var = np.random.rand(3).astype(np.float32)
+epsilon = 1e-2
+y = _batchnorm_test_mode(x, s, bias, mean, var, epsilon).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "BatchNormalization",
+    inputs=["x", "s", "bias", "mean", "var"],
+    outputs=["y"],
+    epsilon=epsilon,
+)
+
+# output size: (2, 3, 4, 5)
+expect(
+    node,
+    inputs=[x, s, bias, mean, var],
+    outputs=[y],
+    name="test_batchnorm_epsilon",
+)
+```
+
+</details>
+
+
+<details>
+<summary>train</summary>
+
+```python
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+mean = np.random.randn(3).astype(np.float32)
+var = np.random.rand(3).astype(np.float32)
+# using np.bool(1) while generating test data with "'bool' object has no attribute 'dtype'"
+# working around by using np.byte(1).astype(bool)
+training_mode = 1
+y, output_mean, output_var = _batchnorm_training_mode(x, s, bias, mean, var)
+
+node = onnx.helper.make_node(
+    "BatchNormalization",
+    inputs=["x", "s", "bias", "mean", "var"],
+    outputs=["y", "output_mean", "output_var"],
+    training_mode=training_mode,
+)
+
+# output size: (2, 3, 4, 5)
+expect(
+    node,
+    inputs=[x, s, bias, mean, var],
+    outputs=[y, output_mean, output_var],
+    name="test_batchnorm_example_training_mode",
+)
+
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+mean = np.random.randn(3).astype(np.float32)
+var = np.random.rand(3).astype(np.float32)
+training_mode = 1
+momentum = 0.9
+epsilon = 1e-2
+y, output_mean, output_var = _batchnorm_training_mode(
+    x, s, bias, mean, var, momentum, epsilon
+)
+
+node = onnx.helper.make_node(
+    "BatchNormalization",
+    inputs=["x", "s", "bias", "mean", "var"],
+    outputs=["y", "output_mean", "output_var"],
+    epsilon=epsilon,
+    training_mode=training_mode,
+)
+
+# output size: (2, 3, 4, 5)
+expect(
+    node,
+    inputs=[x, s, bias, mean, var],
+    outputs=[y, output_mean, output_var],
+    name="test_batchnorm_epsilon_training_mode",
+)
+```
+
+</details>
+
+
+### <a name="Bernoulli"></a><a name="bernoulli">**Bernoulli**</a>
+
+  Draws binary random numbers (0 or 1) from a Bernoulli distribution. The input tensor should be a tensor
+  containing probabilities p (a value in the range [0,1]) to be used for drawing the binary random number,
+  where an output of 1 is produced with probability p and an output of 0 is produced with probability (1-p).
+
+  This operator is non-deterministic and may not produce the same values in different
+  implementations (even if a seed is specified).
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Bernoulli-15">15</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>The data type for the elements of the output tensor. if not specified, we will use the data type of the input tensor.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>All values in input have to be in the range:[0, 1].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>The returned output tensor only has values 0 or 1, same shape as input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool)</dt>
+<dd>Constrain output types to all numeric tensors and bool tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>bernoulli_with_dtype</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Bernoulli",
+    inputs=["x"],
+    outputs=["y"],
+    dtype=onnx.TensorProto.DOUBLE,
+)
+
+x = np.random.uniform(0.0, 1.0, 10).astype(np.float32)
+y = bernoulli_reference_implementation(x, float)
+expect(node, inputs=[x], outputs=[y], name="test_bernoulli_double")
+```
+
+</details>
+
+
+<details>
+<summary>bernoulli_with_seed</summary>
+
+```python
+seed = float(0)
+node = onnx.helper.make_node(
+    "Bernoulli",
+    inputs=["x"],
+    outputs=["y"],
+    seed=seed,
+)
+
+x = np.random.uniform(0.0, 1.0, 10).astype(np.float32)
+y = bernoulli_reference_implementation(x, np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_bernoulli_seed")
+```
+
+</details>
+
+
+<details>
+<summary>bernoulli_without_dtype</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Bernoulli",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.uniform(0.0, 1.0, 10).astype(float)
+y = bernoulli_reference_implementation(x, float)
+expect(node, inputs=[x], outputs=[y], name="test_bernoulli")
+```
+
+</details>
+
+
+### <a name="BitCast"></a><a name="bitcast">**BitCast**</a>
+
+  Reinterprets the binary representation of a tensor as a different data type,
+  specified by the 'to' attribute. Unlike Cast, BitCast preserves the exact bit
+  pattern without any value conversion.
+
+  The target data type must have the same bit-width as the input data type.
+  The output tensor has the same shape as the input tensor.
+  All types except string are supported. Implementations must treat the
+  underlying bytes as little endian.
+
+#### Version
+
+This version of the operator has been available since version 26 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the input tensor is bitwise reinterpreted. Must be one of the non-string types from DataType enum in TensorProto. The target type must have the same bit-width as the input type.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (non-differentiable) : T1</dt>
+<dd>Input tensor to be bitcast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T2</dt>
+<dd>Output tensor with the same shape as the input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input types. Bitcasting from string is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain output types. Bitcasting to string is not supported.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>bitcast_2d_float32_to_int32</summary>
+
+```python
+"""Test bitcasting 2D array from float32 to int32."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT32,
+)
+x = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float32)
+y = x.view(np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_2d_float32_to_int32")
+```
+
+</details>
+
+
+<details>
+<summary>bitcast_bool_to_uint8</summary>
+
+```python
+"""Test bitcasting from bool to uint8 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.UINT8,
+)
+x = np.array([True, False, True, False], dtype=np.bool_)
+y = x.view(np.uint8)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_bool_to_uint8")
+```
+
+</details>
+
+
+<details>
+<summary>bitcast_float32_to_int32</summary>
+
+```python
+"""Test bitcasting from float32 to int32 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT32,
+)
+x = np.array([1.0, -2.5, 3.75], dtype=np.float32)
+y = x.view(np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_float32_to_int32")
+```
+
+</details>
+
+
+<details>
+<summary>bitcast_float64_to_int64</summary>
+
+```python
+"""Test bitcasting from float64 to int64 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT64,
+)
+x = np.array([1.0, -2.5, 3.75], dtype=np.float64)
+y = x.view(np.int64)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_float64_to_int64")
+```
+
+</details>
+
+
+<details>
+<summary>bitcast_int32_to_float32</summary>
+
+```python
+"""Test bitcasting from int32 to float32 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.FLOAT,
+)
+x = np.array([1065353216, -1071644672, 1081081856], dtype=np.int32)
+y = x.view(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_int32_to_float32")
+```
+
+</details>
+
+
+<details>
+<summary>bitcast_int64_to_float64</summary>
+
+```python
+"""Test bitcasting from int64 to float64 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.DOUBLE,
+)
+x = np.array(
+    [4607182418800017408, -4611686018427387904, 4614256656552045184],
+    dtype=np.int64,
+)
+y = x.view(np.float64)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_int64_to_float64")
+```
+
+</details>
+
+
+<details>
+<summary>bitcast_int8_to_uint8</summary>
+
+```python
+"""Test bitcasting from int8 to uint8 (same size, different signedness)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.UINT8,
+)
+x = np.array([-1, -128, 127, 0], dtype=np.int8)
+y = x.view(np.uint8)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_int8_to_uint8")
+```
+
+</details>
+
+
+<details>
+<summary>bitcast_scalar_float32_to_int32</summary>
+
+```python
+"""Test bitcasting scalar from float32 to int32."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT32,
+)
+x = np.array(1.0, dtype=np.float32)
+y = x.view(np.int32)
+expect(
+    node, inputs=[x], outputs=[y], name="test_bitcast_scalar_float32_to_int32"
+)
+```
+
+</details>
+
+
+<details>
+<summary>bitcast_uint16_to_int16</summary>
+
+```python
+"""Test bitcasting from uint16 to int16 (same size, different signedness)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT16,
+)
+x = np.array([1, 32768, 65535], dtype=np.uint16)
+y = x.view(np.int16)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_uint16_to_int16")
+```
+
+</details>
+
+
+<details>
+<summary>bitcast_uint32_to_int32</summary>
+
+```python
+"""Test bitcasting from uint32 to int32 (same size, different signedness)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT32,
+)
+x = np.array([4294967295, 2147483648, 2147483647], dtype=np.uint32)
+y = x.view(np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_uint32_to_int32")
+```
+
+</details>
+
+
+### <a name="BitShift"></a><a name="bitshift">**BitShift**</a>
+
+  Bitwise shift operator performs element-wise operation. For each input element, if the
+  attribute "direction" is "RIGHT", this operator moves its binary representation toward
+  the right side so that the input value is effectively decreased. If the attribute "direction"
+  is "LEFT", bits of binary representation moves toward the left side, which results the
+  increase of its actual value. The input X is the tensor to be shifted and another input
+  Y specifies the amounts of shifting. For example, if "direction" is "Right", X is [1, 4],
+  and S is [1, 1], the corresponding output Z would be [0, 2]. If "direction" is "LEFT" with
+  X=[1, 2] and S=[1, 2], the corresponding output Y would be [2, 8].
+
+  Because this operator supports Numpy-style broadcasting, X's and Y's shapes are
+  not necessarily identical.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>direction</tt> : string (required)</dt>
+<dd>Direction of moving bits. It can be either "RIGHT" (for right shift) or "LEFT" (for left shift).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>First operand, input to be shifted.</dd>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Second operand, amounts of shift.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64)</dt>
+<dd>Constrain input and output types to integer tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>left_unit16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint16)
+y = np.array([1, 2, 3]).astype(np.uint16)
+z = x << y  # expected output [32, 16, 8]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint16")
+```
+
+</details>
+
+
+<details>
+<summary>left_unit32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint32)
+y = np.array([1, 2, 3]).astype(np.uint32)
+z = x << y  # expected output [32, 16, 8]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint32")
+```
+
+</details>
+
+
+<details>
+<summary>left_unit64</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint64)
+y = np.array([1, 2, 3]).astype(np.uint64)
+z = x << y  # expected output [32, 16, 8]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>left_unit8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint8)
+y = np.array([1, 2, 3]).astype(np.uint8)
+z = x << y  # expected output [32, 16, 8]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint8")
+```
+
+</details>
+
+
+<details>
+<summary>right_unit16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint16)
+y = np.array([1, 2, 3]).astype(np.uint16)
+z = x >> y  # expected output [8, 1, 0]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint16")
+```
+
+</details>
+
+
+<details>
+<summary>right_unit32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint32)
+y = np.array([1, 2, 3]).astype(np.uint32)
+z = x >> y  # expected output [8, 1, 0]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint32")
+```
+
+</details>
+
+
+<details>
+<summary>right_unit64</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint64)
+y = np.array([1, 2, 3]).astype(np.uint64)
+z = x >> y  # expected output [8, 1, 0]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>right_unit8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint8)
+y = np.array([1, 2, 3]).astype(np.uint8)
+z = x >> y  # expected output [8, 1, 0]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint8")
+```
+
+</details>
+
+
+### <a name="BitwiseAnd"></a><a name="bitwiseand">**BitwiseAnd**</a>
+
+  Returns the tensor resulting from performing the bitwise `and` operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the bitwise operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the bitwise operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input to integer tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>bitwiseand</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseAnd",
+    inputs=["x", "y"],
+    outputs=["bitwiseand"],
+)
+
+# 2d
+x = create_random_int((3, 4), np.int32)
+y = create_random_int((3, 4), np.int32)
+z = np.bitwise_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i32_2d")
+
+# 3d
+x = create_random_int((3, 4, 5), np.int16)
+y = create_random_int((3, 4, 5), np.int16)
+z = np.bitwise_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i16_3d")
+```
+
+</details>
+
+
+<details>
+<summary>bitwiseand_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseAnd",
+    inputs=["x", "y"],
+    outputs=["bitwiseand"],
+)
+
+# 3d vs 1d
+x = create_random_int((3, 4, 5), np.uint64)
+y = create_random_int((5,), np.uint64)
+z = np.bitwise_and(x, y)
+expect(
+    node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui64_bcast_3v1d"
+)
+
+# 4d vs 3d
+x = create_random_int((3, 4, 5, 6), np.uint8)
+y = create_random_int((4, 5, 6), np.uint8)
+z = np.bitwise_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui8_bcast_4v3d")
+```
+
+</details>
+
+
+### <a name="BitwiseNot"></a><a name="bitwisenot">**BitwiseNot**</a>
+
+  Returns the bitwise not of the input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input/output to integer tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>bitwisenot</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseNot",
+    inputs=["x"],
+    outputs=["bitwise_not"],
+)
+
+# 2d
+x = create_random_int((3, 4), np.int32)
+y = np.bitwise_not(x)
+expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_2d")
+
+# 3d
+x = create_random_int((3, 4, 5), np.uint16)
+y = np.bitwise_not(x)
+expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_3d")
+
+# 4d
+x = create_random_int((3, 4, 5, 6), np.uint8)
+y = np.bitwise_not(x)
+expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_4d")
+```
+
+</details>
+
+
+### <a name="BitwiseOr"></a><a name="bitwiseor">**BitwiseOr**</a>
+
+  Returns the tensor resulting from performing the bitwise `or` operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the bitwise operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the bitwise operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input to integer tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>bitwiseor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseOr",
+    inputs=["x", "y"],
+    outputs=["bitwiseor"],
+)
+# 2d
+x = create_random_int((3, 4), np.int32)
+y = create_random_int((3, 4), np.int32)
+z = np.bitwise_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i32_2d")
+
+# 4d
+x = create_random_int((3, 4, 5, 6), np.int8)
+y = create_random_int((3, 4, 5, 6), np.int8)
+z = np.bitwise_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i16_4d")
+```
+
+</details>
+
+
+<details>
+<summary>bitwiseor_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseOr",
+    inputs=["x", "y"],
+    outputs=["bitwiseor"],
+)
+
+# 3d vs 1d
+x = create_random_int((3, 4, 5), np.uint64)
+y = create_random_int((5,), np.uint64)
+z = np.bitwise_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui64_bcast_3v1d")
+
+# 4d vs 3d
+x = create_random_int((3, 4, 5, 6), np.uint8)
+y = create_random_int((4, 5, 6), np.uint8)
+z = np.bitwise_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui8_bcast_4v3d")
+```
+
+</details>
+
+
+### <a name="BitwiseXor"></a><a name="bitwisexor">**BitwiseXor**</a>
+
+  Returns the tensor resulting from performing the bitwise `xor` operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the bitwise operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the bitwise operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input to integer tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>bitwiseor_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseXor",
+    inputs=["x", "y"],
+    outputs=["bitwisexor"],
+)
+
+# 3d vs 1d
+x = create_random_int((3, 4, 5), np.uint64)
+y = create_random_int((5,), np.uint64)
+z = np.bitwise_xor(x, y)
+expect(
+    node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui64_bcast_3v1d"
+)
+
+# 4d vs 3d
+x = create_random_int((3, 4, 5, 6), np.uint8)
+y = create_random_int((4, 5, 6), np.uint8)
+z = np.bitwise_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui8_bcast_4v3d")
+```
+
+</details>
+
+
+<details>
+<summary>bitwisexor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseXor",
+    inputs=["x", "y"],
+    outputs=["bitwisexor"],
+)
+
+# 2d
+x = create_random_int((3, 4), np.int32)
+y = create_random_int((3, 4), np.int32)
+z = np.bitwise_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i32_2d")
+
+# 3d
+x = create_random_int((3, 4, 5), np.int16)
+y = create_random_int((3, 4, 5), np.int16)
+z = np.bitwise_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i16_3d")
+```
+
+</details>
+
+
+### <a name="BlackmanWindow"></a><a name="blackmanwindow">**BlackmanWindow**</a>
+
+  Generates a Blackman window as described in the paper https://ieeexplore.ieee.org/document/1455106.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>output_datatype</tt> : int (default is 1)</dt>
+<dd>The data type of the output tensor. Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T2. The default value is 1 = FLOAT. </dd>
+<dt><tt>periodic</tt> : int (default is 1)</dt>
+<dd>If 1, returns a window to be used as periodic function. If 0, return a symmetric window. When 'periodic' is specified, hann computes a window of length size + 1 and returns the first size points. The default value is 1. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>A scalar value indicating the length of the window.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T2</dt>
+<dd>A Blackman window with length: size. The output has the shape: [size].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain the input size to int32_t or int64_t.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>blackmanwindow</summary>
+
+```python
+# Test periodic window
+node = onnx.helper.make_node(
+    "BlackmanWindow",
+    inputs=["x"],
+    outputs=["y"],
+)
+size = np.int32(10)
+a0 = 0.42
+a1 = -0.5
+a2 = 0.08
+y = a0
+y += a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+y += a2 * np.cos(4 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_blackmanwindow",
+)
+
+# Test symmetric window
+node = onnx.helper.make_node(
+    "BlackmanWindow", inputs=["x"], outputs=["y"], periodic=0
+)
+size = np.int32(10)
+a0 = 0.42
+a1 = -0.5
+a2 = 0.08
+y = a0
+y += a1 * np.cos(
+    2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+)
+y += a2 * np.cos(
+    4 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_blackmanwindow_symmetric",
+)
+```
+
+</details>
+
+
+### <a name="Cast"></a><a name="cast">**Cast**</a>
+
+  The operator casts the elements of a given input tensor to a data type
+  specified by the 'to' argument and returns an output tensor of the same size in
+  the converted type. The 'to' argument must be one of the data types specified
+  in the 'DataType' enum field in the TensorProto message.
+
+  Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+  (e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+  yield result 100. There are some string literals reserved for special floating-point values;
+  "+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+  Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+  this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+  to string tensors, plain floating-point representation (such as "314.15926") would be used.
+  Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+  of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+  Conversion from a numerical type to any numerical type is always allowed.
+  User must be aware of precision loss and value change caused by range difference between two types.
+  For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+  an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+  In more detail, the conversion among numerical types should follow these rules
+  if the destination type is not a float 8 type.
+
+  * Casting from floating point to:
+    * floating point: +/- infinity if OOR (out of range).
+    * fixed point: undefined if OOR.
+    * bool: +/- 0.0 to False; all else to True.
+  * Casting from fixed point to:
+    * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+    * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+      signed types). For example, 200 (int16) -> -56 (int8).
+    * bool: zero to False; nonzero to True.
+  * Casting from bool to:
+    * floating point: `{1.0, 0.0}`.
+    * fixed point: `{1, 0}`.
+    * bool: no change.
+
+  Float 8 types (E4M3FN, E4M3FNUZ, E5M2, E5M2FNUZ) were introduced to speed up the training of
+  deep models. By default the conversion of a float *x* obeys
+  to the following rules. `[x]` means the value rounded to
+  the target mantissa width.
+
+  | x                 | E4M3FN   | E4M3FNUZ | E5M2     | E5M2FNUZ |
+  | ----------------- | -------- | -------- | -------- | -------- |
+  | 0                 | 0        | 0        | 0        | 0        |
+  | -0                | -0       | 0        | -0       | 0        |
+  | NaN               | NaN      | NaN      | NaN      | NaN      |
+  | Inf               | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+  | -Inf              | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+  | \[x\] > FLT_MAX   | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+  | \[x\] \< -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+  | else              | RNE      | RNE      | RNE      | RNE      |
+
+  The behavior changes if the parameter 'saturate' is set to False.
+  The rules then become:
+
+  | x                 | E4M3FN | E4M3FNUZ | E5M2 | E5M2FNUZ |
+  | ----------------- | ------ | -------- | ---- | -------- |
+  | 0                 | 0      | 0        | 0    | 0        |
+  | -0                | -0     | 0        | -0   | 0        |
+  | NaN               | NaN    | NaN      | NaN  | NaN      |
+  | -NaN              | -NaN   | NaN      | -NaN | NaN      |
+  | Inf               | NaN    | NaN      | Inf  | NaN      |
+  | -Inf              | -NaN   | NaN      | -Inf | NaN      |
+  | \[x\] > FLT_MAX   | NaN    | NaN      | Inf  | NaN      |
+  | \[x\] \< -FLT_MAX | NaN    | NaN      | -Inf | NaN      |
+  | else              | RNE    | RNE      | RNE  | RNE      |
+
+  FLOAT8E8M0 type was introduced to enable [Microscaling (MX) formats](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf).
+  When casting to FLOAT8E8M0, the rounding behavior can be specified using the `round_mode` and `saturate` attributes.
+  The current CUDA behavior is to round up and saturate. Casting negative values to FLOAT8E8M0 gives undefined behavior.
+  The following table describes the casting behavior of special values to FLOAT8E8M0 in the two most common cases.
+
+  | x                 | saturate + up | non-saturate + nearest |
+  | ----------------- | ------------- | ---------------------  |
+  | 0                 | 0             | NaN                    |
+  | -0                | Unspecified   | Unspecified            |
+  | NaN               | NaN           | NaN                    |
+  | Inf               | E8M0_MAX      | NaN                    |
+  | x > E8M0_MAX      | E8M0_MAX      | NaN                    |
+  | x < E8M0_MIN      | E8M0_MIN      | NaN                    |
+  | x < 0             | Unspecified   | Unspecified            |
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Cast-1">1</a>, <a href="Changelog.md#Cast-6">6</a>, <a href="Changelog.md#Cast-9">9</a>, <a href="Changelog.md#Cast-13">13</a>, <a href="Changelog.md#Cast-19">19</a>, <a href="Changelog.md#Cast-21">21</a>, <a href="Changelog.md#Cast-23">23</a>, <a href="Changelog.md#Cast-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>round_mode</tt> : string (default is up)</dt>
+<dd>Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. `up`: round to nearest value away from zero, `down`: round to nearest value towards zero, `nearest`: round to nearest value and ties round up.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. All cases are fully described in the tables inserted in the operator description.</dd>
+<dt><tt>to</tt> : int (required)</dt>
+<dd>The data type to which the elements of the input tensor are cast. Strictly must be one of the types from DataType enum in TensorProto</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor with the same shape as input with type specified by the 'to' argument</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>cast</summary>
+
+```python
+test_cases = [
+    ("FLOAT", "FLOAT16"),
+    ("FLOAT", "DOUBLE"),
+    ("FLOAT16", "FLOAT"),
+    ("FLOAT16", "DOUBLE"),
+    ("DOUBLE", "FLOAT"),
+    ("DOUBLE", "FLOAT16"),
+    ("FLOAT", "BFLOAT16"),
+    ("BFLOAT16", "FLOAT"),
+    ("FLOAT", "FLOAT8E4M3FN"),
+    ("FLOAT16", "FLOAT8E4M3FN"),
+    ("FLOAT", "FLOAT8E4M3FNUZ"),
+    ("FLOAT16", "FLOAT8E4M3FNUZ"),
+    ("FLOAT8E4M3FN", "FLOAT"),
+    ("FLOAT8E4M3FN", "FLOAT16"),
+    ("FLOAT8E4M3FNUZ", "FLOAT"),
+    ("FLOAT8E4M3FNUZ", "FLOAT16"),
+    ("FLOAT", "FLOAT8E5M2"),
+    ("FLOAT16", "FLOAT8E5M2"),
+    ("FLOAT", "FLOAT8E5M2FNUZ"),
+    ("FLOAT16", "FLOAT8E5M2FNUZ"),
+    ("FLOAT8E5M2", "FLOAT"),
+    ("FLOAT8E5M2", "FLOAT16"),
+    ("FLOAT8E5M2FNUZ", "FLOAT"),
+    ("FLOAT8E5M2FNUZ", "FLOAT16"),
+    ("FLOAT", "UINT4"),
+    ("FLOAT16", "UINT4"),
+    ("FLOAT", "INT4"),
+    ("FLOAT16", "INT4"),
+    ("UINT4", "FLOAT"),
+    ("UINT4", "FLOAT16"),
+    ("UINT4", "UINT8"),
+    ("INT4", "FLOAT"),
+    ("INT4", "FLOAT16"),
+    ("INT4", "INT8"),
+    ("FLOAT4E2M1", "FLOAT"),
+    ("FLOAT4E2M1", "FLOAT16"),
+    ("FLOAT", "FLOAT4E2M1"),
+    ("FLOAT16", "FLOAT4E2M1"),
+    ("FLOAT", "UINT2"),
+    ("FLOAT16", "UINT2"),
+    ("FLOAT", "INT2"),
+    ("FLOAT16", "INT2"),
+    ("UINT2", "FLOAT"),
+    ("UINT2", "FLOAT16"),
+    ("UINT2", "UINT8"),
+    ("INT2", "FLOAT"),
+    ("INT2", "FLOAT16"),
+    ("INT2", "INT8"),
+]
+
+for from_type, to_type in test_cases:
+    if from_type == to_type:
+        # Skip cases where from_type and to_type are the same
+        continue
+    from_dtype = getattr(TensorProto, from_type)
+    to_dtype = getattr(TensorProto, to_type)
+    from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+    to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+
+    if from_type == "BFLOAT16" or to_type == "BFLOAT16":
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.816468",
+                "0.21087195",
+                "0.7229038",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 4)
+
+    elif from_type in F8_TYPES or to_type in F8_TYPES:
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.7229038",
+                "1000000",
+                "1e-7",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+                "-0.0000001",
+                "0.0000001",
+                "-1000000",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 5)
+    elif from_type in ("UINT4", "INT4") or to_type in ("UINT4", "INT4"):
+        np_fp32 = np.arange(-9, 16).astype(np.float32)
+        input_shape = (5, 5)
+    elif from_type in ("UINT2", "INT2") or to_type in ("UINT2", "INT2"):
+        np_fp32 = np.arange(-3, 4).astype(np.float32)
+        input_shape = (7, 1)
+    elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1":
+        np_fp32 = np.array(
+            [
+                "0.48",
+                "0.25",
+                "1.05",
+                "-3.5",
+                "-8",
+                "9",
+                "1000000",
+                "1e-7",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+                "-4",
+                "0.01",
+                "-0.0",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 5)
+
+    else:
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.816468",
+                "0.21087195",
+                "0.7229038",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+            ],
+            dtype=np.float32,
+        ).reshape([3, 4])
+        input_shape = (3, 4)
+
+    if from_type in F8_TYPES:
+        np_from = onnx.numpy_helper.saturate_cast(np_fp32, from_np_dtype)
+        input = make_tensor(
+            "input",
+            from_dtype,
+            input_shape,
+            vals=np_from,
+            raw=True,
+        )
+    elif from_type in FOUR_BIT_TYPES:
+        np_from = np_fp32.astype(from_np_dtype)
+        packed = onnx.numpy_helper._pack_4bitx2(np_from)
+        # No byteswap needed on big-endian machines as _pack_4bitx2()
+        # returns a numpy array with uint8 datatype.
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    elif from_type in TWO_BIT_TYPES:
+        np_from = np_fp32.astype(from_np_dtype)
+        packed = onnx.numpy_helper._pack_2bitx4(np_from)
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    else:
+        np_from = np_fp32.astype(from_np_dtype)
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=np_from, raw=True
+        )
+
+    if to_type in F8_TYPES:
+        output = make_tensor(
+            "output",
+            to_dtype,
+            input_shape,
+            vals=onnx.numpy_helper.saturate_cast(np_from, to_np_dtype),
+            raw=True,
+        )
+    elif to_type in FOUR_BIT_TYPES:
+        packed = onnx.numpy_helper._pack_4bitx2(np_from.astype(to_np_dtype))
+        # No byteswap needed on big-endian machines as _pack_4bitx2()
+        # returns a numpy array with uint8 datatype.
+        output = make_tensor(
+            "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    elif to_type in TWO_BIT_TYPES:
+        packed = onnx.numpy_helper._pack_2bitx4(np_from.astype(to_np_dtype))
+        output = make_tensor(
+            "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    else:
+        output = make_tensor(
+            "output",
+            to_dtype,
+            input_shape,
+            vals=np_from.astype(to_np_dtype),
+            raw=True,
+        )
+
+    node = onnx.helper.make_node(
+        "Cast",
+        inputs=["input"],
+        outputs=["output"],
+        to=to_dtype,
+    )
+    expect(
+        node,
+        inputs=[input],
+        outputs=[output],
+        name="test_cast_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+
+
+<details>
+<summary>e8m0</summary>
+
+```python
+np_fp32 = np.array(
+    [
+        "0.0",
+        "0.124",
+        "0.25",
+        "0.5",
+        "1.1",
+        "2.0",
+        "4.0",
+        "8.0",
+    ],
+    dtype=np.float32,
+)
+test_cases = [
+    ("FLOAT", "FLOAT8E8M0"),
+    ("FLOAT16", "FLOAT8E8M0"),
+    ("FLOAT8E8M0", "FLOAT"),
+    ("FLOAT8E8M0", "FLOAT16"),
+]
+for from_type, to_type in test_cases:
+    if from_type == "FLOAT":
+        input_np = np_fp32
+        output_np = to_float8e8m0(np_fp32)
+    elif from_type == "FLOAT16":
+        input_np = np_fp32.astype(np.float16)
+        output_np = to_float8e8m0(input_np)
+    elif from_type == "FLOAT8E8M0":
+        input_np = to_float8e8m0(np_fp32)
+        if to_type == "FLOAT":
+            output_np = input_np.astype(np.float32)
+        elif to_type == "FLOAT16":
+            output_np = input_np.astype(np.float16)
+        else:
+            raise ValueError(
+                f"Conversion from {from_type} to {to_type} is not tested."
+            )
+    else:
+        raise ValueError(
+            f"Conversion from {from_type} to {to_type} is not tested."
+        )
+    input = make_tensor(
+        "input",
+        getattr(TensorProto, from_type),
+        [2, 4],
+        input_np,
+        raw=True,
+    )
+    output = make_tensor(
+        "output",
+        getattr(TensorProto, to_type),
+        [2, 4],
+        output_np,
+        raw=True,
+    )
+    if to_type == "FLOAT8E8M0":
+        node = onnx.helper.make_node(
+            "Cast",
+            inputs=["input"],
+            outputs=["output"],
+            to=getattr(TensorProto, to_type),
+            saturate=1,
+            round_mode="up",
+        )
+    else:
+        node = onnx.helper.make_node(
+            "Cast",
+            inputs=["input"],
+            outputs=["output"],
+            to=getattr(TensorProto, to_type),
+        )
+
+    expect(
+        node,
+        inputs=[input],
+        outputs=[output],
+        name="test_cast_e8m0_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+
+
+<details>
+<summary>saturate_false</summary>
+
+```python
+test_cases = itertools.product(
+    [
+        "FLOAT",
+        "FLOAT16",
+    ],
+    [
+        "FLOAT8E4M3FN",
+        "FLOAT8E4M3FNUZ",
+        "FLOAT8E5M2",
+        "FLOAT8E5M2FNUZ",
+    ],
+)
+input_shape = (3, 5)
+for from_type, to_type in test_cases:
+    from_dtype = getattr(TensorProto, from_type)
+    to_dtype = getattr(TensorProto, to_type)
+    from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+    to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+    np_fp32 = np.array(
+        [
+            "0.47892547",
+            "0.48033667",
+            "0.49968487",
+            "0.81910545",
+            "0.47031248",
+            "0.7229038",
+            "1000000",
+            "1e-7",
+            "NaN",
+            "INF",
+            "+INF",
+            "-INF",
+            "-0.0000001",
+            "0.0000001",
+            "-1000000",
+        ],
+        dtype=np.float32,
+    )
+
+    input = make_tensor(
+        "input",
+        from_dtype,
+        input_shape,
+        vals=np_fp32.astype(from_np_dtype),
+        raw=True,
+    )
+    output = make_tensor(
+        "output",
+        to_dtype,
+        input_shape,
+        vals=np_fp32.astype(from_np_dtype).astype(to_np_dtype),
+        raw=True,
+    )
+
+    node = onnx.helper.make_node(
+        "Cast",
+        inputs=["input"],
+        outputs=["output"],
+        to=to_dtype,
+        saturate=0,
+    )
+    expect(
+        node,
+        inputs=[input],
+        outputs=[output],
+        name="test_cast_no_saturate_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+
+
+### <a name="CastLike"></a><a name="castlike">**CastLike**</a>
+
+  The operator casts the elements of a given input tensor (the first input) to
+  the same data type as the elements of the second input tensor.
+  See documentation of the Cast operator for further details.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#CastLike-15">15</a>, <a href="Changelog.md#CastLike-19">19</a>, <a href="Changelog.md#CastLike-21">21</a>, <a href="Changelog.md#CastLike-23">23</a>, <a href="Changelog.md#CastLike-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>round_mode</tt> : string (default is up)</dt>
+<dd>Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. `up`: round to nearest value away from zero, `down`: round to nearest value towards zero, `nearest`: round to nearest value and ties round up. Please refer to operator Cast description for further details.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 conversion (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. Please refer to operator Cast description for further details.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T1</dt>
+<dd>Input tensor to be cast.</dd>
+<dt><tt>target_type</tt> (non-differentiable) : T2</dt>
+<dd>The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T2</dt>
+<dd>Output tensor produced by casting the first input tensor to have the same type as the second input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input types. Casting from complex is not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain output types. Casting to complex is not supported.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>castlike</summary>
+
+```python
+test_cases = [
+    ("FLOAT", "FLOAT16"),
+    ("FLOAT", "DOUBLE"),
+    ("FLOAT16", "FLOAT"),
+    ("FLOAT16", "DOUBLE"),
+    ("DOUBLE", "FLOAT"),
+    ("DOUBLE", "FLOAT16"),
+    ("FLOAT", "BFLOAT16"),
+    ("BFLOAT16", "FLOAT"),
+    ("FLOAT", "FLOAT8E4M3FN"),
+    ("FLOAT16", "FLOAT8E4M3FN"),
+    ("FLOAT", "FLOAT8E4M3FNUZ"),
+    ("FLOAT16", "FLOAT8E4M3FNUZ"),
+    ("FLOAT8E4M3FN", "FLOAT"),
+    ("FLOAT8E4M3FN", "FLOAT16"),
+    ("FLOAT8E4M3FNUZ", "FLOAT"),
+    ("FLOAT8E4M3FNUZ", "FLOAT16"),
+    ("FLOAT", "FLOAT8E5M2"),
+    ("FLOAT16", "FLOAT8E5M2"),
+    ("FLOAT", "FLOAT8E5M2FNUZ"),
+    ("FLOAT16", "FLOAT8E5M2FNUZ"),
+    ("FLOAT8E5M2", "FLOAT"),
+    ("FLOAT8E5M2", "FLOAT16"),
+    ("FLOAT8E5M2FNUZ", "FLOAT"),
+    ("FLOAT8E5M2FNUZ", "FLOAT16"),
+    ("FLOAT", "UINT4"),
+    ("FLOAT16", "UINT4"),
+    ("FLOAT", "INT4"),
+    ("FLOAT16", "INT4"),
+    ("UINT4", "FLOAT"),
+    ("UINT4", "FLOAT16"),
+    ("UINT4", "UINT8"),
+    ("INT4", "FLOAT"),
+    ("INT4", "FLOAT16"),
+    ("INT4", "INT8"),
+    ("FLOAT4E2M1", "FLOAT"),
+    ("FLOAT4E2M1", "FLOAT16"),
+    ("FLOAT", "FLOAT4E2M1"),
+    ("FLOAT16", "FLOAT4E2M1"),
+    ("FLOAT", "UINT2"),
+    ("FLOAT16", "UINT2"),
+    ("FLOAT", "INT2"),
+    ("FLOAT16", "INT2"),
+    ("UINT2", "FLOAT"),
+    ("UINT2", "FLOAT16"),
+    ("UINT2", "UINT8"),
+    ("INT2", "FLOAT"),
+    ("INT2", "FLOAT16"),
+    ("INT2", "INT8"),
+]
+
+f8_types = {"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"}
+
+for from_type, to_type in test_cases:
+    if from_type == to_type:
+        # Skip cases where from_type and to_type are the same
+        continue
+    from_dtype = getattr(TensorProto, from_type)
+    to_dtype = getattr(TensorProto, to_type)
+    from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+    to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+
+    if from_type == "BFLOAT16" or to_type == "BFLOAT16":
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.816468",
+                "0.21087195",
+                "0.7229038",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 4)
+
+    elif from_type in f8_types or to_type in f8_types:
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.7229038",
+                "1000000",
+                "1e-7",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+                "-0.0000001",
+                "0.0000001",
+                "-1000000",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 5)
+    elif from_type in ("UINT4", "INT4") or to_type in ("UINT4", "INT4"):
+        np_fp32 = np.arange(-9, 16).astype(np.float32)
+        input_shape = (5, 5)
+    elif from_type in ("UINT2", "INT2") or to_type in ("UINT2", "INT2"):
+        np_fp32 = np.arange(-3, 4).astype(np.float32)
+        input_shape = (7, 1)
+    elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1":
+        np_fp32 = np.array(
+            [
+                "0.48",
+                "0.25",
+                "1.05",
+                "-3.5",
+                "-8",
+                "9",
+                "1000000",
+                "1e-7",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+                "-4",
+                "0.01",
+                "-0.0",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 5)
+
+    else:
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.816468",
+                "0.21087195",
+                "0.7229038",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+            ],
+            dtype=np.float32,
+        ).reshape([3, 4])
+        input_shape = (3, 4)
+
+    if from_type in F8_TYPES:
+        np_from = onnx.numpy_helper.saturate_cast(np_fp32, from_np_dtype)
+        input = make_tensor(
+            "input",
+            from_dtype,
+            input_shape,
+            vals=np_from,
+            raw=True,
+        )
+    elif from_type in FOUR_BIT_TYPES:
+        np_from = np_fp32.astype(from_np_dtype)
+        packed = onnx.numpy_helper._pack_4bitx2(np_from)
+        # No byteswap needed on big-endian machines as _pack_4bitx2()
+        # returns a numpy array with uint8 datatype.
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    elif from_type in TWO_BIT_TYPES:
+        np_from = np_fp32.astype(from_np_dtype)
+        packed = onnx.numpy_helper._pack_2bitx4(np_from)
+        # No byteswap needed on big-endian machines as _pack_2bitx4()
+        # returns a numpy array with uint8 datatype.
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    else:
+        np_from = np_fp32.astype(from_np_dtype)
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=np_from, raw=True
+        )
+
+    if to_type in F8_TYPES:
+        output = make_tensor(
+            "output",
+            to_dtype,
+            input_shape,
+            vals=onnx.numpy_helper.saturate_cast(np_from, to_np_dtype),
+            raw=True,
+        )
+    elif to_type in FOUR_BIT_TYPES:
+        packed = onnx.numpy_helper._pack_4bitx2(np_from.astype(to_np_dtype))
+        # No byteswap needed on big-endian machines as _pack_4bitx2()
+        # returns a numpy array with uint8 datatype.
+        output = make_tensor(
+            "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    elif to_type in TWO_BIT_TYPES:
+        packed = onnx.numpy_helper._pack_2bitx4(np_from.astype(to_np_dtype))
+        # No byteswap needed on big-endian machines as _pack_2bitx4()
+        # returns a numpy array with uint8 datatype.
+        output = make_tensor(
+            "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    else:
+        output = make_tensor(
+            "output",
+            to_dtype,
+            input_shape,
+            vals=np_from.astype(to_np_dtype),
+            raw=True,
+        )
+
+    like = make_tensor("like", to_dtype, (0,), vals=[])
+
+    node = onnx.helper.make_node(
+        "CastLike",
+        inputs=["input", "like"],
+        outputs=["output"],
+    )
+
+    expect(
+        node,
+        inputs=[input, like],
+        outputs=[output],
+        name="test_castlike_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+
+
+<details>
+<summary>saturate_false</summary>
+
+```python
+test_cases = itertools.product(
+    [
+        "FLOAT",
+        "FLOAT16",
+    ],
+    [
+        "FLOAT8E4M3FN",
+        "FLOAT8E4M3FNUZ",
+        "FLOAT8E5M2",
+        "FLOAT8E5M2FNUZ",
+    ],
+)
+input_shape = (3, 5)
+for from_type, to_type in test_cases:
+    from_dtype = getattr(TensorProto, from_type)
+    to_dtype = getattr(TensorProto, to_type)
+    from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+    to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+    np_fp32 = np.array(
+        [
+            "0.47892547",
+            "0.48033667",
+            "0.49968487",
+            "0.81910545",
+            "0.47031248",
+            "0.7229038",
+            "1000000",
+            "1e-7",
+            "NaN",
+            "INF",
+            "+INF",
+            "-INF",
+            "-0.0000001",
+            "0.0000001",
+            "-1000000",
+        ],
+        dtype=np.float32,
+    )
+
+    input = make_tensor(
+        "input",
+        from_dtype,
+        input_shape,
+        vals=np_fp32.astype(from_np_dtype),
+        raw=True,
+    )
+    output = make_tensor(
+        "output",
+        to_dtype,
+        input_shape,
+        vals=np_fp32.astype(from_np_dtype).astype(to_np_dtype),
+        raw=True,
+    )
+
+    like = make_tensor("like", to_dtype, (0,), vals=[])
+
+    node = onnx.helper.make_node(
+        "CastLike",
+        inputs=["input", "like"],
+        outputs=["output"],
+        saturate=0,
+    )
+
+    expect(
+        node,
+        inputs=[input, like],
+        outputs=[output],
+        name="test_castlike_no_saturate_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+
+
+### <a name="CausalConvWithState"></a><a name="causalconvwithstate">**CausalConvWithState**</a>
+
+  Stateful causal 1D depthwise convolution.
+
+  Used by Gated DeltaNet (Qwen3.5) and Mamba (Jamba, FalconMamba) as a preprocessing step.
+  Replaces the 3-op pattern (Concat + Conv + Slice) with a single fused operation.
+
+  The convolution is causal (looks only at current and past positions) and depthwise
+  (each channel is convolved independently with its own kernel).
+
+  The input, weight, past_state, output, and present_state tensors are rank-3 with
+  shape (batch_size, channels, length). The optional bias input is rank-1 with
+  shape (channels). For higher-dimensional data, use Reshape nodes before and
+  after this operator to pack extra dimensions into the batch or channel axis.
+
+  Weight layout: (channels, 1, k) for depthwise convolution.
+  The carry state stores the last (k-1) positions for incremental decode.
+
+  The optional activation attribute supports fused SiLU/Swish activation.
+
+
+#### Version
+
+This version of the operator has been available since version 27 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>activation</tt> : string (default is none)</dt>
+<dd>Fused activation function. One of: 'silu', 'swish', 'none'. Default is 'none'.</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor with shape (batch_size, channels, length). Channels-first layout.</dd>
+<dt><tt>weight</tt> (differentiable) : T</dt>
+<dd>Depthwise convolution kernel with shape (channels, 1, k) where k is the kernel size. The middle dim of size 1 follows the ONNX `Conv` weight layout `(M, C/group, k1, ..., kn)`: since this op is always depthwise, `group = channels`, so `C/group = 1`. Keeping this layout makes the weight tensor a drop-in for a depthwise `Conv(group=channels)` weight, so `Conv` <-> `CausalConvWithState` rewrites require no reshape.</dd>
+<dt><tt>bias</tt> (optional, differentiable) : T</dt>
+<dd>Optional per-channel bias with shape (channels).</dd>
+<dt><tt>past_state</tt> (optional, non-differentiable) : T</dt>
+<dd>Carry state from previous step with shape (batch_size, channels, k - 1). If not provided, padding is zero.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Convolution output with same shape as input.</dd>
+<dt><tt>present_state</tt> (non-differentiable) : T</dt>
+<dd>Updated carry state with shape (batch_size, channels, k - 1). Contains the last (k - 1) values of the effective padded/concatenated sequence along the causal axis, including any values from past_state or zero-padding when the current input is shorter than k - 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>b1_c1_degenerate</summary>
+
+```python
+# Mamba/GDN inner-head edge case: B=1, C=1.
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 1, 1, 6, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_b1_c1_degenerate",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>basic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_basic",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>decode_step</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "bias", "past_state"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 1, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+bias = np.random.randn(channels).astype(np.float32)
+past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+output, present_state = _compute(
+    input_, weight, bias=bias, past_state=past_state
+)
+
+expect(
+    node,
+    inputs=[input_, weight, bias, past_state],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_decode_step",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>fp16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.rand(batch_size, channels, length).astype(np.float16)
+weight = np.random.rand(channels, 1, k).astype(np.float16)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>kernel_size_one</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 1
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_kernel_size_one",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>short_input_no_past_state</summary>
+
+```python
+# L < k-1 with no past_state: zero-pad is wider than the input.
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 2, 5
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_short_input_no_past_state",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>silu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+    activation="silu",
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight, activation="silu")
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_silu",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>silu_fp16</summary>
+
+```python
+# fp16 + SiLU: the reference upcasts Sigmoid/Mul to float32, so the
+# function-body expansion must do the same to stay numerically faithful.
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+    activation="silu",
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.rand(batch_size, channels, length).astype(np.float16)
+weight = np.random.rand(channels, 1, k).astype(np.float16)
+
+output, present_state = _compute(input_, weight, activation="silu")
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_silu_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>silu_with_past_state</summary>
+
+```python
+# Fused activation combined with concat-from-past variant of PaddedInput.
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "", "past_state"],
+    outputs=["output", "present_state"],
+    activation="silu",
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+output, present_state = _compute(
+    input_, weight, past_state=past_state, activation="silu"
+)
+
+expect(
+    node,
+    inputs=[input_, weight, past_state],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_silu_with_past_state",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>swish_alias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+    activation="swish",
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight, activation="swish")
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_swish_alias",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>with_bias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "bias"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+bias = np.random.randn(channels).astype(np.float32)
+
+output, present_state = _compute(input_, weight, bias=bias)
+
+expect(
+    node,
+    inputs=[input_, weight, bias],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_with_bias",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>with_bias_and_past_state</summary>
+
+```python
+# Multi-token (T>1) path through Concat(past, input) -> Conv(+bias).
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "bias", "past_state"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+bias = np.random.randn(channels).astype(np.float32)
+past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+output, present_state = _compute(
+    input_, weight, bias=bias, past_state=past_state
+)
+
+expect(
+    node,
+    inputs=[input_, weight, bias, past_state],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_with_bias_and_past_state",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>with_past_state</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "", "past_state"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+output, present_state = _compute(input_, weight, past_state=past_state)
+
+expect(
+    node,
+    inputs=[input_, weight, past_state],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_with_past_state",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+### <a name="Ceil"></a><a name="ceil">**Ceil**</a>
+
+  Ceil takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the ceil is, y = ceil(x), is applied to
+  the tensor elementwise. If x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Ceil-1">1</a>, <a href="Changelog.md#Ceil-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>ceil</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Ceil",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.5, 1.2]).astype(np.float32)
+y = np.ceil(x)  # expected output [-1., 2.]
+expect(node, inputs=[x], outputs=[y], name="test_ceil_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.ceil(x)
+expect(node, inputs=[x], outputs=[y], name="test_ceil")
+```
+
+</details>
+
+
+### <a name="Celu"></a><a name="celu">**Celu**</a>
+
+  Continuously Differentiable Exponential Linear Units:
+  Perform the linear unit element-wise on the input tensor X
+  using formula:
+
+  ```
+  max(0,x) + min(0,alpha*(exp(x/alpha)-1))
+  ```
+
+#### Version
+
+This version of the operator has been available since version 28 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Celu-12">12</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>The Alpha value in Celu formula which control the shape of the unit. The default value is 1.0.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>celu</summary>
+
+```python
+alpha = 2.0
+node = onnx.helper.make_node(
+    "Celu",
+    inputs=["X"],
+    outputs=["Y"],
+    alpha=alpha,
+)
+
+input_data = np.array(
+    [
+        [
+            [[0.8439683], [0.5665144], [0.05836735]],
+            [[0.02916367], [0.12964272], [0.5060197]],
+            [[0.79538304], [0.9411346], [0.9546573]],
+        ],
+        [
+            [[0.17730942], [0.46192095], [0.26480448]],
+            [[0.6746842], [0.01665257], [0.62473077]],
+            [[0.9240844], [0.9722341], [0.11965699]],
+        ],
+        [
+            [[0.41356155], [0.9129373], [0.59330076]],
+            [[0.81929934], [0.7862604], [0.11799799]],
+            [[0.69248444], [0.54119414], [0.07513223]],
+        ],
+    ],
+    dtype=np.float32,
+)
+
+# Calculate expected output data
+positive_input = np.maximum(0, input_data)
+negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1))
+expected_output = positive_input + negative_input
+
+expect(node, inputs=[input_data], outputs=[expected_output], name="test_celu")
+```
+
+</details>
+
+
+<details>
+<summary>celu_bfloat16</summary>
+
+```python
+alpha = 2.0
+node = onnx.helper.make_node(
+    "Celu",
+    inputs=["X"],
+    outputs=["Y"],
+    alpha=alpha,
+)
+
+input_data = np.array([-3.0, -0.5, 0.0, 0.5, 3.0], dtype=ml_dtypes.bfloat16)
+
+positive_input = np.maximum(0, input_data)
+negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1))
+expected_output = (positive_input + negative_input).astype(ml_dtypes.bfloat16)
+
+expect(
+    node,
+    inputs=[input_data],
+    outputs=[expected_output],
+    name="test_celu_bfloat16",
+)
+```
+
+</details>
+
+
+<details>
+<summary>celu_float16</summary>
+
+```python
+alpha = 2.0
+node = onnx.helper.make_node(
+    "Celu",
+    inputs=["X"],
+    outputs=["Y"],
+    alpha=alpha,
+)
+
+input_data = np.array([-3.0, -0.5, 0.0, 0.5, 3.0], dtype=np.float16)
+
+positive_input = np.maximum(0, input_data)
+negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1))
+expected_output = (positive_input + negative_input).astype(np.float16)
+
+expect(
+    node,
+    inputs=[input_data],
+    outputs=[expected_output],
+    name="test_celu_float16",
+)
+```
+
+</details>
+
+
+### <a name="CenterCropPad"></a><a name="centercroppad">**CenterCropPad**</a>
+
+  Center crop or pad an input to given dimensions.
+
+  The crop/pad dimensions can be specified for a subset of the `axes`; unspecified dimensions will remain unchanged.
+
+  If the input dimensions are larger than the target crop dimensions, a centered cropping window will be extracted
+  from the input. The starting value for the cropping window is rounded down, which means that if the difference
+  between the input shape and the crop shape is odd, the cropping window will be shifted half a pixel to the left
+  of the input center.
+
+  If the input dimensions are smaller than the target crop dimensions, the input will be padded equally on both sides
+  to center it in the output. In cases where the total number of padding pixels is odd, an additional pixel will be
+  added to the right side.
+
+  The padding value used is zero.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>If provided, it specifies a subset of axes that 'shape' refer to. If not provided, all axes are assumed [0, 1, ..., r-1], where r = rank(data). Negative value means counting dimensions from the back. Accepted range is [-r, r-1], where r = rank(data). Behavior is undefined if an axis is repeated.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input_data</tt> (differentiable) : T</dt>
+<dd>Input to extract the centered crop from.</dd>
+<dt><tt>shape</tt> (non-differentiable) : Tind</dt>
+<dd>1-D tensor representing the cropping window dimensions.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_data</tt> (differentiable) : T</dt>
+<dd>Output data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>center_crop_pad_crop</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+)
+
+# First dim is even diff, second is uneven
+x = np.random.randn(20, 10, 3).astype(np.float32)
+shape = np.array([10, 7, 3], dtype=np.int64)
+y = x[5:15, 1:8, :]
+
+expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_crop")
+```
+
+</details>
+
+
+<details>
+<summary>center_crop_pad_crop_and_pad</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+)
+
+# Cropping on first dim, padding on second, third stays the same
+x = np.random.randn(20, 8, 3).astype(np.float32)
+shape = np.array([10, 10, 3], dtype=np.int64)
+y = np.zeros([10, 10, 3], dtype=np.float32)
+y[:, 1:9, :] = x[5:15, :, :]
+
+expect(
+    node,
+    inputs=[x, shape],
+    outputs=[y],
+    name="test_center_crop_pad_crop_and_pad",
+)
+```
+
+</details>
+
+
+<details>
+<summary>center_crop_pad_crop_axes_chw</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+    axes=[1, 2],
+)
+
+# Cropping on second dim, padding on third, first stays the same
+x = np.random.randn(3, 20, 8).astype(np.float32)
+shape = np.array([10, 9], dtype=np.int64)
+y = np.zeros([3, 10, 9], dtype=np.float32)
+y[:, :, :8] = x[:, 5:15, :]
+
+expect(
+    node,
+    inputs=[x, shape],
+    outputs=[y],
+    name="test_center_crop_pad_crop_axes_chw",
+)
+```
+
+</details>
+
+
+<details>
+<summary>center_crop_pad_crop_axes_hwc</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+    axes=[0, 1],
+)
+
+# Cropping on first dim, padding on second, third stays the same
+x = np.random.randn(20, 8, 3).astype(np.float32)
+shape = np.array([10, 9], dtype=np.int64)
+y = np.zeros([10, 9, 3], dtype=np.float32)
+y[:, :8, :] = x[5:15, :, :]
+
+expect(
+    node,
+    inputs=[x, shape],
+    outputs=[y],
+    name="test_center_crop_pad_crop_axes_hwc",
+)
+```
+
+</details>
+
+
+<details>
+<summary>center_crop_pad_crop_negative_axes_hwc</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+    axes=[-3, -2],
+)
+
+# Cropping on first dim, padding on second, third stays the same
+x = np.random.randn(20, 8, 3).astype(np.float32)
+shape = np.array([10, 9], dtype=np.int64)
+y = np.zeros([10, 9, 3], dtype=np.float32)
+y[:, :8, :] = x[5:15, :, :]
+
+expect(
+    node,
+    inputs=[x, shape],
+    outputs=[y],
+    name="test_center_crop_pad_crop_negative_axes_hwc",
+)
+```
+
+</details>
+
+
+<details>
+<summary>center_crop_pad_pad</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+)
+
+# First dim is even diff, second is uneven
+x = np.random.randn(10, 7, 3).astype(np.float32)
+shape = np.array([20, 10, 3], dtype=np.int64)
+y = np.zeros([20, 10, 3], dtype=np.float32)
+y[5:15, 1:8, :] = x
+
+expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_pad")
+```
+
+</details>
+
+
+### <a name="Clip"></a><a name="clip">**Clip**</a>
+
+  Clip operator limits the given input within an interval. The interval is
+  specified by the inputs 'min' and 'max'. They default to
+  numeric_limits::lowest() and numeric_limits::max(), respectively.
+  When 'min' is greater than 'max', the clip operator sets all the 'input' values to
+  the value of 'max'. Thus, this is equivalent to 'Min(max, Max(input, min))'.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Clip-1">1</a>, <a href="Changelog.md#Clip-6">6</a>, <a href="Changelog.md#Clip-11">11</a>, <a href="Changelog.md#Clip-12">12</a>
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor whose elements to be clipped</dd>
+<dt><tt>min</tt> (optional, non-differentiable) : T</dt>
+<dd>Minimum value, under which element is replaced by min. It must be a scalar(tensor of empty shape).</dd>
+<dt><tt>max</tt> (optional, non-differentiable) : T</dt>
+<dd>Maximum value, above which element is replaced by max. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor with clipped input elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>clip</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", "min", "max"],
+    outputs=["y"],
+)
+
+x = np.array([-2, 0, 2]).astype(np.float32)
+min_val = np.float32(-1)
+max_val = np.float32(1)
+y = np.clip(x, min_val, max_val)  # expected output [-1., 0., 1.]
+expect(
+    node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_example"
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, min_val, max_val)
+expect(node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip")
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", "min", "max"],
+    outputs=["y"],
+)
+
+min_val = np.float32(-5)
+max_val = np.float32(5)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.array([-1, 0, 1]).astype(np.float32)
+expect(
+    node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_inbounds"
+)
+
+x = np.array([-6, 0, 6]).astype(np.float32)
+y = np.array([-5, 0, 5]).astype(np.float32)
+expect(
+    node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_outbounds"
+)
+
+x = np.array([-1, 0, 6]).astype(np.float32)
+y = np.array([-1, 0, 5]).astype(np.float32)
+expect(
+    node,
+    inputs=[x, min_val, max_val],
+    outputs=[y],
+    name="test_clip_splitbounds",
+)
+
+x = np.array([-2, 0, 6]).astype(np.float32)
+y = np.array([1, 1, 1]).astype(np.float32)
+min_val = np.float32(2)
+max_val = np.float32(1)
+expect(
+    node,
+    inputs=[x, min_val, max_val],
+    outputs=[y],
+    name="test_clip_min_greater_than_max",
+)
+```
+
+</details>
+
+
+<details>
+<summary>clip_default</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", "min"],
+    outputs=["y"],
+)
+min_val = np.float32(0)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, min_val, np.inf)
+expect(node, inputs=[x, min_val], outputs=[y], name="test_clip_default_min")
+
+no_min = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", no_min, "max"],
+    outputs=["y"],
+)
+max_val = np.float32(0)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, -np.inf, max_val)
+expect(node, inputs=[x, max_val], outputs=[y], name="test_clip_default_max")
+
+no_max = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", no_min, no_max],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.array([-1, 0, 1]).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_clip_default_inbounds")
+```
+
+</details>
+
+
+<details>
+<summary>clip_default_int8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", "min"],
+    outputs=["y"],
+)
+min_val = np.int8(0)
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.clip(x, min_val, np.iinfo(np.int8).max)
+expect(
+    node, inputs=[x, min_val], outputs=[y], name="test_clip_default_int8_min"
+)
+
+no_min = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", no_min, "max"],
+    outputs=["y"],
+)
+max_val = np.int8(0)
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.clip(x, np.iinfo(np.int8).min, max_val)
+expect(
+    node, inputs=[x, max_val], outputs=[y], name="test_clip_default_int8_max"
+)
+
+no_max = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", no_min, no_max],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.int8)
+y = np.array([-1, 0, 1]).astype(np.int8)
+expect(node, inputs=[x], outputs=[y], name="test_clip_default_int8_inbounds")
+```
+
+</details>
+
+
+### <a name="Col2Im"></a><a name="col2im">**Col2Im**</a>
+
+  The operator rearranges column blocks back into a multidimensional image
+
+  Col2Im behaves similarly to PyTorch's fold https://pytorch.org/docs/stable/generated/torch.nn.Fold.html,
+  but it only supports *batched* multi-dimensional image tensors.
+  Another implementation in Python with N-dimension support can be found at https://github.com/f-dangel/unfoldNd/.
+
+  NOTE:
+    Although specifying image_shape looks redundant because it could be calculated from
+    convolution formulas, it is required as input for more advanced scenarios as explained
+    at PyTorch's implementation (https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/Col2Im.cpp#L10)
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>1-dimensional tensor with dilation value along each spatial axis of the image. If not present, the dilation defaults to 1 along each spatial axis of the image.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>1-dimensional tensor with padding value for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin is the number of pixels added at the beginning of axis `i` and xi_end is the number of pixels added at the end of axis `i`. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>1-dimensional tensor with stride value along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input data tensor to be rearranged from column blocks back into an image. This is a 3-dimensional tensor containing [N, C * n-ary-product(block_shape), L], where N is batch dimension, C is image channel dimension and L is number of blocks.The blocks are enumerated in increasing lexicographic-order of their indices.For example, with an image-size 10*20 and block-size 9*18, there would be 2*3 blocks, enumerated in the order block(0, 0), block(0, 1), block(0, 2), block(1, 0), block(1, 1), block(1, 2).</dd>
+<dt><tt>image_shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>The shape of the spatial dimensions of the image after rearranging the column blocks.This is a 1-dimensional tensor with size of at least 2, containing the value [H_img, W_img]  for a 2-D image or [dim_i1, dim_i2, ..., dim_iN] for a N-D image.</dd>
+<dt><tt>block_shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>The shape of the block to apply on the input.This is a 1-dimensional tensor of size of at least 2, containing the value [H_block, W_block]  for a 2-D image or [dim_b1, dim_b2, ..., dim_bN] for a N-D block.This is the block-shape before dilation is applied to it.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor produced by rearranging blocks into an image.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all numeric tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>col2im</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [1.0, 6.0, 11.0, 16.0, 21.0],  # (1, 5, 5)
+            [2.0, 7.0, 12.0, 17.0, 22.0],
+            [3.0, 8.0, 13.0, 18.0, 23.0],
+            [4.0, 9.0, 14.0, 19.0, 24.0],
+            [5.0, 0.0, 15.0, 20.0, 25.0],
+        ]
+    ]
+).astype(np.float32)
+
+image_shape = np.array([5, 5]).astype(np.int64)
+block_shape = np.array([1, 5]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Col2Im", ["input", "image_shape", "block_shape"], ["output"]
+)
+
+output = np.array(
+    [
+        [
+            [
+                [1.0, 2.0, 3.0, 4.0, 5.0],  # (1, 1, 5, 5)
+                [6.0, 7.0, 8.0, 9.0, 0.0],
+                [11.0, 12.0, 13.0, 14.0, 15.0],
+                [16.0, 17.0, 18.0, 19.0, 20.0],
+                [21.0, 22.0, 23.0, 24.0, 25.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im",
+)
+```
+
+</details>
+
+
+<details>
+<summary>col2im_5d</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56],  # (1, 10, 12)
+            [2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57],
+            [3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53, 58],
+            [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59],
+            [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60],
+            [61, 66, 71, 76, 81, 86, 91, 96, 101, 106, 111, 116],
+            [62, 67, 72, 77, 82, 87, 92, 97, 102, 107, 112, 117],
+            [63, 68, 73, 78, 83, 88, 93, 98, 103, 108, 113, 118],
+            [64, 69, 74, 79, 84, 89, 94, 99, 104, 109, 114, 119],
+            [65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120],
+        ]
+    ]
+).astype(np.float32)
+image_shape = np.array([3, 4, 5]).astype(np.int64)
+block_shape = np.array([1, 1, 5]).astype(np.int64)
+
+output = np.array(
+    [
+        [
+            [
+                [
+                    [1, 2, 3, 4, 5],  # (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, 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],
+                ],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Col2Im", ["input", "image_shape", "block_shape"], ["output"]
+)
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im_5d",
+)
+```
+
+</details>
+
+
+<details>
+<summary>col2im_dilations</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [1.0, 5.0, 9.0, 13.0, 17],  # (1, 4, 5)
+            [2.0, 6.0, 10.0, 14.0, 18],
+            [3.0, 7.0, 11.0, 15.0, 19],
+            [4.0, 8.0, 12.0, 16.0, 20],
+        ]
+    ]
+).astype(np.float32)
+image_shape = np.array([6, 6]).astype(np.int64)
+block_shape = np.array([2, 2]).astype(np.int64)
+
+output = np.array(
+    [
+        [
+            [
+                [1.0, 0.0, 0.0, 0.0, 0.0, 2.0],  # (1, 1, 6, 6)
+                [8.0, 0.0, 0.0, 0.0, 0.0, 10.0],
+                [16.0, 0.0, 0.0, 0.0, 0.0, 18.0],
+                [24.0, 0.0, 0.0, 0.0, 0.0, 26.0],
+                [32.0, 0.0, 0.0, 0.0, 0.0, 34.0],
+                [19.0, 0.0, 0.0, 0.0, 0.0, 20.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Col2Im",
+    ["input", "image_shape", "block_shape"],
+    ["output"],
+    dilations=[1, 5],
+)
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im_dilations",
+)
+```
+
+</details>
+
+
+<details>
+<summary>col2im_pads</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [
+                1.0,
+                6.0,
+                11.0,
+                16.0,
+                21.0,
+                26,
+                31,
+                36,
+                41,
+                46,
+                51,
+                56,
+                61,
+                66,
+                71,
+            ],  # (1, 5, 15)
+            [
+                2.0,
+                7.0,
+                12.0,
+                17.0,
+                22.0,
+                27,
+                32,
+                37,
+                42,
+                47,
+                52,
+                57,
+                62,
+                67,
+                72,
+            ],
+            [
+                3.0,
+                8.0,
+                13.0,
+                18.0,
+                23.0,
+                28,
+                33,
+                38,
+                43,
+                48,
+                53,
+                58,
+                63,
+                68,
+                73,
+            ],
+            [
+                4.0,
+                9.0,
+                14.0,
+                19.0,
+                24.0,
+                29,
+                34,
+                39,
+                44,
+                49,
+                54,
+                59,
+                64,
+                69,
+                74,
+            ],
+            [
+                5.0,
+                10.0,
+                15.0,
+                20.0,
+                25.0,
+                30,
+                35,
+                40,
+                45,
+                50,
+                55,
+                60,
+                65,
+                70,
+                75,
+            ],
+        ]
+    ]
+).astype(np.float32)
+image_shape = np.array([5, 5]).astype(np.int64)
+block_shape = np.array([1, 5]).astype(np.int64)
+
+output = np.array(
+    [
+        [
+            [
+                [8.0, 21.0, 24.0, 27.0, 24.0],  # (1, 1, 5, 5)
+                [38.0, 66.0, 69.0, 72.0, 54.0],
+                [68.0, 111.0, 114.0, 117.0, 84.0],
+                [98.0, 156.0, 159.0, 162.0, 114.0],
+                [128.0, 201.0, 204.0, 207.0, 144.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Col2Im",
+    ["input", "image_shape", "block_shape"],
+    ["output"],
+    pads=[0, 1, 0, 1],
+)
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im_pads",
+)
+```
+
+</details>
+
+
+<details>
+<summary>col2im_strides</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [0.0, 0.0, 0.0, 0.0],  # (1, 9, 4)
+            [1.0, 1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.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],
+            [1.0, 1.0, 1.0, 1.0],
+            [0.0, 0.0, 0.0, 0.0],
+        ]
+    ]
+).astype(np.float32)
+image_shape = np.array([5, 5]).astype(np.int64)
+block_shape = np.array([3, 3]).astype(np.int64)
+
+output = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 1.0, 1.0, 1.0],  # (1, 1, 5, 5)
+                [1.0, 0.0, 1.0, 0.0, 0.0],
+                [0.0, 2.0, 1.0, 2.0, 1.0],
+                [1.0, 0.0, 1.0, 0.0, 0.0],
+                [0.0, 1.0, 0.0, 1.0, 0.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Col2Im",
+    ["input", "image_shape", "block_shape"],
+    ["output"],
+    strides=[2, 2],
+)
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im_strides",
+)
+```
+
+</details>
+
+
+### <a name="Compress"></a><a name="compress">**Compress**</a>
+
+  Selects slices from an input tensor along a given axis where condition evaluates to True for each axis index.
+      In case axis is not provided, input is flattened before elements are selected.
+      Compress behaves like numpy.compress: https://docs.scipy.org/doc/numpy/reference/generated/numpy.compress.html
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Compress-9">9</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>(Optional) Axis along which to take slices. If not specified, input is flattened before elements being selected. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>condition</tt> (non-differentiable) : T1</dt>
+<dd>Rank 1 tensor of booleans to indicate which slices or data elements to be selected. Its length can be less than the input length along the axis or the flattened input size if axis is not specified. In such cases data slices or elements exceeding the condition length are discarded.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r if axis is specified. Otherwise output is a Tensor of rank 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain to boolean tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>compress_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Compress",
+    inputs=["input", "condition"],
+    outputs=["output"],
+    axis=0,
+)
+input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+condition = np.array([0, 1, 1])
+output = np.compress(condition, input, axis=0)
+# print(output)
+# [[ 3.  4.]
+# [ 5.  6.]]
+
+expect(
+    node,
+    inputs=[input, condition.astype(bool)],
+    outputs=[output],
+    name="test_compress_0",
+)
+```
+
+</details>
+
+
+<details>
+<summary>compress_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Compress",
+    inputs=["input", "condition"],
+    outputs=["output"],
+    axis=1,
+)
+input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+condition = np.array([0, 1])
+output = np.compress(condition, input, axis=1)
+# print(output)
+# [[ 2.]
+# [ 4.]
+# [ 6.]]
+
+expect(
+    node,
+    inputs=[input, condition.astype(bool)],
+    outputs=[output],
+    name="test_compress_1",
+)
+```
+
+</details>
+
+
+<details>
+<summary>compress_default_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Compress",
+    inputs=["input", "condition"],
+    outputs=["output"],
+)
+input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+condition = np.array([0, 1, 0, 0, 1])
+output = np.compress(condition, input)
+# print(output)
+# [ 2., 5.]
+
+expect(
+    node,
+    inputs=[input, condition.astype(bool)],
+    outputs=[output],
+    name="test_compress_default_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>compress_negative_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Compress",
+    inputs=["input", "condition"],
+    outputs=["output"],
+    axis=-1,
+)
+input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+condition = np.array([0, 1])
+output = np.compress(condition, input, axis=-1)
+# print(output)
+# [[ 2.]
+# [ 4.]
+# [ 6.]]
+expect(
+    node,
+    inputs=[input, condition.astype(bool)],
+    outputs=[output],
+    name="test_compress_negative_axis",
+)
+```
+
+</details>
+
+
+### <a name="Concat"></a><a name="concat">**Concat**</a>
+
+  Concatenate a list of tensors into a single tensor. All input tensors must have the same shape, except for the dimension size of the axis to concatenate on.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Concat-1">1</a>, <a href="Changelog.md#Concat-4">4</a>, <a href="Changelog.md#Concat-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (required)</dt>
+<dd>Which axis to concat on. A negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(inputs)..</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>inputs</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for concatenation</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>concat_result</tt> (differentiable) : T</dt>
+<dd>Concatenated tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>concat</summary>
+
+```python
+test_cases: dict[str, Sequence[Any]] = {
+    "1d": ([1, 2], [3, 4]),
+    "2d": ([[1, 2], [3, 4]], [[5, 6], [7, 8]]),
+    "3d": (
+        [[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
+        [[[9, 10], [11, 12]], [[13, 14], [15, 16]]],
+    ),
+}
+
+for test_case, values_ in test_cases.items():
+    values = [np.asarray(v, dtype=np.float32) for v in values_]
+    for i in range(len(values[0].shape)):
+        in_args = ["value" + str(k) for k in range(len(values))]
+        node = onnx.helper.make_node(
+            "Concat", inputs=list(in_args), outputs=["output"], axis=i
+        )
+        output = np.concatenate(values, i)
+        expect(
+            node,
+            inputs=list(values),
+            outputs=[output],
+            name="test_concat_" + test_case + "_axis_" + str(i),
+        )
+
+    for i in range(-len(values[0].shape), 0):
+        in_args = ["value" + str(k) for k in range(len(values))]
+        node = onnx.helper.make_node(
+            "Concat", inputs=list(in_args), outputs=["output"], axis=i
+        )
+        output = np.concatenate(values, i)
+        expect(
+            node,
+            inputs=list(values),
+            outputs=[output],
+            name="test_concat_" + test_case + "_axis_negative_" + str(abs(i)),
+        )
+```
+
+</details>
+
+
+### <a name="ConcatFromSequence"></a><a name="concatfromsequence">**ConcatFromSequence**</a>
+
+  Concatenate a sequence of tensors into a single tensor.
+  All input tensors must have the same shape, except for the dimension size of the axis to concatenate on.
+  By default 'new_axis' is 0, the behavior is similar to numpy.concatenate.
+  When 'new_axis' is 1, the behavior is similar to numpy.stack.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (required)</dt>
+<dd>Which axis to concat on. Accepted range in `[-r, r - 1]`, where `r` is the rank of input tensors. When `new_axis` is 1, accepted range is `[-r - 1, r]`. </dd>
+<dt><tt>new_axis</tt> : int (default is 0)</dt>
+<dd>Insert and concatenate on a new axis or not, default 0 means do not insert new axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Sequence of tensors for concatenation</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>concat_result</tt> : T</dt>
+<dd>Concatenated tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input types to any tensor type.</dd>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+
+### <a name="Constant"></a><a name="constant">**Constant**</a>
+
+  This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+  or value_* must be specified.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Constant-1">1</a>, <a href="Changelog.md#Constant-9">9</a>, <a href="Changelog.md#Constant-11">11</a>, <a href="Changelog.md#Constant-12">12</a>, <a href="Changelog.md#Constant-13">13</a>, <a href="Changelog.md#Constant-19">19</a>, <a href="Changelog.md#Constant-21">21</a>, <a href="Changelog.md#Constant-23">23</a>, <a href="Changelog.md#Constant-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>sparse_value</tt> : sparse_tensor</dt>
+<dd>The value for the elements of the output tensor in sparse format.</dd>
+<dt><tt>value</tt> : tensor</dt>
+<dd>The value for the elements of the output tensor.</dd>
+<dt><tt>value_float</tt> : float</dt>
+<dd>The value for the sole element for the scalar, float32, output tensor.</dd>
+<dt><tt>value_floats</tt> : list of floats</dt>
+<dd>The values for the elements for the 1D, float32, output tensor.</dd>
+<dt><tt>value_int</tt> : int</dt>
+<dd>The value for the sole element for the scalar, int64, output tensor.</dd>
+<dt><tt>value_ints</tt> : list of ints</dt>
+<dd>The values for the elements for the 1D, int64, output tensor.</dd>
+<dt><tt>value_string</tt> : string</dt>
+<dd>The value for the sole element for the scalar, UTF-8 string, output tensor.</dd>
+<dt><tt>value_strings</tt> : list of strings</dt>
+<dd>The values for the elements for the 1D, UTF-8 string, output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor containing the same value of the provided tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>constant</summary>
+
+```python
+values = np.random.randn(5, 5).astype(np.float32)
+node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["values"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor",
+        data_type=onnx.TensorProto.FLOAT,
+        dims=values.shape,
+        vals=values.flatten().astype(float),
+    ),
+)
+
+expect(node, inputs=[], outputs=[values], name="test_constant")
+```
+
+</details>
+
+
+### <a name="ConstantOfShape"></a><a name="constantofshape">**ConstantOfShape**</a>
+
+  Generate a tensor with given value and shape.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ConstantOfShape-9">9</a>, <a href="Changelog.md#ConstantOfShape-20">20</a>, <a href="Changelog.md#ConstantOfShape-21">21</a>, <a href="Changelog.md#ConstantOfShape-23">23</a>, <a href="Changelog.md#ConstantOfShape-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>value</tt> : tensor</dt>
+<dd>(Optional) The value of the output elements.Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar. All values must be >= 0.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of shape specified by 'input'.If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'.If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype defaults to float32.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain input types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(uint4), tensor(int4), tensor(bool), tensor(bfloat16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain output types to be numerics or boolean.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>float_ones</summary>
+
+```python
+x = np.array([4, 3, 2]).astype(np.int64)
+tensor_value = onnx.helper.make_tensor(
+    "value", onnx.TensorProto.FLOAT, [1], [1]
+)
+node = onnx.helper.make_node(
+    "ConstantOfShape",
+    inputs=["x"],
+    outputs=["y"],
+    value=tensor_value,
+)
+
+y = np.ones(x, dtype=np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_constantofshape_float_ones")
+```
+
+</details>
+
+
+<details>
+<summary>int32_shape_zero</summary>
+
+```python
+x = np.array(
+    [
+        0,
+    ]
+).astype(np.int64)
+tensor_value = onnx.helper.make_tensor(
+    "value", onnx.TensorProto.INT32, [1], [0]
+)
+node = onnx.helper.make_node(
+    "ConstantOfShape",
+    inputs=["x"],
+    outputs=["y"],
+    value=tensor_value,
+)
+y = np.zeros(x, dtype=np.int32)
+expect(
+    node, inputs=[x], outputs=[y], name="test_constantofshape_int_shape_zero"
+)
+```
+
+</details>
+
+
+<details>
+<summary>int32_zeros</summary>
+
+```python
+x = np.array([10, 6]).astype(np.int64)
+tensor_value = onnx.helper.make_tensor(
+    "value", onnx.TensorProto.INT32, [1], [0]
+)
+node = onnx.helper.make_node(
+    "ConstantOfShape",
+    inputs=["x"],
+    outputs=["y"],
+    value=tensor_value,
+)
+y = np.zeros(x, dtype=np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_constantofshape_int_zeros")
+```
+
+</details>
+
+
+### <a name="Conv"></a><a name="conv">**Conv**</a>
+
+  The convolution operator consumes an input tensor and a filter, and
+  computes the output.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Conv-1">1</a>, <a href="Changelog.md#Conv-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input W.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults is 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn). Optionally, if dimension denotation is in effect, the operation expects input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (M x C/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the kernel shape will be (M x C/group x k1 x k2 x ... x kn), where (k1 x k2 x ... kn) is the dimension of the kernel. Optionally, if dimension denotation is in effect, the operation expects the weight tensor to arrive with the dimension denotation of [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. Assuming zero based indices for the shape array, X.shape[1] == (W.shape[1] * group) == C and W.shape[0] mod G == 0. Or in other words FILTER_IN_CHANNEL multiplied by the number of groups should be equal to DATA_CHANNEL and the number of feature maps M should be a multiple of the number of groups G.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, and pad lengths.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>conv</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 5, 5) input tensor
+                [5.0, 6.0, 7.0, 8.0, 9.0],
+                [10.0, 11.0, 12.0, 13.0, 14.0],
+                [15.0, 16.0, 17.0, 18.0, 19.0],
+                [20.0, 21.0, 22.0, 23.0, 24.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [
+                [1.0, 1.0, 1.0],  # (1, 1, 3, 3) tensor for convolution weights
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+# Convolution with padding
+node_with_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1
+    pads=[1, 1, 1, 1],
+)
+y_with_padding = np.array(
+    [
+        [
+            [
+                [12.0, 21.0, 27.0, 33.0, 24.0],  # (1, 1, 5, 5) output tensor
+                [33.0, 54.0, 63.0, 72.0, 51.0],
+                [63.0, 99.0, 108.0, 117.0, 81.0],
+                [93.0, 144.0, 153.0, 162.0, 111.0],
+                [72.0, 111.0, 117.0, 123.0, 84.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_with_padding,
+    inputs=[x, W],
+    outputs=[y_with_padding],
+    name="test_basic_conv_with_padding",
+)
+
+# Convolution without padding
+node_without_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1
+    pads=[0, 0, 0, 0],
+)
+y_without_padding = np.array(
+    [
+        [
+            [
+                [54.0, 63.0, 72.0],  # (1, 1, 3, 3) output tensor
+                [99.0, 108.0, 117.0],
+                [144.0, 153.0, 162.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_without_padding,
+    inputs=[x, W],
+    outputs=[y_without_padding],
+    name="test_basic_conv_without_padding",
+)
+```
+
+</details>
+
+
+<details>
+<summary>conv_with_autopad_same</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 5, 5) input tensor
+                [5.0, 6.0, 7.0, 8.0, 9.0],
+                [10.0, 11.0, 12.0, 13.0, 14.0],
+                [15.0, 16.0, 17.0, 18.0, 19.0],
+                [20.0, 21.0, 22.0, 23.0, 24.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [
+                [1.0, 1.0, 1.0],  # (1, 1, 3, 3) tensor for convolution weights
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+# Convolution with auto_pad='SAME_LOWER' and strides=2
+node = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    auto_pad="SAME_LOWER",
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+)
+y = np.array(
+    [[[[12.0, 27.0, 24.0], [63.0, 108.0, 81.0], [72.0, 117.0, 84.0]]]]
+).astype(np.float32)
+expect(node, inputs=[x, W], outputs=[y], name="test_conv_with_autopad_same")
+```
+
+</details>
+
+
+<details>
+<summary>conv_with_strides</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 7, 5) input tensor
+                [5.0, 6.0, 7.0, 8.0, 9.0],
+                [10.0, 11.0, 12.0, 13.0, 14.0],
+                [15.0, 16.0, 17.0, 18.0, 19.0],
+                [20.0, 21.0, 22.0, 23.0, 24.0],
+                [25.0, 26.0, 27.0, 28.0, 29.0],
+                [30.0, 31.0, 32.0, 33.0, 34.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [
+                [1.0, 1.0, 1.0],  # (1, 1, 3, 3) tensor for convolution weights
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+# Convolution with strides=2 and padding
+node_with_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[1, 1, 1, 1],
+    strides=[
+        2,
+        2,
+    ],  # Default values for other attributes: dilations=[1, 1], groups=1
+)
+y_with_padding = np.array(
+    [
+        [
+            [
+                [12.0, 27.0, 24.0],  # (1, 1, 4, 3) output tensor
+                [63.0, 108.0, 81.0],
+                [123.0, 198.0, 141.0],
+                [112.0, 177.0, 124.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_with_padding,
+    inputs=[x, W],
+    outputs=[y_with_padding],
+    name="test_conv_with_strides_padding",
+)
+
+# Convolution with strides=2 and no padding
+node_without_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[0, 0, 0, 0],
+    strides=[
+        2,
+        2,
+    ],  # Default values for other attributes: dilations=[1, 1], groups=1
+)
+y_without_padding = np.array(
+    [
+        [
+            [
+                [54.0, 72.0],  # (1, 1, 3, 2) output tensor
+                [144.0, 162.0],
+                [234.0, 252.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_without_padding,
+    inputs=[x, W],
+    outputs=[y_without_padding],
+    name="test_conv_with_strides_no_padding",
+)
+
+# Convolution with strides=2 and padding only along one dimension (the H dimension in NxCxHxW tensor)
+node_with_asymmetric_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[1, 0, 1, 0],
+    strides=[
+        2,
+        2,
+    ],  # Default values for other attributes: dilations=[1, 1], groups=1
+)
+y_with_asymmetric_padding = np.array(
+    [
+        [
+            [
+                [21.0, 33.0],  # (1, 1, 4, 2) output tensor
+                [99.0, 117.0],
+                [189.0, 207.0],
+                [171.0, 183.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_with_asymmetric_padding,
+    inputs=[x, W],
+    outputs=[y_with_asymmetric_padding],
+    name="test_conv_with_strides_and_asymmetric_padding",
+)
+```
+
+</details>
+
+
+### <a name="ConvInteger"></a><a name="convinteger">**ConvInteger**</a>
+
+  The integer convolution operator consumes an input tensor, its zero-point, a filter, and its zero-point,
+  and computes the output. The production MUST never overflow. The accumulation may overflow if and only if in 32 bits.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into. default is 1.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input 'w'.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0.The value represent the number of pixels added to the beginning and end part of the corresponding axis.`pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number ofpixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`.This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaultsto 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each axis.</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn). Optionally, if dimension denotation is in effect, the operation expects input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>w</tt> : T2</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (M x C/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the kernel shape will be (M x C/group x k1 x k2 x ... x kn), where (k1 x k2 x ... kn) is the dimension of the kernel. Optionally, if dimension denotation is in effect, the operation expects the weight tensor to arrive with the dimension denotation of [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. X.shape[1] == (W.shape[1] * group) == C (assuming zero based indices for the shape array). Or in other words FILTER_IN_CHANNEL should be equal to DATA_CHANNEL. </dd>
+<dt><tt>x_zero_point</tt> (optional) : T1</dt>
+<dd>Zero point tensor for input 'x'. It's optional and default value is 0. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>w_zero_point</tt> (optional) : T2</dt>
+<dd>Zero point tensor for input 'w'. It's optional and default value is 0.  It could be a scalar or a 1-D tensor, which means a per-tensor/layer or per output channel quantization. If it's a 1-D tensor, its number of elements should be equal to the number of output channels (M)</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, and pad lengths.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input x and its zero point data type to 8-bit integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input w and its zero point data type to 8-bit integer tensor.</dd>
+<dt><tt>T3</tt> : tensor(int32)</dt>
+<dd>Constrain output y data type to 32-bit integer tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>with_padding</summary>
+
+```python
+x = (
+    np.array([2, 3, 4, 5, 6, 7, 8, 9, 10])
+    .astype(np.uint8)
+    .reshape((1, 1, 3, 3))
+)
+x_zero_point = np.uint8(1)
+w_zero_points = np.array([0, 1], dtype=np.uint8)
+w = np.array([1, 1, 1, 1, 1, 1, 1, 1]).astype(np.uint8).reshape((2, 1, 2, 2))
+
+y = (
+    np.array(
+        [
+            1,
+            3,
+            5,
+            3,
+            5,
+            12,
+            16,
+            9,
+            11,
+            24,
+            28,
+            15,
+            7,
+            15,
+            17,
+            9,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+        ]
+    )
+    .astype(np.int32)
+    .reshape((1, 2, 4, 4))
+)
+
+# ConvInteger with padding
+convinteger_node_with_padding = onnx.helper.make_node(
+    "ConvInteger",
+    inputs=["x", "w", "x_zero_point", "w_zero_points"],
+    outputs=["y"],
+    pads=[1, 1, 1, 1],
+)
+
+expect(
+    convinteger_node_with_padding,
+    inputs=[x, w, x_zero_point, w_zero_points],
+    outputs=[y],
+    name="test_convinteger_with_padding",
+)
+```
+
+</details>
+
+
+<details>
+<summary>without_padding</summary>
+
+```python
+x = (
+    np.array([2, 3, 4, 5, 6, 7, 8, 9, 10])
+    .astype(np.uint8)
+    .reshape((1, 1, 3, 3))
+)
+x_zero_point = np.uint8(1)
+w = np.array([1, 1, 1, 1]).astype(np.uint8).reshape((1, 1, 2, 2))
+
+y = np.array([12, 16, 24, 28]).astype(np.int32).reshape(1, 1, 2, 2)
+
+# ConvInteger without padding
+convinteger_node = onnx.helper.make_node(
+    "ConvInteger", inputs=["x", "w", "x_zero_point"], outputs=["y"]
+)
+
+expect(
+    convinteger_node,
+    inputs=[x, w, x_zero_point],
+    outputs=[y],
+    name="test_convinteger_without_padding",
+)
+```
+
+</details>
+
+
+### <a name="ConvTranspose"></a><a name="convtranspose">**ConvTranspose**</a>
+
+  The convolution transpose operator consumes an input tensor and a filter,
+  and computes the output.
+
+  If the pads parameter is provided the shape of the output is calculated via the following equation:
+
+    output_shape[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - pads[start_i] - pads[end_i]
+
+  output_shape can also be explicitly specified in which case pads values are auto generated using these equations:
+
+    total_padding[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - output_shape[i]
+    If (auto_pads == SAME_UPPER): pads[start_i] = total_padding[i]/2; pads[end_i] = total_padding[i] - (total_padding[i]/2)
+    Else: pads[start_i] = total_padding[i] - (total_padding[i]/2); pads[end_i] = (total_padding[i]/2).
+
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ConvTranspose-1">1</a>, <a href="Changelog.md#ConvTranspose-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = input_shape[i] * strides[i]` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input W.</dd>
+<dt><tt>output_padding</tt> : list of ints</dt>
+<dd>Additional elements added to the side with higher coordinate indices in the output. Each padding value in "output_padding" must be less than the corresponding stride/dilation dimension. By default, this attribute is a zero vector. Note that this attribute doesn't directly affect the computed output values. It only controls the selection of the computed values, so changing this attribute only adds or removes output elements. If "output_shape" is explicitly provided, "output_padding" does not contribute additional size to "output_shape" but participates in the computation of the needed padding amount. This is also called adjs or adjustment in some frameworks.</dd>
+<dt><tt>output_shape</tt> : list of ints</dt>
+<dd>The shape of the output can be explicitly set which will cause pads values to be auto generated. If output_shape is specified pads values are ignored. See doc for details for equations to generate pads. Note that the output_shape attribute value should not include dimensions for batch size and channels, which are automatically inferred.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn)</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (C x M/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the weight shape will be (C x M/group x k1 x k2 x ... x kn), where (k1 x k2 x ... x kn) is the dimension of the kernel. The number of channels in the output should be equal to W.shape[1] * group (assuming zero based indices of the shape array)</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, pad lengths and group count. The number of channels in the output should be equal to W.shape[1] * group (assuming zero based indices of the shape array)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>convtranspose</summary>
+
+```python
+x = np.array(
+    [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"])
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],  # (1, 2, 5, 5)
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose")
+```
+
+</details>
+
+
+<details>
+<summary>convtranspose_1d</summary>
+
+```python
+x = np.array([[[0.0, 1.0, 2.0]]]).astype(np.float32)  # (1, 1, 3)
+
+W = np.array([[[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]]).astype(  # (1, 2, 3)
+    np.float32
+)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"])
+
+y = np.array(
+    [[[0.0, 1.0, 3.0, 3.0, 2.0], [0.0, 1.0, 3.0, 3.0, 2.0]]]  # (1, 2, 5)
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_1d")
+```
+
+</details>
+
+
+<details>
+<summary>convtranspose_3d</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [
+                [
+                    [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 3, 4, 5)
+                    [5.0, 6.0, 7.0, 8.0, 9.0],
+                    [10.0, 11.0, 12.0, 13.0, 14.0],
+                    [15.0, 16.0, 17.0, 18.0, 19.0],
+                ],
+                [
+                    [20.0, 21.0, 22.0, 23.0, 24.0],
+                    [25.0, 26.0, 27.0, 28.0, 29.0],
+                    [30.0, 31.0, 32.0, 33.0, 34.0],
+                    [35.0, 36.0, 37.0, 38.0, 39.0],
+                ],
+                [
+                    [40.0, 41.0, 42.0, 43.0, 44.0],
+                    [45.0, 46.0, 47.0, 48.0, 49.0],
+                    [50.0, 51.0, 52.0, 53.0, 54.0],
+                    [55.0, 56.0, 57.0, 58.0, 59.0],
+                ],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [
+                [
+                    [1.0, 1.0, 1.0],  # (1, 2, 3, 3, 3)
+                    [1.0, 1.0, 1.0],
+                    [1.0, 1.0, 1.0],
+                ],
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+            ],
+            [
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"])
+
+y = np.array(
+    [
+        [
+            [
+                [
+                    [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0],  # (1, 2, 5, 6, 7)
+                    [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0],
+                    [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0],
+                    [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0],
+                    [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0],
+                    [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0],
+                ],
+                [
+                    [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0],
+                    [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0],
+                    [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0],
+                    [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0],
+                    [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0],
+                    [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0],
+                ],
+                [
+                    [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0],
+                    [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0],
+                    [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0],
+                    [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0],
+                    [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0],
+                    [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0],
+                ],
+                [
+                    [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0],
+                    [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0],
+                    [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0],
+                    [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0],
+                    [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0],
+                    [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0],
+                ],
+                [
+                    [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0],
+                    [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0],
+                    [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0],
+                    [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0],
+                    [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0],
+                    [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0],
+                ],
+            ],
+            [
+                [
+                    [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0],
+                    [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0],
+                    [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0],
+                    [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0],
+                    [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0],
+                    [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0],
+                ],
+                [
+                    [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0],
+                    [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0],
+                    [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0],
+                    [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0],
+                    [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0],
+                    [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0],
+                ],
+                [
+                    [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0],
+                    [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0],
+                    [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0],
+                    [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0],
+                    [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0],
+                    [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0],
+                ],
+                [
+                    [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0],
+                    [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0],
+                    [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0],
+                    [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0],
+                    [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0],
+                    [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0],
+                ],
+                [
+                    [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0],
+                    [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0],
+                    [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0],
+                    [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0],
+                    [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0],
+                    [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0],
+                ],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_3d")
+```
+
+</details>
+
+
+<details>
+<summary>convtranspose_attributes</summary>
+
+```python
+x = np.array(
+    [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ]
+    ]
+).astype(np.float32)
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],  # (1, 2, 10, 8)
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.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, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_shape=[10, 8]
+)
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_output_shape")
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_padding=[1, 1]
+)
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pad")
+
+node = onnx.helper.make_node(
+    "ConvTranspose",
+    ["X", "W"],
+    ["Y"],
+    name="test",
+    strides=[3, 2],
+    output_shape=[10, 8],
+    kernel_shape=[3, 3],
+    output_padding=[1, 1],
+)
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_kernel_shape")
+```
+
+</details>
+
+
+<details>
+<summary>convtranspose_autopad_same</summary>
+
+```python
+x = np.array(
+    [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], auto_pad="SAME_UPPER", strides=[2, 2]
+)
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                [3.0, 3.0, 8.0, 5.0, 12.0, 7.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0],
+                [9.0, 9.0, 20.0, 11.0, 24.0, 13.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0],
+            ],
+            [
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                [3.0, 3.0, 8.0, 5.0, 12.0, 7.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0],
+                [9.0, 9.0, 20.0, 11.0, 24.0, 13.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_autopad_same")
+```
+
+</details>
+
+
+<details>
+<summary>convtranspose_dilations</summary>
+
+```python
+x = np.array(
+    [[[[3.0, 8.0, 1.0], [9.0, 5.0, 7.0], [3.0, 2.0, 6.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+W = np.array([[[[7.0, 2.0], [1.0, 9.0]]]]).astype(np.float32)  # (1, 1, 2, 2)
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], dilations=[2, 2]
+)
+
+y = np.array(
+    [
+        [
+            [
+                [21.0, 56.0, 13.0, 16.0, 2.0],  # [1, 1, 5, 5]
+                [63.0, 35.0, 67.0, 10.0, 14.0],
+                [24.0, 22.0, 76.0, 76.0, 21.0],
+                [9.0, 5.0, 88.0, 45.0, 63.0],
+                [3.0, 2.0, 33.0, 18.0, 54.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_dilations")
+```
+
+</details>
+
+
+<details>
+<summary>convtranspose_group_2</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+        ]
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ],
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ],
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"], group=2)
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+            [
+                [9.0, 19.0, 30.0, 21.0, 11.0],
+                [21.0, 44.0, 69.0, 48.0, 25.0],
+                [36.0, 75.0, 117.0, 81.0, 42.0],
+                [27.0, 56.0, 87.0, 60.0, 31.0],
+                [15.0, 31.0, 48.0, 33.0, 17.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_group_2")
+```
+
+</details>
+
+
+<details>
+<summary>convtranspose_group_2_image_3</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+        ],
+        [
+            [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0], [24.0, 25.0, 26.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+        ],
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+        ],
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ],
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ],
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"], group=2)
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+            [
+                [9.0, 19.0, 30.0, 21.0, 11.0],
+                [21.0, 44.0, 69.0, 48.0, 25.0],
+                [36.0, 75.0, 117.0, 81.0, 42.0],
+                [27.0, 56.0, 87.0, 60.0, 31.0],
+                [15.0, 31.0, 48.0, 33.0, 17.0],
+            ],
+        ],
+        [
+            [
+                [18.0, 37.0, 57.0, 39.0, 20.0],
+                [39.0, 80.0, 123.0, 84.0, 43.0],
+                [63.0, 129.0, 198.0, 135.0, 69.0],
+                [45.0, 92.0, 141.0, 96.0, 49.0],
+                [24.0, 49.0, 75.0, 51.0, 26.0],
+            ],
+            [
+                [9.0, 19.0, 30.0, 21.0, 11.0],
+                [21.0, 44.0, 69.0, 48.0, 25.0],
+                [36.0, 75.0, 117.0, 81.0, 42.0],
+                [27.0, 56.0, 87.0, 60.0, 31.0],
+                [15.0, 31.0, 48.0, 33.0, 17.0],
+            ],
+        ],
+        [
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+            [
+                [9.0, 19.0, 30.0, 21.0, 11.0],
+                [21.0, 44.0, 69.0, 48.0, 25.0],
+                [36.0, 75.0, 117.0, 81.0, 42.0],
+                [27.0, 56.0, 87.0, 60.0, 31.0],
+                [15.0, 31.0, 48.0, 33.0, 17.0],
+            ],
+        ],
+    ]
+).astype(np.float32)
+
+expect(
+    node, inputs=[x, W], outputs=[y], name="test_convtranspose_group_2_image_3"
+)
+```
+
+</details>
+
+
+<details>
+<summary>convtranspose_pads</summary>
+
+```python
+x = np.array(
+    [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], pads=[1, 2, 1, 2]
+)
+
+y = np.array(
+    [
+        [
+            [
+                [1.0, 1.0, 3.0],  # (1, 2, 7, 3)
+                [1.0, 1.0, 3.0],
+                [7.0, 4.0, 9.0],
+                [7.0, 4.0, 9.0],
+                [7.0, 4.0, 9.0],
+                [13.0, 7.0, 15.0],
+                [13.0, 7.0, 15.0],
+            ],
+            [
+                [1.0, 1.0, 3.0],
+                [1.0, 1.0, 3.0],
+                [7.0, 4.0, 9.0],
+                [7.0, 4.0, 9.0],
+                [7.0, 4.0, 9.0],
+                [13.0, 7.0, 15.0],
+                [13.0, 7.0, 15.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pads")
+```
+
+</details>
+
+
+### <a name="Cos"></a><a name="cos">**Cos**</a>
+
+  Calculates the cosine of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Cos-7">7</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The cosine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>cos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Cos",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.cos(x)
+expect(node, inputs=[x], outputs=[y], name="test_cos_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.cos(x)
+expect(node, inputs=[x], outputs=[y], name="test_cos")
+```
+
+</details>
+
+
+### <a name="Cosh"></a><a name="cosh">**Cosh**</a>
+
+  Calculates the hyperbolic cosine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Cosh-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic cosine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>cosh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Cosh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.cosh(x)  # expected output [1.54308069,  1.,  1.54308069]
+expect(node, inputs=[x], outputs=[y], name="test_cosh_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.cosh(x)
+expect(node, inputs=[x], outputs=[y], name="test_cosh")
+```
+
+</details>
+
+
+### <a name="CumProd"></a><a name="cumprod">**CumProd**</a>
+
+  Performs cumulative product of the input elements along the given axis.
+  By default, it will do the product inclusively meaning the first element is copied as is.
+  Through an `exclusive` attribute, this behavior can change to exclude the first element.
+  It can also perform product in the opposite direction of the axis. For that, set `reverse` attribute to 1.
+
+  Example:
+  ```
+  input_x = [1, 2, 3]
+  axis=0
+  output = [1, 2, 6]
+  exclusive=1
+  output = [1, 1, 2]
+  exclusive=0
+  reverse=1
+  output = [6, 6, 3]
+  exclusive=1
+  reverse=1
+  output = [6, 3, 1]
+  ```
+
+
+#### Version
+
+This version of the operator has been available since version 26 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>exclusive</tt> : int (default is 0)</dt>
+<dd>If set to 1 will return exclusive product in which the top element is not included. In other terms, if set to 1, the j-th output element would be the product of the first (j-1) elements. Otherwise, it would be the product of the first j elements.</dd>
+<dt><tt>reverse</tt> : int (default is 0)</dt>
+<dd>If set to 1 will perform the products in reverse direction.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>x</tt> (differentiable) : T</dt>
+<dd>An input tensor that is to be processed.</dd>
+<dt><tt>axis</tt> (non-differentiable) : T2</dt>
+<dd>A 0-D tensor. Must be in the range [-rank(x), rank(x)-1]. Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> (differentiable) : T</dt>
+<dd>Output tensor of the same type as 'x' with cumulative products of the x's elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>axis tensor can be int32 or int64 only</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>cumprod_1d</summary>
+
+```python
+node = onnx.helper.make_node("CumProd", inputs=["x", "axis"], outputs=["y"])
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.array(0, dtype=np.int32)
+y = np.array([1.0, 2.0, 6.0, 24.0, 120.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d")
+```
+
+</details>
+
+
+<details>
+<summary>cumprod_1d_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd", inputs=["x", "axis"], outputs=["y"], exclusive=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.array(0, dtype=np.int32)
+y = np.array([1.0, 1.0, 2.0, 6.0, 24.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_exclusive")
+```
+
+</details>
+
+
+<details>
+<summary>cumprod_1d_int32_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd", inputs=["x", "axis"], outputs=["y"], exclusive=1
+)
+x = np.array([1, 2, 3, 4, 5]).astype(np.int32)
+axis = np.array(0, dtype=np.int32)
+y = np.array([1, 1, 2, 6, 24]).astype(np.int32)
+expect(
+    node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_int32_exclusive"
+)
+```
+
+</details>
+
+
+<details>
+<summary>cumprod_1d_reverse</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd", inputs=["x", "axis"], outputs=["y"], reverse=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.array(0, dtype=np.int32)
+y = np.array([120.0, 120.0, 60.0, 20.0, 5.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_reverse")
+```
+
+</details>
+
+
+<details>
+<summary>cumprod_1d_reverse_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd", inputs=["x", "axis"], outputs=["y"], reverse=1, exclusive=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.array(0, dtype=np.int32)
+y = np.array([120.0, 60.0, 20.0, 5.0, 1.0]).astype(np.float64)
+expect(
+    node,
+    inputs=[x, axis],
+    outputs=[y],
+    name="test_cumprod_1d_reverse_exclusive",
+)
+```
+
+</details>
+
+
+<details>
+<summary>cumprod_2d_axis_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.array(0, dtype=np.int32)
+y = (
+    np.array([1.0, 2.0, 3.0, 4.0, 10.0, 18.0])
+    .astype(np.float64)
+    .reshape((2, 3))
+)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_axis_0")
+```
+
+</details>
+
+
+<details>
+<summary>cumprod_2d_axis_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.array(1, dtype=np.int32)
+y = (
+    np.array([1.0, 2.0, 6.0, 4.0, 20.0, 120.0])
+    .astype(np.float64)
+    .reshape((2, 3))
+)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_axis_1")
+```
+
+</details>
+
+
+<details>
+<summary>cumprod_2d_int32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.int32).reshape((2, 3))
+axis = np.array(0, dtype=np.int32)
+y = np.array([1, 2, 3, 4, 10, 18]).astype(np.int32).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_int32")
+```
+
+</details>
+
+
+<details>
+<summary>cumprod_2d_negative_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.array(-1, dtype=np.int32)
+y = (
+    np.array([1.0, 2.0, 6.0, 4.0, 20.0, 120.0])
+    .astype(np.float64)
+    .reshape((2, 3))
+)
+expect(
+    node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_negative_axis"
+)
+```
+
+</details>
+
+
+### <a name="CumSum"></a><a name="cumsum">**CumSum**</a>
+
+  Performs cumulative sum of the input elements along the given axis.
+  By default, it will do the sum inclusively meaning the first element is copied as is.
+  Through an `exclusive` attribute, this behavior can change to exclude the first element.
+  It can also perform summation in the opposite direction of the axis. For that, set `reverse` attribute to 1.
+
+  Example:
+  ```
+  input_x = [1, 2, 3]
+  axis=0
+  output = [1, 3, 6]
+  exclusive=1
+  output = [0, 1, 3]
+  exclusive=0
+  reverse=1
+  output = [6, 5, 3]
+  exclusive=1
+  reverse=1
+  output = [5, 3, 0]
+  ```
+
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#CumSum-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>exclusive</tt> : int (default is 0)</dt>
+<dd>If set to 1 will return exclusive sum in which the top element is not included. In other terms, if set to 1, the j-th output element would be the sum of the first (j-1) elements. Otherwise, it would be the sum of the first j elements.</dd>
+<dt><tt>reverse</tt> : int (default is 0)</dt>
+<dd>If set to 1 will perform the sums in reverse direction.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>x</tt> (differentiable) : T</dt>
+<dd>An input tensor that is to be processed.</dd>
+<dt><tt>axis</tt> (non-differentiable) : T2</dt>
+<dd>A 0-D tensor. Must be in the range [-rank(x), rank(x)-1]. Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> (differentiable) : T</dt>
+<dd>Output tensor of the same type as 'x' with cumulative sums of the x's elements</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>axis tensor can be int32 or int64 only</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>cumsum_1d</summary>
+
+```python
+node = onnx.helper.make_node("CumSum", inputs=["x", "axis"], outputs=["y"])
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.int32(0)
+y = np.array([1.0, 3.0, 6.0, 10.0, 15.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d")
+```
+
+</details>
+
+
+<details>
+<summary>cumsum_1d_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.int32(0)
+y = np.array([0.0, 1.0, 3.0, 6.0, 10.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_exclusive")
+```
+
+</details>
+
+
+<details>
+<summary>cumsum_1d_int32_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1
+)
+x = np.array([1, 2, 3, 4, 5]).astype(np.int32)
+axis = np.int32(0)
+y = np.array([0, 1, 3, 6, 10]).astype(np.int32)
+expect(
+    node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_int32_exclusive"
+)
+```
+
+</details>
+
+
+<details>
+<summary>cumsum_1d_reverse</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.int32(0)
+y = np.array([15.0, 14.0, 12.0, 9.0, 5.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse")
+```
+
+</details>
+
+
+<details>
+<summary>cumsum_1d_reverse_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1, exclusive=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.int32(0)
+y = np.array([14.0, 12.0, 9.0, 5.0, 0.0]).astype(np.float64)
+expect(
+    node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse_exclusive"
+)
+```
+
+</details>
+
+
+<details>
+<summary>cumsum_2d_axis_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.int32(0)
+y = np.array([1.0, 2.0, 3.0, 5.0, 7.0, 9.0]).astype(np.float64).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_0")
+```
+
+</details>
+
+
+<details>
+<summary>cumsum_2d_axis_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.int32(1)
+y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_1")
+```
+
+</details>
+
+
+<details>
+<summary>cumsum_2d_int32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.int32).reshape((2, 3))
+axis = np.int32(0)
+y = np.array([1, 2, 3, 5, 7, 9]).astype(np.int32).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_int32")
+```
+
+</details>
+
+
+<details>
+<summary>cumsum_2d_negative_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.int32(-1)
+y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_negative_axis")
+```
+
+</details>
+
+
+### <a name="DFT"></a><a name="dft">**DFT**</a>
+
+  Computes the discrete Fourier Transform (DFT) of the input.
+
+  Assuming the input has shape `[M, N]`, where `N` is the dimension over which the
+  DFT is computed and `M` denotes the conceptual "all other dimensions,"
+  the DFT `y[m, k]` of shape `[M, N]` is defined as
+
+  $$y[m, k] = \sum_{n=0}^{N-1} e^{-2 \pi j \frac{k n}{N} } x[m, n] ,$$
+
+  and the inverse transform is defined as
+
+  $$x[m, n] = \frac{1}{N} \sum_{k=0}^{N-1} e^{2 \pi j \frac{k n}{N} } y[m, k] ,$$
+
+  where $j$ is the imaginary unit.
+
+  The actual shape of the output is specified in the "output" section.
+
+  Reference: https://docs.scipy.org/doc/scipy/tutorial/fft.html
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#DFT-17">17</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>inverse</tt> : int (default is 0)</dt>
+<dd>Whether to perform the inverse discrete Fourier Transform. Default is 0, which corresponds to `false`.</dd>
+<dt><tt>onesided</tt> : int (default is 0)</dt>
+<dd>If `onesided` is `1`, only values for `k` in `[0, 1, 2, ..., floor(n_fft/2) + 1]` are used or returned because the real-to-complex Fourier transform satisfies the conjugate symmetry, i.e., `X[m, k] = X[m, n_fft-k]*`, where `m` denotes "all other dimensions" DFT was not applied on. When `onesided=1` and `inverse=0` (forward DFT), only real input is supported and a one-sided complex spectrum is returned (RFFT). When `onesided=1` and `inverse=1` (inverse DFT), only complex input is supported and a full real signal is returned (IRFFT). Value can be `0` or `1`. Default is `0`.</dd>
+</dl>
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>input</tt> (non-differentiable) : T1</dt>
+<dd>For real input, the following shape is expected: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][1]`. For complex input, the following shape is expected: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][2]`. The final dimension represents the real and imaginary parts of the value in that order.</dd>
+<dt><tt>dft_length</tt> (optional, non-differentiable) : T2</dt>
+<dd>The length of the signal as a scalar. If greater than the axis dimension, the signal will be zero-padded up to `dft_length`. If less than the axis dimension, only the first `dft_length` values will be used as the signal. If not provided, the default `dft_length = signal_dim_axis`, except for the IRFFT case (`onesided=1`, `inverse=1`), in which case the default dft_length is `2 * (signal_dim_axis - 1)`.</dd>
+<dt><tt>axis</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>The axis as a scalar on which to perform the DFT. Default is `-2` (last signal axis). Negative value means counting dimensions from the back. Accepted range is $[-r, -2] \cup [0, r-2]$ where `r = rank(input)`. The last dimension is for representing complex numbers and thus is an invalid axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T1</dt>
+<dd>The Fourier Transform of the input vector. For standard DFT (`onesided=0`), the output shape is: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][2]` (complex), with `signal_dim_axis = dft_length`. For RFFT (`onesided=1`, `inverse=0`), the output shape is: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][2]` (one-sided complex), with `signal_dim_axis = floor(dft_length/2) + 1`. For IRFFT (`onesided=1`, `inverse=1`), the output shape is: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][1]` (real), where `signal_dim_axis = dft_length`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain scalar length types to integers.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>dft</summary>
+
+```python
+node = onnx.helper.make_node("DFT", inputs=["x", "", "axis"], outputs=["y"])
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+axis = np.array(1, dtype=np.int64)
+y = np.fft.fft(x, axis=0)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft")
+
+node = onnx.helper.make_node("DFT", inputs=["x", "", "axis"], outputs=["y"])
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+axis = np.array(2, dtype=np.int64)
+y = np.fft.fft(x, axis=1)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft_axis")
+
+node = onnx.helper.make_node(
+    "DFT", inputs=["x", "", "axis"], outputs=["y"], inverse=1
+)
+x = np.arange(0, 100, dtype=np.complex64).reshape(10, 10)
+axis = np.array(1, dtype=np.int64)
+y = np.fft.ifft(x, axis=0)
+
+x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft_inverse")
+
+# Test RFFT (Real FFT): real input -> one-sided complex output
+node = onnx.helper.make_node(
+    "DFT", inputs=["x", "", "axis"], outputs=["y"], onesided=1
+)
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+axis = np.array(1, dtype=np.int64)
+y = np.fft.rfft(x, axis=0)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft_rfft")
+
+# Test IRFFT (Inverse Real FFT): one-sided complex input -> real output
+node = onnx.helper.make_node(
+    "DFT", inputs=["x", "", "axis"], outputs=["y"], onesided=1, inverse=1
+)
+# Create one-sided complex input (6 bins for signal length 10)
+x = np.fft.rfft(np.arange(0, 100).reshape(10, 10), axis=0).astype(np.complex64)
+axis = np.array(1, dtype=np.int64)
+y = np.fft.irfft(x, n=10, axis=0)
+
+x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+y = y.reshape(1, 10, 10, 1).astype(np.float32)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft_irfft")
+```
+
+</details>
+
+
+<details>
+<summary>opset19</summary>
+
+```python
+node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=1)
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+y = np.fft.fft(x, axis=0)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+
+node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=2)
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+y = np.fft.fft(x, axis=1)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_axis_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+
+node = onnx.helper.make_node(
+    "DFT", inputs=["x"], outputs=["y"], inverse=1, axis=1
+)
+x = np.arange(0, 100, dtype=np.complex64).reshape(
+    10,
+    10,
+)
+y = np.fft.ifft(x, axis=0)
+
+x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_inverse_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+
+# Test RFFT (Real FFT): real input -> one-sided complex output
+node = onnx.helper.make_node(
+    "DFT", inputs=["x"], outputs=["y"], onesided=1, axis=1
+)
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+y = np.fft.rfft(x, axis=0)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_rfft_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+
+# Test IRFFT (Inverse Real FFT): one-sided complex input -> real output
+node = onnx.helper.make_node(
+    "DFT", inputs=["x"], outputs=["y"], onesided=1, inverse=1, axis=1
+)
+# Create one-sided complex input (6 bins for signal length 10)
+x = np.fft.rfft(np.arange(0, 100).reshape(10, 10), axis=0).astype(np.complex64)
+y = np.fft.irfft(x, n=10, axis=0)
+
+x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+y = y.reshape(1, 10, 10, 1).astype(np.float32)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_irfft_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+```
+
+</details>
+
+
+### <a name="DeformConv"></a><a name="deformconv">**DeformConv**</a>
+
+  Performs deformable convolution as described in https://arxiv.org/abs/1703.06211 and https://arxiv.org/abs/1811.11168.
+  This operator specification supports the general N-D case. Note that most common use cases have 2D or 3D data.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#DeformConv-19">19</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of the kernel. Default is 1 along each axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>Number of groups the input and output channels, C and oC, are divided into. C and oC must both be divisible by group. Default is 1.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>Shape of the convolution kernel. If not present, it is inferred from the shape of input W.</dd>
+<dt><tt>offset_group</tt> : int (default is 1)</dt>
+<dd>Number of groups of offset. C must be divisible by offset_group. Default is 1.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and end along each spatial axis. The values represent the number of pixels added to the beginning and end of the corresponding axis and can take any nonnegative value. The format should be as follows: [x1_begin, x2_begin, ..., x1_end, x2_end, ...], where xi_begin is the number of pixels added at the beginning of axis `i` and xi_end is the number of pixels added at the end of axis `i`. Default is 0 along each axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. Default is 1 along each axis.</dd>
+</dl>
+
+#### Inputs (3 - 5)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Input data tensor. For 2D image data, it has shape (N, C, H, W) where N is the batch size, C is the number of input channels, and H and W are the height and width. In general, the shape is (N, C, D1, D2, ... , Dn) for n-dimensional data, where D1 to Dn are the spatial dimension sizes. Most common use cases have n = 2 or 3.</dd>
+<dt><tt>W</tt> : T</dt>
+<dd>Weight tensor that will be used in the convolutions. It has shape (oC, C/group, kH, kW), where oC is the number of output channels and kH and kW are the kernel height and width. For more than 2 dimensions, it has shape (oC, C/group, k1, k2, ... , kn).</dd>
+<dt><tt>offset</tt> : T</dt>
+<dd>Offset tensor denoting the offset for the sampling locations in the convolution kernel. It has shape (N, offset_group * kH * kW * 2, oH, oW) for 2D data or (N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Use linear interpolationfor fractional offset values. Sampling locations outside of the padded input tensor gives zero.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>Optional 1D bias of length oC to be added to the convolution. Default is a tensor of zeros.</dd>
+<dt><tt>mask</tt> (optional) : T</dt>
+<dd>The mask tensor to be applied to each position in the convolution kernel. It has shape (N, offset_group * kH * kW, oH, oW) for 2D data or (N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Default is a tensor of ones.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Output data tensor that contains the result of convolution. It has shape (N, oC, oH, oW) for 2D data or (N, oC, o1, o2, ..., on) for nD data</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>deformconv</summary>
+
+```python
+X = np.arange(9).astype(np.float32)
+X.shape = (1, 1, 3, 3)
+W = np.ones((1, 1, 2, 2), dtype=np.float32)
+
+# Convolution with padding
+offset_with_padding = np.zeros((1, 8, 4, 4), dtype=np.float32)
+# h-coord of [0, 0] element of kernel, at output position [0, 0]
+offset_with_padding[0, 0, 0, 0] = 0.5
+# w-coord of [1, 0] element of kernel, at output position [1, 2]
+offset_with_padding[0, 5, 1, 2] = -0.1
+
+node_with_padding = onnx.helper.make_node(
+    "DeformConv",
+    inputs=["X", "W", "offset_with_padding"],
+    outputs=["Y_with_padding"],
+    kernel_shape=[2, 2],
+    pads=[1, 1, 1, 1],
+)
+Y_with_padding = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 3.0, 2.0],  # (1, 1, 4, 4) output tensor
+                [3.0, 8.0, 11.9, 7.0],
+                [9.0, 20.0, 24.0, 13.0],
+                [6.0, 13.0, 15.0, 8.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_with_padding,
+    inputs=[X, W, offset_with_padding],
+    outputs=[Y_with_padding],
+    name="test_basic_deform_conv_with_padding",
+)
+
+# Convolution without padding
+offset_without_padding = np.zeros((1, 8, 2, 2), dtype=np.float32)
+# h-coord of [0, 0] element of kernel, at output position [0, 0]
+offset_without_padding[0, 0, 0, 0] = 0.5
+# w-coord of [1, 0] element of kernel, at output position [0, 1]
+offset_without_padding[0, 5, 0, 1] = -0.1
+
+node_without_padding = onnx.helper.make_node(
+    "DeformConv",
+    inputs=["X", "W", "offset_without_padding"],
+    outputs=["Y_without_padding"],
+    kernel_shape=[2, 2],
+    pads=[0, 0, 0, 0],
+)
+Y_without_padding = np.array(
+    [
+        [
+            [
+                [9.5, 11.9],  # (1, 1, 2, 2) output tensor
+                [20.0, 24.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_without_padding,
+    inputs=[X, W, offset_without_padding],
+    outputs=[Y_without_padding],
+    name="test_basic_deform_conv_without_padding",
+)
+```
+
+</details>
+
+
+<details>
+<summary>deformconv_with_mask_bias</summary>
+
+```python
+X = np.arange(9).astype(np.float32)
+X.shape = (1, 1, 3, 3)
+W = np.ones((1, 1, 2, 2), dtype=np.float32)
+B = np.ones((1,), dtype=np.float32)
+
+offset = np.zeros((1, 8, 2, 2), dtype=np.float32)
+# h-coord of [0, 0] element of kernel, at output position [0, 0]
+offset[0, 0, 0, 0] = 0.5
+# w-coord of [1, 0] element of kernel, at output position [0, 1]
+offset[0, 5, 0, 1] = -0.1
+
+mask = np.ones((1, 4, 2, 2), dtype=np.float32)
+mask[0, 2, 1, 1] = 0.2  # [1, 0] element of kernel at output position [1, 1]
+
+node = onnx.helper.make_node(
+    "DeformConv",
+    inputs=["X", "W", "offset", "B", "mask"],
+    outputs=["Y"],
+    kernel_shape=[2, 2],
+    pads=[0, 0, 0, 0],
+)
+Y = np.array(
+    [
+        [
+            [
+                [10.5, 12.9],  # (1, 1, 2, 2) output tensor
+                [21.0, 19.4],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node,
+    inputs=[X, W, offset, B, mask],
+    outputs=[Y],
+    name="test_deform_conv_with_mask_bias",
+)
+```
+
+</details>
+
+
+<details>
+<summary>deformconv_with_multiple_offset_groups</summary>
+
+```python
+X = np.zeros((1, 2, 3, 3), dtype=np.float32)
+X[0, 0] = np.reshape(np.arange(9).astype(np.float32), (3, 3))
+X[0, 1] = np.reshape(np.arange(8, -1, -1).astype(np.float32), (3, 3))
+X.shape = (1, 2, 3, 3)
+W = np.ones((1, 2, 2, 2), dtype=np.float32)
+
+offset = np.zeros((1, 16, 2, 2), dtype=np.float32)
+# h-coord of [0, 0] element of kernel in channel 0, at output position [0, 0]
+offset[0, 0, 0, 0] = 0.5
+# w-coord of [1, 0] element of kernel in channel 1, at output position [0, 1]
+offset[0, 13, 0, 1] = -0.1
+
+node = onnx.helper.make_node(
+    "DeformConv",
+    inputs=["X", "W", "offset"],
+    outputs=["Y"],
+    kernel_shape=[2, 2],
+    pads=[0, 0, 0, 0],
+    offset_group=2,
+)
+Y = np.array(
+    [
+        [
+            [
+                [33.5, 32.1],  # (1, 1, 2, 2) output tensor
+                [32.0, 32.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node,
+    inputs=[X, W, offset],
+    outputs=[Y],
+    name="test_deform_conv_with_multiple_offset_groups",
+)
+```
+
+</details>
+
+
+### <a name="DepthToSpace"></a><a name="depthtospace">**DepthToSpace**</a>
+
+  DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
+  This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
+  the input tensor where values from the depth dimension are moved in spatial blocks to the height
+  and width dimensions. By default, `mode` = `DCR`.
+  In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the
+  following order: depth, column, and then row. The output y is computed from the input x as below:
+
+  ```
+  b, c, h, w = x.shape
+  tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])
+  tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])
+  y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])
+  ```
+
+  In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the
+  following order: column, row, and the depth. The output y is computed from the input x as below:
+
+  ```
+  b, c, h, w = x.shape
+  tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])
+  tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])
+  y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#DepthToSpace-1">1</a>, <a href="Changelog.md#DepthToSpace-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>blocksize</tt> : int (required)</dt>
+<dd>Blocks of [blocksize, blocksize] are moved.</dd>
+<dt><tt>mode</tt> : string (default is DCR)</dt>
+<dd>DCR (default) for depth-column-row order re-arrangement. Use CRD for column-row-depth order.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>crd_mode_example</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="CRD"
+)
+
+# (1, 8, 2, 3) input tensor
+x = np.array(
+    [
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]],
+            [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]],
+            [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]],
+            [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]],
+            [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]],
+            [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]],
+            [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]],
+        ]
+    ]
+).astype(np.float32)
+
+# (1, 2, 4, 6) output tensor
+y = np.array(
+    [
+        [
+            [
+                [0.0, 9.0, 1.0, 10.0, 2.0, 11.0],
+                [18.0, 27.0, 19.0, 28.0, 20.0, 29.0],
+                [3.0, 12.0, 4.0, 13.0, 5.0, 14.0],
+                [21.0, 30.0, 22.0, 31.0, 23.0, 32.0],
+            ],
+            [
+                [36.0, 45.0, 37.0, 46.0, 38.0, 47.0],
+                [54.0, 63.0, 55.0, 64.0, 56.0, 65.0],
+                [39.0, 48.0, 40.0, 49.0, 41.0, 50.0],
+                [57.0, 66.0, 58.0, 67.0, 59.0, 68.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_depthtospace_crd_mode_example")
+```
+
+</details>
+
+
+<details>
+<summary>default_mode_example</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="DCR"
+)
+
+# (1, 8, 2, 3) input tensor
+x = np.array(
+    [
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]],
+            [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]],
+            [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]],
+            [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]],
+            [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]],
+            [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]],
+            [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]],
+        ]
+    ]
+).astype(np.float32)
+
+# (1, 2, 4, 6) output tensor
+y = np.array(
+    [
+        [
+            [
+                [0.0, 18.0, 1.0, 19.0, 2.0, 20.0],
+                [36.0, 54.0, 37.0, 55.0, 38.0, 56.0],
+                [3.0, 21.0, 4.0, 22.0, 5.0, 23.0],
+                [39.0, 57.0, 40.0, 58.0, 41.0, 59.0],
+            ],
+            [
+                [9.0, 27.0, 10.0, 28.0, 11.0, 29.0],
+                [45.0, 63.0, 46.0, 64.0, 47.0, 65.0],
+                [12.0, 30.0, 13.0, 31.0, 14.0, 32.0],
+                [48.0, 66.0, 49.0, 67.0, 50.0, 68.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_depthtospace_example")
+```
+
+</details>
+
+
+### <a name="DequantizeLinear"></a><a name="dequantizelinear">**DequantizeLinear**</a>
+
+  The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the
+  full-precision tensor. The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point`
+  must have the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
+  a 1-D tensor for per-axis quantization, or have a rank identical to the input for blocked quantization.
+  See QuantizeLinear for details on quantization granularity.
+
+  `x_zero_point` and `x` must have the same type. `x` and `y` must have the same shape. In the case of dequantizing
+  `int32`, there's no zero point (zero point is supposed to be 0).
+  `zero-point` is usually not used in the case of float8 and 4-bit types quantization, but the dequantization formula remains the same
+  for consistency. The output type is determined by the attribute `output_dtype`. If `output_dtype` is not supplied then the output type
+  is the same as `x_scale`. The output type also determines the precision of the multiplication operation.
+
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#DequantizeLinear-10">10</a>, <a href="Changelog.md#DequantizeLinear-13">13</a>, <a href="Changelog.md#DequantizeLinear-19">19</a>, <a href="Changelog.md#DequantizeLinear-21">21</a>, <a href="Changelog.md#DequantizeLinear-23">23</a>, <a href="Changelog.md#DequantizeLinear-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+<dt><tt>output_dtype</tt> : int (default is 0)</dt>
+<dd>(Optional) The output data type. If not supplied, the output data type is inferred from `x_scale` data type (`T2`)</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D quantized input tensor to be de-quantized.</dd>
+<dt><tt>x_scale</tt> : T2</dt>
+<dd>Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>x_zero_point</tt> (optional) : T1</dt>
+<dd>Zero point for input `x`. Shape must match x_scale. It's optional. Zero point is 0 when it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>N-D full precision output tensor. It has the same shape as input `x`. The data type is specified by the `output_dtype` attribute or, in its absence, the type of `x_scale`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(int32), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(uint2), tensor(int2)</dt>
+<dd>The type of the inputs 'x_zero_point' and 'x'.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(float8e8m0)</dt>
+<dd>The type of the input 'x_scale'.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>The type of the output 'y'.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+)
+
+# 1-D tensor zero point and scale of size equal to axis 1 of the input tensor
+x = np.array(
+    [
+        [
+            [[3, 89], [34, 200], [74, 59]],
+            [[5, 24], [24, 87], [32, 13]],
+            [[245, 99], [4, 142], [121, 102]],
+        ],
+    ],
+    dtype=np.uint8,
+)
+x_scale = np.array([2, 4, 5], dtype=np.float32)
+x_zero_point = np.array([84, 24, 196], dtype=np.uint8)
+y = (
+    x.astype(np.float32) - x_zero_point.reshape(1, 3, 1, 1).astype(np.float32)
+) * x_scale.reshape(1, 3, 1, 1)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>blocked</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=1,
+    block_size=2,
+)
+
+x = np.array(
+    [
+        [
+            [[3, 89], [34, 200], [74, 59]],
+            [[5, 24], [24, 87], [32, 13]],
+            [[5, 12], [12, 33], [65, 42]],
+            [[245, 99], [4, 142], [121, 102]],
+        ],
+    ],
+    dtype=np.uint8,
+)
+
+x_scale = np.array(
+    [
+        [
+            [[3.0, 2.0], [4.0, 1.0], [2.0, 2.0]],
+            [[5.0, 2.0], [4.0, 3.0], [5.0, 2.0]],
+        ],
+    ],
+    dtype=np.float32,
+)
+x_zero_point = np.array(
+    [
+        [
+            [[1, 0], [0, 1], [2, 20]],
+            [[3, 2], [4, 3], [15, 2]],
+        ],
+    ],
+    dtype=np.uint8,
+)
+
+# x.shape = (1, 4, 3, 2)
+# x_scale.shape = (1, 2, 3, 2)
+assert x_scale.shape == x_zero_point.shape
+block_axis = 1
+# The block shape is [x.shape[i] // x_scale.shape[i] for i in range(len(x.shape))] = (1, 2, 1, 1)
+assert all(
+    x.shape[i] == x_scale.shape[i]
+    for i in range(len(x.shape))
+    if i != block_axis
+)
+assert x.shape[block_axis] % x_scale.shape[block_axis] == 0
+repeats = x.shape[block_axis] // x_scale.shape[block_axis]
+
+# Create element-wise scale and zero point
+x_scale_elementwise = np.repeat(x_scale, repeats=repeats, axis=block_axis)
+x_zero_point_elementwise = np.repeat(
+    x_zero_point, repeats=repeats, axis=block_axis
+)
+
+y = (
+    x.astype(np.float32) - x_zero_point_elementwise.astype(np.float32)
+) * x_scale_elementwise
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_blocked",
+)
+```
+
+</details>
+
+
+<details>
+<summary>dequantizelinear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+)
+
+# scalar zero point and scale
+x = np.array([0, 3, 128, 255]).astype(np.uint8)
+x_scale = np.float32(2)
+x_zero_point = np.uint8(128)
+y = np.array([-256, -250, 0, 254], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear",
+)
+```
+
+</details>
+
+
+<details>
+<summary>e4m3fn</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104])
+x_scale = np.float32(2)
+y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale],
+    outputs=[y],
+    name="test_dequantizelinear_e4m3fn",
+)
+```
+
+</details>
+
+
+<details>
+<summary>e4m3fn_float16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104])
+x_scale = np.float16(2)
+y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float16)
+
+expect(
+    node,
+    inputs=[x, x_scale],
+    outputs=[y],
+    name="test_dequantizelinear_e4m3fn_float16",
+)
+```
+
+</details>
+
+
+<details>
+<summary>e4m3fn_zero_point</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104])
+zero_point = make_tensor("zero_point", TensorProto.FLOAT8E4M3FN, [1], [0])
+x_scale = np.float32(2)
+y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_e4m3fn_zero_point",
+)
+```
+
+</details>
+
+
+<details>
+<summary>e5m2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, -96])
+x_scale = np.float32(2)
+y = np.array([0.0, 1.0, 2.0, 98304.0, -192.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale],
+    outputs=[y],
+    name="test_dequantizelinear_e5m2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>float4e2m1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT4E2M1, [5], [0, 1, -1, 1.5, -4])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.FLOAT4E2M1, (1,), [0])
+y = np.array([0, 2, -2, 3, -8], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_float4e2m1",
+)
+```
+
+</details>
+
+
+<details>
+<summary>int16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([-300, -30, -1025, 1270]).astype(np.int16)
+x_scale = np.float32(2)
+x_zero_point = np.int16(-1024)
+y = np.array([1448.0, 1988.0, -2.0, 4588.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_int16",
+)
+```
+
+</details>
+
+
+<details>
+<summary>int2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.INT2, [4], [0, 1, -1, -2])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.INT2, (1,), [1])
+y = np.array([-2, 0, -4, -6], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_int2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>int4</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.INT4, [5], [0, 1, 7, -4, -8])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.INT4, (1,), [1])
+y = np.array([-2, 0, 12, -10, -18], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_int4",
+)
+```
+
+</details>
+
+
+<details>
+<summary>uint16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([30000, 31000, 32768, 33000]).astype(np.uint16)
+x_scale = np.float32(2)
+x_zero_point = np.uint16(32767)
+y = np.array([-5534.0, -3534.0, 2.0, 466.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_uint16",
+)
+```
+
+</details>
+
+
+<details>
+<summary>uint2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.UINT2, [4], [0, 1, 2, 3])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.UINT2, (1,), [1])
+y = np.array([-2, 0, 2, 4], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_uint2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>uint4</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.UINT4, [5], [0, 1, 7, 10, 15])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.UINT4, (1,), [1])
+y = np.array([-2, 0, 12, 18, 28], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_uint4",
+)
+```
+
+</details>
+
+
+### <a name="Det"></a><a name="det">**Det**</a>
+
+  Det calculates determinant of a square matrix or batches of square matrices.
+  Det takes one input tensor of shape `[*, M, M]`, where `*` is zero or more batch dimensions,
+  and the inner-most 2 dimensions form square matrices.
+  The output is a tensor of shape `[*]`, containing the determinants of all input submatrices.
+  e.g., When the input is 2-D, the output is a scalar(shape is empty: `[]`).
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Det-11">11</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to floating-point tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>2d</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Det",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.arange(4).reshape(2, 2).astype(np.float32)
+y = np.linalg.det(x)  # expect -2
+expect(node, inputs=[x], outputs=[y], name="test_det_2d")
+```
+
+</details>
+
+
+<details>
+<summary>nd</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Det",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([[[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]]]).astype(
+    np.float32
+)
+y = np.linalg.det(x)  # expect array([-2., -3., -8.])
+expect(node, inputs=[x], outputs=[y], name="test_det_nd")
+```
+
+</details>
+
+
+### <a name="Div"></a><a name="div">**Div**</a>
+
+  Performs element-wise binary division (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  For integer inputs, the result is computed using truncating division (rounding toward zero).
+  (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Div-1">1</a>, <a href="Changelog.md#Div-6">6</a>, <a href="Changelog.md#Div-7">7</a>, <a href="Changelog.md#Div-13">13</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>div</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Div",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([3, 4]).astype(np.float32)
+y = np.array([1, 2]).astype(np.float32)
+z = x / y  # expected output [3., 2.]
+expect(node, inputs=[x, y], outputs=[z], name="test_div_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.rand(3, 4, 5).astype(np.float32) + 1.0
+z = x / y
+expect(node, inputs=[x, y], outputs=[z], name="test_div")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_int8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_int16")
+
+x = np.array([-3, 3, -3, 3], dtype=np.int32)
+y = np.array([2, 2, -2, -2], dtype=np.int32)
+z = np.array([-1, 1, 1, -1], dtype=np.int32)
+expect(node, inputs=[x, y], outputs=[z], name="test_div_int32_trunc")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>div_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Div",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.rand(5).astype(np.float32) + 1.0
+z = x / y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_bcast")
+```
+
+</details>
+
+
+### <a name="Dropout"></a><a name="dropout">**Dropout**</a>
+
+  Dropout takes an input floating-point tensor, an optional input ratio (floating-point scalar) and an optional input training_mode (boolean scalar). It produces two tensor outputs,
+  output (floating-point tensor) and mask (optional `Tensor<bool>`). If `training_mode` is true then the output Y will be a random dropout;
+  Note that this Dropout scales the masked input data by the following equation, so to convert the trained model into inference mode,
+  the user can simply not pass `training_mode` input or set it to false.
+  ```
+  output = scale * data * mask,
+  ```
+  where
+  ```
+  scale = 1. / (1. - ratio).
+  ```
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Dropout-1">1</a>, <a href="Changelog.md#Dropout-6">6</a>, <a href="Changelog.md#Dropout-7">7</a>, <a href="Changelog.md#Dropout-10">10</a>, <a href="Changelog.md#Dropout-12">12</a>, <a href="Changelog.md#Dropout-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>seed</tt> : int</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs (1 - 3)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>The input data as Tensor.</dd>
+<dt><tt>ratio</tt> (optional, non-differentiable) : T1</dt>
+<dd>The ratio of random dropout, with value in [0, 1). If set to 0, the output would be a simple copy of the input. If it's non-zero, output will be a random dropout of the scaled input, which is typically the case during training. It is an optional value, if not specified it will default to 0.5.</dd>
+<dt><tt>training_mode</tt> (optional, non-differentiable) : T2</dt>
+<dd>If set to true then it indicates dropout is being used for training. It is an optional value hence unless specified explicitly, it is false. If it is false, ratio is ignored and the operation mimics inference mode where nothing will be dropped from the input data and if mask is requested as output it will contain all ones.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output.</dd>
+<dt><tt>mask</tt> (optional, non-differentiable) : T2</dt>
+<dd>The output mask.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input 'ratio' types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output 'mask' types to boolean tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node("Dropout", inputs=["x"], outputs=["y"], seed=seed)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = dropout(x)
+expect(node, inputs=[x], outputs=[y], name="test_dropout_default")
+```
+
+</details>
+
+
+<details>
+<summary>default_mask</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x"], outputs=["y", "z"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y, z = dropout(x, return_mask=True)
+expect(node, inputs=[x], outputs=[y, z], name="test_dropout_default_mask")
+```
+
+</details>
+
+
+<details>
+<summary>default_mask_ratio</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r"], outputs=["y", "z"], seed=seed
+)
+
+r = np.float32(0.1)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y, z = dropout(x, r, return_mask=True)
+expect(
+    node, inputs=[x, r], outputs=[y, z], name="test_dropout_default_mask_ratio"
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_old</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Dropout",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = x
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dropout_default_old",
+    opset_imports=[helper.make_opsetid("", 11)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_ratio</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r"], outputs=["y"], seed=seed
+)
+
+r = np.float32(0.1)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = dropout(x, r)
+expect(node, inputs=[x, r], outputs=[y], name="test_dropout_default_ratio")
+```
+
+</details>
+
+
+<details>
+<summary>random_old</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Dropout",
+    inputs=["x"],
+    outputs=["y"],
+    ratio=0.2,
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = x
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dropout_random_old",
+    opset_imports=[helper.make_opsetid("", 11)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>training</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.75)
+t = np.bool_(True)
+y = dropout(x, r, training_mode=t)
+expect(node, inputs=[x, r, t], outputs=[y], name="test_training_dropout")
+```
+
+</details>
+
+
+<details>
+<summary>training_default</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.5)
+t = np.bool_(True)
+y = dropout(x, r, training_mode=t)
+expect(
+    node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_default"
+)
+```
+
+</details>
+
+
+<details>
+<summary>training_default_ratio_mask</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.5)
+t = np.bool_(True)
+y, z = dropout(x, r, training_mode=t, return_mask=True)
+expect(
+    node,
+    inputs=[x, r, t],
+    outputs=[y, z],
+    name="test_training_dropout_default_mask",
+)
+```
+
+</details>
+
+
+<details>
+<summary>training_default_zero_ratio</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.0)
+t = np.bool_(True)
+y = dropout(x, r, training_mode=t)
+expect(
+    node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_zero_ratio"
+)
+```
+
+</details>
+
+
+<details>
+<summary>training_default_zero_ratio_mask</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.0)
+t = np.bool_(True)
+y, z = dropout(x, r, training_mode=t, return_mask=True)
+expect(
+    node,
+    inputs=[x, r, t],
+    outputs=[y, z],
+    name="test_training_dropout_zero_ratio_mask",
+)
+```
+
+</details>
+
+
+<details>
+<summary>training_ratio_mask</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.75)
+t = np.bool_(True)
+y, z = dropout(x, r, training_mode=t, return_mask=True)
+expect(
+    node, inputs=[x, r, t], outputs=[y, z], name="test_training_dropout_mask"
+)
+```
+
+</details>
+
+
+### <a name="DynamicQuantizeLinear"></a><a name="dynamicquantizelinear">**DynamicQuantizeLinear**</a>
+
+  A Function to fuse calculation for Scale, Zero Point and FP32->8Bit conversion of FP32 Input data.
+  Outputs Scale, ZeroPoint and Quantized Input for a given FP32 Input.
+  Scale is calculated as:
+  ```
+  y_scale = (maximum(0, max(x)) - minimum(0, min(x))) / (qmax - qmin)
+  ```
+
+  * where qmax and qmin are max and min values for quantization range i.e. [0, 255] in case of uint8
+  * data range is adjusted to include 0.
+
+  Zero point is calculated as:
+  ```
+  intermediate_zero_point = qmin - min(x)/y_scale
+  y_zero_point = cast(round(saturate(intermediate_zero_point)))
+  ```
+
+  * where qmax and qmin are max and min values for quantization range .i.e [0, 255] in case of uint8
+  * for saturation, it saturates to [0, 255] if it's uint8, or [-127, 127] if it's int8. Right now only uint8 is supported.
+  * rounding to nearest ties to even.
+
+  Data quantization formula is:
+  ```
+  y = saturate (round (x / y_scale) + y_zero_point)
+  ```
+
+  * for saturation, it saturates to [0, 255] if it's uint8, or [-127, 127] if it's int8. Right now only uint8 is supported.
+  * rounding to nearest ties to even.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T2</dt>
+<dd>Quantized output tensor</dd>
+<dt><tt>y_scale</tt> : tensor(float)</dt>
+<dd>Output scale. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>y_zero_point</tt> : T2</dt>
+<dd>Output zero point. It's a scalar, which means a per-tensor/layer quantization.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float)</dt>
+<dd>Constrain 'x' to float tensor.</dd>
+<dt><tt>T2</tt> : tensor(uint8)</dt>
+<dd>Constrain 'y_zero_point' and 'y' to 8-bit unsigned integer tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>dynamicquantizelinear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DynamicQuantizeLinear",
+    inputs=["x"],
+    outputs=["y", "y_scale", "y_zero_point"],
+)
+
+# expected scale 0.0196078438 and zero point 153
+X = np.array([0, 2, -3, -2.5, 1.34, 0.5]).astype(np.float32)
+x_min = np.minimum(0, np.min(X))
+x_max = np.maximum(0, np.max(X))
+Y_Scale = np.float32((x_max - x_min) / (255 - 0))  # uint8 -> [0, 255]
+Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8)
+Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[X],
+    outputs=[Y, Y_Scale, Y_ZeroPoint],
+    name="test_dynamicquantizelinear",
+)
+
+# expected scale 0.0156862754 and zero point 255
+X = np.array([-1.0, -2.1, -1.3, -2.5, -3.34, -4.0]).astype(np.float32)
+x_min = np.minimum(0, np.min(X))
+x_max = np.maximum(0, np.max(X))
+Y_Scale = np.float32((x_max - x_min) / (255 - 0))  # uint8 -> [0, 255]
+Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8)
+Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[X],
+    outputs=[Y, Y_Scale, Y_ZeroPoint],
+    name="test_dynamicquantizelinear_max_adjusted",
+)
+
+X = (
+    np.array([1, 2.1, 1.3, 2.5, 3.34, 4.0, 1.5, 2.6, 3.9, 4.0, 3.0, 2.345])
+    .astype(np.float32)
+    .reshape((3, 4))
+)
+
+# expected scale 0.0156862754 and zero point 0
+x_min = np.minimum(0, np.min(X))
+x_max = np.maximum(0, np.max(X))
+Y_Scale = np.float32((x_max - x_min) / (255 - 0))  # uint8 -> [0, 255]
+Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8)
+Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[X],
+    outputs=[Y, Y_Scale, Y_ZeroPoint],
+    name="test_dynamicquantizelinear_min_adjusted",
+)
+```
+
+</details>
+
+
+### <a name="Einsum"></a><a name="einsum">**Einsum**</a>
+
+  An einsum of the form `term1, term2 -> output-term` produces an output tensor using the following equation
+
+  ```
+  output[output-term] = reduce-sum( input1[term1] * input2[term2] )
+  ```
+
+  where the reduce-sum performs a summation over all the indices occurring in the input terms (term1, term2)
+  that do not occur in the output-term.
+
+  The Einsum operator evaluates algebraic tensor operations on a sequence of tensors, using the Einstein summation
+  convention. The equation string contains a comma-separated sequence of lower case letters. Each term corresponds to
+  an operand tensor, and the characters within the terms correspond to operands dimensions.
+
+  This sequence may be followed by "->" to separate the left and right hand side of the equation.
+  If the equation contains "->" followed by the right-hand side, the explicit (not classical) form of the Einstein
+  summation is performed, and the right-hand side indices indicate output tensor dimensions. In other cases,
+  output indices are (implicitly) set to the alphabetically sorted sequence of indices appearing exactly once in the
+  equation.
+
+  When a dimension character is repeated in the left-hand side, it represents summation along the dimension.
+
+  The equation may contain ellipsis ("...") to enable broadcasting. Ellipsis must indicate a fixed number of dimensions.
+  Specifically, every occurrence of ellipsis in the equation must represent the same number of dimensions.
+  The right-hand side may contain exactly one ellipsis. In implicit mode, the ellipsis dimensions are set to the
+  beginning of the output. The equation string may contain space (U+0020) character.
+
+#### Version
+
+This version of the operator has been available since version 12 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>equation</tt> : string (required)</dt>
+<dd>Einsum expression string.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>Inputs</tt> (variadic, differentiable) : T</dt>
+<dd>Operands</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Output</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to all numerical tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>einsum_batch_diagonal</summary>
+
+```python
+Eqn = "...ii ->...i"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+)
+
+X = np.random.randn(3, 5, 5)
+Z = einsum_reference_implementation(Eqn, (X,))
+
+expect(node, inputs=[X], outputs=[Z], name="test_einsum_batch_diagonal")
+```
+
+</details>
+
+
+<details>
+<summary>einsum_batch_matmul</summary>
+
+```python
+Eqn = "bij, bjk -> bik"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn
+)
+
+X = np.random.randn(5, 2, 3)
+Y = np.random.randn(5, 3, 4)
+Z = einsum_reference_implementation(Eqn, (X, Y))
+
+expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_batch_matmul")
+```
+
+</details>
+
+
+<details>
+<summary>einsum_inner_prod</summary>
+
+```python
+Eqn = "i,i"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn
+)
+
+X = np.random.randn(5)
+Y = np.random.randn(5)
+Z = einsum_reference_implementation(Eqn, (X, Y))
+
+expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_inner_prod")
+```
+
+</details>
+
+
+<details>
+<summary>einsum_scalar</summary>
+
+```python
+Eqn = "->"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+)
+
+X = np.array(5.0)  # scalar input
+Z = einsum_reference_implementation(Eqn, (X,))
+
+expect(node, inputs=[X], outputs=[Z], name="test_einsum_scalar")
+```
+
+</details>
+
+
+<details>
+<summary>einsum_sum</summary>
+
+```python
+Eqn = "ij->i"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+)
+
+X = np.random.randn(3, 4)
+Z = einsum_reference_implementation(Eqn, (X,))
+
+expect(node, inputs=[X], outputs=[Z], name="test_einsum_sum")
+```
+
+</details>
+
+
+<details>
+<summary>einsum_transpose</summary>
+
+```python
+Eqn = "ij->ji"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+)
+
+X = np.random.randn(3, 4)
+Y = einsum_reference_implementation(Eqn, (X,))
+
+expect(node, inputs=[X], outputs=[Y], name="test_einsum_transpose")
+```
+
+</details>
+
+
+### <a name="Elu"></a><a name="elu">**Elu**</a>
+
+  Elu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the function `f(x) = alpha * (exp(x) - 1.) for x <
+  0`, `f(x) = x for x >= 0`., is applied to the tensor elementwise.
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Elu-1">1</a>, <a href="Changelog.md#Elu-6">6</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Coefficient of ELU.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>elu</summary>
+
+```python
+node = onnx.helper.make_node("Elu", inputs=["x"], outputs=["y"], alpha=2.0)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-1.2642411, 0., 1.]
+y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0
+expect(node, inputs=[x], outputs=[y], name="test_elu_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0
+expect(node, inputs=[x], outputs=[y], name="test_elu")
+```
+
+</details>
+
+
+<details>
+<summary>elu_default</summary>
+
+```python
+default_alpha = 1.0
+node = onnx.helper.make_node(
+    "Elu",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * default_alpha
+expect(node, inputs=[x], outputs=[y], name="test_elu_default")
+```
+
+</details>
+
+
+### <a name="Equal"></a><a name="equal">**Equal**</a>
+
+  Returns the tensor resulted from performing the `equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Equal-1">1</a>, <a href="Changelog.md#Equal-7">7</a>, <a href="Changelog.md#Equal-11">11</a>, <a href="Changelog.md#Equal-13">13</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(string)</dt>
+<dd>Constrain input types to all (non-complex) tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>equal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Equal",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = (np.random.randn(3, 4, 5) * 10).astype(np.int32)
+y = (np.random.randn(3, 4, 5) * 10).astype(np.int32)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal")
+
+x = (np.random.randn(3, 4, 5) * 10).astype(np.int8)
+y = (np.random.randn(3, 4, 5) * 10).astype(np.int8)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_int8")
+
+x = (np.random.randn(3, 4, 5) * 10).astype(np.int16)
+y = (np.random.randn(3, 4, 5) * 10).astype(np.int16)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>equal_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Equal",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = (np.random.randn(3, 4, 5) * 10).astype(np.int32)
+y = (np.random.randn(5) * 10).astype(np.int32)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_bcast")
+```
+
+</details>
+
+
+<details>
+<summary>equal_string</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Equal",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+x = np.array(["string1", "string2"], dtype=np.dtype(object))
+y = np.array(["string1", "string3"], dtype=np.dtype(object))
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_string")
+```
+
+</details>
+
+
+<details>
+<summary>equal_string_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Equal",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+x = np.array(["string1", "string2"], dtype=np.dtype(object))
+y = np.array(["string1"], dtype=np.dtype(object))
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_string_broadcast")
+```
+
+</details>
+
+
+### <a name="Erf"></a><a name="erf">**Erf**</a>
+
+  Computes the error function of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Erf-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The error function of the input tensor computed element-wise. It has the same shape and type of the input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>erf</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Erf",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+y = np.vectorize(math.erf)(x).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_erf")
+```
+
+</details>
+
+
+### <a name="Exp"></a><a name="exp">**Exp**</a>
+
+  Calculates the exponential of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Exp-1">1</a>, <a href="Changelog.md#Exp-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The exponential of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>exp</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Exp",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.exp(x)  # expected output [0.36787945, 1., 2.71828175]
+expect(node, inputs=[x], outputs=[y], name="test_exp_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.exp(x)
+expect(node, inputs=[x], outputs=[y], name="test_exp")
+```
+
+</details>
+
+
+### <a name="Expand"></a><a name="expand">**Expand**</a>
+
+  Broadcast the input tensor following the given shape and the broadcast rule.
+  The broadcast rule is similar to numpy.array(input) * numpy.ones(shape):
+  Dimensions are right alignment;
+  Two corresponding dimensions must have the same value, or one of them is equal to 1.
+  Also, this operator is similar to numpy.broadcast_to(input, shape),
+  but the major difference is numpy.broadcast_to() does not allow shape to be smaller than input.size().
+  It is possible that the output.shape is not equal to shape, when some dimensions in shape is equal to 1,
+  or the shape.ndim < input.shape.ndim.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Expand-8">8</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D tensor indicates the shape you want to expand to, following the broadcast rule</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>dim_changed</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Expand",
+    inputs=["data", "new_shape"],
+    outputs=["expanded"],
+)
+shape = [3, 1]
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[1.], [2.], [3.]]
+new_shape = [2, 1, 6]
+expanded = data * np.ones(new_shape, dtype=np.float32)
+# print(expanded)
+# [[[1., 1., 1., 1., 1., 1.],
+#  [2., 2., 2., 2., 2., 2.],
+#  [3., 3., 3., 3., 3., 3.]],
+#
+# [[1., 1., 1., 1., 1., 1.],
+#  [2., 2., 2., 2., 2., 2.],
+#  [3., 3., 3., 3., 3., 3.]]]
+new_shape = np.array(new_shape, dtype=np.int64)
+expect(
+    node,
+    inputs=[data, new_shape],
+    outputs=[expanded],
+    name="test_expand_dim_changed",
+)
+```
+
+</details>
+
+
+<details>
+<summary>dim_unchanged</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Expand",
+    inputs=["data", "new_shape"],
+    outputs=["expanded"],
+)
+shape = [3, 1]
+new_shape = [3, 4]
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[1.], [2.], [3.]]
+expanded = np.tile(data, 4)
+# print(expanded)
+# [[1., 1., 1., 1.],
+# [2., 2., 2., 2.],
+# [3., 3., 3., 3.]]
+new_shape = np.array(new_shape, dtype=np.int64)
+expect(
+    node,
+    inputs=[data, new_shape],
+    outputs=[expanded],
+    name="test_expand_dim_unchanged",
+)
+```
+
+</details>
+
+
+### <a name="EyeLike"></a><a name="eyelike">**EyeLike**</a>
+
+  Generate a 2D tensor (matrix) with ones on the diagonal and zeros everywhere else. Only 2D
+  tensors are supported, i.e. input T1 must be of rank 2. The shape of the output tensor is the
+  same as the input tensor. The data type can be specified by the 'dtype' argument. If
+  'dtype' is not specified, then the type of input tensor is used. By default, the main diagonal
+  is populated with ones, but attribute 'k' can be used to populate upper or lower diagonals.
+  The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message and be valid as an output type.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#EyeLike-9">9</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type for the elements of the output tensor. If not specified, the data type of the input tensor T1 is used.</dd>
+<dt><tt>k</tt> : int (default is 0)</dt>
+<dd>(Optional) Index of the diagonal to be populated with ones. Default is 0. If T2 is the output, this op sets T2[i, i+k] = 1. k = 0 populates the main diagonal, k > 0 populates an upper diagonal,  and k < 0 populates a lower diagonal.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>2D input tensor to copy shape, and optionally, type information from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor, same shape as input tensor T1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool)</dt>
+<dd>Constrain input types. Strings and complex are not supported.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(bool)</dt>
+<dd>Constrain output types. Strings and complex are not supported.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>populate_off_main_diagonal</summary>
+
+```python
+shape = (4, 5)
+off_diagonal_offset = 1
+node = onnx.helper.make_node(
+    "EyeLike",
+    inputs=["x"],
+    outputs=["y"],
+    k=off_diagonal_offset,
+    dtype=onnx.TensorProto.FLOAT,
+)
+
+x = np.random.randint(0, 100, size=shape, dtype=np.int32)
+y = np.eye(shape[0], shape[1], k=off_diagonal_offset, dtype=np.float32)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_eyelike_populate_off_main_diagonal",
+)
+```
+
+</details>
+
+
+<details>
+<summary>with_dtype</summary>
+
+```python
+shape = (3, 4)
+node = onnx.helper.make_node(
+    "EyeLike",
+    inputs=["x"],
+    outputs=["y"],
+    dtype=onnx.TensorProto.DOUBLE,
+)
+
+x = np.random.randint(0, 100, size=shape, dtype=np.int32)
+y = np.eye(shape[0], shape[1], dtype=np.float64)
+expect(node, inputs=[x], outputs=[y], name="test_eyelike_with_dtype")
+```
+
+</details>
+
+
+<details>
+<summary>without_dtype</summary>
+
+```python
+shape = (4, 4)
+node = onnx.helper.make_node(
+    "EyeLike",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.randint(0, 100, size=shape, dtype=np.int32)
+y = np.eye(shape[0], shape[1], dtype=np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_eyelike_without_dtype")
+```
+
+</details>
+
+
+### <a name="Flatten"></a><a name="flatten">**Flatten**</a>
+
+  Flattens the input tensor into a 2D matrix. If input tensor has shape
+  (d_0, d_1, ... d_n) then the output will have shape
+  (d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Flatten-1">1</a>, <a href="Changelog.md#Flatten-9">9</a>, <a href="Changelog.md#Flatten-11">11</a>, <a href="Changelog.md#Flatten-13">13</a>, <a href="Changelog.md#Flatten-21">21</a>, <a href="Changelog.md#Flatten-23">23</a>, <a href="Changelog.md#Flatten-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>Indicate up to which input dimensions (exclusive) should be flattened to the outer dimension of the output. The value for axis must be in the range [-r, r], where r is the rank of the input tensor. Negative value means counting dimensions from the back. When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), where the shape of the input tensor is (d_0, d_1, ... d_n). </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>A tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>A 2D tensor with the contents of the input tensor, with input dimensions up to axis flattened to the outer dimension of the output and remaining input dimensions flattened into the inner dimension of the output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output to all tensor types up to IRv13.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>flatten</summary>
+
+```python
+shape = (2, 3, 4, 5)
+a = np.random.random_sample(shape).astype(np.float32)
+
+for i in range(len(shape)):
+    node = onnx.helper.make_node(
+        "Flatten",
+        inputs=["a"],
+        outputs=["b"],
+        axis=i,
+    )
+
+    new_shape = (1, -1) if i == 0 else (np.prod(shape[0:i]).astype(int), -1)
+    b = np.reshape(a, new_shape)
+    expect(node, inputs=[a], outputs=[b], name="test_flatten_axis" + str(i))
+```
+
+</details>
+
+
+<details>
+<summary>flatten_negative_axis</summary>
+
+```python
+shape = (2, 3, 4, 5)
+a = np.random.random_sample(shape).astype(np.float32)
+
+for i in range(-len(shape), 0):
+    node = onnx.helper.make_node(
+        "Flatten",
+        inputs=["a"],
+        outputs=["b"],
+        axis=i,
+    )
+
+    new_shape = (np.prod(shape[0:i]).astype(int), -1)
+    b = np.reshape(a, new_shape)
+    expect(
+        node,
+        inputs=[a],
+        outputs=[b],
+        name="test_flatten_negative_axis" + str(abs(i)),
+    )
+```
+
+</details>
+
+
+<details>
+<summary>flatten_with_default_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Flatten",
+    inputs=["a"],
+    outputs=["b"],  # Default value for axis: axis=1
+)
+
+shape = (5, 4, 3, 2)
+a = np.random.random_sample(shape).astype(np.float32)
+new_shape = (5, 24)
+b = np.reshape(a, new_shape)
+expect(node, inputs=[a], outputs=[b], name="test_flatten_default_axis")
+```
+
+</details>
+
+
+### <a name="Floor"></a><a name="floor">**Floor**</a>
+
+  Floor takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the floor is, y = floor(x), is applied to
+  the tensor elementwise. If x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Floor-1">1</a>, <a href="Changelog.md#Floor-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>floor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Floor",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.5, 1.2, 2]).astype(np.float32)
+y = np.floor(x)  # expected output [-2., 1., 2.]
+expect(node, inputs=[x], outputs=[y], name="test_floor_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.floor(x)
+expect(node, inputs=[x], outputs=[y], name="test_floor")
+```
+
+</details>
+
+
+### <a name="GRU"></a><a name="gru">**GRU**</a>
+
+  Computes an one-layer GRU. This operator is usually supported via some custom
+  implementation such as CuDNN.
+
+  Notations:
+
+  * `X` - input tensor
+  * `z` - update gate
+  * `r` - reset gate
+  * `h` - hidden gate
+  * `t` - time step (t-1 means previous time step)
+  * `W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+  * `R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+  * `Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+  * `Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+  * `WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+  * `RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+  * `WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+  * `RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+  * `H` - Hidden state
+  * `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+  * Relu(x)                - max(0, x)
+  * Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+  * Sigmoid(x)             - 1/(1 + e^{-x})
+
+  NOTE:
+    Below are optional
+
+  * Affine(x)              - alpha * x + beta
+  * LeakyRelu(x)           - x if x >= 0 else alpha * x
+  * ThresholdedRelu(x)     - x if x >= alpha else 0
+  * ScaledTanh(x)          - alpha * Tanh(beta * x)
+  * HardSigmoid(x)         - min(max(alpha * x + beta, 0), 1)
+  * Elu(x)                 - x if x >= 0 else alpha * (e^x - 1)
+  * Softsign(x)            - x/(1 + |x|)
+  * Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh):
+
+  * zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz)
+  * rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr)
+  * ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # default, when linear_before_reset = 0
+  * ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset != 0
+  * Ht = (1 - zt) (.) ht + zt (.) Ht-1
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#GRU-1">1</a>, <a href="Changelog.md#GRU-3">3</a>, <a href="Changelog.md#GRU-7">7</a>, <a href="Changelog.md#GRU-14">14</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 2 (or 4 if bidirectional) activation functions for update, reset, and hidden gates. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>layout</tt> : int (default is 0)</dt>
+<dd>The shape format of inputs X, initial_h and outputs Y, Y_h. If 0, the following shapes are expected: X.shape = [seq_length, batch_size, input_size], Y.shape = [seq_length, num_directions, batch_size, hidden_size], initial_h.shape = Y_h.shape = [num_directions, batch_size, hidden_size]. If 1, the following shapes are expected: X.shape = [batch_size, seq_length, input_size], Y.shape = [batch_size, seq_length, num_directions, hidden_size], initial_h.shape = Y_h.shape = [batch_size, num_directions, hidden_size].</dd>
+<dt><tt>linear_before_reset</tt> : int (default is 0)</dt>
+<dd>When computing the output of the hidden gate, apply the linear transformation before multiplying by the output of the reset gate.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> (differentiable) : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 3*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and `[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 6*hidden_size]`. Optional: If not specified - assumed to be 0</dd>
+<dt><tt>sequence_lens</tt> (optional, non-differentiable) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional, differentiable) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>batchwise</summary>
+
+```python
+input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 6
+number_of_gates = 3
+weight_scale = 0.2
+layout = 1
+
+node = onnx.helper.make_node(
+    "GRU",
+    inputs=["X", "W", "R"],
+    outputs=["Y", "Y_h"],
+    hidden_size=hidden_size,
+    layout=layout,
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+gru = GRUHelper(X=input, W=W, R=R, layout=layout)
+Y, Y_h = gru.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y.astype(np.float32), Y_h.astype(np.float32)],
+    name="test_gru_batchwise",
+)
+```
+
+</details>
+
+
+<details>
+<summary>defaults</summary>
+
+```python
+input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 5
+weight_scale = 0.1
+number_of_gates = 3
+
+node = onnx.helper.make_node(
+    "GRU", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+gru = GRUHelper(X=input, W=W, R=R)
+_, Y_h = gru.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_gru_defaults",
+)
+```
+
+</details>
+
+
+<details>
+<summary>initial_bias</summary>
+
+```python
+input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype(
+    np.float32
+)
+
+input_size = 3
+hidden_size = 3
+weight_scale = 0.1
+custom_bias = 0.1
+number_of_gates = 3
+
+node = onnx.helper.make_node(
+    "GRU",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+# Adding custom bias
+W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype(
+    np.float32
+)
+R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32)
+B = np.concatenate((W_B, R_B), axis=1)
+
+gru = GRUHelper(X=input, W=W, R=R, B=B)
+_, Y_h = gru.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_gru_with_initial_bias",
+)
+```
+
+</details>
+
+
+<details>
+<summary>seq_length</summary>
+
+```python
+input = np.array(
+    [
+        [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
+        [[10.0, 11.0, 12.0], [13.0, 14.0, 15.0], [16.0, 17.0, 18.0]],
+    ]
+).astype(np.float32)
+
+input_size = 3
+hidden_size = 5
+number_of_gates = 3
+
+node = onnx.helper.make_node(
+    "GRU",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = np.random.randn(1, number_of_gates * hidden_size, input_size).astype(
+    np.float32
+)
+R = np.random.randn(1, number_of_gates * hidden_size, hidden_size).astype(
+    np.float32
+)
+
+# Adding custom bias
+W_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32)
+R_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32)
+B = np.concatenate((W_B, R_B), axis=1)
+
+gru = GRUHelper(X=input, W=W, R=R, B=B)
+_, Y_h = gru.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_gru_seq_length",
+)
+```
+
+</details>
+
+
+### <a name="Gather"></a><a name="gather">**Gather**</a>
+
+  Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
+  entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
+  them in an output tensor of rank q + (r - 1).
+
+  It is an indexing operation that indexes into the input `data` along a single (specified) axis.
+  Each entry in `indices` produces a `r-1` dimensional slice of the input tensor.
+  The entire operation produces, conceptually, a `q`-dimensional tensor of `r-1` dimensional slices,
+  which is arranged into a `q + (r-1)`-dimensional tensor, with the `q` dimensions taking the
+  place of the original `axis` that is being indexed into.
+
+  The following few examples illustrate how `Gather` works for specific shapes of `data`,
+  `indices`, and given value of `axis`:
+  | data shape | indices shape | axis | output shape | output equation |
+  | --- | --- | --- | --- | --- |
+  | (P, Q) | ( )  (a scalar)   | 0 | (Q)       | output[q] = data[indices, q] |
+  | (P, Q, R) | ( )  (a scalar)   | 1 | (P, R)       | output[p, r] = data[p, indices, r] |
+  | (P, Q) | (R, S) | 0 | (R, S, Q) | output[r, s, q] = data[ [indices[r, s], q] |
+  | (P, Q) | (R, S) | 1 | (P, R, S) | output[p, r, s] = data[ p, indices[r, s]] |
+
+  More generally, if `axis = 0`, let `k = indices[i_{0}, ..., i_{q-1}]`
+  then `output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[k , j_{0}, ..., j_{r-2}]`:
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+  indices = [
+      [0, 1],
+      [1, 2],
+  ]
+  output = [
+      [
+          [1.0, 1.2],
+          [2.3, 3.4],
+      ],
+      [
+          [2.3, 3.4],
+          [4.5, 5.7],
+      ],
+  ]
+  ```
+
+  If `axis = 1`, let `k = indices[i_{0}, ..., i_{q-1}]`
+  then `output[j_{0}, i_{0}, ..., i_{q-1}, j_{1}, ..., j_{r-2}] = input[j_{0}, k, j_{1}, ..., j_{r-2}]`:
+
+  ```
+  data = [
+      [1.0, 1.2, 1.9],
+      [2.3, 3.4, 3.9],
+      [4.5, 5.7, 5.9],
+  ]
+  indices = [
+      [0, 2],
+  ]
+  axis = 1,
+  output = [
+          [[1.0, 1.9]],
+          [[2.3, 3.9]],
+          [[4.5, 5.9]],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Gather-1">1</a>, <a href="Changelog.md#Gather-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to gather on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : Tind</dt>
+<dd>Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank q + (r - 1).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>gather_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gather",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=0,
+)
+data = np.random.randn(5, 4, 3, 2).astype(np.float32)
+indices = np.array([0, 1, 3])
+y = np.take(data, indices, axis=0)
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_0",
+)
+```
+
+</details>
+
+
+<details>
+<summary>gather_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gather",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=1,
+)
+data = np.random.randn(5, 4, 3, 2).astype(np.float32)
+indices = np.array([0, 1, 3])
+y = np.take(data, indices, axis=1)
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_1",
+)
+```
+
+</details>
+
+
+<details>
+<summary>gather_2d_indices</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gather",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=1,
+)
+data = np.random.randn(3, 3).astype(np.float32)
+indices = np.array([[0, 2]])
+y = np.take(data, indices, axis=1)
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_2d_indices",
+)
+```
+
+</details>
+
+
+<details>
+<summary>gather_negative_indices</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gather",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=0,
+)
+data = np.arange(10).astype(np.float32)
+indices = np.array([0, -9, -10])
+y = np.take(data, indices, axis=0)
+
+# print(y)
+# [0. 1. 0.]
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_negative_indices",
+)
+```
+
+</details>
+
+
+### <a name="GatherElements"></a><a name="gatherelements">**GatherElements**</a>
+
+  GatherElements takes two inputs `data` and `indices` of the same rank r >= 1
+  and an optional attribute `axis` that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). It is an indexing operation
+  that produces its output by indexing into the input data tensor at index
+  positions determined by elements of the `indices` tensor.
+  Its output shape is the same as the shape of `indices` and consists of one value
+  (gathered from the `data`) for each element in `indices`.
+
+  For instance, in the 3-D case (r = 3), the output produced is determined
+  by the following equations:
+  ```
+  out[i][j][k] = input[index[i][j][k]][j][k] if axis = 0,
+  out[i][j][k] = input[i][index[i][j][k]][k] if axis = 1,
+  out[i][j][k] = input[i][j][index[i][j][k]] if axis = 2,
+  ```
+
+  This operator is also the inverse of ScatterElements. It is similar to Torch's gather operation.
+
+  Example 1:
+  ```
+  data = [
+      [1, 2],
+      [3, 4],
+  ]
+  indices = [
+      [0, 0],
+      [1, 0],
+  ]
+  axis = 1
+  output = [
+      [1, 1],
+      [4, 3],
+  ]
+  ```
+  Example 2:
+  ```
+  data = [
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9],
+  ]
+  indices = [
+      [1, 2, 0],
+      [2, 0, 0],
+  ]
+  axis = 0
+  output = [
+      [4, 8, 3],
+      [7, 2, 3],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#GatherElements-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to gather on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : Tind</dt>
+<dd>Tensor of int32/int64 indices, with the same rank r as the input. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of the same shape as indices.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>gather_elements_0</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "GatherElements",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+indices = np.array([[0, 0], [1, 0]], dtype=np.int32)
+
+y = gather_elements(data, indices, axis)
+# print(y) produces
+# [[1, 1],
+#  [4, 3]]
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_elements_0",
+)
+```
+
+</details>
+
+
+<details>
+<summary>gather_elements_1</summary>
+
+```python
+axis = 0
+node = onnx.helper.make_node(
+    "GatherElements",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32)
+indices = np.array([[1, 2, 0], [2, 0, 0]], dtype=np.int32)
+
+y = gather_elements(data, indices, axis)
+# print(y) produces
+# [[4, 8, 3],
+#  [7, 2, 3]]
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_elements_1",
+)
+```
+
+</details>
+
+
+<details>
+<summary>gather_elements_negative_indices</summary>
+
+```python
+axis = 0
+node = onnx.helper.make_node(
+    "GatherElements",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32)
+indices = np.array([[-1, -2, 0], [-2, 0, 0]], dtype=np.int32)
+
+y = gather_elements(data, indices, axis)
+# print(y) produces
+# [[7, 5, 3],
+#  [4, 2, 3]]
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_elements_negative_indices",
+)
+```
+
+</details>
+
+
+### <a name="GatherND"></a><a name="gathernd">**GatherND**</a>
+
+  Given `data` tensor of rank `r` >= 1, `indices` tensor of rank `q` >= 1, and `batch_dims` integer `b`, this operator gathers
+  slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1 - b`.
+
+  `indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
+  where each element defines a slice of `data`
+
+  `batch_dims` (denoted as `b`) is an integer indicating the number of batch dimensions, i.e the leading `b` number of dimensions of
+  `data` tensor and `indices` are representing the batches, and the gather starts from the `b+1` dimension.
+
+  Some salient points about the inputs' rank and shape:
+
+  1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`
+
+  2) The first `b` dimensions of the shape of `indices` tensor and `data` tensor must be equal.
+
+  3) b < min(q, r) is to be honored.
+
+  4) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r-b` (inclusive)
+
+  5) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
+     It is an error if any of the index values are out of bounds.
+
+  The output is computed as follows:
+
+  The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.
+
+  1) If `indices_shape[-1] > r-b` => error condition
+
+  2) If `indices_shape[-1] == r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensors
+     containing 1-D tensors of dimension `r-b`, where `N` is an integer equals to the product of 1 and all the elements in the batch dimensions
+     of the indices_shape. Let us think of each such `r-b` ranked tensor as `indices_slice`. Each *scalar value* corresponding to `data[0:b-1,indices_slice]`
+     is filled into the corresponding location of the `(q-b-1)`-dimensional tensor to form the `output` tensor (Example 1 below)
+
+  3) If `indices_shape[-1] < r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensor
+     containing 1-D tensors of dimension `< r-b`. Let us think of each such tensors as `indices_slice`. Each *tensor slice* corresponding
+     to `data[0:b-1, indices_slice , :]` is filled into the corresponding location of the `(q-b-1)`-dimensional tensor
+     to form the `output` tensor (Examples 2, 3, 4 and 5 below)
+
+  This operator is the inverse of `ScatterND`.
+
+  **Example 1**
+
+  ```
+  batch_dims = 0
+  data    = [[0,1],[2,3]]   # data_shape    = [2, 2]
+  indices = [[0,0],[1,1]]   # indices_shape = [2, 2]
+  output  = [0,3]           # output_shape  = [2]
+  ```
+
+  **Example 2**
+
+  ```
+  batch_dims = 0
+  data    = [[0,1],[2,3]]  # data_shape    = [2, 2]
+  indices = [[1],[0]]      # indices_shape = [2, 1]
+  output  = [[2,3],[0,1]]  # output_shape  = [2, 2]
+  ```
+
+  **Example 3**
+
+  ```
+  batch_dims = 0
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
+  indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]
+  output  = [[2,3],[4,5]]                 # output_shape  = [2, 2]
+  ```
+
+  **Example 4**
+
+  ```
+  batch_dims = 0
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
+  indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]
+  output  = [[[2,3]],[[4,5]]]             # output_shape  = [2, 1, 2]
+  ```
+
+  **Example 5**
+
+  ```
+  batch_dims = 1
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
+  indices = [[1],[0]]                     # indices_shape = [2, 1]
+  output  = [[2,3],[4,5]]                 # output_shape  = [2, 2]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#GatherND-11">11</a>, <a href="Changelog.md#GatherND-12">12</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>batch_dims</tt> : int (default is 0)</dt>
+<dd>The number of batch dimensions. The gather of indexing starts from dimension of data[batch_dims:]</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank q + r - indices_shape[-1] - 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>float32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GatherND",
+    inputs=["data", "indices"],
+    outputs=["output"],
+)
+
+data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.float32)
+indices = np.array([[[0, 1]], [[1, 0]]], dtype=np.int64)
+output = gather_nd_impl(data, indices, 0)
+expected_output = np.array([[[2, 3]], [[4, 5]]], dtype=np.float32)
+assert np.array_equal(output, expected_output)
+expect(
+    node,
+    inputs=[data, indices],
+    outputs=[output],
+    name="test_gathernd_example_float32",
+)
+```
+
+</details>
+
+
+<details>
+<summary>int32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GatherND",
+    inputs=["data", "indices"],
+    outputs=["output"],
+)
+
+data = np.array([[0, 1], [2, 3]], dtype=np.int32)
+indices = np.array([[0, 0], [1, 1]], dtype=np.int64)
+output = gather_nd_impl(data, indices, 0)
+expected_output = np.array([0, 3], dtype=np.int32)
+assert np.array_equal(output, expected_output)
+expect(
+    node,
+    inputs=[data, indices],
+    outputs=[output],
+    name="test_gathernd_example_int32",
+)
+```
+
+</details>
+
+
+<details>
+<summary>int32_batchdim_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GatherND",
+    inputs=["data", "indices"],
+    outputs=["output"],
+    batch_dims=1,
+)
+
+data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.int32)
+indices = np.array([[1], [0]], dtype=np.int64)
+output = gather_nd_impl(data, indices, 1)
+expected_output = np.array([[2, 3], [4, 5]], dtype=np.int32)
+assert np.array_equal(output, expected_output)
+expect(
+    node,
+    inputs=[data, indices],
+    outputs=[output],
+    name="test_gathernd_example_int32_batch_dim1",
+)
+```
+
+</details>
+
+
+### <a name="Gelu"></a><a name="gelu">**Gelu**</a>
+
+  Gelu takes one input data (Tensor<T>) and produces one
+  output data (Tensor<T>) where the gaussian error linear units function,
+  $y = 0.5 * x * (1 + erf(x/sqrt(2)))$ is applied to the tensor elementwise.
+  If the attribute "approximate" is set to "tanh", the function estimation,
+  $y = 0.5 * x * (1 + Tanh(sqrt(2/\pi) * (x + 0.044715 * x^3)))$ is used and applied
+  to the tensor elementwise.
+
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>approximate</tt> : string (default is none)</dt>
+<dd>Gelu approximation algorithm: `"tanh"`, `"none"`(default).`"none"`: do not use approximation.`"tanh"`: use tanh approximation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>gelu_default</summary>
+
+```python
+node = onnx.helper.make_node("Gelu", inputs=["x"], outputs=["y"])
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-0.15865526, 0., 0.84134474]
+y = (0.5 * x * (1 + np.vectorize(math.erf)(x / np.sqrt(2)))).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_gelu_default_1")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+# expected output [2.99595031, 3.99987331, 4.99999857]
+y = (0.5 * x * (1 + np.vectorize(math.erf)(x / np.sqrt(2)))).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_gelu_default_2")
+```
+
+</details>
+
+
+<details>
+<summary>gelu_tanh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gelu", inputs=["x"], outputs=["y"], approximate="tanh"
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-0.158808, 0., 0.841192]
+y = (
+    0.5
+    * x
+    * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_gelu_tanh_1")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+# expected output [2.9963627, 3.99993, 4.9999995]
+y = (
+    0.5
+    * x
+    * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_gelu_tanh_2")
+```
+
+</details>
+
+
+### <a name="Gemm"></a><a name="gemm">**Gemm**</a>
+
+  General Matrix multiplication:
+  https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+
+  * A' = transpose(A) if transA else A
+  * B' = transpose(B) if transB else B
+
+  Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M),
+  input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N),
+  and output tensor Y has shape (M, N). A will be transposed before doing the
+  computation if attribute transA is non-zero, same for B and transB.
+  This operator supports **unidirectional broadcasting** (tensor C should be unidirectional broadcastable to tensor A * B); for more details please check [the doc](Broadcasting.md).
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Gemm-1">1</a>, <a href="Changelog.md#Gemm-6">6</a>, <a href="Changelog.md#Gemm-7">7</a>, <a href="Changelog.md#Gemm-9">9</a>, <a href="Changelog.md#Gemm-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for the product of input tensors A * B.</dd>
+<dt><tt>beta</tt> : float (default is 1.0)</dt>
+<dd>Scalar multiplier for input tensor C.</dd>
+<dt><tt>transA</tt> : int (default is 0)</dt>
+<dd>Whether A should be transposed</dd>
+<dt><tt>transB</tt> : int (default is 0)</dt>
+<dd>Whether B should be transposed</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>Input tensor A. The shape of A should be (M, K) if transA is 0, or (K, M) if transA is non-zero.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Input tensor B. The shape of B should be (K, N) if transB is 0, or (N, K) if transB is non-zero.</dd>
+<dt><tt>C</tt> (optional, differentiable) : T</dt>
+<dd>Optional input tensor C. If not specified, the computation is done as if C is a scalar 0. The shape of C should be unidirectional broadcastable to (M, N).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor of shape (M, N).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>all_attributes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm",
+    inputs=["a", "b", "c"],
+    outputs=["y"],
+    alpha=0.25,
+    beta=0.35,
+    transA=1,
+    transB=1,
+)
+a = np.random.ranf([4, 3]).astype(np.float32)
+b = np.random.ranf([5, 4]).astype(np.float32)
+c = np.random.ranf([1, 5]).astype(np.float32)
+y = gemm_reference_implementation(
+    a, b, c, transA=1, transB=1, alpha=0.25, beta=0.35
+)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_all_attributes")
+```
+
+</details>
+
+
+<details>
+<summary>alpha</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm", inputs=["a", "b", "c"], outputs=["y"], alpha=0.5
+)
+a = np.random.ranf([3, 5]).astype(np.float32)
+b = np.random.ranf([5, 4]).astype(np.float32)
+c = np.zeros([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c, alpha=0.5)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_alpha")
+```
+
+</details>
+
+
+<details>
+<summary>beta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm", inputs=["a", "b", "c"], outputs=["y"], beta=0.5
+)
+a = np.random.ranf([2, 7]).astype(np.float32)
+b = np.random.ranf([7, 4]).astype(np.float32)
+c = np.random.ranf([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c, beta=0.5)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_beta")
+```
+
+</details>
+
+
+<details>
+<summary>default_matrix_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([3, 6]).astype(np.float32)
+b = np.random.ranf([6, 4]).astype(np.float32)
+c = np.random.ranf([3, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(
+    node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_matrix_bias"
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_no_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b"], outputs=["y"])
+a = np.random.ranf([2, 10]).astype(np.float32)
+b = np.random.ranf([10, 3]).astype(np.float32)
+y = gemm_reference_implementation(a, b)
+expect(node, inputs=[a, b], outputs=[y], name="test_gemm_default_no_bias")
+```
+
+</details>
+
+
+<details>
+<summary>default_scalar_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([2, 3]).astype(np.float32)
+b = np.random.ranf([3, 4]).astype(np.float32)
+c = np.array(3.14).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(
+    node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_scalar_bias"
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_single_elem_vector_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([3, 7]).astype(np.float32)
+b = np.random.ranf([7, 3]).astype(np.float32)
+c = np.random.ranf([1]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(
+    node,
+    inputs=[a, b, c],
+    outputs=[y],
+    name="test_gemm_default_single_elem_vector_bias",
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_vector_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([2, 7]).astype(np.float32)
+b = np.random.ranf([7, 4]).astype(np.float32)
+c = np.random.ranf([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(
+    node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_vector_bias"
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_zero_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([3, 5]).astype(np.float32)
+b = np.random.ranf([5, 4]).astype(np.float32)
+c = np.zeros([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_zero_bias")
+```
+
+</details>
+
+
+<details>
+<summary>transposeA</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm", inputs=["a", "b", "c"], outputs=["y"], transA=1
+)
+a = np.random.ranf([6, 3]).astype(np.float32)
+b = np.random.ranf([6, 4]).astype(np.float32)
+c = np.zeros([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c, transA=1)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeA")
+```
+
+</details>
+
+
+<details>
+<summary>transposeB</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm", inputs=["a", "b", "c"], outputs=["y"], transB=1
+)
+a = np.random.ranf([3, 6]).astype(np.float32)
+b = np.random.ranf([4, 6]).astype(np.float32)
+c = np.zeros([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c, transB=1)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeB")
+```
+
+</details>
+
+
+### <a name="GlobalAveragePool"></a><a name="globalaveragepool">**GlobalAveragePool**</a>
+
+  GlobalAveragePool consumes an input tensor X and applies average pooling across
+   the values in the same channel. This is equivalent to AveragePool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#GlobalAveragePool-1">1</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from pooling across the input tensor. The output tensor has the same rank as the input. The first two dimensions of output shape are the same as the input (N x C), while the other dimensions are all 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>globalaveragepool</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GlobalAveragePool",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 5, 5).astype(np.float32)
+y = np.mean(x, axis=tuple(range(2, np.ndim(x))), keepdims=True)
+expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool")
+```
+
+</details>
+
+
+<details>
+<summary>globalaveragepool_precomputed</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GlobalAveragePool",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[5]]]]).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool_precomputed")
+```
+
+</details>
+
+
+### <a name="GlobalLpPool"></a><a name="globallppool">**GlobalLpPool**</a>
+
+  GlobalLpPool consumes an input tensor X and applies lp pool pooling across
+   the values in the same channel. This is equivalent to LpPool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#GlobalLpPool-1">1</a>, <a href="Changelog.md#GlobalLpPool-2">2</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>p value of the Lp norm used to pool over the input data.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from pooling across the input tensor. The output tensor has the same rank as the input. The first two dimensions of output shape are the same as the input (N x C), while the other dimensions are all 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+### <a name="GlobalMaxPool"></a><a name="globalmaxpool">**GlobalMaxPool**</a>
+
+  GlobalMaxPool consumes an input tensor X and applies max pooling across
+   the values in the same channel. This is equivalent to MaxPool with kernel size
+   equal to the spatial dimension of input tensor.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#GlobalMaxPool-1">1</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from pooling across the input tensor. The output tensor has the same rank as the input. The first two dimensions of output shape are the same as the input (N x C), while the other dimensions are all 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>globalmaxpool</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GlobalMaxPool",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 5, 5).astype(np.float32)
+y = np.max(x, axis=tuple(range(2, np.ndim(x))), keepdims=True)
+expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool")
+```
+
+</details>
+
+
+<details>
+<summary>globalmaxpool_precomputed</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GlobalMaxPool",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[9]]]]).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool_precomputed")
+```
+
+</details>
+
+
+### <a name="Greater"></a><a name="greater">**Greater**</a>
+
+  Returns the tensor resulted from performing the `greater` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Greater-1">1</a>, <a href="Changelog.md#Greater-7">7</a>, <a href="Changelog.md#Greater-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>greater</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Greater",
+    inputs=["x", "y"],
+    outputs=["greater"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater")
+
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.random.randn(3, 4, 5).astype(np.int8)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_int8")
+
+x = np.random.randn(3, 4, 5).astype(np.int16)
+y = np.random.randn(3, 4, 5).astype(np.int16)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>greater</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GreaterOrEqual",
+    inputs=["x", "y"],
+    outputs=["greater_equal"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal")
+
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.random.randn(3, 4, 5).astype(np.int8)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int8")
+
+x = np.random.randn(3, 4, 5).astype(np.int16)
+y = np.random.randn(3, 4, 5).astype(np.int16)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>greater_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Greater",
+    inputs=["x", "y"],
+    outputs=["greater"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_bcast")
+```
+
+</details>
+
+
+<details>
+<summary>greater_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GreaterOrEqual",
+    inputs=["x", "y"],
+    outputs=["greater_equal"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_bcast")
+```
+
+</details>
+
+
+### <a name="GreaterOrEqual"></a><a name="greaterorequal">**GreaterOrEqual**</a>
+
+  Returns the tensor resulted from performing the `greater_equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#GreaterOrEqual-12">12</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+
+### <a name="GridSample"></a><a name="gridsample">**GridSample**</a>
+
+  Given an input `X` and a flow-field `grid`, computes the output `Y` using `X` values and pixel locations from the `grid`.
+  For spatial input `X` with shape (N, C, H, W), the `grid` will have shape (N, H_out, W_out, 2),
+  the output `Y` will have shape (N, C, H_out, W_out). For volumetric input `X` with shape (N, C, D, H, W),
+  the `grid` will have shape (N, D_out, H_out, W_out, 3), the output `Y` will have shape (N, C, D_out, H_out, W_out).
+  More generally, for an input `X` of rank r+2 with shape (N, C, d1, d2, ..., dr),
+  the `grid` will have shape (N, D1_out, D2_out, ..., Dr_out, r), the output `Y` will have shape (N, C, D1_out, D2_out, ..., Dr_out).
+
+  The tensor `X` contains values at centers of square pixels (voxels, etc) locations such as (n, c, d1_in, d2_in, ..., dr_in).
+  The (n, d1_out, d2_out, ..., dr_out, :) values from the tensor `grid` are the normalized positions for interpolating the values
+  at the (n, c, d1_out, d2_out, ..., dr_out) locations from the output tensor `Y` using a specified interpolation method (the mode)
+  and a padding mode (for `grid` positions falling outside the 2-dimensional image).
+
+  For example, the values in `grid[n, h_out, w_out, :]` are size-2 vectors specifying normalized positions in the 2-dimensional space of `X`.
+  They are used to interpolate output values of `Y[n, c, h_out, w_out]`.
+
+  The GridSample operator is often used in doing grid generator and sampler in the
+  [Spatial Transformer Networks](https://arxiv.org/abs/1506.02025).
+  See also in [torch.nn.functional.grid_sample](https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html).
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#GridSample-16">16</a>, <a href="Changelog.md#GridSample-20">20</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>align_corners</tt> : int (default is 0)</dt>
+<dd>If align_corners=1, the extrema (-1 and 1) are considered as referring to the center points of the input's corner pixels (voxels, etc.). If align_corners=0, they are instead considered as referring to the corner points of the input's corner pixels (voxels, etc.), making the sampling more resolution agnostic.</dd>
+<dt><tt>mode</tt> : string (default is linear)</dt>
+<dd>Three interpolation modes: linear (default), nearest and cubic. The "linear" mode includes linear and N-linear interpolation modes depending on the number of spatial dimensions of the input tensor (i.e. linear for 1 spatial dimension, bilinear for 2 spatial dimensions, etc.). The "cubic" mode also includes N-cubic interpolation modes following the same rules. The "nearest" mode rounds to the nearest even index when the sampling point falls halfway between two indices.</dd>
+<dt><tt>padding_mode</tt> : string (default is zeros)</dt>
+<dd>Support padding modes for outside grid values: `zeros`(default), `border`, `reflection`. zeros: use 0 for out-of-bound grid locations, border: use border values for out-of-bound grid locations, reflection: use values at locations reflected by the border for out-of-bound grid locations. If index 0 represents the margin pixel, the reflected value at index -1 will be the same as the value at index 1. For location far away from the border, it will keep being reflected until becoming in bound. If pixel location x = -3.5 reflects by border -1 and becomes x' = 1.5, then reflects by border 1 and becomes x'' = 0.5.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>Input tensor of rank r+2 that has shape (N, C, D1, D2, ..., Dr), where N is the batch size, C is the number of channels, D1, D2, ..., Dr are the spatial dimensions.</dd>
+<dt><tt>grid</tt> (non-differentiable) : T2</dt>
+<dd>Input offset of shape (N, D1_out, D2_out, ..., Dr_out, r), where D1_out, D2_out, ..., Dr_out are the spatial dimensions of the grid and output, and r is the number of spatial dimensions. Grid specifies the sampling locations normalized by the input spatial dimensions. Therefore, it should have most values in the range of [-1, 1]. If the grid has values outside the range of [-1, 1], the corresponding outputs will be handled as defined by padding_mode. Following computer vision convention, the coordinates in the length-r location vector are listed from the innermost tensor dimension to the outermost, the opposite of regular tensor indexing.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>Output tensor of rank r+2 that has shape (N, C, D1_out, D2_out, ..., Dr_out) of the sampled values. For integer input types, intermediate values are computed as floating point and cast to integer at the end.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input `X` and output `Y` types to all tensor types.</dd>
+<dt><tt>T2</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain grid types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>gridsample</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    padding_mode="zeros",
+    align_corners=0,
+)
+# X shape, [N, C, H, W] - [1, 1, 4, 4]
+X = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 2.0, 3.0],
+                [4.0, 5.0, 6.0, 7.0],
+                [8.0, 9.0, 10.0, 11.0],
+                [12.0, 13.0, 14.0, 15.0],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+# Grid shape, [N, H_out, W_out, 2] - [1, 6, 6, 2]
+Grid = np.array(
+    [
+        [
+            [
+                [-1.0000, -1.0000],
+                [-0.6000, -1.0000],
+                [-0.2000, -1.0000],
+                [0.2000, -1.0000],
+                [0.6000, -1.0000],
+                [1.0000, -1.0000],
+            ],
+            [
+                [-1.0000, -0.6000],
+                [-0.6000, -0.6000],
+                [-0.2000, -0.6000],
+                [0.2000, -0.6000],
+                [0.6000, -0.6000],
+                [1.0000, -0.6000],
+            ],
+            [
+                [-1.0000, -0.2000],
+                [-0.6000, -0.2000],
+                [-0.2000, -0.2000],
+                [0.2000, -0.2000],
+                [0.6000, -0.2000],
+                [1.0000, -0.2000],
+            ],
+            [
+                [-1.0000, 0.2000],
+                [-0.6000, 0.2000],
+                [-0.2000, 0.2000],
+                [0.2000, 0.2000],
+                [0.6000, 0.2000],
+                [1.0000, 0.2000],
+            ],
+            [
+                [-1.0000, 0.6000],
+                [-0.6000, 0.6000],
+                [-0.2000, 0.6000],
+                [0.2000, 0.6000],
+                [0.6000, 0.6000],
+                [1.0000, 0.6000],
+            ],
+            [
+                [-1.0000, 1.0000],
+                [-0.6000, 1.0000],
+                [-0.2000, 1.0000],
+                [0.2000, 1.0000],
+                [0.6000, 1.0000],
+                [1.0000, 1.0000],
+            ],
+        ]
+    ],
+    dtype=np.float32,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 6, 6]
+Y = np.array(
+    [
+        [
+            [
+                [0.0000, 0.1500, 0.5500, 0.9500, 1.3500, 0.7500],
+                [0.6000, 1.5000, 2.3000, 3.1000, 3.9000, 2.1000],
+                [2.2000, 4.7000, 5.5000, 6.3000, 7.1000, 3.7000],
+                [3.8000, 7.9000, 8.7000, 9.5000, 10.3000, 5.3000],
+                [5.4000, 11.1000, 11.9000, 12.7000, 13.5000, 6.9000],
+                [3.0000, 6.1500, 6.5500, 6.9500, 7.3500, 3.7500],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+expect(node, inputs=[X, Grid], outputs=[Y], name="test_gridsample")
+```
+
+</details>
+
+
+<details>
+<summary>gridsample_mode_aligncorners</summary>
+
+```python
+# X shape, [N, C, H, W] - [1, 1, 3, 2]
+X = np.array(
+    [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]],
+    dtype=np.float32,
+)
+# Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2]
+Grid = np.array(
+    [
+        [
+            [
+                [-1.0000, -1.0000],
+                [-0.5000, -0.5000],
+                [-0.2000, -0.2000],
+                [0.0000, 0.0000],
+            ],
+            [
+                [0.0000, 0.0000],
+                [-0.2000, -0.2000],
+                [0.5000, 0.5000],
+                [1.0000, 1.0000],
+            ],
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# setting mode = 'bilinear', default align_corners = 0
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [[[[0.0000, 0.5000, 1.7000, 2.5000], [2.5000, 1.7000, 4.5000, 1.2500]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_bilinear",
+)
+
+# setting mode = 'bilinear', align_corners = 1
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_align_corners = np.array(
+    [[[[0.0000, 1.2500, 2.0000, 2.5000], [2.5000, 2.0000, 3.7500, 5.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_align_corners],
+    name="test_gridsample_aligncorners_true",
+)
+
+# setting mode = 'nearest'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [[[[0.0, 0.0, 2.0, 2.0], [2.0, 2.0, 5.0, 0.0]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node, inputs=[X, Grid], outputs=[Y_nearest], name="test_gridsample_nearest"
+)
+
+# setting mode = 'bicubic'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="cubic",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bicubic = np.array(
+    [[[[-0.1406, 0.3828, 1.7556, 2.9688], [2.9688, 1.7556, 5.1445, 1.3906]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node, inputs=[X, Grid], outputs=[Y_bicubic], name="test_gridsample_bicubic"
+)
+
+# ============================================================================
+# Additional tests
+# The reference output tensors were generated using PyTorch 2.0.
+Grid = np.array(
+    [
+        [
+            [[-1.0, -0.8], [-0.6, -0.5], [-0.1, -0.2], [0.7, 0.0]],
+            [[0.0, 0.4], [0.2, -0.2], [-0.3, 0.5], [-1.0, 1.0]],
+        ]
+    ],
+    dtype=np.float32,
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [[[[0.0, 0.0, 2.0, 3.0], [4.0, 3.0, 4.0, 4.0]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_nearest],
+    name="test_gridsample_nearest_align_corners_0_additional_1",
+)
+
+# setting mode = 'nearest'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [[[[0.0, 0.0, 2.0, 3.0], [2.0, 3.0, 4.0, 4.0]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_nearest],
+    name="test_gridsample_nearest_align_corners_1_additional_1",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [[[[0.0000, 0.4500, 1.8000, 2.4000], [3.7000, 2.1000, 3.7000, 1.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_bilinear_align_corners_0_additional_1",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [[[[0.4000, 1.2000, 2.0500, 2.8500], [3.3000, 2.2000, 3.3500, 4.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_bilinear_align_corners_1_additional_1",
+)
+
+# These two new bicubic tests produces slightly higher error ~5e-5
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="cubic",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bicubic = np.array(
+    [
+        [
+            [
+                [-0.173250, 0.284265, 1.923106, 2.568000],
+                [5.170375, 2.284414, 4.744844, 1.046875],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bicubic],
+    name="test_gridsample_bicubic_align_corners_0_additional_1",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="cubic",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bicubic = np.array(
+    [
+        [
+            [
+                [0.304001, 1.128750, 2.266270, 3.144844],
+                [4.531500, 2.455360, 4.599819, 4.000000],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bicubic],
+    name="test_gridsample_bicubic_align_corners_1_additional_1",
+)
+```
+
+</details>
+
+
+<details>
+<summary>gridsample_paddingmode</summary>
+
+```python
+# X shape, [N, C, H, W] - [1, 1, 3, 2]
+X = np.array(
+    [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]],
+    dtype=np.float32,
+)
+# Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2]
+Grid = np.array(
+    [
+        [
+            [
+                [-10.0000, -10.0000],
+                [-5.0000, -5.0000],
+                [-0.2000, -0.2000],
+                [10.0000, 10.0000],
+            ],
+            [
+                [10.0000, 10.0000],
+                [-0.2000, -0.2000],
+                [5.0000, 5.0000],
+                [10.0000, 10.0000],
+            ],
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# setting padding_mode = 'zeros'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    padding_mode="zeros",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_zeros = np.array(
+    [[[[0.0000, 0.0000, 1.7000, 0.0000], [0.0000, 1.7000, 0.0000, 0.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_zeros],
+    name="test_gridsample_zeros_padding",
+)
+
+# setting padding_mode = 'border'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    padding_mode="border",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_border = np.array(
+    [[[[0.0000, 0.0000, 1.7000, 5.0000], [5.0000, 1.7000, 5.0000, 5.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_border],
+    name="test_gridsample_border_padding",
+)
+
+# setting padding_mode = 'reflection'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    padding_mode="reflection",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_reflection = np.array(
+    [[[[2.5000, 0.0000, 1.7000, 2.5000], [2.5000, 1.7000, 5.0000, 2.5000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_reflection],
+    name="test_gridsample_reflection_padding",
+)
+```
+
+</details>
+
+
+<details>
+<summary>volumeetric_gridsample_mode_aligncorners</summary>
+
+```python
+X = np.array(
+    [
+        [
+            [
+                [[1.0, 2.0], [3.0, 4.0]],
+                [[5.0, 6.0], [7.0, 8.0]],
+                [[9.0, 10.0], [11.0, 12.0]],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+Grid = np.array(
+    [
+        [
+            [
+                [[-1.0, -1.0, -1.0], [-1.0, -0.5, 0.3]],
+                [[-0.5, -0.5, -0.5], [1.0, -0.6, -1.0]],
+                [[-0.2, -0.2, -0.2], [0.4, 0.2, 0.6]],
+                [[0.0, 0.0, 0.0], [-1.0, 0.0, 0.0]],
+            ],
+            [
+                [[0.0, 0.0, 0.0], [-1.0, 1.0, 0.0]],
+                [[-0.2, -0.2, -0.2], [1.0, 0.4, -0.2]],
+                [[0.5, 0.5, 0.5], [-1.0, -0.8, 0.8]],
+                [[1.0, 1.0, 1.0], [0.4, 0.6, -0.3]],
+            ],
+        ]
+    ],
+    dtype=np.float32,
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [
+        [
+            [
+                [[1.0, 5.0], [1.0, 0.0], [5.0, 12.0], [5.0, 5.0]],
+                [[5.0, 0.0], [5.0, 0.0], [12.0, 9.0], [0.0, 8.0]],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_nearest],
+    name="test_gridsample_volumetric_nearest_align_corners_0",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [
+        [
+            [
+                [[1.0, 5.0], [1.0, 2.0], [5.0, 12.0], [5.0, 5.0]],
+                [[5.0, 7.0], [5.0, 8.0], [12.0, 9.0], [12.0, 8.0]],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_nearest],
+    name="test_gridsample_volumetric_nearest_align_corners_1",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [
+        [
+            [
+                [
+                    [0.1250, 3.4000],
+                    [2.0000, 0.4500],
+                    [4.7000, 10.9000],
+                    [6.5000, 3.0000],
+                ],
+                [
+                    [6.5000, 1.7500],
+                    [4.7000, 3.3000],
+                    [11.0000, 2.5200],
+                    [1.5000, 5.4900],
+                ],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_volumetric_bilinear_align_corners_0",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [
+        [
+            [
+                [
+                    [1.0000, 6.7000],
+                    [3.7500, 2.4000],
+                    [5.4000, 9.3000],
+                    [6.5000, 6.0000],
+                ],
+                [
+                    [6.5000, 7.0000],
+                    [5.4000, 6.6000],
+                    [9.2500, 8.4000],
+                    [12.0000, 6.1000],
+                ],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_volumetric_bilinear_align_corners_1",
+)
+```
+
+</details>
+
+
+### <a name="GroupNormalization"></a><a name="groupnormalization">**GroupNormalization**</a>
+
+  A GroupNormalization function. Carries out group normalization as described in
+  the paper https://arxiv.org/abs/1803.08494
+
+  This operator transforms input according to
+  ```
+  y = scale * (x - mean) / sqrt(variance + epsilon) + bias,
+  ```
+  where the mean and variance are computed per instance per group of channels, and
+  `scale` and `bias` should be specified for each channel. The number of
+  groups `num_groups` should be divisible by the number of channels so that there are
+  an equal number of channels per group.
+
+  The overall computation has two stages: the first stage normalizes the elements to
+  have zero mean and unit variance for each instance in each group, and the second
+  stage scales and shifts the results of the first stage. The floating-point precision
+  used in the first stage is determined by the `stash_type` attribute. For example,
+  if `stash_type` is 1, the operator casts all input variables to 32-bit float,
+  performs the computation, and finally casts the normalized results back to the
+  original type of `X`. The second stage does not depend on `stash_type`.
+
+  When the number of groups is the same as the number of channels, this operator is
+  equivalent to InstanceNormalization. When there is only one group, this operator
+  is equivalent to LayerNormalization.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#GroupNormalization-18">18</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>num_groups</tt> : int (required)</dt>
+<dd>The number of groups of channels. It should be a divisor of the number of channels `C`.</dd>
+<dt><tt>stash_type</tt> : int (default is 1)</dt>
+<dd>The floating-point precision used in stage one of the computation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor. Dimensions for image cases are `(N x C x H x W)`, where `N` is the batch size, `C` is the number of channels, and `H` and `W` are the height and width of the data. Statistics are computed for every group of channels over `C`, `H`, and `W`. For non-image cases, the dimensions are in the form of `(N x C x D1 x D2 ... Dn)`.</dd>
+<dt><tt>scale</tt> (differentiable) : T</dt>
+<dd>Scale tensor of shape `(C)`.</dd>
+<dt><tt>bias</tt> (differentiable) : T</dt>
+<dd>Bias tensor of shape `(C)`.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>The output tensor of the same shape as `X`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>epsilon</summary>
+
+```python
+c = 4
+num_groups = 2
+x = np.random.randn(3, c, 2, 2).astype(np.float32)
+scale = np.random.randn(c).astype(np.float32)
+bias = np.random.randn(c).astype(np.float32)
+epsilon = 1e-2
+y = _group_normalization(x, num_groups, scale, bias, epsilon).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "GroupNormalization",
+    inputs=["x", "scale", "bias"],
+    outputs=["y"],
+    epsilon=epsilon,
+    num_groups=num_groups,
+)
+
+expect(
+    node,
+    inputs=[x, scale, bias],
+    outputs=[y],
+    name="test_group_normalization_epsilon",
+)
+```
+
+</details>
+
+
+<details>
+<summary>groupnormalization</summary>
+
+```python
+c = 4
+num_groups = 2
+x = np.random.randn(3, c, 2, 2).astype(np.float32)
+scale = np.random.randn(c).astype(np.float32)
+bias = np.random.randn(c).astype(np.float32)
+y = _group_normalization(x, num_groups, scale, bias).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "GroupNormalization",
+    inputs=["x", "scale", "bias"],
+    outputs=["y"],
+    num_groups=num_groups,
+)
+
+expect(
+    node,
+    inputs=[x, scale, bias],
+    outputs=[y],
+    name="test_group_normalization_example",
+)
+```
+
+</details>
+
+
+### <a name="HammingWindow"></a><a name="hammingwindow">**HammingWindow**</a>
+
+  Generates a Hamming window as described in the paper https://ieeexplore.ieee.org/document/1455106.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>output_datatype</tt> : int (default is 1)</dt>
+<dd>The data type of the output tensor. Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T2. The default value is 1 = FLOAT. </dd>
+<dt><tt>periodic</tt> : int (default is 1)</dt>
+<dd>If 1, returns a window to be used as periodic function. If 0, return a symmetric window. When 'periodic' is specified, hann computes a window of length size + 1 and returns the first size points. The default value is 1. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>A scalar value indicating the length of the window.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T2</dt>
+<dd>A Hamming window with length: size. The output has the shape: [size].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain the input size to int32_t or int64_t.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>hammingwindow</summary>
+
+```python
+# Test periodic window
+node = onnx.helper.make_node(
+    "HammingWindow",
+    inputs=["x"],
+    outputs=["y"],
+)
+size = np.int32(10)
+a0 = 25 / 46
+a1 = 1 - a0
+y = a0 - a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_hammingwindow",
+)
+
+# Test symmetric window
+node = onnx.helper.make_node(
+    "HammingWindow", inputs=["x"], outputs=["y"], periodic=0
+)
+size = np.int32(10)
+a0 = 25 / 46
+a1 = 1 - a0
+y = a0 - a1 * np.cos(
+    2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_hammingwindow_symmetric",
+)
+```
+
+</details>
+
+
+### <a name="HannWindow"></a><a name="hannwindow">**HannWindow**</a>
+
+  Generates a Hann window as described in the paper https://ieeexplore.ieee.org/document/1455106.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>output_datatype</tt> : int (default is 1)</dt>
+<dd>The data type of the output tensor. Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T2. The default value is 1 = FLOAT. </dd>
+<dt><tt>periodic</tt> : int (default is 1)</dt>
+<dd>If 1, returns a window to be used as periodic function. If 0, return a symmetric window. When 'periodic' is specified, hann computes a window of length size + 1 and returns the first size points. The default value is 1. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>A scalar value indicating the length of the window.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T2</dt>
+<dd>A Hann window with length: size. The output has the shape: [size].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain the input size to int32_t or int64_t.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>hannwindow</summary>
+
+```python
+# Test periodic window
+node = onnx.helper.make_node(
+    "HannWindow",
+    inputs=["x"],
+    outputs=["y"],
+)
+size = np.int32(10)
+a0 = 0.5
+a1 = 0.5
+y = a0 - a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+expect(
+    node, inputs=[size], outputs=[y.astype(np.float32)], name="test_hannwindow"
+)
+
+# Test symmetric window
+node = onnx.helper.make_node(
+    "HannWindow", inputs=["x"], outputs=["y"], periodic=0
+)
+size = np.int32(10)
+a0 = 0.5
+a1 = 0.5
+y = a0 - a1 * np.cos(
+    2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_hannwindow_symmetric",
+)
+```
+
+</details>
+
+
+### <a name="HardSigmoid"></a><a name="hardsigmoid">**HardSigmoid**</a>
+
+  HardSigmoid takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the HardSigmoid function, y = max(0, min(1, alpha * x + beta)),
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#HardSigmoid-1">1</a>, <a href="Changelog.md#HardSigmoid-6">6</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.2)</dt>
+<dd>Value of alpha.</dd>
+<dt><tt>beta</tt> : float (default is 0.5)</dt>
+<dd>Value of beta.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>hardsigmoid</summary>
+
+```python
+node = onnx.helper.make_node(
+    "HardSigmoid", inputs=["x"], outputs=["y"], alpha=0.5, beta=0.6
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.clip(x * 0.5 + 0.6, 0, 1)  # expected output [0.1, 0.6, 1.]
+expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x * 0.5 + 0.6, 0, 1)
+expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid")
+```
+
+</details>
+
+
+<details>
+<summary>hardsigmoid_default</summary>
+
+```python
+default_alpha = 0.2
+default_beta = 0.5
+node = onnx.helper.make_node(
+    "HardSigmoid",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x * default_alpha + default_beta, 0, 1)
+expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_default")
+```
+
+</details>
+
+
+### <a name="HardSwish"></a><a name="hardswish">**HardSwish**</a>
+
+  HardSwish takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where
+  the HardSwish function, y = x * max(0, min(1, alpha * x + beta)) = x * HardSigmoid<alpha, beta>(x),
+  where alpha = 1/6 and beta = 0.5, is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#HardSwish-14">14</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>hardswish</summary>
+
+```python
+node = onnx.helper.make_node(
+    "HardSwish",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = hardswish(x)
+
+expect(node, inputs=[x], outputs=[y], name="test_hardswish")
+```
+
+</details>
+
+
+### <a name="Hardmax"></a><a name="hardmax">**Hardmax**</a>
+
+  The operator computes the hardmax values for the given input:
+
+   Hardmax(element in input, axis) = 1 if the element is the first maximum value along the specified axis, 0 otherwise
+
+  The "axis" attribute indicates the dimension along which Hardmax
+  will be performed. The output tensor has the same shape
+  and contains the Hardmax values of the corresponding input.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Hardmax-1">1</a>, <a href="Changelog.md#Hardmax-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>
+Describes the dimension Hardmax will be performed on.
+Negative value means counting dimensions
+from the back. Accepted range is [-r, r-1] where r = rank(input).
+</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The input tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output values with the same shape as the input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>hardmax</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([[3, 0, 1, 2], [2, 5, 1, 0], [0, 1, 3, 2], [0, 1, 2, 3]]).astype(
+    np.float32
+)
+# expect result:
+# [[1. 0. 0. 0.]
+# [0. 1. 0. 0.]
+# [0. 0. 1. 0.]
+# [0. 0. 0. 1.]]
+y = hardmax(x)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_example")
+
+# For multiple occurrences of the maximal values, the first occurrence is selected for one-hot output
+x = np.array([[3, 3, 3, 1]]).astype(np.float32)
+# expect result:
+# [[1, 0, 0, 0]]
+y = hardmax(x)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_one_hot")
+```
+
+</details>
+
+
+<details>
+<summary>hardmax_axis</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=0,
+)
+y = hardmax(x, axis=0)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_0")
+
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=1,
+)
+y = hardmax(x, axis=1)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_1")
+
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=2,
+)
+y = hardmax(x, axis=2)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_2")
+
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=-1,
+)
+y = hardmax(x, axis=-1)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_negative_axis")
+
+# default axis is -1
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_default_axis")
+```
+
+</details>
+
+
+### <a name="Identity"></a><a name="identity">**Identity**</a>
+
+  Identity operator
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Identity-1">1</a>, <a href="Changelog.md#Identity-13">13</a>, <a href="Changelog.md#Identity-14">14</a>, <a href="Changelog.md#Identity-16">16</a>, <a href="Changelog.md#Identity-19">19</a>, <a href="Changelog.md#Identity-21">21</a>, <a href="Changelog.md#Identity-23">23</a>, <a href="Changelog.md#Identity-24">24</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : V</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : V</dt>
+<dd>Tensor to copy input into.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain input and output types to all tensor, sequence, and optional types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>identity</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Identity",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(node, inputs=[data], outputs=[data], name="test_identity")
+```
+
+</details>
+
+
+<details>
+<summary>identity_opt</summary>
+
+```python
+ten_in_tp = onnx.helper.make_tensor_type_proto(
+    onnx.TensorProto.FLOAT, shape=[5]
+)
+seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp)
+opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp)
+
+identity_node = onnx.helper.make_node(
+    "Identity", inputs=["opt_in"], outputs=["opt_out"]
+)
+
+x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)]
+
+expect(
+    identity_node,
+    inputs=[x],
+    outputs=[x],
+    name="test_identity_opt",
+    opset_imports=[onnx.helper.make_opsetid("", 16)],
+    input_type_protos=[opt_in_tp],
+    output_type_protos=[opt_in_tp],
+)
+```
+
+</details>
+
+
+<details>
+<summary>sequence</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Identity",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+data = [
+    np.array(
+        [
+            [
+                [
+                    [1, 2],
+                    [3, 4],
+                ]
+            ]
+        ],
+        dtype=np.float32,
+    ),
+    np.array(
+        [
+            [
+                [
+                    [2, 3],
+                    [1, 5],
+                ]
+            ]
+        ],
+        dtype=np.float32,
+    ),
+]
+
+expect(node, inputs=[data], outputs=[data], name="test_identity_sequence")
+```
+
+</details>
+
+
+### <a name="If"></a><a name="if">**If**</a>
+
+  If conditional
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#If-1">1</a>, <a href="Changelog.md#If-11">11</a>, <a href="Changelog.md#If-13">13</a>, <a href="Changelog.md#If-16">16</a>, <a href="Changelog.md#If-19">19</a>, <a href="Changelog.md#If-21">21</a>, <a href="Changelog.md#If-23">23</a>, <a href="Changelog.md#If-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>else_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is false. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the then_branch.</dd>
+<dt><tt>then_branch</tt> : graph (required)</dt>
+<dd>Graph to run if condition is true. Has N outputs: values you wish to be live-out to the enclosing scope. The number of outputs must match the number of outputs in the else_branch.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>cond</tt> : B</dt>
+<dd>Condition for the if. The tensor must contain a single element.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Values that are live-out to the enclosing scope. The return values in the `then_branch` and `else_branch` must be of the same data type. The `then_branch` and `else_branch` may produce tensors with the same element type and different shapes. If corresponding outputs from the then-branch and the else-branch have static shapes S1 and S2, then the shape of the corresponding output variable of the if-node (if present) must be compatible with both S1 and S2 as it represents the union of both possible shapes.For example, if in a model file, the first output of `then_branch` is typed float tensor with shape [2] and the first output of `else_branch` is another float tensor with shape [3], If's first output should have (a) no shape set, or (b) a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) a shape of rank 1 with a unique `dim_param`. In contrast, the first output cannot have the shape [2] since [2] and [3] are not compatible.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), seq(tensor(float4e2m1)), seq(tensor(float8e8m0)), seq(tensor(uint2)), seq(tensor(int2)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4)), optional(tensor(float4e2m1)), optional(tensor(float8e8m0)), optional(tensor(uint2)), optional(tensor(int2))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv13.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Only bool</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>if</summary>
+
+```python
+# Given a bool scalar input cond.
+# return constant tensor x if cond is True, otherwise return constant tensor y.
+
+then_out = onnx.helper.make_tensor_value_info(
+    "then_out", onnx.TensorProto.FLOAT, [5]
+)
+else_out = onnx.helper.make_tensor_value_info(
+    "else_out", onnx.TensorProto.FLOAT, [5]
+)
+
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+y = np.array([5, 4, 3, 2, 1]).astype(np.float32)
+
+then_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["then_out"],
+    value=onnx.numpy_helper.from_array(x),
+)
+
+else_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["else_out"],
+    value=onnx.numpy_helper.from_array(y),
+)
+
+then_body = onnx.helper.make_graph(
+    [then_const_node], "then_body", [], [then_out]
+)
+
+else_body = onnx.helper.make_graph(
+    [else_const_node], "else_body", [], [else_out]
+)
+
+if_node = onnx.helper.make_node(
+    "If",
+    inputs=["cond"],
+    outputs=["res"],
+    then_branch=then_body,
+    else_branch=else_body,
+)
+
+cond = np.array(1).astype(bool)
+res = x if cond else y
+expect(
+    if_node,
+    inputs=[cond],
+    outputs=[res],
+    name="test_if",
+    opset_imports=[onnx.helper.make_opsetid("", 11)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>if_optional</summary>
+
+```python
+# Given a bool scalar input cond, return an empty optional sequence of
+# tensor if True, return an optional sequence with value x
+# (the input optional sequence) otherwise.
+
+ten_in_tp = onnx.helper.make_tensor_type_proto(
+    onnx.TensorProto.FLOAT, shape=[5]
+)
+seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp)
+
+then_out_tensor_tp = onnx.helper.make_tensor_type_proto(
+    onnx.TensorProto.FLOAT, shape=[5]
+)
+then_out_seq_tp = onnx.helper.make_sequence_type_proto(then_out_tensor_tp)
+then_out_opt_tp = onnx.helper.make_optional_type_proto(then_out_seq_tp)
+then_out = onnx.helper.make_value_info("optional_empty", then_out_opt_tp)
+
+else_out_tensor_tp = onnx.helper.make_tensor_type_proto(
+    onnx.TensorProto.FLOAT, shape=[5]
+)
+else_out_seq_tp = onnx.helper.make_sequence_type_proto(else_out_tensor_tp)
+else_out_opt_tp = onnx.helper.make_optional_type_proto(else_out_seq_tp)
+else_out = onnx.helper.make_value_info("else_opt", else_out_opt_tp)
+
+x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)]
+cond = np.array(0).astype(bool)
+res = compute_if_outputs(x, cond)
+
+opt_empty_in = onnx.helper.make_node(
+    "Optional", inputs=[], outputs=["optional_empty"], type=seq_in_tp
+)
+
+then_body = onnx.helper.make_graph([opt_empty_in], "then_body", [], [then_out])
+
+else_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.numpy_helper.from_array(x[0]),
+)
+
+else_seq_node = onnx.helper.make_node(
+    "SequenceConstruct", inputs=["x"], outputs=["else_seq"]
+)
+
+else_optional_seq_node = onnx.helper.make_node(
+    "Optional", inputs=["else_seq"], outputs=["else_opt"]
+)
+
+else_body = onnx.helper.make_graph(
+    [else_const_node, else_seq_node, else_optional_seq_node],
+    "else_body",
+    [],
+    [else_out],
+)
+
+if_node = onnx.helper.make_node(
+    "If",
+    inputs=["cond"],
+    outputs=["sequence"],
+    then_branch=then_body,
+    else_branch=else_body,
+)
+
+expect(
+    if_node,
+    inputs=[cond],
+    outputs=[res],
+    name="test_if_opt",
+    output_type_protos=[else_out_opt_tp],
+    opset_imports=[onnx.helper.make_opsetid("", 16)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>if_seq</summary>
+
+```python
+# Given a bool scalar input cond.
+# return constant sequence x if cond is True, otherwise return constant sequence y.
+
+then_out = onnx.helper.make_tensor_sequence_value_info(
+    "then_out", onnx.TensorProto.FLOAT, shape=[5]
+)
+else_out = onnx.helper.make_tensor_sequence_value_info(
+    "else_out", onnx.TensorProto.FLOAT, shape=[5]
+)
+
+x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)]
+y = [np.array([5, 4, 3, 2, 1]).astype(np.float32)]
+
+then_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.numpy_helper.from_array(x[0]),
+)
+
+then_seq_node = onnx.helper.make_node(
+    "SequenceConstruct", inputs=["x"], outputs=["then_out"]
+)
+
+else_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["y"],
+    value=onnx.numpy_helper.from_array(y[0]),
+)
+
+else_seq_node = onnx.helper.make_node(
+    "SequenceConstruct", inputs=["y"], outputs=["else_out"]
+)
+
+then_body = onnx.helper.make_graph(
+    [then_const_node, then_seq_node], "then_body", [], [then_out]
+)
+
+else_body = onnx.helper.make_graph(
+    [else_const_node, else_seq_node], "else_body", [], [else_out]
+)
+
+if_node = onnx.helper.make_node(
+    "If",
+    inputs=["cond"],
+    outputs=["res"],
+    then_branch=then_body,
+    else_branch=else_body,
+)
+
+cond = np.array(1).astype(bool)
+res = x if cond else y
+expect(
+    if_node,
+    inputs=[cond],
+    outputs=[res],
+    name="test_if_seq",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+
+
+### <a name="ImageDecoder"></a><a name="imagedecoder">**ImageDecoder**</a>
+
+  Loads and decodes and image from a file. If it can't decode for any reason (e.g. corrupted encoded
+  stream, invalid format, it will return an empty matrix).
+  The following image formats are supported:
+  * BMP
+  * JPEG (note: Lossless JPEG support is optional)
+  * JPEG2000
+  * TIFF
+  * PNG
+  * WebP
+  * Portable image format (PBM, PGM, PPM, PXM, PNM)
+  Decoded images follow a channel-last layout: (Height, Width, Channels).
+  **JPEG chroma upsampling method:**
+  When upsampling the chroma components by a factor of 2, the pixels are linearly interpolated so that the
+  centers of the output pixels are 1/4 and 3/4 of the way between input pixel centers.
+  When rounding, 0.5 is rounded down and up at alternative pixels locations to prevent bias towards
+  larger values (ordered dither pattern).
+  Considering adjacent input pixels A, B, and C, B is upsampled to pixels B0 and B1 so that
+  ```
+  B0 = round_half_down((1/4) * A + (3/4) * B)
+  B1 = round_half_up((3/4) * B + (1/4) * C)
+  ```
+  This method,  is the default chroma upsampling method in the well-established libjpeg-turbo library,
+  also referred as "smooth" or "fancy" upsampling.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>pixel_format</tt> : string (default is RGB)</dt>
+<dd>Pixel format. Can be one of "RGB", "BGR", or "Grayscale".</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>encoded_stream</tt> (non-differentiable) : T1</dt>
+<dd>Encoded stream</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>image</tt> (non-differentiable) : T2</dt>
+<dd>Decoded image</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8)</dt>
+<dd>Constrain input types to 8-bit unsigned integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(uint8)</dt>
+<dd>Constrain output types to 8-bit unsigned integer tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>image_decoder_decode_bmp_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "bmp", _image_decoder_data.image_decoder_decode_bmp_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_bmp_rgb",
+)
+```
+
+</details>
+
+
+<details>
+<summary>image_decoder_decode_jpeg2k_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "jpeg2000", _image_decoder_data.image_decoder_decode_jpeg2k_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_jpeg2k_rgb",
+)
+```
+
+</details>
+
+
+<details>
+<summary>image_decoder_decode_jpeg_bgr</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="BGR",
+)
+
+data, output = _generate_test_data(
+    "jpeg", _image_decoder_data.image_decoder_decode_jpeg_bgr, "BGR"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_jpeg_bgr",
+)
+```
+
+</details>
+
+
+<details>
+<summary>image_decoder_decode_jpeg_grayscale</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="Grayscale",
+)
+
+data, output = _generate_test_data(
+    "jpeg", _image_decoder_data.image_decoder_decode_jpeg_grayscale, "Grayscale"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_jpeg_grayscale",
+)
+```
+
+</details>
+
+
+<details>
+<summary>image_decoder_decode_jpeg_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "jpeg", _image_decoder_data.image_decoder_decode_jpeg_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_jpeg_rgb",
+)
+```
+
+</details>
+
+
+<details>
+<summary>image_decoder_decode_png_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "png", _image_decoder_data.image_decoder_decode_png_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_png_rgb",
+)
+```
+
+</details>
+
+
+<details>
+<summary>image_decoder_decode_pnm_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "ppm", _image_decoder_data.image_decoder_decode_pnm_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_pnm_rgb",
+)
+```
+
+</details>
+
+
+<details>
+<summary>image_decoder_decode_tiff_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "tiff", _image_decoder_data.image_decoder_decode_tiff_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_tiff_rgb",
+)
+```
+
+</details>
+
+
+<details>
+<summary>image_decoder_decode_webp_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "webp", _image_decoder_data.image_decoder_decode_webp_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_webp_rgb",
+)
+```
+
+</details>
+
+
+### <a name="InstanceNormalization"></a><a name="instancenormalization">**InstanceNormalization**</a>
+
+  Carries out instance normalization as described in the paper
+  https://arxiv.org/abs/1607.08022.
+
+  y = scale * (x - mean) / sqrt(variance + epsilon) + B,
+  where mean and variance are computed per instance per channel.
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#InstanceNormalization-1">1</a>, <a href="Changelog.md#InstanceNormalization-6">6</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+<dt><tt>scale</tt> (differentiable) : T</dt>
+<dd>The input 1-dimensional scale tensor of size C.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>The input 1-dimensional bias tensor of size C.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output tensor of the same shape as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>instancenormalization</summary>
+
+```python
+def _instancenorm_test_mode(
+    x: np.ndarray, s: np.ndarray, bias: np.ndarray, epsilon: float = 1e-5
+) -> np.ndarray:
+    dims_x = len(x.shape)
+    axis = tuple(range(2, dims_x))
+    mean = np.mean(x, axis=axis, keepdims=True)
+    var = np.var(x, axis=axis, keepdims=True)
+    dim_ones = (1,) * (dims_x - 2)
+    s = s.reshape(-1, *dim_ones)
+    bias = bias.reshape(-1, *dim_ones)
+    return s * (x - mean) / np.sqrt(var + epsilon) + bias
+
+# input size: (1, 2, 1, 3)
+x = np.array([[[[-1, 0, 1]], [[2, 3, 4]]]]).astype(np.float32)
+s = np.array([1.0, 1.5]).astype(np.float32)
+bias = np.array([0, 1]).astype(np.float32)
+y = _instancenorm_test_mode(x, s, bias).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "InstanceNormalization",
+    inputs=["x", "s", "bias"],
+    outputs=["y"],
+)
+
+# output size: (1, 2, 1, 3)
+expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_example")
+
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+epsilon = 1e-2
+y = _instancenorm_test_mode(x, s, bias, epsilon).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "InstanceNormalization",
+    inputs=["x", "s", "bias"],
+    outputs=["y"],
+    epsilon=epsilon,
+)
+
+# output size: (2, 3, 4, 5)
+expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_epsilon")
+```
+
+</details>
+
+
+### <a name="IsInf"></a><a name="isinf">**IsInf**</a>
+
+  Map infinity to true and other values to false.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#IsInf-10">10</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>detect_negative</tt> : int (default is 1)</dt>
+<dd>(Optional) Whether map negative infinity to true. Default to 1 so that negative infinity induces true. Set this attribute to 0 if negative infinity should be mapped to false.</dd>
+<dt><tt>detect_positive</tt> : int (default is 1)</dt>
+<dd>(Optional) Whether map positive infinity to true. Default to 1 so that positive infinity induces true. Set this attribute to 0 if positive infinity should be mapped to false.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output types to boolean tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>infinity</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsInf",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32)
+y = np.isinf(x)
+expect(node, inputs=[x], outputs=[y], name="test_isinf")
+```
+
+</details>
+
+
+<details>
+<summary>infinity_float16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsInf",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16)
+y = np.isinf(x)
+expect(node, inputs=[x], outputs=[y], name="test_isinf_float16")
+```
+
+</details>
+
+
+<details>
+<summary>negative_infinity_only</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsInf", inputs=["x"], outputs=["y"], detect_positive=0
+)
+
+x = np.array([-1.7, np.nan, np.inf, -3.6, -np.inf, np.inf], dtype=np.float32)
+y = np.isneginf(x)
+expect(node, inputs=[x], outputs=[y], name="test_isinf_negative")
+```
+
+</details>
+
+
+<details>
+<summary>positive_infinity_only</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsInf", inputs=["x"], outputs=["y"], detect_negative=0
+)
+
+x = np.array([-1.7, np.nan, np.inf, 3.6, -np.inf, np.inf], dtype=np.float32)
+y = np.isposinf(x)
+expect(node, inputs=[x], outputs=[y], name="test_isinf_positive")
+```
+
+</details>
+
+
+### <a name="IsNaN"></a><a name="isnan">**IsNaN**</a>
+
+  Returns which elements of the input are NaN.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#IsNaN-9">9</a>, <a href="Changelog.md#IsNaN-13">13</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Constrain output types to boolean tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>float16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsNaN",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16)
+y = np.isnan(x)
+expect(node, inputs=[x], outputs=[y], name="test_isnan_float16")
+```
+
+</details>
+
+
+<details>
+<summary>isnan</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsNaN",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32)
+y = np.isnan(x)
+expect(node, inputs=[x], outputs=[y], name="test_isnan")
+```
+
+</details>
+
+
+### <a name="LRN"></a><a name="lrn">**LRN**</a>
+
+  Local Response Normalization proposed in the [AlexNet paper](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf).
+  It normalizes over local input regions.
+  The local region is defined across the channels. For an element `X[n, c, d1, ..., dk]` in a tensor
+  of shape `(N x C x D1 x D2, ..., Dk)`, its region is
+  `{X[n, i, d1, ..., dk] | max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))}`.
+
+  `square_sum[n, c, d1, ..., dk] = sum(X[n, i, d1, ..., dk] ^ 2)`,
+  where `max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))`.
+
+  `Y[n, c, d1, ..., dk] = X[n, c, d1, ..., dk] / (bias + alpha / size * square_sum[n, c, d1, ..., dk] ) ^ beta`
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#LRN-1">1</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.0001)</dt>
+<dd>Scaling parameter.</dd>
+<dt><tt>beta</tt> : float (default is 0.75)</dt>
+<dd>The exponent.</dd>
+<dt><tt>bias</tt> : float (default is 1.0)</dt>
+<dd></dd>
+<dt><tt>size</tt> : int (required)</dt>
+<dd>The number of channels to sum over</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor, which has the shape and type as input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output  types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default</summary>
+
+```python
+alpha = 0.0001
+beta = 0.75
+bias = 1.0
+nsize = 3
+node = onnx.helper.make_node("LRN", inputs=["x"], outputs=["y"], size=3)
+x = np.random.randn(5, 5, 5, 5).astype(np.float32)
+square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32)
+for n, c, h, w in np.ndindex(x.shape):
+    square_sum[n, c, h, w] = sum(
+        x[
+            n,
+            max(0, c - math.floor((nsize - 1) / 2)) : min(
+                5, c + math.ceil((nsize - 1) / 2) + 1
+            ),
+            h,
+            w,
+        ]
+        ** 2
+    )
+y = x / ((bias + (alpha / nsize) * square_sum) ** beta)
+expect(node, inputs=[x], outputs=[y], name="test_lrn_default")
+```
+
+</details>
+
+
+<details>
+<summary>lrn</summary>
+
+```python
+alpha = 0.0002
+beta = 0.5
+bias = 2.0
+nsize = 3
+node = onnx.helper.make_node(
+    "LRN",
+    inputs=["x"],
+    outputs=["y"],
+    alpha=alpha,
+    beta=beta,
+    bias=bias,
+    size=nsize,
+)
+x = np.random.randn(5, 5, 5, 5).astype(np.float32)
+square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32)
+for n, c, h, w in np.ndindex(x.shape):
+    square_sum[n, c, h, w] = sum(
+        x[
+            n,
+            max(0, c - math.floor((nsize - 1) / 2)) : min(
+                5, c + math.ceil((nsize - 1) / 2) + 1
+            ),
+            h,
+            w,
+        ]
+        ** 2
+    )
+y = x / ((bias + (alpha / nsize) * square_sum) ** beta)
+expect(node, inputs=[x], outputs=[y], name="test_lrn")
+```
+
+</details>
+
+
+### <a name="LSTM"></a><a name="lstm">**LSTM**</a>
+
+  Computes an one-layer LSTM. This operator is usually supported via some
+  custom implementation such as CuDNN.
+
+  Notations:
+
+  * `X` - input tensor
+  * `i` - input gate
+  * `o` - output gate
+  * `f` - forget gate
+  * `c` - cell gate
+  * `t` - time step (t-1 means previous time step)
+  * `W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
+  * `R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
+  * `Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
+  * `Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
+  * `P[iof]`  - P peephole weight vector for input, output, and forget gates
+  * `WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
+  * `RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
+  * `WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
+  * `RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
+  * `PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
+  * `H` - Hidden state
+  * `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+  * Relu(x)                - max(0, x)
+  * Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+  * Sigmoid(x)             - 1/(1 + e^{-x})
+
+  NOTE: Below are optional
+
+  * Affine(x)              - alpha*x + beta
+  * LeakyRelu(x)           - x if x >= 0 else alpha * x
+  * ThresholdedRelu(x)     - x if x >= alpha else 0
+  * ScaledTanh(x)          - alpha*Tanh(beta*x)
+  * HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+  * Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+  * Softsign(x)            - x/(1 + |x|)
+  * Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Sigmoid, g=Tanh, h=Tanh):
+
+  * it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi)
+  * ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf)
+  * ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc)
+  * Ct = ft (.) Ct-1 + it (.) ct
+  * ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.) Ct + Wbo + Rbo)
+  * Ht = ot (.) h(Ct)
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#LSTM-1">1</a>, <a href="Changelog.md#LSTM-7">7</a>, <a href="Changelog.md#LSTM-14">14</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings</dt>
+<dd>A list of 3 (or 6 if bidirectional) activation functions for input, output, forget, cell, and hidden. The activation functions must be one of the activation functions specified above. Optional: See the equations for default if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>input_forget</tt> : int (default is 0)</dt>
+<dd>Couple the input and forget gates if 1.</dd>
+<dt><tt>layout</tt> : int (default is 0)</dt>
+<dd>The shape format of inputs X, initial_h, initial_c and outputs Y, Y_h, Y_c. If 0, the following shapes are expected: X.shape = [seq_length, batch_size, input_size], Y.shape = [seq_length, num_directions, batch_size, hidden_size], initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = [num_directions, batch_size, hidden_size]. If 1, the following shapes are expected: X.shape = [batch_size, seq_length, input_size], Y.shape = [batch_size, seq_length, num_directions, hidden_size], initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = [batch_size, num_directions, hidden_size].</dd>
+</dl>
+
+#### Inputs (3 - 8)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor for the gates. Concatenation of `W[iofc]` and `WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape `[num_directions, 4*hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> (differentiable) : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `R[iofc]` and `RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 4*hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional, non-differentiable) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>initial_c</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the cell. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>P</tt> (optional, differentiable) : T</dt>
+<dd>The weight tensor for peepholes. Concatenation of `P[iof]` and `PB[iof]` (if bidirectional) along dimension 0. It has shape `[num_directions, 3*hidde_size]`. Optional: If not specified - assumed to be 0.</dd>
+</dl>
+
+#### Outputs (0 - 3)
+
+<dl>
+<dt><tt>Y</tt> (optional, differentiable) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+<dt><tt>Y_c</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the cell. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>batchwise</summary>
+
+```python
+input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 7
+weight_scale = 0.3
+number_of_gates = 4
+layout = 1
+
+node = onnx.helper.make_node(
+    "LSTM",
+    inputs=["X", "W", "R"],
+    outputs=["Y", "Y_h"],
+    hidden_size=hidden_size,
+    layout=layout,
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+lstm = LSTMHelper(X=input, W=W, R=R, layout=layout)
+Y, Y_h = lstm.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y.astype(np.float32), Y_h.astype(np.float32)],
+    name="test_lstm_batchwise",
+)
+```
+
+</details>
+
+
+<details>
+<summary>defaults</summary>
+
+```python
+input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 3
+weight_scale = 0.1
+number_of_gates = 4
+
+node = onnx.helper.make_node(
+    "LSTM", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+lstm = LSTMHelper(X=input, W=W, R=R)
+_, Y_h = lstm.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_lstm_defaults",
+)
+```
+
+</details>
+
+
+<details>
+<summary>initial_bias</summary>
+
+```python
+input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype(
+    np.float32
+)
+
+input_size = 3
+hidden_size = 4
+weight_scale = 0.1
+custom_bias = 0.1
+number_of_gates = 4
+
+node = onnx.helper.make_node(
+    "LSTM",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+# Adding custom bias
+W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype(
+    np.float32
+)
+R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32)
+B = np.concatenate((W_B, R_B), 1)
+
+lstm = LSTMHelper(X=input, W=W, R=R, B=B)
+_, Y_h = lstm.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_lstm_with_initial_bias",
+)
+```
+
+</details>
+
+
+<details>
+<summary>peepholes</summary>
+
+```python
+input = np.array([[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]]]).astype(
+    np.float32
+)
+
+input_size = 4
+hidden_size = 3
+weight_scale = 0.1
+number_of_gates = 4
+number_of_peepholes = 3
+
+node = onnx.helper.make_node(
+    "LSTM",
+    inputs=["X", "W", "R", "B", "sequence_lens", "initial_h", "initial_c", "P"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+# Initializing Inputs
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+B = np.zeros((1, 2 * number_of_gates * hidden_size)).astype(np.float32)
+seq_lens = np.repeat(input.shape[0], input.shape[1]).astype(np.int32)
+init_h = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32)
+init_c = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32)
+P = weight_scale * np.ones((1, number_of_peepholes * hidden_size)).astype(
+    np.float32
+)
+
+lstm = LSTMHelper(
+    X=input, W=W, R=R, B=B, P=P, initial_c=init_c, initial_h=init_h
+)
+_, Y_h = lstm.step()
+expect(
+    node,
+    inputs=[input, W, R, B, seq_lens, init_h, init_c, P],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_lstm_with_peepholes",
+)
+```
+
+</details>
+
+
+### <a name="LayerNormalization"></a><a name="layernormalization">**LayerNormalization**</a>
+
+  This is layer normalization defined in ONNX as function.
+        The overall computation can be split into two stages.
+        The first stage is standardization, which makes the
+        normalized elements have zero mean and unit variances.
+        The computation required by standardization can be
+        described by the following equations.
+        ```
+        Mean = ReduceMean<axes=normalized_axes>(X)
+        D = Sub(X, Mean)
+        DD = Mul(D, D)
+        Var = ReduceMean<axes=normalized_axes>(DD)
+        VarEps = Add(Var, epsilon)
+        StdDev = Sqrt(VarEps)
+        InvStdDev = Reciprocal(StdDev)
+        Normalized = Mul(D, InvStdDev)
+        ```
+        where `normalized_axes` is `[axis, ..., rank of X - 1]`.
+        The variables `Var` and `StdDev` stand for variance and
+        standard deviation, respectively. The second output is
+        `Mean` and the last one is `InvStdDev`.
+        Depending on `stash_type` attribute, the actual computation
+        must happen in different floating-point precision.
+        For example, if `stash_type` is 1, this operator casts
+        all input variables to 32-bit float, perform the computation, and
+        finally cast `Normalized` back to the original type of `X`.
+        The second stage then scales and shifts the outcome of the
+        first stage using
+        ```
+        NormalizedScaled = Mul(Normalized, Scale)
+        Y = Add(NormalizedScaled, B)
+        ```
+        The second stage doesn't depends on `stash_type`.
+        All equations are in [this syntax](https://github.com/onnx/onnx/blob/main/docs/Syntax.md).
+        The same variable (i.e., input, output, and attribute) uses
+        the same name in the equations above and this operator's definition.
+        Let `d[i]` indicate the i-th dimension of `X`.
+        If `X`'s shape is `[d[0], ..., d[axis-1], d[axis], ..., d[rank-1]]`,
+        the shape of `Mean` and `InvStdDev` is `[d[0], ..., d[axis-1], 1, ..., 1]`.
+        `Y` and `X` have the same shape. This operator supports unidirectional broadcasting
+        (tensors `Scale` and `B` should be unidirectional broadcastable to tensor `X`);
+        for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>The first normalization dimension. If rank(X) is r, axis' allowed range is [-r, r). Negative value means counting dimensions from the back.</dd>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>stash_type</tt> : int (default is 1)</dt>
+<dd>Type of Mean and InvStdDev. This also specifies stage one's computation precision.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>Tensor to be normalized.</dd>
+<dt><tt>Scale</tt> : T</dt>
+<dd>Scale tensor.</dd>
+<dt><tt>B</tt> (optional) : T</dt>
+<dd>Bias tensor.</dd>
+</dl>
+
+#### Outputs (1 - 3)
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Normalized tensor.</dd>
+<dt><tt>Mean</tt> (optional) : U</dt>
+<dd>Saved mean used during training to speed up gradient computation</dd>
+<dt><tt>InvStdDev</tt> (optional) : U</dt>
+<dd>Saved inverse standard deviation used during training to speed up gradient computation.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types and output Y type to float tensors.</dd>
+<dt><tt>U</tt> : tensor(float), tensor(bfloat16)</dt>
+<dd>Type of Mean and InvStdDev tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>d</summary>
+
+```python
+X = np.random.randn(3, 4).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    B = np.random.randn(*normalized_shape).astype(np.float32)
+    Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis=axis)
+
+    node = onnx.helper.make_node(
+        "LayerNormalization",
+        inputs=["X", "W", "B"],
+        outputs=["Y", "Mean", "InvStdDev"],
+        axis=axis,
+    )
+
+    if axis < 0:
+        name = f"test_layer_normalization_2d_axis_negative_{-axis}"
+    else:
+        name = f"test_layer_normalization_2d_axis{axis}"
+
+    expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+
+
+<details>
+<summary>d_epsilon</summary>
+
+```python
+epsilon = 1e-1
+X = np.random.randn(2, 3, 5).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    B = np.random.randn(*normalized_shape).astype(np.float32)
+    Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis, epsilon)
+    node = onnx.helper.make_node(
+        "LayerNormalization",
+        inputs=["X", "W", "B"],
+        outputs=["Y", "Mean", "InvStdDev"],
+        axis=axis,
+        epsilon=epsilon,
+    )
+
+    if axis < 0:
+        name = f"test_layer_normalization_3d_axis_negative_{-axis}_epsilon"
+    else:
+        name = f"test_layer_normalization_3d_axis{axis}_epsilon"
+
+    expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+
+
+<details>
+<summary>default_axis</summary>
+
+```python
+X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+# Default axis in LayerNormalization is -1.
+normalized_shape = calculate_normalized_shape(X.shape, -1)
+W = np.random.randn(*normalized_shape).astype(np.float32)
+B = np.random.randn(*normalized_shape).astype(np.float32)
+# Axis is default to -1 in the reference implementation.
+Y, mean, inv_std_dev = _layer_normalization(X, W, B)
+
+# Not specifying axis attribute means -1.
+node = onnx.helper.make_node(
+    "LayerNormalization",
+    inputs=["X", "W", "B"],
+    outputs=["Y", "Mean", "InvStdDev"],
+)
+
+expect(
+    node,
+    inputs=[X, W, B],
+    outputs=[Y, mean, inv_std_dev],
+    name="test_layer_normalization_default_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>layernormalization</summary>
+
+```python
+X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    B = np.random.randn(*normalized_shape).astype(np.float32)
+    Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis)
+
+    node = onnx.helper.make_node(
+        "LayerNormalization",
+        inputs=["X", "W", "B"],
+        outputs=["Y", "Mean", "InvStdDev"],
+        axis=axis,
+    )
+
+    if axis < 0:
+        name = f"test_layer_normalization_4d_axis_negative_{-axis}"
+    else:
+        name = f"test_layer_normalization_4d_axis{axis}"
+
+    expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+
+
+### <a name="LeakyRelu"></a><a name="leakyrelu">**LeakyRelu**</a>
+
+  LeakyRelu takes input data (Tensor<T>) and an argument alpha, and produces one
+  output data (Tensor<T>) where the function `f(x) = alpha * x for x < 0`,
+  `f(x) = x for x >= 0`, is applied to the data tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#LeakyRelu-1">1</a>, <a href="Changelog.md#LeakyRelu-6">6</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.01)</dt>
+<dd>Coefficient of leakage.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>leakyrelu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LeakyRelu", inputs=["x"], outputs=["y"], alpha=0.1
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-0.1, 0., 1.]
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1
+expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1
+expect(node, inputs=[x], outputs=[y], name="test_leakyrelu")
+```
+
+</details>
+
+
+<details>
+<summary>leakyrelu_default</summary>
+
+```python
+default_alpha = 0.01
+node = onnx.helper.make_node(
+    "LeakyRelu",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * default_alpha
+expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_default")
+```
+
+</details>
+
+
+### <a name="Less"></a><a name="less">**Less**</a>
+
+  Returns the tensor resulted from performing the `less` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Less-1">1</a>, <a href="Changelog.md#Less-7">7</a>, <a href="Changelog.md#Less-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>less</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Less",
+    inputs=["x", "y"],
+    outputs=["less"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less")
+
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.random.randn(3, 4, 5).astype(np.int8)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_int8")
+
+x = np.random.randn(3, 4, 5).astype(np.int16)
+y = np.random.randn(3, 4, 5).astype(np.int16)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>less</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LessOrEqual",
+    inputs=["x", "y"],
+    outputs=["less_equal"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal")
+
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.random.randn(3, 4, 5).astype(np.int8)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int8")
+
+x = np.random.randn(3, 4, 5).astype(np.int16)
+y = np.random.randn(3, 4, 5).astype(np.int16)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>less_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Less",
+    inputs=["x", "y"],
+    outputs=["less"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_bcast")
+```
+
+</details>
+
+
+<details>
+<summary>less_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LessOrEqual",
+    inputs=["x", "y"],
+    outputs=["less_equal"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_bcast")
+```
+
+</details>
+
+
+### <a name="LessOrEqual"></a><a name="lessorequal">**LessOrEqual**</a>
+
+  Returns the tensor resulted from performing the `less_equal` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#LessOrEqual-12">12</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input types to all numeric tensors.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+
+### <a name="LinearAttention"></a><a name="linearattention">**LinearAttention**</a>
+
+  Unified linear attention operator for autoregressive decoding (T=1) and prefill (T>1).
+
+  The query, key, value, and (where applicable) decay/beta inputs use 3D packed format
+  [B, T, H*D], where heads are flattened into the last dimension; q_num_heads and
+  kv_num_heads are always required and are used to unpack to 4D internally for computation.
+  The optional past_state and present_state are 4D with shape (B, H_kv, d_k, d_v).
+
+  Group-query attention (GQA) is supported: q_num_heads must be a positive multiple of
+  kv_num_heads. When q_num_heads == kv_num_heads this reduces to multi-headed linear
+  attention; when q_num_heads > kv_num_heads each KV head (and its recurrent state) is
+  shared by `q_num_heads / kv_num_heads` query heads (multi-query attention is the
+  special case kv_num_heads == 1).
+
+  The update_rule attribute selects the recurrence type:
+  - "linear": S_t = S_{t-1} + k_t ⊗ v_t; o_t = scale * q_t^T S_t
+  - "gated": S_t = exp(g_t) * S_{t-1} + k_t ⊗ v_t; o_t = scale * q_t^T S_t
+  - "delta": S_t = S_{t-1} + β_t * k_t ⊗ (v_t - S_{t-1}^T k_t); o_t = scale * q_t^T S_t
+  - "gated_delta": S_t = exp(g_t) * S_{t-1} + β_t * k_t ⊗ (v_t - exp(g_t) * S_{t-1}^T k_t); o_t = scale * q_t^T S_t
+
+  where g_t is the decay (in log-space), β_t is the update rate, and ⊗ denotes outer product.
+
+  Semantics: Equivalent to running the recurrent update sequentially for each token,
+  but may be implemented using chunk-parallel algorithms for GPU efficiency.
+
+
+#### Version
+
+This version of the operator has been available since version 27 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>chunk_size</tt> : int (default is 64)</dt>
+<dd>Chunk size for the chunk-parallel WY decomposition during prefill (T>1). Tuning hint; does not affect output correctness.</dd>
+<dt><tt>kv_num_heads</tt> : int (required)</dt>
+<dd>Number of key/value heads. Always required.</dd>
+<dt><tt>q_num_heads</tt> : int (required)</dt>
+<dd>Number of query heads. Always required.</dd>
+<dt><tt>scale</tt> : float (default is 0.0)</dt>
+<dd>Output scaling factor. When 0.0 (default), derives d_k = query.shape[-1] / q_num_heads and uses 1/sqrt(d_k). Set explicitly to override.</dd>
+<dt><tt>update_rule</tt> : string (default is gated_delta)</dt>
+<dd>The update rule for the linear attention recurrence. One of: 'linear', 'gated', 'delta', 'gated_delta'. Default is 'gated_delta'.</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>query</tt> (differentiable) : T</dt>
+<dd>Query vectors with 3D packed shape (B, T, H_q * d_k). Heads are packed into the last dimension.</dd>
+<dt><tt>key</tt> (differentiable) : T</dt>
+<dd>Key vectors with 3D packed shape (B, T, H_kv * d_k). Should be L2-normalized for delta/gated_delta modes.</dd>
+<dt><tt>value</tt> (differentiable) : T</dt>
+<dd>Value vectors with 3D packed shape (B, T, H_kv * d_v).</dd>
+<dt><tt>past_state</tt> (optional, non-differentiable) : S</dt>
+<dd>Recurrent state from previous step with shape (B, H_kv, d_k, d_v). Always 4D. If not provided, defaults to zeros.</dd>
+<dt><tt>decay</tt> (optional, differentiable) : T</dt>
+<dd>Exponential decay gate in log-space. 3D packed shape: (B, T, H_kv * d_k) for per-key-dimension decay (GLA/RWKV-6), or (B, T, H_kv) for per-head scalar decay (DeltaNet/RetNet). Required for 'gated' and 'gated_delta' modes.</dd>
+<dt><tt>beta</tt> (optional, differentiable) : T</dt>
+<dd>Update rate (sigmoid output). 3D packed shape: (B, T, H_kv) or (B, T, 1). Required for 'delta' and 'gated_delta' modes.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Attention output with 3D packed shape (B, T, H_q * d_v).</dd>
+<dt><tt>present_state</tt> (non-differentiable) : S</dt>
+<dd>Updated recurrent state with shape (B, H_kv, d_k, d_v). Always 4D.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(bfloat16), tensor(float)</dt>
+<dd>Constrain activation input and output types to float16, bfloat16, or float32 tensors.</dd>
+<dt><tt>S</tt> : tensor(float16), tensor(bfloat16), tensor(float)</dt>
+<dd>Constrain state types to float16, bfloat16, or float32 tensors. Should be float32 or the same as T for numerical stability on long sequences.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>decode_step</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "past_state", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 1, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+past_state = np.random.randn(b, h_kv, d_k, d_v).astype(np.float32) * 0.1
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    past_state=past_state,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, past_state, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_decode_step",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "", "beta"],
+    outputs=["output", "present_state"],
+    update_rule="delta",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="delta",
+)
+expect(
+    node,
+    inputs=[query, key, value, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_delta",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>explicit_scale</summary>
+
+```python
+scale = 0.25
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+    scale=scale,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    scale=scale,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_explicit_scale",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>fp16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=8,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float16)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float16), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float16)
+decay = (-np.abs(np.random.randn(b, t, h_kv * d_k)) * 0.1).astype(np.float16)
+beta = np.random.rand(b, t, h_kv).astype(np.float16)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_fp16",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>gated</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay"],
+    outputs=["output", "present_state"],
+    update_rule="gated",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+# Per-key-dim decay in log-space (negative -> decay).
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="gated",
+)
+expect(
+    node,
+    inputs=[query, key, value, decay],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>gated_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_delta",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>gated_delta_beta_scalar</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, 1).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_delta_beta_scalar",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>gated_delta_gqa</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=8,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_delta_gqa",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>gated_delta_mqa</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=8,
+    kv_num_heads=1,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 1, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_delta_mqa",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>gated_per_head_decay</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay"],
+    outputs=["output", "present_state"],
+    update_rule="gated",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+# Per-head scalar decay.
+decay = -np.abs(np.random.randn(b, t, h_kv)).astype(np.float32) * 0.1
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="gated",
+)
+expect(
+    node,
+    inputs=[query, key, value, decay],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_per_head_decay",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>linear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value"],
+    outputs=["output", "present_state"],
+    update_rule="linear",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="linear",
+)
+expect(
+    node,
+    inputs=[query, key, value],
+    outputs=[output, present_state],
+    name="test_linear_attention_linear",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>linear_t1_no_past</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value"],
+    outputs=["output", "present_state"],
+    update_rule="linear",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 1, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="linear",
+)
+expect(
+    node,
+    inputs=[query, key, value],
+    outputs=[output, present_state],
+    name="test_linear_attention_linear_t1_no_past",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>no_past_explicit_zeros</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "past_state", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+past_state = np.zeros((b, h_kv, d_k, d_v), dtype=np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    past_state=past_state,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, past_state, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_no_past_explicit_zeros",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+<details>
+<summary>prefill_with_past</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "past_state", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+past_state = np.random.randn(b, h_kv, d_k, d_v).astype(np.float32) * 0.1
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    past_state=past_state,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, past_state, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_prefill_with_past",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+### <a name="Log"></a><a name="log">**Log**</a>
+
+  Calculates the natural log of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Log-1">1</a>, <a href="Changelog.md#Log-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The natural log of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>log</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Log",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([1, 10]).astype(np.float32)
+y = np.log(x)  # expected output [0., 2.30258512]
+expect(node, inputs=[x], outputs=[y], name="test_log_example")
+
+x = np.exp(np.random.randn(3, 4, 5).astype(np.float32))
+y = np.log(x)
+expect(node, inputs=[x], outputs=[y], name="test_log")
+```
+
+</details>
+
+
+### <a name="LogSoftmax"></a><a name="logsoftmax">**LogSoftmax**</a>
+
+  The operator computes the log of softmax values for the given input:
+
+   LogSoftmax(input, axis) = Log(Softmax(input, axis=axis))
+
+  The "axis" attribute indicates the dimension along which LogSoftmax
+  will be performed. The output tensor has the same shape
+  and contains the LogSoftmax values of the corresponding input.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#LogSoftmax-1">1</a>, <a href="Changelog.md#LogSoftmax-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>
+Describes the dimension LogSoftmax will be performed on.
+Negative value means counting dimensions
+from the back. Accepted range is [-r, r-1] where r = rank(input).
+</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The input tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output values with the same shape as the input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>logsoftmax</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.array([[-1, 0, 1]]).astype(np.float32)
+# expected output
+# [[-2.4076061 -1.407606  -0.407606 ]]
+y = logsoftmax(x)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_example_1")
+```
+
+</details>
+
+
+<details>
+<summary>logsoftmax_axis</summary>
+
+```python
+x = np.array([[0, 1, 2, 3], [10000, 10001, 10002, 10003]]).astype(np.float32)
+# expected output
+# [[-3.4401896  -2.4401896  -1.4401896  -0.44018966]
+# [-3.4401896  -2.4401896  -1.4401896  -0.44018966]]
+y = logsoftmax(x)
+
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_large_number")
+
+x = np.abs(np.random.randn(3, 4, 5).astype(np.float32))
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=0,
+)
+y = logsoftmax(x, axis=0)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_0")
+
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=1,
+)
+y = logsoftmax(x, axis=1)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_1")
+
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=2,
+)
+y = logsoftmax(x, axis=2)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_2")
+
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=-1,
+)
+y = logsoftmax(x, axis=-1)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_negative_axis")
+
+# default axis is -1
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_default_axis")
+```
+
+</details>
+
+
+### <a name="Loop"></a><a name="loop">**Loop**</a>
+
+  Generic Looping construct. This loop has multiple termination conditions:
+
+  1) Trip count. Iteration count specified at runtime. Set by
+     specifying the input M. Optional. Set to empty string to omit.
+     Note that a static trip count (specified at graph construction time) can be
+     specified by passing in a constant node for input M.
+  2) Loop termination condition. This is an input to the op that determines
+     whether to run the first iteration and also a loop-carried dependency for
+     the body graph. The body graph must yield a value for the condition variable,
+     whether this input is provided or not.
+
+  This table summarizes the operating modes of this operator with equivalent
+  C-style code:
+
+  Operator inputs defined as (max_trip_count, condition_var).
+
+  * input ("", ""):
+          for (int i=0; ; ++i) {
+            cond = ... // Note this value is ignored, but is required in the body
+          }
+
+  * input ("", cond) // Note this is analogous to a while loop
+          bool cond = ...;
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input ("", 1) // Note this is analogous to a do-while loop
+          bool cond = true
+          for (int i=0; cond; ++i) {
+            cond = ...;
+          }
+
+  * input (trip_count, "") // Note this is analogous to a for loop
+          int trip_count = ...
+          for (int i=0; i < trip_count; ++i) {
+            cond = ...; // ignored
+          }
+
+  * input (trip_count, cond)
+          int trip_count = ...;
+          bool cond = ...;
+          for (int i=0; i < trip_count && cond; ++i) {
+            cond = ...;
+          }
+
+
+  *Sample usage - cond as well as trip count*
+
+      graph predict-net {
+        %a = Constant[value = <Scalar Tensor [3]>]()
+        %b = Constant[value = <Scalar Tensor [6]>]()
+        %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+        %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+        %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+        return
+      }
+
+      graph body-net (
+        %i[INT32, scalar]           // iteration number
+        %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+        %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+      ) {
+        %my_local = Add(%a, %b_in)
+        %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+        %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+        %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+        return %keepgoing_out, %b_out, %user_defined_val
+      }
+
+  *Sample equivalent C code*
+
+      {
+        /* User-defined code (enclosing scope) */
+        int a = 3, b = 6;
+        bool keepgoing = true; // Analogous to input cond
+        /* End user-defined code */
+
+        /* Implicitly-defined code */
+        const int max_trip_count = 10; // Analogous to input M
+        int user_defined_vals[]; // Imagine this is resizable
+        /* End implicitly-defined code */
+        /* initialize loop-carried variables and scan-output variables */
+        bool keepgoing_out = keepgoing
+        int b_out = b
+
+        for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+          /* Implicitly-defined code: bind actual parameter values
+             to formal parameter variables of loop-body */
+          bool keepgoing_in = keepgoing_out;
+          bool b_in = b_out;
+
+          /* User-defined code (loop body) */
+          int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+          b_out = a - b_in;
+          keepgoing_out = my_local > b_out;
+          user_defined_val = b_in + b_in; // b_in and b_out are different variables
+          /* End user-defined code */
+
+          /* Implicitly defined-code */
+          user_defined_vals[i] = user_defined_val // accumulate scan-output values
+        }
+        // int t = my_local; // Can't do this. my_local is not accessible here.
+
+        // The values below are bound to the output variables of the loop and therefore accessible
+        // b_out; user_defined_vals; keepgoing_out;
+      }
+
+  There are several things of note in this code snippet:
+
+  1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+     be referenced in the inputs of the loop.
+  2) Any values computed in the loop body that needs to be used in a subsequent
+     iteration or after the loop are modeled using a pair of variables in the loop-body,
+     consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+     These are referred to as loop-carried dependences. The loop operation node
+     supplies the input value of the input variable for the first iteration, and
+     returns the output value of the output variable produced by the final
+     iteration.
+  3) Scan_output variables are used to implicitly concatenate values computed across
+     all the iterations. In the above example, the value of user_defined_val computed
+     over all iterations are concatenated and returned as the value of user_defined_vals
+     after the loop.
+  4) Values created in the body cannot be accessed in the enclosing scope,
+     except using the mechanism described above.
+
+  Note that the semantics of this op support "diagonal" or "wavefront" execution.
+  (See Step 3 here for an example:
+  https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+  Frontends should emit multi-layer RNNs as a series of While operators (with
+  time being the inner looping dimension), with each successive layer consuming
+  the scan_outputs from the previous layer, possibly going through several
+  point-wise operators (e.g. dropout, residual connections, linear layer).
+
+  The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Loop-1">1</a>, <a href="Changelog.md#Loop-11">11</a>, <a href="Changelog.md#Loop-13">13</a>, <a href="Changelog.md#Loop-16">16</a>, <a href="Changelog.md#Loop-19">19</a>, <a href="Changelog.md#Loop-21">21</a>, <a href="Changelog.md#Loop-23">23</a>, <a href="Changelog.md#Loop-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has 2+N inputs: (iteration_num, condition, loop carried dependencies...). It has 1+N+K outputs: (condition, loop carried dependencies..., scan_outputs...). Each scan_output is created by concatenating the value of the specified output value at the end of each iteration of the loop. It is an error if the dimensions or data type of these scan_outputs change across loop iterations.</dd>
+</dl>
+
+#### Inputs (2 - &#8734;)
+
+<dl>
+<dt><tt>M</tt> (optional) : I</dt>
+<dd>A maximum trip-count for the loop specified at runtime. Optional. Pass empty string to skip.</dd>
+<dt><tt>cond</tt> (optional) : B</dt>
+<dd>A boolean termination condition. Optional. Pass empty string to skip.</dd>
+<dt><tt>v_initial</tt> (variadic, heterogeneous) : V</dt>
+<dd>The initial values of any loop-carried dependencies (values that change across loop iterations)</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>v_final_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final N loop carried dependency values then K scan_outputs. Scan outputs must be Tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128)), seq(tensor(float8e4m3fn)), seq(tensor(float8e4m3fnuz)), seq(tensor(float8e5m2)), seq(tensor(float8e5m2fnuz)), seq(tensor(uint4)), seq(tensor(int4)), seq(tensor(float4e2m1)), seq(tensor(float8e8m0)), seq(tensor(uint2)), seq(tensor(int2)), optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(bfloat16))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(bfloat16)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), optional(tensor(float8e4m3fn)), optional(tensor(float8e4m3fnuz)), optional(tensor(float8e5m2)), optional(tensor(float8e5m2fnuz)), optional(tensor(uint4)), optional(tensor(int4)), optional(tensor(float4e2m1)), optional(tensor(float8e8m0)), optional(tensor(uint2)), optional(tensor(int2))</dt>
+<dd>All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv13.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>tensor of int64, which should be a scalar.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>tensor of bool, which should be a scalar.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>loop_11</summary>
+
+```python
+# Given a tensor x of values [x1, ..., xN], and initial tensor y
+# sum up its elements using a scan
+# returning the final state (y+x1+x2+...+xN) as well the scan_output
+# [y+x1, y+x1+x2, ..., y+x1+x2+...+xN]
+
+y_in = onnx.helper.make_tensor_value_info("y_in", onnx.TensorProto.FLOAT, [1])
+y_out = onnx.helper.make_tensor_value_info("y_out", onnx.TensorProto.FLOAT, [1])
+scan_out = onnx.helper.make_tensor_value_info(
+    "scan_out", onnx.TensorProto.FLOAT, [1]
+)
+cond_in = onnx.helper.make_tensor_value_info(
+    "cond_in", onnx.TensorProto.BOOL, []
+)
+cond_out = onnx.helper.make_tensor_value_info(
+    "cond_out", onnx.TensorProto.BOOL, []
+)
+iter_count = onnx.helper.make_tensor_value_info(
+    "iter_count", onnx.TensorProto.INT64, []
+)
+
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+y = np.array([-2]).astype(np.float32)
+
+x_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_x",
+        data_type=onnx.TensorProto.FLOAT,
+        dims=x.shape,
+        vals=x.flatten().astype(float),
+    ),
+)
+
+one_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["one"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_one",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[1],
+    ),
+)
+
+i_add_node = onnx.helper.make_node(
+    "Add", inputs=["iter_count", "one"], outputs=["end"]
+)
+
+start_unsqueeze_node = onnx.helper.make_node(
+    "Unsqueeze", inputs=["iter_count"], outputs=["slice_start"], axes=[0]
+)
+
+end_unsqueeze_node = onnx.helper.make_node(
+    "Unsqueeze", inputs=["end"], outputs=["slice_end"], axes=[0]
+)
+
+slice_node = onnx.helper.make_node(
+    "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+)
+
+y_add_node = onnx.helper.make_node(
+    "Add", inputs=["y_in", "slice_out"], outputs=["y_out"]
+)
+
+identity_node = onnx.helper.make_node(
+    "Identity", inputs=["cond_in"], outputs=["cond_out"]
+)
+
+scan_identity_node = onnx.helper.make_node(
+    "Identity", inputs=["y_out"], outputs=["scan_out"]
+)
+
+loop_body = onnx.helper.make_graph(
+    [
+        identity_node,
+        x_const_node,
+        one_const_node,
+        i_add_node,
+        start_unsqueeze_node,
+        end_unsqueeze_node,
+        slice_node,
+        y_add_node,
+        scan_identity_node,
+    ],
+    "loop_body",
+    [iter_count, cond_in, y_in],
+    [cond_out, y_out, scan_out],
+)
+
+node = onnx.helper.make_node(
+    "Loop",
+    inputs=["trip_count", "cond", "y"],
+    outputs=["res_y", "res_scan"],
+    body=loop_body,
+)
+
+trip_count = np.array(5).astype(np.int64)
+res_y = np.array([13]).astype(np.float32)
+cond = np.array(1).astype(bool)
+res_scan = np.array([-1, 1, 4, 8, 13]).astype(np.float32).reshape((5, 1))
+expect(
+    node,
+    inputs=[trip_count, cond, y],
+    outputs=[res_y, res_scan],
+    name="test_loop11",
+    opset_imports=[onnx.helper.make_opsetid("", 11)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>loop_13</summary>
+
+```python
+# Given a tensor x of values [x1, ..., xN],
+# Return a sequence of tensors of
+#   [[x1], [x1, x2], ..., [x1, ..., xN]]
+
+seq_in = onnx.helper.make_tensor_sequence_value_info(
+    "seq_in", onnx.TensorProto.FLOAT, None
+)
+seq_out = onnx.helper.make_tensor_sequence_value_info(
+    "seq_out", onnx.TensorProto.FLOAT, None
+)
+cond_in = onnx.helper.make_tensor_value_info(
+    "cond_in", onnx.TensorProto.BOOL, []
+)
+cond_out = onnx.helper.make_tensor_value_info(
+    "cond_out", onnx.TensorProto.BOOL, []
+)
+iter_count = onnx.helper.make_tensor_value_info(
+    "iter_count", onnx.TensorProto.INT64, []
+)
+
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+
+x_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_x",
+        data_type=onnx.TensorProto.FLOAT,
+        dims=x.shape,
+        vals=x.flatten().astype(float),
+    ),
+)
+
+one_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["one"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_one",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[1],
+    ),
+)
+
+zero_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["slice_start"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_zero",
+        data_type=onnx.TensorProto.INT64,
+        dims=(1,),
+        vals=[0],
+    ),
+)
+
+axes_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["axes"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_axes",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[0],
+    ),
+)
+
+add_node = onnx.helper.make_node(
+    "Add", inputs=["iter_count", "one"], outputs=["end"]
+)
+
+end_unsqueeze_node = onnx.helper.make_node(
+    "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"]
+)
+
+slice_node = onnx.helper.make_node(
+    "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+)
+
+insert_node = onnx.helper.make_node(
+    "SequenceInsert", inputs=["seq_in", "slice_out"], outputs=["seq_out"]
+)
+
+identity_node = onnx.helper.make_node(
+    "Identity", inputs=["cond_in"], outputs=["cond_out"]
+)
+
+loop_body = onnx.helper.make_graph(
+    [
+        identity_node,
+        x_const_node,
+        one_const_node,
+        zero_const_node,
+        add_node,
+        axes_node,
+        end_unsqueeze_node,
+        slice_node,
+        insert_node,
+    ],
+    "loop_body",
+    [iter_count, cond_in, seq_in],
+    [cond_out, seq_out],
+)
+
+node = onnx.helper.make_node(
+    "Loop",
+    inputs=["trip_count", "cond", "seq_empty"],
+    outputs=["seq_res"],
+    body=loop_body,
+)
+
+trip_count = np.array(5).astype(np.int64)
+seq_empty: list[Any] = []
+seq_res = [x[: int(i)] for i in x]
+cond = np.array(1).astype(bool)
+expect(
+    node,
+    inputs=[trip_count, cond, seq_empty],
+    outputs=[seq_res],
+    name="test_loop13_seq",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+    input_type_protos=[
+        onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.INT64, trip_count.shape
+        ),
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape),
+        onnx.helper.make_sequence_type_proto(
+            onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, [])
+        ),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>loop_16_none</summary>
+
+```python
+# Given a tensor sequence of values [x1, ..., xN], and an initial optional sequence of tensors [x0],
+# Return a concatenated sequence of tensors of
+#   [x0, [x1], [x1, x2], ..., [x1, ..., xN]]
+
+ten_in_tp = onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, [])
+seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp)
+opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp)
+opt_in = onnx.helper.make_value_info("opt_seq_in", opt_in_tp)
+seq_out = onnx.helper.make_tensor_sequence_value_info(
+    "seq_out", onnx.TensorProto.FLOAT, []
+)
+cond_in = onnx.helper.make_tensor_value_info(
+    "cond_in", onnx.TensorProto.BOOL, []
+)
+cond_out = onnx.helper.make_tensor_value_info(
+    "cond_out", onnx.TensorProto.BOOL, []
+)
+iter_count = onnx.helper.make_tensor_value_info(
+    "iter_count", onnx.TensorProto.INT64, []
+)
+
+x0 = np.array(0).astype(np.float32)
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+
+optional_has_elem_node = onnx.helper.make_node(
+    "OptionalHasElement", inputs=["opt_seq_in"], outputs=["optional_has_elem"]
+)
+
+optional_is_none = onnx.helper.make_node(
+    "Not", inputs=["optional_has_elem"], outputs=["optional_is_none"]
+)
+
+optional_get_elem = onnx.helper.make_node(
+    "OptionalGetElement", inputs=["opt_seq_in"], outputs=["seq_in"]
+)
+
+constant_in = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["constant_in"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor", data_type=onnx.TensorProto.FLOAT, dims=(), vals=[0]
+    ),
+)
+
+seq_const_in = onnx.helper.make_node(
+    "SequenceConstruct", inputs=["constant_in"], outputs=["init_seq_in"]
+)
+
+then_seq_out = onnx.helper.make_tensor_sequence_value_info(
+    "init_seq_in", onnx.TensorProto.FLOAT, []
+)
+then_body = onnx.helper.make_graph(
+    [constant_in, seq_const_in], "then_body", [], [then_seq_out]
+)
+
+else_seq_out = onnx.helper.make_tensor_sequence_value_info(
+    "seq_in", onnx.TensorProto.FLOAT, []
+)
+else_body = onnx.helper.make_graph(
+    [optional_get_elem], "else_body", [], [else_seq_out]
+)
+
+if_node = onnx.helper.make_node(
+    "If",
+    inputs=["optional_is_none"],
+    outputs=["sequence"],
+    then_branch=then_body,
+    else_branch=else_body,
+)
+
+x_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_x",
+        data_type=onnx.TensorProto.FLOAT,
+        dims=x.shape,
+        vals=x.flatten().astype(float),
+    ),
+)
+
+one_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["one"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_one",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[1],
+    ),
+)
+
+zero_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["slice_start"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_zero",
+        data_type=onnx.TensorProto.INT64,
+        dims=(1,),
+        vals=[0],
+    ),
+)
+
+axes_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["axes"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_axes",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[0],
+    ),
+)
+
+add_node = onnx.helper.make_node(
+    "Add", inputs=["iter_count", "one"], outputs=["end"]
+)
+
+end_unsqueeze_node = onnx.helper.make_node(
+    "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"]
+)
+
+slice_node = onnx.helper.make_node(
+    "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+)
+
+insert_node = onnx.helper.make_node(
+    "SequenceInsert", inputs=["sequence", "slice_out"], outputs=["seq_out"]
+)
+
+identity_node = onnx.helper.make_node(
+    "Identity", inputs=["cond_in"], outputs=["cond_out"]
+)
+
+loop_body = onnx.helper.make_graph(
+    [
+        identity_node,
+        optional_has_elem_node,
+        optional_is_none,
+        if_node,
+        x_const_node,
+        one_const_node,
+        zero_const_node,
+        add_node,
+        axes_node,
+        end_unsqueeze_node,
+        slice_node,
+        insert_node,
+    ],
+    "loop_body",
+    [iter_count, cond_in, opt_in],
+    [cond_out, seq_out],
+)
+
+node = onnx.helper.make_node(
+    "Loop",
+    inputs=["trip_count", "cond", "opt_seq"],
+    outputs=["seq_res"],
+    body=loop_body,
+)
+
+trip_count = np.array(5).astype(np.int64)
+cond = np.array(1).astype(bool)
+seq_res = compute_loop_outputs(x, [x0], trip_count)
+opt_seq_in: list[Any] = [x0]
+expect(
+    node,
+    inputs=[trip_count, cond, opt_seq_in],
+    outputs=[seq_res],
+    name="test_loop16_seq_none",
+    opset_imports=[onnx.helper.make_opsetid("", 16)],
+    input_type_protos=[
+        onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.INT64, trip_count.shape
+        ),
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape),
+        opt_in_tp,
+    ],
+)
+```
+
+</details>
+
+
+### <a name="LpNormalization"></a><a name="lpnormalization">**LpNormalization**</a>
+
+  Given a matrix, apply Lp-normalization along the provided axis.
+  The output is computed as: `output = input / Lp_norm(input, axis)`.
+  When the Lp norm is zero (i.e., all elements along the axis are zero),
+  the output is defined to be zero to avoid division by zero.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#LpNormalization-1">1</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>The axis on which to apply normalization, -1 mean last axis.</dd>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>The order of the normalization, only 1 or 2 are supported.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input matrix</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Matrix after normalization</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default</summary>
+
+```python
+node = onnx.helper.make_node("LpNormalization", inputs=["x"], outputs=["y"])
+x = np.array(
+    [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+    dtype=np.float32,
+)
+lp_norm_default = np.sqrt(np.sum(x**2, axis=-1, keepdims=True))
+y = x / lp_norm_default
+expect(node, inputs=[x], outputs=[y], name="test_lpnormalization_default")
+```
+
+</details>
+
+
+<details>
+<summary>l1normalization_axis_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=1
+)
+x = np.array([3.0, 4.0], dtype=np.float32)
+l1_norm_axis_0 = np.sum(abs(x), axis=0, keepdims=True)
+y = x / l1_norm_axis_0
+expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_0")
+```
+
+</details>
+
+
+<details>
+<summary>l1normalization_axis_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=1
+)
+x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+l1_norm_axis_1 = np.sum(abs(x), axis=1, keepdims=True)
+y = x / l1_norm_axis_1
+expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_1")
+```
+
+</details>
+
+
+<details>
+<summary>l1normalization_axis_last</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=-1, p=1
+)
+x = np.array(
+    [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+    dtype=np.float32,
+)
+l1_norm_axis_last = np.sum(abs(x), axis=-1, keepdims=True)
+y = x / l1_norm_axis_last
+expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_last")
+```
+
+</details>
+
+
+<details>
+<summary>l2normalization_axis_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=2
+)
+x = np.array(
+    [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+    dtype=np.float32,
+)
+l2_norm_axis_0 = np.sqrt(np.sum(x**2, axis=0, keepdims=True))
+# When norm is 0, output is 0 (0/0 = 0)
+y = np.where(l2_norm_axis_0 == 0, 0, x / l2_norm_axis_0)
+expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_0")
+```
+
+</details>
+
+
+<details>
+<summary>l2normalization_axis_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=2
+)
+x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+l2_norm_axis_1 = np.sqrt(np.sum(x**2, axis=1, keepdims=True))
+y = x / l2_norm_axis_1
+expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_1")
+```
+
+</details>
+
+
+### <a name="LpPool"></a><a name="lppool">**LpPool**</a>
+
+  LpPool consumes an input tensor X and applies Lp pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   Lp pooling consisting of computing the Lp norm on all values of a subset
+   of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape will be following:
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled `pad_shape[i]` is the sum of pads along axis `i`.
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]
+   ```
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#LpPool-1">1</a>, <a href="Changelog.md#LpPool-2">2</a>, <a href="Changelog.md#LpPool-11">11</a>, <a href="Changelog.md#LpPool-18">18</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>p</tt> : int (default is 2)</dt>
+<dd>p value of the Lp norm used to pool over the input data.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from Lp pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>lppool_1d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32]
+output_shape: [1, 3, 31]
+"""
+p = 3
+kernel_shape = [2]
+strides = [1]
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=kernel_shape,
+    strides=strides,
+    p=p,
+)
+x = np.random.randn(1, 3, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_1d_default")
+```
+
+</details>
+
+
+<details>
+<summary>lppool_2d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 31, 31]
+"""
+p = 4
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_default")
+```
+
+</details>
+
+
+<details>
+<summary>lppool_2d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+p = 2
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[1, 1],
+    dilations=[2, 2],
+    p=p,
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+y = np.array(
+    [
+        [
+            [
+                [14.560219778561036, 16.24807680927192],
+                [21.633307652783937, 23.49468024894146],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_dilations")
+```
+
+</details>
+
+
+<details>
+<summary>lppool_2d_pads</summary>
+
+```python
+"""input_shape: [1, 3, 28, 28]
+output_shape: [1, 3, 30, 30]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+p = 3
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[2, 2, 2, 2],
+    p=p,
+)
+x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (3, 3)
+strides = (1, 1)
+pad_bottom = pad_top = pad_right = pad_left = 2
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+out_shape, extra_pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = np.pad(
+    x,
+    (
+        (0, 0),
+        (0, 0),
+        (extra_pads[0], extra_pads[2]),
+        (extra_pads[1], extra_pads[3]),
+    ),
+    mode="constant",
+    constant_values=0,
+)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "LPPOOL",
+    pads_required=extra_pads,
+    pads=pads,
+    p=p,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_pads")
+```
+
+</details>
+
+
+<details>
+<summary>lppool_2d_same_lower</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+"""
+p = 4
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_LOWER",
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_bottom = pad_shape[0] // 2
+pad_top = pad_shape[0] - pad_bottom
+pad_right = pad_shape[1] // 2
+pad_left = pad_shape[1] - pad_right
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=0,
+)
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+y = pool(
+    padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_lower")
+```
+
+</details>
+
+
+<details>
+<summary>lppool_2d_same_upper</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+"""
+p = 2
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_UPPER",
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_top = pad_shape[0] // 2
+pad_bottom = pad_shape[0] - pad_top
+pad_left = pad_shape[1] // 2
+pad_right = pad_shape[1] - pad_left
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=0,
+)
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+y = pool(
+    padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_upper")
+```
+
+</details>
+
+
+<details>
+<summary>lppool_2d_strides</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 10, 10]
+"""
+p = 2
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    strides=[3, 3],
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (5, 5)
+strides = (3, 3)
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_strides")
+```
+
+</details>
+
+
+<details>
+<summary>lppool_3d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32, 32]
+output_shape: [1, 3, 31, 31, 31]
+"""
+p = 3
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2, 2, 2]
+strides = [1, 1, 1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_3d_default")
+```
+
+</details>
+
+
+### <a name="MatMul"></a><a name="matmul">**MatMul**</a>
+
+  Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#MatMul-1">1</a>, <a href="Changelog.md#MatMul-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>N-dimensional matrix A</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>N-dimensional matrix B</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Matrix multiply results from A * B</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>matmul</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MatMul",
+    inputs=["a", "b"],
+    outputs=["c"],
+)
+
+# 2d
+a = np.random.randn(3, 4).astype(np.float32)
+b = np.random.randn(4, 3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_2d")
+
+# 3d
+a = np.random.randn(2, 3, 4).astype(np.float32)
+b = np.random.randn(2, 4, 3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_3d")
+
+# 4d
+a = np.random.randn(1, 2, 3, 4).astype(np.float32)
+b = np.random.randn(1, 2, 4, 3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_4d")
+
+# broadcasting
+a = np.random.randn(3, 1, 3, 4).astype(np.float32)
+b = np.random.randn(1, 2, 4, 2).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_bcast")
+
+# 1d + 3d
+a = np.random.randn(4).astype(np.float32)
+b = np.random.randn(2, 4, 1).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_1d_3d")
+
+# 3d + 1d
+a = np.random.randn(1, 2, 4, 3).astype(np.float32)
+b = np.random.randn(3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_4d_1d")
+
+# 1d + 1d
+a = np.random.randn(3).astype(np.float32)
+b = np.random.randn(3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_1d_1d")
+```
+
+</details>
+
+
+### <a name="MatMulInteger"></a><a name="matmulinteger">**MatMulInteger**</a>
+
+  Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+  The production MUST never overflow. The accumulation may overflow if and only if in 32 bits.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T1</dt>
+<dd>N-dimensional matrix A</dd>
+<dt><tt>B</tt> (non-differentiable) : T2</dt>
+<dd>N-dimensional matrix B</dd>
+<dt><tt>a_zero_point</tt> (optional, non-differentiable) : T1</dt>
+<dd>Zero point tensor for input 'A'. It's optional and default value is 0. It could be a scalar or N-D tensor. Scalar refers to per tensor quantization whereas N-D refers to per row quantization. If the input is 2D of shape [M, K] then zero point tensor may be an M element vector [zp_1, zp_2, ..., zp_M]. If the input is N-D tensor with shape [D1, D2, M, K] then zero point tensor may have shape [D1, D2, M, 1]. </dd>
+<dt><tt>b_zero_point</tt> (optional, non-differentiable) : T2</dt>
+<dd>Zero point tensor for input 'B'. It's optional and default value is 0. It could be a scalar or a N-D tensor, Scalar refers to per tensor quantization whereas N-D refers to per col quantization. If the input is 2D of shape [K, N] then zero point tensor may be an N element vector [zp_1, zp_2, ..., zp_N]. If the input is N-D tensor with shape [D1, D2, K, N] then zero point tensor may have shape [D1, D2, 1, N]. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T3</dt>
+<dd>Matrix multiply results from A * B</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input A data type to 8-bit integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input B data type to 8-bit integer tensor.</dd>
+<dt><tt>T3</tt> : tensor(int32)</dt>
+<dd>Constrain output Y data type as 32-bit integer tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>matmulinteger</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MatMulInteger",
+    inputs=["A", "B", "a_zero_point", "b_zero_point"],
+    outputs=["Y"],
+)
+
+A = np.array(
+    [
+        [11, 7, 3],
+        [10, 6, 2],
+        [9, 5, 1],
+        [8, 4, 0],
+    ],
+    dtype=np.uint8,
+)
+
+a_zero_point = np.array([12], dtype=np.uint8)
+
+B = np.array(
+    [
+        [1, 4],
+        [2, 5],
+        [3, 6],
+    ],
+    dtype=np.uint8,
+)
+
+b_zero_point = np.array([0], dtype=np.uint8)
+
+output = np.array(
+    [
+        [-38, -83],
+        [-44, -98],
+        [-50, -113],
+        [-56, -128],
+    ],
+    dtype=np.int32,
+)
+
+expect(
+    node,
+    inputs=[A, B, a_zero_point, b_zero_point],
+    outputs=[output],
+    name="test_matmulinteger",
+)
+```
+
+</details>
+
+
+### <a name="Max"></a><a name="max">**Max**</a>
+
+  Element-wise max of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Max-1">1</a>, <a href="Changelog.md#Max-6">6</a>, <a href="Changelog.md#Max-8">8</a>, <a href="Changelog.md#Max-12">12</a>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for max.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>max</tt> (differentiable) : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>max</summary>
+
+```python
+data_0 = np.array([3, 2, 1]).astype(np.float32)
+data_1 = np.array([1, 4, 4]).astype(np.float32)
+data_2 = np.array([2, 5, 3]).astype(np.float32)
+result = np.array([3, 5, 4]).astype(np.float32)
+node = onnx.helper.make_node(
+    "Max",
+    inputs=["data_0", "data_1", "data_2"],
+    outputs=["result"],
+)
+expect(
+    node,
+    inputs=[data_0, data_1, data_2],
+    outputs=[result],
+    name="test_max_example",
+)
+
+node = onnx.helper.make_node(
+    "Max",
+    inputs=["data_0"],
+    outputs=["result"],
+)
+expect(node, inputs=[data_0], outputs=[data_0], name="test_max_one_input")
+
+result = np.maximum(data_0, data_1)
+node = onnx.helper.make_node(
+    "Max",
+    inputs=["data_0", "data_1"],
+    outputs=["result"],
+)
+expect(
+    node, inputs=[data_0, data_1], outputs=[result], name="test_max_two_inputs"
+)
+```
+
+</details>
+
+
+<details>
+<summary>max_all_numeric_types</summary>
+
+```python
+for op_dtype in all_numeric_dtypes:
+    data_0 = np.array([3, 2, 1]).astype(op_dtype)
+    data_1 = np.array([1, 4, 4]).astype(op_dtype)
+    result = np.array([3, 4, 4]).astype(op_dtype)
+    node = onnx.helper.make_node(
+        "Max",
+        inputs=["data_0", "data_1"],
+        outputs=["result"],
+    )
+    expect(
+        node,
+        inputs=[data_0, data_1],
+        outputs=[result],
+        name=f"test_max_{np.dtype(op_dtype).name}",
+    )
+```
+
+</details>
+
+
+### <a name="MaxPool"></a><a name="maxpool">**MaxPool**</a>
+
+  MaxPool consumes an input tensor X and applies max pooling across
+   the tensor according to kernel sizes, stride sizes, and pad lengths.
+   max pooling consisting of computing the max on all values of a
+   subset of the input tensor according to the kernel size and downsampling the
+   data into the output tensor Y for further processing. The output spatial shape is calculated differently
+   depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
+   With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):
+   ```
+   output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   or
+   ```
+   output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+   ```
+   if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`. Sliding windows that would start in the right padded region are ignored.
+
+   `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+   ```
+   VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) + 1) / strides_spatial_shape[i])
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+   ```
+   or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):
+   ```
+   VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - ((kernel_spatial_shape[i] - 1) * dilations[i] + 1)) / strides_spatial_shape[i]) + 1
+   SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1
+   ```
+   And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+   ```
+   pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + ((kernel_spatial_shape[i] - 1) * dilations[i] + 1) - input_spatial_shape[i]
+   ```
+   The output of each pooling window is maximum number of elements exclude pad.
+
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#MaxPool-1">1</a>, <a href="Changelog.md#MaxPool-8">8</a>, <a href="Changelog.md#MaxPool-10">10</a>, <a href="Changelog.md#MaxPool-11">11</a>, <a href="Changelog.md#MaxPool-12">12</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>ceil_mode</tt> : int (default is 0)</dt>
+<dd>Whether to use ceil or floor (default) to compute the output shape.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>storage_order</tt> : int (default is 0)</dt>
+<dd>The storage order of the tensor. 0 is row major, and 1 is column major. This attribute is used only to convert an n-tuple index value into a single integer value for producing the second output. </dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output data tensor from average or max pooling across the input tensor. Dimensions will vary based on various kernel, stride, and pad sizes. Floor value of the dimension is used</dd>
+<dt><tt>Indices</tt> (optional, non-differentiable) : I</dt>
+<dd>Indices tensor from max pooling across the input tensor. The dimensions of indices are the same as output tensor. The values in indices of are the indices of the selected values during pooling. The indices are computed as flatten 1-D tensor, and the indices do not consider padding. So the values in indices are in [0, N x C x D1 x ... x Dn).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input and output types to float and 8 bit tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>maxpool_1d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32]
+output_shape: [1, 3, 31]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2],
+)
+x = np.random.randn(1, 3, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2]
+strides = [1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_1d_default")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_ceil</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+    ceil_mode=True,
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_ceil")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_ceil_output_size_reduce_by_one</summary>
+
+```python
+"""input_shape: [1, 1, 2, 2]
+output_shape: [1, 1, 1, 1]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[1, 1],
+    strides=[2, 2],
+    ceil_mode=True,
+)
+x = np.array([[[[1, 2], [3, 4]]]]).astype(np.float32)
+y = np.array([[[[1]]]]).astype(np.float32)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_maxpool_2d_ceil_output_size_reduce_by_one",
+)
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 31, 31]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_default")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[1, 1],
+    dilations=[2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_dilations")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_pads</summary>
+
+```python
+"""input_shape: [1, 3, 28, 28]
+output_shape: [1, 3, 30, 30]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[2, 2, 2, 2],
+)
+x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (3, 3)
+strides = (1, 1)
+pad_bottom = pad_top = pad_right = pad_left = 2
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+out_shape, extra_pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "MAX",
+    pads_required=extra_pads,
+    pads=pads,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_pads")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_precomputed_pads</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array(
+    [
+        [
+            [
+                [13, 14, 15, 15, 15],
+                [18, 19, 20, 20, 20],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_pads")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_precomputed_same_upper</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 3, 3]
+pad_shape: [2, 2] -> [1, 1, 1, 1] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+    auto_pad="SAME_UPPER",
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[7, 9, 10], [17, 19, 20], [22, 24, 25]]]]).astype(np.float32)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_same_upper"
+)
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_precomputed_strides</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[2, 2], strides=[2, 2]
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_strides"
+)
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_same_lower</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_LOWER",
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_bottom = pad_shape[0] // 2
+pad_top = pad_shape[0] - pad_bottom
+pad_right = pad_shape[1] // 2
+pad_left = pad_shape[1] - pad_right
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_lower")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_same_upper</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_UPPER",
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_top = pad_shape[0] // 2
+pad_bottom = pad_shape[0] - pad_top
+pad_left = pad_shape[1] // 2
+pad_right = pad_shape[1] - pad_left
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_upper")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_strides</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 10, 10]
+"""
+node = onnx.helper.make_node(
+    "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[5, 5], strides=[3, 3]
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (5, 5)
+strides = (3, 3)
+out_shape, pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_strides")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_2d_uint8</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.uint8)
+y = np.array(
+    [
+        [
+            [
+                [13, 14, 15, 15, 15],
+                [18, 19, 20, 20, 20],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+            ]
+        ]
+    ]
+).astype(np.uint8)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_uint8")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_3d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32, 32]
+output_shape: [1, 3, 31, 31, 31]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+)
+x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2, 2, 2]
+strides = [1, 1, 1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_3d_default")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_3d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4, 4]
+output_shape: [1, 1, 2, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+    strides=[1, 1, 1],
+    dilations=[2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[[11, 12], [15, 16]], [[11, 12], [15, 16]]]]]).astype(
+    np.float32
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_3d_dilations")
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_3d_dilations_use_ref_impl</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4, 4]
+output_shape: [1, 1, 2, 2, 2]
+"""
+dilations = [2, 2, 2]
+kernel_shape = [2, 2, 2]
+strides = [1, 1, 1]
+ceil_mode = False
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+    strides=[1, 1, 1],
+    dilations=dilations,
+)
+x = np.array(
+    [
+        [
+            [
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+x_shape = x.shape[2:]
+out_shape, pads = get_output_shape_explicit_padding(
+    None, x_shape, kernel_shape, strides, dilations, ceil_mode=ceil_mode
+)
+padded = x
+y = pool(
+    padded,
+    (1, 1, *x_shape),
+    kernel_shape,
+    strides,
+    out_shape,
+    "MAX",
+    pads_required=pads,
+    pads=None,
+    dilations=dilations,
+)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_maxpool_3d_dilations_use_ref_impl"
+)
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_3d_dilations_use_ref_impl_large</summary>
+
+```python
+x_shape = (32, 32, 32)
+dilations = (2, 2, 2)
+kernel_shape = (5, 5, 5)
+strides = (3, 3, 3)
+ceil_mode = True
+
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=kernel_shape,
+    strides=strides,
+    dilations=dilations,
+    ceil_mode=ceil_mode,
+)
+
+x = np.random.randn(1, 1, *x_shape).astype(np.float32)
+out_shape, pads = get_output_shape_explicit_padding(
+    None, x_shape, kernel_shape, strides, dilations, ceil_mode=ceil_mode
+)
+padded = np.pad(
+    x,
+    (
+        (0, 0),
+        (0, 0),
+        (pads[0], pads[3]),
+        (pads[1], pads[4]),
+        (pads[2], pads[5]),
+    ),
+    mode="constant",
+    constant_values=0,
+)
+y = pool(
+    padded,
+    (1, 1, *x_shape),
+    kernel_shape,
+    strides,
+    out_shape,
+    "MAX",
+    pads_required=pads,
+    pads=None,
+    dilations=dilations,
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_maxpool_3d_dilations_use_ref_impl_large",
+)
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_with_argmax_2d_precomputed_pads</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y", "z"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array(
+    [
+        [
+            [
+                [13, 14, 15, 15, 15],
+                [18, 19, 20, 20, 20],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+            ]
+        ]
+    ]
+).astype(np.float32)
+z = np.array(
+    [
+        [
+            [
+                [12, 13, 14, 14, 14],
+                [17, 18, 19, 19, 19],
+                [22, 23, 24, 24, 24],
+                [22, 23, 24, 24, 24],
+                [22, 23, 24, 24, 24],
+            ]
+        ]
+    ]
+).astype(np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y, z],
+    name="test_maxpool_with_argmax_2d_precomputed_pads",
+)
+```
+
+</details>
+
+
+<details>
+<summary>maxpool_with_argmax_2d_precomputed_strides</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y", "z"],
+    kernel_shape=[2, 2],
+    strides=[2, 2],
+    storage_order=1,
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32)
+z = np.array([[[[6, 16], [8, 18]]]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y, z],
+    name="test_maxpool_with_argmax_2d_precomputed_strides",
+)
+```
+
+</details>
+
+
+### <a name="MaxRoiPool"></a><a name="maxroipool">**MaxRoiPool**</a>
+
+  ROI max pool consumes an input tensor X and region of interests (RoIs) to
+   apply max pooling across each RoI, to produce output 4-D tensor of shape
+   (num_rois, channels, pooled_shape[0], pooled_shape[1]).
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#MaxRoiPool-1">1</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>pooled_shape</tt> : list of ints (required)</dt>
+<dd>ROI pool output shape (height, width).</dd>
+<dt><tt>spatial_scale</tt> : float (default is 1.0)</dt>
+<dd>Multiplicative spatial scale factor to translate ROI coordinates from their input scale to the scale used when pooling.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input data tensor from the previous operator; dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data.</dd>
+<dt><tt>rois</tt> (non-differentiable) : T</dt>
+<dd>RoIs (Regions of Interest) to pool over. Should be a 2-D tensor of shape (num_rois, 5) given as [[batch_id, x1, y1, x2, y2], ...].</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>RoI pooled output 4-D tensor of shape (num_rois, channels, pooled_shape[0], pooled_shape[1]).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+### <a name="MaxUnpool"></a><a name="maxunpool">**MaxUnpool**</a>
+
+  MaxUnpool essentially computes the partial inverse of the MaxPool op.
+   The input information to this op is typically the output information from a MaxPool op. The first
+   input tensor X is the tensor that needs to be unpooled, which is typically the pooled tensor (first output)
+   from MaxPool. The second input tensor, I, contains the indices to the (locally maximal) elements corresponding
+   to the elements in the first input tensor X. Input tensor I is typically the second output of the MaxPool op.
+   The third (optional) input is a tensor that specifies the output size of the unpooling operation.
+
+  MaxUnpool is intended to do 'partial' inverse of the MaxPool op. 'Partial' because all the non-maximal
+   values from the original input to MaxPool are set to zero in the output of the MaxUnpool op. Pooling
+   the result of an unpooling operation should give back the original input to the unpooling op.
+
+  MaxUnpool can produce the same output size for several input sizes, which makes unpooling op ambiguous.
+   The third input argument, output_size, is meant to disambiguate the op and produce output tensor of
+   known/predictable size.
+
+  In addition to the inputs, MaxUnpool takes three attributes, namely kernel_shape, strides, and pads,
+   which define the exact unpooling op. The attributes typically have the same values as the corresponding
+   pooling op that the unpooling op is trying to invert.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#MaxUnpool-9">9</a>, <a href="Changelog.md#MaxUnpool-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>kernel_shape</tt> : list of ints (required)</dt>
+<dd>The size of the kernel along each axis.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0. The value represent the number of pixels added to the beginning and end part of the corresponding axis. `pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`. This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>Input data tensor that has to be unpooled. This tensor is typically the first output of the MaxPool op.Dimensions for image case are (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data. For non-image case, the dimensions are in the form of (N x C x D1 x D2 ... Dn), where N is the batch size. Optionally, if dimension denotation is in effect, the operation expects the input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>I</tt> (non-differentiable) : T2</dt>
+<dd>Input data tensor containing the indices corresponding to elements in the first input tensor X.This tensor is typically the second output of the MaxPool op.Dimensions must be the same as input tensor X. The indices are linear, i.e. computed considering the tensor as flattened 1-D tensor, assuming row-major storage. Also, the linear indices should not consider padding. So the values in indices are in the range [0, N x C x D1 x ... x Dn).</dd>
+<dt><tt>output_shape</tt> (optional, non-differentiable) : T2</dt>
+<dd>The shape of the output can be explicitly set which will cause pads values to be auto generated. If 'output_shape' is specified, 'pads' values are ignored.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T1</dt>
+<dd>Output data tensor that contains the result of the unpooling.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>with_output_shape</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MaxUnpool",
+    inputs=["xT", "xI", "output_shape"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[2, 2],
+)
+xT = np.array([[[[5, 6], [7, 8]]]], dtype=np.float32)
+xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64)
+output_shape = np.array((1, 1, 5, 5), dtype=np.int64)
+y = np.array(
+    [
+        [
+            [
+                [0, 0, 0, 0, 0],
+                [0, 5, 0, 6, 0],
+                [0, 0, 0, 0, 0],
+                [0, 7, 0, 8, 0],
+                [0, 0, 0, 0, 0],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[xT, xI, output_shape],
+    outputs=[y],
+    name="test_maxunpool_export_with_output_shape",
+)
+```
+
+</details>
+
+
+<details>
+<summary>without_output_shape</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MaxUnpool",
+    inputs=["xT", "xI"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[2, 2],
+)
+xT = np.array([[[[1, 2], [3, 4]]]], dtype=np.float32)
+xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64)
+y = np.array(
+    [[[[0, 0, 0, 0], [0, 1, 0, 2], [0, 0, 0, 0], [0, 3, 0, 4]]]],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[xT, xI],
+    outputs=[y],
+    name="test_maxunpool_export_without_output_shape",
+)
+```
+
+</details>
+
+
+### <a name="Mean"></a><a name="mean">**Mean**</a>
+
+  Element-wise mean of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Mean-1">1</a>, <a href="Changelog.md#Mean-6">6</a>, <a href="Changelog.md#Mean-8">8</a>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for mean.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>mean</tt> (differentiable) : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>mean</summary>
+
+```python
+data_0 = np.array([3, 0, 2]).astype(np.float32)
+data_1 = np.array([1, 3, 4]).astype(np.float32)
+data_2 = np.array([2, 6, 6]).astype(np.float32)
+result = np.array([2, 3, 4]).astype(np.float32)
+node = onnx.helper.make_node(
+    "Mean",
+    inputs=["data_0", "data_1", "data_2"],
+    outputs=["result"],
+)
+expect(
+    node,
+    inputs=[data_0, data_1, data_2],
+    outputs=[result],
+    name="test_mean_example",
+)
+
+node = onnx.helper.make_node(
+    "Mean",
+    inputs=["data_0"],
+    outputs=["result"],
+)
+expect(node, inputs=[data_0], outputs=[data_0], name="test_mean_one_input")
+
+result = np.divide(np.add(data_0, data_1), 2.0)
+node = onnx.helper.make_node(
+    "Mean",
+    inputs=["data_0", "data_1"],
+    outputs=["result"],
+)
+expect(
+    node, inputs=[data_0, data_1], outputs=[result], name="test_mean_two_inputs"
+)
+```
+
+</details>
+
+
+### <a name="MeanVarianceNormalization"></a><a name="meanvariancenormalization">**MeanVarianceNormalization**</a>
+
+  A MeanVarianceNormalization Function: Perform mean variance normalization
+        on the input tensor X using formula: `(X-EX)/sqrt(E(X-EX)^2)`
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#MeanVarianceNormalization-9">9</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axes</tt> : list of ints (default is ['0', '2', '3'])</dt>
+<dd>A list of integers, along which to reduce. The default is to calculate along axes [0,2,3] for calculating mean and variance along each channel. Two variables with the same C-coordinate are associated with the same mean and variance.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>meanvariancenormalization</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MeanVarianceNormalization", inputs=["X"], outputs=["Y"]
+)
+
+input_data = np.array(
+    [
+        [
+            [[0.8439683], [0.5665144], [0.05836735]],
+            [[0.02916367], [0.12964272], [0.5060197]],
+            [[0.79538304], [0.9411346], [0.9546573]],
+        ],
+        [
+            [[0.17730942], [0.46192095], [0.26480448]],
+            [[0.6746842], [0.01665257], [0.62473077]],
+            [[0.9240844], [0.9722341], [0.11965699]],
+        ],
+        [
+            [[0.41356155], [0.9129373], [0.59330076]],
+            [[0.81929934], [0.7862604], [0.11799799]],
+            [[0.69248444], [0.54119414], [0.07513223]],
+        ],
+    ],
+    dtype=np.float32,
+)
+
+# Calculate expected output data
+data_mean = np.mean(input_data, axis=(0, 2, 3), keepdims=1)
+data_mean_squared = np.power(data_mean, 2)
+data_squared = np.power(input_data, 2)
+data_squared_mean = np.mean(data_squared, axis=(0, 2, 3), keepdims=1)
+std = np.sqrt(data_squared_mean - data_mean_squared)
+expected_output = (input_data - data_mean) / (std + 1e-9)
+
+expect(node, inputs=[input_data], outputs=[expected_output], name="test_mvn")
+```
+
+</details>
+
+
+### <a name="MelWeightMatrix"></a><a name="melweightmatrix">**MelWeightMatrix**</a>
+
+  Generate a MelWeightMatrix that can be used to re-weight a Tensor containing a linearly sampled frequency spectra (from DFT or STFT) into num_mel_bins frequency information based on the [lower_edge_hertz, upper_edge_hertz] range on the mel scale.
+  This function defines the mel scale in terms of a frequency in hertz according to the following formula:
+
+      mel(f) = 2595 * log10(1 + f/700)
+
+  In the returned matrix, all the triangles (filterbanks) have a peak value of 1.0.
+
+  The returned MelWeightMatrix can be used to right-multiply a spectrogram S of shape [frames, num_spectrogram_bins] of linear scale spectrum values (e.g. STFT magnitudes) to generate a "mel spectrogram" M of shape [frames, num_mel_bins].
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>output_datatype</tt> : int (default is 1)</dt>
+<dd>The data type of the output tensor. Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T3. The default value is 1 = FLOAT. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>num_mel_bins</tt> (non-differentiable) : T1</dt>
+<dd>The number of bands in the mel spectrum.</dd>
+<dt><tt>dft_length</tt> (non-differentiable) : T1</dt>
+<dd>The size of the original DFT. The size of the original DFT is used to infer the size of the onesided DFT, which is understood to be floor(dft_length/2) + 1, i.e. the spectrogram only contains the nonredundant DFT bins.</dd>
+<dt><tt>sample_rate</tt> (non-differentiable) : T1</dt>
+<dd>Samples per second of the input signal used to create the spectrogram. Used to figure out the frequencies corresponding to each spectrogram bin, which dictates how they are mapped into the mel scale.</dd>
+<dt><tt>lower_edge_hertz</tt> (non-differentiable) : T2</dt>
+<dd>Lower bound on the frequencies to be included in the mel spectrum. This corresponds to the lower edge of the lowest triangular band.</dd>
+<dt><tt>upper_edge_hertz</tt> (non-differentiable) : T2</dt>
+<dd>The desired top edge of the highest frequency band.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T3</dt>
+<dd>The Mel Weight Matrix. The output has the shape: [floor(dft_length/2) + 1][num_mel_bins].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain to integer tensors.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain to float tensors</dd>
+<dt><tt>T3</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain to any numerical types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>melweightmatrix</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MelWeightMatrix",
+    inputs=[
+        "num_mel_bins",
+        "dft_length",
+        "sample_rate",
+        "lower_edge_hertz",
+        "upper_edge_hertz",
+    ],
+    outputs=["output"],
+)
+
+num_mel_bins = np.int32(8)
+dft_length = np.int32(16)
+sample_rate = np.int32(8192)
+lower_edge_hertz = np.float32(0)
+upper_edge_hertz = np.float32(8192 / 2)
+
+num_spectrogram_bins = dft_length // 2 + 1
+frequency_bins = np.arange(0, num_mel_bins + 2)
+
+low_frequency_mel = 2595 * np.log10(1 + lower_edge_hertz / 700)
+high_frequency_mel = 2595 * np.log10(1 + upper_edge_hertz / 700)
+mel_step = (high_frequency_mel - low_frequency_mel) / frequency_bins.shape[0]
+
+frequency_bins = frequency_bins * mel_step + low_frequency_mel
+frequency_bins = 700 * (np.power(10, (frequency_bins / 2595)) - 1)
+frequency_bins = ((dft_length + 1) * frequency_bins) // sample_rate
+frequency_bins = frequency_bins.astype(int)
+
+output = np.zeros((num_spectrogram_bins, num_mel_bins))
+output.flags.writeable = True
+
+for i in range(num_mel_bins):
+    lower_frequency_value = frequency_bins[i]  # left
+    center_frequency_point = frequency_bins[i + 1]  # center
+    higher_frequency_point = frequency_bins[i + 2]  # right
+    low_to_center = center_frequency_point - lower_frequency_value
+    if low_to_center == 0:
+        output[center_frequency_point, i] = 1
+    else:
+        for j in range(lower_frequency_value, center_frequency_point + 1):
+            output[j, i] = float(j - lower_frequency_value) / float(
+                low_to_center
+            )
+    center_to_high = higher_frequency_point - center_frequency_point
+    if center_to_high > 0:
+        for j in range(center_frequency_point, higher_frequency_point):
+            output[j, i] = float(higher_frequency_point - j) / float(
+                center_to_high
+            )
+
+# Expected output
+# 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+output = output.astype(np.float32)
+expect(
+    node,
+    inputs=[
+        num_mel_bins,
+        dft_length,
+        sample_rate,
+        lower_edge_hertz,
+        upper_edge_hertz,
+    ],
+    outputs=[output],
+    name="test_melweightmatrix",
+)
+```
+
+</details>
+
+
+### <a name="Min"></a><a name="min">**Min**</a>
+
+  Element-wise min of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Min-1">1</a>, <a href="Changelog.md#Min-6">6</a>, <a href="Changelog.md#Min-8">8</a>, <a href="Changelog.md#Min-12">12</a>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for min.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>min</tt> (differentiable) : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>min</summary>
+
+```python
+data_0 = np.array([3, 2, 1]).astype(np.float32)
+data_1 = np.array([1, 4, 4]).astype(np.float32)
+data_2 = np.array([2, 5, 0]).astype(np.float32)
+result = np.array([1, 2, 0]).astype(np.float32)
+node = onnx.helper.make_node(
+    "Min",
+    inputs=["data_0", "data_1", "data_2"],
+    outputs=["result"],
+)
+expect(
+    node,
+    inputs=[data_0, data_1, data_2],
+    outputs=[result],
+    name="test_min_example",
+)
+
+node = onnx.helper.make_node(
+    "Min",
+    inputs=["data_0"],
+    outputs=["result"],
+)
+expect(node, inputs=[data_0], outputs=[data_0], name="test_min_one_input")
+
+result = np.minimum(data_0, data_1)
+node = onnx.helper.make_node(
+    "Min",
+    inputs=["data_0", "data_1"],
+    outputs=["result"],
+)
+expect(
+    node, inputs=[data_0, data_1], outputs=[result], name="test_min_two_inputs"
+)
+```
+
+</details>
+
+
+<details>
+<summary>min_all_numeric_types</summary>
+
+```python
+for op_dtype in all_numeric_dtypes:
+    data_0 = np.array([3, 2, 1]).astype(op_dtype)
+    data_1 = np.array([1, 4, 4]).astype(op_dtype)
+    result = np.array([1, 2, 1]).astype(op_dtype)
+    node = onnx.helper.make_node(
+        "Min",
+        inputs=["data_0", "data_1"],
+        outputs=["result"],
+    )
+    expect(
+        node,
+        inputs=[data_0, data_1],
+        outputs=[result],
+        name=f"test_min_{np.dtype(op_dtype).name}",
+    )
+```
+
+</details>
+
+
+### <a name="Mish"></a><a name="mish">**Mish**</a>
+
+  Mish: A Self Regularized Non-Monotonic Neural Activation Function.
+
+  Perform the linear unit element-wise on the input tensor X using formula:
+
+  ```
+  mish(x) = x * tanh(softplus(x)) = x * tanh(ln(1 + e^{x}))
+  ```
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Mish-18">18</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input X and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>mish</summary>
+
+```python
+node = onnx.helper.make_node("Mish", inputs=["X"], outputs=["Y"])
+
+input_data = np.linspace(-10, 10, 10000, dtype=np.float32)
+
+# Calculate expected output data
+expected_output = input_data * np.tanh(np.log1p(np.exp(input_data)))
+
+expect(node, inputs=[input_data], outputs=[expected_output], name="test_mish")
+```
+
+</details>
+
+
+### <a name="Mod"></a><a name="mod">**Mod**</a>
+
+  Performs an element-wise binary modulo operation.
+  The semantics and supported data types depend on the value of the `fmod` attribute which must be `0` (default), or `1`.
+
+  If the `fmod` attribute is set to `0`, `T` is constrained to integer data types and the semantics follow that of the Python `%`-operator.
+  The sign of the result is that of the divisor.
+
+  If `fmod` is set to `1`, the behavior of this operator follows that of the `fmod` function in C and `T` is constrained to floating point data types.
+  The result of this operator is the remainder of the division operation `x / y` where `x` and `y` are respective elements of `A` and `B`. The result is exactly the value `x - n * y`, where `n` is `x / y` with its fractional part truncated.
+  The returned value has the same sign as `x` (except if `x` is `-0`) and is less or equal to `|y|` in magnitude.
+  The following special cases apply when `fmod` is set to `1`:
+  - If `x` is `-0` and `y` is greater than zero, either `+0` or `-0` may be returned.
+  - If `x` is `±∞` and `y` is not `NaN`, `NaN` is returned.
+  - If `y` is `±0` and `x` is not `NaN`, `NaN` should be returned.
+  - If `y` is `±∞` and `x` is finite, `x` is returned.
+  - If either argument is `NaN`, `NaN` is returned.
+
+  This operator supports **multidirectional (i.e., NumPy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Mod-10">10</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>fmod</tt> : int (default is 0)</dt>
+<dd>Whether the operator should behave like fmod (default=0 meaning it will do integer mods); Set this to 1 to force fmod treatment</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>Dividend tensor</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Divisor tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Remainder tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to high-precision numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>mod_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.arange(0, 30).reshape([3, 2, 5]).astype(np.int32)
+y = np.array([7]).astype(np.int32)
+z = np.mod(x, y)
+#   array([[[0, 1, 2, 3, 4],
+#     [5, 6, 0, 1, 2]],
+
+#    [[3, 4, 5, 6, 0],
+#     [1, 2, 3, 4, 5]],
+
+#    [[6, 0, 1, 2, 3],
+#     [4, 5, 6, 0, 1]]], dtype=int32)
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_broadcast")
+```
+
+</details>
+
+
+<details>
+<summary>mod_int64_fmod</summary>
+
+```python
+node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64)
+z = np.fmod(x, y)  # expected output [ 0,  1,  5,  0, -1,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_int64_fmod")
+```
+
+</details>
+
+
+<details>
+<summary>mod_mixed_sign_float16</summary>
+
+```python
+node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float16)
+y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float16)
+z = np.fmod(
+    x, y
+)  # expected output [-0.10156, 0.3984 , 5. , 0.10156, -0.3984 ,  3.]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float16")
+```
+
+</details>
+
+
+<details>
+<summary>mod_mixed_sign_float32</summary>
+
+```python
+node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float32)
+y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float32)
+z = np.fmod(
+    x, y
+)  # expected output [-0.10000038, 0.39999962, 5. , 0.10000038, -0.39999962, 3.]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float32")
+```
+
+</details>
+
+
+<details>
+<summary>mod_mixed_sign_float64</summary>
+
+```python
+node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float64)
+y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float64)
+z = np.fmod(x, y)  # expected output [-0.1,  0.4,  5. ,  0.1, -0.4,  3.]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float64")
+```
+
+</details>
+
+
+<details>
+<summary>mod_mixed_sign_int16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int16)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int16)
+z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int16")
+```
+
+</details>
+
+
+<details>
+<summary>mod_mixed_sign_int32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int32)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int32)
+z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int32")
+```
+
+</details>
+
+
+<details>
+<summary>mod_mixed_sign_int64</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64)
+z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int64")
+```
+
+</details>
+
+
+<details>
+<summary>mod_mixed_sign_int8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int8)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int8)
+z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int8")
+```
+
+</details>
+
+
+<details>
+<summary>mod_uint16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([4, 7, 5]).astype(np.uint16)
+y = np.array([2, 3, 8]).astype(np.uint16)
+z = np.mod(x, y)  # expected output [0, 1, 5]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint16")
+```
+
+</details>
+
+
+<details>
+<summary>mod_uint32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([4, 7, 5]).astype(np.uint32)
+y = np.array([2, 3, 8]).astype(np.uint32)
+z = np.mod(x, y)  # expected output [0, 1, 5]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint32")
+```
+
+</details>
+
+
+<details>
+<summary>mod_uint64</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([4, 7, 5]).astype(np.uint64)
+y = np.array([2, 3, 8]).astype(np.uint64)
+z = np.mod(x, y)  # expected output [0, 1, 5]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>mod_uint8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([4, 7, 5]).astype(np.uint8)
+y = np.array([2, 3, 8]).astype(np.uint8)
+z = np.mod(x, y)  # expected output [0, 1, 5]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint8")
+```
+
+</details>
+
+
+### <a name="Mul"></a><a name="mul">**Mul**</a>
+
+  Performs element-wise binary multiplication (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Mul-1">1</a>, <a href="Changelog.md#Mul-6">6</a>, <a href="Changelog.md#Mul-7">7</a>, <a href="Changelog.md#Mul-13">13</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>mul</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mul",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.float32)
+z = x * y  # expected output [4., 10., 18.]
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.int8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_int8")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.int16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_int16")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint8")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint16")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint32")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>mul_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mul",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_bcast")
+```
+
+</details>
+
+
+### <a name="Multinomial"></a><a name="multinomial">**Multinomial**</a>
+
+  Generate a tensor of samples from a multinomial distribution according to the probabilities
+  of each of the possible outcomes.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Multinomial-7">7</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int (default is 6)</dt>
+<dd>(Optional) The data type for the elements of the output tensor, if not specified, we will use int32.</dd>
+<dt><tt>sample_size</tt> : int (default is 1)</dt>
+<dd>Number of times to sample.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor with shape [batch_size, class_size], where class_size is the number of all possible outcomes. Each value along the axis zero represents the unnormalized log-probability of each corresponding outcome in a batch.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor with shape [batch_size, sample_size], where sample_size is the number of times to sample. Each value along the axis zero represents the outcome of the corresponding sample in a batch.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain output types to integral tensors.</dd>
+</dl>
+
+
+### <a name="Neg"></a><a name="neg">**Neg**</a>
+
+  Neg takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where each element flipped sign, y = -x, is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Neg-1">1</a>, <a href="Changelog.md#Neg-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(int32), tensor(int8), tensor(int16), tensor(int64), tensor(float16), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to signed numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Neg",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-4, 2]).astype(np.float32)
+y = np.negative(x)  # expected output [4., -2.],
+expect(node, inputs=[x], outputs=[y], name="test_neg_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.negative(x)
+expect(node, inputs=[x], outputs=[y], name="test_neg")
+```
+
+</details>
+
+
+### <a name="NegativeLogLikelihoodLoss"></a><a name="negativeloglikelihoodloss">**NegativeLogLikelihoodLoss**</a>
+
+  A NegativeLogLikelihoodLoss operator computes (weighted) negative log likelihood loss.
+  Its "input" tensor has the shape of (N, C, d1, d2, ..., dk) where k >= 0.
+  The "input" tensor contains log-probabilities for input[n, :, d_1, d_2,..., d_k] being in a class of [0, C).
+  The operator's "target" input tensor has the shape of (N, d1, d2, ..., dk). It encodes class labels (one of C classes)
+  or it may contain a special value (indicated by an attribute ignore_index) for N x d1 x d2 x ... x dk samples.
+  The loss value for input[n, :, d_1, d_2,...d_k] being classified as class c = target[n][d_1][d_2]...[d_k] is computed as:
+
+  ```
+  loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k].
+  ```
+
+  When an optional "weight" is provided, the sample loss is calculated as:
+
+  ```
+  loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k] * weight[c].
+  ```
+
+  loss is zero for the case when target-value equals ignore_index.
+
+  ```
+  loss[n][d_1][d_2]...[d_k] = 0, when target[n][d_1][d_2]...[d_k] = ignore_index
+  ```
+
+  If "reduction" attribute is set to "none", the operator's output will be the above loss with shape (N, d1, d2, ..., dk).
+  If "reduction" attribute is set to "mean" (the default attribute value), the output loss is (weight) averaged:
+
+  ```
+  mean(loss), if "weight" is not provided,
+  ```
+
+  or if weight is provided,
+
+  ```
+  sum(loss) / sum(weight[target[n][d_1][d_2]...[d_k]]]), for all samples.
+  ```
+
+  If "reduction" attribute is set to "sum", the output is a scalar: `sum(loss)`.
+
+  See also https://pytorch.org/docs/stable/nn.html#torch.nn.NLLLoss.
+
+  Example 1:
+
+  ```
+  // negative log likelihood loss, "none" reduction
+  N, C, d1 = 2, 3, 2
+  input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+            [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+  target = [[2, 1], [0, 2]]
+
+  loss = np.zeros((N, d1))
+  for n in range(N):
+      for d_1 in range(d1):
+          c = target[n][d_1]
+          loss[n][d_1] = -input[n][c][d_1]
+
+  // print(loss)
+  // [[-3. -2.]
+  //  [-0. -2.]]
+  ```
+
+  Example 2:
+
+  ```
+  // weighted negative log likelihood loss, sum reduction
+  N, C, d1 = 2, 3, 2
+  input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+          [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+  target = [[2, 1], [0, 2]]
+  weight = [0.2, 0.3, 0.1]
+  loss = np.zeros((N, d1))
+  for n in range(N):
+      for d_1 in range(d1):
+          c = target[n][d_1]
+          loss[n][d_1] = -input[n][c][d_1] * weight[c]
+
+  loss = np.sum(loss)
+  // print(loss)
+  // -1.1
+  ```
+
+  Example 3:
+
+  ```
+  // weighted negative log likelihood loss, mean reduction
+  N, C, d1 = 2, 3, 2
+  input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+          [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+  target = [[2, 1], [0, 2]]
+  weight = [0.2, 0.3, 0.1]
+  loss = np.zeros((N, d1))
+  weight_total = 0
+  for n in range(N):
+      for d_1 in range(d1):
+          c = target[n][d_1]
+          loss[n][d_1] = -input[n][c][d_1] * weight[c]
+          weight_total = weight_total + weight[c]
+
+  loss = np.sum(loss) / weight_total
+  // print(loss)
+  // -1.57
+  ```
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#NegativeLogLikelihoodLoss-12">12</a>, <a href="Changelog.md#NegativeLogLikelihoodLoss-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>ignore_index</tt> : int</dt>
+<dd>Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.</dd>
+<dt><tt>reduction</tt> : string (default is mean)</dt>
+<dd>Type of reduction to apply to loss: none, sum, mean (default). 'none': the output is the loss for each sample. 'sum': the output will be summed. 'mean': the sum of the output will be divided by the sum of applied weights.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of shape (N, C) or (N, C, d1, d2, ..., dk).</dd>
+<dt><tt>target</tt> (non-differentiable) : Tind</dt>
+<dd>Target tensor of shape (N) or (N, d1, d2, ..., dk). Target element value shall be in range of [0, C). If ignore_index is specified, it may have a value outside [0, C) and the target values should either be in the range [0, C) or have the value ignore_index.</dd>
+<dt><tt>weight</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional rescaling weight tensor. If given, it has to be a tensor of size C. Otherwise, it is treated as if having all ones.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>loss</tt> (differentiable) : T</dt>
+<dd>The negative log likelihood loss</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input, weight, and output types to floating-point tensors.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain target to integer types</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>input_shape_is_NC</summary>
+
+```python
+reduction = "none"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C = 3, 5
+np.random.seed(0)
+input = np.random.rand(N, C).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N,)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NC",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1</summary>
+
+```python
+reduction = "mean"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, d1 = 3, 5, 2
+np.random.seed(0)
+input = np.random.rand(N, C, d1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(1)
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, d1 = 3, 5, 2
+np.random.seed(0)
+input = np.random.rand(N, C, d1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+target[0][0] = np.int64(1)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1_mean_weight_negative_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(-1)
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1 = 3, 5, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64)
+target[0][0] = -1
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1_mean_weight_negative_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1_weight</summary>
+
+```python
+reduction = "mean"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, d1 = 3, 5, 2
+np.random.seed(0)
+input = np.random.rand(N, C, d1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1_weight",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1_weight_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(1)
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, d1 = 3, 5, 2
+np.random.seed(0)
+input = np.random.rand(N, C, d1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+target[0][0] = np.int64(1)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1_weight_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2</summary>
+
+```python
+reduction = "none"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2_no_weight_reduction_mean_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(1)
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+target[0][0][0] = np.int64(1)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_no_weight_reduction_mean_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2_reduction_mean</summary>
+
+```python
+reduction = "mean"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_reduction_mean",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2_reduction_sum</summary>
+
+```python
+reduction = "sum"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_reduction_sum",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2_with_weight</summary>
+
+```python
+reduction = "none"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_with_weight",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2_with_weight_reduction_mean</summary>
+
+```python
+reduction = "mean"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_with_weight_reduction_mean",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2_with_weight_reduction_sum</summary>
+
+```python
+reduction = "sum"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_with_weight_reduction_sum",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2_with_weight_reduction_sum_ii</summary>
+
+```python
+reduction = "sum"
+ignore_index = np.int64(0)
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+target[0][0][0] = np.int64(0)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_with_weight_reduction_sum_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3_none_no_weight_negative_ii</summary>
+
+```python
+reduction = "none"
+ignore_index = np.int64(-5)
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype(
+    np.int64
+)
+target[0][0][0][0] = -5
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2d3_none_no_weight_negative_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3_sum_weight_high_ii</summary>
+
+```python
+reduction = "sum"
+ignore_index = np.int64(10)
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C = 3, 5
+np.random.seed(0)
+input = np.random.rand(N, C).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N)).astype(np.int64)
+target[0] = 10
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2d3_sum_weight_high_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_mean_weight</summary>
+
+```python
+reduction = "mean"
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+target = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2d3d4d5_mean_weight",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_none_no_weight</summary>
+
+```python
+reduction = "none"
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+target = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2d3d4d5_none_no_weight",
+)
+```
+
+</details>
+
+
+### <a name="NonMaxSuppression"></a><a name="nonmaxsuppression">**NonMaxSuppression**</a>
+
+  Filter out boxes that have high intersection-over-union (IOU) overlap with previously selected boxes.
+  Bounding boxes with score less than score_threshold are removed. Bounding box format is indicated by attribute center_point_box.
+  Boxes are suppressed if their IOU with a previously selected box is strictly greater than iou_threshold (i.e., boxes with IOU exactly equal to the threshold are kept).
+  Note that this algorithm is agnostic to where the origin is in the coordinate system and more generally is invariant to
+  orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system
+  result in the same boxes being selected by the algorithm.
+  The selected_indices output is a set of integers indexing into the input collection of bounding boxes representing the selected boxes.
+  The bounding box coordinates corresponding to the selected indices can then be obtained using the Gather or GatherND operation.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#NonMaxSuppression-10">10</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>center_point_box</tt> : int (default is 0)</dt>
+<dd>Integer indicate the format of the box data. The default is 0. 0 - the box data is supplied as [y1, x1, y2, x2] where (y1, x1) and (y2, x2) are the coordinates of any diagonal pair of box corners and the coordinates can be provided as normalized (i.e., lying in the interval [0, 1]) or absolute. Mostly used for TF models. 1 - the box data is supplied as [x_center, y_center, width, height]. Mostly used for Pytorch models.</dd>
+</dl>
+
+#### Inputs (2 - 5)
+
+<dl>
+<dt><tt>boxes</tt> : tensor(float)</dt>
+<dd>An input tensor with shape [num_batches, spatial_dimension, 4]. The single box data format is indicated by center_point_box.</dd>
+<dt><tt>scores</tt> : tensor(float)</dt>
+<dd>An input tensor with shape [num_batches, num_classes, spatial_dimension]</dd>
+<dt><tt>max_output_boxes_per_class</tt> (optional) : tensor(int64)</dt>
+<dd>Integer representing the maximum number of boxes to be selected per batch per class. It is a scalar. Default to 0, which means no output.</dd>
+<dt><tt>iou_threshold</tt> (optional) : tensor(float)</dt>
+<dd>Float representing the threshold for deciding whether boxes overlap too much with respect to IOU. Boxes with IoU strictly greater than this threshold are suppressed. It is scalar. Value range [0, 1]. Default to 0.</dd>
+<dt><tt>score_threshold</tt> (optional) : tensor(float)</dt>
+<dd>Float representing the threshold for deciding when to remove boxes based on score. It is a scalar.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>selected_indices</tt> : tensor(int64)</dt>
+<dd>selected indices from the boxes tensor. [num_selected_indices, 3], the selected index format is [batch_index, class_index, box_index].</dd>
+</dl>
+
+#### Type Constraints
+
+
+
+#### Examples
+
+<details>
+<summary>nonmaxsuppression_center_point_box_format</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+    center_point_box=1,
+)
+boxes = np.array(
+    [
+        [
+            [0.5, 0.5, 1.0, 1.0],
+            [0.5, 0.6, 1.0, 1.0],
+            [0.5, 0.4, 1.0, 1.0],
+            [0.5, 10.5, 1.0, 1.0],
+            [0.5, 10.6, 1.0, 1.0],
+            [0.5, 100.5, 1.0, 1.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_center_point_box_format",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nonmaxsuppression_flipped_coordinates</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [1.0, 1.0, 0.0, 0.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, 0.9, 1.0, -0.1],
+            [0.0, 10.0, 1.0, 11.0],
+            [1.0, 10.1, 0.0, 11.1],
+            [1.0, 101.0, 0.0, 100.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_flipped_coordinates",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nonmaxsuppression_identical_boxes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array(
+    [[[0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9]]]
+).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 0]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_identical_boxes",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nonmaxsuppression_iou_threshold_boundary</summary>
+
+```python
+"""Test boundary condition where IoU exactly equals threshold.
+
+This test verifies that the comparison is strict (>), not inclusive (>=).
+When IoU exactly equals the threshold, boxes should be KEPT, not suppressed.
+This follows PyTorch's NMS implementation.
+"""
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+# Two boxes with 50% overlap in each dimension
+# box1=[0,0,1,1], box2=[0.5,0.5,1.5,1.5]
+# Intersection area = 0.5 * 0.5 = 0.25
+# Union area = 1.0 + 1.0 - 0.25 = 1.75
+# IoU = 0.25 / 1.75 (exact value computed below as float32)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],  # box 0
+            [0.5, 0.5, 1.5, 1.5],  # box 1 - overlaps box 0
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.8]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+# Compute the exact IoU value and use it as threshold
+# This ensures the threshold exactly equals the IoU
+exact_iou = np.float32(0.25 / 1.75)
+iou_threshold = np.array([exact_iou]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+# Both boxes should be selected because IoU == threshold (not > threshold)
+selected_indices = np.array([[0, 0, 0], [0, 0, 1]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_iou_threshold_boundary",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nonmaxsuppression_limit_output_size</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([2]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_limit_output_size",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nonmaxsuppression_single_box</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array([[[0.0, 0.0, 1.0, 1.0]]]).astype(np.float32)
+scores = np.array([[[0.9]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 0]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_single_box",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nonmaxsuppression_suppress_by_IOU</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_suppress_by_IOU",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nonmaxsuppression_suppress_by_IOU_and_scores</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.4]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_suppress_by_IOU_and_scores",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nonmaxsuppression_two_batches</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ],
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ],
+    ]
+).astype(np.float32)
+scores = np.array(
+    [[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]], [[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]
+).astype(np.float32)
+max_output_boxes_per_class = np.array([2]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array(
+    [[0, 0, 3], [0, 0, 0], [1, 0, 3], [1, 0, 0]]
+).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_two_batches",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nonmaxsuppression_two_classes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array(
+    [[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3], [0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]
+).astype(np.float32)
+max_output_boxes_per_class = np.array([2]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array(
+    [[0, 0, 3], [0, 0, 0], [0, 1, 3], [0, 1, 0]]
+).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_two_classes",
+)
+```
+
+</details>
+
+
+### <a name="NonZero"></a><a name="nonzero">**NonZero**</a>
+
+  Returns the indices of the elements that are non-zero
+      (in row-major order - by dimension).
+      NonZero behaves similar to numpy.nonzero:
+      https://docs.scipy.org/doc/numpy/reference/generated/numpy.nonzero.html,
+      but for scalar input, NonZero produces output shape (0, N) instead of (1, N), which is different from Numpy's behavior.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#NonZero-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>input</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>output</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to all tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>nonzero</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonZero",
+    inputs=["condition"],
+    outputs=["result"],
+)
+
+condition = np.array([[1, 0], [1, 1]], dtype=bool)
+result = np.array(
+    np.nonzero(condition), dtype=np.int64
+)  # expected output [[0, 1, 1], [0, 0, 1]]
+expect(node, inputs=[condition], outputs=[result], name="test_nonzero_example")
+```
+
+</details>
+
+
+### <a name="Not"></a><a name="not">**Not**</a>
+
+  Returns the negation of the input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 1 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input/output to boolean tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>not</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Not",
+    inputs=["x"],
+    outputs=["not"],
+)
+
+# 2d
+x = (np.random.randn(3, 4) > 0).astype(bool)
+expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_2d")
+
+# 3d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_3d")
+
+# 4d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_4d")
+```
+
+</details>
+
+
+### <a name="OneHot"></a><a name="onehot">**OneHot**</a>
+
+  Produces a one-hot tensor based on inputs.
+      The locations represented by the index values in the 'indices' input tensor will have 'on_value'
+      and the other locations will have 'off_value' in the output tensor, where 'on_value' and 'off_value'
+      are specified as part of required input argument 'values', which is a two-element tensor of format
+      [off_value, on_value]. The rank of the output tensor will be one greater than the rank of the
+      input tensor. The additional dimension is for one-hot representation. The additional dimension will
+      be inserted at the position specified by 'axis'. If 'axis' is not specified then then additional
+      dimension will be inserted as the innermost dimension, i.e. axis=-1. The size of the additional
+      dimension is specified by required scalar input 'depth'. The type of the output tensor is the same
+      as the type of the 'values' input. Any entries in the 'indices' input tensor with values outside
+      the range [-depth, depth-1] will result in one-hot representation with all 'off_value' values in the
+      output tensor.
+
+      when axis = 0:
+      output[input[i, j, k], i, j, k] = 1 for all i, j, k and 0 otherwise.
+
+      when axis = -1:
+      output[i, j, k, input[i, j, k]] = 1 for all i, j, k and 0 otherwise.
+
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#OneHot-9">9</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>(Optional) Axis along which one-hot representation in added. Default: axis=-1. axis=-1 means that the additional dimension will be inserted as the innermost/last dimension in the output tensor. Negative value means counting dimensions from the back. Accepted range is [-r-1, r] where r = rank(indices).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>indices</tt> (non-differentiable) : T1</dt>
+<dd>Input tensor containing indices. Any entries in the 'indices' input tensor with values outside the range [-depth, depth-1] will result in one-hot representation with all 'off_value' values in the output tensor.In case 'indices' is of non-integer type, the values will be casted to int64 before use.</dd>
+<dt><tt>depth</tt> (non-differentiable) : T2</dt>
+<dd>Scalar or Rank 1 tensor containing exactly one element, specifying the number of classes in one-hot tensor. This is also the size of the one-hot dimension (specified by 'axis' attribute) added on in the output tensor. The values in the 'indices' input tensor are expected to be in the range [-depth, depth-1]. In case 'depth' is of non-integer type, it will be casted to int64 before use.</dd>
+<dt><tt>values</tt> (non-differentiable) : T3</dt>
+<dd>Rank 1 tensor containing exactly two elements, in the format [off_value, on_value], where 'on_value' is the value used for filling locations specified in 'indices' input tensor, and 'off_value' is the value used for filling locations other than those specified in 'indices' input tensor. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T3</dt>
+<dd>Tensor of rank one greater than input tensor 'indices', i.e. rank(output) = rank(indices) + 1. The data type for the elements of the output tensor is the same as the type of input 'values' is used.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to only numeric types.</dd>
+<dt><tt>T2</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to only numeric types.</dd>
+<dt><tt>T3</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>with_axis</summary>
+
+```python
+axisValue = 1
+on_value = 3
+off_value = 1
+output_type = np.float32
+node = onnx.helper.make_node(
+    "OneHot",
+    inputs=["indices", "depth", "values"],
+    outputs=["y"],
+    axis=axisValue,
+)
+indices = np.array([[1, 9], [2, 4]], dtype=np.float32)
+depth = np.float32(10)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_with_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>with_negative_axis</summary>
+
+```python
+axisValue = -2
+on_value = 3
+off_value = 1
+output_type = np.float32
+node = onnx.helper.make_node(
+    "OneHot",
+    inputs=["indices", "depth", "values"],
+    outputs=["y"],
+    axis=axisValue,
+)
+indices = np.array([[1, 9], [2, 4]], dtype=np.float32)
+depth = np.float32(10)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_with_negative_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>with_negative_indices</summary>
+
+```python
+axisValue = 1
+on_value = 3
+off_value = 1
+output_type = np.float32
+node = onnx.helper.make_node(
+    "OneHot",
+    inputs=["indices", "depth", "values"],
+    outputs=["y"],
+    axis=axisValue,
+)
+indices = np.array([0, -7, -8], dtype=np.int64)
+
+# print(y)
+# [[3. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
+#  [1. 1. 1. 3. 1. 1. 1. 1. 1. 1.]
+#  [1. 1. 3. 1. 1. 1. 1. 1. 1. 1.]]
+
+depth = np.float32(10)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_negative_indices",
+)
+```
+
+</details>
+
+
+<details>
+<summary>with_out_of_range_indices</summary>
+
+```python
+axisValue = 1
+on_value = 3
+off_value = 1
+output_type = np.float32
+node = onnx.helper.make_node(
+    "OneHot",
+    inputs=["indices", "depth", "values"],
+    outputs=["y"],
+    axis=axisValue,
+)
+# Indices outside [-depth, depth-1] map to an all-off_value row.
+indices = np.array([5, -6, -1], dtype=np.int64)
+
+# print(y)
+# [[1. 1. 1. 1. 1.]
+#  [1. 1. 1. 1. 1.]
+#  [1. 1. 1. 1. 3.]]
+
+depth = np.float32(5)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_out_of_range_indices",
+)
+```
+
+</details>
+
+
+<details>
+<summary>without_axis</summary>
+
+```python
+on_value = 5
+off_value = 2
+output_type = np.int32
+node = onnx.helper.make_node(
+    "OneHot", inputs=["indices", "depth", "values"], outputs=["y"]
+)
+indices = np.array([0, 7, 8], dtype=np.int64)
+depth = np.float32(12)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_without_axis",
+)
+```
+
+</details>
+
+
+### <a name="Optional"></a><a name="optional">**Optional**</a>
+
+  Constructs an optional-type value containing either an empty optional of a certain type specified by the attribute,
+  or a non-empty value containing the input element.
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>type</tt> : type_proto</dt>
+<dd>Type of the element in the optional output</dd>
+</dl>
+
+#### Inputs (0 - 1)
+
+<dl>
+<dt><tt>input</tt> (optional) : V</dt>
+<dd>The input element.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : O</dt>
+<dd>The optional output enclosing the input element.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input type to all tensor and sequence types.</dd>
+<dt><tt>O</tt> : optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128))</dt>
+<dd>Constrain output type to all optional tensor or optional sequence types.</dd>
+</dl>
+
+
+### <a name="OptionalGetElement"></a><a name="optionalgetelement">**OptionalGetElement**</a>
+
+  If the input is a tensor or sequence type, it returns the input.
+  If the input is an optional type, it outputs the element in the input.
+  It is an error if the input is an empty optional-type (i.e. does not have an element) and the behavior is undefined in this case.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#OptionalGetElement-15">15</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : O</dt>
+<dd>The optional input.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : V</dt>
+<dd>Output element in the optional input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>O</tt> : optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input type to optional tensor and optional sequence types.</dd>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output type to all tensor or sequence types.</dd>
+</dl>
+
+
+### <a name="OptionalHasElement"></a><a name="optionalhaselement">**OptionalHasElement**</a>
+
+  Returns true if (1) the input is an optional-type and contains an element,
+  or, (2) the input is a tensor or sequence type.
+  If the input is not provided or is an empty optional-type, this op returns false.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#OptionalHasElement-15">15</a>
+
+#### Inputs (0 - 1)
+
+<dl>
+<dt><tt>input</tt> (optional) : O</dt>
+<dd>The optional input.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : B</dt>
+<dd>A scalar boolean tensor. If true, it indicates that optional-type input contains an element. Otherwise, it is empty.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>O</tt> : optional(seq(tensor(uint8))), optional(seq(tensor(uint16))), optional(seq(tensor(uint32))), optional(seq(tensor(uint64))), optional(seq(tensor(int8))), optional(seq(tensor(int16))), optional(seq(tensor(int32))), optional(seq(tensor(int64))), optional(seq(tensor(float16))), optional(seq(tensor(float))), optional(seq(tensor(double))), optional(seq(tensor(string))), optional(seq(tensor(bool))), optional(seq(tensor(complex64))), optional(seq(tensor(complex128))), optional(tensor(uint8)), optional(tensor(uint16)), optional(tensor(uint32)), optional(tensor(uint64)), optional(tensor(int8)), optional(tensor(int16)), optional(tensor(int32)), optional(tensor(int64)), optional(tensor(float16)), optional(tensor(float)), optional(tensor(double)), optional(tensor(string)), optional(tensor(bool)), optional(tensor(complex64)), optional(tensor(complex128)), tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input type to optional tensor and optional sequence types.</dd>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Constrain output to a boolean tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>empty</summary>
+
+```python
+optional = None
+
+tensor_type_proto = onnx.helper.make_tensor_type_proto(
+    elem_type=onnx.TensorProto.INT32, shape=[]
+)
+optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)
+
+# OptionalHasElement takes a tensor or optional as input
+for input_type_proto in [tensor_type_proto, optional_type_proto]:
+    input_name_options = {
+        "empty": "optional_input",
+        "empty_no_input_name": "",
+        "empty_no_input": None,
+    }
+    for test_name_surfix, input_name in input_name_options.items():
+        if input_type_proto == tensor_type_proto and input_name:
+            # the input tensor cannot be empty if input name is provided.
+            continue
+        node = onnx.helper.make_node(
+            "OptionalHasElement",
+            inputs=[] if input_name is None else [input_name],
+            outputs=["output"],
+        )
+        output = optional_has_element_reference_implementation(optional)
+        test_name = (
+            "test_optional_has_element_"
+            + test_name_surfix
+            + (
+                "_optional_input"
+                if input_type_proto == optional_type_proto
+                else "_tensor_input"
+            )
+        )
+        expect(
+            node,
+            inputs=[optional] if input_name else [],
+            outputs=[output],
+            input_type_protos=[input_type_proto] if input_name else [],
+            name=test_name,
+        )
+```
+
+</details>
+
+
+<details>
+<summary>get_element_sequence</summary>
+
+```python
+optional = [np.array([1, 2, 3, 4]).astype(np.int32)]
+tensor_type_proto = onnx.helper.make_tensor_type_proto(
+    elem_type=onnx.TensorProto.INT32,
+    shape=[
+        4,
+    ],
+)
+seq_type_proto = onnx.helper.make_sequence_type_proto(tensor_type_proto)
+optional_type_proto = onnx.helper.make_optional_type_proto(seq_type_proto)
+
+node = onnx.helper.make_node(
+    "OptionalGetElement", inputs=["optional_input"], outputs=["output"]
+)
+output = optional_get_element_reference_implementation(optional)
+expect(
+    node,
+    inputs=[optional],
+    outputs=[output],
+    input_type_protos=[optional_type_proto],
+    name="test_optional_get_element_optional_sequence",
+)
+expect(
+    node,
+    inputs=[optional],
+    outputs=[output],
+    input_type_protos=[seq_type_proto],
+    name="test_optional_get_element_sequence",
+)
+```
+
+</details>
+
+
+<details>
+<summary>get_element_tensor</summary>
+
+```python
+optional = np.array([1, 2, 3, 4]).astype(np.float32)
+tensor_type_proto = onnx.helper.make_tensor_type_proto(
+    elem_type=onnx.TensorProto.FLOAT,
+    shape=[
+        4,
+    ],
+)
+optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)
+
+node = onnx.helper.make_node(
+    "OptionalGetElement", inputs=["optional_input"], outputs=["output"]
+)
+output = optional_get_element_reference_implementation(optional)
+expect(
+    node,
+    inputs=[optional],
+    outputs=[output],
+    input_type_protos=[optional_type_proto],
+    name="test_optional_get_element_optional_tensor",
+)
+expect(
+    node,
+    inputs=[optional],
+    outputs=[output],
+    input_type_protos=[tensor_type_proto],
+    name="test_optional_get_element_tensor",
+)
+```
+
+</details>
+
+
+<details>
+<summary>optionalhaselement</summary>
+
+```python
+optional = np.array([1, 2, 3, 4]).astype(np.float32)
+tensor_type_proto = onnx.helper.make_tensor_type_proto(
+    elem_type=onnx.TensorProto.FLOAT,
+    shape=[
+        4,
+    ],
+)
+optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)
+
+# OptionalHasElement takes a tensor or optional as input
+for input_type_protos in [tensor_type_proto, optional_type_proto]:
+    node = onnx.helper.make_node(
+        "OptionalHasElement", inputs=["optional_input"], outputs=["output"]
+    )
+    output = optional_has_element_reference_implementation(optional)
+    test_name = "test_optional_has_element_" + (
+        "optional_input"
+        if input_type_protos == optional_type_proto
+        else "tensor_input"
+    )
+    expect(
+        node,
+        inputs=[optional],
+        outputs=[output],
+        input_type_protos=[optional_type_proto],
+        name=test_name,
+    )
+```
+
+</details>
+
+
+### <a name="Or"></a><a name="or">**Or**</a>
+
+  Returns the tensor resulted from performing the `or` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Or-1">1</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input to boolean tensor.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>or</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Or",
+    inputs=["x", "y"],
+    outputs=["or"],
+)
+
+# 2d
+x = (np.random.randn(3, 4) > 0).astype(bool)
+y = (np.random.randn(3, 4) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or2d")
+
+# 3d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or3d")
+
+# 4d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or4d")
+```
+
+</details>
+
+
+<details>
+<summary>or_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Or",
+    inputs=["x", "y"],
+    outputs=["or"],
+)
+
+# 3d vs 1d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(5) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast3v1d")
+
+# 3d vs 2d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(4, 5) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast3v2d")
+
+# 4d vs 2d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(5, 6) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v2d")
+
+# 4d vs 3d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(4, 5, 6) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v3d")
+
+# 4d vs 4d
+x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool)
+y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v4d")
+```
+
+</details>
+
+
+### <a name="PRelu"></a><a name="prelu">**PRelu**</a>
+
+  PRelu takes input data (Tensor<T>) and slope tensor as input, and produces one
+  output data (Tensor<T>) where the function `f(x) = slope * x for x < 0`,
+  `f(x) = x for x >= 0`., is applied to the data tensor elementwise.
+  This operator supports **unidirectional broadcasting** (tensor slope should be unidirectional broadcastable to input tensor X); for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#PRelu-1">1</a>, <a href="Changelog.md#PRelu-6">6</a>, <a href="Changelog.md#PRelu-7">7</a>, <a href="Changelog.md#PRelu-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+<dt><tt>slope</tt> (differentiable) : T</dt>
+<dd>Slope tensor. The shape of slope can be smaller than first input X; if so, its shape must be unidirectional broadcastable to X</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor (same size as X)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(uint32), tensor(uint64), tensor(int32), tensor(int64)</dt>
+<dd>Constrain input and output types to float/int tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>prelu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "PRelu",
+    inputs=["x", "slope"],
+    outputs=["y"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+slope = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * slope
+
+expect(node, inputs=[x, slope], outputs=[y], name="test_prelu_example")
+```
+
+</details>
+
+
+<details>
+<summary>prelu_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "PRelu",
+    inputs=["x", "slope"],
+    outputs=["y"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+slope = np.random.randn(5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * slope
+
+expect(node, inputs=[x, slope], outputs=[y], name="test_prelu_broadcast")
+```
+
+</details>
+
+
+### <a name="Pad"></a><a name="pad">**Pad**</a>
+
+  Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+  a padded tensor (`output`) is generated.
+
+  The four supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+  1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+  2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+  3) `edge` - pads with the edge values of array
+
+  4) `wrap` - wrap-around padding as if the data tensor forms a torus
+
+
+  Example 1 (`constant` mode):
+
+  Insert 0 pads to the beginning of the second dimension.
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'constant'
+
+  constant_value = 0.0
+
+  output = [
+      [0.0, 0.0, 1.0, 1.2],
+      [0.0, 0.0, 2.3, 3.4],
+      [0.0, 0.0, 4.5, 5.7],
+  ]
+  ```
+
+  Example 2 (`reflect` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'reflect'
+
+  output = [
+      [1.0, 1.2, 1.0, 1.2],
+      [2.3, 3.4, 2.3, 3.4],
+      [4.5, 5.7, 4.5, 5.7],
+  ]
+  ```
+
+  Example 3 (`edge` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'edge'
+
+  output = [
+      [1.0, 1.0, 1.0, 1.2],
+      [2.3, 2.3, 2.3, 3.4],
+      [4.5, 4.5, 4.5, 5.7],
+  ]
+  ```
+
+  Example 4 (`wrap` mode):
+
+  ```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [2, 1, 1, 1]
+
+  mode = 'wrap'
+
+  output = [
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+      [3.4, 2.3, 3.4, 2.3],
+      [5.7, 4.5, 5.7, 4.5],
+      [1.2, 1.0, 1.2, 1.0],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Pad-1">1</a>, <a href="Changelog.md#Pad-2">2</a>, <a href="Changelog.md#Pad-11">11</a>, <a href="Changelog.md#Pad-13">13</a>, <a href="Changelog.md#Pad-18">18</a>, <a href="Changelog.md#Pad-19">19</a>, <a href="Changelog.md#Pad-21">21</a>, <a href="Changelog.md#Pad-23">23</a>, <a href="Changelog.md#Pad-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>mode</tt> : string (default is constant)</dt>
+<dd>Supported modes: `constant`(default), `reflect`, `edge`, `wrap`</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Input tensor.</dd>
+<dt><tt>pads</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of integers indicating the number of padding elements to add or remove (if negative) at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. `pads` should be a 1D tensor of shape [2 * num_axes] where `num_axes` refers to the number of elements in the `axes` input or the input rank if `axes` are not provided explicitly. `pads` format should be: [x1_begin, x2_begin, ..., x1_end, x2_end,...], where xi_begin is the number of pad values added at the beginning of axis `axes[i]` and xi_end, the number of pad values added at the end of axis `axes[i]`.</dd>
+<dt><tt>constant_value</tt> (optional, non-differentiable) : T</dt>
+<dd>(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, empty string or False).</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of axes that `pads` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated. If not provided, all axes are assumed (`[0, 1, ..., input_rank-1]`).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor after padding.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv13.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>constant_pad</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pad", inputs=["x", "pads", "value"], outputs=["y"], mode="constant"
+)
+x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+pads = np.array([0, 0, 1, 3, 0, 0, 2, 4]).astype(
+    np.int64
+)  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+value = np.float32(1.2)
+y = pad_impl(x, pads, "constant", 1.2)
+
+expect(node, inputs=[x, pads, value], outputs=[y], name="test_constant_pad")
+```
+
+</details>
+
+
+<details>
+<summary>constant_pad_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pad", inputs=["x", "pads", "value", "axes"], outputs=["y"], mode="constant"
+)
+x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+pads = np.array([0, 3, 0, 4]).astype(
+    np.int64
+)  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+value = np.float32(1.2)
+axes = np.array([1, 3], dtype=np.int64)
+y = pad_impl(
+    x,
+    pads,
+    "constant",
+    1.2,
+    [1, 3],
+)
+
+expect(
+    node,
+    inputs=[x, pads, value, axes],
+    outputs=[y],
+    name="test_constant_pad_axes",
+)
+```
+
+</details>
+
+
+<details>
+<summary>constant_pad_negative_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pad", inputs=["x", "pads", "value", "axes"], outputs=["y"], mode="constant"
+)
+x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+pads = np.array([0, 3, 0, 4]).astype(
+    np.int64
+)  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+value = np.float32(1.2)
+axes = np.array([-3, -1], dtype=np.int64)
+y = pad_impl(
+    x,
+    pads,
+    "constant",
+    1.2,
+    [-3, -1],
+)
+
+expect(
+    node,
+    inputs=[x, pads, value, axes],
+    outputs=[y],
+    name="test_constant_pad_negative_axes",
+)
+```
+
+</details>
+
+
+<details>
+<summary>reflection_edge_and_wrap_pad</summary>
+
+```python
+for mode in ("edge", "reflect", "wrap"):
+    node = onnx.helper.make_node(
+        "Pad", inputs=["x", "pads"], outputs=["y"], mode=mode
+    )
+    x = np.random.randn(1, 3, 4, 5).astype(np.int32)
+    pads = np.array([0, 0, 1, 1, 0, 0, 1, 1]).astype(
+        np.int64
+    )  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+    y = pad_impl(x, pads, mode)
+
+    expect(node, inputs=[x, pads], outputs=[y], name=f"test_{mode}_pad")
+```
+
+</details>
+
+
+### <a name="Pow"></a><a name="pow">**Pow**</a>
+
+  Pow takes input data (Tensor<T>) and exponent Tensor, and
+  produces one output data (Tensor<T>) where the function `f(x) = x^exponent`,
+  is applied to the data tensor elementwise.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 15 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Pow-1">1</a>, <a href="Changelog.md#Pow-7">7</a>, <a href="Changelog.md#Pow-12">12</a>, <a href="Changelog.md#Pow-13">13</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>First operand, base of the exponent.</dd>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>Second operand, power of the exponent.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input X and output types to float/int tensors.</dd>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input Y types to float/int tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>pow</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pow",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.float32)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_example")
+
+x = np.arange(60).reshape(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = pow(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_pow")
+```
+
+</details>
+
+
+<details>
+<summary>pow_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pow",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array(2).astype(np.float32)
+z = pow(x, y)  # expected output [1., 4., 9.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_bcast_scalar")
+
+node = onnx.helper.make_node(
+    "Pow",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+x = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
+y = np.array([1, 2, 3]).astype(np.float32)
+# expected output [[1, 4, 27], [4, 25, 216]]
+z = pow(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_bcast_array")
+```
+
+</details>
+
+
+<details>
+<summary>types</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pow",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.int64)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_int64")
+
+x = np.array([1, 2, 3]).astype(np.int64)
+y = np.array([4, 5, 6]).astype(np.float32)
+z = pow(x, y)  # expected output [1, 32, 729]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int64_float32")
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.int32)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_int32")
+
+x = np.array([1, 2, 3]).astype(np.int32)
+y = np.array([4, 5, 6]).astype(np.float32)
+z = pow(x, y)  # expected output [1, 32, 729]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int32_float32")
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.uint64)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_uint64")
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.uint32)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_uint32")
+
+x = np.array([1, 2, 3]).astype(np.int64)
+y = np.array([4, 5, 6]).astype(np.int64)
+z = pow(x, y)  # expected output [1, 32, 729]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int64_int64")
+
+x = np.array([1, 2, 3]).astype(np.int32)
+y = np.array([4, 5, 6]).astype(np.int32)
+z = pow(x, y)  # expected output [1, 32, 729]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int32_int32")
+```
+
+</details>
+
+
+### <a name="QLinearConv"></a><a name="qlinearconv">**QLinearConv**</a>
+
+  The convolution operator consumes a quantized input tensor, its scale and zero point,
+  a quantized filter, its scale and zero point, and output's scale and zero point,
+  and computes the quantized output. Each scale and zero-point pair must have same shape.
+  It means they must be either scalars (per tensor) or 1-D tensors (per output channel).
+  Each input or output and its related zero point must have same type.
+  When bias is present it must be quantized using scale = input scale * weight scale and
+  zero point as 0.
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>auto_pad</tt> : string (default is NOTSET)</dt>
+<dd>auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where default value is NOTSET, which means explicit padding is used. SAME_UPPER or SAME_LOWER mean pad the input so that `output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. The padding is split between the two sides equally or almost equally (depending on whether it is even or odd). In case the padding is an odd number, the extra padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.</dd>
+<dt><tt>dilations</tt> : list of ints</dt>
+<dd>dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each spatial axis.</dd>
+<dt><tt>group</tt> : int (default is 1)</dt>
+<dd>number of groups input channels and output channels are divided into. default is 1.</dd>
+<dt><tt>kernel_shape</tt> : list of ints</dt>
+<dd>The shape of the convolution kernel. If not present, should be inferred from input 'w'.</dd>
+<dt><tt>pads</tt> : list of ints</dt>
+<dd>Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0.The value represent the number of pixels added to the beginning and end part of the corresponding axis.`pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number ofpixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`.This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaultsto 0 along start and end of each spatial axis.</dd>
+<dt><tt>strides</tt> : list of ints</dt>
+<dd>Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.</dd>
+</dl>
+
+#### Inputs (8 - 9)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>Input data tensor from previous layer; has size (N x C x H x W), where N is the batch size, C is the number of channels, and H and W are the height and width. Note that this is for the 2D image. Otherwise the size is (N x C x D1 x D2 ... x Dn). Optionally, if dimension denotation is in effect, the operation expects input data tensor to arrive with the dimension denotation of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].</dd>
+<dt><tt>x_scale</tt> : tensor(float)</dt>
+<dd>Scale tensor for input 'x'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>x_zero_point</tt> : T1</dt>
+<dd>Zero point tensor for input 'x'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>w</tt> : T2</dt>
+<dd>The weight tensor that will be used in the convolutions; has size (M x C/group x kH x kW), where C is the number of channels, and kH and kW are the height and width of the kernel, and M is the number of feature maps. For more than 2 dimensions, the kernel shape will be (M x C/group x k1 x k2 x ... x kn), where (k1 x k2 x ... kn) is the dimension of the kernel. Optionally, if dimension denotation is in effect, the operation expects the weight tensor to arrive with the dimension denotation of [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. X.shape[1] == (W.shape[1] * group) == C (assuming zero based indices for the shape array). Or in other words FILTER_IN_CHANNEL should be equal to DATA_CHANNEL. </dd>
+<dt><tt>w_scale</tt> : tensor(float)</dt>
+<dd>Scale tensor for input 'w'. It could be a scalar or a 1-D tensor, which means a per-tensor/layer or per output channel quantization. If it's a 1-D tensor, its number of elements should be equal to the number of output channels (M).</dd>
+<dt><tt>w_zero_point</tt> : T2</dt>
+<dd>Zero point tensor for input 'w'. It could be a scalar or a 1-D tensor, which means a per-tensor/layer or per output channel quantization. If it's a 1-D tensor, its number of elements should be equal to the number of output channels (M).</dd>
+<dt><tt>y_scale</tt> : tensor(float)</dt>
+<dd>Scale tensor for output 'y'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>y_zero_point</tt> : T3</dt>
+<dd>Zero point tensor for output 'y'. It's a scalar, which means a per-tensor/layer quantization.</dd>
+<dt><tt>B</tt> (optional) : T4</dt>
+<dd>Optional 1D bias to be added to the convolution, has size of M. Bias must be quantized using scale = x_scale * w_scale and zero_point = 0</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>Output data tensor that contains the result of the convolution. The output dimensions are functions of the kernel size, stride size, and pad lengths.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain input type to 8-bit integer tensor.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain filter type to 8-bit integer tensor.</dd>
+<dt><tt>T3</tt> : tensor(int8), tensor(uint8)</dt>
+<dd>Constrain output type to 8-bit integer tensor.</dd>
+<dt><tt>T4</tt> : tensor(int32)</dt>
+<dd>Constrain bias type to 32-bit integer tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>qlinearconv</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QLinearConv",
+    inputs=[
+        "x",
+        "x_scale",
+        "x_zero_point",
+        "w",
+        "w_scale",
+        "w_zero_point",
+        "y_scale",
+        "y_zero_point",
+    ],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        [255, 174, 162, 25, 203, 168, 58],
+        [15, 59, 237, 95, 129, 0, 64],
+        [56, 242, 153, 221, 168, 12, 166],
+        [232, 178, 186, 195, 237, 162, 237],
+        [188, 39, 124, 77, 80, 102, 43],
+        [127, 230, 21, 83, 41, 40, 134],
+        [255, 154, 92, 141, 42, 148, 247],
+    ],
+    dtype=np.uint8,
+).reshape((1, 1, 7, 7))
+
+x_scale = np.float32(0.00369204697)
+x_zero_point = np.uint8(132)
+
+w = np.array([0], dtype=np.uint8).reshape((1, 1, 1, 1))
+
+w_scale = np.array([0.00172794575], dtype=np.float32)
+w_zero_point = np.array([255], dtype=np.uint8)
+
+y_scale = np.float32(0.00162681262)
+y_zero_point = np.uint8(123)
+
+output = np.array(
+    [
+        [0, 81, 93, 230, 52, 87, 197],
+        [240, 196, 18, 160, 126, 255, 191],
+        [199, 13, 102, 34, 87, 243, 89],
+        [23, 77, 69, 60, 18, 93, 18],
+        [67, 216, 131, 178, 175, 153, 212],
+        [128, 25, 234, 172, 214, 215, 121],
+        [0, 101, 163, 114, 213, 107, 8],
+    ],
+    dtype=np.uint8,
+).reshape((1, 1, 7, 7))
+
+expect(
+    node,
+    inputs=[
+        x,
+        x_scale,
+        x_zero_point,
+        w,
+        w_scale,
+        w_zero_point,
+        y_scale,
+        y_zero_point,
+    ],
+    outputs=[output],
+    name="test_qlinearconv",
+)
+```
+
+</details>
+
+
+### <a name="QLinearMatMul"></a><a name="qlinearmatmul">**QLinearMatMul**</a>
+
+  Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+  It consumes two quantized input tensors, their scales and zero points, scale and zero point of output,
+  and computes the quantized output. The quantization formula is y = saturate((x / y_scale) + y_zero_point).
+  For (x / y_scale), it is rounding to nearest ties to even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+  Scale and zero point must have same shape. They must be either scalar (per tensor) or N-D tensor
+  (per row for 'a' and per column for 'b'). Scalar refers to per tensor quantization whereas N-D refers to per row
+  or per column quantization. If the input is 2D of shape [M, K] then zero point and scale tensor may be
+  an M element vector [v_1, v_2, ..., v_M] for per row quantization and K element vector of shape [v_1, v_2, ..., v_K]
+  for per column quantization. If the input is N-D tensor with shape [D1, D2, M, K] then zero point and scale tensor may
+  have shape [D1, D2, M, 1] for per row quantization and shape [D1, D2, 1, K] for per column quantization.
+  Production must never overflow, and accumulation may overflow if and only if in 32 bits.
+
+#### Version
+
+This version of the operator has been available since version 21 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#QLinearMatMul-10">10</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>a</tt> (non-differentiable) : T1</dt>
+<dd>N-dimensional quantized matrix a</dd>
+<dt><tt>a_scale</tt> (non-differentiable) : TS</dt>
+<dd>scale of quantized input a</dd>
+<dt><tt>a_zero_point</tt> (non-differentiable) : T1</dt>
+<dd>zero point of quantized input a</dd>
+<dt><tt>b</tt> (non-differentiable) : T2</dt>
+<dd>N-dimensional quantized matrix b</dd>
+<dt><tt>b_scale</tt> (non-differentiable) : TS</dt>
+<dd>scale of quantized input b</dd>
+<dt><tt>b_zero_point</tt> (non-differentiable) : T2</dt>
+<dd>zero point of quantized input b</dd>
+<dt><tt>y_scale</tt> (non-differentiable) : TS</dt>
+<dd>scale of quantized output y</dd>
+<dt><tt>y_zero_point</tt> (non-differentiable) : T3</dt>
+<dd>zero point of quantized output y</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> (non-differentiable) : T3</dt>
+<dd>Quantized matrix multiply results from a * b</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>TS</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>Constrain scales.</dd>
+<dt><tt>T1</tt> : tensor(int8), tensor(uint8), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>The type of input a and its zeropoint.</dd>
+<dt><tt>T2</tt> : tensor(int8), tensor(uint8), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>The type of input b and its zeropoint.</dd>
+<dt><tt>T3</tt> : tensor(int8), tensor(uint8), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz)</dt>
+<dd>The type of the output and its zeropoint.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>int</summary>
+
+```python
+for quant_type_name in ["uint8", "int8"]:
+    quant_type = getattr(np, quant_type_name)
+    for dtype_name in ["float32", "float16"]:
+        dtype = getattr(np, dtype_name)
+        node = onnx.helper.make_node(
+            "QLinearMatMul",
+            inputs=[
+                "a",
+                "a_scale",
+                "a_zero_point",
+                "b",
+                "b_scale",
+                "b_zero_point",
+                "y_scale",
+                "y_zero_point",
+            ],
+            outputs=["y"],
+        )
+
+        # 2D
+        a = np.array([[208, 236, 0, 238], [3, 214, 255, 29]])
+        if quant_type == np.int8:
+            a -= 127
+        a = a.astype(quant_type)
+
+        a_scale = np.array([0.0066], dtype=dtype)
+        a_zero_point = np.array(
+            [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type
+        )
+
+        b = np.array(
+            [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]]
+        )
+        if quant_type == np.int8:
+            b -= 127
+        b = b.astype(quant_type)
+
+        b_scale = np.array([0.00705], dtype=dtype)
+        b_zero_point = np.array(
+            [114 - 127] if quant_type == np.int8 else [114], dtype=quant_type
+        )
+
+        y_scale = np.array([0.0107], dtype=dtype)
+        y_zero_point = np.array(
+            [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type
+        )
+
+        if quant_type == np.int8:
+            output = np.array([[41, -12, -9], [1, -75, -128]])
+        else:
+            output = np.array([[168, 115, 255], [1, 66, 151]])
+        output = output.astype(quant_type)
+
+        expect(
+            node,
+            inputs=[
+                a,
+                a_scale,
+                a_zero_point,
+                b,
+                b_scale,
+                b_zero_point,
+                y_scale,
+                y_zero_point,
+            ],
+            outputs=[output],
+            name=f"test_qlinearmatmul_2D_{quant_type_name}_{dtype_name}",
+        )
+
+        # 3D
+        a = np.array(
+            [
+                [[208, 236, 0, 238], [3, 214, 255, 29]],
+                [[208, 236, 0, 238], [3, 214, 255, 29]],
+            ],
+        )
+        if quant_type == np.int8:
+            a -= 127
+        a = a.astype(quant_type)
+
+        a_scale = np.array([0.0066], dtype=dtype)
+        a_zero_point = np.array(
+            [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type
+        )
+
+        b = np.array(
+            [
+                [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
+                [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
+            ],
+        )
+        if quant_type == np.int8:
+            b -= 127
+        b = b.astype(quant_type)
+
+        b_scale = np.array([0.00705], dtype=dtype)
+        b_zero_point = np.array([114], dtype=quant_type)
+
+        y_scale = np.array([0.0107], dtype=dtype)
+        y_zero_point = np.array(
+            [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type
+        )
+
+        if quant_type == np.int8:
+            output = np.array(
+                [
+                    [[-86, -128, -128], [115, 39, -121]],
+                    [[-86, -128, -128], [115, 39, -121]],
+                ]
+            )
+        else:
+            output = np.array(
+                [
+                    [[168, 115, 255], [1, 66, 151]],
+                    [[168, 115, 255], [1, 66, 151]],
+                ]
+            )
+        output = output.astype(quant_type)
+
+        expect(
+            node,
+            inputs=[
+                a,
+                a_scale,
+                a_zero_point,
+                b,
+                b_scale,
+                b_zero_point,
+                y_scale,
+                y_zero_point,
+            ],
+            outputs=[output],
+            name=f"test_qlinearmatmul_3D_{quant_type_name}_{dtype_name}",
+        )
+```
+
+</details>
+
+
+### <a name="QuantizeLinear"></a><a name="quantizelinear">**QuantizeLinear**</a>
+
+  The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
+  low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
+  granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
+
+  Saturation is done according to:
+  - uint16: [0, 65535]
+  - int16: [-32768, 32767]
+  - uint8: [0, 255]
+  - int8: [-128, 127]
+  - uint4: [0, 15]
+  - int4: [-8, 7]
+  - uint2: [0, 3]
+  - int2: [-2, 1]
+
+  For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+
+  `y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 and 4bit types, but the quantization
+  formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+  `x` and `y_scale` are allowed to have different types. The type of `y_scale` determines the precision of the division operation between `x` and
+  `y_scale`, unless the `precision` attribute is specified.
+
+  There are three supported quantization granularities, determined by the shape of `y_scale`.
+  In all cases, `y_zero_point` must have the same shape as `y_scale`.
+  - Per-tensor (per-layer) quantization: `y_scale` is a scalar.
+  - Per-axis quantization: The scale must be a 1-D tensor, with the length of the quantization axis. For an input shape
+   `(D0, ..., Di, ..., Dn)` and `axis=i`, `y_scale` is a 1-D tensor of length `Di`.
+  - Blocked quantization: The scale's shape is identical to the input's shape, except for one dimension, in which
+    blocking is performed. Given `x` shape `(D0, ..., Di, ..., Dn)`, `axis=i`, and block size `B`: `y_scale` shape is
+    `(D0, ..., ceil(Di/B), ..., Dn)`.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#QuantizeLinear-10">10</a>, <a href="Changelog.md#QuantizeLinear-13">13</a>, <a href="Changelog.md#QuantizeLinear-19">19</a>, <a href="Changelog.md#QuantizeLinear-21">21</a>, <a href="Changelog.md#QuantizeLinear-23">23</a>, <a href="Changelog.md#QuantizeLinear-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 1)</dt>
+<dd>(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, rendering the axis unnecessary in this scenario.</dd>
+<dt><tt>block_size</tt> : int (default is 0)</dt>
+<dd>(Optional) The size of the quantization block (number of times every scale is replicated). Used only for blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, `y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is `[ceil(Di/Si), ceil(Di/(Si-1))-1]`</dd>
+<dt><tt>output_dtype</tt> : int (default is 0)</dt>
+<dd>(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T3`). If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T3`.</dd>
+<dt><tt>precision</tt> : int (default is 0)</dt>
+<dd>(Optional) The precision of the division operation between `x` and `y_scale`. If not provided, it will be the same as the type of `y_scale`.</dd>
+<dt><tt>saturate</tt> : int (default is 1)</dt>
+<dd>The parameter defines how the conversion behaves if an input value is out of range of the destination type. It only applies for float 8 quantization (float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. All cases are fully described in two tables inserted in the operator description.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>x</tt> : T1</dt>
+<dd>N-D full precision Input tensor to be quantized.</dd>
+<dt><tt>y_scale</tt> : T2</dt>
+<dd>Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the input, except for one dimension in which blocking is performed.</dd>
+<dt><tt>y_zero_point</tt> (optional) : T3</dt>
+<dd>Zero point for doing quantization to get `y`. Shape must match `y_scale`. Default is uint8 with zero point of 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>y</tt> : T3</dt>
+<dd>N-D quantized output tensor. It has same shape as input `x`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32)</dt>
+<dd>The type of the input 'x'.</dd>
+<dt><tt>T2</tt> : tensor(float), tensor(float16), tensor(bfloat16), tensor(int32), tensor(float8e8m0)</dt>
+<dd>The type of the input 'y_scale'.</dd>
+<dt><tt>T3</tt> : tensor(int8), tensor(uint8), tensor(int16), tensor(uint16), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(uint2), tensor(int2)</dt>
+<dd>The type of the input `y_zero_point` and the output `y`.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        [
+            [[-162, 10], [-100, 232], [-20, -50]],
+            [[-76, 0], [0, 252], [32, -44]],
+            [[245, -485], [-960, -270], [-375, -470]],
+        ],
+    ],
+    dtype=np.float32,
+)
+y_scale = np.array([2, 4, 5], dtype=np.float32)
+y_zero_point = np.array([84, 24, 196], dtype=np.uint8)
+y = (x / y_scale.reshape(1, 3, 1, 1) + y_zero_point.reshape(1, 3, 1, 1)).astype(
+    np.uint8
+)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>blocked_asymmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=1,
+    block_size=2,
+)
+
+x = np.array(
+    [
+        [6.0, 12.0, 50.0, 5.0],
+        [1.0, 8.0, 4.0, 5.0],
+        [0.0, 20.0, 10.0, 4.0],
+    ],
+    dtype=np.float32,
+)
+y_scale = np.array(
+    [
+        [1.5, 2.5],
+        [3.0, 4.9],
+        [5.1, 6.9],
+    ],
+    dtype=np.float32,
+)
+y_zero_point = np.array(
+    [
+        [0, 1],
+        [1, 0],
+        [2, 3],
+    ],
+    dtype=np.uint8,
+)
+# x.shape = (3, 4)
+# y_scale.shape = (3, 2)
+assert y_scale.shape == y_zero_point.shape
+block_axis = 1
+# The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2)
+assert all(
+    x.shape[i] == y_scale.shape[i]
+    for i in range(len(x.shape))
+    if i != block_axis
+)
+assert x.shape[block_axis] % y_scale.shape[block_axis] == 0
+repeats = x.shape[block_axis] // y_scale.shape[block_axis]
+
+# Create element-wise scale and zero point
+y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis)
+y_zero_point_elementwise = np.repeat(
+    y_zero_point, repeats=repeats, axis=block_axis
+)
+
+y = np.rint(x / y_scale_elementwise + y_zero_point_elementwise).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_blocked_asymmetric",
+)
+```
+
+</details>
+
+
+<details>
+<summary>blocked_symmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale"],
+    outputs=["y"],
+    axis=1,
+    block_size=2,
+    output_dtype=TensorProto.INT16,
+)
+
+x = np.array(
+    [
+        [6.0, -8, -10, 5.0],
+        [1.0, 8.0, 4.0, 5.0],
+        [0.0, 20.0, 10.0, 4.0],
+    ],
+    dtype=np.float32,
+)
+
+y_scale = np.array(
+    [
+        [1.5, 2.5],
+        [3.0, 4.9],
+        [5.1, 6.9],
+    ],
+    dtype=np.float32,
+)
+
+# x.shape = (3, 4)
+# y_scale.shape = (3, 2)
+
+block_axis = 1
+# The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2)
+assert all(
+    x.shape[i] == y_scale.shape[i]
+    for i in range(len(x.shape))
+    if i != block_axis
+)
+assert x.shape[block_axis] % y_scale.shape[block_axis] == 0
+repeats = x.shape[block_axis] // y_scale.shape[block_axis]
+
+# Create element-wise scale and zero point
+y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis)
+
+y_val = np.clip(
+    np.rint(x / y_scale_elementwise), a_min=-32768, a_max=32767
+).astype(np.int16)
+y = make_tensor(
+    "y",
+    TensorProto.INT16,
+    x.shape,
+    y_val,
+)
+expect(
+    node,
+    inputs=[x, y_scale],
+    outputs=[y],
+    name="test_quantizelinear_blocked_symmetric",
+)
+```
+
+</details>
+
+
+<details>
+<summary>e4m3fn</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32)
+y_scale = np.float32(2)
+y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E4M3FN, [1], [0])
+y = make_tensor("y", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, 96])
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_e4m3fn",
+)
+```
+
+</details>
+
+
+<details>
+<summary>e5m2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32)
+y_scale = np.float32(2)
+y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E5M2, [1], [0.0])
+y = make_tensor("y", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, 96])
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_e5m2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>float4e2m1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-30, -20, 6, 9],
+        [-0.0, -2.5, -4.8, -8.6],
+    ]
+).astype(np.float32)
+
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point",
+    TensorProto.FLOAT4E2M1,
+    y_scale.shape,
+    np.zeros_like(y_scale),
+)
+y = make_tensor(
+    "y",
+    TensorProto.FLOAT4E2M1,
+    x.shape,
+    [0, 1, 2, 4, -6, -6, 2, 3, 0, -0.5, -1, -2],
+)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_float4e2m1",
+)
+```
+
+</details>
+
+
+<details>
+<summary>int16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        0.0,
+        -514.0,
+        3.0,
+        -3.0,
+        2.9,
+        -2.9,
+        3.1,
+        -3.1,
+        65022.0,
+        -66046.0,
+        65023.0,
+        -66047.0,
+        65024.0,
+        -66048.0,
+        70000.0,
+        -70000.0,
+    ]
+).astype(np.float32)
+y_scale = np.float32(2.0)
+y_zero_point = np.int16(256)
+y = np.array(
+    [
+        256,
+        -1,
+        258,
+        254,
+        257,
+        255,
+        258,
+        254,
+        32767,
+        -32767,
+        32767,
+        -32768,
+        32767,
+        -32768,
+        32767,
+        -32768,
+    ]
+).astype(np.int16)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_int16",
+)
+```
+
+</details>
+
+
+<details>
+<summary>int2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-4.0, -3.0, 1.0, 2.0],
+        [-0.0, -2.5, -4.8, -8.6],
+    ],
+    dtype=np.float32,
+)
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point", TensorProto.INT2, y_scale.shape, np.zeros_like(y_scale)
+)
+y = make_tensor(
+    "y", TensorProto.INT2, x.shape, [0, 1, 1, 1, -1, -1, 0, 1, 0, -1, -1, -2]
+)
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_int2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>int4</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-30, -20, 6, 9],
+        [12, 15, 16, 40],
+    ]
+).astype(np.float32)
+
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point", TensorProto.INT4, y_scale.shape, np.ones_like(y_scale)
+)
+y = make_tensor(
+    "y", TensorProto.INT4, x.shape, [1, 2, 3, 5, -8, -6, 3, 4, 4, 5, 5, 7]
+)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_int4",
+)
+```
+
+</details>
+
+
+<details>
+<summary>quantizelinear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([0, 2, 3, 1000, -254, -1000]).astype(np.float32)
+y_scale = np.float32(2)
+y_zero_point = np.uint8(128)
+y = np.array([128, 129, 130, 255, 1, 0]).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear",
+)
+```
+
+</details>
+
+
+<details>
+<summary>uint16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        0.0,
+        -128.0,
+        3.0,
+        -3.0,
+        2.9,
+        -2.9,
+        3.1,
+        -3.1,
+        65536.0,
+        -65534.0,
+        70000.0,
+        -70000.0,
+    ]
+).astype(np.float32)
+y_scale = np.float32(2.0)
+y_zero_point = np.uint16(32767)
+y = np.array(
+    [
+        32767,
+        32703,
+        32769,
+        32765,
+        32768,
+        32766,
+        32769,
+        32765,
+        65535,
+        0,
+        65535,
+        0,
+    ]
+).astype(np.uint16)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_uint16",
+)
+```
+
+</details>
+
+
+<details>
+<summary>uint2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-2.0, -1.0, 1.0, 3.0],
+        [4.0, 5.0, 6.0, 7.0],
+    ],
+    dtype=np.float32,
+)
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point", TensorProto.UINT2, y_scale.shape, np.zeros_like(y_scale)
+)
+y = make_tensor(
+    "y", TensorProto.UINT2, x.shape, [0, 1, 2, 3, 0, 0, 0, 1, 1, 1, 2, 2]
+)
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_uint2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>uint4</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-30, -20, 6, 9],
+        [12, 15, 16, 40],
+    ]
+).astype(np.float32)
+
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point", TensorProto.UINT4, y_scale.shape, np.ones_like(y_scale)
+)
+y = make_tensor(
+    "y", TensorProto.UINT4, x.shape, [1, 2, 3, 5, 0, 0, 3, 4, 4, 5, 5, 11]
+)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_uint4",
+)
+```
+
+</details>
+
+
+### <a name="RMSNormalization"></a><a name="rmsnormalization">**RMSNormalization**</a>
+
+  This is RMS normalization defined in ONNX as function as described in the paper https://arxiv.org/pdf/1910.07467.
+        The overall computation can be split into two stages. The root mean squared norm is taken over the last D dimensions,
+        where D is the dimension of normalized_shape. For example, if normalized_shape is (3, 5) (a 2-dimensional shape),
+        the rms norm is computed over the last 2 dimensions of the input. The computation required by standardization can be
+        described by the following equations.
+        ```
+        XSquared = Mul(X, X)
+        XSquaredMean = ReduceMean<axes=normalized_axes>(XSquared)
+        MeanSquareEpsilon = Add(XSquaredMean, epsilon)
+        RMS = Sqrt(MeanSquareEpsilon)
+        Normalized = Div(X, RMS)
+        ```
+        where `normalized_axes` is `[axis, ..., rank of X - 1]`. The variables `RMS` stand for root mean square,
+        Depending on `stash_type` attribute, the actual computation
+        must happen in different floating-point precision.
+        For example, if `stash_type` is 1, this operator casts
+        all input variables to 32-bit float, perform the computation, and
+        finally cast `Normalized` back to the original type of `X`.
+        The second stage then scales the outcome of the first stage using:
+        ```
+        Y= Mul(Normalized, Scale)
+        ```
+        Let `d[i]` indicate the i-th dimension of `X`.
+        If `X`'s shape is `[d[0], ..., d[axis-1], d[axis], ..., d[rank-1]]`,
+        the shape of `RMS` is `[d[0], ..., d[axis-1], 1, ..., 1]`.
+        `Y` and `X` have the same shape. This operator supports unidirectional broadcasting
+        (`Scale` should be unidirectional broadcastable to tensor `X`);
+        for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>The first normalization dimension. If rank(X) is r, axis' allowed range is [-r, r). Negative value means counting dimensions from the back.</dd>
+<dt><tt>epsilon</tt> : float (default is 1e-05)</dt>
+<dd>The epsilon value to use to avoid division by zero.</dd>
+<dt><tt>stash_type</tt> : int (default is 1)</dt>
+<dd>The floating-point precision used in stage one of the computation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input tensor to be normalized. In general, the shape is (D1, D2, ... , Dn) for n-dimensional data, where the root mean squared norm is taken over the last D dimensions, D is determined by the axis attribute.</dd>
+<dt><tt>scale</tt> : V</dt>
+<dd>Scale tensor. Scale tensor shape should be broadcastable to the normalized shape.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : V</dt>
+<dd>Output data tensor. Same shape as X</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input X type to float tensors.</dd>
+<dt><tt>V</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain output Y and scale type to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>d</summary>
+
+```python
+X = np.random.randn(3, 4).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    Y = _rms_normalization(X, W, axis=axis)
+
+    node = onnx.helper.make_node(
+        "RMSNormalization",
+        inputs=["X", "W"],
+        outputs=["Y"],
+        axis=axis,
+    )
+
+    if axis < 0:
+        name = f"test_rms_normalization_2d_axis_negative_{-axis}"
+    else:
+        name = f"test_rms_normalization_2d_axis{axis}"
+
+    expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+
+
+<details>
+<summary>d_epsilon</summary>
+
+```python
+epsilon = 1e-1
+X = np.random.randn(2, 3, 5).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    Y = _rms_normalization(X, W, axis=axis, epsilon=epsilon)
+    node = onnx.helper.make_node(
+        "RMSNormalization",
+        inputs=["X", "W"],
+        outputs=["Y"],
+        axis=axis,
+        epsilon=epsilon,
+    )
+
+    if axis < 0:
+        name = f"test_rms_normalization_3d_axis_negative_{-axis}_epsilon"
+    else:
+        name = f"test_rms_normalization_3d_axis{axis}_epsilon"
+
+    expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+
+
+<details>
+<summary>default_axis</summary>
+
+```python
+X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+# Default axis in RMSNormalization is -1.
+normalized_shape = calculate_normalized_shape(X.shape, -1)
+W = np.random.randn(*normalized_shape).astype(np.float32)
+# Axis is default to -1 in the reference implementation.
+Y = _rms_normalization(X, W)
+
+# Not specifying axis attribute means -1.
+node = onnx.helper.make_node(
+    "RMSNormalization",
+    inputs=["X", "W"],
+    outputs=["Y"],
+)
+
+expect(
+    node,
+    inputs=[X, W],
+    outputs=[Y],
+    name="test_rms_normalization_default_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>rmsnormalization</summary>
+
+```python
+X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    Y = _rms_normalization(X, W, axis=axis)
+
+    node = onnx.helper.make_node(
+        "RMSNormalization",
+        inputs=["X", "W"],
+        outputs=["Y"],
+        axis=axis,
+    )
+
+    if axis < 0:
+        name = f"test_rms_normalization_4d_axis_negative_{-axis}"
+    else:
+        name = f"test_rms_normalization_4d_axis{axis}"
+
+    expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+
+
+### <a name="RNN"></a><a name="rnn">**RNN**</a>
+
+  Computes an one-layer simple RNN. This operator is usually supported
+  via some custom implementation such as CuDNN.
+
+  Notations:
+
+  * `X` - input tensor
+  * `i` - input gate
+  * `t` - time step (t-1 means previous time step)
+  * `Wi` - W parameter weight matrix for input gate
+  * `Ri` - R recurrence weight matrix for input gate
+  * `Wbi` - W parameter bias vector for input gate
+  * `Rbi` - R parameter bias vector for input gate
+  * `WBi` - W parameter weight matrix for backward input gate
+  * `RBi` - R recurrence weight matrix for backward input gate
+  * `WBbi` - WR bias vectors for backward input gate
+  * `RBbi` - RR bias vectors for backward input gate
+  * `H` - Hidden state
+  * `num_directions` - 2 if direction == bidirectional else 1
+
+  Activation functions:
+
+  * Relu(x)                - max(0, x)
+  * Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+  * Sigmoid(x)             - 1/(1 + e^{-x})
+
+  NOTE: Below are optional
+
+  * Affine(x)              - alpha*x + beta
+  * LeakyRelu(x)           - x if x >= 0 else alpha * x
+  * ThresholdedRelu(x)     - x if x >= alpha else 0
+  * ScaledTanh(x)          - alpha*Tanh(beta*x)
+  * HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+  * Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+  * Softsign(x)            - x/(1 + |x|)
+  * Softplus(x)            - log(1 + e^x)
+
+  Equations (Default: f=Tanh):
+
+  * Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi)
+  This operator has **optional** inputs/outputs. See [the doc](IR.md) for more details about the representation of optional arguments. An empty string may be used in the place of an actual argument's name to indicate a missing argument. Trailing optional arguments (those not followed by an argument that is present) may also be simply omitted.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#RNN-1">1</a>, <a href="Changelog.md#RNN-7">7</a>, <a href="Changelog.md#RNN-14">14</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>activation_alpha</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.For example with LeakyRelu, the default alpha is 0.01.</dd>
+<dt><tt>activation_beta</tt> : list of floats</dt>
+<dd>Optional scaling values used by some activation functions. The values are consumed in the order of activation functions, for example (f, g, h) in LSTM. Default values are the same as of corresponding ONNX operators.</dd>
+<dt><tt>activations</tt> : list of strings (default is ['Tanh', 'Tanh'])</dt>
+<dd>One (or two if bidirectional) activation function for input gate. The activation function must be one of the activation functions specified above. Optional: Default `Tanh` if not specified.</dd>
+<dt><tt>clip</tt> : float</dt>
+<dd>Cell clip threshold. Clipping bounds the elements of a tensor in the range of [-threshold, +threshold] and is applied to the input of activations. No clip if not specified.</dd>
+<dt><tt>direction</tt> : string (default is forward)</dt>
+<dd>Specify if the RNN is forward, reverse, or bidirectional. Must be one of forward (default), reverse, or bidirectional.</dd>
+<dt><tt>hidden_size</tt> : int</dt>
+<dd>Number of neurons in the hidden layer</dd>
+<dt><tt>layout</tt> : int (default is 0)</dt>
+<dd>The shape format of inputs X, initial_h and outputs Y, Y_h. If 0, the following shapes are expected: X.shape = [seq_length, batch_size, input_size], Y.shape = [seq_length, num_directions, batch_size, hidden_size], initial_h.shape = Y_h.shape = [num_directions, batch_size, hidden_size]. If 1, the following shapes are expected: X.shape = [batch_size, seq_length, input_size], Y.shape = [batch_size, seq_length, num_directions, hidden_size], initial_h.shape = Y_h.shape = [batch_size, num_directions, hidden_size].</dd>
+</dl>
+
+#### Inputs (3 - 6)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>The input sequences packed (and potentially padded) into one 3-D tensor with the shape of `[seq_length, batch_size, input_size]`.</dd>
+<dt><tt>W</tt> (differentiable) : T</dt>
+<dd>The weight tensor for input gate. Concatenation of `Wi` and `WBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, input_size]`.</dd>
+<dt><tt>R</tt> (differentiable) : T</dt>
+<dd>The recurrence weight tensor. Concatenation of `Ri` and `RBi` (if bidirectional). The tensor has shape `[num_directions, hidden_size, hidden_size]`.</dd>
+<dt><tt>B</tt> (optional, differentiable) : T</dt>
+<dd>The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` and `[WBbi, RBbi]` (if bidirectional). The tensor has shape `[num_directions, 2*hidden_size]`. Optional: If not specified - assumed to be 0.</dd>
+<dt><tt>sequence_lens</tt> (optional, non-differentiable) : T1</dt>
+<dd>Optional tensor specifying lengths of the sequences in a batch. If not specified - assumed all sequences in the batch to have length `seq_length`. It has shape `[batch_size]`.</dd>
+<dt><tt>initial_h</tt> (optional, non-differentiable) : T</dt>
+<dd>Optional initial value of the hidden. If not specified - assumed to be 0. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Outputs (0 - 2)
+
+<dl>
+<dt><tt>Y</tt> (optional, differentiable) : T</dt>
+<dd>A tensor that concats all the intermediate output values of the hidden. It has shape `[seq_length, num_directions, batch_size, hidden_size]`. </dd>
+<dt><tt>Y_h</tt> (optional, differentiable) : T</dt>
+<dd>The last output value of the hidden. It has shape `[num_directions, batch_size, hidden_size]`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>T1</tt> : tensor(int32)</dt>
+<dd>Constrain seq_lens to integer tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>batchwise</summary>
+
+```python
+input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 4
+weight_scale = 0.5
+layout = 1
+
+node = onnx.helper.make_node(
+    "RNN",
+    inputs=["X", "W", "R"],
+    outputs=["Y", "Y_h"],
+    hidden_size=hidden_size,
+    layout=layout,
+)
+
+W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32)
+R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32)
+
+rnn = RNNHelper(X=input, W=W, R=R, layout=layout)
+Y, Y_h = rnn.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y.astype(np.float32), Y_h.astype(np.float32)],
+    name="test_simple_rnn_batchwise",
+)
+```
+
+</details>
+
+
+<details>
+<summary>defaults</summary>
+
+```python
+input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 4
+weight_scale = 0.1
+
+node = onnx.helper.make_node(
+    "RNN", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size
+)
+
+W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32)
+R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32)
+
+rnn = RNNHelper(X=input, W=W, R=R)
+_, Y_h = rnn.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_simple_rnn_defaults",
+)
+```
+
+</details>
+
+
+<details>
+<summary>initial_bias</summary>
+
+```python
+input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype(
+    np.float32
+)
+
+input_size = 3
+hidden_size = 5
+custom_bias = 0.1
+weight_scale = 0.1
+
+node = onnx.helper.make_node(
+    "RNN",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32)
+R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32)
+
+# Adding custom bias
+W_B = custom_bias * np.ones((1, hidden_size)).astype(np.float32)
+R_B = np.zeros((1, hidden_size)).astype(np.float32)
+B = np.concatenate((W_B, R_B), axis=1)
+
+rnn = RNNHelper(X=input, W=W, R=R, B=B)
+_, Y_h = rnn.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_simple_rnn_with_initial_bias",
+)
+```
+
+</details>
+
+
+<details>
+<summary>seq_length</summary>
+
+```python
+input = np.array(
+    [
+        [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
+        [[10.0, 11.0, 12.0], [13.0, 14.0, 15.0], [16.0, 17.0, 18.0]],
+    ]
+).astype(np.float32)
+
+input_size = 3
+hidden_size = 5
+
+node = onnx.helper.make_node(
+    "RNN",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = np.random.randn(1, hidden_size, input_size).astype(np.float32)
+R = np.random.randn(1, hidden_size, hidden_size).astype(np.float32)
+
+# Adding custom bias
+W_B = np.random.randn(1, hidden_size).astype(np.float32)
+R_B = np.random.randn(1, hidden_size).astype(np.float32)
+B = np.concatenate((W_B, R_B), axis=1)
+
+rnn = RNNHelper(X=input, W=W, R=R, B=B)
+_, Y_h = rnn.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_rnn_seq_length",
+)
+```
+
+</details>
+
+
+### <a name="RandomNormal"></a><a name="randomnormal">**RandomNormal**</a>
+
+  Generate a tensor with random values drawn from a normal distribution. The shape
+  of the tensor is specified by the `shape` argument and the parameter of the normal distribution
+  specified by `mean` and `scale`.
+
+  The data type is specified by the 'dtype' argument. The 'dtype' argument must
+  be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#RandomNormal-1">1</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int (default is 1)</dt>
+<dd>The data type for the elements of the output tensor. Default is TensorProto::FLOAT.</dd>
+<dt><tt>mean</tt> : float (default is 0.0)</dt>
+<dd>The mean of the normal distribution.</dd>
+<dt><tt>scale</tt> : float (default is 1.0)</dt>
+<dd>The standard deviation of the normal distribution.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+<dt><tt>shape</tt> : list of ints (required)</dt>
+<dd>The shape of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of random values drawn from normal distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+
+### <a name="RandomNormalLike"></a><a name="randomnormallike">**RandomNormalLike**</a>
+
+  Generate a tensor with random values drawn from a normal distribution.
+  The shape of the output tensor is copied from the shape of the input tensor,
+  and the parameters of the normal distribution are specified by `mean` and `scale`.
+
+  The data type is specified by the 'dtype' argument, or copied from the input tensor if not provided.
+  The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message, and be valid as an output type.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#RandomNormalLike-1">1</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type for the elements of the output tensor, if not specified, we will use the data type of the input tensor.</dd>
+<dt><tt>mean</tt> : float (default is 0.0)</dt>
+<dd>The mean of the normal distribution.</dd>
+<dt><tt>scale</tt> : float (default is 1.0)</dt>
+<dd>The standard deviation of the normal distribution.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor to copy shape and optionally type information from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of random values drawn from normal distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.</dd>
+<dt><tt>T2</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+
+### <a name="RandomUniform"></a><a name="randomuniform">**RandomUniform**</a>
+
+  Generate a tensor with random values drawn from a uniform distribution. The shape
+  of the tensor is specified by the `shape` argument and the range by `low` and `high`.
+
+  The data type is specified by the 'dtype' argument. The 'dtype' argument must
+  be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#RandomUniform-1">1</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int (default is 1)</dt>
+<dd>The data type for the elements of the output tensor. If not specified, default is TensorProto::FLOAT.</dd>
+<dt><tt>high</tt> : float (default is 1.0)</dt>
+<dd>Upper boundary of the output values.</dd>
+<dt><tt>low</tt> : float (default is 0.0)</dt>
+<dd>Lower boundary of the output values.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+<dt><tt>shape</tt> : list of ints (required)</dt>
+<dd>The shape of the output tensor.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>Output tensor of random values drawn from uniform distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+
+### <a name="RandomUniformLike"></a><a name="randomuniformlike">**RandomUniformLike**</a>
+
+  Generate a tensor with random values drawn from a uniform distribution.
+  The shape of the output tensor is copied from the shape of the input tensor,
+  and the parameters of the uniform distribution are specified by `low` and `high`.
+
+  The data type is specified by the 'dtype' argument, or copied from the input tensor if not provided.
+  The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+  TensorProto message and be valid as an output type.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#RandomUniformLike-1">1</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type for the elements of the output tensor, if not specified, we will use the data type of the input tensor.</dd>
+<dt><tt>high</tt> : float (default is 1.0)</dt>
+<dd>Upper boundary of the output values.</dd>
+<dt><tt>low</tt> : float (default is 0.0)</dt>
+<dd>Lower boundary of the output values.</dd>
+<dt><tt>seed</tt> : float</dt>
+<dd>(Optional) Seed to the random generator, if not specified we will auto generate one.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T1</dt>
+<dd>Input tensor to copy shape and optionally type information from.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T2</dt>
+<dd>Output tensor of random values drawn from uniform distribution</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.</dd>
+<dt><tt>T2</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain output types to float tensors.</dd>
+</dl>
+
+
+### <a name="Range"></a><a name="range">**Range**</a>
+
+  Generate a tensor containing a sequence of numbers that begin at `start` and extends by increments of `delta`
+  up to `limit` (exclusive).
+
+  The number of elements in the output of range is computed as below:
+  ```
+  number_of_elements = max( ceil( (limit - start) / delta ) , 0 )
+  ```
+  The pseudocode determining the contents of the output is shown below:
+  ```
+  for(int i=0; i<number_of_elements; ++i) {
+    output[i] =  start + (i * delta);
+  }
+  ```
+  Example 1:
+  ```
+  Inputs: start = 3, limit = 9, delta = 3
+  Output: [3, 6]
+  ```
+  Example 2:
+  ```
+  Inputs: start = 10, limit = 4, delta = -2
+  Output: [10, 8, 6]
+  ```
+
+  For `float16` and `bfloat16` inputs, the `stash_type` attribute controls the precision used for
+  intermediate accumulation. Setting `stash_type` to `1` (float) causes `start`, `limit`, and
+  `delta` to be cast to 32-bit float before the loop, with the output cast back to the original
+  type. This avoids precision loss for large ranges where successive additions in float16 or
+  bfloat16 would otherwise be inexact (e.g. `x + 1 == x` for large `x`).
+
+#### Version
+
+This version of the operator has been available since version 27 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Range-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>stash_type</tt> : int (default is 1)</dt>
+<dd>The data type used for intermediate computation when T is float16 or bfloat16. Defaults to 1 (float). Has no effect for other types.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>start</tt> : T</dt>
+<dd>Scalar. First entry for the range of output values.</dd>
+<dt><tt>limit</tt> : T</dt>
+<dd>Scalar. Exclusive upper limit for the range of output values.</dd>
+<dt><tt>delta</tt> : T</dt>
+<dd>Scalar. Value to step by.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : T</dt>
+<dd>A 1-D tensor with same type as the inputs containing generated range of values.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(double), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(bfloat16)</dt>
+<dd>Constrain input types to common numeric type tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>range_bfloat16_type_positive_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Range",
+    inputs=["start", "limit", "delta"],
+    outputs=["output"],
+)
+
+start = np.array(1.0, dtype=ml_dtypes.bfloat16)
+limit = np.array(5.0, dtype=ml_dtypes.bfloat16)
+delta = np.array(2.0, dtype=ml_dtypes.bfloat16)
+
+output = np.arange(1.0, 5.0, 2.0, dtype=np.float32).astype(
+    ml_dtypes.bfloat16
+)  # expected output [1.0, 3.0] as bfloat16
+
+expect(
+    node,
+    inputs=[start, limit, delta],
+    outputs=[output],
+    name="test_range_bfloat16_type_positive_delta",
+)
+```
+
+</details>
+
+
+<details>
+<summary>range_float16_type_positive_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Range",
+    inputs=["start", "limit", "delta"],
+    outputs=["output"],
+)
+
+start = np.float16(1)
+limit = np.float16(5)
+delta = np.float16(2)
+
+output = np.arange(
+    start, limit, delta, dtype=np.float16
+)  # expected output [1.0, 3.0]
+expect(
+    node,
+    inputs=[start, limit, delta],
+    outputs=[output],
+    name="test_range_float16_type_positive_delta",
+)
+```
+
+</details>
+
+
+<details>
+<summary>range_float_type_positive_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Range",
+    inputs=["start", "limit", "delta"],
+    outputs=["output"],
+)
+
+start = np.float32(1)
+limit = np.float32(5)
+delta = np.float32(2)
+
+output = np.arange(
+    start, limit, delta, dtype=np.float32
+)  # expected output [1.0, 3.0]
+expect(
+    node,
+    inputs=[start, limit, delta],
+    outputs=[output],
+    name="test_range_float_type_positive_delta",
+)
+```
+
+</details>
+
+
+<details>
+<summary>range_int32_type_negative_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Range",
+    inputs=["start", "limit", "delta"],
+    outputs=["output"],
+)
+
+start = np.int32(10)
+limit = np.int32(6)
+delta = np.int32(-3)
+
+output = np.arange(
+    start, limit, delta, dtype=np.int32
+)  # expected output [10, 7]
+expect(
+    node,
+    inputs=[start, limit, delta],
+    outputs=[output],
+    name="test_range_int32_type_negative_delta",
+)
+```
+
+</details>
+
+
+### <a name="Reciprocal"></a><a name="reciprocal">**Reciprocal**</a>
+
+  Reciprocal takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the reciprocal is, y = 1/x, is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Reciprocal-1">1</a>, <a href="Changelog.md#Reciprocal-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>reciprocal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Reciprocal",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-4, 2]).astype(np.float32)
+y = np.reciprocal(x)  # expected output [-0.25, 0.5],
+expect(node, inputs=[x], outputs=[y], name="test_reciprocal_example")
+
+x = np.random.rand(3, 4, 5).astype(np.float32) + 0.5
+y = np.reciprocal(x)
+expect(node, inputs=[x], outputs=[y], name="test_reciprocal")
+```
+
+</details>
+
+
+### <a name="ReduceL1"></a><a name="reducel1">**ReduceL1**</a>
+
+  Computes the L1 norm of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceL1-1">1</a>, <a href="Changelog.md#ReduceL1-11">11</a>, <a href="Changelog.md#ReduceL1-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL1", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1)
+# print(reduced)
+# [[[78.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_default_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([2], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceL1",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[3., 7.], [11., 15.], [19., 23.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_do_not_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceL1",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_empty_set",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL1",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_keep_dims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_keep_dims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL1",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_negative_axes_keep_dims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_negative_axes_keep_dims_random",
+)
+```
+
+</details>
+
+
+### <a name="ReduceL2"></a><a name="reducel2">**ReduceL2**</a>
+
+  Computes the L2 norm of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceL2-1">1</a>, <a href="Changelog.md#ReduceL2-11">11</a>, <a href="Changelog.md#ReduceL2-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL2", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sqrt(np.sum(a=np.square(data), axis=None, keepdims=keepdims == 1))
+# print(reduced)
+# [[[25.49509757]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sqrt(np.sum(a=np.square(data), axis=None, keepdims=keepdims == 1))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_default_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([2], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceL2",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+# print(reduced)
+# [[2.23606798, 5.],
+# [7.81024968, 10.63014581],
+# [13.45362405, 16.2788206]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_do_not_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceL2",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_empty_set",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL2",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+# print(reduced)
+# [[[2.23606798], [5.]]
+# [[7.81024968], [10.63014581]]
+# [[13.45362405], [16.2788206 ]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_keep_dims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_keep_dims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL2",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+# print(reduced)
+# [[[2.23606798], [5.]]
+# [[7.81024968], [10.63014581]]
+# [[13.45362405], [16.2788206 ]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_negative_axes_keep_dims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_negative_axes_keep_dims_random",
+)
+```
+
+</details>
+
+
+### <a name="ReduceLogSum"></a><a name="reducelogsum">**ReduceLogSum**</a>
+
+  Computes the log sum of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or undefined otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceLogSum-1">1</a>, <a href="Changelog.md#ReduceLogSum-11">11</a>, <a href="Changelog.md#ReduceLogSum-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceLogSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+reduced = np.log(zero)  # -inf
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_empty_set",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ReduceLogSum", inputs=["data", "axes"], outputs=["reduced"]
+)
+data = np.random.ranf([3, 4, 5]).astype(np.float32)
+reduced = np.log(np.sum(data, keepdims=True))
+axes = np.array([], dtype=np.int64)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_default",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+axes = np.array([-2], dtype=np.int64)
+node = onnx.helper.make_node(
+    "ReduceLogSum", inputs=["data", "axes"], outputs=["reduced"]
+)
+data = np.random.ranf([3, 4, 5]).astype(np.float32)
+reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=True))
+# print(reduced)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_negative_axes",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nokeepdims</summary>
+
+```python
+shape = [3, 4, 5]
+axes = np.array([2, 1], dtype=np.int64)
+
+node = onnx.helper.make_node(
+    "ReduceLogSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=0,
+)
+data = np.random.ranf(shape).astype(np.float32)
+reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=False))
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_desc_axes",
+)
+
+axes = np.array([0, 1], dtype=np.int64)
+node = onnx.helper.make_node(
+    "ReduceLogSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=0,
+)
+data = np.random.ranf(shape).astype(np.float32)
+reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=False))
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_asc_axes",
+)
+```
+
+</details>
+
+
+### <a name="ReduceLogSumExp"></a><a name="reducelogsumexp">**ReduceLogSumExp**</a>
+
+  Computes the log sum exponent of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or undefined otherwise.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceLogSumExp-1">1</a>, <a href="Changelog.md#ReduceLogSumExp-11">11</a>, <a href="Changelog.md#ReduceLogSumExp-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+)
+reduced = np.log(np.sum(np.exp(data), axis=None, keepdims=keepdims == 1))
+# print(reduced)
+# [[[60.00671387]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.double)
+reduced = np.log(np.sum(np.exp(data), axis=None, keepdims=keepdims == 1))
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_default_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+# print(reduced)
+# [[20., 2.31326175]
+# [40.00004578, 2.31326175]
+# [60.00671387, 2.31326175]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.double)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_do_not_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+reduced = np.log(zero)  # -inf
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_empty_set",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+# print(reduced)
+# [[[20., 2.31326175]]
+# [[40.00004578, 2.31326175]]
+# [[60.00671387, 2.31326175]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.double)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+# print(reduced)
+# [[[20., 2.31326175]]
+# [[40.00004578, 2.31326175]]
+# [[60.00671387, 2.31326175]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.double)
+reduced = np.log(
+    np.sum(np.exp(data), axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_negative_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+### <a name="ReduceMax"></a><a name="reducemax">**ReduceMax**</a>
+
+  Computes the max of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields minus infinity (if supported by the datatype) or the minimum value of the data type otherwise.
+
+
+  If the input data type is Boolean, the comparison should consider `False < True`.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceMax-1">1</a>, <a href="Changelog.md#ReduceMax-11">11</a>, <a href="Changelog.md#ReduceMax-12">12</a>, <a href="Changelog.md#ReduceMax-13">13</a>, <a href="Changelog.md#ReduceMax-18">18</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(uint8), tensor(int8), tensor(bool)</dt>
+<dd>Constrain input and output types to numeric and Boolean tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>bool_inputs</summary>
+
+```python
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[True, True], [True, False], [False, True], [False, False]],
+)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=bool(keepdims))
+# print(reduced)
+# [[True],
+#  [True],
+#  [True],
+#  [False]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_bool_inputs",
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = None
+keepdims = 1
+node = onnx.helper.make_node(
+    "ReduceMax", inputs=["data"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.maximum.reduce(data, axis=axes, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_max_default_axes_keepdim_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.maximum.reduce(data, axis=axes, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_max_default_axes_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[20., 2.]
+# [40., 2.]
+# [60., 2.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_do_not_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_do_not_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+one = np.array(np.ones(reduced_shape, dtype=np.float32))
+zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+reduced = -(one / zero)  # -inf
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_empty_set",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[20., 2.]]
+# [[40., 2.]]
+# [[60., 2.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[20., 2.]]
+# [[40., 2.]]
+# [[60., 2.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_negative_axes_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_negative_axes_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+### <a name="ReduceMean"></a><a name="reducemean">**ReduceMean**</a>
+
+  Computes the mean of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields undefined.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceMean-1">1</a>, <a href="Changelog.md#ReduceMean-11">11</a>, <a href="Changelog.md#ReduceMean-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMean",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.mean(data, axis=None, keepdims=keepdims == 1)
+# print(reduced)
+# [[[18.25]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.mean(data, axis=None, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_default_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceMean",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[12.5, 1.5]
+# [35., 1.5]
+# [57.5, 1.5]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_do_not_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMean",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[12.5, 1.5]]
+# [[35., 1.5]]
+# [[57.5, 1.5]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMean",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[12.5, 1.5]]
+# [[35., 1.5]]
+# [[57.5, 1.5]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_negative_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+### <a name="ReduceMin"></a><a name="reducemin">**ReduceMin**</a>
+
+  Computes the min of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields plus infinity (if supported by the datatype) or the maximum value of the data type otherwise.
+
+
+  If the input data type is Boolean, the comparison should consider `False < True`.
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceMin-1">1</a>, <a href="Changelog.md#ReduceMin-11">11</a>, <a href="Changelog.md#ReduceMin-12">12</a>, <a href="Changelog.md#ReduceMin-13">13</a>, <a href="Changelog.md#ReduceMin-18">18</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16), tensor(uint8), tensor(int8), tensor(bool)</dt>
+<dd>Constrain input and output types to numeric and Boolean tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>bool_inputs</summary>
+
+```python
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[True, True], [True, False], [False, True], [False, False]],
+)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=bool(keepdims))
+# print(reduced)
+# [[ True],
+#  [False],
+#  [False],
+#  [False]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_bool_inputs",
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = None
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMin", inputs=["data"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.minimum.reduce(data, axis=axes, keepdims=keepdims == 1)
+# print(reduced)
+# [[[1.]]]
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_min_default_axes_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.minimum.reduce(data, axis=axes, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_min_default_axes_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[5., 1.]
+# [30., 1.]
+# [55., 1.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_do_not_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_do_not_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+one = np.array(np.ones(reduced_shape, dtype=np.float32))
+zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+reduced = one / zero  # inf
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_empty_set",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[5., 1.]]
+# [[30., 1.]]
+# [[55., 1.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[5., 1.]]
+# [[30., 1.]]
+# [[55., 1.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_negative_axes_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_negative_axes_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+### <a name="ReduceProd"></a><a name="reduceprod">**ReduceProd**</a>
+
+  Computes the product of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 1.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceProd-1">1</a>, <a href="Changelog.md#ReduceProd-11">11</a>, <a href="Changelog.md#ReduceProd-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = None
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceProd", inputs=["data"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.prod(data, axis=axes, keepdims=keepdims == 1)
+# print(reduced)
+# [[[4.790016e+08]]]
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_prod_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.prod(data, axis=axes, keepdims=keepdims == 1)
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_prod_default_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceProd",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[3., 8.]
+# [35., 48.]
+# [99., 120.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_do_not_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceProd",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.ones(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_empty_set",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceProd",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[3., 8.]]
+# [[35., 48.]]
+# [[99., 120.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceProd",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[3., 8.]]
+# [[35., 48.]]
+# [[99., 120.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_negative_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+### <a name="ReduceSum"></a><a name="reducesum">**ReduceSum**</a>
+
+  Computes the sum of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceSum-1">1</a>, <a href="Changelog.md#ReduceSum-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(data, axis=None, keepdims=keepdims == 1)
+# print(reduced)
+# [[[78.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(data, axis=None, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_default_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+# print(reduced)
+# [[4., 6.]
+# [12., 14.]
+# [20., 22.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_do_not_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_axes_input_noop</summary>
+
+```python
+shape = [3, 2, 2]
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+    noop_with_empty_axes=True,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+axes = np.array([], dtype=np.int64)
+reduced = np.array(data)
+# print(reduced)
+# [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_empty_axes_input_noop_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.array(data)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_empty_axes_input_noop",
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_set</summary>
+
+```python
+"""Test case with the reduced-axis of size zero."""
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_empty_set",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+# print(reduced)
+# [[[4., 6.]]
+# [[12., 14.]]
+# [[20., 22.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+# print(reduced)
+# [[[4., 6.]]
+# [[12., 14.]]
+# [[20., 22.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_negative_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>non_reduced_axis_zero</summary>
+
+```python
+"""Test case with the non-reduced-axis of size zero."""
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 0, 1]
+
+node = onnx.helper.make_node(
+    "ReduceSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([2], dtype=np.int64)
+reduced = np.array([], dtype=np.float32).reshape(reduced_shape)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_empty_set_non_reduced_axis_zero",
+)
+```
+
+</details>
+
+
+### <a name="ReduceSumSquare"></a><a name="reducesumsquare">**ReduceSumSquare**</a>
+
+  Computes the sum square of the input tensor's elements along the provided axes. The resulting
+  tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+  the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+  valid. Reduction over an empty set of values yields 0.
+
+
+  The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+  to `False` instead of `True`.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ReduceSumSquare-1">1</a>, <a href="Changelog.md#ReduceSumSquare-11">11</a>, <a href="Changelog.md#ReduceSumSquare-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the reduced dimension or not, default 1 means keep reduced dimension.</dd>
+<dt><tt>noop_with_empty_axes</tt> : int (default is 0)</dt>
+<dd>Defines behavior when axes is not provided or is empty. If false (default), reduction happens over all axes (similar to the case when `axis=None` in numpy). If true, reduction happens over an empty set of axes (similar to the case when `axis=()` in numpy). Note that reduction over an empty set of axes means that the reduction step behaves like a no-op (identity function), but composite-reduction operators will still perform the non-reduction steps as needed. Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare returns the Square of the input tensor, in this case.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional input list of integers, along which to reduce. The default is to reduce over empty axes. When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': reduction over all axes if 'noop_with_empty_axes' is false, and reduction over the empty set of axes when 'noop_with_empty_axes' is true. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reduced</tt> (differentiable) : T</dt>
+<dd>Reduced output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint32), tensor(uint64), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(np.square(data), axis=None, keepdims=keepdims == 1)
+# print(reduced)
+# [[[650.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(np.square(data), axis=None, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_default_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[10., 20.]
+# [74., 100.]
+# [202., 244.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_do_not_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_empty_set",
+)
+```
+
+</details>
+
+
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[10., 20.]]
+# [[74., 100.]]
+# [[202., 244.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_keepdims_random",
+)
+```
+
+</details>
+
+
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[10., 20.s]]
+# [[74., 100.]]
+# [[202., 244.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_negative_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+### <a name="RegexFullMatch"></a><a name="regexfullmatch">**RegexFullMatch**</a>
+
+  RegexFullMatch performs a full regex match on each element of the input tensor. If an element fully matches the regex pattern specified as an attribute, the corresponding element in the output is True and it is False otherwise. [RE2](https://github.com/google/re2/wiki/Syntax) regex syntax is used.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>pattern</tt> : string</dt>
+<dd>Regex pattern to match on. This must be valid RE2 syntax.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>Tensor with strings to match on.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>Tensor of bools indicating if each input string fully matches the regex pattern specified.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string)</dt>
+<dd>Inputs must be UTF-8 strings</dd>
+<dt><tt>T2</tt> : tensor(bool)</dt>
+<dd>Outputs are bools and are True where there is a full regex match and False otherwise.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>basic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RegexFullMatch",
+    inputs=["X"],
+    outputs=["Y"],
+    pattern=r"www\.[\w.-]+\.\bcom\b",
+)
+
+x = np.array(["www.google.com", "www.facebook.com", "www.bbc.co.uk"]).astype(
+    object
+)
+result = np.array([True, True, False])
+expect(node, inputs=[x], outputs=[result], name="test_regex_full_match_basic")
+```
+
+</details>
+
+
+<details>
+<summary>match_email_domain</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RegexFullMatch",
+    inputs=["X"],
+    outputs=["Y"],
+    pattern=r"(\W|^)[\w.\-]{0,25}@(yahoo|gmail)\.com(\W|$)",
+)
+
+x = np.array(
+    [
+        ["account@gmail.com", "account@hotmail.com"],
+        ["not email", "account2@yahoo.com"],
+    ]
+).astype(object)
+result = np.array([[True, False], [False, True]])
+expect(
+    node,
+    inputs=[x],
+    outputs=[result],
+    name="test_regex_full_match_email_domain",
+)
+```
+
+</details>
+
+
+<details>
+<summary>match_empty</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RegexFullMatch",
+    inputs=["X"],
+    outputs=["Y"],
+    pattern=r"(\W|^)[\w.\-]{0,25}@(yahoo|gmail)\.com(\W|$)",
+)
+
+x = np.array([[], []]).astype(object)
+result = np.array([[], []]).astype(bool)
+expect(
+    node,
+    inputs=[x],
+    outputs=[result],
+    name="test_regex_full_match_empty",
+)
+```
+
+</details>
+
+
+### <a name="Relu"></a><a name="relu">**Relu**</a>
+
+  Relu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the rectified linear function, y = max(0, x), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Relu-1">1</a>, <a href="Changelog.md#Relu-6">6</a>, <a href="Changelog.md#Relu-13">13</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(int32), tensor(int8), tensor(int16), tensor(int64), tensor(float16), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to signed numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>relu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Relu",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf)
+
+expect(node, inputs=[x], outputs=[y], name="test_relu")
+```
+
+</details>
+
+
+### <a name="Reshape"></a><a name="reshape">**Reshape**</a>
+
+  Reshape the input tensor similar to numpy.reshape.
+  First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+  At most one dimension of the new shape can be -1. In this case, the value is
+  inferred from the size of the tensor and the remaining dimensions. A dimension
+  could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+  from the input tensor). If 'allowzero' is set, and the new shape includes 0, the
+  dimension will be set explicitly to zero (i.e. not taken from input tensor).
+  Shape (second input) could be an empty shape, which means converting to a scalar.
+  The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+  If the attribute 'allowzero' is set, it is invalid for the specified shape to
+  contain both a zero value and -1, as the value of the dimension corresponding
+  to -1 cannot be determined uniquely.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Reshape-1">1</a>, <a href="Changelog.md#Reshape-5">5</a>, <a href="Changelog.md#Reshape-13">13</a>, <a href="Changelog.md#Reshape-14">14</a>, <a href="Changelog.md#Reshape-19">19</a>, <a href="Changelog.md#Reshape-21">21</a>, <a href="Changelog.md#Reshape-23">23</a>, <a href="Changelog.md#Reshape-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>allowzero</tt> : int (default is 0)</dt>
+<dd>(Optional) By default, when any value in the 'shape' input is equal to zero the corresponding dimension value is copied from the input tensor dynamically. allowzero=1 indicates that if any value in the 'shape' input is set to zero, the zero value is honored, similar to NumPy.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+<dt><tt>shape</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Specified shape for output.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>reshaped</tt> (differentiable) : T</dt>
+<dd>Reshaped data.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>allowzero</summary>
+
+```python
+original_shape = [0, 3, 4]
+test_cases = {
+    "allowzero_reordered": np.array([3, 4, 0], dtype=np.int64),
+}
+data = np.random.random_sample(original_shape).astype(np.float32)
+
+for test_name, shape in test_cases.items():
+    node = onnx.helper.make_node(
+        "Reshape",
+        inputs=["data", "shape"],
+        outputs=["reshaped"],
+        allowzero=1,  # if allowzero=1, final shape = (3, 4, 0)
+        # if allowzero=0, final shape = (3, 4, 4)
+    )
+
+    reshaped = reshape_reference_implementation(data, shape, allowzero=1)
+
+    expect(
+        node,
+        inputs=[data, shape],
+        outputs=[reshaped],
+        name="test_reshape_" + test_name,
+    )
+```
+
+</details>
+
+
+<details>
+<summary>reshape</summary>
+
+```python
+original_shape = [2, 3, 4]
+test_cases = {
+    "reordered_all_dims": np.array([4, 2, 3], dtype=np.int64),
+    "reordered_last_dims": np.array([2, 4, 3], dtype=np.int64),
+    "reduced_dims": np.array([2, 12], dtype=np.int64),
+    "extended_dims": np.array([2, 3, 2, 2], dtype=np.int64),
+    "one_dim": np.array([24], dtype=np.int64),
+    "negative_dim": np.array([2, -1, 2], dtype=np.int64),
+    "negative_extended_dims": np.array([-1, 2, 3, 4], dtype=np.int64),
+    "zero_dim": np.array([2, 0, 4, 1], dtype=np.int64),
+    "zero_and_negative_dim": np.array([2, 0, 1, -1], dtype=np.int64),
+}
+data = np.random.random_sample(original_shape).astype(np.float32)
+
+for test_name, shape in test_cases.items():
+    node = onnx.helper.make_node(
+        "Reshape",
+        inputs=["data", "shape"],
+        outputs=["reshaped"],
+    )
+
+    reshaped = reshape_reference_implementation(data, shape)
+
+    expect(
+        node,
+        inputs=[data, shape],
+        outputs=[reshaped],
+        name="test_reshape_" + test_name,
+    )
+```
+
+</details>
+
+
+### <a name="Resize"></a><a name="resize">**Resize**</a>
+
+  Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
+  Each dimension value of the output tensor is:
+  ```
+  output_dimension = floor(input_dimension * (roi_end - roi_start) * scale)
+  ```
+  if input \"sizes\" is not specified.
+
+#### Version
+
+This version of the operator has been available since version 19 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Resize-10">10</a>, <a href="Changelog.md#Resize-11">11</a>, <a href="Changelog.md#Resize-13">13</a>, <a href="Changelog.md#Resize-18">18</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>antialias</tt> : int (default is 0)</dt>
+<dd>If set to 1, "linear" and "cubic" interpolation modes will use an antialiasing filter when downscaling. Antialiasing is achieved by stretching the resampling filter by a factor max(1, 1 / scale), which means that when downsampling, more input pixels contribute to an output pixel.</dd>
+<dt><tt>axes</tt> : list of ints</dt>
+<dd>If provided, it specifies a subset of axes that 'roi', 'scales' and 'sizes' refer to. If not provided, all axes are assumed [0, 1, ..., r-1], where r = rank(data). Non-specified dimensions are interpreted as non-resizable. Negative value means counting dimensions from the back. Accepted range is [-r, r-1], where r = rank(data). Behavior is undefined if an axis is repeated.</dd>
+<dt><tt>coordinate_transformation_mode</tt> : string (default is half_pixel)</dt>
+<dd>
+This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor.
+
+The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
+Denote `x_resized` as the coordinate of axis x in the resized tensor,
+ `x_original` as the coordinate of axis x in the original tensor,
+ `length_original` as the length of the original tensor in axis x,
+ `length_resized` as the length of the resized tensor in axis x,
+ `scale = length_resized / length_original`,
+ `output_width` the target length on the axis x which can be a fractional number when it is calculated out of a scale factor,
+ and `output_width_int` the effective output width as an integer.
+
+if coordinate_transformation_mode is `"half_pixel"`,
+```
+x_original = (x_resized + 0.5) / scale - 0.5
+```
+
+if coordinate_transformation_mode is `"half_pixel_symmetric"`,
+```
+adjustment = output_width_int / output_width
+center = input_width / 2
+offset = center * (1 - adjustment)
+x_ori = offset + (x + 0.5) / scale - 0.5
+```
+
+if coordinate_transformation_mode is `"pytorch_half_pixel"`,
+```
+x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0
+```
+
+if coordinate_transformation_mode is `"align_corners"`,
+```
+x_original = x_resized * (length_original - 1) / (length_resized - 1)
+```
+
+if coordinate_transformation_mode is `"asymmetric"`,
+```
+x_original = x_resized / scale
+```
+
+if coordinate_transformation_mode is `"tf_crop_and_resize"`,
+```
+x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1)
+```
+.</dd>
+<dt><tt>cubic_coeff_a</tt> : float (default is -0.75)</dt>
+<dd>The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75 (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. This attribute is valid only if mode is "cubic".</dd>
+<dt><tt>exclude_outside</tt> : int (default is 0)</dt>
+<dd>If set to 1, the weight of sampling locations outside the tensor will be set to 0 and the weight will be renormalized so that their sum is 1.0. The default value is 0.</dd>
+<dt><tt>extrapolation_value</tt> : float (default is 0.0)</dt>
+<dd>When coordinate_transformation_mode is "tf_crop_and_resize" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f.</dd>
+<dt><tt>keep_aspect_ratio_policy</tt> : string (default is stretch)</dt>
+<dd>
+This attribute describes how to interpret the `sizes` input with regard to keeping the original aspect ratio of the input, and it is not applicable when
+the `scales` input is used.
+
+Given a set of `sizes`, associated with a subset of `axes` (explicitly provided or default), and assuming `d = axes[i]`, with `i` being the index of the provided `sizes`.
+
+If `keep_aspect_ratio_policy` is `"stretch"`, the original aspect ratio is disregarded, and the input is resized to the specified size:
+`out_size[d] = sizes[i]`
+
+If `keep_aspect_ratio_policy` is `"not_larger"`, the sizes are adjusted so that no extent of the output is larger than the specified size, while keeping the original aspect ratio:
+```
+scale = Min(sizes[i] / in_size[d])
+out_size[d] = round_int(scale * in_size[d])
+```
+
+If `keep_aspect_ratio_policy` is `"not_smaller"`, the sizes are adjusted so that no extent of the output is smaller than the specified size, while keeping the original aspect ratio:
+```
+scale = Max(sizes[i] / in_size[d])
+out_size[d] = round_int(scale * in_size[d])
+```
+
+For non-resizable axes (those not specified in `axes`), the output size will be equal to the input size.
+
+Note: `round_int` stands for computing the nearest integer value, rounding halfway cases up.</dd>
+<dt><tt>mode</tt> : string (default is nearest)</dt>
+<dd>Three interpolation modes: "nearest" (default), "linear" and "cubic". The "linear" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). The "cubic" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor).</dd>
+<dt><tt>nearest_mode</tt> : string (default is round_prefer_floor)</dt>
+<dd>Four modes: "round_prefer_floor" (default, as known as round half down), "round_prefer_ceil" (as known as round half up), "floor", "ceil". Only used by nearest interpolation. It indicates how to get "nearest" pixel in input tensor from x_original, so this attribute is valid only if "mode" is "nearest".</dd>
+</dl>
+
+#### Inputs (1 - 4)
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T1</dt>
+<dd>N-D tensor</dd>
+<dt><tt>roi</tt> (optional, non-differentiable) : T2</dt>
+<dd>1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X or the length of axes, if provided. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is "tf_crop_and_resize"</dd>
+<dt><tt>scales</tt> (optional, non-differentiable) : tensor(float)</dt>
+<dd>The scale array along each dimension. It takes value greater than 0. If it's less than 1, it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should be the same as the rank of input 'X' or the length of 'axes', if provided. One of 'scales' and 'sizes' MUST be specified and it is an error if both are specified. If 'sizes' is needed, the user can use an empty string as the name of 'scales' in this operator's input list.</dd>
+<dt><tt>sizes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Target size of the output tensor. Its interpretation depends on the 'keep_aspect_ratio_policy' value.The number of elements of 'sizes' should be the same as the rank of input 'X', or the length of 'axes', if provided. Only one of 'scales' and 'sizes' can be specified. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T1</dt>
+<dd>N-D tensor after resizing</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input 'X' and output 'Y' to all tensor types.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain roi type to float or double.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>resize_downsample_scales_cubic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32)
+
+# [[[[ 1.47119141  2.78125     4.08251953]
+#    [ 6.71142578  8.02148438  9.32275391]
+#    [11.91650391 13.2265625  14.52783203]]]]
+output = interpolate_nd(
+    data, lambda x, _: cubic_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_cubic",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_scales_cubic_A_n0p5_exclude_outside</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    cubic_coeff_a=-0.5,
+    exclude_outside=True,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32)
+
+# [[[[ 1.36812675  2.6695014   4.0133367 ]
+#    [ 6.57362535  7.875       9.2188353 ]
+#    [11.94896657 13.25034122 14.59417652]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x, A=-0.5),
+    scale_factors=scales,
+    exclude_outside=True,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_cubic_A_n0p5_exclude_outside",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_scales_cubic_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    coordinate_transformation_mode="align_corners",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32)
+
+# [[[[ 1.          2.39519159  3.79038317]
+#    [ 6.58076634  7.97595793  9.37114951]
+#    [12.16153268 13.55672427 14.95191585]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_cubic_align_corners",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_scales_cubic_antialias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    antialias=1,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[ 2.5180721  4.2858863]
+#    [ 9.589329  11.357142 ]]]]
+output = interpolate_nd(
+    data, cubic_coeffs_antialias, scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_cubic_antialias",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_scales_linear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[2.6666665 4.3333331]]]]
+output = interpolate_nd(
+    data, lambda x, _: linear_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_linear",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_scales_linear_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="align_corners",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[1.       3.142857]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_linear_align_corners",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_scales_linear_antialias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    antialias=1,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[ 2.875  4.5  ]
+#    [ 9.375 11.   ]]]]
+output = interpolate_nd(
+    data, linear_coeffs_antialias, scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_linear_antialias",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_scales_linear_half_pixel_symmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="half_pixel_symmetric",
+)
+
+data = np.array([[[[1, 2, 3, 4]]]], dtype=np.float32)
+scales = np.array([1.0, 1.0, 1.0, 0.6], dtype=np.float32)
+
+# [[[[1.6666667, 3.3333333]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="half_pixel_symmetric",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_linear_half_pixel_symmetric",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_scales_nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[1. 3.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_nearest",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_sizes_cubic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="cubic",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 1.63078704  3.00462963  4.37847222]
+#    [ 7.12615741  8.5         9.87384259]
+#    [12.62152778 13.99537037 15.36921296]]]]
+output = interpolate_nd(
+    data, lambda x, _: cubic_coeffs(x), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_cubic",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_sizes_cubic_antialias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="cubic",
+    antialias=1,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 1.7750092  3.1200073  4.4650054]
+#    [ 7.1550016  8.5        9.844998 ]
+#    [12.534994  13.8799925 15.224991 ]]]]
+output = interpolate_nd(data, cubic_coeffs_antialias, output_size=sizes).astype(
+    np.float32
+)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_cubic_antialias",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_sizes_linear_antialias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    antialias=1,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 2.3636363  3.590909   4.818182 ]
+#    [ 7.2727275  8.5        9.727273 ]
+#    [12.181818  13.409091  14.636364 ]]]]
+output = interpolate_nd(
+    data, linear_coeffs_antialias, output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_linear_antialias",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_sizes_linear_pytorch_half_pixel</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="pytorch_half_pixel",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 3, 1], dtype=np.int64)
+
+# [[[[ 1.6666666]
+#    [ 7.       ]
+#    [12.333333 ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    coordinate_transformation_mode="pytorch_half_pixel",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_linear_pytorch_half_pixel",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_sizes_nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 1, 3], dtype=np.int64)
+
+# [[[[1. 2. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_nearest",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_sizes_nearest_not_larger</summary>
+
+```python
+keep_aspect_ratio_policy = "not_larger"
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 3], dtype=np.int64)  # Results in 1x2
+
+# [[[[1. 3.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x),
+    output_size=sizes,
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_nearest_not_larger",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_downsample_sizes_nearest_not_smaller</summary>
+
+```python
+keep_aspect_ratio_policy = "not_smaller"
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 3], dtype=np.int64)  # Results in 2x3
+
+# [[[[1. 2. 4.]
+#    [5. 6. 8.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x),
+    output_size=sizes,
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_nearest_not_smaller",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_tf_crop_and_resize</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "roi", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="tf_crop_and_resize",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# Note: for some rois, the result may be different with that of TF for inaccurate floating point
+roi = np.array([0, 0, 0.4, 0.6, 1, 1, 0.6, 0.8], dtype=np.float32)
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 7.6000004  7.9        8.2      ]
+#    [ 8.8        9.1        9.400001 ]
+#    [10.        10.3       10.6      ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    roi=roi,
+    coordinate_transformation_mode="tf_crop_and_resize",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, roi, sizes],
+    outputs=[output],
+    name="test_resize_tf_crop_and_resize",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_tf_crop_and_resize_axes_2_3</summary>
+
+```python
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "roi", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="tf_crop_and_resize",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# Note: for some rois, the result may be different with that of TF for inaccurate floating point
+roi = np.array([0.4, 0.6, 0.6, 0.8], dtype=np.float32)
+sizes = np.array([3, 3], dtype=np.int64)
+
+# [[[[ 7.6000004  7.9        8.2      ]
+#    [ 8.8        9.1        9.400001 ]
+#    [10.        10.3       10.6      ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    roi=roi,
+    axes=axes,
+    coordinate_transformation_mode="tf_crop_and_resize",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, roi, sizes],
+    outputs=[output],
+    name="test_resize_tf_crop_and_resize_axes_2_3",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_tf_crop_and_resize_axes_3_2</summary>
+
+```python
+axes = [3, 2]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "roi", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="tf_crop_and_resize",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# Note: for some rois, the result may be different with that of TF for inaccurate floating point
+roi = np.array([0.6, 0.4, 0.8, 0.6], dtype=np.float32)
+sizes = np.array([3, 3], dtype=np.int64)
+
+# [[[[ 7.6000004  7.9        8.2      ]
+#    [ 8.8        9.1        9.400001 ]
+#    [10.        10.3       10.6      ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    roi=roi,
+    axes=axes,
+    coordinate_transformation_mode="tf_crop_and_resize",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, roi, sizes],
+    outputs=[output],
+    name="test_resize_tf_crop_and_resize_axes_3_2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_tf_crop_and_resize_extrapolation_value</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "roi", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="tf_crop_and_resize",
+    extrapolation_value=10.0,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# Note: for some rois, the result may be different with that of TF for inaccurate floating point
+roi = np.array([0, 0, 0.4, 0.6, 1, 1, 1.2, 1.7], dtype=np.float32)
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 7.6000004 10.        10.       ]
+#    [12.400001  10.        10.       ]
+#    [10.        10.        10.       ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    roi=roi,
+    coordinate_transformation_mode="tf_crop_and_resize",
+    extrapolation_value=10.0,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, roi, sizes],
+    outputs=[output],
+    name="test_resize_tf_crop_and_resize_extrapolation_value",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_cubic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[ 0.47265625  0.76953125  1.24609375  1.875       2.28125
+#      2.91015625  3.38671875  3.68359375]
+#    [ 1.66015625  1.95703125  2.43359375  3.0625      3.46875
+#      4.09765625  4.57421875  4.87109375]
+#    [ 3.56640625  3.86328125  4.33984375  4.96875     5.375
+#      6.00390625  6.48046875  6.77734375]
+#    [ 6.08203125  6.37890625  6.85546875  7.484375    7.890625
+#      8.51953125  8.99609375  9.29296875]
+#    [ 7.70703125  8.00390625  8.48046875  9.109375    9.515625
+#     10.14453125 10.62109375 10.91796875]
+#    [10.22265625 10.51953125 10.99609375 11.625      12.03125
+#     12.66015625 13.13671875 13.43359375]
+#    [12.12890625 12.42578125 12.90234375 13.53125    13.9375
+#     14.56640625 15.04296875 15.33984375]
+#    [13.31640625 13.61328125 14.08984375 14.71875    15.125
+#     15.75390625 16.23046875 16.52734375]]]]
+output = interpolate_nd(
+    data, lambda x, _: cubic_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_cubic",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_cubic_A_n0p5_exclude_outside</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    cubic_coeff_a=-0.5,
+    exclude_outside=True,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[ 0.55882353  0.81494204  1.35698249  1.89705882  2.39705882
+#      2.93713516  3.47917561  3.73529412]
+#    [ 1.58329755  1.83941606  2.38145651  2.92153285  3.42153285
+#      3.96160918  4.50364964  4.75976814]
+#    [ 3.75145936  4.00757787  4.54961832  5.08969466  5.58969466
+#      6.12977099  6.67181144  6.92792995]
+#    [ 5.91176471  6.16788321  6.70992366  7.25        7.75
+#      8.29007634  8.83211679  9.08823529]
+#    [ 7.91176471  8.16788321  8.70992366  9.25        9.75
+#     10.29007634 10.83211679 11.08823529]
+#    [10.07207005 10.32818856 10.87022901 11.41030534 11.91030534
+#     12.45038168 12.99242213 13.24854064]
+#    [12.24023186 12.49635036 13.03839082 13.57846715 14.07846715
+#     14.61854349 15.16058394 15.41670245]
+#    [13.26470588 13.52082439 14.06286484 14.60294118 15.10294118
+#     15.64301751 16.18505796 16.44117647]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x, A=-0.5),
+    scale_factors=scales,
+    exclude_outside=True,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_cubic_A_n0p5_exclude_outside",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_cubic_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    coordinate_transformation_mode="align_corners",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[ 1.          1.34110787  1.80029155  2.32944606  2.67055394
+#      3.19970845  3.65889213  4.        ]
+#    [ 2.36443149  2.70553936  3.16472303  3.69387755  4.03498542
+#      4.56413994  5.02332362  5.36443149]
+#    [ 4.20116618  4.54227405  5.00145773  5.53061224  5.87172012
+#      6.40087464  6.86005831  7.20116618]
+#    [ 6.31778426  6.65889213  7.1180758   7.64723032  7.98833819
+#      8.51749271  8.97667638  9.31778426]
+#    [ 7.68221574  8.02332362  8.48250729  9.01166181  9.35276968
+#      9.8819242  10.34110787 10.68221574]
+#    [ 9.79883382 10.13994169 10.59912536 11.12827988 11.46938776
+#     11.99854227 12.45772595 12.79883382]
+#    [11.63556851 11.97667638 12.43586006 12.96501458 13.30612245
+#     13.83527697 14.29446064 14.63556851]
+#    [13.         13.34110787 13.80029155 14.32944606 14.67055394
+#     15.19970845 15.65889213 16.        ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_cubic_align_corners",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_cubic_asymmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    coordinate_transformation_mode="asymmetric",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[ 1.       1.40625  2.       2.5      3.       3.59375  4.
+#      4.09375]
+#    [ 2.625    3.03125  3.625    4.125    4.625    5.21875  5.625
+#      5.71875]
+#    [ 5.       5.40625  6.       6.5      7.       7.59375  8.
+#      8.09375]
+#    [ 7.       7.40625  8.       8.5      9.       9.59375 10.
+#     10.09375]
+#    [ 9.       9.40625 10.      10.5     11.      11.59375 12.
+#     12.09375]
+#    [11.375   11.78125 12.375   12.875   13.375   13.96875 14.375
+#     14.46875]
+#    [13.      13.40625 14.      14.5     15.      15.59375 16.
+#     16.09375]
+#    [13.375   13.78125 14.375   14.875   15.375   15.96875 16.375
+#     16.46875]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x, A=-0.75),
+    scale_factors=scales,
+    coordinate_transformation_mode="asymmetric",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_cubic_asymmetric",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_linear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[1.   1.25 1.75 2.  ]
+#    [1.5  1.75 2.25 2.5 ]
+#    [2.5  2.75 3.25 3.5 ]
+#    [3.   3.25 3.75 4.  ]]]]
+output = interpolate_nd(
+    data, lambda x, _: linear_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_linear",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_linear_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="align_corners",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[1.         1.33333333 1.66666667 2.        ]
+#    [1.66666667 2.         2.33333333 2.66666667]
+#    [2.33333333 2.66666667 3.         3.33333333]
+#    [3.         3.33333333 3.66666667 4.        ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_linear_align_corners",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_linear_half_pixel_symmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="half_pixel_symmetric",
+)
+
+data = np.array([[[[1, 2], [3, 4]]]], dtype=np.float32)
+scales = np.array([1.0, 1.0, 2.3, 2.94], dtype=np.float32)
+
+# [[[[1.        , 1.15986395, 1.5       , 1.84013605, 2.        ],
+#    [1.56521738, 1.72508133, 2.06521738, 2.40535343, 2.56521738],
+#    [2.43478262, 2.59464657, 2.93478262, 3.27491867, 3.43478262],
+#    [3.        , 3.15986395, 3.5       , 3.84013605, 4.        ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="half_pixel_symmetric",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_linear_half_pixel_symmetric",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
+
+# [[[[1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 2. 2. 2.]
+#    [3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_nearest",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_nearest_axes_2_3</summary>
+
+```python
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([2.0, 3.0], dtype=np.float32)
+
+# [[[[1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 2. 2. 2.]
+#    [3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), scale_factors=scales, axes=axes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_nearest_axes_2_3",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_scales_nearest_axes_3_2</summary>
+
+```python
+axes = [3, 2]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([3.0, 2.0], dtype=np.float32)
+
+# [[[[1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 2. 2. 2.]
+#    [3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), scale_factors=scales, axes=axes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_nearest_axes_3_2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_sizes_cubic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="cubic",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 9, 10], dtype=np.int64)
+
+# [[[[ 0.45507922  0.64057922  0.97157922  1.42257922  1.90732922
+#      2.22332922  2.70807922  3.15907922  3.49007922  3.67557922]
+#    [ 1.39437963  1.57987963  1.91087963  2.36187963  2.84662963
+#      3.16262963  3.64737963  4.09837963  4.42937963  4.61487963]
+#    [ 2.95130693  3.13680693  3.46780693  3.91880693  4.40355693
+#      4.71955693  5.20430693  5.65530693  5.98630693  6.17180693]
+#    [ 5.20525069  5.39075069  5.72175069  6.17275069  6.65750069
+#      6.97350069  7.45825069  7.90925069  8.24025069  8.42575069]
+#    [ 6.88975     7.07525     7.40625     7.85725     8.342
+#      8.658       9.14275     9.59375     9.92475    10.11025   ]
+#    [ 8.57424931  8.75974931  9.09074931  9.54174931 10.02649931
+#     10.34249931 10.82724931 11.27824931 11.60924931 11.79474931]
+#    [10.82819307 11.01369307 11.34469307 11.79569307 12.28044307
+#     12.59644307 13.08119307 13.53219307 13.86319307 14.04869307]
+#    [12.38512037 12.57062037 12.90162037 13.35262037 13.83737037
+#     14.15337037 14.63812037 15.08912037 15.42012037 15.60562037]
+#    [13.32442078 13.50992078 13.84092078 14.29192078 14.77667078
+#     15.09267078 15.57742078 16.02842078 16.35942078 16.54492078]]]]
+output = interpolate_nd(
+    data, lambda x, _: cubic_coeffs(x), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_cubic",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_sizes_nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 7, 8], dtype=np.int64)
+
+# [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_sizes_nearest_axes_2_3</summary>
+
+```python
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([7, 8], dtype=np.int64)
+
+# [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), output_size=sizes, axes=axes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_axes_2_3",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_sizes_nearest_axes_3_2</summary>
+
+```python
+axes = [3, 2]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([8, 7], dtype=np.int64)
+
+# [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), output_size=sizes, axes=axes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_axes_3_2",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_sizes_nearest_ceil_half_pixel</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    coordinate_transformation_mode="half_pixel",
+    nearest_mode="ceil",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 8, 8], dtype=np.int64)
+
+# [[[[ 1.  2.  2.  3.  3.  4.  4.  4.]
+#    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+#    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+#    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+#    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x, mode="ceil"), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_ceil_half_pixel",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_sizes_nearest_floor_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    coordinate_transformation_mode="align_corners",
+    nearest_mode="floor",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 8, 8], dtype=np.int64)
+
+# [[[[ 1.  1.  1.  2.  2.  3.  3.  4.]
+#    [ 1.  1.  1.  2.  2.  3.  3.  4.]
+#    [ 1.  1.  1.  2.  2.  3.  3.  4.]
+#    [ 5.  5.  5.  6.  6.  7.  7.  8.]
+#    [ 5.  5.  5.  6.  6.  7.  7.  8.]
+#    [ 9.  9.  9. 10. 10. 11. 11. 12.]
+#    [ 9.  9.  9. 10. 10. 11. 11. 12.]
+#    [13. 13. 13. 14. 14. 15. 15. 16.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x, mode="floor"),
+    output_size=sizes,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_floor_align_corners",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_sizes_nearest_not_larger</summary>
+
+```python
+keep_aspect_ratio_policy = "not_larger"
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([7, 8], dtype=np.int64)  # Results in 7x7
+
+# [[[[1. 1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x),
+    output_size=sizes,
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_not_larger",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_sizes_nearest_not_smaller</summary>
+
+```python
+keep_aspect_ratio_policy = "not_smaller"
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([7, 8], dtype=np.int64)  # Results in 8x8
+
+# [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x),
+    output_size=sizes,
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_not_smaller",
+)
+```
+
+</details>
+
+
+<details>
+<summary>resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    coordinate_transformation_mode="asymmetric",
+    nearest_mode="round_prefer_ceil",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 8, 8], dtype=np.int64)
+
+# [[[[ 1.  2.  2.  3.  3.  4.  4.  4.]
+#    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+#    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+#    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+#    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x, mode="round_prefer_ceil"),
+    output_size=sizes,
+    coordinate_transformation_mode="asymmetric",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric",
+)
+```
+
+</details>
+
+
+### <a name="ReverseSequence"></a><a name="reversesequence">**ReverseSequence**</a>
+
+  Reverse batch of sequences having different lengths specified by `sequence_lens`.
+
+  For each slice i iterating on batch axis, the operator reverses the first sequence_lens[i] elements on time axis,
+  and copies elements whose index's beyond sequence_lens[i] to the output. So the output slice i contains reversed
+  sequences on the first sequence_lens[i] elements, then have original values copied for the other elements.
+
+  Example 1:
+    input = [[0.0, 4.0, 8.0,  12.0],
+             [1.0, 5.0, 9.0,  13.0],
+             [2.0, 6.0, 10.0, 14.0],
+             [3.0, 7.0, 11.0, 15.0]]
+    sequence_lens = [4, 3, 2, 1]
+    time_axis = 0
+    batch_axis = 1
+
+    output = [[3.0, 6.0, 9.0,  12.0],
+              [2.0, 5.0, 8.0,  13.0],
+              [1.0, 4.0, 10.0, 14.0],
+              [0.0, 7.0, 11.0, 15.0]]
+
+  Example 2:
+    input = [[0.0,  1.0,  2.0,  3.0 ],
+             [4.0,  5.0,  6.0,  7.0 ],
+             [8.0,  9.0,  10.0, 11.0],
+             [12.0, 13.0, 14.0, 15.0]]
+    sequence_lens = [1, 2, 3, 4]
+    time_axis = 1
+    batch_axis = 0
+
+    output = [[0.0,  1.0,  2.0,  3.0 ],
+              [5.0,  4.0,  6.0,  7.0 ],
+              [10.0, 9.0,  8.0,  11.0],
+              [15.0, 14.0, 13.0, 12.0]]
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>batch_axis</tt> : int (default is 1)</dt>
+<dd>(Optional) Specify which axis is batch axis. Must be one of 1 (default), or 0.</dd>
+<dt><tt>time_axis</tt> : int (default is 0)</dt>
+<dd>(Optional) Specify which axis is time axis. Must be one of 0 (default), or 1.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>Tensor of rank r >= 2.</dd>
+<dt><tt>sequence_lens</tt> : tensor(int64)</dt>
+<dd>Tensor specifying lengths of the sequences in a batch. It has shape `[batch_size]`.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Tensor with same shape of input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input and output types can be of any tensor type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>reversesequence_batch</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ReverseSequence",
+    inputs=["x", "sequence_lens"],
+    outputs=["y"],
+    time_axis=1,
+    batch_axis=0,
+)
+x = np.array(
+    [
+        [0.0, 1.0, 2.0, 3.0],
+        [4.0, 5.0, 6.0, 7.0],
+        [8.0, 9.0, 10.0, 11.0],
+        [12.0, 13.0, 14.0, 15.0],
+    ],
+    dtype=np.float32,
+)
+sequence_lens = np.array([1, 2, 3, 4], dtype=np.int64)
+
+y = np.array(
+    [
+        [0.0, 1.0, 2.0, 3.0],
+        [5.0, 4.0, 6.0, 7.0],
+        [10.0, 9.0, 8.0, 11.0],
+        [15.0, 14.0, 13.0, 12.0],
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[x, sequence_lens],
+    outputs=[y],
+    name="test_reversesequence_batch",
+)
+```
+
+</details>
+
+
+<details>
+<summary>reversesequence_time</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ReverseSequence",
+    inputs=["x", "sequence_lens"],
+    outputs=["y"],
+    time_axis=0,
+    batch_axis=1,
+)
+x = np.array(
+    [
+        [0.0, 4.0, 8.0, 12.0],
+        [1.0, 5.0, 9.0, 13.0],
+        [2.0, 6.0, 10.0, 14.0],
+        [3.0, 7.0, 11.0, 15.0],
+    ],
+    dtype=np.float32,
+)
+sequence_lens = np.array([4, 3, 2, 1], dtype=np.int64)
+
+y = np.array(
+    [
+        [3.0, 6.0, 9.0, 12.0],
+        [2.0, 5.0, 8.0, 13.0],
+        [1.0, 4.0, 10.0, 14.0],
+        [0.0, 7.0, 11.0, 15.0],
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[x, sequence_lens],
+    outputs=[y],
+    name="test_reversesequence_time",
+)
+```
+
+</details>
+
+
+### <a name="RoiAlign"></a><a name="roialign">**RoiAlign**</a>
+
+  Region of Interest (RoI) align operation described in the
+  [Mask R-CNN paper](https://arxiv.org/abs/1703.06870).
+  RoiAlign consumes an input tensor X and region of interests (rois)
+  to apply pooling across each RoI; it produces a 4-D tensor of shape
+  (num_rois, C, output_height, output_width).
+
+  RoiAlign is proposed to avoid the misalignment by removing
+  quantizations while converting from original image into feature
+  map and from feature map into RoI feature; in each ROI bin,
+  the value of the sampled locations are computed directly
+  through bilinear interpolation.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#RoiAlign-10">10</a>, <a href="Changelog.md#RoiAlign-16">16</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>coordinate_transformation_mode</tt> : string (default is half_pixel)</dt>
+<dd>Allowed values are 'half_pixel' and 'output_half_pixel'. Use the value 'half_pixel' to pixel shift the input coordinates by -0.5 (the recommended behavior). Use the value 'output_half_pixel' to omit the pixel shift for the input (use this for a backward-compatible behavior).</dd>
+<dt><tt>mode</tt> : string (default is avg)</dt>
+<dd>The pooling method. Two modes are supported: 'avg' and 'max'. Default is 'avg'.</dd>
+<dt><tt>output_height</tt> : int (default is 1)</dt>
+<dd>default 1; Pooled output Y's height.</dd>
+<dt><tt>output_width</tt> : int (default is 1)</dt>
+<dd>default 1; Pooled output Y's width.</dd>
+<dt><tt>sampling_ratio</tt> : int (default is 0)</dt>
+<dd>Number of sampling points in the interpolation grid used to compute the output value of each pooled output bin. If > 0, then exactly sampling_ratio x sampling_ratio grid points are used. If == 0, then an adaptive number of grid points are used (computed as ceil(roi_width / output_width), and likewise for height). Default is 0.</dd>
+<dt><tt>spatial_scale</tt> : float (default is 1.0)</dt>
+<dd>Multiplicative spatial scale factor to translate ROI coordinates from their input spatial scale to the scale used when pooling, i.e., spatial scale of the input feature map X relative to the input image. E.g.; default is 1.0f. </dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : T1</dt>
+<dd>Input data tensor from the previous operator; 4-D feature map of shape (N, C, H, W), where N is the batch size, C is the number of channels, and H and W are the height and the width of the data.</dd>
+<dt><tt>rois</tt> : T1</dt>
+<dd>RoIs (Regions of Interest) to pool over; rois is 2-D input of shape (num_rois, 4) given as [[x1, y1, x2, y2], ...]. The RoIs' coordinates are in the coordinate system of the input image. Each coordinate set has a 1:1 correspondence with the 'batch_indices' input.</dd>
+<dt><tt>batch_indices</tt> : T2</dt>
+<dd>1-D tensor of shape (num_rois,) with each element denoting the index of the corresponding image in the batch.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>RoI pooled output, 4-D tensor of shape (num_rois, C, output_height, output_width). The r-th batch element Y[r-1] is a pooled feature map corresponding to the r-th RoI X[r-1].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain types to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain types to int tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>roialign_aligned_false</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RoiAlign",
+    inputs=["X", "rois", "batch_indices"],
+    outputs=["Y"],
+    spatial_scale=1.0,
+    output_height=5,
+    output_width=5,
+    sampling_ratio=2,
+    coordinate_transformation_mode="output_half_pixel",
+)
+
+X, batch_indices, rois = get_roi_align_input_values()
+# (num_rois, C, output_height, output_width)
+Y = np.array(
+    [
+        [
+            [
+                [0.4664, 0.4466, 0.3405, 0.5688, 0.6068],
+                [0.3714, 0.4296, 0.3835, 0.5562, 0.3510],
+                [0.2768, 0.4883, 0.5222, 0.5528, 0.4171],
+                [0.4713, 0.4844, 0.6904, 0.4920, 0.8774],
+                [0.6239, 0.7125, 0.6289, 0.3355, 0.3495],
+            ]
+        ],
+        [
+            [
+                [0.3022, 0.4305, 0.4696, 0.3978, 0.5423],
+                [0.3656, 0.7050, 0.5165, 0.3172, 0.7015],
+                [0.2912, 0.5059, 0.6476, 0.6235, 0.8299],
+                [0.5916, 0.7389, 0.7048, 0.8372, 0.8893],
+                [0.6227, 0.6153, 0.7097, 0.6154, 0.4585],
+            ]
+        ],
+        [
+            [
+                [0.2384, 0.3379, 0.3717, 0.6100, 0.7601],
+                [0.3767, 0.3785, 0.7147, 0.9243, 0.9727],
+                [0.5749, 0.5826, 0.5709, 0.7619, 0.8770],
+                [0.5355, 0.2566, 0.2141, 0.2796, 0.3600],
+                [0.4365, 0.3504, 0.2887, 0.3661, 0.2349],
+            ]
+        ],
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, rois, batch_indices],
+    outputs=[Y],
+    name="test_roialign_aligned_false",
+)
+```
+
+</details>
+
+
+<details>
+<summary>roialign_aligned_true</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RoiAlign",
+    inputs=["X", "rois", "batch_indices"],
+    outputs=["Y"],
+    spatial_scale=1.0,
+    output_height=5,
+    output_width=5,
+    sampling_ratio=2,
+    coordinate_transformation_mode="half_pixel",
+)
+
+X, batch_indices, rois = get_roi_align_input_values()
+# (num_rois, C, output_height, output_width)
+Y = np.array(
+    [
+        [
+            [
+                [0.5178, 0.3434, 0.3229, 0.4474, 0.6344],
+                [0.4031, 0.5366, 0.4428, 0.4861, 0.4023],
+                [0.2512, 0.4002, 0.5155, 0.6954, 0.3465],
+                [0.3350, 0.4601, 0.5881, 0.3439, 0.6849],
+                [0.4932, 0.7141, 0.8217, 0.4719, 0.4039],
+            ]
+        ],
+        [
+            [
+                [0.3070, 0.2187, 0.3337, 0.4880, 0.4870],
+                [0.1871, 0.4914, 0.5561, 0.4192, 0.3686],
+                [0.1433, 0.4608, 0.5971, 0.5310, 0.4982],
+                [0.2788, 0.4386, 0.6022, 0.7000, 0.7524],
+                [0.5774, 0.7024, 0.7251, 0.7338, 0.8163],
+            ]
+        ],
+        [
+            [
+                [0.2393, 0.4075, 0.3379, 0.2525, 0.4743],
+                [0.3671, 0.2702, 0.4105, 0.6419, 0.8308],
+                [0.5556, 0.4543, 0.5564, 0.7502, 0.9300],
+                [0.6626, 0.5617, 0.4813, 0.4954, 0.6663],
+                [0.6636, 0.3721, 0.2056, 0.1928, 0.2478],
+            ]
+        ],
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, rois, batch_indices],
+    outputs=[Y],
+    name="test_roialign_aligned_true",
+)
+```
+
+</details>
+
+
+<details>
+<summary>roialign_mode_max</summary>
+
+```python
+X = np.array(
+    [
+        [
+            [
+                [
+                    0.2764,
+                    0.715,
+                    0.1958,
+                    0.3416,
+                    0.4638,
+                    0.0259,
+                    0.2963,
+                    0.6518,
+                    0.4856,
+                    0.725,
+                ],
+                [
+                    0.9637,
+                    0.0895,
+                    0.2919,
+                    0.6753,
+                    0.0234,
+                    0.6132,
+                    0.8085,
+                    0.5324,
+                    0.8992,
+                    0.4467,
+                ],
+                [
+                    0.3265,
+                    0.8479,
+                    0.9698,
+                    0.2471,
+                    0.9336,
+                    0.1878,
+                    0.4766,
+                    0.4308,
+                    0.34,
+                    0.2162,
+                ],
+                [
+                    0.0206,
+                    0.172,
+                    0.2155,
+                    0.4394,
+                    0.0653,
+                    0.3406,
+                    0.7724,
+                    0.3921,
+                    0.2541,
+                    0.5799,
+                ],
+                [
+                    0.4062,
+                    0.2194,
+                    0.4473,
+                    0.4687,
+                    0.7109,
+                    0.9327,
+                    0.9815,
+                    0.632,
+                    0.1728,
+                    0.6119,
+                ],
+                [
+                    0.3097,
+                    0.1283,
+                    0.4984,
+                    0.5068,
+                    0.4279,
+                    0.0173,
+                    0.4388,
+                    0.043,
+                    0.4671,
+                    0.7119,
+                ],
+                [
+                    0.1011,
+                    0.8477,
+                    0.4726,
+                    0.1777,
+                    0.9923,
+                    0.4042,
+                    0.1869,
+                    0.7795,
+                    0.9946,
+                    0.9689,
+                ],
+                [
+                    0.1366,
+                    0.3671,
+                    0.7011,
+                    0.6234,
+                    0.9867,
+                    0.5585,
+                    0.6985,
+                    0.5609,
+                    0.8788,
+                    0.9928,
+                ],
+                [
+                    0.5697,
+                    0.8511,
+                    0.6711,
+                    0.9406,
+                    0.8751,
+                    0.7496,
+                    0.165,
+                    0.1049,
+                    0.1559,
+                    0.2514,
+                ],
+                [
+                    0.7012,
+                    0.4056,
+                    0.7879,
+                    0.3461,
+                    0.0415,
+                    0.2998,
+                    0.5094,
+                    0.3727,
+                    0.5482,
+                    0.0502,
+                ],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+rois = np.array(
+    [[0.0, 0.0, 9.0, 9.0], [0.0, 5.0, 4.0, 9.0], [5.0, 5.0, 9.0, 9.0]],
+    dtype=np.float32,
+)
+batch_indices = np.array([0, 0, 0], dtype=np.int64)
+
+Y = np.array(
+    [
+        [
+            [
+                [0.3445228, 0.37310338, 0.37865096, 0.446696, 0.37991184],
+                [0.4133513, 0.5455125, 0.6651902, 0.55805874, 0.27110294],
+                [0.21223956, 0.40924096, 0.8417618, 0.792561, 0.37196714],
+                [0.46835402, 0.39741728, 0.8012819, 0.4969306, 0.5495158],
+                [0.3595896, 0.5196813, 0.5403741, 0.23814403, 0.19992709],
+            ]
+        ],
+        [
+            [
+                [0.30517197, 0.5086199, 0.3189761, 0.4054401, 0.47630402],
+                [0.50862, 0.8477, 0.37808004, 0.24936005, 0.79384017],
+                [0.17620805, 0.29368007, 0.44870415, 0.4987201, 0.63148826],
+                [0.51066005, 0.8511, 0.5368801, 0.9406, 0.70008016],
+                [0.4487681, 0.51066035, 0.5042561, 0.5643603, 0.42004836],
+            ]
+        ],
+        [
+            [
+                [0.21062402, 0.3510401, 0.37416005, 0.5967599, 0.46507207],
+                [0.32336006, 0.31180006, 0.6236001, 0.9946, 0.7751202],
+                [0.35744014, 0.5588001, 0.35897616, 0.7030401, 0.6353923],
+                [0.5996801, 0.27940005, 0.17948808, 0.35152006, 0.31769615],
+                [0.3598083, 0.40752012, 0.2385281, 0.43856013, 0.26313624],
+            ]
+        ],
+    ],
+    dtype=np.float32,
+)
+
+node = onnx.helper.make_node(
+    "RoiAlign",
+    inputs=["X", "rois", "batch_indices"],
+    mode="max",
+    outputs=["Y"],
+    spatial_scale=1.0,
+    output_height=5,
+    output_width=5,
+    sampling_ratio=2,
+    coordinate_transformation_mode="output_half_pixel",
+)
+
+expect(
+    node,
+    inputs=[X, rois, batch_indices],
+    outputs=[Y],
+    name="test_roialign_mode_max",
+)
+```
+
+</details>
+
+
+### <a name="RotaryEmbedding"></a><a name="rotaryembedding">**RotaryEmbedding**</a>
+
+  RotaryEmbedding is the implementation of rotary positional embeddings (RoPE) based on the paper https://arxiv.org/pdf/2104.09864.
+  The key advantage of RoPE is that it allows the model to understand both the absolute position of a token and the relative distances
+  between tokens. This is achieved through a rotational mechanism where the extent of rotation is computed based on the token's absolute position (position_ids).
+
+  The rotational mechanism is defined by sine and cosine functions that are used to represent the rotation angles.
+  For each token in the sequence, its positional embedding is computed by rotating its embedding vector. This is done by splitting the
+  embedding vector either into two halves or interleaving every alternate token and applying the rotation matrix to each half of the embedding vector.
+  The rotation matrix is parameterized by the token's position in the sequence. The rotated halves of the embedding vector are concatenated
+  to form the final positional embedding for each token. The rotated positional embeddings are used in the self-attention mechanism.
+  The rotation ensures that the model captures both absolute and relative positional information.
+
+  Rotary embeddings are defined using the following algorithm:
+
+  ```python
+  def rotary_embedding(
+      input: np.ndarray,
+      cos_cache: np.ndarray,
+      sin_cache: np.ndarray,
+      position_ids: np.ndarray | None = None,
+      interleaved=None,
+      rotary_embedding_dim=None,
+      num_heads=None,
+  ) -> np.ndarray:
+      original_input_shape = input.shape
+      # First ensure input to be processed has shape [batch_size, seq_len, num_heads, head_size]
+      if len(input.shape) == 4:
+          input = np.transpose(input, (0, 2, 1, 3))
+      batch_size = input.shape[0]
+      sequence_length = input.shape[1]
+      if len(input.shape) == 3:
+          hidden_size = input.shape[2]
+          assert num_heads != 0
+          head_size = int(hidden_size / num_heads)
+          new_shape = [batch_size, sequence_length, num_heads, head_size]
+          input = np.reshape(input, new_shape)
+      assert len(input.shape) == 4
+      head_size = input.shape[3]
+
+      # Fully or partially perform rotation on input based on rotary_embedding_dim attribute
+      if rotary_embedding_dim is None or rotary_embedding_dim == 0:
+          # If rotary_embedding_dim not provided, perform full rotation by using head_size
+          rotary_embedding_dim = head_size
+      x_rotate = input[:, :, :, :rotary_embedding_dim]
+      x_not_rotate = input[:, :, :, rotary_embedding_dim:]
+      rotary_embedding_dim_half = int(rotary_embedding_dim / 2)
+
+      # Retrieve sin and cos caches using position ids
+      if position_ids is not None:
+          cos_cache = cos_cache[
+              position_ids
+          ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+          sin_cache = sin_cache[
+              position_ids
+          ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+
+      # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+      if cos_cache.shape[-1] != rotary_embedding_dim_half:
+          raise ValueError(
+              f"Last dimension of cos cache ({cos_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+          )
+      if sin_cache.shape[-1] != rotary_embedding_dim_half:
+          raise ValueError(
+              f"Last dimension of sin cache ({sin_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+          )
+
+      cos_cache = np.expand_dims(
+          cos_cache, axis=2
+      )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
+      sin_cache = np.expand_dims(
+          sin_cache, axis=2
+      )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
+
+      # Either divide the input in halves or interleave (based on interleaved attribute)
+      if interleaved:
+          x1 = x_rotate[:, :, :, 0::2]
+          x2 = x_rotate[:, :, :, 1::2]
+      else:
+          x1, x2 = np.split(x_rotate, 2, axis=-1)
+
+      # Calculate real and imaginary values
+      real = (cos_cache * x1) - (sin_cache * x2)
+      imag = (sin_cache * x1) + (cos_cache * x2)
+
+      # Inserted rotated embeddings back to the original input
+      if interleaved:
+          # x_rotate[:, :, :, 0::2] = real
+          # x_rotate[:, :, :, 1::2] = imag
+          real = np.expand_dims(real, axis=-1)
+          imag = np.expand_dims(imag, axis=-1)
+          x_rotate_concat = np.concatenate((real, imag), axis=-1)
+          x_rotate = np.reshape(x_rotate_concat, x_rotate.shape)
+      else:
+          x_rotate = np.concatenate((real, imag), axis=-1)
+      output = np.concatenate((x_rotate, x_not_rotate), axis=-1)
+      if len(original_input_shape) == 3:
+          output = np.reshape(output, original_input_shape)
+      else:
+          output = np.transpose(output, (0, 2, 1, 3))
+      return output
+  ```
+
+#### Version
+
+This version of the operator has been available since version 23 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>interleaved</tt> : int (default is 0)</dt>
+<dd>Rotate using interleaved pattern. Default value is 0 (False).</dd>
+<dt><tt>num_heads</tt> : int</dt>
+<dd>Number of attention heads. Must be provided when input is a 3D tensor. </dd>
+<dt><tt>rotary_embedding_dim</tt> : int (default is 0)</dt>
+<dd>Rotary embedding dimension used to apply partial rotary embeddings.</dd>
+</dl>
+
+#### Inputs (3 - 4)
+
+<dl>
+<dt><tt>X</tt> : T</dt>
+<dd>The input tensor representing the token embeddings. 4D tensor with shape `(batch_size, num_heads, sequence_length, head_size)` or 3D tensor with shape `(batch_size, sequence_length, hidden_size)`. For cases with a 4D input tensor, `head_size` has to be even. For cases with a 3D input tensor, `num_heads` attribute must be provided and `hidden_size` must be an even multiple of `num_heads` where `hidden_size = num_heads * head_size`</dd>
+<dt><tt>cos_cache</tt> : T</dt>
+<dd>The cosine values for the rotation. 2D tensor with shape `(max_position_id_plus_1, head_size / 2)` for full rotation or `(max_position_id_plus_1, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are provided. 3D tensor with shape `(batch_size, sequence_length, head_size / 2)` for full rotation or `(batch_size, sequence_length, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are not provided. `max_position_id_plus_1` is a parameter to the model.</dd>
+<dt><tt>sin_cache</tt> : T</dt>
+<dd>The sine values for the rotation. 2D tensor with shape `(max_position_id_plus_1, head_size / 2)` for full rotation or `(max_position_id_plus_1, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are provided. 3D tensor with shape `(batch_size, sequence_length, head_size / 2)` for full rotation or `(batch_size, sequence_length, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are not provided. `max_position_id_plus_1` is a parameter to the model.</dd>
+<dt><tt>position_ids</tt> (optional) : M</dt>
+<dd>The position indices for the tokens. 2D tensor with shape `(batch_size, sequence_length)`</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T</dt>
+<dd>Tensor with same shape as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float), tensor(float16), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>M</tt> : tensor(int64)</dt>
+<dd>Constrain input and output types to integer tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>rotary_embedding</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 4).astype(np.float32)
+cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data, cos_cache_data, sin_cache_data, position_ids=position_ids_data
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding",
+)
+```
+
+</details>
+
+
+<details>
+<summary>rotary_embedding_3d_input</summary>
+
+```python
+num_heads = 4
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+    num_heads=num_heads,
+)
+
+input_data = np.random.rand(2, 3, 32).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 4).astype(np.float32)
+cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    position_ids=position_ids_data,
+    num_heads=num_heads,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_3d_input",
+)
+```
+
+</details>
+
+
+<details>
+<summary>rotary_embedding_interleaved</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+    interleaved=1,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 4).astype(np.float32)
+cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    position_ids=position_ids_data,
+    interleaved=1,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_interleaved",
+)
+```
+
+</details>
+
+
+<details>
+<summary>rotary_embedding_no_position_ids</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache"],
+    outputs=["output"],
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+sin_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+cos_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+
+expected_output = rotary_embedding(input_data, cos_cache_data, sin_cache_data)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_no_position_ids",
+)
+```
+
+</details>
+
+
+<details>
+<summary>rotary_embedding_no_position_ids_interleaved</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache"],
+    outputs=["output"],
+    interleaved=1,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+sin_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+cos_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    interleaved=1,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_no_position_ids_interleaved",
+)
+```
+
+</details>
+
+
+<details>
+<summary>rotary_embedding_no_position_ids_rotary_dim</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache"],
+    outputs=["output"],
+    rotary_embedding_dim=4,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+sin_cache_data = np.random.rand(2, 3, 2).astype(np.float32)
+cos_cache_data = np.random.rand(2, 3, 2).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    rotary_embedding_dim=4,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_no_position_ids_rotary_dim",
+)
+```
+
+</details>
+
+
+<details>
+<summary>rotary_embedding_with_interleaved_rotary_dim</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+    rotary_embedding_dim=4,
+    interleaved=1,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 2).astype(np.float32)
+cos_cache_data = np.random.rand(50, 2).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    position_ids=position_ids_data,
+    interleaved=1,
+    rotary_embedding_dim=4,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_with_interleaved_rotary_dim",
+)
+```
+
+</details>
+
+
+<details>
+<summary>rotary_embedding_with_rotary_dim</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+    rotary_embedding_dim=4,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 2).astype(np.float32)
+cos_cache_data = np.random.rand(50, 2).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    position_ids=position_ids_data,
+    rotary_embedding_dim=4,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_with_rotary_dim",
+)
+```
+
+</details>
+
+
+### <a name="Round"></a><a name="round">**Round**</a>
+
+  Round takes one input Tensor and rounds the values, element-wise, meaning
+  it finds the nearest integer for each value.
+  In case of halves, the rule is to round them to the nearest even integer.
+  If input x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+  The output tensor has the same shape and type as the input.
+
+  Examples:
+  ```
+  round([0.9]) = [1.0]
+  round([2.5]) = [2.0]
+  round([2.3]) = [2.0]
+  round([1.5]) = [2.0]
+  round([-4.5]) = [-4.0]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Round-11">11</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>round</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Round",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        0.1,
+        0.5,
+        0.9,
+        1.2,
+        1.5,
+        1.8,
+        2.3,
+        2.5,
+        2.7,
+        -1.1,
+        -1.5,
+        -1.9,
+        -2.2,
+        -2.5,
+        -2.8,
+    ]
+).astype(np.float32)
+
+# expected output
+y = np.array(
+    [
+        0.0,
+        0.0,
+        1.0,
+        1.0,
+        2.0,
+        2.0,
+        2.0,
+        2.0,
+        3.0,
+        -1.0,
+        -2.0,
+        -2.0,
+        -2.0,
+        -2.0,
+        -3.0,
+    ]
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_round")
+```
+
+</details>
+
+
+### <a name="STFT"></a><a name="stft">**STFT**</a>
+
+  Computes the Short-time Fourier Transform of the signal.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>onesided</tt> : int (default is 1)</dt>
+<dd>If onesided is 1, only values for w in [0, 1, 2, ..., floor(n_fft/2) + 1] are returned because the real-to-complex Fourier transform satisfies the conjugate symmetry, i.e., X[m, w] = X[m,w]=X[m,n_fft-w]*. Note if the input or window tensors are complex, then onesided output is not possible. Enabling onesided with real inputs performs a Real-valued fast Fourier transform (RFFT).When invoked with real or complex valued input, the default value is 1. Values can be 0 or 1.</dd>
+</dl>
+
+#### Inputs (2 - 4)
+
+<dl>
+<dt><tt>signal</tt> (non-differentiable) : T1</dt>
+<dd>Input tensor representing a real or complex valued signal. For real input, the following shape is expected: [batch_size][signal_length][1]. For complex input, the following shape is expected: [batch_size][signal_length][2], where [batch_size][signal_length][0] represents the real component and [batch_size][signal_length][1] represents the imaginary component of the signal.</dd>
+<dt><tt>frame_step</tt> (non-differentiable) : T2</dt>
+<dd>The number of samples to step between successive DFTs.</dd>
+<dt><tt>window</tt> (optional, non-differentiable) : T1</dt>
+<dd>A tensor representing the window that will be slid over the signal.The window must have rank 1 with shape: [window_shape]. It's an optional value. </dd>
+<dt><tt>frame_length</tt> (optional, non-differentiable) : T2</dt>
+<dd>A scalar representing the size of the DFT. It's an optional value.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T1</dt>
+<dd>The Short-time Fourier Transform of the signals.If onesided is 1, the output has the shape: [batch_size][frames][dft_unique_bins][2], where dft_unique_bins is frame_length // 2 + 1 (the unique components of the DFT) If onesided is 0, the output has the shape: [batch_size][frames][frame_length][2], where frame_length is the length of the DFT.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(float16), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain signal and output to float tensors.</dd>
+<dt><tt>T2</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain scalar length types to int64_t.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>stft</summary>
+
+```python
+signal = np.arange(0, 128, dtype=np.float32).reshape(1, 128, 1)
+length = np.array(16).astype(np.int64)
+onesided_length = (length >> 1) + 1
+step = np.array(8).astype(np.int64)
+
+no_window = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "STFT",
+    inputs=["signal", "frame_step", no_window, "frame_length"],
+    outputs=["output"],
+)
+
+nstfts = ((signal.shape[1] - length) // step) + 1
+# [batch_size][frames][frame_length][2]
+output = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32)
+for i in range(nstfts):
+    start = i * step
+    stop = i * step + length
+    complex_out = np.fft.fft(signal[0, start:stop, 0])[0:onesided_length]
+    output[0, i] = np.stack((complex_out.real, complex_out.imag), axis=1)
+
+output = output.astype(signal.dtype)
+expect(node, inputs=[signal, step, length], outputs=[output], name="test_stft")
+
+node = onnx.helper.make_node(
+    "STFT",
+    inputs=["signal", "frame_step", "window"],
+    outputs=["output"],
+)
+
+# Test with window
+a0 = 0.5
+a1 = 0.5
+window = a0 + a1 * np.cos(
+    2 * np.pi * np.arange(0, length, 1, dtype=np.float32) / length
+)
+nstfts = 1 + (signal.shape[1] - window.shape[0]) // step
+
+# [batch_size][frames][frame_length][2]
+output = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32)
+for i in range(nstfts):
+    start = i * step
+    stop = i * step + length
+    complex_out = np.fft.fft(signal[0, start:stop, 0] * window)[
+        0:onesided_length
+    ]
+    output[0, i] = np.stack((complex_out.real, complex_out.imag), axis=1)
+window = window.astype(signal.dtype)
+output = output.astype(signal.dtype)
+expect(
+    node,
+    inputs=[signal, step, window],
+    outputs=[output],
+    name="test_stft_with_window",
+)
+```
+
+</details>
+
+
+### <a name="Scan"></a><a name="scan">**Scan**</a>
+
+  Scan can be used to iterate over one or more scan_input tensors,
+  constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+  functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+  generalizations of RNN-like constructs for sequence-to-sequence processing.
+  Other tensors (referred to as state_variables here) can be used to carry a state
+  when iterating from one element to another (similar to hidden-state in RNNs, also referred
+  to as loop-carried dependences in the context of loops).
+  Many common usages involve a single scan_input tensor (where functionality
+  similar to scan, fold and map can be obtained). When more than one scan_input is used,
+  a behavior similar to zip is obtained.
+
+  The attribute body must be a graph, specifying the computation to be performed in
+  every iteration. It takes as input the current values of the state_variables and
+  the current iterated element of the scan_inputs. It must return the (updated) values
+  of the state_variables and zero or more scan_output_element tensors. The values of the
+  scan_output_element tensors are concatenated over all the iterations to produce the
+  scan_output values of the scan construct (similar to the concatenated intermediate
+  hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+  well as scan_output_element tensors) are required to have the same shape in each iteration
+  of the loop (a restriction imposed to enable efficient memory allocation).
+
+  Note that the iterated element passed to the body subgraph does not have a sequence
+  axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+  The scan operation returns the final values of the state_variables as well as the
+  scan_outputs.
+
+  The optional attribute scan_input_directions specifies the direction (forward or backward)
+  for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+  direction. A bidirectional scan may be performed by specifying the same tensor input twice
+  in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+  The scan_output of the operation is produced by concatenating the scan_output_element
+  values produced by the body in each iteration.  The optional attribute scan_output_directions
+  specifies the direction in which scan_output is constructed (by appending or prepending the
+  scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+  is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+  The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+  If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+  batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+  Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+  The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+  are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+  scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+  value of 1.
+
+  Note that because of the ONNX restriction that only the last parameter of an operator can
+  be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+  Similarly, the final-states and scan-outputs are listed together as one output parameter.
+  The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+  The behavior of
+
+      Scan <
+          num_scan_inputs = m,
+          body = loop-body,
+          scan_input_axes = [axis_1, ..., axis_m]
+      > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+  is equivalent to the following pseudo-code:
+
+      // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+      // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+      sequence_length = scan_1.shape[axis_1];
+
+      // initialize state-variables
+      st_1 = init_1; ... st_n = init_n;
+      // initialize scan-output variables: [] denotes an empty tensor
+      scan_out_1 = []; ...; scan_out_k = [];
+      // identify number of iterations:
+
+      // execute loop
+      for (int t = 0; t < sequence_length; ++t) {
+          // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+          // of rank one less than T obtained by indexing T at position t along axis k.
+          si_1 = scan_1<axis=axis_1>[t];
+          ... ;
+          si_m = scan_m<axis=axis_m>[t];
+          // execute loop-body
+          st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+          // accumulate the scan-output elements
+          scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+      }
+
+      return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+  *Sample usage: Encoding RNN using a Scan*
+
+  The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+  recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+  be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+  %Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+  values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+      graph rnn-encoding {
+        %H_0 = ...
+        %X = ...
+        %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+        return %Y, %Y_h
+      }
+
+      graph rnn-cell-1 (
+        %H_tminus1[FLOAT, tensor]
+        %X_t[FLOAT, tensor]
+      ) {
+        %Wi = ...
+        %Ri = ...
+        %Wbi = ...
+        %Rbi = ...
+        %t1 = X_t * (Wi^T)
+        %t2 = H_tminus1*(Ri^T)
+        %t3 = Add(%t1, %t2)
+        %t4 = Add(%t3, %Wbi)
+        %t5 = Add(%t4, %Rbi)
+        %Ht = Tanh(%t5)
+        %Accumulate = Identity(%Ht)
+        return %Ht, %Accumulate
+      }
+
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Scan-8">8</a>, <a href="Changelog.md#Scan-9">9</a>, <a href="Changelog.md#Scan-11">11</a>, <a href="Changelog.md#Scan-16">16</a>, <a href="Changelog.md#Scan-19">19</a>, <a href="Changelog.md#Scan-21">21</a>, <a href="Changelog.md#Scan-23">23</a>, <a href="Changelog.md#Scan-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph run each iteration. It has N+M inputs: (loop state variables..., scan_input_elts...). It has N+K outputs: (loop state variables..., scan_output_elts...). Each scan_output is created by concatenating the value of the specified scan_output_elt value at the end of each iteration of the loop. It is an error if the dimensions of these values change across loop iterations.</dd>
+<dt><tt>num_scan_inputs</tt> : int (required)</dt>
+<dd>An attribute specifying the number of scan_inputs M. </dd>
+<dt><tt>scan_input_axes</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the axis to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will be used as the scan axis for every scan_input. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>scan_input_directions</tt> : list of ints</dt>
+<dd>An optional list of M flags. The i-th element of the list specifies the direction to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 indicates reverse direction. If omitted, all scan_input tensors will be scanned in the forward direction.</dd>
+<dt><tt>scan_output_axes</tt> : list of ints</dt>
+<dd>An optional list of K flags. The i-th element of the list specifies the axis for the i-th scan_output. The scan outputs are accumulated along the specified axis. If omitted, 0 will be used as the scan axis for every scan_output. Negative value for an axis means counting dimensions from the back. Accepted range is [-r, r-1].</dd>
+<dt><tt>scan_output_directions</tt> : list of ints</dt>
+<dd>An optional list of K flags, one for each scan_output. The i-th element of the list specifies whether the i-th scan_output should be constructed by appending or prepending a new value in each iteration: 0 indicates appending and 1 indicates prepending. If omitted, all scan_output tensors will be produced by appending a value in each iteration.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>initial_state_and_scan_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Initial values of the loop's N state variables followed by M scan_inputs</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>final_state_and_scan_outputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Final values of the loop's N state variables followed by K scan_outputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>All Tensor types up to IRv13.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>scan_8</summary>
+
+```python
+# Given an input sequence [x1, ..., xN], sum up its elements using a scan
+# returning the final state (x1+x2+...+xN) as well the scan_output
+# [x1, x1+x2, ..., x1+x2+...+xN]
+# Note: the first input (sequence_lens) is optional and omitted via "".
+node = onnx.parser.parse_node(
+    """
+    y, z = Scan ("", initial, x) <
+        num_scan_inputs = 1,
+        body = scan_body (float[2] sum_in, float[2] next)
+            => (float[2] sum_out, float[2] scan_out)
+        {
+            sum_out  = Add(sum_in, next)
+            scan_out = Identity(sum_out)
+        }
+    >
+    """
+)
+# create inputs for batch-size 1, sequence-length 3, inner dimension 2
+initial = np.array([0, 0]).astype(np.float32).reshape((1, 2))
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((1, 3, 2))
+# final state computed = [1 + 3 + 5, 2 + 4 + 6]
+y = np.array([9, 12]).astype(np.float32).reshape((1, 2))
+# scan-output computed
+z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((1, 3, 2))
+
+expect(
+    node,
+    inputs=[initial, x],
+    outputs=[y, z],
+    name="test_scan_sum",
+    opset_imports=[onnx.helper.make_opsetid("", 8)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>scan_9</summary>
+
+```python
+# Given an input sequence [x1, ..., xN], sum up its elements using a scan
+# returning the final state (x1+x2+...+xN) as well the scan_output
+# [x1, x1+x2, ..., x1+x2+...+xN]
+node = onnx.parser.parse_node(
+    """
+    y, z = Scan (initial, x) <
+        num_scan_inputs = 1,
+        body = scan_body (float[2] sum_in, float[2] next)
+            => (float[2] sum_out, float[2] scan_out)
+        {
+            sum_out  = Add(sum_in, next)
+            scan_out = Identity(sum_out)
+        }
+    >
+    """
+)
+# create inputs for sequence-length 3, inner dimension 2
+initial = np.array([0, 0]).astype(np.float32).reshape((2,))
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((3, 2))
+# final state computed = [1 + 3 + 5, 2 + 4 + 6]
+y = np.array([9, 12]).astype(np.float32).reshape((2,))
+# scan-output computed
+z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((3, 2))
+
+expect(
+    node,
+    inputs=[initial, x],
+    outputs=[y, z],
+    name="test_scan9_sum",
+    opset_imports=[onnx.helper.make_opsetid("", 9)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>scan_9_multi_state</summary>
+
+```python
+# Scan with two state variables: running sum and running product.
+# This exercises the case where num_loop_state_vars (2) differs from
+# num_scan_inputs (1).
+#
+# Body inputs:  sum_in (state), prod_in (state), next (scan)
+# Body outputs: sum_out (state), prod_out (state), scan_out (scan)
+node = onnx.parser.parse_node(
+    """
+    y_sum, y_prod, z = Scan (initial_sum, initial_prod, x) <
+        num_scan_inputs = 1,
+        body = scan_body (float[2] sum_in, float[2] prod_in, float[2] next)
+            => (float[2] sum_out, float[2] prod_out, float[2] scan_out)
+        {
+            sum_out  = Add(sum_in, next)
+            prod_out = Mul(prod_in, next)
+            scan_out = Identity(sum_out)
+        }
+    >
+    """
+)
+# x = [[1, 2], [3, 4], [5, 6]]
+initial_sum = np.array([0, 0]).astype(np.float32)
+initial_prod = np.array([1, 1]).astype(np.float32)
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((3, 2))
+# final sum = [1+3+5, 2+4+6] = [9, 12]
+y_sum = np.array([9, 12]).astype(np.float32)
+# final product = [1*3*5, 2*4*6] = [15, 48]
+y_prod = np.array([15, 48]).astype(np.float32)
+# scan output (running sum) = [[1,2], [4,6], [9,12]]
+z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((3, 2))
+
+expect(
+    node,
+    inputs=[initial_sum, initial_prod, x],
+    outputs=[y_sum, y_prod, z],
+    name="test_scan9_multi_state",
+    opset_imports=[onnx.helper.make_opsetid("", 9)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>scan_9_scalar</summary>
+
+```python
+# Scan with scalar state and scan output to verify that output
+# shapes are not distorted (e.g. (T,) not (T, 1)).
+node = onnx.parser.parse_node(
+    """
+    y, z = Scan (initial, x) <
+        num_scan_inputs = 1,
+        body = scan_body (float sum_in, float next)
+            => (float sum_out, float scan_out)
+        {
+            sum_out  = Add(sum_in, next)
+            scan_out = Identity(sum_out)
+        }
+    >
+    """
+)
+initial = np.float32(0.0)
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+# final state = 1+2+3+4+5 = 15
+y = np.float32(15.0)
+# scan output = [1, 3, 6, 10, 15], shape (5,)
+z = np.array([1, 3, 6, 10, 15]).astype(np.float32)
+
+expect(
+    node,
+    inputs=[initial, x],
+    outputs=[y, z],
+    name="test_scan9_scalar",
+    opset_imports=[onnx.helper.make_opsetid("", 9)],
+)
+```
+
+</details>
+
+
+### <a name="Scatter"></a><a name="scatter">**Scatter** (deprecated)</a>
+
+  This operator is deprecated. Please use ScatterElements, which provides the same functionality.
+
+  Scatter takes three inputs `data`, `updates`, and `indices` of the same
+  rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value
+  to values specified by `updates` at specific index positions specified by
+  `indices`. Its output shape is the same as the shape of `data`.
+
+  For each entry in `updates`, the target index in `data` is obtained by combining
+  the corresponding entry in `indices` with the index of the entry itself: the
+  index-value for dimension = axis is obtained from the value of the corresponding
+  entry in `indices` and the index-value for dimension != axis is obtained from the
+  index of the entry itself.
+
+  For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
+  is performed as below:
+  ```
+    output[indices[i][j]][j] = updates[i][j] if axis = 0,
+    output[i][indices[i][j]] = updates[i][j] if axis = 1,
+  ```
+
+  This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+
+  Example 1:
+  ```
+    data = [
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+        [0.0, 0.0, 0.0],
+    ]
+    indices = [
+        [1, 0, 2],
+        [0, 2, 1],
+    ]
+    updates = [
+        [1.0, 1.1, 1.2],
+        [2.0, 2.1, 2.2],
+    ]
+    output = [
+        [2.0, 1.1, 0.0]
+        [1.0, 0.0, 2.2]
+        [0.0, 2.1, 1.2]
+    ]
+  ```
+  Example 2:
+  ```
+    data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+    indices = [[1, 3]]
+    updates = [[1.1, 2.1]]
+    axis = 1
+    output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+  ```
+
+#### Version
+
+This version of the operator has been deprecated since version 11 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Scatter-9">9</a>
+
+
+#### Examples
+
+<details>
+<summary>scatter_with_axis</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "Scatter",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 3]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter(data, indices, updates, axis=axis)
+# print(y) produces
+# [[1.0, 1.1, 3.0, 2.1, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_with_axis",
+    opset_imports=[helper.make_opsetid("", 10)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatter_without_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Scatter",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+)
+data = np.zeros((3, 3), dtype=np.float32)
+indices = np.array([[1, 0, 2], [0, 2, 1]], dtype=np.int64)
+updates = np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]], dtype=np.float32)
+
+y = scatter(data, indices, updates)
+# print(y) produces
+# [[2.0, 1.1, 0.0],
+#  [1.0, 0.0, 2.2],
+#  [0.0, 2.1, 1.2]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_without_axis",
+    opset_imports=[helper.make_opsetid("", 10)],
+)
+```
+
+</details>
+
+
+### <a name="ScatterElements"></a><a name="scatterelements">**ScatterElements**</a>
+
+  ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
+  rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+  (by default, the outer-most axis, that is axis 0). The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value
+  to values specified by `updates` at specific index positions specified by
+  `indices`. Its output shape is the same as the shape of `data`.
+
+  For each entry in `updates`, the target index in `data` is obtained by combining
+  the corresponding entry in `indices` with the index of the entry itself: the
+  index-value for dimension = axis is obtained from the value of the corresponding
+  entry in `indices` and the index-value for dimension != axis is obtained from the
+  index of the entry itself.
+
+  `reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+  tensor into `output` at the specified `indices`.
+  In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+  then indices[idx1] != indices[idx2]. For instance, in a 2-D tensor case, the update
+  corresponding to the [i][j] entry is performed as below:
+  ```
+  output[indices[i][j]][j] = updates[i][j] if axis = 0,
+  output[i][indices[i][j]] = updates[i][j] if axis = 1,
+  ```
+  When `reduction` is set to some reduction function `f`, the update corresponding to the [i][j] entry is performed as below:
+  ```
+  output[indices[i][j]][j] = f(output[indices[i][j]][j], updates[i][j]) if axis = 0,
+  output[i][indices[i][j]] = f(output[i][indices[i][j]], updates[i][j]) if axis = 1,
+  ```
+  where the `f` is `+`, `*`, `max` or `min` as specified.
+
+  This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+
+  (Opset 18 change): Adds max/min to the set of allowed reduction ops.
+
+  Example 1:
+  ```
+  data = [
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+  ]
+  indices = [
+      [1, 0, 2],
+      [0, 2, 1],
+  ]
+  updates = [
+      [1.0, 1.1, 1.2],
+      [2.0, 2.1, 2.2],
+  ]
+  output = [
+      [2.0, 1.1, 0.0]
+      [1.0, 0.0, 2.2]
+      [0.0, 2.1, 1.2]
+  ]
+  ```
+  Example 2:
+  ```
+  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+  indices = [[1, 3]]
+  updates = [[1.1, 2.1]]
+  axis = 1
+  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ScatterElements-11">11</a>, <a href="Changelog.md#ScatterElements-13">13</a>, <a href="Changelog.md#ScatterElements-16">16</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to scatter on. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+<dt><tt>reduction</tt> : string (default is none)</dt>
+<dd>Type of reduction to apply: none (default), add, mul, max, min. 'none': no reduction applied. 'add':  reduction using the addition operation. 'mul': reduction using the multiplication operation.'max': reduction using the maximum operation.'min': reduction using the minimum operation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : Tind</dt>
+<dd>Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.</dd>
+<dt><tt>updates</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >=1 (same rank and shape as indices)</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1 (same rank as input).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input and output types can be of any tensor type.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>scatter_elements_with_axis</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 3]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis)
+# print(y) produces
+# [[1.0, 1.1, 3.0, 2.1, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatter_elements_with_duplicate_indices</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+    reduction="add",
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 1]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis, reduction="add")
+# print(y) produces
+# [[1.0, 5.2, 3.0, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_duplicate_indices",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatter_elements_with_negative_indices</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, -3]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis)
+# print(y) produces
+# [[1.0, 1.1, 2.1, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_negative_indices",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatter_elements_with_reduction_max</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+    reduction="max",
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 1]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis, reduction="max")
+# print(y) produces
+# [[1.0, 2.1, 3.0, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_reduction_max",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatter_elements_with_reduction_min</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+    reduction="min",
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 1]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis, reduction="min")
+# print(y) produces
+# [[1.0, 1.1, 3.0, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_reduction_min",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatter_elements_with_reduction_mul</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+    reduction="mul",
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 1]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis, reduction="mul")
+# print(y) produces
+# [[1.0, 4.62, 3.0, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_reduction_mul",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatter_elements_without_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+)
+data = np.zeros((3, 3), dtype=np.float32)
+indices = np.array([[1, 0, 2], [0, 2, 1]], dtype=np.int64)
+updates = np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates)
+# print(y) produces
+# [[2.0, 1.1, 0.0],
+#  [1.0, 0.0, 2.2],
+#  [0.0, 2.1, 1.2]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_without_axis",
+)
+```
+
+</details>
+
+
+### <a name="ScatterND"></a><a name="scatternd">**ScatterND**</a>
+
+  ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
+  and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
+  is produced by creating a copy of the input `data`, and then updating its value to values
+  specified by `updates` at specific index positions specified by `indices`. Its output shape
+  is the same as the shape of `data`.
+
+  `indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
+  `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
+  Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
+  update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
+  update to a slice of the tensor. Index values are allowed to be negative, as per the usual
+  convention for counting backwards from the end, but are expected in the valid range.
+
+  `updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
+  first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
+  The remaining dimensions of `updates` correspond to the dimensions of the
+  replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
+  corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
+  must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
+  of shapes.
+
+  The `output` is calculated via the following equation:
+
+  ```
+  output = np.copy(data)
+  update_indices = indices.shape[:-1]
+  for idx in np.ndindex(update_indices):
+      output[tuple(indices[idx])] = updates[idx]
+  ```
+
+  The order of iteration in the above loop is not specified.
+  In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
+  This ensures that the output value does not depend on the iteration order.
+
+  `reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+  tensor into `output` at the specified `indices`.
+  In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+  then indices[idx1] != indices[idx2]. This ensures that the output value does not depend on the iteration order.
+  When `reduction` is set to some reduction function `f`, `output` is calculated as follows:
+
+  ```
+  output = np.copy(data)
+  update_indices = indices.shape[:-1]
+  for idx in np.ndindex(update_indices):
+      output[tuple(indices[idx])] = f(output[tuple(indices[idx])], updates[idx])
+  ```
+
+  where the `f` is `+`, `*`, `max` or `min` as specified.
+
+  This operator is the inverse of GatherND.
+
+  (Opset 18 change): Adds max/min to the set of allowed reduction ops.
+
+  Example 1:
+  ```
+  data    = [1, 2, 3, 4, 5, 6, 7, 8]
+  indices = [[4], [3], [1], [7]]
+  updates = [9, 10, 11, 12]
+  output  = [1, 11, 3, 10, 9, 6, 7, 12]
+  ```
+
+  Example 2:
+  ```
+  data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+              [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+              [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+              [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+  indices = [[0], [2]]
+  updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+              [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
+  output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+              [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+              [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+              [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ScatterND-11">11</a>, <a href="Changelog.md#ScatterND-13">13</a>, <a href="Changelog.md#ScatterND-16">16</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>reduction</tt> : string (default is none)</dt>
+<dd>Type of reduction to apply: none (default), add, mul, max, min. 'none': no reduction applied. 'add':  reduction using the addition operation. 'mul':  reduction using the addition operation. 'max': reduction using the maximum operation.'min': reduction using the minimum operation.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+<dt><tt>indices</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>Tensor of rank q >= 1.</dd>
+<dt><tt>updates</tt> (differentiable) : T</dt>
+<dd>Tensor of rank q + r - indices_shape[-1] - 1.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of rank r >= 1.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>scatternd</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [2]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates)
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatternd_add</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="add",
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [0]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[7, 8, 9, 10], [13, 14, 15, 16], [18, 17, 16, 15], [16, 15, 14, 13]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="add")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_add",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatternd_max</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="max",
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [0]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[5, 5, 5, 5], [6, 6, 7, 8], [8, 7, 7, 7], [8, 8 ,8, 8]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="max")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_max",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatternd_max_with_element_indices</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="max",
+)
+data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+# Indices address individual elements (index rank == data rank),
+# which exercises the reduction at the element level.
+indices = np.array([[0, 0], [1, 1]], dtype=np.int64)
+updates = np.array([5, 1], dtype=np.float32)
+# Expecting output as np.array([[5, 2], [3, 4]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="max")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_max_with_element_indices",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatternd_min</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="min",
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [0]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 3, 2, 1]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="min")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_min",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatternd_min_with_element_indices</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="min",
+)
+data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+indices = np.array([[0, 0], [1, 1]], dtype=np.int64)
+updates = np.array([5, 1], dtype=np.float32)
+# Expecting output as np.array([[1, 2], [3, 1]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="min")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_min_with_element_indices",
+)
+```
+
+</details>
+
+
+<details>
+<summary>scatternd_multiply</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="mul",
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [0]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[5, 10, 15, 20], [60, 72, 84, 96], [168, 147, 126, 105], [128, 96, 64, 32]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="mul")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_multiply",
+)
+```
+
+</details>
+
+
+### <a name="Selu"></a><a name="selu">**Selu**</a>
+
+  Selu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the scaled exponential linear unit function,
+  `y = gamma * (alpha * e^x - alpha) for x <= 0`, `y = gamma * x for x > 0`,
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Selu-1">1</a>, <a href="Changelog.md#Selu-6">6</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.67326)</dt>
+<dd>Coefficient of SELU default to 1.67326319217681884765625 (i.e., float32 approximation of 1.6732632423543772848170429916717).</dd>
+<dt><tt>gamma</tt> : float (default is 1.0507)</dt>
+<dd>Coefficient of SELU default to 1.05070102214813232421875 (i.e., float32 approximation of 1.0507009873554804934193349852946).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>selu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Selu", inputs=["x"], outputs=["y"], alpha=2.0, gamma=3.0
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-3.79272318, 0., 3.]
+y = (
+    np.clip(x, 0, np.inf) * 3.0
+    + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 * 3.0
+)
+expect(node, inputs=[x], outputs=[y], name="test_selu_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = (
+    np.clip(x, 0, np.inf) * 3.0
+    + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 * 3.0
+)
+expect(node, inputs=[x], outputs=[y], name="test_selu")
+```
+
+</details>
+
+
+<details>
+<summary>selu_default</summary>
+
+```python
+default_alpha = 1.67326319217681884765625
+default_gamma = 1.05070102214813232421875
+node = onnx.helper.make_node(
+    "Selu",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = (
+    np.clip(x, 0, np.inf) * default_gamma
+    + (np.exp(np.clip(x, -np.inf, 0)) - 1) * default_alpha * default_gamma
+)
+expect(node, inputs=[x], outputs=[y], name="test_selu_default")
+```
+
+</details>
+
+
+### <a name="SequenceAt"></a><a name="sequenceat">**SequenceAt**</a>
+
+  Outputs a tensor copy from the tensor at 'position' in 'input_sequence'.
+  Accepted range for 'position' is in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'.
+  Negative value means counting positions from the back.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+<dt><tt>position</tt> : I</dt>
+<dd>Position of the tensor in the sequence. Negative value means counting positions from the back. Accepted range in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'. It is an error if any of the index values are out of bounds. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>tensor</tt> : T</dt>
+<dd>Output tensor at the specified position in the input sequence.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>I</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain position to integral tensor. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+
+### <a name="SequenceConstruct"></a><a name="sequenceconstruct">**SequenceConstruct**</a>
+
+  Construct a tensor sequence containing 'inputs' tensors.
+  All tensors in 'inputs' must have the same data type.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>inputs</tt> (variadic) : T</dt>
+<dd>Tensors.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_sequence</tt> : S</dt>
+<dd>Sequence enclosing the input tensors.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input types to any tensor type.</dd>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+
+### <a name="SequenceEmpty"></a><a name="sequenceempty">**SequenceEmpty**</a>
+
+  Construct an empty tensor sequence, with given data type.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>dtype</tt> : int</dt>
+<dd>(Optional) The data type of the tensors in the output sequence. The default type is 'float'.</dd>
+</dl>
+
+#### Inputs
+
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> : S</dt>
+<dd>Empty sequence.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output types to any tensor type.</dd>
+</dl>
+
+
+### <a name="SequenceErase"></a><a name="sequenceerase">**SequenceErase**</a>
+
+  Outputs a tensor sequence that removes the tensor at 'position' from 'input_sequence'.
+  Accepted range for 'position' is in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'.
+  Negative value means counting positions from the back.
+  'position' is optional, by default it erases the last tensor from 'input_sequence'.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+<dt><tt>position</tt> (optional) : I</dt>
+<dd>Position of the tensor in the sequence. Negative value means counting positions from the back. Accepted range in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'. It is an error if any of the index values are out of bounds. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_sequence</tt> : S</dt>
+<dd>Output sequence that has the tensor at the specified position removed.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>I</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain position to integral tensor. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+
+### <a name="SequenceInsert"></a><a name="sequenceinsert">**SequenceInsert**</a>
+
+  Outputs a tensor sequence that inserts 'tensor' into 'input_sequence' at 'position'.
+  'tensor' must have the same data type as 'input_sequence'.
+  Accepted range for 'position' is in `[-n, n]`, where `n` is the number of tensors in 'input_sequence'.
+  Negative value means counting positions from the back.
+  'position' is optional, by default it inserts 'tensor' to the back of 'input_sequence'.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+<dt><tt>tensor</tt> : T</dt>
+<dd>Input tensor to be inserted into the input sequence.</dd>
+<dt><tt>position</tt> (optional) : I</dt>
+<dd>Position in the sequence where the new tensor is inserted. It is optional and default is to insert to the back of the sequence. Negative value means counting positions from the back. Accepted range in `[-n, n]`, where `n` is the number of tensors in 'input_sequence'. It is an error if any of the index values are out of bounds. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_sequence</tt> : S</dt>
+<dd>Output sequence that contains the inserted tensor at given position.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>I</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain position to integral tensor. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>sequenceinsert</summary>
+
+```python
+test_cases = {
+    "at_back": [np.array([10, 11, 12]).astype(np.int64)],
+    "at_front": [np.array([-2, -1, 0]), np.array([0]).astype(np.int64)],
+}
+sequence = [
+    np.array([1, 2, 3, 4]).astype(np.int64),
+    np.array([5, 6, 7]).astype(np.int64),
+    np.array([8, 9]).astype(np.int64),
+]
+
+for test_name, test_inputs in test_cases.items():
+    tensor = test_inputs[0].astype(np.int64)
+
+    if len(test_inputs) > 1:
+        node = onnx.helper.make_node(
+            "SequenceInsert",
+            inputs=["sequence", "tensor", "position"],
+            outputs=["output_sequence"],
+        )
+        position = test_inputs[1]
+        inserted = sequence_insert_reference_implementation(
+            sequence, tensor, position
+        )
+        expect(
+            node,
+            inputs=[sequence, tensor, position],
+            outputs=[inserted],
+            name="test_sequence_insert_" + test_name,
+        )
+    else:
+        node = onnx.helper.make_node(
+            "SequenceInsert",
+            inputs=["sequence", "tensor"],
+            outputs=["output_sequence"],
+        )
+        inserted = sequence_insert_reference_implementation(sequence, tensor)
+        expect(
+            node,
+            inputs=[sequence, tensor],
+            outputs=[inserted],
+            name="test_sequence_insert_" + test_name,
+        )
+```
+
+</details>
+
+
+### <a name="SequenceLength"></a><a name="sequencelength">**SequenceLength**</a>
+
+  Produces a scalar(tensor of empty shape) containing the number of tensors in 'input_sequence'.
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>length</tt> : I</dt>
+<dd>Length of input sequence. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor type.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain output to integral tensor. It must be a scalar(tensor of empty shape).</dd>
+</dl>
+
+
+### <a name="SequenceMap"></a><a name="sequencemap">**SequenceMap**</a>
+
+  Applies a sub-graph to each sample in the input sequence(s).
+
+  Inputs can be either tensors or sequences, with the exception of the first input which must
+  be a sequence. The length of the first input sequence will determine the number of samples in the
+  outputs. Any other sequence inputs should have the same number of samples. The number of inputs
+  and outputs, should match the one of the subgraph.
+
+  For each i-th element in the output, a sample will be extracted from the input sequence(s) at
+  the i-th position and the sub-graph will be applied to it.
+  The outputs will contain the outputs of the sub-graph for each sample, in the same order as in
+  the input.
+
+  This operator assumes that processing each sample is independent and could executed in parallel
+  or in any order. Users cannot expect any specific ordering in which each subgraph is computed.
+
+#### Version
+
+This version of the operator has been available since version 17 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>body</tt> : graph (required)</dt>
+<dd>The graph to be run for each sample in the sequence(s). It should have as many inputs and outputs as inputs and outputs to the SequenceMap function.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>input_sequence</tt> : S</dt>
+<dd>Input sequence.</dd>
+<dt><tt>additional_inputs</tt> (variadic, heterogeneous) : V</dt>
+<dd>Additional inputs to the graph</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>out_sequence</tt> (variadic, heterogeneous) : S</dt>
+<dd>Output sequence(s)</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain input types to any sequence type.</dd>
+<dt><tt>V</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain to any tensor or sequence type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>sequence_map_add_1_sequence_1_tensor</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [onnx.helper.make_node("Add", ["in0", "in1"], ["out0"])],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "in0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "in1", onnx.TensorProto.FLOAT, ["N"]
+        ),
+    ],
+    [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["N"])],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x0", "x1"], outputs=["y0"], body=body
+)
+
+x0 = [np.random.uniform(0.0, 1.0, 10).astype(np.float32) for k in range(3)]
+x1 = np.random.uniform(0.0, 1.0, 10).astype(np.float32)
+y0 = [x0[i] + x1 for i in range(3)]
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+expect(
+    node,
+    inputs=[x0, x1],
+    outputs=[y0],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_add_1_sequence_1_tensor",
+)
+```
+
+</details>
+
+
+<details>
+<summary>sequence_map_add_2_sequences</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [onnx.helper.make_node("Add", ["in0", "in1"], ["out0"])],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "in0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "in1", onnx.TensorProto.FLOAT, ["N"]
+        ),
+    ],
+    [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["N"])],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x0", "x1"], outputs=["y0"], body=body
+)
+
+N = [np.random.randint(1, 10) for _ in range(3)]
+x0 = [np.random.uniform(0.0, 1.0, N[k]).astype(np.float32) for k in range(3)]
+x1 = [np.random.uniform(0.0, 1.0, N[k]).astype(np.float32) for k in range(3)]
+y0 = [x0[k] + x1[k] for k in range(3)]
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+expect(
+    node,
+    inputs=[x0, x1],
+    outputs=[y0],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_add_2_sequences",
+)
+```
+
+</details>
+
+
+<details>
+<summary>sequence_map_extract_shapes</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [onnx.helper.make_node("Shape", ["x"], ["shape"])],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "x", onnx.TensorProto.FLOAT, ["H", "W", "C"]
+        )
+    ],
+    [onnx.helper.make_tensor_value_info("shape", onnx.TensorProto.INT64, [3])],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["in_seq"], outputs=["shapes"], body=body
+)
+
+shapes = [
+    np.array([40, 30, 3], dtype=np.int64),
+    np.array([20, 10, 3], dtype=np.int64),
+    np.array([10, 5, 3], dtype=np.int64),
+]
+x0 = [np.zeros(shape, dtype=np.float32) for shape in shapes]
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.FLOAT, ["H", "W", "C"]
+        )
+    ),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.INT64, [3])
+    ),
+]
+expect(
+    node,
+    inputs=[x0],
+    outputs=[shapes],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_extract_shapes",
+)
+```
+
+</details>
+
+
+<details>
+<summary>sequence_map_identity_1_sequence</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [onnx.helper.make_node("Identity", ["in0"], ["out0"])],
+    "seq_map_body",
+    [onnx.helper.make_tensor_value_info("in0", onnx.TensorProto.FLOAT, ["N"])],
+    [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["M"])],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x"], outputs=["y"], body=body
+)
+
+x = [np.random.uniform(0.0, 1.0, 10).astype(np.float32) for _ in range(3)]
+y = x
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_identity_1_sequence",
+)
+```
+
+</details>
+
+
+<details>
+<summary>sequence_map_identity_1_sequence_1_tensor</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [
+        onnx.helper.make_node("Identity", ["in0"], ["out0"]),
+        onnx.helper.make_node("Identity", ["in1"], ["out1"]),
+    ],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "in0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "in1", onnx.TensorProto.FLOAT, ["M"]
+        ),
+    ],
+    [
+        onnx.helper.make_tensor_value_info(
+            "out0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "out1", onnx.TensorProto.FLOAT, ["M"]
+        ),
+    ],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x0", "x1"], outputs=["y0", "y1"], body=body
+)
+
+x0 = [
+    np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+    for _ in range(3)
+]
+x1 = np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+y0 = x0
+y1 = [x1 for _ in range(3)]
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"]),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"])
+    ),
+]
+expect(
+    node,
+    inputs=[x0, x1],
+    outputs=[y0, y1],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_identity_1_sequence_1_tensor",
+)
+```
+
+</details>
+
+
+<details>
+<summary>sequence_map_identity_2_sequences</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [
+        onnx.helper.make_node("Identity", ["in0"], ["out0"]),
+        onnx.helper.make_node("Identity", ["in1"], ["out1"]),
+    ],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "in0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "in1", onnx.TensorProto.FLOAT, ["M"]
+        ),
+    ],
+    [
+        onnx.helper.make_tensor_value_info(
+            "out0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "out1", onnx.TensorProto.FLOAT, ["M"]
+        ),
+    ],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x0", "x1"], outputs=["y0", "y1"], body=body
+)
+
+x0 = [
+    np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+    for _ in range(3)
+]
+x1 = [
+    np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+    for _ in range(3)
+]
+y0 = x0
+y1 = x1
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"])
+    ),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"])
+    ),
+]
+expect(
+    node,
+    inputs=[x0, x1],
+    outputs=[y0, y1],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_identity_2_sequences",
+)
+```
+
+</details>
+
+
+### <a name="Shape"></a><a name="shape">**Shape**</a>
+
+  Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+  Optional attributes start and end can be used to compute a slice of the input tensor's shape.
+  If start axis is omitted, the slice starts from axis 0.
+  The end axis, if specified, is exclusive (and the returned value will not include the size of that axis).
+  If the end axis is omitted, the axes upto the last one will be included.
+  Negative axes indicate counting back from the last axis.
+  Note that axes will be clamped to the range [0, r], where r is the
+  rank of the input tensor if they are out-of-range (after adding r in the case of
+  negative axis). Thus, specifying any end value > r is equivalent to specifying an end
+  value of r, and specifying any start value < -r is equivalent to specifying a start
+  value of 0. If start > end, the result will be an empty shape.
+
+  Examples:
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  No attributes specified.
+  Output: [2, 3, 4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: -1
+  Output: [4]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  end: -1
+  Output: [2, 3]
+  ```
+
+  ```
+  Input tensor with shape: [2, 3, 4]
+  start: 1
+  end: 2
+  Output: [3]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Shape-1">1</a>, <a href="Changelog.md#Shape-13">13</a>, <a href="Changelog.md#Shape-15">15</a>, <a href="Changelog.md#Shape-19">19</a>, <a href="Changelog.md#Shape-21">21</a>, <a href="Changelog.md#Shape-23">23</a>, <a href="Changelog.md#Shape-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>end</tt> : int</dt>
+<dd>(Optional) Ending axis for slicing the shape. Negative value means counting dimensions from the back. If omitted, sizes of all axes upto (including) the last one will be included.</dd>
+<dt><tt>start</tt> : int (default is 0)</dt>
+<dd>(Optional) Starting axis for slicing the shape. Default value is 0.Negative value means counting dimensions from the back.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>shape</tt> (non-differentiable) : T1</dt>
+<dd>Shape of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>shape</summary>
+
+```python
+x = np.array(
+    [
+        [1, 2, 3],
+        [4, 5, 6],
+    ]
+).astype(np.float32)
+test_shape("_example", x)  # preserve names of original test cases
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+
+test_shape("", x)  # preserve names of original test cases
+
+test_shape("_start_1", x, start=1)
+
+test_shape("_end_1", x, end=1)
+
+test_shape("_start_negative_1", x, start=-1)
+
+test_shape("_end_negative_1", x, end=-1)
+
+test_shape("_start_1_end_negative_1", x, start=1, end=-1)
+
+test_shape("_start_1_end_2", x, start=1, end=2)
+
+test_shape("_clip_start", x, start=-10)
+
+test_shape("_clip_end", x, end=10)
+
+test_shape("_start_greater_than_end", x, start=2, end=1)
+```
+
+</details>
+
+
+### <a name="Shrink"></a><a name="shrink">**Shrink**</a>
+
+  Shrink takes one input data (Tensor<numeric>) and produces one Tensor output,
+  having same datatype and shape with input. It has two attributes, lambd and
+  bias. The formula of this operator is: If x < -lambd, y = x + bias;
+  If x > lambd, y = x - bias; Otherwise, y = 0.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>bias</tt> : float (default is 0.0)</dt>
+<dd>The bias value added to output. Default is 0.</dd>
+<dt><tt>lambd</tt> : float (default is 0.5)</dt>
+<dd>The lambd value for the Shrink formulation. Default is 0.5.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The input data as Tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input to only numeric types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>hard_shrink</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Shrink",
+    inputs=["x"],
+    outputs=["y"],
+    lambd=1.5,
+)
+X = np.arange(-2.0, 2.1, dtype=np.float32)
+Y = np.array([-2, 0, 0, 0, 2], dtype=np.float32)
+expect(node, inputs=[X], outputs=[Y], name="test_shrink_hard")
+```
+
+</details>
+
+
+<details>
+<summary>soft_shrink</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Shrink",
+    inputs=["x"],
+    outputs=["y"],
+    lambd=1.5,
+    bias=1.5,
+)
+X = np.arange(-2.0, 2.1, dtype=np.float32)
+Y = np.array([-0.5, 0, 0, 0, 0.5], dtype=np.float32)
+expect(node, inputs=[X], outputs=[Y], name="test_shrink_soft")
+```
+
+</details>
+
+
+### <a name="Sigmoid"></a><a name="sigmoid">**Sigmoid**</a>
+
+  Sigmoid takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the sigmoid function, y = 1 / (1 + exp(-x)), is applied to the
+  tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Sigmoid-1">1</a>, <a href="Changelog.md#Sigmoid-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>sigmoid</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sigmoid",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = 1.0 / (
+    1.0 + np.exp(np.negative(x))
+)  # expected output [0.26894143, 0.5, 0.7310586]
+expect(node, inputs=[x], outputs=[y], name="test_sigmoid_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = 1.0 / (1.0 + np.exp(np.negative(x)))
+expect(node, inputs=[x], outputs=[y], name="test_sigmoid")
+```
+
+</details>
+
+
+### <a name="Sign"></a><a name="sign">**Sign**</a>
+
+  Calculate the sign of the given input tensor element-wise.
+  If input > 0, output 1. if input < 0, output -1. if input == 0, output 0.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Sign-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (non-differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (non-differentiable) : T</dt>
+<dd>The sign of the input tensor computed element-wise. It has the same shape and type of the input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>sign</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sign",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array(range(-5, 6)).astype(np.float32)
+y = np.sign(x)
+expect(node, inputs=[x], outputs=[y], name="test_sign")
+```
+
+</details>
+
+
+### <a name="Sin"></a><a name="sin">**Sin**</a>
+
+  Calculates the sine of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Sin-7">7</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The sine of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>sin</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sin",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.sin(x)
+expect(node, inputs=[x], outputs=[y], name="test_sin_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.sin(x)
+expect(node, inputs=[x], outputs=[y], name="test_sin")
+```
+
+</details>
+
+
+### <a name="Sinh"></a><a name="sinh">**Sinh**</a>
+
+  Calculates the hyperbolic sine of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Sinh-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic sine values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>sinh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sinh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.sinh(x)  # expected output [-1.17520118,  0.,  1.17520118]
+expect(node, inputs=[x], outputs=[y], name="test_sinh_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.sinh(x)
+expect(node, inputs=[x], outputs=[y], name="test_sinh")
+```
+
+</details>
+
+
+### <a name="Size"></a><a name="size">**Size**</a>
+
+  Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Size-1">1</a>, <a href="Changelog.md#Size-13">13</a>, <a href="Changelog.md#Size-19">19</a>, <a href="Changelog.md#Size-21">21</a>, <a href="Changelog.md#Size-23">23</a>, <a href="Changelog.md#Size-24">24</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (non-differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>size</tt> (non-differentiable) : T1</dt>
+<dd>Total number of elements of the input tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Input tensor can be of arbitrary type.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain output to int64 tensor, which should be a scalar though.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>size</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Size",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        [1, 2, 3],
+        [4, 5, 6],
+    ]
+).astype(np.float32)
+y = np.array(6).astype(np.int64)
+
+expect(node, inputs=[x], outputs=[y], name="test_size_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.array(x.size).astype(np.int64)
+
+expect(node, inputs=[x], outputs=[y], name="test_size")
+```
+
+</details>
+
+
+### <a name="Slice"></a><a name="slice">**Slice**</a>
+
+  Produces a slice of the input tensor along multiple axes. Similar to numpy:
+  https://numpy.org/doc/stable/user/basics.indexing.html?highlight=slice#slicing-and-striding
+
+  Slice uses the `starts`, `ends`, `axes` and `steps` inputs to select a sub-tensor
+  of its input `data` tensor.
+
+  An effective `starts[i]`, `ends[i]`, and `steps[i]` must be computed for each `i`
+  in `[0, ... r-1]` where `r = rank(input)` as follows:
+
+  If `axes` are omitted, they are set to `[0, ..., r-1]`.
+  If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
+
+  The effective values are initialized as `start[i] = 0`, `ends[i] = dims[i]` where
+  `dims` are the dimensions of `input` and `steps[i] = 1`.
+
+  All negative elements of `axes` are made non-negative by adding `r` to them, where
+  `r =rank(input)`.
+
+  All negative values in `starts[i]` and `ends[i]` have `dims[axes[i]]` added to them,
+  where `dims` are the dimensions of `input`. Then `start[axes[i]]` is the adjusted
+  `starts[i]` is clamped into the range `[0, dims[axes[i]]]` for positive stepping
+  and `[0, dims[axes[i]]-1]` for negative stepping.
+
+  The clamping for the adjusted `ends[i]` depends on the sign of `steps[i]` and must
+  accommodate copying 0 through `dims[axes[i]]` elements, so for positive stepping
+  `ends[axes[i]]` is clamped to `[0, dims[axes[i]]]`, while for negative stepping it
+  is clamped to `[-1, dims[axes[i]]-1]`.
+
+  Finally, `steps[axes[i]] = steps[i]`.
+
+  For slicing to the end of a dimension with unknown size, it is recommended to pass
+  in `INT_MAX` when slicing forward and 'INT_MIN' when slicing backward.
+
+  Example 1:
+
+  ```
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  axes = [0, 1]
+  starts = [1, 0]
+  ends = [2, 3]
+  steps = [1, 2]
+  result = [
+      [5, 7],
+  ]
+  ```
+
+  Example 2:
+
+  ```
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  starts = [0, 1]
+  ends = [-1, 1000]
+  result = [
+      [2, 3, 4],
+  ]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Slice-1">1</a>, <a href="Changelog.md#Slice-10">10</a>, <a href="Changelog.md#Slice-11">11</a>
+
+#### Inputs (3 - 5)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensor of data to extract slices from.</dd>
+<dt><tt>starts</tt> (non-differentiable) : Tind</dt>
+<dd>1-D tensor of starting indices of corresponding axis in `axes`</dd>
+<dt><tt>ends</tt> (non-differentiable) : Tind</dt>
+<dd>1-D tensor of ending indices (exclusive) of corresponding axis in `axes`</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of axes that `starts` and `ends` apply to. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an axis is repeated.</dd>
+<dt><tt>steps</tt> (optional, non-differentiable) : Tind</dt>
+<dd>1-D tensor of slice step of corresponding axis in `axes`. Negative value means slicing backward. 'steps' cannot be 0. Defaults to 1s.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Sliced data tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain indices to integer types</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>slice</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+y = x[0:3, 0:10]
+starts = np.array([0, 0], dtype=np.int64)
+ends = np.array([3, 10], dtype=np.int64)
+axes = np.array([0, 1], dtype=np.int64)
+steps = np.array([1, 1], dtype=np.int64)
+
+expect(
+    node, inputs=[x, starts, ends, axes, steps], outputs=[y], name="test_slice"
+)
+```
+
+</details>
+
+
+<details>
+<summary>slice_default_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([0, 0, 3], dtype=np.int64)
+ends = np.array([20, 10, 4], dtype=np.int64)
+y = x[:, :, 3:4]
+
+expect(
+    node, inputs=[x, starts, ends], outputs=[y], name="test_slice_default_axes"
+)
+```
+
+</details>
+
+
+<details>
+<summary>slice_default_steps</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([0, 0, 3], dtype=np.int64)
+ends = np.array([20, 10, 4], dtype=np.int64)
+axes = np.array([0, 1, 2], dtype=np.int64)
+y = x[:, :, 3:4]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes],
+    outputs=[y],
+    name="test_slice_default_steps",
+)
+```
+
+</details>
+
+
+<details>
+<summary>slice_end_out_of_bounds</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([1], dtype=np.int64)
+ends = np.array([1000], dtype=np.int64)
+axes = np.array([1], dtype=np.int64)
+steps = np.array([1], dtype=np.int64)
+y = x[:, 1:1000]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes, steps],
+    outputs=[y],
+    name="test_slice_end_out_of_bounds",
+)
+```
+
+</details>
+
+
+<details>
+<summary>slice_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([0], dtype=np.int64)
+ends = np.array([-1], dtype=np.int64)
+axes = np.array([1], dtype=np.int64)
+steps = np.array([1], dtype=np.int64)
+y = x[:, 0:-1]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes, steps],
+    outputs=[y],
+    name="test_slice_neg",
+)
+```
+
+</details>
+
+
+<details>
+<summary>slice_neg_steps</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([20, 10, 4], dtype=np.int64)
+ends = np.array([0, 0, 1], dtype=np.int64)
+axes = np.array([0, 1, 2], dtype=np.int64)
+steps = np.array([-1, -3, -2]).astype(np.int64)
+y = x[20:0:-1, 10:0:-3, 4:1:-2]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes, steps],
+    outputs=[y],
+    name="test_slice_neg_steps",
+)
+```
+
+</details>
+
+
+<details>
+<summary>slice_negative_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([0, 0, 3], dtype=np.int64)
+ends = np.array([20, 10, 4], dtype=np.int64)
+axes = np.array([0, -2, -1], dtype=np.int64)
+y = x[:, :, 3:4]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes],
+    outputs=[y],
+    name="test_slice_negative_axes",
+)
+```
+
+</details>
+
+
+<details>
+<summary>slice_start_out_of_bounds</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([1000], dtype=np.int64)
+ends = np.array([1000], dtype=np.int64)
+axes = np.array([1], dtype=np.int64)
+steps = np.array([1], dtype=np.int64)
+y = x[:, 1000:1000]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes, steps],
+    outputs=[y],
+    name="test_slice_start_out_of_bounds",
+)
+```
+
+</details>
+
+
+### <a name="Softmax"></a><a name="softmax">**Softmax**</a>
+
+  The operator computes the normalized exponential values for the given input:
+
+   Softmax(input, axis) = Exp(input) / ReduceSum(Exp(input), axis=axis, keepdims=1)
+
+  The "axis" attribute indicates the dimension along which Softmax
+  will be performed. The output tensor has the same shape
+  and contains the Softmax values of the corresponding input.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Softmax-1">1</a>, <a href="Changelog.md#Softmax-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>
+Describes the dimension Softmax will be performed on.
+Negative value means counting dimensions
+from the back. Accepted range is [-r, r-1] where r = rank(input).
+</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The input tensor of rank >= axis.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The output values with the same shape as the input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>softmax</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.array([[-1, 0, 1]]).astype(np.float32)
+# expected output [[0.09003058, 0.24472848, 0.66524094]]
+y = softmax(x, axis=1)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_example")
+```
+
+</details>
+
+
+<details>
+<summary>softmax_axis</summary>
+
+```python
+x = np.array([[0, 1, 2, 3], [10000, 10001, 10002, 10003]]).astype(np.float32)
+# expected output
+# [[0.032058604 0.08714432  0.23688284  0.6439143  ]
+# [0.032058604 0.08714432  0.23688284  0.6439143  ]]
+y = softmax(x)
+
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_large_number")
+
+x = np.abs(np.random.randn(3, 4, 5).astype(np.float32))
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=0,
+)
+y = softmax(x, axis=0)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_0")
+
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=1,
+)
+y = softmax(x, axis=1)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_1")
+
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=2,
+)
+y = softmax(x, axis=2)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_2")
+
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=-1,
+)
+y = softmax(x, axis=-1)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_negative_axis")
+
+# default axis is -1
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_default_axis")
+```
+
+</details>
+
+
+### <a name="SoftmaxCrossEntropyLoss"></a><a name="softmaxcrossentropyloss">**SoftmaxCrossEntropyLoss**</a>
+
+  Loss function that measures the softmax cross entropy
+  between 'scores' and 'labels'.
+  This operator first computes a loss tensor whose shape is identical to the labels input.
+  If the input is 2-D with shape (N, C), the loss tensor may be a N-element vector L = (l_1, l_2, ..., l_N).
+  If the input is N-D tensor with shape (N, C, D1, D2, ..., Dk),
+  the loss tensor L may have (N, D1, D2, ..., Dk) as its shape and L[i,][j_1][j_2]...[j_k] denotes a scalar element in L.
+  After L is available, this operator can optionally do a reduction operator.
+
+  * shape(scores): (N, C) where C is the number of classes, or (N, C, D1, D2,..., Dk),
+    with K >= 1 in case of K-dimensional loss.
+  * shape(labels): (N) where each value is 0 <= labels[i] <= C-1, or (N, D1, D2,..., Dk),
+    with K >= 1 in case of K-dimensional loss.
+
+  The loss for one sample, l_i, can calculated as follows:
+  ```
+  l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk], where i is the index of classes.
+  ```
+  or
+  ```
+  l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk] * weights[c], if 'weights' is provided.
+  ```
+
+  loss is zero for the case when label-value equals ignore_index.
+  ```
+  l[i][d1][d2]...[dk]  = 0, when labels[n][d1][d2]...[dk] = ignore_index
+  ```
+
+  where:
+  ```
+  p = Softmax(scores)
+  y = Log(p)
+  c = labels[i][d1][d2]...[dk]
+  ```
+
+  Finally, L is optionally reduced:
+
+  * If reduction = 'none', the output is L with shape (N, D1, D2, ..., Dk).
+  * If reduction = 'sum', the output is scalar: Sum(L).
+  * If reduction = 'mean', the output is scalar: ReduceMean(L), or if weight is provided: `ReduceSum(L) / ReduceSum(W)`,
+    where tensor W is of shape `(N, D1, D2, ..., Dk)` and `W[n][d1][d2]...[dk] = weights[labels[i][d1][d2]...[dk]]`.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#SoftmaxCrossEntropyLoss-12">12</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>ignore_index</tt> : int</dt>
+<dd>Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.</dd>
+<dt><tt>reduction</tt> : string (default is mean)</dt>
+<dd>Type of reduction to apply to loss: none, sum, mean(default). 'none': no reduction will be applied, 'sum': the output will be summed. 'mean': the sum of the output will be divided by the number of elements in the output.</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>scores</tt> (differentiable) : T</dt>
+<dd>The predicted outputs with shape [batch_size, class_size], or [batch_size, class_size, D1, D2 , ..., Dk], where K is the number of dimensions.</dd>
+<dt><tt>labels</tt> (non-differentiable) : Tind</dt>
+<dd>The ground truth output tensor, with shape [batch_size], or [batch_size, D1, D2, ..., Dk], where K is the number of dimensions. Labels element value shall be in range of [0, C). If ignore_index is specified, it may have a value outside [0, C) and the label values should either be in the range [0, C) or have the value ignore_index.</dd>
+<dt><tt>weights</tt> (optional, non-differentiable) : T</dt>
+<dd>A manual rescaling weight given to each class. If given, it has to be a 1D Tensor assigning weight to each of the classes. Otherwise, it is treated as if having all ones.</dd>
+</dl>
+
+#### Outputs (1 - 2)
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Weighted loss float Tensor. If reduction is 'none', this has the shape of [batch_size], or [batch_size, D1, D2, ..., Dk] in case of K-dimensional loss. Otherwise, it is a scalar.</dd>
+<dt><tt>log_prob</tt> (optional, differentiable) : T</dt>
+<dd>Log probability tensor. If the output of softmax is prob, its value is log(prob).</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+<dt><tt>Tind</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain target to integer types</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>input_shape_is_NCd1_mean_weight_negative_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(-1)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1 = 3, 5, 6
+np.random.seed(0)
+x = np.random.rand(N, C, dim1).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64)
+labels[0][0] = -1
+weight = np.random.rand(C).astype(np.float32)
+
+sce = softmaxcrossentropy(
+    x, labels, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[sce],
+    name="test_sce_NCd1_mean_weight_negative_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1_mean_weight_negative_ii_log_prob</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(-1)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1 = 3, 5, 6
+np.random.seed(0)
+x = np.random.rand(N, C, dim1).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64)
+labels[0][0] = -1
+weight = np.random.rand(C).astype(np.float32)
+
+loss, log_prob = softmaxcrossentropy(
+    x,
+    labels,
+    weight=weight,
+    reduction=reduction,
+    ignore_index=ignore_index,
+    get_log_prob=True,
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1_mean_weight_negative_ii_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3_none_no_weight_negative_ii</summary>
+
+```python
+reduction = "none"
+ignore_index = np.int64(-5)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype(
+    np.int64
+)
+labels[0][0][0][0] = -5
+
+sce = softmaxcrossentropy(
+    x, labels, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[sce],
+    name="test_sce_NCd1d2d3_none_no_weight_negative_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3_none_no_weight_negative_ii_log_prob</summary>
+
+```python
+reduction = "none"
+ignore_index = np.int64(-5)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype(
+    np.int64
+)
+labels[0][0][0][0] = -5
+
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction=reduction, ignore_index=ignore_index, get_log_prob=True
+)
+
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3_sum_weight_high_ii</summary>
+
+```python
+reduction = "sum"
+ignore_index = np.int64(10)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C = 3, 5
+np.random.seed(0)
+x = np.random.rand(N, C).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N)).astype(np.int64)
+labels[0] = 10
+weight = np.random.rand(C).astype(np.float32)
+
+sce = softmaxcrossentropy(
+    x, labels, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[sce],
+    name="test_sce_NCd1d2d3_sum_weight_high_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3_sum_weight_high_ii_log_prob</summary>
+
+```python
+reduction = "sum"
+ignore_index = np.int64(10)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C = 3, 5
+np.random.seed(0)
+x = np.random.rand(N, C).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N)).astype(np.int64)
+labels[0] = 10
+weight = np.random.rand(C).astype(np.float32)
+
+loss, log_prob = softmaxcrossentropy(
+    x,
+    labels,
+    weight=weight,
+    reduction=reduction,
+    ignore_index=ignore_index,
+    get_log_prob=True,
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1d2d3_sum_weight_high_ii_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_mean_weight</summary>
+
+```python
+reduction = "mean"
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+labels = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+sce = softmaxcrossentropy(x, labels, weight=weight, reduction=reduction)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[sce],
+    name="test_sce_NCd1d2d3d4d5_mean_weight",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_mean_weight_log_prob</summary>
+
+```python
+reduction = "mean"
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+labels = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weight, reduction=reduction, get_log_prob=True
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1d2d3d4d5_mean_weight_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_none_no_weight</summary>
+
+```python
+reduction = "none"
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+labels = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+
+sce = softmaxcrossentropy(x, labels, reduction=reduction)
+
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[sce],
+    name="test_sce_NCd1d2d3d4d5_none_no_weight",
+)
+```
+
+</details>
+
+
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_none_no_weight_log_prob</summary>
+
+```python
+reduction = "none"
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+labels = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction=reduction, get_log_prob=True
+)
+
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1d2d3d4d5_none_no_weight_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels)
+
+# Check results
+expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_mean")
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_3d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+y = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, y)
+
+# Check results
+expect(node, inputs=[x, y], outputs=[sce], name="test_sce_mean_3d")
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_3d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+y = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(x, y, get_log_prob=True)
+
+# Check results
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_3d_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(x, labels, get_log_prob=True)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+labels[0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, ignore_index=ignore_index)
+
+# Check results
+expect(
+    node, inputs=[x, labels], outputs=[sce], name="test_sce_mean_no_weight_ii"
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_3d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+labels[0][0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, ignore_index=ignore_index)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[sce],
+    name="test_sce_mean_no_weight_ii_3d",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_3d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+labels[0][0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_no_weight_ii_3d_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_4d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+labels[0][0][0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(
+    x, labels, reduction=reduction, ignore_index=ignore_index
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[sce],
+    name="test_sce_mean_no_weight_ii_4d",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_4d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+labels[0][0][0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction=reduction, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_no_weight_ii_4d_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+labels[0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_no_weight_ii_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_weights</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, weight=weights)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_mean_weight",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(0)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+labels[0] = np.int64(0)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, weight=weights, ignore_index=ignore_index)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_mean_weight_ii",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_3d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(1)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+labels[0][0] = np.int64(1)
+weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, weight=weights, ignore_index=ignore_index)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_mean_weight_ii_3d",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_3d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(1)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+labels[0][0] = np.int64(1)
+weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weights, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_weight_ii_3d_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_4d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+labels[0][0][0] = np.int64(2)
+weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(
+    x, labels, reduction=reduction, weight=weights, ignore_index=ignore_index
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_mean_weight_ii_4d",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_4d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+labels[0][0][0] = np.int64(2)
+weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x,
+    labels,
+    reduction=reduction,
+    weight=weights,
+    ignore_index=ignore_index,
+    get_log_prob=True,
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_weight_ii_4d_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(0)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+labels[0] = np.int64(0)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weights, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_weight_ii_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_mean_weights_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weights, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_weight_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_none</summary>
+
+```python
+# Define operator attributes.
+reduction = "none"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, reduction="none")
+
+# Check results
+expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_none")
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_none_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "none"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction="none", get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_none_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_none_weights</summary>
+
+```python
+# Define operator attributes.
+reduction = "none"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, weight=weights, reduction="none")
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_none_weights",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_none_weights_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "none"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weights, reduction="none", get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_none_weights_log_prob",
+)
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_sum</summary>
+
+```python
+# Define operator attributes.
+reduction = "sum"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, reduction="sum")
+
+# Check results
+expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_sum")
+```
+
+</details>
+
+
+<details>
+<summary>softmaxcrossentropy_sum_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "sum"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction="sum", get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_sum_log_prob",
+)
+```
+
+</details>
+
+
+### <a name="Softplus"></a><a name="softplus">**Softplus**</a>
+
+  Softplus takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the softplus function, y = ln(exp(x) + 1), is applied to
+  the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Softplus-1">1</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>softplus</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Softplus",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.log(
+    np.exp(x) + 1
+)  # expected output [0.31326166, 0.69314718, 1.31326163]
+expect(node, inputs=[x], outputs=[y], name="test_softplus_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.log(np.exp(x) + 1)
+expect(node, inputs=[x], outputs=[y], name="test_softplus")
+```
+
+</details>
+
+
+### <a name="Softsign"></a><a name="softsign">**Softsign**</a>
+
+  Calculates the softsign (x/(1+|x|)) of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Softsign-1">1</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The softsign (x/(1+|x|)) values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>softsign</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Softsign",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.array([-0.5, 0, 0.5]).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_softsign_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = x / (1 + np.abs(x))
+expect(node, inputs=[x], outputs=[y], name="test_softsign")
+```
+
+</details>
+
+
+### <a name="SpaceToDepth"></a><a name="spacetodepth">**SpaceToDepth**</a>
+
+  SpaceToDepth rearranges blocks of spatial data into depth. More specifically,
+  this op outputs a copy of the input tensor where values from the height and width dimensions
+  are moved to the depth dimension.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#SpaceToDepth-1">1</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>blocksize</tt> : int (required)</dt>
+<dd>Blocks of [blocksize, blocksize] are moved.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth, H is the height and W is the width.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor of [N, C * blocksize * blocksize, H/blocksize, W/blocksize].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>example</summary>
+
+```python
+node = onnx.helper.make_node(
+    "SpaceToDepth",
+    inputs=["x"],
+    outputs=["y"],
+    blocksize=2,
+)
+
+# (1, 1, 4, 6) input tensor
+x = np.array(
+    [
+        [
+            [
+                [0, 6, 1, 7, 2, 8],
+                [12, 18, 13, 19, 14, 20],
+                [3, 9, 4, 10, 5, 11],
+                [15, 21, 16, 22, 17, 23],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+# (1, 4, 2, 3) output tensor
+y = np.array(
+    [
+        [
+            [[0, 1, 2], [3, 4, 5]],
+            [[6, 7, 8], [9, 10, 11]],
+            [[12, 13, 14], [15, 16, 17]],
+            [[18, 19, 20], [21, 22, 23]],
+        ]
+    ]
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_spacetodepth_example")
+```
+
+</details>
+
+
+<details>
+<summary>spacetodepth</summary>
+
+```python
+b, c, h, w = shape = (2, 2, 6, 6)
+blocksize = 2
+node = onnx.helper.make_node(
+    "SpaceToDepth",
+    inputs=["x"],
+    outputs=["y"],
+    blocksize=blocksize,
+)
+x = np.random.random_sample(shape).astype(np.float32)
+tmp = np.reshape(
+    x, [b, c, h // blocksize, blocksize, w // blocksize, blocksize]
+)
+tmp = np.transpose(tmp, [0, 3, 5, 1, 2, 4])
+y = np.reshape(tmp, [b, c * (blocksize**2), h // blocksize, w // blocksize])
+expect(node, inputs=[x], outputs=[y], name="test_spacetodepth")
+```
+
+</details>
+
+
+### <a name="Split"></a><a name="split">**Split**</a>
+
+  Split a tensor into a list of tensors, along the specified 'axis'.
+  Either input 'split' or the attribute 'num_outputs' should be specified, but not both.
+  If the attribute 'num_outputs' is specified, then the tensor is split into equal sized parts.
+  If the tensor is not evenly splittable into `num_outputs`, the last chunk will be smaller.
+  If the input 'split' is specified, it indicates the sizes of each output in the split.
+
+#### Version
+
+This version of the operator has been available since version 18 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Split-1">1</a>, <a href="Changelog.md#Split-2">2</a>, <a href="Changelog.md#Split-11">11</a>, <a href="Changelog.md#Split-13">13</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to split on. A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] where r = rank(input).</dd>
+<dt><tt>num_outputs</tt> : int</dt>
+<dd>Number of outputs to split parts of the tensor into. If the tensor is not evenly splittable the last chunk will be smaller.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>The tensor to split</dd>
+<dt><tt>split</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Optional length of each output. Values should be >= 0.Sum of the values must be equal to the dim value at 'axis' specified.</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, differentiable) : T</dt>
+<dd>One or more outputs forming list of tensors after splitting</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>1d_opset13</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3"],
+    axis=0,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_1d_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2"],
+    axis=0,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_1d_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>1d_opset18</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3"],
+    axis=0,
+    num_outputs=3,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_1d_opset18",
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2"],
+    axis=0,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_1d_opset18",
+)
+```
+
+</details>
+
+
+<details>
+<summary>1d_uneven_split_opset18</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]).astype(np.float32)
+
+# If axis is not specified, split is applied on default axis 0
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3", "output_4"],
+    num_outputs=4,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+    np.array([7.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_1d_uneven_split_opset18",
+)
+```
+
+</details>
+
+
+<details>
+<summary>2d_opset13</summary>
+
+```python
+node_input = np.array(
+    [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split", inputs=["input"], outputs=["output_1", "output_2"], axis=1
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0, 3.0], [7.0, 8.0, 9.0]]).astype(np.float32),
+    np.array([[4.0, 5.0, 6.0], [10.0, 11.0, 12.0]]).astype(np.float32),
+]
+
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_2d_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2"],
+    axis=1,
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0], [7.0, 8.0]]).astype(np.float32),
+    np.array([[3.0, 4.0, 5.0, 6.0], [9.0, 10.0, 11.0, 12.0]]).astype(
+        np.float32
+    ),
+]
+
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_2d_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>2d_opset18</summary>
+
+```python
+node_input = np.array(
+    [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2"],
+    axis=1,
+    num_outputs=2,
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0, 3.0], [7.0, 8.0, 9.0]]).astype(np.float32),
+    np.array([[4.0, 5.0, 6.0], [10.0, 11.0, 12.0]]).astype(np.float32),
+]
+
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_2d",
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2"],
+    axis=1,
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0], [7.0, 8.0]]).astype(np.float32),
+    np.array([[3.0, 4.0, 5.0, 6.0], [9.0, 10.0, 11.0, 12.0]]).astype(
+        np.float32
+    ),
+]
+
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_2d_opset18",
+)
+```
+
+</details>
+
+
+<details>
+<summary>2d_uneven_split_opset18</summary>
+
+```python
+node_input = np.array(
+    [
+        [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
+        [9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0],
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3"],
+    axis=1,
+    num_outputs=3,
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0, 3.0], [9.0, 10.0, 11.0]]).astype(np.float32),
+    np.array([[4.0, 5.0, 6.0], [12.0, 13.0, 14.0]]).astype(np.float32),
+    np.array([[7.0, 8.0], [15.0, 16.0]]).astype(np.float32),
+]
+
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_2d_uneven_split_opset18",
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_values_opset13</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+# If axis is not specified, split is applied on default axis 0
+node = onnx.helper.make_node(
+    "Split", inputs=["input"], outputs=["output_1", "output_2", "output_3"]
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_default_axis_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split", inputs=["input", "split"], outputs=["output_1", "output_2"]
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_default_axis_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>default_values_opset18</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+# If axis is not specified, split is applied on default axis 0
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3"],
+    num_outputs=3,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_default_axis_opset18",
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split", inputs=["input", "split"], outputs=["output_1", "output_2"]
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_default_axis_opset18",
+)
+```
+
+</details>
+
+
+<details>
+<summary>zero_size_splits_opset13</summary>
+
+```python
+# 1-dimensional tensor with dimension_size=0
+node_input = np.array([]).astype(np.float32)
+
+# Split empty tensor to tensors of size zero
+split = np.array([0, 0, 0]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2", "output_3"],
+)
+
+expected_outputs = [
+    np.array([]).astype(np.float32),
+    np.array([]).astype(np.float32),
+    np.array([]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_zero_size_splits_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+
+
+<details>
+<summary>zero_size_splits_opset18</summary>
+
+```python
+# 1-dimensional tensor with dimension_size=0
+node_input = np.array([]).astype(np.float32)
+
+# Split empty tensor to tensors of size zero
+split = np.array([0, 0, 0]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2", "output_3"],
+)
+
+expected_outputs = [
+    np.array([]).astype(np.float32),
+    np.array([]).astype(np.float32),
+    np.array([]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_zero_size_splits_opset18",
+)
+```
+
+</details>
+
+
+### <a name="SplitToSequence"></a><a name="splittosequence">**SplitToSequence**</a>
+
+  Split a tensor into a sequence of tensors, along the specified 'axis'.
+  Lengths of the parts can be specified using the optional argument 'split'.
+  If the argument `split' is not specified, a default scalar value of 1
+  is used as the value of `split'.
+  'split' must contain only positive numbers.
+  'split' is either a scalar (tensor of empty shape), or a 1-D tensor.
+  If 'split' is a scalar, then 'input' will be split into chunks all of size 'split'
+  if possible. The last chunk alone may be smaller than 'split' if the 'input' size
+  along the given axis 'axis' is not divisible by 'split'.
+  If 'split' is a 1-dimensional tensor, the input tensor is split into 'size(split)' chunks,
+  with lengths of the parts on 'axis' specified in 'split'. In this scenario, the sum of entries
+  in 'split' must be equal to the dimension size of input tensor on 'axis'.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#SplitToSequence-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is 0)</dt>
+<dd>Which axis to split on. A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1].</dd>
+<dt><tt>keepdims</tt> : int (default is 1)</dt>
+<dd>Keep the split dimension or not. Default 1, which means we keep split dimension. If input 'split' is specified, this attribute is ignored.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> : T</dt>
+<dd>The tensor to split</dd>
+<dt><tt>split</tt> (optional) : I</dt>
+<dd>Length of each output. It can be either a scalar(tensor of empty shape), or a 1-D tensor. All values must be >= 0. </dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output_sequence</tt> : S</dt>
+<dd>One or more outputs forming a sequence of tensors after splitting</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input types to all tensor types.</dd>
+<dt><tt>I</tt> : tensor(int32), tensor(int64)</dt>
+<dd>Constrain split size to integral tensor.</dd>
+<dt><tt>S</tt> : seq(tensor(uint8)), seq(tensor(uint16)), seq(tensor(uint32)), seq(tensor(uint64)), seq(tensor(int8)), seq(tensor(int16)), seq(tensor(int32)), seq(tensor(int64)), seq(tensor(bfloat16)), seq(tensor(float16)), seq(tensor(float)), seq(tensor(double)), seq(tensor(string)), seq(tensor(bool)), seq(tensor(complex64)), seq(tensor(complex128))</dt>
+<dd>Constrain output types to all tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>nokeepdims</summary>
+
+```python
+data = np.arange(18).reshape((3, 6)).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "SplitToSequence",
+    ["data"],
+    ["seq"],
+    axis=1,
+    keepdims=0,
+)
+
+expected_outputs = [[data[:, i] for i in range(data.shape[1])]]
+
+expect(
+    node,
+    inputs=[data],
+    outputs=expected_outputs,
+    name="test_split_to_sequence_nokeepdims",
+)
+```
+
+</details>
+
+
+<details>
+<summary>with_split_1</summary>
+
+```python
+data = np.arange(18).reshape((3, 6)).astype(np.float32)
+split = np.array(2, dtype=np.int64)
+
+node = onnx.helper.make_node(
+    "SplitToSequence", ["data", "split"], ["seq"], axis=1
+)
+
+expected_outputs = [
+    [
+        np.array([[0.0, 1.0], [6.0, 7.0], [12.0, 13.0]], dtype=np.float32),
+        np.array([[2.0, 3.0], [8.0, 9.0], [14.0, 15.0]], dtype=np.float32),
+        np.array([[4.0, 5.0], [10.0, 11.0], [16.0, 17.0]], dtype=np.float32),
+    ]
+]
+
+expect(
+    node,
+    inputs=[data, split],
+    outputs=expected_outputs,
+    name="test_split_to_sequence_1",
+)
+```
+
+</details>
+
+
+<details>
+<summary>with_split_2</summary>
+
+```python
+data = np.arange(18).reshape((3, 6)).astype(np.float32)
+split = np.array([1, 2], dtype=np.int64)
+
+node = onnx.helper.make_node(
+    "SplitToSequence", ["data", "split"], ["seq"], axis=0
+)
+
+expected_outputs = [
+    [
+        data[:1],
+        data[1:],
+    ]
+]
+
+expect(
+    node,
+    inputs=[data, split],
+    outputs=expected_outputs,
+    name="test_split_to_sequence_2",
+)
+```
+
+</details>
+
+
+### <a name="Sqrt"></a><a name="sqrt">**Sqrt**</a>
+
+  Square root takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the square root is, y = x^0.5, is applied to
+  the tensor elementwise. If x is negative, then it will return NaN.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Sqrt-1">1</a>, <a href="Changelog.md#Sqrt-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>sqrt</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sqrt",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([1, 4, 9]).astype(np.float32)
+y = np.sqrt(x)  # expected output [1., 2., 3.]
+expect(node, inputs=[x], outputs=[y], name="test_sqrt_example")
+
+x = np.abs(np.random.randn(3, 4, 5).astype(np.float32))
+y = np.sqrt(x)
+expect(node, inputs=[x], outputs=[y], name="test_sqrt")
+```
+
+</details>
+
+
+### <a name="Squeeze"></a><a name="squeeze">**Squeeze**</a>
+
+  Remove single-dimensional entries from the shape of a tensor.
+  Takes an input `axes` with a list of axes to squeeze.
+  If `axes` is not provided, all the single dimensions will be removed from
+  the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Squeeze-1">1</a>, <a href="Changelog.md#Squeeze-11">11</a>, <a href="Changelog.md#Squeeze-13">13</a>, <a href="Changelog.md#Squeeze-21">21</a>, <a href="Changelog.md#Squeeze-23">23</a>, <a href="Changelog.md#Squeeze-24">24</a>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Tensors with at least max(dims) dimensions.</dd>
+<dt><tt>axes</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>1D tensor of integers indicating the dimensions to squeeze. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>squeezed</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv13.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>squeeze</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Squeeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+axes = np.array([0], dtype=np.int64)
+y = np.squeeze(x, axis=0)
+
+expect(node, inputs=[x, axes], outputs=[y], name="test_squeeze")
+```
+
+</details>
+
+
+<details>
+<summary>squeeze_negative_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Squeeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 1, 5).astype(np.float32)
+axes = np.array([-2], dtype=np.int64)
+y = np.squeeze(x, axis=-2)
+expect(node, inputs=[x, axes], outputs=[y], name="test_squeeze_negative_axes")
+```
+
+</details>
+
+
+### <a name="StringConcat"></a><a name="stringconcat">**StringConcat**</a>
+
+  StringConcat concatenates string tensors elementwise (with NumPy-style broadcasting support)
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Tensor to prepend in concatenation</dd>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>Tensor to append in concatenation</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Z</tt> (non-differentiable) : T</dt>
+<dd>Concatenated string tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(string)</dt>
+<dd>Inputs and outputs must be UTF-8 strings</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>stringconcat</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringConcat",
+    inputs=["x", "y"],
+    outputs=["result"],
+)
+x = np.array(["abc", "def"]).astype("object")
+y = np.array([".com", ".net"]).astype("object")
+result = np.array(["abc.com", "def.net"]).astype("object")
+
+expect(node, inputs=[x, y], outputs=[result], name="test_string_concat")
+
+x = np.array(["cat", "dog", "snake"]).astype("object")
+y = np.array(["s"]).astype("object")
+result = np.array(["cats", "dogs", "snakes"]).astype("object")
+
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[result],
+    name="test_string_concat_broadcasting",
+)
+
+x = np.array("cat").astype("object")
+y = np.array("s").astype("object")
+result = np.array("cats").astype("object")
+
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[result],
+    name="test_string_concat_zero_dimensional",
+)
+
+x = np.array(["abc", ""]).astype("object")
+y = np.array(["", "abc"]).astype("object")
+result = np.array(["abc", "abc"]).astype("object")
+
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[result],
+    name="test_string_concat_empty_string",
+)
+
+x = np.array(["的", "中"]).astype("object")
+y = np.array(["的", "中"]).astype("object")
+result = np.array(["的的", "中中"]).astype("object")
+
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[result],
+    name="test_string_concat_utf8",
+)
+```
+
+</details>
+
+
+### <a name="StringNormalizer"></a><a name="stringnormalizer">**StringNormalizer**</a>
+
+  StringNormalization performs string operations for basic cleaning.
+  This operator has only one input (denoted by X) and only one output
+  (denoted by Y). This operator first examines the elements in the X,
+  and removes elements specified in "stopwords" attribute.
+  After removing stop words, the intermediate result can be further lowercased,
+  uppercased, or just returned depending the "case_change_action" attribute.
+  This operator only accepts [C]- and [1, C]-tensor.
+  If all elements in X are dropped, the output will be the empty value of string tensor with shape [1]
+  if input shape is [C] and shape [1, 1] if input shape is [1, C].
+
+#### Version
+
+This version of the operator has been available since version 10 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>case_change_action</tt> : string (default is NONE)</dt>
+<dd>string enum that cases output to be lowercased/uppercases/unchanged. Valid values are "LOWER", "UPPER", "NONE". Default is "NONE"</dd>
+<dt><tt>is_case_sensitive</tt> : int (default is 0)</dt>
+<dd>Boolean. Whether the identification of stop words in X is case-sensitive. Default is false</dd>
+<dt><tt>locale</tt> : string</dt>
+<dd>Environment dependent string that denotes the locale according to which output strings needs to be upper/lowercased.Default en_US or platform specific equivalent as decided by the implementation.</dd>
+<dt><tt>stopwords</tt> : list of strings</dt>
+<dd>List of stop words. If not set, no word would be removed from X.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> : tensor(string)</dt>
+<dd>UTF-8 strings to normalize</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : tensor(string)</dt>
+<dd>UTF-8 Normalized strings</dd>
+</dl>
+
+#### Type Constraints
+
+
+
+#### Examples
+
+<details>
+<summary>monday_casesensintive_lower</summary>
+
+```python
+input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+output = np.array(["tuesday", "wednesday", "thursday"]).astype(object)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    case_change_action="LOWER",
+    is_case_sensitive=1,
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_casesensintive_lower",
+)
+```
+
+</details>
+
+
+<details>
+<summary>monday_casesensintive_nochangecase</summary>
+
+```python
+input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+output = np.array(["tuesday", "wednesday", "thursday"]).astype(object)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    is_case_sensitive=1,
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_casesensintive_nochangecase",
+)
+```
+
+</details>
+
+
+<details>
+<summary>monday_casesensintive_upper</summary>
+
+```python
+input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+output = np.array(["TUESDAY", "WEDNESDAY", "THURSDAY"]).astype(object)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    case_change_action="UPPER",
+    is_case_sensitive=1,
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_casesensintive_upper",
+)
+```
+
+</details>
+
+
+<details>
+<summary>monday_empty_output</summary>
+
+```python
+input = np.array(["monday", "monday"]).astype(object)
+output = np.array([""]).astype(object)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    case_change_action="UPPER",
+    is_case_sensitive=1,
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_empty_output",
+)
+```
+
+</details>
+
+
+<details>
+<summary>monday_insensintive_upper_twodim</summary>
+
+```python
+input = (
+    np.array(
+        ["Monday", "tuesday", "wednesday", "Monday", "tuesday", "wednesday"]
+    )
+    .astype(object)
+    .reshape([1, 6])
+)
+
+# It does upper case cecedille, accented E
+# and german umlaut but fails
+# with german eszett
+output = (
+    np.array(["TUESDAY", "WEDNESDAY", "TUESDAY", "WEDNESDAY"])
+    .astype(object)
+    .reshape([1, 4])
+)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    case_change_action="UPPER",
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_insensintive_upper_twodim",
+)
+```
+
+</details>
+
+
+<details>
+<summary>nostopwords_nochangecase</summary>
+
+```python
+input = np.array(["monday", "tuesday"]).astype(object)
+output = input
+
+# No stopwords. This is a NOOP
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    is_case_sensitive=1,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_nostopwords_nochangecase",
+)
+```
+
+</details>
+
+
+### <a name="StringSplit"></a><a name="stringsplit">**StringSplit**</a>
+
+  StringSplit splits a string tensor's elements into substrings based on a delimiter attribute and a maxsplit attribute.
+
+  The first output of this operator is a tensor of strings representing the substrings from splitting each input string on the `delimiter` substring. This tensor has one additional rank compared to the input tensor in order to store the substrings for each input element (where the input tensor is not empty). Note that, in order to ensure the same number of elements are present in the final dimension, this tensor will pad empty strings as illustrated in the examples below. Consecutive delimiters are not grouped together and are deemed to delimit empty strings, except if the `delimiter` is unspecified or is the empty string (""). In the case where the `delimiter` is unspecified or the empty string, consecutive whitespace characters are regarded as a single separator and leading or trailing whitespace is removed in the output.
+
+  The second output tensor represents the number of substrings generated. `maxsplit` can be used to limit the number of splits performed - after the `maxsplit`th split if the string is not fully split, the trailing suffix of input string after the final split point is also added. For elements where fewer splits are possible than specified in `maxsplit`, it has no effect.
+
+#### Version
+
+This version of the operator has been available since version 20 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>delimiter</tt> : string</dt>
+<dd>Delimiter to split on. If left unset or set to the empty string (""), the input is split on consecutive whitespace.</dd>
+<dt><tt>maxsplit</tt> : int</dt>
+<dd>Maximum number of splits (from left to right). If left unset (or if the number of possible splits are less than maxsplit), it will make as many splits as possible. Note that the maximum possible number of substrings returned with `maxsplit` specified is `maxsplit+1` since the remaining suffix after the `maxsplit`th split is included in the output.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T1</dt>
+<dd>Tensor of strings to split.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T2</dt>
+<dd>Tensor of substrings representing the outcome of splitting the strings in the input on the delimiter. Note that to ensure the same number of elements are present in the final rank, this tensor will pad any necessary empty strings.</dd>
+<dt><tt>Z</tt> (non-differentiable) : T3</dt>
+<dd>The number of substrings generated for each input element.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(string)</dt>
+<dd>The input must be a UTF-8 string tensor</dd>
+<dt><tt>T2</tt> : tensor(string)</dt>
+<dd>Tensor of substrings.</dd>
+<dt><tt>T3</tt> : tensor(int64)</dt>
+<dd>The number of substrings generated.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>basic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringSplit",
+    inputs=["x"],
+    outputs=["substrings", "length"],
+    delimiter=".",
+    maxsplit=None,
+)
+
+x = np.array(["abc.com", "def.net"]).astype(object)
+
+substrings = np.array([["abc", "com"], ["def", "net"]]).astype(object)
+
+length = np.array([2, 2], dtype=np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[substrings, length],
+    name="test_string_split_basic",
+)
+```
+
+</details>
+
+
+<details>
+<summary>consecutive_delimiters</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringSplit",
+    inputs=["x"],
+    outputs=["substrings", "length"],
+    delimiter="-",
+    maxsplit=None,
+)
+
+x = np.array(["o-n-n--x-", "o-n----nx"]).astype(object)
+
+substrings = np.array(
+    [["o", "n", "n", "", "x", ""], ["o", "n", "", "", "", "nx"]]
+).astype(object)
+
+length = np.array([6, 6], dtype=np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[substrings, length],
+    name="test_string_split_consecutive_delimiters",
+)
+```
+
+</details>
+
+
+<details>
+<summary>empty_string_delimiter</summary>
+
+```python
+for delimiter, test_name in (
+    ("", "test_string_split_empty_string_delimiter"),
+    (None, "test_string_split_no_delimiter"),
+):
+    node = onnx.helper.make_node(
+        "StringSplit",
+        inputs=["x"],
+        outputs=["substrings", "length"],
+        delimiter=delimiter,
+        maxsplit=None,
+    )
+
+    x = np.array(
+        ["hello world !", "  hello   world !", " hello world   ! "]
+    ).astype(object)
+
+    substrings = np.array(
+        [
+            ["hello", "world", "!"],
+            ["hello", "world", "!"],
+            ["hello", "world", "!"],
+        ]
+    ).astype(object)
+
+    length = np.array([3, 3, 3], dtype=np.int64)
+
+    expect(
+        node,
+        inputs=[x],
+        outputs=[substrings, length],
+        name=test_name,
+    )
+```
+
+</details>
+
+
+<details>
+<summary>empty_string_split</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringSplit",
+    inputs=["x"],
+    outputs=["substrings", "length"],
+    delimiter=None,
+    maxsplit=None,
+)
+
+x = np.array([]).astype(object)
+
+substrings = np.array([]).astype(object).reshape(0, 0)
+
+length = np.array([], dtype=np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[substrings, length],
+    name="test_string_split_empty_tensor",
+    output_type_protos=[
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.STRING, (0, None)),
+        None,
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>maxsplit</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringSplit",
+    inputs=["x"],
+    outputs=["substrings", "length"],
+    maxsplit=2,
+)
+
+x = np.array(
+    [["hello world", "def.net"], ["o n n x", "the quick brown fox"]]
+).astype(object)
+
+substrings = np.array(
+    [
+        [["hello", "world", ""], ["def.net", "", ""]],
+        [["o", "n", "n x"], ["the", "quick", "brown fox"]],
+    ]
+).astype(object)
+
+length = np.array([[2, 1], [3, 3]], np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[substrings, length],
+    name="test_string_split_maxsplit",
+)
+```
+
+</details>
+
+
+### <a name="Sub"></a><a name="sub">**Sub**</a>
+
+  Performs element-wise binary subtraction (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+  (Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Sub-1">1</a>, <a href="Changelog.md#Sub-6">6</a>, <a href="Changelog.md#Sub-7">7</a>, <a href="Changelog.md#Sub-13">13</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (differentiable) : T</dt>
+<dd>First operand.</dd>
+<dt><tt>B</tt> (differentiable) : T</dt>
+<dd>Second operand.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (differentiable) : T</dt>
+<dd>Result, has same element type as two inputs</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to all numeric tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>sub</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sub",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([3, 2, 1]).astype(np.float32)
+z = x - y  # expected output [-2., 0., 2.]
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int8)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.int8)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_int8")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int16)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.int16)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_int16")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint8)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint8")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint16)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint16")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint32)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint32")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint64)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint64")
+```
+
+</details>
+
+
+<details>
+<summary>sub_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sub",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_bcast")
+```
+
+</details>
+
+
+### <a name="Sum"></a><a name="sum">**Sum**</a>
+
+  Element-wise sum of each of the input tensors (with Numpy-style broadcasting support).
+  All inputs and outputs must have the same data type.
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Sum-1">1</a>, <a href="Changelog.md#Sum-6">6</a>, <a href="Changelog.md#Sum-8">8</a>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>data_0</tt> (variadic, differentiable) : T</dt>
+<dd>List of tensors for sum.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>sum</tt> (differentiable) : T</dt>
+<dd>Output tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>sum</summary>
+
+```python
+data_0 = np.array([3, 0, 2]).astype(np.float32)
+data_1 = np.array([1, 3, 4]).astype(np.float32)
+data_2 = np.array([2, 6, 6]).astype(np.float32)
+result = np.array([6, 9, 12]).astype(np.float32)
+node = onnx.helper.make_node(
+    "Sum",
+    inputs=["data_0", "data_1", "data_2"],
+    outputs=["result"],
+)
+expect(
+    node,
+    inputs=[data_0, data_1, data_2],
+    outputs=[result],
+    name="test_sum_example",
+)
+
+node = onnx.helper.make_node(
+    "Sum",
+    inputs=["data_0"],
+    outputs=["result"],
+)
+expect(node, inputs=[data_0], outputs=[data_0], name="test_sum_one_input")
+
+result = np.add(data_0, data_1)
+node = onnx.helper.make_node(
+    "Sum",
+    inputs=["data_0", "data_1"],
+    outputs=["result"],
+)
+expect(
+    node, inputs=[data_0, data_1], outputs=[result], name="test_sum_two_inputs"
+)
+```
+
+</details>
+
+
+### <a name="Swish"></a><a name="swish">**Swish**</a>
+
+  Swish function takes one input data (Tensor<T>) and produces one output data (Tensor<T>) of the same shape,
+  where $Swish(x) = x * sigmoid(alpha * x)$.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Coefficient to multiply with input before sigmoid.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(float16), tensor(float), tensor(bfloat16), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>swish</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Swish",
+    inputs=["x"],
+    outputs=["y"],
+    alpha=1.0,  # pass alpha as attribute
+)
+
+x = np.array([3, 4, 5], dtype=np.float32)
+y = swish(x, alpha=1.0)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_swish",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+### <a name="Tan"></a><a name="tan">**Tan**</a>
+
+  Calculates the tangent of the given input tensor, element-wise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Tan-7">7</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The tangent of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>tan</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Tan",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.tan(x)
+expect(node, inputs=[x], outputs=[y], name="test_tan_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.tan(x)
+expect(node, inputs=[x], outputs=[y], name="test_tan")
+```
+
+</details>
+
+
+### <a name="Tanh"></a><a name="tanh">**Tanh**</a>
+
+  Calculates the hyperbolic tangent of the given input tensor element-wise.
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Tanh-1">1</a>, <a href="Changelog.md#Tanh-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>The hyperbolic tangent values of the input tensor computed element-wise</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>tanh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Tanh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.tanh(x)  # expected output [-0.76159418, 0., 0.76159418]
+expect(node, inputs=[x], outputs=[y], name="test_tanh_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.tanh(x)
+expect(node, inputs=[x], outputs=[y], name="test_tanh")
+```
+
+</details>
+
+
+### <a name="TensorScatter"></a><a name="tensorscatter">**TensorScatter**</a>
+
+  TensorScatter is a generic tensor update operation, motivated by the requirements for KV cache updates for Attention
+  ops commonly found in LLMs. It is a functional operation that models an in-place update to a KV cache buffer.
+
+  The past and present cache tensors have the same shape (batch_size, D1, D2, ..., max_sequence_length, ..., Dn), with
+  the sequence dimension (indicated by the `axis` attribute) being max_sequence_length, so the sizes of these tensors do
+  not need to grow between iterations. The `update` tensor's shape only differs from the cache tensors in the sequence
+  dimension: (batch_size, D1, D2, ..., sequence_length, ..., Dn), where sequence_length <= max_sequence_length.
+
+  The optional `write_indices` input indicates the write index for each sample in the batch, assumed to be zero
+  if not provided. When the `mode` attribute is set to "circular", the write index is modulo max_sequence_length.
+  The operation can be described using the following pseudocode:
+
+  ```
+  for prefix_idx in np.ndindex(past_cache.shape[:axis]):
+      batch_idx = prefix_idx[0]
+      for sequence_idx in range(sequence_length):
+          cache_idx = (*prefix_idx, write_indices[batch_idx] + sequence_idx)
+          if mode == "circular":
+              cache_idx = tuple(np.mod(np.asarray(cache_idx), max_sequence_length))
+          update_idx = (*prefix_idx, sequence_idx)
+          present_cache[cache_idx] = update[update_idx]
+  ```
+
+  During the prefill phase of attention, only the first two inputs are needed. During the decode phase, `write_indices`
+  is also needed so that the incoming key or value update can be appended after the last valid token for each sample
+  in the batch.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -2)</dt>
+<dd>Sequence dimension of the `past_cache` and `update` tensors. It cannot be 0 (the batch dimension). Default is -2.</dd>
+<dt><tt>mode</tt> : string (default is linear)</dt>
+<dd>Write mode of cache update. Supported modes include `linear` and `circular`. `linear` mode requires write_indices+sequence_length<=max_sequence_length. For `circular` mode, the updates happen in wrap-around fashion, ie, the update index is modulo `max_sequence_length`</dd>
+</dl>
+
+#### Inputs (2 - 3)
+
+<dl>
+<dt><tt>past_cache</tt> (differentiable) : T</dt>
+<dd>Past state cache for key or value with shape `(batch_size, D1, D2, ..., max_sequence_length, ..., Dn)`.</dd>
+<dt><tt>update</tt> (differentiable) : T</dt>
+<dd>New update tensor with shape `(batch_size, D1, D2, ..., sequence_length, ..., Dn)`.</dd>
+<dt><tt>write_indices</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>Write indices for the incoming update tensor in the cache. Shape is `(batch_size,)`. Assumed to be all zeros if not provided.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>present_cache</tt> (differentiable) : T</dt>
+<dd>Updated cache. Same shape as `past_cache`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0)</dt>
+<dd>Constrain input and output types to any tensor type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>tensorscatter</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TensorScatter",
+    inputs=["past_cache", "update", "write_indices"],
+    outputs=["present_cache"],
+    mode="linear",
+)
+past_cache = np.array(
+    [
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+    ],
+    dtype=np.float32,
+)
+update = np.array(
+    [
+        [[[5, 5, 5, 5, 5]]],
+        [[[1, 1, 1, 1, 1]]],
+    ],
+    dtype=np.float32,
+)
+write_indices = np.array([1, 2], dtype=np.int64)
+present_cache = np.array(
+    [
+        [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [1, 1, 1, 1, 1], [4, 3, 2, 1, 0]]],
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[past_cache, update, write_indices],
+    outputs=[present_cache],
+    name="test_tensorscatter",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tensorscatter_3d</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TensorScatter",
+    inputs=["past_cache", "update", "write_indices"],
+    outputs=["present_cache"],
+)
+past_cache = np.array(
+    [
+        [
+            [1, 2, 3, 4, 5],
+            [5, 6, 7, 8, 9],
+            [8, 7, 6, 5, 4],
+            [5, 4, 3, 2, 1],
+        ],
+        [
+            [1, 2, 3, 4, 5],
+            [5, 6, 7, 8, 9],
+            [8, 7, 6, 5, 4],
+            [5, 4, 3, 2, 1],
+        ],
+        [
+            [1, 2, 3, 4, 5],
+            [5, 6, 7, 8, 9],
+            [8, 7, 6, 5, 4],
+            [5, 4, 3, 2, 1],
+        ],
+    ],
+    dtype=np.float32,
+)
+update = np.array(
+    [
+        [
+            [4, 4, 4, 4, 4],
+            [5, 5, 5, 5, 5],
+        ],
+        [
+            [6, 6, 6, 6, 6],
+            [7, 7, 7, 7, 7],
+        ],
+        [
+            [2, 2, 2, 2, 2],
+            [3, 3, 3, 3, 3],
+        ],
+    ],
+    dtype=np.float32,
+)
+write_indices = np.array([1, 2, 0], dtype=np.int64)
+present_cache = np.array(
+    [
+        [
+            [1, 2, 3, 4, 5],
+            [4, 4, 4, 4, 4],
+            [5, 5, 5, 5, 5],
+            [5, 4, 3, 2, 1],
+        ],
+        [
+            [1, 2, 3, 4, 5],
+            [5, 6, 7, 8, 9],
+            [6, 6, 6, 6, 6],
+            [7, 7, 7, 7, 7],
+        ],
+        [
+            [2, 2, 2, 2, 2],
+            [3, 3, 3, 3, 3],
+            [8, 7, 6, 5, 4],
+            [5, 4, 3, 2, 1],
+        ],
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[past_cache, update, write_indices],
+    outputs=[present_cache],
+    name="test_tensorscatter_3d",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tensorscatter_circular</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TensorScatter",
+    inputs=["past_cache", "update", "write_indices"],
+    outputs=["present_cache"],
+    mode="circular",
+)
+past_cache = np.array(
+    [
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+    ],
+    dtype=np.float32,
+)
+update = np.array(
+    [
+        [
+            [
+                [5, 5, 5, 5, 5],
+                [6, 6, 6, 6, 6],
+            ]
+        ],
+        [
+            [
+                [1, 1, 1, 1, 1],
+                [2, 2, 2, 2, 2],
+            ]
+        ],
+    ],
+    dtype=np.float32,
+)
+write_indices = np.array([1, 3], dtype=np.int64)
+present_cache = np.array(
+    [
+        [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [6, 6, 6, 6, 6], [4, 3, 2, 1, 0]]],
+        [[[2, 2, 2, 2, 2], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [1, 1, 1, 1, 1]]],
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[past_cache, update, write_indices],
+    outputs=[present_cache],
+    name="test_tensorscatter_circular",
+)
+```
+
+</details>
+
+
+### <a name="TfIdfVectorizer"></a><a name="tfidfvectorizer">**TfIdfVectorizer**</a>
+
+  This transform extracts n-grams from the input sequence and save them as a vector. Input can
+  be either a 1-D or 2-D tensor. For 1-D input, output is the n-gram representation of that input.
+  For 2-D input, the output is also a  2-D tensor whose i-th row is the n-gram representation of the i-th input row.
+  More specifically, if input shape is [C], the corresponding output shape would be [max(ngram_indexes) + 1].
+  If input shape is [N, C], this operator produces a [N, max(ngram_indexes) + 1]-tensor.
+
+  In contrast to standard n-gram extraction, here, the indexes of extracting an n-gram from the original
+  sequence are not necessarily consecutive numbers. The discontinuity between indexes are controlled by the number of skips.
+  If the number of skips is 2, we should skip two tokens when scanning through the original sequence.
+  Let's consider an example. Assume that input sequence is [94, 17, 36, 12, 28] and the number of skips is 2.
+  The associated 2-grams are [94, 12] and [17, 28] respectively indexed by [0, 3] and [1, 4].
+  If the number of skips becomes 0, the 2-grams generated are [94, 17], [17, 36], [36, 12], [12, 28]
+  indexed by [0, 1], [1, 2], [2, 3], [3, 4], respectively.
+
+  The output vector (denoted by Y) stores the count of each n-gram;
+  Y[ngram_indexes[i]] indicates the times that the i-th n-gram is found. The attribute ngram_indexes is used to determine the mapping
+  between index i and the corresponding n-gram's output coordinate. If pool_int64s is [94, 17, 17, 36], ngram_indexes is [1, 0],
+  ngram_counts=[0, 0], then the Y[0] (first element in Y) and Y[1] (second element in Y) are the counts of [17, 36] and [94, 17],
+  respectively. An n-gram which cannot be found in pool_strings/pool_int64s should be ignored and has no effect on the output.
+  Note that we may consider all skips up to S when generating the n-grams.
+
+  The examples used above are true if mode is "TF". If mode is "IDF", all the counts larger than 1 would be truncated to 1 and
+  the i-th element in weights would be used to scale (by multiplication) the count of the i-th n-gram in pool. If mode is "TFIDF",
+  this operator first computes the counts of all n-grams and then scale them by the associated values in the weights attribute.
+
+  Only one of pool_strings and pool_int64s can be set. If pool_int64s is set, the input should be an integer tensor.
+  If pool_strings is set, the input must be a string tensor.
+
+#### Version
+
+This version of the operator has been available since version 9 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>max_gram_length</tt> : int (required)</dt>
+<dd>Maximum n-gram length. If this value is 3, 3-grams will be used to generate the output.</dd>
+<dt><tt>max_skip_count</tt> : int (required)</dt>
+<dd>Maximum number of items (integers/strings) to be skipped when constructing an n-gram from X. If max_skip_count=1, min_gram_length=2, max_gram_length=3, this operator may generate 2-grams with skip_count=0 and skip_count=1, and 3-grams with skip_count=0 and skip_count=1</dd>
+<dt><tt>min_gram_length</tt> : int (required)</dt>
+<dd>Minimum n-gram length. If this value is 2 and max_gram_length is 3, output may contain counts of 2-grams and 3-grams.</dd>
+<dt><tt>mode</tt> : string (required)</dt>
+<dd>The weighting criteria. It can be one of "TF" (term frequency), "IDF" (inverse document frequency), and "TFIDF" (the combination of TF and IDF)</dd>
+<dt><tt>ngram_counts</tt> : list of ints (required)</dt>
+<dd>The starting indexes of 1-grams, 2-grams, and so on in pool. It is useful when determining the boundary between two consecutive collections of n-grams. For example, if ngram_counts is [0, 17, 36], the first index (zero-based) of 1-gram/2-gram/3-gram in pool are 0/17/36. This format is essentially identical to CSR (or CSC) sparse matrix format, and we choose to use this due to its popularity.</dd>
+<dt><tt>ngram_indexes</tt> : list of ints (required)</dt>
+<dd>list of int64s (type: AttributeProto::INTS). This list is parallel to the specified 'pool_*' attribute. The i-th element in ngram_indexes indicate the coordinate of the i-th n-gram in the output tensor.</dd>
+<dt><tt>pool_int64s</tt> : list of ints</dt>
+<dd>List of int64 n-grams learned from the training set. Either this or pool_strings attributes must be present but not both. It's an 1-D tensor starting with the collections of all 1-grams and ending with the collections of n-grams. The i-th element in pool stores the n-gram that should be mapped to coordinate ngram_indexes[i] in the output vector.</dd>
+<dt><tt>pool_strings</tt> : list of strings</dt>
+<dd>List of strings n-grams learned from the training set. Either this or pool_int64s attributes must be present but not both. It's an 1-D tensor starting with the collections of all 1-grams and ending with the collections of n-grams. The i-th element in pool stores the n-gram that should be mapped to coordinate ngram_indexes[i] in the output vector.</dd>
+<dt><tt>weights</tt> : list of floats</dt>
+<dd>list of floats. This attribute stores the weight of each n-gram in pool. The i-th element in weights is the weight of the i-th n-gram in pool. Its length equals to the size of ngram_indexes. By default, weights is an all-one tensor.This attribute is used when mode is "IDF" or "TFIDF" to scale the associated word counts.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>Input for n-gram extraction</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T1</dt>
+<dd>Ngram results</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(string), tensor(int32), tensor(int64)</dt>
+<dd>Input is either string UTF-8 or int32/int64</dd>
+<dt><tt>T1</tt> : tensor(float)</dt>
+<dd>1-D tensor of floats</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>tf_batch_onlybigrams_skip0</summary>
+
+```python
+input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32)
+output = np.array(
+    [[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, 1.0]]
+).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=0,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_batch_onlybigrams_skip0",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tf_batch_onlybigrams_skip5</summary>
+
+```python
+input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32)
+output = np.array(
+    [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0]]
+).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=5,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_batch_onlybigrams_skip5",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tf_batch_uniandbigrams_skip5</summary>
+
+```python
+input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32)
+output = np.array(
+    [[0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0]]
+).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=1,
+    max_gram_length=2,
+    max_skip_count=5,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_batch_uniandbigrams_skip5",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tf_only_bigrams_skip0</summary>
+
+```python
+input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+output = np.array([0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0]).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=0,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_only_bigrams_skip0",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tf_onlybigrams_levelempty</summary>
+
+```python
+input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+output = np.array([1.0, 1.0, 1.0]).astype(np.float32)
+
+ngram_counts = np.array([0, 0]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2]).astype(np.int64)
+pool_int64s = np.array([5, 6, 7, 8, 6, 7]).astype(  # unigrams none
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=0,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_onlybigrams_levelempty",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tf_onlybigrams_skip5</summary>
+
+```python
+input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+output = np.array([0.0, 0.0, 0.0, 0.0, 1.0, 3.0, 1.0]).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=5,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_onlybigrams_skip5",
+)
+```
+
+</details>
+
+
+<details>
+<summary>tf_uniandbigrams_skip5</summary>
+
+```python
+input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+output = np.array([0.0, 3.0, 1.0, 0.0, 1.0, 3.0, 1.0]).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=1,
+    max_gram_length=2,
+    max_skip_count=5,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_uniandbigrams_skip5",
+)
+```
+
+</details>
+
+
+### <a name="ThresholdedRelu"></a><a name="thresholdedrelu">**ThresholdedRelu**</a>
+
+  ThresholdedRelu takes one input data (Tensor<T>) and produces one output data
+  (Tensor<T>) where the rectified linear function, y = x for x > alpha, y = 0 otherwise,
+  is applied to the tensor elementwise.
+
+#### Version
+
+This version of the operator has been available since version 22 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#ThresholdedRelu-10">10</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 1.0)</dt>
+<dd>Threshold value</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Input tensor</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>Output tensor</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>default</summary>
+
+```python
+default_alpha = 1.0
+node = onnx.helper.make_node("ThresholdedRelu", inputs=["x"], outputs=["y"])
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, default_alpha, np.inf)
+y[y == default_alpha] = 0
+
+expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu_default")
+```
+
+</details>
+
+
+<details>
+<summary>thresholdedrelu</summary>
+
+```python
+alpha = 2.0
+node = onnx.helper.make_node(
+    "ThresholdedRelu", inputs=["x"], outputs=["y"], alpha=alpha
+)
+
+x = np.array([-1.5, 0.0, 1.2, 2.0, 2.2]).astype(np.float32)
+y = np.clip(x, alpha, np.inf)  # expected output [0., 0., 0., 0., 2.2]
+y[y == alpha] = 0
+
+expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, alpha, np.inf)
+y[y == alpha] = 0
+
+expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu")
+```
+
+</details>
+
+
+### <a name="Tile"></a><a name="tile">**Tile**</a>
+
+  Constructs a tensor by tiling a given tensor.
+  This is the same as function `tile` in Numpy, but no broadcast.
+  For example A = [[1, 2], [3, 4]], B = [1, 2], tile(A, B) = [[1, 2, 1, 2], [3, 4, 3, 4]]
+
+#### Version
+
+This version of the operator has been available since version 13 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Tile-1">1</a>, <a href="Changelog.md#Tile-6">6</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of any shape.</dd>
+<dt><tt>repeats</tt> (non-differentiable) : T1</dt>
+<dd>1D int64 tensor of the same length as input's dimension number, includes numbers of repeated copies along input's dimensions.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor of the same dimensions and type as tensor input. output_dim[i] = input_dim[i] * repeats[i]</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+<dt><tt>T1</tt> : tensor(int64)</dt>
+<dd>Constrain repeat's type to int64 tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>tile</summary>
+
+```python
+node = onnx.helper.make_node("Tile", inputs=["x", "y"], outputs=["z"])
+
+x = np.random.rand(2, 3, 4, 5).astype(np.float32)
+
+repeats = np.random.randint(low=1, high=10, size=(np.ndim(x),)).astype(np.int64)
+
+z = np.tile(x, repeats)
+
+expect(node, inputs=[x, repeats], outputs=[z], name="test_tile")
+```
+
+</details>
+
+
+<details>
+<summary>tile_precomputed</summary>
+
+```python
+node = onnx.helper.make_node("Tile", inputs=["x", "y"], outputs=["z"])
+
+x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+
+repeats = np.array([2, 2], dtype=np.int64)
+
+z = np.array(
+    [[0, 1, 0, 1], [2, 3, 2, 3], [0, 1, 0, 1], [2, 3, 2, 3]], dtype=np.float32
+)
+
+expect(node, inputs=[x, repeats], outputs=[z], name="test_tile_precomputed")
+```
+
+</details>
+
+
+### <a name="TopK"></a><a name="topk">**TopK**</a>
+
+  Retrieve the top-K largest or smallest elements along a specified axis. Given an input tensor of
+  shape [a_0, a_1, ..., a_{n-1}] and integer argument k, return two outputs:
+
+  * Value tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}]
+    which contains the values of the top k elements along the specified axis
+  * Index tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] which
+    contains the indices of the top k elements (original indices from the input
+    tensor).
+
+  * If "largest" is 1 (the default value) then the k largest elements are returned.
+  * If "sorted" is 1 (the default value) then the resulting k elements will be sorted.
+  * If "sorted" is 0, order of returned 'Values' and 'Indices' are undefined.
+
+  Given two equivalent values, this operator uses the indices along the axis as
+  a tiebreaker. That is, the element with the lower index will appear first.
+
+#### Version
+
+This version of the operator has been available since version 24 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#TopK-1">1</a>, <a href="Changelog.md#TopK-10">10</a>, <a href="Changelog.md#TopK-11">11</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int (default is -1)</dt>
+<dd>Dimension on which to do the sort. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>largest</tt> : int (default is 1)</dt>
+<dd>Whether to return the top-K largest or smallest elements.</dd>
+<dt><tt>sorted</tt> : int (default is 1)</dt>
+<dd>Whether to return the elements in sorted order.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{n-1}]</dd>
+<dt><tt>K</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D tensor containing a single positive value corresponding to the number of top elements to retrieve</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Values</tt> (differentiable) : T</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing top K values from the input tensor</dd>
+<dt><tt>Indices</tt> (non-differentiable) : I</dt>
+<dd>Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] containing the corresponding input tensor indices for the top K values.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(bfloat16)</dt>
+<dd>Constrain input and output types to numeric tensors.</dd>
+<dt><tt>I</tt> : tensor(int64)</dt>
+<dd>Constrain index tensor to int64</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>top_k</summary>
+
+```python
+axis = 1
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [8, 9, 10, 11],
+    ],
+    dtype=np.float32,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[ 3.  2.  1.]
+# [ 7.  6.  5.]
+# [11. 10.  9.]]
+# print(indices_ref)
+# [[3 2 1]
+# [3 2 1]
+# [3 2 1]]
+
+expect(
+    node, inputs=[X, K], outputs=[values_ref, indices_ref], name="test_top_k"
+)
+```
+
+</details>
+
+
+<details>
+<summary>top_k_negative_axis</summary>
+
+```python
+axis = -1
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [8, 9, 10, 11],
+    ],
+    dtype=np.float32,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[ 3.  2.  1.]
+# [ 7.  6.  5.]
+# [11. 10.  9.]]
+# print(indices_ref)
+# [[3 2 1]
+# [3 2 1]
+# [3 2 1]]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_negative_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>top_k_same_values</summary>
+
+```python
+axis = 0
+largest = 0
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [0, 0, 0, 0],
+    dtype=np.int64,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# (Pdb) print(values_ref)
+# [0 0 0]
+# (Pdb) print(indices_ref)
+# [0 1 2]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_same_values",
+)
+```
+
+</details>
+
+
+<details>
+<summary>top_k_same_values_2d</summary>
+
+```python
+axis = 1
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 1, 1]],
+    dtype=np.int64,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[0 0 0]
+# [1 1 1]
+# [1 1 2]]
+# print(indices_ref)
+# [[0 1 2]
+# [0 1 2]
+# [2 3 0]]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_same_values_2d",
+)
+```
+
+</details>
+
+
+<details>
+<summary>top_k_same_values_largest</summary>
+
+```python
+axis = 0
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [0, 0, 0, 0],
+    dtype=np.int64,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [0 0 0]
+# print(indices_ref)
+# [0 1 2]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_same_values_largest",
+)
+```
+
+</details>
+
+
+<details>
+<summary>top_k_smallest</summary>
+
+```python
+axis = 1
+largest = 0
+sorted_ = 1
+k = 3
+
+node = onnx.helper.make_node(
+    "TopK",
+    inputs=["x", "k"],
+    outputs=["values", "indices"],
+    axis=axis,
+    largest=largest,
+    sorted=sorted_,
+)
+
+X = np.array(
+    [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [11, 10, 9, 8],
+    ],
+    dtype=np.float32,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[ 0.  1.  2.]
+# [ 4.  5.  6.]
+# [ 8.  9. 10.]]
+# print(indices_ref)
+# [[0 1 2]
+# [0 1 2]
+# [3 2 1]]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_smallest",
+)
+```
+
+</details>
+
+
+<details>
+<summary>top_k_uint64</summary>
+
+```python
+axis = 1
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [8, 9, 10, 11],
+    ],
+    dtype=np.uint64,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[ 3  2  1]
+# [ 7  6  5]
+# [11 10  9]]
+# print(indices_ref)
+# [[3 2 1]
+# [3 2 1]
+# [3 2 1]]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_uint64",
+)
+```
+
+</details>
+
+
+### <a name="Transpose"></a><a name="transpose">**Transpose**</a>
+
+  Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+  The optional attribute `perm` must be a permutation of the dimensions of
+  the input tensor. Axis `i` of the output tensor corresponds to the axis
+  `perm[i]` of the input tensor.
+  For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 1, 3).
+  When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+  the output shape will be (2, 3, 1).
+  If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+  where `n` is the rank of the input tensor.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Transpose-1">1</a>, <a href="Changelog.md#Transpose-13">13</a>, <a href="Changelog.md#Transpose-21">21</a>, <a href="Changelog.md#Transpose-23">23</a>, <a href="Changelog.md#Transpose-24">24</a>
+
+#### Attributes
+
+<dl>
+<dt><tt>perm</tt> : list of ints</dt>
+<dd>A list of integers. By default, reverse the dimensions, otherwise permute the axes according to the values given. Its length must be equal to the rank of the input.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>An input tensor.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>transposed</tt> (differentiable) : T</dt>
+<dd>Transposed output.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>all_permutations</summary>
+
+```python
+shape = (2, 3, 4)
+data = np.random.random_sample(shape).astype(np.float32)
+permutations = list(itertools.permutations(np.arange(len(shape))))
+
+for i, permutation in enumerate(permutations):
+    node = onnx.helper.make_node(
+        "Transpose",
+        inputs=["data"],
+        outputs=["transposed"],
+        perm=permutation,
+    )
+    transposed = np.transpose(data, permutation)
+    expect(
+        node,
+        inputs=[data],
+        outputs=[transposed],
+        name=f"test_transpose_all_permutations_{i}",
+    )
+```
+
+</details>
+
+
+<details>
+<summary>default</summary>
+
+```python
+shape = (2, 3, 4)
+data = np.random.random_sample(shape).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Transpose", inputs=["data"], outputs=["transposed"]
+)
+
+transposed = np.transpose(data)
+expect(node, inputs=[data], outputs=[transposed], name="test_transpose_default")
+```
+
+</details>
+
+
+### <a name="Trilu"></a><a name="trilu">**Trilu**</a>
+
+  Given a 2-D matrix or batches of 2-D matrices, returns the upper or lower triangular part of the tensor(s).
+  The attribute "upper" determines whether the upper or lower part is retained. If set to true,
+  the upper triangular matrix is retained. Lower triangular matrix is retained otherwise.
+  Default value for the "upper" attribute is true.
+  Trilu takes one input tensor of shape [*, N, M], where * is zero or more batch dimensions. The upper triangular part consists
+  of the elements on and above the given diagonal (k). The lower triangular part consists of elements on and below the diagonal.
+  All other elements in the matrix are set to zero.
+  If k = 0, the triangular part on and above/below the main diagonal is retained.
+  If upper is set to true, a positive k retains the upper triangular matrix excluding the main diagonal and (k-1) diagonals above it.
+  A negative k value retains the main diagonal and |k| diagonals below it.
+  If upper is set to false, a positive k retains the lower triangular matrix including the main diagonal and k diagonals above it.
+  A negative k value excludes the main diagonal and (|k|-1) diagonals below it.
+
+#### Version
+
+This version of the operator has been available since version 14 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>upper</tt> : int (default is 1)</dt>
+<dd>Boolean. Indicates whether upper or lower part of matrix is retained. Default is true.</dd>
+</dl>
+
+#### Inputs (1 - 2)
+
+<dl>
+<dt><tt>input</tt> (differentiable) : T</dt>
+<dd>Input tensor of rank 2 or higher.</dd>
+<dt><tt>k</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>A 0-D tensor containing a single value corresponding to the number diagonals above or below the main diagonal to exclude or include. Default value is 0 if it's not specified.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Output tensor of the same type and shape as the input tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>tril</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 0, 0, 0, 0],
+#   [1, 2, 0, 0, 0],
+#   [9, 4, 1, 0, 0],
+#   [4, 3, 4, 2, 0]]
+y = tril_reference_implementation(x)
+expect(node, inputs=[x], outputs=[y], name="test_tril")
+```
+
+</details>
+
+
+<details>
+<summary>tril_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(-1).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[0, 0, 0, 0, 0],
+#   [1, 0, 0, 0, 0],
+#   [9, 4, 0, 0, 0],
+#   [4, 3, 4, 0, 0]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_neg")
+```
+
+</details>
+
+
+<details>
+<summary>tril_one_row</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(3, 1, 5)).astype(np.int64)
+# X:
+# [[[6, 2, 4, 1, 6]],
+#
+#  [[8, 3, 8, 7, 0]],
+#
+#  [[2, 2, 9, 5, 9]]]
+# expect result:
+# [[[6, 0, 0, 0, 0]],
+#
+#  [[8, 0, 0, 0, 0]],
+#
+#  [[2, 0, 0, 0, 0]]]
+y = tril_reference_implementation(x)
+expect(node, inputs=[x], outputs=[y], name="test_tril_one_row_neg")
+```
+
+</details>
+
+
+<details>
+<summary>tril_out_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(-7).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_out_neg")
+```
+
+</details>
+
+
+<details>
+<summary>tril_out_pos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(6).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_out_pos")
+```
+
+</details>
+
+
+<details>
+<summary>tril_pos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(2).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 0, 0],
+#   [1, 2, 8, 6, 0],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_pos")
+```
+
+</details>
+
+
+<details>
+<summary>tril_square</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+# X:
+# [[[0, 4, 3],
+#   [2, 0, 9],
+#   [8, 2, 5]],
+#
+#  [[2, 7, 2],
+#   [2, 6, 0],
+#   [2, 6, 5]]]
+# expect result:
+# [[[0, 0, 0],
+#   [2, 0, 0],
+#   [8, 2, 5]],
+#
+#  [[2, 0, 0],
+#   [2, 6, 0],
+#   [2, 6, 5]]]
+y = tril_reference_implementation(x)
+expect(node, inputs=[x], outputs=[y], name="test_tril_square")
+```
+
+</details>
+
+
+<details>
+<summary>tril_square_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+k = np.array(-1).astype(np.int64)
+# X:
+# [[[0, 4, 3],
+#   [2, 0, 9],
+#   [8, 2, 5]],
+#
+#  [[2, 7, 2],
+#   [2, 6, 0],
+#   [2, 6, 5]]]
+# expect result:
+# [[[0, 0, 0],
+#   [2, 0, 0],
+#   [8, 2, 0]],
+#
+#  [[0, 0, 0],
+#   [2, 0, 0],
+#   [2, 6, 0]]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_square_neg")
+```
+
+</details>
+
+
+<details>
+<summary>tril_zero</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(3, 0, 5)).astype(np.int64)
+k = np.array(6).astype(np.int64)
+# X:
+# []
+# expect result:
+# []
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_zero")
+```
+
+</details>
+
+
+<details>
+<summary>triu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 7, 9],
+#   [0, 2, 8, 6, 9],
+#   [0, 0, 0, 8, 7],
+#   [0, 0, 0, 2, 4]]
+y = triu_reference_implementation(x)
+expect(node, inputs=[x], outputs=[y], name="test_triu")
+```
+
+</details>
+
+
+<details>
+<summary>triu_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(-1).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [0, 4, 0, 8, 7],
+#   [0, 0, 4, 2, 4]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_neg")
+```
+
+</details>
+
+
+<details>
+<summary>triu_one_row</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(3, 1, 5)).astype(np.int64)
+k = np.array(1).astype(np.int64)
+# X:
+# [[[1, 4, 9, 7, 1]],
+#
+#  [[9, 2, 8, 8, 4]],
+#
+#  [[3, 9, 7, 4, 2]]]
+# expect result:
+# [[[0, 4, 9, 7, 1]],
+#
+#  [[0, 2, 8, 8, 4]],
+#
+#  [[0, 9, 7, 4, 2]]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_one_row")
+```
+
+</details>
+
+
+<details>
+<summary>triu_out_neg_out</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(-7).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_out_neg_out")
+```
+
+</details>
+
+
+<details>
+<summary>triu_out_pos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(6).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_out_pos")
+```
+
+</details>
+
+
+<details>
+<summary>triu_pos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(2).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[0, 0, 3, 7, 9],
+#   [0, 0, 0, 6, 9],
+#   [0, 0, 0, 0, 7],
+#   [0, 0, 0, 0, 0]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_pos")
+```
+
+</details>
+
+
+<details>
+<summary>triu_square</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+y = triu_reference_implementation(x)
+# X:
+# [[[4, 6, 9],
+#   [7, 5, 4],
+#   [8, 1, 2]],
+#
+#  [[1, 4, 9],
+#   [9, 6, 3],
+#   [8, 9, 8]]]
+# expect result:
+# [[[4, 6, 9],
+#   [0, 5, 4],
+#   [0, 0, 2]],
+#
+#  [[1, 4, 9],
+#   [0, 6, 3],
+#   [0, 0, 8]]]
+expect(node, inputs=[x], outputs=[y], name="test_triu_square")
+```
+
+</details>
+
+
+<details>
+<summary>triu_square_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+k = np.array(-1).astype(np.int64)
+# X:
+# [[[4, 6, 9],
+#   [7, 5, 4],
+#   [8, 1, 2]],
+#
+#  [[1, 4, 9],
+#   [9, 6, 3],
+#   [8, 9, 8]]]
+# expect result:
+# [[[4, 6, 9],
+#   [7, 5, 4],
+#   [0, 1, 2]],
+#
+#  [[1, 4, 9],
+#   [9, 6, 3],
+#   [0, 9, 8]]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_square_neg")
+```
+
+</details>
+
+
+<details>
+<summary>triu_zero</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(0, 5)).astype(np.int64)
+k = np.array(6).astype(np.int64)
+# X:
+# []
+# expect result:
+# []
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_zero")
+```
+
+</details>
+
+
+### <a name="Unique"></a><a name="unique">**Unique**</a>
+
+  Find the unique elements of a tensor. When an optional attribute 'axis' is provided, unique subtensors sliced along the 'axis' are returned.
+  Otherwise the input tensor is flattened and unique values of the flattened tensor are returned.
+
+  This operator returns the unique values or sliced unique subtensors of the input tensor and three optional outputs.
+  The first output tensor 'Y' contains all unique values or subtensors of the input.
+  The second optional output tensor 'indices' contains indices of 'Y' elements' first occurrence in 'X'.
+  The third optional output tensor 'inverse_indices' contains, for elements of 'X', its corresponding indices in 'Y'.
+  The fourth optional output tensor 'counts' contains the count of each element of 'Y' in the input.
+
+  Outputs are either sorted in ascending order or optionally in the order of the first occurrence of the values in the input.
+
+  https://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
+
+  Example 1:
+  ```
+  input_X = [2, 1, 1, 3, 4, 3]
+  attribute_sorted = 0
+  attribute_axis = None
+  output_Y = [2, 1, 3, 4]
+  output_indices = [0, 1, 3, 4]
+  output_inverse_indices = [0, 1, 1, 2, 3, 2]
+  output_counts = [1, 2, 2, 1]
+  ```
+
+  Example 2:
+  ```
+  input_X = [[1, 3], [2, 3]]
+  attribute_sorted = 1
+  attribute_axis = None
+  output_Y = [1, 2, 3]
+  output_indices = [0, 2, 1]
+  output_inverse_indices = [0, 2, 1, 2]
+  output_counts = [1, 1, 2]
+  ```
+
+  Example 3:
+  ```
+  input_X = [[1, 0, 0], [1, 0, 0], [2, 3, 4]]
+  attribute_sorted = 1
+  attribute_axis = 0
+  output_Y = [[1, 0, 0], [2, 3, 4]]
+  output_indices = [0, 2]
+  output_inverse_indices = [0, 0, 1]
+  output_counts = [2, 1]
+  ```
+
+  Example 4:
+  ```
+  input_x = [[[1., 1.], [0., 1.], [2., 1.], [0., 1.]],
+              [[1., 1.], [0., 1.], [2., 1.], [0., 1.]]]
+  attribute_sorted = 1
+  attribute_axis = 1
+  ```
+
+  intermediate data are presented below for better understanding:
+  there are 4 subtensors sliced along axis 1 of input_x (shape = (2, 4, 2)):
+  ```
+  A: [[1, 1], [1, 1]],
+     [[0, 1], [0, 1]],
+     [[2, 1], [2, 1]],
+     [[0, 1], [0, 1]].
+  ```
+
+  there are 3 unique subtensors:
+  ```
+  [[1, 1], [1, 1]],
+  [[0, 1], [0, 1]],
+  [[2, 1], [2, 1]].
+  ```
+
+  sorted unique subtensors:
+  ```
+  B: [[0, 1], [0, 1]],
+     [[1, 1], [1, 1]],
+     [[2, 1], [2, 1]].
+  ```
+
+  output_Y is constructed from B:
+  ```
+  [[[0. 1.], [1. 1.], [2. 1.]],
+   [[0. 1.], [1. 1.], [2. 1.]]]
+  ```
+
+  output_indices is to map from B to A:
+  ```
+  [1, 0, 2]
+  ```
+
+  output_inverse_indices is to map from A to B:
+  ```
+  [1, 0, 2, 0]
+  ```
+
+  output_counts:
+  ```
+  [2, 1, 1]
+  ```
+
+#### Version
+
+This version of the operator has been available since version 11 of the default ONNX operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>axis</tt> : int</dt>
+<dd>(Optional) The dimension to apply unique. If not specified, the unique elements of the flattened input are returned. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).</dd>
+<dt><tt>sorted</tt> : int (default is 1)</dt>
+<dd>(Optional) Whether to sort the unique elements in ascending order before returning as output. Must be one of 0, or 1 (default).</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>X</tt> (non-differentiable) : T</dt>
+<dd>A N-D input tensor that is to be processed.</dd>
+</dl>
+
+#### Outputs (1 - 4)
+
+<dl>
+<dt><tt>Y</tt> (non-differentiable) : T</dt>
+<dd>A tensor of the same type as 'X' containing all the unique values or subtensors sliced along a provided 'axis' in 'X', either sorted or maintained in the same order they occur in input 'X'</dd>
+<dt><tt>indices</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D INT64 tensor containing indices of 'Y' elements' first occurrence in 'X'. When 'axis' is provided, it contains indices to subtensors in input 'X' on the 'axis'. When 'axis' is not provided, it contains indices to values in the flattened input tensor. </dd>
+<dt><tt>inverse_indices</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D INT64 tensor containing, for elements of 'X', its corresponding indices in 'Y'. When 'axis' is provided, it contains indices to subtensors in output 'Y' on the 'axis'. When 'axis' is not provided, it contains indices to values in output 'Y'. </dd>
+<dt><tt>counts</tt> (optional, non-differentiable) : tensor(int64)</dt>
+<dd>A 1-D INT64 tensor containing the count of each element of 'Y' in input 'X'</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Input can be of any tensor type.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>length_1</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=1,
+)
+
+x = np.array([0], dtype=np.int64)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# behavior changed with numpy >= 2.0
+inverse_indices = inverse_indices.reshape(-1)
+# print(y)
+# [0]
+# print(indices)
+# [0]
+# print(inverse_indices)
+# [0]
+# print(counts)
+# [1]
+
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_length_1",
+)
+```
+
+</details>
+
+
+<details>
+<summary>not_sorted_without_axis</summary>
+
+```python
+node_not_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=0,
+)
+# numpy unique does not retain original order (it sorts the output unique values)
+# https://github.com/numpy/numpy/issues/8621
+# we need to recover unsorted output and indices
+x = np.array([2.0, 1.0, 1.0, 3.0, 4.0, 3.0], dtype=np.float32)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+
+# prepare index mapping from sorted to unsorted
+argsorted_indices = np.argsort(indices)
+inverse_indices_map = dict(
+    zip(argsorted_indices, np.arange(len(argsorted_indices)), strict=True)
+)
+
+indices = indices[argsorted_indices]
+y = np.take(x, indices, axis=0)
+inverse_indices = np.asarray(
+    [inverse_indices_map[i] for i in inverse_indices], dtype=np.int64
+)
+counts = counts[argsorted_indices]
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# print(y)
+# [2.0, 1.0, 3.0, 4.0]
+# print(indices)
+# [0 1 3 4]
+# print(inverse_indices)
+# [0, 1, 1, 2, 3, 2]
+# print(counts)
+# [1, 2, 2, 1]
+
+expect(
+    node_not_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_not_sorted_without_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>sorted_with_axis</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=1,
+    axis=0,
+)
+
+x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]], dtype=np.float32)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=0)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# behavior changed with numpy >= 2.0
+inverse_indices = inverse_indices.reshape(-1)
+# print(y)
+# [[1. 0. 0.]
+#  [2. 3. 4.]]
+# print(indices)
+# [0 2]
+# print(inverse_indices)
+# [0 0 1]
+# print(counts)
+# [2 1]
+
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_sorted_with_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>sorted_with_axis_3d</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=1,
+    axis=1,
+)
+
+x = np.array(
+    [
+        [[1.0, 1.0], [0.0, 1.0], [2.0, 1.0], [0.0, 1.0]],
+        [[1.0, 1.0], [0.0, 1.0], [2.0, 1.0], [0.0, 1.0]],
+    ],
+    dtype=np.float32,
+)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=1)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# behavior changed with numpy >= 2.0
+inverse_indices = inverse_indices.reshape(-1)
+# print(y)
+# [[[0. 1.]
+#  [1. 1.]
+#  [2. 1.]]
+# [[0. 1.]
+#  [1. 1.]
+#  [2. 1.]]]
+# print(indices)
+# [1 0 2]
+# print(inverse_indices)
+# [1 0 2 0]
+# print(counts)
+# [2 1 1]
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_sorted_with_axis_3d",
+)
+```
+
+</details>
+
+
+<details>
+<summary>sorted_with_negative_axis</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=1,
+    axis=-1,
+)
+
+x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 3]], dtype=np.float32)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=-1)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# behavior changed with numpy >= 2.0
+inverse_indices = inverse_indices.reshape(-1)
+# print(y)
+# [[0. 1.]
+#  [0. 1.]
+#  [3. 2.]]
+# print(indices)
+# [1 0]
+# print(inverse_indices)
+# [1 0 0]
+# print(counts)
+# [2 1]
+
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_sorted_with_negative_axis",
+)
+```
+
+</details>
+
+
+<details>
+<summary>sorted_without_axis</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+)
+
+x = np.array([2.0, 1.0, 1.0, 3.0, 4.0, 3.0], dtype=np.float32)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_sorted_without_axis",
+)
+```
+
+</details>
+
+
+### <a name="Unsqueeze"></a><a name="unsqueeze">**Unsqueeze**</a>
+
+  Insert single-dimensional entries to the shape of an input tensor (`data`).
+  Takes one required input `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).
+
+  For example, given an input tensor (`data`) of shape [3, 4, 5], then
+  Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].
+
+  The input `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
+  The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
+  Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
+  The order of values in `axes` does not matter and can come in any order.
+
+#### Version
+
+This version of the operator has been available since version 25 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Unsqueeze-1">1</a>, <a href="Changelog.md#Unsqueeze-11">11</a>, <a href="Changelog.md#Unsqueeze-13">13</a>, <a href="Changelog.md#Unsqueeze-21">21</a>, <a href="Changelog.md#Unsqueeze-23">23</a>, <a href="Changelog.md#Unsqueeze-24">24</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>data</tt> (differentiable) : T</dt>
+<dd>Original tensor</dd>
+<dt><tt>axes</tt> (non-differentiable) : tensor(int64)</dt>
+<dd>1D tensor of integers indicating the dimensions to be inserted. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(expanded).</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>expanded</tt> (differentiable) : T</dt>
+<dd>Reshaped tensor with same data as input.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128), tensor(float8e4m3fn), tensor(float8e4m3fnuz), tensor(float8e5m2), tensor(float8e5m2fnuz), tensor(uint4), tensor(int4), tensor(float4e2m1), tensor(float8e8m0), tensor(uint2), tensor(int2)</dt>
+<dd>Constrain input and output types to all tensor types up to IRv13.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>unsqueeze_negative_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Unsqueeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 1, 5).astype(np.float32)
+axes = np.array([-2]).astype(np.int64)
+y = np.expand_dims(x, axis=-2)
+expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_negative_axes")
+```
+
+</details>
+
+
+<details>
+<summary>unsqueeze_one_axis</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+
+for i in range(x.ndim):
+    axes = np.array([i]).astype(np.int64)
+    node = onnx.helper.make_node(
+        "Unsqueeze",
+        inputs=["x", "axes"],
+        outputs=["y"],
+    )
+    y = np.expand_dims(x, axis=i)
+
+    expect(
+        node,
+        inputs=[x, axes],
+        outputs=[y],
+        name="test_unsqueeze_axis_" + str(i),
+    )
+```
+
+</details>
+
+
+<details>
+<summary>unsqueeze_three_axes</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+axes = np.array([2, 4, 5]).astype(np.int64)
+
+node = onnx.helper.make_node(
+    "Unsqueeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+y = np.expand_dims(x, axis=2)
+y = np.expand_dims(y, axis=4)
+y = np.expand_dims(y, axis=5)
+
+expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_three_axes")
+```
+
+</details>
+
+
+<details>
+<summary>unsqueeze_two_axes</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+axes = np.array([1, 4]).astype(np.int64)
+
+node = onnx.helper.make_node(
+    "Unsqueeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+y = np.expand_dims(x, axis=1)
+y = np.expand_dims(y, axis=4)
+
+expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_two_axes")
+```
+
+</details>
+
+
+<details>
+<summary>unsqueeze_unsorted_axes</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+axes = np.array([5, 4, 2]).astype(np.int64)
+
+node = onnx.helper.make_node(
+    "Unsqueeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+y = np.expand_dims(x, axis=2)
+y = np.expand_dims(y, axis=4)
+y = np.expand_dims(y, axis=5)
+
+expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_unsorted_axes")
+```
+
+</details>
+
+
+### <a name="Upsample"></a><a name="upsample">**Upsample** (deprecated)</a>
+
+  Upsample the input tensor.
+  Each dimension value of the output tensor is:
+    output_dimension = floor(input_dimension * scale).
+
+#### Version
+
+This version of the operator has been deprecated since version 10 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Upsample-7">7</a>, <a href="Changelog.md#Upsample-9">9</a>
+
+
+#### Examples
+
+<details>
+<summary>nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Upsample",
+    inputs=["X", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
+
+output = np.array(
+    [
+        [
+            [
+                [1, 1, 1, 2, 2, 2],
+                [1, 1, 1, 2, 2, 2],
+                [3, 3, 3, 4, 4, 4],
+                [3, 3, 3, 4, 4, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_upsample_nearest",
+    opset_imports=[helper.make_opsetid("", 9)],
+)
+```
+
+</details>
+
+
+### <a name="Where"></a><a name="where">**Where**</a>
+
+  Return elements, either from X or Y, depending on condition.
+  Where behaves like
+  [numpy.where](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html)
+  with three parameters.
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 16 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Where-9">9</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>condition</tt> (non-differentiable) : B</dt>
+<dd>When True (nonzero), yield X, otherwise yield Y</dd>
+<dt><tt>X</tt> (differentiable) : T</dt>
+<dd>values selected at indices where condition is True</dd>
+<dt><tt>Y</tt> (differentiable) : T</dt>
+<dd>values selected at indices where condition is False</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>output</tt> (differentiable) : T</dt>
+<dd>Tensor of shape equal to the broadcasted shape of condition, X, and Y.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>B</tt> : tensor(bool)</dt>
+<dd>Constrain to boolean tensors.</dd>
+<dt><tt>T</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(bfloat16), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Constrain input and output types to all tensor types (including bfloat).</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>long</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Where",
+    inputs=["condition", "x", "y"],
+    outputs=["z"],
+)
+
+condition = np.array([[1, 0], [1, 1]], dtype=bool)
+x = np.array([[1, 2], [3, 4]], dtype=np.int64)
+y = np.array([[9, 8], [7, 6]], dtype=np.int64)
+z = np.where(condition, x, y)  # expected output [[1, 8], [3, 4]]
+expect(
+    node, inputs=[condition, x, y], outputs=[z], name="test_where_long_example"
+)
+```
+
+</details>
+
+
+<details>
+<summary>where</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Where",
+    inputs=["condition", "x", "y"],
+    outputs=["z"],
+)
+
+condition = np.array([[1, 0], [1, 1]], dtype=bool)
+x = np.array([[1, 2], [3, 4]], dtype=np.float32)
+y = np.array([[9, 8], [7, 6]], dtype=np.float32)
+z = np.where(condition, x, y)  # expected output [[1, 8], [3, 4]]
+expect(node, inputs=[condition, x, y], outputs=[z], name="test_where_example")
+```
+
+</details>
+
+
+### <a name="Xor"></a><a name="xor">**Xor**</a>
+
+  Returns the tensor resulted from performing the `xor` logical operation
+  elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+
+#### Version
+
+This version of the operator has been available since version 7 of the default ONNX operator set.
+
+Other versions of this operator: <a href="Changelog.md#Xor-1">1</a>
+
+#### Inputs
+
+<dl>
+<dt><tt>A</tt> (non-differentiable) : T</dt>
+<dd>First input operand for the logical operator.</dd>
+<dt><tt>B</tt> (non-differentiable) : T</dt>
+<dd>Second input operand for the logical operator.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>C</tt> (non-differentiable) : T1</dt>
+<dd>Result tensor.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T</tt> : tensor(bool)</dt>
+<dd>Constrain input to boolean tensor.</dd>
+<dt><tt>T1</tt> : tensor(bool)</dt>
+<dd>Constrain output to boolean tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>xor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Xor",
+    inputs=["x", "y"],
+    outputs=["xor"],
+)
+
+# 2d
+x = (np.random.randn(3, 4) > 0).astype(bool)
+y = (np.random.randn(3, 4) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor2d")
+
+# 3d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor3d")
+
+# 4d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor4d")
+```
+
+</details>
+
+
+<details>
+<summary>xor_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Xor",
+    inputs=["x", "y"],
+    outputs=["xor"],
+)
+
+# 3d vs 1d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(5) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast3v1d")
+
+# 3d vs 2d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(4, 5) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast3v2d")
+
+# 4d vs 2d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(5, 6) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v2d")
+
+# 4d vs 3d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(4, 5, 6) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v3d")
+
+# 4d vs 4d
+x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool)
+y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v4d")
+```
+
+</details>
+
+
+## ai.onnx.preview
+### <sub>experimental</sub> <a name="ai.onnx.preview.FlexAttention"></a><a name="ai.onnx.preview.flexattention">**ai.onnx.preview.FlexAttention**</a>
+
+  Computes scaled dot-product attention over rank-4 (batched, multi-head) inputs,
+  with optional user-provided customization subgraphs at two stages:
+
+  1. score_mod: Modify the attention score tensor after Q·K^T
+  2. prob_mod: Modify the probability tensor after Softmax
+
+  This operator mirrors the capabilities of PyTorch's flex_attention:
+  https://docs.pytorch.org/docs/stable/nn.attention.flex_attention.html
+
+  Input Shapes (MUST be rank-4 tensors):
+  - Q: `(batch_size, q_num_heads, q_sequence_length, head_size)`
+  - K: `(batch_size, kv_num_heads, kv_sequence_length, head_size)`
+  - V: `(batch_size, kv_num_heads, kv_sequence_length, v_head_size)`
+
+  Output Shape:
+  - Y: `(batch_size, q_num_heads, q_sequence_length, v_head_size)`
+
+  FlexAttention Computation:
+  ```
+  Scores = (Q @ K^T) * scale
+  Scores = score_mod(Scores)             # if 'score_mod' is provided
+  Probs = Softmax(Scores, axis=-1)
+  Probs = prob_mod(Probs)                # if 'prob_mod' is provided
+  Y = Probs @ V
+  ```
+
+  Grouped Query Attention (GQA):
+  When `q_num_heads != kv_num_heads`, each K/V head is shared by a contiguous
+  group of query heads in head-index order. Let
+  `group_size = q_num_heads / kv_num_heads`; then query head `h` uses K/V head
+  `floor(h / group_size)`. `q_num_heads` must be a multiple of
+  `kv_num_heads`.
+
+  Modifier Subgraphs (score_mod, prob_mod):
+  Each modifier subgraph takes exactly one rank-4 tensor input and must produce
+  exactly one rank-4 tensor output of the same shape and element type.
+  - score_mod input/output shape: `(batch_size, q_num_heads, q_sequence_length, kv_sequence_length)`
+  - prob_mod  input/output shape: `(batch_size, q_num_heads, q_sequence_length, kv_sequence_length)`
+  The element type is determined by softmax_precision (defaults to float32 for
+  non-double inputs, otherwise double).
+
+  Masking can be expressed in score_mod by writing masked positions as -inf (or a
+  large negative value appropriate for the target precision).
+
+#### Version
+
+No versioning maintained for experimental ops.
+#### Attributes
+
+<dl>
+<dt><tt>prob_mod</tt> : graph</dt>
+<dd>Optional probability modifier subgraph with 1 rank-4 tensor input and 1 rank-4 tensor output of the same shape and element type: (probs) -> probs_out. probs has softmax_precision element type and shape (B, Hq, L, S). The output must preserve the input shape.</dd>
+<dt><tt>scale</tt> : float</dt>
+<dd>Scaling factor for Q*K^T. Defaults to 1/sqrt(head_size).</dd>
+<dt><tt>score_mod</tt> : graph</dt>
+<dd>Optional score modifier subgraph with 1 rank-4 tensor input and 1 rank-4 tensor output of the same shape and element type: (scores) -> scores_out. scores has softmax_precision element type and shape (B, Hq, L, S). The output must preserve the input shape.</dd>
+<dt><tt>softmax_precision</tt> : int</dt>
+<dd>Floating-point precision for softmax computation. Defaults to float32 for non-double inputs, otherwise uses double. Must be explicitly specified for non-float types.</dd>
+</dl>
+
+#### Inputs
+
+<dl>
+<dt><tt>Q</tt> : T1</dt>
+<dd>Query tensor with shape `(batch_size, q_num_heads, q_seq_len, head_size)`.</dd>
+<dt><tt>K</tt> : T1</dt>
+<dd>Key tensor with shape `(batch_size, kv_num_heads, kv_seq_len, head_size)`.</dd>
+<dt><tt>V</tt> : T1</dt>
+<dd>Value tensor with shape `(batch_size, kv_num_heads, kv_seq_len, v_head_size)`.</dd>
+</dl>
+
+#### Outputs
+
+<dl>
+<dt><tt>Y</tt> : T1</dt>
+<dd>Output tensor with shape `(batch_size, q_num_heads, q_seq_len, v_head_size)`.</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(bfloat16), tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Constrain Q, K, V to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>flexattention</summary>
+
+```python
+"""Basic FlexAttention test with default settings."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_causal_mask</summary>
+
+```python
+"""FlexAttention with causal masking score_mod (Qwen-3, Gemma-3, Llama-3 pattern)."""
+score_mod_graph = _make_score_mod_causal_mask_graph(TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+node.attribute.append(score_mod_attr)
+
+B, Hq, L, E = 1, 2, 4, 8
+S, Ev = 4, 8
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+# Manually compute expected output with causal masking
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+# Apply causal mask: set future positions to -inf
+q_idx = np.arange(L).reshape(1, 1, L, 1)
+k_idx = np.arange(S).reshape(1, 1, 1, S)
+mask = q_idx >= k_idx
+scores = np.where(mask, scores, -np.inf)
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_causal_mask",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_diff_head_sizes</summary>
+
+```python
+"""FlexAttention with different head sizes for Q/K vs V."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 32  # V has different head size
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_diff_head_sizes",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_double</summary>
+
+```python
+"""FlexAttention with double precision inputs."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float64)
+K = np.random.rand(B, Hq, S, E).astype(np.float64)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float64)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_double",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_fp16</summary>
+
+```python
+"""FlexAttention with float16 inputs."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float16)
+K = np.random.rand(B, Hq, S, E).astype(np.float16)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float16)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_fp16",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_gqa</summary>
+
+```python
+"""FlexAttention with Grouped Query Attention (GQA)."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, Hkv, L, S, E, Ev = 2, 8, 2, 4, 6, 16, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hkv, S, E).astype(np.float32)
+V = np.random.rand(B, Hkv, S, Ev).astype(np.float32)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_gqa",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_prob_mod</summary>
+
+```python
+"""FlexAttention with prob_mod subgraph (scales probabilities)."""
+scale_value = 0.5
+prob_mod_graph = _make_prob_mod_scale_graph(scale_value, TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+prob_mod_attr = helper.make_attribute("prob_mod", prob_mod_graph)
+node.attribute.append(prob_mod_attr)
+
+B, Hq, L, E = 1, 2, 3, 4
+S, Ev = 3, 4
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+probs = probs * scale_value
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_prob_mod",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_relative_positional</summary>
+
+```python
+"""FlexAttention with relative positional bias score_mod."""
+score_mod_graph = _make_score_mod_relative_positional_graph(TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+node.attribute.append(score_mod_attr)
+
+B, Hq, L, E = 1, 2, 4, 8
+S, Ev = 4, 8
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+# Manually compute expected output with relative positional bias
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+q_idx = np.arange(L).reshape(-1, 1)
+k_idx = np.arange(S).reshape(1, -1)
+rel_pos = (q_idx - k_idx).astype(np.float32)
+scores = scores + rel_pos
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_relative_positional",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_scaled</summary>
+
+```python
+"""FlexAttention with explicit scale attribute."""
+scale = 0.1
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+(Y,) = _compute_flex_attention(Q, K, V, scale=scale)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_scaled",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_score_mod</summary>
+
+```python
+"""FlexAttention with score_mod subgraph (adds bias to scores)."""
+bias_value = 0.5
+score_mod_graph = _make_score_mod_bias_graph(bias_value, TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+# Add score_mod as a graph attribute
+score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+node.attribute.append(score_mod_attr)
+
+B, Hq, L, E = 1, 2, 3, 4
+S, Ev = 3, 4
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+scores = scores + bias_value  # score_mod: add bias
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_score_mod",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>flexattention_soft_cap</summary>
+
+```python
+"""FlexAttention with soft capping score_mod (Gemma-2 pattern)."""
+cap_value = 20.0
+score_mod_graph = _make_score_mod_soft_cap_graph(cap_value, TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+node.attribute.append(score_mod_attr)
+
+B, Hq, L, E = 1, 2, 4, 8
+S, Ev = 4, 8
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+# Manually compute expected output with soft capping
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+scores = np.tanh(scores / cap_value) * cap_value
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_soft_cap",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+## ai.onnx.preview.training
+### <a name="ai.onnx.preview.training.Adagrad"></a><a name="ai.onnx.preview.training.adagrad">**ai.onnx.preview.training.Adagrad**</a>
+
+  Compute one iteration of ADAGRAD, a stochastic gradient based optimization
+      algorithm. This operator can conduct the optimization of multiple tensor variables.
+
+      Let's define the behavior of this operator. As you can imagine, ADAGRAD requires
+      some parameters:
+
+       - The initial learning-rate "R".
+       - The update count "T". That is, the number of training iterations conducted.
+       - A L2-norm regularization coefficient "norm_coefficient".
+       - A learning-rate decay factor "decay_factor".
+       - A small constant "epsilon" to avoid dividing-by-zero.
+
+      At each ADAGRAD iteration, the optimized tensors are moved along a direction
+      computed based on their estimated gradient and accumulated squared gradient. Assume
+      that only a single tensor "X" is updated by this operator. We need the value of "X",
+      its gradient "G", and its accumulated squared gradient "H". Therefore, variables in
+      this operator's input list are sequentially "R", "T", "X", "G", and "H". Other
+      parameters are given as attributes because they are usually constants. Also, the
+      corresponding output tensors are the new value of "X" (called "X_new"), and then
+      the new accumulated squared gradient (called "H_new"). Those outputs are computed
+      from the given inputs following the pseudo code below.
+
+      Let "+", "-", "*", and "/" are all element-wise arithmetic operations with
+      numpy-style broadcasting support. The pseudo code to compute those outputs is:
+
+        // Compute a scalar learning-rate factor. At the first update of X, T is generally
+        // 0 (0-based update index) or 1 (1-based update index).
+        r = R / (1 + T * decay_factor);
+
+        // Add gradient of 0.5 * norm_coefficient * ||X||_2^2, where ||X||_2 is the 2-norm.
+        G_regularized = norm_coefficient * X + G;
+
+        // Compute new accumulated squared gradient.
+        H_new = H + G_regularized * G_regularized;
+
+        // Compute the adaptive part of per-coordinate learning rate. Note that Sqrt(...)
+        // computes element-wise square-root.
+        H_adaptive = Sqrt(H_new) + epsilon
+
+        // Compute the new value of "X".
+        X_new = X - r * G_regularized / H_adaptive;
+
+      If one assign this operators to optimize multiple inputs, for example, "X_1" and "X_2", the same
+      pseudo code may be extended to handle all tensors jointly. More specifically, we can view "X" as a
+      concatenation of "X_1" and "X_2" (of course, their gradient and accumulate gradient should
+      be concatenated too) and then just reuse the entire pseudo code.
+
+      Note that ADAGRAD was first proposed in http://jmlr.org/papers/volume12/duchi11a/duchi11a.pdf.
+      In that reference paper, this operator is a special case of the Figure 1's composite mirror
+      descent update.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.preview.training' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>decay_factor</tt> : float (default is 0.0)</dt>
+<dd>The decay factor of learning rate after one update.The effective learning rate is computed by r = R / (1 + T * decay_factor). Default to 0 so that increasing update counts doesn't reduce the learning rate.</dd>
+<dt><tt>epsilon</tt> : float (default is 0.0)</dt>
+<dd>Small scalar to avoid dividing by zero.</dd>
+<dt><tt>norm_coefficient</tt> : float (default is 0.0)</dt>
+<dd>Regularization coefficient in 0.5 * norm_coefficient * ||X||_2^2. Default to 0, which means no regularization.</dd>
+</dl>
+
+#### Inputs (3 - &#8734;)
+
+<dl>
+<dt><tt>R</tt> : T1</dt>
+<dd>The initial learning rate.</dd>
+<dt><tt>T</tt> : T2</dt>
+<dd>The update count of "X". It should be a scalar.</dd>
+<dt><tt>inputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>The current values of optimized tensors, followed by their respective gradients, followed by their respective accumulated squared gradients.For example, if two tensor "X_1" and "X_2" are optimized, The input list would be ["X_1", "X_2", gradient of "X_1", gradient of "X_2", accumulated squared gradient of "X_1", accumulated squared gradient of "X_2"].</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>Updated values of optimized tensors, followed by their updated values of accumulated squared gradients. For example, if two tensor "X_1" and "X_2" are optimized, the output list would be [new value of "X_1," new value of "X_2" new accumulated squared gradient of "X_1", new accumulated squared gradient of "X_2"].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float scalars.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain input types to 64-bit integer scalars.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>adagrad</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+epsilon = 1e-5
+decay_factor = 0.1
+
+# Create operator.
+node = onnx.helper.make_node(
+    "Adagrad",
+    inputs=["R", "T", "X", "G", "H"],
+    outputs=["X_new", "H_new"],
+    norm_coefficient=norm_coefficient,
+    epsilon=epsilon,
+    decay_factor=decay_factor,
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+x = np.array([1.0], dtype=np.float32)
+g = np.array([-1.0], dtype=np.float32)
+h = np.array([2.0], dtype=np.float32)
+
+# Compute expected outputs of Adagrad.
+x_new, h_new = apply_adagrad(
+    r, t, x, g, h, norm_coefficient, epsilon, decay_factor
+)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x, g, h],
+    outputs=[x_new, h_new],
+    name="test_adagrad",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>adagrad_multiple</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+epsilon = 1e-5
+decay_factor = 0.1
+
+node = onnx.helper.make_node(
+    "Adagrad",
+    inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"],
+    outputs=["X1_new", "X2_new", "H1_new", "H2_new"],
+    norm_coefficient=norm_coefficient,
+    epsilon=epsilon,
+    decay_factor=decay_factor,
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+
+x1 = np.array([1.0], dtype=np.float32)
+g1 = np.array([-1.0], dtype=np.float32)
+h1 = np.array([2.0], dtype=np.float32)
+
+x2 = np.array([1.0, 2.0], dtype=np.float32)
+g2 = np.array([-1.0, -3.0], dtype=np.float32)
+h2 = np.array([4.0, 1.0], dtype=np.float32)
+
+# Compute expected outputs of Adagrad.
+x1_new, h1_new = apply_adagrad(
+    r, t, x1, g1, h1, norm_coefficient, epsilon, decay_factor
+)
+x2_new, h2_new = apply_adagrad(
+    r, t, x2, g2, h2, norm_coefficient, epsilon, decay_factor
+)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x1, x2, g1, g2, h1, h2],
+    outputs=[x1_new, x2_new, h1_new, h2_new],
+    name="test_adagrad_multiple",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
+### <a name="ai.onnx.preview.training.Adam"></a><a name="ai.onnx.preview.training.adam">**ai.onnx.preview.training.Adam**</a>
+
+  Compute one iteration of Adam, a stochastic gradient based optimization
+      algorithm. This operator can conduct the optimization of multiple tensor variables.
+
+      Let's define the behavior of this operator. First of all, Adam requires
+      some parameters:
+
+       - The learning-rate "R".
+       - The update count "T". That is, the number of training iterations conducted.
+       - A L2-norm regularization coefficient "norm_coefficient".
+       - A small constant "epsilon" to avoid dividing-by-zero.
+       - Two coefficients, "alpha" and "beta".
+
+      At each Adam iteration, the optimized tensors are moved along a direction
+      computed based on their exponentially-averaged historical gradient and
+      exponentially-averaged historical squared gradient. Assume that only a tensor
+      "X" is being optimized. The rest of required information is
+
+       - the value of "X",
+       - "X"'s gradient (denoted by "G"),
+       - "X"'s exponentially-averaged historical gradient (denoted by "V"), and
+       - "X"'s exponentially-averaged historical squared gradient (denoted by "H").
+
+      Some of those parameters are passed into this operator as input tensors and others
+      are stored as this operator's attributes. Specifically, this operator's input tensor
+      list is ["R", "T", "X", "G", "V", "H"]. That is, "R" is the first input, "T" is
+      the second input, and so on. Other parameters are given as attributes because they
+      are constants. Moreover, the corresponding output tensors are
+
+       - the new value of "X" (called "X_new"),
+       - the new exponentially-averaged historical gradient (denoted by "V_new"), and
+       - the new exponentially-averaged historical squared gradient (denoted by "H_new").
+
+      Those outputs are computed following the pseudo code below.
+
+      Let "+", "-", "*", and "/" are all element-wise arithmetic operations with
+      numpy-style broadcasting support. The pseudo code to compute those outputs is:
+
+        // Add gradient of 0.5 * norm_coefficient * ||X||_2^2, where ||X||_2 is the 2-norm.
+        G_regularized = norm_coefficient * X + G
+
+        // Update exponentially-averaged historical gradient.
+        V_new = alpha * V + (1 - alpha) * G_regularized
+
+        // Update exponentially-averaged historical squared gradient.
+        H_new = beta * H + (1 - beta) * G_regularized * G_regularized
+
+        // Compute the element-wise square-root of H_new. V_new will be element-wisely
+        // divided by H_sqrt for a better update direction.
+        H_sqrt = Sqrt(H_new) + epsilon
+
+        // Compute learning-rate. Note that "alpha**T"/"beta**T" is alpha's/beta's T-th power.
+        R_adjusted = T > 0 ? R * Sqrt(1 - beta**T) / (1 - alpha**T) : R
+
+        // Compute new value of "X".
+        X_new = X - R_adjusted * V_new / H_sqrt
+
+        // Post-update regularization.
+        X_final = (1 - norm_coefficient_post) * X_new
+
+      If there are multiple inputs to be optimized, the pseudo code will be applied
+      independently to each of them.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.preview.training' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (default is 0.9)</dt>
+<dd>Coefficient of previously accumulated gradient in running average. Default to 0.9.</dd>
+<dt><tt>beta</tt> : float (default is 0.999)</dt>
+<dd>Coefficient of previously accumulated squared-gradient in running average. Default to 0.999.</dd>
+<dt><tt>epsilon</tt> : float (default is 0.0)</dt>
+<dd>Small scalar to avoid dividing by zero.</dd>
+<dt><tt>norm_coefficient</tt> : float (default is 0.0)</dt>
+<dd>Regularization coefficient of 0.5 * norm_coefficient * ||X||_2^2. Default to 0, which means no regularization.</dd>
+<dt><tt>norm_coefficient_post</tt> : float (default is 0.0)</dt>
+<dd>Regularization coefficient of 0.5 * norm_coefficient * ||X||_2^2. Default to 0, which means no regularization.</dd>
+</dl>
+
+#### Inputs (3 - &#8734;)
+
+<dl>
+<dt><tt>R</tt> : T1</dt>
+<dd>The initial learning rate.</dd>
+<dt><tt>T</tt> : T2</dt>
+<dd>The update count of "X". It should be a scalar.</dd>
+<dt><tt>inputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>The tensors to be optimized, followed by their respective gradients, followed by their respective accumulated gradients (aka momentum), followed by their respective accumulated squared gradients. For example, to optimize tensors "X_1" and "X_2,", the input list would be ["X_1", "X_2", gradient of "X_1", gradient of "X_2", accumulated gradient of "X_1", accumulated gradient of "X_2", accumulated squared gradient of "X_1", accumulated squared gradient of "X_2"].</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>New values of optimized tensors, followed by their respective new accumulated gradients, followed by their respective new accumulated squared gradients. For example, if two tensors "X_1" and "X_2" are optimized, the outputs list would be [new value of "X_1", new value of "X_2", new accumulated gradient of "X_1", new accumulated gradient of "X_2", new accumulated squared gradient of "X_1", new accumulated squared gradient of "X_2"].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float scalars.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain input types to 64-bit integer scalars.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input and output types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>adam</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+alpha = 0.95
+beta = 0.1
+epsilon = 1e-7
+
+# Create operator.
+node = onnx.helper.make_node(
+    "Adam",
+    inputs=["R", "T", "X", "G", "V", "H"],
+    outputs=["X_new", "V_new", "H_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    epsilon=epsilon,
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+x = np.array([1.2, 2.8], dtype=np.float32)
+g = np.array([-0.94, -2.5], dtype=np.float32)
+v = np.array([1.7, 3.6], dtype=np.float32)
+h = np.array([0.1, 0.1], dtype=np.float32)
+
+# Compute expected outputs of Adam.
+x_new, v_new, h_new = apply_adam(
+    r, t, x, g, v, h, norm_coefficient, 0.0, alpha, beta, epsilon
+)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x, g, v, h],
+    outputs=[x_new, v_new, h_new],
+    name="test_adam",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>adam_multiple</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+alpha = 0.95
+beta = 0.85
+epsilon = 1e-2
+
+node = onnx.helper.make_node(
+    "Adam",
+    inputs=["R", "T", "X1", "X2", "G1", "G2", "V1", "V2", "H1", "H2"],
+    outputs=["X1_new", "X2_new", "V1_new", "V2_new", "H1_new", "H2_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    epsilon=epsilon,
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+
+x1 = np.array([1.0], dtype=np.float32)
+g1 = np.array([-1.0], dtype=np.float32)
+v1 = np.array([2.0], dtype=np.float32)
+h1 = np.array([0.5], dtype=np.float32)
+
+x2 = np.array([1.0, 2.0], dtype=np.float32)
+g2 = np.array([-1.0, -3.0], dtype=np.float32)
+v2 = np.array([4.0, 1.0], dtype=np.float32)
+h2 = np.array([1.0, 10.0], dtype=np.float32)
+
+# Compute expected outputs of Adam.
+x1_new, v1_new, h1_new = apply_adam(
+    r, t, x1, g1, v1, h1, norm_coefficient, 0.0, alpha, beta, epsilon
+)
+x2_new, v2_new, h2_new = apply_adam(
+    r, t, x2, g2, v2, h2, norm_coefficient, 0.0, alpha, beta, epsilon
+)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x1, x2, g1, g2, v1, v2, h1, h2],
+    outputs=[x1_new, x2_new, v1_new, v2_new, h1_new, h2_new],
+    name="test_adam_multiple",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
+### <a name="ai.onnx.preview.training.Gradient"></a><a name="ai.onnx.preview.training.gradient">**ai.onnx.preview.training.Gradient**</a>
+
+  Gradient operator computes the partial derivatives of a specific tensor w.r.t.
+  some other tensors. This operator is widely used in gradient-based training
+  algorithms. To illustrate its use, let's consider a computation graph,
+
+  ```
+  X -----.
+         |
+         v
+  W --> Conv --> H --> Gemm --> Y
+                        ^
+                        |
+                        Z
+  ```
+
+  , where W and Z are trainable tensors. Note that operators' attributes are
+  omitted for the sake of simplicity. Let dY/dW (dY/dZ) be the gradient of
+  Y with respect to W (Z). The user can compute gradient by inserting Gradient
+  operator to form another graph shown below.
+
+  ```
+  W --> Conv --> H --> Gemm --> Y
+  |      ^              ^
+  |      |              |
+  |      X              Z
+  |      |              |
+  |      |   .----------'
+  |      |   |  (W/Z/X is the 1st/2nd/3rd input of Gradient as shown in
+  |      |   |   "xs" followed by "zs")
+  |      v   v
+  '---> Gradient(xs=["W", "Z"], zs=["X"], y="Y")
+         |   |
+         |   '-----------------------------------> dY/dW (1st output of Gradient)
+         |
+         '---------------------------------------> dY/dZ (2nd output of Gradient)
+  ```
+
+  By definition, the tensor "y" is a function of independent variables in "xs"
+  and "zs". Since we only compute the gradient of "y" w.r.t. the differentiable
+  variables in "xs", this Gradient only outputs dY/dW and dY/dZ. Note that "H"
+  cannot appear in "xs" and "zs". The reason is that "H" can be determined by
+  tensors "W" and "X" and therefore "H" is not an independent variable.
+
+  All outputs are optional. If needed, for example, user can assign an empty
+  string to the 1st output name of that Gradient to skip the generation of dY/dW.
+  Note that the concept of optional outputs can also be found in ONNX's RNN, GRU,
+  and LSTM.
+
+  Gradient operator can compute derivative against intermediate tensors. For
+  example, the gradient of Y with respect to H can be done via
+
+  ```
+  W --> Conv --> H --> Gemm --> Y
+         ^       |      ^
+         |       |      |
+         X       |      Z
+         .-------'      |
+         |   .----------'
+         |   | (H/Z is the 1st/2nd input of Gradient as shown in "xs")
+         v   v
+        Gradient(xs=["H", "Z"], y="Y")
+         |   |
+         |   '-----------------------------------> dY/dH (1st output of Gradient)
+         |
+         '---------------------------------------> dY/dZ (2nd output of Gradient)
+  ```
+
+  It is possible to represent high-order differentiation using Gradient operators.
+  For example, given the following linear model:
+
+  ```
+  W --> Gemm --> Y --> Loss --> O
+         ^              ^
+         |              |
+         X              L
+  ```
+
+  To compute the 2nd order derivative of O with respect to W (denoted by
+  d^2O/dW^2), one can do
+
+  ```
+  W --> Gemm --> Y --> Loss --> O
+  |      ^              ^
+  |      |              |
+  |      X .------------L
+  |      | |            |
+  |      | |            v
+  +------+-+> Gradient(xs=["X", "W"], zs=["L"], y="O") ---> dO/dX (1st output of Gradient)
+  |      | |    |
+  |      | |    '---> dO/dW (2nd output of Gradient)
+  |      v v
+  '---> Gradient(xs=["X", "W"], zs=["L"], y="dO/dW") ---> d(dO/dW)dX (1st output of
+         |                                                  Gradient)
+         |
+         |
+         '---> d^2O/dW^2 (2nd output of Gradient)
+  ```
+
+  The tensors named in attributes "xs", "zs", and "y" define the differentiated
+  computation graph, and the inputs to Gradient node define the values at
+  which the gradient is computed. We can feed different tensors to the identified
+  graph. For example, one can compute the gradient of Y with respect to H at
+  a specific value of H, H_1, by providing that value as an input to the Gradient
+  node.
+
+  ```
+  W --> Conv --> H --> Gemm --> Y
+         ^              ^
+         |              |
+         X              Z
+
+            Z_1 (2nd input of Gradient)
+             |
+             v
+  H_1 --> Gradient(xs=["H", "Z"], y="Y") ---> dY/dH when H = H_1 and Y = Y_1.
+             |
+             '------------------------------> dY/dZ (2nd output of Gradient)
+  ```
+
+  When the inputs of Gradient are the tensors named in "xs" and "zs", the
+  computation can be optimized. More specifically, intermediate variables in
+  forward pass can be reused if the gradient is computed via reverse-mode
+  auto-differentiation.
+
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.preview.training' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>xs</tt> : list of strings (required)</dt>
+<dd>Input tensor names of the differentiated sub-graph. It contains only the necessary differentiated inputs of a (sub-)graph. Variables (usually called intermediate variables) that can be generated from inputs cannot be included in this attribute.</dd>
+<dt><tt>y</tt> : string (required)</dt>
+<dd>The targeted tensor. It can be viewed as the output of the differentiated function. The attribute "xs" and attribute "zs" are the minimal independent variable set that determines the value of "y".</dd>
+<dt><tt>zs</tt> : list of strings</dt>
+<dd>Input tensor names of the differentiated sub-graph. It contains only the necessary non-differentiated inputs of a (sub-)graph. Variables (usually called intermediate variables) that can be generated from inputs cannot be included in this attribute.</dd>
+</dl>
+
+#### Inputs (1 - &#8734;)
+
+<dl>
+<dt><tt>Inputs</tt> (variadic, heterogeneous) : T1</dt>
+<dd>The values fed into graph identified by the attributes. The i-th input is the value of the i-th tensor specified in the concatenated list of the attribute "xs" and the attribute  "zs". For example, if xs=["A", "B"] and zs=["C"], the first input is used as the value of symbol "A" and the 3rd input is substituted for all the occurrences of "C".</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>Outputs</tt> (variadic, heterogeneous) : T2</dt>
+<dd>The gradient of the tensor specified by the attribute "y" with respect to each of tensors specified in the attribute "xs". The i-th output is the gradient of "y" with respect to the i-th tensor specified in the attribute "xs".</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(uint8), tensor(uint16), tensor(uint32), tensor(uint64), tensor(int8), tensor(int16), tensor(int32), tensor(int64), tensor(float16), tensor(float), tensor(double), tensor(string), tensor(bool), tensor(complex64), tensor(complex128)</dt>
+<dd>Allow outputs to be any kind of tensor.</dd>
+<dt><tt>T2</tt> : tensor(float16), tensor(float), tensor(double)</dt>
+<dd>Allow inputs to be any kind of floating-point tensor.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>gradient_scalar_add</summary>
+
+```python
+add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add")
+gradient_node = onnx.helper.make_node(
+    "Gradient",
+    ["a", "b"],
+    ["dc_da", "dc_db"],
+    name="my_gradient",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+    xs=["a", "b"],
+    y="c",
+)
+
+a = np.array(1.0).astype(np.float32)
+b = np.array(2.0).astype(np.float32)
+c = a + b
+# dc / da = d(a+b) / da = 1
+dc_da = np.array(1).astype(np.float32)
+# db / db = d(a+b) / db = 1
+dc_db = np.array(1).astype(np.float32)
+
+graph = onnx.helper.make_graph(
+    nodes=[add_node, gradient_node],
+    name="GradientOfAdd",
+    inputs=[
+        onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []),
+    ],
+    outputs=[
+        onnx.helper.make_tensor_value_info("c", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("dc_da", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("dc_db", onnx.TensorProto.FLOAT, []),
+    ],
+)
+opsets = [
+    onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12),
+    onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+]
+model = onnx.helper.make_model_gen_version(
+    graph, producer_name="backend-test", opset_imports=opsets
+)
+expect(
+    model, inputs=[a, b], outputs=[c, dc_da, dc_db], name="test_gradient_of_add"
+)
+```
+
+</details>
+
+
+<details>
+<summary>gradient_scalar_add_and_mul</summary>
+
+```python
+add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add")
+mul_node = onnx.helper.make_node("Mul", ["c", "a"], ["d"], name="my_mul")
+gradient_node = onnx.helper.make_node(
+    "Gradient",
+    ["a", "b"],
+    ["dd_da", "dd_db"],
+    name="my_gradient",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+    xs=["a", "b"],
+    y="d",
+)
+
+a = np.array(1.0).astype(np.float32)
+b = np.array(2.0).astype(np.float32)
+c = a + b
+# d = a * c = a * (a + b)
+d = a * c
+# dd / da = d(a*a+a*b) / da = 2 * a + b
+dd_da = (2 * a + b).astype(np.float32)
+# dd / db = d(a*a+a*b) / db = a
+dd_db = a
+
+graph = onnx.helper.make_graph(
+    nodes=[add_node, mul_node, gradient_node],
+    name="GradientOfTwoOperators",
+    inputs=[
+        onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []),
+    ],
+    outputs=[
+        onnx.helper.make_tensor_value_info("d", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("dd_da", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("dd_db", onnx.TensorProto.FLOAT, []),
+    ],
+)
+
+opsets = [
+    onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12),
+    onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+]
+model = onnx.helper.make_model_gen_version(
+    graph, producer_name="backend-test", opset_imports=opsets
+)
+expect(
+    model,
+    inputs=[a, b],
+    outputs=[d, dd_da, dd_db],
+    name="test_gradient_of_add_and_mul",
+)
+```
+
+</details>
+
+
+### <a name="ai.onnx.preview.training.Momentum"></a><a name="ai.onnx.preview.training.momentum">**ai.onnx.preview.training.Momentum**</a>
+
+  Compute one iteration of stochastic gradient update with momentum.
+      This operator can conduct the optimization of multiple tensor variables.
+
+      Let's define the behavior of this operator. As you can imagine, SG with momentum requires
+      several parameters:
+
+       - The learning-rate "R".
+       - The update count "T". That is, the number of conducted training iterations. It should
+         be zero in the first training iteration.
+       - A L2-norm regularization coefficient "norm_coefficient".
+       - A decay coefficient of previous accumulated gradient (i.e., momentum) "alpha".
+       - The scaling coefficient of current gradient "beta".
+       - An attribute to choose either standard momentum or Nesterov's momentum "mode" should
+         be used.
+
+      For the sake of simplicity, assume that there is only one tensor (called "X") to be optimized.
+      Other necessary inputs are "X"'s gradient (called "G") and "X"'s momentum (called "V"). This
+      Momentum operator maps all these inputs to the new value of "X" (called "X_new") and its new
+      momentum (called "V_new").
+
+      This operator supports two different momentum algorithms. Set the attribute "mode" to
+      "nesterov" if Nesterov's momentum is desired. Otherwise, set the attribute "model" to
+      "standard" to use standard momentum. Computation details are described subsequently.
+
+      Let "+", "-", "*", and "/" are all element-wise operations with numpy-style broadcasting.
+
+      Pseudo code for SG with standard momentum:
+
+        // Add gradient of 0.5 * norm_coefficient * ||X||^2, where ||X|| is the sum of squared
+        // values of all elements in X.
+        G_regularized = norm_coefficient * X + G
+
+        // In the first training iteration, beta should always be 1.
+        beta_adjusted = T > 0 ? beta : 1
+
+        // Compute the current momentum based on previous momentum and the current gradient.
+        V_new = alpha * V + beta_adjusted * G_regularized
+
+        // Update X.
+        X_new = X - R * V_new
+
+      Pseudo code for SG with Nesterov's momentum:
+
+        // Add gradient of 0.5 * norm_coefficient * ||X||^2, where ||X|| is the sum of squared
+        // values of all elements in X.
+        G_regularized = norm_coefficient * X + G;
+
+        // In the first training iteration, beta should always be 1.
+        beta_adjusted = T > 0 ? beta : 1
+
+        // Compute the current momentum based on previous momentum and the current gradient.
+        V_new = alpha * V + beta_adjusted * G_regularized;
+
+        // Compute final update direction and then update X.
+        X_new = X - R * (G_regularized + alpha * V_new)
+
+      If one assign this operators to optimize multiple inputs, for example, "X_1" and "X_2". The same
+      pseudo code would be extended to handle all tensors jointly. More specifically, we can view "X" as a
+      concatenation of "X_1" and "X_2" (of course, their gradient and accumulate gradient should
+      be concatenated too) and then our pseudo code becomes applicable.
+
+#### Version
+
+This version of the operator has been available since version 1 of the 'ai.onnx.preview.training' operator set.
+
+#### Attributes
+
+<dl>
+<dt><tt>alpha</tt> : float (required)</dt>
+<dd>The decay factor of momentum. It should be a scalar.</dd>
+<dt><tt>beta</tt> : float (required)</dt>
+<dd>The coefficient of gradient in computing new momentum. It should be a scalar.</dd>
+<dt><tt>mode</tt> : string (required)</dt>
+<dd>Its value should be either "nesterov" or "standard". The value "nesterov" leads to the use of Nesterov's momentum while "standard" invokes stochastic gradient method using standard momentum</dd>
+<dt><tt>norm_coefficient</tt> : float (required)</dt>
+<dd>Coefficient of 0.5 * norm_coefficient * ||X||^2.</dd>
+</dl>
+
+#### Inputs (3 - &#8734;)
+
+<dl>
+<dt><tt>R</tt> : T1</dt>
+<dd>The learning rate.</dd>
+<dt><tt>T</tt> : T2</dt>
+<dd>Update count of "X". It should be a scalar.</dd>
+<dt><tt>inputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>It sequentially contains the current values of optimized tensors, then their gradient tensors, and finally their momentum tensors. For example, if two tensors "X_1" and "X_2" are optimized, The expected input list would be ["X_1", "X_2", gradient of "X_1", gradient of "X_2", momentum of "X_1", momentum of "X_2"].</dd>
+</dl>
+
+#### Outputs (1 - &#8734;)
+
+<dl>
+<dt><tt>outputs</tt> (variadic, heterogeneous) : T3</dt>
+<dd>It sequentially contains the new values of optimized tensors and then the new values of their momentum tensors. For example, if two tensors "X_1" and "X_2" are optimized, the output list would be [new value of "X_1," new value of "X_2" new momentum of "X_1", new momentum of "X_2"].</dd>
+</dl>
+
+#### Type Constraints
+
+<dl>
+<dt><tt>T1</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float scalars.</dd>
+<dt><tt>T2</tt> : tensor(int64)</dt>
+<dd>Constrain input types to 64-bit integer scalars.</dd>
+<dt><tt>T3</tt> : tensor(float), tensor(double)</dt>
+<dd>Constrain input types to float tensors.</dd>
+</dl>
+
+
+#### Examples
+
+<details>
+<summary>momentum</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+alpha = 0.95
+beta = 0.1
+
+# Create operator.
+node = onnx.helper.make_node(
+    "Momentum",
+    inputs=["R", "T", "X", "G", "V"],
+    outputs=["X_new", "V_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    mode="standard",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+x = np.array([1.2, 2.8], dtype=np.float32)
+g = np.array([-0.94, -2.5], dtype=np.float32)
+v = np.array([1.7, 3.6], dtype=np.float32)
+
+# Compute expected outputs of Momentum.
+x_new, v_new = apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x, g, v],
+    outputs=[x_new, v_new],
+    name="test_momentum",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>momentum_multiple</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+alpha = 0.95
+beta = 0.85
+
+node = onnx.helper.make_node(
+    "Momentum",
+    inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"],
+    outputs=["X1_new", "X2_new", "V1_new", "V2_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    mode="standard",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+
+x1 = np.array([1.0], dtype=np.float32)
+g1 = np.array([-1.0], dtype=np.float32)
+v1 = np.array([2.0], dtype=np.float32)
+
+x2 = np.array([1.0, 2.0], dtype=np.float32)
+g2 = np.array([-1.0, -3.0], dtype=np.float32)
+v2 = np.array([4.0, 1.0], dtype=np.float32)
+
+# Compute expected outputs of Momentum.
+x1_new, v1_new = apply_momentum(r, t, x1, g1, v1, norm_coefficient, alpha, beta)
+x2_new, v2_new = apply_momentum(r, t, x2, g2, v2, norm_coefficient, alpha, beta)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x1, x2, g1, g2, v1, v2],
+    outputs=[x1_new, x2_new, v1_new, v2_new],
+    name="test_momentum_multiple",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
+<details>
+<summary>nesterov_momentum</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.01
+alpha = 0.95
+beta = 1.0
+
+# Create operator.
+node = onnx.helper.make_node(
+    "Momentum",
+    inputs=["R", "T", "X", "G", "V"],
+    outputs=["X_new", "V_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    mode="nesterov",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+x = np.array([1.2, 2.8], dtype=np.float32)
+g = np.array([-0.94, -2.5], dtype=np.float32)
+v = np.array([1.7, 3.6], dtype=np.float32)
+
+# Compute expected outputs of Momentum.
+x_new, v_new = apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x, g, v],
+    outputs=[x_new, v_new],
+    name="test_nesterov_momentum",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
diff --git a/docs/Overview.md b/docs/Overview.md
new file mode 100644
index 0000000..bbd6b9b
--- /dev/null
+++ b/docs/Overview.md
@@ -0,0 +1,23 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Overview
+
+Deep learning with neural networks is accomplished through computation over dataflow graphs. Some frameworks (such as CNTK, Caffe2, Theano, and TensorFlow) make use of static graphs, while others (such as PyTorch and Chainer) use dynamic graphs. However, they all provide interfaces that make it simple for developers to construct computation graphs and runtimes that process the graphs in an optimized way. The graph serves as an Intermediate Representation (IR) that captures the specific intent of the developer's source code, and is conducive for optimization and translation to run on specific devices (CPU, GPU, FPGA, etc.).
+
+## Why a common IR?
+
+Today, each framework has its own proprietary representation of the graph, though they all provide similar capabilities – meaning each framework is a siloed stack of API, graph, and runtime. Furthermore, frameworks are typically optimized for some characteristic, such as fast training, supporting complicated network architectures, inference on mobile devices, etc. It's up to the developer to select a framework that is optimized for one of these characteristics. Additionally, these optimizations may be better suited for particular stages of development. This leads to significant delays between research and production due to the necessity of conversion.
+
+With the goal of democratizing AI, we envision empowering developers to select the framework that works best for their project, at any stage of development or deployment. The Open Neural Network Exchange (ONNX) format is a common IR to help establish this powerful ecosystem.
+
+By providing a common representation of the computation graph, ONNX helps developers choose the right framework for their task, allows authors to focus on innovative enhancements, and enables hardware vendors to streamline optimizations for their platforms.
+
+ONNX is designed to be an open format. We welcome contributions from the community and encourage everyone to adopt ONNX in their ecosystem.
+
+## Why two variants?
+
+The base definition of ONNX includes the necessary support for machine learning algorithms based on neural network technologies. ONNX-ML includes additional types and standard operators commonly used in classical machine learning algorithms. The two variants were created in order to explicitly recognize the desire for some frameworks to go beyond neural network algorithms in a standardized fashion, while allowing other frameworks to support only neural networks.
diff --git a/docs/PythonAPIOverview.md b/docs/PythonAPIOverview.md
new file mode 100644
index 0000000..ec0b46f
--- /dev/null
+++ b/docs/PythonAPIOverview.md
@@ -0,0 +1,503 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Python API Overview
+
+The full API is described at [API Reference](https://onnx.ai/onnx/api).
+
+## Loading an ONNX Model
+
+```python
+import onnx
+
+# onnx_model is an in-memory ModelProto
+onnx_model = onnx.load("path/to/the/model.onnx")
+```
+
+## Loading an ONNX Model with External Data
+
+* If the external data is under the same directory of the model, simply use `onnx.load()`
+
+```python
+import onnx
+
+onnx_model = onnx.load("path/to/the/model.onnx")
+```
+
+* If the external data is under another directory, use `load_external_data_for_model()` to specify the directory path and load after using `onnx.load()`
+
+```python
+import onnx
+from onnx.external_data_helper import load_external_data_for_model
+
+onnx_model = onnx.load("path/to/the/model.onnx", load_external_data=False)
+load_external_data_for_model(onnx_model, "data/directory/path/")
+# Then the onnx_model has loaded the external data from the specific directory
+```
+
+## Converting an ONNX Model to External Data
+
+```python
+from onnx.external_data_helper import convert_model_to_external_data
+
+# onnx_model is an in-memory ModelProto
+onnx_model = ...
+convert_model_to_external_data(onnx_model, all_tensors_to_one_file=True, location="filename", size_threshold=1024, convert_attribute=False)
+# Then the onnx_model has converted raw data as external data
+# Must be followed by save
+```
+
+## Saving an ONNX Model
+
+```python
+import onnx
+
+# onnx_model is an in-memory ModelProto
+onnx_model = ...
+
+# Save the ONNX model
+onnx.save(onnx_model, "path/to/the/model.onnx")
+```
+
+## Converting and Saving an ONNX Model to External Data
+
+```python
+import onnx
+
+# onnx_model is an in-memory ModelProto
+onnx_model = ...
+onnx.save_model(onnx_model, "path/to/save/the/model.onnx", save_as_external_data=True, all_tensors_to_one_file=True, location="filename", size_threshold=1024, convert_attribute=False)
+# Then the onnx_model has converted raw data as external data and saved to specific directory
+```
+
+## Manipulating TensorProto and Numpy Array
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    import onnx
+    from onnx import numpy_helper
+
+    # Preprocessing: create a Numpy array
+    numpy_array = numpy.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=float)
+    print(f"Original Numpy array:\n{numpy_array}\n")
+
+    # Convert the Numpy array to a TensorProto
+    tensor = numpy_helper.from_array(numpy_array)
+    print(f"TensorProto:\n{tensor}")
+
+    # Convert the TensorProto to a Numpy array
+    new_array = numpy_helper.to_array(tensor)
+    print(f"After round trip, Numpy array:\n{new_array}\n")
+
+    # Save the TensorProto
+    with open("tensor.pb", "wb") as f:
+        f.write(tensor.SerializeToString())
+
+    # Load a TensorProto
+    new_tensor = onnx.TensorProto()
+    with open("tensor.pb", "rb") as f:
+        new_tensor.ParseFromString(f.read())
+    print(f"After saving and loading, new TensorProto:\n{new_tensor}")
+
+    from onnx import TensorProto, helper
+
+    # Conversion utilities for mapping attributes in ONNX IR
+    # The functions below are available after ONNX 1.13
+    np_dtype = helper.tensor_dtype_to_np_dtype(TensorProto.FLOAT)
+    print(f"The converted numpy dtype for {helper.tensor_dtype_to_string(TensorProto.FLOAT)} is {np_dtype}.")
+    storage_dtype = helper.tensor_dtype_to_storage_tensor_dtype(TensorProto.FLOAT)
+    print(f"The storage dtype for {helper.tensor_dtype_to_string(TensorProto.FLOAT)} is {helper.tensor_dtype_to_string(storage_dtype)}.")
+    field_name = helper.tensor_dtype_to_field(TensorProto.FLOAT)
+    print(f"The field name for {helper.tensor_dtype_to_string(TensorProto.FLOAT)} is {field_name}.")
+    tensor_dtype = helper.np_dtype_to_tensor_dtype(np_dtype)
+    print(f"The tensor data type for numpy dtype: {np_dtype} is {helper.tensor_dtype_to_string(tensor_dtype)}.")
+
+    for tensor_dtype in helper.get_all_tensor_dtypes():
+        print(helper.tensor_dtype_to_string(tensor_dtype))
+```
+
+## Creating an ONNX Model Using Helper Functions
+
+```{eval-rst}
+.. exec_code::
+
+    import onnx
+    from onnx import helper, TensorProto
+
+    # Create inputs and output value info
+    X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [3, 2])
+    pads = helper.make_tensor_value_info("pads", TensorProto.INT64, [4])
+    Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [5, 4])
+
+    # Create Pad node
+    node_def = helper.make_node(
+        "Pad",
+        inputs=["X", "pads"],
+        outputs=["Y"],
+        mode="constant",
+    )
+
+    # Build graph and model
+    graph_def = helper.make_graph(
+        [node_def],
+        "test-model",
+        [X, pads],
+        [Y],
+    )
+    model_def = helper.make_model(
+        graph_def,
+        producer_name="onnx-example",
+        opset_imports=[helper.make_opsetid("", 11)]
+    )
+
+    # Validate the model
+    onnx.checker.check_model(model_def)
+    print("Model is valid!")
+```
+
+## Conversion utilities for mapping attributes in ONNX IR
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import TensorProto, helper
+
+    np_dtype = helper.tensor_dtype_to_np_dtype(TensorProto.FLOAT)
+    print(f"The converted numpy dtype for {helper.tensor_dtype_to_string(TensorProto.FLOAT)} is {np_dtype}.")
+
+    field_name = helper.tensor_dtype_to_field(TensorProto.FLOAT)
+    print(f"The field name for {helper.tensor_dtype_to_string(TensorProto.FLOAT)} is {field_name}.")
+
+    # There are other useful conversion utilities. Please check onnx.helper
+```
+
+## Checking an ONNX Model
+
+```python
+import onnx
+
+# Preprocessing: load the ONNX model
+model_path = "path/to/the/model.onnx"
+onnx_model = onnx.load(model_path)
+
+print(f"The model is:\n{onnx_model}")
+
+# Check the model
+try:
+    onnx.checker.check_model(onnx_model)
+except onnx.checker.ValidationError as e:
+    print(f"The model is invalid: {e}")
+else:
+    print("The model is valid!")
+```
+
+### Checking a Large ONNX Model >2GB
+
+Current checker supports checking models with external data, but for those models larger than 2GB, please use the model path for onnx.checker and the external data needs to be under the same directory.
+
+```python
+import onnx
+
+onnx.checker.check_model("path/to/the/model.onnx")
+# onnx.checker.check_model(loaded_onnx_model) will fail if given >2GB model
+```
+
+## Running Shape Inference on an ONNX Model
+
+```{eval-rst}
+.. exec_code::
+
+    import onnx
+    from onnx import helper, shape_inference
+    from onnx import TensorProto
+
+    # Preprocessing: create a model with two nodes, Y's shape is unknown
+    node1 = helper.make_node("Transpose", ["X"], ["Y"], perm=[1, 0, 2])
+    node2 = helper.make_node("Transpose", ["Y"], ["Z"], perm=[1, 0, 2])
+
+    graph = helper.make_graph(
+        [node1, node2],
+        "two-transposes",
+        [helper.make_tensor_value_info("X", TensorProto.FLOAT, (2, 3, 4))],
+        [helper.make_tensor_value_info("Z", TensorProto.FLOAT, (2, 3, 4))],
+    )
+
+    original_model = helper.make_model(graph, producer_name="onnx-examples")
+
+    # Check the model and print Y's shape information
+    onnx.checker.check_model(original_model)
+    print(f"Before shape inference, the shape info of Y is:\n{original_model.graph.value_info}")
+
+    # Apply shape inference on the model
+    inferred_model = shape_inference.infer_shapes(original_model)
+
+    # Check the model and print Y's shape information
+    onnx.checker.check_model(inferred_model)
+    print(f"After shape inference, the shape info of Y is:\n{inferred_model.graph.value_info}")
+```
+
+### Shape inference a Large ONNX Model >2GB
+
+Current shape_inference supports models with external data, but for those models larger than 2GB, please use the model path for onnx.shape_inference.infer_shapes_path and the external data needs to be under the same directory. You can specify the output path for saving the inferred model; otherwise, the default output path is same as the original model path.
+
+```python
+import onnx
+
+# output the inferred model to the original model path
+onnx.shape_inference.infer_shapes_path("path/to/the/model.onnx")
+
+# output the inferred model to the specified model path
+onnx.shape_inference.infer_shapes_path("path/to/the/model.onnx", "output/inferred/model.onnx")
+
+# inferred_model = onnx.shape_inference.infer_shapes(loaded_onnx_model) will fail if given >2GB model
+```
+
+## Running Type Inference on an ONNX Function
+
+```{eval-rst}
+.. exec_code::
+
+    import onnx
+    import onnx.helper
+    import onnx.parser
+    import onnx.shape_inference
+
+    function_text = """
+        <opset_import: [ "" : 18 ], domain: "local">
+        CastTo <dtype> (x) => (y) {
+            y = Cast <to : int = @dtype> (x)
+        }
+    """
+    function = onnx.parser.parse_function(function_text)
+
+    # The function above has one input-parameter x, and one attribute-parameter dtype.
+    # To apply type-and-shape-inference to this function, we must supply the type of
+    # input-parameter and an attribute value for the attribute-parameter as below:
+
+    float_type_ = onnx.helper.make_tensor_type_proto(1, None)
+    dtype_6 = onnx.helper.make_attribute("dtype", 6)
+    result = onnx.shape_inference.infer_function_output_types(
+        function, [float_type_], [dtype_6]
+    )
+    print(result)  # a list containing the (single) output type
+```
+
+## Converting Version of an ONNX Model within Default Domain (""/"ai.onnx")
+
+```python
+import onnx
+from onnx import version_converter, helper
+
+# Preprocessing: load the model to be converted.
+model_path = "path/to/the/model.onnx"
+original_model = onnx.load(model_path)
+
+print(f"The model before conversion:\n{original_model}")
+
+# A full list of supported adapters can be found here:
+# https://github.com/onnx/onnx/blob/main/onnx/version_converter.py#L21
+# Apply the version conversion on the original model
+converted_model = version_converter.convert_version(original_model, <int target_version>)
+
+print(f"The model after conversion:\n{converted_model}")
+```
+
+## Utility Functions
+
+### Extracting Sub-model with Inputs Outputs Tensor Names
+
+Function `extract_model()` extracts sub-model from an ONNX model.
+The sub-model is defined by the names of the input and output tensors *exactly*.
+
+```python
+import onnx
+
+input_path = "path/to/the/original/model.onnx"
+output_path = "path/to/save/the/extracted/model.onnx"
+input_names = ["input_0", "input_1", "input_2"]
+output_names = ["output_0", "output_1"]
+
+onnx.utils.extract_model(input_path, output_path, input_names, output_names)
+```
+
+Note: For control-flow operators, e.g. If and Loop, the *boundary of sub-model*,
+which is defined by the input and output tensors, should not *cut through* the
+subgraph that is connected to the *main graph* as attributes of these operators.
+
+### ONNX Compose
+
+`onnx.compose` module provides tools to create combined models.
+
+`onnx.compose.merge_models` can be used to merge two models, by connecting some of the outputs
+from the first model with inputs from the second model. By default, inputs/outputs not present in the
+`io_map` argument will remain as inputs/outputs of the combined model.
+
+In this example we merge two models by connecting each output of the first model to an input in the second. The resulting model will have the same inputs as the first model and the same outputs as the second:
+
+```python
+import onnx
+
+model1 = onnx.load("path/to/model1.onnx")
+# agraph (float[N] A, float[N] B) => (float[N] C, float[N] D)
+#   {
+#      C = Add(A, B)
+#      D = Sub(A, B)
+#   }
+
+model2 = onnx.load("path/to/model2.onnx")
+#   agraph (float[N] X, float[N] Y) => (float[N] Z)
+#   {
+#      Z = Mul(X, Y)
+#   }
+
+combined_model = onnx.compose.merge_models(
+    model1, model2,
+    io_map=[("C", "X"), ("D", "Y")]
+)
+```
+
+Additionally, a user can specify a list of `inputs`/`outputs` to be included in the combined model,
+effectively dropping the part of the graph that does't contribute to the combined model outputs.
+In the following example, we are connecting only one of the two outputs in the first model
+to both inputs in the second. By specifying the outputs of the combined model explicitly, we are dropping the output not consumed from the first model, and the relevant part of the graph:
+
+```python
+import onnx
+
+# Default case. Include all outputs in the combined model
+combined_model = onnx.compose.merge_models(
+    model1, model2,
+    io_map=[("C", "X"), ("C", "Y")],
+)  # outputs: "D", "Z"
+
+# Explicit outputs. "Y" output and the Sub node are not present in the combined model
+combined_model = onnx.compose.merge_models(
+    model1, model2,
+    io_map=[("C", "X"), ("C", "Y")],
+    outputs=["Z"],
+)  # outputs: "Z"
+```
+
+`onnx.compose.add_prefix` allows you to add a prefix to names in the model, to avoid a name collision
+when merging them. By default, it renames all names in the graph: inputs, outputs, edges, nodes,
+initializers, sparse initializers and value infos.
+
+```python
+import onnx
+
+model = onnx.load("path/to/the/model.onnx")
+# model - outputs: ["out0", "out1"], inputs: ["in0", "in1"]
+
+new_model = onnx.compose.add_prefix(model, prefix="m1/")
+# new_model - outputs: ["m1/out0", "m1/out1"], inputs: ["m1/in0", "m1/in1"]
+
+# Can also be run in-place
+onnx.compose.add_prefix(model, prefix="m1/", inplace=True)
+```
+
+`onnx.compose.expand_out_dim` can be used to connect models that expect a different number
+ of dimensions by inserting dimensions with extent one. This can be useful, when combining a
+ model producing samples with a model that works with batches of samples.
+
+```python
+import onnx
+
+# outputs: "out0", shape=[200, 200, 3]
+model1 = onnx.load("path/to/the/model1.onnx")
+
+# outputs: "in0", shape=[N, 200, 200, 3]
+model2 = onnx.load("path/to/the/model2.onnx")
+
+# outputs: "out0", shape=[1, 200, 200, 3]
+new_model1 = onnx.compose.expand_out_dims(model1, dim_idx=0)
+
+# Models can now be merged
+combined_model = onnx.compose.merge_models(
+    new_model1, model2, io_map=[("out0", "in0")]
+)
+
+# Can also be run in-place
+onnx.compose.expand_out_dims(model1, dim_idx=0, inplace=True)
+```
+
+## Tools
+
+### Updating Model"s Inputs Outputs Dimension Sizes with Variable Length
+
+Function `update_inputs_outputs_dims` updates the dimension of the inputs and outputs of the model,
+to the provided values in the parameter. You could provide both static and dynamic dimension size,
+by using dim_param. For more information on static and dynamic dimension size, checkout [Tensor Shapes](IR.md#tensor-shapes).
+
+The function runs model checker after the input/output sizes are updated.
+
+```python
+import onnx
+from onnx.tools import update_model_dims
+
+model = onnx.load("path/to/the/model.onnx")
+# Here both "seq", "batch" and -1 are dynamic using dim_param.
+variable_length_model = update_model_dims.update_inputs_outputs_dims(model, {"input_name": ["seq", "batch", 3, -1]}, {"output_name": ["seq", "batch", 1, -1]})
+```
+
+## ONNX Parser
+
+Functions `onnx.parser.parse_model` and `onnx.parser.parse_graph` can be used to create an ONNX model
+or graph from a textual representation as shown below. See [Language Syntax](Syntax.md) for more details
+about the language syntax.
+
+```{eval-rst}
+.. exec_code::
+
+    import onnx
+
+    input = """
+       agraph (float[N, 128] X, float[128, 10] W, float[10] B) => (float[N, 10] C)
+       {
+            T = MatMul(X, W)
+            S = Add(T, B)
+            C = Softmax(S)
+       }
+    """
+    graph = onnx.parser.parse_graph(input)
+    print(f"Graph name: {graph.name}")
+    print(f"Graph nodes: {[n.op_type for n in graph.node]}")
+
+    input = """
+       <
+         ir_version: 7,
+         opset_import: ["" : 10]
+       >
+       agraph (float[N, 128] X, float[128, 10] W, float[10] B) => (float[N, 10] C)
+       {
+          T = MatMul(X, W)
+          S = Add(T, B)
+          C = Softmax(S)
+       }
+    """
+    model = onnx.parser.parse_model(input)
+    print(f"Model IR version: {model.ir_version}")
+    print(f"Model graph: {model.graph.name}")
+```
+
+## ONNX Inliner
+
+Functions `onnx.inliner.inline_local_functions` and `inline_selected_functions` can be used
+to inline model-local functions in an ONNX model. In particular, `inline_local_functions` can
+be used to produce a function-free model (suitable for backends that do not handle or support
+functions). On the other hand, `inline_selected_functions` can be used to inline selected
+functions. There is no support yet for inlining ONNX standard ops that are functions (also known
+as schema-defined functions).
+
+```python
+import onnx
+import onnx.inliner
+
+model = onnx.load("path/to/the/model.onnx")
+inlined = onnx.inliner.inline_local_functions(model)
+onnx.save("path/to/the/inlinedmodel.onnx")
+```
diff --git a/docs/ReleaseVerification.md b/docs/ReleaseVerification.md
new file mode 100644
index 0000000..b37acfc
--- /dev/null
+++ b/docs/ReleaseVerification.md
@@ -0,0 +1,39 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Verifying ONNX PyPI Releases with Sigstore Attestations
+
+ONNX PyPI releases include **Sigstore attestations** compliant with **PEP 740**, enabling cryptographic verification of **integrity, provenance, and publisher identity**.
+
+## Security Guarantees
+
+Verification confirms that:
+
+- the artifact **has not been modified**,
+- it was **built and published by ONNX CI**,
+- the signature is **publicly auditable** in Sigstore’s transparency log,
+- the publisher identity matches **`onnx/onnx`**.
+
+## Verify a Release
+
+```bash
+pip install pypi-attestations
+
+pypi-attestations verify pypi \
+  --repository https://github.com/onnx/onnx \
+  pypi:onnx-1.20.1-cp313-cp313t-win_amd64.whl
+```
+
+## References
+
+- PEP 740 – Digital Attestations for Python Packages
+  https://peps.python.org/pep-0740/
+
+- Sigstore
+  https://www.sigstore.dev/
+
+- PyPI Attestations
+  https://pypi.org/project/pypi-attestations/
diff --git a/docs/Relicensing.md b/docs/Relicensing.md
new file mode 100644
index 0000000..09fa854
--- /dev/null
+++ b/docs/Relicensing.md
@@ -0,0 +1,15 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Relicensing MIT to Apache-2.0
+
+The following copyright holders agree that all of their contributions originally submitted to this project under the MIT license are hereby relicensed to Apache-2.0, and are submitted pursuant to the Developer Certificate of Origin, version 1.1:
+
+Intel Corporation
+Microsoft Corporation
+NVIDIA Corporation
+IBM Corporation
+Facebook Inc.
diff --git a/docs/ShapeInference.md b/docs/ShapeInference.md
new file mode 100644
index 0000000..5720716
--- /dev/null
+++ b/docs/ShapeInference.md
@@ -0,0 +1,197 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Shape Inference
+
+ONNX provides an optional implementation of shape inference on ONNX
+graphs. This implementation covers each of the core operators, as well
+as provides an interface for extensibility. Therefore, you may choose
+to invoke the existing shape inference functionality on your graphs,
+or to define shape inference implementations to go along with your
+custom operators (or both!). Shape inference functions are stored as a
+member of the OpSchema objects.
+
+In ONNX 1.10 release, symbol generation and propagation along with shape
+data propagation was added to ONNX graph level shape inference.
+Detailed proposal is [here](proposals/0005-SymbolicShapeInfProposal.md)
+
+## Background
+
+Please see this [section](IR.md#static-tensor-shapes) of IR.md for a review of static tensor shapes.
+In particular, a static tensor shape (represented by a `TensorShapeProto`) is distinct from
+a runtime tensor shape. This feature is commonly used when the exact runtime tensor shape is
+not known statically (that is, at compile time).
+
+* A `Tensor` with an undefined `shape` field is used to represent a tensor of unknown rank.
+* A `Tensor` with a defined `shape` represents a tensor of known rank.
+* Each `Dimension` of a `TensorShapeProto` can have a known integer value
+(represented by the `dim_value` field) or it can have an unknown value
+represented by a symbolic identified (the `dim_param` field) or it
+may have neither field defined (in which case it represents an anonymous
+unknown value).
+
+## Invoking Shape Inference
+
+Shape inference can be invoked either via C++ or Python. The Python
+API is described, with example,
+[here](PythonAPIOverview.md#running-shape-inference-on-an-onnx-model).
+
+The C++ API consists of a single function
+
+```cpp
+shape_inference::InferShapes(
+    ModelProto& m,
+    const ISchemaRegistry* schema_registry);
+```
+
+The first argument is a `ModelProto` to perform shape inference on,
+which is annotated in-place with shape information. The second
+argument is optional.
+
+## Limitations
+
+Shape inference is not guaranteed to be complete. In particular, some
+dynamic behaviors block the flow of shape inference, for example a
+Reshape to a dynamically-provide shape. Also, all operators are not
+required to have a shape inference implementation.
+
+Shape inference works only with constants and simple variables. It
+does not support arithmetic expressions containing variables. For
+example, `Concat` on tensors of shapes `(5, 2)` and `(7, 2)` can be
+inferred to produce a result of shape `(12, 2)`, but `Concat` on
+tensors of shapes `(5, 2)` and `(N, 2)` will simply produce `(M, 2)`,
+rather than containing a representation of `N+5`. Note that differing
+unknown symbolic values will be propagated, so the `M` here represents
+an unknown quantity that is the same as other occurrences of `M`.
+
+These limitations are a property of the current implementation, not
+fundamental constraints - if you are in need of something more
+advanced, do let us know!
+
+## Type Inference vs. Shape Inference
+
+**Type inference** (determining the element type of outputs) is typically handled
+automatically by the schema's type constraints. When a type constraint variable
+(e.g., `"T"`) is shared between an input and an output in the schema definition,
+the framework propagates the element type from the input to the output without
+any explicit inference code.
+
+However, many existing ops still explicitly call `propagateElemTypeFromInputToOutput`
+as a best practice for robustness. This is harmless when type constraints already
+cover the case, and ensures correct behavior regardless of how shape inference
+is invoked.
+
+Explicit type inference logic in `TypeAndShapeInferenceFunction` is only needed when:
+- The output type is determined by an **attribute** rather than an input type
+  (e.g., `Cast`, where the `to` attribute specifies the output element type)
+- The output type differs from all input types in a way that cannot be expressed
+  via shared type constraint variables
+- The operator uses **heterogeneous** variadic inputs/outputs (see below)
+
+### Homogeneous vs. Heterogeneous variadic inputs/outputs
+
+The homogeneous/heterogeneous flag applies only to variadic (repeated) inputs or
+outputs in the schema definition:
+
+- **Homogeneous** (the default): All repeated arguments must have the same type.
+  The type constraint variable constrains them to be identical, and the framework
+  enforces and propagates this automatically.
+- **Heterogeneous**: Each repeated argument may have a distinct type. The type
+  constraint variable only describes the set of *allowed* types — it does not
+  constrain different arguments to have the same type. This is used by operators
+  like `Loop` and `Scan`, whose carried state variables can have mixed types.
+
+When using heterogeneous variadic arguments, the operator's
+`TypeAndShapeInferenceFunction` must explicitly propagate types for each
+individual argument, since the framework cannot do it automatically.
+
+**Shape inference**, on the other hand, almost always requires explicit logic,
+since output shapes typically depend on input shapes, attributes, or both.
+
+## Implementing Shape Inference For Operators
+
+You can add a shape inference function to your operator's Schema with
+
+```cpp
+OpSchema& Opschema::TypeAndShapeInferenceFunction(InferenceFunction inferenceFunction);
+```
+
+`InferenceFunction` is defined in
+[shape_inference.h](/onnx/defs/shape_inference.h), along with the core
+interface struct `InferenceContext` and an assortment of helper
+methods. `InferenceContext` is the core struct which is provided to
+your inference function. It allows accessing information about the
+operator's inputs, and also allows writing out inferred information.
+
+To see numerous examples, search for occurrences of
+`TypeAndShapeInferenceFunction` in the codebase. One that is
+relatively involved is the implementation for `Concat`, in
+onnx/defs/tensor/defs.cc.
+
+Please note the following points when implementing the shape-inference method for
+operators to avoid common errors:
+
+* Before accessing the `shape` of any input, the code must check that
+the shape is available. If unavailable, it should be treated as a dynamic
+tensor whose rank is unknown and handled appropriately. Usually, the
+shape-inference logic is guarded by a call to `hasInputShape` or
+`hasNInputShapes`.
+
+* Before accessing the `dim_value` or `dim_param` of any dimension, the
+code must check if these fields have a value. In particular, the code must
+handle the possibility that the dimension may not have a statically
+known value.
+
+There are several utility functions in [shape_inference.h](/onnx/defs/shape_inference.h)
+to handle various common situations.
+
+* Use `checkInputRank` for inputs that must have a fixed rank. (See the
+inference for `RoiAlign` as an example.)
+
+* `unifyInputDim` and `unifyDim` and `updateOutputShape` can be used
+when multiple input dims are expected to be the same, and when input
+dimensions are propagated to specific output dimensions. (See the inference
+for `RoiAlign` for an example.)
+
+* `unifyInputShape` and `unifyInputShapePrefix` are higher-level utilities
+built on `unifyInputDim`. They unify all dimensions (or a prefix of dimensions)
+of an input in one call, enabling a more declarative style. `unifyInputDim`
+remains useful for more complex scenarios where individual dimensions are
+accessed selectively.
+
+* Overloaded operators `*` and `/` can be used on symbolic dimensions when output
+dimensions are computed from input dimensions using arithmetic. (See the inference
+for `SpaceToDepth` for an example.)
+
+These utilities handle missing shapes and dimensions safely.
+
+_Example_: Consider a simple matrix-multiplication op that expects inputs of shape
+`[M,K]` and `[K,N]` and returns an output of shape `[M,N]`. This can be coded
+up as below:
+
+```cpp
+   // Check that input 0 has rank 2 (if its rank is known).
+   checkInputRank(ctx, 0, 2);
+   // Check that input 1 has rank 2 (if its rank is known).
+   checkInputRank(ctx, 1, 2);
+   Dim M, K, N;
+   // Check various dimensions, handling missing dimensions/shapes safely.
+   unifyInputDim(ctx, 0, 0, M);
+   unifyInputDim(ctx, 0, 1, K);
+   unifyInputDim(ctx, 1, 0, K);
+   unifyInputDim(ctx, 1, 1, N);
+   updateOutputShape(ctx, 0, {M, N});
+```
+
+The same example can be written more concisely using `unifyInputShape`, which
+checks rank and unifies all dimensions in one call:
+
+```cpp
+   Dim M, K, N;
+   unifyInputShape(ctx, 0, {M, K});
+   unifyInputShape(ctx, 1, {K, N});
+   updateOutputShape(ctx, 0, {M, N});
+```
diff --git a/docs/Syntax.md b/docs/Syntax.md
new file mode 100644
index 0000000..0dc8da5
--- /dev/null
+++ b/docs/Syntax.md
@@ -0,0 +1,97 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Textual Syntax
+
+## Overview
+
+This document describes a textual syntax for ONNX models, which is currently an experimental feature.
+The syntax enables a compact and readable representation of ONNX models. It is motivated by a couple
+of use-cases. One is to enable compact description of test-cases and its use in CI (both in the ONNX
+repo as well as in other dependent repos such as ONNX-MLIR). The second is to help simplify the
+definition of ONNX functions. Several of the existing function-definitions are verbose, and the
+use of this syntax will lead to more compact, readable, and easier-to-maintain function definitions.
+Efficient representation and efficient parsing of very large tensor-constants is *not* a goal.
+Alternative methods should be used for that.
+
+## The API
+
+The key parser methods are the ```OnnxParser::Parse``` methods, used as below.
+
+```cpp
+  const char* code = R"ONNX(
+<
+  ir_version: 7,
+  opset_import: [ "" : 10 ]
+>
+agraph (float[N, 128] X, float[128, 10] W, float[10] B) => (float[N, 10] C)
+{
+    T = MatMul(X, W)
+    S = Add(T, B)
+    C = Softmax(S)
+}
+)ONNX";
+
+  ModelProto model;
+  OnnxParser::Parse(model, code);
+
+  checker::check_model(model);
+```
+
+See the [test-cases](../onnx/test/cpp/parser_test.cc) for more examples illustrating the API and syntax.
+
+## The Syntax
+
+The grammar below describes the syntax:
+
+```bnf
+   id-list ::= id (',' id)*
+   quotable-id-list ::= quotable-id (',' quotable-id)*
+   tensor-dim ::= '?' | quotable-id | int-constant
+   tensor-dims ::= tensor-dim (',' tensor-dim)*
+   tensor-type ::= prim-type | prim-type '[' ']' | prim-type '[' tensor-dims ']'
+   type ::= tensor-type | 'seq' '(' type ')' | 'map' '(' prim-type ',' type ')'
+            | 'optional' '(' type ')' | 'sparse_tensor' '(' tensor-type ')'
+   value-info ::= type quotable-id
+   value-infos ::= value-info (',' value-info)*
+   value-info-list ::= '(' value-infos? ')
+   id-or-value-info ::= type? quotable-id
+   id-or-value-infos ::= id-or-value-info (',' id-or-value-info)*
+   quoted-str :== '"' ([^"])* '"'
+   quotable-id :== id | quoted-str
+   str-str :== quoted-str ':' quoted-str
+   str-str-list :== '[' str-str (',' str-str)* ']'
+   internal-data ::= '{' prim-constants '}'
+   external-data ::= str-str-list
+   constant-data ::= internal-data | external-data
+   value-info-or-initializer ::= type quotable-id [ '=' constant-data ]
+   value-info-or-initializers ::= value-info-or-initializer (',' value-info-or-initializer)*
+   input-list ::= '(' value-info-or-initializers? ')'
+   output-list ::= '(' value-infos? ')'
+   initializer-list ::= '<' value-info-or-initializers? '>'
+   prim-constants ::= prim-constant (',' prim-constant)*
+   tensor-constant ::= tensor-type (quotable-id)? ('=')? '{' prim-constants '}'
+   attr-ref ::= '@' id
+   single-attr-value ::= tensor-constant | graph | prim-constant | attr-ref
+   attr-value-list ::= '[' single-attr-value (',' single-attr-value)* ']'
+   attr-value ::= single-attr-value | attr-value-list
+   attr-type ::= ':' id
+   attr ::= id attr-type? '=' attr-value
+   attr-list ::= '<' attr (',' attr)* '>'
+   node-label ::= '[' quotable-id ']'
+   node ::= node-label? quotable-id-list? '=' qualified-id attr-list? '(' quotable-id-list? ')'
+         |  node-label? quotable-id-list? '=' qualified-id '(' quotable-id-list? ')' attr-list
+   node-list ::= '{' node* '}'
+   graph ::= quotable-id input-list '=>' output-list initializer-list node-list
+   other-data ::= id ':' value
+   other-data-list ::= '<' other-data (',' other-data)* '>'
+   fun-attr-list ::= '<' id | attr (',' id | attr)* '>'
+   fun-input-list ::= '(' id-or-value-infos ')'
+   fun-output-list ::= '(' id-or-value-infos ')'
+   fun-value-infos ::= ( '<' value-infos '>' )?
+   function ::= other-data-list? id fun-attr-list? quotable-id fun-input-list '=>' fun-output-list fun-value-infos node-list
+   model ::= other-data-list? graph function*
+```
diff --git a/docs/TestCoverage-ml.md b/docs/TestCoverage-ml.md
new file mode 100644
index 0000000..89b6771
--- /dev/null
+++ b/docs/TestCoverage-ml.md
@@ -0,0 +1,350 @@
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+# Test Coverage Report (ONNX-ML Operators)
+## Outlines
+* [Node Test Coverage](#node-test-coverage)
+* [Model Test Coverage](#model-test-coverage)
+* [Overall Test Coverage](#overall-test-coverage)
+# Node Test Coverage
+## Summary
+Node tests have covered 4/19 (21.05%, 0 generators excluded) common operators.
+
+Node tests have covered 0/0 (N/A) experimental operators.
+
+* [Covered Common Operators](#covered-common-operators)
+* [No Cover Common Operators](#no-cover-common-operators)
+* [Covered Experimental Operators](#covered-experimental-operators)
+* [No Cover Experimental Operators](#no-cover-experimental-operators)
+
+## &#x1F49A;Covered Common Operators
+### ArrayFeatureExtractor
+There are 1 test cases, listed as following:
+<details>
+<summary>arrayfeatureextractor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ArrayFeatureExtractor",
+    inputs=["x", "y"],
+    outputs=["z"],
+    domain="ai.onnx.ml",
+)
+
+x = np.arange(12).reshape((3, 4)).astype(np.float32)
+y = np.array([0, 1], dtype=np.int64)
+z = np.array([[0, 4, 8], [1, 5, 9]], dtype=np.float32).T
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[z],
+    name="test_ai_onnx_ml_array_feature_extractor",
+)
+```
+
+</details>
+
+
+### Binarizer
+There are 1 test cases, listed as following:
+<details>
+<summary>binarizer</summary>
+
+```python
+threshold = 1.0
+node = onnx.helper.make_node(
+    "Binarizer",
+    inputs=["X"],
+    outputs=["Y"],
+    threshold=threshold,
+    domain="ai.onnx.ml",
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = compute_binarizer(x, threshold)[0]
+
+expect(node, inputs=[x], outputs=[y], name="test_ai_onnx_ml_binarizer")
+```
+
+</details>
+
+
+### LabelEncoder
+There are 2 test cases, listed as following:
+<details>
+<summary>string_int_label_encoder</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LabelEncoder",
+    inputs=["X"],
+    outputs=["Y"],
+    domain="ai.onnx.ml",
+    keys_strings=["a", "b", "c"],
+    values_int64s=[0, 1, 2],
+    default_int64=42,
+)
+x = np.array(["a", "b", "d", "c", "g"]).astype(object)
+y = np.array([0, 1, 42, 2, 42]).astype(np.int64)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_label_encoder_string_int",
+)
+
+node = onnx.helper.make_node(
+    "LabelEncoder",
+    inputs=["X"],
+    outputs=["Y"],
+    domain="ai.onnx.ml",
+    keys_strings=["a", "b", "c"],
+    values_int64s=[0, 1, 2],
+)
+x = np.array(["a", "b", "d", "c", "g"]).astype(object)
+y = np.array([0, 1, -1, 2, -1]).astype(np.int64)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_label_encoder_string_int_no_default",
+)
+```
+
+</details>
+<details>
+<summary>tensor_based_label_encoder</summary>
+
+```python
+tensor_keys = make_tensor(
+    "keys_tensor", onnx.TensorProto.STRING, (3,), ["a", "b", "c"]
+)
+repeated_string_keys = ["a", "b", "c"]
+x = np.array(["a", "b", "d", "c", "g"]).astype(object)
+y = np.array([0, 1, 42, 2, 42]).astype(np.int16)
+
+node = onnx.helper.make_node(
+    "LabelEncoder",
+    inputs=["X"],
+    outputs=["Y"],
+    domain="ai.onnx.ml",
+    keys_tensor=tensor_keys,
+    values_tensor=make_tensor(
+        "values_tensor", onnx.TensorProto.INT16, (3,), [0, 1, 2]
+    ),
+    default_tensor=make_tensor(
+        "default_tensor", onnx.TensorProto.INT16, (1,), [42]
+    ),
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_label_encoder_tensor_mapping",
+)
+
+node = onnx.helper.make_node(
+    "LabelEncoder",
+    inputs=["X"],
+    outputs=["Y"],
+    domain="ai.onnx.ml",
+    keys_strings=repeated_string_keys,
+    values_tensor=make_tensor(
+        "values_tensor", onnx.TensorProto.INT16, (3,), [0, 1, 2]
+    ),
+    default_tensor=make_tensor(
+        "default_tensor", onnx.TensorProto.INT16, (1,), [42]
+    ),
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_label_encoder_tensor_value_only_mapping",
+)
+```
+
+</details>
+
+
+### TreeEnsemble
+There are 2 test cases, listed as following:
+<details>
+<summary>tree_ensemble_set_membership</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TreeEnsemble",
+    ["X"],
+    ["Y"],
+    domain="ai.onnx.ml",
+    n_targets=4,
+    aggregate_function=1,
+    membership_values=make_tensor(
+        "membership_values",
+        onnx.TensorProto.FLOAT,
+        (8,),
+        [1.2, 3.7, 8, 9, np.nan, 12, 7, np.nan],
+    ),
+    nodes_missing_value_tracks_true=None,
+    nodes_hitrates=None,
+    post_transform=0,
+    tree_roots=[0],
+    nodes_modes=make_tensor(
+        "nodes_modes",
+        onnx.TensorProto.UINT8,
+        (3,),
+        np.array([0, 6, 6], dtype=np.uint8),
+    ),
+    nodes_featureids=[0, 0, 0],
+    nodes_splits=make_tensor(
+        "nodes_splits",
+        onnx.TensorProto.FLOAT,
+        (3,),
+        np.array([11, 232344.0, np.nan], dtype=np.float32),
+    ),
+    nodes_trueleafs=[0, 1, 1],
+    nodes_truenodeids=[1, 0, 1],
+    nodes_falseleafs=[1, 0, 1],
+    nodes_falsenodeids=[2, 2, 3],
+    leaf_targetids=[0, 1, 2, 3],
+    leaf_weights=make_tensor(
+        "leaf_weights", onnx.TensorProto.FLOAT, (4,), [1, 10, 1000, 100]
+    ),
+)
+
+x = np.array([1.2, 3.4, -0.12, np.nan, 12, 7], np.float32).reshape(-1, 1)
+expected = np.array(
+    [
+        [1, 0, 0, 0],
+        [0, 0, 0, 100],
+        [0, 0, 0, 100],
+        [0, 0, 1000, 0],
+        [0, 0, 1000, 0],
+        [0, 10, 0, 0],
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[x],
+    outputs=[expected],
+    name="test_ai_onnx_ml_tree_ensemble_set_membership",
+)
+```
+
+</details>
+<details>
+<summary>tree_ensemble_single_tree</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TreeEnsemble",
+    ["X"],
+    ["Y"],
+    domain="ai.onnx.ml",
+    n_targets=2,
+    membership_values=None,
+    nodes_missing_value_tracks_true=None,
+    nodes_hitrates=None,
+    aggregate_function=1,
+    post_transform=0,
+    tree_roots=[0],
+    nodes_modes=make_tensor(
+        "nodes_modes",
+        onnx.TensorProto.UINT8,
+        (3,),
+        np.array([0, 0, 0], dtype=np.uint8),
+    ),
+    nodes_featureids=[0, 0, 0],
+    nodes_splits=make_tensor(
+        "nodes_splits",
+        onnx.TensorProto.DOUBLE,
+        (3,),
+        np.array([3.14, 1.2, 4.2], dtype=np.float64),
+    ),
+    nodes_truenodeids=[1, 0, 1],
+    nodes_trueleafs=[0, 1, 1],
+    nodes_falsenodeids=[2, 2, 3],
+    nodes_falseleafs=[0, 1, 1],
+    leaf_targetids=[0, 1, 0, 1],
+    leaf_weights=make_tensor(
+        "leaf_weights",
+        onnx.TensorProto.DOUBLE,
+        (4,),
+        np.array([5.23, 12.12, -12.23, 7.21], dtype=np.float64),
+    ),
+)
+
+x = np.array([1.2, 3.4, -0.12, 1.66, 4.14, 1.77], np.float64).reshape(3, 2)
+y = np.array([[5.23, 0], [5.23, 0], [0, 12.12]], dtype=np.float64)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_ai_onnx_ml_tree_ensemble_single_tree",
+)
+```
+
+</details>
+
+
+<br/>
+
+## &#x1F494;No Cover Common Operators
+### CastMap (call for test cases)
+
+
+### CategoryMapper (call for test cases)
+
+
+### DictVectorizer (call for test cases)
+
+
+### FeatureVectorizer (call for test cases)
+
+
+### Imputer (call for test cases)
+
+
+### LinearClassifier (call for test cases)
+
+
+### LinearRegressor (call for test cases)
+
+
+### Normalizer (call for test cases)
+
+
+### OneHotEncoder (call for test cases)
+
+
+### SVMClassifier (call for test cases)
+
+
+### SVMRegressor (call for test cases)
+
+
+### Scaler (call for test cases)
+
+
+### TreeEnsembleClassifier (call for test cases)
+
+
+### TreeEnsembleRegressor (call for test cases)
+
+
+### ZipMap (call for test cases)
+
+
+<br/>
+
+## &#x1F49A;Covered Experimental Operators
+<br/>
+
+## &#x1F494;No Cover Experimental Operators
+<br/>
+
+# Model Test Coverage
+No model tests present for selected domain
+# Overall Test Coverage
+## To be filled.
diff --git a/docs/TestCoverage.md b/docs/TestCoverage.md
new file mode 100644
index 0000000..2931494
--- /dev/null
+++ b/docs/TestCoverage.md
@@ -0,0 +1,32001 @@
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+# Test Coverage Report (ONNX Core Operators)
+## Outlines
+* [Node Test Coverage](#node-test-coverage)
+* [Model Test Coverage](#model-test-coverage)
+* [Overall Test Coverage](#overall-test-coverage)
+# Node Test Coverage
+## Summary
+Node tests have covered 189/201 (94.03%, 5 generators excluded) common operators.
+
+Node tests have covered 1/1 (100.00%, 0 generators excluded) experimental operators.
+
+* [Covered Common Operators](#covered-common-operators)
+* [No Cover Common Operators](#no-cover-common-operators)
+* [Covered Experimental Operators](#covered-experimental-operators)
+* [No Cover Experimental Operators](#no-cover-experimental-operators)
+
+## &#x1F49A;Covered Common Operators
+### Abs
+There are 1 test cases, listed as following:
+<details>
+<summary>abs</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Abs",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.abs(x)
+
+expect(node, inputs=[x], outputs=[y], name="test_abs")
+```
+
+</details>
+
+
+### Acos
+There are 1 test cases, listed as following:
+<details>
+<summary>acos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Acos",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-0.5, 0, 0.5]).astype(np.float32)
+y = np.arccos(x)
+expect(node, inputs=[x], outputs=[y], name="test_acos_example")
+
+x = np.random.rand(3, 4, 5).astype(np.float32)
+y = np.arccos(x)
+expect(node, inputs=[x], outputs=[y], name="test_acos")
+```
+
+</details>
+
+
+### Acosh
+There are 1 test cases, listed as following:
+<details>
+<summary>acosh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Acosh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([10, np.e, 1]).astype(np.float32)
+y = np.arccosh(x)  # expected output [2.99322295,  1.65745449,  0.]
+expect(node, inputs=[x], outputs=[y], name="test_acosh_example")
+
+x = np.random.uniform(1.0, 10.0, (3, 4, 5)).astype(np.float32)
+y = np.arccosh(x)
+expect(node, inputs=[x], outputs=[y], name="test_acosh")
+```
+
+</details>
+
+
+### Adagrad
+There are 2 test cases, listed as following:
+<details>
+<summary>adagrad</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+epsilon = 1e-5
+decay_factor = 0.1
+
+# Create operator.
+node = onnx.helper.make_node(
+    "Adagrad",
+    inputs=["R", "T", "X", "G", "H"],
+    outputs=["X_new", "H_new"],
+    norm_coefficient=norm_coefficient,
+    epsilon=epsilon,
+    decay_factor=decay_factor,
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+x = np.array([1.0], dtype=np.float32)
+g = np.array([-1.0], dtype=np.float32)
+h = np.array([2.0], dtype=np.float32)
+
+# Compute expected outputs of Adagrad.
+x_new, h_new = apply_adagrad(
+    r, t, x, g, h, norm_coefficient, epsilon, decay_factor
+)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x, g, h],
+    outputs=[x_new, h_new],
+    name="test_adagrad",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+<details>
+<summary>adagrad_multiple</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+epsilon = 1e-5
+decay_factor = 0.1
+
+node = onnx.helper.make_node(
+    "Adagrad",
+    inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"],
+    outputs=["X1_new", "X2_new", "H1_new", "H2_new"],
+    norm_coefficient=norm_coefficient,
+    epsilon=epsilon,
+    decay_factor=decay_factor,
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+
+x1 = np.array([1.0], dtype=np.float32)
+g1 = np.array([-1.0], dtype=np.float32)
+h1 = np.array([2.0], dtype=np.float32)
+
+x2 = np.array([1.0, 2.0], dtype=np.float32)
+g2 = np.array([-1.0, -3.0], dtype=np.float32)
+h2 = np.array([4.0, 1.0], dtype=np.float32)
+
+# Compute expected outputs of Adagrad.
+x1_new, h1_new = apply_adagrad(
+    r, t, x1, g1, h1, norm_coefficient, epsilon, decay_factor
+)
+x2_new, h2_new = apply_adagrad(
+    r, t, x2, g2, h2, norm_coefficient, epsilon, decay_factor
+)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x1, x2, g1, g2, h1, h2],
+    outputs=[x1_new, x2_new, h1_new, h2_new],
+    name="test_adagrad_multiple",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
+### Adam
+There are 2 test cases, listed as following:
+<details>
+<summary>adam</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+alpha = 0.95
+beta = 0.1
+epsilon = 1e-7
+
+# Create operator.
+node = onnx.helper.make_node(
+    "Adam",
+    inputs=["R", "T", "X", "G", "V", "H"],
+    outputs=["X_new", "V_new", "H_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    epsilon=epsilon,
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+x = np.array([1.2, 2.8], dtype=np.float32)
+g = np.array([-0.94, -2.5], dtype=np.float32)
+v = np.array([1.7, 3.6], dtype=np.float32)
+h = np.array([0.1, 0.1], dtype=np.float32)
+
+# Compute expected outputs of Adam.
+x_new, v_new, h_new = apply_adam(
+    r, t, x, g, v, h, norm_coefficient, 0.0, alpha, beta, epsilon
+)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x, g, v, h],
+    outputs=[x_new, v_new, h_new],
+    name="test_adam",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+<details>
+<summary>adam_multiple</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+alpha = 0.95
+beta = 0.85
+epsilon = 1e-2
+
+node = onnx.helper.make_node(
+    "Adam",
+    inputs=["R", "T", "X1", "X2", "G1", "G2", "V1", "V2", "H1", "H2"],
+    outputs=["X1_new", "X2_new", "V1_new", "V2_new", "H1_new", "H2_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    epsilon=epsilon,
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+
+x1 = np.array([1.0], dtype=np.float32)
+g1 = np.array([-1.0], dtype=np.float32)
+v1 = np.array([2.0], dtype=np.float32)
+h1 = np.array([0.5], dtype=np.float32)
+
+x2 = np.array([1.0, 2.0], dtype=np.float32)
+g2 = np.array([-1.0, -3.0], dtype=np.float32)
+v2 = np.array([4.0, 1.0], dtype=np.float32)
+h2 = np.array([1.0, 10.0], dtype=np.float32)
+
+# Compute expected outputs of Adam.
+x1_new, v1_new, h1_new = apply_adam(
+    r, t, x1, g1, v1, h1, norm_coefficient, 0.0, alpha, beta, epsilon
+)
+x2_new, v2_new, h2_new = apply_adam(
+    r, t, x2, g2, v2, h2, norm_coefficient, 0.0, alpha, beta, epsilon
+)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x1, x2, g1, g2, v1, v2, h1, h2],
+    outputs=[x1_new, x2_new, v1_new, v2_new, h1_new, h2_new],
+    name="test_adam_multiple",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
+### Add
+There are 2 test cases, listed as following:
+<details>
+<summary>add</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Add",
+    inputs=["x", "y"],
+    outputs=["sum"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_int8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint64")
+```
+
+</details>
+<details>
+<summary>add_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Add",
+    inputs=["x", "y"],
+    outputs=["sum"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+expect(node, inputs=[x, y], outputs=[x + y], name="test_add_bcast")
+```
+
+</details>
+
+
+### AffineGrid
+There are 2 test cases, listed as following:
+<details>
+<summary>2d_no_reference_evaluator</summary>
+
+```python
+theta_2d = create_theta_2d()
+N, C, H, W = len(theta_2d), 3, 5, 6
+data_size = (H, W)
+for align_corners in (0, 1):
+    node = onnx.helper.make_node(
+        "AffineGrid",
+        inputs=["theta", "size"],
+        outputs=["grid"],
+        align_corners=align_corners,
+    )
+
+    original_grid = construct_original_grid(data_size, align_corners)
+    grid = apply_affine_transform(theta_2d, original_grid)
+
+    test_name = "test_affine_grid_2d"
+    if align_corners == 1:
+        test_name += "_align_corners"
+    expect(
+        node,
+        inputs=[theta_2d, np.array([N, C, H, W], dtype=np.int64)],
+        outputs=[grid],
+        name=test_name,
+    )
+```
+
+</details>
+<details>
+<summary>3d_no_reference_evaluator</summary>
+
+```python
+theta_3d = create_theta_3d()
+N, C, D, H, W = len(theta_3d), 3, 4, 5, 6
+data_size = (D, H, W)
+for align_corners in (0, 1):
+    node = onnx.helper.make_node(
+        "AffineGrid",
+        inputs=["theta", "size"],
+        outputs=["grid"],
+        align_corners=align_corners,
+    )
+
+    original_grid = construct_original_grid(data_size, align_corners)
+    grid = apply_affine_transform(theta_3d, original_grid)
+
+    test_name = "test_affine_grid_3d"
+    if align_corners == 1:
+        test_name += "_align_corners"
+    expect(
+        node,
+        inputs=[theta_3d, np.array([N, C, D, H, W], dtype=np.int64)],
+        outputs=[grid],
+        name=test_name,
+    )
+```
+
+</details>
+
+
+### And
+There are 2 test cases, listed as following:
+<details>
+<summary>and</summary>
+
+```python
+node = onnx.helper.make_node(
+    "And",
+    inputs=["x", "y"],
+    outputs=["and"],
+)
+
+# 2d
+x = (np.random.randn(3, 4) > 0).astype(bool)
+y = (np.random.randn(3, 4) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and2d")
+
+# 3d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and3d")
+
+# 4d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and4d")
+```
+
+</details>
+<details>
+<summary>and_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "And",
+    inputs=["x", "y"],
+    outputs=["and"],
+)
+
+# 3d vs 1d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(5) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v1d")
+
+# 3d vs 2d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(4, 5) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v2d")
+
+# 4d vs 2d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(5, 6) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v2d")
+
+# 4d vs 3d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(4, 5, 6) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v3d")
+
+# 4d vs 4d
+x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool)
+y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool)
+z = np.logical_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v4d")
+```
+
+</details>
+
+
+### ArgMax
+There are 8 test cases, listed as following:
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax", inputs=["data"], outputs=["result"], keepdims=keepdims
+)
+
+# result: [[1, 1]]
+result = argmax_use_numpy(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_default_axis_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [1, 3, 4]
+result = argmax_use_numpy(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_default_axis_random",
+)
+```
+
+</details>
+<details>
+<summary>default_axes_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax",
+    inputs=["data"],
+    outputs=["result"],
+    keepdims=keepdims,
+    select_last_index=True,
+)
+
+# result: [[1, 1]]
+result = argmax_use_numpy_select_last_index(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_default_axis_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [1, 3, 4]
+result = argmax_use_numpy_select_last_index(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_default_axis_random_select_last_index",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# result: [[0], [1]]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmax_keepdims_example"
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 1, 4]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmax_keepdims_random"
+)
+```
+
+</details>
+<details>
+<summary>keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1], [1]]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 1, 4]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_keepdims_random_select_last_index",
+)
+```
+
+</details>
+<details>
+<summary>negative_axis_keepdims</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = -1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# result: [[0], [1]]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_negative_axis_keepdims_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 3, 1]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_negative_axis_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>negative_axis_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = -1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMax",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1], [1]]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_negative_axis_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 3, 1]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_negative_axis_keepdims_random_select_last_index",
+)
+```
+
+</details>
+<details>
+<summary>no_keepdims</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 0
+node = onnx.helper.make_node(
+    "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# result: [0, 1]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_no_keepdims_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 4]
+result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmax_no_keepdims_random"
+)
+```
+
+</details>
+<details>
+<summary>no_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 0
+node = onnx.helper.make_node(
+    "ArgMax",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [1, 1]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_no_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 4]
+result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmax_no_keepdims_random_select_last_index",
+)
+```
+
+</details>
+
+
+### ArgMin
+There are 8 test cases, listed as following:
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin", inputs=["data"], outputs=["result"], keepdims=keepdims
+)
+
+# The content of result is : [[0], [0]]
+result = argmin_use_numpy(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_default_axis_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [1, 3, 4]
+result = argmin_use_numpy(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_default_axis_random",
+)
+```
+
+</details>
+<details>
+<summary>default_axes_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin",
+    inputs=["data"],
+    outputs=["result"],
+    keepdims=keepdims,
+    select_last_index=True,
+)
+
+# result: [[0, 0]]
+result = argmin_use_numpy_select_last_index(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_default_axis_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [1, 3, 4]
+result = argmin_use_numpy_select_last_index(data, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_default_axis_random_select_last_index",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# The content of result is : [[1], [0]]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmin_keepdims_example"
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 1, 4]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmin_keepdims_random"
+)
+```
+
+</details>
+<details>
+<summary>keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1], [0]]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 1, 4]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_keepdims_random_select_last_index",
+)
+```
+
+</details>
+<details>
+<summary>negative_axis_keepdims</summary>
+
+```python
+data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+axis = -1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# The content of result is : [[1], [0]]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_negative_axis_keepdims_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 3, 1]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_negative_axis_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>negative_axis_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = -1
+keepdims = 1
+node = onnx.helper.make_node(
+    "ArgMin",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1], [0]]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_negative_axis_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 3, 1]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_negative_axis_keepdims_random_select_last_index",
+)
+```
+
+</details>
+<details>
+<summary>no_keepdims</summary>
+
+```python
+data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 0
+node = onnx.helper.make_node(
+    "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+)
+# The content of result is : [[1, 0]]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_no_keepdims_example",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 4]
+result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+expect(
+    node, inputs=[data], outputs=[result], name="test_argmin_no_keepdims_random"
+)
+```
+
+</details>
+<details>
+<summary>no_keepdims_select_last_index</summary>
+
+```python
+data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+axis = 1
+keepdims = 0
+node = onnx.helper.make_node(
+    "ArgMin",
+    inputs=["data"],
+    outputs=["result"],
+    axis=axis,
+    keepdims=keepdims,
+    select_last_index=True,
+)
+# result: [[1, 0]]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_no_keepdims_example_select_last_index",
+)
+
+data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+# result's shape: [2, 4]
+result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+expect(
+    node,
+    inputs=[data],
+    outputs=[result],
+    name="test_argmin_no_keepdims_random_select_last_index",
+)
+```
+
+</details>
+
+
+### Asin
+There are 1 test cases, listed as following:
+<details>
+<summary>asin</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Asin",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-0.5, 0, 0.5]).astype(np.float32)
+y = np.arcsin(x)
+expect(node, inputs=[x], outputs=[y], name="test_asin_example")
+
+x = np.random.rand(3, 4, 5).astype(np.float32)
+y = np.arcsin(x)
+expect(node, inputs=[x], outputs=[y], name="test_asin")
+```
+
+</details>
+
+
+### Asinh
+There are 1 test cases, listed as following:
+<details>
+<summary>asinh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Asinh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.arcsinh(x)  # expected output [-0.88137358,  0.,  0.88137358]
+expect(node, inputs=[x], outputs=[y], name="test_asinh_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.arcsinh(x)
+expect(node, inputs=[x], outputs=[y], name="test_asinh")
+```
+
+</details>
+
+
+### Atan
+There are 1 test cases, listed as following:
+<details>
+<summary>atan</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Atan",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.arctan(x)
+expect(node, inputs=[x], outputs=[y], name="test_atan_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.arctan(x)
+expect(node, inputs=[x], outputs=[y], name="test_atan")
+```
+
+</details>
+
+
+### Atanh
+There are 1 test cases, listed as following:
+<details>
+<summary>atanh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Atanh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-0.5, 0, 0.5]).astype(np.float32)
+y = np.arctanh(x)  # expected output [-0.54930615,  0.,  0.54930615]
+expect(node, inputs=[x], outputs=[y], name="test_atanh_example")
+
+x = np.random.uniform(0.0, 1.0, (3, 4, 5)).astype(np.float32)
+y = np.arctanh(x)
+expect(node, inputs=[x], outputs=[y], name="test_atanh")
+```
+
+</details>
+
+
+### Attention
+There are 76 test cases, listed as following:
+<details>
+<summary>attention</summary>
+
+```python
+node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_23_boolmask_fullymasked_row_nan_robustness</summary>
+
+```python
+"""Opset-23 fully-masked boolean ``attn_mask`` row -> zero (not ``NaN``).
+
+This locks the opset-23 / ``old.cc`` function-body fully-masked-row guard
+against future regressions. In opset 23 the only in-contract fully-masked
+row comes from an all-``False`` boolean ``attn_mask`` row (``is_causal`` is
+not set here): every key for that query is disallowed, so ``softmax`` over an
+all-``-inf`` bias row is ``NaN``. The guard zeros that row's probabilities
+before the ``P @ V`` contraction so the output row is exactly ``0``, while
+rows with at least one allowed key are unchanged.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(4)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(B, H, S, D).astype(np.float32)
+K = np.random.rand(B, H, S, D).astype(np.float32)
+V = np.random.rand(B, H, S, D).astype(np.float32)
+# Row 0: no key allowed -> fully masked (Bug-2 empty row). Row 1: both keys
+# allowed -> finite, unchanged by the guard.
+attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask)
+
+# Fully-masked row 0 is exactly zero (not NaN); every other cell is finite.
+assert np.all(np.isfinite(Y)), "non-masked rows must be finite"
+assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+    "fully-masked row must be zero (Bug-2)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_23_boolmask_fullymasked_row_nan_robustness",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_23_fullymasked_qk_matmul_output_mode3_zero</summary>
+
+```python
+"""Opset-23 ``qk_matmul_output_mode=3`` fully-masked row is a zero row.
+
+Mode ``3`` exposes the post-softmax matrix as the optional
+``qk_matmul_output``.  For a fully-masked query row (all-``False`` boolean
+``attn_mask`` row), the fully-masked-row guard is applied before this output
+is produced, so the mode-3 row is zeroed, consistent with the primary output
+``Y`` row (both are ``0``).  This pins the mandated agreement between the
+guarded primary output and the mode-3 output at opset 23.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(13)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=3,
+)
+
+Q = np.random.rand(B, H, S, D).astype(np.float32)
+K = np.random.rand(B, H, S, D).astype(np.float32)
+V = np.random.rand(B, H, S, D).astype(np.float32)
+# Row 0: no key allowed -> fully masked. Row 1: both keys allowed -> finite.
+attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=3,
+)
+
+# Primary output row 0 and the mode-3 row 0 are both guarded to zero.
+assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+    "fully-masked primary output row must be zero"
+)
+assert np.array_equal(
+    qk_matmul_output[:, :, 0, :], np.zeros_like(qk_matmul_output[:, :, 0, :])
+), "mode-3 output row for a fully-masked query must be zero (consistent with Y)"
+assert np.all(np.isfinite(qk_matmul_output)), (
+    "all mode-3 rows are finite (the fully-masked row is guarded to 0.0)"
+)
+assert np.all(np.isfinite(Y)), (
+    "all Y rows are finite (the fully-masked row is guarded to 0.0)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_23_fullymasked_qk_matmul_output_mode3_zero",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_24_fullymasked_qk_matmul_output_mode3_zero</summary>
+
+```python
+"""Opset-24 ``qk_matmul_output_mode=3`` fully-masked row is a zero row.
+
+The opset-24 twin of
+``export_attention_23_fullymasked_qk_matmul_output_mode3_zero``.  Mode ``3``
+exposes the post-softmax matrix as the optional ``qk_matmul_output``.  For a
+fully-masked query row (all-``False`` boolean ``attn_mask`` row), the
+fully-masked-row guard is applied before this output is produced, so the
+mode-3 row is zeroed, consistent with the primary output ``Y`` row (both are
+``0``).  This pins the mandated agreement between the guarded primary output
+and the mode-3 output at opset 24.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(13)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=3,
+)
+
+Q = np.random.rand(B, H, S, D).astype(np.float32)
+K = np.random.rand(B, H, S, D).astype(np.float32)
+V = np.random.rand(B, H, S, D).astype(np.float32)
+# Row 0: no key allowed -> fully masked. Row 1: both keys allowed -> finite.
+attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=3,
+)
+
+# Primary output row 0 and the mode-3 row 0 are both guarded to zero.
+assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+    "fully-masked primary output row must be zero"
+)
+assert np.array_equal(
+    qk_matmul_output[:, :, 0, :], np.zeros_like(qk_matmul_output[:, :, 0, :])
+), "mode-3 output row for a fully-masked query must be zero (consistent with Y)"
+assert np.all(np.isfinite(qk_matmul_output)), (
+    "all mode-3 rows are finite (the fully-masked row is guarded to 0.0)"
+)
+assert np.all(np.isfinite(Y)), (
+    "all Y rows are finite (the fully-masked row is guarded to 0.0)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_24_fullymasked_qk_matmul_output_mode3_zero",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_24_qk_matmul_output_mode3_softmax_precision</summary>
+
+```python
+"""Mode-3 ``qk_matmul_output`` is emitted at the output precision ``T1``.
+
+``qk_matmul_output_mode=3`` exposes the post-softmax probabilities.  When
+``softmax_precision`` differs from the operator's output type ``T1`` (here
+``T1 = float16`` with softmax computed in ``float32``), the mode-3 output is
+cast back to ``T1`` -- matching the reference implementation, which casts the
+exposed matrix to ``Q.dtype``.  This locks both the dtype contract and the
+fully-masked-row zeroing under a non-default ``softmax_precision``.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(17)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=3,
+    softmax_precision=int(onnx.TensorProto.FLOAT),
+)
+
+# T1 = float16; softmax runs in float32, so the mode-3 output is cast back to
+# float16 on emission.
+Q = np.random.rand(B, H, S, D).astype(np.float16)
+K = np.random.rand(B, H, S, D).astype(np.float16)
+V = np.random.rand(B, H, S, D).astype(np.float16)
+# Row 0: fully masked. Row 1: both keys allowed -> finite.
+attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=3,
+    softmax_precision=int(onnx.TensorProto.FLOAT),
+)
+
+# The mode-3 output is emitted at T1 (float16), not the float32 softmax
+# precision, matching the operator's output type.
+assert qk_matmul_output.dtype == np.float16, (
+    "mode-3 qk_matmul_output must be emitted at the output precision T1 (float16)"
+)
+# The fully-masked row is still guarded to zero, consistent with Y.
+assert np.array_equal(
+    qk_matmul_output[:, :, 0, :], np.zeros_like(qk_matmul_output[:, :, 0, :])
+), "mode-3 output row for a fully-masked query must be zero (consistent with Y)"
+assert np.all(np.isfinite(qk_matmul_output)), (
+    "all mode-3 rows are finite (the fully-masked row is guarded to 0.0)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_24_qk_matmul_output_mode3_softmax_precision",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_attn_mask</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_3d_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_causal</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_diff_head_sizes</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_diff_head_sizes_attn_mask</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_diff_head_sizes_causal</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_diff_head_sizes_scaled</summary>
+
+```python
+scale = 1e-2
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_diff_head_sizes_softcap</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_diff_heads_sizes_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_diff_head_sizes_with_past_and_present</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 30).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_3d_diff_heads_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_gqa</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_gqa",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_gqa_attn_mask</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_3d_gqa_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_gqa_causal</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    is_causal=1,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_gqa_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_gqa_scaled</summary>
+
+```python
+scale = 1e-2
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_gqa_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_gqa_softcap</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_gqa_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_gqa_with_past_and_present</summary>
+
+```python
+q_num_heads, kv_num_heads = 9, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 72).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_3d_gqa_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_scaled</summary>
+
+```python
+scale = 1e-2
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    scale=scale,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_softcap</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    softcap=3.0,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_transpose_verification</summary>
+
+```python
+"""Test case to verify correct 3D to 4D transpose behavior.
+
+This test verifies that 3D inputs are correctly reshaped and transposed
+according to the ONNX specification:
+[batch_size, seq_length, hidden_size] ->
+[batch_size, seq_length, num_heads, head_size] ->
+[batch_size, num_heads, seq_length, head_size]
+"""
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+# Test inputs that will clearly demonstrate the transpose behavior
+batch_size = 1
+q_seq_length = 2
+kv_seq_length = 2
+head_size = 4
+q_hidden_size = q_num_heads * head_size  # 3 * 4 = 12
+kv_hidden_size = kv_num_heads * head_size  # 3 * 4 = 12
+
+# Create structured inputs to verify correct transpose behavior
+# Q has a pattern where each position in hidden dimension has a specific value
+Q = np.zeros((batch_size, q_seq_length, q_hidden_size), dtype=np.float32)
+# Fill Q with pattern: head0=[1,1,1,1], head1=[2,2,2,2], head2=[3,3,3,3]
+for head in range(q_num_heads):
+    start_idx = head * head_size
+    end_idx = start_idx + head_size
+    Q[0, :, start_idx:end_idx] = float(head + 1)
+
+K = np.ones((batch_size, kv_seq_length, kv_hidden_size), dtype=np.float32) * 0.1
+V = np.ones((batch_size, kv_seq_length, kv_hidden_size), dtype=np.float32) * 0.1
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_3d_transpose_verification",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_with_past_and_present</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_3d_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_with_past_and_present_qk_matmul</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_3d_with_past_and_present_qk_matmul",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_with_past_and_present_qk_matmul_bias</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    qk_matmul_output_mode=2,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_3d_with_past_and_present_qk_matmul_bias",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_with_past_and_present_qk_matmul_softcap</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    softcap=2.0,
+    qk_matmul_output_mode=1,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    softcap=2.0,
+    qk_matmul_output_mode=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_3d_with_past_and_present_qk_matmul_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_3d_with_past_and_present_qk_matmul_softmax</summary>
+
+```python
+q_num_heads, kv_num_heads = 3, 3
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    qk_matmul_output_mode=3,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 4, 24).astype(np.float32)
+K = np.random.rand(2, 6, 24).astype(np.float32)
+V = np.random.rand(2, 6, 24).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    q_num_heads=q_num_heads,
+    kv_num_heads=kv_num_heads,
+    qk_matmul_output_mode=3,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_3d_with_past_and_present_qk_matmul_softmax",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_4d_causal_nonpad_attn_mask_composition</summary>
+
+```python
+"""Compose ``is_causal`` + ``nonpad_kv_seqlen`` + boolean ``attn_mask``.
+
+The existing nonpad tests use no ``attn_mask`` and the existing mask tests
+use no ``nonpad_kv_seqlen``; this is the first to activate all three
+constraints together on the external-cache path with ``batch > 1``.  The
+three biases are summed additively and a key is attended only if allowed by
+all three.  Crucially the inputs are designed so that **each constraint is
+independently necessary** -- removing any one changes the golden -- to avoid a
+degenerate test that a backend ignoring ``is_causal`` and/or
+``nonpad_kv_seqlen`` could still pass:
+
+* **``is_causal`` binds.**  Each batch has a key that the boolean mask allows
+  (``True``) but the bottom-right causal frontier disallows
+  (``j > i + offset``); only ``is_causal`` masks it (batch 0 row 0 key 2,
+  batch 1 row 0 key 3).
+* **``attn_mask`` binds.**  Each batch has a key the causal frontier and the
+  padding bound both allow but the boolean mask sets ``False`` (batch 0 row 2
+  key 1, batch 1 row 2 key 2); only the mask masks it.
+* **``nonpad_kv_seqlen`` binds.**  ``nonpad_kv_seqlen`` sets the per-batch
+  causal *offset* (``offset = nonpad_kv_seqlen - q_sequence_length``), so
+  dropping it collapses the frontier to top-left (``offset = 0``) and shifts
+  which keys are attended.  (Under ``is_causal=1`` the causal frontier already
+  subsumes the ``j < nonpad`` padding bound, so ``nonpad_kv_seqlen`` binds
+  through the offset it induces rather than through a redundant padding cut.)
+
+The mask is chosen to leave at least one allowed key on every query row, so
+this exercises the *intersection* of the three constraints with finite outputs
+(the fully-masked-row guard is covered by
+``test_attention_4d_causal_nonpad_negative_offset_structural_empty`` and
+``test_attention_24_fullymasked_qk_matmul_output_mode3_zero``).
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(11)
+B, H, L, D = 2, 2, 6, 8
+S_q = 3
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, L, D).astype(np.float32)
+V = np.random.rand(B, H, L, D).astype(np.float32)
+nonpad_kv_seqlen = np.array([4, 5], dtype=np.int64)  # offsets [1, 2]
+# Per-batch (B, 1, S_q, L) bool mask. Each batch is laid out so all three
+# constraints uniquely bind (see the docstring): a causal-only-masked key
+# (mask True, j > i + offset), a mask-only-masked key (mask False, causal +
+# nonpad allow it), and >=1 allowed key per row.
+attn_mask = np.array(
+    [
+        [
+            [
+                [True, True, True, False, False, False],
+                [True, True, True, False, False, False],
+                [True, False, True, True, False, False],
+            ]
+        ],
+        [
+            [
+                [True, True, True, True, False, False],
+                [True, True, True, True, False, False],
+                [True, True, False, True, True, False],
+            ]
+        ],
+    ],
+    dtype=np.bool_,
+)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+# The chosen mask leaves >=1 allowed key per row, so the composition stays
+# finite (no fully-masked row in this case).
+assert np.all(np.isfinite(Y)), "composed-constraint output must be finite"
+
+# Non-degeneracy: each constraint is independently necessary. Removing any one
+# of the three (is_causal, attn_mask, nonpad_kv_seqlen) must change the result,
+# so a backend that ignores is_causal or nonpad_kv_seqlen cannot reproduce the
+# golden by applying only the most restrictive mask.
+y_no_causal, _, _, _ = _compute_attention(
+    Q, K, V, attn_mask=attn_mask, nonpad_kv_seqlen=nonpad_kv_seqlen, is_causal=0
+)
+y_no_mask, _, _, _ = _compute_attention(
+    Q, K, V, nonpad_kv_seqlen=nonpad_kv_seqlen, is_causal=1
+)
+y_no_nonpad, _, _, _ = _compute_attention(
+    Q, K, V, attn_mask=attn_mask, is_causal=1
+)
+assert not np.allclose(Y, y_no_causal, equal_nan=True), (
+    "is_causal must bind: dropping it changes the result"
+)
+assert not np.allclose(Y, y_no_mask, equal_nan=True), (
+    "attn_mask must bind: dropping it changes the result"
+)
+assert not np.allclose(Y, y_no_nonpad, equal_nan=True), (
+    "nonpad_kv_seqlen must bind (via the causal offset): dropping it changes the result"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_causal_nonpad_attn_mask_composition",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_4d_causal_nonpad_batch_prefill</summary>
+
+```python
+"""Batch>1 continued prefill with distinct per-batch bottom-right offsets.
+
+The batched generalization of the ``batch == 1`` continued-prefill case: with
+``nonpad_kv_seqlen = [4, 5, 6]`` and ``S_q = 2`` the per-batch bottom-right
+offsets are ``[2, 3, 4]`` (all ``>= 0``), so each batch realigns its causal
+frontier to its own valid-key prefix.  This pins that the per-batch offset is
+applied independently across the batch dimension.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(12)
+B, H, L, D = 3, 2, 6, 8
+S_q = 2
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, L, D).astype(np.float32)
+V = np.random.rand(B, H, L, D).astype(np.float32)
+nonpad_kv_seqlen = np.array([4, 5, 6], dtype=np.int64)  # offsets [2, 3, 4]
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+assert np.all(np.isfinite(Y)), "per-batch prefill output must be finite"
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_causal_nonpad_batch_prefill",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_4d_causal_nonpad_continued_prefill</summary>
+
+```python
+"""Continued / chunked prefill (S_q=2) into a partially-filled static cache.
+
+With ``nonpad_kv_seqlen = [4]`` and ``S_q = 2`` the bottom-right offset is
+``4 - 2 = 2``: query 0 attends keys ``{0,1,2}`` and query 1 attends
+``{0,1,2,3}``.  The old top-left alignment would mask everything past the
+diagonal (``{0}`` and ``{0,1}``), so this test fails pre-fix.
+"""
+np.random.seed(1)
+B, H, L, D = 1, 2, 4, 8
+S_q = 2
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, L, D).astype(np.float32)
+V = np.random.rand(B, H, L, D).astype(np.float32)
+nonpad_kv_seqlen = np.array([4], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_causal_nonpad_continued_prefill",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_4d_causal_nonpad_negative_offset_structural_empty</summary>
+
+```python
+"""Negative bottom-right offset: structurally-empty early query rows -> zero.
+
+This is the onnx-node twin of the ORT gtest
+``Attention_Causal_NonPadKVSeqLen_StructuralEmptyRow_Zero`` /
+``StructuralEmptyRows_Zero_CUDA``.  With ``nonpad_kv_seqlen = [2]`` and
+``S_q = 4`` the bottom-right offset is ``2 - 4 = -2``: query row ``sq``
+attends keys ``0..(sq - 2)``, so rows 0 and 1 have an empty key set.  Their
+``softmax`` over an all-``-inf`` bias row is ``NaN``; the fully-masked-row
+guard zeros those rows before the ``P @ V`` contraction so the output rows are
+exactly ``0``, while rows 2 and 3 (attending keys ``{0}`` and ``{0,1}``) stay finite
+and nonzero.  A ``nonpad_kv_seqlen[b] < q_sequence_length`` input is out of
+the contract's intended use, but its result is still well-defined (zeroed
+rows) rather than ``NaN``; this test pins that defined behavior.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(7)
+B, H, L, D = 1, 2, 4, 8
+S_q = 4
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, L, D).astype(np.float32)
+V = np.random.rand(B, H, L, D).astype(np.float32)
+# offset = nonpad - S_q = 2 - 4 = -2 -> rows 0,1 structurally empty.
+nonpad_kv_seqlen = np.array([2], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+# Structurally-empty early rows are exactly zero (not NaN); later rows finite.
+assert np.all(np.isfinite(Y)), "all output rows must be finite"
+assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+    "structurally-empty row 0 must be zero"
+)
+assert np.array_equal(Y[:, :, 1, :], np.zeros_like(Y[:, :, 1, :])), (
+    "structurally-empty row 1 must be zero"
+)
+assert np.any(Y[:, :, 2, :] != 0) and np.any(Y[:, :, 3, :] != 0), (
+    "rows with a non-empty key set must be nonzero"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_causal_nonpad_negative_offset_structural_empty",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_4d_causal_with_past_and_present</summary>
+
+```python
+"""Regression guard: internal (past_key) cache + is_causal.
+
+This exercises the unchanged scalar bottom-right path (offset =
+past_sequence_length).  Its golden output must remain identical to the
+pre-fix behavior, proving the external-cache change does not touch the
+past_key path.
+"""
+np.random.seed(2)
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+    is_causal=1,
+)
+
+past_sequence_length = 3
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 4, 8).astype(np.float32)
+V = np.random.rand(2, 3, 4, 8).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    past_key=past_key,
+    past_value=past_value,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_causal_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_4d_diff_heads_mask4d_padded_kv</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 4).astype(np.float32)
+nonpad_kv_seqlen = np.array([3, 4], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_mask4d_padded_kv",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_4d_gqa_causal_nonpad_decode</summary>
+
+```python
+"""External/static-cache decode (S_q=1) with per-batch valid lengths.
+
+K/V are the full static cache buffer; ``nonpad_kv_seqlen`` marks how many
+leading keys are valid per batch.  With bottom-right (offset-aware) causal
+masking the single decode query attends keys ``0..nonpad[b]-1``.  Under the
+old top-left alignment it would attend only key 0, so this test fails
+pre-fix and passes post-fix.
+"""
+np.random.seed(0)
+B, H_q, H_kv, L, D = 2, 4, 2, 8, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H_q, 1, D).astype(np.float32)
+K = np.random.rand(B, H_kv, L, D).astype(np.float32)
+V = np.random.rand(B, H_kv, L, D).astype(np.float32)
+# Batch 0 has all 8 keys valid, batch 1 only the first 5.
+nonpad_kv_seqlen = np.array([8, 5], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_gqa_causal_nonpad_decode",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_4d_gqa_causal_nonpad_decode_fp16</summary>
+
+```python
+"""fp16 variant of the external-cache decode case (locks -inf dtype handling)."""
+np.random.seed(0)
+B, H_q, H_kv, L, D = 2, 4, 2, 8, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H_q, 1, D).astype(np.float16)
+K = np.random.rand(B, H_kv, L, D).astype(np.float16)
+V = np.random.rand(B, H_kv, L, D).astype(np.float16)
+nonpad_kv_seqlen = np.array([8, 5], dtype=np.int64)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    nonpad_kv_seqlen=nonpad_kv_seqlen,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, nonpad_kv_seqlen],
+    outputs=[Y],
+    name="test_attention_4d_gqa_causal_nonpad_decode_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_attn_3d_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_3d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_attn_3d_mask_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_3d_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_attn_4d_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_4d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_attn_4d_mask_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_4d_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_attn_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_attn_mask_bool</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(bool)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_bool",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_attn_mask_bool_4d</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6).astype(bool)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_attn_mask_bool_4d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, is_causal=1)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_causal_boolmask_nan_robustness</summary>
+
+```python
+"""Composed ``is_causal`` + boolean ``attn_mask`` NaN-robustness.
+
+The causal frontier (lower-triangular here, offset 0) and the boolean
+``attn_mask`` are intersected: a key is attended only if allowed by both.
+This exercises two pre-fix NaN sources on the same forward pass:
+
+* **Bug-1 (allowed cells stay finite).**  Query 0 is allowed key 0 by both
+  the causal frontier (``{0}``) and the mask (``True`` at key 0).  The old
+  ``(1 - attn_mask) * -inf`` conversion computes ``0 * -inf = NaN`` at that
+  allowed cell, poisoning the row.  The select conversion
+  ``where(attn_mask, 0, -inf)`` keeps it finite.
+* **Bug-2 (fully-masked row -> 0).**  Query 1 is allowed keys ``{0, 1}`` by
+  the causal frontier but the mask is ``False`` at both, so the combined
+  constraint allows no key.  ``softmax`` of an all-``-inf`` row is ``NaN``;
+  the fully-masked-row guard zeros it before the ``P @ V`` contraction so
+  the output row is ``0``.
+
+4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+them would make the function body treat the input as 3D).
+"""
+np.random.seed(3)
+B, H, S, D = 1, 2, 2, 8
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(B, H, S, D).astype(np.float32)
+K = np.random.rand(B, H, S, D).astype(np.float32)
+V = np.random.rand(B, H, S, D).astype(np.float32)
+# Row 0: key 0 allowed (Bug-1 allowed cell). Row 1: no key allowed -> fully
+# masked once intersected with the causal frontier (Bug-2 empty row).
+attn_mask = np.array([[True, False], [False, False]], dtype=np.bool_)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    is_causal=1,
+)
+
+# Bug-1: allowed cells are finite (no NaN anywhere). Bug-2: the fully-masked
+# query row is exactly zero, not NaN.
+assert np.all(np.isfinite(Y)), "allowed cells must be finite (Bug-1)"
+assert np.array_equal(Y[:, :, 1, :], np.zeros_like(Y[:, :, 1, :])), (
+    "fully-masked row must be zero (Bug-2)"
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_causal_boolmask_nan_robustness",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+<details>
+<summary>attention_diff_head_sizes</summary>
+
+```python
+node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_diff_head_sizes_attn_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_diff_head_sizes_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_diff_head_sizes_scaled</summary>
+
+```python
+scale = 1e-2
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, scale=scale)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_diff_head_sizes_softcap</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=2.0,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    softcap=2.0,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_diff_heads_sizes_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_diff_head_sizes_with_past_and_present</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_diff_heads_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_diff_head_sizes_with_past_and_present_mask3D</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_diff_heads_with_past_and_present_mask3d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_diff_head_sizes_with_past_and_present_mask4D</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_diff_heads_with_past_and_present_mask4d",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_fp16</summary>
+
+```python
+node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float16)
+K = np.random.rand(2, 3, 6, 8).astype(np.float16)
+V = np.random.rand(2, 3, 6, 8).astype(np.float16)
+
+Y, _, _, _ = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_gqa</summary>
+
+```python
+node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_gqa",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_gqa_attn_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+)
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_gqa_attn_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_gqa_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    is_causal=1,
+)
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, is_causal=1)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_gqa_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_gqa_scaled</summary>
+
+```python
+scale = 1e-2
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+)
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, scale=scale)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_gqa_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_gqa_softcap</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=2.0,
+)
+
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, softcap=2.0)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_gqa_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_gqa_with_past_and_present</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_gqa_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_gqa_with_past_and_present_fp16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 9, 4, 8).astype(np.float16)
+K = np.random.rand(2, 3, 6, 8).astype(np.float16)
+V = np.random.rand(2, 3, 6, 8).astype(np.float16)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float16)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float16)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float16)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_gqa_with_past_and_present_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_scaled</summary>
+
+```python
+scale = 1e-2
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, scale=scale)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_scaled",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_softcap</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    softcap=2.0,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, _ = _compute_attention(Q, K, V, softcap=2.0)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_attention_4d_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_softcap_with_neginf_mask</summary>
+
+```python
+"""Softcap + -inf mask: verifies softcap is applied BEFORE mask/bias.
+
+If ordering were wrong (mask then softcap), tanh(-inf/softcap) = -1,
+so softcap * tanh(-inf/softcap) = -softcap (finite).  That leaks
+probability to masked positions.  With correct ordering (softcap then
+mask), the -inf mask values survive to softmax and yield zero weight.
+"""
+np.random.seed(42)
+B, H, S_q, S_kv, D = 1, 1, 4, 6, 8
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, S_kv, D).astype(np.float32)
+V = np.random.rand(B, H, S_kv, D).astype(np.float32)
+
+# All Q positions are blocked from KV positions 4 and 5.
+attn_mask = np.zeros((S_q, S_kv), dtype=np.float32)
+attn_mask[:, 4:] = -np.inf
+
+softcap = 0.5
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    softcap=softcap,
+)
+
+Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask, softcap=softcap)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_softcap_neginf_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_softcap_with_neginf_mask_poison</summary>
+
+```python
+"""Softcap + -inf mask + poison values at masked KV positions.
+
+V has value 1000 at the masked positions (4 and 5).  With correct
+ordering the output stays in [0, 1] because the mask zeros out those
+positions.  With wrong ordering the output explodes (> 50), making
+the failure obvious even with loose tolerances.
+"""
+np.random.seed(42)
+B, H, S_q, S_kv, D = 1, 1, 4, 6, 8
+
+Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+K = np.random.rand(B, H, S_kv, D).astype(np.float32)
+V = np.random.rand(B, H, S_kv, D).astype(np.float32)
+
+# Block all Q positions from KV positions 4 and 5.
+attn_mask = np.zeros((S_q, S_kv), dtype=np.float32)
+attn_mask[:, 4:] = -np.inf
+
+# Poison: if attention leaks to masked positions, output >> 1.
+V[:, :, 4:, :] = 1000.0
+
+softcap = 0.5
+
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y"],
+    softcap=softcap,
+)
+
+Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask, softcap=softcap)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y],
+    name="test_attention_4d_softcap_neginf_mask_poison",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_past_and_present</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, _ = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value],
+    name="test_attention_4d_with_past_and_present",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_past_and_present_qk_matmul</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias_3d_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias_3d_mask_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+    is_causal=1,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias_4d_mask</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_past_and_present_qk_matmul_bias_4d_mask_causal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+    outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+    is_causal=1,
+)
+
+past_sequence_length = 12
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32)
+past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+Y, present_key, present_value, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    past_key=past_key,
+    past_value=past_value,
+    qk_matmul_output_mode=2,
+    is_causal=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask, past_key, past_value],
+    outputs=[Y, present_key, present_value, qk_matmul_output],
+    name="test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_qk_matmul</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+Y, _, _, qk_matmul_output = _compute_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_4d_with_qk_matmul",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_qk_matmul_bias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=2,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=2,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_4d_with_qk_matmul_bias",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_qk_matmul_softcap</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    softcap=2.0,
+    qk_matmul_output_mode=1,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    softcap=2.0,
+    qk_matmul_output_mode=1,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_4d_with_qk_matmul_softcap",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+<details>
+<summary>attention_with_qk_matmul_softmax</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Attention",
+    inputs=["Q", "K", "V", "attn_mask"],
+    outputs=["Y", "", "", "qk_matmul_output"],
+    qk_matmul_output_mode=3,
+)
+
+Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+Y, _, _, qk_matmul_output = _compute_attention(
+    Q,
+    K,
+    V,
+    attn_mask=attn_mask,
+    qk_matmul_output_mode=3,
+)
+
+expect(
+    node,
+    inputs=[Q, K, V, attn_mask],
+    outputs=[Y, qk_matmul_output],
+    name="test_attention_4d_with_qk_matmul_softmax",
+    opset_imports=[onnx.helper.make_opsetid("", 23)],
+)
+```
+
+</details>
+
+
+### AveragePool
+There are 17 test cases, listed as following:
+<details>
+<summary>averagepool_1d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32]
+output_shape: [1, 3, 31]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2],
+)
+x = np.random.randn(1, 3, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2]
+strides = [1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG")
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_1d_default")
+```
+
+</details>
+<details>
+<summary>averagepool_2d_ceil</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+    ceil_mode=True,
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[6, 7.5], [12, 13.5]]]]).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_ceil")
+```
+
+</details>
+<details>
+<summary>averagepool_2d_ceil_last_window_starts_on_pad</summary>
+
+```python
+"""input_shape: [1, 3, 2, 2]
+output_shape: [1, 3, 1, 1]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[3, 3],
+    pads=[1, 1, 1, 1],
+    ceil_mode=True,
+    count_include_pad=1,
+)
+x = np.array(
+    [
+        [
+            [[0.8580, 0.0786], [0.2692, 0.1537]],
+            [[0.8816, 0.4353], [0.5772, 0.6623]],
+            [[0.9067, 0.9483], [0.5970, 0.7630]],
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[0.1511]], [[0.2841]], [[0.3572]]]]).astype(np.float32)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_ceil_last_window_starts_on_pad",
+)
+```
+
+</details>
+<details>
+<summary>averagepool_2d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 31, 31]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG")
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_default")
+```
+
+</details>
+<details>
+<summary>averagepool_2d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[1, 1],
+    dilations=[2, 2],
+    ceil_mode=True,
+)
+
+# input shape: [1, 1, 4, 4]
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+y = np.array([[[[6, 7], [10, 11]]]]).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_dilations")
+```
+
+</details>
+<details>
+<summary>averagepool_2d_pads</summary>
+
+```python
+"""input_shape: [1, 3, 28, 28]
+output_shape: [1, 3, 30, 30]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[2, 2, 2, 2],
+)
+x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (3, 3)
+strides = (1, 1)
+pad_bottom = 2
+pad_top = 2
+pad_right = 2
+pad_left = 2
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+out_shape, extra_pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides, ceil_mode=False
+)
+padded = np.pad(
+    x,
+    (
+        (0, 0),
+        (0, 0),
+        (extra_pads[0], extra_pads[2]),
+        (extra_pads[1], extra_pads[3]),
+    ),
+    mode="constant",
+    constant_values=np.nan,
+)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=extra_pads,
+    pads=pads,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_pads")
+```
+
+</details>
+<details>
+<summary>averagepool_2d_pads_count_include_pad</summary>
+
+```python
+"""input_shape: [1, 3, 28, 28]
+output_shape: [1, 3, 30, 30]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[2, 2, 2, 2],
+    count_include_pad=1,
+)
+x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+x_shape = np.shape(x)
+dilations = (1, 1)
+kernel_shape = (3, 3)
+strides = (1, 1)
+pad_bottom = 2
+pad_top = 2
+pad_right = 2
+pad_left = 2
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+out_shape, extra_pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides, dilations, ceil_mode=False
+)
+padded = np.pad(
+    x,
+    (
+        (0, 0),
+        (0, 0),
+        (extra_pads[0], extra_pads[2]),
+        (extra_pads[1], extra_pads[3]),
+    ),
+    mode="constant",
+    constant_values=0,
+)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=extra_pads,
+    pads=pads,
+    count_include_pad=1,
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_pads_count_include_pad",
+)
+```
+
+</details>
+<details>
+<summary>averagepool_2d_precomputed_pads</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array(
+    [
+        [
+            [
+                [7, 7.5, 8, 8.5, 9],
+                [9.5, 10, 10.5, 11, 11.5],
+                [12, 12.5, 13, 13.5, 14],
+                [14.5, 15, 15.5, 16, 16.5],
+                [17, 17.5, 18, 18.5, 19],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_averagepool_2d_precomputed_pads"
+)
+```
+
+</details>
+<details>
+<summary>averagepool_2d_precomputed_pads_count_include_pad</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+    count_include_pad=1,
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array(
+    [
+        [
+            [
+                [2.5200, 3.6000, 4.8000, 4.0800, 3.2400],
+                [4.5600, 6.4000, 8.4000, 7.0400, 5.5200],
+                [7.2000, 10.0000, 13.0000, 10.8000, 8.4000],
+                [6.9600, 9.6000, 12.4000, 10.2400, 7.9200],
+                [6.1200, 8.4000, 10.8000, 8.8800, 6.8400],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_precomputed_pads_count_include_pad",
+)
+```
+
+</details>
+<details>
+<summary>averagepool_2d_precomputed_same_upper</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 3, 3]
+pad_shape: [2, 2] -> [1, 1, 1, 1] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+    auto_pad="SAME_UPPER",
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[4, 5.5, 7], [11.5, 13, 14.5], [19, 20.5, 22]]]]).astype(
+    np.float32
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_precomputed_same_upper",
+)
+```
+
+</details>
+<details>
+<summary>averagepool_2d_precomputed_strides</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[4, 6], [14, 16]]]]).astype(np.float32)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_averagepool_2d_precomputed_strides",
+)
+```
+
+</details>
+<details>
+<summary>averagepool_2d_same_lower</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_LOWER",
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_bottom = pad_shape[0] // 2
+pad_top = pad_shape[0] - pad_bottom
+pad_right = pad_shape[1] // 2
+pad_left = pad_shape[1] - pad_right
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+pads = (pad_top, pad_left, pad_bottom, pad_right)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=pads,
+    pads=pads,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_lower")
+```
+
+</details>
+<details>
+<summary>averagepool_2d_same_upper</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_UPPER",
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_top = pad_shape[0] // 2
+pad_bottom = pad_shape[0] - pad_top
+pad_left = pad_shape[1] // 2
+pad_right = pad_shape[1] - pad_left
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+pads = (pad_top, pad_left, pad_bottom, pad_right)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=pads,
+    pads=pads,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_upper")
+```
+
+</details>
+<details>
+<summary>averagepool_2d_strides</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 10, 10]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    strides=[3, 3],
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (5, 5)
+strides = (3, 3)
+out_shape, pads = get_output_shape_explicit_padding(
+    None, x_shape[2:], kernel_shape, strides, ceil_mode=False
+)
+padded = x
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "AVG",
+    pads_required=pads,
+    pads=None,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_strides")
+```
+
+</details>
+<details>
+<summary>averagepool_3d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32, 32]
+output_shape: [1, 3, 31, 31, 31]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+)
+x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2, 2, 2]
+strides = [1, 1, 1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG")
+
+expect(node, inputs=[x], outputs=[y], name="test_averagepool_3d_default")
+```
+
+</details>
+<details>
+<summary>averagepool_3d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "AveragePool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+    strides=[1, 1, 1],
+    dilations=[2, 2, 2],
+    ceil_mode=True,
+)
+
+# input shape: [1, 1, 4, 4, 4]
+x = np.array(
+    [
+        [
+            [
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+y = np.array([[[[[6, 7], [10, 11]], [[6, 7], [10, 11]]]]]).astype(np.float32)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_averagepool_3d_dilations_small"
+)
+```
+
+</details>
+<details>
+<summary>averagepool_3d_dilations_large</summary>
+
+```python
+x_shape = (32, 32, 32)
+dilations = (2, 2, 2)
+kernel_shape = (5, 5, 5)
+strides = (3, 3, 3)
+count_include_pad = 0
+
+for count_include_pad in (0, 1):
+    for ceil_mode in (True, False):
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=kernel_shape,
+            strides=strides,
+            dilations=dilations,
+            count_include_pad=count_include_pad,
+            ceil_mode=ceil_mode,
+        )
+
+        x = np.random.randn(1, 1, *x_shape).astype(np.float32)
+        out_shape, extra_pads = get_output_shape_explicit_padding(
+            None,
+            x_shape,
+            kernel_shape,
+            strides,
+            dilations=dilations,
+            ceil_mode=ceil_mode,
+        )
+        padded = np.pad(
+            x,
+            (
+                (0, 0),
+                (0, 0),
+                (extra_pads[0], extra_pads[3]),
+                (extra_pads[1], extra_pads[4]),
+                (extra_pads[2], extra_pads[5]),
+            ),
+            mode="constant",
+            constant_values=0 if count_include_pad == 1 else np.nan,
+        )
+        y = pool(
+            padded,
+            (1, 1, *x_shape),
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=extra_pads,
+            pads=None,
+            dilations=dilations,
+            count_include_pad=count_include_pad,
+        )
+
+        test_name = f"test_averagepool_3d_dilations_large_count_include_pad_is_{count_include_pad}_ceil_mode_is_{ceil_mode}"
+        expect(node, inputs=[x], outputs=[y], name=test_name)
+```
+
+</details>
+
+
+### BatchNormalization
+There are 2 test cases, listed as following:
+<details>
+<summary>batchnormalization</summary>
+
+```python
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+mean = np.random.randn(3).astype(np.float32)
+var = np.random.rand(3).astype(np.float32)
+y = _batchnorm_test_mode(x, s, bias, mean, var).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "BatchNormalization",
+    inputs=["x", "s", "bias", "mean", "var"],
+    outputs=["y"],
+)
+
+# output size: (2, 3, 4, 5)
+expect(
+    node,
+    inputs=[x, s, bias, mean, var],
+    outputs=[y],
+    name="test_batchnorm_example",
+)
+
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+mean = np.random.randn(3).astype(np.float32)
+var = np.random.rand(3).astype(np.float32)
+epsilon = 1e-2
+y = _batchnorm_test_mode(x, s, bias, mean, var, epsilon).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "BatchNormalization",
+    inputs=["x", "s", "bias", "mean", "var"],
+    outputs=["y"],
+    epsilon=epsilon,
+)
+
+# output size: (2, 3, 4, 5)
+expect(
+    node,
+    inputs=[x, s, bias, mean, var],
+    outputs=[y],
+    name="test_batchnorm_epsilon",
+)
+```
+
+</details>
+<details>
+<summary>train</summary>
+
+```python
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+mean = np.random.randn(3).astype(np.float32)
+var = np.random.rand(3).astype(np.float32)
+# using np.bool(1) while generating test data with "'bool' object has no attribute 'dtype'"
+# working around by using np.byte(1).astype(bool)
+training_mode = 1
+y, output_mean, output_var = _batchnorm_training_mode(x, s, bias, mean, var)
+
+node = onnx.helper.make_node(
+    "BatchNormalization",
+    inputs=["x", "s", "bias", "mean", "var"],
+    outputs=["y", "output_mean", "output_var"],
+    training_mode=training_mode,
+)
+
+# output size: (2, 3, 4, 5)
+expect(
+    node,
+    inputs=[x, s, bias, mean, var],
+    outputs=[y, output_mean, output_var],
+    name="test_batchnorm_example_training_mode",
+)
+
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+mean = np.random.randn(3).astype(np.float32)
+var = np.random.rand(3).astype(np.float32)
+training_mode = 1
+momentum = 0.9
+epsilon = 1e-2
+y, output_mean, output_var = _batchnorm_training_mode(
+    x, s, bias, mean, var, momentum, epsilon
+)
+
+node = onnx.helper.make_node(
+    "BatchNormalization",
+    inputs=["x", "s", "bias", "mean", "var"],
+    outputs=["y", "output_mean", "output_var"],
+    epsilon=epsilon,
+    training_mode=training_mode,
+)
+
+# output size: (2, 3, 4, 5)
+expect(
+    node,
+    inputs=[x, s, bias, mean, var],
+    outputs=[y, output_mean, output_var],
+    name="test_batchnorm_epsilon_training_mode",
+)
+```
+
+</details>
+
+
+### Bernoulli
+There are 3 test cases, listed as following:
+<details>
+<summary>bernoulli_with_dtype</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Bernoulli",
+    inputs=["x"],
+    outputs=["y"],
+    dtype=onnx.TensorProto.DOUBLE,
+)
+
+x = np.random.uniform(0.0, 1.0, 10).astype(np.float32)
+y = bernoulli_reference_implementation(x, float)
+expect(node, inputs=[x], outputs=[y], name="test_bernoulli_double")
+```
+
+</details>
+<details>
+<summary>bernoulli_with_seed</summary>
+
+```python
+seed = float(0)
+node = onnx.helper.make_node(
+    "Bernoulli",
+    inputs=["x"],
+    outputs=["y"],
+    seed=seed,
+)
+
+x = np.random.uniform(0.0, 1.0, 10).astype(np.float32)
+y = bernoulli_reference_implementation(x, np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_bernoulli_seed")
+```
+
+</details>
+<details>
+<summary>bernoulli_without_dtype</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Bernoulli",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.uniform(0.0, 1.0, 10).astype(float)
+y = bernoulli_reference_implementation(x, float)
+expect(node, inputs=[x], outputs=[y], name="test_bernoulli")
+```
+
+</details>
+
+
+### BitCast
+There are 10 test cases, listed as following:
+<details>
+<summary>bitcast_2d_float32_to_int32</summary>
+
+```python
+"""Test bitcasting 2D array from float32 to int32."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT32,
+)
+x = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float32)
+y = x.view(np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_2d_float32_to_int32")
+```
+
+</details>
+<details>
+<summary>bitcast_bool_to_uint8</summary>
+
+```python
+"""Test bitcasting from bool to uint8 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.UINT8,
+)
+x = np.array([True, False, True, False], dtype=np.bool_)
+y = x.view(np.uint8)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_bool_to_uint8")
+```
+
+</details>
+<details>
+<summary>bitcast_float32_to_int32</summary>
+
+```python
+"""Test bitcasting from float32 to int32 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT32,
+)
+x = np.array([1.0, -2.5, 3.75], dtype=np.float32)
+y = x.view(np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_float32_to_int32")
+```
+
+</details>
+<details>
+<summary>bitcast_float64_to_int64</summary>
+
+```python
+"""Test bitcasting from float64 to int64 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT64,
+)
+x = np.array([1.0, -2.5, 3.75], dtype=np.float64)
+y = x.view(np.int64)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_float64_to_int64")
+```
+
+</details>
+<details>
+<summary>bitcast_int32_to_float32</summary>
+
+```python
+"""Test bitcasting from int32 to float32 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.FLOAT,
+)
+x = np.array([1065353216, -1071644672, 1081081856], dtype=np.int32)
+y = x.view(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_int32_to_float32")
+```
+
+</details>
+<details>
+<summary>bitcast_int64_to_float64</summary>
+
+```python
+"""Test bitcasting from int64 to float64 (same size)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.DOUBLE,
+)
+x = np.array(
+    [4607182418800017408, -4611686018427387904, 4614256656552045184],
+    dtype=np.int64,
+)
+y = x.view(np.float64)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_int64_to_float64")
+```
+
+</details>
+<details>
+<summary>bitcast_int8_to_uint8</summary>
+
+```python
+"""Test bitcasting from int8 to uint8 (same size, different signedness)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.UINT8,
+)
+x = np.array([-1, -128, 127, 0], dtype=np.int8)
+y = x.view(np.uint8)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_int8_to_uint8")
+```
+
+</details>
+<details>
+<summary>bitcast_scalar_float32_to_int32</summary>
+
+```python
+"""Test bitcasting scalar from float32 to int32."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT32,
+)
+x = np.array(1.0, dtype=np.float32)
+y = x.view(np.int32)
+expect(
+    node, inputs=[x], outputs=[y], name="test_bitcast_scalar_float32_to_int32"
+)
+```
+
+</details>
+<details>
+<summary>bitcast_uint16_to_int16</summary>
+
+```python
+"""Test bitcasting from uint16 to int16 (same size, different signedness)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT16,
+)
+x = np.array([1, 32768, 65535], dtype=np.uint16)
+y = x.view(np.int16)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_uint16_to_int16")
+```
+
+</details>
+<details>
+<summary>bitcast_uint32_to_int32</summary>
+
+```python
+"""Test bitcasting from uint32 to int32 (same size, different signedness)."""
+node = onnx.helper.make_node(
+    "BitCast",
+    inputs=["x"],
+    outputs=["y"],
+    to=onnx.TensorProto.INT32,
+)
+x = np.array([4294967295, 2147483648, 2147483647], dtype=np.uint32)
+y = x.view(np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_bitcast_uint32_to_int32")
+```
+
+</details>
+
+
+### BitShift
+There are 8 test cases, listed as following:
+<details>
+<summary>left_unit16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint16)
+y = np.array([1, 2, 3]).astype(np.uint16)
+z = x << y  # expected output [32, 16, 8]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint16")
+```
+
+</details>
+<details>
+<summary>left_unit32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint32)
+y = np.array([1, 2, 3]).astype(np.uint32)
+z = x << y  # expected output [32, 16, 8]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint32")
+```
+
+</details>
+<details>
+<summary>left_unit64</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint64)
+y = np.array([1, 2, 3]).astype(np.uint64)
+z = x << y  # expected output [32, 16, 8]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint64")
+```
+
+</details>
+<details>
+<summary>left_unit8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint8)
+y = np.array([1, 2, 3]).astype(np.uint8)
+z = x << y  # expected output [32, 16, 8]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint8")
+```
+
+</details>
+<details>
+<summary>right_unit16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint16)
+y = np.array([1, 2, 3]).astype(np.uint16)
+z = x >> y  # expected output [8, 1, 0]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint16")
+```
+
+</details>
+<details>
+<summary>right_unit32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint32)
+y = np.array([1, 2, 3]).astype(np.uint32)
+z = x >> y  # expected output [8, 1, 0]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint32")
+```
+
+</details>
+<details>
+<summary>right_unit64</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint64)
+y = np.array([1, 2, 3]).astype(np.uint64)
+z = x >> y  # expected output [8, 1, 0]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint64")
+```
+
+</details>
+<details>
+<summary>right_unit8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+)
+
+x = np.array([16, 4, 1]).astype(np.uint8)
+y = np.array([1, 2, 3]).astype(np.uint8)
+z = x >> y  # expected output [8, 1, 0]
+expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint8")
+```
+
+</details>
+
+
+### BitwiseAnd
+There are 2 test cases, listed as following:
+<details>
+<summary>bitwiseand</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseAnd",
+    inputs=["x", "y"],
+    outputs=["bitwiseand"],
+)
+
+# 2d
+x = create_random_int((3, 4), np.int32)
+y = create_random_int((3, 4), np.int32)
+z = np.bitwise_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i32_2d")
+
+# 3d
+x = create_random_int((3, 4, 5), np.int16)
+y = create_random_int((3, 4, 5), np.int16)
+z = np.bitwise_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i16_3d")
+```
+
+</details>
+<details>
+<summary>bitwiseand_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseAnd",
+    inputs=["x", "y"],
+    outputs=["bitwiseand"],
+)
+
+# 3d vs 1d
+x = create_random_int((3, 4, 5), np.uint64)
+y = create_random_int((5,), np.uint64)
+z = np.bitwise_and(x, y)
+expect(
+    node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui64_bcast_3v1d"
+)
+
+# 4d vs 3d
+x = create_random_int((3, 4, 5, 6), np.uint8)
+y = create_random_int((4, 5, 6), np.uint8)
+z = np.bitwise_and(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui8_bcast_4v3d")
+```
+
+</details>
+
+
+### BitwiseNot
+There are 1 test cases, listed as following:
+<details>
+<summary>bitwisenot</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseNot",
+    inputs=["x"],
+    outputs=["bitwise_not"],
+)
+
+# 2d
+x = create_random_int((3, 4), np.int32)
+y = np.bitwise_not(x)
+expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_2d")
+
+# 3d
+x = create_random_int((3, 4, 5), np.uint16)
+y = np.bitwise_not(x)
+expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_3d")
+
+# 4d
+x = create_random_int((3, 4, 5, 6), np.uint8)
+y = np.bitwise_not(x)
+expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_4d")
+```
+
+</details>
+
+
+### BitwiseOr
+There are 2 test cases, listed as following:
+<details>
+<summary>bitwiseor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseOr",
+    inputs=["x", "y"],
+    outputs=["bitwiseor"],
+)
+# 2d
+x = create_random_int((3, 4), np.int32)
+y = create_random_int((3, 4), np.int32)
+z = np.bitwise_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i32_2d")
+
+# 4d
+x = create_random_int((3, 4, 5, 6), np.int8)
+y = create_random_int((3, 4, 5, 6), np.int8)
+z = np.bitwise_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i16_4d")
+```
+
+</details>
+<details>
+<summary>bitwiseor_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseOr",
+    inputs=["x", "y"],
+    outputs=["bitwiseor"],
+)
+
+# 3d vs 1d
+x = create_random_int((3, 4, 5), np.uint64)
+y = create_random_int((5,), np.uint64)
+z = np.bitwise_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui64_bcast_3v1d")
+
+# 4d vs 3d
+x = create_random_int((3, 4, 5, 6), np.uint8)
+y = create_random_int((4, 5, 6), np.uint8)
+z = np.bitwise_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui8_bcast_4v3d")
+```
+
+</details>
+
+
+### BitwiseXor
+There are 2 test cases, listed as following:
+<details>
+<summary>bitwiseor_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseXor",
+    inputs=["x", "y"],
+    outputs=["bitwisexor"],
+)
+
+# 3d vs 1d
+x = create_random_int((3, 4, 5), np.uint64)
+y = create_random_int((5,), np.uint64)
+z = np.bitwise_xor(x, y)
+expect(
+    node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui64_bcast_3v1d"
+)
+
+# 4d vs 3d
+x = create_random_int((3, 4, 5, 6), np.uint8)
+y = create_random_int((4, 5, 6), np.uint8)
+z = np.bitwise_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui8_bcast_4v3d")
+```
+
+</details>
+<details>
+<summary>bitwisexor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "BitwiseXor",
+    inputs=["x", "y"],
+    outputs=["bitwisexor"],
+)
+
+# 2d
+x = create_random_int((3, 4), np.int32)
+y = create_random_int((3, 4), np.int32)
+z = np.bitwise_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i32_2d")
+
+# 3d
+x = create_random_int((3, 4, 5), np.int16)
+y = create_random_int((3, 4, 5), np.int16)
+z = np.bitwise_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i16_3d")
+```
+
+</details>
+
+
+### BlackmanWindow
+There are 1 test cases, listed as following:
+<details>
+<summary>blackmanwindow</summary>
+
+```python
+# Test periodic window
+node = onnx.helper.make_node(
+    "BlackmanWindow",
+    inputs=["x"],
+    outputs=["y"],
+)
+size = np.int32(10)
+a0 = 0.42
+a1 = -0.5
+a2 = 0.08
+y = a0
+y += a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+y += a2 * np.cos(4 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_blackmanwindow",
+)
+
+# Test symmetric window
+node = onnx.helper.make_node(
+    "BlackmanWindow", inputs=["x"], outputs=["y"], periodic=0
+)
+size = np.int32(10)
+a0 = 0.42
+a1 = -0.5
+a2 = 0.08
+y = a0
+y += a1 * np.cos(
+    2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+)
+y += a2 * np.cos(
+    4 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_blackmanwindow_symmetric",
+)
+```
+
+</details>
+
+
+### Cast
+There are 3 test cases, listed as following:
+<details>
+<summary>cast</summary>
+
+```python
+test_cases = [
+    ("FLOAT", "FLOAT16"),
+    ("FLOAT", "DOUBLE"),
+    ("FLOAT16", "FLOAT"),
+    ("FLOAT16", "DOUBLE"),
+    ("DOUBLE", "FLOAT"),
+    ("DOUBLE", "FLOAT16"),
+    ("FLOAT", "BFLOAT16"),
+    ("BFLOAT16", "FLOAT"),
+    ("FLOAT", "FLOAT8E4M3FN"),
+    ("FLOAT16", "FLOAT8E4M3FN"),
+    ("FLOAT", "FLOAT8E4M3FNUZ"),
+    ("FLOAT16", "FLOAT8E4M3FNUZ"),
+    ("FLOAT8E4M3FN", "FLOAT"),
+    ("FLOAT8E4M3FN", "FLOAT16"),
+    ("FLOAT8E4M3FNUZ", "FLOAT"),
+    ("FLOAT8E4M3FNUZ", "FLOAT16"),
+    ("FLOAT", "FLOAT8E5M2"),
+    ("FLOAT16", "FLOAT8E5M2"),
+    ("FLOAT", "FLOAT8E5M2FNUZ"),
+    ("FLOAT16", "FLOAT8E5M2FNUZ"),
+    ("FLOAT8E5M2", "FLOAT"),
+    ("FLOAT8E5M2", "FLOAT16"),
+    ("FLOAT8E5M2FNUZ", "FLOAT"),
+    ("FLOAT8E5M2FNUZ", "FLOAT16"),
+    ("FLOAT", "UINT4"),
+    ("FLOAT16", "UINT4"),
+    ("FLOAT", "INT4"),
+    ("FLOAT16", "INT4"),
+    ("UINT4", "FLOAT"),
+    ("UINT4", "FLOAT16"),
+    ("UINT4", "UINT8"),
+    ("INT4", "FLOAT"),
+    ("INT4", "FLOAT16"),
+    ("INT4", "INT8"),
+    ("FLOAT4E2M1", "FLOAT"),
+    ("FLOAT4E2M1", "FLOAT16"),
+    ("FLOAT", "FLOAT4E2M1"),
+    ("FLOAT16", "FLOAT4E2M1"),
+    ("FLOAT", "UINT2"),
+    ("FLOAT16", "UINT2"),
+    ("FLOAT", "INT2"),
+    ("FLOAT16", "INT2"),
+    ("UINT2", "FLOAT"),
+    ("UINT2", "FLOAT16"),
+    ("UINT2", "UINT8"),
+    ("INT2", "FLOAT"),
+    ("INT2", "FLOAT16"),
+    ("INT2", "INT8"),
+]
+
+for from_type, to_type in test_cases:
+    if from_type == to_type:
+        # Skip cases where from_type and to_type are the same
+        continue
+    from_dtype = getattr(TensorProto, from_type)
+    to_dtype = getattr(TensorProto, to_type)
+    from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+    to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+
+    if from_type == "BFLOAT16" or to_type == "BFLOAT16":
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.816468",
+                "0.21087195",
+                "0.7229038",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 4)
+
+    elif from_type in F8_TYPES or to_type in F8_TYPES:
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.7229038",
+                "1000000",
+                "1e-7",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+                "-0.0000001",
+                "0.0000001",
+                "-1000000",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 5)
+    elif from_type in ("UINT4", "INT4") or to_type in ("UINT4", "INT4"):
+        np_fp32 = np.arange(-9, 16).astype(np.float32)
+        input_shape = (5, 5)
+    elif from_type in ("UINT2", "INT2") or to_type in ("UINT2", "INT2"):
+        np_fp32 = np.arange(-3, 4).astype(np.float32)
+        input_shape = (7, 1)
+    elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1":
+        np_fp32 = np.array(
+            [
+                "0.48",
+                "0.25",
+                "1.05",
+                "-3.5",
+                "-8",
+                "9",
+                "1000000",
+                "1e-7",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+                "-4",
+                "0.01",
+                "-0.0",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 5)
+
+    else:
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.816468",
+                "0.21087195",
+                "0.7229038",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+            ],
+            dtype=np.float32,
+        ).reshape([3, 4])
+        input_shape = (3, 4)
+
+    if from_type in F8_TYPES:
+        np_from = onnx.numpy_helper.saturate_cast(np_fp32, from_np_dtype)
+        input = make_tensor(
+            "input",
+            from_dtype,
+            input_shape,
+            vals=np_from,
+            raw=True,
+        )
+    elif from_type in FOUR_BIT_TYPES:
+        np_from = np_fp32.astype(from_np_dtype)
+        packed = onnx.numpy_helper._pack_4bitx2(np_from)
+        # No byteswap needed on big-endian machines as _pack_4bitx2()
+        # returns a numpy array with uint8 datatype.
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    elif from_type in TWO_BIT_TYPES:
+        np_from = np_fp32.astype(from_np_dtype)
+        packed = onnx.numpy_helper._pack_2bitx4(np_from)
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    else:
+        np_from = np_fp32.astype(from_np_dtype)
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=np_from, raw=True
+        )
+
+    if to_type in F8_TYPES:
+        output = make_tensor(
+            "output",
+            to_dtype,
+            input_shape,
+            vals=onnx.numpy_helper.saturate_cast(np_from, to_np_dtype),
+            raw=True,
+        )
+    elif to_type in FOUR_BIT_TYPES:
+        packed = onnx.numpy_helper._pack_4bitx2(np_from.astype(to_np_dtype))
+        # No byteswap needed on big-endian machines as _pack_4bitx2()
+        # returns a numpy array with uint8 datatype.
+        output = make_tensor(
+            "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    elif to_type in TWO_BIT_TYPES:
+        packed = onnx.numpy_helper._pack_2bitx4(np_from.astype(to_np_dtype))
+        output = make_tensor(
+            "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    else:
+        output = make_tensor(
+            "output",
+            to_dtype,
+            input_shape,
+            vals=np_from.astype(to_np_dtype),
+            raw=True,
+        )
+
+    node = onnx.helper.make_node(
+        "Cast",
+        inputs=["input"],
+        outputs=["output"],
+        to=to_dtype,
+    )
+    expect(
+        node,
+        inputs=[input],
+        outputs=[output],
+        name="test_cast_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+<details>
+<summary>e8m0</summary>
+
+```python
+np_fp32 = np.array(
+    [
+        "0.0",
+        "0.124",
+        "0.25",
+        "0.5",
+        "1.1",
+        "2.0",
+        "4.0",
+        "8.0",
+    ],
+    dtype=np.float32,
+)
+test_cases = [
+    ("FLOAT", "FLOAT8E8M0"),
+    ("FLOAT16", "FLOAT8E8M0"),
+    ("FLOAT8E8M0", "FLOAT"),
+    ("FLOAT8E8M0", "FLOAT16"),
+]
+for from_type, to_type in test_cases:
+    if from_type == "FLOAT":
+        input_np = np_fp32
+        output_np = to_float8e8m0(np_fp32)
+    elif from_type == "FLOAT16":
+        input_np = np_fp32.astype(np.float16)
+        output_np = to_float8e8m0(input_np)
+    elif from_type == "FLOAT8E8M0":
+        input_np = to_float8e8m0(np_fp32)
+        if to_type == "FLOAT":
+            output_np = input_np.astype(np.float32)
+        elif to_type == "FLOAT16":
+            output_np = input_np.astype(np.float16)
+        else:
+            raise ValueError(
+                f"Conversion from {from_type} to {to_type} is not tested."
+            )
+    else:
+        raise ValueError(
+            f"Conversion from {from_type} to {to_type} is not tested."
+        )
+    input = make_tensor(
+        "input",
+        getattr(TensorProto, from_type),
+        [2, 4],
+        input_np,
+        raw=True,
+    )
+    output = make_tensor(
+        "output",
+        getattr(TensorProto, to_type),
+        [2, 4],
+        output_np,
+        raw=True,
+    )
+    if to_type == "FLOAT8E8M0":
+        node = onnx.helper.make_node(
+            "Cast",
+            inputs=["input"],
+            outputs=["output"],
+            to=getattr(TensorProto, to_type),
+            saturate=1,
+            round_mode="up",
+        )
+    else:
+        node = onnx.helper.make_node(
+            "Cast",
+            inputs=["input"],
+            outputs=["output"],
+            to=getattr(TensorProto, to_type),
+        )
+
+    expect(
+        node,
+        inputs=[input],
+        outputs=[output],
+        name="test_cast_e8m0_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+<details>
+<summary>saturate_false</summary>
+
+```python
+test_cases = itertools.product(
+    [
+        "FLOAT",
+        "FLOAT16",
+    ],
+    [
+        "FLOAT8E4M3FN",
+        "FLOAT8E4M3FNUZ",
+        "FLOAT8E5M2",
+        "FLOAT8E5M2FNUZ",
+    ],
+)
+input_shape = (3, 5)
+for from_type, to_type in test_cases:
+    from_dtype = getattr(TensorProto, from_type)
+    to_dtype = getattr(TensorProto, to_type)
+    from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+    to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+    np_fp32 = np.array(
+        [
+            "0.47892547",
+            "0.48033667",
+            "0.49968487",
+            "0.81910545",
+            "0.47031248",
+            "0.7229038",
+            "1000000",
+            "1e-7",
+            "NaN",
+            "INF",
+            "+INF",
+            "-INF",
+            "-0.0000001",
+            "0.0000001",
+            "-1000000",
+        ],
+        dtype=np.float32,
+    )
+
+    input = make_tensor(
+        "input",
+        from_dtype,
+        input_shape,
+        vals=np_fp32.astype(from_np_dtype),
+        raw=True,
+    )
+    output = make_tensor(
+        "output",
+        to_dtype,
+        input_shape,
+        vals=np_fp32.astype(from_np_dtype).astype(to_np_dtype),
+        raw=True,
+    )
+
+    node = onnx.helper.make_node(
+        "Cast",
+        inputs=["input"],
+        outputs=["output"],
+        to=to_dtype,
+        saturate=0,
+    )
+    expect(
+        node,
+        inputs=[input],
+        outputs=[output],
+        name="test_cast_no_saturate_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+
+
+### CastLike
+There are 2 test cases, listed as following:
+<details>
+<summary>castlike</summary>
+
+```python
+test_cases = [
+    ("FLOAT", "FLOAT16"),
+    ("FLOAT", "DOUBLE"),
+    ("FLOAT16", "FLOAT"),
+    ("FLOAT16", "DOUBLE"),
+    ("DOUBLE", "FLOAT"),
+    ("DOUBLE", "FLOAT16"),
+    ("FLOAT", "BFLOAT16"),
+    ("BFLOAT16", "FLOAT"),
+    ("FLOAT", "FLOAT8E4M3FN"),
+    ("FLOAT16", "FLOAT8E4M3FN"),
+    ("FLOAT", "FLOAT8E4M3FNUZ"),
+    ("FLOAT16", "FLOAT8E4M3FNUZ"),
+    ("FLOAT8E4M3FN", "FLOAT"),
+    ("FLOAT8E4M3FN", "FLOAT16"),
+    ("FLOAT8E4M3FNUZ", "FLOAT"),
+    ("FLOAT8E4M3FNUZ", "FLOAT16"),
+    ("FLOAT", "FLOAT8E5M2"),
+    ("FLOAT16", "FLOAT8E5M2"),
+    ("FLOAT", "FLOAT8E5M2FNUZ"),
+    ("FLOAT16", "FLOAT8E5M2FNUZ"),
+    ("FLOAT8E5M2", "FLOAT"),
+    ("FLOAT8E5M2", "FLOAT16"),
+    ("FLOAT8E5M2FNUZ", "FLOAT"),
+    ("FLOAT8E5M2FNUZ", "FLOAT16"),
+    ("FLOAT", "UINT4"),
+    ("FLOAT16", "UINT4"),
+    ("FLOAT", "INT4"),
+    ("FLOAT16", "INT4"),
+    ("UINT4", "FLOAT"),
+    ("UINT4", "FLOAT16"),
+    ("UINT4", "UINT8"),
+    ("INT4", "FLOAT"),
+    ("INT4", "FLOAT16"),
+    ("INT4", "INT8"),
+    ("FLOAT4E2M1", "FLOAT"),
+    ("FLOAT4E2M1", "FLOAT16"),
+    ("FLOAT", "FLOAT4E2M1"),
+    ("FLOAT16", "FLOAT4E2M1"),
+    ("FLOAT", "UINT2"),
+    ("FLOAT16", "UINT2"),
+    ("FLOAT", "INT2"),
+    ("FLOAT16", "INT2"),
+    ("UINT2", "FLOAT"),
+    ("UINT2", "FLOAT16"),
+    ("UINT2", "UINT8"),
+    ("INT2", "FLOAT"),
+    ("INT2", "FLOAT16"),
+    ("INT2", "INT8"),
+]
+
+f8_types = {"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"}
+
+for from_type, to_type in test_cases:
+    if from_type == to_type:
+        # Skip cases where from_type and to_type are the same
+        continue
+    from_dtype = getattr(TensorProto, from_type)
+    to_dtype = getattr(TensorProto, to_type)
+    from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+    to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+
+    if from_type == "BFLOAT16" or to_type == "BFLOAT16":
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.816468",
+                "0.21087195",
+                "0.7229038",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 4)
+
+    elif from_type in f8_types or to_type in f8_types:
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.7229038",
+                "1000000",
+                "1e-7",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+                "-0.0000001",
+                "0.0000001",
+                "-1000000",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 5)
+    elif from_type in ("UINT4", "INT4") or to_type in ("UINT4", "INT4"):
+        np_fp32 = np.arange(-9, 16).astype(np.float32)
+        input_shape = (5, 5)
+    elif from_type in ("UINT2", "INT2") or to_type in ("UINT2", "INT2"):
+        np_fp32 = np.arange(-3, 4).astype(np.float32)
+        input_shape = (7, 1)
+    elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1":
+        np_fp32 = np.array(
+            [
+                "0.48",
+                "0.25",
+                "1.05",
+                "-3.5",
+                "-8",
+                "9",
+                "1000000",
+                "1e-7",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+                "-4",
+                "0.01",
+                "-0.0",
+            ],
+            dtype=np.float32,
+        )
+        input_shape = (3, 5)
+
+    else:
+        np_fp32 = np.array(
+            [
+                "0.47892547",
+                "0.48033667",
+                "0.49968487",
+                "0.81910545",
+                "0.47031248",
+                "0.816468",
+                "0.21087195",
+                "0.7229038",
+                "NaN",
+                "INF",
+                "+INF",
+                "-INF",
+            ],
+            dtype=np.float32,
+        ).reshape([3, 4])
+        input_shape = (3, 4)
+
+    if from_type in F8_TYPES:
+        np_from = onnx.numpy_helper.saturate_cast(np_fp32, from_np_dtype)
+        input = make_tensor(
+            "input",
+            from_dtype,
+            input_shape,
+            vals=np_from,
+            raw=True,
+        )
+    elif from_type in FOUR_BIT_TYPES:
+        np_from = np_fp32.astype(from_np_dtype)
+        packed = onnx.numpy_helper._pack_4bitx2(np_from)
+        # No byteswap needed on big-endian machines as _pack_4bitx2()
+        # returns a numpy array with uint8 datatype.
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    elif from_type in TWO_BIT_TYPES:
+        np_from = np_fp32.astype(from_np_dtype)
+        packed = onnx.numpy_helper._pack_2bitx4(np_from)
+        # No byteswap needed on big-endian machines as _pack_2bitx4()
+        # returns a numpy array with uint8 datatype.
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    else:
+        np_from = np_fp32.astype(from_np_dtype)
+        input = make_tensor(
+            "input", from_dtype, input_shape, vals=np_from, raw=True
+        )
+
+    if to_type in F8_TYPES:
+        output = make_tensor(
+            "output",
+            to_dtype,
+            input_shape,
+            vals=onnx.numpy_helper.saturate_cast(np_from, to_np_dtype),
+            raw=True,
+        )
+    elif to_type in FOUR_BIT_TYPES:
+        packed = onnx.numpy_helper._pack_4bitx2(np_from.astype(to_np_dtype))
+        # No byteswap needed on big-endian machines as _pack_4bitx2()
+        # returns a numpy array with uint8 datatype.
+        output = make_tensor(
+            "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    elif to_type in TWO_BIT_TYPES:
+        packed = onnx.numpy_helper._pack_2bitx4(np_from.astype(to_np_dtype))
+        # No byteswap needed on big-endian machines as _pack_2bitx4()
+        # returns a numpy array with uint8 datatype.
+        output = make_tensor(
+            "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+        )
+    else:
+        output = make_tensor(
+            "output",
+            to_dtype,
+            input_shape,
+            vals=np_from.astype(to_np_dtype),
+            raw=True,
+        )
+
+    like = make_tensor("like", to_dtype, (0,), vals=[])
+
+    node = onnx.helper.make_node(
+        "CastLike",
+        inputs=["input", "like"],
+        outputs=["output"],
+    )
+
+    expect(
+        node,
+        inputs=[input, like],
+        outputs=[output],
+        name="test_castlike_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+<details>
+<summary>saturate_false</summary>
+
+```python
+test_cases = itertools.product(
+    [
+        "FLOAT",
+        "FLOAT16",
+    ],
+    [
+        "FLOAT8E4M3FN",
+        "FLOAT8E4M3FNUZ",
+        "FLOAT8E5M2",
+        "FLOAT8E5M2FNUZ",
+    ],
+)
+input_shape = (3, 5)
+for from_type, to_type in test_cases:
+    from_dtype = getattr(TensorProto, from_type)
+    to_dtype = getattr(TensorProto, to_type)
+    from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+    to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+    np_fp32 = np.array(
+        [
+            "0.47892547",
+            "0.48033667",
+            "0.49968487",
+            "0.81910545",
+            "0.47031248",
+            "0.7229038",
+            "1000000",
+            "1e-7",
+            "NaN",
+            "INF",
+            "+INF",
+            "-INF",
+            "-0.0000001",
+            "0.0000001",
+            "-1000000",
+        ],
+        dtype=np.float32,
+    )
+
+    input = make_tensor(
+        "input",
+        from_dtype,
+        input_shape,
+        vals=np_fp32.astype(from_np_dtype),
+        raw=True,
+    )
+    output = make_tensor(
+        "output",
+        to_dtype,
+        input_shape,
+        vals=np_fp32.astype(from_np_dtype).astype(to_np_dtype),
+        raw=True,
+    )
+
+    like = make_tensor("like", to_dtype, (0,), vals=[])
+
+    node = onnx.helper.make_node(
+        "CastLike",
+        inputs=["input", "like"],
+        outputs=["output"],
+        saturate=0,
+    )
+
+    expect(
+        node,
+        inputs=[input, like],
+        outputs=[output],
+        name="test_castlike_no_saturate_" + from_type + "_to_" + to_type,
+    )
+```
+
+</details>
+
+
+### CausalConvWithState
+There are 13 test cases, listed as following:
+<details>
+<summary>b1_c1_degenerate</summary>
+
+```python
+# Mamba/GDN inner-head edge case: B=1, C=1.
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 1, 1, 6, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_b1_c1_degenerate",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>basic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_basic",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>decode_step</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "bias", "past_state"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 1, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+bias = np.random.randn(channels).astype(np.float32)
+past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+output, present_state = _compute(
+    input_, weight, bias=bias, past_state=past_state
+)
+
+expect(
+    node,
+    inputs=[input_, weight, bias, past_state],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_decode_step",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>fp16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.rand(batch_size, channels, length).astype(np.float16)
+weight = np.random.rand(channels, 1, k).astype(np.float16)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>kernel_size_one</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 1
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_kernel_size_one",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>short_input_no_past_state</summary>
+
+```python
+# L < k-1 with no past_state: zero-pad is wider than the input.
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 2, 5
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight)
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_short_input_no_past_state",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>silu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+    activation="silu",
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight, activation="silu")
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_silu",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>silu_fp16</summary>
+
+```python
+# fp16 + SiLU: the reference upcasts Sigmoid/Mul to float32, so the
+# function-body expansion must do the same to stay numerically faithful.
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+    activation="silu",
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.rand(batch_size, channels, length).astype(np.float16)
+weight = np.random.rand(channels, 1, k).astype(np.float16)
+
+output, present_state = _compute(input_, weight, activation="silu")
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_silu_fp16",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>silu_with_past_state</summary>
+
+```python
+# Fused activation combined with concat-from-past variant of PaddedInput.
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "", "past_state"],
+    outputs=["output", "present_state"],
+    activation="silu",
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+output, present_state = _compute(
+    input_, weight, past_state=past_state, activation="silu"
+)
+
+expect(
+    node,
+    inputs=[input_, weight, past_state],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_silu_with_past_state",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>swish_alias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight"],
+    outputs=["output", "present_state"],
+    activation="swish",
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+output, present_state = _compute(input_, weight, activation="swish")
+
+expect(
+    node,
+    inputs=[input_, weight],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_swish_alias",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>with_bias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "bias"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+bias = np.random.randn(channels).astype(np.float32)
+
+output, present_state = _compute(input_, weight, bias=bias)
+
+expect(
+    node,
+    inputs=[input_, weight, bias],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_with_bias",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>with_bias_and_past_state</summary>
+
+```python
+# Multi-token (T>1) path through Concat(past, input) -> Conv(+bias).
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "bias", "past_state"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+bias = np.random.randn(channels).astype(np.float32)
+past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+output, present_state = _compute(
+    input_, weight, bias=bias, past_state=past_state
+)
+
+expect(
+    node,
+    inputs=[input_, weight, bias, past_state],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_with_bias_and_past_state",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+<details>
+<summary>with_past_state</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CausalConvWithState",
+    inputs=["input", "weight", "", "past_state"],
+    outputs=["output", "present_state"],
+)
+
+batch_size, channels, length, k = 2, 4, 8, 4
+input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+weight = np.random.randn(channels, 1, k).astype(np.float32)
+past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+output, present_state = _compute(input_, weight, past_state=past_state)
+
+expect(
+    node,
+    inputs=[input_, weight, past_state],
+    outputs=[output, present_state],
+    name="test_causal_conv_with_state_with_past_state",
+    opset_imports=[onnx.helper.make_opsetid("", 27)],
+)
+```
+
+</details>
+
+
+### Ceil
+There are 1 test cases, listed as following:
+<details>
+<summary>ceil</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Ceil",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.5, 1.2]).astype(np.float32)
+y = np.ceil(x)  # expected output [-1., 2.]
+expect(node, inputs=[x], outputs=[y], name="test_ceil_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.ceil(x)
+expect(node, inputs=[x], outputs=[y], name="test_ceil")
+```
+
+</details>
+
+
+### Celu
+There are 3 test cases, listed as following:
+<details>
+<summary>celu</summary>
+
+```python
+alpha = 2.0
+node = onnx.helper.make_node(
+    "Celu",
+    inputs=["X"],
+    outputs=["Y"],
+    alpha=alpha,
+)
+
+input_data = np.array(
+    [
+        [
+            [[0.8439683], [0.5665144], [0.05836735]],
+            [[0.02916367], [0.12964272], [0.5060197]],
+            [[0.79538304], [0.9411346], [0.9546573]],
+        ],
+        [
+            [[0.17730942], [0.46192095], [0.26480448]],
+            [[0.6746842], [0.01665257], [0.62473077]],
+            [[0.9240844], [0.9722341], [0.11965699]],
+        ],
+        [
+            [[0.41356155], [0.9129373], [0.59330076]],
+            [[0.81929934], [0.7862604], [0.11799799]],
+            [[0.69248444], [0.54119414], [0.07513223]],
+        ],
+    ],
+    dtype=np.float32,
+)
+
+# Calculate expected output data
+positive_input = np.maximum(0, input_data)
+negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1))
+expected_output = positive_input + negative_input
+
+expect(node, inputs=[input_data], outputs=[expected_output], name="test_celu")
+```
+
+</details>
+<details>
+<summary>celu_bfloat16</summary>
+
+```python
+alpha = 2.0
+node = onnx.helper.make_node(
+    "Celu",
+    inputs=["X"],
+    outputs=["Y"],
+    alpha=alpha,
+)
+
+input_data = np.array([-3.0, -0.5, 0.0, 0.5, 3.0], dtype=ml_dtypes.bfloat16)
+
+positive_input = np.maximum(0, input_data)
+negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1))
+expected_output = (positive_input + negative_input).astype(ml_dtypes.bfloat16)
+
+expect(
+    node,
+    inputs=[input_data],
+    outputs=[expected_output],
+    name="test_celu_bfloat16",
+)
+```
+
+</details>
+<details>
+<summary>celu_float16</summary>
+
+```python
+alpha = 2.0
+node = onnx.helper.make_node(
+    "Celu",
+    inputs=["X"],
+    outputs=["Y"],
+    alpha=alpha,
+)
+
+input_data = np.array([-3.0, -0.5, 0.0, 0.5, 3.0], dtype=np.float16)
+
+positive_input = np.maximum(0, input_data)
+negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1))
+expected_output = (positive_input + negative_input).astype(np.float16)
+
+expect(
+    node,
+    inputs=[input_data],
+    outputs=[expected_output],
+    name="test_celu_float16",
+)
+```
+
+</details>
+
+
+### CenterCropPad
+There are 6 test cases, listed as following:
+<details>
+<summary>center_crop_pad_crop</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+)
+
+# First dim is even diff, second is uneven
+x = np.random.randn(20, 10, 3).astype(np.float32)
+shape = np.array([10, 7, 3], dtype=np.int64)
+y = x[5:15, 1:8, :]
+
+expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_crop")
+```
+
+</details>
+<details>
+<summary>center_crop_pad_crop_and_pad</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+)
+
+# Cropping on first dim, padding on second, third stays the same
+x = np.random.randn(20, 8, 3).astype(np.float32)
+shape = np.array([10, 10, 3], dtype=np.int64)
+y = np.zeros([10, 10, 3], dtype=np.float32)
+y[:, 1:9, :] = x[5:15, :, :]
+
+expect(
+    node,
+    inputs=[x, shape],
+    outputs=[y],
+    name="test_center_crop_pad_crop_and_pad",
+)
+```
+
+</details>
+<details>
+<summary>center_crop_pad_crop_axes_chw</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+    axes=[1, 2],
+)
+
+# Cropping on second dim, padding on third, first stays the same
+x = np.random.randn(3, 20, 8).astype(np.float32)
+shape = np.array([10, 9], dtype=np.int64)
+y = np.zeros([3, 10, 9], dtype=np.float32)
+y[:, :, :8] = x[:, 5:15, :]
+
+expect(
+    node,
+    inputs=[x, shape],
+    outputs=[y],
+    name="test_center_crop_pad_crop_axes_chw",
+)
+```
+
+</details>
+<details>
+<summary>center_crop_pad_crop_axes_hwc</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+    axes=[0, 1],
+)
+
+# Cropping on first dim, padding on second, third stays the same
+x = np.random.randn(20, 8, 3).astype(np.float32)
+shape = np.array([10, 9], dtype=np.int64)
+y = np.zeros([10, 9, 3], dtype=np.float32)
+y[:, :8, :] = x[5:15, :, :]
+
+expect(
+    node,
+    inputs=[x, shape],
+    outputs=[y],
+    name="test_center_crop_pad_crop_axes_hwc",
+)
+```
+
+</details>
+<details>
+<summary>center_crop_pad_crop_negative_axes_hwc</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+    axes=[-3, -2],
+)
+
+# Cropping on first dim, padding on second, third stays the same
+x = np.random.randn(20, 8, 3).astype(np.float32)
+shape = np.array([10, 9], dtype=np.int64)
+y = np.zeros([10, 9, 3], dtype=np.float32)
+y[:, :8, :] = x[5:15, :, :]
+
+expect(
+    node,
+    inputs=[x, shape],
+    outputs=[y],
+    name="test_center_crop_pad_crop_negative_axes_hwc",
+)
+```
+
+</details>
+<details>
+<summary>center_crop_pad_pad</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CenterCropPad",
+    inputs=["x", "shape"],
+    outputs=["y"],
+)
+
+# First dim is even diff, second is uneven
+x = np.random.randn(10, 7, 3).astype(np.float32)
+shape = np.array([20, 10, 3], dtype=np.int64)
+y = np.zeros([20, 10, 3], dtype=np.float32)
+y[5:15, 1:8, :] = x
+
+expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_pad")
+```
+
+</details>
+
+
+### Clip
+There are 3 test cases, listed as following:
+<details>
+<summary>clip</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", "min", "max"],
+    outputs=["y"],
+)
+
+x = np.array([-2, 0, 2]).astype(np.float32)
+min_val = np.float32(-1)
+max_val = np.float32(1)
+y = np.clip(x, min_val, max_val)  # expected output [-1., 0., 1.]
+expect(
+    node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_example"
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, min_val, max_val)
+expect(node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip")
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", "min", "max"],
+    outputs=["y"],
+)
+
+min_val = np.float32(-5)
+max_val = np.float32(5)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.array([-1, 0, 1]).astype(np.float32)
+expect(
+    node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_inbounds"
+)
+
+x = np.array([-6, 0, 6]).astype(np.float32)
+y = np.array([-5, 0, 5]).astype(np.float32)
+expect(
+    node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_outbounds"
+)
+
+x = np.array([-1, 0, 6]).astype(np.float32)
+y = np.array([-1, 0, 5]).astype(np.float32)
+expect(
+    node,
+    inputs=[x, min_val, max_val],
+    outputs=[y],
+    name="test_clip_splitbounds",
+)
+
+x = np.array([-2, 0, 6]).astype(np.float32)
+y = np.array([1, 1, 1]).astype(np.float32)
+min_val = np.float32(2)
+max_val = np.float32(1)
+expect(
+    node,
+    inputs=[x, min_val, max_val],
+    outputs=[y],
+    name="test_clip_min_greater_than_max",
+)
+```
+
+</details>
+<details>
+<summary>clip_default</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", "min"],
+    outputs=["y"],
+)
+min_val = np.float32(0)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, min_val, np.inf)
+expect(node, inputs=[x, min_val], outputs=[y], name="test_clip_default_min")
+
+no_min = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", no_min, "max"],
+    outputs=["y"],
+)
+max_val = np.float32(0)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, -np.inf, max_val)
+expect(node, inputs=[x, max_val], outputs=[y], name="test_clip_default_max")
+
+no_max = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", no_min, no_max],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.array([-1, 0, 1]).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_clip_default_inbounds")
+```
+
+</details>
+<details>
+<summary>clip_default_int8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", "min"],
+    outputs=["y"],
+)
+min_val = np.int8(0)
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.clip(x, min_val, np.iinfo(np.int8).max)
+expect(
+    node, inputs=[x, min_val], outputs=[y], name="test_clip_default_int8_min"
+)
+
+no_min = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", no_min, "max"],
+    outputs=["y"],
+)
+max_val = np.int8(0)
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.clip(x, np.iinfo(np.int8).min, max_val)
+expect(
+    node, inputs=[x, max_val], outputs=[y], name="test_clip_default_int8_max"
+)
+
+no_max = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "Clip",
+    inputs=["x", no_min, no_max],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.int8)
+y = np.array([-1, 0, 1]).astype(np.int8)
+expect(node, inputs=[x], outputs=[y], name="test_clip_default_int8_inbounds")
+```
+
+</details>
+
+
+### Col2Im
+There are 5 test cases, listed as following:
+<details>
+<summary>col2im</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [1.0, 6.0, 11.0, 16.0, 21.0],  # (1, 5, 5)
+            [2.0, 7.0, 12.0, 17.0, 22.0],
+            [3.0, 8.0, 13.0, 18.0, 23.0],
+            [4.0, 9.0, 14.0, 19.0, 24.0],
+            [5.0, 0.0, 15.0, 20.0, 25.0],
+        ]
+    ]
+).astype(np.float32)
+
+image_shape = np.array([5, 5]).astype(np.int64)
+block_shape = np.array([1, 5]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Col2Im", ["input", "image_shape", "block_shape"], ["output"]
+)
+
+output = np.array(
+    [
+        [
+            [
+                [1.0, 2.0, 3.0, 4.0, 5.0],  # (1, 1, 5, 5)
+                [6.0, 7.0, 8.0, 9.0, 0.0],
+                [11.0, 12.0, 13.0, 14.0, 15.0],
+                [16.0, 17.0, 18.0, 19.0, 20.0],
+                [21.0, 22.0, 23.0, 24.0, 25.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im",
+)
+```
+
+</details>
+<details>
+<summary>col2im_5d</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56],  # (1, 10, 12)
+            [2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57],
+            [3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53, 58],
+            [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59],
+            [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60],
+            [61, 66, 71, 76, 81, 86, 91, 96, 101, 106, 111, 116],
+            [62, 67, 72, 77, 82, 87, 92, 97, 102, 107, 112, 117],
+            [63, 68, 73, 78, 83, 88, 93, 98, 103, 108, 113, 118],
+            [64, 69, 74, 79, 84, 89, 94, 99, 104, 109, 114, 119],
+            [65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120],
+        ]
+    ]
+).astype(np.float32)
+image_shape = np.array([3, 4, 5]).astype(np.int64)
+block_shape = np.array([1, 1, 5]).astype(np.int64)
+
+output = np.array(
+    [
+        [
+            [
+                [
+                    [1, 2, 3, 4, 5],  # (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, 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],
+                ],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Col2Im", ["input", "image_shape", "block_shape"], ["output"]
+)
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im_5d",
+)
+```
+
+</details>
+<details>
+<summary>col2im_dilations</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [1.0, 5.0, 9.0, 13.0, 17],  # (1, 4, 5)
+            [2.0, 6.0, 10.0, 14.0, 18],
+            [3.0, 7.0, 11.0, 15.0, 19],
+            [4.0, 8.0, 12.0, 16.0, 20],
+        ]
+    ]
+).astype(np.float32)
+image_shape = np.array([6, 6]).astype(np.int64)
+block_shape = np.array([2, 2]).astype(np.int64)
+
+output = np.array(
+    [
+        [
+            [
+                [1.0, 0.0, 0.0, 0.0, 0.0, 2.0],  # (1, 1, 6, 6)
+                [8.0, 0.0, 0.0, 0.0, 0.0, 10.0],
+                [16.0, 0.0, 0.0, 0.0, 0.0, 18.0],
+                [24.0, 0.0, 0.0, 0.0, 0.0, 26.0],
+                [32.0, 0.0, 0.0, 0.0, 0.0, 34.0],
+                [19.0, 0.0, 0.0, 0.0, 0.0, 20.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Col2Im",
+    ["input", "image_shape", "block_shape"],
+    ["output"],
+    dilations=[1, 5],
+)
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im_dilations",
+)
+```
+
+</details>
+<details>
+<summary>col2im_pads</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [
+                1.0,
+                6.0,
+                11.0,
+                16.0,
+                21.0,
+                26,
+                31,
+                36,
+                41,
+                46,
+                51,
+                56,
+                61,
+                66,
+                71,
+            ],  # (1, 5, 15)
+            [
+                2.0,
+                7.0,
+                12.0,
+                17.0,
+                22.0,
+                27,
+                32,
+                37,
+                42,
+                47,
+                52,
+                57,
+                62,
+                67,
+                72,
+            ],
+            [
+                3.0,
+                8.0,
+                13.0,
+                18.0,
+                23.0,
+                28,
+                33,
+                38,
+                43,
+                48,
+                53,
+                58,
+                63,
+                68,
+                73,
+            ],
+            [
+                4.0,
+                9.0,
+                14.0,
+                19.0,
+                24.0,
+                29,
+                34,
+                39,
+                44,
+                49,
+                54,
+                59,
+                64,
+                69,
+                74,
+            ],
+            [
+                5.0,
+                10.0,
+                15.0,
+                20.0,
+                25.0,
+                30,
+                35,
+                40,
+                45,
+                50,
+                55,
+                60,
+                65,
+                70,
+                75,
+            ],
+        ]
+    ]
+).astype(np.float32)
+image_shape = np.array([5, 5]).astype(np.int64)
+block_shape = np.array([1, 5]).astype(np.int64)
+
+output = np.array(
+    [
+        [
+            [
+                [8.0, 21.0, 24.0, 27.0, 24.0],  # (1, 1, 5, 5)
+                [38.0, 66.0, 69.0, 72.0, 54.0],
+                [68.0, 111.0, 114.0, 117.0, 84.0],
+                [98.0, 156.0, 159.0, 162.0, 114.0],
+                [128.0, 201.0, 204.0, 207.0, 144.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Col2Im",
+    ["input", "image_shape", "block_shape"],
+    ["output"],
+    pads=[0, 1, 0, 1],
+)
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im_pads",
+)
+```
+
+</details>
+<details>
+<summary>col2im_strides</summary>
+
+```python
+input = np.array(
+    [
+        [
+            [0.0, 0.0, 0.0, 0.0],  # (1, 9, 4)
+            [1.0, 1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0, 1.0],
+            [1.0, 1.0, 1.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],
+            [1.0, 1.0, 1.0, 1.0],
+            [0.0, 0.0, 0.0, 0.0],
+        ]
+    ]
+).astype(np.float32)
+image_shape = np.array([5, 5]).astype(np.int64)
+block_shape = np.array([3, 3]).astype(np.int64)
+
+output = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 1.0, 1.0, 1.0],  # (1, 1, 5, 5)
+                [1.0, 0.0, 1.0, 0.0, 0.0],
+                [0.0, 2.0, 1.0, 2.0, 1.0],
+                [1.0, 0.0, 1.0, 0.0, 0.0],
+                [0.0, 1.0, 0.0, 1.0, 0.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Col2Im",
+    ["input", "image_shape", "block_shape"],
+    ["output"],
+    strides=[2, 2],
+)
+expect(
+    node,
+    inputs=[input, image_shape, block_shape],
+    outputs=[output],
+    name="test_col2im_strides",
+)
+```
+
+</details>
+
+
+### Compress
+There are 4 test cases, listed as following:
+<details>
+<summary>compress_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Compress",
+    inputs=["input", "condition"],
+    outputs=["output"],
+    axis=0,
+)
+input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+condition = np.array([0, 1, 1])
+output = np.compress(condition, input, axis=0)
+# print(output)
+# [[ 3.  4.]
+# [ 5.  6.]]
+
+expect(
+    node,
+    inputs=[input, condition.astype(bool)],
+    outputs=[output],
+    name="test_compress_0",
+)
+```
+
+</details>
+<details>
+<summary>compress_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Compress",
+    inputs=["input", "condition"],
+    outputs=["output"],
+    axis=1,
+)
+input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+condition = np.array([0, 1])
+output = np.compress(condition, input, axis=1)
+# print(output)
+# [[ 2.]
+# [ 4.]
+# [ 6.]]
+
+expect(
+    node,
+    inputs=[input, condition.astype(bool)],
+    outputs=[output],
+    name="test_compress_1",
+)
+```
+
+</details>
+<details>
+<summary>compress_default_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Compress",
+    inputs=["input", "condition"],
+    outputs=["output"],
+)
+input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+condition = np.array([0, 1, 0, 0, 1])
+output = np.compress(condition, input)
+# print(output)
+# [ 2., 5.]
+
+expect(
+    node,
+    inputs=[input, condition.astype(bool)],
+    outputs=[output],
+    name="test_compress_default_axis",
+)
+```
+
+</details>
+<details>
+<summary>compress_negative_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Compress",
+    inputs=["input", "condition"],
+    outputs=["output"],
+    axis=-1,
+)
+input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+condition = np.array([0, 1])
+output = np.compress(condition, input, axis=-1)
+# print(output)
+# [[ 2.]
+# [ 4.]
+# [ 6.]]
+expect(
+    node,
+    inputs=[input, condition.astype(bool)],
+    outputs=[output],
+    name="test_compress_negative_axis",
+)
+```
+
+</details>
+
+
+### Concat
+There are 1 test cases, listed as following:
+<details>
+<summary>concat</summary>
+
+```python
+test_cases: dict[str, Sequence[Any]] = {
+    "1d": ([1, 2], [3, 4]),
+    "2d": ([[1, 2], [3, 4]], [[5, 6], [7, 8]]),
+    "3d": (
+        [[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
+        [[[9, 10], [11, 12]], [[13, 14], [15, 16]]],
+    ),
+}
+
+for test_case, values_ in test_cases.items():
+    values = [np.asarray(v, dtype=np.float32) for v in values_]
+    for i in range(len(values[0].shape)):
+        in_args = ["value" + str(k) for k in range(len(values))]
+        node = onnx.helper.make_node(
+            "Concat", inputs=list(in_args), outputs=["output"], axis=i
+        )
+        output = np.concatenate(values, i)
+        expect(
+            node,
+            inputs=list(values),
+            outputs=[output],
+            name="test_concat_" + test_case + "_axis_" + str(i),
+        )
+
+    for i in range(-len(values[0].shape), 0):
+        in_args = ["value" + str(k) for k in range(len(values))]
+        node = onnx.helper.make_node(
+            "Concat", inputs=list(in_args), outputs=["output"], axis=i
+        )
+        output = np.concatenate(values, i)
+        expect(
+            node,
+            inputs=list(values),
+            outputs=[output],
+            name="test_concat_" + test_case + "_axis_negative_" + str(abs(i)),
+        )
+```
+
+</details>
+
+
+### Constant
+There are 1 test cases, listed as following:
+<details>
+<summary>constant</summary>
+
+```python
+values = np.random.randn(5, 5).astype(np.float32)
+node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["values"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor",
+        data_type=onnx.TensorProto.FLOAT,
+        dims=values.shape,
+        vals=values.flatten().astype(float),
+    ),
+)
+
+expect(node, inputs=[], outputs=[values], name="test_constant")
+```
+
+</details>
+
+
+### ConstantOfShape
+There are 3 test cases, listed as following:
+<details>
+<summary>float_ones</summary>
+
+```python
+x = np.array([4, 3, 2]).astype(np.int64)
+tensor_value = onnx.helper.make_tensor(
+    "value", onnx.TensorProto.FLOAT, [1], [1]
+)
+node = onnx.helper.make_node(
+    "ConstantOfShape",
+    inputs=["x"],
+    outputs=["y"],
+    value=tensor_value,
+)
+
+y = np.ones(x, dtype=np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_constantofshape_float_ones")
+```
+
+</details>
+<details>
+<summary>int32_shape_zero</summary>
+
+```python
+x = np.array(
+    [
+        0,
+    ]
+).astype(np.int64)
+tensor_value = onnx.helper.make_tensor(
+    "value", onnx.TensorProto.INT32, [1], [0]
+)
+node = onnx.helper.make_node(
+    "ConstantOfShape",
+    inputs=["x"],
+    outputs=["y"],
+    value=tensor_value,
+)
+y = np.zeros(x, dtype=np.int32)
+expect(
+    node, inputs=[x], outputs=[y], name="test_constantofshape_int_shape_zero"
+)
+```
+
+</details>
+<details>
+<summary>int32_zeros</summary>
+
+```python
+x = np.array([10, 6]).astype(np.int64)
+tensor_value = onnx.helper.make_tensor(
+    "value", onnx.TensorProto.INT32, [1], [0]
+)
+node = onnx.helper.make_node(
+    "ConstantOfShape",
+    inputs=["x"],
+    outputs=["y"],
+    value=tensor_value,
+)
+y = np.zeros(x, dtype=np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_constantofshape_int_zeros")
+```
+
+</details>
+
+
+### Conv
+There are 3 test cases, listed as following:
+<details>
+<summary>conv</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 5, 5) input tensor
+                [5.0, 6.0, 7.0, 8.0, 9.0],
+                [10.0, 11.0, 12.0, 13.0, 14.0],
+                [15.0, 16.0, 17.0, 18.0, 19.0],
+                [20.0, 21.0, 22.0, 23.0, 24.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [
+                [1.0, 1.0, 1.0],  # (1, 1, 3, 3) tensor for convolution weights
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+# Convolution with padding
+node_with_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1
+    pads=[1, 1, 1, 1],
+)
+y_with_padding = np.array(
+    [
+        [
+            [
+                [12.0, 21.0, 27.0, 33.0, 24.0],  # (1, 1, 5, 5) output tensor
+                [33.0, 54.0, 63.0, 72.0, 51.0],
+                [63.0, 99.0, 108.0, 117.0, 81.0],
+                [93.0, 144.0, 153.0, 162.0, 111.0],
+                [72.0, 111.0, 117.0, 123.0, 84.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_with_padding,
+    inputs=[x, W],
+    outputs=[y_with_padding],
+    name="test_basic_conv_with_padding",
+)
+
+# Convolution without padding
+node_without_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1
+    pads=[0, 0, 0, 0],
+)
+y_without_padding = np.array(
+    [
+        [
+            [
+                [54.0, 63.0, 72.0],  # (1, 1, 3, 3) output tensor
+                [99.0, 108.0, 117.0],
+                [144.0, 153.0, 162.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_without_padding,
+    inputs=[x, W],
+    outputs=[y_without_padding],
+    name="test_basic_conv_without_padding",
+)
+```
+
+</details>
+<details>
+<summary>conv_with_autopad_same</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 5, 5) input tensor
+                [5.0, 6.0, 7.0, 8.0, 9.0],
+                [10.0, 11.0, 12.0, 13.0, 14.0],
+                [15.0, 16.0, 17.0, 18.0, 19.0],
+                [20.0, 21.0, 22.0, 23.0, 24.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [
+                [1.0, 1.0, 1.0],  # (1, 1, 3, 3) tensor for convolution weights
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+# Convolution with auto_pad='SAME_LOWER' and strides=2
+node = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    auto_pad="SAME_LOWER",
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+)
+y = np.array(
+    [[[[12.0, 27.0, 24.0], [63.0, 108.0, 81.0], [72.0, 117.0, 84.0]]]]
+).astype(np.float32)
+expect(node, inputs=[x, W], outputs=[y], name="test_conv_with_autopad_same")
+```
+
+</details>
+<details>
+<summary>conv_with_strides</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 7, 5) input tensor
+                [5.0, 6.0, 7.0, 8.0, 9.0],
+                [10.0, 11.0, 12.0, 13.0, 14.0],
+                [15.0, 16.0, 17.0, 18.0, 19.0],
+                [20.0, 21.0, 22.0, 23.0, 24.0],
+                [25.0, 26.0, 27.0, 28.0, 29.0],
+                [30.0, 31.0, 32.0, 33.0, 34.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [
+                [1.0, 1.0, 1.0],  # (1, 1, 3, 3) tensor for convolution weights
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 1.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+# Convolution with strides=2 and padding
+node_with_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[1, 1, 1, 1],
+    strides=[
+        2,
+        2,
+    ],  # Default values for other attributes: dilations=[1, 1], groups=1
+)
+y_with_padding = np.array(
+    [
+        [
+            [
+                [12.0, 27.0, 24.0],  # (1, 1, 4, 3) output tensor
+                [63.0, 108.0, 81.0],
+                [123.0, 198.0, 141.0],
+                [112.0, 177.0, 124.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_with_padding,
+    inputs=[x, W],
+    outputs=[y_with_padding],
+    name="test_conv_with_strides_padding",
+)
+
+# Convolution with strides=2 and no padding
+node_without_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[0, 0, 0, 0],
+    strides=[
+        2,
+        2,
+    ],  # Default values for other attributes: dilations=[1, 1], groups=1
+)
+y_without_padding = np.array(
+    [
+        [
+            [
+                [54.0, 72.0],  # (1, 1, 3, 2) output tensor
+                [144.0, 162.0],
+                [234.0, 252.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_without_padding,
+    inputs=[x, W],
+    outputs=[y_without_padding],
+    name="test_conv_with_strides_no_padding",
+)
+
+# Convolution with strides=2 and padding only along one dimension (the H dimension in NxCxHxW tensor)
+node_with_asymmetric_padding = onnx.helper.make_node(
+    "Conv",
+    inputs=["x", "W"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[1, 0, 1, 0],
+    strides=[
+        2,
+        2,
+    ],  # Default values for other attributes: dilations=[1, 1], groups=1
+)
+y_with_asymmetric_padding = np.array(
+    [
+        [
+            [
+                [21.0, 33.0],  # (1, 1, 4, 2) output tensor
+                [99.0, 117.0],
+                [189.0, 207.0],
+                [171.0, 183.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_with_asymmetric_padding,
+    inputs=[x, W],
+    outputs=[y_with_asymmetric_padding],
+    name="test_conv_with_strides_and_asymmetric_padding",
+)
+```
+
+</details>
+
+
+### ConvInteger
+There are 2 test cases, listed as following:
+<details>
+<summary>with_padding</summary>
+
+```python
+x = (
+    np.array([2, 3, 4, 5, 6, 7, 8, 9, 10])
+    .astype(np.uint8)
+    .reshape((1, 1, 3, 3))
+)
+x_zero_point = np.uint8(1)
+w_zero_points = np.array([0, 1], dtype=np.uint8)
+w = np.array([1, 1, 1, 1, 1, 1, 1, 1]).astype(np.uint8).reshape((2, 1, 2, 2))
+
+y = (
+    np.array(
+        [
+            1,
+            3,
+            5,
+            3,
+            5,
+            12,
+            16,
+            9,
+            11,
+            24,
+            28,
+            15,
+            7,
+            15,
+            17,
+            9,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+        ]
+    )
+    .astype(np.int32)
+    .reshape((1, 2, 4, 4))
+)
+
+# ConvInteger with padding
+convinteger_node_with_padding = onnx.helper.make_node(
+    "ConvInteger",
+    inputs=["x", "w", "x_zero_point", "w_zero_points"],
+    outputs=["y"],
+    pads=[1, 1, 1, 1],
+)
+
+expect(
+    convinteger_node_with_padding,
+    inputs=[x, w, x_zero_point, w_zero_points],
+    outputs=[y],
+    name="test_convinteger_with_padding",
+)
+```
+
+</details>
+<details>
+<summary>without_padding</summary>
+
+```python
+x = (
+    np.array([2, 3, 4, 5, 6, 7, 8, 9, 10])
+    .astype(np.uint8)
+    .reshape((1, 1, 3, 3))
+)
+x_zero_point = np.uint8(1)
+w = np.array([1, 1, 1, 1]).astype(np.uint8).reshape((1, 1, 2, 2))
+
+y = np.array([12, 16, 24, 28]).astype(np.int32).reshape(1, 1, 2, 2)
+
+# ConvInteger without padding
+convinteger_node = onnx.helper.make_node(
+    "ConvInteger", inputs=["x", "w", "x_zero_point"], outputs=["y"]
+)
+
+expect(
+    convinteger_node,
+    inputs=[x, w, x_zero_point],
+    outputs=[y],
+    name="test_convinteger_without_padding",
+)
+```
+
+</details>
+
+
+### ConvTranspose
+There are 9 test cases, listed as following:
+<details>
+<summary>convtranspose</summary>
+
+```python
+x = np.array(
+    [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"])
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],  # (1, 2, 5, 5)
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose")
+```
+
+</details>
+<details>
+<summary>convtranspose_1d</summary>
+
+```python
+x = np.array([[[0.0, 1.0, 2.0]]]).astype(np.float32)  # (1, 1, 3)
+
+W = np.array([[[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]]).astype(  # (1, 2, 3)
+    np.float32
+)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"])
+
+y = np.array(
+    [[[0.0, 1.0, 3.0, 3.0, 2.0], [0.0, 1.0, 3.0, 3.0, 2.0]]]  # (1, 2, 5)
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_1d")
+```
+
+</details>
+<details>
+<summary>convtranspose_3d</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [
+                [
+                    [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 3, 4, 5)
+                    [5.0, 6.0, 7.0, 8.0, 9.0],
+                    [10.0, 11.0, 12.0, 13.0, 14.0],
+                    [15.0, 16.0, 17.0, 18.0, 19.0],
+                ],
+                [
+                    [20.0, 21.0, 22.0, 23.0, 24.0],
+                    [25.0, 26.0, 27.0, 28.0, 29.0],
+                    [30.0, 31.0, 32.0, 33.0, 34.0],
+                    [35.0, 36.0, 37.0, 38.0, 39.0],
+                ],
+                [
+                    [40.0, 41.0, 42.0, 43.0, 44.0],
+                    [45.0, 46.0, 47.0, 48.0, 49.0],
+                    [50.0, 51.0, 52.0, 53.0, 54.0],
+                    [55.0, 56.0, 57.0, 58.0, 59.0],
+                ],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [
+                [
+                    [1.0, 1.0, 1.0],  # (1, 2, 3, 3, 3)
+                    [1.0, 1.0, 1.0],
+                    [1.0, 1.0, 1.0],
+                ],
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+            ],
+            [
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"])
+
+y = np.array(
+    [
+        [
+            [
+                [
+                    [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0],  # (1, 2, 5, 6, 7)
+                    [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0],
+                    [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0],
+                    [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0],
+                    [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0],
+                    [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0],
+                ],
+                [
+                    [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0],
+                    [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0],
+                    [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0],
+                    [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0],
+                    [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0],
+                    [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0],
+                ],
+                [
+                    [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0],
+                    [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0],
+                    [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0],
+                    [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0],
+                    [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0],
+                    [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0],
+                ],
+                [
+                    [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0],
+                    [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0],
+                    [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0],
+                    [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0],
+                    [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0],
+                    [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0],
+                ],
+                [
+                    [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0],
+                    [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0],
+                    [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0],
+                    [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0],
+                    [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0],
+                    [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0],
+                ],
+            ],
+            [
+                [
+                    [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0],
+                    [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0],
+                    [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0],
+                    [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0],
+                    [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0],
+                    [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0],
+                ],
+                [
+                    [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0],
+                    [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0],
+                    [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0],
+                    [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0],
+                    [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0],
+                    [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0],
+                ],
+                [
+                    [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0],
+                    [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0],
+                    [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0],
+                    [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0],
+                    [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0],
+                    [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0],
+                ],
+                [
+                    [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0],
+                    [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0],
+                    [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0],
+                    [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0],
+                    [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0],
+                    [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0],
+                ],
+                [
+                    [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0],
+                    [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0],
+                    [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0],
+                    [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0],
+                    [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0],
+                    [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0],
+                ],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_3d")
+```
+
+</details>
+<details>
+<summary>convtranspose_attributes</summary>
+
+```python
+x = np.array(
+    [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ]
+    ]
+).astype(np.float32)
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],  # (1, 2, 10, 8)
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.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, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_shape=[10, 8]
+)
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_output_shape")
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_padding=[1, 1]
+)
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pad")
+
+node = onnx.helper.make_node(
+    "ConvTranspose",
+    ["X", "W"],
+    ["Y"],
+    name="test",
+    strides=[3, 2],
+    output_shape=[10, 8],
+    kernel_shape=[3, 3],
+    output_padding=[1, 1],
+)
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_kernel_shape")
+```
+
+</details>
+<details>
+<summary>convtranspose_autopad_same</summary>
+
+```python
+x = np.array(
+    [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], auto_pad="SAME_UPPER", strides=[2, 2]
+)
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                [3.0, 3.0, 8.0, 5.0, 12.0, 7.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0],
+                [9.0, 9.0, 20.0, 11.0, 24.0, 13.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0],
+            ],
+            [
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                [3.0, 3.0, 8.0, 5.0, 12.0, 7.0],
+                [3.0, 3.0, 7.0, 4.0, 9.0, 5.0],
+                [9.0, 9.0, 20.0, 11.0, 24.0, 13.0],
+                [6.0, 6.0, 13.0, 7.0, 15.0, 8.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_autopad_same")
+```
+
+</details>
+<details>
+<summary>convtranspose_dilations</summary>
+
+```python
+x = np.array(
+    [[[[3.0, 8.0, 1.0], [9.0, 5.0, 7.0], [3.0, 2.0, 6.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+W = np.array([[[[7.0, 2.0], [1.0, 9.0]]]]).astype(np.float32)  # (1, 1, 2, 2)
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], dilations=[2, 2]
+)
+
+y = np.array(
+    [
+        [
+            [
+                [21.0, 56.0, 13.0, 16.0, 2.0],  # [1, 1, 5, 5]
+                [63.0, 35.0, 67.0, 10.0, 14.0],
+                [24.0, 22.0, 76.0, 76.0, 21.0],
+                [9.0, 5.0, 88.0, 45.0, 63.0],
+                [3.0, 2.0, 33.0, 18.0, 54.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_dilations")
+```
+
+</details>
+<details>
+<summary>convtranspose_group_2</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+        ]
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ],
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ],
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"], group=2)
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+            [
+                [9.0, 19.0, 30.0, 21.0, 11.0],
+                [21.0, 44.0, 69.0, 48.0, 25.0],
+                [36.0, 75.0, 117.0, 81.0, 42.0],
+                [27.0, 56.0, 87.0, 60.0, 31.0],
+                [15.0, 31.0, 48.0, 33.0, 17.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_group_2")
+```
+
+</details>
+<details>
+<summary>convtranspose_group_2_image_3</summary>
+
+```python
+x = np.array(
+    [
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+        ],
+        [
+            [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0], [24.0, 25.0, 26.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+        ],
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+        ],
+    ]
+).astype(np.float32)
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ],
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ],
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"], group=2)
+
+y = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+            [
+                [9.0, 19.0, 30.0, 21.0, 11.0],
+                [21.0, 44.0, 69.0, 48.0, 25.0],
+                [36.0, 75.0, 117.0, 81.0, 42.0],
+                [27.0, 56.0, 87.0, 60.0, 31.0],
+                [15.0, 31.0, 48.0, 33.0, 17.0],
+            ],
+        ],
+        [
+            [
+                [18.0, 37.0, 57.0, 39.0, 20.0],
+                [39.0, 80.0, 123.0, 84.0, 43.0],
+                [63.0, 129.0, 198.0, 135.0, 69.0],
+                [45.0, 92.0, 141.0, 96.0, 49.0],
+                [24.0, 49.0, 75.0, 51.0, 26.0],
+            ],
+            [
+                [9.0, 19.0, 30.0, 21.0, 11.0],
+                [21.0, 44.0, 69.0, 48.0, 25.0],
+                [36.0, 75.0, 117.0, 81.0, 42.0],
+                [27.0, 56.0, 87.0, 60.0, 31.0],
+                [15.0, 31.0, 48.0, 33.0, 17.0],
+            ],
+        ],
+        [
+            [
+                [0.0, 1.0, 3.0, 3.0, 2.0],
+                [3.0, 8.0, 15.0, 12.0, 7.0],
+                [9.0, 21.0, 36.0, 27.0, 15.0],
+                [9.0, 20.0, 33.0, 24.0, 13.0],
+                [6.0, 13.0, 21.0, 15.0, 8.0],
+            ],
+            [
+                [9.0, 19.0, 30.0, 21.0, 11.0],
+                [21.0, 44.0, 69.0, 48.0, 25.0],
+                [36.0, 75.0, 117.0, 81.0, 42.0],
+                [27.0, 56.0, 87.0, 60.0, 31.0],
+                [15.0, 31.0, 48.0, 33.0, 17.0],
+            ],
+        ],
+    ]
+).astype(np.float32)
+
+expect(
+    node, inputs=[x, W], outputs=[y], name="test_convtranspose_group_2_image_3"
+)
+```
+
+</details>
+<details>
+<summary>convtranspose_pads</summary>
+
+```python
+x = np.array(
+    [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+).astype(np.float32)
+
+W = np.array(
+    [
+        [
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+            [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+        ]
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], pads=[1, 2, 1, 2]
+)
+
+y = np.array(
+    [
+        [
+            [
+                [1.0, 1.0, 3.0],  # (1, 2, 7, 3)
+                [1.0, 1.0, 3.0],
+                [7.0, 4.0, 9.0],
+                [7.0, 4.0, 9.0],
+                [7.0, 4.0, 9.0],
+                [13.0, 7.0, 15.0],
+                [13.0, 7.0, 15.0],
+            ],
+            [
+                [1.0, 1.0, 3.0],
+                [1.0, 1.0, 3.0],
+                [7.0, 4.0, 9.0],
+                [7.0, 4.0, 9.0],
+                [7.0, 4.0, 9.0],
+                [13.0, 7.0, 15.0],
+                [13.0, 7.0, 15.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pads")
+```
+
+</details>
+
+
+### Cos
+There are 1 test cases, listed as following:
+<details>
+<summary>cos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Cos",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.cos(x)
+expect(node, inputs=[x], outputs=[y], name="test_cos_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.cos(x)
+expect(node, inputs=[x], outputs=[y], name="test_cos")
+```
+
+</details>
+
+
+### Cosh
+There are 1 test cases, listed as following:
+<details>
+<summary>cosh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Cosh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.cosh(x)  # expected output [1.54308069,  1.,  1.54308069]
+expect(node, inputs=[x], outputs=[y], name="test_cosh_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.cosh(x)
+expect(node, inputs=[x], outputs=[y], name="test_cosh")
+```
+
+</details>
+
+
+### CumProd
+There are 9 test cases, listed as following:
+<details>
+<summary>cumprod_1d</summary>
+
+```python
+node = onnx.helper.make_node("CumProd", inputs=["x", "axis"], outputs=["y"])
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.array(0, dtype=np.int32)
+y = np.array([1.0, 2.0, 6.0, 24.0, 120.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d")
+```
+
+</details>
+<details>
+<summary>cumprod_1d_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd", inputs=["x", "axis"], outputs=["y"], exclusive=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.array(0, dtype=np.int32)
+y = np.array([1.0, 1.0, 2.0, 6.0, 24.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_exclusive")
+```
+
+</details>
+<details>
+<summary>cumprod_1d_int32_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd", inputs=["x", "axis"], outputs=["y"], exclusive=1
+)
+x = np.array([1, 2, 3, 4, 5]).astype(np.int32)
+axis = np.array(0, dtype=np.int32)
+y = np.array([1, 1, 2, 6, 24]).astype(np.int32)
+expect(
+    node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_int32_exclusive"
+)
+```
+
+</details>
+<details>
+<summary>cumprod_1d_reverse</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd", inputs=["x", "axis"], outputs=["y"], reverse=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.array(0, dtype=np.int32)
+y = np.array([120.0, 120.0, 60.0, 20.0, 5.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_reverse")
+```
+
+</details>
+<details>
+<summary>cumprod_1d_reverse_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd", inputs=["x", "axis"], outputs=["y"], reverse=1, exclusive=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.array(0, dtype=np.int32)
+y = np.array([120.0, 60.0, 20.0, 5.0, 1.0]).astype(np.float64)
+expect(
+    node,
+    inputs=[x, axis],
+    outputs=[y],
+    name="test_cumprod_1d_reverse_exclusive",
+)
+```
+
+</details>
+<details>
+<summary>cumprod_2d_axis_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.array(0, dtype=np.int32)
+y = (
+    np.array([1.0, 2.0, 3.0, 4.0, 10.0, 18.0])
+    .astype(np.float64)
+    .reshape((2, 3))
+)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_axis_0")
+```
+
+</details>
+<details>
+<summary>cumprod_2d_axis_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.array(1, dtype=np.int32)
+y = (
+    np.array([1.0, 2.0, 6.0, 4.0, 20.0, 120.0])
+    .astype(np.float64)
+    .reshape((2, 3))
+)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_axis_1")
+```
+
+</details>
+<details>
+<summary>cumprod_2d_int32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.int32).reshape((2, 3))
+axis = np.array(0, dtype=np.int32)
+y = np.array([1, 2, 3, 4, 10, 18]).astype(np.int32).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_int32")
+```
+
+</details>
+<details>
+<summary>cumprod_2d_negative_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumProd",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.array(-1, dtype=np.int32)
+y = (
+    np.array([1.0, 2.0, 6.0, 4.0, 20.0, 120.0])
+    .astype(np.float64)
+    .reshape((2, 3))
+)
+expect(
+    node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_negative_axis"
+)
+```
+
+</details>
+
+
+### CumSum
+There are 9 test cases, listed as following:
+<details>
+<summary>cumsum_1d</summary>
+
+```python
+node = onnx.helper.make_node("CumSum", inputs=["x", "axis"], outputs=["y"])
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.int32(0)
+y = np.array([1.0, 3.0, 6.0, 10.0, 15.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d")
+```
+
+</details>
+<details>
+<summary>cumsum_1d_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.int32(0)
+y = np.array([0.0, 1.0, 3.0, 6.0, 10.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_exclusive")
+```
+
+</details>
+<details>
+<summary>cumsum_1d_int32_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1
+)
+x = np.array([1, 2, 3, 4, 5]).astype(np.int32)
+axis = np.int32(0)
+y = np.array([0, 1, 3, 6, 10]).astype(np.int32)
+expect(
+    node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_int32_exclusive"
+)
+```
+
+</details>
+<details>
+<summary>cumsum_1d_reverse</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.int32(0)
+y = np.array([15.0, 14.0, 12.0, 9.0, 5.0]).astype(np.float64)
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse")
+```
+
+</details>
+<details>
+<summary>cumsum_1d_reverse_exclusive</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1, exclusive=1
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+axis = np.int32(0)
+y = np.array([14.0, 12.0, 9.0, 5.0, 0.0]).astype(np.float64)
+expect(
+    node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse_exclusive"
+)
+```
+
+</details>
+<details>
+<summary>cumsum_2d_axis_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.int32(0)
+y = np.array([1.0, 2.0, 3.0, 5.0, 7.0, 9.0]).astype(np.float64).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_0")
+```
+
+</details>
+<details>
+<summary>cumsum_2d_axis_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.int32(1)
+y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_1")
+```
+
+</details>
+<details>
+<summary>cumsum_2d_int32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.int32).reshape((2, 3))
+axis = np.int32(0)
+y = np.array([1, 2, 3, 5, 7, 9]).astype(np.int32).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_int32")
+```
+
+</details>
+<details>
+<summary>cumsum_2d_negative_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "CumSum",
+    inputs=["x", "axis"],
+    outputs=["y"],
+)
+x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+axis = np.int32(-1)
+y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3))
+expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_negative_axis")
+```
+
+</details>
+
+
+### DFT
+There are 2 test cases, listed as following:
+<details>
+<summary>dft</summary>
+
+```python
+node = onnx.helper.make_node("DFT", inputs=["x", "", "axis"], outputs=["y"])
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+axis = np.array(1, dtype=np.int64)
+y = np.fft.fft(x, axis=0)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft")
+
+node = onnx.helper.make_node("DFT", inputs=["x", "", "axis"], outputs=["y"])
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+axis = np.array(2, dtype=np.int64)
+y = np.fft.fft(x, axis=1)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft_axis")
+
+node = onnx.helper.make_node(
+    "DFT", inputs=["x", "", "axis"], outputs=["y"], inverse=1
+)
+x = np.arange(0, 100, dtype=np.complex64).reshape(10, 10)
+axis = np.array(1, dtype=np.int64)
+y = np.fft.ifft(x, axis=0)
+
+x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft_inverse")
+
+# Test RFFT (Real FFT): real input -> one-sided complex output
+node = onnx.helper.make_node(
+    "DFT", inputs=["x", "", "axis"], outputs=["y"], onesided=1
+)
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+axis = np.array(1, dtype=np.int64)
+y = np.fft.rfft(x, axis=0)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft_rfft")
+
+# Test IRFFT (Inverse Real FFT): one-sided complex input -> real output
+node = onnx.helper.make_node(
+    "DFT", inputs=["x", "", "axis"], outputs=["y"], onesided=1, inverse=1
+)
+# Create one-sided complex input (6 bins for signal length 10)
+x = np.fft.rfft(np.arange(0, 100).reshape(10, 10), axis=0).astype(np.complex64)
+axis = np.array(1, dtype=np.int64)
+y = np.fft.irfft(x, n=10, axis=0)
+
+x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+y = y.reshape(1, 10, 10, 1).astype(np.float32)
+expect(node, inputs=[x, axis], outputs=[y], name="test_dft_irfft")
+```
+
+</details>
+<details>
+<summary>opset19</summary>
+
+```python
+node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=1)
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+y = np.fft.fft(x, axis=0)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+
+node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=2)
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+y = np.fft.fft(x, axis=1)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_axis_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+
+node = onnx.helper.make_node(
+    "DFT", inputs=["x"], outputs=["y"], inverse=1, axis=1
+)
+x = np.arange(0, 100, dtype=np.complex64).reshape(
+    10,
+    10,
+)
+y = np.fft.ifft(x, axis=0)
+
+x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_inverse_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+
+# Test RFFT (Real FFT): real input -> one-sided complex output
+node = onnx.helper.make_node(
+    "DFT", inputs=["x"], outputs=["y"], onesided=1, axis=1
+)
+x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+y = np.fft.rfft(x, axis=0)
+
+x = x.reshape(1, 10, 10, 1)
+y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_rfft_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+
+# Test IRFFT (Inverse Real FFT): one-sided complex input -> real output
+node = onnx.helper.make_node(
+    "DFT", inputs=["x"], outputs=["y"], onesided=1, inverse=1, axis=1
+)
+# Create one-sided complex input (6 bins for signal length 10)
+x = np.fft.rfft(np.arange(0, 100).reshape(10, 10), axis=0).astype(np.complex64)
+y = np.fft.irfft(x, n=10, axis=0)
+
+x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+y = y.reshape(1, 10, 10, 1).astype(np.float32)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dft_irfft_opset19",
+    opset_imports=[onnx.helper.make_opsetid("", 19)],
+)
+```
+
+</details>
+
+
+### DeformConv
+There are 3 test cases, listed as following:
+<details>
+<summary>deformconv</summary>
+
+```python
+X = np.arange(9).astype(np.float32)
+X.shape = (1, 1, 3, 3)
+W = np.ones((1, 1, 2, 2), dtype=np.float32)
+
+# Convolution with padding
+offset_with_padding = np.zeros((1, 8, 4, 4), dtype=np.float32)
+# h-coord of [0, 0] element of kernel, at output position [0, 0]
+offset_with_padding[0, 0, 0, 0] = 0.5
+# w-coord of [1, 0] element of kernel, at output position [1, 2]
+offset_with_padding[0, 5, 1, 2] = -0.1
+
+node_with_padding = onnx.helper.make_node(
+    "DeformConv",
+    inputs=["X", "W", "offset_with_padding"],
+    outputs=["Y_with_padding"],
+    kernel_shape=[2, 2],
+    pads=[1, 1, 1, 1],
+)
+Y_with_padding = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 3.0, 2.0],  # (1, 1, 4, 4) output tensor
+                [3.0, 8.0, 11.9, 7.0],
+                [9.0, 20.0, 24.0, 13.0],
+                [6.0, 13.0, 15.0, 8.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_with_padding,
+    inputs=[X, W, offset_with_padding],
+    outputs=[Y_with_padding],
+    name="test_basic_deform_conv_with_padding",
+)
+
+# Convolution without padding
+offset_without_padding = np.zeros((1, 8, 2, 2), dtype=np.float32)
+# h-coord of [0, 0] element of kernel, at output position [0, 0]
+offset_without_padding[0, 0, 0, 0] = 0.5
+# w-coord of [1, 0] element of kernel, at output position [0, 1]
+offset_without_padding[0, 5, 0, 1] = -0.1
+
+node_without_padding = onnx.helper.make_node(
+    "DeformConv",
+    inputs=["X", "W", "offset_without_padding"],
+    outputs=["Y_without_padding"],
+    kernel_shape=[2, 2],
+    pads=[0, 0, 0, 0],
+)
+Y_without_padding = np.array(
+    [
+        [
+            [
+                [9.5, 11.9],  # (1, 1, 2, 2) output tensor
+                [20.0, 24.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node_without_padding,
+    inputs=[X, W, offset_without_padding],
+    outputs=[Y_without_padding],
+    name="test_basic_deform_conv_without_padding",
+)
+```
+
+</details>
+<details>
+<summary>deformconv_with_mask_bias</summary>
+
+```python
+X = np.arange(9).astype(np.float32)
+X.shape = (1, 1, 3, 3)
+W = np.ones((1, 1, 2, 2), dtype=np.float32)
+B = np.ones((1,), dtype=np.float32)
+
+offset = np.zeros((1, 8, 2, 2), dtype=np.float32)
+# h-coord of [0, 0] element of kernel, at output position [0, 0]
+offset[0, 0, 0, 0] = 0.5
+# w-coord of [1, 0] element of kernel, at output position [0, 1]
+offset[0, 5, 0, 1] = -0.1
+
+mask = np.ones((1, 4, 2, 2), dtype=np.float32)
+mask[0, 2, 1, 1] = 0.2  # [1, 0] element of kernel at output position [1, 1]
+
+node = onnx.helper.make_node(
+    "DeformConv",
+    inputs=["X", "W", "offset", "B", "mask"],
+    outputs=["Y"],
+    kernel_shape=[2, 2],
+    pads=[0, 0, 0, 0],
+)
+Y = np.array(
+    [
+        [
+            [
+                [10.5, 12.9],  # (1, 1, 2, 2) output tensor
+                [21.0, 19.4],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node,
+    inputs=[X, W, offset, B, mask],
+    outputs=[Y],
+    name="test_deform_conv_with_mask_bias",
+)
+```
+
+</details>
+<details>
+<summary>deformconv_with_multiple_offset_groups</summary>
+
+```python
+X = np.zeros((1, 2, 3, 3), dtype=np.float32)
+X[0, 0] = np.reshape(np.arange(9).astype(np.float32), (3, 3))
+X[0, 1] = np.reshape(np.arange(8, -1, -1).astype(np.float32), (3, 3))
+X.shape = (1, 2, 3, 3)
+W = np.ones((1, 2, 2, 2), dtype=np.float32)
+
+offset = np.zeros((1, 16, 2, 2), dtype=np.float32)
+# h-coord of [0, 0] element of kernel in channel 0, at output position [0, 0]
+offset[0, 0, 0, 0] = 0.5
+# w-coord of [1, 0] element of kernel in channel 1, at output position [0, 1]
+offset[0, 13, 0, 1] = -0.1
+
+node = onnx.helper.make_node(
+    "DeformConv",
+    inputs=["X", "W", "offset"],
+    outputs=["Y"],
+    kernel_shape=[2, 2],
+    pads=[0, 0, 0, 0],
+    offset_group=2,
+)
+Y = np.array(
+    [
+        [
+            [
+                [33.5, 32.1],  # (1, 1, 2, 2) output tensor
+                [32.0, 32.0],
+            ]
+        ]
+    ]
+).astype(np.float32)
+expect(
+    node,
+    inputs=[X, W, offset],
+    outputs=[Y],
+    name="test_deform_conv_with_multiple_offset_groups",
+)
+```
+
+</details>
+
+
+### DepthToSpace
+There are 2 test cases, listed as following:
+<details>
+<summary>crd_mode_example</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="CRD"
+)
+
+# (1, 8, 2, 3) input tensor
+x = np.array(
+    [
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]],
+            [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]],
+            [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]],
+            [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]],
+            [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]],
+            [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]],
+            [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]],
+        ]
+    ]
+).astype(np.float32)
+
+# (1, 2, 4, 6) output tensor
+y = np.array(
+    [
+        [
+            [
+                [0.0, 9.0, 1.0, 10.0, 2.0, 11.0],
+                [18.0, 27.0, 19.0, 28.0, 20.0, 29.0],
+                [3.0, 12.0, 4.0, 13.0, 5.0, 14.0],
+                [21.0, 30.0, 22.0, 31.0, 23.0, 32.0],
+            ],
+            [
+                [36.0, 45.0, 37.0, 46.0, 38.0, 47.0],
+                [54.0, 63.0, 55.0, 64.0, 56.0, 65.0],
+                [39.0, 48.0, 40.0, 49.0, 41.0, 50.0],
+                [57.0, 66.0, 58.0, 67.0, 59.0, 68.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_depthtospace_crd_mode_example")
+```
+
+</details>
+<details>
+<summary>default_mode_example</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="DCR"
+)
+
+# (1, 8, 2, 3) input tensor
+x = np.array(
+    [
+        [
+            [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
+            [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]],
+            [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]],
+            [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]],
+            [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]],
+            [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]],
+            [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]],
+            [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]],
+        ]
+    ]
+).astype(np.float32)
+
+# (1, 2, 4, 6) output tensor
+y = np.array(
+    [
+        [
+            [
+                [0.0, 18.0, 1.0, 19.0, 2.0, 20.0],
+                [36.0, 54.0, 37.0, 55.0, 38.0, 56.0],
+                [3.0, 21.0, 4.0, 22.0, 5.0, 23.0],
+                [39.0, 57.0, 40.0, 58.0, 41.0, 59.0],
+            ],
+            [
+                [9.0, 27.0, 10.0, 28.0, 11.0, 29.0],
+                [45.0, 63.0, 46.0, 64.0, 47.0, 65.0],
+                [12.0, 30.0, 13.0, 31.0, 14.0, 32.0],
+                [48.0, 66.0, 49.0, 67.0, 50.0, 68.0],
+            ],
+        ]
+    ]
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_depthtospace_example")
+```
+
+</details>
+
+
+### DequantizeLinear
+There are 14 test cases, listed as following:
+<details>
+<summary>axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+)
+
+# 1-D tensor zero point and scale of size equal to axis 1 of the input tensor
+x = np.array(
+    [
+        [
+            [[3, 89], [34, 200], [74, 59]],
+            [[5, 24], [24, 87], [32, 13]],
+            [[245, 99], [4, 142], [121, 102]],
+        ],
+    ],
+    dtype=np.uint8,
+)
+x_scale = np.array([2, 4, 5], dtype=np.float32)
+x_zero_point = np.array([84, 24, 196], dtype=np.uint8)
+y = (
+    x.astype(np.float32) - x_zero_point.reshape(1, 3, 1, 1).astype(np.float32)
+) * x_scale.reshape(1, 3, 1, 1)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_axis",
+)
+```
+
+</details>
+<details>
+<summary>blocked</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=1,
+    block_size=2,
+)
+
+x = np.array(
+    [
+        [
+            [[3, 89], [34, 200], [74, 59]],
+            [[5, 24], [24, 87], [32, 13]],
+            [[5, 12], [12, 33], [65, 42]],
+            [[245, 99], [4, 142], [121, 102]],
+        ],
+    ],
+    dtype=np.uint8,
+)
+
+x_scale = np.array(
+    [
+        [
+            [[3.0, 2.0], [4.0, 1.0], [2.0, 2.0]],
+            [[5.0, 2.0], [4.0, 3.0], [5.0, 2.0]],
+        ],
+    ],
+    dtype=np.float32,
+)
+x_zero_point = np.array(
+    [
+        [
+            [[1, 0], [0, 1], [2, 20]],
+            [[3, 2], [4, 3], [15, 2]],
+        ],
+    ],
+    dtype=np.uint8,
+)
+
+# x.shape = (1, 4, 3, 2)
+# x_scale.shape = (1, 2, 3, 2)
+assert x_scale.shape == x_zero_point.shape
+block_axis = 1
+# The block shape is [x.shape[i] // x_scale.shape[i] for i in range(len(x.shape))] = (1, 2, 1, 1)
+assert all(
+    x.shape[i] == x_scale.shape[i]
+    for i in range(len(x.shape))
+    if i != block_axis
+)
+assert x.shape[block_axis] % x_scale.shape[block_axis] == 0
+repeats = x.shape[block_axis] // x_scale.shape[block_axis]
+
+# Create element-wise scale and zero point
+x_scale_elementwise = np.repeat(x_scale, repeats=repeats, axis=block_axis)
+x_zero_point_elementwise = np.repeat(
+    x_zero_point, repeats=repeats, axis=block_axis
+)
+
+y = (
+    x.astype(np.float32) - x_zero_point_elementwise.astype(np.float32)
+) * x_scale_elementwise
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_blocked",
+)
+```
+
+</details>
+<details>
+<summary>dequantizelinear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+)
+
+# scalar zero point and scale
+x = np.array([0, 3, 128, 255]).astype(np.uint8)
+x_scale = np.float32(2)
+x_zero_point = np.uint8(128)
+y = np.array([-256, -250, 0, 254], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear",
+)
+```
+
+</details>
+<details>
+<summary>e4m3fn</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104])
+x_scale = np.float32(2)
+y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale],
+    outputs=[y],
+    name="test_dequantizelinear_e4m3fn",
+)
+```
+
+</details>
+<details>
+<summary>e4m3fn_float16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104])
+x_scale = np.float16(2)
+y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float16)
+
+expect(
+    node,
+    inputs=[x, x_scale],
+    outputs=[y],
+    name="test_dequantizelinear_e4m3fn_float16",
+)
+```
+
+</details>
+<details>
+<summary>e4m3fn_zero_point</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104])
+zero_point = make_tensor("zero_point", TensorProto.FLOAT8E4M3FN, [1], [0])
+x_scale = np.float32(2)
+y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_e4m3fn_zero_point",
+)
+```
+
+</details>
+<details>
+<summary>e5m2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, -96])
+x_scale = np.float32(2)
+y = np.array([0.0, 1.0, 2.0, 98304.0, -192.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale],
+    outputs=[y],
+    name="test_dequantizelinear_e5m2",
+)
+```
+
+</details>
+<details>
+<summary>float4e2m1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.FLOAT4E2M1, [5], [0, 1, -1, 1.5, -4])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.FLOAT4E2M1, (1,), [0])
+y = np.array([0, 2, -2, 3, -8], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_float4e2m1",
+)
+```
+
+</details>
+<details>
+<summary>int16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([-300, -30, -1025, 1270]).astype(np.int16)
+x_scale = np.float32(2)
+x_zero_point = np.int16(-1024)
+y = np.array([1448.0, 1988.0, -2.0, 4588.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_int16",
+)
+```
+
+</details>
+<details>
+<summary>int2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.INT2, [4], [0, 1, -1, -2])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.INT2, (1,), [1])
+y = np.array([-2, 0, -4, -6], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_int2",
+)
+```
+
+</details>
+<details>
+<summary>int4</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.INT4, [5], [0, 1, 7, -4, -8])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.INT4, (1,), [1])
+y = np.array([-2, 0, 12, -10, -18], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_int4",
+)
+```
+
+</details>
+<details>
+<summary>uint16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([30000, 31000, 32768, 33000]).astype(np.uint16)
+x_scale = np.float32(2)
+x_zero_point = np.uint16(32767)
+y = np.array([-5534.0, -3534.0, 2.0, 466.0], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_uint16",
+)
+```
+
+</details>
+<details>
+<summary>uint2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.UINT2, [4], [0, 1, 2, 3])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.UINT2, (1,), [1])
+y = np.array([-2, 0, 2, 4], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_uint2",
+)
+```
+
+</details>
+<details>
+<summary>uint4</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DequantizeLinear",
+    inputs=["x", "x_scale", "x_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+# scalar zero point and scale
+x = make_tensor("x", TensorProto.UINT4, [5], [0, 1, 7, 10, 15])
+x_scale = np.float32(2)
+x_zero_point = make_tensor("x_zero_point", TensorProto.UINT4, (1,), [1])
+y = np.array([-2, 0, 12, 18, 28], dtype=np.float32)
+
+expect(
+    node,
+    inputs=[x, x_scale, x_zero_point],
+    outputs=[y],
+    name="test_dequantizelinear_uint4",
+)
+```
+
+</details>
+
+
+### Det
+There are 2 test cases, listed as following:
+<details>
+<summary>2d</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Det",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.arange(4).reshape(2, 2).astype(np.float32)
+y = np.linalg.det(x)  # expect -2
+expect(node, inputs=[x], outputs=[y], name="test_det_2d")
+```
+
+</details>
+<details>
+<summary>nd</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Det",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([[[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]]]).astype(
+    np.float32
+)
+y = np.linalg.det(x)  # expect array([-2., -3., -8.])
+expect(node, inputs=[x], outputs=[y], name="test_det_nd")
+```
+
+</details>
+
+
+### Div
+There are 2 test cases, listed as following:
+<details>
+<summary>div</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Div",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([3, 4]).astype(np.float32)
+y = np.array([1, 2]).astype(np.float32)
+z = x / y  # expected output [3., 2.]
+expect(node, inputs=[x, y], outputs=[z], name="test_div_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.rand(3, 4, 5).astype(np.float32) + 1.0
+z = x / y
+expect(node, inputs=[x, y], outputs=[z], name="test_div")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_int8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_int16")
+
+x = np.array([-3, 3, -3, 3], dtype=np.int32)
+y = np.array([2, 2, -2, -2], dtype=np.int32)
+z = np.array([-1, 1, 1, -1], dtype=np.int32)
+expect(node, inputs=[x, y], outputs=[z], name="test_div_int32_trunc")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + 1
+z = x // y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_uint64")
+```
+
+</details>
+<details>
+<summary>div_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Div",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.rand(5).astype(np.float32) + 1.0
+z = x / y
+expect(node, inputs=[x, y], outputs=[z], name="test_div_bcast")
+```
+
+</details>
+
+
+### Dropout
+There are 12 test cases, listed as following:
+<details>
+<summary>default</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node("Dropout", inputs=["x"], outputs=["y"], seed=seed)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = dropout(x)
+expect(node, inputs=[x], outputs=[y], name="test_dropout_default")
+```
+
+</details>
+<details>
+<summary>default_mask</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x"], outputs=["y", "z"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y, z = dropout(x, return_mask=True)
+expect(node, inputs=[x], outputs=[y, z], name="test_dropout_default_mask")
+```
+
+</details>
+<details>
+<summary>default_mask_ratio</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r"], outputs=["y", "z"], seed=seed
+)
+
+r = np.float32(0.1)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y, z = dropout(x, r, return_mask=True)
+expect(
+    node, inputs=[x, r], outputs=[y, z], name="test_dropout_default_mask_ratio"
+)
+```
+
+</details>
+<details>
+<summary>default_old</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Dropout",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = x
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dropout_default_old",
+    opset_imports=[helper.make_opsetid("", 11)],
+)
+```
+
+</details>
+<details>
+<summary>default_ratio</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r"], outputs=["y"], seed=seed
+)
+
+r = np.float32(0.1)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = dropout(x, r)
+expect(node, inputs=[x, r], outputs=[y], name="test_dropout_default_ratio")
+```
+
+</details>
+<details>
+<summary>random_old</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Dropout",
+    inputs=["x"],
+    outputs=["y"],
+    ratio=0.2,
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = x
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_dropout_random_old",
+    opset_imports=[helper.make_opsetid("", 11)],
+)
+```
+
+</details>
+<details>
+<summary>training</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.75)
+t = np.bool_(True)
+y = dropout(x, r, training_mode=t)
+expect(node, inputs=[x, r, t], outputs=[y], name="test_training_dropout")
+```
+
+</details>
+<details>
+<summary>training_default</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.5)
+t = np.bool_(True)
+y = dropout(x, r, training_mode=t)
+expect(
+    node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_default"
+)
+```
+
+</details>
+<details>
+<summary>training_default_ratio_mask</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.5)
+t = np.bool_(True)
+y, z = dropout(x, r, training_mode=t, return_mask=True)
+expect(
+    node,
+    inputs=[x, r, t],
+    outputs=[y, z],
+    name="test_training_dropout_default_mask",
+)
+```
+
+</details>
+<details>
+<summary>training_default_zero_ratio</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.0)
+t = np.bool_(True)
+y = dropout(x, r, training_mode=t)
+expect(
+    node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_zero_ratio"
+)
+```
+
+</details>
+<details>
+<summary>training_default_zero_ratio_mask</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.0)
+t = np.bool_(True)
+y, z = dropout(x, r, training_mode=t, return_mask=True)
+expect(
+    node,
+    inputs=[x, r, t],
+    outputs=[y, z],
+    name="test_training_dropout_zero_ratio_mask",
+)
+```
+
+</details>
+<details>
+<summary>training_ratio_mask</summary>
+
+```python
+seed = np.int64(0)
+node = onnx.helper.make_node(
+    "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+r = np.float32(0.75)
+t = np.bool_(True)
+y, z = dropout(x, r, training_mode=t, return_mask=True)
+expect(
+    node, inputs=[x, r, t], outputs=[y, z], name="test_training_dropout_mask"
+)
+```
+
+</details>
+
+
+### DynamicQuantizeLinear
+There are 1 test cases, listed as following:
+<details>
+<summary>dynamicquantizelinear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "DynamicQuantizeLinear",
+    inputs=["x"],
+    outputs=["y", "y_scale", "y_zero_point"],
+)
+
+# expected scale 0.0196078438 and zero point 153
+X = np.array([0, 2, -3, -2.5, 1.34, 0.5]).astype(np.float32)
+x_min = np.minimum(0, np.min(X))
+x_max = np.maximum(0, np.max(X))
+Y_Scale = np.float32((x_max - x_min) / (255 - 0))  # uint8 -> [0, 255]
+Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8)
+Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[X],
+    outputs=[Y, Y_Scale, Y_ZeroPoint],
+    name="test_dynamicquantizelinear",
+)
+
+# expected scale 0.0156862754 and zero point 255
+X = np.array([-1.0, -2.1, -1.3, -2.5, -3.34, -4.0]).astype(np.float32)
+x_min = np.minimum(0, np.min(X))
+x_max = np.maximum(0, np.max(X))
+Y_Scale = np.float32((x_max - x_min) / (255 - 0))  # uint8 -> [0, 255]
+Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8)
+Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[X],
+    outputs=[Y, Y_Scale, Y_ZeroPoint],
+    name="test_dynamicquantizelinear_max_adjusted",
+)
+
+X = (
+    np.array([1, 2.1, 1.3, 2.5, 3.34, 4.0, 1.5, 2.6, 3.9, 4.0, 3.0, 2.345])
+    .astype(np.float32)
+    .reshape((3, 4))
+)
+
+# expected scale 0.0156862754 and zero point 0
+x_min = np.minimum(0, np.min(X))
+x_max = np.maximum(0, np.max(X))
+Y_Scale = np.float32((x_max - x_min) / (255 - 0))  # uint8 -> [0, 255]
+Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8)
+Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[X],
+    outputs=[Y, Y_Scale, Y_ZeroPoint],
+    name="test_dynamicquantizelinear_min_adjusted",
+)
+```
+
+</details>
+
+
+### Einsum
+There are 6 test cases, listed as following:
+<details>
+<summary>einsum_batch_diagonal</summary>
+
+```python
+Eqn = "...ii ->...i"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+)
+
+X = np.random.randn(3, 5, 5)
+Z = einsum_reference_implementation(Eqn, (X,))
+
+expect(node, inputs=[X], outputs=[Z], name="test_einsum_batch_diagonal")
+```
+
+</details>
+<details>
+<summary>einsum_batch_matmul</summary>
+
+```python
+Eqn = "bij, bjk -> bik"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn
+)
+
+X = np.random.randn(5, 2, 3)
+Y = np.random.randn(5, 3, 4)
+Z = einsum_reference_implementation(Eqn, (X, Y))
+
+expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_batch_matmul")
+```
+
+</details>
+<details>
+<summary>einsum_inner_prod</summary>
+
+```python
+Eqn = "i,i"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn
+)
+
+X = np.random.randn(5)
+Y = np.random.randn(5)
+Z = einsum_reference_implementation(Eqn, (X, Y))
+
+expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_inner_prod")
+```
+
+</details>
+<details>
+<summary>einsum_scalar</summary>
+
+```python
+Eqn = "->"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+)
+
+X = np.array(5.0)  # scalar input
+Z = einsum_reference_implementation(Eqn, (X,))
+
+expect(node, inputs=[X], outputs=[Z], name="test_einsum_scalar")
+```
+
+</details>
+<details>
+<summary>einsum_sum</summary>
+
+```python
+Eqn = "ij->i"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+)
+
+X = np.random.randn(3, 4)
+Z = einsum_reference_implementation(Eqn, (X,))
+
+expect(node, inputs=[X], outputs=[Z], name="test_einsum_sum")
+```
+
+</details>
+<details>
+<summary>einsum_transpose</summary>
+
+```python
+Eqn = "ij->ji"
+node = onnx.helper.make_node(
+    "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+)
+
+X = np.random.randn(3, 4)
+Y = einsum_reference_implementation(Eqn, (X,))
+
+expect(node, inputs=[X], outputs=[Y], name="test_einsum_transpose")
+```
+
+</details>
+
+
+### Elu
+There are 2 test cases, listed as following:
+<details>
+<summary>elu</summary>
+
+```python
+node = onnx.helper.make_node("Elu", inputs=["x"], outputs=["y"], alpha=2.0)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-1.2642411, 0., 1.]
+y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0
+expect(node, inputs=[x], outputs=[y], name="test_elu_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0
+expect(node, inputs=[x], outputs=[y], name="test_elu")
+```
+
+</details>
+<details>
+<summary>elu_default</summary>
+
+```python
+default_alpha = 1.0
+node = onnx.helper.make_node(
+    "Elu",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * default_alpha
+expect(node, inputs=[x], outputs=[y], name="test_elu_default")
+```
+
+</details>
+
+
+### Equal
+There are 4 test cases, listed as following:
+<details>
+<summary>equal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Equal",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = (np.random.randn(3, 4, 5) * 10).astype(np.int32)
+y = (np.random.randn(3, 4, 5) * 10).astype(np.int32)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal")
+
+x = (np.random.randn(3, 4, 5) * 10).astype(np.int8)
+y = (np.random.randn(3, 4, 5) * 10).astype(np.int8)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_int8")
+
+x = (np.random.randn(3, 4, 5) * 10).astype(np.int16)
+y = (np.random.randn(3, 4, 5) * 10).astype(np.int16)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint64")
+```
+
+</details>
+<details>
+<summary>equal_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Equal",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = (np.random.randn(3, 4, 5) * 10).astype(np.int32)
+y = (np.random.randn(5) * 10).astype(np.int32)
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_bcast")
+```
+
+</details>
+<details>
+<summary>equal_string</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Equal",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+x = np.array(["string1", "string2"], dtype=np.dtype(object))
+y = np.array(["string1", "string3"], dtype=np.dtype(object))
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_string")
+```
+
+</details>
+<details>
+<summary>equal_string_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Equal",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+x = np.array(["string1", "string2"], dtype=np.dtype(object))
+y = np.array(["string1"], dtype=np.dtype(object))
+z = np.equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_equal_string_broadcast")
+```
+
+</details>
+
+
+### Erf
+There are 1 test cases, listed as following:
+<details>
+<summary>erf</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Erf",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+y = np.vectorize(math.erf)(x).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_erf")
+```
+
+</details>
+
+
+### Exp
+There are 1 test cases, listed as following:
+<details>
+<summary>exp</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Exp",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.exp(x)  # expected output [0.36787945, 1., 2.71828175]
+expect(node, inputs=[x], outputs=[y], name="test_exp_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.exp(x)
+expect(node, inputs=[x], outputs=[y], name="test_exp")
+```
+
+</details>
+
+
+### Expand
+There are 2 test cases, listed as following:
+<details>
+<summary>dim_changed</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Expand",
+    inputs=["data", "new_shape"],
+    outputs=["expanded"],
+)
+shape = [3, 1]
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[1.], [2.], [3.]]
+new_shape = [2, 1, 6]
+expanded = data * np.ones(new_shape, dtype=np.float32)
+# print(expanded)
+# [[[1., 1., 1., 1., 1., 1.],
+#  [2., 2., 2., 2., 2., 2.],
+#  [3., 3., 3., 3., 3., 3.]],
+#
+# [[1., 1., 1., 1., 1., 1.],
+#  [2., 2., 2., 2., 2., 2.],
+#  [3., 3., 3., 3., 3., 3.]]]
+new_shape = np.array(new_shape, dtype=np.int64)
+expect(
+    node,
+    inputs=[data, new_shape],
+    outputs=[expanded],
+    name="test_expand_dim_changed",
+)
+```
+
+</details>
+<details>
+<summary>dim_unchanged</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Expand",
+    inputs=["data", "new_shape"],
+    outputs=["expanded"],
+)
+shape = [3, 1]
+new_shape = [3, 4]
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[1.], [2.], [3.]]
+expanded = np.tile(data, 4)
+# print(expanded)
+# [[1., 1., 1., 1.],
+# [2., 2., 2., 2.],
+# [3., 3., 3., 3.]]
+new_shape = np.array(new_shape, dtype=np.int64)
+expect(
+    node,
+    inputs=[data, new_shape],
+    outputs=[expanded],
+    name="test_expand_dim_unchanged",
+)
+```
+
+</details>
+
+
+### EyeLike
+There are 3 test cases, listed as following:
+<details>
+<summary>populate_off_main_diagonal</summary>
+
+```python
+shape = (4, 5)
+off_diagonal_offset = 1
+node = onnx.helper.make_node(
+    "EyeLike",
+    inputs=["x"],
+    outputs=["y"],
+    k=off_diagonal_offset,
+    dtype=onnx.TensorProto.FLOAT,
+)
+
+x = np.random.randint(0, 100, size=shape, dtype=np.int32)
+y = np.eye(shape[0], shape[1], k=off_diagonal_offset, dtype=np.float32)
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_eyelike_populate_off_main_diagonal",
+)
+```
+
+</details>
+<details>
+<summary>with_dtype</summary>
+
+```python
+shape = (3, 4)
+node = onnx.helper.make_node(
+    "EyeLike",
+    inputs=["x"],
+    outputs=["y"],
+    dtype=onnx.TensorProto.DOUBLE,
+)
+
+x = np.random.randint(0, 100, size=shape, dtype=np.int32)
+y = np.eye(shape[0], shape[1], dtype=np.float64)
+expect(node, inputs=[x], outputs=[y], name="test_eyelike_with_dtype")
+```
+
+</details>
+<details>
+<summary>without_dtype</summary>
+
+```python
+shape = (4, 4)
+node = onnx.helper.make_node(
+    "EyeLike",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.randint(0, 100, size=shape, dtype=np.int32)
+y = np.eye(shape[0], shape[1], dtype=np.int32)
+expect(node, inputs=[x], outputs=[y], name="test_eyelike_without_dtype")
+```
+
+</details>
+
+
+### Flatten
+There are 3 test cases, listed as following:
+<details>
+<summary>flatten</summary>
+
+```python
+shape = (2, 3, 4, 5)
+a = np.random.random_sample(shape).astype(np.float32)
+
+for i in range(len(shape)):
+    node = onnx.helper.make_node(
+        "Flatten",
+        inputs=["a"],
+        outputs=["b"],
+        axis=i,
+    )
+
+    new_shape = (1, -1) if i == 0 else (np.prod(shape[0:i]).astype(int), -1)
+    b = np.reshape(a, new_shape)
+    expect(node, inputs=[a], outputs=[b], name="test_flatten_axis" + str(i))
+```
+
+</details>
+<details>
+<summary>flatten_negative_axis</summary>
+
+```python
+shape = (2, 3, 4, 5)
+a = np.random.random_sample(shape).astype(np.float32)
+
+for i in range(-len(shape), 0):
+    node = onnx.helper.make_node(
+        "Flatten",
+        inputs=["a"],
+        outputs=["b"],
+        axis=i,
+    )
+
+    new_shape = (np.prod(shape[0:i]).astype(int), -1)
+    b = np.reshape(a, new_shape)
+    expect(
+        node,
+        inputs=[a],
+        outputs=[b],
+        name="test_flatten_negative_axis" + str(abs(i)),
+    )
+```
+
+</details>
+<details>
+<summary>flatten_with_default_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Flatten",
+    inputs=["a"],
+    outputs=["b"],  # Default value for axis: axis=1
+)
+
+shape = (5, 4, 3, 2)
+a = np.random.random_sample(shape).astype(np.float32)
+new_shape = (5, 24)
+b = np.reshape(a, new_shape)
+expect(node, inputs=[a], outputs=[b], name="test_flatten_default_axis")
+```
+
+</details>
+
+
+### Floor
+There are 1 test cases, listed as following:
+<details>
+<summary>floor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Floor",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.5, 1.2, 2]).astype(np.float32)
+y = np.floor(x)  # expected output [-2., 1., 2.]
+expect(node, inputs=[x], outputs=[y], name="test_floor_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.floor(x)
+expect(node, inputs=[x], outputs=[y], name="test_floor")
+```
+
+</details>
+
+
+### GRU
+There are 4 test cases, listed as following:
+<details>
+<summary>batchwise</summary>
+
+```python
+input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 6
+number_of_gates = 3
+weight_scale = 0.2
+layout = 1
+
+node = onnx.helper.make_node(
+    "GRU",
+    inputs=["X", "W", "R"],
+    outputs=["Y", "Y_h"],
+    hidden_size=hidden_size,
+    layout=layout,
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+gru = GRUHelper(X=input, W=W, R=R, layout=layout)
+Y, Y_h = gru.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y.astype(np.float32), Y_h.astype(np.float32)],
+    name="test_gru_batchwise",
+)
+```
+
+</details>
+<details>
+<summary>defaults</summary>
+
+```python
+input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 5
+weight_scale = 0.1
+number_of_gates = 3
+
+node = onnx.helper.make_node(
+    "GRU", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+gru = GRUHelper(X=input, W=W, R=R)
+_, Y_h = gru.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_gru_defaults",
+)
+```
+
+</details>
+<details>
+<summary>initial_bias</summary>
+
+```python
+input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype(
+    np.float32
+)
+
+input_size = 3
+hidden_size = 3
+weight_scale = 0.1
+custom_bias = 0.1
+number_of_gates = 3
+
+node = onnx.helper.make_node(
+    "GRU",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+# Adding custom bias
+W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype(
+    np.float32
+)
+R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32)
+B = np.concatenate((W_B, R_B), axis=1)
+
+gru = GRUHelper(X=input, W=W, R=R, B=B)
+_, Y_h = gru.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_gru_with_initial_bias",
+)
+```
+
+</details>
+<details>
+<summary>seq_length</summary>
+
+```python
+input = np.array(
+    [
+        [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
+        [[10.0, 11.0, 12.0], [13.0, 14.0, 15.0], [16.0, 17.0, 18.0]],
+    ]
+).astype(np.float32)
+
+input_size = 3
+hidden_size = 5
+number_of_gates = 3
+
+node = onnx.helper.make_node(
+    "GRU",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = np.random.randn(1, number_of_gates * hidden_size, input_size).astype(
+    np.float32
+)
+R = np.random.randn(1, number_of_gates * hidden_size, hidden_size).astype(
+    np.float32
+)
+
+# Adding custom bias
+W_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32)
+R_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32)
+B = np.concatenate((W_B, R_B), axis=1)
+
+gru = GRUHelper(X=input, W=W, R=R, B=B)
+_, Y_h = gru.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_gru_seq_length",
+)
+```
+
+</details>
+
+
+### Gather
+There are 4 test cases, listed as following:
+<details>
+<summary>gather_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gather",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=0,
+)
+data = np.random.randn(5, 4, 3, 2).astype(np.float32)
+indices = np.array([0, 1, 3])
+y = np.take(data, indices, axis=0)
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_0",
+)
+```
+
+</details>
+<details>
+<summary>gather_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gather",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=1,
+)
+data = np.random.randn(5, 4, 3, 2).astype(np.float32)
+indices = np.array([0, 1, 3])
+y = np.take(data, indices, axis=1)
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_1",
+)
+```
+
+</details>
+<details>
+<summary>gather_2d_indices</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gather",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=1,
+)
+data = np.random.randn(3, 3).astype(np.float32)
+indices = np.array([[0, 2]])
+y = np.take(data, indices, axis=1)
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_2d_indices",
+)
+```
+
+</details>
+<details>
+<summary>gather_negative_indices</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gather",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=0,
+)
+data = np.arange(10).astype(np.float32)
+indices = np.array([0, -9, -10])
+y = np.take(data, indices, axis=0)
+
+# print(y)
+# [0. 1. 0.]
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_negative_indices",
+)
+```
+
+</details>
+
+
+### GatherElements
+There are 3 test cases, listed as following:
+<details>
+<summary>gather_elements_0</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "GatherElements",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+indices = np.array([[0, 0], [1, 0]], dtype=np.int32)
+
+y = gather_elements(data, indices, axis)
+# print(y) produces
+# [[1, 1],
+#  [4, 3]]
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_elements_0",
+)
+```
+
+</details>
+<details>
+<summary>gather_elements_1</summary>
+
+```python
+axis = 0
+node = onnx.helper.make_node(
+    "GatherElements",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32)
+indices = np.array([[1, 2, 0], [2, 0, 0]], dtype=np.int32)
+
+y = gather_elements(data, indices, axis)
+# print(y) produces
+# [[4, 8, 3],
+#  [7, 2, 3]]
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_elements_1",
+)
+```
+
+</details>
+<details>
+<summary>gather_elements_negative_indices</summary>
+
+```python
+axis = 0
+node = onnx.helper.make_node(
+    "GatherElements",
+    inputs=["data", "indices"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32)
+indices = np.array([[-1, -2, 0], [-2, 0, 0]], dtype=np.int32)
+
+y = gather_elements(data, indices, axis)
+# print(y) produces
+# [[7, 5, 3],
+#  [4, 2, 3]]
+
+expect(
+    node,
+    inputs=[data, indices.astype(np.int64)],
+    outputs=[y],
+    name="test_gather_elements_negative_indices",
+)
+```
+
+</details>
+
+
+### GatherND
+There are 3 test cases, listed as following:
+<details>
+<summary>float32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GatherND",
+    inputs=["data", "indices"],
+    outputs=["output"],
+)
+
+data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.float32)
+indices = np.array([[[0, 1]], [[1, 0]]], dtype=np.int64)
+output = gather_nd_impl(data, indices, 0)
+expected_output = np.array([[[2, 3]], [[4, 5]]], dtype=np.float32)
+assert np.array_equal(output, expected_output)
+expect(
+    node,
+    inputs=[data, indices],
+    outputs=[output],
+    name="test_gathernd_example_float32",
+)
+```
+
+</details>
+<details>
+<summary>int32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GatherND",
+    inputs=["data", "indices"],
+    outputs=["output"],
+)
+
+data = np.array([[0, 1], [2, 3]], dtype=np.int32)
+indices = np.array([[0, 0], [1, 1]], dtype=np.int64)
+output = gather_nd_impl(data, indices, 0)
+expected_output = np.array([0, 3], dtype=np.int32)
+assert np.array_equal(output, expected_output)
+expect(
+    node,
+    inputs=[data, indices],
+    outputs=[output],
+    name="test_gathernd_example_int32",
+)
+```
+
+</details>
+<details>
+<summary>int32_batchdim_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GatherND",
+    inputs=["data", "indices"],
+    outputs=["output"],
+    batch_dims=1,
+)
+
+data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.int32)
+indices = np.array([[1], [0]], dtype=np.int64)
+output = gather_nd_impl(data, indices, 1)
+expected_output = np.array([[2, 3], [4, 5]], dtype=np.int32)
+assert np.array_equal(output, expected_output)
+expect(
+    node,
+    inputs=[data, indices],
+    outputs=[output],
+    name="test_gathernd_example_int32_batch_dim1",
+)
+```
+
+</details>
+
+
+### Gelu
+There are 2 test cases, listed as following:
+<details>
+<summary>gelu_default</summary>
+
+```python
+node = onnx.helper.make_node("Gelu", inputs=["x"], outputs=["y"])
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-0.15865526, 0., 0.84134474]
+y = (0.5 * x * (1 + np.vectorize(math.erf)(x / np.sqrt(2)))).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_gelu_default_1")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+# expected output [2.99595031, 3.99987331, 4.99999857]
+y = (0.5 * x * (1 + np.vectorize(math.erf)(x / np.sqrt(2)))).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_gelu_default_2")
+```
+
+</details>
+<details>
+<summary>gelu_tanh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gelu", inputs=["x"], outputs=["y"], approximate="tanh"
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-0.158808, 0., 0.841192]
+y = (
+    0.5
+    * x
+    * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_gelu_tanh_1")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+# expected output [2.9963627, 3.99993, 4.9999995]
+y = (
+    0.5
+    * x
+    * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_gelu_tanh_2")
+```
+
+</details>
+
+
+### Gemm
+There are 11 test cases, listed as following:
+<details>
+<summary>all_attributes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm",
+    inputs=["a", "b", "c"],
+    outputs=["y"],
+    alpha=0.25,
+    beta=0.35,
+    transA=1,
+    transB=1,
+)
+a = np.random.ranf([4, 3]).astype(np.float32)
+b = np.random.ranf([5, 4]).astype(np.float32)
+c = np.random.ranf([1, 5]).astype(np.float32)
+y = gemm_reference_implementation(
+    a, b, c, transA=1, transB=1, alpha=0.25, beta=0.35
+)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_all_attributes")
+```
+
+</details>
+<details>
+<summary>alpha</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm", inputs=["a", "b", "c"], outputs=["y"], alpha=0.5
+)
+a = np.random.ranf([3, 5]).astype(np.float32)
+b = np.random.ranf([5, 4]).astype(np.float32)
+c = np.zeros([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c, alpha=0.5)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_alpha")
+```
+
+</details>
+<details>
+<summary>beta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm", inputs=["a", "b", "c"], outputs=["y"], beta=0.5
+)
+a = np.random.ranf([2, 7]).astype(np.float32)
+b = np.random.ranf([7, 4]).astype(np.float32)
+c = np.random.ranf([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c, beta=0.5)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_beta")
+```
+
+</details>
+<details>
+<summary>default_matrix_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([3, 6]).astype(np.float32)
+b = np.random.ranf([6, 4]).astype(np.float32)
+c = np.random.ranf([3, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(
+    node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_matrix_bias"
+)
+```
+
+</details>
+<details>
+<summary>default_no_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b"], outputs=["y"])
+a = np.random.ranf([2, 10]).astype(np.float32)
+b = np.random.ranf([10, 3]).astype(np.float32)
+y = gemm_reference_implementation(a, b)
+expect(node, inputs=[a, b], outputs=[y], name="test_gemm_default_no_bias")
+```
+
+</details>
+<details>
+<summary>default_scalar_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([2, 3]).astype(np.float32)
+b = np.random.ranf([3, 4]).astype(np.float32)
+c = np.array(3.14).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(
+    node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_scalar_bias"
+)
+```
+
+</details>
+<details>
+<summary>default_single_elem_vector_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([3, 7]).astype(np.float32)
+b = np.random.ranf([7, 3]).astype(np.float32)
+c = np.random.ranf([1]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(
+    node,
+    inputs=[a, b, c],
+    outputs=[y],
+    name="test_gemm_default_single_elem_vector_bias",
+)
+```
+
+</details>
+<details>
+<summary>default_vector_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([2, 7]).astype(np.float32)
+b = np.random.ranf([7, 4]).astype(np.float32)
+c = np.random.ranf([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(
+    node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_vector_bias"
+)
+```
+
+</details>
+<details>
+<summary>default_zero_bias</summary>
+
+```python
+node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+a = np.random.ranf([3, 5]).astype(np.float32)
+b = np.random.ranf([5, 4]).astype(np.float32)
+c = np.zeros([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_zero_bias")
+```
+
+</details>
+<details>
+<summary>transposeA</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm", inputs=["a", "b", "c"], outputs=["y"], transA=1
+)
+a = np.random.ranf([6, 3]).astype(np.float32)
+b = np.random.ranf([6, 4]).astype(np.float32)
+c = np.zeros([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c, transA=1)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeA")
+```
+
+</details>
+<details>
+<summary>transposeB</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Gemm", inputs=["a", "b", "c"], outputs=["y"], transB=1
+)
+a = np.random.ranf([3, 6]).astype(np.float32)
+b = np.random.ranf([4, 6]).astype(np.float32)
+c = np.zeros([1, 4]).astype(np.float32)
+y = gemm_reference_implementation(a, b, c, transB=1)
+expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeB")
+```
+
+</details>
+
+
+### GlobalAveragePool
+There are 2 test cases, listed as following:
+<details>
+<summary>globalaveragepool</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GlobalAveragePool",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 5, 5).astype(np.float32)
+y = np.mean(x, axis=tuple(range(2, np.ndim(x))), keepdims=True)
+expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool")
+```
+
+</details>
+<details>
+<summary>globalaveragepool_precomputed</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GlobalAveragePool",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[5]]]]).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool_precomputed")
+```
+
+</details>
+
+
+### GlobalMaxPool
+There are 2 test cases, listed as following:
+<details>
+<summary>globalmaxpool</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GlobalMaxPool",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 5, 5).astype(np.float32)
+y = np.max(x, axis=tuple(range(2, np.ndim(x))), keepdims=True)
+expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool")
+```
+
+</details>
+<details>
+<summary>globalmaxpool_precomputed</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GlobalMaxPool",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3],
+                [4, 5, 6],
+                [7, 8, 9],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[9]]]]).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool_precomputed")
+```
+
+</details>
+
+
+### Gradient
+There are 2 test cases, listed as following:
+<details>
+<summary>gradient_scalar_add</summary>
+
+```python
+add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add")
+gradient_node = onnx.helper.make_node(
+    "Gradient",
+    ["a", "b"],
+    ["dc_da", "dc_db"],
+    name="my_gradient",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+    xs=["a", "b"],
+    y="c",
+)
+
+a = np.array(1.0).astype(np.float32)
+b = np.array(2.0).astype(np.float32)
+c = a + b
+# dc / da = d(a+b) / da = 1
+dc_da = np.array(1).astype(np.float32)
+# db / db = d(a+b) / db = 1
+dc_db = np.array(1).astype(np.float32)
+
+graph = onnx.helper.make_graph(
+    nodes=[add_node, gradient_node],
+    name="GradientOfAdd",
+    inputs=[
+        onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []),
+    ],
+    outputs=[
+        onnx.helper.make_tensor_value_info("c", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("dc_da", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("dc_db", onnx.TensorProto.FLOAT, []),
+    ],
+)
+opsets = [
+    onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12),
+    onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+]
+model = onnx.helper.make_model_gen_version(
+    graph, producer_name="backend-test", opset_imports=opsets
+)
+expect(
+    model, inputs=[a, b], outputs=[c, dc_da, dc_db], name="test_gradient_of_add"
+)
+```
+
+</details>
+<details>
+<summary>gradient_scalar_add_and_mul</summary>
+
+```python
+add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add")
+mul_node = onnx.helper.make_node("Mul", ["c", "a"], ["d"], name="my_mul")
+gradient_node = onnx.helper.make_node(
+    "Gradient",
+    ["a", "b"],
+    ["dd_da", "dd_db"],
+    name="my_gradient",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+    xs=["a", "b"],
+    y="d",
+)
+
+a = np.array(1.0).astype(np.float32)
+b = np.array(2.0).astype(np.float32)
+c = a + b
+# d = a * c = a * (a + b)
+d = a * c
+# dd / da = d(a*a+a*b) / da = 2 * a + b
+dd_da = (2 * a + b).astype(np.float32)
+# dd / db = d(a*a+a*b) / db = a
+dd_db = a
+
+graph = onnx.helper.make_graph(
+    nodes=[add_node, mul_node, gradient_node],
+    name="GradientOfTwoOperators",
+    inputs=[
+        onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []),
+    ],
+    outputs=[
+        onnx.helper.make_tensor_value_info("d", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("dd_da", onnx.TensorProto.FLOAT, []),
+        onnx.helper.make_tensor_value_info("dd_db", onnx.TensorProto.FLOAT, []),
+    ],
+)
+
+opsets = [
+    onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12),
+    onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+]
+model = onnx.helper.make_model_gen_version(
+    graph, producer_name="backend-test", opset_imports=opsets
+)
+expect(
+    model,
+    inputs=[a, b],
+    outputs=[d, dd_da, dd_db],
+    name="test_gradient_of_add_and_mul",
+)
+```
+
+</details>
+
+
+### Greater
+There are 4 test cases, listed as following:
+<details>
+<summary>greater</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Greater",
+    inputs=["x", "y"],
+    outputs=["greater"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater")
+
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.random.randn(3, 4, 5).astype(np.int8)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_int8")
+
+x = np.random.randn(3, 4, 5).astype(np.int16)
+y = np.random.randn(3, 4, 5).astype(np.int16)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint64")
+```
+
+</details>
+<details>
+<summary>greater</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GreaterOrEqual",
+    inputs=["x", "y"],
+    outputs=["greater_equal"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal")
+
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.random.randn(3, 4, 5).astype(np.int8)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int8")
+
+x = np.random.randn(3, 4, 5).astype(np.int16)
+y = np.random.randn(3, 4, 5).astype(np.int16)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint64")
+```
+
+</details>
+<details>
+<summary>greater_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Greater",
+    inputs=["x", "y"],
+    outputs=["greater"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = np.greater(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_bcast")
+```
+
+</details>
+<details>
+<summary>greater_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GreaterOrEqual",
+    inputs=["x", "y"],
+    outputs=["greater_equal"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = np.greater_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_bcast")
+```
+
+</details>
+
+
+### GridSample
+There are 4 test cases, listed as following:
+<details>
+<summary>gridsample</summary>
+
+```python
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    padding_mode="zeros",
+    align_corners=0,
+)
+# X shape, [N, C, H, W] - [1, 1, 4, 4]
+X = np.array(
+    [
+        [
+            [
+                [0.0, 1.0, 2.0, 3.0],
+                [4.0, 5.0, 6.0, 7.0],
+                [8.0, 9.0, 10.0, 11.0],
+                [12.0, 13.0, 14.0, 15.0],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+# Grid shape, [N, H_out, W_out, 2] - [1, 6, 6, 2]
+Grid = np.array(
+    [
+        [
+            [
+                [-1.0000, -1.0000],
+                [-0.6000, -1.0000],
+                [-0.2000, -1.0000],
+                [0.2000, -1.0000],
+                [0.6000, -1.0000],
+                [1.0000, -1.0000],
+            ],
+            [
+                [-1.0000, -0.6000],
+                [-0.6000, -0.6000],
+                [-0.2000, -0.6000],
+                [0.2000, -0.6000],
+                [0.6000, -0.6000],
+                [1.0000, -0.6000],
+            ],
+            [
+                [-1.0000, -0.2000],
+                [-0.6000, -0.2000],
+                [-0.2000, -0.2000],
+                [0.2000, -0.2000],
+                [0.6000, -0.2000],
+                [1.0000, -0.2000],
+            ],
+            [
+                [-1.0000, 0.2000],
+                [-0.6000, 0.2000],
+                [-0.2000, 0.2000],
+                [0.2000, 0.2000],
+                [0.6000, 0.2000],
+                [1.0000, 0.2000],
+            ],
+            [
+                [-1.0000, 0.6000],
+                [-0.6000, 0.6000],
+                [-0.2000, 0.6000],
+                [0.2000, 0.6000],
+                [0.6000, 0.6000],
+                [1.0000, 0.6000],
+            ],
+            [
+                [-1.0000, 1.0000],
+                [-0.6000, 1.0000],
+                [-0.2000, 1.0000],
+                [0.2000, 1.0000],
+                [0.6000, 1.0000],
+                [1.0000, 1.0000],
+            ],
+        ]
+    ],
+    dtype=np.float32,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 6, 6]
+Y = np.array(
+    [
+        [
+            [
+                [0.0000, 0.1500, 0.5500, 0.9500, 1.3500, 0.7500],
+                [0.6000, 1.5000, 2.3000, 3.1000, 3.9000, 2.1000],
+                [2.2000, 4.7000, 5.5000, 6.3000, 7.1000, 3.7000],
+                [3.8000, 7.9000, 8.7000, 9.5000, 10.3000, 5.3000],
+                [5.4000, 11.1000, 11.9000, 12.7000, 13.5000, 6.9000],
+                [3.0000, 6.1500, 6.5500, 6.9500, 7.3500, 3.7500],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+expect(node, inputs=[X, Grid], outputs=[Y], name="test_gridsample")
+```
+
+</details>
+<details>
+<summary>gridsample_mode_aligncorners</summary>
+
+```python
+# X shape, [N, C, H, W] - [1, 1, 3, 2]
+X = np.array(
+    [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]],
+    dtype=np.float32,
+)
+# Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2]
+Grid = np.array(
+    [
+        [
+            [
+                [-1.0000, -1.0000],
+                [-0.5000, -0.5000],
+                [-0.2000, -0.2000],
+                [0.0000, 0.0000],
+            ],
+            [
+                [0.0000, 0.0000],
+                [-0.2000, -0.2000],
+                [0.5000, 0.5000],
+                [1.0000, 1.0000],
+            ],
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# setting mode = 'bilinear', default align_corners = 0
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [[[[0.0000, 0.5000, 1.7000, 2.5000], [2.5000, 1.7000, 4.5000, 1.2500]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_bilinear",
+)
+
+# setting mode = 'bilinear', align_corners = 1
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_align_corners = np.array(
+    [[[[0.0000, 1.2500, 2.0000, 2.5000], [2.5000, 2.0000, 3.7500, 5.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_align_corners],
+    name="test_gridsample_aligncorners_true",
+)
+
+# setting mode = 'nearest'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [[[[0.0, 0.0, 2.0, 2.0], [2.0, 2.0, 5.0, 0.0]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node, inputs=[X, Grid], outputs=[Y_nearest], name="test_gridsample_nearest"
+)
+
+# setting mode = 'bicubic'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="cubic",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bicubic = np.array(
+    [[[[-0.1406, 0.3828, 1.7556, 2.9688], [2.9688, 1.7556, 5.1445, 1.3906]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node, inputs=[X, Grid], outputs=[Y_bicubic], name="test_gridsample_bicubic"
+)
+
+# ============================================================================
+# Additional tests
+# The reference output tensors were generated using PyTorch 2.0.
+Grid = np.array(
+    [
+        [
+            [[-1.0, -0.8], [-0.6, -0.5], [-0.1, -0.2], [0.7, 0.0]],
+            [[0.0, 0.4], [0.2, -0.2], [-0.3, 0.5], [-1.0, 1.0]],
+        ]
+    ],
+    dtype=np.float32,
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [[[[0.0, 0.0, 2.0, 3.0], [4.0, 3.0, 4.0, 4.0]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_nearest],
+    name="test_gridsample_nearest_align_corners_0_additional_1",
+)
+
+# setting mode = 'nearest'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [[[[0.0, 0.0, 2.0, 3.0], [2.0, 3.0, 4.0, 4.0]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_nearest],
+    name="test_gridsample_nearest_align_corners_1_additional_1",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [[[[0.0000, 0.4500, 1.8000, 2.4000], [3.7000, 2.1000, 3.7000, 1.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_bilinear_align_corners_0_additional_1",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [[[[0.4000, 1.2000, 2.0500, 2.8500], [3.3000, 2.2000, 3.3500, 4.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_bilinear_align_corners_1_additional_1",
+)
+
+# These two new bicubic tests produces slightly higher error ~5e-5
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="cubic",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bicubic = np.array(
+    [
+        [
+            [
+                [-0.173250, 0.284265, 1.923106, 2.568000],
+                [5.170375, 2.284414, 4.744844, 1.046875],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bicubic],
+    name="test_gridsample_bicubic_align_corners_0_additional_1",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="cubic",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bicubic = np.array(
+    [
+        [
+            [
+                [0.304001, 1.128750, 2.266270, 3.144844],
+                [4.531500, 2.455360, 4.599819, 4.000000],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bicubic],
+    name="test_gridsample_bicubic_align_corners_1_additional_1",
+)
+```
+
+</details>
+<details>
+<summary>gridsample_paddingmode</summary>
+
+```python
+# X shape, [N, C, H, W] - [1, 1, 3, 2]
+X = np.array(
+    [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]],
+    dtype=np.float32,
+)
+# Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2]
+Grid = np.array(
+    [
+        [
+            [
+                [-10.0000, -10.0000],
+                [-5.0000, -5.0000],
+                [-0.2000, -0.2000],
+                [10.0000, 10.0000],
+            ],
+            [
+                [10.0000, 10.0000],
+                [-0.2000, -0.2000],
+                [5.0000, 5.0000],
+                [10.0000, 10.0000],
+            ],
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# setting padding_mode = 'zeros'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    padding_mode="zeros",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_zeros = np.array(
+    [[[[0.0000, 0.0000, 1.7000, 0.0000], [0.0000, 1.7000, 0.0000, 0.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_zeros],
+    name="test_gridsample_zeros_padding",
+)
+
+# setting padding_mode = 'border'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    padding_mode="border",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_border = np.array(
+    [[[[0.0000, 0.0000, 1.7000, 5.0000], [5.0000, 1.7000, 5.0000, 5.0000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_border],
+    name="test_gridsample_border_padding",
+)
+
+# setting padding_mode = 'reflection'
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    padding_mode="reflection",
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_reflection = np.array(
+    [[[[2.5000, 0.0000, 1.7000, 2.5000], [2.5000, 1.7000, 5.0000, 2.5000]]]],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_reflection],
+    name="test_gridsample_reflection_padding",
+)
+```
+
+</details>
+<details>
+<summary>volumeetric_gridsample_mode_aligncorners</summary>
+
+```python
+X = np.array(
+    [
+        [
+            [
+                [[1.0, 2.0], [3.0, 4.0]],
+                [[5.0, 6.0], [7.0, 8.0]],
+                [[9.0, 10.0], [11.0, 12.0]],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+Grid = np.array(
+    [
+        [
+            [
+                [[-1.0, -1.0, -1.0], [-1.0, -0.5, 0.3]],
+                [[-0.5, -0.5, -0.5], [1.0, -0.6, -1.0]],
+                [[-0.2, -0.2, -0.2], [0.4, 0.2, 0.6]],
+                [[0.0, 0.0, 0.0], [-1.0, 0.0, 0.0]],
+            ],
+            [
+                [[0.0, 0.0, 0.0], [-1.0, 1.0, 0.0]],
+                [[-0.2, -0.2, -0.2], [1.0, 0.4, -0.2]],
+                [[0.5, 0.5, 0.5], [-1.0, -0.8, 0.8]],
+                [[1.0, 1.0, 1.0], [0.4, 0.6, -0.3]],
+            ],
+        ]
+    ],
+    dtype=np.float32,
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [
+        [
+            [
+                [[1.0, 5.0], [1.0, 0.0], [5.0, 12.0], [5.0, 5.0]],
+                [[5.0, 0.0], [5.0, 0.0], [12.0, 9.0], [0.0, 8.0]],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_nearest],
+    name="test_gridsample_volumetric_nearest_align_corners_0",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="nearest",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_nearest = np.array(
+    [
+        [
+            [
+                [[1.0, 5.0], [1.0, 2.0], [5.0, 12.0], [5.0, 5.0]],
+                [[5.0, 7.0], [5.0, 8.0], [12.0, 9.0], [12.0, 8.0]],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_nearest],
+    name="test_gridsample_volumetric_nearest_align_corners_1",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=0,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [
+        [
+            [
+                [
+                    [0.1250, 3.4000],
+                    [2.0000, 0.4500],
+                    [4.7000, 10.9000],
+                    [6.5000, 3.0000],
+                ],
+                [
+                    [6.5000, 1.7500],
+                    [4.7000, 3.3000],
+                    [11.0000, 2.5200],
+                    [1.5000, 5.4900],
+                ],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_volumetric_bilinear_align_corners_0",
+)
+
+node = onnx.helper.make_node(
+    "GridSample",
+    inputs=["X", "Grid"],
+    outputs=["Y"],
+    mode="linear",
+    align_corners=1,
+)
+# Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+Y_bilinear = np.array(
+    [
+        [
+            [
+                [
+                    [1.0000, 6.7000],
+                    [3.7500, 2.4000],
+                    [5.4000, 9.3000],
+                    [6.5000, 6.0000],
+                ],
+                [
+                    [6.5000, 7.0000],
+                    [5.4000, 6.6000],
+                    [9.2500, 8.4000],
+                    [12.0000, 6.1000],
+                ],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, Grid],
+    outputs=[Y_bilinear],
+    name="test_gridsample_volumetric_bilinear_align_corners_1",
+)
+```
+
+</details>
+
+
+### GroupNormalization
+There are 2 test cases, listed as following:
+<details>
+<summary>epsilon</summary>
+
+```python
+c = 4
+num_groups = 2
+x = np.random.randn(3, c, 2, 2).astype(np.float32)
+scale = np.random.randn(c).astype(np.float32)
+bias = np.random.randn(c).astype(np.float32)
+epsilon = 1e-2
+y = _group_normalization(x, num_groups, scale, bias, epsilon).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "GroupNormalization",
+    inputs=["x", "scale", "bias"],
+    outputs=["y"],
+    epsilon=epsilon,
+    num_groups=num_groups,
+)
+
+expect(
+    node,
+    inputs=[x, scale, bias],
+    outputs=[y],
+    name="test_group_normalization_epsilon",
+)
+```
+
+</details>
+<details>
+<summary>groupnormalization</summary>
+
+```python
+c = 4
+num_groups = 2
+x = np.random.randn(3, c, 2, 2).astype(np.float32)
+scale = np.random.randn(c).astype(np.float32)
+bias = np.random.randn(c).astype(np.float32)
+y = _group_normalization(x, num_groups, scale, bias).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "GroupNormalization",
+    inputs=["x", "scale", "bias"],
+    outputs=["y"],
+    num_groups=num_groups,
+)
+
+expect(
+    node,
+    inputs=[x, scale, bias],
+    outputs=[y],
+    name="test_group_normalization_example",
+)
+```
+
+</details>
+
+
+### HammingWindow
+There are 1 test cases, listed as following:
+<details>
+<summary>hammingwindow</summary>
+
+```python
+# Test periodic window
+node = onnx.helper.make_node(
+    "HammingWindow",
+    inputs=["x"],
+    outputs=["y"],
+)
+size = np.int32(10)
+a0 = 25 / 46
+a1 = 1 - a0
+y = a0 - a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_hammingwindow",
+)
+
+# Test symmetric window
+node = onnx.helper.make_node(
+    "HammingWindow", inputs=["x"], outputs=["y"], periodic=0
+)
+size = np.int32(10)
+a0 = 25 / 46
+a1 = 1 - a0
+y = a0 - a1 * np.cos(
+    2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_hammingwindow_symmetric",
+)
+```
+
+</details>
+
+
+### HannWindow
+There are 1 test cases, listed as following:
+<details>
+<summary>hannwindow</summary>
+
+```python
+# Test periodic window
+node = onnx.helper.make_node(
+    "HannWindow",
+    inputs=["x"],
+    outputs=["y"],
+)
+size = np.int32(10)
+a0 = 0.5
+a1 = 0.5
+y = a0 - a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+expect(
+    node, inputs=[size], outputs=[y.astype(np.float32)], name="test_hannwindow"
+)
+
+# Test symmetric window
+node = onnx.helper.make_node(
+    "HannWindow", inputs=["x"], outputs=["y"], periodic=0
+)
+size = np.int32(10)
+a0 = 0.5
+a1 = 0.5
+y = a0 - a1 * np.cos(
+    2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+)
+expect(
+    node,
+    inputs=[size],
+    outputs=[y.astype(np.float32)],
+    name="test_hannwindow_symmetric",
+)
+```
+
+</details>
+
+
+### HardSigmoid
+There are 2 test cases, listed as following:
+<details>
+<summary>hardsigmoid</summary>
+
+```python
+node = onnx.helper.make_node(
+    "HardSigmoid", inputs=["x"], outputs=["y"], alpha=0.5, beta=0.6
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.clip(x * 0.5 + 0.6, 0, 1)  # expected output [0.1, 0.6, 1.]
+expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x * 0.5 + 0.6, 0, 1)
+expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid")
+```
+
+</details>
+<details>
+<summary>hardsigmoid_default</summary>
+
+```python
+default_alpha = 0.2
+default_beta = 0.5
+node = onnx.helper.make_node(
+    "HardSigmoid",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x * default_alpha + default_beta, 0, 1)
+expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_default")
+```
+
+</details>
+
+
+### HardSwish
+There are 1 test cases, listed as following:
+<details>
+<summary>hardswish</summary>
+
+```python
+node = onnx.helper.make_node(
+    "HardSwish",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = hardswish(x)
+
+expect(node, inputs=[x], outputs=[y], name="test_hardswish")
+```
+
+</details>
+
+
+### Hardmax
+There are 2 test cases, listed as following:
+<details>
+<summary>hardmax</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([[3, 0, 1, 2], [2, 5, 1, 0], [0, 1, 3, 2], [0, 1, 2, 3]]).astype(
+    np.float32
+)
+# expect result:
+# [[1. 0. 0. 0.]
+# [0. 1. 0. 0.]
+# [0. 0. 1. 0.]
+# [0. 0. 0. 1.]]
+y = hardmax(x)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_example")
+
+# For multiple occurrences of the maximal values, the first occurrence is selected for one-hot output
+x = np.array([[3, 3, 3, 1]]).astype(np.float32)
+# expect result:
+# [[1, 0, 0, 0]]
+y = hardmax(x)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_one_hot")
+```
+
+</details>
+<details>
+<summary>hardmax_axis</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=0,
+)
+y = hardmax(x, axis=0)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_0")
+
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=1,
+)
+y = hardmax(x, axis=1)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_1")
+
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=2,
+)
+y = hardmax(x, axis=2)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_2")
+
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=-1,
+)
+y = hardmax(x, axis=-1)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_negative_axis")
+
+# default axis is -1
+node = onnx.helper.make_node(
+    "Hardmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_hardmax_default_axis")
+```
+
+</details>
+
+
+### Identity
+There are 3 test cases, listed as following:
+<details>
+<summary>identity</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Identity",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(node, inputs=[data], outputs=[data], name="test_identity")
+```
+
+</details>
+<details>
+<summary>identity_opt</summary>
+
+```python
+ten_in_tp = onnx.helper.make_tensor_type_proto(
+    onnx.TensorProto.FLOAT, shape=[5]
+)
+seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp)
+opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp)
+
+identity_node = onnx.helper.make_node(
+    "Identity", inputs=["opt_in"], outputs=["opt_out"]
+)
+
+x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)]
+
+expect(
+    identity_node,
+    inputs=[x],
+    outputs=[x],
+    name="test_identity_opt",
+    opset_imports=[onnx.helper.make_opsetid("", 16)],
+    input_type_protos=[opt_in_tp],
+    output_type_protos=[opt_in_tp],
+)
+```
+
+</details>
+<details>
+<summary>sequence</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Identity",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+data = [
+    np.array(
+        [
+            [
+                [
+                    [1, 2],
+                    [3, 4],
+                ]
+            ]
+        ],
+        dtype=np.float32,
+    ),
+    np.array(
+        [
+            [
+                [
+                    [2, 3],
+                    [1, 5],
+                ]
+            ]
+        ],
+        dtype=np.float32,
+    ),
+]
+
+expect(node, inputs=[data], outputs=[data], name="test_identity_sequence")
+```
+
+</details>
+
+
+### If
+There are 3 test cases, listed as following:
+<details>
+<summary>if</summary>
+
+```python
+# Given a bool scalar input cond.
+# return constant tensor x if cond is True, otherwise return constant tensor y.
+
+then_out = onnx.helper.make_tensor_value_info(
+    "then_out", onnx.TensorProto.FLOAT, [5]
+)
+else_out = onnx.helper.make_tensor_value_info(
+    "else_out", onnx.TensorProto.FLOAT, [5]
+)
+
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+y = np.array([5, 4, 3, 2, 1]).astype(np.float32)
+
+then_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["then_out"],
+    value=onnx.numpy_helper.from_array(x),
+)
+
+else_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["else_out"],
+    value=onnx.numpy_helper.from_array(y),
+)
+
+then_body = onnx.helper.make_graph(
+    [then_const_node], "then_body", [], [then_out]
+)
+
+else_body = onnx.helper.make_graph(
+    [else_const_node], "else_body", [], [else_out]
+)
+
+if_node = onnx.helper.make_node(
+    "If",
+    inputs=["cond"],
+    outputs=["res"],
+    then_branch=then_body,
+    else_branch=else_body,
+)
+
+cond = np.array(1).astype(bool)
+res = x if cond else y
+expect(
+    if_node,
+    inputs=[cond],
+    outputs=[res],
+    name="test_if",
+    opset_imports=[onnx.helper.make_opsetid("", 11)],
+)
+```
+
+</details>
+<details>
+<summary>if_optional</summary>
+
+```python
+# Given a bool scalar input cond, return an empty optional sequence of
+# tensor if True, return an optional sequence with value x
+# (the input optional sequence) otherwise.
+
+ten_in_tp = onnx.helper.make_tensor_type_proto(
+    onnx.TensorProto.FLOAT, shape=[5]
+)
+seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp)
+
+then_out_tensor_tp = onnx.helper.make_tensor_type_proto(
+    onnx.TensorProto.FLOAT, shape=[5]
+)
+then_out_seq_tp = onnx.helper.make_sequence_type_proto(then_out_tensor_tp)
+then_out_opt_tp = onnx.helper.make_optional_type_proto(then_out_seq_tp)
+then_out = onnx.helper.make_value_info("optional_empty", then_out_opt_tp)
+
+else_out_tensor_tp = onnx.helper.make_tensor_type_proto(
+    onnx.TensorProto.FLOAT, shape=[5]
+)
+else_out_seq_tp = onnx.helper.make_sequence_type_proto(else_out_tensor_tp)
+else_out_opt_tp = onnx.helper.make_optional_type_proto(else_out_seq_tp)
+else_out = onnx.helper.make_value_info("else_opt", else_out_opt_tp)
+
+x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)]
+cond = np.array(0).astype(bool)
+res = compute_if_outputs(x, cond)
+
+opt_empty_in = onnx.helper.make_node(
+    "Optional", inputs=[], outputs=["optional_empty"], type=seq_in_tp
+)
+
+then_body = onnx.helper.make_graph([opt_empty_in], "then_body", [], [then_out])
+
+else_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.numpy_helper.from_array(x[0]),
+)
+
+else_seq_node = onnx.helper.make_node(
+    "SequenceConstruct", inputs=["x"], outputs=["else_seq"]
+)
+
+else_optional_seq_node = onnx.helper.make_node(
+    "Optional", inputs=["else_seq"], outputs=["else_opt"]
+)
+
+else_body = onnx.helper.make_graph(
+    [else_const_node, else_seq_node, else_optional_seq_node],
+    "else_body",
+    [],
+    [else_out],
+)
+
+if_node = onnx.helper.make_node(
+    "If",
+    inputs=["cond"],
+    outputs=["sequence"],
+    then_branch=then_body,
+    else_branch=else_body,
+)
+
+expect(
+    if_node,
+    inputs=[cond],
+    outputs=[res],
+    name="test_if_opt",
+    output_type_protos=[else_out_opt_tp],
+    opset_imports=[onnx.helper.make_opsetid("", 16)],
+)
+```
+
+</details>
+<details>
+<summary>if_seq</summary>
+
+```python
+# Given a bool scalar input cond.
+# return constant sequence x if cond is True, otherwise return constant sequence y.
+
+then_out = onnx.helper.make_tensor_sequence_value_info(
+    "then_out", onnx.TensorProto.FLOAT, shape=[5]
+)
+else_out = onnx.helper.make_tensor_sequence_value_info(
+    "else_out", onnx.TensorProto.FLOAT, shape=[5]
+)
+
+x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)]
+y = [np.array([5, 4, 3, 2, 1]).astype(np.float32)]
+
+then_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.numpy_helper.from_array(x[0]),
+)
+
+then_seq_node = onnx.helper.make_node(
+    "SequenceConstruct", inputs=["x"], outputs=["then_out"]
+)
+
+else_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["y"],
+    value=onnx.numpy_helper.from_array(y[0]),
+)
+
+else_seq_node = onnx.helper.make_node(
+    "SequenceConstruct", inputs=["y"], outputs=["else_out"]
+)
+
+then_body = onnx.helper.make_graph(
+    [then_const_node, then_seq_node], "then_body", [], [then_out]
+)
+
+else_body = onnx.helper.make_graph(
+    [else_const_node, else_seq_node], "else_body", [], [else_out]
+)
+
+if_node = onnx.helper.make_node(
+    "If",
+    inputs=["cond"],
+    outputs=["res"],
+    then_branch=then_body,
+    else_branch=else_body,
+)
+
+cond = np.array(1).astype(bool)
+res = x if cond else y
+expect(
+    if_node,
+    inputs=[cond],
+    outputs=[res],
+    name="test_if_seq",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+
+
+### ImageDecoder
+There are 9 test cases, listed as following:
+<details>
+<summary>image_decoder_decode_bmp_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "bmp", _image_decoder_data.image_decoder_decode_bmp_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_bmp_rgb",
+)
+```
+
+</details>
+<details>
+<summary>image_decoder_decode_jpeg2k_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "jpeg2000", _image_decoder_data.image_decoder_decode_jpeg2k_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_jpeg2k_rgb",
+)
+```
+
+</details>
+<details>
+<summary>image_decoder_decode_jpeg_bgr</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="BGR",
+)
+
+data, output = _generate_test_data(
+    "jpeg", _image_decoder_data.image_decoder_decode_jpeg_bgr, "BGR"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_jpeg_bgr",
+)
+```
+
+</details>
+<details>
+<summary>image_decoder_decode_jpeg_grayscale</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="Grayscale",
+)
+
+data, output = _generate_test_data(
+    "jpeg", _image_decoder_data.image_decoder_decode_jpeg_grayscale, "Grayscale"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_jpeg_grayscale",
+)
+```
+
+</details>
+<details>
+<summary>image_decoder_decode_jpeg_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "jpeg", _image_decoder_data.image_decoder_decode_jpeg_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_jpeg_rgb",
+)
+```
+
+</details>
+<details>
+<summary>image_decoder_decode_png_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "png", _image_decoder_data.image_decoder_decode_png_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_png_rgb",
+)
+```
+
+</details>
+<details>
+<summary>image_decoder_decode_pnm_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "ppm", _image_decoder_data.image_decoder_decode_pnm_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_pnm_rgb",
+)
+```
+
+</details>
+<details>
+<summary>image_decoder_decode_tiff_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "tiff", _image_decoder_data.image_decoder_decode_tiff_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_tiff_rgb",
+)
+```
+
+</details>
+<details>
+<summary>image_decoder_decode_webp_rgb</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ImageDecoder",
+    inputs=["data"],
+    outputs=["output"],
+    pixel_format="RGB",
+)
+
+data, output = _generate_test_data(
+    "webp", _image_decoder_data.image_decoder_decode_webp_rgb, "RGB"
+)
+expect(
+    node,
+    inputs=[data],
+    outputs=[output],
+    name="test_image_decoder_decode_webp_rgb",
+)
+```
+
+</details>
+
+
+### InstanceNormalization
+There are 1 test cases, listed as following:
+<details>
+<summary>instancenormalization</summary>
+
+```python
+def _instancenorm_test_mode(
+    x: np.ndarray, s: np.ndarray, bias: np.ndarray, epsilon: float = 1e-5
+) -> np.ndarray:
+    dims_x = len(x.shape)
+    axis = tuple(range(2, dims_x))
+    mean = np.mean(x, axis=axis, keepdims=True)
+    var = np.var(x, axis=axis, keepdims=True)
+    dim_ones = (1,) * (dims_x - 2)
+    s = s.reshape(-1, *dim_ones)
+    bias = bias.reshape(-1, *dim_ones)
+    return s * (x - mean) / np.sqrt(var + epsilon) + bias
+
+# input size: (1, 2, 1, 3)
+x = np.array([[[[-1, 0, 1]], [[2, 3, 4]]]]).astype(np.float32)
+s = np.array([1.0, 1.5]).astype(np.float32)
+bias = np.array([0, 1]).astype(np.float32)
+y = _instancenorm_test_mode(x, s, bias).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "InstanceNormalization",
+    inputs=["x", "s", "bias"],
+    outputs=["y"],
+)
+
+# output size: (1, 2, 1, 3)
+expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_example")
+
+# input size: (2, 3, 4, 5)
+x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+s = np.random.randn(3).astype(np.float32)
+bias = np.random.randn(3).astype(np.float32)
+epsilon = 1e-2
+y = _instancenorm_test_mode(x, s, bias, epsilon).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "InstanceNormalization",
+    inputs=["x", "s", "bias"],
+    outputs=["y"],
+    epsilon=epsilon,
+)
+
+# output size: (2, 3, 4, 5)
+expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_epsilon")
+```
+
+</details>
+
+
+### IsInf
+There are 4 test cases, listed as following:
+<details>
+<summary>infinity</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsInf",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32)
+y = np.isinf(x)
+expect(node, inputs=[x], outputs=[y], name="test_isinf")
+```
+
+</details>
+<details>
+<summary>infinity_float16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsInf",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16)
+y = np.isinf(x)
+expect(node, inputs=[x], outputs=[y], name="test_isinf_float16")
+```
+
+</details>
+<details>
+<summary>negative_infinity_only</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsInf", inputs=["x"], outputs=["y"], detect_positive=0
+)
+
+x = np.array([-1.7, np.nan, np.inf, -3.6, -np.inf, np.inf], dtype=np.float32)
+y = np.isneginf(x)
+expect(node, inputs=[x], outputs=[y], name="test_isinf_negative")
+```
+
+</details>
+<details>
+<summary>positive_infinity_only</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsInf", inputs=["x"], outputs=["y"], detect_negative=0
+)
+
+x = np.array([-1.7, np.nan, np.inf, 3.6, -np.inf, np.inf], dtype=np.float32)
+y = np.isposinf(x)
+expect(node, inputs=[x], outputs=[y], name="test_isinf_positive")
+```
+
+</details>
+
+
+### IsNaN
+There are 2 test cases, listed as following:
+<details>
+<summary>float16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsNaN",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16)
+y = np.isnan(x)
+expect(node, inputs=[x], outputs=[y], name="test_isnan_float16")
+```
+
+</details>
+<details>
+<summary>isnan</summary>
+
+```python
+node = onnx.helper.make_node(
+    "IsNaN",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32)
+y = np.isnan(x)
+expect(node, inputs=[x], outputs=[y], name="test_isnan")
+```
+
+</details>
+
+
+### LRN
+There are 2 test cases, listed as following:
+<details>
+<summary>default</summary>
+
+```python
+alpha = 0.0001
+beta = 0.75
+bias = 1.0
+nsize = 3
+node = onnx.helper.make_node("LRN", inputs=["x"], outputs=["y"], size=3)
+x = np.random.randn(5, 5, 5, 5).astype(np.float32)
+square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32)
+for n, c, h, w in np.ndindex(x.shape):
+    square_sum[n, c, h, w] = sum(
+        x[
+            n,
+            max(0, c - math.floor((nsize - 1) / 2)) : min(
+                5, c + math.ceil((nsize - 1) / 2) + 1
+            ),
+            h,
+            w,
+        ]
+        ** 2
+    )
+y = x / ((bias + (alpha / nsize) * square_sum) ** beta)
+expect(node, inputs=[x], outputs=[y], name="test_lrn_default")
+```
+
+</details>
+<details>
+<summary>lrn</summary>
+
+```python
+alpha = 0.0002
+beta = 0.5
+bias = 2.0
+nsize = 3
+node = onnx.helper.make_node(
+    "LRN",
+    inputs=["x"],
+    outputs=["y"],
+    alpha=alpha,
+    beta=beta,
+    bias=bias,
+    size=nsize,
+)
+x = np.random.randn(5, 5, 5, 5).astype(np.float32)
+square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32)
+for n, c, h, w in np.ndindex(x.shape):
+    square_sum[n, c, h, w] = sum(
+        x[
+            n,
+            max(0, c - math.floor((nsize - 1) / 2)) : min(
+                5, c + math.ceil((nsize - 1) / 2) + 1
+            ),
+            h,
+            w,
+        ]
+        ** 2
+    )
+y = x / ((bias + (alpha / nsize) * square_sum) ** beta)
+expect(node, inputs=[x], outputs=[y], name="test_lrn")
+```
+
+</details>
+
+
+### LSTM
+There are 4 test cases, listed as following:
+<details>
+<summary>batchwise</summary>
+
+```python
+input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 7
+weight_scale = 0.3
+number_of_gates = 4
+layout = 1
+
+node = onnx.helper.make_node(
+    "LSTM",
+    inputs=["X", "W", "R"],
+    outputs=["Y", "Y_h"],
+    hidden_size=hidden_size,
+    layout=layout,
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+lstm = LSTMHelper(X=input, W=W, R=R, layout=layout)
+Y, Y_h = lstm.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y.astype(np.float32), Y_h.astype(np.float32)],
+    name="test_lstm_batchwise",
+)
+```
+
+</details>
+<details>
+<summary>defaults</summary>
+
+```python
+input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 3
+weight_scale = 0.1
+number_of_gates = 4
+
+node = onnx.helper.make_node(
+    "LSTM", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+lstm = LSTMHelper(X=input, W=W, R=R)
+_, Y_h = lstm.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_lstm_defaults",
+)
+```
+
+</details>
+<details>
+<summary>initial_bias</summary>
+
+```python
+input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype(
+    np.float32
+)
+
+input_size = 3
+hidden_size = 4
+weight_scale = 0.1
+custom_bias = 0.1
+number_of_gates = 4
+
+node = onnx.helper.make_node(
+    "LSTM",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+
+# Adding custom bias
+W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype(
+    np.float32
+)
+R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32)
+B = np.concatenate((W_B, R_B), 1)
+
+lstm = LSTMHelper(X=input, W=W, R=R, B=B)
+_, Y_h = lstm.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_lstm_with_initial_bias",
+)
+```
+
+</details>
+<details>
+<summary>peepholes</summary>
+
+```python
+input = np.array([[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]]]).astype(
+    np.float32
+)
+
+input_size = 4
+hidden_size = 3
+weight_scale = 0.1
+number_of_gates = 4
+number_of_peepholes = 3
+
+node = onnx.helper.make_node(
+    "LSTM",
+    inputs=["X", "W", "R", "B", "sequence_lens", "initial_h", "initial_c", "P"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+# Initializing Inputs
+W = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, input_size)
+).astype(np.float32)
+R = weight_scale * np.ones(
+    (1, number_of_gates * hidden_size, hidden_size)
+).astype(np.float32)
+B = np.zeros((1, 2 * number_of_gates * hidden_size)).astype(np.float32)
+seq_lens = np.repeat(input.shape[0], input.shape[1]).astype(np.int32)
+init_h = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32)
+init_c = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32)
+P = weight_scale * np.ones((1, number_of_peepholes * hidden_size)).astype(
+    np.float32
+)
+
+lstm = LSTMHelper(
+    X=input, W=W, R=R, B=B, P=P, initial_c=init_c, initial_h=init_h
+)
+_, Y_h = lstm.step()
+expect(
+    node,
+    inputs=[input, W, R, B, seq_lens, init_h, init_c, P],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_lstm_with_peepholes",
+)
+```
+
+</details>
+
+
+### LayerNormalization
+There are 4 test cases, listed as following:
+<details>
+<summary>d</summary>
+
+```python
+X = np.random.randn(3, 4).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    B = np.random.randn(*normalized_shape).astype(np.float32)
+    Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis=axis)
+
+    node = onnx.helper.make_node(
+        "LayerNormalization",
+        inputs=["X", "W", "B"],
+        outputs=["Y", "Mean", "InvStdDev"],
+        axis=axis,
+    )
+
+    if axis < 0:
+        name = f"test_layer_normalization_2d_axis_negative_{-axis}"
+    else:
+        name = f"test_layer_normalization_2d_axis{axis}"
+
+    expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+<details>
+<summary>d_epsilon</summary>
+
+```python
+epsilon = 1e-1
+X = np.random.randn(2, 3, 5).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    B = np.random.randn(*normalized_shape).astype(np.float32)
+    Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis, epsilon)
+    node = onnx.helper.make_node(
+        "LayerNormalization",
+        inputs=["X", "W", "B"],
+        outputs=["Y", "Mean", "InvStdDev"],
+        axis=axis,
+        epsilon=epsilon,
+    )
+
+    if axis < 0:
+        name = f"test_layer_normalization_3d_axis_negative_{-axis}_epsilon"
+    else:
+        name = f"test_layer_normalization_3d_axis{axis}_epsilon"
+
+    expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+<details>
+<summary>default_axis</summary>
+
+```python
+X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+# Default axis in LayerNormalization is -1.
+normalized_shape = calculate_normalized_shape(X.shape, -1)
+W = np.random.randn(*normalized_shape).astype(np.float32)
+B = np.random.randn(*normalized_shape).astype(np.float32)
+# Axis is default to -1 in the reference implementation.
+Y, mean, inv_std_dev = _layer_normalization(X, W, B)
+
+# Not specifying axis attribute means -1.
+node = onnx.helper.make_node(
+    "LayerNormalization",
+    inputs=["X", "W", "B"],
+    outputs=["Y", "Mean", "InvStdDev"],
+)
+
+expect(
+    node,
+    inputs=[X, W, B],
+    outputs=[Y, mean, inv_std_dev],
+    name="test_layer_normalization_default_axis",
+)
+```
+
+</details>
+<details>
+<summary>layernormalization</summary>
+
+```python
+X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    B = np.random.randn(*normalized_shape).astype(np.float32)
+    Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis)
+
+    node = onnx.helper.make_node(
+        "LayerNormalization",
+        inputs=["X", "W", "B"],
+        outputs=["Y", "Mean", "InvStdDev"],
+        axis=axis,
+    )
+
+    if axis < 0:
+        name = f"test_layer_normalization_4d_axis_negative_{-axis}"
+    else:
+        name = f"test_layer_normalization_4d_axis{axis}"
+
+    expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+
+
+### LeakyRelu
+There are 2 test cases, listed as following:
+<details>
+<summary>leakyrelu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LeakyRelu", inputs=["x"], outputs=["y"], alpha=0.1
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-0.1, 0., 1.]
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1
+expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1
+expect(node, inputs=[x], outputs=[y], name="test_leakyrelu")
+```
+
+</details>
+<details>
+<summary>leakyrelu_default</summary>
+
+```python
+default_alpha = 0.01
+node = onnx.helper.make_node(
+    "LeakyRelu",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * default_alpha
+expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_default")
+```
+
+</details>
+
+
+### Less
+There are 4 test cases, listed as following:
+<details>
+<summary>less</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Less",
+    inputs=["x", "y"],
+    outputs=["less"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less")
+
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.random.randn(3, 4, 5).astype(np.int8)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_int8")
+
+x = np.random.randn(3, 4, 5).astype(np.int16)
+y = np.random.randn(3, 4, 5).astype(np.int16)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_uint64")
+```
+
+</details>
+<details>
+<summary>less</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LessOrEqual",
+    inputs=["x", "y"],
+    outputs=["less_equal"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal")
+
+x = np.random.randn(3, 4, 5).astype(np.int8)
+y = np.random.randn(3, 4, 5).astype(np.int8)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int8")
+
+x = np.random.randn(3, 4, 5).astype(np.int16)
+y = np.random.randn(3, 4, 5).astype(np.int16)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint8")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint16")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint32")
+
+x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint64")
+```
+
+</details>
+<details>
+<summary>less_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Less",
+    inputs=["x", "y"],
+    outputs=["less"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = np.less(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_bcast")
+```
+
+</details>
+<details>
+<summary>less_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LessOrEqual",
+    inputs=["x", "y"],
+    outputs=["less_equal"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = np.less_equal(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_bcast")
+```
+
+</details>
+
+
+### LinearAttention
+There are 14 test cases, listed as following:
+<details>
+<summary>decode_step</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "past_state", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 1, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+past_state = np.random.randn(b, h_kv, d_k, d_v).astype(np.float32) * 0.1
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    past_state=past_state,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, past_state, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_decode_step",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "", "beta"],
+    outputs=["output", "present_state"],
+    update_rule="delta",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="delta",
+)
+expect(
+    node,
+    inputs=[query, key, value, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_delta",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>explicit_scale</summary>
+
+```python
+scale = 0.25
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+    scale=scale,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    scale=scale,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_explicit_scale",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>fp16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=8,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float16)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float16), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float16)
+decay = (-np.abs(np.random.randn(b, t, h_kv * d_k)) * 0.1).astype(np.float16)
+beta = np.random.rand(b, t, h_kv).astype(np.float16)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_fp16",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>gated</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay"],
+    outputs=["output", "present_state"],
+    update_rule="gated",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+# Per-key-dim decay in log-space (negative -> decay).
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="gated",
+)
+expect(
+    node,
+    inputs=[query, key, value, decay],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>gated_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_delta",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>gated_delta_beta_scalar</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, 1).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_delta_beta_scalar",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>gated_delta_gqa</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=8,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_delta_gqa",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>gated_delta_mqa</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=8,
+    kv_num_heads=1,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 1, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_delta_mqa",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>gated_per_head_decay</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "", "decay"],
+    outputs=["output", "present_state"],
+    update_rule="gated",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+# Per-head scalar decay.
+decay = -np.abs(np.random.randn(b, t, h_kv)).astype(np.float32) * 0.1
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    decay=decay,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="gated",
+)
+expect(
+    node,
+    inputs=[query, key, value, decay],
+    outputs=[output, present_state],
+    name="test_linear_attention_gated_per_head_decay",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>linear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value"],
+    outputs=["output", "present_state"],
+    update_rule="linear",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="linear",
+)
+expect(
+    node,
+    inputs=[query, key, value],
+    outputs=[output, present_state],
+    name="test_linear_attention_linear",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>linear_t1_no_past</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value"],
+    outputs=["output", "present_state"],
+    update_rule="linear",
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 1, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+    update_rule="linear",
+)
+expect(
+    node,
+    inputs=[query, key, value],
+    outputs=[output, present_state],
+    name="test_linear_attention_linear_t1_no_past",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>no_past_explicit_zeros</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "past_state", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+past_state = np.zeros((b, h_kv, d_k, d_v), dtype=np.float32)
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    past_state=past_state,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, past_state, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_no_past_explicit_zeros",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+<details>
+<summary>prefill_with_past</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LinearAttention",
+    inputs=["query", "key", "value", "past_state", "decay", "beta"],
+    outputs=["output", "present_state"],
+    q_num_heads=4,
+    kv_num_heads=4,
+)
+b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+past_state = np.random.randn(b, h_kv, d_k, d_v).astype(np.float32) * 0.1
+decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+output, present_state = _compute(
+    query,
+    key,
+    value,
+    past_state=past_state,
+    decay=decay,
+    beta=beta,
+    q_num_heads=h_q,
+    kv_num_heads=h_kv,
+)
+expect(
+    node,
+    inputs=[query, key, value, past_state, decay, beta],
+    outputs=[output, present_state],
+    name="test_linear_attention_prefill_with_past",
+    opset_imports=_OPSET,
+)
+```
+
+</details>
+
+
+### Log
+There are 1 test cases, listed as following:
+<details>
+<summary>log</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Log",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([1, 10]).astype(np.float32)
+y = np.log(x)  # expected output [0., 2.30258512]
+expect(node, inputs=[x], outputs=[y], name="test_log_example")
+
+x = np.exp(np.random.randn(3, 4, 5).astype(np.float32))
+y = np.log(x)
+expect(node, inputs=[x], outputs=[y], name="test_log")
+```
+
+</details>
+
+
+### LogSoftmax
+There are 2 test cases, listed as following:
+<details>
+<summary>logsoftmax</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.array([[-1, 0, 1]]).astype(np.float32)
+# expected output
+# [[-2.4076061 -1.407606  -0.407606 ]]
+y = logsoftmax(x)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_example_1")
+```
+
+</details>
+<details>
+<summary>logsoftmax_axis</summary>
+
+```python
+x = np.array([[0, 1, 2, 3], [10000, 10001, 10002, 10003]]).astype(np.float32)
+# expected output
+# [[-3.4401896  -2.4401896  -1.4401896  -0.44018966]
+# [-3.4401896  -2.4401896  -1.4401896  -0.44018966]]
+y = logsoftmax(x)
+
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_large_number")
+
+x = np.abs(np.random.randn(3, 4, 5).astype(np.float32))
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=0,
+)
+y = logsoftmax(x, axis=0)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_0")
+
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=1,
+)
+y = logsoftmax(x, axis=1)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_1")
+
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=2,
+)
+y = logsoftmax(x, axis=2)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_2")
+
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=-1,
+)
+y = logsoftmax(x, axis=-1)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_negative_axis")
+
+# default axis is -1
+node = onnx.helper.make_node(
+    "LogSoftmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_default_axis")
+```
+
+</details>
+
+
+### Loop
+There are 3 test cases, listed as following:
+<details>
+<summary>loop_11</summary>
+
+```python
+# Given a tensor x of values [x1, ..., xN], and initial tensor y
+# sum up its elements using a scan
+# returning the final state (y+x1+x2+...+xN) as well the scan_output
+# [y+x1, y+x1+x2, ..., y+x1+x2+...+xN]
+
+y_in = onnx.helper.make_tensor_value_info("y_in", onnx.TensorProto.FLOAT, [1])
+y_out = onnx.helper.make_tensor_value_info("y_out", onnx.TensorProto.FLOAT, [1])
+scan_out = onnx.helper.make_tensor_value_info(
+    "scan_out", onnx.TensorProto.FLOAT, [1]
+)
+cond_in = onnx.helper.make_tensor_value_info(
+    "cond_in", onnx.TensorProto.BOOL, []
+)
+cond_out = onnx.helper.make_tensor_value_info(
+    "cond_out", onnx.TensorProto.BOOL, []
+)
+iter_count = onnx.helper.make_tensor_value_info(
+    "iter_count", onnx.TensorProto.INT64, []
+)
+
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+y = np.array([-2]).astype(np.float32)
+
+x_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_x",
+        data_type=onnx.TensorProto.FLOAT,
+        dims=x.shape,
+        vals=x.flatten().astype(float),
+    ),
+)
+
+one_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["one"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_one",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[1],
+    ),
+)
+
+i_add_node = onnx.helper.make_node(
+    "Add", inputs=["iter_count", "one"], outputs=["end"]
+)
+
+start_unsqueeze_node = onnx.helper.make_node(
+    "Unsqueeze", inputs=["iter_count"], outputs=["slice_start"], axes=[0]
+)
+
+end_unsqueeze_node = onnx.helper.make_node(
+    "Unsqueeze", inputs=["end"], outputs=["slice_end"], axes=[0]
+)
+
+slice_node = onnx.helper.make_node(
+    "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+)
+
+y_add_node = onnx.helper.make_node(
+    "Add", inputs=["y_in", "slice_out"], outputs=["y_out"]
+)
+
+identity_node = onnx.helper.make_node(
+    "Identity", inputs=["cond_in"], outputs=["cond_out"]
+)
+
+scan_identity_node = onnx.helper.make_node(
+    "Identity", inputs=["y_out"], outputs=["scan_out"]
+)
+
+loop_body = onnx.helper.make_graph(
+    [
+        identity_node,
+        x_const_node,
+        one_const_node,
+        i_add_node,
+        start_unsqueeze_node,
+        end_unsqueeze_node,
+        slice_node,
+        y_add_node,
+        scan_identity_node,
+    ],
+    "loop_body",
+    [iter_count, cond_in, y_in],
+    [cond_out, y_out, scan_out],
+)
+
+node = onnx.helper.make_node(
+    "Loop",
+    inputs=["trip_count", "cond", "y"],
+    outputs=["res_y", "res_scan"],
+    body=loop_body,
+)
+
+trip_count = np.array(5).astype(np.int64)
+res_y = np.array([13]).astype(np.float32)
+cond = np.array(1).astype(bool)
+res_scan = np.array([-1, 1, 4, 8, 13]).astype(np.float32).reshape((5, 1))
+expect(
+    node,
+    inputs=[trip_count, cond, y],
+    outputs=[res_y, res_scan],
+    name="test_loop11",
+    opset_imports=[onnx.helper.make_opsetid("", 11)],
+)
+```
+
+</details>
+<details>
+<summary>loop_13</summary>
+
+```python
+# Given a tensor x of values [x1, ..., xN],
+# Return a sequence of tensors of
+#   [[x1], [x1, x2], ..., [x1, ..., xN]]
+
+seq_in = onnx.helper.make_tensor_sequence_value_info(
+    "seq_in", onnx.TensorProto.FLOAT, None
+)
+seq_out = onnx.helper.make_tensor_sequence_value_info(
+    "seq_out", onnx.TensorProto.FLOAT, None
+)
+cond_in = onnx.helper.make_tensor_value_info(
+    "cond_in", onnx.TensorProto.BOOL, []
+)
+cond_out = onnx.helper.make_tensor_value_info(
+    "cond_out", onnx.TensorProto.BOOL, []
+)
+iter_count = onnx.helper.make_tensor_value_info(
+    "iter_count", onnx.TensorProto.INT64, []
+)
+
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+
+x_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_x",
+        data_type=onnx.TensorProto.FLOAT,
+        dims=x.shape,
+        vals=x.flatten().astype(float),
+    ),
+)
+
+one_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["one"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_one",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[1],
+    ),
+)
+
+zero_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["slice_start"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_zero",
+        data_type=onnx.TensorProto.INT64,
+        dims=(1,),
+        vals=[0],
+    ),
+)
+
+axes_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["axes"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_axes",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[0],
+    ),
+)
+
+add_node = onnx.helper.make_node(
+    "Add", inputs=["iter_count", "one"], outputs=["end"]
+)
+
+end_unsqueeze_node = onnx.helper.make_node(
+    "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"]
+)
+
+slice_node = onnx.helper.make_node(
+    "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+)
+
+insert_node = onnx.helper.make_node(
+    "SequenceInsert", inputs=["seq_in", "slice_out"], outputs=["seq_out"]
+)
+
+identity_node = onnx.helper.make_node(
+    "Identity", inputs=["cond_in"], outputs=["cond_out"]
+)
+
+loop_body = onnx.helper.make_graph(
+    [
+        identity_node,
+        x_const_node,
+        one_const_node,
+        zero_const_node,
+        add_node,
+        axes_node,
+        end_unsqueeze_node,
+        slice_node,
+        insert_node,
+    ],
+    "loop_body",
+    [iter_count, cond_in, seq_in],
+    [cond_out, seq_out],
+)
+
+node = onnx.helper.make_node(
+    "Loop",
+    inputs=["trip_count", "cond", "seq_empty"],
+    outputs=["seq_res"],
+    body=loop_body,
+)
+
+trip_count = np.array(5).astype(np.int64)
+seq_empty: list[Any] = []
+seq_res = [x[: int(i)] for i in x]
+cond = np.array(1).astype(bool)
+expect(
+    node,
+    inputs=[trip_count, cond, seq_empty],
+    outputs=[seq_res],
+    name="test_loop13_seq",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+    input_type_protos=[
+        onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.INT64, trip_count.shape
+        ),
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape),
+        onnx.helper.make_sequence_type_proto(
+            onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, [])
+        ),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>loop_16_none</summary>
+
+```python
+# Given a tensor sequence of values [x1, ..., xN], and an initial optional sequence of tensors [x0],
+# Return a concatenated sequence of tensors of
+#   [x0, [x1], [x1, x2], ..., [x1, ..., xN]]
+
+ten_in_tp = onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, [])
+seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp)
+opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp)
+opt_in = onnx.helper.make_value_info("opt_seq_in", opt_in_tp)
+seq_out = onnx.helper.make_tensor_sequence_value_info(
+    "seq_out", onnx.TensorProto.FLOAT, []
+)
+cond_in = onnx.helper.make_tensor_value_info(
+    "cond_in", onnx.TensorProto.BOOL, []
+)
+cond_out = onnx.helper.make_tensor_value_info(
+    "cond_out", onnx.TensorProto.BOOL, []
+)
+iter_count = onnx.helper.make_tensor_value_info(
+    "iter_count", onnx.TensorProto.INT64, []
+)
+
+x0 = np.array(0).astype(np.float32)
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+
+optional_has_elem_node = onnx.helper.make_node(
+    "OptionalHasElement", inputs=["opt_seq_in"], outputs=["optional_has_elem"]
+)
+
+optional_is_none = onnx.helper.make_node(
+    "Not", inputs=["optional_has_elem"], outputs=["optional_is_none"]
+)
+
+optional_get_elem = onnx.helper.make_node(
+    "OptionalGetElement", inputs=["opt_seq_in"], outputs=["seq_in"]
+)
+
+constant_in = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["constant_in"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor", data_type=onnx.TensorProto.FLOAT, dims=(), vals=[0]
+    ),
+)
+
+seq_const_in = onnx.helper.make_node(
+    "SequenceConstruct", inputs=["constant_in"], outputs=["init_seq_in"]
+)
+
+then_seq_out = onnx.helper.make_tensor_sequence_value_info(
+    "init_seq_in", onnx.TensorProto.FLOAT, []
+)
+then_body = onnx.helper.make_graph(
+    [constant_in, seq_const_in], "then_body", [], [then_seq_out]
+)
+
+else_seq_out = onnx.helper.make_tensor_sequence_value_info(
+    "seq_in", onnx.TensorProto.FLOAT, []
+)
+else_body = onnx.helper.make_graph(
+    [optional_get_elem], "else_body", [], [else_seq_out]
+)
+
+if_node = onnx.helper.make_node(
+    "If",
+    inputs=["optional_is_none"],
+    outputs=["sequence"],
+    then_branch=then_body,
+    else_branch=else_body,
+)
+
+x_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["x"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_x",
+        data_type=onnx.TensorProto.FLOAT,
+        dims=x.shape,
+        vals=x.flatten().astype(float),
+    ),
+)
+
+one_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["one"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_one",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[1],
+    ),
+)
+
+zero_const_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["slice_start"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_zero",
+        data_type=onnx.TensorProto.INT64,
+        dims=(1,),
+        vals=[0],
+    ),
+)
+
+axes_node = onnx.helper.make_node(
+    "Constant",
+    inputs=[],
+    outputs=["axes"],
+    value=onnx.helper.make_tensor(
+        name="const_tensor_axes",
+        data_type=onnx.TensorProto.INT64,
+        dims=(),
+        vals=[0],
+    ),
+)
+
+add_node = onnx.helper.make_node(
+    "Add", inputs=["iter_count", "one"], outputs=["end"]
+)
+
+end_unsqueeze_node = onnx.helper.make_node(
+    "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"]
+)
+
+slice_node = onnx.helper.make_node(
+    "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+)
+
+insert_node = onnx.helper.make_node(
+    "SequenceInsert", inputs=["sequence", "slice_out"], outputs=["seq_out"]
+)
+
+identity_node = onnx.helper.make_node(
+    "Identity", inputs=["cond_in"], outputs=["cond_out"]
+)
+
+loop_body = onnx.helper.make_graph(
+    [
+        identity_node,
+        optional_has_elem_node,
+        optional_is_none,
+        if_node,
+        x_const_node,
+        one_const_node,
+        zero_const_node,
+        add_node,
+        axes_node,
+        end_unsqueeze_node,
+        slice_node,
+        insert_node,
+    ],
+    "loop_body",
+    [iter_count, cond_in, opt_in],
+    [cond_out, seq_out],
+)
+
+node = onnx.helper.make_node(
+    "Loop",
+    inputs=["trip_count", "cond", "opt_seq"],
+    outputs=["seq_res"],
+    body=loop_body,
+)
+
+trip_count = np.array(5).astype(np.int64)
+cond = np.array(1).astype(bool)
+seq_res = compute_loop_outputs(x, [x0], trip_count)
+opt_seq_in: list[Any] = [x0]
+expect(
+    node,
+    inputs=[trip_count, cond, opt_seq_in],
+    outputs=[seq_res],
+    name="test_loop16_seq_none",
+    opset_imports=[onnx.helper.make_opsetid("", 16)],
+    input_type_protos=[
+        onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.INT64, trip_count.shape
+        ),
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape),
+        opt_in_tp,
+    ],
+)
+```
+
+</details>
+
+
+### LpNormalization
+There are 6 test cases, listed as following:
+<details>
+<summary>default</summary>
+
+```python
+node = onnx.helper.make_node("LpNormalization", inputs=["x"], outputs=["y"])
+x = np.array(
+    [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+    dtype=np.float32,
+)
+lp_norm_default = np.sqrt(np.sum(x**2, axis=-1, keepdims=True))
+y = x / lp_norm_default
+expect(node, inputs=[x], outputs=[y], name="test_lpnormalization_default")
+```
+
+</details>
+<details>
+<summary>l1normalization_axis_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=1
+)
+x = np.array([3.0, 4.0], dtype=np.float32)
+l1_norm_axis_0 = np.sum(abs(x), axis=0, keepdims=True)
+y = x / l1_norm_axis_0
+expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_0")
+```
+
+</details>
+<details>
+<summary>l1normalization_axis_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=1
+)
+x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+l1_norm_axis_1 = np.sum(abs(x), axis=1, keepdims=True)
+y = x / l1_norm_axis_1
+expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_1")
+```
+
+</details>
+<details>
+<summary>l1normalization_axis_last</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=-1, p=1
+)
+x = np.array(
+    [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+    dtype=np.float32,
+)
+l1_norm_axis_last = np.sum(abs(x), axis=-1, keepdims=True)
+y = x / l1_norm_axis_last
+expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_last")
+```
+
+</details>
+<details>
+<summary>l2normalization_axis_0</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=2
+)
+x = np.array(
+    [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+    dtype=np.float32,
+)
+l2_norm_axis_0 = np.sqrt(np.sum(x**2, axis=0, keepdims=True))
+# When norm is 0, output is 0 (0/0 = 0)
+y = np.where(l2_norm_axis_0 == 0, 0, x / l2_norm_axis_0)
+expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_0")
+```
+
+</details>
+<details>
+<summary>l2normalization_axis_1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=2
+)
+x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+l2_norm_axis_1 = np.sqrt(np.sum(x**2, axis=1, keepdims=True))
+y = x / l2_norm_axis_1
+expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_1")
+```
+
+</details>
+
+
+### LpPool
+There are 8 test cases, listed as following:
+<details>
+<summary>lppool_1d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32]
+output_shape: [1, 3, 31]
+"""
+p = 3
+kernel_shape = [2]
+strides = [1]
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=kernel_shape,
+    strides=strides,
+    p=p,
+)
+x = np.random.randn(1, 3, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_1d_default")
+```
+
+</details>
+<details>
+<summary>lppool_2d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 31, 31]
+"""
+p = 4
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_default")
+```
+
+</details>
+<details>
+<summary>lppool_2d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+p = 2
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[1, 1],
+    dilations=[2, 2],
+    p=p,
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+y = np.array(
+    [
+        [
+            [
+                [14.560219778561036, 16.24807680927192],
+                [21.633307652783937, 23.49468024894146],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_dilations")
+```
+
+</details>
+<details>
+<summary>lppool_2d_pads</summary>
+
+```python
+"""input_shape: [1, 3, 28, 28]
+output_shape: [1, 3, 30, 30]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+p = 3
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[2, 2, 2, 2],
+    p=p,
+)
+x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (3, 3)
+strides = (1, 1)
+pad_bottom = pad_top = pad_right = pad_left = 2
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+out_shape, extra_pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = np.pad(
+    x,
+    (
+        (0, 0),
+        (0, 0),
+        (extra_pads[0], extra_pads[2]),
+        (extra_pads[1], extra_pads[3]),
+    ),
+    mode="constant",
+    constant_values=0,
+)
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "LPPOOL",
+    pads_required=extra_pads,
+    pads=pads,
+    p=p,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_pads")
+```
+
+</details>
+<details>
+<summary>lppool_2d_same_lower</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+"""
+p = 4
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_LOWER",
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_bottom = pad_shape[0] // 2
+pad_top = pad_shape[0] - pad_bottom
+pad_right = pad_shape[1] // 2
+pad_left = pad_shape[1] - pad_right
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=0,
+)
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+y = pool(
+    padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_lower")
+```
+
+</details>
+<details>
+<summary>lppool_2d_same_upper</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+"""
+p = 2
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_UPPER",
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_top = pad_shape[0] // 2
+pad_bottom = pad_shape[0] - pad_top
+pad_left = pad_shape[1] // 2
+pad_right = pad_shape[1] - pad_left
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=0,
+)
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+y = pool(
+    padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_upper")
+```
+
+</details>
+<details>
+<summary>lppool_2d_strides</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 10, 10]
+"""
+p = 2
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    strides=[3, 3],
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (5, 5)
+strides = (3, 3)
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_strides")
+```
+
+</details>
+<details>
+<summary>lppool_3d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32, 32]
+output_shape: [1, 3, 31, 31, 31]
+"""
+p = 3
+node = onnx.helper.make_node(
+    "LpPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+    p=p,
+)
+x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2, 2, 2]
+strides = [1, 1, 1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+expect(node, inputs=[x], outputs=[y], name="test_lppool_3d_default")
+```
+
+</details>
+
+
+### MatMul
+There are 1 test cases, listed as following:
+<details>
+<summary>matmul</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MatMul",
+    inputs=["a", "b"],
+    outputs=["c"],
+)
+
+# 2d
+a = np.random.randn(3, 4).astype(np.float32)
+b = np.random.randn(4, 3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_2d")
+
+# 3d
+a = np.random.randn(2, 3, 4).astype(np.float32)
+b = np.random.randn(2, 4, 3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_3d")
+
+# 4d
+a = np.random.randn(1, 2, 3, 4).astype(np.float32)
+b = np.random.randn(1, 2, 4, 3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_4d")
+
+# broadcasting
+a = np.random.randn(3, 1, 3, 4).astype(np.float32)
+b = np.random.randn(1, 2, 4, 2).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_bcast")
+
+# 1d + 3d
+a = np.random.randn(4).astype(np.float32)
+b = np.random.randn(2, 4, 1).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_1d_3d")
+
+# 3d + 1d
+a = np.random.randn(1, 2, 4, 3).astype(np.float32)
+b = np.random.randn(3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_4d_1d")
+
+# 1d + 1d
+a = np.random.randn(3).astype(np.float32)
+b = np.random.randn(3).astype(np.float32)
+c = np.matmul(a, b)
+expect(node, inputs=[a, b], outputs=[c], name="test_matmul_1d_1d")
+```
+
+</details>
+
+
+### MatMulInteger
+There are 1 test cases, listed as following:
+<details>
+<summary>matmulinteger</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MatMulInteger",
+    inputs=["A", "B", "a_zero_point", "b_zero_point"],
+    outputs=["Y"],
+)
+
+A = np.array(
+    [
+        [11, 7, 3],
+        [10, 6, 2],
+        [9, 5, 1],
+        [8, 4, 0],
+    ],
+    dtype=np.uint8,
+)
+
+a_zero_point = np.array([12], dtype=np.uint8)
+
+B = np.array(
+    [
+        [1, 4],
+        [2, 5],
+        [3, 6],
+    ],
+    dtype=np.uint8,
+)
+
+b_zero_point = np.array([0], dtype=np.uint8)
+
+output = np.array(
+    [
+        [-38, -83],
+        [-44, -98],
+        [-50, -113],
+        [-56, -128],
+    ],
+    dtype=np.int32,
+)
+
+expect(
+    node,
+    inputs=[A, B, a_zero_point, b_zero_point],
+    outputs=[output],
+    name="test_matmulinteger",
+)
+```
+
+</details>
+
+
+### Max
+There are 2 test cases, listed as following:
+<details>
+<summary>max</summary>
+
+```python
+data_0 = np.array([3, 2, 1]).astype(np.float32)
+data_1 = np.array([1, 4, 4]).astype(np.float32)
+data_2 = np.array([2, 5, 3]).astype(np.float32)
+result = np.array([3, 5, 4]).astype(np.float32)
+node = onnx.helper.make_node(
+    "Max",
+    inputs=["data_0", "data_1", "data_2"],
+    outputs=["result"],
+)
+expect(
+    node,
+    inputs=[data_0, data_1, data_2],
+    outputs=[result],
+    name="test_max_example",
+)
+
+node = onnx.helper.make_node(
+    "Max",
+    inputs=["data_0"],
+    outputs=["result"],
+)
+expect(node, inputs=[data_0], outputs=[data_0], name="test_max_one_input")
+
+result = np.maximum(data_0, data_1)
+node = onnx.helper.make_node(
+    "Max",
+    inputs=["data_0", "data_1"],
+    outputs=["result"],
+)
+expect(
+    node, inputs=[data_0, data_1], outputs=[result], name="test_max_two_inputs"
+)
+```
+
+</details>
+<details>
+<summary>max_all_numeric_types</summary>
+
+```python
+for op_dtype in all_numeric_dtypes:
+    data_0 = np.array([3, 2, 1]).astype(op_dtype)
+    data_1 = np.array([1, 4, 4]).astype(op_dtype)
+    result = np.array([3, 4, 4]).astype(op_dtype)
+    node = onnx.helper.make_node(
+        "Max",
+        inputs=["data_0", "data_1"],
+        outputs=["result"],
+    )
+    expect(
+        node,
+        inputs=[data_0, data_1],
+        outputs=[result],
+        name=f"test_max_{np.dtype(op_dtype).name}",
+    )
+```
+
+</details>
+
+
+### MaxPool
+There are 19 test cases, listed as following:
+<details>
+<summary>maxpool_1d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32]
+output_shape: [1, 3, 31]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2],
+)
+x = np.random.randn(1, 3, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2]
+strides = [1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_1d_default")
+```
+
+</details>
+<details>
+<summary>maxpool_2d_ceil</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+    ceil_mode=True,
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_ceil")
+```
+
+</details>
+<details>
+<summary>maxpool_2d_ceil_output_size_reduce_by_one</summary>
+
+```python
+"""input_shape: [1, 1, 2, 2]
+output_shape: [1, 1, 1, 1]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[1, 1],
+    strides=[2, 2],
+    ceil_mode=True,
+)
+x = np.array([[[[1, 2], [3, 4]]]]).astype(np.float32)
+y = np.array([[[[1]]]]).astype(np.float32)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_maxpool_2d_ceil_output_size_reduce_by_one",
+)
+```
+
+</details>
+<details>
+<summary>maxpool_2d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 31, 31]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_default")
+```
+
+</details>
+<details>
+<summary>maxpool_2d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[1, 1],
+    dilations=[2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_dilations")
+```
+
+</details>
+<details>
+<summary>maxpool_2d_pads</summary>
+
+```python
+"""input_shape: [1, 3, 28, 28]
+output_shape: [1, 3, 30, 30]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    pads=[2, 2, 2, 2],
+)
+x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (3, 3)
+strides = (1, 1)
+pad_bottom = pad_top = pad_right = pad_left = 2
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+out_shape, extra_pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+
+y = pool(
+    padded,
+    x_shape,
+    kernel_shape,
+    strides,
+    out_shape,
+    "MAX",
+    pads_required=extra_pads,
+    pads=pads,
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_pads")
+```
+
+</details>
+<details>
+<summary>maxpool_2d_precomputed_pads</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array(
+    [
+        [
+            [
+                [13, 14, 15, 15, 15],
+                [18, 19, 20, 20, 20],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_pads")
+```
+
+</details>
+<details>
+<summary>maxpool_2d_precomputed_same_upper</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 3, 3]
+pad_shape: [2, 2] -> [1, 1, 1, 1] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[3, 3],
+    strides=[2, 2],
+    auto_pad="SAME_UPPER",
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[7, 9, 10], [17, 19, 20], [22, 24, 25]]]]).astype(np.float32)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_same_upper"
+)
+```
+
+</details>
+<details>
+<summary>maxpool_2d_precomputed_strides</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[2, 2], strides=[2, 2]
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_strides"
+)
+```
+
+</details>
+<details>
+<summary>maxpool_2d_same_lower</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_LOWER",
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_bottom = pad_shape[0] // 2
+pad_top = pad_shape[0] - pad_bottom
+pad_right = pad_shape[1] // 2
+pad_left = pad_shape[1] - pad_right
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_lower")
+```
+
+</details>
+<details>
+<summary>maxpool_2d_same_upper</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 32, 32]
+pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    auto_pad="SAME_UPPER",
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+kernel_shape = (2, 2)
+strides = (1, 1)
+out_shape = get_output_shape_auto_pad(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides
+)
+pad_shape = get_pad_shape(
+    "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+)
+pad_top = pad_shape[0] // 2
+pad_bottom = pad_shape[0] - pad_top
+pad_left = pad_shape[1] // 2
+pad_right = pad_shape[1] - pad_left
+padded = np.pad(
+    x,
+    ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+    mode="constant",
+    constant_values=np.nan,
+)
+pads = [pad_top, pad_left, pad_bottom, pad_right]
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_upper")
+```
+
+</details>
+<details>
+<summary>maxpool_2d_strides</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32]
+output_shape: [1, 3, 10, 10]
+"""
+node = onnx.helper.make_node(
+    "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[5, 5], strides=[3, 3]
+)
+x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = (5, 5)
+strides = (3, 3)
+out_shape, pads = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_strides")
+```
+
+</details>
+<details>
+<summary>maxpool_2d_uint8</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.uint8)
+y = np.array(
+    [
+        [
+            [
+                [13, 14, 15, 15, 15],
+                [18, 19, 20, 20, 20],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+            ]
+        ]
+    ]
+).astype(np.uint8)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_uint8")
+```
+
+</details>
+<details>
+<summary>maxpool_3d_default</summary>
+
+```python
+"""input_shape: [1, 3, 32, 32, 32]
+output_shape: [1, 3, 31, 31, 31]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+)
+x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+x_shape = np.shape(x)
+pads = None
+kernel_shape = [2, 2, 2]
+strides = [1, 1, 1]
+out_shape, _ = get_output_shape_explicit_padding(
+    pads, x_shape[2:], kernel_shape, strides
+)
+padded = x
+y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_3d_default")
+```
+
+</details>
+<details>
+<summary>maxpool_3d_dilations</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4, 4]
+output_shape: [1, 1, 2, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+    strides=[1, 1, 1],
+    dilations=[2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[[11, 12], [15, 16]], [[11, 12], [15, 16]]]]]).astype(
+    np.float32
+)
+
+expect(node, inputs=[x], outputs=[y], name="test_maxpool_3d_dilations")
+```
+
+</details>
+<details>
+<summary>maxpool_3d_dilations_use_ref_impl</summary>
+
+```python
+"""input_shape: [1, 1, 4, 4, 4]
+output_shape: [1, 1, 2, 2, 2]
+"""
+dilations = [2, 2, 2]
+kernel_shape = [2, 2, 2]
+strides = [1, 1, 1]
+ceil_mode = False
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=[2, 2, 2],
+    strides=[1, 1, 1],
+    dilations=dilations,
+)
+x = np.array(
+    [
+        [
+            [
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+                [
+                    [1, 2, 3, 4],
+                    [5, 6, 7, 8],
+                    [9, 10, 11, 12],
+                    [13, 14, 15, 16],
+                ],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+x_shape = x.shape[2:]
+out_shape, pads = get_output_shape_explicit_padding(
+    None, x_shape, kernel_shape, strides, dilations, ceil_mode=ceil_mode
+)
+padded = x
+y = pool(
+    padded,
+    (1, 1, *x_shape),
+    kernel_shape,
+    strides,
+    out_shape,
+    "MAX",
+    pads_required=pads,
+    pads=None,
+    dilations=dilations,
+)
+
+expect(
+    node, inputs=[x], outputs=[y], name="test_maxpool_3d_dilations_use_ref_impl"
+)
+```
+
+</details>
+<details>
+<summary>maxpool_3d_dilations_use_ref_impl_large</summary>
+
+```python
+x_shape = (32, 32, 32)
+dilations = (2, 2, 2)
+kernel_shape = (5, 5, 5)
+strides = (3, 3, 3)
+ceil_mode = True
+
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y"],
+    kernel_shape=kernel_shape,
+    strides=strides,
+    dilations=dilations,
+    ceil_mode=ceil_mode,
+)
+
+x = np.random.randn(1, 1, *x_shape).astype(np.float32)
+out_shape, pads = get_output_shape_explicit_padding(
+    None, x_shape, kernel_shape, strides, dilations, ceil_mode=ceil_mode
+)
+padded = np.pad(
+    x,
+    (
+        (0, 0),
+        (0, 0),
+        (pads[0], pads[3]),
+        (pads[1], pads[4]),
+        (pads[2], pads[5]),
+    ),
+    mode="constant",
+    constant_values=0,
+)
+y = pool(
+    padded,
+    (1, 1, *x_shape),
+    kernel_shape,
+    strides,
+    out_shape,
+    "MAX",
+    pads_required=pads,
+    pads=None,
+    dilations=dilations,
+)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_maxpool_3d_dilations_use_ref_impl_large",
+)
+```
+
+</details>
+<details>
+<summary>maxpool_with_argmax_2d_precomputed_pads</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 5, 5]
+pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y", "z"],
+    kernel_shape=[5, 5],
+    pads=[2, 2, 2, 2],
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array(
+    [
+        [
+            [
+                [13, 14, 15, 15, 15],
+                [18, 19, 20, 20, 20],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+                [23, 24, 25, 25, 25],
+            ]
+        ]
+    ]
+).astype(np.float32)
+z = np.array(
+    [
+        [
+            [
+                [12, 13, 14, 14, 14],
+                [17, 18, 19, 19, 19],
+                [22, 23, 24, 24, 24],
+                [22, 23, 24, 24, 24],
+                [22, 23, 24, 24, 24],
+            ]
+        ]
+    ]
+).astype(np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y, z],
+    name="test_maxpool_with_argmax_2d_precomputed_pads",
+)
+```
+
+</details>
+<details>
+<summary>maxpool_with_argmax_2d_precomputed_strides</summary>
+
+```python
+"""input_shape: [1, 1, 5, 5]
+output_shape: [1, 1, 2, 2]
+"""
+node = onnx.helper.make_node(
+    "MaxPool",
+    inputs=["x"],
+    outputs=["y", "z"],
+    kernel_shape=[2, 2],
+    strides=[2, 2],
+    storage_order=1,
+)
+x = np.array(
+    [
+        [
+            [
+                [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],
+            ]
+        ]
+    ]
+).astype(np.float32)
+y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32)
+z = np.array([[[[6, 16], [8, 18]]]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y, z],
+    name="test_maxpool_with_argmax_2d_precomputed_strides",
+)
+```
+
+</details>
+
+
+### MaxUnpool
+There are 2 test cases, listed as following:
+<details>
+<summary>with_output_shape</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MaxUnpool",
+    inputs=["xT", "xI", "output_shape"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[2, 2],
+)
+xT = np.array([[[[5, 6], [7, 8]]]], dtype=np.float32)
+xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64)
+output_shape = np.array((1, 1, 5, 5), dtype=np.int64)
+y = np.array(
+    [
+        [
+            [
+                [0, 0, 0, 0, 0],
+                [0, 5, 0, 6, 0],
+                [0, 0, 0, 0, 0],
+                [0, 7, 0, 8, 0],
+                [0, 0, 0, 0, 0],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[xT, xI, output_shape],
+    outputs=[y],
+    name="test_maxunpool_export_with_output_shape",
+)
+```
+
+</details>
+<details>
+<summary>without_output_shape</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MaxUnpool",
+    inputs=["xT", "xI"],
+    outputs=["y"],
+    kernel_shape=[2, 2],
+    strides=[2, 2],
+)
+xT = np.array([[[[1, 2], [3, 4]]]], dtype=np.float32)
+xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64)
+y = np.array(
+    [[[[0, 0, 0, 0], [0, 1, 0, 2], [0, 0, 0, 0], [0, 3, 0, 4]]]],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[xT, xI],
+    outputs=[y],
+    name="test_maxunpool_export_without_output_shape",
+)
+```
+
+</details>
+
+
+### Mean
+There are 1 test cases, listed as following:
+<details>
+<summary>mean</summary>
+
+```python
+data_0 = np.array([3, 0, 2]).astype(np.float32)
+data_1 = np.array([1, 3, 4]).astype(np.float32)
+data_2 = np.array([2, 6, 6]).astype(np.float32)
+result = np.array([2, 3, 4]).astype(np.float32)
+node = onnx.helper.make_node(
+    "Mean",
+    inputs=["data_0", "data_1", "data_2"],
+    outputs=["result"],
+)
+expect(
+    node,
+    inputs=[data_0, data_1, data_2],
+    outputs=[result],
+    name="test_mean_example",
+)
+
+node = onnx.helper.make_node(
+    "Mean",
+    inputs=["data_0"],
+    outputs=["result"],
+)
+expect(node, inputs=[data_0], outputs=[data_0], name="test_mean_one_input")
+
+result = np.divide(np.add(data_0, data_1), 2.0)
+node = onnx.helper.make_node(
+    "Mean",
+    inputs=["data_0", "data_1"],
+    outputs=["result"],
+)
+expect(
+    node, inputs=[data_0, data_1], outputs=[result], name="test_mean_two_inputs"
+)
+```
+
+</details>
+
+
+### MeanVarianceNormalization
+There are 1 test cases, listed as following:
+<details>
+<summary>meanvariancenormalization</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MeanVarianceNormalization", inputs=["X"], outputs=["Y"]
+)
+
+input_data = np.array(
+    [
+        [
+            [[0.8439683], [0.5665144], [0.05836735]],
+            [[0.02916367], [0.12964272], [0.5060197]],
+            [[0.79538304], [0.9411346], [0.9546573]],
+        ],
+        [
+            [[0.17730942], [0.46192095], [0.26480448]],
+            [[0.6746842], [0.01665257], [0.62473077]],
+            [[0.9240844], [0.9722341], [0.11965699]],
+        ],
+        [
+            [[0.41356155], [0.9129373], [0.59330076]],
+            [[0.81929934], [0.7862604], [0.11799799]],
+            [[0.69248444], [0.54119414], [0.07513223]],
+        ],
+    ],
+    dtype=np.float32,
+)
+
+# Calculate expected output data
+data_mean = np.mean(input_data, axis=(0, 2, 3), keepdims=1)
+data_mean_squared = np.power(data_mean, 2)
+data_squared = np.power(input_data, 2)
+data_squared_mean = np.mean(data_squared, axis=(0, 2, 3), keepdims=1)
+std = np.sqrt(data_squared_mean - data_mean_squared)
+expected_output = (input_data - data_mean) / (std + 1e-9)
+
+expect(node, inputs=[input_data], outputs=[expected_output], name="test_mvn")
+```
+
+</details>
+
+
+### MelWeightMatrix
+There are 1 test cases, listed as following:
+<details>
+<summary>melweightmatrix</summary>
+
+```python
+node = onnx.helper.make_node(
+    "MelWeightMatrix",
+    inputs=[
+        "num_mel_bins",
+        "dft_length",
+        "sample_rate",
+        "lower_edge_hertz",
+        "upper_edge_hertz",
+    ],
+    outputs=["output"],
+)
+
+num_mel_bins = np.int32(8)
+dft_length = np.int32(16)
+sample_rate = np.int32(8192)
+lower_edge_hertz = np.float32(0)
+upper_edge_hertz = np.float32(8192 / 2)
+
+num_spectrogram_bins = dft_length // 2 + 1
+frequency_bins = np.arange(0, num_mel_bins + 2)
+
+low_frequency_mel = 2595 * np.log10(1 + lower_edge_hertz / 700)
+high_frequency_mel = 2595 * np.log10(1 + upper_edge_hertz / 700)
+mel_step = (high_frequency_mel - low_frequency_mel) / frequency_bins.shape[0]
+
+frequency_bins = frequency_bins * mel_step + low_frequency_mel
+frequency_bins = 700 * (np.power(10, (frequency_bins / 2595)) - 1)
+frequency_bins = ((dft_length + 1) * frequency_bins) // sample_rate
+frequency_bins = frequency_bins.astype(int)
+
+output = np.zeros((num_spectrogram_bins, num_mel_bins))
+output.flags.writeable = True
+
+for i in range(num_mel_bins):
+    lower_frequency_value = frequency_bins[i]  # left
+    center_frequency_point = frequency_bins[i + 1]  # center
+    higher_frequency_point = frequency_bins[i + 2]  # right
+    low_to_center = center_frequency_point - lower_frequency_value
+    if low_to_center == 0:
+        output[center_frequency_point, i] = 1
+    else:
+        for j in range(lower_frequency_value, center_frequency_point + 1):
+            output[j, i] = float(j - lower_frequency_value) / float(
+                low_to_center
+            )
+    center_to_high = higher_frequency_point - center_frequency_point
+    if center_to_high > 0:
+        for j in range(center_frequency_point, higher_frequency_point):
+            output[j, i] = float(higher_frequency_point - j) / float(
+                center_to_high
+            )
+
+# Expected output
+# 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+# 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+output = output.astype(np.float32)
+expect(
+    node,
+    inputs=[
+        num_mel_bins,
+        dft_length,
+        sample_rate,
+        lower_edge_hertz,
+        upper_edge_hertz,
+    ],
+    outputs=[output],
+    name="test_melweightmatrix",
+)
+```
+
+</details>
+
+
+### Min
+There are 2 test cases, listed as following:
+<details>
+<summary>min</summary>
+
+```python
+data_0 = np.array([3, 2, 1]).astype(np.float32)
+data_1 = np.array([1, 4, 4]).astype(np.float32)
+data_2 = np.array([2, 5, 0]).astype(np.float32)
+result = np.array([1, 2, 0]).astype(np.float32)
+node = onnx.helper.make_node(
+    "Min",
+    inputs=["data_0", "data_1", "data_2"],
+    outputs=["result"],
+)
+expect(
+    node,
+    inputs=[data_0, data_1, data_2],
+    outputs=[result],
+    name="test_min_example",
+)
+
+node = onnx.helper.make_node(
+    "Min",
+    inputs=["data_0"],
+    outputs=["result"],
+)
+expect(node, inputs=[data_0], outputs=[data_0], name="test_min_one_input")
+
+result = np.minimum(data_0, data_1)
+node = onnx.helper.make_node(
+    "Min",
+    inputs=["data_0", "data_1"],
+    outputs=["result"],
+)
+expect(
+    node, inputs=[data_0, data_1], outputs=[result], name="test_min_two_inputs"
+)
+```
+
+</details>
+<details>
+<summary>min_all_numeric_types</summary>
+
+```python
+for op_dtype in all_numeric_dtypes:
+    data_0 = np.array([3, 2, 1]).astype(op_dtype)
+    data_1 = np.array([1, 4, 4]).astype(op_dtype)
+    result = np.array([1, 2, 1]).astype(op_dtype)
+    node = onnx.helper.make_node(
+        "Min",
+        inputs=["data_0", "data_1"],
+        outputs=["result"],
+    )
+    expect(
+        node,
+        inputs=[data_0, data_1],
+        outputs=[result],
+        name=f"test_min_{np.dtype(op_dtype).name}",
+    )
+```
+
+</details>
+
+
+### Mish
+There are 1 test cases, listed as following:
+<details>
+<summary>mish</summary>
+
+```python
+node = onnx.helper.make_node("Mish", inputs=["X"], outputs=["Y"])
+
+input_data = np.linspace(-10, 10, 10000, dtype=np.float32)
+
+# Calculate expected output data
+expected_output = input_data * np.tanh(np.log1p(np.exp(input_data)))
+
+expect(node, inputs=[input_data], outputs=[expected_output], name="test_mish")
+```
+
+</details>
+
+
+### Mod
+There are 13 test cases, listed as following:
+<details>
+<summary>mod_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.arange(0, 30).reshape([3, 2, 5]).astype(np.int32)
+y = np.array([7]).astype(np.int32)
+z = np.mod(x, y)
+#   array([[[0, 1, 2, 3, 4],
+#     [5, 6, 0, 1, 2]],
+
+#    [[3, 4, 5, 6, 0],
+#     [1, 2, 3, 4, 5]],
+
+#    [[6, 0, 1, 2, 3],
+#     [4, 5, 6, 0, 1]]], dtype=int32)
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_broadcast")
+```
+
+</details>
+<details>
+<summary>mod_int64_fmod</summary>
+
+```python
+node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64)
+z = np.fmod(x, y)  # expected output [ 0,  1,  5,  0, -1,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_int64_fmod")
+```
+
+</details>
+<details>
+<summary>mod_mixed_sign_float16</summary>
+
+```python
+node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float16)
+y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float16)
+z = np.fmod(
+    x, y
+)  # expected output [-0.10156, 0.3984 , 5. , 0.10156, -0.3984 ,  3.]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float16")
+```
+
+</details>
+<details>
+<summary>mod_mixed_sign_float32</summary>
+
+```python
+node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float32)
+y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float32)
+z = np.fmod(
+    x, y
+)  # expected output [-0.10000038, 0.39999962, 5. , 0.10000038, -0.39999962, 3.]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float32")
+```
+
+</details>
+<details>
+<summary>mod_mixed_sign_float64</summary>
+
+```python
+node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float64)
+y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float64)
+z = np.fmod(x, y)  # expected output [-0.1,  0.4,  5. ,  0.1, -0.4,  3.]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float64")
+```
+
+</details>
+<details>
+<summary>mod_mixed_sign_int16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int16)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int16)
+z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int16")
+```
+
+</details>
+<details>
+<summary>mod_mixed_sign_int32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int32)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int32)
+z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int32")
+```
+
+</details>
+<details>
+<summary>mod_mixed_sign_int64</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64)
+z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int64")
+```
+
+</details>
+<details>
+<summary>mod_mixed_sign_int8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int8)
+y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int8)
+z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int8")
+```
+
+</details>
+<details>
+<summary>mod_uint16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([4, 7, 5]).astype(np.uint16)
+y = np.array([2, 3, 8]).astype(np.uint16)
+z = np.mod(x, y)  # expected output [0, 1, 5]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint16")
+```
+
+</details>
+<details>
+<summary>mod_uint32</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([4, 7, 5]).astype(np.uint32)
+y = np.array([2, 3, 8]).astype(np.uint32)
+z = np.mod(x, y)  # expected output [0, 1, 5]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint32")
+```
+
+</details>
+<details>
+<summary>mod_uint64</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([4, 7, 5]).astype(np.uint64)
+y = np.array([2, 3, 8]).astype(np.uint64)
+z = np.mod(x, y)  # expected output [0, 1, 5]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint64")
+```
+
+</details>
+<details>
+<summary>mod_uint8</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mod",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([4, 7, 5]).astype(np.uint8)
+y = np.array([2, 3, 8]).astype(np.uint8)
+z = np.mod(x, y)  # expected output [0, 1, 5]
+expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint8")
+```
+
+</details>
+
+
+### Momentum
+There are 3 test cases, listed as following:
+<details>
+<summary>momentum</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+alpha = 0.95
+beta = 0.1
+
+# Create operator.
+node = onnx.helper.make_node(
+    "Momentum",
+    inputs=["R", "T", "X", "G", "V"],
+    outputs=["X_new", "V_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    mode="standard",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+x = np.array([1.2, 2.8], dtype=np.float32)
+g = np.array([-0.94, -2.5], dtype=np.float32)
+v = np.array([1.7, 3.6], dtype=np.float32)
+
+# Compute expected outputs of Momentum.
+x_new, v_new = apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x, g, v],
+    outputs=[x_new, v_new],
+    name="test_momentum",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+<details>
+<summary>momentum_multiple</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.001
+alpha = 0.95
+beta = 0.85
+
+node = onnx.helper.make_node(
+    "Momentum",
+    inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"],
+    outputs=["X1_new", "X2_new", "V1_new", "V2_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    mode="standard",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+
+x1 = np.array([1.0], dtype=np.float32)
+g1 = np.array([-1.0], dtype=np.float32)
+v1 = np.array([2.0], dtype=np.float32)
+
+x2 = np.array([1.0, 2.0], dtype=np.float32)
+g2 = np.array([-1.0, -3.0], dtype=np.float32)
+v2 = np.array([4.0, 1.0], dtype=np.float32)
+
+# Compute expected outputs of Momentum.
+x1_new, v1_new = apply_momentum(r, t, x1, g1, v1, norm_coefficient, alpha, beta)
+x2_new, v2_new = apply_momentum(r, t, x2, g2, v2, norm_coefficient, alpha, beta)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x1, x2, g1, g2, v1, v2],
+    outputs=[x1_new, x2_new, v1_new, v2_new],
+    name="test_momentum_multiple",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+<details>
+<summary>nesterov_momentum</summary>
+
+```python
+# Define operator attributes.
+norm_coefficient = 0.01
+alpha = 0.95
+beta = 1.0
+
+# Create operator.
+node = onnx.helper.make_node(
+    "Momentum",
+    inputs=["R", "T", "X", "G", "V"],
+    outputs=["X_new", "V_new"],
+    norm_coefficient=norm_coefficient,
+    alpha=alpha,
+    beta=beta,
+    mode="nesterov",
+    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+)
+
+# Define operator inputs.
+r = np.array(0.1, dtype=np.float32)  # scalar
+t = np.array(0, dtype=np.int64)  # scalar
+x = np.array([1.2, 2.8], dtype=np.float32)
+g = np.array([-0.94, -2.5], dtype=np.float32)
+v = np.array([1.7, 3.6], dtype=np.float32)
+
+# Compute expected outputs of Momentum.
+x_new, v_new = apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta)
+
+# Check results.
+expect(
+    node,
+    inputs=[r, t, x, g, v],
+    outputs=[x_new, v_new],
+    name="test_nesterov_momentum",
+    opset_imports=[
+        onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+    ],
+)
+```
+
+</details>
+
+
+### Mul
+There are 2 test cases, listed as following:
+<details>
+<summary>mul</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mul",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.float32)
+z = x * y  # expected output [4., 10., 18.]
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.int8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_int8")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.int16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_int16")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint8")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint16")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint32")
+
+x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint64")
+```
+
+</details>
+<details>
+<summary>mul_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Mul",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = x * y
+expect(node, inputs=[x, y], outputs=[z], name="test_mul_bcast")
+```
+
+</details>
+
+
+### Neg
+There are 1 test cases, listed as following:
+<details>
+<summary>neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Neg",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-4, 2]).astype(np.float32)
+y = np.negative(x)  # expected output [4., -2.],
+expect(node, inputs=[x], outputs=[y], name="test_neg_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.negative(x)
+expect(node, inputs=[x], outputs=[y], name="test_neg")
+```
+
+</details>
+
+
+### NegativeLogLikelihoodLoss
+There are 18 test cases, listed as following:
+<details>
+<summary>input_shape_is_NC</summary>
+
+```python
+reduction = "none"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C = 3, 5
+np.random.seed(0)
+input = np.random.rand(N, C).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N,)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NC",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1</summary>
+
+```python
+reduction = "mean"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, d1 = 3, 5, 2
+np.random.seed(0)
+input = np.random.rand(N, C, d1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(1)
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, d1 = 3, 5, 2
+np.random.seed(0)
+input = np.random.rand(N, C, d1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+target[0][0] = np.int64(1)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1_mean_weight_negative_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(-1)
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1 = 3, 5, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64)
+target[0][0] = -1
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1_mean_weight_negative_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1_weight</summary>
+
+```python
+reduction = "mean"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, d1 = 3, 5, 2
+np.random.seed(0)
+input = np.random.rand(N, C, d1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1_weight",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1_weight_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(1)
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, d1 = 3, 5, 2
+np.random.seed(0)
+input = np.random.rand(N, C, d1).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+target[0][0] = np.int64(1)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1_weight_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2</summary>
+
+```python
+reduction = "none"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2_no_weight_reduction_mean_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(1)
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+target[0][0][0] = np.int64(1)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_no_weight_reduction_mean_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2_reduction_mean</summary>
+
+```python
+reduction = "mean"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_reduction_mean",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2_reduction_sum</summary>
+
+```python
+reduction = "sum"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_reduction_sum",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2_with_weight</summary>
+
+```python
+reduction = "none"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_with_weight",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2_with_weight_reduction_mean</summary>
+
+```python
+reduction = "mean"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_with_weight_reduction_mean",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2_with_weight_reduction_sum</summary>
+
+```python
+reduction = "sum"
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_with_weight_reduction_sum",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2_with_weight_reduction_sum_ii</summary>
+
+```python
+reduction = "sum"
+ignore_index = np.int64(0)
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2 = 3, 5, 6, 6
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+target[0][0][0] = np.int64(0)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2_with_weight_reduction_sum_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3_none_no_weight_negative_ii</summary>
+
+```python
+reduction = "none"
+ignore_index = np.int64(-5)
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype(
+    np.int64
+)
+target[0][0][0][0] = -5
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2d3_none_no_weight_negative_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3_sum_weight_high_ii</summary>
+
+```python
+reduction = "sum"
+ignore_index = np.int64(10)
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C = 3, 5
+np.random.seed(0)
+input = np.random.rand(N, C).astype(np.float32)
+target = np.random.randint(0, high=C, size=(N)).astype(np.int64)
+target[0] = 10
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2d3_sum_weight_high_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_mean_weight</summary>
+
+```python
+reduction = "mean"
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target", "weight"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+target = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, weight=weight, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target, weight],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2d3d4d5_mean_weight",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_none_no_weight</summary>
+
+```python
+reduction = "none"
+
+node = onnx.helper.make_node(
+    "NegativeLogLikelihoodLoss",
+    inputs=["input", "target"],
+    outputs=["loss"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+input = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+target = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+
+negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+    input, target, reduction=reduction
+)
+
+expect(
+    node,
+    inputs=[input, target],
+    outputs=[negative_log_likelihood_loss],
+    name="test_nllloss_NCd1d2d3d4d5_none_no_weight",
+)
+```
+
+</details>
+
+
+### NonMaxSuppression
+There are 10 test cases, listed as following:
+<details>
+<summary>nonmaxsuppression_center_point_box_format</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+    center_point_box=1,
+)
+boxes = np.array(
+    [
+        [
+            [0.5, 0.5, 1.0, 1.0],
+            [0.5, 0.6, 1.0, 1.0],
+            [0.5, 0.4, 1.0, 1.0],
+            [0.5, 10.5, 1.0, 1.0],
+            [0.5, 10.6, 1.0, 1.0],
+            [0.5, 100.5, 1.0, 1.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_center_point_box_format",
+)
+```
+
+</details>
+<details>
+<summary>nonmaxsuppression_flipped_coordinates</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [1.0, 1.0, 0.0, 0.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, 0.9, 1.0, -0.1],
+            [0.0, 10.0, 1.0, 11.0],
+            [1.0, 10.1, 0.0, 11.1],
+            [1.0, 101.0, 0.0, 100.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_flipped_coordinates",
+)
+```
+
+</details>
+<details>
+<summary>nonmaxsuppression_identical_boxes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.0, 1.0, 1.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array(
+    [[[0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9]]]
+).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 0]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_identical_boxes",
+)
+```
+
+</details>
+<details>
+<summary>nonmaxsuppression_iou_threshold_boundary</summary>
+
+```python
+"""Test boundary condition where IoU exactly equals threshold.
+
+This test verifies that the comparison is strict (>), not inclusive (>=).
+When IoU exactly equals the threshold, boxes should be KEPT, not suppressed.
+This follows PyTorch's NMS implementation.
+"""
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+# Two boxes with 50% overlap in each dimension
+# box1=[0,0,1,1], box2=[0.5,0.5,1.5,1.5]
+# Intersection area = 0.5 * 0.5 = 0.25
+# Union area = 1.0 + 1.0 - 0.25 = 1.75
+# IoU = 0.25 / 1.75 (exact value computed below as float32)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],  # box 0
+            [0.5, 0.5, 1.5, 1.5],  # box 1 - overlaps box 0
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.8]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+# Compute the exact IoU value and use it as threshold
+# This ensures the threshold exactly equals the IoU
+exact_iou = np.float32(0.25 / 1.75)
+iou_threshold = np.array([exact_iou]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+# Both boxes should be selected because IoU == threshold (not > threshold)
+selected_indices = np.array([[0, 0, 0], [0, 0, 1]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_iou_threshold_boundary",
+)
+```
+
+</details>
+<details>
+<summary>nonmaxsuppression_limit_output_size</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([2]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_limit_output_size",
+)
+```
+
+</details>
+<details>
+<summary>nonmaxsuppression_single_box</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array([[[0.0, 0.0, 1.0, 1.0]]]).astype(np.float32)
+scores = np.array([[[0.9]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 0]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_single_box",
+)
+```
+
+</details>
+<details>
+<summary>nonmaxsuppression_suppress_by_IOU</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_suppress_by_IOU",
+)
+```
+
+</details>
+<details>
+<summary>nonmaxsuppression_suppress_by_IOU_and_scores</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+max_output_boxes_per_class = np.array([3]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.4]).astype(np.float32)
+selected_indices = np.array([[0, 0, 3], [0, 0, 0]]).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_suppress_by_IOU_and_scores",
+)
+```
+
+</details>
+<details>
+<summary>nonmaxsuppression_two_batches</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ],
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ],
+    ]
+).astype(np.float32)
+scores = np.array(
+    [[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]], [[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]
+).astype(np.float32)
+max_output_boxes_per_class = np.array([2]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array(
+    [[0, 0, 3], [0, 0, 0], [1, 0, 3], [1, 0, 0]]
+).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_two_batches",
+)
+```
+
+</details>
+<details>
+<summary>nonmaxsuppression_two_classes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonMaxSuppression",
+    inputs=[
+        "boxes",
+        "scores",
+        "max_output_boxes_per_class",
+        "iou_threshold",
+        "score_threshold",
+    ],
+    outputs=["selected_indices"],
+)
+boxes = np.array(
+    [
+        [
+            [0.0, 0.0, 1.0, 1.0],
+            [0.0, 0.1, 1.0, 1.1],
+            [0.0, -0.1, 1.0, 0.9],
+            [0.0, 10.0, 1.0, 11.0],
+            [0.0, 10.1, 1.0, 11.1],
+            [0.0, 100.0, 1.0, 101.0],
+        ]
+    ]
+).astype(np.float32)
+scores = np.array(
+    [[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3], [0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]
+).astype(np.float32)
+max_output_boxes_per_class = np.array([2]).astype(np.int64)
+iou_threshold = np.array([0.5]).astype(np.float32)
+score_threshold = np.array([0.0]).astype(np.float32)
+selected_indices = np.array(
+    [[0, 0, 3], [0, 0, 0], [0, 1, 3], [0, 1, 0]]
+).astype(np.int64)
+
+expect(
+    node,
+    inputs=[
+        boxes,
+        scores,
+        max_output_boxes_per_class,
+        iou_threshold,
+        score_threshold,
+    ],
+    outputs=[selected_indices],
+    name="test_nonmaxsuppression_two_classes",
+)
+```
+
+</details>
+
+
+### NonZero
+There are 1 test cases, listed as following:
+<details>
+<summary>nonzero</summary>
+
+```python
+node = onnx.helper.make_node(
+    "NonZero",
+    inputs=["condition"],
+    outputs=["result"],
+)
+
+condition = np.array([[1, 0], [1, 1]], dtype=bool)
+result = np.array(
+    np.nonzero(condition), dtype=np.int64
+)  # expected output [[0, 1, 1], [0, 0, 1]]
+expect(node, inputs=[condition], outputs=[result], name="test_nonzero_example")
+```
+
+</details>
+
+
+### Not
+There are 1 test cases, listed as following:
+<details>
+<summary>not</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Not",
+    inputs=["x"],
+    outputs=["not"],
+)
+
+# 2d
+x = (np.random.randn(3, 4) > 0).astype(bool)
+expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_2d")
+
+# 3d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_3d")
+
+# 4d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_4d")
+```
+
+</details>
+
+
+### OneHot
+There are 5 test cases, listed as following:
+<details>
+<summary>with_axis</summary>
+
+```python
+axisValue = 1
+on_value = 3
+off_value = 1
+output_type = np.float32
+node = onnx.helper.make_node(
+    "OneHot",
+    inputs=["indices", "depth", "values"],
+    outputs=["y"],
+    axis=axisValue,
+)
+indices = np.array([[1, 9], [2, 4]], dtype=np.float32)
+depth = np.float32(10)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_with_axis",
+)
+```
+
+</details>
+<details>
+<summary>with_negative_axis</summary>
+
+```python
+axisValue = -2
+on_value = 3
+off_value = 1
+output_type = np.float32
+node = onnx.helper.make_node(
+    "OneHot",
+    inputs=["indices", "depth", "values"],
+    outputs=["y"],
+    axis=axisValue,
+)
+indices = np.array([[1, 9], [2, 4]], dtype=np.float32)
+depth = np.float32(10)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_with_negative_axis",
+)
+```
+
+</details>
+<details>
+<summary>with_negative_indices</summary>
+
+```python
+axisValue = 1
+on_value = 3
+off_value = 1
+output_type = np.float32
+node = onnx.helper.make_node(
+    "OneHot",
+    inputs=["indices", "depth", "values"],
+    outputs=["y"],
+    axis=axisValue,
+)
+indices = np.array([0, -7, -8], dtype=np.int64)
+
+# print(y)
+# [[3. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
+#  [1. 1. 1. 3. 1. 1. 1. 1. 1. 1.]
+#  [1. 1. 3. 1. 1. 1. 1. 1. 1. 1.]]
+
+depth = np.float32(10)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_negative_indices",
+)
+```
+
+</details>
+<details>
+<summary>with_out_of_range_indices</summary>
+
+```python
+axisValue = 1
+on_value = 3
+off_value = 1
+output_type = np.float32
+node = onnx.helper.make_node(
+    "OneHot",
+    inputs=["indices", "depth", "values"],
+    outputs=["y"],
+    axis=axisValue,
+)
+# Indices outside [-depth, depth-1] map to an all-off_value row.
+indices = np.array([5, -6, -1], dtype=np.int64)
+
+# print(y)
+# [[1. 1. 1. 1. 1.]
+#  [1. 1. 1. 1. 1.]
+#  [1. 1. 1. 1. 3.]]
+
+depth = np.float32(5)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_out_of_range_indices",
+)
+```
+
+</details>
+<details>
+<summary>without_axis</summary>
+
+```python
+on_value = 5
+off_value = 2
+output_type = np.int32
+node = onnx.helper.make_node(
+    "OneHot", inputs=["indices", "depth", "values"], outputs=["y"]
+)
+indices = np.array([0, 7, 8], dtype=np.int64)
+depth = np.float32(12)
+values = np.array([off_value, on_value], dtype=output_type)
+y = one_hot(indices, depth, dtype=output_type)
+y = y * (on_value - off_value) + off_value
+expect(
+    node,
+    inputs=[indices, depth, values],
+    outputs=[y],
+    name="test_onehot_without_axis",
+)
+```
+
+</details>
+
+
+### OptionalHasElement
+There are 4 test cases, listed as following:
+<details>
+<summary>empty</summary>
+
+```python
+optional = None
+
+tensor_type_proto = onnx.helper.make_tensor_type_proto(
+    elem_type=onnx.TensorProto.INT32, shape=[]
+)
+optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)
+
+# OptionalHasElement takes a tensor or optional as input
+for input_type_proto in [tensor_type_proto, optional_type_proto]:
+    input_name_options = {
+        "empty": "optional_input",
+        "empty_no_input_name": "",
+        "empty_no_input": None,
+    }
+    for test_name_surfix, input_name in input_name_options.items():
+        if input_type_proto == tensor_type_proto and input_name:
+            # the input tensor cannot be empty if input name is provided.
+            continue
+        node = onnx.helper.make_node(
+            "OptionalHasElement",
+            inputs=[] if input_name is None else [input_name],
+            outputs=["output"],
+        )
+        output = optional_has_element_reference_implementation(optional)
+        test_name = (
+            "test_optional_has_element_"
+            + test_name_surfix
+            + (
+                "_optional_input"
+                if input_type_proto == optional_type_proto
+                else "_tensor_input"
+            )
+        )
+        expect(
+            node,
+            inputs=[optional] if input_name else [],
+            outputs=[output],
+            input_type_protos=[input_type_proto] if input_name else [],
+            name=test_name,
+        )
+```
+
+</details>
+<details>
+<summary>get_element_sequence</summary>
+
+```python
+optional = [np.array([1, 2, 3, 4]).astype(np.int32)]
+tensor_type_proto = onnx.helper.make_tensor_type_proto(
+    elem_type=onnx.TensorProto.INT32,
+    shape=[
+        4,
+    ],
+)
+seq_type_proto = onnx.helper.make_sequence_type_proto(tensor_type_proto)
+optional_type_proto = onnx.helper.make_optional_type_proto(seq_type_proto)
+
+node = onnx.helper.make_node(
+    "OptionalGetElement", inputs=["optional_input"], outputs=["output"]
+)
+output = optional_get_element_reference_implementation(optional)
+expect(
+    node,
+    inputs=[optional],
+    outputs=[output],
+    input_type_protos=[optional_type_proto],
+    name="test_optional_get_element_optional_sequence",
+)
+expect(
+    node,
+    inputs=[optional],
+    outputs=[output],
+    input_type_protos=[seq_type_proto],
+    name="test_optional_get_element_sequence",
+)
+```
+
+</details>
+<details>
+<summary>get_element_tensor</summary>
+
+```python
+optional = np.array([1, 2, 3, 4]).astype(np.float32)
+tensor_type_proto = onnx.helper.make_tensor_type_proto(
+    elem_type=onnx.TensorProto.FLOAT,
+    shape=[
+        4,
+    ],
+)
+optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)
+
+node = onnx.helper.make_node(
+    "OptionalGetElement", inputs=["optional_input"], outputs=["output"]
+)
+output = optional_get_element_reference_implementation(optional)
+expect(
+    node,
+    inputs=[optional],
+    outputs=[output],
+    input_type_protos=[optional_type_proto],
+    name="test_optional_get_element_optional_tensor",
+)
+expect(
+    node,
+    inputs=[optional],
+    outputs=[output],
+    input_type_protos=[tensor_type_proto],
+    name="test_optional_get_element_tensor",
+)
+```
+
+</details>
+<details>
+<summary>optionalhaselement</summary>
+
+```python
+optional = np.array([1, 2, 3, 4]).astype(np.float32)
+tensor_type_proto = onnx.helper.make_tensor_type_proto(
+    elem_type=onnx.TensorProto.FLOAT,
+    shape=[
+        4,
+    ],
+)
+optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)
+
+# OptionalHasElement takes a tensor or optional as input
+for input_type_protos in [tensor_type_proto, optional_type_proto]:
+    node = onnx.helper.make_node(
+        "OptionalHasElement", inputs=["optional_input"], outputs=["output"]
+    )
+    output = optional_has_element_reference_implementation(optional)
+    test_name = "test_optional_has_element_" + (
+        "optional_input"
+        if input_type_protos == optional_type_proto
+        else "tensor_input"
+    )
+    expect(
+        node,
+        inputs=[optional],
+        outputs=[output],
+        input_type_protos=[optional_type_proto],
+        name=test_name,
+    )
+```
+
+</details>
+
+
+### Or
+There are 2 test cases, listed as following:
+<details>
+<summary>or</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Or",
+    inputs=["x", "y"],
+    outputs=["or"],
+)
+
+# 2d
+x = (np.random.randn(3, 4) > 0).astype(bool)
+y = (np.random.randn(3, 4) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or2d")
+
+# 3d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or3d")
+
+# 4d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or4d")
+```
+
+</details>
+<details>
+<summary>or_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Or",
+    inputs=["x", "y"],
+    outputs=["or"],
+)
+
+# 3d vs 1d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(5) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast3v1d")
+
+# 3d vs 2d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(4, 5) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast3v2d")
+
+# 4d vs 2d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(5, 6) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v2d")
+
+# 4d vs 3d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(4, 5, 6) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v3d")
+
+# 4d vs 4d
+x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool)
+y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool)
+z = np.logical_or(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v4d")
+```
+
+</details>
+
+
+### PRelu
+There are 2 test cases, listed as following:
+<details>
+<summary>prelu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "PRelu",
+    inputs=["x", "slope"],
+    outputs=["y"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+slope = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * slope
+
+expect(node, inputs=[x, slope], outputs=[y], name="test_prelu_example")
+```
+
+</details>
+<details>
+<summary>prelu_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "PRelu",
+    inputs=["x", "slope"],
+    outputs=["y"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+slope = np.random.randn(5).astype(np.float32)
+y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * slope
+
+expect(node, inputs=[x, slope], outputs=[y], name="test_prelu_broadcast")
+```
+
+</details>
+
+
+### Pad
+There are 4 test cases, listed as following:
+<details>
+<summary>constant_pad</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pad", inputs=["x", "pads", "value"], outputs=["y"], mode="constant"
+)
+x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+pads = np.array([0, 0, 1, 3, 0, 0, 2, 4]).astype(
+    np.int64
+)  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+value = np.float32(1.2)
+y = pad_impl(x, pads, "constant", 1.2)
+
+expect(node, inputs=[x, pads, value], outputs=[y], name="test_constant_pad")
+```
+
+</details>
+<details>
+<summary>constant_pad_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pad", inputs=["x", "pads", "value", "axes"], outputs=["y"], mode="constant"
+)
+x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+pads = np.array([0, 3, 0, 4]).astype(
+    np.int64
+)  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+value = np.float32(1.2)
+axes = np.array([1, 3], dtype=np.int64)
+y = pad_impl(
+    x,
+    pads,
+    "constant",
+    1.2,
+    [1, 3],
+)
+
+expect(
+    node,
+    inputs=[x, pads, value, axes],
+    outputs=[y],
+    name="test_constant_pad_axes",
+)
+```
+
+</details>
+<details>
+<summary>constant_pad_negative_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pad", inputs=["x", "pads", "value", "axes"], outputs=["y"], mode="constant"
+)
+x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+pads = np.array([0, 3, 0, 4]).astype(
+    np.int64
+)  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+value = np.float32(1.2)
+axes = np.array([-3, -1], dtype=np.int64)
+y = pad_impl(
+    x,
+    pads,
+    "constant",
+    1.2,
+    [-3, -1],
+)
+
+expect(
+    node,
+    inputs=[x, pads, value, axes],
+    outputs=[y],
+    name="test_constant_pad_negative_axes",
+)
+```
+
+</details>
+<details>
+<summary>reflection_edge_and_wrap_pad</summary>
+
+```python
+for mode in ("edge", "reflect", "wrap"):
+    node = onnx.helper.make_node(
+        "Pad", inputs=["x", "pads"], outputs=["y"], mode=mode
+    )
+    x = np.random.randn(1, 3, 4, 5).astype(np.int32)
+    pads = np.array([0, 0, 1, 1, 0, 0, 1, 1]).astype(
+        np.int64
+    )  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+    y = pad_impl(x, pads, mode)
+
+    expect(node, inputs=[x, pads], outputs=[y], name=f"test_{mode}_pad")
+```
+
+</details>
+
+
+### Pow
+There are 3 test cases, listed as following:
+<details>
+<summary>pow</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pow",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.float32)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_example")
+
+x = np.arange(60).reshape(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = pow(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_pow")
+```
+
+</details>
+<details>
+<summary>pow_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pow",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array(2).astype(np.float32)
+z = pow(x, y)  # expected output [1., 4., 9.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_bcast_scalar")
+
+node = onnx.helper.make_node(
+    "Pow",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+x = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
+y = np.array([1, 2, 3]).astype(np.float32)
+# expected output [[1, 4, 27], [4, 25, 216]]
+z = pow(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_bcast_array")
+```
+
+</details>
+<details>
+<summary>types</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Pow",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.int64)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_int64")
+
+x = np.array([1, 2, 3]).astype(np.int64)
+y = np.array([4, 5, 6]).astype(np.float32)
+z = pow(x, y)  # expected output [1, 32, 729]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int64_float32")
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.int32)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_int32")
+
+x = np.array([1, 2, 3]).astype(np.int32)
+y = np.array([4, 5, 6]).astype(np.float32)
+z = pow(x, y)  # expected output [1, 32, 729]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int32_float32")
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.uint64)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_uint64")
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([4, 5, 6]).astype(np.uint32)
+z = pow(x, y)  # expected output [1., 32., 729.]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_uint32")
+
+x = np.array([1, 2, 3]).astype(np.int64)
+y = np.array([4, 5, 6]).astype(np.int64)
+z = pow(x, y)  # expected output [1, 32, 729]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int64_int64")
+
+x = np.array([1, 2, 3]).astype(np.int32)
+y = np.array([4, 5, 6]).astype(np.int32)
+z = pow(x, y)  # expected output [1, 32, 729]
+expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int32_int32")
+```
+
+</details>
+
+
+### QLinearConv
+There are 1 test cases, listed as following:
+<details>
+<summary>qlinearconv</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QLinearConv",
+    inputs=[
+        "x",
+        "x_scale",
+        "x_zero_point",
+        "w",
+        "w_scale",
+        "w_zero_point",
+        "y_scale",
+        "y_zero_point",
+    ],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        [255, 174, 162, 25, 203, 168, 58],
+        [15, 59, 237, 95, 129, 0, 64],
+        [56, 242, 153, 221, 168, 12, 166],
+        [232, 178, 186, 195, 237, 162, 237],
+        [188, 39, 124, 77, 80, 102, 43],
+        [127, 230, 21, 83, 41, 40, 134],
+        [255, 154, 92, 141, 42, 148, 247],
+    ],
+    dtype=np.uint8,
+).reshape((1, 1, 7, 7))
+
+x_scale = np.float32(0.00369204697)
+x_zero_point = np.uint8(132)
+
+w = np.array([0], dtype=np.uint8).reshape((1, 1, 1, 1))
+
+w_scale = np.array([0.00172794575], dtype=np.float32)
+w_zero_point = np.array([255], dtype=np.uint8)
+
+y_scale = np.float32(0.00162681262)
+y_zero_point = np.uint8(123)
+
+output = np.array(
+    [
+        [0, 81, 93, 230, 52, 87, 197],
+        [240, 196, 18, 160, 126, 255, 191],
+        [199, 13, 102, 34, 87, 243, 89],
+        [23, 77, 69, 60, 18, 93, 18],
+        [67, 216, 131, 178, 175, 153, 212],
+        [128, 25, 234, 172, 214, 215, 121],
+        [0, 101, 163, 114, 213, 107, 8],
+    ],
+    dtype=np.uint8,
+).reshape((1, 1, 7, 7))
+
+expect(
+    node,
+    inputs=[
+        x,
+        x_scale,
+        x_zero_point,
+        w,
+        w_scale,
+        w_zero_point,
+        y_scale,
+        y_zero_point,
+    ],
+    outputs=[output],
+    name="test_qlinearconv",
+)
+```
+
+</details>
+
+
+### QLinearMatMul
+There are 1 test cases, listed as following:
+<details>
+<summary>int</summary>
+
+```python
+for quant_type_name in ["uint8", "int8"]:
+    quant_type = getattr(np, quant_type_name)
+    for dtype_name in ["float32", "float16"]:
+        dtype = getattr(np, dtype_name)
+        node = onnx.helper.make_node(
+            "QLinearMatMul",
+            inputs=[
+                "a",
+                "a_scale",
+                "a_zero_point",
+                "b",
+                "b_scale",
+                "b_zero_point",
+                "y_scale",
+                "y_zero_point",
+            ],
+            outputs=["y"],
+        )
+
+        # 2D
+        a = np.array([[208, 236, 0, 238], [3, 214, 255, 29]])
+        if quant_type == np.int8:
+            a -= 127
+        a = a.astype(quant_type)
+
+        a_scale = np.array([0.0066], dtype=dtype)
+        a_zero_point = np.array(
+            [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type
+        )
+
+        b = np.array(
+            [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]]
+        )
+        if quant_type == np.int8:
+            b -= 127
+        b = b.astype(quant_type)
+
+        b_scale = np.array([0.00705], dtype=dtype)
+        b_zero_point = np.array(
+            [114 - 127] if quant_type == np.int8 else [114], dtype=quant_type
+        )
+
+        y_scale = np.array([0.0107], dtype=dtype)
+        y_zero_point = np.array(
+            [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type
+        )
+
+        if quant_type == np.int8:
+            output = np.array([[41, -12, -9], [1, -75, -128]])
+        else:
+            output = np.array([[168, 115, 255], [1, 66, 151]])
+        output = output.astype(quant_type)
+
+        expect(
+            node,
+            inputs=[
+                a,
+                a_scale,
+                a_zero_point,
+                b,
+                b_scale,
+                b_zero_point,
+                y_scale,
+                y_zero_point,
+            ],
+            outputs=[output],
+            name=f"test_qlinearmatmul_2D_{quant_type_name}_{dtype_name}",
+        )
+
+        # 3D
+        a = np.array(
+            [
+                [[208, 236, 0, 238], [3, 214, 255, 29]],
+                [[208, 236, 0, 238], [3, 214, 255, 29]],
+            ],
+        )
+        if quant_type == np.int8:
+            a -= 127
+        a = a.astype(quant_type)
+
+        a_scale = np.array([0.0066], dtype=dtype)
+        a_zero_point = np.array(
+            [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type
+        )
+
+        b = np.array(
+            [
+                [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
+                [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
+            ],
+        )
+        if quant_type == np.int8:
+            b -= 127
+        b = b.astype(quant_type)
+
+        b_scale = np.array([0.00705], dtype=dtype)
+        b_zero_point = np.array([114], dtype=quant_type)
+
+        y_scale = np.array([0.0107], dtype=dtype)
+        y_zero_point = np.array(
+            [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type
+        )
+
+        if quant_type == np.int8:
+            output = np.array(
+                [
+                    [[-86, -128, -128], [115, 39, -121]],
+                    [[-86, -128, -128], [115, 39, -121]],
+                ]
+            )
+        else:
+            output = np.array(
+                [
+                    [[168, 115, 255], [1, 66, 151]],
+                    [[168, 115, 255], [1, 66, 151]],
+                ]
+            )
+        output = output.astype(quant_type)
+
+        expect(
+            node,
+            inputs=[
+                a,
+                a_scale,
+                a_zero_point,
+                b,
+                b_scale,
+                b_zero_point,
+                y_scale,
+                y_zero_point,
+            ],
+            outputs=[output],
+            name=f"test_qlinearmatmul_3D_{quant_type_name}_{dtype_name}",
+        )
+```
+
+</details>
+
+
+### QuantizeLinear
+There are 13 test cases, listed as following:
+<details>
+<summary>axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        [
+            [[-162, 10], [-100, 232], [-20, -50]],
+            [[-76, 0], [0, 252], [32, -44]],
+            [[245, -485], [-960, -270], [-375, -470]],
+        ],
+    ],
+    dtype=np.float32,
+)
+y_scale = np.array([2, 4, 5], dtype=np.float32)
+y_zero_point = np.array([84, 24, 196], dtype=np.uint8)
+y = (x / y_scale.reshape(1, 3, 1, 1) + y_zero_point.reshape(1, 3, 1, 1)).astype(
+    np.uint8
+)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_axis",
+)
+```
+
+</details>
+<details>
+<summary>blocked_asymmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=1,
+    block_size=2,
+)
+
+x = np.array(
+    [
+        [6.0, 12.0, 50.0, 5.0],
+        [1.0, 8.0, 4.0, 5.0],
+        [0.0, 20.0, 10.0, 4.0],
+    ],
+    dtype=np.float32,
+)
+y_scale = np.array(
+    [
+        [1.5, 2.5],
+        [3.0, 4.9],
+        [5.1, 6.9],
+    ],
+    dtype=np.float32,
+)
+y_zero_point = np.array(
+    [
+        [0, 1],
+        [1, 0],
+        [2, 3],
+    ],
+    dtype=np.uint8,
+)
+# x.shape = (3, 4)
+# y_scale.shape = (3, 2)
+assert y_scale.shape == y_zero_point.shape
+block_axis = 1
+# The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2)
+assert all(
+    x.shape[i] == y_scale.shape[i]
+    for i in range(len(x.shape))
+    if i != block_axis
+)
+assert x.shape[block_axis] % y_scale.shape[block_axis] == 0
+repeats = x.shape[block_axis] // y_scale.shape[block_axis]
+
+# Create element-wise scale and zero point
+y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis)
+y_zero_point_elementwise = np.repeat(
+    y_zero_point, repeats=repeats, axis=block_axis
+)
+
+y = np.rint(x / y_scale_elementwise + y_zero_point_elementwise).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_blocked_asymmetric",
+)
+```
+
+</details>
+<details>
+<summary>blocked_symmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale"],
+    outputs=["y"],
+    axis=1,
+    block_size=2,
+    output_dtype=TensorProto.INT16,
+)
+
+x = np.array(
+    [
+        [6.0, -8, -10, 5.0],
+        [1.0, 8.0, 4.0, 5.0],
+        [0.0, 20.0, 10.0, 4.0],
+    ],
+    dtype=np.float32,
+)
+
+y_scale = np.array(
+    [
+        [1.5, 2.5],
+        [3.0, 4.9],
+        [5.1, 6.9],
+    ],
+    dtype=np.float32,
+)
+
+# x.shape = (3, 4)
+# y_scale.shape = (3, 2)
+
+block_axis = 1
+# The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2)
+assert all(
+    x.shape[i] == y_scale.shape[i]
+    for i in range(len(x.shape))
+    if i != block_axis
+)
+assert x.shape[block_axis] % y_scale.shape[block_axis] == 0
+repeats = x.shape[block_axis] // y_scale.shape[block_axis]
+
+# Create element-wise scale and zero point
+y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis)
+
+y_val = np.clip(
+    np.rint(x / y_scale_elementwise), a_min=-32768, a_max=32767
+).astype(np.int16)
+y = make_tensor(
+    "y",
+    TensorProto.INT16,
+    x.shape,
+    y_val,
+)
+expect(
+    node,
+    inputs=[x, y_scale],
+    outputs=[y],
+    name="test_quantizelinear_blocked_symmetric",
+)
+```
+
+</details>
+<details>
+<summary>e4m3fn</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32)
+y_scale = np.float32(2)
+y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E4M3FN, [1], [0])
+y = make_tensor("y", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, 96])
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_e4m3fn",
+)
+```
+
+</details>
+<details>
+<summary>e5m2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32)
+y_scale = np.float32(2)
+y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E5M2, [1], [0.0])
+y = make_tensor("y", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, 96])
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_e5m2",
+)
+```
+
+</details>
+<details>
+<summary>float4e2m1</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-30, -20, 6, 9],
+        [-0.0, -2.5, -4.8, -8.6],
+    ]
+).astype(np.float32)
+
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point",
+    TensorProto.FLOAT4E2M1,
+    y_scale.shape,
+    np.zeros_like(y_scale),
+)
+y = make_tensor(
+    "y",
+    TensorProto.FLOAT4E2M1,
+    x.shape,
+    [0, 1, 2, 4, -6, -6, 2, 3, 0, -0.5, -1, -2],
+)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_float4e2m1",
+)
+```
+
+</details>
+<details>
+<summary>int16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        0.0,
+        -514.0,
+        3.0,
+        -3.0,
+        2.9,
+        -2.9,
+        3.1,
+        -3.1,
+        65022.0,
+        -66046.0,
+        65023.0,
+        -66047.0,
+        65024.0,
+        -66048.0,
+        70000.0,
+        -70000.0,
+    ]
+).astype(np.float32)
+y_scale = np.float32(2.0)
+y_zero_point = np.int16(256)
+y = np.array(
+    [
+        256,
+        -1,
+        258,
+        254,
+        257,
+        255,
+        258,
+        254,
+        32767,
+        -32767,
+        32767,
+        -32768,
+        32767,
+        -32768,
+        32767,
+        -32768,
+    ]
+).astype(np.int16)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_int16",
+)
+```
+
+</details>
+<details>
+<summary>int2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-4.0, -3.0, 1.0, 2.0],
+        [-0.0, -2.5, -4.8, -8.6],
+    ],
+    dtype=np.float32,
+)
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point", TensorProto.INT2, y_scale.shape, np.zeros_like(y_scale)
+)
+y = make_tensor(
+    "y", TensorProto.INT2, x.shape, [0, 1, 1, 1, -1, -1, 0, 1, 0, -1, -1, -2]
+)
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_int2",
+)
+```
+
+</details>
+<details>
+<summary>int4</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-30, -20, 6, 9],
+        [12, 15, 16, 40],
+    ]
+).astype(np.float32)
+
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point", TensorProto.INT4, y_scale.shape, np.ones_like(y_scale)
+)
+y = make_tensor(
+    "y", TensorProto.INT4, x.shape, [1, 2, 3, 5, -8, -6, 3, 4, 4, 5, 5, 7]
+)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_int4",
+)
+```
+
+</details>
+<details>
+<summary>quantizelinear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array([0, 2, 3, 1000, -254, -1000]).astype(np.float32)
+y_scale = np.float32(2)
+y_zero_point = np.uint8(128)
+y = np.array([128, 129, 130, 255, 1, 0]).astype(np.uint8)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear",
+)
+```
+
+</details>
+<details>
+<summary>uint16</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        0.0,
+        -128.0,
+        3.0,
+        -3.0,
+        2.9,
+        -2.9,
+        3.1,
+        -3.1,
+        65536.0,
+        -65534.0,
+        70000.0,
+        -70000.0,
+    ]
+).astype(np.float32)
+y_scale = np.float32(2.0)
+y_zero_point = np.uint16(32767)
+y = np.array(
+    [
+        32767,
+        32703,
+        32769,
+        32765,
+        32768,
+        32766,
+        32769,
+        32765,
+        65535,
+        0,
+        65535,
+        0,
+    ]
+).astype(np.uint16)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_uint16",
+)
+```
+
+</details>
+<details>
+<summary>uint2</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-2.0, -1.0, 1.0, 3.0],
+        [4.0, 5.0, 6.0, 7.0],
+    ],
+    dtype=np.float32,
+)
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point", TensorProto.UINT2, y_scale.shape, np.zeros_like(y_scale)
+)
+y = make_tensor(
+    "y", TensorProto.UINT2, x.shape, [0, 1, 2, 3, 0, 0, 0, 1, 1, 1, 2, 2]
+)
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_uint2",
+)
+```
+
+</details>
+<details>
+<summary>uint4</summary>
+
+```python
+node = onnx.helper.make_node(
+    "QuantizeLinear",
+    inputs=["x", "y_scale", "y_zero_point"],
+    outputs=["y"],
+    axis=0,
+)
+
+x = np.array(
+    [
+        [0.0, 2.5, 4.8, 8.6],
+        [-30, -20, 6, 9],
+        [12, 15, 16, 40],
+    ]
+).astype(np.float32)
+
+y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+y_zero_point = make_tensor(
+    "y_zero_point", TensorProto.UINT4, y_scale.shape, np.ones_like(y_scale)
+)
+y = make_tensor(
+    "y", TensorProto.UINT4, x.shape, [1, 2, 3, 5, 0, 0, 3, 4, 4, 5, 5, 11]
+)
+
+expect(
+    node,
+    inputs=[x, y_scale, y_zero_point],
+    outputs=[y],
+    name="test_quantizelinear_uint4",
+)
+```
+
+</details>
+
+
+### RMSNormalization
+There are 4 test cases, listed as following:
+<details>
+<summary>d</summary>
+
+```python
+X = np.random.randn(3, 4).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    Y = _rms_normalization(X, W, axis=axis)
+
+    node = onnx.helper.make_node(
+        "RMSNormalization",
+        inputs=["X", "W"],
+        outputs=["Y"],
+        axis=axis,
+    )
+
+    if axis < 0:
+        name = f"test_rms_normalization_2d_axis_negative_{-axis}"
+    else:
+        name = f"test_rms_normalization_2d_axis{axis}"
+
+    expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+<details>
+<summary>d_epsilon</summary>
+
+```python
+epsilon = 1e-1
+X = np.random.randn(2, 3, 5).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    Y = _rms_normalization(X, W, axis=axis, epsilon=epsilon)
+    node = onnx.helper.make_node(
+        "RMSNormalization",
+        inputs=["X", "W"],
+        outputs=["Y"],
+        axis=axis,
+        epsilon=epsilon,
+    )
+
+    if axis < 0:
+        name = f"test_rms_normalization_3d_axis_negative_{-axis}_epsilon"
+    else:
+        name = f"test_rms_normalization_3d_axis{axis}_epsilon"
+
+    expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+<details>
+<summary>default_axis</summary>
+
+```python
+X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+# Default axis in RMSNormalization is -1.
+normalized_shape = calculate_normalized_shape(X.shape, -1)
+W = np.random.randn(*normalized_shape).astype(np.float32)
+# Axis is default to -1 in the reference implementation.
+Y = _rms_normalization(X, W)
+
+# Not specifying axis attribute means -1.
+node = onnx.helper.make_node(
+    "RMSNormalization",
+    inputs=["X", "W"],
+    outputs=["Y"],
+)
+
+expect(
+    node,
+    inputs=[X, W],
+    outputs=[Y],
+    name="test_rms_normalization_default_axis",
+)
+```
+
+</details>
+<details>
+<summary>rmsnormalization</summary>
+
+```python
+X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+def case(axis: int) -> None:
+    normalized_shape = calculate_normalized_shape(X.shape, axis)
+    W = np.random.randn(*normalized_shape).astype(np.float32)
+    Y = _rms_normalization(X, W, axis=axis)
+
+    node = onnx.helper.make_node(
+        "RMSNormalization",
+        inputs=["X", "W"],
+        outputs=["Y"],
+        axis=axis,
+    )
+
+    if axis < 0:
+        name = f"test_rms_normalization_4d_axis_negative_{-axis}"
+    else:
+        name = f"test_rms_normalization_4d_axis{axis}"
+
+    expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+for i in range(len(X.shape)):
+    case(i)
+    case(i - len(X.shape))
+```
+
+</details>
+
+
+### RNN
+There are 4 test cases, listed as following:
+<details>
+<summary>batchwise</summary>
+
+```python
+input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 4
+weight_scale = 0.5
+layout = 1
+
+node = onnx.helper.make_node(
+    "RNN",
+    inputs=["X", "W", "R"],
+    outputs=["Y", "Y_h"],
+    hidden_size=hidden_size,
+    layout=layout,
+)
+
+W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32)
+R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32)
+
+rnn = RNNHelper(X=input, W=W, R=R, layout=layout)
+Y, Y_h = rnn.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y.astype(np.float32), Y_h.astype(np.float32)],
+    name="test_simple_rnn_batchwise",
+)
+```
+
+</details>
+<details>
+<summary>defaults</summary>
+
+```python
+input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32)
+
+input_size = 2
+hidden_size = 4
+weight_scale = 0.1
+
+node = onnx.helper.make_node(
+    "RNN", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size
+)
+
+W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32)
+R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32)
+
+rnn = RNNHelper(X=input, W=W, R=R)
+_, Y_h = rnn.step()
+expect(
+    node,
+    inputs=[input, W, R],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_simple_rnn_defaults",
+)
+```
+
+</details>
+<details>
+<summary>initial_bias</summary>
+
+```python
+input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype(
+    np.float32
+)
+
+input_size = 3
+hidden_size = 5
+custom_bias = 0.1
+weight_scale = 0.1
+
+node = onnx.helper.make_node(
+    "RNN",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32)
+R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32)
+
+# Adding custom bias
+W_B = custom_bias * np.ones((1, hidden_size)).astype(np.float32)
+R_B = np.zeros((1, hidden_size)).astype(np.float32)
+B = np.concatenate((W_B, R_B), axis=1)
+
+rnn = RNNHelper(X=input, W=W, R=R, B=B)
+_, Y_h = rnn.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_simple_rnn_with_initial_bias",
+)
+```
+
+</details>
+<details>
+<summary>seq_length</summary>
+
+```python
+input = np.array(
+    [
+        [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
+        [[10.0, 11.0, 12.0], [13.0, 14.0, 15.0], [16.0, 17.0, 18.0]],
+    ]
+).astype(np.float32)
+
+input_size = 3
+hidden_size = 5
+
+node = onnx.helper.make_node(
+    "RNN",
+    inputs=["X", "W", "R", "B"],
+    outputs=["", "Y_h"],
+    hidden_size=hidden_size,
+)
+
+W = np.random.randn(1, hidden_size, input_size).astype(np.float32)
+R = np.random.randn(1, hidden_size, hidden_size).astype(np.float32)
+
+# Adding custom bias
+W_B = np.random.randn(1, hidden_size).astype(np.float32)
+R_B = np.random.randn(1, hidden_size).astype(np.float32)
+B = np.concatenate((W_B, R_B), axis=1)
+
+rnn = RNNHelper(X=input, W=W, R=R, B=B)
+_, Y_h = rnn.step()
+expect(
+    node,
+    inputs=[input, W, R, B],
+    outputs=[Y_h.astype(np.float32)],
+    name="test_rnn_seq_length",
+)
+```
+
+</details>
+
+
+### Range
+There are 4 test cases, listed as following:
+<details>
+<summary>range_bfloat16_type_positive_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Range",
+    inputs=["start", "limit", "delta"],
+    outputs=["output"],
+)
+
+start = np.array(1.0, dtype=ml_dtypes.bfloat16)
+limit = np.array(5.0, dtype=ml_dtypes.bfloat16)
+delta = np.array(2.0, dtype=ml_dtypes.bfloat16)
+
+output = np.arange(1.0, 5.0, 2.0, dtype=np.float32).astype(
+    ml_dtypes.bfloat16
+)  # expected output [1.0, 3.0] as bfloat16
+
+expect(
+    node,
+    inputs=[start, limit, delta],
+    outputs=[output],
+    name="test_range_bfloat16_type_positive_delta",
+)
+```
+
+</details>
+<details>
+<summary>range_float16_type_positive_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Range",
+    inputs=["start", "limit", "delta"],
+    outputs=["output"],
+)
+
+start = np.float16(1)
+limit = np.float16(5)
+delta = np.float16(2)
+
+output = np.arange(
+    start, limit, delta, dtype=np.float16
+)  # expected output [1.0, 3.0]
+expect(
+    node,
+    inputs=[start, limit, delta],
+    outputs=[output],
+    name="test_range_float16_type_positive_delta",
+)
+```
+
+</details>
+<details>
+<summary>range_float_type_positive_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Range",
+    inputs=["start", "limit", "delta"],
+    outputs=["output"],
+)
+
+start = np.float32(1)
+limit = np.float32(5)
+delta = np.float32(2)
+
+output = np.arange(
+    start, limit, delta, dtype=np.float32
+)  # expected output [1.0, 3.0]
+expect(
+    node,
+    inputs=[start, limit, delta],
+    outputs=[output],
+    name="test_range_float_type_positive_delta",
+)
+```
+
+</details>
+<details>
+<summary>range_int32_type_negative_delta</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Range",
+    inputs=["start", "limit", "delta"],
+    outputs=["output"],
+)
+
+start = np.int32(10)
+limit = np.int32(6)
+delta = np.int32(-3)
+
+output = np.arange(
+    start, limit, delta, dtype=np.int32
+)  # expected output [10, 7]
+expect(
+    node,
+    inputs=[start, limit, delta],
+    outputs=[output],
+    name="test_range_int32_type_negative_delta",
+)
+```
+
+</details>
+
+
+### Reciprocal
+There are 1 test cases, listed as following:
+<details>
+<summary>reciprocal</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Reciprocal",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-4, 2]).astype(np.float32)
+y = np.reciprocal(x)  # expected output [-0.25, 0.5],
+expect(node, inputs=[x], outputs=[y], name="test_reciprocal_example")
+
+x = np.random.rand(3, 4, 5).astype(np.float32) + 0.5
+y = np.reciprocal(x)
+expect(node, inputs=[x], outputs=[y], name="test_reciprocal")
+```
+
+</details>
+
+
+### ReduceL1
+There are 5 test cases, listed as following:
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL1", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1)
+# print(reduced)
+# [[[78.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_default_axes_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([2], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceL1",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[3., 7.], [11., 15.], [19., 23.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_do_not_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceL1",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_empty_set",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL1",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_keep_dims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_keep_dims_random",
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL1",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_negative_axes_keep_dims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l1_negative_axes_keep_dims_random",
+)
+```
+
+</details>
+
+
+### ReduceL2
+There are 5 test cases, listed as following:
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL2", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sqrt(np.sum(a=np.square(data), axis=None, keepdims=keepdims == 1))
+# print(reduced)
+# [[[25.49509757]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sqrt(np.sum(a=np.square(data), axis=None, keepdims=keepdims == 1))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_default_axes_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([2], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceL2",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+# print(reduced)
+# [[2.23606798, 5.],
+# [7.81024968, 10.63014581],
+# [13.45362405, 16.2788206]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_do_not_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceL2",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_empty_set",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL2",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+# print(reduced)
+# [[[2.23606798], [5.]]
+# [[7.81024968], [10.63014581]]
+# [[13.45362405], [16.2788206 ]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_keep_dims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_keep_dims_random",
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceL2",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+# print(data)
+# [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+# print(reduced)
+# [[[2.23606798], [5.]]
+# [[7.81024968], [10.63014581]]
+# [[13.45362405], [16.2788206 ]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_negative_axes_keep_dims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sqrt(
+    np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_l2_negative_axes_keep_dims_random",
+)
+```
+
+</details>
+
+
+### ReduceLogSum
+There are 4 test cases, listed as following:
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceLogSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+reduced = np.log(zero)  # -inf
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_empty_set",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ReduceLogSum", inputs=["data", "axes"], outputs=["reduced"]
+)
+data = np.random.ranf([3, 4, 5]).astype(np.float32)
+reduced = np.log(np.sum(data, keepdims=True))
+axes = np.array([], dtype=np.int64)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_default",
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+axes = np.array([-2], dtype=np.int64)
+node = onnx.helper.make_node(
+    "ReduceLogSum", inputs=["data", "axes"], outputs=["reduced"]
+)
+data = np.random.ranf([3, 4, 5]).astype(np.float32)
+reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=True))
+# print(reduced)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_negative_axes",
+)
+```
+
+</details>
+<details>
+<summary>nokeepdims</summary>
+
+```python
+shape = [3, 4, 5]
+axes = np.array([2, 1], dtype=np.int64)
+
+node = onnx.helper.make_node(
+    "ReduceLogSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=0,
+)
+data = np.random.ranf(shape).astype(np.float32)
+reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=False))
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_desc_axes",
+)
+
+axes = np.array([0, 1], dtype=np.int64)
+node = onnx.helper.make_node(
+    "ReduceLogSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=0,
+)
+data = np.random.ranf(shape).astype(np.float32)
+reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=False))
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_asc_axes",
+)
+```
+
+</details>
+
+
+### ReduceLogSumExp
+There are 5 test cases, listed as following:
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+)
+reduced = np.log(np.sum(np.exp(data), axis=None, keepdims=keepdims == 1))
+# print(reduced)
+# [[[60.00671387]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.double)
+reduced = np.log(np.sum(np.exp(data), axis=None, keepdims=keepdims == 1))
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_default_axes_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+# print(reduced)
+# [[20., 2.31326175]
+# [40.00004578, 2.31326175]
+# [60.00671387, 2.31326175]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.double)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_do_not_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+reduced = np.log(zero)  # -inf
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_empty_set",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+# print(reduced)
+# [[[20., 2.31326175]]
+# [[40.00004578, 2.31326175]]
+# [[60.00671387, 2.31326175]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.double)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+node = onnx.helper.make_node(
+    "ReduceLogSumExp",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+)
+reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+# print(reduced)
+# [[[20., 2.31326175]]
+# [[40.00004578, 2.31326175]]
+# [[60.00671387, 2.31326175]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.double)
+reduced = np.log(
+    np.sum(np.exp(data), axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_log_sum_exp_negative_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+### ReduceMax
+There are 6 test cases, listed as following:
+<details>
+<summary>bool_inputs</summary>
+
+```python
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[True, True], [True, False], [False, True], [False, False]],
+)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=bool(keepdims))
+# print(reduced)
+# [[True],
+#  [True],
+#  [True],
+#  [False]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_bool_inputs",
+)
+```
+
+</details>
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = None
+keepdims = 1
+node = onnx.helper.make_node(
+    "ReduceMax", inputs=["data"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.maximum.reduce(data, axis=axes, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_max_default_axes_keepdim_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.maximum.reduce(data, axis=axes, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_max_default_axes_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[20., 2.]
+# [40., 2.]
+# [60., 2.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_do_not_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_do_not_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+one = np.array(np.ones(reduced_shape, dtype=np.float32))
+zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+reduced = -(one / zero)  # -inf
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_empty_set",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[20., 2.]]
+# [[40., 2.]]
+# [[60., 2.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMax",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[20., 2.]]
+# [[40., 2.]]
+# [[60., 2.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_negative_axes_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_max_negative_axes_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+### ReduceMean
+There are 4 test cases, listed as following:
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMean",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.mean(data, axis=None, keepdims=keepdims == 1)
+# print(reduced)
+# [[[18.25]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.mean(data, axis=None, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_default_axes_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceMean",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[12.5, 1.5]
+# [35., 1.5]
+# [57.5, 1.5]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_do_not_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMean",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[12.5, 1.5]]
+# [[35., 1.5]]
+# [[57.5, 1.5]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMean",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[12.5, 1.5]]
+# [[35., 1.5]]
+# [[57.5, 1.5]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_mean_negative_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+### ReduceMin
+There are 6 test cases, listed as following:
+<details>
+<summary>bool_inputs</summary>
+
+```python
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[True, True], [True, False], [False, True], [False, False]],
+)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=bool(keepdims))
+# print(reduced)
+# [[ True],
+#  [False],
+#  [False],
+#  [False]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_bool_inputs",
+)
+```
+
+</details>
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = None
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMin", inputs=["data"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.minimum.reduce(data, axis=axes, keepdims=keepdims == 1)
+# print(reduced)
+# [[[1.]]]
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_min_default_axes_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.minimum.reduce(data, axis=axes, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_min_default_axes_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[5., 1.]
+# [30., 1.]
+# [55., 1.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_do_not_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_do_not_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+one = np.array(np.ones(reduced_shape, dtype=np.float32))
+zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+reduced = one / zero  # inf
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_empty_set",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[5., 1.]]
+# [[30., 1.]]
+# [[55., 1.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceMin",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+    dtype=np.float32,
+)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[5., 1.]]
+# [[30., 1.]]
+# [[55., 1.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_negative_axes_keepdims_example",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_min_negative_axes_keepdims_random",
+    opset_imports=[onnx.helper.make_opsetid("", 18)],
+)
+```
+
+</details>
+
+
+### ReduceProd
+There are 5 test cases, listed as following:
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = None
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceProd", inputs=["data"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.prod(data, axis=axes, keepdims=keepdims == 1)
+# print(reduced)
+# [[[4.790016e+08]]]
+
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_prod_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.prod(data, axis=axes, keepdims=keepdims == 1)
+expect(
+    node,
+    inputs=[data],
+    outputs=[reduced],
+    name="test_reduce_prod_default_axes_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceProd",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[3., 8.]
+# [35., 48.]
+# [99., 120.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_do_not_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceProd",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.ones(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_empty_set",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceProd",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[3., 8.]]
+# [[35., 48.]]
+# [[99., 120.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceProd",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[3., 8.]]
+# [[35., 48.]]
+# [[99., 120.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_prod_negative_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+### ReduceSum
+There are 7 test cases, listed as following:
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(data, axis=None, keepdims=keepdims == 1)
+# print(reduced)
+# [[[78.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(data, axis=None, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_default_axes_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+# print(reduced)
+# [[4., 6.]
+# [12., 14.]
+# [20., 22.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_do_not_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>empty_axes_input_noop</summary>
+
+```python
+shape = [3, 2, 2]
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+    noop_with_empty_axes=True,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+axes = np.array([], dtype=np.int64)
+reduced = np.array(data)
+# print(reduced)
+# [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_empty_axes_input_noop_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.array(data)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_empty_axes_input_noop",
+)
+```
+
+</details>
+<details>
+<summary>empty_set</summary>
+
+```python
+"""Test case with the reduced-axis of size zero."""
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_empty_set",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+# print(reduced)
+# [[[4., 6.]]
+# [[12., 14.]]
+# [[20., 22.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+# print(reduced)
+# [[[4., 6.]]
+# [[12., 14.]]
+# [[20., 22.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_negative_axes_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>non_reduced_axis_zero</summary>
+
+```python
+"""Test case with the non-reduced-axis of size zero."""
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 0, 1]
+
+node = onnx.helper.make_node(
+    "ReduceSum",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([2], dtype=np.int64)
+reduced = np.array([], dtype=np.float32).reshape(reduced_shape)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_empty_set_non_reduced_axis_zero",
+)
+```
+
+</details>
+
+
+### ReduceSumSquare
+There are 5 test cases, listed as following:
+<details>
+<summary>default_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(np.square(data), axis=None, keepdims=keepdims == 1)
+# print(reduced)
+# [[[650.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_default_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(np.square(data), axis=None, keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_default_axes_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>do_not_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 0
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[10., 20.]
+# [74., 100.]
+# [202., 244.]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_do_not_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_do_not_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>empty_set</summary>
+
+```python
+shape = [2, 0, 4]
+keepdims = 1
+reduced_shape = [2, 1, 4]
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array([], dtype=np.float32).reshape(shape)
+axes = np.array([1], dtype=np.int64)
+reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_empty_set",
+)
+```
+
+</details>
+<details>
+<summary>keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([1], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[10., 20.]]
+# [[74., 100.]]
+# [[202., 244.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_keepdims_random",
+)
+```
+
+</details>
+<details>
+<summary>negative_axes_keepdims</summary>
+
+```python
+shape = [3, 2, 2]
+axes = np.array([-2], dtype=np.int64)
+keepdims = 1
+
+node = onnx.helper.make_node(
+    "ReduceSumSquare",
+    inputs=["data", "axes"],
+    outputs=["reduced"],
+    keepdims=keepdims,
+)
+
+data = np.array(
+    [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+# print(reduced)
+# [[[10., 20.s]]
+# [[74., 100.]]
+# [[202., 244.]]]
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_negative_axes_keepdims_example",
+)
+
+np.random.seed(0)
+data = np.random.uniform(-10, 10, shape).astype(np.float32)
+reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+expect(
+    node,
+    inputs=[data, axes],
+    outputs=[reduced],
+    name="test_reduce_sum_square_negative_axes_keepdims_random",
+)
+```
+
+</details>
+
+
+### RegexFullMatch
+There are 3 test cases, listed as following:
+<details>
+<summary>basic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RegexFullMatch",
+    inputs=["X"],
+    outputs=["Y"],
+    pattern=r"www\.[\w.-]+\.\bcom\b",
+)
+
+x = np.array(["www.google.com", "www.facebook.com", "www.bbc.co.uk"]).astype(
+    object
+)
+result = np.array([True, True, False])
+expect(node, inputs=[x], outputs=[result], name="test_regex_full_match_basic")
+```
+
+</details>
+<details>
+<summary>match_email_domain</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RegexFullMatch",
+    inputs=["X"],
+    outputs=["Y"],
+    pattern=r"(\W|^)[\w.\-]{0,25}@(yahoo|gmail)\.com(\W|$)",
+)
+
+x = np.array(
+    [
+        ["account@gmail.com", "account@hotmail.com"],
+        ["not email", "account2@yahoo.com"],
+    ]
+).astype(object)
+result = np.array([[True, False], [False, True]])
+expect(
+    node,
+    inputs=[x],
+    outputs=[result],
+    name="test_regex_full_match_email_domain",
+)
+```
+
+</details>
+<details>
+<summary>match_empty</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RegexFullMatch",
+    inputs=["X"],
+    outputs=["Y"],
+    pattern=r"(\W|^)[\w.\-]{0,25}@(yahoo|gmail)\.com(\W|$)",
+)
+
+x = np.array([[], []]).astype(object)
+result = np.array([[], []]).astype(bool)
+expect(
+    node,
+    inputs=[x],
+    outputs=[result],
+    name="test_regex_full_match_empty",
+)
+```
+
+</details>
+
+
+### Relu
+There are 1 test cases, listed as following:
+<details>
+<summary>relu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Relu",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, 0, np.inf)
+
+expect(node, inputs=[x], outputs=[y], name="test_relu")
+```
+
+</details>
+
+
+### Reshape
+There are 2 test cases, listed as following:
+<details>
+<summary>allowzero</summary>
+
+```python
+original_shape = [0, 3, 4]
+test_cases = {
+    "allowzero_reordered": np.array([3, 4, 0], dtype=np.int64),
+}
+data = np.random.random_sample(original_shape).astype(np.float32)
+
+for test_name, shape in test_cases.items():
+    node = onnx.helper.make_node(
+        "Reshape",
+        inputs=["data", "shape"],
+        outputs=["reshaped"],
+        allowzero=1,  # if allowzero=1, final shape = (3, 4, 0)
+        # if allowzero=0, final shape = (3, 4, 4)
+    )
+
+    reshaped = reshape_reference_implementation(data, shape, allowzero=1)
+
+    expect(
+        node,
+        inputs=[data, shape],
+        outputs=[reshaped],
+        name="test_reshape_" + test_name,
+    )
+```
+
+</details>
+<details>
+<summary>reshape</summary>
+
+```python
+original_shape = [2, 3, 4]
+test_cases = {
+    "reordered_all_dims": np.array([4, 2, 3], dtype=np.int64),
+    "reordered_last_dims": np.array([2, 4, 3], dtype=np.int64),
+    "reduced_dims": np.array([2, 12], dtype=np.int64),
+    "extended_dims": np.array([2, 3, 2, 2], dtype=np.int64),
+    "one_dim": np.array([24], dtype=np.int64),
+    "negative_dim": np.array([2, -1, 2], dtype=np.int64),
+    "negative_extended_dims": np.array([-1, 2, 3, 4], dtype=np.int64),
+    "zero_dim": np.array([2, 0, 4, 1], dtype=np.int64),
+    "zero_and_negative_dim": np.array([2, 0, 1, -1], dtype=np.int64),
+}
+data = np.random.random_sample(original_shape).astype(np.float32)
+
+for test_name, shape in test_cases.items():
+    node = onnx.helper.make_node(
+        "Reshape",
+        inputs=["data", "shape"],
+        outputs=["reshaped"],
+    )
+
+    reshaped = reshape_reference_implementation(data, shape)
+
+    expect(
+        node,
+        inputs=[data, shape],
+        outputs=[reshaped],
+        name="test_reshape_" + test_name,
+    )
+```
+
+</details>
+
+
+### Resize
+There are 39 test cases, listed as following:
+<details>
+<summary>resize_downsample_scales_cubic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32)
+
+# [[[[ 1.47119141  2.78125     4.08251953]
+#    [ 6.71142578  8.02148438  9.32275391]
+#    [11.91650391 13.2265625  14.52783203]]]]
+output = interpolate_nd(
+    data, lambda x, _: cubic_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_cubic",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_scales_cubic_A_n0p5_exclude_outside</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    cubic_coeff_a=-0.5,
+    exclude_outside=True,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32)
+
+# [[[[ 1.36812675  2.6695014   4.0133367 ]
+#    [ 6.57362535  7.875       9.2188353 ]
+#    [11.94896657 13.25034122 14.59417652]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x, A=-0.5),
+    scale_factors=scales,
+    exclude_outside=True,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_cubic_A_n0p5_exclude_outside",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_scales_cubic_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    coordinate_transformation_mode="align_corners",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32)
+
+# [[[[ 1.          2.39519159  3.79038317]
+#    [ 6.58076634  7.97595793  9.37114951]
+#    [12.16153268 13.55672427 14.95191585]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_cubic_align_corners",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_scales_cubic_antialias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    antialias=1,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[ 2.5180721  4.2858863]
+#    [ 9.589329  11.357142 ]]]]
+output = interpolate_nd(
+    data, cubic_coeffs_antialias, scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_cubic_antialias",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_scales_linear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[2.6666665 4.3333331]]]]
+output = interpolate_nd(
+    data, lambda x, _: linear_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_linear",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_scales_linear_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="align_corners",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[1.       3.142857]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_linear_align_corners",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_scales_linear_antialias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    antialias=1,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[ 2.875  4.5  ]
+#    [ 9.375 11.   ]]]]
+output = interpolate_nd(
+    data, linear_coeffs_antialias, scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_linear_antialias",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_scales_linear_half_pixel_symmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="half_pixel_symmetric",
+)
+
+data = np.array([[[[1, 2, 3, 4]]]], dtype=np.float32)
+scales = np.array([1.0, 1.0, 1.0, 0.6], dtype=np.float32)
+
+# [[[[1.6666667, 3.3333333]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="half_pixel_symmetric",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_linear_half_pixel_symmetric",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_scales_nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+# [[[[1. 3.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_downsample_scales_nearest",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_sizes_cubic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="cubic",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 1.63078704  3.00462963  4.37847222]
+#    [ 7.12615741  8.5         9.87384259]
+#    [12.62152778 13.99537037 15.36921296]]]]
+output = interpolate_nd(
+    data, lambda x, _: cubic_coeffs(x), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_cubic",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_sizes_cubic_antialias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="cubic",
+    antialias=1,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 1.7750092  3.1200073  4.4650054]
+#    [ 7.1550016  8.5        9.844998 ]
+#    [12.534994  13.8799925 15.224991 ]]]]
+output = interpolate_nd(data, cubic_coeffs_antialias, output_size=sizes).astype(
+    np.float32
+)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_cubic_antialias",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_sizes_linear_antialias</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    antialias=1,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 2.3636363  3.590909   4.818182 ]
+#    [ 7.2727275  8.5        9.727273 ]
+#    [12.181818  13.409091  14.636364 ]]]]
+output = interpolate_nd(
+    data, linear_coeffs_antialias, output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_linear_antialias",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_sizes_linear_pytorch_half_pixel</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="pytorch_half_pixel",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 3, 1], dtype=np.int64)
+
+# [[[[ 1.6666666]
+#    [ 7.       ]
+#    [12.333333 ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    coordinate_transformation_mode="pytorch_half_pixel",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_linear_pytorch_half_pixel",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_sizes_nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 1, 3], dtype=np.int64)
+
+# [[[[1. 2. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_nearest",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_sizes_nearest_not_larger</summary>
+
+```python
+keep_aspect_ratio_policy = "not_larger"
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 3], dtype=np.int64)  # Results in 1x2
+
+# [[[[1. 3.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x),
+    output_size=sizes,
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_nearest_not_larger",
+)
+```
+
+</details>
+<details>
+<summary>resize_downsample_sizes_nearest_not_smaller</summary>
+
+```python
+keep_aspect_ratio_policy = "not_smaller"
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 3], dtype=np.int64)  # Results in 2x3
+
+# [[[[1. 2. 4.]
+#    [5. 6. 8.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x),
+    output_size=sizes,
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_downsample_sizes_nearest_not_smaller",
+)
+```
+
+</details>
+<details>
+<summary>resize_tf_crop_and_resize</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "roi", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="tf_crop_and_resize",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# Note: for some rois, the result may be different with that of TF for inaccurate floating point
+roi = np.array([0, 0, 0.4, 0.6, 1, 1, 0.6, 0.8], dtype=np.float32)
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 7.6000004  7.9        8.2      ]
+#    [ 8.8        9.1        9.400001 ]
+#    [10.        10.3       10.6      ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    roi=roi,
+    coordinate_transformation_mode="tf_crop_and_resize",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, roi, sizes],
+    outputs=[output],
+    name="test_resize_tf_crop_and_resize",
+)
+```
+
+</details>
+<details>
+<summary>resize_tf_crop_and_resize_axes_2_3</summary>
+
+```python
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "roi", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="tf_crop_and_resize",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# Note: for some rois, the result may be different with that of TF for inaccurate floating point
+roi = np.array([0.4, 0.6, 0.6, 0.8], dtype=np.float32)
+sizes = np.array([3, 3], dtype=np.int64)
+
+# [[[[ 7.6000004  7.9        8.2      ]
+#    [ 8.8        9.1        9.400001 ]
+#    [10.        10.3       10.6      ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    roi=roi,
+    axes=axes,
+    coordinate_transformation_mode="tf_crop_and_resize",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, roi, sizes],
+    outputs=[output],
+    name="test_resize_tf_crop_and_resize_axes_2_3",
+)
+```
+
+</details>
+<details>
+<summary>resize_tf_crop_and_resize_axes_3_2</summary>
+
+```python
+axes = [3, 2]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "roi", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="tf_crop_and_resize",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# Note: for some rois, the result may be different with that of TF for inaccurate floating point
+roi = np.array([0.6, 0.4, 0.8, 0.6], dtype=np.float32)
+sizes = np.array([3, 3], dtype=np.int64)
+
+# [[[[ 7.6000004  7.9        8.2      ]
+#    [ 8.8        9.1        9.400001 ]
+#    [10.        10.3       10.6      ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    roi=roi,
+    axes=axes,
+    coordinate_transformation_mode="tf_crop_and_resize",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, roi, sizes],
+    outputs=[output],
+    name="test_resize_tf_crop_and_resize_axes_3_2",
+)
+```
+
+</details>
+<details>
+<summary>resize_tf_crop_and_resize_extrapolation_value</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "roi", "", "sizes"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="tf_crop_and_resize",
+    extrapolation_value=10.0,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+# Note: for some rois, the result may be different with that of TF for inaccurate floating point
+roi = np.array([0, 0, 0.4, 0.6, 1, 1, 1.2, 1.7], dtype=np.float32)
+sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+# [[[[ 7.6000004 10.        10.       ]
+#    [12.400001  10.        10.       ]
+#    [10.        10.        10.       ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    output_size=sizes,
+    roi=roi,
+    coordinate_transformation_mode="tf_crop_and_resize",
+    extrapolation_value=10.0,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, roi, sizes],
+    outputs=[output],
+    name="test_resize_tf_crop_and_resize_extrapolation_value",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_cubic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[ 0.47265625  0.76953125  1.24609375  1.875       2.28125
+#      2.91015625  3.38671875  3.68359375]
+#    [ 1.66015625  1.95703125  2.43359375  3.0625      3.46875
+#      4.09765625  4.57421875  4.87109375]
+#    [ 3.56640625  3.86328125  4.33984375  4.96875     5.375
+#      6.00390625  6.48046875  6.77734375]
+#    [ 6.08203125  6.37890625  6.85546875  7.484375    7.890625
+#      8.51953125  8.99609375  9.29296875]
+#    [ 7.70703125  8.00390625  8.48046875  9.109375    9.515625
+#     10.14453125 10.62109375 10.91796875]
+#    [10.22265625 10.51953125 10.99609375 11.625      12.03125
+#     12.66015625 13.13671875 13.43359375]
+#    [12.12890625 12.42578125 12.90234375 13.53125    13.9375
+#     14.56640625 15.04296875 15.33984375]
+#    [13.31640625 13.61328125 14.08984375 14.71875    15.125
+#     15.75390625 16.23046875 16.52734375]]]]
+output = interpolate_nd(
+    data, lambda x, _: cubic_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_cubic",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_cubic_A_n0p5_exclude_outside</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    cubic_coeff_a=-0.5,
+    exclude_outside=True,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[ 0.55882353  0.81494204  1.35698249  1.89705882  2.39705882
+#      2.93713516  3.47917561  3.73529412]
+#    [ 1.58329755  1.83941606  2.38145651  2.92153285  3.42153285
+#      3.96160918  4.50364964  4.75976814]
+#    [ 3.75145936  4.00757787  4.54961832  5.08969466  5.58969466
+#      6.12977099  6.67181144  6.92792995]
+#    [ 5.91176471  6.16788321  6.70992366  7.25        7.75
+#      8.29007634  8.83211679  9.08823529]
+#    [ 7.91176471  8.16788321  8.70992366  9.25        9.75
+#     10.29007634 10.83211679 11.08823529]
+#    [10.07207005 10.32818856 10.87022901 11.41030534 11.91030534
+#     12.45038168 12.99242213 13.24854064]
+#    [12.24023186 12.49635036 13.03839082 13.57846715 14.07846715
+#     14.61854349 15.16058394 15.41670245]
+#    [13.26470588 13.52082439 14.06286484 14.60294118 15.10294118
+#     15.64301751 16.18505796 16.44117647]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x, A=-0.5),
+    scale_factors=scales,
+    exclude_outside=True,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_cubic_A_n0p5_exclude_outside",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_cubic_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    coordinate_transformation_mode="align_corners",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[ 1.          1.34110787  1.80029155  2.32944606  2.67055394
+#      3.19970845  3.65889213  4.        ]
+#    [ 2.36443149  2.70553936  3.16472303  3.69387755  4.03498542
+#      4.56413994  5.02332362  5.36443149]
+#    [ 4.20116618  4.54227405  5.00145773  5.53061224  5.87172012
+#      6.40087464  6.86005831  7.20116618]
+#    [ 6.31778426  6.65889213  7.1180758   7.64723032  7.98833819
+#      8.51749271  8.97667638  9.31778426]
+#    [ 7.68221574  8.02332362  8.48250729  9.01166181  9.35276968
+#      9.8819242  10.34110787 10.68221574]
+#    [ 9.79883382 10.13994169 10.59912536 11.12827988 11.46938776
+#     11.99854227 12.45772595 12.79883382]
+#    [11.63556851 11.97667638 12.43586006 12.96501458 13.30612245
+#     13.83527697 14.29446064 14.63556851]
+#    [13.         13.34110787 13.80029155 14.32944606 14.67055394
+#     15.19970845 15.65889213 16.        ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_cubic_align_corners",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_cubic_asymmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="cubic",
+    coordinate_transformation_mode="asymmetric",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[ 1.       1.40625  2.       2.5      3.       3.59375  4.
+#      4.09375]
+#    [ 2.625    3.03125  3.625    4.125    4.625    5.21875  5.625
+#      5.71875]
+#    [ 5.       5.40625  6.       6.5      7.       7.59375  8.
+#      8.09375]
+#    [ 7.       7.40625  8.       8.5      9.       9.59375 10.
+#     10.09375]
+#    [ 9.       9.40625 10.      10.5     11.      11.59375 12.
+#     12.09375]
+#    [11.375   11.78125 12.375   12.875   13.375   13.96875 14.375
+#     14.46875]
+#    [13.      13.40625 14.      14.5     15.      15.59375 16.
+#     16.09375]
+#    [13.375   13.78125 14.375   14.875   15.375   15.96875 16.375
+#     16.46875]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: cubic_coeffs(x, A=-0.75),
+    scale_factors=scales,
+    coordinate_transformation_mode="asymmetric",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_cubic_asymmetric",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_linear</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[1.   1.25 1.75 2.  ]
+#    [1.5  1.75 2.25 2.5 ]
+#    [2.5  2.75 3.25 3.5 ]
+#    [3.   3.25 3.75 4.  ]]]]
+output = interpolate_nd(
+    data, lambda x, _: linear_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_linear",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_linear_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="align_corners",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+# [[[[1.         1.33333333 1.66666667 2.        ]
+#    [1.66666667 2.         2.33333333 2.66666667]
+#    [2.33333333 2.66666667 3.         3.33333333]
+#    [3.         3.33333333 3.66666667 4.        ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_linear_align_corners",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_linear_half_pixel_symmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="linear",
+    coordinate_transformation_mode="half_pixel_symmetric",
+)
+
+data = np.array([[[[1, 2], [3, 4]]]], dtype=np.float32)
+scales = np.array([1.0, 1.0, 2.3, 2.94], dtype=np.float32)
+
+# [[[[1.        , 1.15986395, 1.5       , 1.84013605, 2.        ],
+#    [1.56521738, 1.72508133, 2.06521738, 2.40535343, 2.56521738],
+#    [2.43478262, 2.59464657, 2.93478262, 3.27491867, 3.43478262],
+#    [3.        , 3.15986395, 3.5       , 3.84013605, 4.        ]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: linear_coeffs(x),
+    scale_factors=scales,
+    coordinate_transformation_mode="half_pixel_symmetric",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_linear_half_pixel_symmetric",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
+
+# [[[[1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 2. 2. 2.]
+#    [3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), scale_factors=scales
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_nearest",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_nearest_axes_2_3</summary>
+
+```python
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([2.0, 3.0], dtype=np.float32)
+
+# [[[[1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 2. 2. 2.]
+#    [3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), scale_factors=scales, axes=axes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_nearest_axes_2_3",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_scales_nearest_axes_3_2</summary>
+
+```python
+axes = [3, 2]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([3.0, 2.0], dtype=np.float32)
+
+# [[[[1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 2. 2. 2.]
+#    [3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), scale_factors=scales, axes=axes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_resize_upsample_scales_nearest_axes_3_2",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_sizes_cubic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="cubic",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 9, 10], dtype=np.int64)
+
+# [[[[ 0.45507922  0.64057922  0.97157922  1.42257922  1.90732922
+#      2.22332922  2.70807922  3.15907922  3.49007922  3.67557922]
+#    [ 1.39437963  1.57987963  1.91087963  2.36187963  2.84662963
+#      3.16262963  3.64737963  4.09837963  4.42937963  4.61487963]
+#    [ 2.95130693  3.13680693  3.46780693  3.91880693  4.40355693
+#      4.71955693  5.20430693  5.65530693  5.98630693  6.17180693]
+#    [ 5.20525069  5.39075069  5.72175069  6.17275069  6.65750069
+#      6.97350069  7.45825069  7.90925069  8.24025069  8.42575069]
+#    [ 6.88975     7.07525     7.40625     7.85725     8.342
+#      8.658       9.14275     9.59375     9.92475    10.11025   ]
+#    [ 8.57424931  8.75974931  9.09074931  9.54174931 10.02649931
+#     10.34249931 10.82724931 11.27824931 11.60924931 11.79474931]
+#    [10.82819307 11.01369307 11.34469307 11.79569307 12.28044307
+#     12.59644307 13.08119307 13.53219307 13.86319307 14.04869307]
+#    [12.38512037 12.57062037 12.90162037 13.35262037 13.83737037
+#     14.15337037 14.63812037 15.08912037 15.42012037 15.60562037]
+#    [13.32442078 13.50992078 13.84092078 14.29192078 14.77667078
+#     15.09267078 15.57742078 16.02842078 16.35942078 16.54492078]]]]
+output = interpolate_nd(
+    data, lambda x, _: cubic_coeffs(x), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_cubic",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_sizes_nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 7, 8], dtype=np.int64)
+
+# [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_sizes_nearest_axes_2_3</summary>
+
+```python
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([7, 8], dtype=np.int64)
+
+# [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), output_size=sizes, axes=axes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_axes_2_3",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_sizes_nearest_axes_3_2</summary>
+
+```python
+axes = [3, 2]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([8, 7], dtype=np.int64)
+
+# [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x), output_size=sizes, axes=axes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_axes_3_2",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_sizes_nearest_ceil_half_pixel</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    coordinate_transformation_mode="half_pixel",
+    nearest_mode="ceil",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 8, 8], dtype=np.int64)
+
+# [[[[ 1.  2.  2.  3.  3.  4.  4.  4.]
+#    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+#    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+#    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+#    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]]]]
+output = interpolate_nd(
+    data, lambda x, _: nearest_coeffs(x, mode="ceil"), output_size=sizes
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_ceil_half_pixel",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_sizes_nearest_floor_align_corners</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    coordinate_transformation_mode="align_corners",
+    nearest_mode="floor",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 8, 8], dtype=np.int64)
+
+# [[[[ 1.  1.  1.  2.  2.  3.  3.  4.]
+#    [ 1.  1.  1.  2.  2.  3.  3.  4.]
+#    [ 1.  1.  1.  2.  2.  3.  3.  4.]
+#    [ 5.  5.  5.  6.  6.  7.  7.  8.]
+#    [ 5.  5.  5.  6.  6.  7.  7.  8.]
+#    [ 9.  9.  9. 10. 10. 11. 11. 12.]
+#    [ 9.  9.  9. 10. 10. 11. 11. 12.]
+#    [13. 13. 13. 14. 14. 15. 15. 16.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x, mode="floor"),
+    output_size=sizes,
+    coordinate_transformation_mode="align_corners",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_floor_align_corners",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_sizes_nearest_not_larger</summary>
+
+```python
+keep_aspect_ratio_policy = "not_larger"
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([7, 8], dtype=np.int64)  # Results in 7x7
+
+# [[[[1. 1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x),
+    output_size=sizes,
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_not_larger",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_sizes_nearest_not_smaller</summary>
+
+```python
+keep_aspect_ratio_policy = "not_smaller"
+axes = [2, 3]
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([7, 8], dtype=np.int64)  # Results in 8x8
+
+# [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [1. 1. 1. 1. 2. 2. 2. 2.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]
+#    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x),
+    output_size=sizes,
+    axes=axes,
+    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_not_smaller",
+)
+```
+
+</details>
+<details>
+<summary>resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Resize",
+    inputs=["X", "", "", "sizes"],
+    outputs=["Y"],
+    mode="nearest",
+    coordinate_transformation_mode="asymmetric",
+    nearest_mode="round_prefer_ceil",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2, 3, 4],
+                [5, 6, 7, 8],
+                [9, 10, 11, 12],
+                [13, 14, 15, 16],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+sizes = np.array([1, 1, 8, 8], dtype=np.int64)
+
+# [[[[ 1.  2.  2.  3.  3.  4.  4.  4.]
+#    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+#    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+#    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+#    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]
+#    [13. 14. 14. 15. 15. 16. 16. 16.]]]]
+output = interpolate_nd(
+    data,
+    lambda x, _: nearest_coeffs(x, mode="round_prefer_ceil"),
+    output_size=sizes,
+    coordinate_transformation_mode="asymmetric",
+).astype(np.float32)
+
+expect(
+    node,
+    inputs=[data, sizes],
+    outputs=[output],
+    name="test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric",
+)
+```
+
+</details>
+
+
+### ReverseSequence
+There are 2 test cases, listed as following:
+<details>
+<summary>reversesequence_batch</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ReverseSequence",
+    inputs=["x", "sequence_lens"],
+    outputs=["y"],
+    time_axis=1,
+    batch_axis=0,
+)
+x = np.array(
+    [
+        [0.0, 1.0, 2.0, 3.0],
+        [4.0, 5.0, 6.0, 7.0],
+        [8.0, 9.0, 10.0, 11.0],
+        [12.0, 13.0, 14.0, 15.0],
+    ],
+    dtype=np.float32,
+)
+sequence_lens = np.array([1, 2, 3, 4], dtype=np.int64)
+
+y = np.array(
+    [
+        [0.0, 1.0, 2.0, 3.0],
+        [5.0, 4.0, 6.0, 7.0],
+        [10.0, 9.0, 8.0, 11.0],
+        [15.0, 14.0, 13.0, 12.0],
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[x, sequence_lens],
+    outputs=[y],
+    name="test_reversesequence_batch",
+)
+```
+
+</details>
+<details>
+<summary>reversesequence_time</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ReverseSequence",
+    inputs=["x", "sequence_lens"],
+    outputs=["y"],
+    time_axis=0,
+    batch_axis=1,
+)
+x = np.array(
+    [
+        [0.0, 4.0, 8.0, 12.0],
+        [1.0, 5.0, 9.0, 13.0],
+        [2.0, 6.0, 10.0, 14.0],
+        [3.0, 7.0, 11.0, 15.0],
+    ],
+    dtype=np.float32,
+)
+sequence_lens = np.array([4, 3, 2, 1], dtype=np.int64)
+
+y = np.array(
+    [
+        [3.0, 6.0, 9.0, 12.0],
+        [2.0, 5.0, 8.0, 13.0],
+        [1.0, 4.0, 10.0, 14.0],
+        [0.0, 7.0, 11.0, 15.0],
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[x, sequence_lens],
+    outputs=[y],
+    name="test_reversesequence_time",
+)
+```
+
+</details>
+
+
+### RoiAlign
+There are 3 test cases, listed as following:
+<details>
+<summary>roialign_aligned_false</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RoiAlign",
+    inputs=["X", "rois", "batch_indices"],
+    outputs=["Y"],
+    spatial_scale=1.0,
+    output_height=5,
+    output_width=5,
+    sampling_ratio=2,
+    coordinate_transformation_mode="output_half_pixel",
+)
+
+X, batch_indices, rois = get_roi_align_input_values()
+# (num_rois, C, output_height, output_width)
+Y = np.array(
+    [
+        [
+            [
+                [0.4664, 0.4466, 0.3405, 0.5688, 0.6068],
+                [0.3714, 0.4296, 0.3835, 0.5562, 0.3510],
+                [0.2768, 0.4883, 0.5222, 0.5528, 0.4171],
+                [0.4713, 0.4844, 0.6904, 0.4920, 0.8774],
+                [0.6239, 0.7125, 0.6289, 0.3355, 0.3495],
+            ]
+        ],
+        [
+            [
+                [0.3022, 0.4305, 0.4696, 0.3978, 0.5423],
+                [0.3656, 0.7050, 0.5165, 0.3172, 0.7015],
+                [0.2912, 0.5059, 0.6476, 0.6235, 0.8299],
+                [0.5916, 0.7389, 0.7048, 0.8372, 0.8893],
+                [0.6227, 0.6153, 0.7097, 0.6154, 0.4585],
+            ]
+        ],
+        [
+            [
+                [0.2384, 0.3379, 0.3717, 0.6100, 0.7601],
+                [0.3767, 0.3785, 0.7147, 0.9243, 0.9727],
+                [0.5749, 0.5826, 0.5709, 0.7619, 0.8770],
+                [0.5355, 0.2566, 0.2141, 0.2796, 0.3600],
+                [0.4365, 0.3504, 0.2887, 0.3661, 0.2349],
+            ]
+        ],
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, rois, batch_indices],
+    outputs=[Y],
+    name="test_roialign_aligned_false",
+)
+```
+
+</details>
+<details>
+<summary>roialign_aligned_true</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RoiAlign",
+    inputs=["X", "rois", "batch_indices"],
+    outputs=["Y"],
+    spatial_scale=1.0,
+    output_height=5,
+    output_width=5,
+    sampling_ratio=2,
+    coordinate_transformation_mode="half_pixel",
+)
+
+X, batch_indices, rois = get_roi_align_input_values()
+# (num_rois, C, output_height, output_width)
+Y = np.array(
+    [
+        [
+            [
+                [0.5178, 0.3434, 0.3229, 0.4474, 0.6344],
+                [0.4031, 0.5366, 0.4428, 0.4861, 0.4023],
+                [0.2512, 0.4002, 0.5155, 0.6954, 0.3465],
+                [0.3350, 0.4601, 0.5881, 0.3439, 0.6849],
+                [0.4932, 0.7141, 0.8217, 0.4719, 0.4039],
+            ]
+        ],
+        [
+            [
+                [0.3070, 0.2187, 0.3337, 0.4880, 0.4870],
+                [0.1871, 0.4914, 0.5561, 0.4192, 0.3686],
+                [0.1433, 0.4608, 0.5971, 0.5310, 0.4982],
+                [0.2788, 0.4386, 0.6022, 0.7000, 0.7524],
+                [0.5774, 0.7024, 0.7251, 0.7338, 0.8163],
+            ]
+        ],
+        [
+            [
+                [0.2393, 0.4075, 0.3379, 0.2525, 0.4743],
+                [0.3671, 0.2702, 0.4105, 0.6419, 0.8308],
+                [0.5556, 0.4543, 0.5564, 0.7502, 0.9300],
+                [0.6626, 0.5617, 0.4813, 0.4954, 0.6663],
+                [0.6636, 0.3721, 0.2056, 0.1928, 0.2478],
+            ]
+        ],
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[X, rois, batch_indices],
+    outputs=[Y],
+    name="test_roialign_aligned_true",
+)
+```
+
+</details>
+<details>
+<summary>roialign_mode_max</summary>
+
+```python
+X = np.array(
+    [
+        [
+            [
+                [
+                    0.2764,
+                    0.715,
+                    0.1958,
+                    0.3416,
+                    0.4638,
+                    0.0259,
+                    0.2963,
+                    0.6518,
+                    0.4856,
+                    0.725,
+                ],
+                [
+                    0.9637,
+                    0.0895,
+                    0.2919,
+                    0.6753,
+                    0.0234,
+                    0.6132,
+                    0.8085,
+                    0.5324,
+                    0.8992,
+                    0.4467,
+                ],
+                [
+                    0.3265,
+                    0.8479,
+                    0.9698,
+                    0.2471,
+                    0.9336,
+                    0.1878,
+                    0.4766,
+                    0.4308,
+                    0.34,
+                    0.2162,
+                ],
+                [
+                    0.0206,
+                    0.172,
+                    0.2155,
+                    0.4394,
+                    0.0653,
+                    0.3406,
+                    0.7724,
+                    0.3921,
+                    0.2541,
+                    0.5799,
+                ],
+                [
+                    0.4062,
+                    0.2194,
+                    0.4473,
+                    0.4687,
+                    0.7109,
+                    0.9327,
+                    0.9815,
+                    0.632,
+                    0.1728,
+                    0.6119,
+                ],
+                [
+                    0.3097,
+                    0.1283,
+                    0.4984,
+                    0.5068,
+                    0.4279,
+                    0.0173,
+                    0.4388,
+                    0.043,
+                    0.4671,
+                    0.7119,
+                ],
+                [
+                    0.1011,
+                    0.8477,
+                    0.4726,
+                    0.1777,
+                    0.9923,
+                    0.4042,
+                    0.1869,
+                    0.7795,
+                    0.9946,
+                    0.9689,
+                ],
+                [
+                    0.1366,
+                    0.3671,
+                    0.7011,
+                    0.6234,
+                    0.9867,
+                    0.5585,
+                    0.6985,
+                    0.5609,
+                    0.8788,
+                    0.9928,
+                ],
+                [
+                    0.5697,
+                    0.8511,
+                    0.6711,
+                    0.9406,
+                    0.8751,
+                    0.7496,
+                    0.165,
+                    0.1049,
+                    0.1559,
+                    0.2514,
+                ],
+                [
+                    0.7012,
+                    0.4056,
+                    0.7879,
+                    0.3461,
+                    0.0415,
+                    0.2998,
+                    0.5094,
+                    0.3727,
+                    0.5482,
+                    0.0502,
+                ],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+rois = np.array(
+    [[0.0, 0.0, 9.0, 9.0], [0.0, 5.0, 4.0, 9.0], [5.0, 5.0, 9.0, 9.0]],
+    dtype=np.float32,
+)
+batch_indices = np.array([0, 0, 0], dtype=np.int64)
+
+Y = np.array(
+    [
+        [
+            [
+                [0.3445228, 0.37310338, 0.37865096, 0.446696, 0.37991184],
+                [0.4133513, 0.5455125, 0.6651902, 0.55805874, 0.27110294],
+                [0.21223956, 0.40924096, 0.8417618, 0.792561, 0.37196714],
+                [0.46835402, 0.39741728, 0.8012819, 0.4969306, 0.5495158],
+                [0.3595896, 0.5196813, 0.5403741, 0.23814403, 0.19992709],
+            ]
+        ],
+        [
+            [
+                [0.30517197, 0.5086199, 0.3189761, 0.4054401, 0.47630402],
+                [0.50862, 0.8477, 0.37808004, 0.24936005, 0.79384017],
+                [0.17620805, 0.29368007, 0.44870415, 0.4987201, 0.63148826],
+                [0.51066005, 0.8511, 0.5368801, 0.9406, 0.70008016],
+                [0.4487681, 0.51066035, 0.5042561, 0.5643603, 0.42004836],
+            ]
+        ],
+        [
+            [
+                [0.21062402, 0.3510401, 0.37416005, 0.5967599, 0.46507207],
+                [0.32336006, 0.31180006, 0.6236001, 0.9946, 0.7751202],
+                [0.35744014, 0.5588001, 0.35897616, 0.7030401, 0.6353923],
+                [0.5996801, 0.27940005, 0.17948808, 0.35152006, 0.31769615],
+                [0.3598083, 0.40752012, 0.2385281, 0.43856013, 0.26313624],
+            ]
+        ],
+    ],
+    dtype=np.float32,
+)
+
+node = onnx.helper.make_node(
+    "RoiAlign",
+    inputs=["X", "rois", "batch_indices"],
+    mode="max",
+    outputs=["Y"],
+    spatial_scale=1.0,
+    output_height=5,
+    output_width=5,
+    sampling_ratio=2,
+    coordinate_transformation_mode="output_half_pixel",
+)
+
+expect(
+    node,
+    inputs=[X, rois, batch_indices],
+    outputs=[Y],
+    name="test_roialign_mode_max",
+)
+```
+
+</details>
+
+
+### RotaryEmbedding
+There are 8 test cases, listed as following:
+<details>
+<summary>rotary_embedding</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 4).astype(np.float32)
+cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data, cos_cache_data, sin_cache_data, position_ids=position_ids_data
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding",
+)
+```
+
+</details>
+<details>
+<summary>rotary_embedding_3d_input</summary>
+
+```python
+num_heads = 4
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+    num_heads=num_heads,
+)
+
+input_data = np.random.rand(2, 3, 32).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 4).astype(np.float32)
+cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    position_ids=position_ids_data,
+    num_heads=num_heads,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_3d_input",
+)
+```
+
+</details>
+<details>
+<summary>rotary_embedding_interleaved</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+    interleaved=1,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 4).astype(np.float32)
+cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    position_ids=position_ids_data,
+    interleaved=1,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_interleaved",
+)
+```
+
+</details>
+<details>
+<summary>rotary_embedding_no_position_ids</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache"],
+    outputs=["output"],
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+sin_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+cos_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+
+expected_output = rotary_embedding(input_data, cos_cache_data, sin_cache_data)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_no_position_ids",
+)
+```
+
+</details>
+<details>
+<summary>rotary_embedding_no_position_ids_interleaved</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache"],
+    outputs=["output"],
+    interleaved=1,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+sin_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+cos_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    interleaved=1,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_no_position_ids_interleaved",
+)
+```
+
+</details>
+<details>
+<summary>rotary_embedding_no_position_ids_rotary_dim</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache"],
+    outputs=["output"],
+    rotary_embedding_dim=4,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+sin_cache_data = np.random.rand(2, 3, 2).astype(np.float32)
+cos_cache_data = np.random.rand(2, 3, 2).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    rotary_embedding_dim=4,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_no_position_ids_rotary_dim",
+)
+```
+
+</details>
+<details>
+<summary>rotary_embedding_with_interleaved_rotary_dim</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+    rotary_embedding_dim=4,
+    interleaved=1,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 2).astype(np.float32)
+cos_cache_data = np.random.rand(50, 2).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    position_ids=position_ids_data,
+    interleaved=1,
+    rotary_embedding_dim=4,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_with_interleaved_rotary_dim",
+)
+```
+
+</details>
+<details>
+<summary>rotary_embedding_with_rotary_dim</summary>
+
+```python
+node = onnx.helper.make_node(
+    "RotaryEmbedding",
+    inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+    outputs=["output"],
+    rotary_embedding_dim=4,
+)
+
+input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+sin_cache_data = np.random.rand(50, 2).astype(np.float32)
+cos_cache_data = np.random.rand(50, 2).astype(np.float32)
+
+expected_output = rotary_embedding(
+    input_data,
+    cos_cache_data,
+    sin_cache_data,
+    position_ids=position_ids_data,
+    rotary_embedding_dim=4,
+)
+
+expect(
+    node,
+    inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+    outputs=[expected_output],
+    name="test_rotary_embedding_with_rotary_dim",
+)
+```
+
+</details>
+
+
+### Round
+There are 1 test cases, listed as following:
+<details>
+<summary>round</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Round",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        0.1,
+        0.5,
+        0.9,
+        1.2,
+        1.5,
+        1.8,
+        2.3,
+        2.5,
+        2.7,
+        -1.1,
+        -1.5,
+        -1.9,
+        -2.2,
+        -2.5,
+        -2.8,
+    ]
+).astype(np.float32)
+
+# expected output
+y = np.array(
+    [
+        0.0,
+        0.0,
+        1.0,
+        1.0,
+        2.0,
+        2.0,
+        2.0,
+        2.0,
+        3.0,
+        -1.0,
+        -2.0,
+        -2.0,
+        -2.0,
+        -2.0,
+        -3.0,
+    ]
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_round")
+```
+
+</details>
+
+
+### STFT
+There are 1 test cases, listed as following:
+<details>
+<summary>stft</summary>
+
+```python
+signal = np.arange(0, 128, dtype=np.float32).reshape(1, 128, 1)
+length = np.array(16).astype(np.int64)
+onesided_length = (length >> 1) + 1
+step = np.array(8).astype(np.int64)
+
+no_window = ""  # optional input, not supplied
+node = onnx.helper.make_node(
+    "STFT",
+    inputs=["signal", "frame_step", no_window, "frame_length"],
+    outputs=["output"],
+)
+
+nstfts = ((signal.shape[1] - length) // step) + 1
+# [batch_size][frames][frame_length][2]
+output = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32)
+for i in range(nstfts):
+    start = i * step
+    stop = i * step + length
+    complex_out = np.fft.fft(signal[0, start:stop, 0])[0:onesided_length]
+    output[0, i] = np.stack((complex_out.real, complex_out.imag), axis=1)
+
+output = output.astype(signal.dtype)
+expect(node, inputs=[signal, step, length], outputs=[output], name="test_stft")
+
+node = onnx.helper.make_node(
+    "STFT",
+    inputs=["signal", "frame_step", "window"],
+    outputs=["output"],
+)
+
+# Test with window
+a0 = 0.5
+a1 = 0.5
+window = a0 + a1 * np.cos(
+    2 * np.pi * np.arange(0, length, 1, dtype=np.float32) / length
+)
+nstfts = 1 + (signal.shape[1] - window.shape[0]) // step
+
+# [batch_size][frames][frame_length][2]
+output = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32)
+for i in range(nstfts):
+    start = i * step
+    stop = i * step + length
+    complex_out = np.fft.fft(signal[0, start:stop, 0] * window)[
+        0:onesided_length
+    ]
+    output[0, i] = np.stack((complex_out.real, complex_out.imag), axis=1)
+window = window.astype(signal.dtype)
+output = output.astype(signal.dtype)
+expect(
+    node,
+    inputs=[signal, step, window],
+    outputs=[output],
+    name="test_stft_with_window",
+)
+```
+
+</details>
+
+
+### Scan
+There are 4 test cases, listed as following:
+<details>
+<summary>scan_8</summary>
+
+```python
+# Given an input sequence [x1, ..., xN], sum up its elements using a scan
+# returning the final state (x1+x2+...+xN) as well the scan_output
+# [x1, x1+x2, ..., x1+x2+...+xN]
+# Note: the first input (sequence_lens) is optional and omitted via "".
+node = onnx.parser.parse_node(
+    """
+    y, z = Scan ("", initial, x) <
+        num_scan_inputs = 1,
+        body = scan_body (float[2] sum_in, float[2] next)
+            => (float[2] sum_out, float[2] scan_out)
+        {
+            sum_out  = Add(sum_in, next)
+            scan_out = Identity(sum_out)
+        }
+    >
+    """
+)
+# create inputs for batch-size 1, sequence-length 3, inner dimension 2
+initial = np.array([0, 0]).astype(np.float32).reshape((1, 2))
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((1, 3, 2))
+# final state computed = [1 + 3 + 5, 2 + 4 + 6]
+y = np.array([9, 12]).astype(np.float32).reshape((1, 2))
+# scan-output computed
+z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((1, 3, 2))
+
+expect(
+    node,
+    inputs=[initial, x],
+    outputs=[y, z],
+    name="test_scan_sum",
+    opset_imports=[onnx.helper.make_opsetid("", 8)],
+)
+```
+
+</details>
+<details>
+<summary>scan_9</summary>
+
+```python
+# Given an input sequence [x1, ..., xN], sum up its elements using a scan
+# returning the final state (x1+x2+...+xN) as well the scan_output
+# [x1, x1+x2, ..., x1+x2+...+xN]
+node = onnx.parser.parse_node(
+    """
+    y, z = Scan (initial, x) <
+        num_scan_inputs = 1,
+        body = scan_body (float[2] sum_in, float[2] next)
+            => (float[2] sum_out, float[2] scan_out)
+        {
+            sum_out  = Add(sum_in, next)
+            scan_out = Identity(sum_out)
+        }
+    >
+    """
+)
+# create inputs for sequence-length 3, inner dimension 2
+initial = np.array([0, 0]).astype(np.float32).reshape((2,))
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((3, 2))
+# final state computed = [1 + 3 + 5, 2 + 4 + 6]
+y = np.array([9, 12]).astype(np.float32).reshape((2,))
+# scan-output computed
+z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((3, 2))
+
+expect(
+    node,
+    inputs=[initial, x],
+    outputs=[y, z],
+    name="test_scan9_sum",
+    opset_imports=[onnx.helper.make_opsetid("", 9)],
+)
+```
+
+</details>
+<details>
+<summary>scan_9_multi_state</summary>
+
+```python
+# Scan with two state variables: running sum and running product.
+# This exercises the case where num_loop_state_vars (2) differs from
+# num_scan_inputs (1).
+#
+# Body inputs:  sum_in (state), prod_in (state), next (scan)
+# Body outputs: sum_out (state), prod_out (state), scan_out (scan)
+node = onnx.parser.parse_node(
+    """
+    y_sum, y_prod, z = Scan (initial_sum, initial_prod, x) <
+        num_scan_inputs = 1,
+        body = scan_body (float[2] sum_in, float[2] prod_in, float[2] next)
+            => (float[2] sum_out, float[2] prod_out, float[2] scan_out)
+        {
+            sum_out  = Add(sum_in, next)
+            prod_out = Mul(prod_in, next)
+            scan_out = Identity(sum_out)
+        }
+    >
+    """
+)
+# x = [[1, 2], [3, 4], [5, 6]]
+initial_sum = np.array([0, 0]).astype(np.float32)
+initial_prod = np.array([1, 1]).astype(np.float32)
+x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((3, 2))
+# final sum = [1+3+5, 2+4+6] = [9, 12]
+y_sum = np.array([9, 12]).astype(np.float32)
+# final product = [1*3*5, 2*4*6] = [15, 48]
+y_prod = np.array([15, 48]).astype(np.float32)
+# scan output (running sum) = [[1,2], [4,6], [9,12]]
+z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((3, 2))
+
+expect(
+    node,
+    inputs=[initial_sum, initial_prod, x],
+    outputs=[y_sum, y_prod, z],
+    name="test_scan9_multi_state",
+    opset_imports=[onnx.helper.make_opsetid("", 9)],
+)
+```
+
+</details>
+<details>
+<summary>scan_9_scalar</summary>
+
+```python
+# Scan with scalar state and scan output to verify that output
+# shapes are not distorted (e.g. (T,) not (T, 1)).
+node = onnx.parser.parse_node(
+    """
+    y, z = Scan (initial, x) <
+        num_scan_inputs = 1,
+        body = scan_body (float sum_in, float next)
+            => (float sum_out, float scan_out)
+        {
+            sum_out  = Add(sum_in, next)
+            scan_out = Identity(sum_out)
+        }
+    >
+    """
+)
+initial = np.float32(0.0)
+x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+# final state = 1+2+3+4+5 = 15
+y = np.float32(15.0)
+# scan output = [1, 3, 6, 10, 15], shape (5,)
+z = np.array([1, 3, 6, 10, 15]).astype(np.float32)
+
+expect(
+    node,
+    inputs=[initial, x],
+    outputs=[y, z],
+    name="test_scan9_scalar",
+    opset_imports=[onnx.helper.make_opsetid("", 9)],
+)
+```
+
+</details>
+
+
+### Scatter
+There are 2 test cases, listed as following:
+<details>
+<summary>scatter_with_axis</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "Scatter",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 3]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter(data, indices, updates, axis=axis)
+# print(y) produces
+# [[1.0, 1.1, 3.0, 2.1, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_with_axis",
+    opset_imports=[helper.make_opsetid("", 10)],
+)
+```
+
+</details>
+<details>
+<summary>scatter_without_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Scatter",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+)
+data = np.zeros((3, 3), dtype=np.float32)
+indices = np.array([[1, 0, 2], [0, 2, 1]], dtype=np.int64)
+updates = np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]], dtype=np.float32)
+
+y = scatter(data, indices, updates)
+# print(y) produces
+# [[2.0, 1.1, 0.0],
+#  [1.0, 0.0, 2.2],
+#  [0.0, 2.1, 1.2]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_without_axis",
+    opset_imports=[helper.make_opsetid("", 10)],
+)
+```
+
+</details>
+
+
+### ScatterElements
+There are 7 test cases, listed as following:
+<details>
+<summary>scatter_elements_with_axis</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 3]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis)
+# print(y) produces
+# [[1.0, 1.1, 3.0, 2.1, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_axis",
+)
+```
+
+</details>
+<details>
+<summary>scatter_elements_with_duplicate_indices</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+    reduction="add",
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 1]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis, reduction="add")
+# print(y) produces
+# [[1.0, 5.2, 3.0, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_duplicate_indices",
+)
+```
+
+</details>
+<details>
+<summary>scatter_elements_with_negative_indices</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, -3]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis)
+# print(y) produces
+# [[1.0, 1.1, 2.1, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_negative_indices",
+)
+```
+
+</details>
+<details>
+<summary>scatter_elements_with_reduction_max</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+    reduction="max",
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 1]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis, reduction="max")
+# print(y) produces
+# [[1.0, 2.1, 3.0, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_reduction_max",
+)
+```
+
+</details>
+<details>
+<summary>scatter_elements_with_reduction_min</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+    reduction="min",
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 1]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis, reduction="min")
+# print(y) produces
+# [[1.0, 1.1, 3.0, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_reduction_min",
+)
+```
+
+</details>
+<details>
+<summary>scatter_elements_with_reduction_mul</summary>
+
+```python
+axis = 1
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    axis=axis,
+    reduction="mul",
+)
+data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+indices = np.array([[1, 1]], dtype=np.int64)
+updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates, axis, reduction="mul")
+# print(y) produces
+# [[1.0, 4.62, 3.0, 4.0, 5.0]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_with_reduction_mul",
+)
+```
+
+</details>
+<details>
+<summary>scatter_elements_without_axis</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterElements",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+)
+data = np.zeros((3, 3), dtype=np.float32)
+indices = np.array([[1, 0, 2], [0, 2, 1]], dtype=np.int64)
+updates = np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]], dtype=np.float32)
+
+y = scatter_elements(data, indices, updates)
+# print(y) produces
+# [[2.0, 1.1, 0.0],
+#  [1.0, 0.0, 2.2],
+#  [0.0, 2.1, 1.2]]
+
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[y],
+    name="test_scatter_elements_without_axis",
+)
+```
+
+</details>
+
+
+### ScatterND
+There are 7 test cases, listed as following:
+<details>
+<summary>scatternd</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [2]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates)
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd",
+)
+```
+
+</details>
+<details>
+<summary>scatternd_add</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="add",
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [0]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[7, 8, 9, 10], [13, 14, 15, 16], [18, 17, 16, 15], [16, 15, 14, 13]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="add")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_add",
+)
+```
+
+</details>
+<details>
+<summary>scatternd_max</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="max",
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [0]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[5, 5, 5, 5], [6, 6, 7, 8], [8, 7, 7, 7], [8, 8 ,8, 8]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="max")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_max",
+)
+```
+
+</details>
+<details>
+<summary>scatternd_max_with_element_indices</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="max",
+)
+data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+# Indices address individual elements (index rank == data rank),
+# which exercises the reduction at the element level.
+indices = np.array([[0, 0], [1, 1]], dtype=np.int64)
+updates = np.array([5, 1], dtype=np.float32)
+# Expecting output as np.array([[5, 2], [3, 4]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="max")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_max_with_element_indices",
+)
+```
+
+</details>
+<details>
+<summary>scatternd_min</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="min",
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [0]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 3, 2, 1]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="min")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_min",
+)
+```
+
+</details>
+<details>
+<summary>scatternd_min_with_element_indices</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="min",
+)
+data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+indices = np.array([[0, 0], [1, 1]], dtype=np.int64)
+updates = np.array([5, 1], dtype=np.float32)
+# Expecting output as np.array([[1, 2], [3, 1]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="min")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_min_with_element_indices",
+)
+```
+
+</details>
+<details>
+<summary>scatternd_multiply</summary>
+
+```python
+node = onnx.helper.make_node(
+    "ScatterND",
+    inputs=["data", "indices", "updates"],
+    outputs=["y"],
+    reduction="mul",
+)
+data = np.array(
+    [
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+        [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+    ],
+    dtype=np.float32,
+)
+indices = np.array([[0], [0]], dtype=np.int64)
+updates = np.array(
+    [
+        [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+    ],
+    dtype=np.float32,
+)
+# Expecting output as np.array(
+#    [[[5, 10, 15, 20], [60, 72, 84, 96], [168, 147, 126, 105], [128, 96, 64, 32]],
+#     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+#     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+#     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+output = scatter_nd_impl(data, indices, updates, reduction="mul")
+expect(
+    node,
+    inputs=[data, indices, updates],
+    outputs=[output],
+    name="test_scatternd_multiply",
+)
+```
+
+</details>
+
+
+### Selu
+There are 2 test cases, listed as following:
+<details>
+<summary>selu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Selu", inputs=["x"], outputs=["y"], alpha=2.0, gamma=3.0
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+# expected output [-3.79272318, 0., 3.]
+y = (
+    np.clip(x, 0, np.inf) * 3.0
+    + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 * 3.0
+)
+expect(node, inputs=[x], outputs=[y], name="test_selu_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = (
+    np.clip(x, 0, np.inf) * 3.0
+    + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 * 3.0
+)
+expect(node, inputs=[x], outputs=[y], name="test_selu")
+```
+
+</details>
+<details>
+<summary>selu_default</summary>
+
+```python
+default_alpha = 1.67326319217681884765625
+default_gamma = 1.05070102214813232421875
+node = onnx.helper.make_node(
+    "Selu",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = (
+    np.clip(x, 0, np.inf) * default_gamma
+    + (np.exp(np.clip(x, -np.inf, 0)) - 1) * default_alpha * default_gamma
+)
+expect(node, inputs=[x], outputs=[y], name="test_selu_default")
+```
+
+</details>
+
+
+### SequenceInsert
+There are 1 test cases, listed as following:
+<details>
+<summary>sequenceinsert</summary>
+
+```python
+test_cases = {
+    "at_back": [np.array([10, 11, 12]).astype(np.int64)],
+    "at_front": [np.array([-2, -1, 0]), np.array([0]).astype(np.int64)],
+}
+sequence = [
+    np.array([1, 2, 3, 4]).astype(np.int64),
+    np.array([5, 6, 7]).astype(np.int64),
+    np.array([8, 9]).astype(np.int64),
+]
+
+for test_name, test_inputs in test_cases.items():
+    tensor = test_inputs[0].astype(np.int64)
+
+    if len(test_inputs) > 1:
+        node = onnx.helper.make_node(
+            "SequenceInsert",
+            inputs=["sequence", "tensor", "position"],
+            outputs=["output_sequence"],
+        )
+        position = test_inputs[1]
+        inserted = sequence_insert_reference_implementation(
+            sequence, tensor, position
+        )
+        expect(
+            node,
+            inputs=[sequence, tensor, position],
+            outputs=[inserted],
+            name="test_sequence_insert_" + test_name,
+        )
+    else:
+        node = onnx.helper.make_node(
+            "SequenceInsert",
+            inputs=["sequence", "tensor"],
+            outputs=["output_sequence"],
+        )
+        inserted = sequence_insert_reference_implementation(sequence, tensor)
+        expect(
+            node,
+            inputs=[sequence, tensor],
+            outputs=[inserted],
+            name="test_sequence_insert_" + test_name,
+        )
+```
+
+</details>
+
+
+### SequenceMap
+There are 6 test cases, listed as following:
+<details>
+<summary>sequence_map_add_1_sequence_1_tensor</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [onnx.helper.make_node("Add", ["in0", "in1"], ["out0"])],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "in0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "in1", onnx.TensorProto.FLOAT, ["N"]
+        ),
+    ],
+    [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["N"])],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x0", "x1"], outputs=["y0"], body=body
+)
+
+x0 = [np.random.uniform(0.0, 1.0, 10).astype(np.float32) for k in range(3)]
+x1 = np.random.uniform(0.0, 1.0, 10).astype(np.float32)
+y0 = [x0[i] + x1 for i in range(3)]
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+expect(
+    node,
+    inputs=[x0, x1],
+    outputs=[y0],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_add_1_sequence_1_tensor",
+)
+```
+
+</details>
+<details>
+<summary>sequence_map_add_2_sequences</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [onnx.helper.make_node("Add", ["in0", "in1"], ["out0"])],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "in0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "in1", onnx.TensorProto.FLOAT, ["N"]
+        ),
+    ],
+    [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["N"])],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x0", "x1"], outputs=["y0"], body=body
+)
+
+N = [np.random.randint(1, 10) for _ in range(3)]
+x0 = [np.random.uniform(0.0, 1.0, N[k]).astype(np.float32) for k in range(3)]
+x1 = [np.random.uniform(0.0, 1.0, N[k]).astype(np.float32) for k in range(3)]
+y0 = [x0[k] + x1[k] for k in range(3)]
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+expect(
+    node,
+    inputs=[x0, x1],
+    outputs=[y0],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_add_2_sequences",
+)
+```
+
+</details>
+<details>
+<summary>sequence_map_extract_shapes</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [onnx.helper.make_node("Shape", ["x"], ["shape"])],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "x", onnx.TensorProto.FLOAT, ["H", "W", "C"]
+        )
+    ],
+    [onnx.helper.make_tensor_value_info("shape", onnx.TensorProto.INT64, [3])],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["in_seq"], outputs=["shapes"], body=body
+)
+
+shapes = [
+    np.array([40, 30, 3], dtype=np.int64),
+    np.array([20, 10, 3], dtype=np.int64),
+    np.array([10, 5, 3], dtype=np.int64),
+]
+x0 = [np.zeros(shape, dtype=np.float32) for shape in shapes]
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.FLOAT, ["H", "W", "C"]
+        )
+    ),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.INT64, [3])
+    ),
+]
+expect(
+    node,
+    inputs=[x0],
+    outputs=[shapes],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_extract_shapes",
+)
+```
+
+</details>
+<details>
+<summary>sequence_map_identity_1_sequence</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [onnx.helper.make_node("Identity", ["in0"], ["out0"])],
+    "seq_map_body",
+    [onnx.helper.make_tensor_value_info("in0", onnx.TensorProto.FLOAT, ["N"])],
+    [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["M"])],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x"], outputs=["y"], body=body
+)
+
+x = [np.random.uniform(0.0, 1.0, 10).astype(np.float32) for _ in range(3)]
+y = x
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+]
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_identity_1_sequence",
+)
+```
+
+</details>
+<details>
+<summary>sequence_map_identity_1_sequence_1_tensor</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [
+        onnx.helper.make_node("Identity", ["in0"], ["out0"]),
+        onnx.helper.make_node("Identity", ["in1"], ["out1"]),
+    ],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "in0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "in1", onnx.TensorProto.FLOAT, ["M"]
+        ),
+    ],
+    [
+        onnx.helper.make_tensor_value_info(
+            "out0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "out1", onnx.TensorProto.FLOAT, ["M"]
+        ),
+    ],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x0", "x1"], outputs=["y0", "y1"], body=body
+)
+
+x0 = [
+    np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+    for _ in range(3)
+]
+x1 = np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+y0 = x0
+y1 = [x1 for _ in range(3)]
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"]),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"])
+    ),
+]
+expect(
+    node,
+    inputs=[x0, x1],
+    outputs=[y0, y1],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_identity_1_sequence_1_tensor",
+)
+```
+
+</details>
+<details>
+<summary>sequence_map_identity_2_sequences</summary>
+
+```python
+body = onnx.helper.make_graph(
+    [
+        onnx.helper.make_node("Identity", ["in0"], ["out0"]),
+        onnx.helper.make_node("Identity", ["in1"], ["out1"]),
+    ],
+    "seq_map_body",
+    [
+        onnx.helper.make_tensor_value_info(
+            "in0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "in1", onnx.TensorProto.FLOAT, ["M"]
+        ),
+    ],
+    [
+        onnx.helper.make_tensor_value_info(
+            "out0", onnx.TensorProto.FLOAT, ["N"]
+        ),
+        onnx.helper.make_tensor_value_info(
+            "out1", onnx.TensorProto.FLOAT, ["M"]
+        ),
+    ],
+)
+
+node = onnx.helper.make_node(
+    "SequenceMap", inputs=["x0", "x1"], outputs=["y0", "y1"], body=body
+)
+
+x0 = [
+    np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+    for _ in range(3)
+]
+x1 = [
+    np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+    for _ in range(3)
+]
+y0 = x0
+y1 = x1
+input_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"])
+    ),
+]
+output_type_protos = [
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+    ),
+    onnx.helper.make_sequence_type_proto(
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"])
+    ),
+]
+expect(
+    node,
+    inputs=[x0, x1],
+    outputs=[y0, y1],
+    input_type_protos=input_type_protos,
+    output_type_protos=output_type_protos,
+    name="test_sequence_map_identity_2_sequences",
+)
+```
+
+</details>
+
+
+### Shape
+There are 1 test cases, listed as following:
+<details>
+<summary>shape</summary>
+
+```python
+x = np.array(
+    [
+        [1, 2, 3],
+        [4, 5, 6],
+    ]
+).astype(np.float32)
+test_shape("_example", x)  # preserve names of original test cases
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+
+test_shape("", x)  # preserve names of original test cases
+
+test_shape("_start_1", x, start=1)
+
+test_shape("_end_1", x, end=1)
+
+test_shape("_start_negative_1", x, start=-1)
+
+test_shape("_end_negative_1", x, end=-1)
+
+test_shape("_start_1_end_negative_1", x, start=1, end=-1)
+
+test_shape("_start_1_end_2", x, start=1, end=2)
+
+test_shape("_clip_start", x, start=-10)
+
+test_shape("_clip_end", x, end=10)
+
+test_shape("_start_greater_than_end", x, start=2, end=1)
+```
+
+</details>
+
+
+### Shrink
+There are 2 test cases, listed as following:
+<details>
+<summary>hard_shrink</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Shrink",
+    inputs=["x"],
+    outputs=["y"],
+    lambd=1.5,
+)
+X = np.arange(-2.0, 2.1, dtype=np.float32)
+Y = np.array([-2, 0, 0, 0, 2], dtype=np.float32)
+expect(node, inputs=[X], outputs=[Y], name="test_shrink_hard")
+```
+
+</details>
+<details>
+<summary>soft_shrink</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Shrink",
+    inputs=["x"],
+    outputs=["y"],
+    lambd=1.5,
+    bias=1.5,
+)
+X = np.arange(-2.0, 2.1, dtype=np.float32)
+Y = np.array([-0.5, 0, 0, 0, 0.5], dtype=np.float32)
+expect(node, inputs=[X], outputs=[Y], name="test_shrink_soft")
+```
+
+</details>
+
+
+### Sigmoid
+There are 1 test cases, listed as following:
+<details>
+<summary>sigmoid</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sigmoid",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = 1.0 / (
+    1.0 + np.exp(np.negative(x))
+)  # expected output [0.26894143, 0.5, 0.7310586]
+expect(node, inputs=[x], outputs=[y], name="test_sigmoid_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = 1.0 / (1.0 + np.exp(np.negative(x)))
+expect(node, inputs=[x], outputs=[y], name="test_sigmoid")
+```
+
+</details>
+
+
+### Sign
+There are 1 test cases, listed as following:
+<details>
+<summary>sign</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sign",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array(range(-5, 6)).astype(np.float32)
+y = np.sign(x)
+expect(node, inputs=[x], outputs=[y], name="test_sign")
+```
+
+</details>
+
+
+### Sin
+There are 1 test cases, listed as following:
+<details>
+<summary>sin</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sin",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.sin(x)
+expect(node, inputs=[x], outputs=[y], name="test_sin_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.sin(x)
+expect(node, inputs=[x], outputs=[y], name="test_sin")
+```
+
+</details>
+
+
+### Sinh
+There are 1 test cases, listed as following:
+<details>
+<summary>sinh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sinh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.sinh(x)  # expected output [-1.17520118,  0.,  1.17520118]
+expect(node, inputs=[x], outputs=[y], name="test_sinh_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.sinh(x)
+expect(node, inputs=[x], outputs=[y], name="test_sinh")
+```
+
+</details>
+
+
+### Size
+There are 1 test cases, listed as following:
+<details>
+<summary>size</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Size",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array(
+    [
+        [1, 2, 3],
+        [4, 5, 6],
+    ]
+).astype(np.float32)
+y = np.array(6).astype(np.int64)
+
+expect(node, inputs=[x], outputs=[y], name="test_size_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.array(x.size).astype(np.int64)
+
+expect(node, inputs=[x], outputs=[y], name="test_size")
+```
+
+</details>
+
+
+### Slice
+There are 8 test cases, listed as following:
+<details>
+<summary>slice</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+y = x[0:3, 0:10]
+starts = np.array([0, 0], dtype=np.int64)
+ends = np.array([3, 10], dtype=np.int64)
+axes = np.array([0, 1], dtype=np.int64)
+steps = np.array([1, 1], dtype=np.int64)
+
+expect(
+    node, inputs=[x, starts, ends, axes, steps], outputs=[y], name="test_slice"
+)
+```
+
+</details>
+<details>
+<summary>slice_default_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([0, 0, 3], dtype=np.int64)
+ends = np.array([20, 10, 4], dtype=np.int64)
+y = x[:, :, 3:4]
+
+expect(
+    node, inputs=[x, starts, ends], outputs=[y], name="test_slice_default_axes"
+)
+```
+
+</details>
+<details>
+<summary>slice_default_steps</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([0, 0, 3], dtype=np.int64)
+ends = np.array([20, 10, 4], dtype=np.int64)
+axes = np.array([0, 1, 2], dtype=np.int64)
+y = x[:, :, 3:4]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes],
+    outputs=[y],
+    name="test_slice_default_steps",
+)
+```
+
+</details>
+<details>
+<summary>slice_end_out_of_bounds</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([1], dtype=np.int64)
+ends = np.array([1000], dtype=np.int64)
+axes = np.array([1], dtype=np.int64)
+steps = np.array([1], dtype=np.int64)
+y = x[:, 1:1000]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes, steps],
+    outputs=[y],
+    name="test_slice_end_out_of_bounds",
+)
+```
+
+</details>
+<details>
+<summary>slice_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([0], dtype=np.int64)
+ends = np.array([-1], dtype=np.int64)
+axes = np.array([1], dtype=np.int64)
+steps = np.array([1], dtype=np.int64)
+y = x[:, 0:-1]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes, steps],
+    outputs=[y],
+    name="test_slice_neg",
+)
+```
+
+</details>
+<details>
+<summary>slice_neg_steps</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([20, 10, 4], dtype=np.int64)
+ends = np.array([0, 0, 1], dtype=np.int64)
+axes = np.array([0, 1, 2], dtype=np.int64)
+steps = np.array([-1, -3, -2]).astype(np.int64)
+y = x[20:0:-1, 10:0:-3, 4:1:-2]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes, steps],
+    outputs=[y],
+    name="test_slice_neg_steps",
+)
+```
+
+</details>
+<details>
+<summary>slice_negative_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([0, 0, 3], dtype=np.int64)
+ends = np.array([20, 10, 4], dtype=np.int64)
+axes = np.array([0, -2, -1], dtype=np.int64)
+y = x[:, :, 3:4]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes],
+    outputs=[y],
+    name="test_slice_negative_axes",
+)
+```
+
+</details>
+<details>
+<summary>slice_start_out_of_bounds</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Slice",
+    inputs=["x", "starts", "ends", "axes", "steps"],
+    outputs=["y"],
+)
+
+x = np.random.randn(20, 10, 5).astype(np.float32)
+starts = np.array([1000], dtype=np.int64)
+ends = np.array([1000], dtype=np.int64)
+axes = np.array([1], dtype=np.int64)
+steps = np.array([1], dtype=np.int64)
+y = x[:, 1000:1000]
+
+expect(
+    node,
+    inputs=[x, starts, ends, axes, steps],
+    outputs=[y],
+    name="test_slice_start_out_of_bounds",
+)
+```
+
+</details>
+
+
+### Softmax
+There are 2 test cases, listed as following:
+<details>
+<summary>softmax</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+x = np.array([[-1, 0, 1]]).astype(np.float32)
+# expected output [[0.09003058, 0.24472848, 0.66524094]]
+y = softmax(x, axis=1)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_example")
+```
+
+</details>
+<details>
+<summary>softmax_axis</summary>
+
+```python
+x = np.array([[0, 1, 2, 3], [10000, 10001, 10002, 10003]]).astype(np.float32)
+# expected output
+# [[0.032058604 0.08714432  0.23688284  0.6439143  ]
+# [0.032058604 0.08714432  0.23688284  0.6439143  ]]
+y = softmax(x)
+
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_large_number")
+
+x = np.abs(np.random.randn(3, 4, 5).astype(np.float32))
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=0,
+)
+y = softmax(x, axis=0)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_0")
+
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=1,
+)
+y = softmax(x, axis=1)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_1")
+
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=2,
+)
+y = softmax(x, axis=2)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_2")
+
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+    axis=-1,
+)
+y = softmax(x, axis=-1)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_negative_axis")
+
+# default axis is -1
+node = onnx.helper.make_node(
+    "Softmax",
+    inputs=["x"],
+    outputs=["y"],
+)
+expect(node, inputs=[x], outputs=[y], name="test_softmax_default_axis")
+```
+
+</details>
+
+
+### SoftmaxCrossEntropyLoss
+There are 34 test cases, listed as following:
+<details>
+<summary>input_shape_is_NCd1_mean_weight_negative_ii</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(-1)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1 = 3, 5, 6
+np.random.seed(0)
+x = np.random.rand(N, C, dim1).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64)
+labels[0][0] = -1
+weight = np.random.rand(C).astype(np.float32)
+
+sce = softmaxcrossentropy(
+    x, labels, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[sce],
+    name="test_sce_NCd1_mean_weight_negative_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1_mean_weight_negative_ii_log_prob</summary>
+
+```python
+reduction = "mean"
+ignore_index = np.int64(-1)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1 = 3, 5, 6
+np.random.seed(0)
+x = np.random.rand(N, C, dim1).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64)
+labels[0][0] = -1
+weight = np.random.rand(C).astype(np.float32)
+
+loss, log_prob = softmaxcrossentropy(
+    x,
+    labels,
+    weight=weight,
+    reduction=reduction,
+    ignore_index=ignore_index,
+    get_log_prob=True,
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1_mean_weight_negative_ii_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3_none_no_weight_negative_ii</summary>
+
+```python
+reduction = "none"
+ignore_index = np.int64(-5)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype(
+    np.int64
+)
+labels[0][0][0][0] = -5
+
+sce = softmaxcrossentropy(
+    x, labels, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[sce],
+    name="test_sce_NCd1d2d3_none_no_weight_negative_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3_none_no_weight_negative_ii_log_prob</summary>
+
+```python
+reduction = "none"
+ignore_index = np.int64(-5)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype(
+    np.int64
+)
+labels[0][0][0][0] = -5
+
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction=reduction, ignore_index=ignore_index, get_log_prob=True
+)
+
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3_sum_weight_high_ii</summary>
+
+```python
+reduction = "sum"
+ignore_index = np.int64(10)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C = 3, 5
+np.random.seed(0)
+x = np.random.rand(N, C).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N)).astype(np.int64)
+labels[0] = 10
+weight = np.random.rand(C).astype(np.float32)
+
+sce = softmaxcrossentropy(
+    x, labels, weight=weight, reduction=reduction, ignore_index=ignore_index
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[sce],
+    name="test_sce_NCd1d2d3_sum_weight_high_ii",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3_sum_weight_high_ii_log_prob</summary>
+
+```python
+reduction = "sum"
+ignore_index = np.int64(10)
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+N, C = 3, 5
+np.random.seed(0)
+x = np.random.rand(N, C).astype(np.float32)
+labels = np.random.randint(0, high=C, size=(N)).astype(np.int64)
+labels[0] = 10
+weight = np.random.rand(C).astype(np.float32)
+
+loss, log_prob = softmaxcrossentropy(
+    x,
+    labels,
+    weight=weight,
+    reduction=reduction,
+    ignore_index=ignore_index,
+    get_log_prob=True,
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1d2d3_sum_weight_high_ii_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_mean_weight</summary>
+
+```python
+reduction = "mean"
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+labels = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+sce = softmaxcrossentropy(x, labels, weight=weight, reduction=reduction)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[sce],
+    name="test_sce_NCd1d2d3d4d5_mean_weight",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_mean_weight_log_prob</summary>
+
+```python
+reduction = "mean"
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+labels = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+weight = np.random.rand(C).astype(np.float32)
+
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weight, reduction=reduction, get_log_prob=True
+)
+
+expect(
+    node,
+    inputs=[x, labels, weight],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1d2d3d4d5_mean_weight_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_none_no_weight</summary>
+
+```python
+reduction = "none"
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+labels = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+
+sce = softmaxcrossentropy(x, labels, reduction=reduction)
+
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[sce],
+    name="test_sce_NCd1d2d3d4d5_none_no_weight",
+)
+```
+
+</details>
+<details>
+<summary>input_shape_is_NCd1d2d3d4d5_none_no_weight_log_prob</summary>
+
+```python
+reduction = "none"
+
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+np.random.seed(0)
+x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+labels = np.random.randint(
+    0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+).astype(np.int64)
+
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction=reduction, get_log_prob=True
+)
+
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_NCd1d2d3d4d5_none_no_weight_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels)
+
+# Check results
+expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_mean")
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_3d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+y = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, y)
+
+# Check results
+expect(node, inputs=[x, y], outputs=[sce], name="test_sce_mean_3d")
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_3d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+y = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(x, y, get_log_prob=True)
+
+# Check results
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_3d_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(x, labels, get_log_prob=True)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+labels[0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, ignore_index=ignore_index)
+
+# Check results
+expect(
+    node, inputs=[x, labels], outputs=[sce], name="test_sce_mean_no_weight_ii"
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_3d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+labels[0][0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, ignore_index=ignore_index)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[sce],
+    name="test_sce_mean_no_weight_ii_3d",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_3d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+labels[0][0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_no_weight_ii_3d_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_4d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+labels[0][0][0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(
+    x, labels, reduction=reduction, ignore_index=ignore_index
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[sce],
+    name="test_sce_mean_no_weight_ii_4d",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_4d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+labels[0][0][0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction=reduction, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_no_weight_ii_4d_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_no_weights_ii_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+labels[0] = np.int64(2)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_no_weight_ii_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_weights</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, weight=weights)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_mean_weight",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(0)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+labels[0] = np.int64(0)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, weight=weights, ignore_index=ignore_index)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_mean_weight_ii",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_3d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(1)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+labels[0][0] = np.int64(1)
+weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, weight=weights, ignore_index=ignore_index)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_mean_weight_ii_3d",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_3d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(1)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+labels[0][0] = np.int64(1)
+weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weights, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_weight_ii_3d_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_4d</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+labels[0][0][0] = np.int64(2)
+weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(
+    x, labels, reduction=reduction, weight=weights, ignore_index=ignore_index
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_mean_weight_ii_4d",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_4d_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(2)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+labels[0][0][0] = np.int64(2)
+weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x,
+    labels,
+    reduction=reduction,
+    weight=weights,
+    ignore_index=ignore_index,
+    get_log_prob=True,
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_weight_ii_4d_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_weights_ii_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+ignore_index = np.int64(0)
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+    ignore_index=ignore_index,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+labels[0] = np.int64(0)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weights, ignore_index=ignore_index, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_weight_ii_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_mean_weights_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "mean"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weights, get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_mean_weight_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_none</summary>
+
+```python
+# Define operator attributes.
+reduction = "none"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, reduction="none")
+
+# Check results
+expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_none")
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_none_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "none"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction="none", get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_none_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_none_weights</summary>
+
+```python
+# Define operator attributes.
+reduction = "none"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, weight=weights, reduction="none")
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[sce],
+    name="test_sce_none_weights",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_none_weights_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "none"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y", "w"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, weight=weights, reduction="none", get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels, weights],
+    outputs=[loss, log_prob],
+    name="test_sce_none_weights_log_prob",
+)
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_sum</summary>
+
+```python
+# Define operator attributes.
+reduction = "sum"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+sce = softmaxcrossentropy(x, labels, reduction="sum")
+
+# Check results
+expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_sum")
+```
+
+</details>
+<details>
+<summary>softmaxcrossentropy_sum_log_prob</summary>
+
+```python
+# Define operator attributes.
+reduction = "sum"
+
+# Create operator.
+node = onnx.helper.make_node(
+    "SoftmaxCrossEntropyLoss",
+    inputs=["x", "y"],
+    outputs=["z", "log_prob"],
+    reduction=reduction,
+)
+
+# Define operator inputs.
+np.random.seed(0)
+x = np.random.rand(3, 5).astype(np.float32)
+labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+# Compute SoftmaxCrossEntropyLoss
+loss, log_prob = softmaxcrossentropy(
+    x, labels, reduction="sum", get_log_prob=True
+)
+
+# Check results
+expect(
+    node,
+    inputs=[x, labels],
+    outputs=[loss, log_prob],
+    name="test_sce_sum_log_prob",
+)
+```
+
+</details>
+
+
+### Softplus
+There are 1 test cases, listed as following:
+<details>
+<summary>softplus</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Softplus",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.log(
+    np.exp(x) + 1
+)  # expected output [0.31326166, 0.69314718, 1.31326163]
+expect(node, inputs=[x], outputs=[y], name="test_softplus_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.log(np.exp(x) + 1)
+expect(node, inputs=[x], outputs=[y], name="test_softplus")
+```
+
+</details>
+
+
+### Softsign
+There are 1 test cases, listed as following:
+<details>
+<summary>softsign</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Softsign",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.array([-0.5, 0, 0.5]).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_softsign_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = x / (1 + np.abs(x))
+expect(node, inputs=[x], outputs=[y], name="test_softsign")
+```
+
+</details>
+
+
+### SpaceToDepth
+There are 2 test cases, listed as following:
+<details>
+<summary>example</summary>
+
+```python
+node = onnx.helper.make_node(
+    "SpaceToDepth",
+    inputs=["x"],
+    outputs=["y"],
+    blocksize=2,
+)
+
+# (1, 1, 4, 6) input tensor
+x = np.array(
+    [
+        [
+            [
+                [0, 6, 1, 7, 2, 8],
+                [12, 18, 13, 19, 14, 20],
+                [3, 9, 4, 10, 5, 11],
+                [15, 21, 16, 22, 17, 23],
+            ]
+        ]
+    ]
+).astype(np.float32)
+
+# (1, 4, 2, 3) output tensor
+y = np.array(
+    [
+        [
+            [[0, 1, 2], [3, 4, 5]],
+            [[6, 7, 8], [9, 10, 11]],
+            [[12, 13, 14], [15, 16, 17]],
+            [[18, 19, 20], [21, 22, 23]],
+        ]
+    ]
+).astype(np.float32)
+expect(node, inputs=[x], outputs=[y], name="test_spacetodepth_example")
+```
+
+</details>
+<details>
+<summary>spacetodepth</summary>
+
+```python
+b, c, h, w = shape = (2, 2, 6, 6)
+blocksize = 2
+node = onnx.helper.make_node(
+    "SpaceToDepth",
+    inputs=["x"],
+    outputs=["y"],
+    blocksize=blocksize,
+)
+x = np.random.random_sample(shape).astype(np.float32)
+tmp = np.reshape(
+    x, [b, c, h // blocksize, blocksize, w // blocksize, blocksize]
+)
+tmp = np.transpose(tmp, [0, 3, 5, 1, 2, 4])
+y = np.reshape(tmp, [b, c * (blocksize**2), h // blocksize, w // blocksize])
+expect(node, inputs=[x], outputs=[y], name="test_spacetodepth")
+```
+
+</details>
+
+
+### Split
+There are 10 test cases, listed as following:
+<details>
+<summary>1d_opset13</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3"],
+    axis=0,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_1d_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2"],
+    axis=0,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_1d_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+<details>
+<summary>1d_opset18</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3"],
+    axis=0,
+    num_outputs=3,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_1d_opset18",
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2"],
+    axis=0,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_1d_opset18",
+)
+```
+
+</details>
+<details>
+<summary>1d_uneven_split_opset18</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]).astype(np.float32)
+
+# If axis is not specified, split is applied on default axis 0
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3", "output_4"],
+    num_outputs=4,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+    np.array([7.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_1d_uneven_split_opset18",
+)
+```
+
+</details>
+<details>
+<summary>2d_opset13</summary>
+
+```python
+node_input = np.array(
+    [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split", inputs=["input"], outputs=["output_1", "output_2"], axis=1
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0, 3.0], [7.0, 8.0, 9.0]]).astype(np.float32),
+    np.array([[4.0, 5.0, 6.0], [10.0, 11.0, 12.0]]).astype(np.float32),
+]
+
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_2d_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2"],
+    axis=1,
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0], [7.0, 8.0]]).astype(np.float32),
+    np.array([[3.0, 4.0, 5.0, 6.0], [9.0, 10.0, 11.0, 12.0]]).astype(
+        np.float32
+    ),
+]
+
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_2d_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+<details>
+<summary>2d_opset18</summary>
+
+```python
+node_input = np.array(
+    [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2"],
+    axis=1,
+    num_outputs=2,
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0, 3.0], [7.0, 8.0, 9.0]]).astype(np.float32),
+    np.array([[4.0, 5.0, 6.0], [10.0, 11.0, 12.0]]).astype(np.float32),
+]
+
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_2d",
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2"],
+    axis=1,
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0], [7.0, 8.0]]).astype(np.float32),
+    np.array([[3.0, 4.0, 5.0, 6.0], [9.0, 10.0, 11.0, 12.0]]).astype(
+        np.float32
+    ),
+]
+
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_2d_opset18",
+)
+```
+
+</details>
+<details>
+<summary>2d_uneven_split_opset18</summary>
+
+```python
+node_input = np.array(
+    [
+        [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
+        [9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0],
+    ]
+).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3"],
+    axis=1,
+    num_outputs=3,
+)
+
+expected_outputs = [
+    np.array([[1.0, 2.0, 3.0], [9.0, 10.0, 11.0]]).astype(np.float32),
+    np.array([[4.0, 5.0, 6.0], [12.0, 13.0, 14.0]]).astype(np.float32),
+    np.array([[7.0, 8.0], [15.0, 16.0]]).astype(np.float32),
+]
+
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_2d_uneven_split_opset18",
+)
+```
+
+</details>
+<details>
+<summary>default_values_opset13</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+# If axis is not specified, split is applied on default axis 0
+node = onnx.helper.make_node(
+    "Split", inputs=["input"], outputs=["output_1", "output_2", "output_3"]
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_default_axis_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split", inputs=["input", "split"], outputs=["output_1", "output_2"]
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_default_axis_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+<details>
+<summary>default_values_opset18</summary>
+
+```python
+node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+# If axis is not specified, split is applied on default axis 0
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input"],
+    outputs=["output_1", "output_2", "output_3"],
+    num_outputs=3,
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0]).astype(np.float32),
+    np.array([5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input],
+    outputs=expected_outputs,
+    name="test_split_equal_parts_default_axis_opset18",
+)
+
+split = np.array([2, 4]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split", inputs=["input", "split"], outputs=["output_1", "output_2"]
+)
+
+expected_outputs = [
+    np.array([1.0, 2.0]).astype(np.float32),
+    np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_variable_parts_default_axis_opset18",
+)
+```
+
+</details>
+<details>
+<summary>zero_size_splits_opset13</summary>
+
+```python
+# 1-dimensional tensor with dimension_size=0
+node_input = np.array([]).astype(np.float32)
+
+# Split empty tensor to tensors of size zero
+split = np.array([0, 0, 0]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2", "output_3"],
+)
+
+expected_outputs = [
+    np.array([]).astype(np.float32),
+    np.array([]).astype(np.float32),
+    np.array([]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_zero_size_splits_opset13",
+    opset_imports=[onnx.helper.make_opsetid("", 13)],
+)
+```
+
+</details>
+<details>
+<summary>zero_size_splits_opset18</summary>
+
+```python
+# 1-dimensional tensor with dimension_size=0
+node_input = np.array([]).astype(np.float32)
+
+# Split empty tensor to tensors of size zero
+split = np.array([0, 0, 0]).astype(np.int64)
+node = onnx.helper.make_node(
+    "Split",
+    inputs=["input", "split"],
+    outputs=["output_1", "output_2", "output_3"],
+)
+
+expected_outputs = [
+    np.array([]).astype(np.float32),
+    np.array([]).astype(np.float32),
+    np.array([]).astype(np.float32),
+]
+expect(
+    node,
+    inputs=[node_input, split],
+    outputs=expected_outputs,
+    name="test_split_zero_size_splits_opset18",
+)
+```
+
+</details>
+
+
+### SplitToSequence
+There are 3 test cases, listed as following:
+<details>
+<summary>nokeepdims</summary>
+
+```python
+data = np.arange(18).reshape((3, 6)).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "SplitToSequence",
+    ["data"],
+    ["seq"],
+    axis=1,
+    keepdims=0,
+)
+
+expected_outputs = [[data[:, i] for i in range(data.shape[1])]]
+
+expect(
+    node,
+    inputs=[data],
+    outputs=expected_outputs,
+    name="test_split_to_sequence_nokeepdims",
+)
+```
+
+</details>
+<details>
+<summary>with_split_1</summary>
+
+```python
+data = np.arange(18).reshape((3, 6)).astype(np.float32)
+split = np.array(2, dtype=np.int64)
+
+node = onnx.helper.make_node(
+    "SplitToSequence", ["data", "split"], ["seq"], axis=1
+)
+
+expected_outputs = [
+    [
+        np.array([[0.0, 1.0], [6.0, 7.0], [12.0, 13.0]], dtype=np.float32),
+        np.array([[2.0, 3.0], [8.0, 9.0], [14.0, 15.0]], dtype=np.float32),
+        np.array([[4.0, 5.0], [10.0, 11.0], [16.0, 17.0]], dtype=np.float32),
+    ]
+]
+
+expect(
+    node,
+    inputs=[data, split],
+    outputs=expected_outputs,
+    name="test_split_to_sequence_1",
+)
+```
+
+</details>
+<details>
+<summary>with_split_2</summary>
+
+```python
+data = np.arange(18).reshape((3, 6)).astype(np.float32)
+split = np.array([1, 2], dtype=np.int64)
+
+node = onnx.helper.make_node(
+    "SplitToSequence", ["data", "split"], ["seq"], axis=0
+)
+
+expected_outputs = [
+    [
+        data[:1],
+        data[1:],
+    ]
+]
+
+expect(
+    node,
+    inputs=[data, split],
+    outputs=expected_outputs,
+    name="test_split_to_sequence_2",
+)
+```
+
+</details>
+
+
+### Sqrt
+There are 1 test cases, listed as following:
+<details>
+<summary>sqrt</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sqrt",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([1, 4, 9]).astype(np.float32)
+y = np.sqrt(x)  # expected output [1., 2., 3.]
+expect(node, inputs=[x], outputs=[y], name="test_sqrt_example")
+
+x = np.abs(np.random.randn(3, 4, 5).astype(np.float32))
+y = np.sqrt(x)
+expect(node, inputs=[x], outputs=[y], name="test_sqrt")
+```
+
+</details>
+
+
+### Squeeze
+There are 2 test cases, listed as following:
+<details>
+<summary>squeeze</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Squeeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+axes = np.array([0], dtype=np.int64)
+y = np.squeeze(x, axis=0)
+
+expect(node, inputs=[x, axes], outputs=[y], name="test_squeeze")
+```
+
+</details>
+<details>
+<summary>squeeze_negative_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Squeeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 1, 5).astype(np.float32)
+axes = np.array([-2], dtype=np.int64)
+y = np.squeeze(x, axis=-2)
+expect(node, inputs=[x, axes], outputs=[y], name="test_squeeze_negative_axes")
+```
+
+</details>
+
+
+### StringConcat
+There are 1 test cases, listed as following:
+<details>
+<summary>stringconcat</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringConcat",
+    inputs=["x", "y"],
+    outputs=["result"],
+)
+x = np.array(["abc", "def"]).astype("object")
+y = np.array([".com", ".net"]).astype("object")
+result = np.array(["abc.com", "def.net"]).astype("object")
+
+expect(node, inputs=[x, y], outputs=[result], name="test_string_concat")
+
+x = np.array(["cat", "dog", "snake"]).astype("object")
+y = np.array(["s"]).astype("object")
+result = np.array(["cats", "dogs", "snakes"]).astype("object")
+
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[result],
+    name="test_string_concat_broadcasting",
+)
+
+x = np.array("cat").astype("object")
+y = np.array("s").astype("object")
+result = np.array("cats").astype("object")
+
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[result],
+    name="test_string_concat_zero_dimensional",
+)
+
+x = np.array(["abc", ""]).astype("object")
+y = np.array(["", "abc"]).astype("object")
+result = np.array(["abc", "abc"]).astype("object")
+
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[result],
+    name="test_string_concat_empty_string",
+)
+
+x = np.array(["的", "中"]).astype("object")
+y = np.array(["的", "中"]).astype("object")
+result = np.array(["的的", "中中"]).astype("object")
+
+expect(
+    node,
+    inputs=[x, y],
+    outputs=[result],
+    name="test_string_concat_utf8",
+)
+```
+
+</details>
+
+
+### StringNormalizer
+There are 6 test cases, listed as following:
+<details>
+<summary>monday_casesensintive_lower</summary>
+
+```python
+input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+output = np.array(["tuesday", "wednesday", "thursday"]).astype(object)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    case_change_action="LOWER",
+    is_case_sensitive=1,
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_casesensintive_lower",
+)
+```
+
+</details>
+<details>
+<summary>monday_casesensintive_nochangecase</summary>
+
+```python
+input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+output = np.array(["tuesday", "wednesday", "thursday"]).astype(object)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    is_case_sensitive=1,
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_casesensintive_nochangecase",
+)
+```
+
+</details>
+<details>
+<summary>monday_casesensintive_upper</summary>
+
+```python
+input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+output = np.array(["TUESDAY", "WEDNESDAY", "THURSDAY"]).astype(object)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    case_change_action="UPPER",
+    is_case_sensitive=1,
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_casesensintive_upper",
+)
+```
+
+</details>
+<details>
+<summary>monday_empty_output</summary>
+
+```python
+input = np.array(["monday", "monday"]).astype(object)
+output = np.array([""]).astype(object)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    case_change_action="UPPER",
+    is_case_sensitive=1,
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_empty_output",
+)
+```
+
+</details>
+<details>
+<summary>monday_insensintive_upper_twodim</summary>
+
+```python
+input = (
+    np.array(
+        ["Monday", "tuesday", "wednesday", "Monday", "tuesday", "wednesday"]
+    )
+    .astype(object)
+    .reshape([1, 6])
+)
+
+# It does upper case cecedille, accented E
+# and german umlaut but fails
+# with german eszett
+output = (
+    np.array(["TUESDAY", "WEDNESDAY", "TUESDAY", "WEDNESDAY"])
+    .astype(object)
+    .reshape([1, 4])
+)
+stopwords = ["monday"]
+
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    case_change_action="UPPER",
+    stopwords=stopwords,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_export_monday_insensintive_upper_twodim",
+)
+```
+
+</details>
+<details>
+<summary>nostopwords_nochangecase</summary>
+
+```python
+input = np.array(["monday", "tuesday"]).astype(object)
+output = input
+
+# No stopwords. This is a NOOP
+node = onnx.helper.make_node(
+    "StringNormalizer",
+    inputs=["x"],
+    outputs=["y"],
+    is_case_sensitive=1,
+)
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_strnormalizer_nostopwords_nochangecase",
+)
+```
+
+</details>
+
+
+### StringSplit
+There are 5 test cases, listed as following:
+<details>
+<summary>basic</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringSplit",
+    inputs=["x"],
+    outputs=["substrings", "length"],
+    delimiter=".",
+    maxsplit=None,
+)
+
+x = np.array(["abc.com", "def.net"]).astype(object)
+
+substrings = np.array([["abc", "com"], ["def", "net"]]).astype(object)
+
+length = np.array([2, 2], dtype=np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[substrings, length],
+    name="test_string_split_basic",
+)
+```
+
+</details>
+<details>
+<summary>consecutive_delimiters</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringSplit",
+    inputs=["x"],
+    outputs=["substrings", "length"],
+    delimiter="-",
+    maxsplit=None,
+)
+
+x = np.array(["o-n-n--x-", "o-n----nx"]).astype(object)
+
+substrings = np.array(
+    [["o", "n", "n", "", "x", ""], ["o", "n", "", "", "", "nx"]]
+).astype(object)
+
+length = np.array([6, 6], dtype=np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[substrings, length],
+    name="test_string_split_consecutive_delimiters",
+)
+```
+
+</details>
+<details>
+<summary>empty_string_delimiter</summary>
+
+```python
+for delimiter, test_name in (
+    ("", "test_string_split_empty_string_delimiter"),
+    (None, "test_string_split_no_delimiter"),
+):
+    node = onnx.helper.make_node(
+        "StringSplit",
+        inputs=["x"],
+        outputs=["substrings", "length"],
+        delimiter=delimiter,
+        maxsplit=None,
+    )
+
+    x = np.array(
+        ["hello world !", "  hello   world !", " hello world   ! "]
+    ).astype(object)
+
+    substrings = np.array(
+        [
+            ["hello", "world", "!"],
+            ["hello", "world", "!"],
+            ["hello", "world", "!"],
+        ]
+    ).astype(object)
+
+    length = np.array([3, 3, 3], dtype=np.int64)
+
+    expect(
+        node,
+        inputs=[x],
+        outputs=[substrings, length],
+        name=test_name,
+    )
+```
+
+</details>
+<details>
+<summary>empty_string_split</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringSplit",
+    inputs=["x"],
+    outputs=["substrings", "length"],
+    delimiter=None,
+    maxsplit=None,
+)
+
+x = np.array([]).astype(object)
+
+substrings = np.array([]).astype(object).reshape(0, 0)
+
+length = np.array([], dtype=np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[substrings, length],
+    name="test_string_split_empty_tensor",
+    output_type_protos=[
+        onnx.helper.make_tensor_type_proto(onnx.TensorProto.STRING, (0, None)),
+        None,
+    ],
+)
+```
+
+</details>
+<details>
+<summary>maxsplit</summary>
+
+```python
+node = onnx.helper.make_node(
+    "StringSplit",
+    inputs=["x"],
+    outputs=["substrings", "length"],
+    maxsplit=2,
+)
+
+x = np.array(
+    [["hello world", "def.net"], ["o n n x", "the quick brown fox"]]
+).astype(object)
+
+substrings = np.array(
+    [
+        [["hello", "world", ""], ["def.net", "", ""]],
+        [["o", "n", "n x"], ["the", "quick", "brown fox"]],
+    ]
+).astype(object)
+
+length = np.array([[2, 1], [3, 3]], np.int64)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[substrings, length],
+    name="test_string_split_maxsplit",
+)
+```
+
+</details>
+
+
+### Sub
+There are 2 test cases, listed as following:
+<details>
+<summary>sub</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sub",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.array([1, 2, 3]).astype(np.float32)
+y = np.array([3, 2, 1]).astype(np.float32)
+z = x - y  # expected output [-2., 0., 2.]
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(3, 4, 5).astype(np.float32)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int8)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.int8)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_int8")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int16)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.int16)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_int16")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint8)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint8)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint8")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint16)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint16)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint16")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint32)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint32)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint32")
+
+x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint64)
+y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint64)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint64")
+```
+
+</details>
+<details>
+<summary>sub_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Sub",
+    inputs=["x", "y"],
+    outputs=["z"],
+)
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.random.randn(5).astype(np.float32)
+z = x - y
+expect(node, inputs=[x, y], outputs=[z], name="test_sub_bcast")
+```
+
+</details>
+
+
+### Sum
+There are 1 test cases, listed as following:
+<details>
+<summary>sum</summary>
+
+```python
+data_0 = np.array([3, 0, 2]).astype(np.float32)
+data_1 = np.array([1, 3, 4]).astype(np.float32)
+data_2 = np.array([2, 6, 6]).astype(np.float32)
+result = np.array([6, 9, 12]).astype(np.float32)
+node = onnx.helper.make_node(
+    "Sum",
+    inputs=["data_0", "data_1", "data_2"],
+    outputs=["result"],
+)
+expect(
+    node,
+    inputs=[data_0, data_1, data_2],
+    outputs=[result],
+    name="test_sum_example",
+)
+
+node = onnx.helper.make_node(
+    "Sum",
+    inputs=["data_0"],
+    outputs=["result"],
+)
+expect(node, inputs=[data_0], outputs=[data_0], name="test_sum_one_input")
+
+result = np.add(data_0, data_1)
+node = onnx.helper.make_node(
+    "Sum",
+    inputs=["data_0", "data_1"],
+    outputs=["result"],
+)
+expect(
+    node, inputs=[data_0, data_1], outputs=[result], name="test_sum_two_inputs"
+)
+```
+
+</details>
+
+
+### Swish
+There are 1 test cases, listed as following:
+<details>
+<summary>swish</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Swish",
+    inputs=["x"],
+    outputs=["y"],
+    alpha=1.0,  # pass alpha as attribute
+)
+
+x = np.array([3, 4, 5], dtype=np.float32)
+y = swish(x, alpha=1.0)
+
+expect(
+    node,
+    inputs=[x],
+    outputs=[y],
+    name="test_swish",
+    opset_imports=[onnx.helper.make_opsetid("", 24)],
+)
+```
+
+</details>
+
+
+### Tan
+There are 1 test cases, listed as following:
+<details>
+<summary>tan</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Tan",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.tan(x)
+expect(node, inputs=[x], outputs=[y], name="test_tan_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.tan(x)
+expect(node, inputs=[x], outputs=[y], name="test_tan")
+```
+
+</details>
+
+
+### Tanh
+There are 1 test cases, listed as following:
+<details>
+<summary>tanh</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Tanh",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.array([-1, 0, 1]).astype(np.float32)
+y = np.tanh(x)  # expected output [-0.76159418, 0., 0.76159418]
+expect(node, inputs=[x], outputs=[y], name="test_tanh_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.tanh(x)
+expect(node, inputs=[x], outputs=[y], name="test_tanh")
+```
+
+</details>
+
+
+### TensorScatter
+There are 3 test cases, listed as following:
+<details>
+<summary>tensorscatter</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TensorScatter",
+    inputs=["past_cache", "update", "write_indices"],
+    outputs=["present_cache"],
+    mode="linear",
+)
+past_cache = np.array(
+    [
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+    ],
+    dtype=np.float32,
+)
+update = np.array(
+    [
+        [[[5, 5, 5, 5, 5]]],
+        [[[1, 1, 1, 1, 1]]],
+    ],
+    dtype=np.float32,
+)
+write_indices = np.array([1, 2], dtype=np.int64)
+present_cache = np.array(
+    [
+        [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [1, 1, 1, 1, 1], [4, 3, 2, 1, 0]]],
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[past_cache, update, write_indices],
+    outputs=[present_cache],
+    name="test_tensorscatter",
+)
+```
+
+</details>
+<details>
+<summary>tensorscatter_3d</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TensorScatter",
+    inputs=["past_cache", "update", "write_indices"],
+    outputs=["present_cache"],
+)
+past_cache = np.array(
+    [
+        [
+            [1, 2, 3, 4, 5],
+            [5, 6, 7, 8, 9],
+            [8, 7, 6, 5, 4],
+            [5, 4, 3, 2, 1],
+        ],
+        [
+            [1, 2, 3, 4, 5],
+            [5, 6, 7, 8, 9],
+            [8, 7, 6, 5, 4],
+            [5, 4, 3, 2, 1],
+        ],
+        [
+            [1, 2, 3, 4, 5],
+            [5, 6, 7, 8, 9],
+            [8, 7, 6, 5, 4],
+            [5, 4, 3, 2, 1],
+        ],
+    ],
+    dtype=np.float32,
+)
+update = np.array(
+    [
+        [
+            [4, 4, 4, 4, 4],
+            [5, 5, 5, 5, 5],
+        ],
+        [
+            [6, 6, 6, 6, 6],
+            [7, 7, 7, 7, 7],
+        ],
+        [
+            [2, 2, 2, 2, 2],
+            [3, 3, 3, 3, 3],
+        ],
+    ],
+    dtype=np.float32,
+)
+write_indices = np.array([1, 2, 0], dtype=np.int64)
+present_cache = np.array(
+    [
+        [
+            [1, 2, 3, 4, 5],
+            [4, 4, 4, 4, 4],
+            [5, 5, 5, 5, 5],
+            [5, 4, 3, 2, 1],
+        ],
+        [
+            [1, 2, 3, 4, 5],
+            [5, 6, 7, 8, 9],
+            [6, 6, 6, 6, 6],
+            [7, 7, 7, 7, 7],
+        ],
+        [
+            [2, 2, 2, 2, 2],
+            [3, 3, 3, 3, 3],
+            [8, 7, 6, 5, 4],
+            [5, 4, 3, 2, 1],
+        ],
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[past_cache, update, write_indices],
+    outputs=[present_cache],
+    name="test_tensorscatter_3d",
+)
+```
+
+</details>
+<details>
+<summary>tensorscatter_circular</summary>
+
+```python
+node = onnx.helper.make_node(
+    "TensorScatter",
+    inputs=["past_cache", "update", "write_indices"],
+    outputs=["present_cache"],
+    mode="circular",
+)
+past_cache = np.array(
+    [
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+        [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+    ],
+    dtype=np.float32,
+)
+update = np.array(
+    [
+        [
+            [
+                [5, 5, 5, 5, 5],
+                [6, 6, 6, 6, 6],
+            ]
+        ],
+        [
+            [
+                [1, 1, 1, 1, 1],
+                [2, 2, 2, 2, 2],
+            ]
+        ],
+    ],
+    dtype=np.float32,
+)
+write_indices = np.array([1, 3], dtype=np.int64)
+present_cache = np.array(
+    [
+        [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [6, 6, 6, 6, 6], [4, 3, 2, 1, 0]]],
+        [[[2, 2, 2, 2, 2], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [1, 1, 1, 1, 1]]],
+    ],
+    dtype=np.float32,
+)
+expect(
+    node,
+    inputs=[past_cache, update, write_indices],
+    outputs=[present_cache],
+    name="test_tensorscatter_circular",
+)
+```
+
+</details>
+
+
+### TfIdfVectorizer
+There are 7 test cases, listed as following:
+<details>
+<summary>tf_batch_onlybigrams_skip0</summary>
+
+```python
+input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32)
+output = np.array(
+    [[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, 1.0]]
+).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=0,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_batch_onlybigrams_skip0",
+)
+```
+
+</details>
+<details>
+<summary>tf_batch_onlybigrams_skip5</summary>
+
+```python
+input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32)
+output = np.array(
+    [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0]]
+).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=5,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_batch_onlybigrams_skip5",
+)
+```
+
+</details>
+<details>
+<summary>tf_batch_uniandbigrams_skip5</summary>
+
+```python
+input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32)
+output = np.array(
+    [[0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0]]
+).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=1,
+    max_gram_length=2,
+    max_skip_count=5,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_batch_uniandbigrams_skip5",
+)
+```
+
+</details>
+<details>
+<summary>tf_only_bigrams_skip0</summary>
+
+```python
+input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+output = np.array([0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0]).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=0,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_only_bigrams_skip0",
+)
+```
+
+</details>
+<details>
+<summary>tf_onlybigrams_levelempty</summary>
+
+```python
+input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+output = np.array([1.0, 1.0, 1.0]).astype(np.float32)
+
+ngram_counts = np.array([0, 0]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2]).astype(np.int64)
+pool_int64s = np.array([5, 6, 7, 8, 6, 7]).astype(  # unigrams none
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=0,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_onlybigrams_levelempty",
+)
+```
+
+</details>
+<details>
+<summary>tf_onlybigrams_skip5</summary>
+
+```python
+input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+output = np.array([0.0, 0.0, 0.0, 0.0, 1.0, 3.0, 1.0]).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=2,
+    max_gram_length=2,
+    max_skip_count=5,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_onlybigrams_skip5",
+)
+```
+
+</details>
+<details>
+<summary>tf_uniandbigrams_skip5</summary>
+
+```python
+input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+output = np.array([0.0, 3.0, 1.0, 0.0, 1.0, 3.0, 1.0]).astype(np.float32)
+
+ngram_counts = np.array([0, 4]).astype(np.int64)
+ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+    np.int64
+)  # bigrams
+
+helper = TfIdfVectorizerHelper(
+    mode="TF",
+    min_gram_length=1,
+    max_gram_length=2,
+    max_skip_count=5,
+    ngram_counts=ngram_counts,
+    ngram_indexes=ngram_indexes,
+    pool_int64s=pool_int64s,
+)
+node = helper.make_node_noweights()
+expect(
+    node,
+    inputs=[input],
+    outputs=[output],
+    name="test_tfidfvectorizer_tf_uniandbigrams_skip5",
+)
+```
+
+</details>
+
+
+### ThresholdedRelu
+There are 2 test cases, listed as following:
+<details>
+<summary>default</summary>
+
+```python
+default_alpha = 1.0
+node = onnx.helper.make_node("ThresholdedRelu", inputs=["x"], outputs=["y"])
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, default_alpha, np.inf)
+y[y == default_alpha] = 0
+
+expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu_default")
+```
+
+</details>
+<details>
+<summary>thresholdedrelu</summary>
+
+```python
+alpha = 2.0
+node = onnx.helper.make_node(
+    "ThresholdedRelu", inputs=["x"], outputs=["y"], alpha=alpha
+)
+
+x = np.array([-1.5, 0.0, 1.2, 2.0, 2.2]).astype(np.float32)
+y = np.clip(x, alpha, np.inf)  # expected output [0., 0., 0., 0., 2.2]
+y[y == alpha] = 0
+
+expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu_example")
+
+x = np.random.randn(3, 4, 5).astype(np.float32)
+y = np.clip(x, alpha, np.inf)
+y[y == alpha] = 0
+
+expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu")
+```
+
+</details>
+
+
+### Tile
+There are 2 test cases, listed as following:
+<details>
+<summary>tile</summary>
+
+```python
+node = onnx.helper.make_node("Tile", inputs=["x", "y"], outputs=["z"])
+
+x = np.random.rand(2, 3, 4, 5).astype(np.float32)
+
+repeats = np.random.randint(low=1, high=10, size=(np.ndim(x),)).astype(np.int64)
+
+z = np.tile(x, repeats)
+
+expect(node, inputs=[x, repeats], outputs=[z], name="test_tile")
+```
+
+</details>
+<details>
+<summary>tile_precomputed</summary>
+
+```python
+node = onnx.helper.make_node("Tile", inputs=["x", "y"], outputs=["z"])
+
+x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+
+repeats = np.array([2, 2], dtype=np.int64)
+
+z = np.array(
+    [[0, 1, 0, 1], [2, 3, 2, 3], [0, 1, 0, 1], [2, 3, 2, 3]], dtype=np.float32
+)
+
+expect(node, inputs=[x, repeats], outputs=[z], name="test_tile_precomputed")
+```
+
+</details>
+
+
+### TopK
+There are 7 test cases, listed as following:
+<details>
+<summary>top_k</summary>
+
+```python
+axis = 1
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [8, 9, 10, 11],
+    ],
+    dtype=np.float32,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[ 3.  2.  1.]
+# [ 7.  6.  5.]
+# [11. 10.  9.]]
+# print(indices_ref)
+# [[3 2 1]
+# [3 2 1]
+# [3 2 1]]
+
+expect(
+    node, inputs=[X, K], outputs=[values_ref, indices_ref], name="test_top_k"
+)
+```
+
+</details>
+<details>
+<summary>top_k_negative_axis</summary>
+
+```python
+axis = -1
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [8, 9, 10, 11],
+    ],
+    dtype=np.float32,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[ 3.  2.  1.]
+# [ 7.  6.  5.]
+# [11. 10.  9.]]
+# print(indices_ref)
+# [[3 2 1]
+# [3 2 1]
+# [3 2 1]]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_negative_axis",
+)
+```
+
+</details>
+<details>
+<summary>top_k_same_values</summary>
+
+```python
+axis = 0
+largest = 0
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [0, 0, 0, 0],
+    dtype=np.int64,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# (Pdb) print(values_ref)
+# [0 0 0]
+# (Pdb) print(indices_ref)
+# [0 1 2]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_same_values",
+)
+```
+
+</details>
+<details>
+<summary>top_k_same_values_2d</summary>
+
+```python
+axis = 1
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 1, 1]],
+    dtype=np.int64,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[0 0 0]
+# [1 1 1]
+# [1 1 2]]
+# print(indices_ref)
+# [[0 1 2]
+# [0 1 2]
+# [2 3 0]]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_same_values_2d",
+)
+```
+
+</details>
+<details>
+<summary>top_k_same_values_largest</summary>
+
+```python
+axis = 0
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [0, 0, 0, 0],
+    dtype=np.int64,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [0 0 0]
+# print(indices_ref)
+# [0 1 2]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_same_values_largest",
+)
+```
+
+</details>
+<details>
+<summary>top_k_smallest</summary>
+
+```python
+axis = 1
+largest = 0
+sorted_ = 1
+k = 3
+
+node = onnx.helper.make_node(
+    "TopK",
+    inputs=["x", "k"],
+    outputs=["values", "indices"],
+    axis=axis,
+    largest=largest,
+    sorted=sorted_,
+)
+
+X = np.array(
+    [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [11, 10, 9, 8],
+    ],
+    dtype=np.float32,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[ 0.  1.  2.]
+# [ 4.  5.  6.]
+# [ 8.  9. 10.]]
+# print(indices_ref)
+# [[0 1 2]
+# [0 1 2]
+# [3 2 1]]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_smallest",
+)
+```
+
+</details>
+<details>
+<summary>top_k_uint64</summary>
+
+```python
+axis = 1
+largest = 1
+
+k = 3
+node = onnx.helper.make_node(
+    "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+)
+X = np.array(
+    [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [8, 9, 10, 11],
+    ],
+    dtype=np.uint64,
+)
+K = np.array([k], dtype=np.int64)
+values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+# print(values_ref)
+# [[ 3  2  1]
+# [ 7  6  5]
+# [11 10  9]]
+# print(indices_ref)
+# [[3 2 1]
+# [3 2 1]
+# [3 2 1]]
+
+expect(
+    node,
+    inputs=[X, K],
+    outputs=[values_ref, indices_ref],
+    name="test_top_k_uint64",
+)
+```
+
+</details>
+
+
+### Transpose
+There are 2 test cases, listed as following:
+<details>
+<summary>all_permutations</summary>
+
+```python
+shape = (2, 3, 4)
+data = np.random.random_sample(shape).astype(np.float32)
+permutations = list(itertools.permutations(np.arange(len(shape))))
+
+for i, permutation in enumerate(permutations):
+    node = onnx.helper.make_node(
+        "Transpose",
+        inputs=["data"],
+        outputs=["transposed"],
+        perm=permutation,
+    )
+    transposed = np.transpose(data, permutation)
+    expect(
+        node,
+        inputs=[data],
+        outputs=[transposed],
+        name=f"test_transpose_all_permutations_{i}",
+    )
+```
+
+</details>
+<details>
+<summary>default</summary>
+
+```python
+shape = (2, 3, 4)
+data = np.random.random_sample(shape).astype(np.float32)
+
+node = onnx.helper.make_node(
+    "Transpose", inputs=["data"], outputs=["transposed"]
+)
+
+transposed = np.transpose(data)
+expect(node, inputs=[data], outputs=[transposed], name="test_transpose_default")
+```
+
+</details>
+
+
+### Trilu
+There are 18 test cases, listed as following:
+<details>
+<summary>tril</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 0, 0, 0, 0],
+#   [1, 2, 0, 0, 0],
+#   [9, 4, 1, 0, 0],
+#   [4, 3, 4, 2, 0]]
+y = tril_reference_implementation(x)
+expect(node, inputs=[x], outputs=[y], name="test_tril")
+```
+
+</details>
+<details>
+<summary>tril_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(-1).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[0, 0, 0, 0, 0],
+#   [1, 0, 0, 0, 0],
+#   [9, 4, 0, 0, 0],
+#   [4, 3, 4, 0, 0]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_neg")
+```
+
+</details>
+<details>
+<summary>tril_one_row</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(3, 1, 5)).astype(np.int64)
+# X:
+# [[[6, 2, 4, 1, 6]],
+#
+#  [[8, 3, 8, 7, 0]],
+#
+#  [[2, 2, 9, 5, 9]]]
+# expect result:
+# [[[6, 0, 0, 0, 0]],
+#
+#  [[8, 0, 0, 0, 0]],
+#
+#  [[2, 0, 0, 0, 0]]]
+y = tril_reference_implementation(x)
+expect(node, inputs=[x], outputs=[y], name="test_tril_one_row_neg")
+```
+
+</details>
+<details>
+<summary>tril_out_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(-7).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_out_neg")
+```
+
+</details>
+<details>
+<summary>tril_out_pos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(6).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_out_pos")
+```
+
+</details>
+<details>
+<summary>tril_pos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(2).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 0, 0],
+#   [1, 2, 8, 6, 0],
+#   [9, 4, 1, 8, 7],
+#   [4, 3, 4, 2, 4]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_pos")
+```
+
+</details>
+<details>
+<summary>tril_square</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+# X:
+# [[[0, 4, 3],
+#   [2, 0, 9],
+#   [8, 2, 5]],
+#
+#  [[2, 7, 2],
+#   [2, 6, 0],
+#   [2, 6, 5]]]
+# expect result:
+# [[[0, 0, 0],
+#   [2, 0, 0],
+#   [8, 2, 5]],
+#
+#  [[2, 0, 0],
+#   [2, 6, 0],
+#   [2, 6, 5]]]
+y = tril_reference_implementation(x)
+expect(node, inputs=[x], outputs=[y], name="test_tril_square")
+```
+
+</details>
+<details>
+<summary>tril_square_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+k = np.array(-1).astype(np.int64)
+# X:
+# [[[0, 4, 3],
+#   [2, 0, 9],
+#   [8, 2, 5]],
+#
+#  [[2, 7, 2],
+#   [2, 6, 0],
+#   [2, 6, 5]]]
+# expect result:
+# [[[0, 0, 0],
+#   [2, 0, 0],
+#   [8, 2, 0]],
+#
+#  [[0, 0, 0],
+#   [2, 0, 0],
+#   [2, 6, 0]]]
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_square_neg")
+```
+
+</details>
+<details>
+<summary>tril_zero</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+    upper=0,
+)
+
+x = np.random.randint(10, size=(3, 0, 5)).astype(np.int64)
+k = np.array(6).astype(np.int64)
+# X:
+# []
+# expect result:
+# []
+y = tril_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_tril_zero")
+```
+
+</details>
+<details>
+<summary>triu</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 7, 9],
+#   [0, 2, 8, 6, 9],
+#   [0, 0, 0, 8, 7],
+#   [0, 0, 0, 2, 4]]
+y = triu_reference_implementation(x)
+expect(node, inputs=[x], outputs=[y], name="test_triu")
+```
+
+</details>
+<details>
+<summary>triu_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(-1).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [0, 4, 0, 8, 7],
+#   [0, 0, 4, 2, 4]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_neg")
+```
+
+</details>
+<details>
+<summary>triu_one_row</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(3, 1, 5)).astype(np.int64)
+k = np.array(1).astype(np.int64)
+# X:
+# [[[1, 4, 9, 7, 1]],
+#
+#  [[9, 2, 8, 8, 4]],
+#
+#  [[3, 9, 7, 4, 2]]]
+# expect result:
+# [[[0, 4, 9, 7, 1]],
+#
+#  [[0, 2, 8, 8, 4]],
+#
+#  [[0, 9, 7, 4, 2]]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_one_row")
+```
+
+</details>
+<details>
+<summary>triu_out_neg_out</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(-7).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_out_neg_out")
+```
+
+</details>
+<details>
+<summary>triu_out_pos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(6).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0],
+#   [0, 0, 0, 0, 0]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_out_pos")
+```
+
+</details>
+<details>
+<summary>triu_pos</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+k = np.array(2).astype(np.int64)
+# X:
+#  [[4, 7, 3, 7, 9],
+#   [1, 2, 8, 6, 9],
+#   [9, 4, 0, 8, 7],
+#   [4, 3, 4, 2, 4]]
+# expect result:
+#  [[0, 0, 3, 7, 9],
+#   [0, 0, 0, 6, 9],
+#   [0, 0, 0, 0, 7],
+#   [0, 0, 0, 0, 0]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_pos")
+```
+
+</details>
+<details>
+<summary>triu_square</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+y = triu_reference_implementation(x)
+# X:
+# [[[4, 6, 9],
+#   [7, 5, 4],
+#   [8, 1, 2]],
+#
+#  [[1, 4, 9],
+#   [9, 6, 3],
+#   [8, 9, 8]]]
+# expect result:
+# [[[4, 6, 9],
+#   [0, 5, 4],
+#   [0, 0, 2]],
+#
+#  [[1, 4, 9],
+#   [0, 6, 3],
+#   [0, 0, 8]]]
+expect(node, inputs=[x], outputs=[y], name="test_triu_square")
+```
+
+</details>
+<details>
+<summary>triu_square_neg</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+k = np.array(-1).astype(np.int64)
+# X:
+# [[[4, 6, 9],
+#   [7, 5, 4],
+#   [8, 1, 2]],
+#
+#  [[1, 4, 9],
+#   [9, 6, 3],
+#   [8, 9, 8]]]
+# expect result:
+# [[[4, 6, 9],
+#   [7, 5, 4],
+#   [0, 1, 2]],
+#
+#  [[1, 4, 9],
+#   [9, 6, 3],
+#   [0, 9, 8]]]
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_square_neg")
+```
+
+</details>
+<details>
+<summary>triu_zero</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Trilu",
+    inputs=["x", "k"],
+    outputs=["y"],
+)
+
+x = np.random.randint(10, size=(0, 5)).astype(np.int64)
+k = np.array(6).astype(np.int64)
+# X:
+# []
+# expect result:
+# []
+y = triu_reference_implementation(x, int(k))
+expect(node, inputs=[x, k], outputs=[y], name="test_triu_zero")
+```
+
+</details>
+
+
+### Unique
+There are 6 test cases, listed as following:
+<details>
+<summary>length_1</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=1,
+)
+
+x = np.array([0], dtype=np.int64)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# behavior changed with numpy >= 2.0
+inverse_indices = inverse_indices.reshape(-1)
+# print(y)
+# [0]
+# print(indices)
+# [0]
+# print(inverse_indices)
+# [0]
+# print(counts)
+# [1]
+
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_length_1",
+)
+```
+
+</details>
+<details>
+<summary>not_sorted_without_axis</summary>
+
+```python
+node_not_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=0,
+)
+# numpy unique does not retain original order (it sorts the output unique values)
+# https://github.com/numpy/numpy/issues/8621
+# we need to recover unsorted output and indices
+x = np.array([2.0, 1.0, 1.0, 3.0, 4.0, 3.0], dtype=np.float32)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+
+# prepare index mapping from sorted to unsorted
+argsorted_indices = np.argsort(indices)
+inverse_indices_map = dict(
+    zip(argsorted_indices, np.arange(len(argsorted_indices)), strict=True)
+)
+
+indices = indices[argsorted_indices]
+y = np.take(x, indices, axis=0)
+inverse_indices = np.asarray(
+    [inverse_indices_map[i] for i in inverse_indices], dtype=np.int64
+)
+counts = counts[argsorted_indices]
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# print(y)
+# [2.0, 1.0, 3.0, 4.0]
+# print(indices)
+# [0 1 3 4]
+# print(inverse_indices)
+# [0, 1, 1, 2, 3, 2]
+# print(counts)
+# [1, 2, 2, 1]
+
+expect(
+    node_not_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_not_sorted_without_axis",
+)
+```
+
+</details>
+<details>
+<summary>sorted_with_axis</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=1,
+    axis=0,
+)
+
+x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]], dtype=np.float32)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=0)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# behavior changed with numpy >= 2.0
+inverse_indices = inverse_indices.reshape(-1)
+# print(y)
+# [[1. 0. 0.]
+#  [2. 3. 4.]]
+# print(indices)
+# [0 2]
+# print(inverse_indices)
+# [0 0 1]
+# print(counts)
+# [2 1]
+
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_sorted_with_axis",
+)
+```
+
+</details>
+<details>
+<summary>sorted_with_axis_3d</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=1,
+    axis=1,
+)
+
+x = np.array(
+    [
+        [[1.0, 1.0], [0.0, 1.0], [2.0, 1.0], [0.0, 1.0]],
+        [[1.0, 1.0], [0.0, 1.0], [2.0, 1.0], [0.0, 1.0]],
+    ],
+    dtype=np.float32,
+)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=1)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# behavior changed with numpy >= 2.0
+inverse_indices = inverse_indices.reshape(-1)
+# print(y)
+# [[[0. 1.]
+#  [1. 1.]
+#  [2. 1.]]
+# [[0. 1.]
+#  [1. 1.]
+#  [2. 1.]]]
+# print(indices)
+# [1 0 2]
+# print(inverse_indices)
+# [1 0 2 0]
+# print(counts)
+# [2 1 1]
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_sorted_with_axis_3d",
+)
+```
+
+</details>
+<details>
+<summary>sorted_with_negative_axis</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+    sorted=1,
+    axis=-1,
+)
+
+x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 3]], dtype=np.float32)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=-1)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+# behavior changed with numpy >= 2.0
+inverse_indices = inverse_indices.reshape(-1)
+# print(y)
+# [[0. 1.]
+#  [0. 1.]
+#  [3. 2.]]
+# print(indices)
+# [1 0]
+# print(inverse_indices)
+# [1 0 0]
+# print(counts)
+# [2 1]
+
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_sorted_with_negative_axis",
+)
+```
+
+</details>
+<details>
+<summary>sorted_without_axis</summary>
+
+```python
+node_sorted = onnx.helper.make_node(
+    "Unique",
+    inputs=["X"],
+    outputs=["Y", "indices", "inverse_indices", "counts"],
+)
+
+x = np.array([2.0, 1.0, 1.0, 3.0, 4.0, 3.0], dtype=np.float32)
+y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+indices, inverse_indices, counts = specify_int64(
+    indices, inverse_indices, counts
+)
+expect(
+    node_sorted,
+    inputs=[x],
+    outputs=[y, indices, inverse_indices, counts],
+    name="test_unique_sorted_without_axis",
+)
+```
+
+</details>
+
+
+### Unsqueeze
+There are 5 test cases, listed as following:
+<details>
+<summary>unsqueeze_negative_axes</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Unsqueeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+x = np.random.randn(1, 3, 1, 5).astype(np.float32)
+axes = np.array([-2]).astype(np.int64)
+y = np.expand_dims(x, axis=-2)
+expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_negative_axes")
+```
+
+</details>
+<details>
+<summary>unsqueeze_one_axis</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+
+for i in range(x.ndim):
+    axes = np.array([i]).astype(np.int64)
+    node = onnx.helper.make_node(
+        "Unsqueeze",
+        inputs=["x", "axes"],
+        outputs=["y"],
+    )
+    y = np.expand_dims(x, axis=i)
+
+    expect(
+        node,
+        inputs=[x, axes],
+        outputs=[y],
+        name="test_unsqueeze_axis_" + str(i),
+    )
+```
+
+</details>
+<details>
+<summary>unsqueeze_three_axes</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+axes = np.array([2, 4, 5]).astype(np.int64)
+
+node = onnx.helper.make_node(
+    "Unsqueeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+y = np.expand_dims(x, axis=2)
+y = np.expand_dims(y, axis=4)
+y = np.expand_dims(y, axis=5)
+
+expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_three_axes")
+```
+
+</details>
+<details>
+<summary>unsqueeze_two_axes</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+axes = np.array([1, 4]).astype(np.int64)
+
+node = onnx.helper.make_node(
+    "Unsqueeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+y = np.expand_dims(x, axis=1)
+y = np.expand_dims(y, axis=4)
+
+expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_two_axes")
+```
+
+</details>
+<details>
+<summary>unsqueeze_unsorted_axes</summary>
+
+```python
+x = np.random.randn(3, 4, 5).astype(np.float32)
+axes = np.array([5, 4, 2]).astype(np.int64)
+
+node = onnx.helper.make_node(
+    "Unsqueeze",
+    inputs=["x", "axes"],
+    outputs=["y"],
+)
+y = np.expand_dims(x, axis=2)
+y = np.expand_dims(y, axis=4)
+y = np.expand_dims(y, axis=5)
+
+expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_unsorted_axes")
+```
+
+</details>
+
+
+### Upsample
+There are 1 test cases, listed as following:
+<details>
+<summary>nearest</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Upsample",
+    inputs=["X", "scales"],
+    outputs=["Y"],
+    mode="nearest",
+)
+
+data = np.array(
+    [
+        [
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
+
+output = np.array(
+    [
+        [
+            [
+                [1, 1, 1, 2, 2, 2],
+                [1, 1, 1, 2, 2, 2],
+                [3, 3, 3, 4, 4, 4],
+                [3, 3, 3, 4, 4, 4],
+            ]
+        ]
+    ],
+    dtype=np.float32,
+)
+
+expect(
+    node,
+    inputs=[data, scales],
+    outputs=[output],
+    name="test_upsample_nearest",
+    opset_imports=[helper.make_opsetid("", 9)],
+)
+```
+
+</details>
+
+
+### Where
+There are 2 test cases, listed as following:
+<details>
+<summary>long</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Where",
+    inputs=["condition", "x", "y"],
+    outputs=["z"],
+)
+
+condition = np.array([[1, 0], [1, 1]], dtype=bool)
+x = np.array([[1, 2], [3, 4]], dtype=np.int64)
+y = np.array([[9, 8], [7, 6]], dtype=np.int64)
+z = np.where(condition, x, y)  # expected output [[1, 8], [3, 4]]
+expect(
+    node, inputs=[condition, x, y], outputs=[z], name="test_where_long_example"
+)
+```
+
+</details>
+<details>
+<summary>where</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Where",
+    inputs=["condition", "x", "y"],
+    outputs=["z"],
+)
+
+condition = np.array([[1, 0], [1, 1]], dtype=bool)
+x = np.array([[1, 2], [3, 4]], dtype=np.float32)
+y = np.array([[9, 8], [7, 6]], dtype=np.float32)
+z = np.where(condition, x, y)  # expected output [[1, 8], [3, 4]]
+expect(node, inputs=[condition, x, y], outputs=[z], name="test_where_example")
+```
+
+</details>
+
+
+### Xor
+There are 2 test cases, listed as following:
+<details>
+<summary>xor</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Xor",
+    inputs=["x", "y"],
+    outputs=["xor"],
+)
+
+# 2d
+x = (np.random.randn(3, 4) > 0).astype(bool)
+y = (np.random.randn(3, 4) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor2d")
+
+# 3d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor3d")
+
+# 4d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor4d")
+```
+
+</details>
+<details>
+<summary>xor_broadcast</summary>
+
+```python
+node = onnx.helper.make_node(
+    "Xor",
+    inputs=["x", "y"],
+    outputs=["xor"],
+)
+
+# 3d vs 1d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(5) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast3v1d")
+
+# 3d vs 2d
+x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+y = (np.random.randn(4, 5) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast3v2d")
+
+# 4d vs 2d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(5, 6) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v2d")
+
+# 4d vs 3d
+x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+y = (np.random.randn(4, 5, 6) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v3d")
+
+# 4d vs 4d
+x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool)
+y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool)
+z = np.logical_xor(x, y)
+expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v4d")
+```
+
+</details>
+
+
+<br/>
+
+## &#x1F494;No Cover Common Operators
+### ConcatFromSequence (call for test cases)
+
+
+### GlobalLpPool (call for test cases)
+
+
+### GreaterOrEqual (call for test cases)
+
+
+### LessOrEqual (call for test cases)
+
+
+### MaxRoiPool (call for test cases)
+
+
+### Multinomial (random generator operator)
+
+
+### Optional (call for test cases)
+
+
+### OptionalGetElement (call for test cases)
+
+
+### RandomNormal (random generator operator)
+
+
+### RandomNormalLike (random generator operator)
+
+
+### RandomUniform (random generator operator)
+
+
+### RandomUniformLike (random generator operator)
+
+
+### SequenceAt (call for test cases)
+
+
+### SequenceConstruct (call for test cases)
+
+
+### SequenceEmpty (call for test cases)
+
+
+### SequenceErase (call for test cases)
+
+
+### SequenceLength (call for test cases)
+
+
+<br/>
+
+## &#x1F49A;Covered Experimental Operators
+### FlexAttention
+There are 11 test cases, listed as following:
+<details>
+<summary>flexattention</summary>
+
+```python
+"""Basic FlexAttention test with default settings."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_causal_mask</summary>
+
+```python
+"""FlexAttention with causal masking score_mod (Qwen-3, Gemma-3, Llama-3 pattern)."""
+score_mod_graph = _make_score_mod_causal_mask_graph(TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+node.attribute.append(score_mod_attr)
+
+B, Hq, L, E = 1, 2, 4, 8
+S, Ev = 4, 8
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+# Manually compute expected output with causal masking
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+# Apply causal mask: set future positions to -inf
+q_idx = np.arange(L).reshape(1, 1, L, 1)
+k_idx = np.arange(S).reshape(1, 1, 1, S)
+mask = q_idx >= k_idx
+scores = np.where(mask, scores, -np.inf)
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_causal_mask",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_diff_head_sizes</summary>
+
+```python
+"""FlexAttention with different head sizes for Q/K vs V."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 32  # V has different head size
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_diff_head_sizes",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_double</summary>
+
+```python
+"""FlexAttention with double precision inputs."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float64)
+K = np.random.rand(B, Hq, S, E).astype(np.float64)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float64)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_double",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_fp16</summary>
+
+```python
+"""FlexAttention with float16 inputs."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float16)
+K = np.random.rand(B, Hq, S, E).astype(np.float16)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float16)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_fp16",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_gqa</summary>
+
+```python
+"""FlexAttention with Grouped Query Attention (GQA)."""
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, Hkv, L, S, E, Ev = 2, 8, 2, 4, 6, 16, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hkv, S, E).astype(np.float32)
+V = np.random.rand(B, Hkv, S, Ev).astype(np.float32)
+
+(Y,) = _compute_flex_attention(Q, K, V)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_gqa",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_prob_mod</summary>
+
+```python
+"""FlexAttention with prob_mod subgraph (scales probabilities)."""
+scale_value = 0.5
+prob_mod_graph = _make_prob_mod_scale_graph(scale_value, TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+prob_mod_attr = helper.make_attribute("prob_mod", prob_mod_graph)
+node.attribute.append(prob_mod_attr)
+
+B, Hq, L, E = 1, 2, 3, 4
+S, Ev = 3, 4
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+probs = probs * scale_value
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_prob_mod",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_relative_positional</summary>
+
+```python
+"""FlexAttention with relative positional bias score_mod."""
+score_mod_graph = _make_score_mod_relative_positional_graph(TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+node.attribute.append(score_mod_attr)
+
+B, Hq, L, E = 1, 2, 4, 8
+S, Ev = 4, 8
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+# Manually compute expected output with relative positional bias
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+q_idx = np.arange(L).reshape(-1, 1)
+k_idx = np.arange(S).reshape(1, -1)
+rel_pos = (q_idx - k_idx).astype(np.float32)
+scores = scores + rel_pos
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_relative_positional",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_scaled</summary>
+
+```python
+"""FlexAttention with explicit scale attribute."""
+scale = 0.1
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    scale=scale,
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+
+B, Hq, L, E = 2, 4, 8, 16
+S, Ev = 6, 16
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+(Y,) = _compute_flex_attention(Q, K, V, scale=scale)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_scaled",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_score_mod</summary>
+
+```python
+"""FlexAttention with score_mod subgraph (adds bias to scores)."""
+bias_value = 0.5
+score_mod_graph = _make_score_mod_bias_graph(bias_value, TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+# Add score_mod as a graph attribute
+score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+node.attribute.append(score_mod_attr)
+
+B, Hq, L, E = 1, 2, 3, 4
+S, Ev = 3, 4
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+scores = scores + bias_value  # score_mod: add bias
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_score_mod",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+<details>
+<summary>flexattention_soft_cap</summary>
+
+```python
+"""FlexAttention with soft capping score_mod (Gemma-2 pattern)."""
+cap_value = 20.0
+score_mod_graph = _make_score_mod_soft_cap_graph(cap_value, TensorProto.FLOAT)
+
+node = helper.make_node(
+    "FlexAttention",
+    inputs=["Q", "K", "V"],
+    outputs=["Y"],
+    domain=AI_ONNX_PREVIEW_DOMAIN,
+)
+score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+node.attribute.append(score_mod_attr)
+
+B, Hq, L, E = 1, 2, 4, 8
+S, Ev = 4, 8
+
+Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+K = np.random.rand(B, Hq, S, E).astype(np.float32)
+V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+# Manually compute expected output with soft capping
+scale = 1.0 / np.sqrt(E)
+scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+scores = np.tanh(scores / cap_value) * cap_value
+probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+probs = probs / probs.sum(axis=-1, keepdims=True)
+Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+expect(
+    node,
+    inputs=[Q, K, V],
+    outputs=[Y],
+    name="test_flexattention_soft_cap",
+    opset_imports=[
+        helper.make_opsetid("", 26),
+        helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+    ],
+)
+```
+
+</details>
+
+
+<br/>
+
+## &#x1F494;No Cover Experimental Operators
+<br/>
+
+# Model Test Coverage
+## bvlc_alexnet
+
+bvlc_alexnet has 40 nodes. Of these, 40 are covered by node tests (100.0%)
+
+
+<details>
+<summary>nodes</summary>
+
+<details>
+<summary>ConstantOfShape: 1 out of 1 attributes covered</summary>
+
+value: 1
+</details>
+<details>
+<summary>Conv: 4 out of 6 attributes covered</summary>
+
+auto_pad: 0
+dilations: 0
+group: 1
+kernel_shape: 3
+pads: 3
+strides: 2
+</details>
+<details>
+<summary>Dropout: 1 out of 1 attributes covered</summary>
+
+seed: 0
+</details>
+<details>
+<summary>Gemm: 1 out of 4 attributes covered</summary>
+
+alpha: 0
+beta: 0
+transA: 0
+transB: 1
+</details>
+<details>
+<summary>LRN: 4 out of 4 attributes covered</summary>
+
+alpha: 1
+beta: 1
+bias: 1
+size: 1
+</details>
+<details>
+<summary>MaxPool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+dilations: 0
+kernel_shape: 1
+pads: 2
+storage_order: 0
+strides: 1
+</details>
+</details>
+
+
+## densenet121
+
+densenet121 has 1746 nodes. Of these, 1746 are covered by node tests (100.0%)
+
+
+<details>
+<summary>nodes</summary>
+
+<details>
+<summary>AveragePool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+count_include_pad: 0
+dilations: 0
+kernel_shape: 1
+pads: 1
+strides: 1
+</details>
+<details>
+<summary>BatchNormalization: 1 out of 3 attributes covered</summary>
+
+epsilon: 1
+momentum: 0
+training_mode: 0
+</details>
+<details>
+<summary>Concat: 1 out of 1 attributes covered</summary>
+
+axis: 1
+</details>
+<details>
+<summary>ConstantOfShape: 1 out of 1 attributes covered</summary>
+
+value: 1
+</details>
+<details>
+<summary>Conv: 4 out of 6 attributes covered</summary>
+
+auto_pad: 0
+dilations: 0
+group: 1
+kernel_shape: 5
+pads: 4
+strides: 3
+</details>
+<details>
+<summary>Dropout: 1 out of 1 attributes covered</summary>
+
+seed: 0
+</details>
+<details>
+<summary>Gemm: 1 out of 4 attributes covered</summary>
+
+alpha: 0
+beta: 0
+transA: 0
+transB: 1
+</details>
+<details>
+<summary>LRN: 4 out of 4 attributes covered</summary>
+
+alpha: 1
+beta: 1
+bias: 1
+size: 1
+</details>
+<details>
+<summary>MaxPool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+dilations: 0
+kernel_shape: 1
+pads: 3
+storage_order: 0
+strides: 1
+</details>
+<details>
+<summary>Unsqueeze: 1 out of 0 attributes covered</summary>
+
+</details>
+</details>
+
+
+## inception_v1
+
+inception_v1 has 237 nodes. Of these, 237 are covered by node tests (100.0%)
+
+
+<details>
+<summary>nodes</summary>
+
+<details>
+<summary>AveragePool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+count_include_pad: 0
+dilations: 0
+kernel_shape: 2
+pads: 2
+strides: 2
+</details>
+<details>
+<summary>BatchNormalization: 1 out of 3 attributes covered</summary>
+
+epsilon: 1
+momentum: 0
+training_mode: 0
+</details>
+<details>
+<summary>Concat: 1 out of 1 attributes covered</summary>
+
+axis: 1
+</details>
+<details>
+<summary>ConstantOfShape: 1 out of 1 attributes covered</summary>
+
+value: 1
+</details>
+<details>
+<summary>Conv: 4 out of 6 attributes covered</summary>
+
+auto_pad: 0
+dilations: 0
+group: 1
+kernel_shape: 5
+pads: 4
+strides: 3
+</details>
+<details>
+<summary>Dropout: 1 out of 1 attributes covered</summary>
+
+seed: 0
+</details>
+<details>
+<summary>Gemm: 1 out of 4 attributes covered</summary>
+
+alpha: 0
+beta: 0
+transA: 0
+transB: 1
+</details>
+<details>
+<summary>LRN: 4 out of 4 attributes covered</summary>
+
+alpha: 1
+beta: 1
+bias: 1
+size: 1
+</details>
+<details>
+<summary>MaxPool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+dilations: 0
+kernel_shape: 1
+pads: 3
+storage_order: 0
+strides: 2
+</details>
+<details>
+<summary>Unsqueeze: 1 out of 0 attributes covered</summary>
+
+</details>
+</details>
+
+
+## inception_v2
+
+inception_v2 has 916 nodes. Of these, 916 are covered by node tests (100.0%)
+
+
+<details>
+<summary>nodes</summary>
+
+<details>
+<summary>AveragePool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+count_include_pad: 0
+dilations: 0
+kernel_shape: 3
+pads: 3
+strides: 2
+</details>
+<details>
+<summary>BatchNormalization: 1 out of 3 attributes covered</summary>
+
+epsilon: 1
+momentum: 0
+training_mode: 0
+</details>
+<details>
+<summary>Concat: 1 out of 1 attributes covered</summary>
+
+axis: 1
+</details>
+<details>
+<summary>ConstantOfShape: 1 out of 1 attributes covered</summary>
+
+value: 1
+</details>
+<details>
+<summary>Conv: 4 out of 6 attributes covered</summary>
+
+auto_pad: 0
+dilations: 0
+group: 1
+kernel_shape: 5
+pads: 4
+strides: 3
+</details>
+<details>
+<summary>Dropout: 1 out of 1 attributes covered</summary>
+
+seed: 0
+</details>
+<details>
+<summary>Gemm: 1 out of 4 attributes covered</summary>
+
+alpha: 0
+beta: 0
+transA: 0
+transB: 1
+</details>
+<details>
+<summary>LRN: 4 out of 4 attributes covered</summary>
+
+alpha: 1
+beta: 1
+bias: 1
+size: 1
+</details>
+<details>
+<summary>MaxPool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+dilations: 0
+kernel_shape: 1
+pads: 3
+storage_order: 0
+strides: 2
+</details>
+<details>
+<summary>Unsqueeze: 1 out of 0 attributes covered</summary>
+
+</details>
+</details>
+
+
+## resnet50
+
+resnet50 has 415 nodes. Of these, 415 are covered by node tests (100.0%)
+
+
+<details>
+<summary>nodes</summary>
+
+<details>
+<summary>AveragePool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+count_include_pad: 0
+dilations: 0
+kernel_shape: 3
+pads: 3
+strides: 2
+</details>
+<details>
+<summary>BatchNormalization: 1 out of 3 attributes covered</summary>
+
+epsilon: 2
+momentum: 0
+training_mode: 0
+</details>
+<details>
+<summary>Concat: 1 out of 1 attributes covered</summary>
+
+axis: 1
+</details>
+<details>
+<summary>ConstantOfShape: 1 out of 1 attributes covered</summary>
+
+value: 1
+</details>
+<details>
+<summary>Conv: 4 out of 6 attributes covered</summary>
+
+auto_pad: 0
+dilations: 0
+group: 1
+kernel_shape: 5
+pads: 4
+strides: 3
+</details>
+<details>
+<summary>Dropout: 1 out of 1 attributes covered</summary>
+
+seed: 0
+</details>
+<details>
+<summary>Gemm: 1 out of 4 attributes covered</summary>
+
+alpha: 0
+beta: 0
+transA: 0
+transB: 1
+</details>
+<details>
+<summary>LRN: 4 out of 4 attributes covered</summary>
+
+alpha: 1
+beta: 1
+bias: 1
+size: 1
+</details>
+<details>
+<summary>MaxPool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+dilations: 0
+kernel_shape: 1
+pads: 3
+storage_order: 0
+strides: 2
+</details>
+<details>
+<summary>Unsqueeze: 1 out of 0 attributes covered</summary>
+
+</details>
+</details>
+
+
+## shufflenet
+
+shufflenet has 446 nodes. Of these, 446 are covered by node tests (100.0%)
+
+
+<details>
+<summary>nodes</summary>
+
+<details>
+<summary>AveragePool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+count_include_pad: 0
+dilations: 0
+kernel_shape: 3
+pads: 3
+strides: 2
+</details>
+<details>
+<summary>BatchNormalization: 1 out of 3 attributes covered</summary>
+
+epsilon: 2
+momentum: 0
+training_mode: 0
+</details>
+<details>
+<summary>Concat: 1 out of 1 attributes covered</summary>
+
+axis: 1
+</details>
+<details>
+<summary>ConstantOfShape: 1 out of 1 attributes covered</summary>
+
+value: 1
+</details>
+<details>
+<summary>Conv: 4 out of 6 attributes covered</summary>
+
+auto_pad: 0
+dilations: 0
+group: 6
+kernel_shape: 5
+pads: 4
+strides: 3
+</details>
+<details>
+<summary>Dropout: 1 out of 1 attributes covered</summary>
+
+seed: 0
+</details>
+<details>
+<summary>Gemm: 1 out of 4 attributes covered</summary>
+
+alpha: 0
+beta: 0
+transA: 0
+transB: 1
+</details>
+<details>
+<summary>LRN: 4 out of 4 attributes covered</summary>
+
+alpha: 1
+beta: 1
+bias: 1
+size: 1
+</details>
+<details>
+<summary>MaxPool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+dilations: 0
+kernel_shape: 1
+pads: 3
+storage_order: 0
+strides: 2
+</details>
+<details>
+<summary>Transpose: 1 out of 1 attributes covered</summary>
+
+perm: 1
+</details>
+<details>
+<summary>Unsqueeze: 1 out of 0 attributes covered</summary>
+
+</details>
+</details>
+
+
+## squeezenet_old
+
+squeezenet_old has 105 nodes. Of these, 105 are covered by node tests (100.0%)
+
+
+<details>
+<summary>nodes</summary>
+
+<details>
+<summary>AveragePool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+count_include_pad: 0
+dilations: 0
+kernel_shape: 3
+pads: 3
+strides: 2
+</details>
+<details>
+<summary>BatchNormalization: 1 out of 3 attributes covered</summary>
+
+epsilon: 2
+momentum: 0
+training_mode: 0
+</details>
+<details>
+<summary>Concat: 1 out of 1 attributes covered</summary>
+
+axis: 1
+</details>
+<details>
+<summary>ConstantOfShape: 1 out of 1 attributes covered</summary>
+
+value: 1
+</details>
+<details>
+<summary>Conv: 4 out of 6 attributes covered</summary>
+
+auto_pad: 0
+dilations: 0
+group: 6
+kernel_shape: 5
+pads: 4
+strides: 3
+</details>
+<details>
+<summary>Dropout: 1 out of 1 attributes covered</summary>
+
+seed: 0
+</details>
+<details>
+<summary>Gemm: 1 out of 4 attributes covered</summary>
+
+alpha: 0
+beta: 0
+transA: 0
+transB: 1
+</details>
+<details>
+<summary>LRN: 4 out of 4 attributes covered</summary>
+
+alpha: 1
+beta: 1
+bias: 1
+size: 1
+</details>
+<details>
+<summary>MaxPool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+dilations: 0
+kernel_shape: 1
+pads: 3
+storage_order: 0
+strides: 2
+</details>
+<details>
+<summary>Transpose: 1 out of 1 attributes covered</summary>
+
+perm: 1
+</details>
+<details>
+<summary>Unsqueeze: 1 out of 0 attributes covered</summary>
+
+</details>
+</details>
+
+
+## vgg19
+
+vgg19 has 82 nodes. Of these, 82 are covered by node tests (100.0%)
+
+
+<details>
+<summary>nodes</summary>
+
+<details>
+<summary>AveragePool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+count_include_pad: 0
+dilations: 0
+kernel_shape: 3
+pads: 3
+strides: 2
+</details>
+<details>
+<summary>BatchNormalization: 1 out of 3 attributes covered</summary>
+
+epsilon: 2
+momentum: 0
+training_mode: 0
+</details>
+<details>
+<summary>Concat: 1 out of 1 attributes covered</summary>
+
+axis: 1
+</details>
+<details>
+<summary>ConstantOfShape: 1 out of 1 attributes covered</summary>
+
+value: 1
+</details>
+<details>
+<summary>Conv: 4 out of 6 attributes covered</summary>
+
+auto_pad: 0
+dilations: 0
+group: 6
+kernel_shape: 5
+pads: 4
+strides: 3
+</details>
+<details>
+<summary>Dropout: 1 out of 1 attributes covered</summary>
+
+seed: 0
+</details>
+<details>
+<summary>Gemm: 1 out of 4 attributes covered</summary>
+
+alpha: 0
+beta: 0
+transA: 0
+transB: 1
+</details>
+<details>
+<summary>LRN: 4 out of 4 attributes covered</summary>
+
+alpha: 1
+beta: 1
+bias: 1
+size: 1
+</details>
+<details>
+<summary>MaxPool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+dilations: 0
+kernel_shape: 2
+pads: 3
+storage_order: 0
+strides: 2
+</details>
+<details>
+<summary>Transpose: 1 out of 1 attributes covered</summary>
+
+perm: 1
+</details>
+<details>
+<summary>Unsqueeze: 1 out of 0 attributes covered</summary>
+
+</details>
+</details>
+
+
+## zfnet512
+
+zfnet512 has 38 nodes. Of these, 38 are covered by node tests (100.0%)
+
+
+<details>
+<summary>nodes</summary>
+
+<details>
+<summary>AveragePool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+count_include_pad: 0
+dilations: 0
+kernel_shape: 3
+pads: 3
+strides: 2
+</details>
+<details>
+<summary>BatchNormalization: 1 out of 3 attributes covered</summary>
+
+epsilon: 2
+momentum: 0
+training_mode: 0
+</details>
+<details>
+<summary>Concat: 1 out of 1 attributes covered</summary>
+
+axis: 1
+</details>
+<details>
+<summary>ConstantOfShape: 1 out of 1 attributes covered</summary>
+
+value: 1
+</details>
+<details>
+<summary>Conv: 4 out of 6 attributes covered</summary>
+
+auto_pad: 0
+dilations: 0
+group: 6
+kernel_shape: 5
+pads: 4
+strides: 3
+</details>
+<details>
+<summary>Dropout: 1 out of 1 attributes covered</summary>
+
+seed: 0
+</details>
+<details>
+<summary>Gemm: 1 out of 4 attributes covered</summary>
+
+alpha: 0
+beta: 0
+transA: 0
+transB: 1
+</details>
+<details>
+<summary>LRN: 4 out of 4 attributes covered</summary>
+
+alpha: 2
+beta: 1
+bias: 2
+size: 1
+</details>
+<details>
+<summary>MaxPool: 3 out of 7 attributes covered</summary>
+
+auto_pad: 0
+ceil_mode: 0
+dilations: 0
+kernel_shape: 2
+pads: 3
+storage_order: 0
+strides: 2
+</details>
+<details>
+<summary>Transpose: 1 out of 1 attributes covered</summary>
+
+perm: 1
+</details>
+<details>
+<summary>Unsqueeze: 1 out of 0 attributes covered</summary>
+
+</details>
+</details>
+
+
+# Overall Test Coverage
+## To be filled.
diff --git a/docs/TypeDenotation.md b/docs/TypeDenotation.md
new file mode 100644
index 0000000..b3c8c3b
--- /dev/null
+++ b/docs/TypeDenotation.md
@@ -0,0 +1,62 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Type Denotation
+
+Type Denotation is used to describe semantic information around what the inputs and outputs are.    It is stored on the TypeProto message.
+
+## Motivation
+
+The motivation of such a mechanism can be illustrated via a simple example. In the neural network SqueezeNet, it takes in an NCHW image input float[1,3,244,244] and produces a output float[1,1000,1,1]:
+
+```text
+input_in_NCHW -> data_0 -> SqueezeNet() -> output_softmaxout_1
+```
+
+In order to run this model the user needs a lot of information.    In this case the user needs to know:
+
+* the input is an image
+* the image is in the format of NCHW
+* the color channels are in the order of bgr
+* the pixel data is 8 bit
+* the pixel data is normalized as values 0-255
+
+This proposal consists of three key components to provide all of this information:
+
+* Type Denotation,
+* [Dimension Denotation](DimensionDenotation.md),
+* [Model Metadata](MetadataProps.md).
+
+## Type Denotation Definition
+
+To begin with, we define a set of semantic types that define what models generally consume as inputs and produce as outputs.
+
+Specifically, in our first proposal we define the following set of standard denotations:
+
+0. `TENSOR` describes that a type holds a generic tensor using the standard TypeProto message.
+1. `IMAGE` describes that a type holds an image.  You can use dimension denotation to learn more about the layout of the image, and also the optional model metadata_props.
+2. `AUDIO` describes that a type holds an audio clip.
+3. `TEXT` describes that a type holds a block of text.
+
+Model authors SHOULD add type denotation to inputs and outputs for the model as appropriate.
+
+## An Example with input IMAGE
+
+Let's use the same SqueezeNet example from above and show everything to properly annotate the model:
+
+* First set the TypeProto.denotation =`IMAGE` for the ValueInfoProto `data_0`
+* Because it's an image, the model consumer now knows to go look for image metadata on the model
+* Then include 3 metadata strings on ModelProto.metadata_props
+  * `Image.BitmapPixelFormat` = `Bgr8`
+  * `Image.ColorSpaceGamma` = `SRGB`
+  * `Image.NominalPixelRange` = `NominalRange_0_255`
+* For that same ValueInfoProto, make sure to also use Dimension Denotations to denote NCHW
+  * TensorShapeProto.Dimension[0].denotation = `DATA_BATCH`
+  * TensorShapeProto.Dimension[1].denotation = `DATA_CHANNEL`
+  * TensorShapeProto.Dimension[2].denotation = `DATA_FEATURE`
+  * TensorShapeProto.Dimension[3].denotation = `DATA_FEATURE`
+
+Now there is enough information in the model to know everything about how to pass a correct image into the model.
diff --git a/docs/VersionConverter.md b/docs/VersionConverter.md
new file mode 100644
index 0000000..2aa0701
--- /dev/null
+++ b/docs/VersionConverter.md
@@ -0,0 +1,55 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Version Converter
+
+ONNX provides a library for converting ONNX models between different
+opset versions. The primary motivation is to improve backwards compatibility of ONNX
+models without having to strengthen the spec for ONNX backends.  This
+allows backend developers to offer support for a particular opset version
+and for users to write or export models to a particular opset version but
+run in an environment with a different opset version. Implementation wise, the library leverages the in-memory representation that is much more convenient to manipulate than the raw protobuf structs, and converters to and from the protobuf format which were developed for the ONNX Optimizer.
+
+You may be interested in invoking the provided op-specific adapters, or in
+implementing new ones (or both). Default adapters only work in the default
+domain, but can be generalized to work cross-domain or utilizing new
+conversion methods, dependent on the nature of relevant breaking changes.
+
+## Invoking The Version Converter
+
+The version converter may be invoked either via C++ or Python.
+
+The Python API
+is described, with example,
+[here](PythonAPIOverview.md#converting-version-of-an-onnx-model-within-default-domain-aionnx).
+
+The C++ API consists of a single function
+
+```cpp
+ModelProto ConvertVersion(
+    const ModelProto& mp_in,
+    const OpSetID& initial_version,
+    const OpSetID& target_version);
+```
+
+which accepts an input `ModelProto`, the initial opset version of the model,
+and the target opset version, and which returns a new `ModelProto` which
+is the result of apply all relevant adapters between initial_version and
+target_version. For a list of available passes, see
+[convert.h](/onnx/version_converter/convert.h).
+
+## Implementing Adapters
+
+You can implement a new adapter by subclassing `Adapter`, and registering
+your new adapter with `VersionConverter::registerAdapter()`. Adapters operate
+on an in-memory graph representation defined in [ir.h](/onnx/common/ir.h).
+There are a number of examples in the [adapters](/onnx/version_converter/adapters)
+directory.  Please ensure that all adapters convert from opset version i to i + 1
+or i - 1, i.e. from Version 6 to Version 5 or vice versa, even if the 2 versions
+being converted between are Version 1 and Version 6.
+
+If your adapter applies in the default domain, please consider adding it
+to the core ONNX repository
diff --git a/docs/Versioning.md b/docs/Versioning.md
new file mode 100644
index 0000000..5356a2e
--- /dev/null
+++ b/docs/Versioning.md
@@ -0,0 +1,205 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Versioning
+
+This document describes the rules for versioning ONNX. MUST, SHOULD et al are used consistent with [RFC2119](https://tools.ietf.org/html/rfc2119).
+
+## Versioning Principles
+
+ONNX defines the versioning policy and mechanism for three classes of entities:
+
+* The [intermediate representation (IR) specification](IR.md), which is the abstract model for graphs and operators and the concrete format that represents them. These are always versioned atomically and are referred to as the *IR version*.
+* Operator specifications that may be referenced by a given ONNX graph. We refer to this as the *operator version*.
+* A defined/trained model that defines a specific graph in terms of specific operators. We refer to this as the *model version*.
+
+The versioning of all three of these entity types is distinct and largely independent. The IR specification evolves at a different (generally slower) rate than the operator specifications. Model versions are entirely independent of the other two versions.
+
+Specific policies for version management are mandated only for IR version and operator version. For model versioning, they are merely recommendations. For model versioning, ONNX users and systems MAY follow whichever local customs make sense; however, to facilitate easily managing shared collections of ONNX models, they SHOULD adhere to the policies described under model versioning.
+
+New IR and operator versions are released as part of ONNX _releases_, which have their own versioning scheme. The release versioning scheme is not described as part of the standard itself. It is discussed in the [ONNX release management document](../RELEASE-MANAGEMENT.md).
+
+### Semantic Versioning or Simple Numbers?
+
+The ONNX versioning system allows for simple monotonically increasing numbers or [semantic versioning (SemVer)](https://semver.org/). For IR and operator sets, versioning is based on simple numbers. For models, ONNX does not require any scheme, but recommends a set of shared conventions.
+
+Which versioning scheme is in use by a model is made clear by inspecting the most significant four bytes, which MUST be non-zero when using semantic versioning and MUST be zero when using simple numbers. In other words, when using SemVer, at least one of the MAJOR or MINOR numbers must be non-zero.
+
+### SemVer, Files and Consumers
+
+For model and release versioning, ONNX builds on the principles and syntax defined by [SemVer 2.0.0](http://semver.org/spec/v2.0.0.html). Throughout this document, we use the terms *breaking change*, *non-breaking change*, and *patch* consistent with SemVer 2.0.0.
+
+Because ONNX models are serialized files (not APIs), it's worth making clear the relationship between a serialized model and a piece of software that consumes that model. As a rough approximation, the serialized model plays the role of an API's *callee*, while the consumer of the serialized model plays the role of the API's *caller*.
+
+The ONNX versioning principles are based on the [robustness principle](https://en.wikipedia.org/wiki/Robustness_principle): "be conservative in what you do, be liberal in what you accept from others".
+
+1. A producer of a given ONNX model (and the ONNX specification itself) MUST strictly adhere to the rules for breaking vs. non-breaking changes defined in this specification.
+2. A consumer of a given ONNX model SHOULD consume an updated ONNX file, provided there are no breaking changes in the new ONNX file's IR version, referenced operator versions, or model version (meaning the MAJOR version numbers have not changed between the two ONNX files).
+3. A consumer of a given ONNX model MAY consume an updated ONNX file, provided there are one or more breaking changes in the new ONNX file's IR version, referenced operator versions, or model version.
+
+### Serializing SemVer version numbers in protobuf
+
+For efficiency, ONNX serializes the MAJOR, MINOR, and PATCH values as a bit-packed 64-bit integer; the two most significant bytes are the MAJOR component, the next two most significant bytes are the MINOR component, and the least significant four bytes are the PATCH component.
+
+For example, *1.2.345* is represented as *0x0001000200000159*.
+
+Pre-release and build metadata are not stored in the model.
+
+## IR versioning
+
+The IR format is versioned using simple numbers, which MUST be monotonically increasing. Breaking changes to the format or semantics of the ONNX specification require an increment of the version. Non-breaking changes to the IR format do not require changing the version number.
+
+NOTE: breaking changes include those that do not alter the serialized binary format, but still break software using libraries that write or read it. For example, changing the spelling of a message property will cause code accessing the property break.
+
+The IR format adheres to the versioning guidelines defined in the [Updating a Message Type](https://developers.google.com/protocol-buffers/docs/proto3#updating) section of the proto3 specification.
+
+As a general principle, implementations SHOULD be robust in the face of missing fields. However, to ensure basic interoperation, a subset of message fields will be marked as required for a given IR version and all producers MUST set these fields correctly. Required fields MUST always be marked with the comment:
+
+    // This field MUST be present for this version of the IR.
+
+For example, the `ModelProto.ir_version` property MUST be present in every model. The ONNX checker (`onnx/checker.py`) will enforce these rules.
+
+Because the protocol buffer message definitions (.proto / .proto3 files) are expected to be consumed by multiple independent developers, changes to those definitions SHOULD NOT break code that depends on generated language bindings (e.g., changing the type of an existing field).
+
+## Operator versioning
+
+The IR can evolve independently from the set of operators. Operators represent both the signature and semantics of a given operation. Operators are abstract interfaces in that they do not imply a specific implementation; rather, they are simply the contract between a model author and the implementations that model may execute on.
+
+A given operator is identified by a three-tuple: `(domain, op_type, since_version)`, written as `domain.op_type:since_version` in prose (e.g., `com.acme.FastConv:3`). `since_version` is the version of the operator set that introduced the operator. Breaking operator changes include:
+
+* Adding/removing/renaming an attribute. This even includes the case of adding a new optional attribute, where omitting the attribute would imply a default value yielding semantics identical to the previous operator version.
+
+* Adding/removing/reordering inputs or outputs.
+
+* Adding/removing types supported by inputs and outputs, and changing types used by attributes.
+
+* Supporting new behavior even when the existing parameter signature is otherwise identical (e.g. implicitly supporting tensor broadcasting in the Mean operator).
+
+The following are not breaking:
+
+* Clarifications of specification ambiguities to match prevailing
+  implementation practice.
+
+Changes to the semantics of an operator or function MUST be introduced in a new operator, which MUST be introduced in a new [operator set](#operator-sets).
+
+> In practice, this means that BC-breaking changes in the ONNX
+> repository require contributors to follow these steps:
+>
+> 1. Increment the maximum version in `DomainToVersionRange`.
+> 2. Copy the old operator schema to an `old.cc` file.
+> 3. Update the `SinceVersion` signifier to the new max version from
+>    step (1).
+> 4. Register the new operator in the corresponding `operator_sets`
+>    header file.
+> 5. Add a version adapter to `convert.h` so that the version
+>    converter can upgrade the old version of the operator to the new
+>    one. This can be a `CompatibleAdapter` in case operators following
+>    the old schema are still valid under the new one (which is usually
+>    true).
+> 6. A version adapter to downgrade the new operator to the older version
+>    can also be added to `convert.h` but it's not mandatory.
+
+How nodes bind to operator declarations is strictly defined, and are designed to increase model compatibility across ONNX implementations, in the spirit of the conservative clause of the robustness principle.
+
+How ONNX implementations bind an operator declaration to a specific implementation is outside the scope of this specification. Implementations of ONNX MAY elect to introduce more sophisticated operator declaration/implementation binding modes, in the spirit of the liberal clause of the robustness principle.
+
+### Operator sets
+
+ONNX uses operator sets to group together immutable operator specifications. An operator set represents a specific version of a domain, indicated by a pair (domain, version). This represents the set of all operators belonging to the specified domain with the specified version (referred to as the `opset_version`). When the inventory of a given operator set changes either by addition, removal, or a change in semantics of a contained operator, its version MUST increase.
+
+Models declare which operator sets they require as a list of `(domain, opset_version)` pairs in `ModelProto.opset_import`. The empty string ("") domain indicates the operators defined as part of the ONNX specification; other domains correspond to operator sets of other vendors (meaning they can be used to provide vendor-specific extensions to ONNX). The union of the operator sets specified by a given model MUST have a compatible operator declaration for each node in the model's graph.
+
+### Example
+
+This section is not normative and informational only.
+
+Given the following operator sets:
+
+OpSet|Operators|Comments
+-|-|-
+1|{A}           | A introduced
+2|{A, B}        | B introduced
+3|{A', B, C}    | A updated (to A'), C introduced
+4|{B, C'}       | A removed, C updated (to C')
+
+The operators for a given operator set will have the following `since_version` values:
+
+Operator|OpSet 1|OpSet 2|OpSet 3|OpSet 4
+-|-|-|-|-
+A|**1** |1      |**3**  |**-**
+B|-     |**2**  |2      |2
+C|-     |-      |**3**  |**4**
+
+Notes:
+
+- Values that are new or updated from a previous OpSet version are in **bold**.
+
+## Model versioning
+
+This section of the specification is not normative. It simply outlines a set of recommended practices.
+
+Model authors and applications/systems MAY elect to ignore the model versioning mechanism and policy rules. For models that will be shared across developers, teams, or organizations, model authors and applications/systems SHOULD adhere to the following version policies:
+
+### Signature Changes
+
+1. Breaking changes to the ModelProto.graph.GraphProto.input or .output MUST increment the MAJOR version of `ModelProto.model_version`. Breaking changes include:
+
+    * Breaking changes to the semantics of an input or output (e.g., changing the required contents of an input tensor from a color image to a black and white image).
+    * Changing the declared type of an input or output to an incompatible type (e.g., `tensor(int)->tensor(string)`).
+    * Adding a new input for which there is no meaningful or specified default value. Recall that default values for inputs are specified in the initializer list.
+    * Removing an existing output for which there is no meaningful or specified default value.
+
+2. Non-breaking changes to the ModelProto.graph.GraphProto.input or .output MUST increment the MINOR version of `ModelProto.model_version`. Non-breaking changes include:
+
+    * Changing the declared type of an input or output to a compatible/widening type (e.g., `tensor(int32)->tensor(int64)`, `tensor(float16)->tensor(float32)`).
+    * Adding a new input for which there is a meaningful or specified default value.
+    * Adding new behavior that is only triggered in the presence of inputs that were not
+    possible in prior versions of the graph (typically by the presence of a new input
+    or allowing a previously invalid input value).
+
+### Accuracy or performance changes
+
+Changes that impact accuracy or performance significantly but do not change the model's inputs or outputs SHOULD increment the PATCH version of `ModelProto.model_version`.
+
+## Released Versions
+
+ONNX version|IR version|Opset version ai.onnx|Opset version ai.onnx.ml|Opset version ai.onnx.training
+------------|-------------------|---------------------|------------------------|------------------------------
+1.0|3|1|1|-
+1.1|3|5|1|-
+1.1.2|3|6|1|-
+1.2|3|7|1|-
+1.3|3|8|1|-
+1.4.1|4|9|1|-
+1.5.0|5|10|1|-
+1.6.0|6|11|2|-
+1.7.0|7|12|2|1
+1.8.0|7|13|2|1
+1.8.1|7|13|2|1
+1.9.0|7|14|2|1
+1.10.0|8|15|2|1
+1.10.1|8|15|2|1
+1.10.2|8|15|2|1
+1.11.0|8|16|3|1
+1.12.0|8|17|3|1
+1.13.0|8|18|3|1
+1.13.1|8|18|3|1
+1.14.0|9|19|3|1
+1.14.1|9|19|3|1
+1.15.0|9|20|4|1
+1.16.0|10|21|5|1
+1.16.1|10|21|5|1
+1.16.2|10|21|5|1
+1.17.0|10|22|5|1
+1.18.0|11|23|5|1
+1.19.0|12|24|5|1
+1.19.1|12|24|5|1
+1.20.0|13|25|5|1
+1.20.1|13|25|5|1
+1.21.0|13|26|5|1
+
+The version number is centrally defined in [VERSION_NUMBER](../VERSION_NUMBER).
+Programmatically accessible version information is available from [onnx/helper.py](../onnx/helper.py), `onnx/common/version.h` (auto-generated) and [onnx/defs/schema.h](../onnx/defs/schema.h).
diff --git a/docs/docsgen/Makefile b/docs/docsgen/Makefile
new file mode 100644
index 0000000..c7fb98f
--- /dev/null
+++ b/docs/docsgen/Makefile
@@ -0,0 +1,24 @@
+# Copyright (c) Sphinx Project
+#
+# SPDX-License-Identifier: BSD-2-Clause
+
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) --keep-going
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) --keep-going
diff --git a/docs/docsgen/make.bat b/docs/docsgen/make.bat
new file mode 100644
index 0000000..ed82127
--- /dev/null
+++ b/docs/docsgen/make.bat
@@ -0,0 +1,39 @@
+REM Copyright (c) Sphinx Project
+REM
+REM SPDX-License-Identifier: BSD-2-Clause
+
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/docs/docsgen/source/_static/ONNX-Logo.svg b/docs/docsgen/source/_static/ONNX-Logo.svg
new file mode 100644
index 0000000..d2d3adf
--- /dev/null
+++ b/docs/docsgen/source/_static/ONNX-Logo.svg
@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 23.0.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 210 52" style="enable-background:new 0 0 210 52;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#545554;}
+	.st2{fill:#3E3E3D;}
+	.st3{fill:#4D4C4D;}
+	.st4{fill:#5D5D5D;}
+	.st5{fill:#717272;}
+</style>
+<g>
+	<g>
+		<path class="st0" d="M50.8,24.2c-0.1,0-0.2,0-0.3,0L41.6,8c0.2-0.3,0.2-0.6,0.2-1c0-1.2-1-2.1-2.1-2.1c-0.6,0-1.2,0.3-1.5,0.7
+			L20.6,2c-0.1-1.1-1-1.9-2.1-1.9c-1.2,0-2.1,1-2.1,2.1c0,0.4,0.1,0.7,0.2,1L2.9,22.9c-0.2,0-0.4-0.1-0.6-0.1c-1.2,0-2.1,1-2.1,2.1
+			c0,1.2,1,2.1,2.1,2.1l0.1,0l7.4,18.3c-0.1,0.3-0.2,0.6-0.2,0.9c0,1.2,1,2.1,2.1,2.1c0.6,0,1.2-0.3,1.5-0.7l22.2,2.2
+			c0.2,0.9,1.1,1.6,2.1,1.6c1.2,0,2.1-1,2.1-2.1c0-0.5-0.2-1-0.5-1.4l11.2-19.5c0.1,0,0.2,0,0.4,0c1.2,0,2.1-1,2.1-2.1
+			C52.9,25.2,52,24.2,50.8,24.2z M38,8.3c0.3,0.3,0.6,0.6,1,0.7l-3.4,25.4c-0.2,0-0.4,0.1-0.6,0.2l-18.5-16c0-0.2,0.1-0.4,0.1-0.6
+			c0-0.1,0-0.3,0-0.4L38,8.3z M48.7,27l-11.4,7.8c-0.1-0.1-0.2-0.1-0.3-0.2L40.5,9l0,0l8.7,16c-0.3,0.4-0.5,0.9-0.5,1.4
+			C48.6,26.6,48.7,26.8,48.7,27z M14.2,15.9c-1,0.2-1.8,1-1.8,2.1l0,0.1l-7.6,4.5L16.6,5.7L14.2,15.9z M15,20.1
+			c0.3-0.1,0.6-0.2,0.8-0.3l18.3,15.9C34,35.9,34,36.2,34,36.5l0,0.1L13.5,45c-0.3-0.4-0.8-0.8-1.3-0.9L15,20.1z M34.5,37.9
+			c0.3,0.3,0.7,0.5,1.1,0.6l1,8.9c-0.4,0.2-0.8,0.6-1,1l-21.5-2.1L34.5,37.9z M37.1,38.4c0.7-0.3,1.2-1.1,1.2-1.9
+			c0-0.2,0-0.4-0.1-0.5l10.4-7.1L38.1,47.1L37.1,38.4z M37.6,6.9l-21.7,9.5c-0.1-0.1-0.2-0.1-0.2-0.2l2.8-11.8l0.1,0
+			c0.8,0,1.4-0.4,1.8-1L37.6,6.9L37.6,6.9z M4.5,24.9c0-0.1,0-0.3,0-0.4l8.6-5.1c0.2,0.2,0.4,0.3,0.6,0.4l-2.8,24l-7-17.3
+			C4.2,26.1,4.5,25.6,4.5,24.9z"/>
+		<path class="st0" d="M77,34.2V18.9c0-7.4,5.6-10.2,12.9-10.2c7.2,0,12.9,2.8,12.9,10.2v15.3c0,7.4-5.7,10.2-12.9,10.2
+			C82.6,44.4,77,41.6,77,34.2z M99.6,18.9c0-5.4-3.6-7.8-9.7-7.8c-6.1,0-9.7,2.5-9.7,7.8v15.3c0,5.4,3.6,7.8,9.7,7.8
+			c6.1,0,9.7-2.5,9.7-7.8V18.9z"/>
+		<path class="st0" d="M134.5,42.3l-18.8-27.8V43c0,0.7-0.8,1.1-1.6,1.1c-0.8,0-1.6-0.3-1.6-1.1V9.8c0-0.8,0.8-1,1.6-1
+			c1.2,0,2,1.2,2.6,2l18.5,27.6V9.8c0-0.7,0.8-1,1.6-1c0.8,0,1.6,0.3,1.6,1V43c0,0.7-0.8,1.1-1.6,1.1
+			C135.8,44.1,135.1,43.1,134.5,42.3z"/>
+		<path class="st0" d="M170.5,42.3l-18.8-27.8V43c0,0.7-0.8,1.1-1.6,1.1c-0.8,0-1.6-0.3-1.6-1.1V9.8c0-0.8,0.8-1,1.6-1
+			c1.2,0,2,1.2,2.6,2l18.5,27.6V9.8c0-0.7,0.8-1,1.6-1c0.8,0,1.6,0.3,1.6,1V43c0,0.7-0.8,1.1-1.6,1.1
+			C171.9,44.1,171.1,43.1,170.5,42.3z"/>
+		<path class="st0" d="M194.3,28.7l-9.5,13.8c-0.4,0.7-1,1.6-1.9,1.6c-0.8,0-1.8-0.5-1.8-1.2c0-0.2,0.1-0.4,0.3-0.6l11-15.9
+			l-10.8-15.8c-0.3-0.3-0.4-0.6-0.4-0.9c0-0.6,0.8-1,1.8-1c0.9,0,1.5,0.9,2,1.7l9.3,13.7l9.3-13.7c0.5-0.7,1.1-1.7,2-1.7
+			c1,0,1.8,0.4,1.8,1c0,0.3-0.1,0.6-0.4,0.9l-10.9,15.8l11.1,15.9c0.1,0.2,0.3,0.4,0.3,0.6c0,0.7-0.9,1.2-1.8,1.2
+			c-1,0-1.5-1-1.9-1.6L194.3,28.7z"/>
+	</g>
+	<path class="st1" d="M40.5,9l8.7,16c-0.3,0.4-0.5,0.9-0.5,1.4c0,0.2,0,0.4,0.1,0.6l-11.4,7.8c-0.1-0.1-0.2-0.1-0.3-0.2L40.5,9
+		L40.5,9"/>
+	<path class="st2" d="M37.1,38.4c0.7-0.3,1.2-1.1,1.2-1.9c0-0.2,0-0.4-0.1-0.5l10.4-7.1L38.1,47.1L37.1,38.4z"/>
+	<path class="st3" d="M34.5,37.9c0.3,0.3,0.7,0.5,1.1,0.6l1,8.9c-0.4,0.2-0.8,0.6-1,1l-21.5-2.1L34.5,37.9z"/>
+	<path class="st4" d="M15,20.1c0.3-0.1,0.6-0.2,0.8-0.3l18.3,15.9C34,35.9,34,36.2,34,36.5l0,0.1L13.5,45c-0.3-0.4-0.8-0.8-1.3-0.9
+		L15,20.1z"/>
+	<path class="st3" d="M4.5,24.9c0-0.1,0-0.3,0-0.4l8.6-5.1c0.2,0.2,0.4,0.3,0.6,0.4l-2.8,24l-7-17.3C4.2,26.1,4.5,25.6,4.5,24.9z"/>
+	<path class="st2" d="M14.2,15.9c-1,0.2-1.8,1-1.8,2.1l0,0.1l-7.6,4.5L16.6,5.7L14.2,15.9z"/>
+	<path class="st1" d="M37.6,6.9l-21.7,9.5c-0.1-0.1-0.2-0.1-0.2-0.2l2.8-11.8l0.1,0c0.8,0,1.4-0.4,1.8-1L37.6,6.9L37.6,6.9z"/>
+	<path class="st5" d="M38,8.3c0.3,0.3,0.6,0.6,1,0.7l-3.4,25.4c-0.2,0-0.4,0.1-0.6,0.2l-18.5-16c0-0.2,0.1-0.4,0.1-0.6
+		c0-0.1,0-0.3,0-0.4L38,8.3z"/>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+<g>
+</g>
+</svg>
diff --git a/docs/docsgen/source/_static/css/custom.css b/docs/docsgen/source/_static/css/custom.css
new file mode 100644
index 0000000..8db8be6
--- /dev/null
+++ b/docs/docsgen/source/_static/css/custom.css
@@ -0,0 +1,36 @@
+@import "../basic.css";
+
+html[data-theme="dark"] {
+    --pst-color-text-base: #5c8fda;
+}
+
+.d2h-del {
+    background-color: var(--pst-color-danger-highlight);
+    color: var(--pst-color-text-base);
+}
+
+.d2h-ins {
+    background-color: var(--pst-color-success);
+    color: var(--pst-color-text-base);
+}
+
+.d2h-change {
+    background-color: var(--yellow);
+    color: var(--pst-color-text-base);
+}
+
+.sphinx-tabs-panel {
+    background-color: var(--pst-color-background);
+}
+
+.sphinx-tabs-tab {
+    background-color: var(--pst-color-background);
+}
+
+.sphinx-tabs {
+    background-color: var(--pst-color-background);
+}
+
+.closeable{
+    background-color: var(--pst-color-background);
+}
diff --git a/docs/docsgen/source/_static/diff2html-ui-slim.min.js b/docs/docsgen/source/_static/diff2html-ui-slim.min.js
new file mode 100644
index 0000000..da87c3e
--- /dev/null
+++ b/docs/docsgen/source/_static/diff2html-ui-slim.min.js
@@ -0,0 +1 @@
+!function(e,n){if("object"==typeof exports&&"object"==typeof module)module.exports=n();else if("function"==typeof define&&define.amd)define([],n);else{var t=n();for(var i in t)("object"==typeof exports?exports:e)[i]=t[i]}}(this,(()=>(()=>{var e={696:(e,n)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.convertChangesToDMP=function(e){for(var n,t,i=[],a=0;a<e.length;a++)t=(n=e[a]).added?1:n.removed?-1:0,i.push([t,n.value]);return i}},5826:(e,n)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.convertChangesToXML=function(e){for(var n=[],t=0;t<e.length;t++){var i=e[t];i.added?n.push("<ins>"):i.removed&&n.push("<del>"),n.push((a=i.value,void 0,a.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;"))),i.added?n.push("</ins>"):i.removed&&n.push("</del>")}var a;return n.join("")}},6976:(e,n,t)=>{"use strict";var i;Object.defineProperty(n,"__esModule",{value:!0}),n.diffArrays=function(e,n,t){return a.diff(e,n,t)},n.arrayDiff=void 0;var a=new(((i=t(5913))&&i.__esModule?i:{default:i}).default);n.arrayDiff=a,a.tokenize=function(e){return e.slice()},a.join=a.removeEmpty=function(e){return e}},5913:(e,n)=>{"use strict";function t(){}function i(e,n,t,i,a){for(var r=0,s=n.length,o=0,l=0;r<s;r++){var c=n[r];if(c.removed){if(c.value=e.join(i.slice(l,l+c.count)),l+=c.count,r&&n[r-1].added){var d=n[r-1];n[r-1]=n[r],n[r]=d}}else{if(!c.added&&a){var u=t.slice(o,o+c.count);u=u.map((function(e,n){var t=i[l+n];return t.length>e.length?t:e})),c.value=e.join(u)}else c.value=e.join(t.slice(o,o+c.count));o+=c.count,c.added||(l+=c.count)}}var g=n[s-1];return s>1&&"string"==typeof g.value&&(g.added||g.removed)&&e.equals("",g.value)&&(n[s-2].value+=g.value,n.pop()),n}Object.defineProperty(n,"__esModule",{value:!0}),n.default=t,t.prototype={diff:function(e,n){var t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},a=t.callback;"function"==typeof t&&(a=t,t={}),this.options=t;var r=this;function s(e){return a?(setTimeout((function(){a(void 0,e)}),0),!0):e}e=this.castInput(e),n=this.castInput(n),e=this.removeEmpty(this.tokenize(e));var o=(n=this.removeEmpty(this.tokenize(n))).length,l=e.length,c=1,d=o+l;t.maxEditLength&&(d=Math.min(d,t.maxEditLength));var u=[{newPos:-1,components:[]}],g=this.extractCommon(u[0],n,e,0);if(u[0].newPos+1>=o&&g+1>=l)return s([{value:this.join(n),count:n.length}]);function b(){for(var t=-1*c;t<=c;t+=2){var a=void 0,d=u[t-1],g=u[t+1],b=(g?g.newPos:0)-t;d&&(u[t-1]=void 0);var p=d&&d.newPos+1<o,f=g&&0<=b&&b<l;if(p||f){if(!p||f&&d.newPos<g.newPos?(a={newPos:(m=g).newPos,components:m.components.slice(0)},r.pushComponent(a.components,void 0,!0)):((a=d).newPos++,r.pushComponent(a.components,!0,void 0)),b=r.extractCommon(a,n,e,t),a.newPos+1>=o&&b+1>=l)return s(i(r,a.components,n,e,r.useLongestToken));u[t]=a}else u[t]=void 0}var m;c++}if(a)!function e(){setTimeout((function(){if(c>d)return a();b()||e()}),0)}();else for(;c<=d;){var p=b();if(p)return p}},pushComponent:function(e,n,t){var i=e[e.length-1];i&&i.added===n&&i.removed===t?e[e.length-1]={count:i.count+1,added:n,removed:t}:e.push({count:1,added:n,removed:t})},extractCommon:function(e,n,t,i){for(var a=n.length,r=t.length,s=e.newPos,o=s-i,l=0;s+1<a&&o+1<r&&this.equals(n[s+1],t[o+1]);)s++,o++,l++;return l&&e.components.push({count:l}),e.newPos=s,o},equals:function(e,n){return this.options.comparator?this.options.comparator(e,n):e===n||this.options.ignoreCase&&e.toLowerCase()===n.toLowerCase()},removeEmpty:function(e){for(var n=[],t=0;t<e.length;t++)e[t]&&n.push(e[t]);return n},castInput:function(e){return e},tokenize:function(e){return e.split("")},join:function(e){return e.join("")}}},7630:(e,n,t)=>{"use strict";var i;Object.defineProperty(n,"__esModule",{value:!0}),n.diffChars=function(e,n,t){return a.diff(e,n,t)},n.characterDiff=void 0;var a=new(((i=t(5913))&&i.__esModule?i:{default:i}).default);n.characterDiff=a},4852:(e,n,t)=>{"use strict";var i;Object.defineProperty(n,"__esModule",{value:!0}),n.diffCss=function(e,n,t){return a.diff(e,n,t)},n.cssDiff=void 0;var a=new(((i=t(5913))&&i.__esModule?i:{default:i}).default);n.cssDiff=a,a.tokenize=function(e){return e.split(/([{}:;,]|\s+)/)}},4276:(e,n,t)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.diffJson=function(e,n,t){return l.diff(e,n,t)},n.canonicalize=c,n.jsonDiff=void 0;var i,a=(i=t(5913))&&i.__esModule?i:{default:i},r=t(8187);function s(e){return s="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},s(e)}var o=Object.prototype.toString,l=new a.default;function c(e,n,t,i,a){var r,l;for(n=n||[],t=t||[],i&&(e=i(a,e)),r=0;r<n.length;r+=1)if(n[r]===e)return t[r];if("[object Array]"===o.call(e)){for(n.push(e),l=new Array(e.length),t.push(l),r=0;r<e.length;r+=1)l[r]=c(e[r],n,t,i,a);return n.pop(),t.pop(),l}if(e&&e.toJSON&&(e=e.toJSON()),"object"===s(e)&&null!==e){n.push(e),l={},t.push(l);var d,u=[];for(d in e)e.hasOwnProperty(d)&&u.push(d);for(u.sort(),r=0;r<u.length;r+=1)l[d=u[r]]=c(e[d],n,t,i,d);n.pop(),t.pop()}else l=e;return l}n.jsonDiff=l,l.useLongestToken=!0,l.tokenize=r.lineDiff.tokenize,l.castInput=function(e){var n=this.options,t=n.undefinedReplacement,i=n.stringifyReplacer,a=void 0===i?function(e,n){return void 0===n?t:n}:i;return"string"==typeof e?e:JSON.stringify(c(e,null,null,a),a,"  ")},l.equals=function(e,n){return a.default.prototype.equals.call(l,e.replace(/,([\r\n])/g,"$1"),n.replace(/,([\r\n])/g,"$1"))}},8187:(e,n,t)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.diffLines=function(e,n,t){return s.diff(e,n,t)},n.diffTrimmedLines=function(e,n,t){var i=(0,r.generateOptions)(t,{ignoreWhitespace:!0});return s.diff(e,n,i)},n.lineDiff=void 0;var i,a=(i=t(5913))&&i.__esModule?i:{default:i},r=t(8009),s=new a.default;n.lineDiff=s,s.tokenize=function(e){var n=[],t=e.split(/(\n|\r\n)/);t[t.length-1]||t.pop();for(var i=0;i<t.length;i++){var a=t[i];i%2&&!this.options.newlineIsToken?n[n.length-1]+=a:(this.options.ignoreWhitespace&&(a=a.trim()),n.push(a))}return n}},4146:(e,n,t)=>{"use strict";var i;Object.defineProperty(n,"__esModule",{value:!0}),n.diffSentences=function(e,n,t){return a.diff(e,n,t)},n.sentenceDiff=void 0;var a=new(((i=t(5913))&&i.__esModule?i:{default:i}).default);n.sentenceDiff=a,a.tokenize=function(e){return e.split(/(\S.+?[.!?])(?=\s+|$)/)}},5303:(e,n,t)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.diffWords=function(e,n,t){return t=(0,r.generateOptions)(t,{ignoreWhitespace:!0}),l.diff(e,n,t)},n.diffWordsWithSpace=function(e,n,t){return l.diff(e,n,t)},n.wordDiff=void 0;var i,a=(i=t(5913))&&i.__esModule?i:{default:i},r=t(8009),s=/^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/,o=/\S/,l=new a.default;n.wordDiff=l,l.equals=function(e,n){return this.options.ignoreCase&&(e=e.toLowerCase(),n=n.toLowerCase()),e===n||this.options.ignoreWhitespace&&!o.test(e)&&!o.test(n)},l.tokenize=function(e){for(var n=e.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/),t=0;t<n.length-1;t++)!n[t+1]&&n[t+2]&&s.test(n[t])&&s.test(n[t+2])&&(n[t]+=n[t+2],n.splice(t+1,2),t--);return n}},9479:(e,n,t)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),Object.defineProperty(n,"Diff",{enumerable:!0,get:function(){return a.default}}),Object.defineProperty(n,"diffChars",{enumerable:!0,get:function(){return r.diffChars}}),Object.defineProperty(n,"diffWords",{enumerable:!0,get:function(){return s.diffWords}}),Object.defineProperty(n,"diffWordsWithSpace",{enumerable:!0,get:function(){return s.diffWordsWithSpace}}),Object.defineProperty(n,"diffLines",{enumerable:!0,get:function(){return o.diffLines}}),Object.defineProperty(n,"diffTrimmedLines",{enumerable:!0,get:function(){return o.diffTrimmedLines}}),Object.defineProperty(n,"diffSentences",{enumerable:!0,get:function(){return l.diffSentences}}),Object.defineProperty(n,"diffCss",{enumerable:!0,get:function(){return c.diffCss}}),Object.defineProperty(n,"diffJson",{enumerable:!0,get:function(){return d.diffJson}}),Object.defineProperty(n,"canonicalize",{enumerable:!0,get:function(){return d.canonicalize}}),Object.defineProperty(n,"diffArrays",{enumerable:!0,get:function(){return u.diffArrays}}),Object.defineProperty(n,"applyPatch",{enumerable:!0,get:function(){return g.applyPatch}}),Object.defineProperty(n,"applyPatches",{enumerable:!0,get:function(){return g.applyPatches}}),Object.defineProperty(n,"parsePatch",{enumerable:!0,get:function(){return b.parsePatch}}),Object.defineProperty(n,"merge",{enumerable:!0,get:function(){return p.merge}}),Object.defineProperty(n,"structuredPatch",{enumerable:!0,get:function(){return f.structuredPatch}}),Object.defineProperty(n,"createTwoFilesPatch",{enumerable:!0,get:function(){return f.createTwoFilesPatch}}),Object.defineProperty(n,"createPatch",{enumerable:!0,get:function(){return f.createPatch}}),Object.defineProperty(n,"convertChangesToDMP",{enumerable:!0,get:function(){return m.convertChangesToDMP}}),Object.defineProperty(n,"convertChangesToXML",{enumerable:!0,get:function(){return E.convertChangesToXML}});var i,a=(i=t(5913))&&i.__esModule?i:{default:i},r=t(7630),s=t(5303),o=t(8187),l=t(4146),c=t(4852),d=t(4276),u=t(6976),g=t(3690),b=t(3719),p=t(3051),f=t(1286),m=t(696),E=t(5826)},3690:(e,n,t)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.applyPatch=s,n.applyPatches=function(e,n){"string"==typeof e&&(e=(0,a.parsePatch)(e));var t=0;!function i(){var a=e[t++];if(!a)return n.complete();n.loadFile(a,(function(e,t){if(e)return n.complete(e);var r=s(t,a,n);n.patched(a,r,(function(e){if(e)return n.complete(e);i()}))}))}()};var i,a=t(3719),r=(i=t(8169))&&i.__esModule?i:{default:i};function s(e,n){var t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};if("string"==typeof n&&(n=(0,a.parsePatch)(n)),Array.isArray(n)){if(n.length>1)throw new Error("applyPatch only works with a single input.");n=n[0]}var i,s,o=e.split(/\r\n|[\n\v\f\r\x85]/),l=e.match(/\r\n|[\n\v\f\r\x85]/g)||[],c=n.hunks,d=t.compareLine||function(e,n,t,i){return n===i},u=0,g=t.fuzzFactor||0,b=0,p=0;function f(e,n){for(var t=0;t<e.lines.length;t++){var i=e.lines[t],a=i.length>0?i[0]:" ",r=i.length>0?i.substr(1):i;if(" "===a||"-"===a){if(!d(n+1,o[n],a,r)&&++u>g)return!1;n++}}return!0}for(var m=0;m<c.length;m++){for(var E=c[m],h=o.length-E.oldLines,_=0,N=p+E.oldStart-1,T=(0,r.default)(N,b,h);void 0!==_;_=T())if(f(E,N+_)){E.offset=p+=_;break}if(void 0===_)return!1;b=E.offset+E.oldStart+E.oldLines}for(var O=0,A=0;A<c.length;A++){var v=c[A],y=v.oldStart+v.offset+O-1;O+=v.newLines-v.oldLines;for(var S=0;S<v.lines.length;S++){var R=v.lines[S],I=R.length>0?R[0]:" ",w=R.length>0?R.substr(1):R,C=v.linedelimiters[S];if(" "===I)y++;else if("-"===I)o.splice(y,1),l.splice(y,1);else if("+"===I)o.splice(y,0,w),l.splice(y,0,C),y++;else if("\\"===I){var L=v.lines[S-1]?v.lines[S-1][0]:null;"+"===L?i=!0:"-"===L&&(s=!0)}}}if(i)for(;!o[o.length-1];)o.pop(),l.pop();else s&&(o.push(""),l.push("\n"));for(var M=0;M<o.length-1;M++)o[M]=o[M]+l[M];return o.join("")}},1286:(e,n,t)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.structuredPatch=s,n.formatPatch=o,n.createTwoFilesPatch=l,n.createPatch=function(e,n,t,i,a,r){return l(e,e,n,t,i,a,r)};var i=t(8187);function a(e){return function(e){if(Array.isArray(e))return r(e)}(e)||function(e){if("undefined"!=typeof Symbol&&Symbol.iterator in Object(e))return Array.from(e)}(e)||function(e,n){if(e){if("string"==typeof e)return r(e,n);var t=Object.prototype.toString.call(e).slice(8,-1);return"Object"===t&&e.constructor&&(t=e.constructor.name),"Map"===t||"Set"===t?Array.from(e):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?r(e,n):void 0}}(e)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function r(e,n){(null==n||n>e.length)&&(n=e.length);for(var t=0,i=new Array(n);t<n;t++)i[t]=e[t];return i}function s(e,n,t,r,s,o,l){l||(l={}),void 0===l.context&&(l.context=4);var c=(0,i.diffLines)(t,r,l);if(c){c.push({value:"",lines:[]});for(var d=[],u=0,g=0,b=[],p=1,f=1,m=function(e){var n=c[e],i=n.lines||n.value.replace(/\n$/,"").split("\n");if(n.lines=i,n.added||n.removed){var s;if(!u){var o=c[e-1];u=p,g=f,o&&(b=l.context>0?h(o.lines.slice(-l.context)):[],u-=b.length,g-=b.length)}(s=b).push.apply(s,a(i.map((function(e){return(n.added?"+":"-")+e})))),n.added?f+=i.length:p+=i.length}else{if(u)if(i.length<=2*l.context&&e<c.length-2){var m;(m=b).push.apply(m,a(h(i)))}else{var E,_=Math.min(i.length,l.context);(E=b).push.apply(E,a(h(i.slice(0,_))));var N={oldStart:u,oldLines:p-u+_,newStart:g,newLines:f-g+_,lines:b};if(e>=c.length-2&&i.length<=l.context){var T=/\n$/.test(t),O=/\n$/.test(r),A=0==i.length&&b.length>N.oldLines;!T&&A&&t.length>0&&b.splice(N.oldLines,0,"\\ No newline at end of file"),(T||A)&&O||b.push("\\ No newline at end of file")}d.push(N),u=0,g=0,b=[]}p+=i.length,f+=i.length}},E=0;E<c.length;E++)m(E);return{oldFileName:e,newFileName:n,oldHeader:s,newHeader:o,hunks:d}}function h(e){return e.map((function(e){return" "+e}))}}function o(e){var n=[];e.oldFileName==e.newFileName&&n.push("Index: "+e.oldFileName),n.push("==================================================================="),n.push("--- "+e.oldFileName+(void 0===e.oldHeader?"":"\t"+e.oldHeader)),n.push("+++ "+e.newFileName+(void 0===e.newHeader?"":"\t"+e.newHeader));for(var t=0;t<e.hunks.length;t++){var i=e.hunks[t];0===i.oldLines&&(i.oldStart-=1),0===i.newLines&&(i.newStart-=1),n.push("@@ -"+i.oldStart+","+i.oldLines+" +"+i.newStart+","+i.newLines+" @@"),n.push.apply(n,i.lines)}return n.join("\n")+"\n"}function l(e,n,t,i,a,r,l){return o(s(e,n,t,i,a,r,l))}},3051:(e,n,t)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.calcLineCount=l,n.merge=function(e,n,t){e=c(e,t),n=c(n,t);var i={};(e.index||n.index)&&(i.index=e.index||n.index),(e.newFileName||n.newFileName)&&(d(e)?d(n)?(i.oldFileName=u(i,e.oldFileName,n.oldFileName),i.newFileName=u(i,e.newFileName,n.newFileName),i.oldHeader=u(i,e.oldHeader,n.oldHeader),i.newHeader=u(i,e.newHeader,n.newHeader)):(i.oldFileName=e.oldFileName,i.newFileName=e.newFileName,i.oldHeader=e.oldHeader,i.newHeader=e.newHeader):(i.oldFileName=n.oldFileName||e.oldFileName,i.newFileName=n.newFileName||e.newFileName,i.oldHeader=n.oldHeader||e.oldHeader,i.newHeader=n.newHeader||e.newHeader)),i.hunks=[];for(var a=0,r=0,s=0,o=0;a<e.hunks.length||r<n.hunks.length;){var l=e.hunks[a]||{oldStart:1/0},f=n.hunks[r]||{oldStart:1/0};if(g(l,f))i.hunks.push(b(l,s)),a++,o+=l.newLines-l.oldLines;else if(g(f,l))i.hunks.push(b(f,o)),r++,s+=f.newLines-f.oldLines;else{var m={oldStart:Math.min(l.oldStart,f.oldStart),oldLines:0,newStart:Math.min(l.newStart+s,f.oldStart+o),newLines:0,lines:[]};p(m,l.oldStart,l.lines,f.oldStart,f.lines),r++,a++,i.hunks.push(m)}}return i};var i=t(1286),a=t(3719),r=t(7780);function s(e){return function(e){if(Array.isArray(e))return o(e)}(e)||function(e){if("undefined"!=typeof Symbol&&Symbol.iterator in Object(e))return Array.from(e)}(e)||function(e,n){if(e){if("string"==typeof e)return o(e,n);var t=Object.prototype.toString.call(e).slice(8,-1);return"Object"===t&&e.constructor&&(t=e.constructor.name),"Map"===t||"Set"===t?Array.from(e):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?o(e,n):void 0}}(e)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function o(e,n){(null==n||n>e.length)&&(n=e.length);for(var t=0,i=new Array(n);t<n;t++)i[t]=e[t];return i}function l(e){var n=A(e.lines),t=n.oldLines,i=n.newLines;void 0!==t?e.oldLines=t:delete e.oldLines,void 0!==i?e.newLines=i:delete e.newLines}function c(e,n){if("string"==typeof e){if(/^@@/m.test(e)||/^Index:/m.test(e))return(0,a.parsePatch)(e)[0];if(!n)throw new Error("Must provide a base reference or pass in a patch");return(0,i.structuredPatch)(void 0,void 0,n,e)}return e}function d(e){return e.newFileName&&e.newFileName!==e.oldFileName}function u(e,n,t){return n===t?n:(e.conflict=!0,{mine:n,theirs:t})}function g(e,n){return e.oldStart<n.oldStart&&e.oldStart+e.oldLines<n.oldStart}function b(e,n){return{oldStart:e.oldStart,oldLines:e.oldLines,newStart:e.newStart+n,newLines:e.newLines,lines:e.lines}}function p(e,n,t,i,a){var r={offset:n,lines:t,index:0},o={offset:i,lines:a,index:0};for(h(e,r,o),h(e,o,r);r.index<r.lines.length&&o.index<o.lines.length;){var c=r.lines[r.index],d=o.lines[o.index];if("-"!==c[0]&&"+"!==c[0]||"-"!==d[0]&&"+"!==d[0])if("+"===c[0]&&" "===d[0]){var u;(u=e.lines).push.apply(u,s(N(r)))}else if("+"===d[0]&&" "===c[0]){var g;(g=e.lines).push.apply(g,s(N(o)))}else"-"===c[0]&&" "===d[0]?m(e,r,o):"-"===d[0]&&" "===c[0]?m(e,o,r,!0):c===d?(e.lines.push(c),r.index++,o.index++):E(e,N(r),N(o));else f(e,r,o)}_(e,r),_(e,o),l(e)}function f(e,n,t){var i=N(n),a=N(t);if(T(i)&&T(a)){var o,l;if((0,r.arrayStartsWith)(i,a)&&O(t,i,i.length-a.length))return void(o=e.lines).push.apply(o,s(i));if((0,r.arrayStartsWith)(a,i)&&O(n,a,a.length-i.length))return void(l=e.lines).push.apply(l,s(a))}else if((0,r.arrayEqual)(i,a)){var c;return void(c=e.lines).push.apply(c,s(i))}E(e,i,a)}function m(e,n,t,i){var a,r=N(n),o=function(e,n){for(var t=[],i=[],a=0,r=!1,s=!1;a<n.length&&e.index<e.lines.length;){var o=e.lines[e.index],l=n[a];if("+"===l[0])break;if(r=r||" "!==o[0],i.push(l),a++,"+"===o[0])for(s=!0;"+"===o[0];)t.push(o),o=e.lines[++e.index];l.substr(1)===o.substr(1)?(t.push(o),e.index++):s=!0}if("+"===(n[a]||"")[0]&&r&&(s=!0),s)return t;for(;a<n.length;)i.push(n[a++]);return{merged:i,changes:t}}(t,r);o.merged?(a=e.lines).push.apply(a,s(o.merged)):E(e,i?o:r,i?r:o)}function E(e,n,t){e.conflict=!0,e.lines.push({conflict:!0,mine:n,theirs:t})}function h(e,n,t){for(;n.offset<t.offset&&n.index<n.lines.length;){var i=n.lines[n.index++];e.lines.push(i),n.offset++}}function _(e,n){for(;n.index<n.lines.length;){var t=n.lines[n.index++];e.lines.push(t)}}function N(e){for(var n=[],t=e.lines[e.index][0];e.index<e.lines.length;){var i=e.lines[e.index];if("-"===t&&"+"===i[0]&&(t="+"),t!==i[0])break;n.push(i),e.index++}return n}function T(e){return e.reduce((function(e,n){return e&&"-"===n[0]}),!0)}function O(e,n,t){for(var i=0;i<t;i++){var a=n[n.length-t+i].substr(1);if(e.lines[e.index+i]!==" "+a)return!1}return e.index+=t,!0}function A(e){var n=0,t=0;return e.forEach((function(e){if("string"!=typeof e){var i=A(e.mine),a=A(e.theirs);void 0!==n&&(i.oldLines===a.oldLines?n+=i.oldLines:n=void 0),void 0!==t&&(i.newLines===a.newLines?t+=i.newLines:t=void 0)}else void 0===t||"+"!==e[0]&&" "!==e[0]||t++,void 0===n||"-"!==e[0]&&" "!==e[0]||n++})),{oldLines:n,newLines:t}}},3719:(e,n)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.parsePatch=function(e){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},t=e.split(/\r\n|[\n\v\f\r\x85]/),i=e.match(/\r\n|[\n\v\f\r\x85]/g)||[],a=[],r=0;function s(){var e={};for(a.push(e);r<t.length;){var i=t[r];if(/^(\-\-\-|\+\+\+|@@)\s/.test(i))break;var s=/^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(i);s&&(e.index=s[1]),r++}for(o(e),o(e),e.hunks=[];r<t.length;){var c=t[r];if(/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(c))break;if(/^@@/.test(c))e.hunks.push(l());else{if(c&&n.strict)throw new Error("Unknown line "+(r+1)+" "+JSON.stringify(c));r++}}}function o(e){var n=/^(---|\+\+\+)\s+(.*)$/.exec(t[r]);if(n){var i="---"===n[1]?"old":"new",a=n[2].split("\t",2),s=a[0].replace(/\\\\/g,"\\");/^".*"$/.test(s)&&(s=s.substr(1,s.length-2)),e[i+"FileName"]=s,e[i+"Header"]=(a[1]||"").trim(),r++}}function l(){var e=r,a=t[r++].split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/),s={oldStart:+a[1],oldLines:void 0===a[2]?1:+a[2],newStart:+a[3],newLines:void 0===a[4]?1:+a[4],lines:[],linedelimiters:[]};0===s.oldLines&&(s.oldStart+=1),0===s.newLines&&(s.newStart+=1);for(var o=0,l=0;r<t.length&&!(0===t[r].indexOf("--- ")&&r+2<t.length&&0===t[r+1].indexOf("+++ ")&&0===t[r+2].indexOf("@@"));r++){var c=0==t[r].length&&r!=t.length-1?" ":t[r][0];if("+"!==c&&"-"!==c&&" "!==c&&"\\"!==c)break;s.lines.push(t[r]),s.linedelimiters.push(i[r]||"\n"),"+"===c?o++:"-"===c?l++:" "===c&&(o++,l++)}if(o||1!==s.newLines||(s.newLines=0),l||1!==s.oldLines||(s.oldLines=0),n.strict){if(o!==s.newLines)throw new Error("Added line count did not match for hunk at line "+(e+1));if(l!==s.oldLines)throw new Error("Removed line count did not match for hunk at line "+(e+1))}return s}for(;r<t.length;)s();return a}},7780:(e,n)=>{"use strict";function t(e,n){if(n.length>e.length)return!1;for(var t=0;t<n.length;t++)if(n[t]!==e[t])return!1;return!0}Object.defineProperty(n,"__esModule",{value:!0}),n.arrayEqual=function(e,n){return e.length===n.length&&t(e,n)},n.arrayStartsWith=t},8169:(e,n)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.default=function(e,n,t){var i=!0,a=!1,r=!1,s=1;return function o(){if(i&&!r){if(a?s++:i=!1,e+s<=t)return s;r=!0}if(!a)return r||(i=!0),n<=e-s?-s++:(a=!0,o())}}},8009:(e,n)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.generateOptions=function(e,n){if("function"==typeof e)n.callback=e;else if(e)for(var t in e)e.hasOwnProperty(t)&&(n[t]=e[t]);return n}},9397:(e,n)=>{!function(e){var n=/\S/,t=/\"/g,i=/\n/g,a=/\r/g,r=/\\/g,s=/\u2028/,o=/\u2029/;function l(e){return e.trim?e.trim():e.replace(/^\s*|\s*$/g,"")}function c(e,n,t){if(n.charAt(t)!=e.charAt(0))return!1;for(var i=1,a=e.length;i<a;i++)if(n.charAt(t+i)!=e.charAt(i))return!1;return!0}e.tags={"#":1,"^":2,"<":3,$:4,"/":5,"!":6,">":7,"=":8,_v:9,"{":10,"&":11,_t:12},e.scan=function(t,i){var a,r=t.length,s=0,o=null,d=null,u="",g=[],b=!1,p=0,f=0,m="{{",E="}}";function h(){u.length>0&&(g.push({tag:"_t",text:new String(u)}),u="")}function _(t,i){if(h(),t&&function(){for(var t=!0,i=f;i<g.length;i++)if(!(t=e.tags[g[i].tag]<e.tags._v||"_t"==g[i].tag&&null===g[i].text.match(n)))return!1;return t}())for(var a,r=f;r<g.length;r++)g[r].text&&((a=g[r+1])&&">"==a.tag&&(a.indent=g[r].text.toString()),g.splice(r,1));else i||g.push({tag:"\n"});b=!1,f=g.length}function N(e,n){var t="="+E,i=e.indexOf(t,n),a=l(e.substring(e.indexOf("=",n)+1,i)).split(" ");return m=a[0],E=a[a.length-1],i+t.length-1}for(i&&(i=i.split(" "),m=i[0],E=i[1]),p=0;p<r;p++)0==s?c(m,t,p)?(--p,h(),s=1):"\n"==t.charAt(p)?_(b):u+=t.charAt(p):1==s?(p+=m.length-1,"="==(o=(d=e.tags[t.charAt(p+1)])?t.charAt(p+1):"_v")?(p=N(t,p),s=0):(d&&p++,s=2),b=p):c(E,t,p)?(g.push({tag:o,n:l(u),otag:m,ctag:E,i:"/"==o?b-m.length:p+E.length}),u="",p+=E.length-1,s=0,"{"==o&&("}}"==E?p++:"}"===(a=g[g.length-1]).n.substr(a.n.length-1)&&(a.n=a.n.substring(0,a.n.length-1)))):u+=t.charAt(p);return _(b,!0),g};var d={_t:!0,"\n":!0,$:!0,"/":!0};function u(n,t,i,a){var r,s=[],o=null,l=null;for(r=i[i.length-1];n.length>0;){if(l=n.shift(),r&&"<"==r.tag&&!(l.tag in d))throw new Error("Illegal content in < super tag.");if(e.tags[l.tag]<=e.tags.$||g(l,a))i.push(l),l.nodes=u(n,l.tag,i,a);else{if("/"==l.tag){if(0===i.length)throw new Error("Closing tag without opener: /"+l.n);if(o=i.pop(),l.n!=o.n&&!b(l.n,o.n,a))throw new Error("Nesting error: "+o.n+" vs. "+l.n);return o.end=l.i,s}"\n"==l.tag&&(l.last=0==n.length||"\n"==n[0].tag)}s.push(l)}if(i.length>0)throw new Error("missing closing tag: "+i.pop().n);return s}function g(e,n){for(var t=0,i=n.length;t<i;t++)if(n[t].o==e.n)return e.tag="#",!0}function b(e,n,t){for(var i=0,a=t.length;i<a;i++)if(t[i].c==e&&t[i].o==n)return!0}function p(e){var n=[];for(var t in e.partials)n.push('"'+m(t)+'":{name:"'+m(e.partials[t].name)+'", '+p(e.partials[t])+"}");return"partials: {"+n.join(",")+"}, subs: "+function(e){var n=[];for(var t in e)n.push('"'+m(t)+'": function(c,p,t,i) {'+e[t]+"}");return"{ "+n.join(",")+" }"}(e.subs)}e.stringify=function(n,t,i){return"{code: function (c,p,i) { "+e.wrapMain(n.code)+" },"+p(n)+"}"};var f=0;function m(e){return e.replace(r,"\\\\").replace(t,'\\"').replace(i,"\\n").replace(a,"\\r").replace(s,"\\u2028").replace(o,"\\u2029")}function E(e){return~e.indexOf(".")?"d":"f"}function h(e,n){var t="<"+(n.prefix||"")+e.n+f++;return n.partials[t]={name:e.n,partials:{}},n.code+='t.b(t.rp("'+m(t)+'",c,p,"'+(e.indent||"")+'"));',t}function _(e,n){n.code+="t.b(t.t(t."+E(e.n)+'("'+m(e.n)+'",c,p,0)));'}function N(e){return"t.b("+e+");"}e.generate=function(n,t,i){f=0;var a={code:"",subs:{},partials:{}};return e.walk(n,a),i.asString?this.stringify(a,t,i):this.makeTemplate(a,t,i)},e.wrapMain=function(e){return'var t=this;t.b(i=i||"");'+e+"return t.fl();"},e.template=e.Template,e.makeTemplate=function(e,n,t){var i=this.makePartials(e);return i.code=new Function("c","p","i",this.wrapMain(e.code)),new this.template(i,n,this,t)},e.makePartials=function(e){var n,t={subs:{},partials:e.partials,name:e.name};for(n in t.partials)t.partials[n]=this.makePartials(t.partials[n]);for(n in e.subs)t.subs[n]=new Function("c","p","t","i",e.subs[n]);return t},e.codegen={"#":function(n,t){t.code+="if(t.s(t."+E(n.n)+'("'+m(n.n)+'",c,p,1),c,p,0,'+n.i+","+n.end+',"'+n.otag+" "+n.ctag+'")){t.rs(c,p,function(c,p,t){',e.walk(n.nodes,t),t.code+="});c.pop();}"},"^":function(n,t){t.code+="if(!t.s(t."+E(n.n)+'("'+m(n.n)+'",c,p,1),c,p,1,0,0,"")){',e.walk(n.nodes,t),t.code+="};"},">":h,"<":function(n,t){var i={partials:{},code:"",subs:{},inPartial:!0};e.walk(n.nodes,i);var a=t.partials[h(n,t)];a.subs=i.subs,a.partials=i.partials},$:function(n,t){var i={subs:{},code:"",partials:t.partials,prefix:n.n};e.walk(n.nodes,i),t.subs[n.n]=i.code,t.inPartial||(t.code+='t.sub("'+m(n.n)+'",c,p,i);')},"\n":function(e,n){n.code+=N('"\\n"'+(e.last?"":" + i"))},_v:function(e,n){n.code+="t.b(t.v(t."+E(e.n)+'("'+m(e.n)+'",c,p,0)));'},_t:function(e,n){n.code+=N('"'+m(e.text)+'"')},"{":_,"&":_},e.walk=function(n,t){for(var i,a=0,r=n.length;a<r;a++)(i=e.codegen[n[a].tag])&&i(n[a],t);return t},e.parse=function(e,n,t){return u(e,0,[],(t=t||{}).sectionTags||[])},e.cache={},e.cacheKey=function(e,n){return[e,!!n.asString,!!n.disableLambda,n.delimiters,!!n.modelGet].join("||")},e.compile=function(n,t){t=t||{};var i=e.cacheKey(n,t),a=this.cache[i];if(a){var r=a.partials;for(var s in r)delete r[s].instance;return a}return a=this.generate(this.parse(this.scan(n,t.delimiters),n,t),n,t),this.cache[i]=a}}(n)},5485:(e,n,t)=>{var i=t(9397);i.Template=t(2882).Template,i.template=i.Template,e.exports=i},2882:(e,n)=>{!function(e){function n(e,n,t){var i;return n&&"object"==typeof n&&(void 0!==n[e]?i=n[e]:t&&n.get&&"function"==typeof n.get&&(i=n.get(e))),i}e.Template=function(e,n,t,i){e=e||{},this.r=e.code||this.r,this.c=t,this.options=i||{},this.text=n||"",this.partials=e.partials||{},this.subs=e.subs||{},this.buf=""},e.Template.prototype={r:function(e,n,t){return""},v:function(e){return e=l(e),o.test(e)?e.replace(t,"&amp;").replace(i,"&lt;").replace(a,"&gt;").replace(r,"&#39;").replace(s,"&quot;"):e},t:l,render:function(e,n,t){return this.ri([e],n||{},t)},ri:function(e,n,t){return this.r(e,n,t)},ep:function(e,n){var t=this.partials[e],i=n[t.name];if(t.instance&&t.base==i)return t.instance;if("string"==typeof i){if(!this.c)throw new Error("No compiler available.");i=this.c.compile(i,this.options)}if(!i)return null;if(this.partials[e].base=i,t.subs){for(key in n.stackText||(n.stackText={}),t.subs)n.stackText[key]||(n.stackText[key]=void 0!==this.activeSub&&n.stackText[this.activeSub]?n.stackText[this.activeSub]:this.text);i=function(e,n,t,i,a,r){function s(){}function o(){}var l;s.prototype=e,o.prototype=e.subs;var c=new s;for(l in c.subs=new o,c.subsText={},c.buf="",i=i||{},c.stackSubs=i,c.subsText=r,n)i[l]||(i[l]=n[l]);for(l in i)c.subs[l]=i[l];for(l in a=a||{},c.stackPartials=a,t)a[l]||(a[l]=t[l]);for(l in a)c.partials[l]=a[l];return c}(i,t.subs,t.partials,this.stackSubs,this.stackPartials,n.stackText)}return this.partials[e].instance=i,i},rp:function(e,n,t,i){var a=this.ep(e,t);return a?a.ri(n,t,i):""},rs:function(e,n,t){var i=e[e.length-1];if(c(i))for(var a=0;a<i.length;a++)e.push(i[a]),t(e,n,this),e.pop();else t(e,n,this)},s:function(e,n,t,i,a,r,s){var o;return(!c(e)||0!==e.length)&&("function"==typeof e&&(e=this.ms(e,n,t,i,a,r,s)),o=!!e,!i&&o&&n&&n.push("object"==typeof e?e:n[n.length-1]),o)},d:function(e,t,i,a){var r,s=e.split("."),o=this.f(s[0],t,i,a),l=this.options.modelGet,d=null;if("."===e&&c(t[t.length-2]))o=t[t.length-1];else for(var u=1;u<s.length;u++)void 0!==(r=n(s[u],o,l))?(d=o,o=r):o="";return!(a&&!o)&&(a||"function"!=typeof o||(t.push(d),o=this.mv(o,t,i),t.pop()),o)},f:function(e,t,i,a){for(var r=!1,s=!1,o=this.options.modelGet,l=t.length-1;l>=0;l--)if(void 0!==(r=n(e,t[l],o))){s=!0;break}return s?(a||"function"!=typeof r||(r=this.mv(r,t,i)),r):!a&&""},ls:function(e,n,t,i,a){var r=this.options.delimiters;return this.options.delimiters=a,this.b(this.ct(l(e.call(n,i)),n,t)),this.options.delimiters=r,!1},ct:function(e,n,t){if(this.options.disableLambda)throw new Error("Lambda features disabled.");return this.c.compile(e,this.options).render(n,t)},b:function(e){this.buf+=e},fl:function(){var e=this.buf;return this.buf="",e},ms:function(e,n,t,i,a,r,s){var o,l=n[n.length-1],c=e.call(l);return"function"==typeof c?!!i||(o=this.activeSub&&this.subsText&&this.subsText[this.activeSub]?this.subsText[this.activeSub]:this.text,this.ls(c,l,t,o.substring(a,r),s)):c},mv:function(e,n,t){var i=n[n.length-1],a=e.call(i);return"function"==typeof a?this.ct(l(a.call(i)),i,t):a},sub:function(e,n,t,i){var a=this.subs[e];a&&(this.activeSub=e,a(n,t,this,i),this.activeSub=!1)}};var t=/&/g,i=/</g,a=/>/g,r=/\'/g,s=/\"/g,o=/[&<>\"\']/;function l(e){return String(null==e?"":e)}var c=Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)}}(n)},8468:(e,n,t)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.parse=void 0;const i=t(9699),a=t(8593);function r(e,n){const t=e.split(".");return t.length>1?t[t.length-1]:n}function s(e,n){return n.reduce(((n,t)=>n||e.startsWith(t)),!1)}const o=["a/","b/","i/","w/","c/","o/"];function l(e,n,t){const i=void 0!==t?[...o,t]:o,r=n?new RegExp(`^${(0,a.escapeForRegExp)(n)} "?(.+?)"?$`):new RegExp('^"?(.+?)"?$'),[,s=""]=r.exec(e)||[],l=i.find((e=>0===s.indexOf(e)));return(l?s.slice(l.length):s).replace(/\s+\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)? [+-]\d{4}.*$/,"")}n.parse=function(e,n={}){const t=[];let a=null,o=null,c=null,d=null,u=null,g=null,b=null;const p="--- ",f="+++ ",m="@@",E=/^old mode (\d{6})/,h=/^new mode (\d{6})/,_=/^deleted file mode (\d{6})/,N=/^new file mode (\d{6})/,T=/^copy from "?(.+)"?/,O=/^copy to "?(.+)"?/,A=/^rename from "?(.+)"?/,v=/^rename to "?(.+)"?/,y=/^similarity index (\d+)%/,S=/^dissimilarity index (\d+)%/,R=/^index ([\da-z]+)\.\.([\da-z]+)\s*(\d{6})?/,I=/^Binary files (.*) and (.*) differ/,w=/^GIT binary patch/,C=/^index ([\da-z]+),([\da-z]+)\.\.([\da-z]+)/,L=/^mode (\d{6}),(\d{6})\.\.(\d{6})/,M=/^new file mode (\d{6})/,D=/^deleted file mode (\d{6}),(\d{6})/,x=e.replace(/\\ No newline at end of file/g,"").replace(/\r\n?/g,"\n").split("\n");function k(){null!==o&&null!==a&&(a.blocks.push(o),o=null)}function P(){null!==a&&(a.oldName||null===g||(a.oldName=g),a.newName||null===b||(a.newName=b),a.newName&&(t.push(a),a=null)),g=null,b=null}function U(){k(),P(),a={blocks:[],deletedLines:0,addedLines:0}}function B(e){let n;k(),null!==a&&((n=/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@.*/.exec(e))?(a.isCombined=!1,c=parseInt(n[1],10),u=parseInt(n[2],10)):(n=/^@@@ -(\d+)(?:,\d+)? -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@@.*/.exec(e))?(a.isCombined=!0,c=parseInt(n[1],10),d=parseInt(n[2],10),u=parseInt(n[3],10)):(e.startsWith(m)&&console.error("Failed to parse lines, starting in 0!"),c=0,u=0,a.isCombined=!1)),o={lines:[],oldStartLine:c,oldStartLine2:d,newStartLine:u,header:e}}return x.forEach(((e,d)=>{if(!e||e.startsWith("*"))return;let k;const P=x[d-1],F=x[d+1],j=x[d+2];if(e.startsWith("diff --git")||e.startsWith("diff --combined")){if(U(),(k=/^diff --git "?([a-ciow]\/.+)"? "?([a-ciow]\/.+)"?/.exec(e))&&(g=l(k[1],void 0,n.dstPrefix),b=l(k[2],void 0,n.srcPrefix)),null===a)throw new Error("Where is my file !!!");return void(a.isGitDiff=!0)}if(e.startsWith("Binary files")&&!(null==a?void 0:a.isGitDiff)){if(U(),(k=/^Binary files "?([a-ciow]\/.+)"? and "?([a-ciow]\/.+)"? differ/.exec(e))&&(g=l(k[1],void 0,n.dstPrefix),b=l(k[2],void 0,n.srcPrefix)),null===a)throw new Error("Where is my file !!!");return void(a.isBinary=!0)}if((!a||!a.isGitDiff&&a&&e.startsWith(p)&&F.startsWith(f)&&j.startsWith(m))&&U(),null==a?void 0:a.isTooBig)return;if(a&&("number"==typeof n.diffMaxChanges&&a.addedLines+a.deletedLines>n.diffMaxChanges||"number"==typeof n.diffMaxLineLength&&e.length>n.diffMaxLineLength))return a.isTooBig=!0,a.addedLines=0,a.deletedLines=0,a.blocks=[],o=null,void B("function"==typeof n.diffTooBigMessage?n.diffTooBigMessage(t.length):"Diff too big to be displayed");if(e.startsWith(p)&&F.startsWith(f)||e.startsWith(f)&&P.startsWith(p)){if(a&&!a.oldName&&e.startsWith("--- ")&&(k=function(e,n){return l(e,"---",n)}(e,n.srcPrefix)))return a.oldName=k,void(a.language=r(a.oldName,a.language));if(a&&!a.newName&&e.startsWith("+++ ")&&(k=function(e,n){return l(e,"+++",n)}(e,n.dstPrefix)))return a.newName=k,void(a.language=r(a.newName,a.language))}if(a&&(e.startsWith(m)||a.isGitDiff&&a.oldName&&a.newName&&!o))return void B(e);if(o&&(e.startsWith("+")||e.startsWith("-")||e.startsWith(" ")))return void function(e){if(null===a||null===o||null===c||null===u)return;const n={content:e},t=a.isCombined?["+ "," +","++"]:["+"],r=a.isCombined?["- "," -","--"]:["-"];s(e,t)?(a.addedLines++,n.type=i.LineType.INSERT,n.oldNumber=void 0,n.newNumber=u++):s(e,r)?(a.deletedLines++,n.type=i.LineType.DELETE,n.oldNumber=c++,n.newNumber=void 0):(n.type=i.LineType.CONTEXT,n.oldNumber=c++,n.newNumber=u++),o.lines.push(n)}(e);const H=!function(e,n){let t=n;for(;t<x.length-3;){if(e.startsWith("diff"))return!1;if(x[t].startsWith(p)&&x[t+1].startsWith(f)&&x[t+2].startsWith(m))return!0;t++}return!1}(e,d);if(null===a)throw new Error("Where is my file !!!");(k=E.exec(e))?a.oldMode=k[1]:(k=h.exec(e))?a.newMode=k[1]:(k=_.exec(e))?(a.deletedFileMode=k[1],a.isDeleted=!0):(k=N.exec(e))?(a.newFileMode=k[1],a.isNew=!0):(k=T.exec(e))?(H&&(a.oldName=k[1]),a.isCopy=!0):(k=O.exec(e))?(H&&(a.newName=k[1]),a.isCopy=!0):(k=A.exec(e))?(H&&(a.oldName=k[1]),a.isRename=!0):(k=v.exec(e))?(H&&(a.newName=k[1]),a.isRename=!0):(k=I.exec(e))?(a.isBinary=!0,a.oldName=l(k[1],void 0,n.srcPrefix),a.newName=l(k[2],void 0,n.dstPrefix),B("Binary file")):w.test(e)?(a.isBinary=!0,B(e)):(k=y.exec(e))?a.unchangedPercentage=parseInt(k[1],10):(k=S.exec(e))?a.changedPercentage=parseInt(k[1],10):(k=R.exec(e))?(a.checksumBefore=k[1],a.checksumAfter=k[2],k[3]&&(a.mode=k[3])):(k=C.exec(e))?(a.checksumBefore=[k[2],k[3]],a.checksumAfter=k[1]):(k=L.exec(e))?(a.oldMode=[k[2],k[3]],a.newMode=k[1]):(k=M.exec(e))?(a.newFileMode=k[1],a.isNew=!0):(k=D.exec(e))&&(a.deletedFileMode=k[1],a.isDeleted=!0)})),k(),P(),t}},979:function(e,n,t){"use strict";var i=this&&this.__createBinding||(Object.create?function(e,n,t,i){void 0===i&&(i=t);var a=Object.getOwnPropertyDescriptor(n,t);a&&!("get"in a?!n.__esModule:a.writable||a.configurable)||(a={enumerable:!0,get:function(){return n[t]}}),Object.defineProperty(e,i,a)}:function(e,n,t,i){void 0===i&&(i=t),e[i]=n[t]}),a=this&&this.__setModuleDefault||(Object.create?function(e,n){Object.defineProperty(e,"default",{enumerable:!0,value:n})}:function(e,n){e.default=n}),r=this&&this.__importStar||function(e){if(e&&e.__esModule)return e;var n={};if(null!=e)for(var t in e)"default"!==t&&Object.prototype.hasOwnProperty.call(e,t)&&i(n,e,t);return a(n,e),n};Object.defineProperty(n,"__esModule",{value:!0}),n.defaultTemplates=void 0;const s=r(t(5485));n.defaultTemplates={},n.defaultTemplates["file-summary-line"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<li class="d2h-file-list-line">'),i.b("\n"+t),i.b('    <span class="d2h-file-name-wrapper">'),i.b("\n"+t),i.b(i.rp("<fileIcon0",e,n,"      ")),i.b('      <a href="#'),i.b(i.v(i.f("fileHtmlId",e,n,0))),i.b('" class="d2h-file-name">'),i.b(i.v(i.f("fileName",e,n,0))),i.b("</a>"),i.b("\n"+t),i.b('      <span class="d2h-file-stats">'),i.b("\n"+t),i.b('          <span class="d2h-lines-added">'),i.b(i.v(i.f("addedLines",e,n,0))),i.b("</span>"),i.b("\n"+t),i.b('          <span class="d2h-lines-deleted">'),i.b(i.v(i.f("deletedLines",e,n,0))),i.b("</span>"),i.b("\n"+t),i.b("      </span>"),i.b("\n"+t),i.b("    </span>"),i.b("\n"+t),i.b("</li>"),i.fl()},partials:{"<fileIcon0":{name:"fileIcon",partials:{},subs:{}}},subs:{}}),n.defaultTemplates["file-summary-wrapper"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<div class="d2h-file-list-wrapper '),i.b(i.v(i.f("colorScheme",e,n,0))),i.b('">'),i.b("\n"+t),i.b('    <div class="d2h-file-list-header">'),i.b("\n"+t),i.b('        <span class="d2h-file-list-title">Files changed ('),i.b(i.v(i.f("filesNumber",e,n,0))),i.b(")</span>"),i.b("\n"+t),i.b('        <a class="d2h-file-switch d2h-hide">hide</a>'),i.b("\n"+t),i.b('        <a class="d2h-file-switch d2h-show">show</a>'),i.b("\n"+t),i.b("    </div>"),i.b("\n"+t),i.b('    <ol class="d2h-file-list">'),i.b("\n"+t),i.b("    "),i.b(i.t(i.f("files",e,n,0))),i.b("\n"+t),i.b("    </ol>"),i.b("\n"+t),i.b("</div>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["generic-block-header"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b("<tr>"),i.b("\n"+t),i.b('    <td class="'),i.b(i.v(i.f("lineClass",e,n,0))),i.b(" "),i.b(i.v(i.d("CSSLineClass.INFO",e,n,0))),i.b('"></td>'),i.b("\n"+t),i.b('    <td class="'),i.b(i.v(i.d("CSSLineClass.INFO",e,n,0))),i.b('">'),i.b("\n"+t),i.b('        <div class="'),i.b(i.v(i.f("contentClass",e,n,0))),i.b('">'),i.s(i.f("blockHeader",e,n,1),e,n,0,156,173,"{{ }}")&&(i.rs(e,n,(function(e,n,t){t.b(t.t(t.f("blockHeader",e,n,0)))})),e.pop()),i.s(i.f("blockHeader",e,n,1),e,n,1,0,0,"")||i.b("&nbsp;"),i.b("</div>"),i.b("\n"+t),i.b("    </td>"),i.b("\n"+t),i.b("</tr>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["generic-empty-diff"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b("<tr>"),i.b("\n"+t),i.b('    <td class="'),i.b(i.v(i.d("CSSLineClass.INFO",e,n,0))),i.b('">'),i.b("\n"+t),i.b('        <div class="'),i.b(i.v(i.f("contentClass",e,n,0))),i.b('">'),i.b("\n"+t),i.b("            File without changes"),i.b("\n"+t),i.b("        </div>"),i.b("\n"+t),i.b("    </td>"),i.b("\n"+t),i.b("</tr>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["generic-file-path"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<span class="d2h-file-name-wrapper">'),i.b("\n"+t),i.b(i.rp("<fileIcon0",e,n,"    ")),i.b('    <span class="d2h-file-name">'),i.b(i.v(i.f("fileDiffName",e,n,0))),i.b("</span>"),i.b("\n"+t),i.b(i.rp("<fileTag1",e,n,"    ")),i.b("</span>"),i.b("\n"+t),i.b('<label class="d2h-file-collapse">'),i.b("\n"+t),i.b('    <input class="d2h-file-collapse-input" type="checkbox" name="viewed" value="viewed">'),i.b("\n"+t),i.b("    Viewed"),i.b("\n"+t),i.b("</label>"),i.fl()},partials:{"<fileIcon0":{name:"fileIcon",partials:{},subs:{}},"<fileTag1":{name:"fileTag",partials:{},subs:{}}},subs:{}}),n.defaultTemplates["generic-line"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b("<tr>"),i.b("\n"+t),i.b('    <td class="'),i.b(i.v(i.f("lineClass",e,n,0))),i.b(" "),i.b(i.v(i.f("type",e,n,0))),i.b('">'),i.b("\n"+t),i.b("      "),i.b(i.t(i.f("lineNumber",e,n,0))),i.b("\n"+t),i.b("    </td>"),i.b("\n"+t),i.b('    <td class="'),i.b(i.v(i.f("type",e,n,0))),i.b('">'),i.b("\n"+t),i.b('        <div class="'),i.b(i.v(i.f("contentClass",e,n,0))),i.b('">'),i.b("\n"+t),i.s(i.f("prefix",e,n,1),e,n,0,162,238,"{{ }}")&&(i.rs(e,n,(function(e,n,i){i.b('            <span class="d2h-code-line-prefix">'),i.b(i.t(i.f("prefix",e,n,0))),i.b("</span>"),i.b("\n"+t)})),e.pop()),i.s(i.f("prefix",e,n,1),e,n,1,0,0,"")||(i.b('            <span class="d2h-code-line-prefix">&nbsp;</span>'),i.b("\n"+t)),i.s(i.f("content",e,n,1),e,n,0,371,445,"{{ }}")&&(i.rs(e,n,(function(e,n,i){i.b('            <span class="d2h-code-line-ctn">'),i.b(i.t(i.f("content",e,n,0))),i.b("</span>"),i.b("\n"+t)})),e.pop()),i.s(i.f("content",e,n,1),e,n,1,0,0,"")||(i.b('            <span class="d2h-code-line-ctn"><br></span>'),i.b("\n"+t)),i.b("        </div>"),i.b("\n"+t),i.b("    </td>"),i.b("\n"+t),i.b("</tr>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["generic-wrapper"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<div class="d2h-wrapper '),i.b(i.v(i.f("colorScheme",e,n,0))),i.b('">'),i.b("\n"+t),i.b("    "),i.b(i.t(i.f("content",e,n,0))),i.b("\n"+t),i.b("</div>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["icon-file-added"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<svg aria-hidden="true" class="d2h-icon d2h-added" height="16" title="added" version="1.1" viewBox="0 0 14 16"'),i.b("\n"+t),i.b('     width="14">'),i.b("\n"+t),i.b('    <path d="M13 1H1C0.45 1 0 1.45 0 2v12c0 0.55 0.45 1 1 1h12c0.55 0 1-0.45 1-1V2c0-0.55-0.45-1-1-1z m0 13H1V2h12v12zM6 9H3V7h3V4h2v3h3v2H8v3H6V9z"></path>'),i.b("\n"+t),i.b("</svg>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["icon-file-changed"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<svg aria-hidden="true" class="d2h-icon d2h-changed" height="16" title="modified" version="1.1"'),i.b("\n"+t),i.b('     viewBox="0 0 14 16" width="14">'),i.b("\n"+t),i.b('    <path d="M13 1H1C0.45 1 0 1.45 0 2v12c0 0.55 0.45 1 1 1h12c0.55 0 1-0.45 1-1V2c0-0.55-0.45-1-1-1z m0 13H1V2h12v12zM4 8c0-1.66 1.34-3 3-3s3 1.34 3 3-1.34 3-3 3-3-1.34-3-3z"></path>'),i.b("\n"+t),i.b("</svg>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["icon-file-deleted"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<svg aria-hidden="true" class="d2h-icon d2h-deleted" height="16" title="removed" version="1.1"'),i.b("\n"+t),i.b('     viewBox="0 0 14 16" width="14">'),i.b("\n"+t),i.b('    <path d="M13 1H1C0.45 1 0 1.45 0 2v12c0 0.55 0.45 1 1 1h12c0.55 0 1-0.45 1-1V2c0-0.55-0.45-1-1-1z m0 13H1V2h12v12zM11 9H3V7h8v2z"></path>'),i.b("\n"+t),i.b("</svg>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["icon-file-renamed"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<svg aria-hidden="true" class="d2h-icon d2h-moved" height="16" title="renamed" version="1.1"'),i.b("\n"+t),i.b('     viewBox="0 0 14 16" width="14">'),i.b("\n"+t),i.b('    <path d="M6 9H3V7h3V4l5 4-5 4V9z m8-7v12c0 0.55-0.45 1-1 1H1c-0.55 0-1-0.45-1-1V2c0-0.55 0.45-1 1-1h12c0.55 0 1 0.45 1 1z m-1 0H1v12h12V2z"></path>'),i.b("\n"+t),i.b("</svg>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["icon-file"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<svg aria-hidden="true" class="d2h-icon" height="16" version="1.1" viewBox="0 0 12 16" width="12">'),i.b("\n"+t),i.b('    <path d="M6 5H2v-1h4v1zM2 8h7v-1H2v1z m0 2h7v-1H2v1z m0 2h7v-1H2v1z m10-7.5v9.5c0 0.55-0.45 1-1 1H1c-0.55 0-1-0.45-1-1V2c0-0.55 0.45-1 1-1h7.5l3.5 3.5z m-1 0.5L8 2H1v12h10V5z"></path>'),i.b("\n"+t),i.b("</svg>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["line-by-line-file-diff"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<div id="'),i.b(i.v(i.f("fileHtmlId",e,n,0))),i.b('" class="d2h-file-wrapper" data-lang="'),i.b(i.v(i.d("file.language",e,n,0))),i.b('">'),i.b("\n"+t),i.b('    <div class="d2h-file-header">'),i.b("\n"+t),i.b("    "),i.b(i.t(i.f("filePath",e,n,0))),i.b("\n"+t),i.b("    </div>"),i.b("\n"+t),i.b('    <div class="d2h-file-diff">'),i.b("\n"+t),i.b('        <div class="d2h-code-wrapper">'),i.b("\n"+t),i.b('            <table class="d2h-diff-table">'),i.b("\n"+t),i.b('                <tbody class="d2h-diff-tbody">'),i.b("\n"+t),i.b("                "),i.b(i.t(i.f("diffs",e,n,0))),i.b("\n"+t),i.b("                </tbody>"),i.b("\n"+t),i.b("            </table>"),i.b("\n"+t),i.b("        </div>"),i.b("\n"+t),i.b("    </div>"),i.b("\n"+t),i.b("</div>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["line-by-line-numbers"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<div class="line-num1">'),i.b(i.v(i.f("oldNumber",e,n,0))),i.b("</div>"),i.b("\n"+t),i.b('<div class="line-num2">'),i.b(i.v(i.f("newNumber",e,n,0))),i.b("</div>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["side-by-side-file-diff"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<div id="'),i.b(i.v(i.f("fileHtmlId",e,n,0))),i.b('" class="d2h-file-wrapper" data-lang="'),i.b(i.v(i.d("file.language",e,n,0))),i.b('">'),i.b("\n"+t),i.b('    <div class="d2h-file-header">'),i.b("\n"+t),i.b("      "),i.b(i.t(i.f("filePath",e,n,0))),i.b("\n"+t),i.b("    </div>"),i.b("\n"+t),i.b('    <div class="d2h-files-diff">'),i.b("\n"+t),i.b('        <div class="d2h-file-side-diff">'),i.b("\n"+t),i.b('            <div class="d2h-code-wrapper">'),i.b("\n"+t),i.b('                <table class="d2h-diff-table">'),i.b("\n"+t),i.b('                    <tbody class="d2h-diff-tbody">'),i.b("\n"+t),i.b("                    "),i.b(i.t(i.d("diffs.left",e,n,0))),i.b("\n"+t),i.b("                    </tbody>"),i.b("\n"+t),i.b("                </table>"),i.b("\n"+t),i.b("            </div>"),i.b("\n"+t),i.b("        </div>"),i.b("\n"+t),i.b('        <div class="d2h-file-side-diff">'),i.b("\n"+t),i.b('            <div class="d2h-code-wrapper">'),i.b("\n"+t),i.b('                <table class="d2h-diff-table">'),i.b("\n"+t),i.b('                    <tbody class="d2h-diff-tbody">'),i.b("\n"+t),i.b("                    "),i.b(i.t(i.d("diffs.right",e,n,0))),i.b("\n"+t),i.b("                    </tbody>"),i.b("\n"+t),i.b("                </table>"),i.b("\n"+t),i.b("            </div>"),i.b("\n"+t),i.b("        </div>"),i.b("\n"+t),i.b("    </div>"),i.b("\n"+t),i.b("</div>"),i.fl()},partials:{},subs:{}}),n.defaultTemplates["tag-file-added"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<span class="d2h-tag d2h-added d2h-added-tag">ADDED</span>'),i.fl()},partials:{},subs:{}}),n.defaultTemplates["tag-file-changed"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<span class="d2h-tag d2h-changed d2h-changed-tag">CHANGED</span>'),i.fl()},partials:{},subs:{}}),n.defaultTemplates["tag-file-deleted"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<span class="d2h-tag d2h-deleted d2h-deleted-tag">DELETED</span>'),i.fl()},partials:{},subs:{}}),n.defaultTemplates["tag-file-renamed"]=new s.Template({code:function(e,n,t){var i=this;return i.b(t=t||""),i.b('<span class="d2h-tag d2h-moved d2h-moved-tag">RENAMED</span>'),i.fl()},partials:{},subs:{}})},6834:function(e,n,t){"use strict";var i=this&&this.__createBinding||(Object.create?function(e,n,t,i){void 0===i&&(i=t);var a=Object.getOwnPropertyDescriptor(n,t);a&&!("get"in a?!n.__esModule:a.writable||a.configurable)||(a={enumerable:!0,get:function(){return n[t]}}),Object.defineProperty(e,i,a)}:function(e,n,t,i){void 0===i&&(i=t),e[i]=n[t]}),a=this&&this.__setModuleDefault||(Object.create?function(e,n){Object.defineProperty(e,"default",{enumerable:!0,value:n})}:function(e,n){e.default=n}),r=this&&this.__importStar||function(e){if(e&&e.__esModule)return e;var n={};if(null!=e)for(var t in e)"default"!==t&&Object.prototype.hasOwnProperty.call(e,t)&&i(n,e,t);return a(n,e),n},s=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(n,"__esModule",{value:!0}),n.html=n.parse=n.defaultDiff2HtmlConfig=void 0;const o=r(t(8468)),l=t(3479),c=r(t(2378)),d=r(t(170)),u=t(9699),g=s(t(4063));n.defaultDiff2HtmlConfig=Object.assign(Object.assign(Object.assign({},c.defaultLineByLineRendererConfig),d.defaultSideBySideRendererConfig),{outputFormat:u.OutputFormatType.LINE_BY_LINE,drawFileList:!0}),n.parse=function(e,t={}){return o.parse(e,Object.assign(Object.assign({},n.defaultDiff2HtmlConfig),t))},n.html=function(e,t={}){const i=Object.assign(Object.assign({},n.defaultDiff2HtmlConfig),t),a="string"==typeof e?o.parse(e,i):e,r=new g.default(i),{colorScheme:s}=i,u={colorScheme:s};return(i.drawFileList?new l.FileListRenderer(r,u).render(a):"")+("side-by-side"===i.outputFormat?new d.default(r,i).render(a):new c.default(r,i).render(a))}},3479:function(e,n,t){"use strict";var i=this&&this.__createBinding||(Object.create?function(e,n,t,i){void 0===i&&(i=t);var a=Object.getOwnPropertyDescriptor(n,t);a&&!("get"in a?!n.__esModule:a.writable||a.configurable)||(a={enumerable:!0,get:function(){return n[t]}}),Object.defineProperty(e,i,a)}:function(e,n,t,i){void 0===i&&(i=t),e[i]=n[t]}),a=this&&this.__setModuleDefault||(Object.create?function(e,n){Object.defineProperty(e,"default",{enumerable:!0,value:n})}:function(e,n){e.default=n}),r=this&&this.__importStar||function(e){if(e&&e.__esModule)return e;var n={};if(null!=e)for(var t in e)"default"!==t&&Object.prototype.hasOwnProperty.call(e,t)&&i(n,e,t);return a(n,e),n};Object.defineProperty(n,"__esModule",{value:!0}),n.FileListRenderer=n.defaultFileListRendererConfig=void 0;const s=r(t(5741)),o="file-summary";n.defaultFileListRendererConfig={colorScheme:s.defaultRenderConfig.colorScheme},n.FileListRenderer=class{constructor(e,t={}){this.hoganUtils=e,this.config=Object.assign(Object.assign({},n.defaultFileListRendererConfig),t)}render(e){const n=e.map((e=>this.hoganUtils.render(o,"line",{fileHtmlId:s.getHtmlId(e),oldName:e.oldName,newName:e.newName,fileName:s.filenameDiff(e),deletedLines:"-"+e.deletedLines,addedLines:"+"+e.addedLines},{fileIcon:this.hoganUtils.template("icon",s.getFileIcon(e))}))).join("\n");return this.hoganUtils.render(o,"wrapper",{colorScheme:s.colorSchemeToCss(this.config.colorScheme),filesNumber:e.length,files:n})}}},4063:function(e,n,t){"use strict";var i=this&&this.__createBinding||(Object.create?function(e,n,t,i){void 0===i&&(i=t);var a=Object.getOwnPropertyDescriptor(n,t);a&&!("get"in a?!n.__esModule:a.writable||a.configurable)||(a={enumerable:!0,get:function(){return n[t]}}),Object.defineProperty(e,i,a)}:function(e,n,t,i){void 0===i&&(i=t),e[i]=n[t]}),a=this&&this.__setModuleDefault||(Object.create?function(e,n){Object.defineProperty(e,"default",{enumerable:!0,value:n})}:function(e,n){e.default=n}),r=this&&this.__importStar||function(e){if(e&&e.__esModule)return e;var n={};if(null!=e)for(var t in e)"default"!==t&&Object.prototype.hasOwnProperty.call(e,t)&&i(n,e,t);return a(n,e),n};Object.defineProperty(n,"__esModule",{value:!0});const s=r(t(5485)),o=t(979);n.default=class{constructor({compiledTemplates:e={},rawTemplates:n={}}){const t=Object.entries(n).reduce(((e,[n,t])=>{const i=s.compile(t,{asString:!1});return Object.assign(Object.assign({},e),{[n]:i})}),{});this.preCompiledTemplates=Object.assign(Object.assign(Object.assign({},o.defaultTemplates),e),t)}static compile(e){return s.compile(e,{asString:!1})}render(e,n,t,i,a){const r=this.templateKey(e,n);try{return this.preCompiledTemplates[r].render(t,i,a)}catch(e){throw new Error(`Could not find template to render '${r}'`)}}template(e,n){return this.preCompiledTemplates[this.templateKey(e,n)]}templateKey(e,n){return`${e}-${n}`}}},2378:function(e,n,t){"use strict";var i=this&&this.__createBinding||(Object.create?function(e,n,t,i){void 0===i&&(i=t);var a=Object.getOwnPropertyDescriptor(n,t);a&&!("get"in a?!n.__esModule:a.writable||a.configurable)||(a={enumerable:!0,get:function(){return n[t]}}),Object.defineProperty(e,i,a)}:function(e,n,t,i){void 0===i&&(i=t),e[i]=n[t]}),a=this&&this.__setModuleDefault||(Object.create?function(e,n){Object.defineProperty(e,"default",{enumerable:!0,value:n})}:function(e,n){e.default=n}),r=this&&this.__importStar||function(e){if(e&&e.__esModule)return e;var n={};if(null!=e)for(var t in e)"default"!==t&&Object.prototype.hasOwnProperty.call(e,t)&&i(n,e,t);return a(n,e),n};Object.defineProperty(n,"__esModule",{value:!0}),n.defaultLineByLineRendererConfig=void 0;const s=r(t(1483)),o=r(t(5741)),l=t(9699);n.defaultLineByLineRendererConfig=Object.assign(Object.assign({},o.defaultRenderConfig),{renderNothingWhenEmpty:!1,matchingMaxComparisons:2500,maxLineSizeInBlockForComparison:200});const c="generic",d="line-by-line";n.default=class{constructor(e,t={}){this.hoganUtils=e,this.config=Object.assign(Object.assign({},n.defaultLineByLineRendererConfig),t)}render(e){const n=e.map((e=>{let n;return n=e.blocks.length?this.generateFileHtml(e):this.generateEmptyDiff(),this.makeFileDiffHtml(e,n)})).join("\n");return this.hoganUtils.render(c,"wrapper",{colorScheme:o.colorSchemeToCss(this.config.colorScheme),content:n})}makeFileDiffHtml(e,n){if(this.config.renderNothingWhenEmpty&&Array.isArray(e.blocks)&&0===e.blocks.length)return"";const t=this.hoganUtils.template(d,"file-diff"),i=this.hoganUtils.template(c,"file-path"),a=this.hoganUtils.template("icon","file"),r=this.hoganUtils.template("tag",o.getFileIcon(e));return t.render({file:e,fileHtmlId:o.getHtmlId(e),diffs:n,filePath:i.render({fileDiffName:o.filenameDiff(e)},{fileIcon:a,fileTag:r})})}generateEmptyDiff(){return this.hoganUtils.render(c,"empty-diff",{contentClass:"d2h-code-line",CSSLineClass:o.CSSLineClass})}generateFileHtml(e){const n=s.newMatcherFn(s.newDistanceFn((n=>o.deconstructLine(n.content,e.isCombined).content)));return e.blocks.map((t=>{let i=this.hoganUtils.render(c,"block-header",{CSSLineClass:o.CSSLineClass,blockHeader:e.isTooBig?t.header:o.escapeForHtml(t.header),lineClass:"d2h-code-linenumber",contentClass:"d2h-code-line"});return this.applyLineGroupping(t).forEach((([t,a,r])=>{if(a.length&&r.length&&!t.length)this.applyRematchMatching(a,r,n).map((([n,t])=>{const{left:a,right:r}=this.processChangedLines(e,e.isCombined,n,t);i+=a,i+=r}));else if(t.length)t.forEach((n=>{const{prefix:t,content:a}=o.deconstructLine(n.content,e.isCombined);i+=this.generateSingleLineHtml(e,{type:o.CSSLineClass.CONTEXT,prefix:t,content:a,oldNumber:n.oldNumber,newNumber:n.newNumber})}));else if(a.length||r.length){const{left:n,right:t}=this.processChangedLines(e,e.isCombined,a,r);i+=n,i+=t}else console.error("Unknown state reached while processing groups of lines",t,a,r)})),i})).join("\n")}applyLineGroupping(e){const n=[];let t=[],i=[];for(let a=0;a<e.lines.length;a++){const r=e.lines[a];(r.type!==l.LineType.INSERT&&i.length||r.type===l.LineType.CONTEXT&&t.length>0)&&(n.push([[],t,i]),t=[],i=[]),r.type===l.LineType.CONTEXT?n.push([[r],[],[]]):r.type===l.LineType.INSERT&&0===t.length?n.push([[],[],[r]]):r.type===l.LineType.INSERT&&t.length>0?i.push(r):r.type===l.LineType.DELETE&&t.push(r)}return(t.length||i.length)&&(n.push([[],t,i]),t=[],i=[]),n}applyRematchMatching(e,n,t){const i=e.length*n.length,a=Math.max.apply(null,[0].concat(e.concat(n).map((e=>e.content.length))));return i<this.config.matchingMaxComparisons&&a<this.config.maxLineSizeInBlockForComparison&&("lines"===this.config.matching||"words"===this.config.matching)?t(e,n):[[e,n]]}processChangedLines(e,n,t,i){const a={right:"",left:""},r=Math.max(t.length,i.length);for(let s=0;s<r;s++){const r=t[s],l=i[s],c=void 0!==r&&void 0!==l?o.diffHighlight(r.content,l.content,n,this.config):void 0,d=void 0!==r&&void 0!==r.oldNumber?Object.assign(Object.assign({},void 0!==c?{prefix:c.oldLine.prefix,content:c.oldLine.content,type:o.CSSLineClass.DELETE_CHANGES}:Object.assign(Object.assign({},o.deconstructLine(r.content,n)),{type:o.toCSSClass(r.type)})),{oldNumber:r.oldNumber,newNumber:r.newNumber}):void 0,u=void 0!==l&&void 0!==l.newNumber?Object.assign(Object.assign({},void 0!==c?{prefix:c.newLine.prefix,content:c.newLine.content,type:o.CSSLineClass.INSERT_CHANGES}:Object.assign(Object.assign({},o.deconstructLine(l.content,n)),{type:o.toCSSClass(l.type)})),{oldNumber:l.oldNumber,newNumber:l.newNumber}):void 0,{left:g,right:b}=this.generateLineHtml(e,d,u);a.left+=g,a.right+=b}return a}generateLineHtml(e,n,t){return{left:this.generateSingleLineHtml(e,n),right:this.generateSingleLineHtml(e,t)}}generateSingleLineHtml(e,n){if(void 0===n)return"";const t=this.hoganUtils.render(d,"numbers",{oldNumber:n.oldNumber||"",newNumber:n.newNumber||""});return this.hoganUtils.render(c,"line",{type:n.type,lineClass:"d2h-code-linenumber",contentClass:"d2h-code-line",prefix:" "===n.prefix?"&nbsp;":n.prefix,content:n.content,lineNumber:t,line:n,file:e})}}},1483:(e,n)=>{"use strict";function t(e,n){if(0===e.length)return n.length;if(0===n.length)return e.length;const t=[];let i,a;for(i=0;i<=n.length;i++)t[i]=[i];for(a=0;a<=e.length;a++)t[0][a]=a;for(i=1;i<=n.length;i++)for(a=1;a<=e.length;a++)n.charAt(i-1)===e.charAt(a-1)?t[i][a]=t[i-1][a-1]:t[i][a]=Math.min(t[i-1][a-1]+1,Math.min(t[i][a-1]+1,t[i-1][a]+1));return t[n.length][e.length]}Object.defineProperty(n,"__esModule",{value:!0}),n.newMatcherFn=n.newDistanceFn=n.levenshtein=void 0,n.levenshtein=t,n.newDistanceFn=function(e){return(n,i)=>{const a=e(n).trim(),r=e(i).trim();return t(a,r)/(a.length+r.length)}},n.newMatcherFn=function(e){return function n(t,i,a=0,r=new Map){const s=function(n,t,i=new Map){let a,r=1/0;for(let s=0;s<n.length;++s)for(let o=0;o<t.length;++o){const l=JSON.stringify([n[s],t[o]]);let c;i.has(l)&&(c=i.get(l))||(c=e(n[s],t[o]),i.set(l,c)),c<r&&(r=c,a={indexA:s,indexB:o,score:r})}return a}(t,i,r);if(!s||t.length+i.length<3)return[[t,i]];const o=t.slice(0,s.indexA),l=i.slice(0,s.indexB),c=[t[s.indexA]],d=[i[s.indexB]],u=s.indexA+1,g=s.indexB+1,b=t.slice(u),p=i.slice(g),f=n(o,l,a+1,r),m=n(c,d,a+1,r),E=n(b,p,a+1,r);let h=m;return(s.indexA>0||s.indexB>0)&&(h=f.concat(h)),(t.length>u||i.length>g)&&(h=h.concat(E)),h}}},5741:function(e,n,t){"use strict";var i=this&&this.__createBinding||(Object.create?function(e,n,t,i){void 0===i&&(i=t);var a=Object.getOwnPropertyDescriptor(n,t);a&&!("get"in a?!n.__esModule:a.writable||a.configurable)||(a={enumerable:!0,get:function(){return n[t]}}),Object.defineProperty(e,i,a)}:function(e,n,t,i){void 0===i&&(i=t),e[i]=n[t]}),a=this&&this.__setModuleDefault||(Object.create?function(e,n){Object.defineProperty(e,"default",{enumerable:!0,value:n})}:function(e,n){e.default=n}),r=this&&this.__importStar||function(e){if(e&&e.__esModule)return e;var n={};if(null!=e)for(var t in e)"default"!==t&&Object.prototype.hasOwnProperty.call(e,t)&&i(n,e,t);return a(n,e),n};Object.defineProperty(n,"__esModule",{value:!0}),n.diffHighlight=n.getFileIcon=n.getHtmlId=n.filenameDiff=n.deconstructLine=n.escapeForHtml=n.colorSchemeToCss=n.toCSSClass=n.defaultRenderConfig=n.CSSLineClass=void 0;const s=r(t(9479)),o=t(8593),l=r(t(1483)),c=t(9699);n.CSSLineClass={INSERTS:"d2h-ins",DELETES:"d2h-del",CONTEXT:"d2h-cntx",INFO:"d2h-info",INSERT_CHANGES:"d2h-ins d2h-change",DELETE_CHANGES:"d2h-del d2h-change"},n.defaultRenderConfig={matching:c.LineMatchingType.NONE,matchWordsThreshold:.25,maxLineLengthHighlight:1e4,diffStyle:c.DiffStyleType.WORD,colorScheme:c.ColorSchemeType.LIGHT};const d="/",u=l.newDistanceFn((e=>e.value)),g=l.newMatcherFn(u);function b(e){return-1!==e.indexOf("dev/null")}function p(e){return e.replace(/(<del[^>]*>((.|\n)*?)<\/del>)/g,"")}function f(e){return e.slice(0).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;").replace(/\//g,"&#x2F;")}function m(e,n,t=!0){const i=function(e){return e?2:1}(n);return{prefix:e.substring(0,i),content:t?f(e.substring(i)):e.substring(i)}}function E(e){const n=(0,o.unifyPath)(e.oldName),t=(0,o.unifyPath)(e.newName);if(n===t||b(n)||b(t))return b(t)?n:t;{const e=[],i=[],a=n.split(d),r=t.split(d);let s=0,o=a.length-1,l=r.length-1;for(;s<o&&s<l&&a[s]===r[s];)e.push(r[s]),s+=1;for(;o>s&&l>s&&a[o]===r[l];)i.unshift(r[l]),o-=1,l-=1;const c=e.join(d),u=i.join(d),g=a.slice(s,o+1).join(d),b=r.slice(s,l+1).join(d);return c.length&&u.length?c+d+"{"+g+" → "+b+"}"+d+u:c.length?c+d+"{"+g+" → "+b+"}":u.length?"{"+g+" → "+b+"}"+d+u:n+" → "+t}}n.toCSSClass=function(e){switch(e){case c.LineType.CONTEXT:return n.CSSLineClass.CONTEXT;case c.LineType.INSERT:return n.CSSLineClass.INSERTS;case c.LineType.DELETE:return n.CSSLineClass.DELETES}},n.colorSchemeToCss=function(e){switch(e){case c.ColorSchemeType.DARK:return"d2h-dark-color-scheme";case c.ColorSchemeType.AUTO:return"d2h-auto-color-scheme";case c.ColorSchemeType.LIGHT:default:return"d2h-light-color-scheme"}},n.escapeForHtml=f,n.deconstructLine=m,n.filenameDiff=E,n.getHtmlId=function(e){return`d2h-${(0,o.hashCode)(E(e)).toString().slice(-6)}`},n.getFileIcon=function(e){let n="file-changed";return e.isRename||e.isCopy?n="file-renamed":e.isNew?n="file-added":e.isDeleted?n="file-deleted":e.newName!==e.oldName&&(n="file-renamed"),n},n.diffHighlight=function(e,t,i,a={}){const{matching:r,maxLineLengthHighlight:o,matchWordsThreshold:l,diffStyle:c}=Object.assign(Object.assign({},n.defaultRenderConfig),a),d=m(e,i,!1),b=m(t,i,!1);if(d.content.length>o||b.content.length>o)return{oldLine:{prefix:d.prefix,content:f(d.content)},newLine:{prefix:b.prefix,content:f(b.content)}};const E="char"===c?s.diffChars(d.content,b.content):s.diffWordsWithSpace(d.content,b.content),h=[];if("word"===c&&"words"===r){const e=E.filter((e=>e.removed)),n=E.filter((e=>e.added));g(n,e).forEach((e=>{1===e[0].length&&1===e[1].length&&u(e[0][0],e[1][0])<l&&(h.push(e[0][0]),h.push(e[1][0]))}))}const _=E.reduce(((e,n)=>{const t=n.added?"ins":n.removed?"del":null,i=h.indexOf(n)>-1?' class="d2h-change"':"",a=f(n.value);return null!==t?`${e}<${t}${i}>${a}</${t}>`:`${e}${a}`}),"");return{oldLine:{prefix:d.prefix,content:(N=_,N.replace(/(<ins[^>]*>((.|\n)*?)<\/ins>)/g,""))},newLine:{prefix:b.prefix,content:p(_)}};var N}},170:function(e,n,t){"use strict";var i=this&&this.__createBinding||(Object.create?function(e,n,t,i){void 0===i&&(i=t);var a=Object.getOwnPropertyDescriptor(n,t);a&&!("get"in a?!n.__esModule:a.writable||a.configurable)||(a={enumerable:!0,get:function(){return n[t]}}),Object.defineProperty(e,i,a)}:function(e,n,t,i){void 0===i&&(i=t),e[i]=n[t]}),a=this&&this.__setModuleDefault||(Object.create?function(e,n){Object.defineProperty(e,"default",{enumerable:!0,value:n})}:function(e,n){e.default=n}),r=this&&this.__importStar||function(e){if(e&&e.__esModule)return e;var n={};if(null!=e)for(var t in e)"default"!==t&&Object.prototype.hasOwnProperty.call(e,t)&&i(n,e,t);return a(n,e),n};Object.defineProperty(n,"__esModule",{value:!0}),n.defaultSideBySideRendererConfig=void 0;const s=r(t(1483)),o=r(t(5741)),l=t(9699);n.defaultSideBySideRendererConfig=Object.assign(Object.assign({},o.defaultRenderConfig),{renderNothingWhenEmpty:!1,matchingMaxComparisons:2500,maxLineSizeInBlockForComparison:200});const c="generic";n.default=class{constructor(e,t={}){this.hoganUtils=e,this.config=Object.assign(Object.assign({},n.defaultSideBySideRendererConfig),t)}render(e){const n=e.map((e=>{let n;return n=e.blocks.length?this.generateFileHtml(e):this.generateEmptyDiff(),this.makeFileDiffHtml(e,n)})).join("\n");return this.hoganUtils.render(c,"wrapper",{colorScheme:o.colorSchemeToCss(this.config.colorScheme),content:n})}makeFileDiffHtml(e,n){if(this.config.renderNothingWhenEmpty&&Array.isArray(e.blocks)&&0===e.blocks.length)return"";const t=this.hoganUtils.template("side-by-side","file-diff"),i=this.hoganUtils.template(c,"file-path"),a=this.hoganUtils.template("icon","file"),r=this.hoganUtils.template("tag",o.getFileIcon(e));return t.render({file:e,fileHtmlId:o.getHtmlId(e),diffs:n,filePath:i.render({fileDiffName:o.filenameDiff(e)},{fileIcon:a,fileTag:r})})}generateEmptyDiff(){return{right:"",left:this.hoganUtils.render(c,"empty-diff",{contentClass:"d2h-code-side-line",CSSLineClass:o.CSSLineClass})}}generateFileHtml(e){const n=s.newMatcherFn(s.newDistanceFn((n=>o.deconstructLine(n.content,e.isCombined).content)));return e.blocks.map((t=>{const i={left:this.makeHeaderHtml(t.header,e),right:this.makeHeaderHtml("")};return this.applyLineGroupping(t).forEach((([t,a,r])=>{if(a.length&&r.length&&!t.length)this.applyRematchMatching(a,r,n).map((([n,t])=>{const{left:a,right:r}=this.processChangedLines(e.isCombined,n,t);i.left+=a,i.right+=r}));else if(t.length)t.forEach((n=>{const{prefix:t,content:a}=o.deconstructLine(n.content,e.isCombined),{left:r,right:s}=this.generateLineHtml({type:o.CSSLineClass.CONTEXT,prefix:t,content:a,number:n.oldNumber},{type:o.CSSLineClass.CONTEXT,prefix:t,content:a,number:n.newNumber});i.left+=r,i.right+=s}));else if(a.length||r.length){const{left:n,right:t}=this.processChangedLines(e.isCombined,a,r);i.left+=n,i.right+=t}else console.error("Unknown state reached while processing groups of lines",t,a,r)})),i})).reduce(((e,n)=>({left:e.left+n.left,right:e.right+n.right})),{left:"",right:""})}applyLineGroupping(e){const n=[];let t=[],i=[];for(let a=0;a<e.lines.length;a++){const r=e.lines[a];(r.type!==l.LineType.INSERT&&i.length||r.type===l.LineType.CONTEXT&&t.length>0)&&(n.push([[],t,i]),t=[],i=[]),r.type===l.LineType.CONTEXT?n.push([[r],[],[]]):r.type===l.LineType.INSERT&&0===t.length?n.push([[],[],[r]]):r.type===l.LineType.INSERT&&t.length>0?i.push(r):r.type===l.LineType.DELETE&&t.push(r)}return(t.length||i.length)&&(n.push([[],t,i]),t=[],i=[]),n}applyRematchMatching(e,n,t){const i=e.length*n.length,a=Math.max.apply(null,[0].concat(e.concat(n).map((e=>e.content.length))));return i<this.config.matchingMaxComparisons&&a<this.config.maxLineSizeInBlockForComparison&&("lines"===this.config.matching||"words"===this.config.matching)?t(e,n):[[e,n]]}makeHeaderHtml(e,n){return this.hoganUtils.render(c,"block-header",{CSSLineClass:o.CSSLineClass,blockHeader:(null==n?void 0:n.isTooBig)?e:o.escapeForHtml(e),lineClass:"d2h-code-side-linenumber",contentClass:"d2h-code-side-line"})}processChangedLines(e,n,t){const i={right:"",left:""},a=Math.max(n.length,t.length);for(let r=0;r<a;r++){const a=n[r],s=t[r],l=void 0!==a&&void 0!==s?o.diffHighlight(a.content,s.content,e,this.config):void 0,c=void 0!==a&&void 0!==a.oldNumber?Object.assign(Object.assign({},void 0!==l?{prefix:l.oldLine.prefix,content:l.oldLine.content,type:o.CSSLineClass.DELETE_CHANGES}:Object.assign(Object.assign({},o.deconstructLine(a.content,e)),{type:o.toCSSClass(a.type)})),{number:a.oldNumber}):void 0,d=void 0!==s&&void 0!==s.newNumber?Object.assign(Object.assign({},void 0!==l?{prefix:l.newLine.prefix,content:l.newLine.content,type:o.CSSLineClass.INSERT_CHANGES}:Object.assign(Object.assign({},o.deconstructLine(s.content,e)),{type:o.toCSSClass(s.type)})),{number:s.newNumber}):void 0,{left:u,right:g}=this.generateLineHtml(c,d);i.left+=u,i.right+=g}return i}generateLineHtml(e,n){return{left:this.generateSingleHtml(e),right:this.generateSingleHtml(n)}}generateSingleHtml(e){const n="d2h-code-side-linenumber",t="d2h-code-side-line";return this.hoganUtils.render(c,"line",{type:(null==e?void 0:e.type)||`${o.CSSLineClass.CONTEXT} d2h-emptyplaceholder`,lineClass:void 0!==e?n:`${n} d2h-code-side-emptyplaceholder`,contentClass:void 0!==e?t:`${t} d2h-code-side-emptyplaceholder`,prefix:" "===(null==e?void 0:e.prefix)?"&nbsp;":null==e?void 0:e.prefix,content:null==e?void 0:e.content,lineNumber:null==e?void 0:e.number})}}},9699:(e,n)=>{"use strict";var t,i;Object.defineProperty(n,"__esModule",{value:!0}),n.ColorSchemeType=n.DiffStyleType=n.LineMatchingType=n.OutputFormatType=n.LineType=void 0,function(e){e.INSERT="insert",e.DELETE="delete",e.CONTEXT="context"}(t||(n.LineType=t={})),n.OutputFormatType={LINE_BY_LINE:"line-by-line",SIDE_BY_SIDE:"side-by-side"},n.LineMatchingType={LINES:"lines",WORDS:"words",NONE:"none"},n.DiffStyleType={WORD:"word",CHAR:"char"},function(e){e.AUTO="auto",e.DARK="dark",e.LIGHT="light"}(i||(n.ColorSchemeType=i={}))},4169:(e,n,t)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.Diff2HtmlUI=n.defaultDiff2HtmlUIConfig=void 0;const i=t(1529),a=t(6834);n.defaultDiff2HtmlUIConfig=Object.assign(Object.assign({},a.defaultDiff2HtmlConfig),{synchronisedScroll:!0,highlight:!0,fileListToggle:!0,fileListStartVisible:!1,highlightLanguages:new Map,smartSelection:!0,fileContentToggle:!0,stickyFileHeaders:!0}),n.Diff2HtmlUI=class{constructor(e,t,i={},r){this.hljs=null,this.currentSelectionColumnId=-1,this.config=Object.assign(Object.assign({},n.defaultDiff2HtmlUIConfig),i),this.diffHtml=void 0!==t?(0,a.html)(t,this.config):e.innerHTML,this.targetElement=e,void 0!==r&&(this.hljs=r)}draw(){this.targetElement.innerHTML=this.diffHtml,this.config.synchronisedScroll&&this.synchronisedScroll(),this.config.highlight&&this.highlightCode(),this.config.fileListToggle&&this.fileListToggle(this.config.fileListStartVisible),this.config.fileContentToggle&&this.fileContentToggle(),this.config.stickyFileHeaders&&this.stickyFileHeaders()}synchronisedScroll(){this.targetElement.querySelectorAll(".d2h-file-wrapper").forEach((e=>{const[n,t]=Array().slice.call(e.querySelectorAll(".d2h-file-side-diff"));if(void 0===n||void 0===t)return;const i=e=>{null!==e&&null!==e.target&&(e.target===n?(t.scrollTop=n.scrollTop,t.scrollLeft=n.scrollLeft):(n.scrollTop=t.scrollTop,n.scrollLeft=t.scrollLeft))};n.addEventListener("scroll",i),t.addEventListener("scroll",i)}))}fileListToggle(e){const n=this.targetElement.querySelector(".d2h-show"),t=this.targetElement.querySelector(".d2h-hide"),i=this.targetElement.querySelector(".d2h-file-list");if(null===n||null===t||null===i)return;const a=()=>{n.style.display="none",t.style.display="inline",i.style.display="block"},r=()=>{n.style.display="inline",t.style.display="none",i.style.display="none"};n.addEventListener("click",(()=>a())),t.addEventListener("click",(()=>r()));const s=this.getHashTag();"files-summary-show"===s?a():"files-summary-hide"===s?r():e?a():r()}fileContentToggle(){this.targetElement.querySelectorAll(".d2h-file-collapse").forEach((e=>{e.style.display="flex";const n=n=>{var t;const i=null===(t=e.closest(".d2h-file-wrapper"))||void 0===t?void 0:t.querySelector(n);null!=i&&(e.classList.toggle("d2h-selected"),i.classList.toggle("d2h-d-none"))};e.addEventListener("click",(t=>(t=>{e!==t.target&&(n(".d2h-file-diff"),n(".d2h-files-diff"))})(t)))}))}highlightCode(){const e=this.hljs;if(null===e)throw new Error("Missing a `highlight.js` implementation. Please provide one when instantiating Diff2HtmlUI.");this.targetElement.querySelectorAll(".d2h-file-wrapper").forEach((n=>{const t=n.getAttribute("data-lang");this.config.highlightLanguages instanceof Map||(this.config.highlightLanguages=new Map(Object.entries(this.config.highlightLanguages)));let a=t&&this.config.highlightLanguages.has(t)?this.config.highlightLanguages.get(t):t?(0,i.getLanguage)(t):"plaintext";void 0===e.getLanguage(a)&&(a="plaintext"),n.querySelectorAll(".d2h-code-line-ctn").forEach((n=>{const t=n.textContent,r=n.parentNode;if(null===t||null===r||!this.isElement(r))return;const s=(0,i.closeTags)(e.highlight(t,{language:a,ignoreIllegals:!0})),o=(0,i.nodeStream)(n);if(o.length){const e=document.createElementNS("http://www.w3.org/1999/xhtml","div");e.innerHTML=s.value,s.value=(0,i.mergeStreams)(o,(0,i.nodeStream)(e),t)}n.classList.add("hljs"),s.language&&n.classList.add(s.language),n.innerHTML=s.value}))}))}stickyFileHeaders(){this.targetElement.querySelectorAll(".d2h-file-header").forEach((e=>{e.classList.add("d2h-sticky-header")}))}smartSelection(){console.warn("Smart selection is now enabled by default with CSS. No need to call this method anymore.")}getHashTag(){const e=document.URL,n=e.indexOf("#");let t=null;return-1!==n&&(t=e.substr(n+1)),t}isElement(e){return null!==e&&void 0!==(null==e?void 0:e.classList)}}},1529:(e,n)=>{"use strict";function t(e){return e.replace(/&/gm,"&amp;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;")}function i(e){return e.nodeName.toLowerCase()}Object.defineProperty(n,"__esModule",{value:!0}),n.getLanguage=n.closeTags=n.mergeStreams=n.nodeStream=void 0,n.nodeStream=function(e){const n=[],t=(e,a)=>{for(let r=e.firstChild;r;r=r.nextSibling)3===r.nodeType&&null!==r.nodeValue?a+=r.nodeValue.length:1===r.nodeType&&(n.push({event:"start",offset:a,node:r}),a=t(r,a),i(r).match(/br|hr|img|input/)||n.push({event:"stop",offset:a,node:r}));return a};return t(e,0),n},n.mergeStreams=function(e,n,a){let r=0,s="";const o=[];function l(){return e.length&&n.length?e[0].offset!==n[0].offset?e[0].offset<n[0].offset?e:n:"start"===n[0].event?e:n:e.length?e:n}function c(e){if(null===(n=e)||void 0===(null==n?void 0:n.attributes))throw new Error("Node is not an Element");var n;s+=`<${i(e)} ${Array().map.call(e.attributes,(e=>`${e.nodeName}="${t(e.value).replace(/"/g,"&quot;")}"`)).join(" ")}>`}function d(e){s+="</"+i(e)+">"}function u(e){("start"===e.event?c:d)(e.node)}for(;e.length||n.length;){let n=l();if(s+=t(a.substring(r,n[0].offset)),r=n[0].offset,n===e){o.reverse().forEach(d);do{u(n.splice(0,1)[0]),n=l()}while(n===e&&n.length&&n[0].offset===r);o.reverse().forEach(c)}else"start"===n[0].event?o.push(n[0].node):o.pop(),u(n.splice(0,1)[0])}return s+t(a.substr(r))},n.closeTags=function(e){const n=new Array;return e.value=e.value.split("\n").map((e=>{const t=n.map((e=>`<span class="${e}">`)).join(""),i=e.matchAll(/(<span class="(.*?)">|<\/span>)/g);return Array.from(i).forEach((e=>{"</span>"===e[0]?n.shift():n.unshift(e[2])})),t+e+"</span>".repeat(n.length)})).join("\n"),e};const a={"1c":"1c",abnf:"abnf",accesslog:"accesslog",as:"actionscript",adb:"ada",ada:"ada",ads:"ada",angelscript:"angelscript",apache:"apache",applescript:"applescript",scpt:"applescript",arcade:"arcade",cpp:"cpp",hpp:"cpp",arduino:"arduino",ino:"arduino",armasm:"armasm",arm:"armasm",xml:"xml",html:"xml",xhtml:"xml",rss:"xml",atom:"xml",xjb:"xml",xsd:"xml",xsl:"xml",plist:"xml",svg:"xml",asciidoc:"asciidoc",adoc:"asciidoc",asc:"asciidoc",aspectj:"aspectj",ahk:"autohotkey",ahkl:"autohotkey",au3:"autoit",avrasm:"avrasm",awk:"awk",axapta:"axapta","x++":"axapta",bash:"bash",sh:"bash",zsh:"bash",b:"basic",bnf:"bnf",bf:"brainfuck",c:"c",h:"c",cats:"c",idc:"c",cal:"cal",capnproto:"capnproto",capnp:"capnproto",ceylon:"ceylon",clean:"clean",clj:"clojure",boot:"clojure",cl2:"clojure",cljc:"clojure",cljs:"clojure","cljs.hl":"clojure",cljscm:"clojure",cljx:"clojure",hic:"clojure","clojure-repl":"clojure-repl",cmake:"cmake","cmake.in":"cmake",coffee:"coffeescript",_coffee:"coffeescript",cake:"coffeescript",cjsx:"coffeescript",iced:"coffeescript",cson:"coffeescript",coq:"coq",cos:"cos",cls:"cos",crmsh:"crmsh",crm:"crmsh",pcmk:"crmsh",cr:"crystal",cs:"csharp",csx:"csharp",csp:"csp",css:"css",d:"d",di:"d",md:"markdown",markdown:"markdown",mdown:"markdown",mdwn:"markdown",mkd:"markdown",mkdn:"markdown",mkdown:"markdown",ronn:"markdown",workbook:"markdown",dart:"dart",dpr:"delphi",dfm:"delphi",pas:"delphi",pascal:"delphi",diff:"diff",patch:"diff",django:"django",jinja:"django",dns:"dns",zone:"dns",bind:"dns",dockerfile:"dockerfile",docker:"dockerfile",dos:"dos",bat:"dos",cmd:"dos",dsconfig:"dsconfig",dts:"dts",dust:"dust",dst:"dust",ebnf:"ebnf",ex:"elixir",exs:"elixir",elm:"elm",rb:"ruby",builder:"ruby",eye:"ruby",gemspec:"ruby",god:"ruby",jbuilder:"ruby",mspec:"ruby",pluginspec:"ruby",podspec:"ruby",rabl:"ruby",rake:"ruby",rbuild:"ruby",rbw:"ruby",rbx:"ruby",ru:"ruby",ruby:"ruby",spec:"ruby",thor:"ruby",watchr:"ruby",erb:"erb","erlang-repl":"erlang-repl",erl:"erlang","app.src":"erlang",escript:"erlang",hrl:"erlang",xrl:"erlang",yrl:"erlang",excel:"excel",xls:"excel",xlsx:"excel",fix:"fix",flix:"flix",f90:"fortran",f:"fortran",f03:"fortran",f08:"fortran",f77:"fortran",f95:"fortran",for:"fortran",fpp:"fortran",fs:"fsharp",fsx:"fsharp",gams:"gams",gms:"gams",gauss:"gauss",gss:"gauss",gcode:"gcode",nc:"gcode",gherkin:"gherkin",glsl:"glsl",fp:"glsl",frag:"glsl",frg:"glsl",fsh:"glsl",fshader:"glsl",geo:"glsl",geom:"glsl",glslv:"glsl",gshader:"glsl",shader:"glsl",tesc:"glsl",tese:"glsl",vert:"glsl",vrx:"glsl",vsh:"glsl",vshader:"glsl",gml:"gml",go:"go",bal:"go",golo:"golo",gololang:"golo",gradle:"gradle",groovy:"groovy",grt:"groovy",gtpl:"groovy",gvy:"groovy",haml:"haml","haml.deface":"haml",handlebars:"handlebars",hbs:"handlebars","html.hbs":"handlebars","html.handlebars":"handlebars",hs:"haskell",hsc:"haskell",idr:"haskell",purs:"haskell",hx:"haxe",hxsl:"haxe",hsp:"hsp",htmlbars:"htmlbars",http:"http",https:"http",hy:"hy",inform7:"inform7",i7:"inform7",ini:"ini",toml:"ini",cfg:"ini",prefs:"ini",irpf90:"irpf90",isbl:"isbl",java:"java",jsp:"java",js:"javascript",jsx:"javascript",_js:"javascript",bones:"javascript",es:"javascript",es6:"javascript",gs:"javascript",jake:"javascript",jsb:"javascript",jscad:"javascript",jsfl:"javascript",jsm:"javascript",jss:"javascript",mjs:"javascript",njs:"javascript",pac:"javascript",sjs:"javascript",ssjs:"javascript",xsjs:"javascript",xsjslib:"javascript",cfc:"javascript","jboss-cli":"jboss-cli",json:"json",avsc:"json",geojson:"json",gltf:"json","JSON-tmLanguage":"json",jsonl:"json",tfstate:"json","tfstate.backup":"json",topojson:"json",webapp:"json",webmanifest:"json",jl:"julia","julia-repl":"julia-repl",kt:"kotlin",ktm:"kotlin",kts:"kotlin",lasso:"lasso",lassoscript:"lasso",tex:"latex",ldif:"ldif",leaf:"leaf",less:"less",lisp:"lisp",factor:"lisp",livecodeserver:"livecodeserver",ls:"livescript",_ls:"livescript",llvm:"llvm",lsl:"lsl",lua:"lua",nse:"lua",p8:"lua",pd_lua:"lua",rbxs:"lua",wlua:"lua",mak:"makefile",make:"makefile",mk:"makefile",mkfile:"makefile",mathematica:"mathematica",mma:"mathematica",wl:"mathematica",matlab:"matlab",maxima:"maxima",mel:"mel",mercury:"mercury",mipsasm:"mipsasm",miz:"mizar",voc:"mizar",al:"perl",cgi:"perl",fcgi:"perl",perl:"perl",ph:"perl",plx:"perl",pl:"perl",pm:"perl",psgi:"perl",t:"perl",mojolicious:"mojolicious",monkey:"monkey",monkey2:"monkey",moonscript:"moonscript",moon:"moonscript",n1ql:"n1ql",nginxconf:"nginx",nim:"nim",nimrod:"nim",nix:"nix",nsi:"nsis",nsh:"nsis",m:"objectivec",objc:"objectivec",mm:"objectivec","obj-c":"objectivec","obj-c++":"objectivec","objective-c++":"objectivec",fun:"ocaml",sig:"ocaml",ml:"ocaml",mli:"ocaml",eliom:"ocaml",eliomi:"ocaml",ml4:"ocaml",mll:"ocaml",mly:"ocaml",openscad:"openscad",oxygene:"oxygene",parser3:"parser3",pf:"pf","pf.conf":"pf",pgsql:"pgsql",postgres:"pgsql",postgresql:"pgsql",php:"php",aw:"php",ctp:"php",inc:"php",php3:"php",php4:"php",php5:"php",phps:"php",phpt:"php","php-template":"php-template",plaintext:"plaintext",txt:"plaintext",text:"plaintext",pony:"pony",ps:"powershell",ps1:"powershell",psd1:"powershell",psm1:"powershell",pde:"processing",profile:"profile",pro:"prolog",prolog:"prolog",yap:"prolog",properties:"properties",proto:"protobuf",puppet:"puppet",pp:"puppet",purebasic:"purebasic",py:"python",bzl:"python",gyp:"python",gypi:"python",lmi:"python",py3:"python",pyde:"python",pyi:"python",pyp:"python",pyt:"python",pyw:"python",rpy:"python",tac:"python",wsgi:"python",xpy:"python","python-repl":"python-repl",pycon:"python-repl",q:"q",k:"q",kdb:"q",qml:"qml",r:"r",rd:"r",rsx:"r",reasonml:"reasonml",re:"reasonml",rib:"rib",roboconf:"roboconf",graph:"roboconf",instances:"roboconf",routeros:"routeros",rsl:"rsl",ruleslanguage:"ruleslanguage",rs:"rust","rs.in":"rust",sas:"sas",scala:"scala",kojo:"scala",sbt:"scala",sc:"scala",scm:"scheme",sch:"scheme",sld:"scheme",sls:"scheme",sps:"scheme",ss:"scheme",rkt:"scheme",scilab:"scilab",scss:"scss",shell:"shell",smali:"smali",st:"smalltalk",sml:"sml",sqf:"sqf",sql:"sql",cql:"sql",ddl:"sql",mysql:"sql",prc:"sql",tab:"sql",udf:"sql",viw:"sql",stan:"stan",stanfuncs:"stan",stata:"stata",step21:"step21",step:"step21",stp:"step21",styl:"stylus",subunit:"subunit",swift:"swift",taggerscript:"taggerscript",yml:"yaml",mir:"yaml",reek:"yaml",rviz:"yaml","sublime-syntax":"yaml",syntax:"yaml",yaml:"yaml","yaml-tmlanguage":"yaml","yml.mysql":"yaml",tap:"tap",tcl:"tcl",adp:"tcl",tm:"tcl",thrift:"thrift",tp:"tp",twig:"twig",craftcms:"twig",ts:"typescript",tsx:"typescript",vala:"vala",vbnet:"vbnet",vb:"vbnet",vbscript:"vbscript",vbs:"vbscript","vbscript-html":"vbscript-html",v:"verilog",veo:"verilog",vhdl:"vhdl",vhd:"vhdl",vhf:"vhdl",vhi:"vhdl",vho:"vhdl",vhs:"vhdl",vht:"vhdl",vhw:"vhdl",vim:"vim",x86asm:"x86asm",xl:"xl",xquery:"xquery",xpath:"xquery",xq:"xquery",zephir:"zephir",zep:"zephir"};n.getLanguage=function(e){var n;return null!==(n=a[e])&&void 0!==n?n:"plaintext"}},1761:function(e,n,t){"use strict";var i=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(n,"__esModule",{value:!0}),n.hljs=void 0;const a=i(t(3390)),r=i(t(6248)),s=i(t(4610)),o=i(t(4868)),l=i(t(8780)),c=i(t(612)),d=i(t(2177)),u=i(t(3147)),g=i(t(3707)),b=i(t(9534)),p=i(t(5064)),f=i(t(2003)),m=i(t(6642)),E=i(t(7731)),h=i(t(7360)),_=i(t(2543)),N=i(t(5658)),T=i(t(7905)),O=i(t(7569)),A=i(t(6652)),v=i(t(2399)),y=i(t(9878)),S=i(t(4658)),R=i(t(1407)),I=i(t(7077)),w=i(t(4762)),C=i(t(8257)),L=i(t(978)),M=i(t(14)),D=i(t(5812)),x=i(t(4210)),k=i(t(1943)),P=i(t(4981)),U=i(t(7903)),B=i(t(2482)),F=i(t(4028)),j=i(t(2446)),H=i(t(9814)),G=i(t(2656)),$=i(t(2437)),z=i(t(5040)),V=i(t(7546)),K=i(t(5559)),W=i(t(8245)),q=i(t(9880)),X=i(t(729)),Y=i(t(1062)),Z=i(t(7874)),Q=i(t(8935)),J=i(t(7690)),ee=i(t(1392)),ne=i(t(8987));a.default.registerLanguage("cpp",r.default),a.default.registerLanguage("xml",s.default),a.default.registerLanguage("awk",o.default),a.default.registerLanguage("bash",l.default),a.default.registerLanguage("c",c.default),a.default.registerLanguage("clojure",d.default),a.default.registerLanguage("crystal",u.default),a.default.registerLanguage("csharp",g.default),a.default.registerLanguage("csp",b.default),a.default.registerLanguage("css",p.default),a.default.registerLanguage("markdown",f.default),a.default.registerLanguage("dart",m.default),a.default.registerLanguage("diff",E.default),a.default.registerLanguage("dockerfile",h.default),a.default.registerLanguage("elixir",_.default),a.default.registerLanguage("elm",N.default),a.default.registerLanguage("ruby",T.default),a.default.registerLanguage("erlang",O.default),a.default.registerLanguage("fsharp",A.default),a.default.registerLanguage("go",v.default),a.default.registerLanguage("gradle",y.default),a.default.registerLanguage("groovy",S.default),a.default.registerLanguage("handlebars",R.default),a.default.registerLanguage("haskell",I.default),a.default.registerLanguage("ini",w.default),a.default.registerLanguage("java",C.default),a.default.registerLanguage("javascript",L.default),a.default.registerLanguage("json",M.default),a.default.registerLanguage("kotlin",D.default),a.default.registerLanguage("less",x.default),a.default.registerLanguage("lisp",k.default),a.default.registerLanguage("lua",P.default),a.default.registerLanguage("makefile",U.default),a.default.registerLanguage("perl",B.default),a.default.registerLanguage("nginx",F.default),a.default.registerLanguage("objectivec",j.default),a.default.registerLanguage("pgsql",H.default),a.default.registerLanguage("php",G.default),a.default.registerLanguage("plaintext",$.default),a.default.registerLanguage("powershell",z.default),a.default.registerLanguage("properties",V.default),a.default.registerLanguage("protobuf",K.default),a.default.registerLanguage("python",W.default),a.default.registerLanguage("rust",q.default),a.default.registerLanguage("scala",X.default),a.default.registerLanguage("scss",Y.default),a.default.registerLanguage("shell",Z.default),a.default.registerLanguage("sql",Q.default),a.default.registerLanguage("swift",J.default),a.default.registerLanguage("yaml",ee.default),a.default.registerLanguage("typescript",ne.default),n.hljs=a.default},8593:(e,n)=>{"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.hashCode=n.unifyPath=n.escapeForRegExp=void 0;const t=RegExp("["+["-","[","]","/","{","}","(",")","*","+","?",".","\\","^","$","|"].join("\\")+"]","g");n.escapeForRegExp=function(e){return e.replace(t,"\\$&")},n.unifyPath=function(e){return e?e.replace(/\\/g,"/"):e},n.hashCode=function(e){let n,t,i,a=0;for(n=0,i=e.length;n<i;n++)t=e.charCodeAt(n),a=(a<<5)-a+t,a|=0;return a}},3390:e=>{function n(e){return e instanceof Map?e.clear=e.delete=e.set=function(){throw new Error("map is read-only")}:e instanceof Set&&(e.add=e.clear=e.delete=function(){throw new Error("set is read-only")}),Object.freeze(e),Object.getOwnPropertyNames(e).forEach((t=>{const i=e[t],a=typeof i;"object"!==a&&"function"!==a||Object.isFrozen(i)||n(i)})),e}class t{constructor(e){void 0===e.data&&(e.data={}),this.data=e.data,this.isMatchIgnored=!1}ignoreMatch(){this.isMatchIgnored=!0}}function i(e){return e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;")}function a(e,...n){const t=Object.create(null);for(const n in e)t[n]=e[n];return n.forEach((function(e){for(const n in e)t[n]=e[n]})),t}const r=e=>!!e.scope;class s{constructor(e,n){this.buffer="",this.classPrefix=n.classPrefix,e.walk(this)}addText(e){this.buffer+=i(e)}openNode(e){if(!r(e))return;const n=((e,{prefix:n})=>{if(e.startsWith("language:"))return e.replace("language:","language-");if(e.includes(".")){const t=e.split(".");return[`${n}${t.shift()}`,...t.map(((e,n)=>`${e}${"_".repeat(n+1)}`))].join(" ")}return`${n}${e}`})(e.scope,{prefix:this.classPrefix});this.span(n)}closeNode(e){r(e)&&(this.buffer+="</span>")}value(){return this.buffer}span(e){this.buffer+=`<span class="${e}">`}}const o=(e={})=>{const n={children:[]};return Object.assign(n,e),n};class l{constructor(){this.rootNode=o(),this.stack=[this.rootNode]}get top(){return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(e){this.top.children.push(e)}openNode(e){const n=o({scope:e});this.add(n),this.stack.push(n)}closeNode(){if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}walk(e){return this.constructor._walk(e,this.rootNode)}static _walk(e,n){return"string"==typeof n?e.addText(n):n.children&&(e.openNode(n),n.children.forEach((n=>this._walk(e,n))),e.closeNode(n)),e}static _collapse(e){"string"!=typeof e&&e.children&&(e.children.every((e=>"string"==typeof e))?e.children=[e.children.join("")]:e.children.forEach((e=>{l._collapse(e)})))}}class c extends l{constructor(e){super(),this.options=e}addText(e){""!==e&&this.add(e)}startScope(e){this.openNode(e)}endScope(){this.closeNode()}__addSublanguage(e,n){const t=e.root;n&&(t.scope=`language:${n}`),this.add(t)}toHTML(){return new s(this,this.options).value()}finalize(){return this.closeAllNodes(),!0}}function d(e){return e?"string"==typeof e?e:e.source:null}function u(e){return p("(?=",e,")")}function g(e){return p("(?:",e,")*")}function b(e){return p("(?:",e,")?")}function p(...e){return e.map((e=>d(e))).join("")}function f(...e){const n=function(e){const n=e[e.length-1];return"object"==typeof n&&n.constructor===Object?(e.splice(e.length-1,1),n):{}}(e);return"("+(n.capture?"":"?:")+e.map((e=>d(e))).join("|")+")"}function m(e){return new RegExp(e.toString()+"|").exec("").length-1}const E=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;function h(e,{joinWith:n}){let t=0;return e.map((e=>{t+=1;const n=t;let i=d(e),a="";for(;i.length>0;){const e=E.exec(i);if(!e){a+=i;break}a+=i.substring(0,e.index),i=i.substring(e.index+e[0].length),"\\"===e[0][0]&&e[1]?a+="\\"+String(Number(e[1])+n):(a+=e[0],"("===e[0]&&t++)}return a})).map((e=>`(${e})`)).join(n)}const _="[a-zA-Z]\\w*",N="[a-zA-Z_]\\w*",T="\\b\\d+(\\.\\d+)?",O="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",A="\\b(0b[01]+)",v={begin:"\\\\[\\s\\S]",relevance:0},y={scope:"string",begin:"'",end:"'",illegal:"\\n",contains:[v]},S={scope:"string",begin:'"',end:'"',illegal:"\\n",contains:[v]},R=function(e,n,t={}){const i=a({scope:"comment",begin:e,end:n,contains:[]},t);i.contains.push({scope:"doctag",begin:"[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",end:/(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,excludeBegin:!0,relevance:0});const r=f("I","a","is","so","us","to","at","if","in","it","on",/[A-Za-z]+['](d|ve|re|ll|t|s|n)/,/[A-Za-z]+[-][a-z]+/,/[A-Za-z][a-z]{2,}/);return i.contains.push({begin:p(/[ ]+/,"(",r,/[.]?[:]?([.][ ]|[ ])/,"){3}")}),i},I=R("//","$"),w=R("/\\*","\\*/"),C=R("#","$"),L={scope:"number",begin:T,relevance:0},M={scope:"number",begin:O,relevance:0},D={scope:"number",begin:A,relevance:0},x={begin:/(?=\/[^/\n]*\/)/,contains:[{scope:"regexp",begin:/\//,end:/\/[gimuy]*/,illegal:/\n/,contains:[v,{begin:/\[/,end:/\]/,relevance:0,contains:[v]}]}]},k={scope:"title",begin:_,relevance:0},P={scope:"title",begin:N,relevance:0},U={begin:"\\.\\s*"+N,relevance:0};var B=Object.freeze({__proto__:null,MATCH_NOTHING_RE:/\b\B/,IDENT_RE:_,UNDERSCORE_IDENT_RE:N,NUMBER_RE:T,C_NUMBER_RE:O,BINARY_NUMBER_RE:A,RE_STARTERS_RE:"!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",SHEBANG:(e={})=>{const n=/^#![ ]*\//;return e.binary&&(e.begin=p(n,/.*\b/,e.binary,/\b.*/)),a({scope:"meta",begin:n,end:/$/,relevance:0,"on:begin":(e,n)=>{0!==e.index&&n.ignoreMatch()}},e)},BACKSLASH_ESCAPE:v,APOS_STRING_MODE:y,QUOTE_STRING_MODE:S,PHRASAL_WORDS_MODE:{begin:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/},COMMENT:R,C_LINE_COMMENT_MODE:I,C_BLOCK_COMMENT_MODE:w,HASH_COMMENT_MODE:C,NUMBER_MODE:L,C_NUMBER_MODE:M,BINARY_NUMBER_MODE:D,REGEXP_MODE:x,TITLE_MODE:k,UNDERSCORE_TITLE_MODE:P,METHOD_GUARD:U,END_SAME_AS_BEGIN:function(e){return Object.assign(e,{"on:begin":(e,n)=>{n.data._beginMatch=e[1]},"on:end":(e,n)=>{n.data._beginMatch!==e[1]&&n.ignoreMatch()}})}});function F(e,n){"."===e.input[e.index-1]&&n.ignoreMatch()}function j(e,n){void 0!==e.className&&(e.scope=e.className,delete e.className)}function H(e,n){n&&e.beginKeywords&&(e.begin="\\b("+e.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",e.__beforeBegin=F,e.keywords=e.keywords||e.beginKeywords,delete e.beginKeywords,void 0===e.relevance&&(e.relevance=0))}function G(e,n){Array.isArray(e.illegal)&&(e.illegal=f(...e.illegal))}function $(e,n){if(e.match){if(e.begin||e.end)throw new Error("begin & end are not supported with match");e.begin=e.match,delete e.match}}function z(e,n){void 0===e.relevance&&(e.relevance=1)}const V=(e,n)=>{if(!e.beforeMatch)return;if(e.starts)throw new Error("beforeMatch cannot be used with starts");const t=Object.assign({},e);Object.keys(e).forEach((n=>{delete e[n]})),e.keywords=t.keywords,e.begin=p(t.beforeMatch,u(t.begin)),e.starts={relevance:0,contains:[Object.assign(t,{endsParent:!0})]},e.relevance=0,delete t.beforeMatch},K=["of","and","for","in","not","or","if","then","parent","list","value"],W="keyword";function q(e,n,t=W){const i=Object.create(null);return"string"==typeof e?a(t,e.split(" ")):Array.isArray(e)?a(t,e):Object.keys(e).forEach((function(t){Object.assign(i,q(e[t],n,t))})),i;function a(e,t){n&&(t=t.map((e=>e.toLowerCase()))),t.forEach((function(n){const t=n.split("|");i[t[0]]=[e,X(t[0],t[1])]}))}}function X(e,n){return n?Number(n):function(e){return K.includes(e.toLowerCase())}(e)?0:1}const Y={},Z=e=>{console.error(e)},Q=(e,...n)=>{console.log(`WARN: ${e}`,...n)},J=(e,n)=>{Y[`${e}/${n}`]||(console.log(`Deprecated as of ${e}. ${n}`),Y[`${e}/${n}`]=!0)},ee=new Error;function ne(e,n,{key:t}){let i=0;const a=e[t],r={},s={};for(let e=1;e<=n.length;e++)s[e+i]=a[e],r[e+i]=!0,i+=m(n[e-1]);e[t]=s,e[t]._emit=r,e[t]._multi=!0}function te(e){!function(e){e.scope&&"object"==typeof e.scope&&null!==e.scope&&(e.beginScope=e.scope,delete e.scope)}(e),"string"==typeof e.beginScope&&(e.beginScope={_wrap:e.beginScope}),"string"==typeof e.endScope&&(e.endScope={_wrap:e.endScope}),function(e){if(Array.isArray(e.begin)){if(e.skip||e.excludeBegin||e.returnBegin)throw Z("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),ee;if("object"!=typeof e.beginScope||null===e.beginScope)throw Z("beginScope must be object"),ee;ne(e,e.begin,{key:"beginScope"}),e.begin=h(e.begin,{joinWith:""})}}(e),function(e){if(Array.isArray(e.end)){if(e.skip||e.excludeEnd||e.returnEnd)throw Z("skip, excludeEnd, returnEnd not compatible with endScope: {}"),ee;if("object"!=typeof e.endScope||null===e.endScope)throw Z("endScope must be object"),ee;ne(e,e.end,{key:"endScope"}),e.end=h(e.end,{joinWith:""})}}(e)}function ie(e){function n(n,t){return new RegExp(d(n),"m"+(e.case_insensitive?"i":"")+(e.unicodeRegex?"u":"")+(t?"g":""))}class t{constructor(){this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}addRule(e,n){n.position=this.position++,this.matchIndexes[this.matchAt]=n,this.regexes.push([n,e]),this.matchAt+=m(e)+1}compile(){0===this.regexes.length&&(this.exec=()=>null);const e=this.regexes.map((e=>e[1]));this.matcherRe=n(h(e,{joinWith:"|"}),!0),this.lastIndex=0}exec(e){this.matcherRe.lastIndex=this.lastIndex;const n=this.matcherRe.exec(e);if(!n)return null;const t=n.findIndex(((e,n)=>n>0&&void 0!==e)),i=this.matchIndexes[t];return n.splice(0,t),Object.assign(n,i)}}class i{constructor(){this.rules=[],this.multiRegexes=[],this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(e){if(this.multiRegexes[e])return this.multiRegexes[e];const n=new t;return this.rules.slice(e).forEach((([e,t])=>n.addRule(e,t))),n.compile(),this.multiRegexes[e]=n,n}resumingScanAtSamePosition(){return 0!==this.regexIndex}considerAll(){this.regexIndex=0}addRule(e,n){this.rules.push([e,n]),"begin"===n.type&&this.count++}exec(e){const n=this.getMatcher(this.regexIndex);n.lastIndex=this.lastIndex;let t=n.exec(e);if(this.resumingScanAtSamePosition())if(t&&t.index===this.lastIndex);else{const n=this.getMatcher(0);n.lastIndex=this.lastIndex+1,t=n.exec(e)}return t&&(this.regexIndex+=t.position+1,this.regexIndex===this.count&&this.considerAll()),t}}if(e.compilerExtensions||(e.compilerExtensions=[]),e.contains&&e.contains.includes("self"))throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");return e.classNameAliases=a(e.classNameAliases||{}),function t(r,s){const o=r;if(r.isCompiled)return o;[j,$,te,V].forEach((e=>e(r,s))),e.compilerExtensions.forEach((e=>e(r,s))),r.__beforeBegin=null,[H,G,z].forEach((e=>e(r,s))),r.isCompiled=!0;let l=null;return"object"==typeof r.keywords&&r.keywords.$pattern&&(r.keywords=Object.assign({},r.keywords),l=r.keywords.$pattern,delete r.keywords.$pattern),l=l||/\w+/,r.keywords&&(r.keywords=q(r.keywords,e.case_insensitive)),o.keywordPatternRe=n(l,!0),s&&(r.begin||(r.begin=/\B|\b/),o.beginRe=n(o.begin),r.end||r.endsWithParent||(r.end=/\B|\b/),r.end&&(o.endRe=n(o.end)),o.terminatorEnd=d(o.end)||"",r.endsWithParent&&s.terminatorEnd&&(o.terminatorEnd+=(r.end?"|":"")+s.terminatorEnd)),r.illegal&&(o.illegalRe=n(r.illegal)),r.contains||(r.contains=[]),r.contains=[].concat(...r.contains.map((function(e){return function(e){return e.variants&&!e.cachedVariants&&(e.cachedVariants=e.variants.map((function(n){return a(e,{variants:null},n)}))),e.cachedVariants?e.cachedVariants:ae(e)?a(e,{starts:e.starts?a(e.starts):null}):Object.isFrozen(e)?a(e):e}("self"===e?r:e)}))),r.contains.forEach((function(e){t(e,o)})),r.starts&&t(r.starts,s),o.matcher=function(e){const n=new i;return e.contains.forEach((e=>n.addRule(e.begin,{rule:e,type:"begin"}))),e.terminatorEnd&&n.addRule(e.terminatorEnd,{type:"end"}),e.illegal&&n.addRule(e.illegal,{type:"illegal"}),n}(o),o}(e)}function ae(e){return!!e&&(e.endsWithParent||ae(e.starts))}class re extends Error{constructor(e,n){super(e),this.name="HTMLInjectionError",this.html=n}}const se=i,oe=a,le=Symbol("nomatch"),ce=function(e){const i=Object.create(null),a=Object.create(null),r=[];let s=!0;const o="Could not find the language '{}', did you forget to load/include a language module?",l={disableAutodetect:!0,name:"Plain text",contains:[]};let d={ignoreUnescapedHTML:!1,throwUnescapedHTML:!1,noHighlightRe:/^(no-?highlight)$/i,languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",cssSelector:"pre code",languages:null,__emitter:c};function m(e){return d.noHighlightRe.test(e)}function E(e,n,t){let i="",a="";"object"==typeof n?(i=e,t=n.ignoreIllegals,a=n.language):(J("10.7.0","highlight(lang, code, ...args) has been deprecated."),J("10.7.0","Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),a=e,i=n),void 0===t&&(t=!0);const r={code:i,language:a};S("before:highlight",r);const s=r.result?r.result:h(r.language,r.code,t);return s.code=r.code,S("after:highlight",s),s}function h(e,n,a,r){const l=Object.create(null);function c(){if(!S.keywords)return void I.addText(w);let e=0;S.keywordPatternRe.lastIndex=0;let n=S.keywordPatternRe.exec(w),t="";for(;n;){t+=w.substring(e,n.index);const a=O.case_insensitive?n[0].toLowerCase():n[0],r=(i=a,S.keywords[i]);if(r){const[e,i]=r;if(I.addText(t),t="",l[a]=(l[a]||0)+1,l[a]<=7&&(C+=i),e.startsWith("_"))t+=n[0];else{const t=O.classNameAliases[e]||e;g(n[0],t)}}else t+=n[0];e=S.keywordPatternRe.lastIndex,n=S.keywordPatternRe.exec(w)}var i;t+=w.substring(e),I.addText(t)}function u(){null!=S.subLanguage?function(){if(""===w)return;let e=null;if("string"==typeof S.subLanguage){if(!i[S.subLanguage])return void I.addText(w);e=h(S.subLanguage,w,!0,R[S.subLanguage]),R[S.subLanguage]=e._top}else e=_(w,S.subLanguage.length?S.subLanguage:null);S.relevance>0&&(C+=e.relevance),I.__addSublanguage(e._emitter,e.language)}():c(),w=""}function g(e,n){""!==e&&(I.startScope(n),I.addText(e),I.endScope())}function b(e,n){let t=1;const i=n.length-1;for(;t<=i;){if(!e._emit[t]){t++;continue}const i=O.classNameAliases[e[t]]||e[t],a=n[t];i?g(a,i):(w=a,c(),w=""),t++}}function p(e,n){return e.scope&&"string"==typeof e.scope&&I.openNode(O.classNameAliases[e.scope]||e.scope),e.beginScope&&(e.beginScope._wrap?(g(w,O.classNameAliases[e.beginScope._wrap]||e.beginScope._wrap),w=""):e.beginScope._multi&&(b(e.beginScope,n),w="")),S=Object.create(e,{parent:{value:S}}),S}function f(e,n,i){let a=function(e,n){const t=e&&e.exec(n);return t&&0===t.index}(e.endRe,i);if(a){if(e["on:end"]){const i=new t(e);e["on:end"](n,i),i.isMatchIgnored&&(a=!1)}if(a){for(;e.endsParent&&e.parent;)e=e.parent;return e}}if(e.endsWithParent)return f(e.parent,n,i)}function m(e){return 0===S.matcher.regexIndex?(w+=e[0],1):(D=!0,0)}function E(e){const t=e[0],i=n.substring(e.index),a=f(S,e,i);if(!a)return le;const r=S;S.endScope&&S.endScope._wrap?(u(),g(t,S.endScope._wrap)):S.endScope&&S.endScope._multi?(u(),b(S.endScope,e)):r.skip?w+=t:(r.returnEnd||r.excludeEnd||(w+=t),u(),r.excludeEnd&&(w=t));do{S.scope&&I.closeNode(),S.skip||S.subLanguage||(C+=S.relevance),S=S.parent}while(S!==a.parent);return a.starts&&p(a.starts,e),r.returnEnd?0:t.length}let N={};function T(i,r){const o=r&&r[0];if(w+=i,null==o)return u(),0;if("begin"===N.type&&"end"===r.type&&N.index===r.index&&""===o){if(w+=n.slice(r.index,r.index+1),!s){const n=new Error(`0 width match regex (${e})`);throw n.languageName=e,n.badRule=N.rule,n}return 1}if(N=r,"begin"===r.type)return function(e){const n=e[0],i=e.rule,a=new t(i),r=[i.__beforeBegin,i["on:begin"]];for(const t of r)if(t&&(t(e,a),a.isMatchIgnored))return m(n);return i.skip?w+=n:(i.excludeBegin&&(w+=n),u(),i.returnBegin||i.excludeBegin||(w=n)),p(i,e),i.returnBegin?0:n.length}(r);if("illegal"===r.type&&!a){const e=new Error('Illegal lexeme "'+o+'" for mode "'+(S.scope||"<unnamed>")+'"');throw e.mode=S,e}if("end"===r.type){const e=E(r);if(e!==le)return e}if("illegal"===r.type&&""===o)return 1;if(M>1e5&&M>3*r.index)throw new Error("potential infinite loop, way more iterations than matches");return w+=o,o.length}const O=A(e);if(!O)throw Z(o.replace("{}",e)),new Error('Unknown language: "'+e+'"');const v=ie(O);let y="",S=r||v;const R={},I=new d.__emitter(d);!function(){const e=[];for(let n=S;n!==O;n=n.parent)n.scope&&e.unshift(n.scope);e.forEach((e=>I.openNode(e)))}();let w="",C=0,L=0,M=0,D=!1;try{if(O.__emitTokens)O.__emitTokens(n,I);else{for(S.matcher.considerAll();;){M++,D?D=!1:S.matcher.considerAll(),S.matcher.lastIndex=L;const e=S.matcher.exec(n);if(!e)break;const t=T(n.substring(L,e.index),e);L=e.index+t}T(n.substring(L))}return I.finalize(),y=I.toHTML(),{language:e,value:y,relevance:C,illegal:!1,_emitter:I,_top:S}}catch(t){if(t.message&&t.message.includes("Illegal"))return{language:e,value:se(n),illegal:!0,relevance:0,_illegalBy:{message:t.message,index:L,context:n.slice(L-100,L+100),mode:t.mode,resultSoFar:y},_emitter:I};if(s)return{language:e,value:se(n),illegal:!1,relevance:0,errorRaised:t,_emitter:I,_top:S};throw t}}function _(e,n){n=n||d.languages||Object.keys(i);const t=function(e){const n={value:se(e),illegal:!1,relevance:0,_top:l,_emitter:new d.__emitter(d)};return n._emitter.addText(e),n}(e),a=n.filter(A).filter(y).map((n=>h(n,e,!1)));a.unshift(t);const r=a.sort(((e,n)=>{if(e.relevance!==n.relevance)return n.relevance-e.relevance;if(e.language&&n.language){if(A(e.language).supersetOf===n.language)return 1;if(A(n.language).supersetOf===e.language)return-1}return 0})),[s,o]=r,c=s;return c.secondBest=o,c}function N(e){let n=null;const t=function(e){let n=e.className+" ";n+=e.parentNode?e.parentNode.className:"";const t=d.languageDetectRe.exec(n);if(t){const n=A(t[1]);return n||(Q(o.replace("{}",t[1])),Q("Falling back to no-highlight mode for this block.",e)),n?t[1]:"no-highlight"}return n.split(/\s+/).find((e=>m(e)||A(e)))}(e);if(m(t))return;if(S("before:highlightElement",{el:e,language:t}),e.children.length>0&&(d.ignoreUnescapedHTML||(console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."),console.warn("https://github.com/highlightjs/highlight.js/wiki/security"),console.warn("The element with unescaped HTML:"),console.warn(e)),d.throwUnescapedHTML))throw new re("One of your code blocks includes unescaped HTML.",e.innerHTML);n=e;const i=n.textContent,r=t?E(i,{language:t,ignoreIllegals:!0}):_(i);e.innerHTML=r.value,function(e,n,t){const i=n&&a[n]||t;e.classList.add("hljs"),e.classList.add(`language-${i}`)}(e,t,r.language),e.result={language:r.language,re:r.relevance,relevance:r.relevance},r.secondBest&&(e.secondBest={language:r.secondBest.language,relevance:r.secondBest.relevance}),S("after:highlightElement",{el:e,result:r,text:i})}let T=!1;function O(){"loading"!==document.readyState?document.querySelectorAll(d.cssSelector).forEach(N):T=!0}function A(e){return e=(e||"").toLowerCase(),i[e]||i[a[e]]}function v(e,{languageName:n}){"string"==typeof e&&(e=[e]),e.forEach((e=>{a[e.toLowerCase()]=n}))}function y(e){const n=A(e);return n&&!n.disableAutodetect}function S(e,n){const t=e;r.forEach((function(e){e[t]&&e[t](n)}))}"undefined"!=typeof window&&window.addEventListener&&window.addEventListener("DOMContentLoaded",(function(){T&&O()}),!1),Object.assign(e,{highlight:E,highlightAuto:_,highlightAll:O,highlightElement:N,highlightBlock:function(e){return J("10.7.0","highlightBlock will be removed entirely in v12.0"),J("10.7.0","Please use highlightElement now."),N(e)},configure:function(e){d=oe(d,e)},initHighlighting:()=>{O(),J("10.6.0","initHighlighting() deprecated.  Use highlightAll() now.")},initHighlightingOnLoad:function(){O(),J("10.6.0","initHighlightingOnLoad() deprecated.  Use highlightAll() now.")},registerLanguage:function(n,t){let a=null;try{a=t(e)}catch(e){if(Z("Language definition for '{}' could not be registered.".replace("{}",n)),!s)throw e;Z(e),a=l}a.name||(a.name=n),i[n]=a,a.rawDefinition=t.bind(null,e),a.aliases&&v(a.aliases,{languageName:n})},unregisterLanguage:function(e){delete i[e];for(const n of Object.keys(a))a[n]===e&&delete a[n]},listLanguages:function(){return Object.keys(i)},getLanguage:A,registerAliases:v,autoDetection:y,inherit:oe,addPlugin:function(e){!function(e){e["before:highlightBlock"]&&!e["before:highlightElement"]&&(e["before:highlightElement"]=n=>{e["before:highlightBlock"](Object.assign({block:n.el},n))}),e["after:highlightBlock"]&&!e["after:highlightElement"]&&(e["after:highlightElement"]=n=>{e["after:highlightBlock"](Object.assign({block:n.el},n))})}(e),r.push(e)},removePlugin:function(e){const n=r.indexOf(e);-1!==n&&r.splice(n,1)}}),e.debugMode=function(){s=!1},e.safeMode=function(){s=!0},e.versionString="11.8.0",e.regex={concat:p,lookahead:u,either:f,optional:b,anyNumberOfTimes:g};for(const e in B)"object"==typeof B[e]&&n(B[e]);return Object.assign(e,B),e},de=ce({});de.newInstance=()=>ce({}),e.exports=de,de.HighlightJS=de,de.default=de},4868:e=>{e.exports=function(e){return{name:"Awk",keywords:{keyword:"BEGIN END if else while do for in break continue delete next nextfile function func exit|10"},contains:[{className:"variable",variants:[{begin:/\$[\w\d#@][\w\d_]*/},{begin:/\$\{(.*?)\}/}]},{className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{begin:/(u|b)?r?'''/,end:/'''/,relevance:10},{begin:/(u|b)?r?"""/,end:/"""/,relevance:10},{begin:/(u|r|ur)'/,end:/'/,relevance:10},{begin:/(u|r|ur)"/,end:/"/,relevance:10},{begin:/(b|br)'/,end:/'/},{begin:/(b|br)"/,end:/"/},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},e.REGEXP_MODE,e.HASH_COMMENT_MODE,e.NUMBER_MODE]}}},8780:e=>{e.exports=function(e){const n=e.regex,t={},i={begin:/\$\{/,end:/\}/,contains:["self",{begin:/:-/,contains:[t]}]};Object.assign(t,{className:"variable",variants:[{begin:n.concat(/\$[\w\d#@][\w\d_]*/,"(?![\\w\\d])(?![$])")},i]});const a={className:"subst",begin:/\$\(/,end:/\)/,contains:[e.BACKSLASH_ESCAPE]},r={begin:/<<-?\s*(?=\w+)/,starts:{contains:[e.END_SAME_AS_BEGIN({begin:/(\w+)/,end:/(\w+)/,className:"string"})]}},s={className:"string",begin:/"/,end:/"/,contains:[e.BACKSLASH_ESCAPE,t,a]};a.contains.push(s);const o={begin:/\$?\(\(/,end:/\)\)/,contains:[{begin:/\d+#[0-9a-f]+/,className:"number"},e.NUMBER_MODE,t]},l=e.SHEBANG({binary:`(${["fish","bash","zsh","sh","csh","ksh","tcsh","dash","scsh"].join("|")})`,relevance:10}),c={className:"function",begin:/\w[\w\d_]*\s*\(\s*\)\s*\{/,returnBegin:!0,contains:[e.inherit(e.TITLE_MODE,{begin:/\w[\w\d_]*/})],relevance:0};return{name:"Bash",aliases:["sh"],keywords:{$pattern:/\b[a-z][a-z0-9._-]+\b/,keyword:["if","then","else","elif","fi","for","while","until","in","do","done","case","esac","function","select"],literal:["true","false"],built_in:["break","cd","continue","eval","exec","exit","export","getopts","hash","pwd","readonly","return","shift","test","times","trap","umask","unset","alias","bind","builtin","caller","command","declare","echo","enable","help","let","local","logout","mapfile","printf","read","readarray","source","type","typeset","ulimit","unalias","set","shopt","autoload","bg","bindkey","bye","cap","chdir","clone","comparguments","compcall","compctl","compdescribe","compfiles","compgroups","compquote","comptags","comptry","compvalues","dirs","disable","disown","echotc","echoti","emulate","fc","fg","float","functions","getcap","getln","history","integer","jobs","kill","limit","log","noglob","popd","print","pushd","pushln","rehash","sched","setcap","setopt","stat","suspend","ttyctl","unfunction","unhash","unlimit","unsetopt","vared","wait","whence","where","which","zcompile","zformat","zftp","zle","zmodload","zparseopts","zprof","zpty","zregexparse","zsocket","zstyle","ztcp","chcon","chgrp","chown","chmod","cp","dd","df","dir","dircolors","ln","ls","mkdir","mkfifo","mknod","mktemp","mv","realpath","rm","rmdir","shred","sync","touch","truncate","vdir","b2sum","base32","base64","cat","cksum","comm","csplit","cut","expand","fmt","fold","head","join","md5sum","nl","numfmt","od","paste","ptx","pr","sha1sum","sha224sum","sha256sum","sha384sum","sha512sum","shuf","sort","split","sum","tac","tail","tr","tsort","unexpand","uniq","wc","arch","basename","chroot","date","dirname","du","echo","env","expr","factor","groups","hostid","id","link","logname","nice","nohup","nproc","pathchk","pinky","printenv","printf","pwd","readlink","runcon","seq","sleep","stat","stdbuf","stty","tee","test","timeout","tty","uname","unlink","uptime","users","who","whoami","yes"]},contains:[l,e.SHEBANG(),c,o,e.HASH_COMMENT_MODE,r,{match:/(\/[a-z._-]+)+/},s,{className:"",begin:/\\"/},{className:"string",begin:/'/,end:/'/},t]}}},612:e=>{e.exports=function(e){const n=e.regex,t=e.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),i="decltype\\(auto\\)",a="[a-zA-Z_]\\w*::",r="("+i+"|"+n.optional(a)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",s={className:"type",variants:[{begin:"\\b[a-z\\d_]*_t\\b"},{match:/\batomic_[a-z]{3,6}\b/}]},o={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{begin:"(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)",end:"'",illegal:"."},e.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},l={className:"number",variants:[{begin:"\\b(0b[01']+)"},{begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)"},{begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"}],relevance:0},c={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include"},contains:[{begin:/\\\n/,relevance:0},e.inherit(o,{className:"string"}),{className:"string",begin:/<.*?>/},t,e.C_BLOCK_COMMENT_MODE]},d={className:"title",begin:n.optional(a)+e.IDENT_RE,relevance:0},u=n.optional(a)+e.IDENT_RE+"\\s*\\(",g={keyword:["asm","auto","break","case","continue","default","do","else","enum","extern","for","fortran","goto","if","inline","register","restrict","return","sizeof","struct","switch","typedef","union","volatile","while","_Alignas","_Alignof","_Atomic","_Generic","_Noreturn","_Static_assert","_Thread_local","alignas","alignof","noreturn","static_assert","thread_local","_Pragma"],type:["float","double","signed","unsigned","int","short","long","char","void","_Bool","_Complex","_Imaginary","_Decimal32","_Decimal64","_Decimal128","const","static","complex","bool","imaginary"],literal:"true false NULL",built_in:"std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan vfprintf vprintf vsprintf endl initializer_list unique_ptr"},b=[c,s,t,e.C_BLOCK_COMMENT_MODE,l,o],p={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:g,contains:b.concat([{begin:/\(/,end:/\)/,keywords:g,contains:b.concat(["self"]),relevance:0}]),relevance:0},f={begin:"("+r+"[\\*&\\s]+)+"+u,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:g,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:i,keywords:g,relevance:0},{begin:u,returnBegin:!0,contains:[e.inherit(d,{className:"title.function"})],relevance:0},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:g,relevance:0,contains:[t,e.C_BLOCK_COMMENT_MODE,o,l,s,{begin:/\(/,end:/\)/,keywords:g,relevance:0,contains:["self",t,e.C_BLOCK_COMMENT_MODE,o,l,s]}]},s,t,e.C_BLOCK_COMMENT_MODE,c]};return{name:"C",aliases:["h"],keywords:g,disableAutodetect:!0,illegal:"</",contains:[].concat(p,f,b,[c,{begin:e.IDENT_RE+"::",keywords:g},{className:"class",beginKeywords:"enum class struct union",end:/[{;:<>=]/,contains:[{beginKeywords:"final class struct"},e.TITLE_MODE]}]),exports:{preprocessor:c,strings:o,keywords:g}}}},2177:e=>{e.exports=function(e){const n="a-zA-Z_\\-!.?+*=<>&'",t="[#]?["+n+"]["+n+"0-9/;:$#]*",i="def defonce defprotocol defstruct defmulti defmethod defn- defn defmacro deftype defrecord",a={$pattern:t,built_in:i+" cond apply if-not if-let if not not= =|0 <|0 >|0 <=|0 >=|0 ==|0 +|0 /|0 *|0 -|0 rem quot neg? pos? delay? symbol? keyword? true? false? integer? empty? coll? list? set? ifn? fn? associative? sequential? sorted? counted? reversible? number? decimal? class? distinct? isa? float? rational? reduced? ratio? odd? even? char? seq? vector? string? map? nil? contains? zero? instance? not-every? not-any? libspec? -> ->> .. . inc compare do dotimes mapcat take remove take-while drop letfn drop-last take-last drop-while while intern condp case reduced cycle split-at split-with repeat replicate iterate range merge zipmap declare line-seq sort comparator sort-by dorun doall nthnext nthrest partition eval doseq await await-for let agent atom send send-off release-pending-sends add-watch mapv filterv remove-watch agent-error restart-agent set-error-handler error-handler set-error-mode! error-mode shutdown-agents quote var fn loop recur throw try monitor-enter monitor-exit macroexpand macroexpand-1 for dosync and or when when-not when-let comp juxt partial sequence memoize constantly complement identity assert peek pop doto proxy first rest cons cast coll last butlast sigs reify second ffirst fnext nfirst nnext meta with-meta ns in-ns create-ns import refer keys select-keys vals key val rseq name namespace promise into transient persistent! conj! assoc! dissoc! pop! disj! use class type num float double short byte boolean bigint biginteger bigdec print-method print-dup throw-if printf format load compile get-in update-in pr pr-on newline flush read slurp read-line subvec with-open memfn time re-find re-groups rand-int rand mod locking assert-valid-fdecl alias resolve ref deref refset swap! reset! set-validator! compare-and-set! alter-meta! reset-meta! commute get-validator alter ref-set ref-history-count ref-min-history ref-max-history ensure sync io! new next conj set! to-array future future-call into-array aset gen-class reduce map filter find empty hash-map hash-set sorted-map sorted-map-by sorted-set sorted-set-by vec vector seq flatten reverse assoc dissoc list disj get union difference intersection extend extend-type extend-protocol int nth delay count concat chunk chunk-buffer chunk-append chunk-first chunk-rest max min dec unchecked-inc-int unchecked-inc unchecked-dec-inc unchecked-dec unchecked-negate unchecked-add-int unchecked-add unchecked-subtract-int unchecked-subtract chunk-next chunk-cons chunked-seq? prn vary-meta lazy-seq spread list* str find-keyword keyword symbol gensym force rationalize"},r={begin:t,relevance:0},s={scope:"number",relevance:0,variants:[{match:/[-+]?0[xX][0-9a-fA-F]+N?/},{match:/[-+]?0[0-7]+N?/},{match:/[-+]?[1-9][0-9]?[rR][0-9a-zA-Z]+N?/},{match:/[-+]?[0-9]+\/[0-9]+N?/},{match:/[-+]?[0-9]+((\.[0-9]*([eE][+-]?[0-9]+)?M?)|([eE][+-]?[0-9]+M?|M))/},{match:/[-+]?([1-9][0-9]*|0)N?/}]},o={scope:"character",variants:[{match:/\\o[0-3]?[0-7]{1,2}/},{match:/\\u[0-9a-fA-F]{4}/},{match:/\\(newline|space|tab|formfeed|backspace|return)/},{match:/\\\S/,relevance:0}]},l={scope:"regex",begin:/#"/,end:/"/,contains:[e.BACKSLASH_ESCAPE]},c=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),d={scope:"punctuation",match:/,/,relevance:0},u=e.COMMENT(";","$",{relevance:0}),g={className:"literal",begin:/\b(true|false|nil)\b/},b={begin:"\\[|(#::?"+t+")?\\{",end:"[\\]\\}]",relevance:0},p={className:"symbol",begin:"[:]{1,2}"+t},f={begin:"\\(",end:"\\)"},m={endsWithParent:!0,relevance:0},E={keywords:a,className:"name",begin:t,relevance:0,starts:m},h=[d,f,o,l,c,u,p,b,s,g,r],_={beginKeywords:i,keywords:{$pattern:t,keyword:i},end:'(\\[|#|\\d|"|:|\\{|\\)|\\(|$)',contains:[{className:"title",begin:t,relevance:0,excludeEnd:!0,endsParent:!0}].concat(h)};return f.contains=[_,E,m],m.contains=h,b.contains=h,{name:"Clojure",aliases:["clj","edn"],illegal:/\S/,contains:[d,f,o,l,c,u,p,b,s,g]}}},6248:e=>{e.exports=function(e){const n=e.regex,t=e.COMMENT("//","$",{contains:[{begin:/\\\n/}]}),i="decltype\\(auto\\)",a="[a-zA-Z_]\\w*::",r="(?!struct)("+i+"|"+n.optional(a)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",s={className:"type",begin:"\\b[a-z\\d_]*_t\\b"},o={className:"string",variants:[{begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{begin:"(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)",end:"'",illegal:"."},e.END_SAME_AS_BEGIN({begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},l={className:"number",variants:[{begin:"\\b(0b[01']+)"},{begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)"},{begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"}],relevance:0},c={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include"},contains:[{begin:/\\\n/,relevance:0},e.inherit(o,{className:"string"}),{className:"string",begin:/<.*?>/},t,e.C_BLOCK_COMMENT_MODE]},d={className:"title",begin:n.optional(a)+e.IDENT_RE,relevance:0},u=n.optional(a)+e.IDENT_RE+"\\s*\\(",g={type:["bool","char","char16_t","char32_t","char8_t","double","float","int","long","short","void","wchar_t","unsigned","signed","const","static"],keyword:["alignas","alignof","and","and_eq","asm","atomic_cancel","atomic_commit","atomic_noexcept","auto","bitand","bitor","break","case","catch","class","co_await","co_return","co_yield","compl","concept","const_cast|10","consteval","constexpr","constinit","continue","decltype","default","delete","do","dynamic_cast|10","else","enum","explicit","export","extern","false","final","for","friend","goto","if","import","inline","module","mutable","namespace","new","noexcept","not","not_eq","nullptr","operator","or","or_eq","override","private","protected","public","reflexpr","register","reinterpret_cast|10","requires","return","sizeof","static_assert","static_cast|10","struct","switch","synchronized","template","this","thread_local","throw","transaction_safe","transaction_safe_dynamic","true","try","typedef","typeid","typename","union","using","virtual","volatile","while","xor","xor_eq"],literal:["NULL","false","nullopt","nullptr","true"],built_in:["_Pragma"],_type_hints:["any","auto_ptr","barrier","binary_semaphore","bitset","complex","condition_variable","condition_variable_any","counting_semaphore","deque","false_type","future","imaginary","initializer_list","istringstream","jthread","latch","lock_guard","multimap","multiset","mutex","optional","ostringstream","packaged_task","pair","promise","priority_queue","queue","recursive_mutex","recursive_timed_mutex","scoped_lock","set","shared_future","shared_lock","shared_mutex","shared_timed_mutex","shared_ptr","stack","string_view","stringstream","timed_mutex","thread","true_type","tuple","unique_lock","unique_ptr","unordered_map","unordered_multimap","unordered_multiset","unordered_set","variant","vector","weak_ptr","wstring","wstring_view"]},b={className:"function.dispatch",relevance:0,keywords:{_hint:["abort","abs","acos","apply","as_const","asin","atan","atan2","calloc","ceil","cerr","cin","clog","cos","cosh","cout","declval","endl","exchange","exit","exp","fabs","floor","fmod","forward","fprintf","fputs","free","frexp","fscanf","future","invoke","isalnum","isalpha","iscntrl","isdigit","isgraph","islower","isprint","ispunct","isspace","isupper","isxdigit","labs","launder","ldexp","log","log10","make_pair","make_shared","make_shared_for_overwrite","make_tuple","make_unique","malloc","memchr","memcmp","memcpy","memset","modf","move","pow","printf","putchar","puts","realloc","scanf","sin","sinh","snprintf","sprintf","sqrt","sscanf","std","stderr","stdin","stdout","strcat","strchr","strcmp","strcpy","strcspn","strlen","strncat","strncmp","strncpy","strpbrk","strrchr","strspn","strstr","swap","tan","tanh","terminate","to_underlying","tolower","toupper","vfprintf","visit","vprintf","vsprintf"]},begin:n.concat(/\b/,/(?!decltype)/,/(?!if)/,/(?!for)/,/(?!switch)/,/(?!while)/,e.IDENT_RE,n.lookahead(/(<[^<>]+>|)\s*\(/))},p=[b,c,s,t,e.C_BLOCK_COMMENT_MODE,l,o],f={variants:[{begin:/=/,end:/;/},{begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],keywords:g,contains:p.concat([{begin:/\(/,end:/\)/,keywords:g,contains:p.concat(["self"]),relevance:0}]),relevance:0},m={className:"function",begin:"("+r+"[\\*&\\s]+)+"+u,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,keywords:g,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:i,keywords:g,relevance:0},{begin:u,returnBegin:!0,contains:[d],relevance:0},{begin:/::/,relevance:0},{begin:/:/,endsWithParent:!0,contains:[o,l]},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,keywords:g,relevance:0,contains:[t,e.C_BLOCK_COMMENT_MODE,o,l,s,{begin:/\(/,end:/\)/,keywords:g,relevance:0,contains:["self",t,e.C_BLOCK_COMMENT_MODE,o,l,s]}]},s,t,e.C_BLOCK_COMMENT_MODE,c]};return{name:"C++",aliases:["cc","c++","h++","hpp","hh","hxx","cxx"],keywords:g,illegal:"</",classNameAliases:{"function.dispatch":"built_in"},contains:[].concat(f,m,b,p,[c,{begin:"\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array|tuple|optional|variant|function)\\s*<(?!<)",end:">",keywords:g,contains:["self",s]},{begin:e.IDENT_RE+"::",keywords:g},{match:[/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,/\s+/,/\w+/],className:{1:"keyword",3:"title.class"}}])}}},3147:e=>{e.exports=function(e){const n="(_?[ui](8|16|32|64|128))?",t="[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|[=!]~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~|]|//|//=|&[-+*]=?|&\\*\\*|\\[\\][=?]?",i="[A-Za-z_]\\w*(::\\w+)*(\\?|!)?",a={$pattern:"[a-zA-Z_]\\w*[!?=]?",keyword:"abstract alias annotation as as? asm begin break case class def do else elsif end ensure enum extend for fun if include instance_sizeof is_a? lib macro module next nil? of out pointerof private protected rescue responds_to? return require select self sizeof struct super then type typeof union uninitialized unless until verbatim when while with yield __DIR__ __END_LINE__ __FILE__ __LINE__",literal:"false nil true"},r={className:"subst",begin:/#\{/,end:/\}/,keywords:a},s={className:"template-variable",variants:[{begin:"\\{\\{",end:"\\}\\}"},{begin:"\\{%",end:"%\\}"}],keywords:a};function o(e,n){const t=[{begin:e,end:n}];return t[0].contains=t,t}const l={className:"string",contains:[e.BACKSLASH_ESCAPE,r],variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/`/,end:/`/},{begin:"%[Qwi]?\\(",end:"\\)",contains:o("\\(","\\)")},{begin:"%[Qwi]?\\[",end:"\\]",contains:o("\\[","\\]")},{begin:"%[Qwi]?\\{",end:/\}/,contains:o(/\{/,/\}/)},{begin:"%[Qwi]?<",end:">",contains:o("<",">")},{begin:"%[Qwi]?\\|",end:"\\|"},{begin:/<<-\w+$/,end:/^\s*\w+$/}],relevance:0},c={className:"string",variants:[{begin:"%q\\(",end:"\\)",contains:o("\\(","\\)")},{begin:"%q\\[",end:"\\]",contains:o("\\[","\\]")},{begin:"%q\\{",end:/\}/,contains:o(/\{/,/\}/)},{begin:"%q<",end:">",contains:o("<",">")},{begin:"%q\\|",end:"\\|"},{begin:/<<-'\w+'$/,end:/^\s*\w+$/}],relevance:0},d={begin:"(?!%\\})("+e.RE_STARTERS_RE+"|\\n|\\b(case|if|select|unless|until|when|while)\\b)\\s*",keywords:"case if select unless until when while",contains:[{className:"regexp",contains:[e.BACKSLASH_ESCAPE,r],variants:[{begin:"//[a-z]*",relevance:0},{begin:"/(?!\\/)",end:"/[a-z]*"}]}],relevance:0},u=[s,l,c,{className:"regexp",contains:[e.BACKSLASH_ESCAPE,r],variants:[{begin:"%r\\(",end:"\\)",contains:o("\\(","\\)")},{begin:"%r\\[",end:"\\]",contains:o("\\[","\\]")},{begin:"%r\\{",end:/\}/,contains:o(/\{/,/\}/)},{begin:"%r<",end:">",contains:o("<",">")},{begin:"%r\\|",end:"\\|"}],relevance:0},d,{className:"meta",begin:"@\\[",end:"\\]",contains:[e.inherit(e.QUOTE_STRING_MODE,{className:"string"})]},{className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"},e.HASH_COMMENT_MODE,{className:"class",beginKeywords:"class module struct",end:"$|;",illegal:/=/,contains:[e.HASH_COMMENT_MODE,e.inherit(e.TITLE_MODE,{begin:i}),{begin:"<"}]},{className:"class",beginKeywords:"lib enum union",end:"$|;",illegal:/=/,contains:[e.HASH_COMMENT_MODE,e.inherit(e.TITLE_MODE,{begin:i})]},{beginKeywords:"annotation",end:"$|;",illegal:/=/,contains:[e.HASH_COMMENT_MODE,e.inherit(e.TITLE_MODE,{begin:i})],relevance:2},{className:"function",beginKeywords:"def",end:/\B\b/,contains:[e.inherit(e.TITLE_MODE,{begin:t,endsParent:!0})]},{className:"function",beginKeywords:"fun macro",end:/\B\b/,contains:[e.inherit(e.TITLE_MODE,{begin:t,endsParent:!0})],relevance:2},{className:"symbol",begin:e.UNDERSCORE_IDENT_RE+"(!|\\?)?:",relevance:0},{className:"symbol",begin:":",contains:[l,{begin:t}],relevance:0},{className:"number",variants:[{begin:"\\b0b([01_]+)"+n},{begin:"\\b0o([0-7_]+)"+n},{begin:"\\b0x([A-Fa-f0-9_]+)"+n},{begin:"\\b([1-9][0-9_]*[0-9]|[0-9])(\\.[0-9][0-9_]*)?([eE]_?[-+]?[0-9_]*)?(_?f(32|64))?(?!_)"},{begin:"\\b([1-9][0-9_]*|0)"+n}],relevance:0}];return r.contains=u,s.contains=u.slice(1),{name:"Crystal",aliases:["cr"],keywords:a,contains:u}}},3707:e=>{e.exports=function(e){const n={keyword:["abstract","as","base","break","case","catch","class","const","continue","do","else","event","explicit","extern","finally","fixed","for","foreach","goto","if","implicit","in","interface","internal","is","lock","namespace","new","operator","out","override","params","private","protected","public","readonly","record","ref","return","scoped","sealed","sizeof","stackalloc","static","struct","switch","this","throw","try","typeof","unchecked","unsafe","using","virtual","void","volatile","while"].concat(["add","alias","and","ascending","async","await","by","descending","equals","from","get","global","group","init","into","join","let","nameof","not","notnull","on","or","orderby","partial","remove","select","set","unmanaged","value|0","var","when","where","with","yield"]),built_in:["bool","byte","char","decimal","delegate","double","dynamic","enum","float","int","long","nint","nuint","object","sbyte","short","string","ulong","uint","ushort"],literal:["default","false","null","true"]},t=e.inherit(e.TITLE_MODE,{begin:"[a-zA-Z](\\.?\\w)*"}),i={className:"number",variants:[{begin:"\\b(0b[01']+)"},{begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)"},{begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"}],relevance:0},a={className:"string",begin:'@"',end:'"',contains:[{begin:'""'}]},r=e.inherit(a,{illegal:/\n/}),s={className:"subst",begin:/\{/,end:/\}/,keywords:n},o=e.inherit(s,{illegal:/\n/}),l={className:"string",begin:/\$"/,end:'"',illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},e.BACKSLASH_ESCAPE,o]},c={className:"string",begin:/\$@"/,end:'"',contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},s]},d=e.inherit(c,{illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},o]});s.contains=[c,l,a,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,i,e.C_BLOCK_COMMENT_MODE],o.contains=[d,l,r,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,i,e.inherit(e.C_BLOCK_COMMENT_MODE,{illegal:/\n/})];const u={variants:[c,l,a,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},g={begin:"<",end:">",contains:[{beginKeywords:"in out"},t]},b=e.IDENT_RE+"(<"+e.IDENT_RE+"(\\s*,\\s*"+e.IDENT_RE+")*>)?(\\[\\])?",p={begin:"@"+e.IDENT_RE,relevance:0};return{name:"C#",aliases:["cs","c#"],keywords:n,illegal:/::/,contains:[e.COMMENT("///","$",{returnBegin:!0,contains:[{className:"doctag",variants:[{begin:"///",relevance:0},{begin:"\x3c!--|--\x3e"},{begin:"</?",end:">"}]}]}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"meta",begin:"#",end:"$",keywords:{keyword:"if else elif endif define undef warning error line region endregion pragma checksum"}},u,i,{beginKeywords:"class interface",relevance:0,end:/[{;=]/,illegal:/[^\s:,]/,contains:[{beginKeywords:"where class"},t,g,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"namespace",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[t,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"record",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[t,g,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"meta",begin:"^\\s*\\[(?=[\\w])",excludeBegin:!0,end:"\\]",excludeEnd:!0,contains:[{className:"string",begin:/"/,end:/"/}]},{beginKeywords:"new return throw await else",relevance:0},{className:"function",begin:"("+b+"\\s+)+"+e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,end:/\s*[{;=]/,excludeEnd:!0,keywords:n,contains:[{beginKeywords:["public","private","protected","static","internal","protected","abstract","async","extern","override","unsafe","virtual","new","sealed","partial"].join(" "),relevance:0},{begin:e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,contains:[e.TITLE_MODE,g],relevance:0},{match:/\(\)/},{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:n,relevance:0,contains:[u,i,e.C_BLOCK_COMMENT_MODE]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},p]}}},9534:e=>{e.exports=function(e){return{name:"CSP",case_insensitive:!1,keywords:{$pattern:"[a-zA-Z][a-zA-Z0-9_-]*",keyword:["base-uri","child-src","connect-src","default-src","font-src","form-action","frame-ancestors","frame-src","img-src","manifest-src","media-src","object-src","plugin-types","report-uri","sandbox","script-src","style-src","trusted-types","unsafe-hashes","worker-src"]},contains:[{className:"string",begin:"'",end:"'"},{className:"attribute",begin:"^Content",end:":",excludeEnd:!0}]}}},5064:e=>{const n=["a","abbr","address","article","aside","audio","b","blockquote","body","button","canvas","caption","cite","code","dd","del","details","dfn","div","dl","dt","em","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","html","i","iframe","img","input","ins","kbd","label","legend","li","main","mark","menu","nav","object","ol","p","q","quote","samp","section","span","strong","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","tr","ul","var","video"],t=["any-hover","any-pointer","aspect-ratio","color","color-gamut","color-index","device-aspect-ratio","device-height","device-width","display-mode","forced-colors","grid","height","hover","inverted-colors","monochrome","orientation","overflow-block","overflow-inline","pointer","prefers-color-scheme","prefers-contrast","prefers-reduced-motion","prefers-reduced-transparency","resolution","scan","scripting","update","width","min-width","max-width","min-height","max-height"],i=["active","any-link","blank","checked","current","default","defined","dir","disabled","drop","empty","enabled","first","first-child","first-of-type","fullscreen","future","focus","focus-visible","focus-within","has","host","host-context","hover","indeterminate","in-range","invalid","is","lang","last-child","last-of-type","left","link","local-link","not","nth-child","nth-col","nth-last-child","nth-last-col","nth-last-of-type","nth-of-type","only-child","only-of-type","optional","out-of-range","past","placeholder-shown","read-only","read-write","required","right","root","scope","target","target-within","user-invalid","valid","visited","where"],a=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"],r=["align-content","align-items","align-self","all","animation","animation-delay","animation-direction","animation-duration","animation-fill-mode","animation-iteration-count","animation-name","animation-play-state","animation-timing-function","backface-visibility","background","background-attachment","background-blend-mode","background-clip","background-color","background-image","background-origin","background-position","background-repeat","background-size","block-size","border","border-block","border-block-color","border-block-end","border-block-end-color","border-block-end-style","border-block-end-width","border-block-start","border-block-start-color","border-block-start-style","border-block-start-width","border-block-style","border-block-width","border-bottom","border-bottom-color","border-bottom-left-radius","border-bottom-right-radius","border-bottom-style","border-bottom-width","border-collapse","border-color","border-image","border-image-outset","border-image-repeat","border-image-slice","border-image-source","border-image-width","border-inline","border-inline-color","border-inline-end","border-inline-end-color","border-inline-end-style","border-inline-end-width","border-inline-start","border-inline-start-color","border-inline-start-style","border-inline-start-width","border-inline-style","border-inline-width","border-left","border-left-color","border-left-style","border-left-width","border-radius","border-right","border-right-color","border-right-style","border-right-width","border-spacing","border-style","border-top","border-top-color","border-top-left-radius","border-top-right-radius","border-top-style","border-top-width","border-width","bottom","box-decoration-break","box-shadow","box-sizing","break-after","break-before","break-inside","caption-side","caret-color","clear","clip","clip-path","clip-rule","color","column-count","column-fill","column-gap","column-rule","column-rule-color","column-rule-style","column-rule-width","column-span","column-width","columns","contain","content","content-visibility","counter-increment","counter-reset","cue","cue-after","cue-before","cursor","direction","display","empty-cells","filter","flex","flex-basis","flex-direction","flex-flow","flex-grow","flex-shrink","flex-wrap","float","flow","font","font-display","font-family","font-feature-settings","font-kerning","font-language-override","font-size","font-size-adjust","font-smoothing","font-stretch","font-style","font-synthesis","font-variant","font-variant-caps","font-variant-east-asian","font-variant-ligatures","font-variant-numeric","font-variant-position","font-variation-settings","font-weight","gap","glyph-orientation-vertical","grid","grid-area","grid-auto-columns","grid-auto-flow","grid-auto-rows","grid-column","grid-column-end","grid-column-start","grid-gap","grid-row","grid-row-end","grid-row-start","grid-template","grid-template-areas","grid-template-columns","grid-template-rows","hanging-punctuation","height","hyphens","icon","image-orientation","image-rendering","image-resolution","ime-mode","inline-size","isolation","justify-content","left","letter-spacing","line-break","line-height","list-style","list-style-image","list-style-position","list-style-type","margin","margin-block","margin-block-end","margin-block-start","margin-bottom","margin-inline","margin-inline-end","margin-inline-start","margin-left","margin-right","margin-top","marks","mask","mask-border","mask-border-mode","mask-border-outset","mask-border-repeat","mask-border-slice","mask-border-source","mask-border-width","mask-clip","mask-composite","mask-image","mask-mode","mask-origin","mask-position","mask-repeat","mask-size","mask-type","max-block-size","max-height","max-inline-size","max-width","min-block-size","min-height","min-inline-size","min-width","mix-blend-mode","nav-down","nav-index","nav-left","nav-right","nav-up","none","normal","object-fit","object-position","opacity","order","orphans","outline","outline-color","outline-offset","outline-style","outline-width","overflow","overflow-wrap","overflow-x","overflow-y","padding","padding-block","padding-block-end","padding-block-start","padding-bottom","padding-inline","padding-inline-end","padding-inline-start","padding-left","padding-right","padding-top","page-break-after","page-break-before","page-break-inside","pause","pause-after","pause-before","perspective","perspective-origin","pointer-events","position","quotes","resize","rest","rest-after","rest-before","right","row-gap","scroll-margin","scroll-margin-block","scroll-margin-block-end","scroll-margin-block-start","scroll-margin-bottom","scroll-margin-inline","scroll-margin-inline-end","scroll-margin-inline-start","scroll-margin-left","scroll-margin-right","scroll-margin-top","scroll-padding","scroll-padding-block","scroll-padding-block-end","scroll-padding-block-start","scroll-padding-bottom","scroll-padding-inline","scroll-padding-inline-end","scroll-padding-inline-start","scroll-padding-left","scroll-padding-right","scroll-padding-top","scroll-snap-align","scroll-snap-stop","scroll-snap-type","scrollbar-color","scrollbar-gutter","scrollbar-width","shape-image-threshold","shape-margin","shape-outside","speak","speak-as","src","tab-size","table-layout","text-align","text-align-all","text-align-last","text-combine-upright","text-decoration","text-decoration-color","text-decoration-line","text-decoration-style","text-emphasis","text-emphasis-color","text-emphasis-position","text-emphasis-style","text-indent","text-justify","text-orientation","text-overflow","text-rendering","text-shadow","text-transform","text-underline-position","top","transform","transform-box","transform-origin","transform-style","transition","transition-delay","transition-duration","transition-property","transition-timing-function","unicode-bidi","vertical-align","visibility","voice-balance","voice-duration","voice-family","voice-pitch","voice-range","voice-rate","voice-stress","voice-volume","white-space","widows","width","will-change","word-break","word-spacing","word-wrap","writing-mode","z-index"].reverse();e.exports=function(e){const s=e.regex,o=(e=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:e.C_BLOCK_COMMENT_MODE,HEXCOLOR:{scope:"number",begin:/#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/},FUNCTION_DISPATCH:{className:"built_in",begin:/[\w-]+(?=\()/},ATTRIBUTE_SELECTOR_MODE:{scope:"selector-attr",begin:/\[/,end:/\]/,illegal:"$",contains:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:e.NUMBER_RE+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",relevance:0},CSS_VARIABLE:{className:"attr",begin:/--[A-Za-z][A-Za-z0-9_-]*/}}))(e),l=[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE];return{name:"CSS",case_insensitive:!0,illegal:/[=|'\$]/,keywords:{keyframePosition:"from to"},classNameAliases:{keyframePosition:"selector-tag"},contains:[o.BLOCK_COMMENT,{begin:/-(webkit|moz|ms|o)-(?=[a-z])/},o.CSS_NUMBER_MODE,{className:"selector-id",begin:/#[A-Za-z0-9_-]+/,relevance:0},{className:"selector-class",begin:"\\.[a-zA-Z-][a-zA-Z0-9_-]*",relevance:0},o.ATTRIBUTE_SELECTOR_MODE,{className:"selector-pseudo",variants:[{begin:":("+i.join("|")+")"},{begin:":(:)?("+a.join("|")+")"}]},o.CSS_VARIABLE,{className:"attribute",begin:"\\b("+r.join("|")+")\\b"},{begin:/:/,end:/[;}{]/,contains:[o.BLOCK_COMMENT,o.HEXCOLOR,o.IMPORTANT,o.CSS_NUMBER_MODE,...l,{begin:/(url|data-uri)\(/,end:/\)/,relevance:0,keywords:{built_in:"url data-uri"},contains:[...l,{className:"string",begin:/[^)]/,endsWithParent:!0,excludeEnd:!0}]},o.FUNCTION_DISPATCH]},{begin:s.lookahead(/@/),end:"[{;]",relevance:0,illegal:/:/,contains:[{className:"keyword",begin:/@-?\w[\w]*(-\w+)*/},{begin:/\s/,endsWithParent:!0,excludeEnd:!0,relevance:0,keywords:{$pattern:/[a-z-]+/,keyword:"and or not only",attribute:t.join(" ")},contains:[{begin:/[a-z-]+(?=:)/,className:"attribute"},...l,o.CSS_NUMBER_MODE]}]},{className:"selector-tag",begin:"\\b("+n.join("|")+")\\b"}]}}},6642:e=>{e.exports=function(e){const n={className:"subst",variants:[{begin:"\\$[A-Za-z0-9_]+"}]},t={className:"subst",variants:[{begin:/\$\{/,end:/\}/}],keywords:"true false null this is new super"},i={className:"string",variants:[{begin:"r'''",end:"'''"},{begin:'r"""',end:'"""'},{begin:"r'",end:"'",illegal:"\\n"},{begin:'r"',end:'"',illegal:"\\n"},{begin:"'''",end:"'''",contains:[e.BACKSLASH_ESCAPE,n,t]},{begin:'"""',end:'"""',contains:[e.BACKSLASH_ESCAPE,n,t]},{begin:"'",end:"'",illegal:"\\n",contains:[e.BACKSLASH_ESCAPE,n,t]},{begin:'"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE,n,t]}]};t.contains=[e.C_NUMBER_MODE,i];const a=["Comparable","DateTime","Duration","Function","Iterable","Iterator","List","Map","Match","Object","Pattern","RegExp","Set","Stopwatch","String","StringBuffer","StringSink","Symbol","Type","Uri","bool","double","int","num","Element","ElementList"],r=a.map((e=>`${e}?`));return{name:"Dart",keywords:{keyword:["abstract","as","assert","async","await","base","break","case","catch","class","const","continue","covariant","default","deferred","do","dynamic","else","enum","export","extends","extension","external","factory","false","final","finally","for","Function","get","hide","if","implements","import","in","interface","is","late","library","mixin","new","null","on","operator","part","required","rethrow","return","sealed","set","show","static","super","switch","sync","this","throw","true","try","typedef","var","void","when","while","with","yield"],built_in:a.concat(r).concat(["Never","Null","dynamic","print","document","querySelector","querySelectorAll","window"]),$pattern:/[A-Za-z][A-Za-z0-9_]*\??/},contains:[i,e.COMMENT(/\/\*\*(?!\/)/,/\*\//,{subLanguage:"markdown",relevance:0}),e.COMMENT(/\/{3,} ?/,/$/,{contains:[{subLanguage:"markdown",begin:".",end:"$",relevance:0}]}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"class",beginKeywords:"class interface",end:/\{/,excludeEnd:!0,contains:[{beginKeywords:"extends implements"},e.UNDERSCORE_TITLE_MODE]},e.C_NUMBER_MODE,{className:"meta",begin:"@[A-Za-z]+"},{begin:"=>"}]}}},7731:e=>{e.exports=function(e){const n=e.regex;return{name:"Diff",aliases:["patch"],contains:[{className:"meta",relevance:10,match:n.either(/^@@ +-\d+,\d+ +\+\d+,\d+ +@@/,/^\*\*\* +\d+,\d+ +\*\*\*\*$/,/^--- +\d+,\d+ +----$/)},{className:"comment",variants:[{begin:n.either(/Index: /,/^index/,/={3,}/,/^-{3}/,/^\*{3} /,/^\+{3}/,/^diff --git/),end:/$/},{match:/^\*{15}$/}]},{className:"addition",begin:/^\+/,end:/$/},{className:"deletion",begin:/^-/,end:/$/},{className:"addition",begin:/^!/,end:/$/}]}}},7360:e=>{e.exports=function(e){return{name:"Dockerfile",aliases:["docker"],case_insensitive:!0,keywords:["from","maintainer","expose","env","arg","user","onbuild","stopsignal"],contains:[e.HASH_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.NUMBER_MODE,{beginKeywords:"run cmd entrypoint volume add copy workdir label healthcheck shell",starts:{end:/[^\\]$/,subLanguage:"bash"}}],illegal:"</"}}},2543:e=>{e.exports=function(e){const n=e.regex,t="[a-zA-Z_][a-zA-Z0-9_.]*(!|\\?)?",i={$pattern:t,keyword:["after","alias","and","case","catch","cond","defstruct","defguard","do","else","end","fn","for","if","import","in","not","or","quote","raise","receive","require","reraise","rescue","try","unless","unquote","unquote_splicing","use","when","with|0"],literal:["false","nil","true"]},a={className:"subst",begin:/#\{/,end:/\}/,keywords:i},r={match:/\\[\s\S]/,scope:"char.escape",relevance:0},s="[/|([{<\"']",o=[{begin:/"/,end:/"/},{begin:/'/,end:/'/},{begin:/\//,end:/\//},{begin:/\|/,end:/\|/},{begin:/\(/,end:/\)/},{begin:/\[/,end:/\]/},{begin:/\{/,end:/\}/},{begin:/</,end:/>/}],l=e=>({scope:"char.escape",begin:n.concat(/\\/,e),relevance:0}),c={className:"string",begin:"~[a-z](?="+s+")",contains:o.map((n=>e.inherit(n,{contains:[l(n.end),r,a]})))},d={className:"string",begin:"~[A-Z](?="+s+")",contains:o.map((n=>e.inherit(n,{contains:[l(n.end)]})))},u={className:"regex",variants:[{begin:"~r(?="+s+")",contains:o.map((t=>e.inherit(t,{end:n.concat(t.end,/[uismxfU]{0,7}/),contains:[l(t.end),r,a]})))},{begin:"~R(?="+s+")",contains:o.map((t=>e.inherit(t,{end:n.concat(t.end,/[uismxfU]{0,7}/),contains:[l(t.end)]})))}]},g={className:"string",contains:[e.BACKSLASH_ESCAPE,a],variants:[{begin:/"""/,end:/"""/},{begin:/'''/,end:/'''/},{begin:/~S"""/,end:/"""/,contains:[]},{begin:/~S"/,end:/"/,contains:[]},{begin:/~S'''/,end:/'''/,contains:[]},{begin:/~S'/,end:/'/,contains:[]},{begin:/'/,end:/'/},{begin:/"/,end:/"/}]},b={className:"function",beginKeywords:"def defp defmacro defmacrop",end:/\B\b/,contains:[e.inherit(e.TITLE_MODE,{begin:t,endsParent:!0})]},p=e.inherit(b,{className:"class",beginKeywords:"defimpl defmodule defprotocol defrecord",end:/\bdo\b|$|;/}),f=[g,u,d,c,e.HASH_COMMENT_MODE,p,b,{begin:"::"},{className:"symbol",begin:":(?![\\s:])",contains:[g,{begin:"[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?"}],relevance:0},{className:"symbol",begin:t+":(?!:)",relevance:0},{className:"title.class",begin:/(\b[A-Z][a-zA-Z0-9_]+)/,relevance:0},{className:"number",begin:"(\\b0o[0-7_]+)|(\\b0b[01_]+)|(\\b0x[0-9a-fA-F_]+)|(-?\\b[0-9][0-9_]*(\\.[0-9_]+([eE][-+]?[0-9]+)?)?)",relevance:0},{className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))"}];return a.contains=f,{name:"Elixir",aliases:["ex","exs"],keywords:i,contains:f}}},5658:e=>{e.exports=function(e){const n={variants:[e.COMMENT("--","$"),e.COMMENT(/\{-/,/-\}/,{contains:["self"]})]},t={className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},i={begin:"\\(",end:"\\)",illegal:'"',contains:[{className:"type",begin:"\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"},n]};return{name:"Elm",keywords:["let","in","if","then","else","case","of","where","module","import","exposing","type","alias","as","infix","infixl","infixr","port","effect","command","subscription"],contains:[{beginKeywords:"port effect module",end:"exposing",keywords:"port effect module where command subscription exposing",contains:[i,n],illegal:"\\W\\.|;"},{begin:"import",end:"$",keywords:"import as exposing",contains:[i,n],illegal:"\\W\\.|;"},{begin:"type",end:"$",keywords:"type alias",contains:[t,i,{begin:/\{/,end:/\}/,contains:i.contains},n]},{beginKeywords:"infix infixl infixr",end:"$",contains:[e.C_NUMBER_MODE,n]},{begin:"port",end:"$",keywords:"port",contains:[n]},{className:"string",begin:"'\\\\?.",end:"'",illegal:"."},e.QUOTE_STRING_MODE,e.C_NUMBER_MODE,t,e.inherit(e.TITLE_MODE,{begin:"^[_a-z][\\w']*"}),n,{begin:"->|<-"}],illegal:/;/}}},7569:e=>{e.exports=function(e){const n="[a-z'][a-zA-Z0-9_']*",t="("+n+":"+n+"|"+n+")",i={keyword:"after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun if let not of orelse|10 query receive rem try when xor",literal:"false true"},a=e.COMMENT("%","$"),r={className:"number",begin:"\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",relevance:0},s={begin:"fun\\s+"+n+"/\\d+"},o={begin:t+"\\(",end:"\\)",returnBegin:!0,relevance:0,contains:[{begin:t,relevance:0},{begin:"\\(",end:"\\)",endsWithParent:!0,returnEnd:!0,relevance:0}]},l={begin:/\{/,end:/\}/,relevance:0},c={begin:"\\b_([A-Z][A-Za-z0-9_]*)?",relevance:0},d={begin:"[A-Z][a-zA-Z0-9_]*",relevance:0},u={begin:"#"+e.UNDERSCORE_IDENT_RE,relevance:0,returnBegin:!0,contains:[{begin:"#"+e.UNDERSCORE_IDENT_RE,relevance:0},{begin:/\{/,end:/\}/,relevance:0}]},g={beginKeywords:"fun receive if try case",end:"end",keywords:i};g.contains=[a,s,e.inherit(e.APOS_STRING_MODE,{className:""}),g,o,e.QUOTE_STRING_MODE,r,l,c,d,u];const b=[a,s,g,o,e.QUOTE_STRING_MODE,r,l,c,d,u];o.contains[1].contains=b,l.contains=b,u.contains[1].contains=b;const p={className:"params",begin:"\\(",end:"\\)",contains:b};return{name:"Erlang",aliases:["erl"],keywords:i,illegal:"(</|\\*=|\\+=|-=|/\\*|\\*/|\\(\\*|\\*\\))",contains:[{className:"function",begin:"^"+n+"\\s*\\(",end:"->",returnBegin:!0,illegal:"\\(|#|//|/\\*|\\\\|:|;",contains:[p,e.inherit(e.TITLE_MODE,{begin:n})],starts:{end:";|\\.",keywords:i,contains:b}},a,{begin:"^-",end:"\\.",relevance:0,excludeEnd:!0,returnBegin:!0,keywords:{$pattern:"-"+e.IDENT_RE,keyword:["-module","-record","-undef","-export","-ifdef","-ifndef","-author","-copyright","-doc","-vsn","-import","-include","-include_lib","-compile","-define","-else","-endif","-file","-behaviour","-behavior","-spec"].map((e=>`${e}|1.5`)).join(" ")},contains:[p]},r,e.QUOTE_STRING_MODE,u,c,d,l,{begin:/\.$/}]}}},6652:e=>{function n(e){return new RegExp(e.replace(/[-/\\^$*+?.()|[\]{}]/g,"\\$&"),"m")}function t(e){return e?"string"==typeof e?e:e.source:null}function i(e){return a("(?=",e,")")}function a(...e){return e.map((e=>t(e))).join("")}function r(...e){const n=function(e){const n=e[e.length-1];return"object"==typeof n&&n.constructor===Object?(e.splice(e.length-1,1),n):{}}(e);return"("+(n.capture?"":"?:")+e.map((e=>t(e))).join("|")+")"}e.exports=function(e){const t={scope:"keyword",match:/\b(yield|return|let|do|match|use)!/},s=["bool","byte","sbyte","int8","int16","int32","uint8","uint16","uint32","int","uint","int64","uint64","nativeint","unativeint","decimal","float","double","float32","single","char","string","unit","bigint","option","voption","list","array","seq","byref","exn","inref","nativeptr","obj","outref","voidptr","Result"],o={keyword:["abstract","and","as","assert","base","begin","class","default","delegate","do","done","downcast","downto","elif","else","end","exception","extern","finally","fixed","for","fun","function","global","if","in","inherit","inline","interface","internal","lazy","let","match","member","module","mutable","namespace","new","of","open","or","override","private","public","rec","return","static","struct","then","to","try","type","upcast","use","val","void","when","while","with","yield"],literal:["true","false","null","Some","None","Ok","Error","infinity","infinityf","nan","nanf"],built_in:["not","ref","raise","reraise","dict","readOnlyDict","set","get","enum","sizeof","typeof","typedefof","nameof","nullArg","invalidArg","invalidOp","id","fst","snd","ignore","lock","using","box","unbox","tryUnbox","printf","printfn","sprintf","eprintf","eprintfn","fprintf","fprintfn","failwith","failwithf"],"variable.constant":["__LINE__","__SOURCE_DIRECTORY__","__SOURCE_FILE__"]},l={variants:[e.COMMENT(/\(\*(?!\))/,/\*\)/,{contains:["self"]}),e.C_LINE_COMMENT_MODE]},c={scope:"variable",begin:/``/,end:/``/},d=/\B('|\^)/,u={scope:"symbol",variants:[{match:a(d,/``.*?``/)},{match:a(d,e.UNDERSCORE_IDENT_RE)}],relevance:0},g=function({includeEqual:e}){let t;t=e?"!%&*+-/<=>@^|~?":"!%&*+-/<>@^|~?";const s=a("[",...Array.from(t).map(n),"]"),o=r(s,/\./),l=a(o,i(o)),c=r(a(l,o,"*"),a(s,"+"));return{scope:"operator",match:r(c,/:\?>/,/:\?/,/:>/,/:=/,/::?/,/\$/),relevance:0}},b=g({includeEqual:!0}),p=g({includeEqual:!1}),f=function(n,t){return{begin:a(n,i(a(/\s*/,r(/\w/,/'/,/\^/,/#/,/``/,/\(/,/{\|/)))),beginScope:t,end:i(r(/\n/,/=/)),relevance:0,keywords:e.inherit(o,{type:s}),contains:[l,u,e.inherit(c,{scope:null}),p]}},m=f(/:/,"operator"),E=f(/\bof\b/,"keyword"),h={begin:[/(^|\s+)/,/type/,/\s+/,/[a-zA-Z_](\w|')*/],beginScope:{2:"keyword",4:"title.class"},end:i(/\(|=|$/),keywords:o,contains:[l,e.inherit(c,{scope:null}),u,{scope:"operator",match:/<|>/},m]},_={scope:"computation-expression",match:/\b[_a-z]\w*(?=\s*\{)/},N={begin:[/^\s*/,a(/#/,r("if","else","endif","line","nowarn","light","r","i","I","load","time","help","quit")),/\b/],beginScope:{2:"meta"},end:i(/\s|$/)},T={variants:[e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE]},O={scope:"string",begin:/"/,end:/"/,contains:[e.BACKSLASH_ESCAPE]},A={scope:"string",begin:/@"/,end:/"/,contains:[{match:/""/},e.BACKSLASH_ESCAPE]},v={scope:"string",begin:/"""/,end:/"""/,relevance:2},y={scope:"subst",begin:/\{/,end:/\}/,keywords:o},S={scope:"string",begin:/\$"/,end:/"/,contains:[{match:/\{\{/},{match:/\}\}/},e.BACKSLASH_ESCAPE,y]},R={scope:"string",begin:/(\$@|@\$)"/,end:/"/,contains:[{match:/\{\{/},{match:/\}\}/},{match:/""/},e.BACKSLASH_ESCAPE,y]},I={scope:"string",begin:/\$"""/,end:/"""/,contains:[{match:/\{\{/},{match:/\}\}/},y],relevance:2},w={scope:"string",match:a(/'/,r(/[^\\']/,/\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8})/),/'/)};return y.contains=[R,S,A,O,w,t,l,c,m,_,N,T,u,b],{name:"F#",aliases:["fs","f#"],keywords:o,illegal:/\/\*/,classNameAliases:{"computation-expression":"keyword"},contains:[t,{variants:[I,R,S,v,A,O,w]},l,c,h,{scope:"meta",begin:/\[</,end:/>\]/,relevance:2,contains:[c,v,A,O,w,T]},E,m,_,N,T,u,b]}}},2399:e=>{e.exports=function(e){const n={keyword:["break","case","chan","const","continue","default","defer","else","fallthrough","for","func","go","goto","if","import","interface","map","package","range","return","select","struct","switch","type","var"],type:["bool","byte","complex64","complex128","error","float32","float64","int8","int16","int32","int64","string","uint8","uint16","uint32","uint64","int","uint","uintptr","rune"],literal:["true","false","iota","nil"],built_in:["append","cap","close","complex","copy","imag","len","make","new","panic","print","println","real","recover","delete"]};return{name:"Go",aliases:["golang"],keywords:n,illegal:"</",contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"string",variants:[e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,{begin:"`",end:"`"}]},{className:"number",variants:[{begin:e.C_NUMBER_RE+"[i]",relevance:1},e.C_NUMBER_MODE]},{begin:/:=/},{className:"function",beginKeywords:"func",end:"\\s*(\\{|$)",excludeEnd:!0,contains:[e.TITLE_MODE,{className:"params",begin:/\(/,end:/\)/,endsParent:!0,keywords:n,illegal:/["']/}]}]}}},9878:e=>{e.exports=function(e){return{name:"Gradle",case_insensitive:!0,keywords:["task","project","allprojects","subprojects","artifacts","buildscript","configurations","dependencies","repositories","sourceSets","description","delete","from","into","include","exclude","source","classpath","destinationDir","includes","options","sourceCompatibility","targetCompatibility","group","flatDir","doLast","doFirst","flatten","todir","fromdir","ant","def","abstract","break","case","catch","continue","default","do","else","extends","final","finally","for","if","implements","instanceof","native","new","private","protected","public","return","static","switch","synchronized","throw","throws","transient","try","volatile","while","strictfp","package","import","false","null","super","this","true","antlrtask","checkstyle","codenarc","copy","boolean","byte","char","class","double","float","int","interface","long","short","void","compile","runTime","file","fileTree","abs","any","append","asList","asWritable","call","collect","compareTo","count","div","dump","each","eachByte","eachFile","eachLine","every","find","findAll","flatten","getAt","getErr","getIn","getOut","getText","grep","immutable","inject","inspect","intersect","invokeMethods","isCase","join","leftShift","minus","multiply","newInputStream","newOutputStream","newPrintWriter","newReader","newWriter","next","plus","pop","power","previous","print","println","push","putAt","read","readBytes","readLines","reverse","reverseEach","round","size","sort","splitEachLine","step","subMap","times","toInteger","toList","tokenize","upto","waitForOrKill","withPrintWriter","withReader","withStream","withWriter","withWriterAppend","write","writeLine"],contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,e.NUMBER_MODE,e.REGEXP_MODE]}}},4658:e=>{function n(e,n={}){return n.variants=e,n}e.exports=function(e){const t=e.regex,i="[A-Za-z0-9_$]+",a=n([e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{begin:/\w+@/,relevance:0},{className:"doctag",begin:"@[A-Za-z]+"}]})]),r={className:"regexp",begin:/~?\/[^\/\n]+\//,contains:[e.BACKSLASH_ESCAPE]},s=n([e.BINARY_NUMBER_MODE,e.C_NUMBER_MODE]),o=n([{begin:/"""/,end:/"""/},{begin:/'''/,end:/'''/},{begin:"\\$/",end:"/\\$",relevance:10},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE],{className:"string"}),l={match:[/(class|interface|trait|enum|extends|implements)/,/\s+/,e.UNDERSCORE_IDENT_RE],scope:{1:"keyword",3:"title.class"}};return{name:"Groovy",keywords:{"variable.language":"this super",literal:"true false null",type:["byte","short","char","int","long","boolean","float","double","void"],keyword:["def","as","in","assert","trait","abstract","static","volatile","transient","public","private","protected","synchronized","final","class","interface","enum","if","else","for","while","switch","case","break","default","continue","throw","throws","try","catch","finally","implements","extends","new","import","package","return","instanceof"]},contains:[e.SHEBANG({binary:"groovy",relevance:10}),a,o,r,s,l,{className:"meta",begin:"@[A-Za-z]+",relevance:0},{className:"attr",begin:i+"[ \t]*:",relevance:0},{begin:/\?/,end:/:/,relevance:0,contains:[a,o,r,s,"self"]},{className:"symbol",begin:"^[ \t]*"+t.lookahead(i+":"),excludeBegin:!0,end:i+":",relevance:0}],illegal:/#|<\//}}},1407:e=>{e.exports=function(e){const n=e.regex,t={$pattern:/[\w.\/]+/,built_in:["action","bindattr","collection","component","concat","debugger","each","each-in","get","hash","if","in","input","link-to","loc","log","lookup","mut","outlet","partial","query-params","render","template","textarea","unbound","unless","view","with","yield"]},i=/\[\]|\[[^\]]+\]/,a=/[^\s!"#%&'()*+,.\/;<=>@\[\\\]^`{|}~]+/,r=n.either(/""|"[^"]+"/,/''|'[^']+'/,i,a),s=n.concat(n.optional(/\.|\.\/|\//),r,n.anyNumberOfTimes(n.concat(/(\.|\/)/,r))),o=n.concat("(",i,"|",a,")(?==)"),l={begin:s},c=e.inherit(l,{keywords:{$pattern:/[\w.\/]+/,literal:["true","false","undefined","null"]}}),d={begin:/\(/,end:/\)/},u={className:"attr",begin:o,relevance:0,starts:{begin:/=/,end:/=/,starts:{contains:[e.NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,c,d]}}},g={contains:[e.NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,{begin:/as\s+\|/,keywords:{keyword:"as"},end:/\|/,contains:[{begin:/\w+/}]},u,c,d],returnEnd:!0},b=e.inherit(l,{className:"name",keywords:t,starts:e.inherit(g,{end:/\)/})});d.contains=[b];const p=e.inherit(l,{keywords:t,className:"name",starts:e.inherit(g,{end:/\}\}/})}),f=e.inherit(l,{keywords:t,className:"name"}),m=e.inherit(l,{className:"name",keywords:t,starts:e.inherit(g,{end:/\}\}/})});return{name:"Handlebars",aliases:["hbs","html.hbs","html.handlebars","htmlbars"],case_insensitive:!0,subLanguage:"xml",contains:[{begin:/\\\{\{/,skip:!0},{begin:/\\\\(?=\{\{)/,skip:!0},e.COMMENT(/\{\{!--/,/--\}\}/),e.COMMENT(/\{\{!/,/\}\}/),{className:"template-tag",begin:/\{\{\{\{(?!\/)/,end:/\}\}\}\}/,contains:[p],starts:{end:/\{\{\{\{\//,returnEnd:!0,subLanguage:"xml"}},{className:"template-tag",begin:/\{\{\{\{\//,end:/\}\}\}\}/,contains:[f]},{className:"template-tag",begin:/\{\{#/,end:/\}\}/,contains:[p]},{className:"template-tag",begin:/\{\{(?=else\}\})/,end:/\}\}/,keywords:"else"},{className:"template-tag",begin:/\{\{(?=else if)/,end:/\}\}/,keywords:"else if"},{className:"template-tag",begin:/\{\{\//,end:/\}\}/,contains:[f]},{className:"template-variable",begin:/\{\{\{/,end:/\}\}\}/,contains:[m]},{className:"template-variable",begin:/\{\{/,end:/\}\}/,contains:[m]}]}}},7077:e=>{e.exports=function(e){const n={variants:[e.COMMENT("--","$"),e.COMMENT(/\{-/,/-\}/,{contains:["self"]})]},t={className:"meta",begin:/\{-#/,end:/#-\}/},i={className:"meta",begin:"^#",end:"$"},a={className:"type",begin:"\\b[A-Z][\\w']*",relevance:0},r={begin:"\\(",end:"\\)",illegal:'"',contains:[t,i,{className:"type",begin:"\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"},e.inherit(e.TITLE_MODE,{begin:"[_a-z][\\w']*"}),n]},s="([0-9]_*)+",o="([0-9a-fA-F]_*)+",l={className:"number",relevance:0,variants:[{match:`\\b(${s})(\\.(${s}))?([eE][+-]?(${s}))?\\b`},{match:`\\b0[xX]_*(${o})(\\.(${o}))?([pP][+-]?(${s}))?\\b`},{match:"\\b0[oO](([0-7]_*)+)\\b"},{match:"\\b0[bB](([01]_*)+)\\b"}]};return{name:"Haskell",aliases:["hs"],keywords:"let in if then else case of where do module import hiding qualified type data newtype deriving class instance as default infix infixl infixr foreign export ccall stdcall cplusplus jvm dotnet safe unsafe family forall mdo proc rec",contains:[{beginKeywords:"module",end:"where",keywords:"module where",contains:[r,n],illegal:"\\W\\.|;"},{begin:"\\bimport\\b",end:"$",keywords:"import qualified as hiding",contains:[r,n],illegal:"\\W\\.|;"},{className:"class",begin:"^(\\s*)?(class|instance)\\b",end:"where",keywords:"class family instance where",contains:[a,r,n]},{className:"class",begin:"\\b(data|(new)?type)\\b",end:"$",keywords:"data family type newtype deriving",contains:[t,a,r,{begin:/\{/,end:/\}/,contains:r.contains},n]},{beginKeywords:"default",end:"$",contains:[a,r,n]},{beginKeywords:"infix infixl infixr",end:"$",contains:[e.C_NUMBER_MODE,n]},{begin:"\\bforeign\\b",end:"$",keywords:"foreign import export ccall stdcall cplusplus jvm dotnet safe unsafe",contains:[a,e.QUOTE_STRING_MODE,n]},{className:"meta",begin:"#!\\/usr\\/bin\\/env runhaskell",end:"$"},t,i,{scope:"string",begin:/'(?=\\?.')/,end:/'/,contains:[{scope:"char.escape",match:/\\./}]},e.QUOTE_STRING_MODE,l,a,e.inherit(e.TITLE_MODE,{begin:"^[_a-z][\\w']*"}),n,{begin:"->|<-"}]}}},4762:e=>{e.exports=function(e){const n=e.regex,t={className:"number",relevance:0,variants:[{begin:/([+-]+)?[\d]+_[\d_]+/},{begin:e.NUMBER_RE}]},i=e.COMMENT();i.variants=[{begin:/;/,end:/$/},{begin:/#/,end:/$/}];const a={className:"variable",variants:[{begin:/\$[\w\d"][\w\d_]*/},{begin:/\$\{(.*?)\}/}]},r={className:"literal",begin:/\bon|off|true|false|yes|no\b/},s={className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{begin:"'''",end:"'''",relevance:10},{begin:'"""',end:'"""',relevance:10},{begin:'"',end:'"'},{begin:"'",end:"'"}]},o={begin:/\[/,end:/\]/,contains:[i,r,a,s,t,"self"],relevance:0},l=n.either(/[A-Za-z0-9_-]+/,/"(\\"|[^"])*"/,/'[^']*'/);return{name:"TOML, also INI",aliases:["toml"],case_insensitive:!0,illegal:/\S/,contains:[i,{className:"section",begin:/\[+/,end:/\]+/},{begin:n.concat(l,"(\\s*\\.\\s*",l,")*",n.lookahead(/\s*=\s*[^#\s]/)),className:"attr",starts:{end:/$/,contains:[i,o,r,a,s,t]}}]}}},8257:e=>{var n="[0-9](_*[0-9])*",t=`\\.(${n})`,i="[0-9a-fA-F](_*[0-9a-fA-F])*",a={className:"number",variants:[{begin:`(\\b(${n})((${t})|\\.)?|(${t}))[eE][+-]?(${n})[fFdD]?\\b`},{begin:`\\b(${n})((${t})[fFdD]?\\b|\\.([fFdD]\\b)?)`},{begin:`(${t})[fFdD]?\\b`},{begin:`\\b(${n})[fFdD]\\b`},{begin:`\\b0[xX]((${i})\\.?|(${i})?\\.(${i}))[pP][+-]?(${n})[fFdD]?\\b`},{begin:"\\b(0|[1-9](_*[0-9])*)[lL]?\\b"},{begin:`\\b0[xX](${i})[lL]?\\b`},{begin:"\\b0(_*[0-7])*[lL]?\\b"},{begin:"\\b0[bB][01](_*[01])*[lL]?\\b"}],relevance:0};function r(e,n,t){return-1===t?"":e.replace(n,(i=>r(e,n,t-1)))}e.exports=function(e){const n=e.regex,t="[À-ʸa-zA-Z_$][À-ʸa-zA-Z_$0-9]*",i=t+r("(?:<"+t+"~~~(?:\\s*,\\s*"+t+"~~~)*>)?",/~~~/g,2),s={keyword:["synchronized","abstract","private","var","static","if","const ","for","while","strictfp","finally","protected","import","native","final","void","enum","else","break","transient","catch","instanceof","volatile","case","assert","package","default","public","try","switch","continue","throws","protected","public","private","module","requires","exports","do","sealed","yield","permits"],literal:["false","true","null"],type:["char","boolean","long","float","int","byte","short","double"],built_in:["super","this"]},o={className:"meta",begin:"@"+t,contains:[{begin:/\(/,end:/\)/,contains:["self"]}]},l={className:"params",begin:/\(/,end:/\)/,keywords:s,relevance:0,contains:[e.C_BLOCK_COMMENT_MODE],endsParent:!0};return{name:"Java",aliases:["jsp"],keywords:s,illegal:/<\/|#/,contains:[e.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{begin:/\w+@/,relevance:0},{className:"doctag",begin:"@[A-Za-z]+"}]}),{begin:/import java\.[a-z]+\./,keywords:"import",relevance:2},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{begin:/"""/,end:/"""/,className:"string",contains:[e.BACKSLASH_ESCAPE]},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{match:[/\b(?:class|interface|enum|extends|implements|new)/,/\s+/,t],className:{1:"keyword",3:"title.class"}},{match:/non-sealed/,scope:"keyword"},{begin:[n.concat(/(?!else)/,t),/\s+/,t,/\s+/,/=(?!=)/],className:{1:"type",3:"variable",5:"operator"}},{begin:[/record/,/\s+/,t],className:{1:"keyword",3:"title.class"},contains:[l,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"new throw return else",relevance:0},{begin:["(?:"+i+"\\s+)",e.UNDERSCORE_IDENT_RE,/\s*(?=\()/],className:{2:"title.function"},keywords:s,contains:[{className:"params",begin:/\(/,end:/\)/,keywords:s,relevance:0,contains:[o,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,a,e.C_BLOCK_COMMENT_MODE]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},a,o]}}},978:e=>{const n="[A-Za-z$_][0-9A-Za-z$_]*",t=["as","in","of","if","for","while","finally","var","new","function","do","return","void","else","break","catch","instanceof","with","throw","case","default","try","switch","continue","typeof","delete","let","yield","const","class","debugger","async","await","static","import","from","export","extends"],i=["true","false","null","undefined","NaN","Infinity"],a=["Object","Function","Boolean","Symbol","Math","Date","Number","BigInt","String","RegExp","Array","Float32Array","Float64Array","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Int32Array","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array","Set","Map","WeakSet","WeakMap","ArrayBuffer","SharedArrayBuffer","Atomics","DataView","JSON","Promise","Generator","GeneratorFunction","AsyncFunction","Reflect","Proxy","Intl","WebAssembly"],r=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],s=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],o=["arguments","this","super","console","window","document","localStorage","sessionStorage","module","global"],l=[].concat(s,a,r);e.exports=function(e){const c=e.regex,d=n,u={begin:/<[A-Za-z0-9\\._:-]+/,end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(e,n)=>{const t=e[0].length+e.index,i=e.input[t];if("<"===i||","===i)return void n.ignoreMatch();let a;">"===i&&(((e,{after:n})=>{const t="</"+e[0].slice(1);return-1!==e.input.indexOf(t,n)})(e,{after:t})||n.ignoreMatch());const r=e.input.substring(t);((a=r.match(/^\s*=/))||(a=r.match(/^\s+extends\s+/))&&0===a.index)&&n.ignoreMatch()}},g={$pattern:n,keyword:t,literal:i,built_in:l,"variable.language":o},b="[0-9](_?[0-9])*",p=`\\.(${b})`,f="0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",m={className:"number",variants:[{begin:`(\\b(${f})((${p})|\\.)?|(${p}))[eE][+-]?(${b})\\b`},{begin:`\\b(${f})\\b((${p})\\b|\\.)?|(${p})\\b`},{begin:"\\b(0|[1-9](_?[0-9])*)n\\b"},{begin:"\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b"},{begin:"\\b0[bB][0-1](_?[0-1])*n?\\b"},{begin:"\\b0[oO][0-7](_?[0-7])*n?\\b"},{begin:"\\b0[0-7]+n?\\b"}],relevance:0},E={className:"subst",begin:"\\$\\{",end:"\\}",keywords:g,contains:[]},h={begin:"html`",end:"",starts:{end:"`",returnEnd:!1,contains:[e.BACKSLASH_ESCAPE,E],subLanguage:"xml"}},_={begin:"css`",end:"",starts:{end:"`",returnEnd:!1,contains:[e.BACKSLASH_ESCAPE,E],subLanguage:"css"}},N={begin:"gql`",end:"",starts:{end:"`",returnEnd:!1,contains:[e.BACKSLASH_ESCAPE,E],subLanguage:"graphql"}},T={className:"string",begin:"`",end:"`",contains:[e.BACKSLASH_ESCAPE,E]},O={className:"comment",variants:[e.COMMENT(/\/\*\*(?!\/)/,"\\*/",{relevance:0,contains:[{begin:"(?=@[A-Za-z]+)",relevance:0,contains:[{className:"doctag",begin:"@[A-Za-z]+"},{className:"type",begin:"\\{",end:"\\}",excludeEnd:!0,excludeBegin:!0,relevance:0},{className:"variable",begin:d+"(?=\\s*(-)|$)",endsParent:!0,relevance:0},{begin:/(?=[^\n])\s/,relevance:0}]}]}),e.C_BLOCK_COMMENT_MODE,e.C_LINE_COMMENT_MODE]},A=[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,h,_,N,T,{match:/\$\d+/},m];E.contains=A.concat({begin:/\{/,end:/\}/,keywords:g,contains:["self"].concat(A)});const v=[].concat(O,E.contains),y=v.concat([{begin:/\(/,end:/\)/,keywords:g,contains:["self"].concat(v)}]),S={className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:g,contains:y},R={variants:[{match:[/class/,/\s+/,d,/\s+/,/extends/,/\s+/,c.concat(d,"(",c.concat(/\./,d),")*")],scope:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},{match:[/class/,/\s+/,d],scope:{1:"keyword",3:"title.class"}}]},I={relevance:0,match:c.either(/\bJSON/,/\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,/\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,/\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/),className:"title.class",keywords:{_:[...a,...r]}},w={variants:[{match:[/function/,/\s+/,d,/(?=\s*\()/]},{match:[/function/,/\s*(?=\()/]}],className:{1:"keyword",3:"title.function"},label:"func.def",contains:[S],illegal:/%/},C={match:c.concat(/\b/,(L=[...s,"super","import"],c.concat("(?!",L.join("|"),")")),d,c.lookahead(/\(/)),className:"title.function",relevance:0};var L;const M={begin:c.concat(/\./,c.lookahead(c.concat(d,/(?![0-9A-Za-z$_(])/))),end:d,excludeBegin:!0,keywords:"prototype",className:"property",relevance:0},D={match:[/get|set/,/\s+/,d,/(?=\()/],className:{1:"keyword",3:"title.function"},contains:[{begin:/\(\)/},S]},x="(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|"+e.UNDERSCORE_IDENT_RE+")\\s*=>",k={match:[/const|var|let/,/\s+/,d,/\s*/,/=\s*/,/(async\s*)?/,c.lookahead(x)],keywords:"async",className:{1:"keyword",3:"title.function"},contains:[S]};return{name:"JavaScript",aliases:["js","jsx","mjs","cjs"],keywords:g,exports:{PARAMS_CONTAINS:y,CLASS_REFERENCE:I},illegal:/#(?![$_A-z])/,contains:[e.SHEBANG({label:"shebang",binary:"node",relevance:5}),{label:"use_strict",className:"meta",relevance:10,begin:/^\s*['"]use (strict|asm)['"]/},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,h,_,N,T,O,{match:/\$\d+/},m,I,{className:"attr",begin:d+c.lookahead(":"),relevance:0},k,{begin:"("+e.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",relevance:0,contains:[O,e.REGEXP_MODE,{className:"function",begin:x,returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:e.UNDERSCORE_IDENT_RE,relevance:0},{className:null,begin:/\(\s*\)/,skip:!0},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:g,contains:y}]}]},{begin:/,/,relevance:0},{match:/\s+/,relevance:0},{variants:[{begin:"<>",end:"</>"},{match:/<[A-Za-z0-9\\._:-]+\s*\/>/},{begin:u.begin,"on:begin":u.isTrulyOpeningTag,end:u.end}],subLanguage:"xml",contains:[{begin:u.begin,end:u.end,skip:!0,contains:["self"]}]}]},w,{beginKeywords:"while if switch catch for"},{begin:"\\b(?!function)"+e.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",returnBegin:!0,label:"func.def",contains:[S,e.inherit(e.TITLE_MODE,{begin:d,className:"title.function"})]},{match:/\.\.\./,relevance:0},M,{match:"\\$"+d,relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"},contains:[S]},C,{relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"},R,D,{match:/\$[(.]/}]}}},14:e=>{e.exports=function(e){const n=["true","false","null"],t={scope:"literal",beginKeywords:n.join(" ")};return{name:"JSON",keywords:{literal:n},contains:[{className:"attr",begin:/"(\\.|[^\\"\r\n])*"(?=\s*:)/,relevance:1.01},{match:/[{}[\],:]/,className:"punctuation",relevance:0},e.QUOTE_STRING_MODE,t,e.C_NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE],illegal:"\\S"}}},5812:e=>{var n="[0-9](_*[0-9])*",t=`\\.(${n})`,i="[0-9a-fA-F](_*[0-9a-fA-F])*",a={className:"number",variants:[{begin:`(\\b(${n})((${t})|\\.)?|(${t}))[eE][+-]?(${n})[fFdD]?\\b`},{begin:`\\b(${n})((${t})[fFdD]?\\b|\\.([fFdD]\\b)?)`},{begin:`(${t})[fFdD]?\\b`},{begin:`\\b(${n})[fFdD]\\b`},{begin:`\\b0[xX]((${i})\\.?|(${i})?\\.(${i}))[pP][+-]?(${n})[fFdD]?\\b`},{begin:"\\b(0|[1-9](_*[0-9])*)[lL]?\\b"},{begin:`\\b0[xX](${i})[lL]?\\b`},{begin:"\\b0(_*[0-7])*[lL]?\\b"},{begin:"\\b0[bB][01](_*[01])*[lL]?\\b"}],relevance:0};e.exports=function(e){const n={keyword:"abstract as val var vararg get set class object open private protected public noinline crossinline dynamic final enum if else do while for when throw try catch finally import package is in fun override companion reified inline lateinit init interface annotation data sealed internal infix operator out by constructor super tailrec where const inner suspend typealias external expect actual",built_in:"Byte Short Char Int Long Boolean Float Double Void Unit Nothing",literal:"true false null"},t={className:"symbol",begin:e.UNDERSCORE_IDENT_RE+"@"},i={className:"subst",begin:/\$\{/,end:/\}/,contains:[e.C_NUMBER_MODE]},r={className:"variable",begin:"\\$"+e.UNDERSCORE_IDENT_RE},s={className:"string",variants:[{begin:'"""',end:'"""(?=[^"])',contains:[r,i]},{begin:"'",end:"'",illegal:/\n/,contains:[e.BACKSLASH_ESCAPE]},{begin:'"',end:'"',illegal:/\n/,contains:[e.BACKSLASH_ESCAPE,r,i]}]};i.contains.push(s);const o={className:"meta",begin:"@(?:file|property|field|get|set|receiver|param|setparam|delegate)\\s*:(?:\\s*"+e.UNDERSCORE_IDENT_RE+")?"},l={className:"meta",begin:"@"+e.UNDERSCORE_IDENT_RE,contains:[{begin:/\(/,end:/\)/,contains:[e.inherit(s,{className:"string"}),"self"]}]},c=a,d=e.COMMENT("/\\*","\\*/",{contains:[e.C_BLOCK_COMMENT_MODE]}),u={variants:[{className:"type",begin:e.UNDERSCORE_IDENT_RE},{begin:/\(/,end:/\)/,contains:[]}]},g=u;return g.variants[1].contains=[u],u.variants[1].contains=[g],{name:"Kotlin",aliases:["kt","kts"],keywords:n,contains:[e.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{className:"doctag",begin:"@[A-Za-z]+"}]}),e.C_LINE_COMMENT_MODE,d,{className:"keyword",begin:/\b(break|continue|return|this)\b/,starts:{contains:[{className:"symbol",begin:/@\w+/}]}},t,o,l,{className:"function",beginKeywords:"fun",end:"[(]|$",returnBegin:!0,excludeEnd:!0,keywords:n,relevance:5,contains:[{begin:e.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,relevance:0,contains:[e.UNDERSCORE_TITLE_MODE]},{className:"type",begin:/</,end:/>/,keywords:"reified",relevance:0},{className:"params",begin:/\(/,end:/\)/,endsParent:!0,keywords:n,relevance:0,contains:[{begin:/:/,end:/[=,\/]/,endsWithParent:!0,contains:[u,e.C_LINE_COMMENT_MODE,d],relevance:0},e.C_LINE_COMMENT_MODE,d,o,l,s,e.C_NUMBER_MODE]},d]},{begin:[/class|interface|trait/,/\s+/,e.UNDERSCORE_IDENT_RE],beginScope:{3:"title.class"},keywords:"class interface trait",end:/[:\{(]|$/,excludeEnd:!0,illegal:"extends implements",contains:[{beginKeywords:"public protected internal private constructor"},e.UNDERSCORE_TITLE_MODE,{className:"type",begin:/</,end:/>/,excludeBegin:!0,excludeEnd:!0,relevance:0},{className:"type",begin:/[,:]\s*/,end:/[<\(,){\s]|$/,excludeBegin:!0,returnEnd:!0},o,l]},s,{className:"meta",begin:"^#!/usr/bin/env",end:"$",illegal:"\n"},c]}}},4210:e=>{const n=["a","abbr","address","article","aside","audio","b","blockquote","body","button","canvas","caption","cite","code","dd","del","details","dfn","div","dl","dt","em","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","html","i","iframe","img","input","ins","kbd","label","legend","li","main","mark","menu","nav","object","ol","p","q","quote","samp","section","span","strong","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","tr","ul","var","video"],t=["any-hover","any-pointer","aspect-ratio","color","color-gamut","color-index","device-aspect-ratio","device-height","device-width","display-mode","forced-colors","grid","height","hover","inverted-colors","monochrome","orientation","overflow-block","overflow-inline","pointer","prefers-color-scheme","prefers-contrast","prefers-reduced-motion","prefers-reduced-transparency","resolution","scan","scripting","update","width","min-width","max-width","min-height","max-height"],i=["active","any-link","blank","checked","current","default","defined","dir","disabled","drop","empty","enabled","first","first-child","first-of-type","fullscreen","future","focus","focus-visible","focus-within","has","host","host-context","hover","indeterminate","in-range","invalid","is","lang","last-child","last-of-type","left","link","local-link","not","nth-child","nth-col","nth-last-child","nth-last-col","nth-last-of-type","nth-of-type","only-child","only-of-type","optional","out-of-range","past","placeholder-shown","read-only","read-write","required","right","root","scope","target","target-within","user-invalid","valid","visited","where"],a=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"],r=["align-content","align-items","align-self","all","animation","animation-delay","animation-direction","animation-duration","animation-fill-mode","animation-iteration-count","animation-name","animation-play-state","animation-timing-function","backface-visibility","background","background-attachment","background-blend-mode","background-clip","background-color","background-image","background-origin","background-position","background-repeat","background-size","block-size","border","border-block","border-block-color","border-block-end","border-block-end-color","border-block-end-style","border-block-end-width","border-block-start","border-block-start-color","border-block-start-style","border-block-start-width","border-block-style","border-block-width","border-bottom","border-bottom-color","border-bottom-left-radius","border-bottom-right-radius","border-bottom-style","border-bottom-width","border-collapse","border-color","border-image","border-image-outset","border-image-repeat","border-image-slice","border-image-source","border-image-width","border-inline","border-inline-color","border-inline-end","border-inline-end-color","border-inline-end-style","border-inline-end-width","border-inline-start","border-inline-start-color","border-inline-start-style","border-inline-start-width","border-inline-style","border-inline-width","border-left","border-left-color","border-left-style","border-left-width","border-radius","border-right","border-right-color","border-right-style","border-right-width","border-spacing","border-style","border-top","border-top-color","border-top-left-radius","border-top-right-radius","border-top-style","border-top-width","border-width","bottom","box-decoration-break","box-shadow","box-sizing","break-after","break-before","break-inside","caption-side","caret-color","clear","clip","clip-path","clip-rule","color","column-count","column-fill","column-gap","column-rule","column-rule-color","column-rule-style","column-rule-width","column-span","column-width","columns","contain","content","content-visibility","counter-increment","counter-reset","cue","cue-after","cue-before","cursor","direction","display","empty-cells","filter","flex","flex-basis","flex-direction","flex-flow","flex-grow","flex-shrink","flex-wrap","float","flow","font","font-display","font-family","font-feature-settings","font-kerning","font-language-override","font-size","font-size-adjust","font-smoothing","font-stretch","font-style","font-synthesis","font-variant","font-variant-caps","font-variant-east-asian","font-variant-ligatures","font-variant-numeric","font-variant-position","font-variation-settings","font-weight","gap","glyph-orientation-vertical","grid","grid-area","grid-auto-columns","grid-auto-flow","grid-auto-rows","grid-column","grid-column-end","grid-column-start","grid-gap","grid-row","grid-row-end","grid-row-start","grid-template","grid-template-areas","grid-template-columns","grid-template-rows","hanging-punctuation","height","hyphens","icon","image-orientation","image-rendering","image-resolution","ime-mode","inline-size","isolation","justify-content","left","letter-spacing","line-break","line-height","list-style","list-style-image","list-style-position","list-style-type","margin","margin-block","margin-block-end","margin-block-start","margin-bottom","margin-inline","margin-inline-end","margin-inline-start","margin-left","margin-right","margin-top","marks","mask","mask-border","mask-border-mode","mask-border-outset","mask-border-repeat","mask-border-slice","mask-border-source","mask-border-width","mask-clip","mask-composite","mask-image","mask-mode","mask-origin","mask-position","mask-repeat","mask-size","mask-type","max-block-size","max-height","max-inline-size","max-width","min-block-size","min-height","min-inline-size","min-width","mix-blend-mode","nav-down","nav-index","nav-left","nav-right","nav-up","none","normal","object-fit","object-position","opacity","order","orphans","outline","outline-color","outline-offset","outline-style","outline-width","overflow","overflow-wrap","overflow-x","overflow-y","padding","padding-block","padding-block-end","padding-block-start","padding-bottom","padding-inline","padding-inline-end","padding-inline-start","padding-left","padding-right","padding-top","page-break-after","page-break-before","page-break-inside","pause","pause-after","pause-before","perspective","perspective-origin","pointer-events","position","quotes","resize","rest","rest-after","rest-before","right","row-gap","scroll-margin","scroll-margin-block","scroll-margin-block-end","scroll-margin-block-start","scroll-margin-bottom","scroll-margin-inline","scroll-margin-inline-end","scroll-margin-inline-start","scroll-margin-left","scroll-margin-right","scroll-margin-top","scroll-padding","scroll-padding-block","scroll-padding-block-end","scroll-padding-block-start","scroll-padding-bottom","scroll-padding-inline","scroll-padding-inline-end","scroll-padding-inline-start","scroll-padding-left","scroll-padding-right","scroll-padding-top","scroll-snap-align","scroll-snap-stop","scroll-snap-type","scrollbar-color","scrollbar-gutter","scrollbar-width","shape-image-threshold","shape-margin","shape-outside","speak","speak-as","src","tab-size","table-layout","text-align","text-align-all","text-align-last","text-combine-upright","text-decoration","text-decoration-color","text-decoration-line","text-decoration-style","text-emphasis","text-emphasis-color","text-emphasis-position","text-emphasis-style","text-indent","text-justify","text-orientation","text-overflow","text-rendering","text-shadow","text-transform","text-underline-position","top","transform","transform-box","transform-origin","transform-style","transition","transition-delay","transition-duration","transition-property","transition-timing-function","unicode-bidi","vertical-align","visibility","voice-balance","voice-duration","voice-family","voice-pitch","voice-range","voice-rate","voice-stress","voice-volume","white-space","widows","width","will-change","word-break","word-spacing","word-wrap","writing-mode","z-index"].reverse(),s=i.concat(a);e.exports=function(e){const o=(e=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:e.C_BLOCK_COMMENT_MODE,HEXCOLOR:{scope:"number",begin:/#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/},FUNCTION_DISPATCH:{className:"built_in",begin:/[\w-]+(?=\()/},ATTRIBUTE_SELECTOR_MODE:{scope:"selector-attr",begin:/\[/,end:/\]/,illegal:"$",contains:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:e.NUMBER_RE+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",relevance:0},CSS_VARIABLE:{className:"attr",begin:/--[A-Za-z][A-Za-z0-9_-]*/}}))(e),l=s,c="[\\w-]+",d="("+c+"|@\\{"+c+"\\})",u=[],g=[],b=function(e){return{className:"string",begin:"~?"+e+".*?"+e}},p=function(e,n,t){return{className:e,begin:n,relevance:t}},f={$pattern:/[a-z-]+/,keyword:"and or not only",attribute:t.join(" ")},m={begin:"\\(",end:"\\)",contains:g,keywords:f,relevance:0};g.push(e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,b("'"),b('"'),o.CSS_NUMBER_MODE,{begin:"(url|data-uri)\\(",starts:{className:"string",end:"[\\)\\n]",excludeEnd:!0}},o.HEXCOLOR,m,p("variable","@@?"+c,10),p("variable","@\\{"+c+"\\}"),p("built_in","~?`[^`]*?`"),{className:"attribute",begin:c+"\\s*:",end:":",returnBegin:!0,excludeEnd:!0},o.IMPORTANT,{beginKeywords:"and not"},o.FUNCTION_DISPATCH);const E=g.concat({begin:/\{/,end:/\}/,contains:u}),h={beginKeywords:"when",endsWithParent:!0,contains:[{beginKeywords:"and not"}].concat(g)},_={begin:d+"\\s*:",returnBegin:!0,end:/[;}]/,relevance:0,contains:[{begin:/-(webkit|moz|ms|o)-/},o.CSS_VARIABLE,{className:"attribute",begin:"\\b("+r.join("|")+")\\b",end:/(?=:)/,starts:{endsWithParent:!0,illegal:"[<=$]",relevance:0,contains:g}}]},N={className:"keyword",begin:"@(import|media|charset|font-face|(-[a-z]+-)?keyframes|supports|document|namespace|page|viewport|host)\\b",starts:{end:"[;{}]",keywords:f,returnEnd:!0,contains:g,relevance:0}},T={className:"variable",variants:[{begin:"@"+c+"\\s*:",relevance:15},{begin:"@"+c}],starts:{end:"[;}]",returnEnd:!0,contains:E}},O={variants:[{begin:"[\\.#:&\\[>]",end:"[;{}]"},{begin:d,end:/\{/}],returnBegin:!0,returnEnd:!0,illegal:"[<='$\"]",relevance:0,contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,h,p("keyword","all\\b"),p("variable","@\\{"+c+"\\}"),{begin:"\\b("+n.join("|")+")\\b",className:"selector-tag"},o.CSS_NUMBER_MODE,p("selector-tag",d,0),p("selector-id","#"+d),p("selector-class","\\."+d,0),p("selector-tag","&",0),o.ATTRIBUTE_SELECTOR_MODE,{className:"selector-pseudo",begin:":("+i.join("|")+")"},{className:"selector-pseudo",begin:":(:)?("+a.join("|")+")"},{begin:/\(/,end:/\)/,relevance:0,contains:E},{begin:"!important"},o.FUNCTION_DISPATCH]},A={begin:c+":(:)?"+`(${l.join("|")})`,returnBegin:!0,contains:[O]};return u.push(e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,N,T,A,_,O,h,o.FUNCTION_DISPATCH),{name:"Less",case_insensitive:!0,illegal:"[=>'/<($\"]",contains:u}}},1943:e=>{e.exports=function(e){const n="[a-zA-Z_\\-+\\*\\/<=>&#][a-zA-Z0-9_\\-+*\\/<=>&#!]*",t="\\|[^]*?\\|",i="(-|\\+)?\\d+(\\.\\d+|\\/\\d+)?((d|e|f|l|s|D|E|F|L|S)(\\+|-)?\\d+)?",a={className:"literal",begin:"\\b(t{1}|nil)\\b"},r={className:"number",variants:[{begin:i,relevance:0},{begin:"#(b|B)[0-1]+(/[0-1]+)?"},{begin:"#(o|O)[0-7]+(/[0-7]+)?"},{begin:"#(x|X)[0-9a-fA-F]+(/[0-9a-fA-F]+)?"},{begin:"#(c|C)\\("+i+" +"+i,end:"\\)"}]},s=e.inherit(e.QUOTE_STRING_MODE,{illegal:null}),o=e.COMMENT(";","$",{relevance:0}),l={begin:"\\*",end:"\\*"},c={className:"symbol",begin:"[:&]"+n},d={begin:n,relevance:0},u={begin:t},g={contains:[r,s,l,c,{begin:"\\(",end:"\\)",contains:["self",a,s,r,d]},d],variants:[{begin:"['`]\\(",end:"\\)"},{begin:"\\(quote ",end:"\\)",keywords:{name:"quote"}},{begin:"'"+t}]},b={variants:[{begin:"'"+n},{begin:"#'"+n+"(::"+n+")*"}]},p={begin:"\\(\\s*",end:"\\)"},f={endsWithParent:!0,relevance:0};return p.contains=[{className:"name",variants:[{begin:n,relevance:0},{begin:t}]},f],f.contains=[g,b,p,a,r,s,o,l,c,u,d],{name:"Lisp",illegal:/\S/,contains:[r,e.SHEBANG(),a,s,o,g,b,p,d]}}},4981:e=>{e.exports=function(e){const n="\\[=*\\[",t="\\]=*\\]",i={begin:n,end:t,contains:["self"]},a=[e.COMMENT("--(?!"+n+")","$"),e.COMMENT("--"+n,t,{contains:[i],relevance:10})];return{name:"Lua",keywords:{$pattern:e.UNDERSCORE_IDENT_RE,literal:"true false nil",keyword:"and break do else elseif end for goto if in local not or repeat return then until while",built_in:"_G _ENV _VERSION __index __newindex __mode __call __metatable __tostring __len __gc __add __sub __mul __div __mod __pow __concat __unm __eq __lt __le assert collectgarbage dofile error getfenv getmetatable ipairs load loadfile loadstring module next pairs pcall print rawequal rawget rawset require select setfenv setmetatable tonumber tostring type unpack xpcall arg self coroutine resume yield status wrap create running debug getupvalue debug sethook getmetatable gethook setmetatable setlocal traceback setfenv getinfo setupvalue getlocal getregistry getfenv io lines write close flush open output type read stderr stdin input stdout popen tmpfile math log max acos huge ldexp pi cos tanh pow deg tan cosh sinh random randomseed frexp ceil floor rad abs sqrt modf asin min mod fmod log10 atan2 exp sin atan os exit setlocale date getenv difftime remove time clock tmpname rename execute package preload loadlib loaded loaders cpath config path seeall string sub upper len gfind rep find match char dump gmatch reverse byte format gsub lower table setn insert getn foreachi maxn foreach concat sort remove"},contains:a.concat([{className:"function",beginKeywords:"function",end:"\\)",contains:[e.inherit(e.TITLE_MODE,{begin:"([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*"}),{className:"params",begin:"\\(",endsWithParent:!0,contains:a}].concat(a)},e.C_NUMBER_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{className:"string",begin:n,end:t,contains:[i],relevance:5}])}}},7903:e=>{e.exports=function(e){const n={className:"variable",variants:[{begin:"\\$\\("+e.UNDERSCORE_IDENT_RE+"\\)",contains:[e.BACKSLASH_ESCAPE]},{begin:/\$[@%<?\^\+\*]/}]},t={className:"string",begin:/"/,end:/"/,contains:[e.BACKSLASH_ESCAPE,n]},i={className:"variable",begin:/\$\([\w-]+\s/,end:/\)/,keywords:{built_in:"subst patsubst strip findstring filter filter-out sort word wordlist firstword lastword dir notdir suffix basename addsuffix addprefix join wildcard realpath abspath error warning shell origin flavor foreach if or and call eval file value"},contains:[n]},a={begin:"^"+e.UNDERSCORE_IDENT_RE+"\\s*(?=[:+?]?=)"},r={className:"section",begin:/^[^\s]+:/,end:/$/,contains:[n]};return{name:"Makefile",aliases:["mk","mak","make"],keywords:{$pattern:/[\w-]+/,keyword:"define endef undefine ifdef ifndef ifeq ifneq else endif include -include sinclude override export unexport private vpath"},contains:[e.HASH_COMMENT_MODE,n,t,i,a,{className:"meta",begin:/^\.PHONY:/,end:/$/,keywords:{$pattern:/[\.\w]+/,keyword:".PHONY"}},r]}}},2003:e=>{e.exports=function(e){const n={begin:/<\/?[A-Za-z_]/,end:">",subLanguage:"xml",relevance:0},t={variants:[{begin:/\[.+?\]\[.*?\]/,relevance:0},{begin:/\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,relevance:2},{begin:e.regex.concat(/\[.+?\]\(/,/[A-Za-z][A-Za-z0-9+.-]*/,/:\/\/.*?\)/),relevance:2},{begin:/\[.+?\]\([./?&#].*?\)/,relevance:1},{begin:/\[.*?\]\(.*?\)/,relevance:0}],returnBegin:!0,contains:[{match:/\[(?=\])/},{className:"string",relevance:0,begin:"\\[",end:"\\]",excludeBegin:!0,returnEnd:!0},{className:"link",relevance:0,begin:"\\]\\(",end:"\\)",excludeBegin:!0,excludeEnd:!0},{className:"symbol",relevance:0,begin:"\\]\\[",end:"\\]",excludeBegin:!0,excludeEnd:!0}]},i={className:"strong",contains:[],variants:[{begin:/_{2}(?!\s)/,end:/_{2}/},{begin:/\*{2}(?!\s)/,end:/\*{2}/}]},a={className:"emphasis",contains:[],variants:[{begin:/\*(?![*\s])/,end:/\*/},{begin:/_(?![_\s])/,end:/_/,relevance:0}]},r=e.inherit(i,{contains:[]}),s=e.inherit(a,{contains:[]});i.contains.push(s),a.contains.push(r);let o=[n,t];return[i,a,r,s].forEach((e=>{e.contains=e.contains.concat(o)})),o=o.concat(i,a),{name:"Markdown",aliases:["md","mkdown","mkd"],contains:[{className:"section",variants:[{begin:"^#{1,6}",end:"$",contains:o},{begin:"(?=^.+?\\n[=-]{2,}$)",contains:[{begin:"^[=-]*$"},{begin:"^",end:"\\n",contains:o}]}]},n,{className:"bullet",begin:"^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",end:"\\s+",excludeEnd:!0},i,a,{className:"quote",begin:"^>\\s+",contains:o,end:"$"},{className:"code",variants:[{begin:"(`{3,})[^`](.|\\n)*?\\1`*[ ]*"},{begin:"(~{3,})[^~](.|\\n)*?\\1~*[ ]*"},{begin:"```",end:"```+[ ]*$"},{begin:"~~~",end:"~~~+[ ]*$"},{begin:"`.+?`"},{begin:"(?=^( {4}|\\t))",contains:[{begin:"^( {4}|\\t)",end:"(\\n)$"}],relevance:0}]},{begin:"^[-\\*]{3,}",end:"$"},t,{begin:/^\[[^\n]+\]:/,returnBegin:!0,contains:[{className:"symbol",begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0},{className:"link",begin:/:\s*/,end:/$/,excludeBegin:!0}]}]}}},4028:e=>{e.exports=function(e){const n=e.regex,t={className:"variable",variants:[{begin:/\$\d+/},{begin:/\$\{\w+\}/},{begin:n.concat(/[$@]/,e.UNDERSCORE_IDENT_RE)}]},i={endsWithParent:!0,keywords:{$pattern:/[a-z_]{2,}|\/dev\/poll/,literal:["on","off","yes","no","true","false","none","blocked","debug","info","notice","warn","error","crit","select","break","last","permanent","redirect","kqueue","rtsig","epoll","poll","/dev/poll"]},relevance:0,illegal:"=>",contains:[e.HASH_COMMENT_MODE,{className:"string",contains:[e.BACKSLASH_ESCAPE,t],variants:[{begin:/"/,end:/"/},{begin:/'/,end:/'/}]},{begin:"([a-z]+):/",end:"\\s",endsWithParent:!0,excludeEnd:!0,contains:[t]},{className:"regexp",contains:[e.BACKSLASH_ESCAPE,t],variants:[{begin:"\\s\\^",end:"\\s|\\{|;",returnEnd:!0},{begin:"~\\*?\\s+",end:"\\s|\\{|;",returnEnd:!0},{begin:"\\*(\\.[a-z\\-]+)+"},{begin:"([a-z\\-]+\\.)+\\*"}]},{className:"number",begin:"\\b\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}(:\\d{1,5})?\\b"},{className:"number",begin:"\\b\\d+[kKmMgGdshdwy]?\\b",relevance:0},t]};return{name:"Nginx config",aliases:["nginxconf"],contains:[e.HASH_COMMENT_MODE,{beginKeywords:"upstream location",end:/;|\{/,contains:i.contains,keywords:{section:"upstream location"}},{className:"section",begin:n.concat(e.UNDERSCORE_IDENT_RE+n.lookahead(/\s+\{/)),relevance:0},{begin:n.lookahead(e.UNDERSCORE_IDENT_RE+"\\s"),end:";|\\{",contains:[{className:"attribute",begin:e.UNDERSCORE_IDENT_RE,starts:i}],relevance:0}],illegal:"[^\\s\\}\\{]"}}},2446:e=>{e.exports=function(e){const n=/[a-zA-Z@][a-zA-Z0-9_]*/,t={$pattern:n,keyword:["@interface","@class","@protocol","@implementation"]};return{name:"Objective-C",aliases:["mm","objc","obj-c","obj-c++","objective-c++"],keywords:{"variable.language":["this","super"],$pattern:n,keyword:["while","export","sizeof","typedef","const","struct","for","union","volatile","static","mutable","if","do","return","goto","enum","else","break","extern","asm","case","default","register","explicit","typename","switch","continue","inline","readonly","assign","readwrite","self","@synchronized","id","typeof","nonatomic","IBOutlet","IBAction","strong","weak","copy","in","out","inout","bycopy","byref","oneway","__strong","__weak","__block","__autoreleasing","@private","@protected","@public","@try","@property","@end","@throw","@catch","@finally","@autoreleasepool","@synthesize","@dynamic","@selector","@optional","@required","@encode","@package","@import","@defs","@compatibility_alias","__bridge","__bridge_transfer","__bridge_retained","__bridge_retain","__covariant","__contravariant","__kindof","_Nonnull","_Nullable","_Null_unspecified","__FUNCTION__","__PRETTY_FUNCTION__","__attribute__","getter","setter","retain","unsafe_unretained","nonnull","nullable","null_unspecified","null_resettable","class","instancetype","NS_DESIGNATED_INITIALIZER","NS_UNAVAILABLE","NS_REQUIRES_SUPER","NS_RETURNS_INNER_POINTER","NS_INLINE","NS_AVAILABLE","NS_DEPRECATED","NS_ENUM","NS_OPTIONS","NS_SWIFT_UNAVAILABLE","NS_ASSUME_NONNULL_BEGIN","NS_ASSUME_NONNULL_END","NS_REFINED_FOR_SWIFT","NS_SWIFT_NAME","NS_SWIFT_NOTHROW","NS_DURING","NS_HANDLER","NS_ENDHANDLER","NS_VALUERETURN","NS_VOIDRETURN"],literal:["false","true","FALSE","TRUE","nil","YES","NO","NULL"],built_in:["dispatch_once_t","dispatch_queue_t","dispatch_sync","dispatch_async","dispatch_once"],type:["int","float","char","unsigned","signed","short","long","double","wchar_t","unichar","void","bool","BOOL","id|0","_Bool"]},illegal:"</",contains:[{className:"built_in",begin:"\\b(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)\\w+"},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.C_NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,{className:"string",variants:[{begin:'@"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]}]},{className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{keyword:"if else elif endif define undef warning error line pragma ifdef ifndef include"},contains:[{begin:/\\\n/,relevance:0},e.inherit(e.QUOTE_STRING_MODE,{className:"string"}),{className:"string",begin:/<.*?>/,end:/$/,illegal:"\\n"},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"class",begin:"("+t.keyword.join("|")+")\\b",end:/(\{|$)/,excludeEnd:!0,keywords:t,contains:[e.UNDERSCORE_TITLE_MODE]},{begin:"\\."+e.UNDERSCORE_IDENT_RE,relevance:0}]}}},2482:e=>{e.exports=function(e){const n=e.regex,t=/[dualxmsipngr]{0,12}/,i={$pattern:/[\w.]+/,keyword:["abs","accept","alarm","and","atan2","bind","binmode","bless","break","caller","chdir","chmod","chomp","chop","chown","chr","chroot","close","closedir","connect","continue","cos","crypt","dbmclose","dbmopen","defined","delete","die","do","dump","each","else","elsif","endgrent","endhostent","endnetent","endprotoent","endpwent","endservent","eof","eval","exec","exists","exit","exp","fcntl","fileno","flock","for","foreach","fork","format","formline","getc","getgrent","getgrgid","getgrnam","gethostbyaddr","gethostbyname","gethostent","getlogin","getnetbyaddr","getnetbyname","getnetent","getpeername","getpgrp","getpriority","getprotobyname","getprotobynumber","getprotoent","getpwent","getpwnam","getpwuid","getservbyname","getservbyport","getservent","getsockname","getsockopt","given","glob","gmtime","goto","grep","gt","hex","if","index","int","ioctl","join","keys","kill","last","lc","lcfirst","length","link","listen","local","localtime","log","lstat","lt","ma","map","mkdir","msgctl","msgget","msgrcv","msgsnd","my","ne","next","no","not","oct","open","opendir","or","ord","our","pack","package","pipe","pop","pos","print","printf","prototype","push","q|0","qq","quotemeta","qw","qx","rand","read","readdir","readline","readlink","readpipe","recv","redo","ref","rename","require","reset","return","reverse","rewinddir","rindex","rmdir","say","scalar","seek","seekdir","select","semctl","semget","semop","send","setgrent","sethostent","setnetent","setpgrp","setpriority","setprotoent","setpwent","setservent","setsockopt","shift","shmctl","shmget","shmread","shmwrite","shutdown","sin","sleep","socket","socketpair","sort","splice","split","sprintf","sqrt","srand","stat","state","study","sub","substr","symlink","syscall","sysopen","sysread","sysseek","system","syswrite","tell","telldir","tie","tied","time","times","tr","truncate","uc","ucfirst","umask","undef","unless","unlink","unpack","unshift","untie","until","use","utime","values","vec","wait","waitpid","wantarray","warn","when","while","write","x|0","xor","y|0"].join(" ")},a={className:"subst",begin:"[$@]\\{",end:"\\}",keywords:i},r={begin:/->\{/,end:/\}/},s={variants:[{begin:/\$\d/},{begin:n.concat(/[$%@](\^\w\b|#\w+(::\w+)*|\{\w+\}|\w+(::\w*)*)/,"(?![A-Za-z])(?![@$%])")},{begin:/[$%@][^\s\w{]/,relevance:0}]},o=[e.BACKSLASH_ESCAPE,a,s],l=[/!/,/\//,/\|/,/\?/,/'/,/"/,/#/],c=(e,i,a="\\1")=>{const r="\\1"===a?a:n.concat(a,i);return n.concat(n.concat("(?:",e,")"),i,/(?:\\.|[^\\\/])*?/,r,/(?:\\.|[^\\\/])*?/,a,t)},d=(e,i,a)=>n.concat(n.concat("(?:",e,")"),i,/(?:\\.|[^\\\/])*?/,a,t),u=[s,e.HASH_COMMENT_MODE,e.COMMENT(/^=\w/,/=cut/,{endsWithParent:!0}),r,{className:"string",contains:o,variants:[{begin:"q[qwxr]?\\s*\\(",end:"\\)",relevance:5},{begin:"q[qwxr]?\\s*\\[",end:"\\]",relevance:5},{begin:"q[qwxr]?\\s*\\{",end:"\\}",relevance:5},{begin:"q[qwxr]?\\s*\\|",end:"\\|",relevance:5},{begin:"q[qwxr]?\\s*<",end:">",relevance:5},{begin:"qw\\s+q",end:"q",relevance:5},{begin:"'",end:"'",contains:[e.BACKSLASH_ESCAPE]},{begin:'"',end:'"'},{begin:"`",end:"`",contains:[e.BACKSLASH_ESCAPE]},{begin:/\{\w+\}/,relevance:0},{begin:"-?\\w+\\s*=>",relevance:0}]},{className:"number",begin:"(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b",relevance:0},{begin:"(\\/\\/|"+e.RE_STARTERS_RE+"|\\b(split|return|print|reverse|grep)\\b)\\s*",keywords:"split return print reverse grep",relevance:0,contains:[e.HASH_COMMENT_MODE,{className:"regexp",variants:[{begin:c("s|tr|y",n.either(...l,{capture:!0}))},{begin:c("s|tr|y","\\(","\\)")},{begin:c("s|tr|y","\\[","\\]")},{begin:c("s|tr|y","\\{","\\}")}],relevance:2},{className:"regexp",variants:[{begin:/(m|qr)\/\//,relevance:0},{begin:d("(?:m|qr)?",/\//,/\//)},{begin:d("m|qr",n.either(...l,{capture:!0}),/\1/)},{begin:d("m|qr",/\(/,/\)/)},{begin:d("m|qr",/\[/,/\]/)},{begin:d("m|qr",/\{/,/\}/)}]}]},{className:"function",beginKeywords:"sub",end:"(\\s*\\(.*?\\))?[;{]",excludeEnd:!0,relevance:5,contains:[e.TITLE_MODE]},{begin:"-\\w\\b",relevance:0},{begin:"^__DATA__$",end:"^__END__$",subLanguage:"mojolicious",contains:[{begin:"^@@.*",end:"$",className:"comment"}]}];return a.contains=u,r.contains=u,{name:"Perl",aliases:["pl","pm"],keywords:i,contains:u}}},9814:e=>{e.exports=function(e){const n=e.COMMENT("--","$"),t="\\$([a-zA-Z_]?|[a-zA-Z_][a-zA-Z_0-9]*)\\$",i="BIGINT INT8 BIGSERIAL SERIAL8 BIT VARYING VARBIT BOOLEAN BOOL BOX BYTEA CHARACTER CHAR VARCHAR CIDR CIRCLE DATE DOUBLE PRECISION FLOAT8 FLOAT INET INTEGER INT INT4 INTERVAL JSON JSONB LINE LSEG|10 MACADDR MACADDR8 MONEY NUMERIC DEC DECIMAL PATH POINT POLYGON REAL FLOAT4 SMALLINT INT2 SMALLSERIAL|10 SERIAL2|10 SERIAL|10 SERIAL4|10 TEXT TIME ZONE TIMETZ|10 TIMESTAMP TIMESTAMPTZ|10 TSQUERY|10 TSVECTOR|10 TXID_SNAPSHOT|10 UUID XML NATIONAL NCHAR INT4RANGE|10 INT8RANGE|10 NUMRANGE|10 TSRANGE|10 TSTZRANGE|10 DATERANGE|10 ANYELEMENT ANYARRAY ANYNONARRAY ANYENUM ANYRANGE CSTRING INTERNAL RECORD PG_DDL_COMMAND VOID UNKNOWN OPAQUE REFCURSOR NAME OID REGPROC|10 REGPROCEDURE|10 REGOPER|10 REGOPERATOR|10 REGCLASS|10 REGTYPE|10 REGROLE|10 REGNAMESPACE|10 REGCONFIG|10 REGDICTIONARY|10 ",a=i.trim().split(" ").map((function(e){return e.split("|")[0]})).join("|"),r="ARRAY_AGG AVG BIT_AND BIT_OR BOOL_AND BOOL_OR COUNT EVERY JSON_AGG JSONB_AGG JSON_OBJECT_AGG JSONB_OBJECT_AGG MAX MIN MODE STRING_AGG SUM XMLAGG CORR COVAR_POP COVAR_SAMP REGR_AVGX REGR_AVGY REGR_COUNT REGR_INTERCEPT REGR_R2 REGR_SLOPE REGR_SXX REGR_SXY REGR_SYY STDDEV STDDEV_POP STDDEV_SAMP VARIANCE VAR_POP VAR_SAMP PERCENTILE_CONT PERCENTILE_DISC ROW_NUMBER RANK DENSE_RANK PERCENT_RANK CUME_DIST NTILE LAG LEAD FIRST_VALUE LAST_VALUE NTH_VALUE NUM_NONNULLS NUM_NULLS ABS CBRT CEIL CEILING DEGREES DIV EXP FLOOR LN LOG MOD PI POWER RADIANS ROUND SCALE SIGN SQRT TRUNC WIDTH_BUCKET RANDOM SETSEED ACOS ACOSD ASIN ASIND ATAN ATAND ATAN2 ATAN2D COS COSD COT COTD SIN SIND TAN TAND BIT_LENGTH CHAR_LENGTH CHARACTER_LENGTH LOWER OCTET_LENGTH OVERLAY POSITION SUBSTRING TREAT TRIM UPPER ASCII BTRIM CHR CONCAT CONCAT_WS CONVERT CONVERT_FROM CONVERT_TO DECODE ENCODE INITCAP LEFT LENGTH LPAD LTRIM MD5 PARSE_IDENT PG_CLIENT_ENCODING QUOTE_IDENT|10 QUOTE_LITERAL|10 QUOTE_NULLABLE|10 REGEXP_MATCH REGEXP_MATCHES REGEXP_REPLACE REGEXP_SPLIT_TO_ARRAY REGEXP_SPLIT_TO_TABLE REPEAT REPLACE REVERSE RIGHT RPAD RTRIM SPLIT_PART STRPOS SUBSTR TO_ASCII TO_HEX TRANSLATE OCTET_LENGTH GET_BIT GET_BYTE SET_BIT SET_BYTE TO_CHAR TO_DATE TO_NUMBER TO_TIMESTAMP AGE CLOCK_TIMESTAMP|10 DATE_PART DATE_TRUNC ISFINITE JUSTIFY_DAYS JUSTIFY_HOURS JUSTIFY_INTERVAL MAKE_DATE MAKE_INTERVAL|10 MAKE_TIME MAKE_TIMESTAMP|10 MAKE_TIMESTAMPTZ|10 NOW STATEMENT_TIMESTAMP|10 TIMEOFDAY TRANSACTION_TIMESTAMP|10 ENUM_FIRST ENUM_LAST ENUM_RANGE AREA CENTER DIAMETER HEIGHT ISCLOSED ISOPEN NPOINTS PCLOSE POPEN RADIUS WIDTH BOX BOUND_BOX CIRCLE LINE LSEG PATH POLYGON ABBREV BROADCAST HOST HOSTMASK MASKLEN NETMASK NETWORK SET_MASKLEN TEXT INET_SAME_FAMILY INET_MERGE MACADDR8_SET7BIT ARRAY_TO_TSVECTOR GET_CURRENT_TS_CONFIG NUMNODE PLAINTO_TSQUERY PHRASETO_TSQUERY WEBSEARCH_TO_TSQUERY QUERYTREE SETWEIGHT STRIP TO_TSQUERY TO_TSVECTOR JSON_TO_TSVECTOR JSONB_TO_TSVECTOR TS_DELETE TS_FILTER TS_HEADLINE TS_RANK TS_RANK_CD TS_REWRITE TSQUERY_PHRASE TSVECTOR_TO_ARRAY TSVECTOR_UPDATE_TRIGGER TSVECTOR_UPDATE_TRIGGER_COLUMN XMLCOMMENT XMLCONCAT XMLELEMENT XMLFOREST XMLPI XMLROOT XMLEXISTS XML_IS_WELL_FORMED XML_IS_WELL_FORMED_DOCUMENT XML_IS_WELL_FORMED_CONTENT XPATH XPATH_EXISTS XMLTABLE XMLNAMESPACES TABLE_TO_XML TABLE_TO_XMLSCHEMA TABLE_TO_XML_AND_XMLSCHEMA QUERY_TO_XML QUERY_TO_XMLSCHEMA QUERY_TO_XML_AND_XMLSCHEMA CURSOR_TO_XML CURSOR_TO_XMLSCHEMA SCHEMA_TO_XML SCHEMA_TO_XMLSCHEMA SCHEMA_TO_XML_AND_XMLSCHEMA DATABASE_TO_XML DATABASE_TO_XMLSCHEMA DATABASE_TO_XML_AND_XMLSCHEMA XMLATTRIBUTES TO_JSON TO_JSONB ARRAY_TO_JSON ROW_TO_JSON JSON_BUILD_ARRAY JSONB_BUILD_ARRAY JSON_BUILD_OBJECT JSONB_BUILD_OBJECT JSON_OBJECT JSONB_OBJECT JSON_ARRAY_LENGTH JSONB_ARRAY_LENGTH JSON_EACH JSONB_EACH JSON_EACH_TEXT JSONB_EACH_TEXT JSON_EXTRACT_PATH JSONB_EXTRACT_PATH JSON_OBJECT_KEYS JSONB_OBJECT_KEYS JSON_POPULATE_RECORD JSONB_POPULATE_RECORD JSON_POPULATE_RECORDSET JSONB_POPULATE_RECORDSET JSON_ARRAY_ELEMENTS JSONB_ARRAY_ELEMENTS JSON_ARRAY_ELEMENTS_TEXT JSONB_ARRAY_ELEMENTS_TEXT JSON_TYPEOF JSONB_TYPEOF JSON_TO_RECORD JSONB_TO_RECORD JSON_TO_RECORDSET JSONB_TO_RECORDSET JSON_STRIP_NULLS JSONB_STRIP_NULLS JSONB_SET JSONB_INSERT JSONB_PRETTY CURRVAL LASTVAL NEXTVAL SETVAL COALESCE NULLIF GREATEST LEAST ARRAY_APPEND ARRAY_CAT ARRAY_NDIMS ARRAY_DIMS ARRAY_FILL ARRAY_LENGTH ARRAY_LOWER ARRAY_POSITION ARRAY_POSITIONS ARRAY_PREPEND ARRAY_REMOVE ARRAY_REPLACE ARRAY_TO_STRING ARRAY_UPPER CARDINALITY STRING_TO_ARRAY UNNEST ISEMPTY LOWER_INC UPPER_INC LOWER_INF UPPER_INF RANGE_MERGE GENERATE_SERIES GENERATE_SUBSCRIPTS CURRENT_DATABASE CURRENT_QUERY CURRENT_SCHEMA|10 CURRENT_SCHEMAS|10 INET_CLIENT_ADDR INET_CLIENT_PORT INET_SERVER_ADDR INET_SERVER_PORT ROW_SECURITY_ACTIVE FORMAT_TYPE TO_REGCLASS TO_REGPROC TO_REGPROCEDURE TO_REGOPER TO_REGOPERATOR TO_REGTYPE TO_REGNAMESPACE TO_REGROLE COL_DESCRIPTION OBJ_DESCRIPTION SHOBJ_DESCRIPTION TXID_CURRENT TXID_CURRENT_IF_ASSIGNED TXID_CURRENT_SNAPSHOT TXID_SNAPSHOT_XIP TXID_SNAPSHOT_XMAX TXID_SNAPSHOT_XMIN TXID_VISIBLE_IN_SNAPSHOT TXID_STATUS CURRENT_SETTING SET_CONFIG BRIN_SUMMARIZE_NEW_VALUES BRIN_SUMMARIZE_RANGE BRIN_DESUMMARIZE_RANGE GIN_CLEAN_PENDING_LIST SUPPRESS_REDUNDANT_UPDATES_TRIGGER LO_FROM_BYTEA LO_PUT LO_GET LO_CREAT LO_CREATE LO_UNLINK LO_IMPORT LO_EXPORT LOREAD LOWRITE GROUPING CAST ".trim().split(" ").map((function(e){return e.split("|")[0]})).join("|");return{name:"PostgreSQL",aliases:["postgres","postgresql"],supersetOf:"sql",case_insensitive:!0,keywords:{keyword:"ABORT ALTER ANALYZE BEGIN CALL CHECKPOINT|10 CLOSE CLUSTER COMMENT COMMIT COPY CREATE DEALLOCATE DECLARE DELETE DISCARD DO DROP END EXECUTE EXPLAIN FETCH GRANT IMPORT INSERT LISTEN LOAD LOCK MOVE NOTIFY PREPARE REASSIGN|10 REFRESH REINDEX RELEASE RESET REVOKE ROLLBACK SAVEPOINT SECURITY SELECT SET SHOW START TRUNCATE UNLISTEN|10 UPDATE VACUUM|10 VALUES AGGREGATE COLLATION CONVERSION|10 DATABASE DEFAULT PRIVILEGES DOMAIN TRIGGER EXTENSION FOREIGN WRAPPER|10 TABLE FUNCTION GROUP LANGUAGE LARGE OBJECT MATERIALIZED VIEW OPERATOR CLASS FAMILY POLICY PUBLICATION|10 ROLE RULE SCHEMA SEQUENCE SERVER STATISTICS SUBSCRIPTION SYSTEM TABLESPACE CONFIGURATION DICTIONARY PARSER TEMPLATE TYPE USER MAPPING PREPARED ACCESS METHOD CAST AS TRANSFORM TRANSACTION OWNED TO INTO SESSION AUTHORIZATION INDEX PROCEDURE ASSERTION ALL ANALYSE AND ANY ARRAY ASC ASYMMETRIC|10 BOTH CASE CHECK COLLATE COLUMN CONCURRENTLY|10 CONSTRAINT CROSS DEFERRABLE RANGE DESC DISTINCT ELSE EXCEPT FOR FREEZE|10 FROM FULL HAVING ILIKE IN INITIALLY INNER INTERSECT IS ISNULL JOIN LATERAL LEADING LIKE LIMIT NATURAL NOT NOTNULL NULL OFFSET ON ONLY OR ORDER OUTER OVERLAPS PLACING PRIMARY REFERENCES RETURNING SIMILAR SOME SYMMETRIC TABLESAMPLE THEN TRAILING UNION UNIQUE USING VARIADIC|10 VERBOSE WHEN WHERE WINDOW WITH BY RETURNS INOUT OUT SETOF|10 IF STRICT CURRENT CONTINUE OWNER LOCATION OVER PARTITION WITHIN BETWEEN ESCAPE EXTERNAL INVOKER DEFINER WORK RENAME VERSION CONNECTION CONNECT TABLES TEMP TEMPORARY FUNCTIONS SEQUENCES TYPES SCHEMAS OPTION CASCADE RESTRICT ADD ADMIN EXISTS VALID VALIDATE ENABLE DISABLE REPLICA|10 ALWAYS PASSING COLUMNS PATH REF VALUE OVERRIDING IMMUTABLE STABLE VOLATILE BEFORE AFTER EACH ROW PROCEDURAL ROUTINE NO HANDLER VALIDATOR OPTIONS STORAGE OIDS|10 WITHOUT INHERIT DEPENDS CALLED INPUT LEAKPROOF|10 COST ROWS NOWAIT SEARCH UNTIL ENCRYPTED|10 PASSWORD CONFLICT|10 INSTEAD INHERITS CHARACTERISTICS WRITE CURSOR ALSO STATEMENT SHARE EXCLUSIVE INLINE ISOLATION REPEATABLE READ COMMITTED SERIALIZABLE UNCOMMITTED LOCAL GLOBAL SQL PROCEDURES RECURSIVE SNAPSHOT ROLLUP CUBE TRUSTED|10 INCLUDE FOLLOWING PRECEDING UNBOUNDED RANGE GROUPS UNENCRYPTED|10 SYSID FORMAT DELIMITER HEADER QUOTE ENCODING FILTER OFF FORCE_QUOTE FORCE_NOT_NULL FORCE_NULL COSTS BUFFERS TIMING SUMMARY DISABLE_PAGE_SKIPPING RESTART CYCLE GENERATED IDENTITY DEFERRED IMMEDIATE LEVEL LOGGED UNLOGGED OF NOTHING NONE EXCLUDE ATTRIBUTE USAGE ROUTINES TRUE FALSE NAN INFINITY ALIAS BEGIN CONSTANT DECLARE END EXCEPTION RETURN PERFORM|10 RAISE GET DIAGNOSTICS STACKED|10 FOREACH LOOP ELSIF EXIT WHILE REVERSE SLICE DEBUG LOG INFO NOTICE WARNING ASSERT OPEN SUPERUSER NOSUPERUSER CREATEDB NOCREATEDB CREATEROLE NOCREATEROLE INHERIT NOINHERIT LOGIN NOLOGIN REPLICATION NOREPLICATION BYPASSRLS NOBYPASSRLS ",built_in:"CURRENT_TIME CURRENT_TIMESTAMP CURRENT_USER CURRENT_CATALOG|10 CURRENT_DATE LOCALTIME LOCALTIMESTAMP CURRENT_ROLE|10 CURRENT_SCHEMA|10 SESSION_USER PUBLIC FOUND NEW OLD TG_NAME|10 TG_WHEN|10 TG_LEVEL|10 TG_OP|10 TG_RELID|10 TG_RELNAME|10 TG_TABLE_NAME|10 TG_TABLE_SCHEMA|10 TG_NARGS|10 TG_ARGV|10 TG_EVENT|10 TG_TAG|10 ROW_COUNT RESULT_OID|10 PG_CONTEXT|10 RETURNED_SQLSTATE COLUMN_NAME CONSTRAINT_NAME PG_DATATYPE_NAME|10 MESSAGE_TEXT TABLE_NAME SCHEMA_NAME PG_EXCEPTION_DETAIL|10 PG_EXCEPTION_HINT|10 PG_EXCEPTION_CONTEXT|10 SQLSTATE SQLERRM|10 SUCCESSFUL_COMPLETION WARNING DYNAMIC_RESULT_SETS_RETURNED IMPLICIT_ZERO_BIT_PADDING NULL_VALUE_ELIMINATED_IN_SET_FUNCTION PRIVILEGE_NOT_GRANTED PRIVILEGE_NOT_REVOKED STRING_DATA_RIGHT_TRUNCATION DEPRECATED_FEATURE NO_DATA NO_ADDITIONAL_DYNAMIC_RESULT_SETS_RETURNED SQL_STATEMENT_NOT_YET_COMPLETE CONNECTION_EXCEPTION CONNECTION_DOES_NOT_EXIST CONNECTION_FAILURE SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION SQLSERVER_REJECTED_ESTABLISHMENT_OF_SQLCONNECTION TRANSACTION_RESOLUTION_UNKNOWN PROTOCOL_VIOLATION TRIGGERED_ACTION_EXCEPTION FEATURE_NOT_SUPPORTED INVALID_TRANSACTION_INITIATION LOCATOR_EXCEPTION INVALID_LOCATOR_SPECIFICATION INVALID_GRANTOR INVALID_GRANT_OPERATION INVALID_ROLE_SPECIFICATION DIAGNOSTICS_EXCEPTION STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER CASE_NOT_FOUND CARDINALITY_VIOLATION DATA_EXCEPTION ARRAY_SUBSCRIPT_ERROR CHARACTER_NOT_IN_REPERTOIRE DATETIME_FIELD_OVERFLOW DIVISION_BY_ZERO ERROR_IN_ASSIGNMENT ESCAPE_CHARACTER_CONFLICT INDICATOR_OVERFLOW INTERVAL_FIELD_OVERFLOW INVALID_ARGUMENT_FOR_LOGARITHM INVALID_ARGUMENT_FOR_NTILE_FUNCTION INVALID_ARGUMENT_FOR_NTH_VALUE_FUNCTION INVALID_ARGUMENT_FOR_POWER_FUNCTION INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION INVALID_CHARACTER_VALUE_FOR_CAST INVALID_DATETIME_FORMAT INVALID_ESCAPE_CHARACTER INVALID_ESCAPE_OCTET INVALID_ESCAPE_SEQUENCE NONSTANDARD_USE_OF_ESCAPE_CHARACTER INVALID_INDICATOR_PARAMETER_VALUE INVALID_PARAMETER_VALUE INVALID_REGULAR_EXPRESSION INVALID_ROW_COUNT_IN_LIMIT_CLAUSE INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE INVALID_TABLESAMPLE_ARGUMENT INVALID_TABLESAMPLE_REPEAT INVALID_TIME_ZONE_DISPLACEMENT_VALUE INVALID_USE_OF_ESCAPE_CHARACTER MOST_SPECIFIC_TYPE_MISMATCH NULL_VALUE_NOT_ALLOWED NULL_VALUE_NO_INDICATOR_PARAMETER NUMERIC_VALUE_OUT_OF_RANGE SEQUENCE_GENERATOR_LIMIT_EXCEEDED STRING_DATA_LENGTH_MISMATCH STRING_DATA_RIGHT_TRUNCATION SUBSTRING_ERROR TRIM_ERROR UNTERMINATED_C_STRING ZERO_LENGTH_CHARACTER_STRING FLOATING_POINT_EXCEPTION INVALID_TEXT_REPRESENTATION INVALID_BINARY_REPRESENTATION BAD_COPY_FILE_FORMAT UNTRANSLATABLE_CHARACTER NOT_AN_XML_DOCUMENT INVALID_XML_DOCUMENT INVALID_XML_CONTENT INVALID_XML_COMMENT INVALID_XML_PROCESSING_INSTRUCTION INTEGRITY_CONSTRAINT_VIOLATION RESTRICT_VIOLATION NOT_NULL_VIOLATION FOREIGN_KEY_VIOLATION UNIQUE_VIOLATION CHECK_VIOLATION EXCLUSION_VIOLATION INVALID_CURSOR_STATE INVALID_TRANSACTION_STATE ACTIVE_SQL_TRANSACTION BRANCH_TRANSACTION_ALREADY_ACTIVE HELD_CURSOR_REQUIRES_SAME_ISOLATION_LEVEL INAPPROPRIATE_ACCESS_MODE_FOR_BRANCH_TRANSACTION INAPPROPRIATE_ISOLATION_LEVEL_FOR_BRANCH_TRANSACTION NO_ACTIVE_SQL_TRANSACTION_FOR_BRANCH_TRANSACTION READ_ONLY_SQL_TRANSACTION SCHEMA_AND_DATA_STATEMENT_MIXING_NOT_SUPPORTED NO_ACTIVE_SQL_TRANSACTION IN_FAILED_SQL_TRANSACTION IDLE_IN_TRANSACTION_SESSION_TIMEOUT INVALID_SQL_STATEMENT_NAME TRIGGERED_DATA_CHANGE_VIOLATION INVALID_AUTHORIZATION_SPECIFICATION INVALID_PASSWORD DEPENDENT_PRIVILEGE_DESCRIPTORS_STILL_EXIST DEPENDENT_OBJECTS_STILL_EXIST INVALID_TRANSACTION_TERMINATION SQL_ROUTINE_EXCEPTION FUNCTION_EXECUTED_NO_RETURN_STATEMENT MODIFYING_SQL_DATA_NOT_PERMITTED PROHIBITED_SQL_STATEMENT_ATTEMPTED READING_SQL_DATA_NOT_PERMITTED INVALID_CURSOR_NAME EXTERNAL_ROUTINE_EXCEPTION CONTAINING_SQL_NOT_PERMITTED MODIFYING_SQL_DATA_NOT_PERMITTED PROHIBITED_SQL_STATEMENT_ATTEMPTED READING_SQL_DATA_NOT_PERMITTED EXTERNAL_ROUTINE_INVOCATION_EXCEPTION INVALID_SQLSTATE_RETURNED NULL_VALUE_NOT_ALLOWED TRIGGER_PROTOCOL_VIOLATED SRF_PROTOCOL_VIOLATED EVENT_TRIGGER_PROTOCOL_VIOLATED SAVEPOINT_EXCEPTION INVALID_SAVEPOINT_SPECIFICATION INVALID_CATALOG_NAME INVALID_SCHEMA_NAME TRANSACTION_ROLLBACK TRANSACTION_INTEGRITY_CONSTRAINT_VIOLATION SERIALIZATION_FAILURE STATEMENT_COMPLETION_UNKNOWN DEADLOCK_DETECTED SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION SYNTAX_ERROR INSUFFICIENT_PRIVILEGE CANNOT_COERCE GROUPING_ERROR WINDOWING_ERROR INVALID_RECURSION INVALID_FOREIGN_KEY INVALID_NAME NAME_TOO_LONG RESERVED_NAME DATATYPE_MISMATCH INDETERMINATE_DATATYPE COLLATION_MISMATCH INDETERMINATE_COLLATION WRONG_OBJECT_TYPE GENERATED_ALWAYS UNDEFINED_COLUMN UNDEFINED_FUNCTION UNDEFINED_TABLE UNDEFINED_PARAMETER UNDEFINED_OBJECT DUPLICATE_COLUMN DUPLICATE_CURSOR DUPLICATE_DATABASE DUPLICATE_FUNCTION DUPLICATE_PREPARED_STATEMENT DUPLICATE_SCHEMA DUPLICATE_TABLE DUPLICATE_ALIAS DUPLICATE_OBJECT AMBIGUOUS_COLUMN AMBIGUOUS_FUNCTION AMBIGUOUS_PARAMETER AMBIGUOUS_ALIAS INVALID_COLUMN_REFERENCE INVALID_COLUMN_DEFINITION INVALID_CURSOR_DEFINITION INVALID_DATABASE_DEFINITION INVALID_FUNCTION_DEFINITION INVALID_PREPARED_STATEMENT_DEFINITION INVALID_SCHEMA_DEFINITION INVALID_TABLE_DEFINITION INVALID_OBJECT_DEFINITION WITH_CHECK_OPTION_VIOLATION INSUFFICIENT_RESOURCES DISK_FULL OUT_OF_MEMORY TOO_MANY_CONNECTIONS CONFIGURATION_LIMIT_EXCEEDED PROGRAM_LIMIT_EXCEEDED STATEMENT_TOO_COMPLEX TOO_MANY_COLUMNS TOO_MANY_ARGUMENTS OBJECT_NOT_IN_PREREQUISITE_STATE OBJECT_IN_USE CANT_CHANGE_RUNTIME_PARAM LOCK_NOT_AVAILABLE OPERATOR_INTERVENTION QUERY_CANCELED ADMIN_SHUTDOWN CRASH_SHUTDOWN CANNOT_CONNECT_NOW DATABASE_DROPPED SYSTEM_ERROR IO_ERROR UNDEFINED_FILE DUPLICATE_FILE SNAPSHOT_TOO_OLD CONFIG_FILE_ERROR LOCK_FILE_EXISTS FDW_ERROR FDW_COLUMN_NAME_NOT_FOUND FDW_DYNAMIC_PARAMETER_VALUE_NEEDED FDW_FUNCTION_SEQUENCE_ERROR FDW_INCONSISTENT_DESCRIPTOR_INFORMATION FDW_INVALID_ATTRIBUTE_VALUE FDW_INVALID_COLUMN_NAME FDW_INVALID_COLUMN_NUMBER FDW_INVALID_DATA_TYPE FDW_INVALID_DATA_TYPE_DESCRIPTORS FDW_INVALID_DESCRIPTOR_FIELD_IDENTIFIER FDW_INVALID_HANDLE FDW_INVALID_OPTION_INDEX FDW_INVALID_OPTION_NAME FDW_INVALID_STRING_LENGTH_OR_BUFFER_LENGTH FDW_INVALID_STRING_FORMAT FDW_INVALID_USE_OF_NULL_POINTER FDW_TOO_MANY_HANDLES FDW_OUT_OF_MEMORY FDW_NO_SCHEMAS FDW_OPTION_NAME_NOT_FOUND FDW_REPLY_HANDLE FDW_SCHEMA_NOT_FOUND FDW_TABLE_NOT_FOUND FDW_UNABLE_TO_CREATE_EXECUTION FDW_UNABLE_TO_CREATE_REPLY FDW_UNABLE_TO_ESTABLISH_CONNECTION PLPGSQL_ERROR RAISE_EXCEPTION NO_DATA_FOUND TOO_MANY_ROWS ASSERT_FAILURE INTERNAL_ERROR DATA_CORRUPTED INDEX_CORRUPTED "},illegal:/:==|\W\s*\(\*|(^|\s)\$[a-z]|\{\{|[a-z]:\s*$|\.\.\.|TO:|DO:/,contains:[{className:"keyword",variants:[{begin:/\bTEXT\s*SEARCH\b/},{begin:/\b(PRIMARY|FOREIGN|FOR(\s+NO)?)\s+KEY\b/},{begin:/\bPARALLEL\s+(UNSAFE|RESTRICTED|SAFE)\b/},{begin:/\bSTORAGE\s+(PLAIN|EXTERNAL|EXTENDED|MAIN)\b/},{begin:/\bMATCH\s+(FULL|PARTIAL|SIMPLE)\b/},{begin:/\bNULLS\s+(FIRST|LAST)\b/},{begin:/\bEVENT\s+TRIGGER\b/},{begin:/\b(MAPPING|OR)\s+REPLACE\b/},{begin:/\b(FROM|TO)\s+(PROGRAM|STDIN|STDOUT)\b/},{begin:/\b(SHARE|EXCLUSIVE)\s+MODE\b/},{begin:/\b(LEFT|RIGHT)\s+(OUTER\s+)?JOIN\b/},{begin:/\b(FETCH|MOVE)\s+(NEXT|PRIOR|FIRST|LAST|ABSOLUTE|RELATIVE|FORWARD|BACKWARD)\b/},{begin:/\bPRESERVE\s+ROWS\b/},{begin:/\bDISCARD\s+PLANS\b/},{begin:/\bREFERENCING\s+(OLD|NEW)\b/},{begin:/\bSKIP\s+LOCKED\b/},{begin:/\bGROUPING\s+SETS\b/},{begin:/\b(BINARY|INSENSITIVE|SCROLL|NO\s+SCROLL)\s+(CURSOR|FOR)\b/},{begin:/\b(WITH|WITHOUT)\s+HOLD\b/},{begin:/\bWITH\s+(CASCADED|LOCAL)\s+CHECK\s+OPTION\b/},{begin:/\bEXCLUDE\s+(TIES|NO\s+OTHERS)\b/},{begin:/\bFORMAT\s+(TEXT|XML|JSON|YAML)\b/},{begin:/\bSET\s+((SESSION|LOCAL)\s+)?NAMES\b/},{begin:/\bIS\s+(NOT\s+)?UNKNOWN\b/},{begin:/\bSECURITY\s+LABEL\b/},{begin:/\bSTANDALONE\s+(YES|NO|NO\s+VALUE)\b/},{begin:/\bWITH\s+(NO\s+)?DATA\b/},{begin:/\b(FOREIGN|SET)\s+DATA\b/},{begin:/\bSET\s+(CATALOG|CONSTRAINTS)\b/},{begin:/\b(WITH|FOR)\s+ORDINALITY\b/},{begin:/\bIS\s+(NOT\s+)?DOCUMENT\b/},{begin:/\bXML\s+OPTION\s+(DOCUMENT|CONTENT)\b/},{begin:/\b(STRIP|PRESERVE)\s+WHITESPACE\b/},{begin:/\bNO\s+(ACTION|MAXVALUE|MINVALUE)\b/},{begin:/\bPARTITION\s+BY\s+(RANGE|LIST|HASH)\b/},{begin:/\bAT\s+TIME\s+ZONE\b/},{begin:/\bGRANTED\s+BY\b/},{begin:/\bRETURN\s+(QUERY|NEXT)\b/},{begin:/\b(ATTACH|DETACH)\s+PARTITION\b/},{begin:/\bFORCE\s+ROW\s+LEVEL\s+SECURITY\b/},{begin:/\b(INCLUDING|EXCLUDING)\s+(COMMENTS|CONSTRAINTS|DEFAULTS|IDENTITY|INDEXES|STATISTICS|STORAGE|ALL)\b/},{begin:/\bAS\s+(ASSIGNMENT|IMPLICIT|PERMISSIVE|RESTRICTIVE|ENUM|RANGE)\b/}]},{begin:/\b(FORMAT|FAMILY|VERSION)\s*\(/},{begin:/\bINCLUDE\s*\(/,keywords:"INCLUDE"},{begin:/\bRANGE(?!\s*(BETWEEN|UNBOUNDED|CURRENT|[-0-9]+))/},{begin:/\b(VERSION|OWNER|TEMPLATE|TABLESPACE|CONNECTION\s+LIMIT|PROCEDURE|RESTRICT|JOIN|PARSER|COPY|START|END|COLLATION|INPUT|ANALYZE|STORAGE|LIKE|DEFAULT|DELIMITER|ENCODING|COLUMN|CONSTRAINT|TABLE|SCHEMA)\s*=/},{begin:/\b(PG_\w+?|HAS_[A-Z_]+_PRIVILEGE)\b/,relevance:10},{begin:/\bEXTRACT\s*\(/,end:/\bFROM\b/,returnEnd:!0,keywords:{type:"CENTURY DAY DECADE DOW DOY EPOCH HOUR ISODOW ISOYEAR MICROSECONDS MILLENNIUM MILLISECONDS MINUTE MONTH QUARTER SECOND TIMEZONE TIMEZONE_HOUR TIMEZONE_MINUTE WEEK YEAR"}},{begin:/\b(XMLELEMENT|XMLPI)\s*\(\s*NAME/,keywords:{keyword:"NAME"}},{begin:/\b(XMLPARSE|XMLSERIALIZE)\s*\(\s*(DOCUMENT|CONTENT)/,keywords:{keyword:"DOCUMENT CONTENT"}},{beginKeywords:"CACHE INCREMENT MAXVALUE MINVALUE",end:e.C_NUMBER_RE,returnEnd:!0,keywords:"BY CACHE INCREMENT MAXVALUE MINVALUE"},{className:"type",begin:/\b(WITH|WITHOUT)\s+TIME\s+ZONE\b/},{className:"type",begin:/\bINTERVAL\s+(YEAR|MONTH|DAY|HOUR|MINUTE|SECOND)(\s+TO\s+(MONTH|HOUR|MINUTE|SECOND))?\b/},{begin:/\bRETURNS\s+(LANGUAGE_HANDLER|TRIGGER|EVENT_TRIGGER|FDW_HANDLER|INDEX_AM_HANDLER|TSM_HANDLER)\b/,keywords:{keyword:"RETURNS",type:"LANGUAGE_HANDLER TRIGGER EVENT_TRIGGER FDW_HANDLER INDEX_AM_HANDLER TSM_HANDLER"}},{begin:"\\b("+r+")\\s*\\("},{begin:"\\.("+a+")\\b"},{begin:"\\b("+a+")\\s+PATH\\b",keywords:{keyword:"PATH",type:i.replace("PATH ","")}},{className:"type",begin:"\\b("+a+")\\b"},{className:"string",begin:"'",end:"'",contains:[{begin:"''"}]},{className:"string",begin:"(e|E|u&|U&)'",end:"'",contains:[{begin:"\\\\."}],relevance:10},e.END_SAME_AS_BEGIN({begin:t,end:t,contains:[{subLanguage:["pgsql","perl","python","tcl","r","lua","java","php","ruby","bash","scheme","xml","json"],endsWithParent:!0}]}),{begin:'"',end:'"',contains:[{begin:'""'}]},e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,n,{className:"meta",variants:[{begin:"%(ROW)?TYPE",relevance:10},{begin:"\\$\\d+"},{begin:"^#\\w",end:"$"}]},{className:"symbol",begin:"<<\\s*[a-zA-Z_][a-zA-Z_0-9$]*\\s*>>",relevance:10}]}}},2656:e=>{e.exports=function(e){const n=e.regex,t=/(?![A-Za-z0-9])(?![$])/,i=n.concat(/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/,t),a=n.concat(/(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,t),r={scope:"variable",match:"\\$+"+i},s={scope:"subst",variants:[{begin:/\$\w+/},{begin:/\{\$/,end:/\}/}]},o=e.inherit(e.APOS_STRING_MODE,{illegal:null}),l="[ \t\n]",c={scope:"string",variants:[e.inherit(e.QUOTE_STRING_MODE,{illegal:null,contains:e.QUOTE_STRING_MODE.contains.concat(s)}),o,{begin:/<<<[ \t]*(?:(\w+)|"(\w+)")\n/,end:/[ \t]*(\w+)\b/,contains:e.QUOTE_STRING_MODE.contains.concat(s),"on:begin":(e,n)=>{n.data._beginMatch=e[1]||e[2]},"on:end":(e,n)=>{n.data._beginMatch!==e[1]&&n.ignoreMatch()}},e.END_SAME_AS_BEGIN({begin:/<<<[ \t]*'(\w+)'\n/,end:/[ \t]*(\w+)\b/})]},d={scope:"number",variants:[{begin:"\\b0[bB][01]+(?:_[01]+)*\\b"},{begin:"\\b0[oO][0-7]+(?:_[0-7]+)*\\b"},{begin:"\\b0[xX][\\da-fA-F]+(?:_[\\da-fA-F]+)*\\b"},{begin:"(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?"}],relevance:0},u=["false","null","true"],g=["__CLASS__","__DIR__","__FILE__","__FUNCTION__","__COMPILER_HALT_OFFSET__","__LINE__","__METHOD__","__NAMESPACE__","__TRAIT__","die","echo","exit","include","include_once","print","require","require_once","array","abstract","and","as","binary","bool","boolean","break","callable","case","catch","class","clone","const","continue","declare","default","do","double","else","elseif","empty","enddeclare","endfor","endforeach","endif","endswitch","endwhile","enum","eval","extends","final","finally","float","for","foreach","from","global","goto","if","implements","instanceof","insteadof","int","integer","interface","isset","iterable","list","match|0","mixed","new","never","object","or","private","protected","public","readonly","real","return","string","switch","throw","trait","try","unset","use","var","void","while","xor","yield"],b=["Error|0","AppendIterator","ArgumentCountError","ArithmeticError","ArrayIterator","ArrayObject","AssertionError","BadFunctionCallException","BadMethodCallException","CachingIterator","CallbackFilterIterator","CompileError","Countable","DirectoryIterator","DivisionByZeroError","DomainException","EmptyIterator","ErrorException","Exception","FilesystemIterator","FilterIterator","GlobIterator","InfiniteIterator","InvalidArgumentException","IteratorIterator","LengthException","LimitIterator","LogicException","MultipleIterator","NoRewindIterator","OutOfBoundsException","OutOfRangeException","OuterIterator","OverflowException","ParentIterator","ParseError","RangeException","RecursiveArrayIterator","RecursiveCachingIterator","RecursiveCallbackFilterIterator","RecursiveDirectoryIterator","RecursiveFilterIterator","RecursiveIterator","RecursiveIteratorIterator","RecursiveRegexIterator","RecursiveTreeIterator","RegexIterator","RuntimeException","SeekableIterator","SplDoublyLinkedList","SplFileInfo","SplFileObject","SplFixedArray","SplHeap","SplMaxHeap","SplMinHeap","SplObjectStorage","SplObserver","SplPriorityQueue","SplQueue","SplStack","SplSubject","SplTempFileObject","TypeError","UnderflowException","UnexpectedValueException","UnhandledMatchError","ArrayAccess","BackedEnum","Closure","Fiber","Generator","Iterator","IteratorAggregate","Serializable","Stringable","Throwable","Traversable","UnitEnum","WeakReference","WeakMap","Directory","__PHP_Incomplete_Class","parent","php_user_filter","self","static","stdClass"],p={keyword:g,literal:(e=>{const n=[];return e.forEach((e=>{n.push(e),e.toLowerCase()===e?n.push(e.toUpperCase()):n.push(e.toLowerCase())})),n})(u),built_in:b},f=e=>e.map((e=>e.replace(/\|\d+$/,""))),m={variants:[{match:[/new/,n.concat(l,"+"),n.concat("(?!",f(b).join("\\b|"),"\\b)"),a],scope:{1:"keyword",4:"title.class"}}]},E=n.concat(i,"\\b(?!\\()"),h={variants:[{match:[n.concat(/::/,n.lookahead(/(?!class\b)/)),E],scope:{2:"variable.constant"}},{match:[/::/,/class/],scope:{2:"variable.language"}},{match:[a,n.concat(/::/,n.lookahead(/(?!class\b)/)),E],scope:{1:"title.class",3:"variable.constant"}},{match:[a,n.concat("::",n.lookahead(/(?!class\b)/))],scope:{1:"title.class"}},{match:[a,/::/,/class/],scope:{1:"title.class",3:"variable.language"}}]},_={scope:"attr",match:n.concat(i,n.lookahead(":"),n.lookahead(/(?!::)/))},N={relevance:0,begin:/\(/,end:/\)/,keywords:p,contains:[_,r,h,e.C_BLOCK_COMMENT_MODE,c,d,m]},T={relevance:0,match:[/\b/,n.concat("(?!fn\\b|function\\b|",f(g).join("\\b|"),"|",f(b).join("\\b|"),"\\b)"),i,n.concat(l,"*"),n.lookahead(/(?=\()/)],scope:{3:"title.function.invoke"},contains:[N]};N.contains.push(T);const O=[_,h,e.C_BLOCK_COMMENT_MODE,c,d,m];return{case_insensitive:!1,keywords:p,contains:[{begin:n.concat(/#\[\s*/,a),beginScope:"meta",end:/]/,endScope:"meta",keywords:{literal:u,keyword:["new","array"]},contains:[{begin:/\[/,end:/]/,keywords:{literal:u,keyword:["new","array"]},contains:["self",...O]},...O,{scope:"meta",match:a}]},e.HASH_COMMENT_MODE,e.COMMENT("//","$"),e.COMMENT("/\\*","\\*/",{contains:[{scope:"doctag",match:"@[A-Za-z]+"}]}),{match:/__halt_compiler\(\);/,keywords:"__halt_compiler",starts:{scope:"comment",end:e.MATCH_NOTHING_RE,contains:[{match:/\?>/,scope:"meta",endsParent:!0}]}},{scope:"meta",variants:[{begin:/<\?php/,relevance:10},{begin:/<\?=/},{begin:/<\?/,relevance:.1},{begin:/\?>/}]},{scope:"variable.language",match:/\$this\b/},r,T,h,{match:[/const/,/\s/,i],scope:{1:"keyword",3:"variable.constant"}},m,{scope:"function",relevance:0,beginKeywords:"fn function",end:/[;{]/,excludeEnd:!0,illegal:"[$%\\[]",contains:[{beginKeywords:"use"},e.UNDERSCORE_TITLE_MODE,{begin:"=>",endsParent:!0},{scope:"params",begin:"\\(",end:"\\)",excludeBegin:!0,excludeEnd:!0,keywords:p,contains:["self",r,h,e.C_BLOCK_COMMENT_MODE,c,d]}]},{scope:"class",variants:[{beginKeywords:"enum",illegal:/[($"]/},{beginKeywords:"class interface trait",illegal:/[:($"]/}],relevance:0,end:/\{/,excludeEnd:!0,contains:[{beginKeywords:"extends implements"},e.UNDERSCORE_TITLE_MODE]},{beginKeywords:"namespace",relevance:0,end:";",illegal:/[.']/,contains:[e.inherit(e.UNDERSCORE_TITLE_MODE,{scope:"title.class"})]},{beginKeywords:"use",relevance:0,end:";",contains:[{match:/\b(as|const|function)\b/,scope:"keyword"},e.UNDERSCORE_TITLE_MODE]},c,d]}}},2437:e=>{e.exports=function(e){return{name:"Plain text",aliases:["text","txt"],disableAutodetect:!0}}},5040:e=>{e.exports=function(e){const n={$pattern:/-?[A-z\.\-]+\b/,keyword:"if else foreach return do while until elseif begin for trap data dynamicparam end break throw param continue finally in switch exit filter try process catch hidden static parameter",built_in:"ac asnp cat cd CFS chdir clc clear clhy cli clp cls clv cnsn compare copy cp cpi cpp curl cvpa dbp del diff dir dnsn ebp echo|0 epal epcsv epsn erase etsn exsn fc fhx fl ft fw gal gbp gc gcb gci gcm gcs gdr gerr ghy gi gin gjb gl gm gmo gp gps gpv group gsn gsnp gsv gtz gu gv gwmi h history icm iex ihy ii ipal ipcsv ipmo ipsn irm ise iwmi iwr kill lp ls man md measure mi mount move mp mv nal ndr ni nmo npssc nsn nv ogv oh popd ps pushd pwd r rbp rcjb rcsn rd rdr ren ri rjb rm rmdir rmo rni rnp rp rsn rsnp rujb rv rvpa rwmi sajb sal saps sasv sbp sc scb select set shcm si sl sleep sls sort sp spjb spps spsv start stz sujb sv swmi tee trcm type wget where wjb write"},t={begin:"`[\\s\\S]",relevance:0},i={className:"variable",variants:[{begin:/\$\B/},{className:"keyword",begin:/\$this/},{begin:/\$[\w\d][\w\d_:]*/}]},a={className:"string",variants:[{begin:/"/,end:/"/},{begin:/@"/,end:/^"@/}],contains:[t,i,{className:"variable",begin:/\$[A-z]/,end:/[^A-z]/}]},r={className:"string",variants:[{begin:/'/,end:/'/},{begin:/@'/,end:/^'@/}]},s=e.inherit(e.COMMENT(null,null),{variants:[{begin:/#/,end:/$/},{begin:/<#/,end:/#>/}],contains:[{className:"doctag",variants:[{begin:/\.(synopsis|description|example|inputs|outputs|notes|link|component|role|functionality)/},{begin:/\.(parameter|forwardhelptargetname|forwardhelpcategory|remotehelprunspace|externalhelp)\s+\S+/}]}]}),o={className:"built_in",variants:[{begin:"(".concat("Add|Clear|Close|Copy|Enter|Exit|Find|Format|Get|Hide|Join|Lock|Move|New|Open|Optimize|Pop|Push|Redo|Remove|Rename|Reset|Resize|Search|Select|Set|Show|Skip|Split|Step|Switch|Undo|Unlock|Watch|Backup|Checkpoint|Compare|Compress|Convert|ConvertFrom|ConvertTo|Dismount|Edit|Expand|Export|Group|Import|Initialize|Limit|Merge|Mount|Out|Publish|Restore|Save|Sync|Unpublish|Update|Approve|Assert|Build|Complete|Confirm|Deny|Deploy|Disable|Enable|Install|Invoke|Register|Request|Restart|Resume|Start|Stop|Submit|Suspend|Uninstall|Unregister|Wait|Debug|Measure|Ping|Repair|Resolve|Test|Trace|Connect|Disconnect|Read|Receive|Send|Write|Block|Grant|Protect|Revoke|Unblock|Unprotect|Use|ForEach|Sort|Tee|Where",")+(-)[\\w\\d]+")}]},l={className:"class",beginKeywords:"class enum",end:/\s*[{]/,excludeEnd:!0,relevance:0,contains:[e.TITLE_MODE]},c={className:"function",begin:/function\s+/,end:/\s*\{|$/,excludeEnd:!0,returnBegin:!0,relevance:0,contains:[{begin:"function",relevance:0,className:"keyword"},{className:"title",begin:/\w[\w\d]*((-)[\w\d]+)*/,relevance:0},{begin:/\(/,end:/\)/,className:"params",relevance:0,contains:[i]}]},d={begin:/using\s/,end:/$/,returnBegin:!0,contains:[a,r,{className:"keyword",begin:/(using|assembly|command|module|namespace|type)/}]},u={variants:[{className:"operator",begin:"(".concat("-and|-as|-band|-bnot|-bor|-bxor|-casesensitive|-ccontains|-ceq|-cge|-cgt|-cle|-clike|-clt|-cmatch|-cne|-cnotcontains|-cnotlike|-cnotmatch|-contains|-creplace|-csplit|-eq|-exact|-f|-file|-ge|-gt|-icontains|-ieq|-ige|-igt|-ile|-ilike|-ilt|-imatch|-in|-ine|-inotcontains|-inotlike|-inotmatch|-ireplace|-is|-isnot|-isplit|-join|-le|-like|-lt|-match|-ne|-not|-notcontains|-notin|-notlike|-notmatch|-or|-regex|-replace|-shl|-shr|-split|-wildcard|-xor",")\\b")},{className:"literal",begin:/(-){1,2}[\w\d-]+/,relevance:0}]},g={className:"function",begin:/\[.*\]\s*[\w]+[ ]??\(/,end:/$/,returnBegin:!0,relevance:0,contains:[{className:"keyword",begin:"(".concat(n.keyword.toString().replace(/\s/g,"|"),")\\b"),endsParent:!0,relevance:0},e.inherit(e.TITLE_MODE,{endsParent:!0})]},b=[g,s,t,e.NUMBER_MODE,a,r,o,i,{className:"literal",begin:/\$(null|true|false)\b/},{className:"selector-tag",begin:/@\B/,relevance:0}],p={begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[].concat("self",b,{begin:"("+["string","char","byte","int","long","bool","decimal","single","double","DateTime","xml","array","hashtable","void"].join("|")+")",className:"built_in",relevance:0},{className:"type",begin:/[\.\w\d]+/,relevance:0})};return g.contains.unshift(p),{name:"PowerShell",aliases:["pwsh","ps","ps1"],case_insensitive:!0,keywords:n,contains:b.concat(l,c,d,u,p)}}},7546:e=>{e.exports=function(e){const n="[ \\t\\f]*",t=n+"[:=]"+n,i="[ \\t\\f]+",a="([^\\\\:= \\t\\f\\n]|\\\\.)+",r={end:"("+t+"|"+i+")",relevance:0,starts:{className:"string",end:/$/,relevance:0,contains:[{begin:"\\\\\\\\"},{begin:"\\\\\\n"}]}};return{name:".properties",disableAutodetect:!0,case_insensitive:!0,illegal:/\S/,contains:[e.COMMENT("^\\s*[!#]","$"),{returnBegin:!0,variants:[{begin:a+t},{begin:a+i}],contains:[{className:"attr",begin:a,endsParent:!0}],starts:r},{className:"attr",begin:a+n+"$"}]}}},5559:e=>{e.exports=function(e){const n={match:[/(message|enum|service)\s+/,e.IDENT_RE],scope:{1:"keyword",2:"title.class"}};return{name:"Protocol Buffers",aliases:["proto"],keywords:{keyword:["package","import","option","optional","required","repeated","group","oneof"],type:["double","float","int32","int64","uint32","uint64","sint32","sint64","fixed32","fixed64","sfixed32","sfixed64","bool","string","bytes"],literal:["true","false"]},contains:[e.QUOTE_STRING_MODE,e.NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,n,{className:"function",beginKeywords:"rpc",end:/[{;]/,excludeEnd:!0,keywords:"rpc returns"},{begin:/^\s*[A-Z_]+(?=\s*=[^\n]+;$)/}]}}},8245:e=>{e.exports=function(e){const n=e.regex,t=/[\p{XID_Start}_]\p{XID_Continue}*/u,i=["and","as","assert","async","await","break","case","class","continue","def","del","elif","else","except","finally","for","from","global","if","import","in","is","lambda","match","nonlocal|10","not","or","pass","raise","return","try","while","with","yield"],a={$pattern:/[A-Za-z]\w+|__\w+__/,keyword:i,built_in:["__import__","abs","all","any","ascii","bin","bool","breakpoint","bytearray","bytes","callable","chr","classmethod","compile","complex","delattr","dict","dir","divmod","enumerate","eval","exec","filter","float","format","frozenset","getattr","globals","hasattr","hash","help","hex","id","input","int","isinstance","issubclass","iter","len","list","locals","map","max","memoryview","min","next","object","oct","open","ord","pow","print","property","range","repr","reversed","round","set","setattr","slice","sorted","staticmethod","str","sum","super","tuple","type","vars","zip"],literal:["__debug__","Ellipsis","False","None","NotImplemented","True"],type:["Any","Callable","Coroutine","Dict","List","Literal","Generic","Optional","Sequence","Set","Tuple","Type","Union"]},r={className:"meta",begin:/^(>>>|\.\.\.) /},s={className:"subst",begin:/\{/,end:/\}/,keywords:a,illegal:/#/},o={begin:/\{\{/,relevance:0},l={className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,end:/'''/,contains:[e.BACKSLASH_ESCAPE,r],relevance:10},{begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,end:/"""/,contains:[e.BACKSLASH_ESCAPE,r],relevance:10},{begin:/([fF][rR]|[rR][fF]|[fF])'''/,end:/'''/,contains:[e.BACKSLASH_ESCAPE,r,o,s]},{begin:/([fF][rR]|[rR][fF]|[fF])"""/,end:/"""/,contains:[e.BACKSLASH_ESCAPE,r,o,s]},{begin:/([uU]|[rR])'/,end:/'/,relevance:10},{begin:/([uU]|[rR])"/,end:/"/,relevance:10},{begin:/([bB]|[bB][rR]|[rR][bB])'/,end:/'/},{begin:/([bB]|[bB][rR]|[rR][bB])"/,end:/"/},{begin:/([fF][rR]|[rR][fF]|[fF])'/,end:/'/,contains:[e.BACKSLASH_ESCAPE,o,s]},{begin:/([fF][rR]|[rR][fF]|[fF])"/,end:/"/,contains:[e.BACKSLASH_ESCAPE,o,s]},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},c="[0-9](_?[0-9])*",d=`(\\b(${c}))?\\.(${c})|\\b(${c})\\.`,u=`\\b|${i.join("|")}`,g={className:"number",relevance:0,variants:[{begin:`(\\b(${c})|(${d}))[eE][+-]?(${c})[jJ]?(?=${u})`},{begin:`(${d})[jJ]?`},{begin:`\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${u})`},{begin:`\\b0[bB](_?[01])+[lL]?(?=${u})`},{begin:`\\b0[oO](_?[0-7])+[lL]?(?=${u})`},{begin:`\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${u})`},{begin:`\\b(${c})[jJ](?=${u})`}]},b={className:"comment",begin:n.lookahead(/# type:/),end:/$/,keywords:a,contains:[{begin:/# type:/},{begin:/#/,end:/\b\B/,endsWithParent:!0}]},p={className:"params",variants:[{className:"",begin:/\(\s*\)/,skip:!0},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:a,contains:["self",r,g,l,e.HASH_COMMENT_MODE]}]};return s.contains=[l,g,r],{name:"Python",aliases:["py","gyp","ipython"],unicodeRegex:!0,keywords:a,illegal:/(<\/|\?)|=>/,contains:[r,g,{begin:/\bself\b/},{beginKeywords:"if",relevance:0},l,b,e.HASH_COMMENT_MODE,{match:[/\bdef/,/\s+/,t],scope:{1:"keyword",3:"title.function"},contains:[p]},{variants:[{match:[/\bclass/,/\s+/,t,/\s*/,/\(\s*/,t,/\s*\)/]},{match:[/\bclass/,/\s+/,t]}],scope:{1:"keyword",3:"title.class",6:"title.class.inherited"}},{className:"meta",begin:/^[\t ]*@/,end:/(?=#)|$/,contains:[g,p,l]}]}}},7905:e=>{e.exports=function(e){const n=e.regex,t="([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)",i=n.either(/\b([A-Z]+[a-z0-9]+)+/,/\b([A-Z]+[a-z0-9]+)+[A-Z]+/),a=n.concat(i,/(::\w+)*/),r={"variable.constant":["__FILE__","__LINE__","__ENCODING__"],"variable.language":["self","super"],keyword:["alias","and","begin","BEGIN","break","case","class","defined","do","else","elsif","end","END","ensure","for","if","in","module","next","not","or","redo","require","rescue","retry","return","then","undef","unless","until","when","while","yield","include","extend","prepend","public","private","protected","raise","throw"],built_in:["proc","lambda","attr_accessor","attr_reader","attr_writer","define_method","private_constant","module_function"],literal:["true","false","nil"]},s={className:"doctag",begin:"@[A-Za-z]+"},o={begin:"#<",end:">"},l=[e.COMMENT("#","$",{contains:[s]}),e.COMMENT("^=begin","^=end",{contains:[s],relevance:10}),e.COMMENT("^__END__",e.MATCH_NOTHING_RE)],c={className:"subst",begin:/#\{/,end:/\}/,keywords:r},d={className:"string",contains:[e.BACKSLASH_ESCAPE,c],variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/`/,end:/`/},{begin:/%[qQwWx]?\(/,end:/\)/},{begin:/%[qQwWx]?\[/,end:/\]/},{begin:/%[qQwWx]?\{/,end:/\}/},{begin:/%[qQwWx]?</,end:/>/},{begin:/%[qQwWx]?\//,end:/\//},{begin:/%[qQwWx]?%/,end:/%/},{begin:/%[qQwWx]?-/,end:/-/},{begin:/%[qQwWx]?\|/,end:/\|/},{begin:/\B\?(\\\d{1,3})/},{begin:/\B\?(\\x[A-Fa-f0-9]{1,2})/},{begin:/\B\?(\\u\{?[A-Fa-f0-9]{1,6}\}?)/},{begin:/\B\?(\\M-\\C-|\\M-\\c|\\c\\M-|\\M-|\\C-\\M-)[\x20-\x7e]/},{begin:/\B\?\\(c|C-)[\x20-\x7e]/},{begin:/\B\?\\?\S/},{begin:n.concat(/<<[-~]?'?/,n.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/)),contains:[e.END_SAME_AS_BEGIN({begin:/(\w+)/,end:/(\w+)/,contains:[e.BACKSLASH_ESCAPE,c]})]}]},u="[0-9](_?[0-9])*",g={className:"number",relevance:0,variants:[{begin:`\\b([1-9](_?[0-9])*|0)(\\.(${u}))?([eE][+-]?(${u})|r)?i?\\b`},{begin:"\\b0[dD][0-9](_?[0-9])*r?i?\\b"},{begin:"\\b0[bB][0-1](_?[0-1])*r?i?\\b"},{begin:"\\b0[oO][0-7](_?[0-7])*r?i?\\b"},{begin:"\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b"},{begin:"\\b0(_?[0-7])+r?i?\\b"}]},b={variants:[{match:/\(\)/},{className:"params",begin:/\(/,end:/(?=\))/,excludeBegin:!0,endsParent:!0,keywords:r}]},p=[d,{variants:[{match:[/class\s+/,a,/\s+<\s+/,a]},{match:[/\b(class|module)\s+/,a]}],scope:{2:"title.class",4:"title.class.inherited"},keywords:r},{match:[/(include|extend)\s+/,a],scope:{2:"title.class"},keywords:r},{relevance:0,match:[a,/\.new[. (]/],scope:{1:"title.class"}},{relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"},{relevance:0,match:i,scope:"title.class"},{match:[/def/,/\s+/,t],scope:{1:"keyword",3:"title.function"},contains:[b]},{begin:e.IDENT_RE+"::"},{className:"symbol",begin:e.UNDERSCORE_IDENT_RE+"(!|\\?)?:",relevance:0},{className:"symbol",begin:":(?!\\s)",contains:[d,{begin:t}],relevance:0},g,{className:"variable",begin:"(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"},{className:"params",begin:/\|/,end:/\|/,excludeBegin:!0,excludeEnd:!0,relevance:0,keywords:r},{begin:"("+e.RE_STARTERS_RE+"|unless)\\s*",keywords:"unless",contains:[{className:"regexp",contains:[e.BACKSLASH_ESCAPE,c],illegal:/\n/,variants:[{begin:"/",end:"/[a-z]*"},{begin:/%r\{/,end:/\}[a-z]*/},{begin:"%r\\(",end:"\\)[a-z]*"},{begin:"%r!",end:"![a-z]*"},{begin:"%r\\[",end:"\\][a-z]*"}]}].concat(o,l),relevance:0}].concat(o,l);c.contains=p,b.contains=p;const f=[{begin:/^\s*=>/,starts:{end:"$",contains:p}},{className:"meta.prompt",begin:"^([>?]>|[\\w#]+\\(\\w+\\):\\d+:\\d+[>*]|(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>)(?=[ ])",starts:{end:"$",keywords:r,contains:p}}];return l.unshift(o),{name:"Ruby",aliases:["rb","gemspec","podspec","thor","irb"],keywords:r,illegal:/\/\*/,contains:[e.SHEBANG({binary:"ruby"})].concat(f).concat(l).concat(p)}}},9880:e=>{e.exports=function(e){const n=e.regex,t={className:"title.function.invoke",relevance:0,begin:n.concat(/\b/,/(?!let\b)/,e.IDENT_RE,n.lookahead(/\s*\(/))},i="([ui](8|16|32|64|128|size)|f(32|64))?",a=["drop ","Copy","Send","Sized","Sync","Drop","Fn","FnMut","FnOnce","ToOwned","Clone","Debug","PartialEq","PartialOrd","Eq","Ord","AsRef","AsMut","Into","From","Default","Iterator","Extend","IntoIterator","DoubleEndedIterator","ExactSizeIterator","SliceConcatExt","ToString","assert!","assert_eq!","bitflags!","bytes!","cfg!","col!","concat!","concat_idents!","debug_assert!","debug_assert_eq!","env!","panic!","file!","format!","format_args!","include_bytes!","include_str!","line!","local_data_key!","module_path!","option_env!","print!","println!","select!","stringify!","try!","unimplemented!","unreachable!","vec!","write!","writeln!","macro_rules!","assert_ne!","debug_assert_ne!"],r=["i8","i16","i32","i64","i128","isize","u8","u16","u32","u64","u128","usize","f32","f64","str","char","bool","Box","Option","Result","String","Vec"];return{name:"Rust",aliases:["rs"],keywords:{$pattern:e.IDENT_RE+"!?",type:r,keyword:["abstract","as","async","await","become","box","break","const","continue","crate","do","dyn","else","enum","extern","false","final","fn","for","if","impl","in","let","loop","macro","match","mod","move","mut","override","priv","pub","ref","return","self","Self","static","struct","super","trait","true","try","type","typeof","unsafe","unsized","use","virtual","where","while","yield"],literal:["true","false","Some","None","Ok","Err"],built_in:a},illegal:"</",contains:[e.C_LINE_COMMENT_MODE,e.COMMENT("/\\*","\\*/",{contains:["self"]}),e.inherit(e.QUOTE_STRING_MODE,{begin:/b?"/,illegal:null}),{className:"string",variants:[{begin:/b?r(#*)"(.|\n)*?"\1(?!#)/},{begin:/b?'\\?(x\w{2}|u\w{4}|U\w{8}|.)'/}]},{className:"symbol",begin:/'[a-zA-Z_][a-zA-Z0-9_]*/},{className:"number",variants:[{begin:"\\b0b([01_]+)"+i},{begin:"\\b0o([0-7_]+)"+i},{begin:"\\b0x([A-Fa-f0-9_]+)"+i},{begin:"\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)"+i}],relevance:0},{begin:[/fn/,/\s+/,e.UNDERSCORE_IDENT_RE],className:{1:"keyword",3:"title.function"}},{className:"meta",begin:"#!?\\[",end:"\\]",contains:[{className:"string",begin:/"/,end:/"/}]},{begin:[/let/,/\s+/,/(?:mut\s+)?/,e.UNDERSCORE_IDENT_RE],className:{1:"keyword",3:"keyword",4:"variable"}},{begin:[/for/,/\s+/,e.UNDERSCORE_IDENT_RE,/\s+/,/in/],className:{1:"keyword",3:"variable",5:"keyword"}},{begin:[/type/,/\s+/,e.UNDERSCORE_IDENT_RE],className:{1:"keyword",3:"title.class"}},{begin:[/(?:trait|enum|struct|union|impl|for)/,/\s+/,e.UNDERSCORE_IDENT_RE],className:{1:"keyword",3:"title.class"}},{begin:e.IDENT_RE+"::",keywords:{keyword:"Self",built_in:a,type:r}},{className:"punctuation",begin:"->"},t]}}},729:e=>{e.exports=function(e){const n=e.regex,t={className:"subst",variants:[{begin:"\\$[A-Za-z0-9_]+"},{begin:/\$\{/,end:/\}/}]},i={className:"string",variants:[{begin:'"""',end:'"""'},{begin:'"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{begin:'[a-z]+"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE,t]},{className:"string",begin:'[a-z]+"""',end:'"""',contains:[t],relevance:10}]},a={className:"type",begin:"\\b[A-Z][A-Za-z0-9_]*",relevance:0},r={className:"title",begin:/[^0-9\n\t "'(),.`{}\[\]:;][^\n\t "'(),.`{}\[\]:;]+|[^0-9\n\t "'(),.`{}\[\]:;=]/,relevance:0},s={className:"class",beginKeywords:"class object trait type",end:/[:={\[\n;]/,excludeEnd:!0,contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{beginKeywords:"extends with",relevance:10},{begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[a]},{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,relevance:0,contains:[a]},r]},o={className:"function",beginKeywords:"def",end:n.lookahead(/[:={\[(\n;]/),contains:[r]};return{name:"Scala",keywords:{literal:"true false null",keyword:"type yield lazy override def with val var sealed abstract private trait object if then forSome for while do throw finally protected extends import final return else break new catch super class case package default try this match continue throws implicit export enum given transparent"},contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,i,a,o,s,e.C_NUMBER_MODE,{begin:[/^\s*/,"extension",/\s+(?=[[(])/],beginScope:{2:"keyword"}},{begin:[/^\s*/,/end/,/\s+/,/(extension\b)?/],beginScope:{2:"keyword",4:"keyword"}},{match:/\.inline\b/},{begin:/\binline(?=\s)/,keywords:"inline"},{begin:[/\(\s*/,/using/,/\s+(?!\))/],beginScope:{2:"keyword"}},{className:"meta",begin:"@[A-Za-z]+"}]}}},1062:e=>{const n=["a","abbr","address","article","aside","audio","b","blockquote","body","button","canvas","caption","cite","code","dd","del","details","dfn","div","dl","dt","em","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","html","i","iframe","img","input","ins","kbd","label","legend","li","main","mark","menu","nav","object","ol","p","q","quote","samp","section","span","strong","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","tr","ul","var","video"],t=["any-hover","any-pointer","aspect-ratio","color","color-gamut","color-index","device-aspect-ratio","device-height","device-width","display-mode","forced-colors","grid","height","hover","inverted-colors","monochrome","orientation","overflow-block","overflow-inline","pointer","prefers-color-scheme","prefers-contrast","prefers-reduced-motion","prefers-reduced-transparency","resolution","scan","scripting","update","width","min-width","max-width","min-height","max-height"],i=["active","any-link","blank","checked","current","default","defined","dir","disabled","drop","empty","enabled","first","first-child","first-of-type","fullscreen","future","focus","focus-visible","focus-within","has","host","host-context","hover","indeterminate","in-range","invalid","is","lang","last-child","last-of-type","left","link","local-link","not","nth-child","nth-col","nth-last-child","nth-last-col","nth-last-of-type","nth-of-type","only-child","only-of-type","optional","out-of-range","past","placeholder-shown","read-only","read-write","required","right","root","scope","target","target-within","user-invalid","valid","visited","where"],a=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"],r=["align-content","align-items","align-self","all","animation","animation-delay","animation-direction","animation-duration","animation-fill-mode","animation-iteration-count","animation-name","animation-play-state","animation-timing-function","backface-visibility","background","background-attachment","background-blend-mode","background-clip","background-color","background-image","background-origin","background-position","background-repeat","background-size","block-size","border","border-block","border-block-color","border-block-end","border-block-end-color","border-block-end-style","border-block-end-width","border-block-start","border-block-start-color","border-block-start-style","border-block-start-width","border-block-style","border-block-width","border-bottom","border-bottom-color","border-bottom-left-radius","border-bottom-right-radius","border-bottom-style","border-bottom-width","border-collapse","border-color","border-image","border-image-outset","border-image-repeat","border-image-slice","border-image-source","border-image-width","border-inline","border-inline-color","border-inline-end","border-inline-end-color","border-inline-end-style","border-inline-end-width","border-inline-start","border-inline-start-color","border-inline-start-style","border-inline-start-width","border-inline-style","border-inline-width","border-left","border-left-color","border-left-style","border-left-width","border-radius","border-right","border-right-color","border-right-style","border-right-width","border-spacing","border-style","border-top","border-top-color","border-top-left-radius","border-top-right-radius","border-top-style","border-top-width","border-width","bottom","box-decoration-break","box-shadow","box-sizing","break-after","break-before","break-inside","caption-side","caret-color","clear","clip","clip-path","clip-rule","color","column-count","column-fill","column-gap","column-rule","column-rule-color","column-rule-style","column-rule-width","column-span","column-width","columns","contain","content","content-visibility","counter-increment","counter-reset","cue","cue-after","cue-before","cursor","direction","display","empty-cells","filter","flex","flex-basis","flex-direction","flex-flow","flex-grow","flex-shrink","flex-wrap","float","flow","font","font-display","font-family","font-feature-settings","font-kerning","font-language-override","font-size","font-size-adjust","font-smoothing","font-stretch","font-style","font-synthesis","font-variant","font-variant-caps","font-variant-east-asian","font-variant-ligatures","font-variant-numeric","font-variant-position","font-variation-settings","font-weight","gap","glyph-orientation-vertical","grid","grid-area","grid-auto-columns","grid-auto-flow","grid-auto-rows","grid-column","grid-column-end","grid-column-start","grid-gap","grid-row","grid-row-end","grid-row-start","grid-template","grid-template-areas","grid-template-columns","grid-template-rows","hanging-punctuation","height","hyphens","icon","image-orientation","image-rendering","image-resolution","ime-mode","inline-size","isolation","justify-content","left","letter-spacing","line-break","line-height","list-style","list-style-image","list-style-position","list-style-type","margin","margin-block","margin-block-end","margin-block-start","margin-bottom","margin-inline","margin-inline-end","margin-inline-start","margin-left","margin-right","margin-top","marks","mask","mask-border","mask-border-mode","mask-border-outset","mask-border-repeat","mask-border-slice","mask-border-source","mask-border-width","mask-clip","mask-composite","mask-image","mask-mode","mask-origin","mask-position","mask-repeat","mask-size","mask-type","max-block-size","max-height","max-inline-size","max-width","min-block-size","min-height","min-inline-size","min-width","mix-blend-mode","nav-down","nav-index","nav-left","nav-right","nav-up","none","normal","object-fit","object-position","opacity","order","orphans","outline","outline-color","outline-offset","outline-style","outline-width","overflow","overflow-wrap","overflow-x","overflow-y","padding","padding-block","padding-block-end","padding-block-start","padding-bottom","padding-inline","padding-inline-end","padding-inline-start","padding-left","padding-right","padding-top","page-break-after","page-break-before","page-break-inside","pause","pause-after","pause-before","perspective","perspective-origin","pointer-events","position","quotes","resize","rest","rest-after","rest-before","right","row-gap","scroll-margin","scroll-margin-block","scroll-margin-block-end","scroll-margin-block-start","scroll-margin-bottom","scroll-margin-inline","scroll-margin-inline-end","scroll-margin-inline-start","scroll-margin-left","scroll-margin-right","scroll-margin-top","scroll-padding","scroll-padding-block","scroll-padding-block-end","scroll-padding-block-start","scroll-padding-bottom","scroll-padding-inline","scroll-padding-inline-end","scroll-padding-inline-start","scroll-padding-left","scroll-padding-right","scroll-padding-top","scroll-snap-align","scroll-snap-stop","scroll-snap-type","scrollbar-color","scrollbar-gutter","scrollbar-width","shape-image-threshold","shape-margin","shape-outside","speak","speak-as","src","tab-size","table-layout","text-align","text-align-all","text-align-last","text-combine-upright","text-decoration","text-decoration-color","text-decoration-line","text-decoration-style","text-emphasis","text-emphasis-color","text-emphasis-position","text-emphasis-style","text-indent","text-justify","text-orientation","text-overflow","text-rendering","text-shadow","text-transform","text-underline-position","top","transform","transform-box","transform-origin","transform-style","transition","transition-delay","transition-duration","transition-property","transition-timing-function","unicode-bidi","vertical-align","visibility","voice-balance","voice-duration","voice-family","voice-pitch","voice-range","voice-rate","voice-stress","voice-volume","white-space","widows","width","will-change","word-break","word-spacing","word-wrap","writing-mode","z-index"].reverse();e.exports=function(e){const s=(e=>({IMPORTANT:{scope:"meta",begin:"!important"},BLOCK_COMMENT:e.C_BLOCK_COMMENT_MODE,HEXCOLOR:{scope:"number",begin:/#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/},FUNCTION_DISPATCH:{className:"built_in",begin:/[\w-]+(?=\()/},ATTRIBUTE_SELECTOR_MODE:{scope:"selector-attr",begin:/\[/,end:/\]/,illegal:"$",contains:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{scope:"number",begin:e.NUMBER_RE+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",relevance:0},CSS_VARIABLE:{className:"attr",begin:/--[A-Za-z][A-Za-z0-9_-]*/}}))(e),o=a,l=i,c="@[a-z-]+",d={className:"variable",begin:"(\\$[a-zA-Z-][a-zA-Z0-9_-]*)\\b",relevance:0};return{name:"SCSS",case_insensitive:!0,illegal:"[=/|']",contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,s.CSS_NUMBER_MODE,{className:"selector-id",begin:"#[A-Za-z0-9_-]+",relevance:0},{className:"selector-class",begin:"\\.[A-Za-z0-9_-]+",relevance:0},s.ATTRIBUTE_SELECTOR_MODE,{className:"selector-tag",begin:"\\b("+n.join("|")+")\\b",relevance:0},{className:"selector-pseudo",begin:":("+l.join("|")+")"},{className:"selector-pseudo",begin:":(:)?("+o.join("|")+")"},d,{begin:/\(/,end:/\)/,contains:[s.CSS_NUMBER_MODE]},s.CSS_VARIABLE,{className:"attribute",begin:"\\b("+r.join("|")+")\\b"},{begin:"\\b(whitespace|wait|w-resize|visible|vertical-text|vertical-ideographic|uppercase|upper-roman|upper-alpha|underline|transparent|top|thin|thick|text|text-top|text-bottom|tb-rl|table-header-group|table-footer-group|sw-resize|super|strict|static|square|solid|small-caps|separate|se-resize|scroll|s-resize|rtl|row-resize|ridge|right|repeat|repeat-y|repeat-x|relative|progress|pointer|overline|outside|outset|oblique|nowrap|not-allowed|normal|none|nw-resize|no-repeat|no-drop|newspaper|ne-resize|n-resize|move|middle|medium|ltr|lr-tb|lowercase|lower-roman|lower-alpha|loose|list-item|line|line-through|line-edge|lighter|left|keep-all|justify|italic|inter-word|inter-ideograph|inside|inset|inline|inline-block|inherit|inactive|ideograph-space|ideograph-parenthesis|ideograph-numeric|ideograph-alpha|horizontal|hidden|help|hand|groove|fixed|ellipsis|e-resize|double|dotted|distribute|distribute-space|distribute-letter|distribute-all-lines|disc|disabled|default|decimal|dashed|crosshair|collapse|col-resize|circle|char|center|capitalize|break-word|break-all|bottom|both|bolder|bold|block|bidi-override|below|baseline|auto|always|all-scroll|absolute|table|table-cell)\\b"},{begin:/:/,end:/[;}{]/,relevance:0,contains:[s.BLOCK_COMMENT,d,s.HEXCOLOR,s.CSS_NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,s.IMPORTANT,s.FUNCTION_DISPATCH]},{begin:"@(page|font-face)",keywords:{$pattern:c,keyword:"@page @font-face"}},{begin:"@",end:"[{;]",returnBegin:!0,keywords:{$pattern:/[a-z-]+/,keyword:"and or not only",attribute:t.join(" ")},contains:[{begin:c,className:"keyword"},{begin:/[a-z-]+(?=:)/,className:"attribute"},d,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,s.HEXCOLOR,s.CSS_NUMBER_MODE]},s.FUNCTION_DISPATCH]}}},7874:e=>{e.exports=function(e){return{name:"Shell Session",aliases:["console","shellsession"],contains:[{className:"meta.prompt",begin:/^\s{0,3}[/~\w\d[\]()@-]*[>%$#][ ]?/,starts:{end:/[^\\](?=\s*$)/,subLanguage:"bash"}}]}}},8935:e=>{e.exports=function(e){const n=e.regex,t=e.COMMENT("--","$"),i=["true","false","unknown"],a=["bigint","binary","blob","boolean","char","character","clob","date","dec","decfloat","decimal","float","int","integer","interval","nchar","nclob","national","numeric","real","row","smallint","time","timestamp","varchar","varying","varbinary"],r=["abs","acos","array_agg","asin","atan","avg","cast","ceil","ceiling","coalesce","corr","cos","cosh","count","covar_pop","covar_samp","cume_dist","dense_rank","deref","element","exp","extract","first_value","floor","json_array","json_arrayagg","json_exists","json_object","json_objectagg","json_query","json_table","json_table_primitive","json_value","lag","last_value","lead","listagg","ln","log","log10","lower","max","min","mod","nth_value","ntile","nullif","percent_rank","percentile_cont","percentile_disc","position","position_regex","power","rank","regr_avgx","regr_avgy","regr_count","regr_intercept","regr_r2","regr_slope","regr_sxx","regr_sxy","regr_syy","row_number","sin","sinh","sqrt","stddev_pop","stddev_samp","substring","substring_regex","sum","tan","tanh","translate","translate_regex","treat","trim","trim_array","unnest","upper","value_of","var_pop","var_samp","width_bucket"],s=["create table","insert into","primary key","foreign key","not null","alter table","add constraint","grouping sets","on overflow","character set","respect nulls","ignore nulls","nulls first","nulls last","depth first","breadth first"],o=r,l=["abs","acos","all","allocate","alter","and","any","are","array","array_agg","array_max_cardinality","as","asensitive","asin","asymmetric","at","atan","atomic","authorization","avg","begin","begin_frame","begin_partition","between","bigint","binary","blob","boolean","both","by","call","called","cardinality","cascaded","case","cast","ceil","ceiling","char","char_length","character","character_length","check","classifier","clob","close","coalesce","collate","collect","column","commit","condition","connect","constraint","contains","convert","copy","corr","corresponding","cos","cosh","count","covar_pop","covar_samp","create","cross","cube","cume_dist","current","current_catalog","current_date","current_default_transform_group","current_path","current_role","current_row","current_schema","current_time","current_timestamp","current_path","current_role","current_transform_group_for_type","current_user","cursor","cycle","date","day","deallocate","dec","decimal","decfloat","declare","default","define","delete","dense_rank","deref","describe","deterministic","disconnect","distinct","double","drop","dynamic","each","element","else","empty","end","end_frame","end_partition","end-exec","equals","escape","every","except","exec","execute","exists","exp","external","extract","false","fetch","filter","first_value","float","floor","for","foreign","frame_row","free","from","full","function","fusion","get","global","grant","group","grouping","groups","having","hold","hour","identity","in","indicator","initial","inner","inout","insensitive","insert","int","integer","intersect","intersection","interval","into","is","join","json_array","json_arrayagg","json_exists","json_object","json_objectagg","json_query","json_table","json_table_primitive","json_value","lag","language","large","last_value","lateral","lead","leading","left","like","like_regex","listagg","ln","local","localtime","localtimestamp","log","log10","lower","match","match_number","match_recognize","matches","max","member","merge","method","min","minute","mod","modifies","module","month","multiset","national","natural","nchar","nclob","new","no","none","normalize","not","nth_value","ntile","null","nullif","numeric","octet_length","occurrences_regex","of","offset","old","omit","on","one","only","open","or","order","out","outer","over","overlaps","overlay","parameter","partition","pattern","per","percent","percent_rank","percentile_cont","percentile_disc","period","portion","position","position_regex","power","precedes","precision","prepare","primary","procedure","ptf","range","rank","reads","real","recursive","ref","references","referencing","regr_avgx","regr_avgy","regr_count","regr_intercept","regr_r2","regr_slope","regr_sxx","regr_sxy","regr_syy","release","result","return","returns","revoke","right","rollback","rollup","row","row_number","rows","running","savepoint","scope","scroll","search","second","seek","select","sensitive","session_user","set","show","similar","sin","sinh","skip","smallint","some","specific","specifictype","sql","sqlexception","sqlstate","sqlwarning","sqrt","start","static","stddev_pop","stddev_samp","submultiset","subset","substring","substring_regex","succeeds","sum","symmetric","system","system_time","system_user","table","tablesample","tan","tanh","then","time","timestamp","timezone_hour","timezone_minute","to","trailing","translate","translate_regex","translation","treat","trigger","trim","trim_array","true","truncate","uescape","union","unique","unknown","unnest","update","upper","user","using","value","values","value_of","var_pop","var_samp","varbinary","varchar","varying","versioning","when","whenever","where","width_bucket","window","with","within","without","year","add","asc","collation","desc","final","first","last","view"].filter((e=>!r.includes(e))),c={begin:n.concat(/\b/,n.either(...o),/\s*\(/),relevance:0,keywords:{built_in:o}};return{name:"SQL",case_insensitive:!0,illegal:/[{}]|<\//,keywords:{$pattern:/\b[\w\.]+/,keyword:function(e,{exceptions:n,when:t}={}){const i=t;return n=n||[],e.map((e=>e.match(/\|\d+$/)||n.includes(e)?e:i(e)?`${e}|0`:e))}(l,{when:e=>e.length<3}),literal:i,type:a,built_in:["current_catalog","current_date","current_default_transform_group","current_path","current_role","current_schema","current_transform_group_for_type","current_user","session_user","system_time","system_user","current_time","localtime","current_timestamp","localtimestamp"]},contains:[{begin:n.either(...s),relevance:0,keywords:{$pattern:/[\w\.]+/,keyword:l.concat(s),literal:i,type:a}},{className:"type",begin:n.either("double precision","large object","with timezone","without timezone")},c,{className:"variable",begin:/@[a-z0-9][a-z0-9_]*/},{className:"string",variants:[{begin:/'/,end:/'/,contains:[{begin:/''/}]}]},{begin:/"/,end:/"/,contains:[{begin:/""/}]},e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,t,{className:"operator",begin:/[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,relevance:0}]}}},7690:e=>{function n(e){return e?"string"==typeof e?e:e.source:null}function t(e){return i("(?=",e,")")}function i(...e){return e.map((e=>n(e))).join("")}function a(...e){const t=function(e){const n=e[e.length-1];return"object"==typeof n&&n.constructor===Object?(e.splice(e.length-1,1),n):{}}(e);return"("+(t.capture?"":"?:")+e.map((e=>n(e))).join("|")+")"}const r=e=>i(/\b/,e,/\w$/.test(e)?/\b/:/\B/),s=["Protocol","Type"].map(r),o=["init","self"].map(r),l=["Any","Self"],c=["actor","any","associatedtype","async","await",/as\?/,/as!/,"as","break","case","catch","class","continue","convenience","default","defer","deinit","didSet","distributed","do","dynamic","else","enum","extension","fallthrough",/fileprivate\(set\)/,"fileprivate","final","for","func","get","guard","if","import","indirect","infix",/init\?/,/init!/,"inout",/internal\(set\)/,"internal","in","is","isolated","nonisolated","lazy","let","mutating","nonmutating",/open\(set\)/,"open","operator","optional","override","postfix","precedencegroup","prefix",/private\(set\)/,"private","protocol",/public\(set\)/,"public","repeat","required","rethrows","return","set","some","static","struct","subscript","super","switch","throws","throw",/try\?/,/try!/,"try","typealias",/unowned\(safe\)/,/unowned\(unsafe\)/,"unowned","var","weak","where","while","willSet"],d=["false","nil","true"],u=["assignment","associativity","higherThan","left","lowerThan","none","right"],g=["#colorLiteral","#column","#dsohandle","#else","#elseif","#endif","#error","#file","#fileID","#fileLiteral","#filePath","#function","#if","#imageLiteral","#keyPath","#line","#selector","#sourceLocation","#warn_unqualified_access","#warning"],b=["abs","all","any","assert","assertionFailure","debugPrint","dump","fatalError","getVaList","isKnownUniquelyReferenced","max","min","numericCast","pointwiseMax","pointwiseMin","precondition","preconditionFailure","print","readLine","repeatElement","sequence","stride","swap","swift_unboxFromSwiftValueWithType","transcode","type","unsafeBitCast","unsafeDowncast","withExtendedLifetime","withUnsafeMutablePointer","withUnsafePointer","withVaList","withoutActuallyEscaping","zip"],p=a(/[/=\-+!*%<>&|^~?]/,/[\u00A1-\u00A7]/,/[\u00A9\u00AB]/,/[\u00AC\u00AE]/,/[\u00B0\u00B1]/,/[\u00B6\u00BB\u00BF\u00D7\u00F7]/,/[\u2016-\u2017]/,/[\u2020-\u2027]/,/[\u2030-\u203E]/,/[\u2041-\u2053]/,/[\u2055-\u205E]/,/[\u2190-\u23FF]/,/[\u2500-\u2775]/,/[\u2794-\u2BFF]/,/[\u2E00-\u2E7F]/,/[\u3001-\u3003]/,/[\u3008-\u3020]/,/[\u3030]/),f=a(p,/[\u0300-\u036F]/,/[\u1DC0-\u1DFF]/,/[\u20D0-\u20FF]/,/[\uFE00-\uFE0F]/,/[\uFE20-\uFE2F]/),m=i(p,f,"*"),E=a(/[a-zA-Z_]/,/[\u00A8\u00AA\u00AD\u00AF\u00B2-\u00B5\u00B7-\u00BA]/,/[\u00BC-\u00BE\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]/,/[\u0100-\u02FF\u0370-\u167F\u1681-\u180D\u180F-\u1DBF]/,/[\u1E00-\u1FFF]/,/[\u200B-\u200D\u202A-\u202E\u203F-\u2040\u2054\u2060-\u206F]/,/[\u2070-\u20CF\u2100-\u218F\u2460-\u24FF\u2776-\u2793]/,/[\u2C00-\u2DFF\u2E80-\u2FFF]/,/[\u3004-\u3007\u3021-\u302F\u3031-\u303F\u3040-\uD7FF]/,/[\uF900-\uFD3D\uFD40-\uFDCF\uFDF0-\uFE1F\uFE30-\uFE44]/,/[\uFE47-\uFEFE\uFF00-\uFFFD]/),h=a(E,/\d/,/[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/),_=i(E,h,"*"),N=i(/[A-Z]/,h,"*"),T=["autoclosure",i(/convention\(/,a("swift","block","c"),/\)/),"discardableResult","dynamicCallable","dynamicMemberLookup","escaping","frozen","GKInspectable","IBAction","IBDesignable","IBInspectable","IBOutlet","IBSegueAction","inlinable","main","nonobjc","NSApplicationMain","NSCopying","NSManaged",i(/objc\(/,_,/\)/),"objc","objcMembers","propertyWrapper","requires_stored_property_inits","resultBuilder","testable","UIApplicationMain","unknown","usableFromInline"],O=["iOS","iOSApplicationExtension","macOS","macOSApplicationExtension","macCatalyst","macCatalystApplicationExtension","watchOS","watchOSApplicationExtension","tvOS","tvOSApplicationExtension","swift"];e.exports=function(e){const n={match:/\s+/,relevance:0},p=e.COMMENT("/\\*","\\*/",{contains:["self"]}),E=[e.C_LINE_COMMENT_MODE,p],A={match:[/\./,a(...s,...o)],className:{2:"keyword"}},v={match:i(/\./,a(...c)),relevance:0},y=c.filter((e=>"string"==typeof e)).concat(["_|0"]),S={variants:[{className:"keyword",match:a(...c.filter((e=>"string"!=typeof e)).concat(l).map(r),...o)}]},R={$pattern:a(/\b\w+/,/#\w+/),keyword:y.concat(g),literal:d},I=[A,v,S],w=[{match:i(/\./,a(...b)),relevance:0},{className:"built_in",match:i(/\b/,a(...b),/(?=\()/)}],C={match:/->/,relevance:0},L=[C,{className:"operator",relevance:0,variants:[{match:m},{match:`\\.(\\.|${f})+`}]}],M="([0-9]_*)+",D="([0-9a-fA-F]_*)+",x={className:"number",relevance:0,variants:[{match:`\\b(${M})(\\.(${M}))?([eE][+-]?(${M}))?\\b`},{match:`\\b0x(${D})(\\.(${D}))?([pP][+-]?(${M}))?\\b`},{match:/\b0o([0-7]_*)+\b/},{match:/\b0b([01]_*)+\b/}]},k=(e="")=>({className:"subst",variants:[{match:i(/\\/,e,/[0\\tnr"']/)},{match:i(/\\/,e,/u\{[0-9a-fA-F]{1,8}\}/)}]}),P=(e="")=>({className:"subst",match:i(/\\/,e,/[\t ]*(?:[\r\n]|\r\n)/)}),U=(e="")=>({className:"subst",label:"interpol",begin:i(/\\/,e,/\(/),end:/\)/}),B=(e="")=>({begin:i(e,/"""/),end:i(/"""/,e),contains:[k(e),P(e),U(e)]}),F=(e="")=>({begin:i(e,/"/),end:i(/"/,e),contains:[k(e),U(e)]}),j={className:"string",variants:[B(),B("#"),B("##"),B("###"),F(),F("#"),F("##"),F("###")]},H={match:i(/`/,_,/`/)},G=[H,{className:"variable",match:/\$\d+/},{className:"variable",match:`\\$${h}+`}],$=[{match:/(@|#(un)?)available/,className:"keyword",starts:{contains:[{begin:/\(/,end:/\)/,keywords:O,contains:[...L,x,j]}]}},{className:"keyword",match:i(/@/,a(...T))},{className:"meta",match:i(/@/,_)}],z={match:t(/\b[A-Z]/),relevance:0,contains:[{className:"type",match:i(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/,h,"+")},{className:"type",match:N,relevance:0},{match:/[?!]+/,relevance:0},{match:/\.\.\./,relevance:0},{match:i(/\s+&\s+/,t(N)),relevance:0}]},V={begin:/</,end:/>/,keywords:R,contains:[...E,...I,...$,C,z]};z.contains.push(V);const K={begin:/\(/,end:/\)/,relevance:0,keywords:R,contains:["self",{match:i(_,/\s*:/),keywords:"_|0",relevance:0},...E,...I,...w,...L,x,j,...G,...$,z]},W={begin:/</,end:/>/,contains:[...E,z]},q={begin:/\(/,end:/\)/,keywords:R,contains:[{begin:a(t(i(_,/\s*:/)),t(i(_,/\s+/,_,/\s*:/))),end:/:/,relevance:0,contains:[{className:"keyword",match:/\b_\b/},{className:"params",match:_}]},...E,...I,...L,x,j,...$,z,K],endsParent:!0,illegal:/["']/},X={match:[/func/,/\s+/,a(H.match,_,m)],className:{1:"keyword",3:"title.function"},contains:[W,q,n],illegal:[/\[/,/%/]},Y={match:[/\b(?:subscript|init[?!]?)/,/\s*(?=[<(])/],className:{1:"keyword"},contains:[W,q,n],illegal:/\[|%/},Z={match:[/operator/,/\s+/,m],className:{1:"keyword",3:"title"}},Q={begin:[/precedencegroup/,/\s+/,N],className:{1:"keyword",3:"title"},contains:[z],keywords:[...u,...d],end:/}/};for(const e of j.variants){const n=e.contains.find((e=>"interpol"===e.label));n.keywords=R;const t=[...I,...w,...L,x,j,...G];n.contains=[...t,{begin:/\(/,end:/\)/,contains:["self",...t]}]}return{name:"Swift",keywords:R,contains:[...E,X,Y,{beginKeywords:"struct protocol class extension enum actor",end:"\\{",excludeEnd:!0,keywords:R,contains:[e.inherit(e.TITLE_MODE,{className:"title.class",begin:/[A-Za-z$_][\u00C0-\u02B80-9A-Za-z$_]*/}),...I]},Z,Q,{beginKeywords:"import",end:/$/,contains:[...E],relevance:0},...I,...w,...L,x,j,...G,...$,z,K]}}},8987:e=>{const n="[A-Za-z$_][0-9A-Za-z$_]*",t=["as","in","of","if","for","while","finally","var","new","function","do","return","void","else","break","catch","instanceof","with","throw","case","default","try","switch","continue","typeof","delete","let","yield","const","class","debugger","async","await","static","import","from","export","extends"],i=["true","false","null","undefined","NaN","Infinity"],a=["Object","Function","Boolean","Symbol","Math","Date","Number","BigInt","String","RegExp","Array","Float32Array","Float64Array","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Int32Array","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array","Set","Map","WeakSet","WeakMap","ArrayBuffer","SharedArrayBuffer","Atomics","DataView","JSON","Promise","Generator","GeneratorFunction","AsyncFunction","Reflect","Proxy","Intl","WebAssembly"],r=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],s=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],o=["arguments","this","super","console","window","document","localStorage","sessionStorage","module","global"],l=[].concat(s,a,r);function c(e){const c=e.regex,d=n,u={begin:/<[A-Za-z0-9\\._:-]+/,end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(e,n)=>{const t=e[0].length+e.index,i=e.input[t];if("<"===i||","===i)return void n.ignoreMatch();let a;">"===i&&(((e,{after:n})=>{const t="</"+e[0].slice(1);return-1!==e.input.indexOf(t,n)})(e,{after:t})||n.ignoreMatch());const r=e.input.substring(t);((a=r.match(/^\s*=/))||(a=r.match(/^\s+extends\s+/))&&0===a.index)&&n.ignoreMatch()}},g={$pattern:n,keyword:t,literal:i,built_in:l,"variable.language":o},b="[0-9](_?[0-9])*",p=`\\.(${b})`,f="0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",m={className:"number",variants:[{begin:`(\\b(${f})((${p})|\\.)?|(${p}))[eE][+-]?(${b})\\b`},{begin:`\\b(${f})\\b((${p})\\b|\\.)?|(${p})\\b`},{begin:"\\b(0|[1-9](_?[0-9])*)n\\b"},{begin:"\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b"},{begin:"\\b0[bB][0-1](_?[0-1])*n?\\b"},{begin:"\\b0[oO][0-7](_?[0-7])*n?\\b"},{begin:"\\b0[0-7]+n?\\b"}],relevance:0},E={className:"subst",begin:"\\$\\{",end:"\\}",keywords:g,contains:[]},h={begin:"html`",end:"",starts:{end:"`",returnEnd:!1,contains:[e.BACKSLASH_ESCAPE,E],subLanguage:"xml"}},_={begin:"css`",end:"",starts:{end:"`",returnEnd:!1,contains:[e.BACKSLASH_ESCAPE,E],subLanguage:"css"}},N={begin:"gql`",end:"",starts:{end:"`",returnEnd:!1,contains:[e.BACKSLASH_ESCAPE,E],subLanguage:"graphql"}},T={className:"string",begin:"`",end:"`",contains:[e.BACKSLASH_ESCAPE,E]},O={className:"comment",variants:[e.COMMENT(/\/\*\*(?!\/)/,"\\*/",{relevance:0,contains:[{begin:"(?=@[A-Za-z]+)",relevance:0,contains:[{className:"doctag",begin:"@[A-Za-z]+"},{className:"type",begin:"\\{",end:"\\}",excludeEnd:!0,excludeBegin:!0,relevance:0},{className:"variable",begin:d+"(?=\\s*(-)|$)",endsParent:!0,relevance:0},{begin:/(?=[^\n])\s/,relevance:0}]}]}),e.C_BLOCK_COMMENT_MODE,e.C_LINE_COMMENT_MODE]},A=[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,h,_,N,T,{match:/\$\d+/},m];E.contains=A.concat({begin:/\{/,end:/\}/,keywords:g,contains:["self"].concat(A)});const v=[].concat(O,E.contains),y=v.concat([{begin:/\(/,end:/\)/,keywords:g,contains:["self"].concat(v)}]),S={className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:g,contains:y},R={variants:[{match:[/class/,/\s+/,d,/\s+/,/extends/,/\s+/,c.concat(d,"(",c.concat(/\./,d),")*")],scope:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},{match:[/class/,/\s+/,d],scope:{1:"keyword",3:"title.class"}}]},I={relevance:0,match:c.either(/\bJSON/,/\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,/\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,/\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/),className:"title.class",keywords:{_:[...a,...r]}},w={variants:[{match:[/function/,/\s+/,d,/(?=\s*\()/]},{match:[/function/,/\s*(?=\()/]}],className:{1:"keyword",3:"title.function"},label:"func.def",contains:[S],illegal:/%/},C={match:c.concat(/\b/,(L=[...s,"super","import"],c.concat("(?!",L.join("|"),")")),d,c.lookahead(/\(/)),className:"title.function",relevance:0};var L;const M={begin:c.concat(/\./,c.lookahead(c.concat(d,/(?![0-9A-Za-z$_(])/))),end:d,excludeBegin:!0,keywords:"prototype",className:"property",relevance:0},D={match:[/get|set/,/\s+/,d,/(?=\()/],className:{1:"keyword",3:"title.function"},contains:[{begin:/\(\)/},S]},x="(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|"+e.UNDERSCORE_IDENT_RE+")\\s*=>",k={match:[/const|var|let/,/\s+/,d,/\s*/,/=\s*/,/(async\s*)?/,c.lookahead(x)],keywords:"async",className:{1:"keyword",3:"title.function"},contains:[S]};return{name:"JavaScript",aliases:["js","jsx","mjs","cjs"],keywords:g,exports:{PARAMS_CONTAINS:y,CLASS_REFERENCE:I},illegal:/#(?![$_A-z])/,contains:[e.SHEBANG({label:"shebang",binary:"node",relevance:5}),{label:"use_strict",className:"meta",relevance:10,begin:/^\s*['"]use (strict|asm)['"]/},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,h,_,N,T,O,{match:/\$\d+/},m,I,{className:"attr",begin:d+c.lookahead(":"),relevance:0},k,{begin:"("+e.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",keywords:"return throw case",relevance:0,contains:[O,e.REGEXP_MODE,{className:"function",begin:x,returnBegin:!0,end:"\\s*=>",contains:[{className:"params",variants:[{begin:e.UNDERSCORE_IDENT_RE,relevance:0},{className:null,begin:/\(\s*\)/,skip:!0},{begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:g,contains:y}]}]},{begin:/,/,relevance:0},{match:/\s+/,relevance:0},{variants:[{begin:"<>",end:"</>"},{match:/<[A-Za-z0-9\\._:-]+\s*\/>/},{begin:u.begin,"on:begin":u.isTrulyOpeningTag,end:u.end}],subLanguage:"xml",contains:[{begin:u.begin,end:u.end,skip:!0,contains:["self"]}]}]},w,{beginKeywords:"while if switch catch for"},{begin:"\\b(?!function)"+e.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",returnBegin:!0,label:"func.def",contains:[S,e.inherit(e.TITLE_MODE,{begin:d,className:"title.function"})]},{match:/\.\.\./,relevance:0},M,{match:"\\$"+d,relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"},contains:[S]},C,{relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,className:"variable.constant"},R,D,{match:/\$[(.]/}]}}e.exports=function(e){const a=c(e),r=n,s=["any","void","number","boolean","string","object","never","symbol","bigint","unknown"],d={beginKeywords:"namespace",end:/\{/,excludeEnd:!0,contains:[a.exports.CLASS_REFERENCE]},u={beginKeywords:"interface",end:/\{/,excludeEnd:!0,keywords:{keyword:"interface extends",built_in:s},contains:[a.exports.CLASS_REFERENCE]},g={$pattern:n,keyword:t.concat(["type","namespace","interface","public","private","protected","implements","declare","abstract","readonly","enum","override"]),literal:i,built_in:l.concat(s),"variable.language":o},b={className:"meta",begin:"@"+r},p=(e,n,t)=>{const i=e.contains.findIndex((e=>e.label===n));if(-1===i)throw new Error("can not find mode to replace");e.contains.splice(i,1,t)};return Object.assign(a.keywords,g),a.exports.PARAMS_CONTAINS.push(b),a.contains=a.contains.concat([b,d,u]),p(a,"shebang",e.SHEBANG()),p(a,"use_strict",{className:"meta",relevance:10,begin:/^\s*['"]use strict['"]/}),a.contains.find((e=>"func.def"===e.label)).relevance=0,Object.assign(a,{name:"TypeScript",aliases:["ts","tsx","mts","cts"]}),a}},4610:e=>{e.exports=function(e){const n=e.regex,t=n.concat(/[\p{L}_]/u,n.optional(/[\p{L}0-9_.-]*:/u),/[\p{L}0-9_.-]*/u),i={className:"symbol",begin:/&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/},a={begin:/\s/,contains:[{className:"keyword",begin:/#?[a-z_][a-z1-9_-]+/,illegal:/\n/}]},r=e.inherit(a,{begin:/\(/,end:/\)/}),s=e.inherit(e.APOS_STRING_MODE,{className:"string"}),o=e.inherit(e.QUOTE_STRING_MODE,{className:"string"}),l={endsWithParent:!0,illegal:/</,relevance:0,contains:[{className:"attr",begin:/[\p{L}0-9._:-]+/u,relevance:0},{begin:/=\s*/,relevance:0,contains:[{className:"string",endsParent:!0,variants:[{begin:/"/,end:/"/,contains:[i]},{begin:/'/,end:/'/,contains:[i]},{begin:/[^\s"'=<>`]+/}]}]}]};return{name:"HTML, XML",aliases:["html","xhtml","rss","atom","xjb","xsd","xsl","plist","wsf","svg"],case_insensitive:!0,unicodeRegex:!0,contains:[{className:"meta",begin:/<![a-z]/,end:/>/,relevance:10,contains:[a,o,s,r,{begin:/\[/,end:/\]/,contains:[{className:"meta",begin:/<![a-z]/,end:/>/,contains:[a,r,o,s]}]}]},e.COMMENT(/<!--/,/-->/,{relevance:10}),{begin:/<!\[CDATA\[/,end:/\]\]>/,relevance:10},i,{className:"meta",end:/\?>/,variants:[{begin:/<\?xml/,relevance:10,contains:[o]},{begin:/<\?[a-z][a-z0-9]+/}]},{className:"tag",begin:/<style(?=\s|>)/,end:/>/,keywords:{name:"style"},contains:[l],starts:{end:/<\/style>/,returnEnd:!0,subLanguage:["css","xml"]}},{className:"tag",begin:/<script(?=\s|>)/,end:/>/,keywords:{name:"script"},contains:[l],starts:{end:/<\/script>/,returnEnd:!0,subLanguage:["javascript","handlebars","xml"]}},{className:"tag",begin:/<>|<\/>/},{className:"tag",begin:n.concat(/</,n.lookahead(n.concat(t,n.either(/\/>/,/>/,/\s/)))),end:/\/?>/,contains:[{className:"name",begin:t,relevance:0,starts:l}]},{className:"tag",begin:n.concat(/<\//,n.lookahead(n.concat(t,/>/))),contains:[{className:"name",begin:t,relevance:0},{begin:/>/,relevance:0,endsParent:!0}]}]}}},1392:e=>{e.exports=function(e){const n="true false yes no null",t="[\\w#;/?:@&=+$,.~*'()[\\]]+",i={className:"string",relevance:0,variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/\S+/}],contains:[e.BACKSLASH_ESCAPE,{className:"template-variable",variants:[{begin:/\{\{/,end:/\}\}/},{begin:/%\{/,end:/\}/}]}]},a=e.inherit(i,{variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/[^\s,{}[\]]+/}]}),r={end:",",endsWithParent:!0,excludeEnd:!0,keywords:n,relevance:0},s={begin:/\{/,end:/\}/,contains:[r],illegal:"\\n",relevance:0},o={begin:"\\[",end:"\\]",contains:[r],illegal:"\\n",relevance:0},l=[{className:"attr",variants:[{begin:"\\w[\\w :\\/.-]*:(?=[ \t]|$)"},{begin:'"\\w[\\w :\\/.-]*":(?=[ \t]|$)'},{begin:"'\\w[\\w :\\/.-]*':(?=[ \t]|$)"}]},{className:"meta",begin:"^---\\s*$",relevance:10},{className:"string",begin:"[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*"},{begin:"<%[%=-]?",end:"[%-]?%>",subLanguage:"ruby",excludeBegin:!0,excludeEnd:!0,relevance:0},{className:"type",begin:"!\\w+!"+t},{className:"type",begin:"!<"+t+">"},{className:"type",begin:"!"+t},{className:"type",begin:"!!"+t},{className:"meta",begin:"&"+e.UNDERSCORE_IDENT_RE+"$"},{className:"meta",begin:"\\*"+e.UNDERSCORE_IDENT_RE+"$"},{className:"bullet",begin:"-(?=[ ]|$)",relevance:0},e.HASH_COMMENT_MODE,{beginKeywords:n,keywords:{literal:n}},{className:"number",begin:"\\b[0-9]{4}(-[0-9][0-9]){0,2}([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?(\\.[0-9]*)?([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?\\b"},{className:"number",begin:e.C_NUMBER_RE+"\\b",relevance:0},s,o,i],c=[...l];return c.pop(),c.push(a),r.contains=c,{name:"YAML",case_insensitive:!0,aliases:["yml"],contains:l}}}},n={};function t(i){var a=n[i];if(void 0!==a)return a.exports;var r=n[i]={exports:{}};return e[i].call(r.exports,r,r.exports,t),r.exports}var i={};return(()=>{"use strict";var e=i;Object.defineProperty(e,"__esModule",{value:!0}),e.defaultDiff2HtmlUIConfig=e.Diff2HtmlUI=void 0;const n=t(1761),a=t(4169);Object.defineProperty(e,"defaultDiff2HtmlUIConfig",{enumerable:!0,get:function(){return a.defaultDiff2HtmlUIConfig}});class r extends a.Diff2HtmlUI{constructor(e,t,i={}){super(e,t,i,n.hljs)}}e.Diff2HtmlUI=r})(),i})()));
\ No newline at end of file
diff --git a/docs/docsgen/source/_static/diff2html.min.css b/docs/docsgen/source/_static/diff2html.min.css
new file mode 100644
index 0000000..1534347
--- /dev/null
+++ b/docs/docsgen/source/_static/diff2html.min.css
@@ -0,0 +1 @@
+:root{--d2h-bg-color:#fff;--d2h-border-color:#ddd;--d2h-dim-color:rgba(0,0,0,.3);--d2h-line-border-color:#eee;--d2h-file-header-bg-color:#f7f7f7;--d2h-file-header-border-color:#d8d8d8;--d2h-empty-placeholder-bg-color:#f1f1f1;--d2h-empty-placeholder-border-color:#e1e1e1;--d2h-selected-color:#c8e1ff;--d2h-ins-bg-color:#dfd;--d2h-ins-border-color:#b4e2b4;--d2h-ins-highlight-bg-color:#97f295;--d2h-ins-label-color:#399839;--d2h-del-bg-color:#fee8e9;--d2h-del-border-color:#e9aeae;--d2h-del-highlight-bg-color:#ffb6ba;--d2h-del-label-color:#c33;--d2h-change-del-color:#fdf2d0;--d2h-change-ins-color:#ded;--d2h-info-bg-color:#f8fafd;--d2h-info-border-color:#d5e4f2;--d2h-change-label-color:#d0b44c;--d2h-moved-label-color:#3572b0;--d2h-dark-color:#e6edf3;--d2h-dark-bg-color:#0d1117;--d2h-dark-border-color:#30363d;--d2h-dark-dim-color:#6e7681;--d2h-dark-line-border-color:#21262d;--d2h-dark-file-header-bg-color:#161b22;--d2h-dark-file-header-border-color:#30363d;--d2h-dark-empty-placeholder-bg-color:hsla(215,8%,47%,.1);--d2h-dark-empty-placeholder-border-color:#30363d;--d2h-dark-selected-color:rgba(56,139,253,.1);--d2h-dark-ins-bg-color:rgba(46,160,67,.15);--d2h-dark-ins-border-color:rgba(46,160,67,.4);--d2h-dark-ins-highlight-bg-color:rgba(46,160,67,.4);--d2h-dark-ins-label-color:#3fb950;--d2h-dark-del-bg-color:rgba(248,81,73,.1);--d2h-dark-del-border-color:rgba(248,81,73,.4);--d2h-dark-del-highlight-bg-color:rgba(248,81,73,.4);--d2h-dark-del-label-color:#f85149;--d2h-dark-change-del-color:rgba(210,153,34,.2);--d2h-dark-change-ins-color:rgba(46,160,67,.25);--d2h-dark-info-bg-color:rgba(56,139,253,.1);--d2h-dark-info-border-color:rgba(56,139,253,.4);--d2h-dark-change-label-color:#d29922;--d2h-dark-moved-label-color:#3572b0}.d2h-wrapper{text-align:left}.d2h-file-header{background-color:#f7f7f7;background-color:var(--d2h-file-header-bg-color);border-bottom:1px solid #d8d8d8;border-bottom:1px solid var(--d2h-file-header-border-color);display:-webkit-box;display:-ms-flexbox;display:flex;font-family:Source Sans Pro,Helvetica Neue,Helvetica,Arial,sans-serif;height:35px;padding:5px 10px}.d2h-file-header.d2h-sticky-header{position:sticky;top:0;z-index:1}.d2h-file-stats{display:-webkit-box;display:-ms-flexbox;display:flex;font-size:14px;margin-left:auto}.d2h-lines-added{border:1px solid #b4e2b4;border:1px solid var(--d2h-ins-border-color);border-radius:5px 0 0 5px;color:#399839;color:var(--d2h-ins-label-color);padding:2px;text-align:right;vertical-align:middle}.d2h-lines-deleted{border:1px solid #e9aeae;border:1px solid var(--d2h-del-border-color);border-radius:0 5px 5px 0;color:#c33;color:var(--d2h-del-label-color);margin-left:1px;padding:2px;text-align:left;vertical-align:middle}.d2h-file-name-wrapper{-webkit-box-align:center;-ms-flex-align:center;align-items:center;display:-webkit-box;display:-ms-flexbox;display:flex;font-size:15px;width:100%}.d2h-file-name{overflow-x:hidden;text-overflow:ellipsis;white-space:nowrap}.d2h-file-wrapper{border:1px solid #ddd;border:1px solid var(--d2h-border-color);border-radius:3px;margin-bottom:1em}.d2h-file-collapse{-webkit-box-pack:end;-ms-flex-pack:end;-webkit-box-align:center;-ms-flex-align:center;align-items:center;border:1px solid #ddd;border:1px solid var(--d2h-border-color);border-radius:3px;cursor:pointer;display:none;font-size:12px;justify-content:flex-end;padding:4px 8px}.d2h-file-collapse.d2h-selected{background-color:#c8e1ff;background-color:var(--d2h-selected-color)}.d2h-file-collapse-input{margin:0 4px 0 0}.d2h-diff-table{border-collapse:collapse;font-family:Menlo,Consolas,monospace;font-size:13px;width:100%}.d2h-files-diff{display:-webkit-box;display:-ms-flexbox;display:flex;width:100%}.d2h-file-diff{overflow-y:hidden}.d2h-file-diff.d2h-d-none,.d2h-files-diff.d2h-d-none{display:none}.d2h-file-side-diff{display:inline-block;overflow-x:scroll;overflow-y:hidden;width:50%}.d2h-code-line{padding:0 8em;width:calc(100% - 16em)}.d2h-code-line,.d2h-code-side-line{display:inline-block;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;white-space:nowrap}.d2h-code-side-line{padding:0 4.5em;width:calc(100% - 9em)}.d2h-code-line-ctn{word-wrap:normal;background:none;display:inline-block;padding:0;-webkit-user-select:text;-moz-user-select:text;-ms-user-select:text;user-select:text;vertical-align:middle;white-space:pre;width:100%}.d2h-code-line del,.d2h-code-side-line del{background-color:#ffb6ba;background-color:var(--d2h-del-highlight-bg-color)}.d2h-code-line del,.d2h-code-line ins,.d2h-code-side-line del,.d2h-code-side-line ins{border-radius:.2em;display:inline-block;margin-top:-1px;-webkit-text-decoration:none;text-decoration:none}.d2h-code-line ins,.d2h-code-side-line ins{background-color:#97f295;background-color:var(--d2h-ins-highlight-bg-color);text-align:left}.d2h-code-line-prefix{word-wrap:normal;background:none;display:inline;padding:0;white-space:pre}.line-num1{float:left}.line-num1,.line-num2{-webkit-box-sizing:border-box;box-sizing:border-box;overflow:hidden;padding:0 .5em;text-overflow:ellipsis;width:3.5em}.line-num2{float:right}.d2h-code-linenumber{background-color:#fff;background-color:var(--d2h-bg-color);border:solid #eee;border:solid var(--d2h-line-border-color);border-width:0 1px;-webkit-box-sizing:border-box;box-sizing:border-box;color:rgba(0,0,0,.3);color:var(--d2h-dim-color);cursor:pointer;display:inline-block;position:absolute;text-align:right;width:7.5em}.d2h-code-linenumber:after{content:"\200b"}.d2h-code-side-linenumber{background-color:#fff;background-color:var(--d2h-bg-color);border:solid #eee;border:solid var(--d2h-line-border-color);border-width:0 1px;-webkit-box-sizing:border-box;box-sizing:border-box;color:rgba(0,0,0,.3);color:var(--d2h-dim-color);cursor:pointer;display:inline-block;overflow:hidden;padding:0 .5em;position:absolute;text-align:right;text-overflow:ellipsis;width:4em}.d2h-code-side-linenumber:after{content:"\200b"}.d2h-code-side-emptyplaceholder,.d2h-emptyplaceholder{background-color:#f1f1f1;background-color:var(--d2h-empty-placeholder-bg-color);border-color:#e1e1e1;border-color:var(--d2h-empty-placeholder-border-color)}.d2h-code-line-prefix,.d2h-code-linenumber,.d2h-code-side-linenumber,.d2h-emptyplaceholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.d2h-code-linenumber,.d2h-code-side-linenumber{direction:rtl}.d2h-del{background-color:#fee8e9;background-color:var(--d2h-del-bg-color);border-color:#e9aeae;border-color:var(--d2h-del-border-color)}.d2h-ins{background-color:#dfd;background-color:var(--d2h-ins-bg-color);border-color:#b4e2b4;border-color:var(--d2h-ins-border-color)}.d2h-info{background-color:#f8fafd;background-color:var(--d2h-info-bg-color);border-color:#d5e4f2;border-color:var(--d2h-info-border-color);color:rgba(0,0,0,.3);color:var(--d2h-dim-color)}.d2h-file-diff .d2h-del.d2h-change{background-color:#fdf2d0;background-color:var(--d2h-change-del-color)}.d2h-file-diff .d2h-ins.d2h-change{background-color:#ded;background-color:var(--d2h-change-ins-color)}.d2h-file-list-wrapper{margin-bottom:10px}.d2h-file-list-wrapper a{-webkit-text-decoration:none;text-decoration:none}.d2h-file-list-wrapper a,.d2h-file-list-wrapper a:visited{color:#3572b0;color:var(--d2h-moved-label-color)}.d2h-file-list-header{text-align:left}.d2h-file-list-title{font-weight:700}.d2h-file-list-line{display:-webkit-box;display:-ms-flexbox;display:flex;text-align:left}.d2h-file-list{display:block;list-style:none;margin:0;padding:0}.d2h-file-list>li{border-bottom:1px solid #ddd;border-bottom:1px solid var(--d2h-border-color);margin:0;padding:5px 10px}.d2h-file-list>li:last-child{border-bottom:none}.d2h-file-switch{cursor:pointer;display:none;font-size:10px}.d2h-icon{fill:currentColor;margin-right:10px;vertical-align:middle}.d2h-deleted{color:#c33;color:var(--d2h-del-label-color)}.d2h-added{color:#399839;color:var(--d2h-ins-label-color)}.d2h-changed{color:#d0b44c;color:var(--d2h-change-label-color)}.d2h-moved{color:#3572b0;color:var(--d2h-moved-label-color)}.d2h-tag{background-color:#fff;background-color:var(--d2h-bg-color);display:-webkit-box;display:-ms-flexbox;display:flex;font-size:10px;margin-left:5px;padding:0 2px}.d2h-deleted-tag{border:1px solid #c33;border:1px solid var(--d2h-del-label-color)}.d2h-added-tag{border:1px solid #399839;border:1px solid var(--d2h-ins-label-color)}.d2h-changed-tag{border:1px solid #d0b44c;border:1px solid var(--d2h-change-label-color)}.d2h-moved-tag{border:1px solid #3572b0;border:1px solid var(--d2h-moved-label-color)}.d2h-dark-color-scheme{background-color:#0d1117;background-color:var(--d2h-dark-bg-color);color:#e6edf3;color:var(--d2h-dark-color)}.d2h-dark-color-scheme .d2h-file-header{background-color:#161b22;background-color:var(--d2h-dark-file-header-bg-color);border-bottom:#30363d;border-bottom:var(--d2h-dark-file-header-border-color)}.d2h-dark-color-scheme .d2h-lines-added{border:1px solid rgba(46,160,67,.4);border:1px solid var(--d2h-dark-ins-border-color);color:#3fb950;color:var(--d2h-dark-ins-label-color)}.d2h-dark-color-scheme .d2h-lines-deleted{border:1px solid rgba(248,81,73,.4);border:1px solid var(--d2h-dark-del-border-color);color:#f85149;color:var(--d2h-dark-del-label-color)}.d2h-dark-color-scheme .d2h-code-line del,.d2h-dark-color-scheme .d2h-code-side-line del{background-color:rgba(248,81,73,.4);background-color:var(--d2h-dark-del-highlight-bg-color)}.d2h-dark-color-scheme .d2h-code-line ins,.d2h-dark-color-scheme .d2h-code-side-line ins{background-color:rgba(46,160,67,.4);background-color:var(--d2h-dark-ins-highlight-bg-color)}.d2h-dark-color-scheme .d2h-diff-tbody{border-color:#30363d;border-color:var(--d2h-dark-border-color)}.d2h-dark-color-scheme .d2h-code-side-linenumber{background-color:#0d1117;background-color:var(--d2h-dark-bg-color);border-color:#21262d;border-color:var(--d2h-dark-line-border-color);color:#6e7681;color:var(--d2h-dark-dim-color)}.d2h-dark-color-scheme .d2h-files-diff .d2h-code-side-emptyplaceholder,.d2h-dark-color-scheme .d2h-files-diff .d2h-emptyplaceholder{background-color:hsla(215,8%,47%,.1);background-color:var(--d2h-dark-empty-placeholder-bg-color);border-color:#30363d;border-color:var(--d2h-dark-empty-placeholder-border-color)}.d2h-dark-color-scheme .d2h-code-linenumber{background-color:#0d1117;background-color:var(--d2h-dark-bg-color);border-color:#21262d;border-color:var(--d2h-dark-line-border-color);color:#6e7681;color:var(--d2h-dark-dim-color)}.d2h-dark-color-scheme .d2h-del{background-color:rgba(248,81,73,.1);background-color:var(--d2h-dark-del-bg-color);border-color:rgba(248,81,73,.4);border-color:var(--d2h-dark-del-border-color)}.d2h-dark-color-scheme .d2h-ins{background-color:rgba(46,160,67,.15);background-color:var(--d2h-dark-ins-bg-color);border-color:rgba(46,160,67,.4);border-color:var(--d2h-dark-ins-border-color)}.d2h-dark-color-scheme .d2h-info{background-color:rgba(56,139,253,.1);background-color:var(--d2h-dark-info-bg-color);border-color:rgba(56,139,253,.4);border-color:var(--d2h-dark-info-border-color);color:#6e7681;color:var(--d2h-dark-dim-color)}.d2h-dark-color-scheme .d2h-file-diff .d2h-del.d2h-change{background-color:rgba(210,153,34,.2);background-color:var(--d2h-dark-change-del-color)}.d2h-dark-color-scheme .d2h-file-diff .d2h-ins.d2h-change{background-color:rgba(46,160,67,.25);background-color:var(--d2h-dark-change-ins-color)}.d2h-dark-color-scheme .d2h-file-wrapper{border:1px solid #30363d;border:1px solid var(--d2h-dark-border-color)}.d2h-dark-color-scheme .d2h-file-collapse{border:1px solid #0d1117;border:1px solid var(--d2h-dark-bg-color)}.d2h-dark-color-scheme .d2h-file-collapse.d2h-selected{background-color:rgba(56,139,253,.1);background-color:var(--d2h-dark-selected-color)}.d2h-dark-color-scheme .d2h-file-list-wrapper a,.d2h-dark-color-scheme .d2h-file-list-wrapper a:visited{color:#3572b0;color:var(--d2h-dark-moved-label-color)}.d2h-dark-color-scheme .d2h-file-list>li{border-bottom:1px solid #0d1117;border-bottom:1px solid var(--d2h-dark-bg-color)}.d2h-dark-color-scheme .d2h-deleted{color:#f85149;color:var(--d2h-dark-del-label-color)}.d2h-dark-color-scheme .d2h-added{color:#3fb950;color:var(--d2h-dark-ins-label-color)}.d2h-dark-color-scheme .d2h-changed{color:#d29922;color:var(--d2h-dark-change-label-color)}.d2h-dark-color-scheme .d2h-moved{color:#3572b0;color:var(--d2h-dark-moved-label-color)}.d2h-dark-color-scheme .d2h-tag{background-color:#0d1117;background-color:var(--d2h-dark-bg-color)}.d2h-dark-color-scheme .d2h-deleted-tag{border:1px solid #f85149;border:1px solid var(--d2h-dark-del-label-color)}.d2h-dark-color-scheme .d2h-added-tag{border:1px solid #3fb950;border:1px solid var(--d2h-dark-ins-label-color)}.d2h-dark-color-scheme .d2h-changed-tag{border:1px solid #d29922;border:1px solid var(--d2h-dark-change-label-color)}.d2h-dark-color-scheme .d2h-moved-tag{border:1px solid #3572b0;border:1px solid var(--d2h-dark-moved-label-color)}@media (prefers-color-scheme:dark){.d2h-auto-color-scheme{background-color:#0d1117;background-color:var(--d2h-dark-bg-color);color:#e6edf3;color:var(--d2h-dark-color)}.d2h-auto-color-scheme .d2h-file-header{background-color:#161b22;background-color:var(--d2h-dark-file-header-bg-color);border-bottom:#30363d;border-bottom:var(--d2h-dark-file-header-border-color)}.d2h-auto-color-scheme .d2h-lines-added{border:1px solid rgba(46,160,67,.4);border:1px solid var(--d2h-dark-ins-border-color);color:#3fb950;color:var(--d2h-dark-ins-label-color)}.d2h-auto-color-scheme .d2h-lines-deleted{border:1px solid rgba(248,81,73,.4);border:1px solid var(--d2h-dark-del-border-color);color:#f85149;color:var(--d2h-dark-del-label-color)}.d2h-auto-color-scheme .d2h-code-line del,.d2h-auto-color-scheme .d2h-code-side-line del{background-color:rgba(248,81,73,.4);background-color:var(--d2h-dark-del-highlight-bg-color)}.d2h-auto-color-scheme .d2h-code-line ins,.d2h-auto-color-scheme .d2h-code-side-line ins{background-color:rgba(46,160,67,.4);background-color:var(--d2h-dark-ins-highlight-bg-color)}.d2h-auto-color-scheme .d2h-diff-tbody{border-color:#30363d;border-color:var(--d2h-dark-border-color)}.d2h-auto-color-scheme .d2h-code-side-linenumber{background-color:#0d1117;background-color:var(--d2h-dark-bg-color);border-color:#21262d;border-color:var(--d2h-dark-line-border-color);color:#6e7681;color:var(--d2h-dark-dim-color)}.d2h-auto-color-scheme .d2h-files-diff .d2h-code-side-emptyplaceholder,.d2h-auto-color-scheme .d2h-files-diff .d2h-emptyplaceholder{background-color:hsla(215,8%,47%,.1);background-color:var(--d2h-dark-empty-placeholder-bg-color);border-color:#30363d;border-color:var(--d2h-dark-empty-placeholder-border-color)}.d2h-auto-color-scheme .d2h-code-linenumber{background-color:#0d1117;background-color:var(--d2h-dark-bg-color);border-color:#21262d;border-color:var(--d2h-dark-line-border-color);color:#6e7681;color:var(--d2h-dark-dim-color)}.d2h-auto-color-scheme .d2h-del{background-color:rgba(248,81,73,.1);background-color:var(--d2h-dark-del-bg-color);border-color:rgba(248,81,73,.4);border-color:var(--d2h-dark-del-border-color)}.d2h-auto-color-scheme .d2h-ins{background-color:rgba(46,160,67,.15);background-color:var(--d2h-dark-ins-bg-color);border-color:rgba(46,160,67,.4);border-color:var(--d2h-dark-ins-border-color)}.d2h-auto-color-scheme .d2h-info{background-color:rgba(56,139,253,.1);background-color:var(--d2h-dark-info-bg-color);border-color:rgba(56,139,253,.4);border-color:var(--d2h-dark-info-border-color);color:#6e7681;color:var(--d2h-dark-dim-color)}.d2h-auto-color-scheme .d2h-file-diff .d2h-del.d2h-change{background-color:rgba(210,153,34,.2);background-color:var(--d2h-dark-change-del-color)}.d2h-auto-color-scheme .d2h-file-diff .d2h-ins.d2h-change{background-color:rgba(46,160,67,.25);background-color:var(--d2h-dark-change-ins-color)}.d2h-auto-color-scheme .d2h-file-wrapper{border:1px solid #30363d;border:1px solid var(--d2h-dark-border-color)}.d2h-auto-color-scheme .d2h-file-collapse{border:1px solid #0d1117;border:1px solid var(--d2h-dark-bg-color)}.d2h-auto-color-scheme .d2h-file-collapse.d2h-selected{background-color:rgba(56,139,253,.1);background-color:var(--d2h-dark-selected-color)}.d2h-auto-color-scheme .d2h-file-list-wrapper a,.d2h-auto-color-scheme .d2h-file-list-wrapper a:visited{color:#3572b0;color:var(--d2h-dark-moved-label-color)}.d2h-auto-color-scheme .d2h-file-list>li{border-bottom:1px solid #0d1117;border-bottom:1px solid var(--d2h-dark-bg-color)}.d2h-dark-color-scheme .d2h-deleted{color:#f85149;color:var(--d2h-dark-del-label-color)}.d2h-auto-color-scheme .d2h-added{color:#3fb950;color:var(--d2h-dark-ins-label-color)}.d2h-auto-color-scheme .d2h-changed{color:#d29922;color:var(--d2h-dark-change-label-color)}.d2h-auto-color-scheme .d2h-moved{color:#3572b0;color:var(--d2h-dark-moved-label-color)}.d2h-auto-color-scheme .d2h-tag{background-color:#0d1117;background-color:var(--d2h-dark-bg-color)}.d2h-auto-color-scheme .d2h-deleted-tag{border:1px solid #f85149;border:1px solid var(--d2h-dark-del-label-color)}.d2h-auto-color-scheme .d2h-added-tag{border:1px solid #3fb950;border:1px solid var(--d2h-dark-ins-label-color)}.d2h-auto-color-scheme .d2h-changed-tag{border:1px solid #d29922;border:1px solid var(--d2h-dark-change-label-color)}.d2h-auto-color-scheme .d2h-moved-tag{border:1px solid #3572b0;border:1px solid var(--d2h-dark-moved-label-color)}}
\ No newline at end of file
diff --git a/docs/docsgen/source/_static/onnx-horizontal-color.png b/docs/docsgen/source/_static/onnx-horizontal-color.png
new file mode 100644
index 0000000..e93090b
Binary files /dev/null and b/docs/docsgen/source/_static/onnx-horizontal-color.png differ
diff --git a/docs/docsgen/source/_static/onnx-horizontal-white.png b/docs/docsgen/source/_static/onnx-horizontal-white.png
new file mode 100644
index 0000000..13cc7a4
Binary files /dev/null and b/docs/docsgen/source/_static/onnx-horizontal-white.png differ
diff --git a/docs/docsgen/source/_static/readme.txt b/docs/docsgen/source/_static/readme.txt
new file mode 100644
index 0000000..c0a8962
--- /dev/null
+++ b/docs/docsgen/source/_static/readme.txt
@@ -0,0 +1,16 @@
+diff2html: https://github.com/rtfpessoa/diff2html
+
+Copyright 2014-2016 Rodrigo Fernandes https://rtfpessoa.github.io/
+
+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.
diff --git a/docs/docsgen/source/api/backend.md b/docs/docsgen/source/api/backend.md
new file mode 100644
index 0000000..6bd284e
--- /dev/null
+++ b/docs/docsgen/source/api/backend.md
@@ -0,0 +1,35 @@
+# onnx.backend
+
+## Backend
+
+```{eval-rst}
+.. autoclass:: onnx.backend.base.Backend
+    :members:
+```
+
+## BackendRep
+
+```{eval-rst}
+.. autoclass:: onnx.backend.base.BackendRep
+    :members:
+```
+
+## Device
+
+```{eval-rst}
+.. autoclass:: onnx.backend.base.Device
+    :members:
+```
+
+## DeviceType
+
+```{eval-rst}
+.. autoclass:: onnx.backend.base.DeviceType
+    :members:
+```
+
+## load_model_tests
+
+```{eval-rst}
+.. autofunction:: onnx.backend.test.loader.load_model_tests
+```
diff --git a/docs/docsgen/source/api/checker.md b/docs/docsgen/source/api/checker.md
new file mode 100644
index 0000000..dc10b83
--- /dev/null
+++ b/docs/docsgen/source/api/checker.md
@@ -0,0 +1,17 @@
+# onnx.checker
+
+## CheckerContext
+
+```{eval-rst}
+.. autoclass:: onnx.checker.DEFAULT_CONTEXT
+    :members:
+```
+
+## The `onnx.checker` module
+
+```{eval-rst}
+.. automodule:: onnx.checker
+    :members:
+    :undoc-members:
+    :show-inheritance:
+```
diff --git a/docs/docsgen/source/api/classes.md b/docs/docsgen/source/api/classes.md
new file mode 100644
index 0000000..3e5bb54
--- /dev/null
+++ b/docs/docsgen/source/api/classes.md
@@ -0,0 +1,294 @@
+(l-onnx-classes)=
+
+# Protos
+
+This structures are defined with protobuf in files `onnx/*.proto`.
+It is recommended to use function in module {ref}`l-mod-onnx-helper`
+to create them instead of directly instantiated them.
+Every structure can be printed with function `print` and is rendered
+as a json string.
+
+## AttributeProto
+
+This class is used to define an attribute of an operator
+defined itself by a NodeProto. It is
+a named attribute containing either singular float, integer, string, graph,
+and tensor values, or repeated float, integer, string, graph, and tensor values.
+An AttributeProto MUST contain the name field, and *only one* of the
+following content fields, effectively enforcing a C/C++ union equivalent.
+
+```{eval-rst}
+.. autoclass:: onnx.AttributeProto
+    :members:
+```
+
+(l-onnx-function-proto)=
+
+## FunctionProto
+
+This defines a function. It is not a model but can
+be used to define custom operators used in a model.
+
+```{eval-rst}
+.. autoclass:: onnx.FunctionProto
+    :members:
+```
+
+(l-onnx-graph-proto)=
+
+## GraphProto
+
+This defines a graph or a set of nodes called from a loop or a test
+for example.
+A graph defines the computational logic of a model and is comprised of a parameterized
+list of nodes that form a directed acyclic graph based on their inputs and outputs.
+This is the equivalent of the *network* or *graph* in many deep learning
+frameworks.
+
+```{eval-rst}
+.. autoclass:: onnx.GraphProto
+    :members:
+```
+
+(l-onnx-map-proto)=
+
+## MapProto
+
+This defines a map or a dictionary. It
+specifies an associative table, defined by keys and values.
+MapProto is formed with a repeated field of keys (of type INT8, INT16, INT32,
+INT64, UINT8, UINT16, UINT32, UINT64, or STRING) and values (of type TENSOR,
+SPARSE_TENSOR, SEQUENCE, or MAP). Key types and value types have to remain
+the same throughout the instantiation of the MapProto.
+
+```{eval-rst}
+.. autoclass:: onnx.MapProto
+    :members:
+```
+
+(l-modelproto)=
+
+## ModelProto
+
+This defines a model. That is the type every converting library
+returns after converting a machine learned model.
+ModelProto is a top-level file/container format for bundling a ML model and
+associating its computation graph with metadata.
+The semantics of the model are described by the associated GraphProto's.
+
+```{eval-rst}
+.. autoclass:: onnx.ModelProto
+    :members:
+```
+
+(l-nodeproto)=
+
+## NodeProto
+
+This defines an operator. A model is a combination of
+mathematical functions, each of them represented as an onnx operator,
+stored in a NodeProto.
+Computation graphs are made up of a DAG of nodes, which represent what is
+commonly called a *layer* or *pipeline stage* in machine learning frameworks.
+For example, it can be a node of type *Conv* that takes in an image, a filter
+tensor and a bias tensor, and produces the convolved output.
+
+```{eval-rst}
+.. autoclass:: onnx.NodeProto
+    :members:
+```
+
+(l-operatorproto)=
+
+## OperatorProto
+
+This class is rarely used by users.
+An OperatorProto represents the immutable specification of the signature
+and semantics of an operator.
+Operators are declared as part of an OperatorSet, which also defines the
+domain name for the set.
+Operators are uniquely identified by a three part identifier
+(domain, op_type, since_version) where
+
+- *domain* is the domain of an operator set that contains this operator specification.
+- *op_type* is the name of the operator as referenced by a NodeProto.op_type
+- *since_version* is the version of the operator set that this operator was initially declared in.
+
+```{eval-rst}
+.. autoclass:: onnx.OperatorProto
+    :members:
+```
+
+(l-operatorsetidproto)=
+
+## OperatorSetIdProto
+
+This is the type of attribute `opset_import` of class ModelProto.
+This attribute specifies the versions of operators used in the model.
+Every operator or node belongs to a domain. All operators for the same
+domain share the same version.
+
+```{eval-rst}
+.. autoclass:: onnx.OperatorSetIdProto
+    :members:
+```
+
+(l-operatorsetproto)=
+
+## OperatorSetProto
+
+An OperatorSetProto represents an immutable set of immutable operator specifications.
+The domain of the set (OperatorSetProto.domain) is a reverse-DNS name
+that disambiguates operator sets defined by independent entities.
+The version of the set (opset_version) is a monotonically increasing
+integer that indicates changes to the membership of the operator set.
+Operator sets are uniquely identified by a two part identifier (domain, opset_version)
+Like ModelProto, OperatorSetProto is intended as a top-level file/wire format,
+and thus has the standard format headers in addition to the operator set information.
+
+```{eval-rst}
+.. autoclass:: onnx.OperatorSetProto
+    :members:
+```
+
+(l-optionalproto)=
+
+## OptionalProto
+
+Some input or output of a model are optional. This class must
+be used in this case. An instance of class OptionalProto
+may contain or not an instance of type TensorProto, SparseTensorProto,
+SequenceProto, MapProto and OptionalProto.
+
+```{eval-rst}
+.. autoclass:: onnx.OptionalProto
+    :members:
+```
+
+(l-onnx-sequence-proto)=
+
+## SequenceProto
+
+This defines a dense, ordered, collection of elements that are of homogeneous types.
+Sequences can be made out of tensors, maps, or sequences.
+If a sequence is made out of tensors, the tensors must have the same element
+type (i.e. int32). In some cases, the tensors in a sequence can have different
+shapes.  Whether the tensors can have different shapes or not depends on the
+type/shape associated with the corresponding `ValueInfo`. For example,
+`Sequence<Tensor<float, [M,N]>` means that all tensors have same shape. However,
+`Sequence<Tensor<float, [omitted,omitted]>` means they can have different
+shapes (all of rank 2), where *omitted* means the corresponding dimension has
+no symbolic/constant value. Finally, `Sequence<Tensor<float, omitted>>` means
+that the different tensors can have different ranks, when the *shape* itself
+is omitted from the tensor-type. For a more complete description, refer to
+[Static tensor shapes](https://github.com/onnx/onnx/blob/main/docs/IR.md#static-tensor-shapes).
+
+```{eval-rst}
+.. autoclass:: onnx.SequenceProto
+    :members:
+```
+
+(l-onnx-sparsetensor-proto)=
+
+## SparseTensorProto
+
+This defines a sparse tensor.
+The sequence of non-default values are encoded as a tensor of shape `[NNZ]`.
+The default-value is zero for numeric tensors, and empty-string for string tensors.
+values must have a non-empty name present which serves as a name for SparseTensorProto
+when used in sparse_initializer list.
+
+```{eval-rst}
+.. autoclass:: onnx.SparseTensorProto
+    :members:
+```
+
+(l-onnx-stringstringentry-proto)=
+
+## StringStringEntryProto
+
+This is equivalent to a pair of strings.
+This is used to store metadata in ModelProto.
+
+```{eval-rst}
+.. autoclass:: onnx.StringStringEntryProto
+    :members:
+```
+
+(l-tensorproto)=
+
+## TensorProto
+
+This defines a tensor. A tensor is fully described with a shape
+(see ShapeProto), the element type (see TypeProto), and the
+elements themselves. All available types are listed in
+{ref}`l-mod-onnx-mapping`.
+
+```{eval-rst}
+.. autoclass:: onnx.TensorProto
+    :members:
+```
+
+(l-tensorshapeproto)=
+
+## TensorShapeProto
+
+This defines the shape of a tensor or a sparse tensor.
+It is a list of dimensions. A dimension can be either an integer value
+or a symbolic variable. A symbolic variable represents an unknown
+dimension.
+
+```{eval-rst}
+.. autoclass:: onnx.TensorShapeProto
+    :members:
+```
+
+(l-traininginfoproto)=
+
+## TrainingInfoProto
+
+TrainingInfoProto stores information for training a model.
+In particular, this defines two functionalities: an initialization-step
+and a training-algorithm-step. Initialization resets the model
+back to its original state as if no training has been performed.
+Training algorithm improves the model based on input data.
+The semantics of the initialization-step is that the initializers
+in ModelProto.graph and in TrainingInfoProto.algorithm are first
+initialized as specified by the initializers in the graph, and then
+updated by the *initialization_binding* in every instance in
+ModelProto.training_info.
+The field *algorithm* defines a computation graph which represents a
+training algorithm's step. After the execution of a
+TrainingInfoProto.algorithm, the initializers specified by *update_binding*
+may be immediately updated. If the targeted training algorithm contains
+consecutive update steps (such as block coordinate descent methods),
+the user needs to create a TrainingInfoProto for each step.
+
+```{eval-rst}
+.. autoclass:: onnx.TrainingInfoProto
+    :members:
+```
+
+(l-typeproto)=
+
+## TypeProto
+
+This defines a type of a tensor which consists in an element type
+and a shape (ShapeProto).
+
+```{eval-rst}
+.. autoclass:: onnx.TypeProto
+    :members:
+```
+
+(l-valueinfoproto)=
+
+## ValueInfoProto
+
+This defines a input or output type of a GraphProto.
+It contains a name, a type (TypeProto), and a documentation string.
+
+```{eval-rst}
+.. autoclass:: onnx.ValueInfoProto
+    :members:
+```
diff --git a/docs/docsgen/source/api/compose.md b/docs/docsgen/source/api/compose.md
new file mode 100644
index 0000000..b83dff0
--- /dev/null
+++ b/docs/docsgen/source/api/compose.md
@@ -0,0 +1,44 @@
+# onnx.compose
+
+```{eval-rst}
+.. currentmodule:: onnx.compose
+```
+
+```{eval-rst}
+.. autosummary::
+
+    merge_graphs
+    merge_models
+```
+
+## merge_graphs
+
+```{eval-rst}
+.. autofunction:: onnx.compose.merge_graphs
+```
+
+## merge_models
+
+```{eval-rst}
+.. autofunction:: onnx.compose.merge_models
+```
+
+## prefix
+
+```{eval-rst}
+.. autofunction:: onnx.compose.add_prefix_graph
+```
+
+```{eval-rst}
+.. autofunction:: onnx.compose.add_prefix
+```
+
+## dimension
+
+```{eval-rst}
+.. autofunction:: onnx.compose.expand_out_dim
+```
+
+```{eval-rst}
+.. autofunction:: onnx.compose.expand_out_dim_graph
+```
diff --git a/docs/docsgen/source/api/defs.md b/docs/docsgen/source/api/defs.md
new file mode 100644
index 0000000..8291a30
--- /dev/null
+++ b/docs/docsgen/source/api/defs.md
@@ -0,0 +1,62 @@
+(l-mod-onnx-defs)=
+
+# onnx.defs
+
+(l-api-opset-version)=
+
+## Opset Version
+
+```{eval-rst}
+.. autofunction:: onnx.defs.onnx_opset_version
+```
+
+## Operators and Functions Schemas
+
+```{eval-rst}
+.. autofunction:: onnx.defs.has
+
+.. autofunction:: onnx.defs.get_schema
+
+.. autofunction:: onnx.defs.get_all_schemas
+
+.. autofunction:: onnx.defs.get_all_schemas_with_history
+
+.. autofunction:: onnx.defs.get_function_ops
+
+.. autofunction:: onnx.defs.register_schema
+
+.. autofunction:: onnx.defs.deregister_schema
+```
+
+## class `OpSchema`
+
+```{eval-rst}
+.. autoclass:: onnx.defs.OpSchema
+    :members:
+    :undoc-members:
+```
+
+## Exceptions
+
+```{eval-rst}
+.. autoclass:: onnx.defs.SchemaError
+```
+
+## Constants
+
+Domains officially supported in onnx package.
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx.defs import (
+        ONNX_DOMAIN,
+        ONNX_ML_DOMAIN,
+        AI_ONNX_PREVIEW_DOMAIN,
+        AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+    )
+    print(f"ONNX_DOMAIN={ONNX_DOMAIN!r}")
+    print(f"ONNX_ML_DOMAIN={ONNX_ML_DOMAIN!r}")
+    print(f"AI_ONNX_PREVIEW_DOMAIN={AI_ONNX_PREVIEW_DOMAIN!r}")
+    print(f"AI_ONNX_PREVIEW_TRAINING_DOMAIN={AI_ONNX_PREVIEW_TRAINING_DOMAIN!r}")
+```
diff --git a/docs/docsgen/source/api/external_data_helper.md b/docs/docsgen/source/api/external_data_helper.md
new file mode 100644
index 0000000..cb3cf58
--- /dev/null
+++ b/docs/docsgen/source/api/external_data_helper.md
@@ -0,0 +1,61 @@
+# onnx.external_data_helper
+
+## convert_model_from_external_data
+
+```{eval-rst}
+.. autofunction:: onnx.external_data_helper.convert_model_from_external_data
+```
+
+## convert_model_to_external_data
+
+```{eval-rst}
+.. autofunction:: onnx.external_data_helper.convert_model_to_external_data
+```
+
+## ExternalDataInfo
+
+```{eval-rst}
+.. autoclass:: onnx.external_data_helper.ExternalDataInfo
+```
+
+## load_external_data_for_model
+
+```{eval-rst}
+.. autofunction:: onnx.external_data_helper.load_external_data_for_model
+```
+
+## load_external_data_for_tensor
+
+```{eval-rst}
+.. autofunction:: onnx.external_data_helper.load_external_data_for_tensor
+```
+
+## remove_external_data_field
+
+```{eval-rst}
+.. autofunction:: onnx.external_data_helper.remove_external_data_field
+```
+
+## save_external_data
+
+```{eval-rst}
+.. autofunction:: onnx.external_data_helper.save_external_data
+```
+
+## set_external_data
+
+```{eval-rst}
+.. autofunction:: onnx.external_data_helper.set_external_data
+```
+
+## uses_external_data
+
+```{eval-rst}
+.. autofunction:: onnx.external_data_helper.uses_external_data
+```
+
+## write_external_data_tensors
+
+```{eval-rst}
+.. autofunction:: onnx.external_data_helper.write_external_data_tensors
+```
diff --git a/docs/docsgen/source/api/helper.md b/docs/docsgen/source/api/helper.md
new file mode 100644
index 0000000..90ea20b
--- /dev/null
+++ b/docs/docsgen/source/api/helper.md
@@ -0,0 +1,163 @@
+(l-mod-onnx-helper)=
+
+# onnx.helper
+
+```{eval-rst}
+.. currentmodule:: onnx.helper
+```
+
+(l-onnx-make-function)=
+
+## Helper functions to make ONNX graph components
+
+All functions used to create an ONNX graph.
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_attribute
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_attribute_ref
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_empty_tensor_value_info
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_function
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_graph
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_map
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_map_type_proto
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_model
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_node
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_operatorsetid
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_opsetid
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_model_gen_version
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_optional
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_optional_type_proto
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_sequence
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_sequence_type_proto
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_sparse_tensor
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_sparse_tensor_type_proto
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_sparse_tensor_value_info
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_tensor
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_tensor_sequence_value_info
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_tensor_type_proto
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_training_info
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_tensor_value_info
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.make_value_info
+```
+
+## Type Mappings
+
+```{eval-rst}
+.. autofunction:: onnx.helper.get_all_tensor_dtypes
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.np_dtype_to_tensor_dtype
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.tensor_dtype_to_field
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.tensor_dtype_to_np_dtype
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.tensor_dtype_to_storage_tensor_dtype
+```
+
+```{eval-rst}
+.. autofunction:: onnx.helper.tensor_dtype_to_string
+```
+
+## Tools
+
+```{eval-rst}
+.. autofunction:: onnx.helper.find_min_ir_version_for
+```
+
+## Other functions
+
+```{eval-rst}
+.. autosummary::
+
+    get_attribute_value
+    get_node_attr_value
+    set_metadata_props
+    set_model_props
+    printable_attribute
+    printable_dim
+    printable_graph
+    printable_node
+    printable_tensor_proto
+    printable_type
+    printable_value_info
+```
diff --git a/docs/docsgen/source/api/index.md b/docs/docsgen/source/api/index.md
new file mode 100644
index 0000000..e36404e
--- /dev/null
+++ b/docs/docsgen/source/api/index.md
@@ -0,0 +1,71 @@
+(l-python-onnx-api)=
+
+# API Reference
+
+```{tip}
+The [ir-py project](https://github.com/onnx/ir-py) provides alternative Pythonic APIs for creating and manipulating ONNX models without interaction with Protobuf.
+```
+
+## Versioning
+
+The following example shows how to retrieve onnx version,
+the onnx opset, the IR version. Every new major release increments the opset version
+(see {ref}`l-api-opset-version`).
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import __version__, IR_VERSION
+    from onnx.defs import onnx_opset_version
+    print(f"onnx.__version__={__version__!r}, opset={onnx_opset_version()}, IR_VERSION={IR_VERSION}")
+```
+
+The intermediate representation (IR) specification is the abstract model for
+graphs and operators and the concrete format that represents them.
+Adding a structure or modifying one of them increases the IR version.
+
+The opset version increases when an operator is added or removed or modified.
+A higher opset means a longer list of operators and more options to
+implement an ONNX functions. An operator is usually modified because it
+supports more input and output type, or an attribute becomes an input.
+
+## Data Structures
+
+Every ONNX object is defined based on a [protobuf message](https://googleapis.dev/python/protobuf/latest/google/protobuf/message.html)
+and has a name ended with suffix `Proto`. For example, {ref}`l-nodeproto` defines
+an operator, {ref}`l-tensorproto` defines a tensor. Next page lists all of them.
+
+```{toctree}
+:maxdepth: 1
+
+classes
+serialization
+```
+
+## Functions
+
+An ONNX model can be created directly from the classes described
+in the previous section, but it is faster to create and
+verify a model with the following helpers.
+
+```{toctree}
+:maxdepth: 1
+
+backend
+checker
+compose
+defs
+external_data_helper
+helper
+inliner
+mapping
+model_container
+numpy_helper
+parser
+printer
+reference
+shape_inference
+tools
+utils
+version_converter
+```
diff --git a/docs/docsgen/source/api/inliner.md b/docs/docsgen/source/api/inliner.md
new file mode 100644
index 0000000..6ae1050
--- /dev/null
+++ b/docs/docsgen/source/api/inliner.md
@@ -0,0 +1,13 @@
+# onnx.inliner
+
+## inline_local_functions
+
+```{eval-rst}
+.. autofunction:: onnx.inliner.inline_local_functions
+```
+
+## inline_selected_functions
+
+```{eval-rst}
+.. autofunction:: onnx.inliner.inline_selected_functions
+```
diff --git a/docs/docsgen/source/api/model_container.md b/docs/docsgen/source/api/model_container.md
new file mode 100644
index 0000000..48641cd
--- /dev/null
+++ b/docs/docsgen/source/api/model_container.md
@@ -0,0 +1,20 @@
+# onnx.model_container
+
+## ModelContainer
+
+```{eval-rst}
+.. autoclass:: onnx.model_container.ModelContainer
+    :members:
+```
+
+## make_large_model
+
+```{eval-rst}
+.. autofunction:: onnx.model_container.make_large_model
+```
+
+## make_large_tensor_proto
+
+```{eval-rst}
+.. autofunction:: onnx.model_container.make_large_tensor_proto
+```
diff --git a/docs/docsgen/source/api/numpy_helper.md b/docs/docsgen/source/api/numpy_helper.md
new file mode 100644
index 0000000..db521f9
--- /dev/null
+++ b/docs/docsgen/source/api/numpy_helper.md
@@ -0,0 +1,63 @@
+# onnx.numpy_helper
+
+```{eval-rst}
+.. currentmodule:: onnx.numpy_helper
+```
+
+```{eval-rst}
+.. autosummary::
+
+    from_array
+    from_dict
+    from_list
+    from_optional
+    to_array
+    to_dict
+    to_list
+    to_optional
+
+```
+
+(l-numpy-helper-onnx-array)=
+
+## array
+
+```{eval-rst}
+.. autofunction:: onnx.numpy_helper.from_array
+```
+
+```{eval-rst}
+.. autofunction:: onnx.numpy_helper.to_array
+```
+
+Arrays with data types not supported natively by NumPy will be return with ``ml_dtypes`` dtypes.
+
+## sequence
+
+```{eval-rst}
+.. autofunction:: onnx.numpy_helper.to_list
+```
+
+```{eval-rst}
+.. autofunction:: onnx.numpy_helper.from_list
+```
+
+## dictionary
+
+```{eval-rst}
+.. autofunction:: onnx.numpy_helper.to_dict
+```
+
+```{eval-rst}
+.. autofunction:: onnx.numpy_helper.from_dict
+```
+
+## optional
+
+```{eval-rst}
+.. autofunction:: onnx.numpy_helper.to_optional
+```
+
+```{eval-rst}
+.. autofunction:: onnx.numpy_helper.from_optional
+```
diff --git a/docs/docsgen/source/api/parser.md b/docs/docsgen/source/api/parser.md
new file mode 100644
index 0000000..8660c7e
--- /dev/null
+++ b/docs/docsgen/source/api/parser.md
@@ -0,0 +1,25 @@
+# onnx.parser
+
+## parse_node
+
+```{eval-rst}
+.. autofunction:: onnx.parser.parse_node
+```
+
+## parse_function
+
+```{eval-rst}
+.. autofunction:: onnx.parser.parse_function
+```
+
+## parse_graph
+
+```{eval-rst}
+.. autofunction:: onnx.parser.parse_graph
+```
+
+## parse_model
+
+```{eval-rst}
+.. autofunction:: onnx.parser.parse_model
+```
diff --git a/docs/docsgen/source/api/printer.md b/docs/docsgen/source/api/printer.md
new file mode 100644
index 0000000..76a7367
--- /dev/null
+++ b/docs/docsgen/source/api/printer.md
@@ -0,0 +1,7 @@
+# onnx.printer
+
+## to_text
+
+```{eval-rst}
+.. autofunction:: onnx.printer.to_text
+```
diff --git a/docs/docsgen/source/api/reference.md b/docs/docsgen/source/api/reference.md
new file mode 100644
index 0000000..2989c61
--- /dev/null
+++ b/docs/docsgen/source/api/reference.md
@@ -0,0 +1,45 @@
+(l-reference-implementation)=
+
+# onnx.reference
+
+## DefaultNone
+
+```{eval-rst}
+.. autoclass:: onnx.reference.op_run.DefaultNone
+    :members:
+```
+
+## ReferenceEvaluator
+
+```{eval-rst}
+.. autoclass:: onnx.reference.ReferenceEvaluator
+    :members: input_names, output_names, opsets, run
+```
+
+## OpFunction
+
+```{eval-rst}
+.. autoclass:: onnx.reference.op_run.OpFunction
+    :members: create, eval, input, output, implicit_inputs, domain, need_context, run, make_node
+```
+
+## OpRun
+
+```{eval-rst}
+.. autoclass:: onnx.reference.op_run.OpRun
+    :members: create, eval, input, output, implicit_inputs, domain, need_context, run, make_node
+```
+
+## RuntimeTypeError
+
+```{eval-rst}
+.. autoclass:: onnx.reference.op_run.RuntimeTypeError
+    :members:
+```
+
+## SparseTensor
+
+```{eval-rst}
+.. autoclass:: onnx.reference.op_run.SparseTensor
+    :members:
+```
diff --git a/docs/docsgen/source/api/serialization.md b/docs/docsgen/source/api/serialization.md
new file mode 100644
index 0000000..2359047
--- /dev/null
+++ b/docs/docsgen/source/api/serialization.md
@@ -0,0 +1,119 @@
+(l-serialization)=
+
+# Serialization
+
+## Save a model and any Proto class
+
+This ONNX graph needs to be serialized into one contiguous
+memory buffer. Method `SerializeToString` is available
+in every ONNX objects.
+
+```
+with open("model.onnx", "wb") as f:
+    f.write(onnx_model.SerializeToString())
+```
+
+This method has the following signature.
+
+```{eval-rst}
+.. autoclass:: onnx.ModelProto
+    :members: SerializeToString
+```
+
+Every Proto class implements method `SerializeToString`.
+Therefore the following code works with any class described
+in page {ref}`l-onnx-classes`.
+
+```
+with open("proto.pb", "wb") as f:
+    f.write(proto.SerializeToString())
+```
+
+Next example shows how to save a {ref}`l-nodeproto`.
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import NodeProto
+
+    node = NodeProto()
+    node.name = "example-type-proto"
+    node.op_type = "Add"
+    node.input.extend(["X", "Y"])
+    node.output.extend(["Z"])
+
+    with open("node.pb", "wb") as f:
+        f.write(node.SerializeToString())
+```
+
+## Load a model
+
+Following function only automates the loading of a class
+{ref}`l-modelproto`. Next sections shows how to restore
+any other proto class.
+
+```{eval-rst}
+.. autofunction:: onnx.load
+```
+
+```
+from onnx import load
+
+onnx_model = load("model.onnx")
+```
+
+Or:
+
+```
+from onnx import load
+
+with open("model.onnx", "rb") as f:
+    onnx_model = load(f)
+```
+
+Next function does the same from a bytes array.
+
+```{eval-rst}
+.. autofunction:: onnx.load_model_from_string
+
+```
+
+(l-onnx-load-data)=
+
+## Load a Proto
+
+Proto means here any type containing data including a model, a tensor,
+a sparse tensor, any class listed in page {ref}`l-onnx-classes`.
+The user must know the type of the data he needs to restore
+and then call method `ParseFromString`.
+[protobuf](https://developers.google.com/protocol-buffers)
+does not store any information about the class
+of the saved data. Therefore, this class must be known before
+restoring an object.
+
+```{eval-rst}
+.. autoclass:: onnx.ModelProto
+    :members: ParseFromString
+```
+
+Next example shows how to restore a {ref}`l-nodeproto`.
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import NodeProto
+
+    tp2 = NodeProto()
+    with open("node.pb", "rb") as f:
+        content = f.read()
+
+    tp2.ParseFromString(content)
+
+    print(tp2)
+```
+
+A shortcut exists for {ref}`l-tensorproto`:
+
+```{eval-rst}
+.. autofunction:: onnx.load_tensor_from_string
+```
diff --git a/docs/docsgen/source/api/shape_inference.md b/docs/docsgen/source/api/shape_inference.md
new file mode 100644
index 0000000..41f9091
--- /dev/null
+++ b/docs/docsgen/source/api/shape_inference.md
@@ -0,0 +1,25 @@
+# onnx.shape_inference
+
+## infer_shapes
+
+```{eval-rst}
+.. autofunction:: onnx.shape_inference.infer_shapes
+```
+
+## infer_shapes_path
+
+```{eval-rst}
+.. autofunction:: onnx.shape_inference.infer_shapes_path
+```
+
+## infer_node_outputs
+
+```{eval-rst}
+.. autofunction:: onnx.shape_inference.infer_node_outputs
+```
+
+## infer_function_output_types
+
+```{eval-rst}
+.. autofunction:: onnx.shape_inference.infer_function_output_types
+```
diff --git a/docs/docsgen/source/api/tools.md b/docs/docsgen/source/api/tools.md
new file mode 100644
index 0000000..0b23db2
--- /dev/null
+++ b/docs/docsgen/source/api/tools.md
@@ -0,0 +1,14 @@
+# onnx.tools
+
+
+## update_inputs_outputs_dims
+
+```{eval-rst}
+.. autofunction:: onnx.tools.update_model_dims.update_inputs_outputs_dims
+```
+
+## replace_initializer_by_constant_of_shape
+
+```{eval-rst}
+.. autofunction:: onnx.tools.replace_constants.replace_initializer_by_constant_of_shape
+```
diff --git a/docs/docsgen/source/api/utils.md b/docs/docsgen/source/api/utils.md
new file mode 100644
index 0000000..b08d1ab
--- /dev/null
+++ b/docs/docsgen/source/api/utils.md
@@ -0,0 +1,14 @@
+# onnx.utils
+
+## Extractor
+
+```{eval-rst}
+.. autoclass:: onnx.utils.Extractor
+    :members:
+```
+
+## extract_model
+
+```{eval-rst}
+.. autofunction:: onnx.utils.extract_model
+```
diff --git a/docs/docsgen/source/api/version_converter.md b/docs/docsgen/source/api/version_converter.md
new file mode 100644
index 0000000..8b7754d
--- /dev/null
+++ b/docs/docsgen/source/api/version_converter.md
@@ -0,0 +1,7 @@
+# onnx.version_converter
+
+## convert_version
+
+```{eval-rst}
+.. autofunction:: onnx.version_converter.convert_version
+```
diff --git a/docs/docsgen/source/conf.py b/docs/docsgen/source/conf.py
new file mode 100644
index 0000000..518d0cc
--- /dev/null
+++ b/docs/docsgen/source/conf.py
@@ -0,0 +1,107 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from __future__ import annotations
+
+import os
+import sys
+import warnings
+
+import onnx
+
+sys.path.append(os.path.abspath(os.path.dirname(__file__)))
+
+
+# -- Project information -----------------------------------------------------
+
+author = "ONNX"
+copyright = "2024"  # noqa: A001
+project = "ONNX"
+release = onnx.__version__
+version = onnx.__version__
+
+# define the latest opset to document,
+# this is meant to avoid documenting opset not released yet
+max_opset = onnx.helper.VERSION_TABLE[-1][2]
+
+# define the latest opset to document for every opset
+_opsets = [t for t in onnx.helper.VERSION_TABLE if t[2] == max_opset][-1]
+max_opsets = {
+    "": max_opset,
+    "ai.onnx.ml": _opsets[3],
+    "ai.onnx.training": _opsets[4],
+}
+
+# -- General configuration ---------------------------------------------------
+
+extensions = [
+    "myst_parser",
+    "onnx_sphinx",
+    "sphinx_copybutton",
+    "sphinx_exec_code",
+    "sphinx_tabs.tabs",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.coverage",
+    "sphinx.ext.doctest",
+    "sphinx.ext.githubpages",
+    "sphinx.ext.graphviz",
+    "sphinx.ext.ifconfig",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.mathjax",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
+]
+
+myst_enable_extensions = [
+    "amsmath",
+    "attrs_inline",
+    "colon_fence",
+    "deflist",
+    "dollarmath",
+    "fieldlist",
+    "html_admonition",
+    "html_image",
+    "linkify",
+    "replacements",
+    "smartquotes",
+    "strikethrough",
+    "substitution",
+    "tasklist",
+]
+
+coverage_show_missing_items = True
+exclude_patterns = []
+graphviz_output_format = "svg"
+html_css_files = ["css/custom.css"]
+html_favicon = "onnx-favicon.png"
+html_sidebars = {}
+html_static_path = ["_static"]
+html_theme = "furo"
+language = "en"
+mathdef_link_only = True
+master_doc = "index"
+onnx_doc_folder = os.path.join(os.path.abspath(os.path.dirname(__file__)), "operators")
+pygments_style = "default"
+source_suffix = [".rst", ".md"]
+templates_path = ["_templates"]
+
+html_context = {
+    "default_mode": "auto",  # auto: the documentation theme will follow the system default that you have set (light or dark)
+}
+
+html_theme_options = {
+    "light_logo": "onnx-horizontal-color.png",
+    "dark_logo": "onnx-horizontal-white.png",
+}
+
+intersphinx_mapping = {
+    "numpy": ("https://numpy.org/doc/stable/", None),
+    "python": (f"https://docs.python.org/{sys.version_info.major}/", None),
+    "scipy": ("https://docs.scipy.org/doc/scipy/", None),
+    "torch": ("https://pytorch.org/docs/stable/", None),
+}
+
+warnings.filterwarnings("ignore", category=FutureWarning)
diff --git a/docs/docsgen/source/expect_onnxruntime.md b/docs/docsgen/source/expect_onnxruntime.md
new file mode 100644
index 0000000..4875050
--- /dev/null
+++ b/docs/docsgen/source/expect_onnxruntime.md
@@ -0,0 +1,75 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+(l-function-expect)=
+
+# Sample operator test code
+
+Many examples from the documentation end by calling
+function `expect` to check a runtime returns the expected
+outputs for the given example. Here is one implementation
+based on [onnxruntime](https://onnxruntime.ai/).
+
+```
+from typing import Any, Sequence
+import numpy as np
+import onnx
+import onnxruntime
+
+
+def expect(
+    node: onnx.NodeProto,
+    inputs: Sequence[np.ndarray],
+    outputs: Sequence[np.ndarray],
+    name: str,
+    **kwargs: Any,
+) -> None:
+    # Builds the model
+    present_inputs = [x for x in node.input if (x != "")]
+    present_outputs = [x for x in node.output if (x != "")]
+    input_type_protos = [None] * len(inputs)
+    if "input_type_protos" in kwargs:
+        input_type_protos = kwargs["input_type_protos"]
+        del kwargs["input_type_protos"]
+    output_type_protos = [None] * len(outputs)
+    if "output_type_protos" in kwargs:
+        output_type_protos = kwargs["output_type_protos"]
+        del kwargs["output_type_protos"]
+    inputs_vi = [
+        _extract_value_info(arr, arr_name, input_type)
+        for arr, arr_name, input_type in zip(inputs, present_inputs, input_type_protos)
+    ]
+    outputs_vi = [
+        _extract_value_info(arr, arr_name, output_type)
+        for arr, arr_name, output_type in zip(
+            outputs, present_outputs, output_type_protos
+        )
+    ]
+    graph = onnx.helper.make_graph(
+        nodes=[node], name=name, inputs=inputs_vi, outputs=outputs_vi
+    )
+    kwargs["producer_name"] = "backend-test"
+
+    if "opset_imports" not in kwargs:
+        # To make sure the model will be produced with the same opset_version after opset changes
+        # By default, it uses since_version as opset_version for produced models
+        produce_opset_version = onnx.defs.get_schema(
+            node.op_type, domain=node.domain
+        ).since_version
+        kwargs["opset_imports"] = [
+            onnx.helper.make_operatorsetid(node.domain, produce_opset_version)
+        ]
+
+    model = onnx.helper.make_model_gen_version(graph, **kwargs)
+
+    # Checking the produces are the expected ones.
+    sess = onnxruntime.InferenceSession(model.SerializeToString(),
+                                        providers=["CPUExecutionProvider"])
+    feeds = {name: value for name, value in zip(node.input, inputs)}
+    results = sess.run(None, feeds)
+    for expected, output in zip(outputs, results):
+        assert_allclose(expected, output)
+```
diff --git a/docs/docsgen/source/index.md b/docs/docsgen/source/index.md
new file mode 100644
index 0000000..80168d8
--- /dev/null
+++ b/docs/docsgen/source/index.md
@@ -0,0 +1,19 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+(l-main-doc-page)=
+
+# ONNX documentation
+
+```{toctree}
+:maxdepth: 2
+
+intro/index
+api/index
+operators/index
+technical/index
+repo-docs/index
+```
diff --git a/docs/docsgen/source/intro/concepts.md b/docs/docsgen/source/intro/concepts.md
new file mode 100644
index 0000000..53766e7
--- /dev/null
+++ b/docs/docsgen/source/intro/concepts.md
@@ -0,0 +1,364 @@
+# ONNX Concepts
+
+ONNX can be compared to a programming language specialized
+in mathematical functions. It defines all the necessary operations
+a machine learning model needs to implement its inference function
+with this language. A linear regression could be represented
+in the following way:
+
+```
+def onnx_linear_regressor(X):
+    "ONNX code for a linear regression"
+    return onnx.Add(onnx.MatMul(X, coefficients), bias)
+```
+
+```{index} ONNX graph
+```
+
+This example is very similar to an expression a developer could
+write in Python. It can be also represented as a graph that shows
+step-by-step how to transform the features to get a prediction.
+That's why a machine-learning model implemented with ONNX is often
+referenced as an **ONNX graph**.
+
+```{image} images/linreg1.png
+```
+
+ONNX aims at providing a common language any machine learning framework
+can use to describe its models. The first scenario is to make it easier
+to deploy a machine learning model in production. An ONNX interpreter
+(or **runtime**) can be specifically implemented and optimized for this task
+in the environment where it is deployed. With ONNX, it is possible
+to build a unique process to deploy a model in production and independent
+from the learning framework used to build the model.
+*onnx* implements a python runtime that can be used to evaluate
+ONNX models and to evaluate ONNX ops. This is intended to clarify the
+semantics of ONNX and to help understand and debug ONNX tools
+and converters. It is not intended to be used for production and
+performance is not a goal (see {ref}`l-reference-implementation`).
+
+## Input, Output, Node, Initializer, Attributes
+
+Building an ONNX graph means implementing a function
+with the ONNX language or more precisely the {ref}`l-onnx-operators`.
+A linear regression would be written this way.
+The following lines do not follow python syntax.
+It is just a kind of pseudo-code to illustrate the model.
+
+```
+Input: float[M,K] x, float[K,N] a, float[N] c
+Output: float[M, N] y
+
+r = onnx.MatMul(x, a)
+y = onnx.Add(r, c)
+```
+
+This code implements a function `f(x, a, c) -> y = x @ a + c`.
+And *x*, *a*, *c* are the **inputs**, *y* is the **output**.
+*r* is an intermediate result.
+*MatMul* and *Add* are the **nodes**. They also have inputs and outputs.
+A node has also a type, one of the operators in
+{ref}`l-onnx-operators`. This graph was built with the example
+in Section {ref}`l-onnx-linear-regression-onnx-api`.
+
+The graph could also have an **initializer**. When an input
+never changes such as the coefficients of the linear regression,
+it is most efficient to turn it into a constant stored in the graph.
+
+```
+Input: float[M,K] x
+Initializer: float[K,N] a, float[N] c
+Output: float[M, N] xac
+
+xa = onnx.MatMul(x, a)
+xac = onnx.Add(xa, c)
+```
+
+Visually, this graph would look like the following image.
+The right side describes operator *Add* where the second input
+is defined as an initializer. This graph was obtained with this
+code {ref}`l-onnx-linear-regression-onnx-api-init`.
+
+```{image} images/linreg2.png
+:alt: Snapshot of Netron
+```
+
+An **attribute** is a fixed parameter of an operator. Operator {ref}`l-onnx-doc-Gemm`
+has four attributes, *alpha*, *beta*, *transA*, *transB*. Unless the runtime
+allows it through its API, once it has loaded the ONNX graph, these values
+cannot be changed and remain frozen for all the predictions.
+
+## Serialization with protobuf
+
+The deployment of a machine-learned model into production
+usually requires replicating the entire ecosystem used to
+train the model, most of the time with a *docker*.
+Once a model is converted into ONNX, the production environment
+only needs a runtime to execute the graph defined with ONNX
+operators. This runtime can be developed in any language
+suitable for the production application, C, java, python, javascript,
+C#, Webassembly, ARM...
+
+But to make that happen, the ONNX graph needs to be saved.
+ONNX uses *protobuf* to serialize the graph into
+one single block
+(see [Parsing and Serialization](https://developers.google.com/protocol-buffers/docs/pythontutorial#parsing-and-serialization)). It aims at optimizing the model size
+as much as possible.
+
+## Metadata
+
+Machine learned models are continuously refreshed. It is important
+to keep track of the model version, the author of the model and
+how it was trained. ONNX offers the possibility to store additional data
+in the model itself.
+
+- **doc_string**: Human-readable documentation for this model.
+  : Markdown is allowed.
+- **domain**: A reverse-DNS name to indicate the model namespace or domain,
+  : for example, 'org.onnx'
+- **metadata_props**: Named metadata as dictionary `map<string,string>`,
+  : `(values, keys)` should be distinct.
+- **model_author**: A comma-separated list of names,
+  : The personal name of the author(s) of the model, and/or their organizations.
+- **model_license**: The well-known name or URL of the license
+  : under which the model is made available.
+- **model_version**: The version of the model itself, encoded in an integer.
+- **producer_name**: The name of the tool used to generate the model.
+- **producer_version**: The version of the generating tool.
+- **training_info**: An optional extension that contains
+  : information for training (see {ref}`l-traininginfoproto`)
+
+## List of available operators and domains
+
+The main list is described here: {ref}`l-onnx-operators`.
+It merges standard matrix operators (Add, Sub, MatMul, Transpose,
+Greater, IsNaN, Shape, Reshape...),
+reductions (ReduceSum, ReduceMin, ...)
+image transformations (Conv, MaxPool, ...),
+deep neural networks layer (RNN, DropOut, ...),
+activations functions (Relu, Softmax, ...).
+It covers most of the operations needed to implement
+inference functions from standard and deep machine learning.
+ONNX does not implement every existing machine learning operator,
+the list of operator would be infinite.
+
+The main list of operators is identified with a domain **ai.onnx**.
+A **domain** can be defined as a set of operators.
+A few operators in this list are dedicated to text but they hardly cover
+the needs. The main list is also missing tree based models very
+popular in standard machine learning.
+These are part of another domain **ai.onnx.ml**,
+it includes tree bases models (TreeEnsemble Regressor, ...),
+preprocessing (OneHotEncoder, LabelEncoder, ...), SVM models
+(SVMRegressor, ...), imputer (Imputer).
+
+ONNX only defines these two domains. But the library onnx
+supports any custom domains and operators
+(see {ref}`l-onnx-extensibility`).
+
+## Supported Types
+
+ONNX specifications are optimized for numerical computation with
+tensors. A *tensor* is a multidimensional array. It is defined
+by:
+
+- a type: the element type, the same for all elements in the tensor
+- a shape: an array with all dimensions, this array can be empty,
+  a dimension can be null
+- a contiguous array: it represents all the values
+
+This definition does not include *strides* or the possibility to define
+a view of a tensor based on an existing tensor. An ONNX tensor is a dense
+full array with no stride.
+
+### Element Type
+
+ONNX was initially developed to help deploying deep learning model.
+That's why the specifications were initially designed for floats (32 bits).
+The current version supports all common types. Dictionary
+{ref}`l-onnx-types-mapping` gives the correspondence between *ONNX*
+and {mod}`numpy`.
+
+```{eval-rst}
+.. exec_code::
+
+    import re
+    from onnx import TensorProto
+
+    reg = re.compile('^[0-9A-Z_]+$')
+
+    values = {}
+    for att in sorted(dir(TensorProto)):
+        if att in {'DESCRIPTOR'}:
+            continue
+        if reg.match(att):
+            values[getattr(TensorProto, att)] = att
+    for i, att in sorted(values.items()):
+        si = str(i)
+        if len(si) == 1:
+            si = " " + si
+        print("%s: onnx.TensorProto.%s" % (si, att))
+```
+
+ONNX is strongly typed and its definition does not support
+implicit cast. ONNX does not allow addition of two tensors
+or matrices with different types, even if other languages do.
+That's why an explicit cast must be inserted in a graph.
+
+### Sparse Tensor
+
+Sparse tensors are useful to represent arrays having many null coefficients.
+ONNX supports 2D sparse tensor. Class {ref}`l-onnx-sparsetensor-proto`
+defines attributes `dims`, `indices` (int64) and `values`.
+
+### Other types
+
+In addition to tensors and sparse tensors, ONNX supports sequences of tensors,
+map of tensors, sequences of map of tensors through types
+{ref}`l-onnx-sequence-proto`, {ref}`l-onnx-map-proto`. They are rarely used.
+
+## What is an opset version?
+
+The opset is mapped to the version of the *onnx* package.
+It is incremented every time the minor version increases.
+Every version brings updated or new operators.
+
+```{eval-rst}
+.. exec_code::
+
+    import onnx
+    print(onnx.__version__, " opset=", onnx.defs.onnx_opset_version())
+```
+
+An opset version is also attached to every ONNX graph.
+It defines the version of all operators inside the graph.
+Operator *Add* was updated in version 6, 7, 13 and 14. If the
+graph opset is 15, it means operator *Add* follows specifications
+version 14. If the graph opset is 12, then operator *Add* follows
+specifications version 7. An operator in a graph follows its most
+recent definition below (or equal) the global graph opset.
+
+A graph may include operators from several domains, `ai.onnx` and
+`ai.onnx.ml` for example. In that case, the graph must define a
+global opset for every domain. The rule is applied to every
+operators within the same domain.
+
+## Subgraphs, tests and loops
+
+ONNX implements tests and loops. They all take another ONNX
+graphs as an attribute. These structures are usually slow and complex.
+It is better to avoid them if possible.
+
+### If
+
+Operator {ref}`l-onnx-doc-If` executes
+one of the two graphs depending on the condition evaluation.
+
+```
+If(condition) then
+    execute this ONNX graph (`then_branch`)
+else
+    execute this ONNX graph (`else_branch`)
+```
+
+Those two graphs can use any result already computed in the
+graph and must produce the exact same number of outputs.
+These outputs will be the output of the operator `If`.
+
+```{image} images/dot_if.png
+```
+
+(l-operator-scan-onnx-tutorial)=
+
+### Scan
+
+Operator {ref}`l-onnx-doc-Scan` implements a loop with a fixed number of iterations.
+It loops over the rows (or any other dimension) of the inputs and concatenates
+the outputs along the same axis. Let's see an example which implements
+pairwise distances: $M(i,j) = \lVert X_i - X_j \rVert^2$.
+
+```{image} images/dot_scan.png
+```
+
+This loop is efficient even if it is still slower than a custom implementation
+of pairwise distances. It assumes inputs and outputs are tensors and
+automatically concatenate the outputs of every iteration into single
+tensors. The previous example only has one but it could have several.
+
+### Loop
+
+Operator {ref}`l-onnx-doc-Loop` implements a for and a while loop. It can do a fixed
+number of iterators and/or ends when a condition is not met anymore.
+Outputs are processed in two different ways. First one is similar to
+loop {ref}`l-onnx-doc-Scan`, outputs are concatenated into tensors (along the first
+dimension). This also means that these outputs must have compatible shapes.
+Second mechanism concatenates tensors into a sequence of tensors.
+
+(l-onnx-extensibility)=
+
+## Extensibility
+
+ONNX defines a list of operators as the standard: {ref}`l-onnx-operators`.
+However, it is very possible
+to define your own operators under this domain or a new one.
+*onnxruntime* defines custom operators to improve inference.
+Every node has a type, a name,
+named inputs and outputs, and attributes. As long as a node is described
+under these constraints, a node can be added to any ONNX graph.
+
+Pairwise distances can be implemented with operator Scan.
+However, a dedicated operator called CDist is proved significantly
+faster, significantly enough to make the effort to implement a dedicated runtime
+for it.
+
+## Functions
+
+Functions are one way to extend ONNX specifications. Some model requires
+the same combination of operators. This can be avoided by creating a function
+itself defined with existing ONNX operators. Once defined, a function behaves
+like any other operators. It has inputs, outputs and attributes.
+
+There are two advantages of using functions. The first one is to have a
+shorter code and easier to read. The second one is that any onnxruntime
+can leverage that information to run predictions faster. The runtime
+could have a specific implementation for a function not relying on the
+implementation of the existing operators.
+
+## Shape (and Type) Inference
+
+Knowing the shapes of results is not necessary to execute an ONNX graph
+but this information can be used to make it faster. If you have the following
+graph:
+
+```
+Add(x, y) -> z
+Abs(z) -> w
+```
+
+If *x* and *y* have the same shape, then *z* and *w* also have the same
+shape. Knowing that, it is possible to reuse the buffer allocated for *z*,
+to compute the absolute value *w* inplace. Shape inference helps the
+runtime to manage the memory and therefore to be more efficient.
+
+ONNX package can compute in most of the cases the output shape
+knowing the input shape for every standard operator. It cannot
+obviously do that for any custom operator outside of the official
+list.
+
+## Tools
+
+[netron](https://netron.app/)
+is very useful to help visualize ONNX graphs.
+That's the only one without programming. The first screenshot was
+made with this tool.
+
+```{image} images/linreg1.png
+```
+
+[onnx2py.py](https://github.com/microsoft/onnxconverter-common/blob/master/onnxconverter_common/onnx2py.py)
+creates a python file from an ONNX graph. This script can create
+the same graph. It may be modified by a user to change the graph.
+
+[zetane](https://github.com/zetane/viewer)
+can load onnx model and show intermediate results
+when the model is executed.
diff --git a/docs/docsgen/source/intro/converters.md b/docs/docsgen/source/intro/converters.md
new file mode 100644
index 0000000..810aa10
--- /dev/null
+++ b/docs/docsgen/source/intro/converters.md
@@ -0,0 +1,317 @@
+# Converters
+
+Using ONNX in production means the prediction function
+of a model can be implemented with ONNX operators.
+A runtime must be chosen, one available on the platform
+the model is deployed. Discrepancies are checked
+and finally, the latency is measured.
+The first step of the model conversion can be easy
+if there exists a converting library for this framework
+supporting all the pieces of the model. If it is not the
+case, the missing parts must be implemented in ONNX.
+That may be very time consuming.
+
+## What is a converting library?
+
+[sklearn-onnx](https://onnx.ai/sklearn-onnx/) converts
+[scikit-learn](https://scikit-learn.org/stable/) models
+into ONNX. It rewrites the prediction function of a model,
+whatever it is, with ONNX operators using the API introduced
+above. It ensures that the predictions are equal or at least
+very close to the expected predictions computed with the
+original model.
+
+Machine learning libraries usually have their own design.
+That's why there exists a specific converting library for
+each of them. Many of them are listed there:
+[Converting to ONNX format](https://github.com/onnx/tutorials#converting-to-onnx-format).
+Here is a short list:
+
+- [sklearn-onnx](https://onnx.ai/sklearn-onnx/):
+  converts models from [scikit-learn](https://scikit-learn.org/stable/),
+- [tensorflow-onnx](https://github.com/onnx/tensorflow-onnx):
+  converts models from [tensorflow](https://www.tensorflow.org/),
+- [jax2onnx](https://github.com/enpasos/jax2onnx):
+  converts models from [JAX](https://docs.jax.dev/),
+- [onnxmltools](https://github.com/onnx/onnxmltools):
+  converts models from [lightgbm](https://lightgbm.readthedocs.io/),
+  [xgboost](https://xgboost.readthedocs.io/en/stable/),
+  [pyspark](https://spark.apache.org/docs/latest/api/python/),
+  [libsvm](https://github.com/cjlin1/libsvm)
+- [torch.onnx](https://pytorch.org/docs/master/onnx.html):
+  converts model from [pytorch](https://pytorch.org/).
+
+The main challenge for all these libraries is to keep up the rhythm.
+They must be updated everytime ONNX or the library they support
+have a new released version. That means three to five new releases
+per year.
+
+Converting libraries are not compatible among each others.
+[tensorflow-onnx](https://github.com/onnx/tensorflow-onnx)
+is dedicated to tensorflow and only tensorflow.
+The same goes for sklearn-onnx specialized into scikit-learn.
+
+One challenge is customization. It is difficult to support
+custom pieces in a machine learned model.
+They have to write the specific converter for this piece.
+Somehow, it is like implementing
+twice the prediction function. There is one easy case:
+deep learning frameworks have their own primitives to ensure
+the same code can be executed on different environments.
+As long as a custom layer or a subpart is using pieces of
+pytorch or tensorflow, there is not much to do.
+It is a different story for scikit-learn. This package
+does not have its own addition or multiplication, it relies
+on numpy or scipy. The user must implement
+its transformer or predictor with ONNX primitives, whether or
+not it was implemented with numpy.
+
+## Alternatives
+
+One alternative for implementing ONNX export capability is to leverage standard protocols such as the [Array API standard](https://data-apis.org/array-api/latest/), which standardizes a common set of array operations. It enables code reuse across libraries like NumPy, JAX, PyTorch, CuPy and more. [ndonnx](https://github.com/Quantco/ndonnx) enables execution with an ONNX backend and instant ONNX export for Array API compliant code. This diminishes the need for dedicated converter library code since the same code used to implement most of a library can reused in ONNX conversion. It also provides a convenient primitive for converter authors looking for a NumPy-like experience when constructing ONNX graphs.
+
+## Opsets
+
+ONNX releases packages with version numbers like
+`major.minor.fix`. Every minor update means the list of operators
+is different or the signature has changed. It is also associated to
+an opset, version `1.10` is opset 15, `1.11` will be opset 16.
+Every ONNX graph should define the opset it follows. Changing this
+version without updating the operators could make the graph invalid.
+If the opset is left unspecified, ONNX will consider that the graph
+is valid for the latest opset.
+
+New opsets usually introduce new operators. A same inference function
+could be implemented differently, usually in a more efficient way.
+However, the runtime the model is running on may not
+support newest opsets or at least not in the installed version.
+That's why every converting library offers the
+possibility to create an ONNX graph for a specific opset usually called
+`target_opset`. ONNX language describes simple and complex operators.
+Changing the opset is similar to upgrading a library. onnx
+and onnx runtimes must support backward compatibility.
+
+## Other API
+
+Examples in previous sections show that onnx API is
+very verbose. It is also difficult to get a whole picture of
+a graph by reading the code unless it is a small one. Almost
+every converting library has implemented a different API
+to create a graph, usually more simple, less verbose
+than the API of onnx package.
+All API automate the addition of initializers, hide the creation
+of a name of every intermediate result, deal with different
+version for different opset.
+
+### A class Graph with a method add_node
+
+`tensorflow-onnx` implements a class graph.
+It rewrites tensorflow function with ONNX operator when
+ONNX does not have a similar function (see [Erf](https://github.com/onnx/tensorflow-onnx/blob/master/tf2onnx/onnx_opset/math.py#L414).
+
+sklearn-onnx defines two different API. The first one
+introduced in that example [Implement a converter](https://onnx.ai/sklearn-onnx/auto_tutorial/plot_jcustom_syntax.html)
+follows a similar design that tensorflow-onnx follows.
+The following lines are extracted from the converter of a linear
+classifier.
+
+```
+# initializer
+
+coef = scope.get_unique_variable_name('coef')
+model_coef = np.array(
+    classifier_attrs['coefficients'], dtype=np.float64)
+model_coef = model_coef.reshape((number_of_classes, -1)).T
+container.add_initializer(
+    coef, proto_dtype, model_coef.shape, model_coef.ravel().tolist())
+
+intercept = scope.get_unique_variable_name('intercept')
+model_intercept = np.array(
+    classifier_attrs['intercepts'], dtype=np.float64)
+model_intercept = model_intercept.reshape((number_of_classes, -1)).T
+container.add_initializer(
+    intercept, proto_dtype, model_intercept.shape,
+    model_intercept.ravel().tolist())
+
+# add nodes
+
+multiplied = scope.get_unique_variable_name('multiplied')
+container.add_node(
+    'MatMul', [operator.inputs[0].full_name, coef], multiplied,
+    name=scope.get_unique_operator_name('MatMul'))
+
+# [...]
+
+argmax_output_name = scope.get_unique_variable_name('label')
+container.add_node('ArgMax', raw_score_name, argmax_output_name,
+                   name=scope.get_unique_operator_name('ArgMax'),
+                   axis=1)
+```
+
+### Operator as function
+
+The second API shown in [Implement a new converter](https://onnx.ai/sklearn-onnx/auto_tutorial/plot_icustom_converter.html)
+is more compact and defines
+every ONNX operator as composable functions.
+The syntax looks like this for [KMeans](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html),
+less verbose and easier to read.
+
+```
+rs = OnnxReduceSumSquare(
+    input_name, axes=[1], keepdims=1, op_version=opv)
+
+gemm_out = OnnxMatMul(
+    input_name, (C.T * (-2)).astype(dtype), op_version=opv)
+
+z = OnnxAdd(rs, gemm_out, op_version=opv)
+y2 = OnnxAdd(C2, z, op_version=opv)
+ll = OnnxArgMin(y2, axis=1, keepdims=0, output_names=out[:1],
+                op_version=opv)
+y2s = OnnxSqrt(y2, output_names=out[1:], op_version=opv)
+```
+
+## Tricks learned from experience
+
+### Discrepancies
+
+ONNX is strongly typed and optimizes for float32, the most
+common type in deep learning. Libraries in standard
+machine learning use both float32 and float64. numpy
+usually cast to the most generic type, float64. It has no significant
+impact when the prediction function is contiguous.
+When it is not, the right type must be used. Example
+[Issues when switching to float](https://onnx.ai/sklearn-onnx/auto_tutorial/plot_ebegin_float_double.html)
+gives more insights on that topic.
+
+Parallelization changes the order of computation. It is usually
+not significant but it may explain some weird discrepancies.
+`1 + 1e17 - 1e17 = 0` but `1e17 - 1e17 + 1 = 1`. High order of
+magnitude are rare but not so rare when a model uses the inverse
+of a matrix.
+
+### IsolationForest Trick
+
+ONNX only implements a {ref}`TreeEnsembleRegressor
+<l-onnx-docai-onnx-ml-TreeEnsembleRegressor>` but
+it does not offer the possibility to retrieve any information
+about the path the decision followed or statistics to the graph.
+The trick is to used one forest to predict the leaf index and map
+this leaf index one or multiple times with the information needed.
+
+```{image} images/iff.png
+```
+
+### Discretization
+
+Looking in which interval a feature falls into. That's easy to do
+with numpy but not so easy to do efficiently with ONNX.
+The fastest way is to use a TreeEnsembleRegressor, a binary search,
+which outputs the interval index. That's what this example
+implements: [Converter for WOE](https://onnx.ai/sklearn-onnx/auto_tutorial/plot_woe_transformer.html).
+
+### Contribute
+
+[onnx repository](https://github.com/onnx/onnx) must be forked and cloned.
+
+### Build
+
+The windows build requires conda. The following steps might not be up to date.
+Folder [onnx/.github/workflows](https://github.com/onnx/onnx/tree/main/.github/workflows)
+contains the latest instructions.
+
+**Windows**
+
+The build is easier with Anaconda. First: create an environment.
+It must be done only once.
+
+```
+conda create --yes --quiet --name py3.9 python=3.9
+conda install -n py3.9 -y -c conda-forge numpy libprotobuf=3.16.0
+```
+
+Then build the package:
+
+```sh
+git submodule update --init --recursive
+set ONNX_BUILD_TESTS=1
+set ONNX_ML=$(onnx_ml)
+set CMAKE_ARGS=-DONNX_USE_PROTOBUF_SHARED_LIBS=ON -DONNX_USE_LITE_PROTO=ON -DONNX_WERROR=ON
+
+python -m build --wheel
+```
+
+The package can now be installed.
+
+**Linux**
+
+After cloning the repository, the following instructions can be run:
+
+```sh
+python -m build --wheel
+```
+
+### Build the markdown documentation
+
+The package must be built first (see previous section).
+
+```
+set ONNX_BUILD_TESTS=1
+set ONNX_ML=$(onnx_ml)
+set CMAKE_ARGS=-DONNX_USE_PROTOBUF_SHARED_LIBS=ON -DONNX_USE_LITE_PROTO=ON -DONNX_WERROR=ON
+
+python onnx\gen_proto.py -l
+python onnx\gen_proto.py -l --ml
+pip install -e .
+python onnx\backend\test\cmd_tools.py generate-data
+python onnx\backend\test\stat_coverage.py
+python onnx\defs\gen_doc.py
+set ONNX_ML=0
+python onnx\defs\gen_doc.py
+set ONNX_ML=1
+```
+
+### Update an existing operator
+
+All operators are defined in folder
+[onnx/onnx/defs](https://github.com/onnx/onnx/tree/main/onnx/defs).
+There are two files in every subfolder, one called `defs.cc` and another one
+called `old.cc`.
+
+- `defs.cc`: contains the most recent definition for every operator
+- `old.cc`: contains the deprecated version of the operators in previous opset
+
+Updating an operator means copying the definition from `defs.cc` to `old.cc`
+and updating the existing one in `defs.cc`.
+
+One file following the pattern `onnx/defs/operator_sets*.h`
+must be modified. These headers registers the list
+of existing operators.
+
+File [onnx/defs/schema.h](https://github.com/onnx/onnx/blob/main/onnx/defs/schema.h)
+contains the latest opset version. It must be updated too if one opset
+was upgraded.
+
+File [onnx/version_converter/convert.h](https://github.com/onnx/onnx/blob/main/onnx/version_converter/convert.h)
+contains rules to apply when converter a node from an opset to the next one.
+This file may be updated too.
+
+The package must be compiled and the documentation must be generated
+again to automatically update the markdown documentation and it must
+be included in the PR.
+
+Then unit test must be updated.
+
+**Summary**
+
+- Modify files `defs.cc`, `old.cc`, `onnx/defs/operator_sets*.h`,
+  `onnx/defs/schema.h`
+- Optional: modify file `onnx/version_converter/convert.h`
+- Build onnx.
+- Build the documentation.
+- Update unit test.
+
+The PR should include the modified files and the modified markdown documentation,
+usually a subset of
+`docs/docs/Changelog-ml.md`, `docs/Changelog.md`,
+`docs/Operators-ml.md`, `docs/Operators.md`,
+`docs/TestCoverage-ml.md`, `docs/TestCoverage.md`.
diff --git a/docs/docsgen/source/intro/images/dot_att.png b/docs/docsgen/source/intro/images/dot_att.png
new file mode 100644
index 0000000..3fe69c8
Binary files /dev/null and b/docs/docsgen/source/intro/images/dot_att.png differ
diff --git a/docs/docsgen/source/intro/images/dot_if.png b/docs/docsgen/source/intro/images/dot_if.png
new file mode 100644
index 0000000..fb223c5
Binary files /dev/null and b/docs/docsgen/source/intro/images/dot_if.png differ
diff --git a/docs/docsgen/source/intro/images/dot_if_py.png b/docs/docsgen/source/intro/images/dot_if_py.png
new file mode 100644
index 0000000..3f1daa4
Binary files /dev/null and b/docs/docsgen/source/intro/images/dot_if_py.png differ
diff --git a/docs/docsgen/source/intro/images/dot_linreg.png b/docs/docsgen/source/intro/images/dot_linreg.png
new file mode 100644
index 0000000..f5e054d
Binary files /dev/null and b/docs/docsgen/source/intro/images/dot_linreg.png differ
diff --git a/docs/docsgen/source/intro/images/dot_linreg2.png b/docs/docsgen/source/intro/images/dot_linreg2.png
new file mode 100644
index 0000000..eca78bd
Binary files /dev/null and b/docs/docsgen/source/intro/images/dot_linreg2.png differ
diff --git a/docs/docsgen/source/intro/images/dot_scan.png b/docs/docsgen/source/intro/images/dot_scan.png
new file mode 100644
index 0000000..1ddfa65
Binary files /dev/null and b/docs/docsgen/source/intro/images/dot_scan.png differ
diff --git a/docs/docsgen/source/intro/images/dot_scan_py.png b/docs/docsgen/source/intro/images/dot_scan_py.png
new file mode 100644
index 0000000..218bda1
Binary files /dev/null and b/docs/docsgen/source/intro/images/dot_scan_py.png differ
diff --git a/docs/docsgen/source/intro/images/iff.png b/docs/docsgen/source/intro/images/iff.png
new file mode 100644
index 0000000..f370f2e
Binary files /dev/null and b/docs/docsgen/source/intro/images/iff.png differ
diff --git a/docs/docsgen/source/intro/images/linreg1.png b/docs/docsgen/source/intro/images/linreg1.png
new file mode 100644
index 0000000..fb63c94
Binary files /dev/null and b/docs/docsgen/source/intro/images/linreg1.png differ
diff --git a/docs/docsgen/source/intro/images/linreg2.png b/docs/docsgen/source/intro/images/linreg2.png
new file mode 100644
index 0000000..5eee0d5
Binary files /dev/null and b/docs/docsgen/source/intro/images/linreg2.png differ
diff --git a/docs/docsgen/source/intro/images/scanop.png b/docs/docsgen/source/intro/images/scanop.png
new file mode 100644
index 0000000..5b21f98
Binary files /dev/null and b/docs/docsgen/source/intro/images/scanop.png differ
diff --git a/docs/docsgen/source/intro/index.md b/docs/docsgen/source/intro/index.md
new file mode 100644
index 0000000..6df473b
--- /dev/null
+++ b/docs/docsgen/source/intro/index.md
@@ -0,0 +1,15 @@
+(onnx-tutorial)=
+
+# Introduction to ONNX
+
+This documentation describes the ONNX concepts (**Open Neural Network Exchange**).
+It shows how it is used with examples in python and finally explains
+some of challenges faced when moving to ONNX in production.
+
+```{toctree}
+:maxdepth: 2
+
+concepts
+python
+converters
+```
diff --git a/docs/docsgen/source/intro/python.md b/docs/docsgen/source/intro/python.md
new file mode 100644
index 0000000..e452384
--- /dev/null
+++ b/docs/docsgen/source/intro/python.md
@@ -0,0 +1,1601 @@
+# ONNX with Python
+
+```{tip}
+Check out the [ir-py project](https://github.com/onnx/ir-py) for an alternative set of Python APIs for creating and manipulating ONNX models. The ir-py project provides a more modern and ergonomic interface compared to the ONNX Protobuf APIs described here.
+```
+
+Next sections highlight the main functions used to build
+an ONNX graph with the {ref}`Python API <l-python-onnx-api>`
+*onnx* offers.
+
+(l-onnx-linear-regression-onnx-api)=
+
+## A simple example: a linear regression
+
+The linear regression is the most simple model
+in machine learning described by the following expression
+$Y = XA + B$. We can see it as a function of three
+variables $Y = f(X, A, B)$ decomposed into
+`y = Add(MatMul(X, A), B)`. That's what we need to represent
+with ONNX operators. The first thing is to implement a function
+with {ref}`ONNX operators <l-onnx-operators>`.
+ONNX is strongly typed. Shape and type must be defined for both
+input and output of the function. That said, we need four functions
+to build the graph among the {ref}`l-onnx-make-function`:
+
+- `make_tensor_value_info`: declares a variable (input or output)
+  given its shape and type
+- `make_node`: creates a node defined by an operation
+  (an operator type), its inputs and outputs
+- `make_graph`: a function to create an ONNX graph with
+  the objects created by the two previous functions
+- `make_model`: a last function which merges the graph and
+  additional metadata
+
+All along the creation, we need to give a name to every input,
+output of every node of the graph. Input and output of the graph
+are defined by onnx objects, strings are used to refer to
+intermediate results. This is how it looks like.
+
+```{eval-rst}
+.. exec_code::
+
+    # imports
+
+    from onnx import TensorProto
+    from onnx.helper import (
+        make_model, make_node, make_graph,
+        make_tensor_value_info)
+    from onnx.checker import check_model
+
+    # inputs
+
+    # 'X' is the name, TensorProto.FLOAT the type, [None, None] the shape
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+
+    # outputs, the shape is left undefined
+
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+
+    # nodes
+
+    # It creates a node defined by the operator type MatMul,
+    # 'X', 'A' are the inputs of the node, 'XA' the output.
+    node1 = make_node('MatMul', ['X', 'A'], ['XA'])
+    node2 = make_node('Add', ['XA', 'B'], ['Y'])
+
+    # from nodes to graph
+    # the graph is built from the list of nodes, the list of inputs,
+    # the list of outputs and a name.
+
+    graph = make_graph([node1, node2],  # nodes
+                        'lr',  # a name
+                        [X, A, B],  # inputs
+                        [Y])  # outputs
+
+    # onnx graph
+    # there is no metadata in this case.
+
+    onnx_model = make_model(graph)
+
+    # Let's check the model is consistent,
+    # this function is described in section
+    # Checker and Shape Inference.
+    check_model(onnx_model)
+
+    # the work is done, let's display it...
+    print(onnx_model)
+```
+
+```{image} images/dot_linreg.png
+```
+
+An empty shape (`None`) means any shape, a shape defined as `[None, None]`
+tells this object is a tensor with two dimensions without any further precision.
+The ONNX graph can also be inspected by looking into the fields
+of each object of the graph.
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import TensorProto
+    from onnx.helper import (
+        make_model, make_node, make_graph,
+        make_tensor_value_info)
+    from onnx.checker import check_model
+
+    def shape2tuple(shape):
+        return tuple(getattr(d, 'dim_value', 0) for d in shape.dim)
+
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+    node1 = make_node('MatMul', ['X', 'A'], ['XA'])
+    node2 = make_node('Add', ['XA', 'B'], ['Y'])
+    graph = make_graph([node1, node2], 'lr', [X, A, B], [Y])
+    onnx_model = make_model(graph)
+    check_model(onnx_model)
+
+    # the list of inputs
+    print('** inputs **')
+    print(onnx_model.graph.input)
+
+    # in a more nicely format
+    print('** inputs **')
+    for obj in onnx_model.graph.input:
+        print("name=%r dtype=%r shape=%r" % (
+            obj.name, obj.type.tensor_type.elem_type,
+            shape2tuple(obj.type.tensor_type.shape)))
+
+    # the list of outputs
+    print('** outputs **')
+    print(onnx_model.graph.output)
+
+    # in a more nicely format
+    print('** outputs **')
+    for obj in onnx_model.graph.output:
+        print("name=%r dtype=%r shape=%r" % (
+            obj.name, obj.type.tensor_type.elem_type,
+            shape2tuple(obj.type.tensor_type.shape)))
+
+    # the list of nodes
+    print('** nodes **')
+    print(onnx_model.graph.node)
+
+    # in a more nicely format
+    print('** nodes **')
+    for node in onnx_model.graph.node:
+        print("name=%r type=%r input=%r output=%r" % (
+            node.name, node.op_type, node.input, node.output))
+```
+
+The tensor type is an integer value (=1 for `FLOAT`). The helper function {func}`onnx.helper.tensor_dtype_to_np_dtype` converts
+the integer to its corresponding numpy data type (float32 for 1).
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import TensorProto
+    from onnx.helper import tensor_dtype_to_np_dtype, tensor_dtype_to_string
+
+    np_dtype = tensor_dtype_to_np_dtype(TensorProto.FLOAT)
+    print(f"The converted numpy dtype for {tensor_dtype_to_string(TensorProto.FLOAT)} is {np_dtype}.")
+```
+
+## Serialization
+
+ONNX is built on the top of protobuf. It adds the necessary definitions
+to describe a machine learning model and most of the time, ONNX is used
+to serialize or deserialize a model. First section addresses this need.
+Second section introduces the serialization and deserialization of
+data such as tensors, sparse tensors...
+
+### Model Serialization
+
+The model needs to be saved to be deployed.
+ONNX is based on protobuf. It minimizes the space needed
+to save the graph on disk. Every object (see {ref}`l-onnx-classes`)
+in onnx can be serialized with method `SerializeToString`. That's
+the case for the whole model.
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import TensorProto
+    from onnx.helper import (
+        make_model, make_node, make_graph,
+        make_tensor_value_info)
+    from onnx.checker import check_model
+
+    def shape2tuple(shape):
+        return tuple(getattr(d, 'dim_value', 0) for d in shape.dim)
+
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+    node1 = make_node('MatMul', ['X', 'A'], ['XA'])
+    node2 = make_node('Add', ['XA', 'B'], ['Y'])
+    graph = make_graph([node1, node2], 'lr', [X, A, B], [Y])
+    onnx_model = make_model(graph)
+    check_model(onnx_model)
+
+    # The serialization
+    with open("linear_regression.onnx", "wb") as f:
+        f.write(onnx_model.SerializeToString())
+
+    # display
+    print(onnx_model)
+```
+
+The graph can be restored with function `load`:
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import load
+
+    with open("linear_regression.onnx", "rb") as f:
+        onnx_model = load(f)
+
+    # display
+    print(onnx_model)
+```
+
+It looks exactly the same. Any model can be serialized this way
+unless they are bigger than 2 Gb. protobuf is limited to size
+smaller than this threshold. Next sections will show how to
+overcome that limit.
+
+### Data Serialization
+
+The serialization of tensors usually happens like the following:
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx.numpy_helper import from_array
+
+    numpy_tensor = numpy.array([0, 1, 4, 5, 3], dtype=numpy.float32)
+    print(type(numpy_tensor))
+
+    onnx_tensor = from_array(numpy_tensor)
+    print(type(onnx_tensor))
+
+    serialized_tensor = onnx_tensor.SerializeToString()
+    print(type(serialized_tensor))
+
+    with open("saved_tensor.pb", "wb") as f:
+        f.write(serialized_tensor)
+```
+
+And the deserialization like:
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import TensorProto
+    from onnx.numpy_helper import to_array
+
+    with open("saved_tensor.pb", "rb") as f:
+        serialized_tensor = f.read()
+    print(type(serialized_tensor))
+
+    onnx_tensor = TensorProto()
+    onnx_tensor.ParseFromString(serialized_tensor)
+    print(type(onnx_tensor))
+
+    numpy_tensor = to_array(onnx_tensor)
+    print(numpy_tensor)
+```
+
+The same schema can be used for but not limited to {ref}`l-tensorproto`:
+
+```{eval-rst}
+.. exec_code::
+
+    import onnx
+    import pprint
+    pprint.pprint([p for p in dir(onnx)
+                   if p.endswith('Proto') and p[0] != '_'])
+```
+
+This code can be simplified with function *load_tensor_from_string*
+(see {ref}`l-onnx-load-data`).
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import load_tensor_from_string
+
+    with open("saved_tensor.pb", "rb") as f:
+        serialized = f.read()
+    proto = load_tensor_from_string(serialized)
+    print(type(proto))
+```
+
+(l-onnx-linear-regression-onnx-api-init)=
+
+## Initializer, default value
+
+The previous model assumed the coefficients of the linear regression
+were also input of the model. That's not very convenient. They should be
+part of the model itself as constant or **initializer** to follow
+onnx semantic. Next example modifies the previous one to change inputs
+`A` and `B` into initializers. The package implements two functions to
+convert from numpy into onnx and the other way around
+(see {ref}`l-numpy-helper-onnx-array`).
+
+- `onnx.numpy_helper.to_array`: converts from onnx to numpy
+- `onnx.numpy_helper.from_array`: converts from numpy to onnx
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto
+    from onnx.helper import (
+        make_model, make_node, make_graph,
+        make_tensor_value_info)
+    from onnx.checker import check_model
+
+    # initializers
+    value = numpy.array([0.5, -0.6], dtype=numpy.float32)
+    A = numpy_helper.from_array(value, name='A')
+
+    value = numpy.array([0.4], dtype=numpy.float32)
+    C = numpy_helper.from_array(value, name='C')
+
+    # the part which does not change
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+    node1 = make_node('MatMul', ['X', 'A'], ['AX'])
+    node2 = make_node('Add', ['AX', 'C'], ['Y'])
+    graph = make_graph([node1, node2], 'lr', [X], [Y], [A, C])
+    onnx_model = make_model(graph)
+    check_model(onnx_model)
+
+    print(onnx_model)
+```
+
+```{image} images/dot_linreg2.png
+```
+
+Again, it is possible to go through the onnx structure to check
+how the initializers look like.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto
+    from onnx.helper import (
+        make_model, make_node, make_graph,
+        make_tensor_value_info)
+    from onnx.checker import check_model
+
+    # initializers
+    value = numpy.array([0.5, -0.6], dtype=numpy.float32)
+    A = numpy_helper.from_array(value, name='A')
+
+    value = numpy.array([0.4], dtype=numpy.float32)
+    C = numpy_helper.from_array(value, name='C')
+
+    # the part which does not change
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+    node1 = make_node('MatMul', ['X', 'A'], ['AX'])
+    node2 = make_node('Add', ['AX', 'C'], ['Y'])
+    graph = make_graph([node1, node2], 'lr', [X], [Y], [A, C])
+    onnx_model = make_model(graph)
+    check_model(onnx_model)
+
+    print('** initializer **')
+    for init in onnx_model.graph.initializer:
+        print(init)
+```
+
+The type is defined as integer as well with the same meaning.
+In this second example, there is only one input left.
+Input `A` and `B` were removed. They could be kept. In that case,
+they are optional: every initializer sharing the same name as input
+is considered as a default value. It replaces the input if this one
+is not given.
+
+## Attributes
+
+Some operators need attributes such as {ref}`l-onnx-doc-Transpose` operator.
+Let's build the graph for expression $y = XA' + B$ or
+`y = Add(MatMul(X, Transpose(A)) + B)`. Transpose needs an attribute
+defining the permutation of axes: `perm=[1, 0]`. It is added
+as a named attribute in function `make_node`.
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import TensorProto
+    from onnx.helper import (
+        make_model, make_node, make_graph,
+        make_tensor_value_info)
+    from onnx.checker import check_model
+
+    # unchanged
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+
+    # added
+    node_transpose = make_node('Transpose', ['A'], ['tA'], perm=[1, 0])
+
+    # unchanged except A is replaced by tA
+    node1 = make_node('MatMul', ['X', 'tA'], ['XA'])
+    node2 = make_node('Add', ['XA', 'B'], ['Y'])
+
+    # node_transpose is added to the list
+    graph = make_graph([node_transpose, node1, node2],
+                       'lr', [X, A, B], [Y])
+    onnx_model = make_model(graph)
+    check_model(onnx_model)
+
+    # the work is done, let's display it...
+    print(onnx_model)
+```
+
+```{image} images/dot_att.png
+```
+
+The whole list of *make* functions is the following. Many of them
+are described in section {ref}`l-onnx-make-function`.
+
+```{eval-rst}
+.. exec_code::
+
+    import onnx
+    import pprint
+    pprint.pprint([k for k in dir(onnx.helper)
+                   if k.startswith('make')])
+```
+
+## Opset and metadata
+
+Let's load the ONNX file previously created and check
+what kind of metadata it has.
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import load
+
+    with open("linear_regression.onnx", "rb") as f:
+        onnx_model = load(f)
+
+    for field in ['doc_string', 'domain', 'functions',
+                  'ir_version', 'metadata_props', 'model_version',
+                  'opset_import', 'producer_name', 'producer_version',
+                  'training_info']:
+        print(field, getattr(onnx_model, field))
+```
+
+Most of them are empty because it was not filled when the ONNX
+graph was created. Two of them have a value:
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import load
+
+    with open("linear_regression.onnx", "rb") as f:
+        onnx_model = load(f)
+
+    print("ir_version:", onnx_model.ir_version)
+    for opset in onnx_model.opset_import:
+        print("opset domain=%r version=%r" % (opset.domain, opset.version))
+```
+
+`IR` defined the version of ONNX language.
+Opset defines the version of operators being used.
+Without any precision, ONNX uses the latest version available
+coming from the installed package.
+Another one can be used.
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import load
+
+    with open("linear_regression.onnx", "rb") as f:
+        onnx_model = load(f)
+
+    del onnx_model.opset_import[:]
+    opset = onnx_model.opset_import.add()
+    opset.domain = ''
+    opset.version = 14
+
+    for opset in onnx_model.opset_import:
+        print("opset domain=%r version=%r" % (opset.domain, opset.version))
+```
+
+Any opset can be used as long as all operators are defined
+the way ONNX specifies it. Version 5 of operator *Reshape*
+defines the shape as an input and not as an attribute like in
+version 1. The opset tells which specifications is followed
+while describing the graph.
+
+The other metadata can be used to store any information,
+to store information about the way the model was generated,
+a way to distinguish a model from another one with a version
+number.
+
+```{eval-rst}
+.. exec_code::
+
+    from onnx import load, helper
+
+    with open("linear_regression.onnx", "rb") as f:
+        onnx_model = load(f)
+
+    onnx_model.model_version = 15
+    onnx_model.producer_name = "something"
+    onnx_model.producer_version = "some other thing"
+    onnx_model.doc_string = "documentation about this model"
+    prop = onnx_model.metadata_props
+
+    data = dict(key1="value1", key2="value2")
+    helper.set_model_props(onnx_model, data)
+
+    print(onnx_model)
+```
+
+Field `training_info` can be used to store additional graphs.
+See [training_tool_test.py](https://github.com/onnx/onnx/blob/main/onnx/test/training_tool_test.py)
+to see how it works.
+
+## Subgraph: test and loops
+
+They are usually grouped in a category called *control flow*.
+It is usually better to avoid them as they are not as efficient
+as the matrix operation are much faster and optimized.
+
+### If
+
+A test can be implemented with operator {ref}`l-onnx-doc-If`.
+It executes one subgraph or another depending on one
+boolean. This is not used very often as a function usually
+needs the result of many comparisons in a batch.
+The following example computes the sum of all floats
+in a matrix based on the sign, returns 1 or -1.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    import onnx
+    from onnx.helper import (
+        make_node, make_graph, make_model, make_tensor_value_info)
+    from onnx.numpy_helper import from_array
+    from onnx.checker import check_model
+    from onnxruntime import InferenceSession
+
+    # initializers
+    value = numpy.array([0], dtype=numpy.float32)
+    zero = from_array(value, name='zero')
+
+    # Same as before, X is the input, Y is the output.
+    X = make_tensor_value_info('X', onnx.TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', onnx.TensorProto.FLOAT, [None])
+
+    # The node building the condition. The first one
+    # sum over all axes.
+    rsum = make_node('ReduceSum', ['X'], ['rsum'])
+    # The second compares the result to 0.
+    cond = make_node('Greater', ['rsum', 'zero'], ['cond'])
+
+    # Builds the graph is the condition is True.
+    # Input for then
+    then_out = make_tensor_value_info(
+        'then_out', onnx.TensorProto.FLOAT, None)
+    # The constant to return.
+    then_cst = from_array(numpy.array([1]).astype(numpy.float32))
+
+    # The only node.
+    then_const_node = make_node(
+        'Constant', inputs=[],
+        outputs=['then_out'],
+        value=then_cst, name='cst1')
+
+    # And the graph wrapping these elements.
+    then_body = make_graph(
+        [then_const_node], 'then_body', [], [then_out])
+
+    # Same process for the else branch.
+    else_out = make_tensor_value_info(
+        'else_out', onnx.TensorProto.FLOAT, [5])
+    else_cst = from_array(numpy.array([-1]).astype(numpy.float32))
+
+    else_const_node = make_node(
+        'Constant', inputs=[],
+        outputs=['else_out'],
+        value=else_cst, name='cst2')
+
+    else_body = make_graph(
+        [else_const_node], 'else_body',
+        [], [else_out])
+
+    # Finally the node If taking both graphs as attributes.
+    if_node = onnx.helper.make_node(
+        'If', ['cond'], ['Y'],
+        then_branch=then_body,
+        else_branch=else_body)
+
+    # The final graph.
+    graph = make_graph([rsum, cond, if_node], 'if', [X], [Y], [zero])
+    onnx_model = make_model(graph)
+    check_model(onnx_model)
+
+    # Let's freeze the opset.
+    del onnx_model.opset_import[:]
+    opset = onnx_model.opset_import.add()
+    opset.domain = ''
+    opset.version = 15
+    onnx_model.ir_version = 8
+
+    # Save.
+    with open("onnx_if_sign.onnx", "wb") as f:
+        f.write(onnx_model.SerializeToString())
+
+    # Let's see the output.
+    sess = InferenceSession(onnx_model.SerializeToString(),
+                            providers=["CPUExecutionProvider"])
+
+    x = numpy.ones((3, 2), dtype=numpy.float32)
+    res = sess.run(None, {'X': x})
+
+    # It works.
+    print("result", res)
+    print()
+
+    # Some display.
+    print(onnx_model)
+```
+
+The whole is easier to visualize with the following image.
+
+```{image} images/dot_if_py.png
+```
+
+Both else and then branches are very simple.
+Node *If* could even be replaced with a node *Where* and
+that would be faster. It becomes interesting when both branches
+are bigger and skipping one is more efficient.
+
+### Scan
+
+{ref}`l-onnx-doc-Scan` seems quite complex when reading the specifications.
+It is useful to loop over one dimension of a tensor and store
+the results in a preallocated tensor.
+
+The following example implements a classic nearest neighbors for
+a regression problem. The first step consists in computing the
+pairwise distances between the input features *X* and the training
+set *W*: $dist(X,W) = (M_{ij}) = (\norm{X_i - W_j}^2)_{ij}$. It is
+followed by an operator {ref}`l-onnx-doc-TopK` which extracts the *k* nearest
+neighbors.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto
+    from onnx.helper import (
+        make_model, make_node, set_model_props, make_tensor, make_graph,
+        make_tensor_value_info)
+    from onnx.checker import check_model
+
+    # subgraph
+    initializers = []
+    nodes = []
+    inputs = []
+    outputs = []
+
+    value = make_tensor_value_info('next_in', 1, [None, 4])
+    inputs.append(value)
+    value = make_tensor_value_info('next', 1, [None])
+    inputs.append(value)
+
+    value = make_tensor_value_info('next_out', 1, [None, None])
+    outputs.append(value)
+    value = make_tensor_value_info('scan_out', 1, [None])
+    outputs.append(value)
+
+    node = make_node(
+        'Identity', ['next_in'], ['next_out'],
+        name='cdistd_17_Identity', domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'Sub', ['next_in', 'next'], ['cdistdf_17_C0'],
+        name='cdistdf_17_Sub', domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'ReduceSumSquare', ['cdistdf_17_C0'], ['cdistdf_17_reduced0'],
+        name='cdistdf_17_ReduceSumSquare', axes=[1], keepdims=0, domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'Identity', ['cdistdf_17_reduced0'],
+        ['scan_out'], name='cdistdf_17_Identity', domain='')
+    nodes.append(node)
+
+    graph = make_graph(nodes, 'OnnxIdentity',
+                       inputs, outputs, initializers)
+
+    # main graph
+
+    initializers = []
+    nodes = []
+    inputs = []
+    outputs = []
+
+    opsets = {'': 15, 'ai.onnx.ml': 15}
+    target_opset = 15  # subgraphs
+
+    # initializers
+    list_value = [23.29599822460675, -120.86516699239603, -144.70495899914215, -260.08772982740413,
+                  154.65272105889147, -122.23295157108991, 247.45232560871727, -182.83789715805776,
+                  -132.92727431421793, 147.48710175784703, 88.27761768038069, -14.87785569894749,
+                  111.71487894705504, 301.0518319089629, -29.64235742280055, -113.78493504731911,
+                  -204.41218591022718, 112.26561056133608, 66.04032954135549,
+                  -229.5428380626701, -33.549262642481615, -140.95737409864623, -87.8145187836131,
+                  -90.61397011283958, 57.185488100413366, 56.864151796743855, 77.09054590340892,
+                  -187.72501631246712, -42.779503579806025, -21.642642730674076, -44.58517761667535,
+                  78.56025104939847, -23.92423223842056, 234.9166231927213, -73.73512816431007,
+                  -10.150864499514297, -70.37105466673813, 65.5755688281476, 108.68676290979731, -78.36748960443065]
+    value = numpy.array(list_value, dtype=numpy.float64).reshape((2, 20))
+    tensor = numpy_helper.from_array(
+        value, name='knny_ArrayFeatureExtractorcst')
+    initializers.append(tensor)
+
+    list_value = [1.1394007205963135, -0.6848101019859314, -1.234825849533081, 0.4023416340351105,
+                  0.17742614448070526, 0.46278226375579834, -0.4017809331417084, -1.630198359489441,
+                  -0.5096521973609924, 0.7774903774261475, -0.4380742907524109, -1.2527953386306763,
+                  -1.0485529899597168, 1.950775384902954, -1.420017957687378, -1.7062702178955078,
+                  1.8675580024719238, -0.15135720372200012, -0.9772778749465942, 0.9500884413719177,
+                  -2.5529897212982178, -0.7421650290489197, 0.653618574142456, 0.8644362092018127,
+                  1.5327792167663574, 0.37816253304481506, 1.4693588018417358, 0.154947429895401,
+                  -0.6724604368209839, -1.7262825965881348, -0.35955315828323364, -0.8131462931632996,
+                  -0.8707971572875977, 0.056165341287851334, -0.5788496732711792, -0.3115525245666504,
+                  1.2302906513214111, -0.302302747964859, 1.202379822731018, -0.38732680678367615,
+                  2.269754648208618, -0.18718385696411133, -1.4543657302856445, 0.04575851559638977,
+                  -0.9072983860969543, 0.12898291647434235, 0.05194539576768875, 0.7290905714035034,
+                  1.4940791130065918, -0.8540957570075989, -0.2051582634449005, 0.3130677044391632,
+                  1.764052391052246, 2.2408931255340576, 0.40015721321105957, 0.978738009929657,
+                  0.06651721894741058, -0.3627411723136902, 0.30247190594673157, -0.6343221068382263,
+                  -0.5108051300048828, 0.4283318817615509, -1.18063223361969, -0.02818222902715206,
+                  -1.6138978004455566, 0.38690251111984253, -0.21274028718471527, -0.8954665660858154,
+                  0.7610377073287964, 0.3336743414402008, 0.12167501449584961, 0.44386324286460876,
+                  -0.10321885347366333, 1.4542734622955322, 0.4105985164642334, 0.14404356479644775,
+                  -0.8877857327461243, 0.15634897351264954, -1.980796456336975, -0.34791216254234314]
+    value = numpy.array(list_value, dtype=numpy.float32).reshape((20, 4))
+    tensor = numpy_helper.from_array(value, name='Sc_Scancst')
+    initializers.append(tensor)
+
+    value = numpy.array([2], dtype=numpy.int64)
+    tensor = numpy_helper.from_array(value, name='To_TopKcst')
+    initializers.append(tensor)
+
+    value = numpy.array([2, -1, 2], dtype=numpy.int64)
+    tensor = numpy_helper.from_array(value, name='knny_Reshapecst')
+    initializers.append(tensor)
+
+    # inputs
+    value = make_tensor_value_info('input', 1, [None, 4])
+    inputs.append(value)
+
+    # outputs
+    value = make_tensor_value_info('variable', 1, [None, 2])
+    outputs.append(value)
+
+    # nodes
+
+    node = make_node(
+        'Scan', ['input', 'Sc_Scancst'], ['UU032UU', 'UU033UU'],
+        name='Sc_Scan', body=graph, num_scan_inputs=1, domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'Transpose', ['UU033UU'], ['Tr_transposed0'],
+        name='Tr_Transpose', perm=[1, 0], domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'Sqrt', ['Tr_transposed0'], ['Sq_Y0'],
+        name='Sq_Sqrt', domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'TopK', ['Sq_Y0', 'To_TopKcst'], ['To_Values0', 'To_Indices1'],
+        name='To_TopK', largest=0, sorted=1, domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'Flatten', ['To_Indices1'], ['knny_output0'],
+        name='knny_Flatten', domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'ArrayFeatureExtractor',
+        ['knny_ArrayFeatureExtractorcst', 'knny_output0'], ['knny_Z0'],
+        name='knny_ArrayFeatureExtractor', domain='ai.onnx.ml')
+    nodes.append(node)
+
+    node = make_node(
+        'Reshape', ['knny_Z0', 'knny_Reshapecst'], ['knny_reshaped0'],
+        name='knny_Reshape', allowzero=0, domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'Transpose', ['knny_reshaped0'], ['knny_transposed0'],
+        name='knny_Transpose', perm=[1, 0, 2], domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'Cast', ['knny_transposed0'], ['Ca_output0'],
+        name='Ca_Cast', to=TensorProto.FLOAT, domain='')
+    nodes.append(node)
+
+    node = make_node(
+        'ReduceMean', ['Ca_output0'], ['variable'],
+        name='Re_ReduceMean', axes=[2], keepdims=0, domain='')
+    nodes.append(node)
+
+    # graph
+    graph = make_graph(nodes, 'KNN regressor', inputs, outputs, initializers)
+
+    # model
+    onnx_model = make_model(graph)
+    onnx_model.ir_version = 8
+    onnx_model.producer_name = 'skl2onnx'
+    onnx_model.producer_version = ''
+    onnx_model.domain = 'ai.onnx'
+    onnx_model.model_version = 0
+    onnx_model.doc_string = ''
+    set_model_props(onnx_model, {})
+
+    # opsets
+    del onnx_model.opset_import[:]
+    for dom, value in opsets.items():
+        op_set = onnx_model.opset_import.add()
+        op_set.domain = dom
+        op_set.version = value
+
+    check_model(onnx_model)
+    with open("knnr.onnx", "wb") as f:
+        f.write(onnx_model.SerializeToString())
+
+    print(onnx_model)
+```
+
+Visually it looks like the following:
+
+```{image} images/dot_scan_py.png
+```
+
+The subgraph is executed by operator {ref}`l-onnx-doc-Scan`. In this case,
+there is one *scan* input meaning the operator only builds one output.
+
+```
+node = make_node(
+    'Scan', ['X1', 'X2'], ['Y1', 'Y2'],
+    name='Sc_Scan', body=graph, num_scan_inputs=1, domain='')
+```
+
+At the first iteration, the subgraph gets *X1* and the first row of *X2*.
+The graph produces two outputs. The first one replaces *X1* in the next iteration,
+the second one is store in a container to form *Y2*. At the second iteration,
+second input of the subgraph is the second row of *X2*.
+Here is a short summary. Green is the first iteration, blue the second.
+
+```{image} images/scanop.png
+:width: 400
+```
+
+## Functions
+
+As mentioned in previous chapter, functions can be used to shorten
+the code to build the model and offer more possibilities to the runtime
+running predictions to be faster if there exists a specific implementation
+of this function. If it is not the case, the runtime can still use
+the default implementation based on existing operators.
+
+Function `make_function` is used to define a function.
+It works like a graph with less types. It is more like a
+template. This API may evolve. It does not include initializers either.
+
+### A function with no attribute
+
+That's the more simple case. Every input of the function is a dynamic
+object known at execution time.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto
+    from onnx.helper import (
+        make_model, make_node, set_model_props, make_tensor,
+        make_graph, make_tensor_value_info, make_opsetid,
+        make_function)
+    from onnx.checker import check_model
+
+    new_domain = 'custom'
+    opset_imports = [make_opsetid("", 14), make_opsetid(new_domain, 1)]
+
+    # Let's define a function for a linear regression
+
+    node1 = make_node('MatMul', ['X', 'A'], ['XA'])
+    node2 = make_node('Add', ['XA', 'B'], ['Y'])
+
+    linear_regression = make_function(
+        new_domain,            # domain name
+        'LinearRegression',     # function name
+        ['X', 'A', 'B'],        # input names
+        ['Y'],                  # output names
+        [node1, node2],         # nodes
+        opset_imports,          # opsets
+        [])                     # attribute names
+
+    # Let's use it in a graph.
+
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+
+    graph = make_graph(
+        [make_node('LinearRegression', ['X', 'A', 'B'], ['Y1'], domain=new_domain),
+         make_node('Abs', ['Y1'], ['Y'])],
+        'example',
+        [X, A, B], [Y])
+
+    onnx_model = make_model(
+        graph, opset_imports=opset_imports,
+        functions=[linear_regression])  # functions to add)
+    check_model(onnx_model)
+
+    # the work is done, let's display it...
+    print(onnx_model)
+```
+
+### A function with attributes
+
+```{index} ref_attr_name
+```
+
+The following functions are equivalent to the previous one except
+one input, *B*, was converted into an argument named *bias*.
+The code is almost the same except the bias is now a constant.
+Inside the function definition, a node *Constant* is created
+to insert the argument as a result. It is linked to the argument
+with the attribute `ref_attr_name`.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto, AttributeProto
+    from onnx.helper import (
+        make_model, make_node, set_model_props, make_tensor,
+        make_graph, make_tensor_value_info, make_opsetid,
+        make_function)
+    from onnx.checker import check_model
+
+    new_domain = 'custom'
+    opset_imports = [make_opsetid("", 14), make_opsetid(new_domain, 1)]
+
+    # Let's define a function for a linear regression
+    # The first step consists in creating a constant
+    # equal to the input parameter of the function.
+    cst = make_node('Constant',  [], ['B'])
+
+    att = AttributeProto()
+    att.name = "value"
+
+    # This line indicates the value comes from the argument
+    # named 'bias' the function is given.
+    att.ref_attr_name = "bias"
+    att.type = AttributeProto.TENSOR
+    cst.attribute.append(att)
+
+    node1 = make_node('MatMul', ['X', 'A'], ['XA'])
+    node2 = make_node('Add', ['XA', 'B'], ['Y'])
+
+    linear_regression = make_function(
+        new_domain,            # domain name
+        'LinearRegression',     # function name
+        ['X', 'A'],             # input names
+        ['Y'],                  # output names
+        [cst, node1, node2],    # nodes
+        opset_imports,          # opsets
+        ["bias"])               # attribute names
+
+    # Let's use it in a graph.
+
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+
+    graph = make_graph(
+        [make_node('LinearRegression', ['X', 'A'], ['Y1'], domain=new_domain,
+                   # bias is now an argument of the function and is defined as a tensor
+                   bias=make_tensor('former_B', TensorProto.FLOAT, [1], [0.67])),
+         make_node('Abs', ['Y1'], ['Y'])],
+        'example',
+        [X, A], [Y])
+
+    onnx_model = make_model(
+        graph, opset_imports=opset_imports,
+        functions=[linear_regression])  # functions to add)
+    check_model(onnx_model)
+
+    # the work is done, let's display it...
+    print(onnx_model)
+```
+
+## Parsing
+
+Module onnx provides a faster way to define a graph
+and is lot easier to read. That's easy to use when the graph is built
+in a single function, less easy when the graph is built from many
+different functions converting each piece of a machine learning
+pipeline.
+
+```
+import onnx.parser
+from onnx.checker import check_model
+
+input = '''
+    <
+        ir_version: 8,
+        opset_import: [ "" : 15]
+    >
+    agraph (float[I,J] X, float[I] A, float[I] B) => (float[I] Y) {
+        XA = MatMul(X, A)
+        Y = Add(XA, B)
+    }
+    '''
+onnx_model = onnx.parser.parse_model(input)
+check_model(onnx_model)
+
+print(onnx_model)
+```
+
+```
+ir_version: 8
+graph {
+node {
+    input: "X"
+    input: "A"
+    output: "XA"
+    op_type: "MatMul"
+    domain: ""
+}
+node {
+    input: "XA"
+    input: "B"
+    output: "Y"
+    op_type: "Add"
+    domain: ""
+}
+name: "agraph"
+input {
+    name: "X"
+    type {
+    tensor_type {
+        elem_type: 1
+        shape {
+        dim {
+            dim_param: "I"
+        }
+        dim {
+            dim_param: "J"
+        }
+        }
+    }
+    }
+}
+input {
+    name: "A"
+    type {
+    tensor_type {
+        elem_type: 1
+        shape {
+        dim {
+            dim_param: "I"
+        }
+        }
+    }
+    }
+}
+input {
+    name: "B"
+    type {
+    tensor_type {
+        elem_type: 1
+        shape {
+        dim {
+            dim_param: "I"
+        }
+        }
+    }
+    }
+}
+output {
+    name: "Y"
+    type {
+    tensor_type {
+        elem_type: 1
+        shape {
+        dim {
+            dim_param: "I"
+        }
+        }
+    }
+    }
+}
+}
+opset_import {
+domain: ""
+version: 15
+}
+```
+
+This way is used to create small models but it is rarely used
+in converting libraries.
+
+## Checker and Shape Inference
+
+onnx provides a function to check the model is valid.
+It checks input type or shapes whenever it can detect inconsistency.
+The following example adds two matrices of different types
+which is not allowed.
+
+```{eval-rst}
+.. exec_code::
+
+    import onnx.parser
+    import onnx.checker
+
+    input = '''
+        <
+            ir_version: 8,
+            opset_import: [ "" : 15]
+        >
+        agraph (float[I,4] X, float[4,2] A, int[4] B) => (float[I] Y) {
+            XA = MatMul(X, A)
+            Y = Add(XA, B)
+        }
+        '''
+    try:
+        onnx_model = onnx.parser.parse_model(input)
+        onnx.checker.check_model(onnx_model)
+    except Exception as e:
+        print(e)
+```
+
+`check_model` raises an error due to that inconsistency.
+This work for all operators defined in the main domain or the ML domain.
+It remains silent for any custom operator not defined in any specification.
+
+Shape inference serves one purpose: estimate the shape
+and the type of intermediate results.
+If known, the runtime can estimate the memory consumption
+beforehand and optimize the computation. It can fuse some
+operators, it can do the computation inplace...
+
+```{eval-rst}
+.. exec_code::
+
+    import onnx.parser
+    from onnx import helper, shape_inference
+
+    input = '''
+        <
+            ir_version: 8,
+            opset_import: [ "" : 15]
+        >
+        agraph (float[I,4] X, float[4,2] A, float[4] B) => (float[I] Y) {
+            XA = MatMul(X, A)
+            Y = Add(XA, B)
+        }
+        '''
+    onnx_model = onnx.parser.parse_model(input)
+    inferred_model = shape_inference.infer_shapes(onnx_model)
+
+    print(inferred_model)
+```
+
+There is a new attribute `value_info` which stores the inferred shapes.
+Letter `I` in `dim_param: "I"` can be seen as a variable. It depends on the inputs
+but the function is able to tell which intermediate result will share
+the same dimension.
+Shape inference does not work all the time. For example,
+a Reshape operator. Shape inference only works if the shape is constant.
+If not constant, the shape cannot be easily inferred unless
+the following nodes expect specific shape.
+
+## Evaluation and Runtime
+
+The ONNX standard allows frameworks to export trained models in ONNX format,
+and enables inference using any backend that supports the ONNX format.
+*onnxruntime* is one efficient option. It is available in many platforms.
+It is optimized for fast inference. Its coverage can be tracked on
+[ONNX Backend Dashboard](https://onnx.ai/backend-scoreboard/).
+*onnx* implements a python runtime useful to help understand a model.
+It is not intended to be used for production and performance is not a goal.
+
+### Evaluation of a linear regression
+
+Full API is described at {ref}`l-reference-implementation`.
+It takes a model (a *ModelProto*, a filename, ...).
+Method `run` returns the outputs for a given set of inputs
+specified in a dictionary.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto
+    from onnx.helper import (
+        make_model, make_node, set_model_props, make_tensor,
+        make_graph, make_tensor_value_info)
+    from onnx.checker import check_model
+    from onnx.reference import ReferenceEvaluator
+
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+    node1 = make_node('MatMul', ['X', 'A'], ['XA'])
+    node2 = make_node('Add', ['XA', 'B'], ['Y'])
+    graph = make_graph([node1, node2], 'lr', [X, A, B], [Y])
+    onnx_model = make_model(graph)
+    check_model(onnx_model)
+
+    sess = ReferenceEvaluator(onnx_model)
+
+    x = numpy.random.randn(4, 2).astype(numpy.float32)
+    a = numpy.random.randn(2, 1).astype(numpy.float32)
+    b = numpy.random.randn(1, 1).astype(numpy.float32)
+    feeds = {'X': x, 'A': a, 'B': b}
+
+    print(sess.run(None, feeds))
+```
+
+### Evaluation of a node
+
+The evaluator can also evaluate a simple node to check how an operator
+behaves on a specific input.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto
+    from onnx.helper import make_node
+
+    from onnx.reference import ReferenceEvaluator
+
+    node = make_node('EyeLike', ['X'], ['Y'])
+
+    sess = ReferenceEvaluator(node)
+
+    x = numpy.random.randn(4, 2).astype(numpy.float32)
+    feeds = {'X': x}
+
+    print(sess.run(None, feeds))
+```
+
+Similar code would also work on *GraphProto* or *FunctionProto*.
+
+### Evaluation Step by Step
+
+A converting library takes an existing model trained with a machine
+learning framework (*pytorch*, *scikit-learn*, ...) and
+converts the model into an ONNX graph. Complex models usually do not work
+on the first try and seeing intermediate results may help to find the
+part incorrectly converted. Parameter `verbose` displays information
+about intermediate results.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto
+    from onnx.helper import (
+        make_model, make_node, set_model_props, make_tensor,
+        make_graph, make_tensor_value_info)
+    from onnx.checker import check_model
+    from onnx.reference import ReferenceEvaluator
+
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+    node1 = make_node('MatMul', ['X', 'A'], ['XA'])
+    node2 = make_node('Add', ['XA', 'B'], ['Y'])
+    graph = make_graph([node1, node2], 'lr', [X, A, B], [Y])
+    onnx_model = make_model(graph)
+    check_model(onnx_model)
+
+    for verbose in [1, 2, 3, 4]:
+        print()
+        print(f"------ verbose={verbose}")
+        print()
+        sess = ReferenceEvaluator(onnx_model, verbose=verbose)
+
+        x = numpy.random.randn(4, 2).astype(numpy.float32)
+        a = numpy.random.randn(2, 1).astype(numpy.float32)
+        b = numpy.random.randn(1, 1).astype(numpy.float32)
+        feeds = {'X': x, 'A': a, 'B': b}
+
+        print(sess.run(None, feeds))
+```
+
+### Evaluate a custom node
+
+The following example still implements a linear regression
+but adds the identity matrix to *A*: $Y = X(A + I) + B$.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto
+    from onnx.helper import (
+        make_model, make_node, set_model_props, make_tensor,
+        make_graph, make_tensor_value_info)
+    from onnx.checker import check_model
+    from onnx.reference import ReferenceEvaluator
+
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+    node0 = make_node('EyeLike', ['A'], ['Eye'])
+    node1 = make_node('Add', ['A', 'Eye'], ['A1'])
+    node2 = make_node('MatMul', ['X', 'A1'], ['XA1'])
+    node3 = make_node('Add', ['XA1', 'B'], ['Y'])
+    graph = make_graph([node0, node1, node2, node3], 'lr', [X, A, B], [Y])
+    onnx_model = make_model(graph)
+    check_model(onnx_model)
+    with open("linear_regression.onnx", "wb") as f:
+        f.write(onnx_model.SerializeToString())
+
+    sess = ReferenceEvaluator(onnx_model, verbose=2)
+
+    x = numpy.random.randn(4, 2).astype(numpy.float32)
+    a = numpy.random.randn(2, 2).astype(numpy.float32) / 10
+    b = numpy.random.randn(1, 2).astype(numpy.float32)
+    feeds = {'X': x, 'A': a, 'B': b}
+
+    print(sess.run(None, feeds))
+```
+
+What if we combine operators *EyeLike* and *Add* into *AddEyeLike* to
+make it more efficient. Next example replaces these two operators
+by a single one from domain `'optimized'`.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto
+    from onnx.helper import (
+        make_model, make_node, set_model_props, make_tensor,
+        make_graph, make_tensor_value_info, make_opsetid)
+    from onnx.checker import check_model
+
+    X = make_tensor_value_info('X', TensorProto.FLOAT, [None, None])
+    A = make_tensor_value_info('A', TensorProto.FLOAT, [None, None])
+    B = make_tensor_value_info('B', TensorProto.FLOAT, [None, None])
+    Y = make_tensor_value_info('Y', TensorProto.FLOAT, [None])
+
+    node01 = make_node('AddEyeLike', ['A'], ['A1'], domain='optimized')
+
+    node2 = make_node('MatMul', ['X', 'A1'], ['XA1'])
+    node3 = make_node('Add', ['XA1', 'B'], ['Y'])
+    graph = make_graph([node01, node2, node3], 'lr', [X, A, B], [Y])
+
+    onnx_model = make_model(graph, opset_imports=[
+        make_opsetid('', 18), make_opsetid('optimized', 1)
+    ])
+
+    check_model(onnx_model)
+    with open("linear_regression_improved.onnx", "wb") as f:
+        f.write(onnx_model.SerializeToString())
+```
+
+We need to evaluate this model is equivalent to the first one.
+This requires an implementation for this particular node.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx.reference import ReferenceEvaluator
+    from onnx.reference.op_run import OpRun
+
+    class AddEyeLike(OpRun):
+
+        op_domain = "optimized"
+
+        def _run(self, X, alpha=1.):
+            assert len(X.shape) == 2
+            assert X.shape[0] == X.shape[1]
+            X = X.copy()
+            ind = numpy.diag_indices(X.shape[0])
+            X[ind] += alpha
+            return (X,)
+
+    sess = ReferenceEvaluator("linear_regression_improved.onnx", verbose=2, new_ops=[AddEyeLike])
+
+    x = numpy.random.randn(4, 2).astype(numpy.float32)
+    a = numpy.random.randn(2, 2).astype(numpy.float32) / 10
+    b = numpy.random.randn(1, 2).astype(numpy.float32)
+    feeds = {'X': x, 'A': a, 'B': b}
+
+    print(sess.run(None, feeds))
+
+    # Let's check with the previous model.
+
+    sess0 = ReferenceEvaluator("linear_regression.onnx",)
+    sess1 = ReferenceEvaluator("linear_regression_improved.onnx", new_ops=[AddEyeLike])
+
+    y0 = sess0.run(None, feeds)[0]
+    y1 = sess1.run(None, feeds)[0]
+    print(y0)
+    print(y1)
+    print(f"difference: {numpy.abs(y0 - y1).max()}")
+```
+
+Predictions are the same. Let's compare the performance
+on a matrix big enough to see a significant difference.
+
+```{eval-rst}
+.. exec_code::
+
+    import timeit
+    import numpy
+    from onnx.reference import ReferenceEvaluator
+    from onnx.reference.op_run import OpRun
+
+    class AddEyeLike(OpRun):
+
+        op_domain = "optimized"
+
+        def _run(self, X, alpha=1.):
+            assert len(X.shape) == 2
+            assert X.shape[0] == X.shape[1]
+            X = X.copy()
+            ind = numpy.diag_indices(X.shape[0])
+            X[ind] += alpha
+            return (X,)
+
+    sess = ReferenceEvaluator("linear_regression_improved.onnx", verbose=2, new_ops=[AddEyeLike])
+
+    x = numpy.random.randn(4, 100).astype(numpy.float32)
+    a = numpy.random.randn(100, 100).astype(numpy.float32) / 10
+    b = numpy.random.randn(1, 100).astype(numpy.float32)
+    feeds = {'X': x, 'A': a, 'B': b}
+
+    sess0 = ReferenceEvaluator("linear_regression.onnx")
+    sess1 = ReferenceEvaluator("linear_regression_improved.onnx", new_ops=[AddEyeLike])
+
+    y0 = sess0.run(None, feeds)[0]
+    y1 = sess1.run(None, feeds)[0]
+    print(f"difference: {numpy.abs(y0 - y1).max()}")
+    print(f"time with EyeLike+Add: {timeit.timeit(lambda: sess0.run(None, feeds), number=1000)}")
+    print(f"time with AddEyeLike: {timeit.timeit(lambda: sess1.run(None, feeds), number=1000)}")
+```
+
+It seems worth adding an optimized node in this case.
+This kind of optimization is usually called *fusion*.
+Two consecutive operators are fused into an optimized version of both.
+Production usually relies on *onnxruntime* but since
+the optimization uses basic matrix operation, it should bring
+the same performance gain on any other runtime.
+
+## Implementation details
+
+### Python and C++
+
+onnx relies on protobuf to define its type.
+You would assume that a python object is just a wrapper around
+a C pointer on the internal structure. Therefore, it should be
+possible to access internal data from a function receiving a python
+object of type `ModelProto`. But it is not. According to
+[Protobuf 4, changes](https://developers.google.com/protocol-buffers/docs/news/2022-05-06),
+this is no longer possible after version 4 and it is safer to assume the
+only way to get a hold on the content is to serialize the model
+into bytes, give it to the C function, then deserialize it.
+Functions like `check_model` or
+`shape_inference` are calling `SerializeToString` then
+`ParseFromString` before checking the model with a C code.
+
+### Attributes and inputs
+
+There is a clear distinction between the two. Inputs are dynamic and
+may change at every execution. Attributes never changes and an optimizer
+can improve the execution graph assuming it never changes.
+Therefore, it is impossible to turn an input into an attribute.
+And the operator *Constant* is the only operator changing an
+attribute into an input.
+
+### Shape or no shape
+
+onnx usually expects a shape for every input or output
+assuming the rank (or the number of dimensions) is known.
+What if we need to create a valid graph for every dimension?
+This case is still puzzling.
+
+```{eval-rst}
+.. exec_code::
+
+    import numpy
+    from onnx import numpy_helper, TensorProto, FunctionProto
+    from onnx.helper import (
+        make_model, make_node, set_model_props, make_tensor,
+        make_graph, make_tensor_value_info, make_opsetid,
+        make_function)
+    from onnx.checker import check_model
+    from onnxruntime import InferenceSession
+
+    def create_model(shapes):
+        new_domain = 'custom'
+        opset_imports = [make_opsetid("", 14), make_opsetid(new_domain, 1)]
+
+        node1 = make_node('MatMul', ['X', 'A'], ['XA'])
+        node2 = make_node('Add', ['XA', 'A'], ['Y'])
+
+        X = make_tensor_value_info('X', TensorProto.FLOAT, shapes['X'])
+        A = make_tensor_value_info('A', TensorProto.FLOAT, shapes['A'])
+        Y = make_tensor_value_info('Y', TensorProto.FLOAT, shapes['Y'])
+
+        graph = make_graph([node1, node2], 'example', [X, A], [Y])
+
+        onnx_model = make_model(graph, opset_imports=opset_imports)
+        # Let models runnable by onnxruntime with a released ir_version
+        onnx_model.ir_version = 8
+
+        return onnx_model
+
+    print("----------- case 1: 2D x 2D -> 2D")
+    onnx_model = create_model({'X': [None, None], 'A': [None, None], 'Y': [None, None]})
+    check_model(onnx_model)
+    sess = InferenceSession(onnx_model.SerializeToString(),
+                            providers=["CPUExecutionProvider"])
+    res = sess.run(None, {
+        'X': numpy.random.randn(2, 2).astype(numpy.float32),
+        'A': numpy.random.randn(2, 2).astype(numpy.float32)})
+    print(res)
+
+    print("----------- case 2: 2D x 1D -> 1D")
+    onnx_model = create_model({'X': [None, None], 'A': [None], 'Y': [None]})
+    check_model(onnx_model)
+    sess = InferenceSession(onnx_model.SerializeToString(),
+                            providers=["CPUExecutionProvider"])
+    res = sess.run(None, {
+        'X': numpy.random.randn(2, 2).astype(numpy.float32),
+        'A': numpy.random.randn(2).astype(numpy.float32)})
+    print(res)
+
+    print("----------- case 3: 2D x 0D -> 0D")
+    onnx_model = create_model({'X': [None, None], 'A': [], 'Y': []})
+    check_model(onnx_model)
+    try:
+        InferenceSession(onnx_model.SerializeToString(),
+                         providers=["CPUExecutionProvider"])
+    except Exception as e:
+        print(e)
+
+    print("----------- case 4: 2D x None -> None")
+    onnx_model = create_model({'X': [None, None], 'A': None, 'Y': None})
+    try:
+        check_model(onnx_model)
+    except Exception as e:
+        print(type(e), e)
+    sess = InferenceSession(onnx_model.SerializeToString(),
+                            providers=["CPUExecutionProvider"])
+    res = sess.run(None, {
+        'X': numpy.random.randn(2, 2).astype(numpy.float32),
+        'A': numpy.random.randn(2).astype(numpy.float32)})
+    print(res)
+    print("----------- end")
+```
diff --git a/docs/docsgen/source/onnx-favicon.png b/docs/docsgen/source/onnx-favicon.png
new file mode 100644
index 0000000..dfe4177
Binary files /dev/null and b/docs/docsgen/source/onnx-favicon.png differ
diff --git a/docs/docsgen/source/onnx_sphinx.py b/docs/docsgen/source/onnx_sphinx.py
new file mode 100644
index 0000000..da292e4
--- /dev/null
+++ b/docs/docsgen/source/onnx_sphinx.py
@@ -0,0 +1,905 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Automates the generation of ONNX operators."""
+
+from __future__ import annotations
+
+import difflib
+import importlib
+import inspect
+import keyword
+import os
+import pathlib
+import re
+import shutil
+import sys
+import textwrap
+from typing import Any
+
+import jinja2
+import numpy as np
+from sphinx.util import logging
+
+import onnx
+from onnx.backend.test.case.base import _Exporter
+from onnx.defs import OpSchema
+
+REPO_DOCS_EXCLUDE = {
+    "Changelog-ml.md",
+    "Changelog.md",
+    "CIPipelines.md",
+    "CONTRIBUTING.md",
+    "Operators-ml.md",
+    "Operators.md",
+    "Relicensing.md",
+    "TestCoverage-ml.md",
+    "TestCoverage.md",
+}
+
+
+def _get_diff_template():
+    return jinja2.Template(
+        textwrap.dedent(
+            """
+            <div id="{{ div_name }}"></div>
+            <link rel="stylesheet" type="text/css" href="../_static/diff2html.min.css" />
+            <script type="text/javascript" src="../_static/diff2html-ui-slim.min.js"></script>
+            <script>
+            const diffString = `
+            --- a/{{ op_name }}{{ version1 }}
+            +++ b/{{ op_name }}{{ version2 }}
+            @@ -1 +1 @@
+            {{ diff_content }}
+            `;
+
+            document.addEventListener('DOMContentLoaded', function () {
+            var targetElement = document.getElementById('{{ div_name }}');
+            var configuration = {
+                drawFileList: true,
+                fileListToggle: false,
+                fileListStartVisible: false,
+                fileContentToggle: false,
+                matching: 'lines',
+                outputFormat: 'line-by-line',
+                synchronisedScroll: true,
+                highlight: true,
+                renderNothingWhenEmpty: false,
+            };
+            var diff2htmlUi = new Diff2HtmlUI(targetElement, diffString, configuration);
+            diff2htmlUi.draw();
+            diff2htmlUi.highlightCode();
+            });
+            </script>
+            """
+        ),
+        autoescape=True,
+    )
+
+
+def _get_ops_template():
+    return jinja2.Template(
+        """\
+{% for sch in schemas %}
+
+.. tag-diff-insert.
+
+(l-onnx-op{{sch.domain.lower().replace(".", "-")}}-{{sch.name.lower()}}-{{str(sch.since_version)}})=
+
+## {{format_name_with_domain(sch)}}
+
+### Version
+
+- **name**: [{{sch.name}} (GitHub)]({{build_doc_url(sch)}}{{sch.name}})
+- **domain**: `{% if sch.domain == '' %}main{% else %}{{sch.domain}}{% endif %}`
+- **since_version**: `{{sch.since_version}}`
+- **function**: `{{sch.has_function or sch.has_context_dependent_function}}`
+- **support_level**: `{{sch.support_level}}`
+- **shape inference**: `{{sch.has_type_and_shape_inference_function}}`
+
+{% if sch.support_level == OpSchema.SupportType.EXPERIMENTAL %}
+No versioning maintained for experimental ops.
+{% else %}
+This version of the operator has been {% if
+sch.deprecated %}deprecated{% else %}available{% endif %}
+**since version {{sch.since_version}}{% if
+sch.domain %} of domain {{sch.domain}}{% endif %}**.
+{% if len(sch.versions) > 1 %}
+Other versions of this operator:
+{% for v in sch.version[:-1] %} {{v}} {% endfor %}
+{% endif %}
+{% endif %}
+
+### Summary
+
+{{process_documentation(sch.doc)}}
+
+{% if sch.has_function %}
+
+#### Function Body
+
+The function definition for this operator.
+
+```
+{{get_function_body(sch)}}
+```
+{% endif %}
+{% if sch.attributes %}
+
+### Attributes
+
+{% for _, attr in sorted(sch.attributes.items())
+%}* **{{attr.name}} - {{str(attr.type).split('.')[-1]}}**{%
+  if attr.required %} (required){% endif %} {%
+  if attr.default_value %}{{clean_default_value(attr)}}{%
+  endif %}:
+
+{{text_indent(attr.description, 2)}}
+
+{% endfor %}
+{% endif %}
+{% if sch.inputs %}
+
+### Inputs
+
+{% if sch.min_input != sch.max_input %}Between {{sch.min_input
+}} and {{sch.max_input}} inputs.
+{% endif %}
+{% for ii, inp in enumerate(sch.inputs) %}
+- **{{getname(inp, ii)}}**{{format_option(inp)}} - **{{inp.type_str}}**:
+
+{{text_indent(inp.description, 2)}}{% endfor %}
+{% endif %}
+{% if sch.outputs %}
+
+### Outputs
+
+{% if sch.min_output != sch.max_output %}Between {{sch.min_output
+}} and {{sch.max_output}} outputs.
+{% endif %}
+{% for ii, out in enumerate(sch.outputs) %}
+- **{{getname(out, ii)}}**{{format_option(out)}} - **{{out.type_str}}**:
+
+{{text_indent(out.description, 2)}}{% endfor %}
+{% endif %}
+{% if sch.type_constraints %}
+
+### Type Constraints
+
+{% for ii, type_constraint in enumerate(sch.type_constraints)
+%}* {{get_constraint(type_constraint, ii)}}:
+
+{{text_indent(type_constraint.description, 2)}}
+{% endfor %}
+{% endif %}
+{% if examples and is_last_schema(sch): %}
+
+### Examples
+
+{% for example, code in examples.items(): %}
+
+#### {{ example }}
+
+```python
+{{ format_example(code) }}
+```
+{% endfor %}
+{% endif %}
+{% endfor %}""",
+        autoescape=jinja2.select_autoescape(),
+    )
+
+
+def _get_main_template():
+    return jinja2.Template(
+        textwrap.dedent(
+            """
+            .. _l-onnx-operators:
+
+            {{ title }}
+            {{ "=" * len(title) }}
+
+            Lists out all the ONNX operators. For each operator, lists out the usage guide,
+            parameters, examples, and line-by-line version history.
+            This section also includes tables detailing each operator
+            with its versions, as done in `Operators.md
+            <https://github.com/onnx/onnx/blob/main/docs/Operators.md>`_.
+
+            All examples end by calling function `expect`.
+            which checks a runtime produces the expected output for this example.
+            One implementation based on `onnxruntime <https://onnxruntime.ai/>`_
+            can be found at :ref:`l-function-expect`.
+
+            .. toctree::
+                :hidden:
+
+                ../expect_onnxruntime
+                {% for p in pages %}{{ os.path.split(p)[-1] }}
+                {% endfor %}
+
+            .. tabs::
+
+                {% for t in tabs %}.. tab:: {{ t.domain_name }}
+                    {{ t.render(indent="        ") }}
+                {% endfor %}
+            """
+        ),
+        autoescape=True,
+    )
+
+
+def _clean_unicode(text):
+    text = text.replace("&#34;", '"')
+    text = text.replace("&#8212;", "-")
+    text = text.replace("&#160;", " ")
+    text = text.replace("&#39;", "'")
+    text = text.replace("&gt;", ">")
+    return text.replace("&lt;", "<")
+
+
+_template_diff = _get_diff_template()
+_template_operator = _get_ops_template()
+_template_main = _get_main_template()
+_all_schemas_with_history = None
+
+
+_attribute_conversion_functions = {
+    onnx.AttributeProto.FLOAT: lambda att: np.float32(att.f),
+    onnx.AttributeProto.FLOATS: lambda att: [np.float32(f) for f in att.floats],
+    # AttributeProto.GRAPH(5)
+    # AttributeProto.GRAPHS(10)
+    onnx.AttributeProto.INT: lambda att: int(att.i),
+    onnx.AttributeProto.INTS: lambda att: [int(i) for i in att.ints],
+    # AttributeProto.SPARSE_TENSOR(11)
+    # AttributeProto.SPARSE_TENSORS(12)
+    onnx.AttributeProto.STRING: lambda att: att.s.decode("utf-8"),
+    onnx.AttributeProto.STRINGS: lambda att: [s.decode("utf-8") for s in att.strings],
+    onnx.AttributeProto.TENSOR: lambda att: onnx.numpy_helper.to_array(att.t),
+    # AttributeProto.TENSORS(9)
+    # onnx.AttributeProto.TYPE_PROTO: lambda att: OnnxType(att.tp),
+    # AttributeProto.TYPE_PROTOS(14)
+}
+
+
+def _populate_all_schemas_with_history():
+    res: dict[str, Any] = {}
+    for schema in onnx.defs.get_all_schemas_with_history():
+        domain = schema.domain
+        version = schema.since_version
+        name = schema.name
+        if domain not in res:
+            res[domain] = {}
+        if name not in res[domain]:
+            res[domain][name] = {}
+        res[domain][name][version] = schema
+
+    return res
+
+
+def _get_all_schemas_with_history():
+    global _all_schemas_with_history  # noqa: PLW0603
+    if _all_schemas_with_history is None:
+        _all_schemas_with_history = _populate_all_schemas_with_history()
+    return _all_schemas_with_history
+
+
+def get_operator_schemas(op_name, version=None, domain=None):
+    """Returns all schemas mapped to an operator name.
+    :param op_name: name of the operator
+    :param version: version
+    :param domain: domain
+    :return: list of schemas
+    """
+    if version == "last" and op_name is not None:
+        if domain is not None:
+            return [onnx.defs.get_schema(op_name, domain=domain)]
+    all_schemas = _get_all_schemas_with_history()
+    if domain is None:
+        domains = []
+        for dom, ops in all_schemas.items():
+            if op_name is None or op_name in ops:
+                domains.append(dom)
+    else:
+        domains = [domain]
+
+    # schemas
+    sch = []
+    for dom in domains:
+        ops = all_schemas[dom]
+        if op_name is None:
+            for op, v in ops.items():
+                if version is None:
+                    sch.extend(v.values())
+                elif version == "last" and (dom == "" or "onnx" in dom):
+                    try:
+                        sch.append(onnx.defs.get_schema(op, domain=dom))
+                    except onnx.defs.SchemaError:
+                        sch.append(v[max(v)])
+                elif version == "last":
+                    sch.append(v[max(v)])
+                else:
+                    sch.append(v[version])
+        elif op_name in ops:
+            if version is None:
+                sch.extend(ops[op_name].values())
+            elif version in ops[op_name]:
+                sch.append(ops[op_name][version])
+
+    # sort
+    vals = [(s.domain, s.name, -s.since_version, s) for s in sch]
+    vals.sort()
+    return [v[-1] for v in vals]
+
+
+def get_markdown_doc(
+    folder,
+    op_name=None,
+    domain=None,
+    version="last",
+    clean=True,
+    diff=False,
+    example=False,
+):
+    """Returns a documentation in Markdown format
+    for all :class:`OnnxOperator`.
+
+    :param op_name: operator name of None for all
+    :param domain: domain
+    :param version: version, None for all, `'last'` for the most recent one
+    :param clean: clean empty lines
+    :param diff: highlights differences between two versions
+    :param example: add example to the documentation
+    :return: string
+    """
+    schemas = get_operator_schemas(op_name, domain=domain, version=version)
+
+    def format_name_with_domain(sch):
+        if version == "last":
+            if sch.domain:
+                return f"{sch.name} ({sch.domain})"
+            return sch.name
+        if sch.domain:
+            return f"{sch.name} - {sch.since_version} ({sch.domain})"
+        return f"{sch.name} - {sch.since_version}"
+
+    def format_option(obj):
+        opts = []
+        if OpSchema.FormalParameterOption.Optional == obj.option:
+            opts.append("optional")
+        elif OpSchema.FormalParameterOption.Variadic == obj.option:
+            opts.append("variadic")
+        if getattr(obj, "is_homogeneous", False):
+            opts.append("heterogeneous")
+        if opts:
+            return f" ({', '.join(opts)})"
+        return ""
+
+    def format_example(code):
+        return code
+
+    def get_constraint(const, ii):
+        if const.type_param_str:
+            name = const.type_param_str
+        else:
+            name = str(ii)
+        name = f"**{name}** in ("
+        if const.allowed_type_strs:
+            types = [f"`{type_str}`" for type_str in sorted(const.allowed_type_strs)]
+            text = ", ".join(types)
+            name += " " + text + " )"
+        return name
+
+    def getname(obj, i):
+        name = obj.name
+        if len(name) == 0:
+            return str(i)
+        return name
+
+    def process_documentation(doc):
+        if doc is None:
+            doc = ""
+        if not isinstance(doc, str):
+            raise TypeError(f"doc must be a string not {type(doc)!r} - {doc + 42!r}.")
+        main_docs_url = "https://github.com/onnx/onnx/blob/main/"
+        rep = {
+            "[the doc](IR.md)": f"[ONNX IR]({main_docs_url}docs/IR.md)",
+            "[the doc](Broadcasting.md)": f"[Broadcasting in ONNX]({main_docs_url}docs/Broadcasting.md)",
+        }
+        for key, value in rep.items():
+            doc = doc.replace(key, value)
+        return textwrap.dedent(doc)
+
+    def build_doc_url(sch):
+        doc_url = "https://github.com/onnx/onnx/blob/main/docs/Operators"
+        if "ml" in sch.domain:
+            doc_url += "-ml"
+        doc_url += ".md"
+        doc_url += "#"
+        if sch.domain not in (None, "", "ai.onnx"):
+            doc_url += sch.domain + "."
+        return doc_url
+
+    def format_default_value(value):
+        if isinstance(value, float):
+            formatted = str(np.round(value, 5))
+            # use default formatting, unless too long.
+            if len(formatted) > 10:  # noqa: PLR2004
+                formatted = f"({value:e})"
+            return formatted
+        if isinstance(value, (bytes, bytearray)):
+            return value.decode("utf-8")
+        return str(value)
+
+    def clean_default_value(attr):
+        if not attr.default_value.name:
+            return ""
+        default_value = onnx.helper.get_attribute_value(attr.default_value)
+        if isinstance(default_value, onnx.AttributeProto) and hasattr(
+            default_value, "default_value"
+        ):
+            if attr.type in _attribute_conversion_functions:
+                sval = _attribute_conversion_functions[attr.type](default_value)
+                return f"(default is `{sval}`)"
+
+        if isinstance(default_value, list):
+            sval = f"[{', '.join(format_default_value(val) for val in default_value)}]"
+        else:
+            sval = format_default_value(default_value)
+        return f"(default is `{sval}`)"
+
+    def text_indent(text: str, indent: int) -> str:
+        s = " " * indent
+        return textwrap.indent(text, s)
+
+    def get_function_body(schema: OpSchema) -> str:
+        return onnx.printer.to_text(schema.function_body)
+
+    examples = get_onnx_example(op_name, domain) if example else {}
+    docs = _template_operator.render(
+        schemas=schemas,
+        OpSchema=OpSchema,
+        len=len,
+        getattr=getattr,
+        sorted=sorted,
+        format_option=format_option,
+        get_constraint=get_constraint,
+        getname=getname,
+        enumerate=enumerate,
+        format_name_with_domain=format_name_with_domain,
+        process_documentation=process_documentation,
+        build_doc_url=build_doc_url,
+        text_indent=text_indent,
+        str=str,
+        clean_default_value=clean_default_value,
+        examples=examples,
+        format_example=format_example,
+        is_last_schema=is_last_schema,
+        get_function_body=get_function_body,
+    )
+
+    d_links = {}
+    for schema in schemas:
+        sdom = schema.domain.replace(".", "-")
+        d_links[schema.since_version] = (
+            f"l-onnx-op{sdom}-{schema.name.lower()}-{schema.since_version}"
+        )
+
+    if diff:
+        lines = docs.split("\n")
+        new_lines = [""]
+        for line in lines:
+            line = line.rstrip("\r\t ")  # noqa: PLW2901
+            if len(line) == 0 and len(new_lines[-1]) == 0:
+                continue
+            new_lines.append(line)
+        docs = "\n".join(new_lines)
+        docs, d_links_diff = _insert_diff(
+            folder,
+            docs,
+            ".. tag-diff-insert.",
+            op_name=op_name,
+            version=version,
+            domain=domain,
+        )
+        d_links.update(d_links_diff)
+
+    if clean:
+        lines = docs.split("\n")
+        new_lines = [""]
+        for line in lines:
+            line = line.rstrip("\r\t ")  # noqa: PLW2901
+            if len(line) == 0 and len(new_lines[-1]) == 0:
+                continue
+            new_lines.append(line)
+        docs = "\n".join(new_lines)
+
+    return docs, d_links, len(examples)
+
+
+def _insert_diff(
+    folder, docs, split=".. tag-diff-insert.", op_name=None, version=None, domain=None
+):
+    """Splits a using `split`, insert HTML differences between pieces.
+    The function relies on package `pyquickhelper`.
+    """
+    doc_parts = docs.split(split)
+    if len(doc_parts) <= 1:
+        return docs
+
+    reg = re.compile("([A-Z][A-Za-z0-9_]*) - ([0-9]+)")
+
+    d_links = {}
+    pieces = [doc_parts[0]]
+    mds = []
+    for i in range(1, len(doc_parts)):
+        spl1 = doc_parts[i - 1].strip("\n ")
+        spl2 = doc_parts[i].strip("\n ")
+        vers1 = reg.findall(spl1)
+        vers2 = reg.findall(spl2)
+
+        spl1 = spl1.split("### Examples")[0].replace("`", "")
+        spl2 = spl2.split("### Examples")[0].replace("`", "")
+        spl1 = spl1.split("### Summary")[-1].strip("\n ")
+        spl2 = spl2.split("### Summary")[-1].strip("\n ")
+        if len(spl1) < 5 or len(spl2) < 5:  # noqa: PLR2004
+            pieces.append(doc_parts[i])
+            continue
+        if not vers1:
+            raise ValueError(f"Unable to find version {version!r} in\n{spl1}")
+        if not vers2:
+            raise ValueError(f"Unable to find version {version!r} in\n{spl2}")
+        v2 = vers2[0][1]
+        v1 = vers1[0][1]
+
+        if not mds:
+            mds.append(
+                (v1, textwrap.dedent(spl1.strip(" \n\r\t")).splitlines(keepends=True))
+            )
+        mds.append(
+            (v2, textwrap.dedent(spl2.strip(" \n\r\t")).splitlines(keepends=True))
+        )
+
+        if len(mds) > 1:
+            show_diff_toc = True
+        else:
+            show_diff_toc = False
+
+        if show_diff_toc:
+            pieces.append("```{toctree}")
+
+        for di in range(len(mds) - 1):
+            dj = len(mds) - 1
+
+            v1, s1 = mds[di]
+            v2, s2 = mds[dj]
+            differ = difflib.Differ()
+            result = list(differ.compare(s2, s1))
+            raw = "".join(result)
+
+            diff = _template_diff.render(
+                op_name=op_name,
+                version1=v2,
+                version2=v1,
+                div_name=f"div_{op_name}_{i}",
+                diff_content=raw,
+            )
+            diff = _clean_unicode(diff)
+
+            title = f"{op_name} - {v2} vs {v1}"
+
+            name = f"text_diff_{op_name}_{v2}_{v1}"
+            domain_str = domain.replace(".", "-")
+            link = f"l-onnx-op{domain_str}-{op_name.lower()}-d{v2}-{v1}"
+            d_links[int(v2), int(v1)] = link
+            content = "\n".join(
+                [
+                    "",
+                    f".. _{link}:",
+                    "",
+                    title,
+                    "=" * len(title),
+                    "",
+                    "Next section compares an older to a newer version of the same operator ",
+                    "after both definition are converted into markdown text.",
+                    "Green means an addition to the newer version, red means a deletion.",
+                    "Anything else is unchanged.",
+                    "",
+                    ".. raw:: html",
+                    "",
+                    textwrap.indent(diff, "    "),
+                ]
+            )
+            filename = os.path.join(folder, name + ".rst")
+            pathlib.Path(filename).write_text(content, encoding="utf-8")
+            # Add diff page to the toctree using myst syntax
+            pieces.append(name)
+
+        if show_diff_toc:
+            # End the toctree
+            pieces.append("```")
+
+        pieces.extend(["", doc_parts[i]])
+
+    return "\n".join(pieces), d_links
+
+
+def pascal_to_snake_case(name: str) -> str:
+    """Switches from *AaBb* into *aa_bb*.
+    :param name: name to convert
+    :return: converted name
+    """
+    s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    s2 = re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+    return s2 if not keyword.iskeyword(s2) else s2 + "_"
+
+
+def _process_example(code: str) -> str:
+    """Add necessary imports to make the example work."""
+    code = code.replace("", "")
+    missing_imports = ["import numpy as np", "import onnx"]
+    elements = [*missing_imports, "", "", code.strip("\n")]
+    return "\n".join(elements)
+
+
+def get_onnx_example(op_name, domain):
+    """Retrieves examples associated to one operator
+    stored in onnx packages.
+    :param op_name: operator name
+    :param domain: operator domain
+    :param fmt: rendering format
+    :return: dictionary
+    """
+    if domain in (None, "ai.onnx"):
+        modules = [
+            f"onnx.backend.test.case.node.{op_name.lower()}",
+            f"onnx.backend.test.case.node.{pascal_to_snake_case(op_name)}",
+        ]
+    else:
+        domain_ = domain.replace(".", "_")
+        modules = [
+            f"onnx.backend.test.case.node.{domain_}.{op_name.lower()}",
+            f"onnx.backend.test.case.node.{domain_}.{pascal_to_snake_case(op_name)}",
+        ]
+    module = None
+    for m in modules:
+        try:
+            mod = importlib.import_module(m)
+            module = m
+        except ImportError:  # noqa: PERF203
+            continue
+    if module is None:
+        # Unable to find an example for 'op_name'.
+        return {}
+    results: dict[str, Any] = {}
+    for v in mod.__dict__.values():
+        if not isinstance(v, _Exporter):
+            continue
+        code_cls = inspect.getsource(v)
+        codes = code_cls.split("@staticmethod")
+        for me in v.__dict__:
+            if not me.startswith("export"):
+                continue
+            sub = f" {me}()"
+            found = None
+            for code in codes:
+                if sub in code:
+                    found = code
+            if found is None:
+                raise RuntimeError(f"Unable to find {sub!r} in\n{code_cls}")
+            found = textwrap.dedent(found)
+            lines = found.split("\n")
+            first = 0
+            for i in range(len(lines)):
+                if lines[i].startswith("def "):
+                    first = i + 1
+            found = textwrap.dedent("\n".join(lines[first:]))
+            key = me[len("export") :]
+            if key == "":
+                key = "default"
+                if key in results:
+                    key = f"example {len(results) + 1}"
+            results[key] = _process_example(found)
+    return results
+
+
+def is_last_schema(sch: OpSchema) -> bool:
+    """Tells if this is the most recent schema for this operator.
+    :param sch: schema
+    :return: True
+    """
+    try:
+        last = onnx.defs.get_schema(sch.name, domain=sch.domain)
+    except onnx.defs.SchemaError:
+        return True
+    return last.since_version == sch.since_version
+
+
+def onnx_documentation_folder(
+    folder, title="ONNX Operators", flog=None, max_opsets=None
+):
+    """Creates documentation in a folder for all known
+    ONNX operators or a subset.
+    :param folder: folder where to write the documentation
+    :param title: index title
+    :param flog: logging function
+    :param max_opsets: included operator definition up to this opsets
+    :return: list of creates files
+    """
+
+    class _Table:
+        def __init__(self, ops, domain, title=None):
+            self.title = title or domain
+            self.domain = domain
+            self.ops = ops
+
+        @property
+        def domain_name(self):
+            title = self.domain
+            if title == "":
+                title = "ai.onnx"
+            return title
+
+        def render(self, indent=""):
+            table_dom = [""]
+            table_dom.extend(
+                [
+                    ".. list-table::",
+                    "    :widths: 10 10 10",
+                    "    :header-rows: 1",
+                    "",
+                    "    * - operator",
+                    "      - versions",
+                    "      - differences",
+                ]
+            )
+
+            for op in self.ops:
+                name = op["name"]
+                dom = self.domain.replace(".", "-")
+                table_dom.append(f"    * - :ref:`{name} <l-onnx-doc{dom}-{name}>`")
+                versions = sorted(
+                    [(k, v) for k, v in op["links"].items() if isinstance(k, int)],
+                    reverse=True,
+                )
+                col1 = ", ".join(f":ref:`{k} <{v}>`" for k, v in versions)
+                diffs = sorted(
+                    [(k, v) for k, v in op["links"].items() if isinstance(k, tuple)],
+                    reverse=True,
+                )
+                col2 = ", ".join(f":ref:`{k[1]}/{k[0]} <{v}>`" for k, v in diffs)
+                table_dom.append(f"      - {col1}")
+                table_dom.append(f"      - {col2}")
+            table_dom.append("")
+            if indent != "":
+                for i in range(len(table_dom)):
+                    table_dom[i] = indent + table_dom[i]
+            return "\n".join(table_dom)
+
+    all_schemas_available = _get_all_schemas_with_history()
+    if len(all_schemas_available) < 3:  # noqa: PLR2004
+        raise RuntimeError(
+            f"At least three domains are expected, found {list(all_schemas_available)}."
+        )
+
+    # filter out operator under development
+    all_schemas = {}
+    for domain, opset in all_schemas_available.items():
+        max_version = None if max_opsets is None else max_opsets.get(domain, None)
+        d = {}
+        for op, schemas in opset.items():
+            vers = {}
+            for version, schema in schemas.items():
+                if max_version is not None and version > max_version:
+                    continue
+                vers[version] = schema
+            d[op] = vers
+        all_schemas[domain] = d
+
+    if len(all_schemas) < 3:  # noqa: PLR2004
+        raise RuntimeError(
+            f"At least three domains are expected, found {list(all_schemas)} in all_schemas."
+        )
+
+    if not os.path.exists(folder):
+        os.makedirs(folder)
+
+    pages = []
+    tables = []
+
+    # loop on domains
+    for dom in sorted(all_schemas):
+        sdom = "ai.onnx" if dom == "" else dom
+        dom_pages = []
+
+        do = all_schemas[dom]
+        if len(do) == 0:
+            raise RuntimeError(f"No operator for domain={dom!r}.")
+
+        # loop on operators
+        for op in sorted(do):
+            if flog is not None:
+                flog(f"generate page for onnx {dom!r} - {op!r}")
+            page_name = f"onnx_{dom.replace('.', '')}_{op}"
+            doc, d_links, n_examples = get_markdown_doc(
+                folder, op, domain=dom, version=None, example=True, diff=True
+            )
+            if flog is not None and n_examples == 0:
+                flog(f"{' ' * 14}no_example for {op} from domain {domain}")
+            if dom == "":
+                main = op
+            else:
+                main = f"{dom} - {op}"
+            sdom = dom.replace(".", "-")
+            # Target in MyST https://myst-parser.readthedocs.io/en/v0.15.1/syntax/syntax.html?highlight=role#extra-markdown-syntax
+            ref_link = f"(l-onnx-doc{sdom}-{op})="
+            rows = [
+                "",
+                ref_link,
+                "",
+                f"# {main}",
+                "",
+                doc,
+            ]
+
+            full = os.path.join(folder, page_name + ".md")
+            content = "\n".join(rows)
+            pathlib.Path(full).write_text(content, encoding="utf-8")
+            pages.append(full)
+            dom_pages.append({"name": op, "links": d_links})
+
+        tables.append(_Table(dom_pages, dom, sdom))
+
+    # final
+    if len(tables) < 3:  # noqa: PLR2004
+        raise RuntimeError(f"At least three domain are expected not {len(tables)}.")
+    index = _template_main.render(pages=pages, tabs=tables, os=os, len=len, title=title)
+    index = _clean_unicode(index)
+    page_name = os.path.join(folder, "index.rst")
+    pathlib.Path(page_name).write_text(index, encoding="utf-8")
+    pages.append(page_name)
+    return pages
+
+
+def _generate_op_doc(app):
+    logger = logging.getLogger(__name__)
+    folder = app.config.onnx_doc_folder
+    max_opsets = app.config.max_opsets
+    onnx_documentation_folder(folder, flog=logger.info, max_opsets=max_opsets)
+
+
+def _copy_repo_docs(app):
+    logger = logging.getLogger(__name__)
+    dest_name = app.config.onnx_md_folder
+
+    docs_dir = pathlib.Path(__file__).parent.parent.parent  # docs
+    dest_folder = docs_dir / "docsgen" / "source" / dest_name
+    dest_folder.mkdir(parents=True, exist_ok=True)
+    # Copy all the markdown files from the folder except for the blocklisted ones
+
+    logger.info("Copying Markdown files from '%s' to '%s'", docs_dir, dest_folder)
+    for file in docs_dir.glob("*.md"):
+        if file.name in REPO_DOCS_EXCLUDE:
+            continue
+        shutil.copy(file, dest_folder)
+        logger.info("Copying '%s'", file.name)
+
+
+def setup(app):
+    """Sphinx extension `onnx_sphinx` displays documentation
+    on ONNX Operators.
+    """
+    import sphinx  # noqa: PLC0415
+
+    app.add_config_value("onnx_doc_folder", "operators", "env")
+    # Folder for storing the Markdown documentation from the repository
+    app.add_config_value("onnx_md_folder", "repo-docs", "env")
+    app.add_config_value("max_opsets", {}, "env")
+    app.connect("builder-inited", _generate_op_doc)
+    app.connect("builder-inited", _copy_repo_docs)
+    return {"version": sphinx.__display_version__, "parallel_read_safe": True}
+
+
+if "debug" in sys.argv:
+    print("DEBUG")
+    onnx_documentation_folder("_debug", flog=print)
+    print("END")
diff --git a/docs/docsgen/source/repo-docs/.gitignore b/docs/docsgen/source/repo-docs/.gitignore
new file mode 100644
index 0000000..427eb8d
--- /dev/null
+++ b/docs/docsgen/source/repo-docs/.gitignore
@@ -0,0 +1,3 @@
+*
+!index.md
+!.gitignore
diff --git a/docs/docsgen/source/repo-docs/index.md b/docs/docsgen/source/repo-docs/index.md
new file mode 100644
index 0000000..9224db8
--- /dev/null
+++ b/docs/docsgen/source/repo-docs/index.md
@@ -0,0 +1,16 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ONNX Repository Documentation
+
+Markdown documentation from the [ONNX repository](https://github.com/onnx/onnx/tree/main/docs).
+
+```{toctree}
+:maxdepth: 1
+:glob:
+
+*
+```
diff --git a/docs/docsgen/source/technical/InPlaceKVCache.png b/docs/docsgen/source/technical/InPlaceKVCache.png
new file mode 100644
index 0000000..7cacb90
Binary files /dev/null and b/docs/docsgen/source/technical/InPlaceKVCache.png differ
diff --git a/docs/docsgen/source/technical/float4.md b/docs/docsgen/source/technical/float4.md
new file mode 100644
index 0000000..dac1aa9
--- /dev/null
+++ b/docs/docsgen/source/technical/float4.md
@@ -0,0 +1,121 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+(onnx-detail-float4)=
+
+# Float stored in 4 bits
+
+## Papers
+
+4 bit floating point formats have emerged as a solution to the
+rising cost and deployment challenges of large language models.
+The S1E2M1 format has been part of the [Open Compute Project (OCP)](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf)
+standard.
+
+As a result, a new data type was introduced in `onnx==1.18.0`
+to support a limited set of operators to enable computation
+with float4.
+
+- `FLOAT4E2M1`: 1 bit for the sign, 2 bits for the exponents, and 1 bit for the mantissa.
+  No nan or infinities.
+
+## E2M1
+
+$S$ stands for the sign. $10_2$ describe a number base 2.
+
+```{eval-rst}
+.. list-table:: Float4 type
+   :widths: 10 10
+   :header-rows: 1
+
+   * -
+     - E2M1
+   * - Exponent bias
+     - 1
+   * - Infinities
+     -
+   * - NaN
+     -
+   * - Zeros
+     - :math:`S.00.0_2`
+   * - Max
+     - :math:`S.11.1_2`
+   * - Min
+     - :math:`S.00.1_2 = 2^{-1}`
+
+```
+
+Let's denote the bit representation as $S.b_2 b_1 b_0$.
+The float value is defined by the following expressions:
+
+```{eval-rst}
+.. list-table:: Float4 type values
+   :widths: 10 10
+   :header-rows: 1
+
+   * -
+     - E2M1
+   * - exponent :math:`\neq` 0
+     - :math:`(-1)^S 2^{\sum_{i=1}^2 b_i 2^{i-1} - 1} \left( 1 + b_0 2^{-1} \right)`
+   * - exponent :math:`=` 0
+     - :math:`(-1)^S  b_0 2^{-1}`
+```
+
+The following table lists all the representable values by float4 E2M1, ignoring the sign bit:
+
+```{eval-rst}
+.. list-table:: Float4 type values
+   :widths: 10 10
+   :header-rows: 1
+
+   * - bits (ignoring sign bit)
+     - E2M1
+   * - 000
+     - 0
+   * - 001
+     - 0.5
+   * - 010
+     - 1
+   * - 011
+     - 1.5
+   * - 100
+     - 2
+   * - 101
+     - 3
+   * - 110
+     - 4
+   * - 111
+     - 6
+```
+
+## Cast
+
+Upcasting from float4 to float32, float16, bfloat16, and float8 is exact.
+The behavior for downcasting to float 4 is summarized below
+
+| x                 | E2M1                                              |
+| ----------------- | ------------------------------------------------- |
+| -6<=x<=6          | E2M1 converted value of x. Round to nearest even. |
+| x=+/-0            | +/-0                                              |
+| x>6               | 6                                                 |
+| x<-6              | -6                                                |
+| +Inf              | 6                                                 |
+| -Inf              | -6                                                |
+| NaN               | 6                                                 |
+
+## Packing and Unpacking
+
+Float4 is stored as 2x4bit in a single byte.
+The first element is stored in the 4 LSB and the second element is stored in the 4 MSB,
+i.e. for elements `x` and `y` that are consecutive elements in the array:
+
+```
+pack(x,y): y << 4 | x & 0x0F
+unpack(z): x = z & 0x0F, y = z >> 4
+```
+
+In case the total number of elements is odd, padding of 4 bits will be appended.
+The storage size of a 4 bit tensor of size `N` is `ceil(N/2)`.
diff --git a/docs/docsgen/source/technical/float8.md b/docs/docsgen/source/technical/float8.md
new file mode 100644
index 0000000..46d6fb2
--- /dev/null
+++ b/docs/docsgen/source/technical/float8.md
@@ -0,0 +1,232 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+(onnx-detail-float8)=
+
+# Float stored in 8 bits
+
+## Papers
+
+Two papers have been published in 2022 to introduce floats
+stored on a byte as opposed to float 32 stored on 4 bytes.
+The float precision is much lower but the training accuracy
+does not suffer too much.
+
+[FP8 Formats for Deep Learning](https://arxiv.org/abs/2209.05433)
+from NVIDIA, Intel and ARM introduces two types following
+[IEEE specification](https://en.wikipedia.org/wiki/IEEE_754).
+First one is E4M3, 1 bit for the sign, 4 bits for the exponents and 3
+bits for the mantissa. Second one is E5M2, 1 bit for the sign,
+5 bits for the exponents and 2 for the mantissa. The first types
+is mostly used for the weights, the second one for the gradient.
+
+Second paper [8-bit Numerical Formats For Deep Neural Networks](https://arxiv.org/pdf/2206.02915.pdf) introduces
+similar types. IEEE standard gives the same value
+to `+0` (or integer 0) and `-0` (or integer 128).
+They chose to give distinct float values to these two
+numbers. The paper experiments different split between
+exponent and mantissa and shows and E4M3 and E5M2 are
+the best ones.
+
+As a result, four new types were introduced in `onnx==1.15.0`
+to support a limited set of operators to enable computation
+with float 8.
+
+- `E4M3FN`: 1 bit for the sign, 4 bits for the exponents, 3 bits for the mantissa,
+  only nan values and no infinite values (FN),
+- `E4M3FNUZ`: 1 bit for the sign, 4 bits for the exponents, 3 bits for the mantissa,
+  only nan values and no infinite values (FN), no negative zero (UZ)
+- `E5M2`: 1 bit for the sign, 5 bits for the exponents, 2 bits for the mantissa,
+- `E5M2FNUZ`: 1 bit for the sign, 5 bits for the exponents, 2 bits for the mantissa,
+  only nan values and no infinite values (FN), no negative zero (UZ)
+
+The implementation is usually hardware dependent.
+NVIDIA, Intel and Arm implement `E4M3FN` and `E5M2` is its latest graphical processor.
+GraphCore does the same only with `E4M3FNUZ` and `E5M2FNUZ`.
+
+## E4M3FN and E5M2
+
+$S$ stands for the sign. $10_2$ describe a number base 2.
+
+```{eval-rst}
+.. list-table:: Float8 types
+   :widths: 10 10 10
+   :header-rows: 1
+
+   * -
+     - E4M3FN
+     - E5M2
+   * - Exponent bias
+     - 7
+     - 15
+   * - Infinities
+     -
+     - :math:`S.11111.00_2`
+   * - NaN
+     - :math:`S.1111.111_2`
+     - :math:`S.11111.\{01, 10, 11\}_2`
+   * - Zeros
+     - :math:`S.0000.000_2`
+     - :math:`S.00000.00_2`
+   * - Max
+     - :math:`S.1111.110_2`
+     - :math:`1.75 \times 2^{15}= 57344`
+   * - Min
+     - :math:`S.0000.001_2 = 2^{-9}`
+     - :math:`S.00000.01_2 = 2^{-16}`
+
+```
+
+Let's denote the bit representation as $S.b_6 b_5 b_4 b_3 b_2 b_1 b_0$.
+The float value is defined by the following expressions:
+
+```{eval-rst}
+.. list-table:: Float8 types values
+   :widths: 10 10 10
+   :header-rows: 1
+
+   * -
+     - E4M3FN
+     - E5M2
+   * - exponent :math:`\neq` 0
+     - :math:`(-1)^S 2^{\sum_{i=3}^6 b_i 2^{i-3} - 7} \left( 1 + \sum_{i=0}^2 b_i 2^{i-3} \right)`
+     - :math:`(-1)^S 2^{\sum_{i=2}^6 b_i 2^{i-2} - 15} \left( 1 + \sum_{i=0}^1 b_i 2^{i-2} \right)`
+   * - exponent :math:`=` 0
+     - :math:`(-1)^S 2^{-6} \sum_{i=0}^2 b_i 2^{i-3}`
+     - :math:`(-1)^S 2^{-14} \sum_{i=0}^1 b_i 2^{i-2}`
+```
+
+## E4M3FNUZ and E5M2FNUZ
+
+The previous types support positive and negative zero, positive and negative nan.
+Another type definition was introduced by GraphCore to make a better use
+of these four values. Every type including UZ in its name have only one zero
+and one nan (= negative zero). The other difference comes from the exponent bias.
+As a result, a float 8 *FLOAT8E4M3FN*, not null, not nan, cannot be simply
+converted into *FLOAT8E4M3FNUZ* due to this exponent bias difference.
+Even if the mantissa is the same, the exponent is not.
+
+```{eval-rst}
+.. list-table:: Float8 types
+   :widths: 10 10 10
+   :header-rows: 1
+
+   * -
+     - E4M3FNUZ
+     - E5M2FNUZ
+   * - Exponent bias
+     - 8
+     - 16
+   * - Infinities
+     -
+     -
+   * - NaN
+     - :math:`1.0000.000_2`
+     - :math:`1.00000.00_2`
+   * - Zeros
+     - :math:`0.0000.000_2`
+     - :math:`0.00000.00_2`
+   * - Max
+     - :math:`S.1111.111_2`
+     - :math:`S.11111.11_2`
+   * - Min
+     - :math:`S.0000.001_2 = 2^{-10}`
+     - :math:`S.00000.01_2 = 2^{-17}`
+```
+
+The float value is defined by the following expressions:
+
+```{eval-rst}
+.. list-table:: Float8 types values
+   :widths: 10 10 10
+   :header-rows: 1
+
+   * -
+     - E4M3FNUZ
+     - E5M2FNUZ
+   * - exponent :math:`\neq` 0
+     - :math:`(-1)^S 2^{\sum_{i=3}^6 b_i 2^{i-3} - 8} \left( 1 + \sum_{i=0}^2 b_i 2^{i-3} \right)`
+     - :math:`(-1)^S 2^{\sum_{i=2}^6 b_i 2^{i-2} - 16} \left( 1 + \sum_{i=0}^1 b_i 2^{i-2} \right)`
+   * - exponent :math:`=` 0
+     - :math:`(-1)^S 2^{-7} \sum_{i=0}^2 b_i 2^{i-3}`
+     - :math:`(-1)^S 2^{-15} \sum_{i=0}^1 b_i 2^{i-2}`
+```
+
+## Cast
+
+Cast from float 8 to
+[float 16](https://en.wikipedia.org/wiki/Half-precision_floating-point_format) (or E5M10),
+[bfloat16](https://en.wikipedia.org/wiki/Bfloat16_floating-point_format) (or E8M7),
+[float32](https://en.wikipedia.org/wiki/Single-precision_floating-point_format) (or E8M23) is easier.
+The cast is exact. The conversion does not necessarily preserve the sign for
+specific values such as `-0` or `-NaN`.
+
+Cast to float 8 consists in finding the closest float 8
+to the original float 32 value. It is usually done by shifting
+and truncating.
+
+The conversion may with saturation, every value out of range
+becomes the highest available value. Next table summarizes
+all the case. `[x]` means the value rounded to
+the target mantissa width.
+
+| x                 | E4M3FN   | E4M3FNUZ | E5M2     | E5M2FNUZ |
+| ----------------- | -------- | -------- | -------- | -------- |
+| 0                 | 0        | 0        | 0        | 0        |
+| -0                | -0       | 0        | -0       | 0        |
+| NaN               | NaN      | NaN      | NaN      | NaN      |
+| Inf               | FLT_MAX  | NaN      | FLT_MAX  | NaN      |
+| -Inf              | -FLT_MAX | NaN      | -FLT_MAX | NaN      |
+| \[x\] > FLT_MAX   | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+| \[x\] \< -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+| else              | RNE      | RNE      | RNE      | RNE      |
+
+The conversion may also be defined without any saturation.
+
+| x                 | E4M3FN | E4M3FNUZ | E5M2 | E5M2FNUZ |
+| ----------------- | ------ | -------- | ---- | -------- |
+| 0                 | 0      | 0        | 0    | 0        |
+| -0                | -0     | 0        | -0   | 0        |
+| NaN               | NaN    | NaN      | NaN  | NaN      |
+| -NaN              | -NaN   | NaN      | -NaN | NaN      |
+| Inf               | NaN    | NaN      | Inf  | NaN      |
+| -Inf              | -NaN   | NaN      | -Inf | NaN      |
+| \[x\] > FLT_MAX   | NaN    | NaN      | Inf  | NaN      |
+| \[x\] \< -FLT_MAX | NaN    | NaN      | -Inf | NaN      |
+| else              | RNE    | RNE      | RNE  | RNE      |
+
+## E8M0
+
+The E8M0 data type serves as the common scale type for all [OCP Microscaling (MX) Formats](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf). It has eight bits for the exponent, and no sign or mantissa bits.
+
+```{eval-rst}
+.. list-table:: E8M0
+   :widths: 10 10
+   :header-rows: 1
+
+   * -
+     - E8M0
+   * - Exponent bias
+     - 127
+   * - Infinities
+     -
+   * - NaN
+     - :math:`11111111_2`
+   * - Zeros
+     -
+   * - Max
+     - :math:`11111110_2 = 2^{127}`
+   * - Min
+     - :math:`00000000_2 = 2^{-127}`
+```
+
+When computing scale factors in MX formats, there are different casting choices one can make. For this reason, the ONNX spec for the Cast operator has introduced an additional "round_mode" attribute, which accepts the following:
+
+- "up": round to nearest value away from zero
+- "down": round to nearest value towards zero
+- "nearest": round to nearest value and ties round up
+
+It has been [shown](https://arxiv.org/abs/2506.08027) that rounding up with saturation achieves superior accuracy in LLM pretraining compared to other rounding modes.
diff --git a/docs/docsgen/source/technical/index.md b/docs/docsgen/source/technical/index.md
new file mode 100644
index 0000000..9b99e6e
--- /dev/null
+++ b/docs/docsgen/source/technical/index.md
@@ -0,0 +1,21 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+(onnx-technical)=
+
+# Technical Details
+
+This section enters into implementation details, technical descriptions,
+deeper than the code documentation.
+
+```{toctree}
+:maxdepth: 2
+
+float8
+int4
+float4
+int2
+```
diff --git a/docs/docsgen/source/technical/int2.md b/docs/docsgen/source/technical/int2.md
new file mode 100644
index 0000000..3876bc9
--- /dev/null
+++ b/docs/docsgen/source/technical/int2.md
@@ -0,0 +1,43 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+(onnx-detail-int2) =
+
+# 2 bit integer types
+
+## Papers
+
+[T-MAC: CPU Renaissance via Table Lookup for Low-Bit LLM Deployment on Edge](https://arxiv.org/abs/2407.00088)
+
+T-MAC, an innovative lookup table(LUT)-based method designed for efficient low-bit LLM (i.e., weight-quantized LLM) inference on CPUs. T-MAC directly supports mpGEMM without dequantization, while simultaneously eliminating multiplications and reducing additions required. Specifically, T-MAC transforms the traditional data-type-centric multiplication to bit-wise table lookup, and enables a unified and scalable mpGEMM solution.
+
+## Cast
+
+Cast from 2 bit to any higher precision type is exact.
+Cast to a 2 bit type is done by rounding to the nearest-integer (with ties to even)
+nearest-even integer and truncating.
+
+
+## Packing and Unpacking (2-bit)
+All 2-bit types are stored as 4×2-bit values in a single byte. The elements are packed from least significant bits (LSB) to most significant bits (MSB). That is, for consecutive elements x0, x1, x2, x3 in the array:
+
+Packing:
+```
+pack(x0, x1, x2, x3):
+    (x0 & 0x03) |
+    ((x1 & 0x03) << 2) |
+    ((x2 & 0x03) << 4) |
+    ((x3 & 0x03) << 6)
+```
+
+Unpacking:
+```
+x0 = z & 0x03
+x1 = (z >> 2) & 0x03
+x2 = (z >> 4) & 0x03
+x3 = (z >> 6) & 0x03
+```
+In case the total number of elements is not divisible by 4, zero-padding will be applied in the remaining higher bits of the final byte.
+The storage size of a 2-bit tensor of size N is: ceil(N / 4) bytes
diff --git a/docs/docsgen/source/technical/int4.md b/docs/docsgen/source/technical/int4.md
new file mode 100644
index 0000000..42468d6
--- /dev/null
+++ b/docs/docsgen/source/technical/int4.md
@@ -0,0 +1,58 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+(onnx-detail-int4)=
+
+# 4 bit integer types
+
+## Papers
+
+Several papers have been published in 2023 to introduce 4 bit integers and their usage in LLMs. Although their range is
+limited, with careful selection of scaling parameters, good accuracy is obtained when used for compression of weights
+(weight-only quantization), and in some cases for quantization of activations as well.
+
+[AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration](https://arxiv.org/abs/2306.00978)
+Activation-aware Weight Quantization (AWQ) focuses on the quantization of weights in LLMs by considering the
+observation that not all weights are equally important. The method aims to protect salient weights based on the
+activation, rather than relying on backpropagation or reconstruction techniques. By searching for the optimal
+per-channel scaling that preserves the crucial weights, AWQ aims to minimize quantization errors.
+
+[GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers](https://arxiv.org/abs/2210.17323)
+GPTQ proposes a one-shot weight quantization method based on approximate second-order information. GPTQ achieves
+significant compression gains, reducing the bit-width to 3 or 4 bits per weight with negligible accuracy degradation
+compared to the uncompressed baseline.
+
+[Understanding INT4 Quantization for Transformer Models: Latency Speedup, Composability, and Failure Cases](https://arxiv.org/abs/2301.12017)
+This paper discusses quantization of both weights and activations to 4 bit (W4A4). Results indicate that W4A4
+quantization leads to little to no accuracy degradation for encoder-only and encoder-decoder models but results in
+a significant accuracy drop for decoder-only models. To realize the performance gains using W4A4, the study introduces
+a highly optimized end-to-end W4A4 encoder inference pipeline that supports various quantization strategies.
+
+As a result, two new types were introduced in `onnx==1.17.0` supporting a limited set of operators to enable compression using
+4 bit data-types:
+
+- `UINT4`: 4 bit unsigned integer, values in range [0, 15]
+- `INT4`: 4 bit signed integer, using two's complement representation. Values in range [-8, 7].
+
+## Cast
+
+Cast from 4 bit to any higher precision type is exact.
+Cast to a 4 bit type is done by rounding to the nearest-integer (with ties to even)
+nearest-even integer and truncating.
+
+## Packing and Unpacking
+
+All 4 bit types are stored as 2x4bit in a single byte.
+The first element is stored in the 4 LSB and the second element is stored in the 4 MSB.
+i.e. for elements x, y, that are consecutive elements in the array:
+
+```
+pack(x,y): y << 4 | x & 0x0F
+unpack(z): x = z & 0x0F, y = z >> 4
+```
+
+In case the total number of elements is odd, padding of 4 bits will be appended.
+The storage size of a 4 bit tensor of size `N` is `ceil(N/2)`.
diff --git a/docs/docsgen/source/technical/kv_cache.md b/docs/docsgen/source/technical/kv_cache.md
new file mode 100644
index 0000000..b258926
--- /dev/null
+++ b/docs/docsgen/source/technical/kv_cache.md
@@ -0,0 +1,25 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+(onnx-detail-kvcache)=
+
+# In-place KV Cache for Attention
+
+KV caching in attention-based models refers to a mechanism for storing previously computed Key and Value tensors during autoregressive generation. In decoder-only transformers, each new token must attend to all previous tokens using the attention mechanism. Normally, this would require recomputing the Key and Value projections for every prior token at each time step, which is inefficient. Instead, the KV cache stores these projections after they are first computed, allowing the model to reuse them for future tokens without recomputation. This significantly speeds up the generation process.
+
+Updating the KV cache in place means writing new Key and Value tensors directly into pre-allocated memory at the index corresponding to the current position in the sequence. This has several advantages: it avoids repeated memory allocation or copying, reducing computational overhead; it also allows better performance on hardware accelerators by enabling the use of fused kernels and reducing memory bandwidth usage. In-place updates are essential for achieving high throughput and low latency during inference, particularly for large language models deployed in real-time applications.
+
+ONNX opset-24 has introduced new features to facilitate the representation of in-place KV cache updates. This diagram shows an example use case:
+
+![InPlace KV Cache](InPlaceKVCache.png)
+
+- The `K` and `V` inputs to the `Attention` op contain the entire KV cache tensors with the sequence length dimension being max_sequence_length, hence the size of these inputs do not grow between autoregressive iterations. For this reason an optional `nonpad_kv_seqlen` input can be used to indicate the number of valid (non-padding) tokens in each sample to skip unnecessary computations.
+- When `is_causal=1` is used with this external KV-cache pattern (`nonpad_kv_seqlen` provided without `past_key`), causal masking uses bottom-right (offset-aware) alignment: per batch, a query at in-block position `i` attends keys `j <= i + offset`, where `offset = nonpad_kv_seqlen - q_sequence_length`, anchoring the current query tokens to the end of the valid cache rather than its start.
+- The logic for KV cache update is separated out of the `Attention` op. The `TensorScatter` op can be used to update the cache tensors, where the incoming key and value tokens for the current iteration are scattered into the cache tensors according to `write_indices`.
+- As an optimization, the backend is free to alias the past and present key/value tensors to avoid duplicating the cache tensors and achieve in-place update. For this optimization to be valid, the backend will need to ensure that the input to `TensorScatter` is not subsequently reused by other ops. Only then is it safe to reuse the memory allocated to the `past_k/v` input of the op for the `present_k/v` output.
+- The same computational graph can be used for both the prefill and decode stages of the autoregressive model.
+
+As a reminder, the ONNX representation is still a functional representation, with ops that are pure functions. The graph layout described above is a useful common pattern to express in-place KV cache update, and the input/output aliasing is entirely up to backend implementations.
diff --git a/docs/images/onnx_hub_arch.svg b/docs/images/onnx_hub_arch.svg
new file mode 100644
index 0000000..e79453a
--- /dev/null
+++ b/docs/images/onnx_hub_arch.svg
@@ -0,0 +1 @@
+<svg width="3126" height="2133" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" overflow="hidden"><defs><clipPath id="clip0"><rect x="541" y="263" width="3126" height="2133"/></clipPath></defs><g clip-path="url(#clip0)" transform="translate(-541 -263)"><rect x="541" y="272" width="3126" height="2124"/><path d="M2442.5 738.837C2442.5 646.971 2516.97 572.5 2608.84 572.5L3471.16 572.5C3563.03 572.5 3637.5 646.971 3637.5 738.837L3637.5 1404.16C3637.5 1496.03 3563.03 1570.5 3471.16 1570.5L2608.84 1570.5C2516.97 1570.5 2442.5 1496.03 2442.5 1404.16Z" stroke="#FFFFFF" stroke-width="4.58333" stroke-miterlimit="8" fill="#404040" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 2789.98 714)">Git LFS Storage<tspan font-family="Calibri Light,Calibri Light_MSFontService,sans-serif" font-weight="300" font-size="202" x="-1743.23" y="-201">ONNX Hub Architecture</tspan></text><path d="M2534.5 817.667C2534.5 802.663 2546.66 790.5 2561.67 790.5L2842.33 790.5C2857.34 790.5 2869.5 802.663 2869.5 817.667L2869.5 926.333C2869.5 941.337 2857.34 953.5 2842.33 953.5L2561.67 953.5C2546.66 953.5 2534.5 941.337 2534.5 926.333Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 2596.49 899)">M1 v2</text><path d="M2534.5 1023.67C2534.5 1008.66 2546.66 996.5 2561.67 996.5L2842.33 996.5C2857.34 996.5 2869.5 1008.66 2869.5 1023.67L2869.5 1132.33C2869.5 1147.34 2857.34 1159.5 2842.33 1159.5L2561.67 1159.5C2546.66 1159.5 2534.5 1147.34 2534.5 1132.33Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 2596.49 1105)">M2 v3</text><path d="M2534.5 1379.67C2534.5 1364.66 2546.66 1352.5 2561.67 1352.5L2842.33 1352.5C2857.34 1352.5 2869.5 1364.66 2869.5 1379.67L2869.5 1488.33C2869.5 1503.34 2857.34 1515.5 2842.33 1515.5L2561.67 1515.5C2546.66 1515.5 2534.5 1503.34 2534.5 1488.33Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 2590.76 1461)">MN v1</text><path d="M2899.5 817.667C2899.5 802.663 2911.66 790.5 2926.67 790.5L3207.33 790.5C3222.34 790.5 3234.5 802.663 3234.5 817.667L3234.5 926.333C3234.5 941.337 3222.34 953.5 3207.33 953.5L2926.67 953.5C2911.66 953.5 2899.5 941.337 2899.5 926.333Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 2961.64 899)">M1 v1</text><path d="M2899.5 1022.83C2899.5 1007.74 2911.74 995.5 2926.83 995.5L3207.17 995.5C3222.26 995.5 3234.5 1007.74 3234.5 1022.83L3234.5 1132.17C3234.5 1147.26 3222.26 1159.5 3207.17 1159.5L2926.83 1159.5C2911.74 1159.5 2899.5 1147.26 2899.5 1132.17Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 2961.64 1104)">M1 v2</text><path d="M3264.5 1022.83C3264.5 1007.74 3276.74 995.5 3291.83 995.5L3572.17 995.5C3587.26 995.5 3599.5 1007.74 3599.5 1022.83L3599.5 1132.17C3599.5 1147.26 3587.26 1159.5 3572.17 1159.5L3291.83 1159.5C3276.74 1159.5 3264.5 1147.26 3264.5 1132.17Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 3326.79 1104)">M1 v2<tspan font-size="133" x="-682.733" y="175">…</tspan></text><path d="M1400.5 736.17C1400.5 645.778 1473.78 572.5 1564.17 572.5L2218.83 572.5C2309.22 572.5 2382.5 645.778 2382.5 736.17L2382.5 1406.83C2382.5 1497.22 2309.22 1570.5 2218.83 1570.5L1564.17 1570.5C1473.78 1570.5 1400.5 1497.22 1400.5 1406.83Z" stroke="#FFFFFF" stroke-width="4.58333" stroke-miterlimit="8" fill="#ED7D31" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 1574.57 714)">onnx<tspan font-size="83" x="165.39" y="0">/models Repo</tspan></text><path d="M1524.67 1515.5C1509.66 1515.5 1497.5 1503.34 1497.5 1488.33L1497.5 817.667C1497.5 802.663 1509.66 790.5 1524.67 790.5L1633.33 790.5C1648.34 790.5 1660.5 802.663 1660.5 817.667L1660.5 1488.33C1660.5 1503.34 1648.34 1515.5 1633.33 1515.5Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(-1.83697e-16 -1 1 -1.83697e-16 1606.11 1401)">MANIFEST.json</text><path d="M1757.5 817.667C1757.5 802.663 1769.66 790.5 1784.67 790.5L2293.33 790.5C2308.34 790.5 2320.5 802.663 2320.5 817.667L2320.5 926.333C2320.5 941.337 2308.34 953.5 2293.33 953.5L1784.67 953.5C1769.66 953.5 1757.5 941.337 1757.5 926.333Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 1802.57 899)">M1 v2 Pointer</text><path d="M1757.5 1023.67C1757.5 1008.66 1769.66 996.5 1784.67 996.5L2293.33 996.5C2308.34 996.5 2320.5 1008.66 2320.5 1023.67L2320.5 1132.33C2320.5 1147.34 2308.34 1159.5 2293.33 1159.5L1784.67 1159.5C1769.66 1159.5 1757.5 1147.34 1757.5 1132.33Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 1802.57 1105)">M2 v3 Pointer</text><path d="M1757.5 1379.67C1757.5 1364.66 1769.66 1352.5 1784.67 1352.5L2293.33 1352.5C2308.34 1352.5 2320.5 1364.66 2320.5 1379.67L2320.5 1488.33C2320.5 1503.34 2308.34 1515.5 2293.33 1515.5L1784.67 1515.5C1769.66 1515.5 1757.5 1503.34 1757.5 1488.33Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 1927.54 1412)">MN v1 <tspan font-size="83" x="-10.3812" y="99">Pointer</tspan></text><path d="M2320 865.125 2499.84 865.125 2499.84 878.875 2320 878.875ZM2492.96 851.375 2534.21 872 2492.96 892.625Z" fill="#FFFFFF"/><path d="M2320 1070.12 2499.84 1070.13 2499.84 1083.88 2320 1083.88ZM2492.96 1056.38 2534.21 1077 2492.96 1097.63Z" fill="#FFFFFF"/><path d="M2320 1427.13 2499.84 1427.13 2499.84 1440.88 2320 1440.88ZM2492.96 1413.38 2534.21 1434 2492.96 1454.63Z" fill="#FFFFFF"/><path d="M1666.5 1150.77 1751.73 1399.25 1738.72 1403.71 1653.5 1155.23ZM1762.51 1388.29 1756.38 1434 1723.49 1401.67Z" fill="#FFFFFF"/><path d="M4.22417-5.42421 73.482 48.5112 65.0336 59.3596-4.22417 5.42421ZM76.5061 33.4386 96.3788 75.0562 51.1611 65.9838Z" fill="#FFFFFF" transform="matrix(1 0 0 -1 1660 1152.06)"/><path d="M6.50311-2.2305 91.7294 246.25 78.7232 250.711-6.50311 2.2305ZM102.505 235.286 96.3788 280.996 63.4865 248.669Z" fill="#FFFFFF" transform="matrix(1 0 0 -1 1660 1153)"/><path d="M603.5 695.336C603.5 627.495 658.496 572.5 726.336 572.5L1217.66 572.5C1285.5 572.5 1340.5 627.495 1340.5 695.336L1340.5 1447.66C1340.5 1515.5 1285.5 1570.5 1217.66 1570.5L726.336 1570.5C658.496 1570.5 603.5 1515.5 603.5 1447.66Z" stroke="#FFFFFF" stroke-width="4.58333" stroke-miterlimit="8" fill="#ED7D31" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 695.493 702)">onnx<tspan font-size="83" x="165.39" y="0">/</tspan><tspan font-size="83" x="196.052" y="0">onnx</tspan><tspan font-size="83" x="380.348" y="0">Repo</tspan></text><path d="M663.5 854.834C663.5 833.11 681.11 815.5 702.834 815.5L1237.17 815.5C1258.89 815.5 1276.5 833.11 1276.5 854.834L1276.5 1012.17C1276.5 1033.89 1258.89 1051.5 1237.17 1051.5L702.834 1051.5C681.11 1051.5 663.5 1033.89 663.5 1012.17Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 789.11 911)">ONNX Hub <tspan font-size="83" x="-44.7562" y="99">Python Client</tspan></text><path d="M603.5 1831C603.5 1774.39 649.391 1728.5 706 1728.5L3535 1728.5C3591.61 1728.5 3637.5 1774.39 3637.5 1831L3637.5 2241C3637.5 2297.61 3591.61 2343.5 3535 2343.5L706 2343.5C649.391 2343.5 603.5 2297.61 603.5 2241Z" stroke="#FFFFFF" stroke-width="4.58333" stroke-miterlimit="8" fill="#7030A0" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 1879.05 1852)">Local Machine</text><path d="M667.5 1966.17C667.5 1933.21 694.214 1906.5 727.168 1906.5L1959.83 1906.5C1992.79 1906.5 2019.5 1933.21 2019.5 1966.17L2019.5 2204.83C2019.5 2237.79 1992.79 2264.5 1959.83 2264.5L727.168 2264.5C694.214 2264.5 667.5 2237.79 667.5 2204.83Z" stroke="#507E32" stroke-width="4.58333" stroke-miterlimit="8" fill="#70AD47" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 1121.52 2017)">Local Process<tspan font-family="Consolas,Consolas_MSFontService,sans-serif" font-size="69" x="-398.747" y="81">import </tspan><tspan font-family="Consolas,Consolas_MSFontService,sans-serif" font-size="69" x="-134.059" y="81">onnx</tspan><tspan font-family="Consolas,Consolas_MSFontService,sans-serif" font-size="69" x="-398.747" y="169">model = </tspan><tspan font-family="Consolas,Consolas_MSFontService,sans-serif" font-size="69" x="-96.247" y="169">onnx.hub.load</tspan><tspan font-family="Consolas,Consolas_MSFontService,sans-serif" font-size="69" x="395.316" y="169">(‘</tspan><tspan font-family="Consolas,Consolas_MSFontService,sans-serif" font-size="69" x="470.941" y="169">modelN</tspan><tspan font-family="Consolas,Consolas_MSFontService,sans-serif" font-size="69" x="697.816" y="169">’)</tspan></text><path d="M2248.5 1963.17C2248.5 1930.21 2275.21 1903.5 2308.17 1903.5L3539.83 1903.5C3572.79 1903.5 3599.5 1930.21 3599.5 1963.17L3599.5 2201.83C3599.5 2234.79 3572.79 2261.5 3539.83 2261.5L2308.17 2261.5C2275.21 2261.5 2248.5 2234.79 2248.5 2201.83Z" stroke="#507E32" stroke-width="4.58333" stroke-miterlimit="8" fill="#70AD47" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 2797.99 2014)">Model Cache</text><path d="M2535.5 2063.83C2535.5 2048.74 2547.74 2036.5 2562.83 2036.5L2843.17 2036.5C2858.26 2036.5 2870.5 2048.74 2870.5 2063.83L2870.5 2173.17C2870.5 2188.26 2858.26 2200.5 2843.17 2200.5L2562.83 2200.5C2547.74 2200.5 2535.5 2188.26 2535.5 2173.17Z" stroke="#2F528F" stroke-width="4.58333" stroke-miterlimit="8" fill="#4472C4" fill-rule="evenodd"/><text fill="#FFFFFF" font-family="Calibri,Calibri_MSFontService,sans-serif" font-weight="400" font-size="83" transform="matrix(1 0 0 1 2591.27 2145)">MN v1</text><path d="M0.0237067-6.87496 480.989-5.21646 480.942 8.53346-0.0237067 6.87496ZM474.162-18.9901 515.341 1.77703 474.02 22.2597Z" fill="#FFFFFF" transform="matrix(-1 0 0 1 2534.34 2118)"/><path d="M2708.87 1514.99 2709.36 2001.07 2695.61 2001.08 2695.12 1515.01ZM2723.1 1994.18 2702.52 2035.45 2681.85 1994.22Z" fill="#FFFFFF"/><path d="M946.875 1050 946.876 1871.31 933.126 1871.31 933.125 1050ZM960.626 1864.44 940.001 1905.69 919.376 1864.44Z" fill="#FFFFFF"/><path d="M1585.87 1515 1585.88 1870.83 1572.13 1870.83 1572.12 1515ZM1599.63 1863.96 1579 1905.21 1558.38 1863.96Z" fill="#FFFFFF"/></g></svg>
\ No newline at end of file
diff --git a/docs/onnx-horizontal-color.png b/docs/onnx-horizontal-color.png
new file mode 100644
index 0000000..e93090b
Binary files /dev/null and b/docs/onnx-horizontal-color.png differ
diff --git a/docs/proposals/0000-template.md b/docs/proposals/0000-template.md
new file mode 100644
index 0000000..1f48359
--- /dev/null
+++ b/docs/proposals/0000-template.md
@@ -0,0 +1,101 @@
+<!--
+Copyright (c) ONNX Project Contributors
+-->
+
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+- Feature Name: (fill me in with a unique ident, `my_awesome_feature`)
+- Start Date: (fill me in with today's date, YYYY-MM-DD)
+- RFC PR: [onnx/onnx#0000](https://github.com/onnx/onnx/pull/0000)
+- Status: (one of "under discussion, "accepted", "superseded", "rejected")
+- Authors: (list of github user names)
+
+## Summary
+[summary]: #summary
+
+One paragraph explanation of the feature.
+
+## Motivation
+[motivation]: #motivation
+
+Any changes to the ONNX standard or related software should focus on solving a problem that users are having.
+This section should explain this problem in detail, including necessary background.
+
+It should also contain several specific use cases where this feature can help a user, and explain how it helps.
+This can then be used to guide the design of the feature.
+
+This section is one of the most important sections of any RFC, and can be lengthy.
+
+## Guide-level explanation
+[guide-level-explanation]: #guide-level-explanation
+
+Explain the proposal as if it has already been accepted and this were part of the relevant user-facing documentation.
+For operators they may typically mean the doc-string associated with the operator.
+More generally (e.g., when proposing a large addition to the `onnx` Python package) this may include:
+
+- Introducing new named concepts.
+- Explaining the feature largely in terms of examples.
+- Explaining how downstream users should *think* about the feature. It should explain the impact on downstream use-cases as concretely as possible.
+- If applicable, provide sample error messages, deprecation warnings, or migration guidance.
+
+## Reference-level explanation
+[reference-level-explanation]: #reference-level-explanation
+
+This is the technical portion of the RFC. Explain the design in sufficient detail that:
+
+- Its interaction with other features/operators is clear.
+- It is reasonably clear how the feature would be implemented (here or downstream in case of a proposed operator).
+- Corner cases are dissected by example.
+
+The section should return to the examples given in the previous section, and explain more fully how the detailed proposal makes those examples work.
+
+## Drawbacks
+[drawbacks]: #drawbacks
+
+Why should we *not* do this?
+
+## Rationale and alternatives
+[rationale-and-alternatives]: #rationale-and-alternatives
+
+- Why is this design the best in the space of possible designs?
+- What other designs have been considered and what is the rationale for not choosing them?
+- What is the impact of not doing this?
+
+## Prior art
+[prior-art]: #prior-art
+
+Discuss prior art, both the good and the bad, in relation to this proposal.
+A few examples of what this can include are:
+
+- Does a similar feature/operator exist in other projects?
+- Is there an existing workaround that is commonly used?
+
+This section is intended to encourage you as an author to think about the lessons from other projects to provide readers of your RFC with a fuller picture.
+If there is no prior art, that is fine - your ideas are interesting to us whether they are brand new or if it is an adaptation from other languages.
+
+Note that while precedent is some motivation, it does not on its own motivate an RFC.
+
+## Unresolved questions
+[unresolved-questions]: #unresolved-questions
+
+- What parts of the design do you expect to resolve through the RFC process before this gets merged?
+- What parts of the design do you expect to resolve through the implementation of this feature before stabilization?
+- What related issues do you consider out of scope for this RFC that could be addressed in the future independently of the solution that comes out of this RFC?
+
+## Future possibilities
+[future-possibilities]: #future-possibilities
+
+Think about what the natural extension and evolution of your proposal would
+be and how it would affect the standard and project as a whole in a holistic
+way. Try to use this section as a tool to more fully consider all possible
+interactions with the project and language in your proposal.
+
+This is also a good place to "dump ideas", if they are out of scope for the
+RFC you are writing but otherwise related.
+
+If you have tried and cannot think of any future possibilities,
+you may simply state that you cannot think of anything.
+
+Note that having something written down in the future-possibilities section
+is not a reason to accept the current or a future RFC; such notes should be
+in the section on motivation or rationale in this or subsequent RFCs.
+The section merely provides additional information.
diff --git a/docs/proposals/0001-ArchiveFileFormatProposal.md b/docs/proposals/0001-ArchiveFileFormatProposal.md
new file mode 100644
index 0000000..db00ab6
--- /dev/null
+++ b/docs/proposals/0001-ArchiveFileFormatProposal.md
@@ -0,0 +1,47 @@
+<!--
+Copyright (c) ONNX Project Contributors
+-->
+
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+- Feature Name: ONNX File Format Proposal
+- Start Date: 2019-04-29
+- RFC PR: [onnx/onnx#1973](https://github.com/onnx/onnx/pull/1973)
+- Status: unclear (historical)
+- Authors:
+  - jspisak
+
+# ONNX File Format Proposal
+
+## Summary
+
+We propose a new file format for ONNX models that is a specific application of the [zip](https://en.wikipedia.org/wiki/Zip_(file_format)) file format. We would like to address issues with capacity limits as well as (de)serialization inefficiencies[0][1]. We aim to design a file format that is simple, widely applicable, and efficient. By storing Tensor values (i.e. values typically contained in `TensorProto` messages) as files within a zip archive, we avoid these size limitations and—with special constraints—allow for direct memory-mapping of an ONNX file such that weights can be used directly from the memory-mapped region. Using zip as our base file format allows us to create a design that is conceptually simple as well as well-supported on various platforms.
+
+## Design
+
+We propose to treat a .zip file as a key-value store, mapping string keys (filenames) to binary data files. For ONNX model serialization, we will have the following entries:
+
+* Data files - Files mapping a unique string identifier to a raw binary data file. These files shall be referenced from the appropriate fields within the base `ModelProto`
+* `__MODEL_PROTO` - File that contains the `ModelProto` describing the file
+
+Note that the order is significant here. We place the model definition file at the end of the archive to allow for the common case of net manipulations while keeping the weights invariant. This way, tools that manipulate the archive do not need to repack or realign all weights when only touching the model file.
+
+Within the ONNX protobuf definition, we propose the following changes:
+
+* Add `optional string external_data` to `TensorProto`. This can be treated as a data field similar to `float_data`, `int_data`, etc in that there must be exactly one of those fields specified. If a `TensorProto` specifies `external_data`, the implementation shall resolve this reference by string key in the containing zip archive. All values of `external_data` must be unique (under down-casing) and conform to the C identifier specification.
+
+Raw data files referenced by `TensorProto`s shall conform to the following specification:
+
+* The data shall be equivalent to that stored within the `raw_data` field in `TensorProto`.
+* Raw data files within the zip archive shall reside on an alignment boundary of 64 bytes. That is, the byte offset within the file of the first byte of a raw data tensor must be divisible by 64. This requirement can be fulfilled by packing bytes into the `extra` field of each local file record in the zip archive. (example: [2]). This constraint facilitates the direct memory-mapping of data files within the archive, and allows for architectures with both strict alignment requirements (e.g. SIMD instructions on aligned data) to operate and give architectures that operate more efficiently on cache line-aligned data to take full advantage.
+
+## File Extension
+
+In keeping with other domain-specific zip applications, we propose to use a custom file extension rather than the `.zip` extension. A custom file extension makes it clear to the user that this is not a general zip file, but rather a file that should be emitted by ONNX tools to conform to the spec.
+
+## Future-Proofing Considerations
+
+This file format represents a generic key-value store that is scalable to many entries as well as large values. Further improvements to the format may come in the form of supporting different or multiple model definitions within the same model, or modifying the way in which weight files are stored. Building off of a proven archival format allows us the reliability as well as flexibility of zip.
+
+[0] https://github.com/onnx/onnx/issues/251
+[1] https://stackoverflow.com/questions/34128872/google-protobuf-maximum-size
+[2] https://developer.android.com/studio/command-line/zipalign.html implementation https://github.com/aosp-mirror/platform_build/blob/master/tools/zipalign/ZipAlign.cpp
diff --git a/docs/proposals/0002-NLP-in-ONNX-proposal.md b/docs/proposals/0002-NLP-in-ONNX-proposal.md
new file mode 100644
index 0000000..6bb8ad5
--- /dev/null
+++ b/docs/proposals/0002-NLP-in-ONNX-proposal.md
@@ -0,0 +1,77 @@
+<!--
+Copyright (c) ONNX Project Contributors
+-->
+
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+- Feature Name: NLP in ONNX
+- Start Date: 2019-04-29
+- RFC PR: [onnx/onnx#1975](https://github.com/onnx/onnx/pull/1975)
+- Status: unclear (historical)
+- Authors:
+  - jspisak
+
+## Background
+
+Modern NLP (Natural Language Processing) is an important domain in which deep learning is applied. In addition, modern NLP networks are often non-trivial to implement and even more difficult to transfer between frameworks. These networks are handled fairly non-uniformly across the landscape of frameworks. The ability for ONNX to interchange these networks can be a very compelling feature.
+
+NLP networks, including recurrent networks, are often built on dynamic control structures. Standardizing the handling of these structures can lead to better collaboration with backends to expose network semantics and achieve better performance. A tradition has developed within the Computer Vision field for optimizing hardware backends for canonical vision models, such as ResNet-50. There is not really such as tradition in the NLP field, however. Through standardizing the representation of NLP networks, we can give vendors a common representation and push forward the performance of NLP models.
+
+## Ultimate Goal and Challenges
+
+We should work toward being able to represent major classes of NLP model architectures. One example of such an architecture is the seq2seq with attention model (e.g. https://arxiv.org/abs/1409.0473). This architecture is used for many use cases, including neural machine translation, speech processing, summarization, dialog systems, image captioning, and syntax parsing, among many others. At the same time, seq2seq with attention is sufficiently complex that supporting it will push forward the state of the art in ONNX, but not so complex that we'd need to define a full programming language.
+
+seq2seq with attention can roughly be broken down into these constituent parts:
+
+* An Encoder network
+  * This network takes a sequence of tokens and yields a sequence of embeddings representing the context found at each time-step
+  * Major classes of encoders: recurrent network (e.g. LSTM[1]), convolutional[2], attention[3].
+  * Requirements from an ONNX representation
+    * Recurrent network - general recurrent network structures preserving outputs at every timestep. Handling of padding and hidden states for batches with different sequence lengths).
+    * Convolutional - 1d convolution, position embeddings
+    * Attention - sinusoid position encodings, layer normalization
+* A Decoder network
+  * This network generates a sequence token by token, parameterized by the context provided from the encoder.
+  * Yields a probability distribution over possible tokens given previous context and encoder context.
+  * Major classes of decoders: recurrent network (e.g. LSTM), convolutional (causal, temporal for generation), attention.
+  * Generation requires dynamic control flow. Often, this is done as a beam search, so this is distinct from regular recurrent networks.
+  * Model-specific requirements
+    * Recurrent network - Recurrent network cell that can be used within the context of beam search
+    * Convolutional - 1d causal convolution (only see previous timesteps)
+    * Attention - sinusoid position encodings, masking along diagonal
+* An Attention mechanism
+  * This network weights the Encoder contexts based on the Decoder's generation state, and provides a focused Encoder context to the decoder. The Decoder “focuses” on a certain part of the input sequence at each timestep via this mechanism.
+  * Many classes of attention mechanism: some examples are here https://arxiv.org/pdf/1508.04025.pdf
+
+Vanilla seq2seq with attention and non-backtracking beam search does NOT include things such as auxiliary data-structures (e.g. stacks), thus it does not require us to implement the full semantics of a programming language. It is an architecture that we can break down into incremental improvements to ONNX without compromising ONNX's fundamental goal.
+
+[1] https://arxiv.org/abs/1409.0473
+[2] https://arxiv.org/abs/1705.03122
+[3] https://arxiv.org/abs/1706.03762
+
+## Standard Recurrent Network Constructs
+
+Standard recurrent network architectures such as LSTM or GRU are very common, and we can get very far supporting these. We already have the [LSTM](/docs/Operators.md#LSTM) and [GRU](/docs/Operators.md#GRU) operators, which execute the standard LSTM and GRU[4] operations over a sequence of inputs. These high-level operators are great, since they give backends a semantic view of the computation to be performed, and thus backends can make informed decisions about optimization. Many NLP use cases can get away with using just these operators.
+
+[4] http://colah.github.io/posts/2015-08-Understanding-LSTMs/
+
+## Generic Control Flow
+
+Once we move beyond the domain of standard LSTM and GRU operations, we need a more generic abstraction onto which we can map NLP architectures. A simple example is how one can implement Multiplicative Integration LSTM (https://arxiv.org/pdf/1606.06630.pdf) in ONNX. We can expose a standard LSTMCell via the proposed Function abstraction (https://github.com/onnx/onnx/issues/481). Building on top of this, we can construct a MI-LSTM by applying the required second-order transformations to the inputs to the LSTMCell. Once we have this aggregated implementation, we can use the generic control flow operators (https://github.com/onnx/onnx/pull/436) to apply this “composite” MI-LSTM cell over a sequence.
+
+Of course, the dynamic control flow constructs can be used for more general use cases. For example, consider the [beam search](https://en.wikipedia.org/wiki/Beam_search) used often in NLP for sequence generation. This algorithm has several tricky aspects: a (potentially) dynamic stopping condition, a desired maximum trip count (so we don't fall into an infinite loop), loop-carried dependencies, and the desire to preserve the outputs at every time-step, not just the final time-step. Inherently, this is an imperative algorithm that operates on mutable state. The proposed control flow operators in ONNX, however, fulfill all of these requirements, and thus we can represent many instances of sequence generation in ONNX graphs.
+
+Note that there are more general forms of beam search, such as those including backtracking, but we are not considering these forms for this focused proposal.
+
+## End-to-end Example : seq2seq with attention
+
+We should endeavor to have full support for seq2seq with attention models in ONNX. Facebook is currently working on this internally and creating a pytorch→ONNX→caffe2 pathway. An example of such a model we'd like to represent in ONNX is [fairseq](https://github.com/facebookresearch/fairseq). We would love to engage with the community and collaborate on anything that will help make this a reality. Additionally, if the community has any other suggestions for prominent NLP models we should be able to represent, we would love to hear your ideas.
+
+## Further Challenges
+
+Beyond the constructs used in seq2seq with attention, there are NLP models that exist today that contain more non-trivial features, such as mutable data structures that are manipulated at runtime. Examples of this include back-tracking beam search and parser models such as RNNG (https://arxiv.org/abs/1602.07776). These will present further challenges for ONNX, and the representation of these models will likely remain tied to application code for the time being. We may want to revisit this class of models in the future.
+
+Another thing we should consider is how to handle preprocessing and postprocessing routines for NLP models. For example, do we defer tokenization, normalization, and index lookup to application code? And how do we, for example, distribute dictionaries that map tokens to indices. Initially this will probably remain out of the scope of ONNX unless there is a good story for standardizing text processing.
+
+## Conclusion
+
+We have presented a proposal for a strategy for representing NLP models in ONNX, using seq2seq with attention as a canonical example that covers many use cases. We would like to hear your thoughts about this proposal and to explore opportunities for collaboration with the ONNX community for making ONNX a pleasure to use for NLP. Please feel free to voice your opinions!
diff --git a/docs/proposals/0003-ONNXIFIproposal.md b/docs/proposals/0003-ONNXIFIproposal.md
new file mode 100644
index 0000000..07866bd
--- /dev/null
+++ b/docs/proposals/0003-ONNXIFIproposal.md
@@ -0,0 +1,127 @@
+<!--
+Copyright (c) ONNX Project Contributors
+-->
+
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+- Feature Name: ONNX Interface for Framework Integration: API Proposal
+- Start Date: 2019-05-29
+- RFC PR: [onnx/onnx#1976](https://github.com/onnx/onnx/pull/1976)
+- Status: unclear (historical)
+- Authors:
+  - jspisak
+
+# ONNX Interface for Framework Integration: API Proposal
+
+## Background
+
+Leading hardware and systems vendors offer highly optimized software to run neural network graphs. These software can deliver order-of-magnitude speedups compared to generic implementations, but their integration with deep learning frameworks and applications is complicated by large variety in vendor-specific interfaces, and subtle incompatibilities with the software stack of high-level applications.
+
+So far, ONNX format targets the problem of offline conversion of neural network models between different high-level frameworks and vendor-specific libraries through offline translation. In this proposal, we suggest that ONNX ecosystem could be enriched to enable runtime discovery and selection of high-performance graph execution backends, and online (in runtime) conversion of ONNX graph to internal representations of these implementations.
+
+## Ultimate Goal
+
+We should strive for consensus on a library API to interface with optimized backends and offload parts of ONNX graphs to these high-performance hardware and software implementation. The API should enable wide interoperability between high-level deep learning frameworks, software implementations of optimized graph runtimes, and existing and upcoming neural network acceleration hardware.
+
+The standardized API should reduce friction in deploying neural network models for all involved parties:
+
+- Applications would be able to ship only one version of a neural network model (either in ONNX format, or in the format of their deep learning framework, and convert it on the fly to ONNX).
+- Deep learning frameworks would be able to integrate with many hardware vendors by using only a single interface.
+- Hardware vendors would be able to implement only one interface and get integration with many deep learning frameworks.
+
+## Design Choices
+
+- Interface must use only highly portable aspects of C ABI.
+- Neural network graphs are passed as serialized ONNX ModelProto messages. To avoid serialization overhead, weights can be passed as raw memory blobs.
+- Input and output tensors are allocated by the caller and use NCHW layout.
+- Intermediate tensors are allocated by the vendor implementation, and can use any layout.
+- Backends (software implementations and hardware accelerators) are discovered, selected, and initialized on-demand in run-time. Multiple backends can be used in the same application simultaneously.
+- There is no minimal set of ONNX operators to implement. The implementer and the user (a deep learning framework) of the API decide which operators can and will be offloaded in runtime.
+- The proposal includes the minimal functionality to let deep learning frameworks and vendor libraries work together. Several extension mechanisms can be used for more efficient vendor- or platform-specific functionality.
+
+## Proposed Interface
+
+We propose a small C-based API, which includes the following functionality:
+
+* Discover (`onnxGetNumBackends`) and query information (`onnxGetBackendInfo`) about high-performance backends
+* Initialize (`onnxInitBackend`) and deinitialize (`onnxReleaseBackend`) high-performance backends
+* Query if a backend supports an ONNX operator with particular parameters and input shapes (`onnxGetBackendCompatibility`)
+* Convert an ONNX graph to opaque vendor-specific representation of a backend (`onnxInitGraph`)
+* Specify memory locations and metadata about graph inputs and outputs (`onnxSetGraphIO`)
+* Run an ONNX graph, converted to vendor-specific representation (`onnxRunGraph`)
+* Release the vendor-specific representation of a graph and associated resources (`onnxReleaseGraph`)
+
+## General Use Pattern for Deep Learning Frameworks
+
+1. The user (deep learning framework) iterates operators in a model graph one-by-one, convert them to ONNX, and calls `onnxGetBackendCompatibility` to check which of the operators can be offloaded to the backend.
+2. The user constructs connected subgraphs of operators that can be offloaded to the backend.
+3. (Optional) For each subgraph, the user estimates if it is beneficial to offload it to the optimized backend:
+
+    a. The user queries the backend about it high-level performance characteristics using `ONNX_BACKEND_MACS_*` and `ONNX_BACKEND_MEMORY_BANDWIDTH` information queries. These data let the user build a simple roofline model of backend performance.
+
+    b. For every subgraph the user estimates time to do inference using the roofline model.
+
+    c. The user additionally estimates time to transfer subgraph inputs to the backend using `ONNX_BACKEND_CPU_MEMORY_READ_BANDWIDTH` information query and to transfer subgraph outputs from the backend using `ONNX_BACKEND_CPU_MEMORY_WRITE_BANDWIDTH`.
+
+    d. If predicted time to transfer inputs to the backend, do inference, and transfer outputs from the backend exceeds predicted time to do the inference on default engine (e.g. CPU), the user falls back to a different ONNX backend, or to the default engine.
+
+4. The user initialized the backend, and offloads the subgraph execution to the ONNX backend by calling `onnxInitGraph`, `onnxSetGraphIO` and `onnxRunGraph`
+
+## Implementation Notes
+
+### Backend object
+
+Backend is a combination of software library and hardware device. The same device (e.g. "NVIDIA Tesla P100 on CUDA index #0" accessed though different software libraries would be seen as different backends. A single software library can expose multiple backends, one per device  (e.g. each CUDA GPU in a system is exposed as a separate backend, or CPU, GPU, and DSP on a mobile chipset are exposed as three different backends).
+
+We recommend that vendors make the backend object reference-counted, and use `uint32_t magic` as the first data field of the object:
+
+```c
+struct MyBackend {
+  uint32_t magic;
+  uint64_t referenceCount;
+  ...
+};
+
+/* This line won't compile, but gives you an idea of relation between MyBackend structure and onnxBackend type. */
+typedef MyBackend* onnxBackend;
+```
+
+Magic is an arbitrary 32-bit integer unique for a library implementing the API. It should be used to verify that the backend object passed to `onnxInitGraph` was created by `onnxInitBackend` in the same library.
+
+### Graph object
+
+Graph object is a vendor-specific representation of ONNX ModelProto message. Graph is logically related to the backend used to create it, and a typical implementation of a graph object would hold a reference to its backend object.
+
+We recommend that vendors use `uint32_t magic` as the first data field of the graph object:
+
+```c
+struct MyGraph {
+  uint32_t magic;
+  struct MyBackend* backend;
+  ...
+};
+
+/* This line won't compile, but gives you an idea of relation between MyGraph structure and onnxGraph type. */
+typedef MyGraph* onnxGraph;
+```
+
+Magic is an arbitrary 32-bit integer unique for a library implementing the API. It should be used to verify that the backend object passed to `onnxInitGraph` was created by `onnxInitBackend` in the same library. Magic for a graph object should be different from magic of a backend object of the same library.
+
+### Library initialization
+
+During one-time library initialization, the implementation of the API would detect `n` supported devices and map them to backend indices in `0...(n-1)` range. The implementation of device discovery and checking required device characteristics is highly vendor- and platform-specific, e.g.:
+
+- A CPU implementation may always expose 1 device.
+- A CUDA-based implementation may call `cudaGetDeviceCount` to get the number of CUDA-enabled devices, then
+ call `cudaGetDeviceProperties` for each device, and map CUDA devices which satisfy the minimum required functionality, such as compute capability, to backend indices.
+- An OpenCL-based implementation for a mobile GPU would try to load OpenCL library, call `clGetPlatformIDs` and `clGetPlatformInfo` to find a supported platform, then call `clGetDeviceIDs` and `clGetDeviceInfo` to find a supported GPU device, and map it to the only exposed backend if such device exists, or expose 0 devices otherwise.
+- An implementation for hardware neural network accelerators would call vendor-specific driver API to discover accelerator devices installed in the system and map them to backend indices.
+
+We recommend that library initialization is triggered on the first call to `onnxGetNumBackends`, `onnxGetBackendInfo`, or `onnxInitBackend`. Using a global static C++ object for initialization may hurt portability if library initialization involves loading other shared libraries (DLLs): on Windows `LoadLibrary` function can't be used in initializers of global static objects.
+
+### onnxGetNumBackends
+
+Implementation would [initialize the library](#library-initialization), if it wasn't initialized already, and return the number `n` of available backends.
+
+### onnxGetBackendInfo
+
+Implementation would [initialize the library](#library-initialization), if it wasn't initialized already, and query information about the backend using vendor- or platform-specific API (e.g. `cudaGetDeviceProperties`, `clGetDeviceInfo`, CPUID instruction). Implementation can cache this information when it is first queried or during initialization, and return the cached value.
diff --git a/docs/proposals/0004-FunctionsProposal.md b/docs/proposals/0004-FunctionsProposal.md
new file mode 100644
index 0000000..3ad7d32
--- /dev/null
+++ b/docs/proposals/0004-FunctionsProposal.md
@@ -0,0 +1,33 @@
+<!--
+Copyright (c) ONNX Project Contributors
+-->
+
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+- Feature Name: Adding Function into ONNX
+- Start Date: 2019-04-29
+- RFC PR: [onnx/onnx#1978](https://github.com/onnx/onnx/pull/1978)
+- Status: unclear (historical)
+- Authors:
+  - jspisak
+
+## Proposal Adding Function into ONNX
+
+Motivation:
+
+1. Reduce number of primitive operators in ONNX
+To make it easier for hardware vendors to follow ONNX, we want to make it possible to define composite operators in terms of more primitive operators, reducing the number of kernels which must be directly implemented. For example, FC should be declared to be a composition MatMul and Add.
+
+2. Expose customize function capability for graph optimization.
+To provide a mechanism of doing graph optimization, say, kernel fusion (merge a subgraph into one node with generated efficient kernel codes). This will in turn help HW acceleration, since common-patterns of kernel fusion may be pre-defined as common functions in ONNX and no sub-graph (function) finding needed for kernel fusion anymore. For example, subgraph having "Add", "Sigmoid", "Tanh", "Mul" nodes could be merged into one fusion node with generated cuda kernel containing "+", "sigmoidf", "tanhf", "*".
+
+3. Provide a flexible RNN implementation.
+To define a library of RNN cells and allow the user to write a custom one.
+
+MAJOR CHANGES:
+
+1. FunctionProto added to represent a function.
+2. FunctionSetProto added to represent a function set.
+3. AttributeProto updated to support function attribute type and allow attribute reference.
+4. ModelProto updated to contain customized function set.
+
+Prototype details can be found [here](https://github.com/linkerzhang/onnx/blob/kezhan/add_function_private/onnx/onnx.in.proto)
diff --git a/docs/proposals/0005-SymbolicShapeInfProposal.md b/docs/proposals/0005-SymbolicShapeInfProposal.md
new file mode 100644
index 0000000..b462c6a
--- /dev/null
+++ b/docs/proposals/0005-SymbolicShapeInfProposal.md
@@ -0,0 +1,178 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+- Feature Name: Symbolic Shape Inference And Partial Data Propagation
+- Start Date: 2021-09-16
+- RFC PR: [onnx/onnx#3721](https://github.com/onnx/onnx/pull/3721)
+- Status: accepted
+- Authors:
+  - askhade
+
+# Proposal - Symbolic Shape Inference And Partial Data Propagation
+
+*Note: This proposal was accepted and implemented in ONNX 1.10. Following PRs implemented this proposal: 3518, 3551, 3593, 3580*
+
+## Introduction
+
+ONNX provides an implementation of shape inference on ONNX graphs. Shape inference is computed using the operator level shape inference functions. The inferred shape of an operator is used to get the shape information without having to launch the model in a session. Such static shape inference can be used to catch obvious errors before runtime, eliminate run-time checks which are otherwise guaranteed to pass, improve static memory planning and improve model visualization experience. For pytorch exporter and compiler-based execution providers like Nuphar, shape inference is required (rank inference is minimum requirement), and they cannot work with unknown shapes.
+
+This document explains the limitations of shape inference and lays out a proposal for addressing these limitations.
+
+## Current onnx shape inference limitations (Pre ONNX 1.10)
+
+Today, ONNX shape inference is not guaranteed to be complete. Wherever possible we fall back to rank inference however, there are scenarios when rank inference is not possible either. Here are the various limitations which block the completion of shape inference:
+
+1. Some dynamic behaviors block the flow of shape inference, and the shape inference stops. For example, reshape to a dynamically computed shape.
+
+2. Shape inference works only with constants and simple variables. It does not support arithmetic expressions containing variables nor does it support symbol generation. For example, concatenation on tensors of shapes (5, 2) and (7, 2) can be inferred to produce a result of shape (12, 2), but concatenation on tensors of shapes (5, 2) and (N, 2) will simply produce (?, 2), where “?” represents a dimension with neither dim value nor dim param, rather than containing a representation of N+5 or generating a new symbol (M, 2). In such scenarios shape propagation stops.
+
+3. All operators are not required to have a shape inference implementation. When such an op is encountered the shape inference stops. There are also cases when rank inference is not done as a fallback mechanism. (Note: We are working on an ongoing basis to identify and fix such issues. The current document does not focus on this limitation)
+
+## Goals and Non-Goals
+
+Our **goal** is to fix the shape inference gap in scenarios where:
+
+* Shape computations are done in branches (refer to limitation 1)
+
+* Symbolic dimensions are present (refer to limitation 2)
+
+By fixing these gaps we aim to:
+
+* Unblock pytorch exporter from exporting models when exporting stops because of absence of shape information.
+
+* Improve static memory planning in the runtimes.
+
+* Enable pre-allocating output buffers outside of the runtimes so that its lifetime can be managed by the caller itself.
+
+### Non-goals
+
+* Add symbolic expressions to ONNX standard: This is not necessary for accomplishing our goals. There are advantages to having this capability, for example this can significantly reduce the number of symbols introduced and it can also provide more deterministic shape calculations in certain special cases. However, the tradeoff is the added complexity. So, at this point we are not considering it. This can be considered in future iterations.
+
+* Enable data computation and propagation for older operator sets. (details in the proposal section)
+
+Note: This work will benefit Nuphar as well but right now there is no plan to move Nuphar to use this solution.
+
+## Terminology
+
+Shape inference can be broken into 2 parts:
+
+* Node level shape inference: This refers to operator specific shape inference functions. They are defined with the operator schema itself.
+
+* Graph-level shape inference: This refers to the higher-level logic which walks through the entire graph, gets the inferred shape from node level shape inference functions and then makes decisions on merging these inferred shapes with existing shapes so that they are available for downstream nodes.
+
+## Proposal
+
+Extend current shape inference to allow:
+
+* Symbol generation and propagation
+
+* Partial data computation and propagation
+
+* Extend shape op to generate slice of the shape to facilitate simplifying shape computations.
+
+## Extend shape inference
+
+### Symbol generation and propagation
+
+Extend graph level shape inference to maintain a graph level view of symbols and generate new symbols where necessary. This will enable us to continue the shape inference of the downstream nodes.
+
+Example:
+
+For an op like “Concat” if its inputs have shapes “[M]” and “[N]” current shape-inference returns “[?]” where “?” is to indicate a dimension with neither dim-value nor dim-param set. Now, suppose the output X of “Concat” is input to a unary-op Op1() whose output Y is then input to another unary-op Op2() whose output is Z, etc. The shape “[?]” is propagated further. We infer that Y and Z have shape “[?]”. However, we do not infer that X, Y, and Z have the same shape because two “?” cannot be considered equal.
+
+Per the current proposal, “[?]” in inferred shapes will be replaced by a new unique symbol by the graph level shape inference so the downstream nodes can use the symbolic shapes to carry out shape inference. In the current example, “Concat” will produce “[?]” as the shape which will then be replaced by “[K]”, then subsequent shape inference will infer that X, Y, and Z all have the same shape “[K]”. Runtimes can use this information to reuse memory for these tensors.
+
+### Partial data computation and propagation
+
+When shape inputs are computed dynamically, shape inference post a reshape node stops. This can be prevented by making this data available to the reshape node during shape inference. We propose computation and propagation of data for operators which are used in shape computation.
+
+It is called “partial” data computation and propagation because this will only be done for shape computations. It is not meant to be a full-fledged kernel for the operator. For the same reasons data computations will be implemented for a limited set of operators. While we will increase the coverage in the future iterations it is important to note that for some operators like LSTM, convolution ops, pooling ops etc. data propagation function will never be added because such ops are not used in shape computations.
+
+The following operators will be picked in the first phase. (These operators are generally used for shape computations.)
+
+| Ops     |
+| --------|
+| Add     |
+| Sub     |
+| Mul     |
+| Cast    |
+| Concat  |
+| Gather  |
+| Reshape |
+| Shape   |
+| Slice   |
+| Size    |
+| Squeeze |
+| UnSqueeze |
+
+The OpSchema class will be extended to include an optional “PartialDataPropagationFunction” like the existing TypeAndShapeInferenceFunction. This function will provide data computation for the operators which will then be propagated to the downstream operators by the graph level shape inference. PartialDataPropagationFunction will be called by the graph level shape inference after TypeAndShapeInference runs for the node because the output shape is required for partial data computation.
+
+A new interface "DataPropagationContext” will be added to allow  PartialDataPropagationFunction to access all the information required to propagate shape data for the given node and allow writing of the computed data.
+
+Example:
+
+```
+using DataPropagationFunction = std::function<void(DataPropagationContext&)>
+
+class OpSchema final {
+
+ public:
+  .
+  .
+  .
+
+  OpSchema& PartialDataPropagationFunction(DataPropagationFunction dataPropagationFunction)  {
+    partial_data_propagation_function_ = std::move(dataPropagationFunction);
+    return *this;
+  }
+
+  DataPropagationFunction GetDataPropagationFunction() const {
+    return partial_data_propagation_function_ ? partial_data_propagation_function_ : dummyDataPropagator;
+  }
+}
+
+// Operator schema example
+ONNX_OPERATOR_SET_SCHEMA(
+    Shape,
+    13,
+    OpSchema()
+        .SetDoc(“”)
+        .Input(0, "data", "An input tensor.", "T", . . .)
+        .Output(0, "shape", "Shape of the input tensor", "T1", . . .)
+        .TypeConstraint("T", OpSchema::all_tensor_types())
+        .TypeConstraint("T1", {"tensor(int64)"})
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+        . . .
+        })
+
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          TensorShapeProto tp;
+          // compute output data for shape operator
+          // add computed data to DataPropagationContext for propagating it downstream
+          ctx.addOutputData(0, std::move(tp));
+        }));
+```
+
+The symbol generation will happen at the graph level shape inference, therefore all the models (older opsets as well as the latest opset versions) can benefit from this enhancement. However, the data computation and propagation are tied to the OpScehma and will happen at node level. To begin with these functions will only be added to the latest op schemas. Older schemas can be extended to support data computation later, on a case by case basis to support some high priority scenarios. What this means is that older opset models will not benefit from shape inference improvements because of this enhancement.
+
+## Special Cases
+
+This section considers some edge cases and proposes a solution to handle them.
+
+### Broadcasting with symbolic dims
+
+If we have a broadcast between two unknown dimensions “M” and “N” we cannot infer that both M and N should have the same value. The runtime semantics allows for one of the two symbols to have the value 1 and the other to have a value different from 1. So, merging M and N and treating them as the same value is potentially unsound. In this case, a new symbol will be generated for the output shape and the shape inference will continue.
+
+### Inferred shape does not match output shape
+
+Inferred and existing shapes can be mismatched. Although failing shape inference in such cases seems like the correct approach it may not always be practical. By default, shape inference will fail when such a case is encountered however callers will have an option to override existing types with inferred types. When this option is enabled, shape inference will continue with the inferred type.
+
+### Handling symbolic dimensions with data propagation
+
+When the shape contains symbolic dimensions, we try and propagate them downstream, however in cases where some arithmetic operations are performed on these symbolic dims we create new symbols and propagate them instead.
+
+### Output shape is dependent on input data
+
+There are certain nodes like NonZero where the output shape depends on the input data. In this case it is not possible to infer the shape completely hence a new symbolic shape will be created using the inferred rank and shape inference will continue.
diff --git a/docs/proposals/0006-ONNXMultiDeviceProposal.md b/docs/proposals/0006-ONNXMultiDeviceProposal.md
new file mode 100644
index 0000000..e8f10a0
--- /dev/null
+++ b/docs/proposals/0006-ONNXMultiDeviceProposal.md
@@ -0,0 +1,191 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+- Feature Name: Multi-Device Proposal
+- Start Date: 2025-03-04
+- RFC PR: [onnx/onnx#6641](https://github.com/onnx/onnx/pull/6641)
+- Status: unclear (historical)
+- Authors:
+  - kevinch-nv
+
+# ONNX Multi-Device Proposal
+
+## Background
+
+The recent trend in increasingly larger models has spurred an interest in distributed inference. A key performance bottleneck for inference for these large models has been the memory limits of GPUs and other accelerators as well as communication bandwidth. Thus, efficient distributed inference typically requires parallelization of the computation across multiple devices taking memory and bandwidth into account.
+
+Our goal is to extend ONNX so that it can serve as a representation of a parallelized model. This is driven by the current state-of-the-art techniques used for distributed inference (eg., see [GSPMD: General and Scalable Parallelization for ML Computation Graphs](https://arxiv.org/pdf/2105.04663.pdf)). In particular, two techniques of interest are tensor parallelism and pipelining. In tensor parallelism (also known as horizontal parallelism or operator parallelism), the computation of a single operator (node) in the graph is parallelized across multiple devices by sharding its inputs, In pipeline parallelism, different subgraphs are assigned to different devices.
+
+## Design
+
+See [this commit](https://github.com/kevinch-nv/onnx/commit/07e97452096b28ba7c46fec6927d195907431e07) for the proposed additions to the ONNX spec.
+
+The key point of this design is that all multi-device specific annotations are at the node level, and do not affect the main computational graph. This means:
+
+- All communication operations required for multi-device execution are implicit
+- A backend may choose to ignore the annotations if the provided configurations are either not supported or not available
+
+### Sharding Specification
+
+Sharding refers to modifying a tensor into multiple parts to be sent across multiple devices. A tensor may be sharded across any of its axis.
+
+Modification of a tensor generally falls into two categories: splitting and duplication. A formal description of the sharding rules can be found [here](0007-ShardingFormalism.md).
+
+#### Sharding as a Split
+
+For example, consider the following 2x2 tensor:
+
+`[[1, 2], [3, 4]]`
+
+If a sharding across axis 0 is specified over two devices, then:
+
+- Device 0 will receive a tensor of shape 1x2 with data `[[1, 2]]`
+- Device 1 will receive a tensor of shape 1x2 with data `[[3, 4]]`
+
+The corresponding ShardingSpecProto for the above will look like:
+
+```
+{
+    device = [0, 1]
+    sharded_dim =[
+        {
+            axis = 0
+            simple_sharding =
+            [
+                {
+                    num_shards = 2
+                }
+            ]
+        }
+    ]
+}
+```
+
+If a sharding across axis 1 is specified over two devices, then:
+
+- Device 0 will receive a tensor of shape 2x1 with data `[[1], [3]]`
+- Device 1 will receive a tensor of shape 2x1 with data `[[2], [4]]`
+
+The corresponding ShardingSpecProto for the above will look like:
+
+```
+{
+    device = [0, 1]
+    sharded_dim =[
+        {
+            axis = 1
+            simple_sharding =
+            [
+                {
+                    num_shards = 2
+                }
+            ]
+        }
+    ]
+}
+```
+
+If a sharding across axis 0 and axis 1 is specified over four devices, then:
+
+- Device 0 will receive a tensor of shape 1x1 with data `[[1]]`
+- Device 1 will receive a tensor of shape 1x1 with data `[[2]]`
+- Device 2 will receive a tensor of shape 1x1 with data `[[3]]`
+- Device 3 will receive a tensor of shape 1x1 with data `[[4]]`
+
+The corresponding ShardingSpecProto for the above will look like:
+
+```
+{
+    device = [0, 1, 2, 3]
+    sharded_dim =[
+        {
+            axis = 0
+            simple_sharding =
+            [
+                {
+                    num_shards = 2
+                }
+            ]
+        }
+        {
+            axis = 1
+            simple_sharding =
+            [
+                {
+                    num_shards = 2
+                }
+            ]
+        }
+    ]
+}
+```
+
+A key observation in the above example shows how indexing is performed when multiple sharding axes are provided. In general, the splitting is done as:
+
+```
+split_tensors = []
+for a in range(num_shards_a):
+    a_width = input.shape[axis0] / num_shards_a
+    a_index = a * a_width
+    for b in range(num_shards_b):
+        b_width = input.shape[axis1] / num_shards_b
+        b_index =  b * b_width
+        split = input[a_index : a_index + a_width, b_index : b_index + b_width]
+        split_tensors.append(split)
+```
+
+Note that the above examples assume that the num_shards are evenly divisible into the axis that's being sharded. While this is not a hard restriction, it is up to the backend on how to handle non-evenly divisible cases.
+
+#### Sharding as a Broadcast
+
+There may be cases where data in a tensor must be duplicated across multiple devices to ensure that operations stay functionally correct.
+
+For example consider replicating the same 2x2 tensor across two devices. We can do so by providing the following ShardingSpecProto:
+
+```
+{
+    device = [-1] // keys into device_map
+    device_map = {-1: [0, 1]}
+    sharded_dim =[]
+}
+```
+
+It is also possible to mix splitting and broadcasting, consider the following ShardingSpecProto:
+
+```
+{
+    device = [-1, -2] // keys into device_map
+    device_map = {-1: [0, 1], -2: [2, 3]}
+    sharded_dim =[
+        {
+            axis = 0
+            simple_sharding =
+            [
+                {
+                    num_shards = 2
+                }
+            ]
+        }
+    ]
+}
+```
+
+On device 0 and 1, the following 1x2 tensor is produced: `[[1,2]]`
+On device 2 and 3, the following 1x2 tensor is produced: `[[2,3]]`
+
+#### Pipeline Parallelism
+
+Pipeline stages are represented as an optional integer value in a node's NodeConfigurationProto. It is a hint to the backend on how to run a model in a pipelined fashion across multiple devices. For example, consider the following diagram:
+
+```
+Nodes below have a pipeline id of 1:
+
+A -> B -> C -> D -> E
+                    | Nodes below have a pipeline id of 2:
+                    F -> G -> H -> I -> J -> K
+
+```
+
+It is possible to have both pipeline and tensor parallel annotations in the same ONNX graph.
diff --git a/docs/proposals/0007-ShardingFormalism.md b/docs/proposals/0007-ShardingFormalism.md
new file mode 100644
index 0000000..1cad51b
--- /dev/null
+++ b/docs/proposals/0007-ShardingFormalism.md
@@ -0,0 +1,269 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+- Feature Name: Sharding Formalism
+- Start Date: 2025-03-04
+- RFC PR: [onnx/onnx#6641](https://github.com/onnx/onnx/pull/6641)
+- Status: unclear (historical)
+- Authors:
+  - kevinch-nv
+
+# Sharding Formalism
+
+In this section, we address the following aspects of a sharding specification:
+the semantics of a sharding specification,
+checking a sharding specification for validity,
+and inferring a complete sharding specification given a partial one.
+
+**Semantics of the sharding spec**:
+We start with an informal description of the intended behavior of a sharding spec.
+Operationally, the execution of an annotated node proceeds as below:
+first, the input data is partitioned or repartitioned, as necessary, to
+ensure that it is in the sharded form specified in the node.
+This potentially involves communication operations among the different devices.
+Next, a parallelized implementation of the operation is applied to the sharded
+data.
+Finally, the output is produced in the sharded form specified in the node.
+This too may involve the use of communication collective ops.
+
+**Validity of a sharding spec**:
+Note that not all input sharding specs make sense.
+For example, consider the addition operator `Add(A,B)`, where both inputs are
+two dimensional tensors of shapes `[32, 1024]`. Sharding the first input between
+two devices along axis 0 and the second input between the same two devices
+along axis 1 does not make sense. In fact, we typically expect both inputs to be
+sharded the same way.
+
+A sharding-checker to check if a given input sharding spec makes sense would be
+useful and we recommend building one. The correctness requirements, however, vary from
+operator to operator, though they mostly fall into one of a few different groups,
+described in more detail below.
+
+Note that the output sharding spec for a node does not have to be consistent with
+the input sharding spec of the node.
+This is useful when we want to reshard the output to be more suitable for the consumers
+of the output.
+
+However, even if a given sharding spec makes sense, a particular implementation
+may not support it. The implementation should ideally provide feedback to
+the user indicating this, but may choose to use an alternative impcccccbkvgevnrbllementation
+or abort. Different users and scenarios may have different requirements (on
+whether an alternative parallel or sequential implementation is preferable or not.)
+Thus, a particular implementation may have stricter requirements on the set of sharding
+specs that it supports.
+
+**Inference of missing elements of a sharding spec**:
+A validity checker can be extended to automatically infer some missing elements of a sharding
+spec, as we outline below.
+
+* If no input sharding spec is provided for a node's input X, it is assumed to be the same as
+the sharding spec specified for X at the node that produces the value X.
+* If X is a model input, then X is assumed to be unsharded.
+
+If no output sharding spec is provided for a node's output, it is inferred from the node's
+input sharding spec and the node's operation. In general, this may vary from operator to
+operator. The inference scheme is outlined for a few core groups of operators below.
+
+**Extensions**:
+Currently, the sharding spec does not allow a way of specifying a sharding for the model
+inputs. Sharded model inputs could be useful in an execution setting where the model input
+already exists in sharded form, making it easier to compose sharded execution.
+Extensions to the sharding spec to enable this is future work.
+
+## Restrictions on Sharding Specs
+
+Informally, constraints on sharding follow from parallelizability of the computation along
+the different axes of the input and output tensors. Often the computation of the output
+can be expressed in terms of loops (iterations) over the different axes of the input and/or output tensors.
+If the iteration over a specific axis can be expressed as a parallel loop, sharding along
+that axis makes sense. If that iteration is a reduction loop, sharding along that axis may
+still work, but require a subsequent collective (multi-device) reduction after the local
+reductions on each device.
+
+### Unary elementwise ops
+
+List of operations:
+_Abs, Acos, Acosh, Asin, Asinh, Atan, Atanh, Cast, Ceil, Cos, Cosh, Dropout, Erf, Exp, Floor, Identity, IsInf, IsNaN, Log, Max, Min, Neg, Not, Reciprocal, Round, Sigmoid, Sign, Sin, Sinh, Tan, Tanh, ConstantOfShape_.
+
+**Constraints on input sharding**
+
+* No constraints on input sharding.
+
+**Inference of output sharding**
+
+* If not specified, the output sharding is the same as input sharding
+
+### Broadcast n-ary elementwise ops
+
+List of operations:
+_Add, And, BitShift, BitwiseAnd, BitwiseNot, BitwiseOr, BitwiseXor, Equal, Greater, Less, Mod, Mul, Or, Pow, Sub, Sum, Where, Xor_.
+
+**Constraints on input sharding**
+
+* For any non-broadcast axis, the sharding spec of the two (or more) inputs must be identical
+* Any broadcast axis of size 1 (in the unsharded original tensor) must be replicated across all devices
+that participate in the parallel computation (that is, all devices identified in the node's sharding spec).
+* The case where there are two or more broadcast axes is more involved. Some conditions must be satisfied
+to ensure that the natural output (without extra communication ops) has a proper (complete) sharding.
+The constraint is that the sharding specs of the multiple broadcast axes must be *composable*,
+which is illustrated down below.
+
+**Inference of output sharding**
+
+* The sharding spec for any axis of the output is the same as the sharding spec for the corresponding
+input axes in the case of non-broadcast.
+* In the case of a single broadcast axis, the output axis derives the sharding spec from the corresponding
+input axes with a size other than 1, if any.
+* In the special case where all corresponding input axes have a size of 1, the output axis inherits
+the same sharding (that is, replicated across all devices of the node op).
+* In the case of two or more broadcast axes, the output axis derives the sharding spec from the corresponding
+input axes with a size other than 1, if any. However, the device assignment is inferred by composing the
+sharding specs of all broadcast axes (where each output shard resides in the intersection of the sets of
+devices that contain the corresponding input shards used to compute that output shard). See below for
+an illustration of this.
+
+**Composing Sharding Specs on Different Axes**
+
+Consider the example of an `Add (Input1, Input2)` op. Consider the case where `Input1` has shape `[M, 1]` and
+`Input2` has shape `[1, N]`. The output has shape `[M, N]`, as a result of broadcasting.
+
+The figure below shows how we can use sharding for both the `M` and `N` axes:
+
+![Composing sharding specs on different axes](images/composing_broadcast_axes.png)
+
+Note that in this example, both the `M` and `N` axes are split into two shards each.
+This means that the output itself has 4 shards, as shown in the figure.
+In this example, we want each output-shard to be on one device, as described by
+the sharding spec
+
+```python
+{
+    device = [0, 1, 2, 3]
+    sharded_dim =[
+        {
+            axis = 0
+            simple_sharding =
+            [
+                {
+                    num_shards = 2
+                }
+            ]
+        }
+        {
+            axis = 1
+            simple_sharding =
+            [
+                {
+                    num_shards = 2
+                }
+            ]
+        }
+    ]
+}
+```
+
+To produce this output, however, we need to ensure that the input-shards are
+each available in two devices each, as shown in the figure above. In particular,
+the first shard of `Input1` is needed by both devices 0 and 1, as it is used
+to compute the first two output shards. Likewise, the first shard of `Input2`
+is needed by both devices 0 and 2.
+
+Thus, the sharding spec for `Input1` is as below:
+
+```python
+{
+    device = [-1, -2] // keys into device_map
+    device_map = {-1: [0, 1], -2: [2, 3]}
+    sharded_dim =[
+        {
+            axis = 0
+            simple_sharding =
+            [
+                {
+                    num_shards = 2
+                }
+            ]
+        }
+    ]
+}
+```
+
+The sharding spec for `Input2` is analogous, as explained and shown in figure above.
+
+This leads to the following constraint for input-sharding and inference rule
+for output-sharding in the presence of two broadcast axes:
+
+* The (inferred) devices for `output-shard[i,j]` is the intersection of the set of devices
+for `input-1-shard[i]` and `input-2-shard[j]`. If this set is empty, then the input
+sharding specs are not compatible (for broadcast composition).
+
+This rule is extended to the case of more than two broadcast axes accordingly.
+
+### Reduction ops
+
+**Constraints on input sharding**
+
+* No constraints on input sharding.
+* Sharding along non-reduction axes is straightforward. It indicates
+parallelization of the iteration over the non-reduction axes.
+* Sharding along reduction axes is permitted. It indicates parallelization of the reduction
+loop, but this involves performing the reduction in two steps. In the first step, the
+reduction is done locally on the shard, and in the second step the reduction is done
+across the different shards. This can be typically mapped to a collective-reduce operation.
+
+**Inference of output sharding**
+
+* Non-reduction axes inherit the sharding of the corresponding axes of the input.
+* Since the size of the reduction axis is one after the reduction, it can't be used
+for any meaningful sharding. The axis may even be omitted from the output shape,
+depending on the value of the attribute `keep_dims`. If the axis is retained, it
+is treated as having no sharding.
+
+In the case where the inputs are only sharded along one or more reduction axes,
+there will be no sharded axis in the inferred output sharding specification.
+However, there is still a choice as to whether the computed output is replicated
+on all the devices that participate in this operation, or whether it is stored
+only in some distinguished node. Collective-reduce operations typically
+support both variations. The default inferred output specification is to
+broadcast the computed result to all devices that participate in the particular
+reduction (the first option).
+
+### MatMul-like ops
+
+List of operations: MatMul, Gemm, quantized variations of these ops, special cases of Einsum
+
+The constraints for these ops follow analogous cases above. Consider the simple case of matrix multiplication
+of two matrices of dimensions `[M, K]` and `[K, N]` producing an output matrix of dimension `[M, N]`.
+This operation is essentially a broadcast-reduction operation, where the first
+input is interpreted to have the shape `[M, K, 1]` and the second input is interpreted to have
+the shape `[1, K, N]`, and we perform a broadcast element-wise multiplication, followed
+by a reduce-sum along the `K` axis. The constraints and inference for the operation follows
+from the corresponding rules for broadcast and reduction described above.
+
+Axis 0 of the first input (with value `M`) is conceptually broadcast to the second input.
+Hence, its constraints and handling are similar to the treatment of broadcast axes for n-ary
+elementwise ops. Specifically, since only the first input has this axis, the partitioning of
+this axis is not constrained by the partitioning of the second input. Furthermore, the output
+matrix will inherit the partitioning for the corresponding axis from the partitioning of axis
+0 of the first input.
+
+Axis 1 of the second input (with value `N`) is also handled similarly.
+
+The two axes with size value (the _reduction_ axes) are both required to
+have the same sharding (similar to non-broadcast axes in a binary operation above).
+
+The output device assignment follows the rules described above for broadcast axes.
+
+### Unsupported ops
+
+The following ops are not supported in this version:
+
+* Operations on sequences and optional values.
+* Control-flow ops, such as _If, Loop, Scan_.
+* _GRU, LSTM, RNN, DFT, STFT, MelWeightMatrix, TfidVectorizer_
+* Convolution / Pooling ops, such as:
+* _AveragePool, GlobalAveragePool, GlobalLpPool, GlobalMaxPool, LpPool, MaxPool, MaxRoiPool,_
+* _Conv, ConvInteger, ConvTranspose, DeformConv,_
+* _InstanceNorm, LpNormalization, LayerNormalization_
diff --git a/docs/proposals/README.md b/docs/proposals/README.md
new file mode 100644
index 0000000..44fa56b
--- /dev/null
+++ b/docs/proposals/README.md
@@ -0,0 +1,34 @@
+<!--
+Copyright (c) ONNX Project Contributors
+-->
+
+<!--- SPDX-License-Identifier: Apache-2.0 -->
+
+# ONNX RFCs
+[ONNX RFCs]: #onnx-rfcs
+
+The "RFC" (request for comments) process is intended to provide a consistent
+and controlled path for changes to ONNX (such as new features) so that all
+stakeholders can be confident about the direction of the project.
+
+Many changes, including bug fixes and documentation improvements can be
+implemented and reviewed via the normal GitHub pull request workflow without an RFC.
+
+Some changes though are "substantial", and we ask that these be put through a
+bit of a design process and produce a consensus among the ONNX community and
+the relevant [Special Interest Groups](https://github.com/onnx/sigs/tree/main).
+
+The template found in this folder is the (strongly recommended) starting point for new RFCs, but authors may deviate from it if needed.
+
+## Life-cycle of an RFC
+
+Before drafting up an RFC, it is recommended to first get in touch with relevant people and groups.
+This may happen by creating a small issue in [`onnx/onnx`](https://github.com/onnx/onnx), asking questions on [slack](https://app.slack.com/client/TPUCV58TG/CPS6Q1600), or by joining relevant [sig meetings](https://github.com/onnx/sigs/tree/main).
+
+After this initial phase, authors are encouraged to draft the RFC based on the template found in this folder and to open a PR.
+The proposal is then reviewed and discussed within that PR.
+The outcome of this process may either lead to the proposal being accepted or rejected, but it should be merged either way for future reference.
+
+Generally, an accepted RFC should be a fairly stable and final affair due to a rigorous review process leading to the acceptance in the first place.
+However, new circumstances and ideas may arise after an RFC has been accepted.
+In such cases we may either choose to re-open the accepted RFC, or to create a new RFC.
diff --git a/docs/proposals/images/composing_broadcast_axes.png b/docs/proposals/images/composing_broadcast_axes.png
new file mode 100644
index 0000000..d147056
Binary files /dev/null and b/docs/proposals/images/composing_broadcast_axes.png differ
diff --git a/onnx/CMakeLists.txt b/onnx/CMakeLists.txt
new file mode 100644
index 0000000..1c7a7c6
--- /dev/null
+++ b/onnx/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+# Sources directly in onnx/
+# Note: cpp2py_export.cc is excluded — it is compiled separately into the
+# onnx_cpp2py_export Python extension module.
+target_sources(onnx PRIVATE
+    checker.cc
+    checker.h
+    onnx_pb.h
+    onnx-operators_pb.h
+    proto_utils.h
+    py_utils.h
+    string_utils.h
+)
+
+add_subdirectory(common)
+add_subdirectory(defs)
+add_subdirectory(inliner)
+add_subdirectory(shape_inference)
+add_subdirectory(version_converter)
diff --git a/onnx/__init__.py b/onnx/__init__.py
new file mode 100644
index 0000000..4c286c4
--- /dev/null
+++ b/onnx/__init__.py
@@ -0,0 +1,470 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+__all__ = [
+    # Constants
+    "ONNX_ML",
+    "IR_VERSION",
+    "IR_VERSION_2017_10_10",
+    "IR_VERSION_2017_10_30",
+    "IR_VERSION_2017_11_3",
+    "IR_VERSION_2019_1_22",
+    "IR_VERSION_2019_3_18",
+    "IR_VERSION_2019_9_19",
+    "IR_VERSION_2020_5_8",
+    "IR_VERSION_2021_7_30",
+    "IR_VERSION_2023_5_5",
+    "IR_VERSION_2024_3_25",
+    "EXPERIMENTAL",
+    "STABLE",
+    # Modules
+    "checker",
+    "compose",
+    "defs",
+    "gen_proto",
+    "helper",
+    "numpy_helper",
+    "parser",
+    "printer",
+    "shape_inference",
+    "utils",
+    "version_converter",
+    # Proto classes
+    "AttributeProto",
+    "DeviceConfigurationProto",
+    "FunctionProto",
+    "GraphProto",
+    "IntIntListEntryProto",
+    "MapProto",
+    "ModelProto",
+    "NodeDeviceConfigurationProto",
+    "NodeProto",
+    "OperatorProto",
+    "OperatorSetIdProto",
+    "OperatorSetProto",
+    "OperatorStatus",
+    "OptionalProto",
+    "SequenceProto",
+    "SimpleShardedDimProto",
+    "ShardedDimProto",
+    "ShardingSpecProto",
+    "SparseTensorProto",
+    "StringStringEntryProto",
+    "TensorAnnotation",
+    "TensorProto",
+    "TensorShapeProto",
+    "TrainingInfoProto",
+    "TypeProto",
+    "ValueInfoProto",
+    "Version",
+    # Utility functions
+    "convert_model_to_external_data",
+    "load_external_data_for_model",
+    "load_model_from_string",
+    "load_model",
+    "load_tensor_from_string",
+    "load_tensor",
+    "save_model",
+    "save_tensor",
+    "write_external_data_tensors",
+]
+# isort:skip_file
+
+import os
+import typing
+from typing import IO, Literal
+
+
+from onnx import serialization
+from onnx.onnx_cpp2py_export import ONNX_ML
+from onnx.external_data_helper import (
+    load_external_data_for_model,
+    write_external_data_tensors,
+    convert_model_to_external_data,
+)
+from onnx.onnx_pb import (
+    AttributeProto,
+    DeviceConfigurationProto,
+    EXPERIMENTAL,
+    FunctionProto,
+    GraphProto,
+    IntIntListEntryProto,
+    IR_VERSION,
+    IR_VERSION_2017_10_10,
+    IR_VERSION_2017_10_30,
+    IR_VERSION_2017_11_3,
+    IR_VERSION_2019_1_22,
+    IR_VERSION_2019_3_18,
+    IR_VERSION_2019_9_19,
+    IR_VERSION_2020_5_8,
+    IR_VERSION_2021_7_30,
+    IR_VERSION_2023_5_5,
+    IR_VERSION_2024_3_25,
+    ModelProto,
+    NodeDeviceConfigurationProto,
+    NodeProto,
+    OperatorSetIdProto,
+    OperatorStatus,
+    STABLE,
+    SimpleShardedDimProto,
+    ShardedDimProto,
+    ShardingSpecProto,
+    SparseTensorProto,
+    StringStringEntryProto,
+    TensorAnnotation,
+    TensorProto,
+    TensorShapeProto,
+    TrainingInfoProto,
+    TypeProto,
+    ValueInfoProto,
+    Version,
+)
+from onnx.onnx_operators_pb import OperatorProto, OperatorSetProto
+from onnx.onnx_data_pb import MapProto, OptionalProto, SequenceProto
+import importlib.metadata
+
+# Import common subpackages so they're available when you 'import onnx'
+from onnx import (
+    checker,
+    compose,
+    defs,
+    gen_proto,
+    helper,
+    numpy_helper,
+    parser,
+    printer,
+    shape_inference,
+    utils,
+    version_converter,
+)
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Sequence
+
+try:
+    __version__ = importlib.metadata.version("onnx")
+except importlib.metadata.PackageNotFoundError:
+    try:
+        __version__ = importlib.metadata.version("onnx-weekly")
+    except importlib.metadata.PackageNotFoundError:
+        __version__ = "unknown"
+
+# Supported model formats that can be loaded from and saved to
+# The literals are formats with built-in support. But we also allow users to
+# register their own formats. So we allow str as well.
+_SupportedFormat = Literal["protobuf", "textproto", "onnxtxt", "json"] | str  # noqa: PYI051
+# Default serialization format
+_DEFAULT_FORMAT = "protobuf"
+
+
+def _load_bytes(f: IO[bytes] | str | os.PathLike) -> bytes:
+    if hasattr(f, "read") and callable(typing.cast("IO[bytes]", f).read):
+        content = typing.cast("IO[bytes]", f).read()
+    else:
+        f = typing.cast("str | os.PathLike", f)
+        with open(f, "rb") as readable:
+            content = readable.read()
+    return content
+
+
+def _save_bytes(content: bytes, f: IO[bytes] | str | os.PathLike) -> None:
+    if hasattr(f, "write") and callable(typing.cast("IO[bytes]", f).write):
+        typing.cast("IO[bytes]", f).write(content)
+    else:
+        f = typing.cast("str | os.PathLike", f)
+        with open(f, "wb") as writable:
+            writable.write(content)
+
+
+def _get_file_path(f: IO[bytes] | str | os.PathLike | None) -> str | None:
+    if isinstance(f, (str, os.PathLike)):
+        return os.path.abspath(f)
+    if hasattr(f, "name"):
+        assert f is not None
+        return os.path.abspath(f.name)
+    return None
+
+
+def _get_serializer(
+    fmt: _SupportedFormat | None, f: str | os.PathLike | IO[bytes] | None = None
+) -> serialization.ProtoSerializer:
+    """Get the serializer for the given path and format from the serialization registry."""
+    # Use fmt if it is specified
+    if fmt is not None:
+        return serialization.registry.get(fmt)
+
+    if (file_path := _get_file_path(f)) is not None:
+        _, ext = os.path.splitext(file_path)
+        fmt = serialization.registry.get_format_from_file_extension(ext)
+
+    # Failed to resolve format if fmt is None. Use protobuf as default
+    fmt = fmt or _DEFAULT_FORMAT
+    assert fmt is not None
+
+    return serialization.registry.get(fmt)
+
+
+def load_model(
+    f: IO[bytes] | str | os.PathLike,
+    format: _SupportedFormat | None = None,  # noqa: A002
+    load_external_data: bool = True,
+) -> ModelProto:
+    """Loads a serialized ModelProto into memory.
+
+    Args:
+        f: can be a file-like object (has "read" function) or a string/PathLike containing a file name
+        format: The serialization format. When it is not specified, it is inferred
+            from the file extension when ``f`` is a path. If not specified _and_
+            ``f`` is not a path, 'protobuf' is used. The encoding is assumed to
+            be "utf-8" when the format is a text format.
+        load_external_data: Whether to load the external data.
+            Set to True if the data is under the same directory of the model.
+            If not, users need to call :func:`load_external_data_for_model`
+            with directory to load external data from.
+
+    Returns:
+        Loaded in-memory ModelProto.
+    """
+    model = _get_serializer(format, f).deserialize_proto(_load_bytes(f), ModelProto())
+
+    if load_external_data:
+        model_filepath = _get_file_path(f)
+        if model_filepath:
+            base_dir = os.path.dirname(model_filepath)
+            load_external_data_for_model(model, base_dir)
+
+    return model
+
+
+def load_tensor(
+    f: IO[bytes] | str | os.PathLike,
+    format: _SupportedFormat | None = None,  # noqa: A002
+) -> TensorProto:
+    """Loads a serialized TensorProto into memory.
+
+    Args:
+        f: can be a file-like object (has "read" function) or a string/PathLike containing a file name
+        format: The serialization format. When it is not specified, it is inferred
+            from the file extension when ``f`` is a path. If not specified _and_
+            ``f`` is not a path, 'protobuf' is used. The encoding is assumed to
+            be "utf-8" when the format is a text format.
+
+    Returns:
+        Loaded in-memory TensorProto.
+    """
+    return _get_serializer(format, f).deserialize_proto(_load_bytes(f), TensorProto())
+
+
+def load_model_from_string(
+    s: bytes | str,
+    format: _SupportedFormat = _DEFAULT_FORMAT,  # noqa: A002
+) -> ModelProto:
+    """Loads a binary string (bytes) that contains serialized ModelProto.
+
+    Args:
+        s: a string, which contains serialized ModelProto
+        format: The serialization format. When it is not specified, it is inferred
+            from the file extension when ``f`` is a path. If not specified _and_
+            ``f`` is not a path, 'protobuf' is used. The encoding is assumed to
+            be "utf-8" when the format is a text format.
+
+    Returns:
+        Loaded in-memory ModelProto.
+    """
+    return _get_serializer(format).deserialize_proto(s, ModelProto())
+
+
+def load_tensor_from_string(
+    s: bytes,
+    format: _SupportedFormat = _DEFAULT_FORMAT,  # noqa: A002
+) -> TensorProto:
+    """Loads a binary string (bytes) that contains serialized TensorProto.
+
+    Args:
+        s: a string, which contains serialized TensorProto
+        format: The serialization format. When it is not specified, it is inferred
+            from the file extension when ``f`` is a path. If not specified _and_
+            ``f`` is not a path, 'protobuf' is used. The encoding is assumed to
+            be "utf-8" when the format is a text format.
+
+    Returns:
+        Loaded in-memory TensorProto.
+    """
+    return _get_serializer(format).deserialize_proto(s, TensorProto())
+
+
+def save_model(
+    proto: ModelProto | bytes,
+    f: IO[bytes] | str | os.PathLike,
+    format: _SupportedFormat | None = None,  # noqa: A002
+    *,
+    save_as_external_data: bool = False,
+    all_tensors_to_one_file: bool = True,
+    location: str | None = None,
+    size_threshold: int = 1024,
+    convert_attribute: bool = False,
+) -> None:
+    """Saves the ModelProto to the specified path and optionally, serialize tensors with raw data as external data before saving.
+
+    Args:
+        proto: should be a in-memory ModelProto
+        f: can be a file-like object (has "write" function) or a string containing
+        a file name or a pathlike object
+        format: The serialization format. When it is not specified, it is inferred
+            from the file extension when ``f`` is a path. If not specified _and_
+            ``f`` is not a path, 'protobuf' is used. The encoding is assumed to
+            be "utf-8" when the format is a text format.
+        save_as_external_data: If true, save tensors to external file(s).
+        all_tensors_to_one_file: Effective only if save_as_external_data is True.
+            If true, save all tensors to one external file specified by location.
+            If false, save each tensor to a file named with the tensor name.
+        location: Effective only if save_as_external_data is true.
+            Specify the external file that all tensors to save to.
+            Path is relative to the model path.
+            If not specified, will use the model name.
+        size_threshold: Effective only if save_as_external_data is True.
+            Threshold for size of data. Only when tensor's data is >= the size_threshold it will be converted
+            to external data. To convert every tensor with raw data to external data set size_threshold=0.
+        convert_attribute: Effective only if save_as_external_data is True.
+            If true, convert all tensors to external data
+            If false, convert only non-attribute tensors to external data
+    """
+    if isinstance(proto, bytes):
+        proto = _get_serializer(_DEFAULT_FORMAT).deserialize_proto(proto, ModelProto())
+
+    if save_as_external_data:
+        convert_model_to_external_data(
+            proto, all_tensors_to_one_file, location, size_threshold, convert_attribute
+        )
+
+    model_filepath = _get_file_path(f)
+    if model_filepath is not None:
+        basepath = os.path.dirname(model_filepath)
+        proto = write_external_data_tensors(proto, basepath)
+
+    serialized = _get_serializer(format, model_filepath).serialize_proto(proto)
+    _save_bytes(serialized, f)
+
+
+def save_tensor(
+    proto: TensorProto,
+    f: IO[bytes] | str | os.PathLike,
+    format: _SupportedFormat | None = None,  # noqa: A002
+) -> None:
+    """Saves the TensorProto to the specified path.
+
+    Args:
+        proto: should be a in-memory TensorProto
+        f: can be a file-like object (has "write" function) or a string
+        containing a file name or a pathlike object.
+        format: The serialization format. When it is not specified, it is inferred
+            from the file extension when ``f`` is a path. If not specified _and_
+            ``f`` is not a path, 'protobuf' is used. The encoding is assumed to
+            be "utf-8" when the format is a text format.
+    """
+    serialized = _get_serializer(format, f).serialize_proto(proto)
+    _save_bytes(serialized, f)
+
+
+# For backward compatibility
+load = load_model
+load_from_string = load_model_from_string
+save = save_model
+
+
+def _model_proto_repr(self: ModelProto) -> str:
+    if self.domain:
+        domain = f", domain='{self.domain}'"
+    else:
+        domain = ""
+    if self.producer_name:
+        producer_name = f", producer_name='{self.producer_name}'"
+    else:
+        producer_name = ""
+    if self.producer_version:
+        producer_version = f", producer_version='{self.producer_version}'"
+    else:
+        producer_version = ""
+    if self.graph:
+        graph = f", graph={self.graph!r}"
+    else:
+        graph = ""
+    if self.functions:
+        functions = f", functions=<{len(self.functions)} functions>"
+    else:
+        functions = ""
+    if self.opset_import:
+        opset_import = f", opset_import={_operator_set_protos_repr(self.opset_import)}"
+    else:
+        opset_import = ""
+    return f"ModelProto(ir_version={self.ir_version}{opset_import}{domain}{producer_name}{producer_version}{graph}{functions})"
+
+
+def _graph_proto_repr(self: GraphProto) -> str:
+    if self.initializer:
+        initializer = f", initializer=<{len(self.initializer)} initializers>"
+    else:
+        initializer = ""
+    if self.node:
+        node = f", node=<{len(self.node)} nodes>"
+    else:
+        node = ""
+    if self.value_info:
+        value_info = f", value_info=<{len(self.value_info)} value_info>"
+    else:
+        value_info = ""
+    if self.input:
+        input = f", input=<{len(self.input)} inputs>"
+    else:
+        input = ""
+    if self.output:
+        output = f", output=<{len(self.output)} outputs>"
+    else:
+        output = ""
+    return f"GraphProto('{self.name}'{input}{output}{initializer}{node}{value_info})"
+
+
+def _function_proto_repr(self: FunctionProto) -> str:
+    if self.domain:
+        domain = f", domain='{self.domain}'"
+    else:
+        domain = ""
+    if self.overload:
+        overload = f", overload='{self.overload}'"
+    else:
+        overload = ""
+    if self.node:
+        node = f", node=<{len(self.node)} nodes>"
+    else:
+        node = ""
+    if self.attribute:
+        attribute = f", attribute={self.attribute}"
+    else:
+        attribute = ""
+    if self.opset_import:
+        opset_import = f", opset_import={_operator_set_protos_repr(self.opset_import)}"
+    else:
+        opset_import = ""
+    if self.input:
+        input = f", input=<{len(self.input)} inputs>"
+    else:
+        input = ""
+    if self.output:
+        output = f", output=<{len(self.output)} outputs>"
+    else:
+        output = ""
+    return f"FunctionProto('{self.name}'{domain}{overload}{opset_import}{input}{output}{attribute}{node})"
+
+
+def _operator_set_protos_repr(protos: Sequence[OperatorSetIdProto]) -> str:
+    opset_imports = {proto.domain: proto.version for proto in protos}
+    return repr(opset_imports)
+
+
+# Override __repr__ for some proto classes to make it more efficient
+ModelProto.__repr__ = _model_proto_repr  # type: ignore[method-assign,assignment]
+GraphProto.__repr__ = _graph_proto_repr  # type: ignore[method-assign,assignment]
+FunctionProto.__repr__ = _function_proto_repr  # type: ignore[method-assign,assignment]
diff --git a/onnx/_mapping.py b/onnx/_mapping.py
new file mode 100644
index 0000000..ff4a602
--- /dev/null
+++ b/onnx/_mapping.py
@@ -0,0 +1,119 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import ml_dtypes
+import numpy as np
+
+from onnx.onnx_pb import TensorProto
+
+
+class TensorDtypeMap(NamedTuple):
+    np_dtype: np.dtype
+    storage_dtype: int
+    name: str
+
+
+# tensor_dtype: (numpy type, storage type, string name)
+# The storage type is the type used to store the tensor in the *_data field of
+# a TensorProto. All available fields are float_data, int32_data, int64_data,
+# string_data, uint64_data and double_data.
+TENSOR_TYPE_MAP: dict[int, TensorDtypeMap] = {
+    int(TensorProto.FLOAT): TensorDtypeMap(
+        np.dtype("float32"), int(TensorProto.FLOAT), "TensorProto.FLOAT"
+    ),
+    int(TensorProto.UINT8): TensorDtypeMap(
+        np.dtype("uint8"), int(TensorProto.INT32), "TensorProto.UINT8"
+    ),
+    int(TensorProto.INT8): TensorDtypeMap(
+        np.dtype("int8"), int(TensorProto.INT32), "TensorProto.INT8"
+    ),
+    int(TensorProto.UINT16): TensorDtypeMap(
+        np.dtype("uint16"), int(TensorProto.INT32), "TensorProto.UINT16"
+    ),
+    int(TensorProto.INT16): TensorDtypeMap(
+        np.dtype("int16"), int(TensorProto.INT32), "TensorProto.INT16"
+    ),
+    int(TensorProto.INT32): TensorDtypeMap(
+        np.dtype("int32"), int(TensorProto.INT32), "TensorProto.INT32"
+    ),
+    int(TensorProto.INT64): TensorDtypeMap(
+        np.dtype("int64"), int(TensorProto.INT64), "TensorProto.INT64"
+    ),
+    int(TensorProto.BOOL): TensorDtypeMap(
+        np.dtype("bool"), int(TensorProto.INT32), "TensorProto.BOOL"
+    ),
+    int(TensorProto.FLOAT16): TensorDtypeMap(
+        np.dtype("float16"), int(TensorProto.INT32), "TensorProto.FLOAT16"
+    ),
+    int(TensorProto.BFLOAT16): TensorDtypeMap(
+        np.dtype(ml_dtypes.bfloat16),
+        int(TensorProto.INT32),
+        "TensorProto.BFLOAT16",
+    ),
+    int(TensorProto.DOUBLE): TensorDtypeMap(
+        np.dtype("float64"), int(TensorProto.DOUBLE), "TensorProto.DOUBLE"
+    ),
+    int(TensorProto.COMPLEX64): TensorDtypeMap(
+        np.dtype("complex64"), int(TensorProto.FLOAT), "TensorProto.COMPLEX64"
+    ),
+    int(TensorProto.COMPLEX128): TensorDtypeMap(
+        np.dtype("complex128"),
+        int(TensorProto.DOUBLE),
+        "TensorProto.COMPLEX128",
+    ),
+    int(TensorProto.UINT32): TensorDtypeMap(
+        np.dtype("uint32"), int(TensorProto.UINT64), "TensorProto.UINT32"
+    ),
+    int(TensorProto.UINT64): TensorDtypeMap(
+        np.dtype("uint64"), int(TensorProto.UINT64), "TensorProto.UINT64"
+    ),
+    int(TensorProto.STRING): TensorDtypeMap(
+        np.dtype("object"), int(TensorProto.STRING), "TensorProto.STRING"
+    ),
+    int(TensorProto.FLOAT8E4M3FN): TensorDtypeMap(
+        np.dtype(ml_dtypes.float8_e4m3fn),
+        int(TensorProto.INT32),
+        "TensorProto.FLOAT8E4M3FN",
+    ),
+    int(TensorProto.FLOAT8E4M3FNUZ): TensorDtypeMap(
+        np.dtype(ml_dtypes.float8_e4m3fnuz),
+        int(TensorProto.INT32),
+        "TensorProto.FLOAT8E4M3FNUZ",
+    ),
+    int(TensorProto.FLOAT8E5M2): TensorDtypeMap(
+        np.dtype(ml_dtypes.float8_e5m2),
+        int(TensorProto.INT32),
+        "TensorProto.FLOAT8E5M2",
+    ),
+    int(TensorProto.FLOAT8E5M2FNUZ): TensorDtypeMap(
+        np.dtype(ml_dtypes.float8_e5m2fnuz),
+        int(TensorProto.INT32),
+        "TensorProto.FLOAT8E5M2FNUZ",
+    ),
+    int(TensorProto.UINT4): TensorDtypeMap(
+        np.dtype(ml_dtypes.uint4), int(TensorProto.INT32), "TensorProto.UINT4"
+    ),
+    int(TensorProto.INT4): TensorDtypeMap(
+        np.dtype(ml_dtypes.int4), int(TensorProto.INT32), "TensorProto.INT4"
+    ),
+    int(TensorProto.FLOAT4E2M1): TensorDtypeMap(
+        np.dtype(ml_dtypes.float4_e2m1fn),
+        int(TensorProto.INT32),
+        "TensorProto.FLOAT4E2M1",
+    ),
+    int(TensorProto.FLOAT8E8M0): TensorDtypeMap(
+        np.dtype(ml_dtypes.float8_e8m0fnu),
+        int(TensorProto.INT32),
+        "TensorProto.FLOAT8E8M0",
+    ),
+    int(TensorProto.UINT2): TensorDtypeMap(
+        np.dtype(ml_dtypes.uint2), int(TensorProto.INT32), "TensorProto.UINT2"
+    ),
+    int(TensorProto.INT2): TensorDtypeMap(
+        np.dtype(ml_dtypes.int2), int(TensorProto.INT32), "TensorProto.INT2"
+    ),
+}
diff --git a/onnx/backend/__init__.py b/onnx/backend/__init__.py
new file mode 100644
index 0000000..c974daf
--- /dev/null
+++ b/onnx/backend/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
diff --git a/onnx/backend/base.py b/onnx/backend/base.py
new file mode 100644
index 0000000..c4fd765
--- /dev/null
+++ b/onnx/backend/base.py
@@ -0,0 +1,148 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from collections import namedtuple
+from typing import TYPE_CHECKING, Any, NewType
+
+import onnx.checker
+import onnx.onnx_cpp2py_export.checker as c_checker
+from onnx import IR_VERSION, ModelProto, NodeProto
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import numpy
+
+
+class DeviceType:
+    """Describes device type."""
+
+    _Type = NewType("_Type", int)
+    CPU: _Type = _Type(0)
+    CUDA: _Type = _Type(1)
+
+
+class Device:
+    """Describes device type and device id
+    syntax: device_type:device_id(optional)
+    example: 'CPU', 'CUDA', 'CUDA:1'
+    """
+
+    def __init__(self, device: str) -> None:
+        options = device.split(":")
+        self.type = getattr(DeviceType, options[0])
+        self.device_id = 0
+        if len(options) > 1:
+            self.device_id = int(options[1])
+
+
+def namedtupledict(
+    typename: str, field_names: Sequence[str], *args: Any, **kwargs: Any
+) -> type[tuple[Any, ...]]:
+    field_names_map = {n: i for i, n in enumerate(field_names)}
+    # Some output names are invalid python identifier, e.g. "0"
+    kwargs.setdefault("rename", True)
+    data = namedtuple(typename, field_names, *args, **kwargs)  # type: ignore[misc]  # noqa: PYI024
+
+    def getitem(self: Any, key: Any) -> Any:
+        if isinstance(key, str):
+            key = field_names_map[key]
+        return super(type(self), self).__getitem__(key)
+
+    data.__getitem__ = getitem  # type: ignore[method-assign]
+    return data
+
+
+class BackendRep:
+    """BackendRep is the handle that a Backend returns after preparing to execute
+    a model repeatedly. Users will then pass inputs to the run function of
+    BackendRep to retrieve the corresponding results.
+    """
+
+    def run(self, inputs: Any, **kwargs: Any) -> tuple[Any, ...]:  # noqa: ARG002
+        """Abstract function."""
+        return (None,)
+
+
+class Backend:
+    """Backend is the entity that will take an ONNX model with inputs,
+    perform a computation, and then return the output.
+
+    For one-off execution, users can use run_node and run_model to obtain results quickly.
+
+    For repeated execution, users should use prepare, in which the Backend
+    does all of the preparation work for executing the model repeatedly
+    (e.g., loading initializers), and returns a BackendRep handle.
+    """
+
+    @classmethod
+    def is_compatible(
+        cls,
+        model: ModelProto,  # noqa: ARG003
+        device: str = "CPU",  # noqa: ARG003
+        **kwargs: Any,  # noqa: ARG003
+    ) -> bool:
+        # Return whether the model is compatible with the backend.
+        return True
+
+    @classmethod
+    def prepare(
+        cls,
+        model: ModelProto,
+        device: str = "CPU",  # noqa: ARG003
+        **kwargs: Any,  # noqa: ARG003
+    ) -> BackendRep | None:
+        # TODO Remove Optional from return type
+        onnx.checker.check_model(model)
+        return None
+
+    @classmethod
+    def run_model(
+        cls, model: ModelProto, inputs: Any, device: str = "CPU", **kwargs: Any
+    ) -> tuple[Any, ...]:
+        backend = cls.prepare(model, device, **kwargs)
+        assert backend is not None
+        return backend.run(inputs)
+
+    @classmethod
+    def run_node(
+        cls,
+        node: NodeProto,
+        inputs: Any,  # noqa: ARG003
+        device: str = "CPU",  # noqa: ARG003
+        outputs_info: (  # noqa: ARG003
+            Sequence[tuple[numpy.dtype, tuple[int, ...]]] | None
+        ) = None,
+        **kwargs: dict[str, Any],
+    ) -> tuple[Any, ...] | None:
+        """Simple run one operator and return the results.
+
+        Args:
+            node: The node proto.
+            inputs: Inputs to the node.
+            device: The device to run on.
+            outputs_info: a list of tuples, which contains the element type and
+                shape of each output. First element of the tuple is the dtype, and
+                the second element is the shape. More use case can be found in
+                https://github.com/onnx/onnx/blob/main/onnx/backend/test/runner/__init__.py
+            kwargs: Other keyword arguments.
+        """
+        # TODO Remove Optional from return type
+        if "opset_version" in kwargs:
+            special_context = c_checker.CheckerContext()
+            special_context.ir_version = IR_VERSION
+            special_context.opset_imports = {"": kwargs["opset_version"]}  # type: ignore[dict-item]
+            onnx.checker.check_node(node, special_context)
+        else:
+            onnx.checker.check_node(node)
+
+        return None
+
+    @classmethod
+    def supports_device(cls, device: str) -> bool:  # noqa: ARG003
+        """Checks whether the backend is compiled with particular device support.
+        In particular it's used in the testing suite.
+        """
+        return True
diff --git a/onnx/backend/sample/__init__.py b/onnx/backend/sample/__init__.py
new file mode 100644
index 0000000..e790f24
--- /dev/null
+++ b/onnx/backend/sample/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
diff --git a/onnx/backend/sample/ops/__init__.py b/onnx/backend/sample/ops/__init__.py
new file mode 100644
index 0000000..dbdaf61
--- /dev/null
+++ b/onnx/backend/sample/ops/__init__.py
@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import importlib
+import inspect
+import pkgutil
+import sys
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+
+def collect_sample_implementations() -> dict[str, str]:
+    dict_: dict[str, str] = {}
+    _recursive_scan(sys.modules[__name__], dict_)
+    return dict_
+
+
+def _recursive_scan(package: ModuleType, dict_: dict[str, str]) -> None:
+    pkg_dir = package.__path__
+    module_location = package.__name__
+    for _module_loader, name, ispkg in pkgutil.iter_modules(pkg_dir):
+        module_name = f"{module_location}.{name}"  # Module/package
+        module = importlib.import_module(module_name)
+        dict_[name] = inspect.getsource(module)
+        if ispkg:
+            _recursive_scan(module, dict_)
diff --git a/onnx/backend/sample/ops/abs.py b/onnx/backend/sample/ops/abs.py
new file mode 100644
index 0000000..d76cc5e
--- /dev/null
+++ b/onnx/backend/sample/ops/abs.py
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+
+def abs(input: np.ndarray) -> np.ndarray:  # noqa: A001
+    return np.abs(input)  # type: ignore[no-any-return]
diff --git a/onnx/backend/test/__init__.py b/onnx/backend/test/__init__.py
new file mode 100644
index 0000000..f38efa7
--- /dev/null
+++ b/onnx/backend/test/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = ["BackendTest"]
+# for backward compatibility
+from onnx.backend.test.runner import Runner as BackendTest
diff --git a/onnx/backend/test/case/__init__.py b/onnx/backend/test/case/__init__.py
new file mode 100644
index 0000000..f78d288
--- /dev/null
+++ b/onnx/backend/test/case/__init__.py
@@ -0,0 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import sys
+
+from onnx.backend.test.case.base import Snippets
+from onnx.backend.test.case.utils import import_recursive
+
+
+def collect_snippets() -> dict[str, list[tuple[str, str]]]:
+    import_recursive(sys.modules[__name__])
+    return Snippets
diff --git a/onnx/backend/test/case/base.py b/onnx/backend/test/case/base.py
new file mode 100644
index 0000000..b979fad
--- /dev/null
+++ b/onnx/backend/test/case/base.py
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import inspect
+from collections import defaultdict
+from textwrap import dedent
+from typing import Any, ClassVar
+
+import numpy as np
+
+
+def process_snippet(op_name: str, name: str, export: Any) -> tuple[str, str]:
+    snippet_name = name[len("export_") :] or op_name.lower()
+    source_code = dedent(inspect.getsource(export))
+    # remove the function signature line
+    lines = source_code.splitlines()
+    assert lines[0] == "@staticmethod"
+    assert lines[1].startswith("def export")
+    return snippet_name, dedent("\n".join(lines[2:]))
+
+
+Snippets: dict[str, list[tuple[str, str]]] = defaultdict(list)
+
+
+class _Exporter(type):
+    exports: ClassVar[dict[str, list[tuple[str, str]]]] = defaultdict(list)
+
+    def __init__(
+        cls, name: str, bases: tuple[type[Any], ...], dct: dict[str, Any]
+    ) -> None:
+        for k, v in dct.items():
+            if k.startswith("export"):
+                if not isinstance(v, staticmethod):
+                    raise ValueError("Only staticmethods could be named as export.*")
+                export = getattr(cls, k)
+                Snippets[name].append(process_snippet(name, k, export))
+                # export functions should call expect and so populate
+                # TestCases
+                np.random.seed(seed=0)
+                export()
+        super().__init__(name, bases, dct)
+
+
+class Base(metaclass=_Exporter):
+    pass
diff --git a/onnx/backend/test/case/model/__init__.py b/onnx/backend/test/case/model/__init__.py
new file mode 100644
index 0000000..75dfb8d
--- /dev/null
+++ b/onnx/backend/test/case/model/__init__.py
@@ -0,0 +1,81 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from onnx.backend.test.case.test_case import TestCase
+from onnx.backend.test.case.utils import import_recursive
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import numpy as np
+
+    from onnx import ModelProto
+
+_SimpleModelTestCases = []
+
+
+def expect(
+    model: ModelProto,
+    inputs: Sequence[np.ndarray],
+    outputs: Sequence[np.ndarray],
+    name: str | None = None,
+) -> None:
+    name = name or model.graph.name
+    _SimpleModelTestCases.append(
+        TestCase(
+            name=name,
+            model_name=model.graph.name,
+            url=None,
+            model_dir=None,
+            model=model,
+            data_sets=[(inputs, outputs)],
+            kind="simple",
+            rtol=1e-3,
+            atol=1e-7,
+        )
+    )
+
+
+BASE_URL = "onnx/backend/test/data/light/light_%s.onnx"
+
+
+def collect_testcases() -> list[TestCase]:
+    """Collect model test cases defined in python/numpy code."""
+    real_model_testcases = []
+
+    model_tests = [
+        ("test_bvlc_alexnet", "bvlc_alexnet", 1e-3, 1e-7),
+        ("test_densenet121", "densenet121", 2e-3, 1e-7),
+        ("test_inception_v1", "inception_v1", 1e-3, 1e-7),
+        ("test_inception_v2", "inception_v2", 1e-3, 1e-7),
+        ("test_resnet50", "resnet50", 1e-3, 1e-7),
+        ("test_shufflenet", "shufflenet", 1e-3, 1e-7),
+        ("test_squeezenet", "squeezenet", 1e-3, 1e-7),
+        ("test_vgg19", "vgg19", 1e-3, 1e-7),
+        ("test_zfnet512", "zfnet512", 1e-3, 1e-7),
+    ]
+
+    for test_name, model_name, rtol, atol in model_tests:
+        url = BASE_URL % model_name
+        real_model_testcases.append(
+            TestCase(
+                name=test_name,
+                model_name=model_name,
+                url=url,
+                model_dir=None,
+                model=None,
+                data_sets=None,
+                kind="real",
+                rtol=rtol,
+                atol=atol,
+            )
+        )
+
+    import_recursive(sys.modules[__name__])
+
+    return real_model_testcases + _SimpleModelTestCases
diff --git a/onnx/backend/test/case/model/expand.py b/onnx/backend/test/case/model/expand.py
new file mode 100644
index 0000000..b99ed46
--- /dev/null
+++ b/onnx/backend/test/case/model/expand.py
@@ -0,0 +1,91 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+class ExpandDynamicShape(Base):
+    @staticmethod
+    def export() -> None:
+        def make_graph(
+            node: onnx.helper.NodeProto,
+            input_shape: Sequence[int],
+            shape_shape: Sequence[int],
+            output_shape: Sequence[int],
+        ) -> onnx.helper.GraphProto:
+            return onnx.helper.make_graph(
+                nodes=[node],
+                name="Expand",
+                inputs=[
+                    onnx.helper.make_tensor_value_info(
+                        "X", onnx.TensorProto.FLOAT, input_shape
+                    ),
+                    onnx.helper.make_tensor_value_info(
+                        "shape", onnx.TensorProto.INT64, shape_shape
+                    ),
+                ],
+                outputs=[
+                    onnx.helper.make_tensor_value_info(
+                        "Y", onnx.TensorProto.FLOAT, output_shape
+                    )
+                ],
+            )
+
+        node = onnx.helper.make_node("Expand", ["X", "shape"], ["Y"], name="test")
+        input_shape = [1, 3, 1]
+        x = np.ones(input_shape, dtype=np.float32)
+
+        # 1st testcase
+        shape = np.array([3, 1], dtype=np.int64)
+        y = x * np.ones(shape, dtype=np.float32)
+        graph = make_graph(node, input_shape, shape.shape, y.shape)
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 9)],
+        )
+        expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model1")
+
+        # 2nd testcase
+        shape = np.array([1, 3], dtype=np.int64)
+        y = x * np.ones(shape, dtype=np.float32)
+        graph = make_graph(node, input_shape, shape.shape, y.shape)
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 9)],
+        )
+        expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model2")
+
+        # 3rd testcase
+        shape = np.array([3, 1, 3], dtype=np.int64)
+        y = x * np.ones(shape, dtype=np.float32)
+        graph = make_graph(node, input_shape, shape.shape, y.shape)
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 9)],
+        )
+        expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model3")
+
+        # 4th testcase
+        shape = np.array([3, 3, 1, 3], dtype=np.int64)
+        y = x * np.ones(shape, dtype=np.float32)
+        graph = make_graph(node, input_shape, shape.shape, y.shape)
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 9)],
+        )
+        expect(model, inputs=[x, shape], outputs=[y], name="test_expand_shape_model4")
diff --git a/onnx/backend/test/case/model/gradient.py b/onnx/backend/test/case/model/gradient.py
new file mode 100644
index 0000000..947ee2c
--- /dev/null
+++ b/onnx/backend/test/case/model/gradient.py
@@ -0,0 +1,110 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
+from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN, ONNX_DOMAIN
+
+
+class Gradient(Base):
+    @staticmethod
+    def export_gradient_scalar_add() -> None:
+        add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add")
+        gradient_node = onnx.helper.make_node(
+            "Gradient",
+            ["a", "b"],
+            ["dc_da", "dc_db"],
+            name="my_gradient",
+            domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+            xs=["a", "b"],
+            y="c",
+        )
+
+        a = np.array(1.0).astype(np.float32)
+        b = np.array(2.0).astype(np.float32)
+        c = a + b
+        # dc / da = d(a+b) / da = 1
+        dc_da = np.array(1).astype(np.float32)
+        # db / db = d(a+b) / db = 1
+        dc_db = np.array(1).astype(np.float32)
+
+        graph = onnx.helper.make_graph(
+            nodes=[add_node, gradient_node],
+            name="GradientOfAdd",
+            inputs=[
+                onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []),
+                onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []),
+            ],
+            outputs=[
+                onnx.helper.make_tensor_value_info("c", onnx.TensorProto.FLOAT, []),
+                onnx.helper.make_tensor_value_info("dc_da", onnx.TensorProto.FLOAT, []),
+                onnx.helper.make_tensor_value_info("dc_db", onnx.TensorProto.FLOAT, []),
+            ],
+        )
+        opsets = [
+            onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12),
+            onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+        ]
+        model = onnx.helper.make_model_gen_version(
+            graph, producer_name="backend-test", opset_imports=opsets
+        )
+        expect(
+            model, inputs=[a, b], outputs=[c, dc_da, dc_db], name="test_gradient_of_add"
+        )
+
+    @staticmethod
+    def export_gradient_scalar_add_and_mul() -> None:
+        add_node = onnx.helper.make_node("Add", ["a", "b"], ["c"], name="my_add")
+        mul_node = onnx.helper.make_node("Mul", ["c", "a"], ["d"], name="my_mul")
+        gradient_node = onnx.helper.make_node(
+            "Gradient",
+            ["a", "b"],
+            ["dd_da", "dd_db"],
+            name="my_gradient",
+            domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+            xs=["a", "b"],
+            y="d",
+        )
+
+        a = np.array(1.0).astype(np.float32)
+        b = np.array(2.0).astype(np.float32)
+        c = a + b
+        # d = a * c = a * (a + b)
+        d = a * c
+        # dd / da = d(a*a+a*b) / da = 2 * a + b
+        dd_da = (2 * a + b).astype(np.float32)
+        # dd / db = d(a*a+a*b) / db = a
+        dd_db = a
+
+        graph = onnx.helper.make_graph(
+            nodes=[add_node, mul_node, gradient_node],
+            name="GradientOfTwoOperators",
+            inputs=[
+                onnx.helper.make_tensor_value_info("a", onnx.TensorProto.FLOAT, []),
+                onnx.helper.make_tensor_value_info("b", onnx.TensorProto.FLOAT, []),
+            ],
+            outputs=[
+                onnx.helper.make_tensor_value_info("d", onnx.TensorProto.FLOAT, []),
+                onnx.helper.make_tensor_value_info("dd_da", onnx.TensorProto.FLOAT, []),
+                onnx.helper.make_tensor_value_info("dd_db", onnx.TensorProto.FLOAT, []),
+            ],
+        )
+
+        opsets = [
+            onnx.helper.make_operatorsetid(ONNX_DOMAIN, 12),
+            onnx.helper.make_operatorsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+        ]
+        model = onnx.helper.make_model_gen_version(
+            graph, producer_name="backend-test", opset_imports=opsets
+        )
+        expect(
+            model,
+            inputs=[a, b],
+            outputs=[d, dd_da, dd_db],
+            name="test_gradient_of_add_and_mul",
+        )
diff --git a/onnx/backend/test/case/model/sequence.py b/onnx/backend/test/case/model/sequence.py
new file mode 100644
index 0000000..9ac4513
--- /dev/null
+++ b/onnx/backend/test/case/model/sequence.py
@@ -0,0 +1,456 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typing
+
+import numpy as np
+
+import onnx
+from onnx import TensorProto
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
+
+
+def SequenceEmptyImpl() -> list[np.ndarray | None]:
+    return []
+
+
+def SequenceConstructImpl(*tensors: np.ndarray) -> list[np.ndarray]:
+    return list(tensors)
+
+
+def SequenceInsertImpl(
+    sequence: list[np.ndarray], tensor: np.ndarray, position: int | None = None
+) -> list[np.ndarray]:
+    if position is None:
+        position = len(sequence)
+    sequence.insert(position, tensor)
+    return sequence
+
+
+def SequenceAtImpl(sequence: list[np.ndarray], position: int) -> np.ndarray:
+    return sequence[position]
+
+
+def SequenceEraseImpl(
+    sequence: list[np.ndarray], position: int | None = None
+) -> list[np.ndarray | None]:
+    if position is None:
+        position = -1
+    del sequence[position]
+    return sequence
+
+
+def SequenceLengthImpl(sequence: list[np.ndarray]) -> np.int64:
+    return np.int64(len(sequence))
+
+
+def SplitToSequenceImpl(
+    tensor: np.ndarray,
+    split: int | list[int] | None = None,
+    axis: int = 0,
+    keepdims: int = 1,
+) -> list[np.ndarray]:
+    dim_size = tensor.shape[axis]
+    if split is None:
+        split = 1
+        split_indices = [
+            i * split + 1 for i in range(dim_size) if i * split + 1 < dim_size
+        ]
+        if not keepdims:
+            results = np.array_split(tensor, split_indices, axis)
+            return [np.squeeze(res, axis) for res in results]
+    if np.isscalar(split):
+        split_indices = [
+            i * split + 1 for i in range(dim_size) if i * split + 1 < dim_size
+        ]
+    else:
+        split_indices = np.cumsum(split) + 1
+    return np.array_split(tensor, split_indices, axis)
+
+
+def ConcatFromSequenceImpl(
+    sequence: list[np.ndarray], axis: int, new_axis: int | None = 0
+) -> np.ndarray:
+    if not new_axis:
+        return np.concatenate(sequence, axis)
+    return np.stack(sequence, axis)
+
+
+class Sequence(Base):
+    @staticmethod
+    def export() -> None:
+        def make_graph(
+            nodes: list[onnx.helper.NodeProto],
+            input_shapes: list[typing.Sequence[str | int] | None],
+            output_shapes: list[typing.Sequence[str | int] | None],
+            input_names: list[str],
+            output_names: list[str],
+            input_types: list[TensorProto.DataType],
+            output_types: list[TensorProto.DataType],
+            initializers: list[TensorProto] | None = None,
+        ) -> onnx.helper.GraphProto:
+            return onnx.helper.make_graph(
+                nodes=nodes,
+                name="Sequence",
+                inputs=[
+                    onnx.helper.make_tensor_value_info(name, input_type, input_shape)
+                    for name, input_type, input_shape in zip(
+                        input_names, input_types, input_shapes, strict=False
+                    )
+                ],
+                outputs=[
+                    onnx.helper.make_tensor_value_info(name, output_type, output_shape)
+                    for name, output_type, output_shape in zip(
+                        output_names, output_types, output_shapes, strict=False
+                    )
+                ],
+                initializer=initializers,
+            )
+
+        # 1st testcase - insert and at.
+        # 1. SequenceEmpty:         -> []
+        # 2. SequenceInsert(x):     -> [x]
+        # 3. SequenceInsert(y):     -> [x, y]
+        # 4. SequenceInsert(z, 1):  -> [x, z, y]
+        # 5. SequenceAt(2):         -> y
+        seq_empty_node = onnx.helper.make_node("SequenceEmpty", [], ["Seq_empty"])
+        seq_insert_node = onnx.helper.make_node(
+            "SequenceInsert", ["Seq_empty", "X"], ["Seq_1"]
+        )
+        seq_insert_node2 = onnx.helper.make_node(
+            "SequenceInsert", ["Seq_1", "Y"], ["Seq_2"]
+        )
+        seq_insert_node3 = onnx.helper.make_node(
+            "SequenceInsert", ["Seq_2", "Z", "pos"], ["Seq_3"]
+        )
+        seq_at_node = onnx.helper.make_node("SequenceAt", ["Seq_3", "pos_at"], ["out"])
+
+        x_shape = [2, 3, 4]
+        y_shape = [1, 3, 4]
+        z_shape = [3, 3, 4]
+        out_shape = [None, 3, 4]
+
+        x = np.ones(x_shape, dtype=np.float32)
+        y = np.zeros(y_shape, dtype=np.float32)
+        z = np.ones(z_shape, dtype=np.float32) * 2
+        pos_val = 1
+        pos_at_val = 2
+
+        out = SequenceEmptyImpl()
+        out = SequenceInsertImpl(out, x)
+        out = SequenceInsertImpl(out, y)
+        out = SequenceInsertImpl(out, z, pos_val)
+        out = SequenceAtImpl(out, pos_at_val)
+        assert np.array_equal(out, y)
+
+        pos = onnx.helper.make_tensor("pos", TensorProto.INT64, (), (pos_val,))
+        pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,))
+
+        graph = make_graph(
+            [
+                seq_empty_node,
+                seq_insert_node,
+                seq_insert_node2,
+                seq_insert_node3,
+                seq_at_node,
+            ],
+            [x_shape, y_shape, z_shape, [], []],
+            [out_shape],
+            ["X", "Y", "Z", "pos", "pos_at"],
+            ["out"],
+            [onnx.TensorProto.FLOAT] * 3 + [onnx.TensorProto.INT64] * 2,
+            [onnx.TensorProto.FLOAT],
+            [pos, pos_at],
+        )
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 12)],
+        )
+        expect(model, inputs=[x, y, z], outputs=[out], name="test_sequence_model1")
+
+        # 2nd testcase - erase and at.
+        # 1. SequenceConstruct(x, y, z):    -> [x, y, z]
+        # 2. SequenceErase(1):              -> [x, z]
+        # 3. SequenceAt(1):                 -> z
+        seq_construct_node = onnx.helper.make_node(
+            "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"]
+        )
+        seq_erase_node = onnx.helper.make_node(
+            "SequenceErase", ["seq_1", "pos_erase"], ["seq_2"]
+        )
+        seq_at_node = onnx.helper.make_node("SequenceAt", ["seq_2", "pos_at"], ["out"])
+
+        tensor_shape = [2, 3, 4]
+
+        x = np.ones(tensor_shape, dtype=np.float32)
+        y = np.zeros(tensor_shape, dtype=np.float32)
+        z = np.ones(tensor_shape, dtype=np.float32) * 2
+        pos_erase_val = 1
+        pos_at_val = 1
+
+        out = SequenceConstructImpl(x, y, z)
+        out = SequenceEraseImpl(out, pos_erase_val)
+        out = SequenceAtImpl(out, pos_at_val)
+        assert np.array_equal(out, z)
+
+        pos_erase = onnx.helper.make_tensor(
+            "pos_erase", TensorProto.INT64, (), (pos_erase_val,)
+        )
+        pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,))
+
+        graph = make_graph(
+            [seq_construct_node, seq_erase_node, seq_at_node],
+            [tensor_shape, tensor_shape, tensor_shape, [], []],
+            [tensor_shape],
+            ["X", "Y", "Z", "pos_erase", "pos_at"],
+            ["out"],
+            [onnx.TensorProto.FLOAT] * 3 + [onnx.TensorProto.INT64] * 2,
+            [onnx.TensorProto.FLOAT],
+            [pos_erase, pos_at],
+        )
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 12)],
+        )
+        expect(model, inputs=[x, y, z], outputs=[out], name="test_sequence_model2")
+
+        # 3rd testcase - erase, insert and at, with negative index value.
+        # 1. SequenceConstruct(x, y, z):    -> [x, y, z]
+        # 2. SequenceErase(-3):             -> [y, z]
+        # 3. SequenceInsert(x, -1):         -> [y, x, z]
+        # 4. SequenceAt(-1):                -> z
+        seq_construct_node = onnx.helper.make_node(
+            "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"]
+        )
+        seq_erase_node = onnx.helper.make_node(
+            "SequenceErase", ["seq_1", "pos_erase"], ["seq_2"]
+        )
+        seq_insert_node = onnx.helper.make_node(
+            "SequenceInsert", ["seq_2", "X", "pos_insert"], ["seq_3"]
+        )
+        seq_at_node = onnx.helper.make_node("SequenceAt", ["seq_3", "pos_at"], ["out"])
+
+        tensor_shape = [2, 3, 4]
+
+        x = np.ones(tensor_shape, dtype=np.float32)
+        y = np.zeros(tensor_shape, dtype=np.float32)
+        z = np.ones(tensor_shape, dtype=np.float32) * 2
+        pos_erase_val = -3
+        pos_insert_val = -1
+        pos_at_val = -1
+        out = SequenceConstructImpl(x, y, z)
+        out = SequenceEraseImpl(out, pos_erase_val)
+        out = SequenceInsertImpl(out, x, pos_insert_val)
+        out = SequenceAtImpl(out, pos_at_val)
+        assert np.array_equal(out, z)
+
+        pos_erase = onnx.helper.make_tensor(
+            "pos_erase", TensorProto.INT64, (), (pos_erase_val,)
+        )
+        pos_insert = onnx.helper.make_tensor(
+            "pos_insert", TensorProto.INT64, (), (pos_insert_val,)
+        )
+        pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,))
+
+        graph = make_graph(
+            [seq_construct_node, seq_erase_node, seq_insert_node, seq_at_node],
+            [tensor_shape, tensor_shape, tensor_shape, [], [], []],
+            [tensor_shape],
+            ["X", "Y", "Z", "pos_erase", "pos_insert", "pos_at"],
+            ["out"],
+            [onnx.TensorProto.FLOAT] * 3 + [onnx.TensorProto.INT64] * 3,
+            [onnx.TensorProto.FLOAT],
+            [pos_erase, pos_insert, pos_at],
+        )
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 12)],
+        )
+        expect(model, inputs=[x, y, z], outputs=[out], name="test_sequence_model3")
+
+        # 4th testcase - concat
+        seq_construct_node = onnx.helper.make_node(
+            "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"]
+        )
+        seq_concat_node = onnx.helper.make_node(
+            "ConcatFromSequence", ["seq_1"], ["out"], axis=1
+        )
+
+        tensor_shape = [2, 3, 4]
+        concat_out_shape = [2, None, 4]
+
+        x = np.ones(tensor_shape, dtype=np.float32)
+        y = np.zeros(tensor_shape, dtype=np.float32)
+        z = np.ones(tensor_shape, dtype=np.float32) * 2
+        out = SequenceConstructImpl(x, y, z)
+        concat_out = ConcatFromSequenceImpl(out, 1)
+
+        graph = make_graph(
+            [seq_construct_node, seq_concat_node],
+            [tensor_shape] * 3,
+            [concat_out_shape],
+            ["X", "Y", "Z"],
+            ["out"],
+            [onnx.TensorProto.FLOAT] * 3,
+            [onnx.TensorProto.FLOAT],
+        )
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 12)],
+        )
+        expect(
+            model, inputs=[x, y, z], outputs=[concat_out], name="test_sequence_model4"
+        )
+
+        # 5th testcase - concat with new_axis = 1
+        seq_construct_node = onnx.helper.make_node(
+            "SequenceConstruct", ["X", "Y", "Z"], ["seq_1"]
+        )
+        seq_concat_node = onnx.helper.make_node(
+            "ConcatFromSequence", ["seq_1"], ["out"], axis=-1, new_axis=1
+        )
+
+        tensor_shape = [2, 3, 4]
+        concat_out_shape = [2, 3, 4, 3]
+
+        x = np.ones(tensor_shape, dtype=np.float32)
+        y = np.zeros(tensor_shape, dtype=np.float32)
+        z = np.ones(tensor_shape, dtype=np.float32) * 2
+        out = SequenceConstructImpl(x, y, z)
+        concat_out = ConcatFromSequenceImpl(out, -1, 1)
+
+        graph = make_graph(
+            [seq_construct_node, seq_concat_node],
+            [tensor_shape] * 3,
+            [concat_out_shape],
+            ["X", "Y", "Z"],
+            ["out"],
+            [onnx.TensorProto.FLOAT] * 3,
+            [onnx.TensorProto.FLOAT],
+        )
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 12)],
+        )
+        expect(
+            model, inputs=[x, y, z], outputs=[concat_out], name="test_sequence_model5"
+        )
+
+        # 6th testcase - split and len
+        seq_split_node = onnx.helper.make_node(
+            "SplitToSequence", ["X"], ["seq_1"], axis=-1
+        )
+        seq_len_node = onnx.helper.make_node("SequenceLength", ["seq_1"], ["len"])
+
+        tensor_shape = [2, 3, 4]
+        len_shape = []
+
+        x = np.ones(tensor_shape, dtype=np.float32)
+        out = SplitToSequenceImpl(x, axis=-1)
+        out = SequenceLengthImpl(out)
+        assert np.array_equal(out, np.int64(4))
+
+        graph = onnx.helper.make_graph(
+            nodes=[seq_split_node, seq_len_node],
+            name="Sequence",
+            inputs=[
+                onnx.helper.make_tensor_value_info(
+                    "X", onnx.TensorProto.FLOAT, tensor_shape
+                )
+            ],
+            outputs=[
+                onnx.helper.make_tensor_value_info(
+                    "len", onnx.TensorProto.INT64, len_shape
+                )
+            ],
+        )
+
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 12)],
+        )
+        expect(model, inputs=[x], outputs=[out], name="test_sequence_model6")
+
+        # 7th testcase - split with keepdims=0, and SequenceAt
+        seq_split_node = onnx.helper.make_node(
+            "SplitToSequence", ["X"], ["seq_1"], axis=0, keepdims=0
+        )
+        seq_at_node = onnx.helper.make_node("SequenceAt", ["seq_1", "pos_at"], ["out"])
+
+        tensor_shape = [2, 3, 4]
+        out_shape = [3, 4]
+
+        x = np.random.rand(*tensor_shape)
+        pos_at_val = 1
+        out = SplitToSequenceImpl(x, axis=0, keepdims=0)
+        out = SequenceAtImpl(out, pos_at_val)
+        assert np.array_equal(out, x[pos_at_val])
+
+        pos_at = onnx.helper.make_tensor("pos_at", TensorProto.INT64, (), (pos_at_val,))
+
+        graph = make_graph(
+            [seq_split_node, seq_at_node],
+            [tensor_shape, []],
+            [out_shape],
+            ["X", "pos_at"],
+            ["out"],
+            [onnx.TensorProto.DOUBLE, onnx.TensorProto.INT64],
+            [onnx.TensorProto.DOUBLE],
+            [pos_at],
+        )
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 12)],
+        )
+        expect(model, inputs=[x], outputs=[out], name="test_sequence_model7")
+
+        # 8th testcase - split zero length
+        seq_split_node = onnx.helper.make_node(
+            "SplitToSequence", ["X", "Splits"], ["seq_1"]
+        )
+        seq_len_node = onnx.helper.make_node("SequenceLength", ["seq_1"], ["len"])
+
+        tensor_shape = ["n"]
+        splits_shape = [3]
+
+        x = np.array([]).astype(np.float32)
+        splits = np.array([0, 0, 0]).astype(np.int64)
+        out_len = np.int64(3)
+
+        graph = onnx.helper.make_graph(
+            nodes=[seq_split_node, seq_len_node],
+            name="Sequence",
+            inputs=[
+                onnx.helper.make_tensor_value_info(
+                    "X", onnx.TensorProto.FLOAT, tensor_shape
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "Splits", onnx.TensorProto.INT64, splits_shape
+                ),
+            ],
+            outputs=[
+                onnx.helper.make_tensor_value_info(
+                    "len", onnx.TensorProto.INT64, len_shape
+                )
+            ],
+        )
+
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 12)],
+        )
+        expect(
+            model, inputs=[x, splits], outputs=[out_len], name="test_sequence_model8"
+        )
diff --git a/onnx/backend/test/case/model/shrink.py b/onnx/backend/test/case/model/shrink.py
new file mode 100644
index 0000000..6a4ad6a
--- /dev/null
+++ b/onnx/backend/test/case/model/shrink.py
@@ -0,0 +1,42 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
+
+
+class ShrinkTest(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Shrink",
+            ["x"],
+            ["y"],
+            lambd=1.5,
+            bias=1.5,
+        )
+        graph = onnx.helper.make_graph(
+            nodes=[node],
+            name="Shrink",
+            inputs=[
+                onnx.helper.make_tensor_value_info("x", onnx.TensorProto.FLOAT, [5])
+            ],
+            outputs=[
+                onnx.helper.make_tensor_value_info("y", onnx.TensorProto.FLOAT, [5])
+            ],
+        )
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 10)],
+        )
+
+        x = np.array([-2.0, -1.0, 0.0, 1.0, 2.0], dtype=np.float32)
+        y = np.array([-0.5, 0.0, 0.0, 0.0, 0.5], dtype=np.float32)
+
+        expect(model, inputs=[x], outputs=[y], name="test_shrink")
diff --git a/onnx/backend/test/case/model/sign.py b/onnx/backend/test/case/model/sign.py
new file mode 100644
index 0000000..59b1b84
--- /dev/null
+++ b/onnx/backend/test/case/model/sign.py
@@ -0,0 +1,36 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
+
+
+class SingleSign(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node("Sign", ["x"], ["y"], name="test")
+
+        x = np.array([-1.0, 4.5, -4.5, 3.1, 0.0, 2.4, -5.5]).astype(np.float32)
+        y = np.array([-1.0, 1.0, -1.0, 1.0, 0.0, 1.0, -1.0]).astype(np.float32)
+
+        graph = onnx.helper.make_graph(
+            nodes=[node],
+            name="SingleSign",
+            inputs=[
+                onnx.helper.make_tensor_value_info("x", onnx.TensorProto.FLOAT, [7])
+            ],
+            outputs=[
+                onnx.helper.make_tensor_value_info("y", onnx.TensorProto.FLOAT, [7])
+            ],
+        )
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 9)],
+        )
+        expect(model, inputs=[x], outputs=[y], name="test_sign_model")
diff --git a/onnx/backend/test/case/model/single_relu.py b/onnx/backend/test/case/model/single_relu.py
new file mode 100644
index 0000000..a7f8ab3
--- /dev/null
+++ b/onnx/backend/test/case/model/single_relu.py
@@ -0,0 +1,36 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
+
+
+class SingleRelu(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node("Relu", ["x"], ["y"], name="test")
+        graph = onnx.helper.make_graph(
+            nodes=[node],
+            name="SingleRelu",
+            inputs=[
+                onnx.helper.make_tensor_value_info("x", onnx.TensorProto.FLOAT, [1, 2])
+            ],
+            outputs=[
+                onnx.helper.make_tensor_value_info("y", onnx.TensorProto.FLOAT, [1, 2])
+            ],
+        )
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 9)],
+        )
+
+        x = np.random.randn(1, 2).astype(np.float32)
+        y = np.maximum(x, 0)
+
+        expect(model, inputs=[x], outputs=[y], name="test_single_relu_model")
diff --git a/onnx/backend/test/case/model/stringnormalizer.py b/onnx/backend/test/case/model/stringnormalizer.py
new file mode 100644
index 0000000..948ad36
--- /dev/null
+++ b/onnx/backend/test/case/model/stringnormalizer.py
@@ -0,0 +1,205 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.model import expect
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+class NormalizeStrings(Base):
+    @staticmethod
+    def export() -> None:
+        def make_graph(
+            node: onnx.helper.NodeProto,
+            input_shape: Sequence[int],
+            output_shape: Sequence[int],
+        ) -> onnx.helper.GraphProto:
+            return onnx.helper.make_graph(
+                nodes=[node],
+                name="StringNormalizer",
+                inputs=[
+                    onnx.helper.make_tensor_value_info(
+                        "x", onnx.TensorProto.STRING, input_shape
+                    )
+                ],
+                outputs=[
+                    onnx.helper.make_tensor_value_info(
+                        "y", onnx.TensorProto.STRING, output_shape
+                    )
+                ],
+            )
+
+        # 1st model_monday_casesensintive_nochangecase
+        stopwords = ["monday"]
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            is_case_sensitive=1,
+            stopwords=stopwords,
+        )
+
+        x = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+        y = np.array(["tuesday", "wednesday", "thursday"]).astype(object)
+
+        graph = make_graph(node, [4], [3])
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 10)],
+        )
+        expect(
+            model,
+            inputs=[x],
+            outputs=[y],
+            name="test_strnorm_model_monday_casesensintive_nochangecase",
+        )
+
+        # 2nd model_nostopwords_nochangecase
+        node = onnx.helper.make_node(
+            "StringNormalizer", inputs=["x"], outputs=["y"], is_case_sensitive=1
+        )
+
+        x = np.array(["monday", "tuesday"]).astype(object)
+        y = x
+
+        graph = make_graph(node, [2], [2])
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 10)],
+        )
+        expect(
+            model,
+            inputs=[x],
+            outputs=[y],
+            name="test_strnorm_model_nostopwords_nochangecase",
+        )
+
+        # 3rd model_monday_casesensintive_lower
+        stopwords = ["monday"]
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            case_change_action="LOWER",
+            is_case_sensitive=1,
+            stopwords=stopwords,
+        )
+
+        x = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+        y = np.array(["tuesday", "wednesday", "thursday"]).astype(object)
+
+        graph = make_graph(node, [4], [3])
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 10)],
+        )
+        expect(
+            model,
+            inputs=[x],
+            outputs=[y],
+            name="test_strnorm_model_monday_casesensintive_lower",
+        )
+
+        # 4 model_monday_casesensintive_upper
+        stopwords = ["monday"]
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            case_change_action="UPPER",
+            is_case_sensitive=1,
+            stopwords=stopwords,
+        )
+
+        x = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+        y = np.array(["TUESDAY", "WEDNESDAY", "THURSDAY"]).astype(object)
+
+        graph = make_graph(node, [4], [3])
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 10)],
+        )
+        expect(
+            model,
+            inputs=[x],
+            outputs=[y],
+            name="test_strnorm_model_monday_casesensintive_upper",
+        )
+
+        # 5 monday_insensintive_upper_twodim
+        stopwords = ["monday"]
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            case_change_action="UPPER",
+            stopwords=stopwords,
+        )
+
+        input_shape = [1, 6]
+        output_shape = [1, 4]
+        x = (
+            np.array(
+                ["Monday", "tuesday", "wednesday", "Monday", "tuesday", "wednesday"]
+            )
+            .astype(object)
+            .reshape(input_shape)
+        )
+        y = (
+            np.array(["TUESDAY", "WEDNESDAY", "TUESDAY", "WEDNESDAY"])
+            .astype(object)
+            .reshape(output_shape)
+        )
+
+        graph = make_graph(node, input_shape, output_shape)
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 10)],
+        )
+        expect(
+            model,
+            inputs=[x],
+            outputs=[y],
+            name="test_strnorm_model_monday_insensintive_upper_twodim",
+        )
+
+        # 6 monday_empty_output
+        stopwords = ["monday"]
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            case_change_action="UPPER",
+            is_case_sensitive=0,
+            stopwords=stopwords,
+        )
+
+        x = np.array(["monday", "monday"]).astype(object)
+        y = np.array([""]).astype(object)
+
+        graph = make_graph(node, [2], [1])
+        model = onnx.helper.make_model_gen_version(
+            graph,
+            producer_name="backend-test",
+            opset_imports=[onnx.helper.make_opsetid("", 10)],
+        )
+        expect(
+            model,
+            inputs=[x],
+            outputs=[y],
+            name="test_strnorm_model_monday_empty_output",
+        )
diff --git a/onnx/backend/test/case/node/__init__.py b/onnx/backend/test/case/node/__init__.py
new file mode 100644
index 0000000..4c9eb8d
--- /dev/null
+++ b/onnx/backend/test/case/node/__init__.py
@@ -0,0 +1,474 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import subprocess
+import sys
+from copy import deepcopy
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import onnx
+from onnx.backend.test.case.test_case import TestCase
+from onnx.backend.test.case.utils import import_recursive
+from onnx.onnx_pb import (
+    AttributeProto,
+    FunctionProto,
+    GraphProto,
+    ModelProto,
+    NodeProto,
+    OperatorSetIdProto,
+    TensorProto,
+    TypeProto,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+    import numpy as np
+
+_NodeTestCases = []
+_TargetOpType = None
+_DiffOpTypes = None
+_existing_names: dict[str, onnx.NodeProto] = {}
+
+
+def _rename_edges_helper(
+    internal_node: NodeProto,
+    rename_helper: Callable[[str], str],
+    attribute_map: dict[str, AttributeProto],
+    prefix: str,
+) -> NodeProto:
+    new_node = NodeProto()
+    new_node.CopyFrom(internal_node)
+    new_node.ClearField("input")
+    new_node.ClearField("output")
+    new_node.ClearField("attribute")
+    for internal_name in internal_node.input:
+        new_node.input.append(rename_helper(internal_name))
+    for internal_name in internal_node.output:
+        new_node.output.append(rename_helper(internal_name))
+    for attr in internal_node.attribute:
+        if attr.HasField("ref_attr_name"):
+            if attr.ref_attr_name in attribute_map:
+                new_attr = AttributeProto()
+                new_attr.CopyFrom(attribute_map[attr.ref_attr_name])
+                new_attr.name = attr.name
+                new_node.attribute.extend([new_attr])
+        else:
+            new_attr = AttributeProto()
+            new_attr.CopyFrom(attr)
+            if attr.type == AttributeProto.GRAPH:
+                new_graph = new_attr.g
+                sg_rename = {}
+                for in_desc in new_graph.input:
+                    sg_rename[in_desc.name] = in_desc.name = prefix + in_desc.name
+                for out_desc in new_graph.output:
+                    sg_rename[out_desc.name] = out_desc.name = prefix + out_desc.name
+                for init_desc in new_graph.initializer:
+                    sg_rename[init_desc.name] = init_desc.name = prefix + init_desc.name
+                for sparse_init_desc in new_graph.sparse_initializer:
+                    sg_rename[sparse_init_desc.values.name] = (
+                        sparse_init_desc.values.name
+                    ) = prefix + sparse_init_desc.values.name
+                for sparse_init_desc in new_graph.sparse_initializer:
+                    sg_rename[sparse_init_desc.indices.name] = (
+                        sparse_init_desc.indices.name
+                    ) = prefix + sparse_init_desc.indices.name
+
+                def subgraph_rename_helper(name: str) -> Any:
+                    if name in sg_rename:  # noqa: B023
+                        return sg_rename[name]  # noqa: B023
+                    return rename_helper(name)
+
+                new_nodes = [
+                    _rename_edges_helper(
+                        node_desc, subgraph_rename_helper, attribute_map, prefix
+                    )
+                    for node_desc in new_graph.node
+                ]
+                new_graph.ClearField("node")
+                new_graph.node.extend(new_nodes)
+            new_node.attribute.extend([new_attr])
+    return new_node
+
+
+# FIXME(TMVector): Any reason we can't get rid of this and use the C++ helper directly?
+def function_expand_helper(
+    node: NodeProto, function_proto: FunctionProto, op_prefix: str
+) -> list[NodeProto]:
+    io_names_map = {}
+    attribute_map = {a.name: a for a in node.attribute}
+
+    for idx, input in enumerate(function_proto.input):
+        io_names_map[input] = node.input[idx] if idx in range(len(node.input)) else ""
+
+    for idx, output in enumerate(function_proto.output):
+        # Even if the node has been created with optional outputs missing, we
+        # can't assume that the function body handles this correctly, such as in
+        # the case that output is also an intermediate value.
+        # So we only add a name mapping if the output is present. An internal
+        # name will be generated if the missing output is used, the same as any
+        # other internal tensor.
+        if idx in range(len(node.output)) and node.output[idx] != "":
+            io_names_map[output] = node.output[idx]
+
+    def rename_helper(internal_name: str) -> Any:
+        if internal_name in io_names_map:
+            return io_names_map[internal_name]
+        if internal_name == "":
+            return ""
+        return op_prefix + internal_name
+
+    return [
+        _rename_edges_helper(internal_node, rename_helper, attribute_map, op_prefix)
+        for internal_node in function_proto.node
+    ]
+
+
+def function_testcase_helper(
+    node: NodeProto,
+    input_types: list[TypeProto],
+    name: str,
+    opset_imports: Sequence[OperatorSetIdProto] | None = None,
+) -> tuple[list[tuple[list[NodeProto], Any]], int]:
+    test_op = node.op_type
+    op_prefix = test_op + "_" + name + "_expanded_function_"
+    if opset_imports is None:
+        # No opset in the model. We take the most recent definition.
+        schema = onnx.defs.get_schema(test_op, domain=node.domain)
+    else:
+        # We take the function defined in the specific version mentioned
+        # in the model. Find the opset_import matching the node's domain.
+        node_domain = node.domain or ""
+        matching_opset = None
+        for opset in opset_imports:
+            opset_domain = opset.domain or ""
+            if opset_domain == node_domain or (
+                node_domain in {"", "ai.onnx"} and opset_domain in {"", "ai.onnx"}
+            ):
+                matching_opset = opset
+                break
+        if matching_opset is None:
+            raise ValueError(
+                f"No matching opset_import found for domain {node_domain!r} "
+                f"in {[o.domain for o in opset_imports]}."
+            )
+        version = matching_opset.version
+        schema = onnx.defs.get_schema(test_op, version, domain=node.domain)
+
+    # an op schema may have several functions, each for one opset version
+    # opset versions include the op's since_version and other opset versions
+    # if it is needed to define the op for a opset version other than the op's since_version.
+    function_protos = []
+    for opset_version in schema.function_opset_versions:  # type: ignore[attr-defined]
+        function_proto_str = schema.get_function_with_opset_version(opset_version)  # type: ignore[attr-defined]
+        function_proto = FunctionProto()
+        function_proto.ParseFromString(function_proto_str)
+        function_protos.append(function_proto)
+    for opset_version in schema.context_dependent_function_opset_versions:  # type: ignore[attr-defined]
+        function_proto_str = schema.get_context_dependent_function_with_opset_version(  # type: ignore[attr-defined]
+            opset_version,
+            node.SerializeToString(),
+            [t.SerializeToString() for t in input_types],
+        )
+        function_proto = FunctionProto()
+        function_proto.ParseFromString(function_proto_str)
+        function_protos.append(function_proto)
+
+    expanded_tests = []
+    for function_proto in function_protos:
+        for attr in schema.attributes:
+            if attr in [a.name for a in node.attribute]:
+                continue
+            if schema.attributes[attr].default_value:
+                node.attribute.extend([schema.attributes[attr].default_value])
+
+        # function_proto.attributes
+        node_list = function_expand_helper(node, function_proto, op_prefix)
+        expanded_tests.append((node_list, function_proto.opset_import))
+
+    return expanded_tests, schema.since_version
+
+
+def _extract_value_info(
+    input: list[Any] | np.ndarray | None,
+    name: str,
+    type_proto: TypeProto | None = None,
+) -> onnx.ValueInfoProto:
+    if type_proto is None:
+        if input is None:
+            raise NotImplementedError(
+                "_extract_value_info: both input and type_proto arguments cannot be None."
+            )
+        if isinstance(input, list):
+            elem_type = onnx.helper.np_dtype_to_tensor_dtype(input[0].dtype)
+            shape = None
+            tensor_type_proto = onnx.helper.make_tensor_type_proto(elem_type, shape)
+            type_proto = onnx.helper.make_sequence_type_proto(tensor_type_proto)
+        elif isinstance(input, TensorProto):
+            elem_type = input.data_type
+            shape = tuple(input.dims)
+            type_proto = onnx.helper.make_tensor_type_proto(elem_type, shape)
+        else:
+            elem_type = onnx.helper.np_dtype_to_tensor_dtype(input.dtype)
+            shape = input.shape
+            type_proto = onnx.helper.make_tensor_type_proto(elem_type, shape)
+
+    return onnx.helper.make_value_info(name, type_proto)
+
+
+def _make_test_model_gen_version(graph: GraphProto, **kwargs: Any) -> ModelProto:
+    (
+        latest_onnx_version,
+        latest_ml_version,
+        latest_training_version,
+    ) = onnx.helper.VERSION_TABLE[-1][2:5]  # type: ignore[index]
+    if "opset_imports" in kwargs:
+        for opset in kwargs["opset_imports"]:
+            # If the test model uses an unreleased opset version (latest_version+1),
+            # directly use make_model to create a model with the latest ir version
+            if (
+                (
+                    (opset.domain in {"", "ai.onnx"})
+                    and opset.version == latest_onnx_version + 1
+                )
+                or (
+                    opset.domain == "ai.onnx.ml"
+                    and opset.version == latest_ml_version + 1
+                )
+                or (
+                    (
+                        opset.domain
+                        in {"ai.onnx.training version", "ai.onnx.preview.training"}
+                    )
+                    and opset.version == latest_training_version + 1
+                )
+            ):
+                return onnx.helper.make_model(graph, **kwargs)
+    # Otherwise, find and use the corresponding ir version according to given opset version
+    return onnx.helper.make_model_gen_version(graph, **kwargs)
+
+
+# In the case of ops with optional inputs and outputs, node_op.input and node_op.output indicate
+# which inputs/outputs are present and which are omitted. However, the parameter inputs
+# and outputs of this function include values only for inputs/outputs that are present.
+# E.g., for an op with 3 inputs, if the second parameter is optional and we wish to omit it,
+# node_op.inputs would look like ["Param1", "", "Param3"], while inputs would look like
+# [input-1-value, input-3-value]
+# Instead of creating model with latest version, it now generates models for since_version by default.
+# Thus it can make every model uses the same opset version after every opset change.
+# Besides, user can specify "use_max_opset_version" to generate models for
+# the latest opset version that supports before targeted opset version
+def expect(
+    node_op: onnx.NodeProto,
+    inputs: Sequence[np.ndarray | TensorProto],
+    outputs: Sequence[np.ndarray | TensorProto],
+    name: str,
+    **kwargs: Any,
+) -> None:
+    # skip if the node_op's op_type is not same as the given one
+    if _TargetOpType and node_op.op_type != _TargetOpType:
+        return
+    if _DiffOpTypes is not None and node_op.op_type.lower() not in _DiffOpTypes:
+        return
+    if name in _existing_names:
+        raise ValueError(
+            f"Name {name!r} is already using by one test case for node type {node_op.op_type!r}."
+        )
+    _existing_names[name] = node_op
+
+    # in case node_op is modified
+    node = deepcopy(node_op)
+    present_inputs = [x for x in node.input if (x != "")]
+    present_outputs = [x for x in node.output if (x != "")]
+    input_type_protos = [None] * len(inputs)
+    if "input_type_protos" in kwargs:
+        input_type_protos = kwargs["input_type_protos"]
+        del kwargs["input_type_protos"]
+    output_type_protos = [None] * len(outputs)
+    if "output_type_protos" in kwargs:
+        output_type_protos = kwargs["output_type_protos"]
+        del kwargs["output_type_protos"]
+    inputs_vi = [
+        _extract_value_info(arr, arr_name, input_type)
+        for arr, arr_name, input_type in zip(
+            inputs, present_inputs, input_type_protos, strict=False
+        )
+    ]
+    outputs_vi = [
+        _extract_value_info(arr, arr_name, output_type)
+        for arr, arr_name, output_type in zip(
+            outputs, present_outputs, output_type_protos, strict=False
+        )
+    ]
+    graph = onnx.helper.make_graph(
+        nodes=[node], name=name, inputs=inputs_vi, outputs=outputs_vi
+    )
+    kwargs["producer_name"] = "backend-test"
+
+    if "opset_imports" not in kwargs:
+        # To make sure the model will be produced with the same opset_version after opset changes
+        # By default, it uses since_version as opset_version for produced models
+        produce_opset_version = onnx.defs.get_schema(
+            node.op_type, domain=node.domain
+        ).since_version
+        kwargs["opset_imports"] = [
+            onnx.helper.make_operatorsetid(node.domain, produce_opset_version)
+        ]
+
+    model = _make_test_model_gen_version(graph, **kwargs)
+
+    _NodeTestCases.append(
+        TestCase(
+            name=name,
+            model_name=name,
+            url=None,
+            model_dir=None,
+            model=model,
+            data_sets=[(inputs, outputs)],
+            kind="node",
+            rtol=1e-3,
+            atol=1e-7,
+        )
+    )
+
+    # Create list of types for node.input, filling a default TypeProto for missing inputs:
+    # E.g. merge(["x", "", "y"], [x-value-info, y-value-info]) will return [x-type, default-type, y-type]
+    def merge(
+        node_inputs: list[str], present_value_info: list[onnx.ValueInfoProto]
+    ) -> list[TypeProto]:
+        if node_inputs:
+            if node_inputs[0] != "":
+                return [
+                    present_value_info[0].type,
+                    *merge(node_inputs[1:], present_value_info[1:]),
+                ]
+            return [TypeProto(), *merge(node_inputs[1:], present_value_info)]
+        return []
+
+    merged_types = merge(list(node.input), inputs_vi)
+    (
+        expanded_tests,
+        since_version,
+    ) = function_testcase_helper(
+        node, merged_types, name, opset_imports=kwargs.get("opset_imports")
+    )
+    for expanded_function_nodes, func_opset_import in expanded_tests:
+        kwargs["producer_name"] = "backend-test"
+
+        # TODO: if kwargs["opset_imports"] already exists, only generate test case for the opset version.
+        # replace opset versions with what are specified in function proto
+        if "opset_imports" not in kwargs:
+            kwargs["opset_imports"] = func_opset_import
+        else:
+            for opset_import in func_opset_import:
+                matches = [
+                    opset
+                    for opset in kwargs["opset_imports"]
+                    if opset.domain == opset_import.domain
+                ]
+                if matches:
+                    matches[0].version = opset_import.version
+                else:
+                    kwargs["opset_imports"].append(opset_import)
+
+        onnx_ai_opset_version = ""
+        if "opset_imports" in kwargs:
+            onnx_ai_opset_imports = [
+                oi for oi in kwargs["opset_imports"] if oi.domain in ("", "ai.onnx")
+            ]
+            if len(onnx_ai_opset_imports) == 1:
+                onnx_ai_opset_version = onnx_ai_opset_imports[0].version
+
+        function_test_name = name + "_expanded"
+        if onnx_ai_opset_version and onnx_ai_opset_version != since_version:
+            function_test_name += f"_ver{onnx_ai_opset_version}"
+        graph = onnx.helper.make_graph(
+            nodes=expanded_function_nodes,
+            name=function_test_name,
+            inputs=inputs_vi,
+            outputs=outputs_vi,
+        )
+        model = _make_test_model_gen_version(graph, **kwargs)
+        _NodeTestCases.append(
+            TestCase(
+                name=function_test_name,
+                model_name=function_test_name,
+                url=None,
+                model_dir=None,
+                model=model,
+                data_sets=[(inputs, outputs)],
+                kind="node",
+                rtol=1e-3,
+                atol=1e-7,
+            )
+        )
+
+
+def collect_testcases(op_type: str) -> list[TestCase]:
+    """Collect node test cases"""
+    # only keep those tests related to this operator
+    global _TargetOpType  # noqa: PLW0603
+    _TargetOpType = op_type
+
+    import_recursive(sys.modules[__name__])
+    return _NodeTestCases
+
+
+def collect_diff_testcases() -> list[TestCase]:
+    """Collect node test cases which are different from the main branch"""
+    global _DiffOpTypes  # noqa: PLW0603
+    _DiffOpTypes = get_diff_op_types()
+
+    import_recursive(sys.modules[__name__])
+    return _NodeTestCases
+
+
+def get_diff_op_types():
+    cwd_path = Path.cwd()
+    # Resolve the upstream main branch from the canonical onnx/onnx repository
+    # to avoid depending on local branch or remote naming conventions.
+    upstream_url = "https://github.com/onnx/onnx.git"
+    ls_remote = subprocess.run(
+        ["git", "ls-remote", upstream_url, "refs/heads/main"],
+        cwd=cwd_path,
+        capture_output=True,
+        check=True,
+    )
+    upstream_main_hash = ls_remote.stdout.split()[0].decode("utf-8")
+    # Fetch the upstream main commit so merge-base works even if the
+    # local repo hasn't fetched recently.
+    subprocess.run(
+        ["git", "fetch", upstream_url, upstream_main_hash],
+        cwd=cwd_path,
+        capture_output=True,
+        check=True,
+    )
+    # Find the fork point from upstream main
+    merge_base = subprocess.run(
+        ["git", "merge-base", "HEAD", upstream_main_hash],
+        cwd=cwd_path,
+        capture_output=True,
+        check=True,
+    )
+    base_commit = merge_base.stdout.strip().decode("utf-8")
+    # obtain list of added or modified files since the fork point
+    result = subprocess.run(
+        ["git", "diff", "--name-only", "--diff-filter=AM", base_commit, "HEAD"],
+        cwd=cwd_path,
+        capture_output=True,
+        check=True,
+    )
+    diff_list = result.stdout.split()
+    changed_op_types = []
+    for file in diff_list:
+        file_name = file.decode("utf-8")
+        if file_name.startswith("onnx/backend/test/case/node/") and file_name.endswith(
+            ".py"
+        ):
+            changed_op_types.append(
+                file_name.split("/")[-1].replace(".py", "").rstrip("_")
+            )
+    return changed_op_types
diff --git a/onnx/backend/test/case/node/_image_decoder_data.py b/onnx/backend/test/case/node/_image_decoder_data.py
new file mode 100644
index 0000000..90828e4
--- /dev/null
+++ b/onnx/backend/test/case/node/_image_decoder_data.py
@@ -0,0 +1,6353 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# This file contains freeze NumPy array for ImageDecoder backend test's input/output
+# They were generated by image_decoder.py's generate_test_data with pillow
+# To make ONNX backend test generation simple, use freeze NumPy array directly
+# People can still use generate_test_data to get these data here with installed pillow
+from __future__ import annotations
+
+from typing import NamedTuple
+
+import numpy as np
+
+
+class ImageData(NamedTuple):
+    data: np.ndarray
+    output: np.ndarray
+
+
+# Remove black check for better readability with large NumPy array
+# fmt: off
+image_decoder_decode_jpeg_rgb = ImageData(
+    np.array([255, 216, 255, 224,   0,  16,  74,  70,  73,  70,   0,   1,   1,
+         0,   0,   1,   0,   1,   0,   0, 255, 219,   0,  67,   0,   8,
+         6,   6,   7,   6,   5,   8,   7,   7,   7,   9,   9,   8,  10,
+        12,  20,  13,  12,  11,  11,  12,  25,  18,  19,  15,  20,  29,
+        26,  31,  30,  29,  26,  28,  28,  32,  36,  46,  39,  32,  34,
+        44,  35,  28,  28,  40,  55,  41,  44,  48,  49,  52,  52,  52,
+        31,  39,  57,  61,  56,  50,  60,  46,  51,  52,  50, 255, 219,
+         0,  67,   1,   9,   9,   9,  12,  11,  12,  24,  13,  13,  24,
+        50,  33,  28,  33,  50,  50,  50,  50,  50,  50,  50,  50,  50,
+        50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,
+        50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,
+        50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,  50,
+        50,  50, 255, 192,   0,  17,   8,   0,  32,   0,  32,   3,   1,
+        34,   0,   2,  17,   1,   3,  17,   1, 255, 196,   0,  31,   0,
+         0,   1,   5,   1,   1,   1,   1,   1,   1,   0,   0,   0,   0,
+         0,   0,   0,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+        10,  11, 255, 196,   0, 181,  16,   0,   2,   1,   3,   3,   2,
+         4,   3,   5,   5,   4,   4,   0,   0,   1, 125,   1,   2,   3,
+         0,   4,  17,   5,  18,  33,  49,  65,   6,  19,  81,  97,   7,
+        34, 113,  20,  50, 129, 145, 161,   8,  35,  66, 177, 193,  21,
+        82, 209, 240,  36,  51,  98, 114, 130,   9,  10,  22,  23,  24,
+        25,  26,  37,  38,  39,  40,  41,  42,  52,  53,  54,  55,  56,
+        57,  58,  67,  68,  69,  70,  71,  72,  73,  74,  83,  84,  85,
+        86,  87,  88,  89,  90,  99, 100, 101, 102, 103, 104, 105, 106,
+       115, 116, 117, 118, 119, 120, 121, 122, 131, 132, 133, 134, 135,
+       136, 137, 138, 146, 147, 148, 149, 150, 151, 152, 153, 154, 162,
+       163, 164, 165, 166, 167, 168, 169, 170, 178, 179, 180, 181, 182,
+       183, 184, 185, 186, 194, 195, 196, 197, 198, 199, 200, 201, 202,
+       210, 211, 212, 213, 214, 215, 216, 217, 218, 225, 226, 227, 228,
+       229, 230, 231, 232, 233, 234, 241, 242, 243, 244, 245, 246, 247,
+       248, 249, 250, 255, 196,   0,  31,   1,   0,   3,   1,   1,   1,
+         1,   1,   1,   1,   1,   1,   0,   0,   0,   0,   0,   0,   1,
+         2,   3,   4,   5,   6,   7,   8,   9,  10,  11, 255, 196,   0,
+       181,  17,   0,   2,   1,   2,   4,   4,   3,   4,   7,   5,   4,
+         4,   0,   1,   2, 119,   0,   1,   2,   3,  17,   4,   5,  33,
+        49,   6,  18,  65,  81,   7,  97, 113,  19,  34,  50, 129,   8,
+        20,  66, 145, 161, 177, 193,   9,  35,  51,  82, 240,  21,  98,
+       114, 209,  10,  22,  36,  52, 225,  37, 241,  23,  24,  25,  26,
+        38,  39,  40,  41,  42,  53,  54,  55,  56,  57,  58,  67,  68,
+        69,  70,  71,  72,  73,  74,  83,  84,  85,  86,  87,  88,  89,
+        90,  99, 100, 101, 102, 103, 104, 105, 106, 115, 116, 117, 118,
+       119, 120, 121, 122, 130, 131, 132, 133, 134, 135, 136, 137, 138,
+       146, 147, 148, 149, 150, 151, 152, 153, 154, 162, 163, 164, 165,
+       166, 167, 168, 169, 170, 178, 179, 180, 181, 182, 183, 184, 185,
+       186, 194, 195, 196, 197, 198, 199, 200, 201, 202, 210, 211, 212,
+       213, 214, 215, 216, 217, 218, 226, 227, 228, 229, 230, 231, 232,
+       233, 234, 242, 243, 244, 245, 246, 247, 248, 249, 250, 255, 218,
+         0,  12,   3,   1,   0,   2,  17,   3,  17,   0,  63,   0,  93,
+        15, 199, 122,  93, 181, 235, 187, 193, 120,  65, 140, 143, 149,
+        23, 212, 127, 181,  93,  36,  95,  16, 180, 150, 145,  36,  22,
+       247, 187, 119,   3, 247,  19, 255,   0, 138, 175,  29, 180, 183,
+       153,  37,  36, 195,  32, 249, 123, 169, 174, 175,  68, 138, 194,
+        73, 108, 226, 187, 104, 193, 105,  66, 186, 180, 155,  78,  11,
+       125, 120, 226, 184, 243, 204,  13,  12, 101, 117, 141, 154, 110,
+        46, 209, 211, 123, 247, 125,  45, 243,  61, 156,  62,  34, 141,
+        92,  59, 173, 137,  77, 201, 221,  46,  94, 253,  14, 135, 198,
+        14,  62,  32, 253, 139, 251,  39,  48, 253, 135, 127, 153, 246,
+       191, 151,  59, 246, 227,  27, 119, 127, 112, 245, 199, 106, 224,
+       124,  90, 134, 211, 194, 183, 118, 114,  96, 201,   8, 142,  54,
+        43, 208, 149, 117,   7,  30, 220,  87, 166, 234,  22, 182, 250,
+       103, 151, 253, 132, 163, 247, 153, 243, 188, 166,  50, 244, 198,
+       220, 231,  56, 234, 107, 142, 241, 245, 157, 168, 240,  86, 161,
+       114,  80,  11, 179, 229, 179,  18, 199,  59, 140, 139, 158,  51,
+       238, 107, 179,  15, 130, 246,  20,  21,  55,  36, 224, 175, 202,
+       147, 214, 251, 235, 243,  60, 117,  78, 166,  38,  42,  53, 218,
+        92, 154, 174, 154, 147,  29,  35,  96, 207, 159, 159, 248,   7,
+       255,   0,  94, 179, 100, 180, 251,  62, 168, 178, 239, 221, 229,
+       186, 182,  49, 140, 227,   6, 181, 173, 124, 127, 224, 229, 148,
+       153, 181,   4,  43, 142,  51, 107,  33, 231, 254, 248, 170,  26,
+       151, 141, 124,  35,  52, 243,  52,  23, 145, 144, 203, 242, 145,
+       107,  32, 231,  31, 238, 215,   6,  89, 154,  85, 141,  79,  99,
+        94, 140, 185,  31, 149, 149, 219,  93, 108, 107,  71,  56, 132,
+        40, 243, 209, 161,  40, 174, 145, 123, 223, 190, 167,  75, 164,
+       106, 249, 243, 191, 113, 253, 223, 227, 250, 251,  86, 119, 196,
+       109,  63,  30,   0, 212, 175, 124, 223, 188,  34, 125, 155, 122,
+       110, 149,  56, 206, 125, 235, 147, 255,   0, 132, 199,  71, 143,
+       253,  86, 160, 201, 158, 187,  99, 144, 103, 244, 170, 158,  37,
+       241, 133, 166, 167, 225, 155, 155,   8, 181,  73, 166, 103,   8,
+         4,  76,  36, 193, 195,  41, 238,  49, 218, 175,  49, 194,  42,
+        88, 181, 245,  95, 134, 234, 246, 215,  77,  58, 234,  24,  90,
+        95,  95, 162, 241,  56, 185, 165,  36, 155,  73, 232, 238, 180,
+        90, 105, 216, 255, 217], dtype=np.uint8),
+    np.array([[[230,  73, 255],
+        [227,  76, 255],
+        [222,  81, 255],
+        [211,  95, 206],
+        [204, 123, 142],
+        [251, 202, 133],
+        [245, 226,  72],
+        [234, 230,  34],
+        [235, 234,  32],
+        [231, 229,  32],
+        [227, 221,  37],
+        [233, 224,  45],
+        [237, 227,  42],
+        [232, 216,  32],
+        [243, 219,  35],
+        [255, 247,  63],
+        [246, 255,  71],
+        [249, 255,  83],
+        [243, 253,  68],
+        [255, 251, 134],
+        [ 97,  23,  46],
+        [127,  19, 121],
+        [123,   0, 124],
+        [118,  19, 128],
+        [ 63,  28,  82],
+        [ 99, 133, 143],
+        [ 39, 146, 128],
+        [ 24, 162, 110],
+        [ 26, 157,  64],
+        [ 66, 154,  76],
+        [  0,   9,   0],
+        [ 15,   0,   9]],
+
+       [[232,  77, 255],
+        [228,  79, 255],
+        [221,  83, 254],
+        [210,  93, 208],
+        [202, 117, 146],
+        [248, 193, 137],
+        [242, 216,  77],
+        [230, 222,  35],
+        [239, 237,  40],
+        [235, 233,  36],
+        [230, 225,  37],
+        [235, 227,  41],
+        [238, 228,  42],
+        [230, 220,  34],
+        [237, 225,  41],
+        [255, 253,  70],
+        [242, 250,  68],
+        [242, 251,  70],
+        [255, 255,  79],
+        [255, 232, 124],
+        [112,  32,  57],
+        [119,   9, 108],
+        [132,  10, 129],
+        [117,  21, 121],
+        [ 83,  50,  95],
+        [ 98, 132, 134],
+        [ 34, 137, 108],
+        [ 31, 165, 106],
+        [ 40, 168,  75],
+        [ 62, 151,  71],
+        [  0,   9,   0],
+        [ 11,   0,   5]],
+
+       [[234,  81, 255],
+        [229,  82, 255],
+        [221,  86, 250],
+        [211,  95, 218],
+        [207, 115, 164],
+        [254, 189, 161],
+        [249, 213, 101],
+        [238, 224,  57],
+        [235, 232,  41],
+        [231, 229,  30],
+        [229, 221,  26],
+        [229, 221,  26],
+        [231, 225,  29],
+        [218, 219,  27],
+        [215, 229,  45],
+        [237, 252,  71],
+        [252, 252,  76],
+        [255, 248,  80],
+        [255, 249,  94],
+        [255, 225, 135],
+        [120,  30,  58],
+        [120,   6, 101],
+        [126,   9, 116],
+        [109,  20, 104],
+        [ 75,  47,  72],
+        [ 97, 130, 113],
+        [ 48, 144,  98],
+        [ 37, 163,  89],
+        [ 48, 169,  72],
+        [ 59, 151,  66],
+        [  0,  16,   0],
+        [  0,  13,   0]],
+
+       [[216,  83, 236],
+        [211,  83, 238],
+        [205,  88, 246],
+        [203,  98, 226],
+        [205, 114, 181],
+        [255, 184, 178],
+        [255, 207, 120],
+        [251, 220,  77],
+        [246, 228,  56],
+        [247, 228,  46],
+        [248, 216,  43],
+        [251, 214,  45],
+        [250, 217,  50],
+        [234, 217,  51],
+        [217, 232,  69],
+        [234, 255,  95],
+        [245, 251,  93],
+        [255, 254, 104],
+        [252, 232, 101],
+        [255, 228, 153],
+        [111,  34,  52],
+        [126,  33, 103],
+        [109,  15,  93],
+        [103,  34,  91],
+        [ 52,  33,  39],
+        [ 98, 127,  99],
+        [ 75, 152, 106],
+        [ 48, 148,  86],
+        [ 53, 151,  78],
+        [ 69, 148,  83],
+        [  0,  16,   0],
+        [  0,  15,   0]],
+
+       [[202, 104, 227],
+        [196, 103, 235],
+        [191, 106, 253],
+        [192, 111, 242],
+        [200, 117, 199],
+        [253, 176, 192],
+        [255, 193, 127],
+        [255, 204,  85],
+        [255, 210,  67],
+        [255, 209,  67],
+        [255, 195,  76],
+        [255, 189,  82],
+        [255, 193,  88],
+        [255, 197,  88],
+        [229, 217,  97],
+        [229, 246, 118],
+        [228, 250, 123],
+        [249, 255, 148],
+        [245, 251, 145],
+        [239, 224, 155],
+        [ 97,  57,  49],
+        [ 87,  35,  58],
+        [ 72,  21,  52],
+        [ 83,  48,  68],
+        [ 80,  76,  65],
+        [ 99, 122,  96],
+        [ 88, 136, 110],
+        [ 63, 123,  98],
+        [ 70, 127, 108],
+        [ 86, 130, 115],
+        [  0,   9,   0],
+        [  0,   7,   0]],
+
+       [[ 83,  27, 128],
+        [ 76,  23, 137],
+        [ 70,  23, 161],
+        [ 73,  22, 151],
+        [ 84,  16, 103],
+        [138,  60,  86],
+        [146,  66,  13],
+        [150,  72,   0],
+        [146,  73,   0],
+        [164,  71,   0],
+        [186,  55,   0],
+        [198,  48,  15],
+        [202,  51,  24],
+        [176,  56,  19],
+        [136,  81,  16],
+        [116, 114,  31],
+        [ 94, 131,  38],
+        [ 62, 112,  17],
+        [ 75, 109,  23],
+        [108, 125,  55],
+        [173, 175, 128],
+        [200, 194, 162],
+        [203, 197, 175],
+        [175, 174, 153],
+        [150, 161, 131],
+        [ 98, 117,  95],
+        [ 83, 105, 102],
+        [ 80, 103, 117],
+        [ 92, 111, 143],
+        [ 92, 107, 138],
+        [  0,   3,  12],
+        [  0,   5,   2]],
+
+       [[ 52,  43, 132],
+        [ 45,  40, 142],
+        [ 41,  38, 167],
+        [ 51,  35, 159],
+        [ 70,  21, 103],
+        [129,  55,  82],
+        [144,  53,   6],
+        [155,  53,   0],
+        [163,  53,   0],
+        [189,  52,  10],
+        [224,  32,  53],
+        [242,  23,  77],
+        [251,  25,  88],
+        [223,  33,  77],
+        [172,  59,  61],
+        [131,  98,  65],
+        [ 62, 111,  55],
+        [ 47, 130,  58],
+        [ 80, 146,  72],
+        [ 73, 128,  44],
+        [153, 200, 104],
+        [139, 183,  86],
+        [160, 202, 120],
+        [169, 206, 139],
+        [174, 203, 155],
+        [ 92, 109,  91],
+        [ 92,  92, 116],
+        [101,  90, 148],
+        [103,  88, 171],
+        [ 97,  87, 160],
+        [  0,   0,  23],
+        [  0,   4,   4]],
+
+       [[ 26,  47, 140],
+        [ 21,  44, 146],
+        [ 22,  48, 169],
+        [ 39,  47, 158],
+        [ 67,  31, 103],
+        [131,  62,  83],
+        [153,  56,  14],
+        [170,  52,   0],
+        [164,  37,   0],
+        [195,  37,  25],
+        [233,  21,  71],
+        [255,  13, 100],
+        [255,  14, 111],
+        [236,  20, 103],
+        [180,  45,  88],
+        [131,  84,  92],
+        [ 70, 118,  92],
+        [ 46, 136,  85],
+        [ 43, 118,  59],
+        [ 53, 122,  41],
+        [153, 222, 106],
+        [156, 225, 100],
+        [143, 209, 101],
+        [150, 205, 122],
+        [155, 192, 141],
+        [ 89, 101,  91],
+        [119,  98, 137],
+        [120,  83, 161],
+        [104,  65, 174],
+        [104,  78, 167],
+        [  4,   6,  27],
+        [  0,   7,   0]],
+
+       [[ 18,  50, 161],
+        [ 20,  54, 164],
+        [ 13,  53, 166],
+        [ 26,  47, 140],
+        [ 69,  44,  99],
+        [118,  52,  64],
+        [155,  55,  23],
+        [170,  48,   0],
+        [169,  41,   2],
+        [190,  36,  26],
+        [233,  35,  71],
+        [249,  26,  91],
+        [239,  10,  92],
+        [218,  23, 102],
+        [177,  54, 117],
+        [129,  83, 119],
+        [ 75, 112, 105],
+        [ 58, 131, 101],
+        [ 56, 116,  78],
+        [ 64, 120,  57],
+        [151, 214, 110],
+        [153, 217, 103],
+        [138, 203, 109],
+        [147, 202, 134],
+        [169, 199, 163],
+        [102, 102, 104],
+        [124,  88, 132],
+        [120,  67, 147],
+        [131,  78, 184],
+        [101,  68, 147],
+        [  3,   9,   7],
+        [  0,  18,   0]],
+
+       [[ 15,  46, 136],
+        [ 16,  52, 138],
+        [ 11,  53, 135],
+        [ 23,  46, 114],
+        [ 66,  43,  89],
+        [114,  48,  76],
+        [151,  46,  60],
+        [164,  39,  45],
+        [167,  43,  51],
+        [164,  28,  38],
+        [200,  43,  54],
+        [214,  43,  59],
+        [210,  42,  59],
+        [195,  56,  79],
+        [144,  65,  94],
+        [115,  93, 114],
+        [ 72, 103, 106],
+        [ 63, 116, 108],
+        [ 70, 111, 103],
+        [ 87, 127, 103],
+        [139, 187, 129],
+        [151, 201, 138],
+        [147, 198, 155],
+        [160, 198, 177],
+        [150, 162, 162],
+        [117,  97, 124],
+        [143,  86, 141],
+        [142,  68, 147],
+        [148,  76, 176],
+        [124,  74, 145],
+        [  6,   0,   0],
+        [  0,  10,   0]],
+
+       [[ 36,  57,  88],
+        [ 37,  62,  92],
+        [ 29,  65,  91],
+        [ 39,  55,  88],
+        [ 76,  47,  95],
+        [118,  47, 115],
+        [150,  39, 134],
+        [158,  32, 132],
+        [154,  41, 123],
+        [146,  43,  86],
+        [196, 101,  79],
+        [194, 111,  45],
+        [180, 109,  17],
+        [170, 126,  37],
+        [140, 138,  77],
+        [173, 197, 165],
+        [185, 215, 215],
+        [183, 214, 235],
+        [186, 206, 239],
+        [173, 192, 225],
+        [120, 142, 165],
+        [107, 128, 157],
+        [101, 121, 171],
+        [112, 118, 178],
+        [158, 138, 199],
+        [180, 129, 195],
+        [215, 130, 198],
+        [226, 125, 203],
+        [222, 126, 216],
+        [201, 125, 189],
+        [ 44,   6,   3],
+        [ 23,   5,   0]],
+
+       [[ 43,  58,  65],
+        [ 43,  62,  66],
+        [ 36,  65,  63],
+        [ 42,  55,  64],
+        [ 72,  44,  84],
+        [112,  41, 121],
+        [140,  28, 156],
+        [143,  21, 158],
+        [130,  28, 140],
+        [115,  39,  86],
+        [164, 121,  70],
+        [151, 132,  14],
+        [131, 127,   0],
+        [127, 142,   0],
+        [115, 151,  55],
+        [196, 235, 190],
+        [189, 214, 218],
+        [192, 206, 245],
+        [201, 208, 255],
+        [202, 207, 255],
+        [110, 114, 188],
+        [109, 113, 202],
+        [117, 115, 225],
+        [126, 109, 224],
+        [137,  95, 195],
+        [195, 127, 212],
+        [225, 129, 201],
+        [237, 127, 200],
+        [229, 120, 203],
+        [217, 125, 188],
+        [ 41,   0,   0],
+        [ 32,   0,   0]],
+
+       [[ 44,  55,  73],
+        [ 46,  63,  73],
+        [ 41,  66,  63],
+        [ 46,  57,  59],
+        [ 74,  50,  76],
+        [111,  47, 108],
+        [141,  35, 146],
+        [142,  27, 148],
+        [146,  52, 148],
+        [114,  55,  85],
+        [139, 130,  55],
+        [125, 147,  10],
+        [119, 155,   0],
+        [115, 158,  16],
+        [104, 140,  68],
+        [186, 213, 194],
+        [196, 209, 226],
+        [186, 190, 235],
+        [187, 187, 247],
+        [198, 197, 255],
+        [109, 105, 202],
+        [121, 113, 232],
+        [123, 108, 249],
+        [122,  91, 231],
+        [149,  99, 214],
+        [211, 141, 230],
+        [225, 133, 200],
+        [232, 126, 190],
+        [224, 118, 192],
+        [227, 132, 196],
+        [ 51,   0,  14],
+        [ 43,   0,   4]],
+
+       [[ 33,  57,  59],
+        [ 36,  62,  59],
+        [ 34,  66,  53],
+        [ 39,  58,  52],
+        [ 69,  52,  70],
+        [107,  50, 105],
+        [137,  36, 140],
+        [142,  27, 148],
+        [128,  30, 131],
+        [110,  49,  93],
+        [126, 120,  68],
+        [116, 146,  32],
+        [115, 160,  18],
+        [112, 150,  31],
+        [121, 131,  81],
+        [205, 200, 196],
+        [215, 206, 227],
+        [218, 206, 242],
+        [215, 207, 248],
+        [214, 206, 255],
+        [120, 113, 193],
+        [121, 110, 215],
+        [125, 106, 234],
+        [135, 105, 229],
+        [141,  97, 192],
+        [190, 133, 202],
+        [206, 133, 178],
+        [216, 135, 176],
+        [210, 132, 184],
+        [209, 139, 193],
+        [ 36,   0,  21],
+        [ 29,   0,  18]],
+
+       [[ 22,  75,  33],
+        [ 27,  79,  40],
+        [ 26,  77,  44],
+        [ 33,  65,  50],
+        [ 61,  57,  72],
+        [ 99,  50, 106],
+        [134,  32, 141],
+        [143,  19, 153],
+        [146,  29, 162],
+        [142,  57, 150],
+        [136, 108, 120],
+        [123, 131,  84],
+        [123, 141,  57],
+        [123, 124,  48],
+        [162, 121,  91],
+        [248, 192, 193],
+        [227, 185, 197],
+        [233, 201, 214],
+        [221, 199, 201],
+        [207, 192, 197],
+        [134, 126, 150],
+        [122, 114, 161],
+        [116, 105, 174],
+        [133, 116, 184],
+        [150, 127, 171],
+        [171, 143, 165],
+        [181, 149, 154],
+        [189, 157, 160],
+        [188, 156, 177],
+        [175, 152, 181],
+        [ 11,   0,  30],
+        [  1,   0,  27]],
+
+       [[ 58, 122,  61],
+        [ 61, 125,  64],
+        [ 60, 121,  64],
+        [ 66, 106,  71],
+        [ 92,  93,  97],
+        [129,  81, 133],
+        [165,  59, 170],
+        [174,  41, 184],
+        [172,  40, 185],
+        [151,  48, 165],
+        [102,  50, 112],
+        [ 82,  60,  73],
+        [ 91,  77,  50],
+        [ 94,  59,  27],
+        [134,  53,  50],
+        [199, 106, 114],
+        [193, 121, 124],
+        [186, 127, 121],
+        [173, 115, 101],
+        [184, 143, 121],
+        [179, 165, 139],
+        [192, 189, 170],
+        [181, 172, 175],
+        [180, 174, 176],
+        [168, 169, 155],
+        [150, 158, 134],
+        [134, 151, 119],
+        [125, 148, 120],
+        [123, 150, 133],
+        [121, 143, 140],
+        [  0,   4,  17],
+        [  0,   3,  26]],
+
+       [[ 61, 119,  61],
+        [ 60, 121,  54],
+        [ 60, 124,  38],
+        [ 71, 116,  47],
+        [ 96,  97,  79],
+        [127,  76, 119],
+        [164,  51, 167],
+        [181,  39, 183],
+        [181,  41, 172],
+        [164,  45, 161],
+        [118,  40, 139],
+        [100,  45, 113],
+        [106,  56,  85],
+        [124,  56,  71],
+        [140,  31,  60],
+        [224, 107, 126],
+        [212, 114, 105],
+        [213, 116,  97],
+        [223, 109,  99],
+        [206, 116,  89],
+        [205, 181, 109],
+        [185, 190, 100],
+        [192, 182, 110],
+        [188, 185, 116],
+        [170, 194, 118],
+        [112, 162,  89],
+        [104, 180, 118],
+        [ 87, 176, 120],
+        [ 76, 166, 105],
+        [ 98, 165, 121],
+        [  0,  20,   7],
+        [  0,   0,   5]],
+
+       [[ 61, 114,  72],
+        [ 61, 116,  59],
+        [ 63, 121,  37],
+        [ 77, 114,  44],
+        [100,  97,  78],
+        [128,  77, 120],
+        [161,  54, 168],
+        [178,  43, 182],
+        [183,  50, 169],
+        [174,  52, 163],
+        [135,  37, 158],
+        [120,  35, 139],
+        [120,  38, 104],
+        [135,  39,  87],
+        [151,  24,  77],
+        [231, 100, 132],
+        [223, 109,  98],
+        [227, 111,  86],
+        [240, 101,  94],
+        [220, 111,  82],
+        [210, 183,  92],
+        [186, 193,  79],
+        [195, 186,  85],
+        [189, 191,  94],
+        [161, 199,  98],
+        [ 94, 165,  71],
+        [ 80, 181, 105],
+        [ 76, 190, 118],
+        [ 72, 184, 100],
+        [ 91, 174, 104],
+        [  0,  13,   0],
+        [  0,   1,   0]],
+
+       [[ 59, 110,  91],
+        [ 65, 111,  82],
+        [ 73, 113,  63],
+        [ 86, 107,  68],
+        [106,  94,  98],
+        [127,  79, 131],
+        [149,  62, 169],
+        [163,  54, 179],
+        [163,  47, 154],
+        [164,  48, 155],
+        [138,  26, 154],
+        [134,  23, 144],
+        [136,  23, 111],
+        [149,  30,  98],
+        [162,  27,  94],
+        [231,  98, 141],
+        [223, 106,  99],
+        [226, 110,  87],
+        [235, 102,  95],
+        [214, 110,  85],
+        [208, 181, 102],
+        [184, 190,  92],
+        [189, 184, 103],
+        [181, 189, 112],
+        [167, 211, 126],
+        [102, 174,  90],
+        [ 81, 173,  98],
+        [ 83, 181, 104],
+        [ 86, 179,  88],
+        [102, 173,  95],
+        [  0,  14,   0],
+        [  1,  12,   0]],
+
+       [[ 88,  95,  88],
+        [ 94,  95,  81],
+        [104,  95,  64],
+        [114,  90,  66],
+        [124,  81,  88],
+        [133,  73, 111],
+        [138,  65, 138],
+        [143,  60, 142],
+        [155,  66, 132],
+        [163,  62, 142],
+        [144,  29, 148],
+        [151,  26, 154],
+        [152,  25, 130],
+        [160,  33, 124],
+        [162,  35, 124],
+        [204,  91, 157],
+        [200, 115, 138],
+        [199, 120, 125],
+        [207, 115, 130],
+        [190, 121, 114],
+        [196, 187, 128],
+        [180, 194, 115],
+        [186, 189, 122],
+        [182, 193, 125],
+        [145, 189, 102],
+        [115, 176,  81],
+        [104, 170,  80],
+        [105, 171,  74],
+        [110, 167,  60],
+        [124, 167,  75],
+        [  0,  12,   0],
+        [  0,   7,   0]],
+
+       [[194, 115, 111],
+        [198, 114, 103],
+        [207, 113,  88],
+        [210, 112,  87],
+        [204, 111,  96],
+        [192, 111, 108],
+        [178, 113, 121],
+        [171, 114, 123],
+        [171, 111, 111],
+        [175,  99, 127],
+        [159,  49, 144],
+        [170,  44, 169],
+        [167,  39, 158],
+        [164,  43, 159],
+        [146,  43, 160],
+        [148,  77, 181],
+        [108,  84, 162],
+        [ 99,  93, 155],
+        [107,  89, 147],
+        [100,  94, 122],
+        [124, 153, 122],
+        [121, 157,  96],
+        [135, 148,  92],
+        [139, 152,  82],
+        [142, 179,  76],
+        [170, 211,  91],
+        [191, 217,  92],
+        [200, 212,  84],
+        [202, 206,  70],
+        [207, 207,  93],
+        [ 14,  19,   0],
+        [  2,   8,   0]],
+
+       [[230,  98,  93],
+        [234,  97,  87],
+        [239,  97,  77],
+        [236,  97,  74],
+        [220, 101,  79],
+        [197, 105,  80],
+        [170, 113,  84],
+        [158, 117,  85],
+        [170, 127,  92],
+        [177, 112, 118],
+        [159,  53, 143],
+        [180,  50, 184],
+        [175,  44, 182],
+        [167,  48, 192],
+        [143,  51, 198],
+        [117,  69, 205],
+        [ 81,  93, 205],
+        [ 66, 105, 198],
+        [ 73, 105, 182],
+        [ 73, 108, 148],
+        [113, 160, 142],
+        [117, 161, 112],
+        [134, 154, 103],
+        [140, 158,  84],
+        [122, 156,  44],
+        [185, 213,  77],
+        [214, 213,  73],
+        [223, 200,  58],
+        [225, 192,  51],
+        [224, 201,  89],
+        [  4,   7,   0],
+        [  0,   8,   0]],
+
+       [[245,  93,  82],
+        [247,  93,  81],
+        [250,  92,  80],
+        [242,  95,  79],
+        [222, 101,  82],
+        [196, 109,  81],
+        [168, 119,  79],
+        [155, 122,  79],
+        [158, 120,  81],
+        [169, 106, 115],
+        [156,  45, 148],
+        [179,  44, 199],
+        [173,  36, 201],
+        [166,  44, 215],
+        [148,  53, 233],
+        [113,  66, 232],
+        [ 73,  92, 220],
+        [ 54, 108, 204],
+        [ 56, 110, 184],
+        [ 59, 113, 147],
+        [111, 160, 139],
+        [119, 159, 109],
+        [133, 153, 100],
+        [137, 158,  83],
+        [133, 170,  54],
+        [198, 222,  84],
+        [220, 203,  63],
+        [231, 189,  53],
+        [235, 183,  61],
+        [229, 197, 110],
+        [  0,   8,   0],
+        [  0,  18,  21]],
+
+       [[222, 106,  57],
+        [223, 107,  60],
+        [225, 106,  66],
+        [218, 109,  70],
+        [202, 115,  72],
+        [182, 120,  69],
+        [159, 128,  64],
+        [150, 129,  64],
+        [158, 129,  71],
+        [170, 118, 107],
+        [150,  59, 138],
+        [167,  58, 185],
+        [152,  46, 178],
+        [142,  54, 192],
+        [128,  68, 216],
+        [ 95,  76, 218],
+        [ 60,  99, 218],
+        [ 44, 113, 208],
+        [ 42, 116, 187],
+        [ 49, 117, 152],
+        [111, 159, 147],
+        [124, 154, 116],
+        [135, 149, 113],
+        [142, 153,  93],
+        [137, 162,  61],
+        [205, 209,  86],
+        [230, 185,  58],
+        [255, 183,  62],
+        [255, 182,  73],
+        [246, 190, 116],
+        [  0,   5,   0],
+        [  0,  12,  25]],
+
+       [[167, 145,  26],
+        [163, 140,  28],
+        [162, 137,  37],
+        [162, 137,  45],
+        [153, 136,  46],
+        [145, 134,  42],
+        [144, 140,  40],
+        [150, 146,  46],
+        [156, 142,  45],
+        [153, 122,  65],
+        [134,  81,  99],
+        [130,  76, 126],
+        [123,  85, 126],
+        [105,  89, 128],
+        [ 92, 102, 153],
+        [ 60,  97, 165],
+        [ 50, 114, 202],
+        [ 31, 115, 205],
+        [ 28, 119, 189],
+        [ 54, 131, 173],
+        [105, 144, 151],
+        [138, 151, 141],
+        [147, 146, 141],
+        [149, 143, 117],
+        [160, 159,  92],
+        [217, 188,  96],
+        [255, 176,  77],
+        [255, 179,  77],
+        [255, 162,  64],
+        [255, 159,  89],
+        [ 31,   6,   0],
+        [  0,   3,   5]],
+
+       [[119, 197,  23],
+        [121, 197,  29],
+        [124, 193,  42],
+        [132, 194,  49],
+        [145, 196,  55],
+        [161, 203,  59],
+        [178, 206,  59],
+        [191, 207,  59],
+        [196, 199,  58],
+        [187, 183,  75],
+        [153, 145,  99],
+        [135, 138, 117],
+        [118, 148, 110],
+        [ 96, 152, 115],
+        [ 78, 155, 139],
+        [ 46, 135, 153],
+        [ 33, 125, 192],
+        [ 26, 121, 205],
+        [ 21, 122, 192],
+        [ 43, 117, 166],
+        [ 87, 105, 127],
+        [114,  97, 107],
+        [121,  90, 105],
+        [126,  86,  84],
+        [132,  88,  49],
+        [175, 104,  42],
+        [205,  78,   9],
+        [231,  73,   0],
+        [230,  69,   0],
+        [219,  95,  35],
+        [ 34,   0,   0],
+        [  7,   3,   2]],
+
+       [[ 41, 226,  10],
+        [ 46, 226,  15],
+        [ 51, 219,  20],
+        [ 62, 212,  16],
+        [ 93, 215,  16],
+        [131, 224,  22],
+        [164, 223,  21],
+        [177, 214,  13],
+        [191, 217,  22],
+        [180, 207,  42],
+        [131, 173,  63],
+        [102, 168,  78],
+        [ 82, 184,  82],
+        [ 64, 193, 101],
+        [ 45, 188, 134],
+        [ 13, 152, 147],
+        [ 28, 143, 198],
+        [ 36, 139, 218],
+        [ 37, 140, 209],
+        [ 62, 125, 178],
+        [111,  96, 127],
+        [140,  78, 101],
+        [151,  73,  97],
+        [164,  72,  83],
+        [167,  65,  50],
+        [210,  83,  50],
+        [234,  64,  28],
+        [252,  67,  23],
+        [238,  63,   8],
+        [210,  82,  37],
+        [ 34,   0,   0],
+        [  1,   0,   4]],
+
+       [[ 14, 255,  23],
+        [ 22, 255,  27],
+        [ 27, 248,  23],
+        [ 38, 234,  10],
+        [ 77, 234,   5],
+        [127, 245,  13],
+        [163, 239,   7],
+        [176, 225,   0],
+        [178, 216,   0],
+        [166, 209,  15],
+        [113, 177,  29],
+        [ 78, 171,  41],
+        [ 62, 189,  50],
+        [ 53, 200,  83],
+        [ 38, 191, 127],
+        [  2, 149, 143],
+        [  4, 133, 190],
+        [ 12, 131, 213],
+        [ 20, 132, 206],
+        [ 52, 116, 177],
+        [113,  85, 125],
+        [150,  67,  95],
+        [164,  66,  91],
+        [181,  66,  81],
+        [194,  63,  55],
+        [226,  71,  51],
+        [239,  52,  33],
+        [250,  56,  29],
+        [234,  57,  15],
+        [203,  75,  38],
+        [ 42,   0,   0],
+        [ 10,   2,   0]],
+
+       [[  0, 251,  19],
+        [  5, 252,  23],
+        [ 15, 241,  17],
+        [ 29, 228,   1],
+        [ 70, 231,   0],
+        [122, 242,   4],
+        [159, 237,   3],
+        [171, 222,   0],
+        [186, 228,   6],
+        [175, 222,  22],
+        [126, 188,  29],
+        [ 93, 174,  33],
+        [ 80, 184,  37],
+        [ 76, 189,  73],
+        [ 69, 175, 127],
+        [ 25, 138, 154],
+        [  8, 140, 212],
+        [  1, 140, 235],
+        [  8, 138, 224],
+        [ 44, 121, 191],
+        [113,  91, 137],
+        [150,  74, 102],
+        [160,  72,  88],
+        [174,  68,  70],
+        [195,  65,  51],
+        [224,  69,  49],
+        [235,  53,  40],
+        [248,  63,  43],
+        [230,  67,  26],
+        [192,  70,  29],
+        [ 46,   0,   0],
+        [ 15,   0,   0]],
+
+       [[ 37, 234,  58],
+        [ 45, 233,  60],
+        [ 55, 225,  58],
+        [ 70, 216,  47],
+        [101, 215,  39],
+        [137, 220,  44],
+        [163, 216,  48],
+        [170, 207,  42],
+        [170, 205,  43],
+        [163, 203,  55],
+        [125, 176,  55],
+        [103, 168,  52],
+        [ 96, 173,  43],
+        [ 94, 170,  70],
+        [ 99, 159, 133],
+        [ 66, 133, 160],
+        [ 33, 131, 192],
+        [ 19, 133, 206],
+        [ 17, 130, 200],
+        [ 48, 117, 174],
+        [114,  93, 126],
+        [144,  80,  96],
+        [141,  81,  83],
+        [146,  78,  69],
+        [166,  73,  58],
+        [191,  77,  66],
+        [204,  68,  70],
+        [219,  81,  78],
+        [205,  83,  59],
+        [168,  79,  47],
+        [ 50,  13,   0],
+        [ 10,   1,   0]],
+
+       [[  0,  28,   0],
+        [  0,  25,   0],
+        [  0,  19,   0],
+        [  0,  15,   0],
+        [  0,  10,   0],
+        [  0,   7,   0],
+        [  5,   4,   0],
+        [  5,   6,   0],
+        [  1,  13,   0],
+        [  0,  21,   0],
+        [  0,  15,   0],
+        [  0,  19,   0],
+        [  0,  24,   0],
+        [  0,  20,   0],
+        [  0,   8,   6],
+        [  0,   1,  30],
+        [  0,   5,  28],
+        [  0,  10,  32],
+        [  0,  15,  41],
+        [  0,   9,  28],
+        [ 18,   0,   0],
+        [ 31,   0,   0],
+        [ 10,   0,   0],
+        [  4,   1,   0],
+        [ 18,   0,   0],
+        [ 27,   0,   0],
+        [ 32,   0,   7],
+        [ 36,   0,   5],
+        [ 35,   0,   0],
+        [ 31,   1,   0],
+        [  0,   1,   0],
+        [  0,   5,   7]],
+
+       [[  0,   2,   0],
+        [  3,   0,   0],
+        [ 10,   0,   4],
+        [ 17,   0,  10],
+        [ 22,   0,  11],
+        [ 18,   0,  14],
+        [ 15,   0,  25],
+        [  9,   0,  29],
+        [  0,   0,  21],
+        [  0,   5,  18],
+        [  0,   8,  11],
+        [  0,  16,   0],
+        [  0,  20,   0],
+        [  0,  13,   0],
+        [  7,   4,  15],
+        [  8,   0,  25],
+        [  6,   0,   2],
+        [  0,   4,   0],
+        [  0,  13,  16],
+        [  0,   8,   9],
+        [ 22,   0,   0],
+        [ 25,   0,   0],
+        [  0,   7,   0],
+        [  0,  12,   0],
+        [  0,   7,   0],
+        [  0,   5,  15],
+        [  1,   0,  32],
+        [ 10,   0,  33],
+        [  9,   0,  10],
+        [  8,   6,  11],
+        [  0,   5,  14],
+        [  0,  16,  27]]], dtype=np.uint8),
+)
+
+image_decoder_decode_jpeg_grayscale = ImageData(
+    image_decoder_decode_jpeg_rgb.data,
+    np.array([[[141], [142], [143], [142], [149], [209], [214], [209], [211], [207], [202], [206], [209], [200], [205], [228], [231], [234], [229], [239], [ 48], [ 63], [ 51], [ 61], [ 45], [124], [112], [115], [107], [119], [  5], [  6]],[[144], [144], [144], [141], [146], [203], [208], [203], [215], [211], [205], [208], [210], [202], [208], [233], [227], [228], [235], [227], [ 59], [ 53], [ 60], [ 61], [ 65], [122], [103], [118], [119], [115], [  5], [  4]],[[147], [146], [145], [144], [148], [205], [211], [209], [211], [207], [201], [201], [204], [197], [204], [227], [232], [231], [233], [224], [ 60], [ 51], [ 56], [ 56], [ 58], [118], [110], [117], [122], [114], [  9], [  8]],[[140], [139], [141], [144], [149], [205], [211], [213], [214], [213], [206], [206], [208], [203], [209], [230], [231], [237], [223], [228], [ 59], [ 69], [ 52], [ 61], [ 39], [115], [124], [111], [113], [117], [  9], [  9]],[[147], [146], [148], [150], [151], [201], [204], [206], [207], [207], [199], [197], [200], [202], [207], [226], [229], [241], [237], [221], [ 68], [ 53], [ 40], [ 61], [ 76], [112], [119], [102], [108], [115], [  5], [  4]],[[ 55], [ 52], [ 53], [ 52], [ 46], [ 86], [ 84], [ 87], [ 87], [ 91], [ 88], [ 89], [ 93], [ 88], [ 90], [105], [109], [ 86], [ 89], [112], [169], [192], [196], [172], [154], [109], [ 98], [ 98], [109], [106], [  3], [  3]],[[ 56], [ 53], [ 54], [ 54], [ 45], [ 80], [ 75], [ 77], [ 80], [ 88], [ 92], [ 95], [100], [ 95], [ 93], [104], [ 90], [ 97], [118], [102], [175], [159], [180], [187], [189], [102], [ 95], [100], [102], [ 98], [  3], [  3]],[[ 51], [ 49], [ 54], [ 57], [ 50], [ 85], [ 80], [ 81], [ 71], [ 83], [ 90], [ 95], [ 97], [ 94], [ 90], [ 99], [101], [103], [ 89], [ 92], [188], [190], [177], [179], [175], [ 96], [109], [103], [ 89], [ 96], [  8], [  4]],[[ 53], [ 56], [ 54], [ 51], [ 58], [ 73], [ 81], [ 79], [ 75], [ 81], [ 98], [100], [ 88], [ 90], [ 98], [101], [100], [106], [ 94], [ 96], [183], [185], [173], [178], [186], [102], [104], [ 92], [106], [ 87], [  7], [ 11]],[[ 47], [ 51], [ 50], [ 47], [ 55], [ 71], [ 79], [ 77], [ 81], [ 70], [ 91], [ 96], [ 94], [100], [ 92], [102], [ 94], [ 99], [ 98], [112], [166], [179], [178], [184], [158], [106], [109], [ 99], [109], [ 97], [  2], [  6]],[[ 54], [ 58], [ 57], [ 54], [ 61], [ 76], [ 83], [ 81], [ 84], [ 79], [127], [128], [120], [129], [132], [186], [206], [207], [204], [190], [138], [125], [121], [123], [151], [152], [163], [164], [165], [155], [ 17], [ 10]],[[ 54], [ 57], [ 56], [ 52], [ 57], [ 71], [ 76], [ 73], [ 71], [ 67], [128], [124], [114], [121], [129], [218], [207], [206], [211], [211], [121], [122], [128], [127], [119], [157], [166], [168], [162], [160], [ 12], [ 10]],[[ 54], [ 59], [ 58], [ 54], [ 60], [ 73], [ 79], [ 75], [ 91], [ 76], [124], [125], [127], [129], [121], [203], [207], [194], [194], [204], [117], [129], [129], [116], [127], [172], [168], [165], [158], [168], [ 17], [ 13]],[[ 50], [ 54], [ 55], [ 52], [ 59], [ 73], [ 78], [ 75], [ 71], [ 72], [116], [124], [130], [125], [122], [201], [211], [214], [214], [214], [124], [125], [126], [128], [121], [158], [160], [164], [161], [166], [ 13], [ 11]],[[ 54], [ 59], [ 58], [ 54], [ 60], [ 71], [ 75], [ 71], [ 79], [ 93], [118], [123], [126], [115], [130], [209], [199], [212], [206], [197], [131], [122], [116], [129], [139], [154], [159], [167], [168], [162], [  7], [  3]],[[ 96], [ 99], [ 96], [ 90], [ 93], [101], [103], [ 97], [ 96], [ 92], [ 73], [ 68], [ 78], [ 66], [ 77], [135], [143], [144], [131], [153], [166], [188], [175], [176], [167], [153], [142], [138], [140], [136], [  4], [  5]],[[ 95], [ 95], [ 95], [ 95], [ 95], [ 96], [ 98], [ 98], [ 98], [ 94], [ 75], [ 69], [ 74], [ 78], [ 67], [144], [142], [143], [142], [140], [180], [178], [177], [178], [178], [139], [150], [143], [132], [140], [ 13], [  1]],[[ 93], [ 93], [ 94], [ 95], [ 96], [ 97], [ 99], [ 99], [103], [101], [ 80], [ 72], [ 70], [ 73], [ 68], [143], [142], [143], [142], [140], [181], [178], [177], [179], [176], [133], [142], [148], [141], [141], [  8], [  1]],[[ 93], [ 94], [ 95], [ 96], [ 98], [ 99], [100], [101], [ 94], [ 95], [ 74], [ 70], [ 67], [ 73], [ 75], [143], [140], [142], [141], [138], [180], [177], [176], [178], [188], [143], [137], [143], [141], [143], [  8], [  7]],[[ 92], [ 93], [ 94], [ 94], [ 95], [ 95], [ 95], [ 94], [100], [101], [ 77], [ 78], [ 75], [ 81], [ 83], [132], [143], [144], [144], [141], [183], [181], [180], [182], [166], [147], [140], [140], [138], [144], [  7], [  4]],[[138], [138], [138], [138], [137], [135], [133], [132], [129], [125], [ 93], [ 96], [ 91], [ 92], [ 87], [110], [100], [102], [101], [ 99], [141], [139], [138], [140], [156], [185], [195], [194], [189], [194], [ 15], [  5]],[[137], [137], [137], [136], [134], [130], [127], [126], [136], [132], [ 95], [104], [ 99], [100], [ 95], [ 99], [102], [104], [104], [102], [144], [142], [142], [144], [133], [189], [197], [191], [186], [195], [  5], [  5]],[[137], [138], [138], [137], [135], [132], [129], [127], [127], [126], [ 90], [102], [ 96], [100], [102], [ 99], [101], [103], [102], [101], [143], [141], [141], [143], [146], [199], [192], [186], [185], [197], [  5], [ 13]],[[135], [136], [137], [137], [136], [133], [130], [128], [131], [132], [ 95], [105], [ 93], [ 96], [103], [ 98], [101], [103], [102], [101], [143], [141], [141], [143], [143], [194], [184], [191], [191], [198], [  3], [ 10]],[[138], [134], [133], [134], [131], [127], [130], [136], [135], [125], [ 99], [ 98], [101], [ 98], [105], [ 94], [105], [100], [100], [113], [133], [146], [146], [142], [152], [186], [188], [190], [179], [180], [ 13], [  2]],[[154], [155], [155], [159], [165], [174], [181], [185], [182], [172], [142], [135], [135], [131], [130], [110], [105], [102], [100], [100], [102], [103], [101], [ 98], [ 97], [118], [108], [112], [109], [125], [ 10], [  4]],[[146], [148], [146], [145], [156], [173], [182], [180], [187], [180], [148], [138], [142], [144], [139], [110], [115], [117], [117], [112], [104], [ 99], [ 99], [101], [ 94], [117], [111], [117], [109], [115], [ 10], [  1]],[[156], [159], [156], [150], [161], [183], [190], [185], [180], [174], [141], [128], [135], [143], [138], [104], [101], [105], [107], [104], [ 98], [ 95], [ 98], [102], [101], [115], [106], [111], [105], [109], [ 13], [  4]],[[150], [152], [148], [143], [157], [179], [187], [181], [190], [185], [151], [134], [136], [142], [138], [106], [109], [109], [109], [106], [103], [100], [100], [100], [102], [113], [106], [116], [111], [102], [ 14], [  4]],[[155], [157], [155], [153], [161], [175], [181], [177], [176], [174], [147], [135], [135], [136], [138], [116], [109], [107], [104], [103], [103], [101], [ 99], [ 97], [ 99], [110], [109], [122], [117], [102], [ 23], [  4]],[[ 16], [ 15], [ 11], [  9], [  6], [  4], [  4], [  5], [  8], [ 12], [  9], [ 11], [ 14], [ 12], [  5], [  4], [  6], [ 10], [ 13], [  8], [  5], [  9], [  3], [  2], [  5], [  8], [ 10], [ 11], [ 10], [ 10], [  1], [  4]],[[  1], [  1], [  3], [  6], [  8], [  7], [  7], [  6], [  2], [  5], [  6], [  9], [ 12], [  8], [  6], [  5], [  2], [  2], [  9], [  6], [  7], [  7], [  4], [  7], [  4], [  5], [  4], [  7], [  4], [  7], [  5], [ 12]]], dtype=np.uint8),
+)
+
+image_decoder_decode_jpeg_bgr = ImageData(
+    image_decoder_decode_jpeg_rgb.data,
+    np.array([[[255,  73, 230],
+        [255,  76, 227],
+        [255,  81, 222],
+        [206,  95, 211],
+        [142, 123, 204],
+        [133, 202, 251],
+        [ 72, 226, 245],
+        [ 34, 230, 234],
+        [ 32, 234, 235],
+        [ 32, 229, 231],
+        [ 37, 221, 227],
+        [ 45, 224, 233],
+        [ 42, 227, 237],
+        [ 32, 216, 232],
+        [ 35, 219, 243],
+        [ 63, 247, 255],
+        [ 71, 255, 246],
+        [ 83, 255, 249],
+        [ 68, 253, 243],
+        [134, 251, 255],
+        [ 46,  23,  97],
+        [121,  19, 127],
+        [124,   0, 123],
+        [128,  19, 118],
+        [ 82,  28,  63],
+        [143, 133,  99],
+        [128, 146,  39],
+        [110, 162,  24],
+        [ 64, 157,  26],
+        [ 76, 154,  66],
+        [  0,   9,   0],
+        [  9,   0,  15]],
+
+       [[255,  77, 232],
+        [255,  79, 228],
+        [254,  83, 221],
+        [208,  93, 210],
+        [146, 117, 202],
+        [137, 193, 248],
+        [ 77, 216, 242],
+        [ 35, 222, 230],
+        [ 40, 237, 239],
+        [ 36, 233, 235],
+        [ 37, 225, 230],
+        [ 41, 227, 235],
+        [ 42, 228, 238],
+        [ 34, 220, 230],
+        [ 41, 225, 237],
+        [ 70, 253, 255],
+        [ 68, 250, 242],
+        [ 70, 251, 242],
+        [ 79, 255, 255],
+        [124, 232, 255],
+        [ 57,  32, 112],
+        [108,   9, 119],
+        [129,  10, 132],
+        [121,  21, 117],
+        [ 95,  50,  83],
+        [134, 132,  98],
+        [108, 137,  34],
+        [106, 165,  31],
+        [ 75, 168,  40],
+        [ 71, 151,  62],
+        [  0,   9,   0],
+        [  5,   0,  11]],
+
+       [[255,  81, 234],
+        [255,  82, 229],
+        [250,  86, 221],
+        [218,  95, 211],
+        [164, 115, 207],
+        [161, 189, 254],
+        [101, 213, 249],
+        [ 57, 224, 238],
+        [ 41, 232, 235],
+        [ 30, 229, 231],
+        [ 26, 221, 229],
+        [ 26, 221, 229],
+        [ 29, 225, 231],
+        [ 27, 219, 218],
+        [ 45, 229, 215],
+        [ 71, 252, 237],
+        [ 76, 252, 252],
+        [ 80, 248, 255],
+        [ 94, 249, 255],
+        [135, 225, 255],
+        [ 58,  30, 120],
+        [101,   6, 120],
+        [116,   9, 126],
+        [104,  20, 109],
+        [ 72,  47,  75],
+        [113, 130,  97],
+        [ 98, 144,  48],
+        [ 89, 163,  37],
+        [ 72, 169,  48],
+        [ 66, 151,  59],
+        [  0,  16,   0],
+        [  0,  13,   0]],
+
+       [[236,  83, 216],
+        [238,  83, 211],
+        [246,  88, 205],
+        [226,  98, 203],
+        [181, 114, 205],
+        [178, 184, 255],
+        [120, 207, 255],
+        [ 77, 220, 251],
+        [ 56, 228, 246],
+        [ 46, 228, 247],
+        [ 43, 216, 248],
+        [ 45, 214, 251],
+        [ 50, 217, 250],
+        [ 51, 217, 234],
+        [ 69, 232, 217],
+        [ 95, 255, 234],
+        [ 93, 251, 245],
+        [104, 254, 255],
+        [101, 232, 252],
+        [153, 228, 255],
+        [ 52,  34, 111],
+        [103,  33, 126],
+        [ 93,  15, 109],
+        [ 91,  34, 103],
+        [ 39,  33,  52],
+        [ 99, 127,  98],
+        [106, 152,  75],
+        [ 86, 148,  48],
+        [ 78, 151,  53],
+        [ 83, 148,  69],
+        [  0,  16,   0],
+        [  0,  15,   0]],
+
+       [[227, 104, 202],
+        [235, 103, 196],
+        [253, 106, 191],
+        [242, 111, 192],
+        [199, 117, 200],
+        [192, 176, 253],
+        [127, 193, 255],
+        [ 85, 204, 255],
+        [ 67, 210, 255],
+        [ 67, 209, 255],
+        [ 76, 195, 255],
+        [ 82, 189, 255],
+        [ 88, 193, 255],
+        [ 88, 197, 255],
+        [ 97, 217, 229],
+        [118, 246, 229],
+        [123, 250, 228],
+        [148, 255, 249],
+        [145, 251, 245],
+        [155, 224, 239],
+        [ 49,  57,  97],
+        [ 58,  35,  87],
+        [ 52,  21,  72],
+        [ 68,  48,  83],
+        [ 65,  76,  80],
+        [ 96, 122,  99],
+        [110, 136,  88],
+        [ 98, 123,  63],
+        [108, 127,  70],
+        [115, 130,  86],
+        [  0,   9,   0],
+        [  0,   7,   0]],
+
+       [[128,  27,  83],
+        [137,  23,  76],
+        [161,  23,  70],
+        [151,  22,  73],
+        [103,  16,  84],
+        [ 86,  60, 138],
+        [ 13,  66, 146],
+        [  0,  72, 150],
+        [  0,  73, 146],
+        [  0,  71, 164],
+        [  0,  55, 186],
+        [ 15,  48, 198],
+        [ 24,  51, 202],
+        [ 19,  56, 176],
+        [ 16,  81, 136],
+        [ 31, 114, 116],
+        [ 38, 131,  94],
+        [ 17, 112,  62],
+        [ 23, 109,  75],
+        [ 55, 125, 108],
+        [128, 175, 173],
+        [162, 194, 200],
+        [175, 197, 203],
+        [153, 174, 175],
+        [131, 161, 150],
+        [ 95, 117,  98],
+        [102, 105,  83],
+        [117, 103,  80],
+        [143, 111,  92],
+        [138, 107,  92],
+        [ 12,   3,   0],
+        [  2,   5,   0]],
+
+       [[132,  43,  52],
+        [142,  40,  45],
+        [167,  38,  41],
+        [159,  35,  51],
+        [103,  21,  70],
+        [ 82,  55, 129],
+        [  6,  53, 144],
+        [  0,  53, 155],
+        [  0,  53, 163],
+        [ 10,  52, 189],
+        [ 53,  32, 224],
+        [ 77,  23, 242],
+        [ 88,  25, 251],
+        [ 77,  33, 223],
+        [ 61,  59, 172],
+        [ 65,  98, 131],
+        [ 55, 111,  62],
+        [ 58, 130,  47],
+        [ 72, 146,  80],
+        [ 44, 128,  73],
+        [104, 200, 153],
+        [ 86, 183, 139],
+        [120, 202, 160],
+        [139, 206, 169],
+        [155, 203, 174],
+        [ 91, 109,  92],
+        [116,  92,  92],
+        [148,  90, 101],
+        [171,  88, 103],
+        [160,  87,  97],
+        [ 23,   0,   0],
+        [  4,   4,   0]],
+
+       [[140,  47,  26],
+        [146,  44,  21],
+        [169,  48,  22],
+        [158,  47,  39],
+        [103,  31,  67],
+        [ 83,  62, 131],
+        [ 14,  56, 153],
+        [  0,  52, 170],
+        [  0,  37, 164],
+        [ 25,  37, 195],
+        [ 71,  21, 233],
+        [100,  13, 255],
+        [111,  14, 255],
+        [103,  20, 236],
+        [ 88,  45, 180],
+        [ 92,  84, 131],
+        [ 92, 118,  70],
+        [ 85, 136,  46],
+        [ 59, 118,  43],
+        [ 41, 122,  53],
+        [106, 222, 153],
+        [100, 225, 156],
+        [101, 209, 143],
+        [122, 205, 150],
+        [141, 192, 155],
+        [ 91, 101,  89],
+        [137,  98, 119],
+        [161,  83, 120],
+        [174,  65, 104],
+        [167,  78, 104],
+        [ 27,   6,   4],
+        [  0,   7,   0]],
+
+       [[161,  50,  18],
+        [164,  54,  20],
+        [166,  53,  13],
+        [140,  47,  26],
+        [ 99,  44,  69],
+        [ 64,  52, 118],
+        [ 23,  55, 155],
+        [  0,  48, 170],
+        [  2,  41, 169],
+        [ 26,  36, 190],
+        [ 71,  35, 233],
+        [ 91,  26, 249],
+        [ 92,  10, 239],
+        [102,  23, 218],
+        [117,  54, 177],
+        [119,  83, 129],
+        [105, 112,  75],
+        [101, 131,  58],
+        [ 78, 116,  56],
+        [ 57, 120,  64],
+        [110, 214, 151],
+        [103, 217, 153],
+        [109, 203, 138],
+        [134, 202, 147],
+        [163, 199, 169],
+        [104, 102, 102],
+        [132,  88, 124],
+        [147,  67, 120],
+        [184,  78, 131],
+        [147,  68, 101],
+        [  7,   9,   3],
+        [  0,  18,   0]],
+
+       [[136,  46,  15],
+        [138,  52,  16],
+        [135,  53,  11],
+        [114,  46,  23],
+        [ 89,  43,  66],
+        [ 76,  48, 114],
+        [ 60,  46, 151],
+        [ 45,  39, 164],
+        [ 51,  43, 167],
+        [ 38,  28, 164],
+        [ 54,  43, 200],
+        [ 59,  43, 214],
+        [ 59,  42, 210],
+        [ 79,  56, 195],
+        [ 94,  65, 144],
+        [114,  93, 115],
+        [106, 103,  72],
+        [108, 116,  63],
+        [103, 111,  70],
+        [103, 127,  87],
+        [129, 187, 139],
+        [138, 201, 151],
+        [155, 198, 147],
+        [177, 198, 160],
+        [162, 162, 150],
+        [124,  97, 117],
+        [141,  86, 143],
+        [147,  68, 142],
+        [176,  76, 148],
+        [145,  74, 124],
+        [  0,   0,   6],
+        [  0,  10,   0]],
+
+       [[ 88,  57,  36],
+        [ 92,  62,  37],
+        [ 91,  65,  29],
+        [ 88,  55,  39],
+        [ 95,  47,  76],
+        [115,  47, 118],
+        [134,  39, 150],
+        [132,  32, 158],
+        [123,  41, 154],
+        [ 86,  43, 146],
+        [ 79, 101, 196],
+        [ 45, 111, 194],
+        [ 17, 109, 180],
+        [ 37, 126, 170],
+        [ 77, 138, 140],
+        [165, 197, 173],
+        [215, 215, 185],
+        [235, 214, 183],
+        [239, 206, 186],
+        [225, 192, 173],
+        [165, 142, 120],
+        [157, 128, 107],
+        [171, 121, 101],
+        [178, 118, 112],
+        [199, 138, 158],
+        [195, 129, 180],
+        [198, 130, 215],
+        [203, 125, 226],
+        [216, 126, 222],
+        [189, 125, 201],
+        [  3,   6,  44],
+        [  0,   5,  23]],
+
+       [[ 65,  58,  43],
+        [ 66,  62,  43],
+        [ 63,  65,  36],
+        [ 64,  55,  42],
+        [ 84,  44,  72],
+        [121,  41, 112],
+        [156,  28, 140],
+        [158,  21, 143],
+        [140,  28, 130],
+        [ 86,  39, 115],
+        [ 70, 121, 164],
+        [ 14, 132, 151],
+        [  0, 127, 131],
+        [  0, 142, 127],
+        [ 55, 151, 115],
+        [190, 235, 196],
+        [218, 214, 189],
+        [245, 206, 192],
+        [255, 208, 201],
+        [255, 207, 202],
+        [188, 114, 110],
+        [202, 113, 109],
+        [225, 115, 117],
+        [224, 109, 126],
+        [195,  95, 137],
+        [212, 127, 195],
+        [201, 129, 225],
+        [200, 127, 237],
+        [203, 120, 229],
+        [188, 125, 217],
+        [  0,   0,  41],
+        [  0,   0,  32]],
+
+       [[ 73,  55,  44],
+        [ 73,  63,  46],
+        [ 63,  66,  41],
+        [ 59,  57,  46],
+        [ 76,  50,  74],
+        [108,  47, 111],
+        [146,  35, 141],
+        [148,  27, 142],
+        [148,  52, 146],
+        [ 85,  55, 114],
+        [ 55, 130, 139],
+        [ 10, 147, 125],
+        [  0, 155, 119],
+        [ 16, 158, 115],
+        [ 68, 140, 104],
+        [194, 213, 186],
+        [226, 209, 196],
+        [235, 190, 186],
+        [247, 187, 187],
+        [255, 197, 198],
+        [202, 105, 109],
+        [232, 113, 121],
+        [249, 108, 123],
+        [231,  91, 122],
+        [214,  99, 149],
+        [230, 141, 211],
+        [200, 133, 225],
+        [190, 126, 232],
+        [192, 118, 224],
+        [196, 132, 227],
+        [ 14,   0,  51],
+        [  4,   0,  43]],
+
+       [[ 59,  57,  33],
+        [ 59,  62,  36],
+        [ 53,  66,  34],
+        [ 52,  58,  39],
+        [ 70,  52,  69],
+        [105,  50, 107],
+        [140,  36, 137],
+        [148,  27, 142],
+        [131,  30, 128],
+        [ 93,  49, 110],
+        [ 68, 120, 126],
+        [ 32, 146, 116],
+        [ 18, 160, 115],
+        [ 31, 150, 112],
+        [ 81, 131, 121],
+        [196, 200, 205],
+        [227, 206, 215],
+        [242, 206, 218],
+        [248, 207, 215],
+        [255, 206, 214],
+        [193, 113, 120],
+        [215, 110, 121],
+        [234, 106, 125],
+        [229, 105, 135],
+        [192,  97, 141],
+        [202, 133, 190],
+        [178, 133, 206],
+        [176, 135, 216],
+        [184, 132, 210],
+        [193, 139, 209],
+        [ 21,   0,  36],
+        [ 18,   0,  29]],
+
+       [[ 33,  75,  22],
+        [ 40,  79,  27],
+        [ 44,  77,  26],
+        [ 50,  65,  33],
+        [ 72,  57,  61],
+        [106,  50,  99],
+        [141,  32, 134],
+        [153,  19, 143],
+        [162,  29, 146],
+        [150,  57, 142],
+        [120, 108, 136],
+        [ 84, 131, 123],
+        [ 57, 141, 123],
+        [ 48, 124, 123],
+        [ 91, 121, 162],
+        [193, 192, 248],
+        [197, 185, 227],
+        [214, 201, 233],
+        [201, 199, 221],
+        [197, 192, 207],
+        [150, 126, 134],
+        [161, 114, 122],
+        [174, 105, 116],
+        [184, 116, 133],
+        [171, 127, 150],
+        [165, 143, 171],
+        [154, 149, 181],
+        [160, 157, 189],
+        [177, 156, 188],
+        [181, 152, 175],
+        [ 30,   0,  11],
+        [ 27,   0,   1]],
+
+       [[ 61, 122,  58],
+        [ 64, 125,  61],
+        [ 64, 121,  60],
+        [ 71, 106,  66],
+        [ 97,  93,  92],
+        [133,  81, 129],
+        [170,  59, 165],
+        [184,  41, 174],
+        [185,  40, 172],
+        [165,  48, 151],
+        [112,  50, 102],
+        [ 73,  60,  82],
+        [ 50,  77,  91],
+        [ 27,  59,  94],
+        [ 50,  53, 134],
+        [114, 106, 199],
+        [124, 121, 193],
+        [121, 127, 186],
+        [101, 115, 173],
+        [121, 143, 184],
+        [139, 165, 179],
+        [170, 189, 192],
+        [175, 172, 181],
+        [176, 174, 180],
+        [155, 169, 168],
+        [134, 158, 150],
+        [119, 151, 134],
+        [120, 148, 125],
+        [133, 150, 123],
+        [140, 143, 121],
+        [ 17,   4,   0],
+        [ 26,   3,   0]],
+
+       [[ 61, 119,  61],
+        [ 54, 121,  60],
+        [ 38, 124,  60],
+        [ 47, 116,  71],
+        [ 79,  97,  96],
+        [119,  76, 127],
+        [167,  51, 164],
+        [183,  39, 181],
+        [172,  41, 181],
+        [161,  45, 164],
+        [139,  40, 118],
+        [113,  45, 100],
+        [ 85,  56, 106],
+        [ 71,  56, 124],
+        [ 60,  31, 140],
+        [126, 107, 224],
+        [105, 114, 212],
+        [ 97, 116, 213],
+        [ 99, 109, 223],
+        [ 89, 116, 206],
+        [109, 181, 205],
+        [100, 190, 185],
+        [110, 182, 192],
+        [116, 185, 188],
+        [118, 194, 170],
+        [ 89, 162, 112],
+        [118, 180, 104],
+        [120, 176,  87],
+        [105, 166,  76],
+        [121, 165,  98],
+        [  7,  20,   0],
+        [  5,   0,   0]],
+
+       [[ 72, 114,  61],
+        [ 59, 116,  61],
+        [ 37, 121,  63],
+        [ 44, 114,  77],
+        [ 78,  97, 100],
+        [120,  77, 128],
+        [168,  54, 161],
+        [182,  43, 178],
+        [169,  50, 183],
+        [163,  52, 174],
+        [158,  37, 135],
+        [139,  35, 120],
+        [104,  38, 120],
+        [ 87,  39, 135],
+        [ 77,  24, 151],
+        [132, 100, 231],
+        [ 98, 109, 223],
+        [ 86, 111, 227],
+        [ 94, 101, 240],
+        [ 82, 111, 220],
+        [ 92, 183, 210],
+        [ 79, 193, 186],
+        [ 85, 186, 195],
+        [ 94, 191, 189],
+        [ 98, 199, 161],
+        [ 71, 165,  94],
+        [105, 181,  80],
+        [118, 190,  76],
+        [100, 184,  72],
+        [104, 174,  91],
+        [  0,  13,   0],
+        [  0,   1,   0]],
+
+       [[ 91, 110,  59],
+        [ 82, 111,  65],
+        [ 63, 113,  73],
+        [ 68, 107,  86],
+        [ 98,  94, 106],
+        [131,  79, 127],
+        [169,  62, 149],
+        [179,  54, 163],
+        [154,  47, 163],
+        [155,  48, 164],
+        [154,  26, 138],
+        [144,  23, 134],
+        [111,  23, 136],
+        [ 98,  30, 149],
+        [ 94,  27, 162],
+        [141,  98, 231],
+        [ 99, 106, 223],
+        [ 87, 110, 226],
+        [ 95, 102, 235],
+        [ 85, 110, 214],
+        [102, 181, 208],
+        [ 92, 190, 184],
+        [103, 184, 189],
+        [112, 189, 181],
+        [126, 211, 167],
+        [ 90, 174, 102],
+        [ 98, 173,  81],
+        [104, 181,  83],
+        [ 88, 179,  86],
+        [ 95, 173, 102],
+        [  0,  14,   0],
+        [  0,  12,   1]],
+
+       [[ 88,  95,  88],
+        [ 81,  95,  94],
+        [ 64,  95, 104],
+        [ 66,  90, 114],
+        [ 88,  81, 124],
+        [111,  73, 133],
+        [138,  65, 138],
+        [142,  60, 143],
+        [132,  66, 155],
+        [142,  62, 163],
+        [148,  29, 144],
+        [154,  26, 151],
+        [130,  25, 152],
+        [124,  33, 160],
+        [124,  35, 162],
+        [157,  91, 204],
+        [138, 115, 200],
+        [125, 120, 199],
+        [130, 115, 207],
+        [114, 121, 190],
+        [128, 187, 196],
+        [115, 194, 180],
+        [122, 189, 186],
+        [125, 193, 182],
+        [102, 189, 145],
+        [ 81, 176, 115],
+        [ 80, 170, 104],
+        [ 74, 171, 105],
+        [ 60, 167, 110],
+        [ 75, 167, 124],
+        [  0,  12,   0],
+        [  0,   7,   0]],
+
+       [[111, 115, 194],
+        [103, 114, 198],
+        [ 88, 113, 207],
+        [ 87, 112, 210],
+        [ 96, 111, 204],
+        [108, 111, 192],
+        [121, 113, 178],
+        [123, 114, 171],
+        [111, 111, 171],
+        [127,  99, 175],
+        [144,  49, 159],
+        [169,  44, 170],
+        [158,  39, 167],
+        [159,  43, 164],
+        [160,  43, 146],
+        [181,  77, 148],
+        [162,  84, 108],
+        [155,  93,  99],
+        [147,  89, 107],
+        [122,  94, 100],
+        [122, 153, 124],
+        [ 96, 157, 121],
+        [ 92, 148, 135],
+        [ 82, 152, 139],
+        [ 76, 179, 142],
+        [ 91, 211, 170],
+        [ 92, 217, 191],
+        [ 84, 212, 200],
+        [ 70, 206, 202],
+        [ 93, 207, 207],
+        [  0,  19,  14],
+        [  0,   8,   2]],
+
+       [[ 93,  98, 230],
+        [ 87,  97, 234],
+        [ 77,  97, 239],
+        [ 74,  97, 236],
+        [ 79, 101, 220],
+        [ 80, 105, 197],
+        [ 84, 113, 170],
+        [ 85, 117, 158],
+        [ 92, 127, 170],
+        [118, 112, 177],
+        [143,  53, 159],
+        [184,  50, 180],
+        [182,  44, 175],
+        [192,  48, 167],
+        [198,  51, 143],
+        [205,  69, 117],
+        [205,  93,  81],
+        [198, 105,  66],
+        [182, 105,  73],
+        [148, 108,  73],
+        [142, 160, 113],
+        [112, 161, 117],
+        [103, 154, 134],
+        [ 84, 158, 140],
+        [ 44, 156, 122],
+        [ 77, 213, 185],
+        [ 73, 213, 214],
+        [ 58, 200, 223],
+        [ 51, 192, 225],
+        [ 89, 201, 224],
+        [  0,   7,   4],
+        [  0,   8,   0]],
+
+       [[ 82,  93, 245],
+        [ 81,  93, 247],
+        [ 80,  92, 250],
+        [ 79,  95, 242],
+        [ 82, 101, 222],
+        [ 81, 109, 196],
+        [ 79, 119, 168],
+        [ 79, 122, 155],
+        [ 81, 120, 158],
+        [115, 106, 169],
+        [148,  45, 156],
+        [199,  44, 179],
+        [201,  36, 173],
+        [215,  44, 166],
+        [233,  53, 148],
+        [232,  66, 113],
+        [220,  92,  73],
+        [204, 108,  54],
+        [184, 110,  56],
+        [147, 113,  59],
+        [139, 160, 111],
+        [109, 159, 119],
+        [100, 153, 133],
+        [ 83, 158, 137],
+        [ 54, 170, 133],
+        [ 84, 222, 198],
+        [ 63, 203, 220],
+        [ 53, 189, 231],
+        [ 61, 183, 235],
+        [110, 197, 229],
+        [  0,   8,   0],
+        [ 21,  18,   0]],
+
+       [[ 57, 106, 222],
+        [ 60, 107, 223],
+        [ 66, 106, 225],
+        [ 70, 109, 218],
+        [ 72, 115, 202],
+        [ 69, 120, 182],
+        [ 64, 128, 159],
+        [ 64, 129, 150],
+        [ 71, 129, 158],
+        [107, 118, 170],
+        [138,  59, 150],
+        [185,  58, 167],
+        [178,  46, 152],
+        [192,  54, 142],
+        [216,  68, 128],
+        [218,  76,  95],
+        [218,  99,  60],
+        [208, 113,  44],
+        [187, 116,  42],
+        [152, 117,  49],
+        [147, 159, 111],
+        [116, 154, 124],
+        [113, 149, 135],
+        [ 93, 153, 142],
+        [ 61, 162, 137],
+        [ 86, 209, 205],
+        [ 58, 185, 230],
+        [ 62, 183, 255],
+        [ 73, 182, 255],
+        [116, 190, 246],
+        [  0,   5,   0],
+        [ 25,  12,   0]],
+
+       [[ 26, 145, 167],
+        [ 28, 140, 163],
+        [ 37, 137, 162],
+        [ 45, 137, 162],
+        [ 46, 136, 153],
+        [ 42, 134, 145],
+        [ 40, 140, 144],
+        [ 46, 146, 150],
+        [ 45, 142, 156],
+        [ 65, 122, 153],
+        [ 99,  81, 134],
+        [126,  76, 130],
+        [126,  85, 123],
+        [128,  89, 105],
+        [153, 102,  92],
+        [165,  97,  60],
+        [202, 114,  50],
+        [205, 115,  31],
+        [189, 119,  28],
+        [173, 131,  54],
+        [151, 144, 105],
+        [141, 151, 138],
+        [141, 146, 147],
+        [117, 143, 149],
+        [ 92, 159, 160],
+        [ 96, 188, 217],
+        [ 77, 176, 255],
+        [ 77, 179, 255],
+        [ 64, 162, 255],
+        [ 89, 159, 255],
+        [  0,   6,  31],
+        [  5,   3,   0]],
+
+       [[ 23, 197, 119],
+        [ 29, 197, 121],
+        [ 42, 193, 124],
+        [ 49, 194, 132],
+        [ 55, 196, 145],
+        [ 59, 203, 161],
+        [ 59, 206, 178],
+        [ 59, 207, 191],
+        [ 58, 199, 196],
+        [ 75, 183, 187],
+        [ 99, 145, 153],
+        [117, 138, 135],
+        [110, 148, 118],
+        [115, 152,  96],
+        [139, 155,  78],
+        [153, 135,  46],
+        [192, 125,  33],
+        [205, 121,  26],
+        [192, 122,  21],
+        [166, 117,  43],
+        [127, 105,  87],
+        [107,  97, 114],
+        [105,  90, 121],
+        [ 84,  86, 126],
+        [ 49,  88, 132],
+        [ 42, 104, 175],
+        [  9,  78, 205],
+        [  0,  73, 231],
+        [  0,  69, 230],
+        [ 35,  95, 219],
+        [  0,   0,  34],
+        [  2,   3,   7]],
+
+       [[ 10, 226,  41],
+        [ 15, 226,  46],
+        [ 20, 219,  51],
+        [ 16, 212,  62],
+        [ 16, 215,  93],
+        [ 22, 224, 131],
+        [ 21, 223, 164],
+        [ 13, 214, 177],
+        [ 22, 217, 191],
+        [ 42, 207, 180],
+        [ 63, 173, 131],
+        [ 78, 168, 102],
+        [ 82, 184,  82],
+        [101, 193,  64],
+        [134, 188,  45],
+        [147, 152,  13],
+        [198, 143,  28],
+        [218, 139,  36],
+        [209, 140,  37],
+        [178, 125,  62],
+        [127,  96, 111],
+        [101,  78, 140],
+        [ 97,  73, 151],
+        [ 83,  72, 164],
+        [ 50,  65, 167],
+        [ 50,  83, 210],
+        [ 28,  64, 234],
+        [ 23,  67, 252],
+        [  8,  63, 238],
+        [ 37,  82, 210],
+        [  0,   0,  34],
+        [  4,   0,   1]],
+
+       [[ 23, 255,  14],
+        [ 27, 255,  22],
+        [ 23, 248,  27],
+        [ 10, 234,  38],
+        [  5, 234,  77],
+        [ 13, 245, 127],
+        [  7, 239, 163],
+        [  0, 225, 176],
+        [  0, 216, 178],
+        [ 15, 209, 166],
+        [ 29, 177, 113],
+        [ 41, 171,  78],
+        [ 50, 189,  62],
+        [ 83, 200,  53],
+        [127, 191,  38],
+        [143, 149,   2],
+        [190, 133,   4],
+        [213, 131,  12],
+        [206, 132,  20],
+        [177, 116,  52],
+        [125,  85, 113],
+        [ 95,  67, 150],
+        [ 91,  66, 164],
+        [ 81,  66, 181],
+        [ 55,  63, 194],
+        [ 51,  71, 226],
+        [ 33,  52, 239],
+        [ 29,  56, 250],
+        [ 15,  57, 234],
+        [ 38,  75, 203],
+        [  0,   0,  42],
+        [  0,   2,  10]],
+
+       [[ 19, 251,   0],
+        [ 23, 252,   5],
+        [ 17, 241,  15],
+        [  1, 228,  29],
+        [  0, 231,  70],
+        [  4, 242, 122],
+        [  3, 237, 159],
+        [  0, 222, 171],
+        [  6, 228, 186],
+        [ 22, 222, 175],
+        [ 29, 188, 126],
+        [ 33, 174,  93],
+        [ 37, 184,  80],
+        [ 73, 189,  76],
+        [127, 175,  69],
+        [154, 138,  25],
+        [212, 140,   8],
+        [235, 140,   1],
+        [224, 138,   8],
+        [191, 121,  44],
+        [137,  91, 113],
+        [102,  74, 150],
+        [ 88,  72, 160],
+        [ 70,  68, 174],
+        [ 51,  65, 195],
+        [ 49,  69, 224],
+        [ 40,  53, 235],
+        [ 43,  63, 248],
+        [ 26,  67, 230],
+        [ 29,  70, 192],
+        [  0,   0,  46],
+        [  0,   0,  15]],
+
+       [[ 58, 234,  37],
+        [ 60, 233,  45],
+        [ 58, 225,  55],
+        [ 47, 216,  70],
+        [ 39, 215, 101],
+        [ 44, 220, 137],
+        [ 48, 216, 163],
+        [ 42, 207, 170],
+        [ 43, 205, 170],
+        [ 55, 203, 163],
+        [ 55, 176, 125],
+        [ 52, 168, 103],
+        [ 43, 173,  96],
+        [ 70, 170,  94],
+        [133, 159,  99],
+        [160, 133,  66],
+        [192, 131,  33],
+        [206, 133,  19],
+        [200, 130,  17],
+        [174, 117,  48],
+        [126,  93, 114],
+        [ 96,  80, 144],
+        [ 83,  81, 141],
+        [ 69,  78, 146],
+        [ 58,  73, 166],
+        [ 66,  77, 191],
+        [ 70,  68, 204],
+        [ 78,  81, 219],
+        [ 59,  83, 205],
+        [ 47,  79, 168],
+        [  0,  13,  50],
+        [  0,   1,  10]],
+
+       [[  0,  28,   0],
+        [  0,  25,   0],
+        [  0,  19,   0],
+        [  0,  15,   0],
+        [  0,  10,   0],
+        [  0,   7,   0],
+        [  0,   4,   5],
+        [  0,   6,   5],
+        [  0,  13,   1],
+        [  0,  21,   0],
+        [  0,  15,   0],
+        [  0,  19,   0],
+        [  0,  24,   0],
+        [  0,  20,   0],
+        [  6,   8,   0],
+        [ 30,   1,   0],
+        [ 28,   5,   0],
+        [ 32,  10,   0],
+        [ 41,  15,   0],
+        [ 28,   9,   0],
+        [  0,   0,  18],
+        [  0,   0,  31],
+        [  0,   0,  10],
+        [  0,   1,   4],
+        [  0,   0,  18],
+        [  0,   0,  27],
+        [  7,   0,  32],
+        [  5,   0,  36],
+        [  0,   0,  35],
+        [  0,   1,  31],
+        [  0,   1,   0],
+        [  7,   5,   0]],
+
+       [[  0,   2,   0],
+        [  0,   0,   3],
+        [  4,   0,  10],
+        [ 10,   0,  17],
+        [ 11,   0,  22],
+        [ 14,   0,  18],
+        [ 25,   0,  15],
+        [ 29,   0,   9],
+        [ 21,   0,   0],
+        [ 18,   5,   0],
+        [ 11,   8,   0],
+        [  0,  16,   0],
+        [  0,  20,   0],
+        [  0,  13,   0],
+        [ 15,   4,   7],
+        [ 25,   0,   8],
+        [  2,   0,   6],
+        [  0,   4,   0],
+        [ 16,  13,   0],
+        [  9,   8,   0],
+        [  0,   0,  22],
+        [  0,   0,  25],
+        [  0,   7,   0],
+        [  0,  12,   0],
+        [  0,   7,   0],
+        [ 15,   5,   0],
+        [ 32,   0,   1],
+        [ 33,   0,  10],
+        [ 10,   0,   9],
+        [ 11,   6,   8],
+        [ 14,   5,   0],
+        [ 27,  16,   0]]], dtype=np.uint8),
+)
+
+image_decoder_decode_jpeg2k_rgb = ImageData(
+  np.array([  0,   0,   0,  12, 106,  80,  32,  32,  13,  10, 135,  10,   0,
+         0,   0,  20, 102, 116, 121, 112, 106, 112,  50,  32,   0,   0,
+         0,   0, 106, 112,  50,  32,   0,   0,   0,  45, 106, 112,  50,
+       104,   0,   0,   0,  22, 105, 104, 100, 114,   0,   0,   0,  32,
+         0,   0,   0,  32,   0,   3,   7,   7,   0,   0,   0,   0,   0,
+        15,  99, 111, 108, 114,   1,   0,   0,   0,   0,   0,  16,   0,
+         0,   7,  18, 106, 112,  50,  99, 255,  79, 255,  81,   0,  47,
+         0,   0,   0,   0,   0,  32,   0,   0,   0,  32,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,  32,   0,   0,   0,  32,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   3,   7,   1,   1,
+         7,   1,   1,   7,   1,   1, 255,  82,   0,  12,   0,   0,   0,
+         1,   0,   5,   4,   4,   0,   1, 255,  92,   0,  19,  64,  64,
+        72,  72,  80,  72,  72,  80,  72,  72,  80,  72,  72,  80,  72,
+        72,  80, 255, 100,   0,  37,   0,   1,  67, 114, 101,  97, 116,
+       101, 100,  32,  98, 121,  32,  79, 112, 101, 110,  74,  80,  69,
+        71,  32, 118, 101, 114, 115, 105, 111, 110,  32,  50,  46,  53,
+        46,  48, 255, 144,   0,  10,   0,   0,   0,   0,   6, 139,   0,
+         1, 255, 147, 195, 231,   4,   0,  31, 193, 242,   2,   9, 127,
+       195, 231,   2,   7, 195, 234,   2, 143, 180,  10,  31, 104,  16,
+         4, 115,   5, 159,   0,  79, 199, 218,   5,  15, 168,  10,  31,
+       104,   8,   3,  25,   8, 159,   9, 193, 243, 130, 131, 231,   5,
+        63,  48,  32,   9, 111,   8, 127,   4, 167, 199, 218,  11,  63,
+         0, 104, 252,   1,  64,  14,  25, 236, 129,  63,  10, 242, 160,
+       112,  52, 191,   3,  34, 223, 152,  23, 207, 192,  22,  62, 208,
+        88, 125, 160, 192,  14, 120, 105, 193, 230,   9, 210, 147, 177,
+        25,   9, 144, 148, 195, 126, 191, 207, 192,  26,  62, 208,  88,
+       252,   1,  64,   7, 247, 239,  48, 181, 159,  12,  90,  58, 122,
+         9,  12,  13, 199, 195, 143, 207, 192,  78, 126,   2, 113, 248,
+        10,   0,  22, 170,  96,  67, 117, 221, 185, 238, 123, 216, 135,
+       177,  65,  60,  79, 209, 148,   7, 159,   1,  17,  79, 179, 172,
+        17,  21,  60, 101,  99, 223,  82, 254, 246, 110,  40,  44,   0,
+       127,  21, 238, 219,  43, 124, 121, 243, 213, 250,  63,  49,  33,
+        98,  47, 113,  45, 170, 153, 160, 243, 207, 192,  78, 126,   2,
+       144, 251,  68,  64,  34, 100, 150, 169,  72,  29, 190, 139,  77,
+       175, 243, 121,  86, 141,  46, 115,  17, 255, 127,  27, 206, 245,
+        36, 137,   3,  88, 150, 229,  17,  22,  80, 214, 179, 155, 191,
+         9, 119, 234, 159,  22, 133, 163,  43,  90,  41, 169,  46,  72,
+        36, 172,  70,  56,  17, 202, 131, 183, 199, 218,  37,  63,   1,
+        41, 249, 137, 128,  20, 147, 110, 123, 141, 178, 193,  87, 126,
+       222,  22,  15,  24,  73,  29, 111, 114, 149,  32, 218, 201,  39,
+       120, 134, 155, 184, 134,  66,  58, 217,  10,   0, 156,  49,  44,
+       239,  22,   2, 193,  92, 254, 178, 255,  95,  37, 196,  94,  93,
+        83, 106,   3,  55, 215,  87,  63, 223, 154,  12, 252,  17,  35,
+       240,  60,  57,  83,  92,   9, 186, 184, 253,  97, 108, 204,  42,
+       121, 198,  54, 152, 214, 158, 133, 109, 255,  22,  77, 129, 217,
+       162, 182, 150,  79, 119,  10, 227,  28, 236,  98, 161,  32, 251,
+       158, 183, 120,  79, 138, 187, 174, 187, 111, 254,  30, 115,  99,
+        23, 127,  60, 252,  16, 118, 155,  70,  55, 232, 247,  73, 175,
+       224, 111,  60, 142,  99, 107, 203,  71, 232,  40, 144,  21, 187,
+        70,  32, 169, 182, 179, 169, 171,  82, 155,  15, 190, 227, 163,
+       167,  10, 254, 246, 118,  49, 244, 220, 255, 116, 207, 201,  87,
+       180,  16, 121,  97, 154,  12, 240, 180, 206, 164,   0,  13, 219,
+       227, 153,  33,  36, 212,  33,  89, 109,   6, 212, 168, 226, 221,
+       243,   0,  50,  17, 127,  97, 234, 151,  12,  94, 181,  84, 194,
+         7, 118,  33,  72, 104,   4, 221,  22,  70, 229,  50,  52,  80,
+       241, 134,  38, 236,  26,  66,  70,  23,  53, 244, 221, 116,  56,
+       165, 197, 163,  99,   7, 113,  30, 233, 241,  30,  91, 217, 146,
+        56, 101, 216,  39,  56, 250, 172, 211,  15,  16,  47,  65, 127,
+       207, 192, 254, 126,   7, 208, 251,  77, 192,  39,  93, 199, 157,
+       201, 217,   6,  20,  49, 113,  89,  51, 238, 155, 138, 137, 202,
+        96, 134, 221, 198,  47, 240, 209, 203,  72,  12, 202, 155,  22,
+       157,  81, 250,   5, 207,  71,  13, 208,  91,  14, 180,  66,  25,
+       170, 123, 251, 123, 200,  96, 140, 228, 107,  89,  93,  20,  28,
+        69, 249, 146, 179, 144, 250, 127,  62,  97, 226, 175, 173,  54,
+       142, 247,   5,  69, 105,  71, 176,  25,  38, 200, 187, 193, 148,
+       222, 254,  21, 255, 122, 230,  25, 106,  31, 176,  84,  10, 231,
+       179, 117, 255,  50, 202,  29, 225, 188,  22, 227,  11, 177, 103,
+        37, 205, 237,  14,  73,  88,  35,  83, 169, 242,  85, 211, 102,
+         4, 142,  68,  95,  37,  82,  80, 214,  20,  11,  88, 115, 195,
+        98, 106, 218, 114, 145, 123,  75,  75, 137, 231,  55,  77, 234,
+       255,  15,  84, 210, 255,  64,  64,  20, 121,  57,  78, 253, 249,
+       212,  65, 128, 151,  92,  94, 202, 110, 182,  34, 187,   7,  53,
+        92,  36,  83, 100, 165, 121,  71, 207, 192, 250, 126,   7, 176,
+       251,  77, 128,  36, 198, 178,  18,  76, 218, 211, 240, 218,  60,
+        13, 248,  75, 214,  67,  64,  18,  66, 236, 198,  84, 245,  51,
+        12,   3,   1,  92,  45,  35, 139, 118,  66, 222, 137,  88, 222,
+        75,  85,  44, 193, 125, 206,  91, 163,  92, 147, 203,  52,  24,
+       223, 120,  99, 100,  87,  72,  29,  61, 233,  70, 212, 108, 239,
+        82, 243,  93, 156, 226,  55, 118, 254, 179,  72, 189,  40, 125,
+       216, 140, 179, 219, 226, 142, 202, 239,  14, 133, 104, 196, 156,
+        84, 111, 170, 186, 228, 127, 214,  32, 165,  68, 129, 204, 171,
+         3, 120, 212,   6, 164, 158, 250, 178, 132, 138,  76, 206,  80,
+        43, 120,   0, 235, 221, 142, 194, 133, 111,  76, 233,  61, 247,
+         7, 103,  43, 113,  35, 140,  59, 224,  80, 183, 221,  52, 198,
+        22, 127, 253, 147, 102,  60, 126, 241,  91, 200, 146, 170,  69,
+       217, 123,  36, 141,  88, 160, 132, 121, 239, 104, 123, 227, 227,
+       123, 190, 157,  71,  12, 179,  28, 187, 245,  45, 111, 207, 193,
+       146, 126,  12, 112, 251,  77, 192, 172, 193, 118, 152,  92, 250,
+       245, 178, 145, 220,   2, 246, 200, 173, 130, 233,  43,  23, 207,
+       176, 154, 220,  79, 208, 152, 232,  49, 148, 197,  12,  28, 187,
+       215, 231,  74, 253, 114, 157,  45,  56,  62,  45,  55,  37,  63,
+       220, 131, 255,  32, 189, 251, 116,  36, 204,  16,  72, 124, 138,
+        94,  44,  96, 110,  62, 104,  57, 246,  44, 174, 179, 147, 146,
+        32,  91,  92, 114, 196,  87, 209, 170,  88,  95,  21, 139, 254,
+        78, 207, 156, 124, 151, 116, 227,  49,  30, 171, 162,  67, 120,
+        31, 199, 127, 172, 192,  52,  46, 151, 230, 141, 248, 110,  35,
+       243, 135, 232,  26,  43, 142, 196, 185,  12,  31, 123, 137, 118,
+       145,  48,  91,  56,  46,  85,  72,  18,  97,  34, 253, 207,  73,
+         6, 204, 217, 124, 228,  59, 146, 216,  33,  21, 121, 105, 196,
+        65, 232, 214, 181,  33, 112,  35,  55,  32,  33, 125,  46, 251,
+       203, 242, 226, 175, 225, 187, 121, 111, 111, 255,  29,  75,   9,
+         3, 194, 219, 238,  88, 133,  72, 196, 238,  51, 233, 109,  12,
+        25,  10, 233, 187,   9, 192, 207,  13, 156,  39, 179, 130, 200,
+        62, 211, 143, 151,  41, 170,  39,  11, 131,  60, 130,  78, 123,
+        42, 202,  95,  61, 144, 135,  25,  74, 217, 191, 126,  75,   2,
+       248, 229, 162, 158, 203, 118, 243, 164, 243,  12,  46,   4, 178,
+       182, 205,  93,  28, 245, 197, 208,  12, 129, 253, 202, 125,  52,
+       175, 199, 218, 191,  31, 106, 252,  62, 211,  16,  28, 232,  48,
+       162,  23, 193, 178,  85, 202, 167,  50, 213, 135, 203, 213,  27,
+        46,  88, 209,  38, 100, 195, 157,  78,   8,  92,  80, 131,   1,
+        63, 224, 212,   8,  26,  89,  41, 113,  24, 140,  81,  51, 226,
+       213,  93, 247, 195,  32, 162,  62,  37,  90, 178, 221,  91,  29,
+       208, 212,  99, 228,  11,  68,  39, 232, 182, 168, 128,  68,  47,
+       120,  91, 215,  14,  39, 113, 211, 156,  72, 108,  30, 128, 171,
+        43, 176, 182, 171, 113, 246, 165, 179, 121,  20, 155,  19, 123,
+       199,  34, 225, 202,  31,  38,  55, 160, 175, 114,  38, 236,  62,
+        89, 241, 175,  49, 106, 198,  41,  44, 173,  11, 243,  12,   6,
+       173, 111, 165,  11, 112, 162, 192,  47, 188, 234,  18,  87, 128,
+       156, 125,  24, 251,  76, 185, 246,  22, 208, 211, 181,  43,   9,
+         5, 168,  66, 222, 117,  48,  39, 165, 199, 250, 206,  38,  56,
+       205,  16,  78, 244,  43, 227, 148,  36,  44,  93, 250,   6, 159,
+        16,  86,   5,  48, 155, 224, 126,  49, 225, 114, 202,  48, 143,
+       249,  97, 218, 162,  47,  65, 170,  89, 251, 164, 134, 209,  85,
+        26,  37, 116,  11, 118, 109,   5,  54,   2, 191, 141, 206, 195,
+        31, 248,  32, 125,   3,  11, 136, 183,  82,   5,  75,  21,  29,
+         7, 133,  33, 216, 139,  51,  76,   2,  21, 246, 232, 226, 180,
+       170,  62, 199, 218, 181,  31, 106, 236,  62, 211,  80,  28,  76,
+        84, 159,   4,  65,  45,  39, 210, 159,  35, 192, 202, 118, 120,
+       113, 103, 253,  75,  75,  29,  51, 207,  47, 118,  61, 205,  24,
+        61,  63,   1,  17,  52, 104, 120, 192, 211, 103,  43, 123,  71,
+       170, 107,   8, 243,  28,  56, 166,  39, 181, 109, 213,   6,  39,
+        56, 190, 181,  90,  56,  15, 152, 255,  45,  19, 192, 235, 243,
+        23, 245, 230, 151, 239,  68,  55, 179,  23,  15, 235,  29,  68,
+       125, 242,   9, 113,  86,  86,  21,  82, 207,  67, 115, 187,  10,
+        73,  82, 210, 112,  95, 199, 163, 129,  28, 179,  43,  72, 187,
+       122,  30, 152, 227,  80, 163,  50, 129, 121, 138,   9,  19,  10,
+        19,  44, 101, 108,  69, 246, 105,  58,  85, 146, 155, 114, 216,
+       168,  49,  23, 223,  94, 202, 124,  62, 127,  16,  20,  86,  26,
+       183,  95, 189, 192, 165, 141,  55,  91,  79,  49, 229, 108,  77,
+       250, 123, 247, 184, 138,  47, 103, 176, 157,   8,  81, 201, 192,
+       156,  59, 240, 251,  47,  34,  71,  39,   3, 179,  38, 223, 110,
+       159, 133, 196,  85,  72, 241, 227, 104, 224, 110, 127, 216, 242,
+        88,  42, 220,  81,  93, 138,  63,  86,  78,  76, 149, 234, 116,
+       126,  32,   5,  40,  46, 103, 109, 144, 200, 232,  34, 217, 153,
+        38,  76, 185, 122, 147, 225, 110, 237, 245,  41, 121, 206, 151,
+       255, 217], dtype=np.uint8),
+    np.array([[[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0]]], dtype=np.uint8),
+)
+
+image_decoder_decode_bmp_rgb = ImageData(
+    np.array([ 66,  77,  54,  12,   0,   0,   0,   0,   0,   0,  54,   0,   0,
+         0,  40,   0,   0,   0,  32,   0,   0,   0,  32,   0,   0,   0,
+         1,   0,  24,   0,   0,   0,   0,   0,   0,  12,   0,   0, 196,
+        14,   0,   0, 196,  14,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  11,
+       246,  24,  11, 246,  24,  11, 246,  24,  11, 246,  24,  11, 246,
+        24,   6, 219, 177,   6, 219, 177,   6, 219, 177,   6, 219, 177,
+         6, 219, 177,  37, 188,  77,  37, 188,  77,  37, 188,  77,  37,
+       188,  77,  37, 188,  77, 230, 138,   2, 230, 138,   2, 230, 138,
+         2, 230, 138,   2, 230, 138,   2,  81,  74, 159,  81,  74, 159,
+        81,  74, 159,  81,  74, 159,  81,  74, 159,  27,  63, 240,  27,
+        63, 240,  27,  63, 240,  27,  63, 240,  27,  63, 240,   0,   0,
+         0,   0,   0,   0,  11, 246,  24,  11, 246,  24,  11, 246,  24,
+        11, 246,  24,  11, 246,  24,   6, 219, 177,   6, 219, 177,   6,
+       219, 177,   6, 219, 177,   6, 219, 177,  37, 188,  77,  37, 188,
+        77,  37, 188,  77,  37, 188,  77,  37, 188,  77, 230, 138,   2,
+       230, 138,   2, 230, 138,   2, 230, 138,   2, 230, 138,   2,  81,
+        74, 159,  81,  74, 159,  81,  74, 159,  81,  74, 159,  81,  74,
+       159,  27,  63, 240,  27,  63, 240,  27,  63, 240,  27,  63, 240,
+        27,  63, 240,   0,   0,   0,   0,   0,   0,  11, 246,  24,  11,
+       246,  24,  11, 246,  24,  11, 246,  24,  11, 246,  24,   6, 219,
+       177,   6, 219, 177,   6, 219, 177,   6, 219, 177,   6, 219, 177,
+        37, 188,  77,  37, 188,  77,  37, 188,  77,  37, 188,  77,  37,
+       188,  77, 230, 138,   2, 230, 138,   2, 230, 138,   2, 230, 138,
+         2, 230, 138,   2,  81,  74, 159,  81,  74, 159,  81,  74, 159,
+        81,  74, 159,  81,  74, 159,  27,  63, 240,  27,  63, 240,  27,
+        63, 240,  27,  63, 240,  27,  63, 240,   0,   0,   0,   0,   0,
+         0,  11, 246,  24,  11, 246,  24,  11, 246,  24,  11, 246,  24,
+        11, 246,  24,   6, 219, 177,   6, 219, 177,   6, 219, 177,   6,
+       219, 177,   6, 219, 177,  37, 188,  77,  37, 188,  77,  37, 188,
+        77,  37, 188,  77,  37, 188,  77, 230, 138,   2, 230, 138,   2,
+       230, 138,   2, 230, 138,   2, 230, 138,   2,  81,  74, 159,  81,
+        74, 159,  81,  74, 159,  81,  74, 159,  81,  74, 159,  27,  63,
+       240,  27,  63, 240,  27,  63, 240,  27,  63, 240,  27,  63, 240,
+         0,   0,   0,   0,   0,   0,  11, 246,  24,  11, 246,  24,  11,
+       246,  24,  11, 246,  24,  11, 246,  24,   6, 219, 177,   6, 219,
+       177,   6, 219, 177,   6, 219, 177,   6, 219, 177,  37, 188,  77,
+        37, 188,  77,  37, 188,  77,  37, 188,  77,  37, 188,  77, 230,
+       138,   2, 230, 138,   2, 230, 138,   2, 230, 138,   2, 230, 138,
+         2,  81,  74, 159,  81,  74, 159,  81,  74, 159,  81,  74, 159,
+        81,  74, 159,  27,  63, 240,  27,  63, 240,  27,  63, 240,  27,
+        63, 240,  27,  63, 240,   0,   0,   0,   0,   0,   0,  80,  90,
+       247,  80,  90, 247,  80,  90, 247,  80,  90, 247,  80,  90, 247,
+        85, 118, 167,  85, 118, 167,  85, 118, 167,  85, 118, 167,  85,
+       118, 167, 208,  39, 172, 208,  39, 172, 208,  39, 172, 208,  39,
+       172, 208,  39, 172, 191, 106,  60, 191, 106,  60, 191, 106,  60,
+       191, 106,  60, 191, 106,  60, 112, 163, 114, 112, 163, 114, 112,
+       163, 114, 112, 163, 114, 112, 163, 114,  50, 201, 228,  50, 201,
+       228,  50, 201, 228,  50, 201, 228,  50, 201, 228,   0,   0,   0,
+         0,   0,   0,  80,  90, 247,  80,  90, 247,  80,  90, 247,  80,
+        90, 247,  80,  90, 247,  85, 118, 167,  85, 118, 167,  85, 118,
+       167,  85, 118, 167,  85, 118, 167, 208,  39, 172, 208,  39, 172,
+       208,  39, 172, 208,  39, 172, 208,  39, 172, 191, 106,  60, 191,
+       106,  60, 191, 106,  60, 191, 106,  60, 191, 106,  60, 112, 163,
+       114, 112, 163, 114, 112, 163, 114, 112, 163, 114, 112, 163, 114,
+        50, 201, 228,  50, 201, 228,  50, 201, 228,  50, 201, 228,  50,
+       201, 228,   0,   0,   0,   0,   0,   0,  80,  90, 247,  80,  90,
+       247,  80,  90, 247,  80,  90, 247,  80,  90, 247,  85, 118, 167,
+        85, 118, 167,  85, 118, 167,  85, 118, 167,  85, 118, 167, 208,
+        39, 172, 208,  39, 172, 208,  39, 172, 208,  39, 172, 208,  39,
+       172, 191, 106,  60, 191, 106,  60, 191, 106,  60, 191, 106,  60,
+       191, 106,  60, 112, 163, 114, 112, 163, 114, 112, 163, 114, 112,
+       163, 114, 112, 163, 114,  50, 201, 228,  50, 201, 228,  50, 201,
+       228,  50, 201, 228,  50, 201, 228,   0,   0,   0,   0,   0,   0,
+        80,  90, 247,  80,  90, 247,  80,  90, 247,  80,  90, 247,  80,
+        90, 247,  85, 118, 167,  85, 118, 167,  85, 118, 167,  85, 118,
+       167,  85, 118, 167, 208,  39, 172, 208,  39, 172, 208,  39, 172,
+       208,  39, 172, 208,  39, 172, 191, 106,  60, 191, 106,  60, 191,
+       106,  60, 191, 106,  60, 191, 106,  60, 112, 163, 114, 112, 163,
+       114, 112, 163, 114, 112, 163, 114, 112, 163, 114,  50, 201, 228,
+        50, 201, 228,  50, 201, 228,  50, 201, 228,  50, 201, 228,   0,
+         0,   0,   0,   0,   0,  80,  90, 247,  80,  90, 247,  80,  90,
+       247,  80,  90, 247,  80,  90, 247,  85, 118, 167,  85, 118, 167,
+        85, 118, 167,  85, 118, 167,  85, 118, 167, 208,  39, 172, 208,
+        39, 172, 208,  39, 172, 208,  39, 172, 208,  39, 172, 191, 106,
+        60, 191, 106,  60, 191, 106,  60, 191, 106,  60, 191, 106,  60,
+       112, 163, 114, 112, 163, 114, 112, 163, 114, 112, 163, 114, 112,
+       163, 114,  50, 201, 228,  50, 201, 228,  50, 201, 228,  50, 201,
+       228,  50, 201, 228,   0,   0,   0,   0,   0,   0,  59, 118,  64,
+        59, 118,  64,  59, 118,  64,  59, 118,  64,  59, 118,  64, 167,
+        54, 157, 167,  54, 157, 167,  54, 157, 167,  54, 157, 167,  54,
+       157, 122,  26, 142, 122,  26, 142, 122,  26, 142, 122,  26, 142,
+       122,  26, 142,  88, 105, 236,  88, 105, 236,  88, 105, 236,  88,
+       105, 236,  88, 105, 236,  91, 191, 184,  91, 191, 184,  91, 191,
+       184,  91, 191, 184,  91, 191, 184,  95, 185,  76,  95, 185,  76,
+        95, 185,  76,  95, 185,  76,  95, 185,  76,   0,   0,   0,   0,
+         0,   0,  59, 118,  64,  59, 118,  64,  59, 118,  64,  59, 118,
+        64,  59, 118,  64, 167,  54, 157, 167,  54, 157, 167,  54, 157,
+       167,  54, 157, 167,  54, 157, 122,  26, 142, 122,  26, 142, 122,
+        26, 142, 122,  26, 142, 122,  26, 142,  88, 105, 236,  88, 105,
+       236,  88, 105, 236,  88, 105, 236,  88, 105, 236,  91, 191, 184,
+        91, 191, 184,  91, 191, 184,  91, 191, 184,  91, 191, 184,  95,
+       185,  76,  95, 185,  76,  95, 185,  76,  95, 185,  76,  95, 185,
+        76,   0,   0,   0,   0,   0,   0,  59, 118,  64,  59, 118,  64,
+        59, 118,  64,  59, 118,  64,  59, 118,  64, 167,  54, 157, 167,
+        54, 157, 167,  54, 157, 167,  54, 157, 167,  54, 157, 122,  26,
+       142, 122,  26, 142, 122,  26, 142, 122,  26, 142, 122,  26, 142,
+        88, 105, 236,  88, 105, 236,  88, 105, 236,  88, 105, 236,  88,
+       105, 236,  91, 191, 184,  91, 191, 184,  91, 191, 184,  91, 191,
+       184,  91, 191, 184,  95, 185,  76,  95, 185,  76,  95, 185,  76,
+        95, 185,  76,  95, 185,  76,   0,   0,   0,   0,   0,   0,  59,
+       118,  64,  59, 118,  64,  59, 118,  64,  59, 118,  64,  59, 118,
+        64, 167,  54, 157, 167,  54, 157, 167,  54, 157, 167,  54, 157,
+       167,  54, 157, 122,  26, 142, 122,  26, 142, 122,  26, 142, 122,
+        26, 142, 122,  26, 142,  88, 105, 236,  88, 105, 236,  88, 105,
+       236,  88, 105, 236,  88, 105, 236,  91, 191, 184,  91, 191, 184,
+        91, 191, 184,  91, 191, 184,  91, 191, 184,  95, 185,  76,  95,
+       185,  76,  95, 185,  76,  95, 185,  76,  95, 185,  76,   0,   0,
+         0,   0,   0,   0,  59, 118,  64,  59, 118,  64,  59, 118,  64,
+        59, 118,  64,  59, 118,  64, 167,  54, 157, 167,  54, 157, 167,
+        54, 157, 167,  54, 157, 167,  54, 157, 122,  26, 142, 122,  26,
+       142, 122,  26, 142, 122,  26, 142, 122,  26, 142,  88, 105, 236,
+        88, 105, 236,  88, 105, 236,  88, 105, 236,  88, 105, 236,  91,
+       191, 184,  91, 191, 184,  91, 191, 184,  91, 191, 184,  91, 191,
+       184,  95, 185,  76,  95, 185,  76,  95, 185,  76,  95, 185,  76,
+        95, 185,  76,   0,   0,   0,   0,   0,   0,  54,  66,  34,  54,
+        66,  34,  54,  66,  34,  54,  66,  34,  54,  66,  34, 158,  29,
+       136, 158,  29, 136, 158,  29, 136, 158,  29, 136, 158,  29, 136,
+         1, 152, 117,   1, 152, 117,   1, 152, 117,   1, 152, 117,   1,
+       152, 117, 244, 208, 187, 244, 208, 187, 244, 208, 187, 244, 208,
+       187, 244, 208, 187, 234, 108, 118, 234, 108, 118, 234, 108, 118,
+       234, 108, 118, 234, 108, 118, 205, 113, 246, 205, 113, 246, 205,
+       113, 246, 205, 113, 246, 205, 113, 246,   0,   0,   0,   0,   0,
+         0,  54,  66,  34,  54,  66,  34,  54,  66,  34,  54,  66,  34,
+        54,  66,  34, 158,  29, 136, 158,  29, 136, 158,  29, 136, 158,
+        29, 136, 158,  29, 136,   1, 152, 117,   1, 152, 117,   1, 152,
+       117,   1, 152, 117,   1, 152, 117, 244, 208, 187, 244, 208, 187,
+       244, 208, 187, 244, 208, 187, 244, 208, 187, 234, 108, 118, 234,
+       108, 118, 234, 108, 118, 234, 108, 118, 234, 108, 118, 205, 113,
+       246, 205, 113, 246, 205, 113, 246, 205, 113, 246, 205, 113, 246,
+         0,   0,   0,   0,   0,   0,  54,  66,  34,  54,  66,  34,  54,
+        66,  34,  54,  66,  34,  54,  66,  34, 158,  29, 136, 158,  29,
+       136, 158,  29, 136, 158,  29, 136, 158,  29, 136,   1, 152, 117,
+         1, 152, 117,   1, 152, 117,   1, 152, 117,   1, 152, 117, 244,
+       208, 187, 244, 208, 187, 244, 208, 187, 244, 208, 187, 244, 208,
+       187, 234, 108, 118, 234, 108, 118, 234, 108, 118, 234, 108, 118,
+       234, 108, 118, 205, 113, 246, 205, 113, 246, 205, 113, 246, 205,
+       113, 246, 205, 113, 246,   0,   0,   0,   0,   0,   0,  54,  66,
+        34,  54,  66,  34,  54,  66,  34,  54,  66,  34,  54,  66,  34,
+       158,  29, 136, 158,  29, 136, 158,  29, 136, 158,  29, 136, 158,
+        29, 136,   1, 152, 117,   1, 152, 117,   1, 152, 117,   1, 152,
+       117,   1, 152, 117, 244, 208, 187, 244, 208, 187, 244, 208, 187,
+       244, 208, 187, 244, 208, 187, 234, 108, 118, 234, 108, 118, 234,
+       108, 118, 234, 108, 118, 234, 108, 118, 205, 113, 246, 205, 113,
+       246, 205, 113, 246, 205, 113, 246, 205, 113, 246,   0,   0,   0,
+         0,   0,   0,  54,  66,  34,  54,  66,  34,  54,  66,  34,  54,
+        66,  34,  54,  66,  34, 158,  29, 136, 158,  29, 136, 158,  29,
+       136, 158,  29, 136, 158,  29, 136,   1, 152, 117,   1, 152, 117,
+         1, 152, 117,   1, 152, 117,   1, 152, 117, 244, 208, 187, 244,
+       208, 187, 244, 208, 187, 244, 208, 187, 244, 208, 187, 234, 108,
+       118, 234, 108, 118, 234, 108, 118, 234, 108, 118, 234, 108, 118,
+       205, 113, 246, 205, 113, 246, 205, 113, 246, 205, 113, 246, 205,
+       113, 246,   0,   0,   0,   0,   0,   0, 169,  47,  21, 169,  47,
+        21, 169,  47,  21, 169,  47,  21, 169,  47,  21,  10,  45, 173,
+        10,  45, 173,  10,  45, 173,  10,  45, 173,  10,  45, 173,  94,
+        15, 254,  94,  15, 254,  94,  15, 254,  94,  15, 254,  94,  15,
+       254,  81, 126,  52,  81, 126,  52,  81, 126,  52,  81, 126,  52,
+        81, 126,  52, 101, 211, 145, 101, 211, 145, 101, 211, 145, 101,
+       211, 145, 101, 211, 145, 145,  86, 109, 145,  86, 109, 145,  86,
+       109, 145,  86, 109, 145,  86, 109,   0,   0,   0,   0,   0,   0,
+       169,  47,  21, 169,  47,  21, 169,  47,  21, 169,  47,  21, 169,
+        47,  21,  10,  45, 173,  10,  45, 173,  10,  45, 173,  10,  45,
+       173,  10,  45, 173,  94,  15, 254,  94,  15, 254,  94,  15, 254,
+        94,  15, 254,  94,  15, 254,  81, 126,  52,  81, 126,  52,  81,
+       126,  52,  81, 126,  52,  81, 126,  52, 101, 211, 145, 101, 211,
+       145, 101, 211, 145, 101, 211, 145, 101, 211, 145, 145,  86, 109,
+       145,  86, 109, 145,  86, 109, 145,  86, 109, 145,  86, 109,   0,
+         0,   0,   0,   0,   0, 169,  47,  21, 169,  47,  21, 169,  47,
+        21, 169,  47,  21, 169,  47,  21,  10,  45, 173,  10,  45, 173,
+        10,  45, 173,  10,  45, 173,  10,  45, 173,  94,  15, 254,  94,
+        15, 254,  94,  15, 254,  94,  15, 254,  94,  15, 254,  81, 126,
+        52,  81, 126,  52,  81, 126,  52,  81, 126,  52,  81, 126,  52,
+       101, 211, 145, 101, 211, 145, 101, 211, 145, 101, 211, 145, 101,
+       211, 145, 145,  86, 109, 145,  86, 109, 145,  86, 109, 145,  86,
+       109, 145,  86, 109,   0,   0,   0,   0,   0,   0, 169,  47,  21,
+       169,  47,  21, 169,  47,  21, 169,  47,  21, 169,  47,  21,  10,
+        45, 173,  10,  45, 173,  10,  45, 173,  10,  45, 173,  10,  45,
+       173,  94,  15, 254,  94,  15, 254,  94,  15, 254,  94,  15, 254,
+        94,  15, 254,  81, 126,  52,  81, 126,  52,  81, 126,  52,  81,
+       126,  52,  81, 126,  52, 101, 211, 145, 101, 211, 145, 101, 211,
+       145, 101, 211, 145, 101, 211, 145, 145,  86, 109, 145,  86, 109,
+       145,  86, 109, 145,  86, 109, 145,  86, 109,   0,   0,   0,   0,
+         0,   0, 169,  47,  21, 169,  47,  21, 169,  47,  21, 169,  47,
+        21, 169,  47,  21,  10,  45, 173,  10,  45, 173,  10,  45, 173,
+        10,  45, 173,  10,  45, 173,  94,  15, 254,  94,  15, 254,  94,
+        15, 254,  94,  15, 254,  94,  15, 254,  81, 126,  52,  81, 126,
+        52,  81, 126,  52,  81, 126,  52,  81, 126,  52, 101, 211, 145,
+       101, 211, 145, 101, 211, 145, 101, 211, 145, 101, 211, 145, 145,
+        86, 109, 145,  86, 109, 145,  86, 109, 145,  86, 109, 145,  86,
+       109,   0,   0,   0,   0,   0,   0, 251,  81, 226, 251,  81, 226,
+       251,  81, 226, 251,  81, 226, 251,  81, 226,  45, 229, 237,  45,
+       229, 237,  45, 229, 237,  45, 229, 237,  45, 229, 237,  29, 227,
+       225,  29, 227, 225,  29, 227, 225,  29, 227, 225,  29, 227, 225,
+        80, 253, 253,  80, 253, 253,  80, 253, 253,  80, 253, 253,  80,
+       253, 253, 118,   8, 129, 118,   8, 129, 118,   8, 129, 118,   8,
+       129, 118,   8, 129,  77, 164,  33,  77, 164,  33,  77, 164,  33,
+        77, 164,  33,  77, 164,  33,   0,   0,   0,   0,   0,   0, 251,
+        81, 226, 251,  81, 226, 251,  81, 226, 251,  81, 226, 251,  81,
+       226,  45, 229, 237,  45, 229, 237,  45, 229, 237,  45, 229, 237,
+        45, 229, 237,  29, 227, 225,  29, 227, 225,  29, 227, 225,  29,
+       227, 225,  29, 227, 225,  80, 253, 253,  80, 253, 253,  80, 253,
+       253,  80, 253, 253,  80, 253, 253, 118,   8, 129, 118,   8, 129,
+       118,   8, 129, 118,   8, 129, 118,   8, 129,  77, 164,  33,  77,
+       164,  33,  77, 164,  33,  77, 164,  33,  77, 164,  33,   0,   0,
+         0,   0,   0,   0, 251,  81, 226, 251,  81, 226, 251,  81, 226,
+       251,  81, 226, 251,  81, 226,  45, 229, 237,  45, 229, 237,  45,
+       229, 237,  45, 229, 237,  45, 229, 237,  29, 227, 225,  29, 227,
+       225,  29, 227, 225,  29, 227, 225,  29, 227, 225,  80, 253, 253,
+        80, 253, 253,  80, 253, 253,  80, 253, 253,  80, 253, 253, 118,
+         8, 129, 118,   8, 129, 118,   8, 129, 118,   8, 129, 118,   8,
+       129,  77, 164,  33,  77, 164,  33,  77, 164,  33,  77, 164,  33,
+        77, 164,  33,   0,   0,   0,   0,   0,   0, 251,  81, 226, 251,
+        81, 226, 251,  81, 226, 251,  81, 226, 251,  81, 226,  45, 229,
+       237,  45, 229, 237,  45, 229, 237,  45, 229, 237,  45, 229, 237,
+        29, 227, 225,  29, 227, 225,  29, 227, 225,  29, 227, 225,  29,
+       227, 225,  80, 253, 253,  80, 253, 253,  80, 253, 253,  80, 253,
+       253,  80, 253, 253, 118,   8, 129, 118,   8, 129, 118,   8, 129,
+       118,   8, 129, 118,   8, 129,  77, 164,  33,  77, 164,  33,  77,
+       164,  33,  77, 164,  33,  77, 164,  33,   0,   0,   0,   0,   0,
+         0, 251,  81, 226, 251,  81, 226, 251,  81, 226, 251,  81, 226,
+       251,  81, 226,  45, 229, 237,  45, 229, 237,  45, 229, 237,  45,
+       229, 237,  45, 229, 237,  29, 227, 225,  29, 227, 225,  29, 227,
+       225,  29, 227, 225,  29, 227, 225,  80, 253, 253,  80, 253, 253,
+        80, 253, 253,  80, 253, 253,  80, 253, 253, 118,   8, 129, 118,
+         8, 129, 118,   8, 129, 118,   8, 129, 118,   8, 129,  77, 164,
+        33,  77, 164,  33,  77, 164,  33,  77, 164,  33,  77, 164,  33,
+         0,   0,   0,   0,   0,   0], dtype=np.uint8),
+    image_decoder_decode_jpeg2k_rgb.output,
+)
+
+image_decoder_decode_png_rgb = ImageData(
+    np.array([137,  80,  78,  71,  13,  10,  26,  10,   0,   0,   0,  13,  73,
+        72,  68,  82,   0,   0,   0,  32,   0,   0,   0,  32,   8,   2,
+         0,   0,   0, 252,  24, 237, 163,   0,   0,   0, 255,  73,  68,
+        65,  84, 120, 156,  99, 124,  20, 248, 155,   1,   9, 112,  79,
+        49,  66, 230, 126, 249, 247,   1, 153,  43,  35, 101, 140, 204,
+       109, 225,  86,  67, 230,  46, 152, 115,  29, 153, 123,  63, 102,
+        51,   3,   3,   3,  19,   3, 141, 193, 168,   5,   4,   1, 139,
+       241, 189, 117, 200, 252,  25,  30, 119, 145, 185, 129, 143,  66,
+       144, 185, 102, 249, 159, 145, 185, 177, 167, 223,  35, 115, 125,
+       154,  93, 144, 185, 147,  25,  70,  35, 121, 112,  88, 192, 168,
+       228, 100, 134, 204,  79, 187, 157, 129, 204, 125,  91, 157, 140,
+       204, 117, 179,  64, 137, 228, 221, 115, 190,  33, 115,  27,  88,
+        31,  35, 115, 185, 250, 141,  25, 134,  67,  16,  13, 125,  11,
+        88, 228,  76,  88, 145, 249, 162,  95,  56, 145, 185, 108,  77,
+       149, 200,  92,  67, 255,  20, 100, 238, 223,  48, 102, 100, 110,
+       216,  47,  22,  20, 179, 251,  25,  24, 134,  67,  16,  13, 125,
+        11,  88, 182,  63,  17,  69, 230, 111, 112,  64,  41, 189, 249,
+        55,  86,  35, 115,   3,  24,  81, 202, 103, 179,  39,  27, 145,
+       185,  51, 212,  14,  33, 115, 101,  24,  24,  24, 134,  67,  16,
+        13, 125,  11,  88,  20, 231, 236,  70, 230, 207, 124, 138, 210,
+        14, 155, 227, 118,   1, 153, 123, 236, 220,  65, 100, 110, 242,
+       242, 135, 200,  92, 158, 175,  47,  49,  45,  24, 250,  65,  52,
+       244,  45,  24, 250,   0,   0,  70, 253,  59, 210,  74,  38,  46,
+       197,   0,   0,   0,   0,  73,  69,  78,  68, 174,  66,  96, 130],
+      dtype=np.uint8),
+    image_decoder_decode_bmp_rgb.output,
+)
+
+image_decoder_decode_tiff_rgb = ImageData(
+    np.array([ 73,  73,  42,   0,   8,   0,   0,   0,  10,   0,   0,   1,   4,
+         0,   1,   0,   0,   0,  32,   0,   0,   0,   1,   1,   4,   0,
+         1,   0,   0,   0,  32,   0,   0,   0,   2,   1,   3,   0,   3,
+         0,   0,   0, 134,   0,   0,   0,   3,   1,   3,   0,   1,   0,
+         0,   0,   1,   0,   0,   0,   6,   1,   3,   0,   1,   0,   0,
+         0,   2,   0,   0,   0,  17,   1,   4,   0,   1,   0,   0,   0,
+       140,   0,   0,   0,  21,   1,   3,   0,   1,   0,   0,   0,   3,
+         0,   0,   0,  22,   1,   4,   0,   1,   0,   0,   0,  32,   0,
+         0,   0,  23,   1,   4,   0,   1,   0,   0,   0,   0,  12,   0,
+         0,  28,   1,   3,   0,   1,   0,   0,   0,   1,   0,   0,   0,
+         0,   0,   0,   0,   8,   0,   8,   0,   8,   0, 226,  81, 251,
+       226,  81, 251, 226,  81, 251, 226,  81, 251, 226,  81, 251, 237,
+       229,  45, 237, 229,  45, 237, 229,  45, 237, 229,  45, 237, 229,
+        45, 225, 227,  29, 225, 227,  29, 225, 227,  29, 225, 227,  29,
+       225, 227,  29, 253, 253,  80, 253, 253,  80, 253, 253,  80, 253,
+       253,  80, 253, 253,  80, 129,   8, 118, 129,   8, 118, 129,   8,
+       118, 129,   8, 118, 129,   8, 118,  33, 164,  77,  33, 164,  77,
+        33, 164,  77,  33, 164,  77,  33, 164,  77,   0,   0,   0,   0,
+         0,   0, 226,  81, 251, 226,  81, 251, 226,  81, 251, 226,  81,
+       251, 226,  81, 251, 237, 229,  45, 237, 229,  45, 237, 229,  45,
+       237, 229,  45, 237, 229,  45, 225, 227,  29, 225, 227,  29, 225,
+       227,  29, 225, 227,  29, 225, 227,  29, 253, 253,  80, 253, 253,
+        80, 253, 253,  80, 253, 253,  80, 253, 253,  80, 129,   8, 118,
+       129,   8, 118, 129,   8, 118, 129,   8, 118, 129,   8, 118,  33,
+       164,  77,  33, 164,  77,  33, 164,  77,  33, 164,  77,  33, 164,
+        77,   0,   0,   0,   0,   0,   0, 226,  81, 251, 226,  81, 251,
+       226,  81, 251, 226,  81, 251, 226,  81, 251, 237, 229,  45, 237,
+       229,  45, 237, 229,  45, 237, 229,  45, 237, 229,  45, 225, 227,
+        29, 225, 227,  29, 225, 227,  29, 225, 227,  29, 225, 227,  29,
+       253, 253,  80, 253, 253,  80, 253, 253,  80, 253, 253,  80, 253,
+       253,  80, 129,   8, 118, 129,   8, 118, 129,   8, 118, 129,   8,
+       118, 129,   8, 118,  33, 164,  77,  33, 164,  77,  33, 164,  77,
+        33, 164,  77,  33, 164,  77,   0,   0,   0,   0,   0,   0, 226,
+        81, 251, 226,  81, 251, 226,  81, 251, 226,  81, 251, 226,  81,
+       251, 237, 229,  45, 237, 229,  45, 237, 229,  45, 237, 229,  45,
+       237, 229,  45, 225, 227,  29, 225, 227,  29, 225, 227,  29, 225,
+       227,  29, 225, 227,  29, 253, 253,  80, 253, 253,  80, 253, 253,
+        80, 253, 253,  80, 253, 253,  80, 129,   8, 118, 129,   8, 118,
+       129,   8, 118, 129,   8, 118, 129,   8, 118,  33, 164,  77,  33,
+       164,  77,  33, 164,  77,  33, 164,  77,  33, 164,  77,   0,   0,
+         0,   0,   0,   0, 226,  81, 251, 226,  81, 251, 226,  81, 251,
+       226,  81, 251, 226,  81, 251, 237, 229,  45, 237, 229,  45, 237,
+       229,  45, 237, 229,  45, 237, 229,  45, 225, 227,  29, 225, 227,
+        29, 225, 227,  29, 225, 227,  29, 225, 227,  29, 253, 253,  80,
+       253, 253,  80, 253, 253,  80, 253, 253,  80, 253, 253,  80, 129,
+         8, 118, 129,   8, 118, 129,   8, 118, 129,   8, 118, 129,   8,
+       118,  33, 164,  77,  33, 164,  77,  33, 164,  77,  33, 164,  77,
+        33, 164,  77,   0,   0,   0,   0,   0,   0,  21,  47, 169,  21,
+        47, 169,  21,  47, 169,  21,  47, 169,  21,  47, 169, 173,  45,
+        10, 173,  45,  10, 173,  45,  10, 173,  45,  10, 173,  45,  10,
+       254,  15,  94, 254,  15,  94, 254,  15,  94, 254,  15,  94, 254,
+        15,  94,  52, 126,  81,  52, 126,  81,  52, 126,  81,  52, 126,
+        81,  52, 126,  81, 145, 211, 101, 145, 211, 101, 145, 211, 101,
+       145, 211, 101, 145, 211, 101, 109,  86, 145, 109,  86, 145, 109,
+        86, 145, 109,  86, 145, 109,  86, 145,   0,   0,   0,   0,   0,
+         0,  21,  47, 169,  21,  47, 169,  21,  47, 169,  21,  47, 169,
+        21,  47, 169, 173,  45,  10, 173,  45,  10, 173,  45,  10, 173,
+        45,  10, 173,  45,  10, 254,  15,  94, 254,  15,  94, 254,  15,
+        94, 254,  15,  94, 254,  15,  94,  52, 126,  81,  52, 126,  81,
+        52, 126,  81,  52, 126,  81,  52, 126,  81, 145, 211, 101, 145,
+       211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, 109,  86,
+       145, 109,  86, 145, 109,  86, 145, 109,  86, 145, 109,  86, 145,
+         0,   0,   0,   0,   0,   0,  21,  47, 169,  21,  47, 169,  21,
+        47, 169,  21,  47, 169,  21,  47, 169, 173,  45,  10, 173,  45,
+        10, 173,  45,  10, 173,  45,  10, 173,  45,  10, 254,  15,  94,
+       254,  15,  94, 254,  15,  94, 254,  15,  94, 254,  15,  94,  52,
+       126,  81,  52, 126,  81,  52, 126,  81,  52, 126,  81,  52, 126,
+        81, 145, 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101,
+       145, 211, 101, 109,  86, 145, 109,  86, 145, 109,  86, 145, 109,
+        86, 145, 109,  86, 145,   0,   0,   0,   0,   0,   0,  21,  47,
+       169,  21,  47, 169,  21,  47, 169,  21,  47, 169,  21,  47, 169,
+       173,  45,  10, 173,  45,  10, 173,  45,  10, 173,  45,  10, 173,
+        45,  10, 254,  15,  94, 254,  15,  94, 254,  15,  94, 254,  15,
+        94, 254,  15,  94,  52, 126,  81,  52, 126,  81,  52, 126,  81,
+        52, 126,  81,  52, 126,  81, 145, 211, 101, 145, 211, 101, 145,
+       211, 101, 145, 211, 101, 145, 211, 101, 109,  86, 145, 109,  86,
+       145, 109,  86, 145, 109,  86, 145, 109,  86, 145,   0,   0,   0,
+         0,   0,   0,  21,  47, 169,  21,  47, 169,  21,  47, 169,  21,
+        47, 169,  21,  47, 169, 173,  45,  10, 173,  45,  10, 173,  45,
+        10, 173,  45,  10, 173,  45,  10, 254,  15,  94, 254,  15,  94,
+       254,  15,  94, 254,  15,  94, 254,  15,  94,  52, 126,  81,  52,
+       126,  81,  52, 126,  81,  52, 126,  81,  52, 126,  81, 145, 211,
+       101, 145, 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101,
+       109,  86, 145, 109,  86, 145, 109,  86, 145, 109,  86, 145, 109,
+        86, 145,   0,   0,   0,   0,   0,   0,  34,  66,  54,  34,  66,
+        54,  34,  66,  54,  34,  66,  54,  34,  66,  54, 136,  29, 158,
+       136,  29, 158, 136,  29, 158, 136,  29, 158, 136,  29, 158, 117,
+       152,   1, 117, 152,   1, 117, 152,   1, 117, 152,   1, 117, 152,
+         1, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244,
+       187, 208, 244, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118,
+       108, 234, 118, 108, 234, 246, 113, 205, 246, 113, 205, 246, 113,
+       205, 246, 113, 205, 246, 113, 205,   0,   0,   0,   0,   0,   0,
+        34,  66,  54,  34,  66,  54,  34,  66,  54,  34,  66,  54,  34,
+        66,  54, 136,  29, 158, 136,  29, 158, 136,  29, 158, 136,  29,
+       158, 136,  29, 158, 117, 152,   1, 117, 152,   1, 117, 152,   1,
+       117, 152,   1, 117, 152,   1, 187, 208, 244, 187, 208, 244, 187,
+       208, 244, 187, 208, 244, 187, 208, 244, 118, 108, 234, 118, 108,
+       234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 246, 113, 205,
+       246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, 205,   0,
+         0,   0,   0,   0,   0,  34,  66,  54,  34,  66,  54,  34,  66,
+        54,  34,  66,  54,  34,  66,  54, 136,  29, 158, 136,  29, 158,
+       136,  29, 158, 136,  29, 158, 136,  29, 158, 117, 152,   1, 117,
+       152,   1, 117, 152,   1, 117, 152,   1, 117, 152,   1, 187, 208,
+       244, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244,
+       118, 108, 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118,
+       108, 234, 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113,
+       205, 246, 113, 205,   0,   0,   0,   0,   0,   0,  34,  66,  54,
+        34,  66,  54,  34,  66,  54,  34,  66,  54,  34,  66,  54, 136,
+        29, 158, 136,  29, 158, 136,  29, 158, 136,  29, 158, 136,  29,
+       158, 117, 152,   1, 117, 152,   1, 117, 152,   1, 117, 152,   1,
+       117, 152,   1, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187,
+       208, 244, 187, 208, 244, 118, 108, 234, 118, 108, 234, 118, 108,
+       234, 118, 108, 234, 118, 108, 234, 246, 113, 205, 246, 113, 205,
+       246, 113, 205, 246, 113, 205, 246, 113, 205,   0,   0,   0,   0,
+         0,   0,  34,  66,  54,  34,  66,  54,  34,  66,  54,  34,  66,
+        54,  34,  66,  54, 136,  29, 158, 136,  29, 158, 136,  29, 158,
+       136,  29, 158, 136,  29, 158, 117, 152,   1, 117, 152,   1, 117,
+       152,   1, 117, 152,   1, 117, 152,   1, 187, 208, 244, 187, 208,
+       244, 187, 208, 244, 187, 208, 244, 187, 208, 244, 118, 108, 234,
+       118, 108, 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 246,
+       113, 205, 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113,
+       205,   0,   0,   0,   0,   0,   0,  64, 118,  59,  64, 118,  59,
+        64, 118,  59,  64, 118,  59,  64, 118,  59, 157,  54, 167, 157,
+        54, 167, 157,  54, 167, 157,  54, 167, 157,  54, 167, 142,  26,
+       122, 142,  26, 122, 142,  26, 122, 142,  26, 122, 142,  26, 122,
+       236, 105,  88, 236, 105,  88, 236, 105,  88, 236, 105,  88, 236,
+       105,  88, 184, 191,  91, 184, 191,  91, 184, 191,  91, 184, 191,
+        91, 184, 191,  91,  76, 185,  95,  76, 185,  95,  76, 185,  95,
+        76, 185,  95,  76, 185,  95,   0,   0,   0,   0,   0,   0,  64,
+       118,  59,  64, 118,  59,  64, 118,  59,  64, 118,  59,  64, 118,
+        59, 157,  54, 167, 157,  54, 167, 157,  54, 167, 157,  54, 167,
+       157,  54, 167, 142,  26, 122, 142,  26, 122, 142,  26, 122, 142,
+        26, 122, 142,  26, 122, 236, 105,  88, 236, 105,  88, 236, 105,
+        88, 236, 105,  88, 236, 105,  88, 184, 191,  91, 184, 191,  91,
+       184, 191,  91, 184, 191,  91, 184, 191,  91,  76, 185,  95,  76,
+       185,  95,  76, 185,  95,  76, 185,  95,  76, 185,  95,   0,   0,
+         0,   0,   0,   0,  64, 118,  59,  64, 118,  59,  64, 118,  59,
+        64, 118,  59,  64, 118,  59, 157,  54, 167, 157,  54, 167, 157,
+        54, 167, 157,  54, 167, 157,  54, 167, 142,  26, 122, 142,  26,
+       122, 142,  26, 122, 142,  26, 122, 142,  26, 122, 236, 105,  88,
+       236, 105,  88, 236, 105,  88, 236, 105,  88, 236, 105,  88, 184,
+       191,  91, 184, 191,  91, 184, 191,  91, 184, 191,  91, 184, 191,
+        91,  76, 185,  95,  76, 185,  95,  76, 185,  95,  76, 185,  95,
+        76, 185,  95,   0,   0,   0,   0,   0,   0,  64, 118,  59,  64,
+       118,  59,  64, 118,  59,  64, 118,  59,  64, 118,  59, 157,  54,
+       167, 157,  54, 167, 157,  54, 167, 157,  54, 167, 157,  54, 167,
+       142,  26, 122, 142,  26, 122, 142,  26, 122, 142,  26, 122, 142,
+        26, 122, 236, 105,  88, 236, 105,  88, 236, 105,  88, 236, 105,
+        88, 236, 105,  88, 184, 191,  91, 184, 191,  91, 184, 191,  91,
+       184, 191,  91, 184, 191,  91,  76, 185,  95,  76, 185,  95,  76,
+       185,  95,  76, 185,  95,  76, 185,  95,   0,   0,   0,   0,   0,
+         0,  64, 118,  59,  64, 118,  59,  64, 118,  59,  64, 118,  59,
+        64, 118,  59, 157,  54, 167, 157,  54, 167, 157,  54, 167, 157,
+        54, 167, 157,  54, 167, 142,  26, 122, 142,  26, 122, 142,  26,
+       122, 142,  26, 122, 142,  26, 122, 236, 105,  88, 236, 105,  88,
+       236, 105,  88, 236, 105,  88, 236, 105,  88, 184, 191,  91, 184,
+       191,  91, 184, 191,  91, 184, 191,  91, 184, 191,  91,  76, 185,
+        95,  76, 185,  95,  76, 185,  95,  76, 185,  95,  76, 185,  95,
+         0,   0,   0,   0,   0,   0, 247,  90,  80, 247,  90,  80, 247,
+        90,  80, 247,  90,  80, 247,  90,  80, 167, 118,  85, 167, 118,
+        85, 167, 118,  85, 167, 118,  85, 167, 118,  85, 172,  39, 208,
+       172,  39, 208, 172,  39, 208, 172,  39, 208, 172,  39, 208,  60,
+       106, 191,  60, 106, 191,  60, 106, 191,  60, 106, 191,  60, 106,
+       191, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112,
+       114, 163, 112, 228, 201,  50, 228, 201,  50, 228, 201,  50, 228,
+       201,  50, 228, 201,  50,   0,   0,   0,   0,   0,   0, 247,  90,
+        80, 247,  90,  80, 247,  90,  80, 247,  90,  80, 247,  90,  80,
+       167, 118,  85, 167, 118,  85, 167, 118,  85, 167, 118,  85, 167,
+       118,  85, 172,  39, 208, 172,  39, 208, 172,  39, 208, 172,  39,
+       208, 172,  39, 208,  60, 106, 191,  60, 106, 191,  60, 106, 191,
+        60, 106, 191,  60, 106, 191, 114, 163, 112, 114, 163, 112, 114,
+       163, 112, 114, 163, 112, 114, 163, 112, 228, 201,  50, 228, 201,
+        50, 228, 201,  50, 228, 201,  50, 228, 201,  50,   0,   0,   0,
+         0,   0,   0, 247,  90,  80, 247,  90,  80, 247,  90,  80, 247,
+        90,  80, 247,  90,  80, 167, 118,  85, 167, 118,  85, 167, 118,
+        85, 167, 118,  85, 167, 118,  85, 172,  39, 208, 172,  39, 208,
+       172,  39, 208, 172,  39, 208, 172,  39, 208,  60, 106, 191,  60,
+       106, 191,  60, 106, 191,  60, 106, 191,  60, 106, 191, 114, 163,
+       112, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112,
+       228, 201,  50, 228, 201,  50, 228, 201,  50, 228, 201,  50, 228,
+       201,  50,   0,   0,   0,   0,   0,   0, 247,  90,  80, 247,  90,
+        80, 247,  90,  80, 247,  90,  80, 247,  90,  80, 167, 118,  85,
+       167, 118,  85, 167, 118,  85, 167, 118,  85, 167, 118,  85, 172,
+        39, 208, 172,  39, 208, 172,  39, 208, 172,  39, 208, 172,  39,
+       208,  60, 106, 191,  60, 106, 191,  60, 106, 191,  60, 106, 191,
+        60, 106, 191, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114,
+       163, 112, 114, 163, 112, 228, 201,  50, 228, 201,  50, 228, 201,
+        50, 228, 201,  50, 228, 201,  50,   0,   0,   0,   0,   0,   0,
+       247,  90,  80, 247,  90,  80, 247,  90,  80, 247,  90,  80, 247,
+        90,  80, 167, 118,  85, 167, 118,  85, 167, 118,  85, 167, 118,
+        85, 167, 118,  85, 172,  39, 208, 172,  39, 208, 172,  39, 208,
+       172,  39, 208, 172,  39, 208,  60, 106, 191,  60, 106, 191,  60,
+       106, 191,  60, 106, 191,  60, 106, 191, 114, 163, 112, 114, 163,
+       112, 114, 163, 112, 114, 163, 112, 114, 163, 112, 228, 201,  50,
+       228, 201,  50, 228, 201,  50, 228, 201,  50, 228, 201,  50,   0,
+         0,   0,   0,   0,   0,  24, 246,  11,  24, 246,  11,  24, 246,
+        11,  24, 246,  11,  24, 246,  11, 177, 219,   6, 177, 219,   6,
+       177, 219,   6, 177, 219,   6, 177, 219,   6,  77, 188,  37,  77,
+       188,  37,  77, 188,  37,  77, 188,  37,  77, 188,  37,   2, 138,
+       230,   2, 138, 230,   2, 138, 230,   2, 138, 230,   2, 138, 230,
+       159,  74,  81, 159,  74,  81, 159,  74,  81, 159,  74,  81, 159,
+        74,  81, 240,  63,  27, 240,  63,  27, 240,  63,  27, 240,  63,
+        27, 240,  63,  27,   0,   0,   0,   0,   0,   0,  24, 246,  11,
+        24, 246,  11,  24, 246,  11,  24, 246,  11,  24, 246,  11, 177,
+       219,   6, 177, 219,   6, 177, 219,   6, 177, 219,   6, 177, 219,
+         6,  77, 188,  37,  77, 188,  37,  77, 188,  37,  77, 188,  37,
+        77, 188,  37,   2, 138, 230,   2, 138, 230,   2, 138, 230,   2,
+       138, 230,   2, 138, 230, 159,  74,  81, 159,  74,  81, 159,  74,
+        81, 159,  74,  81, 159,  74,  81, 240,  63,  27, 240,  63,  27,
+       240,  63,  27, 240,  63,  27, 240,  63,  27,   0,   0,   0,   0,
+         0,   0,  24, 246,  11,  24, 246,  11,  24, 246,  11,  24, 246,
+        11,  24, 246,  11, 177, 219,   6, 177, 219,   6, 177, 219,   6,
+       177, 219,   6, 177, 219,   6,  77, 188,  37,  77, 188,  37,  77,
+       188,  37,  77, 188,  37,  77, 188,  37,   2, 138, 230,   2, 138,
+       230,   2, 138, 230,   2, 138, 230,   2, 138, 230, 159,  74,  81,
+       159,  74,  81, 159,  74,  81, 159,  74,  81, 159,  74,  81, 240,
+        63,  27, 240,  63,  27, 240,  63,  27, 240,  63,  27, 240,  63,
+        27,   0,   0,   0,   0,   0,   0,  24, 246,  11,  24, 246,  11,
+        24, 246,  11,  24, 246,  11,  24, 246,  11, 177, 219,   6, 177,
+       219,   6, 177, 219,   6, 177, 219,   6, 177, 219,   6,  77, 188,
+        37,  77, 188,  37,  77, 188,  37,  77, 188,  37,  77, 188,  37,
+         2, 138, 230,   2, 138, 230,   2, 138, 230,   2, 138, 230,   2,
+       138, 230, 159,  74,  81, 159,  74,  81, 159,  74,  81, 159,  74,
+        81, 159,  74,  81, 240,  63,  27, 240,  63,  27, 240,  63,  27,
+       240,  63,  27, 240,  63,  27,   0,   0,   0,   0,   0,   0,  24,
+       246,  11,  24, 246,  11,  24, 246,  11,  24, 246,  11,  24, 246,
+        11, 177, 219,   6, 177, 219,   6, 177, 219,   6, 177, 219,   6,
+       177, 219,   6,  77, 188,  37,  77, 188,  37,  77, 188,  37,  77,
+       188,  37,  77, 188,  37,   2, 138, 230,   2, 138, 230,   2, 138,
+       230,   2, 138, 230,   2, 138, 230, 159,  74,  81, 159,  74,  81,
+       159,  74,  81, 159,  74,  81, 159,  74,  81, 240,  63,  27, 240,
+        63,  27, 240,  63,  27, 240,  63,  27, 240,  63,  27,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0], dtype=np.uint8),
+    image_decoder_decode_bmp_rgb.output,
+)
+
+image_decoder_decode_webp_rgb = ImageData(
+    np.array([ 82,  73,  70,  70,  32,   2,   0,   0,  87,  69,  66,  80,  86,
+        80,  56,  32,  20,   2,   0,   0,  80,  13,   0, 157,   1,  42,
+        32,   0,  32,   0,  62, 109,  46, 146,  70, 164,  34, 161, 161,
+        40,  13,  80, 128,  13, 137, 108,   0, 157,  50, 132, 112,  55,
+       151, 254,  57, 126,  51, 115, 134, 108,  25, 128,  93, 115, 126,
+        83, 204,   7, 168,  15, 178, 191,  82,  95,  48,  15, 232,  29,
+        32,  63,  93, 191, 183, 117, 128, 253,  57, 246,   0, 255, 147,
+       230, 171, 236,   1, 232,   1, 230, 153, 254, 107, 245, 239, 225,
+        11, 246,  51, 246, 239, 218, 118, 236, 247,  43, 147,  15, 163,
+       180,   0, 165,  21, 251,  68,  81,  89, 121,  30,  65, 221, 213,
+       115, 111, 216, 229,  96,   0, 253, 210, 122, 138,  75,  92, 219,
+       102,  22,  86, 171, 131, 154,   9,  97, 230, 179, 178,  43,  43,
+       206,  57, 143,  19, 232, 129,  21, 139,  23, 214, 170,  75,  14,
+        52,  78, 111,  88,  54,   0, 216, 240,  73,  98, 154, 194,  36,
+        47,  34,  68, 148, 194, 197,  79,  81, 220, 205, 223,  88, 250,
+        42,  71, 218,  15, 124, 129,  12,  38, 200, 116, 251,  93, 147,
+        57,  36, 183, 245,  31, 100, 160, 116, 212, 180,  65, 118,  26,
+         4, 133, 242, 198,  50,  89,  34, 109, 244, 199, 253,  50, 134,
+       185,  19, 231, 104,  63, 202, 255, 252, 169,  61, 255, 112,  75,
+        33, 165, 235, 249, 208, 254,  59, 253,  66, 115, 104,   1, 198,
+        21, 242, 126, 158, 181, 152,  55,  50,  77,  29,  83,   7,  74,
+       139,   7, 157, 145, 131, 163,   5, 105, 181, 174,  38, 245,  83,
+        73, 183, 195, 243, 162, 207, 173, 142,  14,  38, 114, 149, 107,
+       162,   8,  74, 172,  85, 135, 196,  54,  62,  66, 159,  28, 239,
+       150,  13,   1, 197, 236, 121, 183,  69, 189,  23, 138,  22,  15,
+       245, 216, 244,  67, 220, 105,  77,  80, 101, 145,  47, 254,  82,
+        86, 190, 233,  60, 253, 192, 109,  30, 199, 255, 255,  11, 191,
+       132, 172, 157, 189, 172,  98,  91, 223,  41, 168,  79, 177, 124,
+       248, 219,  66,  28,  89, 184, 193, 218,  73, 123, 199, 170, 197,
+        85,  60, 244, 144,  65, 180,  53,  51,  76, 101, 246,  98, 255,
+       202, 147, 239, 114,  41,  19, 231, 202, 205,   1,  24,  55,  73,
+       164, 212,  62, 253, 138, 147, 181,  58, 249, 167,  19, 186, 248,
+       198, 120,  78, 227, 215,   3, 206, 125, 176, 241, 255, 249, 143,
+        31,  16, 189, 165, 240, 216,  14,  60,  28, 102, 246,  10, 178,
+         9,  29, 179, 207, 170,  34,  51, 136, 167, 194, 160,  17, 118,
+       203, 188,  35, 229, 124, 128, 245, 253, 232, 250,  94,  77, 150,
+       161,  46,   3, 185, 215,  69, 122, 167, 159, 211, 209, 119, 111,
+       211, 153, 178, 160, 153, 174, 180, 229,  61,  15, 196, 225,  48,
+        93, 243, 101,  64, 200,  23,  47, 211, 242,  50,  31, 133, 231,
+        63, 151, 123,  87, 178,  77, 165, 172, 205,  35, 249, 186, 231,
+       150, 205, 218, 230, 245,  10,  39,  42, 157, 116, 223, 241, 120,
+       201,  34,  28,  59, 113,  38, 151,  73,  39, 119, 255, 227, 105,
+        45, 148,  84,   0,   0,   0], dtype=np.uint8),
+    np.array([[[230,  84, 242],
+        [230,  84, 240],
+        [232,  84, 238],
+        [225,  94, 202],
+        [207, 108, 126],
+        [255, 199, 131],
+        [243, 221,  74],
+        [229, 229,  47],
+        [232, 234,  65],
+        [228, 231,  61],
+        [228, 226,  43],
+        [228, 223,  31],
+        [232, 225,  31],
+        [227, 221,  34],
+        [224, 219,  43],
+        [255, 250,  82],
+        [255, 247,  84],
+        [255, 248,  82],
+        [254, 253,  76],
+        [255, 236, 130],
+        [121,  22,  71],
+        [132,   5, 128],
+        [126,  10, 122],
+        [105,  23, 107],
+        [ 70,  43,  86],
+        [ 90, 125, 122],
+        [ 49, 154,  98],
+        [ 27, 166,  83],
+        [ 29, 168,  80],
+        [ 48, 155,  87],
+        [  0,  13,   0],
+        [  0,   0,   0]],
+
+       [[229,  84, 244],
+        [229,  84, 242],
+        [229,  85, 240],
+        [222,  95, 204],
+        [205, 108, 130],
+        [255, 198, 137],
+        [244, 219,  80],
+        [232, 227,  49],
+        [235, 233,  61],
+        [232, 230,  55],
+        [228, 227,  39],
+        [227, 224,  29],
+        [230, 226,  31],
+        [225, 222,  32],
+        [223, 220,  41],
+        [255, 251,  80],
+        [255, 249,  82],
+        [255, 250,  80],
+        [252, 254,  76],
+        [255, 237, 130],
+        [118,  23,  71],
+        [130,   6, 126],
+        [126,  10, 122],
+        [107,  22, 109],
+        [ 70,  43,  84],
+        [ 90, 125, 120],
+        [ 51, 153,  98],
+        [ 31, 165,  83],
+        [ 32, 167,  80],
+        [ 50, 154,  87],
+        [  0,  13,   0],
+        [  0,   0,   0]],
+
+       [[224,  86, 246],
+        [224,  86, 246],
+        [222,  87, 244],
+        [217,  96, 210],
+        [202, 108, 138],
+        [255, 196, 147],
+        [249, 215,  90],
+        [239, 223,  55],
+        [240, 233,  53],
+        [235, 231,  43],
+        [230, 228,  33],
+        [227, 224,  27],
+        [227, 227,  31],
+        [224, 223,  32],
+        [221, 221,  37],
+        [252, 254,  76],
+        [252, 254,  76],
+        [250, 254,  76],
+        [247, 255,  76],
+        [255, 238, 132],
+        [115,  25,  69],
+        [129,   7, 126],
+        [126,   9, 126],
+        [107,  21, 112],
+        [ 70,  43,  82],
+        [ 92, 125, 116],
+        [ 56, 152,  94],
+        [ 35, 163,  81],
+        [ 37, 164,  80],
+        [ 55, 151,  89],
+        [  0,  11,   0],
+        [  0,   0,   2]],
+
+       [[208,  93, 250],
+        [208,  93, 250],
+        [208,  93, 250],
+        [205, 101, 218],
+        [194, 111, 148],
+        [255, 195, 157],
+        [255, 209, 104],
+        [250, 215,  67],
+        [255, 222,  63],
+        [252, 220,  53],
+        [249, 215,  49],
+        [246, 211,  47],
+        [245, 214,  54],
+        [237, 212,  56],
+        [231, 212,  59],
+        [255, 249,  94],
+        [244, 254,  94],
+        [239, 255,  94],
+        [239, 255,  96],
+        [252, 241, 142],
+        [103,  33,  59],
+        [116,  17, 107],
+        [116,  17, 107],
+        [100,  27,  97],
+        [ 69,  46,  74],
+        [ 95, 124, 112],
+        [ 64, 147,  98],
+        [ 47, 156,  87],
+        [ 48, 157,  88],
+        [ 63, 146,  95],
+        [  0,   9,   0],
+        [  0,   0,   2]],
+
+       [[183, 109, 255],
+        [183, 109, 255],
+        [185, 108, 255],
+        [186, 113, 229],
+        [189, 120, 166],
+        [255, 195, 174],
+        [255, 217, 133],
+        [255, 208,  93],
+        [255, 202,  86],
+        [255, 195,  84],
+        [255, 183,  86],
+        [255, 176,  88],
+        [255, 180,  98],
+        [255, 183, 101],
+        [255, 202, 115],
+        [255, 230, 132],
+        [235, 247, 134],
+        [223, 254, 132],
+        [224, 253, 130],
+        [235, 242, 158],
+        [ 84,  46,  41],
+        [ 95,  35,  69],
+        [ 97,  34,  69],
+        [ 86,  41,  65],
+        [ 70,  57,  64],
+        [102, 125, 112],
+        [ 77, 135, 104],
+        [ 69, 143, 104],
+        [ 72, 147, 108],
+        [ 77, 134, 108],
+        [  0,  11,   3],
+        [  0,   0,   2]],
+
+       [[ 55,  31, 165],
+        [ 57,  30, 167],
+        [ 62,  27, 171],
+        [ 70,  28, 142],
+        [ 78,  26,  78],
+        [123,  60,  52],
+        [140,  64,   1],
+        [155,  66,   0],
+        [155,  55,   0],
+        [174,  52,   0],
+        [199,  48,  10],
+        [208,  48,  25],
+        [204,  54,  38],
+        [183,  56,  38],
+        [164,  79,  44],
+        [146, 109,  58],
+        [ 93, 112,  37],
+        [ 75, 121,  35],
+        [ 77, 121,  33],
+        [ 85, 115,  43],
+        [184, 183, 147],
+        [194, 177, 155],
+        [195, 176, 153],
+        [190, 178, 157],
+        [176, 176, 163],
+        [ 92, 107,  97],
+        [ 83, 114, 106],
+        [ 77, 116, 110],
+        [ 75, 115, 111],
+        [ 81, 110, 109],
+        [  0,   1,   4],
+        [  0,   0,   1]],
+
+       [[ 20,  51, 168],
+        [ 23,  48, 172],
+        [ 31,  43, 176],
+        [ 47,  40, 150],
+        [ 78,  46, 100],
+        [121,  61,  63],
+        [142,  53,   8],
+        [165,  60,   0],
+        [163,  46,   0],
+        [189,  45,  18],
+        [229,  39,  48],
+        [248,  40,  72],
+        [233,  35,  75],
+        [201,  39,  71],
+        [163,  64,  72],
+        [131,  95,  79],
+        [ 84, 113,  74],
+        [ 63, 124,  72],
+        [ 63, 124,  72],
+        [ 70, 123,  64],
+        [158, 197, 127],
+        [164, 195, 118],
+        [164, 195, 116],
+        [167, 191, 129],
+        [170, 182, 150],
+        [103, 108, 104],
+        [ 98,  99, 119],
+        [ 93,  93, 125],
+        [ 95,  93, 130],
+        [ 96,  96, 125],
+        [  0,   0,  11],
+        [  0,   2,   7]],
+
+       [[  0,  55, 168],
+        [  3,  53, 168],
+        [ 13,  47, 172],
+        [ 32,  43, 146],
+        [ 58,  36,  91],
+        [121,  63,  71],
+        [155,  58,  22],
+        [173,  56,   4],
+        [170,  47,   9],
+        [191,  38,  30],
+        [232,  22,  63],
+        [249,  17,  84],
+        [255,  30, 102],
+        [220,  32,  93],
+        [171,  56,  90],
+        [128,  89,  95],
+        [ 77, 112,  89],
+        [ 53, 125,  85],
+        [ 51, 126,  85],
+        [ 56, 127,  69],
+        [147, 207, 119],
+        [152, 208, 103],
+        [151, 209, 101],
+        [157, 203, 117],
+        [166, 187, 146],
+        [105, 105, 105],
+        [102,  87, 122],
+        [106,  84, 139],
+        [113,  92, 149],
+        [108,  95, 138],
+        [  1,   0,  13],
+        [  0,   2,   3]],
+
+       [[  7,  56, 174],
+        [ 10,  55, 172],
+        [ 16,  52, 168],
+        [ 34,  48, 141],
+        [ 61,  38,  94],
+        [122,  60,  74],
+        [152,  50,  20],
+        [167,  45,   0],
+        [171,  48,   8],
+        [184,  32,  26],
+        [232,  28,  78],
+        [248,  16,  96],
+        [254,  20,  99],
+        [228,  28,  95],
+        [180,  53,  93],
+        [120,  73,  82],
+        [ 78, 114,  88],
+        [ 49, 129,  84],
+        [ 47, 131,  80],
+        [ 54, 130,  66],
+        [145, 210, 118],
+        [152, 210, 102],
+        [150, 212, 100],
+        [157, 205, 116],
+        [169, 189, 148],
+        [104, 102, 102],
+        [112,  92, 133],
+        [111,  86, 145],
+        [108,  89, 148],
+        [104,  93, 134],
+        [  2,   0,   4],
+        [  1,   3,   0]],
+
+       [[ 15,  58, 141],
+        [ 16,  58, 139],
+        [ 21,  56, 137],
+        [ 36,  51, 123],
+        [ 59,  39,  94],
+        [119,  58,  92],
+        [149,  44,  57],
+        [162,  39,  39],
+        [165,  44,  48],
+        [168,  36,  49],
+        [197,  45,  71],
+        [199,  35,  65],
+        [210,  39,  65],
+        [201,  54,  72],
+        [157,  65,  73],
+        [116,  83,  78],
+        [ 78, 111,  91],
+        [ 56, 122,  93],
+        [ 54, 123,  91],
+        [ 59, 122,  85],
+        [152, 200, 154],
+        [157, 199, 146],
+        [155, 200, 146],
+        [163, 194, 156],
+        [175, 178, 177],
+        [114,  93, 123],
+        [123,  80, 135],
+        [125,  73, 143],
+        [125,  80, 148],
+        [117,  83, 133],
+        [  6,   0,   6],
+        [  0,   0,   0]],
+
+       [[ 28,  65,  73],
+        [ 28,  64,  77],
+        [ 28,  63,  83],
+        [ 39,  56,  91],
+        [ 56,  41,  94],
+        [111,  56, 127],
+        [137,  37, 125],
+        [149,  29, 124],
+        [141,  26, 117],
+        [144,  50,  98],
+        [168, 112,  76],
+        [164, 128,  45],
+        [163, 130,  36],
+        [151, 124,  40],
+        [149, 134,  75],
+        [206, 206, 174],
+        [191, 212, 205],
+        [181, 214, 221],
+        [179, 214, 225],
+        [183, 210, 235],
+        [113, 125, 173],
+        [116, 122, 183],
+        [114, 122, 187],
+        [124, 116, 189],
+        [142, 109, 189],
+        [195, 134, 218],
+        [215, 126, 210],
+        [228, 123, 209],
+        [223, 120, 207],
+        [209, 129, 199],
+        [ 20,   0,  18],
+        [  6,   0,   8]],
+
+       [[ 37,  66,  43],
+        [ 36,  66,  47],
+        [ 34,  65,  55],
+        [ 40,  59,  69],
+        [ 54,  43,  88],
+        [106,  56, 137],
+        [130,  35, 156],
+        [140,  26, 164],
+        [133,  25, 157],
+        [128,  56, 119],
+        [133, 126,  55],
+        [117, 147,   5],
+        [118, 151,   4],
+        [119, 152,  20],
+        [123, 147,  55],
+        [197, 218, 170],
+        [191, 211, 211],
+        [189, 208, 233],
+        [189, 206, 239],
+        [192, 201, 255],
+        [117, 115, 212],
+        [121, 110, 230],
+        [121, 109, 234],
+        [130, 105, 230],
+        [148,  97, 215],
+        [207, 125, 234],
+        [228, 114, 212],
+        [242, 111, 203],
+        [244, 109, 207],
+        [222, 118, 197],
+        [ 26,   0,  20],
+        [  3,   0,  10]],
+
+       [[ 42,  62,  49],
+        [ 40,  63,  49],
+        [ 37,  64,  51],
+        [ 42,  60,  61],
+        [ 55,  48,  78],
+        [ 96,  53, 120],
+        [118,  31, 142],
+        [137,  31, 163],
+        [133,  32, 160],
+        [120,  54, 113],
+        [129, 125,  49],
+        [113, 143,   0],
+        [114, 149,   7],
+        [115, 149,  24],
+        [117, 146,  54],
+        [191, 217, 167],
+        [186, 213, 213],
+        [186, 208, 237],
+        [189, 206, 239],
+        [191, 202, 255],
+        [113, 115, 215],
+        [115, 111, 233],
+        [118, 109, 233],
+        [129, 105, 227],
+        [150, 100, 213],
+        [204, 123, 228],
+        [230, 117, 212],
+        [242, 111, 203],
+        [246, 112, 207],
+        [223, 120, 194],
+        [ 27,   0,  18],
+        [  3,   0,   4]],
+
+       [[ 42,  63,  45],
+        [ 40,  64,  45],
+        [ 37,  65,  47],
+        [ 42,  61,  57],
+        [ 61,  55,  80],
+        [102,  60, 122],
+        [124,  38, 144],
+        [143,  38, 165],
+        [139,  37, 162],
+        [123,  49, 112],
+        [149, 134,  73],
+        [129, 142,  22],
+        [131, 143,  27],
+        [131, 143,  41],
+        [132, 142,  66],
+        [206, 215, 173],
+        [201, 209, 213],
+        [201, 206, 231],
+        [204, 204, 231],
+        [202, 202, 246],
+        [119, 119, 199],
+        [119, 117, 213],
+        [120, 116, 211],
+        [130, 112, 205],
+        [142, 105, 190],
+        [198, 137, 215],
+        [212, 126, 196],
+        [225, 122, 191],
+        [231, 131, 199],
+        [212, 135, 188],
+        [ 21,   0,  14],
+        [  2,   0,   3]],
+
+       [[ 41,  72,  34],
+        [ 39,  72,  38],
+        [ 37,  71,  46],
+        [ 44,  65,  60],
+        [ 61,  52,  82],
+        [104,  56, 122],
+        [127,  35, 139],
+        [148,  34, 159],
+        [139,  23, 151],
+        [134,  41, 122],
+        [157, 110,  92],
+        [152, 124,  56],
+        [151, 119,  50],
+        [155, 120,  59],
+        [156, 120,  77],
+        [231, 193, 174],
+        [230, 195, 202],
+        [228, 194, 212],
+        [228, 194, 208],
+        [222, 196, 216],
+        [129, 120, 157],
+        [122, 122, 165],
+        [122, 123, 161],
+        [124, 123, 157],
+        [131, 121, 154],
+        [174, 153, 183],
+        [187, 149, 173],
+        [185, 140, 162],
+        [188, 151, 170],
+        [178, 151, 167],
+        [ 10,   0,  10],
+        [  2,   0,   6]],
+
+       [[ 72, 113,  67],
+        [ 72, 112,  71],
+        [ 70, 112,  79],
+        [ 80, 104,  93],
+        [ 86,  77, 103],
+        [128,  82, 143],
+        [152,  60, 162],
+        [174,  58, 182],
+        [165,  47, 173],
+        [162,  58, 153],
+        [125,  50,  76],
+        [122,  58,  47],
+        [120,  49,  36],
+        [125,  50,  39],
+        [128,  51,  45],
+        [204, 127, 128],
+        [195, 118, 126],
+        [193, 119, 126],
+        [193, 120, 122],
+        [179, 127, 124],
+        [190, 176, 169],
+        [178, 182, 171],
+        [178, 182, 167],
+        [175, 184, 167],
+        [167, 184, 165],
+        [136, 155, 135],
+        [137, 150, 127],
+        [138, 151, 128],
+        [134, 154, 129],
+        [137, 154, 137],
+        [  0,   0,   0],
+        [  2,   0,   4]],
+
+       [[ 64, 116,  73],
+        [ 65, 115,  73],
+        [ 67, 114,  73],
+        [ 76, 108,  83],
+        [ 97,  95, 107],
+        [121,  78, 129],
+        [146,  60, 155],
+        [159,  51, 169],
+        [159,  49, 168],
+        [163,  55, 159],
+        [135,  37, 111],
+        [137,  38,  97],
+        [139,  35,  90],
+        [141,  33,  81],
+        [143,  35,  67],
+        [221, 110, 129],
+        [220, 108, 112],
+        [222, 109, 104],
+        [222, 109, 102],
+        [201, 121,  98],
+        [200, 179, 129],
+        [181, 189, 125],
+        [181, 189, 125],
+        [173, 193, 125],
+        [153, 199, 125],
+        [112, 174,  98],
+        [103, 172, 101],
+        [101, 174, 106],
+        [ 96, 171, 105],
+        [112, 168, 117],
+        [  0,   8,   0],
+        [  2,   3,   0]],
+
+       [[ 60, 118,  71],
+        [ 62, 117,  71],
+        [ 64, 117,  69],
+        [ 75, 109,  79],
+        [ 95,  97, 101],
+        [117,  81, 125],
+        [143,  62, 153],
+        [157,  52, 167],
+        [159,  50, 164],
+        [164,  53, 164],
+        [143,  29, 129],
+        [145,  30, 121],
+        [146,  26, 117],
+        [149,  25, 103],
+        [152,  28,  81],
+        [232, 104, 131],
+        [233, 104, 102],
+        [236, 104,  90],
+        [238, 103,  90],
+        [214, 117,  84],
+        [203, 181, 107],
+        [181, 194, 101],
+        [181, 194, 101],
+        [171, 198, 103],
+        [147, 207, 104],
+        [102, 182,  80],
+        [ 87, 183,  87],
+        [ 84, 185,  94],
+        [ 80, 181,  92],
+        [ 99, 177, 107],
+        [  0,  12,   0],
+        [  0,   7,   0]],
+
+       [[ 62, 119,  63],
+        [ 62, 119,  63],
+        [ 64, 118,  65],
+        [ 73, 110,  77],
+        [ 93,  98,  99],
+        [117,  81, 123],
+        [143,  63, 149],
+        [159,  52, 163],
+        [163,  48, 164],
+        [169,  51, 162],
+        [145,  29, 125],
+        [145,  30, 119],
+        [146,  27, 115],
+        [148,  26, 103],
+        [151,  28,  81],
+        [232, 105, 129],
+        [236, 102, 100],
+        [239, 103,  88],
+        [239, 103,  90],
+        [215, 116,  82],
+        [203, 182, 101],
+        [179, 196,  95],
+        [179, 195,  97],
+        [170, 199, 101],
+        [148, 206, 104],
+        [104, 182,  80],
+        [ 91, 181,  85],
+        [ 87, 184,  90],
+        [ 82, 181,  88],
+        [ 99, 177, 105],
+        [  0,  14,   0],
+        [  0,   9,   0]],
+
+       [[ 97, 102,  55],
+        [ 97, 102,  57],
+        [ 99, 101,  59],
+        [105,  96,  67],
+        [117,  88,  85],
+        [130,  78, 105],
+        [145,  67, 125],
+        [153,  61, 135],
+        [155,  58, 134],
+        [163,  58, 143],
+        [143,  29, 129],
+        [146,  26, 135],
+        [144,  24, 131],
+        [141,  25, 121],
+        [138,  30, 105],
+        [211, 109, 162],
+        [206, 111, 134],
+        [204, 114, 124],
+        [204, 114, 124],
+        [187, 125, 112],
+        [189, 186, 121],
+        [171, 197, 107],
+        [171, 197, 109],
+        [167, 200, 109],
+        [155, 202, 106],
+        [118, 175,  74],
+        [113, 173,  69],
+        [111, 176,  68],
+        [106, 173,  66],
+        [117, 171,  89],
+        [  0,  11,   0],
+        [  0,   7,   0]],
+
+       [[205, 108,  89],
+        [207, 107,  89],
+        [210, 106,  89],
+        [210, 105,  91],
+        [204, 107,  99],
+        [192, 106, 103],
+        [180, 107, 111],
+        [172, 107, 113],
+        [167, 110, 111],
+        [174, 103, 138],
+        [164,  55, 167],
+        [170,  43, 193],
+        [170,  43, 191],
+        [161,  50, 188],
+        [142,  60, 186],
+        [124,  73, 179],
+        [103,  86, 165],
+        [ 92,  96, 156],
+        [ 89,  98, 152],
+        [ 88, 104, 131],
+        [123, 153, 125],
+        [122, 158, 101],
+        [119, 161,  97],
+        [122, 160,  90],
+        [129, 161,  77],
+        [188, 209, 108],
+        [202, 208,  85],
+        [205, 206,  74],
+        [204, 212,  79],
+        [197, 205, 104],
+        [  6,   5,   0],
+        [  1,   0,   0]],
+
+       [[240,  92,  81],
+        [242,  91,  81],
+        [245,  90,  81],
+        [240,  92,  83],
+        [228,  98,  85],
+        [207, 102,  85],
+        [182, 111,  87],
+        [165, 116,  85],
+        [159, 119,  83],
+        [170, 108, 122],
+        [164,  53, 173],
+        [171,  39, 207],
+        [168,  41, 205],
+        [156,  49, 208],
+        [131,  61, 212],
+        [103,  77, 209],
+        [ 73,  95, 199],
+        [ 58, 106, 192],
+        [ 53, 109, 188],
+        [ 59, 113, 159],
+        [111, 156, 143],
+        [115, 159, 113],
+        [112, 162, 109],
+        [117, 161,  99],
+        [134, 158,  82],
+        [201, 203, 102],
+        [222, 201,  69],
+        [229, 198,  52],
+        [226, 205,  57],
+        [215, 199,  86],
+        [ 14,   2,   0],
+        [  4,   0,   0]],
+
+       [[242,  93,  73],
+        [242,  92,  75],
+        [245,  90,  79],
+        [239,  93,  81],
+        [226,  99,  85],
+        [205, 104,  83],
+        [182, 111,  83],
+        [167, 116,  81],
+        [164, 117,  81],
+        [173, 107, 120],
+        [166,  53, 169],
+        [171,  40, 205],
+        [168,  42, 203],
+        [155,  50, 206],
+        [129,  62, 212],
+        [103,  77, 209],
+        [ 75,  94, 197],
+        [ 60, 105, 190],
+        [ 57, 107, 188],
+        [ 61, 113, 157],
+        [111, 157, 137],
+        [114, 161, 107],
+        [111, 163, 105],
+        [117, 162,  94],
+        [134, 158,  80],
+        [202, 202, 102],
+        [226, 199,  67],
+        [231, 198,  48],
+        [228, 205,  53],
+        [215, 200,  84],
+        [ 12,   3,   0],
+        [  1,   0,   0]],
+
+       [[212, 111,  58],
+        [212, 111,  60],
+        [213, 109,  64],
+        [210, 110,  66],
+        [201, 115,  68],
+        [187, 116,  67],
+        [172, 120,  65],
+        [162, 121,  64],
+        [159, 123,  64],
+        [166, 114, 102],
+        [154,  64, 142],
+        [157,  52, 176],
+        [152,  55, 176],
+        [140,  61, 184],
+        [118,  71, 192],
+        [ 95,  84, 197],
+        [ 67,  98, 197],
+        [ 53, 107, 196],
+        [ 50, 110, 192],
+        [ 59, 113, 161],
+        [115, 155, 137],
+        [123, 157, 105],
+        [120, 159, 103],
+        [127, 157,  94],
+        [145, 153,  80],
+        [213, 196, 104],
+        [238, 192,  73],
+        [245, 190,  56],
+        [241, 197,  61],
+        [224, 193,  92],
+        [ 14,   2,   0],
+        [  0,   0,   0]],
+
+       [[149, 147,  36],
+        [149, 147,  38],
+        [151, 146,  38],
+        [151, 145,  40],
+        [154, 144,  40],
+        [158, 145,  43],
+        [153, 135,  34],
+        [160, 142,  43],
+        [152, 139,  39],
+        [160, 139,  73],
+        [127,  84,  92],
+        [129,  81, 124],
+        [122,  83, 128],
+        [104,  80, 131],
+        [ 99,  94, 155],
+        [ 76,  98, 173],
+        [ 58, 114, 204],
+        [ 43, 119, 214],
+        [ 40, 121, 210],
+        [ 58, 119, 176],
+        [125, 146, 144],
+        [141, 145, 109],
+        [140, 146, 107],
+        [146, 145,  97],
+        [167, 144,  86],
+        [232, 182, 108],
+        [255, 181,  91],
+        [255, 168,  68],
+        [255, 179,  80],
+        [238, 174, 102],
+        [ 26,   3,   0],
+        [  1,   0,   0]],
+
+       [[106, 198,  38],
+        [108, 198,  36],
+        [108, 198,  36],
+        [114, 195,  34],
+        [130, 193,  35],
+        [173, 212,  60],
+        [190, 205,  59],
+        [195, 197,  55],
+        [190, 198,  52],
+        [191, 199,  80],
+        [142, 150,  88],
+        [136, 148, 115],
+        [120, 142, 109],
+        [117, 148, 128],
+        [104, 149, 152],
+        [ 60, 122, 161],
+        [ 39, 124, 202],
+        [ 27, 125, 222],
+        [ 24, 127, 220],
+        [ 51, 121, 184],
+        [ 97,  98, 107],
+        [123,  92,  73],
+        [121,  93,  71],
+        [128,  92,  61],
+        [142,  86,  43],
+        [183,  98,  45],
+        [205,  88,  22],
+        [214,  84,  14],
+        [206,  83,  15],
+        [181,  89,  40],
+        [ 23,   0,   0],
+        [  3,   0,   2]],
+
+       [[ 46, 230,  22],
+        [ 48, 230,  20],
+        [ 51, 229,  16],
+        [ 64, 223,  10],
+        [ 80, 207,   0],
+        [143, 231,  30],
+        [180, 220,  31],
+        [186, 207,  20],
+        [186, 213,  21],
+        [175, 214,  44],
+        [111, 171,  42],
+        [ 95, 170,  60],
+        [ 92, 172,  60],
+        [ 91, 181,  87],
+        [ 73, 177, 124],
+        [ 23, 137, 135],
+        [ 18, 135, 196],
+        [ 11, 133, 224],
+        [  8, 134, 226],
+        [ 43, 124, 190],
+        [115,  94, 111],
+        [152,  83,  74],
+        [147,  84,  78],
+        [155,  82,  70],
+        [182,  80,  60],
+        [209,  84,  53],
+        [219,  71,  30],
+        [232,  73,  29],
+        [220,  66,  20],
+        [194,  79,  45],
+        [ 29,   0,   0],
+        [  8,   3,   7]],
+
+       [[ 22, 251,  21],
+        [ 24, 250,  19],
+        [ 27, 250,  13],
+        [ 43, 243,   5],
+        [ 73, 231,   0],
+        [130, 241,  19],
+        [167, 224,  13],
+        [182, 213,   7],
+        [185, 221,  13],
+        [169, 225,  31],
+        [ 95, 184,  20],
+        [ 76, 182,  35],
+        [ 75, 183,  35],
+        [ 69, 187,  61],
+        [ 53, 186, 109],
+        [ 16, 155, 138],
+        [  7, 141, 194],
+        [  2, 138, 224],
+        [  0, 139, 226],
+        [ 40, 125, 192],
+        [119,  88, 110],
+        [161,  74,  76],
+        [158,  75,  80],
+        [166,  72,  74],
+        [181,  62,  54],
+        [217,  76,  60],
+        [231,  69,  41],
+        [237,  67,  35],
+        [235,  65,  31],
+        [205,  74,  50],
+        [ 30,   0,   0],
+        [  3,   0,   2]],
+
+       [[ 24, 246,  19],
+        [ 24, 246,  17],
+        [ 28, 246,  10],
+        [ 42, 240,   4],
+        [ 71, 232,   0],
+        [130, 243,  21],
+        [164, 225,  13],
+        [175, 213,   9],
+        [176, 219,  15],
+        [163, 224,  33],
+        [ 85, 179,  11],
+        [ 69, 176,  24],
+        [ 79, 184,  39],
+        [ 73, 185,  70],
+        [ 53, 179, 114],
+        [ 11, 145, 136],
+        [  6, 145, 198],
+        [  1, 142, 226],
+        [  1, 142, 224],
+        [ 42, 128, 192],
+        [117,  90, 117],
+        [159,  76,  83],
+        [159,  76,  83],
+        [167,  72,  79],
+        [188,  74,  74],
+        [209,  74,  63],
+        [229,  70,  49],
+        [237,  66,  37],
+        [239,  70,  36],
+        [202,  72,  46],
+        [ 37,   0,   0],
+        [  4,   0,   0]],
+
+       [[ 60, 221,  53],
+        [ 58, 222,  51],
+        [ 58, 223,  47],
+        [ 68, 219,  43],
+        [ 87, 211,  37],
+        [135, 224,  55],
+        [166, 214,  55],
+        [181, 210,  57],
+        [174, 208,  57],
+        [163, 211,  70],
+        [106, 175,  47],
+        [ 94, 171,  56],
+        [ 96, 172,  67],
+        [ 90, 169,  88],
+        [ 76, 167, 125],
+        [ 43, 141, 140],
+        [ 28, 132, 175],
+        [ 25, 131, 193],
+        [ 25, 131, 193],
+        [ 56, 119, 166],
+        [113,  91, 112],
+        [143,  81,  88],
+        [145,  80,  88],
+        [151,  78,  82],
+        [164,  80,  77],
+        [180,  81,  71],
+        [196,  78,  63],
+        [203,  74,  54],
+        [206,  76,  51],
+        [178,  79,  58],
+        [ 31,   0,   0],
+        [  8,   0,   0]],
+
+       [[  0,  24,   0],
+        [  0,  25,   0],
+        [  0,  27,   0],
+        [  0,  26,   0],
+        [  0,  24,   0],
+        [  0,  28,   0],
+        [  0,  13,   0],
+        [  1,  11,   0],
+        [  0,  14,   0],
+        [  0,  13,   0],
+        [  0,  10,   0],
+        [  0,   7,   0],
+        [  0,  15,   0],
+        [  0,  10,   0],
+        [  0,  13,   7],
+        [  0,   4,   9],
+        [  0,   5,  24],
+        [  0,   5,  28],
+        [  0,   6,  28],
+        [  0,   1,  17],
+        [  4,   0,   0],
+        [ 16,   0,   0],
+        [ 15,   0,   0],
+        [ 16,   0,   0],
+        [ 20,   0,   0],
+        [ 28,   0,   0],
+        [ 33,   0,   0],
+        [ 34,   0,   0],
+        [ 36,   0,   0],
+        [ 29,   0,   0],
+        [ 10,   0,   0],
+        [  2,   0,   0]],
+
+       [[  4,   0,   1],
+        [  1,   1,   1],
+        [  0,   4,   1],
+        [  0,   5,   1],
+        [  0,   3,   0],
+        [  0,   8,   5],
+        [  0,   0,   0],
+        [  4,   7,   6],
+        [  0,   1,   0],
+        [  0,   0,   0],
+        [  6,   0,   0],
+        [  7,   0,   0],
+        [ 12,   0,   6],
+        [  2,   0,   2],
+        [  2,   0,   9],
+        [  0,   0,   3],
+        [  1,   0,   2],
+        [  0,   0,   0],
+        [  0,   0,   2],
+        [  0,   0,   0],
+        [  4,   0,   0],
+        [  7,   0,   0],
+        [  6,   0,   0],
+        [  4,   0,   0],
+        [  3,   0,   0],
+        [  6,   2,   0],
+        [  5,   2,   6],
+        [  4,   0,   8],
+        [  6,   1,   2],
+        [  8,   0,   0],
+        [  8,   0,   0],
+        [ 10,   0,   0]]], dtype=np.uint8),
+)
+
+image_decoder_decode_pnm_rgb = ImageData(
+  np.array([ 80,  54,  10,  51,  50,  32,  51,  50,  10,  50,  53,  53,  10,
+       226,  81, 251, 226,  81, 251, 226,  81, 251, 226,  81, 251, 226,
+        81, 251, 237, 229,  45, 237, 229,  45, 237, 229,  45, 237, 229,
+        45, 237, 229,  45, 225, 227,  29, 225, 227,  29, 225, 227,  29,
+       225, 227,  29, 225, 227,  29, 253, 253,  80, 253, 253,  80, 253,
+       253,  80, 253, 253,  80, 253, 253,  80, 129,   8, 118, 129,   8,
+       118, 129,   8, 118, 129,   8, 118, 129,   8, 118,  33, 164,  77,
+        33, 164,  77,  33, 164,  77,  33, 164,  77,  33, 164,  77,   0,
+         0,   0,   0,   0,   0, 226,  81, 251, 226,  81, 251, 226,  81,
+       251, 226,  81, 251, 226,  81, 251, 237, 229,  45, 237, 229,  45,
+       237, 229,  45, 237, 229,  45, 237, 229,  45, 225, 227,  29, 225,
+       227,  29, 225, 227,  29, 225, 227,  29, 225, 227,  29, 253, 253,
+        80, 253, 253,  80, 253, 253,  80, 253, 253,  80, 253, 253,  80,
+       129,   8, 118, 129,   8, 118, 129,   8, 118, 129,   8, 118, 129,
+         8, 118,  33, 164,  77,  33, 164,  77,  33, 164,  77,  33, 164,
+        77,  33, 164,  77,   0,   0,   0,   0,   0,   0, 226,  81, 251,
+       226,  81, 251, 226,  81, 251, 226,  81, 251, 226,  81, 251, 237,
+       229,  45, 237, 229,  45, 237, 229,  45, 237, 229,  45, 237, 229,
+        45, 225, 227,  29, 225, 227,  29, 225, 227,  29, 225, 227,  29,
+       225, 227,  29, 253, 253,  80, 253, 253,  80, 253, 253,  80, 253,
+       253,  80, 253, 253,  80, 129,   8, 118, 129,   8, 118, 129,   8,
+       118, 129,   8, 118, 129,   8, 118,  33, 164,  77,  33, 164,  77,
+        33, 164,  77,  33, 164,  77,  33, 164,  77,   0,   0,   0,   0,
+         0,   0, 226,  81, 251, 226,  81, 251, 226,  81, 251, 226,  81,
+       251, 226,  81, 251, 237, 229,  45, 237, 229,  45, 237, 229,  45,
+       237, 229,  45, 237, 229,  45, 225, 227,  29, 225, 227,  29, 225,
+       227,  29, 225, 227,  29, 225, 227,  29, 253, 253,  80, 253, 253,
+        80, 253, 253,  80, 253, 253,  80, 253, 253,  80, 129,   8, 118,
+       129,   8, 118, 129,   8, 118, 129,   8, 118, 129,   8, 118,  33,
+       164,  77,  33, 164,  77,  33, 164,  77,  33, 164,  77,  33, 164,
+        77,   0,   0,   0,   0,   0,   0, 226,  81, 251, 226,  81, 251,
+       226,  81, 251, 226,  81, 251, 226,  81, 251, 237, 229,  45, 237,
+       229,  45, 237, 229,  45, 237, 229,  45, 237, 229,  45, 225, 227,
+        29, 225, 227,  29, 225, 227,  29, 225, 227,  29, 225, 227,  29,
+       253, 253,  80, 253, 253,  80, 253, 253,  80, 253, 253,  80, 253,
+       253,  80, 129,   8, 118, 129,   8, 118, 129,   8, 118, 129,   8,
+       118, 129,   8, 118,  33, 164,  77,  33, 164,  77,  33, 164,  77,
+        33, 164,  77,  33, 164,  77,   0,   0,   0,   0,   0,   0,  21,
+        47, 169,  21,  47, 169,  21,  47, 169,  21,  47, 169,  21,  47,
+       169, 173,  45,  10, 173,  45,  10, 173,  45,  10, 173,  45,  10,
+       173,  45,  10, 254,  15,  94, 254,  15,  94, 254,  15,  94, 254,
+        15,  94, 254,  15,  94,  52, 126,  81,  52, 126,  81,  52, 126,
+        81,  52, 126,  81,  52, 126,  81, 145, 211, 101, 145, 211, 101,
+       145, 211, 101, 145, 211, 101, 145, 211, 101, 109,  86, 145, 109,
+        86, 145, 109,  86, 145, 109,  86, 145, 109,  86, 145,   0,   0,
+         0,   0,   0,   0,  21,  47, 169,  21,  47, 169,  21,  47, 169,
+        21,  47, 169,  21,  47, 169, 173,  45,  10, 173,  45,  10, 173,
+        45,  10, 173,  45,  10, 173,  45,  10, 254,  15,  94, 254,  15,
+        94, 254,  15,  94, 254,  15,  94, 254,  15,  94,  52, 126,  81,
+        52, 126,  81,  52, 126,  81,  52, 126,  81,  52, 126,  81, 145,
+       211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, 145, 211,
+       101, 109,  86, 145, 109,  86, 145, 109,  86, 145, 109,  86, 145,
+       109,  86, 145,   0,   0,   0,   0,   0,   0,  21,  47, 169,  21,
+        47, 169,  21,  47, 169,  21,  47, 169,  21,  47, 169, 173,  45,
+        10, 173,  45,  10, 173,  45,  10, 173,  45,  10, 173,  45,  10,
+       254,  15,  94, 254,  15,  94, 254,  15,  94, 254,  15,  94, 254,
+        15,  94,  52, 126,  81,  52, 126,  81,  52, 126,  81,  52, 126,
+        81,  52, 126,  81, 145, 211, 101, 145, 211, 101, 145, 211, 101,
+       145, 211, 101, 145, 211, 101, 109,  86, 145, 109,  86, 145, 109,
+        86, 145, 109,  86, 145, 109,  86, 145,   0,   0,   0,   0,   0,
+         0,  21,  47, 169,  21,  47, 169,  21,  47, 169,  21,  47, 169,
+        21,  47, 169, 173,  45,  10, 173,  45,  10, 173,  45,  10, 173,
+        45,  10, 173,  45,  10, 254,  15,  94, 254,  15,  94, 254,  15,
+        94, 254,  15,  94, 254,  15,  94,  52, 126,  81,  52, 126,  81,
+        52, 126,  81,  52, 126,  81,  52, 126,  81, 145, 211, 101, 145,
+       211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101, 109,  86,
+       145, 109,  86, 145, 109,  86, 145, 109,  86, 145, 109,  86, 145,
+         0,   0,   0,   0,   0,   0,  21,  47, 169,  21,  47, 169,  21,
+        47, 169,  21,  47, 169,  21,  47, 169, 173,  45,  10, 173,  45,
+        10, 173,  45,  10, 173,  45,  10, 173,  45,  10, 254,  15,  94,
+       254,  15,  94, 254,  15,  94, 254,  15,  94, 254,  15,  94,  52,
+       126,  81,  52, 126,  81,  52, 126,  81,  52, 126,  81,  52, 126,
+        81, 145, 211, 101, 145, 211, 101, 145, 211, 101, 145, 211, 101,
+       145, 211, 101, 109,  86, 145, 109,  86, 145, 109,  86, 145, 109,
+        86, 145, 109,  86, 145,   0,   0,   0,   0,   0,   0,  34,  66,
+        54,  34,  66,  54,  34,  66,  54,  34,  66,  54,  34,  66,  54,
+       136,  29, 158, 136,  29, 158, 136,  29, 158, 136,  29, 158, 136,
+        29, 158, 117, 152,   1, 117, 152,   1, 117, 152,   1, 117, 152,
+         1, 117, 152,   1, 187, 208, 244, 187, 208, 244, 187, 208, 244,
+       187, 208, 244, 187, 208, 244, 118, 108, 234, 118, 108, 234, 118,
+       108, 234, 118, 108, 234, 118, 108, 234, 246, 113, 205, 246, 113,
+       205, 246, 113, 205, 246, 113, 205, 246, 113, 205,   0,   0,   0,
+         0,   0,   0,  34,  66,  54,  34,  66,  54,  34,  66,  54,  34,
+        66,  54,  34,  66,  54, 136,  29, 158, 136,  29, 158, 136,  29,
+       158, 136,  29, 158, 136,  29, 158, 117, 152,   1, 117, 152,   1,
+       117, 152,   1, 117, 152,   1, 117, 152,   1, 187, 208, 244, 187,
+       208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244, 118, 108,
+       234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118, 108, 234,
+       246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, 205, 246,
+       113, 205,   0,   0,   0,   0,   0,   0,  34,  66,  54,  34,  66,
+        54,  34,  66,  54,  34,  66,  54,  34,  66,  54, 136,  29, 158,
+       136,  29, 158, 136,  29, 158, 136,  29, 158, 136,  29, 158, 117,
+       152,   1, 117, 152,   1, 117, 152,   1, 117, 152,   1, 117, 152,
+         1, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244,
+       187, 208, 244, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118,
+       108, 234, 118, 108, 234, 246, 113, 205, 246, 113, 205, 246, 113,
+       205, 246, 113, 205, 246, 113, 205,   0,   0,   0,   0,   0,   0,
+        34,  66,  54,  34,  66,  54,  34,  66,  54,  34,  66,  54,  34,
+        66,  54, 136,  29, 158, 136,  29, 158, 136,  29, 158, 136,  29,
+       158, 136,  29, 158, 117, 152,   1, 117, 152,   1, 117, 152,   1,
+       117, 152,   1, 117, 152,   1, 187, 208, 244, 187, 208, 244, 187,
+       208, 244, 187, 208, 244, 187, 208, 244, 118, 108, 234, 118, 108,
+       234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 246, 113, 205,
+       246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113, 205,   0,
+         0,   0,   0,   0,   0,  34,  66,  54,  34,  66,  54,  34,  66,
+        54,  34,  66,  54,  34,  66,  54, 136,  29, 158, 136,  29, 158,
+       136,  29, 158, 136,  29, 158, 136,  29, 158, 117, 152,   1, 117,
+       152,   1, 117, 152,   1, 117, 152,   1, 117, 152,   1, 187, 208,
+       244, 187, 208, 244, 187, 208, 244, 187, 208, 244, 187, 208, 244,
+       118, 108, 234, 118, 108, 234, 118, 108, 234, 118, 108, 234, 118,
+       108, 234, 246, 113, 205, 246, 113, 205, 246, 113, 205, 246, 113,
+       205, 246, 113, 205,   0,   0,   0,   0,   0,   0,  64, 118,  59,
+        64, 118,  59,  64, 118,  59,  64, 118,  59,  64, 118,  59, 157,
+        54, 167, 157,  54, 167, 157,  54, 167, 157,  54, 167, 157,  54,
+       167, 142,  26, 122, 142,  26, 122, 142,  26, 122, 142,  26, 122,
+       142,  26, 122, 236, 105,  88, 236, 105,  88, 236, 105,  88, 236,
+       105,  88, 236, 105,  88, 184, 191,  91, 184, 191,  91, 184, 191,
+        91, 184, 191,  91, 184, 191,  91,  76, 185,  95,  76, 185,  95,
+        76, 185,  95,  76, 185,  95,  76, 185,  95,   0,   0,   0,   0,
+         0,   0,  64, 118,  59,  64, 118,  59,  64, 118,  59,  64, 118,
+        59,  64, 118,  59, 157,  54, 167, 157,  54, 167, 157,  54, 167,
+       157,  54, 167, 157,  54, 167, 142,  26, 122, 142,  26, 122, 142,
+        26, 122, 142,  26, 122, 142,  26, 122, 236, 105,  88, 236, 105,
+        88, 236, 105,  88, 236, 105,  88, 236, 105,  88, 184, 191,  91,
+       184, 191,  91, 184, 191,  91, 184, 191,  91, 184, 191,  91,  76,
+       185,  95,  76, 185,  95,  76, 185,  95,  76, 185,  95,  76, 185,
+        95,   0,   0,   0,   0,   0,   0,  64, 118,  59,  64, 118,  59,
+        64, 118,  59,  64, 118,  59,  64, 118,  59, 157,  54, 167, 157,
+        54, 167, 157,  54, 167, 157,  54, 167, 157,  54, 167, 142,  26,
+       122, 142,  26, 122, 142,  26, 122, 142,  26, 122, 142,  26, 122,
+       236, 105,  88, 236, 105,  88, 236, 105,  88, 236, 105,  88, 236,
+       105,  88, 184, 191,  91, 184, 191,  91, 184, 191,  91, 184, 191,
+        91, 184, 191,  91,  76, 185,  95,  76, 185,  95,  76, 185,  95,
+        76, 185,  95,  76, 185,  95,   0,   0,   0,   0,   0,   0,  64,
+       118,  59,  64, 118,  59,  64, 118,  59,  64, 118,  59,  64, 118,
+        59, 157,  54, 167, 157,  54, 167, 157,  54, 167, 157,  54, 167,
+       157,  54, 167, 142,  26, 122, 142,  26, 122, 142,  26, 122, 142,
+        26, 122, 142,  26, 122, 236, 105,  88, 236, 105,  88, 236, 105,
+        88, 236, 105,  88, 236, 105,  88, 184, 191,  91, 184, 191,  91,
+       184, 191,  91, 184, 191,  91, 184, 191,  91,  76, 185,  95,  76,
+       185,  95,  76, 185,  95,  76, 185,  95,  76, 185,  95,   0,   0,
+         0,   0,   0,   0,  64, 118,  59,  64, 118,  59,  64, 118,  59,
+        64, 118,  59,  64, 118,  59, 157,  54, 167, 157,  54, 167, 157,
+        54, 167, 157,  54, 167, 157,  54, 167, 142,  26, 122, 142,  26,
+       122, 142,  26, 122, 142,  26, 122, 142,  26, 122, 236, 105,  88,
+       236, 105,  88, 236, 105,  88, 236, 105,  88, 236, 105,  88, 184,
+       191,  91, 184, 191,  91, 184, 191,  91, 184, 191,  91, 184, 191,
+        91,  76, 185,  95,  76, 185,  95,  76, 185,  95,  76, 185,  95,
+        76, 185,  95,   0,   0,   0,   0,   0,   0, 247,  90,  80, 247,
+        90,  80, 247,  90,  80, 247,  90,  80, 247,  90,  80, 167, 118,
+        85, 167, 118,  85, 167, 118,  85, 167, 118,  85, 167, 118,  85,
+       172,  39, 208, 172,  39, 208, 172,  39, 208, 172,  39, 208, 172,
+        39, 208,  60, 106, 191,  60, 106, 191,  60, 106, 191,  60, 106,
+       191,  60, 106, 191, 114, 163, 112, 114, 163, 112, 114, 163, 112,
+       114, 163, 112, 114, 163, 112, 228, 201,  50, 228, 201,  50, 228,
+       201,  50, 228, 201,  50, 228, 201,  50,   0,   0,   0,   0,   0,
+         0, 247,  90,  80, 247,  90,  80, 247,  90,  80, 247,  90,  80,
+       247,  90,  80, 167, 118,  85, 167, 118,  85, 167, 118,  85, 167,
+       118,  85, 167, 118,  85, 172,  39, 208, 172,  39, 208, 172,  39,
+       208, 172,  39, 208, 172,  39, 208,  60, 106, 191,  60, 106, 191,
+        60, 106, 191,  60, 106, 191,  60, 106, 191, 114, 163, 112, 114,
+       163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112, 228, 201,
+        50, 228, 201,  50, 228, 201,  50, 228, 201,  50, 228, 201,  50,
+         0,   0,   0,   0,   0,   0, 247,  90,  80, 247,  90,  80, 247,
+        90,  80, 247,  90,  80, 247,  90,  80, 167, 118,  85, 167, 118,
+        85, 167, 118,  85, 167, 118,  85, 167, 118,  85, 172,  39, 208,
+       172,  39, 208, 172,  39, 208, 172,  39, 208, 172,  39, 208,  60,
+       106, 191,  60, 106, 191,  60, 106, 191,  60, 106, 191,  60, 106,
+       191, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112,
+       114, 163, 112, 228, 201,  50, 228, 201,  50, 228, 201,  50, 228,
+       201,  50, 228, 201,  50,   0,   0,   0,   0,   0,   0, 247,  90,
+        80, 247,  90,  80, 247,  90,  80, 247,  90,  80, 247,  90,  80,
+       167, 118,  85, 167, 118,  85, 167, 118,  85, 167, 118,  85, 167,
+       118,  85, 172,  39, 208, 172,  39, 208, 172,  39, 208, 172,  39,
+       208, 172,  39, 208,  60, 106, 191,  60, 106, 191,  60, 106, 191,
+        60, 106, 191,  60, 106, 191, 114, 163, 112, 114, 163, 112, 114,
+       163, 112, 114, 163, 112, 114, 163, 112, 228, 201,  50, 228, 201,
+        50, 228, 201,  50, 228, 201,  50, 228, 201,  50,   0,   0,   0,
+         0,   0,   0, 247,  90,  80, 247,  90,  80, 247,  90,  80, 247,
+        90,  80, 247,  90,  80, 167, 118,  85, 167, 118,  85, 167, 118,
+        85, 167, 118,  85, 167, 118,  85, 172,  39, 208, 172,  39, 208,
+       172,  39, 208, 172,  39, 208, 172,  39, 208,  60, 106, 191,  60,
+       106, 191,  60, 106, 191,  60, 106, 191,  60, 106, 191, 114, 163,
+       112, 114, 163, 112, 114, 163, 112, 114, 163, 112, 114, 163, 112,
+       228, 201,  50, 228, 201,  50, 228, 201,  50, 228, 201,  50, 228,
+       201,  50,   0,   0,   0,   0,   0,   0,  24, 246,  11,  24, 246,
+        11,  24, 246,  11,  24, 246,  11,  24, 246,  11, 177, 219,   6,
+       177, 219,   6, 177, 219,   6, 177, 219,   6, 177, 219,   6,  77,
+       188,  37,  77, 188,  37,  77, 188,  37,  77, 188,  37,  77, 188,
+        37,   2, 138, 230,   2, 138, 230,   2, 138, 230,   2, 138, 230,
+         2, 138, 230, 159,  74,  81, 159,  74,  81, 159,  74,  81, 159,
+        74,  81, 159,  74,  81, 240,  63,  27, 240,  63,  27, 240,  63,
+        27, 240,  63,  27, 240,  63,  27,   0,   0,   0,   0,   0,   0,
+        24, 246,  11,  24, 246,  11,  24, 246,  11,  24, 246,  11,  24,
+       246,  11, 177, 219,   6, 177, 219,   6, 177, 219,   6, 177, 219,
+         6, 177, 219,   6,  77, 188,  37,  77, 188,  37,  77, 188,  37,
+        77, 188,  37,  77, 188,  37,   2, 138, 230,   2, 138, 230,   2,
+       138, 230,   2, 138, 230,   2, 138, 230, 159,  74,  81, 159,  74,
+        81, 159,  74,  81, 159,  74,  81, 159,  74,  81, 240,  63,  27,
+       240,  63,  27, 240,  63,  27, 240,  63,  27, 240,  63,  27,   0,
+         0,   0,   0,   0,   0,  24, 246,  11,  24, 246,  11,  24, 246,
+        11,  24, 246,  11,  24, 246,  11, 177, 219,   6, 177, 219,   6,
+       177, 219,   6, 177, 219,   6, 177, 219,   6,  77, 188,  37,  77,
+       188,  37,  77, 188,  37,  77, 188,  37,  77, 188,  37,   2, 138,
+       230,   2, 138, 230,   2, 138, 230,   2, 138, 230,   2, 138, 230,
+       159,  74,  81, 159,  74,  81, 159,  74,  81, 159,  74,  81, 159,
+        74,  81, 240,  63,  27, 240,  63,  27, 240,  63,  27, 240,  63,
+        27, 240,  63,  27,   0,   0,   0,   0,   0,   0,  24, 246,  11,
+        24, 246,  11,  24, 246,  11,  24, 246,  11,  24, 246,  11, 177,
+       219,   6, 177, 219,   6, 177, 219,   6, 177, 219,   6, 177, 219,
+         6,  77, 188,  37,  77, 188,  37,  77, 188,  37,  77, 188,  37,
+        77, 188,  37,   2, 138, 230,   2, 138, 230,   2, 138, 230,   2,
+       138, 230,   2, 138, 230, 159,  74,  81, 159,  74,  81, 159,  74,
+        81, 159,  74,  81, 159,  74,  81, 240,  63,  27, 240,  63,  27,
+       240,  63,  27, 240,  63,  27, 240,  63,  27,   0,   0,   0,   0,
+         0,   0,  24, 246,  11,  24, 246,  11,  24, 246,  11,  24, 246,
+        11,  24, 246,  11, 177, 219,   6, 177, 219,   6, 177, 219,   6,
+       177, 219,   6, 177, 219,   6,  77, 188,  37,  77, 188,  37,  77,
+       188,  37,  77, 188,  37,  77, 188,  37,   2, 138, 230,   2, 138,
+       230,   2, 138, 230,   2, 138, 230,   2, 138, 230, 159,  74,  81,
+       159,  74,  81, 159,  74,  81, 159,  74,  81, 159,  74,  81, 240,
+        63,  27, 240,  63,  27, 240,  63,  27, 240,  63,  27, 240,  63,
+        27,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+         0,   0,   0,   0], dtype=np.uint8),
+    np.array([[[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [226,  81, 251],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [237, 229,  45],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [225, 227,  29],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [253, 253,  80],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [129,   8, 118],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [ 33, 164,  77],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [ 21,  47, 169],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [173,  45,  10],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [254,  15,  94],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [ 52, 126,  81],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [145, 211, 101],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [109,  86, 145],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [ 34,  66,  54],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [136,  29, 158],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [117, 152,   1],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [187, 208, 244],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [118, 108, 234],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [246, 113, 205],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [ 64, 118,  59],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [157,  54, 167],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [142,  26, 122],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [236, 105,  88],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [184, 191,  91],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [ 76, 185,  95],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [247,  90,  80],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [167, 118,  85],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [172,  39, 208],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [ 60, 106, 191],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [114, 163, 112],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [228, 201,  50],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [ 24, 246,  11],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [177, 219,   6],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [ 77, 188,  37],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [  2, 138, 230],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [159,  74,  81],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [240,  63,  27],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0]],
+
+       [[  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0],
+        [  0,   0,   0]]], dtype=np.uint8),
+)
+# fmt: on
diff --git a/onnx/backend/test/case/node/abs.py b/onnx/backend/test/case/node/abs.py
new file mode 100644
index 0000000..5054fdd
--- /dev/null
+++ b/onnx/backend/test/case/node/abs.py
@@ -0,0 +1,24 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Abs(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Abs",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.abs(x)
+
+        expect(node, inputs=[x], outputs=[y], name="test_abs")
diff --git a/onnx/backend/test/case/node/acos.py b/onnx/backend/test/case/node/acos.py
new file mode 100644
index 0000000..4083407
--- /dev/null
+++ b/onnx/backend/test/case/node/acos.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Acos(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Acos",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-0.5, 0, 0.5]).astype(np.float32)
+        y = np.arccos(x)
+        expect(node, inputs=[x], outputs=[y], name="test_acos_example")
+
+        x = np.random.rand(3, 4, 5).astype(np.float32)
+        y = np.arccos(x)
+        expect(node, inputs=[x], outputs=[y], name="test_acos")
diff --git a/onnx/backend/test/case/node/acosh.py b/onnx/backend/test/case/node/acosh.py
new file mode 100644
index 0000000..665c441
--- /dev/null
+++ b/onnx/backend/test/case/node/acosh.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Acosh(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Acosh",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([10, np.e, 1]).astype(np.float32)
+        y = np.arccosh(x)  # expected output [2.99322295,  1.65745449,  0.]
+        expect(node, inputs=[x], outputs=[y], name="test_acosh_example")
+
+        x = np.random.uniform(1.0, 10.0, (3, 4, 5)).astype(np.float32)
+        y = np.arccosh(x)
+        expect(node, inputs=[x], outputs=[y], name="test_acosh")
diff --git a/onnx/backend/test/case/node/adagrad.py b/onnx/backend/test/case/node/adagrad.py
new file mode 100644
index 0000000..1a3d4a0
--- /dev/null
+++ b/onnx/backend/test/case/node/adagrad.py
@@ -0,0 +1,116 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN
+
+
+def apply_adagrad(r, t, x, g, h, norm_coefficient, epsilon, decay_factor):
+    # Compute adjusted learning-rate.
+    r_ = r / (1 + t * decay_factor)
+    # Add gradient of regularization term.
+    g_regularized = norm_coefficient * x + g
+    # Update squared accumulated gradient.
+    h_new = h + g_regularized * g_regularized
+    # Compute ADAGRAD's gradient scaling factors
+    h_sqrt = np.sqrt(h_new) + epsilon
+    # Apply ADAGRAD update rule.
+    x_new = x - r_ * g_regularized / h_sqrt
+    return (x_new.astype(x.dtype), h_new.astype(h.dtype))
+
+
+class Adagrad(Base):
+    @staticmethod
+    def export_adagrad() -> None:
+        # Define operator attributes.
+        norm_coefficient = 0.001
+        epsilon = 1e-5
+        decay_factor = 0.1
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "Adagrad",
+            inputs=["R", "T", "X", "G", "H"],
+            outputs=["X_new", "H_new"],
+            norm_coefficient=norm_coefficient,
+            epsilon=epsilon,
+            decay_factor=decay_factor,
+            domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+        )
+
+        # Define operator inputs.
+        r = np.array(0.1, dtype=np.float32)  # scalar
+        t = np.array(0, dtype=np.int64)  # scalar
+        x = np.array([1.0], dtype=np.float32)
+        g = np.array([-1.0], dtype=np.float32)
+        h = np.array([2.0], dtype=np.float32)
+
+        # Compute expected outputs of Adagrad.
+        x_new, h_new = apply_adagrad(
+            r, t, x, g, h, norm_coefficient, epsilon, decay_factor
+        )
+
+        # Check results.
+        expect(
+            node,
+            inputs=[r, t, x, g, h],
+            outputs=[x_new, h_new],
+            name="test_adagrad",
+            opset_imports=[
+                onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+            ],
+        )
+
+    @staticmethod
+    def export_adagrad_multiple() -> None:
+        # Define operator attributes.
+        norm_coefficient = 0.001
+        epsilon = 1e-5
+        decay_factor = 0.1
+
+        node = onnx.helper.make_node(
+            "Adagrad",
+            inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"],
+            outputs=["X1_new", "X2_new", "H1_new", "H2_new"],
+            norm_coefficient=norm_coefficient,
+            epsilon=epsilon,
+            decay_factor=decay_factor,
+            domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+        )
+
+        # Define operator inputs.
+        r = np.array(0.1, dtype=np.float32)  # scalar
+        t = np.array(0, dtype=np.int64)  # scalar
+
+        x1 = np.array([1.0], dtype=np.float32)
+        g1 = np.array([-1.0], dtype=np.float32)
+        h1 = np.array([2.0], dtype=np.float32)
+
+        x2 = np.array([1.0, 2.0], dtype=np.float32)
+        g2 = np.array([-1.0, -3.0], dtype=np.float32)
+        h2 = np.array([4.0, 1.0], dtype=np.float32)
+
+        # Compute expected outputs of Adagrad.
+        x1_new, h1_new = apply_adagrad(
+            r, t, x1, g1, h1, norm_coefficient, epsilon, decay_factor
+        )
+        x2_new, h2_new = apply_adagrad(
+            r, t, x2, g2, h2, norm_coefficient, epsilon, decay_factor
+        )
+
+        # Check results.
+        expect(
+            node,
+            inputs=[r, t, x1, x2, g1, g2, h1, h2],
+            outputs=[x1_new, x2_new, h1_new, h2_new],
+            name="test_adagrad_multiple",
+            opset_imports=[
+                onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+            ],
+        )
diff --git a/onnx/backend/test/case/node/adam.py b/onnx/backend/test/case/node/adam.py
new file mode 100644
index 0000000..108b84d
--- /dev/null
+++ b/onnx/backend/test/case/node/adam.py
@@ -0,0 +1,135 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN
+
+
+def apply_adam(
+    r, t, x, g, v, h, norm_coefficient, norm_coefficient_post, alpha, beta, epsilon
+):
+    # Add gradient of regularization term.
+    g_regularized = norm_coefficient * x + g
+    # Update momentum.
+    v_new = alpha * v + (1 - alpha) * g_regularized
+    # Update second-order momentum.
+    h_new = beta * h + (1 - beta) * (g_regularized * g_regularized)
+    # Compute element-wise square root.
+    h_sqrt = np.sqrt(h_new) + epsilon
+    # Adjust learning rate.
+    r_adjusted = None
+    if t > 0:
+        # Consider bias correction on momentums.
+        r_adjusted = r * np.sqrt(1 - beta**t) / (1 - alpha**t)
+    else:
+        # No bias correction on momentums.
+        r_adjusted = r
+    # Apply Adam update rule.
+    x_new = x - r_adjusted * (v_new / h_sqrt)
+    # It's possible to apply regularization in the end.
+    x_final = (1 - norm_coefficient_post) * x_new
+    return x_final, v_new, h_new
+
+
+class Adam(Base):
+    @staticmethod
+    def export_adam() -> None:
+        # Define operator attributes.
+        norm_coefficient = 0.001
+        alpha = 0.95
+        beta = 0.1
+        epsilon = 1e-7
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "Adam",
+            inputs=["R", "T", "X", "G", "V", "H"],
+            outputs=["X_new", "V_new", "H_new"],
+            norm_coefficient=norm_coefficient,
+            alpha=alpha,
+            beta=beta,
+            epsilon=epsilon,
+            domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+        )
+
+        # Define operator inputs.
+        r = np.array(0.1, dtype=np.float32)  # scalar
+        t = np.array(0, dtype=np.int64)  # scalar
+        x = np.array([1.2, 2.8], dtype=np.float32)
+        g = np.array([-0.94, -2.5], dtype=np.float32)
+        v = np.array([1.7, 3.6], dtype=np.float32)
+        h = np.array([0.1, 0.1], dtype=np.float32)
+
+        # Compute expected outputs of Adam.
+        x_new, v_new, h_new = apply_adam(
+            r, t, x, g, v, h, norm_coefficient, 0.0, alpha, beta, epsilon
+        )
+
+        # Check results.
+        expect(
+            node,
+            inputs=[r, t, x, g, v, h],
+            outputs=[x_new, v_new, h_new],
+            name="test_adam",
+            opset_imports=[
+                onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+            ],
+        )
+
+    @staticmethod
+    def export_adam_multiple() -> None:
+        # Define operator attributes.
+        norm_coefficient = 0.001
+        alpha = 0.95
+        beta = 0.85
+        epsilon = 1e-2
+
+        node = onnx.helper.make_node(
+            "Adam",
+            inputs=["R", "T", "X1", "X2", "G1", "G2", "V1", "V2", "H1", "H2"],
+            outputs=["X1_new", "X2_new", "V1_new", "V2_new", "H1_new", "H2_new"],
+            norm_coefficient=norm_coefficient,
+            alpha=alpha,
+            beta=beta,
+            epsilon=epsilon,
+            domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+        )
+
+        # Define operator inputs.
+        r = np.array(0.1, dtype=np.float32)  # scalar
+        t = np.array(0, dtype=np.int64)  # scalar
+
+        x1 = np.array([1.0], dtype=np.float32)
+        g1 = np.array([-1.0], dtype=np.float32)
+        v1 = np.array([2.0], dtype=np.float32)
+        h1 = np.array([0.5], dtype=np.float32)
+
+        x2 = np.array([1.0, 2.0], dtype=np.float32)
+        g2 = np.array([-1.0, -3.0], dtype=np.float32)
+        v2 = np.array([4.0, 1.0], dtype=np.float32)
+        h2 = np.array([1.0, 10.0], dtype=np.float32)
+
+        # Compute expected outputs of Adam.
+        x1_new, v1_new, h1_new = apply_adam(
+            r, t, x1, g1, v1, h1, norm_coefficient, 0.0, alpha, beta, epsilon
+        )
+        x2_new, v2_new, h2_new = apply_adam(
+            r, t, x2, g2, v2, h2, norm_coefficient, 0.0, alpha, beta, epsilon
+        )
+
+        # Check results.
+        expect(
+            node,
+            inputs=[r, t, x1, x2, g1, g2, v1, v2, h1, h2],
+            outputs=[x1_new, x2_new, v1_new, v2_new, h1_new, h2_new],
+            name="test_adam_multiple",
+            opset_imports=[
+                onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+            ],
+        )
diff --git a/onnx/backend/test/case/node/add.py b/onnx/backend/test/case/node/add.py
new file mode 100644
index 0000000..0a3d9ac
--- /dev/null
+++ b/onnx/backend/test/case/node/add.py
@@ -0,0 +1,60 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Add(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Add",
+            inputs=["x", "y"],
+            outputs=["sum"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(3, 4, 5).astype(np.float32)
+        expect(node, inputs=[x, y], outputs=[x + y], name="test_add")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+        expect(node, inputs=[x, y], outputs=[x + y], name="test_add_int8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+        expect(node, inputs=[x, y], outputs=[x + y], name="test_add_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        expect(node, inputs=[x, y], outputs=[x + y], name="test_add_uint64")
+
+    @staticmethod
+    def export_add_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Add",
+            inputs=["x", "y"],
+            outputs=["sum"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(5).astype(np.float32)
+        expect(node, inputs=[x, y], outputs=[x + y], name="test_add_bcast")
diff --git a/onnx/backend/test/case/node/affinegrid.py b/onnx/backend/test/case/node/affinegrid.py
new file mode 100644
index 0000000..5eb281f
--- /dev/null
+++ b/onnx/backend/test/case/node/affinegrid.py
@@ -0,0 +1,208 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_affine_grid import (
+    apply_affine_transform,
+    construct_original_grid,
+)
+
+
+def create_affine_matrix_3d(
+    angle1,
+    angle2,
+    offset_x,
+    offset_y,
+    offset_z,
+    shear_x,
+    shear_y,
+    shear_z,
+    scale_x,
+    scale_y,
+    scale_z,
+):
+    rot_x = np.stack(
+        [
+            np.ones_like(angle1),
+            np.zeros_like(angle1),
+            np.zeros_like(angle1),
+            np.zeros_like(angle1),
+            np.cos(angle1),
+            -np.sin(angle1),
+            np.zeros_like(angle1),
+            np.sin(angle1),
+            np.cos(angle1),
+        ],
+        axis=-1,
+    ).reshape(-1, 3, 3)
+    rot_y = np.stack(
+        [
+            np.cos(angle2),
+            np.zeros_like(angle2),
+            np.sin(angle2),
+            np.zeros_like(angle2),
+            np.ones_like(angle2),
+            np.zeros_like(angle2),
+            -np.sin(angle2),
+            np.zeros_like(angle2),
+            np.cos(angle2),
+        ],
+        axis=-1,
+    ).reshape(-1, 3, 3)
+    shear = np.stack(
+        [
+            np.ones_like(shear_x),
+            shear_x,
+            shear_y,
+            shear_z,
+            np.ones_like(shear_x),
+            shear_x,
+            shear_y,
+            shear_x,
+            np.ones_like(shear_x),
+        ],
+        axis=-1,
+    ).reshape(-1, 3, 3)
+    scale = np.stack(
+        [
+            scale_x,
+            np.zeros_like(scale_x),
+            np.zeros_like(scale_x),
+            np.zeros_like(scale_x),
+            scale_y,
+            np.zeros_like(scale_x),
+            np.zeros_like(scale_x),
+            np.zeros_like(scale_x),
+            scale_z,
+        ],
+        axis=-1,
+    ).reshape(-1, 3, 3)
+    translation = np.transpose(np.array([offset_x, offset_y, offset_z])).reshape(
+        -1, 1, 3
+    )
+    rotation_matrix = rot_y @ rot_x @ shear @ scale  # (N, 3, 3)
+    rotation_matrix = np.transpose(rotation_matrix, (0, 2, 1))
+    affine_matrix = np.hstack((rotation_matrix, translation))
+    affine_matrix = np.transpose(affine_matrix, (0, 2, 1))
+    return affine_matrix.astype(np.float32)
+
+
+def create_affine_matrix_2d(
+    angle1, offset_x, offset_y, shear_x, shear_y, scale_x, scale_y
+):
+    rot = np.stack(
+        [np.cos(angle1), -np.sin(angle1), np.sin(angle1), np.cos(angle1)], axis=-1
+    ).reshape(-1, 2, 2)
+    shear = np.stack(
+        [np.ones_like(shear_x), shear_x, shear_y, np.ones_like(shear_x)], axis=-1
+    ).reshape(-1, 2, 2)
+    scale = np.stack(
+        [scale_x, np.zeros_like(scale_x), np.zeros_like(scale_x), scale_y], axis=-1
+    ).reshape(-1, 2, 2)
+    translation = np.transpose(np.array([offset_x, offset_y])).reshape(-1, 1, 2)
+    rotation_matrix = rot @ shear @ scale  # (N, 3, 3)
+    rotation_matrix = np.transpose(rotation_matrix, (0, 2, 1))
+    affine_matrix = np.hstack((rotation_matrix, translation))
+    affine_matrix = np.transpose(affine_matrix, (0, 2, 1))
+    return affine_matrix.astype(np.float32)
+
+
+def create_theta_2d():
+    angle = np.array([np.pi / 4, np.pi / 3])
+    offset_x = np.array([5.0, 2.5])
+    offset_y = np.array([-3.3, 1.1])
+    shear_x = np.array([-0.5, 0.5])
+    shear_y = np.array([0.3, -0.3])
+    scale_x = np.array([2.2, 1.1])
+    scale_y = np.array([3.1, 0.9])
+    return create_affine_matrix_2d(
+        angle, offset_x, offset_y, shear_x, shear_y, scale_x, scale_y
+    )
+
+
+def create_theta_3d():
+    angle1 = np.array([np.pi / 4, np.pi / 3])
+    angle2 = np.array([np.pi / 6, np.pi / 2])
+    offset_x = np.array([5.0, 2.5])
+    offset_y = np.array([-3.3, 1.1])
+    offset_z = np.array([-1.1, 2.2])
+    shear_x = np.array([-0.5, 0.5])
+    shear_y = np.array([0.3, -0.3])
+    shear_z = np.array([0.7, -0.2])
+    scale_x = np.array([2.2, 1.1])
+    scale_y = np.array([3.1, 0.9])
+    scale_z = np.array([0.5, 1.5])
+
+    return create_affine_matrix_3d(
+        angle1,
+        angle2,
+        offset_x,
+        offset_y,
+        offset_z,
+        shear_x,
+        shear_y,
+        shear_z,
+        scale_x,
+        scale_y,
+        scale_z,
+    )
+
+
+class AffineGrid(Base):
+    @staticmethod
+    def export_2d_no_reference_evaluator() -> None:
+        theta_2d = create_theta_2d()
+        N, C, H, W = len(theta_2d), 3, 5, 6
+        data_size = (H, W)
+        for align_corners in (0, 1):
+            node = onnx.helper.make_node(
+                "AffineGrid",
+                inputs=["theta", "size"],
+                outputs=["grid"],
+                align_corners=align_corners,
+            )
+
+            original_grid = construct_original_grid(data_size, align_corners)
+            grid = apply_affine_transform(theta_2d, original_grid)
+
+            test_name = "test_affine_grid_2d"
+            if align_corners == 1:
+                test_name += "_align_corners"
+            expect(
+                node,
+                inputs=[theta_2d, np.array([N, C, H, W], dtype=np.int64)],
+                outputs=[grid],
+                name=test_name,
+            )
+
+    @staticmethod
+    def export_3d_no_reference_evaluator() -> None:
+        theta_3d = create_theta_3d()
+        N, C, D, H, W = len(theta_3d), 3, 4, 5, 6
+        data_size = (D, H, W)
+        for align_corners in (0, 1):
+            node = onnx.helper.make_node(
+                "AffineGrid",
+                inputs=["theta", "size"],
+                outputs=["grid"],
+                align_corners=align_corners,
+            )
+
+            original_grid = construct_original_grid(data_size, align_corners)
+            grid = apply_affine_transform(theta_3d, original_grid)
+
+            test_name = "test_affine_grid_3d"
+            if align_corners == 1:
+                test_name += "_align_corners"
+            expect(
+                node,
+                inputs=[theta_3d, np.array([N, C, D, H, W], dtype=np.int64)],
+                outputs=[grid],
+                name=test_name,
+            )
diff --git a/onnx/backend/test/case/node/ai_onnx_ml/__init__.py b/onnx/backend/test/case/node/ai_onnx_ml/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py b/onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py
new file mode 100644
index 0000000..2292dd6
--- /dev/null
+++ b/onnx/backend/test/case/node/ai_onnx_ml/array_feature_extractor.py
@@ -0,0 +1,31 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ArrayFeatureExtractor(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "ArrayFeatureExtractor",
+            inputs=["x", "y"],
+            outputs=["z"],
+            domain="ai.onnx.ml",
+        )
+
+        x = np.arange(12).reshape((3, 4)).astype(np.float32)
+        y = np.array([0, 1], dtype=np.int64)
+        z = np.array([[0, 4, 8], [1, 5, 9]], dtype=np.float32).T
+        expect(
+            node,
+            inputs=[x, y],
+            outputs=[z],
+            name="test_ai_onnx_ml_array_feature_extractor",
+        )
diff --git a/onnx/backend/test/case/node/ai_onnx_ml/binarizer.py b/onnx/backend/test/case/node/ai_onnx_ml/binarizer.py
new file mode 100644
index 0000000..fc4c636
--- /dev/null
+++ b/onnx/backend/test/case/node/ai_onnx_ml/binarizer.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.aionnxml.op_binarizer import compute_binarizer
+
+
+class Binarizer(Base):
+    @staticmethod
+    def export() -> None:
+        threshold = 1.0
+        node = onnx.helper.make_node(
+            "Binarizer",
+            inputs=["X"],
+            outputs=["Y"],
+            threshold=threshold,
+            domain="ai.onnx.ml",
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = compute_binarizer(x, threshold)[0]
+
+        expect(node, inputs=[x], outputs=[y], name="test_ai_onnx_ml_binarizer")
diff --git a/onnx/backend/test/case/node/ai_onnx_ml/label_encoder.py b/onnx/backend/test/case/node/ai_onnx_ml/label_encoder.py
new file mode 100644
index 0000000..c8f5177
--- /dev/null
+++ b/onnx/backend/test/case/node/ai_onnx_ml/label_encoder.py
@@ -0,0 +1,101 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.helper import make_tensor
+
+
+class LabelEncoder(Base):
+    @staticmethod
+    def export_string_int_label_encoder() -> None:
+        node = onnx.helper.make_node(
+            "LabelEncoder",
+            inputs=["X"],
+            outputs=["Y"],
+            domain="ai.onnx.ml",
+            keys_strings=["a", "b", "c"],
+            values_int64s=[0, 1, 2],
+            default_int64=42,
+        )
+        x = np.array(["a", "b", "d", "c", "g"]).astype(object)
+        y = np.array([0, 1, 42, 2, 42]).astype(np.int64)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_ai_onnx_ml_label_encoder_string_int",
+        )
+
+        node = onnx.helper.make_node(
+            "LabelEncoder",
+            inputs=["X"],
+            outputs=["Y"],
+            domain="ai.onnx.ml",
+            keys_strings=["a", "b", "c"],
+            values_int64s=[0, 1, 2],
+        )
+        x = np.array(["a", "b", "d", "c", "g"]).astype(object)
+        y = np.array([0, 1, -1, 2, -1]).astype(np.int64)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_ai_onnx_ml_label_encoder_string_int_no_default",
+        )
+
+    @staticmethod
+    def export_tensor_based_label_encoder() -> None:
+        tensor_keys = make_tensor(
+            "keys_tensor", onnx.TensorProto.STRING, (3,), ["a", "b", "c"]
+        )
+        repeated_string_keys = ["a", "b", "c"]
+        x = np.array(["a", "b", "d", "c", "g"]).astype(object)
+        y = np.array([0, 1, 42, 2, 42]).astype(np.int16)
+
+        node = onnx.helper.make_node(
+            "LabelEncoder",
+            inputs=["X"],
+            outputs=["Y"],
+            domain="ai.onnx.ml",
+            keys_tensor=tensor_keys,
+            values_tensor=make_tensor(
+                "values_tensor", onnx.TensorProto.INT16, (3,), [0, 1, 2]
+            ),
+            default_tensor=make_tensor(
+                "default_tensor", onnx.TensorProto.INT16, (1,), [42]
+            ),
+        )
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_ai_onnx_ml_label_encoder_tensor_mapping",
+        )
+
+        node = onnx.helper.make_node(
+            "LabelEncoder",
+            inputs=["X"],
+            outputs=["Y"],
+            domain="ai.onnx.ml",
+            keys_strings=repeated_string_keys,
+            values_tensor=make_tensor(
+                "values_tensor", onnx.TensorProto.INT16, (3,), [0, 1, 2]
+            ),
+            default_tensor=make_tensor(
+                "default_tensor", onnx.TensorProto.INT16, (1,), [42]
+            ),
+        )
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_ai_onnx_ml_label_encoder_tensor_value_only_mapping",
+        )
diff --git a/onnx/backend/test/case/node/ai_onnx_ml/tree_ensemble.py b/onnx/backend/test/case/node/ai_onnx_ml/tree_ensemble.py
new file mode 100644
index 0000000..72d3edf
--- /dev/null
+++ b/onnx/backend/test/case/node/ai_onnx_ml/tree_ensemble.py
@@ -0,0 +1,123 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.helper import make_tensor
+
+
+class TreeEnsemble(Base):
+    @staticmethod
+    def export_tree_ensemble_single_tree() -> None:
+        node = onnx.helper.make_node(
+            "TreeEnsemble",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            n_targets=2,
+            membership_values=None,
+            nodes_missing_value_tracks_true=None,
+            nodes_hitrates=None,
+            aggregate_function=1,
+            post_transform=0,
+            tree_roots=[0],
+            nodes_modes=make_tensor(
+                "nodes_modes",
+                onnx.TensorProto.UINT8,
+                (3,),
+                np.array([0, 0, 0], dtype=np.uint8),
+            ),
+            nodes_featureids=[0, 0, 0],
+            nodes_splits=make_tensor(
+                "nodes_splits",
+                onnx.TensorProto.DOUBLE,
+                (3,),
+                np.array([3.14, 1.2, 4.2], dtype=np.float64),
+            ),
+            nodes_truenodeids=[1, 0, 1],
+            nodes_trueleafs=[0, 1, 1],
+            nodes_falsenodeids=[2, 2, 3],
+            nodes_falseleafs=[0, 1, 1],
+            leaf_targetids=[0, 1, 0, 1],
+            leaf_weights=make_tensor(
+                "leaf_weights",
+                onnx.TensorProto.DOUBLE,
+                (4,),
+                np.array([5.23, 12.12, -12.23, 7.21], dtype=np.float64),
+            ),
+        )
+
+        x = np.array([1.2, 3.4, -0.12, 1.66, 4.14, 1.77], np.float64).reshape(3, 2)
+        y = np.array([[5.23, 0], [5.23, 0], [0, 12.12]], dtype=np.float64)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_ai_onnx_ml_tree_ensemble_single_tree",
+        )
+
+    @staticmethod
+    def export_tree_ensemble_set_membership() -> None:
+        node = onnx.helper.make_node(
+            "TreeEnsemble",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            n_targets=4,
+            aggregate_function=1,
+            membership_values=make_tensor(
+                "membership_values",
+                onnx.TensorProto.FLOAT,
+                (8,),
+                [1.2, 3.7, 8, 9, np.nan, 12, 7, np.nan],
+            ),
+            nodes_missing_value_tracks_true=None,
+            nodes_hitrates=None,
+            post_transform=0,
+            tree_roots=[0],
+            nodes_modes=make_tensor(
+                "nodes_modes",
+                onnx.TensorProto.UINT8,
+                (3,),
+                np.array([0, 6, 6], dtype=np.uint8),
+            ),
+            nodes_featureids=[0, 0, 0],
+            nodes_splits=make_tensor(
+                "nodes_splits",
+                onnx.TensorProto.FLOAT,
+                (3,),
+                np.array([11, 232344.0, np.nan], dtype=np.float32),
+            ),
+            nodes_trueleafs=[0, 1, 1],
+            nodes_truenodeids=[1, 0, 1],
+            nodes_falseleafs=[1, 0, 1],
+            nodes_falsenodeids=[2, 2, 3],
+            leaf_targetids=[0, 1, 2, 3],
+            leaf_weights=make_tensor(
+                "leaf_weights", onnx.TensorProto.FLOAT, (4,), [1, 10, 1000, 100]
+            ),
+        )
+
+        x = np.array([1.2, 3.4, -0.12, np.nan, 12, 7], np.float32).reshape(-1, 1)
+        expected = np.array(
+            [
+                [1, 0, 0, 0],
+                [0, 0, 0, 100],
+                [0, 0, 0, 100],
+                [0, 0, 1000, 0],
+                [0, 0, 1000, 0],
+                [0, 10, 0, 0],
+            ],
+            dtype=np.float32,
+        )
+        expect(
+            node,
+            inputs=[x],
+            outputs=[expected],
+            name="test_ai_onnx_ml_tree_ensemble_set_membership",
+        )
diff --git a/onnx/backend/test/case/node/and_.py b/onnx/backend/test/case/node/and_.py
new file mode 100644
index 0000000..025ce6a
--- /dev/null
+++ b/onnx/backend/test/case/node/and_.py
@@ -0,0 +1,76 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class And(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "And",
+            inputs=["x", "y"],
+            outputs=["and"],
+        )
+
+        # 2d
+        x = (np.random.randn(3, 4) > 0).astype(bool)
+        y = (np.random.randn(3, 4) > 0).astype(bool)
+        z = np.logical_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_and2d")
+
+        # 3d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        y = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        z = np.logical_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_and3d")
+
+        # 4d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        z = np.logical_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_and4d")
+
+    @staticmethod
+    def export_and_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "And",
+            inputs=["x", "y"],
+            outputs=["and"],
+        )
+
+        # 3d vs 1d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        y = (np.random.randn(5) > 0).astype(bool)
+        z = np.logical_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v1d")
+
+        # 3d vs 2d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        y = (np.random.randn(4, 5) > 0).astype(bool)
+        z = np.logical_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast3v2d")
+
+        # 4d vs 2d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        y = (np.random.randn(5, 6) > 0).astype(bool)
+        z = np.logical_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v2d")
+
+        # 4d vs 3d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        y = (np.random.randn(4, 5, 6) > 0).astype(bool)
+        z = np.logical_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v3d")
+
+        # 4d vs 4d
+        x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool)
+        y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool)
+        z = np.logical_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_and_bcast4v4d")
diff --git a/onnx/backend/test/case/node/argmax.py b/onnx/backend/test/case/node/argmax.py
new file mode 100644
index 0000000..ca3e153
--- /dev/null
+++ b/onnx/backend/test/case/node/argmax.py
@@ -0,0 +1,256 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def argmax_use_numpy(data: np.ndarray, axis: int = 0, keepdims: int = 1) -> np.ndarray:
+    result = np.argmax(data, axis=axis)
+    if keepdims == 1:
+        result = np.expand_dims(result, axis)
+    return result.astype(np.int64)
+
+
+def argmax_use_numpy_select_last_index(
+    data: np.ndarray, axis: int = 0, keepdims: int = True
+) -> np.ndarray:
+    data = np.flip(data, axis)
+    result = np.argmax(data, axis=axis)
+    result = data.shape[axis] - result - 1
+    if keepdims:
+        result = np.expand_dims(result, axis)
+    return result.astype(np.int64)
+
+
+class ArgMax(Base):
+    @staticmethod
+    def export_no_keepdims() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        axis = 1
+        keepdims = 0
+        node = onnx.helper.make_node(
+            "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+        )
+        # result: [0, 1]
+        result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_no_keepdims_example",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 4]
+        result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node, inputs=[data], outputs=[result], name="test_argmax_no_keepdims_random"
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        axis = 1
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+        )
+        # result: [[0], [1]]
+        result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node, inputs=[data], outputs=[result], name="test_argmax_keepdims_example"
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 1, 4]
+        result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node, inputs=[data], outputs=[result], name="test_argmax_keepdims_random"
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMax", inputs=["data"], outputs=["result"], keepdims=keepdims
+        )
+
+        # result: [[1, 1]]
+        result = argmax_use_numpy(data, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_default_axis_example",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [1, 3, 4]
+        result = argmax_use_numpy(data, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_default_axis_random",
+        )
+
+    @staticmethod
+    def export_negative_axis_keepdims() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        axis = -1
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMax", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+        )
+        # result: [[0], [1]]
+        result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_negative_axis_keepdims_example",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 3, 1]
+        result = argmax_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_negative_axis_keepdims_random",
+        )
+
+    @staticmethod
+    def export_no_keepdims_select_last_index() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        axis = 1
+        keepdims = 0
+        node = onnx.helper.make_node(
+            "ArgMax",
+            inputs=["data"],
+            outputs=["result"],
+            axis=axis,
+            keepdims=keepdims,
+            select_last_index=True,
+        )
+        # result: [1, 1]
+        result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_no_keepdims_example_select_last_index",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 4]
+        result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_no_keepdims_random_select_last_index",
+        )
+
+    @staticmethod
+    def export_keepdims_select_last_index() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        axis = 1
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMax",
+            inputs=["data"],
+            outputs=["result"],
+            axis=axis,
+            keepdims=keepdims,
+            select_last_index=True,
+        )
+        # result: [[1], [1]]
+        result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_keepdims_example_select_last_index",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 1, 4]
+        result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_keepdims_random_select_last_index",
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims_select_last_index() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMax",
+            inputs=["data"],
+            outputs=["result"],
+            keepdims=keepdims,
+            select_last_index=True,
+        )
+
+        # result: [[1, 1]]
+        result = argmax_use_numpy_select_last_index(data, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_default_axis_example_select_last_index",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [1, 3, 4]
+        result = argmax_use_numpy_select_last_index(data, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_default_axis_random_select_last_index",
+        )
+
+    @staticmethod
+    def export_negative_axis_keepdims_select_last_index() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        axis = -1
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMax",
+            inputs=["data"],
+            outputs=["result"],
+            axis=axis,
+            keepdims=keepdims,
+            select_last_index=True,
+        )
+        # result: [[1], [1]]
+        result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_negative_axis_keepdims_example_select_last_index",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 3, 1]
+        result = argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmax_negative_axis_keepdims_random_select_last_index",
+        )
diff --git a/onnx/backend/test/case/node/argmin.py b/onnx/backend/test/case/node/argmin.py
new file mode 100644
index 0000000..0279ecd
--- /dev/null
+++ b/onnx/backend/test/case/node/argmin.py
@@ -0,0 +1,256 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def argmin_use_numpy(data: np.ndarray, axis: int = 0, keepdims: int = 1) -> np.ndarray:
+    result = np.argmin(data, axis=axis)
+    if keepdims == 1:
+        result = np.expand_dims(result, axis)
+    return result.astype(np.int64)
+
+
+def argmin_use_numpy_select_last_index(
+    data: np.ndarray, axis: int = 0, keepdims: int = True
+) -> np.ndarray:
+    data = np.flip(data, axis)
+    result = np.argmin(data, axis=axis)
+    result = data.shape[axis] - result - 1
+    if keepdims:
+        result = np.expand_dims(result, axis)
+    return result.astype(np.int64)
+
+
+class ArgMin(Base):
+    @staticmethod
+    def export_no_keepdims() -> None:
+        data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+        axis = 1
+        keepdims = 0
+        node = onnx.helper.make_node(
+            "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+        )
+        # The content of result is : [[1, 0]]
+        result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_no_keepdims_example",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 4]
+        result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node, inputs=[data], outputs=[result], name="test_argmin_no_keepdims_random"
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+        axis = 1
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+        )
+        # The content of result is : [[1], [0]]
+        result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node, inputs=[data], outputs=[result], name="test_argmin_keepdims_example"
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 1, 4]
+        result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node, inputs=[data], outputs=[result], name="test_argmin_keepdims_random"
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMin", inputs=["data"], outputs=["result"], keepdims=keepdims
+        )
+
+        # The content of result is : [[0], [0]]
+        result = argmin_use_numpy(data, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_default_axis_example",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [1, 3, 4]
+        result = argmin_use_numpy(data, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_default_axis_random",
+        )
+
+    @staticmethod
+    def export_negative_axis_keepdims() -> None:
+        data = np.array([[2, 1], [3, 10]], dtype=np.float32)
+        axis = -1
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMin", inputs=["data"], outputs=["result"], axis=axis, keepdims=keepdims
+        )
+        # The content of result is : [[1], [0]]
+        result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_negative_axis_keepdims_example",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 3, 1]
+        result = argmin_use_numpy(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_negative_axis_keepdims_random",
+        )
+
+    @staticmethod
+    def export_no_keepdims_select_last_index() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        axis = 1
+        keepdims = 0
+        node = onnx.helper.make_node(
+            "ArgMin",
+            inputs=["data"],
+            outputs=["result"],
+            axis=axis,
+            keepdims=keepdims,
+            select_last_index=True,
+        )
+        # result: [[1, 0]]
+        result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_no_keepdims_example_select_last_index",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 4]
+        result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_no_keepdims_random_select_last_index",
+        )
+
+    @staticmethod
+    def export_keepdims_select_last_index() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        axis = 1
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMin",
+            inputs=["data"],
+            outputs=["result"],
+            axis=axis,
+            keepdims=keepdims,
+            select_last_index=True,
+        )
+        # result: [[1], [0]]
+        result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_keepdims_example_select_last_index",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 1, 4]
+        result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_keepdims_random_select_last_index",
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims_select_last_index() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMin",
+            inputs=["data"],
+            outputs=["result"],
+            keepdims=keepdims,
+            select_last_index=True,
+        )
+
+        # result: [[0, 0]]
+        result = argmin_use_numpy_select_last_index(data, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_default_axis_example_select_last_index",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [1, 3, 4]
+        result = argmin_use_numpy_select_last_index(data, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_default_axis_random_select_last_index",
+        )
+
+    @staticmethod
+    def export_negative_axis_keepdims_select_last_index() -> None:
+        data = np.array([[2, 2], [3, 10]], dtype=np.float32)
+        axis = -1
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ArgMin",
+            inputs=["data"],
+            outputs=["result"],
+            axis=axis,
+            keepdims=keepdims,
+            select_last_index=True,
+        )
+        # result: [[1], [0]]
+        result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_negative_axis_keepdims_example_select_last_index",
+        )
+
+        data = np.random.uniform(-10, 10, [2, 3, 4]).astype(np.float32)
+        # result's shape: [2, 3, 1]
+        result = argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[result],
+            name="test_argmin_negative_axis_keepdims_random_select_last_index",
+        )
diff --git a/onnx/backend/test/case/node/asin.py b/onnx/backend/test/case/node/asin.py
new file mode 100644
index 0000000..8db0e38
--- /dev/null
+++ b/onnx/backend/test/case/node/asin.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Asin(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Asin",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-0.5, 0, 0.5]).astype(np.float32)
+        y = np.arcsin(x)
+        expect(node, inputs=[x], outputs=[y], name="test_asin_example")
+
+        x = np.random.rand(3, 4, 5).astype(np.float32)
+        y = np.arcsin(x)
+        expect(node, inputs=[x], outputs=[y], name="test_asin")
diff --git a/onnx/backend/test/case/node/asinh.py b/onnx/backend/test/case/node/asinh.py
new file mode 100644
index 0000000..3023b9d
--- /dev/null
+++ b/onnx/backend/test/case/node/asinh.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Asinh(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Asinh",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.arcsinh(x)  # expected output [-0.88137358,  0.,  0.88137358]
+        expect(node, inputs=[x], outputs=[y], name="test_asinh_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.arcsinh(x)
+        expect(node, inputs=[x], outputs=[y], name="test_asinh")
diff --git a/onnx/backend/test/case/node/atan.py b/onnx/backend/test/case/node/atan.py
new file mode 100644
index 0000000..8d606b8
--- /dev/null
+++ b/onnx/backend/test/case/node/atan.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Atan(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Atan",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.arctan(x)
+        expect(node, inputs=[x], outputs=[y], name="test_atan_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.arctan(x)
+        expect(node, inputs=[x], outputs=[y], name="test_atan")
diff --git a/onnx/backend/test/case/node/atanh.py b/onnx/backend/test/case/node/atanh.py
new file mode 100644
index 0000000..35428c0
--- /dev/null
+++ b/onnx/backend/test/case/node/atanh.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Atanh(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Atanh",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-0.5, 0, 0.5]).astype(np.float32)
+        y = np.arctanh(x)  # expected output [-0.54930615,  0.,  0.54930615]
+        expect(node, inputs=[x], outputs=[y], name="test_atanh_example")
+
+        x = np.random.uniform(0.0, 1.0, (3, 4, 5)).astype(np.float32)
+        y = np.arctanh(x)
+        expect(node, inputs=[x], outputs=[y], name="test_atanh")
diff --git a/onnx/backend/test/case/node/attention.py b/onnx/backend/test/case/node/attention.py
new file mode 100644
index 0000000..0cb5ee5
--- /dev/null
+++ b/onnx/backend/test/case/node/attention.py
@@ -0,0 +1,2699 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_attention import _compute_attention
+
+
+class Attention(Base):
+    @staticmethod
+    def export_attention() -> None:
+        node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_fp16() -> None:
+        node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float16)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float16)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float16)
+
+        Y, _, _, _ = _compute_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_fp16",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_gqa() -> None:
+        node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+        Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_gqa",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_diff_head_sizes() -> None:
+        node = onnx.helper.make_node("Attention", inputs=["Q", "K", "V"], outputs=["Y"])
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_diff_heads_sizes",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_scaled() -> None:
+        scale = 1e-2
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            scale=scale,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V, scale=scale)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_scaled",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_gqa_scaled() -> None:
+        scale = 1e-2
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            scale=scale,
+        )
+
+        Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V, scale=scale)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_gqa_scaled",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_diff_head_sizes_scaled() -> None:
+        scale = 1e-2
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            scale=scale,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V, scale=scale)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_diff_heads_sizes_scaled",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_causal() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V, is_causal=1)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_gqa_causal() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V, is_causal=1)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_gqa_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_diff_head_sizes_causal() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            is_causal=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_diff_heads_sizes_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_attn_mask() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_attn_mask",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_attn_3d_mask() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(2, 1, 4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_attn_mask_3d",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_attn_3d_mask_causal() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(2, 1, 4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            is_causal=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_attn_mask_3d_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_attn_4d_mask() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(2, 3, 4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_attn_mask_4d",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_attn_4d_mask_causal() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(2, 3, 4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            is_causal=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_attn_mask_4d_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_attn_mask_bool() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(bool)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_attn_mask_bool",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_attn_mask_bool_4d() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(2, 3, 4, 6).astype(bool)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_attn_mask_bool_4d",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_gqa_attn_mask() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+        )
+
+        Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_gqa_attn_mask",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_diff_head_sizes_attn_mask() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_diff_heads_sizes_attn_mask",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_past_and_present() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_4d_with_past_and_present",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_gqa_with_past_and_present() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_4d_gqa_with_past_and_present",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_gqa_with_past_and_present_fp16() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 9, 4, 8).astype(np.float16)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float16)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float16)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float16)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float16)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float16)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_4d_gqa_with_past_and_present_fp16",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_diff_head_sizes_with_past_and_present() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_4d_diff_heads_with_past_and_present",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_diff_head_sizes_with_past_and_present_mask3D() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+        attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_4d_diff_heads_with_past_and_present_mask3d",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_diff_head_sizes_with_past_and_present_mask4D() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+        attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_4d_diff_heads_with_past_and_present_mask4d",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_softcap() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            softcap=2.0,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V, softcap=2.0)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_softcap",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_gqa_softcap() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            softcap=2.0,
+        )
+
+        Q = np.random.rand(2, 9, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(Q, K, V, softcap=2.0)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_gqa_softcap",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_diff_head_sizes_softcap() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            softcap=2.0,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            softcap=2.0,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_4d_diff_heads_sizes_softcap",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_qk_matmul() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y", "", "", "qk_matmul_output"],
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+
+        Y, _, _, qk_matmul_output = _compute_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y, qk_matmul_output],
+            name="test_attention_4d_with_qk_matmul",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_qk_matmul_bias() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y", "", "", "qk_matmul_output"],
+            qk_matmul_output_mode=2,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+        Y, _, _, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            qk_matmul_output_mode=2,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y, qk_matmul_output],
+            name="test_attention_4d_with_qk_matmul_bias",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_qk_matmul_softcap() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y", "", "", "qk_matmul_output"],
+            softcap=2.0,
+            qk_matmul_output_mode=1,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+        Y, _, _, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            softcap=2.0,
+            qk_matmul_output_mode=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y, qk_matmul_output],
+            name="test_attention_4d_with_qk_matmul_softcap",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_qk_matmul_softmax() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y", "", "", "qk_matmul_output"],
+            qk_matmul_output_mode=3,
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+        Y, _, _, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            qk_matmul_output_mode=3,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y, qk_matmul_output],
+            name="test_attention_4d_with_qk_matmul_softmax",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_past_and_present_qk_matmul_bias() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+            qk_matmul_output_mode=2,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            qk_matmul_output_mode=2,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_4d_with_past_and_present_qk_matmul_bias",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_past_and_present_qk_matmul_bias_3d_mask() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+            qk_matmul_output_mode=2,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            qk_matmul_output_mode=2,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_past_and_present_qk_matmul_bias_4d_mask() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+            qk_matmul_output_mode=2,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            qk_matmul_output_mode=2,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_past_and_present_qk_matmul_bias_3d_mask_causal() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+            qk_matmul_output_mode=2,
+            is_causal=1,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(2, 1, 4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            qk_matmul_output_mode=2,
+            is_causal=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_past_and_present_qk_matmul_bias_4d_mask_causal() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+            qk_matmul_output_mode=2,
+            is_causal=1,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(2, 3, 4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            qk_matmul_output_mode=2,
+            is_causal=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_with_past_and_present_qk_matmul() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_4d_with_past_and_present_qk_matmul",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_gqa() -> None:
+        q_num_heads, kv_num_heads = 9, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 72).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_gqa",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_diff_head_sizes() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 30).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_diff_heads_sizes",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_scaled() -> None:
+        scale = 1e-2
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            scale=scale,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            scale=scale,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_scaled",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_gqa_scaled() -> None:
+        scale = 1e-2
+        q_num_heads, kv_num_heads = 9, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            scale=scale,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 72).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            scale=scale,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_gqa_scaled",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_diff_head_sizes_scaled() -> None:
+        scale = 1e-2
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            scale=scale,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 30).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            scale=scale,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_diff_heads_sizes_scaled",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_causal() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            is_causal=1,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            is_causal=1,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_gqa_causal() -> None:
+        q_num_heads, kv_num_heads = 9, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            is_causal=1,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 72).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            is_causal=1,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_gqa_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_diff_head_sizes_causal() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            is_causal=1,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 30).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            is_causal=1,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_diff_heads_sizes_causal",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_attn_mask() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_3d_attn_mask",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_gqa_attn_mask() -> None:
+        q_num_heads, kv_num_heads = 9, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 72).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_3d_gqa_attn_mask",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_diff_head_sizes_attn_mask() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 30).astype(np.float32)
+        attn_mask = np.random.rand(4, 6).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_3d_diff_heads_sizes_attn_mask",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_softcap() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            softcap=3.0,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            softcap=3.0,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_softcap",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_gqa_softcap() -> None:
+        q_num_heads, kv_num_heads = 9, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            softcap=3.0,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 72).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            softcap=3.0,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_gqa_softcap",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_diff_head_sizes_softcap() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            softcap=3.0,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 30).astype(np.float32)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            softcap=3.0,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_diff_heads_sizes_softcap",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_with_past_and_present() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_3d_with_past_and_present",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_gqa_with_past_and_present() -> None:
+        q_num_heads, kv_num_heads = 9, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 4, 72).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_3d_gqa_with_past_and_present",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_diff_head_sizes_with_past_and_present() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 30).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 10).astype(np.float32)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_3d_diff_heads_with_past_and_present",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_with_past_and_present_qk_matmul() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_3d_with_past_and_present_qk_matmul",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_with_past_and_present_qk_matmul_bias() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+            qk_matmul_output_mode=2,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+            qk_matmul_output_mode=2,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_3d_with_past_and_present_qk_matmul_bias",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_with_past_and_present_qk_matmul_softcap() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+            softcap=2.0,
+            qk_matmul_output_mode=1,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+            softcap=2.0,
+            qk_matmul_output_mode=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_3d_with_past_and_present_qk_matmul_softcap",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_with_past_and_present_qk_matmul_softmax() -> None:
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value", "qk_matmul_output"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+            qk_matmul_output_mode=3,
+        )
+
+        past_sequence_length = 12
+        Q = np.random.rand(2, 4, 24).astype(np.float32)
+        K = np.random.rand(2, 6, 24).astype(np.float32)
+        V = np.random.rand(2, 6, 24).astype(np.float32)
+        attn_mask = np.random.rand(4, 6 + past_sequence_length).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+            qk_matmul_output_mode=3,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, past_key, past_value],
+            outputs=[Y, present_key, present_value, qk_matmul_output],
+            name="test_attention_3d_with_past_and_present_qk_matmul_softmax",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_3d_transpose_verification() -> None:
+        """Test case to verify correct 3D to 4D transpose behavior.
+
+        This test verifies that 3D inputs are correctly reshaped and transposed
+        according to the ONNX specification:
+        [batch_size, seq_length, hidden_size] ->
+        [batch_size, seq_length, num_heads, head_size] ->
+        [batch_size, num_heads, seq_length, head_size]
+        """
+        q_num_heads, kv_num_heads = 3, 3
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        # Test inputs that will clearly demonstrate the transpose behavior
+        batch_size = 1
+        q_seq_length = 2
+        kv_seq_length = 2
+        head_size = 4
+        q_hidden_size = q_num_heads * head_size  # 3 * 4 = 12
+        kv_hidden_size = kv_num_heads * head_size  # 3 * 4 = 12
+
+        # Create structured inputs to verify correct transpose behavior
+        # Q has a pattern where each position in hidden dimension has a specific value
+        Q = np.zeros((batch_size, q_seq_length, q_hidden_size), dtype=np.float32)
+        # Fill Q with pattern: head0=[1,1,1,1], head1=[2,2,2,2], head2=[3,3,3,3]
+        for head in range(q_num_heads):
+            start_idx = head * head_size
+            end_idx = start_idx + head_size
+            Q[0, :, start_idx:end_idx] = float(head + 1)
+
+        K = np.ones((batch_size, kv_seq_length, kv_hidden_size), dtype=np.float32) * 0.1
+        V = np.ones((batch_size, kv_seq_length, kv_hidden_size), dtype=np.float32) * 0.1
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_attention_3d_transpose_verification",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_4d_diff_heads_mask4d_padded_kv() -> None:
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "", "", "nonpad_kv_seqlen"],
+            outputs=["Y"],
+        )
+
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 6, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 6, 10).astype(np.float32)
+        attn_mask = np.random.rand(2, 3, 4, 4).astype(np.float32)
+        nonpad_kv_seqlen = np.array([3, 4], dtype=np.int64)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            nonpad_kv_seqlen=nonpad_kv_seqlen,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, nonpad_kv_seqlen],
+            outputs=[Y],
+            name="test_attention_4d_diff_heads_mask4d_padded_kv",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_softcap_with_neginf_mask() -> None:
+        """Softcap + -inf mask: verifies softcap is applied BEFORE mask/bias.
+
+        If ordering were wrong (mask then softcap), tanh(-inf/softcap) = -1,
+        so softcap * tanh(-inf/softcap) = -softcap (finite).  That leaks
+        probability to masked positions.  With correct ordering (softcap then
+        mask), the -inf mask values survive to softmax and yield zero weight.
+        """
+        np.random.seed(42)
+        B, H, S_q, S_kv, D = 1, 1, 4, 6, 8
+
+        Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+        K = np.random.rand(B, H, S_kv, D).astype(np.float32)
+        V = np.random.rand(B, H, S_kv, D).astype(np.float32)
+
+        # All Q positions are blocked from KV positions 4 and 5.
+        attn_mask = np.zeros((S_q, S_kv), dtype=np.float32)
+        attn_mask[:, 4:] = -np.inf
+
+        softcap = 0.5
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+            softcap=softcap,
+        )
+
+        Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask, softcap=softcap)
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_softcap_neginf_mask",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_softcap_with_neginf_mask_poison() -> None:
+        """Softcap + -inf mask + poison values at masked KV positions.
+
+        V has value 1000 at the masked positions (4 and 5).  With correct
+        ordering the output stays in [0, 1] because the mask zeros out those
+        positions.  With wrong ordering the output explodes (> 50), making
+        the failure obvious even with loose tolerances.
+        """
+        np.random.seed(42)
+        B, H, S_q, S_kv, D = 1, 1, 4, 6, 8
+
+        Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+        K = np.random.rand(B, H, S_kv, D).astype(np.float32)
+        V = np.random.rand(B, H, S_kv, D).astype(np.float32)
+
+        # Block all Q positions from KV positions 4 and 5.
+        attn_mask = np.zeros((S_q, S_kv), dtype=np.float32)
+        attn_mask[:, 4:] = -np.inf
+
+        # Poison: if attention leaks to masked positions, output >> 1.
+        V[:, :, 4:, :] = 1000.0
+
+        softcap = 0.5
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+            softcap=softcap,
+        )
+
+        Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask, softcap=softcap)
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_4d_softcap_neginf_mask_poison",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_4d_gqa_causal_nonpad_decode() -> None:
+        """External/static-cache decode (S_q=1) with per-batch valid lengths.
+
+        K/V are the full static cache buffer; ``nonpad_kv_seqlen`` marks how many
+        leading keys are valid per batch.  With bottom-right (offset-aware) causal
+        masking the single decode query attends keys ``0..nonpad[b]-1``.  Under the
+        old top-left alignment it would attend only key 0, so this test fails
+        pre-fix and passes post-fix.
+        """
+        np.random.seed(0)
+        B, H_q, H_kv, L, D = 2, 4, 2, 8, 8
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(B, H_q, 1, D).astype(np.float32)
+        K = np.random.rand(B, H_kv, L, D).astype(np.float32)
+        V = np.random.rand(B, H_kv, L, D).astype(np.float32)
+        # Batch 0 has all 8 keys valid, batch 1 only the first 5.
+        nonpad_kv_seqlen = np.array([8, 5], dtype=np.int64)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            nonpad_kv_seqlen=nonpad_kv_seqlen,
+            is_causal=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, nonpad_kv_seqlen],
+            outputs=[Y],
+            name="test_attention_4d_gqa_causal_nonpad_decode",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_4d_gqa_causal_nonpad_decode_fp16() -> None:
+        """fp16 variant of the external-cache decode case (locks -inf dtype handling)."""
+        np.random.seed(0)
+        B, H_q, H_kv, L, D = 2, 4, 2, 8, 8
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(B, H_q, 1, D).astype(np.float16)
+        K = np.random.rand(B, H_kv, L, D).astype(np.float16)
+        V = np.random.rand(B, H_kv, L, D).astype(np.float16)
+        nonpad_kv_seqlen = np.array([8, 5], dtype=np.int64)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            nonpad_kv_seqlen=nonpad_kv_seqlen,
+            is_causal=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, nonpad_kv_seqlen],
+            outputs=[Y],
+            name="test_attention_4d_gqa_causal_nonpad_decode_fp16",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_4d_causal_nonpad_continued_prefill() -> None:
+        """Continued / chunked prefill (S_q=2) into a partially-filled static cache.
+
+        With ``nonpad_kv_seqlen = [4]`` and ``S_q = 2`` the bottom-right offset is
+        ``4 - 2 = 2``: query 0 attends keys ``{0,1,2}`` and query 1 attends
+        ``{0,1,2,3}``.  The old top-left alignment would mask everything past the
+        diagonal (``{0}`` and ``{0,1}``), so this test fails pre-fix.
+        """
+        np.random.seed(1)
+        B, H, L, D = 1, 2, 4, 8
+        S_q = 2
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+        K = np.random.rand(B, H, L, D).astype(np.float32)
+        V = np.random.rand(B, H, L, D).astype(np.float32)
+        nonpad_kv_seqlen = np.array([4], dtype=np.int64)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            nonpad_kv_seqlen=nonpad_kv_seqlen,
+            is_causal=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, nonpad_kv_seqlen],
+            outputs=[Y],
+            name="test_attention_4d_causal_nonpad_continued_prefill",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_4d_causal_with_past_and_present() -> None:
+        """Regression guard: internal (past_key) cache + is_causal.
+
+        This exercises the unchanged scalar bottom-right path (offset =
+        past_sequence_length).  Its golden output must remain identical to the
+        pre-fix behavior, proving the external-cache change does not touch the
+        past_key path.
+        """
+        np.random.seed(2)
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "", "past_key", "past_value"],
+            outputs=["Y", "present_key", "present_value"],
+            is_causal=1,
+        )
+
+        past_sequence_length = 3
+        Q = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        K = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        V = np.random.rand(2, 3, 4, 8).astype(np.float32)
+        past_key = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+        past_value = np.random.rand(2, 3, past_sequence_length, 8).astype(np.float32)
+
+        Y, present_key, present_value, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            past_key=past_key,
+            past_value=past_value,
+            is_causal=1,
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, past_key, past_value],
+            outputs=[Y, present_key, present_value],
+            name="test_attention_4d_causal_with_past_and_present",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_causal_boolmask_nan_robustness() -> None:
+        """Composed ``is_causal`` + boolean ``attn_mask`` NaN-robustness.
+
+        The causal frontier (lower-triangular here, offset 0) and the boolean
+        ``attn_mask`` are intersected: a key is attended only if allowed by both.
+        This exercises two pre-fix NaN sources on the same forward pass:
+
+        * **Bug-1 (allowed cells stay finite).**  Query 0 is allowed key 0 by both
+          the causal frontier (``{0}``) and the mask (``True`` at key 0).  The old
+          ``(1 - attn_mask) * -inf`` conversion computes ``0 * -inf = NaN`` at that
+          allowed cell, poisoning the row.  The select conversion
+          ``where(attn_mask, 0, -inf)`` keeps it finite.
+        * **Bug-2 (fully-masked row -> 0).**  Query 1 is allowed keys ``{0, 1}`` by
+          the causal frontier but the mask is ``False`` at both, so the combined
+          constraint allows no key.  ``softmax`` of an all-``-inf`` row is ``NaN``;
+          the fully-masked-row guard zeros it before the ``P @ V`` contraction so
+          the output row is ``0``.
+
+        4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+        them would make the function body treat the input as 3D).
+        """
+        np.random.seed(3)
+        B, H, S, D = 1, 2, 2, 8
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(B, H, S, D).astype(np.float32)
+        K = np.random.rand(B, H, S, D).astype(np.float32)
+        V = np.random.rand(B, H, S, D).astype(np.float32)
+        # Row 0: key 0 allowed (Bug-1 allowed cell). Row 1: no key allowed -> fully
+        # masked once intersected with the causal frontier (Bug-2 empty row).
+        attn_mask = np.array([[True, False], [False, False]], dtype=np.bool_)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            is_causal=1,
+        )
+
+        # Bug-1: allowed cells are finite (no NaN anywhere). Bug-2: the fully-masked
+        # query row is exactly zero, not NaN.
+        assert np.all(np.isfinite(Y)), "allowed cells must be finite (Bug-1)"
+        assert np.array_equal(Y[:, :, 1, :], np.zeros_like(Y[:, :, 1, :])), (
+            "fully-masked row must be zero (Bug-2)"
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_causal_boolmask_nan_robustness",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_23_boolmask_fullymasked_row_nan_robustness() -> None:
+        """Opset-23 fully-masked boolean ``attn_mask`` row -> zero (not ``NaN``).
+
+        This locks the opset-23 / ``old.cc`` function-body fully-masked-row guard
+        against future regressions. In opset 23 the only in-contract fully-masked
+        row comes from an all-``False`` boolean ``attn_mask`` row (``is_causal`` is
+        not set here): every key for that query is disallowed, so ``softmax`` over an
+        all-``-inf`` bias row is ``NaN``. The guard zeros that row's probabilities
+        before the ``P @ V`` contraction so the output row is exactly ``0``, while
+        rows with at least one allowed key are unchanged.
+
+        4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+        them would make the function body treat the input as 3D).
+        """
+        np.random.seed(4)
+        B, H, S, D = 1, 2, 2, 8
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y"],
+        )
+
+        Q = np.random.rand(B, H, S, D).astype(np.float32)
+        K = np.random.rand(B, H, S, D).astype(np.float32)
+        V = np.random.rand(B, H, S, D).astype(np.float32)
+        # Row 0: no key allowed -> fully masked (Bug-2 empty row). Row 1: both keys
+        # allowed -> finite, unchanged by the guard.
+        attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+        Y, _, _, _ = _compute_attention(Q, K, V, attn_mask=attn_mask)
+
+        # Fully-masked row 0 is exactly zero (not NaN); every other cell is finite.
+        assert np.all(np.isfinite(Y)), "non-masked rows must be finite"
+        assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+            "fully-masked row must be zero (Bug-2)"
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y],
+            name="test_attention_23_boolmask_fullymasked_row_nan_robustness",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_4d_causal_nonpad_negative_offset_structural_empty() -> None:
+        """Negative bottom-right offset: structurally-empty early query rows -> zero.
+
+        This is the onnx-node twin of the ORT gtest
+        ``Attention_Causal_NonPadKVSeqLen_StructuralEmptyRow_Zero`` /
+        ``StructuralEmptyRows_Zero_CUDA``.  With ``nonpad_kv_seqlen = [2]`` and
+        ``S_q = 4`` the bottom-right offset is ``2 - 4 = -2``: query row ``sq``
+        attends keys ``0..(sq - 2)``, so rows 0 and 1 have an empty key set.  Their
+        ``softmax`` over an all-``-inf`` bias row is ``NaN``; the fully-masked-row
+        guard zeros those rows before the ``P @ V`` contraction so the output rows are
+        exactly ``0``, while rows 2 and 3 (attending keys ``{0}`` and ``{0,1}``) stay finite
+        and nonzero.  A ``nonpad_kv_seqlen[b] < q_sequence_length`` input is out of
+        the contract's intended use, but its result is still well-defined (zeroed
+        rows) rather than ``NaN``; this test pins that defined behavior.
+
+        4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+        them would make the function body treat the input as 3D).
+        """
+        np.random.seed(7)
+        B, H, L, D = 1, 2, 4, 8
+        S_q = 4
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+        K = np.random.rand(B, H, L, D).astype(np.float32)
+        V = np.random.rand(B, H, L, D).astype(np.float32)
+        # offset = nonpad - S_q = 2 - 4 = -2 -> rows 0,1 structurally empty.
+        nonpad_kv_seqlen = np.array([2], dtype=np.int64)
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            nonpad_kv_seqlen=nonpad_kv_seqlen,
+            is_causal=1,
+        )
+
+        # Structurally-empty early rows are exactly zero (not NaN); later rows finite.
+        assert np.all(np.isfinite(Y)), "all output rows must be finite"
+        assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+            "structurally-empty row 0 must be zero"
+        )
+        assert np.array_equal(Y[:, :, 1, :], np.zeros_like(Y[:, :, 1, :])), (
+            "structurally-empty row 1 must be zero"
+        )
+        assert np.any(Y[:, :, 2, :] != 0) and np.any(Y[:, :, 3, :] != 0), (
+            "rows with a non-empty key set must be nonzero"
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, nonpad_kv_seqlen],
+            outputs=[Y],
+            name="test_attention_4d_causal_nonpad_negative_offset_structural_empty",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_23_fullymasked_qk_matmul_output_mode3_zero() -> None:
+        """Opset-23 ``qk_matmul_output_mode=3`` fully-masked row is a zero row.
+
+        Mode ``3`` exposes the post-softmax matrix as the optional
+        ``qk_matmul_output``.  For a fully-masked query row (all-``False`` boolean
+        ``attn_mask`` row), the fully-masked-row guard is applied before this output
+        is produced, so the mode-3 row is zeroed, consistent with the primary output
+        ``Y`` row (both are ``0``).  This pins the mandated agreement between the
+        guarded primary output and the mode-3 output at opset 23.
+
+        4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+        them would make the function body treat the input as 3D).
+        """
+        np.random.seed(13)
+        B, H, S, D = 1, 2, 2, 8
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y", "", "", "qk_matmul_output"],
+            qk_matmul_output_mode=3,
+        )
+
+        Q = np.random.rand(B, H, S, D).astype(np.float32)
+        K = np.random.rand(B, H, S, D).astype(np.float32)
+        V = np.random.rand(B, H, S, D).astype(np.float32)
+        # Row 0: no key allowed -> fully masked. Row 1: both keys allowed -> finite.
+        attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+        Y, _, _, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            qk_matmul_output_mode=3,
+        )
+
+        # Primary output row 0 and the mode-3 row 0 are both guarded to zero.
+        assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+            "fully-masked primary output row must be zero"
+        )
+        assert np.array_equal(
+            qk_matmul_output[:, :, 0, :], np.zeros_like(qk_matmul_output[:, :, 0, :])
+        ), "mode-3 output row for a fully-masked query must be zero (consistent with Y)"
+        assert np.all(np.isfinite(qk_matmul_output)), (
+            "all mode-3 rows are finite (the fully-masked row is guarded to 0.0)"
+        )
+        assert np.all(np.isfinite(Y)), (
+            "all Y rows are finite (the fully-masked row is guarded to 0.0)"
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y, qk_matmul_output],
+            name="test_attention_23_fullymasked_qk_matmul_output_mode3_zero",
+            opset_imports=[onnx.helper.make_opsetid("", 23)],
+        )
+
+    @staticmethod
+    def export_attention_24_fullymasked_qk_matmul_output_mode3_zero() -> None:
+        """Opset-24 ``qk_matmul_output_mode=3`` fully-masked row is a zero row.
+
+        The opset-24 twin of
+        ``export_attention_23_fullymasked_qk_matmul_output_mode3_zero``.  Mode ``3``
+        exposes the post-softmax matrix as the optional ``qk_matmul_output``.  For a
+        fully-masked query row (all-``False`` boolean ``attn_mask`` row), the
+        fully-masked-row guard is applied before this output is produced, so the
+        mode-3 row is zeroed, consistent with the primary output ``Y`` row (both are
+        ``0``).  This pins the mandated agreement between the guarded primary output
+        and the mode-3 output at opset 24.
+
+        4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+        them would make the function body treat the input as 3D).
+        """
+        np.random.seed(13)
+        B, H, S, D = 1, 2, 2, 8
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y", "", "", "qk_matmul_output"],
+            qk_matmul_output_mode=3,
+        )
+
+        Q = np.random.rand(B, H, S, D).astype(np.float32)
+        K = np.random.rand(B, H, S, D).astype(np.float32)
+        V = np.random.rand(B, H, S, D).astype(np.float32)
+        # Row 0: no key allowed -> fully masked. Row 1: both keys allowed -> finite.
+        attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+        Y, _, _, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            qk_matmul_output_mode=3,
+        )
+
+        # Primary output row 0 and the mode-3 row 0 are both guarded to zero.
+        assert np.array_equal(Y[:, :, 0, :], np.zeros_like(Y[:, :, 0, :])), (
+            "fully-masked primary output row must be zero"
+        )
+        assert np.array_equal(
+            qk_matmul_output[:, :, 0, :], np.zeros_like(qk_matmul_output[:, :, 0, :])
+        ), "mode-3 output row for a fully-masked query must be zero (consistent with Y)"
+        assert np.all(np.isfinite(qk_matmul_output)), (
+            "all mode-3 rows are finite (the fully-masked row is guarded to 0.0)"
+        )
+        assert np.all(np.isfinite(Y)), (
+            "all Y rows are finite (the fully-masked row is guarded to 0.0)"
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y, qk_matmul_output],
+            name="test_attention_24_fullymasked_qk_matmul_output_mode3_zero",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_24_qk_matmul_output_mode3_softmax_precision() -> None:
+        """Mode-3 ``qk_matmul_output`` is emitted at the output precision ``T1``.
+
+        ``qk_matmul_output_mode=3`` exposes the post-softmax probabilities.  When
+        ``softmax_precision`` differs from the operator's output type ``T1`` (here
+        ``T1 = float16`` with softmax computed in ``float32``), the mode-3 output is
+        cast back to ``T1`` -- matching the reference implementation, which casts the
+        exposed matrix to ``Q.dtype``.  This locks both the dtype contract and the
+        fully-masked-row zeroing under a non-default ``softmax_precision``.
+
+        4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+        them would make the function body treat the input as 3D).
+        """
+        np.random.seed(17)
+        B, H, S, D = 1, 2, 2, 8
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask"],
+            outputs=["Y", "", "", "qk_matmul_output"],
+            qk_matmul_output_mode=3,
+            softmax_precision=int(onnx.TensorProto.FLOAT),
+        )
+
+        # T1 = float16; softmax runs in float32, so the mode-3 output is cast back to
+        # float16 on emission.
+        Q = np.random.rand(B, H, S, D).astype(np.float16)
+        K = np.random.rand(B, H, S, D).astype(np.float16)
+        V = np.random.rand(B, H, S, D).astype(np.float16)
+        # Row 0: fully masked. Row 1: both keys allowed -> finite.
+        attn_mask = np.array([[False, False], [True, True]], dtype=np.bool_)
+
+        Y, _, _, qk_matmul_output = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            qk_matmul_output_mode=3,
+            softmax_precision=int(onnx.TensorProto.FLOAT),
+        )
+
+        # The mode-3 output is emitted at T1 (float16), not the float32 softmax
+        # precision, matching the operator's output type.
+        assert qk_matmul_output.dtype == np.float16, (
+            "mode-3 qk_matmul_output must be emitted at the output precision T1 (float16)"
+        )
+        # The fully-masked row is still guarded to zero, consistent with Y.
+        assert np.array_equal(
+            qk_matmul_output[:, :, 0, :], np.zeros_like(qk_matmul_output[:, :, 0, :])
+        ), "mode-3 output row for a fully-masked query must be zero (consistent with Y)"
+        assert np.all(np.isfinite(qk_matmul_output)), (
+            "all mode-3 rows are finite (the fully-masked row is guarded to 0.0)"
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask],
+            outputs=[Y, qk_matmul_output],
+            name="test_attention_24_qk_matmul_output_mode3_softmax_precision",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_4d_causal_nonpad_attn_mask_composition() -> None:
+        """Compose ``is_causal`` + ``nonpad_kv_seqlen`` + boolean ``attn_mask``.
+
+        The existing nonpad tests use no ``attn_mask`` and the existing mask tests
+        use no ``nonpad_kv_seqlen``; this is the first to activate all three
+        constraints together on the external-cache path with ``batch > 1``.  The
+        three biases are summed additively and a key is attended only if allowed by
+        all three.  Crucially the inputs are designed so that **each constraint is
+        independently necessary** -- removing any one changes the golden -- to avoid a
+        degenerate test that a backend ignoring ``is_causal`` and/or
+        ``nonpad_kv_seqlen`` could still pass:
+
+        * **``is_causal`` binds.**  Each batch has a key that the boolean mask allows
+          (``True``) but the bottom-right causal frontier disallows
+          (``j > i + offset``); only ``is_causal`` masks it (batch 0 row 0 key 2,
+          batch 1 row 0 key 3).
+        * **``attn_mask`` binds.**  Each batch has a key the causal frontier and the
+          padding bound both allow but the boolean mask sets ``False`` (batch 0 row 2
+          key 1, batch 1 row 2 key 2); only the mask masks it.
+        * **``nonpad_kv_seqlen`` binds.**  ``nonpad_kv_seqlen`` sets the per-batch
+          causal *offset* (``offset = nonpad_kv_seqlen - q_sequence_length``), so
+          dropping it collapses the frontier to top-left (``offset = 0``) and shifts
+          which keys are attended.  (Under ``is_causal=1`` the causal frontier already
+          subsumes the ``j < nonpad`` padding bound, so ``nonpad_kv_seqlen`` binds
+          through the offset it induces rather than through a redundant padding cut.)
+
+        The mask is chosen to leave at least one allowed key on every query row, so
+        this exercises the *intersection* of the three constraints with finite outputs
+        (the fully-masked-row guard is covered by
+        ``test_attention_4d_causal_nonpad_negative_offset_structural_empty`` and
+        ``test_attention_24_fullymasked_qk_matmul_output_mode3_zero``).
+
+        4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+        them would make the function body treat the input as 3D).
+        """
+        np.random.seed(11)
+        B, H, L, D = 2, 2, 6, 8
+        S_q = 3
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "attn_mask", "", "", "nonpad_kv_seqlen"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+        K = np.random.rand(B, H, L, D).astype(np.float32)
+        V = np.random.rand(B, H, L, D).astype(np.float32)
+        nonpad_kv_seqlen = np.array([4, 5], dtype=np.int64)  # offsets [1, 2]
+        # Per-batch (B, 1, S_q, L) bool mask. Each batch is laid out so all three
+        # constraints uniquely bind (see the docstring): a causal-only-masked key
+        # (mask True, j > i + offset), a mask-only-masked key (mask False, causal +
+        # nonpad allow it), and >=1 allowed key per row.
+        attn_mask = np.array(
+            [
+                [
+                    [
+                        [True, True, True, False, False, False],
+                        [True, True, True, False, False, False],
+                        [True, False, True, True, False, False],
+                    ]
+                ],
+                [
+                    [
+                        [True, True, True, True, False, False],
+                        [True, True, True, True, False, False],
+                        [True, True, False, True, True, False],
+                    ]
+                ],
+            ],
+            dtype=np.bool_,
+        )
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            nonpad_kv_seqlen=nonpad_kv_seqlen,
+            is_causal=1,
+        )
+
+        # The chosen mask leaves >=1 allowed key per row, so the composition stays
+        # finite (no fully-masked row in this case).
+        assert np.all(np.isfinite(Y)), "composed-constraint output must be finite"
+
+        # Non-degeneracy: each constraint is independently necessary. Removing any one
+        # of the three (is_causal, attn_mask, nonpad_kv_seqlen) must change the result,
+        # so a backend that ignores is_causal or nonpad_kv_seqlen cannot reproduce the
+        # golden by applying only the most restrictive mask.
+        y_no_causal, _, _, _ = _compute_attention(
+            Q, K, V, attn_mask=attn_mask, nonpad_kv_seqlen=nonpad_kv_seqlen, is_causal=0
+        )
+        y_no_mask, _, _, _ = _compute_attention(
+            Q, K, V, nonpad_kv_seqlen=nonpad_kv_seqlen, is_causal=1
+        )
+        y_no_nonpad, _, _, _ = _compute_attention(
+            Q, K, V, attn_mask=attn_mask, is_causal=1
+        )
+        assert not np.allclose(Y, y_no_causal, equal_nan=True), (
+            "is_causal must bind: dropping it changes the result"
+        )
+        assert not np.allclose(Y, y_no_mask, equal_nan=True), (
+            "attn_mask must bind: dropping it changes the result"
+        )
+        assert not np.allclose(Y, y_no_nonpad, equal_nan=True), (
+            "nonpad_kv_seqlen must bind (via the causal offset): dropping it changes the result"
+        )
+
+        expect(
+            node,
+            inputs=[Q, K, V, attn_mask, nonpad_kv_seqlen],
+            outputs=[Y],
+            name="test_attention_4d_causal_nonpad_attn_mask_composition",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
+
+    @staticmethod
+    def export_attention_4d_causal_nonpad_batch_prefill() -> None:
+        """Batch>1 continued prefill with distinct per-batch bottom-right offsets.
+
+        The batched generalization of the ``batch == 1`` continued-prefill case: with
+        ``nonpad_kv_seqlen = [4, 5, 6]`` and ``S_q = 2`` the per-batch bottom-right
+        offsets are ``[2, 3, 4]`` (all ``>= 0``), so each batch realigns its causal
+        frontier to its own valid-key prefix.  This pins that the per-batch offset is
+        applied independently across the batch dimension.
+
+        4D Q/K/V is used so ``q_num_heads``/``kv_num_heads`` are omitted (passing
+        them would make the function body treat the input as 3D).
+        """
+        np.random.seed(12)
+        B, H, L, D = 3, 2, 6, 8
+        S_q = 2
+
+        node = onnx.helper.make_node(
+            "Attention",
+            inputs=["Q", "K", "V", "", "", "", "nonpad_kv_seqlen"],
+            outputs=["Y"],
+            is_causal=1,
+        )
+
+        Q = np.random.rand(B, H, S_q, D).astype(np.float32)
+        K = np.random.rand(B, H, L, D).astype(np.float32)
+        V = np.random.rand(B, H, L, D).astype(np.float32)
+        nonpad_kv_seqlen = np.array([4, 5, 6], dtype=np.int64)  # offsets [2, 3, 4]
+
+        Y, _, _, _ = _compute_attention(
+            Q,
+            K,
+            V,
+            nonpad_kv_seqlen=nonpad_kv_seqlen,
+            is_causal=1,
+        )
+
+        assert np.all(np.isfinite(Y)), "per-batch prefill output must be finite"
+
+        expect(
+            node,
+            inputs=[Q, K, V, nonpad_kv_seqlen],
+            outputs=[Y],
+            name="test_attention_4d_causal_nonpad_batch_prefill",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
diff --git a/onnx/backend/test/case/node/averagepool.py b/onnx/backend/test/case/node/averagepool.py
new file mode 100644
index 0000000..61044f6
--- /dev/null
+++ b/onnx/backend/test/case/node/averagepool.py
@@ -0,0 +1,695 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_pool_common import (
+    get_output_shape_auto_pad,
+    get_output_shape_explicit_padding,
+    get_pad_shape,
+    pool,
+)
+
+
+class AveragePool(Base):
+    @staticmethod
+    def export_averagepool_2d_precomputed_pads() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 5, 5]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[5, 5],
+            pads=[2, 2, 2, 2],
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array(
+            [
+                [
+                    [
+                        [7, 7.5, 8, 8.5, 9],
+                        [9.5, 10, 10.5, 11, 11.5],
+                        [12, 12.5, 13, 13.5, 14],
+                        [14.5, 15, 15.5, 16, 16.5],
+                        [17, 17.5, 18, 18.5, 19],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(
+            node, inputs=[x], outputs=[y], name="test_averagepool_2d_precomputed_pads"
+        )
+
+    @staticmethod
+    def export_averagepool_2d_precomputed_pads_count_include_pad() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 5, 5]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[5, 5],
+            pads=[2, 2, 2, 2],
+            count_include_pad=1,
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array(
+            [
+                [
+                    [
+                        [2.5200, 3.6000, 4.8000, 4.0800, 3.2400],
+                        [4.5600, 6.4000, 8.4000, 7.0400, 5.5200],
+                        [7.2000, 10.0000, 13.0000, 10.8000, 8.4000],
+                        [6.9600, 9.6000, 12.4000, 10.2400, 7.9200],
+                        [6.1200, 8.4000, 10.8000, 8.8800, 6.8400],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_averagepool_2d_precomputed_pads_count_include_pad",
+        )
+
+    @staticmethod
+    def export_averagepool_2d_precomputed_strides() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 2, 2]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            strides=[2, 2],
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[4, 6], [14, 16]]]]).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_averagepool_2d_precomputed_strides",
+        )
+
+    @staticmethod
+    def export_averagepool_2d_precomputed_same_upper() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 3, 3]
+        pad_shape: [2, 2] -> [1, 1, 1, 1] by axis
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            strides=[2, 2],
+            auto_pad="SAME_UPPER",
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[4, 5.5, 7], [11.5, 13, 14.5], [19, 20.5, 22]]]]).astype(
+            np.float32
+        )
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_averagepool_2d_precomputed_same_upper",
+        )
+
+    @staticmethod
+    def export_averagepool_1d_default() -> None:
+        """input_shape: [1, 3, 32]
+        output_shape: [1, 3, 31]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2],
+        )
+        x = np.random.randn(1, 3, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = [2]
+        strides = [1]
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG")
+
+        expect(node, inputs=[x], outputs=[y], name="test_averagepool_1d_default")
+
+    @staticmethod
+    def export_averagepool_2d_default() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 31, 31]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG")
+
+        expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_default")
+
+    @staticmethod
+    def export_averagepool_3d_default() -> None:
+        """input_shape: [1, 3, 32, 32, 32]
+        output_shape: [1, 3, 31, 31, 31]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2, 2],
+        )
+        x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = [2, 2, 2]
+        strides = [1, 1, 1]
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "AVG")
+
+        expect(node, inputs=[x], outputs=[y], name="test_averagepool_3d_default")
+
+    @staticmethod
+    def export_averagepool_2d_same_upper() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 32, 32]
+        pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            auto_pad="SAME_UPPER",
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape = get_output_shape_auto_pad(
+            "SAME_UPPER", x_shape[2:], kernel_shape, strides
+        )
+        pad_shape = get_pad_shape(
+            "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+        )
+        pad_top = pad_shape[0] // 2
+        pad_bottom = pad_shape[0] - pad_top
+        pad_left = pad_shape[1] // 2
+        pad_right = pad_shape[1] - pad_left
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=np.nan,
+        )
+        pads = (pad_top, pad_left, pad_bottom, pad_right)
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=pads,
+            pads=pads,
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_upper")
+
+    @staticmethod
+    def export_averagepool_2d_same_lower() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 32, 32]
+        pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            auto_pad="SAME_LOWER",
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape = get_output_shape_auto_pad(
+            "SAME_LOWER", x_shape[2:], kernel_shape, strides
+        )
+        pad_shape = get_pad_shape(
+            "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+        )
+        pad_bottom = pad_shape[0] // 2
+        pad_top = pad_shape[0] - pad_bottom
+        pad_right = pad_shape[1] // 2
+        pad_left = pad_shape[1] - pad_right
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=np.nan,
+        )
+        pads = (pad_top, pad_left, pad_bottom, pad_right)
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=pads,
+            pads=pads,
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_same_lower")
+
+    @staticmethod
+    def export_averagepool_2d_pads() -> None:
+        """input_shape: [1, 3, 28, 28]
+        output_shape: [1, 3, 30, 30]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            pads=[2, 2, 2, 2],
+        )
+        x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (3, 3)
+        strides = (1, 1)
+        pad_bottom = 2
+        pad_top = 2
+        pad_right = 2
+        pad_left = 2
+        pads = [pad_top, pad_left, pad_bottom, pad_right]
+        out_shape, extra_pads = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides, ceil_mode=False
+        )
+        padded = np.pad(
+            x,
+            (
+                (0, 0),
+                (0, 0),
+                (extra_pads[0], extra_pads[2]),
+                (extra_pads[1], extra_pads[3]),
+            ),
+            mode="constant",
+            constant_values=np.nan,
+        )
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=extra_pads,
+            pads=pads,
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_pads")
+
+    @staticmethod
+    def export_averagepool_2d_pads_count_include_pad() -> None:
+        """input_shape: [1, 3, 28, 28]
+        output_shape: [1, 3, 30, 30]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            pads=[2, 2, 2, 2],
+            count_include_pad=1,
+        )
+        x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+        x_shape = np.shape(x)
+        dilations = (1, 1)
+        kernel_shape = (3, 3)
+        strides = (1, 1)
+        pad_bottom = 2
+        pad_top = 2
+        pad_right = 2
+        pad_left = 2
+        pads = [pad_top, pad_left, pad_bottom, pad_right]
+        out_shape, extra_pads = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides, dilations, ceil_mode=False
+        )
+        padded = np.pad(
+            x,
+            (
+                (0, 0),
+                (0, 0),
+                (extra_pads[0], extra_pads[2]),
+                (extra_pads[1], extra_pads[3]),
+            ),
+            mode="constant",
+            constant_values=0,
+        )
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=extra_pads,
+            pads=pads,
+            count_include_pad=1,
+        )
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_averagepool_2d_pads_count_include_pad",
+        )
+
+    @staticmethod
+    def export_averagepool_2d_strides() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 10, 10]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[5, 5],
+            strides=[3, 3],
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (5, 5)
+        strides = (3, 3)
+        out_shape, pads = get_output_shape_explicit_padding(
+            None, x_shape[2:], kernel_shape, strides, ceil_mode=False
+        )
+        padded = x
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "AVG",
+            pads_required=pads,
+            pads=None,
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_strides")
+
+    @staticmethod
+    def export_averagepool_2d_ceil() -> None:
+        """input_shape: [1, 1, 4, 4]
+        output_shape: [1, 1, 2, 2]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            strides=[2, 2],
+            ceil_mode=True,
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[6, 7.5], [12, 13.5]]]]).astype(np.float32)
+
+        expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_ceil")
+
+    @staticmethod
+    def export_averagepool_2d_ceil_last_window_starts_on_pad() -> None:
+        """input_shape: [1, 3, 2, 2]
+        output_shape: [1, 3, 1, 1]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            strides=[3, 3],
+            pads=[1, 1, 1, 1],
+            ceil_mode=True,
+            count_include_pad=1,
+        )
+        x = np.array(
+            [
+                [
+                    [[0.8580, 0.0786], [0.2692, 0.1537]],
+                    [[0.8816, 0.4353], [0.5772, 0.6623]],
+                    [[0.9067, 0.9483], [0.5970, 0.7630]],
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[0.1511]], [[0.2841]], [[0.3572]]]]).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_averagepool_2d_ceil_last_window_starts_on_pad",
+        )
+
+    @staticmethod
+    def export_averagepool_2d_dilations() -> None:
+        """input_shape: [1, 1, 4, 4]
+        output_shape: [1, 1, 2, 2]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            strides=[1, 1],
+            dilations=[2, 2],
+            ceil_mode=True,
+        )
+
+        # input shape: [1, 1, 4, 4]
+        x = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        y = np.array([[[[6, 7], [10, 11]]]]).astype(np.float32)
+
+        expect(node, inputs=[x], outputs=[y], name="test_averagepool_2d_dilations")
+
+    @staticmethod
+    def export_averagepool_3d_dilations() -> None:
+        """input_shape: [1, 1, 4, 4]
+        output_shape: [1, 1, 2, 2]
+        """
+        node = onnx.helper.make_node(
+            "AveragePool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2, 2],
+            strides=[1, 1, 1],
+            dilations=[2, 2, 2],
+            ceil_mode=True,
+        )
+
+        # input shape: [1, 1, 4, 4, 4]
+        x = np.array(
+            [
+                [
+                    [
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        y = np.array([[[[[6, 7], [10, 11]], [[6, 7], [10, 11]]]]]).astype(np.float32)
+
+        expect(
+            node, inputs=[x], outputs=[y], name="test_averagepool_3d_dilations_small"
+        )
+
+    @staticmethod
+    def export_averagepool_3d_dilations_large() -> None:
+        x_shape = (32, 32, 32)
+        dilations = (2, 2, 2)
+        kernel_shape = (5, 5, 5)
+        strides = (3, 3, 3)
+        count_include_pad = 0
+
+        for count_include_pad in (0, 1):
+            for ceil_mode in (True, False):
+                node = onnx.helper.make_node(
+                    "AveragePool",
+                    inputs=["x"],
+                    outputs=["y"],
+                    kernel_shape=kernel_shape,
+                    strides=strides,
+                    dilations=dilations,
+                    count_include_pad=count_include_pad,
+                    ceil_mode=ceil_mode,
+                )
+
+                x = np.random.randn(1, 1, *x_shape).astype(np.float32)
+                out_shape, extra_pads = get_output_shape_explicit_padding(
+                    None,
+                    x_shape,
+                    kernel_shape,
+                    strides,
+                    dilations=dilations,
+                    ceil_mode=ceil_mode,
+                )
+                padded = np.pad(
+                    x,
+                    (
+                        (0, 0),
+                        (0, 0),
+                        (extra_pads[0], extra_pads[3]),
+                        (extra_pads[1], extra_pads[4]),
+                        (extra_pads[2], extra_pads[5]),
+                    ),
+                    mode="constant",
+                    constant_values=0 if count_include_pad == 1 else np.nan,
+                )
+                y = pool(
+                    padded,
+                    (1, 1, *x_shape),
+                    kernel_shape,
+                    strides,
+                    out_shape,
+                    "AVG",
+                    pads_required=extra_pads,
+                    pads=None,
+                    dilations=dilations,
+                    count_include_pad=count_include_pad,
+                )
+
+                test_name = f"test_averagepool_3d_dilations_large_count_include_pad_is_{count_include_pad}_ceil_mode_is_{ceil_mode}"
+                expect(node, inputs=[x], outputs=[y], name=test_name)
diff --git a/onnx/backend/test/case/node/batchnorm.py b/onnx/backend/test/case/node/batchnorm.py
new file mode 100644
index 0000000..83e321f
--- /dev/null
+++ b/onnx/backend/test/case/node/batchnorm.py
@@ -0,0 +1,137 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def _batchnorm_test_mode(x, s, bias, mean, var, epsilon=1e-5):
+    dims_x = len(x.shape)
+    dim_ones = (1,) * (dims_x - 2)
+    s = s.reshape(-1, *dim_ones)
+    bias = bias.reshape(-1, *dim_ones)
+    mean = mean.reshape(-1, *dim_ones)
+    var = var.reshape(-1, *dim_ones)
+    return s * (x - mean) / np.sqrt(var + epsilon) + bias
+
+
+def _batchnorm_training_mode(x, s, bias, mean, var, momentum=0.9, epsilon=1e-5):
+    axis = tuple(np.delete(np.arange(len(x.shape)), 1))
+    saved_mean = x.mean(axis=axis)
+    saved_var = x.var(axis=axis)
+    output_mean = mean * momentum + saved_mean * (1 - momentum)
+    output_var = var * momentum + saved_var * (1 - momentum)
+    y = _batchnorm_test_mode(x, s, bias, saved_mean, saved_var, epsilon=epsilon)
+    return y.astype(np.float32), output_mean, output_var
+
+
+class BatchNormalization(Base):
+    @staticmethod
+    def export() -> None:
+        # input size: (2, 3, 4, 5)
+        x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+        s = np.random.randn(3).astype(np.float32)
+        bias = np.random.randn(3).astype(np.float32)
+        mean = np.random.randn(3).astype(np.float32)
+        var = np.random.rand(3).astype(np.float32)
+        y = _batchnorm_test_mode(x, s, bias, mean, var).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "BatchNormalization",
+            inputs=["x", "s", "bias", "mean", "var"],
+            outputs=["y"],
+        )
+
+        # output size: (2, 3, 4, 5)
+        expect(
+            node,
+            inputs=[x, s, bias, mean, var],
+            outputs=[y],
+            name="test_batchnorm_example",
+        )
+
+        # input size: (2, 3, 4, 5)
+        x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+        s = np.random.randn(3).astype(np.float32)
+        bias = np.random.randn(3).astype(np.float32)
+        mean = np.random.randn(3).astype(np.float32)
+        var = np.random.rand(3).astype(np.float32)
+        epsilon = 1e-2
+        y = _batchnorm_test_mode(x, s, bias, mean, var, epsilon).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "BatchNormalization",
+            inputs=["x", "s", "bias", "mean", "var"],
+            outputs=["y"],
+            epsilon=epsilon,
+        )
+
+        # output size: (2, 3, 4, 5)
+        expect(
+            node,
+            inputs=[x, s, bias, mean, var],
+            outputs=[y],
+            name="test_batchnorm_epsilon",
+        )
+
+    @staticmethod
+    def export_train() -> None:
+        # input size: (2, 3, 4, 5)
+        x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+        s = np.random.randn(3).astype(np.float32)
+        bias = np.random.randn(3).astype(np.float32)
+        mean = np.random.randn(3).astype(np.float32)
+        var = np.random.rand(3).astype(np.float32)
+        # using np.bool(1) while generating test data with "'bool' object has no attribute 'dtype'"
+        # working around by using np.byte(1).astype(bool)
+        training_mode = 1
+        y, output_mean, output_var = _batchnorm_training_mode(x, s, bias, mean, var)
+
+        node = onnx.helper.make_node(
+            "BatchNormalization",
+            inputs=["x", "s", "bias", "mean", "var"],
+            outputs=["y", "output_mean", "output_var"],
+            training_mode=training_mode,
+        )
+
+        # output size: (2, 3, 4, 5)
+        expect(
+            node,
+            inputs=[x, s, bias, mean, var],
+            outputs=[y, output_mean, output_var],
+            name="test_batchnorm_example_training_mode",
+        )
+
+        # input size: (2, 3, 4, 5)
+        x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+        s = np.random.randn(3).astype(np.float32)
+        bias = np.random.randn(3).astype(np.float32)
+        mean = np.random.randn(3).astype(np.float32)
+        var = np.random.rand(3).astype(np.float32)
+        training_mode = 1
+        momentum = 0.9
+        epsilon = 1e-2
+        y, output_mean, output_var = _batchnorm_training_mode(
+            x, s, bias, mean, var, momentum, epsilon
+        )
+
+        node = onnx.helper.make_node(
+            "BatchNormalization",
+            inputs=["x", "s", "bias", "mean", "var"],
+            outputs=["y", "output_mean", "output_var"],
+            epsilon=epsilon,
+            training_mode=training_mode,
+        )
+
+        # output size: (2, 3, 4, 5)
+        expect(
+            node,
+            inputs=[x, s, bias, mean, var],
+            outputs=[y, output_mean, output_var],
+            name="test_batchnorm_epsilon_training_mode",
+        )
diff --git a/onnx/backend/test/case/node/bernoulli.py b/onnx/backend/test/case/node/bernoulli.py
new file mode 100755
index 0000000..164ec9e
--- /dev/null
+++ b/onnx/backend/test/case/node/bernoulli.py
@@ -0,0 +1,59 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def bernoulli_reference_implementation(x, dtype):
+    # binomial n = 1 equal bernoulli
+    # This example and test-case is for informational purpose. The generator operator is
+    # non-deterministic and may not produce the same values in different implementations
+    # even if a seed is specified.
+    return np.random.binomial(1, p=x).astype(dtype)
+
+
+class Bernoulli(Base):
+    @staticmethod
+    def export_bernoulli_without_dtype() -> None:
+        node = onnx.helper.make_node(
+            "Bernoulli",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.random.uniform(0.0, 1.0, 10).astype(float)
+        y = bernoulli_reference_implementation(x, float)
+        expect(node, inputs=[x], outputs=[y], name="test_bernoulli")
+
+    @staticmethod
+    def export_bernoulli_with_dtype() -> None:
+        node = onnx.helper.make_node(
+            "Bernoulli",
+            inputs=["x"],
+            outputs=["y"],
+            dtype=onnx.TensorProto.DOUBLE,
+        )
+
+        x = np.random.uniform(0.0, 1.0, 10).astype(np.float32)
+        y = bernoulli_reference_implementation(x, float)
+        expect(node, inputs=[x], outputs=[y], name="test_bernoulli_double")
+
+    @staticmethod
+    def export_bernoulli_with_seed() -> None:
+        seed = float(0)
+        node = onnx.helper.make_node(
+            "Bernoulli",
+            inputs=["x"],
+            outputs=["y"],
+            seed=seed,
+        )
+
+        x = np.random.uniform(0.0, 1.0, 10).astype(np.float32)
+        y = bernoulli_reference_implementation(x, np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_bernoulli_seed")
diff --git a/onnx/backend/test/case/node/bitcast.py b/onnx/backend/test/case/node/bitcast.py
new file mode 100644
index 0000000..15f2a3b
--- /dev/null
+++ b/onnx/backend/test/case/node/bitcast.py
@@ -0,0 +1,147 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class BitCast(Base):
+    @staticmethod
+    def export_bitcast_float32_to_int32() -> None:
+        """Test bitcasting from float32 to int32 (same size)."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.INT32,
+        )
+        x = np.array([1.0, -2.5, 3.75], dtype=np.float32)
+        y = x.view(np.int32)
+        expect(node, inputs=[x], outputs=[y], name="test_bitcast_float32_to_int32")
+
+    @staticmethod
+    def export_bitcast_int32_to_float32() -> None:
+        """Test bitcasting from int32 to float32 (same size)."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.FLOAT,
+        )
+        x = np.array([1065353216, -1071644672, 1081081856], dtype=np.int32)
+        y = x.view(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_bitcast_int32_to_float32")
+
+    @staticmethod
+    def export_bitcast_float64_to_int64() -> None:
+        """Test bitcasting from float64 to int64 (same size)."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.INT64,
+        )
+        x = np.array([1.0, -2.5, 3.75], dtype=np.float64)
+        y = x.view(np.int64)
+        expect(node, inputs=[x], outputs=[y], name="test_bitcast_float64_to_int64")
+
+    @staticmethod
+    def export_bitcast_int64_to_float64() -> None:
+        """Test bitcasting from int64 to float64 (same size)."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.DOUBLE,
+        )
+        x = np.array(
+            [4607182418800017408, -4611686018427387904, 4614256656552045184],
+            dtype=np.int64,
+        )
+        y = x.view(np.float64)
+        expect(node, inputs=[x], outputs=[y], name="test_bitcast_int64_to_float64")
+
+    @staticmethod
+    def export_bitcast_uint32_to_int32() -> None:
+        """Test bitcasting from uint32 to int32 (same size, different signedness)."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.INT32,
+        )
+        x = np.array([4294967295, 2147483648, 2147483647], dtype=np.uint32)
+        y = x.view(np.int32)
+        expect(node, inputs=[x], outputs=[y], name="test_bitcast_uint32_to_int32")
+
+    @staticmethod
+    def export_bitcast_2d_float32_to_int32() -> None:
+        """Test bitcasting 2D array from float32 to int32."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.INT32,
+        )
+        x = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=np.float32)
+        y = x.view(np.int32)
+        expect(node, inputs=[x], outputs=[y], name="test_bitcast_2d_float32_to_int32")
+
+    @staticmethod
+    def export_bitcast_int8_to_uint8() -> None:
+        """Test bitcasting from int8 to uint8 (same size, different signedness)."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.UINT8,
+        )
+        x = np.array([-1, -128, 127, 0], dtype=np.int8)
+        y = x.view(np.uint8)
+        expect(node, inputs=[x], outputs=[y], name="test_bitcast_int8_to_uint8")
+
+    @staticmethod
+    def export_bitcast_scalar_float32_to_int32() -> None:
+        """Test bitcasting scalar from float32 to int32."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.INT32,
+        )
+        x = np.array(1.0, dtype=np.float32)
+        y = x.view(np.int32)
+        expect(
+            node, inputs=[x], outputs=[y], name="test_bitcast_scalar_float32_to_int32"
+        )
+
+    @staticmethod
+    def export_bitcast_uint16_to_int16() -> None:
+        """Test bitcasting from uint16 to int16 (same size, different signedness)."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.INT16,
+        )
+        x = np.array([1, 32768, 65535], dtype=np.uint16)
+        y = x.view(np.int16)
+        expect(node, inputs=[x], outputs=[y], name="test_bitcast_uint16_to_int16")
+
+    @staticmethod
+    def export_bitcast_bool_to_uint8() -> None:
+        """Test bitcasting from bool to uint8 (same size)."""
+        node = onnx.helper.make_node(
+            "BitCast",
+            inputs=["x"],
+            outputs=["y"],
+            to=onnx.TensorProto.UINT8,
+        )
+        x = np.array([True, False, True, False], dtype=np.bool_)
+        y = x.view(np.uint8)
+        expect(node, inputs=[x], outputs=[y], name="test_bitcast_bool_to_uint8")
diff --git a/onnx/backend/test/case/node/bitshift.py b/onnx/backend/test/case/node/bitshift.py
new file mode 100644
index 0000000..4eeb4ba
--- /dev/null
+++ b/onnx/backend/test/case/node/bitshift.py
@@ -0,0 +1,100 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class BitShift(Base):
+    @staticmethod
+    def export_right_unit8() -> None:
+        node = onnx.helper.make_node(
+            "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+        )
+
+        x = np.array([16, 4, 1]).astype(np.uint8)
+        y = np.array([1, 2, 3]).astype(np.uint8)
+        z = x >> y  # expected output [8, 1, 0]
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint8")
+
+    @staticmethod
+    def export_right_unit16() -> None:
+        node = onnx.helper.make_node(
+            "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+        )
+
+        x = np.array([16, 4, 1]).astype(np.uint16)
+        y = np.array([1, 2, 3]).astype(np.uint16)
+        z = x >> y  # expected output [8, 1, 0]
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint16")
+
+    @staticmethod
+    def export_right_unit32() -> None:
+        node = onnx.helper.make_node(
+            "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+        )
+
+        x = np.array([16, 4, 1]).astype(np.uint32)
+        y = np.array([1, 2, 3]).astype(np.uint32)
+        z = x >> y  # expected output [8, 1, 0]
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint32")
+
+    @staticmethod
+    def export_right_unit64() -> None:
+        node = onnx.helper.make_node(
+            "BitShift", inputs=["x", "y"], outputs=["z"], direction="RIGHT"
+        )
+
+        x = np.array([16, 4, 1]).astype(np.uint64)
+        y = np.array([1, 2, 3]).astype(np.uint64)
+        z = x >> y  # expected output [8, 1, 0]
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_right_uint64")
+
+    @staticmethod
+    def export_left_unit8() -> None:
+        node = onnx.helper.make_node(
+            "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+        )
+
+        x = np.array([16, 4, 1]).astype(np.uint8)
+        y = np.array([1, 2, 3]).astype(np.uint8)
+        z = x << y  # expected output [32, 16, 8]
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint8")
+
+    @staticmethod
+    def export_left_unit16() -> None:
+        node = onnx.helper.make_node(
+            "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+        )
+
+        x = np.array([16, 4, 1]).astype(np.uint16)
+        y = np.array([1, 2, 3]).astype(np.uint16)
+        z = x << y  # expected output [32, 16, 8]
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint16")
+
+    @staticmethod
+    def export_left_unit32() -> None:
+        node = onnx.helper.make_node(
+            "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+        )
+
+        x = np.array([16, 4, 1]).astype(np.uint32)
+        y = np.array([1, 2, 3]).astype(np.uint32)
+        z = x << y  # expected output [32, 16, 8]
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint32")
+
+    @staticmethod
+    def export_left_unit64() -> None:
+        node = onnx.helper.make_node(
+            "BitShift", inputs=["x", "y"], outputs=["z"], direction="LEFT"
+        )
+
+        x = np.array([16, 4, 1]).astype(np.uint64)
+        y = np.array([1, 2, 3]).astype(np.uint64)
+        z = x << y  # expected output [32, 16, 8]
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitshift_left_uint64")
diff --git a/onnx/backend/test/case/node/bitwiseand.py b/onnx/backend/test/case/node/bitwiseand.py
new file mode 100644
index 0000000..723b66d
--- /dev/null
+++ b/onnx/backend/test/case/node/bitwiseand.py
@@ -0,0 +1,55 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.numpy_helper import create_random_int
+
+
+class BitwiseAnd(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "BitwiseAnd",
+            inputs=["x", "y"],
+            outputs=["bitwiseand"],
+        )
+
+        # 2d
+        x = create_random_int((3, 4), np.int32)
+        y = create_random_int((3, 4), np.int32)
+        z = np.bitwise_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i32_2d")
+
+        # 3d
+        x = create_random_int((3, 4, 5), np.int16)
+        y = create_random_int((3, 4, 5), np.int16)
+        z = np.bitwise_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_i16_3d")
+
+    @staticmethod
+    def export_bitwiseand_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "BitwiseAnd",
+            inputs=["x", "y"],
+            outputs=["bitwiseand"],
+        )
+
+        # 3d vs 1d
+        x = create_random_int((3, 4, 5), np.uint64)
+        y = create_random_int((5,), np.uint64)
+        z = np.bitwise_and(x, y)
+        expect(
+            node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui64_bcast_3v1d"
+        )
+
+        # 4d vs 3d
+        x = create_random_int((3, 4, 5, 6), np.uint8)
+        y = create_random_int((4, 5, 6), np.uint8)
+        z = np.bitwise_and(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_and_ui8_bcast_4v3d")
diff --git a/onnx/backend/test/case/node/bitwisenot.py b/onnx/backend/test/case/node/bitwisenot.py
new file mode 100644
index 0000000..fb0ba20
--- /dev/null
+++ b/onnx/backend/test/case/node/bitwisenot.py
@@ -0,0 +1,36 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.numpy_helper import create_random_int
+
+
+class BitwiseNot(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "BitwiseNot",
+            inputs=["x"],
+            outputs=["bitwise_not"],
+        )
+
+        # 2d
+        x = create_random_int((3, 4), np.int32)
+        y = np.bitwise_not(x)
+        expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_2d")
+
+        # 3d
+        x = create_random_int((3, 4, 5), np.uint16)
+        y = np.bitwise_not(x)
+        expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_3d")
+
+        # 4d
+        x = create_random_int((3, 4, 5, 6), np.uint8)
+        y = np.bitwise_not(x)
+        expect(node, inputs=[x], outputs=[y], name="test_bitwise_not_4d")
diff --git a/onnx/backend/test/case/node/bitwiseor.py b/onnx/backend/test/case/node/bitwiseor.py
new file mode 100644
index 0000000..5968002
--- /dev/null
+++ b/onnx/backend/test/case/node/bitwiseor.py
@@ -0,0 +1,52 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.numpy_helper import create_random_int
+
+
+class BitwiseOr(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "BitwiseOr",
+            inputs=["x", "y"],
+            outputs=["bitwiseor"],
+        )
+        # 2d
+        x = create_random_int((3, 4), np.int32)
+        y = create_random_int((3, 4), np.int32)
+        z = np.bitwise_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i32_2d")
+
+        # 4d
+        x = create_random_int((3, 4, 5, 6), np.int8)
+        y = create_random_int((3, 4, 5, 6), np.int8)
+        z = np.bitwise_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_i16_4d")
+
+    @staticmethod
+    def export_bitwiseor_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "BitwiseOr",
+            inputs=["x", "y"],
+            outputs=["bitwiseor"],
+        )
+
+        # 3d vs 1d
+        x = create_random_int((3, 4, 5), np.uint64)
+        y = create_random_int((5,), np.uint64)
+        z = np.bitwise_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui64_bcast_3v1d")
+
+        # 4d vs 3d
+        x = create_random_int((3, 4, 5, 6), np.uint8)
+        y = create_random_int((4, 5, 6), np.uint8)
+        z = np.bitwise_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_or_ui8_bcast_4v3d")
diff --git a/onnx/backend/test/case/node/bitwisexor.py b/onnx/backend/test/case/node/bitwisexor.py
new file mode 100644
index 0000000..338ebc0
--- /dev/null
+++ b/onnx/backend/test/case/node/bitwisexor.py
@@ -0,0 +1,55 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.numpy_helper import create_random_int
+
+
+class BitwiseXor(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "BitwiseXor",
+            inputs=["x", "y"],
+            outputs=["bitwisexor"],
+        )
+
+        # 2d
+        x = create_random_int((3, 4), np.int32)
+        y = create_random_int((3, 4), np.int32)
+        z = np.bitwise_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i32_2d")
+
+        # 3d
+        x = create_random_int((3, 4, 5), np.int16)
+        y = create_random_int((3, 4, 5), np.int16)
+        z = np.bitwise_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_i16_3d")
+
+    @staticmethod
+    def export_bitwiseor_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "BitwiseXor",
+            inputs=["x", "y"],
+            outputs=["bitwisexor"],
+        )
+
+        # 3d vs 1d
+        x = create_random_int((3, 4, 5), np.uint64)
+        y = create_random_int((5,), np.uint64)
+        z = np.bitwise_xor(x, y)
+        expect(
+            node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui64_bcast_3v1d"
+        )
+
+        # 4d vs 3d
+        x = create_random_int((3, 4, 5, 6), np.uint8)
+        y = create_random_int((4, 5, 6), np.uint8)
+        z = np.bitwise_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_bitwise_xor_ui8_bcast_4v3d")
diff --git a/onnx/backend/test/case/node/blackmanwindow.py b/onnx/backend/test/case/node/blackmanwindow.py
new file mode 100644
index 0000000..b0da12b
--- /dev/null
+++ b/onnx/backend/test/case/node/blackmanwindow.py
@@ -0,0 +1,56 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class BlackmanWindow(Base):
+    @staticmethod
+    def export() -> None:
+        # Test periodic window
+        node = onnx.helper.make_node(
+            "BlackmanWindow",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        size = np.int32(10)
+        a0 = 0.42
+        a1 = -0.5
+        a2 = 0.08
+        y = a0
+        y += a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+        y += a2 * np.cos(4 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+        expect(
+            node,
+            inputs=[size],
+            outputs=[y.astype(np.float32)],
+            name="test_blackmanwindow",
+        )
+
+        # Test symmetric window
+        node = onnx.helper.make_node(
+            "BlackmanWindow", inputs=["x"], outputs=["y"], periodic=0
+        )
+        size = np.int32(10)
+        a0 = 0.42
+        a1 = -0.5
+        a2 = 0.08
+        y = a0
+        y += a1 * np.cos(
+            2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+        )
+        y += a2 * np.cos(
+            4 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+        )
+        expect(
+            node,
+            inputs=[size],
+            outputs=[y.astype(np.float32)],
+            name="test_blackmanwindow_symmetric",
+        )
diff --git a/onnx/backend/test/case/node/cast.py b/onnx/backend/test/case/node/cast.py
new file mode 100644
index 0000000..dc3218a
--- /dev/null
+++ b/onnx/backend/test/case/node/cast.py
@@ -0,0 +1,398 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import itertools
+
+import numpy as np
+
+import onnx
+from onnx import TensorProto
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.helper import (
+    make_tensor,
+    tensor_dtype_to_np_dtype,
+)
+from onnx.numpy_helper import to_float8e8m0
+
+F8_TYPES = frozenset({"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"})
+FOUR_BIT_TYPES = frozenset({"UINT4", "INT4", "FLOAT4E2M1"})
+TWO_BIT_TYPES = frozenset({"UINT2", "INT2"})
+
+
+class Cast(Base):
+    @staticmethod
+    def export() -> None:
+        test_cases = [
+            ("FLOAT", "FLOAT16"),
+            ("FLOAT", "DOUBLE"),
+            ("FLOAT16", "FLOAT"),
+            ("FLOAT16", "DOUBLE"),
+            ("DOUBLE", "FLOAT"),
+            ("DOUBLE", "FLOAT16"),
+            ("FLOAT", "BFLOAT16"),
+            ("BFLOAT16", "FLOAT"),
+            ("FLOAT", "FLOAT8E4M3FN"),
+            ("FLOAT16", "FLOAT8E4M3FN"),
+            ("FLOAT", "FLOAT8E4M3FNUZ"),
+            ("FLOAT16", "FLOAT8E4M3FNUZ"),
+            ("FLOAT8E4M3FN", "FLOAT"),
+            ("FLOAT8E4M3FN", "FLOAT16"),
+            ("FLOAT8E4M3FNUZ", "FLOAT"),
+            ("FLOAT8E4M3FNUZ", "FLOAT16"),
+            ("FLOAT", "FLOAT8E5M2"),
+            ("FLOAT16", "FLOAT8E5M2"),
+            ("FLOAT", "FLOAT8E5M2FNUZ"),
+            ("FLOAT16", "FLOAT8E5M2FNUZ"),
+            ("FLOAT8E5M2", "FLOAT"),
+            ("FLOAT8E5M2", "FLOAT16"),
+            ("FLOAT8E5M2FNUZ", "FLOAT"),
+            ("FLOAT8E5M2FNUZ", "FLOAT16"),
+            ("FLOAT", "UINT4"),
+            ("FLOAT16", "UINT4"),
+            ("FLOAT", "INT4"),
+            ("FLOAT16", "INT4"),
+            ("UINT4", "FLOAT"),
+            ("UINT4", "FLOAT16"),
+            ("UINT4", "UINT8"),
+            ("INT4", "FLOAT"),
+            ("INT4", "FLOAT16"),
+            ("INT4", "INT8"),
+            ("FLOAT4E2M1", "FLOAT"),
+            ("FLOAT4E2M1", "FLOAT16"),
+            ("FLOAT", "FLOAT4E2M1"),
+            ("FLOAT16", "FLOAT4E2M1"),
+            ("FLOAT", "UINT2"),
+            ("FLOAT16", "UINT2"),
+            ("FLOAT", "INT2"),
+            ("FLOAT16", "INT2"),
+            ("UINT2", "FLOAT"),
+            ("UINT2", "FLOAT16"),
+            ("UINT2", "UINT8"),
+            ("INT2", "FLOAT"),
+            ("INT2", "FLOAT16"),
+            ("INT2", "INT8"),
+        ]
+
+        for from_type, to_type in test_cases:
+            if from_type == to_type:
+                # Skip cases where from_type and to_type are the same
+                continue
+            from_dtype = getattr(TensorProto, from_type)
+            to_dtype = getattr(TensorProto, to_type)
+            from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+            to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+
+            if from_type == "BFLOAT16" or to_type == "BFLOAT16":
+                np_fp32 = np.array(
+                    [
+                        "0.47892547",
+                        "0.48033667",
+                        "0.49968487",
+                        "0.81910545",
+                        "0.47031248",
+                        "0.816468",
+                        "0.21087195",
+                        "0.7229038",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                    ],
+                    dtype=np.float32,
+                )
+                input_shape = (3, 4)
+
+            elif from_type in F8_TYPES or to_type in F8_TYPES:
+                np_fp32 = np.array(
+                    [
+                        "0.47892547",
+                        "0.48033667",
+                        "0.49968487",
+                        "0.81910545",
+                        "0.47031248",
+                        "0.7229038",
+                        "1000000",
+                        "1e-7",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                        "-0.0000001",
+                        "0.0000001",
+                        "-1000000",
+                    ],
+                    dtype=np.float32,
+                )
+                input_shape = (3, 5)
+            elif from_type in ("UINT4", "INT4") or to_type in ("UINT4", "INT4"):
+                np_fp32 = np.arange(-9, 16).astype(np.float32)
+                input_shape = (5, 5)
+            elif from_type in ("UINT2", "INT2") or to_type in ("UINT2", "INT2"):
+                np_fp32 = np.arange(-3, 4).astype(np.float32)
+                input_shape = (7, 1)
+            elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1":
+                np_fp32 = np.array(
+                    [
+                        "0.48",
+                        "0.25",
+                        "1.05",
+                        "-3.5",
+                        "-8",
+                        "9",
+                        "1000000",
+                        "1e-7",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                        "-4",
+                        "0.01",
+                        "-0.0",
+                    ],
+                    dtype=np.float32,
+                )
+                input_shape = (3, 5)
+
+            else:
+                np_fp32 = np.array(
+                    [
+                        "0.47892547",
+                        "0.48033667",
+                        "0.49968487",
+                        "0.81910545",
+                        "0.47031248",
+                        "0.816468",
+                        "0.21087195",
+                        "0.7229038",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                    ],
+                    dtype=np.float32,
+                ).reshape([3, 4])
+                input_shape = (3, 4)
+
+            if from_type in F8_TYPES:
+                np_from = onnx.numpy_helper.saturate_cast(np_fp32, from_np_dtype)
+                input = make_tensor(
+                    "input",
+                    from_dtype,
+                    input_shape,
+                    vals=np_from,
+                    raw=True,
+                )
+            elif from_type in FOUR_BIT_TYPES:
+                np_from = np_fp32.astype(from_np_dtype)
+                packed = onnx.numpy_helper._pack_4bitx2(np_from)
+                # No byteswap needed on big-endian machines as _pack_4bitx2()
+                # returns a numpy array with uint8 datatype.
+                input = make_tensor(
+                    "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            elif from_type in TWO_BIT_TYPES:
+                np_from = np_fp32.astype(from_np_dtype)
+                packed = onnx.numpy_helper._pack_2bitx4(np_from)
+                input = make_tensor(
+                    "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            else:
+                np_from = np_fp32.astype(from_np_dtype)
+                input = make_tensor(
+                    "input", from_dtype, input_shape, vals=np_from, raw=True
+                )
+
+            if to_type in F8_TYPES:
+                output = make_tensor(
+                    "output",
+                    to_dtype,
+                    input_shape,
+                    vals=onnx.numpy_helper.saturate_cast(np_from, to_np_dtype),
+                    raw=True,
+                )
+            elif to_type in FOUR_BIT_TYPES:
+                packed = onnx.numpy_helper._pack_4bitx2(np_from.astype(to_np_dtype))
+                # No byteswap needed on big-endian machines as _pack_4bitx2()
+                # returns a numpy array with uint8 datatype.
+                output = make_tensor(
+                    "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            elif to_type in TWO_BIT_TYPES:
+                packed = onnx.numpy_helper._pack_2bitx4(np_from.astype(to_np_dtype))
+                output = make_tensor(
+                    "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            else:
+                output = make_tensor(
+                    "output",
+                    to_dtype,
+                    input_shape,
+                    vals=np_from.astype(to_np_dtype),
+                    raw=True,
+                )
+
+            node = onnx.helper.make_node(
+                "Cast",
+                inputs=["input"],
+                outputs=["output"],
+                to=to_dtype,
+            )
+            expect(
+                node,
+                inputs=[input],
+                outputs=[output],
+                name="test_cast_" + from_type + "_to_" + to_type,
+            )
+
+    @staticmethod
+    def export_saturate_false() -> None:
+        test_cases = itertools.product(
+            [
+                "FLOAT",
+                "FLOAT16",
+            ],
+            [
+                "FLOAT8E4M3FN",
+                "FLOAT8E4M3FNUZ",
+                "FLOAT8E5M2",
+                "FLOAT8E5M2FNUZ",
+            ],
+        )
+        input_shape = (3, 5)
+        for from_type, to_type in test_cases:
+            from_dtype = getattr(TensorProto, from_type)
+            to_dtype = getattr(TensorProto, to_type)
+            from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+            to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+            np_fp32 = np.array(
+                [
+                    "0.47892547",
+                    "0.48033667",
+                    "0.49968487",
+                    "0.81910545",
+                    "0.47031248",
+                    "0.7229038",
+                    "1000000",
+                    "1e-7",
+                    "NaN",
+                    "INF",
+                    "+INF",
+                    "-INF",
+                    "-0.0000001",
+                    "0.0000001",
+                    "-1000000",
+                ],
+                dtype=np.float32,
+            )
+
+            input = make_tensor(
+                "input",
+                from_dtype,
+                input_shape,
+                vals=np_fp32.astype(from_np_dtype),
+                raw=True,
+            )
+            output = make_tensor(
+                "output",
+                to_dtype,
+                input_shape,
+                vals=np_fp32.astype(from_np_dtype).astype(to_np_dtype),
+                raw=True,
+            )
+
+            node = onnx.helper.make_node(
+                "Cast",
+                inputs=["input"],
+                outputs=["output"],
+                to=to_dtype,
+                saturate=0,
+            )
+            expect(
+                node,
+                inputs=[input],
+                outputs=[output],
+                name="test_cast_no_saturate_" + from_type + "_to_" + to_type,
+            )
+
+    @staticmethod
+    def export_e8m0() -> None:
+        np_fp32 = np.array(
+            [
+                "0.0",
+                "0.124",
+                "0.25",
+                "0.5",
+                "1.1",
+                "2.0",
+                "4.0",
+                "8.0",
+            ],
+            dtype=np.float32,
+        )
+        test_cases = [
+            ("FLOAT", "FLOAT8E8M0"),
+            ("FLOAT16", "FLOAT8E8M0"),
+            ("FLOAT8E8M0", "FLOAT"),
+            ("FLOAT8E8M0", "FLOAT16"),
+        ]
+        for from_type, to_type in test_cases:
+            if from_type == "FLOAT":
+                input_np = np_fp32
+                output_np = to_float8e8m0(np_fp32)
+            elif from_type == "FLOAT16":
+                input_np = np_fp32.astype(np.float16)
+                output_np = to_float8e8m0(input_np)
+            elif from_type == "FLOAT8E8M0":
+                input_np = to_float8e8m0(np_fp32)
+                if to_type == "FLOAT":
+                    output_np = input_np.astype(np.float32)
+                elif to_type == "FLOAT16":
+                    output_np = input_np.astype(np.float16)
+                else:
+                    raise ValueError(
+                        f"Conversion from {from_type} to {to_type} is not tested."
+                    )
+            else:
+                raise ValueError(
+                    f"Conversion from {from_type} to {to_type} is not tested."
+                )
+            input = make_tensor(
+                "input",
+                getattr(TensorProto, from_type),
+                [2, 4],
+                input_np,
+                raw=True,
+            )
+            output = make_tensor(
+                "output",
+                getattr(TensorProto, to_type),
+                [2, 4],
+                output_np,
+                raw=True,
+            )
+            if to_type == "FLOAT8E8M0":
+                node = onnx.helper.make_node(
+                    "Cast",
+                    inputs=["input"],
+                    outputs=["output"],
+                    to=getattr(TensorProto, to_type),
+                    saturate=1,
+                    round_mode="up",
+                )
+            else:
+                node = onnx.helper.make_node(
+                    "Cast",
+                    inputs=["input"],
+                    outputs=["output"],
+                    to=getattr(TensorProto, to_type),
+                )
+
+            expect(
+                node,
+                inputs=[input],
+                outputs=[output],
+                name="test_cast_e8m0_" + from_type + "_to_" + to_type,
+            )
diff --git a/onnx/backend/test/case/node/castlike.py b/onnx/backend/test/case/node/castlike.py
new file mode 100644
index 0000000..7bd9018
--- /dev/null
+++ b/onnx/backend/test/case/node/castlike.py
@@ -0,0 +1,324 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import itertools
+
+import numpy as np
+
+import onnx
+from onnx import TensorProto
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.helper import make_tensor, tensor_dtype_to_np_dtype
+
+F8_TYPES = frozenset({"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"})
+FOUR_BIT_TYPES = frozenset({"UINT4", "INT4", "FLOAT4E2M1"})
+TWO_BIT_TYPES = frozenset({"UINT2", "INT2"})
+
+
+class CastLike(Base):
+    @staticmethod
+    def export() -> None:
+        test_cases = [
+            ("FLOAT", "FLOAT16"),
+            ("FLOAT", "DOUBLE"),
+            ("FLOAT16", "FLOAT"),
+            ("FLOAT16", "DOUBLE"),
+            ("DOUBLE", "FLOAT"),
+            ("DOUBLE", "FLOAT16"),
+            ("FLOAT", "BFLOAT16"),
+            ("BFLOAT16", "FLOAT"),
+            ("FLOAT", "FLOAT8E4M3FN"),
+            ("FLOAT16", "FLOAT8E4M3FN"),
+            ("FLOAT", "FLOAT8E4M3FNUZ"),
+            ("FLOAT16", "FLOAT8E4M3FNUZ"),
+            ("FLOAT8E4M3FN", "FLOAT"),
+            ("FLOAT8E4M3FN", "FLOAT16"),
+            ("FLOAT8E4M3FNUZ", "FLOAT"),
+            ("FLOAT8E4M3FNUZ", "FLOAT16"),
+            ("FLOAT", "FLOAT8E5M2"),
+            ("FLOAT16", "FLOAT8E5M2"),
+            ("FLOAT", "FLOAT8E5M2FNUZ"),
+            ("FLOAT16", "FLOAT8E5M2FNUZ"),
+            ("FLOAT8E5M2", "FLOAT"),
+            ("FLOAT8E5M2", "FLOAT16"),
+            ("FLOAT8E5M2FNUZ", "FLOAT"),
+            ("FLOAT8E5M2FNUZ", "FLOAT16"),
+            ("FLOAT", "UINT4"),
+            ("FLOAT16", "UINT4"),
+            ("FLOAT", "INT4"),
+            ("FLOAT16", "INT4"),
+            ("UINT4", "FLOAT"),
+            ("UINT4", "FLOAT16"),
+            ("UINT4", "UINT8"),
+            ("INT4", "FLOAT"),
+            ("INT4", "FLOAT16"),
+            ("INT4", "INT8"),
+            ("FLOAT4E2M1", "FLOAT"),
+            ("FLOAT4E2M1", "FLOAT16"),
+            ("FLOAT", "FLOAT4E2M1"),
+            ("FLOAT16", "FLOAT4E2M1"),
+            ("FLOAT", "UINT2"),
+            ("FLOAT16", "UINT2"),
+            ("FLOAT", "INT2"),
+            ("FLOAT16", "INT2"),
+            ("UINT2", "FLOAT"),
+            ("UINT2", "FLOAT16"),
+            ("UINT2", "UINT8"),
+            ("INT2", "FLOAT"),
+            ("INT2", "FLOAT16"),
+            ("INT2", "INT8"),
+        ]
+
+        f8_types = {"FLOAT8E4M3FN", "FLOAT8E4M3FNUZ", "FLOAT8E5M2", "FLOAT8E5M2FNUZ"}
+
+        for from_type, to_type in test_cases:
+            if from_type == to_type:
+                # Skip cases where from_type and to_type are the same
+                continue
+            from_dtype = getattr(TensorProto, from_type)
+            to_dtype = getattr(TensorProto, to_type)
+            from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+            to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+
+            if from_type == "BFLOAT16" or to_type == "BFLOAT16":
+                np_fp32 = np.array(
+                    [
+                        "0.47892547",
+                        "0.48033667",
+                        "0.49968487",
+                        "0.81910545",
+                        "0.47031248",
+                        "0.816468",
+                        "0.21087195",
+                        "0.7229038",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                    ],
+                    dtype=np.float32,
+                )
+                input_shape = (3, 4)
+
+            elif from_type in f8_types or to_type in f8_types:
+                np_fp32 = np.array(
+                    [
+                        "0.47892547",
+                        "0.48033667",
+                        "0.49968487",
+                        "0.81910545",
+                        "0.47031248",
+                        "0.7229038",
+                        "1000000",
+                        "1e-7",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                        "-0.0000001",
+                        "0.0000001",
+                        "-1000000",
+                    ],
+                    dtype=np.float32,
+                )
+                input_shape = (3, 5)
+            elif from_type in ("UINT4", "INT4") or to_type in ("UINT4", "INT4"):
+                np_fp32 = np.arange(-9, 16).astype(np.float32)
+                input_shape = (5, 5)
+            elif from_type in ("UINT2", "INT2") or to_type in ("UINT2", "INT2"):
+                np_fp32 = np.arange(-3, 4).astype(np.float32)
+                input_shape = (7, 1)
+            elif from_type == "FLOAT4E2M1" or to_type == "FLOAT4E2M1":
+                np_fp32 = np.array(
+                    [
+                        "0.48",
+                        "0.25",
+                        "1.05",
+                        "-3.5",
+                        "-8",
+                        "9",
+                        "1000000",
+                        "1e-7",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                        "-4",
+                        "0.01",
+                        "-0.0",
+                    ],
+                    dtype=np.float32,
+                )
+                input_shape = (3, 5)
+
+            else:
+                np_fp32 = np.array(
+                    [
+                        "0.47892547",
+                        "0.48033667",
+                        "0.49968487",
+                        "0.81910545",
+                        "0.47031248",
+                        "0.816468",
+                        "0.21087195",
+                        "0.7229038",
+                        "NaN",
+                        "INF",
+                        "+INF",
+                        "-INF",
+                    ],
+                    dtype=np.float32,
+                ).reshape([3, 4])
+                input_shape = (3, 4)
+
+            if from_type in F8_TYPES:
+                np_from = onnx.numpy_helper.saturate_cast(np_fp32, from_np_dtype)
+                input = make_tensor(
+                    "input",
+                    from_dtype,
+                    input_shape,
+                    vals=np_from,
+                    raw=True,
+                )
+            elif from_type in FOUR_BIT_TYPES:
+                np_from = np_fp32.astype(from_np_dtype)
+                packed = onnx.numpy_helper._pack_4bitx2(np_from)
+                # No byteswap needed on big-endian machines as _pack_4bitx2()
+                # returns a numpy array with uint8 datatype.
+                input = make_tensor(
+                    "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            elif from_type in TWO_BIT_TYPES:
+                np_from = np_fp32.astype(from_np_dtype)
+                packed = onnx.numpy_helper._pack_2bitx4(np_from)
+                # No byteswap needed on big-endian machines as _pack_2bitx4()
+                # returns a numpy array with uint8 datatype.
+                input = make_tensor(
+                    "input", from_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            else:
+                np_from = np_fp32.astype(from_np_dtype)
+                input = make_tensor(
+                    "input", from_dtype, input_shape, vals=np_from, raw=True
+                )
+
+            if to_type in F8_TYPES:
+                output = make_tensor(
+                    "output",
+                    to_dtype,
+                    input_shape,
+                    vals=onnx.numpy_helper.saturate_cast(np_from, to_np_dtype),
+                    raw=True,
+                )
+            elif to_type in FOUR_BIT_TYPES:
+                packed = onnx.numpy_helper._pack_4bitx2(np_from.astype(to_np_dtype))
+                # No byteswap needed on big-endian machines as _pack_4bitx2()
+                # returns a numpy array with uint8 datatype.
+                output = make_tensor(
+                    "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            elif to_type in TWO_BIT_TYPES:
+                packed = onnx.numpy_helper._pack_2bitx4(np_from.astype(to_np_dtype))
+                # No byteswap needed on big-endian machines as _pack_2bitx4()
+                # returns a numpy array with uint8 datatype.
+                output = make_tensor(
+                    "output", to_dtype, input_shape, vals=packed.tobytes(), raw=True
+                )
+            else:
+                output = make_tensor(
+                    "output",
+                    to_dtype,
+                    input_shape,
+                    vals=np_from.astype(to_np_dtype),
+                    raw=True,
+                )
+
+            like = make_tensor("like", to_dtype, (0,), vals=[])
+
+            node = onnx.helper.make_node(
+                "CastLike",
+                inputs=["input", "like"],
+                outputs=["output"],
+            )
+
+            expect(
+                node,
+                inputs=[input, like],
+                outputs=[output],
+                name="test_castlike_" + from_type + "_to_" + to_type,
+            )
+
+    @staticmethod
+    def export_saturate_false() -> None:
+        test_cases = itertools.product(
+            [
+                "FLOAT",
+                "FLOAT16",
+            ],
+            [
+                "FLOAT8E4M3FN",
+                "FLOAT8E4M3FNUZ",
+                "FLOAT8E5M2",
+                "FLOAT8E5M2FNUZ",
+            ],
+        )
+        input_shape = (3, 5)
+        for from_type, to_type in test_cases:
+            from_dtype = getattr(TensorProto, from_type)
+            to_dtype = getattr(TensorProto, to_type)
+            from_np_dtype = tensor_dtype_to_np_dtype(from_dtype)
+            to_np_dtype = tensor_dtype_to_np_dtype(to_dtype)
+            np_fp32 = np.array(
+                [
+                    "0.47892547",
+                    "0.48033667",
+                    "0.49968487",
+                    "0.81910545",
+                    "0.47031248",
+                    "0.7229038",
+                    "1000000",
+                    "1e-7",
+                    "NaN",
+                    "INF",
+                    "+INF",
+                    "-INF",
+                    "-0.0000001",
+                    "0.0000001",
+                    "-1000000",
+                ],
+                dtype=np.float32,
+            )
+
+            input = make_tensor(
+                "input",
+                from_dtype,
+                input_shape,
+                vals=np_fp32.astype(from_np_dtype),
+                raw=True,
+            )
+            output = make_tensor(
+                "output",
+                to_dtype,
+                input_shape,
+                vals=np_fp32.astype(from_np_dtype).astype(to_np_dtype),
+                raw=True,
+            )
+
+            like = make_tensor("like", to_dtype, (0,), vals=[])
+
+            node = onnx.helper.make_node(
+                "CastLike",
+                inputs=["input", "like"],
+                outputs=["output"],
+                saturate=0,
+            )
+
+            expect(
+                node,
+                inputs=[input, like],
+                outputs=[output],
+                name="test_castlike_no_saturate_" + from_type + "_to_" + to_type,
+            )
diff --git a/onnx/backend/test/case/node/causal_conv_with_state.py b/onnx/backend/test/case/node/causal_conv_with_state.py
new file mode 100644
index 0000000..a06e673
--- /dev/null
+++ b/onnx/backend/test/case/node/causal_conv_with_state.py
@@ -0,0 +1,335 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_causal_conv_with_state import (
+    CausalConvWithState as _RefCausalConvWithState,
+)
+
+
+def _compute(input_, weight, bias=None, past_state=None, activation="none"):
+    op = _RefCausalConvWithState.__new__(_RefCausalConvWithState)
+    return op._run(
+        input_,
+        weight,
+        bias=bias,
+        past_state=past_state,
+        activation=activation,
+    )
+
+
+class CausalConvWithState(Base):
+    @staticmethod
+    def export_basic() -> None:
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight"],
+            outputs=["output", "present_state"],
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 4
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+        output, present_state = _compute(input_, weight)
+
+        expect(
+            node,
+            inputs=[input_, weight],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_basic",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_with_bias() -> None:
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight", "bias"],
+            outputs=["output", "present_state"],
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 4
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+        bias = np.random.randn(channels).astype(np.float32)
+
+        output, present_state = _compute(input_, weight, bias=bias)
+
+        expect(
+            node,
+            inputs=[input_, weight, bias],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_with_bias",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_with_past_state() -> None:
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight", "", "past_state"],
+            outputs=["output", "present_state"],
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 4
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+        past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+        output, present_state = _compute(input_, weight, past_state=past_state)
+
+        expect(
+            node,
+            inputs=[input_, weight, past_state],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_with_past_state",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_silu() -> None:
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight"],
+            outputs=["output", "present_state"],
+            activation="silu",
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 4
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+        output, present_state = _compute(input_, weight, activation="silu")
+
+        expect(
+            node,
+            inputs=[input_, weight],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_silu",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_swish_alias() -> None:
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight"],
+            outputs=["output", "present_state"],
+            activation="swish",
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 4
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+        output, present_state = _compute(input_, weight, activation="swish")
+
+        expect(
+            node,
+            inputs=[input_, weight],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_swish_alias",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_decode_step() -> None:
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight", "bias", "past_state"],
+            outputs=["output", "present_state"],
+        )
+
+        batch_size, channels, length, k = 2, 4, 1, 4
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+        bias = np.random.randn(channels).astype(np.float32)
+        past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+        output, present_state = _compute(
+            input_, weight, bias=bias, past_state=past_state
+        )
+
+        expect(
+            node,
+            inputs=[input_, weight, bias, past_state],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_decode_step",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_kernel_size_one() -> None:
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight"],
+            outputs=["output", "present_state"],
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 1
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+        output, present_state = _compute(input_, weight)
+
+        expect(
+            node,
+            inputs=[input_, weight],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_kernel_size_one",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_with_bias_and_past_state() -> None:
+        # Multi-token (T>1) path through Concat(past, input) -> Conv(+bias).
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight", "bias", "past_state"],
+            outputs=["output", "present_state"],
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 4
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+        bias = np.random.randn(channels).astype(np.float32)
+        past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+        output, present_state = _compute(
+            input_, weight, bias=bias, past_state=past_state
+        )
+
+        expect(
+            node,
+            inputs=[input_, weight, bias, past_state],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_with_bias_and_past_state",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_silu_with_past_state() -> None:
+        # Fused activation combined with concat-from-past variant of PaddedInput.
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight", "", "past_state"],
+            outputs=["output", "present_state"],
+            activation="silu",
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 4
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+        past_state = np.random.randn(batch_size, channels, k - 1).astype(np.float32)
+
+        output, present_state = _compute(
+            input_, weight, past_state=past_state, activation="silu"
+        )
+
+        expect(
+            node,
+            inputs=[input_, weight, past_state],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_silu_with_past_state",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_b1_c1_degenerate() -> None:
+        # Mamba/GDN inner-head edge case: B=1, C=1.
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight"],
+            outputs=["output", "present_state"],
+        )
+
+        batch_size, channels, length, k = 1, 1, 6, 4
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+        output, present_state = _compute(input_, weight)
+
+        expect(
+            node,
+            inputs=[input_, weight],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_b1_c1_degenerate",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_short_input_no_past_state() -> None:
+        # L < k-1 with no past_state: zero-pad is wider than the input.
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight"],
+            outputs=["output", "present_state"],
+        )
+
+        batch_size, channels, length, k = 2, 4, 2, 5
+        input_ = np.random.randn(batch_size, channels, length).astype(np.float32)
+        weight = np.random.randn(channels, 1, k).astype(np.float32)
+
+        output, present_state = _compute(input_, weight)
+
+        expect(
+            node,
+            inputs=[input_, weight],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_short_input_no_past_state",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_fp16() -> None:
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight"],
+            outputs=["output", "present_state"],
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 4
+        input_ = np.random.rand(batch_size, channels, length).astype(np.float16)
+        weight = np.random.rand(channels, 1, k).astype(np.float16)
+
+        output, present_state = _compute(input_, weight)
+
+        expect(
+            node,
+            inputs=[input_, weight],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_fp16",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
+
+    @staticmethod
+    def export_silu_fp16() -> None:
+        # fp16 + SiLU: the reference upcasts Sigmoid/Mul to float32, so the
+        # function-body expansion must do the same to stay numerically faithful.
+        node = onnx.helper.make_node(
+            "CausalConvWithState",
+            inputs=["input", "weight"],
+            outputs=["output", "present_state"],
+            activation="silu",
+        )
+
+        batch_size, channels, length, k = 2, 4, 8, 4
+        input_ = np.random.rand(batch_size, channels, length).astype(np.float16)
+        weight = np.random.rand(channels, 1, k).astype(np.float16)
+
+        output, present_state = _compute(input_, weight, activation="silu")
+
+        expect(
+            node,
+            inputs=[input_, weight],
+            outputs=[output, present_state],
+            name="test_causal_conv_with_state_silu_fp16",
+            opset_imports=[onnx.helper.make_opsetid("", 27)],
+        )
diff --git a/onnx/backend/test/case/node/ceil.py b/onnx/backend/test/case/node/ceil.py
new file mode 100644
index 0000000..bce69e8
--- /dev/null
+++ b/onnx/backend/test/case/node/ceil.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Ceil(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Ceil",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1.5, 1.2]).astype(np.float32)
+        y = np.ceil(x)  # expected output [-1., 2.]
+        expect(node, inputs=[x], outputs=[y], name="test_ceil_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.ceil(x)
+        expect(node, inputs=[x], outputs=[y], name="test_ceil")
diff --git a/onnx/backend/test/case/node/celu.py b/onnx/backend/test/case/node/celu.py
new file mode 100644
index 0000000..18d91c2
--- /dev/null
+++ b/onnx/backend/test/case/node/celu.py
@@ -0,0 +1,97 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import ml_dtypes
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Celu(Base):
+    @staticmethod
+    def export() -> None:
+        alpha = 2.0
+        node = onnx.helper.make_node(
+            "Celu",
+            inputs=["X"],
+            outputs=["Y"],
+            alpha=alpha,
+        )
+
+        input_data = np.array(
+            [
+                [
+                    [[0.8439683], [0.5665144], [0.05836735]],
+                    [[0.02916367], [0.12964272], [0.5060197]],
+                    [[0.79538304], [0.9411346], [0.9546573]],
+                ],
+                [
+                    [[0.17730942], [0.46192095], [0.26480448]],
+                    [[0.6746842], [0.01665257], [0.62473077]],
+                    [[0.9240844], [0.9722341], [0.11965699]],
+                ],
+                [
+                    [[0.41356155], [0.9129373], [0.59330076]],
+                    [[0.81929934], [0.7862604], [0.11799799]],
+                    [[0.69248444], [0.54119414], [0.07513223]],
+                ],
+            ],
+            dtype=np.float32,
+        )
+
+        # Calculate expected output data
+        positive_input = np.maximum(0, input_data)
+        negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1))
+        expected_output = positive_input + negative_input
+
+        expect(node, inputs=[input_data], outputs=[expected_output], name="test_celu")
+
+    @staticmethod
+    def export_celu_float16() -> None:
+        alpha = 2.0
+        node = onnx.helper.make_node(
+            "Celu",
+            inputs=["X"],
+            outputs=["Y"],
+            alpha=alpha,
+        )
+
+        input_data = np.array([-3.0, -0.5, 0.0, 0.5, 3.0], dtype=np.float16)
+
+        positive_input = np.maximum(0, input_data)
+        negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1))
+        expected_output = (positive_input + negative_input).astype(np.float16)
+
+        expect(
+            node,
+            inputs=[input_data],
+            outputs=[expected_output],
+            name="test_celu_float16",
+        )
+
+    @staticmethod
+    def export_celu_bfloat16() -> None:
+        alpha = 2.0
+        node = onnx.helper.make_node(
+            "Celu",
+            inputs=["X"],
+            outputs=["Y"],
+            alpha=alpha,
+        )
+
+        input_data = np.array([-3.0, -0.5, 0.0, 0.5, 3.0], dtype=ml_dtypes.bfloat16)
+
+        positive_input = np.maximum(0, input_data)
+        negative_input = np.minimum(0, alpha * (np.exp(input_data / alpha) - 1))
+        expected_output = (positive_input + negative_input).astype(ml_dtypes.bfloat16)
+
+        expect(
+            node,
+            inputs=[input_data],
+            outputs=[expected_output],
+            name="test_celu_bfloat16",
+        )
diff --git a/onnx/backend/test/case/node/center_crop_pad.py b/onnx/backend/test/case/node/center_crop_pad.py
new file mode 100644
index 0000000..90e89d7
--- /dev/null
+++ b/onnx/backend/test/case/node/center_crop_pad.py
@@ -0,0 +1,130 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class CenterCropPad(Base):
+    @staticmethod
+    def export_center_crop_pad_crop() -> None:
+        node = onnx.helper.make_node(
+            "CenterCropPad",
+            inputs=["x", "shape"],
+            outputs=["y"],
+        )
+
+        # First dim is even diff, second is uneven
+        x = np.random.randn(20, 10, 3).astype(np.float32)
+        shape = np.array([10, 7, 3], dtype=np.int64)
+        y = x[5:15, 1:8, :]
+
+        expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_crop")
+
+    @staticmethod
+    def export_center_crop_pad_pad() -> None:
+        node = onnx.helper.make_node(
+            "CenterCropPad",
+            inputs=["x", "shape"],
+            outputs=["y"],
+        )
+
+        # First dim is even diff, second is uneven
+        x = np.random.randn(10, 7, 3).astype(np.float32)
+        shape = np.array([20, 10, 3], dtype=np.int64)
+        y = np.zeros([20, 10, 3], dtype=np.float32)
+        y[5:15, 1:8, :] = x
+
+        expect(node, inputs=[x, shape], outputs=[y], name="test_center_crop_pad_pad")
+
+    @staticmethod
+    def export_center_crop_pad_crop_and_pad() -> None:
+        node = onnx.helper.make_node(
+            "CenterCropPad",
+            inputs=["x", "shape"],
+            outputs=["y"],
+        )
+
+        # Cropping on first dim, padding on second, third stays the same
+        x = np.random.randn(20, 8, 3).astype(np.float32)
+        shape = np.array([10, 10, 3], dtype=np.int64)
+        y = np.zeros([10, 10, 3], dtype=np.float32)
+        y[:, 1:9, :] = x[5:15, :, :]
+
+        expect(
+            node,
+            inputs=[x, shape],
+            outputs=[y],
+            name="test_center_crop_pad_crop_and_pad",
+        )
+
+    @staticmethod
+    def export_center_crop_pad_crop_axes_hwc() -> None:
+        node = onnx.helper.make_node(
+            "CenterCropPad",
+            inputs=["x", "shape"],
+            outputs=["y"],
+            axes=[0, 1],
+        )
+
+        # Cropping on first dim, padding on second, third stays the same
+        x = np.random.randn(20, 8, 3).astype(np.float32)
+        shape = np.array([10, 9], dtype=np.int64)
+        y = np.zeros([10, 9, 3], dtype=np.float32)
+        y[:, :8, :] = x[5:15, :, :]
+
+        expect(
+            node,
+            inputs=[x, shape],
+            outputs=[y],
+            name="test_center_crop_pad_crop_axes_hwc",
+        )
+
+    @staticmethod
+    def export_center_crop_pad_crop_negative_axes_hwc() -> None:
+        node = onnx.helper.make_node(
+            "CenterCropPad",
+            inputs=["x", "shape"],
+            outputs=["y"],
+            axes=[-3, -2],
+        )
+
+        # Cropping on first dim, padding on second, third stays the same
+        x = np.random.randn(20, 8, 3).astype(np.float32)
+        shape = np.array([10, 9], dtype=np.int64)
+        y = np.zeros([10, 9, 3], dtype=np.float32)
+        y[:, :8, :] = x[5:15, :, :]
+
+        expect(
+            node,
+            inputs=[x, shape],
+            outputs=[y],
+            name="test_center_crop_pad_crop_negative_axes_hwc",
+        )
+
+    @staticmethod
+    def export_center_crop_pad_crop_axes_chw() -> None:
+        node = onnx.helper.make_node(
+            "CenterCropPad",
+            inputs=["x", "shape"],
+            outputs=["y"],
+            axes=[1, 2],
+        )
+
+        # Cropping on second dim, padding on third, first stays the same
+        x = np.random.randn(3, 20, 8).astype(np.float32)
+        shape = np.array([10, 9], dtype=np.int64)
+        y = np.zeros([3, 10, 9], dtype=np.float32)
+        y[:, :, :8] = x[:, 5:15, :]
+
+        expect(
+            node,
+            inputs=[x, shape],
+            outputs=[y],
+            name="test_center_crop_pad_crop_axes_chw",
+        )
diff --git a/onnx/backend/test/case/node/clip.py b/onnx/backend/test/case/node/clip.py
new file mode 100644
index 0000000..c9b9e6f
--- /dev/null
+++ b/onnx/backend/test/case/node/clip.py
@@ -0,0 +1,144 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Clip(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Clip",
+            inputs=["x", "min", "max"],
+            outputs=["y"],
+        )
+
+        x = np.array([-2, 0, 2]).astype(np.float32)
+        min_val = np.float32(-1)
+        max_val = np.float32(1)
+        y = np.clip(x, min_val, max_val)  # expected output [-1., 0., 1.]
+        expect(
+            node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_example"
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, min_val, max_val)
+        expect(node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip")
+        node = onnx.helper.make_node(
+            "Clip",
+            inputs=["x", "min", "max"],
+            outputs=["y"],
+        )
+
+        min_val = np.float32(-5)
+        max_val = np.float32(5)
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.array([-1, 0, 1]).astype(np.float32)
+        expect(
+            node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_inbounds"
+        )
+
+        x = np.array([-6, 0, 6]).astype(np.float32)
+        y = np.array([-5, 0, 5]).astype(np.float32)
+        expect(
+            node, inputs=[x, min_val, max_val], outputs=[y], name="test_clip_outbounds"
+        )
+
+        x = np.array([-1, 0, 6]).astype(np.float32)
+        y = np.array([-1, 0, 5]).astype(np.float32)
+        expect(
+            node,
+            inputs=[x, min_val, max_val],
+            outputs=[y],
+            name="test_clip_splitbounds",
+        )
+
+        x = np.array([-2, 0, 6]).astype(np.float32)
+        y = np.array([1, 1, 1]).astype(np.float32)
+        min_val = np.float32(2)
+        max_val = np.float32(1)
+        expect(
+            node,
+            inputs=[x, min_val, max_val],
+            outputs=[y],
+            name="test_clip_min_greater_than_max",
+        )
+
+    @staticmethod
+    def export_clip_default() -> None:
+        node = onnx.helper.make_node(
+            "Clip",
+            inputs=["x", "min"],
+            outputs=["y"],
+        )
+        min_val = np.float32(0)
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, min_val, np.inf)
+        expect(node, inputs=[x, min_val], outputs=[y], name="test_clip_default_min")
+
+        no_min = ""  # optional input, not supplied
+        node = onnx.helper.make_node(
+            "Clip",
+            inputs=["x", no_min, "max"],
+            outputs=["y"],
+        )
+        max_val = np.float32(0)
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, -np.inf, max_val)
+        expect(node, inputs=[x, max_val], outputs=[y], name="test_clip_default_max")
+
+        no_max = ""  # optional input, not supplied
+        node = onnx.helper.make_node(
+            "Clip",
+            inputs=["x", no_min, no_max],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.array([-1, 0, 1]).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_clip_default_inbounds")
+
+    @staticmethod
+    def export_clip_default_int8() -> None:
+        node = onnx.helper.make_node(
+            "Clip",
+            inputs=["x", "min"],
+            outputs=["y"],
+        )
+        min_val = np.int8(0)
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.clip(x, min_val, np.iinfo(np.int8).max)
+        expect(
+            node, inputs=[x, min_val], outputs=[y], name="test_clip_default_int8_min"
+        )
+
+        no_min = ""  # optional input, not supplied
+        node = onnx.helper.make_node(
+            "Clip",
+            inputs=["x", no_min, "max"],
+            outputs=["y"],
+        )
+        max_val = np.int8(0)
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.clip(x, np.iinfo(np.int8).min, max_val)
+        expect(
+            node, inputs=[x, max_val], outputs=[y], name="test_clip_default_int8_max"
+        )
+
+        no_max = ""  # optional input, not supplied
+        node = onnx.helper.make_node(
+            "Clip",
+            inputs=["x", no_min, no_max],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.int8)
+        y = np.array([-1, 0, 1]).astype(np.int8)
+        expect(node, inputs=[x], outputs=[y], name="test_clip_default_int8_inbounds")
diff --git a/onnx/backend/test/case/node/col2im.py b/onnx/backend/test/case/node/col2im.py
new file mode 100644
index 0000000..8516985
--- /dev/null
+++ b/onnx/backend/test/case/node/col2im.py
@@ -0,0 +1,349 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Col2Im(Base):
+    """Col2Im operator with N-dimension support
+
+    The tests below can be reproduced in Python using https://github.com/f-dangel/unfoldNd/
+    """
+
+    @staticmethod
+    def export() -> None:
+        input = np.array(
+            [
+                [
+                    [1.0, 6.0, 11.0, 16.0, 21.0],  # (1, 5, 5)
+                    [2.0, 7.0, 12.0, 17.0, 22.0],
+                    [3.0, 8.0, 13.0, 18.0, 23.0],
+                    [4.0, 9.0, 14.0, 19.0, 24.0],
+                    [5.0, 0.0, 15.0, 20.0, 25.0],
+                ]
+            ]
+        ).astype(np.float32)
+
+        image_shape = np.array([5, 5]).astype(np.int64)
+        block_shape = np.array([1, 5]).astype(np.int64)
+        node = onnx.helper.make_node(
+            "Col2Im", ["input", "image_shape", "block_shape"], ["output"]
+        )
+
+        output = np.array(
+            [
+                [
+                    [
+                        [1.0, 2.0, 3.0, 4.0, 5.0],  # (1, 1, 5, 5)
+                        [6.0, 7.0, 8.0, 9.0, 0.0],
+                        [11.0, 12.0, 13.0, 14.0, 15.0],
+                        [16.0, 17.0, 18.0, 19.0, 20.0],
+                        [21.0, 22.0, 23.0, 24.0, 25.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[input, image_shape, block_shape],
+            outputs=[output],
+            name="test_col2im",
+        )
+
+    @staticmethod
+    def export_col2im_strides() -> None:
+        input = np.array(
+            [
+                [
+                    [0.0, 0.0, 0.0, 0.0],  # (1, 9, 4)
+                    [1.0, 1.0, 1.0, 1.0],
+                    [1.0, 1.0, 1.0, 1.0],
+                    [1.0, 1.0, 1.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],
+                    [1.0, 1.0, 1.0, 1.0],
+                    [0.0, 0.0, 0.0, 0.0],
+                ]
+            ]
+        ).astype(np.float32)
+        image_shape = np.array([5, 5]).astype(np.int64)
+        block_shape = np.array([3, 3]).astype(np.int64)
+
+        output = np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 1.0, 1.0, 1.0],  # (1, 1, 5, 5)
+                        [1.0, 0.0, 1.0, 0.0, 0.0],
+                        [0.0, 2.0, 1.0, 2.0, 1.0],
+                        [1.0, 0.0, 1.0, 0.0, 0.0],
+                        [0.0, 1.0, 0.0, 1.0, 0.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Col2Im",
+            ["input", "image_shape", "block_shape"],
+            ["output"],
+            strides=[2, 2],
+        )
+        expect(
+            node,
+            inputs=[input, image_shape, block_shape],
+            outputs=[output],
+            name="test_col2im_strides",
+        )
+
+    @staticmethod
+    def export_col2im_pads() -> None:
+        input = np.array(
+            [
+                [
+                    [
+                        1.0,
+                        6.0,
+                        11.0,
+                        16.0,
+                        21.0,
+                        26,
+                        31,
+                        36,
+                        41,
+                        46,
+                        51,
+                        56,
+                        61,
+                        66,
+                        71,
+                    ],  # (1, 5, 15)
+                    [
+                        2.0,
+                        7.0,
+                        12.0,
+                        17.0,
+                        22.0,
+                        27,
+                        32,
+                        37,
+                        42,
+                        47,
+                        52,
+                        57,
+                        62,
+                        67,
+                        72,
+                    ],
+                    [
+                        3.0,
+                        8.0,
+                        13.0,
+                        18.0,
+                        23.0,
+                        28,
+                        33,
+                        38,
+                        43,
+                        48,
+                        53,
+                        58,
+                        63,
+                        68,
+                        73,
+                    ],
+                    [
+                        4.0,
+                        9.0,
+                        14.0,
+                        19.0,
+                        24.0,
+                        29,
+                        34,
+                        39,
+                        44,
+                        49,
+                        54,
+                        59,
+                        64,
+                        69,
+                        74,
+                    ],
+                    [
+                        5.0,
+                        10.0,
+                        15.0,
+                        20.0,
+                        25.0,
+                        30,
+                        35,
+                        40,
+                        45,
+                        50,
+                        55,
+                        60,
+                        65,
+                        70,
+                        75,
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+        image_shape = np.array([5, 5]).astype(np.int64)
+        block_shape = np.array([1, 5]).astype(np.int64)
+
+        output = np.array(
+            [
+                [
+                    [
+                        [8.0, 21.0, 24.0, 27.0, 24.0],  # (1, 1, 5, 5)
+                        [38.0, 66.0, 69.0, 72.0, 54.0],
+                        [68.0, 111.0, 114.0, 117.0, 84.0],
+                        [98.0, 156.0, 159.0, 162.0, 114.0],
+                        [128.0, 201.0, 204.0, 207.0, 144.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Col2Im",
+            ["input", "image_shape", "block_shape"],
+            ["output"],
+            pads=[0, 1, 0, 1],
+        )
+        expect(
+            node,
+            inputs=[input, image_shape, block_shape],
+            outputs=[output],
+            name="test_col2im_pads",
+        )
+
+    @staticmethod
+    def export_col2im_dilations() -> None:
+        input = np.array(
+            [
+                [
+                    [1.0, 5.0, 9.0, 13.0, 17],  # (1, 4, 5)
+                    [2.0, 6.0, 10.0, 14.0, 18],
+                    [3.0, 7.0, 11.0, 15.0, 19],
+                    [4.0, 8.0, 12.0, 16.0, 20],
+                ]
+            ]
+        ).astype(np.float32)
+        image_shape = np.array([6, 6]).astype(np.int64)
+        block_shape = np.array([2, 2]).astype(np.int64)
+
+        output = np.array(
+            [
+                [
+                    [
+                        [1.0, 0.0, 0.0, 0.0, 0.0, 2.0],  # (1, 1, 6, 6)
+                        [8.0, 0.0, 0.0, 0.0, 0.0, 10.0],
+                        [16.0, 0.0, 0.0, 0.0, 0.0, 18.0],
+                        [24.0, 0.0, 0.0, 0.0, 0.0, 26.0],
+                        [32.0, 0.0, 0.0, 0.0, 0.0, 34.0],
+                        [19.0, 0.0, 0.0, 0.0, 0.0, 20.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Col2Im",
+            ["input", "image_shape", "block_shape"],
+            ["output"],
+            dilations=[1, 5],
+        )
+        expect(
+            node,
+            inputs=[input, image_shape, block_shape],
+            outputs=[output],
+            name="test_col2im_dilations",
+        )
+
+    @staticmethod
+    def export_col2im_5d() -> None:
+        input = np.array(
+            [
+                [
+                    [1, 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56],  # (1, 10, 12)
+                    [2, 7, 12, 17, 22, 27, 32, 37, 42, 47, 52, 57],
+                    [3, 8, 13, 18, 23, 28, 33, 38, 43, 48, 53, 58],
+                    [4, 9, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59],
+                    [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60],
+                    [61, 66, 71, 76, 81, 86, 91, 96, 101, 106, 111, 116],
+                    [62, 67, 72, 77, 82, 87, 92, 97, 102, 107, 112, 117],
+                    [63, 68, 73, 78, 83, 88, 93, 98, 103, 108, 113, 118],
+                    [64, 69, 74, 79, 84, 89, 94, 99, 104, 109, 114, 119],
+                    [65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120],
+                ]
+            ]
+        ).astype(np.float32)
+        image_shape = np.array([3, 4, 5]).astype(np.int64)
+        block_shape = np.array([1, 1, 5]).astype(np.int64)
+
+        output = np.array(
+            [
+                [
+                    [
+                        [
+                            [1, 2, 3, 4, 5],  # (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, 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],
+                        ],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Col2Im", ["input", "image_shape", "block_shape"], ["output"]
+        )
+        expect(
+            node,
+            inputs=[input, image_shape, block_shape],
+            outputs=[output],
+            name="test_col2im_5d",
+        )
diff --git a/onnx/backend/test/case/node/compress.py b/onnx/backend/test/case/node/compress.py
new file mode 100644
index 0000000..aa20c17
--- /dev/null
+++ b/onnx/backend/test/case/node/compress.py
@@ -0,0 +1,99 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Compress(Base):
+    @staticmethod
+    def export_compress_0() -> None:
+        node = onnx.helper.make_node(
+            "Compress",
+            inputs=["input", "condition"],
+            outputs=["output"],
+            axis=0,
+        )
+        input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+        condition = np.array([0, 1, 1])
+        output = np.compress(condition, input, axis=0)
+        # print(output)
+        # [[ 3.  4.]
+        # [ 5.  6.]]
+
+        expect(
+            node,
+            inputs=[input, condition.astype(bool)],
+            outputs=[output],
+            name="test_compress_0",
+        )
+
+    @staticmethod
+    def export_compress_1() -> None:
+        node = onnx.helper.make_node(
+            "Compress",
+            inputs=["input", "condition"],
+            outputs=["output"],
+            axis=1,
+        )
+        input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+        condition = np.array([0, 1])
+        output = np.compress(condition, input, axis=1)
+        # print(output)
+        # [[ 2.]
+        # [ 4.]
+        # [ 6.]]
+
+        expect(
+            node,
+            inputs=[input, condition.astype(bool)],
+            outputs=[output],
+            name="test_compress_1",
+        )
+
+    @staticmethod
+    def export_compress_default_axis() -> None:
+        node = onnx.helper.make_node(
+            "Compress",
+            inputs=["input", "condition"],
+            outputs=["output"],
+        )
+        input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+        condition = np.array([0, 1, 0, 0, 1])
+        output = np.compress(condition, input)
+        # print(output)
+        # [ 2., 5.]
+
+        expect(
+            node,
+            inputs=[input, condition.astype(bool)],
+            outputs=[output],
+            name="test_compress_default_axis",
+        )
+
+    @staticmethod
+    def export_compress_negative_axis() -> None:
+        node = onnx.helper.make_node(
+            "Compress",
+            inputs=["input", "condition"],
+            outputs=["output"],
+            axis=-1,
+        )
+        input = np.array([[1, 2], [3, 4], [5, 6]]).astype(np.float32)
+        condition = np.array([0, 1])
+        output = np.compress(condition, input, axis=-1)
+        # print(output)
+        # [[ 2.]
+        # [ 4.]
+        # [ 6.]]
+        expect(
+            node,
+            inputs=[input, condition.astype(bool)],
+            outputs=[output],
+            name="test_compress_negative_axis",
+        )
diff --git a/onnx/backend/test/case/node/concat.py b/onnx/backend/test/case/node/concat.py
new file mode 100644
index 0000000..25807eb
--- /dev/null
+++ b/onnx/backend/test/case/node/concat.py
@@ -0,0 +1,56 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+class Concat(Base):
+    @staticmethod
+    def export() -> None:
+        test_cases: dict[str, Sequence[Any]] = {
+            "1d": ([1, 2], [3, 4]),
+            "2d": ([[1, 2], [3, 4]], [[5, 6], [7, 8]]),
+            "3d": (
+                [[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
+                [[[9, 10], [11, 12]], [[13, 14], [15, 16]]],
+            ),
+        }
+
+        for test_case, values_ in test_cases.items():
+            values = [np.asarray(v, dtype=np.float32) for v in values_]
+            for i in range(len(values[0].shape)):
+                in_args = ["value" + str(k) for k in range(len(values))]
+                node = onnx.helper.make_node(
+                    "Concat", inputs=list(in_args), outputs=["output"], axis=i
+                )
+                output = np.concatenate(values, i)
+                expect(
+                    node,
+                    inputs=list(values),
+                    outputs=[output],
+                    name="test_concat_" + test_case + "_axis_" + str(i),
+                )
+
+            for i in range(-len(values[0].shape), 0):
+                in_args = ["value" + str(k) for k in range(len(values))]
+                node = onnx.helper.make_node(
+                    "Concat", inputs=list(in_args), outputs=["output"], axis=i
+                )
+                output = np.concatenate(values, i)
+                expect(
+                    node,
+                    inputs=list(values),
+                    outputs=[output],
+                    name="test_concat_" + test_case + "_axis_negative_" + str(abs(i)),
+                )
diff --git a/onnx/backend/test/case/node/constant.py b/onnx/backend/test/case/node/constant.py
new file mode 100644
index 0000000..82a1942
--- /dev/null
+++ b/onnx/backend/test/case/node/constant.py
@@ -0,0 +1,29 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Constant(Base):
+    @staticmethod
+    def export() -> None:
+        values = np.random.randn(5, 5).astype(np.float32)
+        node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["values"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=values.shape,
+                vals=values.flatten().astype(float),
+            ),
+        )
+
+        expect(node, inputs=[], outputs=[values], name="test_constant")
diff --git a/onnx/backend/test/case/node/constantofshape.py b/onnx/backend/test/case/node/constantofshape.py
new file mode 100644
index 0000000..9083842
--- /dev/null
+++ b/onnx/backend/test/case/node/constantofshape.py
@@ -0,0 +1,64 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ConstantOfShape(Base):
+    @staticmethod
+    def export_float_ones() -> None:
+        x = np.array([4, 3, 2]).astype(np.int64)
+        tensor_value = onnx.helper.make_tensor(
+            "value", onnx.TensorProto.FLOAT, [1], [1]
+        )
+        node = onnx.helper.make_node(
+            "ConstantOfShape",
+            inputs=["x"],
+            outputs=["y"],
+            value=tensor_value,
+        )
+
+        y = np.ones(x, dtype=np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_constantofshape_float_ones")
+
+    @staticmethod
+    def export_int32_zeros() -> None:
+        x = np.array([10, 6]).astype(np.int64)
+        tensor_value = onnx.helper.make_tensor(
+            "value", onnx.TensorProto.INT32, [1], [0]
+        )
+        node = onnx.helper.make_node(
+            "ConstantOfShape",
+            inputs=["x"],
+            outputs=["y"],
+            value=tensor_value,
+        )
+        y = np.zeros(x, dtype=np.int32)
+        expect(node, inputs=[x], outputs=[y], name="test_constantofshape_int_zeros")
+
+    @staticmethod
+    def export_int32_shape_zero() -> None:
+        x = np.array(
+            [
+                0,
+            ]
+        ).astype(np.int64)
+        tensor_value = onnx.helper.make_tensor(
+            "value", onnx.TensorProto.INT32, [1], [0]
+        )
+        node = onnx.helper.make_node(
+            "ConstantOfShape",
+            inputs=["x"],
+            outputs=["y"],
+            value=tensor_value,
+        )
+        y = np.zeros(x, dtype=np.int32)
+        expect(
+            node, inputs=[x], outputs=[y], name="test_constantofshape_int_shape_zero"
+        )
diff --git a/onnx/backend/test/case/node/conv.py b/onnx/backend/test/case/node/conv.py
new file mode 100644
index 0000000..0be699e
--- /dev/null
+++ b/onnx/backend/test/case/node/conv.py
@@ -0,0 +1,257 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Conv(Base):
+    @staticmethod
+    def export() -> None:
+        x = np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 5, 5) input tensor
+                        [5.0, 6.0, 7.0, 8.0, 9.0],
+                        [10.0, 11.0, 12.0, 13.0, 14.0],
+                        [15.0, 16.0, 17.0, 18.0, 19.0],
+                        [20.0, 21.0, 22.0, 23.0, 24.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        W = np.array(
+            [
+                [
+                    [
+                        [1.0, 1.0, 1.0],  # (1, 1, 3, 3) tensor for convolution weights
+                        [1.0, 1.0, 1.0],
+                        [1.0, 1.0, 1.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        # Convolution with padding
+        node_with_padding = onnx.helper.make_node(
+            "Conv",
+            inputs=["x", "W"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1
+            pads=[1, 1, 1, 1],
+        )
+        y_with_padding = np.array(
+            [
+                [
+                    [
+                        [12.0, 21.0, 27.0, 33.0, 24.0],  # (1, 1, 5, 5) output tensor
+                        [33.0, 54.0, 63.0, 72.0, 51.0],
+                        [63.0, 99.0, 108.0, 117.0, 81.0],
+                        [93.0, 144.0, 153.0, 162.0, 111.0],
+                        [72.0, 111.0, 117.0, 123.0, 84.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        expect(
+            node_with_padding,
+            inputs=[x, W],
+            outputs=[y_with_padding],
+            name="test_basic_conv_with_padding",
+        )
+
+        # Convolution without padding
+        node_without_padding = onnx.helper.make_node(
+            "Conv",
+            inputs=["x", "W"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            # Default values for other attributes: strides=[1, 1], dilations=[1, 1], groups=1
+            pads=[0, 0, 0, 0],
+        )
+        y_without_padding = np.array(
+            [
+                [
+                    [
+                        [54.0, 63.0, 72.0],  # (1, 1, 3, 3) output tensor
+                        [99.0, 108.0, 117.0],
+                        [144.0, 153.0, 162.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        expect(
+            node_without_padding,
+            inputs=[x, W],
+            outputs=[y_without_padding],
+            name="test_basic_conv_without_padding",
+        )
+
+    @staticmethod
+    def export_conv_with_strides() -> None:
+        x = np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 7, 5) input tensor
+                        [5.0, 6.0, 7.0, 8.0, 9.0],
+                        [10.0, 11.0, 12.0, 13.0, 14.0],
+                        [15.0, 16.0, 17.0, 18.0, 19.0],
+                        [20.0, 21.0, 22.0, 23.0, 24.0],
+                        [25.0, 26.0, 27.0, 28.0, 29.0],
+                        [30.0, 31.0, 32.0, 33.0, 34.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        W = np.array(
+            [
+                [
+                    [
+                        [1.0, 1.0, 1.0],  # (1, 1, 3, 3) tensor for convolution weights
+                        [1.0, 1.0, 1.0],
+                        [1.0, 1.0, 1.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        # Convolution with strides=2 and padding
+        node_with_padding = onnx.helper.make_node(
+            "Conv",
+            inputs=["x", "W"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            pads=[1, 1, 1, 1],
+            strides=[
+                2,
+                2,
+            ],  # Default values for other attributes: dilations=[1, 1], groups=1
+        )
+        y_with_padding = np.array(
+            [
+                [
+                    [
+                        [12.0, 27.0, 24.0],  # (1, 1, 4, 3) output tensor
+                        [63.0, 108.0, 81.0],
+                        [123.0, 198.0, 141.0],
+                        [112.0, 177.0, 124.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        expect(
+            node_with_padding,
+            inputs=[x, W],
+            outputs=[y_with_padding],
+            name="test_conv_with_strides_padding",
+        )
+
+        # Convolution with strides=2 and no padding
+        node_without_padding = onnx.helper.make_node(
+            "Conv",
+            inputs=["x", "W"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            pads=[0, 0, 0, 0],
+            strides=[
+                2,
+                2,
+            ],  # Default values for other attributes: dilations=[1, 1], groups=1
+        )
+        y_without_padding = np.array(
+            [
+                [
+                    [
+                        [54.0, 72.0],  # (1, 1, 3, 2) output tensor
+                        [144.0, 162.0],
+                        [234.0, 252.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        expect(
+            node_without_padding,
+            inputs=[x, W],
+            outputs=[y_without_padding],
+            name="test_conv_with_strides_no_padding",
+        )
+
+        # Convolution with strides=2 and padding only along one dimension (the H dimension in NxCxHxW tensor)
+        node_with_asymmetric_padding = onnx.helper.make_node(
+            "Conv",
+            inputs=["x", "W"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            pads=[1, 0, 1, 0],
+            strides=[
+                2,
+                2,
+            ],  # Default values for other attributes: dilations=[1, 1], groups=1
+        )
+        y_with_asymmetric_padding = np.array(
+            [
+                [
+                    [
+                        [21.0, 33.0],  # (1, 1, 4, 2) output tensor
+                        [99.0, 117.0],
+                        [189.0, 207.0],
+                        [171.0, 183.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        expect(
+            node_with_asymmetric_padding,
+            inputs=[x, W],
+            outputs=[y_with_asymmetric_padding],
+            name="test_conv_with_strides_and_asymmetric_padding",
+        )
+
+    @staticmethod
+    def export_conv_with_autopad_same() -> None:
+        x = np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 5, 5) input tensor
+                        [5.0, 6.0, 7.0, 8.0, 9.0],
+                        [10.0, 11.0, 12.0, 13.0, 14.0],
+                        [15.0, 16.0, 17.0, 18.0, 19.0],
+                        [20.0, 21.0, 22.0, 23.0, 24.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        W = np.array(
+            [
+                [
+                    [
+                        [1.0, 1.0, 1.0],  # (1, 1, 3, 3) tensor for convolution weights
+                        [1.0, 1.0, 1.0],
+                        [1.0, 1.0, 1.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        # Convolution with auto_pad='SAME_LOWER' and strides=2
+        node = onnx.helper.make_node(
+            "Conv",
+            inputs=["x", "W"],
+            outputs=["y"],
+            auto_pad="SAME_LOWER",
+            kernel_shape=[3, 3],
+            strides=[2, 2],
+        )
+        y = np.array(
+            [[[[12.0, 27.0, 24.0], [63.0, 108.0, 81.0], [72.0, 117.0, 84.0]]]]
+        ).astype(np.float32)
+        expect(node, inputs=[x, W], outputs=[y], name="test_conv_with_autopad_same")
diff --git a/onnx/backend/test/case/node/convinteger.py b/onnx/backend/test/case/node/convinteger.py
new file mode 100644
index 0000000..1b000a2
--- /dev/null
+++ b/onnx/backend/test/case/node/convinteger.py
@@ -0,0 +1,103 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ConvInteger(Base):
+    @staticmethod
+    def export_without_padding() -> None:
+        x = (
+            np.array([2, 3, 4, 5, 6, 7, 8, 9, 10])
+            .astype(np.uint8)
+            .reshape((1, 1, 3, 3))
+        )
+        x_zero_point = np.uint8(1)
+        w = np.array([1, 1, 1, 1]).astype(np.uint8).reshape((1, 1, 2, 2))
+
+        y = np.array([12, 16, 24, 28]).astype(np.int32).reshape(1, 1, 2, 2)
+
+        # ConvInteger without padding
+        convinteger_node = onnx.helper.make_node(
+            "ConvInteger", inputs=["x", "w", "x_zero_point"], outputs=["y"]
+        )
+
+        expect(
+            convinteger_node,
+            inputs=[x, w, x_zero_point],
+            outputs=[y],
+            name="test_convinteger_without_padding",
+        )
+
+    @staticmethod
+    def export_with_padding() -> None:
+        x = (
+            np.array([2, 3, 4, 5, 6, 7, 8, 9, 10])
+            .astype(np.uint8)
+            .reshape((1, 1, 3, 3))
+        )
+        x_zero_point = np.uint8(1)
+        w_zero_points = np.array([0, 1], dtype=np.uint8)
+        w = np.array([1, 1, 1, 1, 1, 1, 1, 1]).astype(np.uint8).reshape((2, 1, 2, 2))
+
+        y = (
+            np.array(
+                [
+                    1,
+                    3,
+                    5,
+                    3,
+                    5,
+                    12,
+                    16,
+                    9,
+                    11,
+                    24,
+                    28,
+                    15,
+                    7,
+                    15,
+                    17,
+                    9,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                ]
+            )
+            .astype(np.int32)
+            .reshape((1, 2, 4, 4))
+        )
+
+        # ConvInteger with padding
+        convinteger_node_with_padding = onnx.helper.make_node(
+            "ConvInteger",
+            inputs=["x", "w", "x_zero_point", "w_zero_points"],
+            outputs=["y"],
+            pads=[1, 1, 1, 1],
+        )
+
+        expect(
+            convinteger_node_with_padding,
+            inputs=[x, w, x_zero_point, w_zero_points],
+            outputs=[y],
+            name="test_convinteger_with_padding",
+        )
diff --git a/onnx/backend/test/case/node/convtranspose.py b/onnx/backend/test/case/node/convtranspose.py
new file mode 100644
index 0000000..64a9fdd
--- /dev/null
+++ b/onnx/backend/test/case/node/convtranspose.py
@@ -0,0 +1,532 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ConvTranspose(Base):
+    @staticmethod
+    def export() -> None:
+        x = np.array(
+            [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+        ).astype(np.float32)
+
+        W = np.array(
+            [
+                [
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ]
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"])
+
+        y = np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 3.0, 3.0, 2.0],  # (1, 2, 5, 5)
+                        [3.0, 8.0, 15.0, 12.0, 7.0],
+                        [9.0, 21.0, 36.0, 27.0, 15.0],
+                        [9.0, 20.0, 33.0, 24.0, 13.0],
+                        [6.0, 13.0, 21.0, 15.0, 8.0],
+                    ],
+                    [
+                        [0.0, 1.0, 3.0, 3.0, 2.0],
+                        [3.0, 8.0, 15.0, 12.0, 7.0],
+                        [9.0, 21.0, 36.0, 27.0, 15.0],
+                        [9.0, 20.0, 33.0, 24.0, 13.0],
+                        [6.0, 13.0, 21.0, 15.0, 8.0],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose")
+
+    @staticmethod
+    def export_convtranspose_1d() -> None:
+        x = np.array([[[0.0, 1.0, 2.0]]]).astype(np.float32)  # (1, 1, 3)
+
+        W = np.array([[[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]]).astype(  # (1, 2, 3)
+            np.float32
+        )
+
+        node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"])
+
+        y = np.array(
+            [[[0.0, 1.0, 3.0, 3.0, 2.0], [0.0, 1.0, 3.0, 3.0, 2.0]]]  # (1, 2, 5)
+        ).astype(np.float32)
+
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_1d")
+
+    @staticmethod
+    def export_convtranspose_3d() -> None:
+        x = np.array(
+            [
+                [
+                    [
+                        [
+                            [0.0, 1.0, 2.0, 3.0, 4.0],  # (1, 1, 3, 4, 5)
+                            [5.0, 6.0, 7.0, 8.0, 9.0],
+                            [10.0, 11.0, 12.0, 13.0, 14.0],
+                            [15.0, 16.0, 17.0, 18.0, 19.0],
+                        ],
+                        [
+                            [20.0, 21.0, 22.0, 23.0, 24.0],
+                            [25.0, 26.0, 27.0, 28.0, 29.0],
+                            [30.0, 31.0, 32.0, 33.0, 34.0],
+                            [35.0, 36.0, 37.0, 38.0, 39.0],
+                        ],
+                        [
+                            [40.0, 41.0, 42.0, 43.0, 44.0],
+                            [45.0, 46.0, 47.0, 48.0, 49.0],
+                            [50.0, 51.0, 52.0, 53.0, 54.0],
+                            [55.0, 56.0, 57.0, 58.0, 59.0],
+                        ],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        W = np.array(
+            [
+                [
+                    [
+                        [
+                            [1.0, 1.0, 1.0],  # (1, 2, 3, 3, 3)
+                            [1.0, 1.0, 1.0],
+                            [1.0, 1.0, 1.0],
+                        ],
+                        [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                        [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                    ],
+                    [
+                        [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                        [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                        [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"])
+
+        y = np.array(
+            [
+                [
+                    [
+                        [
+                            [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0],  # (1, 2, 5, 6, 7)
+                            [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0],
+                            [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0],
+                            [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0],
+                            [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0],
+                            [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0],
+                        ],
+                        [
+                            [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0],
+                            [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0],
+                            [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0],
+                            [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0],
+                            [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0],
+                            [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0],
+                        ],
+                        [
+                            [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0],
+                            [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0],
+                            [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0],
+                            [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0],
+                            [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0],
+                            [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0],
+                        ],
+                        [
+                            [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0],
+                            [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0],
+                            [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0],
+                            [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0],
+                            [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0],
+                            [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0],
+                        ],
+                        [
+                            [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0],
+                            [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0],
+                            [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0],
+                            [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0],
+                            [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0],
+                            [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0],
+                        ],
+                    ],
+                    [
+                        [
+                            [0.0, 1.0, 3.0, 6.0, 9.0, 7.0, 4.0],
+                            [5.0, 12.0, 21.0, 27.0, 33.0, 24.0, 13.0],
+                            [15.0, 33.0, 54.0, 63.0, 72.0, 51.0, 27.0],
+                            [30.0, 63.0, 99.0, 108.0, 117.0, 81.0, 42.0],
+                            [25.0, 52.0, 81.0, 87.0, 93.0, 64.0, 33.0],
+                            [15.0, 31.0, 48.0, 51.0, 54.0, 37.0, 19.0],
+                        ],
+                        [
+                            [20.0, 42.0, 66.0, 72.0, 78.0, 54.0, 28.0],
+                            [50.0, 104.0, 162.0, 174.0, 186.0, 128.0, 66.0],
+                            [90.0, 186.0, 288.0, 306.0, 324.0, 222.0, 114.0],
+                            [120.0, 246.0, 378.0, 396.0, 414.0, 282.0, 144.0],
+                            [90.0, 184.0, 282.0, 294.0, 306.0, 208.0, 106.0],
+                            [50.0, 102.0, 156.0, 162.0, 168.0, 114.0, 58.0],
+                        ],
+                        [
+                            [60.0, 123.0, 189.0, 198.0, 207.0, 141.0, 72.0],
+                            [135.0, 276.0, 423.0, 441.0, 459.0, 312.0, 159.0],
+                            [225.0, 459.0, 702.0, 729.0, 756.0, 513.0, 261.0],
+                            [270.0, 549.0, 837.0, 864.0, 891.0, 603.0, 306.0],
+                            [195.0, 396.0, 603.0, 621.0, 639.0, 432.0, 219.0],
+                            [105.0, 213.0, 324.0, 333.0, 342.0, 231.0, 117.0],
+                        ],
+                        [
+                            [60.0, 122.0, 186.0, 192.0, 198.0, 134.0, 68.0],
+                            [130.0, 264.0, 402.0, 414.0, 426.0, 288.0, 146.0],
+                            [210.0, 426.0, 648.0, 666.0, 684.0, 462.0, 234.0],
+                            [240.0, 486.0, 738.0, 756.0, 774.0, 522.0, 264.0],
+                            [170.0, 344.0, 522.0, 534.0, 546.0, 368.0, 186.0],
+                            [90.0, 182.0, 276.0, 282.0, 288.0, 194.0, 98.0],
+                        ],
+                        [
+                            [40.0, 81.0, 123.0, 126.0, 129.0, 87.0, 44.0],
+                            [85.0, 172.0, 261.0, 267.0, 273.0, 184.0, 93.0],
+                            [135.0, 273.0, 414.0, 423.0, 432.0, 291.0, 147.0],
+                            [150.0, 303.0, 459.0, 468.0, 477.0, 321.0, 162.0],
+                            [105.0, 212.0, 321.0, 327.0, 333.0, 224.0, 113.0],
+                            [55.0, 111.0, 168.0, 171.0, 174.0, 117.0, 59.0],
+                        ],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_3d")
+
+    @staticmethod
+    def export_convtranspose_attributes() -> None:
+        x = np.array(
+            [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+        ).astype(np.float32)
+
+        W = np.array(
+            [
+                [
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ]
+            ]
+        ).astype(np.float32)
+
+        y = np.array(
+            [
+                [
+                    [
+                        [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],  # (1, 2, 10, 8)
+                        [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                        [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                        [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                        [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                        [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                        [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                        [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                        [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.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, 1.0, 3.0, 2.0, 2.0, 0.0],
+                        [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                        [0.0, 0.0, 1.0, 1.0, 3.0, 2.0, 2.0, 0.0],
+                        [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                        [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                        [3.0, 3.0, 7.0, 4.0, 9.0, 5.0, 5.0, 0.0],
+                        [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                        [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                        [6.0, 6.0, 13.0, 7.0, 15.0, 8.0, 8.0, 0.0],
+                        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_shape=[10, 8]
+        )
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_output_shape")
+
+        node = onnx.helper.make_node(
+            "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], output_padding=[1, 1]
+        )
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pad")
+
+        node = onnx.helper.make_node(
+            "ConvTranspose",
+            ["X", "W"],
+            ["Y"],
+            name="test",
+            strides=[3, 2],
+            output_shape=[10, 8],
+            kernel_shape=[3, 3],
+            output_padding=[1, 1],
+        )
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_kernel_shape")
+
+    @staticmethod
+    def export_convtranspose_pads() -> None:
+        x = np.array(
+            [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+        ).astype(np.float32)
+
+        W = np.array(
+            [
+                [
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ]
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "ConvTranspose", ["X", "W"], ["Y"], strides=[3, 2], pads=[1, 2, 1, 2]
+        )
+
+        y = np.array(
+            [
+                [
+                    [
+                        [1.0, 1.0, 3.0],  # (1, 2, 7, 3)
+                        [1.0, 1.0, 3.0],
+                        [7.0, 4.0, 9.0],
+                        [7.0, 4.0, 9.0],
+                        [7.0, 4.0, 9.0],
+                        [13.0, 7.0, 15.0],
+                        [13.0, 7.0, 15.0],
+                    ],
+                    [
+                        [1.0, 1.0, 3.0],
+                        [1.0, 1.0, 3.0],
+                        [7.0, 4.0, 9.0],
+                        [7.0, 4.0, 9.0],
+                        [7.0, 4.0, 9.0],
+                        [13.0, 7.0, 15.0],
+                        [13.0, 7.0, 15.0],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_pads")
+
+    @staticmethod
+    def export_convtranspose_dilations() -> None:
+        x = np.array(
+            [[[[3.0, 8.0, 1.0], [9.0, 5.0, 7.0], [3.0, 2.0, 6.0]]]]  # (1, 1, 3, 3)
+        ).astype(np.float32)
+        W = np.array([[[[7.0, 2.0], [1.0, 9.0]]]]).astype(np.float32)  # (1, 1, 2, 2)
+
+        node = onnx.helper.make_node(
+            "ConvTranspose", ["X", "W"], ["Y"], dilations=[2, 2]
+        )
+
+        y = np.array(
+            [
+                [
+                    [
+                        [21.0, 56.0, 13.0, 16.0, 2.0],  # [1, 1, 5, 5]
+                        [63.0, 35.0, 67.0, 10.0, 14.0],
+                        [24.0, 22.0, 76.0, 76.0, 21.0],
+                        [9.0, 5.0, 88.0, 45.0, 63.0],
+                        [3.0, 2.0, 33.0, 18.0, 54.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_dilations")
+
+    @staticmethod
+    def export_convtranspose_autopad_same() -> None:
+        x = np.array(
+            [[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]]]  # (1, 1, 3, 3)
+        ).astype(np.float32)
+
+        W = np.array(
+            [
+                [
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],  # (1, 2, 3, 3)
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ]
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "ConvTranspose", ["X", "W"], ["Y"], auto_pad="SAME_UPPER", strides=[2, 2]
+        )
+
+        y = np.array(
+            [
+                [
+                    [
+                        [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                        [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                        [3.0, 3.0, 8.0, 5.0, 12.0, 7.0],
+                        [3.0, 3.0, 7.0, 4.0, 9.0, 5.0],
+                        [9.0, 9.0, 20.0, 11.0, 24.0, 13.0],
+                        [6.0, 6.0, 13.0, 7.0, 15.0, 8.0],
+                    ],
+                    [
+                        [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                        [0.0, 0.0, 1.0, 1.0, 3.0, 2.0],
+                        [3.0, 3.0, 8.0, 5.0, 12.0, 7.0],
+                        [3.0, 3.0, 7.0, 4.0, 9.0, 5.0],
+                        [9.0, 9.0, 20.0, 11.0, 24.0, 13.0],
+                        [6.0, 6.0, 13.0, 7.0, 15.0, 8.0],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_autopad_same")
+
+    @staticmethod
+    def export_convtranspose_group_2() -> None:
+        x = np.array(
+            [
+                [
+                    [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
+                    [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+                ]
+            ]
+        ).astype(np.float32)
+        W = np.array(
+            [
+                [
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ],
+                [
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ],
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"], group=2)
+
+        y = np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 3.0, 3.0, 2.0],
+                        [3.0, 8.0, 15.0, 12.0, 7.0],
+                        [9.0, 21.0, 36.0, 27.0, 15.0],
+                        [9.0, 20.0, 33.0, 24.0, 13.0],
+                        [6.0, 13.0, 21.0, 15.0, 8.0],
+                    ],
+                    [
+                        [9.0, 19.0, 30.0, 21.0, 11.0],
+                        [21.0, 44.0, 69.0, 48.0, 25.0],
+                        [36.0, 75.0, 117.0, 81.0, 42.0],
+                        [27.0, 56.0, 87.0, 60.0, 31.0],
+                        [15.0, 31.0, 48.0, 33.0, 17.0],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(node, inputs=[x, W], outputs=[y], name="test_convtranspose_group_2")
+
+    @staticmethod
+    def export_convtranspose_group_2_image_3() -> None:
+        x = np.array(
+            [
+                [
+                    [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
+                    [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+                ],
+                [
+                    [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0], [24.0, 25.0, 26.0]],
+                    [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+                ],
+                [
+                    [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
+                    [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0], [15.0, 16.0, 17.0]],
+                ],
+            ]
+        ).astype(np.float32)
+        W = np.array(
+            [
+                [
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ],
+                [
+                    [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]],
+                ],
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node("ConvTranspose", ["X", "W"], ["Y"], group=2)
+
+        y = np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 3.0, 3.0, 2.0],
+                        [3.0, 8.0, 15.0, 12.0, 7.0],
+                        [9.0, 21.0, 36.0, 27.0, 15.0],
+                        [9.0, 20.0, 33.0, 24.0, 13.0],
+                        [6.0, 13.0, 21.0, 15.0, 8.0],
+                    ],
+                    [
+                        [9.0, 19.0, 30.0, 21.0, 11.0],
+                        [21.0, 44.0, 69.0, 48.0, 25.0],
+                        [36.0, 75.0, 117.0, 81.0, 42.0],
+                        [27.0, 56.0, 87.0, 60.0, 31.0],
+                        [15.0, 31.0, 48.0, 33.0, 17.0],
+                    ],
+                ],
+                [
+                    [
+                        [18.0, 37.0, 57.0, 39.0, 20.0],
+                        [39.0, 80.0, 123.0, 84.0, 43.0],
+                        [63.0, 129.0, 198.0, 135.0, 69.0],
+                        [45.0, 92.0, 141.0, 96.0, 49.0],
+                        [24.0, 49.0, 75.0, 51.0, 26.0],
+                    ],
+                    [
+                        [9.0, 19.0, 30.0, 21.0, 11.0],
+                        [21.0, 44.0, 69.0, 48.0, 25.0],
+                        [36.0, 75.0, 117.0, 81.0, 42.0],
+                        [27.0, 56.0, 87.0, 60.0, 31.0],
+                        [15.0, 31.0, 48.0, 33.0, 17.0],
+                    ],
+                ],
+                [
+                    [
+                        [0.0, 1.0, 3.0, 3.0, 2.0],
+                        [3.0, 8.0, 15.0, 12.0, 7.0],
+                        [9.0, 21.0, 36.0, 27.0, 15.0],
+                        [9.0, 20.0, 33.0, 24.0, 13.0],
+                        [6.0, 13.0, 21.0, 15.0, 8.0],
+                    ],
+                    [
+                        [9.0, 19.0, 30.0, 21.0, 11.0],
+                        [21.0, 44.0, 69.0, 48.0, 25.0],
+                        [36.0, 75.0, 117.0, 81.0, 42.0],
+                        [27.0, 56.0, 87.0, 60.0, 31.0],
+                        [15.0, 31.0, 48.0, 33.0, 17.0],
+                    ],
+                ],
+            ]
+        ).astype(np.float32)
+
+        expect(
+            node, inputs=[x, W], outputs=[y], name="test_convtranspose_group_2_image_3"
+        )
diff --git a/onnx/backend/test/case/node/cos.py b/onnx/backend/test/case/node/cos.py
new file mode 100644
index 0000000..ce52093
--- /dev/null
+++ b/onnx/backend/test/case/node/cos.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Cos(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Cos",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.cos(x)
+        expect(node, inputs=[x], outputs=[y], name="test_cos_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.cos(x)
+        expect(node, inputs=[x], outputs=[y], name="test_cos")
diff --git a/onnx/backend/test/case/node/cosh.py b/onnx/backend/test/case/node/cosh.py
new file mode 100644
index 0000000..2c3bf23
--- /dev/null
+++ b/onnx/backend/test/case/node/cosh.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Cosh(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Cosh",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.cosh(x)  # expected output [1.54308069,  1.,  1.54308069]
+        expect(node, inputs=[x], outputs=[y], name="test_cosh_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.cosh(x)
+        expect(node, inputs=[x], outputs=[y], name="test_cosh")
diff --git a/onnx/backend/test/case/node/cumprod.py b/onnx/backend/test/case/node/cumprod.py
new file mode 100644
index 0000000..3b75ded
--- /dev/null
+++ b/onnx/backend/test/case/node/cumprod.py
@@ -0,0 +1,129 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class CumProd(Base):
+    @staticmethod
+    def export_cumprod_1d() -> None:
+        node = onnx.helper.make_node("CumProd", inputs=["x", "axis"], outputs=["y"])
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+        axis = np.array(0, dtype=np.int32)
+        y = np.array([1.0, 2.0, 6.0, 24.0, 120.0]).astype(np.float64)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d")
+
+    @staticmethod
+    def export_cumprod_1d_exclusive() -> None:
+        node = onnx.helper.make_node(
+            "CumProd", inputs=["x", "axis"], outputs=["y"], exclusive=1
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+        axis = np.array(0, dtype=np.int32)
+        y = np.array([1.0, 1.0, 2.0, 6.0, 24.0]).astype(np.float64)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_exclusive")
+
+    @staticmethod
+    def export_cumprod_1d_reverse() -> None:
+        node = onnx.helper.make_node(
+            "CumProd", inputs=["x", "axis"], outputs=["y"], reverse=1
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+        axis = np.array(0, dtype=np.int32)
+        y = np.array([120.0, 120.0, 60.0, 20.0, 5.0]).astype(np.float64)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_reverse")
+
+    @staticmethod
+    def export_cumprod_1d_reverse_exclusive() -> None:
+        node = onnx.helper.make_node(
+            "CumProd", inputs=["x", "axis"], outputs=["y"], reverse=1, exclusive=1
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+        axis = np.array(0, dtype=np.int32)
+        y = np.array([120.0, 60.0, 20.0, 5.0, 1.0]).astype(np.float64)
+        expect(
+            node,
+            inputs=[x, axis],
+            outputs=[y],
+            name="test_cumprod_1d_reverse_exclusive",
+        )
+
+    @staticmethod
+    def export_cumprod_2d_axis_0() -> None:
+        node = onnx.helper.make_node(
+            "CumProd",
+            inputs=["x", "axis"],
+            outputs=["y"],
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+        axis = np.array(0, dtype=np.int32)
+        y = (
+            np.array([1.0, 2.0, 3.0, 4.0, 10.0, 18.0])
+            .astype(np.float64)
+            .reshape((2, 3))
+        )
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_axis_0")
+
+    @staticmethod
+    def export_cumprod_2d_axis_1() -> None:
+        node = onnx.helper.make_node(
+            "CumProd",
+            inputs=["x", "axis"],
+            outputs=["y"],
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+        axis = np.array(1, dtype=np.int32)
+        y = (
+            np.array([1.0, 2.0, 6.0, 4.0, 20.0, 120.0])
+            .astype(np.float64)
+            .reshape((2, 3))
+        )
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_axis_1")
+
+    @staticmethod
+    def export_cumprod_2d_negative_axis() -> None:
+        node = onnx.helper.make_node(
+            "CumProd",
+            inputs=["x", "axis"],
+            outputs=["y"],
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+        axis = np.array(-1, dtype=np.int32)
+        y = (
+            np.array([1.0, 2.0, 6.0, 4.0, 20.0, 120.0])
+            .astype(np.float64)
+            .reshape((2, 3))
+        )
+        expect(
+            node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_negative_axis"
+        )
+
+    @staticmethod
+    def export_cumprod_2d_int32() -> None:
+        node = onnx.helper.make_node(
+            "CumProd",
+            inputs=["x", "axis"],
+            outputs=["y"],
+        )
+        x = np.array([1, 2, 3, 4, 5, 6]).astype(np.int32).reshape((2, 3))
+        axis = np.array(0, dtype=np.int32)
+        y = np.array([1, 2, 3, 4, 10, 18]).astype(np.int32).reshape((2, 3))
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumprod_2d_int32")
+
+    @staticmethod
+    def export_cumprod_1d_int32_exclusive() -> None:
+        node = onnx.helper.make_node(
+            "CumProd", inputs=["x", "axis"], outputs=["y"], exclusive=1
+        )
+        x = np.array([1, 2, 3, 4, 5]).astype(np.int32)
+        axis = np.array(0, dtype=np.int32)
+        y = np.array([1, 1, 2, 6, 24]).astype(np.int32)
+        expect(
+            node, inputs=[x, axis], outputs=[y], name="test_cumprod_1d_int32_exclusive"
+        )
diff --git a/onnx/backend/test/case/node/cumsum.py b/onnx/backend/test/case/node/cumsum.py
new file mode 100644
index 0000000..81a35f2
--- /dev/null
+++ b/onnx/backend/test/case/node/cumsum.py
@@ -0,0 +1,112 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class CumSum(Base):
+    @staticmethod
+    def export_cumsum_1d() -> None:
+        node = onnx.helper.make_node("CumSum", inputs=["x", "axis"], outputs=["y"])
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+        axis = np.int32(0)
+        y = np.array([1.0, 3.0, 6.0, 10.0, 15.0]).astype(np.float64)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d")
+
+    @staticmethod
+    def export_cumsum_1d_exclusive() -> None:
+        node = onnx.helper.make_node(
+            "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+        axis = np.int32(0)
+        y = np.array([0.0, 1.0, 3.0, 6.0, 10.0]).astype(np.float64)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_exclusive")
+
+    @staticmethod
+    def export_cumsum_1d_reverse() -> None:
+        node = onnx.helper.make_node(
+            "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+        axis = np.int32(0)
+        y = np.array([15.0, 14.0, 12.0, 9.0, 5.0]).astype(np.float64)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse")
+
+    @staticmethod
+    def export_cumsum_1d_reverse_exclusive() -> None:
+        node = onnx.helper.make_node(
+            "CumSum", inputs=["x", "axis"], outputs=["y"], reverse=1, exclusive=1
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0]).astype(np.float64)
+        axis = np.int32(0)
+        y = np.array([14.0, 12.0, 9.0, 5.0, 0.0]).astype(np.float64)
+        expect(
+            node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_reverse_exclusive"
+        )
+
+    @staticmethod
+    def export_cumsum_2d_axis_0() -> None:
+        node = onnx.helper.make_node(
+            "CumSum",
+            inputs=["x", "axis"],
+            outputs=["y"],
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+        axis = np.int32(0)
+        y = np.array([1.0, 2.0, 3.0, 5.0, 7.0, 9.0]).astype(np.float64).reshape((2, 3))
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_0")
+
+    @staticmethod
+    def export_cumsum_2d_axis_1() -> None:
+        node = onnx.helper.make_node(
+            "CumSum",
+            inputs=["x", "axis"],
+            outputs=["y"],
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+        axis = np.int32(1)
+        y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3))
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_axis_1")
+
+    @staticmethod
+    def export_cumsum_2d_negative_axis() -> None:
+        node = onnx.helper.make_node(
+            "CumSum",
+            inputs=["x", "axis"],
+            outputs=["y"],
+        )
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float64).reshape((2, 3))
+        axis = np.int32(-1)
+        y = np.array([1.0, 3.0, 6.0, 4.0, 9.0, 15.0]).astype(np.float64).reshape((2, 3))
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_negative_axis")
+
+    @staticmethod
+    def export_cumsum_2d_int32() -> None:
+        node = onnx.helper.make_node(
+            "CumSum",
+            inputs=["x", "axis"],
+            outputs=["y"],
+        )
+        x = np.array([1, 2, 3, 4, 5, 6]).astype(np.int32).reshape((2, 3))
+        axis = np.int32(0)
+        y = np.array([1, 2, 3, 5, 7, 9]).astype(np.int32).reshape((2, 3))
+        expect(node, inputs=[x, axis], outputs=[y], name="test_cumsum_2d_int32")
+
+    @staticmethod
+    def export_cumsum_1d_int32_exclusive() -> None:
+        node = onnx.helper.make_node(
+            "CumSum", inputs=["x", "axis"], outputs=["y"], exclusive=1
+        )
+        x = np.array([1, 2, 3, 4, 5]).astype(np.int32)
+        axis = np.int32(0)
+        y = np.array([0, 1, 3, 6, 10]).astype(np.int32)
+        expect(
+            node, inputs=[x, axis], outputs=[y], name="test_cumsum_1d_int32_exclusive"
+        )
diff --git a/onnx/backend/test/case/node/deformconv.py b/onnx/backend/test/case/node/deformconv.py
new file mode 100644
index 0000000..85c53f4
--- /dev/null
+++ b/onnx/backend/test/case/node/deformconv.py
@@ -0,0 +1,161 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class DeformConv(Base):
+    @staticmethod
+    def export() -> None:
+        X = np.arange(9).astype(np.float32)
+        X.shape = (1, 1, 3, 3)
+        W = np.ones((1, 1, 2, 2), dtype=np.float32)
+
+        # Convolution with padding
+        offset_with_padding = np.zeros((1, 8, 4, 4), dtype=np.float32)
+        # h-coord of [0, 0] element of kernel, at output position [0, 0]
+        offset_with_padding[0, 0, 0, 0] = 0.5
+        # w-coord of [1, 0] element of kernel, at output position [1, 2]
+        offset_with_padding[0, 5, 1, 2] = -0.1
+
+        node_with_padding = onnx.helper.make_node(
+            "DeformConv",
+            inputs=["X", "W", "offset_with_padding"],
+            outputs=["Y_with_padding"],
+            kernel_shape=[2, 2],
+            pads=[1, 1, 1, 1],
+        )
+        Y_with_padding = np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 3.0, 2.0],  # (1, 1, 4, 4) output tensor
+                        [3.0, 8.0, 11.9, 7.0],
+                        [9.0, 20.0, 24.0, 13.0],
+                        [6.0, 13.0, 15.0, 8.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        expect(
+            node_with_padding,
+            inputs=[X, W, offset_with_padding],
+            outputs=[Y_with_padding],
+            name="test_basic_deform_conv_with_padding",
+        )
+
+        # Convolution without padding
+        offset_without_padding = np.zeros((1, 8, 2, 2), dtype=np.float32)
+        # h-coord of [0, 0] element of kernel, at output position [0, 0]
+        offset_without_padding[0, 0, 0, 0] = 0.5
+        # w-coord of [1, 0] element of kernel, at output position [0, 1]
+        offset_without_padding[0, 5, 0, 1] = -0.1
+
+        node_without_padding = onnx.helper.make_node(
+            "DeformConv",
+            inputs=["X", "W", "offset_without_padding"],
+            outputs=["Y_without_padding"],
+            kernel_shape=[2, 2],
+            pads=[0, 0, 0, 0],
+        )
+        Y_without_padding = np.array(
+            [
+                [
+                    [
+                        [9.5, 11.9],  # (1, 1, 2, 2) output tensor
+                        [20.0, 24.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        expect(
+            node_without_padding,
+            inputs=[X, W, offset_without_padding],
+            outputs=[Y_without_padding],
+            name="test_basic_deform_conv_without_padding",
+        )
+
+    @staticmethod
+    def export_deformconv_with_mask_bias() -> None:
+        X = np.arange(9).astype(np.float32)
+        X.shape = (1, 1, 3, 3)
+        W = np.ones((1, 1, 2, 2), dtype=np.float32)
+        B = np.ones((1,), dtype=np.float32)
+
+        offset = np.zeros((1, 8, 2, 2), dtype=np.float32)
+        # h-coord of [0, 0] element of kernel, at output position [0, 0]
+        offset[0, 0, 0, 0] = 0.5
+        # w-coord of [1, 0] element of kernel, at output position [0, 1]
+        offset[0, 5, 0, 1] = -0.1
+
+        mask = np.ones((1, 4, 2, 2), dtype=np.float32)
+        mask[0, 2, 1, 1] = 0.2  # [1, 0] element of kernel at output position [1, 1]
+
+        node = onnx.helper.make_node(
+            "DeformConv",
+            inputs=["X", "W", "offset", "B", "mask"],
+            outputs=["Y"],
+            kernel_shape=[2, 2],
+            pads=[0, 0, 0, 0],
+        )
+        Y = np.array(
+            [
+                [
+                    [
+                        [10.5, 12.9],  # (1, 1, 2, 2) output tensor
+                        [21.0, 19.4],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        expect(
+            node,
+            inputs=[X, W, offset, B, mask],
+            outputs=[Y],
+            name="test_deform_conv_with_mask_bias",
+        )
+
+    @staticmethod
+    def export_deformconv_with_multiple_offset_groups() -> None:
+        X = np.zeros((1, 2, 3, 3), dtype=np.float32)
+        X[0, 0] = np.reshape(np.arange(9).astype(np.float32), (3, 3))
+        X[0, 1] = np.reshape(np.arange(8, -1, -1).astype(np.float32), (3, 3))
+        X.shape = (1, 2, 3, 3)
+        W = np.ones((1, 2, 2, 2), dtype=np.float32)
+
+        offset = np.zeros((1, 16, 2, 2), dtype=np.float32)
+        # h-coord of [0, 0] element of kernel in channel 0, at output position [0, 0]
+        offset[0, 0, 0, 0] = 0.5
+        # w-coord of [1, 0] element of kernel in channel 1, at output position [0, 1]
+        offset[0, 13, 0, 1] = -0.1
+
+        node = onnx.helper.make_node(
+            "DeformConv",
+            inputs=["X", "W", "offset"],
+            outputs=["Y"],
+            kernel_shape=[2, 2],
+            pads=[0, 0, 0, 0],
+            offset_group=2,
+        )
+        Y = np.array(
+            [
+                [
+                    [
+                        [33.5, 32.1],  # (1, 1, 2, 2) output tensor
+                        [32.0, 32.0],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        expect(
+            node,
+            inputs=[X, W, offset],
+            outputs=[Y],
+            name="test_deform_conv_with_multiple_offset_groups",
+        )
diff --git a/onnx/backend/test/case/node/depthtospace.py b/onnx/backend/test/case/node/depthtospace.py
new file mode 100755
index 0000000..0049f9e
--- /dev/null
+++ b/onnx/backend/test/case/node/depthtospace.py
@@ -0,0 +1,98 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class DepthToSpace(Base):
+    @staticmethod
+    def export_default_mode_example() -> None:
+        node = onnx.helper.make_node(
+            "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="DCR"
+        )
+
+        # (1, 8, 2, 3) input tensor
+        x = np.array(
+            [
+                [
+                    [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
+                    [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]],
+                    [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]],
+                    [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]],
+                    [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]],
+                    [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]],
+                    [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]],
+                    [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]],
+                ]
+            ]
+        ).astype(np.float32)
+
+        # (1, 2, 4, 6) output tensor
+        y = np.array(
+            [
+                [
+                    [
+                        [0.0, 18.0, 1.0, 19.0, 2.0, 20.0],
+                        [36.0, 54.0, 37.0, 55.0, 38.0, 56.0],
+                        [3.0, 21.0, 4.0, 22.0, 5.0, 23.0],
+                        [39.0, 57.0, 40.0, 58.0, 41.0, 59.0],
+                    ],
+                    [
+                        [9.0, 27.0, 10.0, 28.0, 11.0, 29.0],
+                        [45.0, 63.0, 46.0, 64.0, 47.0, 65.0],
+                        [12.0, 30.0, 13.0, 31.0, 14.0, 32.0],
+                        [48.0, 66.0, 49.0, 67.0, 50.0, 68.0],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_depthtospace_example")
+
+    @staticmethod
+    def export_crd_mode_example() -> None:
+        node = onnx.helper.make_node(
+            "DepthToSpace", inputs=["x"], outputs=["y"], blocksize=2, mode="CRD"
+        )
+
+        # (1, 8, 2, 3) input tensor
+        x = np.array(
+            [
+                [
+                    [[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]],
+                    [[9.0, 10.0, 11.0], [12.0, 13.0, 14.0]],
+                    [[18.0, 19.0, 20.0], [21.0, 22.0, 23.0]],
+                    [[27.0, 28.0, 29.0], [30.0, 31.0, 32.0]],
+                    [[36.0, 37.0, 38.0], [39.0, 40.0, 41.0]],
+                    [[45.0, 46.0, 47.0], [48.0, 49.0, 50.0]],
+                    [[54.0, 55.0, 56.0], [57.0, 58.0, 59.0]],
+                    [[63.0, 64.0, 65.0], [66.0, 67.0, 68.0]],
+                ]
+            ]
+        ).astype(np.float32)
+
+        # (1, 2, 4, 6) output tensor
+        y = np.array(
+            [
+                [
+                    [
+                        [0.0, 9.0, 1.0, 10.0, 2.0, 11.0],
+                        [18.0, 27.0, 19.0, 28.0, 20.0, 29.0],
+                        [3.0, 12.0, 4.0, 13.0, 5.0, 14.0],
+                        [21.0, 30.0, 22.0, 31.0, 23.0, 32.0],
+                    ],
+                    [
+                        [36.0, 45.0, 37.0, 46.0, 38.0, 47.0],
+                        [54.0, 63.0, 55.0, 64.0, 56.0, 65.0],
+                        [39.0, 48.0, 40.0, 49.0, 41.0, 50.0],
+                        [57.0, 66.0, 58.0, 67.0, 59.0, 68.0],
+                    ],
+                ]
+            ]
+        ).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_depthtospace_crd_mode_example")
diff --git a/onnx/backend/test/case/node/dequantizelinear.py b/onnx/backend/test/case/node/dequantizelinear.py
new file mode 100644
index 0000000..d1b8b55
--- /dev/null
+++ b/onnx/backend/test/case/node/dequantizelinear.py
@@ -0,0 +1,373 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx import TensorProto
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.helper import make_tensor
+
+
+class DequantizeLinear(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+        )
+
+        # scalar zero point and scale
+        x = np.array([0, 3, 128, 255]).astype(np.uint8)
+        x_scale = np.float32(2)
+        x_zero_point = np.uint8(128)
+        y = np.array([-256, -250, 0, 254], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear",
+        )
+
+    @staticmethod
+    def export_axis() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+        )
+
+        # 1-D tensor zero point and scale of size equal to axis 1 of the input tensor
+        x = np.array(
+            [
+                [
+                    [[3, 89], [34, 200], [74, 59]],
+                    [[5, 24], [24, 87], [32, 13]],
+                    [[245, 99], [4, 142], [121, 102]],
+                ],
+            ],
+            dtype=np.uint8,
+        )
+        x_scale = np.array([2, 4, 5], dtype=np.float32)
+        x_zero_point = np.array([84, 24, 196], dtype=np.uint8)
+        y = (
+            x.astype(np.float32) - x_zero_point.reshape(1, 3, 1, 1).astype(np.float32)
+        ) * x_scale.reshape(1, 3, 1, 1)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_axis",
+        )
+
+    @staticmethod
+    def export_e4m3fn() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104])
+        x_scale = np.float32(2)
+        y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale],
+            outputs=[y],
+            name="test_dequantizelinear_e4m3fn",
+        )
+
+    @staticmethod
+    def export_e4m3fn_float16() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104])
+        x_scale = np.float16(2)
+        y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float16)
+
+        expect(
+            node,
+            inputs=[x, x_scale],
+            outputs=[y],
+            name="test_dequantizelinear_e4m3fn_float16",
+        )
+
+    @staticmethod
+    def export_e4m3fn_zero_point() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, -104])
+        zero_point = make_tensor("zero_point", TensorProto.FLOAT8E4M3FN, [1], [0])
+        x_scale = np.float32(2)
+        y = np.array([0.0, 1.0, 2.0, 896.0, -208.0], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_e4m3fn_zero_point",
+        )
+
+    @staticmethod
+    def export_e5m2() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, -96])
+        x_scale = np.float32(2)
+        y = np.array([0.0, 1.0, 2.0, 98304.0, -192.0], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale],
+            outputs=[y],
+            name="test_dequantizelinear_e5m2",
+        )
+
+    @staticmethod
+    def export_uint16() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array([30000, 31000, 32768, 33000]).astype(np.uint16)
+        x_scale = np.float32(2)
+        x_zero_point = np.uint16(32767)
+        y = np.array([-5534.0, -3534.0, 2.0, 466.0], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_uint16",
+        )
+
+    @staticmethod
+    def export_int16() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array([-300, -30, -1025, 1270]).astype(np.int16)
+        x_scale = np.float32(2)
+        x_zero_point = np.int16(-1024)
+        y = np.array([1448.0, 1988.0, -2.0, 4588.0], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_int16",
+        )
+
+    @staticmethod
+    def export_uint4() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.UINT4, [5], [0, 1, 7, 10, 15])
+        x_scale = np.float32(2)
+        x_zero_point = make_tensor("x_zero_point", TensorProto.UINT4, (1,), [1])
+        y = np.array([-2, 0, 12, 18, 28], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_uint4",
+        )
+
+    @staticmethod
+    def export_int4() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.INT4, [5], [0, 1, 7, -4, -8])
+        x_scale = np.float32(2)
+        x_zero_point = make_tensor("x_zero_point", TensorProto.INT4, (1,), [1])
+        y = np.array([-2, 0, 12, -10, -18], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_int4",
+        )
+
+    @staticmethod
+    def export_uint2() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.UINT2, [4], [0, 1, 2, 3])
+        x_scale = np.float32(2)
+        x_zero_point = make_tensor("x_zero_point", TensorProto.UINT2, (1,), [1])
+        y = np.array([-2, 0, 2, 4], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_uint2",
+        )
+
+    @staticmethod
+    def export_int2() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.INT2, [4], [0, 1, -1, -2])
+        x_scale = np.float32(2)
+        x_zero_point = make_tensor("x_zero_point", TensorProto.INT2, (1,), [1])
+        y = np.array([-2, 0, -4, -6], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_int2",
+        )
+
+    @staticmethod
+    def export_float4e2m1() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        # scalar zero point and scale
+        x = make_tensor("x", TensorProto.FLOAT4E2M1, [5], [0, 1, -1, 1.5, -4])
+        x_scale = np.float32(2)
+        x_zero_point = make_tensor("x_zero_point", TensorProto.FLOAT4E2M1, (1,), [0])
+        y = np.array([0, 2, -2, 3, -8], dtype=np.float32)
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_float4e2m1",
+        )
+
+    @staticmethod
+    def export_blocked() -> None:
+        node = onnx.helper.make_node(
+            "DequantizeLinear",
+            inputs=["x", "x_scale", "x_zero_point"],
+            outputs=["y"],
+            axis=1,
+            block_size=2,
+        )
+
+        x = np.array(
+            [
+                [
+                    [[3, 89], [34, 200], [74, 59]],
+                    [[5, 24], [24, 87], [32, 13]],
+                    [[5, 12], [12, 33], [65, 42]],
+                    [[245, 99], [4, 142], [121, 102]],
+                ],
+            ],
+            dtype=np.uint8,
+        )
+
+        x_scale = np.array(
+            [
+                [
+                    [[3.0, 2.0], [4.0, 1.0], [2.0, 2.0]],
+                    [[5.0, 2.0], [4.0, 3.0], [5.0, 2.0]],
+                ],
+            ],
+            dtype=np.float32,
+        )
+        x_zero_point = np.array(
+            [
+                [
+                    [[1, 0], [0, 1], [2, 20]],
+                    [[3, 2], [4, 3], [15, 2]],
+                ],
+            ],
+            dtype=np.uint8,
+        )
+
+        # x.shape = (1, 4, 3, 2)
+        # x_scale.shape = (1, 2, 3, 2)
+        assert x_scale.shape == x_zero_point.shape
+        block_axis = 1
+        # The block shape is [x.shape[i] // x_scale.shape[i] for i in range(len(x.shape))] = (1, 2, 1, 1)
+        assert all(
+            x.shape[i] == x_scale.shape[i]
+            for i in range(len(x.shape))
+            if i != block_axis
+        )
+        assert x.shape[block_axis] % x_scale.shape[block_axis] == 0
+        repeats = x.shape[block_axis] // x_scale.shape[block_axis]
+
+        # Create element-wise scale and zero point
+        x_scale_elementwise = np.repeat(x_scale, repeats=repeats, axis=block_axis)
+        x_zero_point_elementwise = np.repeat(
+            x_zero_point, repeats=repeats, axis=block_axis
+        )
+
+        y = (
+            x.astype(np.float32) - x_zero_point_elementwise.astype(np.float32)
+        ) * x_scale_elementwise
+
+        expect(
+            node,
+            inputs=[x, x_scale, x_zero_point],
+            outputs=[y],
+            name="test_dequantizelinear_blocked",
+        )
diff --git a/onnx/backend/test/case/node/det.py b/onnx/backend/test/case/node/det.py
new file mode 100644
index 0000000..0815b95
--- /dev/null
+++ b/onnx/backend/test/case/node/det.py
@@ -0,0 +1,38 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Det(Base):
+    @staticmethod
+    def export_2d() -> None:
+        node = onnx.helper.make_node(
+            "Det",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.arange(4).reshape(2, 2).astype(np.float32)
+        y = np.linalg.det(x)  # expect -2
+        expect(node, inputs=[x], outputs=[y], name="test_det_2d")
+
+    @staticmethod
+    def export_nd() -> None:
+        node = onnx.helper.make_node(
+            "Det",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([[[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]]]).astype(
+            np.float32
+        )
+        y = np.linalg.det(x)  # expect array([-2., -3., -8.])
+        expect(node, inputs=[x], outputs=[y], name="test_det_nd")
diff --git a/onnx/backend/test/case/node/dft.py b/onnx/backend/test/case/node/dft.py
new file mode 100644
index 0000000..713cc8b
--- /dev/null
+++ b/onnx/backend/test/case/node/dft.py
@@ -0,0 +1,152 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class DFT(Base):
+    @staticmethod
+    def export_opset19() -> None:
+        node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=1)
+        x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+        y = np.fft.fft(x, axis=0)
+
+        x = x.reshape(1, 10, 10, 1)
+        y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_dft_opset19",
+            opset_imports=[onnx.helper.make_opsetid("", 19)],
+        )
+
+        node = onnx.helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=2)
+        x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+        y = np.fft.fft(x, axis=1)
+
+        x = x.reshape(1, 10, 10, 1)
+        y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_dft_axis_opset19",
+            opset_imports=[onnx.helper.make_opsetid("", 19)],
+        )
+
+        node = onnx.helper.make_node(
+            "DFT", inputs=["x"], outputs=["y"], inverse=1, axis=1
+        )
+        x = np.arange(0, 100, dtype=np.complex64).reshape(
+            10,
+            10,
+        )
+        y = np.fft.ifft(x, axis=0)
+
+        x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+        y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_dft_inverse_opset19",
+            opset_imports=[onnx.helper.make_opsetid("", 19)],
+        )
+
+        # Test RFFT (Real FFT): real input -> one-sided complex output
+        node = onnx.helper.make_node(
+            "DFT", inputs=["x"], outputs=["y"], onesided=1, axis=1
+        )
+        x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+        y = np.fft.rfft(x, axis=0)
+
+        x = x.reshape(1, 10, 10, 1)
+        y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_dft_rfft_opset19",
+            opset_imports=[onnx.helper.make_opsetid("", 19)],
+        )
+
+        # Test IRFFT (Inverse Real FFT): one-sided complex input -> real output
+        node = onnx.helper.make_node(
+            "DFT", inputs=["x"], outputs=["y"], onesided=1, inverse=1, axis=1
+        )
+        # Create one-sided complex input (6 bins for signal length 10)
+        x = np.fft.rfft(np.arange(0, 100).reshape(10, 10), axis=0).astype(np.complex64)
+        y = np.fft.irfft(x, n=10, axis=0)
+
+        x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+        y = y.reshape(1, 10, 10, 1).astype(np.float32)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_dft_irfft_opset19",
+            opset_imports=[onnx.helper.make_opsetid("", 19)],
+        )
+
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node("DFT", inputs=["x", "", "axis"], outputs=["y"])
+        x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+        axis = np.array(1, dtype=np.int64)
+        y = np.fft.fft(x, axis=0)
+
+        x = x.reshape(1, 10, 10, 1)
+        y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_dft")
+
+        node = onnx.helper.make_node("DFT", inputs=["x", "", "axis"], outputs=["y"])
+        x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+        axis = np.array(2, dtype=np.int64)
+        y = np.fft.fft(x, axis=1)
+
+        x = x.reshape(1, 10, 10, 1)
+        y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_dft_axis")
+
+        node = onnx.helper.make_node(
+            "DFT", inputs=["x", "", "axis"], outputs=["y"], inverse=1
+        )
+        x = np.arange(0, 100, dtype=np.complex64).reshape(10, 10)
+        axis = np.array(1, dtype=np.int64)
+        y = np.fft.ifft(x, axis=0)
+
+        x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+        y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 10, 10, 2)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_dft_inverse")
+
+        # Test RFFT (Real FFT): real input -> one-sided complex output
+        node = onnx.helper.make_node(
+            "DFT", inputs=["x", "", "axis"], outputs=["y"], onesided=1
+        )
+        x = np.arange(0, 100).reshape(10, 10).astype(np.float32)
+        axis = np.array(1, dtype=np.int64)
+        y = np.fft.rfft(x, axis=0)
+
+        x = x.reshape(1, 10, 10, 1)
+        y = np.stack((y.real, y.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_dft_rfft")
+
+        # Test IRFFT (Inverse Real FFT): one-sided complex input -> real output
+        node = onnx.helper.make_node(
+            "DFT", inputs=["x", "", "axis"], outputs=["y"], onesided=1, inverse=1
+        )
+        # Create one-sided complex input (6 bins for signal length 10)
+        x = np.fft.rfft(np.arange(0, 100).reshape(10, 10), axis=0).astype(np.complex64)
+        axis = np.array(1, dtype=np.int64)
+        y = np.fft.irfft(x, n=10, axis=0)
+
+        x = np.stack((x.real, x.imag), axis=2).astype(np.float32).reshape(1, 6, 10, 2)
+        y = y.reshape(1, 10, 10, 1).astype(np.float32)
+        expect(node, inputs=[x, axis], outputs=[y], name="test_dft_irfft")
diff --git a/onnx/backend/test/case/node/div.py b/onnx/backend/test/case/node/div.py
new file mode 100644
index 0000000..0b34c71
--- /dev/null
+++ b/onnx/backend/test/case/node/div.py
@@ -0,0 +1,78 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Div(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Div",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([3, 4]).astype(np.float32)
+        y = np.array([1, 2]).astype(np.float32)
+        z = x / y  # expected output [3., 2.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.rand(3, 4, 5).astype(np.float32) + 1.0
+        z = x / y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_int8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_int16")
+
+        x = np.array([-3, 3, -3, 3], dtype=np.int32)
+        y = np.array([2, 2, -2, -2], dtype=np.int32)
+        z = np.array([-1, 1, 1, -1], dtype=np.int32)
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_int32_trunc")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64) + 1
+        z = x // y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_uint64")
+
+    @staticmethod
+    def export_div_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Div",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.rand(5).astype(np.float32) + 1.0
+        z = x / y
+        expect(node, inputs=[x, y], outputs=[z], name="test_div_bcast")
diff --git a/onnx/backend/test/case/node/dropout.py b/onnx/backend/test/case/node/dropout.py
new file mode 100644
index 0000000..87f2554
--- /dev/null
+++ b/onnx/backend/test/case/node/dropout.py
@@ -0,0 +1,209 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx import helper
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def dropout(X, drop_probability=0.5, seed=0, training_mode=False, return_mask=False):
+    if drop_probability == 0 or training_mode is False:
+        if return_mask is True:
+            return X, np.ones(X.shape, dtype=bool)
+        return X
+
+    np.random.seed(seed)
+    mask = np.random.uniform(0, 1.0, X.shape) >= drop_probability
+    scale = 1 / (1 - drop_probability)
+    if return_mask:
+        return mask * X * scale, mask.astype(bool)
+    return mask * X * scale
+
+
+class Dropout(Base):
+    # Inferencing tests.
+    @staticmethod
+    def export_default() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node("Dropout", inputs=["x"], outputs=["y"], seed=seed)
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = dropout(x)
+        expect(node, inputs=[x], outputs=[y], name="test_dropout_default")
+
+    @staticmethod
+    def export_default_ratio() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node(
+            "Dropout", inputs=["x", "r"], outputs=["y"], seed=seed
+        )
+
+        r = np.float32(0.1)
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = dropout(x, r)
+        expect(node, inputs=[x, r], outputs=[y], name="test_dropout_default_ratio")
+
+    @staticmethod
+    def export_default_mask() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node(
+            "Dropout", inputs=["x"], outputs=["y", "z"], seed=seed
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y, z = dropout(x, return_mask=True)
+        expect(node, inputs=[x], outputs=[y, z], name="test_dropout_default_mask")
+
+    @staticmethod
+    def export_default_mask_ratio() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node(
+            "Dropout", inputs=["x", "r"], outputs=["y", "z"], seed=seed
+        )
+
+        r = np.float32(0.1)
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y, z = dropout(x, r, return_mask=True)
+        expect(
+            node, inputs=[x, r], outputs=[y, z], name="test_dropout_default_mask_ratio"
+        )
+
+    # Training tests.
+
+    @staticmethod
+    def export_training_default() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node(
+            "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        r = np.float32(0.5)
+        t = np.bool_(True)
+        y = dropout(x, r, training_mode=t)
+        expect(
+            node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_default"
+        )
+
+    @staticmethod
+    def export_training_default_ratio_mask() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node(
+            "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        r = np.float32(0.5)
+        t = np.bool_(True)
+        y, z = dropout(x, r, training_mode=t, return_mask=True)
+        expect(
+            node,
+            inputs=[x, r, t],
+            outputs=[y, z],
+            name="test_training_dropout_default_mask",
+        )
+
+    @staticmethod
+    def export_training() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node(
+            "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        r = np.float32(0.75)
+        t = np.bool_(True)
+        y = dropout(x, r, training_mode=t)
+        expect(node, inputs=[x, r, t], outputs=[y], name="test_training_dropout")
+
+    @staticmethod
+    def export_training_ratio_mask() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node(
+            "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        r = np.float32(0.75)
+        t = np.bool_(True)
+        y, z = dropout(x, r, training_mode=t, return_mask=True)
+        expect(
+            node, inputs=[x, r, t], outputs=[y, z], name="test_training_dropout_mask"
+        )
+
+    @staticmethod
+    def export_training_default_zero_ratio() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node(
+            "Dropout", inputs=["x", "r", "t"], outputs=["y"], seed=seed
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        r = np.float32(0.0)
+        t = np.bool_(True)
+        y = dropout(x, r, training_mode=t)
+        expect(
+            node, inputs=[x, r, t], outputs=[y], name="test_training_dropout_zero_ratio"
+        )
+
+    @staticmethod
+    def export_training_default_zero_ratio_mask() -> None:
+        seed = np.int64(0)
+        node = onnx.helper.make_node(
+            "Dropout", inputs=["x", "r", "t"], outputs=["y", "z"], seed=seed
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        r = np.float32(0.0)
+        t = np.bool_(True)
+        y, z = dropout(x, r, training_mode=t, return_mask=True)
+        expect(
+            node,
+            inputs=[x, r, t],
+            outputs=[y, z],
+            name="test_training_dropout_zero_ratio_mask",
+        )
+
+    # Old dropout tests
+
+    @staticmethod
+    def export_default_old() -> None:
+        node = onnx.helper.make_node(
+            "Dropout",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = x
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_dropout_default_old",
+            opset_imports=[helper.make_opsetid("", 11)],
+        )
+
+    @staticmethod
+    def export_random_old() -> None:
+        node = onnx.helper.make_node(
+            "Dropout",
+            inputs=["x"],
+            outputs=["y"],
+            ratio=0.2,
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = x
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_dropout_random_old",
+            opset_imports=[helper.make_opsetid("", 11)],
+        )
diff --git a/onnx/backend/test/case/node/dynamicquantizelinear.py b/onnx/backend/test/case/node/dynamicquantizelinear.py
new file mode 100644
index 0000000..66553a3
--- /dev/null
+++ b/onnx/backend/test/case/node/dynamicquantizelinear.py
@@ -0,0 +1,70 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class DynamicQuantizeLinear(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "DynamicQuantizeLinear",
+            inputs=["x"],
+            outputs=["y", "y_scale", "y_zero_point"],
+        )
+
+        # expected scale 0.0196078438 and zero point 153
+        X = np.array([0, 2, -3, -2.5, 1.34, 0.5]).astype(np.float32)
+        x_min = np.minimum(0, np.min(X))
+        x_max = np.maximum(0, np.max(X))
+        Y_Scale = np.float32((x_max - x_min) / (255 - 0))  # uint8 -> [0, 255]
+        Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8)
+        Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8)
+
+        expect(
+            node,
+            inputs=[X],
+            outputs=[Y, Y_Scale, Y_ZeroPoint],
+            name="test_dynamicquantizelinear",
+        )
+
+        # expected scale 0.0156862754 and zero point 255
+        X = np.array([-1.0, -2.1, -1.3, -2.5, -3.34, -4.0]).astype(np.float32)
+        x_min = np.minimum(0, np.min(X))
+        x_max = np.maximum(0, np.max(X))
+        Y_Scale = np.float32((x_max - x_min) / (255 - 0))  # uint8 -> [0, 255]
+        Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8)
+        Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8)
+
+        expect(
+            node,
+            inputs=[X],
+            outputs=[Y, Y_Scale, Y_ZeroPoint],
+            name="test_dynamicquantizelinear_max_adjusted",
+        )
+
+        X = (
+            np.array([1, 2.1, 1.3, 2.5, 3.34, 4.0, 1.5, 2.6, 3.9, 4.0, 3.0, 2.345])
+            .astype(np.float32)
+            .reshape((3, 4))
+        )
+
+        # expected scale 0.0156862754 and zero point 0
+        x_min = np.minimum(0, np.min(X))
+        x_max = np.maximum(0, np.max(X))
+        Y_Scale = np.float32((x_max - x_min) / (255 - 0))  # uint8 -> [0, 255]
+        Y_ZeroPoint = np.clip(round((0 - x_min) / Y_Scale), 0, 255).astype(np.uint8)
+        Y = np.clip(np.round(X / Y_Scale) + Y_ZeroPoint, 0, 255).astype(np.uint8)
+
+        expect(
+            node,
+            inputs=[X],
+            outputs=[Y, Y_Scale, Y_ZeroPoint],
+            name="test_dynamicquantizelinear_min_adjusted",
+        )
diff --git a/onnx/backend/test/case/node/einsum.py b/onnx/backend/test/case/node/einsum.py
new file mode 100644
index 0000000..e6c4e2e
--- /dev/null
+++ b/onnx/backend/test/case/node/einsum.py
@@ -0,0 +1,92 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def einsum_reference_implementation(
+    Eqn: str, Operands: tuple[np.ndarray, ...]
+) -> np.ndarray:
+    return np.einsum(Eqn, *Operands)
+
+
+class Einsum(Base):
+    @staticmethod
+    def export_einsum_transpose() -> None:
+        Eqn = "ij->ji"
+        node = onnx.helper.make_node(
+            "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+        )
+
+        X = np.random.randn(3, 4)
+        Y = einsum_reference_implementation(Eqn, (X,))
+
+        expect(node, inputs=[X], outputs=[Y], name="test_einsum_transpose")
+
+    @staticmethod
+    def export_einsum_sum() -> None:
+        Eqn = "ij->i"
+        node = onnx.helper.make_node(
+            "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+        )
+
+        X = np.random.randn(3, 4)
+        Z = einsum_reference_implementation(Eqn, (X,))
+
+        expect(node, inputs=[X], outputs=[Z], name="test_einsum_sum")
+
+    @staticmethod
+    def export_einsum_batch_diagonal() -> None:
+        Eqn = "...ii ->...i"
+        node = onnx.helper.make_node(
+            "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+        )
+
+        X = np.random.randn(3, 5, 5)
+        Z = einsum_reference_implementation(Eqn, (X,))
+
+        expect(node, inputs=[X], outputs=[Z], name="test_einsum_batch_diagonal")
+
+    @staticmethod
+    def export_einsum_inner_prod() -> None:
+        Eqn = "i,i"
+        node = onnx.helper.make_node(
+            "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn
+        )
+
+        X = np.random.randn(5)
+        Y = np.random.randn(5)
+        Z = einsum_reference_implementation(Eqn, (X, Y))
+
+        expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_inner_prod")
+
+    @staticmethod
+    def export_einsum_batch_matmul() -> None:
+        Eqn = "bij, bjk -> bik"
+        node = onnx.helper.make_node(
+            "Einsum", inputs=["x", "y"], outputs=["z"], equation=Eqn
+        )
+
+        X = np.random.randn(5, 2, 3)
+        Y = np.random.randn(5, 3, 4)
+        Z = einsum_reference_implementation(Eqn, (X, Y))
+
+        expect(node, inputs=[X, Y], outputs=[Z], name="test_einsum_batch_matmul")
+
+    @staticmethod
+    def export_einsum_scalar() -> None:
+        Eqn = "->"
+        node = onnx.helper.make_node(
+            "Einsum", inputs=["x"], outputs=["y"], equation=Eqn
+        )
+
+        X = np.array(5.0)  # scalar input
+        Z = einsum_reference_implementation(Eqn, (X,))
+
+        expect(node, inputs=[X], outputs=[Z], name="test_einsum_scalar")
diff --git a/onnx/backend/test/case/node/elu.py b/onnx/backend/test/case/node/elu.py
new file mode 100644
index 0000000..d19132f
--- /dev/null
+++ b/onnx/backend/test/case/node/elu.py
@@ -0,0 +1,37 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Elu(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node("Elu", inputs=["x"], outputs=["y"], alpha=2.0)
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        # expected output [-1.2642411, 0., 1.]
+        y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0
+        expect(node, inputs=[x], outputs=[y], name="test_elu_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0
+        expect(node, inputs=[x], outputs=[y], name="test_elu")
+
+    @staticmethod
+    def export_elu_default() -> None:
+        default_alpha = 1.0
+        node = onnx.helper.make_node(
+            "Elu",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, 0, np.inf) + (np.exp(np.clip(x, -np.inf, 0)) - 1) * default_alpha
+        expect(node, inputs=[x], outputs=[y], name="test_elu_default")
diff --git a/onnx/backend/test/case/node/equal.py b/onnx/backend/test/case/node/equal.py
new file mode 100644
index 0000000..ea09b43
--- /dev/null
+++ b/onnx/backend/test/case/node/equal.py
@@ -0,0 +1,92 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Equal(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Equal",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = (np.random.randn(3, 4, 5) * 10).astype(np.int32)
+        y = (np.random.randn(3, 4, 5) * 10).astype(np.int32)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal")
+
+        x = (np.random.randn(3, 4, 5) * 10).astype(np.int8)
+        y = (np.random.randn(3, 4, 5) * 10).astype(np.int8)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_int8")
+
+        x = (np.random.randn(3, 4, 5) * 10).astype(np.int16)
+        y = (np.random.randn(3, 4, 5) * 10).astype(np.int16)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_uint64")
+
+    @staticmethod
+    def export_equal_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Equal",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = (np.random.randn(3, 4, 5) * 10).astype(np.int32)
+        y = (np.random.randn(5) * 10).astype(np.int32)
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_bcast")
+
+    @staticmethod
+    def export_equal_string() -> None:
+        node = onnx.helper.make_node(
+            "Equal",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+        x = np.array(["string1", "string2"], dtype=np.dtype(object))
+        y = np.array(["string1", "string3"], dtype=np.dtype(object))
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_string")
+
+    @staticmethod
+    def export_equal_string_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Equal",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+        x = np.array(["string1", "string2"], dtype=np.dtype(object))
+        y = np.array(["string1"], dtype=np.dtype(object))
+        z = np.equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_equal_string_broadcast")
diff --git a/onnx/backend/test/case/node/erf.py b/onnx/backend/test/case/node/erf.py
new file mode 100644
index 0000000..3a5842a
--- /dev/null
+++ b/onnx/backend/test/case/node/erf.py
@@ -0,0 +1,26 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Erf(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Erf",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        y = np.vectorize(math.erf)(x).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_erf")
diff --git a/onnx/backend/test/case/node/exp.py b/onnx/backend/test/case/node/exp.py
new file mode 100644
index 0000000..c0a0692
--- /dev/null
+++ b/onnx/backend/test/case/node/exp.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Exp(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Exp",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.exp(x)  # expected output [0.36787945, 1., 2.71828175]
+        expect(node, inputs=[x], outputs=[y], name="test_exp_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.exp(x)
+        expect(node, inputs=[x], outputs=[y], name="test_exp")
diff --git a/onnx/backend/test/case/node/expand.py b/onnx/backend/test/case/node/expand.py
new file mode 100644
index 0000000..d88a625
--- /dev/null
+++ b/onnx/backend/test/case/node/expand.py
@@ -0,0 +1,66 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Expand(Base):
+    @staticmethod
+    def export_dim_changed() -> None:
+        node = onnx.helper.make_node(
+            "Expand",
+            inputs=["data", "new_shape"],
+            outputs=["expanded"],
+        )
+        shape = [3, 1]
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[1.], [2.], [3.]]
+        new_shape = [2, 1, 6]
+        expanded = data * np.ones(new_shape, dtype=np.float32)
+        # print(expanded)
+        # [[[1., 1., 1., 1., 1., 1.],
+        #  [2., 2., 2., 2., 2., 2.],
+        #  [3., 3., 3., 3., 3., 3.]],
+        #
+        # [[1., 1., 1., 1., 1., 1.],
+        #  [2., 2., 2., 2., 2., 2.],
+        #  [3., 3., 3., 3., 3., 3.]]]
+        new_shape = np.array(new_shape, dtype=np.int64)
+        expect(
+            node,
+            inputs=[data, new_shape],
+            outputs=[expanded],
+            name="test_expand_dim_changed",
+        )
+
+    @staticmethod
+    def export_dim_unchanged() -> None:
+        node = onnx.helper.make_node(
+            "Expand",
+            inputs=["data", "new_shape"],
+            outputs=["expanded"],
+        )
+        shape = [3, 1]
+        new_shape = [3, 4]
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[1.], [2.], [3.]]
+        expanded = np.tile(data, 4)
+        # print(expanded)
+        # [[1., 1., 1., 1.],
+        # [2., 2., 2., 2.],
+        # [3., 3., 3., 3.]]
+        new_shape = np.array(new_shape, dtype=np.int64)
+        expect(
+            node,
+            inputs=[data, new_shape],
+            outputs=[expanded],
+            name="test_expand_dim_unchanged",
+        )
diff --git a/onnx/backend/test/case/node/eyelike.py b/onnx/backend/test/case/node/eyelike.py
new file mode 100644
index 0000000..6ea785f
--- /dev/null
+++ b/onnx/backend/test/case/node/eyelike.py
@@ -0,0 +1,60 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class EyeLike(Base):
+    @staticmethod
+    def export_without_dtype() -> None:
+        shape = (4, 4)
+        node = onnx.helper.make_node(
+            "EyeLike",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(0, 100, size=shape, dtype=np.int32)
+        y = np.eye(shape[0], shape[1], dtype=np.int32)
+        expect(node, inputs=[x], outputs=[y], name="test_eyelike_without_dtype")
+
+    @staticmethod
+    def export_with_dtype() -> None:
+        shape = (3, 4)
+        node = onnx.helper.make_node(
+            "EyeLike",
+            inputs=["x"],
+            outputs=["y"],
+            dtype=onnx.TensorProto.DOUBLE,
+        )
+
+        x = np.random.randint(0, 100, size=shape, dtype=np.int32)
+        y = np.eye(shape[0], shape[1], dtype=np.float64)
+        expect(node, inputs=[x], outputs=[y], name="test_eyelike_with_dtype")
+
+    @staticmethod
+    def export_populate_off_main_diagonal() -> None:
+        shape = (4, 5)
+        off_diagonal_offset = 1
+        node = onnx.helper.make_node(
+            "EyeLike",
+            inputs=["x"],
+            outputs=["y"],
+            k=off_diagonal_offset,
+            dtype=onnx.TensorProto.FLOAT,
+        )
+
+        x = np.random.randint(0, 100, size=shape, dtype=np.int32)
+        y = np.eye(shape[0], shape[1], k=off_diagonal_offset, dtype=np.float32)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_eyelike_populate_off_main_diagonal",
+        )
diff --git a/onnx/backend/test/case/node/flatten.py b/onnx/backend/test/case/node/flatten.py
new file mode 100644
index 0000000..ab2268f
--- /dev/null
+++ b/onnx/backend/test/case/node/flatten.py
@@ -0,0 +1,65 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Flatten(Base):
+    @staticmethod
+    def export() -> None:
+        shape = (2, 3, 4, 5)
+        a = np.random.random_sample(shape).astype(np.float32)
+
+        for i in range(len(shape)):
+            node = onnx.helper.make_node(
+                "Flatten",
+                inputs=["a"],
+                outputs=["b"],
+                axis=i,
+            )
+
+            new_shape = (1, -1) if i == 0 else (np.prod(shape[0:i]).astype(int), -1)
+            b = np.reshape(a, new_shape)
+            expect(node, inputs=[a], outputs=[b], name="test_flatten_axis" + str(i))
+
+    @staticmethod
+    def export_flatten_with_default_axis() -> None:
+        node = onnx.helper.make_node(
+            "Flatten",
+            inputs=["a"],
+            outputs=["b"],  # Default value for axis: axis=1
+        )
+
+        shape = (5, 4, 3, 2)
+        a = np.random.random_sample(shape).astype(np.float32)
+        new_shape = (5, 24)
+        b = np.reshape(a, new_shape)
+        expect(node, inputs=[a], outputs=[b], name="test_flatten_default_axis")
+
+    @staticmethod
+    def export_flatten_negative_axis() -> None:
+        shape = (2, 3, 4, 5)
+        a = np.random.random_sample(shape).astype(np.float32)
+
+        for i in range(-len(shape), 0):
+            node = onnx.helper.make_node(
+                "Flatten",
+                inputs=["a"],
+                outputs=["b"],
+                axis=i,
+            )
+
+            new_shape = (np.prod(shape[0:i]).astype(int), -1)
+            b = np.reshape(a, new_shape)
+            expect(
+                node,
+                inputs=[a],
+                outputs=[b],
+                name="test_flatten_negative_axis" + str(abs(i)),
+            )
diff --git a/onnx/backend/test/case/node/flexattention.py b/onnx/backend/test/case/node/flexattention.py
new file mode 100644
index 0000000..c6b1d09
--- /dev/null
+++ b/onnx/backend/test/case/node/flexattention.py
@@ -0,0 +1,583 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx import TensorProto, helper
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.defs import AI_ONNX_PREVIEW_DOMAIN
+from onnx.reference.ops.aionnx_preview.op_flex_attention import (
+    _compute_flex_attention,
+)
+
+
+def _make_score_mod_bias_graph(
+    bias_value: float,
+    dtype: TensorProto.DataType = TensorProto.FLOAT,
+) -> onnx.GraphProto:
+    """Create a score_mod subgraph that adds a constant bias to the scores.
+
+    score_mod(scores) -> scores + bias
+    """
+    score_in = helper.make_tensor_value_info("scores", dtype, ["B", "H", "L", "S"])
+    score_out = helper.make_tensor_value_info("scores_out", dtype, ["B", "H", "L", "S"])
+
+    bias_tensor = helper.make_tensor("bias", dtype, [], [bias_value])
+    add_node = helper.make_node("Add", ["scores", "bias"], ["scores_out"])
+
+    return helper.make_graph(
+        [add_node],
+        "score_mod_bias",
+        [score_in],
+        [score_out],
+        [bias_tensor],
+    )
+
+
+def _make_prob_mod_scale_graph(
+    scale_value: float,
+    dtype: TensorProto.DataType = TensorProto.FLOAT,
+) -> onnx.GraphProto:
+    """Create a prob_mod subgraph that scales the probabilities.
+
+    prob_mod(probs) -> probs * scale
+    """
+    prob_in = helper.make_tensor_value_info("probs", dtype, ["B", "H", "L", "S"])
+    prob_out = helper.make_tensor_value_info("probs_out", dtype, ["B", "H", "L", "S"])
+
+    scale_tensor = helper.make_tensor("scale", dtype, [], [scale_value])
+    mul_node = helper.make_node("Mul", ["probs", "scale"], ["probs_out"])
+
+    return helper.make_graph(
+        [mul_node],
+        "prob_mod_scale",
+        [prob_in],
+        [prob_out],
+        [scale_tensor],
+    )
+
+
+def _make_score_mod_causal_mask_graph(
+    dtype: TensorProto.DataType = TensorProto.FLOAT,
+) -> onnx.GraphProto:
+    """Create a score_mod subgraph that applies causal masking.
+
+    For each position, masks out future tokens by setting scores to -inf
+    where k_idx > q_idx. This pattern is used in Qwen-3, Gemma-3, Llama-3, etc.
+
+    score_mod(scores) -> Where(q_idx >= k_idx, scores, -inf)
+    """
+    score_in = helper.make_tensor_value_info("scores", dtype, ["B", "H", "L", "S"])
+    score_out = helper.make_tensor_value_info("scores_out", dtype, ["B", "H", "L", "S"])
+
+    nodes = [
+        # Extract L and S from scores shape [B, H, L, S]
+        helper.make_node("Shape", ["scores"], ["scores_shape"]),
+        helper.make_node("Gather", ["scores_shape", "idx_2"], ["L_dim"], axis=0),
+        helper.make_node("Gather", ["scores_shape", "idx_3"], ["S_dim"], axis=0),
+        # Build q_idx: range(L) reshaped to [1, 1, L, 1]
+        helper.make_node("Range", ["zero", "L_dim", "one"], ["q_range"]),
+        helper.make_node("Reshape", ["q_range", "q_shape"], ["q_idx"]),
+        # Build k_idx: range(S) reshaped to [1, 1, 1, S]
+        helper.make_node("Range", ["zero", "S_dim", "one"], ["k_range"]),
+        helper.make_node("Reshape", ["k_range", "k_shape"], ["k_idx"]),
+        # Causal mask: q_idx >= k_idx
+        helper.make_node("GreaterOrEqual", ["q_idx", "k_idx"], ["mask"]),
+        # Where(mask, scores, -inf)
+        helper.make_node("Where", ["mask", "scores", "neg_inf"], ["scores_out"]),
+    ]
+
+    initializers = [
+        helper.make_tensor("zero", TensorProto.INT64, [], [0]),
+        helper.make_tensor("one", TensorProto.INT64, [], [1]),
+        helper.make_tensor("idx_2", TensorProto.INT64, [], [2]),
+        helper.make_tensor("idx_3", TensorProto.INT64, [], [3]),
+        helper.make_tensor("q_shape", TensorProto.INT64, [4], [1, 1, -1, 1]),
+        helper.make_tensor("k_shape", TensorProto.INT64, [4], [1, 1, 1, -1]),
+        helper.make_tensor("neg_inf", dtype, [], [float("-inf")]),
+    ]
+
+    return helper.make_graph(
+        nodes,
+        "score_mod_causal_mask",
+        [score_in],
+        [score_out],
+        initializers,
+    )
+
+
+def _make_score_mod_soft_cap_graph(
+    cap_value: float,
+    dtype: TensorProto.DataType = TensorProto.FLOAT,
+) -> onnx.GraphProto:
+    """Create a score_mod subgraph that applies soft capping.
+
+    Used in Gemma-2 to stabilize attention scores.
+
+    score_mod(scores) -> tanh(scores / cap) * cap
+    """
+    score_in = helper.make_tensor_value_info("scores", dtype, ["B", "H", "L", "S"])
+    score_out = helper.make_tensor_value_info("scores_out", dtype, ["B", "H", "L", "S"])
+
+    nodes = [
+        helper.make_node("Div", ["scores", "cap"], ["scaled"]),
+        helper.make_node("Tanh", ["scaled"], ["tanh_out"]),
+        helper.make_node("Mul", ["tanh_out", "cap"], ["scores_out"]),
+    ]
+
+    initializers = [
+        helper.make_tensor("cap", dtype, [], [cap_value]),
+    ]
+
+    return helper.make_graph(
+        nodes,
+        "score_mod_soft_cap",
+        [score_in],
+        [score_out],
+        initializers,
+    )
+
+
+def _make_score_mod_relative_positional_graph(
+    dtype: TensorProto.DataType = TensorProto.FLOAT,
+) -> onnx.GraphProto:
+    """Create a score_mod subgraph that adds relative positional bias.
+
+    Adds (q_idx - k_idx) to the scores. This pattern captures the core idea
+    of relative position embeddings used in various Transformer models.
+
+    score_mod(scores) -> scores + Cast(q_idx - k_idx, dtype)
+    """
+    score_in = helper.make_tensor_value_info("scores", dtype, ["B", "H", "L", "S"])
+    score_out = helper.make_tensor_value_info("scores_out", dtype, ["B", "H", "L", "S"])
+
+    nodes = [
+        # Extract L and S from scores shape [B, H, L, S]
+        helper.make_node("Shape", ["scores"], ["scores_shape"]),
+        helper.make_node("Gather", ["scores_shape", "idx_2"], ["L_dim"], axis=0),
+        helper.make_node("Gather", ["scores_shape", "idx_3"], ["S_dim"], axis=0),
+        # Build q_idx: range(L) reshaped to [L, 1]
+        helper.make_node("Range", ["zero", "L_dim", "one"], ["q_range"]),
+        helper.make_node("Reshape", ["q_range", "q_shape"], ["q_idx"]),
+        # Build k_idx: range(S) reshaped to [1, S]
+        helper.make_node("Range", ["zero", "S_dim", "one"], ["k_range"]),
+        helper.make_node("Reshape", ["k_range", "k_shape"], ["k_idx"]),
+        # Relative position: q_idx - k_idx (broadcasts to [L, S])
+        helper.make_node("Sub", ["q_idx", "k_idx"], ["rel_pos"]),
+        # Cast to score dtype and add to scores
+        helper.make_node("Cast", ["rel_pos"], ["rel_pos_cast"], to=dtype),
+        helper.make_node("Add", ["scores", "rel_pos_cast"], ["scores_out"]),
+    ]
+
+    initializers = [
+        helper.make_tensor("zero", TensorProto.INT64, [], [0]),
+        helper.make_tensor("one", TensorProto.INT64, [], [1]),
+        helper.make_tensor("idx_2", TensorProto.INT64, [], [2]),
+        helper.make_tensor("idx_3", TensorProto.INT64, [], [3]),
+        helper.make_tensor("q_shape", TensorProto.INT64, [2], [-1, 1]),
+        helper.make_tensor("k_shape", TensorProto.INT64, [2], [1, -1]),
+    ]
+
+    return helper.make_graph(
+        nodes,
+        "score_mod_relative_positional",
+        [score_in],
+        [score_out],
+        initializers,
+    )
+
+
+class FlexAttention(Base):
+    @staticmethod
+    def export_flexattention() -> None:
+        """Basic FlexAttention test with default settings."""
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+
+        B, Hq, L, E = 2, 4, 8, 16
+        S, Ev = 6, 16
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+        K = np.random.rand(B, Hq, S, E).astype(np.float32)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+        (Y,) = _compute_flex_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_scaled() -> None:
+        """FlexAttention with explicit scale attribute."""
+        scale = 0.1
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            scale=scale,
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+
+        B, Hq, L, E = 2, 4, 8, 16
+        S, Ev = 6, 16
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+        K = np.random.rand(B, Hq, S, E).astype(np.float32)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+        (Y,) = _compute_flex_attention(Q, K, V, scale=scale)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_scaled",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_gqa() -> None:
+        """FlexAttention with Grouped Query Attention (GQA)."""
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+
+        B, Hq, Hkv, L, S, E, Ev = 2, 8, 2, 4, 6, 16, 16
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+        K = np.random.rand(B, Hkv, S, E).astype(np.float32)
+        V = np.random.rand(B, Hkv, S, Ev).astype(np.float32)
+
+        (Y,) = _compute_flex_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_gqa",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_diff_head_sizes() -> None:
+        """FlexAttention with different head sizes for Q/K vs V."""
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+
+        B, Hq, L, E = 2, 4, 8, 16
+        S, Ev = 6, 32  # V has different head size
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+        K = np.random.rand(B, Hq, S, E).astype(np.float32)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+        (Y,) = _compute_flex_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_diff_head_sizes",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_score_mod() -> None:
+        """FlexAttention with score_mod subgraph (adds bias to scores)."""
+        bias_value = 0.5
+        score_mod_graph = _make_score_mod_bias_graph(bias_value, TensorProto.FLOAT)
+
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+        # Add score_mod as a graph attribute
+        score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+        node.attribute.append(score_mod_attr)
+
+        B, Hq, L, E = 1, 2, 3, 4
+        S, Ev = 3, 4
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+        K = np.random.rand(B, Hq, S, E).astype(np.float32)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+        scale = 1.0 / np.sqrt(E)
+        scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+        scores = scores + bias_value  # score_mod: add bias
+        probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+        probs = probs / probs.sum(axis=-1, keepdims=True)
+        Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_score_mod",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_prob_mod() -> None:
+        """FlexAttention with prob_mod subgraph (scales probabilities)."""
+        scale_value = 0.5
+        prob_mod_graph = _make_prob_mod_scale_graph(scale_value, TensorProto.FLOAT)
+
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+        prob_mod_attr = helper.make_attribute("prob_mod", prob_mod_graph)
+        node.attribute.append(prob_mod_attr)
+
+        B, Hq, L, E = 1, 2, 3, 4
+        S, Ev = 3, 4
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+        K = np.random.rand(B, Hq, S, E).astype(np.float32)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+        scale = 1.0 / np.sqrt(E)
+        scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+        probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+        probs = probs / probs.sum(axis=-1, keepdims=True)
+        probs = probs * scale_value
+        Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_prob_mod",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_fp16() -> None:
+        """FlexAttention with float16 inputs."""
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+
+        B, Hq, L, E = 2, 4, 8, 16
+        S, Ev = 6, 16
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float16)
+        K = np.random.rand(B, Hq, S, E).astype(np.float16)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float16)
+
+        (Y,) = _compute_flex_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_fp16",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_double() -> None:
+        """FlexAttention with double precision inputs."""
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+
+        B, Hq, L, E = 2, 4, 8, 16
+        S, Ev = 6, 16
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float64)
+        K = np.random.rand(B, Hq, S, E).astype(np.float64)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float64)
+
+        (Y,) = _compute_flex_attention(Q, K, V)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_double",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_causal_mask() -> None:
+        """FlexAttention with causal masking score_mod (Qwen-3, Gemma-3, Llama-3 pattern)."""
+        score_mod_graph = _make_score_mod_causal_mask_graph(TensorProto.FLOAT)
+
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+        score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+        node.attribute.append(score_mod_attr)
+
+        B, Hq, L, E = 1, 2, 4, 8
+        S, Ev = 4, 8
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+        K = np.random.rand(B, Hq, S, E).astype(np.float32)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+        # Manually compute expected output with causal masking
+        scale = 1.0 / np.sqrt(E)
+        scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+        # Apply causal mask: set future positions to -inf
+        q_idx = np.arange(L).reshape(1, 1, L, 1)
+        k_idx = np.arange(S).reshape(1, 1, 1, S)
+        mask = q_idx >= k_idx
+        scores = np.where(mask, scores, -np.inf)
+        probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+        probs = probs / probs.sum(axis=-1, keepdims=True)
+        Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_causal_mask",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_soft_cap() -> None:
+        """FlexAttention with soft capping score_mod (Gemma-2 pattern)."""
+        cap_value = 20.0
+        score_mod_graph = _make_score_mod_soft_cap_graph(cap_value, TensorProto.FLOAT)
+
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+        score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+        node.attribute.append(score_mod_attr)
+
+        B, Hq, L, E = 1, 2, 4, 8
+        S, Ev = 4, 8
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+        K = np.random.rand(B, Hq, S, E).astype(np.float32)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+        # Manually compute expected output with soft capping
+        scale = 1.0 / np.sqrt(E)
+        scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+        scores = np.tanh(scores / cap_value) * cap_value
+        probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+        probs = probs / probs.sum(axis=-1, keepdims=True)
+        Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_soft_cap",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    @staticmethod
+    def export_flexattention_relative_positional() -> None:
+        """FlexAttention with relative positional bias score_mod."""
+        score_mod_graph = _make_score_mod_relative_positional_graph(TensorProto.FLOAT)
+
+        node = helper.make_node(
+            "FlexAttention",
+            inputs=["Q", "K", "V"],
+            outputs=["Y"],
+            domain=AI_ONNX_PREVIEW_DOMAIN,
+        )
+        score_mod_attr = helper.make_attribute("score_mod", score_mod_graph)
+        node.attribute.append(score_mod_attr)
+
+        B, Hq, L, E = 1, 2, 4, 8
+        S, Ev = 4, 8
+
+        Q = np.random.rand(B, Hq, L, E).astype(np.float32)
+        K = np.random.rand(B, Hq, S, E).astype(np.float32)
+        V = np.random.rand(B, Hq, S, Ev).astype(np.float32)
+
+        # Manually compute expected output with relative positional bias
+        scale = 1.0 / np.sqrt(E)
+        scores = np.einsum("bhle,bhse->bhls", Q, K) * scale
+        q_idx = np.arange(L).reshape(-1, 1)
+        k_idx = np.arange(S).reshape(1, -1)
+        rel_pos = (q_idx - k_idx).astype(np.float32)
+        scores = scores + rel_pos
+        probs = np.exp(scores - scores.max(axis=-1, keepdims=True))
+        probs = probs / probs.sum(axis=-1, keepdims=True)
+        Y = np.einsum("bhls,bhsv->bhlv", probs, V).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[Q, K, V],
+            outputs=[Y],
+            name="test_flexattention_relative_positional",
+            opset_imports=[
+                helper.make_opsetid("", 26),
+                helper.make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
diff --git a/onnx/backend/test/case/node/floor.py b/onnx/backend/test/case/node/floor.py
new file mode 100644
index 0000000..76373dd
--- /dev/null
+++ b/onnx/backend/test/case/node/floor.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Floor(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Floor",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1.5, 1.2, 2]).astype(np.float32)
+        y = np.floor(x)  # expected output [-2., 1., 2.]
+        expect(node, inputs=[x], outputs=[y], name="test_floor_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.floor(x)
+        expect(node, inputs=[x], outputs=[y], name="test_floor")
diff --git a/onnx/backend/test/case/node/gather.py b/onnx/backend/test/case/node/gather.py
new file mode 100644
index 0000000..20435ec
--- /dev/null
+++ b/onnx/backend/test/case/node/gather.py
@@ -0,0 +1,91 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Gather(Base):
+    @staticmethod
+    def export_gather_0() -> None:
+        node = onnx.helper.make_node(
+            "Gather",
+            inputs=["data", "indices"],
+            outputs=["y"],
+            axis=0,
+        )
+        data = np.random.randn(5, 4, 3, 2).astype(np.float32)
+        indices = np.array([0, 1, 3])
+        y = np.take(data, indices, axis=0)
+
+        expect(
+            node,
+            inputs=[data, indices.astype(np.int64)],
+            outputs=[y],
+            name="test_gather_0",
+        )
+
+    @staticmethod
+    def export_gather_1() -> None:
+        node = onnx.helper.make_node(
+            "Gather",
+            inputs=["data", "indices"],
+            outputs=["y"],
+            axis=1,
+        )
+        data = np.random.randn(5, 4, 3, 2).astype(np.float32)
+        indices = np.array([0, 1, 3])
+        y = np.take(data, indices, axis=1)
+
+        expect(
+            node,
+            inputs=[data, indices.astype(np.int64)],
+            outputs=[y],
+            name="test_gather_1",
+        )
+
+    @staticmethod
+    def export_gather_2d_indices() -> None:
+        node = onnx.helper.make_node(
+            "Gather",
+            inputs=["data", "indices"],
+            outputs=["y"],
+            axis=1,
+        )
+        data = np.random.randn(3, 3).astype(np.float32)
+        indices = np.array([[0, 2]])
+        y = np.take(data, indices, axis=1)
+
+        expect(
+            node,
+            inputs=[data, indices.astype(np.int64)],
+            outputs=[y],
+            name="test_gather_2d_indices",
+        )
+
+    @staticmethod
+    def export_gather_negative_indices() -> None:
+        node = onnx.helper.make_node(
+            "Gather",
+            inputs=["data", "indices"],
+            outputs=["y"],
+            axis=0,
+        )
+        data = np.arange(10).astype(np.float32)
+        indices = np.array([0, -9, -10])
+        y = np.take(data, indices, axis=0)
+
+        # print(y)
+        # [0. 1. 0.]
+
+        expect(
+            node,
+            inputs=[data, indices.astype(np.int64)],
+            outputs=[y],
+            name="test_gather_negative_indices",
+        )
diff --git a/onnx/backend/test/case/node/gatherelements.py b/onnx/backend/test/case/node/gatherelements.py
new file mode 100644
index 0000000..56dd77e
--- /dev/null
+++ b/onnx/backend/test/case/node/gatherelements.py
@@ -0,0 +1,92 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+# The below GatherElements' numpy implementation is from https://stackoverflow.com/a/46204790/11767360
+def gather_elements(data, indices, axis=0):
+    data_swapped = np.swapaxes(data, 0, axis)
+    index_swapped = np.swapaxes(indices, 0, axis)
+    gathered = np.choose(index_swapped, data_swapped, mode="wrap")
+    return np.swapaxes(gathered, 0, axis)
+
+
+class GatherElements(Base):
+    @staticmethod
+    def export_gather_elements_0() -> None:
+        axis = 1
+        node = onnx.helper.make_node(
+            "GatherElements",
+            inputs=["data", "indices"],
+            outputs=["y"],
+            axis=axis,
+        )
+        data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+        indices = np.array([[0, 0], [1, 0]], dtype=np.int32)
+
+        y = gather_elements(data, indices, axis)
+        # print(y) produces
+        # [[1, 1],
+        #  [4, 3]]
+
+        expect(
+            node,
+            inputs=[data, indices.astype(np.int64)],
+            outputs=[y],
+            name="test_gather_elements_0",
+        )
+
+    @staticmethod
+    def export_gather_elements_1() -> None:
+        axis = 0
+        node = onnx.helper.make_node(
+            "GatherElements",
+            inputs=["data", "indices"],
+            outputs=["y"],
+            axis=axis,
+        )
+        data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32)
+        indices = np.array([[1, 2, 0], [2, 0, 0]], dtype=np.int32)
+
+        y = gather_elements(data, indices, axis)
+        # print(y) produces
+        # [[4, 8, 3],
+        #  [7, 2, 3]]
+
+        expect(
+            node,
+            inputs=[data, indices.astype(np.int64)],
+            outputs=[y],
+            name="test_gather_elements_1",
+        )
+
+    @staticmethod
+    def export_gather_elements_negative_indices() -> None:
+        axis = 0
+        node = onnx.helper.make_node(
+            "GatherElements",
+            inputs=["data", "indices"],
+            outputs=["y"],
+            axis=axis,
+        )
+        data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float32)
+        indices = np.array([[-1, -2, 0], [-2, 0, 0]], dtype=np.int32)
+
+        y = gather_elements(data, indices, axis)
+        # print(y) produces
+        # [[7, 5, 3],
+        #  [4, 2, 3]]
+
+        expect(
+            node,
+            inputs=[data, indices.astype(np.int64)],
+            outputs=[y],
+            name="test_gather_elements_negative_indices",
+        )
diff --git a/onnx/backend/test/case/node/gathernd.py b/onnx/backend/test/case/node/gathernd.py
new file mode 100644
index 0000000..971a83e
--- /dev/null
+++ b/onnx/backend/test/case/node/gathernd.py
@@ -0,0 +1,121 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def gather_nd_impl(
+    data: np.ndarray, indices: np.ndarray, batch_dims: int
+) -> np.ndarray:
+    # Note the data rank - will be reused multiple times later
+    data_rank = len(data.shape)
+
+    # Check input tensors' shape/rank condition
+    assert indices.shape[-1] <= data_rank
+
+    # The list of data/indice shape of batch_dims
+    batch_dims_shape = []
+
+    # The number of elements in the batch_dims for data/indice array
+    batch_dims_size = 1
+
+    # Check the shape of indice and data are identical for batch dims.
+    for i in range(batch_dims):
+        batch_dims_shape.append(indices.shape[i])
+        batch_dims_size *= indices.shape[i]
+
+    # Compute output of the op as below
+
+    # Compute shape of output array
+    output_shape = (
+        batch_dims_shape + list(indices.shape)[batch_dims:-1]
+        if (indices.shape[-1] == data_rank - batch_dims)
+        else batch_dims_shape
+        + list(indices.shape)[batch_dims:-1]
+        + list(data.shape)[batch_dims + indices.shape[-1] :]
+    )
+
+    # Placeholder for output data
+    output_data_buffer = []
+
+    # Flatten 'indices' to 2D array
+    reshaped_indices = indices.reshape(batch_dims_size, -1, indices.shape[-1])
+
+    # Flatten 'data' to array of shape (batch_dim_size, data.shape[batch_dimes:])
+    reshaped_data = data.reshape((batch_dims_size, *data.shape[batch_dims:]))
+
+    # gather each scalar value from 'data'
+    for batch_dim in range(reshaped_indices.shape[0]):
+        for outer_dim in range(reshaped_indices.shape[1]):
+            gather_index = tuple(reshaped_indices[batch_dim][outer_dim])
+            output_data_buffer.append(reshaped_data[(batch_dim, *gather_index)])
+    return np.asarray(output_data_buffer, dtype=data.dtype).reshape(output_shape)
+
+
+class GatherND(Base):
+    @staticmethod
+    def export_int32() -> None:
+        node = onnx.helper.make_node(
+            "GatherND",
+            inputs=["data", "indices"],
+            outputs=["output"],
+        )
+
+        data = np.array([[0, 1], [2, 3]], dtype=np.int32)
+        indices = np.array([[0, 0], [1, 1]], dtype=np.int64)
+        output = gather_nd_impl(data, indices, 0)
+        expected_output = np.array([0, 3], dtype=np.int32)
+        assert np.array_equal(output, expected_output)
+        expect(
+            node,
+            inputs=[data, indices],
+            outputs=[output],
+            name="test_gathernd_example_int32",
+        )
+
+    @staticmethod
+    def export_float32() -> None:
+        node = onnx.helper.make_node(
+            "GatherND",
+            inputs=["data", "indices"],
+            outputs=["output"],
+        )
+
+        data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.float32)
+        indices = np.array([[[0, 1]], [[1, 0]]], dtype=np.int64)
+        output = gather_nd_impl(data, indices, 0)
+        expected_output = np.array([[[2, 3]], [[4, 5]]], dtype=np.float32)
+        assert np.array_equal(output, expected_output)
+        expect(
+            node,
+            inputs=[data, indices],
+            outputs=[output],
+            name="test_gathernd_example_float32",
+        )
+
+    @staticmethod
+    def export_int32_batchdim_1() -> None:
+        node = onnx.helper.make_node(
+            "GatherND",
+            inputs=["data", "indices"],
+            outputs=["output"],
+            batch_dims=1,
+        )
+
+        data = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]], dtype=np.int32)
+        indices = np.array([[1], [0]], dtype=np.int64)
+        output = gather_nd_impl(data, indices, 1)
+        expected_output = np.array([[2, 3], [4, 5]], dtype=np.int32)
+        assert np.array_equal(output, expected_output)
+        expect(
+            node,
+            inputs=[data, indices],
+            outputs=[output],
+            name="test_gathernd_example_int32_batch_dim1",
+        )
diff --git a/onnx/backend/test/case/node/gelu.py b/onnx/backend/test/case/node/gelu.py
new file mode 100644
index 0000000..86ac9d6
--- /dev/null
+++ b/onnx/backend/test/case/node/gelu.py
@@ -0,0 +1,52 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Gelu(Base):
+    @staticmethod
+    def export_gelu_tanh() -> None:
+        node = onnx.helper.make_node(
+            "Gelu", inputs=["x"], outputs=["y"], approximate="tanh"
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        # expected output [-0.158808, 0., 0.841192]
+        y = (
+            0.5
+            * x
+            * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
+        ).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_gelu_tanh_1")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        # expected output [2.9963627, 3.99993, 4.9999995]
+        y = (
+            0.5
+            * x
+            * (1 + np.tanh(np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3))))
+        ).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_gelu_tanh_2")
+
+    @staticmethod
+    def export_gelu_default() -> None:
+        node = onnx.helper.make_node("Gelu", inputs=["x"], outputs=["y"])
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        # expected output [-0.15865526, 0., 0.84134474]
+        y = (0.5 * x * (1 + np.vectorize(math.erf)(x / np.sqrt(2)))).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_gelu_default_1")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        # expected output [2.99595031, 3.99987331, 4.99999857]
+        y = (0.5 * x * (1 + np.vectorize(math.erf)(x / np.sqrt(2)))).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_gelu_default_2")
diff --git a/onnx/backend/test/case/node/gemm.py b/onnx/backend/test/case/node/gemm.py
new file mode 100644
index 0000000..5ad7aca
--- /dev/null
+++ b/onnx/backend/test/case/node/gemm.py
@@ -0,0 +1,157 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def gemm_reference_implementation(
+    A: np.ndarray,
+    B: np.ndarray,
+    C: np.ndarray | None = None,
+    alpha: float = 1.0,
+    beta: float = 1.0,
+    transA: int = 0,
+    transB: int = 0,
+) -> np.ndarray:
+    A = A if transA == 0 else A.T
+    B = B if transB == 0 else B.T
+    C = C if C is not None else np.array(0)
+
+    Y = alpha * np.dot(A, B) + beta * C
+
+    return Y.astype(A.dtype)
+
+
+class Gemm(Base):
+    @staticmethod
+    def export_default_zero_bias() -> None:
+        node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+        a = np.random.ranf([3, 5]).astype(np.float32)
+        b = np.random.ranf([5, 4]).astype(np.float32)
+        c = np.zeros([1, 4]).astype(np.float32)
+        y = gemm_reference_implementation(a, b, c)
+        expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_zero_bias")
+
+    @staticmethod
+    def export_default_no_bias() -> None:
+        node = onnx.helper.make_node("Gemm", inputs=["a", "b"], outputs=["y"])
+        a = np.random.ranf([2, 10]).astype(np.float32)
+        b = np.random.ranf([10, 3]).astype(np.float32)
+        y = gemm_reference_implementation(a, b)
+        expect(node, inputs=[a, b], outputs=[y], name="test_gemm_default_no_bias")
+
+    @staticmethod
+    def export_default_scalar_bias() -> None:
+        node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+        a = np.random.ranf([2, 3]).astype(np.float32)
+        b = np.random.ranf([3, 4]).astype(np.float32)
+        c = np.array(3.14).astype(np.float32)
+        y = gemm_reference_implementation(a, b, c)
+        expect(
+            node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_scalar_bias"
+        )
+
+    @staticmethod
+    def export_default_single_elem_vector_bias() -> None:
+        node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+        a = np.random.ranf([3, 7]).astype(np.float32)
+        b = np.random.ranf([7, 3]).astype(np.float32)
+        c = np.random.ranf([1]).astype(np.float32)
+        y = gemm_reference_implementation(a, b, c)
+        expect(
+            node,
+            inputs=[a, b, c],
+            outputs=[y],
+            name="test_gemm_default_single_elem_vector_bias",
+        )
+
+    @staticmethod
+    def export_default_vector_bias() -> None:
+        node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+        a = np.random.ranf([2, 7]).astype(np.float32)
+        b = np.random.ranf([7, 4]).astype(np.float32)
+        c = np.random.ranf([1, 4]).astype(np.float32)
+        y = gemm_reference_implementation(a, b, c)
+        expect(
+            node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_vector_bias"
+        )
+
+    @staticmethod
+    def export_default_matrix_bias() -> None:
+        node = onnx.helper.make_node("Gemm", inputs=["a", "b", "c"], outputs=["y"])
+        a = np.random.ranf([3, 6]).astype(np.float32)
+        b = np.random.ranf([6, 4]).astype(np.float32)
+        c = np.random.ranf([3, 4]).astype(np.float32)
+        y = gemm_reference_implementation(a, b, c)
+        expect(
+            node, inputs=[a, b, c], outputs=[y], name="test_gemm_default_matrix_bias"
+        )
+
+    @staticmethod
+    def export_transposeA() -> None:
+        node = onnx.helper.make_node(
+            "Gemm", inputs=["a", "b", "c"], outputs=["y"], transA=1
+        )
+        a = np.random.ranf([6, 3]).astype(np.float32)
+        b = np.random.ranf([6, 4]).astype(np.float32)
+        c = np.zeros([1, 4]).astype(np.float32)
+        y = gemm_reference_implementation(a, b, c, transA=1)
+        expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeA")
+
+    @staticmethod
+    def export_transposeB() -> None:
+        node = onnx.helper.make_node(
+            "Gemm", inputs=["a", "b", "c"], outputs=["y"], transB=1
+        )
+        a = np.random.ranf([3, 6]).astype(np.float32)
+        b = np.random.ranf([4, 6]).astype(np.float32)
+        c = np.zeros([1, 4]).astype(np.float32)
+        y = gemm_reference_implementation(a, b, c, transB=1)
+        expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_transposeB")
+
+    @staticmethod
+    def export_alpha() -> None:
+        node = onnx.helper.make_node(
+            "Gemm", inputs=["a", "b", "c"], outputs=["y"], alpha=0.5
+        )
+        a = np.random.ranf([3, 5]).astype(np.float32)
+        b = np.random.ranf([5, 4]).astype(np.float32)
+        c = np.zeros([1, 4]).astype(np.float32)
+        y = gemm_reference_implementation(a, b, c, alpha=0.5)
+        expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_alpha")
+
+    @staticmethod
+    def export_beta() -> None:
+        node = onnx.helper.make_node(
+            "Gemm", inputs=["a", "b", "c"], outputs=["y"], beta=0.5
+        )
+        a = np.random.ranf([2, 7]).astype(np.float32)
+        b = np.random.ranf([7, 4]).astype(np.float32)
+        c = np.random.ranf([1, 4]).astype(np.float32)
+        y = gemm_reference_implementation(a, b, c, beta=0.5)
+        expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_beta")
+
+    @staticmethod
+    def export_all_attributes() -> None:
+        node = onnx.helper.make_node(
+            "Gemm",
+            inputs=["a", "b", "c"],
+            outputs=["y"],
+            alpha=0.25,
+            beta=0.35,
+            transA=1,
+            transB=1,
+        )
+        a = np.random.ranf([4, 3]).astype(np.float32)
+        b = np.random.ranf([5, 4]).astype(np.float32)
+        c = np.random.ranf([1, 5]).astype(np.float32)
+        y = gemm_reference_implementation(
+            a, b, c, transA=1, transB=1, alpha=0.25, beta=0.35
+        )
+        expect(node, inputs=[a, b, c], outputs=[y], name="test_gemm_all_attributes")
diff --git a/onnx/backend/test/case/node/globalaveragepool.py b/onnx/backend/test/case/node/globalaveragepool.py
new file mode 100644
index 0000000..eaab769
--- /dev/null
+++ b/onnx/backend/test/case/node/globalaveragepool.py
@@ -0,0 +1,44 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class GlobalAveragePool(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "GlobalAveragePool",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(1, 3, 5, 5).astype(np.float32)
+        y = np.mean(x, axis=tuple(range(2, np.ndim(x))), keepdims=True)
+        expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool")
+
+    @staticmethod
+    def export_globalaveragepool_precomputed() -> None:
+        node = onnx.helper.make_node(
+            "GlobalAveragePool",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3],
+                        [4, 5, 6],
+                        [7, 8, 9],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[5]]]]).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_globalaveragepool_precomputed")
diff --git a/onnx/backend/test/case/node/globalmaxpool.py b/onnx/backend/test/case/node/globalmaxpool.py
new file mode 100644
index 0000000..9e7e94b
--- /dev/null
+++ b/onnx/backend/test/case/node/globalmaxpool.py
@@ -0,0 +1,44 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class GlobalMaxPool(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "GlobalMaxPool",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(1, 3, 5, 5).astype(np.float32)
+        y = np.max(x, axis=tuple(range(2, np.ndim(x))), keepdims=True)
+        expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool")
+
+    @staticmethod
+    def export_globalmaxpool_precomputed() -> None:
+        node = onnx.helper.make_node(
+            "GlobalMaxPool",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3],
+                        [4, 5, 6],
+                        [7, 8, 9],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[9]]]]).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_globalmaxpool_precomputed")
diff --git a/onnx/backend/test/case/node/greater.py b/onnx/backend/test/case/node/greater.py
new file mode 100644
index 0000000..958b698
--- /dev/null
+++ b/onnx/backend/test/case/node/greater.py
@@ -0,0 +1,68 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Greater(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Greater",
+            inputs=["x", "y"],
+            outputs=["greater"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(3, 4, 5).astype(np.float32)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater")
+
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.random.randn(3, 4, 5).astype(np.int8)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_int8")
+
+        x = np.random.randn(3, 4, 5).astype(np.int16)
+        y = np.random.randn(3, 4, 5).astype(np.int16)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_uint64")
+
+    @staticmethod
+    def export_greater_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Greater",
+            inputs=["x", "y"],
+            outputs=["greater"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(5).astype(np.float32)
+        z = np.greater(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_bcast")
diff --git a/onnx/backend/test/case/node/greater_equal.py b/onnx/backend/test/case/node/greater_equal.py
new file mode 100644
index 0000000..e346602
--- /dev/null
+++ b/onnx/backend/test/case/node/greater_equal.py
@@ -0,0 +1,68 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Greater(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "GreaterOrEqual",
+            inputs=["x", "y"],
+            outputs=["greater_equal"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(3, 4, 5).astype(np.float32)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal")
+
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.random.randn(3, 4, 5).astype(np.int8)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int8")
+
+        x = np.random.randn(3, 4, 5).astype(np.int16)
+        y = np.random.randn(3, 4, 5).astype(np.int16)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_uint64")
+
+    @staticmethod
+    def export_greater_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "GreaterOrEqual",
+            inputs=["x", "y"],
+            outputs=["greater_equal"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(5).astype(np.float32)
+        z = np.greater_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_greater_equal_bcast")
diff --git a/onnx/backend/test/case/node/gridsample.py b/onnx/backend/test/case/node/gridsample.py
new file mode 100644
index 0000000..26ecc83
--- /dev/null
+++ b/onnx/backend/test/case/node/gridsample.py
@@ -0,0 +1,642 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class GridSample(Base):
+    @staticmethod
+    def export_gridsample() -> None:
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="linear",
+            padding_mode="zeros",
+            align_corners=0,
+        )
+        # X shape, [N, C, H, W] - [1, 1, 4, 4]
+        X = np.array(
+            [
+                [
+                    [
+                        [0.0, 1.0, 2.0, 3.0],
+                        [4.0, 5.0, 6.0, 7.0],
+                        [8.0, 9.0, 10.0, 11.0],
+                        [12.0, 13.0, 14.0, 15.0],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+        # Grid shape, [N, H_out, W_out, 2] - [1, 6, 6, 2]
+        Grid = np.array(
+            [
+                [
+                    [
+                        [-1.0000, -1.0000],
+                        [-0.6000, -1.0000],
+                        [-0.2000, -1.0000],
+                        [0.2000, -1.0000],
+                        [0.6000, -1.0000],
+                        [1.0000, -1.0000],
+                    ],
+                    [
+                        [-1.0000, -0.6000],
+                        [-0.6000, -0.6000],
+                        [-0.2000, -0.6000],
+                        [0.2000, -0.6000],
+                        [0.6000, -0.6000],
+                        [1.0000, -0.6000],
+                    ],
+                    [
+                        [-1.0000, -0.2000],
+                        [-0.6000, -0.2000],
+                        [-0.2000, -0.2000],
+                        [0.2000, -0.2000],
+                        [0.6000, -0.2000],
+                        [1.0000, -0.2000],
+                    ],
+                    [
+                        [-1.0000, 0.2000],
+                        [-0.6000, 0.2000],
+                        [-0.2000, 0.2000],
+                        [0.2000, 0.2000],
+                        [0.6000, 0.2000],
+                        [1.0000, 0.2000],
+                    ],
+                    [
+                        [-1.0000, 0.6000],
+                        [-0.6000, 0.6000],
+                        [-0.2000, 0.6000],
+                        [0.2000, 0.6000],
+                        [0.6000, 0.6000],
+                        [1.0000, 0.6000],
+                    ],
+                    [
+                        [-1.0000, 1.0000],
+                        [-0.6000, 1.0000],
+                        [-0.2000, 1.0000],
+                        [0.2000, 1.0000],
+                        [0.6000, 1.0000],
+                        [1.0000, 1.0000],
+                    ],
+                ]
+            ],
+            dtype=np.float32,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 6, 6]
+        Y = np.array(
+            [
+                [
+                    [
+                        [0.0000, 0.1500, 0.5500, 0.9500, 1.3500, 0.7500],
+                        [0.6000, 1.5000, 2.3000, 3.1000, 3.9000, 2.1000],
+                        [2.2000, 4.7000, 5.5000, 6.3000, 7.1000, 3.7000],
+                        [3.8000, 7.9000, 8.7000, 9.5000, 10.3000, 5.3000],
+                        [5.4000, 11.1000, 11.9000, 12.7000, 13.5000, 6.9000],
+                        [3.0000, 6.1500, 6.5500, 6.9500, 7.3500, 3.7500],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+        expect(node, inputs=[X, Grid], outputs=[Y], name="test_gridsample")
+
+    @staticmethod
+    def export_gridsample_paddingmode() -> None:
+        # X shape, [N, C, H, W] - [1, 1, 3, 2]
+        X = np.array(
+            [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]],
+            dtype=np.float32,
+        )
+        # Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2]
+        Grid = np.array(
+            [
+                [
+                    [
+                        [-10.0000, -10.0000],
+                        [-5.0000, -5.0000],
+                        [-0.2000, -0.2000],
+                        [10.0000, 10.0000],
+                    ],
+                    [
+                        [10.0000, 10.0000],
+                        [-0.2000, -0.2000],
+                        [5.0000, 5.0000],
+                        [10.0000, 10.0000],
+                    ],
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        # setting padding_mode = 'zeros'
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            padding_mode="zeros",
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_zeros = np.array(
+            [[[[0.0000, 0.0000, 1.7000, 0.0000], [0.0000, 1.7000, 0.0000, 0.0000]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_zeros],
+            name="test_gridsample_zeros_padding",
+        )
+
+        # setting padding_mode = 'border'
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            padding_mode="border",
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_border = np.array(
+            [[[[0.0000, 0.0000, 1.7000, 5.0000], [5.0000, 1.7000, 5.0000, 5.0000]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_border],
+            name="test_gridsample_border_padding",
+        )
+
+        # setting padding_mode = 'reflection'
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            padding_mode="reflection",
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_reflection = np.array(
+            [[[[2.5000, 0.0000, 1.7000, 2.5000], [2.5000, 1.7000, 5.0000, 2.5000]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_reflection],
+            name="test_gridsample_reflection_padding",
+        )
+
+    @staticmethod
+    def export_gridsample_mode_aligncorners() -> None:
+        # X shape, [N, C, H, W] - [1, 1, 3, 2]
+        X = np.array(
+            [[[[0.0, 1.0], [2.0, 3.0], [4.0, 5.0]]]],
+            dtype=np.float32,
+        )
+        # Grid shape, [N, H_out, W_out, 2] - [1, 2, 4, 2]
+        Grid = np.array(
+            [
+                [
+                    [
+                        [-1.0000, -1.0000],
+                        [-0.5000, -0.5000],
+                        [-0.2000, -0.2000],
+                        [0.0000, 0.0000],
+                    ],
+                    [
+                        [0.0000, 0.0000],
+                        [-0.2000, -0.2000],
+                        [0.5000, 0.5000],
+                        [1.0000, 1.0000],
+                    ],
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        # setting mode = 'bilinear', default align_corners = 0
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="linear",
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_bilinear = np.array(
+            [[[[0.0000, 0.5000, 1.7000, 2.5000], [2.5000, 1.7000, 4.5000, 1.2500]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_bilinear],
+            name="test_gridsample_bilinear",
+        )
+
+        # setting mode = 'bilinear', align_corners = 1
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="linear",
+            align_corners=1,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_align_corners = np.array(
+            [[[[0.0000, 1.2500, 2.0000, 2.5000], [2.5000, 2.0000, 3.7500, 5.0000]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_align_corners],
+            name="test_gridsample_aligncorners_true",
+        )
+
+        # setting mode = 'nearest'
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="nearest",
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_nearest = np.array(
+            [[[[0.0, 0.0, 2.0, 2.0], [2.0, 2.0, 5.0, 0.0]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node, inputs=[X, Grid], outputs=[Y_nearest], name="test_gridsample_nearest"
+        )
+
+        # setting mode = 'bicubic'
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="cubic",
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_bicubic = np.array(
+            [[[[-0.1406, 0.3828, 1.7556, 2.9688], [2.9688, 1.7556, 5.1445, 1.3906]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node, inputs=[X, Grid], outputs=[Y_bicubic], name="test_gridsample_bicubic"
+        )
+
+        # ============================================================================
+        # Additional tests
+        # The reference output tensors were generated using PyTorch 2.0.
+        Grid = np.array(
+            [
+                [
+                    [[-1.0, -0.8], [-0.6, -0.5], [-0.1, -0.2], [0.7, 0.0]],
+                    [[0.0, 0.4], [0.2, -0.2], [-0.3, 0.5], [-1.0, 1.0]],
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="nearest",
+            align_corners=0,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_nearest = np.array(
+            [[[[0.0, 0.0, 2.0, 3.0], [4.0, 3.0, 4.0, 4.0]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_nearest],
+            name="test_gridsample_nearest_align_corners_0_additional_1",
+        )
+
+        # setting mode = 'nearest'
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="nearest",
+            align_corners=1,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_nearest = np.array(
+            [[[[0.0, 0.0, 2.0, 3.0], [2.0, 3.0, 4.0, 4.0]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_nearest],
+            name="test_gridsample_nearest_align_corners_1_additional_1",
+        )
+
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="linear",
+            align_corners=0,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_bilinear = np.array(
+            [[[[0.0000, 0.4500, 1.8000, 2.4000], [3.7000, 2.1000, 3.7000, 1.0000]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_bilinear],
+            name="test_gridsample_bilinear_align_corners_0_additional_1",
+        )
+
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="linear",
+            align_corners=1,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_bilinear = np.array(
+            [[[[0.4000, 1.2000, 2.0500, 2.8500], [3.3000, 2.2000, 3.3500, 4.0000]]]],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_bilinear],
+            name="test_gridsample_bilinear_align_corners_1_additional_1",
+        )
+
+        # These two new bicubic tests produces slightly higher error ~5e-5
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="cubic",
+            align_corners=0,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_bicubic = np.array(
+            [
+                [
+                    [
+                        [-0.173250, 0.284265, 1.923106, 2.568000],
+                        [5.170375, 2.284414, 4.744844, 1.046875],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_bicubic],
+            name="test_gridsample_bicubic_align_corners_0_additional_1",
+        )
+
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="cubic",
+            align_corners=1,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_bicubic = np.array(
+            [
+                [
+                    [
+                        [0.304001, 1.128750, 2.266270, 3.144844],
+                        [4.531500, 2.455360, 4.599819, 4.000000],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_bicubic],
+            name="test_gridsample_bicubic_align_corners_1_additional_1",
+        )
+
+    @staticmethod
+    def export_volumeetric_gridsample_mode_aligncorners() -> None:
+        X = np.array(
+            [
+                [
+                    [
+                        [[1.0, 2.0], [3.0, 4.0]],
+                        [[5.0, 6.0], [7.0, 8.0]],
+                        [[9.0, 10.0], [11.0, 12.0]],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        Grid = np.array(
+            [
+                [
+                    [
+                        [[-1.0, -1.0, -1.0], [-1.0, -0.5, 0.3]],
+                        [[-0.5, -0.5, -0.5], [1.0, -0.6, -1.0]],
+                        [[-0.2, -0.2, -0.2], [0.4, 0.2, 0.6]],
+                        [[0.0, 0.0, 0.0], [-1.0, 0.0, 0.0]],
+                    ],
+                    [
+                        [[0.0, 0.0, 0.0], [-1.0, 1.0, 0.0]],
+                        [[-0.2, -0.2, -0.2], [1.0, 0.4, -0.2]],
+                        [[0.5, 0.5, 0.5], [-1.0, -0.8, 0.8]],
+                        [[1.0, 1.0, 1.0], [0.4, 0.6, -0.3]],
+                    ],
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="nearest",
+            align_corners=0,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_nearest = np.array(
+            [
+                [
+                    [
+                        [[1.0, 5.0], [1.0, 0.0], [5.0, 12.0], [5.0, 5.0]],
+                        [[5.0, 0.0], [5.0, 0.0], [12.0, 9.0], [0.0, 8.0]],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_nearest],
+            name="test_gridsample_volumetric_nearest_align_corners_0",
+        )
+
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="nearest",
+            align_corners=1,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_nearest = np.array(
+            [
+                [
+                    [
+                        [[1.0, 5.0], [1.0, 2.0], [5.0, 12.0], [5.0, 5.0]],
+                        [[5.0, 7.0], [5.0, 8.0], [12.0, 9.0], [12.0, 8.0]],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_nearest],
+            name="test_gridsample_volumetric_nearest_align_corners_1",
+        )
+
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="linear",
+            align_corners=0,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_bilinear = np.array(
+            [
+                [
+                    [
+                        [
+                            [0.1250, 3.4000],
+                            [2.0000, 0.4500],
+                            [4.7000, 10.9000],
+                            [6.5000, 3.0000],
+                        ],
+                        [
+                            [6.5000, 1.7500],
+                            [4.7000, 3.3000],
+                            [11.0000, 2.5200],
+                            [1.5000, 5.4900],
+                        ],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_bilinear],
+            name="test_gridsample_volumetric_bilinear_align_corners_0",
+        )
+
+        node = onnx.helper.make_node(
+            "GridSample",
+            inputs=["X", "Grid"],
+            outputs=["Y"],
+            mode="linear",
+            align_corners=1,
+        )
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 2, 4]
+        Y_bilinear = np.array(
+            [
+                [
+                    [
+                        [
+                            [1.0000, 6.7000],
+                            [3.7500, 2.4000],
+                            [5.4000, 9.3000],
+                            [6.5000, 6.0000],
+                        ],
+                        [
+                            [6.5000, 7.0000],
+                            [5.4000, 6.6000],
+                            [9.2500, 8.4000],
+                            [12.0000, 6.1000],
+                        ],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, Grid],
+            outputs=[Y_bilinear],
+            name="test_gridsample_volumetric_bilinear_align_corners_1",
+        )
+
+    """
+    For someone who want to test by script. Comment it cause github ONNX CI
+    do not have the torch python package.
+    @staticmethod
+    def export_gridsample_torch():  # type: () -> None
+        node = onnx.helper.make_node(
+            'GridSample',
+            inputs=['X', 'Grid'],
+            outputs=['Y'],
+            mode='bilinear',
+            padding_mode='zeros',
+            align_corners=0,
+        )
+
+        # X shape, [N, C, H, W] - [1, 1, 4, 4]
+        # Grid shape, [N, H_out, W_out, 2] - [1, 6, 6, 2]
+        # Y shape, [N, C, H_out, W_out] - [1, 1, 6, 6]
+        import torch
+        X = torch.arange(3 * 3).view(1, 1, 3, 3).float()
+        d = torch.linspace(-1, 1, 6)
+        meshx, meshy = torch.meshgrid((d, d))
+        grid = torch.stack((meshy, meshx), 2)
+        Grid = grid.unsqueeze(0)
+        Y = torch.nn.functional.grid_sample(X, Grid, mode='bilinear',
+                                            padding_mode='zeros', align_corners=False)
+        expect(node, inputs=[X.numpy(), Grid.numpy()], outputs=[Y.numpy()],
+               name='test_gridsample_torch')
+    """
diff --git a/onnx/backend/test/case/node/groupnormalization.py b/onnx/backend/test/case/node/groupnormalization.py
new file mode 100644
index 0000000..69a7909
--- /dev/null
+++ b/onnx/backend/test/case/node/groupnormalization.py
@@ -0,0 +1,78 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+# Group normalization's reference implementation
+def _group_normalization(x, num_groups, scale, bias, epsilon=1e-5):
+    # Assume channel is first dim
+    assert x.shape[1] % num_groups == 0
+    group_size = x.shape[1] // num_groups
+    # Reshape to [N, group_size, C/group_size, H, W, ...]
+    new_shape = [x.shape[0], num_groups, group_size, *list(x.shape[2:])]
+    x_reshaped = x.reshape(new_shape)
+    axes = tuple(range(2, len(new_shape)))
+    mean = np.mean(x_reshaped, axis=axes, keepdims=True)
+    var = np.var(x_reshaped, axis=axes, keepdims=True)
+    x_normalized = ((x_reshaped - mean) / np.sqrt(var + epsilon)).reshape(x.shape)
+    dim_ones = (1,) * (len(x.shape) - 2)
+    scale = scale.reshape(-1, *dim_ones)
+    bias = bias.reshape(-1, *dim_ones)
+    return scale * x_normalized + bias
+
+
+class GroupNormalization(Base):
+    @staticmethod
+    def export() -> None:
+        c = 4
+        num_groups = 2
+        x = np.random.randn(3, c, 2, 2).astype(np.float32)
+        scale = np.random.randn(c).astype(np.float32)
+        bias = np.random.randn(c).astype(np.float32)
+        y = _group_normalization(x, num_groups, scale, bias).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "GroupNormalization",
+            inputs=["x", "scale", "bias"],
+            outputs=["y"],
+            num_groups=num_groups,
+        )
+
+        expect(
+            node,
+            inputs=[x, scale, bias],
+            outputs=[y],
+            name="test_group_normalization_example",
+        )
+
+    @staticmethod
+    def export_epsilon() -> None:
+        c = 4
+        num_groups = 2
+        x = np.random.randn(3, c, 2, 2).astype(np.float32)
+        scale = np.random.randn(c).astype(np.float32)
+        bias = np.random.randn(c).astype(np.float32)
+        epsilon = 1e-2
+        y = _group_normalization(x, num_groups, scale, bias, epsilon).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "GroupNormalization",
+            inputs=["x", "scale", "bias"],
+            outputs=["y"],
+            epsilon=epsilon,
+            num_groups=num_groups,
+        )
+
+        expect(
+            node,
+            inputs=[x, scale, bias],
+            outputs=[y],
+            name="test_group_normalization_epsilon",
+        )
diff --git a/onnx/backend/test/case/node/gru.py b/onnx/backend/test/case/node/gru.py
new file mode 100644
index 0000000..4ff29fc
--- /dev/null
+++ b/onnx/backend/test/case/node/gru.py
@@ -0,0 +1,264 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class GRUHelper:
+    def __init__(self, **params: Any) -> None:
+        # GRU Input Names
+        X = "X"
+        W = "W"
+        R = "R"
+        B = "B"
+        H_0 = "initial_h"
+        LBR = "linear_before_reset"
+        LAYOUT = "layout"
+        number_of_gates = 3
+
+        required_inputs = [X, W, R]
+        for i in required_inputs:
+            assert i in params, f"Missing Required Input: {i}"
+
+        self.num_directions = params[W].shape[0]
+
+        if self.num_directions == 1:
+            for k, v in params.items():
+                if k != X:
+                    params[k] = np.squeeze(v, axis=0)
+
+            hidden_size = params[R].shape[-1]
+            batch_size = params[X].shape[1]
+
+            layout = params.get(LAYOUT, 0)
+            x = params[X]
+            x = x if layout == 0 else np.swapaxes(x, 0, 1)
+            b = (
+                params[B]
+                if B in params
+                else np.zeros(2 * number_of_gates * hidden_size)
+            )
+            h_0 = params[H_0] if H_0 in params else np.zeros((batch_size, hidden_size))
+            lbr = params.get(LBR, 0)
+
+            self.X = x
+            self.W = params[W]
+            self.R = params[R]
+            self.B = b
+            self.H_0 = h_0
+            self.LBR = lbr
+            self.LAYOUT = layout
+
+        else:
+            raise NotImplementedError
+
+    def f(self, x: np.ndarray) -> np.ndarray:
+        return 1 / (1 + np.exp(-x))
+
+    def g(self, x: np.ndarray) -> np.ndarray:
+        return np.tanh(x)
+
+    def step(self) -> tuple[np.ndarray, np.ndarray]:
+        seq_length = self.X.shape[0]
+        hidden_size = self.H_0.shape[-1]
+        batch_size = self.X.shape[1]
+
+        Y = np.empty([seq_length, self.num_directions, batch_size, hidden_size])
+        h_list = []
+
+        [w_z, w_r, w_h] = np.split(self.W, 3)
+        [r_z, r_r, r_h] = np.split(self.R, 3)
+        [w_bz, w_br, w_bh, r_bz, r_br, r_bh] = np.split(self.B, 6)
+        gates_w = np.transpose(np.concatenate((w_z, w_r)))
+        gates_r = np.transpose(np.concatenate((r_z, r_r)))
+        gates_b = np.add(np.concatenate((w_bz, w_br)), np.concatenate((r_bz, r_br)))
+
+        H_t = self.H_0
+        for x in np.split(self.X, self.X.shape[0], axis=0):
+            gates = np.dot(x, gates_w) + np.dot(H_t, gates_r) + gates_b
+            z, r = np.split(gates, 2, -1)
+            z = self.f(z)
+            r = self.f(r)
+            h_default = self.g(
+                np.dot(x, np.transpose(w_h))
+                + np.dot(r * H_t, np.transpose(r_h))
+                + w_bh
+                + r_bh
+            )
+            h_linear = self.g(
+                np.dot(x, np.transpose(w_h))
+                + r * (np.dot(H_t, np.transpose(r_h)) + r_bh)
+                + w_bh
+            )
+            h = h_linear if self.LBR else h_default
+            H = (1 - z) * h + z * H_t
+            h_list.append(H)
+            H_t = H
+
+        concatenated = np.concatenate(h_list)
+        if self.num_directions == 1:
+            Y[:, 0, :, :] = concatenated
+
+        if self.LAYOUT == 0:
+            Y_h = Y[-1]
+        else:
+            Y = np.transpose(Y, [2, 0, 1, 3])
+            Y_h = Y[:, :, -1, :]
+
+        return Y, Y_h
+
+
+class GRU(Base):
+    @staticmethod
+    def export_defaults() -> None:
+        input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32)
+
+        input_size = 2
+        hidden_size = 5
+        weight_scale = 0.1
+        number_of_gates = 3
+
+        node = onnx.helper.make_node(
+            "GRU", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size
+        )
+
+        W = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, input_size)
+        ).astype(np.float32)
+        R = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, hidden_size)
+        ).astype(np.float32)
+
+        gru = GRUHelper(X=input, W=W, R=R)
+        _, Y_h = gru.step()
+        expect(
+            node,
+            inputs=[input, W, R],
+            outputs=[Y_h.astype(np.float32)],
+            name="test_gru_defaults",
+        )
+
+    @staticmethod
+    def export_initial_bias() -> None:
+        input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype(
+            np.float32
+        )
+
+        input_size = 3
+        hidden_size = 3
+        weight_scale = 0.1
+        custom_bias = 0.1
+        number_of_gates = 3
+
+        node = onnx.helper.make_node(
+            "GRU",
+            inputs=["X", "W", "R", "B"],
+            outputs=["", "Y_h"],
+            hidden_size=hidden_size,
+        )
+
+        W = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, input_size)
+        ).astype(np.float32)
+        R = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, hidden_size)
+        ).astype(np.float32)
+
+        # Adding custom bias
+        W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype(
+            np.float32
+        )
+        R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32)
+        B = np.concatenate((W_B, R_B), axis=1)
+
+        gru = GRUHelper(X=input, W=W, R=R, B=B)
+        _, Y_h = gru.step()
+        expect(
+            node,
+            inputs=[input, W, R, B],
+            outputs=[Y_h.astype(np.float32)],
+            name="test_gru_with_initial_bias",
+        )
+
+    @staticmethod
+    def export_seq_length() -> None:
+        input = np.array(
+            [
+                [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
+                [[10.0, 11.0, 12.0], [13.0, 14.0, 15.0], [16.0, 17.0, 18.0]],
+            ]
+        ).astype(np.float32)
+
+        input_size = 3
+        hidden_size = 5
+        number_of_gates = 3
+
+        node = onnx.helper.make_node(
+            "GRU",
+            inputs=["X", "W", "R", "B"],
+            outputs=["", "Y_h"],
+            hidden_size=hidden_size,
+        )
+
+        W = np.random.randn(1, number_of_gates * hidden_size, input_size).astype(
+            np.float32
+        )
+        R = np.random.randn(1, number_of_gates * hidden_size, hidden_size).astype(
+            np.float32
+        )
+
+        # Adding custom bias
+        W_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32)
+        R_B = np.random.randn(1, number_of_gates * hidden_size).astype(np.float32)
+        B = np.concatenate((W_B, R_B), axis=1)
+
+        gru = GRUHelper(X=input, W=W, R=R, B=B)
+        _, Y_h = gru.step()
+        expect(
+            node,
+            inputs=[input, W, R, B],
+            outputs=[Y_h.astype(np.float32)],
+            name="test_gru_seq_length",
+        )
+
+    @staticmethod
+    def export_batchwise() -> None:
+        input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32)
+
+        input_size = 2
+        hidden_size = 6
+        number_of_gates = 3
+        weight_scale = 0.2
+        layout = 1
+
+        node = onnx.helper.make_node(
+            "GRU",
+            inputs=["X", "W", "R"],
+            outputs=["Y", "Y_h"],
+            hidden_size=hidden_size,
+            layout=layout,
+        )
+
+        W = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, input_size)
+        ).astype(np.float32)
+        R = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, hidden_size)
+        ).astype(np.float32)
+
+        gru = GRUHelper(X=input, W=W, R=R, layout=layout)
+        Y, Y_h = gru.step()
+        expect(
+            node,
+            inputs=[input, W, R],
+            outputs=[Y.astype(np.float32), Y_h.astype(np.float32)],
+            name="test_gru_batchwise",
+        )
diff --git a/onnx/backend/test/case/node/hammingwindow.py b/onnx/backend/test/case/node/hammingwindow.py
new file mode 100644
index 0000000..7cd3bf5
--- /dev/null
+++ b/onnx/backend/test/case/node/hammingwindow.py
@@ -0,0 +1,48 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class HammingWindow(Base):
+    @staticmethod
+    def export() -> None:
+        # Test periodic window
+        node = onnx.helper.make_node(
+            "HammingWindow",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        size = np.int32(10)
+        a0 = 25 / 46
+        a1 = 1 - a0
+        y = a0 - a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+        expect(
+            node,
+            inputs=[size],
+            outputs=[y.astype(np.float32)],
+            name="test_hammingwindow",
+        )
+
+        # Test symmetric window
+        node = onnx.helper.make_node(
+            "HammingWindow", inputs=["x"], outputs=["y"], periodic=0
+        )
+        size = np.int32(10)
+        a0 = 25 / 46
+        a1 = 1 - a0
+        y = a0 - a1 * np.cos(
+            2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+        )
+        expect(
+            node,
+            inputs=[size],
+            outputs=[y.astype(np.float32)],
+            name="test_hammingwindow_symmetric",
+        )
diff --git a/onnx/backend/test/case/node/hannwindow.py b/onnx/backend/test/case/node/hannwindow.py
new file mode 100644
index 0000000..ba41c4a
--- /dev/null
+++ b/onnx/backend/test/case/node/hannwindow.py
@@ -0,0 +1,45 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class HannWindow(Base):
+    @staticmethod
+    def export() -> None:
+        # Test periodic window
+        node = onnx.helper.make_node(
+            "HannWindow",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        size = np.int32(10)
+        a0 = 0.5
+        a1 = 0.5
+        y = a0 - a1 * np.cos(2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / size)
+        expect(
+            node, inputs=[size], outputs=[y.astype(np.float32)], name="test_hannwindow"
+        )
+
+        # Test symmetric window
+        node = onnx.helper.make_node(
+            "HannWindow", inputs=["x"], outputs=["y"], periodic=0
+        )
+        size = np.int32(10)
+        a0 = 0.5
+        a1 = 0.5
+        y = a0 - a1 * np.cos(
+            2 * np.pi * np.arange(0, size, 1, dtype=np.float32) / (size - 1)
+        )
+        expect(
+            node,
+            inputs=[size],
+            outputs=[y.astype(np.float32)],
+            name="test_hannwindow_symmetric",
+        )
diff --git a/onnx/backend/test/case/node/hardmax.py b/onnx/backend/test/case/node/hardmax.py
new file mode 100644
index 0000000..4af4592
--- /dev/null
+++ b/onnx/backend/test/case/node/hardmax.py
@@ -0,0 +1,92 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def hardmax(x: np.ndarray, axis: int = -1) -> np.ndarray:
+    x_argmax = np.argmax(x, axis=axis)
+    y = np.zeros_like(x)
+    np.put_along_axis(y, np.expand_dims(x_argmax, axis=axis), 1, axis=axis)
+    return y
+
+
+class Hardmax(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Hardmax",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([[3, 0, 1, 2], [2, 5, 1, 0], [0, 1, 3, 2], [0, 1, 2, 3]]).astype(
+            np.float32
+        )
+        # expect result:
+        # [[1. 0. 0. 0.]
+        # [0. 1. 0. 0.]
+        # [0. 0. 1. 0.]
+        # [0. 0. 0. 1.]]
+        y = hardmax(x)
+        expect(node, inputs=[x], outputs=[y], name="test_hardmax_example")
+
+        # For multiple occurrences of the maximal values, the first occurrence is selected for one-hot output
+        x = np.array([[3, 3, 3, 1]]).astype(np.float32)
+        # expect result:
+        # [[1, 0, 0, 0]]
+        y = hardmax(x)
+        expect(node, inputs=[x], outputs=[y], name="test_hardmax_one_hot")
+
+    @staticmethod
+    def export_hardmax_axis() -> None:
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        node = onnx.helper.make_node(
+            "Hardmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=0,
+        )
+        y = hardmax(x, axis=0)
+        expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_0")
+
+        node = onnx.helper.make_node(
+            "Hardmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=1,
+        )
+        y = hardmax(x, axis=1)
+        expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_1")
+
+        node = onnx.helper.make_node(
+            "Hardmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=2,
+        )
+        y = hardmax(x, axis=2)
+        expect(node, inputs=[x], outputs=[y], name="test_hardmax_axis_2")
+
+        node = onnx.helper.make_node(
+            "Hardmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=-1,
+        )
+        y = hardmax(x, axis=-1)
+        expect(node, inputs=[x], outputs=[y], name="test_hardmax_negative_axis")
+
+        # default axis is -1
+        node = onnx.helper.make_node(
+            "Hardmax",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        expect(node, inputs=[x], outputs=[y], name="test_hardmax_default_axis")
diff --git a/onnx/backend/test/case/node/hardsigmoid.py b/onnx/backend/test/case/node/hardsigmoid.py
new file mode 100644
index 0000000..f788141
--- /dev/null
+++ b/onnx/backend/test/case/node/hardsigmoid.py
@@ -0,0 +1,39 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class HardSigmoid(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "HardSigmoid", inputs=["x"], outputs=["y"], alpha=0.5, beta=0.6
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.clip(x * 0.5 + 0.6, 0, 1)  # expected output [0.1, 0.6, 1.]
+        expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x * 0.5 + 0.6, 0, 1)
+        expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid")
+
+    @staticmethod
+    def export_hardsigmoid_default() -> None:
+        default_alpha = 0.2
+        default_beta = 0.5
+        node = onnx.helper.make_node(
+            "HardSigmoid",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x * default_alpha + default_beta, 0, 1)
+        expect(node, inputs=[x], outputs=[y], name="test_hardsigmoid_default")
diff --git a/onnx/backend/test/case/node/hardswish.py b/onnx/backend/test/case/node/hardswish.py
new file mode 100644
index 0000000..72dd675
--- /dev/null
+++ b/onnx/backend/test/case/node/hardswish.py
@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def hardswish(x: np.ndarray) -> np.ndarray:
+    alfa = float(1 / 6)
+    beta = 0.5
+    return x * np.maximum(0, np.minimum(1, alfa * x + beta))
+
+
+class HardSwish(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "HardSwish",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = hardswish(x)
+
+        expect(node, inputs=[x], outputs=[y], name="test_hardswish")
diff --git a/onnx/backend/test/case/node/identity.py b/onnx/backend/test/case/node/identity.py
new file mode 100644
index 0000000..d399ae9
--- /dev/null
+++ b/onnx/backend/test/case/node/identity.py
@@ -0,0 +1,93 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Identity(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Identity",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        expect(node, inputs=[data], outputs=[data], name="test_identity")
+
+    @staticmethod
+    def export_sequence() -> None:
+        node = onnx.helper.make_node(
+            "Identity",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        data = [
+            np.array(
+                [
+                    [
+                        [
+                            [1, 2],
+                            [3, 4],
+                        ]
+                    ]
+                ],
+                dtype=np.float32,
+            ),
+            np.array(
+                [
+                    [
+                        [
+                            [2, 3],
+                            [1, 5],
+                        ]
+                    ]
+                ],
+                dtype=np.float32,
+            ),
+        ]
+
+        expect(node, inputs=[data], outputs=[data], name="test_identity_sequence")
+
+    @staticmethod
+    def export_identity_opt() -> None:
+        ten_in_tp = onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.FLOAT, shape=[5]
+        )
+        seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp)
+        opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp)
+
+        identity_node = onnx.helper.make_node(
+            "Identity", inputs=["opt_in"], outputs=["opt_out"]
+        )
+
+        x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)]
+
+        expect(
+            identity_node,
+            inputs=[x],
+            outputs=[x],
+            name="test_identity_opt",
+            opset_imports=[onnx.helper.make_opsetid("", 16)],
+            input_type_protos=[opt_in_tp],
+            output_type_protos=[opt_in_tp],
+        )
diff --git a/onnx/backend/test/case/node/if_.py b/onnx/backend/test/case/node/if_.py
new file mode 100644
index 0000000..d22c8a0
--- /dev/null
+++ b/onnx/backend/test/case/node/if_.py
@@ -0,0 +1,210 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def compute_if_outputs(x, cond):
+    if cond:
+        return []
+    return x
+
+
+class If(Base):
+    @staticmethod
+    def export_if() -> None:
+        # Given a bool scalar input cond.
+        # return constant tensor x if cond is True, otherwise return constant tensor y.
+
+        then_out = onnx.helper.make_tensor_value_info(
+            "then_out", onnx.TensorProto.FLOAT, [5]
+        )
+        else_out = onnx.helper.make_tensor_value_info(
+            "else_out", onnx.TensorProto.FLOAT, [5]
+        )
+
+        x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+        y = np.array([5, 4, 3, 2, 1]).astype(np.float32)
+
+        then_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["then_out"],
+            value=onnx.numpy_helper.from_array(x),
+        )
+
+        else_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["else_out"],
+            value=onnx.numpy_helper.from_array(y),
+        )
+
+        then_body = onnx.helper.make_graph(
+            [then_const_node], "then_body", [], [then_out]
+        )
+
+        else_body = onnx.helper.make_graph(
+            [else_const_node], "else_body", [], [else_out]
+        )
+
+        if_node = onnx.helper.make_node(
+            "If",
+            inputs=["cond"],
+            outputs=["res"],
+            then_branch=then_body,
+            else_branch=else_body,
+        )
+
+        cond = np.array(1).astype(bool)
+        res = x if cond else y
+        expect(
+            if_node,
+            inputs=[cond],
+            outputs=[res],
+            name="test_if",
+            opset_imports=[onnx.helper.make_opsetid("", 11)],
+        )
+
+    @staticmethod
+    def export_if_seq() -> None:
+        # Given a bool scalar input cond.
+        # return constant sequence x if cond is True, otherwise return constant sequence y.
+
+        then_out = onnx.helper.make_tensor_sequence_value_info(
+            "then_out", onnx.TensorProto.FLOAT, shape=[5]
+        )
+        else_out = onnx.helper.make_tensor_sequence_value_info(
+            "else_out", onnx.TensorProto.FLOAT, shape=[5]
+        )
+
+        x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)]
+        y = [np.array([5, 4, 3, 2, 1]).astype(np.float32)]
+
+        then_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["x"],
+            value=onnx.numpy_helper.from_array(x[0]),
+        )
+
+        then_seq_node = onnx.helper.make_node(
+            "SequenceConstruct", inputs=["x"], outputs=["then_out"]
+        )
+
+        else_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["y"],
+            value=onnx.numpy_helper.from_array(y[0]),
+        )
+
+        else_seq_node = onnx.helper.make_node(
+            "SequenceConstruct", inputs=["y"], outputs=["else_out"]
+        )
+
+        then_body = onnx.helper.make_graph(
+            [then_const_node, then_seq_node], "then_body", [], [then_out]
+        )
+
+        else_body = onnx.helper.make_graph(
+            [else_const_node, else_seq_node], "else_body", [], [else_out]
+        )
+
+        if_node = onnx.helper.make_node(
+            "If",
+            inputs=["cond"],
+            outputs=["res"],
+            then_branch=then_body,
+            else_branch=else_body,
+        )
+
+        cond = np.array(1).astype(bool)
+        res = x if cond else y
+        expect(
+            if_node,
+            inputs=[cond],
+            outputs=[res],
+            name="test_if_seq",
+            opset_imports=[onnx.helper.make_opsetid("", 13)],
+        )
+
+    @staticmethod
+    def export_if_optional() -> None:
+        # Given a bool scalar input cond, return an empty optional sequence of
+        # tensor if True, return an optional sequence with value x
+        # (the input optional sequence) otherwise.
+
+        ten_in_tp = onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.FLOAT, shape=[5]
+        )
+        seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp)
+
+        then_out_tensor_tp = onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.FLOAT, shape=[5]
+        )
+        then_out_seq_tp = onnx.helper.make_sequence_type_proto(then_out_tensor_tp)
+        then_out_opt_tp = onnx.helper.make_optional_type_proto(then_out_seq_tp)
+        then_out = onnx.helper.make_value_info("optional_empty", then_out_opt_tp)
+
+        else_out_tensor_tp = onnx.helper.make_tensor_type_proto(
+            onnx.TensorProto.FLOAT, shape=[5]
+        )
+        else_out_seq_tp = onnx.helper.make_sequence_type_proto(else_out_tensor_tp)
+        else_out_opt_tp = onnx.helper.make_optional_type_proto(else_out_seq_tp)
+        else_out = onnx.helper.make_value_info("else_opt", else_out_opt_tp)
+
+        x = [np.array([1, 2, 3, 4, 5]).astype(np.float32)]
+        cond = np.array(0).astype(bool)
+        res = compute_if_outputs(x, cond)
+
+        opt_empty_in = onnx.helper.make_node(
+            "Optional", inputs=[], outputs=["optional_empty"], type=seq_in_tp
+        )
+
+        then_body = onnx.helper.make_graph([opt_empty_in], "then_body", [], [then_out])
+
+        else_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["x"],
+            value=onnx.numpy_helper.from_array(x[0]),
+        )
+
+        else_seq_node = onnx.helper.make_node(
+            "SequenceConstruct", inputs=["x"], outputs=["else_seq"]
+        )
+
+        else_optional_seq_node = onnx.helper.make_node(
+            "Optional", inputs=["else_seq"], outputs=["else_opt"]
+        )
+
+        else_body = onnx.helper.make_graph(
+            [else_const_node, else_seq_node, else_optional_seq_node],
+            "else_body",
+            [],
+            [else_out],
+        )
+
+        if_node = onnx.helper.make_node(
+            "If",
+            inputs=["cond"],
+            outputs=["sequence"],
+            then_branch=then_body,
+            else_branch=else_body,
+        )
+
+        expect(
+            if_node,
+            inputs=[cond],
+            outputs=[res],
+            name="test_if_opt",
+            output_type_protos=[else_out_opt_tp],
+            opset_imports=[onnx.helper.make_opsetid("", 16)],
+        )
diff --git a/onnx/backend/test/case/node/image_decoder.py b/onnx/backend/test/case/node/image_decoder.py
new file mode 100644
index 0000000..883845d
--- /dev/null
+++ b/onnx/backend/test/case/node/image_decoder.py
@@ -0,0 +1,249 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import io
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import _image_decoder_data, expect
+
+
+def generate_checkerboard(width: int, height: int, square_size: int) -> np.ndarray:
+    # Create an empty RGB image
+    image = np.zeros((height, width, 3), dtype=np.uint8)
+
+    # Calculate the number of squares in each dimension
+    num_squares_x = width // square_size
+    num_squares_y = height // square_size
+
+    # Generate a random color for each square
+    colors = np.random.randint(
+        0, 256, size=(num_squares_y, num_squares_x, 3), dtype=np.uint8
+    )
+
+    # Iterate over each square
+    for i in range(num_squares_y):
+        for j in range(num_squares_x):
+            # Calculate the position of the current square
+            x = j * square_size
+            y = i * square_size
+
+            # Get the color for the current square
+            color = colors[i, j]
+
+            # Fill the square with the corresponding color
+            image[y : y + square_size, x : x + square_size, :] = color
+
+    return image
+
+
+def _generate_test_data(
+    format_: str,
+    frozen_data: _image_decoder_data.ImageDecoderData,
+    pixel_format: str = "RGB",
+    height: int = 32,
+    width: int = 32,
+    tile_sz: int = 5,
+) -> tuple[np.ndarray, np.ndarray]:
+    try:
+        import PIL.Image  # noqa: PLC0415
+    except ImportError:
+        # Since pillow is not installed to generate test data for the ImageDecoder operator
+        # directly use the frozen data from _image_decoder_data.py.
+        return frozen_data.data, frozen_data.output
+    np.random.seed(12345)
+    image = generate_checkerboard(height, width, tile_sz)
+    image_pil = PIL.Image.fromarray(image)
+    with io.BytesIO() as f:
+        image_pil.save(f, format=format_)
+        data = f.getvalue()
+        data_array = np.frombuffer(data, dtype=np.uint8)
+    if pixel_format == "BGR":
+        output_pil = PIL.Image.open(io.BytesIO(data))
+        output = np.array(output_pil)[:, :, ::-1]
+    elif pixel_format == "RGB":
+        output_pil = PIL.Image.open(io.BytesIO(data))
+        output = np.array(output_pil)
+    elif pixel_format == "Grayscale":
+        output_pil = PIL.Image.open(io.BytesIO(data)).convert("L")
+        output = np.array(output_pil)[:, :, np.newaxis]
+    else:
+        raise ValueError(f"Unsupported pixel format: {pixel_format}")
+    return data_array, output
+
+
+class ImageDecoder(Base):
+    @staticmethod
+    def export_image_decoder_decode_jpeg_rgb() -> None:
+        node = onnx.helper.make_node(
+            "ImageDecoder",
+            inputs=["data"],
+            outputs=["output"],
+            pixel_format="RGB",
+        )
+
+        data, output = _generate_test_data(
+            "jpeg", _image_decoder_data.image_decoder_decode_jpeg_rgb, "RGB"
+        )
+        expect(
+            node,
+            inputs=[data],
+            outputs=[output],
+            name="test_image_decoder_decode_jpeg_rgb",
+        )
+
+    @staticmethod
+    def export_image_decoder_decode_jpeg_grayscale() -> None:
+        node = onnx.helper.make_node(
+            "ImageDecoder",
+            inputs=["data"],
+            outputs=["output"],
+            pixel_format="Grayscale",
+        )
+
+        data, output = _generate_test_data(
+            "jpeg", _image_decoder_data.image_decoder_decode_jpeg_grayscale, "Grayscale"
+        )
+        expect(
+            node,
+            inputs=[data],
+            outputs=[output],
+            name="test_image_decoder_decode_jpeg_grayscale",
+        )
+
+    @staticmethod
+    def export_image_decoder_decode_jpeg_bgr() -> None:
+        node = onnx.helper.make_node(
+            "ImageDecoder",
+            inputs=["data"],
+            outputs=["output"],
+            pixel_format="BGR",
+        )
+
+        data, output = _generate_test_data(
+            "jpeg", _image_decoder_data.image_decoder_decode_jpeg_bgr, "BGR"
+        )
+        expect(
+            node,
+            inputs=[data],
+            outputs=[output],
+            name="test_image_decoder_decode_jpeg_bgr",
+        )
+
+    @staticmethod
+    def export_image_decoder_decode_jpeg2k_rgb() -> None:
+        node = onnx.helper.make_node(
+            "ImageDecoder",
+            inputs=["data"],
+            outputs=["output"],
+            pixel_format="RGB",
+        )
+
+        data, output = _generate_test_data(
+            "jpeg2000", _image_decoder_data.image_decoder_decode_jpeg2k_rgb, "RGB"
+        )
+        expect(
+            node,
+            inputs=[data],
+            outputs=[output],
+            name="test_image_decoder_decode_jpeg2k_rgb",
+        )
+
+    @staticmethod
+    def export_image_decoder_decode_bmp_rgb() -> None:
+        node = onnx.helper.make_node(
+            "ImageDecoder",
+            inputs=["data"],
+            outputs=["output"],
+            pixel_format="RGB",
+        )
+
+        data, output = _generate_test_data(
+            "bmp", _image_decoder_data.image_decoder_decode_bmp_rgb, "RGB"
+        )
+        expect(
+            node,
+            inputs=[data],
+            outputs=[output],
+            name="test_image_decoder_decode_bmp_rgb",
+        )
+
+    @staticmethod
+    def export_image_decoder_decode_png_rgb() -> None:
+        node = onnx.helper.make_node(
+            "ImageDecoder",
+            inputs=["data"],
+            outputs=["output"],
+            pixel_format="RGB",
+        )
+
+        data, output = _generate_test_data(
+            "png", _image_decoder_data.image_decoder_decode_png_rgb, "RGB"
+        )
+        expect(
+            node,
+            inputs=[data],
+            outputs=[output],
+            name="test_image_decoder_decode_png_rgb",
+        )
+
+    @staticmethod
+    def export_image_decoder_decode_tiff_rgb() -> None:
+        node = onnx.helper.make_node(
+            "ImageDecoder",
+            inputs=["data"],
+            outputs=["output"],
+            pixel_format="RGB",
+        )
+
+        data, output = _generate_test_data(
+            "tiff", _image_decoder_data.image_decoder_decode_tiff_rgb, "RGB"
+        )
+        expect(
+            node,
+            inputs=[data],
+            outputs=[output],
+            name="test_image_decoder_decode_tiff_rgb",
+        )
+
+    @staticmethod
+    def export_image_decoder_decode_webp_rgb() -> None:
+        node = onnx.helper.make_node(
+            "ImageDecoder",
+            inputs=["data"],
+            outputs=["output"],
+            pixel_format="RGB",
+        )
+
+        data, output = _generate_test_data(
+            "webp", _image_decoder_data.image_decoder_decode_webp_rgb, "RGB"
+        )
+        expect(
+            node,
+            inputs=[data],
+            outputs=[output],
+            name="test_image_decoder_decode_webp_rgb",
+        )
+
+    @staticmethod
+    def export_image_decoder_decode_pnm_rgb() -> None:
+        node = onnx.helper.make_node(
+            "ImageDecoder",
+            inputs=["data"],
+            outputs=["output"],
+            pixel_format="RGB",
+        )
+
+        data, output = _generate_test_data(
+            "ppm", _image_decoder_data.image_decoder_decode_pnm_rgb, "RGB"
+        )
+        expect(
+            node,
+            inputs=[data],
+            outputs=[output],
+            name="test_image_decoder_decode_pnm_rgb",
+        )
diff --git a/onnx/backend/test/case/node/instancenorm.py b/onnx/backend/test/case/node/instancenorm.py
new file mode 100644
index 0000000..09b1f43
--- /dev/null
+++ b/onnx/backend/test/case/node/instancenorm.py
@@ -0,0 +1,58 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class InstanceNormalization(Base):
+    @staticmethod
+    def export() -> None:
+        def _instancenorm_test_mode(
+            x: np.ndarray, s: np.ndarray, bias: np.ndarray, epsilon: float = 1e-5
+        ) -> np.ndarray:
+            dims_x = len(x.shape)
+            axis = tuple(range(2, dims_x))
+            mean = np.mean(x, axis=axis, keepdims=True)
+            var = np.var(x, axis=axis, keepdims=True)
+            dim_ones = (1,) * (dims_x - 2)
+            s = s.reshape(-1, *dim_ones)
+            bias = bias.reshape(-1, *dim_ones)
+            return s * (x - mean) / np.sqrt(var + epsilon) + bias
+
+        # input size: (1, 2, 1, 3)
+        x = np.array([[[[-1, 0, 1]], [[2, 3, 4]]]]).astype(np.float32)
+        s = np.array([1.0, 1.5]).astype(np.float32)
+        bias = np.array([0, 1]).astype(np.float32)
+        y = _instancenorm_test_mode(x, s, bias).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "InstanceNormalization",
+            inputs=["x", "s", "bias"],
+            outputs=["y"],
+        )
+
+        # output size: (1, 2, 1, 3)
+        expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_example")
+
+        # input size: (2, 3, 4, 5)
+        x = np.random.randn(2, 3, 4, 5).astype(np.float32)
+        s = np.random.randn(3).astype(np.float32)
+        bias = np.random.randn(3).astype(np.float32)
+        epsilon = 1e-2
+        y = _instancenorm_test_mode(x, s, bias, epsilon).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "InstanceNormalization",
+            inputs=["x", "s", "bias"],
+            outputs=["y"],
+            epsilon=epsilon,
+        )
+
+        # output size: (2, 3, 4, 5)
+        expect(node, inputs=[x, s, bias], outputs=[y], name="test_instancenorm_epsilon")
diff --git a/onnx/backend/test/case/node/isinf.py b/onnx/backend/test/case/node/isinf.py
new file mode 100644
index 0000000..11ffcd5
--- /dev/null
+++ b/onnx/backend/test/case/node/isinf.py
@@ -0,0 +1,56 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class IsInf(Base):
+    @staticmethod
+    def export_infinity() -> None:
+        node = onnx.helper.make_node(
+            "IsInf",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32)
+        y = np.isinf(x)
+        expect(node, inputs=[x], outputs=[y], name="test_isinf")
+
+    @staticmethod
+    def export_positive_infinity_only() -> None:
+        node = onnx.helper.make_node(
+            "IsInf", inputs=["x"], outputs=["y"], detect_negative=0
+        )
+
+        x = np.array([-1.7, np.nan, np.inf, 3.6, -np.inf, np.inf], dtype=np.float32)
+        y = np.isposinf(x)
+        expect(node, inputs=[x], outputs=[y], name="test_isinf_positive")
+
+    @staticmethod
+    def export_negative_infinity_only() -> None:
+        node = onnx.helper.make_node(
+            "IsInf", inputs=["x"], outputs=["y"], detect_positive=0
+        )
+
+        x = np.array([-1.7, np.nan, np.inf, -3.6, -np.inf, np.inf], dtype=np.float32)
+        y = np.isneginf(x)
+        expect(node, inputs=[x], outputs=[y], name="test_isinf_negative")
+
+    @staticmethod
+    def export_infinity_float16() -> None:
+        node = onnx.helper.make_node(
+            "IsInf",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16)
+        y = np.isinf(x)
+        expect(node, inputs=[x], outputs=[y], name="test_isinf_float16")
diff --git a/onnx/backend/test/case/node/isnan.py b/onnx/backend/test/case/node/isnan.py
new file mode 100644
index 0000000..a8cecf8
--- /dev/null
+++ b/onnx/backend/test/case/node/isnan.py
@@ -0,0 +1,36 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class IsNaN(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "IsNaN",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float32)
+        y = np.isnan(x)
+        expect(node, inputs=[x], outputs=[y], name="test_isnan")
+
+    @staticmethod
+    def export_float16() -> None:
+        node = onnx.helper.make_node(
+            "IsNaN",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1.2, np.nan, np.inf, 2.8, -np.inf, np.inf], dtype=np.float16)
+        y = np.isnan(x)
+        expect(node, inputs=[x], outputs=[y], name="test_isnan_float16")
diff --git a/onnx/backend/test/case/node/layernormalization.py b/onnx/backend/test/case/node/layernormalization.py
new file mode 100644
index 0000000..5f2776e
--- /dev/null
+++ b/onnx/backend/test/case/node/layernormalization.py
@@ -0,0 +1,178 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+# Layer normalization's reference implementation
+def _layer_normalization(X, W, B, axis=-1, epsilon=1e-5):
+    X_shape = X.shape
+    X_rank = len(X_shape)
+    if axis < 0:
+        # If axis = -1 and rank of X is 4,
+        # the axis is changed to -1 + 4 = 3,
+        # which means the last axis.
+        axis = axis + X_rank
+    unsqueezed_rank = X_rank - axis
+    reduction_shape = X_shape[0:axis] + (1,) * unsqueezed_rank
+
+    # Parameter used to convert N-D tensor layer
+    # normalization to equivalent 2-D matrix operations.
+    row_number = 1
+    col_number = 1
+    for i in range(X_rank):
+        if i < axis:
+            row_number *= X_shape[i]
+        else:
+            col_number *= X_shape[i]
+
+    # After reshaping input tensor X into a matrix,
+    # layer normalization is equivalent to conducting
+    # standardization on each column vector (s.t. each
+    # column has zero mean and unit variance).
+    x_mat = np.reshape(X, (row_number, col_number))
+    # This computes mean for every x_mat's column.
+    x_mean = np.sum(x_mat, axis=1, keepdims=True) / col_number
+    x_diff = x_mat - x_mean
+    x_squared_diff = x_diff * x_diff
+    # This computes variance for every x_mat's column.
+    variance = np.sum(x_squared_diff, axis=1, keepdims=True) / col_number
+    variance_eps = variance + epsilon
+    std_dev = np.sqrt(variance_eps)
+    inv_std_dev = np.reciprocal(std_dev)
+    # Standardization step. y_mat is zero-mean and unit-variance.
+    y_mat = x_diff * inv_std_dev
+    # Apply affine transform on normalization outcome.
+    # W is linear coefficient while B is bias.
+    Y = np.reshape(y_mat, X_shape) * W + B
+    # Matrix-level operations' outputs should be reshaped
+    # to compensate the initial tensor-to-matrix reshape.
+    X_mean = np.reshape(x_mean, reduction_shape)
+    X_inv_std_dev = np.reshape(inv_std_dev, reduction_shape)
+
+    return Y, X_mean, X_inv_std_dev
+
+
+def calculate_normalized_shape(X_shape, axis):
+    X_rank = len(X_shape)
+    if axis < 0:
+        axis = axis + X_rank
+    return X_shape[axis:]
+
+
+class LayerNormalization(Base):
+    @staticmethod
+    def export() -> None:
+        X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+        def case(axis: int) -> None:
+            normalized_shape = calculate_normalized_shape(X.shape, axis)
+            W = np.random.randn(*normalized_shape).astype(np.float32)
+            B = np.random.randn(*normalized_shape).astype(np.float32)
+            Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis)
+
+            node = onnx.helper.make_node(
+                "LayerNormalization",
+                inputs=["X", "W", "B"],
+                outputs=["Y", "Mean", "InvStdDev"],
+                axis=axis,
+            )
+
+            if axis < 0:
+                name = f"test_layer_normalization_4d_axis_negative_{-axis}"
+            else:
+                name = f"test_layer_normalization_4d_axis{axis}"
+
+            expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name)
+
+        for i in range(len(X.shape)):
+            case(i)
+            case(i - len(X.shape))
+
+    @staticmethod
+    def export_default_axis() -> None:
+        X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+        # Default axis in LayerNormalization is -1.
+        normalized_shape = calculate_normalized_shape(X.shape, -1)
+        W = np.random.randn(*normalized_shape).astype(np.float32)
+        B = np.random.randn(*normalized_shape).astype(np.float32)
+        # Axis is default to -1 in the reference implementation.
+        Y, mean, inv_std_dev = _layer_normalization(X, W, B)
+
+        # Not specifying axis attribute means -1.
+        node = onnx.helper.make_node(
+            "LayerNormalization",
+            inputs=["X", "W", "B"],
+            outputs=["Y", "Mean", "InvStdDev"],
+        )
+
+        expect(
+            node,
+            inputs=[X, W, B],
+            outputs=[Y, mean, inv_std_dev],
+            name="test_layer_normalization_default_axis",
+        )
+
+    @staticmethod
+    def export2d() -> None:
+        X = np.random.randn(3, 4).astype(np.float32)
+
+        def case(axis: int) -> None:
+            normalized_shape = calculate_normalized_shape(X.shape, axis)
+            W = np.random.randn(*normalized_shape).astype(np.float32)
+            B = np.random.randn(*normalized_shape).astype(np.float32)
+            Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis=axis)
+
+            node = onnx.helper.make_node(
+                "LayerNormalization",
+                inputs=["X", "W", "B"],
+                outputs=["Y", "Mean", "InvStdDev"],
+                axis=axis,
+            )
+
+            if axis < 0:
+                name = f"test_layer_normalization_2d_axis_negative_{-axis}"
+            else:
+                name = f"test_layer_normalization_2d_axis{axis}"
+
+            expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name)
+
+        for i in range(len(X.shape)):
+            case(i)
+            case(i - len(X.shape))
+
+    @staticmethod
+    def export3d_epsilon() -> None:
+        epsilon = 1e-1
+        X = np.random.randn(2, 3, 5).astype(np.float32)
+
+        def case(axis: int) -> None:
+            normalized_shape = calculate_normalized_shape(X.shape, axis)
+            W = np.random.randn(*normalized_shape).astype(np.float32)
+            B = np.random.randn(*normalized_shape).astype(np.float32)
+            Y, mean, inv_std_dev = _layer_normalization(X, W, B, axis, epsilon)
+            node = onnx.helper.make_node(
+                "LayerNormalization",
+                inputs=["X", "W", "B"],
+                outputs=["Y", "Mean", "InvStdDev"],
+                axis=axis,
+                epsilon=epsilon,
+            )
+
+            if axis < 0:
+                name = f"test_layer_normalization_3d_axis_negative_{-axis}_epsilon"
+            else:
+                name = f"test_layer_normalization_3d_axis{axis}_epsilon"
+
+            expect(node, inputs=[X, W, B], outputs=[Y, mean, inv_std_dev], name=name)
+
+        for i in range(len(X.shape)):
+            case(i)
+            case(i - len(X.shape))
diff --git a/onnx/backend/test/case/node/leakyrelu.py b/onnx/backend/test/case/node/leakyrelu.py
new file mode 100644
index 0000000..b24b5a9
--- /dev/null
+++ b/onnx/backend/test/case/node/leakyrelu.py
@@ -0,0 +1,39 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class LeakyRelu(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "LeakyRelu", inputs=["x"], outputs=["y"], alpha=0.1
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        # expected output [-0.1, 0., 1.]
+        y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1
+        expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * 0.1
+        expect(node, inputs=[x], outputs=[y], name="test_leakyrelu")
+
+    @staticmethod
+    def export_leakyrelu_default() -> None:
+        default_alpha = 0.01
+        node = onnx.helper.make_node(
+            "LeakyRelu",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * default_alpha
+        expect(node, inputs=[x], outputs=[y], name="test_leakyrelu_default")
diff --git a/onnx/backend/test/case/node/less.py b/onnx/backend/test/case/node/less.py
new file mode 100644
index 0000000..b325279
--- /dev/null
+++ b/onnx/backend/test/case/node/less.py
@@ -0,0 +1,68 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Less(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Less",
+            inputs=["x", "y"],
+            outputs=["less"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(3, 4, 5).astype(np.float32)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less")
+
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.random.randn(3, 4, 5).astype(np.int8)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_int8")
+
+        x = np.random.randn(3, 4, 5).astype(np.int16)
+        y = np.random.randn(3, 4, 5).astype(np.int16)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_uint64")
+
+    @staticmethod
+    def export_less_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Less",
+            inputs=["x", "y"],
+            outputs=["less"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(5).astype(np.float32)
+        z = np.less(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_bcast")
diff --git a/onnx/backend/test/case/node/less_equal.py b/onnx/backend/test/case/node/less_equal.py
new file mode 100644
index 0000000..d49413c
--- /dev/null
+++ b/onnx/backend/test/case/node/less_equal.py
@@ -0,0 +1,68 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Less(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "LessOrEqual",
+            inputs=["x", "y"],
+            outputs=["less_equal"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(3, 4, 5).astype(np.float32)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal")
+
+        x = np.random.randn(3, 4, 5).astype(np.int8)
+        y = np.random.randn(3, 4, 5).astype(np.int8)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int8")
+
+        x = np.random.randn(3, 4, 5).astype(np.int16)
+        y = np.random.randn(3, 4, 5).astype(np.int16)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_int16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint8")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint16")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint32")
+
+        x = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_uint64")
+
+    @staticmethod
+    def export_less_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "LessOrEqual",
+            inputs=["x", "y"],
+            outputs=["less_equal"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(5).astype(np.float32)
+        z = np.less_equal(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_less_equal_bcast")
diff --git a/onnx/backend/test/case/node/linear_attention.py b/onnx/backend/test/case/node/linear_attention.py
new file mode 100644
index 0000000..2564b0c
--- /dev/null
+++ b/onnx/backend/test/case/node/linear_attention.py
@@ -0,0 +1,541 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_linear_attention import (
+    LinearAttention as _RefLinearAttention,
+)
+
+_OPSET = [onnx.helper.make_opsetid("", 27)]
+
+
+def _compute(
+    query,
+    key,
+    value,
+    past_state=None,
+    decay=None,
+    beta=None,
+    *,
+    q_num_heads,
+    kv_num_heads,
+    update_rule="gated_delta",
+    scale=0.0,
+    chunk_size=64,
+):
+    op = _RefLinearAttention.__new__(_RefLinearAttention)
+    return op._run(
+        query,
+        key,
+        value,
+        past_state,
+        decay,
+        beta,
+        chunk_size=chunk_size,
+        kv_num_heads=kv_num_heads,
+        q_num_heads=q_num_heads,
+        scale=scale,
+        update_rule=update_rule,
+    )
+
+
+def _l2_normalize(x: np.ndarray, num_heads: int) -> np.ndarray:
+    """L2-normalize key along the per-head feature dim. Required for delta rules."""
+    b, t, hd = x.shape
+    d = hd // num_heads
+    x4 = x.reshape(b, t, num_heads, d)
+    norm = np.linalg.norm(x4, axis=-1, keepdims=True)
+    x4 = x4 / np.maximum(norm, 1e-6)
+    return x4.reshape(b, t, hd).astype(x.dtype)
+
+
+class LinearAttention(Base):
+    # ------------------------------------------------------------------
+    # Update-rule axis (B=2, T=4, H_q=H_kv=4, d_k=d_v=8)
+    # ------------------------------------------------------------------
+    @staticmethod
+    def export_linear() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value"],
+            outputs=["output", "present_state"],
+            update_rule="linear",
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+            update_rule="linear",
+        )
+        expect(
+            node,
+            inputs=[query, key, value],
+            outputs=[output, present_state],
+            name="test_linear_attention_linear",
+            opset_imports=_OPSET,
+        )
+
+    @staticmethod
+    def export_gated() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "", "decay"],
+            outputs=["output", "present_state"],
+            update_rule="gated",
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        # Per-key-dim decay in log-space (negative -> decay).
+        decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            decay=decay,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+            update_rule="gated",
+        )
+        expect(
+            node,
+            inputs=[query, key, value, decay],
+            outputs=[output, present_state],
+            name="test_linear_attention_gated",
+            opset_imports=_OPSET,
+        )
+
+    @staticmethod
+    def export_gated_per_head_decay() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "", "decay"],
+            outputs=["output", "present_state"],
+            update_rule="gated",
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        # Per-head scalar decay.
+        decay = -np.abs(np.random.randn(b, t, h_kv)).astype(np.float32) * 0.1
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            decay=decay,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+            update_rule="gated",
+        )
+        expect(
+            node,
+            inputs=[query, key, value, decay],
+            outputs=[output, present_state],
+            name="test_linear_attention_gated_per_head_decay",
+            opset_imports=_OPSET,
+        )
+
+    @staticmethod
+    def export_delta() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "", "", "beta"],
+            outputs=["output", "present_state"],
+            update_rule="delta",
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+            update_rule="delta",
+        )
+        expect(
+            node,
+            inputs=[query, key, value, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_delta",
+            opset_imports=_OPSET,
+        )
+
+    @staticmethod
+    def export_gated_delta() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "", "decay", "beta"],
+            outputs=["output", "present_state"],
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+        beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            decay=decay,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+        )
+        expect(
+            node,
+            inputs=[query, key, value, decay, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_gated_delta",
+            opset_imports=_OPSET,
+        )
+
+    @staticmethod
+    def export_gated_delta_beta_scalar() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "", "decay", "beta"],
+            outputs=["output", "present_state"],
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+        beta = np.random.rand(b, t, 1).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            decay=decay,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+        )
+        expect(
+            node,
+            inputs=[query, key, value, decay, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_gated_delta_beta_scalar",
+            opset_imports=_OPSET,
+        )
+
+    # ------------------------------------------------------------------
+    # GQA / MQA axis
+    # ------------------------------------------------------------------
+    @staticmethod
+    def export_gated_delta_gqa() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "", "decay", "beta"],
+            outputs=["output", "present_state"],
+            q_num_heads=8,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+        beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            decay=decay,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+        )
+        expect(
+            node,
+            inputs=[query, key, value, decay, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_gated_delta_gqa",
+            opset_imports=_OPSET,
+        )
+
+    @staticmethod
+    def export_gated_delta_mqa() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "", "decay", "beta"],
+            outputs=["output", "present_state"],
+            q_num_heads=8,
+            kv_num_heads=1,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 1, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+        beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            decay=decay,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+        )
+        expect(
+            node,
+            inputs=[query, key, value, decay, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_gated_delta_mqa",
+            opset_imports=_OPSET,
+        )
+
+    # ------------------------------------------------------------------
+    # Decoding / past_state axis
+    # ------------------------------------------------------------------
+    @staticmethod
+    def export_decode_step() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "past_state", "decay", "beta"],
+            outputs=["output", "present_state"],
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 1, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        past_state = np.random.randn(b, h_kv, d_k, d_v).astype(np.float32) * 0.1
+        decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+        beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            past_state=past_state,
+            decay=decay,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+        )
+        expect(
+            node,
+            inputs=[query, key, value, past_state, decay, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_decode_step",
+            opset_imports=_OPSET,
+        )
+
+    @staticmethod
+    def export_prefill_with_past() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "past_state", "decay", "beta"],
+            outputs=["output", "present_state"],
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        past_state = np.random.randn(b, h_kv, d_k, d_v).astype(np.float32) * 0.1
+        decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+        beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            past_state=past_state,
+            decay=decay,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+        )
+        expect(
+            node,
+            inputs=[query, key, value, past_state, decay, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_prefill_with_past",
+            opset_imports=_OPSET,
+        )
+
+    @staticmethod
+    def export_no_past_explicit_zeros() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "past_state", "decay", "beta"],
+            outputs=["output", "present_state"],
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        past_state = np.zeros((b, h_kv, d_k, d_v), dtype=np.float32)
+        decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+        beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            past_state=past_state,
+            decay=decay,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+        )
+        expect(
+            node,
+            inputs=[query, key, value, past_state, decay, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_no_past_explicit_zeros",
+            opset_imports=_OPSET,
+        )
+
+    # ------------------------------------------------------------------
+    # Scale & dtype axis
+    # ------------------------------------------------------------------
+    @staticmethod
+    def export_explicit_scale() -> None:
+        scale = 0.25
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "", "decay", "beta"],
+            outputs=["output", "present_state"],
+            q_num_heads=4,
+            kv_num_heads=4,
+            scale=scale,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float32), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+        decay = -np.abs(np.random.randn(b, t, h_kv * d_k)).astype(np.float32) * 0.1
+        beta = np.random.rand(b, t, h_kv).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            decay=decay,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+            scale=scale,
+        )
+        expect(
+            node,
+            inputs=[query, key, value, decay, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_explicit_scale",
+            opset_imports=_OPSET,
+        )
+
+    @staticmethod
+    def export_fp16() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value", "", "decay", "beta"],
+            outputs=["output", "present_state"],
+            q_num_heads=8,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 4, 8, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float16)
+        key = _l2_normalize(np.random.randn(b, t, h_kv * d_k).astype(np.float16), h_kv)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float16)
+        decay = (-np.abs(np.random.randn(b, t, h_kv * d_k)) * 0.1).astype(np.float16)
+        beta = np.random.rand(b, t, h_kv).astype(np.float16)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            decay=decay,
+            beta=beta,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+        )
+        expect(
+            node,
+            inputs=[query, key, value, decay, beta],
+            outputs=[output, present_state],
+            name="test_linear_attention_fp16",
+            opset_imports=_OPSET,
+        )
+
+    # ------------------------------------------------------------------
+    # Edge cases
+    # ------------------------------------------------------------------
+    @staticmethod
+    def export_linear_t1_no_past() -> None:
+        node = onnx.helper.make_node(
+            "LinearAttention",
+            inputs=["query", "key", "value"],
+            outputs=["output", "present_state"],
+            update_rule="linear",
+            q_num_heads=4,
+            kv_num_heads=4,
+        )
+        b, t, h_q, h_kv, d_k, d_v = 2, 1, 4, 4, 8, 8
+        query = np.random.randn(b, t, h_q * d_k).astype(np.float32)
+        key = np.random.randn(b, t, h_kv * d_k).astype(np.float32)
+        value = np.random.randn(b, t, h_kv * d_v).astype(np.float32)
+
+        output, present_state = _compute(
+            query,
+            key,
+            value,
+            q_num_heads=h_q,
+            kv_num_heads=h_kv,
+            update_rule="linear",
+        )
+        expect(
+            node,
+            inputs=[query, key, value],
+            outputs=[output, present_state],
+            name="test_linear_attention_linear_t1_no_past",
+            opset_imports=_OPSET,
+        )
diff --git a/onnx/backend/test/case/node/log.py b/onnx/backend/test/case/node/log.py
new file mode 100644
index 0000000..62ac4da
--- /dev/null
+++ b/onnx/backend/test/case/node/log.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Log(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Log",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([1, 10]).astype(np.float32)
+        y = np.log(x)  # expected output [0., 2.30258512]
+        expect(node, inputs=[x], outputs=[y], name="test_log_example")
+
+        x = np.exp(np.random.randn(3, 4, 5).astype(np.float32))
+        y = np.log(x)
+        expect(node, inputs=[x], outputs=[y], name="test_log")
diff --git a/onnx/backend/test/case/node/logsoftmax.py b/onnx/backend/test/case/node/logsoftmax.py
new file mode 100644
index 0000000..96ed103
--- /dev/null
+++ b/onnx/backend/test/case/node/logsoftmax.py
@@ -0,0 +1,92 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def logsoftmax(x: np.ndarray, axis: int = -1) -> np.ndarray:
+    x_max = np.max(x, axis=axis, keepdims=True)
+    tmp = np.exp(x - x_max)
+    s = np.sum(tmp, axis=axis, keepdims=True)
+    return (x - x_max) - np.log(s)
+
+
+class LogSoftmax(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "LogSoftmax",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.array([[-1, 0, 1]]).astype(np.float32)
+        # expected output
+        # [[-2.4076061 -1.407606  -0.407606 ]]
+        y = logsoftmax(x)
+        expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_example_1")
+
+    @staticmethod
+    def export_logsoftmax_axis() -> None:
+        x = np.array([[0, 1, 2, 3], [10000, 10001, 10002, 10003]]).astype(np.float32)
+        # expected output
+        # [[-3.4401896  -2.4401896  -1.4401896  -0.44018966]
+        # [-3.4401896  -2.4401896  -1.4401896  -0.44018966]]
+        y = logsoftmax(x)
+
+        node = onnx.helper.make_node(
+            "LogSoftmax",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_large_number")
+
+        x = np.abs(np.random.randn(3, 4, 5).astype(np.float32))
+        node = onnx.helper.make_node(
+            "LogSoftmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=0,
+        )
+        y = logsoftmax(x, axis=0)
+        expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_0")
+
+        node = onnx.helper.make_node(
+            "LogSoftmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=1,
+        )
+        y = logsoftmax(x, axis=1)
+        expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_1")
+
+        node = onnx.helper.make_node(
+            "LogSoftmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=2,
+        )
+        y = logsoftmax(x, axis=2)
+        expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_axis_2")
+
+        node = onnx.helper.make_node(
+            "LogSoftmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=-1,
+        )
+        y = logsoftmax(x, axis=-1)
+        expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_negative_axis")
+
+        # default axis is -1
+        node = onnx.helper.make_node(
+            "LogSoftmax",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        expect(node, inputs=[x], outputs=[y], name="test_logsoftmax_default_axis")
diff --git a/onnx/backend/test/case/node/loop.py b/onnx/backend/test/case/node/loop.py
new file mode 100644
index 0000000..7de826d
--- /dev/null
+++ b/onnx/backend/test/case/node/loop.py
@@ -0,0 +1,459 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def compute_loop_outputs(x, seq, trip_count):
+    for i in range(trip_count):
+        if seq is None:
+            seq = []
+        seq += [x[: int(i + 1)]]
+    return seq
+
+
+class Loop(Base):
+    @staticmethod
+    def export_loop_11() -> None:
+        # Given a tensor x of values [x1, ..., xN], and initial tensor y
+        # sum up its elements using a scan
+        # returning the final state (y+x1+x2+...+xN) as well the scan_output
+        # [y+x1, y+x1+x2, ..., y+x1+x2+...+xN]
+
+        y_in = onnx.helper.make_tensor_value_info("y_in", onnx.TensorProto.FLOAT, [1])
+        y_out = onnx.helper.make_tensor_value_info("y_out", onnx.TensorProto.FLOAT, [1])
+        scan_out = onnx.helper.make_tensor_value_info(
+            "scan_out", onnx.TensorProto.FLOAT, [1]
+        )
+        cond_in = onnx.helper.make_tensor_value_info(
+            "cond_in", onnx.TensorProto.BOOL, []
+        )
+        cond_out = onnx.helper.make_tensor_value_info(
+            "cond_out", onnx.TensorProto.BOOL, []
+        )
+        iter_count = onnx.helper.make_tensor_value_info(
+            "iter_count", onnx.TensorProto.INT64, []
+        )
+
+        x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+        y = np.array([-2]).astype(np.float32)
+
+        x_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["x"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_x",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=x.shape,
+                vals=x.flatten().astype(float),
+            ),
+        )
+
+        one_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["one"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_one",
+                data_type=onnx.TensorProto.INT64,
+                dims=(),
+                vals=[1],
+            ),
+        )
+
+        i_add_node = onnx.helper.make_node(
+            "Add", inputs=["iter_count", "one"], outputs=["end"]
+        )
+
+        start_unsqueeze_node = onnx.helper.make_node(
+            "Unsqueeze", inputs=["iter_count"], outputs=["slice_start"], axes=[0]
+        )
+
+        end_unsqueeze_node = onnx.helper.make_node(
+            "Unsqueeze", inputs=["end"], outputs=["slice_end"], axes=[0]
+        )
+
+        slice_node = onnx.helper.make_node(
+            "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+        )
+
+        y_add_node = onnx.helper.make_node(
+            "Add", inputs=["y_in", "slice_out"], outputs=["y_out"]
+        )
+
+        identity_node = onnx.helper.make_node(
+            "Identity", inputs=["cond_in"], outputs=["cond_out"]
+        )
+
+        scan_identity_node = onnx.helper.make_node(
+            "Identity", inputs=["y_out"], outputs=["scan_out"]
+        )
+
+        loop_body = onnx.helper.make_graph(
+            [
+                identity_node,
+                x_const_node,
+                one_const_node,
+                i_add_node,
+                start_unsqueeze_node,
+                end_unsqueeze_node,
+                slice_node,
+                y_add_node,
+                scan_identity_node,
+            ],
+            "loop_body",
+            [iter_count, cond_in, y_in],
+            [cond_out, y_out, scan_out],
+        )
+
+        node = onnx.helper.make_node(
+            "Loop",
+            inputs=["trip_count", "cond", "y"],
+            outputs=["res_y", "res_scan"],
+            body=loop_body,
+        )
+
+        trip_count = np.array(5).astype(np.int64)
+        res_y = np.array([13]).astype(np.float32)
+        cond = np.array(1).astype(bool)
+        res_scan = np.array([-1, 1, 4, 8, 13]).astype(np.float32).reshape((5, 1))
+        expect(
+            node,
+            inputs=[trip_count, cond, y],
+            outputs=[res_y, res_scan],
+            name="test_loop11",
+            opset_imports=[onnx.helper.make_opsetid("", 11)],
+        )
+
+    @staticmethod
+    def export_loop_13() -> None:
+        # Given a tensor x of values [x1, ..., xN],
+        # Return a sequence of tensors of
+        #   [[x1], [x1, x2], ..., [x1, ..., xN]]
+
+        seq_in = onnx.helper.make_tensor_sequence_value_info(
+            "seq_in", onnx.TensorProto.FLOAT, None
+        )
+        seq_out = onnx.helper.make_tensor_sequence_value_info(
+            "seq_out", onnx.TensorProto.FLOAT, None
+        )
+        cond_in = onnx.helper.make_tensor_value_info(
+            "cond_in", onnx.TensorProto.BOOL, []
+        )
+        cond_out = onnx.helper.make_tensor_value_info(
+            "cond_out", onnx.TensorProto.BOOL, []
+        )
+        iter_count = onnx.helper.make_tensor_value_info(
+            "iter_count", onnx.TensorProto.INT64, []
+        )
+
+        x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+
+        x_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["x"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_x",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=x.shape,
+                vals=x.flatten().astype(float),
+            ),
+        )
+
+        one_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["one"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_one",
+                data_type=onnx.TensorProto.INT64,
+                dims=(),
+                vals=[1],
+            ),
+        )
+
+        zero_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["slice_start"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_zero",
+                data_type=onnx.TensorProto.INT64,
+                dims=(1,),
+                vals=[0],
+            ),
+        )
+
+        axes_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["axes"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_axes",
+                data_type=onnx.TensorProto.INT64,
+                dims=(),
+                vals=[0],
+            ),
+        )
+
+        add_node = onnx.helper.make_node(
+            "Add", inputs=["iter_count", "one"], outputs=["end"]
+        )
+
+        end_unsqueeze_node = onnx.helper.make_node(
+            "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"]
+        )
+
+        slice_node = onnx.helper.make_node(
+            "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+        )
+
+        insert_node = onnx.helper.make_node(
+            "SequenceInsert", inputs=["seq_in", "slice_out"], outputs=["seq_out"]
+        )
+
+        identity_node = onnx.helper.make_node(
+            "Identity", inputs=["cond_in"], outputs=["cond_out"]
+        )
+
+        loop_body = onnx.helper.make_graph(
+            [
+                identity_node,
+                x_const_node,
+                one_const_node,
+                zero_const_node,
+                add_node,
+                axes_node,
+                end_unsqueeze_node,
+                slice_node,
+                insert_node,
+            ],
+            "loop_body",
+            [iter_count, cond_in, seq_in],
+            [cond_out, seq_out],
+        )
+
+        node = onnx.helper.make_node(
+            "Loop",
+            inputs=["trip_count", "cond", "seq_empty"],
+            outputs=["seq_res"],
+            body=loop_body,
+        )
+
+        trip_count = np.array(5).astype(np.int64)
+        seq_empty: list[Any] = []
+        seq_res = [x[: int(i)] for i in x]
+        cond = np.array(1).astype(bool)
+        expect(
+            node,
+            inputs=[trip_count, cond, seq_empty],
+            outputs=[seq_res],
+            name="test_loop13_seq",
+            opset_imports=[onnx.helper.make_opsetid("", 13)],
+            input_type_protos=[
+                onnx.helper.make_tensor_type_proto(
+                    onnx.TensorProto.INT64, trip_count.shape
+                ),
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape),
+                onnx.helper.make_sequence_type_proto(
+                    onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, [])
+                ),
+            ],
+        )
+
+    @staticmethod
+    def export_loop_16_none() -> None:
+        # Given a tensor sequence of values [x1, ..., xN], and an initial optional sequence of tensors [x0],
+        # Return a concatenated sequence of tensors of
+        #   [x0, [x1], [x1, x2], ..., [x1, ..., xN]]
+
+        ten_in_tp = onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, [])
+        seq_in_tp = onnx.helper.make_sequence_type_proto(ten_in_tp)
+        opt_in_tp = onnx.helper.make_optional_type_proto(seq_in_tp)
+        opt_in = onnx.helper.make_value_info("opt_seq_in", opt_in_tp)
+        seq_out = onnx.helper.make_tensor_sequence_value_info(
+            "seq_out", onnx.TensorProto.FLOAT, []
+        )
+        cond_in = onnx.helper.make_tensor_value_info(
+            "cond_in", onnx.TensorProto.BOOL, []
+        )
+        cond_out = onnx.helper.make_tensor_value_info(
+            "cond_out", onnx.TensorProto.BOOL, []
+        )
+        iter_count = onnx.helper.make_tensor_value_info(
+            "iter_count", onnx.TensorProto.INT64, []
+        )
+
+        x0 = np.array(0).astype(np.float32)
+        x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+
+        optional_has_elem_node = onnx.helper.make_node(
+            "OptionalHasElement", inputs=["opt_seq_in"], outputs=["optional_has_elem"]
+        )
+
+        optional_is_none = onnx.helper.make_node(
+            "Not", inputs=["optional_has_elem"], outputs=["optional_is_none"]
+        )
+
+        optional_get_elem = onnx.helper.make_node(
+            "OptionalGetElement", inputs=["opt_seq_in"], outputs=["seq_in"]
+        )
+
+        constant_in = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["constant_in"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor", data_type=onnx.TensorProto.FLOAT, dims=(), vals=[0]
+            ),
+        )
+
+        seq_const_in = onnx.helper.make_node(
+            "SequenceConstruct", inputs=["constant_in"], outputs=["init_seq_in"]
+        )
+
+        then_seq_out = onnx.helper.make_tensor_sequence_value_info(
+            "init_seq_in", onnx.TensorProto.FLOAT, []
+        )
+        then_body = onnx.helper.make_graph(
+            [constant_in, seq_const_in], "then_body", [], [then_seq_out]
+        )
+
+        else_seq_out = onnx.helper.make_tensor_sequence_value_info(
+            "seq_in", onnx.TensorProto.FLOAT, []
+        )
+        else_body = onnx.helper.make_graph(
+            [optional_get_elem], "else_body", [], [else_seq_out]
+        )
+
+        if_node = onnx.helper.make_node(
+            "If",
+            inputs=["optional_is_none"],
+            outputs=["sequence"],
+            then_branch=then_body,
+            else_branch=else_body,
+        )
+
+        x_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["x"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_x",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=x.shape,
+                vals=x.flatten().astype(float),
+            ),
+        )
+
+        one_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["one"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_one",
+                data_type=onnx.TensorProto.INT64,
+                dims=(),
+                vals=[1],
+            ),
+        )
+
+        zero_const_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["slice_start"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_zero",
+                data_type=onnx.TensorProto.INT64,
+                dims=(1,),
+                vals=[0],
+            ),
+        )
+
+        axes_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["axes"],
+            value=onnx.helper.make_tensor(
+                name="const_tensor_axes",
+                data_type=onnx.TensorProto.INT64,
+                dims=(),
+                vals=[0],
+            ),
+        )
+
+        add_node = onnx.helper.make_node(
+            "Add", inputs=["iter_count", "one"], outputs=["end"]
+        )
+
+        end_unsqueeze_node = onnx.helper.make_node(
+            "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"]
+        )
+
+        slice_node = onnx.helper.make_node(
+            "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+        )
+
+        insert_node = onnx.helper.make_node(
+            "SequenceInsert", inputs=["sequence", "slice_out"], outputs=["seq_out"]
+        )
+
+        identity_node = onnx.helper.make_node(
+            "Identity", inputs=["cond_in"], outputs=["cond_out"]
+        )
+
+        loop_body = onnx.helper.make_graph(
+            [
+                identity_node,
+                optional_has_elem_node,
+                optional_is_none,
+                if_node,
+                x_const_node,
+                one_const_node,
+                zero_const_node,
+                add_node,
+                axes_node,
+                end_unsqueeze_node,
+                slice_node,
+                insert_node,
+            ],
+            "loop_body",
+            [iter_count, cond_in, opt_in],
+            [cond_out, seq_out],
+        )
+
+        node = onnx.helper.make_node(
+            "Loop",
+            inputs=["trip_count", "cond", "opt_seq"],
+            outputs=["seq_res"],
+            body=loop_body,
+        )
+
+        trip_count = np.array(5).astype(np.int64)
+        cond = np.array(1).astype(bool)
+        seq_res = compute_loop_outputs(x, [x0], trip_count)
+        opt_seq_in: list[Any] = [x0]
+        expect(
+            node,
+            inputs=[trip_count, cond, opt_seq_in],
+            outputs=[seq_res],
+            name="test_loop16_seq_none",
+            opset_imports=[onnx.helper.make_opsetid("", 16)],
+            input_type_protos=[
+                onnx.helper.make_tensor_type_proto(
+                    onnx.TensorProto.INT64, trip_count.shape
+                ),
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.BOOL, cond.shape),
+                opt_in_tp,
+            ],
+        )
diff --git a/onnx/backend/test/case/node/lpnormalization.py b/onnx/backend/test/case/node/lpnormalization.py
new file mode 100644
index 0000000..d258e57
--- /dev/null
+++ b/onnx/backend/test/case/node/lpnormalization.py
@@ -0,0 +1,80 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class LpNormalization(Base):
+    @staticmethod
+    def export_l2normalization_axis_0() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=2
+        )
+        x = np.array(
+            [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+            dtype=np.float32,
+        )
+        l2_norm_axis_0 = np.sqrt(np.sum(x**2, axis=0, keepdims=True))
+        # When norm is 0, output is 0 (0/0 = 0)
+        y = np.where(l2_norm_axis_0 == 0, 0, x / l2_norm_axis_0)
+        expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_0")
+
+    @staticmethod
+    def export_l2normalization_axis_1() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=2
+        )
+        x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+        l2_norm_axis_1 = np.sqrt(np.sum(x**2, axis=1, keepdims=True))
+        y = x / l2_norm_axis_1
+        expect(node, inputs=[x], outputs=[y], name="test_l2normalization_axis_1")
+
+    @staticmethod
+    def export_l1normalization_axis_0() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=0, p=1
+        )
+        x = np.array([3.0, 4.0], dtype=np.float32)
+        l1_norm_axis_0 = np.sum(abs(x), axis=0, keepdims=True)
+        y = x / l1_norm_axis_0
+        expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_0")
+
+    @staticmethod
+    def export_l1normalization_axis_1() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=1, p=1
+        )
+        x = np.array([[3.0, 4.0], [6.0, 8.0]], dtype=np.float32)
+        l1_norm_axis_1 = np.sum(abs(x), axis=1, keepdims=True)
+        y = x / l1_norm_axis_1
+        expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_1")
+
+    @staticmethod
+    def export_l1normalization_axis_last() -> None:
+        node = onnx.helper.make_node(
+            "LpNormalization", inputs=["x"], outputs=["y"], axis=-1, p=1
+        )
+        x = np.array(
+            [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+            dtype=np.float32,
+        )
+        l1_norm_axis_last = np.sum(abs(x), axis=-1, keepdims=True)
+        y = x / l1_norm_axis_last
+        expect(node, inputs=[x], outputs=[y], name="test_l1normalization_axis_last")
+
+    @staticmethod
+    def export_default() -> None:
+        node = onnx.helper.make_node("LpNormalization", inputs=["x"], outputs=["y"])
+        x = np.array(
+            [[[1.0, 2.0, 2.0], [3.0, 4.0, 0.0]], [[0.0, 5.0, 5.0], [6.0, 8.0, 0.0]]],
+            dtype=np.float32,
+        )
+        lp_norm_default = np.sqrt(np.sum(x**2, axis=-1, keepdims=True))
+        y = x / lp_norm_default
+        expect(node, inputs=[x], outputs=[y], name="test_lpnormalization_default")
diff --git a/onnx/backend/test/case/node/lppool.py b/onnx/backend/test/case/node/lppool.py
new file mode 100644
index 0000000..9f41828
--- /dev/null
+++ b/onnx/backend/test/case/node/lppool.py
@@ -0,0 +1,298 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_pool_common import (
+    get_output_shape_auto_pad,
+    get_output_shape_explicit_padding,
+    get_pad_shape,
+    pool,
+)
+
+
+class LpPool(Base):
+    @staticmethod
+    def export_lppool_1d_default() -> None:
+        """input_shape: [1, 3, 32]
+        output_shape: [1, 3, 31]
+        """
+        p = 3
+        kernel_shape = [2]
+        strides = [1]
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=kernel_shape,
+            strides=strides,
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_1d_default")
+
+    @staticmethod
+    def export_lppool_2d_default() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 31, 31]
+        """
+        p = 4
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_default")
+
+    @staticmethod
+    def export_lppool_3d_default() -> None:
+        """input_shape: [1, 3, 32, 32, 32]
+        output_shape: [1, 3, 31, 31, 31]
+        """
+        p = 3
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2, 2],
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = [2, 2, 2]
+        strides = [1, 1, 1]
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_3d_default")
+
+    @staticmethod
+    def export_lppool_2d_same_upper() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 32, 32]
+        pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+        """
+        p = 2
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            auto_pad="SAME_UPPER",
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape = get_output_shape_auto_pad(
+            "SAME_UPPER", x_shape[2:], kernel_shape, strides
+        )
+        pad_shape = get_pad_shape(
+            "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+        )
+        pad_top = pad_shape[0] // 2
+        pad_bottom = pad_shape[0] - pad_top
+        pad_left = pad_shape[1] // 2
+        pad_right = pad_shape[1] - pad_left
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=0,
+        )
+        pads = [pad_top, pad_left, pad_bottom, pad_right]
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_upper")
+
+    @staticmethod
+    def export_lppool_2d_same_lower() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 32, 32]
+        pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+        """
+        p = 4
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            auto_pad="SAME_LOWER",
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape = get_output_shape_auto_pad(
+            "SAME_LOWER", x_shape[2:], kernel_shape, strides
+        )
+        pad_shape = get_pad_shape(
+            "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+        )
+        pad_bottom = pad_shape[0] // 2
+        pad_top = pad_shape[0] - pad_bottom
+        pad_right = pad_shape[1] // 2
+        pad_left = pad_shape[1] - pad_right
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=0,
+        )
+        pads = [pad_top, pad_left, pad_bottom, pad_right]
+        y = pool(
+            padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", pads, pads, p=p
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_same_lower")
+
+    @staticmethod
+    def export_lppool_2d_pads() -> None:
+        """input_shape: [1, 3, 28, 28]
+        output_shape: [1, 3, 30, 30]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        p = 3
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            pads=[2, 2, 2, 2],
+            p=p,
+        )
+        x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (3, 3)
+        strides = (1, 1)
+        pad_bottom = pad_top = pad_right = pad_left = 2
+        pads = [pad_top, pad_left, pad_bottom, pad_right]
+        out_shape, extra_pads = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = np.pad(
+            x,
+            (
+                (0, 0),
+                (0, 0),
+                (extra_pads[0], extra_pads[2]),
+                (extra_pads[1], extra_pads[3]),
+            ),
+            mode="constant",
+            constant_values=0,
+        )
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "LPPOOL",
+            pads_required=extra_pads,
+            pads=pads,
+            p=p,
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_pads")
+
+    @staticmethod
+    def export_lppool_2d_strides() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 10, 10]
+        """
+        p = 2
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[5, 5],
+            strides=[3, 3],
+            p=p,
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = (5, 5)
+        strides = (3, 3)
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "LPPOOL", p=p)
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_strides")
+
+    @staticmethod
+    def export_lppool_2d_dilations() -> None:
+        """input_shape: [1, 1, 4, 4]
+        output_shape: [1, 1, 2, 2]
+        """
+        p = 2
+        node = onnx.helper.make_node(
+            "LpPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            strides=[1, 1],
+            dilations=[2, 2],
+            p=p,
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        y = np.array(
+            [
+                [
+                    [
+                        [14.560219778561036, 16.24807680927192],
+                        [21.633307652783937, 23.49468024894146],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(node, inputs=[x], outputs=[y], name="test_lppool_2d_dilations")
diff --git a/onnx/backend/test/case/node/lrn.py b/onnx/backend/test/case/node/lrn.py
new file mode 100644
index 0000000..05244c1
--- /dev/null
+++ b/onnx/backend/test/case/node/lrn.py
@@ -0,0 +1,70 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class LRN(Base):
+    @staticmethod
+    def export() -> None:
+        alpha = 0.0002
+        beta = 0.5
+        bias = 2.0
+        nsize = 3
+        node = onnx.helper.make_node(
+            "LRN",
+            inputs=["x"],
+            outputs=["y"],
+            alpha=alpha,
+            beta=beta,
+            bias=bias,
+            size=nsize,
+        )
+        x = np.random.randn(5, 5, 5, 5).astype(np.float32)
+        square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32)
+        for n, c, h, w in np.ndindex(x.shape):
+            square_sum[n, c, h, w] = sum(
+                x[
+                    n,
+                    max(0, c - math.floor((nsize - 1) / 2)) : min(
+                        5, c + math.ceil((nsize - 1) / 2) + 1
+                    ),
+                    h,
+                    w,
+                ]
+                ** 2
+            )
+        y = x / ((bias + (alpha / nsize) * square_sum) ** beta)
+        expect(node, inputs=[x], outputs=[y], name="test_lrn")
+
+    @staticmethod
+    def export_default() -> None:
+        alpha = 0.0001
+        beta = 0.75
+        bias = 1.0
+        nsize = 3
+        node = onnx.helper.make_node("LRN", inputs=["x"], outputs=["y"], size=3)
+        x = np.random.randn(5, 5, 5, 5).astype(np.float32)
+        square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32)
+        for n, c, h, w in np.ndindex(x.shape):
+            square_sum[n, c, h, w] = sum(
+                x[
+                    n,
+                    max(0, c - math.floor((nsize - 1) / 2)) : min(
+                        5, c + math.ceil((nsize - 1) / 2) + 1
+                    ),
+                    h,
+                    w,
+                ]
+                ** 2
+            )
+        y = x / ((bias + (alpha / nsize) * square_sum) ** beta)
+        expect(node, inputs=[x], outputs=[y], name="test_lrn_default")
diff --git a/onnx/backend/test/case/node/lstm.py b/onnx/backend/test/case/node/lstm.py
new file mode 100644
index 0000000..0213275
--- /dev/null
+++ b/onnx/backend/test/case/node/lstm.py
@@ -0,0 +1,278 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class LSTMHelper:
+    def __init__(self, **params: Any) -> None:
+        # LSTM Input Names
+        X = "X"
+        W = "W"
+        R = "R"
+        B = "B"
+        H_0 = "initial_h"
+        C_0 = "initial_c"
+        P = "P"
+        LAYOUT = "layout"
+        number_of_gates = 4
+        number_of_peepholes = 3
+
+        required_inputs = [X, W, R]
+        for i in required_inputs:
+            assert i in params, f"Missing Required Input: {i}"
+
+        self.num_directions = params[W].shape[0]
+
+        if self.num_directions == 1:
+            for k, v in params.items():
+                if k != X:
+                    params[k] = np.squeeze(v, axis=0)
+
+            hidden_size = params[R].shape[-1]
+            batch_size = params[X].shape[1]
+
+            layout = params.get(LAYOUT, 0)
+            x = params[X]
+            x = x if layout == 0 else np.swapaxes(x, 0, 1)
+            b = (
+                params[B]
+                if B in params
+                else np.zeros(2 * number_of_gates * hidden_size, dtype=np.float32)
+            )
+            p = (
+                params[P]
+                if P in params
+                else np.zeros(number_of_peepholes * hidden_size, dtype=np.float32)
+            )
+            h_0 = (
+                params[H_0]
+                if H_0 in params
+                else np.zeros((batch_size, hidden_size), dtype=np.float32)
+            )
+            c_0 = (
+                params[C_0]
+                if C_0 in params
+                else np.zeros((batch_size, hidden_size), dtype=np.float32)
+            )
+
+            self.X = x
+            self.W = params[W]
+            self.R = params[R]
+            self.B = b
+            self.P = p
+            self.H_0 = h_0
+            self.C_0 = c_0
+            self.LAYOUT = layout
+
+        else:
+            raise NotImplementedError
+
+    def f(self, x: np.ndarray) -> np.ndarray:
+        return 1 / (1 + np.exp(-x))
+
+    def g(self, x: np.ndarray) -> np.ndarray:
+        return np.tanh(x)
+
+    def h(self, x: np.ndarray) -> np.ndarray:
+        return np.tanh(x)
+
+    def step(self) -> tuple[np.ndarray, np.ndarray]:
+        seq_length = self.X.shape[0]
+        hidden_size = self.H_0.shape[-1]
+        batch_size = self.X.shape[1]
+
+        Y = np.empty([seq_length, self.num_directions, batch_size, hidden_size])
+        h_list = []
+
+        [p_i, p_o, p_f] = np.split(self.P, 3)
+        H_t = self.H_0
+        C_t = self.C_0
+        for x in np.split(self.X, self.X.shape[0], axis=0):
+            gates = (
+                np.dot(x, np.transpose(self.W))
+                + np.dot(H_t, np.transpose(self.R))
+                + np.add(*np.split(self.B, 2))
+            )
+            i, o, f, c = np.split(gates, 4, -1)
+            i = self.f(i + p_i * C_t)
+            f = self.f(f + p_f * C_t)
+            c = self.g(c)
+            C = f * C_t + i * c
+            o = self.f(o + p_o * C)
+            H = o * self.h(C)
+            h_list.append(H)
+            H_t = H
+            C_t = C
+
+        concatenated = np.concatenate(h_list)
+        if self.num_directions == 1:
+            Y[:, 0, :, :] = concatenated
+
+        if self.LAYOUT == 0:
+            Y_h = Y[-1]
+        else:
+            Y = np.transpose(Y, [2, 0, 1, 3])
+            Y_h = Y[:, :, -1, :]
+
+        return Y, Y_h
+
+
+class LSTM(Base):
+    @staticmethod
+    def export_defaults() -> None:
+        input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32)
+
+        input_size = 2
+        hidden_size = 3
+        weight_scale = 0.1
+        number_of_gates = 4
+
+        node = onnx.helper.make_node(
+            "LSTM", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size
+        )
+
+        W = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, input_size)
+        ).astype(np.float32)
+        R = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, hidden_size)
+        ).astype(np.float32)
+
+        lstm = LSTMHelper(X=input, W=W, R=R)
+        _, Y_h = lstm.step()
+        expect(
+            node,
+            inputs=[input, W, R],
+            outputs=[Y_h.astype(np.float32)],
+            name="test_lstm_defaults",
+        )
+
+    @staticmethod
+    def export_initial_bias() -> None:
+        input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype(
+            np.float32
+        )
+
+        input_size = 3
+        hidden_size = 4
+        weight_scale = 0.1
+        custom_bias = 0.1
+        number_of_gates = 4
+
+        node = onnx.helper.make_node(
+            "LSTM",
+            inputs=["X", "W", "R", "B"],
+            outputs=["", "Y_h"],
+            hidden_size=hidden_size,
+        )
+
+        W = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, input_size)
+        ).astype(np.float32)
+        R = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, hidden_size)
+        ).astype(np.float32)
+
+        # Adding custom bias
+        W_B = custom_bias * np.ones((1, number_of_gates * hidden_size)).astype(
+            np.float32
+        )
+        R_B = np.zeros((1, number_of_gates * hidden_size)).astype(np.float32)
+        B = np.concatenate((W_B, R_B), 1)
+
+        lstm = LSTMHelper(X=input, W=W, R=R, B=B)
+        _, Y_h = lstm.step()
+        expect(
+            node,
+            inputs=[input, W, R, B],
+            outputs=[Y_h.astype(np.float32)],
+            name="test_lstm_with_initial_bias",
+        )
+
+    @staticmethod
+    def export_peepholes() -> None:
+        input = np.array([[[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]]]).astype(
+            np.float32
+        )
+
+        input_size = 4
+        hidden_size = 3
+        weight_scale = 0.1
+        number_of_gates = 4
+        number_of_peepholes = 3
+
+        node = onnx.helper.make_node(
+            "LSTM",
+            inputs=["X", "W", "R", "B", "sequence_lens", "initial_h", "initial_c", "P"],
+            outputs=["", "Y_h"],
+            hidden_size=hidden_size,
+        )
+
+        # Initializing Inputs
+        W = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, input_size)
+        ).astype(np.float32)
+        R = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, hidden_size)
+        ).astype(np.float32)
+        B = np.zeros((1, 2 * number_of_gates * hidden_size)).astype(np.float32)
+        seq_lens = np.repeat(input.shape[0], input.shape[1]).astype(np.int32)
+        init_h = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32)
+        init_c = np.zeros((1, input.shape[1], hidden_size)).astype(np.float32)
+        P = weight_scale * np.ones((1, number_of_peepholes * hidden_size)).astype(
+            np.float32
+        )
+
+        lstm = LSTMHelper(
+            X=input, W=W, R=R, B=B, P=P, initial_c=init_c, initial_h=init_h
+        )
+        _, Y_h = lstm.step()
+        expect(
+            node,
+            inputs=[input, W, R, B, seq_lens, init_h, init_c, P],
+            outputs=[Y_h.astype(np.float32)],
+            name="test_lstm_with_peepholes",
+        )
+
+    @staticmethod
+    def export_batchwise() -> None:
+        input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32)
+
+        input_size = 2
+        hidden_size = 7
+        weight_scale = 0.3
+        number_of_gates = 4
+        layout = 1
+
+        node = onnx.helper.make_node(
+            "LSTM",
+            inputs=["X", "W", "R"],
+            outputs=["Y", "Y_h"],
+            hidden_size=hidden_size,
+            layout=layout,
+        )
+
+        W = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, input_size)
+        ).astype(np.float32)
+        R = weight_scale * np.ones(
+            (1, number_of_gates * hidden_size, hidden_size)
+        ).astype(np.float32)
+
+        lstm = LSTMHelper(X=input, W=W, R=R, layout=layout)
+        Y, Y_h = lstm.step()
+        expect(
+            node,
+            inputs=[input, W, R],
+            outputs=[Y.astype(np.float32), Y_h.astype(np.float32)],
+            name="test_lstm_batchwise",
+        )
diff --git a/onnx/backend/test/case/node/matmul.py b/onnx/backend/test/case/node/matmul.py
new file mode 100644
index 0000000..3a8aeaa
--- /dev/null
+++ b/onnx/backend/test/case/node/matmul.py
@@ -0,0 +1,62 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class MatMul(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "MatMul",
+            inputs=["a", "b"],
+            outputs=["c"],
+        )
+
+        # 2d
+        a = np.random.randn(3, 4).astype(np.float32)
+        b = np.random.randn(4, 3).astype(np.float32)
+        c = np.matmul(a, b)
+        expect(node, inputs=[a, b], outputs=[c], name="test_matmul_2d")
+
+        # 3d
+        a = np.random.randn(2, 3, 4).astype(np.float32)
+        b = np.random.randn(2, 4, 3).astype(np.float32)
+        c = np.matmul(a, b)
+        expect(node, inputs=[a, b], outputs=[c], name="test_matmul_3d")
+
+        # 4d
+        a = np.random.randn(1, 2, 3, 4).astype(np.float32)
+        b = np.random.randn(1, 2, 4, 3).astype(np.float32)
+        c = np.matmul(a, b)
+        expect(node, inputs=[a, b], outputs=[c], name="test_matmul_4d")
+
+        # broadcasting
+        a = np.random.randn(3, 1, 3, 4).astype(np.float32)
+        b = np.random.randn(1, 2, 4, 2).astype(np.float32)
+        c = np.matmul(a, b)
+        expect(node, inputs=[a, b], outputs=[c], name="test_matmul_bcast")
+
+        # 1d + 3d
+        a = np.random.randn(4).astype(np.float32)
+        b = np.random.randn(2, 4, 1).astype(np.float32)
+        c = np.matmul(a, b)
+        expect(node, inputs=[a, b], outputs=[c], name="test_matmul_1d_3d")
+
+        # 3d + 1d
+        a = np.random.randn(1, 2, 4, 3).astype(np.float32)
+        b = np.random.randn(3).astype(np.float32)
+        c = np.matmul(a, b)
+        expect(node, inputs=[a, b], outputs=[c], name="test_matmul_4d_1d")
+
+        # 1d + 1d
+        a = np.random.randn(3).astype(np.float32)
+        b = np.random.randn(3).astype(np.float32)
+        c = np.matmul(a, b)
+        expect(node, inputs=[a, b], outputs=[c], name="test_matmul_1d_1d")
diff --git a/onnx/backend/test/case/node/matmulinteger.py b/onnx/backend/test/case/node/matmulinteger.py
new file mode 100644
index 0000000..4df5633
--- /dev/null
+++ b/onnx/backend/test/case/node/matmulinteger.py
@@ -0,0 +1,60 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class MatMulInteger(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "MatMulInteger",
+            inputs=["A", "B", "a_zero_point", "b_zero_point"],
+            outputs=["Y"],
+        )
+
+        A = np.array(
+            [
+                [11, 7, 3],
+                [10, 6, 2],
+                [9, 5, 1],
+                [8, 4, 0],
+            ],
+            dtype=np.uint8,
+        )
+
+        a_zero_point = np.array([12], dtype=np.uint8)
+
+        B = np.array(
+            [
+                [1, 4],
+                [2, 5],
+                [3, 6],
+            ],
+            dtype=np.uint8,
+        )
+
+        b_zero_point = np.array([0], dtype=np.uint8)
+
+        output = np.array(
+            [
+                [-38, -83],
+                [-44, -98],
+                [-50, -113],
+                [-56, -128],
+            ],
+            dtype=np.int32,
+        )
+
+        expect(
+            node,
+            inputs=[A, B, a_zero_point, b_zero_point],
+            outputs=[output],
+            name="test_matmulinteger",
+        )
diff --git a/onnx/backend/test/case/node/max.py b/onnx/backend/test/case/node/max.py
new file mode 100644
index 0000000..139cfc8
--- /dev/null
+++ b/onnx/backend/test/case/node/max.py
@@ -0,0 +1,66 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.backend.test.case.utils import all_numeric_dtypes
+
+
+class Max(Base):
+    @staticmethod
+    def export() -> None:
+        data_0 = np.array([3, 2, 1]).astype(np.float32)
+        data_1 = np.array([1, 4, 4]).astype(np.float32)
+        data_2 = np.array([2, 5, 3]).astype(np.float32)
+        result = np.array([3, 5, 4]).astype(np.float32)
+        node = onnx.helper.make_node(
+            "Max",
+            inputs=["data_0", "data_1", "data_2"],
+            outputs=["result"],
+        )
+        expect(
+            node,
+            inputs=[data_0, data_1, data_2],
+            outputs=[result],
+            name="test_max_example",
+        )
+
+        node = onnx.helper.make_node(
+            "Max",
+            inputs=["data_0"],
+            outputs=["result"],
+        )
+        expect(node, inputs=[data_0], outputs=[data_0], name="test_max_one_input")
+
+        result = np.maximum(data_0, data_1)
+        node = onnx.helper.make_node(
+            "Max",
+            inputs=["data_0", "data_1"],
+            outputs=["result"],
+        )
+        expect(
+            node, inputs=[data_0, data_1], outputs=[result], name="test_max_two_inputs"
+        )
+
+    @staticmethod
+    def export_max_all_numeric_types() -> None:
+        for op_dtype in all_numeric_dtypes:
+            data_0 = np.array([3, 2, 1]).astype(op_dtype)
+            data_1 = np.array([1, 4, 4]).astype(op_dtype)
+            result = np.array([3, 4, 4]).astype(op_dtype)
+            node = onnx.helper.make_node(
+                "Max",
+                inputs=["data_0", "data_1"],
+                outputs=["result"],
+            )
+            expect(
+                node,
+                inputs=[data_0, data_1],
+                outputs=[result],
+                name=f"test_max_{np.dtype(op_dtype).name}",
+            )
diff --git a/onnx/backend/test/case/node/maxpool.py b/onnx/backend/test/case/node/maxpool.py
new file mode 100644
index 0000000..c9f6b60
--- /dev/null
+++ b/onnx/backend/test/case/node/maxpool.py
@@ -0,0 +1,725 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_pool_common import (
+    get_output_shape_auto_pad,
+    get_output_shape_explicit_padding,
+    get_pad_shape,
+    pool,
+)
+
+
+class MaxPool(Base):
+    @staticmethod
+    def export_maxpool_2d_uint8() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 5, 5]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[5, 5],
+            pads=[2, 2, 2, 2],
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.uint8)
+        y = np.array(
+            [
+                [
+                    [
+                        [13, 14, 15, 15, 15],
+                        [18, 19, 20, 20, 20],
+                        [23, 24, 25, 25, 25],
+                        [23, 24, 25, 25, 25],
+                        [23, 24, 25, 25, 25],
+                    ]
+                ]
+            ]
+        ).astype(np.uint8)
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_uint8")
+
+    @staticmethod
+    def export_maxpool_2d_precomputed_pads() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 5, 5]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[5, 5],
+            pads=[2, 2, 2, 2],
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array(
+            [
+                [
+                    [
+                        [13, 14, 15, 15, 15],
+                        [18, 19, 20, 20, 20],
+                        [23, 24, 25, 25, 25],
+                        [23, 24, 25, 25, 25],
+                        [23, 24, 25, 25, 25],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_pads")
+
+    @staticmethod
+    def export_maxpool_with_argmax_2d_precomputed_pads() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 5, 5]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y", "z"],
+            kernel_shape=[5, 5],
+            pads=[2, 2, 2, 2],
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array(
+            [
+                [
+                    [
+                        [13, 14, 15, 15, 15],
+                        [18, 19, 20, 20, 20],
+                        [23, 24, 25, 25, 25],
+                        [23, 24, 25, 25, 25],
+                        [23, 24, 25, 25, 25],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        z = np.array(
+            [
+                [
+                    [
+                        [12, 13, 14, 14, 14],
+                        [17, 18, 19, 19, 19],
+                        [22, 23, 24, 24, 24],
+                        [22, 23, 24, 24, 24],
+                        [22, 23, 24, 24, 24],
+                    ]
+                ]
+            ]
+        ).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y, z],
+            name="test_maxpool_with_argmax_2d_precomputed_pads",
+        )
+
+    @staticmethod
+    def export_maxpool_2d_precomputed_strides() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 2, 2]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[2, 2], strides=[2, 2]
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32)
+
+        expect(
+            node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_strides"
+        )
+
+    @staticmethod
+    def export_maxpool_with_argmax_2d_precomputed_strides() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 2, 2]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y", "z"],
+            kernel_shape=[2, 2],
+            strides=[2, 2],
+            storage_order=1,
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[7, 9], [17, 19]]]]).astype(np.float32)
+        z = np.array([[[[6, 16], [8, 18]]]]).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y, z],
+            name="test_maxpool_with_argmax_2d_precomputed_strides",
+        )
+
+    @staticmethod
+    def export_maxpool_2d_precomputed_same_upper() -> None:
+        """input_shape: [1, 1, 5, 5]
+        output_shape: [1, 1, 3, 3]
+        pad_shape: [2, 2] -> [1, 1, 1, 1] by axis
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            strides=[2, 2],
+            auto_pad="SAME_UPPER",
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [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],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[7, 9, 10], [17, 19, 20], [22, 24, 25]]]]).astype(np.float32)
+
+        expect(
+            node, inputs=[x], outputs=[y], name="test_maxpool_2d_precomputed_same_upper"
+        )
+
+    @staticmethod
+    def export_maxpool_1d_default() -> None:
+        """input_shape: [1, 3, 32]
+        output_shape: [1, 3, 31]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2],
+        )
+        x = np.random.randn(1, 3, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = [2]
+        strides = [1]
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_1d_default")
+
+    @staticmethod
+    def export_maxpool_2d_default() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 31, 31]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_default")
+
+    @staticmethod
+    def export_maxpool_3d_default() -> None:
+        """input_shape: [1, 3, 32, 32, 32]
+        output_shape: [1, 3, 31, 31, 31]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2, 2],
+        )
+        x = np.random.randn(1, 3, 32, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = [2, 2, 2]
+        strides = [1, 1, 1]
+        out_shape, _ = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_3d_default")
+
+    @staticmethod
+    def export_maxpool_2d_same_upper() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 32, 32]
+        pad_shape: [1, 1] -> [0, 1, 0, 1] by axis
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            auto_pad="SAME_UPPER",
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape = get_output_shape_auto_pad(
+            "SAME_UPPER", x_shape[2:], kernel_shape, strides
+        )
+        pad_shape = get_pad_shape(
+            "SAME_UPPER", x_shape[2:], kernel_shape, strides, out_shape
+        )
+        pad_top = pad_shape[0] // 2
+        pad_bottom = pad_shape[0] - pad_top
+        pad_left = pad_shape[1] // 2
+        pad_right = pad_shape[1] - pad_left
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=np.nan,
+        )
+        pads = [pad_top, pad_left, pad_bottom, pad_right]
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads)
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_upper")
+
+    @staticmethod
+    def export_maxpool_2d_same_lower() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 32, 32]
+        pad_shape: [1, 1] -> [1, 0, 1, 0] by axis
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            auto_pad="SAME_LOWER",
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (2, 2)
+        strides = (1, 1)
+        out_shape = get_output_shape_auto_pad(
+            "SAME_LOWER", x_shape[2:], kernel_shape, strides
+        )
+        pad_shape = get_pad_shape(
+            "SAME_LOWER", x_shape[2:], kernel_shape, strides, out_shape
+        )
+        pad_bottom = pad_shape[0] // 2
+        pad_top = pad_shape[0] - pad_bottom
+        pad_right = pad_shape[1] // 2
+        pad_left = pad_shape[1] - pad_right
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=np.nan,
+        )
+        pads = [pad_top, pad_left, pad_bottom, pad_right]
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX", pads, pads)
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_same_lower")
+
+    @staticmethod
+    def export_maxpool_2d_pads() -> None:
+        """input_shape: [1, 3, 28, 28]
+        output_shape: [1, 3, 30, 30]
+        pad_shape: [4, 4] -> [2, 2, 2, 2] by axis
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            pads=[2, 2, 2, 2],
+        )
+        x = np.random.randn(1, 3, 28, 28).astype(np.float32)
+        x_shape = np.shape(x)
+        kernel_shape = (3, 3)
+        strides = (1, 1)
+        pad_bottom = pad_top = pad_right = pad_left = 2
+        pads = [pad_top, pad_left, pad_bottom, pad_right]
+        out_shape, extra_pads = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+            mode="constant",
+            constant_values=np.nan,
+        )
+
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            "MAX",
+            pads_required=extra_pads,
+            pads=pads,
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_pads")
+
+    @staticmethod
+    def export_maxpool_2d_strides() -> None:
+        """input_shape: [1, 3, 32, 32]
+        output_shape: [1, 3, 10, 10]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool", inputs=["x"], outputs=["y"], kernel_shape=[5, 5], strides=[3, 3]
+        )
+        x = np.random.randn(1, 3, 32, 32).astype(np.float32)
+        x_shape = np.shape(x)
+        pads = None
+        kernel_shape = (5, 5)
+        strides = (3, 3)
+        out_shape, pads = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides
+        )
+        padded = x
+        y = pool(padded, x_shape, kernel_shape, strides, out_shape, "MAX")
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_strides")
+
+    @staticmethod
+    def export_maxpool_2d_ceil() -> None:
+        """input_shape: [1, 1, 4, 4]
+        output_shape: [1, 1, 2, 2]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            strides=[2, 2],
+            ceil_mode=True,
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32)
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_ceil")
+
+    @staticmethod
+    def export_maxpool_2d_ceil_output_size_reduce_by_one() -> None:
+        """input_shape: [1, 1, 2, 2]
+        output_shape: [1, 1, 1, 1]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[1, 1],
+            strides=[2, 2],
+            ceil_mode=True,
+        )
+        x = np.array([[[[1, 2], [3, 4]]]]).astype(np.float32)
+        y = np.array([[[[1]]]]).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_maxpool_2d_ceil_output_size_reduce_by_one",
+        )
+
+    @staticmethod
+    def export_maxpool_2d_dilations() -> None:
+        """input_shape: [1, 1, 4, 4]
+        output_shape: [1, 1, 2, 2]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            strides=[1, 1],
+            dilations=[2, 2],
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[11, 12], [15, 16]]]]).astype(np.float32)
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_2d_dilations")
+
+    @staticmethod
+    def export_maxpool_3d_dilations() -> None:
+        """input_shape: [1, 1, 4, 4, 4]
+        output_shape: [1, 1, 2, 2, 2]
+        """
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2, 2],
+            strides=[1, 1, 1],
+            dilations=[2, 2, 2],
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+        y = np.array([[[[[11, 12], [15, 16]], [[11, 12], [15, 16]]]]]).astype(
+            np.float32
+        )
+
+        expect(node, inputs=[x], outputs=[y], name="test_maxpool_3d_dilations")
+
+    @staticmethod
+    def export_maxpool_3d_dilations_use_ref_impl() -> None:
+        """input_shape: [1, 1, 4, 4, 4]
+        output_shape: [1, 1, 2, 2, 2]
+        """
+        dilations = [2, 2, 2]
+        kernel_shape = [2, 2, 2]
+        strides = [1, 1, 1]
+        ceil_mode = False
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=[2, 2, 2],
+            strides=[1, 1, 1],
+            dilations=dilations,
+        )
+        x = np.array(
+            [
+                [
+                    [
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                        [
+                            [1, 2, 3, 4],
+                            [5, 6, 7, 8],
+                            [9, 10, 11, 12],
+                            [13, 14, 15, 16],
+                        ],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        x_shape = x.shape[2:]
+        out_shape, pads = get_output_shape_explicit_padding(
+            None, x_shape, kernel_shape, strides, dilations, ceil_mode=ceil_mode
+        )
+        padded = x
+        y = pool(
+            padded,
+            (1, 1, *x_shape),
+            kernel_shape,
+            strides,
+            out_shape,
+            "MAX",
+            pads_required=pads,
+            pads=None,
+            dilations=dilations,
+        )
+
+        expect(
+            node, inputs=[x], outputs=[y], name="test_maxpool_3d_dilations_use_ref_impl"
+        )
+
+    @staticmethod
+    def export_maxpool_3d_dilations_use_ref_impl_large() -> None:
+        x_shape = (32, 32, 32)
+        dilations = (2, 2, 2)
+        kernel_shape = (5, 5, 5)
+        strides = (3, 3, 3)
+        ceil_mode = True
+
+        node = onnx.helper.make_node(
+            "MaxPool",
+            inputs=["x"],
+            outputs=["y"],
+            kernel_shape=kernel_shape,
+            strides=strides,
+            dilations=dilations,
+            ceil_mode=ceil_mode,
+        )
+
+        x = np.random.randn(1, 1, *x_shape).astype(np.float32)
+        out_shape, pads = get_output_shape_explicit_padding(
+            None, x_shape, kernel_shape, strides, dilations, ceil_mode=ceil_mode
+        )
+        padded = np.pad(
+            x,
+            (
+                (0, 0),
+                (0, 0),
+                (pads[0], pads[3]),
+                (pads[1], pads[4]),
+                (pads[2], pads[5]),
+            ),
+            mode="constant",
+            constant_values=0,
+        )
+        y = pool(
+            padded,
+            (1, 1, *x_shape),
+            kernel_shape,
+            strides,
+            out_shape,
+            "MAX",
+            pads_required=pads,
+            pads=None,
+            dilations=dilations,
+        )
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_maxpool_3d_dilations_use_ref_impl_large",
+        )
diff --git a/onnx/backend/test/case/node/maxunpool.py b/onnx/backend/test/case/node/maxunpool.py
new file mode 100644
index 0000000..a30aa06
--- /dev/null
+++ b/onnx/backend/test/case/node/maxunpool.py
@@ -0,0 +1,67 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class MaxUnpool(Base):
+    @staticmethod
+    def export_without_output_shape() -> None:
+        node = onnx.helper.make_node(
+            "MaxUnpool",
+            inputs=["xT", "xI"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            strides=[2, 2],
+        )
+        xT = np.array([[[[1, 2], [3, 4]]]], dtype=np.float32)
+        xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64)
+        y = np.array(
+            [[[[0, 0, 0, 0], [0, 1, 0, 2], [0, 0, 0, 0], [0, 3, 0, 4]]]],
+            dtype=np.float32,
+        )
+        expect(
+            node,
+            inputs=[xT, xI],
+            outputs=[y],
+            name="test_maxunpool_export_without_output_shape",
+        )
+
+    @staticmethod
+    def export_with_output_shape() -> None:
+        node = onnx.helper.make_node(
+            "MaxUnpool",
+            inputs=["xT", "xI", "output_shape"],
+            outputs=["y"],
+            kernel_shape=[2, 2],
+            strides=[2, 2],
+        )
+        xT = np.array([[[[5, 6], [7, 8]]]], dtype=np.float32)
+        xI = np.array([[[[5, 7], [13, 15]]]], dtype=np.int64)
+        output_shape = np.array((1, 1, 5, 5), dtype=np.int64)
+        y = np.array(
+            [
+                [
+                    [
+                        [0, 0, 0, 0, 0],
+                        [0, 5, 0, 6, 0],
+                        [0, 0, 0, 0, 0],
+                        [0, 7, 0, 8, 0],
+                        [0, 0, 0, 0, 0],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+        expect(
+            node,
+            inputs=[xT, xI, output_shape],
+            outputs=[y],
+            name="test_maxunpool_export_with_output_shape",
+        )
diff --git a/onnx/backend/test/case/node/mean.py b/onnx/backend/test/case/node/mean.py
new file mode 100644
index 0000000..f564aef
--- /dev/null
+++ b/onnx/backend/test/case/node/mean.py
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Mean(Base):
+    @staticmethod
+    def export() -> None:
+        data_0 = np.array([3, 0, 2]).astype(np.float32)
+        data_1 = np.array([1, 3, 4]).astype(np.float32)
+        data_2 = np.array([2, 6, 6]).astype(np.float32)
+        result = np.array([2, 3, 4]).astype(np.float32)
+        node = onnx.helper.make_node(
+            "Mean",
+            inputs=["data_0", "data_1", "data_2"],
+            outputs=["result"],
+        )
+        expect(
+            node,
+            inputs=[data_0, data_1, data_2],
+            outputs=[result],
+            name="test_mean_example",
+        )
+
+        node = onnx.helper.make_node(
+            "Mean",
+            inputs=["data_0"],
+            outputs=["result"],
+        )
+        expect(node, inputs=[data_0], outputs=[data_0], name="test_mean_one_input")
+
+        result = np.divide(np.add(data_0, data_1), 2.0)
+        node = onnx.helper.make_node(
+            "Mean",
+            inputs=["data_0", "data_1"],
+            outputs=["result"],
+        )
+        expect(
+            node, inputs=[data_0, data_1], outputs=[result], name="test_mean_two_inputs"
+        )
diff --git a/onnx/backend/test/case/node/meanvariancenormalization.py b/onnx/backend/test/case/node/meanvariancenormalization.py
new file mode 100644
index 0000000..690eb43
--- /dev/null
+++ b/onnx/backend/test/case/node/meanvariancenormalization.py
@@ -0,0 +1,49 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class MeanVarianceNormalization(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "MeanVarianceNormalization", inputs=["X"], outputs=["Y"]
+        )
+
+        input_data = np.array(
+            [
+                [
+                    [[0.8439683], [0.5665144], [0.05836735]],
+                    [[0.02916367], [0.12964272], [0.5060197]],
+                    [[0.79538304], [0.9411346], [0.9546573]],
+                ],
+                [
+                    [[0.17730942], [0.46192095], [0.26480448]],
+                    [[0.6746842], [0.01665257], [0.62473077]],
+                    [[0.9240844], [0.9722341], [0.11965699]],
+                ],
+                [
+                    [[0.41356155], [0.9129373], [0.59330076]],
+                    [[0.81929934], [0.7862604], [0.11799799]],
+                    [[0.69248444], [0.54119414], [0.07513223]],
+                ],
+            ],
+            dtype=np.float32,
+        )
+
+        # Calculate expected output data
+        data_mean = np.mean(input_data, axis=(0, 2, 3), keepdims=1)
+        data_mean_squared = np.power(data_mean, 2)
+        data_squared = np.power(input_data, 2)
+        data_squared_mean = np.mean(data_squared, axis=(0, 2, 3), keepdims=1)
+        std = np.sqrt(data_squared_mean - data_mean_squared)
+        expected_output = (input_data - data_mean) / (std + 1e-9)
+
+        expect(node, inputs=[input_data], outputs=[expected_output], name="test_mvn")
diff --git a/onnx/backend/test/case/node/melweightmatrix.py b/onnx/backend/test/case/node/melweightmatrix.py
new file mode 100644
index 0000000..22fb87a
--- /dev/null
+++ b/onnx/backend/test/case/node/melweightmatrix.py
@@ -0,0 +1,90 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class MelWeightMatrix(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "MelWeightMatrix",
+            inputs=[
+                "num_mel_bins",
+                "dft_length",
+                "sample_rate",
+                "lower_edge_hertz",
+                "upper_edge_hertz",
+            ],
+            outputs=["output"],
+        )
+
+        num_mel_bins = np.int32(8)
+        dft_length = np.int32(16)
+        sample_rate = np.int32(8192)
+        lower_edge_hertz = np.float32(0)
+        upper_edge_hertz = np.float32(8192 / 2)
+
+        num_spectrogram_bins = dft_length // 2 + 1
+        frequency_bins = np.arange(0, num_mel_bins + 2)
+
+        low_frequency_mel = 2595 * np.log10(1 + lower_edge_hertz / 700)
+        high_frequency_mel = 2595 * np.log10(1 + upper_edge_hertz / 700)
+        mel_step = (high_frequency_mel - low_frequency_mel) / frequency_bins.shape[0]
+
+        frequency_bins = frequency_bins * mel_step + low_frequency_mel
+        frequency_bins = 700 * (np.power(10, (frequency_bins / 2595)) - 1)
+        frequency_bins = ((dft_length + 1) * frequency_bins) // sample_rate
+        frequency_bins = frequency_bins.astype(int)
+
+        output = np.zeros((num_spectrogram_bins, num_mel_bins))
+        output.flags.writeable = True
+
+        for i in range(num_mel_bins):
+            lower_frequency_value = frequency_bins[i]  # left
+            center_frequency_point = frequency_bins[i + 1]  # center
+            higher_frequency_point = frequency_bins[i + 2]  # right
+            low_to_center = center_frequency_point - lower_frequency_value
+            if low_to_center == 0:
+                output[center_frequency_point, i] = 1
+            else:
+                for j in range(lower_frequency_value, center_frequency_point + 1):
+                    output[j, i] = float(j - lower_frequency_value) / float(
+                        low_to_center
+                    )
+            center_to_high = higher_frequency_point - center_frequency_point
+            if center_to_high > 0:
+                for j in range(center_frequency_point, higher_frequency_point):
+                    output[j, i] = float(higher_frequency_point - j) / float(
+                        center_to_high
+                    )
+
+        # Expected output
+        # 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+        # 0.000000, 0.000000, 1.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+        # 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000,
+        # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000,
+        # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000,
+        # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000,
+        # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+        # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+        # 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000000,
+        output = output.astype(np.float32)
+        expect(
+            node,
+            inputs=[
+                num_mel_bins,
+                dft_length,
+                sample_rate,
+                lower_edge_hertz,
+                upper_edge_hertz,
+            ],
+            outputs=[output],
+            name="test_melweightmatrix",
+        )
diff --git a/onnx/backend/test/case/node/min.py b/onnx/backend/test/case/node/min.py
new file mode 100644
index 0000000..30afe00
--- /dev/null
+++ b/onnx/backend/test/case/node/min.py
@@ -0,0 +1,66 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.backend.test.case.utils import all_numeric_dtypes
+
+
+class Min(Base):
+    @staticmethod
+    def export() -> None:
+        data_0 = np.array([3, 2, 1]).astype(np.float32)
+        data_1 = np.array([1, 4, 4]).astype(np.float32)
+        data_2 = np.array([2, 5, 0]).astype(np.float32)
+        result = np.array([1, 2, 0]).astype(np.float32)
+        node = onnx.helper.make_node(
+            "Min",
+            inputs=["data_0", "data_1", "data_2"],
+            outputs=["result"],
+        )
+        expect(
+            node,
+            inputs=[data_0, data_1, data_2],
+            outputs=[result],
+            name="test_min_example",
+        )
+
+        node = onnx.helper.make_node(
+            "Min",
+            inputs=["data_0"],
+            outputs=["result"],
+        )
+        expect(node, inputs=[data_0], outputs=[data_0], name="test_min_one_input")
+
+        result = np.minimum(data_0, data_1)
+        node = onnx.helper.make_node(
+            "Min",
+            inputs=["data_0", "data_1"],
+            outputs=["result"],
+        )
+        expect(
+            node, inputs=[data_0, data_1], outputs=[result], name="test_min_two_inputs"
+        )
+
+    @staticmethod
+    def export_min_all_numeric_types() -> None:
+        for op_dtype in all_numeric_dtypes:
+            data_0 = np.array([3, 2, 1]).astype(op_dtype)
+            data_1 = np.array([1, 4, 4]).astype(op_dtype)
+            result = np.array([1, 2, 1]).astype(op_dtype)
+            node = onnx.helper.make_node(
+                "Min",
+                inputs=["data_0", "data_1"],
+                outputs=["result"],
+            )
+            expect(
+                node,
+                inputs=[data_0, data_1],
+                outputs=[result],
+                name=f"test_min_{np.dtype(op_dtype).name}",
+            )
diff --git a/onnx/backend/test/case/node/mish.py b/onnx/backend/test/case/node/mish.py
new file mode 100644
index 0000000..fafac67
--- /dev/null
+++ b/onnx/backend/test/case/node/mish.py
@@ -0,0 +1,23 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Mish(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node("Mish", inputs=["X"], outputs=["Y"])
+
+        input_data = np.linspace(-10, 10, 10000, dtype=np.float32)
+
+        # Calculate expected output data
+        expected_output = input_data * np.tanh(np.log1p(np.exp(input_data)))
+
+        expect(node, inputs=[input_data], outputs=[expected_output], name="test_mish")
diff --git a/onnx/backend/test/case/node/mod.py b/onnx/backend/test/case/node/mod.py
new file mode 100644
index 0000000..580e2a0
--- /dev/null
+++ b/onnx/backend/test/case/node/mod.py
@@ -0,0 +1,177 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Mod(Base):
+    @staticmethod
+    def export_mod_mixed_sign_float64() -> None:
+        node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+        x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float64)
+        y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float64)
+        z = np.fmod(x, y)  # expected output [-0.1,  0.4,  5. ,  0.1, -0.4,  3.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float64")
+
+    @staticmethod
+    def export_mod_mixed_sign_float32() -> None:
+        node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+        x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float32)
+        y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float32)
+        z = np.fmod(
+            x, y
+        )  # expected output [-0.10000038, 0.39999962, 5. , 0.10000038, -0.39999962, 3.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float32")
+
+    @staticmethod
+    def export_mod_mixed_sign_float16() -> None:
+        node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+        x = np.array([-4.3, 7.2, 5.0, 4.3, -7.2, 8.0]).astype(np.float16)
+        y = np.array([2.1, -3.4, 8.0, -2.1, 3.4, 5.0]).astype(np.float16)
+        z = np.fmod(
+            x, y
+        )  # expected output [-0.10156, 0.3984 , 5. , 0.10156, -0.3984 ,  3.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_float16")
+
+    @staticmethod
+    def export_mod_mixed_sign_int64() -> None:
+        node = onnx.helper.make_node(
+            "Mod",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64)
+        y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64)
+        z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int64")
+
+    @staticmethod
+    def export_mod_mixed_sign_int32() -> None:
+        node = onnx.helper.make_node(
+            "Mod",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int32)
+        y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int32)
+        z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int32")
+
+    @staticmethod
+    def export_mod_mixed_sign_int16() -> None:
+        node = onnx.helper.make_node(
+            "Mod",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int16)
+        y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int16)
+        z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int16")
+
+    @staticmethod
+    def export_mod_mixed_sign_int8() -> None:
+        node = onnx.helper.make_node(
+            "Mod",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int8)
+        y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int8)
+        z = np.mod(x, y)  # expected output [ 0, -2,  5,  0,  2,  3]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_mixed_sign_int8")
+
+    @staticmethod
+    def export_mod_uint8() -> None:
+        node = onnx.helper.make_node(
+            "Mod",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([4, 7, 5]).astype(np.uint8)
+        y = np.array([2, 3, 8]).astype(np.uint8)
+        z = np.mod(x, y)  # expected output [0, 1, 5]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint8")
+
+    @staticmethod
+    def export_mod_uint16() -> None:
+        node = onnx.helper.make_node(
+            "Mod",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([4, 7, 5]).astype(np.uint16)
+        y = np.array([2, 3, 8]).astype(np.uint16)
+        z = np.mod(x, y)  # expected output [0, 1, 5]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint16")
+
+    @staticmethod
+    def export_mod_uint32() -> None:
+        node = onnx.helper.make_node(
+            "Mod",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([4, 7, 5]).astype(np.uint32)
+        y = np.array([2, 3, 8]).astype(np.uint32)
+        z = np.mod(x, y)  # expected output [0, 1, 5]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint32")
+
+    @staticmethod
+    def export_mod_uint64() -> None:
+        node = onnx.helper.make_node(
+            "Mod",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([4, 7, 5]).astype(np.uint64)
+        y = np.array([2, 3, 8]).astype(np.uint64)
+        z = np.mod(x, y)  # expected output [0, 1, 5]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_uint64")
+
+    @staticmethod
+    def export_mod_int64_fmod() -> None:
+        node = onnx.helper.make_node("Mod", inputs=["x", "y"], outputs=["z"], fmod=1)
+
+        x = np.array([-4, 7, 5, 4, -7, 8]).astype(np.int64)
+        y = np.array([2, -3, 8, -2, 3, 5]).astype(np.int64)
+        z = np.fmod(x, y)  # expected output [ 0,  1,  5,  0, -1,  3]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_int64_fmod")
+
+    @staticmethod
+    def export_mod_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Mod",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.arange(0, 30).reshape([3, 2, 5]).astype(np.int32)
+        y = np.array([7]).astype(np.int32)
+        z = np.mod(x, y)
+        #   array([[[0, 1, 2, 3, 4],
+        #     [5, 6, 0, 1, 2]],
+
+        #    [[3, 4, 5, 6, 0],
+        #     [1, 2, 3, 4, 5]],
+
+        #    [[6, 0, 1, 2, 3],
+        #     [4, 5, 6, 0, 1]]], dtype=int32)
+        expect(node, inputs=[x, y], outputs=[z], name="test_mod_broadcast")
diff --git a/onnx/backend/test/case/node/momentum.py b/onnx/backend/test/case/node/momentum.py
new file mode 100644
index 0000000..266e87f
--- /dev/null
+++ b/onnx/backend/test/case/node/momentum.py
@@ -0,0 +1,162 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.defs import AI_ONNX_PREVIEW_TRAINING_DOMAIN
+
+
+def apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta):
+    # Add gradient of regularization term.
+    g_regularized = norm_coefficient * x + g
+    # Coefficient of gradient should be 1 at the first iteration.
+    beta_adjusted = beta if t > 0 else 1
+    # Update momentum.
+    v_new = alpha * v + beta_adjusted * g_regularized
+    # Apply SG with momentum update rule.
+    x_new = x - r * v_new
+    return x_new, v_new
+
+
+def apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta):
+    # Add gradient of regularization term.
+    g_regularized = norm_coefficient * x + g
+    # Coefficient of gradient should be 1 at the first iteration.
+    beta_adjusted = beta if t > 0 else 1
+    # Update momentum.
+    v_new = alpha * v + beta_adjusted * g_regularized
+    # Apply Nesterov with momentum update rule.
+    x_new = x - r * (g_regularized + alpha * v_new)
+    return x_new, v_new
+
+
+class Momentum(Base):
+    @staticmethod
+    def export_momentum() -> None:
+        # Define operator attributes.
+        norm_coefficient = 0.001
+        alpha = 0.95
+        beta = 0.1
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "Momentum",
+            inputs=["R", "T", "X", "G", "V"],
+            outputs=["X_new", "V_new"],
+            norm_coefficient=norm_coefficient,
+            alpha=alpha,
+            beta=beta,
+            mode="standard",
+            domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+        )
+
+        # Define operator inputs.
+        r = np.array(0.1, dtype=np.float32)  # scalar
+        t = np.array(0, dtype=np.int64)  # scalar
+        x = np.array([1.2, 2.8], dtype=np.float32)
+        g = np.array([-0.94, -2.5], dtype=np.float32)
+        v = np.array([1.7, 3.6], dtype=np.float32)
+
+        # Compute expected outputs of Momentum.
+        x_new, v_new = apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta)
+
+        # Check results.
+        expect(
+            node,
+            inputs=[r, t, x, g, v],
+            outputs=[x_new, v_new],
+            name="test_momentum",
+            opset_imports=[
+                onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+            ],
+        )
+
+    @staticmethod
+    def export_nesterov_momentum() -> None:
+        # Define operator attributes.
+        norm_coefficient = 0.01
+        alpha = 0.95
+        beta = 1.0
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "Momentum",
+            inputs=["R", "T", "X", "G", "V"],
+            outputs=["X_new", "V_new"],
+            norm_coefficient=norm_coefficient,
+            alpha=alpha,
+            beta=beta,
+            mode="nesterov",
+            domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+        )
+
+        # Define operator inputs.
+        r = np.array(0.1, dtype=np.float32)  # scalar
+        t = np.array(0, dtype=np.int64)  # scalar
+        x = np.array([1.2, 2.8], dtype=np.float32)
+        g = np.array([-0.94, -2.5], dtype=np.float32)
+        v = np.array([1.7, 3.6], dtype=np.float32)
+
+        # Compute expected outputs of Momentum.
+        x_new, v_new = apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta)
+
+        # Check results.
+        expect(
+            node,
+            inputs=[r, t, x, g, v],
+            outputs=[x_new, v_new],
+            name="test_nesterov_momentum",
+            opset_imports=[
+                onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+            ],
+        )
+
+    @staticmethod
+    def export_momentum_multiple() -> None:
+        # Define operator attributes.
+        norm_coefficient = 0.001
+        alpha = 0.95
+        beta = 0.85
+
+        node = onnx.helper.make_node(
+            "Momentum",
+            inputs=["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"],
+            outputs=["X1_new", "X2_new", "V1_new", "V2_new"],
+            norm_coefficient=norm_coefficient,
+            alpha=alpha,
+            beta=beta,
+            mode="standard",
+            domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+        )
+
+        # Define operator inputs.
+        r = np.array(0.1, dtype=np.float32)  # scalar
+        t = np.array(0, dtype=np.int64)  # scalar
+
+        x1 = np.array([1.0], dtype=np.float32)
+        g1 = np.array([-1.0], dtype=np.float32)
+        v1 = np.array([2.0], dtype=np.float32)
+
+        x2 = np.array([1.0, 2.0], dtype=np.float32)
+        g2 = np.array([-1.0, -3.0], dtype=np.float32)
+        v2 = np.array([4.0, 1.0], dtype=np.float32)
+
+        # Compute expected outputs of Momentum.
+        x1_new, v1_new = apply_momentum(r, t, x1, g1, v1, norm_coefficient, alpha, beta)
+        x2_new, v2_new = apply_momentum(r, t, x2, g2, v2, norm_coefficient, alpha, beta)
+
+        # Check results.
+        expect(
+            node,
+            inputs=[r, t, x1, x2, g1, g2, v1, v2],
+            outputs=[x1_new, x2_new, v1_new, v2_new],
+            name="test_momentum_multiple",
+            opset_imports=[
+                onnx.helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1)
+            ],
+        )
diff --git a/onnx/backend/test/case/node/mul.py b/onnx/backend/test/case/node/mul.py
new file mode 100644
index 0000000..6ae1f9c
--- /dev/null
+++ b/onnx/backend/test/case/node/mul.py
@@ -0,0 +1,73 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Mul(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Mul",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([1, 2, 3]).astype(np.float32)
+        y = np.array([4, 5, 6]).astype(np.float32)
+        z = x * y  # expected output [4., 10., 18.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(3, 4, 5).astype(np.float32)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul")
+
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.int8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int8)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_int8")
+
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.int16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.int16)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_int16")
+
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint8)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint8")
+
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint16)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint16")
+
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint32)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint32")
+
+        x = np.random.randint(4, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(24, size=(3, 4, 5), dtype=np.uint64)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_uint64")
+
+    @staticmethod
+    def export_mul_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Mul",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(5).astype(np.float32)
+        z = x * y
+        expect(node, inputs=[x, y], outputs=[z], name="test_mul_bcast")
diff --git a/onnx/backend/test/case/node/neg.py b/onnx/backend/test/case/node/neg.py
new file mode 100644
index 0000000..1082d33
--- /dev/null
+++ b/onnx/backend/test/case/node/neg.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Neg(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Neg",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-4, 2]).astype(np.float32)
+        y = np.negative(x)  # expected output [4., -2.],
+        expect(node, inputs=[x], outputs=[y], name="test_neg_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.negative(x)
+        expect(node, inputs=[x], outputs=[y], name="test_neg")
diff --git a/onnx/backend/test/case/node/negativeloglikelihoodloss.py b/onnx/backend/test/case/node/negativeloglikelihoodloss.py
new file mode 100644
index 0000000..c5fcdd8
--- /dev/null
+++ b/onnx/backend/test/case/node/negativeloglikelihoodloss.py
@@ -0,0 +1,585 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def compute_negative_log_likelihood_loss(
+    input, target, weight=None, reduction="mean", ignore_index=None
+):
+    input_shape = input.shape
+    if len(input_shape) == 1:
+        raise RuntimeError("Unsupported shape")
+
+    target_shape = target.shape
+    N = input_shape[0]
+    C = input_shape[1]
+
+    # initialize the positional weights when required
+    gather_weight = None
+    if weight is not None:
+        # setting mode='clip' to deal with ignore_index > C or < 0 cases.
+        # when the target value is > C or < 0, it doesn't matter which value we are
+        # taking in gather_weight, since it will be set to 0 in the following if-block
+        # use np.int32 to make it compatible with x86 machines
+        gather_weight = np.take(weight, np.array(target, dtype=np.int32), mode="clip")
+        # set `ignore_index`'s loss weight to 0.
+        # The loss tensor will be multiplied by this weight tensor,
+        # so `ignore_index`'s loss value will be eliminated.
+        if ignore_index is not None:
+            gather_weight = np.where(target == ignore_index, 0, gather_weight).astype(
+                dtype=np.float32
+            )
+    elif ignore_index is not None:
+        gather_weight = np.where(target == ignore_index, 0, 1).astype(dtype=np.float32)
+
+    # if input is 4-d and above, make it 3-d
+    if len(input_shape) != 3:
+        input = input.reshape((N, C, -1))
+        target = target.reshape((N, -1))
+
+    # Get a dimension from the reshaped input.
+    # If the original input shape is [N, C, H, W],
+    # the D here should be H * W because we reshape
+    # [N, C, H, W] to [N, C, H * W].
+    D = input.shape[2]
+    neg_gather_element_input = np.zeros((N, D), dtype=np.float32)
+    for i in range(N):
+        for d in range(D):
+            if target[i][d] != ignore_index:
+                neg_gather_element_input[i][d] = -input[i][target[i][d]][d]
+
+    loss = neg_gather_element_input
+
+    # if the input was 4-d or above reshape to the right shape
+    if len(input_shape) != 3:
+        loss = loss.reshape(target_shape)
+
+    # apply the weights when required
+    if gather_weight is not None:
+        loss = gather_weight * loss
+        if reduction == "mean":
+            return loss.sum() / gather_weight.sum()
+
+    if reduction == "mean":
+        loss = np.mean(loss)
+    elif reduction == "sum":
+        loss = np.sum(loss)
+    return loss
+
+
+class NegativeLogLikelihoodLoss(Base):
+    @staticmethod
+    def export_input_shape_is_NC() -> None:
+        reduction = "none"
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C = 3, 5
+        np.random.seed(0)
+        input = np.random.rand(N, C).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N,)).astype(np.int64)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=None, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NC",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2() -> None:
+        reduction = "none"
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2 = 3, 5, 6, 6
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=None, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2_reduction_mean() -> None:
+        reduction = "mean"
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2 = 3, 5, 6, 6
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=None, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2_reduction_mean",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2_reduction_sum() -> None:
+        reduction = "sum"
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2 = 3, 5, 6, 6
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=None, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2_reduction_sum",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2_with_weight() -> None:
+        reduction = "none"
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target", "weight"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2 = 3, 5, 6, 6
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+        weight = np.random.rand(C).astype(np.float32)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=weight, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target, weight],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2_with_weight",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2_with_weight_reduction_mean() -> None:
+        reduction = "mean"
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target", "weight"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2 = 3, 5, 6, 6
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+        weight = np.random.rand(C).astype(np.float32)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=weight, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target, weight],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2_with_weight_reduction_mean",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2_with_weight_reduction_sum() -> None:
+        reduction = "sum"
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target", "weight"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2 = 3, 5, 6, 6
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+        weight = np.random.rand(C).astype(np.float32)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=weight, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target, weight],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2_with_weight_reduction_sum",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2_with_weight_reduction_sum_ii() -> None:
+        reduction = "sum"
+        ignore_index = np.int64(0)
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target", "weight"],
+            outputs=["loss"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, dim1, dim2 = 3, 5, 6, 6
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+        target[0][0][0] = np.int64(0)
+        weight = np.random.rand(C).astype(np.float32)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[input, target, weight],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2_with_weight_reduction_sum_ii",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2_no_weight_reduction_mean_ii() -> None:
+        reduction = "mean"
+        ignore_index = np.int64(1)
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target"],
+            outputs=["loss"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, dim1, dim2 = 3, 5, 6, 6
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1, dim2)).astype(np.int64)
+        target[0][0][0] = np.int64(1)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[input, target],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2_no_weight_reduction_mean_ii",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1() -> None:
+        reduction = "mean"
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, d1 = 3, 5, 2
+        np.random.seed(0)
+        input = np.random.rand(N, C, d1).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=None, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1_weight() -> None:
+        reduction = "mean"
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target", "weight"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, d1 = 3, 5, 2
+        np.random.seed(0)
+        input = np.random.rand(N, C, d1).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+        weight = np.random.rand(C).astype(np.float32)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=weight, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target, weight],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1_weight",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1_ii() -> None:
+        reduction = "mean"
+        ignore_index = np.int64(1)
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target"],
+            outputs=["loss"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, d1 = 3, 5, 2
+        np.random.seed(0)
+        input = np.random.rand(N, C, d1).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+        target[0][0] = np.int64(1)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=None, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[input, target],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1_ii",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1_weight_ii() -> None:
+        reduction = "mean"
+        ignore_index = np.int64(1)
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target", "weight"],
+            outputs=["loss"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, d1 = 3, 5, 2
+        np.random.seed(0)
+        input = np.random.rand(N, C, d1).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, d1)).astype(np.int64)
+        target[0][0] = np.int64(1)
+        weight = np.random.rand(C).astype(np.float32)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[input, target, weight],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1_weight_ii",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3d4d5_mean_weight() -> None:
+        reduction = "mean"
+
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target", "weight"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+        target = np.random.randint(
+            0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+        ).astype(np.int64)
+        weight = np.random.rand(C).astype(np.float32)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=weight, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target, weight],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2d3d4d5_mean_weight",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3d4d5_none_no_weight() -> None:
+        reduction = "none"
+
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target"],
+            outputs=["loss"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+        target = np.random.randint(
+            0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+        ).astype(np.int64)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, reduction=reduction
+        )
+
+        expect(
+            node,
+            inputs=[input, target],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2d3d4d5_none_no_weight",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1_mean_weight_negative_ii() -> None:
+        reduction = "mean"
+        ignore_index = np.int64(-1)
+
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target", "weight"],
+            outputs=["loss"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, dim1 = 3, 5, 6
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64)
+        target[0][0] = -1
+        weight = np.random.rand(C).astype(np.float32)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[input, target, weight],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1_mean_weight_negative_ii",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3_none_no_weight_negative_ii() -> None:
+        reduction = "none"
+        ignore_index = np.int64(-5)
+
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target"],
+            outputs=["loss"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5
+        np.random.seed(0)
+        input = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype(
+            np.int64
+        )
+        target[0][0][0][0] = -5
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[input, target],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2d3_none_no_weight_negative_ii",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3_sum_weight_high_ii() -> None:
+        reduction = "sum"
+        ignore_index = np.int64(10)
+
+        node = onnx.helper.make_node(
+            "NegativeLogLikelihoodLoss",
+            inputs=["input", "target", "weight"],
+            outputs=["loss"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C = 3, 5
+        np.random.seed(0)
+        input = np.random.rand(N, C).astype(np.float32)
+        target = np.random.randint(0, high=C, size=(N)).astype(np.int64)
+        target[0] = 10
+        weight = np.random.rand(C).astype(np.float32)
+
+        negative_log_likelihood_loss = compute_negative_log_likelihood_loss(
+            input, target, weight=weight, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[input, target, weight],
+            outputs=[negative_log_likelihood_loss],
+            name="test_nllloss_NCd1d2d3_sum_weight_high_ii",
+        )
diff --git a/onnx/backend/test/case/node/nonmaxsuppression.py b/onnx/backend/test/case/node/nonmaxsuppression.py
new file mode 100644
index 0000000..f1b9ed4
--- /dev/null
+++ b/onnx/backend/test/case/node/nonmaxsuppression.py
@@ -0,0 +1,475 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class NonMaxSuppression(Base):
+    @staticmethod
+    def export_nonmaxsuppression_suppress_by_IOU() -> None:
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+        )
+        boxes = np.array(
+            [
+                [
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.1, 1.0, 1.1],
+                    [0.0, -0.1, 1.0, 0.9],
+                    [0.0, 10.0, 1.0, 11.0],
+                    [0.0, 10.1, 1.0, 11.1],
+                    [0.0, 100.0, 1.0, 101.0],
+                ]
+            ]
+        ).astype(np.float32)
+        scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+        max_output_boxes_per_class = np.array([3]).astype(np.int64)
+        iou_threshold = np.array([0.5]).astype(np.float32)
+        score_threshold = np.array([0.0]).astype(np.float32)
+        selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_suppress_by_IOU",
+        )
+
+    @staticmethod
+    def export_nonmaxsuppression_suppress_by_IOU_and_scores() -> None:
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+        )
+        boxes = np.array(
+            [
+                [
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.1, 1.0, 1.1],
+                    [0.0, -0.1, 1.0, 0.9],
+                    [0.0, 10.0, 1.0, 11.0],
+                    [0.0, 10.1, 1.0, 11.1],
+                    [0.0, 100.0, 1.0, 101.0],
+                ]
+            ]
+        ).astype(np.float32)
+        scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+        max_output_boxes_per_class = np.array([3]).astype(np.int64)
+        iou_threshold = np.array([0.5]).astype(np.float32)
+        score_threshold = np.array([0.4]).astype(np.float32)
+        selected_indices = np.array([[0, 0, 3], [0, 0, 0]]).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_suppress_by_IOU_and_scores",
+        )
+
+    @staticmethod
+    def export_nonmaxsuppression_flipped_coordinates() -> None:
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+        )
+        boxes = np.array(
+            [
+                [
+                    [1.0, 1.0, 0.0, 0.0],
+                    [0.0, 0.1, 1.0, 1.1],
+                    [0.0, 0.9, 1.0, -0.1],
+                    [0.0, 10.0, 1.0, 11.0],
+                    [1.0, 10.1, 0.0, 11.1],
+                    [1.0, 101.0, 0.0, 100.0],
+                ]
+            ]
+        ).astype(np.float32)
+        scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+        max_output_boxes_per_class = np.array([3]).astype(np.int64)
+        iou_threshold = np.array([0.5]).astype(np.float32)
+        score_threshold = np.array([0.0]).astype(np.float32)
+        selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_flipped_coordinates",
+        )
+
+    @staticmethod
+    def export_nonmaxsuppression_limit_output_size() -> None:
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+        )
+        boxes = np.array(
+            [
+                [
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.1, 1.0, 1.1],
+                    [0.0, -0.1, 1.0, 0.9],
+                    [0.0, 10.0, 1.0, 11.0],
+                    [0.0, 10.1, 1.0, 11.1],
+                    [0.0, 100.0, 1.0, 101.0],
+                ]
+            ]
+        ).astype(np.float32)
+        scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+        max_output_boxes_per_class = np.array([2]).astype(np.int64)
+        iou_threshold = np.array([0.5]).astype(np.float32)
+        score_threshold = np.array([0.0]).astype(np.float32)
+        selected_indices = np.array([[0, 0, 3], [0, 0, 0]]).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_limit_output_size",
+        )
+
+    @staticmethod
+    def export_nonmaxsuppression_single_box() -> None:
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+        )
+        boxes = np.array([[[0.0, 0.0, 1.0, 1.0]]]).astype(np.float32)
+        scores = np.array([[[0.9]]]).astype(np.float32)
+        max_output_boxes_per_class = np.array([3]).astype(np.int64)
+        iou_threshold = np.array([0.5]).astype(np.float32)
+        score_threshold = np.array([0.0]).astype(np.float32)
+        selected_indices = np.array([[0, 0, 0]]).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_single_box",
+        )
+
+    @staticmethod
+    def export_nonmaxsuppression_identical_boxes() -> None:
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+        )
+        boxes = np.array(
+            [
+                [
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0],
+                ]
+            ]
+        ).astype(np.float32)
+        scores = np.array(
+            [[[0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9]]]
+        ).astype(np.float32)
+        max_output_boxes_per_class = np.array([3]).astype(np.int64)
+        iou_threshold = np.array([0.5]).astype(np.float32)
+        score_threshold = np.array([0.0]).astype(np.float32)
+        selected_indices = np.array([[0, 0, 0]]).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_identical_boxes",
+        )
+
+    @staticmethod
+    def export_nonmaxsuppression_center_point_box_format() -> None:
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+            center_point_box=1,
+        )
+        boxes = np.array(
+            [
+                [
+                    [0.5, 0.5, 1.0, 1.0],
+                    [0.5, 0.6, 1.0, 1.0],
+                    [0.5, 0.4, 1.0, 1.0],
+                    [0.5, 10.5, 1.0, 1.0],
+                    [0.5, 10.6, 1.0, 1.0],
+                    [0.5, 100.5, 1.0, 1.0],
+                ]
+            ]
+        ).astype(np.float32)
+        scores = np.array([[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]).astype(np.float32)
+        max_output_boxes_per_class = np.array([3]).astype(np.int64)
+        iou_threshold = np.array([0.5]).astype(np.float32)
+        score_threshold = np.array([0.0]).astype(np.float32)
+        selected_indices = np.array([[0, 0, 3], [0, 0, 0], [0, 0, 5]]).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_center_point_box_format",
+        )
+
+    @staticmethod
+    def export_nonmaxsuppression_two_classes() -> None:
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+        )
+        boxes = np.array(
+            [
+                [
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.1, 1.0, 1.1],
+                    [0.0, -0.1, 1.0, 0.9],
+                    [0.0, 10.0, 1.0, 11.0],
+                    [0.0, 10.1, 1.0, 11.1],
+                    [0.0, 100.0, 1.0, 101.0],
+                ]
+            ]
+        ).astype(np.float32)
+        scores = np.array(
+            [[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3], [0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]
+        ).astype(np.float32)
+        max_output_boxes_per_class = np.array([2]).astype(np.int64)
+        iou_threshold = np.array([0.5]).astype(np.float32)
+        score_threshold = np.array([0.0]).astype(np.float32)
+        selected_indices = np.array(
+            [[0, 0, 3], [0, 0, 0], [0, 1, 3], [0, 1, 0]]
+        ).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_two_classes",
+        )
+
+    @staticmethod
+    def export_nonmaxsuppression_two_batches() -> None:
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+        )
+        boxes = np.array(
+            [
+                [
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.1, 1.0, 1.1],
+                    [0.0, -0.1, 1.0, 0.9],
+                    [0.0, 10.0, 1.0, 11.0],
+                    [0.0, 10.1, 1.0, 11.1],
+                    [0.0, 100.0, 1.0, 101.0],
+                ],
+                [
+                    [0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.1, 1.0, 1.1],
+                    [0.0, -0.1, 1.0, 0.9],
+                    [0.0, 10.0, 1.0, 11.0],
+                    [0.0, 10.1, 1.0, 11.1],
+                    [0.0, 100.0, 1.0, 101.0],
+                ],
+            ]
+        ).astype(np.float32)
+        scores = np.array(
+            [[[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]], [[0.9, 0.75, 0.6, 0.95, 0.5, 0.3]]]
+        ).astype(np.float32)
+        max_output_boxes_per_class = np.array([2]).astype(np.int64)
+        iou_threshold = np.array([0.5]).astype(np.float32)
+        score_threshold = np.array([0.0]).astype(np.float32)
+        selected_indices = np.array(
+            [[0, 0, 3], [0, 0, 0], [1, 0, 3], [1, 0, 0]]
+        ).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_two_batches",
+        )
+
+    @staticmethod
+    def export_nonmaxsuppression_iou_threshold_boundary() -> None:
+        """Test boundary condition where IoU exactly equals threshold.
+
+        This test verifies that the comparison is strict (>), not inclusive (>=).
+        When IoU exactly equals the threshold, boxes should be KEPT, not suppressed.
+        This follows PyTorch's NMS implementation.
+        """
+        node = onnx.helper.make_node(
+            "NonMaxSuppression",
+            inputs=[
+                "boxes",
+                "scores",
+                "max_output_boxes_per_class",
+                "iou_threshold",
+                "score_threshold",
+            ],
+            outputs=["selected_indices"],
+        )
+        # Two boxes with 50% overlap in each dimension
+        # box1=[0,0,1,1], box2=[0.5,0.5,1.5,1.5]
+        # Intersection area = 0.5 * 0.5 = 0.25
+        # Union area = 1.0 + 1.0 - 0.25 = 1.75
+        # IoU = 0.25 / 1.75 (exact value computed below as float32)
+        boxes = np.array(
+            [
+                [
+                    [0.0, 0.0, 1.0, 1.0],  # box 0
+                    [0.5, 0.5, 1.5, 1.5],  # box 1 - overlaps box 0
+                ]
+            ]
+        ).astype(np.float32)
+        scores = np.array([[[0.9, 0.8]]]).astype(np.float32)
+        max_output_boxes_per_class = np.array([3]).astype(np.int64)
+        # Compute the exact IoU value and use it as threshold
+        # This ensures the threshold exactly equals the IoU
+        exact_iou = np.float32(0.25 / 1.75)
+        iou_threshold = np.array([exact_iou]).astype(np.float32)
+        score_threshold = np.array([0.0]).astype(np.float32)
+        # Both boxes should be selected because IoU == threshold (not > threshold)
+        selected_indices = np.array([[0, 0, 0], [0, 0, 1]]).astype(np.int64)
+
+        expect(
+            node,
+            inputs=[
+                boxes,
+                scores,
+                max_output_boxes_per_class,
+                iou_threshold,
+                score_threshold,
+            ],
+            outputs=[selected_indices],
+            name="test_nonmaxsuppression_iou_threshold_boundary",
+        )
diff --git a/onnx/backend/test/case/node/nonzero.py b/onnx/backend/test/case/node/nonzero.py
new file mode 100644
index 0000000..03feeed
--- /dev/null
+++ b/onnx/backend/test/case/node/nonzero.py
@@ -0,0 +1,26 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class NonZero(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "NonZero",
+            inputs=["condition"],
+            outputs=["result"],
+        )
+
+        condition = np.array([[1, 0], [1, 1]], dtype=bool)
+        result = np.array(
+            np.nonzero(condition), dtype=np.int64
+        )  # expected output [[0, 1, 1], [0, 0, 1]]
+        expect(node, inputs=[condition], outputs=[result], name="test_nonzero_example")
diff --git a/onnx/backend/test/case/node/not_.py b/onnx/backend/test/case/node/not_.py
new file mode 100644
index 0000000..b610dff
--- /dev/null
+++ b/onnx/backend/test/case/node/not_.py
@@ -0,0 +1,32 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Not(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Not",
+            inputs=["x"],
+            outputs=["not"],
+        )
+
+        # 2d
+        x = (np.random.randn(3, 4) > 0).astype(bool)
+        expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_2d")
+
+        # 3d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_3d")
+
+        # 4d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        expect(node, inputs=[x], outputs=[np.logical_not(x)], name="test_not_4d")
diff --git a/onnx/backend/test/case/node/onehot.py b/onnx/backend/test/case/node/onehot.py
new file mode 100644
index 0000000..4d6f27c
--- /dev/null
+++ b/onnx/backend/test/case/node/onehot.py
@@ -0,0 +1,159 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def one_hot(indices, depth, axis=-1, dtype=np.float32):
+    """Compute one hot from indices at a specific axis"""
+    values = np.asarray(indices)
+    rank = len(values.shape)
+    depth_range = np.arange(depth)
+    if axis < 0:
+        axis += rank + 1
+    ls = values.shape[0:axis]
+    rs = values.shape[axis:rank]
+    targets = np.reshape(
+        depth_range, (1,) * len(ls) + depth_range.shape + (1,) * len(rs)
+    )
+    # Wrap negative in-range indices; leave out-of-range ones unmatched (all off_value).
+    values = np.where(values < 0, values + depth, values)
+    values = np.reshape(values, (*ls, 1, *rs))
+    return np.asarray(targets == values, dtype=dtype)
+
+
+class OneHot(Base):
+    @staticmethod
+    def export_without_axis() -> None:
+        on_value = 5
+        off_value = 2
+        output_type = np.int32
+        node = onnx.helper.make_node(
+            "OneHot", inputs=["indices", "depth", "values"], outputs=["y"]
+        )
+        indices = np.array([0, 7, 8], dtype=np.int64)
+        depth = np.float32(12)
+        values = np.array([off_value, on_value], dtype=output_type)
+        y = one_hot(indices, depth, dtype=output_type)
+        y = y * (on_value - off_value) + off_value
+        expect(
+            node,
+            inputs=[indices, depth, values],
+            outputs=[y],
+            name="test_onehot_without_axis",
+        )
+
+    @staticmethod
+    def export_with_axis() -> None:
+        axisValue = 1
+        on_value = 3
+        off_value = 1
+        output_type = np.float32
+        node = onnx.helper.make_node(
+            "OneHot",
+            inputs=["indices", "depth", "values"],
+            outputs=["y"],
+            axis=axisValue,
+        )
+        indices = np.array([[1, 9], [2, 4]], dtype=np.float32)
+        depth = np.float32(10)
+        values = np.array([off_value, on_value], dtype=output_type)
+        y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+        y = y * (on_value - off_value) + off_value
+        expect(
+            node,
+            inputs=[indices, depth, values],
+            outputs=[y],
+            name="test_onehot_with_axis",
+        )
+
+    @staticmethod
+    def export_with_negative_indices() -> None:
+        axisValue = 1
+        on_value = 3
+        off_value = 1
+        output_type = np.float32
+        node = onnx.helper.make_node(
+            "OneHot",
+            inputs=["indices", "depth", "values"],
+            outputs=["y"],
+            axis=axisValue,
+        )
+        indices = np.array([0, -7, -8], dtype=np.int64)
+
+        # print(y)
+        # [[3. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
+        #  [1. 1. 1. 3. 1. 1. 1. 1. 1. 1.]
+        #  [1. 1. 3. 1. 1. 1. 1. 1. 1. 1.]]
+
+        depth = np.float32(10)
+        values = np.array([off_value, on_value], dtype=output_type)
+        y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+        y = y * (on_value - off_value) + off_value
+        expect(
+            node,
+            inputs=[indices, depth, values],
+            outputs=[y],
+            name="test_onehot_negative_indices",
+        )
+
+    @staticmethod
+    def export_with_out_of_range_indices() -> None:
+        axisValue = 1
+        on_value = 3
+        off_value = 1
+        output_type = np.float32
+        node = onnx.helper.make_node(
+            "OneHot",
+            inputs=["indices", "depth", "values"],
+            outputs=["y"],
+            axis=axisValue,
+        )
+        # Indices outside [-depth, depth-1] map to an all-off_value row.
+        indices = np.array([5, -6, -1], dtype=np.int64)
+
+        # print(y)
+        # [[1. 1. 1. 1. 1.]
+        #  [1. 1. 1. 1. 1.]
+        #  [1. 1. 1. 1. 3.]]
+
+        depth = np.float32(5)
+        values = np.array([off_value, on_value], dtype=output_type)
+        y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+        y = y * (on_value - off_value) + off_value
+        expect(
+            node,
+            inputs=[indices, depth, values],
+            outputs=[y],
+            name="test_onehot_out_of_range_indices",
+        )
+
+    @staticmethod
+    def export_with_negative_axis() -> None:
+        axisValue = -2
+        on_value = 3
+        off_value = 1
+        output_type = np.float32
+        node = onnx.helper.make_node(
+            "OneHot",
+            inputs=["indices", "depth", "values"],
+            outputs=["y"],
+            axis=axisValue,
+        )
+        indices = np.array([[1, 9], [2, 4]], dtype=np.float32)
+        depth = np.float32(10)
+        values = np.array([off_value, on_value], dtype=output_type)
+        y = one_hot(indices, depth, axis=axisValue, dtype=output_type)
+        y = y * (on_value - off_value) + off_value
+        expect(
+            node,
+            inputs=[indices, depth, values],
+            outputs=[y],
+            name="test_onehot_with_negative_axis",
+        )
diff --git a/onnx/backend/test/case/node/optionalgetelement.py b/onnx/backend/test/case/node/optionalgetelement.py
new file mode 100644
index 0000000..c7f5efa
--- /dev/null
+++ b/onnx/backend/test/case/node/optionalgetelement.py
@@ -0,0 +1,80 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def optional_get_element_reference_implementation(optional: Any | None) -> Any:
+    assert optional is not None
+    return optional
+
+
+class OptionalHasElement(Base):
+    @staticmethod
+    def export_get_element_tensor() -> None:
+        optional = np.array([1, 2, 3, 4]).astype(np.float32)
+        tensor_type_proto = onnx.helper.make_tensor_type_proto(
+            elem_type=onnx.TensorProto.FLOAT,
+            shape=[
+                4,
+            ],
+        )
+        optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)
+
+        node = onnx.helper.make_node(
+            "OptionalGetElement", inputs=["optional_input"], outputs=["output"]
+        )
+        output = optional_get_element_reference_implementation(optional)
+        expect(
+            node,
+            inputs=[optional],
+            outputs=[output],
+            input_type_protos=[optional_type_proto],
+            name="test_optional_get_element_optional_tensor",
+        )
+        expect(
+            node,
+            inputs=[optional],
+            outputs=[output],
+            input_type_protos=[tensor_type_proto],
+            name="test_optional_get_element_tensor",
+        )
+
+    @staticmethod
+    def export_get_element_sequence() -> None:
+        optional = [np.array([1, 2, 3, 4]).astype(np.int32)]
+        tensor_type_proto = onnx.helper.make_tensor_type_proto(
+            elem_type=onnx.TensorProto.INT32,
+            shape=[
+                4,
+            ],
+        )
+        seq_type_proto = onnx.helper.make_sequence_type_proto(tensor_type_proto)
+        optional_type_proto = onnx.helper.make_optional_type_proto(seq_type_proto)
+
+        node = onnx.helper.make_node(
+            "OptionalGetElement", inputs=["optional_input"], outputs=["output"]
+        )
+        output = optional_get_element_reference_implementation(optional)
+        expect(
+            node,
+            inputs=[optional],
+            outputs=[output],
+            input_type_protos=[optional_type_proto],
+            name="test_optional_get_element_optional_sequence",
+        )
+        expect(
+            node,
+            inputs=[optional],
+            outputs=[output],
+            input_type_protos=[seq_type_proto],
+            name="test_optional_get_element_sequence",
+        )
diff --git a/onnx/backend/test/case/node/optionalhaselement.py b/onnx/backend/test/case/node/optionalhaselement.py
new file mode 100644
index 0000000..e704cd3
--- /dev/null
+++ b/onnx/backend/test/case/node/optionalhaselement.py
@@ -0,0 +1,93 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def optional_has_element_reference_implementation(
+    optional: np.ndarray | None,
+) -> np.ndarray:
+    if optional is None:
+        return np.array(False)
+    return np.array(True)
+
+
+class OptionalHasElement(Base):
+    @staticmethod
+    def export() -> None:
+        optional = np.array([1, 2, 3, 4]).astype(np.float32)
+        tensor_type_proto = onnx.helper.make_tensor_type_proto(
+            elem_type=onnx.TensorProto.FLOAT,
+            shape=[
+                4,
+            ],
+        )
+        optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)
+
+        # OptionalHasElement takes a tensor or optional as input
+        for input_type_protos in [tensor_type_proto, optional_type_proto]:
+            node = onnx.helper.make_node(
+                "OptionalHasElement", inputs=["optional_input"], outputs=["output"]
+            )
+            output = optional_has_element_reference_implementation(optional)
+            test_name = "test_optional_has_element_" + (
+                "optional_input"
+                if input_type_protos == optional_type_proto
+                else "tensor_input"
+            )
+            expect(
+                node,
+                inputs=[optional],
+                outputs=[output],
+                input_type_protos=[optional_type_proto],
+                name=test_name,
+            )
+
+    @staticmethod
+    def export_empty() -> None:
+        optional = None
+
+        tensor_type_proto = onnx.helper.make_tensor_type_proto(
+            elem_type=onnx.TensorProto.INT32, shape=[]
+        )
+        optional_type_proto = onnx.helper.make_optional_type_proto(tensor_type_proto)
+
+        # OptionalHasElement takes a tensor or optional as input
+        for input_type_proto in [tensor_type_proto, optional_type_proto]:
+            input_name_options = {
+                "empty": "optional_input",
+                "empty_no_input_name": "",
+                "empty_no_input": None,
+            }
+            for test_name_surfix, input_name in input_name_options.items():
+                if input_type_proto == tensor_type_proto and input_name:
+                    # the input tensor cannot be empty if input name is provided.
+                    continue
+                node = onnx.helper.make_node(
+                    "OptionalHasElement",
+                    inputs=[] if input_name is None else [input_name],
+                    outputs=["output"],
+                )
+                output = optional_has_element_reference_implementation(optional)
+                test_name = (
+                    "test_optional_has_element_"
+                    + test_name_surfix
+                    + (
+                        "_optional_input"
+                        if input_type_proto == optional_type_proto
+                        else "_tensor_input"
+                    )
+                )
+                expect(
+                    node,
+                    inputs=[optional] if input_name else [],
+                    outputs=[output],
+                    input_type_protos=[input_type_proto] if input_name else [],
+                    name=test_name,
+                )
diff --git a/onnx/backend/test/case/node/or_.py b/onnx/backend/test/case/node/or_.py
new file mode 100644
index 0000000..ade9f57
--- /dev/null
+++ b/onnx/backend/test/case/node/or_.py
@@ -0,0 +1,76 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Or(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Or",
+            inputs=["x", "y"],
+            outputs=["or"],
+        )
+
+        # 2d
+        x = (np.random.randn(3, 4) > 0).astype(bool)
+        y = (np.random.randn(3, 4) > 0).astype(bool)
+        z = np.logical_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_or2d")
+
+        # 3d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        y = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        z = np.logical_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_or3d")
+
+        # 4d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        z = np.logical_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_or4d")
+
+    @staticmethod
+    def export_or_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Or",
+            inputs=["x", "y"],
+            outputs=["or"],
+        )
+
+        # 3d vs 1d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        y = (np.random.randn(5) > 0).astype(bool)
+        z = np.logical_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast3v1d")
+
+        # 3d vs 2d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        y = (np.random.randn(4, 5) > 0).astype(bool)
+        z = np.logical_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast3v2d")
+
+        # 4d vs 2d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        y = (np.random.randn(5, 6) > 0).astype(bool)
+        z = np.logical_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v2d")
+
+        # 4d vs 3d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        y = (np.random.randn(4, 5, 6) > 0).astype(bool)
+        z = np.logical_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v3d")
+
+        # 4d vs 4d
+        x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool)
+        y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool)
+        z = np.logical_or(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_or_bcast4v4d")
diff --git a/onnx/backend/test/case/node/pad.py b/onnx/backend/test/case/node/pad.py
new file mode 100644
index 0000000..5d1cdc3
--- /dev/null
+++ b/onnx/backend/test/case/node/pad.py
@@ -0,0 +1,129 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def pad_impl(data, raw_pads, mode, constant_values=0.0, axes=None):
+    input_rank = data.ndim
+    if axes is None:
+        axes = list(range(input_rank))
+    else:
+        axes = [axis if axis >= 0 else axis + input_rank for axis in axes]
+    num_axes = len(axes)
+
+    if num_axes * 2 != raw_pads.size:
+        raise ValueError("The number of elements in raw_pads should be 2 * num_axes")
+
+    pad_width = []
+    for _ in range(input_rank):
+        pad_width += [[0, 0]]  # init to zero
+
+    # re-order to np.pad accepted order ((x1_begin, x1_end), (x2_begin, x2_end), ...)
+    for i in range(num_axes):
+        axis = axes[i]
+        if axis < 0:
+            axis = input_rank + axis
+        pad_width[axis] = [raw_pads[i], raw_pads[i + num_axes]]
+
+    if mode == "constant":
+        return np.pad(
+            data,
+            pad_width=pad_width,
+            mode=mode,
+            constant_values=constant_values,
+        )
+
+    return np.pad(
+        data,
+        pad_width=pad_width,
+        mode=mode,
+    )
+
+
+class Pad(Base):
+    @staticmethod
+    def export_constant_pad() -> None:
+        node = onnx.helper.make_node(
+            "Pad", inputs=["x", "pads", "value"], outputs=["y"], mode="constant"
+        )
+        x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+        pads = np.array([0, 0, 1, 3, 0, 0, 2, 4]).astype(
+            np.int64
+        )  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+        value = np.float32(1.2)
+        y = pad_impl(x, pads, "constant", 1.2)
+
+        expect(node, inputs=[x, pads, value], outputs=[y], name="test_constant_pad")
+
+    @staticmethod
+    def export_reflection_edge_and_wrap_pad() -> None:
+        for mode in ("edge", "reflect", "wrap"):
+            node = onnx.helper.make_node(
+                "Pad", inputs=["x", "pads"], outputs=["y"], mode=mode
+            )
+            x = np.random.randn(1, 3, 4, 5).astype(np.int32)
+            pads = np.array([0, 0, 1, 1, 0, 0, 1, 1]).astype(
+                np.int64
+            )  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+            y = pad_impl(x, pads, mode)
+
+            expect(node, inputs=[x, pads], outputs=[y], name=f"test_{mode}_pad")
+
+    @staticmethod
+    def export_constant_pad_axes() -> None:
+        node = onnx.helper.make_node(
+            "Pad", inputs=["x", "pads", "value", "axes"], outputs=["y"], mode="constant"
+        )
+        x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+        pads = np.array([0, 3, 0, 4]).astype(
+            np.int64
+        )  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+        value = np.float32(1.2)
+        axes = np.array([1, 3], dtype=np.int64)
+        y = pad_impl(
+            x,
+            pads,
+            "constant",
+            1.2,
+            [1, 3],
+        )
+
+        expect(
+            node,
+            inputs=[x, pads, value, axes],
+            outputs=[y],
+            name="test_constant_pad_axes",
+        )
+
+    @staticmethod
+    def export_constant_pad_negative_axes() -> None:
+        node = onnx.helper.make_node(
+            "Pad", inputs=["x", "pads", "value", "axes"], outputs=["y"], mode="constant"
+        )
+        x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+        pads = np.array([0, 3, 0, 4]).astype(
+            np.int64
+        )  # pad order [x1_begin, x2_begin, ..., x1_end, x2_end, ...]
+        value = np.float32(1.2)
+        axes = np.array([-3, -1], dtype=np.int64)
+        y = pad_impl(
+            x,
+            pads,
+            "constant",
+            1.2,
+            [-3, -1],
+        )
+
+        expect(
+            node,
+            inputs=[x, pads, value, axes],
+            outputs=[y],
+            name="test_constant_pad_negative_axes",
+        )
diff --git a/onnx/backend/test/case/node/pow.py b/onnx/backend/test/case/node/pow.py
new file mode 100644
index 0000000..412faf5
--- /dev/null
+++ b/onnx/backend/test/case/node/pow.py
@@ -0,0 +1,106 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def pow(x: np.ndarray, y: np.ndarray) -> np.ndarray:  # noqa: A001
+    return np.power(x, y).astype(x.dtype)
+
+
+class Pow(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Pow",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([1, 2, 3]).astype(np.float32)
+        y = np.array([4, 5, 6]).astype(np.float32)
+        z = pow(x, y)  # expected output [1., 32., 729.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_example")
+
+        x = np.arange(60).reshape(3, 4, 5).astype(np.float32)
+        y = np.random.randn(3, 4, 5).astype(np.float32)
+        z = pow(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow")
+
+    @staticmethod
+    def export_pow_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Pow",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([1, 2, 3]).astype(np.float32)
+        y = np.array(2).astype(np.float32)
+        z = pow(x, y)  # expected output [1., 4., 9.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_bcast_scalar")
+
+        node = onnx.helper.make_node(
+            "Pow",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+        x = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
+        y = np.array([1, 2, 3]).astype(np.float32)
+        # expected output [[1, 4, 27], [4, 25, 216]]
+        z = pow(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_bcast_array")
+
+    @staticmethod
+    def export_types() -> None:
+        node = onnx.helper.make_node(
+            "Pow",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([1, 2, 3]).astype(np.float32)
+        y = np.array([4, 5, 6]).astype(np.int64)
+        z = pow(x, y)  # expected output [1., 32., 729.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_int64")
+
+        x = np.array([1, 2, 3]).astype(np.int64)
+        y = np.array([4, 5, 6]).astype(np.float32)
+        z = pow(x, y)  # expected output [1, 32, 729]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int64_float32")
+
+        x = np.array([1, 2, 3]).astype(np.float32)
+        y = np.array([4, 5, 6]).astype(np.int32)
+        z = pow(x, y)  # expected output [1., 32., 729.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_int32")
+
+        x = np.array([1, 2, 3]).astype(np.int32)
+        y = np.array([4, 5, 6]).astype(np.float32)
+        z = pow(x, y)  # expected output [1, 32, 729]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int32_float32")
+
+        x = np.array([1, 2, 3]).astype(np.float32)
+        y = np.array([4, 5, 6]).astype(np.uint64)
+        z = pow(x, y)  # expected output [1., 32., 729.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_uint64")
+
+        x = np.array([1, 2, 3]).astype(np.float32)
+        y = np.array([4, 5, 6]).astype(np.uint32)
+        z = pow(x, y)  # expected output [1., 32., 729.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_float32_uint32")
+
+        x = np.array([1, 2, 3]).astype(np.int64)
+        y = np.array([4, 5, 6]).astype(np.int64)
+        z = pow(x, y)  # expected output [1, 32, 729]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int64_int64")
+
+        x = np.array([1, 2, 3]).astype(np.int32)
+        y = np.array([4, 5, 6]).astype(np.int32)
+        z = pow(x, y)  # expected output [1, 32, 729]
+        expect(node, inputs=[x, y], outputs=[z], name="test_pow_types_int32_int32")
diff --git a/onnx/backend/test/case/node/prelu.py b/onnx/backend/test/case/node/prelu.py
new file mode 100644
index 0000000..1c7ecfd
--- /dev/null
+++ b/onnx/backend/test/case/node/prelu.py
@@ -0,0 +1,40 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class PRelu(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "PRelu",
+            inputs=["x", "slope"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        slope = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * slope
+
+        expect(node, inputs=[x, slope], outputs=[y], name="test_prelu_example")
+
+    @staticmethod
+    def export_prelu_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "PRelu",
+            inputs=["x", "slope"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        slope = np.random.randn(5).astype(np.float32)
+        y = np.clip(x, 0, np.inf) + np.clip(x, -np.inf, 0) * slope
+
+        expect(node, inputs=[x, slope], outputs=[y], name="test_prelu_broadcast")
diff --git a/onnx/backend/test/case/node/qlinearconv.py b/onnx/backend/test/case/node/qlinearconv.py
new file mode 100644
index 0000000..8c40fac
--- /dev/null
+++ b/onnx/backend/test/case/node/qlinearconv.py
@@ -0,0 +1,82 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class QLinearConv(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "QLinearConv",
+            inputs=[
+                "x",
+                "x_scale",
+                "x_zero_point",
+                "w",
+                "w_scale",
+                "w_zero_point",
+                "y_scale",
+                "y_zero_point",
+            ],
+            outputs=["y"],
+        )
+
+        x = np.array(
+            [
+                [255, 174, 162, 25, 203, 168, 58],
+                [15, 59, 237, 95, 129, 0, 64],
+                [56, 242, 153, 221, 168, 12, 166],
+                [232, 178, 186, 195, 237, 162, 237],
+                [188, 39, 124, 77, 80, 102, 43],
+                [127, 230, 21, 83, 41, 40, 134],
+                [255, 154, 92, 141, 42, 148, 247],
+            ],
+            dtype=np.uint8,
+        ).reshape((1, 1, 7, 7))
+
+        x_scale = np.float32(0.00369204697)
+        x_zero_point = np.uint8(132)
+
+        w = np.array([0], dtype=np.uint8).reshape((1, 1, 1, 1))
+
+        w_scale = np.array([0.00172794575], dtype=np.float32)
+        w_zero_point = np.array([255], dtype=np.uint8)
+
+        y_scale = np.float32(0.00162681262)
+        y_zero_point = np.uint8(123)
+
+        output = np.array(
+            [
+                [0, 81, 93, 230, 52, 87, 197],
+                [240, 196, 18, 160, 126, 255, 191],
+                [199, 13, 102, 34, 87, 243, 89],
+                [23, 77, 69, 60, 18, 93, 18],
+                [67, 216, 131, 178, 175, 153, 212],
+                [128, 25, 234, 172, 214, 215, 121],
+                [0, 101, 163, 114, 213, 107, 8],
+            ],
+            dtype=np.uint8,
+        ).reshape((1, 1, 7, 7))
+
+        expect(
+            node,
+            inputs=[
+                x,
+                x_scale,
+                x_zero_point,
+                w,
+                w_scale,
+                w_zero_point,
+                y_scale,
+                y_zero_point,
+            ],
+            outputs=[output],
+            name="test_qlinearconv",
+        )
diff --git a/onnx/backend/test/case/node/qlinearmatmul.py b/onnx/backend/test/case/node/qlinearmatmul.py
new file mode 100644
index 0000000..6a92c1b
--- /dev/null
+++ b/onnx/backend/test/case/node/qlinearmatmul.py
@@ -0,0 +1,149 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class QLinearMatMul(Base):
+    @staticmethod
+    def export_int() -> None:
+        for quant_type_name in ["uint8", "int8"]:
+            quant_type = getattr(np, quant_type_name)
+            for dtype_name in ["float32", "float16"]:
+                dtype = getattr(np, dtype_name)
+                node = onnx.helper.make_node(
+                    "QLinearMatMul",
+                    inputs=[
+                        "a",
+                        "a_scale",
+                        "a_zero_point",
+                        "b",
+                        "b_scale",
+                        "b_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    outputs=["y"],
+                )
+
+                # 2D
+                a = np.array([[208, 236, 0, 238], [3, 214, 255, 29]])
+                if quant_type == np.int8:
+                    a -= 127
+                a = a.astype(quant_type)
+
+                a_scale = np.array([0.0066], dtype=dtype)
+                a_zero_point = np.array(
+                    [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type
+                )
+
+                b = np.array(
+                    [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]]
+                )
+                if quant_type == np.int8:
+                    b -= 127
+                b = b.astype(quant_type)
+
+                b_scale = np.array([0.00705], dtype=dtype)
+                b_zero_point = np.array(
+                    [114 - 127] if quant_type == np.int8 else [114], dtype=quant_type
+                )
+
+                y_scale = np.array([0.0107], dtype=dtype)
+                y_zero_point = np.array(
+                    [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type
+                )
+
+                if quant_type == np.int8:
+                    output = np.array([[41, -12, -9], [1, -75, -128]])
+                else:
+                    output = np.array([[168, 115, 255], [1, 66, 151]])
+                output = output.astype(quant_type)
+
+                expect(
+                    node,
+                    inputs=[
+                        a,
+                        a_scale,
+                        a_zero_point,
+                        b,
+                        b_scale,
+                        b_zero_point,
+                        y_scale,
+                        y_zero_point,
+                    ],
+                    outputs=[output],
+                    name=f"test_qlinearmatmul_2D_{quant_type_name}_{dtype_name}",
+                )
+
+                # 3D
+                a = np.array(
+                    [
+                        [[208, 236, 0, 238], [3, 214, 255, 29]],
+                        [[208, 236, 0, 238], [3, 214, 255, 29]],
+                    ],
+                )
+                if quant_type == np.int8:
+                    a -= 127
+                a = a.astype(quant_type)
+
+                a_scale = np.array([0.0066], dtype=dtype)
+                a_zero_point = np.array(
+                    [113 - 127] if quant_type == np.int8 else [113], dtype=quant_type
+                )
+
+                b = np.array(
+                    [
+                        [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
+                        [[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]],
+                    ],
+                )
+                if quant_type == np.int8:
+                    b -= 127
+                b = b.astype(quant_type)
+
+                b_scale = np.array([0.00705], dtype=dtype)
+                b_zero_point = np.array([114], dtype=quant_type)
+
+                y_scale = np.array([0.0107], dtype=dtype)
+                y_zero_point = np.array(
+                    [118 - 127] if quant_type == np.int8 else [118], dtype=quant_type
+                )
+
+                if quant_type == np.int8:
+                    output = np.array(
+                        [
+                            [[-86, -128, -128], [115, 39, -121]],
+                            [[-86, -128, -128], [115, 39, -121]],
+                        ]
+                    )
+                else:
+                    output = np.array(
+                        [
+                            [[168, 115, 255], [1, 66, 151]],
+                            [[168, 115, 255], [1, 66, 151]],
+                        ]
+                    )
+                output = output.astype(quant_type)
+
+                expect(
+                    node,
+                    inputs=[
+                        a,
+                        a_scale,
+                        a_zero_point,
+                        b,
+                        b_scale,
+                        b_zero_point,
+                        y_scale,
+                        y_zero_point,
+                    ],
+                    outputs=[output],
+                    name=f"test_qlinearmatmul_3D_{quant_type_name}_{dtype_name}",
+                )
diff --git a/onnx/backend/test/case/node/quantizelinear.py b/onnx/backend/test/case/node/quantizelinear.py
new file mode 100644
index 0000000..9f07b9a
--- /dev/null
+++ b/onnx/backend/test/case/node/quantizelinear.py
@@ -0,0 +1,499 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx import TensorProto
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.helper import make_tensor
+
+
+class QuantizeLinear(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array([0, 2, 3, 1000, -254, -1000]).astype(np.float32)
+        y_scale = np.float32(2)
+        y_zero_point = np.uint8(128)
+        y = np.array([128, 129, 130, 255, 1, 0]).astype(np.uint8)
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear",
+        )
+
+    @staticmethod
+    def export_axis() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array(
+            [
+                [
+                    [[-162, 10], [-100, 232], [-20, -50]],
+                    [[-76, 0], [0, 252], [32, -44]],
+                    [[245, -485], [-960, -270], [-375, -470]],
+                ],
+            ],
+            dtype=np.float32,
+        )
+        y_scale = np.array([2, 4, 5], dtype=np.float32)
+        y_zero_point = np.array([84, 24, 196], dtype=np.uint8)
+        y = (x / y_scale.reshape(1, 3, 1, 1) + y_zero_point.reshape(1, 3, 1, 1)).astype(
+            np.uint8
+        )
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_axis",
+        )
+
+    @staticmethod
+    def export_e4m3fn() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32)
+        y_scale = np.float32(2)
+        y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E4M3FN, [1], [0])
+        y = make_tensor("y", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 448, 96])
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_e4m3fn",
+        )
+
+    @staticmethod
+    def export_e5m2() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array([0.0, 1.0, 2.0, 100000.0, 200.0]).astype(np.float32)
+        y_scale = np.float32(2)
+        y_zero_point = make_tensor("y_zero_point", TensorProto.FLOAT8E5M2, [1], [0.0])
+        y = make_tensor("y", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 49152, 96])
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_e5m2",
+        )
+
+    @staticmethod
+    def export_uint16() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array(
+            [
+                0.0,
+                -128.0,
+                3.0,
+                -3.0,
+                2.9,
+                -2.9,
+                3.1,
+                -3.1,
+                65536.0,
+                -65534.0,
+                70000.0,
+                -70000.0,
+            ]
+        ).astype(np.float32)
+        y_scale = np.float32(2.0)
+        y_zero_point = np.uint16(32767)
+        y = np.array(
+            [
+                32767,
+                32703,
+                32769,
+                32765,
+                32768,
+                32766,
+                32769,
+                32765,
+                65535,
+                0,
+                65535,
+                0,
+            ]
+        ).astype(np.uint16)
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_uint16",
+        )
+
+    @staticmethod
+    def export_int16() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+        )
+
+        x = np.array(
+            [
+                0.0,
+                -514.0,
+                3.0,
+                -3.0,
+                2.9,
+                -2.9,
+                3.1,
+                -3.1,
+                65022.0,
+                -66046.0,
+                65023.0,
+                -66047.0,
+                65024.0,
+                -66048.0,
+                70000.0,
+                -70000.0,
+            ]
+        ).astype(np.float32)
+        y_scale = np.float32(2.0)
+        y_zero_point = np.int16(256)
+        y = np.array(
+            [
+                256,
+                -1,
+                258,
+                254,
+                257,
+                255,
+                258,
+                254,
+                32767,
+                -32767,
+                32767,
+                -32768,
+                32767,
+                -32768,
+                32767,
+                -32768,
+            ]
+        ).astype(np.int16)
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_int16",
+        )
+
+    @staticmethod
+    def export_uint4() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        x = np.array(
+            [
+                [0.0, 2.5, 4.8, 8.6],
+                [-30, -20, 6, 9],
+                [12, 15, 16, 40],
+            ]
+        ).astype(np.float32)
+
+        y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+        y_zero_point = make_tensor(
+            "y_zero_point", TensorProto.UINT4, y_scale.shape, np.ones_like(y_scale)
+        )
+        y = make_tensor(
+            "y", TensorProto.UINT4, x.shape, [1, 2, 3, 5, 0, 0, 3, 4, 4, 5, 5, 11]
+        )
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_uint4",
+        )
+
+    @staticmethod
+    def export_int4() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        x = np.array(
+            [
+                [0.0, 2.5, 4.8, 8.6],
+                [-30, -20, 6, 9],
+                [12, 15, 16, 40],
+            ]
+        ).astype(np.float32)
+
+        y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+        y_zero_point = make_tensor(
+            "y_zero_point", TensorProto.INT4, y_scale.shape, np.ones_like(y_scale)
+        )
+        y = make_tensor(
+            "y", TensorProto.INT4, x.shape, [1, 2, 3, 5, -8, -6, 3, 4, 4, 5, 5, 7]
+        )
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_int4",
+        )
+
+    @staticmethod
+    def export_uint2() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        x = np.array(
+            [
+                [0.0, 2.5, 4.8, 8.6],
+                [-2.0, -1.0, 1.0, 3.0],
+                [4.0, 5.0, 6.0, 7.0],
+            ],
+            dtype=np.float32,
+        )
+        y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+        y_zero_point = make_tensor(
+            "y_zero_point", TensorProto.UINT2, y_scale.shape, np.zeros_like(y_scale)
+        )
+        y = make_tensor(
+            "y", TensorProto.UINT2, x.shape, [0, 1, 2, 3, 0, 0, 0, 1, 1, 1, 2, 2]
+        )
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_uint2",
+        )
+
+    @staticmethod
+    def export_int2() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+        x = np.array(
+            [
+                [0.0, 2.5, 4.8, 8.6],
+                [-4.0, -3.0, 1.0, 2.0],
+                [-0.0, -2.5, -4.8, -8.6],
+            ],
+            dtype=np.float32,
+        )
+        y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+        y_zero_point = make_tensor(
+            "y_zero_point", TensorProto.INT2, y_scale.shape, np.zeros_like(y_scale)
+        )
+        y = make_tensor(
+            "y", TensorProto.INT2, x.shape, [0, 1, 1, 1, -1, -1, 0, 1, 0, -1, -1, -2]
+        )
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_int2",
+        )
+
+    @staticmethod
+    def export_float4e2m1() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=0,
+        )
+
+        x = np.array(
+            [
+                [0.0, 2.5, 4.8, 8.6],
+                [-30, -20, 6, 9],
+                [-0.0, -2.5, -4.8, -8.6],
+            ]
+        ).astype(np.float32)
+
+        y_scale = np.asarray([2.0, 3.0, 4.0], dtype=np.float32)
+        y_zero_point = make_tensor(
+            "y_zero_point",
+            TensorProto.FLOAT4E2M1,
+            y_scale.shape,
+            np.zeros_like(y_scale),
+        )
+        y = make_tensor(
+            "y",
+            TensorProto.FLOAT4E2M1,
+            x.shape,
+            [0, 1, 2, 4, -6, -6, 2, 3, 0, -0.5, -1, -2],
+        )
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_float4e2m1",
+        )
+
+    @staticmethod
+    def export_blocked_asymmetric() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale", "y_zero_point"],
+            outputs=["y"],
+            axis=1,
+            block_size=2,
+        )
+
+        x = np.array(
+            [
+                [6.0, 12.0, 50.0, 5.0],
+                [1.0, 8.0, 4.0, 5.0],
+                [0.0, 20.0, 10.0, 4.0],
+            ],
+            dtype=np.float32,
+        )
+        y_scale = np.array(
+            [
+                [1.5, 2.5],
+                [3.0, 4.9],
+                [5.1, 6.9],
+            ],
+            dtype=np.float32,
+        )
+        y_zero_point = np.array(
+            [
+                [0, 1],
+                [1, 0],
+                [2, 3],
+            ],
+            dtype=np.uint8,
+        )
+        # x.shape = (3, 4)
+        # y_scale.shape = (3, 2)
+        assert y_scale.shape == y_zero_point.shape
+        block_axis = 1
+        # The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2)
+        assert all(
+            x.shape[i] == y_scale.shape[i]
+            for i in range(len(x.shape))
+            if i != block_axis
+        )
+        assert x.shape[block_axis] % y_scale.shape[block_axis] == 0
+        repeats = x.shape[block_axis] // y_scale.shape[block_axis]
+
+        # Create element-wise scale and zero point
+        y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis)
+        y_zero_point_elementwise = np.repeat(
+            y_zero_point, repeats=repeats, axis=block_axis
+        )
+
+        y = np.rint(x / y_scale_elementwise + y_zero_point_elementwise).astype(np.uint8)
+
+        expect(
+            node,
+            inputs=[x, y_scale, y_zero_point],
+            outputs=[y],
+            name="test_quantizelinear_blocked_asymmetric",
+        )
+
+    @staticmethod
+    def export_blocked_symmetric() -> None:
+        node = onnx.helper.make_node(
+            "QuantizeLinear",
+            inputs=["x", "y_scale"],
+            outputs=["y"],
+            axis=1,
+            block_size=2,
+            output_dtype=TensorProto.INT16,
+        )
+
+        x = np.array(
+            [
+                [6.0, -8, -10, 5.0],
+                [1.0, 8.0, 4.0, 5.0],
+                [0.0, 20.0, 10.0, 4.0],
+            ],
+            dtype=np.float32,
+        )
+
+        y_scale = np.array(
+            [
+                [1.5, 2.5],
+                [3.0, 4.9],
+                [5.1, 6.9],
+            ],
+            dtype=np.float32,
+        )
+
+        # x.shape = (3, 4)
+        # y_scale.shape = (3, 2)
+
+        block_axis = 1
+        # The block shape is [x.shape[i] // y_scale.shape[i] for i in range(len(x.shape))] = (1, 2)
+        assert all(
+            x.shape[i] == y_scale.shape[i]
+            for i in range(len(x.shape))
+            if i != block_axis
+        )
+        assert x.shape[block_axis] % y_scale.shape[block_axis] == 0
+        repeats = x.shape[block_axis] // y_scale.shape[block_axis]
+
+        # Create element-wise scale and zero point
+        y_scale_elementwise = np.repeat(y_scale, repeats=repeats, axis=block_axis)
+
+        y_val = np.clip(
+            np.rint(x / y_scale_elementwise), a_min=-32768, a_max=32767
+        ).astype(np.int16)
+        y = make_tensor(
+            "y",
+            TensorProto.INT16,
+            x.shape,
+            y_val,
+        )
+        expect(
+            node,
+            inputs=[x, y_scale],
+            outputs=[y],
+            name="test_quantizelinear_blocked_symmetric",
+        )
diff --git a/onnx/backend/test/case/node/rangeop.py b/onnx/backend/test/case/node/rangeop.py
new file mode 100644
index 0000000..88d005f
--- /dev/null
+++ b/onnx/backend/test/case/node/rangeop.py
@@ -0,0 +1,102 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import ml_dtypes
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Range(Base):
+    @staticmethod
+    def export_range_float_type_positive_delta() -> None:
+        node = onnx.helper.make_node(
+            "Range",
+            inputs=["start", "limit", "delta"],
+            outputs=["output"],
+        )
+
+        start = np.float32(1)
+        limit = np.float32(5)
+        delta = np.float32(2)
+
+        output = np.arange(
+            start, limit, delta, dtype=np.float32
+        )  # expected output [1.0, 3.0]
+        expect(
+            node,
+            inputs=[start, limit, delta],
+            outputs=[output],
+            name="test_range_float_type_positive_delta",
+        )
+
+    @staticmethod
+    def export_range_float16_type_positive_delta() -> None:
+        node = onnx.helper.make_node(
+            "Range",
+            inputs=["start", "limit", "delta"],
+            outputs=["output"],
+        )
+
+        start = np.float16(1)
+        limit = np.float16(5)
+        delta = np.float16(2)
+
+        output = np.arange(
+            start, limit, delta, dtype=np.float16
+        )  # expected output [1.0, 3.0]
+        expect(
+            node,
+            inputs=[start, limit, delta],
+            outputs=[output],
+            name="test_range_float16_type_positive_delta",
+        )
+
+    @staticmethod
+    def export_range_bfloat16_type_positive_delta() -> None:
+        node = onnx.helper.make_node(
+            "Range",
+            inputs=["start", "limit", "delta"],
+            outputs=["output"],
+        )
+
+        start = np.array(1.0, dtype=ml_dtypes.bfloat16)
+        limit = np.array(5.0, dtype=ml_dtypes.bfloat16)
+        delta = np.array(2.0, dtype=ml_dtypes.bfloat16)
+
+        output = np.arange(1.0, 5.0, 2.0, dtype=np.float32).astype(
+            ml_dtypes.bfloat16
+        )  # expected output [1.0, 3.0] as bfloat16
+
+        expect(
+            node,
+            inputs=[start, limit, delta],
+            outputs=[output],
+            name="test_range_bfloat16_type_positive_delta",
+        )
+
+    @staticmethod
+    def export_range_int32_type_negative_delta() -> None:
+        node = onnx.helper.make_node(
+            "Range",
+            inputs=["start", "limit", "delta"],
+            outputs=["output"],
+        )
+
+        start = np.int32(10)
+        limit = np.int32(6)
+        delta = np.int32(-3)
+
+        output = np.arange(
+            start, limit, delta, dtype=np.int32
+        )  # expected output [10, 7]
+        expect(
+            node,
+            inputs=[start, limit, delta],
+            outputs=[output],
+            name="test_range_int32_type_negative_delta",
+        )
diff --git a/onnx/backend/test/case/node/reciprocal.py b/onnx/backend/test/case/node/reciprocal.py
new file mode 100644
index 0000000..eea8f2c
--- /dev/null
+++ b/onnx/backend/test/case/node/reciprocal.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Reciprocal(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Reciprocal",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-4, 2]).astype(np.float32)
+        y = np.reciprocal(x)  # expected output [-0.25, 0.5],
+        expect(node, inputs=[x], outputs=[y], name="test_reciprocal_example")
+
+        x = np.random.rand(3, 4, 5).astype(np.float32) + 0.5
+        y = np.reciprocal(x)
+        expect(node, inputs=[x], outputs=[y], name="test_reciprocal")
diff --git a/onnx/backend/test/case/node/reduce_log_sum.py b/onnx/backend/test/case/node/reduce_log_sum.py
new file mode 100644
index 0000000..8a99f71
--- /dev/null
+++ b/onnx/backend/test/case/node/reduce_log_sum.py
@@ -0,0 +1,104 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceLogSum(Base):
+    @staticmethod
+    def export_nokeepdims() -> None:
+        shape = [3, 4, 5]
+        axes = np.array([2, 1], dtype=np.int64)
+
+        node = onnx.helper.make_node(
+            "ReduceLogSum",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=0,
+        )
+        data = np.random.ranf(shape).astype(np.float32)
+        reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=False))
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_desc_axes",
+        )
+
+        axes = np.array([0, 1], dtype=np.int64)
+        node = onnx.helper.make_node(
+            "ReduceLogSum",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=0,
+        )
+        data = np.random.ranf(shape).astype(np.float32)
+        reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=False))
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_asc_axes",
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        node = onnx.helper.make_node(
+            "ReduceLogSum", inputs=["data", "axes"], outputs=["reduced"]
+        )
+        data = np.random.ranf([3, 4, 5]).astype(np.float32)
+        reduced = np.log(np.sum(data, keepdims=True))
+        axes = np.array([], dtype=np.int64)
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_default",
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        axes = np.array([-2], dtype=np.int64)
+        node = onnx.helper.make_node(
+            "ReduceLogSum", inputs=["data", "axes"], outputs=["reduced"]
+        )
+        data = np.random.ranf([3, 4, 5]).astype(np.float32)
+        reduced = np.log(np.sum(data, axis=tuple(axes), keepdims=True))
+        # print(reduced)
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_negative_axes",
+        )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceLogSum",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+        reduced = np.log(zero)  # -inf
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_empty_set",
+        )
diff --git a/onnx/backend/test/case/node/reduce_log_sum_exp.py b/onnx/backend/test/case/node/reduce_log_sum_exp.py
new file mode 100644
index 0000000..30f7b52
--- /dev/null
+++ b/onnx/backend/test/case/node/reduce_log_sum_exp.py
@@ -0,0 +1,193 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceLogSumExp(Base):
+    @staticmethod
+    def export_do_not_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 0
+        node = onnx.helper.make_node(
+            "ReduceLogSumExp",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+        )
+        reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+        # print(reduced)
+        # [[20., 2.31326175]
+        # [40.00004578, 2.31326175]
+        # [60.00671387, 2.31326175]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_exp_do_not_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.double)
+        reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_exp_do_not_keepdims_random",
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ReduceLogSumExp",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+        )
+        reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+        # print(reduced)
+        # [[[20., 2.31326175]]
+        # [[40.00004578, 2.31326175]]
+        # [[60.00671387, 2.31326175]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_exp_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.double)
+        reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_exp_keepdims_random",
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceLogSumExp",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+        )
+        reduced = np.log(np.sum(np.exp(data), axis=None, keepdims=keepdims == 1))
+        # print(reduced)
+        # [[[60.00671387]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_exp_default_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.double)
+        reduced = np.log(np.sum(np.exp(data), axis=None, keepdims=keepdims == 1))
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_exp_default_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([-2], dtype=np.int64)
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ReduceLogSumExp",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.double
+        )
+        reduced = np.log(np.sum(np.exp(data), axis=tuple(axes), keepdims=keepdims == 1))
+        # print(reduced)
+        # [[[20., 2.31326175]]
+        # [[40.00004578, 2.31326175]]
+        # [[60.00671387, 2.31326175]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_exp_negative_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.double)
+        reduced = np.log(
+            np.sum(np.exp(data), axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+        )
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_exp_negative_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceLogSumExp",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+        reduced = np.log(zero)  # -inf
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_log_sum_exp_empty_set",
+        )
diff --git a/onnx/backend/test/case/node/reducel1.py b/onnx/backend/test/case/node/reducel1.py
new file mode 100644
index 0000000..711c8b0
--- /dev/null
+++ b/onnx/backend/test/case/node/reducel1.py
@@ -0,0 +1,189 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceL1(Base):
+    @staticmethod
+    def export_do_not_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([2], dtype=np.int64)
+        keepdims = 0
+
+        node = onnx.helper.make_node(
+            "ReduceL1",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+        reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[3., 7.], [11., 15.], [19., 23.]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l1_do_not_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l1_do_not_keepdims_random",
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([2], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceL1",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+        reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l1_keep_dims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l1_keep_dims_random",
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceL1", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+        )
+
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+        reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[78.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l1_default_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(a=np.abs(data), axis=None, keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l1_default_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([-1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceL1",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+        reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[3.], [7.]], [[11.], [15.]], [[19.], [23.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l1_negative_axes_keep_dims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(a=np.abs(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l1_negative_axes_keep_dims_random",
+        )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceL1",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l1_empty_set",
+        )
diff --git a/onnx/backend/test/case/node/reducel2.py b/onnx/backend/test/case/node/reducel2.py
new file mode 100644
index 0000000..9b440cc
--- /dev/null
+++ b/onnx/backend/test/case/node/reducel2.py
@@ -0,0 +1,207 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceL2(Base):
+    @staticmethod
+    def export_do_not_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([2], dtype=np.int64)
+        keepdims = 0
+
+        node = onnx.helper.make_node(
+            "ReduceL2",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+        reduced = np.sqrt(
+            np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+        )
+        # print(reduced)
+        # [[2.23606798, 5.],
+        # [7.81024968, 10.63014581],
+        # [13.45362405, 16.2788206]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l2_do_not_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sqrt(
+            np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+        )
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l2_do_not_keepdims_random",
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([2], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceL2",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+        reduced = np.sqrt(
+            np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+        )
+        # print(reduced)
+        # [[[2.23606798], [5.]]
+        # [[7.81024968], [10.63014581]]
+        # [[13.45362405], [16.2788206 ]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l2_keep_dims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sqrt(
+            np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+        )
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l2_keep_dims_random",
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceL2", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+        )
+
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+        reduced = np.sqrt(np.sum(a=np.square(data), axis=None, keepdims=keepdims == 1))
+        # print(reduced)
+        # [[[25.49509757]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l2_default_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sqrt(np.sum(a=np.square(data), axis=None, keepdims=keepdims == 1))
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l2_default_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([-1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceL2",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.reshape(np.arange(1, np.prod(shape) + 1, dtype=np.float32), shape)
+        # print(data)
+        # [[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]], [[9., 10.], [11., 12.]]]
+
+        reduced = np.sqrt(
+            np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+        )
+        # print(reduced)
+        # [[[2.23606798], [5.]]
+        # [[7.81024968], [10.63014581]]
+        # [[13.45362405], [16.2788206 ]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l2_negative_axes_keep_dims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sqrt(
+            np.sum(a=np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+        )
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l2_negative_axes_keep_dims_random",
+        )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceL2",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_l2_empty_set",
+        )
diff --git a/onnx/backend/test/case/node/reducemax.py b/onnx/backend/test/case/node/reducemax.py
new file mode 100644
index 0000000..5da9d48
--- /dev/null
+++ b/onnx/backend/test/case/node/reducemax.py
@@ -0,0 +1,231 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceMax(Base):
+    @staticmethod
+    def export_do_not_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 0
+
+        node = onnx.helper.make_node(
+            "ReduceMax",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[20., 2.]
+        # [40., 2.]
+        # [60., 2.]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_max_do_not_keepdims_example",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_max_do_not_keepdims_random",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMax",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[20., 2.]]
+        # [[40., 2.]]
+        # [[60., 2.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_max_keepdims_example",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_max_keepdims_random",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = None
+        keepdims = 1
+        node = onnx.helper.make_node(
+            "ReduceMax", inputs=["data"], outputs=["reduced"], keepdims=keepdims
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.maximum.reduce(data, axis=axes, keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data],
+            outputs=[reduced],
+            name="test_reduce_max_default_axes_keepdim_example",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.maximum.reduce(data, axis=axes, keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data],
+            outputs=[reduced],
+            name="test_reduce_max_default_axes_keepdims_random",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([-2], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMax",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[20., 2.]]
+        # [[40., 2.]]
+        # [[60., 2.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_max_negative_axes_keepdims_example",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_max_negative_axes_keepdims_random",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+    @staticmethod
+    def export_bool_inputs() -> None:
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMax",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[True, True], [True, False], [False, True], [False, False]],
+        )
+        reduced = np.maximum.reduce(data, axis=tuple(axes), keepdims=bool(keepdims))
+        # print(reduced)
+        # [[True],
+        #  [True],
+        #  [True],
+        #  [False]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_max_bool_inputs",
+        )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceMax",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        one = np.array(np.ones(reduced_shape, dtype=np.float32))
+        zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+        reduced = -(one / zero)  # -inf
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_max_empty_set",
+        )
diff --git a/onnx/backend/test/case/node/reducemean.py b/onnx/backend/test/case/node/reducemean.py
new file mode 100644
index 0000000..fbd68c6
--- /dev/null
+++ b/onnx/backend/test/case/node/reducemean.py
@@ -0,0 +1,174 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceMean(Base):
+    @staticmethod
+    def export_do_not_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 0
+
+        node = onnx.helper.make_node(
+            "ReduceMean",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[12.5, 1.5]
+        # [35., 1.5]
+        # [57.5, 1.5]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_mean_do_not_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_mean_do_not_keepdims_random",
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMean",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[12.5, 1.5]]
+        # [[35., 1.5]]
+        # [[57.5, 1.5]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_mean_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_mean_keepdims_random",
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMean",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.mean(data, axis=None, keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[18.25]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_mean_default_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.mean(data, axis=None, keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_mean_default_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([-2], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMean",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[12.5, 1.5]]
+        # [[35., 1.5]]
+        # [[57.5, 1.5]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_mean_negative_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.mean(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_mean_negative_axes_keepdims_random",
+        )
diff --git a/onnx/backend/test/case/node/reducemin.py b/onnx/backend/test/case/node/reducemin.py
new file mode 100644
index 0000000..7bbc37a
--- /dev/null
+++ b/onnx/backend/test/case/node/reducemin.py
@@ -0,0 +1,234 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceMin(Base):
+    @staticmethod
+    def export_do_not_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 0
+
+        node = onnx.helper.make_node(
+            "ReduceMin",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[5., 1.]
+        # [30., 1.]
+        # [55., 1.]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_min_do_not_keepdims_example",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_min_do_not_keepdims_random",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMin",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[5., 1.]]
+        # [[30., 1.]]
+        # [[55., 1.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_min_keepdims_example",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_min_keepdims_random",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = None
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMin", inputs=["data"], outputs=["reduced"], keepdims=keepdims
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.minimum.reduce(data, axis=axes, keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[1.]]]
+
+        expect(
+            node,
+            inputs=[data],
+            outputs=[reduced],
+            name="test_reduce_min_default_axes_keepdims_example",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.minimum.reduce(data, axis=axes, keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data],
+            outputs=[reduced],
+            name="test_reduce_min_default_axes_keepdims_random",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([-2], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMin",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]],
+            dtype=np.float32,
+        )
+        reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[5., 1.]]
+        # [[30., 1.]]
+        # [[55., 1.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_min_negative_axes_keepdims_example",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_min_negative_axes_keepdims_random",
+            opset_imports=[onnx.helper.make_opsetid("", 18)],
+        )
+
+    @staticmethod
+    def export_bool_inputs() -> None:
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceMin",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[True, True], [True, False], [False, True], [False, False]],
+        )
+        reduced = np.minimum.reduce(data, axis=tuple(axes), keepdims=bool(keepdims))
+        # print(reduced)
+        # [[ True],
+        #  [False],
+        #  [False],
+        #  [False]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_min_bool_inputs",
+        )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceMin",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        one = np.array(np.ones(reduced_shape, dtype=np.float32))
+        zero = np.array(np.zeros(reduced_shape, dtype=np.float32))
+        reduced = one / zero  # inf
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_min_empty_set",
+        )
diff --git a/onnx/backend/test/case/node/reduceprod.py b/onnx/backend/test/case/node/reduceprod.py
new file mode 100644
index 0000000..079c19a
--- /dev/null
+++ b/onnx/backend/test/case/node/reduceprod.py
@@ -0,0 +1,187 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceProd(Base):
+    @staticmethod
+    def export_do_not_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 0
+
+        node = onnx.helper.make_node(
+            "ReduceProd",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[3., 8.]
+        # [35., 48.]
+        # [99., 120.]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_prod_do_not_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_prod_do_not_keepdims_random",
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceProd",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[3., 8.]]
+        # [[35., 48.]]
+        # [[99., 120.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_prod_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_prod_keepdims_random",
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = None
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceProd", inputs=["data"], outputs=["reduced"], keepdims=keepdims
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.prod(data, axis=axes, keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[4.790016e+08]]]
+
+        expect(
+            node,
+            inputs=[data],
+            outputs=[reduced],
+            name="test_reduce_prod_default_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.prod(data, axis=axes, keepdims=keepdims == 1)
+        expect(
+            node,
+            inputs=[data],
+            outputs=[reduced],
+            name="test_reduce_prod_default_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([-2], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceProd",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[3., 8.]]
+        # [[35., 48.]]
+        # [[99., 120.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_prod_negative_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.prod(data, axis=tuple(axes), keepdims=keepdims == 1)
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_prod_negative_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceProd",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        reduced = np.array(np.ones(reduced_shape, dtype=np.float32))
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_prod_empty_set",
+        )
diff --git a/onnx/backend/test/case/node/reducesum.py b/onnx/backend/test/case/node/reducesum.py
new file mode 100644
index 0000000..e311b2c
--- /dev/null
+++ b/onnx/backend/test/case/node/reducesum.py
@@ -0,0 +1,247 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceSum(Base):
+    @staticmethod
+    def export_do_not_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 0
+
+        node = onnx.helper.make_node(
+            "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[4., 6.]
+        # [12., 14.]
+        # [20., 22.]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_do_not_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_do_not_keepdims_random",
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[4., 6.]]
+        # [[12., 14.]]
+        # [[20., 22.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_keepdims_random",
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.sum(data, axis=None, keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[78.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_default_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(data, axis=None, keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_default_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([-2], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceSum", inputs=["data", "axes"], outputs=["reduced"], keepdims=keepdims
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[4., 6.]]
+        # [[12., 14.]]
+        # [[20., 22.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_negative_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(data, axis=tuple(axes.tolist()), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_negative_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_empty_axes_input_noop() -> None:
+        shape = [3, 2, 2]
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceSum",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+            noop_with_empty_axes=True,
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        axes = np.array([], dtype=np.int64)
+        reduced = np.array(data)
+        # print(reduced)
+        # [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_empty_axes_input_noop_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.array(data)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_empty_axes_input_noop",
+        )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        """Test case with the reduced-axis of size zero."""
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceSum",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_empty_set",
+        )
+
+    @staticmethod
+    def export_non_reduced_axis_zero() -> None:
+        """Test case with the non-reduced-axis of size zero."""
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 0, 1]
+
+        node = onnx.helper.make_node(
+            "ReduceSum",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([2], dtype=np.int64)
+        reduced = np.array([], dtype=np.float32).reshape(reduced_shape)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_empty_set_non_reduced_axis_zero",
+        )
diff --git a/onnx/backend/test/case/node/reducesumsquare.py b/onnx/backend/test/case/node/reducesumsquare.py
new file mode 100644
index 0000000..a6c3128
--- /dev/null
+++ b/onnx/backend/test/case/node/reducesumsquare.py
@@ -0,0 +1,194 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReduceSumSquare(Base):
+    @staticmethod
+    def export_do_not_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 0
+
+        node = onnx.helper.make_node(
+            "ReduceSumSquare",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[10., 20.]
+        # [74., 100.]
+        # [202., 244.]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_square_do_not_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_square_do_not_keepdims_random",
+        )
+
+    @staticmethod
+    def export_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([1], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceSumSquare",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[10., 20.]]
+        # [[74., 100.]]
+        # [[202., 244.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_square_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_square_keepdims_random",
+        )
+
+    @staticmethod
+    def export_default_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceSumSquare",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.sum(np.square(data), axis=None, keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[650.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_square_default_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(np.square(data), axis=None, keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_square_default_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_negative_axes_keepdims() -> None:
+        shape = [3, 2, 2]
+        axes = np.array([-2], dtype=np.int64)
+        keepdims = 1
+
+        node = onnx.helper.make_node(
+            "ReduceSumSquare",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array(
+            [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]], dtype=np.float32
+        )
+        reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+        # print(reduced)
+        # [[[10., 20.s]]
+        # [[74., 100.]]
+        # [[202., 244.]]]
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_square_negative_axes_keepdims_example",
+        )
+
+        np.random.seed(0)
+        data = np.random.uniform(-10, 10, shape).astype(np.float32)
+        reduced = np.sum(np.square(data), axis=tuple(axes), keepdims=keepdims == 1)
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_square_negative_axes_keepdims_random",
+        )
+
+    @staticmethod
+    def export_empty_set() -> None:
+        shape = [2, 0, 4]
+        keepdims = 1
+        reduced_shape = [2, 1, 4]
+
+        node = onnx.helper.make_node(
+            "ReduceSumSquare",
+            inputs=["data", "axes"],
+            outputs=["reduced"],
+            keepdims=keepdims,
+        )
+
+        data = np.array([], dtype=np.float32).reshape(shape)
+        axes = np.array([1], dtype=np.int64)
+        reduced = np.array(np.zeros(reduced_shape, dtype=np.float32))
+
+        expect(
+            node,
+            inputs=[data, axes],
+            outputs=[reduced],
+            name="test_reduce_sum_square_empty_set",
+        )
diff --git a/onnx/backend/test/case/node/regex_full_match.py b/onnx/backend/test/case/node/regex_full_match.py
new file mode 100644
index 0000000..3fd7a90
--- /dev/null
+++ b/onnx/backend/test/case/node/regex_full_match.py
@@ -0,0 +1,68 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class RegexFullMatch(Base):
+    @staticmethod
+    def export_basic() -> None:
+        node = onnx.helper.make_node(
+            "RegexFullMatch",
+            inputs=["X"],
+            outputs=["Y"],
+            pattern=r"www\.[\w.-]+\.\bcom\b",
+        )
+
+        x = np.array(["www.google.com", "www.facebook.com", "www.bbc.co.uk"]).astype(
+            object
+        )
+        result = np.array([True, True, False])
+        expect(node, inputs=[x], outputs=[result], name="test_regex_full_match_basic")
+
+    @staticmethod
+    def export_match_email_domain() -> None:
+        node = onnx.helper.make_node(
+            "RegexFullMatch",
+            inputs=["X"],
+            outputs=["Y"],
+            pattern=r"(\W|^)[\w.\-]{0,25}@(yahoo|gmail)\.com(\W|$)",
+        )
+
+        x = np.array(
+            [
+                ["account@gmail.com", "account@hotmail.com"],
+                ["not email", "account2@yahoo.com"],
+            ]
+        ).astype(object)
+        result = np.array([[True, False], [False, True]])
+        expect(
+            node,
+            inputs=[x],
+            outputs=[result],
+            name="test_regex_full_match_email_domain",
+        )
+
+    @staticmethod
+    def export_match_empty() -> None:
+        node = onnx.helper.make_node(
+            "RegexFullMatch",
+            inputs=["X"],
+            outputs=["Y"],
+            pattern=r"(\W|^)[\w.\-]{0,25}@(yahoo|gmail)\.com(\W|$)",
+        )
+
+        x = np.array([[], []]).astype(object)
+        result = np.array([[], []]).astype(bool)
+        expect(
+            node,
+            inputs=[x],
+            outputs=[result],
+            name="test_regex_full_match_empty",
+        )
diff --git a/onnx/backend/test/case/node/relu.py b/onnx/backend/test/case/node/relu.py
new file mode 100644
index 0000000..3fbb181
--- /dev/null
+++ b/onnx/backend/test/case/node/relu.py
@@ -0,0 +1,24 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Relu(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Relu",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, 0, np.inf)
+
+        expect(node, inputs=[x], outputs=[y], name="test_relu")
diff --git a/onnx/backend/test/case/node/reshape.py b/onnx/backend/test/case/node/reshape.py
new file mode 100644
index 0000000..2c369ef
--- /dev/null
+++ b/onnx/backend/test/case/node/reshape.py
@@ -0,0 +1,82 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def reshape_reference_implementation(
+    data: np.ndarray, shape: np.ndarray, allowzero: int = 0
+) -> np.ndarray:
+    # replace zeros with corresponding dim size
+    # we need to do this because np.reshape doesn't support 0 by default unless 'allowzero' is set
+    new_shape = np.copy(shape)
+    if allowzero == 0:
+        zeros_index = np.where(shape == 0)
+        new_shape[zeros_index] = np.array(data.shape)[zeros_index]
+    return np.reshape(data, new_shape)
+
+
+class Reshape(Base):
+    @staticmethod
+    def export_reshape() -> None:
+        original_shape = [2, 3, 4]
+        test_cases = {
+            "reordered_all_dims": np.array([4, 2, 3], dtype=np.int64),
+            "reordered_last_dims": np.array([2, 4, 3], dtype=np.int64),
+            "reduced_dims": np.array([2, 12], dtype=np.int64),
+            "extended_dims": np.array([2, 3, 2, 2], dtype=np.int64),
+            "one_dim": np.array([24], dtype=np.int64),
+            "negative_dim": np.array([2, -1, 2], dtype=np.int64),
+            "negative_extended_dims": np.array([-1, 2, 3, 4], dtype=np.int64),
+            "zero_dim": np.array([2, 0, 4, 1], dtype=np.int64),
+            "zero_and_negative_dim": np.array([2, 0, 1, -1], dtype=np.int64),
+        }
+        data = np.random.random_sample(original_shape).astype(np.float32)
+
+        for test_name, shape in test_cases.items():
+            node = onnx.helper.make_node(
+                "Reshape",
+                inputs=["data", "shape"],
+                outputs=["reshaped"],
+            )
+
+            reshaped = reshape_reference_implementation(data, shape)
+
+            expect(
+                node,
+                inputs=[data, shape],
+                outputs=[reshaped],
+                name="test_reshape_" + test_name,
+            )
+
+    @staticmethod
+    def export_allowzero() -> None:
+        original_shape = [0, 3, 4]
+        test_cases = {
+            "allowzero_reordered": np.array([3, 4, 0], dtype=np.int64),
+        }
+        data = np.random.random_sample(original_shape).astype(np.float32)
+
+        for test_name, shape in test_cases.items():
+            node = onnx.helper.make_node(
+                "Reshape",
+                inputs=["data", "shape"],
+                outputs=["reshaped"],
+                allowzero=1,  # if allowzero=1, final shape = (3, 4, 0)
+                # if allowzero=0, final shape = (3, 4, 4)
+            )
+
+            reshaped = reshape_reference_implementation(data, shape, allowzero=1)
+
+            expect(
+                node,
+                inputs=[data, shape],
+                outputs=[reshaped],
+                name="test_reshape_" + test_name,
+            )
diff --git a/onnx/backend/test/case/node/resize.py b/onnx/backend/test/case/node/resize.py
new file mode 100644
index 0000000..ac31ea4
--- /dev/null
+++ b/onnx/backend/test/case/node/resize.py
@@ -0,0 +1,1714 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_resize import _cubic_coeffs as cubic_coeffs
+from onnx.reference.ops.op_resize import (
+    _cubic_coeffs_antialias as cubic_coeffs_antialias,
+)
+from onnx.reference.ops.op_resize import _interpolate_nd as interpolate_nd
+from onnx.reference.ops.op_resize import _linear_coeffs as linear_coeffs
+from onnx.reference.ops.op_resize import (
+    _linear_coeffs_antialias as linear_coeffs_antialias,
+)
+from onnx.reference.ops.op_resize import _nearest_coeffs as nearest_coeffs
+
+
+class Resize(Base):
+    @staticmethod
+    def export_resize_upsample_scales_nearest() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="nearest",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
+
+        # [[[[1. 1. 1. 2. 2. 2.]
+        #    [1. 1. 1. 2. 2. 2.]
+        #    [3. 3. 3. 4. 4. 4.]
+        #    [3. 3. 3. 4. 4. 4.]]]]
+        output = interpolate_nd(
+            data, lambda x, _: nearest_coeffs(x), scale_factors=scales
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_nearest",
+        )
+
+    @staticmethod
+    def export_resize_downsample_scales_nearest() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="nearest",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+        # [[[[1. 3.]]]]
+        output = interpolate_nd(
+            data, lambda x, _: nearest_coeffs(x), scale_factors=scales
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_downsample_scales_nearest",
+        )
+
+    @staticmethod
+    def export_resize_upsample_sizes_nearest() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 7, 8], dtype=np.int64)
+
+        # [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+        output = interpolate_nd(
+            data, lambda x, _: nearest_coeffs(x), output_size=sizes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_upsample_sizes_nearest",
+        )
+
+    @staticmethod
+    def export_resize_downsample_sizes_nearest() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 1, 3], dtype=np.int64)
+
+        # [[[[1. 2. 4.]]]]
+        output = interpolate_nd(
+            data, lambda x, _: nearest_coeffs(x), output_size=sizes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_downsample_sizes_nearest",
+        )
+
+    @staticmethod
+    def export_resize_upsample_scales_linear() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="linear",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+        # [[[[1.   1.25 1.75 2.  ]
+        #    [1.5  1.75 2.25 2.5 ]
+        #    [2.5  2.75 3.25 3.5 ]
+        #    [3.   3.25 3.75 4.  ]]]]
+        output = interpolate_nd(
+            data, lambda x, _: linear_coeffs(x), scale_factors=scales
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_linear",
+        )
+
+    @staticmethod
+    def export_resize_upsample_scales_linear_align_corners() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="linear",
+            coordinate_transformation_mode="align_corners",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+        # [[[[1.         1.33333333 1.66666667 2.        ]
+        #    [1.66666667 2.         2.33333333 2.66666667]
+        #    [2.33333333 2.66666667 3.         3.33333333]
+        #    [3.         3.33333333 3.66666667 4.        ]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: linear_coeffs(x),
+            scale_factors=scales,
+            coordinate_transformation_mode="align_corners",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_linear_align_corners",
+        )
+
+    @staticmethod
+    def export_resize_downsample_scales_linear() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="linear",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+        # [[[[2.6666665 4.3333331]]]]
+        output = interpolate_nd(
+            data, lambda x, _: linear_coeffs(x), scale_factors=scales
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_downsample_scales_linear",
+        )
+
+    @staticmethod
+    def export_resize_downsample_scales_linear_align_corners() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="linear",
+            coordinate_transformation_mode="align_corners",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+        # [[[[1.       3.142857]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: linear_coeffs(x),
+            scale_factors=scales,
+            coordinate_transformation_mode="align_corners",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_downsample_scales_linear_align_corners",
+        )
+
+    @staticmethod
+    def export_resize_upsample_scales_cubic() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="cubic",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+        # [[[[ 0.47265625  0.76953125  1.24609375  1.875       2.28125
+        #      2.91015625  3.38671875  3.68359375]
+        #    [ 1.66015625  1.95703125  2.43359375  3.0625      3.46875
+        #      4.09765625  4.57421875  4.87109375]
+        #    [ 3.56640625  3.86328125  4.33984375  4.96875     5.375
+        #      6.00390625  6.48046875  6.77734375]
+        #    [ 6.08203125  6.37890625  6.85546875  7.484375    7.890625
+        #      8.51953125  8.99609375  9.29296875]
+        #    [ 7.70703125  8.00390625  8.48046875  9.109375    9.515625
+        #     10.14453125 10.62109375 10.91796875]
+        #    [10.22265625 10.51953125 10.99609375 11.625      12.03125
+        #     12.66015625 13.13671875 13.43359375]
+        #    [12.12890625 12.42578125 12.90234375 13.53125    13.9375
+        #     14.56640625 15.04296875 15.33984375]
+        #    [13.31640625 13.61328125 14.08984375 14.71875    15.125
+        #     15.75390625 16.23046875 16.52734375]]]]
+        output = interpolate_nd(
+            data, lambda x, _: cubic_coeffs(x), scale_factors=scales
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_cubic",
+        )
+
+    @staticmethod
+    def export_resize_upsample_scales_cubic_align_corners() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="cubic",
+            coordinate_transformation_mode="align_corners",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+        # [[[[ 1.          1.34110787  1.80029155  2.32944606  2.67055394
+        #      3.19970845  3.65889213  4.        ]
+        #    [ 2.36443149  2.70553936  3.16472303  3.69387755  4.03498542
+        #      4.56413994  5.02332362  5.36443149]
+        #    [ 4.20116618  4.54227405  5.00145773  5.53061224  5.87172012
+        #      6.40087464  6.86005831  7.20116618]
+        #    [ 6.31778426  6.65889213  7.1180758   7.64723032  7.98833819
+        #      8.51749271  8.97667638  9.31778426]
+        #    [ 7.68221574  8.02332362  8.48250729  9.01166181  9.35276968
+        #      9.8819242  10.34110787 10.68221574]
+        #    [ 9.79883382 10.13994169 10.59912536 11.12827988 11.46938776
+        #     11.99854227 12.45772595 12.79883382]
+        #    [11.63556851 11.97667638 12.43586006 12.96501458 13.30612245
+        #     13.83527697 14.29446064 14.63556851]
+        #    [13.         13.34110787 13.80029155 14.32944606 14.67055394
+        #     15.19970845 15.65889213 16.        ]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: cubic_coeffs(x),
+            scale_factors=scales,
+            coordinate_transformation_mode="align_corners",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_cubic_align_corners",
+        )
+
+    @staticmethod
+    def export_resize_downsample_scales_cubic() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="cubic",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32)
+
+        # [[[[ 1.47119141  2.78125     4.08251953]
+        #    [ 6.71142578  8.02148438  9.32275391]
+        #    [11.91650391 13.2265625  14.52783203]]]]
+        output = interpolate_nd(
+            data, lambda x, _: cubic_coeffs(x), scale_factors=scales
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_downsample_scales_cubic",
+        )
+
+    @staticmethod
+    def export_resize_downsample_scales_cubic_align_corners() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="cubic",
+            coordinate_transformation_mode="align_corners",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32)
+
+        # [[[[ 1.          2.39519159  3.79038317]
+        #    [ 6.58076634  7.97595793  9.37114951]
+        #    [12.16153268 13.55672427 14.95191585]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: cubic_coeffs(x),
+            scale_factors=scales,
+            coordinate_transformation_mode="align_corners",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_downsample_scales_cubic_align_corners",
+        )
+
+    @staticmethod
+    def export_resize_upsample_sizes_cubic() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="cubic",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 9, 10], dtype=np.int64)
+
+        # [[[[ 0.45507922  0.64057922  0.97157922  1.42257922  1.90732922
+        #      2.22332922  2.70807922  3.15907922  3.49007922  3.67557922]
+        #    [ 1.39437963  1.57987963  1.91087963  2.36187963  2.84662963
+        #      3.16262963  3.64737963  4.09837963  4.42937963  4.61487963]
+        #    [ 2.95130693  3.13680693  3.46780693  3.91880693  4.40355693
+        #      4.71955693  5.20430693  5.65530693  5.98630693  6.17180693]
+        #    [ 5.20525069  5.39075069  5.72175069  6.17275069  6.65750069
+        #      6.97350069  7.45825069  7.90925069  8.24025069  8.42575069]
+        #    [ 6.88975     7.07525     7.40625     7.85725     8.342
+        #      8.658       9.14275     9.59375     9.92475    10.11025   ]
+        #    [ 8.57424931  8.75974931  9.09074931  9.54174931 10.02649931
+        #     10.34249931 10.82724931 11.27824931 11.60924931 11.79474931]
+        #    [10.82819307 11.01369307 11.34469307 11.79569307 12.28044307
+        #     12.59644307 13.08119307 13.53219307 13.86319307 14.04869307]
+        #    [12.38512037 12.57062037 12.90162037 13.35262037 13.83737037
+        #     14.15337037 14.63812037 15.08912037 15.42012037 15.60562037]
+        #    [13.32442078 13.50992078 13.84092078 14.29192078 14.77667078
+        #     15.09267078 15.57742078 16.02842078 16.35942078 16.54492078]]]]
+        output = interpolate_nd(
+            data, lambda x, _: cubic_coeffs(x), output_size=sizes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_upsample_sizes_cubic",
+        )
+
+    @staticmethod
+    def export_resize_downsample_sizes_cubic() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="cubic",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+        # [[[[ 1.63078704  3.00462963  4.37847222]
+        #    [ 7.12615741  8.5         9.87384259]
+        #    [12.62152778 13.99537037 15.36921296]]]]
+        output = interpolate_nd(
+            data, lambda x, _: cubic_coeffs(x), output_size=sizes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_downsample_sizes_cubic",
+        )
+
+    # TensorFlow v1 bicubic with half_pixel_centers=True
+    @staticmethod
+    def export_resize_upsample_scales_cubic_A_n0p5_exclude_outside() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="cubic",
+            cubic_coeff_a=-0.5,
+            exclude_outside=True,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+        # [[[[ 0.55882353  0.81494204  1.35698249  1.89705882  2.39705882
+        #      2.93713516  3.47917561  3.73529412]
+        #    [ 1.58329755  1.83941606  2.38145651  2.92153285  3.42153285
+        #      3.96160918  4.50364964  4.75976814]
+        #    [ 3.75145936  4.00757787  4.54961832  5.08969466  5.58969466
+        #      6.12977099  6.67181144  6.92792995]
+        #    [ 5.91176471  6.16788321  6.70992366  7.25        7.75
+        #      8.29007634  8.83211679  9.08823529]
+        #    [ 7.91176471  8.16788321  8.70992366  9.25        9.75
+        #     10.29007634 10.83211679 11.08823529]
+        #    [10.07207005 10.32818856 10.87022901 11.41030534 11.91030534
+        #     12.45038168 12.99242213 13.24854064]
+        #    [12.24023186 12.49635036 13.03839082 13.57846715 14.07846715
+        #     14.61854349 15.16058394 15.41670245]
+        #    [13.26470588 13.52082439 14.06286484 14.60294118 15.10294118
+        #     15.64301751 16.18505796 16.44117647]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: cubic_coeffs(x, A=-0.5),
+            scale_factors=scales,
+            exclude_outside=True,
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_cubic_A_n0p5_exclude_outside",
+        )
+
+    @staticmethod
+    def export_resize_downsample_scales_cubic_A_n0p5_exclude_outside() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="cubic",
+            cubic_coeff_a=-0.5,
+            exclude_outside=True,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 0.8, 0.8], dtype=np.float32)
+
+        # [[[[ 1.36812675  2.6695014   4.0133367 ]
+        #    [ 6.57362535  7.875       9.2188353 ]
+        #    [11.94896657 13.25034122 14.59417652]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: cubic_coeffs(x, A=-0.5),
+            scale_factors=scales,
+            exclude_outside=True,
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_downsample_scales_cubic_A_n0p5_exclude_outside",
+        )
+
+    # TensorFlow v1 bicubic with half_pixel_centers=False
+    @staticmethod
+    def export_resize_upsample_scales_cubic_asymmetric() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="cubic",
+            coordinate_transformation_mode="asymmetric",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
+
+        # [[[[ 1.       1.40625  2.       2.5      3.       3.59375  4.
+        #      4.09375]
+        #    [ 2.625    3.03125  3.625    4.125    4.625    5.21875  5.625
+        #      5.71875]
+        #    [ 5.       5.40625  6.       6.5      7.       7.59375  8.
+        #      8.09375]
+        #    [ 7.       7.40625  8.       8.5      9.       9.59375 10.
+        #     10.09375]
+        #    [ 9.       9.40625 10.      10.5     11.      11.59375 12.
+        #     12.09375]
+        #    [11.375   11.78125 12.375   12.875   13.375   13.96875 14.375
+        #     14.46875]
+        #    [13.      13.40625 14.      14.5     15.      15.59375 16.
+        #     16.09375]
+        #    [13.375   13.78125 14.375   14.875   15.375   15.96875 16.375
+        #     16.46875]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: cubic_coeffs(x, A=-0.75),
+            scale_factors=scales,
+            coordinate_transformation_mode="asymmetric",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_cubic_asymmetric",
+        )
+
+    @staticmethod
+    def export_resize_tf_crop_and_resize() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "roi", "", "sizes"],
+            outputs=["Y"],
+            mode="linear",
+            coordinate_transformation_mode="tf_crop_and_resize",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        # Note: for some rois, the result may be different with that of TF for inaccurate floating point
+        roi = np.array([0, 0, 0.4, 0.6, 1, 1, 0.6, 0.8], dtype=np.float32)
+        sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+        # [[[[ 7.6000004  7.9        8.2      ]
+        #    [ 8.8        9.1        9.400001 ]
+        #    [10.        10.3       10.6      ]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: linear_coeffs(x),
+            output_size=sizes,
+            roi=roi,
+            coordinate_transformation_mode="tf_crop_and_resize",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, roi, sizes],
+            outputs=[output],
+            name="test_resize_tf_crop_and_resize",
+        )
+
+    @staticmethod
+    def export_resize_tf_crop_and_resize_extrapolation_value() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "roi", "", "sizes"],
+            outputs=["Y"],
+            mode="linear",
+            coordinate_transformation_mode="tf_crop_and_resize",
+            extrapolation_value=10.0,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        # Note: for some rois, the result may be different with that of TF for inaccurate floating point
+        roi = np.array([0, 0, 0.4, 0.6, 1, 1, 1.2, 1.7], dtype=np.float32)
+        sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+        # [[[[ 7.6000004 10.        10.       ]
+        #    [12.400001  10.        10.       ]
+        #    [10.        10.        10.       ]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: linear_coeffs(x),
+            output_size=sizes,
+            roi=roi,
+            coordinate_transformation_mode="tf_crop_and_resize",
+            extrapolation_value=10.0,
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, roi, sizes],
+            outputs=[output],
+            name="test_resize_tf_crop_and_resize_extrapolation_value",
+        )
+
+    @staticmethod
+    def export_resize_downsample_sizes_linear_pytorch_half_pixel() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="linear",
+            coordinate_transformation_mode="pytorch_half_pixel",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 3, 1], dtype=np.int64)
+
+        # [[[[ 1.6666666]
+        #    [ 7.       ]
+        #    [12.333333 ]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: linear_coeffs(x),
+            output_size=sizes,
+            coordinate_transformation_mode="pytorch_half_pixel",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_downsample_sizes_linear_pytorch_half_pixel",
+        )
+
+    @staticmethod
+    def export_resize_upsample_sizes_nearest_floor_align_corners() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+            coordinate_transformation_mode="align_corners",
+            nearest_mode="floor",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 8, 8], dtype=np.int64)
+
+        # [[[[ 1.  1.  1.  2.  2.  3.  3.  4.]
+        #    [ 1.  1.  1.  2.  2.  3.  3.  4.]
+        #    [ 1.  1.  1.  2.  2.  3.  3.  4.]
+        #    [ 5.  5.  5.  6.  6.  7.  7.  8.]
+        #    [ 5.  5.  5.  6.  6.  7.  7.  8.]
+        #    [ 9.  9.  9. 10. 10. 11. 11. 12.]
+        #    [ 9.  9.  9. 10. 10. 11. 11. 12.]
+        #    [13. 13. 13. 14. 14. 15. 15. 16.]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: nearest_coeffs(x, mode="floor"),
+            output_size=sizes,
+            coordinate_transformation_mode="align_corners",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_upsample_sizes_nearest_floor_align_corners",
+        )
+
+    @staticmethod
+    def export_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+            coordinate_transformation_mode="asymmetric",
+            nearest_mode="round_prefer_ceil",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 8, 8], dtype=np.int64)
+
+        # [[[[ 1.  2.  2.  3.  3.  4.  4.  4.]
+        #    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+        #    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+        #    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+        #    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+        #    [13. 14. 14. 15. 15. 16. 16. 16.]
+        #    [13. 14. 14. 15. 15. 16. 16. 16.]
+        #    [13. 14. 14. 15. 15. 16. 16. 16.]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: nearest_coeffs(x, mode="round_prefer_ceil"),
+            output_size=sizes,
+            coordinate_transformation_mode="asymmetric",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric",
+        )
+
+    @staticmethod
+    def export_resize_upsample_sizes_nearest_ceil_half_pixel() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+            coordinate_transformation_mode="half_pixel",
+            nearest_mode="ceil",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 8, 8], dtype=np.int64)
+
+        # [[[[ 1.  2.  2.  3.  3.  4.  4.  4.]
+        #    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+        #    [ 5.  6.  6.  7.  7.  8.  8.  8.]
+        #    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+        #    [ 9. 10. 10. 11. 11. 12. 12. 12.]
+        #    [13. 14. 14. 15. 15. 16. 16. 16.]
+        #    [13. 14. 14. 15. 15. 16. 16. 16.]
+        #    [13. 14. 14. 15. 15. 16. 16. 16.]]]]
+        output = interpolate_nd(
+            data, lambda x, _: nearest_coeffs(x, mode="ceil"), output_size=sizes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_upsample_sizes_nearest_ceil_half_pixel",
+        )
+
+    @staticmethod
+    def export_resize_downsample_scales_linear_antialias() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="linear",
+            antialias=1,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+        # [[[[ 2.875  4.5  ]
+        #    [ 9.375 11.   ]]]]
+        output = interpolate_nd(
+            data, linear_coeffs_antialias, scale_factors=scales
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_downsample_scales_linear_antialias",
+        )
+
+    @staticmethod
+    def export_resize_downsample_sizes_linear_antialias() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="linear",
+            antialias=1,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+        # [[[[ 2.3636363  3.590909   4.818182 ]
+        #    [ 7.2727275  8.5        9.727273 ]
+        #    [12.181818  13.409091  14.636364 ]]]]
+        output = interpolate_nd(
+            data, linear_coeffs_antialias, output_size=sizes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_downsample_sizes_linear_antialias",
+        )
+
+    @staticmethod
+    def export_resize_downsample_scales_cubic_antialias() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="cubic",
+            antialias=1,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
+
+        # [[[[ 2.5180721  4.2858863]
+        #    [ 9.589329  11.357142 ]]]]
+        output = interpolate_nd(
+            data, cubic_coeffs_antialias, scale_factors=scales
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_downsample_scales_cubic_antialias",
+        )
+
+    @staticmethod
+    def export_resize_downsample_sizes_cubic_antialias() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="cubic",
+            antialias=1,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 1, 3, 3], dtype=np.int64)
+
+        # [[[[ 1.7750092  3.1200073  4.4650054]
+        #    [ 7.1550016  8.5        9.844998 ]
+        #    [12.534994  13.8799925 15.224991 ]]]]
+        output = interpolate_nd(data, cubic_coeffs_antialias, output_size=sizes).astype(
+            np.float32
+        )
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_downsample_sizes_cubic_antialias",
+        )
+
+    @staticmethod
+    def export_resize_upsample_scales_nearest_axes_2_3() -> None:
+        axes = [2, 3]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="nearest",
+            axes=axes,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([2.0, 3.0], dtype=np.float32)
+
+        # [[[[1. 1. 1. 2. 2. 2.]
+        #    [1. 1. 1. 2. 2. 2.]
+        #    [3. 3. 3. 4. 4. 4.]
+        #    [3. 3. 3. 4. 4. 4.]]]]
+        output = interpolate_nd(
+            data, lambda x, _: nearest_coeffs(x), scale_factors=scales, axes=axes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_nearest_axes_2_3",
+        )
+
+    @staticmethod
+    def export_resize_upsample_scales_nearest_axes_3_2() -> None:
+        axes = [3, 2]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="nearest",
+            axes=axes,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([3.0, 2.0], dtype=np.float32)
+
+        # [[[[1. 1. 1. 2. 2. 2.]
+        #    [1. 1. 1. 2. 2. 2.]
+        #    [3. 3. 3. 4. 4. 4.]
+        #    [3. 3. 3. 4. 4. 4.]]]]
+        output = interpolate_nd(
+            data, lambda x, _: nearest_coeffs(x), scale_factors=scales, axes=axes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_nearest_axes_3_2",
+        )
+
+    @staticmethod
+    def export_resize_upsample_sizes_nearest_axes_2_3() -> None:
+        axes = [2, 3]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+            axes=axes,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([7, 8], dtype=np.int64)
+
+        # [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+        output = interpolate_nd(
+            data, lambda x, _: nearest_coeffs(x), output_size=sizes, axes=axes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_upsample_sizes_nearest_axes_2_3",
+        )
+
+    @staticmethod
+    def export_resize_upsample_sizes_nearest_axes_3_2() -> None:
+        axes = [3, 2]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+            axes=axes,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([8, 7], dtype=np.int64)
+
+        # [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+        output = interpolate_nd(
+            data, lambda x, _: nearest_coeffs(x), output_size=sizes, axes=axes
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_upsample_sizes_nearest_axes_3_2",
+        )
+
+    @staticmethod
+    def export_resize_tf_crop_and_resize_axes_2_3() -> None:
+        axes = [2, 3]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "roi", "", "sizes"],
+            outputs=["Y"],
+            mode="linear",
+            coordinate_transformation_mode="tf_crop_and_resize",
+            axes=axes,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        # Note: for some rois, the result may be different with that of TF for inaccurate floating point
+        roi = np.array([0.4, 0.6, 0.6, 0.8], dtype=np.float32)
+        sizes = np.array([3, 3], dtype=np.int64)
+
+        # [[[[ 7.6000004  7.9        8.2      ]
+        #    [ 8.8        9.1        9.400001 ]
+        #    [10.        10.3       10.6      ]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: linear_coeffs(x),
+            output_size=sizes,
+            roi=roi,
+            axes=axes,
+            coordinate_transformation_mode="tf_crop_and_resize",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, roi, sizes],
+            outputs=[output],
+            name="test_resize_tf_crop_and_resize_axes_2_3",
+        )
+
+    @staticmethod
+    def export_resize_tf_crop_and_resize_axes_3_2() -> None:
+        axes = [3, 2]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "roi", "", "sizes"],
+            outputs=["Y"],
+            mode="linear",
+            coordinate_transformation_mode="tf_crop_and_resize",
+            axes=axes,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                        [9, 10, 11, 12],
+                        [13, 14, 15, 16],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        # Note: for some rois, the result may be different with that of TF for inaccurate floating point
+        roi = np.array([0.6, 0.4, 0.8, 0.6], dtype=np.float32)
+        sizes = np.array([3, 3], dtype=np.int64)
+
+        # [[[[ 7.6000004  7.9        8.2      ]
+        #    [ 8.8        9.1        9.400001 ]
+        #    [10.        10.3       10.6      ]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: linear_coeffs(x),
+            output_size=sizes,
+            roi=roi,
+            axes=axes,
+            coordinate_transformation_mode="tf_crop_and_resize",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, roi, sizes],
+            outputs=[output],
+            name="test_resize_tf_crop_and_resize_axes_3_2",
+        )
+
+    @staticmethod
+    def export_resize_upsample_sizes_nearest_not_larger() -> None:
+        keep_aspect_ratio_policy = "not_larger"
+        axes = [2, 3]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+            axes=axes,
+            keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([7, 8], dtype=np.int64)  # Results in 7x7
+
+        # [[[[1. 1. 1. 1. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2.]
+        #    [3. 3. 3. 3. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4.]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: nearest_coeffs(x),
+            output_size=sizes,
+            axes=axes,
+            keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_upsample_sizes_nearest_not_larger",
+        )
+
+    @staticmethod
+    def export_resize_upsample_sizes_nearest_not_smaller() -> None:
+        keep_aspect_ratio_policy = "not_smaller"
+        axes = [2, 3]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+            axes=axes,
+            keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([7, 8], dtype=np.int64)  # Results in 8x8
+
+        # [[[[1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [1. 1. 1. 1. 2. 2. 2. 2.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]
+        #    [3. 3. 3. 3. 4. 4. 4. 4.]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: nearest_coeffs(x),
+            output_size=sizes,
+            axes=axes,
+            keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_upsample_sizes_nearest_not_smaller",
+        )
+
+    @staticmethod
+    def export_resize_downsample_sizes_nearest_not_larger() -> None:
+        keep_aspect_ratio_policy = "not_larger"
+        axes = [2, 3]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+            axes=axes,
+            keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 3], dtype=np.int64)  # Results in 1x2
+
+        # [[[[1. 3.]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: nearest_coeffs(x),
+            output_size=sizes,
+            axes=axes,
+            keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_downsample_sizes_nearest_not_larger",
+        )
+
+    @staticmethod
+    def export_resize_downsample_sizes_nearest_not_smaller() -> None:
+        keep_aspect_ratio_policy = "not_smaller"
+        axes = [2, 3]
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "", "sizes"],
+            outputs=["Y"],
+            mode="nearest",
+            axes=axes,
+            keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2, 3, 4],
+                        [5, 6, 7, 8],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        sizes = np.array([1, 3], dtype=np.int64)  # Results in 2x3
+
+        # [[[[1. 2. 4.]
+        #    [5. 6. 8.]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: nearest_coeffs(x),
+            output_size=sizes,
+            axes=axes,
+            keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, sizes],
+            outputs=[output],
+            name="test_resize_downsample_sizes_nearest_not_smaller",
+        )
+
+    @staticmethod
+    def export_resize_downsample_scales_linear_half_pixel_symmetric() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="linear",
+            coordinate_transformation_mode="half_pixel_symmetric",
+        )
+
+        data = np.array([[[[1, 2, 3, 4]]]], dtype=np.float32)
+        scales = np.array([1.0, 1.0, 1.0, 0.6], dtype=np.float32)
+
+        # [[[[1.6666667, 3.3333333]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: linear_coeffs(x),
+            scale_factors=scales,
+            coordinate_transformation_mode="half_pixel_symmetric",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_downsample_scales_linear_half_pixel_symmetric",
+        )
+
+    @staticmethod
+    def export_resize_upsample_scales_linear_half_pixel_symmetric() -> None:
+        node = onnx.helper.make_node(
+            "Resize",
+            inputs=["X", "", "scales"],
+            outputs=["Y"],
+            mode="linear",
+            coordinate_transformation_mode="half_pixel_symmetric",
+        )
+
+        data = np.array([[[[1, 2], [3, 4]]]], dtype=np.float32)
+        scales = np.array([1.0, 1.0, 2.3, 2.94], dtype=np.float32)
+
+        # [[[[1.        , 1.15986395, 1.5       , 1.84013605, 2.        ],
+        #    [1.56521738, 1.72508133, 2.06521738, 2.40535343, 2.56521738],
+        #    [2.43478262, 2.59464657, 2.93478262, 3.27491867, 3.43478262],
+        #    [3.        , 3.15986395, 3.5       , 3.84013605, 4.        ]]]]
+        output = interpolate_nd(
+            data,
+            lambda x, _: linear_coeffs(x),
+            scale_factors=scales,
+            coordinate_transformation_mode="half_pixel_symmetric",
+        ).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_resize_upsample_scales_linear_half_pixel_symmetric",
+        )
diff --git a/onnx/backend/test/case/node/reversesequence.py b/onnx/backend/test/case/node/reversesequence.py
new file mode 100644
index 0000000..b5533cc
--- /dev/null
+++ b/onnx/backend/test/case/node/reversesequence.py
@@ -0,0 +1,86 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ReverseSequence(Base):
+    @staticmethod
+    def export_reversesequence_time() -> None:
+        node = onnx.helper.make_node(
+            "ReverseSequence",
+            inputs=["x", "sequence_lens"],
+            outputs=["y"],
+            time_axis=0,
+            batch_axis=1,
+        )
+        x = np.array(
+            [
+                [0.0, 4.0, 8.0, 12.0],
+                [1.0, 5.0, 9.0, 13.0],
+                [2.0, 6.0, 10.0, 14.0],
+                [3.0, 7.0, 11.0, 15.0],
+            ],
+            dtype=np.float32,
+        )
+        sequence_lens = np.array([4, 3, 2, 1], dtype=np.int64)
+
+        y = np.array(
+            [
+                [3.0, 6.0, 9.0, 12.0],
+                [2.0, 5.0, 8.0, 13.0],
+                [1.0, 4.0, 10.0, 14.0],
+                [0.0, 7.0, 11.0, 15.0],
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[x, sequence_lens],
+            outputs=[y],
+            name="test_reversesequence_time",
+        )
+
+    @staticmethod
+    def export_reversesequence_batch() -> None:
+        node = onnx.helper.make_node(
+            "ReverseSequence",
+            inputs=["x", "sequence_lens"],
+            outputs=["y"],
+            time_axis=1,
+            batch_axis=0,
+        )
+        x = np.array(
+            [
+                [0.0, 1.0, 2.0, 3.0],
+                [4.0, 5.0, 6.0, 7.0],
+                [8.0, 9.0, 10.0, 11.0],
+                [12.0, 13.0, 14.0, 15.0],
+            ],
+            dtype=np.float32,
+        )
+        sequence_lens = np.array([1, 2, 3, 4], dtype=np.int64)
+
+        y = np.array(
+            [
+                [0.0, 1.0, 2.0, 3.0],
+                [5.0, 4.0, 6.0, 7.0],
+                [10.0, 9.0, 8.0, 11.0],
+                [15.0, 14.0, 13.0, 12.0],
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[x, sequence_lens],
+            outputs=[y],
+            name="test_reversesequence_batch",
+        )
diff --git a/onnx/backend/test/case/node/rmsnormalization.py b/onnx/backend/test/case/node/rmsnormalization.py
new file mode 100644
index 0000000..3b24e4c
--- /dev/null
+++ b/onnx/backend/test/case/node/rmsnormalization.py
@@ -0,0 +1,126 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_rms_normalization import _rms_normalization
+
+
+def calculate_normalized_shape(x_shape, axis):
+    rank = len(x_shape)
+    if axis < 0:
+        axis = axis + rank
+    return x_shape[axis:]
+
+
+class RMSNormalization(Base):
+    @staticmethod
+    def export() -> None:
+        X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+        def case(axis: int) -> None:
+            normalized_shape = calculate_normalized_shape(X.shape, axis)
+            W = np.random.randn(*normalized_shape).astype(np.float32)
+            Y = _rms_normalization(X, W, axis=axis)
+
+            node = onnx.helper.make_node(
+                "RMSNormalization",
+                inputs=["X", "W"],
+                outputs=["Y"],
+                axis=axis,
+            )
+
+            if axis < 0:
+                name = f"test_rms_normalization_4d_axis_negative_{-axis}"
+            else:
+                name = f"test_rms_normalization_4d_axis{axis}"
+
+            expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+        for i in range(len(X.shape)):
+            case(i)
+            case(i - len(X.shape))
+
+    @staticmethod
+    def export_default_axis() -> None:
+        X = np.random.randn(2, 3, 4, 5).astype(np.float32)
+
+        # Default axis in RMSNormalization is -1.
+        normalized_shape = calculate_normalized_shape(X.shape, -1)
+        W = np.random.randn(*normalized_shape).astype(np.float32)
+        # Axis is default to -1 in the reference implementation.
+        Y = _rms_normalization(X, W)
+
+        # Not specifying axis attribute means -1.
+        node = onnx.helper.make_node(
+            "RMSNormalization",
+            inputs=["X", "W"],
+            outputs=["Y"],
+        )
+
+        expect(
+            node,
+            inputs=[X, W],
+            outputs=[Y],
+            name="test_rms_normalization_default_axis",
+        )
+
+    @staticmethod
+    def export2d() -> None:
+        X = np.random.randn(3, 4).astype(np.float32)
+
+        def case(axis: int) -> None:
+            normalized_shape = calculate_normalized_shape(X.shape, axis)
+            W = np.random.randn(*normalized_shape).astype(np.float32)
+            Y = _rms_normalization(X, W, axis=axis)
+
+            node = onnx.helper.make_node(
+                "RMSNormalization",
+                inputs=["X", "W"],
+                outputs=["Y"],
+                axis=axis,
+            )
+
+            if axis < 0:
+                name = f"test_rms_normalization_2d_axis_negative_{-axis}"
+            else:
+                name = f"test_rms_normalization_2d_axis{axis}"
+
+            expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+        for i in range(len(X.shape)):
+            case(i)
+            case(i - len(X.shape))
+
+    @staticmethod
+    def export3d_epsilon() -> None:
+        epsilon = 1e-1
+        X = np.random.randn(2, 3, 5).astype(np.float32)
+
+        def case(axis: int) -> None:
+            normalized_shape = calculate_normalized_shape(X.shape, axis)
+            W = np.random.randn(*normalized_shape).astype(np.float32)
+            Y = _rms_normalization(X, W, axis=axis, epsilon=epsilon)
+            node = onnx.helper.make_node(
+                "RMSNormalization",
+                inputs=["X", "W"],
+                outputs=["Y"],
+                axis=axis,
+                epsilon=epsilon,
+            )
+
+            if axis < 0:
+                name = f"test_rms_normalization_3d_axis_negative_{-axis}_epsilon"
+            else:
+                name = f"test_rms_normalization_3d_axis{axis}_epsilon"
+
+            expect(node, inputs=[X, W], outputs=[Y], name=name)
+
+        for i in range(len(X.shape)):
+            case(i)
+            case(i - len(X.shape))
diff --git a/onnx/backend/test/case/node/rnn.py b/onnx/backend/test/case/node/rnn.py
new file mode 100644
index 0000000..1c0dbfe
--- /dev/null
+++ b/onnx/backend/test/case/node/rnn.py
@@ -0,0 +1,220 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class RNNHelper:
+    def __init__(self, **params: Any) -> None:
+        # RNN Input Names
+        X = "X"
+        W = "W"
+        R = "R"
+        B = "B"
+        H_0 = "initial_h"
+        LAYOUT = "layout"
+
+        required_inputs = [X, W, R]
+        for i in required_inputs:
+            assert i in params, f"Missing Required Input: {i}"
+
+        self.num_directions = params[str(W)].shape[0]
+
+        if self.num_directions == 1:
+            for k, v in params.items():
+                if k != X:
+                    params[k] = np.squeeze(v, axis=0)
+
+            hidden_size = params[R].shape[-1]
+            batch_size = params[X].shape[1]
+
+            layout = params.get(LAYOUT, 0)
+            x = params[X]
+            x = x if layout == 0 else np.swapaxes(x, 0, 1)
+            b = (
+                params[B]
+                if B in params
+                else np.zeros(2 * hidden_size, dtype=np.float32)
+            )
+            h_0 = (
+                params[H_0]
+                if H_0 in params
+                else np.zeros((batch_size, hidden_size), dtype=np.float32)
+            )
+
+            self.X = x
+            self.W = params[W]
+            self.R = params[R]
+            self.B = b
+            self.H_0 = h_0
+            self.LAYOUT = layout
+
+        else:
+            raise NotImplementedError
+
+    def f(self, x: np.ndarray) -> np.ndarray:
+        return np.tanh(x)
+
+    def step(self) -> tuple[np.ndarray, np.ndarray]:
+        seq_length = self.X.shape[0]
+        hidden_size = self.H_0.shape[-1]
+        batch_size = self.X.shape[1]
+
+        Y = np.empty([seq_length, self.num_directions, batch_size, hidden_size])
+        h_list = []
+
+        H_t = self.H_0
+        for x in np.split(self.X, self.X.shape[0], axis=0):
+            H = self.f(
+                np.dot(x, np.transpose(self.W))
+                + np.dot(H_t, np.transpose(self.R))
+                + np.add(*np.split(self.B, 2))
+            )
+            h_list.append(H)
+            H_t = H
+
+        concatenated = np.concatenate(h_list)
+        if self.num_directions == 1:
+            Y[:, 0, :, :] = concatenated
+
+        if self.LAYOUT == 0:
+            Y_h = Y[-1]
+        else:
+            Y = np.transpose(Y, [2, 0, 1, 3])
+            Y_h = Y[:, :, -1, :]
+
+        return Y, Y_h
+
+
+class RNN(Base):
+    @staticmethod
+    def export_defaults() -> None:
+        input = np.array([[[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]]).astype(np.float32)
+
+        input_size = 2
+        hidden_size = 4
+        weight_scale = 0.1
+
+        node = onnx.helper.make_node(
+            "RNN", inputs=["X", "W", "R"], outputs=["", "Y_h"], hidden_size=hidden_size
+        )
+
+        W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32)
+        R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32)
+
+        rnn = RNNHelper(X=input, W=W, R=R)
+        _, Y_h = rnn.step()
+        expect(
+            node,
+            inputs=[input, W, R],
+            outputs=[Y_h.astype(np.float32)],
+            name="test_simple_rnn_defaults",
+        )
+
+    @staticmethod
+    def export_initial_bias() -> None:
+        input = np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]).astype(
+            np.float32
+        )
+
+        input_size = 3
+        hidden_size = 5
+        custom_bias = 0.1
+        weight_scale = 0.1
+
+        node = onnx.helper.make_node(
+            "RNN",
+            inputs=["X", "W", "R", "B"],
+            outputs=["", "Y_h"],
+            hidden_size=hidden_size,
+        )
+
+        W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32)
+        R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32)
+
+        # Adding custom bias
+        W_B = custom_bias * np.ones((1, hidden_size)).astype(np.float32)
+        R_B = np.zeros((1, hidden_size)).astype(np.float32)
+        B = np.concatenate((W_B, R_B), axis=1)
+
+        rnn = RNNHelper(X=input, W=W, R=R, B=B)
+        _, Y_h = rnn.step()
+        expect(
+            node,
+            inputs=[input, W, R, B],
+            outputs=[Y_h.astype(np.float32)],
+            name="test_simple_rnn_with_initial_bias",
+        )
+
+    @staticmethod
+    def export_seq_length() -> None:
+        input = np.array(
+            [
+                [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
+                [[10.0, 11.0, 12.0], [13.0, 14.0, 15.0], [16.0, 17.0, 18.0]],
+            ]
+        ).astype(np.float32)
+
+        input_size = 3
+        hidden_size = 5
+
+        node = onnx.helper.make_node(
+            "RNN",
+            inputs=["X", "W", "R", "B"],
+            outputs=["", "Y_h"],
+            hidden_size=hidden_size,
+        )
+
+        W = np.random.randn(1, hidden_size, input_size).astype(np.float32)
+        R = np.random.randn(1, hidden_size, hidden_size).astype(np.float32)
+
+        # Adding custom bias
+        W_B = np.random.randn(1, hidden_size).astype(np.float32)
+        R_B = np.random.randn(1, hidden_size).astype(np.float32)
+        B = np.concatenate((W_B, R_B), axis=1)
+
+        rnn = RNNHelper(X=input, W=W, R=R, B=B)
+        _, Y_h = rnn.step()
+        expect(
+            node,
+            inputs=[input, W, R, B],
+            outputs=[Y_h.astype(np.float32)],
+            name="test_rnn_seq_length",
+        )
+
+    @staticmethod
+    def export_batchwise() -> None:
+        input = np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]]).astype(np.float32)
+
+        input_size = 2
+        hidden_size = 4
+        weight_scale = 0.5
+        layout = 1
+
+        node = onnx.helper.make_node(
+            "RNN",
+            inputs=["X", "W", "R"],
+            outputs=["Y", "Y_h"],
+            hidden_size=hidden_size,
+            layout=layout,
+        )
+
+        W = weight_scale * np.ones((1, hidden_size, input_size)).astype(np.float32)
+        R = weight_scale * np.ones((1, hidden_size, hidden_size)).astype(np.float32)
+
+        rnn = RNNHelper(X=input, W=W, R=R, layout=layout)
+        Y, Y_h = rnn.step()
+        expect(
+            node,
+            inputs=[input, W, R],
+            outputs=[Y.astype(np.float32), Y_h.astype(np.float32)],
+            name="test_simple_rnn_batchwise",
+        )
diff --git a/onnx/backend/test/case/node/roialign.py b/onnx/backend/test/case/node/roialign.py
new file mode 100644
index 0000000..888fa6e
--- /dev/null
+++ b/onnx/backend/test/case/node/roialign.py
@@ -0,0 +1,446 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def get_roi_align_input_values():
+    X = np.array(
+        [
+            [
+                [
+                    [
+                        0.2764,
+                        0.7150,
+                        0.1958,
+                        0.3416,
+                        0.4638,
+                        0.0259,
+                        0.2963,
+                        0.6518,
+                        0.4856,
+                        0.7250,
+                    ],
+                    [
+                        0.9637,
+                        0.0895,
+                        0.2919,
+                        0.6753,
+                        0.0234,
+                        0.6132,
+                        0.8085,
+                        0.5324,
+                        0.8992,
+                        0.4467,
+                    ],
+                    [
+                        0.3265,
+                        0.8479,
+                        0.9698,
+                        0.2471,
+                        0.9336,
+                        0.1878,
+                        0.4766,
+                        0.4308,
+                        0.3400,
+                        0.2162,
+                    ],
+                    [
+                        0.0206,
+                        0.1720,
+                        0.2155,
+                        0.4394,
+                        0.0653,
+                        0.3406,
+                        0.7724,
+                        0.3921,
+                        0.2541,
+                        0.5799,
+                    ],
+                    [
+                        0.4062,
+                        0.2194,
+                        0.4473,
+                        0.4687,
+                        0.7109,
+                        0.9327,
+                        0.9815,
+                        0.6320,
+                        0.1728,
+                        0.6119,
+                    ],
+                    [
+                        0.3097,
+                        0.1283,
+                        0.4984,
+                        0.5068,
+                        0.4279,
+                        0.0173,
+                        0.4388,
+                        0.0430,
+                        0.4671,
+                        0.7119,
+                    ],
+                    [
+                        0.1011,
+                        0.8477,
+                        0.4726,
+                        0.1777,
+                        0.9923,
+                        0.4042,
+                        0.1869,
+                        0.7795,
+                        0.9946,
+                        0.9689,
+                    ],
+                    [
+                        0.1366,
+                        0.3671,
+                        0.7011,
+                        0.6234,
+                        0.9867,
+                        0.5585,
+                        0.6985,
+                        0.5609,
+                        0.8788,
+                        0.9928,
+                    ],
+                    [
+                        0.5697,
+                        0.8511,
+                        0.6711,
+                        0.9406,
+                        0.8751,
+                        0.7496,
+                        0.1650,
+                        0.1049,
+                        0.1559,
+                        0.2514,
+                    ],
+                    [
+                        0.7012,
+                        0.4056,
+                        0.7879,
+                        0.3461,
+                        0.0415,
+                        0.2998,
+                        0.5094,
+                        0.3727,
+                        0.5482,
+                        0.0502,
+                    ],
+                ]
+            ]
+        ],
+        dtype=np.float32,
+    )
+    batch_indices = np.array([0, 0, 0], dtype=np.int64)
+    rois = np.array([[0, 0, 9, 9], [0, 5, 4, 9], [5, 5, 9, 9]], dtype=np.float32)
+    return X, batch_indices, rois
+
+
+class RoiAlign(Base):
+    @staticmethod
+    def export_roialign_aligned_false() -> None:
+        node = onnx.helper.make_node(
+            "RoiAlign",
+            inputs=["X", "rois", "batch_indices"],
+            outputs=["Y"],
+            spatial_scale=1.0,
+            output_height=5,
+            output_width=5,
+            sampling_ratio=2,
+            coordinate_transformation_mode="output_half_pixel",
+        )
+
+        X, batch_indices, rois = get_roi_align_input_values()
+        # (num_rois, C, output_height, output_width)
+        Y = np.array(
+            [
+                [
+                    [
+                        [0.4664, 0.4466, 0.3405, 0.5688, 0.6068],
+                        [0.3714, 0.4296, 0.3835, 0.5562, 0.3510],
+                        [0.2768, 0.4883, 0.5222, 0.5528, 0.4171],
+                        [0.4713, 0.4844, 0.6904, 0.4920, 0.8774],
+                        [0.6239, 0.7125, 0.6289, 0.3355, 0.3495],
+                    ]
+                ],
+                [
+                    [
+                        [0.3022, 0.4305, 0.4696, 0.3978, 0.5423],
+                        [0.3656, 0.7050, 0.5165, 0.3172, 0.7015],
+                        [0.2912, 0.5059, 0.6476, 0.6235, 0.8299],
+                        [0.5916, 0.7389, 0.7048, 0.8372, 0.8893],
+                        [0.6227, 0.6153, 0.7097, 0.6154, 0.4585],
+                    ]
+                ],
+                [
+                    [
+                        [0.2384, 0.3379, 0.3717, 0.6100, 0.7601],
+                        [0.3767, 0.3785, 0.7147, 0.9243, 0.9727],
+                        [0.5749, 0.5826, 0.5709, 0.7619, 0.8770],
+                        [0.5355, 0.2566, 0.2141, 0.2796, 0.3600],
+                        [0.4365, 0.3504, 0.2887, 0.3661, 0.2349],
+                    ]
+                ],
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, rois, batch_indices],
+            outputs=[Y],
+            name="test_roialign_aligned_false",
+        )
+
+    @staticmethod
+    def export_roialign_aligned_true() -> None:
+        node = onnx.helper.make_node(
+            "RoiAlign",
+            inputs=["X", "rois", "batch_indices"],
+            outputs=["Y"],
+            spatial_scale=1.0,
+            output_height=5,
+            output_width=5,
+            sampling_ratio=2,
+            coordinate_transformation_mode="half_pixel",
+        )
+
+        X, batch_indices, rois = get_roi_align_input_values()
+        # (num_rois, C, output_height, output_width)
+        Y = np.array(
+            [
+                [
+                    [
+                        [0.5178, 0.3434, 0.3229, 0.4474, 0.6344],
+                        [0.4031, 0.5366, 0.4428, 0.4861, 0.4023],
+                        [0.2512, 0.4002, 0.5155, 0.6954, 0.3465],
+                        [0.3350, 0.4601, 0.5881, 0.3439, 0.6849],
+                        [0.4932, 0.7141, 0.8217, 0.4719, 0.4039],
+                    ]
+                ],
+                [
+                    [
+                        [0.3070, 0.2187, 0.3337, 0.4880, 0.4870],
+                        [0.1871, 0.4914, 0.5561, 0.4192, 0.3686],
+                        [0.1433, 0.4608, 0.5971, 0.5310, 0.4982],
+                        [0.2788, 0.4386, 0.6022, 0.7000, 0.7524],
+                        [0.5774, 0.7024, 0.7251, 0.7338, 0.8163],
+                    ]
+                ],
+                [
+                    [
+                        [0.2393, 0.4075, 0.3379, 0.2525, 0.4743],
+                        [0.3671, 0.2702, 0.4105, 0.6419, 0.8308],
+                        [0.5556, 0.4543, 0.5564, 0.7502, 0.9300],
+                        [0.6626, 0.5617, 0.4813, 0.4954, 0.6663],
+                        [0.6636, 0.3721, 0.2056, 0.1928, 0.2478],
+                    ]
+                ],
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[X, rois, batch_indices],
+            outputs=[Y],
+            name="test_roialign_aligned_true",
+        )
+
+    @staticmethod
+    def export_roialign_mode_max() -> None:
+        X = np.array(
+            [
+                [
+                    [
+                        [
+                            0.2764,
+                            0.715,
+                            0.1958,
+                            0.3416,
+                            0.4638,
+                            0.0259,
+                            0.2963,
+                            0.6518,
+                            0.4856,
+                            0.725,
+                        ],
+                        [
+                            0.9637,
+                            0.0895,
+                            0.2919,
+                            0.6753,
+                            0.0234,
+                            0.6132,
+                            0.8085,
+                            0.5324,
+                            0.8992,
+                            0.4467,
+                        ],
+                        [
+                            0.3265,
+                            0.8479,
+                            0.9698,
+                            0.2471,
+                            0.9336,
+                            0.1878,
+                            0.4766,
+                            0.4308,
+                            0.34,
+                            0.2162,
+                        ],
+                        [
+                            0.0206,
+                            0.172,
+                            0.2155,
+                            0.4394,
+                            0.0653,
+                            0.3406,
+                            0.7724,
+                            0.3921,
+                            0.2541,
+                            0.5799,
+                        ],
+                        [
+                            0.4062,
+                            0.2194,
+                            0.4473,
+                            0.4687,
+                            0.7109,
+                            0.9327,
+                            0.9815,
+                            0.632,
+                            0.1728,
+                            0.6119,
+                        ],
+                        [
+                            0.3097,
+                            0.1283,
+                            0.4984,
+                            0.5068,
+                            0.4279,
+                            0.0173,
+                            0.4388,
+                            0.043,
+                            0.4671,
+                            0.7119,
+                        ],
+                        [
+                            0.1011,
+                            0.8477,
+                            0.4726,
+                            0.1777,
+                            0.9923,
+                            0.4042,
+                            0.1869,
+                            0.7795,
+                            0.9946,
+                            0.9689,
+                        ],
+                        [
+                            0.1366,
+                            0.3671,
+                            0.7011,
+                            0.6234,
+                            0.9867,
+                            0.5585,
+                            0.6985,
+                            0.5609,
+                            0.8788,
+                            0.9928,
+                        ],
+                        [
+                            0.5697,
+                            0.8511,
+                            0.6711,
+                            0.9406,
+                            0.8751,
+                            0.7496,
+                            0.165,
+                            0.1049,
+                            0.1559,
+                            0.2514,
+                        ],
+                        [
+                            0.7012,
+                            0.4056,
+                            0.7879,
+                            0.3461,
+                            0.0415,
+                            0.2998,
+                            0.5094,
+                            0.3727,
+                            0.5482,
+                            0.0502,
+                        ],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+        rois = np.array(
+            [[0.0, 0.0, 9.0, 9.0], [0.0, 5.0, 4.0, 9.0], [5.0, 5.0, 9.0, 9.0]],
+            dtype=np.float32,
+        )
+        batch_indices = np.array([0, 0, 0], dtype=np.int64)
+
+        Y = np.array(
+            [
+                [
+                    [
+                        [0.3445228, 0.37310338, 0.37865096, 0.446696, 0.37991184],
+                        [0.4133513, 0.5455125, 0.6651902, 0.55805874, 0.27110294],
+                        [0.21223956, 0.40924096, 0.8417618, 0.792561, 0.37196714],
+                        [0.46835402, 0.39741728, 0.8012819, 0.4969306, 0.5495158],
+                        [0.3595896, 0.5196813, 0.5403741, 0.23814403, 0.19992709],
+                    ]
+                ],
+                [
+                    [
+                        [0.30517197, 0.5086199, 0.3189761, 0.4054401, 0.47630402],
+                        [0.50862, 0.8477, 0.37808004, 0.24936005, 0.79384017],
+                        [0.17620805, 0.29368007, 0.44870415, 0.4987201, 0.63148826],
+                        [0.51066005, 0.8511, 0.5368801, 0.9406, 0.70008016],
+                        [0.4487681, 0.51066035, 0.5042561, 0.5643603, 0.42004836],
+                    ]
+                ],
+                [
+                    [
+                        [0.21062402, 0.3510401, 0.37416005, 0.5967599, 0.46507207],
+                        [0.32336006, 0.31180006, 0.6236001, 0.9946, 0.7751202],
+                        [0.35744014, 0.5588001, 0.35897616, 0.7030401, 0.6353923],
+                        [0.5996801, 0.27940005, 0.17948808, 0.35152006, 0.31769615],
+                        [0.3598083, 0.40752012, 0.2385281, 0.43856013, 0.26313624],
+                    ]
+                ],
+            ],
+            dtype=np.float32,
+        )
+
+        node = onnx.helper.make_node(
+            "RoiAlign",
+            inputs=["X", "rois", "batch_indices"],
+            mode="max",
+            outputs=["Y"],
+            spatial_scale=1.0,
+            output_height=5,
+            output_width=5,
+            sampling_ratio=2,
+            coordinate_transformation_mode="output_half_pixel",
+        )
+
+        expect(
+            node,
+            inputs=[X, rois, batch_indices],
+            outputs=[Y],
+            name="test_roialign_mode_max",
+        )
diff --git a/onnx/backend/test/case/node/rotaryembedding.py b/onnx/backend/test/case/node/rotaryembedding.py
new file mode 100644
index 0000000..58f1ec6
--- /dev/null
+++ b/onnx/backend/test/case/node/rotaryembedding.py
@@ -0,0 +1,231 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+from onnx.reference.ops.op_rotary_embedding import rotary_embedding
+
+
+class RotaryEmbedding(Base):
+    @staticmethod
+    def export_rotary_embedding() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+        )
+
+        input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+        position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+        sin_cache_data = np.random.rand(50, 4).astype(np.float32)
+        cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+
+        expected_output = rotary_embedding(
+            input_data, cos_cache_data, sin_cache_data, position_ids=position_ids_data
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_3d_input() -> None:
+        num_heads = 4
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+            num_heads=num_heads,
+        )
+
+        input_data = np.random.rand(2, 3, 32).astype(np.float32)
+        position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+        sin_cache_data = np.random.rand(50, 4).astype(np.float32)
+        cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            position_ids=position_ids_data,
+            num_heads=num_heads,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_3d_input",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_interleaved() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+            interleaved=1,
+        )
+
+        input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+        position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+        sin_cache_data = np.random.rand(50, 4).astype(np.float32)
+        cos_cache_data = np.random.rand(50, 4).astype(np.float32)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            position_ids=position_ids_data,
+            interleaved=1,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_interleaved",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_with_rotary_dim() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+            rotary_embedding_dim=4,
+        )
+
+        input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+        position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+        sin_cache_data = np.random.rand(50, 2).astype(np.float32)
+        cos_cache_data = np.random.rand(50, 2).astype(np.float32)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            position_ids=position_ids_data,
+            rotary_embedding_dim=4,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_with_rotary_dim",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_with_interleaved_rotary_dim() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache", "position_ids"],
+            outputs=["output"],
+            rotary_embedding_dim=4,
+            interleaved=1,
+        )
+
+        input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+        position_ids_data = np.random.uniform(0, 50, (2, 3)).astype(np.int64)
+        sin_cache_data = np.random.rand(50, 2).astype(np.float32)
+        cos_cache_data = np.random.rand(50, 2).astype(np.float32)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            position_ids=position_ids_data,
+            interleaved=1,
+            rotary_embedding_dim=4,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data, position_ids_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_with_interleaved_rotary_dim",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_no_position_ids() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache"],
+            outputs=["output"],
+        )
+
+        input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+        sin_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+        cos_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+
+        expected_output = rotary_embedding(input_data, cos_cache_data, sin_cache_data)
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_no_position_ids",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_no_position_ids_interleaved() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache"],
+            outputs=["output"],
+            interleaved=1,
+        )
+
+        input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+        sin_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+        cos_cache_data = np.random.rand(2, 3, 4).astype(np.float32)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            interleaved=1,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_no_position_ids_interleaved",
+        )
+
+    @staticmethod
+    def export_rotary_embedding_no_position_ids_rotary_dim() -> None:
+        node = onnx.helper.make_node(
+            "RotaryEmbedding",
+            inputs=["input", "cos_cache", "sin_cache"],
+            outputs=["output"],
+            rotary_embedding_dim=4,
+        )
+
+        input_data = np.random.rand(2, 4, 3, 8).astype(np.float32)
+        sin_cache_data = np.random.rand(2, 3, 2).astype(np.float32)
+        cos_cache_data = np.random.rand(2, 3, 2).astype(np.float32)
+
+        expected_output = rotary_embedding(
+            input_data,
+            cos_cache_data,
+            sin_cache_data,
+            rotary_embedding_dim=4,
+        )
+
+        expect(
+            node,
+            inputs=[input_data, cos_cache_data, sin_cache_data],
+            outputs=[expected_output],
+            name="test_rotary_embedding_no_position_ids_rotary_dim",
+        )
diff --git a/onnx/backend/test/case/node/round.py b/onnx/backend/test/case/node/round.py
new file mode 100644
index 0000000..475ca3b
--- /dev/null
+++ b/onnx/backend/test/case/node/round.py
@@ -0,0 +1,62 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Round(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Round",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array(
+            [
+                0.1,
+                0.5,
+                0.9,
+                1.2,
+                1.5,
+                1.8,
+                2.3,
+                2.5,
+                2.7,
+                -1.1,
+                -1.5,
+                -1.9,
+                -2.2,
+                -2.5,
+                -2.8,
+            ]
+        ).astype(np.float32)
+
+        # expected output
+        y = np.array(
+            [
+                0.0,
+                0.0,
+                1.0,
+                1.0,
+                2.0,
+                2.0,
+                2.0,
+                2.0,
+                3.0,
+                -1.0,
+                -2.0,
+                -2.0,
+                -2.0,
+                -2.0,
+                -3.0,
+            ]
+        ).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_round")
diff --git a/onnx/backend/test/case/node/scan.py b/onnx/backend/test/case/node/scan.py
new file mode 100644
index 0000000..36dd44e
--- /dev/null
+++ b/onnx/backend/test/case/node/scan.py
@@ -0,0 +1,155 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+import onnx.parser
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Scan(Base):
+    @staticmethod
+    def export_scan_8() -> None:
+        # Given an input sequence [x1, ..., xN], sum up its elements using a scan
+        # returning the final state (x1+x2+...+xN) as well the scan_output
+        # [x1, x1+x2, ..., x1+x2+...+xN]
+        # Note: the first input (sequence_lens) is optional and omitted via "".
+        node = onnx.parser.parse_node(
+            """
+            y, z = Scan ("", initial, x) <
+                num_scan_inputs = 1,
+                body = scan_body (float[2] sum_in, float[2] next)
+                    => (float[2] sum_out, float[2] scan_out)
+                {
+                    sum_out  = Add(sum_in, next)
+                    scan_out = Identity(sum_out)
+                }
+            >
+            """
+        )
+        # create inputs for batch-size 1, sequence-length 3, inner dimension 2
+        initial = np.array([0, 0]).astype(np.float32).reshape((1, 2))
+        x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((1, 3, 2))
+        # final state computed = [1 + 3 + 5, 2 + 4 + 6]
+        y = np.array([9, 12]).astype(np.float32).reshape((1, 2))
+        # scan-output computed
+        z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((1, 3, 2))
+
+        expect(
+            node,
+            inputs=[initial, x],
+            outputs=[y, z],
+            name="test_scan_sum",
+            opset_imports=[onnx.helper.make_opsetid("", 8)],
+        )
+
+    @staticmethod
+    def export_scan_9() -> None:
+        # Given an input sequence [x1, ..., xN], sum up its elements using a scan
+        # returning the final state (x1+x2+...+xN) as well the scan_output
+        # [x1, x1+x2, ..., x1+x2+...+xN]
+        node = onnx.parser.parse_node(
+            """
+            y, z = Scan (initial, x) <
+                num_scan_inputs = 1,
+                body = scan_body (float[2] sum_in, float[2] next)
+                    => (float[2] sum_out, float[2] scan_out)
+                {
+                    sum_out  = Add(sum_in, next)
+                    scan_out = Identity(sum_out)
+                }
+            >
+            """
+        )
+        # create inputs for sequence-length 3, inner dimension 2
+        initial = np.array([0, 0]).astype(np.float32).reshape((2,))
+        x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((3, 2))
+        # final state computed = [1 + 3 + 5, 2 + 4 + 6]
+        y = np.array([9, 12]).astype(np.float32).reshape((2,))
+        # scan-output computed
+        z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((3, 2))
+
+        expect(
+            node,
+            inputs=[initial, x],
+            outputs=[y, z],
+            name="test_scan9_sum",
+            opset_imports=[onnx.helper.make_opsetid("", 9)],
+        )
+
+    @staticmethod
+    def export_scan_9_multi_state() -> None:
+        # Scan with two state variables: running sum and running product.
+        # This exercises the case where num_loop_state_vars (2) differs from
+        # num_scan_inputs (1).
+        #
+        # Body inputs:  sum_in (state), prod_in (state), next (scan)
+        # Body outputs: sum_out (state), prod_out (state), scan_out (scan)
+        node = onnx.parser.parse_node(
+            """
+            y_sum, y_prod, z = Scan (initial_sum, initial_prod, x) <
+                num_scan_inputs = 1,
+                body = scan_body (float[2] sum_in, float[2] prod_in, float[2] next)
+                    => (float[2] sum_out, float[2] prod_out, float[2] scan_out)
+                {
+                    sum_out  = Add(sum_in, next)
+                    prod_out = Mul(prod_in, next)
+                    scan_out = Identity(sum_out)
+                }
+            >
+            """
+        )
+        # x = [[1, 2], [3, 4], [5, 6]]
+        initial_sum = np.array([0, 0]).astype(np.float32)
+        initial_prod = np.array([1, 1]).astype(np.float32)
+        x = np.array([1, 2, 3, 4, 5, 6]).astype(np.float32).reshape((3, 2))
+        # final sum = [1+3+5, 2+4+6] = [9, 12]
+        y_sum = np.array([9, 12]).astype(np.float32)
+        # final product = [1*3*5, 2*4*6] = [15, 48]
+        y_prod = np.array([15, 48]).astype(np.float32)
+        # scan output (running sum) = [[1,2], [4,6], [9,12]]
+        z = np.array([1, 2, 4, 6, 9, 12]).astype(np.float32).reshape((3, 2))
+
+        expect(
+            node,
+            inputs=[initial_sum, initial_prod, x],
+            outputs=[y_sum, y_prod, z],
+            name="test_scan9_multi_state",
+            opset_imports=[onnx.helper.make_opsetid("", 9)],
+        )
+
+    @staticmethod
+    def export_scan_9_scalar() -> None:
+        # Scan with scalar state and scan output to verify that output
+        # shapes are not distorted (e.g. (T,) not (T, 1)).
+        node = onnx.parser.parse_node(
+            """
+            y, z = Scan (initial, x) <
+                num_scan_inputs = 1,
+                body = scan_body (float sum_in, float next)
+                    => (float sum_out, float scan_out)
+                {
+                    sum_out  = Add(sum_in, next)
+                    scan_out = Identity(sum_out)
+                }
+            >
+            """
+        )
+        initial = np.float32(0.0)
+        x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+        # final state = 1+2+3+4+5 = 15
+        y = np.float32(15.0)
+        # scan output = [1, 3, 6, 10, 15], shape (5,)
+        z = np.array([1, 3, 6, 10, 15]).astype(np.float32)
+
+        expect(
+            node,
+            inputs=[initial, x],
+            outputs=[y, z],
+            name="test_scan9_scalar",
+            opset_imports=[onnx.helper.make_opsetid("", 9)],
+        )
diff --git a/onnx/backend/test/case/node/scatter.py b/onnx/backend/test/case/node/scatter.py
new file mode 100644
index 0000000..b59e608
--- /dev/null
+++ b/onnx/backend/test/case/node/scatter.py
@@ -0,0 +1,109 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+import onnx
+from onnx import helper
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+# The below Scatter's numpy implementation is from https://stackoverflow.com/a/46204790/11767360
+def scatter(
+    data: np.ndarray, indices: np.ndarray, updates: np.ndarray, axis: int = 0
+) -> np.ndarray:
+    if axis < 0:
+        axis = data.ndim + axis
+
+    idx_xsection_shape = indices.shape[:axis] + indices.shape[axis + 1 :]
+
+    def make_slice(arr: np.ndarray, axis: int, i: int) -> list[slice | int]:
+        slc: list[slice | int] = [slice(None)] * arr.ndim
+        slc[axis] = i
+        return slc
+
+    def unpack(packed: Any) -> Any:
+        unpacked = packed[0]
+        for i in range(1, len(packed)):
+            unpacked = unpacked, packed[i]
+        return unpacked
+
+    # We use indices and axis parameters to create idx
+    # idx is in a form that can be used as a NumPy advanced indices for scattering of updates param. in data
+    idx = [
+        [
+            unpack(np.indices(idx_xsection_shape).reshape(indices.ndim - 1, -1)),
+            indices[tuple(make_slice(indices, axis, i))].reshape(1, -1)[0],
+        ]
+        for i in range(indices.shape[axis])
+    ]
+    idx = list(np.concatenate(idx, axis=1))
+    idx.insert(axis, idx.pop())
+
+    # updates_idx is a NumPy advanced indices for indexing of elements in the updates
+    updates_idx = list(idx)
+    updates_idx.pop(axis)
+    updates_idx.insert(
+        axis, np.repeat(np.arange(indices.shape[axis]), np.prod(idx_xsection_shape))
+    )
+
+    scattered = np.copy(data)
+    scattered[tuple(idx)] = updates[tuple(updates_idx)]
+    return scattered
+
+
+class Scatter(Base):
+    @staticmethod
+    def export_scatter_without_axis() -> None:
+        node = onnx.helper.make_node(
+            "Scatter",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+        )
+        data = np.zeros((3, 3), dtype=np.float32)
+        indices = np.array([[1, 0, 2], [0, 2, 1]], dtype=np.int64)
+        updates = np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]], dtype=np.float32)
+
+        y = scatter(data, indices, updates)
+        # print(y) produces
+        # [[2.0, 1.1, 0.0],
+        #  [1.0, 0.0, 2.2],
+        #  [0.0, 2.1, 1.2]]
+
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[y],
+            name="test_scatter_without_axis",
+            opset_imports=[helper.make_opsetid("", 10)],
+        )
+
+    @staticmethod
+    def export_scatter_with_axis() -> None:
+        axis = 1
+        node = onnx.helper.make_node(
+            "Scatter",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            axis=axis,
+        )
+        data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+        indices = np.array([[1, 3]], dtype=np.int64)
+        updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+        y = scatter(data, indices, updates, axis=axis)
+        # print(y) produces
+        # [[1.0, 1.1, 3.0, 2.1, 5.0]]
+
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[y],
+            name="test_scatter_with_axis",
+            opset_imports=[helper.make_opsetid("", 10)],
+        )
diff --git a/onnx/backend/test/case/node/scatterelements.py b/onnx/backend/test/case/node/scatterelements.py
new file mode 100644
index 0000000..f693ccf
--- /dev/null
+++ b/onnx/backend/test/case/node/scatterelements.py
@@ -0,0 +1,266 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+# The below ScatterElements' numpy implementation is from https://stackoverflow.com/a/46204790/11767360
+def scatter_elements(
+    data: np.ndarray,
+    indices: np.ndarray,
+    updates: np.ndarray,
+    axis: int = 0,
+    reduction: str = "none",
+) -> np.ndarray:
+    if axis < 0:
+        axis = data.ndim + axis
+
+    idx_xsection_shape = indices.shape[:axis] + indices.shape[axis + 1 :]
+
+    def make_slice(arr: np.ndarray, axis: int, i: int) -> list[slice | int]:
+        slc: list[slice | int] = [slice(None)] * arr.ndim
+        slc[axis] = i
+        return slc
+
+    def unpack(packed: Any) -> Any:
+        unpacked = packed[0]
+        for i in range(1, len(packed)):
+            unpacked = unpacked, packed[i]
+        return unpacked
+
+    def make_indices_for_duplicate(
+        idx: Sequence[Sequence[Any]],
+    ) -> list[tuple[Any, ...]]:
+        final_idx = []
+        for i in range(len(idx[0])):
+            final_idx.append(  # noqa: PERF401
+                tuple(idx_element[i] for idx_element in idx)
+            )
+        return list(final_idx)
+
+    # We use indices and axis parameters to create idx
+    # idx is in a form that can be used as a NumPy advanced indices for scattering of updates param. in data
+    idx = [
+        [
+            unpack(np.indices(idx_xsection_shape).reshape(indices.ndim - 1, -1)),
+            indices[tuple(make_slice(indices, axis, i))].reshape(1, -1)[0],
+        ]
+        for i in range(indices.shape[axis])
+    ]
+    idx = list(np.concatenate(idx, axis=1))
+    idx.insert(axis, idx.pop())
+
+    # updates_idx is a NumPy advanced indices for indexing of elements in the updates
+    updates_idx = list(idx)
+    updates_idx.pop(axis)
+    updates_idx.insert(
+        axis, np.repeat(np.arange(indices.shape[axis]), np.prod(idx_xsection_shape))
+    )
+
+    scattered = np.copy(data)
+    if reduction == "none":
+        scattered[tuple(idx)] = updates[tuple(updates_idx)]
+    else:
+        idx, updates_idx = (
+            make_indices_for_duplicate(idx),
+            make_indices_for_duplicate(updates_idx),
+        )
+        for iter_, idx_set in enumerate(idx):
+            if reduction == "add":
+                scattered[idx_set] += updates[updates_idx[iter_]]
+            elif reduction == "mul":
+                scattered[idx_set] *= updates[updates_idx[iter_]]
+            elif reduction == "max":
+                scattered[idx_set] = np.maximum(
+                    scattered[idx_set], updates[updates_idx[iter_]]
+                )
+            elif reduction == "min":
+                scattered[idx_set] = np.minimum(
+                    scattered[idx_set], updates[updates_idx[iter_]]
+                )
+    return scattered
+
+
+class ScatterElements(Base):
+    @staticmethod
+    def export_scatter_elements_without_axis() -> None:
+        node = onnx.helper.make_node(
+            "ScatterElements",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+        )
+        data = np.zeros((3, 3), dtype=np.float32)
+        indices = np.array([[1, 0, 2], [0, 2, 1]], dtype=np.int64)
+        updates = np.array([[1.0, 1.1, 1.2], [2.0, 2.1, 2.2]], dtype=np.float32)
+
+        y = scatter_elements(data, indices, updates)
+        # print(y) produces
+        # [[2.0, 1.1, 0.0],
+        #  [1.0, 0.0, 2.2],
+        #  [0.0, 2.1, 1.2]]
+
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[y],
+            name="test_scatter_elements_without_axis",
+        )
+
+    @staticmethod
+    def export_scatter_elements_with_axis() -> None:
+        axis = 1
+        node = onnx.helper.make_node(
+            "ScatterElements",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            axis=axis,
+        )
+        data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+        indices = np.array([[1, 3]], dtype=np.int64)
+        updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+        y = scatter_elements(data, indices, updates, axis)
+        # print(y) produces
+        # [[1.0, 1.1, 3.0, 2.1, 5.0]]
+
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[y],
+            name="test_scatter_elements_with_axis",
+        )
+
+    @staticmethod
+    def export_scatter_elements_with_negative_indices() -> None:
+        axis = 1
+        node = onnx.helper.make_node(
+            "ScatterElements",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            axis=axis,
+        )
+        data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+        indices = np.array([[1, -3]], dtype=np.int64)
+        updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+        y = scatter_elements(data, indices, updates, axis)
+        # print(y) produces
+        # [[1.0, 1.1, 2.1, 4.0, 5.0]]
+
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[y],
+            name="test_scatter_elements_with_negative_indices",
+        )
+
+    @staticmethod
+    def export_scatter_elements_with_duplicate_indices() -> None:
+        axis = 1
+        node = onnx.helper.make_node(
+            "ScatterElements",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            axis=axis,
+            reduction="add",
+        )
+        data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+        indices = np.array([[1, 1]], dtype=np.int64)
+        updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+        y = scatter_elements(data, indices, updates, axis, reduction="add")
+        # print(y) produces
+        # [[1.0, 5.2, 3.0, 4.0, 5.0]]
+
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[y],
+            name="test_scatter_elements_with_duplicate_indices",
+        )
+
+    @staticmethod
+    def export_scatter_elements_with_reduction_mul() -> None:
+        axis = 1
+        node = onnx.helper.make_node(
+            "ScatterElements",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            axis=axis,
+            reduction="mul",
+        )
+        data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+        indices = np.array([[1, 1]], dtype=np.int64)
+        updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+        y = scatter_elements(data, indices, updates, axis, reduction="mul")
+        # print(y) produces
+        # [[1.0, 4.62, 3.0, 4.0, 5.0]]
+
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[y],
+            name="test_scatter_elements_with_reduction_mul",
+        )
+
+    @staticmethod
+    def export_scatter_elements_with_reduction_max() -> None:
+        axis = 1
+        node = onnx.helper.make_node(
+            "ScatterElements",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            axis=axis,
+            reduction="max",
+        )
+        data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+        indices = np.array([[1, 1]], dtype=np.int64)
+        updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+        y = scatter_elements(data, indices, updates, axis, reduction="max")
+        # print(y) produces
+        # [[1.0, 2.1, 3.0, 4.0, 5.0]]
+
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[y],
+            name="test_scatter_elements_with_reduction_max",
+        )
+
+    @staticmethod
+    def export_scatter_elements_with_reduction_min() -> None:
+        axis = 1
+        node = onnx.helper.make_node(
+            "ScatterElements",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            axis=axis,
+            reduction="min",
+        )
+        data = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+        indices = np.array([[1, 1]], dtype=np.int64)
+        updates = np.array([[1.1, 2.1]], dtype=np.float32)
+
+        y = scatter_elements(data, indices, updates, axis, reduction="min")
+        # print(y) produces
+        # [[1.0, 1.1, 3.0, 4.0, 5.0]]
+
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[y],
+            name="test_scatter_elements_with_reduction_min",
+        )
diff --git a/onnx/backend/test/case/node/scatternd.py b/onnx/backend/test/case/node/scatternd.py
new file mode 100644
index 0000000..eb31054
--- /dev/null
+++ b/onnx/backend/test/case/node/scatternd.py
@@ -0,0 +1,271 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def scatter_nd_impl(
+    data: np.ndarray, indices: np.ndarray, updates: np.ndarray, reduction: str = "none"
+) -> np.ndarray:
+    # Check tensor shapes
+    assert indices.shape[-1] <= len(data.shape)
+    assert updates.shape == indices.shape[:-1] + data.shape[indices.shape[-1] :]
+
+    # Compute output
+    output = np.copy(data)
+    for i in np.ndindex(indices.shape[:-1]):
+        # NOTE: The order of iteration in this loop is not specified.
+        if reduction == "add":
+            output[tuple(indices[i])] += updates[i]
+        elif reduction == "mul":
+            output[tuple(indices[i])] *= updates[i]
+        elif reduction == "max":
+            output[tuple(indices[i])] = np.maximum(
+                output[tuple(indices[i])], updates[i]
+            )
+        elif reduction == "min":
+            output[tuple(indices[i])] = np.minimum(
+                output[tuple(indices[i])], updates[i]
+            )
+        else:
+            output[tuple(indices[i])] = updates[i]
+    return output
+
+
+class ScatterND(Base):
+    @staticmethod
+    def export_scatternd() -> None:
+        node = onnx.helper.make_node(
+            "ScatterND",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+        )
+        data = np.array(
+            [
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+            ],
+            dtype=np.float32,
+        )
+        indices = np.array([[0], [2]], dtype=np.int64)
+        updates = np.array(
+            [
+                [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+                [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+            ],
+            dtype=np.float32,
+        )
+        # Expecting output as np.array(
+        #    [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+        #     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        #     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+        #     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+        output = scatter_nd_impl(data, indices, updates)
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[output],
+            name="test_scatternd",
+        )
+
+    @staticmethod
+    def export_scatternd_add() -> None:
+        node = onnx.helper.make_node(
+            "ScatterND",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            reduction="add",
+        )
+        data = np.array(
+            [
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+            ],
+            dtype=np.float32,
+        )
+        indices = np.array([[0], [0]], dtype=np.int64)
+        updates = np.array(
+            [
+                [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+                [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+            ],
+            dtype=np.float32,
+        )
+        # Expecting output as np.array(
+        #    [[[7, 8, 9, 10], [13, 14, 15, 16], [18, 17, 16, 15], [16, 15, 14, 13]],
+        #     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        #     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+        #     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+        output = scatter_nd_impl(data, indices, updates, reduction="add")
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[output],
+            name="test_scatternd_add",
+        )
+
+    @staticmethod
+    def export_scatternd_multiply() -> None:
+        node = onnx.helper.make_node(
+            "ScatterND",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            reduction="mul",
+        )
+        data = np.array(
+            [
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+            ],
+            dtype=np.float32,
+        )
+        indices = np.array([[0], [0]], dtype=np.int64)
+        updates = np.array(
+            [
+                [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+                [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+            ],
+            dtype=np.float32,
+        )
+        # Expecting output as np.array(
+        #    [[[5, 10, 15, 20], [60, 72, 84, 96], [168, 147, 126, 105], [128, 96, 64, 32]],
+        #     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        #     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+        #     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+        output = scatter_nd_impl(data, indices, updates, reduction="mul")
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[output],
+            name="test_scatternd_multiply",
+        )
+
+    @staticmethod
+    def export_scatternd_max() -> None:
+        node = onnx.helper.make_node(
+            "ScatterND",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            reduction="max",
+        )
+        data = np.array(
+            [
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+            ],
+            dtype=np.float32,
+        )
+        indices = np.array([[0], [0]], dtype=np.int64)
+        updates = np.array(
+            [
+                [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+                [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+            ],
+            dtype=np.float32,
+        )
+        # Expecting output as np.array(
+        #    [[[5, 5, 5, 5], [6, 6, 7, 8], [8, 7, 7, 7], [8, 8 ,8, 8]],
+        #     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        #     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+        #     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+        output = scatter_nd_impl(data, indices, updates, reduction="max")
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[output],
+            name="test_scatternd_max",
+        )
+
+    @staticmethod
+    def export_scatternd_min() -> None:
+        node = onnx.helper.make_node(
+            "ScatterND",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            reduction="min",
+        )
+        data = np.array(
+            [
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+                [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+            ],
+            dtype=np.float32,
+        )
+        indices = np.array([[0], [0]], dtype=np.int64)
+        updates = np.array(
+            [
+                [[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+                [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+            ],
+            dtype=np.float32,
+        )
+        # Expecting output as np.array(
+        #    [[[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 3, 2, 1]],
+        #     [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+        #     [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+        #     [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]], dtype=np.float32)
+        output = scatter_nd_impl(data, indices, updates, reduction="min")
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[output],
+            name="test_scatternd_min",
+        )
+
+    @staticmethod
+    def export_scatternd_max_with_element_indices() -> None:
+        node = onnx.helper.make_node(
+            "ScatterND",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            reduction="max",
+        )
+        data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+        # Indices address individual elements (index rank == data rank),
+        # which exercises the reduction at the element level.
+        indices = np.array([[0, 0], [1, 1]], dtype=np.int64)
+        updates = np.array([5, 1], dtype=np.float32)
+        # Expecting output as np.array([[5, 2], [3, 4]], dtype=np.float32)
+        output = scatter_nd_impl(data, indices, updates, reduction="max")
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[output],
+            name="test_scatternd_max_with_element_indices",
+        )
+
+    @staticmethod
+    def export_scatternd_min_with_element_indices() -> None:
+        node = onnx.helper.make_node(
+            "ScatterND",
+            inputs=["data", "indices", "updates"],
+            outputs=["y"],
+            reduction="min",
+        )
+        data = np.array([[1, 2], [3, 4]], dtype=np.float32)
+        indices = np.array([[0, 0], [1, 1]], dtype=np.int64)
+        updates = np.array([5, 1], dtype=np.float32)
+        # Expecting output as np.array([[1, 2], [3, 1]], dtype=np.float32)
+        output = scatter_nd_impl(data, indices, updates, reduction="min")
+        expect(
+            node,
+            inputs=[data, indices, updates],
+            outputs=[output],
+            name="test_scatternd_min_with_element_indices",
+        )
diff --git a/onnx/backend/test/case/node/selu.py b/onnx/backend/test/case/node/selu.py
new file mode 100644
index 0000000..025bd81
--- /dev/null
+++ b/onnx/backend/test/case/node/selu.py
@@ -0,0 +1,49 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Selu(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Selu", inputs=["x"], outputs=["y"], alpha=2.0, gamma=3.0
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        # expected output [-3.79272318, 0., 3.]
+        y = (
+            np.clip(x, 0, np.inf) * 3.0
+            + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 * 3.0
+        )
+        expect(node, inputs=[x], outputs=[y], name="test_selu_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = (
+            np.clip(x, 0, np.inf) * 3.0
+            + (np.exp(np.clip(x, -np.inf, 0)) - 1) * 2.0 * 3.0
+        )
+        expect(node, inputs=[x], outputs=[y], name="test_selu")
+
+    @staticmethod
+    def export_selu_default() -> None:
+        default_alpha = 1.67326319217681884765625
+        default_gamma = 1.05070102214813232421875
+        node = onnx.helper.make_node(
+            "Selu",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = (
+            np.clip(x, 0, np.inf) * default_gamma
+            + (np.exp(np.clip(x, -np.inf, 0)) - 1) * default_alpha * default_gamma
+        )
+        expect(node, inputs=[x], outputs=[y], name="test_selu_default")
diff --git a/onnx/backend/test/case/node/sequence_map.py b/onnx/backend/test/case/node/sequence_map.py
new file mode 100755
index 0000000..4d2ab1c
--- /dev/null
+++ b/onnx/backend/test/case/node/sequence_map.py
@@ -0,0 +1,304 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class SequenceMap(Base):
+    @staticmethod
+    def export_sequence_map_identity_1_sequence():  # type: () -> None
+        body = onnx.helper.make_graph(
+            [onnx.helper.make_node("Identity", ["in0"], ["out0"])],
+            "seq_map_body",
+            [onnx.helper.make_tensor_value_info("in0", onnx.TensorProto.FLOAT, ["N"])],
+            [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["M"])],
+        )
+
+        node = onnx.helper.make_node(
+            "SequenceMap", inputs=["x"], outputs=["y"], body=body
+        )
+
+        x = [np.random.uniform(0.0, 1.0, 10).astype(np.float32) for _ in range(3)]
+        y = x
+        input_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+        ]
+        output_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+        ]
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            input_type_protos=input_type_protos,
+            output_type_protos=output_type_protos,
+            name="test_sequence_map_identity_1_sequence",
+        )
+
+    @staticmethod
+    def export_sequence_map_identity_2_sequences():  # type: () -> None
+        body = onnx.helper.make_graph(
+            [
+                onnx.helper.make_node("Identity", ["in0"], ["out0"]),
+                onnx.helper.make_node("Identity", ["in1"], ["out1"]),
+            ],
+            "seq_map_body",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "in0", onnx.TensorProto.FLOAT, ["N"]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "in1", onnx.TensorProto.FLOAT, ["M"]
+                ),
+            ],
+            [
+                onnx.helper.make_tensor_value_info(
+                    "out0", onnx.TensorProto.FLOAT, ["N"]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "out1", onnx.TensorProto.FLOAT, ["M"]
+                ),
+            ],
+        )
+
+        node = onnx.helper.make_node(
+            "SequenceMap", inputs=["x0", "x1"], outputs=["y0", "y1"], body=body
+        )
+
+        x0 = [
+            np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+            for _ in range(3)
+        ]
+        x1 = [
+            np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+            for _ in range(3)
+        ]
+        y0 = x0
+        y1 = x1
+        input_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"])
+            ),
+        ]
+        output_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"])
+            ),
+        ]
+        expect(
+            node,
+            inputs=[x0, x1],
+            outputs=[y0, y1],
+            input_type_protos=input_type_protos,
+            output_type_protos=output_type_protos,
+            name="test_sequence_map_identity_2_sequences",
+        )
+
+    @staticmethod
+    def export_sequence_map_identity_1_sequence_1_tensor():  # type: () -> None
+        body = onnx.helper.make_graph(
+            [
+                onnx.helper.make_node("Identity", ["in0"], ["out0"]),
+                onnx.helper.make_node("Identity", ["in1"], ["out1"]),
+            ],
+            "seq_map_body",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "in0", onnx.TensorProto.FLOAT, ["N"]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "in1", onnx.TensorProto.FLOAT, ["M"]
+                ),
+            ],
+            [
+                onnx.helper.make_tensor_value_info(
+                    "out0", onnx.TensorProto.FLOAT, ["N"]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "out1", onnx.TensorProto.FLOAT, ["M"]
+                ),
+            ],
+        )
+
+        node = onnx.helper.make_node(
+            "SequenceMap", inputs=["x0", "x1"], outputs=["y0", "y1"], body=body
+        )
+
+        x0 = [
+            np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+            for _ in range(3)
+        ]
+        x1 = np.random.uniform(0.0, 1.0, np.random.randint(1, 10)).astype(np.float32)
+        y0 = x0
+        y1 = [x1 for _ in range(3)]
+        input_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+            onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"]),
+        ]
+        output_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["M"])
+            ),
+        ]
+        expect(
+            node,
+            inputs=[x0, x1],
+            outputs=[y0, y1],
+            input_type_protos=input_type_protos,
+            output_type_protos=output_type_protos,
+            name="test_sequence_map_identity_1_sequence_1_tensor",
+        )
+
+    @staticmethod
+    def export_sequence_map_add_2_sequences():  # type: () -> None
+        body = onnx.helper.make_graph(
+            [onnx.helper.make_node("Add", ["in0", "in1"], ["out0"])],
+            "seq_map_body",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "in0", onnx.TensorProto.FLOAT, ["N"]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "in1", onnx.TensorProto.FLOAT, ["N"]
+                ),
+            ],
+            [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["N"])],
+        )
+
+        node = onnx.helper.make_node(
+            "SequenceMap", inputs=["x0", "x1"], outputs=["y0"], body=body
+        )
+
+        N = [np.random.randint(1, 10) for _ in range(3)]
+        x0 = [np.random.uniform(0.0, 1.0, N[k]).astype(np.float32) for k in range(3)]
+        x1 = [np.random.uniform(0.0, 1.0, N[k]).astype(np.float32) for k in range(3)]
+        y0 = [x0[k] + x1[k] for k in range(3)]
+        input_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+        ]
+        output_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+        ]
+        expect(
+            node,
+            inputs=[x0, x1],
+            outputs=[y0],
+            input_type_protos=input_type_protos,
+            output_type_protos=output_type_protos,
+            name="test_sequence_map_add_2_sequences",
+        )
+
+    @staticmethod
+    def export_sequence_map_add_1_sequence_1_tensor():  # type: () -> None
+        body = onnx.helper.make_graph(
+            [onnx.helper.make_node("Add", ["in0", "in1"], ["out0"])],
+            "seq_map_body",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "in0", onnx.TensorProto.FLOAT, ["N"]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "in1", onnx.TensorProto.FLOAT, ["N"]
+                ),
+            ],
+            [onnx.helper.make_tensor_value_info("out0", onnx.TensorProto.FLOAT, ["N"])],
+        )
+
+        node = onnx.helper.make_node(
+            "SequenceMap", inputs=["x0", "x1"], outputs=["y0"], body=body
+        )
+
+        x0 = [np.random.uniform(0.0, 1.0, 10).astype(np.float32) for k in range(3)]
+        x1 = np.random.uniform(0.0, 1.0, 10).astype(np.float32)
+        y0 = [x0[i] + x1 for i in range(3)]
+        input_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+            onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"]),
+        ]
+        output_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.FLOAT, ["N"])
+            ),
+        ]
+        expect(
+            node,
+            inputs=[x0, x1],
+            outputs=[y0],
+            input_type_protos=input_type_protos,
+            output_type_protos=output_type_protos,
+            name="test_sequence_map_add_1_sequence_1_tensor",
+        )
+
+    @staticmethod
+    def export_sequence_map_extract_shapes():  # type: () -> None
+        body = onnx.helper.make_graph(
+            [onnx.helper.make_node("Shape", ["x"], ["shape"])],
+            "seq_map_body",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "x", onnx.TensorProto.FLOAT, ["H", "W", "C"]
+                )
+            ],
+            [onnx.helper.make_tensor_value_info("shape", onnx.TensorProto.INT64, [3])],
+        )
+
+        node = onnx.helper.make_node(
+            "SequenceMap", inputs=["in_seq"], outputs=["shapes"], body=body
+        )
+
+        shapes = [
+            np.array([40, 30, 3], dtype=np.int64),
+            np.array([20, 10, 3], dtype=np.int64),
+            np.array([10, 5, 3], dtype=np.int64),
+        ]
+        x0 = [np.zeros(shape, dtype=np.float32) for shape in shapes]
+        input_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(
+                    onnx.TensorProto.FLOAT, ["H", "W", "C"]
+                )
+            ),
+        ]
+        output_type_protos = [
+            onnx.helper.make_sequence_type_proto(
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.INT64, [3])
+            ),
+        ]
+        expect(
+            node,
+            inputs=[x0],
+            outputs=[shapes],
+            input_type_protos=input_type_protos,
+            output_type_protos=output_type_protos,
+            name="test_sequence_map_extract_shapes",
+        )
diff --git a/onnx/backend/test/case/node/sequenceinsert.py b/onnx/backend/test/case/node/sequenceinsert.py
new file mode 100644
index 0000000..b8b80b3
--- /dev/null
+++ b/onnx/backend/test/case/node/sequenceinsert.py
@@ -0,0 +1,75 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def sequence_insert_reference_implementation(
+    sequence: list[Any], tensor: np.ndarray, position: np.ndarray = None
+) -> list[Any]:
+    # make a copy of input sequence
+    seq = list(sequence)
+    if position is not None:
+        # In these cases, insert_position will be between [-len(sequence), len(sequence)]
+        # The position argument will be in the format np.array([pos_index])
+        insert_position = position[0]
+        seq.insert(insert_position, tensor)
+    else:
+        # Default position of insertion is at the end of the sequence.
+        seq.append(tensor)
+    return seq
+
+
+class SequenceInsert(Base):
+    @staticmethod
+    def export() -> None:
+        test_cases = {
+            "at_back": [np.array([10, 11, 12]).astype(np.int64)],
+            "at_front": [np.array([-2, -1, 0]), np.array([0]).astype(np.int64)],
+        }
+        sequence = [
+            np.array([1, 2, 3, 4]).astype(np.int64),
+            np.array([5, 6, 7]).astype(np.int64),
+            np.array([8, 9]).astype(np.int64),
+        ]
+
+        for test_name, test_inputs in test_cases.items():
+            tensor = test_inputs[0].astype(np.int64)
+
+            if len(test_inputs) > 1:
+                node = onnx.helper.make_node(
+                    "SequenceInsert",
+                    inputs=["sequence", "tensor", "position"],
+                    outputs=["output_sequence"],
+                )
+                position = test_inputs[1]
+                inserted = sequence_insert_reference_implementation(
+                    sequence, tensor, position
+                )
+                expect(
+                    node,
+                    inputs=[sequence, tensor, position],
+                    outputs=[inserted],
+                    name="test_sequence_insert_" + test_name,
+                )
+            else:
+                node = onnx.helper.make_node(
+                    "SequenceInsert",
+                    inputs=["sequence", "tensor"],
+                    outputs=["output_sequence"],
+                )
+                inserted = sequence_insert_reference_implementation(sequence, tensor)
+                expect(
+                    node,
+                    inputs=[sequence, tensor],
+                    outputs=[inserted],
+                    name="test_sequence_insert_" + test_name,
+                )
diff --git a/onnx/backend/test/case/node/shape.py b/onnx/backend/test/case/node/shape.py
new file mode 100644
index 0000000..8238214
--- /dev/null
+++ b/onnx/backend/test/case/node/shape.py
@@ -0,0 +1,64 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+# Reference implementation of shape op
+def shape_reference_impl(
+    x: np.ndarray, start: int | None = None, end: int | None = None
+) -> np.ndarray:
+    dims = x.shape[start:end]
+    return np.array(dims).astype(np.int64)
+
+
+def test_shape(
+    testname: str, xval: np.ndarray, start: int | None = None, end: int | None = None
+) -> None:
+    node = onnx.helper.make_node(
+        "Shape", inputs=["x"], outputs=["y"], start=start, end=end
+    )
+
+    yval = shape_reference_impl(xval, start, end)
+
+    expect(node, inputs=[xval], outputs=[yval], name="test_shape" + testname)
+
+
+class Shape(Base):
+    @staticmethod
+    def export() -> None:
+        x = np.array(
+            [
+                [1, 2, 3],
+                [4, 5, 6],
+            ]
+        ).astype(np.float32)
+        test_shape("_example", x)  # preserve names of original test cases
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+
+        test_shape("", x)  # preserve names of original test cases
+
+        test_shape("_start_1", x, start=1)
+
+        test_shape("_end_1", x, end=1)
+
+        test_shape("_start_negative_1", x, start=-1)
+
+        test_shape("_end_negative_1", x, end=-1)
+
+        test_shape("_start_1_end_negative_1", x, start=1, end=-1)
+
+        test_shape("_start_1_end_2", x, start=1, end=2)
+
+        test_shape("_clip_start", x, start=-10)
+
+        test_shape("_clip_end", x, end=10)
+
+        test_shape("_start_greater_than_end", x, start=2, end=1)
diff --git a/onnx/backend/test/case/node/shrink.py b/onnx/backend/test/case/node/shrink.py
new file mode 100644
index 0000000..d800eba
--- /dev/null
+++ b/onnx/backend/test/case/node/shrink.py
@@ -0,0 +1,37 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Shrink(Base):
+    @staticmethod
+    def export_hard_shrink() -> None:
+        node = onnx.helper.make_node(
+            "Shrink",
+            inputs=["x"],
+            outputs=["y"],
+            lambd=1.5,
+        )
+        X = np.arange(-2.0, 2.1, dtype=np.float32)
+        Y = np.array([-2, 0, 0, 0, 2], dtype=np.float32)
+        expect(node, inputs=[X], outputs=[Y], name="test_shrink_hard")
+
+    @staticmethod
+    def export_soft_shrink() -> None:
+        node = onnx.helper.make_node(
+            "Shrink",
+            inputs=["x"],
+            outputs=["y"],
+            lambd=1.5,
+            bias=1.5,
+        )
+        X = np.arange(-2.0, 2.1, dtype=np.float32)
+        Y = np.array([-0.5, 0, 0, 0, 0.5], dtype=np.float32)
+        expect(node, inputs=[X], outputs=[Y], name="test_shrink_soft")
diff --git a/onnx/backend/test/case/node/sigmoid.py b/onnx/backend/test/case/node/sigmoid.py
new file mode 100644
index 0000000..33e503e
--- /dev/null
+++ b/onnx/backend/test/case/node/sigmoid.py
@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Sigmoid(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Sigmoid",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = 1.0 / (
+            1.0 + np.exp(np.negative(x))
+        )  # expected output [0.26894143, 0.5, 0.7310586]
+        expect(node, inputs=[x], outputs=[y], name="test_sigmoid_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = 1.0 / (1.0 + np.exp(np.negative(x)))
+        expect(node, inputs=[x], outputs=[y], name="test_sigmoid")
diff --git a/onnx/backend/test/case/node/sign.py b/onnx/backend/test/case/node/sign.py
new file mode 100644
index 0000000..965345d
--- /dev/null
+++ b/onnx/backend/test/case/node/sign.py
@@ -0,0 +1,24 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Sign(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Sign",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array(range(-5, 6)).astype(np.float32)
+        y = np.sign(x)
+        expect(node, inputs=[x], outputs=[y], name="test_sign")
diff --git a/onnx/backend/test/case/node/sin.py b/onnx/backend/test/case/node/sin.py
new file mode 100644
index 0000000..9f2ea24
--- /dev/null
+++ b/onnx/backend/test/case/node/sin.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Sin(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Sin",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.sin(x)
+        expect(node, inputs=[x], outputs=[y], name="test_sin_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.sin(x)
+        expect(node, inputs=[x], outputs=[y], name="test_sin")
diff --git a/onnx/backend/test/case/node/sinh.py b/onnx/backend/test/case/node/sinh.py
new file mode 100644
index 0000000..a5d97cd
--- /dev/null
+++ b/onnx/backend/test/case/node/sinh.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Sinh(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Sinh",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.sinh(x)  # expected output [-1.17520118,  0.,  1.17520118]
+        expect(node, inputs=[x], outputs=[y], name="test_sinh_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.sinh(x)
+        expect(node, inputs=[x], outputs=[y], name="test_sinh")
diff --git a/onnx/backend/test/case/node/size.py b/onnx/backend/test/case/node/size.py
new file mode 100644
index 0000000..37acd51
--- /dev/null
+++ b/onnx/backend/test/case/node/size.py
@@ -0,0 +1,35 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Size(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Size",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array(
+            [
+                [1, 2, 3],
+                [4, 5, 6],
+            ]
+        ).astype(np.float32)
+        y = np.array(6).astype(np.int64)
+
+        expect(node, inputs=[x], outputs=[y], name="test_size_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.array(x.size).astype(np.int64)
+
+        expect(node, inputs=[x], outputs=[y], name="test_size")
diff --git a/onnx/backend/test/case/node/slice.py b/onnx/backend/test/case/node/slice.py
new file mode 100644
index 0000000..5d4cb43
--- /dev/null
+++ b/onnx/backend/test/case/node/slice.py
@@ -0,0 +1,178 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Slice(Base):
+    @staticmethod
+    def export_slice() -> None:
+        node = onnx.helper.make_node(
+            "Slice",
+            inputs=["x", "starts", "ends", "axes", "steps"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(20, 10, 5).astype(np.float32)
+        y = x[0:3, 0:10]
+        starts = np.array([0, 0], dtype=np.int64)
+        ends = np.array([3, 10], dtype=np.int64)
+        axes = np.array([0, 1], dtype=np.int64)
+        steps = np.array([1, 1], dtype=np.int64)
+
+        expect(
+            node, inputs=[x, starts, ends, axes, steps], outputs=[y], name="test_slice"
+        )
+
+    @staticmethod
+    def export_slice_neg() -> None:
+        node = onnx.helper.make_node(
+            "Slice",
+            inputs=["x", "starts", "ends", "axes", "steps"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(20, 10, 5).astype(np.float32)
+        starts = np.array([0], dtype=np.int64)
+        ends = np.array([-1], dtype=np.int64)
+        axes = np.array([1], dtype=np.int64)
+        steps = np.array([1], dtype=np.int64)
+        y = x[:, 0:-1]
+
+        expect(
+            node,
+            inputs=[x, starts, ends, axes, steps],
+            outputs=[y],
+            name="test_slice_neg",
+        )
+
+    @staticmethod
+    def export_slice_start_out_of_bounds() -> None:
+        node = onnx.helper.make_node(
+            "Slice",
+            inputs=["x", "starts", "ends", "axes", "steps"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(20, 10, 5).astype(np.float32)
+        starts = np.array([1000], dtype=np.int64)
+        ends = np.array([1000], dtype=np.int64)
+        axes = np.array([1], dtype=np.int64)
+        steps = np.array([1], dtype=np.int64)
+        y = x[:, 1000:1000]
+
+        expect(
+            node,
+            inputs=[x, starts, ends, axes, steps],
+            outputs=[y],
+            name="test_slice_start_out_of_bounds",
+        )
+
+    @staticmethod
+    def export_slice_end_out_of_bounds() -> None:
+        node = onnx.helper.make_node(
+            "Slice",
+            inputs=["x", "starts", "ends", "axes", "steps"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(20, 10, 5).astype(np.float32)
+        starts = np.array([1], dtype=np.int64)
+        ends = np.array([1000], dtype=np.int64)
+        axes = np.array([1], dtype=np.int64)
+        steps = np.array([1], dtype=np.int64)
+        y = x[:, 1:1000]
+
+        expect(
+            node,
+            inputs=[x, starts, ends, axes, steps],
+            outputs=[y],
+            name="test_slice_end_out_of_bounds",
+        )
+
+    @staticmethod
+    def export_slice_default_axes() -> None:
+        node = onnx.helper.make_node(
+            "Slice",
+            inputs=["x", "starts", "ends"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(20, 10, 5).astype(np.float32)
+        starts = np.array([0, 0, 3], dtype=np.int64)
+        ends = np.array([20, 10, 4], dtype=np.int64)
+        y = x[:, :, 3:4]
+
+        expect(
+            node, inputs=[x, starts, ends], outputs=[y], name="test_slice_default_axes"
+        )
+
+    @staticmethod
+    def export_slice_default_steps() -> None:
+        node = onnx.helper.make_node(
+            "Slice",
+            inputs=["x", "starts", "ends", "axes"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(20, 10, 5).astype(np.float32)
+        starts = np.array([0, 0, 3], dtype=np.int64)
+        ends = np.array([20, 10, 4], dtype=np.int64)
+        axes = np.array([0, 1, 2], dtype=np.int64)
+        y = x[:, :, 3:4]
+
+        expect(
+            node,
+            inputs=[x, starts, ends, axes],
+            outputs=[y],
+            name="test_slice_default_steps",
+        )
+
+    @staticmethod
+    def export_slice_neg_steps() -> None:
+        node = onnx.helper.make_node(
+            "Slice",
+            inputs=["x", "starts", "ends", "axes", "steps"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(20, 10, 5).astype(np.float32)
+        starts = np.array([20, 10, 4], dtype=np.int64)
+        ends = np.array([0, 0, 1], dtype=np.int64)
+        axes = np.array([0, 1, 2], dtype=np.int64)
+        steps = np.array([-1, -3, -2]).astype(np.int64)
+        y = x[20:0:-1, 10:0:-3, 4:1:-2]
+
+        expect(
+            node,
+            inputs=[x, starts, ends, axes, steps],
+            outputs=[y],
+            name="test_slice_neg_steps",
+        )
+
+    @staticmethod
+    def export_slice_negative_axes() -> None:
+        node = onnx.helper.make_node(
+            "Slice",
+            inputs=["x", "starts", "ends", "axes"],
+            outputs=["y"],
+        )
+
+        x = np.random.randn(20, 10, 5).astype(np.float32)
+        starts = np.array([0, 0, 3], dtype=np.int64)
+        ends = np.array([20, 10, 4], dtype=np.int64)
+        axes = np.array([0, -2, -1], dtype=np.int64)
+        y = x[:, :, 3:4]
+
+        expect(
+            node,
+            inputs=[x, starts, ends, axes],
+            outputs=[y],
+            name="test_slice_negative_axes",
+        )
diff --git a/onnx/backend/test/case/node/softmax.py b/onnx/backend/test/case/node/softmax.py
new file mode 100644
index 0000000..ae45f40
--- /dev/null
+++ b/onnx/backend/test/case/node/softmax.py
@@ -0,0 +1,91 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def softmax(x: np.ndarray, axis: int = -1) -> np.ndarray:
+    x_max = np.max(x, axis=axis, keepdims=True)
+    tmp = np.exp(x - x_max)
+    s = np.sum(tmp, axis=axis, keepdims=True)
+    return tmp / s
+
+
+class Softmax(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Softmax",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        x = np.array([[-1, 0, 1]]).astype(np.float32)
+        # expected output [[0.09003058, 0.24472848, 0.66524094]]
+        y = softmax(x, axis=1)
+        expect(node, inputs=[x], outputs=[y], name="test_softmax_example")
+
+    @staticmethod
+    def export_softmax_axis() -> None:
+        x = np.array([[0, 1, 2, 3], [10000, 10001, 10002, 10003]]).astype(np.float32)
+        # expected output
+        # [[0.032058604 0.08714432  0.23688284  0.6439143  ]
+        # [0.032058604 0.08714432  0.23688284  0.6439143  ]]
+        y = softmax(x)
+
+        node = onnx.helper.make_node(
+            "Softmax",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        expect(node, inputs=[x], outputs=[y], name="test_softmax_large_number")
+
+        x = np.abs(np.random.randn(3, 4, 5).astype(np.float32))
+        node = onnx.helper.make_node(
+            "Softmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=0,
+        )
+        y = softmax(x, axis=0)
+        expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_0")
+
+        node = onnx.helper.make_node(
+            "Softmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=1,
+        )
+        y = softmax(x, axis=1)
+        expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_1")
+
+        node = onnx.helper.make_node(
+            "Softmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=2,
+        )
+        y = softmax(x, axis=2)
+        expect(node, inputs=[x], outputs=[y], name="test_softmax_axis_2")
+
+        node = onnx.helper.make_node(
+            "Softmax",
+            inputs=["x"],
+            outputs=["y"],
+            axis=-1,
+        )
+        y = softmax(x, axis=-1)
+        expect(node, inputs=[x], outputs=[y], name="test_softmax_negative_axis")
+
+        # default axis is -1
+        node = onnx.helper.make_node(
+            "Softmax",
+            inputs=["x"],
+            outputs=["y"],
+        )
+        expect(node, inputs=[x], outputs=[y], name="test_softmax_default_axis")
diff --git a/onnx/backend/test/case/node/softmaxcrossentropy.py b/onnx/backend/test/case/node/softmaxcrossentropy.py
new file mode 100644
index 0000000..dc6f886
--- /dev/null
+++ b/onnx/backend/test/case/node/softmaxcrossentropy.py
@@ -0,0 +1,1158 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def softmaxcrossentropy(
+    x: np.ndarray,
+    target: np.ndarray,
+    weight: np.ndarray | None = None,
+    reduction: str = "mean",
+    ignore_index: int | None = None,
+    get_log_prob: bool | None = None,
+) -> Any:
+    input_shape = x.shape
+    if len(input_shape) == 1:
+        raise RuntimeError("Unsupported shape")
+
+    target_shape = target.shape
+    N = input_shape[0]
+    C = input_shape[1]
+
+    # compute log_softmax
+    max_x = np.max(x, axis=1, keepdims=True)
+    exp_x = np.exp(x - max_x)
+    p = exp_x / np.sum(exp_x, axis=1, keepdims=True)
+    inp = np.log(p)
+    log_prob = None
+    if get_log_prob is True:
+        log_prob = np.copy(inp)
+
+    # initialize the positional weights when required
+    gather_weight = None
+    if weight is not None:
+        # setting mode='clip' to deal with ignore_index > C or < 0 cases.
+        # when the target value is > C or < 0, it doesn't matter which value we are
+        # taking in gather_weight, since it will be set to 0 in the following if-block
+        # use np.int32 to make it compatible with x86 machines
+        gather_weight = np.take(weight, np.array(target, dtype=np.int32), mode="clip")
+        # set `ignore_index`'s loss weight to 0.
+        # The loss tensor will be multiplied by this weight tensor,
+        # so `ignore_index`'s loss value will be eliminated.
+        if ignore_index is not None:
+            gather_weight = np.where(target == ignore_index, 0, gather_weight).astype(
+                dtype=np.float32
+            )
+    elif ignore_index is not None:
+        gather_weight = np.where(target == ignore_index, 0, 1).astype(dtype=np.float32)
+
+    # if input is 4-d and above, make it 3-d
+    if len(input_shape) != 3:
+        inp = inp.reshape((N, C, -1))
+        target = target.reshape((N, -1))
+
+    # Get a dimension from the reshaped input.
+    # If the original input shape is [N, C, H, W],
+    # the D here should be H * W because we reshape
+    # [N, C, H, W] to [N, C, H * W].
+    D = inp.shape[2]
+    neg_gather_element_input = np.zeros((N, D), dtype=np.float32)
+    for i in range(N):
+        for d in range(D):
+            if target[i][d] != ignore_index:
+                neg_gather_element_input[i][d] = -inp[i][target[i][d]][d]
+
+    loss = neg_gather_element_input
+
+    # if the input was 4-d or above reshape to the right shape
+    if len(input_shape) != 3:
+        loss = loss.reshape(target_shape)
+
+    # apply the weights when required
+    if gather_weight is not None:
+        loss = gather_weight * loss
+        if reduction == "mean":
+            loss = loss.sum() / gather_weight.sum()
+            if get_log_prob is True:
+                return loss, log_prob
+            return loss
+
+    if reduction == "mean":
+        loss = np.mean(loss)
+    elif reduction == "sum":
+        loss = np.sum(loss)
+
+    if get_log_prob:
+        return loss, log_prob
+    return loss
+
+
+class SoftmaxCrossEntropyLoss(Base):
+    @staticmethod
+    def export_softmaxcrossentropy_none() -> None:
+        # Define operator attributes.
+        reduction = "none"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, labels, reduction="none")
+
+        # Check results
+        expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_none")
+
+    @staticmethod
+    def export_softmaxcrossentropy_none_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "none"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, reduction="none", get_log_prob=True
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[loss, log_prob],
+            name="test_sce_none_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_none_weights() -> None:
+        # Define operator attributes.
+        reduction = "none"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+        weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, labels, weight=weights, reduction="none")
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[sce],
+            name="test_sce_none_weights",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_none_weights_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "none"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+        weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, weight=weights, reduction="none", get_log_prob=True
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[loss, log_prob],
+            name="test_sce_none_weights_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_sum() -> None:
+        # Define operator attributes.
+        reduction = "sum"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, labels, reduction="sum")
+
+        # Check results
+        expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_sum")
+
+    @staticmethod
+    def export_softmaxcrossentropy_sum_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "sum"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, reduction="sum", get_log_prob=True
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[loss, log_prob],
+            name="test_sce_sum_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, labels)
+
+        # Check results
+        expect(node, inputs=[x, labels], outputs=[sce], name="test_sce_mean")
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(x, labels, get_log_prob=True)
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[loss, log_prob],
+            name="test_sce_mean_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_3d() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2).astype(np.float32)
+        y = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, y)
+
+        # Check results
+        expect(node, inputs=[x, y], outputs=[sce], name="test_sce_mean_3d")
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_3d_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2).astype(np.float32)
+        y = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(x, y, get_log_prob=True)
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, y],
+            outputs=[loss, log_prob],
+            name="test_sce_mean_3d_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_weights() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+        weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, labels, weight=weights)
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[sce],
+            name="test_sce_mean_weight",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_weights_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+        weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, weight=weights, get_log_prob=True
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[loss, log_prob],
+            name="test_sce_mean_weight_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_weights_ii() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(0)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+        labels[0] = np.int64(0)
+        weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, labels, weight=weights, ignore_index=ignore_index)
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[sce],
+            name="test_sce_mean_weight_ii",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_weights_ii_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(0)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+        labels[0] = np.int64(0)
+        weights = np.array([0.9, 0.7, 0.8, 0.9, 0.9], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, weight=weights, ignore_index=ignore_index, get_log_prob=True
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[loss, log_prob],
+            name="test_sce_mean_weight_ii_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_no_weights_ii() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(2)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+        labels[0] = np.int64(2)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, labels, ignore_index=ignore_index)
+
+        # Check results
+        expect(
+            node, inputs=[x, labels], outputs=[sce], name="test_sce_mean_no_weight_ii"
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_no_weights_ii_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(2)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3,)).astype(np.int64)
+        labels[0] = np.int64(2)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, ignore_index=ignore_index, get_log_prob=True
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[loss, log_prob],
+            name="test_sce_mean_no_weight_ii_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_weights_ii_3d() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(1)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+        labels[0][0] = np.int64(1)
+        weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, labels, weight=weights, ignore_index=ignore_index)
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[sce],
+            name="test_sce_mean_weight_ii_3d",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_weights_ii_3d_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(1)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+        labels[0][0] = np.int64(1)
+        weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, weight=weights, ignore_index=ignore_index, get_log_prob=True
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[loss, log_prob],
+            name="test_sce_mean_weight_ii_3d_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_no_weights_ii_3d() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(2)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+        labels[0][0] = np.int64(2)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(x, labels, ignore_index=ignore_index)
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[sce],
+            name="test_sce_mean_no_weight_ii_3d",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_no_weights_ii_3d_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(2)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3, 2)).astype(np.int64)
+        labels[0][0] = np.int64(2)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, ignore_index=ignore_index, get_log_prob=True
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[loss, log_prob],
+            name="test_sce_mean_no_weight_ii_3d_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_weights_ii_4d() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(2)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+        labels[0][0][0] = np.int64(2)
+        weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(
+            x, labels, reduction=reduction, weight=weights, ignore_index=ignore_index
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[sce],
+            name="test_sce_mean_weight_ii_4d",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_weights_ii_4d_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(2)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+        labels[0][0][0] = np.int64(2)
+        weights = np.array([0.2, 0.3, 0.6, 0.1, 0.5], dtype=np.float32)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x,
+            labels,
+            reduction=reduction,
+            weight=weights,
+            ignore_index=ignore_index,
+            get_log_prob=True,
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels, weights],
+            outputs=[loss, log_prob],
+            name="test_sce_mean_weight_ii_4d_log_prob",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_no_weights_ii_4d() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(2)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+        labels[0][0][0] = np.int64(2)
+
+        # Compute SoftmaxCrossEntropyLoss
+        sce = softmaxcrossentropy(
+            x, labels, reduction=reduction, ignore_index=ignore_index
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[sce],
+            name="test_sce_mean_no_weight_ii_4d",
+        )
+
+    @staticmethod
+    def export_softmaxcrossentropy_mean_no_weights_ii_4d_log_prob() -> None:
+        # Define operator attributes.
+        reduction = "mean"
+        ignore_index = np.int64(2)
+
+        # Create operator.
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        # Define operator inputs.
+        np.random.seed(0)
+        x = np.random.rand(3, 5, 2, 7).astype(np.float32)
+        labels = np.random.randint(0, high=5, size=(3, 2, 7)).astype(np.int64)
+        labels[0][0][0] = np.int64(2)
+
+        # Compute SoftmaxCrossEntropyLoss
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, reduction=reduction, ignore_index=ignore_index, get_log_prob=True
+        )
+
+        # Check results
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[loss, log_prob],
+            name="test_sce_mean_no_weight_ii_4d_log_prob",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3d4d5_mean_weight() -> None:
+        reduction = "mean"
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+        np.random.seed(0)
+        x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+        labels = np.random.randint(
+            0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+        ).astype(np.int64)
+        weight = np.random.rand(C).astype(np.float32)
+
+        sce = softmaxcrossentropy(x, labels, weight=weight, reduction=reduction)
+
+        expect(
+            node,
+            inputs=[x, labels, weight],
+            outputs=[sce],
+            name="test_sce_NCd1d2d3d4d5_mean_weight",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3d4d5_mean_weight_log_prob() -> None:
+        reduction = "mean"
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+        np.random.seed(0)
+        x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+        labels = np.random.randint(
+            0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+        ).astype(np.int64)
+        weight = np.random.rand(C).astype(np.float32)
+
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, weight=weight, reduction=reduction, get_log_prob=True
+        )
+
+        expect(
+            node,
+            inputs=[x, labels, weight],
+            outputs=[loss, log_prob],
+            name="test_sce_NCd1d2d3d4d5_mean_weight_log_prob",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3d4d5_none_no_weight() -> None:
+        reduction = "none"
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+        np.random.seed(0)
+        x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+        labels = np.random.randint(
+            0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+        ).astype(np.int64)
+
+        sce = softmaxcrossentropy(x, labels, reduction=reduction)
+
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[sce],
+            name="test_sce_NCd1d2d3d4d5_none_no_weight",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3d4d5_none_no_weight_log_prob() -> None:
+        reduction = "none"
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+        )
+
+        N, C, dim1, dim2, dim3, dim4, dim5 = 3, 5, 6, 6, 5, 3, 4
+        np.random.seed(0)
+        x = np.random.rand(N, C, dim1, dim2, dim3, dim4, dim5).astype(np.float32)
+        labels = np.random.randint(
+            0, high=C, size=(N, dim1, dim2, dim3, dim4, dim5)
+        ).astype(np.int64)
+
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, reduction=reduction, get_log_prob=True
+        )
+
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[loss, log_prob],
+            name="test_sce_NCd1d2d3d4d5_none_no_weight_log_prob",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1_mean_weight_negative_ii() -> None:
+        reduction = "mean"
+        ignore_index = np.int64(-1)
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, dim1 = 3, 5, 6
+        np.random.seed(0)
+        x = np.random.rand(N, C, dim1).astype(np.float32)
+        labels = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64)
+        labels[0][0] = -1
+        weight = np.random.rand(C).astype(np.float32)
+
+        sce = softmaxcrossentropy(
+            x, labels, weight=weight, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[x, labels, weight],
+            outputs=[sce],
+            name="test_sce_NCd1_mean_weight_negative_ii",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1_mean_weight_negative_ii_log_prob() -> None:
+        reduction = "mean"
+        ignore_index = np.int64(-1)
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, dim1 = 3, 5, 6
+        np.random.seed(0)
+        x = np.random.rand(N, C, dim1).astype(np.float32)
+        labels = np.random.randint(0, high=C, size=(N, dim1)).astype(np.int64)
+        labels[0][0] = -1
+        weight = np.random.rand(C).astype(np.float32)
+
+        loss, log_prob = softmaxcrossentropy(
+            x,
+            labels,
+            weight=weight,
+            reduction=reduction,
+            ignore_index=ignore_index,
+            get_log_prob=True,
+        )
+
+        expect(
+            node,
+            inputs=[x, labels, weight],
+            outputs=[loss, log_prob],
+            name="test_sce_NCd1_mean_weight_negative_ii_log_prob",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3_none_no_weight_negative_ii() -> None:
+        reduction = "none"
+        ignore_index = np.int64(-5)
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5
+        np.random.seed(0)
+        x = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32)
+        labels = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype(
+            np.int64
+        )
+        labels[0][0][0][0] = -5
+
+        sce = softmaxcrossentropy(
+            x, labels, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[sce],
+            name="test_sce_NCd1d2d3_none_no_weight_negative_ii",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3_none_no_weight_negative_ii_log_prob() -> None:
+        reduction = "none"
+        ignore_index = np.int64(-5)
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C, dim1, dim2, dim3 = 3, 5, 6, 6, 5
+        np.random.seed(0)
+        x = np.random.rand(N, C, dim1, dim2, dim3).astype(np.float32)
+        labels = np.random.randint(0, high=C, size=(N, dim1, dim2, dim3)).astype(
+            np.int64
+        )
+        labels[0][0][0][0] = -5
+
+        loss, log_prob = softmaxcrossentropy(
+            x, labels, reduction=reduction, ignore_index=ignore_index, get_log_prob=True
+        )
+
+        expect(
+            node,
+            inputs=[x, labels],
+            outputs=[loss, log_prob],
+            name="test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3_sum_weight_high_ii() -> None:
+        reduction = "sum"
+        ignore_index = np.int64(10)
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C = 3, 5
+        np.random.seed(0)
+        x = np.random.rand(N, C).astype(np.float32)
+        labels = np.random.randint(0, high=C, size=(N)).astype(np.int64)
+        labels[0] = 10
+        weight = np.random.rand(C).astype(np.float32)
+
+        sce = softmaxcrossentropy(
+            x, labels, weight=weight, reduction=reduction, ignore_index=ignore_index
+        )
+
+        expect(
+            node,
+            inputs=[x, labels, weight],
+            outputs=[sce],
+            name="test_sce_NCd1d2d3_sum_weight_high_ii",
+        )
+
+    @staticmethod
+    def export_input_shape_is_NCd1d2d3_sum_weight_high_ii_log_prob() -> None:
+        reduction = "sum"
+        ignore_index = np.int64(10)
+
+        node = onnx.helper.make_node(
+            "SoftmaxCrossEntropyLoss",
+            inputs=["x", "y", "w"],
+            outputs=["z", "log_prob"],
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
+
+        N, C = 3, 5
+        np.random.seed(0)
+        x = np.random.rand(N, C).astype(np.float32)
+        labels = np.random.randint(0, high=C, size=(N)).astype(np.int64)
+        labels[0] = 10
+        weight = np.random.rand(C).astype(np.float32)
+
+        loss, log_prob = softmaxcrossentropy(
+            x,
+            labels,
+            weight=weight,
+            reduction=reduction,
+            ignore_index=ignore_index,
+            get_log_prob=True,
+        )
+
+        expect(
+            node,
+            inputs=[x, labels, weight],
+            outputs=[loss, log_prob],
+            name="test_sce_NCd1d2d3_sum_weight_high_ii_log_prob",
+        )
diff --git a/onnx/backend/test/case/node/softplus.py b/onnx/backend/test/case/node/softplus.py
new file mode 100644
index 0000000..503a653
--- /dev/null
+++ b/onnx/backend/test/case/node/softplus.py
@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Softplus(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Softplus",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.log(
+            np.exp(x) + 1
+        )  # expected output [0.31326166, 0.69314718, 1.31326163]
+        expect(node, inputs=[x], outputs=[y], name="test_softplus_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.log(np.exp(x) + 1)
+        expect(node, inputs=[x], outputs=[y], name="test_softplus")
diff --git a/onnx/backend/test/case/node/softsign.py b/onnx/backend/test/case/node/softsign.py
new file mode 100644
index 0000000..476f55d
--- /dev/null
+++ b/onnx/backend/test/case/node/softsign.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Softsign(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Softsign",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.array([-0.5, 0, 0.5]).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_softsign_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = x / (1 + np.abs(x))
+        expect(node, inputs=[x], outputs=[y], name="test_softsign")
diff --git a/onnx/backend/test/case/node/spacetodepth.py b/onnx/backend/test/case/node/spacetodepth.py
new file mode 100644
index 0000000..157a6d3
--- /dev/null
+++ b/onnx/backend/test/case/node/spacetodepth.py
@@ -0,0 +1,66 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class SpaceToDepth(Base):
+    @staticmethod
+    def export() -> None:
+        b, c, h, w = shape = (2, 2, 6, 6)
+        blocksize = 2
+        node = onnx.helper.make_node(
+            "SpaceToDepth",
+            inputs=["x"],
+            outputs=["y"],
+            blocksize=blocksize,
+        )
+        x = np.random.random_sample(shape).astype(np.float32)
+        tmp = np.reshape(
+            x, [b, c, h // blocksize, blocksize, w // blocksize, blocksize]
+        )
+        tmp = np.transpose(tmp, [0, 3, 5, 1, 2, 4])
+        y = np.reshape(tmp, [b, c * (blocksize**2), h // blocksize, w // blocksize])
+        expect(node, inputs=[x], outputs=[y], name="test_spacetodepth")
+
+    @staticmethod
+    def export_example() -> None:
+        node = onnx.helper.make_node(
+            "SpaceToDepth",
+            inputs=["x"],
+            outputs=["y"],
+            blocksize=2,
+        )
+
+        # (1, 1, 4, 6) input tensor
+        x = np.array(
+            [
+                [
+                    [
+                        [0, 6, 1, 7, 2, 8],
+                        [12, 18, 13, 19, 14, 20],
+                        [3, 9, 4, 10, 5, 11],
+                        [15, 21, 16, 22, 17, 23],
+                    ]
+                ]
+            ]
+        ).astype(np.float32)
+
+        # (1, 4, 2, 3) output tensor
+        y = np.array(
+            [
+                [
+                    [[0, 1, 2], [3, 4, 5]],
+                    [[6, 7, 8], [9, 10, 11]],
+                    [[12, 13, 14], [15, 16, 17]],
+                    [[18, 19, 20], [21, 22, 23]],
+                ]
+            ]
+        ).astype(np.float32)
+        expect(node, inputs=[x], outputs=[y], name="test_spacetodepth_example")
diff --git a/onnx/backend/test/case/node/split.py b/onnx/backend/test/case/node/split.py
new file mode 100644
index 0000000..f93d7cb
--- /dev/null
+++ b/onnx/backend/test/case/node/split.py
@@ -0,0 +1,378 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Split(Base):
+    @staticmethod
+    def export_1d_opset13() -> None:
+        node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input"],
+            outputs=["output_1", "output_2", "output_3"],
+            axis=0,
+        )
+
+        expected_outputs = [
+            np.array([1.0, 2.0]).astype(np.float32),
+            np.array([3.0, 4.0]).astype(np.float32),
+            np.array([5.0, 6.0]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input],
+            outputs=expected_outputs,
+            name="test_split_equal_parts_1d_opset13",
+            opset_imports=[onnx.helper.make_opsetid("", 13)],
+        )
+
+        split = np.array([2, 4]).astype(np.int64)
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input", "split"],
+            outputs=["output_1", "output_2"],
+            axis=0,
+        )
+
+        expected_outputs = [
+            np.array([1.0, 2.0]).astype(np.float32),
+            np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input, split],
+            outputs=expected_outputs,
+            name="test_split_variable_parts_1d_opset13",
+            opset_imports=[onnx.helper.make_opsetid("", 13)],
+        )
+
+    @staticmethod
+    def export_2d_opset13() -> None:
+        node_input = np.array(
+            [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Split", inputs=["input"], outputs=["output_1", "output_2"], axis=1
+        )
+
+        expected_outputs = [
+            np.array([[1.0, 2.0, 3.0], [7.0, 8.0, 9.0]]).astype(np.float32),
+            np.array([[4.0, 5.0, 6.0], [10.0, 11.0, 12.0]]).astype(np.float32),
+        ]
+
+        expect(
+            node,
+            inputs=[node_input],
+            outputs=expected_outputs,
+            name="test_split_equal_parts_2d_opset13",
+            opset_imports=[onnx.helper.make_opsetid("", 13)],
+        )
+
+        split = np.array([2, 4]).astype(np.int64)
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input", "split"],
+            outputs=["output_1", "output_2"],
+            axis=1,
+        )
+
+        expected_outputs = [
+            np.array([[1.0, 2.0], [7.0, 8.0]]).astype(np.float32),
+            np.array([[3.0, 4.0, 5.0, 6.0], [9.0, 10.0, 11.0, 12.0]]).astype(
+                np.float32
+            ),
+        ]
+
+        expect(
+            node,
+            inputs=[node_input, split],
+            outputs=expected_outputs,
+            name="test_split_variable_parts_2d_opset13",
+            opset_imports=[onnx.helper.make_opsetid("", 13)],
+        )
+
+    @staticmethod
+    def export_default_values_opset13() -> None:
+        node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+        # If axis is not specified, split is applied on default axis 0
+        node = onnx.helper.make_node(
+            "Split", inputs=["input"], outputs=["output_1", "output_2", "output_3"]
+        )
+
+        expected_outputs = [
+            np.array([1.0, 2.0]).astype(np.float32),
+            np.array([3.0, 4.0]).astype(np.float32),
+            np.array([5.0, 6.0]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input],
+            outputs=expected_outputs,
+            name="test_split_equal_parts_default_axis_opset13",
+            opset_imports=[onnx.helper.make_opsetid("", 13)],
+        )
+
+        split = np.array([2, 4]).astype(np.int64)
+        node = onnx.helper.make_node(
+            "Split", inputs=["input", "split"], outputs=["output_1", "output_2"]
+        )
+
+        expected_outputs = [
+            np.array([1.0, 2.0]).astype(np.float32),
+            np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input, split],
+            outputs=expected_outputs,
+            name="test_split_variable_parts_default_axis_opset13",
+            opset_imports=[onnx.helper.make_opsetid("", 13)],
+        )
+
+    @staticmethod
+    def export_zero_size_splits_opset13() -> None:
+        # 1-dimensional tensor with dimension_size=0
+        node_input = np.array([]).astype(np.float32)
+
+        # Split empty tensor to tensors of size zero
+        split = np.array([0, 0, 0]).astype(np.int64)
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input", "split"],
+            outputs=["output_1", "output_2", "output_3"],
+        )
+
+        expected_outputs = [
+            np.array([]).astype(np.float32),
+            np.array([]).astype(np.float32),
+            np.array([]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input, split],
+            outputs=expected_outputs,
+            name="test_split_zero_size_splits_opset13",
+            opset_imports=[onnx.helper.make_opsetid("", 13)],
+        )
+
+    @staticmethod
+    def export_1d_opset18() -> None:
+        node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input"],
+            outputs=["output_1", "output_2", "output_3"],
+            axis=0,
+            num_outputs=3,
+        )
+
+        expected_outputs = [
+            np.array([1.0, 2.0]).astype(np.float32),
+            np.array([3.0, 4.0]).astype(np.float32),
+            np.array([5.0, 6.0]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input],
+            outputs=expected_outputs,
+            name="test_split_equal_parts_1d_opset18",
+        )
+
+        split = np.array([2, 4]).astype(np.int64)
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input", "split"],
+            outputs=["output_1", "output_2"],
+            axis=0,
+        )
+
+        expected_outputs = [
+            np.array([1.0, 2.0]).astype(np.float32),
+            np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input, split],
+            outputs=expected_outputs,
+            name="test_split_variable_parts_1d_opset18",
+        )
+
+    @staticmethod
+    def export_2d_opset18() -> None:
+        node_input = np.array(
+            [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0, 11.0, 12.0]]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input"],
+            outputs=["output_1", "output_2"],
+            axis=1,
+            num_outputs=2,
+        )
+
+        expected_outputs = [
+            np.array([[1.0, 2.0, 3.0], [7.0, 8.0, 9.0]]).astype(np.float32),
+            np.array([[4.0, 5.0, 6.0], [10.0, 11.0, 12.0]]).astype(np.float32),
+        ]
+
+        expect(
+            node,
+            inputs=[node_input],
+            outputs=expected_outputs,
+            name="test_split_equal_parts_2d",
+        )
+
+        split = np.array([2, 4]).astype(np.int64)
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input", "split"],
+            outputs=["output_1", "output_2"],
+            axis=1,
+        )
+
+        expected_outputs = [
+            np.array([[1.0, 2.0], [7.0, 8.0]]).astype(np.float32),
+            np.array([[3.0, 4.0, 5.0, 6.0], [9.0, 10.0, 11.0, 12.0]]).astype(
+                np.float32
+            ),
+        ]
+
+        expect(
+            node,
+            inputs=[node_input, split],
+            outputs=expected_outputs,
+            name="test_split_variable_parts_2d_opset18",
+        )
+
+    @staticmethod
+    def export_default_values_opset18() -> None:
+        node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).astype(np.float32)
+
+        # If axis is not specified, split is applied on default axis 0
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input"],
+            outputs=["output_1", "output_2", "output_3"],
+            num_outputs=3,
+        )
+
+        expected_outputs = [
+            np.array([1.0, 2.0]).astype(np.float32),
+            np.array([3.0, 4.0]).astype(np.float32),
+            np.array([5.0, 6.0]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input],
+            outputs=expected_outputs,
+            name="test_split_equal_parts_default_axis_opset18",
+        )
+
+        split = np.array([2, 4]).astype(np.int64)
+        node = onnx.helper.make_node(
+            "Split", inputs=["input", "split"], outputs=["output_1", "output_2"]
+        )
+
+        expected_outputs = [
+            np.array([1.0, 2.0]).astype(np.float32),
+            np.array([3.0, 4.0, 5.0, 6.0]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input, split],
+            outputs=expected_outputs,
+            name="test_split_variable_parts_default_axis_opset18",
+        )
+
+    @staticmethod
+    def export_zero_size_splits_opset18() -> None:
+        # 1-dimensional tensor with dimension_size=0
+        node_input = np.array([]).astype(np.float32)
+
+        # Split empty tensor to tensors of size zero
+        split = np.array([0, 0, 0]).astype(np.int64)
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input", "split"],
+            outputs=["output_1", "output_2", "output_3"],
+        )
+
+        expected_outputs = [
+            np.array([]).astype(np.float32),
+            np.array([]).astype(np.float32),
+            np.array([]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input, split],
+            outputs=expected_outputs,
+            name="test_split_zero_size_splits_opset18",
+        )
+
+    @staticmethod
+    def export_1d_uneven_split_opset18() -> None:
+        node_input = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]).astype(np.float32)
+
+        # If axis is not specified, split is applied on default axis 0
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input"],
+            outputs=["output_1", "output_2", "output_3", "output_4"],
+            num_outputs=4,
+        )
+
+        expected_outputs = [
+            np.array([1.0, 2.0]).astype(np.float32),
+            np.array([3.0, 4.0]).astype(np.float32),
+            np.array([5.0, 6.0]).astype(np.float32),
+            np.array([7.0]).astype(np.float32),
+        ]
+        expect(
+            node,
+            inputs=[node_input],
+            outputs=expected_outputs,
+            name="test_split_1d_uneven_split_opset18",
+        )
+
+    @staticmethod
+    def export_2d_uneven_split_opset18() -> None:
+        node_input = np.array(
+            [
+                [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
+                [9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0],
+            ]
+        ).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Split",
+            inputs=["input"],
+            outputs=["output_1", "output_2", "output_3"],
+            axis=1,
+            num_outputs=3,
+        )
+
+        expected_outputs = [
+            np.array([[1.0, 2.0, 3.0], [9.0, 10.0, 11.0]]).astype(np.float32),
+            np.array([[4.0, 5.0, 6.0], [12.0, 13.0, 14.0]]).astype(np.float32),
+            np.array([[7.0, 8.0], [15.0, 16.0]]).astype(np.float32),
+        ]
+
+        expect(
+            node,
+            inputs=[node_input],
+            outputs=expected_outputs,
+            name="test_split_2d_uneven_split_opset18",
+        )
diff --git a/onnx/backend/test/case/node/splittosequence.py b/onnx/backend/test/case/node/splittosequence.py
new file mode 100644
index 0000000..0ee6e60
--- /dev/null
+++ b/onnx/backend/test/case/node/splittosequence.py
@@ -0,0 +1,80 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class SplitToSequence(Base):
+    @staticmethod
+    def export_with_split_1() -> None:
+        data = np.arange(18).reshape((3, 6)).astype(np.float32)
+        split = np.array(2, dtype=np.int64)
+
+        node = onnx.helper.make_node(
+            "SplitToSequence", ["data", "split"], ["seq"], axis=1
+        )
+
+        expected_outputs = [
+            [
+                np.array([[0.0, 1.0], [6.0, 7.0], [12.0, 13.0]], dtype=np.float32),
+                np.array([[2.0, 3.0], [8.0, 9.0], [14.0, 15.0]], dtype=np.float32),
+                np.array([[4.0, 5.0], [10.0, 11.0], [16.0, 17.0]], dtype=np.float32),
+            ]
+        ]
+
+        expect(
+            node,
+            inputs=[data, split],
+            outputs=expected_outputs,
+            name="test_split_to_sequence_1",
+        )
+
+    @staticmethod
+    def export_with_split_2() -> None:
+        data = np.arange(18).reshape((3, 6)).astype(np.float32)
+        split = np.array([1, 2], dtype=np.int64)
+
+        node = onnx.helper.make_node(
+            "SplitToSequence", ["data", "split"], ["seq"], axis=0
+        )
+
+        expected_outputs = [
+            [
+                data[:1],
+                data[1:],
+            ]
+        ]
+
+        expect(
+            node,
+            inputs=[data, split],
+            outputs=expected_outputs,
+            name="test_split_to_sequence_2",
+        )
+
+    @staticmethod
+    def export_nokeepdims() -> None:
+        data = np.arange(18).reshape((3, 6)).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "SplitToSequence",
+            ["data"],
+            ["seq"],
+            axis=1,
+            keepdims=0,
+        )
+
+        expected_outputs = [[data[:, i] for i in range(data.shape[1])]]
+
+        expect(
+            node,
+            inputs=[data],
+            outputs=expected_outputs,
+            name="test_split_to_sequence_nokeepdims",
+        )
diff --git a/onnx/backend/test/case/node/sqrt.py b/onnx/backend/test/case/node/sqrt.py
new file mode 100644
index 0000000..6469a59
--- /dev/null
+++ b/onnx/backend/test/case/node/sqrt.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Sqrt(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Sqrt",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([1, 4, 9]).astype(np.float32)
+        y = np.sqrt(x)  # expected output [1., 2., 3.]
+        expect(node, inputs=[x], outputs=[y], name="test_sqrt_example")
+
+        x = np.abs(np.random.randn(3, 4, 5).astype(np.float32))
+        y = np.sqrt(x)
+        expect(node, inputs=[x], outputs=[y], name="test_sqrt")
diff --git a/onnx/backend/test/case/node/squeeze.py b/onnx/backend/test/case/node/squeeze.py
new file mode 100644
index 0000000..c6fe8ed
--- /dev/null
+++ b/onnx/backend/test/case/node/squeeze.py
@@ -0,0 +1,37 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Squeeze(Base):
+    @staticmethod
+    def export_squeeze() -> None:
+        node = onnx.helper.make_node(
+            "Squeeze",
+            inputs=["x", "axes"],
+            outputs=["y"],
+        )
+        x = np.random.randn(1, 3, 4, 5).astype(np.float32)
+        axes = np.array([0], dtype=np.int64)
+        y = np.squeeze(x, axis=0)
+
+        expect(node, inputs=[x, axes], outputs=[y], name="test_squeeze")
+
+    @staticmethod
+    def export_squeeze_negative_axes() -> None:
+        node = onnx.helper.make_node(
+            "Squeeze",
+            inputs=["x", "axes"],
+            outputs=["y"],
+        )
+        x = np.random.randn(1, 3, 1, 5).astype(np.float32)
+        axes = np.array([-2], dtype=np.int64)
+        y = np.squeeze(x, axis=-2)
+        expect(node, inputs=[x, axes], outputs=[y], name="test_squeeze_negative_axes")
diff --git a/onnx/backend/test/case/node/stft.py b/onnx/backend/test/case/node/stft.py
new file mode 100644
index 0000000..106366c
--- /dev/null
+++ b/onnx/backend/test/case/node/stft.py
@@ -0,0 +1,70 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class STFT(Base):
+    @staticmethod
+    def export() -> None:
+        signal = np.arange(0, 128, dtype=np.float32).reshape(1, 128, 1)
+        length = np.array(16).astype(np.int64)
+        onesided_length = (length >> 1) + 1
+        step = np.array(8).astype(np.int64)
+
+        no_window = ""  # optional input, not supplied
+        node = onnx.helper.make_node(
+            "STFT",
+            inputs=["signal", "frame_step", no_window, "frame_length"],
+            outputs=["output"],
+        )
+
+        nstfts = ((signal.shape[1] - length) // step) + 1
+        # [batch_size][frames][frame_length][2]
+        output = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32)
+        for i in range(nstfts):
+            start = i * step
+            stop = i * step + length
+            complex_out = np.fft.fft(signal[0, start:stop, 0])[0:onesided_length]
+            output[0, i] = np.stack((complex_out.real, complex_out.imag), axis=1)
+
+        output = output.astype(signal.dtype)
+        expect(node, inputs=[signal, step, length], outputs=[output], name="test_stft")
+
+        node = onnx.helper.make_node(
+            "STFT",
+            inputs=["signal", "frame_step", "window"],
+            outputs=["output"],
+        )
+
+        # Test with window
+        a0 = 0.5
+        a1 = 0.5
+        window = a0 + a1 * np.cos(
+            2 * np.pi * np.arange(0, length, 1, dtype=np.float32) / length
+        )
+        nstfts = 1 + (signal.shape[1] - window.shape[0]) // step
+
+        # [batch_size][frames][frame_length][2]
+        output = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32)
+        for i in range(nstfts):
+            start = i * step
+            stop = i * step + length
+            complex_out = np.fft.fft(signal[0, start:stop, 0] * window)[
+                0:onesided_length
+            ]
+            output[0, i] = np.stack((complex_out.real, complex_out.imag), axis=1)
+        window = window.astype(signal.dtype)
+        output = output.astype(signal.dtype)
+        expect(
+            node,
+            inputs=[signal, step, window],
+            outputs=[output],
+            name="test_stft_with_window",
+        )
diff --git a/onnx/backend/test/case/node/string_concat.py b/onnx/backend/test/case/node/string_concat.py
new file mode 100644
index 0000000..23c78d0
--- /dev/null
+++ b/onnx/backend/test/case/node/string_concat.py
@@ -0,0 +1,69 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class StringConcat(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "StringConcat",
+            inputs=["x", "y"],
+            outputs=["result"],
+        )
+        x = np.array(["abc", "def"]).astype("object")
+        y = np.array([".com", ".net"]).astype("object")
+        result = np.array(["abc.com", "def.net"]).astype("object")
+
+        expect(node, inputs=[x, y], outputs=[result], name="test_string_concat")
+
+        x = np.array(["cat", "dog", "snake"]).astype("object")
+        y = np.array(["s"]).astype("object")
+        result = np.array(["cats", "dogs", "snakes"]).astype("object")
+
+        expect(
+            node,
+            inputs=[x, y],
+            outputs=[result],
+            name="test_string_concat_broadcasting",
+        )
+
+        x = np.array("cat").astype("object")
+        y = np.array("s").astype("object")
+        result = np.array("cats").astype("object")
+
+        expect(
+            node,
+            inputs=[x, y],
+            outputs=[result],
+            name="test_string_concat_zero_dimensional",
+        )
+
+        x = np.array(["abc", ""]).astype("object")
+        y = np.array(["", "abc"]).astype("object")
+        result = np.array(["abc", "abc"]).astype("object")
+
+        expect(
+            node,
+            inputs=[x, y],
+            outputs=[result],
+            name="test_string_concat_empty_string",
+        )
+
+        x = np.array(["的", "中"]).astype("object")
+        y = np.array(["的", "中"]).astype("object")
+        result = np.array(["的的", "中中"]).astype("object")
+
+        expect(
+            node,
+            inputs=[x, y],
+            outputs=[result],
+            name="test_string_concat_utf8",
+        )
diff --git a/onnx/backend/test/case/node/string_split.py b/onnx/backend/test/case/node/string_split.py
new file mode 100644
index 0000000..eebb7c1
--- /dev/null
+++ b/onnx/backend/test/case/node/string_split.py
@@ -0,0 +1,151 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class StringSplit(Base):
+    @staticmethod
+    def export_basic() -> None:
+        node = onnx.helper.make_node(
+            "StringSplit",
+            inputs=["x"],
+            outputs=["substrings", "length"],
+            delimiter=".",
+            maxsplit=None,
+        )
+
+        x = np.array(["abc.com", "def.net"]).astype(object)
+
+        substrings = np.array([["abc", "com"], ["def", "net"]]).astype(object)
+
+        length = np.array([2, 2], dtype=np.int64)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[substrings, length],
+            name="test_string_split_basic",
+        )
+
+    @staticmethod
+    def export_maxsplit() -> None:
+        node = onnx.helper.make_node(
+            "StringSplit",
+            inputs=["x"],
+            outputs=["substrings", "length"],
+            maxsplit=2,
+        )
+
+        x = np.array(
+            [["hello world", "def.net"], ["o n n x", "the quick brown fox"]]
+        ).astype(object)
+
+        substrings = np.array(
+            [
+                [["hello", "world", ""], ["def.net", "", ""]],
+                [["o", "n", "n x"], ["the", "quick", "brown fox"]],
+            ]
+        ).astype(object)
+
+        length = np.array([[2, 1], [3, 3]], np.int64)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[substrings, length],
+            name="test_string_split_maxsplit",
+        )
+
+    @staticmethod
+    def export_consecutive_delimiters() -> None:
+        node = onnx.helper.make_node(
+            "StringSplit",
+            inputs=["x"],
+            outputs=["substrings", "length"],
+            delimiter="-",
+            maxsplit=None,
+        )
+
+        x = np.array(["o-n-n--x-", "o-n----nx"]).astype(object)
+
+        substrings = np.array(
+            [["o", "n", "n", "", "x", ""], ["o", "n", "", "", "", "nx"]]
+        ).astype(object)
+
+        length = np.array([6, 6], dtype=np.int64)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[substrings, length],
+            name="test_string_split_consecutive_delimiters",
+        )
+
+    @staticmethod
+    def export_empty_string_delimiter() -> None:
+        for delimiter, test_name in (
+            ("", "test_string_split_empty_string_delimiter"),
+            (None, "test_string_split_no_delimiter"),
+        ):
+            node = onnx.helper.make_node(
+                "StringSplit",
+                inputs=["x"],
+                outputs=["substrings", "length"],
+                delimiter=delimiter,
+                maxsplit=None,
+            )
+
+            x = np.array(
+                ["hello world !", "  hello   world !", " hello world   ! "]
+            ).astype(object)
+
+            substrings = np.array(
+                [
+                    ["hello", "world", "!"],
+                    ["hello", "world", "!"],
+                    ["hello", "world", "!"],
+                ]
+            ).astype(object)
+
+            length = np.array([3, 3, 3], dtype=np.int64)
+
+            expect(
+                node,
+                inputs=[x],
+                outputs=[substrings, length],
+                name=test_name,
+            )
+
+    @staticmethod
+    def export_empty_string_split() -> None:
+        node = onnx.helper.make_node(
+            "StringSplit",
+            inputs=["x"],
+            outputs=["substrings", "length"],
+            delimiter=None,
+            maxsplit=None,
+        )
+
+        x = np.array([]).astype(object)
+
+        substrings = np.array([]).astype(object).reshape(0, 0)
+
+        length = np.array([], dtype=np.int64)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[substrings, length],
+            name="test_string_split_empty_tensor",
+            output_type_protos=[
+                onnx.helper.make_tensor_type_proto(onnx.TensorProto.STRING, (0, None)),
+                None,
+            ],
+        )
diff --git a/onnx/backend/test/case/node/stringnormalizer.py b/onnx/backend/test/case/node/stringnormalizer.py
new file mode 100644
index 0000000..3eb9d7b
--- /dev/null
+++ b/onnx/backend/test/case/node/stringnormalizer.py
@@ -0,0 +1,148 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class StringNormalizer(Base):
+    @staticmethod
+    def export_nostopwords_nochangecase() -> None:
+        input = np.array(["monday", "tuesday"]).astype(object)
+        output = input
+
+        # No stopwords. This is a NOOP
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            is_case_sensitive=1,
+        )
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_strnormalizer_nostopwords_nochangecase",
+        )
+
+    @staticmethod
+    def export_monday_casesensintive_nochangecase() -> None:
+        input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+        output = np.array(["tuesday", "wednesday", "thursday"]).astype(object)
+        stopwords = ["monday"]
+
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            is_case_sensitive=1,
+            stopwords=stopwords,
+        )
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_strnormalizer_export_monday_casesensintive_nochangecase",
+        )
+
+    @staticmethod
+    def export_monday_casesensintive_lower() -> None:
+        input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+        output = np.array(["tuesday", "wednesday", "thursday"]).astype(object)
+        stopwords = ["monday"]
+
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            case_change_action="LOWER",
+            is_case_sensitive=1,
+            stopwords=stopwords,
+        )
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_strnormalizer_export_monday_casesensintive_lower",
+        )
+
+    @staticmethod
+    def export_monday_casesensintive_upper() -> None:
+        input = np.array(["monday", "tuesday", "wednesday", "thursday"]).astype(object)
+        output = np.array(["TUESDAY", "WEDNESDAY", "THURSDAY"]).astype(object)
+        stopwords = ["monday"]
+
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            case_change_action="UPPER",
+            is_case_sensitive=1,
+            stopwords=stopwords,
+        )
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_strnormalizer_export_monday_casesensintive_upper",
+        )
+
+    @staticmethod
+    def export_monday_empty_output() -> None:
+        input = np.array(["monday", "monday"]).astype(object)
+        output = np.array([""]).astype(object)
+        stopwords = ["monday"]
+
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            case_change_action="UPPER",
+            is_case_sensitive=1,
+            stopwords=stopwords,
+        )
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_strnormalizer_export_monday_empty_output",
+        )
+
+    @staticmethod
+    def export_monday_insensintive_upper_twodim() -> None:
+        input = (
+            np.array(
+                ["Monday", "tuesday", "wednesday", "Monday", "tuesday", "wednesday"]
+            )
+            .astype(object)
+            .reshape([1, 6])
+        )
+
+        # It does upper case cecedille, accented E
+        # and german umlaut but fails
+        # with german eszett
+        output = (
+            np.array(["TUESDAY", "WEDNESDAY", "TUESDAY", "WEDNESDAY"])
+            .astype(object)
+            .reshape([1, 4])
+        )
+        stopwords = ["monday"]
+
+        node = onnx.helper.make_node(
+            "StringNormalizer",
+            inputs=["x"],
+            outputs=["y"],
+            case_change_action="UPPER",
+            stopwords=stopwords,
+        )
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_strnormalizer_export_monday_insensintive_upper_twodim",
+        )
diff --git a/onnx/backend/test/case/node/sub.py b/onnx/backend/test/case/node/sub.py
new file mode 100644
index 0000000..f4c9668
--- /dev/null
+++ b/onnx/backend/test/case/node/sub.py
@@ -0,0 +1,73 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Sub(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Sub",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.array([1, 2, 3]).astype(np.float32)
+        y = np.array([3, 2, 1]).astype(np.float32)
+        z = x - y  # expected output [-2., 0., 2.]
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(3, 4, 5).astype(np.float32)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub")
+
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int8)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.int8)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_int8")
+
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.int16)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.int16)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_int16")
+
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint8)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint8)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint8")
+
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint16)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint16)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint16")
+
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint32)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint32)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint32")
+
+        x = np.random.randint(12, 24, size=(3, 4, 5), dtype=np.uint64)
+        y = np.random.randint(12, size=(3, 4, 5), dtype=np.uint64)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_uint64")
+
+    @staticmethod
+    def export_sub_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Sub",
+            inputs=["x", "y"],
+            outputs=["z"],
+        )
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.random.randn(5).astype(np.float32)
+        z = x - y
+        expect(node, inputs=[x, y], outputs=[z], name="test_sub_bcast")
diff --git a/onnx/backend/test/case/node/sum.py b/onnx/backend/test/case/node/sum.py
new file mode 100644
index 0000000..c2ac0a6
--- /dev/null
+++ b/onnx/backend/test/case/node/sum.py
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Sum(Base):
+    @staticmethod
+    def export() -> None:
+        data_0 = np.array([3, 0, 2]).astype(np.float32)
+        data_1 = np.array([1, 3, 4]).astype(np.float32)
+        data_2 = np.array([2, 6, 6]).astype(np.float32)
+        result = np.array([6, 9, 12]).astype(np.float32)
+        node = onnx.helper.make_node(
+            "Sum",
+            inputs=["data_0", "data_1", "data_2"],
+            outputs=["result"],
+        )
+        expect(
+            node,
+            inputs=[data_0, data_1, data_2],
+            outputs=[result],
+            name="test_sum_example",
+        )
+
+        node = onnx.helper.make_node(
+            "Sum",
+            inputs=["data_0"],
+            outputs=["result"],
+        )
+        expect(node, inputs=[data_0], outputs=[data_0], name="test_sum_one_input")
+
+        result = np.add(data_0, data_1)
+        node = onnx.helper.make_node(
+            "Sum",
+            inputs=["data_0", "data_1"],
+            outputs=["result"],
+        )
+        expect(
+            node, inputs=[data_0, data_1], outputs=[result], name="test_sum_two_inputs"
+        )
diff --git a/onnx/backend/test/case/node/swish.py b/onnx/backend/test/case/node/swish.py
new file mode 100644
index 0000000..49abb2f
--- /dev/null
+++ b/onnx/backend/test/case/node/swish.py
@@ -0,0 +1,36 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def swish(x: np.ndarray, alpha: float) -> np.ndarray:
+    return x * (1 / (1 + np.exp(-alpha * x)))
+
+
+class Swish(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Swish",
+            inputs=["x"],
+            outputs=["y"],
+            alpha=1.0,  # pass alpha as attribute
+        )
+
+        x = np.array([3, 4, 5], dtype=np.float32)
+        y = swish(x, alpha=1.0)
+
+        expect(
+            node,
+            inputs=[x],
+            outputs=[y],
+            name="test_swish",
+            opset_imports=[onnx.helper.make_opsetid("", 24)],
+        )
diff --git a/onnx/backend/test/case/node/tan.py b/onnx/backend/test/case/node/tan.py
new file mode 100644
index 0000000..6888f69
--- /dev/null
+++ b/onnx/backend/test/case/node/tan.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Tan(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Tan",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.tan(x)
+        expect(node, inputs=[x], outputs=[y], name="test_tan_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.tan(x)
+        expect(node, inputs=[x], outputs=[y], name="test_tan")
diff --git a/onnx/backend/test/case/node/tanh.py b/onnx/backend/test/case/node/tanh.py
new file mode 100644
index 0000000..df180c7
--- /dev/null
+++ b/onnx/backend/test/case/node/tanh.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Tanh(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Tanh",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.array([-1, 0, 1]).astype(np.float32)
+        y = np.tanh(x)  # expected output [-0.76159418, 0., 0.76159418]
+        expect(node, inputs=[x], outputs=[y], name="test_tanh_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.tanh(x)
+        expect(node, inputs=[x], outputs=[y], name="test_tanh")
diff --git a/onnx/backend/test/case/node/tensorscatter.py b/onnx/backend/test/case/node/tensorscatter.py
new file mode 100644
index 0000000..8a26452
--- /dev/null
+++ b/onnx/backend/test/case/node/tensorscatter.py
@@ -0,0 +1,174 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class TensorScatter(Base):
+    @staticmethod
+    def export_tensorscatter() -> None:
+        node = onnx.helper.make_node(
+            "TensorScatter",
+            inputs=["past_cache", "update", "write_indices"],
+            outputs=["present_cache"],
+            mode="linear",
+        )
+        past_cache = np.array(
+            [
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+            ],
+            dtype=np.float32,
+        )
+        update = np.array(
+            [
+                [[[5, 5, 5, 5, 5]]],
+                [[[1, 1, 1, 1, 1]]],
+            ],
+            dtype=np.float32,
+        )
+        write_indices = np.array([1, 2], dtype=np.int64)
+        present_cache = np.array(
+            [
+                [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [1, 1, 1, 1, 1], [4, 3, 2, 1, 0]]],
+            ],
+            dtype=np.float32,
+        )
+        expect(
+            node,
+            inputs=[past_cache, update, write_indices],
+            outputs=[present_cache],
+            name="test_tensorscatter",
+        )
+
+    @staticmethod
+    def export_tensorscatter_circular() -> None:
+        node = onnx.helper.make_node(
+            "TensorScatter",
+            inputs=["past_cache", "update", "write_indices"],
+            outputs=["present_cache"],
+            mode="circular",
+        )
+        past_cache = np.array(
+            [
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+                [[[1, 2, 3, 4, 5], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [4, 3, 2, 1, 0]]],
+            ],
+            dtype=np.float32,
+        )
+        update = np.array(
+            [
+                [
+                    [
+                        [5, 5, 5, 5, 5],
+                        [6, 6, 6, 6, 6],
+                    ]
+                ],
+                [
+                    [
+                        [1, 1, 1, 1, 1],
+                        [2, 2, 2, 2, 2],
+                    ]
+                ],
+            ],
+            dtype=np.float32,
+        )
+        write_indices = np.array([1, 3], dtype=np.int64)
+        present_cache = np.array(
+            [
+                [[[1, 2, 3, 4, 5], [5, 5, 5, 5, 5], [6, 6, 6, 6, 6], [4, 3, 2, 1, 0]]],
+                [[[2, 2, 2, 2, 2], [5, 6, 7, 8, 9], [8, 7, 6, 5, 4], [1, 1, 1, 1, 1]]],
+            ],
+            dtype=np.float32,
+        )
+        expect(
+            node,
+            inputs=[past_cache, update, write_indices],
+            outputs=[present_cache],
+            name="test_tensorscatter_circular",
+        )
+
+    @staticmethod
+    def export_tensorscatter_3d() -> None:
+        node = onnx.helper.make_node(
+            "TensorScatter",
+            inputs=["past_cache", "update", "write_indices"],
+            outputs=["present_cache"],
+        )
+        past_cache = np.array(
+            [
+                [
+                    [1, 2, 3, 4, 5],
+                    [5, 6, 7, 8, 9],
+                    [8, 7, 6, 5, 4],
+                    [5, 4, 3, 2, 1],
+                ],
+                [
+                    [1, 2, 3, 4, 5],
+                    [5, 6, 7, 8, 9],
+                    [8, 7, 6, 5, 4],
+                    [5, 4, 3, 2, 1],
+                ],
+                [
+                    [1, 2, 3, 4, 5],
+                    [5, 6, 7, 8, 9],
+                    [8, 7, 6, 5, 4],
+                    [5, 4, 3, 2, 1],
+                ],
+            ],
+            dtype=np.float32,
+        )
+        update = np.array(
+            [
+                [
+                    [4, 4, 4, 4, 4],
+                    [5, 5, 5, 5, 5],
+                ],
+                [
+                    [6, 6, 6, 6, 6],
+                    [7, 7, 7, 7, 7],
+                ],
+                [
+                    [2, 2, 2, 2, 2],
+                    [3, 3, 3, 3, 3],
+                ],
+            ],
+            dtype=np.float32,
+        )
+        write_indices = np.array([1, 2, 0], dtype=np.int64)
+        present_cache = np.array(
+            [
+                [
+                    [1, 2, 3, 4, 5],
+                    [4, 4, 4, 4, 4],
+                    [5, 5, 5, 5, 5],
+                    [5, 4, 3, 2, 1],
+                ],
+                [
+                    [1, 2, 3, 4, 5],
+                    [5, 6, 7, 8, 9],
+                    [6, 6, 6, 6, 6],
+                    [7, 7, 7, 7, 7],
+                ],
+                [
+                    [2, 2, 2, 2, 2],
+                    [3, 3, 3, 3, 3],
+                    [8, 7, 6, 5, 4],
+                    [5, 4, 3, 2, 1],
+                ],
+            ],
+            dtype=np.float32,
+        )
+        expect(
+            node,
+            inputs=[past_cache, update, write_indices],
+            outputs=[present_cache],
+            name="test_tensorscatter_3d",
+        )
diff --git a/onnx/backend/test/case/node/tfidfvectorizer.py b/onnx/backend/test/case/node/tfidfvectorizer.py
new file mode 100644
index 0000000..f17e68c
--- /dev/null
+++ b/onnx/backend/test/case/node/tfidfvectorizer.py
@@ -0,0 +1,264 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+import onnx
+from onnx import NodeProto
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class TfIdfVectorizerHelper:
+    def __init__(self, **params: Any) -> None:
+        # Attr names
+        mode = "mode"
+        min_gram_length = "min_gram_length"
+        max_gram_length = "max_gram_length"
+        max_skip_count = "max_skip_count"
+        ngram_counts = "ngram_counts"
+        ngram_indexes = "ngram_indexes"
+        pool_int64s = "pool_int64s"
+
+        required_attr = [
+            mode,
+            min_gram_length,
+            max_gram_length,
+            max_skip_count,
+            ngram_counts,
+            ngram_indexes,
+            pool_int64s,
+        ]
+
+        for i in required_attr:
+            assert i in params, f"Missing attribute: {i}"
+
+        self.mode = params[mode]
+        self.min_gram_length = params[min_gram_length]
+        self.max_gram_length = params[max_gram_length]
+        self.max_skip_count = params[max_skip_count]
+        self.ngram_counts = params[ngram_counts]
+        self.ngram_indexes = params[ngram_indexes]
+        self.pool_int64s = params[pool_int64s]
+
+    def make_node_noweights(self) -> NodeProto:
+        return onnx.helper.make_node(
+            "TfIdfVectorizer",
+            inputs=["X"],
+            outputs=["Y"],
+            mode=self.mode,
+            min_gram_length=self.min_gram_length,
+            max_gram_length=self.max_gram_length,
+            max_skip_count=self.max_skip_count,
+            ngram_counts=self.ngram_counts,
+            ngram_indexes=self.ngram_indexes,
+            pool_int64s=self.pool_int64s,
+        )
+
+
+class TfIdfVectorizer(Base):
+    @staticmethod
+    def export_tf_only_bigrams_skip0() -> None:
+        input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+        output = np.array([0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0]).astype(np.float32)
+
+        ngram_counts = np.array([0, 4]).astype(np.int64)
+        ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+        pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+            np.int64
+        )  # bigrams
+
+        helper = TfIdfVectorizerHelper(
+            mode="TF",
+            min_gram_length=2,
+            max_gram_length=2,
+            max_skip_count=0,
+            ngram_counts=ngram_counts,
+            ngram_indexes=ngram_indexes,
+            pool_int64s=pool_int64s,
+        )
+        node = helper.make_node_noweights()
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_tfidfvectorizer_tf_only_bigrams_skip0",
+        )
+
+    @staticmethod
+    def export_tf_batch_onlybigrams_skip0() -> None:
+        input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32)
+        output = np.array(
+            [[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, 1.0]]
+        ).astype(np.float32)
+
+        ngram_counts = np.array([0, 4]).astype(np.int64)
+        ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+        pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+            np.int64
+        )  # bigrams
+
+        helper = TfIdfVectorizerHelper(
+            mode="TF",
+            min_gram_length=2,
+            max_gram_length=2,
+            max_skip_count=0,
+            ngram_counts=ngram_counts,
+            ngram_indexes=ngram_indexes,
+            pool_int64s=pool_int64s,
+        )
+        node = helper.make_node_noweights()
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_tfidfvectorizer_tf_batch_onlybigrams_skip0",
+        )
+
+    @staticmethod
+    def export_tf_onlybigrams_levelempty() -> None:
+        input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+        output = np.array([1.0, 1.0, 1.0]).astype(np.float32)
+
+        ngram_counts = np.array([0, 0]).astype(np.int64)
+        ngram_indexes = np.array([0, 1, 2]).astype(np.int64)
+        pool_int64s = np.array([5, 6, 7, 8, 6, 7]).astype(  # unigrams none
+            np.int64
+        )  # bigrams
+
+        helper = TfIdfVectorizerHelper(
+            mode="TF",
+            min_gram_length=2,
+            max_gram_length=2,
+            max_skip_count=0,
+            ngram_counts=ngram_counts,
+            ngram_indexes=ngram_indexes,
+            pool_int64s=pool_int64s,
+        )
+        node = helper.make_node_noweights()
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_tfidfvectorizer_tf_onlybigrams_levelempty",
+        )
+
+    @staticmethod
+    def export_tf_onlybigrams_skip5() -> None:
+        input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+        output = np.array([0.0, 0.0, 0.0, 0.0, 1.0, 3.0, 1.0]).astype(np.float32)
+
+        ngram_counts = np.array([0, 4]).astype(np.int64)
+        ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+        pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+            np.int64
+        )  # bigrams
+
+        helper = TfIdfVectorizerHelper(
+            mode="TF",
+            min_gram_length=2,
+            max_gram_length=2,
+            max_skip_count=5,
+            ngram_counts=ngram_counts,
+            ngram_indexes=ngram_indexes,
+            pool_int64s=pool_int64s,
+        )
+        node = helper.make_node_noweights()
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_tfidfvectorizer_tf_onlybigrams_skip5",
+        )
+
+    @staticmethod
+    def export_tf_batch_onlybigrams_skip5() -> None:
+        input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32)
+        output = np.array(
+            [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0]]
+        ).astype(np.float32)
+
+        ngram_counts = np.array([0, 4]).astype(np.int64)
+        ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+        pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+            np.int64
+        )  # bigrams
+
+        helper = TfIdfVectorizerHelper(
+            mode="TF",
+            min_gram_length=2,
+            max_gram_length=2,
+            max_skip_count=5,
+            ngram_counts=ngram_counts,
+            ngram_indexes=ngram_indexes,
+            pool_int64s=pool_int64s,
+        )
+        node = helper.make_node_noweights()
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_tfidfvectorizer_tf_batch_onlybigrams_skip5",
+        )
+
+    @staticmethod
+    def export_tf_uniandbigrams_skip5() -> None:
+        input = np.array([1, 1, 3, 3, 3, 7, 8, 6, 7, 5, 6, 8]).astype(np.int32)
+        output = np.array([0.0, 3.0, 1.0, 0.0, 1.0, 3.0, 1.0]).astype(np.float32)
+
+        ngram_counts = np.array([0, 4]).astype(np.int64)
+        ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+        pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+            np.int64
+        )  # bigrams
+
+        helper = TfIdfVectorizerHelper(
+            mode="TF",
+            min_gram_length=1,
+            max_gram_length=2,
+            max_skip_count=5,
+            ngram_counts=ngram_counts,
+            ngram_indexes=ngram_indexes,
+            pool_int64s=pool_int64s,
+        )
+        node = helper.make_node_noweights()
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_tfidfvectorizer_tf_uniandbigrams_skip5",
+        )
+
+    @staticmethod
+    def export_tf_batch_uniandbigrams_skip5() -> None:
+        input = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int32)
+        output = np.array(
+            [[0.0, 3.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0]]
+        ).astype(np.float32)
+
+        ngram_counts = np.array([0, 4]).astype(np.int64)
+        ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+        pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+            np.int64
+        )  # bigrams
+
+        helper = TfIdfVectorizerHelper(
+            mode="TF",
+            min_gram_length=1,
+            max_gram_length=2,
+            max_skip_count=5,
+            ngram_counts=ngram_counts,
+            ngram_indexes=ngram_indexes,
+            pool_int64s=pool_int64s,
+        )
+        node = helper.make_node_noweights()
+        expect(
+            node,
+            inputs=[input],
+            outputs=[output],
+            name="test_tfidfvectorizer_tf_batch_uniandbigrams_skip5",
+        )
diff --git a/onnx/backend/test/case/node/thresholdedrelu.py b/onnx/backend/test/case/node/thresholdedrelu.py
new file mode 100644
index 0000000..ccbbc1b
--- /dev/null
+++ b/onnx/backend/test/case/node/thresholdedrelu.py
@@ -0,0 +1,41 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class ThresholdedRelu(Base):
+    @staticmethod
+    def export() -> None:
+        alpha = 2.0
+        node = onnx.helper.make_node(
+            "ThresholdedRelu", inputs=["x"], outputs=["y"], alpha=alpha
+        )
+
+        x = np.array([-1.5, 0.0, 1.2, 2.0, 2.2]).astype(np.float32)
+        y = np.clip(x, alpha, np.inf)  # expected output [0., 0., 0., 0., 2.2]
+        y[y == alpha] = 0
+
+        expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu_example")
+
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, alpha, np.inf)
+        y[y == alpha] = 0
+
+        expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu")
+
+    @staticmethod
+    def export_default() -> None:
+        default_alpha = 1.0
+        node = onnx.helper.make_node("ThresholdedRelu", inputs=["x"], outputs=["y"])
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        y = np.clip(x, default_alpha, np.inf)
+        y[y == default_alpha] = 0
+
+        expect(node, inputs=[x], outputs=[y], name="test_thresholdedrelu_default")
diff --git a/onnx/backend/test/case/node/tile.py b/onnx/backend/test/case/node/tile.py
new file mode 100644
index 0000000..386e724
--- /dev/null
+++ b/onnx/backend/test/case/node/tile.py
@@ -0,0 +1,38 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Tile(Base):
+    @staticmethod
+    def export_tile() -> None:
+        node = onnx.helper.make_node("Tile", inputs=["x", "y"], outputs=["z"])
+
+        x = np.random.rand(2, 3, 4, 5).astype(np.float32)
+
+        repeats = np.random.randint(low=1, high=10, size=(np.ndim(x),)).astype(np.int64)
+
+        z = np.tile(x, repeats)
+
+        expect(node, inputs=[x, repeats], outputs=[z], name="test_tile")
+
+    @staticmethod
+    def export_tile_precomputed() -> None:
+        node = onnx.helper.make_node("Tile", inputs=["x", "y"], outputs=["z"])
+
+        x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+
+        repeats = np.array([2, 2], dtype=np.int64)
+
+        z = np.array(
+            [[0, 1, 0, 1], [2, 3, 2, 3], [0, 1, 0, 1], [2, 3, 2, 3]], dtype=np.float32
+        )
+
+        expect(node, inputs=[x, repeats], outputs=[z], name="test_tile_precomputed")
diff --git a/onnx/backend/test/case/node/topk.py b/onnx/backend/test/case/node/topk.py
new file mode 100644
index 0000000..4e93a72
--- /dev/null
+++ b/onnx/backend/test/case/node/topk.py
@@ -0,0 +1,262 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def topk_sorted_implementation(X, k, axis, largest):
+    ind_axis = np.indices(X.shape)[axis]
+    if largest:
+        ind_axis = -ind_axis
+    sorted_indices = np.lexsort((ind_axis, X), axis=axis)
+    sorted_values = np.sort(X, axis=axis)
+    if largest:
+        sorted_indices = np.flip(sorted_indices, axis=axis)
+        sorted_values = np.flip(sorted_values, axis=axis)
+    topk_sorted_indices = np.take(sorted_indices, np.arange(k), axis=axis)
+    topk_sorted_values = np.take(sorted_values, np.arange(k), axis=axis)
+    return topk_sorted_values, np.array(topk_sorted_indices, dtype=np.int64)
+
+
+class TopK(Base):
+    @staticmethod
+    def export_top_k() -> None:
+        axis = 1
+        largest = 1
+
+        k = 3
+        node = onnx.helper.make_node(
+            "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+        )
+        X = np.array(
+            [
+                [0, 1, 2, 3],
+                [4, 5, 6, 7],
+                [8, 9, 10, 11],
+            ],
+            dtype=np.float32,
+        )
+        K = np.array([k], dtype=np.int64)
+        values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+        # print(values_ref)
+        # [[ 3.  2.  1.]
+        # [ 7.  6.  5.]
+        # [11. 10.  9.]]
+        # print(indices_ref)
+        # [[3 2 1]
+        # [3 2 1]
+        # [3 2 1]]
+
+        expect(
+            node, inputs=[X, K], outputs=[values_ref, indices_ref], name="test_top_k"
+        )
+
+    @staticmethod
+    def export_top_k_uint64() -> None:
+        axis = 1
+        largest = 1
+
+        k = 3
+        node = onnx.helper.make_node(
+            "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+        )
+        X = np.array(
+            [
+                [0, 1, 2, 3],
+                [4, 5, 6, 7],
+                [8, 9, 10, 11],
+            ],
+            dtype=np.uint64,
+        )
+        K = np.array([k], dtype=np.int64)
+        values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+        # print(values_ref)
+        # [[ 3  2  1]
+        # [ 7  6  5]
+        # [11 10  9]]
+        # print(indices_ref)
+        # [[3 2 1]
+        # [3 2 1]
+        # [3 2 1]]
+
+        expect(
+            node,
+            inputs=[X, K],
+            outputs=[values_ref, indices_ref],
+            name="test_top_k_uint64",
+        )
+
+    @staticmethod
+    def export_top_k_same_values() -> None:
+        axis = 0
+        largest = 0
+
+        k = 3
+        node = onnx.helper.make_node(
+            "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+        )
+        X = np.array(
+            [0, 0, 0, 0],
+            dtype=np.int64,
+        )
+        K = np.array([k], dtype=np.int64)
+        values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+        # (Pdb) print(values_ref)
+        # [0 0 0]
+        # (Pdb) print(indices_ref)
+        # [0 1 2]
+
+        expect(
+            node,
+            inputs=[X, K],
+            outputs=[values_ref, indices_ref],
+            name="test_top_k_same_values",
+        )
+
+    @staticmethod
+    def export_top_k_same_values_largest() -> None:
+        axis = 0
+        largest = 1
+
+        k = 3
+        node = onnx.helper.make_node(
+            "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+        )
+        X = np.array(
+            [0, 0, 0, 0],
+            dtype=np.int64,
+        )
+        K = np.array([k], dtype=np.int64)
+        values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+        # print(values_ref)
+        # [0 0 0]
+        # print(indices_ref)
+        # [0 1 2]
+
+        expect(
+            node,
+            inputs=[X, K],
+            outputs=[values_ref, indices_ref],
+            name="test_top_k_same_values_largest",
+        )
+
+    @staticmethod
+    def export_top_k_same_values_2d() -> None:
+        axis = 1
+        largest = 1
+
+        k = 3
+        node = onnx.helper.make_node(
+            "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+        )
+        X = np.array(
+            [[0, 0, 0, 0], [1, 1, 1, 1], [2, 2, 1, 1]],
+            dtype=np.int64,
+        )
+        K = np.array([k], dtype=np.int64)
+        values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+        # print(values_ref)
+        # [[0 0 0]
+        # [1 1 1]
+        # [1 1 2]]
+        # print(indices_ref)
+        # [[0 1 2]
+        # [0 1 2]
+        # [2 3 0]]
+
+        expect(
+            node,
+            inputs=[X, K],
+            outputs=[values_ref, indices_ref],
+            name="test_top_k_same_values_2d",
+        )
+
+    @staticmethod
+    def export_top_k_smallest() -> None:
+        axis = 1
+        largest = 0
+        sorted_ = 1
+        k = 3
+
+        node = onnx.helper.make_node(
+            "TopK",
+            inputs=["x", "k"],
+            outputs=["values", "indices"],
+            axis=axis,
+            largest=largest,
+            sorted=sorted_,
+        )
+
+        X = np.array(
+            [
+                [0, 1, 2, 3],
+                [4, 5, 6, 7],
+                [11, 10, 9, 8],
+            ],
+            dtype=np.float32,
+        )
+        K = np.array([k], dtype=np.int64)
+        values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+        # print(values_ref)
+        # [[ 0.  1.  2.]
+        # [ 4.  5.  6.]
+        # [ 8.  9. 10.]]
+        # print(indices_ref)
+        # [[0 1 2]
+        # [0 1 2]
+        # [3 2 1]]
+
+        expect(
+            node,
+            inputs=[X, K],
+            outputs=[values_ref, indices_ref],
+            name="test_top_k_smallest",
+        )
+
+    @staticmethod
+    def export_top_k_negative_axis() -> None:
+        axis = -1
+        largest = 1
+
+        k = 3
+        node = onnx.helper.make_node(
+            "TopK", inputs=["x", "k"], outputs=["values", "indices"], axis=axis
+        )
+        X = np.array(
+            [
+                [0, 1, 2, 3],
+                [4, 5, 6, 7],
+                [8, 9, 10, 11],
+            ],
+            dtype=np.float32,
+        )
+        K = np.array([k], dtype=np.int64)
+        values_ref, indices_ref = topk_sorted_implementation(X, k, axis, largest)
+
+        # print(values_ref)
+        # [[ 3.  2.  1.]
+        # [ 7.  6.  5.]
+        # [11. 10.  9.]]
+        # print(indices_ref)
+        # [[3 2 1]
+        # [3 2 1]
+        # [3 2 1]]
+
+        expect(
+            node,
+            inputs=[X, K],
+            outputs=[values_ref, indices_ref],
+            name="test_top_k_negative_axis",
+        )
diff --git a/onnx/backend/test/case/node/transpose.py b/onnx/backend/test/case/node/transpose.py
new file mode 100644
index 0000000..817df1f
--- /dev/null
+++ b/onnx/backend/test/case/node/transpose.py
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import itertools
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Transpose(Base):
+    @staticmethod
+    def export_default() -> None:
+        shape = (2, 3, 4)
+        data = np.random.random_sample(shape).astype(np.float32)
+
+        node = onnx.helper.make_node(
+            "Transpose", inputs=["data"], outputs=["transposed"]
+        )
+
+        transposed = np.transpose(data)
+        expect(node, inputs=[data], outputs=[transposed], name="test_transpose_default")
+
+    @staticmethod
+    def export_all_permutations() -> None:
+        shape = (2, 3, 4)
+        data = np.random.random_sample(shape).astype(np.float32)
+        permutations = list(itertools.permutations(np.arange(len(shape))))
+
+        for i, permutation in enumerate(permutations):
+            node = onnx.helper.make_node(
+                "Transpose",
+                inputs=["data"],
+                outputs=["transposed"],
+                perm=permutation,
+            )
+            transposed = np.transpose(data, permutation)
+            expect(
+                node,
+                inputs=[data],
+                outputs=[transposed],
+                name=f"test_transpose_all_permutations_{i}",
+            )
diff --git a/onnx/backend/test/case/node/trilu.py b/onnx/backend/test/case/node/trilu.py
new file mode 100644
index 0000000..a050fb4
--- /dev/null
+++ b/onnx/backend/test/case/node/trilu.py
@@ -0,0 +1,453 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def triu_reference_implementation(x, k=0):
+    return np.triu(x, k)
+
+
+def tril_reference_implementation(x, k=0):
+    return np.tril(x, k)
+
+
+class Trilu(Base):
+    @staticmethod
+    def export_triu() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 0, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[4, 7, 3, 7, 9],
+        #   [0, 2, 8, 6, 9],
+        #   [0, 0, 0, 8, 7],
+        #   [0, 0, 0, 2, 4]]
+        y = triu_reference_implementation(x)
+        expect(node, inputs=[x], outputs=[y], name="test_triu")
+
+    @staticmethod
+    def export_triu_neg() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        k = np.array(-1).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 0, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [0, 4, 0, 8, 7],
+        #   [0, 0, 4, 2, 4]]
+        y = triu_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_triu_neg")
+
+    @staticmethod
+    def export_triu_out_neg_out() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        k = np.array(-7).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 0, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 0, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        y = triu_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_triu_out_neg_out")
+
+    @staticmethod
+    def export_triu_pos() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        k = np.array(2).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 0, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[0, 0, 3, 7, 9],
+        #   [0, 0, 0, 6, 9],
+        #   [0, 0, 0, 0, 7],
+        #   [0, 0, 0, 0, 0]]
+        y = triu_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_triu_pos")
+
+    @staticmethod
+    def export_triu_out_pos() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        k = np.array(6).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 0, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[0, 0, 0, 0, 0],
+        #   [0, 0, 0, 0, 0],
+        #   [0, 0, 0, 0, 0],
+        #   [0, 0, 0, 0, 0]]
+        y = triu_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_triu_out_pos")
+
+    @staticmethod
+    def export_triu_square() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+        y = triu_reference_implementation(x)
+        # X:
+        # [[[4, 6, 9],
+        #   [7, 5, 4],
+        #   [8, 1, 2]],
+        #
+        #  [[1, 4, 9],
+        #   [9, 6, 3],
+        #   [8, 9, 8]]]
+        # expect result:
+        # [[[4, 6, 9],
+        #   [0, 5, 4],
+        #   [0, 0, 2]],
+        #
+        #  [[1, 4, 9],
+        #   [0, 6, 3],
+        #   [0, 0, 8]]]
+        expect(node, inputs=[x], outputs=[y], name="test_triu_square")
+
+    @staticmethod
+    def export_triu_square_neg() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+        k = np.array(-1).astype(np.int64)
+        # X:
+        # [[[4, 6, 9],
+        #   [7, 5, 4],
+        #   [8, 1, 2]],
+        #
+        #  [[1, 4, 9],
+        #   [9, 6, 3],
+        #   [8, 9, 8]]]
+        # expect result:
+        # [[[4, 6, 9],
+        #   [7, 5, 4],
+        #   [0, 1, 2]],
+        #
+        #  [[1, 4, 9],
+        #   [9, 6, 3],
+        #   [0, 9, 8]]]
+        y = triu_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_triu_square_neg")
+
+    @staticmethod
+    def export_triu_one_row() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(10, size=(3, 1, 5)).astype(np.int64)
+        k = np.array(1).astype(np.int64)
+        # X:
+        # [[[1, 4, 9, 7, 1]],
+        #
+        #  [[9, 2, 8, 8, 4]],
+        #
+        #  [[3, 9, 7, 4, 2]]]
+        # expect result:
+        # [[[0, 4, 9, 7, 1]],
+        #
+        #  [[0, 2, 8, 8, 4]],
+        #
+        #  [[0, 9, 7, 4, 2]]]
+        y = triu_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_triu_one_row")
+
+    @staticmethod
+    def export_triu_zero() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+        )
+
+        x = np.random.randint(10, size=(0, 5)).astype(np.int64)
+        k = np.array(6).astype(np.int64)
+        # X:
+        # []
+        # expect result:
+        # []
+        y = triu_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_triu_zero")
+
+    @staticmethod
+    def export_tril() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x"],
+            outputs=["y"],
+            upper=0,
+        )
+
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 1, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[4, 0, 0, 0, 0],
+        #   [1, 2, 0, 0, 0],
+        #   [9, 4, 1, 0, 0],
+        #   [4, 3, 4, 2, 0]]
+        y = tril_reference_implementation(x)
+        expect(node, inputs=[x], outputs=[y], name="test_tril")
+
+    @staticmethod
+    def export_tril_neg() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+            upper=0,
+        )
+
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        k = np.array(-1).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 1, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[0, 0, 0, 0, 0],
+        #   [1, 0, 0, 0, 0],
+        #   [9, 4, 0, 0, 0],
+        #   [4, 3, 4, 0, 0]]
+        y = tril_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_tril_neg")
+
+    @staticmethod
+    def export_tril_out_neg() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+            upper=0,
+        )
+
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        k = np.array(-7).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 1, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[0, 0, 0, 0, 0],
+        #   [0, 0, 0, 0, 0],
+        #   [0, 0, 0, 0, 0],
+        #   [0, 0, 0, 0, 0]]
+        y = tril_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_tril_out_neg")
+
+    @staticmethod
+    def export_tril_pos() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+            upper=0,
+        )
+
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        k = np.array(2).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 1, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[4, 7, 3, 0, 0],
+        #   [1, 2, 8, 6, 0],
+        #   [9, 4, 1, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        y = tril_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_tril_pos")
+
+    @staticmethod
+    def export_tril_out_pos() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+            upper=0,
+        )
+        x = np.random.randint(10, size=(4, 5)).astype(np.int64)
+        k = np.array(6).astype(np.int64)
+        # X:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 1, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        # expect result:
+        #  [[4, 7, 3, 7, 9],
+        #   [1, 2, 8, 6, 9],
+        #   [9, 4, 1, 8, 7],
+        #   [4, 3, 4, 2, 4]]
+        y = tril_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_tril_out_pos")
+
+    @staticmethod
+    def export_tril_square() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x"],
+            outputs=["y"],
+            upper=0,
+        )
+
+        x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+        # X:
+        # [[[0, 4, 3],
+        #   [2, 0, 9],
+        #   [8, 2, 5]],
+        #
+        #  [[2, 7, 2],
+        #   [2, 6, 0],
+        #   [2, 6, 5]]]
+        # expect result:
+        # [[[0, 0, 0],
+        #   [2, 0, 0],
+        #   [8, 2, 5]],
+        #
+        #  [[2, 0, 0],
+        #   [2, 6, 0],
+        #   [2, 6, 5]]]
+        y = tril_reference_implementation(x)
+        expect(node, inputs=[x], outputs=[y], name="test_tril_square")
+
+    @staticmethod
+    def export_tril_square_neg() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+            upper=0,
+        )
+
+        x = np.random.randint(10, size=(2, 3, 3)).astype(np.int64)
+        k = np.array(-1).astype(np.int64)
+        # X:
+        # [[[0, 4, 3],
+        #   [2, 0, 9],
+        #   [8, 2, 5]],
+        #
+        #  [[2, 7, 2],
+        #   [2, 6, 0],
+        #   [2, 6, 5]]]
+        # expect result:
+        # [[[0, 0, 0],
+        #   [2, 0, 0],
+        #   [8, 2, 0]],
+        #
+        #  [[0, 0, 0],
+        #   [2, 0, 0],
+        #   [2, 6, 0]]]
+        y = tril_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_tril_square_neg")
+
+    @staticmethod
+    def export_tril_one_row() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x"],
+            outputs=["y"],
+            upper=0,
+        )
+
+        x = np.random.randint(10, size=(3, 1, 5)).astype(np.int64)
+        # X:
+        # [[[6, 2, 4, 1, 6]],
+        #
+        #  [[8, 3, 8, 7, 0]],
+        #
+        #  [[2, 2, 9, 5, 9]]]
+        # expect result:
+        # [[[6, 0, 0, 0, 0]],
+        #
+        #  [[8, 0, 0, 0, 0]],
+        #
+        #  [[2, 0, 0, 0, 0]]]
+        y = tril_reference_implementation(x)
+        expect(node, inputs=[x], outputs=[y], name="test_tril_one_row_neg")
+
+    @staticmethod
+    def export_tril_zero() -> None:
+        node = onnx.helper.make_node(
+            "Trilu",
+            inputs=["x", "k"],
+            outputs=["y"],
+            upper=0,
+        )
+
+        x = np.random.randint(10, size=(3, 0, 5)).astype(np.int64)
+        k = np.array(6).astype(np.int64)
+        # X:
+        # []
+        # expect result:
+        # []
+        y = tril_reference_implementation(x, int(k))
+        expect(node, inputs=[x, k], outputs=[y], name="test_tril_zero")
diff --git a/onnx/backend/test/case/node/unique.py b/onnx/backend/test/case/node/unique.py
new file mode 100644
index 0000000..4bd1241
--- /dev/null
+++ b/onnx/backend/test/case/node/unique.py
@@ -0,0 +1,229 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+def specify_int64(indices, inverse_indices, counts):
+    return (
+        np.array(indices, dtype=np.int64),
+        np.array(inverse_indices, dtype=np.int64),
+        np.array(counts, dtype=np.int64),
+    )
+
+
+class Unique(Base):
+    @staticmethod
+    def export_sorted_without_axis() -> None:
+        node_sorted = onnx.helper.make_node(
+            "Unique",
+            inputs=["X"],
+            outputs=["Y", "indices", "inverse_indices", "counts"],
+        )
+
+        x = np.array([2.0, 1.0, 1.0, 3.0, 4.0, 3.0], dtype=np.float32)
+        y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+        indices, inverse_indices, counts = specify_int64(
+            indices, inverse_indices, counts
+        )
+        expect(
+            node_sorted,
+            inputs=[x],
+            outputs=[y, indices, inverse_indices, counts],
+            name="test_unique_sorted_without_axis",
+        )
+
+    @staticmethod
+    def export_not_sorted_without_axis() -> None:
+        node_not_sorted = onnx.helper.make_node(
+            "Unique",
+            inputs=["X"],
+            outputs=["Y", "indices", "inverse_indices", "counts"],
+            sorted=0,
+        )
+        # numpy unique does not retain original order (it sorts the output unique values)
+        # https://github.com/numpy/numpy/issues/8621
+        # we need to recover unsorted output and indices
+        x = np.array([2.0, 1.0, 1.0, 3.0, 4.0, 3.0], dtype=np.float32)
+        y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+
+        # prepare index mapping from sorted to unsorted
+        argsorted_indices = np.argsort(indices)
+        inverse_indices_map = dict(
+            zip(argsorted_indices, np.arange(len(argsorted_indices)), strict=True)
+        )
+
+        indices = indices[argsorted_indices]
+        y = np.take(x, indices, axis=0)
+        inverse_indices = np.asarray(
+            [inverse_indices_map[i] for i in inverse_indices], dtype=np.int64
+        )
+        counts = counts[argsorted_indices]
+        indices, inverse_indices, counts = specify_int64(
+            indices, inverse_indices, counts
+        )
+        # print(y)
+        # [2.0, 1.0, 3.0, 4.0]
+        # print(indices)
+        # [0 1 3 4]
+        # print(inverse_indices)
+        # [0, 1, 1, 2, 3, 2]
+        # print(counts)
+        # [1, 2, 2, 1]
+
+        expect(
+            node_not_sorted,
+            inputs=[x],
+            outputs=[y, indices, inverse_indices, counts],
+            name="test_unique_not_sorted_without_axis",
+        )
+
+    @staticmethod
+    def export_sorted_with_axis() -> None:
+        node_sorted = onnx.helper.make_node(
+            "Unique",
+            inputs=["X"],
+            outputs=["Y", "indices", "inverse_indices", "counts"],
+            sorted=1,
+            axis=0,
+        )
+
+        x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]], dtype=np.float32)
+        y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=0)
+        indices, inverse_indices, counts = specify_int64(
+            indices, inverse_indices, counts
+        )
+        # behavior changed with numpy >= 2.0
+        inverse_indices = inverse_indices.reshape(-1)
+        # print(y)
+        # [[1. 0. 0.]
+        #  [2. 3. 4.]]
+        # print(indices)
+        # [0 2]
+        # print(inverse_indices)
+        # [0 0 1]
+        # print(counts)
+        # [2 1]
+
+        expect(
+            node_sorted,
+            inputs=[x],
+            outputs=[y, indices, inverse_indices, counts],
+            name="test_unique_sorted_with_axis",
+        )
+
+    @staticmethod
+    def export_sorted_with_axis_3d() -> None:
+        node_sorted = onnx.helper.make_node(
+            "Unique",
+            inputs=["X"],
+            outputs=["Y", "indices", "inverse_indices", "counts"],
+            sorted=1,
+            axis=1,
+        )
+
+        x = np.array(
+            [
+                [[1.0, 1.0], [0.0, 1.0], [2.0, 1.0], [0.0, 1.0]],
+                [[1.0, 1.0], [0.0, 1.0], [2.0, 1.0], [0.0, 1.0]],
+            ],
+            dtype=np.float32,
+        )
+        y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=1)
+        indices, inverse_indices, counts = specify_int64(
+            indices, inverse_indices, counts
+        )
+        # behavior changed with numpy >= 2.0
+        inverse_indices = inverse_indices.reshape(-1)
+        # print(y)
+        # [[[0. 1.]
+        #  [1. 1.]
+        #  [2. 1.]]
+        # [[0. 1.]
+        #  [1. 1.]
+        #  [2. 1.]]]
+        # print(indices)
+        # [1 0 2]
+        # print(inverse_indices)
+        # [1 0 2 0]
+        # print(counts)
+        # [2 1 1]
+        expect(
+            node_sorted,
+            inputs=[x],
+            outputs=[y, indices, inverse_indices, counts],
+            name="test_unique_sorted_with_axis_3d",
+        )
+
+    @staticmethod
+    def export_sorted_with_negative_axis() -> None:
+        node_sorted = onnx.helper.make_node(
+            "Unique",
+            inputs=["X"],
+            outputs=["Y", "indices", "inverse_indices", "counts"],
+            sorted=1,
+            axis=-1,
+        )
+
+        x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 3]], dtype=np.float32)
+        y, indices, inverse_indices, counts = np.unique(x, True, True, True, axis=-1)
+        indices, inverse_indices, counts = specify_int64(
+            indices, inverse_indices, counts
+        )
+        # behavior changed with numpy >= 2.0
+        inverse_indices = inverse_indices.reshape(-1)
+        # print(y)
+        # [[0. 1.]
+        #  [0. 1.]
+        #  [3. 2.]]
+        # print(indices)
+        # [1 0]
+        # print(inverse_indices)
+        # [1 0 0]
+        # print(counts)
+        # [2 1]
+
+        expect(
+            node_sorted,
+            inputs=[x],
+            outputs=[y, indices, inverse_indices, counts],
+            name="test_unique_sorted_with_negative_axis",
+        )
+
+    @staticmethod
+    def export_length_1() -> None:
+        node_sorted = onnx.helper.make_node(
+            "Unique",
+            inputs=["X"],
+            outputs=["Y", "indices", "inverse_indices", "counts"],
+            sorted=1,
+        )
+
+        x = np.array([0], dtype=np.int64)
+        y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+        indices, inverse_indices, counts = specify_int64(
+            indices, inverse_indices, counts
+        )
+        # behavior changed with numpy >= 2.0
+        inverse_indices = inverse_indices.reshape(-1)
+        # print(y)
+        # [0]
+        # print(indices)
+        # [0]
+        # print(inverse_indices)
+        # [0]
+        # print(counts)
+        # [1]
+
+        expect(
+            node_sorted,
+            inputs=[x],
+            outputs=[y, indices, inverse_indices, counts],
+            name="test_unique_length_1",
+        )
diff --git a/onnx/backend/test/case/node/unsqueeze.py b/onnx/backend/test/case/node/unsqueeze.py
new file mode 100644
index 0000000..6d517a0
--- /dev/null
+++ b/onnx/backend/test/case/node/unsqueeze.py
@@ -0,0 +1,91 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Unsqueeze(Base):
+    @staticmethod
+    def export_unsqueeze_one_axis() -> None:
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+
+        for i in range(x.ndim):
+            axes = np.array([i]).astype(np.int64)
+            node = onnx.helper.make_node(
+                "Unsqueeze",
+                inputs=["x", "axes"],
+                outputs=["y"],
+            )
+            y = np.expand_dims(x, axis=i)
+
+            expect(
+                node,
+                inputs=[x, axes],
+                outputs=[y],
+                name="test_unsqueeze_axis_" + str(i),
+            )
+
+    @staticmethod
+    def export_unsqueeze_two_axes() -> None:
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        axes = np.array([1, 4]).astype(np.int64)
+
+        node = onnx.helper.make_node(
+            "Unsqueeze",
+            inputs=["x", "axes"],
+            outputs=["y"],
+        )
+        y = np.expand_dims(x, axis=1)
+        y = np.expand_dims(y, axis=4)
+
+        expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_two_axes")
+
+    @staticmethod
+    def export_unsqueeze_three_axes() -> None:
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        axes = np.array([2, 4, 5]).astype(np.int64)
+
+        node = onnx.helper.make_node(
+            "Unsqueeze",
+            inputs=["x", "axes"],
+            outputs=["y"],
+        )
+        y = np.expand_dims(x, axis=2)
+        y = np.expand_dims(y, axis=4)
+        y = np.expand_dims(y, axis=5)
+
+        expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_three_axes")
+
+    @staticmethod
+    def export_unsqueeze_unsorted_axes() -> None:
+        x = np.random.randn(3, 4, 5).astype(np.float32)
+        axes = np.array([5, 4, 2]).astype(np.int64)
+
+        node = onnx.helper.make_node(
+            "Unsqueeze",
+            inputs=["x", "axes"],
+            outputs=["y"],
+        )
+        y = np.expand_dims(x, axis=2)
+        y = np.expand_dims(y, axis=4)
+        y = np.expand_dims(y, axis=5)
+
+        expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_unsorted_axes")
+
+    @staticmethod
+    def export_unsqueeze_negative_axes() -> None:
+        node = onnx.helper.make_node(
+            "Unsqueeze",
+            inputs=["x", "axes"],
+            outputs=["y"],
+        )
+        x = np.random.randn(1, 3, 1, 5).astype(np.float32)
+        axes = np.array([-2]).astype(np.int64)
+        y = np.expand_dims(x, axis=-2)
+        expect(node, inputs=[x, axes], outputs=[y], name="test_unsqueeze_negative_axes")
diff --git a/onnx/backend/test/case/node/upsample.py b/onnx/backend/test/case/node/upsample.py
new file mode 100644
index 0000000..6cc43f1
--- /dev/null
+++ b/onnx/backend/test/case/node/upsample.py
@@ -0,0 +1,58 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx import helper
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Upsample(Base):
+    @staticmethod
+    def export_nearest() -> None:
+        node = onnx.helper.make_node(
+            "Upsample",
+            inputs=["X", "scales"],
+            outputs=["Y"],
+            mode="nearest",
+        )
+
+        data = np.array(
+            [
+                [
+                    [
+                        [1, 2],
+                        [3, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
+
+        output = np.array(
+            [
+                [
+                    [
+                        [1, 1, 1, 2, 2, 2],
+                        [1, 1, 1, 2, 2, 2],
+                        [3, 3, 3, 4, 4, 4],
+                        [3, 3, 3, 4, 4, 4],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        expect(
+            node,
+            inputs=[data, scales],
+            outputs=[output],
+            name="test_upsample_nearest",
+            opset_imports=[helper.make_opsetid("", 9)],
+        )
diff --git a/onnx/backend/test/case/node/where.py b/onnx/backend/test/case/node/where.py
new file mode 100644
index 0000000..cb050ee
--- /dev/null
+++ b/onnx/backend/test/case/node/where.py
@@ -0,0 +1,42 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Where(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Where",
+            inputs=["condition", "x", "y"],
+            outputs=["z"],
+        )
+
+        condition = np.array([[1, 0], [1, 1]], dtype=bool)
+        x = np.array([[1, 2], [3, 4]], dtype=np.float32)
+        y = np.array([[9, 8], [7, 6]], dtype=np.float32)
+        z = np.where(condition, x, y)  # expected output [[1, 8], [3, 4]]
+        expect(node, inputs=[condition, x, y], outputs=[z], name="test_where_example")
+
+    @staticmethod
+    def export_long() -> None:
+        node = onnx.helper.make_node(
+            "Where",
+            inputs=["condition", "x", "y"],
+            outputs=["z"],
+        )
+
+        condition = np.array([[1, 0], [1, 1]], dtype=bool)
+        x = np.array([[1, 2], [3, 4]], dtype=np.int64)
+        y = np.array([[9, 8], [7, 6]], dtype=np.int64)
+        z = np.where(condition, x, y)  # expected output [[1, 8], [3, 4]]
+        expect(
+            node, inputs=[condition, x, y], outputs=[z], name="test_where_long_example"
+        )
diff --git a/onnx/backend/test/case/node/xor.py b/onnx/backend/test/case/node/xor.py
new file mode 100644
index 0000000..ed895a7
--- /dev/null
+++ b/onnx/backend/test/case/node/xor.py
@@ -0,0 +1,76 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.backend.test.case.base import Base
+from onnx.backend.test.case.node import expect
+
+
+class Xor(Base):
+    @staticmethod
+    def export() -> None:
+        node = onnx.helper.make_node(
+            "Xor",
+            inputs=["x", "y"],
+            outputs=["xor"],
+        )
+
+        # 2d
+        x = (np.random.randn(3, 4) > 0).astype(bool)
+        y = (np.random.randn(3, 4) > 0).astype(bool)
+        z = np.logical_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_xor2d")
+
+        # 3d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        y = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        z = np.logical_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_xor3d")
+
+        # 4d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        y = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        z = np.logical_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_xor4d")
+
+    @staticmethod
+    def export_xor_broadcast() -> None:
+        node = onnx.helper.make_node(
+            "Xor",
+            inputs=["x", "y"],
+            outputs=["xor"],
+        )
+
+        # 3d vs 1d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        y = (np.random.randn(5) > 0).astype(bool)
+        z = np.logical_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast3v1d")
+
+        # 3d vs 2d
+        x = (np.random.randn(3, 4, 5) > 0).astype(bool)
+        y = (np.random.randn(4, 5) > 0).astype(bool)
+        z = np.logical_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast3v2d")
+
+        # 4d vs 2d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        y = (np.random.randn(5, 6) > 0).astype(bool)
+        z = np.logical_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v2d")
+
+        # 4d vs 3d
+        x = (np.random.randn(3, 4, 5, 6) > 0).astype(bool)
+        y = (np.random.randn(4, 5, 6) > 0).astype(bool)
+        z = np.logical_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v3d")
+
+        # 4d vs 4d
+        x = (np.random.randn(1, 4, 1, 6) > 0).astype(bool)
+        y = (np.random.randn(3, 1, 5, 6) > 0).astype(bool)
+        z = np.logical_xor(x, y)
+        expect(node, inputs=[x, y], outputs=[z], name="test_xor_bcast4v4d")
diff --git a/onnx/backend/test/case/test_case.py b/onnx/backend/test/case/test_case.py
new file mode 100644
index 0000000..628bf24
--- /dev/null
+++ b/onnx/backend/test/case/test_case.py
@@ -0,0 +1,29 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import numpy as np
+
+    import onnx
+
+
+@dataclass
+class TestCase:
+    name: str
+    model_name: str
+    url: str | None
+    model_dir: str | None
+    model: onnx.ModelProto | None
+    data_sets: Sequence[tuple[Sequence[np.ndarray], Sequence[np.ndarray]]] | None
+    kind: str
+    rtol: float
+    atol: float
+    # Tell PyTest this isn't a real test.
+    __test__: bool = False
diff --git a/onnx/backend/test/case/utils.py b/onnx/backend/test/case/utils.py
new file mode 100644
index 0000000..54a0b27
--- /dev/null
+++ b/onnx/backend/test/case/utils.py
@@ -0,0 +1,45 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import importlib
+import pkgutil
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from onnx import ONNX_ML
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+all_numeric_dtypes = [
+    np.int8,
+    np.int16,
+    np.int32,
+    np.int64,
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+    np.float16,
+    np.float32,
+    np.float64,
+]
+
+
+def import_recursive(package: ModuleType) -> None:
+    """Takes a package and imports all modules underneath it."""
+    pkg_dir = package.__path__
+    module_location = package.__name__
+    for _module_loader, name, ispkg in pkgutil.iter_modules(pkg_dir):
+        module_name = f"{module_location}.{name}"  # Module/package
+        if not ONNX_ML and module_name.startswith(
+            "onnx.backend.test.case.node.ai_onnx_ml"
+        ):
+            continue
+
+        module = importlib.import_module(module_name)
+        if ispkg:
+            import_recursive(module)
diff --git a/onnx/backend/test/cmd_tools.py b/onnx/backend/test/cmd_tools.py
new file mode 100644
index 0000000..4da788e
--- /dev/null
+++ b/onnx/backend/test/cmd_tools.py
@@ -0,0 +1,190 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import warnings
+
+import onnx.backend.test.case.model as model_test
+import onnx.backend.test.case.node as node_test
+from onnx import ONNX_ML, TensorProto, numpy_helper
+
+TOP_DIR = os.path.realpath(os.path.dirname(__file__))
+DATA_DIR = os.path.join(TOP_DIR, "data")
+
+
+def generate_data(args: argparse.Namespace) -> None:
+    def prepare_dir(path: str) -> None:
+        if os.path.exists(path):
+            shutil.rmtree(path)
+        os.makedirs(path)
+
+    # Clean the output directory before generating data for node testcases
+    # It is used to check new generated data is correct in CIs
+    node_root = os.path.join(args.output, "node")
+    original_dir_number = len(
+        [name for name in os.listdir(node_root) if os.path.isfile(name)]
+    )
+    if args.clean and os.path.exists(node_root):
+        for sub_dir in os.listdir(node_root):
+            if ONNX_ML or not sub_dir.startswith("test_ai_onnx_ml_"):
+                shutil.rmtree(os.path.join(node_root, sub_dir))
+
+    cases = model_test.collect_testcases()
+    # If op_type is specified, only include those testcases including the given operator
+    # Otherwise, include all of the testcases
+    if args.diff:
+        cases += node_test.collect_diff_testcases()
+    else:
+        cases += node_test.collect_testcases(args.op_type)
+    node_number = 0
+
+    for case in cases:
+        output_dir = os.path.join(args.output, case.kind, case.name)
+        prepare_dir(output_dir)
+        if case.kind == "node":
+            node_number += 1
+        if case.kind == "real":
+            with open(os.path.join(output_dir, "data.json"), "w") as fi:
+                json.dump(
+                    {
+                        "url": case.url,
+                        "model_name": case.model_name,
+                        "rtol": case.rtol,
+                        "atol": case.atol,
+                    },
+                    fi,
+                    sort_keys=True,
+                )
+        else:
+            assert case.model
+            with open(os.path.join(output_dir, "model.onnx"), "wb") as f:
+                f.write(case.model.SerializeToString())
+            assert case.data_sets
+            for i, (inputs, outputs) in enumerate(case.data_sets):
+                data_set_dir = os.path.join(output_dir, f"test_data_set_{i}")
+                prepare_dir(data_set_dir)
+                for j, input in enumerate(inputs):
+                    with open(os.path.join(data_set_dir, f"input_{j}.pb"), "wb") as f:
+                        if case.model.graph.input[j].type.HasField("map_type"):
+                            f.write(
+                                numpy_helper.from_dict(
+                                    input, case.model.graph.input[j].name
+                                ).SerializeToString()
+                            )
+                        elif case.model.graph.input[j].type.HasField("sequence_type"):
+                            f.write(
+                                numpy_helper.from_list(
+                                    input, case.model.graph.input[j].name
+                                ).SerializeToString()
+                            )
+                        elif case.model.graph.input[j].type.HasField("optional_type"):
+                            f.write(
+                                numpy_helper.from_optional(
+                                    input, case.model.graph.input[j].name
+                                ).SerializeToString()
+                            )
+                        else:
+                            assert case.model.graph.input[j].type.HasField(
+                                "tensor_type"
+                            )
+                            if isinstance(input, TensorProto):
+                                f.write(input.SerializeToString())
+                            else:
+                                f.write(
+                                    numpy_helper.from_array(
+                                        input, case.model.graph.input[j].name
+                                    ).SerializeToString()
+                                )
+                for j, output in enumerate(outputs):
+                    with open(os.path.join(data_set_dir, f"output_{j}.pb"), "wb") as f:
+                        if case.model.graph.output[j].type.HasField("map_type"):
+                            f.write(
+                                numpy_helper.from_dict(
+                                    output, case.model.graph.output[j].name
+                                ).SerializeToString()
+                            )
+                        elif case.model.graph.output[j].type.HasField("sequence_type"):
+                            f.write(
+                                numpy_helper.from_list(
+                                    output, case.model.graph.output[j].name
+                                ).SerializeToString()
+                            )
+                        elif case.model.graph.output[j].type.HasField("optional_type"):
+                            f.write(
+                                numpy_helper.from_optional(
+                                    output, case.model.graph.output[j].name
+                                ).SerializeToString()
+                            )
+                        else:
+                            assert case.model.graph.output[j].type.HasField(
+                                "tensor_type"
+                            )
+                            if isinstance(output, TensorProto):
+                                f.write(output.SerializeToString())
+                            else:
+                                f.write(
+                                    numpy_helper.from_array(
+                                        output, case.model.graph.output[j].name
+                                    ).SerializeToString()
+                                )
+    if not args.clean and node_number != original_dir_number:
+        warnings.warn(
+            "There are some models under 'onnx/backend/test/data/node' which cannot not"
+            " be generated by the script from 'onnx/backend/test/case/node'. Please add"
+            " '--clean' option for 'python onnx/backend/test/cmd_tools.py generate-data'"
+            " to cleanup the existing directories and regenerate them.",
+            Warning,
+            stacklevel=2,
+        )
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser("backend-test-tools")
+    subparsers = parser.add_subparsers()
+
+    subparser = subparsers.add_parser(
+        "generate-data", help="convert testcases to test data."
+    )
+    subparser.add_argument(
+        "-c",
+        "--clean",
+        default=False,
+        action="store_true",
+        help="Clean the output directory before generating data for node testcases.",
+    )
+    subparser.add_argument(
+        "-o",
+        "--output",
+        default=DATA_DIR,
+        help="output directory (default: %(default)s)",
+    )
+    subparser.add_argument(
+        "-t",
+        "--op_type",
+        default=None,
+        help="op_type for test case generation. (generates test data for the specified op_type only.)",
+    )
+    subparser.add_argument(
+        "-d",
+        "--diff",
+        default=False,
+        action="store_true",
+        help="only generates test data for those changed files (compared to the main branch).",
+    )
+    subparser.set_defaults(func=generate_data)
+
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/backend/test/data/light/README.md b/onnx/backend/test/data/light/README.md
new file mode 100644
index 0000000..4e62edc
--- /dev/null
+++ b/onnx/backend/test/data/light/README.md
@@ -0,0 +1,16 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# Light models
+
+The models in this folder were created by replacing
+all float initializers by nodes `ConstantOfShape`
+with function `replace_initializer_by_constant_of_shape`.
+The models are lighter and can be added to the repository
+for unit testing.
+
+Expected outputs were obtained by using CReferenceEvaluator
+implemented in [PR 4952](https://github.com/onnx/onnx/pull/4952).
diff --git a/onnx/backend/test/data/light/light_bvlc_alexnet.onnx b/onnx/backend/test/data/light/light_bvlc_alexnet.onnx
new file mode 100644
index 0000000..afe8c31
Binary files /dev/null and b/onnx/backend/test/data/light/light_bvlc_alexnet.onnx differ
diff --git a/onnx/backend/test/data/light/light_bvlc_alexnet_output_0.pb b/onnx/backend/test/data/light/light_bvlc_alexnet_output_0.pb
new file mode 100644
index 0000000..760873f
--- /dev/null
+++ b/onnx/backend/test/data/light/light_bvlc_alexnet_output_0.pb
@@ -0,0 +1 @@
+
�
J�o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/light/light_densenet121.onnx b/onnx/backend/test/data/light/light_densenet121.onnx
new file mode 100644
index 0000000..e10d5ca
Binary files /dev/null and b/onnx/backend/test/data/light/light_densenet121.onnx differ
diff --git a/onnx/backend/test/data/light/light_densenet121_output_0.pb b/onnx/backend/test/data/light/light_densenet121_output_0.pb
new file mode 100644
index 0000000..fe25af4
--- /dev/null
+++ b/onnx/backend/test/data/light/light_densenet121_output_0.pb
@@ -0,0 +1 @@
+
�


J�L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>L�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/light/light_inception_v1.onnx b/onnx/backend/test/data/light/light_inception_v1.onnx
new file mode 100644
index 0000000..0f0309f
Binary files /dev/null and b/onnx/backend/test/data/light/light_inception_v1.onnx differ
diff --git a/onnx/backend/test/data/light/light_inception_v1_output_0.pb b/onnx/backend/test/data/light/light_inception_v1_output_0.pb
new file mode 100644
index 0000000..760873f
--- /dev/null
+++ b/onnx/backend/test/data/light/light_inception_v1_output_0.pb
@@ -0,0 +1 @@
+
�
J�o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/light/light_inception_v2.onnx b/onnx/backend/test/data/light/light_inception_v2.onnx
new file mode 100644
index 0000000..044db1e
Binary files /dev/null and b/onnx/backend/test/data/light/light_inception_v2.onnx differ
diff --git a/onnx/backend/test/data/light/light_inception_v2_output_0.pb b/onnx/backend/test/data/light/light_inception_v2_output_0.pb
new file mode 100644
index 0000000..760873f
--- /dev/null
+++ b/onnx/backend/test/data/light/light_inception_v2_output_0.pb
@@ -0,0 +1 @@
+
�
J�o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/light/light_resnet50.onnx b/onnx/backend/test/data/light/light_resnet50.onnx
new file mode 100644
index 0000000..5f7553a
Binary files /dev/null and b/onnx/backend/test/data/light/light_resnet50.onnx differ
diff --git a/onnx/backend/test/data/light/light_resnet50_output_0.pb b/onnx/backend/test/data/light/light_resnet50_output_0.pb
new file mode 100644
index 0000000..760873f
--- /dev/null
+++ b/onnx/backend/test/data/light/light_resnet50_output_0.pb
@@ -0,0 +1 @@
+
�
J�o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/light/light_shufflenet.onnx b/onnx/backend/test/data/light/light_shufflenet.onnx
new file mode 100644
index 0000000..9d3817e
Binary files /dev/null and b/onnx/backend/test/data/light/light_shufflenet.onnx differ
diff --git a/onnx/backend/test/data/light/light_shufflenet_output_0.pb b/onnx/backend/test/data/light/light_shufflenet_output_0.pb
new file mode 100644
index 0000000..760873f
--- /dev/null
+++ b/onnx/backend/test/data/light/light_shufflenet_output_0.pb
@@ -0,0 +1 @@
+
�
J�o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/light/light_squeezenet.onnx b/onnx/backend/test/data/light/light_squeezenet.onnx
new file mode 100644
index 0000000..0ea5397
Binary files /dev/null and b/onnx/backend/test/data/light/light_squeezenet.onnx differ
diff --git a/onnx/backend/test/data/light/light_squeezenet_output_0.pb b/onnx/backend/test/data/light/light_squeezenet_output_0.pb
new file mode 100644
index 0000000..499973d
--- /dev/null
+++ b/onnx/backend/test/data/light/light_squeezenet_output_0.pb
@@ -0,0 +1 @@
+
�


J�o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/light/light_vgg19.onnx b/onnx/backend/test/data/light/light_vgg19.onnx
new file mode 100644
index 0000000..5c77d13
Binary files /dev/null and b/onnx/backend/test/data/light/light_vgg19.onnx differ
diff --git a/onnx/backend/test/data/light/light_vgg19_output_0.pb b/onnx/backend/test/data/light/light_vgg19_output_0.pb
new file mode 100644
index 0000000..760873f
--- /dev/null
+++ b/onnx/backend/test/data/light/light_vgg19_output_0.pb
@@ -0,0 +1 @@
+
�
J�o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/light/light_zfnet512.onnx b/onnx/backend/test/data/light/light_zfnet512.onnx
new file mode 100644
index 0000000..28a45d3
Binary files /dev/null and b/onnx/backend/test/data/light/light_zfnet512.onnx differ
diff --git a/onnx/backend/test/data/light/light_zfnet512_output_0.pb b/onnx/backend/test/data/light/light_zfnet512_output_0.pb
new file mode 100644
index 0000000..760873f
--- /dev/null
+++ b/onnx/backend/test/data/light/light_zfnet512_output_0.pb
@@ -0,0 +1 @@
+
�
J�o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:o�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_abs/model.onnx b/onnx/backend/test/data/node/test_abs/model.onnx
new file mode 100644
index 0000000..5228009
Binary files /dev/null and b/onnx/backend/test/data/node/test_abs/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_abs/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_abs/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_abs/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_abs/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_abs/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..414f615
--- /dev/null
+++ b/onnx/backend/test/data/node/test_abs/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_acos/model.onnx b/onnx/backend/test/data/node/test_acos/model.onnx
new file mode 100644
index 0000000..206ab39
Binary files /dev/null and b/onnx/backend/test/data/node/test_acos/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_acos/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_acos/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a61135
--- /dev/null
+++ b/onnx/backend/test/data/node/test_acos/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_acos/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_acos/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..543b7cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_acos/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_acos_example/model.onnx b/onnx/backend/test/data/node/test_acos_example/model.onnx
new file mode 100644
index 0000000..8b29942
Binary files /dev/null and b/onnx/backend/test/data/node/test_acos_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_acos_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_acos_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7c32a2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_acos_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_acos_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_acos_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..598a49d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_acos_example/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
B
yJ�
+@��?�
+�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_acosh/model.onnx b/onnx/backend/test/data/node/test_acosh/model.onnx
new file mode 100644
index 0000000..916010c
Binary files /dev/null and b/onnx/backend/test/data/node/test_acosh/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_acosh/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_acosh/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..23af965
Binary files /dev/null and b/onnx/backend/test/data/node/test_acosh/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_acosh/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_acosh/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..52edf0b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_acosh/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
��@D{,@�#@��@�8@��&@w�@��8@Zm=@@�22@*�@
�@>;@���?ZT�?~/?�
5@�81@Վ7@�P>@%�2@��@�d1@\<�?�N&@~2�?�G<@�6@�@���?��0@�@��@��?j[$@��#@sK$@>9<@o�)@��@��@+@V�?5�(@a�(@յ�?(ճ?�V
@�k@��@\@��>@�^�?��?O��?�n'@��?<<@YZ�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_acosh_example/model.onnx b/onnx/backend/test/data/node/test_acosh_example/model.onnx
new file mode 100644
index 0000000..1fbfea1
Binary files /dev/null and b/onnx/backend/test/data/node/test_acosh_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7c690ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7a9cbb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_acosh_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad/model.onnx b/onnx/backend/test/data/node/test_adagrad/model.onnx
new file mode 100644
index 0000000..324e40e
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0483cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
RJ���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..54656de
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..038e9dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..265567a
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..82851b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..075011c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BX_newJ�b�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..47b03d2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adagrad/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BH_newJ@�?@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/model.onnx b/onnx/backend/test/data/node/test_adagrad_multiple/model.onnx
new file mode 100644
index 0000000..c9dc8c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad_multiple/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0483cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
RJ���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..54656de
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..259b58b
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..eb51654
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..15cbe61
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..62e5b3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..ad3e95e
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_6.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..cb33a3d
Binary files /dev/null and b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/input_7.pb differ
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f84f709
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BX1_newJ�b�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..c8d6212
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
BX2_newJ@��?7@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..ac197e1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

BH1_newJ@�?@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..987572f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adagrad_multiple/test_data_set_0/output_3.pb
@@ -0,0 +1 @@
+
BH2_newJ��@��A
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam/model.onnx b/onnx/backend/test/data/node/test_adam/model.onnx
new file mode 100644
index 0000000..e2c192a
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_adam/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0483cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
RJ���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..54656de
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_adam/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..15244fd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
XJ���?333@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..439d577
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_adam/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e3f3aa9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
B
VJ���?fff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..e0fb178
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
B
HJ���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_adam/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fd42a3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BX_newJd4�?\N*@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_adam/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f5f4916
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
BV_newJ1��?��R@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_adam/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..074ed20
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+
BH_newJ9�M?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam_multiple/model.onnx b/onnx/backend/test/data/node/test_adam_multiple/model.onnx
new file mode 100644
index 0000000..565c7c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0483cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
RJ���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..54656de
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..259b58b
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..eb51654
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..15cbe61
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..62e5b3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..0dd424c
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_6.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..bb84e11
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_7.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_8.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_8.pb
new file mode 100644
index 0000000..3a1c3fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_8.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_9.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_9.pb
new file mode 100644
index 0000000..4d97f4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/input_9.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6554ea
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BX1_newJ�VB?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..84851f0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
BX2_newJd� ?6��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..ca18d87
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

BV1_newJp��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..3244803
Binary files /dev/null and b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_4.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_4.pb
new file mode 100644
index 0000000..8b342ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_4.pb
@@ -0,0 +1 @@
+

BH1_newJ�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_5.pb b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_5.pb
new file mode 100644
index 0000000..dfc933b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_adam_multiple/test_data_set_0/output_5.pb
@@ -0,0 +1 @@
+
BH2_newJZ�?;�A
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_add/model.onnx b/onnx/backend/test/data/node/test_add/model.onnx
new file mode 100644
index 0000000..8aa4ab2
Binary files /dev/null and b/onnx/backend/test/data/node/test_add/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_add/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_add/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_add/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_add/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_add/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1424d72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_add/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_add/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_add/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a83758c
Binary files /dev/null and b/onnx/backend/test/data/node/test_add/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_bcast/model.onnx b/onnx/backend/test/data/node/test_add_bcast/model.onnx
new file mode 100644
index 0000000..2ac8bf7
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dcbe531
--- /dev/null
+++ b/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..725a84b
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_bcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_int16/model.onnx b/onnx/backend/test/data/node/test_add_int16/model.onnx
new file mode 100644
index 0000000..3902f0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_add_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_add_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c394bdc
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_add_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..252607f
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_add_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_add_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2d0adbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_int8/model.onnx b/onnx/backend/test/data/node/test_add_int8/model.onnx
new file mode 100644
index 0000000..7abf09f
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_add_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_add_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..34f6024
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_int8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_add_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4658de3
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_int8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_add_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_add_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..896f711
--- /dev/null
+++ b/onnx/backend/test/data/node/test_add_int8/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BsumJ<+
 
(-( 
!"$%
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_add_uint16/model.onnx b/onnx/backend/test/data/node/test_add_uint16/model.onnx
new file mode 100644
index 0000000..0253330
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_add_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_add_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a2c6589
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_add_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e34a8c9
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_add_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bd4ebfd
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint32/model.onnx b/onnx/backend/test/data/node/test_add_uint32/model.onnx
new file mode 100644
index 0000000..0a03cfb
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_add_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_add_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a46c8f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_add_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..91fc50f
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_add_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..375fdad
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint64/model.onnx b/onnx/backend/test/data/node/test_add_uint64/model.onnx
new file mode 100644
index 0000000..c462b13
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_add_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_add_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e85f5bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_add_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7244608
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_add_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8b82de
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint8/model.onnx b/onnx/backend/test/data/node/test_add_uint8/model.onnx
new file mode 100644
index 0000000..1f2f620
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..11ff1a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..01e06bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e8065e2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_add_uint8/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+BsumJ<*+%		#),#
+"#"#
#
+
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d/model.onnx b/onnx/backend/test/data/node/test_affine_grid_2d/model.onnx
new file mode 100644
index 0000000..c047ff8
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eaf0b5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a5ee231
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..887995f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_affine_grid_2d/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BgridJ��"�@0���:��@����]�@�q��P��@��u�n�A
�J�4�Aiu�i�@Î�����@x����G�@,j����@��Y����@(�.�" �@�f�$��@W������@���:1�@�h��Υ@�=�Ql�@P|��	�@p�ο��1@�����H@>�w��5`@��L�
qw@�!�V�@��쿗�@����c&�?~x�����?e�[�_	@ͧ0�vD#@6���:@<�����Q@�<���@˙i�'�!@��=�x3@�>1ME@�;?�!W@�qR?:�h@�ӊ?+�
@���=�r@(��>5G%@"?�7@8e?>�H@7�?��Z@ҵ?h��?;%�>9A@��4?�@��w?B�(@M��?Ǿ:@L5�?L�L@K��?yv�?%�G?��?�b�?F�@���?˸@���?P�,@�3�?�a>@H�@��?�Ŏ?���?�`�?�e�?���?T�@Ֆ�?�[@�
+@^00@jf@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/model.onnx b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/model.onnx
new file mode 100644
index 0000000..f461594
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eaf0b5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a5ee231
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9a0624e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BgridJ�_�@c��LO�@K����
A�����A�u�A
�K�(A���5ñ@�ٻ�v��@������@B�����@
c\�8��@~�(�yt�@��鿼Nz@}P����@�m����@�m� ��@rP9�a�@�����@؊��@6ǘ���,@��}��H@eJ���d@�=��L�@��Ŀ�<�@t�:��}?�=����?Y�Z��@�?��&��
�?�V�ga@C�}��A3@�:��
@����c#@bY���8@ju�=`.N@���>̓c@�;?8�x@!"�?���?` ܽ��@��T>'@W�?�p<@�qV?��Q@]��?d;g@�߻?��?<�>���?О ?JM@
Fq?��*@���?"@@2J�?�}U@˝�?9��?Hs;?T�?=
�?u�@�`�?��@n��?MZ.@�?��C@Э@�
�?yw�?gظ?˻?@��?��?7@"9@x�@�b@�
2@��.@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/model.onnx b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/model.onnx
new file mode 100644
index 0000000..afea948
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eaf0b5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a5ee231
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9a0624e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_affine_grid_2d_align_corners_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BgridJ�_�@c��LO�@K����
A�����A�u�A
�K�(A���5ñ@�ٻ�v��@������@B�����@
c\�8��@~�(�yt�@��鿼Nz@}P����@�m����@�m� ��@rP9�a�@�����@؊��@6ǘ���,@��}��H@eJ���d@�=��L�@��Ŀ�<�@t�:��}?�=����?Y�Z��@�?��&��
�?�V�ga@C�}��A3@�:��
@����c#@bY���8@ju�=`.N@���>̓c@�;?8�x@!"�?���?` ܽ��@��T>'@W�?�p<@�qV?��Q@]��?d;g@�߻?��?<�>���?О ?JM@
Fq?��*@���?"@@2J�?�}U@˝�?9��?Hs;?T�?=
�?u�@�`�?��@n��?MZ.@�?��C@Э@�
�?yw�?gظ?˻?@��?��?7@"9@x�@�b@�
2@��.@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_expanded/model.onnx b/onnx/backend/test/data/node/test_affine_grid_2d_expanded/model.onnx
new file mode 100644
index 0000000..81538da
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eaf0b5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a5ee231
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..887995f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_affine_grid_2d_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BgridJ��"�@0���:��@����]�@�q��P��@��u�n�A
�J�4�Aiu�i�@Î�����@x����G�@,j����@��Y����@(�.�" �@�f�$��@W������@���:1�@�h��Υ@�=�Ql�@P|��	�@p�ο��1@�����H@>�w��5`@��L�
qw@�!�V�@��쿗�@����c&�?~x�����?e�[�_	@ͧ0�vD#@6���:@<�����Q@�<���@˙i�'�!@��=�x3@�>1ME@�;?�!W@�qR?:�h@�ӊ?+�
@���=�r@(��>5G%@"?�7@8e?>�H@7�?��Z@ҵ?h��?;%�>9A@��4?�@��w?B�(@M��?Ǿ:@L5�?L�L@K��?yv�?%�G?��?�b�?F�@���?˸@���?P�,@�3�?�a>@H�@��?�Ŏ?���?�`�?�e�?���?T�@Ֆ�?�[@�
+@^00@jf@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d/model.onnx b/onnx/backend/test/data/node/test_affine_grid_3d/model.onnx
new file mode 100644
index 0000000..d041c46
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..82f6b17
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..04e4c68
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ed58557
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/model.onnx b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/model.onnx
new file mode 100644
index 0000000..4ba99e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..82f6b17
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..04e4c68
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..08bd417
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/model.onnx b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/model.onnx
new file mode 100644
index 0000000..63df4e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..82f6b17
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..04e4c68
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..08bd417
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_align_corners_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_expanded/model.onnx b/onnx/backend/test/data/node/test_affine_grid_3d_expanded/model.onnx
new file mode 100644
index 0000000..684f6dd
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..82f6b17
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..04e4c68
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ed58557
Binary files /dev/null and b/onnx/backend/test/data/node/test_affine_grid_3d_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/model.onnx b/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/model.onnx
new file mode 100644
index 0000000..e1b7d83
--- /dev/null
+++ b/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/model.onnx
@@ -0,0 +1,19 @@
+backend-test:�

+,
+
x
+
y
z"ArrayFeatureExtractor:
+ai.onnx.ml'test_ai_onnx_ml_array_feature_extractorZ
+
x
+

+
+Z
+
y
+
+
+b
+
z
+

+
+B
+
+ai.onnx.ml

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3a5dd6d
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2aac570
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2d47cc4
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_array_feature_extractor/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/model.onnx b/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/model.onnx
new file mode 100644
index 0000000..9e9789e
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a0e2551
--- /dev/null
+++ b/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..766ea88
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_binarizer/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/model.onnx b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/model.onnx
new file mode 100644
index 0000000..64be277
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0d5645d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2
a2
b2
d2
c2
gB
X
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..07bce06
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/model.onnx b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/model.onnx
new file mode 100644
index 0000000..680ffb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0d5645d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2
a2
b2
d2
c2
gB
X
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..35d1380
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_string_int_no_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/model.onnx b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/model.onnx
new file mode 100644
index 0000000..0f01d3d
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0d5645d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2
a2
b2
d2
c2
gB
X
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..724eb81
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_mapping/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/model.onnx b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/model.onnx
new file mode 100644
index 0000000..93a04c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0d5645d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2
a2
b2
d2
c2
gB
X
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..724eb81
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_label_encoder_tensor_value_only_mapping/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/model.onnx b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/model.onnx
new file mode 100644
index 0000000..ed8705d
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..377ef76
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..431fafb
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_set_membership/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/model.onnx b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/model.onnx
new file mode 100644
index 0000000..97a64f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a727fce
--- /dev/null
+++ b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
XJ0333333�?333333@���Q������(\��?���(\�@R���Q�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..815f1f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_ai_onnx_ml_tree_ensemble_single_tree/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and2d/model.onnx b/onnx/backend/test/data/node/test_and2d/model.onnx
new file mode 100644
index 0000000..b1c8f71
Binary files /dev/null and b/onnx/backend/test/data/node/test_and2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d954177
Binary files /dev/null and b/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f37772
Binary files /dev/null and b/onnx/backend/test/data/node/test_and2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_and2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_and2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6441662
Binary files /dev/null and b/onnx/backend/test/data/node/test_and2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and3d/model.onnx b/onnx/backend/test/data/node/test_and3d/model.onnx
new file mode 100644
index 0000000..09c48f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_and3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..402cb45
Binary files /dev/null and b/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..825b4f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_and3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_and3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_and3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ac2cebf
Binary files /dev/null and b/onnx/backend/test/data/node/test_and3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and4d/model.onnx b/onnx/backend/test/data/node/test_and4d/model.onnx
new file mode 100644
index 0000000..05f7f9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_and4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3c2fb94
Binary files /dev/null and b/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..925bab6
Binary files /dev/null and b/onnx/backend/test/data/node/test_and4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_and4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_and4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5389f48
Binary files /dev/null and b/onnx/backend/test/data/node/test_and4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast3v1d/model.onnx b/onnx/backend/test/data/node/test_and_bcast3v1d/model.onnx
new file mode 100644
index 0000000..77550f3
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast3v1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5cc32fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1500686
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5e19b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast3v1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast3v2d/model.onnx b/onnx/backend/test/data/node/test_and_bcast3v2d/model.onnx
new file mode 100644
index 0000000..1ba9c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast3v2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d784193
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8bab0d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..05a20c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast3v2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v2d/model.onnx b/onnx/backend/test/data/node/test_and_bcast4v2d/model.onnx
new file mode 100644
index 0000000..ff7a9ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..22944e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d7cba2c
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..219a330
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v3d/model.onnx b/onnx/backend/test/data/node/test_and_bcast4v3d/model.onnx
new file mode 100644
index 0000000..8d7668e
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70f33b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7e83c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c8235b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v4d/model.onnx b/onnx/backend/test/data/node/test_and_bcast4v4d/model.onnx
new file mode 100644
index 0000000..d113874
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..024a348
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8e18502
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..da964d4
Binary files /dev/null and b/onnx/backend/test/data/node/test_and_bcast4v4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_example/model.onnx b/onnx/backend/test/data/node/test_argmax_default_axis_example/model.onnx
new file mode 100644
index 0000000..e706e97
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f6f7c0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/model.onnx
new file mode 100644
index 0000000..09e38b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f6f7c0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_example_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_random/model.onnx b/onnx/backend/test/data/node/test_argmax_default_axis_random/model.onnx
new file mode 100644
index 0000000..f14dce1
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..155c0f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/model.onnx
new file mode 100644
index 0000000..5e2c04f
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..155c0f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_default_axis_random_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_argmax_keepdims_example/model.onnx
new file mode 100644
index 0000000..c712b21
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7fe4182
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/model.onnx
new file mode 100644
index 0000000..2ae685a
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60d9eeb
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_example_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_argmax_keepdims_random/model.onnx
new file mode 100644
index 0000000..28cc028
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b447f5f
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/model.onnx
new file mode 100644
index 0000000..4cf0fde
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b447f5f
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_keepdims_random_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/model.onnx
new file mode 100644
index 0000000..b8d0008
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7fe4182
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/model.onnx
new file mode 100644
index 0000000..f56a832
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60d9eeb
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/model.onnx
new file mode 100644
index 0000000..2f30fbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..50b682b
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/model.onnx
new file mode 100644
index 0000000..0e362cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..50b682b
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_argmax_no_keepdims_example/model.onnx
new file mode 100644
index 0000000..bfee8ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e8f8fde
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/model.onnx
new file mode 100644
index 0000000..75caba3
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..15b429c
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_argmax_no_keepdims_random/model.onnx
new file mode 100644
index 0000000..7729c59
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..993e0e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/model.onnx
new file mode 100644
index 0000000..91cebe5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..993e0e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmax_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_example/model.onnx b/onnx/backend/test/data/node/test_argmin_default_axis_example/model.onnx
new file mode 100644
index 0000000..66e0e5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..931446f
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..434e6e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/model.onnx
new file mode 100644
index 0000000..72599f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..434e6e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_example_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_random/model.onnx b/onnx/backend/test/data/node/test_argmin_default_axis_random/model.onnx
new file mode 100644
index 0000000..648c7e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ed2a8d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/model.onnx
new file mode 100644
index 0000000..e118987
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ed2a8d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_default_axis_random_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_argmin_keepdims_example/model.onnx
new file mode 100644
index 0000000..4f1ce41
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..931446f
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..19a64be
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/model.onnx
new file mode 100644
index 0000000..a5ca545
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..19a64be
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_example_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_argmin_keepdims_random/model.onnx
new file mode 100644
index 0000000..a7c0839
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a6ab81d
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/model.onnx
new file mode 100644
index 0000000..f31101a
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a6ab81d
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_keepdims_random_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/model.onnx
new file mode 100644
index 0000000..8561632
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..931446f
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..19a64be
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/model.onnx
new file mode 100644
index 0000000..c8b7380
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..19a64be
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_example_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/model.onnx
new file mode 100644
index 0000000..bb0c4a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3a52213
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/model.onnx
new file mode 100644
index 0000000..566eb9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3a52213
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_negative_axis_keepdims_random_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_argmin_no_keepdims_example/model.onnx
new file mode 100644
index 0000000..cb56213
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..931446f
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3b84db5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/model.onnx
new file mode 100644
index 0000000..3191a66
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1821ab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3b84db5
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_example_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_argmin_no_keepdims_random/model.onnx
new file mode 100644
index 0000000..bb618f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0024537
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/model.onnx b/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/model.onnx
new file mode 100644
index 0000000..a05215b
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edce899
--- /dev/null
+++ b/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?�1�?�0A�D	�^����o��@4�@���@j(A$v�@�9E�扳@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0024537
Binary files /dev/null and b/onnx/backend/test/data/node/test_argmin_no_keepdims_random_select_last_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_asin/model.onnx b/onnx/backend/test/data/node/test_asin/model.onnx
new file mode 100644
index 0000000..e7d9804
Binary files /dev/null and b/onnx/backend/test/data/node/test_asin/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_asin/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_asin/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a61135
--- /dev/null
+++ b/onnx/backend/test/data/node/test_asin/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_asin/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_asin/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..906d77b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_asin/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
ĸ?P
L?*�%?�?���>��3?J��>���?8s�?l{�>��i?�? �?�_�?���=ت�=�<��{?#Hd?��?���?fm?C��>F@e?[��=��1?M>`H�?T�?���>��>Z�b?%��>$�?c�<um*?�(?3*?��?D@?{H�>]��>k�E?9�v=;�:?q-<?�
Y>�c>N�>X��>�S?/x�>L��?)Z�=�yW>��%>�06?�>a�>��|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_asin_example/model.onnx b/onnx/backend/test/data/node/test_asin_example/model.onnx
new file mode 100644
index 0000000..22ddea6
Binary files /dev/null and b/onnx/backend/test/data/node/test_asin_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_asin_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_asin_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7c32a2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_asin_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_asin_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_asin_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2ef8fda
Binary files /dev/null and b/onnx/backend/test/data/node/test_asin_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_asinh/model.onnx b/onnx/backend/test/data/node/test_asinh/model.onnx
new file mode 100644
index 0000000..96d1db4
Binary files /dev/null and b/onnx/backend/test/data/node/test_asinh/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_asinh/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_asinh/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_asinh/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_asinh/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_asinh/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2067934
--- /dev/null
+++ b/onnx/backend/test/data/node/test_asinh/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
ɚ�?���>%�]?,��?)��?�~]��{X?ng��ӽ'��>��>���?A�3?b��=�c�>�ѧ><��?��P�
ȝ>!<F��Wտ�??>H?��/��q�?�����\;=
�>�W=�?��?�	>@G�>�L�����\����t>!��?M=�?���v����Pj��$��Q馿��?����I�پ�P���	7?LϠ�D<X��4N�4u�>bQ��-s����漎�>� �=���>���ߵ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_asinh_example/model.onnx b/onnx/backend/test/data/node/test_asinh_example/model.onnx
new file mode 100644
index 0000000..eb47788
Binary files /dev/null and b/onnx/backend/test/data/node/test_asinh_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fc85f0a
Binary files /dev/null and b/onnx/backend/test/data/node/test_asinh_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_atan/model.onnx b/onnx/backend/test/data/node/test_atan/model.onnx
new file mode 100644
index 0000000..4f2f5de
Binary files /dev/null and b/onnx/backend/test/data/node/test_atan/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_atan/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_atan/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_atan/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_atan/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_atan/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c2e5ea7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_atan/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
#
�?~��>�OF?V�?�"�?�F�܂B?~��p�ҽ�z�>4~>|�w?��&?���=���>��>� {?�4O��W�>=�4��F���3?{6?�r#�z�?m�w��K;=�{=�}#~?�%y?j>��>��9�:8���l����>�fc?0�`?�3���N��� O�u��4���m�?jS�fӾH�e�c.)?���d�V�B�:�(�>Q��'8^����s3�>��=�b�>ٵ�t*��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_atan_example/model.onnx b/onnx/backend/test/data/node/test_atan_example/model.onnx
new file mode 100644
index 0000000..bfe9894
Binary files /dev/null and b/onnx/backend/test/data/node/test_atan_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_atan_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_atan_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_atan_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_atan_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_atan_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4a268e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_atan_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_atanh/model.onnx b/onnx/backend/test/data/node/test_atanh/model.onnx
new file mode 100644
index 0000000..a1db102
Binary files /dev/null and b/onnx/backend/test/data/node/test_atanh/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_atanh/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_atanh/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a61135
--- /dev/null
+++ b/onnx/backend/test/data/node/test_atanh/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_atanh/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_atanh/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..deac620
--- /dev/null
+++ b/onnx/backend/test/data/node/test_atanh/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
��?q�e?̍2?eo?�~�>+�D?�@�>B�?�W�?���>���?�?�%?/9�?0��=��=Ԧ�<�*�?5�?���?C�@�R�?���>��?w]�=�B?��>
+��??1?���>���>��?
!�>;,%?��<Ϟ8?W6?�T8?۸�?;U?��>���>��\?��v=�
N?��O?��Z>g�>(3�>�&�>)�%?��>��$@���=�Y>�&>��G?��>T^
?�v>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_atanh_example/model.onnx b/onnx/backend/test/data/node/test_atanh_example/model.onnx
new file mode 100644
index 0000000..d0efa30
Binary files /dev/null and b/onnx/backend/test/data/node/test_atanh_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7c32a2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b2bac68
Binary files /dev/null and b/onnx/backend/test/data/node/test_atanh_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/model.onnx b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/model.onnx
new file mode 100644
index 0000000..87a6744
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2a5058a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..835435f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bb92ddc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�
�nX?ok\??c�=w�?8X{>?�;?�e?��?#�?FB�=VB
+?�I>�S?a0�>ʋD?��F=R��=%/?X�?W?.�W?���>�eO?T�?�=m?ǻ*?�K>���>m�]?�X�>��A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..88016e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ac027bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/model.onnx
new file mode 100644
index 0000000..4a0df33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2a5058a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..835435f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bb92ddc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�
�nX?ok\??c�=w�?8X{>?�;?�e?��?#�?FB�=VB
+?�I>�S?a0�>ʋD?��F=R��=%/?X�?W?.�W?���>�eO?T�?�=m?ǻ*?�K>���>m�]?�X�>��A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..88016e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ac027bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_boolmask_fullymasked_row_nan_robustness_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/model.onnx b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/model.onnx
new file mode 100644
index 0000000..783364a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..55926c9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
QJ�
�G?
>s>�S?W;w?c�x?�*�>5�?�F?�@$?0�8?u�=^Θ>˪o=Yh[?��>�
+.? 7�>*��>8<�w�>��r?� _>D��>"�j?k�=K�=y<!?=�_?n�<�??\P?��=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4aa9d08
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ�
u
(?_?G��>��t?��I7��|>�T6?�/�>wҍ>�2?5&k?�Wz>9��>B��>�7�>�?��E?T�=F�/?�Z?7L
>!?�=�s{>�m>�
m?].?�\s>w�?p??��=#�V?	��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..50190c7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ�
Y>��C>/5�>;G6?�$|?�_?d��>x��=Q�i?Dֺ>�h>�W_?��>�
r>l?;]?�|u?��>�
>��B?*yN>��3>���>�6�>�w?nu>�4X?3^+?@��=F��=jw?��F>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..88016e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f9135a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..74a2ee2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/model.onnx
new file mode 100644
index 0000000..f2b8d42
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..55926c9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
QJ�
�G?
>s>�S?W;w?c�x?�*�>5�?�F?�@$?0�8?u�=^Θ>˪o=Yh[?��>�
+.? 7�>*��>8<�w�>��r?� _>D��>"�j?k�=K�=y<!?=�_?n�<�??\P?��=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4aa9d08
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ�
u
(?_?G��>��t?��I7��|>�T6?�/�>wҍ>�2?5&k?�Wz>9��>B��>�7�>�?��E?T�=F�/?�Z?7L
>!?�=�s{>�m>�
m?].?�\s>w�?p??��=#�V?	��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..50190c7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ�
Y>��C>/5�>;G6?�$|?�_?d��>x��=Q�i?Dֺ>�h>�W_?��>�
r>l?;]?�|u?��>�
>��B?*yN>��3>���>�6�>�w?nu>�4X?3^+?@��=F��=jw?��F>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..88016e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f9135a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..74a2ee2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_23_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/model.onnx b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/model.onnx
new file mode 100644
index 0000000..5b1bde4
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..55926c9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
QJ�
�G?
>s>�S?W;w?c�x?�*�>5�?�F?�@$?0�8?u�=^Θ>˪o=Yh[?��>�
+.? 7�>*��>8<�w�>��r?� _>D��>"�j?k�=K�=y<!?=�_?n�<�??\P?��=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4aa9d08
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ�
u
(?_?G��>��t?��I7��|>�T6?�/�>wҍ>�2?5&k?�Wz>9��>B��>�7�>�?��E?T�=F�/?�Z?7L
>!?�=�s{>�m>�
m?].?�\s>w�?p??��=#�V?	��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..50190c7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ�
Y>��C>/5�>;G6?�$|?�_?d��>x��=Q�i?Dֺ>�h>�W_?��>�
r>l?;]?�|u?��>�
>��B?*yN>��3>���>�6�>�w?nu>�4X?3^+?@��=F��=jw?��F>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..88016e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f9135a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..74a2ee2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/model.onnx
new file mode 100644
index 0000000..663e819
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..55926c9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
QJ�
�G?
>s>�S?W;w?c�x?�*�>5�?�F?�@$?0�8?u�=^Θ>˪o=Yh[?��>�
+.? 7�>*��>8<�w�>��r?� _>D��>"�j?k�=K�=y<!?=�_?n�<�??\P?��=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4aa9d08
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ�
u
(?_?G��>��t?��I7��|>�T6?�/�>wҍ>�2?5&k?�Wz>9��>B��>�7�>�?��E?T�=F�/?�Z?7L
>!?�=�s{>�m>�
m?].?�\s>w�?p??��=#�V?	��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..50190c7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ�
Y>��C>/5�>;G6?�$|?�_?d��>x��=Q�i?Dֺ>�h>�W_?��>�
r>l?;]?�|u?��>�
>��B?*yN>��3>���>�6�>�w?nu>�4X?3^+?@��=F��=jw?��F>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..88016e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f9135a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..74a2ee2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_fullymasked_qk_matmul_output_mode3_zero_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/model.onnx b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/model.onnx
new file mode 100644
index 0000000..7efa9c9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..590054a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0bf70ae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+B
KJ@�8E-\81j9�/7;a:Z,�;F9�9�9;I07:�:�:w'?6�6*8�7,0�;4,�8�8�;Q2U-
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..4e6425f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

+B
VJ@;$]:%:�:T;b4�3�4�9L-g9�:�9H:�53�3�9,C7�7!9�.�8�; 8�8�;�:�7!-
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..88016e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab9e626
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..4f06493
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/model.onnx
new file mode 100644
index 0000000..5e9939a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..590054a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0bf70ae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+B
KJ@�8E-\81j9�/7;a:Z,�;F9�9�9;I07:�:�:w'?6�6*8�7,0�;4,�8�8�;Q2U-
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..4e6425f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

+B
VJ@;$]:%:�:T;b4�3�4�9L-g9�:�9H:�53�3�9,C7�7!9�.�8�; 8�8�;�:�7!-
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..88016e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab9e626
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..4f06493
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_24_qk_matmul_output_mode3_softmax_precision_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d/model.onnx b/onnx/backend/test/data/node/test_attention_3d/model.onnx
new file mode 100644
index 0000000..4c0d340
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1ae25a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask/model.onnx b/onnx/backend/test/data/node/test_attention_3d_attn_mask/model.onnx
new file mode 100644
index 0000000..cf78feb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4afd171
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/model.onnx
new file mode 100644
index 0000000..cbd0766
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4afd171
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_attn_mask_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal/model.onnx b/onnx/backend/test/data/node/test_attention_3d_causal/model.onnx
new file mode 100644
index 0000000..2753830
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6865961
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/model.onnx
new file mode 100644
index 0000000..ae7ad19
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6865961
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/model.onnx
new file mode 100644
index 0000000..532be27
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..267443f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/model.onnx
new file mode 100644
index 0000000..6c196d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..6b3ed4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c115925
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/model.onnx
new file mode 100644
index 0000000..e65514d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..6b3ed4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c115925
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/model.onnx
new file mode 100644
index 0000000..98c4dec
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..16af994
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/model.onnx
new file mode 100644
index 0000000..182db5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..16af994
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/model.onnx
new file mode 100644
index 0000000..95c5847
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..267443f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/model.onnx
new file mode 100644
index 0000000..4d61a8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3ffc018
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/model.onnx
new file mode 100644
index 0000000..b9e44d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3ffc018
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_scaled_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/model.onnx
new file mode 100644
index 0000000..43ad5ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6cb5c75
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/model.onnx
new file mode 100644
index 0000000..c5ce28b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6cb5c75
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_sizes_softcap_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/model.onnx
new file mode 100644
index 0000000..7764504
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..28c2517
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bc6d46e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..f1cf5d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..917edd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..027b3b7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..f56f359
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/model.onnx
new file mode 100644
index 0000000..d269308
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0cb61fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..28c2517
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bc6d46e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..f1cf5d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..917edd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..027b3b7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..f56f359
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_expanded/model.onnx
new file mode 100644
index 0000000..ca78fe6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1ae25a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa/model.onnx
new file mode 100644
index 0000000..0e58b64
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f7cd9c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/model.onnx
new file mode 100644
index 0000000..fd0d191
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..7e68778
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`�l>;��>��L?!�t?��>��S?&��=�L"?�C@?��>��>u�d?� �=�>�<�0?���>�vL?�gl?�*�>���>���>�?��{?<�2?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..56768be
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/model.onnx
new file mode 100644
index 0000000..c8dd553
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..7e68778
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`�l>;��>��L?!�t?��>��S?&��=�L"?�C@?��>��>u�d?� �=�>�<�0?���>�vL?�gl?�*�>���>���>�?��{?<�2?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..56768be
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_attn_mask_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/model.onnx
new file mode 100644
index 0000000..90543de
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9e06750
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/model.onnx
new file mode 100644
index 0000000..79b9053
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9e06750
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/model.onnx
new file mode 100644
index 0000000..16fa4eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f7cd9c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/model.onnx
new file mode 100644
index 0000000..4414920
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bfb6762
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/model.onnx
new file mode 100644
index 0000000..5fa7efd
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bfb6762
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_scaled_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/model.onnx
new file mode 100644
index 0000000..9162dd6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..862e0f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/model.onnx
new file mode 100644
index 0000000..f80a559
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..862e0f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_softcap_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/model.onnx
new file mode 100644
index 0000000..fe61215
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557a7e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..584b6c4
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..d360588
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c9b2bfe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..fd8ce4a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..99c8a9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/model.onnx
new file mode 100644
index 0000000..86cb94e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d14cd2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8579eb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aa77b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557a7e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..584b6c4
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..d360588
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c9b2bfe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..fd8ce4a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..99c8a9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_gqa_with_past_and_present_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled/model.onnx b/onnx/backend/test/data/node/test_attention_3d_scaled/model.onnx
new file mode 100644
index 0000000..8d97712
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_scaled/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1496060
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_scaled/test_data_set_0/output_0.pb
@@ -0,0 +1,7 @@
+
B
YJ��wY>�Q?5��>Q-�>N��>��>>��>���>�/?D��>�?�@?T��>e�?�	?�'?��,?��>C��>�5-?ǡ�>��>��"?X�$?*vY>�Z?A��>{7�>S��>���>���>V�>�t/?Z��>�B?
+l?)��>I�?o�?��&?�-?���>��>�5-?u��>!��>�"?'�$?��X>�V?��>ꮟ>�ժ>ޝ�>	e�>Yl�>�/?��>�?~F?<��>�z?�?,�&?�-?Q"�>a��>�"-?���>�
�>*�"?��$?�Y>2B?���>N��>�Ъ>��>>
��>]}/?"��> ?�V?=m�>�?��?��&?C-?`��>,��>�A-?C��> �>l�"?y�$?�+?ź�>��?�F;?
+�
?�p�>��>��>
w	?,�>���>2t*?�Qx>U�>O��>)	?��/?��>��	?& {>)��>�f?Wl�>���>P+?8��>�
+?VB;?�
?Qh�>�س>���>��	?2��>w�>��*?Cux>V0�>A��>��?i�/?L��>�
+?�{>B��>�H?�[�>��>m
++?'[�>��?{C;?C�
?�q�>,�>���>tA	?��>H��>6u*?Z�w>���>Ռ�>/�?��/?�K�>u
+?��z>���>#U?�s�>���>�+?Eڱ>0�?�N;?D�
?O�>&г>��>�x	?A�>��>�*?�{x>
\�>ݢ�>�	?X�/?�]�>C�	?H�z>�p�>�d?�#�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/model.onnx
new file mode 100644
index 0000000..b2e2f02
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1496060
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_scaled_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,7 @@
+
B
YJ��wY>�Q?5��>Q-�>N��>��>>��>���>�/?D��>�?�@?T��>e�?�	?�'?��,?��>C��>�5-?ǡ�>��>��"?X�$?*vY>�Z?A��>{7�>S��>���>���>V�>�t/?Z��>�B?
+l?)��>I�?o�?��&?�-?���>��>�5-?u��>!��>�"?'�$?��X>�V?��>ꮟ>�ժ>ޝ�>	e�>Yl�>�/?��>�?~F?<��>�z?�?,�&?�-?Q"�>a��>�"-?���>�
�>*�"?��$?�Y>2B?���>N��>�Ъ>��>>
��>]}/?"��> ?�V?=m�>�?��?��&?C-?`��>,��>�A-?C��> �>l�"?y�$?�+?ź�>��?�F;?
+�
?�p�>��>��>
w	?,�>���>2t*?�Qx>U�>O��>)	?��/?��>��	?& {>)��>�f?Wl�>���>P+?8��>�
+?VB;?�
?Qh�>�س>���>��	?2��>w�>��*?Cux>V0�>A��>��?i�/?L��>�
+?�{>B��>�H?�[�>��>m
++?'[�>��?{C;?C�
?�q�>,�>���>tA	?��>H��>6u*?Z�w>���>Ռ�>/�?��/?�K�>u
+?��z>���>#U?�s�>���>�+?Eڱ>0�?�N;?D�
?O�>&г>��>�x	?A�>��>�*?�{x>
\�>ݢ�>�	?X�/?�]�>C�	?H�z>�p�>�d?�#�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap/model.onnx b/onnx/backend/test/data/node/test_attention_3d_softcap/model.onnx
new file mode 100644
index 0000000..bbbc143
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ba55e58
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/model.onnx
new file mode 100644
index 0000000..63596fd
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ba55e58
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_softcap_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification/model.onnx b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/model.onnx
new file mode 100644
index 0000000..ee02f0a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c862907
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f1779c1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ`���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f66b898
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ`���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5cd70fc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_transpose_verification/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
YJ`���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/model.onnx
new file mode 100644
index 0000000..c376f11
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c862907
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f1779c1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ`���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f66b898
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ`���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5cd70fc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_3d_transpose_verification_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
YJ`���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/model.onnx
new file mode 100644
index 0000000..545bc81
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b968d52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/model.onnx
new file mode 100644
index 0000000..7fd0430
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b968d52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/model.onnx
new file mode 100644
index 0000000..10fcd8e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b968d52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..86e26cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/model.onnx
new file mode 100644
index 0000000..5e316bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b968d52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..22ce0ae
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/model.onnx
new file mode 100644
index 0000000..bb995df
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b968d52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..22ce0ae
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/model.onnx
new file mode 100644
index 0000000..d74654b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b968d52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..86e26cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/model.onnx
new file mode 100644
index 0000000..01ecbb3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ce00052
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..b21ebfc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/model.onnx
new file mode 100644
index 0000000..73be609
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ce00052
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..b21ebfc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softcap_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/model.onnx
new file mode 100644
index 0000000..7e152f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b968d52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..0076e0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/model.onnx
new file mode 100644
index 0000000..1fb55b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91fda9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a94b5db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3887003
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b968d52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3a75a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c4bd2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..0076e0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_3d_with_past_and_present_qk_matmul_softmax_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d/model.onnx b/onnx/backend/test/data/node/test_attention_4d/model.onnx
new file mode 100644
index 0000000..787ae98
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..440196c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask/model.onnx
new file mode 100644
index 0000000..d088601
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..593e426
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/model.onnx
new file mode 100644
index 0000000..0846201
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..95791ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9d4ed92
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/model.onnx
new file mode 100644
index 0000000..d9c2aee
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..95791ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3612d70
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/model.onnx
new file mode 100644
index 0000000..bce7b4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..95791ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3612d70
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/model.onnx
new file mode 100644
index 0000000..050abc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..95791ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9d4ed92
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_3d_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/model.onnx
new file mode 100644
index 0000000..3ade479
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..c0ce7e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4ebae76
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/model.onnx
new file mode 100644
index 0000000..0b00034
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..c0ce7e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..98d59c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/model.onnx
new file mode 100644
index 0000000..9ecb7d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..c0ce7e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..98d59c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/model.onnx
new file mode 100644
index 0000000..7c34cc0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..c0ce7e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4ebae76
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_4d_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/model.onnx
new file mode 100644
index 0000000..74761b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..df07dea
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+	B	attn_maskJ
























\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..440196c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/model.onnx
new file mode 100644
index 0000000..02c0fa1
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..5ab44c4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+	B	attn_maskJ�

















































































































































\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..440196c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/model.onnx
new file mode 100644
index 0000000..73c2553
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..5ab44c4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+	B	attn_maskJ�

















































































































































\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..440196c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_4d_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/model.onnx
new file mode 100644
index 0000000..33cbcfe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..df07dea
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+	B	attn_maskJ
























\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..440196c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_bool_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/model.onnx
new file mode 100644
index 0000000..d54d051
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..593e426
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_attn_mask_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal/model.onnx
new file mode 100644
index 0000000..761c8db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cc35016
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/model.onnx
new file mode 100644
index 0000000..3e97005
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cc35016
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/model.onnx
new file mode 100644
index 0000000..23d4632
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4c65655
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
B
QJ���8>���<�*�>E�9?�$�>��>�fQ<ň�>>q?��Y?��:?��=��d?vn[?w)>��!?@ͧ<��=���>ij!>|LB?~zQ?�r�>�9�>���=��=5u6?�{?
+d=���>���>'Y?��7?� ?i
?`�r?��|?l�>��u>7�K?n�=箺>h�=*��>�$�=p��>DJ?Q�g?<�J?Z�?b�?_�>q�,>�Z�>q�;?:ˀ=5ة<�BE?O��>�3?/<?��n?���>-��>){N?��C?�'?��O?1h$?u?��> �<?G(s?�1�>�?9�>O�>���=�u�<cxB?
��>
r?vm=?[�>a8�>�->9;K?�AU?b�;?N`?�%?e12?��E>��D?��>0<�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..87e571a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ba67bf4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_2.pb
@@ -0,0 +1,3 @@
+
B
VJ��Y=5��=�4'?��+?�8�=b[�=�.�<p&?cI�>��v>�*?��=aR	?�6�=���=�$+??�J?U��>��>��3?���={�>��g?��r?9E=r�H;�D?�\�>�.C?��$?�[�>P�5?L�?���<Y��>�a?��G?_�'?�?�
Q?�*�>&��>�r!?(*R?��>��,>-e�>���>���=�� ?�e?�4�>@�t?��>�&	?	z?��5?i
?�*A?WU�>�8?z�c>j{�=^b?(?��>��=F>o? ��=ɫw?��>L�>"�p?w�u?�^3?I�t?t-3>�L[?FB?�S�>ϯ?1��=ؿJ?R$?08�=;�`>_�>Պ�>C)l>�Y�>�-
?g�>��@?��>�o�>��?x!>;d?���=�?�w?&�><�2?k�y?��~?�
+�>2 ?�?q?��?q_?O�2?%%=�>��d?��>N1�>�>��#>G;+?"j�>��a?*�0=\�_?!,�=�R?C��>|=?���>5W">��r?py$?��[>(�?�V>���>�`?�:?j�=C0E>z��>�"?\t[?��?��O?CJ�>*;@>�3�>i��<bo�>'�"?}�W?�mp>!�4?�@?��0?��v?3s?��>�k	?/	�;}J�;=��>���>}8
+>)e�>_6$?A�?���>�!E?��Z=�b?��-?
��>S1?9rp?��'?�+?��3?!jj?ڪc?��>ݻ�<�=�>�a�>�d}>�#�>�p?��A>�S�>9BU?A5>�j�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..a66ca52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..a6928b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad49711
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
B
YJ�2�>%�'>��(?�T�>�:�>`�=A�>=��(?g��>�a�>��?1�?g�m>��)>2��>�E?�>��G>�?�:?c��>��>O��>�\G?��>k�?�7U?oI�>x�Y?��>��>g�N?7�>�	?N?�F?,o??�~�>��"?�}
?x�/?x?��9?���> o;?`��>a�	?$�?�3?�T�>�8&?	~?S��>�60?�z�>x�?6�?�S?�
+?�>+?�/�>�T3?�I�>�
+?��
+?B)?���>�BA?m�>�b%?L��>���>���>y�>�w�>�0�>	T?]9%?�F_>a��>�W�>1�
?i�>Q��>�	?318?���>�?�#�>�.?�2?3�>�'�>��&?"�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/model.onnx
new file mode 100644
index 0000000..a5bc1ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4c65655
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
B
QJ���8>���<�*�>E�9?�$�>��>�fQ<ň�>>q?��Y?��:?��=��d?vn[?w)>��!?@ͧ<��=���>ij!>|LB?~zQ?�r�>�9�>���=��=5u6?�{?
+d=���>���>'Y?��7?� ?i
?`�r?��|?l�>��u>7�K?n�=箺>h�=*��>�$�=p��>DJ?Q�g?<�J?Z�?b�?_�>q�,>�Z�>q�;?:ˀ=5ة<�BE?O��>�3?/<?��n?���>-��>){N?��C?�'?��O?1h$?u?��> �<?G(s?�1�>�?9�>O�>���=�u�<cxB?
��>
r?vm=?[�>a8�>�->9;K?�AU?b�;?N`?�%?e12?��E>��D?��>0<�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..87e571a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ba67bf4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,3 @@
+
B
VJ��Y=5��=�4'?��+?�8�=b[�=�.�<p&?cI�>��v>�*?��=aR	?�6�=���=�$+??�J?U��>��>��3?���={�>��g?��r?9E=r�H;�D?�\�>�.C?��$?�[�>P�5?L�?���<Y��>�a?��G?_�'?�?�
Q?�*�>&��>�r!?(*R?��>��,>-e�>���>���=�� ?�e?�4�>@�t?��>�&	?	z?��5?i
?�*A?WU�>�8?z�c>j{�=^b?(?��>��=F>o? ��=ɫw?��>L�>"�p?w�u?�^3?I�t?t-3>�L[?FB?�S�>ϯ?1��=ؿJ?R$?08�=;�`>_�>Պ�>C)l>�Y�>�-
?g�>��@?��>�o�>��?x!>;d?���=�?�w?&�><�2?k�y?��~?�
+�>2 ?�?q?��?q_?O�2?%%=�>��d?��>N1�>�>��#>G;+?"j�>��a?*�0=\�_?!,�=�R?C��>|=?���>5W">��r?py$?��[>(�?�V>���>�`?�:?j�=C0E>z��>�"?\t[?��?��O?CJ�>*;@>�3�>i��<bo�>'�"?}�W?�mp>!�4?�@?��0?��v?3s?��>�k	?/	�;}J�;=��>���>}8
+>)e�>_6$?A�?���>�!E?��Z=�b?��-?
��>S1?9rp?��'?�+?��3?!jj?ڪc?��>ݻ�<�=�>�a�>�d}>�#�>�p?��A>�S�>9BU?A5>�j�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..a66ca52
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..a6928b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad49711
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_attn_mask_composition_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
B
YJ�2�>%�'>��(?�T�>�:�>`�=A�>=��(?g��>�a�>��?1�?g�m>��)>2��>�E?�>��G>�?�:?c��>��>O��>�\G?��>k�?�7U?oI�>x�Y?��>��>g�N?7�>�	?N?�F?,o??�~�>��"?�}
?x�/?x?��9?���> o;?`��>a�	?$�?�3?�T�>�8&?	~?S��>�60?�z�>x�?6�?�S?�
+?�>+?�/�>�T3?�I�>�
+?��
+?B)?���>�BA?m�>�b%?L��>���>���>y�>�w�>�0�>	T?]9%?�F_>a��>�W�>1�
?i�>Q��>�	?318?���>�?�#�>�.?�2?3�>�'�>��&?"�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/model.onnx
new file mode 100644
index 0000000..57c5863
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4151a77
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
B
QJ���>�s=?:ц>%�?��n<
3k?@�f?��=��t?��>�Q�>D(?��q?�LZ?�;o?WR
?c��>q�D?�$><�C?Oy�<�t
+>� �=媞>R�+?E�>h�P?�D�>%�;?�3?0��>�V�>bz?��?�Gs?IyD?�3S?(3�>��>��>`�~?b�5>�lv?���>g�>�!�>�X�>W�>�=&��=z�;?
�"?���<䯙>*'b>�\a=t�?g.�>�E=�?D�M?��=O�>E$?H�>��
?�A�>�
e???�u?,C�>���>Lqc?'�U>�q?vw�=�[?�0�<PN*?�+#?��\?+q?;)�>X�+?�l?��?�)�>f��>�9�>Ou?���>{Qr?�p[?�]0?�zW;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5b8a564
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1acc93b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..bbdac1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d58d0ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/model.onnx
new file mode 100644
index 0000000..6cdd6bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4151a77
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
B
QJ���>�s=?:ц>%�?��n<
3k?@�f?��=��t?��>�Q�>D(?��q?�LZ?�;o?WR
?c��>q�D?�$><�C?Oy�<�t
+>� �=媞>R�+?E�>h�P?�D�>%�;?�3?0��>�V�>bz?��?�Gs?IyD?�3S?(3�>��>��>`�~?b�5>�lv?���>g�>�!�>�X�>W�>�=&��=z�;?
�"?���<䯙>*'b>�\a=t�?g.�>�E=�?D�M?��=O�>E$?H�>��
?�A�>�
e???�u?,C�>���>Lqc?'�U>�q?vw�=�[?�0�<PN*?�+#?��\?+q?;)�>X�+?�l?��?�)�>f��>�9�>Ou?���>{Qr?�p[?�]0?�zW;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5b8a564
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1acc93b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..bbdac1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d58d0ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_batch_prefill_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/model.onnx
new file mode 100644
index 0000000..85d46a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1c1e8d5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
QJ�
��>0g8?���8V˚>-G>�=��>>V��>%�>��	?���>�j/?�[Q>N�`?�[�<£+?���>L?��>�J>��L?��w?"y�><1?
+[`?�e?�+�=��=�->��`?j�=k��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5274c3d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..8fde5ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..cc85f91
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..441aff1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+

B
YJ�
��i?!5 ?&��<!�E?s?��O?��?e X>��3?�%�>(��<Œ#?�� ?!N:?�?*Z�>	g�>���>��
+?�UM?�?�Z`=Q5�>���>��>�k>~�>W�G?��>�L9>�G�>3�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/model.onnx
new file mode 100644
index 0000000..43595c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1c1e8d5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
QJ�
��>0g8?���8V˚>-G>�=��>>V��>%�>��	?���>�j/?�[Q>N�`?�[�<£+?���>L?��>�J>��L?��w?"y�><1?
+[`?�e?�+�=��=�->��`?j�=k��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5274c3d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..8fde5ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..cc85f91
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..441aff1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_continued_prefill_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+

B
YJ�
��i?!5 ?&��<!�E?s?��O?��?e X>��3?�%�>(��<Œ#?�� ?!N:?�?*Z�>	g�>���>��
+?�UM?�?�Z`=Q5�>���>��>�k>~�>W�G?��>�L9>�G�>3�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/model.onnx
new file mode 100644
index 0000000..ce7b023
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1438bda
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..83cd079
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

B
KJ�I�?g�p>Ww?��q?�0Y?s��>kW?�A>W�>�
�>��=?��>A)>�>0�>�Й>3y)>
n�>p�>�_F?C�K?\�?���>9G?^%c?z�,?2�L?�ip?��&=,`?���>h��>��K?0�7?ڭ>��(?ԍ=�Ѷ>�P?!��>�?�h:?�;R?�B?#�;�+�>1 �>rSc=��
+?ݖ?�T?jq?19>�k>��(?C�>�te>2*?��-><@H?�b[?��	=i[?
L?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0161f50
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ���y?�k�>�(->yo`?/�h?FJ>0�>�8?�hX?]P,>h;*?N�N?�?|�(>��=3%�>��N?�\7=��<�%�>gL�=�>���<
+T?�Z2?���>��	>���>� ?/�p?C~?�fw>YW-<ؤT?�6m?��>?}E?8�]?�?d_?G��<��>��>"�=�$i?�[�<�,,?��=9��>%�>�9>.a?8�?�S�>α<?$>� E>x��>���>�<S>�0k?��S?2��=B-�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..cb05c55
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d354e2a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/model.onnx
new file mode 100644
index 0000000..a07bc7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1438bda
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..83cd079
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

B
KJ�I�?g�p>Ww?��q?�0Y?s��>kW?�A>W�>�
�>��=?��>A)>�>0�>�Й>3y)>
n�>p�>�_F?C�K?\�?���>9G?^%c?z�,?2�L?�ip?��&=,`?���>h��>��K?0�7?ڭ>��(?ԍ=�Ѷ>�P?!��>�?�h:?�;R?�B?#�;�+�>1 �>rSc=��
+?ݖ?�T?jq?19>�k>��(?C�>�te>2*?��-><@H?�b[?��	=i[?
L?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0161f50
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ���y?�k�>�(->yo`?/�h?FJ>0�>�8?�hX?]P,>h;*?N�N?�?|�(>��=3%�>��N?�\7=��<�%�>gL�=�>���<
+T?�Z2?���>��	>���>� ?/�p?C~?�fw>YW-<ؤT?�6m?��>?}E?8�]?�?d_?G��<��>��>"�=�$i?�[�<�,,?��=9��>%�>�9>.a?8�?�S�>α<?$>� E>x��>���>�<S>�0k?��S?2��=B-�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..cb05c55
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d354e2a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_nonpad_negative_offset_structural_empty_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/model.onnx
new file mode 100644
index 0000000..ab6b0c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c2a9b20
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5605319
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3cb40dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..e7cfc31
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f582f30
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6911fda
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..29e3183
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..778a0b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/model.onnx
new file mode 100644
index 0000000..c8f771f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c2a9b20
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5605319
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3cb40dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..e7cfc31
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f582f30
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6911fda
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..29e3183
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..778a0b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_causal_with_past_and_present_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/model.onnx
new file mode 100644
index 0000000..e08c47a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..fba3316
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bfafc01
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1af681f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/model.onnx
new file mode 100644
index 0000000..26a59de
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..fba3316
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bfafc01
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1af681f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_mask4d_padded_kv_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/model.onnx
new file mode 100644
index 0000000..8cc136c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7845157
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/model.onnx
new file mode 100644
index 0000000..308acaf
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..6b3ed4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..88a72e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/model.onnx
new file mode 100644
index 0000000..aa3c3ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..6b3ed4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..88a72e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_attn_mask_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/model.onnx
new file mode 100644
index 0000000..1efbf16
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ea7a490
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/model.onnx
new file mode 100644
index 0000000..cb45656
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ea7a490
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/model.onnx
new file mode 100644
index 0000000..0217255
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7845157
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/model.onnx
new file mode 100644
index 0000000..d719e78
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ac9130b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/model.onnx
new file mode 100644
index 0000000..3162536
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ac9130b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_scaled_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/model.onnx
new file mode 100644
index 0000000..8610627
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..13fbf8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/model.onnx
new file mode 100644
index 0000000..6d3e137
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..13fbf8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_sizes_softcap_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/model.onnx
new file mode 100644
index 0000000..512de32
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..28c2517
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bc6d46e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..f1cf5d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1a529ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..89fde78
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..761e4d6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/model.onnx
new file mode 100644
index 0000000..c7f1853
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..28c2517
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bc6d46e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..f1cf5d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1a529ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..89fde78
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..761e4d6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/model.onnx
new file mode 100644
index 0000000..84f1a81
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..d0d4f65
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..606c9bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b5d7397
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..84b9ca3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ffe38db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..dfec6f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/model.onnx
new file mode 100644
index 0000000..c73aaaa
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..d0d4f65
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..606c9bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b5d7397
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..84b9ca3
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ffe38db
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..dfec6f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask3d_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/model.onnx
new file mode 100644
index 0000000..88134ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..3b49fbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..044dbce
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..eca8fc2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be2d964
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0ba7250
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..2e83376
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/model.onnx
new file mode 100644
index 0000000..ee1485c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..49d76d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..3b49fbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..044dbce
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..eca8fc2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be2d964
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0ba7250
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..2e83376
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_diff_heads_with_past_and_present_mask4d_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_expanded/model.onnx
new file mode 100644
index 0000000..4836066
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..440196c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16/model.onnx b/onnx/backend/test/data/node/test_attention_4d_fp16/model.onnx
new file mode 100644
index 0000000..1b40fab
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_fp16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c96d042
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4e24a04
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
+B
KJ��1�;�9�7G34m+�6�4�96�1Q&N,o9B7K8,;�;�2N974I%:5#6�8�:9�:`4b:�1�;�9�2�;�94�2%8�&�2�6�5k7q4�8�:�/$8:0�9V6�8�1�0�7�5�;:�9;;W-k8�8�;�4�3k.5$p;\9H:�4�8,�7�;;i5�;j3�;�;e:9�:�4�:�8�"�5�0�;�7�79�5a0�:28.3C.�:�;�;A;1:U51-�6n3=0�*�9�!*:�0-�-`9�3�6u8�:�9S450+�424L7w9�9�46�1O:G+�9;:8:'4�5�8]4�5N2\7�)f:�,'8�4�8�;*9�(�68J8s9q4 0H6�;�1;;Z8P7;V7�9b6;;�9�9>5:9�3#1_:�;U7�8�:Q7�;�8�:E;�:19`6,�6$4�:C(�;�5�5.$�1l6o;`.�;�:D7:5s3�8<(�#�6[,43
420*"d/�8�;�;�6719�7�;.,D:�4�3M9�3T9#8�6p8�4�9�6�5�:f;�)r3�5�:�;�;=;�4�;�3�.�;x3�9x+�9;\46�5�9�3�107�4�:�38�;9�:�;:�9�;�;;7
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..26213b1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
+B
VJ��,�4�0�640�8 6*;�;`8f4�8-;�6k8Y4I7m6�38�4�538
:V5e;�:;*4#7�.�5�9r9�8�9�2x5i9	;Y8�4�'�9	 �5?8`;�-69&{5�8w4�2h/�8�9`9�;�-9�8�8�;R$�9�:8X5T:9.7)8�9�-J3�6�8;�8E0�;�:8a;U8c;�:�;\;�(�1:6�;�4#1;$7C;!1J97�,�9�3)�+�+C;�9/;a9;8�4�;�5�7
6�;�1?5q9,�8�7�4�38�5N7f5�;E02.5�8F9[6�;�5�99�:�;;:�9^5�0,�3�6-8/:�;�/�.�8�9�:};�;f66�0{9A9�:9.�7�8�3i1�:~+�7j/P7�;�6�:�/W4v6f6_9�5�99c6�6�8|,�::9�9L8/{6|6#5�'�9/�8�99�;�.�:y'H8x628�52�$%8�:�5"3'-v-3g.>4<,3,�:01z80:M7�0c2�6:8�5@::k;i'*;H6;�9�;:�586�5-4�7t9p428�/1�)�;��1�85-;�9�;8�4e8r;+8F4;�5��35�:V77a5;�;�;6
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..16bf3fe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_fp16/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+B
YJ�8Y8_6�7�4�6+7a98]8p6�7v4�687v9�7v8�6|74�6 7h9�7]8e6�7�4�67^9�857�9N8G5Y8�88�8'7d9M8}5 8�88�87j9d8}5.8�88�8c7Y98d5
8�88m7�76?8[6�87y8|78�5e826�8-7~8�7�7�5]8G6�8>7�8�7�7�5?86�8y7�8%9�7}9$9/6�5y7~6(9v7z9 9-6�5�7s6
9A7l9'9A66y7n69Y7l9G9"66C7l6s8�1I7�6U678 5�7�82h7%6v6F885�7�8�1m7%6,6L8i5�7r8�1S76�5T8�5�7�9y7<6?8b898�7�9�76>88�8�78�9�7�5&8&8988�9�7�5'8(8)9�7�7
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/model.onnx
new file mode 100644
index 0000000..8508534
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c96d042
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4e24a04
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
+B
KJ��1�;�9�7G34m+�6�4�96�1Q&N,o9B7K8,;�;�2N974I%:5#6�8�:9�:`4b:�1�;�9�2�;�94�2%8�&�2�6�5k7q4�8�:�/$8:0�9V6�8�1�0�7�5�;:�9;;W-k8�8�;�4�3k.5$p;\9H:�4�8,�7�;;i5�;j3�;�;e:9�:�4�:�8�"�5�0�;�7�79�5a0�:28.3C.�:�;�;A;1:U51-�6n3=0�*�9�!*:�0-�-`9�3�6u8�:�9S450+�424L7w9�9�46�1O:G+�9;:8:'4�5�8]4�5N2\7�)f:�,'8�4�8�;*9�(�68J8s9q4 0H6�;�1;;Z8P7;V7�9b6;;�9�9>5:9�3#1_:�;U7�8�:Q7�;�8�:E;�:19`6,�6$4�:C(�;�5�5.$�1l6o;`.�;�:D7:5s3�8<(�#�6[,43
420*"d/�8�;�;�6719�7�;.,D:�4�3M9�3T9#8�6p8�4�9�6�5�:f;�)r3�5�:�;�;=;�4�;�3�.�;x3�9x+�9;\46�5�9�3�107�4�:�38�;9�:�;:�9�;�;;7
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..26213b1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
+B
VJ��,�4�0�640�8 6*;�;`8f4�8-;�6k8Y4I7m6�38�4�538
:V5e;�:;*4#7�.�5�9r9�8�9�2x5i9	;Y8�4�'�9	 �5?8`;�-69&{5�8w4�2h/�8�9`9�;�-9�8�8�;R$�9�:8X5T:9.7)8�9�-J3�6�8;�8E0�;�:8a;U8c;�:�;\;�(�1:6�;�4#1;$7C;!1J97�,�9�3)�+�+C;�9/;a9;8�4�;�5�7
6�;�1?5q9,�8�7�4�38�5N7f5�;E02.5�8F9[6�;�5�99�:�;;:�9^5�0,�3�6-8/:�;�/�.�8�9�:};�;f66�0{9A9�:9.�7�8�3i1�:~+�7j/P7�;�6�:�/W4v6f6_9�5�99c6�6�8|,�::9�9L8/{6|6#5�'�9/�8�99�;�.�:y'H8x628�52�$%8�:�5"3'-v-3g.>4<,3,�:01z80:M7�0c2�6:8�5@::k;i'*;H6;�9�;:�586�5-4�7t9p428�/1�)�;��1�85-;�9�;8�4e8r;+8F4;�5��35�:V77a5;�;�;6
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..16bf3fe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_fp16_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+B
YJ�8Y8_6�7�4�6+7a98]8p6�7v4�687v9�7v8�6|74�6 7h9�7]8e6�7�4�67^9�857�9N8G5Y8�88�8'7d9M8}5 8�88�87j9d8}5.8�88�8c7Y98d5
8�88m7�76?8[6�87y8|78�5e826�8-7~8�7�7�5]8G6�8>7�8�7�7�5?86�8y7�8%9�7}9$9/6�5y7~6(9v7z9 9-6�5�7s6
9A7l9'9A66y7n69Y7l9G9"66C7l6s8�1I7�6U678 5�7�82h7%6v6F885�7�8�1m7%6,6L8i5�7r8�1S76�5T8�5�7�9y7<6?8b898�7�9�76>88�8�78�9�7�5&8&8988�9�7�5'8(8)9�7�7
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa/model.onnx
new file mode 100644
index 0000000..7e11d3e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b1ba910
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/model.onnx
new file mode 100644
index 0000000..fea9507
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..7e68778
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`�l>;��>��L?!�t?��>��S?&��=�L"?�C@?��>��>u�d?� �=�>�<�0?���>�vL?�gl?�*�>���>���>�?��{?<�2?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c7c2fed
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/model.onnx
new file mode 100644
index 0000000..054fdc0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..7e68778
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`�l>;��>��L?!�t?��>��S?&��=�L"?�C@?��>��>u�d?� �=�>�<�0?���>�vL?�gl?�*�>���>���>�?��{?<�2?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c7c2fed
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_attn_mask_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/model.onnx
new file mode 100644
index 0000000..945f0e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..17ccf00
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/model.onnx
new file mode 100644
index 0000000..64e53d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..17ccf00
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/model.onnx
new file mode 100644
index 0000000..d8bfb3c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5002334
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..23d4dd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e31e75e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..2959e7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9980ed4
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/model.onnx
new file mode 100644
index 0000000..5419353
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5002334
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..23d4dd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e31e75e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..2959e7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9980ed4
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/model.onnx
new file mode 100644
index 0000000..47e8b7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7becafe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7c66768
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
+B
KJ�J2�5�:7.�:&.�;�7�;�8�9)�4�/�4�/5�6,�9�8?408.�8o;5W980�9�4�1�8&%�:�l9R4�9�;�3�8�8�8#3�;'7�:�9�4�:X6;�8;�9�98�;'9�6�8�$�4H9�4�8�6V0�4�8�8�8:989�6,;�5�6#;s:�9j.[;�9�;�0�:31�8�/�:u:�8�6m,�9B7�9�:�;�:�!�5�9~1+8�*f2�$Y:*3�5m;�9(E1�8�8�3y;�8I8�8�9�4_6�2�1�;�9�7G34m+�6�4�96�1Q&N,o9B7K8,;�;�2N974I%:5#6�8�:9�:`4b:�1�;�9�2�;�94�2%8�&�2�6�5k7q4�8�:�/$8:0�9V6�8�1�0�7�5�;:�9;;W-k8�8�;�4�3k.5$p;\9H:�4�8,�7�;;i5�;j3�;�;e:9�:�4�:�8�"�5�0�;�7�79�5a0�:28.3C.�:�;�;A;1:U51-�6n3=0�*�9�!*:�0-�-`9�3�6u8�:�9
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a7ad95f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
+B
VJ�S450+�424L7w9�9�46�1O:G+�9;:8:'4�5�8]4�5N2\7�)f:�,'8�4�8�;*9�(�68J8s9q4 0H6�;�1;;Z8P7;V7�9b6;;�9�9>5:9�3#1_:�;U7�8�:Q7�;�8�:E;�:19`6,�6$4�:C(�;�5�5.$�1l6o;`.�;�:D7:5s3�8<(�#�6[,43
420*"d/�8�;�;�6719�7�;.,D:�4�3M9�3T9#8�6p8�4�9�6�5�:f;�)r3�5�:�;�;=;�4�;�3�.�;x3�9x+�9;\46�5�9�3�107�4�:�38�;9�:�;:�9�;�;;7�,�4�0�640�8 6*;�;`8f4�8-;�6k8Y4I7m6�38�4�538
:V5e;�:;*4#7�.�5�9r9�8�9�2x5i9	;Y8�4�'�9	 �5?8`;�-69&{5�8w4�2h/�8�9`9�;�-9�8�8�;R$�9�:8X5T:9.7)8�9�-J3�6�8;�8E0�;�:8a;U8c;�:�;\;�(�1:6�;�4
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..2959e7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..739871b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+

+B
YJ�
8B8j7j7P8
+8�8:728G8`7�7O88�807_6�8�5;8�8@7�56�6�8�5"8�87~5"68�7>8@9K7�779C9�7f7�79:7�79]9s8�6:6u9�4-6V8�7�8�6=6�984U6k878
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/model.onnx
new file mode 100644
index 0000000..0be69ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7becafe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7c66768
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
+B
KJ�J2�5�:7.�:&.�;�7�;�8�9)�4�/�4�/5�6,�9�8?408.�8o;5W980�9�4�1�8&%�:�l9R4�9�;�3�8�8�8#3�;'7�:�9�4�:X6;�8;�9�98�;'9�6�8�$�4H9�4�8�6V0�4�8�8�8:989�6,;�5�6#;s:�9j.[;�9�;�0�:31�8�/�:u:�8�6m,�9B7�9�:�;�:�!�5�9~1+8�*f2�$Y:*3�5m;�9(E1�8�8�3y;�8I8�8�9�4_6�2�1�;�9�7G34m+�6�4�96�1Q&N,o9B7K8,;�;�2N974I%:5#6�8�:9�:`4b:�1�;�9�2�;�94�2%8�&�2�6�5k7q4�8�:�/$8:0�9V6�8�1�0�7�5�;:�9;;W-k8�8�;�4�3k.5$p;\9H:�4�8,�7�;;i5�;j3�;�;e:9�:�4�:�8�"�5�0�;�7�79�5a0�:28.3C.�:�;�;A;1:U51-�6n3=0�*�9�!*:�0-�-`9�3�6u8�:�9
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a7ad95f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
+B
VJ�S450+�424L7w9�9�46�1O:G+�9;:8:'4�5�8]4�5N2\7�)f:�,'8�4�8�;*9�(�68J8s9q4 0H6�;�1;;Z8P7;V7�9b6;;�9�9>5:9�3#1_:�;U7�8�:Q7�;�8�:E;�:19`6,�6$4�:C(�;�5�5.$�1l6o;`.�;�:D7:5s3�8<(�#�6[,43
420*"d/�8�;�;�6719�7�;.,D:�4�3M9�3T9#8�6p8�4�9�6�5�:f;�)r3�5�:�;�;=;�4�;�3�.�;x3�9x+�9;\46�5�9�3�107�4�:�38�;9�:�;:�9�;�;;7�,�4�0�640�8 6*;�;`8f4�8-;�6k8Y4I7m6�38�4�538
:V5e;�:;*4#7�.�5�9r9�8�9�2x5i9	;Y8�4�'�9	 �5?8`;�-69&{5�8w4�2h/�8�9`9�;�-9�8�8�;R$�9�:8X5T:9.7)8�9�-J3�6�8;�8E0�;�:8a;U8c;�:�;\;�(�1:6�;�4
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..2959e7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..739871b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_causal_nonpad_decode_fp16_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+

+B
YJ�
8B8j7j7P8
+8�8:728G8`7�7O88�807_6�8�5;8�8@7�56�6�8�5"8�87~5"68�7>8@9K7�779C9�7f7�79:7�79]9s8�6:6u9�4-6V8�7�8�6=6�984U6k878
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/model.onnx
new file mode 100644
index 0000000..5a43835
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b1ba910
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/model.onnx
new file mode 100644
index 0000000..32e618b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f63e8f6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/model.onnx
new file mode 100644
index 0000000..d6c92d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f63e8f6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_scaled_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/model.onnx
new file mode 100644
index 0000000..d203f59
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad2184c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/model.onnx
new file mode 100644
index 0000000..7084a92
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad2184c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_softcap_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/model.onnx
new file mode 100644
index 0000000..0778ba1
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557a7e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..584b6c4
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..d360588
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d51d993
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..e8198ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..32d4568
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/model.onnx
new file mode 100644
index 0000000..cb3d5a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a39d629
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c0332cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf632fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557a7e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..584b6c4
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..d360588
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d51d993
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..e8198ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..32d4568
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/model.onnx
new file mode 100644
index 0000000..40cbdfc
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dcb4e10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0e8a92b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_1.pb
@@ -0,0 +1,3 @@
+
+B
KJ�#1;$7C;!1J97�,�9�3)�+�+C;�9/;a9;8�4�;�5�7
6�;�1?5q9,�8�7�4�38�5N7f5�;E02.5�8F9[6�;�5�99�:�;;:�9^5�0,�3�6-8/:�;�/�.�8�9�:};�;f66�0{9A9�:9.�7�8�3i1�:~+�7j/P7�;�6�:�/W4v6f6_9�5�99c6�6�8|,�::9�9L8/{6|6#5�'�9/�8�99�;�.�:y'H8x628�52�$%8�:�5"3'-v-3g.>4<,3,�:01z80:M7�0c2�6:8�5@::k;i'*;H6;�9�;:�586�5-4�7t9p428�/1�)�;��1�85-;�9�;8�4e8r;+8F4;�5��35�:V77a5;�;�;6�;V:h9�3�2P1b;�4@7�7::�:s0�6�:�:�.
1�4�,�6�.�8�3�8�/�;v;E6�34�7)9�6
+6z:�9�;�5.;):�5�8�4�:2/�2�1s6�978�7y�6,�2v;�2�:l:1�8g/�99:�7R;Q*�4�9�6�1�.�:�7;�9�6�5 8;�9G�9[;�9�1�7}0�5;c;�4o5
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..27fa408
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..37572c1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+
+B	attn_maskJ�
a3M4g:�;5�:�.9:�0�6$;�.�$�8�6d:c;�476�7�8�;�9<684�;V0�9g;Q9�6^2�5�929l;�:�:K;l4�56|8Y9�4�$c6�4�;;�:99�5d8�:P.i:E)�:v:�*98o1�00:�8�;�;�;�/
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..0a73f54
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_4.pb
@@ -0,0 +1,3 @@
+
+Bpast_keyJ�	�;�3U7:�2�8�1�.v/�5��6P9m6~-,s4k1�;�0r:�8�88�;�5N:q8U6�;�8�/�6A:�9U;&4:\7�8�;�;�:�5;9�6�():8J:�9Y:�4h:d8�7g9x%�.�4�;y0J5�*M5 5�;�: 6W&�:I9�0�;j.�:�4�6]:l9�;�8C.;':�9�*W6\1�:�9;�;3:�;�8�(L#y5�:�:�;+,�)N;�4w8�;h6T9j6%:98�3W4!4B8�9�;�9@:h1�5�6~9�4�4�5{:�8�,-�5":�9�9#:�4c8Y8�9�;s4Y:H9�83:�;�(�0
:]-!8	3d4�9�'�:78R8*9�5y.5a1s85�;�;�8�8�;;:5�5q2�7�;L;�/s&0;L8h2d9'9�/'4�+�2<0/2|9V*�.K05�44
:�;F8�;Y6�.�6�4�7B9`7{;;�9�770Z6�9�4�.C;�9�8W:�:�7
;U;X4�868N8�;�4�;8;W7�:':l95I2_9�:)$$97/;%5�78~0�9�:j+�4�(�;V9�;A8k:�5�5
6C9�54;�;�'22//l)J3&7�:3�7p;V9b:h8�;�8�)V2z6�8-:�6�9R:5�;29;s8�9*:D;�0w8�6c;�.�;
;�,�7�9�9@;f:�4�7�9n052�7�4�:�8�5�:p:�;�:�60�:�+�5\;�; 9�9o)8`8q5d,S3�5�6�8�95C5%;) 4�99):':�:�9�;1;�8�8c(�;60�9�:�5M2R.�9>7�9S;�0Z;�6�4�;�;]2A9�.59�:z9�6!6J6�8
;o;�*�1//02�5
8	9�9;�;N9�:9:�4
;y)a4e79�.b9j:�1�6)8;7f:�;d:�,q:C,�3�0R2:8`9�7�;�3:�:8M7�8�6q8�6h6�9�-T1�:+:�4	6i;�:�83�)�6b9�:�:2(�3m5
+2l:$:"8�;�02;t/91�9/�8�6�95;):�:8(�4 8�6f3�4�;�4�5��:�0�24;�2a:w:k;e/�2�9F2�4V1�1�7/&5�6I&76.�7�:�:&-�8�:�3: ;s:�.� #2T4�8&6�9�5�0
5;�;�2O:`4;L1T9d-�;�9�:�8�7�8;8�7:�1z1�6"5�,�:,:Z8�;�,":C4�53P:�0�:K9�+}:9=;�9}8�:s4
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..d6604c7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..333c719
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ac4dc51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_1.pb
@@ -0,0 +1,4 @@
+
+Bpresent_keyJ�
�;�3U7:�2�8�1�.v/�5��6P9m6~-,s4k1�;�0r:�8�88�;�5N:q8U6�;�8�/�6A:�9U;&4:\7�8�;�;�:�5;9�6�():8J:�9Y:�4h:d8�7g9x%�.�4�;y0J5�*M5 5�;�: 6W&�:I9�0�;j.�:�4�6]:l9�;�8C.;':�9�*W6\1�:�9;�;3:�;#1;$7C;!1J97�,�9�3)�+�+C;�9/;a9;8�4�;�5�7
6�;�1?5q9,�8�7�4�38�5N7f5�;E02.5�8F9[6�;�5�99�:�8�(L#y5�:�:�;+,�)N;�4w8�;h6T9j6%:98�3W4!4B8�9�;�9@:h1�5�6~9�4�4�5{:�8�,-�5":�9�9#:�4c8Y8�9�;s4Y:H9�83:�;�(�0
:]-!8	3d4�9�'�:78R8*9�5y.5a1s85�;�;�8�8�;;:5�5q2�7�;L;�/s&0;L8h2d9'9�/'4�+�;;:�9^5�0,�3�6-8/:�;�/�.�8�9�:};�;f66�0{9A9�:9.�7�8�3i1�:~+�7j/P7�;�6�:�/W4v6f6_9�5�99c6�6�2<0/2|9V*�.K05�44
:�;F8�;Y6�.�6�4�7B9`7{;;�9�770Z6�9�4�.C;�9�8W:�:�7
;U;X4�868N8�;�4�;8;W7�:':l95I2_9�:)$$97/;%5�78~0�9�:j+�4�(�;V9�;A8k:�5�5
6C9�54;�;�'22//l)J3&7�:3�7p;V9b:h8�;�8�)V2�8|,�::9�9L8/{6|6#5�'�9/�8�99�;�.�:y'H8x628�52�$%8�:�5"3'-v-3g.>4<,3,�:01z80:M7�0c2�6:8�5@:z6�8-:�6�9R:5�;29;s8�9*:D;�0w8�6c;�.�;
;�,�7�9�9@;f:�4�7�9n052�7�4�:�8�5�:p:�;�:�60�:�+�5\;�; 9�9o)8`8q5d,S3�5�6�8�95C5%;) 4�99):':�:�9�;1;�8�8c(�;60�9�:�5M2R.�9>7�9S;�0Z;�6�4�;�;]2A9�.:k;i'*;H6;�9�;:�586�5-4�7t9p428�/1�)�;��1�85-;�9�;8�4e8r;+8F4;�5��35�:V77a5;�;�;659�:z9�6!6J6�8
;o;�*�1//02�5
8	9�9;�;N9�:9:�4
;y)a4e79�.b9j:�1�6)8;7f:�;d:�,q:C,�3�0R2:8`9�7�;�3:�:8M7�8�6q8�6h6�9�-T1�:+:�4	6i;�:�83�)�6b9�:�:2(�3m5
+2l:$:"8�;�02;t/91�9/�8�6�95;):�:8(�;V:h9�3�2P1b;�4@7�7::�:s0�6�:�:�.
1�4�,�6�.�8�3�8�/�;v;E6�34�7)9�6
+6z:�9�;�5.;):�5�8�4�:2/�2�4 8�6f3�4�;�4�5��:�0�24;�2a:w:k;e/�2�9F2�4V1�1�7/&5�6I&76.�7�:�:&-�8�:�3: ;s:�.� #2T4�8&6�9�5�0
5;�;�2O:`4;L1T9d-�;�9�:�8�7�8;8�7:�1z1�6"5�,�:,:Z8�;�,":C4�53P:�0�:K9�+}:9=;�9}8�:s4�1s6�978�7y�6,�2v;�2�:l:1�8g/�99:�7R;Q*�4�9�6�1�.�:�7;�9�6�5 8;�9G�9[;�9�1�7}0�5;c;�4o5
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..b606f4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/model.onnx
new file mode 100644
index 0000000..c2aaaaf
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dcb4e10
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0e8a92b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,3 @@
+
+B
KJ�#1;$7C;!1J97�,�9�3)�+�+C;�9/;a9;8�4�;�5�7
6�;�1?5q9,�8�7�4�38�5N7f5�;E02.5�8F9[6�;�5�99�:�;;:�9^5�0,�3�6-8/:�;�/�.�8�9�:};�;f66�0{9A9�:9.�7�8�3i1�:~+�7j/P7�;�6�:�/W4v6f6_9�5�99c6�6�8|,�::9�9L8/{6|6#5�'�9/�8�99�;�.�:y'H8x628�52�$%8�:�5"3'-v-3g.>4<,3,�:01z80:M7�0c2�6:8�5@::k;i'*;H6;�9�;:�586�5-4�7t9p428�/1�)�;��1�85-;�9�;8�4e8r;+8F4;�5��35�:V77a5;�;�;6�;V:h9�3�2P1b;�4@7�7::�:s0�6�:�:�.
1�4�,�6�.�8�3�8�/�;v;E6�34�7)9�6
+6z:�9�;�5.;):�5�8�4�:2/�2�1s6�978�7y�6,�2v;�2�:l:1�8g/�99:�7R;Q*�4�9�6�1�.�:�7;�9�6�5 8;�9G�9[;�9�1�7}0�5;c;�4o5
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..27fa408
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..37572c1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+
+B	attn_maskJ�
a3M4g:�;5�:�.9:�0�6$;�.�$�8�6d:c;�476�7�8�;�9<684�;V0�9g;Q9�6^2�5�929l;�:�:K;l4�56|8Y9�4�$c6�4�;;�:99�5d8�:P.i:E)�:v:�*98o1�00:�8�;�;�;�/
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..0a73f54
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_4.pb
@@ -0,0 +1,3 @@
+
+Bpast_keyJ�	�;�3U7:�2�8�1�.v/�5��6P9m6~-,s4k1�;�0r:�8�88�;�5N:q8U6�;�8�/�6A:�9U;&4:\7�8�;�;�:�5;9�6�():8J:�9Y:�4h:d8�7g9x%�.�4�;y0J5�*M5 5�;�: 6W&�:I9�0�;j.�:�4�6]:l9�;�8C.;':�9�*W6\1�:�9;�;3:�;�8�(L#y5�:�:�;+,�)N;�4w8�;h6T9j6%:98�3W4!4B8�9�;�9@:h1�5�6~9�4�4�5{:�8�,-�5":�9�9#:�4c8Y8�9�;s4Y:H9�83:�;�(�0
:]-!8	3d4�9�'�:78R8*9�5y.5a1s85�;�;�8�8�;;:5�5q2�7�;L;�/s&0;L8h2d9'9�/'4�+�2<0/2|9V*�.K05�44
:�;F8�;Y6�.�6�4�7B9`7{;;�9�770Z6�9�4�.C;�9�8W:�:�7
;U;X4�868N8�;�4�;8;W7�:':l95I2_9�:)$$97/;%5�78~0�9�:j+�4�(�;V9�;A8k:�5�5
6C9�54;�;�'22//l)J3&7�:3�7p;V9b:h8�;�8�)V2z6�8-:�6�9R:5�;29;s8�9*:D;�0w8�6c;�.�;
;�,�7�9�9@;f:�4�7�9n052�7�4�:�8�5�:p:�;�:�60�:�+�5\;�; 9�9o)8`8q5d,S3�5�6�8�95C5%;) 4�99):':�:�9�;1;�8�8c(�;60�9�:�5M2R.�9>7�9S;�0Z;�6�4�;�;]2A9�.59�:z9�6!6J6�8
;o;�*�1//02�5
8	9�9;�;N9�:9:�4
;y)a4e79�.b9j:�1�6)8;7f:�;d:�,q:C,�3�0R2:8`9�7�;�3:�:8M7�8�6q8�6h6�9�-T1�:+:�4	6i;�:�83�)�6b9�:�:2(�3m5
+2l:$:"8�;�02;t/91�9/�8�6�95;):�:8(�4 8�6f3�4�;�4�5��:�0�24;�2a:w:k;e/�2�9F2�4V1�1�7/&5�6I&76.�7�:�:&-�8�:�3: ;s:�.� #2T4�8&6�9�5�0
5;�;�2O:`4;L1T9d-�;�9�:�8�7�8;8�7:�1z1�6"5�,�:,:Z8�;�,":C4�53P:�0�:K9�+}:9=;�9}8�:s4
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..d6604c7
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..333c719
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ac4dc51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1,4 @@
+
+Bpresent_keyJ�
�;�3U7:�2�8�1�.v/�5��6P9m6~-,s4k1�;�0r:�8�88�;�5N:q8U6�;�8�/�6A:�9U;&4:\7�8�;�;�:�5;9�6�():8J:�9Y:�4h:d8�7g9x%�.�4�;y0J5�*M5 5�;�: 6W&�:I9�0�;j.�:�4�6]:l9�;�8C.;':�9�*W6\1�:�9;�;3:�;#1;$7C;!1J97�,�9�3)�+�+C;�9/;a9;8�4�;�5�7
6�;�1?5q9,�8�7�4�38�5N7f5�;E02.5�8F9[6�;�5�99�:�8�(L#y5�:�:�;+,�)N;�4w8�;h6T9j6%:98�3W4!4B8�9�;�9@:h1�5�6~9�4�4�5{:�8�,-�5":�9�9#:�4c8Y8�9�;s4Y:H9�83:�;�(�0
:]-!8	3d4�9�'�:78R8*9�5y.5a1s85�;�;�8�8�;;:5�5q2�7�;L;�/s&0;L8h2d9'9�/'4�+�;;:�9^5�0,�3�6-8/:�;�/�.�8�9�:};�;f66�0{9A9�:9.�7�8�3i1�:~+�7j/P7�;�6�:�/W4v6f6_9�5�99c6�6�2<0/2|9V*�.K05�44
:�;F8�;Y6�.�6�4�7B9`7{;;�9�770Z6�9�4�.C;�9�8W:�:�7
;U;X4�868N8�;�4�;8;W7�:':l95I2_9�:)$$97/;%5�78~0�9�:j+�4�(�;V9�;A8k:�5�5
6C9�54;�;�'22//l)J3&7�:3�7p;V9b:h8�;�8�)V2�8|,�::9�9L8/{6|6#5�'�9/�8�99�;�.�:y'H8x628�52�$%8�:�5"3'-v-3g.>4<,3,�:01z80:M7�0c2�6:8�5@:z6�8-:�6�9R:5�;29;s8�9*:D;�0w8�6c;�.�;
;�,�7�9�9@;f:�4�7�9n052�7�4�:�8�5�:p:�;�:�60�:�+�5\;�; 9�9o)8`8q5d,S3�5�6�8�95C5%;) 4�99):':�:�9�;1;�8�8c(�;60�9�:�5M2R.�9>7�9S;�0Z;�6�4�;�;]2A9�.:k;i'*;H6;�9�;:�586�5-4�7t9p428�/1�)�;��1�85-;�9�;8�4e8r;+8F4;�5��35�:V77a5;�;�;659�:z9�6!6J6�8
;o;�*�1//02�5
8	9�9;�;N9�:9:�4
;y)a4e79�.b9j:�1�6)8;7f:�;d:�,q:C,�3�0R2:8`9�7�;�3:�:8M7�8�6q8�6h6�9�-T1�:+:�4	6i;�:�83�)�6b9�:�:2(�3m5
+2l:$:"8�;�02;t/91�9/�8�6�95;):�:8(�;V:h9�3�2P1b;�4@7�7::�:s0�6�:�:�.
1�4�,�6�.�8�3�8�/�;v;E6�34�7)9�6
+6z:�9�;�5.;):�5�8�4�:2/�2�4 8�6f3�4�;�4�5��:�0�24;�2a:w:k;e/�2�9F2�4V1�1�7/&5�6I&76.�7�:�:&-�8�:�3: ;s:�.� #2T4�8&6�9�5�0
5;�;�2O:`4;L1T9d-�;�9�:�8�7�8;8�7:�1z1�6"5�,�:,:Z8�;�,":C4�53P:�0�:K9�+}:9=;�9}8�:s4�1s6�978�7y�6,�2v;�2�:l:1�8g/�99:�7R;Q*�4�9�6�1�.�:�7;�9�6�5 8;�9G�9[;�9�1�7}0�5;c;�4o5
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..b606f4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_gqa_with_past_and_present_fp16_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled/model.onnx b/onnx/backend/test/data/node/test_attention_4d_scaled/model.onnx
new file mode 100644
index 0000000..684466a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ee45685
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/model.onnx
new file mode 100644
index 0000000..65812b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ee45685
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_scaled_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap/model.onnx b/onnx/backend/test/data/node/test_attention_4d_softcap/model.onnx
new file mode 100644
index 0000000..1bfffd8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3e98a3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/model.onnx
new file mode 100644
index 0000000..9c01f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3e98a3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/model.onnx b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/model.onnx
new file mode 100644
index 0000000..9549cea
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5cf240d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


B
QJ�
�ÿ>bs?�c;?�A?Z�>�>�m=��]?��??D5?Р�<Lx?�U?moY>S0:>d�;>�ś>pV?�'�>��>d�?{�>���>ȓ�>
��>K
I?IwL>ޤ?{�?�B>=�?��.>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e44da8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e1234c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..45c8492
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f98a274
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


B
YJ�
n�I?C<�>j][>�O�>i��>�I�>�?�>�)J?D��>�h\>UC�>��>1��>��?
��>&lI?���>Z�\>���>��>K��>��?�c�>xNJ?+8�>:_>�H�>dȧ>��>b?E�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/model.onnx
new file mode 100644
index 0000000..7033b55
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5cf240d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


B
QJ�
�ÿ>bs?�c;?�A?Z�>�>�m=��]?��??D5?Р�<Lx?�U?moY>S0:>d�;>�ś>pV?�'�>��>d�?{�>���>ȓ�>
��>K
I?IwL>ޤ?{�?�B>=�?��.>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e44da8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e1234c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..45c8492
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f98a274
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


B
YJ�
n�I?C<�>j][>�O�>i��>�I�>�?�>�)J?D��>�h\>UC�>��>1��>��?
��>&lI?���>Z�\>���>��>K��>��?�c�>xNJ?+8�>:_>�H�>dȧ>��>b?E�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/model.onnx b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/model.onnx
new file mode 100644
index 0000000..10cfd41
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5cf240d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


B
QJ�
�ÿ>bs?�c;?�A?Z�>�>�m=��]?��??D5?Р�<Lx?�U?moY>S0:>d�;>�ś>pV?�'�>��>d�?{�>���>ȓ�>
��>K
I?IwL>ޤ?{�?�B>=�?��.>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e44da8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9d6786c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..45c8492
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f98a274
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


B
YJ�
n�I?C<�>j][>�O�>i��>�I�>�?�>�)J?D��>�h\>UC�>��>1��>��?
��>&lI?���>Z�\>���>��>K��>��?�c�>xNJ?+8�>:_>�H�>dȧ>��>b?E�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/model.onnx
new file mode 100644
index 0000000..003ae91
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5cf240d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


B
QJ�
�ÿ>bs?�c;?�A?Z�>�>�m=��]?��??D5?Р�<Lx?�U?moY>S0:>d�;>�ś>pV?�'�>��>d�?{�>���>ȓ�>
��>K
I?IwL>ޤ?{�?�B>=�?��.>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e44da8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9d6786c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..45c8492
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f98a274
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_softcap_neginf_mask_poison_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


B
YJ�
n�I?C<�>j][>�O�>i��>�I�>�?�>�)J?D��>�h\>UC�>��>1��>��?
��>&lI?���>Z�\>���>��>K��>��?�c�>xNJ?+8�>:_>�H�>dȧ>��>b?E�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/model.onnx
new file mode 100644
index 0000000..fc3b38e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0221c9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3b01f56
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3813341
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/model.onnx
new file mode 100644
index 0000000..3fb48b5
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0221c9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3b01f56
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3813341
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/model.onnx
new file mode 100644
index 0000000..7864df1
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0221c9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3b01f56
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3813341
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..57e0460
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/model.onnx
new file mode 100644
index 0000000..290c81a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0221c9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3b01f56
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3813341
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..6335834
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/model.onnx
new file mode 100644
index 0000000..41f0edf
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..48112f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bc6d46e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..77f2c87
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9e2ee16
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..89fde78
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4d25617
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..ee74824
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/model.onnx
new file mode 100644
index 0000000..b788c1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..48112f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bc6d46e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..77f2c87
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ca6ab55
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..89fde78
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4d25617
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..4c5271e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/model.onnx
new file mode 100644
index 0000000..14a9f6c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..48112f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bc6d46e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..77f2c87
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ca6ab55
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..89fde78
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4d25617
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..4c5271e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/model.onnx
new file mode 100644
index 0000000..f591da1
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..48112f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bc6d46e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..77f2c87
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9e2ee16
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..89fde78
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4d25617
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..ee74824
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/model.onnx
new file mode 100644
index 0000000..c0c8ad9
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..a3fc81a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e048923
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..c3fbe2b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e27deaf
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..1040fd8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..66c08c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..ea7efad
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/model.onnx
new file mode 100644
index 0000000..c1fafff
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..a3fc81a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e048923
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..c3fbe2b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7476886
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..1040fd8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..66c08c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..dd02e5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/model.onnx
new file mode 100644
index 0000000..910b77e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..a3fc81a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e048923
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..c3fbe2b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7476886
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..1040fd8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..66c08c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..dd02e5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/model.onnx
new file mode 100644
index 0000000..feba0f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..a3fc81a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e048923
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..c3fbe2b
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e27deaf
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..1040fd8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..66c08c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..ea7efad
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/model.onnx
new file mode 100644
index 0000000..9dc3395
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0221c9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3b01f56
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3813341
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..6335834
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_bias_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/model.onnx
new file mode 100644
index 0000000..8f88355
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f43440
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8519679
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b651623
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0221c9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3b01f56
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3813341
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..57e0460
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_past_and_present_qk_matmul_expanded/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/model.onnx
new file mode 100644
index 0000000..b9f041c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..440196c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..6222705
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/model.onnx
new file mode 100644
index 0000000..6c49774
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..593e426
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..b5c8960
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/model.onnx
new file mode 100644
index 0000000..85fde98
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..593e426
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..b5c8960
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_bias_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/model.onnx
new file mode 100644
index 0000000..1c0d39e
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..440196c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..6222705
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/model.onnx
new file mode 100644
index 0000000..b10442c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2559022
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bce2d56
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/model.onnx
new file mode 100644
index 0000000..63fd854
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2559022
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bce2d56
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softcap_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/model.onnx
new file mode 100644
index 0000000..c22b680
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..593e426
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0f090a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/model.onnx
new file mode 100644
index 0000000..bfb1076
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..daf1d33
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b09f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b358e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02a69a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
B	attn_maskJ`pUw?��J?��,?O�z>��]>q*>�9l?7��>���>��>A6G?�X?i>5��>W�W?�jQ?N��=�" >>�U�=nm�>�f�=�v?ly|>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..593e426
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0f090a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_4d_with_qk_matmul_softmax_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/model.onnx b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/model.onnx
new file mode 100644
index 0000000..0e53f3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1970157
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c86782f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f6830c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�
2Ц>
��>�|=�x>�x?Dl>�1?��&?T9?�>�>��?D'�=u��=_�K>s�>��=�e>��
?�R@>�s?~.?D�
+?�	5?'�>�=m?[�V?�9?��>�W?�>?)?H�i?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..670ce65
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8d7d90a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/model.onnx b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/model.onnx
new file mode 100644
index 0000000..85d6213
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1970157
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c86782f
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f6830c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�
2Ц>
��>�|=�x>�x?Dl>�1?��&?T9?�>�>��?D'�=u��=_�K>s�>��=�e>��
?�R@>�s?~.?D�
+?�	5?'�>�=m?[�V?�9?��>�W?�>?)?H�i?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..670ce65
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8d7d90a
Binary files /dev/null and b/onnx/backend/test/data/node/test_attention_causal_boolmask_nan_robustness_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_1d_default/model.onnx b/onnx/backend/test/data/node/test_averagepool_1d_default/model.onnx
new file mode 100644
index 0000000..36f6b96
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_1d_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..04d0812
--- /dev/null
+++ b/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
 
B
xJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..efcdf6c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_averagepool_1d_default/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ�i��?�0?p�?nx@f��>`�^��y�>�W��`>��>��L?�Ǎ?v��>ǐ>��>��i?\�$?��\=Ѐ���
ڿ�s��OB?Piz=�C?T��>>M4��ѐ�x<,?#�?D�O?�y�>ږ���	��$)Ľh}1?ఛ?P��>������,����ȿ�_�=�v8?4��jnX�,[s��־G�i���
�A1����}��X�o��j�L>�\}>$�<>E�)��?��|����
���C������m���c�j�ھ���>���>eZ"?@nC��վ���$G��9�f����4�
�bU��.?�	���ļƕ�?`��?��>3 �����>���>�!7?C�?�*?h?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_ceil/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_ceil/model.onnx
new file mode 100644
index 0000000..168a695
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_ceil/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7ef45fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3ef908e
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_ceil/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/model.onnx
new file mode 100644
index 0000000..2761cb9
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..164279f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJ0�[?	��=�ԉ>�c>��a?���>a�?~�)?~h?��r?��?�SC?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51c8ec4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_averagepool_2d_ceil_last_window_starts_on_pad/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



B
yJ��>�u�>��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_default/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_default/model.onnx
new file mode 100644
index 0000000..11a1b13
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..909f550
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_dilations/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_dilations/model.onnx
new file mode 100644
index 0000000..ce3c86e
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_dilations/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7ef45fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7da0b12
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_dilations/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_pads/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_pads/model.onnx
new file mode 100644
index 0000000..7d5e02e
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_pads/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5309700
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c9de7fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_pads/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/model.onnx
new file mode 100644
index 0000000..4157c3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5309700
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e27490a
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_pads_count_include_pad/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/model.onnx
new file mode 100644
index 0000000..56e616d
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb22a53
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a92a50a
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/model.onnx
new file mode 100644
index 0000000..2c4c4d6
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb22a53
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..62b2add
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_pads_count_include_pad/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/model.onnx
new file mode 100644
index 0000000..413ec8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb22a53
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e8ff996
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_same_upper/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/model.onnx
new file mode 100644
index 0000000..b77b84e
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb22a53
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7b17d98
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_precomputed_strides/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_same_lower/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_same_lower/model.onnx
new file mode 100644
index 0000000..75cfab5
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_same_lower/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7dfbb4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_same_lower/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_same_upper/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_same_upper/model.onnx
new file mode 100644
index 0000000..102b40f
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_same_upper/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2ab7912
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_same_upper/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_strides/model.onnx b/onnx/backend/test/data/node/test_averagepool_2d_strides/model.onnx
new file mode 100644
index 0000000..71f2ba2
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_strides/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab1681f
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_2d_strides/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_default/model.onnx b/onnx/backend/test/data/node/test_averagepool_3d_default/model.onnx
new file mode 100644
index 0000000..4d1bcc8
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1f024e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..57a0a15
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/model.onnx b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/model.onnx
new file mode 100644
index 0000000..7a75725
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..67e7a99
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1c9d762
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_False/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/model.onnx b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/model.onnx
new file mode 100644
index 0000000..894e85f
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..61d8539
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6ea6ff5
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_0_ceil_mode_is_True/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/model.onnx b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/model.onnx
new file mode 100644
index 0000000..eafe776
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e2cab45
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..45530fb
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_False/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/model.onnx b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/model.onnx
new file mode 100644
index 0000000..27f6fb1
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d9aab
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..881680b
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_large_count_include_pad_is_1_ceil_mode_is_True/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_small/model.onnx b/onnx/backend/test/data/node/test_averagepool_3d_dilations_small/model.onnx
new file mode 100644
index 0000000..883cdbe
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_small/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_small/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_small/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fdfbdb2
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_small/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_averagepool_3d_dilations_small/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_averagepool_3d_dilations_small/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..af6afa6
Binary files /dev/null and b/onnx/backend/test/data/node/test_averagepool_3d_dilations_small/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_conv_with_padding/model.onnx b/onnx/backend/test/data/node/test_basic_conv_with_padding/model.onnx
new file mode 100644
index 0000000..e7c3e41
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_conv_with_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..063e191
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6d5f1a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2f8944b
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_conv_with_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_conv_without_padding/model.onnx b/onnx/backend/test/data/node/test_basic_conv_without_padding/model.onnx
new file mode 100644
index 0000000..dbdb55f
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_conv_without_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..063e191
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6d5f1a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c158083
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_conv_without_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/model.onnx b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/model.onnx
new file mode 100644
index 0000000..7729eeb
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fed94a
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2e3467d
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a7fb8aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..45f2460
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_with_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/model.onnx b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/model.onnx
new file mode 100644
index 0000000..1767e75
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fed94a
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2e3467d
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..13d5acd
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4f2f945
Binary files /dev/null and b/onnx/backend/test/data/node/test_basic_deform_conv_without_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon/model.onnx b/onnx/backend/test/data/node/test_batchnorm_epsilon/model.onnx
new file mode 100644
index 0000000..29c2b25
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d514241
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d116d51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
sJ��6?�a:���V?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..04d8744
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ=��?tt���K�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..735331e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
BmeanJ�D��f�<����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f583c02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
BvarJc�6=l�L?W��=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5094ae4
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_epsilon/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/model.onnx b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/model.onnx
new file mode 100644
index 0000000..18f46c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d514241
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d116d51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
sJ��6?�a:���V?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..04d8744
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ=��?tt���K�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..735331e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
BmeanJ�D��f�<����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f583c02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
BvarJc�6=l�L?W��=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7143658
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..b5779a5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Boutput_meanJX����	2�����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..ec74fb0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_epsilon_training_mode/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+
B
+output_varJ�>�X?��!>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example/model.onnx b/onnx/backend/test/data/node/test_batchnorm_example/model.onnx
new file mode 100644
index 0000000..9d3f372
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5103103
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..be392c2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
sJٺ�>*������>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ffa575c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJǩ?3�1��9�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..03fea1b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
BmeanJr�޾���?�,?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..9300137
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
BvarJǻy?�[?n�?<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0809e19
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_example_training_mode/model.onnx b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/model.onnx
new file mode 100644
index 0000000..ad005a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5103103
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..be392c2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
sJٺ�>*������>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ffa575c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJǩ?3�1��9�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..03fea1b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
BmeanJr�޾���?�,?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..9300137
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
BvarJǻy?�[?n�?<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..77cd8aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..89e2fbe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Boutput_meanJ��¾u�?N2?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..30fcb86
--- /dev/null
+++ b/onnx/backend/test/data/node/test_batchnorm_example_training_mode/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+
B
+output_varJ�`v?�/c?P�	>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bernoulli/model.onnx b/onnx/backend/test/data/node/test_bernoulli/model.onnx
new file mode 100644
index 0000000..702c996
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b6d3af5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
+B
xJP�_V��?3�`����?K�nk�I�?��cۮo�?��)�?[��!*��?�Ya�m
�?�:�g��?63IS��?B�KN��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..49da0b5
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_double/model.onnx b/onnx/backend/test/data/node/test_bernoulli_double/model.onnx
new file mode 100644
index 0000000..929e419
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_double/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7faf960
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
+
B
xJ(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..49da0b5
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_double/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_double_expanded/model.onnx b/onnx/backend/test/data/node/test_bernoulli_double_expanded/model.onnx
new file mode 100644
index 0000000..558e382
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_double_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7faf960
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
+
B
xJ(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..49da0b5
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_double_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_expanded/model.onnx b/onnx/backend/test/data/node/test_bernoulli_expanded/model.onnx
new file mode 100644
index 0000000..c510c81
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b6d3af5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
+B
xJP�_V��?3�`����?K�nk�I�?��cۮo�?��)�?[��!*��?�Ya�m
�?�:�g��?63IS��?B�KN��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..49da0b5
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_seed/model.onnx b/onnx/backend/test/data/node/test_bernoulli_seed/model.onnx
new file mode 100644
index 0000000..ea69f01
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_seed/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7faf960
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
+
B
xJ(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e4dd877
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_seed/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_seed_expanded/model.onnx b/onnx/backend/test/data/node/test_bernoulli_seed_expanded/model.onnx
new file mode 100644
index 0000000..3236cbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_seed_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7faf960
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
+
B
xJ(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e4dd877
Binary files /dev/null and b/onnx/backend/test/data/node/test_bernoulli_seed_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/model.onnx b/onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/model.onnx
new file mode 100644
index 0000000..a9f68e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9a18aee
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..34299be
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_2d_float32_to_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_bool_to_uint8/model.onnx b/onnx/backend/test/data/node/test_bitcast_bool_to_uint8/model.onnx
new file mode 100644
index 0000000..33de6ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_bool_to_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_bool_to_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_bool_to_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c10a260
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_bool_to_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_bool_to_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_bool_to_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..069c8e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_bool_to_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_float32_to_int32/model.onnx b/onnx/backend/test/data/node/test_bitcast_float32_to_int32/model.onnx
new file mode 100644
index 0000000..7628acd
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_float32_to_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_float32_to_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_float32_to_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8724600
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_float32_to_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_float32_to_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_float32_to_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..84bb06d
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_float32_to_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_float64_to_int64/model.onnx b/onnx/backend/test/data/node/test_bitcast_float64_to_int64/model.onnx
new file mode 100644
index 0000000..db61122
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_float64_to_int64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_float64_to_int64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_float64_to_int64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fd84592
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_float64_to_int64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_float64_to_int64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_float64_to_int64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6e97326
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_float64_to_int64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_int32_to_float32/model.onnx b/onnx/backend/test/data/node/test_bitcast_int32_to_float32/model.onnx
new file mode 100644
index 0000000..6c716de
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_int32_to_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_int32_to_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_int32_to_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..02e40fd
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_int32_to_float32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_int32_to_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_int32_to_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7711c51
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_int32_to_float32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_int64_to_float64/model.onnx b/onnx/backend/test/data/node/test_bitcast_int64_to_float64/model.onnx
new file mode 100644
index 0000000..47173bc
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_int64_to_float64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_int64_to_float64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_int64_to_float64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..591a4ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_int64_to_float64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_int64_to_float64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_int64_to_float64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be07773
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_int64_to_float64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_int8_to_uint8/model.onnx b/onnx/backend/test/data/node/test_bitcast_int8_to_uint8/model.onnx
new file mode 100644
index 0000000..5bd5931
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_int8_to_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_int8_to_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_int8_to_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5c526d1
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_int8_to_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_int8_to_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_int8_to_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..72560cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_int8_to_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/model.onnx b/onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/model.onnx
new file mode 100644
index 0000000..1d585a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..730ab7e
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..168d01c
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_scalar_float32_to_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_uint16_to_int16/model.onnx b/onnx/backend/test/data/node/test_bitcast_uint16_to_int16/model.onnx
new file mode 100644
index 0000000..dde29e1
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_uint16_to_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_uint16_to_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_uint16_to_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c324c93
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_uint16_to_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_uint16_to_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_uint16_to_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9671fa4
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_uint16_to_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_uint32_to_int32/model.onnx b/onnx/backend/test/data/node/test_bitcast_uint32_to_int32/model.onnx
new file mode 100644
index 0000000..6f3a538
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_uint32_to_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitcast_uint32_to_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitcast_uint32_to_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0d77614
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_uint32_to_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitcast_uint32_to_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitcast_uint32_to_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9aeead4
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitcast_uint32_to_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint16/model.onnx b/onnx/backend/test/data/node/test_bitshift_left_uint16/model.onnx
new file mode 100644
index 0000000..4bd610c
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57ba338
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fcbf693
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fedb775
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint32/model.onnx b/onnx/backend/test/data/node/test_bitshift_left_uint32/model.onnx
new file mode 100644
index 0000000..086106c
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c01899b
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d58cf28
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..126ba2b
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint64/model.onnx b/onnx/backend/test/data/node/test_bitshift_left_uint64/model.onnx
new file mode 100644
index 0000000..994339a
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4c69686
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2b2b147
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..586fb01
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint8/model.onnx b/onnx/backend/test/data/node/test_bitshift_left_uint8/model.onnx
new file mode 100644
index 0000000..b6decae
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_left_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2381f5a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a079f74
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
yJ

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b98bfa6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitshift_left_uint8/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
zJ 
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint16/model.onnx b/onnx/backend/test/data/node/test_bitshift_right_uint16/model.onnx
new file mode 100644
index 0000000..bf1b177
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57ba338
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fcbf693
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..73293c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint32/model.onnx b/onnx/backend/test/data/node/test_bitshift_right_uint32/model.onnx
new file mode 100644
index 0000000..618b758
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c01899b
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d58cf28
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d545c52
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint64/model.onnx b/onnx/backend/test/data/node/test_bitshift_right_uint64/model.onnx
new file mode 100644
index 0000000..4065c19
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4c69686
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2b2b147
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5260f80
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint8/model.onnx b/onnx/backend/test/data/node/test_bitshift_right_uint8/model.onnx
new file mode 100644
index 0000000..18d26f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2381f5a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a079f74
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
yJ

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..36087fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitshift_right_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_i16_3d/model.onnx b/onnx/backend/test/data/node/test_bitwise_and_i16_3d/model.onnx
new file mode 100644
index 0000000..f1c91fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_i16_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8e47289
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7c8236c
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..350f288
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_i16_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_i32_2d/model.onnx b/onnx/backend/test/data/node/test_bitwise_and_i32_2d/model.onnx
new file mode 100644
index 0000000..f771d47
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_i32_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f102699
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ0%����G�/g8H�n�~���̠˪eͅ�Oˑ��Sp������P��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b76bf69
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
yJ0%����G�/g8H�n�~���̠˪eͅ�Oˑ��Sp������P��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6d4f05d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_and_i32_2d/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+B
+bitwiseandJ0%����G�/g8H�n�~���̠˪eͅ�Oˑ��Sp������P��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/model.onnx b/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/model.onnx
new file mode 100644
index 0000000..b8479dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6f8cbfc
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4273f7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1234347
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_ui64_bcast_3v1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/model.onnx b/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/model.onnx
new file mode 100644
index 0000000..1bfbd0a
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9383916
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_0.pb
@@ -0,0 +1,5 @@
+B
xJ�%�H�˅O����G�����e�ԋ�ꜝ�2D������`V��?=9
�<�؍s��y�G�ƕ19��+L4Pms)�@�o�ׇ�h	��~}d��9S�� �
+��W��\J�.�ؗ�AqM����4��Lە�M�KL+$g-�9���`
+|Q�y��ܔ���^<�Rsa���gb
+�`�R���G�6���v���ra�T
+`�=8ٕ�`����t+�͸������5E�e�(M۱q/ͨ�-W���-�tB�.��?K#��!��S06 ��7��J�mc T�2O�@l�q�,�ێ����V��5�n��"d� ����^���O?qW�*���➑D@��Α��ќ�&�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e03f747
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+B
yJx%�H�˅O����G�����e�ԋ�ꜝ�2D������`V��?=9
�<�؍s��y�G�ƕ19��+L4Pms)�@�o�ׇ�h	��~}d��9S�� �
+��W��\J�.��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2fc7cc4
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_and_ui8_bcast_4v3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_not_2d/model.onnx b/onnx/backend/test/data/node/test_bitwise_not_2d/model.onnx
new file mode 100644
index 0000000..1e7ff58
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_not_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f102699
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ0%����G�/g8H�n�~���̠˪eͅ�Oˑ��Sp������P��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7540cab
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_not_2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_not_3d/model.onnx b/onnx/backend/test/data/node/test_bitwise_not_3d/model.onnx
new file mode 100644
index 0000000..dbf925f
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_not_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ae28c09
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+B
xJx%�뀌/H�~��˪�O��S���P̿G���y��}����Te����ɋ�� �M���ߎY2�Dj�|�_�K�B�eޭ`�V����׉��?�=�9�

+��<���u��~s��
�y�ȹ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..766c3a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_not_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_not_4d/model.onnx b/onnx/backend/test/data/node/test_bitwise_not_4d/model.onnx
new file mode 100644
index 0000000..c29eab1
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_not_4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9383916
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/input_0.pb
@@ -0,0 +1,5 @@
+B
xJ�%�H�˅O����G�����e�ԋ�ꜝ�2D������`V��?=9
�<�؍s��y�G�ƕ19��+L4Pms)�@�o�ׇ�h	��~}d��9S�� �
+��W��\J�.�ؗ�AqM����4��Lە�M�KL+$g-�9���`
+|Q�y��ܔ���^<�Rsa���gb
+�`�R���G�6���v���ra�T
+`�=8ٕ�`����t+�͸������5E�e�(M۱q/ͨ�-W���-�tB�.��?K#��!��S06 ��7��J�mc T�2O�@l�q�,�ێ����V��5�n��"d� ����^���O?qW�*���➑D@��Α��ќ�&�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d49ef32
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_not_4d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+Bbitwise_notJ��s�v4z�?o~3�y�M�
�m+tcbqͻ((!��rv�������.�'r�P�7�|9j���;�Գ�˯���-�;�(x�f���<�肛dZƬYw�]��p��8��A�_'hH����2��*9��$j4��7�����ۘ��;�-���胮x�g5#k_s>��g���}#���I��)9=�O��znU�O�r��J���H��&j�,�qr+��y2GDp�v=8ʺ[��ײ$N��2W1Ҩoc�<��1�b���J"�}+����c�-��!�w�����2ͰV��,����a$q�e�x�P�Cݛ�l<�,�YPz����_�5='an��C1nX\.ci�V
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_or_i16_4d/model.onnx b/onnx/backend/test/data/node/test_bitwise_or_i16_4d/model.onnx
new file mode 100644
index 0000000..aaf151e
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_i16_4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fe08ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7864830
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f696fb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_i16_4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_i32_2d/model.onnx b/onnx/backend/test/data/node/test_bitwise_or_i32_2d/model.onnx
new file mode 100644
index 0000000..f0fef77
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_i32_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f102699
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ0%����G�/g8H�n�~���̠˪eͅ�Oˑ��Sp������P��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b76bf69
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
yJ0%����G�/g8H�n�~���̠˪eͅ�Oˑ��Sp������P��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..eb4adbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_or_i32_2d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B	bitwiseorJ0%����G�/g8H�n�~���̠˪eͅ�Oˑ��Sp������P��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/model.onnx b/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/model.onnx
new file mode 100644
index 0000000..a97df71
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6f8cbfc
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4273f7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a186035
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_ui64_bcast_3v1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/model.onnx b/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/model.onnx
new file mode 100644
index 0000000..cab8cbc
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9383916
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_0.pb
@@ -0,0 +1,5 @@
+B
xJ�%�H�˅O����G�����e�ԋ�ꜝ�2D������`V��?=9
�<�؍s��y�G�ƕ19��+L4Pms)�@�o�ׇ�h	��~}d��9S�� �
+��W��\J�.�ؗ�AqM����4��Lە�M�KL+$g-�9���`
+|Q�y��ܔ���^<�Rsa���gb
+�`�R���G�6���v���ra�T
+`�=8ٕ�`����t+�͸������5E�e�(M۱q/ͨ�-W���-�tB�.��?K#��!��S06 ��7��J�mc T�2O�@l�q�,�ێ����V��5�n��"d� ����^���O?qW�*���➑D@��Α��ќ�&�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e03f747
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+B
yJx%�H�˅O����G�����e�ԋ�ꜝ�2D������`V��?=9
�<�؍s��y�G�ƕ19��+L4Pms)�@�o�ׇ�h	��~}d��9S�� �
+��W��\J�.��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cfa6140
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_or_ui8_bcast_4v3d/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+B	bitwiseorJ�%�H�˅O����G�����e�ԋ�ꜝ�2D������`V��?=9
�<�؍s��y�G�ƕ19��+L4Pms)�@�o�ׇ�h	��~}d��9S�� �
+��W��\J�.�ط��y�˅��݇�����۷��m��������7m������m^��ه�������^�����y����柷y�����O��vo���v�����{�|i��~������[����~?����������ݥ��]�������������=�u�ޯ���߯��������`����?�^�m�<�\ݿ��}�w�ֽ?��������v��w�����}������^����_uߥ;���⾛W�������۾���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/model.onnx b/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/model.onnx
new file mode 100644
index 0000000..5196cab
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8e47289
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7c8236c
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a45caff
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_i16_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/model.onnx b/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/model.onnx
new file mode 100644
index 0000000..d91ea4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f102699
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ0%����G�/g8H�n�~���̠˪eͅ�Oˑ��Sp������P��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b76bf69
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
yJ0%����G�/g8H�n�~���̠˪eͅ�Oˑ��Sp������P��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..45912eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_i32_2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/model.onnx b/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/model.onnx
new file mode 100644
index 0000000..f9f3a2c
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6f8cbfc
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4273f7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9fdf8ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_ui64_bcast_3v1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/model.onnx b/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/model.onnx
new file mode 100644
index 0000000..6e6265a
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9383916
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_0.pb
@@ -0,0 +1,5 @@
+B
xJ�%�H�˅O����G�����e�ԋ�ꜝ�2D������`V��?=9
�<�؍s��y�G�ƕ19��+L4Pms)�@�o�ׇ�h	��~}d��9S�� �
+��W��\J�.�ؗ�AqM����4��Lە�M�KL+$g-�9���`
+|Q�y��ܔ���^<�Rsa���gb
+�`�R���G�6���v���ra�T
+`�=8ٕ�`����t+�͸������5E�e�(M۱q/ͨ�-W���-�tB�.��?K#��!��S06 ��7��J�mc T�2O�@l�q�,�ێ����V��5�n��"d� ����^���O?qW�*���➑D@��Α��ќ�&�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e03f747
--- /dev/null
+++ b/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+B
yJx%�H�˅O����G�����e�ԋ�ꜝ�2D������`V��?=9
�<�؍s��y�G�ƕ19��+L4Pms)�@�o�ׇ�h	��~}d��9S�� �
+��W��\J�.��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b8db1e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_bitwise_xor_ui8_bcast_4v3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow/model.onnx b/onnx/backend/test/data/node/test_blackmanwindow/model.onnx
new file mode 100644
index 0000000..ec13ecc
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..12e754c
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow_expanded/model.onnx b/onnx/backend/test/data/node/test_blackmanwindow_expanded/model.onnx
new file mode 100644
index 0000000..8ec41ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..12e754c
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow_symmetric/model.onnx b/onnx/backend/test/data/node/test_blackmanwindow_symmetric/model.onnx
new file mode 100644
index 0000000..5771108
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow_symmetric/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..eff15ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow_symmetric/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/model.onnx b/onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/model.onnx
new file mode 100644
index 0000000..955c1ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..eff15ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_blackmanwindow_symmetric_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/model.onnx
new file mode 100644
index 0000000..09fc5c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6c7eaa6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..172c637
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/model.onnx
new file mode 100644
index 0000000..ef68dc2
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6e6cf2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..20e7394
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..5680a83
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6e6cf2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..064a1f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/model.onnx
new file mode 100644
index 0000000..60e2ad8
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a2fa86
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a07e311
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/model.onnx
new file mode 100644
index 0000000..ad0eca2
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a2fa86
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a12d09b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/model.onnx
new file mode 100644
index 0000000..7b5d284
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4506593
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e0b22f4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT4E2M1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/model.onnx
new file mode 100644
index 0000000..eb85055
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..38ae244
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx
new file mode 100644
index 0000000..c4121f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dce5a1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/model.onnx
new file mode 100644
index 0000000..82e599f
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fb9379
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx
new file mode 100644
index 0000000..68fb048
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2663be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/model.onnx
new file mode 100644
index 0000000..f24b381
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7bb6022
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b9799f9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/model.onnx
new file mode 100644
index 0000000..8858c41
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..28e21c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc2a892
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT16_to_INT4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/model.onnx
new file mode 100644
index 0000000..4fc5e95
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7bb6022
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..914cdda
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/model.onnx
new file mode 100644
index 0000000..9869b94
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..28e21c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4547751
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT16_to_UINT4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/model.onnx
new file mode 100644
index 0000000..885bdec
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..71be3db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1f0bb4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..88a53de
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..71be3db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..61401d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT4E2M1_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx
new file mode 100644
index 0000000..b5dd0e1
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a83379a
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..00b8c7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..0c6224e
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a83379a
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..44ed374
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/model.onnx
new file mode 100644
index 0000000..9c24c66
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dda430c
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc6c366
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..b44b4ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dda430c
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..82562eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx
new file mode 100644
index 0000000..2420804
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9d07415
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8f62ae2
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..717a119
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9d07415
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ed3f634
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/model.onnx
new file mode 100644
index 0000000..aae10f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15606ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..533619b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..38be218
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15606ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3313347
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT8E5M2_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/model.onnx
new file mode 100644
index 0000000..b956019
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc06bd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..917ad2b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/model.onnx
new file mode 100644
index 0000000..93f8c42
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc06bd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f448f0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..994f2d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc06bd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..064a1f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/model.onnx
new file mode 100644
index 0000000..2da5713
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..76566e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e0b22f4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT4E2M1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/model.onnx
new file mode 100644
index 0000000..3141e99
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..38ae244
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx
new file mode 100644
index 0000000..8f22292
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dce5a1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/model.onnx
new file mode 100644
index 0000000..0673080
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fb9379
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx
new file mode 100644
index 0000000..2489030
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2663be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/model.onnx
new file mode 100644
index 0000000..f188f05
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3a396eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b9799f9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/model.onnx
new file mode 100644
index 0000000..2db6fd6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0254197
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc2a892
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT_to_INT4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/model.onnx
new file mode 100644
index 0000000..069a72e
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3a396eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..914cdda
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/model.onnx b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/model.onnx
new file mode 100644
index 0000000..a4f7804
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0254197
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4547751
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_FLOAT_to_UINT4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/model.onnx
new file mode 100644
index 0000000..8eec072
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..87fa05c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c006424
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..e6c190b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..87fa05c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cf97e52
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT2_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_INT2_to_INT8/model.onnx b/onnx/backend/test/data/node/test_cast_INT2_to_INT8/model.onnx
new file mode 100644
index 0000000..b82bef0
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT2_to_INT8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_INT2_to_INT8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_INT2_to_INT8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..87fa05c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_INT2_to_INT8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_INT2_to_INT8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_INT2_to_INT8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..39a1b0b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT2_to_INT8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/model.onnx
new file mode 100644
index 0000000..557df2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f41f133
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8230a3c
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..98eb094
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f41f133
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d5c05ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT4_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_INT4_to_INT8/model.onnx b/onnx/backend/test/data/node/test_cast_INT4_to_INT8/model.onnx
new file mode 100644
index 0000000..3e82325
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT4_to_INT8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_INT4_to_INT8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_INT4_to_INT8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f41f133
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_INT4_to_INT8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_INT4_to_INT8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_INT4_to_INT8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e64997d
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_INT4_to_INT8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/model.onnx
new file mode 100644
index 0000000..44b0d12
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0cffe22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7197952
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..b4180ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0cffe22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..77e3a4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT2_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/model.onnx b/onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/model.onnx
new file mode 100644
index 0000000..04ec892
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0cffe22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..219929b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT2_to_UINT8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/model.onnx
new file mode 100644
index 0000000..2950d8b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aedefbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4dff11
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..1bd1869
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aedefbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc03d72
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT4_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/model.onnx b/onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/model.onnx
new file mode 100644
index 0000000..ce43809
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aedefbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2261d48
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_UINT4_to_UINT8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/model.onnx b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/model.onnx
new file mode 100644
index 0000000..22adf5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..93a1093
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bbc7f8e
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT16_to_FLOAT8E8M0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/model.onnx
new file mode 100644
index 0000000..02a8895
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6236682
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0cf3b2e
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..a14b21b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6236682
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..07d5721
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT8E8M0_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/model.onnx b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/model.onnx
new file mode 100644
index 0000000..bd28cd9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9c91567
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bbc7f8e
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_e8m0_FLOAT_to_FLOAT8E8M0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/model.onnx b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/model.onnx
new file mode 100644
index 0000000..4180561
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51295e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx
new file mode 100644
index 0000000..dc25126
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53f1efe
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/model.onnx b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/model.onnx
new file mode 100644
index 0000000..b4fe487
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67d208a
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx
new file mode 100644
index 0000000..d506a5b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1793547
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/model.onnx b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/model.onnx
new file mode 100644
index 0000000..fe86af3
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51295e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx
new file mode 100644
index 0000000..89ef163
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53f1efe
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/model.onnx b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/model.onnx
new file mode 100644
index 0000000..b4d494f
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67d208a
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx
new file mode 100644
index 0000000..65f447b
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1793547
Binary files /dev/null and b/onnx/backend/test/data/node/test_cast_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/model.onnx
new file mode 100644
index 0000000..7755bef
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6c7eaa6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..172c637
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..77d2b00
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6c7eaa6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..172c637
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_BFLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/model.onnx
new file mode 100644
index 0000000..4f769b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6e6cf2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..20e7394
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..a376758
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6e6cf2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..064a1f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..a442b3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6e6cf2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..064a1f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..5e08068
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6e6cf2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..20e7394
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_DOUBLE_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/model.onnx
new file mode 100644
index 0000000..fbba412
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a2fa86
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5b79afa
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a07e311
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/model.onnx
new file mode 100644
index 0000000..dde21a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a2fa86
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5b79afa
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a07e311
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_DOUBLE_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/model.onnx
new file mode 100644
index 0000000..1db0481
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a2fa86
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a12d09b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/model.onnx
new file mode 100644
index 0000000..f86bb90
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4506593
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c07ffb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e0b22f4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/model.onnx
new file mode 100644
index 0000000..d14b082
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4506593
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c07ffb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e0b22f4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT4E2M1_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/model.onnx
new file mode 100644
index 0000000..9e6d61c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..95fe222
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..38ae244
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx
new file mode 100644
index 0000000..f09d9c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c168fdf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dce5a1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/model.onnx
new file mode 100644
index 0000000..4a8e2ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c168fdf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dce5a1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/model.onnx
new file mode 100644
index 0000000..7aebd4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..95fe222
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..38ae244
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/model.onnx
new file mode 100644
index 0000000..c8e00f6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7f203b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fb9379
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx
new file mode 100644
index 0000000..3cd2b38
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f83b810
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2663be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/model.onnx
new file mode 100644
index 0000000..7ae3295
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f83b810
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2663be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/model.onnx
new file mode 100644
index 0000000..fa43017
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7f203b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fb9379
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..e3e33b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a2fa86
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a12d09b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/model.onnx
new file mode 100644
index 0000000..7e2244b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7bb6022
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..88a020a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b9799f9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/model.onnx
new file mode 100644
index 0000000..7e5e603
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7bb6022
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..88a020a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b9799f9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT2_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/model.onnx
new file mode 100644
index 0000000..f58b198
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..28e21c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e5b7e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc2a892
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/model.onnx
new file mode 100644
index 0000000..6bcca8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..28e21c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e5b7e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc2a892
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_INT4_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/model.onnx
new file mode 100644
index 0000000..0548378
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7bb6022
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..758d3b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..914cdda
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/model.onnx
new file mode 100644
index 0000000..08fc73c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7bb6022
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..758d3b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..914cdda
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT2_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/model.onnx
new file mode 100644
index 0000000..8e5dbcf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..28e21c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bc9502f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4547751
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/model.onnx
new file mode 100644
index 0000000..19c1244
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..28e21c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bc9502f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4547751
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT16_to_UINT4_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/model.onnx
new file mode 100644
index 0000000..dec055f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..71be3db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1f0bb4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..de13ead
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..71be3db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..61401d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..9134bdf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..71be3db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..61401d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..a50c763
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..71be3db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1f0bb4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT4E2M1_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx
new file mode 100644
index 0000000..a8a770f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a83379a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..00b8c7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..09b5846
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a83379a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..44ed374
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..62bedf0
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a83379a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..44ed374
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..59b3dc9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a83379a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..00b8c7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/model.onnx
new file mode 100644
index 0000000..5d9a31f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dda430c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc6c366
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..10b6852
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dda430c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..82562eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..5fd16b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dda430c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..82562eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..967e56b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dda430c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc6c366
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E4M3FN_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx
new file mode 100644
index 0000000..3d50a62
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9d07415
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8f62ae2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..523256a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9d07415
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ed3f634
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..d923d79
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9d07415
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ed3f634
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..72d4c5e
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9d07415
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8f62ae2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2FNUZ_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/model.onnx
new file mode 100644
index 0000000..f96b6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15606ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..533619b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..91bcf50
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15606ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3313347
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..1aea611
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15606ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3313347
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..e26189d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15606ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..533619b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT8E5M2_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/model.onnx
new file mode 100644
index 0000000..2f764ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc06bd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ca8982d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..917ad2b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..87ecb1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc06bd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ca8982d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..917ad2b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_BFLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/model.onnx
new file mode 100644
index 0000000..a9e895e
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc06bd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5b79afa
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f448f0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/model.onnx
new file mode 100644
index 0000000..920c956
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc06bd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5b79afa
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f448f0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_DOUBLE_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..f46d06b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc06bd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..064a1f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..993baa1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc06bd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..064a1f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/model.onnx
new file mode 100644
index 0000000..8e906c4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..76566e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c07ffb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e0b22f4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/model.onnx
new file mode 100644
index 0000000..3190458
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..76566e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c07ffb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e0b22f4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT4E2M1_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/model.onnx
new file mode 100644
index 0000000..0f20ce0
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..95fe222
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..38ae244
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx
new file mode 100644
index 0000000..9fa104a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c168fdf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dce5a1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/model.onnx
new file mode 100644
index 0000000..9661f1a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c168fdf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dce5a1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/model.onnx
new file mode 100644
index 0000000..7a82d3d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..95fe222
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..38ae244
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/model.onnx
new file mode 100644
index 0000000..c046776
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7f203b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fb9379
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx
new file mode 100644
index 0000000..65038d1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f83b810
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2663be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/model.onnx
new file mode 100644
index 0000000..26b20af
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f83b810
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2663be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/model.onnx
new file mode 100644
index 0000000..769a4f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7f203b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fb9379
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/model.onnx
new file mode 100644
index 0000000..a74cd7e
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3a396eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..88a020a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b9799f9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/model.onnx
new file mode 100644
index 0000000..6e01853
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3a396eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..88a020a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b9799f9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT2_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/model.onnx
new file mode 100644
index 0000000..d4f1db1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0254197
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e5b7e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc2a892
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/model.onnx
new file mode 100644
index 0000000..7922285
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0254197
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e5b7e38
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc2a892
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_INT4_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/model.onnx
new file mode 100644
index 0000000..0167256
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3a396eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..758d3b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..914cdda
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/model.onnx
new file mode 100644
index 0000000..2d9c7b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3a396eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..758d3b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..914cdda
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT2_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/model.onnx
new file mode 100644
index 0000000..727f0b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0254197
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bc9502f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4547751
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/model.onnx
new file mode 100644
index 0000000..22872d6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0254197
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bc9502f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4547751
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_FLOAT_to_UINT4_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/model.onnx
new file mode 100644
index 0000000..4b411ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..87fa05c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c006424
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..6674b94
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..87fa05c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cf97e52
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..e84bbe3
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..87fa05c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cf97e52
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..7a3313e
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..87fa05c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c006424
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/model.onnx b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/model.onnx
new file mode 100644
index 0000000..32891a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..87fa05c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4f92b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..39a1b0b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/model.onnx
new file mode 100644
index 0000000..0c9442f
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..87fa05c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4f92b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..39a1b0b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT2_to_INT8_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/model.onnx
new file mode 100644
index 0000000..a8c3f5e
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f41f133
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8230a3c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..ec9c5f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f41f133
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d5c05ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..245fe4d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f41f133
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d5c05ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..5f7a228
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f41f133
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8230a3c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/model.onnx b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/model.onnx
new file mode 100644
index 0000000..f9f556b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f41f133
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4f92b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e64997d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/model.onnx
new file mode 100644
index 0000000..5d9b389
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f41f133
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4f92b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e64997d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_INT4_to_INT8_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/model.onnx
new file mode 100644
index 0000000..e13c36b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0cffe22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7197952
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..88d6fde
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0cffe22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..77e3a4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..fc6e452
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0cffe22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..77e3a4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..eae0738
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0cffe22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7197952
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/model.onnx
new file mode 100644
index 0000000..5606149
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0cffe22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..254f957
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..219929b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/model.onnx
new file mode 100644
index 0000000..500a903
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0cffe22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ99
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..254f957
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..219929b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT2_to_UINT8_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/model.onnx
new file mode 100644
index 0000000..850859b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aedefbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4dff11
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/model.onnx
new file mode 100644
index 0000000..a4b9716
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aedefbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc03d72
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/model.onnx
new file mode 100644
index 0000000..833e6d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aedefbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41b137d
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc03d72
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/model.onnx
new file mode 100644
index 0000000..88493a4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aedefbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b37db7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4dff11
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_FLOAT_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/model.onnx
new file mode 100644
index 0000000..9ec3180
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aedefbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..254f957
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2261d48
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/model.onnx
new file mode 100644
index 0000000..0aedbc7
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aedefbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BinputJ
����!Ce����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..254f957
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2261d48
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_UINT4_to_UINT8_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/model.onnx
new file mode 100644
index 0000000..e707f20
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..95fe222
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51295e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx
new file mode 100644
index 0000000..968cab2
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c168fdf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53f1efe
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/model.onnx
new file mode 100644
index 0000000..15d755b
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c168fdf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53f1efe
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/model.onnx
new file mode 100644
index 0000000..8e92a76
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..95fe222
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51295e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/model.onnx
new file mode 100644
index 0000000..a0ba3f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7f203b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67d208a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx
new file mode 100644
index 0000000..59d89d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f83b810
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1793547
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/model.onnx
new file mode 100644
index 0000000..7b17fe1
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f83b810
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1793547
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/model.onnx
new file mode 100644
index 0000000..e8fe50e
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ed86eb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7f203b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67d208a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT16_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/model.onnx
new file mode 100644
index 0000000..27bd8d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..95fe222
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51295e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx
new file mode 100644
index 0000000..256579c
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c168fdf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53f1efe
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/model.onnx
new file mode 100644
index 0000000..4f866cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c168fdf
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53f1efe
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FNUZ_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/model.onnx
new file mode 100644
index 0000000..6040c40
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..95fe222
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51295e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E4M3FN_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/model.onnx
new file mode 100644
index 0000000..52fc347
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7f203b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67d208a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx
new file mode 100644
index 0000000..7b504b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f83b810
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1793547
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/model.onnx
new file mode 100644
index 0000000..4272049
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f83b810
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1793547
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2FNUZ_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/model.onnx b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/model.onnx
new file mode 100644
index 0000000..8f84d40
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a1984e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7f203b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67d208a
Binary files /dev/null and b/onnx/backend/test/data/node/test_castlike_no_saturate_FLOAT_to_FLOAT8E5M2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/model.onnx
new file mode 100644
index 0000000..57e74cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ff40efd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


BinputJx��?h��>��z?�j@$�?�.z�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..81001cf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+


BweightJ�8s?b��hdӽ�9�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..103bded
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


BoutputJ�l9?X������=7�@�~D?��Y�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..943bdc4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


B
present_stateJ�j@$�?�.z�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/model.onnx
new file mode 100644
index 0000000..91e2811
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ff40efd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


BinputJx��?h��>��z?�j@$�?�.z�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..81001cf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+


BweightJ�8s?b��hdӽ�9�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..103bded
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


BoutputJ�l9?X������=7�@�~D?��Y�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..943bdc4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_b1_c1_degenerate_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


B
present_stateJ�j@$�?�.z�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/model.onnx
new file mode 100644
index 0000000..454a703
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..868a357
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_basic/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/model.onnx
new file mode 100644
index 0000000..d665ea0
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..868a357
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_basic_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/model.onnx
new file mode 100644
index 0000000..8eda86d
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0b9ef3f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

BinputJ x��?h��>��z?�j@$�?�.z��8s?b��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cad0e00
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bdb02b3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ�C@�(��Hm;= �?�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..4898c8a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+
B
+past_stateJ`2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9762f79
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BoutputJ خ�@"L
�B�t�����{�@�c
�XS�4�^>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ab4774e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`��?��>x��?�Ec�����h��>� >*z�?��z?�Oƾmǚ��j@&õ�gڿ$�?�x�FK��.z��	G?4�ο�8s?L=e��>b��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/model.onnx
new file mode 100644
index 0000000..43f40f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0b9ef3f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

BinputJ x��?h��>��z?�j@$�?�.z��8s?b��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cad0e00
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bdb02b3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ�C@�(��Hm;= �?�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..4898c8a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+
B
+past_stateJ`2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9762f79
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BoutputJ خ�@"L
�B�t�����{�@�c
�XS�4�^>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ab4774e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_decode_step_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`��?��>x��?�Ec�����h��>� >*z�?��z?�Oƾmǚ��j@&õ�gڿ$�?�x�FK��.z��	G?4�ο�8s?L=e��>b��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/model.onnx
new file mode 100644
index 0000000..40d5366
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4605c53
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e66c99c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+BweightJ J2�5�:7.�:&.�;�7�;�8�9)�4�/�4�/
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9bdc76b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+BoutputJ�
�*)8�:Z;�:�9�:#:;7|<�:v?�<�>�=f9}*D9�<�?@@>?1#/3=4R8�5�7�5�)�69�5{9Z:�;�<e1s8O:6<p:9>�:;T"�3�7�;A<:>q<�<�,'3�26
33\2N4
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..10330f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/model.onnx
new file mode 100644
index 0000000..72cd95e
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4605c53
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e66c99c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+BweightJ J2�5�:7.�:&.�;�7�;�8�9)�4�/�4�/
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9bdc76b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+BoutputJ�
�*)8�:Z;�:�9�:#:;7|<�:v?�<�>�=f9}*D9�<�?@@>?1#/3=4R8�5�7�5�)�69�5{9Z:�;�<e1s8O:6<p:9>�:;T"�3�7�;A<:>q<�<�,'3�26
33\2N4
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..10330f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_fp16_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/model.onnx
new file mode 100644
index 0000000..0674c23
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..56eded2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+


BweightJ3�5>;�;W���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5e5acba
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2637114
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/model.onnx
new file mode 100644
index 0000000..0a3b28a
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..56eded2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+


BweightJ3�5>;�;W���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5e5acba
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2637114
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_kernel_size_one_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/model.onnx
new file mode 100644
index 0000000..d11e409
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d896c4a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ@x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..555a164
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJP�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1c0059c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ@��� �!�b3���τ��(�>��%@F>B[����>��u��V����{��=0��?O �=|kѽ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..29955cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/model.onnx
new file mode 100644
index 0000000..773a239
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d896c4a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ@x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..555a164
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJP�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1c0059c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BoutputJ@��� �!�b3���τ��(�>��%@F>B[����>��u��V����{��=0��?O �=|kѽ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..29955cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_short_input_no_past_state_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/model.onnx
new file mode 100644
index 0000000..9037a73
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9f67bcf
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/model.onnx
new file mode 100644
index 0000000..dfe504f
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9f67bcf
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/model.onnx
new file mode 100644
index 0000000..4fb8778
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4605c53
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e66c99c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+BweightJ J2�5�:7.�:&.�;�7�;�8�9)�4�/�4�/
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0861061
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+BoutputJ�

'85�8A9�8�7�818k4�:�8v>8;�=�<'7~<&�6�:�>:?E?9>>�+�/�0v5�2�4�2�%)4�63J7`8q9J;�-�5V8>:s8#=�89^r0�4�9S:$=�:H;()�/a/F3�/�/�.�0
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..10330f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/model.onnx
new file mode 100644
index 0000000..b6b091e
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4605c53
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e66c99c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+BweightJ J2�5�:7.�:&.�;�7�;�8�9)�4�/�4�/
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0861061
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+BoutputJ�

'85�8A9�8�7�818k4�:�8v>8;�=�<'7~<&�6�:�>:?E?9>>�+�/�0v5�2�4�2�%)4�63J7`8q9J;�-�5V8>:s8#=�89^r0�4�9S:$=�:H;()�/a/F3�/�/�.�0
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..10330f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_fp16_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/model.onnx
new file mode 100644
index 0000000..2e43c31
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6e270b8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
+past_stateJ`�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..df4c04a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BoutputJ�}OD�PZ,�����T&����Žy�
E�?A넾ٻ+@��������R�z>��?7�>FU��	����p=b��?~���@Y�	?�~��A��?���������y&{��������?���퍾�{_�tQ����>ʜX@��?
b]=�U��Xz7��-
>c�>10����S�]���@cxq?��X���}t�?�^O�
+�@m�`����?�턾a��>��>Eګ?r@�><&���޼^��=��/?�?e/?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/model.onnx
new file mode 100644
index 0000000..79a700b
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6e270b8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
+past_stateJ`�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..df4c04a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BoutputJ�}OD�PZ,�����T&����Žy�
E�?A넾ٻ+@��������R�z>��?7�>FU��	����p=b��?~���@Y�	?�~��A��?���������y&{��������?���퍾�{_�tQ����>ʜX@��?
b]=�U��Xz7��-
>c�>10����S�]���@cxq?��X���}t�?�^O�
+�@m�`����?�턾a��>��>Eګ?r@�><&���޼^��=��/?�?e/?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_silu_with_past_state_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/model.onnx
new file mode 100644
index 0000000..84eb6c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9f67bcf
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/model.onnx
new file mode 100644
index 0000000..37cc95e
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9f67bcf
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_swish_alias_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/model.onnx
new file mode 100644
index 0000000..a42ecbd
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..41c665f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ�#����f?Ok�>��Ŀ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c804857
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/model.onnx
new file mode 100644
index 0000000..961377d
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..41c665f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ�#����f?Ok�>��Ŀ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..29ba3d5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+
B
+past_stateJ`�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..507deb1
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/model.onnx
new file mode 100644
index 0000000..0489753
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..41c665f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ�#����f?Ok�>��Ŀ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..29ba3d5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+
B
+past_stateJ`�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..507deb1
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_and_past_state_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/model.onnx
new file mode 100644
index 0000000..e9446e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..41c665f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ�#����f?Ok�>��Ŀ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c804857
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_bias_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/model.onnx
new file mode 100644
index 0000000..45d5c03
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6e270b8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
+past_stateJ`�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c05f26b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BoutputJ������-�BVS��о�G��&��
�?ce�5�5@����*��խ�>�K?�?�%�����(��=���?	)W���*@�H?�܁���?M	7�w.p�"������lg��C3�?9,���/����
�dr��X�?�;_@���?R��=�oɿ��&�'h>ܺ?�I]�,�;��'�w�#@�T�?���&7���k�?D��QQ�@���5�?�"e��?:?x-�?m�
+?���bd�~S7>d�s?|E?�8s?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/model.onnx b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/model.onnx
new file mode 100644
index 0000000..a6c6090
Binary files /dev/null and b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..829fffc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52743ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

BweightJ@3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6e270b8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
+past_stateJ`�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c05f26b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BoutputJ������-�BVS��о�G��&��
�?ce�5�5@����*��խ�>�K?�?�%�����(��=���?	)W���*@�H?�܁���?M	7�w.p�"������lg��C3�?9,���/����
�dr��X�?�;_@���?R��=�oɿ��&�'h>ܺ?�I]�,�;��'�w�#@�T�?���&7���k�?D��QQ�@���5�?�"e��?:?x-�?m�
+?���bd�~S7>d�s?|E?�8s?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1803e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_causal_conv_with_state_with_past_state_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
B
present_stateJ`�.z��8s?b���0�=B�>]ת>�S'?�K]?��=���?��>���>��?�Oƾmǚ�FKྙ[���	G?���k��QN�>Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_ceil/model.onnx b/onnx/backend/test/data/node/test_ceil/model.onnx
new file mode 100644
index 0000000..7082df3
Binary files /dev/null and b/onnx/backend/test/data/node/test_ceil/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_ceil/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ceil/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_ceil/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_ceil/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ceil/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ca53955
Binary files /dev/null and b/onnx/backend/test/data/node/test_ceil/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ceil_example/model.onnx b/onnx/backend/test/data/node/test_ceil_example/model.onnx
new file mode 100644
index 0000000..74ce0e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_ceil_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_ceil_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_ceil_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b9a2ac3
Binary files /dev/null and b/onnx/backend/test/data/node/test_ceil_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_ceil_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_ceil_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b2814a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_ceil_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_celu/model.onnx b/onnx/backend/test/data/node/test_celu/model.onnx
new file mode 100644
index 0000000..a0ead46
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_celu/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_celu/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb4a0b0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_celu/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
XJlNX??�o=���<�>��
?9�K?2�p?ldt?��5>��>t��>�,?�j�<[�?̐l?U�x?��=W��>B�i?��?��Q?]HI?��=�F1?��
+?�ޙ=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_celu/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_celu/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5ae597
--- /dev/null
+++ b/onnx/backend/test/data/node/test_celu/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+

B
YJlNX??�o=���<�>��
?9�K?2�p?ldt?��5>��>t��>�,?�j�<[�?̐l?U�x?��=W��>B�i?��?��Q?]HI?��=�F1?��
+?�ޙ=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_celu_bfloat16/model.onnx b/onnx/backend/test/data/node/test_celu_bfloat16/model.onnx
new file mode 100644
index 0000000..c44dbb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_bfloat16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_celu_bfloat16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_celu_bfloat16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9c0ebbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_bfloat16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_celu_bfloat16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_celu_bfloat16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4c1d5ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_bfloat16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_celu_bfloat16_expanded/model.onnx b/onnx/backend/test/data/node/test_celu_bfloat16_expanded/model.onnx
new file mode 100644
index 0000000..f4202ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_bfloat16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_celu_bfloat16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_celu_bfloat16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9c0ebbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_bfloat16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_celu_bfloat16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_celu_bfloat16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4c1d5ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_bfloat16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_celu_expanded/model.onnx b/onnx/backend/test/data/node/test_celu_expanded/model.onnx
new file mode 100644
index 0000000..36bde02
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb4a0b0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
XJlNX??�o=���<�>��
?9�K?2�p?ldt?��5>��>t��>�,?�j�<[�?̐l?U�x?��=W��>B�i?��?��Q?]HI?��=�F1?��
+?�ޙ=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5ae597
--- /dev/null
+++ b/onnx/backend/test/data/node/test_celu_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+

B
YJlNX??�o=���<�>��
?9�K?2�p?ldt?��5>��>t��>�,?�j�<[�?̐l?U�x?��=W��>B�i?��?��Q?]HI?��=�F1?��
+?�ޙ=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_celu_float16/model.onnx b/onnx/backend/test/data/node/test_celu_float16/model.onnx
new file mode 100644
index 0000000..f130e75
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_celu_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_celu_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f1cc3c9
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_float16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_celu_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_celu_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..608e556
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_float16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_celu_float16_expanded/model.onnx b/onnx/backend/test/data/node/test_celu_float16_expanded/model.onnx
new file mode 100644
index 0000000..960ca20
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_float16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_celu_float16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_celu_float16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f1cc3c9
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_float16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_celu_float16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_celu_float16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..608e556
Binary files /dev/null and b/onnx/backend/test/data/node/test_celu_float16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop/model.onnx
new file mode 100644
index 0000000..607959b
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..08678b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f66194e
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..89fb4f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/model.onnx
new file mode 100644
index 0000000..7ef0949
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a91719
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3f36f83
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d7be5d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/model.onnx
new file mode 100644
index 0000000..9f2b3c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a91719
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3f36f83
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d7be5d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_and_pad_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/model.onnx
new file mode 100644
index 0000000..2043268
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fb02a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4ec8595
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..543af35
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/model.onnx
new file mode 100644
index 0000000..ed9d45f
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fb02a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4ec8595
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..543af35
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_chw_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/model.onnx
new file mode 100644
index 0000000..df9a2f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a91719
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4ec8595
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d7fad01
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/model.onnx
new file mode 100644
index 0000000..c3be109
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a91719
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4ec8595
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d7fad01
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_axes_hwc_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/model.onnx
new file mode 100644
index 0000000..980df9f
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..08678b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f66194e
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..89fb4f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/model.onnx
new file mode 100644
index 0000000..1bed622
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a91719
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4ec8595
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d7fad01
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/model.onnx
new file mode 100644
index 0000000..57a0e3e
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a91719
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4ec8595
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d7fad01
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_crop_negative_axes_hwc_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_pad/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_pad/model.onnx
new file mode 100644
index 0000000..d9ce933
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5059e54
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..be74c6e
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..20b9855
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_pad/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/model.onnx b/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/model.onnx
new file mode 100644
index 0000000..e614c78
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5059e54
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..be74c6e
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..20b9855
Binary files /dev/null and b/onnx/backend/test/data/node/test_center_crop_pad_pad_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip/model.onnx b/onnx/backend/test/data/node/test_clip/model.onnx
new file mode 100644
index 0000000..68cecb5
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_clip/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_clip/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d79b11f
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cafe4fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..988707f
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_inbounds/model.onnx b/onnx/backend/test/data/node/test_clip_default_inbounds/model.onnx
new file mode 100644
index 0000000..dab57de
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_inbounds/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0b9013
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_inbounds/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_inbounds_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_default_inbounds_expanded/model.onnx
new file mode 100644
index 0000000..6c1c832
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_inbounds_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0b9013
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_inbounds_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_inbounds/model.onnx b/onnx/backend/test/data/node/test_clip_default_int8_inbounds/model.onnx
new file mode 100644
index 0000000..b83039d
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_inbounds/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb14958
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c1139a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_inbounds/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/model.onnx
new file mode 100644
index 0000000..36d0b8a
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb14958
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c1139a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_inbounds_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_max/model.onnx b/onnx/backend/test/data/node/test_clip_default_int8_max/model.onnx
new file mode 100644
index 0000000..2bf5bda
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_max/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..631490b
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..615a814
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9d5ad39
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_max/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/model.onnx
new file mode 100644
index 0000000..cd1b494
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..631490b
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..615a814
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9d5ad39
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_max_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_min/model.onnx b/onnx/backend/test/data/node/test_clip_default_int8_min/model.onnx
new file mode 100644
index 0000000..cb275f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_min/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ec96b45
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0892038
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c26bf83
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_min/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/model.onnx
new file mode 100644
index 0000000..76c653b
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ec96b45
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0892038
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c26bf83
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_int8_min_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_max/model.onnx b/onnx/backend/test/data/node/test_clip_default_max/model.onnx
new file mode 100644
index 0000000..ee3dda6
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_max/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..96a2566
--- /dev/null
+++ b/onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2d8f7a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60eb82b
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_max/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_max_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_default_max_expanded/model.onnx
new file mode 100644
index 0000000..4113368
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_max_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..96a2566
--- /dev/null
+++ b/onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2d8f7a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60eb82b
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_max_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_min/model.onnx b/onnx/backend/test/data/node/test_clip_default_min/model.onnx
new file mode 100644
index 0000000..2ea1b32
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_min/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c2bfba0
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9210c94
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_min/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_min_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_default_min_expanded/model.onnx
new file mode 100644
index 0000000..0c5dab8
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_min_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c2bfba0
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9210c94
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_default_min_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_example/model.onnx b/onnx/backend/test/data/node/test_clip_example/model.onnx
new file mode 100644
index 0000000..12dcc44
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a0ab454
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d79b11f
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cafe4fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0b9013
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_example_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_example_expanded/model.onnx
new file mode 100644
index 0000000..757c2ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a0ab454
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d79b11f
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cafe4fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0b9013
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_expanded/model.onnx
new file mode 100644
index 0000000..53e1f1a
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d79b11f
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cafe4fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..988707f
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds/model.onnx b/onnx/backend/test/data/node/test_clip_inbounds/model.onnx
new file mode 100644
index 0000000..cd66ff1
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..aaaeb64
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5cfc885
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0b9013
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_inbounds_expanded/model.onnx
new file mode 100644
index 0000000..505d024
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..aaaeb64
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5cfc885
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0b9013
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_inbounds_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max/model.onnx b/onnx/backend/test/data/node/test_clip_min_greater_than_max/model.onnx
new file mode 100644
index 0000000..4935aa2
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f40ec6d
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fd4d038
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cafe4fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..82e7d87
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/model.onnx
new file mode 100644
index 0000000..9b83b1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f40ec6d
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fd4d038
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cafe4fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..82e7d87
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_min_greater_than_max_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds/model.onnx b/onnx/backend/test/data/node/test_clip_outbounds/model.onnx
new file mode 100644
index 0000000..eae8542
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9c5dc72
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..aaaeb64
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5cfc885
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..75f56e1
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_outbounds_expanded/model.onnx
new file mode 100644
index 0000000..2c9fe28
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9c5dc72
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..aaaeb64
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5cfc885
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..75f56e1
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_outbounds_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds/model.onnx b/onnx/backend/test/data/node/test_clip_splitbounds/model.onnx
new file mode 100644
index 0000000..b5bde36
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ff367a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..aaaeb64
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5cfc885
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0123d92
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds_expanded/model.onnx b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/model.onnx
new file mode 100644
index 0000000..cac7acc
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ff367a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..aaaeb64
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5cfc885
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0123d92
Binary files /dev/null and b/onnx/backend/test/data/node/test_clip_splitbounds_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im/model.onnx b/onnx/backend/test/data/node/test_col2im/model.onnx
new file mode 100644
index 0000000..fb9d14d
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_col2im/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_col2im/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..164166b
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_col2im/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e2e47c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_col2im/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c0b7595
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_col2im/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..28d4701
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_5d/model.onnx b/onnx/backend/test/data/node/test_col2im_5d/model.onnx
new file mode 100644
index 0000000..f54a1c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_5d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0b66e3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5505bda
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3abcacd
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cdb3bba
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_5d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_dilations/model.onnx b/onnx/backend/test/data/node/test_col2im_dilations/model.onnx
new file mode 100644
index 0000000..9b67a47
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_dilations/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bc96c5a
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ed056b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ea04f67
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cefb7d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_dilations/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_pads/model.onnx b/onnx/backend/test/data/node/test_col2im_pads/model.onnx
new file mode 100644
index 0000000..2ee9a67
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_pads/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cccac0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e2e47c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c0b7595
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..50fd1c7
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_pads/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_strides/model.onnx b/onnx/backend/test/data/node/test_col2im_strides/model.onnx
new file mode 100644
index 0000000..60ba7fb
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_strides/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f33a762
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e2e47c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..19b497c
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..df3f1bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_col2im_strides/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_0/model.onnx b/onnx/backend/test/data/node/test_compress_0/model.onnx
new file mode 100644
index 0000000..36ebd92
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4013bc6
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c8d8c4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_compress_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..787c925
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_1/model.onnx b/onnx/backend/test/data/node/test_compress_1/model.onnx
new file mode 100644
index 0000000..040e28e
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4013bc6
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c00e46c
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_compress_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..695a73b
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_default_axis/model.onnx b/onnx/backend/test/data/node/test_compress_default_axis/model.onnx
new file mode 100644
index 0000000..8a0f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_default_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4013bc6
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0b6c330
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..70260a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_default_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_negative_axis/model.onnx b/onnx/backend/test/data/node/test_compress_negative_axis/model.onnx
new file mode 100644
index 0000000..4b8d935
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_negative_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4013bc6
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c00e46c
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..695a73b
Binary files /dev/null and b/onnx/backend/test/data/node/test_compress_negative_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_1d_axis_0/model.onnx b/onnx/backend/test/data/node/test_concat_1d_axis_0/model.onnx
new file mode 100644
index 0000000..464b6e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_1d_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..956756d
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fe6e05f
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be680bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_1d_axis_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/model.onnx b/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/model.onnx
new file mode 100644
index 0000000..4c7acf6
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..956756d
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fe6e05f
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be680bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_1d_axis_negative_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_0/model.onnx b/onnx/backend/test/data/node/test_concat_2d_axis_0/model.onnx
new file mode 100644
index 0000000..85d89ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c04418c
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..13e244f
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..def8bc4
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_1/model.onnx b/onnx/backend/test/data/node/test_concat_2d_axis_1/model.onnx
new file mode 100644
index 0000000..9fdc077
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c04418c
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..13e244f
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1260354
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/model.onnx b/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/model.onnx
new file mode 100644
index 0000000..a20ee8a
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c04418c
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..13e244f
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1260354
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_negative_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/model.onnx b/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/model.onnx
new file mode 100644
index 0000000..b1850b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c04418c
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..13e244f
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..def8bc4
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_2d_axis_negative_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_0/model.onnx b/onnx/backend/test/data/node/test_concat_3d_axis_0/model.onnx
new file mode 100644
index 0000000..e4db22d
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bb523
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b71b84
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d3ffbb5
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_1/model.onnx b/onnx/backend/test/data/node/test_concat_3d_axis_1/model.onnx
new file mode 100644
index 0000000..6e10269
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bb523
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b71b84
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d03e552
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_2/model.onnx b/onnx/backend/test/data/node/test_concat_3d_axis_2/model.onnx
new file mode 100644
index 0000000..4f770c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bb523
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b71b84
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b4de73e
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/model.onnx b/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/model.onnx
new file mode 100644
index 0000000..5ee0cb1
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bb523
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b71b84
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b4de73e
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/model.onnx b/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/model.onnx
new file mode 100644
index 0000000..d6bd6f6
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bb523
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b71b84
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d03e552
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/model.onnx b/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/model.onnx
new file mode 100644
index 0000000..ccb2687
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bb523
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b71b84
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d3ffbb5
Binary files /dev/null and b/onnx/backend/test/data/node/test_concat_3d_axis_negative_3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_constant/model.onnx b/onnx/backend/test/data/node/test_constant/model.onnx
new file mode 100644
index 0000000..4e4be4c
Binary files /dev/null and b/onnx/backend/test/data/node/test_constant/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_constant/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_constant/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7e2d912
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BvaluesJdx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad/model.onnx b/onnx/backend/test/data/node/test_constant_pad/model.onnx
new file mode 100644
index 0000000..be60cda
Binary files /dev/null and b/onnx/backend/test/data/node/test_constant_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..09d5a14
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..14c2aba
Binary files /dev/null and b/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..61cc724
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BvalueJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..306f7de
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ����?���?���?���?���?���?���?���?���?���?���?���?���?���?���?x��?h��>��z?�j@$�?���?���?���?���?���?���?���?�.z��8s?b��hdӽ�9�>���?���?���?���?���?���?���?(�>�%�?^�B?�0�=B�>���?���?���?���?���?���?���?]ת>�=�?R�iJ�>�Z����?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?/d#��S'?�K]?��=��C@���?���?���?���?���?���?���?�(��Hm;= �?�2�?��?���?���?���?���?���?���?���?��>���>�Ec������!�����?���?���?���?���?���?���?� >*z�?��?�Oƾmǚ����?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�6��&õ�gڿ��?�x����?���?���?���?���?���?���?FKྙ[���	G?4�ο��Y����?���?���?���?���?���?���?L=e��> �����k�漚��?���?���?���?���?���?���?QN�>.:�=�ݚ>�b"�6������?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad_axes/model.onnx b/onnx/backend/test/data/node/test_constant_pad_axes/model.onnx
new file mode 100644
index 0000000..2fb966e
Binary files /dev/null and b/onnx/backend/test/data/node/test_constant_pad_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..09d5a14
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8a023a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..61cc724
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BvalueJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..21019cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7db6e18
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad_axes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ����?���?���?x��?h��>��z?�j@$�?���?���?���?���?���?���?���?�.z��8s?b��hdӽ�9�>���?���?���?���?���?���?���?(�>�%�?^�B?�0�=B�>���?���?���?���?���?���?���?]ת>�=�?R�iJ�>�Z����?���?���?���?���?���?���?/d#��S'?�K]?��=��C@���?���?���?���?���?���?���?�(��Hm;= �?�2�?��?���?���?���?���?���?���?���?��>���>�Ec������!�����?���?���?���?���?���?���?� >*z�?��?�Oƾmǚ����?���?���?���?���?���?���?�6��&õ�gڿ��?�x����?���?���?���?���?���?���?FKྙ[���	G?4�ο��Y����?���?���?���?���?���?���?L=e��> �����k�漚��?���?���?���?���?���?���?QN�>.:�=�ݚ>�b"�6������?���?���?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad_negative_axes/model.onnx b/onnx/backend/test/data/node/test_constant_pad_negative_axes/model.onnx
new file mode 100644
index 0000000..f8144dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_constant_pad_negative_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..09d5a14
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8a023a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..61cc724
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BvalueJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..adf5320
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+BaxesJ����������������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7db6e18
--- /dev/null
+++ b/onnx/backend/test/data/node/test_constant_pad_negative_axes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ����?���?���?x��?h��>��z?�j@$�?���?���?���?���?���?���?���?�.z��8s?b��hdӽ�9�>���?���?���?���?���?���?���?(�>�%�?^�B?�0�=B�>���?���?���?���?���?���?���?]ת>�=�?R�iJ�>�Z����?���?���?���?���?���?���?/d#��S'?�K]?��=��C@���?���?���?���?���?���?���?�(��Hm;= �?�2�?��?���?���?���?���?���?���?���?��>���>�Ec������!�����?���?���?���?���?���?���?� >*z�?��?�Oƾmǚ����?���?���?���?���?���?���?�6��&õ�gڿ��?�x����?���?���?���?���?���?���?FKྙ[���	G?4�ο��Y����?���?���?���?���?���?���?L=e��> �����k�漚��?���?���?���?���?���?���?QN�>.:�=�ݚ>�b"�6������?���?���?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_constantofshape_float_ones/model.onnx b/onnx/backend/test/data/node/test_constantofshape_float_ones/model.onnx
new file mode 100644
index 0000000..d9e0d59
Binary files /dev/null and b/onnx/backend/test/data/node/test_constantofshape_float_ones/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..04b9667
Binary files /dev/null and b/onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d3badd3
Binary files /dev/null and b/onnx/backend/test/data/node/test_constantofshape_float_ones/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_constantofshape_int_shape_zero/model.onnx b/onnx/backend/test/data/node/test_constantofshape_int_shape_zero/model.onnx
new file mode 100644
index 0000000..20eef7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_constantofshape_int_shape_zero/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f62ff7
Binary files /dev/null and b/onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e5181b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_constantofshape_int_shape_zero/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_constantofshape_int_zeros/model.onnx b/onnx/backend/test/data/node/test_constantofshape_int_zeros/model.onnx
new file mode 100644
index 0000000..883c284
Binary files /dev/null and b/onnx/backend/test/data/node/test_constantofshape_int_zeros/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5d50478
Binary files /dev/null and b/onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6362cca
Binary files /dev/null and b/onnx/backend/test/data/node/test_constantofshape_int_zeros/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_autopad_same/model.onnx b/onnx/backend/test/data/node/test_conv_with_autopad_same/model.onnx
new file mode 100644
index 0000000..47dc4a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_autopad_same/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..063e191
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6d5f1a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0aef738
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_autopad_same/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/model.onnx b/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/model.onnx
new file mode 100644
index 0000000..cfa8ad0
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..275a5b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6d5f1a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3ddea28
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_and_asymmetric_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_no_padding/model.onnx b/onnx/backend/test/data/node/test_conv_with_strides_no_padding/model.onnx
new file mode 100644
index 0000000..d4d1961
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_no_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..275a5b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6d5f1a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ec91bfd
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_no_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_padding/model.onnx b/onnx/backend/test/data/node/test_conv_with_strides_padding/model.onnx
new file mode 100644
index 0000000..adb8521
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..275a5b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6d5f1a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3d0a836
Binary files /dev/null and b/onnx/backend/test/data/node/test_conv_with_strides_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convinteger_with_padding/model.onnx b/onnx/backend/test/data/node/test_convinteger_with_padding/model.onnx
new file mode 100644
index 0000000..a293d50
Binary files /dev/null and b/onnx/backend/test/data/node/test_convinteger_with_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..33cea02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJ		
diff --git a/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0472480
--- /dev/null
+++ b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
wJ








\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6741b09
--- /dev/null
+++ b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+Bx_zero_pointJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..0a9f4f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1638d02
Binary files /dev/null and b/onnx/backend/test/data/node/test_convinteger_with_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convinteger_without_padding/model.onnx b/onnx/backend/test/data/node/test_convinteger_without_padding/model.onnx
new file mode 100644
index 0000000..6d42163
Binary files /dev/null and b/onnx/backend/test/data/node/test_convinteger_without_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..33cea02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJ		
diff --git a/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..53980d9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
wJ




\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6741b09
--- /dev/null
+++ b/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+Bx_zero_pointJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f81e5d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_convinteger_without_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose/model.onnx b/onnx/backend/test/data/node/test_convtranspose/model.onnx
new file mode 100644
index 0000000..302c761
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fed94a
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..56545d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e9d5fbb
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_1d/model.onnx b/onnx/backend/test/data/node/test_convtranspose_1d/model.onnx
new file mode 100644
index 0000000..a1b9bca
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..044c8ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cd46a39
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d573578
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_3d/model.onnx b/onnx/backend/test/data/node/test_convtranspose_3d/model.onnx
new file mode 100644
index 0000000..44bfb7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..641c08f
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2e776a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..393c55e
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_autopad_same/model.onnx b/onnx/backend/test/data/node/test_convtranspose_autopad_same/model.onnx
new file mode 100644
index 0000000..cce8a8e
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_autopad_same/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fed94a
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..56545d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9a2f7db
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_autopad_same/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_dilations/model.onnx b/onnx/backend/test/data/node/test_convtranspose_dilations/model.onnx
new file mode 100644
index 0000000..58e922a
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_dilations/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a7469a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..18bbc26
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ebe2192
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_dilations/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_group_2/model.onnx b/onnx/backend/test/data/node/test_convtranspose_group_2/model.onnx
new file mode 100644
index 0000000..9e7a5b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_group_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c98410d
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f5f5f2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e4fe344
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_group_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/model.onnx b/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/model.onnx
new file mode 100644
index 0000000..9160c72
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..362e410
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f5f5f2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9a6e415
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_group_2_image_3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_kernel_shape/model.onnx b/onnx/backend/test/data/node/test_convtranspose_kernel_shape/model.onnx
new file mode 100644
index 0000000..4d328e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_kernel_shape/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fed94a
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..56545d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f24a3ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_kernel_shape/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_output_shape/model.onnx b/onnx/backend/test/data/node/test_convtranspose_output_shape/model.onnx
new file mode 100644
index 0000000..8b9b862
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_output_shape/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fed94a
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..56545d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f24a3ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_output_shape/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_pad/model.onnx b/onnx/backend/test/data/node/test_convtranspose_pad/model.onnx
new file mode 100644
index 0000000..b972e26
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fed94a
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..56545d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f24a3ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_pad/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_pads/model.onnx b/onnx/backend/test/data/node/test_convtranspose_pads/model.onnx
new file mode 100644
index 0000000..1e71164
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_pads/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fed94a
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..56545d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1eccb0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_convtranspose_pads/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cos/model.onnx b/onnx/backend/test/data/node/test_cos/model.onnx
new file mode 100644
index 0000000..9e1260a
Binary files /dev/null and b/onnx/backend/test/data/node/test_cos/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cos/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cos/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cos/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cos/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cos/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9733991
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cos/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
B
yJ�
)�D���k?��?�������
-?x�?�}?2�~?ɸj?IY}?c�=�_9?y~?�1g?b�q?y��=��z?��s?�*(?j�T�J<K?e)&?}�<?7�$�W��=g�?;�{?:�=Rc�=��|?��m?ϑ!?�̾��p?��|?M��>d�>;	m?+dt?f�>
�>#M
+��潾Ow_?s�g?�>�q6?.}0��:z?$
+ ?�m?hR_?��>��?x�h?o?�`t?�3N?kWo?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cos_example/model.onnx b/onnx/backend/test/data/node/test_cos_example/model.onnx
new file mode 100644
index 0000000..b74fcbe
Binary files /dev/null and b/onnx/backend/test/data/node/test_cos_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cos_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cos_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_cos_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cos_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cos_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5791183
Binary files /dev/null and b/onnx/backend/test/data/node/test_cos_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cosh/model.onnx b/onnx/backend/test/data/node/test_cosh/model.onnx
new file mode 100644
index 0000000..e74ac53
Binary files /dev/null and b/onnx/backend/test/data/node/test_cosh/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cosh/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cosh/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cosh/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cosh/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cosh/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..495ee64
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cosh/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
�<@@�b�?B\�?!!�@'T@�%�?�?�?x�?���?9�?�T�?gz@1�?��?;ь?)1�?��@��?�R�?>��?���@LT�?��?]�?^|�@w}@P"�?�?�?U@�r@%��?C�?ص?�]l@@Ӈ?S��?@��?q9�?ظ�?��?�
�?�@�6@G�e@���?�z�?�J�?��?2'@Q�?^׶?T��?��?��?
�?/�?�H�?l�?_��?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cosh_example/model.onnx b/onnx/backend/test/data/node/test_cosh_example/model.onnx
new file mode 100644
index 0000000..7dc7ab4
Binary files /dev/null and b/onnx/backend/test/data/node/test_cosh_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cosh_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cosh_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_cosh_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cosh_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cosh_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..28e3ded
Binary files /dev/null and b/onnx/backend/test/data/node/test_cosh_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d/model.onnx b/onnx/backend/test/data/node/test_cumprod_1d/model.onnx
new file mode 100644
index 0000000..5281803
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5a92807
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d0e0cb7
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_exclusive/model.onnx b/onnx/backend/test/data/node/test_cumprod_1d_exclusive/model.onnx
new file mode 100644
index 0000000..c7e40c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_exclusive/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5a92807
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c6e55d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_exclusive/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/model.onnx b/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/model.onnx
new file mode 100644
index 0000000..2540146
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..503b2f6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3c77633
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_int32_exclusive/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_reverse/model.onnx b/onnx/backend/test/data/node/test_cumprod_1d_reverse/model.onnx
new file mode 100644
index 0000000..85611ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_reverse/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5a92807
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2a64f57
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_reverse/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/model.onnx b/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/model.onnx
new file mode 100644
index 0000000..6a925dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5a92807
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6cf4e34
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_1d_reverse_exclusive/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_axis_0/model.onnx b/onnx/backend/test/data/node/test_cumprod_2d_axis_0/model.onnx
new file mode 100644
index 0000000..5f63add
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f274ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c15b8e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_axis_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_axis_1/model.onnx b/onnx/backend/test/data/node/test_cumprod_2d_axis_1/model.onnx
new file mode 100644
index 0000000..28769dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f274ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c00ea22
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..80b9cf8
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_axis_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_int32/model.onnx b/onnx/backend/test/data/node/test_cumprod_2d_int32/model.onnx
new file mode 100644
index 0000000..f9ecac4
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..68cf0eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6b27657
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/model.onnx b/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/model.onnx
new file mode 100644
index 0000000..46b66ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f274ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1dce0eb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+BaxisJ����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..80b9cf8
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumprod_2d_negative_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d/model.onnx b/onnx/backend/test/data/node/test_cumsum_1d/model.onnx
new file mode 100644
index 0000000..fa0689a
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5a92807
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7844c6a
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_exclusive/model.onnx b/onnx/backend/test/data/node/test_cumsum_1d_exclusive/model.onnx
new file mode 100644
index 0000000..0b4bb96
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_exclusive/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5a92807
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60b17d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_exclusive/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/model.onnx b/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/model.onnx
new file mode 100644
index 0000000..fd1d861
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..503b2f6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4a9782f
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_int32_exclusive/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_reverse/model.onnx b/onnx/backend/test/data/node/test_cumsum_1d_reverse/model.onnx
new file mode 100644
index 0000000..d06225c
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_reverse/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5a92807
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1ea0632
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_reverse/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/model.onnx b/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/model.onnx
new file mode 100644
index 0000000..5a2e531
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5a92807
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f994d03
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_1d_reverse_exclusive/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_axis_0/model.onnx b/onnx/backend/test/data/node/test_cumsum_2d_axis_0/model.onnx
new file mode 100644
index 0000000..f9f3608
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f274ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f590152
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_axis_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_axis_1/model.onnx b/onnx/backend/test/data/node/test_cumsum_2d_axis_1/model.onnx
new file mode 100644
index 0000000..e9a8db6
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f274ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c00ea22
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e3a0842
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_axis_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_int32/model.onnx b/onnx/backend/test/data/node/test_cumsum_2d_int32/model.onnx
new file mode 100644
index 0000000..c425794
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..68cf0eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ea75d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1c2d44c
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/model.onnx b/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/model.onnx
new file mode 100644
index 0000000..b67ced0
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f274ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1dce0eb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+BaxisJ����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e3a0842
Binary files /dev/null and b/onnx/backend/test/data/node/test_cumsum_2d_negative_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/model.onnx b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/model.onnx
new file mode 100644
index 0000000..a489394
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5fed94a
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2e3467d
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7415693
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..db27148
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..b3ebffd
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0ad7f78
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_mask_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/model.onnx b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/model.onnx
new file mode 100644
index 0000000..bb2b554
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cce01cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..240bc20
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e9bbacb
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9fe51dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_deform_conv_with_multiple_offset_groups/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_depthtospace_crd_mode_example/model.onnx b/onnx/backend/test/data/node/test_depthtospace_crd_mode_example/model.onnx
new file mode 100644
index 0000000..0c5b104
Binary files /dev/null and b/onnx/backend/test/data/node/test_depthtospace_crd_mode_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b779a11
Binary files /dev/null and b/onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a4b2f0a
Binary files /dev/null and b/onnx/backend/test/data/node/test_depthtospace_crd_mode_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_depthtospace_example/model.onnx b/onnx/backend/test/data/node/test_depthtospace_example/model.onnx
new file mode 100644
index 0000000..780b483
Binary files /dev/null and b/onnx/backend/test/data/node/test_depthtospace_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b779a11
Binary files /dev/null and b/onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7c25bef
Binary files /dev/null and b/onnx/backend/test/data/node/test_depthtospace_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear/model.onnx
new file mode 100644
index 0000000..2ca6aa0
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0b43ff7
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..d7beff2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+Bx_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f248d25
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_axis/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_axis/model.onnx
new file mode 100644
index 0000000..28b614c
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f5ae5cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJY"�J;W 
�c�yf
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4a72bc4
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..14b45db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+Bx_zero_pointJT�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d50e2b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_blocked/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_blocked/model.onnx
new file mode 100644
index 0000000..59a6efb
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_blocked/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..135fe74
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJY"�J;W 
!A*�c�yf
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0122921
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6b970ae
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..151b898
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_blocked/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/model.onnx
new file mode 100644
index 0000000..f1c909d
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2c92747
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..088e7f3
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/model.onnx
new file mode 100644
index 0000000..7fb53cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2c92747
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d7ac147
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..10aedff
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_float16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/model.onnx
new file mode 100644
index 0000000..388a35b
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2c92747
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a6e11c4
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..088e7f3
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e4m3fn_zero_point/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e5m2/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_e5m2/model.onnx
new file mode 100644
index 0000000..570f0ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e5m2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7ef3022
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2f3e77b
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_e5m2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/model.onnx
new file mode 100644
index 0000000..8596b99
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..41e46fe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+* :B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e5a43e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..df2e8ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_float4e2m1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int16/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_int16/model.onnx
new file mode 100644
index 0000000..b38ee3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e368e32
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ�������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..4236ae2
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7cfbb4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int2/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_int2/model.onnx
new file mode 100644
index 0000000..860a99c
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70752f4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+*�
B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e99ae5e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
*

Bx_zero_point
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d08ea36
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int4/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_int4/model.onnx
new file mode 100644
index 0000000..69e57a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ad69cd0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+*�
B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c0d4733
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
*

Bx_zero_point
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51f86b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_int4/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint16/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_uint16/model.onnx
new file mode 100644
index 0000000..d5ca563
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4ba4b69
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6503f94
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+Bx_zero_pointJ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3e72b1b
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint2/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_uint2/model.onnx
new file mode 100644
index 0000000..8dd904f
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d05a3ad
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+*�
B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..15c6ae3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
*

Bx_zero_point
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6b27017
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint4/model.onnx b/onnx/backend/test/data/node/test_dequantizelinear_uint4/model.onnx
new file mode 100644
index 0000000..e81e203
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1b66879
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+*�
B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0d6480
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..118b7d9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
*

Bx_zero_point
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6b70d35
Binary files /dev/null and b/onnx/backend/test/data/node/test_dequantizelinear_uint4/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_det_2d/model.onnx b/onnx/backend/test/data/node/test_det_2d/model.onnx
new file mode 100644
index 0000000..b2f1c52
Binary files /dev/null and b/onnx/backend/test/data/node/test_det_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_det_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_det_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..188fd6d
Binary files /dev/null and b/onnx/backend/test/data/node/test_det_2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_det_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_det_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ee10c60
Binary files /dev/null and b/onnx/backend/test/data/node/test_det_2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_det_nd/model.onnx b/onnx/backend/test/data/node/test_det_nd/model.onnx
new file mode 100644
index 0000000..26d4c87
Binary files /dev/null and b/onnx/backend/test/data/node/test_det_nd/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_det_nd/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_det_nd/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e8c16bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_det_nd/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_det_nd/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_det_nd/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9f63801
Binary files /dev/null and b/onnx/backend/test/data/node/test_det_nd/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft/model.onnx b/onnx/backend/test/data/node/test_dft/model.onnx
new file mode 100644
index 0000000..ae626a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d892672
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dft/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..df03339
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dft/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4af12d
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_axis/model.onnx b/onnx/backend/test/data/node/test_dft_axis/model.onnx
new file mode 100644
index 0000000..9b2736a
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d892672
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dft_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..37627c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5f4decf
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_axis_opset19/model.onnx b/onnx/backend/test/data/node/test_dft_axis_opset19/model.onnx
new file mode 100644
index 0000000..347c2d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_axis_opset19/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft_axis_opset19/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft_axis_opset19/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d892672
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_axis_opset19/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_axis_opset19/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft_axis_opset19/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5f4decf
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_axis_opset19/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_inverse/model.onnx b/onnx/backend/test/data/node/test_dft_inverse/model.onnx
new file mode 100644
index 0000000..52556d4
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_inverse/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..278b4dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..df03339
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..077b322
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_inverse/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_inverse_opset19/model.onnx b/onnx/backend/test/data/node/test_dft_inverse_opset19/model.onnx
new file mode 100644
index 0000000..bb468df
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_inverse_opset19/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft_inverse_opset19/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft_inverse_opset19/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..278b4dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_inverse_opset19/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_inverse_opset19/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft_inverse_opset19/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..077b322
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_inverse_opset19/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_irfft/model.onnx b/onnx/backend/test/data/node/test_dft_irfft/model.onnx
new file mode 100644
index 0000000..519a6b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_irfft/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f0a4c4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..df03339
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b1aa020
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_irfft/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_irfft_opset19/model.onnx b/onnx/backend/test/data/node/test_dft_irfft_opset19/model.onnx
new file mode 100644
index 0000000..cbdb414
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_irfft_opset19/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft_irfft_opset19/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft_irfft_opset19/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f0a4c4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_irfft_opset19/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_irfft_opset19/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft_irfft_opset19/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b1aa020
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_irfft_opset19/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_opset19/model.onnx b/onnx/backend/test/data/node/test_dft_opset19/model.onnx
new file mode 100644
index 0000000..33d1bb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_opset19/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft_opset19/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft_opset19/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d892672
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_opset19/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_opset19/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft_opset19/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4af12d
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_opset19/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_rfft/model.onnx b/onnx/backend/test/data/node/test_dft_rfft/model.onnx
new file mode 100644
index 0000000..68bc445
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_rfft/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d892672
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..df03339
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b159759
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_rfft/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_rfft_opset19/model.onnx b/onnx/backend/test/data/node/test_dft_rfft_opset19/model.onnx
new file mode 100644
index 0000000..6be09e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_rfft_opset19/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dft_rfft_opset19/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dft_rfft_opset19/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d892672
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_rfft_opset19/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dft_rfft_opset19/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dft_rfft_opset19/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b159759
Binary files /dev/null and b/onnx/backend/test/data/node/test_dft_rfft_opset19/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div/model.onnx b/onnx/backend/test/data/node/test_div/model.onnx
new file mode 100644
index 0000000..25f2287
Binary files /dev/null and b/onnx/backend/test/data/node/test_div/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_div/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_div/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..41fe484
--- /dev/null
+++ b/onnx/backend/test/data/node/test_div/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
��?x2�?���?��?�5�?���?f��?H��?���?>�?���?.��?�ƨ?�m�?�ސ?���?B�?�r�?��?⒂?��?ݙ�?���?���?��?�(�?%ן?���?��?�?�?���?���?h;�?W�?���?j�?�*�?���?���?&g�?���?��?"��?f+�?�`�?Fn�?�@�?K��?�t�?
��?���?C!�?!�?��?7W�?.�?���?���?~��?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_div/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e28adb5
Binary files /dev/null and b/onnx/backend/test/data/node/test_div/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_bcast/model.onnx b/onnx/backend/test/data/node/test_div_bcast/model.onnx
new file mode 100644
index 0000000..dc2dda2
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..69248c4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_div_bcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ��?x2�?���?��?�5�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_div_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51b469f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_div_bcast/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�
d5�?#�>8>?���?3��?�A��hY?>1뽽x��ʍ�>���=Gd�?0�?�2�=	��>�΃>3�?�e�d�b>�wM������?��'?nW���@"���'�'=wn����?���?'��='�>�p,�dF���d���=�Ì?��i?�8���r��dO��x������Ў�?R6��4���V��J?y��ӶL���0�%�>oƾ��U���ؼ
3�>%�s=
k>��(���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_div_example/model.onnx b/onnx/backend/test/data/node/test_div_example/model.onnx
new file mode 100644
index 0000000..936a749
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..085a7dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a76e53
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_div_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5105f6e
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_int16/model.onnx b/onnx/backend/test/data/node/test_div_int16/model.onnx
new file mode 100644
index 0000000..036629e
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1275010
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..32784b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_div_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1590434
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_int32_trunc/model.onnx b/onnx/backend/test/data/node/test_div_int32_trunc/model.onnx
new file mode 100644
index 0000000..34a9313
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int32_trunc/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7fb9dce
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..773a5bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4b8b90e
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int32_trunc/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_int8/model.onnx b/onnx/backend/test/data/node/test_div_int8/model.onnx
new file mode 100644
index 0000000..bd0f791
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d2421ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ec94be9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_div_int8/test_data_set_0/input_1.pb
@@ -0,0 +1,4 @@
+B
yJ<
	
+
+



+
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_div_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cb9b2cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_int8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint16/model.onnx b/onnx/backend/test/data/node/test_div_uint16/model.onnx
new file mode 100644
index 0000000..59dc829
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..49cce2a
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1dcb8cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9119ad4
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint32/model.onnx b/onnx/backend/test/data/node/test_div_uint32/model.onnx
new file mode 100644
index 0000000..f684281
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9f78f8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3dd88c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..83113ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint64/model.onnx b/onnx/backend/test/data/node/test_div_uint64/model.onnx
new file mode 100644
index 0000000..edf4a12
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0d910b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f3cfa5f
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8790e2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint8/model.onnx b/onnx/backend/test/data/node/test_div_uint8/model.onnx
new file mode 100644
index 0000000..cb059d1
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9f9401c
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fa63193
--- /dev/null
+++ b/onnx/backend/test/data/node/test_div_uint8/test_data_set_0/input_1.pb
@@ -0,0 +1,7 @@
+B
yJ<
+
+


+

+	
+


+
		
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_div_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_div_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..32358ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_div_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dropout_default/model.onnx b/onnx/backend/test/data/node/test_dropout_default/model.onnx
new file mode 100644
index 0000000..be75e7d
Binary files /dev/null and b/onnx/backend/test/data/node/test_dropout_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dropout_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dropout_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dropout_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad67ee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_mask/model.onnx b/onnx/backend/test/data/node/test_dropout_default_mask/model.onnx
new file mode 100644
index 0000000..f45cd7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_dropout_default_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad67ee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..de98527
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_mask/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+	B
zJ<




























































\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_mask_ratio/model.onnx b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/model.onnx
new file mode 100644
index 0000000..343482d
Binary files /dev/null and b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..18a4deb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
rJ���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad67ee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..de98527
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_mask_ratio/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+	B
zJ<




























































\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_old/model.onnx b/onnx/backend/test/data/node/test_dropout_default_old/model.onnx
new file mode 100644
index 0000000..efd1edc
Binary files /dev/null and b/onnx/backend/test/data/node/test_dropout_default_old/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0b9013
Binary files /dev/null and b/onnx/backend/test/data/node/test_dropout_default_old/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dropout_default_ratio/model.onnx b/onnx/backend/test/data/node/test_dropout_default_ratio/model.onnx
new file mode 100644
index 0000000..3f079ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_dropout_default_ratio/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..18a4deb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
rJ���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad67ee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_default_ratio/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_random_old/model.onnx b/onnx/backend/test/data/node/test_dropout_random_old/model.onnx
new file mode 100644
index 0000000..fb2c845
Binary files /dev/null and b/onnx/backend/test/data/node/test_dropout_random_old/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad67ee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dropout_random_old/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear/model.onnx b/onnx/backend/test/data/node/test_dynamicquantizelinear/model.onnx
new file mode 100644
index 0000000..ccd0559
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..493d80f
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d185e66
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f849bb8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
By_scaleJ���<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..502709e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+By_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/model.onnx b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/model.onnx
new file mode 100644
index 0000000..545e51c
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..493d80f
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d185e66
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f849bb8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
By_scaleJ���<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..502709e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+By_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/model.onnx b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/model.onnx
new file mode 100644
index 0000000..0ae5d4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ffa1ea8
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4818b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98bf9a5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
By_scaleJ���<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..d583380
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+By_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/model.onnx b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/model.onnx
new file mode 100644
index 0000000..5d41c60
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ffa1ea8
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4818b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98bf9a5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
By_scaleJ���<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..d583380
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_max_adjusted_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+By_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/model.onnx b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/model.onnx
new file mode 100644
index 0000000..681dd2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2651ee2
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..793fce6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ@�S���`�����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98bf9a5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
By_scaleJ���<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..74d6f51
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/model.onnx b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/model.onnx
new file mode 100644
index 0000000..12178f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2651ee2
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..793fce6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ@�S���`�����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98bf9a5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
By_scaleJ���<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..74d6f51
Binary files /dev/null and b/onnx/backend/test/data/node/test_dynamicquantizelinear_min_adjusted_expanded/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_edge_pad/model.onnx b/onnx/backend/test/data/node/test_edge_pad/model.onnx
new file mode 100644
index 0000000..e93c4c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_edge_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f625fc0
Binary files /dev/null and b/onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..131ea5f
Binary files /dev/null and b/onnx/backend/test/data/node/test_edge_pad/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_edge_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_edge_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..12dd0a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_edge_pad/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_einsum_batch_diagonal/model.onnx b/onnx/backend/test/data/node/test_einsum_batch_diagonal/model.onnx
new file mode 100644
index 0000000..157051b
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_batch_diagonal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5e8787c
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e4e6397
--- /dev/null
+++ b/onnx/backend/test/data/node/test_einsum_batch_diagonal/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJx����9�?�2�g�?��kZ�?��
M	�?�ſu(@
:
�E��3ꐑ�3�?$`���<�?���B`6�?���;˿"�_}��쿵���E�?g�ZK꿬�W����nL�'���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_einsum_batch_matmul/model.onnx b/onnx/backend/test/data/node/test_einsum_batch_matmul/model.onnx
new file mode 100644
index 0000000..ad38d2e
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_batch_matmul/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5b93576
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e594483
--- /dev/null
+++ b/onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/input_1.pb
@@ -0,0 +1,3 @@
+B
yJ����6Q��?3ꐑ�3�?ʣ���h�x�0�W���E)�Q1Dֿ�N�6>�?E��GE��?$`���<�?�`hk��ؿ��͢�XӿSdQy���]�~�d���`����L�����B`6�?6��O�e֨�h	ܿn�%s��Qht3��?����������;˿"�_}��쿚�±��??��X࿮�������+T�ۜ�B���i�?����E�?90�[�?����]L�z�4�&7׿����˄忦\C�׿g�ZK�v���ڞ��O�7[��?��JcǶٿf��J����)w9��?��W����
+�>@���?)���T�?e����?�tR6�:�?�*����nL�'���?������z��������n��⿈Fz�ӿ>?(���?}��(t��|ך���?��g�i��?^�sBt���r�H����?�D~�U�?|-��G��?
+����ǿ��7��!�K&���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8d382df
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_batch_matmul/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_einsum_inner_prod/model.onnx b/onnx/backend/test/data/node/test_einsum_inner_prod/model.onnx
new file mode 100644
index 0000000..a14aa6c
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_inner_prod/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..60ec816
--- /dev/null
+++ b/onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ(����9�?S���,��?��"R�Q�?N1�iY�
@�=�|���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9869f3d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
yJ(���B�E��2�g�?6��I�_ÿY����l��f)g�>G�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7dec5a8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_einsum_inner_prod/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
zJ�PR<��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_einsum_scalar/model.onnx b/onnx/backend/test/data/node/test_einsum_scalar/model.onnx
new file mode 100644
index 0000000..d9894d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_scalar/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_einsum_scalar/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_einsum_scalar/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f8fec95
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_scalar/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_einsum_scalar/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_einsum_scalar/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..62edc16
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_scalar/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_einsum_sum/model.onnx b/onnx/backend/test/data/node/test_einsum_sum/model.onnx
new file mode 100644
index 0000000..d1f302e
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_sum/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..86fd72d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ`����9�?S���,��?��"R�Q�?N1�iY�
@�=�|���?���B�E��2�g�?6��I�_ÿY����l��f)g�>G�?��
p�?���K�D�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0785aa6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_einsum_sum/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJZ.܋
�@R��0�?H!@ڻ}�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_einsum_transpose/model.onnx b/onnx/backend/test/data/node/test_einsum_transpose/model.onnx
new file mode 100644
index 0000000..dbaf7a7
Binary files /dev/null and b/onnx/backend/test/data/node/test_einsum_transpose/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..86fd72d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ`����9�?S���,��?��"R�Q�?N1�iY�
@�=�|���?���B�E��2�g�?6��I�_ÿY����l��f)g�>G�?��
p�?���K�D�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..22d7af0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_einsum_transpose/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ`����9�?�=�|���?Y����l��S���,��?���B�E�f)g�>G�?��"R�Q�?�2�g�?��
p�?N1�iY�
@6��I�_ÿ���K�D�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_elu/model.onnx b/onnx/backend/test/data/node/test_elu/model.onnx
new file mode 100644
index 0000000..dd1003b
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_elu/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_elu/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_elu/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_elu/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_elu/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9bab89a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_elu/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�����8s?�ԏ�0�H��9�>(�>�%�?^�B?�0�=B�>]ת>�=�?�iJ�>n��쿌S'?�K]?|���C@+6ĿHm;=Hή�2�?��?��>���>������ܿr�� >*z�?��?Bk$�Ғ�FI��P¿}�ѿ��?vpL�&�5�	ܶ��	G? Ϳ�;ľ�q���>0�L��b��@�c�QN�>.:�=�ݚ>2}p�~��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_elu_default/model.onnx b/onnx/backend/test/data/node/test_elu_default/model.onnx
new file mode 100644
index 0000000..3a97971
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_elu_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_elu_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_elu_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_elu_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_elu_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ce49ec4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_elu_default/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?����8s?���0�Ƚ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?��=�iJ�>n�l��S'?�K]?|��C@+6D�Hm;=H�.�2�?��?��>���>�����\�r��� >*z�?��?Bk��Ғ��FI&�PB�}�Q���?vp̾&���	�6��	G? M��;D��q��>0�̾�b1�@��QN�>.:�=�ݚ>2}�~ě�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_elu_default_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_elu_default_expanded_ver18/model.onnx
new file mode 100644
index 0000000..3508a18
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu_default_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ce49ec4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_elu_default_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?����8s?���0�Ƚ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?��=�iJ�>n�l��S'?�K]?|��C@+6D�Hm;=H�.�2�?��?��>���>�����\�r��� >*z�?��?Bk��Ғ��FI&�PB�}�Q���?vp̾&���	�6��	G? M��;D��q��>0�̾�b1�@��QN�>.:�=�ݚ>2}�~ě�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_elu_example/model.onnx b/onnx/backend/test/data/node/test_elu_example/model.onnx
new file mode 100644
index 0000000..99091bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_elu_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_elu_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_elu_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_elu_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..614cb65
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_elu_example_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_elu_example_expanded_ver18/model.onnx
new file mode 100644
index 0000000..3d5e552
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu_example_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..614cb65
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu_example_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_elu_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_elu_expanded_ver18/model.onnx
new file mode 100644
index 0000000..ad9ba8e
Binary files /dev/null and b/onnx/backend/test/data/node/test_elu_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9bab89a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_elu_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�����8s?�ԏ�0�H��9�>(�>�%�?^�B?�0�=B�>]ת>�=�?�iJ�>n��쿌S'?�K]?|���C@+6ĿHm;=Hή�2�?��?��>���>������ܿr�� >*z�?��?Bk$�Ғ�FI��P¿}�ѿ��?vpL�&�5�	ܶ��	G? Ϳ�;ľ�q���>0�L��b��@�c�QN�>.:�=�ݚ>2}p�~��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_equal/model.onnx b/onnx/backend/test/data/node/test_equal/model.onnx
new file mode 100644
index 0000000..ba52b0a
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b8f53b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6b22267
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_equal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f28c2e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_bcast/model.onnx b/onnx/backend/test/data/node/test_equal_bcast/model.onnx
new file mode 100644
index 0000000..b29b857
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b8f53b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..954f31f
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dbc90ca
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_bcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_int16/model.onnx b/onnx/backend/test/data/node/test_equal_int16/model.onnx
new file mode 100644
index 0000000..3903833
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d0f0d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0a8177b
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a9556df
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_int8/model.onnx b/onnx/backend/test/data/node/test_equal_int8/model.onnx
new file mode 100644
index 0000000..d43850e
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fe002f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_int8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f99b1b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_int8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4dfdd92
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_int8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_string/model.onnx b/onnx/backend/test/data/node/test_equal_string/model.onnx
new file mode 100644
index 0000000..04caea3
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_string/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..29c02d9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2string12string2B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..35b361f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_equal_string/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+2string12string3B
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_equal_string/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal_string/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..32c1639
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_string/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_string_broadcast/model.onnx b/onnx/backend/test/data/node/test_equal_string_broadcast/model.onnx
new file mode 100644
index 0000000..4e3d9b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_string_broadcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..29c02d9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2string12string2B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8cce05e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
2string1B
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..32c1639
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_string_broadcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint16/model.onnx b/onnx/backend/test/data/node/test_equal_uint16/model.onnx
new file mode 100644
index 0000000..6b48c36
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05499ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8caad5
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0a7661
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint32/model.onnx b/onnx/backend/test/data/node/test_equal_uint32/model.onnx
new file mode 100644
index 0000000..462243d
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57ca187
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e078d4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..da9a789
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint64/model.onnx b/onnx/backend/test/data/node/test_equal_uint64/model.onnx
new file mode 100644
index 0000000..5e28aa2
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..028107b
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0884815
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3f6150d
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint8/model.onnx b/onnx/backend/test/data/node/test_equal_uint8/model.onnx
new file mode 100644
index 0000000..0a0b587
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9af0258
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7d08c07
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a90f7b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_equal_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_erf/model.onnx b/onnx/backend/test/data/node/test_erf/model.onnx
new file mode 100644
index 0000000..99cadd4
Binary files /dev/null and b/onnx/backend/test/data/node/test_erf/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_erf/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_erf/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_erf/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_erf/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_erf/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..002174d
Binary files /dev/null and b/onnx/backend/test/data/node/test_erf/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_exp/model.onnx b/onnx/backend/test/data/node/test_exp/model.onnx
new file mode 100644
index 0000000..9ee2288
Binary files /dev/null and b/onnx/backend/test/data/node/test_exp/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_exp/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_exp/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_exp/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_exp/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_exp/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4659043
Binary files /dev/null and b/onnx/backend/test/data/node/test_exp/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_exp_example/model.onnx b/onnx/backend/test/data/node/test_exp_example/model.onnx
new file mode 100644
index 0000000..fef095e
Binary files /dev/null and b/onnx/backend/test/data/node/test_exp_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_exp_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_exp_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_exp_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_exp_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_exp_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2944cdd
Binary files /dev/null and b/onnx/backend/test/data/node/test_exp_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_expand_dim_changed/model.onnx b/onnx/backend/test/data/node/test_expand_dim_changed/model.onnx
new file mode 100644
index 0000000..2127b00
Binary files /dev/null and b/onnx/backend/test/data/node/test_expand_dim_changed/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62725e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8d9183b
Binary files /dev/null and b/onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8aae375
Binary files /dev/null and b/onnx/backend/test/data/node/test_expand_dim_changed/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_expand_dim_unchanged/model.onnx b/onnx/backend/test/data/node/test_expand_dim_unchanged/model.onnx
new file mode 100644
index 0000000..f3fc955
Binary files /dev/null and b/onnx/backend/test/data/node/test_expand_dim_unchanged/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62725e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9bec268
Binary files /dev/null and b/onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fb98340
Binary files /dev/null and b/onnx/backend/test/data/node/test_expand_dim_unchanged/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/model.onnx b/onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/model.onnx
new file mode 100644
index 0000000..60a068b
Binary files /dev/null and b/onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..29bf3c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ae7df04
Binary files /dev/null and b/onnx/backend/test/data/node/test_eyelike_populate_off_main_diagonal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_eyelike_with_dtype/model.onnx b/onnx/backend/test/data/node/test_eyelike_with_dtype/model.onnx
new file mode 100644
index 0000000..8599bfd
Binary files /dev/null and b/onnx/backend/test/data/node/test_eyelike_with_dtype/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0cc6d1
Binary files /dev/null and b/onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6255b1a
Binary files /dev/null and b/onnx/backend/test/data/node/test_eyelike_with_dtype/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_eyelike_without_dtype/model.onnx b/onnx/backend/test/data/node/test_eyelike_without_dtype/model.onnx
new file mode 100644
index 0000000..584a332
Binary files /dev/null and b/onnx/backend/test/data/node/test_eyelike_without_dtype/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1eb1960
Binary files /dev/null and b/onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3cf5be8
Binary files /dev/null and b/onnx/backend/test/data/node/test_eyelike_without_dtype/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flatten_axis0/model.onnx b/onnx/backend/test/data/node/test_flatten_axis0/model.onnx
new file mode 100644
index 0000000..0af89cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_flatten_axis0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cd476a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b8af614
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_axis0/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
x
B
bJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_axis1/model.onnx b/onnx/backend/test/data/node/test_flatten_axis1/model.onnx
new file mode 100644
index 0000000..e685648
Binary files /dev/null and b/onnx/backend/test/data/node/test_flatten_axis1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cd476a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c6d529f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_axis1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+<
B
bJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_axis2/model.onnx b/onnx/backend/test/data/node/test_flatten_axis2/model.onnx
new file mode 100644
index 0000000..744ac2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_flatten_axis2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cd476a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..16f29d6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_axis2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
bJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_axis3/model.onnx b/onnx/backend/test/data/node/test_flatten_axis3/model.onnx
new file mode 100644
index 0000000..95ac9b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_flatten_axis3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cd476a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a9787fd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_axis3/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
bJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_default_axis/model.onnx b/onnx/backend/test/data/node/test_flatten_default_axis/model.onnx
new file mode 100644
index 0000000..f8ac516
Binary files /dev/null and b/onnx/backend/test/data/node/test_flatten_default_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ec5cd29
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9ad6a5c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_default_axis/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
bJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis1/model.onnx b/onnx/backend/test/data/node/test_flatten_negative_axis1/model.onnx
new file mode 100644
index 0000000..64d4496
Binary files /dev/null and b/onnx/backend/test/data/node/test_flatten_negative_axis1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cd476a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a9787fd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_negative_axis1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
bJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis2/model.onnx b/onnx/backend/test/data/node/test_flatten_negative_axis2/model.onnx
new file mode 100644
index 0000000..020ed99
Binary files /dev/null and b/onnx/backend/test/data/node/test_flatten_negative_axis2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cd476a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..16f29d6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_negative_axis2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
bJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis3/model.onnx b/onnx/backend/test/data/node/test_flatten_negative_axis3/model.onnx
new file mode 100644
index 0000000..fcc6a6a
Binary files /dev/null and b/onnx/backend/test/data/node/test_flatten_negative_axis3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cd476a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c6d529f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_negative_axis3/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+<
B
bJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis4/model.onnx b/onnx/backend/test/data/node/test_flatten_negative_axis4/model.onnx
new file mode 100644
index 0000000..4b0771c
Binary files /dev/null and b/onnx/backend/test/data/node/test_flatten_negative_axis4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cd476a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b8af614
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flatten_negative_axis4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
x
B
bJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention/model.onnx b/onnx/backend/test/data/node/test_flexattention/model.onnx
new file mode 100644
index 0000000..1dff88f
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..72d392a
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ed8d544
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..da7d304
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0857f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask/model.onnx b/onnx/backend/test/data/node/test_flexattention_causal_mask/model.onnx
new file mode 100644
index 0000000..9f0c2aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_causal_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6204e1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f5c7017
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..299c04b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�"
)?
��>B6?���>��
+>v��>8�?pC?�?+8'?=�&?���>�e?1�>�)�>Ud?�bN?24?�C�=6ck?��6?p�?�>�=^?�d&>P�?U��=Y?u�N?��?Tz�>m��=��2?�6�>��8?;�]?ǻy?�[?n�?<O�>��:?��/>�b?��^=��L>��<�/K?�Le>�Ѱ>��m?�T4?�i=��(>5?A�?-�s>�(o?�,?;	?W?G�:?A��>���>H�V>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fdf96b1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_causal_mask/test_data_set_0/output_0.pb
@@ -0,0 +1,5 @@
+

B
YJ�"
)?
��>B6?���>��
+>v��>8�?pC?�I?���>9�"?�@�>֌
+?s��>
8�>�Y@?9�.?1?�>#�?�r?�Q
+?z$�>�rC?�u	?�J?`R�>�,?��!?�h?��>$
+?��2?�6�>��8?;�]?ǻy?�[?n�?<O�>��6?�'�>��?>%�>�>?U0�>M��>��>g??�
?,�'?���>9��>��?A7�>���>Q)?��?ar ?ֹ�>ٍ?���>P��>�]�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/model.onnx
new file mode 100644
index 0000000..3ac52dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6204e1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f5c7017
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..299c04b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�"
)?
��>B6?���>��
+>v��>8�?pC?�?+8'?=�&?���>�e?1�>�)�>Ud?�bN?24?�C�=6ck?��6?p�?�>�=^?�d&>P�?U��=Y?u�N?��?Tz�>m��=��2?�6�>��8?;�]?ǻy?�[?n�?<O�>��:?��/>�b?��^=��L>��<�/K?�Le>�Ѱ>��m?�T4?�i=��(>5?A�?-�s>�(o?�,?;	?W?G�:?A��>���>H�V>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fdf96b1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_causal_mask_expanded_ver26/test_data_set_0/output_0.pb
@@ -0,0 +1,5 @@
+

B
YJ�"
)?
��>B6?���>��
+>v��>8�?pC?�I?���>9�"?�@�>֌
+?s��>
8�>�Y@?9�.?1?�>#�?�r?�Q
+?z$�>�rC?�u	?�J?`R�>�,?��!?�h?��>$
+?��2?�6�>��8?;�]?ǻy?�[?n�?<O�>��6?�'�>��?>%�>�>?U0�>M��>��>g??�
?,�'?���>9��>��?A7�>���>Q)?��?ar ?ֹ�>ٍ?���>P��>�]�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/model.onnx b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/model.onnx
new file mode 100644
index 0000000..ebb85fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..72d392a
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ed8d544
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..d0eabbc
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c2f9f30
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/model.onnx
new file mode 100644
index 0000000..4f248bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..72d392a
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ed8d544
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..d0eabbc
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c2f9f30
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_diff_head_sizes_expanded_ver26/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double/model.onnx b/onnx/backend/test/data/node/test_flexattention_double/model.onnx
new file mode 100644
index 0000000..ddeb6af
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bd72467
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3676288
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..39b5b4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b171fab
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/model.onnx
new file mode 100644
index 0000000..911793e
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bd72467
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3676288
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..39b5b4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b171fab
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_double_expanded_ver26/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/model.onnx
new file mode 100644
index 0000000..970b731
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..72d392a
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ed8d544
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..da7d304
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0857f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_expanded_ver26/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16/model.onnx b/onnx/backend/test/data/node/test_flexattention_fp16/model.onnx
new file mode 100644
index 0000000..6da3375
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_fp16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bc1cf24
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4499010
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_1.pb
@@ -0,0 +1,4 @@
+
+B
KJ�::�:�7�1�;$0�7\,�;�;�9�54?4058�059�97&�689�:�7�;@4�"�74�:s3�4T:�9w8�9�6p�!8U-�*�;�:�0q�;t4�1�9�.<4�;9*8^62:�0�;�:�8~)�9N;28�5�/
+:;k.:^$�;�8k8�4o;A4�:�;D:'8;,�77}2�6�5=1744-8�(@;�:l8�:�;/9�;�;�80�8:]2�;I59~4�;�9F5V:�.G63x9�.Z6m4
8�5�9K&9a3M4g:�;5�:�.9:�0�6$;�.�$�8�6d:c;�476�7�8�;�9<684�;V0�9g;Q9�6^2�5�929l;�:�:K;l4�56|8Y9�4�$c6�4�;;�:99�5d8�:P.i:E)�:v:�*98o1�00:�8�;�;�;�/�;�3U7:�2�8�1�.v/�5��6P9m6~-,s4k1�;�0r:�8�88�;�5N:q8U6�;�8�/�6A:�9U;&4:\7�8�;�;�:�5;9�6�():8J:�9Y:�4h:d8�7g9x%�.�4�;y0J5�*M5 5�;�: 6W&�:I9�0�;j.�:�4�6]:l9�;�8C.;':�9�*W6\1�:�9;�;3:�;�8�(L#y5�:�:�;+,�)N;�4w8�;h6T9j6%:98�3W4!4B8�9�;�9@:h1�5�6~9�4�4�5{:�8�,-�5":�9�9#:�4c8Y8�9�;s4Y:H9�83:�;�(�0
:]-!8	3d4�9�'�:78R8*9�5y.5a1s85�;�;�8�8�;;:5�5q2�7�;L;�/s&0;L8h2d9'9�/'4�+�2<0/2|9V*�.K05�44
:�;F8�;Y6�.�6�4�7B9`7{;;�9�770Z6�9�4�.C;�9�8W:�:�7
;U;X4�868N8�;�4�;8;W7�:':l95I2_9�:)$$97/;%5�78~0�9�:j+�4�(�;V9�;A8k:�5�5
6C9�54;�;�'22//l)J3&7�:3�7p;V9b:h8�;�8�)V2z6�8-:�6�9R:5�;29;s8�9*:D;�0w8�6c;�.�;
;�,�7�9�9@;f:�4�7�9n052�7�4�:�8�5�:p:�;�:�60�:�+�5\;�; 9�9o)8`8q5d,S3�5�6�8�95C5%;) 4�99):':�:�9�;1;�8�8c(�;60�9�:�5M2R.�9>7�9S;�0Z;�6�4�;�;]2A9�.59�:z9�6!6J6�8
;o;�*�1//02�5
8	9�9;�;N9�:9:�4
;y)a4e79�.b9j:�1�6)8;7f:�;d:�,q:C,�3�0R2:8`9�7�;�3:�:8M7�8�6q8�6h6�9�-T1�:+:�4	6i;�:�83�)�6b9�:�:2(�3m5
+2l:$:"8�;�02;t/91�9/�8�6�95;):�:8(�4 8�6f3�4�;�4�5��:�0�24;�2a:w:k;e/�2�9F2�4V1�1�7/&5�6I&76.�7�:�:&-�8�:�3: ;s:�.� #2T4�8&6�9�5�0
5;�;�2O:`4;L1T9d-�;�9�:�8�7�8;8�7:�1z1�6"5�,�:,:Z8�;�,":C4�53P:�0�:K9
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c321646
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2fef586
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_fp16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/model.onnx
new file mode 100644
index 0000000..26033bc
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bc1cf24
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4499010
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_1.pb
@@ -0,0 +1,4 @@
+
+B
KJ�::�:�7�1�;$0�7\,�;�;�9�54?4058�059�97&�689�:�7�;@4�"�74�:s3�4T:�9w8�9�6p�!8U-�*�;�:�0q�;t4�1�9�.<4�;9*8^62:�0�;�:�8~)�9N;28�5�/
+:;k.:^$�;�8k8�4o;A4�:�;D:'8;,�77}2�6�5=1744-8�(@;�:l8�:�;/9�;�;�80�8:]2�;I59~4�;�9F5V:�.G63x9�.Z6m4
8�5�9K&9a3M4g:�;5�:�.9:�0�6$;�.�$�8�6d:c;�476�7�8�;�9<684�;V0�9g;Q9�6^2�5�929l;�:�:K;l4�56|8Y9�4�$c6�4�;;�:99�5d8�:P.i:E)�:v:�*98o1�00:�8�;�;�;�/�;�3U7:�2�8�1�.v/�5��6P9m6~-,s4k1�;�0r:�8�88�;�5N:q8U6�;�8�/�6A:�9U;&4:\7�8�;�;�:�5;9�6�():8J:�9Y:�4h:d8�7g9x%�.�4�;y0J5�*M5 5�;�: 6W&�:I9�0�;j.�:�4�6]:l9�;�8C.;':�9�*W6\1�:�9;�;3:�;�8�(L#y5�:�:�;+,�)N;�4w8�;h6T9j6%:98�3W4!4B8�9�;�9@:h1�5�6~9�4�4�5{:�8�,-�5":�9�9#:�4c8Y8�9�;s4Y:H9�83:�;�(�0
:]-!8	3d4�9�'�:78R8*9�5y.5a1s85�;�;�8�8�;;:5�5q2�7�;L;�/s&0;L8h2d9'9�/'4�+�2<0/2|9V*�.K05�44
:�;F8�;Y6�.�6�4�7B9`7{;;�9�770Z6�9�4�.C;�9�8W:�:�7
;U;X4�868N8�;�4�;8;W7�:':l95I2_9�:)$$97/;%5�78~0�9�:j+�4�(�;V9�;A8k:�5�5
6C9�54;�;�'22//l)J3&7�:3�7p;V9b:h8�;�8�)V2z6�8-:�6�9R:5�;29;s8�9*:D;�0w8�6c;�.�;
;�,�7�9�9@;f:�4�7�9n052�7�4�:�8�5�:p:�;�:�60�:�+�5\;�; 9�9o)8`8q5d,S3�5�6�8�95C5%;) 4�99):':�:�9�;1;�8�8c(�;60�9�:�5M2R.�9>7�9S;�0Z;�6�4�;�;]2A9�.59�:z9�6!6J6�8
;o;�*�1//02�5
8	9�9;�;N9�:9:�4
;y)a4e79�.b9j:�1�6)8;7f:�;d:�,q:C,�3�0R2:8`9�7�;�3:�:8M7�8�6q8�6h6�9�-T1�:+:�4	6i;�:�83�)�6b9�:�:2(�3m5
+2l:$:"8�;�02;t/91�9/�8�6�95;):�:8(�4 8�6f3�4�;�4�5��:�0�24;�2a:w:k;e/�2�9F2�4V1�1�7/&5�6I&76.�7�:�:&-�8�:�3: ;s:�.� #2T4�8&6�9�5�0
5;�;�2O:`4;L1T9d-�;�9�:�8�7�8;8�7:�1z1�6"5�,�:,:Z8�;�,":C4�53P:�0�:K9
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c321646
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2fef586
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_fp16_expanded_ver26/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa/model.onnx b/onnx/backend/test/data/node/test_flexattention_gqa/model.onnx
new file mode 100644
index 0000000..37d660f
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d13ee40
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9374064
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..28a2a59
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..91d7d6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/model.onnx
new file mode 100644
index 0000000..68e1dbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d13ee40
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9374064
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..28a2a59
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..91d7d6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_gqa_expanded_ver26/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod/model.onnx b/onnx/backend/test/data/node/test_flexattention_prob_mod/model.onnx
new file mode 100644
index 0000000..a551ff3
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_prob_mod/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..66417b0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e4d1b7a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ`�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ec5e9f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ`��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c56db2a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_prob_mod/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
YJ`���>/0�=�MS>K>$�>���=#�T>̨>��>�=�O>��>�DQ>Y~�=�3�>M#�=&z4>���=��>k��=\EA>��=�C�>As�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/model.onnx
new file mode 100644
index 0000000..9e043c3
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..66417b0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e4d1b7a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ`�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ec5e9f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ`��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c56db2a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_prob_mod_expanded_ver26/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
YJ`���>/0�=�MS>K>$�>���=#�T>̨>��>�=�O>��>�DQ>Y~�=�3�>M#�=&z4>���=��>k��=\EA>��=�C�>As�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional/model.onnx b/onnx/backend/test/data/node/test_flexattention_relative_positional/model.onnx
new file mode 100644
index 0000000..41952ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_relative_positional/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6204e1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f5c7017
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..299c04b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�"
)?
��>B6?���>��
+>v��>8�?pC?�?+8'?=�&?���>�e?1�>�)�>Ud?�bN?24?�C�=6ck?��6?p�?�>�=^?�d&>P�?U��=Y?u�N?��?Tz�>m��=��2?�6�>��8?;�]?ǻy?�[?n�?<O�>��:?��/>�b?��^=��L>��<�/K?�Le>�Ѱ>��m?�T4?�i=��(>5?A�?-�s>�(o?�,?;	?W?G�:?A��>���>H�V>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9a7ce51
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_relative_positional/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/model.onnx
new file mode 100644
index 0000000..ab84048
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6204e1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f5c7017
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..299c04b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�"
)?
��>B6?���>��
+>v��>8�?pC?�?+8'?=�&?���>�e?1�>�)�>Ud?�bN?24?�C�=6ck?��6?p�?�>�=^?�d&>P�?U��=Y?u�N?��?Tz�>m��=��2?�6�>��8?;�]?ǻy?�[?n�?<O�>��:?��/>�b?��^=��L>��<�/K?�Le>�Ѱ>��m?�T4?�i=��(>5?A�?-�s>�(o?�,?;	?W?G�:?A��>���>H�V>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9a7ce51
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_relative_positional_expanded_ver26/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled/model.onnx b/onnx/backend/test/data/node/test_flexattention_scaled/model.onnx
new file mode 100644
index 0000000..7306424
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..72d392a
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ed8d544
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..da7d304
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4654bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/model.onnx
new file mode 100644
index 0000000..8f49cee
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..72d392a
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ed8d544
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..da7d304
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4654bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_scaled_expanded_ver26/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod/model.onnx b/onnx/backend/test/data/node/test_flexattention_score_mod/model.onnx
new file mode 100644
index 0000000..2a7a27f
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_score_mod/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..66417b0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e4d1b7a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ`�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ec5e9f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ`��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7a31168
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_score_mod/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
YJ`��'?/0t>�M�>K�>$�%?��v>#��>̨�>�+?n>��>�ˌ>�D�>Y~9>�3Q?M#x>&z�>��8>�J?k�\>\E�>��1>�CL?Asj>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/model.onnx
new file mode 100644
index 0000000..a2faa3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..66417b0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e4d1b7a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
KJ`�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ec5e9f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
VJ`��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7a31168
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_score_mod_expanded_ver26/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
YJ`��'?/0t>�M�>K�>$�%?��v>#��>̨�>�+?n>��>�ˌ>�D�>Y~9>�3Q?M#x>&z�>��8>�J?k�\>\E�>��1>�CL?Asj>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap/model.onnx b/onnx/backend/test/data/node/test_flexattention_soft_cap/model.onnx
new file mode 100644
index 0000000..b0787eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_soft_cap/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6204e1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f5c7017
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..299c04b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�"
)?
��>B6?���>��
+>v��>8�?pC?�?+8'?=�&?���>�e?1�>�)�>Ud?�bN?24?�C�=6ck?��6?p�?�>�=^?�d&>P�?U��=Y?u�N?��?Tz�>m��=��2?�6�>��8?;�]?ǻy?�[?n�?<O�>��:?��/>�b?��^=��L>��<�/K?�Le>�Ѱ>��m?�T4?�i=��(>5?A�?-�s>�(o?�,?;	?W?G�:?A��>���>H�V>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..aaad8d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_soft_cap/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/model.onnx b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/model.onnx
new file mode 100644
index 0000000..219b5fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6204e1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
QJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f5c7017
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..299c04b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+

B
VJ�"
)?
��>B6?���>��
+>v��>8�?pC?�?+8'?=�&?���>�e?1�>�)�>Ud?�bN?24?�C�=6ck?��6?p�?�>�=^?�d&>P�?U��=Y?u�N?��?Tz�>m��=��2?�6�>��8?;�]?ǻy?�[?n�?<O�>��:?��/>�b?��^=��L>��<�/K?�Le>�Ѱ>��m?�T4?�i=��(>5?A�?-�s>�(o?�,?;	?W?G�:?A��>���>H�V>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..aaad8d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_flexattention_soft_cap_expanded_ver26/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_floor/model.onnx b/onnx/backend/test/data/node/test_floor/model.onnx
new file mode 100644
index 0000000..9fa2658
Binary files /dev/null and b/onnx/backend/test/data/node/test_floor/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_floor/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_floor/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_floor/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_floor/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_floor/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b84ba0b
Binary files /dev/null and b/onnx/backend/test/data/node/test_floor/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_floor_example/model.onnx b/onnx/backend/test/data/node/test_floor_example/model.onnx
new file mode 100644
index 0000000..111eec2
Binary files /dev/null and b/onnx/backend/test/data/node/test_floor_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_floor_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_floor_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7b703a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_floor_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_floor_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_floor_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9300267
Binary files /dev/null and b/onnx/backend/test/data/node/test_floor_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_0/model.onnx b/onnx/backend/test/data/node/test_gather_0/model.onnx
new file mode 100644
index 0000000..b7becd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..663f5c9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bfcd20a
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gather_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..aacfe4e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gather_0/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gather_1/model.onnx b/onnx/backend/test/data/node/test_gather_1/model.onnx
new file mode 100644
index 0000000..1a684d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..663f5c9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bfcd20a
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gather_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ee50b90
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gather_1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gather_2d_indices/model.onnx b/onnx/backend/test/data/node/test_gather_2d_indices/model.onnx
new file mode 100644
index 0000000..84cf3bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_2d_indices/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..37c74ac
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ$x��?h��>��z?�j@$�?�.z��8s?b��hdӽ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0ce468e
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..647152d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gather_2d_indices/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJx��?��z?�j@�.z��8s?hdӽ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gather_elements_0/model.onnx b/onnx/backend/test/data/node/test_gather_elements_0/model.onnx
new file mode 100644
index 0000000..e9c7973
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a2f61e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..65897f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f721f24
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_1/model.onnx b/onnx/backend/test/data/node/test_gather_elements_1/model.onnx
new file mode 100644
index 0000000..0504c6d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..670c322
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e6b50a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..14166cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_negative_indices/model.onnx b/onnx/backend/test/data/node/test_gather_elements_negative_indices/model.onnx
new file mode 100644
index 0000000..34ab220
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_negative_indices/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..670c322
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b4f71fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..587cfeb
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_elements_negative_indices/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_negative_indices/model.onnx b/onnx/backend/test/data/node/test_gather_negative_indices/model.onnx
new file mode 100644
index 0000000..34c8551
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_negative_indices/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6feb34d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0f831b5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f2fef98
Binary files /dev/null and b/onnx/backend/test/data/node/test_gather_negative_indices/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_float32/model.onnx b/onnx/backend/test/data/node/test_gathernd_example_float32/model.onnx
new file mode 100644
index 0000000..6e6d8f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..808688c
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e74ff0a
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ea0b7d1
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_float32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_int32/model.onnx b/onnx/backend/test/data/node/test_gathernd_example_int32/model.onnx
new file mode 100644
index 0000000..5cc7b68
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4bc8485
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..44cc403
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc07bbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/model.onnx b/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/model.onnx
new file mode 100644
index 0000000..29b246f
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ab873d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..76c5233
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..227b48a
Binary files /dev/null and b/onnx/backend/test/data/node/test_gathernd_example_int32_batch_dim1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_default_1/model.onnx b/onnx/backend/test/data/node/test_gelu_default_1/model.onnx
new file mode 100644
index 0000000..ada8f65
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_default_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gelu_default_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gelu_default_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_default_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_default_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gelu_default_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cf9ae5e
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_default_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_default_1_expanded/model.onnx b/onnx/backend/test/data/node/test_gelu_default_1_expanded/model.onnx
new file mode 100644
index 0000000..ffee90b
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_default_1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gelu_default_1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gelu_default_1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_default_1_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_default_1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gelu_default_1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cf9ae5e
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_default_1_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_default_2/model.onnx b/onnx/backend/test/data/node/test_gelu_default_2/model.onnx
new file mode 100644
index 0000000..c03f470
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_default_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gelu_default_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gelu_default_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gelu_default_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gelu_default_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gelu_default_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bd5d99a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gelu_default_2/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
B
yJ�
�?�K�>��Q?A�
@t��?
+V$���I?�W��uB���>�d�=
��?VQ?V��=q��>�~W>�Q�?�x�G>e�+�8^_�$��>�o2?�.�ޓ@�3ٽxD�<+7����?п�?24�=I�z>kL*��'A���
���=D�?D�?��
+�|��
+��B⽁���KR�?h@�:U�Z����?S��;%��<�)����>�f�����a�J�>�s=��?>��*�S �
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gelu_default_2_expanded/model.onnx b/onnx/backend/test/data/node/test_gelu_default_2_expanded/model.onnx
new file mode 100644
index 0000000..1988c1b
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_default_2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gelu_default_2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gelu_default_2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gelu_default_2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gelu_default_2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gelu_default_2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bd5d99a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gelu_default_2_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
B
yJ�
�?�K�>��Q?A�
@t��?
+V$���I?�W��uB���>�d�=
��?VQ?V��=q��>�~W>�Q�?�x�G>e�+�8^_�$��>�o2?�.�ޓ@�3ٽxD�<+7����?п�?24�=I�z>kL*��'A���
���=D�?D�?��
+�|��
+��B⽁���KR�?h@�:U�Z����?S��;%��<�)����>�f�����a�J�>�s=��?>��*�S �
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_1/model.onnx b/onnx/backend/test/data/node/test_gelu_tanh_1/model.onnx
new file mode 100644
index 0000000..cbb06f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gelu_tanh_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gelu_tanh_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0f554cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_1_expanded/model.onnx b/onnx/backend/test/data/node/test_gelu_tanh_1_expanded/model.onnx
new file mode 100644
index 0000000..254f702
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gelu_tanh_1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_1_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gelu_tanh_1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0f554cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_1_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_2/model.onnx b/onnx/backend/test/data/node/test_gelu_tanh_2/model.onnx
new file mode 100644
index 0000000..887e5c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gelu_tanh_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gelu_tanh_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gelu_tanh_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9d1474a
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_2_expanded/model.onnx b/onnx/backend/test/data/node/test_gelu_tanh_2_expanded/model.onnx
new file mode 100644
index 0000000..6456042
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gelu_tanh_2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gelu_tanh_2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gelu_tanh_2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gelu_tanh_2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9d1474a
Binary files /dev/null and b/onnx/backend/test/data/node/test_gelu_tanh_2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gemm_all_attributes/model.onnx b/onnx/backend/test/data/node/test_gemm_all_attributes/model.onnx
new file mode 100644
index 0000000..13b6464
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_all_attributes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..53f90be
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ0?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e5347a9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJP^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a9cf36e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
cJ���>�?�<\?N�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..981b511
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_all_attributes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ<u�>��>�
�>��>��>���>��"?�?*'?�M?���>L�#?n��>�X�>��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_alpha/model.onnx b/onnx/backend/test/data/node/test_gemm_alpha/model.onnx
new file mode 100644
index 0000000..de350c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_alpha/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ee690ba
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6945e22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJP�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7077e4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..26a528b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_alpha/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ0b�}?�C!?%�p?���>�ƕ?D�?\؄?�?�ps?��?No?�	?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_beta/model.onnx b/onnx/backend/test/data/node/test_gemm_beta/model.onnx
new file mode 100644
index 0000000..8fa426b
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_beta/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b8f458a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ8?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3693051
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJpZ{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..257550d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
cJ��2?��v=9�*?�+?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..257d115
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_beta/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ �<�?X{-@�V	@Ε3@�@5�X@7.+@Ċ^@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_matrix_bias/model.onnx b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/model.onnx
new file mode 100644
index 0000000..5687e9d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e0263dc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJH?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2afad68
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJ`H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f794127
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
cJ0��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..25be287
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_matrix_bias/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ0ka@�2@��@��*@��?��P@P�@
+�'@��@C�@��@bD�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_no_bias/model.onnx b/onnx/backend/test/data/node/test_gemm_default_no_bias/model.onnx
new file mode 100644
index 0000000..608f495
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_no_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c697d4a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
+
B
aJP?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..33a04e6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
+
B
bJx��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a2d1ea8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_no_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_scalar_bias/model.onnx b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/model.onnx
new file mode 100644
index 0000000..9500d6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d8296f4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ?�7?�N?w}?H��>QY%?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8407d4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJ0n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..8a37e54
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
cJ��H@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1e8cfac
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_scalar_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/model.onnx b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/model.onnx
new file mode 100644
index 0000000..d2c185d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1c1c52c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJT?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4c02a90
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJT��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c2b01ea
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
cJ��2?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e8c7e34
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_single_elem_vector_bias/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ$�7@�[-@͆2@UX@
�N@�nT@[)@
@*�8@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_vector_bias/model.onnx b/onnx/backend/test/data/node/test_gemm_default_vector_bias/model.onnx
new file mode 100644
index 0000000..3b9b5a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_vector_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b8f458a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ8?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3693051
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJpZ{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..257550d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
cJ��2?��v=9�*?�+?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..151d426
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_vector_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_zero_bias/model.onnx b/onnx/backend/test/data/node/test_gemm_default_zero_bias/model.onnx
new file mode 100644
index 0000000..109ef57
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_zero_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ee690ba
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6945e22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJP�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7077e4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cdbdbc0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_default_zero_bias/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ0b��?�C�?%��?��~?��@D��?\�@��?�p�?�ߎ?N�?�	�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_transposeA/model.onnx b/onnx/backend/test/data/node/test_gemm_transposeA/model.onnx
new file mode 100644
index 0000000..be18bf0
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_transposeA/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4e23312
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJH?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2afad68
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJ`H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7077e4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..40a2611
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_transposeA/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gemm_transposeB/model.onnx b/onnx/backend/test/data/node/test_gemm_transposeB/model.onnx
new file mode 100644
index 0000000..45565f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_transposeB/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e0263dc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJH?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..165ae22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJ`H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7077e4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7d048a5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gemm_transposeB/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ0m�1@�j�?�a�?�	@�7I@m��?��?�L @A�@"̍?S�?0J�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_globalaveragepool/model.onnx b/onnx/backend/test/data/node/test_globalaveragepool/model.onnx
new file mode 100644
index 0000000..1441d1e
Binary files /dev/null and b/onnx/backend/test/data/node/test_globalaveragepool/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eba6662
--- /dev/null
+++ b/onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..11253b3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_globalaveragepool/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



B
yJ�I�>o�F�w��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_globalaveragepool_precomputed/model.onnx b/onnx/backend/test/data/node/test_globalaveragepool_precomputed/model.onnx
new file mode 100644
index 0000000..de1544e
Binary files /dev/null and b/onnx/backend/test/data/node/test_globalaveragepool_precomputed/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f170252
Binary files /dev/null and b/onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..afafcf9
Binary files /dev/null and b/onnx/backend/test/data/node/test_globalaveragepool_precomputed/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_globalmaxpool/model.onnx b/onnx/backend/test/data/node/test_globalmaxpool/model.onnx
new file mode 100644
index 0000000..007fe81
Binary files /dev/null and b/onnx/backend/test/data/node/test_globalmaxpool/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eba6662
--- /dev/null
+++ b/onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..68ac3d7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_globalmaxpool/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



B
yJ�C@��?�ב?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_globalmaxpool_precomputed/model.onnx b/onnx/backend/test/data/node/test_globalmaxpool_precomputed/model.onnx
new file mode 100644
index 0000000..69ac331
Binary files /dev/null and b/onnx/backend/test/data/node/test_globalmaxpool_precomputed/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f170252
Binary files /dev/null and b/onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f526155
Binary files /dev/null and b/onnx/backend/test/data/node/test_globalmaxpool_precomputed/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater/model.onnx b/onnx/backend/test/data/node/test_greater/model.onnx
new file mode 100644
index 0000000..bc4f2ae
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1424d72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3c4514f
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_bcast/model.onnx b/onnx/backend/test/data/node/test_greater_bcast/model.onnx
new file mode 100644
index 0000000..a21365c
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dcbe531
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..086fbce
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_bcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal/model.onnx b/onnx/backend/test/data/node/test_greater_equal/model.onnx
new file mode 100644
index 0000000..061aed0
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1424d72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_equal/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_equal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ef26767
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_bcast/model.onnx b/onnx/backend/test/data/node/test_greater_equal_bcast/model.onnx
new file mode 100644
index 0000000..b17d113
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dcbe531
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..de50622
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_bcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/model.onnx b/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/model.onnx
new file mode 100644
index 0000000..6709355
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dcbe531
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..de50622
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_bcast_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_expanded/model.onnx b/onnx/backend/test/data/node/test_greater_equal_expanded/model.onnx
new file mode 100644
index 0000000..6859da5
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1424d72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ef26767
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int16/model.onnx b/onnx/backend/test/data/node/test_greater_equal_int16/model.onnx
new file mode 100644
index 0000000..1b612d4
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4d27e19
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..617a4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2cdb9a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int16_expanded/model.onnx b/onnx/backend/test/data/node/test_greater_equal_int16_expanded/model.onnx
new file mode 100644
index 0000000..569978d
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4d27e19
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..617a4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2cdb9a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int8/model.onnx b/onnx/backend/test/data/node/test_greater_equal_int8/model.onnx
new file mode 100644
index 0000000..3ffcf4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2060ad4
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dd426bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..95dd0fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int8_expanded/model.onnx b/onnx/backend/test/data/node/test_greater_equal_int8_expanded/model.onnx
new file mode 100644
index 0000000..634274d
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int8_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2060ad4
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dd426bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..95dd0fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_int8_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint16/model.onnx b/onnx/backend/test/data/node/test_greater_equal_uint16/model.onnx
new file mode 100644
index 0000000..04f717c
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05499ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8caad5
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c375851
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/model.onnx b/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/model.onnx
new file mode 100644
index 0000000..b838064
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05499ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8caad5
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c375851
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint32/model.onnx b/onnx/backend/test/data/node/test_greater_equal_uint32/model.onnx
new file mode 100644
index 0000000..b694bd3
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57ca187
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e078d4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9ff3608
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/model.onnx b/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/model.onnx
new file mode 100644
index 0000000..6bb95b7
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57ca187
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e078d4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9ff3608
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint32_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint64/model.onnx b/onnx/backend/test/data/node/test_greater_equal_uint64/model.onnx
new file mode 100644
index 0000000..5d4a097
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..028107b
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0884815
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bdefcc6
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/model.onnx b/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/model.onnx
new file mode 100644
index 0000000..67e595f
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..028107b
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0884815
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bdefcc6
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint64_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint8/model.onnx b/onnx/backend/test/data/node/test_greater_equal_uint8/model.onnx
new file mode 100644
index 0000000..3613ecb
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9af0258
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7d08c07
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3818b41
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/model.onnx b/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/model.onnx
new file mode 100644
index 0000000..c70dab4
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9af0258
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7d08c07
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3818b41
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_equal_uint8_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_int16/model.onnx b/onnx/backend/test/data/node/test_greater_int16/model.onnx
new file mode 100644
index 0000000..035eb08
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4d27e19
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..617a4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c06b444
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_int8/model.onnx b/onnx/backend/test/data/node/test_greater_int8/model.onnx
new file mode 100644
index 0000000..6e14f89
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2060ad4
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_int8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dd426bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_int8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6a41a3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_int8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint16/model.onnx b/onnx/backend/test/data/node/test_greater_uint16/model.onnx
new file mode 100644
index 0000000..765740a
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05499ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8caad5
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..10eab64
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint32/model.onnx b/onnx/backend/test/data/node/test_greater_uint32/model.onnx
new file mode 100644
index 0000000..228bf85
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57ca187
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e078d4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ebd7f6e
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint64/model.onnx b/onnx/backend/test/data/node/test_greater_uint64/model.onnx
new file mode 100644
index 0000000..44d59ca
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..028107b
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0884815
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2be4029
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint8/model.onnx b/onnx/backend/test/data/node/test_greater_uint8/model.onnx
new file mode 100644
index 0000000..9123981
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9af0258
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7d08c07
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d07ace5
Binary files /dev/null and b/onnx/backend/test/data/node/test_greater_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample/model.onnx b/onnx/backend/test/data/node/test_gridsample/model.onnx
new file mode 100644
index 0000000..1d17074
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bf70952
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bb2ce19
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9488b8b
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_aligncorners_true/model.onnx b/onnx/backend/test/data/node/test_gridsample_aligncorners_true/model.onnx
new file mode 100644
index 0000000..6def3c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_aligncorners_true/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1286d0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1269b66
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_aligncorners_true/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic/model.onnx b/onnx/backend/test/data/node/test_gridsample_bicubic/model.onnx
new file mode 100644
index 0000000..307d651
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1286d0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ff96864
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/model.onnx b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/model.onnx
new file mode 100644
index 0000000..cf23035
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..625d3b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f3bf77b
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_0_additional_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/model.onnx b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/model.onnx
new file mode 100644
index 0000000..a617350
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..625d3b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e335d3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bicubic_align_corners_1_additional_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear/model.onnx b/onnx/backend/test/data/node/test_gridsample_bilinear/model.onnx
new file mode 100644
index 0000000..bb1b2eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1286d0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c3cb6e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/model.onnx b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/model.onnx
new file mode 100644
index 0000000..07ac23f
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..625d3b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6d67f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_0_additional_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/model.onnx b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/model.onnx
new file mode 100644
index 0000000..c17ad25
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..625d3b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1bd44f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_bilinear_align_corners_1_additional_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_border_padding/model.onnx b/onnx/backend/test/data/node/test_gridsample_border_padding/model.onnx
new file mode 100644
index 0000000..3c548c9
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_border_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4067cb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c61638d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_border_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest/model.onnx b/onnx/backend/test/data/node/test_gridsample_nearest/model.onnx
new file mode 100644
index 0000000..2940908
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1286d0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e110edb
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/model.onnx b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/model.onnx
new file mode 100644
index 0000000..245dcbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..625d3b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c5ebe49
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_0_additional_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/model.onnx b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/model.onnx
new file mode 100644
index 0000000..de22147
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..625d3b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..89d2f9e
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_nearest_align_corners_1_additional_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_reflection_padding/model.onnx b/onnx/backend/test/data/node/test_gridsample_reflection_padding/model.onnx
new file mode 100644
index 0000000..203f143
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_reflection_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4067cb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0adcf14
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_reflection_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/model.onnx b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/model.onnx
new file mode 100644
index 0000000..7f90268
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..31d13aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..230c443
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e142d68
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/model.onnx b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/model.onnx
new file mode 100644
index 0000000..e3781ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..31d13aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..230c443
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4cafbc8
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_bilinear_align_corners_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/model.onnx b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/model.onnx
new file mode 100644
index 0000000..706252d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..31d13aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..230c443
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..117c0a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/model.onnx b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/model.onnx
new file mode 100644
index 0000000..2eb750c
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..31d13aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..230c443
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8418ba7
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_volumetric_nearest_align_corners_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_zeros_padding/model.onnx b/onnx/backend/test/data/node/test_gridsample_zeros_padding/model.onnx
new file mode 100644
index 0000000..7ed92ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_zeros_padding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0c8ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4067cb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..909b699
Binary files /dev/null and b/onnx/backend/test/data/node/test_gridsample_zeros_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon/model.onnx b/onnx/backend/test/data/node/test_group_normalization_epsilon/model.onnx
new file mode 100644
index 0000000..05b0c2c
Binary files /dev/null and b/onnx/backend/test/data/node/test_group_normalization_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fe9ab9d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7282ad4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BscaleJ4��Y�L=e��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..92aff8b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ �����k��QN�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ffa434b
Binary files /dev/null and b/onnx/backend/test/data/node/test_group_normalization_epsilon/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..3044507
Binary files /dev/null and b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fe9ab9d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7282ad4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BscaleJ4��Y�L=e��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..92aff8b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ �����k��QN�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ffa434b
Binary files /dev/null and b/onnx/backend/test/data/node/test_group_normalization_epsilon_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_group_normalization_example/model.onnx b/onnx/backend/test/data/node/test_group_normalization_example/model.onnx
new file mode 100644
index 0000000..afca020
Binary files /dev/null and b/onnx/backend/test/data/node/test_group_normalization_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fe9ab9d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7282ad4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BscaleJ4��Y�L=e��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..92aff8b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ �����k��QN�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5bebd8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_example/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
�!�,�>>�(���)��N���K�����ew���?4U*=�?��
�:�2?��>�z�>@�>�D.��!о�u����>J�>�8������b��������?��>��?��G?86B?���>|��>�+?��@� Y�A\��}�����������U���z�>�
+7?ڇo?Q�<#�>�W�>��&>T�V?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_example_expanded/model.onnx b/onnx/backend/test/data/node/test_group_normalization_example_expanded/model.onnx
new file mode 100644
index 0000000..153cbba
Binary files /dev/null and b/onnx/backend/test/data/node/test_group_normalization_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fe9ab9d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7282ad4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BscaleJ4��Y�L=e��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..92aff8b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJ �����k��QN�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5bebd8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_group_normalization_example_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
�!�,�>>�(���)��N���K�����ew���?4U*=�?��
�:�2?��>�z�>@�>�D.��!о�u����>J�>�8������b��������?��>��?��G?86B?���>|��>�+?��@� Y�A\��}�����������U���z�>�
+7?ڇo?Q�<#�>�W�>��&>T�V?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_batchwise/model.onnx b/onnx/backend/test/data/node/test_gru_batchwise/model.onnx
new file mode 100644
index 0000000..6e8a50d
Binary files /dev/null and b/onnx/backend/test/data/node/test_gru_batchwise/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a4c92c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..69ecd5b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJ�
��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..213bb3f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJ���L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>��L>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7f5281e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_0.pb
@@ -0,0 +1,7 @@
+


B
YJH
+�B>
+�B>
+�B>
+�B>
+�B>
+�B>W3>W3>W3>W3>W3>W3>fU�=fU�=fU�=fU�=fU�=fU�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..a9c9137
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_batchwise/test_data_set_0/output_1.pb
@@ -0,0 +1,7 @@
+

BY_hJH
+�B>
+�B>
+�B>
+�B>
+�B>
+�B>W3>W3>W3>W3>W3>W3>fU�=fU�=fU�=fU�=fU�=fU�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_defaults/model.onnx b/onnx/backend/test/data/node/test_gru_defaults/model.onnx
new file mode 100644
index 0000000..07689ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_gru_defaults/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..17423bc
Binary files /dev/null and b/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..99b74f9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJx���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7787196
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJ����=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5205e2b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_defaults/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BY_hJ<��=��=��=��=��=yYM>yYM>yYM>yYM>yYM>�L>�L>�L>�L>�L>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_seq_length/model.onnx b/onnx/backend/test/data/node/test_gru_seq_length/model.onnx
new file mode 100644
index 0000000..5f0369e
Binary files /dev/null and b/onnx/backend/test/data/node/test_gru_seq_length/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0879670
Binary files /dev/null and b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e874a35
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0b3c5c4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJ�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..97393a9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+

B
BJxٺ�>*������>ǩ?3�1��9�r�޾���?�,?֞�>8E�<
+?�,��`=��"��*-?u�?ELU�d��>q鋿�᾿���>u�*>l�"?r�@h�q?��i�d��?�o���T�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6116cf9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_seq_length/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BY_hJ<HH��"���~9�>�/��$\�����z���=XO7�X���!�d�.>#<Ѐ�O\L�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_with_initial_bias/model.onnx b/onnx/backend/test/data/node/test_gru_with_initial_bias/model.onnx
new file mode 100644
index 0000000..d87b797
Binary files /dev/null and b/onnx/backend/test/data/node/test_gru_with_initial_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cb9bf0
Binary files /dev/null and b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6515694
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
	
B
WJl���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9dce5b5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
	
B
RJl���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..836334e
Binary files /dev/null and b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..31f8ef0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_gru_with_initial_bias/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BY_hJ$yYM>yYM>yYM>�>�>�>)G�=)G�=)G�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hammingwindow/model.onnx b/onnx/backend/test/data/node/test_hammingwindow/model.onnx
new file mode 100644
index 0000000..9addad3
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2cb235a
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow_expanded/model.onnx b/onnx/backend/test/data/node/test_hammingwindow_expanded/model.onnx
new file mode 100644
index 0000000..3d5dfb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2cb235a
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow_symmetric/model.onnx b/onnx/backend/test/data/node/test_hammingwindow_symmetric/model.onnx
new file mode 100644
index 0000000..bc1ae55
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow_symmetric/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f68503e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hammingwindow_symmetric/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+
B
yJ(C�=�iF>)��>��E?��x?��x?��E?$��>�iF>C�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/model.onnx b/onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/model.onnx
new file mode 100644
index 0000000..006caf4
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f68503e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hammingwindow_symmetric_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+
B
yJ(C�=�iF>)��>��E?��x?��x?��E?$��>�iF>C�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hannwindow/model.onnx b/onnx/backend/test/data/node/test_hannwindow/model.onnx
new file mode 100644
index 0000000..301654d
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hannwindow/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hannwindow/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hannwindow/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hannwindow/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9d14ac5
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hannwindow_expanded/model.onnx b/onnx/backend/test/data/node/test_hannwindow_expanded/model.onnx
new file mode 100644
index 0000000..184d96a
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9d14ac5
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hannwindow_symmetric/model.onnx b/onnx/backend/test/data/node/test_hannwindow_symmetric/model.onnx
new file mode 100644
index 0000000..5d4cecb
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow_symmetric/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..991a2ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow_symmetric/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/model.onnx b/onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/model.onnx
new file mode 100644
index 0000000..8336dcc
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6086fc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..991a2ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_hannwindow_symmetric_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardmax_axis_0/model.onnx b/onnx/backend/test/data/node/test_hardmax_axis_0/model.onnx
new file mode 100644
index 0000000..ea05473
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a6b15b5
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_axis_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardmax_axis_1/model.onnx b/onnx/backend/test/data/node/test_hardmax_axis_1/model.onnx
new file mode 100644
index 0000000..2d317ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4f31bbe
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_axis_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardmax_axis_2/model.onnx b/onnx/backend/test/data/node/test_hardmax_axis_2/model.onnx
new file mode 100644
index 0000000..3634ea5
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_axis_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f7afee9
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_axis_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardmax_default_axis/model.onnx b/onnx/backend/test/data/node/test_hardmax_default_axis/model.onnx
new file mode 100644
index 0000000..ae2c179
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_default_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f7afee9
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_default_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardmax_example/model.onnx b/onnx/backend/test/data/node/test_hardmax_example/model.onnx
new file mode 100644
index 0000000..31a5fb1
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..433614e
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a0fb2a7
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardmax_negative_axis/model.onnx b/onnx/backend/test/data/node/test_hardmax_negative_axis/model.onnx
new file mode 100644
index 0000000..5aa0dfd
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_negative_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f7afee9
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_negative_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardmax_one_hot/model.onnx b/onnx/backend/test/data/node/test_hardmax_one_hot/model.onnx
new file mode 100644
index 0000000..4ab6af9
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_one_hot/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9f8805f
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cd6bf58
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardmax_one_hot/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid/model.onnx b/onnx/backend/test/data/node/test_hardsigmoid/model.onnx
new file mode 100644
index 0000000..5070351
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bb2d84b
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_default/model.onnx b/onnx/backend/test/data/node/test_hardsigmoid_default/model.onnx
new file mode 100644
index 0000000..d0e57f3
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bd3a106
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/model.onnx
new file mode 100644
index 0000000..94aa03d
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bd3a106
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_default_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_example/model.onnx b/onnx/backend/test/data/node/test_hardsigmoid_example/model.onnx
new file mode 100644
index 0000000..ffe09d4
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c7cb5d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/model.onnx
new file mode 100644
index 0000000..8aa3f1e
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c7cb5d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_example_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/model.onnx
new file mode 100644
index 0000000..25a0a30
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bb2d84b
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardsigmoid_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardswish/model.onnx b/onnx/backend/test/data/node/test_hardswish/model.onnx
new file mode 100644
index 0000000..0ed0b32
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardswish/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardswish/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardswish/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardswish/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardswish/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardswish/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5e8478e
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardswish/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_hardswish_expanded/model.onnx b/onnx/backend/test/data/node/test_hardswish_expanded/model.onnx
new file mode 100644
index 0000000..abe72af
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardswish_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5e8478e
Binary files /dev/null and b/onnx/backend/test/data/node/test_hardswish_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_identity/model.onnx b/onnx/backend/test/data/node/test_identity/model.onnx
new file mode 100644
index 0000000..ca9ed94
Binary files /dev/null and b/onnx/backend/test/data/node/test_identity/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_identity/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_identity/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dc6642
Binary files /dev/null and b/onnx/backend/test/data/node/test_identity/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_identity/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_identity/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9e707e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_identity/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_identity_opt/model.onnx b/onnx/backend/test/data/node/test_identity_opt/model.onnx
new file mode 100644
index 0000000..24c05f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_identity_opt/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_identity_opt/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_identity_opt/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6654175
Binary files /dev/null and b/onnx/backend/test/data/node/test_identity_opt/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_identity_opt/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_identity_opt/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..caf27fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_identity_opt/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_identity_sequence/model.onnx b/onnx/backend/test/data/node/test_identity_sequence/model.onnx
new file mode 100644
index 0000000..8a1b756
Binary files /dev/null and b/onnx/backend/test/data/node/test_identity_sequence/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..93d5a7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..edef126
Binary files /dev/null and b/onnx/backend/test/data/node/test_identity_sequence/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_if/model.onnx b/onnx/backend/test/data/node/test_if/model.onnx
new file mode 100644
index 0000000..1a1716e
Binary files /dev/null and b/onnx/backend/test/data/node/test_if/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_if/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_if/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a61228b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_if/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+	BcondJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_if/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_if/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5371ef3
Binary files /dev/null and b/onnx/backend/test/data/node/test_if/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_if_opt/model.onnx b/onnx/backend/test/data/node/test_if_opt/model.onnx
new file mode 100644
index 0000000..bbac0ae
Binary files /dev/null and b/onnx/backend/test/data/node/test_if_opt/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_if_opt/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_if_opt/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c5b8b09
Binary files /dev/null and b/onnx/backend/test/data/node/test_if_opt/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_if_opt/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_if_opt/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d4eb6c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_if_opt/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_if_seq/model.onnx b/onnx/backend/test/data/node/test_if_seq/model.onnx
new file mode 100644
index 0000000..19650be
Binary files /dev/null and b/onnx/backend/test/data/node/test_if_seq/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_if_seq/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_if_seq/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a61228b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_if_seq/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+	BcondJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_if_seq/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_if_seq/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..73dc9b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_if_seq/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/model.onnx b/onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/model.onnx
new file mode 100644
index 0000000..0b90ba5
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7c6c37c
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8a8f1a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_bmp_rgb/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/model.onnx b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/model.onnx
new file mode 100644
index 0000000..f93a389
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5c03142
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8a8f1a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg2k_rgb/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/model.onnx b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/model.onnx
new file mode 100644
index 0000000..24334e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4436a57
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9bf17fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_bgr/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/model.onnx b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/model.onnx
new file mode 100644
index 0000000..4a643ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4436a57
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7630455
--- /dev/null
+++ b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_grayscale/test_data_set_0/output_0.pb
@@ -0,0 +1,10 @@
+  
BoutputJ���������������������0?3=-|pskw��������������������;5<=Azgvws��������������������<388:vnuzr	��������������������;E4='s|oqu		��������������������D5(=Lpwfls7454.VTWW[XY]XZimVYp��Ĭ�mbbmj8566-PKMPX\_d_]hZavf�����f_dfb31692UPQGSZ_a^ZcegY\�����`mgY`5863:IQOKQbdXZbedj^`�����fh\jW/32/7GOMQF[`^d\f^cbp�����jmcma6:96=LSQTO�x�����̾�}y{������
+69849GLIGC�|ry������yz�w�����
+6;:6<IOK[L|}�y�����u��t�����
2674;INKGHt|�}z�����|}~�y�����
6;:6<GKGO]v{~s�����Ńzt�������`c`Z]ega`\IDNBM���������������_____`bbb^KEJNC���������������

]]^_`accgePHFID���������������
]^_`bcde^_JFCIK���������������\]^^___^deMNKQS������������������������}]`[\Wndfec�������½�������~��_hcd_cfhhf������ſ���������~Zf`dfcegfe����������
����������_i]`gbegfe�����¸���
+��������}cbebi^iddq����������
���������������nifddfgebavlpm}
+���������������nsuuphcce^uoums
+
���������������heikhb_bfesjoim
���������������jmmmjgdddfqjtof���������������tmkhggecacnmzuf		
+
	
+
+
+


		
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/model.onnx b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/model.onnx
new file mode 100644
index 0000000..10801be
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4436a57
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..087c567
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_jpeg_rgb/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/model.onnx b/onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/model.onnx
new file mode 100644
index 0000000..42cb3f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4a8bf0e
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8a8f1a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_png_rgb/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/model.onnx b/onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/model.onnx
new file mode 100644
index 0000000..e4f2067
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4bfadef
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8a8f1a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_pnm_rgb/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/model.onnx b/onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/model.onnx
new file mode 100644
index 0000000..011f432
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb7174d
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8a8f1a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_tiff_rgb/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/model.onnx b/onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/model.onnx
new file mode 100644
index 0000000..accb299
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e032c5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99629ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_image_decoder_decode_webp_rgb/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_instancenorm_epsilon/model.onnx b/onnx/backend/test/data/node/test_instancenorm_epsilon/model.onnx
new file mode 100644
index 0000000..9cf84c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_instancenorm_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5103103
--- /dev/null
+++ b/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..be392c2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
sJٺ�>*������>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ffa575c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BbiasJǩ?3�1��9�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4093b49
Binary files /dev/null and b/onnx/backend/test/data/node/test_instancenorm_epsilon/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_instancenorm_example/model.onnx b/onnx/backend/test/data/node/test_instancenorm_example/model.onnx
new file mode 100644
index 0000000..ae190dd
Binary files /dev/null and b/onnx/backend/test/data/node/test_instancenorm_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d1c0c
Binary files /dev/null and b/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c60d361
Binary files /dev/null and b/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..753f636
Binary files /dev/null and b/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5211daa
Binary files /dev/null and b/onnx/backend/test/data/node/test_instancenorm_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isinf/model.onnx b/onnx/backend/test/data/node/test_isinf/model.onnx
new file mode 100644
index 0000000..431361c
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_isinf/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_isinf/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ad81eb1
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isinf/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_isinf/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c75785d
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isinf_float16/model.onnx b/onnx/backend/test/data/node/test_isinf_float16/model.onnx
new file mode 100644
index 0000000..15920a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_isinf_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_isinf_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f423ccd
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf_float16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isinf_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_isinf_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c75785d
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf_float16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isinf_negative/model.onnx b/onnx/backend/test/data/node/test_isinf_negative/model.onnx
new file mode 100644
index 0000000..24b8db5
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf_negative/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2e8954d
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6adb495
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf_negative/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isinf_positive/model.onnx b/onnx/backend/test/data/node/test_isinf_positive/model.onnx
new file mode 100644
index 0000000..339005f
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf_positive/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f65bb69
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ebe65e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_isinf_positive/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isnan/model.onnx b/onnx/backend/test/data/node/test_isnan/model.onnx
new file mode 100644
index 0000000..cdc7176
Binary files /dev/null and b/onnx/backend/test/data/node/test_isnan/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_isnan/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_isnan/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ad81eb1
Binary files /dev/null and b/onnx/backend/test/data/node/test_isnan/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isnan/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_isnan/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a4d6c60
Binary files /dev/null and b/onnx/backend/test/data/node/test_isnan/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isnan_float16/model.onnx b/onnx/backend/test/data/node/test_isnan_float16/model.onnx
new file mode 100644
index 0000000..c963a39
Binary files /dev/null and b/onnx/backend/test/data/node/test_isnan_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_isnan_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_isnan_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f423ccd
Binary files /dev/null and b/onnx/backend/test/data/node/test_isnan_float16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_isnan_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_isnan_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a4d6c60
Binary files /dev/null and b/onnx/backend/test/data/node/test_isnan_float16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_l1normalization_axis_0/model.onnx b/onnx/backend/test/data/node/test_l1normalization_axis_0/model.onnx
new file mode 100644
index 0000000..73b1cf0
Binary files /dev/null and b/onnx/backend/test/data/node/test_l1normalization_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_l1normalization_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_l1normalization_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..085a7dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_l1normalization_axis_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_l1normalization_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_l1normalization_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..166763e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_l1normalization_axis_0/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�m�>%I?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_l1normalization_axis_1/model.onnx b/onnx/backend/test/data/node/test_l1normalization_axis_1/model.onnx
new file mode 100644
index 0000000..7a48ff3
Binary files /dev/null and b/onnx/backend/test/data/node/test_l1normalization_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_l1normalization_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_l1normalization_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f48bb00
Binary files /dev/null and b/onnx/backend/test/data/node/test_l1normalization_axis_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_l1normalization_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_l1normalization_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e76ed5e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_l1normalization_axis_1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�m�>%I?�m�>%I?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_l1normalization_axis_last/model.onnx b/onnx/backend/test/data/node/test_l1normalization_axis_last/model.onnx
new file mode 100644
index 0000000..d96674e
Binary files /dev/null and b/onnx/backend/test/data/node/test_l1normalization_axis_last/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_l1normalization_axis_last/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_l1normalization_axis_last/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bf0307c
Binary files /dev/null and b/onnx/backend/test/data/node/test_l1normalization_axis_last/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_l1normalization_axis_last/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_l1normalization_axis_last/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..870fa13
Binary files /dev/null and b/onnx/backend/test/data/node/test_l1normalization_axis_last/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_l2normalization_axis_0/model.onnx b/onnx/backend/test/data/node/test_l2normalization_axis_0/model.onnx
new file mode 100644
index 0000000..7f53005
Binary files /dev/null and b/onnx/backend/test/data/node/test_l2normalization_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_l2normalization_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_l2normalization_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bf0307c
Binary files /dev/null and b/onnx/backend/test/data/node/test_l2normalization_axis_0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_l2normalization_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_l2normalization_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6056074
Binary files /dev/null and b/onnx/backend/test/data/node/test_l2normalization_axis_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_l2normalization_axis_1/model.onnx b/onnx/backend/test/data/node/test_l2normalization_axis_1/model.onnx
new file mode 100644
index 0000000..9ecd585
Binary files /dev/null and b/onnx/backend/test/data/node/test_l2normalization_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_l2normalization_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_l2normalization_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f48bb00
Binary files /dev/null and b/onnx/backend/test/data/node/test_l2normalization_axis_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_l2normalization_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_l2normalization_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b4b6c88
--- /dev/null
+++ b/onnx/backend/test/data/node/test_l2normalization_axis_1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ��?��L?��?��L?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/model.onnx
new file mode 100644
index 0000000..fdc5f48
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cb9f861
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c4cc3f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ0�C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dfc6746
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0��F@����h >^��>V@./�?��d><��?��?��@�i�W�Ҿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..148269b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJي??
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..43e3980
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/model.onnx
new file mode 100644
index 0000000..d7dd555
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cb9f861
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c4cc3f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ0�C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dfc6746
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0��F@����h >^��>V@./�?��d><��?��?��@�i�W�Ҿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..148269b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJي??
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..43e3980
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/model.onnx
new file mode 100644
index 0000000..86fcf8a
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cb9f861
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c4cc3f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ0�C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dfc6746
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0��F@����h >^��>V@./�?��d><��?��?��@�i�W�Ҿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..148269b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJي??
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..43e3980
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis0_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/model.onnx
new file mode 100644
index 0000000..b5ba7fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e62021
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6292fe9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ3�5>;�;W���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4628fd7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0U�`��Ӡ=p���-ܿ�69�p�=��
����?�U?�G���U�����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98181fe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJlH�?�1�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..2515b32
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�ɴ?�Lm?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/model.onnx
new file mode 100644
index 0000000..65b7ec5
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e62021
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6292fe9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ3�5>;�;W���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4628fd7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0U�`��Ӡ=p���-ܿ�69�p�=��
����?�U?�G���U�����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98181fe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJlH�?�1�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..2515b32
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�ɴ?�Lm?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/model.onnx
new file mode 100644
index 0000000..d06789f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e62021
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6292fe9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ3�5>;�;W���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4628fd7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0U�`��Ӡ=p���-ܿ�69�p�=��
����?�U?�G���U�����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98181fe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJlH�?�1�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..2515b32
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis1_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�ɴ?�Lm?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/model.onnx
new file mode 100644
index 0000000..76810c7
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..42570ca
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ�Dh���T=��:?>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..fda0006
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ�ב?������>�O/�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..804362a
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98181fe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJlH�?�1�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..2515b32
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�ɴ?�Lm?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/model.onnx
new file mode 100644
index 0000000..1ad75d6
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..42570ca
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ�Dh���T=��:?>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..fda0006
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ�ב?������>�O/�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..804362a
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98181fe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJlH�?�1�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..2515b32
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�ɴ?�Lm?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/model.onnx
new file mode 100644
index 0000000..e6bf6f3
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..42570ca
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ�Dh���T=��:?>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..fda0006
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ�ב?������>�O/�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..804362a
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..98181fe
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJlH�?�1�>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..2515b32
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�ɴ?�Lm?���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/model.onnx
new file mode 100644
index 0000000..570a3bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4e7a630
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..d5d501c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ04�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..37959bf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0�ׄ�a�*��~�$(ѽ^2俽ż?0�;���k	?���>m>>�m>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..148269b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJي??
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..43e3980
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/model.onnx
new file mode 100644
index 0000000..f50207e
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4e7a630
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..d5d501c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ04�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..37959bf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0�ׄ�a�*��~�$(ѽ^2俽ż?0�;���k	?���>m>>�m>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..148269b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJي??
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..43e3980
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/model.onnx
new file mode 100644
index 0000000..f97ff72
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4e7a630
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..d5d501c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ04�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..37959bf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0�ׄ�a�*��~�$(ѽ^2俽ż?0�;���k	?���>m>>�m>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..148269b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJي??
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..43e3980
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_2d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/model.onnx
new file mode 100644
index 0000000..0c06b4d
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a316592
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..74d9957
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJx^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..75b51e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0106db6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..a76b1d4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJp!c?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..7b68e2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a316592
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..74d9957
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJx^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..75b51e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0106db6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..a76b1d4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJp!c?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/model.onnx
new file mode 100644
index 0000000..822bb16
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a316592
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..74d9957
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJx^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..75b51e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0106db6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..a76b1d4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis0_epsilon_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJp!c?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/model.onnx
new file mode 100644
index 0000000..2f451c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0186d6a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ<A‹��N�?A�>�z�S�z�ɽ��)��5�?2;��A����)�������?>
s?N�=ۜ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c49373
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ<,(X?���ſ\�?MF�>g�k?E0�>@Y[?��&�b���|.?A�M�V�0��;�t0�<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..820667a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJxF?C?��ſĢ���t�[I@>4x	@l�%?�u�?N��>�Vf�k{?ӀW?������@{�>�LV?>{??�g��䉎?|�>w�@4�8?���>�&L>��߿�?�?8����fz�� �����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2494f05
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ��/?7yK>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..acedd02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ�>�?K�I?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..dcee447
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0186d6a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ<A‹��N�?A�>�z�S�z�ɽ��)��5�?2;��A����)�������?>
s?N�=ۜ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c49373
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ<,(X?���ſ\�?MF�>g�k?E0�>@Y[?��&�b���|.?A�M�V�0��;�t0�<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..820667a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJxF?C?��ſĢ���t�[I@>4x	@l�%?�u�?N��>�Vf�k{?ӀW?������@{�>�LV?>{??�g��䉎?|�>w�@4�8?���>�&L>��߿�?�?8����fz�� �����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2494f05
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ��/?7yK>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..acedd02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ�>�?K�I?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/model.onnx
new file mode 100644
index 0000000..aba6780
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0186d6a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ<A‹��N�?A�>�z�S�z�ɽ��)��5�?2;��A����)�������?>
s?N�=ۜ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c49373
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ<,(X?���ſ\�?MF�>g�k?E0�>@Y[?��&�b���|.?A�M�V�0��;�t0�<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..820667a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJxF?C?��ſĢ���t�[I@>4x	@l�%?�u�?N��>�Vf�k{?ӀW?������@{�>�LV?>{??�g��䉎?|�>w�@4�8?���>�&L>��߿�?�?8����fz�� �����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2494f05
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ��/?7yK>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..acedd02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis1_epsilon_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ�>�?K�I?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/model.onnx
new file mode 100644
index 0000000..d06ef7d
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..82e3d1c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ|
i?mj�>�LI?|��;�q�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aab785
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ	�Ѿen��- �>��@�-�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0645ac3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
YJx����+������j:�?����׿7;�>��<>��@���.���O�>��?�4(@µ=>�a����>p���)"
@,��?��ص=
+�=?�@0#���R��d��X�=��?|‿
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bd9b558
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJĢ�?}�<(�?C�]>���=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..469229d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�t�?X
�?���?�q�?�?\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..26662d6
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..82e3d1c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ|
i?mj�>�LI?|��;�q�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aab785
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ	�Ѿen��- �>��@�-�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0645ac3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
YJx����+������j:�?����׿7;�>��<>��@���.���O�>��?�4(@µ=>�a����>p���)"
@,��?��ص=
+�=?�@0#���R��d��X�=��?|‿
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bd9b558
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJĢ�?}�<(�?C�]>���=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..469229d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�t�?X
�?���?�q�?�?\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/model.onnx
new file mode 100644
index 0000000..5c706fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..82e3d1c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ|
i?mj�>�LI?|��;�q�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9aab785
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ	�Ѿen��- �>��@�-�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0645ac3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
YJx����+������j:�?����׿7;�>��<>��@���.���O�>��?�4(@µ=>�a����>p���)"
@,��?��ص=
+�=?�@0#���R��d��X�=��?|‿
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bd9b558
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJĢ�?}�<(�?C�]>���=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..469229d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis2_epsilon_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�t�?X
�?���?�q�?�?\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/model.onnx
new file mode 100644
index 0000000..f59572e
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ee99892
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJиt��$��t\�����>�8ſ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..89dd201
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ���=@C >��m>�����s�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d42835b
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bd9b558
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJĢ�?}�<(�?C�]>���=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..469229d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�t�?X
�?���?�q�?�?\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..cb35007
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ee99892
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJиt��$��t\�����>�8ſ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..89dd201
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ���=@C >��m>�����s�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d42835b
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bd9b558
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJĢ�?}�<(�?C�]>���=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..469229d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�t�?X
�?���?�q�?�?\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/model.onnx
new file mode 100644
index 0000000..92dce8b
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ee99892
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJиt��$��t\�����>�8ſ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..89dd201
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ���=@C >��m>�����s�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d42835b
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bd9b558
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BMeanJĢ�?}�<(�?C�]>���=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..469229d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_1_epsilon_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

B	InvStdDevJ�t�?X
�?���?�q�?�?\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/model.onnx
new file mode 100644
index 0000000..ea52be5
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a0ab9b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c7a81ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJ<ש/��E?+�R?ur
+@Y�?g���u����?]�'?��#?j�ο�GǼ��<�GR�>ɽ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53d5013
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
YJx�a�3�?�f?��ֿ�
+@3
&@�����?<
�?�&*>m<V��AP>c�=�mÁ?qJu�c3V�k�!����?�A�?LkQ?͚F@v�"��A�?��?�J@��=�jg��9���r����>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2494f05
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ��/?7yK>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..acedd02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ�>�?K�I?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..c0a2930
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a0ab9b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c7a81ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJ<ש/��E?+�R?ur
+@Y�?g���u����?]�'?��#?j�ο�GǼ��<�GR�>ɽ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53d5013
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
YJx�a�3�?�f?��ֿ�
+@3
&@�����?<
�?�&*>m<V��AP>c�=�mÁ?qJu�c3V�k�!����?�A�?LkQ?͚F@v�"��A�?��?�J@��=�jg��9���r����>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2494f05
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ��/?7yK>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..acedd02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ�>�?K�I?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/model.onnx
new file mode 100644
index 0000000..bb83648
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a0ab9b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c7a81ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJ<ש/��E?+�R?ur
+@Y�?g���u����?]�'?��#?j�ο�GǼ��<�GR�>ɽ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53d5013
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
YJx�a�3�?�f?��ֿ�
+@3
&@�����?<
�?�&*>m<V��AP>c�=�mÁ?qJu�c3V�k�!����?�A�?LkQ?͚F@v�"��A�?��?�J@��=�jg��9���r����>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2494f05
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ��/?7yK>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..acedd02
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_2_epsilon_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ�>�?K�I?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/model.onnx
new file mode 100644
index 0000000..3cb5d84
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ceb2770
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0acbab4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJxٺ�>*������>ǩ?3�1��9�r�޾���?�,?֞�>8E�<
+?�,��`=��"��*-?u�?ELU�d��>q鋿�᾿���>u�*>l�"?r�@h�q?��i�d��?�o���T�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d74350c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJx��Ľ�����e�>ԙ8@`�y����aܾbh?�]?ں�>t����+�9���Fz�|#����>�eC>o�b>��2>��2�D���l�?;0�vį�tp�?�о�����?��8����>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0106db6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..a76b1d4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJp!c?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..8103e83
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ceb2770
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0acbab4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJxٺ�>*������>ǩ?3�1��9�r�޾���?�,?֞�>8E�<
+?�,��`=��"��*-?u�?ELU�d��>q鋿�᾿���>u�*>l�"?r�@h�q?��i�d��?�o���T�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d74350c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJx��Ľ�����e�>ԙ8@`�y����aܾbh?�]?ں�>t����+�9���Fz�|#����>�eC>o�b>��2>��2�D���l�?;0�vį�tp�?�о�����?��8����>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0106db6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..a76b1d4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJp!c?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/model.onnx
new file mode 100644
index 0000000..8ed0a4c
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ceb2770
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0acbab4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJxٺ�>*������>ǩ?3�1��9�r�޾���?�,?֞�>8E�<
+?�,��`=��"��*-?u�?ELU�d��>q鋿�᾿���>u�*>l�"?r�@h�q?��i�d��?�o���T�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d74350c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJx��Ľ�����e�>ԙ8@`�y����aܾbh?�]?ں�>t����+�9���Fz�|#����>�eC>o�b>��2>��2�D���l�?;0�vį�tp�?�о�����?��8����>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0106db6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..a76b1d4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_3d_axis_negative_3_epsilon_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJp!c?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/model.onnx
new file mode 100644
index 0000000..cd83008
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..177f420
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bda1787
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJ�/#�6g˾��x���6��K�ֿ��?�0�?�8P�˳���d?�f�,\>���1?�1?��9�����ʿ�A?�,����
�	���PW����-OA>�?��=y,���y�=�O�>)r1�V[�?P��>@'�
++Ⱦ���>������
�� @$c���?.*1�
��?���>1�?�ʅ���?�0?梦?Y� �0I��_s@����f6����?$�=t<?��̾�w�>F<���=�?���) .��*?w���Ȫ�=a���1?8g#�����?�;���
;��žh;�=��,��Ⓘ�k|���۽�78�O P�h��>d�8$���䟾vs!�(n@=g4��yq?�G??Y/����E?g����/*��7?�����>W/�)l�?�Ĉ?/"� 0��f�������������v >�?��>�C��	�����?�0���&��l�������r�����?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..252bdd8
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0c4a329
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+




BMeanJ`�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3c75e1e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+




B	InvStdDevJ��t?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/model.onnx
new file mode 100644
index 0000000..236efaa
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..177f420
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bda1787
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJ�/#�6g˾��x���6��K�ֿ��?�0�?�8P�˳���d?�f�,\>���1?�1?��9�����ʿ�A?�,����
�	���PW����-OA>�?��=y,���y�=�O�>)r1�V[�?P��>@'�
++Ⱦ���>������
�� @$c���?.*1�
��?���>1�?�ʅ���?�0?梦?Y� �0I��_s@����f6����?$�=t<?��̾�w�>F<���=�?���) .��*?w���Ȫ�=a���1?8g#�����?�;���
;��žh;�=��,��Ⓘ�k|���۽�78�O P�h��>d�8$���䟾vs!�(n@=g4��yq?�G??Y/����E?g����/*��7?�����>W/�)l�?�Ĉ?/"� 0��f�������������v >�?��>�C��	�����?�0���&��l�������r�����?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..252bdd8
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0c4a329
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+




BMeanJ`�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3c75e1e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+




B	InvStdDevJ��t?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/model.onnx
new file mode 100644
index 0000000..6d5656d
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..177f420
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bda1787
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJ�/#�6g˾��x���6��K�ֿ��?�0�?�8P�˳���d?�f�,\>���1?�1?��9�����ʿ�A?�,����
�	���PW����-OA>�?��=y,���y�=�O�>)r1�V[�?P��>@'�
++Ⱦ���>������
�� @$c���?.*1�
��?���>1�?�ʅ���?�0?梦?Y� �0I��_s@����f6����?$�=t<?��̾�w�>F<���=�?���) .��*?w���Ȫ�=a���1?8g#�����?�;���
;��žh;�=��,��Ⓘ�k|���۽�78�O P�h��>d�8$���䟾vs!�(n@=g4��yq?�G??Y/����E?g����/*��7?�����>W/�)l�?�Ĉ?/"� 0��f�������������v >�?��>�C��	�����?�0���&��l�������r�����?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..252bdd8
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0c4a329
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+




BMeanJ`�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3c75e1e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis0_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+




B	InvStdDevJ��t?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/model.onnx
new file mode 100644
index 0000000..4960ade
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0bafab8
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..12cf194
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2fc4e53
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..cfe5baa
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��=�A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3f98a19
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJm�q?�6y?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/model.onnx
new file mode 100644
index 0000000..90ae87a
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0bafab8
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..12cf194
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2fc4e53
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..cfe5baa
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��=�A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3f98a19
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJm�q?�6y?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/model.onnx
new file mode 100644
index 0000000..3880fb7
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0bafab8
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..12cf194
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2fc4e53
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..cfe5baa
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��=�A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3f98a19
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis1_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJm�q?�6y?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/model.onnx
new file mode 100644
index 0000000..662e6ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6c525c0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJP/Uu>�V���x?L�@��>�E�2xA?�
+���?�wb=�L%�����(���;���-��z�߾�Lҿ��Ͼw	���<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5bd79db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJPM��?��0>C��<Ǯ�=��h>~$��S뽥�>u��n�]?�j�?ۡ!�A!w��`��
+3?"և��c�-�[�o�P=N��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..75e5a26
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2226bc2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ�?~Zd=SHʾ�O�����>XF�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4b0b73a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?�W?�Ց?���?�|�?�'_?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/model.onnx
new file mode 100644
index 0000000..9ba4b14
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6c525c0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJP/Uu>�V���x?L�@��>�E�2xA?�
+���?�wb=�L%�����(���;���-��z�߾�Lҿ��Ͼw	���<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5bd79db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJPM��?��0>C��<Ǯ�=��h>~$��S뽥�>u��n�]?�j�?ۡ!�A!w��`��
+3?"և��c�-�[�o�P=N��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..75e5a26
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2226bc2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ�?~Zd=SHʾ�O�����>XF�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4b0b73a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?�W?�Ց?���?�|�?�'_?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/model.onnx
new file mode 100644
index 0000000..bb2bf35
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6c525c0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJP/Uu>�V���x?L�@��>�E�2xA?�
+���?�wb=�L%�����(���;���-��z�߾�Lҿ��Ͼw	���<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5bd79db
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJPM��?��0>C��<Ǯ�=��h>~$��S뽥�>u��n�]?�j�?ۡ!�A!w��`��
+3?"և��c�-�[�o�P=N��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..75e5a26
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2226bc2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ�?~Zd=SHʾ�O�����>XF�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4b0b73a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis2_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?�W?�Ց?���?�|�?�'_?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/model.onnx
new file mode 100644
index 0000000..43791e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..14c9a9f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ^;��pV�?��?�BR>r�8=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b2f8e3d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJj�@����F焾I��>GT�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..79de966
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1d0d7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..996fa15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+

B	InvStdDevJ`���?���?��
@ ҥ?�?�d?Z��?��?�8C?O��?�E�?�v@g��?a��?�z�?eF@,
+Y?o�q?���?���?]�=?�	Z?0e?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/model.onnx
new file mode 100644
index 0000000..ef2b695
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..14c9a9f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ^;��pV�?��?�BR>r�8=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b2f8e3d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJj�@����F焾I��>GT�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..79de966
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1d0d7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..996fa15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+

B	InvStdDevJ`���?���?��
@ ҥ?�?�d?Z��?��?�8C?O��?�E�?�v@g��?a��?�z�?eF@,
+Y?o�q?���?���?]�=?�	Z?0e?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/model.onnx
new file mode 100644
index 0000000..654fa2c
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..14c9a9f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ^;��pV�?��?�BR>r�8=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b2f8e3d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJj�@����F焾I��>GT�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..79de966
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1d0d7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..996fa15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis3_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+

B	InvStdDevJ`���?���?��
@ ҥ?�?�d?Z��?��?�8C?O��?�E�?�v@g��?a��?�z�?eF@,
+Y?o�q?���?���?]�=?�	Z?0e?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/model.onnx
new file mode 100644
index 0000000..3b71adb
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..60203fb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJ���?�c���ݝ>
+e��U���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..51f7304
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJEW��߀��=�?L�J�S�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9b6c764
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1d0d7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..996fa15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+

B	InvStdDevJ`���?���?��
@ ҥ?�?�d?Z��?��?�8C?O��?�E�?�v@g��?a��?�z�?eF@,
+Y?o�q?���?���?]�=?�	Z?0e?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/model.onnx
new file mode 100644
index 0000000..9d53a51
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..60203fb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJ���?�c���ݝ>
+e��U���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..51f7304
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJEW��߀��=�?L�J�S�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9b6c764
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1d0d7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..996fa15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+

B	InvStdDevJ`���?���?��
@ ҥ?�?�d?Z��?��?�8C?O��?�E�?�v@g��?a��?�z�?eF@,
+Y?o�q?���?���?]�=?�	Z?0e?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/model.onnx
new file mode 100644
index 0000000..4723a7c
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..60203fb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJ���?�c���ݝ>
+e��U���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..51f7304
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJEW��߀��=�?L�J�S�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9b6c764
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1d0d7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..996fa15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_1_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+

B	InvStdDevJ`���?���?��
@ ҥ?�?�d?Z��?��?�8C?O��?�E�?�v@g��?a��?�z�?eF@,
+Y?o�q?���?���?]�=?�	Z?0e?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/model.onnx
new file mode 100644
index 0000000..8352407
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0df3613
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJPɩ?r�v�!Tu=��Y��C��Ec�ѷo?b���֊>�.M���%�a��>@/n?%�3�x
����?�F[��Rſ
&@R�ξ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..05c71f1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJP����.��.�>�B>�
+Z�O�??��ϣ��
�u?��?:GQ�Y_��g�?Z��
����w?Z�b��"��a��>�p�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..beb6c19
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2226bc2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ�?~Zd=SHʾ�O�����>XF�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4b0b73a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?�W?�Ց?���?�|�?�'_?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/model.onnx
new file mode 100644
index 0000000..23c2f37
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0df3613
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJPɩ?r�v�!Tu=��Y��C��Ec�ѷo?b���֊>�.M���%�a��>@/n?%�3�x
����?�F[��Rſ
&@R�ξ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..05c71f1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJP����.��.�>�B>�
+Z�O�??��ϣ��
�u?��?:GQ�Y_��g�?Z��
����w?Z�b��"��a��>�p�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..beb6c19
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2226bc2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ�?~Zd=SHʾ�O�����>XF�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4b0b73a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?�W?�Ց?���?�|�?�'_?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/model.onnx
new file mode 100644
index 0000000..d95796d
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0df3613
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJPɩ?r�v�!Tu=��Y��C��Ec�ѷo?b���֊>�.M���%�a��>@/n?%�3�x
����?�F[��Rſ
&@R�ξ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..05c71f1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
BJP����.��.�>�B>�
+Z�O�??��ϣ��
�u?��?:GQ�Y_��g�?Z��
����w?Z�b��"��a��>�p�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..beb6c19
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2226bc2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+


BMeanJ�?~Zd=SHʾ�O�����>XF�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..4b0b73a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_2_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+


B	InvStdDevJ��?�W?�Ց?���?�|�?�'_?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/model.onnx
new file mode 100644
index 0000000..6c3a2a7
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..467f7cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJ�
�ƾ����V<>�^ž�ͿJc�C�n�%�?hP?�V?*_
���P���
����"�@Z���b?6l��
+�ս��|�������c��?.�D�H?,�)<"T8?>���q�>T�E?A�Կ�y�>z�?�ms��GR?��+?5�r�"=H�ȿ1�A�>9?^��<�P8?,���Fн��<h��?�N[�����<Kk�DaE>�躾9J�t�o����?�п�}��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..50ca1fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ee4368e
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..cfe5baa
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��=�A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3f98a19
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJm�q?�6y?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/model.onnx
new file mode 100644
index 0000000..3242e9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..467f7cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJ�
�ƾ����V<>�^ž�ͿJc�C�n�%�?hP?�V?*_
���P���
����"�@Z���b?6l��
+�ս��|�������c��?.�D�H?,�)<"T8?>���q�>T�E?A�Կ�y�>z�?�ms��GR?��+?5�r�"=H�ȿ1�A�>9?^��<�P8?,���Fн��<h��?�N[�����<Kk�DaE>�躾9J�t�o����?�п�}��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..50ca1fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ee4368e
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..cfe5baa
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��=�A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3f98a19
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJm�q?�6y?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/model.onnx
new file mode 100644
index 0000000..37f6f7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..467f7cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJ�
�ƾ����V<>�^ž�ͿJc�C�n�%�?hP?�V?*_
���P���
����"�@Z���b?6l��
+�ս��|�������c��?.�D�H?,�)<"T8?>���q�>T�E?A�Կ�y�>z�?�ms��GR?��+?5�r�"=H�ȿ1�A�>9?^��<�P8?,���Fн��<h��?�N[�����<Kk�DaE>�躾9J�t�o����?�п�}��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..50ca1fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ee4368e
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..cfe5baa
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+



BMeanJ��=�A>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3f98a19
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_3_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+



B	InvStdDevJm�q?�6y?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/model.onnx
new file mode 100644
index 0000000..8f34b80
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1256426
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c7e2452
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67de1dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0c4a329
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+




BMeanJ`�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3c75e1e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+




B	InvStdDevJ��t?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/model.onnx
new file mode 100644
index 0000000..1e261c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1256426
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c7e2452
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67de1dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0c4a329
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+




BMeanJ`�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3c75e1e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+




B	InvStdDevJ��t?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/model.onnx
new file mode 100644
index 0000000..6e58c5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1256426
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c7e2452
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67de1dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0c4a329
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+




BMeanJ`�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..3c75e1e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_4d_axis_negative_4_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+




B	InvStdDevJ��t?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_default_axis/model.onnx
new file mode 100644
index 0000000..9360997
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_default_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2664d33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJٺ�>*������>ǩ?3�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0c61766
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ�9�r�޾���?�,?֞�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3857c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1d0d7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..996fa15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+

B	InvStdDevJ`���?���?��
@ ҥ?�?�d?Z��?��?�8C?O��?�E�?�v@g��?a��?�z�?eF@,
+Y?o�q?���?���?]�=?�	Z?0e?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/model.onnx
new file mode 100644
index 0000000..9483fbd
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2664d33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJٺ�>*������>ǩ?3�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0c61766
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ�9�r�޾���?�,?֞�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3857c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1d0d7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..996fa15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+

B	InvStdDevJ`���?���?��
@ ҥ?�?�d?Z��?��?�8C?O��?�E�?�v@g��?a��?�z�?eF@,
+Y?o�q?���?���?]�=?�	Z?0e?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/model.onnx
new file mode 100644
index 0000000..b2de835
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2664d33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJٺ�>*������>ǩ?3�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0c61766
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
BJ�9�r�޾���?�,?֞�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3857c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f1d0d7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..996fa15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_layer_normalization_default_axis_expanded_ver18/test_data_set_0/output_2.pb
@@ -0,0 +1,2 @@
+

B	InvStdDevJ`���?���?��
@ ҥ?�?�d?Z��?��?�8C?O��?�E�?�v@g��?a��?�z�?eF@,
+Y?o�q?���?���?]�=?�	Z?0e?��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_leakyrelu/model.onnx b/onnx/backend/test/data/node/test_leakyrelu/model.onnx
new file mode 100644
index 0000000..17482f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5680514
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_default/model.onnx b/onnx/backend/test/data/node/test_leakyrelu_default/model.onnx
new file mode 100644
index 0000000..a88abca
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5fd7f40
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_default_expanded/model.onnx b/onnx/backend/test/data/node/test_leakyrelu_default_expanded/model.onnx
new file mode 100644
index 0000000..3c1dff7
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_default_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5fd7f40
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_default_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_example/model.onnx b/onnx/backend/test/data/node/test_leakyrelu_example/model.onnx
new file mode 100644
index 0000000..eac6ef0
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..976f75b
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_example_expanded/model.onnx b/onnx/backend/test/data/node/test_leakyrelu_example_expanded/model.onnx
new file mode 100644
index 0000000..1e91b8e
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..976f75b
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_expanded/model.onnx b/onnx/backend/test/data/node/test_leakyrelu_expanded/model.onnx
new file mode 100644
index 0000000..1aa763d
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5680514
Binary files /dev/null and b/onnx/backend/test/data/node/test_leakyrelu_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less/model.onnx b/onnx/backend/test/data/node/test_less/model.onnx
new file mode 100644
index 0000000..854b9fd
Binary files /dev/null and b/onnx/backend/test/data/node/test_less/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1424d72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..832abe8
Binary files /dev/null and b/onnx/backend/test/data/node/test_less/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_bcast/model.onnx b/onnx/backend/test/data/node/test_less_bcast/model.onnx
new file mode 100644
index 0000000..db2ab42
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dcbe531
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_bcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..63d7310
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_bcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal/model.onnx b/onnx/backend/test/data/node/test_less_equal/model.onnx
new file mode 100644
index 0000000..e65eedb
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1424d72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_equal/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_equal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6c30026
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_bcast/model.onnx b/onnx/backend/test/data/node/test_less_equal_bcast/model.onnx
new file mode 100644
index 0000000..f64c6d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dcbe531
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..00bd1b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_bcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_bcast_expanded/model.onnx b/onnx/backend/test/data/node/test_less_equal_bcast_expanded/model.onnx
new file mode 100644
index 0000000..7f67a80
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_bcast_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dcbe531
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..00bd1b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_bcast_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_expanded/model.onnx b/onnx/backend/test/data/node/test_less_equal_expanded/model.onnx
new file mode 100644
index 0000000..9e201b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1424d72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6c30026
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int16/model.onnx b/onnx/backend/test/data/node/test_less_equal_int16/model.onnx
new file mode 100644
index 0000000..a940b66
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4d27e19
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..617a4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d22a770
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int16_expanded/model.onnx b/onnx/backend/test/data/node/test_less_equal_int16_expanded/model.onnx
new file mode 100644
index 0000000..d803aa8
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4d27e19
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..617a4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d22a770
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int8/model.onnx b/onnx/backend/test/data/node/test_less_equal_int8/model.onnx
new file mode 100644
index 0000000..f17a292
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2060ad4
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dd426bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ec430e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int8_expanded/model.onnx b/onnx/backend/test/data/node/test_less_equal_int8_expanded/model.onnx
new file mode 100644
index 0000000..9aa2ac7
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int8_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2060ad4
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dd426bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ec430e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_int8_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint16/model.onnx b/onnx/backend/test/data/node/test_less_equal_uint16/model.onnx
new file mode 100644
index 0000000..2df6648
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05499ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8caad5
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b59bd82
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint16_expanded/model.onnx b/onnx/backend/test/data/node/test_less_equal_uint16_expanded/model.onnx
new file mode 100644
index 0000000..032e002
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05499ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8caad5
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b59bd82
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint32/model.onnx b/onnx/backend/test/data/node/test_less_equal_uint32/model.onnx
new file mode 100644
index 0000000..f65b95f
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57ca187
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e078d4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0f59bb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint32_expanded/model.onnx b/onnx/backend/test/data/node/test_less_equal_uint32_expanded/model.onnx
new file mode 100644
index 0000000..aa79841
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint32_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57ca187
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e078d4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0f59bb6
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint32_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint64/model.onnx b/onnx/backend/test/data/node/test_less_equal_uint64/model.onnx
new file mode 100644
index 0000000..4305389
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..028107b
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0884815
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ae414a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint64_expanded/model.onnx b/onnx/backend/test/data/node/test_less_equal_uint64_expanded/model.onnx
new file mode 100644
index 0000000..6f8f53f
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint64_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..028107b
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0884815
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ae414a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint64_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint8/model.onnx b/onnx/backend/test/data/node/test_less_equal_uint8/model.onnx
new file mode 100644
index 0000000..2ef212d
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9af0258
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7d08c07
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8d2039b
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint8_expanded/model.onnx b/onnx/backend/test/data/node/test_less_equal_uint8_expanded/model.onnx
new file mode 100644
index 0000000..bd3d292
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint8_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9af0258
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7d08c07
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8d2039b
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_equal_uint8_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_int16/model.onnx b/onnx/backend/test/data/node/test_less_int16/model.onnx
new file mode 100644
index 0000000..d76e2a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4d27e19
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..617a4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f8f8a6e
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_int8/model.onnx b/onnx/backend/test/data/node/test_less_int8/model.onnx
new file mode 100644
index 0000000..174587b
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2060ad4
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_int8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dd426bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_int8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..68d08f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_int8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint16/model.onnx b/onnx/backend/test/data/node/test_less_uint16/model.onnx
new file mode 100644
index 0000000..648c520
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05499ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8caad5
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1911bb7
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint32/model.onnx b/onnx/backend/test/data/node/test_less_uint32/model.onnx
new file mode 100644
index 0000000..c4ebea0
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57ca187
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e078d4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a58477b
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint64/model.onnx b/onnx/backend/test/data/node/test_less_uint64/model.onnx
new file mode 100644
index 0000000..3219f78
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..028107b
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0884815
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99f8c94
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint8/model.onnx b/onnx/backend/test/data/node/test_less_uint8/model.onnx
new file mode 100644
index 0000000..51202bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_less_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_less_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9af0258
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_less_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7d08c07
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_less_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_less_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fa42d25
Binary files /dev/null and b/onnx/backend/test/data/node/test_less_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step/model.onnx b/onnx/backend/test/data/node/test_linear_attention_decode_step/model.onnx
new file mode 100644
index 0000000..1e27575
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_decode_step/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15ca097
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
 
BqueryJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7310d91
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
 
BkeyJ��x�=�GC��F� �`>�}ܾ���<�.�>K�z=�M?����?>`���]�ξ�y������m�<`��ME�>`�	>�F�-�>�=?Od�>��T����f�>�l/��?6>�=fx�>�>���>��L;?��=��=��?"m;������>�ƕ�&�>�;ӽ1�>�*��>��>
p�>[g>�����5?��˽��>I�>B�k�vi>�M�>׊>,(о���=/"�>ׁ����b���$�/?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..71ca668
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..15a706e
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e6e62c7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
 
BdecayJ��]�� UZ��ȿ���e�B�
�#B��/^��DB��������������%��{��V1>�BCѽRb�Zv�Q��������,$�ձ��	�������o����p���N�����O��l׽�����e��g�ʼn���*��Wʽ�-� ���3�c�Y��М�}�c������v����:�[���w?���%*���7�b�-�/�ºT9��4U���吽�N���u ���8�ϦټK��KL!��s��
���&����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b94d00b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+

BbetaJ ~��>�q5?�4=R(a?$?�,�<��e>$t?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..37d363f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
 
BoutputJ�w�'�F��dD�>V�����������=�7<2��б�=�oB��̴>�0�>���d!������h.���}<���=�'�܇>�z�;��=�V�=
�s>��9>ź=��=}Q��T�>��B>K�򻉃/>�z������q�rs�>�)0�c��>�8>�3�=
+E�=�<T> �==�^��A�$i%=����U��)�}=iSk���2<�)=�E~�p�=F��f�1��@"?��>"ܭ��b�>��F{�>H+F�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bc2ab94
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_decode_step/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/model.onnx
new file mode 100644
index 0000000..5ba80ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15ca097
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
 
BqueryJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7310d91
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
 
BkeyJ��x�=�GC��F� �`>�}ܾ���<�.�>K�z=�M?����?>`���]�ξ�y������m�<`��ME�>`�	>�F�-�>�=?Od�>��T����f�>�l/��?6>�=fx�>�>���>��L;?��=��=��?"m;������>�ƕ�&�>�;ӽ1�>�*��>��>
p�>[g>�����5?��˽��>I�>B�k�vi>�M�>׊>,(о���=/"�>ׁ����b���$�/?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..71ca668
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..15a706e
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e6e62c7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
 
BdecayJ��]�� UZ��ȿ���e�B�
�#B��/^��DB��������������%��{��V1>�BCѽRb�Zv�Q��������,$�ձ��	�������o����p���N�����O��l׽�����e��g�ʼn���*��Wʽ�-� ���3�c�Y��М�}�c������v����:�[���w?���%*���7�b�-�/�ºT9��4U���吽�N���u ���8�ϦټK��KL!��s��
���&����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..b94d00b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+

BbetaJ ~��>�q5?�4=R(a?$?�,�<��e>$t?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..37d363f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
 
BoutputJ�w�'�F��dD�>V�����������=�7<2��б�=�oB��̴>�0�>���d!������h.���}<���=�'�܇>�z�;��=�V�=
�s>��9>ź=��=}Q��T�>��B>K�򻉃/>�z������q�rs�>�)0�c��>�8>�3�=
+E�=�<T> �==�^��A�$i%=����U��)�}=iSk���2<�)=�E~�p�=F��f�1��@"?��>"ܭ��b�>��F{�>H+F�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bc2ab94
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_decode_step_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta/model.onnx b/onnx/backend/test/data/node/test_linear_attention_delta/model.onnx
new file mode 100644
index 0000000..69324c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..7158e6e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
BbetaJ�
~��>�q5?�4=R(a?$?�,�<��e>$t?�?��=9�>��>{��<E��>R��>��y>�?X�@?�~q>�?I�#?��r?=G?(-Y?Q�>�=>��~?�u>�b�>et�=6�q?Rw?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5d53ec2
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..a7fd439
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/model.onnx
new file mode 100644
index 0000000..bf70922
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..7158e6e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
BbetaJ�
~��>�q5?�4=R(a?$?�,�<��e>$t?�?��=9�>��>{��<E��>R��>��y>�?X�@?�~q>�?I�#?��r?=G?(-Y?Q�>�=>��~?�u>�b�>et�=6�q?Rw?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5d53ec2
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..a7fd439
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_delta_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale/model.onnx b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/model.onnx
new file mode 100644
index 0000000..4fc9cc0
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..34edab3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99cd33c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5c0855a
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/model.onnx
new file mode 100644
index 0000000..174f597
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..34edab3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99cd33c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5c0855a
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_explicit_scale_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16/model.onnx b/onnx/backend/test/data/node/test_linear_attention_fp16/model.onnx
new file mode 100644
index 0000000..48c909d
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..914202f
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c9848b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6dc7f94
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b8d49ee
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+ 
+BdecayJ�{�����'���Ӭ
�L�W�ӬѮN��'���W���ɫ#���[�����ǚw����������ڤQ����:�_�񯲥��	��鞱�G�Q�����P���{��ū����4�#����R�#����|�V�N����?���Ჟ�����u�?��V�
��@��㦸��e�[����ɰ���N�֨=�i����������ʢf�e�V�ҜG�ͪ������
������ܰ��ߦY�ޢѯ�Ӛ�K�̪�y�����F���֩����W�T�0�9�֨$���h�אַ�ձ��c�P�
�Z����������m���%�U��1�q���u�������p�����H��&�J�Ư����&��ު.�礣�Щg�Ь5���h�y�9����'���;�p�׬����"��������&�ȥ	��m���֪���ꪰ�Ψw�����񦰮��\��r�_��������z�z�x����.���'�Ų�.�G�i��5���7���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f8218bb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/input_4.pb
@@ -0,0 +1,3 @@
+
+BbetaJ@�)�6b9�:�:2(�3m5
+2l:$:"8�;�02;t/91�9/�8�6�95;):�:8(�4 8�6f3�4�;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1a2b143
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..47689e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/model.onnx
new file mode 100644
index 0000000..d03ebd0
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..914202f
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c9848b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6dc7f94
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b8d49ee
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+ 
+BdecayJ�{�����'���Ӭ
�L�W�ӬѮN��'���W���ɫ#���[�����ǚw����������ڤQ����:�_�񯲥��	��鞱�G�Q�����P���{��ū����4�#����R�#����|�V�N����?���Ჟ�����u�?��V�
��@��㦸��e�[����ɰ���N�֨=�i����������ʢf�e�V�ҜG�ͪ������
������ܰ��ߦY�ޢѯ�Ӛ�K�̪�y�����F���֩����W�T�0�9�֨$���h�אַ�ձ��c�P�
�Z����������m���%�U��1�q���u�������p�����H��&�J�Ư����&��ު.�礣�Щg�Ь5���h�y�9����'���;�p�׬����"��������&�ȥ	��m���֪���ꪰ�Ψw�����񦰮��\��r�_��������z�z�x����.���'�Ų�.�G�i��5���7���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f8218bb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/input_4.pb
@@ -0,0 +1,3 @@
+
+BbetaJ@�)�6b9�:�:2(�3m5
+2l:$:"8�;�02;t/91�9/�8�6�95;):�:8(�4 8�6f3�4�;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1a2b143
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..47689e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_fp16_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated/model.onnx
new file mode 100644
index 0000000..ea61802
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1d5db8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c93b671
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/output_0.pb
@@ -0,0 +1,6 @@
+ 
BoutputJ�E�
@
{?@�f�?Wψ��B�U�˿�4ݾ��)�_d=l">�>H">�F,��>��&�;{�.)�?h3
�Xq�?�$p�M'7�r*��Y??��>8� =a��<dV�<��<�+�s�9>'�=�8i��]9�����}���V�?'Fþ
+#�?Q�=���?���=R{�>ojV?�O�>V�����>w�����7����?��� �?7>��G�N���0�
+X?�I�>�`�=>�s>�E�����?��">Ĺ*�[j׿]�"�
+���I+�?%͸���?�
y=@q@h潕�3?�Ь?k׃>�Y�>I?�ĉ�5C�H@b�^�w!@u�b������9���H�?.�O?"D>�1�T��=���a�>+�Ŀ����@+(�>���?g'�@���~�/@*\�^5?2�����=�s��U����?�{>�X��?-/�<q�b>�#�]���
`e=��ֽ@����j��[��y����?dVR�C�~=Dz$<��>�j���}i?��{@O��=�p���yW��O?Դ}?~>�UV�l�p=#|:����>7&�=4����=�t!>��=�>]�_<@��>J�=�|D>�A>�9�>9��ǻ��u��>?�>w�<)*@�7p�?/7���W�>�ɧ?:�0Yo����D@;B�?���?b���&?�
>?,?޿�e�q�?}8=��]?<���Ƚ>�<�ȱ���`����oz ?�8?"��>�|	���!��dn�/\��KT�>454���=?%J�5U �~
+@�$�@Y�@f�ٿ�<|?PД��w��Ꮿ>+����
+����.? j�?5�-��:���	�><�쾿Na>`ם>�<�d�>E�?�h�?I?�>v�c�q=�?u��?o	�ʄ,��]:@G����NR@9-�0�M���U+�[�@Fd�?;@�^��N�>]@?�� ���ˀ�2�>�h�@eX�~@U8?]ci?@��t��>zɵ?W-����?\h�+�>�>��=EU%>|�¿�"�,]�?b%�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f18f8e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_delta/model.onnx
new file mode 100644
index 0000000..0635a69
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..34edab3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a310fb2
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5c0855a
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/model.onnx
new file mode 100644
index 0000000..1c268f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..0355174
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fc8a44c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..22e1bb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/model.onnx
new file mode 100644
index 0000000..4e2a5c7
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..0355174
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fc8a44c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..22e1bb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_beta_scalar_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/model.onnx
new file mode 100644
index 0000000..9524b36
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..34edab3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a310fb2
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5c0855a
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/model.onnx
new file mode 100644
index 0000000..8592e50
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..050e22d
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9de5791
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_1.pb
@@ -0,0 +1,8 @@
+ 
BkeyJ���Ѿ����O�c]=�>��>���=6%	?�
��G
��R�1�����=����G�>Y4�>M��Fd>����$�=�̡>�<R
+��4��t���
+���ϽCX`����=68�����A?D������2��>�XP�[�>��M��U=���<��>鏤�d{P����>��5���;�;Ͼ�+j��U2?�}�D_�=���TI��lm�=w��=�Z>�[;��s>�Q>��S��<��>2e�>UD(��І�e$���r/���>�O#�l�\�����[�>g�-�k]��܇��u>P���Bsn��*>�x	>J�	�3I*��	]>�In>����\.���m�-���>����
+�=6)����M�]!�>����<=-j��2�:���
+x>���>�GX��%>���=x�>��?t�/�J��>�2�ѽ���F�,�I��b��=�@?c}μ*
+#�����X��Ej>�:�Nd�>�J>�����={ �>h�*?�N��x?nr�>��ƾW�<u�Z�>�漩�N�z|?ba�=��G�2�=��2>6�=w�>��5��6�"�JPϾ�}̾�t
+��gF>
+�+=X���qT�:��I��>�#���=k�2�$%�$�&��{����=2�>�����Z�>^��>��>[���>�3>�N>�`���(���>�ݿ���=r%?�ȷ=��>@�о��������>��G:��[��=NJ�>�����}�����>,%�=;�??;��>�<J�3��>X�=��}���t>����^�fO?snB�����M�^�s1�>�����w-O��X�=��ە"�����Z��md�>;Z>B�>��Y�Z�k)����L~'?g��A\C>xx޾���{����˾=xž��?�A8�~�����F>z�l;΀>+#�k>�=�9�>���V�+>rF"?�T+�>�N�>`��<}s<o��b䐾��*>I'�>{�|<'�>�1�͙��F<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..d490ddd
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..2d052eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..6b388f0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
BbetaJ�
�A5=���>K1,?LT?�IZ?@=Mz>Ν�>CA>ˏM?�xD?,O?�{?�>�Of?I��='>l;2?f�=9�?�(�>E}:?��f?ME?G�Y?��=�ў>l�?���>�l>���>�r?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..20cbc54
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5112d3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/model.onnx
new file mode 100644
index 0000000..eecb912
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..050e22d
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9de5791
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,8 @@
+ 
BkeyJ���Ѿ����O�c]=�>��>���=6%	?�
��G
��R�1�����=����G�>Y4�>M��Fd>����$�=�̡>�<R
+��4��t���
+���ϽCX`����=68�����A?D������2��>�XP�[�>��M��U=���<��>鏤�d{P����>��5���;�;Ͼ�+j��U2?�}�D_�=���TI��lm�=w��=�Z>�[;��s>�Q>��S��<��>2e�>UD(��І�e$���r/���>�O#�l�\�����[�>g�-�k]��܇��u>P���Bsn��*>�x	>J�	�3I*��	]>�In>����\.���m�-���>����
+�=6)����M�]!�>����<=-j��2�:���
+x>���>�GX��%>���=x�>��?t�/�J��>�2�ѽ���F�,�I��b��=�@?c}μ*
+#�����X��Ej>�:�Nd�>�J>�����={ �>h�*?�N��x?nr�>��ƾW�<u�Z�>�漩�N�z|?ba�=��G�2�=��2>6�=w�>��5��6�"�JPϾ�}̾�t
+��gF>
+�+=X���qT�:��I��>�#���=k�2�$%�$�&��{����=2�>�����Z�>^��>��>[���>�3>�N>�`���(���>�ݿ���=r%?�ȷ=��>@�о��������>��G:��[��=NJ�>�����}�����>,%�=;�??;��>�<J�3��>X�=��}���t>����^�fO?snB�����M�^�s1�>�����w-O��X�=��ە"�����Z��md�>;Z>B�>��Y�Z�k)����L~'?g��A\C>xx޾���{����˾=xž��?�A8�~�����F>z�l;΀>+#�k>�=�9�>���V�+>rF"?�T+�>�N�>`��<}s<o��b䐾��*>I'�>{�|<'�>�1�͙��F<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..d490ddd
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..2d052eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..6b388f0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
BbetaJ�
�A5=���>K1,?LT?�IZ?@=Mz>Ν�>CA>ˏM?�xD?,O?�{?�>�Of?I��='>l;2?f�=9�?�(�>E}:?��f?ME?G�Y?��=�ў>l�?���>�l>���>�r?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..20cbc54
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5112d3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_gqa_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/model.onnx
new file mode 100644
index 0000000..1059408
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..050e22d
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0bc3993
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_1.pb
@@ -0,0 +1,3 @@
+
BkeyJ���Ѿ����O�c]=�>��>���=6%	?�
��G
��R�1�����=����G�>Y4�>M��Fd>����$�=�̡>�<R
+��4��t���
+���ϽCX`����=68�����A?D������2��>�XP�[�>��M��U=���<��>鏤�d{P����>��5���;�;Ͼ�+j��U2?�}�D_�=���TI��lm�=w��=�Z>�[;��s>�Q>��S��<��>2e�>UD(�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3f8c5ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..640b51e
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..660bc6f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+

BbetaJ 
F(?{o?kM�>��f?8�
?4�S?0�9?4�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4214f25
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..493c38b
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/model.onnx
new file mode 100644
index 0000000..c5a00d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..050e22d
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0bc3993
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,3 @@
+
BkeyJ���Ѿ����O�c]=�>��>���=6%	?�
��G
��R�1�����=����G�>Y4�>M��Fd>����$�=�̡>�<R
+��4��t���
+���ϽCX`����=68�����A?D������2��>�XP�[�>��M��U=���<��>鏤�d{P����>��5���;�;Ͼ�+j��U2?�}�D_�=���TI��lm�=w��=�Z>�[;��s>�Q>��S��<��>2e�>UD(�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3f8c5ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..640b51e
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..660bc6f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+

BbetaJ 
F(?{o?kM�>��f?8�
?4�S?0�9?4�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4214f25
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..493c38b
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_delta_mqa_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/model.onnx
new file mode 100644
index 0000000..6673fd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1d5db8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c93b671
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,6 @@
+ 
BoutputJ�E�
@
{?@�f�?Wψ��B�U�˿�4ݾ��)�_d=l">�>H">�F,��>��&�;{�.)�?h3
�Xq�?�$p�M'7�r*��Y??��>8� =a��<dV�<��<�+�s�9>'�=�8i��]9�����}���V�?'Fþ
+#�?Q�=���?���=R{�>ojV?�O�>V�����>w�����7����?��� �?7>��G�N���0�
+X?�I�>�`�=>�s>�E�����?��">Ĺ*�[j׿]�"�
+���I+�?%͸���?�
y=@q@h潕�3?�Ь?k׃>�Y�>I?�ĉ�5C�H@b�^�w!@u�b������9���H�?.�O?"D>�1�T��=���a�>+�Ŀ����@+(�>���?g'�@���~�/@*\�^5?2�����=�s��U����?�{>�X��?-/�<q�b>�#�]���
`e=��ֽ@����j��[��y����?dVR�C�~=Dz$<��>�j���}i?��{@O��=�p���yW��O?Դ}?~>�UV�l�p=#|:����>7&�=4����=�t!>��=�>]�_<@��>J�=�|D>�A>�9�>9��ǻ��u��>?�>w�<)*@�7p�?/7���W�>�ɧ?:�0Yo����D@;B�?���?b���&?�
>?,?޿�e�q�?}8=��]?<���Ƚ>�<�ȱ���`����oz ?�8?"��>�|	���!��dn�/\��KT�>454���=?%J�5U �~
+@�$�@Y�@f�ٿ�<|?PД��w��Ꮿ>+����
+����.? j�?5�-��:���	�><�쾿Na>`ם>�<�d�>E�?�h�?I?�>v�c�q=�?u��?o	�ʄ,��]:@G����NR@9-�0�M���U+�[�@Fd�?;@�^��N�>]@?�� ���ˀ�2�>�h�@eX�~@U8?]ci?@��t��>zɵ?W-����?\h�+�>�>��=EU%>|�¿�"�,]�?b%�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..f18f8e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/model.onnx
new file mode 100644
index 0000000..a516f11
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1d5db8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..d8431bf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
BdecayJ�
�e=�
r���eL�i��<��j睼І��n7��������('�7�ۻ�����U�8�z��^	�kVC�E8s�j�X��-��=�����C6������ɷ��e��꯽v���g���ܽ-�-����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a2889b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..16ab2ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/model.onnx
new file mode 100644
index 0000000..704d3e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1d5db8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..d8431bf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+
BdecayJ�
�e=�
r���eL�i��<��j睼І��n7��������('�7�ۻ�����U�8�z��^	�kVC�E8s�j�X��-��=�����C6������ɷ��e��꯽v���g���ܽ-�-����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a2889b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..16ab2ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_gated_per_head_decay_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear/model.onnx b/onnx/backend/test/data/node/test_linear_attention_linear/model.onnx
new file mode 100644
index 0000000..9eafd84
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1d5db8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be9f6bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..8757946
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/model.onnx
new file mode 100644
index 0000000..8be9acf
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1d5db8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be9f6bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..8757946
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/model.onnx b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/model.onnx
new file mode 100644
index 0000000..f37804a
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15ca097
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
 
BqueryJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b9dcf6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
 
BkeyJ�3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?ٺ�>*������>ǩ?3�1��9�r�޾���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..71ca668
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c67f6ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..24c9b05
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/model.onnx
new file mode 100644
index 0000000..2b9623f
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..15ca097
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
 
BqueryJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b9dcf6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
 
BkeyJ�3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?ٺ�>*������>ǩ?3�1��9�r�޾���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..71ca668
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c67f6ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..24c9b05
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_linear_t1_no_past_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/model.onnx b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/model.onnx
new file mode 100644
index 0000000..11cb04f
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8b20fe1
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..34edab3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a310fb2
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5c0855a
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/model.onnx
new file mode 100644
index 0000000..2d15a0e
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8b20fe1
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..960f4a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..34edab3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a310fb2
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5c0855a
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_no_past_explicit_zeros_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/model.onnx b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/model.onnx
new file mode 100644
index 0000000..c56e249
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..e64c6be
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..db77826
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..fb50ad3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0924ca8
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..d4571a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/model.onnx b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/model.onnx
new file mode 100644
index 0000000..5677fc7
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d0772c
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f72c916
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1aeb0ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..e64c6be
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..db77826
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..fb50ad3
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0924ca8
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..d4571a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_linear_attention_prefill_with_past_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_log/model.onnx b/onnx/backend/test/data/node/test_log/model.onnx
new file mode 100644
index 0000000..2bcb9fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_log/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_log/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_log/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3b05f3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_log/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_log/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_log/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8e2c13d
Binary files /dev/null and b/onnx/backend/test/data/node/test_log/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_log_example/model.onnx b/onnx/backend/test/data/node/test_log_example/model.onnx
new file mode 100644
index 0000000..4fd4a42
Binary files /dev/null and b/onnx/backend/test/data/node/test_log_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_log_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_log_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e410a48
Binary files /dev/null and b/onnx/backend/test/data/node/test_log_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_log_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_log_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6c1287
Binary files /dev/null and b/onnx/backend/test/data/node/test_log_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_0/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_axis_0/model.onnx
new file mode 100644
index 0000000..124c641
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..daae9e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/model.onnx
new file mode 100644
index 0000000..e940d8a
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..daae9e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/model.onnx
new file mode 100644
index 0000000..db7a243
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..daae9e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_1/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_axis_1/model.onnx
new file mode 100644
index 0000000..8d5a2d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8fceb2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/model.onnx
new file mode 100644
index 0000000..b9d0068
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8fceb2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/model.onnx
new file mode 100644
index 0000000..f469e52
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8fceb2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_2/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_axis_2/model.onnx
new file mode 100644
index 0000000..4d11561
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9f080d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/model.onnx
new file mode 100644
index 0000000..2f1911e
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9f080d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/model.onnx
new file mode 100644
index 0000000..cd1753b
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9f080d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_default_axis/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_default_axis/model.onnx
new file mode 100644
index 0000000..3057d6c
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_default_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9f080d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_default_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/model.onnx
new file mode 100644
index 0000000..0c8af90
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9f080d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/model.onnx
new file mode 100644
index 0000000..8b305ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9f080d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_example_1/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_example_1/model.onnx
new file mode 100644
index 0000000..f7f15e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_example_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a00f719
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..54f7680
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_example_1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ8�o,����о
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/model.onnx
new file mode 100644
index 0000000..5896f1f
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a00f719
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..54f7680
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ8�o,����о
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/model.onnx
new file mode 100644
index 0000000..61fec3d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a00f719
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..54f7680
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_example_1_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ8�o,����о
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_large_number/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_large_number/model.onnx
new file mode 100644
index 0000000..7a6fa86
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_large_number/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..559a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..91747ed
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_large_number/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ ,\�,�"X���`�,\�,�"X���`�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/model.onnx
new file mode 100644
index 0000000..42770d1
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..559a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..91747ed
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ ,\�,�"X���`�,\�,�"X���`�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/model.onnx
new file mode 100644
index 0000000..6105b56
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..559a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..91747ed
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_large_number_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ ,\�,�"X���`�,\�,�"X���`�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_negative_axis/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_negative_axis/model.onnx
new file mode 100644
index 0000000..7011339
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_negative_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9f080d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_negative_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/model.onnx
new file mode 100644
index 0000000..a9c304c
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9f080d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/model.onnx
new file mode 100644
index 0000000..8e02fa8
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9f080d
Binary files /dev/null and b/onnx/backend/test/data/node/test_logsoftmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_loop11/model.onnx b/onnx/backend/test/data/node/test_loop11/model.onnx
new file mode 100644
index 0000000..073ba40
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop11/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_loop11/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_loop11/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d5d9bc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop11/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_loop11/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_loop11/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a61228b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_loop11/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+	BcondJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_loop11/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_loop11/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cd343fd
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop11/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_loop11/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_loop11/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..00e8d52
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop11/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_loop11/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_loop11/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ad9be2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop11/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_loop13_seq/model.onnx b/onnx/backend/test/data/node/test_loop13_seq/model.onnx
new file mode 100644
index 0000000..a4a7379
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop13_seq/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d5d9bc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a61228b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+	BcondJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..943fd7c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
+	seq_empty

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c750696
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop13_seq/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_loop16_seq_none/model.onnx b/onnx/backend/test/data/node/test_loop16_seq_none/model.onnx
new file mode 100644
index 0000000..7f379ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop16_seq_none/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d5d9bc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a61228b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+	BcondJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..56d0daf
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..326e70c
Binary files /dev/null and b/onnx/backend/test/data/node/test_loop16_seq_none/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lpnormalization_default/model.onnx b/onnx/backend/test/data/node/test_lpnormalization_default/model.onnx
new file mode 100644
index 0000000..d558215
Binary files /dev/null and b/onnx/backend/test/data/node/test_lpnormalization_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lpnormalization_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lpnormalization_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bf0307c
Binary files /dev/null and b/onnx/backend/test/data/node/test_lpnormalization_default/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lpnormalization_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lpnormalization_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f4b5239
Binary files /dev/null and b/onnx/backend/test/data/node/test_lpnormalization_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_1d_default/model.onnx b/onnx/backend/test/data/node/test_lppool_1d_default/model.onnx
new file mode 100644
index 0000000..d3d882a
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_1d_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..04d0812
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
 
B
xJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..359aee1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lppool_1d_default/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+

B
yJ����?��?aK@��&@���?�q�?̌s?;�)>vU�>�5�>5�?;��?8C?���>���>�?3h�?B�>7.^?�g%@�L$@%sy?TK�?�@i@')�?�@>�P�?k/�?�&�?���>|w@���?U]�>���? /�?˙�?���>GG�?Dv�?/�?X@�,�?�?���?�;�?�
�?���?qBf?�>k?�z?]�?"�?�S�>P��>�i�>(?��+?�4?I�4?��U?�h�?}t�>���?�>�?rr?mHh?p�:?��:?��? ��?
ܟ?�p:?�h~?��r?��?hӟ>%�?�E�?w�p?�r�?��?Cd
+@�^@��?�E�?6`�?tp�?|R�?
��?E�z?2
~?,O<?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lppool_2d_default/model.onnx b/onnx/backend/test/data/node/test_lppool_2d_default/model.onnx
new file mode 100644
index 0000000..0cd55f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a006992
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_dilations/model.onnx b/onnx/backend/test/data/node/test_lppool_2d_dilations/model.onnx
new file mode 100644
index 0000000..7970480
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_dilations/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7ef45fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b74d6d7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lppool_2d_dilations/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


B
yJ��hA��A�A��A
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lppool_2d_pads/model.onnx b/onnx/backend/test/data/node/test_lppool_2d_pads/model.onnx
new file mode 100644
index 0000000..4d01b66
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_pads/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5309700
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5591970
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_pads/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_same_lower/model.onnx b/onnx/backend/test/data/node/test_lppool_2d_same_lower/model.onnx
new file mode 100644
index 0000000..00afca8
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_same_lower/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..918b0f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_same_lower/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_same_upper/model.onnx b/onnx/backend/test/data/node/test_lppool_2d_same_upper/model.onnx
new file mode 100644
index 0000000..108b05a
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_same_upper/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..06942d1
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_same_upper/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_strides/model.onnx b/onnx/backend/test/data/node/test_lppool_2d_strides/model.onnx
new file mode 100644
index 0000000..0ddc7b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_strides/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60232ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_2d_strides/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_3d_default/model.onnx b/onnx/backend/test/data/node/test_lppool_3d_default/model.onnx
new file mode 100644
index 0000000..becb512
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_3d_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1f024e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..87be646
Binary files /dev/null and b/onnx/backend/test/data/node/test_lppool_3d_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lrn/model.onnx b/onnx/backend/test/data/node/test_lrn/model.onnx
new file mode 100644
index 0000000..f0fe213
Binary files /dev/null and b/onnx/backend/test/data/node/test_lrn/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lrn/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lrn/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..93a434a
Binary files /dev/null and b/onnx/backend/test/data/node/test_lrn/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lrn/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lrn/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9ff5b99
Binary files /dev/null and b/onnx/backend/test/data/node/test_lrn/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lrn_default/model.onnx b/onnx/backend/test/data/node/test_lrn_default/model.onnx
new file mode 100644
index 0000000..29c474a
Binary files /dev/null and b/onnx/backend/test/data/node/test_lrn_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lrn_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lrn_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..93a434a
Binary files /dev/null and b/onnx/backend/test/data/node/test_lrn_default/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lrn_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lrn_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99db039
Binary files /dev/null and b/onnx/backend/test/data/node/test_lrn_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_batchwise/model.onnx b/onnx/backend/test/data/node/test_lstm_batchwise/model.onnx
new file mode 100644
index 0000000..2928430
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_batchwise/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a4c92c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e430e38
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJ�
���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..8492882
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJ����>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..79d5f93
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


B
YJT�٪>�٪>�٪>�٪>�٪>�٪>�٪>)U?)U?)U?)U?)U?)U?)U?��7?��7?��7?��7?��7?��7?��7?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..8953f7c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_batchwise/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BY_hJT�٪>�٪>�٪>�٪>�٪>�٪>�٪>)U?)U?)U?)U?)U?)U?)U?��7?��7?��7?��7?��7?��7?��7?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_defaults/model.onnx b/onnx/backend/test/data/node/test_lstm_defaults/model.onnx
new file mode 100644
index 0000000..a7bcc59
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_defaults/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..17423bc
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9487638
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJ`���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a5e32c2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJ�
���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a7809ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_defaults/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BY_hJ$�
�=�
�=�
�=��>��>��>.u�>.u�>.u�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_with_initial_bias/model.onnx b/onnx/backend/test/data/node/test_lstm_with_initial_bias/model.onnx
new file mode 100644
index 0000000..caba9ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_with_initial_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cb9bf0
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..35cc03f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJ�
���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ac89f6c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJ����=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8be234c
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f4b2bd9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_with_initial_bias/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BY_hJ0��>��>��>��>�f	?�f	?�f	?�f	?|�*?|�*?|�*?|�*?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/model.onnx b/onnx/backend/test/data/node/test_lstm_with_peepholes/model.onnx
new file mode 100644
index 0000000..21a9053
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_with_peepholes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..344fd4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..463c96f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJ�
���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a5e32c2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJ�
���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..4b58855
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..bcc1b19
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..174d35f
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..9f828dd
Binary files /dev/null and b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_6.pb differ
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..78aa76a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+
	
B
PJ$���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..93f1a6c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_lstm_with_peepholes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BY_hJ	�>	�>	�>.?.?.?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_1d_1d/model.onnx b/onnx/backend/test/data/node/test_matmul_1d_1d/model.onnx
new file mode 100644
index 0000000..c243d97
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmul_1d_1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9575f18
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJmj�>�LI?|��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..844eaec
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJ;�q�	�Ѿen��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..44f65f0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_1d_1d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
cJ	5�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_1d_3d/model.onnx b/onnx/backend/test/data/node/test_matmul_1d_3d/model.onnx
new file mode 100644
index 0000000..47c1f6c
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmul_1d_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6567650
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ@Y[?��&�b���|.?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..011b736
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
bJ A�M�V�0��;�t0�<�>��g���-�$�=L�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..25ac600
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_1d_3d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
cJWky>���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_2d/model.onnx b/onnx/backend/test/data/node/test_matmul_2d/model.onnx
new file mode 100644
index 0000000..e3e63c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmul_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8478b72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f062118
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJ0^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a3e5cad
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_2d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
cJ$�O@~��?�]���?|6�wS��]�?��?��ɿ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_3d/model.onnx b/onnx/backend/test/data/node/test_matmul_3d/model.onnx
new file mode 100644
index 0000000..19ad0bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmul_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1469c69
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
aJ`�C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c35dcb6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJ`4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3d246c8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_3d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
cJH���[��>�Wz�6������N�_89?)�s?pC@Zb��� ��啿fB�@�A?�CN@4�K@���=c��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_4d/model.onnx b/onnx/backend/test/data/node/test_matmul_4d/model.onnx
new file mode 100644
index 0000000..621812c
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmul_4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..575a605
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
aJ`�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3e4b0b6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
bJ`G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..aaaba27
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_4d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
cJH��B��>آ�?Ệ>�>��>~?�N���3?��B�mT�@���?5>�@կ��D=�3�B?�H�?@�?>�O@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_4d_1d/model.onnx b/onnx/backend/test/data/node/test_matmul_4d_1d/model.onnx
new file mode 100644
index 0000000..181e4c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmul_4d_1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4aa33fd
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..beabf30
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
bJGR�>ɽ|
i?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3498bd4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_4d_1d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
cJ �D,���?:پg��[�@�E>~S?����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_bcast/model.onnx b/onnx/backend/test/data/node/test_matmul_bcast/model.onnx
new file mode 100644
index 0000000..457c827
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmul_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7f59902
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
aJ�
ٺ�>*������>ǩ?3�1��9�r�޾���?�,?֞�>8E�<
+?�,��`=��"��*-?u�?ELU�d��>q鋿�᾿���>u�*>l�"?r�@h�q?��i�d��?�o���T�A‹��N�?A�>�z�S�z�ɽ��)�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..490433c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
bJ@�5�?2;��A����)�������?>
s?N�=ۜ�,(X?���ſ\�?MF�>g�k?E0�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5424f4a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmul_bcast/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
B
cJ�
�2@�3D?�I�?�+
>㷗?R����
@�#"@��@/��=G#ӿS"	�
+�&>��X���6>�
+տ���?qy)?G���d����?l�
+@�b׿�qG@HҔ��05?�?*{��k?U�z�δ?�d@o
>Ls�?�n�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmulinteger/model.onnx b/onnx/backend/test/data/node/test_matmulinteger/model.onnx
new file mode 100644
index 0000000..0fa773a
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmulinteger/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..abf965a
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..997a12d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
BJ

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7910a57
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
Ba_zero_pointJ

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b163ba9
Binary files /dev/null and b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad39e94
--- /dev/null
+++ b/onnx/backend/test/data/node/test_matmulinteger/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
YJ ��������������������������������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_max_example/model.onnx b/onnx/backend/test/data/node/test_max_example/model.onnx
new file mode 100644
index 0000000..5516105
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6b1c568
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e411be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_max_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f1bf1d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_example/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_max_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2057c5b
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_float16/model.onnx b/onnx/backend/test/data/node/test_max_float16/model.onnx
new file mode 100644
index 0000000..c3b4ceb
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..560f20f
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0ebf1b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cf0575b
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_float32/model.onnx b/onnx/backend/test/data/node/test_max_float32/model.onnx
new file mode 100644
index 0000000..4cdfdd6
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6b1c568
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e411be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..928c1df
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_float64/model.onnx b/onnx/backend/test/data/node/test_max_float64/model.onnx
new file mode 100644
index 0000000..b6c0446
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fffda54
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3bc1918
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_float64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_float64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c7e7d31
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_float64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int16/model.onnx b/onnx/backend/test/data/node/test_max_int16/model.onnx
new file mode 100644
index 0000000..54b883b
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f4d1329
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d800761
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8bc9745
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int32/model.onnx b/onnx/backend/test/data/node/test_max_int32/model.onnx
new file mode 100644
index 0000000..2a927c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..136f93f
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0c6f07
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f17e085
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int64/model.onnx b/onnx/backend/test/data/node/test_max_int64/model.onnx
new file mode 100644
index 0000000..08ade0a
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..09588d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c5db1a4
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_int64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3a11a5b
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_int8/model.onnx b/onnx/backend/test/data/node/test_max_int8/model.onnx
new file mode 100644
index 0000000..c849b43
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..33768d3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+Bdata_0J

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..26608b1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_max_int8/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+Bdata_1J

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_max_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cc7d499
--- /dev/null
+++ b/onnx/backend/test/data/node/test_max_int8/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BresultJ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_max_one_input/model.onnx b/onnx/backend/test/data/node/test_max_one_input/model.onnx
new file mode 100644
index 0000000..de85af1
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_one_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_one_input/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_one_input/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6b1c568
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_one_input/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_one_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_one_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0e49b0c
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_one_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_two_inputs/model.onnx b/onnx/backend/test/data/node/test_max_two_inputs/model.onnx
new file mode 100644
index 0000000..d3f4baf
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_two_inputs/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6b1c568
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e411be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..928c1df
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_two_inputs/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint16/model.onnx b/onnx/backend/test/data/node/test_max_uint16/model.onnx
new file mode 100644
index 0000000..6c6052e
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e0f4892
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..04f20f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..59382f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint32/model.onnx b/onnx/backend/test/data/node/test_max_uint32/model.onnx
new file mode 100644
index 0000000..cc347a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3320c87
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d4f4b39
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6901d13
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint64/model.onnx b/onnx/backend/test/data/node/test_max_uint64/model.onnx
new file mode 100644
index 0000000..bccb107
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7925e46
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5c4afcc
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ec8bba3
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_max_uint8/model.onnx b/onnx/backend/test/data/node/test_max_uint8/model.onnx
new file mode 100644
index 0000000..6587f09
Binary files /dev/null and b/onnx/backend/test/data/node/test_max_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3cae306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+Bdata_0J

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3fd882d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_max_uint8/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+Bdata_1J

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_max_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_max_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c3de218
--- /dev/null
+++ b/onnx/backend/test/data/node/test_max_uint8/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BresultJ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_maxpool_1d_default/model.onnx b/onnx/backend/test/data/node/test_maxpool_1d_default/model.onnx
new file mode 100644
index 0000000..dba3be8
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_1d_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..04d0812
--- /dev/null
+++ b/onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
 
B
xJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0d8a86d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_maxpool_1d_default/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ�x��?��z?�j@�j@$�?�8s?�8s?hdӽ�9�>�9�>�%�?�%�?^�B?B�>B�>�=�?�=�?iJ�>iJ�>�Z��S'?�K]?�K]?�C@�C@Hm;=Hm;=2�?2�?��?���>�Ec��!��� >*z�?*z�?��?mǚ�mǚ��6��&õ���?��?FK�FKྜ	G?�	G?��Y���Y��>�> ��k��QN�>QN�>�ݚ>�ݚ>6���6���Z��Z��[*P�3�5>;�;���>���>��T=��:?��:?�ב?�ב?���>���>�O/�~/�Ѓ���
f=�
f=��f?��f?Ok�>�?��?��?@�?7>8�F��?F��?y�?y�?z?z?��4?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_ceil/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_ceil/model.onnx
new file mode 100644
index 0000000..4bb1e32
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_ceil/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7ef45fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2489db8
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_ceil/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/model.onnx
new file mode 100644
index 0000000..c0b1842
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dc6642
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3a795c3
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_ceil_output_size_reduce_by_one/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_default/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_default/model.onnx
new file mode 100644
index 0000000..64c4aff
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c1caa66
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_dilations/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_dilations/model.onnx
new file mode 100644
index 0000000..3c304ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_dilations/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7ef45fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2489db8
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_dilations/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_pads/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_pads/model.onnx
new file mode 100644
index 0000000..98cbdbe
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_pads/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5309700
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6e472f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_pads/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/model.onnx
new file mode 100644
index 0000000..331007d
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb22a53
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fd51891
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_pads/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/model.onnx
new file mode 100644
index 0000000..94ab659
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb22a53
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a505780
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_same_upper/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/model.onnx
new file mode 100644
index 0000000..3175fab
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb22a53
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5570ba5
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_precomputed_strides/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_same_lower/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_same_lower/model.onnx
new file mode 100644
index 0000000..d972e13
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_same_lower/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..de74b27
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_same_lower/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_same_upper/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_same_upper/model.onnx
new file mode 100644
index 0000000..0a4514b
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_same_upper/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..facc6e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_same_upper/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_strides/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_strides/model.onnx
new file mode 100644
index 0000000..ad67b18
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_strides/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3530a84
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..58204a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_strides/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_uint8/model.onnx b/onnx/backend/test/data/node/test_maxpool_2d_uint8/model.onnx
new file mode 100644
index 0000000..8f4fe78
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_2d_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..24dc63e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
xJ
	
+

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1879dc2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_maxpool_2d_uint8/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_default/model.onnx b/onnx/backend/test/data/node/test_maxpool_3d_default/model.onnx
new file mode 100644
index 0000000..c4e27bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1f024e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..991fc51
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_dilations/model.onnx b/onnx/backend/test/data/node/test_maxpool_3d_dilations/model.onnx
new file mode 100644
index 0000000..f9e9844
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_dilations/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_dilations/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_3d_dilations/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fdfbdb2
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_dilations/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_dilations/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_3d_dilations/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0e66003
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_dilations/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/model.onnx b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/model.onnx
new file mode 100644
index 0000000..381c495
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fdfbdb2
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0e66003
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/model.onnx b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/model.onnx
new file mode 100644
index 0000000..9509ad6
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..61d8539
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1eff243
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_3d_dilations_use_ref_impl_large/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/model.onnx b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/model.onnx
new file mode 100644
index 0000000..3abdc84
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb22a53
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fd51891
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..07a2b6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_pads/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/model.onnx b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/model.onnx
new file mode 100644
index 0000000..a67af2f
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb22a53
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5570ba5
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..e0fe852
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxpool_with_argmax_2d_precomputed_strides/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/model.onnx b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/model.onnx
new file mode 100644
index 0000000..04673fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2be0ec8
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e44498d
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a0a2f9d
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5d2d8b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxunpool_export_with_output_shape/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/model.onnx b/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/model.onnx
new file mode 100644
index 0000000..38cc84c
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6298c08
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e44498d
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..846f124
Binary files /dev/null and b/onnx/backend/test/data/node/test_maxunpool_export_without_output_shape/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mean_example/model.onnx b/onnx/backend/test/data/node/test_mean_example/model.onnx
new file mode 100644
index 0000000..66a0556
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..20406f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e6c4d11
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..81b0033
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_example/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_mean_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mean_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..23324b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mean_one_input/model.onnx b/onnx/backend/test/data/node/test_mean_one_input/model.onnx
new file mode 100644
index 0000000..47b3c34
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_one_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..20406f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bf4d7ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_one_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mean_two_inputs/model.onnx b/onnx/backend/test/data/node/test_mean_two_inputs/model.onnx
new file mode 100644
index 0000000..47add50
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_two_inputs/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..20406f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e6c4d11
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7ad6136
Binary files /dev/null and b/onnx/backend/test/data/node/test_mean_two_inputs/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_melweightmatrix/model.onnx b/onnx/backend/test/data/node/test_melweightmatrix/model.onnx
new file mode 100644
index 0000000..603acc1
Binary files /dev/null and b/onnx/backend/test/data/node/test_melweightmatrix/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8cbbb5e
Binary files /dev/null and b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..66c2dbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..d28ab55
Binary files /dev/null and b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..60d0edd
Binary files /dev/null and b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..078e7de
Binary files /dev/null and b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d9ff529
Binary files /dev/null and b/onnx/backend/test/data/node/test_melweightmatrix/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_example/model.onnx b/onnx/backend/test/data/node/test_min_example/model.onnx
new file mode 100644
index 0000000..b57f694
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6b1c568
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e411be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_min_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..da03dc8
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_example/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_min_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fe406ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_float16/model.onnx b/onnx/backend/test/data/node/test_min_float16/model.onnx
new file mode 100644
index 0000000..8948912
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..560f20f
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0ebf1b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f0e5424
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_float32/model.onnx b/onnx/backend/test/data/node/test_min_float32/model.onnx
new file mode 100644
index 0000000..30f0b00
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6b1c568
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e411be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3df9a38
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_float64/model.onnx b/onnx/backend/test/data/node/test_min_float64/model.onnx
new file mode 100644
index 0000000..858355b
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fffda54
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3bc1918
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_float64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_float64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..98fc197
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_float64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int16/model.onnx b/onnx/backend/test/data/node/test_min_int16/model.onnx
new file mode 100644
index 0000000..3c8a56d
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f4d1329
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d800761
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f0d23fb
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int32/model.onnx b/onnx/backend/test/data/node/test_min_int32/model.onnx
new file mode 100644
index 0000000..6653cf4
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..136f93f
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d0c6f07
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e9ae1d8
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int64/model.onnx b/onnx/backend/test/data/node/test_min_int64/model.onnx
new file mode 100644
index 0000000..65f1e7d
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..09588d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c5db1a4
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_int64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..875ced6
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_int8/model.onnx b/onnx/backend/test/data/node/test_min_int8/model.onnx
new file mode 100644
index 0000000..a64fbf5
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..33768d3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+Bdata_0J

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..26608b1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_min_int8/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+Bdata_1J

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_min_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..56666ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_min_int8/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BresultJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_min_one_input/model.onnx b/onnx/backend/test/data/node/test_min_one_input/model.onnx
new file mode 100644
index 0000000..dacef48
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_one_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_one_input/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_one_input/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6b1c568
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_one_input/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_one_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_one_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0e49b0c
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_one_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_two_inputs/model.onnx b/onnx/backend/test/data/node/test_min_two_inputs/model.onnx
new file mode 100644
index 0000000..7841beb
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_two_inputs/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6b1c568
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e411be9
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3df9a38
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_two_inputs/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint16/model.onnx b/onnx/backend/test/data/node/test_min_uint16/model.onnx
new file mode 100644
index 0000000..2841433
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e0f4892
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..04f20f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..df02e20
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint32/model.onnx b/onnx/backend/test/data/node/test_min_uint32/model.onnx
new file mode 100644
index 0000000..c3da701
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3320c87
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d4f4b39
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..65fd206
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint64/model.onnx b/onnx/backend/test/data/node/test_min_uint64/model.onnx
new file mode 100644
index 0000000..7b26da8
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7925e46
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5c4afcc
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dd29962
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_min_uint8/model.onnx b/onnx/backend/test/data/node/test_min_uint8/model.onnx
new file mode 100644
index 0000000..2625d61
Binary files /dev/null and b/onnx/backend/test/data/node/test_min_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3cae306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+Bdata_0J

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3fd882d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_min_uint8/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+Bdata_1J

\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_min_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_min_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..df3ec96
--- /dev/null
+++ b/onnx/backend/test/data/node/test_min_uint8/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BresultJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mish/model.onnx b/onnx/backend/test/data/node/test_mish/model.onnx
new file mode 100644
index 0000000..9b8fb3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_mish/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mish/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mish/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4d68c76
Binary files /dev/null and b/onnx/backend/test/data/node/test_mish/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mish/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mish/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8fb7e71
Binary files /dev/null and b/onnx/backend/test/data/node/test_mish/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mish_expanded/model.onnx b/onnx/backend/test/data/node/test_mish_expanded/model.onnx
new file mode 100644
index 0000000..465033d
Binary files /dev/null and b/onnx/backend/test/data/node/test_mish_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4d68c76
Binary files /dev/null and b/onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8fb7e71
Binary files /dev/null and b/onnx/backend/test/data/node/test_mish_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_broadcast/model.onnx b/onnx/backend/test/data/node/test_mod_broadcast/model.onnx
new file mode 100644
index 0000000..dc11625
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_broadcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..63db997
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e299f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4a2cb52
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_broadcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_int64_fmod/model.onnx b/onnx/backend/test/data/node/test_mod_int64_fmod/model.onnx
new file mode 100644
index 0000000..7165d70
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_int64_fmod/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7c7887f
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..eb8b6e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6299985
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_int64_fmod/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float16/model.onnx b/onnx/backend/test/data/node/test_mod_mixed_sign_float16/model.onnx
new file mode 100644
index 0000000..f9095ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..00344a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0a417c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bf93e49
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float32/model.onnx b/onnx/backend/test/data/node/test_mod_mixed_sign_float32/model.onnx
new file mode 100644
index 0000000..0c2749c
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..327456f
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c701f04
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6c064b
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float64/model.onnx b/onnx/backend/test/data/node/test_mod_mixed_sign_float64/model.onnx
new file mode 100644
index 0000000..ec8f509
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6381f6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..59f28ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..94c868a
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_float64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int16/model.onnx b/onnx/backend/test/data/node/test_mod_mixed_sign_int16/model.onnx
new file mode 100644
index 0000000..77fa330
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..824d736
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f0f16f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..80ac5b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int32/model.onnx b/onnx/backend/test/data/node/test_mod_mixed_sign_int32/model.onnx
new file mode 100644
index 0000000..e9cd49f
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..646a577
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5a7f95b
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b2f250e
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int64/model.onnx b/onnx/backend/test/data/node/test_mod_mixed_sign_int64/model.onnx
new file mode 100644
index 0000000..583541d
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7c7887f
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..eb8b6e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99c107e
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int8/model.onnx b/onnx/backend/test/data/node/test_mod_mixed_sign_int8/model.onnx
new file mode 100644
index 0000000..ab70089
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..06afc2e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8db8016
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
yJ��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..129a893
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_mixed_sign_int8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint16/model.onnx b/onnx/backend/test/data/node/test_mod_uint16/model.onnx
new file mode 100644
index 0000000..45df7e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ebeefaf
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1aacd1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2397054
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint32/model.onnx b/onnx/backend/test/data/node/test_mod_uint32/model.onnx
new file mode 100644
index 0000000..c43c129
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d04eb64
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ecd08b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f1e7b2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint64/model.onnx b/onnx/backend/test/data/node/test_mod_uint64/model.onnx
new file mode 100644
index 0000000..b6a151e
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4333af7
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..39e586b
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..000841f
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mod_uint8/model.onnx b/onnx/backend/test/data/node/test_mod_uint8/model.onnx
new file mode 100644
index 0000000..9c7b6e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5f16748
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a963b73
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
yJ
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3df8e11
Binary files /dev/null and b/onnx/backend/test/data/node/test_mod_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum/model.onnx b/onnx/backend/test/data/node/test_momentum/model.onnx
new file mode 100644
index 0000000..674a5fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0483cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
RJ���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..54656de
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..15244fd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
XJ���?333@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..439d577
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e3f3aa9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
B
VJ���?fff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_momentum/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_momentum/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cb0f2fd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BX_newJ��?IK-@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_momentum/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_momentum/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2602dc1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
BV_newJr-?�<l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/model.onnx b/onnx/backend/test/data/node/test_momentum_multiple/model.onnx
new file mode 100644
index 0000000..a21c706
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum_multiple/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0483cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
RJ���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..54656de
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..259b58b
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..eb51654
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..15cbe61
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..62e5b3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_5.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..ad3e95e
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_6.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..cb33a3d
Binary files /dev/null and b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/input_7.pb differ
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..27ed979
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BX1_newJ5�h?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..bb3ee0e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
BX2_newJ^K8?q
@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..b3cf24e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_2.pb
@@ -0,0 +1 @@
+

BV1_newJ�f?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..84f4779
--- /dev/null
+++ b/onnx/backend/test/data/node/test_momentum_multiple/test_data_set_0/output_3.pb
@@ -0,0 +1 @@
+
BV2_newJ�C3@n�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mul/model.onnx b/onnx/backend/test/data/node/test_mul/model.onnx
new file mode 100644
index 0000000..eaa87ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mul/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mul/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mul/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mul/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mul/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1424d72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mul/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mul/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mul/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2c2b54e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mul/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
B
zJ�
8ח��T�L�K��w�.��>�	�>&@ƿ�s���˿=���<&�=	@>�]?x����6>��i�y���=6�=�ǽ�|D�`>@e�?!�>Q�?�0X@�w0�[�\=�	=�ҿ�Q�?���X��>[W=�t���n���$?�=W�S<Gm	@GXI�����%������?�
+@��?�?��Y�q�?�����F�C�� ֿj{�>�<�>MS��~�;���>�
+�=�@��oǾ�F��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mul_bcast/model.onnx b/onnx/backend/test/data/node/test_mul_bcast/model.onnx
new file mode 100644
index 0000000..5d73ba5
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dcbe531
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..966fee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mul_bcast/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
zJ�
8ח��T�L�K��w�.��>�<(?'箾	�=v6>�2�=l`ƽ���k�(W�9I�=��e���	���*>~Z
+�-����?��p��3����?�0�>o^z?�dž�a�>;X)��z�>�dս�;�k�8?��Z@?�|��R׽W|�@Kz��++?ڱ[��4?ش?���?��W�1��1Ԗ>���>��!��N2@9���'?bs����>Op@B٣�}y��|�üW�{��)�?σ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mul_example/model.onnx b/onnx/backend/test/data/node/test_mul_example/model.onnx
new file mode 100644
index 0000000..efbbb0b
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62e4e87
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a760307
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mul_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..132af70
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_int16/model.onnx b/onnx/backend/test/data/node/test_mul_int16/model.onnx
new file mode 100644
index 0000000..c81f23f
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mul_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mul_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..071d7c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mul_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..df53380
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mul_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..09346f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_int8/model.onnx b/onnx/backend/test/data/node/test_mul_int8/model.onnx
new file mode 100644
index 0000000..660f6ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mul_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mul_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8147f99
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_int8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mul_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..90f9ada
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mul_int8/test_data_set_0/input_1.pb
@@ -0,0 +1,7 @@
+B
yJ<
+
+	
+
	
	
+	
+
+
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mul_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mul_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..839d65c
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_int8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint16/model.onnx b/onnx/backend/test/data/node/test_mul_uint16/model.onnx
new file mode 100644
index 0000000..5b5c0e8
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5d307c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4e882d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b6c96d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint32/model.onnx b/onnx/backend/test/data/node/test_mul_uint32/model.onnx
new file mode 100644
index 0000000..f9e4517
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2ac1e5a
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e1f6aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..78b2872
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint64/model.onnx b/onnx/backend/test/data/node/test_mul_uint64/model.onnx
new file mode 100644
index 0000000..f0cd27f
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a8f7cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..56516e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b840298
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint8/model.onnx b/onnx/backend/test/data/node/test_mul_uint8/model.onnx
new file mode 100644
index 0000000..f5f2de3
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..74cf4cf
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bee6ec6
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..da05138
Binary files /dev/null and b/onnx/backend/test/data/node/test_mul_uint8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_mvn/model.onnx b/onnx/backend/test/data/node/test_mvn/model.onnx
new file mode 100644
index 0000000..5656750
Binary files /dev/null and b/onnx/backend/test/data/node/test_mvn/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mvn/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mvn/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb4a0b0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mvn/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
XJlNX??�o=���<�>��
?9�K?2�p?ldt?��5>��>t��>�,?�j�<[�?̐l?U�x?��=W��>B�i?��?��Q?]HI?��=�F1?��
+?�ޙ=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mvn/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mvn/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b872573
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mvn/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
YJl�d�?�;�>:�ſr����d���>D��>6nQ?��[?:���#rc�vyH�E3U?>	����,?�UD?�Pi?�ҿ�o����?��>�2�?�ϗ?��m����=msþ���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mvn_expanded/model.onnx b/onnx/backend/test/data/node/test_mvn_expanded/model.onnx
new file mode 100644
index 0000000..162bb62
Binary files /dev/null and b/onnx/backend/test/data/node/test_mvn_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb4a0b0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
XJlNX??�o=���<�>��
?9�K?2�p?ldt?��5>��>t��>�,?�j�<[�?̐l?U�x?��=W��>B�i?��?��Q?]HI?��=�F1?��
+?�ޙ=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b872573
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mvn_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
YJl�d�?�;�>:�ſr����d���>D��>6nQ?��[?:���#rc�vyH�E3U?>	����,?�UD?�Pi?�ҿ�o����?��>�2�?�ϗ?��m����=msþ���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mvn_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_mvn_expanded_ver18/model.onnx
new file mode 100644
index 0000000..194abc9
Binary files /dev/null and b/onnx/backend/test/data/node/test_mvn_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb4a0b0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+

B
XJlNX??�o=���<�>��
?9�K?2�p?ldt?��5>��>t��>�,?�j�<[�?̐l?U�x?��=W��>B�i?��?��Q?]HI?��=�F1?��
+?�ޙ=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b872573
--- /dev/null
+++ b/onnx/backend/test/data/node/test_mvn_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
YJl�d�?�;�>:�ſr����d���>D��>6nQ?��[?:���#rc�vyH�E3U?>	����,?�UD?�Pi?�ҿ�o����?��>�2�?�ϗ?��m����=msþ���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_neg/model.onnx b/onnx/backend/test/data/node/test_neg/model.onnx
new file mode 100644
index 0000000..08e3ba0
Binary files /dev/null and b/onnx/backend/test/data/node/test_neg/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_neg/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_neg/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_neg/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_neg/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_neg/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7eddb27
--- /dev/null
+++ b/onnx/backend/test/data/node/test_neg/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��h�̾��z��j�$��.z?�8s�b�>hd�=�9Ҿ(���%��^�B��0��B�]ת��=��R>iJ���Z?/d#@�S'��K]���=?�C��(�?Hm;� �?>2Ŀ�����������Ec?���?�!�>� �*z���癿�O�>mǚ>�6�?&õ?g�?����x?FK�>�[�?�	G�4��?��Y>L=e?ƾ �?��?k��<QN۾.:���ݚ��b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_neg_example/model.onnx b/onnx/backend/test/data/node/test_neg_example/model.onnx
new file mode 100644
index 0000000..d6b2fbc
Binary files /dev/null and b/onnx/backend/test/data/node/test_neg_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_neg_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_neg_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a24b076
Binary files /dev/null and b/onnx/backend/test/data/node/test_neg_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_neg_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_neg_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1232f9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_neg_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nesterov_momentum/model.onnx b/onnx/backend/test/data/node/test_nesterov_momentum/model.onnx
new file mode 100644
index 0000000..defcd31
Binary files /dev/null and b/onnx/backend/test/data/node/test_nesterov_momentum/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d0483cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
RJ���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..54656de
Binary files /dev/null and b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..15244fd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
XJ���?333@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..439d577
Binary files /dev/null and b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e3f3aa9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+
B
VJ���?fff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..96bad14
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BX_newJ��?�A=@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ae87a60
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nesterov_momentum/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
BV_newJ<�/? �r?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NC/model.onnx b/onnx/backend/test/data/node/test_nllloss_NC/model.onnx
new file mode 100644
index 0000000..0d5f138
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NC/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..16567c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..61a5b90
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..390025f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NC/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ�7�rRľ��l�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NC_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NC_expanded/model.onnx
new file mode 100644
index 0000000..0a13d6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NC_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..16567c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..61a5b90
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..390025f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NC_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ�7�rRľ��l�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1/model.onnx
new file mode 100644
index 0000000..189dc6c
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bd677
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8f1eef3
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab2f5e6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/model.onnx
new file mode 100644
index 0000000..d634711
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bd677
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8f1eef3
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab2f5e6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_ii/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1_ii/model.onnx
new file mode 100644
index 0000000..b823ccb
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bd677
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0025f55
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99215ca
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ"��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/model.onnx
new file mode 100644
index 0000000..c75e4ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bd677
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0025f55
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99215ca
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ"��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/model.onnx
new file mode 100644
index 0000000..e9d99c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ecdd53b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..936a645
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ef7d70b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ/��>���>5�A?e��>�be?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ba805e4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJI��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/model.onnx
new file mode 100644
index 0000000..6f6a3f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ecdd53b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..936a645
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ef7d70b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ/��>���>5�A?e��>�be?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ba805e4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJI��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/model.onnx
new file mode 100644
index 0000000..902f9a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bd677
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8f1eef3
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..64acbc9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�<\?N�?c�?y�q?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a6fd092
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/model.onnx
new file mode 100644
index 0000000..2ec9919
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bd677
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8f1eef3
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..64acbc9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�<\?N�?c�?y�q?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a6fd092
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/model.onnx
new file mode 100644
index 0000000..425f977
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bd677
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0025f55
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..64acbc9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�<\?N�?c�?y�q?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..79596bc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJz(	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/model.onnx
new file mode 100644
index 0000000..4f85c65
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..91bd677
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0025f55
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..64acbc9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�<\?N�?c�?y�q?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..79596bc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1_weight_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJz(	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2/model.onnx
new file mode 100644
index 0000000..b91f1df
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c16e700
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/model.onnx
new file mode 100644
index 0000000..e07381d
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c16e700
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/model.onnx
new file mode 100644
index 0000000..d9bc385
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1af101d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/model.onnx
new file mode 100644
index 0000000..59ee8e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1af101d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_no_weight_reduction_mean_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/model.onnx
new file mode 100644
index 0000000..fd66cfa
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fd331f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJx�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/model.onnx
new file mode 100644
index 0000000..4cc60db
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fd331f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_mean_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJx�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/model.onnx
new file mode 100644
index 0000000..d91ed9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e2e31eb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ�Zk�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/model.onnx
new file mode 100644
index 0000000..e2899d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e2e31eb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_reduction_sum_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ�Zk�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/model.onnx
new file mode 100644
index 0000000..1fbc64e
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6d74ae4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�Y?`�o?�p?�W=K�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..49a0351
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/model.onnx
new file mode 100644
index 0000000..5b9611a
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6d74ae4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�Y?`�o?�p?�W=K�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..49a0351
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/model.onnx
new file mode 100644
index 0000000..5e928bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6d74ae4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�Y?`�o?�p?�W=K�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..20aaf18
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BlossJN�
+�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/model.onnx
new file mode 100644
index 0000000..d8bd66f
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6d74ae4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�Y?`�o?�p?�W=K�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..20aaf18
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_mean_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BlossJN�
+�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/model.onnx
new file mode 100644
index 0000000..50d52ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6d74ae4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�Y?`�o?�p?�W=K�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d2bfdf2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ�0	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/model.onnx
new file mode 100644
index 0000000..4dd5a25
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7a4d9cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6d74ae4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�Y?`�o?�p?�W=K�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d2bfdf2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ�0	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/model.onnx
new file mode 100644
index 0000000..5fb3c75
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b16c52b
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6d74ae4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�Y?`�o?�p?�W=K�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d97cebf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJbڿ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/model.onnx
new file mode 100644
index 0000000..31c93d1
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a71820
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b16c52b
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6d74ae4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�Y?`�o?�p?�W=K�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d97cebf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2_with_weight_reduction_sum_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJbڿ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/model.onnx
new file mode 100644
index 0000000..f7f4ff9
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4563573
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..93aec7e
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b60da85
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx
new file mode 100644
index 0000000..0416417
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4563573
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..93aec7e
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b60da85
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/model.onnx
new file mode 100644
index 0000000..eebc8c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..16567c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbae584
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6b2ee34
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
BweightJ(��>u?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..810d9d3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJШ|�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx
new file mode 100644
index 0000000..4d8c1c7
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..16567c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BinputJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbae584
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..6b2ee34
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
BweightJ(��>u?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..810d9d3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJШ|�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/model.onnx
new file mode 100644
index 0000000..178faf5
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b5b9d5a
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ea11374
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9bcb44d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�	�=��?�@?�o�>id>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d7af6c1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ�p��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/model.onnx
new file mode 100644
index 0000000..ede9e00
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b5b9d5a
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ea11374
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9bcb44d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BweightJ�	�=��?�@?�o�>id>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d7af6c1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BlossJ�p��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/model.onnx
new file mode 100644
index 0000000..07005b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b5b9d5a
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ea11374
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..503a1db
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx
new file mode 100644
index 0000000..89543e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b5b9d5a
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ea11374
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..503a1db
Binary files /dev/null and b/onnx/backend/test/data/node/test_nllloss_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/model.onnx
new file mode 100644
index 0000000..e8425e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d82b5c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f22f0f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0120421
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b9ce4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e9d05f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7744c3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_center_point_box_format/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/model.onnx
new file mode 100644
index 0000000..e27644d
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a0d291b
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f22f0f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0120421
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b9ce4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e9d05f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7744c3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_flipped_coordinates/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/model.onnx
new file mode 100644
index 0000000..a8d9e94
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8e00a9e
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dee3a2d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+


+
BscoresJ(fff?fff?fff?fff?fff?fff?fff?fff?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0120421
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b9ce4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e9d05f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c5ef6ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_identical_boxes/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/model.onnx
new file mode 100644
index 0000000..98d4588
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7842886
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f7e0165
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+


BscoresJfff?��L?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0120421
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..02aa3a8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_3.pb
@@ -0,0 +1 @@
+

B
iou_thresholdJ%I>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e9d05f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab2a92b
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_iou_threshold_boundary/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/model.onnx
new file mode 100644
index 0000000..f8f0b2d
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aae6e11
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f22f0f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b66f8f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b9ce4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e9d05f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d188a28
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_limit_output_size/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/model.onnx
new file mode 100644
index 0000000..ecf39de
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..485de5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..869fd92
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+



BscoresJfff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0120421
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b9ce4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e9d05f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c5ef6ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_single_box/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/model.onnx
new file mode 100644
index 0000000..26e60b7
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aae6e11
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f22f0f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0120421
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b9ce4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e9d05f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7744c3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/model.onnx
new file mode 100644
index 0000000..deafc53
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aae6e11
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f22f0f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0120421
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b9ce4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..d4d71e2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+

Bscore_thresholdJ���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d188a28
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_suppress_by_IOU_and_scores/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/model.onnx
new file mode 100644
index 0000000..d5e7ba4
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..94fcdf5
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5835690
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b66f8f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b9ce4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e9d05f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dab25d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_batches/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/model.onnx b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/model.onnx
new file mode 100644
index 0000000..9fd814f
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aae6e11
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2764bfa
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b66f8f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..b9ce4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e9d05f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f66c0f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonmaxsuppression_two_classes/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonzero_example/model.onnx b/onnx/backend/test/data/node/test_nonzero_example/model.onnx
new file mode 100644
index 0000000..ea35117
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonzero_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..deccba9
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6c3c3c4
Binary files /dev/null and b/onnx/backend/test/data/node/test_nonzero_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_not_2d/model.onnx b/onnx/backend/test/data/node/test_not_2d/model.onnx
new file mode 100644
index 0000000..30bcb31
Binary files /dev/null and b/onnx/backend/test/data/node/test_not_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_not_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_not_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d954177
Binary files /dev/null and b/onnx/backend/test/data/node/test_not_2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_not_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_not_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0ca32c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_not_2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_not_3d/model.onnx b/onnx/backend/test/data/node/test_not_3d/model.onnx
new file mode 100644
index 0000000..798c8f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_not_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_not_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_not_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5531431
Binary files /dev/null and b/onnx/backend/test/data/node/test_not_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_not_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_not_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..684f874
Binary files /dev/null and b/onnx/backend/test/data/node/test_not_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_not_4d/model.onnx b/onnx/backend/test/data/node/test_not_4d/model.onnx
new file mode 100644
index 0000000..bbcc58b
Binary files /dev/null and b/onnx/backend/test/data/node/test_not_4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_not_4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_not_4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..482239d
Binary files /dev/null and b/onnx/backend/test/data/node/test_not_4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_not_4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_not_4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f663b0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_not_4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_negative_indices/model.onnx b/onnx/backend/test/data/node/test_onehot_negative_indices/model.onnx
new file mode 100644
index 0000000..fa1c9e8
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_negative_indices/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..71291b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8e2555f
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..db6d62a
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5b52b45
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_negative_indices/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_out_of_range_indices/model.onnx b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/model.onnx
new file mode 100644
index 0000000..c258fb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..11abd17
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3f45574
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..db6d62a
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f457a74
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_out_of_range_indices/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_axis/model.onnx b/onnx/backend/test/data/node/test_onehot_with_axis/model.onnx
new file mode 100644
index 0000000..e54bcba
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..446e8a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8e2555f
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..db6d62a
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..12db939
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_negative_axis/model.onnx b/onnx/backend/test/data/node/test_onehot_with_negative_axis/model.onnx
new file mode 100644
index 0000000..2cdcc96
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_negative_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..446e8a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8e2555f
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..db6d62a
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..12db939
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_with_negative_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_without_axis/model.onnx b/onnx/backend/test/data/node/test_onehot_without_axis/model.onnx
new file mode 100644
index 0000000..4dfdca4
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_without_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e27319b
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..434a8ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3501035
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..063234c
Binary files /dev/null and b/onnx/backend/test/data/node/test_onehot_without_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_optional_sequence/model.onnx b/onnx/backend/test/data/node/test_optional_get_element_optional_sequence/model.onnx
new file mode 100644
index 0000000..0110ecf
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_optional_sequence/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b8e0b61
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3475414
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_optional_sequence/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_optional_tensor/model.onnx b/onnx/backend/test/data/node/test_optional_get_element_optional_tensor/model.onnx
new file mode 100644
index 0000000..bef6fe0
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_optional_tensor/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f8f5e54
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be680bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_optional_tensor/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_sequence/model.onnx b/onnx/backend/test/data/node/test_optional_get_element_sequence/model.onnx
new file mode 100644
index 0000000..f40d78b
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_sequence/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..403a550
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3475414
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_sequence/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_tensor/model.onnx b/onnx/backend/test/data/node/test_optional_get_element_tensor/model.onnx
new file mode 100644
index 0000000..acad3ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_tensor/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1cb42c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be680bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_get_element_tensor/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/model.onnx b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/model.onnx
new file mode 100644
index 0000000..8589ace
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..730a379
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_optional_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/model.onnx b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/model.onnx
new file mode 100644
index 0000000..4812318
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..730a379
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_name_tensor_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/model.onnx b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/model.onnx
new file mode 100644
index 0000000..95e5648
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..730a379
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_optional_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/model.onnx b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/model.onnx
new file mode 100644
index 0000000..8d46a5a
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..730a379
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_no_input_tensor_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/model.onnx b/onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/model.onnx
new file mode 100644
index 0000000..b6c8b57
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d9a1909
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..730a379
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_empty_optional_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_optional_input/model.onnx b/onnx/backend/test/data/node/test_optional_has_element_optional_input/model.onnx
new file mode 100644
index 0000000..158a8e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_optional_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f8f5e54
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..629c2d2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_optional_has_element_optional_input/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+	BoutputJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_optional_has_element_tensor_input/model.onnx b/onnx/backend/test/data/node/test_optional_has_element_tensor_input/model.onnx
new file mode 100644
index 0000000..9996227
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_tensor_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f8f5e54
Binary files /dev/null and b/onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..629c2d2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_optional_has_element_tensor_input/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+	BoutputJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_or2d/model.onnx b/onnx/backend/test/data/node/test_or2d/model.onnx
new file mode 100644
index 0000000..6dacc2b
Binary files /dev/null and b/onnx/backend/test/data/node/test_or2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_or2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_or2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d954177
Binary files /dev/null and b/onnx/backend/test/data/node/test_or2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_or2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f37772
Binary files /dev/null and b/onnx/backend/test/data/node/test_or2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_or2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_or2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d185243
Binary files /dev/null and b/onnx/backend/test/data/node/test_or2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or3d/model.onnx b/onnx/backend/test/data/node/test_or3d/model.onnx
new file mode 100644
index 0000000..8dac059
Binary files /dev/null and b/onnx/backend/test/data/node/test_or3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_or3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_or3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..402cb45
Binary files /dev/null and b/onnx/backend/test/data/node/test_or3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_or3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..825b4f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_or3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_or3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_or3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a15fa6c
Binary files /dev/null and b/onnx/backend/test/data/node/test_or3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or4d/model.onnx b/onnx/backend/test/data/node/test_or4d/model.onnx
new file mode 100644
index 0000000..78fc7b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_or4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_or4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_or4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3c2fb94
Binary files /dev/null and b/onnx/backend/test/data/node/test_or4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_or4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..925bab6
Binary files /dev/null and b/onnx/backend/test/data/node/test_or4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_or4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_or4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d31d551
Binary files /dev/null and b/onnx/backend/test/data/node/test_or4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast3v1d/model.onnx b/onnx/backend/test/data/node/test_or_bcast3v1d/model.onnx
new file mode 100644
index 0000000..a05959e
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast3v1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5cc32fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1500686
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..309a335
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast3v1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast3v2d/model.onnx b/onnx/backend/test/data/node/test_or_bcast3v2d/model.onnx
new file mode 100644
index 0000000..fcef127
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast3v2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d784193
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8bab0d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2721aa9
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast3v2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v2d/model.onnx b/onnx/backend/test/data/node/test_or_bcast4v2d/model.onnx
new file mode 100644
index 0000000..a48b407
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..22944e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d7cba2c
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1b8a57d
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v3d/model.onnx b/onnx/backend/test/data/node/test_or_bcast4v3d/model.onnx
new file mode 100644
index 0000000..824dfed
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70f33b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7e83c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e9785a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v4d/model.onnx b/onnx/backend/test/data/node/test_or_bcast4v4d/model.onnx
new file mode 100644
index 0000000..8403956
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..024a348
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8e18502
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc77944
Binary files /dev/null and b/onnx/backend/test/data/node/test_or_bcast4v4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow/model.onnx b/onnx/backend/test/data/node/test_pow/model.onnx
new file mode 100644
index 0000000..cd587fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..24e3637
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ad67ee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_pow/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_pow/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..68db533
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_bcast_array/model.onnx b/onnx/backend/test/data/node/test_pow_bcast_array/model.onnx
new file mode 100644
index 0000000..849f3d6
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_bcast_array/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9a18aee
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b32d5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..33eb805
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_bcast_array/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_bcast_scalar/model.onnx b/onnx/backend/test/data/node/test_pow_bcast_scalar/model.onnx
new file mode 100644
index 0000000..55a37ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_bcast_scalar/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62e4e87
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..edee9f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad82105
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_bcast_scalar/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_example/model.onnx b/onnx/backend/test/data/node/test_pow_example/model.onnx
new file mode 100644
index 0000000..6e3aa6d
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62e4e87
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a760307
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0cc3970
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_int32/model.onnx b/onnx/backend/test/data/node/test_pow_types_float32_int32/model.onnx
new file mode 100644
index 0000000..4b34ebc
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62e4e87
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..194c2ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0cc3970
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_int64/model.onnx b/onnx/backend/test/data/node/test_pow_types_float32_int64/model.onnx
new file mode 100644
index 0000000..40247cf
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_int64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62e4e87
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2a77616
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0cc3970
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_int64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_uint32/model.onnx b/onnx/backend/test/data/node/test_pow_types_float32_uint32/model.onnx
new file mode 100644
index 0000000..7be41ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62e4e87
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7918aa4
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0cc3970
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_uint64/model.onnx b/onnx/backend/test/data/node/test_pow_types_float32_uint64/model.onnx
new file mode 100644
index 0000000..27b580a
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62e4e87
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..015d9af
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0cc3970
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_float32_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int32_float32/model.onnx b/onnx/backend/test/data/node/test_pow_types_int32_float32/model.onnx
new file mode 100644
index 0000000..f761112
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int32_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb7ca34
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a760307
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67fd11d
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int32_float32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int32_int32/model.onnx b/onnx/backend/test/data/node/test_pow_types_int32_int32/model.onnx
new file mode 100644
index 0000000..9fe38b7
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int32_int32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb7ca34
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..194c2ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67fd11d
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int32_int32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int64_float32/model.onnx b/onnx/backend/test/data/node/test_pow_types_int64_float32/model.onnx
new file mode 100644
index 0000000..d314573
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int64_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d91963f
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a760307
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c77d210
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int64_float32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int64_int64/model.onnx b/onnx/backend/test/data/node/test_pow_types_int64_int64/model.onnx
new file mode 100644
index 0000000..7031ea4
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int64_int64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d91963f
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2a77616
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c77d210
Binary files /dev/null and b/onnx/backend/test/data/node/test_pow_types_int64_int64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_prelu_broadcast/model.onnx b/onnx/backend/test/data/node/test_prelu_broadcast/model.onnx
new file mode 100644
index 0000000..fd8ef91
Binary files /dev/null and b/onnx/backend/test/data/node/test_prelu_broadcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9ba86ee
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BslopeJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cfbf6fc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_broadcast/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�<(?�8s?	�=v6>�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?��*>iJ�>-����?�S'?�K]?���?�C@o^z?Hm;=a�>2�?��?��>���>k�8?��Z@?�|�� >*z�?��?�++?ڱ[��4?ش?���?��?1��1Ԗ>���>�	G?�N2@9���'?�>���>Op@B٣�QN�>.:�=�ݚ>�)�?σ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_broadcast_expanded/model.onnx b/onnx/backend/test/data/node/test_prelu_broadcast_expanded/model.onnx
new file mode 100644
index 0000000..46c7395
Binary files /dev/null and b/onnx/backend/test/data/node/test_prelu_broadcast_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9ba86ee
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BslopeJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cfbf6fc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_broadcast_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�<(?�8s?	�=v6>�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?��*>iJ�>-����?�S'?�K]?���?�C@o^z?Hm;=a�>2�?��?��>���>k�8?��Z@?�|�� >*z�?��?�++?ڱ[��4?ش?���?��?1��1Ԗ>���>�	G?�N2@9���'?�>���>Op@B٣�QN�>.:�=�ݚ>�)�?σ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_example/model.onnx b/onnx/backend/test/data/node/test_prelu_example/model.onnx
new file mode 100644
index 0000000..d3f555b
Binary files /dev/null and b/onnx/backend/test/data/node/test_prelu_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8e8f7df
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BslopeJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_prelu_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c8a3558
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_example/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
x��?h��>��z?�j@$�?�	�>�8s?�s���˿=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?=6�=iJ�>�|D�`>@�S'?�K]?Q�?�C@�w0�Hm;=�	=2�?��?��>���>[W=�t���n���� >*z�?��?GXI�����%������?�
+@��?�?��Y�q�?�	G?��F�C�� ֿ�>�<�>MS��~�;QN�>.:�=�ݚ>�oǾ�F��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_example_expanded/model.onnx b/onnx/backend/test/data/node/test_prelu_example_expanded/model.onnx
new file mode 100644
index 0000000..d4bdf06
Binary files /dev/null and b/onnx/backend/test/data/node/test_prelu_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8e8f7df
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BslopeJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c8a3558
--- /dev/null
+++ b/onnx/backend/test/data/node/test_prelu_example_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
x��?h��>��z?�j@$�?�	�>�8s?�s���˿=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?=6�=iJ�>�|D�`>@�S'?�K]?Q�?�C@�w0�Hm;=�	=2�?��?��>���>[W=�t���n���� >*z�?��?GXI�����%������?�
+@��?�?��Y�q�?�	G?��F�C�� ֿ�>�<�>MS��~�;QN�>.:�=�ݚ>�oǾ�F��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearconv/model.onnx b/onnx/backend/test/data/node/test_qlinearconv/model.onnx
new file mode 100644
index 0000000..3ab6ba4
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearconv/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8e5c824
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a0312d3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
Bx_scaleJE�q;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..19abda9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+Bx_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..8f7a61c
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f4956fc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+

Bw_scaleJ=|�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..4af6cdb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
Bw_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..b12e3ad
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_6.pb
@@ -0,0 +1 @@
+
By_scaleJ�:�:
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..dd078c6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+By_zero_pointJ
{
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8e51997
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearconv/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/model.onnx b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/model.onnx
new file mode 100644
index 0000000..57d513f
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..229aa1a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
aJQm�o�W��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..018faae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+Ba_scaleJ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2ce2ca0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
Ba_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..296f16a
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..a752c8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_4.pb
@@ -0,0 +1,2 @@
+

+Bb_scaleJ8
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..99edcfb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
Bb_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..7d5c692
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_6.pb
@@ -0,0 +1,2 @@
+

+By_scaleJz!
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..b4ea8c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+
By_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8bee35f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float16/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ)��
��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/model.onnx b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/model.onnx
new file mode 100644
index 0000000..a2951e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..229aa1a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
aJQm�o�W��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..53c8940
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

Ba_scaleJ�D�;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2ce2ca0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
Ba_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..296f16a
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e5f59fb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+

Bb_scaleJ��;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..99edcfb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
Bb_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..3128ded
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_6.pb
@@ -0,0 +1 @@
+

By_scaleJO/<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..b4ea8c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+
By_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8bee35f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_int8_float32/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ)��
��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/model.onnx b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/model.onnx
new file mode 100644
index 0000000..ef8aed6
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb9265d
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..018faae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+Ba_scaleJ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9cc71b9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
Ba_zero_pointJ
q
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..ea04e20
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..a752c8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_4.pb
@@ -0,0 +1,2 @@
+

+Bb_scaleJ8
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..db93763
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
Bb_zero_pointJ
r
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..7d5c692
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_6.pb
@@ -0,0 +1,2 @@
+

+By_scaleJz!
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..521faf8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+
By_zero_pointJ
v
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..91b23e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float16/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ�s�
B�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/model.onnx b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/model.onnx
new file mode 100644
index 0000000..154094d
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb9265d
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..53c8940
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

Ba_scaleJ�D�;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9cc71b9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
Ba_zero_pointJ
q
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..ea04e20
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e5f59fb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+

Bb_scaleJ��;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..db93763
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
Bb_zero_pointJ
r
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..3128ded
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_6.pb
@@ -0,0 +1 @@
+

By_scaleJO/<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..521faf8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+
By_zero_pointJ
v
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..91b23e0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_2D_uint8_float32/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ�s�
B�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/model.onnx b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/model.onnx
new file mode 100644
index 0000000..03671c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d18ee37
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
aJQm�o�W��Qm�o�W��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..018faae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+Ba_scaleJ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2ce2ca0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
Ba_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..7ab13ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..a752c8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_4.pb
@@ -0,0 +1,2 @@
+

+Bb_scaleJ8
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..acff1ce
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
Bb_zero_pointJ
r
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..7d5c692
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_6.pb
@@ -0,0 +1,2 @@
+

+By_scaleJz!
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..b4ea8c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+
By_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..58b695e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float16/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ���s'����s'�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/model.onnx b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/model.onnx
new file mode 100644
index 0000000..1240eea
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d18ee37
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
aJQm�o�W��Qm�o�W��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..53c8940
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

Ba_scaleJ�D�;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2ce2ca0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
Ba_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..7ab13ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e5f59fb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+

Bb_scaleJ��;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..acff1ce
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
Bb_zero_pointJ
r
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..3128ded
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_6.pb
@@ -0,0 +1 @@
+

By_scaleJO/<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..b4ea8c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+
By_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..58b695e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_int8_float32/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ���s'����s'�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/model.onnx b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/model.onnx
new file mode 100644
index 0000000..045c02e
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6e19bf7
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..018faae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+

+Ba_scaleJ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9cc71b9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
Ba_zero_pointJ
q
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..4ff4f2e
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..a752c8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_4.pb
@@ -0,0 +1,2 @@
+

+Bb_scaleJ8
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..db93763
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
Bb_zero_pointJ
r
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..7d5c692
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_6.pb
@@ -0,0 +1,2 @@
+

+By_scaleJz!
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..521faf8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+
By_zero_pointJ
v
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e693951
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float16/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ�s�
B��s�
B�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/model.onnx b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/model.onnx
new file mode 100644
index 0000000..0cc8add
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6e19bf7
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..53c8940
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

Ba_scaleJ�D�;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9cc71b9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
Ba_zero_pointJ
q
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..4ff4f2e
Binary files /dev/null and b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..e5f59fb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+

Bb_scaleJ��;
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_5.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_5.pb
new file mode 100644
index 0000000..db93763
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_5.pb
@@ -0,0 +1 @@
+
Bb_zero_pointJ
r
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_6.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_6.pb
new file mode 100644
index 0000000..3128ded
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_6.pb
@@ -0,0 +1 @@
+

By_scaleJO/<
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_7.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_7.pb
new file mode 100644
index 0000000..521faf8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/input_7.pb
@@ -0,0 +1 @@
+
By_zero_pointJ
v
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e693951
--- /dev/null
+++ b/onnx/backend/test/data/node/test_qlinearmatmul_3D_uint8_float32/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ�s�
B��s�
B�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear/model.onnx b/onnx/backend/test/data/node/test_quantizelinear/model.onnx
new file mode 100644
index 0000000..97900a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c1a28ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c2965ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2119acc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+By_zero_pointJ
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5703f72
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_axis/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_axis/model.onnx
new file mode 100644
index 0000000..a51a0f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a72a063
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..52db106
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0639618
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+By_zero_pointJT�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..36b3f93
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_axis/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJY"�J;W 
�c�yf
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/model.onnx
new file mode 100644
index 0000000..3e59936
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8b2d222
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..acf8634
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ce46e24
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e0d1248
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_blocked_asymmetric/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+B
yJ



\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/model.onnx
new file mode 100644
index 0000000..ad0e421
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0028165
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..acf8634
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..53db589
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_blocked_symmetric/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/model.onnx
new file mode 100644
index 0000000..2e0f381
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..89dfd53
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c2965ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..012db71
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9bcfde7
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e4m3fn/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e5m2/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_e5m2/model.onnx
new file mode 100644
index 0000000..70f628a
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e5m2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..89dfd53
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c2965ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b7eca6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a77a10c
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_e5m2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/model.onnx
new file mode 100644
index 0000000..f6e24f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..29e2d75
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4cda36
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..dca288f
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad7efc3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_float4e2m1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+*	 d�
T�
�
B
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int16/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_int16/model.onnx
new file mode 100644
index 0000000..77f2ed9
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7846b65
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c2965ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9057d7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1b0aadf
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int2/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_int2/model.onnx
new file mode 100644
index 0000000..9450cd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8c02e13
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4cda36
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b169c9d
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..50dcfe3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_int2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+*TO�
B
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int4/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_int4/model.onnx
new file mode 100644
index 0000000..8e3d3e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f39a379
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4cda36
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7a0bc58
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+*
By_zero_point
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..65ea807
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_int4/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+*!S�
CTuB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint16/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_uint16/model.onnx
new file mode 100644
index 0000000..203673f
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5424c72
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c2965ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9d6fd7b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+By_zero_pointJ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..811f4ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint2/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_uint2/model.onnx
new file mode 100644
index 0000000..7ba527d
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e626186
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4cda36
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..dde6705
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..618e5c5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_uint2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+*�
@�
B
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint4/model.onnx b/onnx/backend/test/data/node/test_quantizelinear_uint4/model.onnx
new file mode 100644
index 0000000..4bbdbf7
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f39a379
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4cda36
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b0fdf15
--- /dev/null
+++ b/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+*
By_zero_point
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b257471
Binary files /dev/null and b/onnx/backend/test/data/node/test_quantizelinear_uint4/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/model.onnx b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/model.onnx
new file mode 100644
index 0000000..6668fe3
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ac02ca0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BstartJ�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6340af2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+BlimitJ�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1757b7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..312c8c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ�?@@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/model.onnx b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/model.onnx
new file mode 100644
index 0000000..140a276
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ac02ca0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+BstartJ�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6340af2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+BlimitJ�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1757b7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..312c8c3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_range_bfloat16_type_positive_delta_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutputJ�?@@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta/model.onnx b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/model.onnx
new file mode 100644
index 0000000..fb78b95
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d822d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c64f9b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a0b1de3
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..370cda3
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/model.onnx b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/model.onnx
new file mode 100644
index 0000000..cc06bd7
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8d822d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c64f9b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a0b1de3
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..370cda3
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float16_type_positive_delta_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta/model.onnx b/onnx/backend/test/data/node/test_range_float_type_positive_delta/model.onnx
new file mode 100644
index 0000000..dea2cf3
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d12d9e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fc750f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf19463
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..26e23a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/model.onnx b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/model.onnx
new file mode 100644
index 0000000..aaa312f
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d12d9e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fc750f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..bf19463
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..26e23a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_float_type_positive_delta_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta/model.onnx b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/model.onnx
new file mode 100644
index 0000000..25f84a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5709b87
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e269978
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..07ccefa
--- /dev/null
+++ b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+BdeltaJ����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..23aa393
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_int32_type_negative_delta/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/model.onnx b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/model.onnx
new file mode 100644
index 0000000..6465bda
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5709b87
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e269978
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..07ccefa
--- /dev/null
+++ b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+BdeltaJ����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..23aa393
Binary files /dev/null and b/onnx/backend/test/data/node/test_range_int32_type_negative_delta_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reciprocal/model.onnx b/onnx/backend/test/data/node/test_reciprocal/model.onnx
new file mode 100644
index 0000000..3a6578e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reciprocal/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reciprocal/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reciprocal/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..851a5f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reciprocal/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
�?�?S��?Z'�?���?�tl?���?�p?�%�?MY�?9)b??W�?Բ�?���?�y�?k/?N?-?J��?���?�\�?^C�?�J�?�#v?b�?<G?��?Ͳ$?��?�˂?I'j?�C?�?D�t?rˆ?i�?��?'Y�?���?�̸?�E�?�\?T�o?�K�?�j?�X�?vו?��5?P
!?�P?&]?5��?0Hp?��?�?�x5?�K)?��?��@?$`w?��>?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reciprocal/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reciprocal/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..de5edfb
Binary files /dev/null and b/onnx/backend/test/data/node/test_reciprocal/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reciprocal_example/model.onnx b/onnx/backend/test/data/node/test_reciprocal_example/model.onnx
new file mode 100644
index 0000000..7c51857
Binary files /dev/null and b/onnx/backend/test/data/node/test_reciprocal_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a24b076
Binary files /dev/null and b/onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9884413
Binary files /dev/null and b/onnx/backend/test/data/node/test_reciprocal_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..30c249e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7234556
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..c722a71
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7234556
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..72ca98d
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5c62600
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ�B
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..9beedbb
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5c62600
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ�B
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/model.onnx
new file mode 100644
index 0000000..b575978
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5864c47
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..f82245a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5864c47
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/model.onnx
new file mode 100644
index 0000000..951b53e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d64a1b9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ;��@��<@�;�@�VA��9A`2�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..10252be
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d64a1b9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ;��@��<@�;�@�VA��9A`2�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_empty_set/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_empty_set/model.onnx
new file mode 100644
index 0000000..6b74054
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_empty_set/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b43711b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_empty_set/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/model.onnx
new file mode 100644
index 0000000..c7af418
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b43711b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_empty_set_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/model.onnx
new file mode 100644
index 0000000..90e0182
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..187306a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/model.onnx
new file mode 100644
index 0000000..3c63ad3
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..187306a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/model.onnx
new file mode 100644
index 0000000..8f50a40
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1ce9773
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ;��@��<@�;�@�VA��9A`2�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/model.onnx
new file mode 100644
index 0000000..3c36215
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1ce9773
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_keep_dims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ;��@��<@�;�@�VA��9A`2�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/model.onnx
new file mode 100644
index 0000000..a3809bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0c87b22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..187306a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/model.onnx
new file mode 100644
index 0000000..9c72308
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0c87b22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..187306a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/model.onnx
new file mode 100644
index 0000000..9aeab05
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0c87b22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1ce9773
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ;��@��<@�;�@�VA��9A`2�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/model.onnx
new file mode 100644
index 0000000..580c2ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0c87b22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1ce9773
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l1_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ;��@��<@�;�@�VA��9A`2�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..80cf79c
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9369f0f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ���A
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..bef7cbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9369f0f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ���A
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..6571eae
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..83dff2b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ�oA
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..37a0909
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..83dff2b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ�oA
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/model.onnx
new file mode 100644
index 0000000..8f30794
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..307fc64
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..ddcafe2
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..307fc64
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/model.onnx
new file mode 100644
index 0000000..f3ef778
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a479d93
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJV8�@5�@��R@���@�A��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..ac7d433
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a479d93
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJV8�@5�@��R@���@�A��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_empty_set/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_empty_set/model.onnx
new file mode 100644
index 0000000..ea21985
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_empty_set/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b43711b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_empty_set/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/model.onnx
new file mode 100644
index 0000000..5fe19d4
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b43711b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_empty_set_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/model.onnx
new file mode 100644
index 0000000..a780df1
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60a0c66
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/model.onnx
new file mode 100644
index 0000000..47dde4b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60a0c66
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/model.onnx
new file mode 100644
index 0000000..2ca647b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3001214
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJV8�@5�@��R@���@�A��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/model.onnx
new file mode 100644
index 0000000..96a3964
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3001214
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_keep_dims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJV8�@5�@��R@���@�A��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/model.onnx
new file mode 100644
index 0000000..cb7843e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0c87b22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60a0c66
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/model.onnx
new file mode 100644
index 0000000..39daa38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0c87b22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60a0c66
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/model.onnx
new file mode 100644
index 0000000..6bf25f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0c87b22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3001214
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJV8�@5�@��R@���@�A��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/model.onnx
new file mode 100644
index 0000000..5acf10f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..0c87b22
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3001214
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_l2_negative_axes_keep_dims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJV8�@5�@��R@���@�A��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/model.onnx
new file mode 100644
index 0000000..27599e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3cc3bc3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�
��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a067b99
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cab8e98
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ���?T��?|g�?*�?4��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/model.onnx
new file mode 100644
index 0000000..fcef530
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3cc3bc3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�
��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a067b99
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cab8e98
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_asc_axes_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ���?T��?|g�?*�?4��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_default/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_default/model.onnx
new file mode 100644
index 0000000..115b784
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..913f023
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�
?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8ac0928
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_default/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJi�[@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/model.onnx
new file mode 100644
index 0000000..8f2a518
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..913f023
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�
?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8ac0928
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_default_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJi�[@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/model.onnx
new file mode 100644
index 0000000..2bfa923
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..913f023
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�
?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bd24a0a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b147000
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ!	@F�@�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/model.onnx
new file mode 100644
index 0000000..51366e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..913f023
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�
?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bd24a0a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b147000
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_desc_axes_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ!	@F�@�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/model.onnx
new file mode 100644
index 0000000..3ae00b7
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d684528
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/model.onnx
new file mode 100644
index 0000000..8be396f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d684528
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_empty_set_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..f9ccb9e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70c6fe9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ea77801
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..ade2c1b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70c6fe9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ea77801
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..78be935
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6a647e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9780d35
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+


BreducedJ���h+
+#@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..8fed482
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6a647e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9780d35
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+


BreducedJ���h+
+#@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/model.onnx
new file mode 100644
index 0000000..58b8201
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70c6fe9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..85d6a90
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..5e8bb94
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70c6fe9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..85d6a90
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/model.onnx
new file mode 100644
index 0000000..1343418
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6a647e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1017191
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+BreducedJ0�eMIz�@�&~X@{��U��忎c;��^@n6���"@��
+�1�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..1229c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6a647e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1017191
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+BreducedJ0�eMIz�@�&~X@{��U��忎c;��^@n6���"@��
+�1�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/model.onnx
new file mode 100644
index 0000000..308e525
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d684528
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/model.onnx
new file mode 100644
index 0000000..252b1e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d684528
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_empty_set_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/model.onnx
new file mode 100644
index 0000000..7ffd0e1
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70c6fe9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6792bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..c40d016
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70c6fe9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6792bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/model.onnx
new file mode 100644
index 0000000..316090f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6a647e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f35be21
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BreducedJ0�eMIz�@�&~X@{��U��忎c;��^@n6���"@��
+�1�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..eddf05d
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6a647e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f35be21
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BreducedJ0�eMIz�@�&~X@{��U��忎c;��^@n6���"@��
+�1�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..d989ee9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70c6fe9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6792bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..246f32e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70c6fe9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6792bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..7166000
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6a647e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f35be21
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BreducedJ0�eMIz�@�&~X@{��U��忎c;��^@n6���"@��
+�1�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..7432714
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6a647e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f35be21
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_exp_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
BreducedJ0�eMIz�@�&~X@{��U��忎c;��^@n6���"@��
+�1�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/model.onnx
new file mode 100644
index 0000000..9dbeaa3
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..913f023
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�
?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d557c73
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+

BreducedJ<L�:? ?,�?�_�?u�?.�j?8jX?Zoh?�t�?I�V>��?l�
?X:?
+l��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/model.onnx
new file mode 100644
index 0000000..524c62b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..913f023
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ�
?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d557c73
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_log_sum_negative_axes_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+

BreducedJ<L�:? ?,�?�_�?u�?.�j?8jX?Zoh?�t�?I�V>��?l�
?X:?
+l��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_bool_inputs/model.onnx b/onnx/backend/test/data/node/test_reduce_max_bool_inputs/model.onnx
new file mode 100644
index 0000000..e8a6ec5
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_bool_inputs/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52bfa82
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bae1e63
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_bool_inputs/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/model.onnx b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/model.onnx
new file mode 100644
index 0000000..64b4a74
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0c997f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdim_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..f43f7b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e350003
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_default_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJA_A
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/model.onnx
new file mode 100644
index 0000000..2105a71
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..baa4437
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/model.onnx
new file mode 100644
index 0000000..db0fddf
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1cae778
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_do_not_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ��@���@�Ɵ���@A_A&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_empty_set/model.onnx b/onnx/backend/test/data/node/test_reduce_max_empty_set/model.onnx
new file mode 100644
index 0000000..de1892f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_empty_set/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d684528
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_empty_set/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_max_keepdims_example/model.onnx
new file mode 100644
index 0000000..d878783
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7074788
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_max_keepdims_random/model.onnx
new file mode 100644
index 0000000..25fe736
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..078ea58
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ��@���@�Ɵ���@A_A&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..bae8103
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7074788
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..9924f51
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..078ea58
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_max_negative_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ��@���@�Ɵ���@A_A&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..56bc7db
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..05bd7f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..29ec95e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b394041
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_default_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/model.onnx
new file mode 100644
index 0000000..4dcd856
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..28ac847
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/model.onnx
new file mode 100644
index 0000000..dc4bd9c
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be01437
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_do_not_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ��?Ir&@8����
�@^��@1k`�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/model.onnx
new file mode 100644
index 0000000..5a2cb6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5a14b8a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/model.onnx
new file mode 100644
index 0000000..069ba68
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6b871c6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ��?Ir&@8����
�@^��@1k`�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..1a143ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5a14b8a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..6c70573
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6b871c6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_mean_negative_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ��?Ir&@8����
�@^��@1k`�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_bool_inputs/model.onnx b/onnx/backend/test/data/node/test_reduce_min_bool_inputs/model.onnx
new file mode 100644
index 0000000..721eda5
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_bool_inputs/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52bfa82
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..35a0a10
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_bool_inputs/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..08c1a7f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b5a42c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..4734736
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a453386
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_default_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/model.onnx
new file mode 100644
index 0000000..9567bab
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..61f74f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/model.onnx
new file mode 100644
index 0000000..0b1bee9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..02651dc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_do_not_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ��y?I�e?�qÿ��:@;��@�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_empty_set/model.onnx b/onnx/backend/test/data/node/test_reduce_min_empty_set/model.onnx
new file mode 100644
index 0000000..d3d2863
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_empty_set/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1f4fd3c
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_empty_set/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_min_keepdims_example/model.onnx
new file mode 100644
index 0000000..1528580
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..eb58276
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_min_keepdims_random/model.onnx
new file mode 100644
index 0000000..7ef0b4c
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8adff16
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ��y?I�e?�qÿ��:@;��@�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..f2efb33
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a47cf38
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..eb58276
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..796a3ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8adff16
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_min_negative_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ��y?I�e?�qÿ��:@;��@�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..d7c7322
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..06c2b1a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_example/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ�g�M
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..ee67ef0
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..925f922
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_prod_default_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJ�Z��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/model.onnx
new file mode 100644
index 0000000..78523bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ea6f56b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/model.onnx
new file mode 100644
index 0000000..58c928b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a769a4a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_do_not_keepdims_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_empty_set/model.onnx b/onnx/backend/test/data/node/test_reduce_prod_empty_set/model.onnx
new file mode 100644
index 0000000..e093794
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_empty_set/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9b10ea4
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_empty_set/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/model.onnx
new file mode 100644
index 0000000..10c92c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bdead60
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/model.onnx
new file mode 100644
index 0000000..932f700
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc0e85c
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_keepdims_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..22153d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bdead60
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..28fe24b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc0e85c
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_prod_negative_axes_keepdims_random/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..ce06147
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7234556
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..bd072d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3ae4f69
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_default_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJv��A
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/model.onnx
new file mode 100644
index 0000000..5c50ca6
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..73ce772
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/model.onnx
new file mode 100644
index 0000000..22bd635
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e17090b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_do_not_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ�B@Ir�@8�1��
,A^�qA1k�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/model.onnx
new file mode 100644
index 0000000..56ef2a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..63d96ff
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/model.onnx
new file mode 100644
index 0000000..88ec0bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..271a151
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_axes_input_noop_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_set/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_empty_set/model.onnx
new file mode 100644
index 0000000..0ef5cab
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_set/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b43711b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_set/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/model.onnx
new file mode 100644
index 0000000..4decf89
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2ebb1a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_empty_set_non_reduced_axis_zero/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/model.onnx
new file mode 100644
index 0000000..34d88aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a39080e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/model.onnx
new file mode 100644
index 0000000..68bc37a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..76c670d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ�B@Ir�@8�1��
,A^�qA1k�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..0f95aa0
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a39080e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..31e71f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..76c670d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_negative_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJ�B@Ir�@8�1��
,A^�qA1k�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..b8999a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5086a99
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..026abf8
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5086a99
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..0fb64ca
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3e95228
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJN`C
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..4f9185f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f3f037
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3e95228
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_default_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



BreducedJN`C
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/model.onnx
new file mode 100644
index 0000000..cfdc1b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a63a3ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..1282288
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a63a3ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/model.onnx
new file mode 100644
index 0000000..bdd5785
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fc88d33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJګ�@���A��x@#ыB��B��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..1b66e65
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fc88d33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_do_not_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreducedJګ�@���A��x@#ыB��B��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/model.onnx
new file mode 100644
index 0000000..5277d13
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b43711b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/model.onnx
new file mode 100644
index 0000000..af0404a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..99a6775
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b43711b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_empty_set_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/model.onnx
new file mode 100644
index 0000000..04e8953
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d1fa987
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..96e6662
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d1fa987
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/model.onnx
new file mode 100644
index 0000000..3268943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c18ae9b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJګ�@���A��x@#ыB��B��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..995e234
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c18ae9b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJګ�@���A��x@#ыB��B��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/model.onnx
new file mode 100644
index 0000000..7a655db
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d1fa987
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/model.onnx
new file mode 100644
index 0000000..6b658e8
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ba9469
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d1fa987
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_example_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/model.onnx
new file mode 100644
index 0000000..30710bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c18ae9b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJګ�@���A��x@#ыB��B��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/model.onnx b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/model.onnx
new file mode 100644
index 0000000..5d275f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7154933
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ0��y?���@��@I�e?�qÿ��:@�Ɵ���@A_A�1�;��@&�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c18ae9b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reduce_sum_square_negative_axes_keepdims_random_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreducedJګ�@���A��x@#ыB��B��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reflect_pad/model.onnx b/onnx/backend/test/data/node/test_reflect_pad/model.onnx
new file mode 100644
index 0000000..1952d7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_reflect_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3737f7c
Binary files /dev/null and b/onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..131ea5f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1827c78
Binary files /dev/null and b/onnx/backend/test/data/node/test_reflect_pad/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_regex_full_match_basic/model.onnx b/onnx/backend/test/data/node/test_regex_full_match_basic/model.onnx
new file mode 100644
index 0000000..539f0ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_regex_full_match_basic/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_regex_full_match_basic/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_regex_full_match_basic/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8b647d8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_regex_full_match_basic/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2www.google.com2www.facebook.com2
www.bbc.co.ukB
X
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_regex_full_match_basic/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_regex_full_match_basic/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b676b43
Binary files /dev/null and b/onnx/backend/test/data/node/test_regex_full_match_basic/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_regex_full_match_email_domain/model.onnx b/onnx/backend/test/data/node/test_regex_full_match_email_domain/model.onnx
new file mode 100644
index 0000000..bf03e4a
Binary files /dev/null and b/onnx/backend/test/data/node/test_regex_full_match_email_domain/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_regex_full_match_email_domain/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_regex_full_match_email_domain/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9eea4c7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_regex_full_match_email_domain/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2account@gmail.com2account@hotmail.com2	not email2account2@yahoo.comB
X
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_regex_full_match_email_domain/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_regex_full_match_email_domain/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d2ce9b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_regex_full_match_email_domain/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_regex_full_match_empty/model.onnx b/onnx/backend/test/data/node/test_regex_full_match_empty/model.onnx
new file mode 100644
index 0000000..5948686
Binary files /dev/null and b/onnx/backend/test/data/node/test_regex_full_match_empty/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_regex_full_match_empty/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_regex_full_match_empty/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..998c963
Binary files /dev/null and b/onnx/backend/test/data/node/test_regex_full_match_empty/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_regex_full_match_empty/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_regex_full_match_empty/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0ac3770
Binary files /dev/null and b/onnx/backend/test/data/node/test_regex_full_match_empty/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_relu/model.onnx b/onnx/backend/test/data/node/test_relu/model.onnx
new file mode 100644
index 0000000..6b6d137
Binary files /dev/null and b/onnx/backend/test/data/node/test_relu/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_relu/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_relu/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_relu/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_relu/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_relu/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9210c94
Binary files /dev/null and b/onnx/backend/test/data/node/test_relu/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_relu_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_relu_expanded_ver18/model.onnx
new file mode 100644
index 0000000..f16f97f
Binary files /dev/null and b/onnx/backend/test/data/node/test_relu_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9210c94
Binary files /dev/null and b/onnx/backend/test/data/node/test_relu_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_allowzero_reordered/model.onnx b/onnx/backend/test/data/node/test_reshape_allowzero_reordered/model.onnx
new file mode 100644
index 0000000..fcebbbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_allowzero_reordered/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7f0a44b
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4a499af
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..92fa62e
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_allowzero_reordered/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_extended_dims/model.onnx b/onnx/backend/test/data/node/test_reshape_extended_dims/model.onnx
new file mode 100644
index 0000000..40e657d
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_extended_dims/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6febe46
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..23118a4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_extended_dims/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreshapedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_negative_dim/model.onnx b/onnx/backend/test/data/node/test_reshape_negative_dim/model.onnx
new file mode 100644
index 0000000..09784ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_negative_dim/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1f500c3
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3b8f76a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_negative_dim/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreshapedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_negative_extended_dims/model.onnx b/onnx/backend/test/data/node/test_reshape_negative_extended_dims/model.onnx
new file mode 100644
index 0000000..632e58f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_negative_extended_dims/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e2cc6aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..86c7f3e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_negative_extended_dims/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreshapedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_one_dim/model.onnx b/onnx/backend/test/data/node/test_reshape_one_dim/model.onnx
new file mode 100644
index 0000000..33a91fd
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_one_dim/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1c7276f
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..caecce4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_one_dim/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreshapedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_reduced_dims/model.onnx b/onnx/backend/test/data/node/test_reshape_reduced_dims/model.onnx
new file mode 100644
index 0000000..9d45953
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_reduced_dims/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..36ae1cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..515d48c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_reduced_dims/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreshapedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_reordered_all_dims/model.onnx b/onnx/backend/test/data/node/test_reshape_reordered_all_dims/model.onnx
new file mode 100644
index 0000000..5fedfaf
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_reordered_all_dims/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..15b5542
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..12748ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_reordered_all_dims/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreshapedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_reordered_last_dims/model.onnx b/onnx/backend/test/data/node/test_reshape_reordered_last_dims/model.onnx
new file mode 100644
index 0000000..a57fe99
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_reordered_last_dims/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dd88ffb
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..651078e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_reordered_last_dims/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
BreshapedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/model.onnx b/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/model.onnx
new file mode 100644
index 0000000..e966851
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ff09fd3
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..57f7584
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_zero_and_negative_dim/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreshapedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_zero_dim/model.onnx b/onnx/backend/test/data/node/test_reshape_zero_dim/model.onnx
new file mode 100644
index 0000000..dda4bf8
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_zero_dim/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..17ddeb3
Binary files /dev/null and b/onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e4d5bf5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_reshape_zero_dim/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BreshapedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/model.onnx
new file mode 100644
index 0000000..67002ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bed53be
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..23a0313
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/model.onnx
new file mode 100644
index 0000000..4571472
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bed53be
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e90ac9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/model.onnx
new file mode 100644
index 0000000..157355f
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bed53be
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5255d0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_align_corners/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/model.onnx
new file mode 100644
index 0000000..505e7de
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2714f66
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..67f1667
--- /dev/null
+++ b/onnx/backend/test/data/node/test_resize_downsample_scales_cubic_antialias/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


B
YJ(!@�%�@�mA۶5A
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_scales_linear/model.onnx
new file mode 100644
index 0000000..9577f17
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ba20d26
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2714f66
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0b5f698
--- /dev/null
+++ b/onnx/backend/test/data/node/test_resize_downsample_scales_linear/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



B
YJ��*@���@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/model.onnx
new file mode 100644
index 0000000..3a357d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ba20d26
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2714f66
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..862210f
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_align_corners/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/model.onnx
new file mode 100644
index 0000000..218260d
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2714f66
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..66f7463
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_antialias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/model.onnx
new file mode 100644
index 0000000..d36d421
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6087e9b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b2a5bc4
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d55a529
--- /dev/null
+++ b/onnx/backend/test/data/node/test_resize_downsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



B
YJVU�?UUU@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/model.onnx
new file mode 100644
index 0000000..788a002
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ba20d26
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2714f66
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..22295fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_scales_nearest/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/model.onnx
new file mode 100644
index 0000000..dfefdc2
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c028168
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e9a6d91
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/model.onnx
new file mode 100644
index 0000000..ca9e96d
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c028168
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ee224
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_cubic_antialias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/model.onnx
new file mode 100644
index 0000000..22b95ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c028168
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e716783
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_antialias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/model.onnx
new file mode 100644
index 0000000..c0eb4af
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1761b4d
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..18da7b7
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_linear_pytorch_half_pixel/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/model.onnx
new file mode 100644
index 0000000..631fbae
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ba20d26
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbab6e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab23a3f
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/model.onnx
new file mode 100644
index 0000000..c328c68
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ba20d26
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..890be08
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..22295fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/model.onnx b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/model.onnx
new file mode 100644
index 0000000..700273d
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ba20d26
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..890be08
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a70118d
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_downsample_sizes_nearest_not_smaller/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/model.onnx b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/model.onnx
new file mode 100644
index 0000000..9d66dc7
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..97d51d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c028168
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ff0974f
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/model.onnx b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/model.onnx
new file mode 100644
index 0000000..901fd46
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..620b45c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BroiJ���>��?��?��L?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3e53e34
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ff0974f
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_2_3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/model.onnx b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/model.onnx
new file mode 100644
index 0000000..ec376c4
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..80eb473
--- /dev/null
+++ b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BroiJ��?���>��L?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3e53e34
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ff0974f
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_axes_3_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/model.onnx b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/model.onnx
new file mode 100644
index 0000000..61f951d
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5f7472d
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..c028168
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0119c6b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_tf_crop_and_resize_extrapolation_value/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/model.onnx
new file mode 100644
index 0000000..cf7792e
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..87cd42c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab475cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/model.onnx
new file mode 100644
index 0000000..5fba2ec
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..87cd42c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5dad368
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_A_n0p5_exclude_outside/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/model.onnx
new file mode 100644
index 0000000..a5d0531
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..87cd42c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..98130c7
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_align_corners/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/model.onnx
new file mode 100644
index 0000000..e67d0b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..87cd42c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2b849dd
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_cubic_asymmetric/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_linear/model.onnx
new file mode 100644
index 0000000..514dc10
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..87cd42c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1df9afe
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/model.onnx
new file mode 100644
index 0000000..97668aa
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..87cd42c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e357768
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_align_corners/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/model.onnx
new file mode 100644
index 0000000..668e0f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..83b65cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..478eec7
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_linear_half_pixel_symmetric/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/model.onnx
new file mode 100644
index 0000000..4393e84
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c1adc83
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..617f127
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/model.onnx
new file mode 100644
index 0000000..a32bb22
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..368e6e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..617f127
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_2_3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/model.onnx
new file mode 100644
index 0000000..f609937
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..35b496c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..617f127
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_scales_nearest_axes_3_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/model.onnx
new file mode 100644
index 0000000..5534530
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f07c6b4
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1c3c5c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_cubic/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/model.onnx
new file mode 100644
index 0000000..4d0e002
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dae9d7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3455f38
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/model.onnx
new file mode 100644
index 0000000..936d83d
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3ef9c82
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3455f38
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_2_3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/model.onnx
new file mode 100644
index 0000000..fae879b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..62367ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3455f38
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_axes_3_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/model.onnx
new file mode 100644
index 0000000..d9550d6
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dbc7c2c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f570dcd
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_ceil_half_pixel/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/model.onnx
new file mode 100644
index 0000000..2401f58
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dbc7c2c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1f3bda5
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_floor_align_corners/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/model.onnx
new file mode 100644
index 0000000..06168d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3ef9c82
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1140b55
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_larger/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/model.onnx
new file mode 100644
index 0000000..1490d86
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3ef9c82
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..18aaecf
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_not_smaller/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/model.onnx b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/model.onnx
new file mode 100644
index 0000000..ce7bae9
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..97596cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dbc7c2c
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f570dcd
Binary files /dev/null and b/onnx/backend/test/data/node/test_resize_upsample_sizes_nearest_round_prefer_ceil_asymmetric/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reversesequence_batch/model.onnx b/onnx/backend/test/data/node/test_reversesequence_batch/model.onnx
new file mode 100644
index 0000000..f4a4ec1
Binary files /dev/null and b/onnx/backend/test/data/node/test_reversesequence_batch/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..624b0f5
Binary files /dev/null and b/onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..239f9c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a98ca22
Binary files /dev/null and b/onnx/backend/test/data/node/test_reversesequence_batch/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reversesequence_time/model.onnx b/onnx/backend/test/data/node/test_reversesequence_time/model.onnx
new file mode 100644
index 0000000..8da2127
Binary files /dev/null and b/onnx/backend/test/data/node/test_reversesequence_time/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edef4e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6180380
Binary files /dev/null and b/onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ce39dc5
Binary files /dev/null and b/onnx/backend/test/data/node/test_reversesequence_time/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/model.onnx
new file mode 100644
index 0000000..877d8e8
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cb9f861
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..78995a8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0��?j�'=�;�>�!!?�R@�,>�1�>���=�%c>�Ug>r��=.�h�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/model.onnx
new file mode 100644
index 0000000..50f0127
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cb9f861
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..78995a8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis0_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0��?j�'=�;�>�!!?�R@�,>�1�>���=�%c>�Ug>r��=.�h�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/model.onnx
new file mode 100644
index 0000000..3de4c30
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e1a324f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ*z�?��?�Oƾmǚ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2b90fe2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0Ω�?+��>@�1例��?uԁ�Ϣ��H�!=��*�Q"&?i2�����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/model.onnx
new file mode 100644
index 0000000..a618e0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e1a324f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ*z�?��?�Oƾmǚ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2b90fe2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis1_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0Ω�?+��>@�1例��?uԁ�Ϣ��H�!=��*�Q"&?i2�����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/model.onnx
new file mode 100644
index 0000000..229077e
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..38d7e2a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ�6��&õ�gڿ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..adfcff9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0/����L�������7@{\ؿvT�?���~��ܮ>�4D��i��ժn@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/model.onnx
new file mode 100644
index 0000000..8b7e26e
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..38d7e2a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ�6��&õ�gڿ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..adfcff9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_1_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0/����L�������7@{\ؿvT�?���~��ܮ>�4D��i��ժn@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/model.onnx
new file mode 100644
index 0000000..4482a6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..16b73d1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0�C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7d4ef6d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0��W@q����j=vȴ��7@������=�YE�@��=�C/���,��C>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/model.onnx
new file mode 100644
index 0000000..e8b4ca9
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6a03306
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ0x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..16b73d1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ0�C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7d4ef6d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_2d_axis_negative_2_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ0��W@q����j=vȴ��7@������=�YE�@��=�C/���,��C>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/model.onnx
new file mode 100644
index 0000000..87af9d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a316592
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..13ffd1f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJxT!g>���=��7���j��Z	�4
��w?g���9=�ѽ�n��EGڿA��ѵH>LI?�5��B�ſ���վ
�>��?��U>k���b;9?�[X�Ͱ�^�$;��?���M�UY�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..3f88445
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a316592
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..13ffd1f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis0_epsilon_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJxT!g>���=��7���j��Z	�4
��w?g���9=�ѽ�n��EGڿA��ѵH>LI?�5��B�ſ���վ
�>��?��U>k���b;9?�[X�Ͱ�^�$;��?���M�UY�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/model.onnx
new file mode 100644
index 0000000..7c460c4
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ca2b1b6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ<5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..da314ae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJx�� �f9�>u`8>Zp�?�}?/$��^<�|t���=��J>�Xu>ęݿe�Z�
_�={|뾔hֽO�?g3�R�s>+�r�%����;xƙ?�����5?�g�J�D�}�=>
�?����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..04b3b4c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ca2b1b6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ<5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..da314ae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis1_epsilon_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJx�� �f9�>u`8>Zp�?�}?/$��^<�|t���=��J>�Xu>ęݿe�Z�
_�={|뾔hֽO�?g3�R�s>+�r�%����;xƙ?�����5?�g�J�D�}�=>
�?����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/model.onnx
new file mode 100644
index 0000000..a77885d
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2664d33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJٺ�>*������>ǩ?3�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8a8fe2c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJx���>Yl��B�7>��?&L����ں��3��M�C��̾b#�="5���_�>��G>�����?>f���h��&��>:0?h���ܾ]>�+�8r��8�:/,��?��s�?KQZ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..ddb4e6a
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2664d33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJٺ�>*������>ǩ?3�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8a8fe2c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis2_epsilon_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJx���>Yl��B�7>��?&L����ں��3��M�C��̾b#�="5���_�>��G>�����?>f���h��&��>:0?h���ܾ]>�+�8r��8�:/,��?��s�?KQZ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/model.onnx
new file mode 100644
index 0000000..bc17752
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f005fed
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ�9�r�޾���?�,?֞�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..453f1e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..3a9c013
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f005fed
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ�9�r�޾���?�,?֞�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..453f1e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_1_epsilon_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/model.onnx
new file mode 100644
index 0000000..86944f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d10a903
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ<���?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..601eaeb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
B
YJx��A@B��l%���s@�M@�Y�B?
+��=�R2�ǽ��=���?�fս�)�=_�>�3
?d:���e�=���>�{��vm����>�P��4��E_�ƀh��)
+=z��<�;?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..92c41d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d10a903
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ<���?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..601eaeb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_2_epsilon_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
B
YJx��A@B��l%���s@�M@�Y�B?
+��=�R2�ǽ��=���?�fս�)�=_�>�3
?d:���e�=���>�{��vm����>�P��4��E_�ƀh��)
+=z��<�;?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/model.onnx
new file mode 100644
index 0000000..70b8c7e
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..99ddacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99faffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJx��z��R�>(��qL�P�>��>ŵ��]�l�?a�=uH�<��=��>O7?���>�8A�Ä����=��A"��4@���>�0�>Nq?�2@��6q6=f��<�y��Aģ?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/model.onnx
new file mode 100644
index 0000000..e4ca20d
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2dbaacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJxx��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..99ddacc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJx^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..99faffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_3d_axis_negative_3_epsilon_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJx��z��R�>(��qL�P�>��>ŵ��]�l�?a�=uH�<��=��>O7?���>�8A�Ä����=��A"��4@���>�0�>Nq?�2@��6q6=f��<�y��Aģ?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/model.onnx
new file mode 100644
index 0000000..b7c557e
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..177f420
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..eaac2a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/model.onnx
new file mode 100644
index 0000000..087216e
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..177f420
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..eaac2a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis0_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/model.onnx
new file mode 100644
index 0000000..a074082
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..979d0cf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/input_1.pb
@@ -0,0 +1,3 @@
+
B
WJ�
�2?!w;��n?��>�w��[�$>�:C��)ʾ_���b����>Y=~�&uW?r�@�J=-��>B�$?0
+ɿ��S�hSa?�[ٿ�I�>*[��Ⴟ;=>ԿoJ|�e����?R+(>�9?�d������ο�k��'�B��[?��?ڸ�?�@Z?bA��Վ�
+DD?l�>x_⿶
�>_�P?�[q=�~=�
�N�
(��T�L?@D���o����?w;/?�ܽ>�x>1��?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cebefda
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ��j�?g �:�[?�7?���m��"�.��]f=�<*߾ �=@���.O?��鼂]�<��>�g?&B�>�y�5����@W�s>��꿮�6?���=�@��-����>�&@X�h>ni�=mK��F/�>��@@*��=�v��H~?�E�?����\x�1:?S�?����r'?t%Y?���u�˘0=��>U�%>�?N1�>�(>�τ>�:<�E�>�(�<��%=AHh�MF��A�_(����9����٘.���}��]�>-)3��+n>��e�qyH>U0���k?��>13�<?ʥ�iP	���^?]�|=i�A=}�?��>;������?za=�y@�l`���ҁ>�Hؿ��)>r@`�2r���X��3|����˽���Q
<��?�}6>�>�*���R�?��n�oR�>LF�?t[)?()���,��r��J�����%�~�1?Z��>)�ھ8�㾌�?�3�>L�����d?[�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/model.onnx
new file mode 100644
index 0000000..8e48125
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..979d0cf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,3 @@
+
B
WJ�
�2?!w;��n?��>�w��[�$>�:C��)ʾ_���b����>Y=~�&uW?r�@�J=-��>B�$?0
+ɿ��S�hSa?�[ٿ�I�>*[��Ⴟ;=>ԿoJ|�e����?R+(>�9?�d������ο�k��'�B��[?��?ڸ�?�@Z?bA��Վ�
+DD?l�>x_⿶
�>_�P?�[q=�~=�
�N�
(��T�L?@D���o����?w;/?�ܽ>�x>1��?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cebefda
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis1_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
YJ��j�?g �:�[?�7?���m��"�.��]f=�<*߾ �=@���.O?��鼂]�<��>�g?&B�>�y�5����@W�s>��꿮�6?���=�@��-����>�&@X�h>ni�=mK��F/�>��@@*��=�v��H~?�E�?����\x�1:?S�?����r'?t%Y?���u�˘0=��>U�%>�?N1�>�(>�τ>�:<�E�>�(�<��%=AHh�MF��A�_(����9����٘.���}��]�>-)3��+n>��e�qyH>U0���k?��>13�<?ʥ�iP	���^?]�|=i�A=}�?��>;������?za=�y@�l`���ҁ>�Hؿ��)>r@`�2r���X��3|����˽���Q
<��?�}6>�>�*���R�?��n�oR�>LF�?t[)?()���,��r��J�����%�~�1?Z��>)�ھ8�㾌�?�3�>L�����d?[�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/model.onnx
new file mode 100644
index 0000000..20c78f0
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a5f6cb1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJP�zE?�ă?��h�)@پ�\?��)����?�
?4;���a>�ԃ��+��֌?�%�?�,@�e���(�֤�2O��Pr��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2912f3c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/model.onnx
new file mode 100644
index 0000000..fdffe4a
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a5f6cb1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJP�zE?�ă?��h�)@پ�\?��)����?�
?4;���a>�ԃ��+��֌?�%�?�,@�e���(�֤�2O��Pr��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2912f3c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/model.onnx
new file mode 100644
index 0000000..db3072e
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e1a2b66
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ��c���i�)2׿��c���w>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f076391
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
YJ���{�bej�b������	�>c��>X�����>3c>r�>��+�+(޿]ֿ���X�>J½���ٿrJ�>�������oƱ>]����Nc�
b�>��>���>�E����>����Н>MH
��ʰ�
�?<e�?�����1�(��E!����>�����;(>�i?�8
@=���߱�yf�=0�?A��Z�?ˤR��U�>k{���9�?�
+�?0���r��2�b�����?v�^��-&>?:�>��?���?g�>=�=	��?��b�Zk?�j<ѴE��v����d&�?�T�=sZ�>A~�?��?���>�/�<�a>�u2���)�('�?0\�>5$���nd�-f�>J?Y�X>�s�=��a�t
�����=(7���2��Z��`�k��=no���g?ҋ�?��!�/XU�������>�_?ļ���~>s���6����?F��:�H�V�t�f!����>��:�x��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/model.onnx
new file mode 100644
index 0000000..38dc776
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e1a2b66
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ��c���i�)2׿��c���w>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f076391
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis3_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
YJ���{�bej�b������	�>c��>X�����>3c>r�>��+�+(޿]ֿ���X�>J½���ٿrJ�>�������oƱ>]����Nc�
b�>��>���>�E����>����Н>MH
��ʰ�
�?<e�?�����1�(��E!����>�����;(>�i?�8
@=���߱�yf�=0�?A��Z�?ˤR��U�>k{���9�?�
+�?0���r��2�b�����?v�^��-&>?:�>��?���?g�>=�=	��?��b�Zk?�j<ѴE��v����d&�?�T�=sZ�>A~�?��?���>�/�<�a>�u2���)�('�?0\�>5$���nd�-f�>J?Y�X>�s�=��a�t
�����=(7���2��Z��`�k��=no���g?ҋ�?��!�/XU�������>�_?ļ���~>s���6����?F��:�H�V�t�f!����>��:�x��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/model.onnx
new file mode 100644
index 0000000..36b9664
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5b7b698
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ,�c�[�o?'Ǵ?P���2]?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5f01427
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/model.onnx
new file mode 100644
index 0000000..3c24965
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5b7b698
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJ,�c�[�o?'Ǵ?P���2]?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5f01427
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_1_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/model.onnx
new file mode 100644
index 0000000..cd5ce58
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4e28a2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJP���>�A�U�?D�o�
屾��+�п��ȿ�2��?�/e?���?酪�����s�(��	4>UT�>�#�?��>��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1afcc98
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/model.onnx
new file mode 100644
index 0000000..bb7f8b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c4e28a2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJP���>�A�U�?D�o�
屾��+�п��ȿ�2��?�/e?���?酪�����s�(��	4>UT�>�#�?��>��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1afcc98
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/model.onnx
new file mode 100644
index 0000000..147c149
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2382063
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..31bcce1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
B
YJ����?҃`>6�����>'j�������W?���>]�b=��=Ԛ��
+6��R?P�
=ۯϾIu�=ݓ?��q>LӀ�Ks?�6�#*���
+��u�?&S!>B\�<��->'����N�Ay�u�>ƾ�/��?㽪@�>#�
+�vl�8ǔ���k<M�?Bn�?7�4?�r�>��v>u�~���?���u^@:N�I��?�!I�a�>��I?��<��9�>�=���� x,��a-�R6��@M����?thQ�������j���c��i9�>��[<�ܦ�	03�Űr?���󊿾8aS��]/��>@��t���;��>G
�����}S��(��?�U�d*?+*>�hM?A��r�>�u?B&�=Y��>���=�?Mv��b�p��e�<
���/�n�֮�?��?[,>.�?���@��>�O?�׆���>x�f�Ȝ�1�h>�$��v���C?�$�?�>��)?�=�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/model.onnx
new file mode 100644
index 0000000..1d88f25
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2382063
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..31bcce1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_3_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
B
YJ����?҃`>6�����>'j�������W?���>]�b=��=Ԛ��
+6��R?P�
=ۯϾIu�=ݓ?��q>LӀ�Ks?�6�#*���
+��u�?&S!>B\�<��->'����N�Ay�u�>ƾ�/��?㽪@�>#�
+�vl�8ǔ���k<M�?Bn�?7�4?�r�>��v>u�~���?���u^@:N�I��?�!I�a�>��I?��<��9�>�=���� x,��a-�R6��@M����?thQ�������j���c��i9�>��[<�ܦ�	03�Űr?���󊿾8aS��]/��>@��t���;��>G
�����}S��(��?�U�d*?+*>�hM?A��r�>�u?B&�=Y��>���=�?Mv��b�p��e�<
���/�n�֮�?��?[,>.�?���@��>�O?�׆���>x�f�Ȝ�1�h>�$��v���C?�$�?�>��)?�=�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/model.onnx
new file mode 100644
index 0000000..938d615
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6ba3495
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJ�/#�6g˾��x���6��K�ֿ��?�0�?�8P�˳���d?�f�,\>���1?�1?��9�����ʿ�A?�,����
�	���PW����-OA>�?��=y,���y�=�O�>)r1�V[�?P��>@'�
++Ⱦ���>������
�� @$c���?.*1�
��?���>1�?�ʅ���?�0?梦?Y� �0I��_s@����f6����?$�=t<?��̾�w�>F<���=�?���) .��*?w���Ȫ�=a���1?8g#�����?�;���
;��žh;�=��,��Ⓘ�k|���۽�78�O P�h��>d�8$���䟾vs!�(n@=g4��yq?�G??Y/����E?g����/*��7?�����>W/�)l�?�Ĉ?/"� 0��f�������������v >�?��>�C��	�����?�0���&��l�������r�����?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..836b174
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/model.onnx
new file mode 100644
index 0000000..9fcce91
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6ba3495
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
B
WJ�/#�6g˾��x���6��K�ֿ��?�0�?�8P�˳���d?�f�,\>���1?�1?��9�����ʿ�A?�,����
�	���PW����-OA>�?��=y,���y�=�O�>)r1�V[�?P��>@'�
++Ⱦ���>������
�� @$c���?.*1�
��?���>1�?�ʅ���?�0?梦?Y� �0I��_s@����f6����?$�=t<?��̾�w�>F<���=�?���) .��*?w���Ȫ�=a���1?8g#�����?�;���
;��žh;�=��,��Ⓘ�k|���۽�78�O P�h��>d�8$���䟾vs!�(n@=g4��yq?�G??Y/����E?g����/*��7?�����>W/�)l�?�Ĉ?/"� 0��f�������������v >�?��>�C��	�����?�0���&��l�������r�����?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..836b174
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_4d_axis_negative_4_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_default_axis/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_default_axis/model.onnx
new file mode 100644
index 0000000..62c9188
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_default_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2664d33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJٺ�>*������>ǩ?3�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..495bf6c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_default_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/model.onnx b/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/model.onnx
new file mode 100644
index 0000000..852d3e1
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..703fd46
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
XJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2664d33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
WJٺ�>*������>ǩ?3�1�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..495bf6c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rms_normalization_default_axis_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rnn_seq_length/model.onnx b/onnx/backend/test/data/node/test_rnn_seq_length/model.onnx
new file mode 100644
index 0000000..7a02500
Binary files /dev/null and b/onnx/backend/test/data/node/test_rnn_seq_length/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0879670
Binary files /dev/null and b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..481acbc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJ<x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..4f52fb9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJd]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..88f54cf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/input_3.pb
@@ -0,0 +1,2 @@
+

+
B
BJ(�6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2aaa730
Binary files /dev/null and b/onnx/backend/test/data/node/test_rnn_seq_length/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_false/model.onnx b/onnx/backend/test/data/node/test_roialign_aligned_false/model.onnx
new file mode 100644
index 0000000..cd9dfe7
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_aligned_false/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b50b557
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bb14c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7e24ffa
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..951f415
--- /dev/null
+++ b/onnx/backend/test/data/node/test_roialign_aligned_false/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+

B
YJ����>���>V�>��??W?$(�>���>Z�> c?F��>���>u�>�?M�
?"��><N�>G�>�0?m��>I�`?�?ff6?�� ?�ƫ>��>���>j�>io�>q��>,�
+?�/�>�z4?X9?
+h�>��3?+�>��
?�%?��?TtT?s?�(=?�m4?�RV?*�c?Di?M�?�5?ۊ?���>!t>;
�>vO�>�(?�B?���>���>��6?�l?�y?�,?F%?�&?�C?�`?�	?a�>=[>�'�>�Q�>�|�>�g�>}Г>vq�>��p>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_true/model.onnx b/onnx/backend/test/data/node/test_roialign_aligned_true/model.onnx
new file mode 100644
index 0000000..eb22ab1
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_aligned_true/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b50b557
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bb14c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7e24ffa
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..597556b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_roialign_aligned_true/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+

B
YJ���? ү>&S�>��>
+h"? c�>�^	?���>��>D��>I��>��>��?�2?sh�>��>:��>��?��>�U/?���>B�6?�ZR?���>���>/�>��_>�ڪ>#��>X�>$�?>Ș�>�\?b��>$��><�>���>��?��?�>ྎ>.��>�)?333?I�@?}�?}�3?'�9?Q�;?	�P?u>ף�>;
�>�G�>s��>���>�W�>-�>�S$?O�T?�;?��>;p?
@?{n?'�)?��?�l�>��>��*?��)?䃾>ΈR>]mE>H�}>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_roialign_mode_max/model.onnx b/onnx/backend/test/data/node/test_roialign_mode_max/model.onnx
new file mode 100644
index 0000000..c27207a
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_mode_max/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b50b557
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bb14c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..7e24ffa
Binary files /dev/null and b/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..29a1461
--- /dev/null
+++ b/onnx/backend/test/data/node/test_roialign_mode_max/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+

B
YJ�Ke�>h�>���>W��>΃�>Ȣ�>��?�I*?��?
Ί>TUY>��>�}W?G�J?zr�>��>Gz�>� M?�m�>�?!�>�	?�U
+?�s>��L>�?�>�4?�P�>ؕ�>��>�4?�Y?���>>X>9K?�o4><]�>���>>X�>7�!?��?��Y?�p	?)�p?t83?���>��?�
?�y?��>ӭW>���>葿>B�?��>s��>B��>B�?�~?GnF?e�>�
?�˷>p�3?�"?��?�
�>��7>p��>��>�8�>z��>�@t>��>˹�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding/model.onnx
new file mode 100644
index 0000000..baa8be7
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b73f52c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..62163a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1ab85e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/model.onnx
new file mode 100644
index 0000000..bd055d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c067ad6
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b73f52c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..62163a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..715ad1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/model.onnx
new file mode 100644
index 0000000..defe649
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c067ad6
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b73f52c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..62163a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..715ad1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_3d_input_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_expanded/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_expanded/model.onnx
new file mode 100644
index 0000000..167f1b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b73f52c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..62163a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1ab85e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/model.onnx
new file mode 100644
index 0000000..b107a8f
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b73f52c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..62163a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fefe261
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/model.onnx
new file mode 100644
index 0000000..3340cc7
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b73f52c
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..62163a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fefe261
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_interleaved_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/model.onnx
new file mode 100644
index 0000000..bd22701
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e3883d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B	cos_cacheJ`J٣>aU�>�?��T?�!?	f_?�
�>�LL?Y>>'�s?;�/?�\>�r?^;?��>tnZ>ͨ?�:�<	sT>`p�>5��>�Y�>Z%�>�7?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a1ab485
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B	sin_cacheJ`a�>>d�q?3S=?k�>a�h>;�>��m=�k�>���>�C2?�h�>�7>+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1fbe61b
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/model.onnx
new file mode 100644
index 0000000..2ea29c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e3883d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B	cos_cacheJ`J٣>aU�>�?��T?�!?	f_?�
�>�LL?Y>>'�s?;�/?�\>�r?^;?��>tnZ>ͨ?�:�<	sT>`p�>5��>�Y�>Z%�>�7?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a1ab485
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B	sin_cacheJ`a�>>d�q?3S=?k�>a�h>;�>��m=�k�>���>�C2?�h�>�7>+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1fbe61b
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/model.onnx
new file mode 100644
index 0000000..92ddb6b
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e3883d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B	cos_cacheJ`J٣>aU�>�?��T?�!?	f_?�
�>�LL?Y>>'�s?;�/?�\>�r?^;?��>tnZ>ͨ?�:�<	sT>`p�>5��>�Y�>Z%�>�7?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a1ab485
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B	sin_cacheJ`a�>>d�q?3S=?k�>a�h>;�>��m=�k�>���>�C2?�h�>�7>+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2b03d11
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/model.onnx
new file mode 100644
index 0000000..7a4cfa4
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e3883d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B	cos_cacheJ`J٣>aU�>�?��T?�!?	f_?�
�>�LL?Y>>'�s?;�/?�\>�r?^;?��>tnZ>ͨ?�:�<	sT>`p�>5��>�Y�>Z%�>�7?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a1ab485
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B	sin_cacheJ`a�>>d�q?3S=?k�>a�h>;�>��m=�k�>���>�C2?�h�>�7>+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2b03d11
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_interleaved_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/model.onnx
new file mode 100644
index 0000000..3069480
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8573ef8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B	cos_cacheJ0+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f5b27b3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B	sin_cacheJ0a�>>d�q?3S=?k�>a�h>;�>��m=�k�>���>�C2?�h�>�7>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..afb950f
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/model.onnx
new file mode 100644
index 0000000..743f4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8573ef8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B	cos_cacheJ0+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f5b27b3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B	sin_cacheJ0a�>>d�q?3S=?k�>a�h>;�>��m=�k�>���>�C2?�h�>�7>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..afb950f
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_no_position_ids_rotary_dim_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/model.onnx
new file mode 100644
index 0000000..669060e
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..45d2b7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..29780b5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+2
B	sin_cacheJ���m=�k�>���>�C2?�h�>�7>+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?J٣>aU�>�?��T?�!?	f_?�
�>�LL?Y>>'�s?;�/?�\>�r?^;?��>tnZ>ͨ?�:�<	sT>`p�>5��>�Y�>Z%�>�7?�%]?���=�r?�<>�7?V��>s�?��;>�R>���>��>&�p?[�C?k�??-Zg?b٪=|\
?9�?vAv?\��>қv>�f�=n��<��m?�+?��H?�>�>�?���=.��>=z?�b`?,#�>v)v?1Cm>�s?!�p?��L?	e!?V�_?��>]TY?+-?h�X<�ȱ>=�>,Y{?���>��>y�#?��>�/>OvR?~gB>��?]�e>�b�=��\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4a65a3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/model.onnx
new file mode 100644
index 0000000..82045dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..45d2b7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..29780b5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+2
B	sin_cacheJ���m=�k�>���>�C2?�h�>�7>+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?J٣>aU�>�?��T?�!?	f_?�
�>�LL?Y>>'�s?;�/?�\>�r?^;?��>tnZ>ͨ?�:�<	sT>`p�>5��>�Y�>Z%�>�7?�%]?���=�r?�<>�7?V��>s�?��;>�R>���>��>&�p?[�C?k�??-Zg?b٪=|\
?9�?vAv?\��>қv>�f�=n��<��m?�+?��H?�>�>�?���=.��>=z?�b`?,#�>v)v?1Cm>�s?!�p?��L?	e!?V�_?��>]TY?+-?h�X<�ȱ>=�>,Y{?���>��>y�#?��>�/>OvR?~gB>��?]�e>�b�=��\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4a65a3a
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_interleaved_rotary_dim_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/model.onnx
new file mode 100644
index 0000000..947030b
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..45d2b7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..29780b5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+2
B	sin_cacheJ���m=�k�>���>�C2?�h�>�7>+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?J٣>aU�>�?��T?�!?	f_?�
�>�LL?Y>>'�s?;�/?�\>�r?^;?��>tnZ>ͨ?�:�<	sT>`p�>5��>�Y�>Z%�>�7?�%]?���=�r?�<>�7?V��>s�?��;>�R>���>��>&�p?[�C?k�??-Zg?b٪=|\
?9�?vAv?\��>қv>�f�=n��<��m?�+?��H?�>�>�?���=.��>=z?�b`?,#�>v)v?1Cm>�s?!�p?��L?	e!?V�_?��>]TY?+-?h�X<�ȱ>=�>,Y{?���>��>y�#?��>�/>OvR?~gB>��?]�e>�b�=��\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fafd11
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
BoutputJ�P@=�;B>��>��?H��>QY%?n�><Kd?n�;�f>�>?Η?^k?��l?Z{�=�p�=�?�s���	n?��?��z?��L?G�>��G?�3};@���L��=B�E?ڗ?�N�>�s�>.4F?w�=+�>N~�>6�!?N�?c�?y�q?Ƌ.?�^ܾ�6�=+�V?�;�>9�*?�+?�nW>A>�L��r
=�t�>֒�>}?���=��U>R.%>@�[���,>�U(?�߂>��">]�=7(?�
>\<*��X=.<D?ĵ>��V?>��=?�y?
��>�^2>��>��?@�>̐>�)�=���>�'�=���<�a>�W�>#�*?�?"�>��?�c�=|�=����M.I?�A�?�>8a7?	-�>��;>�W(���;o�B?e��;b�-?|>�>�5<?�Qv?#;����ؾ)
�>x�?�od>\�s?���>=�X?�I<�:*h��r>�¶>��a?M�?i�a?�I1?�>(��=��g?�4�>��>�<?;�<h�>�MW�{���?`x�>��
+>v��>8�?pC?�����V�E>'�&?�e?1�>�)�>Ud?%�>�MB=�
?�}�>��6?p�?�>�=^?��o�(���
+>
+&?u�N?��?Tz�>m��=Դ"���
�4Ll>/�?ǻy?�[?n�?<O�>XQ�=��.=��.?�!E=��L>��<�/K?�Le>���0�=���>ZgP?��(>5?A�?-�s>~½�:����>��*?G�:?A��>���>H�V>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/model.onnx b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/model.onnx
new file mode 100644
index 0000000..b1e6d38
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aa55451
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..45d2b7a
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..29780b5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+2
B	sin_cacheJ���m=�k�>���>�C2?�h�>�7>+�<-��=��-?�J�>A]	?@�e?چ}?>^>~�)?1҆>I,�<%B?J٣>aU�>�?��T?�!?	f_?�
�>�LL?Y>>'�s?;�/?�\>�r?^;?��>tnZ>ͨ?�:�<	sT>`p�>5��>�Y�>Z%�>�7?�%]?���=�r?�<>�7?V��>s�?��;>�R>���>��>&�p?[�C?k�??-Zg?b٪=|\
?9�?vAv?\��>қv>�f�=n��<��m?�+?��H?�>�>�?���=.��>=z?�b`?,#�>v)v?1Cm>�s?!�p?��L?	e!?V�_?��>]TY?+-?h�X<�ȱ>=�>,Y{?���>��>y�#?��>�/>OvR?~gB>��?]�e>�b�=��\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..557cce2
Binary files /dev/null and b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fafd11
--- /dev/null
+++ b/onnx/backend/test/data/node/test_rotary_embedding_with_rotary_dim_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
BoutputJ�P@=�;B>��>��?H��>QY%?n�><Kd?n�;�f>�>?Η?^k?��l?Z{�=�p�=�?�s���	n?��?��z?��L?G�>��G?�3};@���L��=B�E?ڗ?�N�>�s�>.4F?w�=+�>N~�>6�!?N�?c�?y�q?Ƌ.?�^ܾ�6�=+�V?�;�>9�*?�+?�nW>A>�L��r
=�t�>֒�>}?���=��U>R.%>@�[���,>�U(?�߂>��">]�=7(?�
>\<*��X=.<D?ĵ>��V?>��=?�y?
��>�^2>��>��?@�>̐>�)�=���>�'�=���<�a>�W�>#�*?�?"�>��?�c�=|�=����M.I?�A�?�>8a7?	-�>��;>�W(���;o�B?e��;b�-?|>�>�5<?�Qv?#;����ؾ)
�>x�?�od>\�s?���>=�X?�I<�:*h��r>�¶>��a?M�?i�a?�I1?�>(��=��g?�4�>��>�<?;�<h�>�MW�{���?`x�>��
+>v��>8�?pC?�����V�E>'�&?�e?1�>�)�>Ud?%�>�MB=�
?�}�>��6?p�?�>�=^?��o�(���
+>
+&?u�N?��?Tz�>m��=Դ"���
�4Ll>/�?ǻy?�[?n�?<O�>XQ�=��.=��.?�!E=��L>��<�/K?�Le>���0�=���>ZgP?��(>5?A�?-�s>~½�:����>��*?G�:?A��>���>H�V>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_round/model.onnx b/onnx/backend/test/data/node/test_round/model.onnx
new file mode 100644
index 0000000..385814c
Binary files /dev/null and b/onnx/backend/test/data/node/test_round/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_round/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_round/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2638e9c
Binary files /dev/null and b/onnx/backend/test/data/node/test_round/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_round/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_round/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..97748c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_round/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_multi_state/model.onnx b/onnx/backend/test/data/node/test_scan9_multi_state/model.onnx
new file mode 100644
index 0000000..7e37f07
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_multi_state/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2cb1b3e
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2cf1ebb
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..da6e540
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ff2bbf5
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..efc1609
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..8d6db10
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_multi_state/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_scalar/model.onnx b/onnx/backend/test/data/node/test_scan9_scalar/model.onnx
new file mode 100644
index 0000000..f34d8a4
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_scalar/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..43a74c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e1a7e42
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..54d8f18
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..79c79bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_scalar/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_sum/model.onnx b/onnx/backend/test/data/node/test_scan9_sum/model.onnx
new file mode 100644
index 0000000..380da1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_sum/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4e664a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..da6e540
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cecc069
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..8d6db10
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan9_sum/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scan_sum/model.onnx b/onnx/backend/test/data/node/test_scan_sum/model.onnx
new file mode 100644
index 0000000..4f75e18
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan_sum/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7bf1077
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8421af8
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab08a5f
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..76bc629
Binary files /dev/null and b/onnx/backend/test/data/node/test_scan_sum/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_axis/model.onnx b/onnx/backend/test/data/node/test_scatter_elements_with_axis/model.onnx
new file mode 100644
index 0000000..3a1c040
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..661309d
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ffdfd30
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1fdaa8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

BupdatesJ�̌?ff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0e60ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/model.onnx b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/model.onnx
new file mode 100644
index 0000000..9c0383a
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..661309d
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..989ee89
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1fdaa8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

BupdatesJ�̌?ff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0733c0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_duplicate_indices/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/model.onnx b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/model.onnx
new file mode 100644
index 0000000..f0f811a
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..661309d
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..97a7da2
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1fdaa8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

BupdatesJ�̌?ff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..115d80f
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_negative_indices/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/model.onnx b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/model.onnx
new file mode 100644
index 0000000..937ebcb
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..661309d
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..989ee89
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1fdaa8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

BupdatesJ�̌?ff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d3b5e04
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_max/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/model.onnx b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/model.onnx
new file mode 100644
index 0000000..c8ed01c
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..661309d
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..989ee89
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1fdaa8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

BupdatesJ�̌?ff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..240c512
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_min/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/model.onnx b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/model.onnx
new file mode 100644
index 0000000..d93513e
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..661309d
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..989ee89
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1fdaa8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

BupdatesJ�̌?ff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a7750e5
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_with_reduction_mul/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_without_axis/model.onnx b/onnx/backend/test/data/node/test_scatter_elements_without_axis/model.onnx
new file mode 100644
index 0000000..8c39d45
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_without_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c063bb7
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..be4025f
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e50cacb
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d5e565d
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_elements_without_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_with_axis/model.onnx b/onnx/backend/test/data/node/test_scatter_with_axis/model.onnx
new file mode 100644
index 0000000..c1898b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_with_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..661309d
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ffdfd30
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1fdaa8c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

BupdatesJ�̌?ff@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c0e60ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_with_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_without_axis/model.onnx b/onnx/backend/test/data/node/test_scatter_without_axis/model.onnx
new file mode 100644
index 0000000..f7fadac
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_without_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c063bb7
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..be4025f
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e50cacb
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d5e565d
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatter_without_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd/model.onnx b/onnx/backend/test/data/node/test_scatternd/model.onnx
new file mode 100644
index 0000000..92fe79f
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8f14eae
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1b01526
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ed14664
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatternd/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2357108
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_add/model.onnx b/onnx/backend/test/data/node/test_scatternd_add/model.onnx
new file mode 100644
index 0000000..7390db7
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_add/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8f14eae
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5637149
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ed14664
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cd316b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_add/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max/model.onnx b/onnx/backend/test/data/node/test_scatternd_max/model.onnx
new file mode 100644
index 0000000..4aca374
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8f14eae
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5637149
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ed14664
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6fd8332
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/model.onnx b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/model.onnx
new file mode 100644
index 0000000..9405406
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a2f61e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..44cc403
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a1e0047
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bb5c239
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_max_with_element_indices/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min/model.onnx b/onnx/backend/test/data/node/test_scatternd_min/model.onnx
new file mode 100644
index 0000000..c19369a
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8f14eae
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5637149
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ed14664
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5e83909
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/model.onnx b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/model.onnx
new file mode 100644
index 0000000..5f1f793
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a2f61e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..44cc403
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a1e0047
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..92caa1b
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_min_with_element_indices/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_multiply/model.onnx b/onnx/backend/test/data/node/test_scatternd_multiply/model.onnx
new file mode 100644
index 0000000..5009929
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_multiply/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8f14eae
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5637149
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..ed14664
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2b812a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_scatternd_multiply/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/model.onnx
new file mode 100644
index 0000000..649e1ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cc7c74
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b03b082
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..94db59b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJ/��>���>5�A?e��>�be?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4f60538
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ(��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/model.onnx
new file mode 100644
index 0000000..4bd8ebb
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cc7c74
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b03b082
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..94db59b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJ/��>���>5�A?e��>�be?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4f60538
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ(��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/model.onnx
new file mode 100644
index 0000000..200c732
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cc7c74
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b03b082
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..94db59b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJ/��>���>5�A?e��>�be?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4f60538
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ(��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ede2e50
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..f26896d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cc7c74
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b03b082
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..94db59b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJ/��>���>5�A?e��>�be?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4f60538
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ(��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ede2e50
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1_mean_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/model.onnx
new file mode 100644
index 0000000..5018642
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05f2333
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4c3b664
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0af5e50
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx
new file mode 100644
index 0000000..6416004
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05f2333
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4c3b664
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0af5e50
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/model.onnx
new file mode 100644
index 0000000..0de9ec8
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05f2333
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4c3b664
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0af5e50
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..e9bbe9d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..22158c5
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..05f2333
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4c3b664
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0af5e50
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..e9bbe9d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_none_no_weight_negative_ii_log_prob_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/model.onnx
new file mode 100644
index 0000000..3218b42
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d6912d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..199d6e3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
wJ(��>u?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..74b8cbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx
new file mode 100644
index 0000000..41f9b73
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d6912d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..199d6e3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
wJ(��>u?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..74b8cbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/model.onnx
new file mode 100644
index 0000000..9bbfd95
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d6912d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..199d6e3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
wJ(��>u?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..74b8cbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..cb5872d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d6912d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..199d6e3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1,2 @@
+
B
wJ(��>u?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..74b8cbd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3_sum_weight_high_ii_log_prob_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/model.onnx
new file mode 100644
index 0000000..a81bc58
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f77b9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..181fd66
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cb79a6e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJ�	�=��?�@?�o�>id>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2d53399
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJX�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/model.onnx
new file mode 100644
index 0000000..3398a7b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f77b9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..181fd66
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cb79a6e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJ�	�=��?�@?�o�>id>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2d53399
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJX�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/model.onnx
new file mode 100644
index 0000000..f0af3fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f77b9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..181fd66
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cb79a6e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJ�	�=��?�@?�o�>id>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2d53399
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJX�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5f4a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..d10c1ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f77b9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..181fd66
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..cb79a6e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJ�	�=��?�@?�o�>id>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2d53399
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJX�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5f4a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/model.onnx
new file mode 100644
index 0000000..f29bb3d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f77b9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..181fd66
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..73961bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx
new file mode 100644
index 0000000..2106055
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f77b9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..181fd66
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..73961bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/model.onnx
new file mode 100644
index 0000000..1d67ec3
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f77b9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..181fd66
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..73961bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5f4a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..86b60fd
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f77b9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..181fd66
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..73961bf
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5f4a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_NCd1d2d3d4d5_none_no_weight_log_prob_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean/model.onnx b/onnx/backend/test/data/node/test_sce_mean/model.onnx
new file mode 100644
index 0000000..b67c687
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9109ee6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJu��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d/model.onnx b/onnx/backend/test/data/node/test_sce_mean_3d/model.onnx
new file mode 100644
index 0000000..49a011b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cd3dd54
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8e8ae88
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_3d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_3d_expanded/model.onnx
new file mode 100644
index 0000000..85eda3c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cd3dd54
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8e8ae88
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_3d_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/model.onnx
new file mode 100644
index 0000000..0c0f7dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cd3dd54
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8e8ae88
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..6756c5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..42c9f1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cd3dd54
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8e8ae88
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..6756c5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_3d_log_prob_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_expanded/model.onnx
new file mode 100644
index 0000000..14a3f87
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9109ee6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJu��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_mean_log_prob/model.onnx
new file mode 100644
index 0000000..2743011
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9109ee6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJu��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_log_prob/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..6f65793
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9109ee6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJu��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_log_prob_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/model.onnx
new file mode 100644
index 0000000..ec5e5ae
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2705ae5
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c97c11c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/model.onnx
new file mode 100644
index 0000000..34be2c3
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5e4604b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a2101ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�C�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/model.onnx
new file mode 100644
index 0000000..e7e12d4
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5e4604b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a2101ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�C�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/model.onnx
new file mode 100644
index 0000000..b99b392
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5e4604b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a2101ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�C�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..6756c5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..71ffae6
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5e4604b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a2101ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�C�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..6756c5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/model.onnx
new file mode 100644
index 0000000..5f09088
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52d3816
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e79fac
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51ae4ed
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJh��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/model.onnx
new file mode 100644
index 0000000..998988a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52d3816
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e79fac
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51ae4ed
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJh��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/model.onnx
new file mode 100644
index 0000000..9951b42
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52d3816
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e79fac
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51ae4ed
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJh��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..9d79cec
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..21d7b3b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52d3816
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e79fac
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51ae4ed
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJh��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..9d79cec
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/model.onnx
new file mode 100644
index 0000000..02c3fe5
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2705ae5
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c97c11c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/model.onnx
new file mode 100644
index 0000000..35d38d8
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2705ae5
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c97c11c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..e98b4bd
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2705ae5
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c97c11c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_no_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight/model.onnx
new file mode 100644
index 0000000..ad4c5f6
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5cf9d9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/model.onnx
new file mode 100644
index 0000000..692a0b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5cf9d9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii/model.onnx
new file mode 100644
index 0000000..e7aeb8a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8a859f
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..840b42e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/model.onnx
new file mode 100644
index 0000000..9dd0ba8
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3dedbc0
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c06a8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d2f7b97
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJA��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/model.onnx
new file mode 100644
index 0000000..421483e
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3dedbc0
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c06a8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d2f7b97
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJA��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/model.onnx
new file mode 100644
index 0000000..510fad2
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3dedbc0
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c06a8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d2f7b97
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJA��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..6756c5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..a453067
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb26b51
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJx?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3dedbc0
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c06a8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d2f7b97
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJA��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..6756c5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_3d_log_prob_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/model.onnx
new file mode 100644
index 0000000..9153b24
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52d3816
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e79fac
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c06a8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..83911ce
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�+�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/model.onnx
new file mode 100644
index 0000000..b1b4ef6
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52d3816
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e79fac
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c06a8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..83911ce
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�+�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/model.onnx
new file mode 100644
index 0000000..aacb6c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52d3816
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e79fac
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c06a8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..83911ce
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�+�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..9d79cec
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..9f8a0b8
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..52d3816
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6e79fac
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c06a8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..83911ce
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�+�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..9d79cec
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_4d_log_prob_expanded/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/model.onnx
new file mode 100644
index 0000000..f61ad22
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8a859f
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..840b42e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/model.onnx
new file mode 100644
index 0000000..bd5ae9c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8a859f
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..840b42e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..93015ef
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a8a859f
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..840b42e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_ii_log_prob_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/model.onnx
new file mode 100644
index 0000000..65f820d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5cf9d9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..62e3d4f
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5cf9d9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_mean_weight_log_prob_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none/model.onnx b/onnx/backend/test/data/node/test_sce_none/model.onnx
new file mode 100644
index 0000000..5880d3e
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_none/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_none/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0eb5d24
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?_t�?^�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_none_expanded/model.onnx
new file mode 100644
index 0000000..67a3a8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0eb5d24
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?_t�?^�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_none_log_prob/model.onnx
new file mode 100644
index 0000000..43aa4bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0eb5d24
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?_t�?^�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_log_prob/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..4f7594d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0eb5d24
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ���?_t�?^�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_log_prob_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights/model.onnx b/onnx/backend/test/data/node/test_sce_none_weights/model.onnx
new file mode 100644
index 0000000..4f83625
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_weights/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cc4d305
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJqU�?���?ٕ?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_none_weights_expanded/model.onnx
new file mode 100644
index 0000000..7283214
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_weights_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cc4d305
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJqU�?���?ٕ?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/model.onnx
new file mode 100644
index 0000000..955ca45
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cc4d305
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJqU�?���?ٕ?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_log_prob/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..d7f3369
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..2186ff7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
B
wJfff?333?��L?fff?fff?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cc4d305
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJqU�?���?ٕ?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_none_weights_log_prob_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum/model.onnx b/onnx/backend/test/data/node/test_sce_sum/model.onnx
new file mode 100644
index 0000000..bb0d20d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_sum/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_sum/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_sum/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_sum/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2f20e8e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_sum_expanded/model.onnx
new file mode 100644
index 0000000..effa809
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_sum_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2f20e8e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob/model.onnx b/onnx/backend/test/data/node/test_sce_sum_log_prob/model.onnx
new file mode 100644
index 0000000..edeb59a
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_sum_log_prob/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2f20e8e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum_log_prob/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/model.onnx b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/model.onnx
new file mode 100644
index 0000000..00ff1cf
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aeb52e9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ<?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6251a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2f20e8e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..935f07e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sce_sum_log_prob_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+
Blog_probJ<p�п�����ʿ:kѿ���S�ӿ��]c���/��_t�����~Fٿ�CԿ^����	�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_selu/model.onnx b/onnx/backend/test/data/node/test_selu/model.onnx
new file mode 100644
index 0000000..364ae84
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_selu/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_selu/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_selu/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_selu/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_selu/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..90dc409
--- /dev/null
+++ b/onnx/backend/test/data/node/test_selu/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
ZY�@��?��;@0 �@I�@�|o��j6@�W���z��?<@�>:��@�@��>�q�?�!�?}n�@.s���op?%�\��
��R��?��%@:/I�~��@�(����>����%�@��@���>�6�?j�a����!���&�>?7l@`�f@���;\ȿ�my�|����$��BF�@XT��6�%��5G@Xř��,���*c���?d��.
+���*��z�?EWL>fLh?�]4����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_selu_default/model.onnx b/onnx/backend/test/data/node/test_selu_default/model.onnx
new file mode 100644
index 0000000..32f7c62
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_selu_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_selu_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_selu_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_selu_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_selu_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dc5f7ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_selu_default/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
7?�?�D�>V��?E�@�*�?Y���?C�|�C�0����>��>���?�L?��>���>ʀ�>4��?�����j�>�>����ϿZ�/?��h?1�k��@�z����D=�����$�?��?�&>�o�>Tk�������?��7(>"v�?.��?N����꾂,�������.���-@Y�3�������!Q?�:������ ��>#�>4�q�H��l�>V"�=���>�fS�k��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_selu_default_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_selu_default_expanded_ver18/model.onnx
new file mode 100644
index 0000000..42b83c7
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu_default_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dc5f7ef
--- /dev/null
+++ b/onnx/backend/test/data/node/test_selu_default_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
7?�?�D�>V��?E�@�*�?Y���?C�|�C�0����>��>���?�L?��>���>ʀ�>4��?�����j�>�>����ϿZ�/?��h?1�k��@�z����D=�����$�?��?�&>�o�>Tk�������?��7(>"v�?.��?N����꾂,�������.���-@Y�3�������!Q?�:������ ��>#�>4�q�H��l�>V"�=���>�fS�k��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_selu_example/model.onnx b/onnx/backend/test/data/node/test_selu_example/model.onnx
new file mode 100644
index 0000000..d822ec6
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_selu_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_selu_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_selu_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_selu_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5962862
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_selu_example_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_selu_example_expanded_ver18/model.onnx
new file mode 100644
index 0000000..7383c8a
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu_example_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5962862
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu_example_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_selu_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_selu_expanded_ver18/model.onnx
new file mode 100644
index 0000000..cf84db4
Binary files /dev/null and b/onnx/backend/test/data/node/test_selu_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..90dc409
--- /dev/null
+++ b/onnx/backend/test/data/node/test_selu_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
ZY�@��?��;@0 �@I�@�|o��j6@�W���z��?<@�>:��@�@��>�q�?�!�?}n�@.s���op?%�\��
��R��?��%@:/I�~��@�(����>����%�@��@���>�6�?j�a����!���&�>?7l@`�f@���;\ȿ�my�|����$��BF�@XT��6�%��5G@Xř��,���*c���?d��.
+���*��z�?EWL>fLh?�]4����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_insert_at_back/model.onnx b/onnx/backend/test/data/node/test_sequence_insert_at_back/model.onnx
new file mode 100644
index 0000000..35d7ea0
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_insert_at_back/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f50d450
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5c8ecf6
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..92fc868
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_insert_at_back/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_insert_at_front/model.onnx b/onnx/backend/test/data/node/test_sequence_insert_at_front/model.onnx
new file mode 100644
index 0000000..0fa7f98
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_insert_at_front/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f50d450
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ea9b4f3
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5da53eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..680e29e
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_insert_at_front/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/model.onnx b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/model.onnx
new file mode 100644
index 0000000..7daaf57
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fd31b64
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_0.pb
@@ -0,0 +1,5 @@
+
+x0
.
+
J(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>.
+
J(~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?.
+
J(��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..497228c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
+
Bx1J(�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5cd6cbb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor/test_data_set_0/output_0.pb
@@ -0,0 +1,6 @@
+
+y0
.
+
J(�8P?j��?|��?-��?��>V��?\�?P�?
+&�?�Z�?.
+
J(44�?�̦?��?e<�?���=wk4?V�!?���?`g�?r��?.
+
J(S �?�d�?��j?Ӫ�?�Z>���?eA?���?���?�Y�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/model.onnx b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/model.onnx
new file mode 100644
index 0000000..95c08d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fd31b64
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,5 @@
+
+x0
.
+
J(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>.
+
J(~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?.
+
J(��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..497228c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,2 @@
+
+
Bx1J(�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5cd6cbb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,6 @@
+
+y0
.
+
J(�8P?j��?|��?-��?��>V��?\�?P�?
+&�?�Z�?.
+
J(44�?�̦?��?e<�?���=wk4?V�!?���?`g�?r��?.
+
J(S �?�d�?��j?Ӫ�?�Z>���?eA?���?���?�Y�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/model.onnx b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/model.onnx
new file mode 100644
index 0000000..33b1953
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1684683
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_0.pb
@@ -0,0 +1,3 @@
+
+x0

JS�[?}�X?ߡ?���>uV�>�Kh=
+

J���>
J���>J�O?���>�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8a6f6cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/input_1.pb
@@ -0,0 +1,4 @@
+
+x1

JB	V?1��>��%?(��>u?�>
+

J
+�^?
J�|�>}M?>?
�-?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..19c75ae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
+y0

J���?���?<Ȣ?�@?���?�I>
+

JlE�?
J��s?dy�?��?L,�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/model.onnx b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/model.onnx
new file mode 100644
index 0000000..641dfb9
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1684683
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,3 @@
+
+x0

JS�[?}�X?ߡ?���>uV�>�Kh=
+

J���>
J���>J�O?���>�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8a6f6cc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,4 @@
+
+x1

JB	V?1��>��%?(��>u?�>
+

J
+�^?
J�|�>}M?>?
�-?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..19c75ae
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_add_2_sequences_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
+y0

J���?���?<Ȣ?�@?���?�I>
+

JlE�?
J��s?dy�?��?L,�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_extract_shapes/model.onnx b/onnx/backend/test/data/node/test_sequence_map_extract_shapes/model.onnx
new file mode 100644
index 0000000..fa902b2
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_extract_shapes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d9ade7
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..705f76b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_extract_shapes/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/model.onnx b/onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/model.onnx
new file mode 100644
index 0000000..61c28af
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1d9ade7
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..705f76b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_extract_shapes_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/model.onnx b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/model.onnx
new file mode 100644
index 0000000..04142ad
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8c9410d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/input_0.pb
@@ -0,0 +1,5 @@
+
+
x
.
+
J(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>.
+
J(~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?.
+
J(��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f7ae380
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence/test_data_set_0/output_0.pb
@@ -0,0 +1,5 @@
+
+
y
.
+
J(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>.
+
J(~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?.
+
J(��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/model.onnx b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/model.onnx
new file mode 100644
index 0000000..6c547fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e212b2b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_0.pb
@@ -0,0 +1,3 @@
+
+x0

J�!X?S�[?}�X?ߡ?���>uV�>*	
J$��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<
Ju?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..92a7bbb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
Bx1JG�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f80a822
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
+y0

J�!X?S�[?}�X?ߡ?���>uV�>*	
J$��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<
Ju?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..fb519d2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor/test_data_set_0/output_1.pb
@@ -0,0 +1,2 @@
+
+y1

JG�>��G?
JG�>��G?
JG�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/model.onnx b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/model.onnx
new file mode 100644
index 0000000..a300f17
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e212b2b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,3 @@
+
+x0

J�!X?S�[?}�X?ߡ?���>uV�>*	
J$��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<
Ju?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..92a7bbb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
Bx1JG�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f80a822
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
+y0

J�!X?S�[?}�X?ߡ?���>uV�>*	
J$��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<
Ju?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..fb519d2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_1_tensor_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1,2 @@
+
+y1

JG�>��G?
JG�>��G?
JG�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/model.onnx b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/model.onnx
new file mode 100644
index 0000000..d085a4c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8c9410d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,5 @@
+
+
x
.
+
J(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>.
+
J(~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?.
+
J(��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f7ae380
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_1_sequence_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,5 @@
+
+
y
.
+
J(?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>.
+
J(~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?.
+
J(��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/model.onnx b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/model.onnx
new file mode 100644
index 0000000..67462b1
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e212b2b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_0.pb
@@ -0,0 +1,3 @@
+
+x0

J�!X?S�[?}�X?ߡ?���>uV�>*	
J$��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<
Ju?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c903c9f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/input_1.pb
@@ -0,0 +1,3 @@
+
+x1

JG�>��G?&
J ��#?4�>��q?ڗ?�N�>�s�>.4F?���>
J�v
+>���>^D>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f80a822
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
+y0

J�!X?S�[?}�X?ߡ?���>uV�>*	
J$��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<
Ju?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0c0f023
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences/test_data_set_0/output_1.pb
@@ -0,0 +1,3 @@
+
+y1

JG�>��G?&
J ��#?4�>��q?ڗ?�N�>�s�>.4F?���>
J�v
+>���>^D>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/model.onnx b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/model.onnx
new file mode 100644
index 0000000..ae9c1c9
Binary files /dev/null and b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e212b2b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1,3 @@
+
+x0

J�!X?S�[?}�X?ߡ?���>uV�>*	
J$��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<
Ju?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c903c9f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/input_1.pb
@@ -0,0 +1,3 @@
+
+x1

JG�>��G?&
J ��#?4�>��q?ڗ?�N�>�s�>.4F?���>
J�v
+>���>^D>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f80a822
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
+y0

J�!X?S�[?}�X?ߡ?���>uV�>*	
J$��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<
Ju?�>
+�^?�|�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0c0f023
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sequence_map_identity_2_sequences_expanded/test_data_set_0/output_1.pb
@@ -0,0 +1,3 @@
+
+y1

JG�>��G?&
J ��#?4�>��q?ڗ?�N�>�s�>.4F?���>
J�v
+>���>^D>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape/model.onnx b/onnx/backend/test/data/node/test_shape/model.onnx
new file mode 100644
index 0000000..34c2a1c
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7a659f3
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_clip_end/model.onnx b/onnx/backend/test/data/node/test_shape_clip_end/model.onnx
new file mode 100644
index 0000000..2ece8e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_clip_end/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7a659f3
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_clip_end/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_clip_start/model.onnx b/onnx/backend/test/data/node/test_shape_clip_start/model.onnx
new file mode 100644
index 0000000..b452906
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_clip_start/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7a659f3
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_clip_start/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_end_1/model.onnx b/onnx/backend/test/data/node/test_shape_end_1/model.onnx
new file mode 100644
index 0000000..7606c6b
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_end_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e1731c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_end_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_end_negative_1/model.onnx b/onnx/backend/test/data/node/test_shape_end_negative_1/model.onnx
new file mode 100644
index 0000000..abd7050
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_end_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9fe08ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_end_negative_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_example/model.onnx b/onnx/backend/test/data/node/test_shape_example/model.onnx
new file mode 100644
index 0000000..2ab9f47
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9a18aee
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..460c220
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_start_1/model.onnx b/onnx/backend/test/data/node/test_shape_start_1/model.onnx
new file mode 100644
index 0000000..7c4627c
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2f33715
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_start_1_end_2/model.onnx b/onnx/backend/test/data/node/test_shape_start_1_end_2/model.onnx
new file mode 100644
index 0000000..83416a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_1_end_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d2b9678
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_1_end_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_start_1_end_negative_1/model.onnx b/onnx/backend/test/data/node/test_shape_start_1_end_negative_1/model.onnx
new file mode 100644
index 0000000..1d983be
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_1_end_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d2b9678
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_1_end_negative_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_start_greater_than_end/model.onnx b/onnx/backend/test/data/node/test_shape_start_greater_than_end/model.onnx
new file mode 100644
index 0000000..f961270
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_greater_than_end/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_start_greater_than_end/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_start_greater_than_end/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape_start_greater_than_end/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape_start_greater_than_end/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_start_greater_than_end/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..aa6ad20
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_greater_than_end/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shape_start_negative_1/model.onnx b/onnx/backend/test/data/node/test_shape_start_negative_1/model.onnx
new file mode 100644
index 0000000..b1f32eb
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_negative_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..149ec66
Binary files /dev/null and b/onnx/backend/test/data/node/test_shape_start_negative_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shrink_hard/model.onnx b/onnx/backend/test/data/node/test_shrink_hard/model.onnx
new file mode 100644
index 0000000..98149c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_hard/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..79ecbb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1a4b178
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_hard/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/model.onnx
new file mode 100644
index 0000000..8e2580e
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..79ecbb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1a4b178
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_hard_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shrink_soft/model.onnx b/onnx/backend/test/data/node/test_shrink_soft/model.onnx
new file mode 100644
index 0000000..96b15a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_soft/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..79ecbb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..236d0ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_soft/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/model.onnx
new file mode 100644
index 0000000..35bc308
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..79ecbb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..236d0ac
Binary files /dev/null and b/onnx/backend/test/data/node/test_shrink_soft_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sigmoid/model.onnx b/onnx/backend/test/data/node/test_sigmoid/model.onnx
new file mode 100644
index 0000000..d598f36
Binary files /dev/null and b/onnx/backend/test/data/node/test_sigmoid/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sigmoid/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sigmoid/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sigmoid/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sigmoid/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sigmoid/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..47970d9
Binary files /dev/null and b/onnx/backend/test/data/node/test_sigmoid/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sigmoid_example/model.onnx b/onnx/backend/test/data/node/test_sigmoid_example/model.onnx
new file mode 100644
index 0000000..1a49be4
Binary files /dev/null and b/onnx/backend/test/data/node/test_sigmoid_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4b15fa1
Binary files /dev/null and b/onnx/backend/test/data/node/test_sigmoid_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sign/model.onnx b/onnx/backend/test/data/node/test_sign/model.onnx
new file mode 100644
index 0000000..8942812
Binary files /dev/null and b/onnx/backend/test/data/node/test_sign/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sign/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sign/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..edc96c8
Binary files /dev/null and b/onnx/backend/test/data/node/test_sign/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sign/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sign/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b508c53
Binary files /dev/null and b/onnx/backend/test/data/node/test_sign/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_batchwise/model.onnx b/onnx/backend/test/data/node/test_simple_rnn_batchwise/model.onnx
new file mode 100644
index 0000000..8a52d04
Binary files /dev/null and b/onnx/backend/test/data/node/test_simple_rnn_batchwise/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a4c92c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b5abd70
Binary files /dev/null and b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b7c321d
Binary files /dev/null and b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b5226a1
--- /dev/null
+++ b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


B
YJ0˷g?˷g?˷g?˷g?��?��?��?��?��?��?��?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..6ffeb6a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_simple_rnn_batchwise/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+

BY_hJ0˷g?˷g?˷g?˷g?��?��?��?��?��?��?��?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_simple_rnn_defaults/model.onnx b/onnx/backend/test/data/node/test_simple_rnn_defaults/model.onnx
new file mode 100644
index 0000000..b376c00
Binary files /dev/null and b/onnx/backend/test/data/node/test_simple_rnn_defaults/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..17423bc
Binary files /dev/null and b/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..973f82b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJ ���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a8590fb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJ@���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6ac7545
--- /dev/null
+++ b/onnx/backend/test/data/node/test_simple_rnn_defaults/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BY_hJ0�&�>�&�>�&�>�&�>ٷ?ٷ?ٷ?ٷ?��L?��L?��L?��L?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/model.onnx b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/model.onnx
new file mode 100644
index 0000000..7570720
Binary files /dev/null and b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9cb9bf0
Binary files /dev/null and b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..156d726
--- /dev/null
+++ b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

B
WJ<���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..0403b66
--- /dev/null
+++ b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+

B
RJd���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=���=
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..508d52d
Binary files /dev/null and b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..34c0d48
--- /dev/null
+++ b/onnx/backend/test/data/node/test_simple_rnn_with_initial_bias/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

BY_hJ<ٷ?ٷ?ٷ?ٷ?ٷ?x�k?x�k?x�k?x�k?x�k?��|?��|?��|?��|?��|?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sin/model.onnx b/onnx/backend/test/data/node/test_sin/model.onnx
new file mode 100644
index 0000000..23fdf09
Binary files /dev/null and b/onnx/backend/test/data/node/test_sin/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sin/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sin/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sin/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sin/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sin/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d35bacf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sin/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
�;{?�t�>]mT?��H?R�t?�7T�_?P?f�]ӽv^�>��>�C~?m�0?v��=t��>L��>=??��P�a��>�A��!��?*�B?�-���C?LD~��\;=�>���?�~?3>�	�>��F�m�j�#���*s>OMq?u�n?�c���n��4�]�u}���}�z�m?����E0پ.*s�
�3?#���4X���G�O0�>sN����l����F��>x �=Ճ�>���`���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sin_example/model.onnx b/onnx/backend/test/data/node/test_sin_example/model.onnx
new file mode 100644
index 0000000..a2678a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_sin_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sin_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sin_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_sin_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sin_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sin_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7908cf4
Binary files /dev/null and b/onnx/backend/test/data/node/test_sin_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sinh/model.onnx b/onnx/backend/test/data/node/test_sinh/model.onnx
new file mode 100644
index 0000000..54cb1d7
Binary files /dev/null and b/onnx/backend/test/data/node/test_sinh/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sinh/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sinh/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sinh/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sinh/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sinh/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6f92e4b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sinh/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
%E5@hd�>�B�?͹�@�,J@����6��?
����ӽ�.�>�>��
@./V?F��=E��>w�>�b@�S��>�7v�H��a3?��y?6�O��-�@
�
�~;=,�@�uH
@W�@DM>cD�>�)����c����"� >0R�?_��?�N˾�%��`2���O��ru*��\@f1����ݸͿ��[?�W�6~[�\�����>��¼�>����>�S�=�<�>V-��ҽ�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sinh_example/model.onnx b/onnx/backend/test/data/node/test_sinh_example/model.onnx
new file mode 100644
index 0000000..b47d538
Binary files /dev/null and b/onnx/backend/test/data/node/test_sinh_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sinh_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sinh_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_sinh_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sinh_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sinh_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4cb4991
Binary files /dev/null and b/onnx/backend/test/data/node/test_sinh_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_size/model.onnx b/onnx/backend/test/data/node/test_size/model.onnx
new file mode 100644
index 0000000..5dcaebd
Binary files /dev/null and b/onnx/backend/test/data/node/test_size/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_size/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_size/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_size/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_size/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_size/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2355ec3
Binary files /dev/null and b/onnx/backend/test/data/node/test_size/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_size_example/model.onnx b/onnx/backend/test/data/node/test_size_example/model.onnx
new file mode 100644
index 0000000..cf1f47d
Binary files /dev/null and b/onnx/backend/test/data/node/test_size_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_size_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_size_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9a18aee
Binary files /dev/null and b/onnx/backend/test/data/node/test_size_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_size_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_size_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6ca8cb7
Binary files /dev/null and b/onnx/backend/test/data/node/test_size_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice/model.onnx b/onnx/backend/test/data/node/test_slice/model.onnx
new file mode 100644
index 0000000..aaf785a
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_slice/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dbead81
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fcc1054
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_slice/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f5957cc
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_slice/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..a067b99
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_slice/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..8a16805
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_slice/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_slice/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ab98615
--- /dev/null
+++ b/onnx/backend/test/data/node/test_slice/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
+
B
yJ�x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?ٺ�>*������>ǩ?3�1��9�r�޾���?�,?֞�>8E�<
+?�,��`=��"��*-?u�?ELU�d��>q鋿�᾿���>u�*>l�"?r�@h�q?��i�d��?�o���T�
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_slice_default_axes/model.onnx b/onnx/backend/test/data/node/test_slice_default_axes/model.onnx
new file mode 100644
index 0000000..d397731
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dbead81
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d407e45
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..8235cfa
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3bc16d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_axes/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_default_steps/model.onnx b/onnx/backend/test/data/node/test_slice_default_steps/model.onnx
new file mode 100644
index 0000000..8683a29
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_steps/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dbead81
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d407e45
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..8235cfa
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..f0febb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3bc16d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_default_steps/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_end_out_of_bounds/model.onnx b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/model.onnx
new file mode 100644
index 0000000..b178bc7
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dbead81
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f6355e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e69ecf6
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f2b5359
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..de6ff73
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_end_out_of_bounds/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg/model.onnx b/onnx/backend/test/data/node/test_slice_neg/model.onnx
new file mode 100644
index 0000000..c90e6c3
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dbead81
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6993ea4
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..9f204f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
BendsJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f2b5359
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6512db5
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg_steps/model.onnx b/onnx/backend/test/data/node/test_slice_neg_steps/model.onnx
new file mode 100644
index 0000000..f0eee35
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg_steps/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dbead81
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5ad1739
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..1cefc06
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..f0febb0
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..b9a2bbf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/input_4.pb
@@ -0,0 +1 @@
+BstepsJ������������������������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fe91b5e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_slice_neg_steps/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
B
yJ��Z�����=�p��#����K?���?�	��?U����ݝ>�p��"��R�ξ�Rſ�C�!Tu=n�]?��>wb=�
+�?@S=���<�<6I�?�xT�bމ�,�>C�?�N[���<�q�>"T8?"�@��
�Ns
������|�?ImK�
(��aA?���>#�?��?6��
Y�^��>S���XĨ>�6���]�<�
�呿��?G�?r�!���#��̣��Ȝ?��?�#�?Pr��֤��\?��h��€>�	K�����v�O�x�dt^?��?�x>�@Z?��?;=*[��b���)ʾ��>�v >�/*���E?��۽�Ⓘ�w�>t<?���>.*1��y�=��=˳���0�?������
+��-�- �>Y�?+�R?+ ?-�$�MF�>�ſ�T�d��?��"��,��l?������>h��?�?Ok�>��T=���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_slice_negative_axes/model.onnx b/onnx/backend/test/data/node/test_slice_negative_axes/model.onnx
new file mode 100644
index 0000000..0cab2e0
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_negative_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dbead81
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d407e45
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..8235cfa
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..0a4bfd1
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3bc16d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_negative_axes/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_start_out_of_bounds/model.onnx b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/model.onnx
new file mode 100644
index 0000000..6695c86
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dbead81
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cd22222
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e69ecf6
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_3.pb b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_3.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_3.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_4.pb b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_4.pb
new file mode 100644
index 0000000..f2b5359
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/input_4.pb differ
diff --git a/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f3f7302
Binary files /dev/null and b/onnx/backend/test/data/node/test_slice_start_out_of_bounds/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_0/model.onnx b/onnx/backend/test/data/node/test_softmax_axis_0/model.onnx
new file mode 100644
index 0000000..7c618a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..af9db83
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_0/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
���>�QJ>�:�>/�
?��>eE�>���>\
�>,��=i�Y>�w>��?�>���=�X�>W�>���>o�T>�&�>��>��?�W�>��f>��=o?� 
?LH>Շ>iQ�>)�?Йz>�3O>�v�>�~?��>��>F��>/?)��>�Ȇ>��>�??��?�J�>�a�=��:>D=�>��>L��>��2>a?rQ>cш>�N�>ꋃ> ��>��=;�j>HG�>x.�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_0_expanded/model.onnx b/onnx/backend/test/data/node/test_softmax_axis_0_expanded/model.onnx
new file mode 100644
index 0000000..8eb69bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_0_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..af9db83
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_0_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
���>�QJ>�:�>/�
?��>eE�>���>\
�>,��=i�Y>�w>��?�>���=�X�>W�>���>o�T>�&�>��>��?�W�>��f>��=o?� 
?LH>Շ>iQ�>)�?Йz>�3O>�v�>�~?��>��>F��>/?)��>�Ȇ>��>�??��?�J�>�a�=��:>D=�>��>L��>��2>a?rQ>cш>�N�>ꋃ> ��>��=;�j>HG�>x.�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/model.onnx
new file mode 100644
index 0000000..560ef20
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..af9db83
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_0_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
���>�QJ>�:�>/�
?��>eE�>���>\
�>,��=i�Y>�w>��?�>���=�X�>W�>���>o�T>�&�>��>��?�W�>��f>��=o?� 
?LH>Շ>iQ�>)�?Йz>�3O>�v�>�~?��>��>F��>/?)��>�Ȇ>��>�??��?�J�>�a�=��:>D=�>��>L��>��2>a?rQ>cш>�N�>ꋃ> ��>��=;�j>HG�>x.�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_1/model.onnx b/onnx/backend/test/data/node/test_softmax_axis_1/model.onnx
new file mode 100644
index 0000000..22bb5a8
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7d71965
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_1/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
�F?u�=�l�>	9?�`?�^v>��N>e�%>n��=��
>o*�=K�>�]�>�ѱ=C>/q
>�
�>�.>
+T�=�ZJ>��(?z�z>P(�>G0>]�?QCa>��>)>>#p�>���>K�u=_>>z;�>~)�>���=�
v=�,�> }�>�8�=�
�=�5�>�>ü?�g�>�ʞ>n9=>&�>�)P>���>��k>|{�>�!>|o>��A>�9D>�c;>#�=�s
>o��=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_1_expanded/model.onnx b/onnx/backend/test/data/node/test_softmax_axis_1_expanded/model.onnx
new file mode 100644
index 0000000..ca36d04
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_1_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7d71965
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_1_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
�F?u�=�l�>	9?�`?�^v>��N>e�%>n��=��
>o*�=K�>�]�>�ѱ=C>/q
>�
�>�.>
+T�=�ZJ>��(?z�z>P(�>G0>]�?QCa>��>)>>#p�>���>K�u=_>>z;�>~)�>���=�
v=�,�> }�>�8�=�
�=�5�>�>ü?�g�>�ʞ>n9=>&�>�)P>���>��k>|{�>�!>|o>��A>�9D>�c;>#�=�s
>o��=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/model.onnx
new file mode 100644
index 0000000..5d18424
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7d71965
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_1_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
yJ�
�F?u�=�l�>	9?�`?�^v>��N>e�%>n��=��
>o*�=K�>�]�>�ѱ=C>/q
>�
�>�.>
+T�=�ZJ>��(?z�z>P(�>G0>]�?QCa>��>)>>#p�>���>K�u=_>>z;�>~)�>���=�
v=�,�> }�>�8�=�
�=�5�>�>ü?�g�>�ʞ>n9=>&�>�)P>���>��k>|{�>�!>|o>��A>�9D>�c;>#�=�s
>o��=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_2/model.onnx b/onnx/backend/test/data/node/test_softmax_axis_2/model.onnx
new file mode 100644
index 0000000..51f7317
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be6015c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_2_expanded/model.onnx b/onnx/backend/test/data/node/test_softmax_axis_2_expanded/model.onnx
new file mode 100644
index 0000000..8a5faef
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_2_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be6015c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_2_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/model.onnx
new file mode 100644
index 0000000..e79fa8c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be6015c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_axis_2_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_default_axis/model.onnx b/onnx/backend/test/data/node/test_softmax_default_axis/model.onnx
new file mode 100644
index 0000000..d0fec32
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_default_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be6015c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_default_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_default_axis_expanded/model.onnx b/onnx/backend/test/data/node/test_softmax_default_axis_expanded/model.onnx
new file mode 100644
index 0000000..d5f715a
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_default_axis_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be6015c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_default_axis_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/model.onnx
new file mode 100644
index 0000000..052b755
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be6015c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_default_axis_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_example/model.onnx b/onnx/backend/test/data/node/test_softmax_example/model.onnx
new file mode 100644
index 0000000..0bda02f
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a00f719
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7bdad0c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_example/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ�a�=�z>;M*?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_example_expanded/model.onnx b/onnx/backend/test/data/node/test_softmax_example_expanded/model.onnx
new file mode 100644
index 0000000..fe0fc03
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_example_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a00f719
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7bdad0c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_example_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ�a�=�z>;M*?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_example_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softmax_example_expanded_ver18/model.onnx
new file mode 100644
index 0000000..51e4da1
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_example_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a00f719
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7bdad0c
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_example_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ�a�=�z>;M*?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_large_number/model.onnx b/onnx/backend/test/data/node/test_softmax_large_number/model.onnx
new file mode 100644
index 0000000..adea591
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_large_number/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..559a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0f9d85e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_large_number/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ �O=�x�=h�r>��$?�O=�x�=h�r>��$?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_large_number_expanded/model.onnx b/onnx/backend/test/data/node/test_softmax_large_number_expanded/model.onnx
new file mode 100644
index 0000000..ebbe2fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_large_number_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..559a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0f9d85e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_large_number_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ �O=�x�=h�r>��$?�O=�x�=h�r>��$?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/model.onnx
new file mode 100644
index 0000000..46288e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..559a11a
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0f9d85e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_large_number_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ �O=�x�=h�r>��$?�O=�x�=h�r>��$?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_negative_axis/model.onnx b/onnx/backend/test/data/node/test_softmax_negative_axis/model.onnx
new file mode 100644
index 0000000..0f37857
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_negative_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be6015c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_negative_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_negative_axis_expanded/model.onnx b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded/model.onnx
new file mode 100644
index 0000000..05d2ef9
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be6015c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/model.onnx
new file mode 100644
index 0000000..d3312be
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be6015c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softmax_negative_axis_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softplus/model.onnx b/onnx/backend/test/data/node/test_softplus/model.onnx
new file mode 100644
index 0000000..4c2f549
Binary files /dev/null and b/onnx/backend/test/data/node/test_softplus/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softplus/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softplus/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softplus/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softplus/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softplus/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0240c64
Binary files /dev/null and b/onnx/backend/test/data/node/test_softplus/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softplus_example/model.onnx b/onnx/backend/test/data/node/test_softplus_example/model.onnx
new file mode 100644
index 0000000..ce4dbff
Binary files /dev/null and b/onnx/backend/test/data/node/test_softplus_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softplus_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softplus_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_softplus_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softplus_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softplus_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..18b7a3f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softplus_example/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�c�>r1?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softplus_example_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softplus_example_expanded_ver18/model.onnx
new file mode 100644
index 0000000..fbdc489
Binary files /dev/null and b/onnx/backend/test/data/node/test_softplus_example_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..18b7a3f
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softplus_example_expanded_ver18/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�c�>r1?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softplus_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softplus_expanded_ver18/model.onnx
new file mode 100644
index 0000000..76fb5d1
Binary files /dev/null and b/onnx/backend/test/data/node/test_softplus_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0240c64
Binary files /dev/null and b/onnx/backend/test/data/node/test_softplus_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softsign/model.onnx b/onnx/backend/test/data/node/test_softsign/model.onnx
new file mode 100644
index 0000000..08a665a
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softsign/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softsign/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softsign/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softsign/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softsign/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a3f7ba6
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softsign_example/model.onnx b/onnx/backend/test/data/node/test_softsign_example/model.onnx
new file mode 100644
index 0000000..08202cb
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softsign_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softsign_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softsign_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softsign_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc3568a
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softsign_example_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softsign_example_expanded_ver18/model.onnx
new file mode 100644
index 0000000..b73a567
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign_example_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc3568a
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign_example_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_softsign_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_softsign_expanded_ver18/model.onnx
new file mode 100644
index 0000000..0d6970c
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a3f7ba6
Binary files /dev/null and b/onnx/backend/test/data/node/test_softsign_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_spacetodepth/model.onnx b/onnx/backend/test/data/node/test_spacetodepth/model.onnx
new file mode 100644
index 0000000..dcdd13a
Binary files /dev/null and b/onnx/backend/test/data/node/test_spacetodepth/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..31fb558
Binary files /dev/null and b/onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ea1db0c
Binary files /dev/null and b/onnx/backend/test/data/node/test_spacetodepth/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_spacetodepth_example/model.onnx b/onnx/backend/test/data/node/test_spacetodepth_example/model.onnx
new file mode 100644
index 0000000..e9e56db
Binary files /dev/null and b/onnx/backend/test/data/node/test_spacetodepth_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..28c6996
Binary files /dev/null and b/onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f71f647
Binary files /dev/null and b/onnx/backend/test/data/node/test_spacetodepth_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/model.onnx b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/model.onnx
new file mode 100644
index 0000000..b4aacf0
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9a9da94
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ae6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..69df4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..645225b
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..bf61976
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_1d_uneven_split_opset18/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/model.onnx b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/model.onnx
new file mode 100644
index 0000000..4534cf5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..733fe68
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f105883
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..8a7fd12
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..8c401e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_2d_uneven_split_opset18/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/model.onnx b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/model.onnx
new file mode 100644
index 0000000..7aef553
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..547a3af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ae6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..69df4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..645225b
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset13/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/model.onnx b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/model.onnx
new file mode 100644
index 0000000..03db4c6
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..547a3af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ae6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..69df4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..645225b
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_1d_opset18/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_2d/model.onnx b/onnx/backend/test/data/node/test_split_equal_parts_2d/model.onnx
new file mode 100644
index 0000000..be44694
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8708fe5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fef1d0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..66077a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_2d/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/model.onnx b/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/model.onnx
new file mode 100644
index 0000000..8994aaa
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8708fe5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fef1d0d
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..66077a2
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_2d_opset13/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/model.onnx b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/model.onnx
new file mode 100644
index 0000000..b12885c
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..547a3af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ae6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..69df4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..645225b
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset13/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/model.onnx b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/model.onnx
new file mode 100644
index 0000000..0be0dde
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..547a3af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ae6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..69df4a6
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..645225b
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_equal_parts_default_axis_opset18/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_1/model.onnx b/onnx/backend/test/data/node/test_split_to_sequence_1/model.onnx
new file mode 100644
index 0000000..59456d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cdb6327
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..59988dd
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..553b542
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_2/model.onnx b/onnx/backend/test/data/node/test_split_to_sequence_2/model.onnx
new file mode 100644
index 0000000..8a5256f
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cdb6327
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4d7246f
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0798b22
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/model.onnx b/onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/model.onnx
new file mode 100644
index 0000000..224942a
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cdb6327
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1400217
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_to_sequence_nokeepdims/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/model.onnx b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/model.onnx
new file mode 100644
index 0000000..b750bdb
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..547a3af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbfc1ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ae6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..7debf1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset13/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/model.onnx b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/model.onnx
new file mode 100644
index 0000000..09342f9
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..547a3af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbfc1ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ae6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..7debf1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_1d_opset18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/model.onnx b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/model.onnx
new file mode 100644
index 0000000..b2e3f13
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8708fe5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbfc1ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6316dcd
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..7c0f7af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset13/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/model.onnx b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/model.onnx
new file mode 100644
index 0000000..7539e71
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8708fe5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbfc1ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6316dcd
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..7c0f7af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_2d_opset18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/model.onnx b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/model.onnx
new file mode 100644
index 0000000..0d80f62
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..547a3af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbfc1ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ae6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..7debf1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset13/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/model.onnx b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/model.onnx
new file mode 100644
index 0000000..66965e1
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..547a3af
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbfc1ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8ae6a5
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..7debf1d
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_variable_parts_default_axis_opset18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/model.onnx b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/model.onnx
new file mode 100644
index 0000000..7589678
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..16d4ac7
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ff7ae24
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..14aa56f
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2f70093
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..f45e84e
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset13/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/model.onnx b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/model.onnx
new file mode 100644
index 0000000..6ac80f6
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..16d4ac7
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ff7ae24
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..14aa56f
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..2f70093
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..f45e84e
Binary files /dev/null and b/onnx/backend/test/data/node/test_split_zero_size_splits_opset18/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sqrt/model.onnx b/onnx/backend/test/data/node/test_sqrt/model.onnx
new file mode 100644
index 0000000..ab4154f
Binary files /dev/null and b/onnx/backend/test/data/node/test_sqrt/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sqrt/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sqrt/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c3a1c95
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sqrt/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z?�8s?b�>hd�=�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R>iJ�>�Z?/d#@�S'?�K]?��=?�C@�(�?Hm;= �?>2�?��?��>���>�Ec?���?�!�>� >*z�?��?�O�>mǚ>�6�?&õ?g�?��?�x?FK�>�[�?�	G?4��?��Y>L=e?�> �?��?k��<QN�>.:�=�ݚ>�b"?6��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sqrt/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sqrt/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..292f9e1
Binary files /dev/null and b/onnx/backend/test/data/node/test_sqrt/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sqrt_example/model.onnx b/onnx/backend/test/data/node/test_sqrt_example/model.onnx
new file mode 100644
index 0000000..dcef8fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_sqrt_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a9e7f45
Binary files /dev/null and b/onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1b32d5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_sqrt_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_squeeze/model.onnx b/onnx/backend/test/data/node/test_squeeze/model.onnx
new file mode 100644
index 0000000..954676f
Binary files /dev/null and b/onnx/backend/test/data/node/test_squeeze/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..09d5a14
--- /dev/null
+++ b/onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ec9874a
Binary files /dev/null and b/onnx/backend/test/data/node/test_squeeze/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_squeeze/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_squeeze/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad67ee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_squeeze/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_squeeze_negative_axes/model.onnx b/onnx/backend/test/data/node/test_squeeze_negative_axes/model.onnx
new file mode 100644
index 0000000..f8804fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_squeeze_negative_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..55c2bdc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


B
xJ<x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ed4b2d0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_squeeze_negative_axes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ<x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_stft/model.onnx b/onnx/backend/test/data/node/test_stft/model.onnx
new file mode 100644
index 0000000..9012054
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_stft/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_stft/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f01c339
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_stft/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_stft/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..daad98f
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_stft/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_stft/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..b8aeb38
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_stft/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_stft/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9c1c13c
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_stft_with_window/model.onnx b/onnx/backend/test/data/node/test_stft_with_window/model.onnx
new file mode 100644
index 0000000..8be4001
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft_with_window/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f01c339
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..daad98f
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..4ddc8ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a5b6fb2
Binary files /dev/null and b/onnx/backend/test/data/node/test_stft_with_window/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_string_concat/model.onnx b/onnx/backend/test/data/node/test_string_concat/model.onnx
new file mode 100644
index 0000000..258e878
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_concat/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_concat/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_concat/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..69329cd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2abc2defB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_string_concat/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6cc32e2
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+2.com2.netB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_concat/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..60d415e
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2abc.com2def.netBresult
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_broadcasting/model.onnx b/onnx/backend/test/data/node/test_string_concat_broadcasting/model.onnx
new file mode 100644
index 0000000..cde5cc9
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_concat_broadcasting/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8dac795
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2cat2dog2snakeB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..9b18dcd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
2
sB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2c1a6b5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_broadcasting/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2cats2dogs2snakesBresult
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_empty_string/model.onnx b/onnx/backend/test/data/node/test_string_concat_empty_string/model.onnx
new file mode 100644
index 0000000..93a0177
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_concat_empty_string/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c15c43b
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1c56d03
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dac25ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_empty_string/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2abc2abcBresult
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_utf8/model.onnx b/onnx/backend/test/data/node/test_string_concat_utf8/model.onnx
new file mode 100644
index 0000000..7ddbbf8
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_concat_utf8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1a8f4f4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2的2中B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8ff819b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+2的2中B
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8975d57
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_utf8/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2的的2中中Bresult
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_zero_dimensional/model.onnx b/onnx/backend/test/data/node/test_string_concat_zero_dimensional/model.onnx
new file mode 100644
index 0000000..610ba8e
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_concat_zero_dimensional/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7d66adf
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2catB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6d237bd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+2
sB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c4842eb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_concat_zero_dimensional/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2catsBresult
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_split_basic/model.onnx b/onnx/backend/test/data/node/test_string_split_basic/model.onnx
new file mode 100644
index 0000000..5a70034
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_basic/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2766575
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2abc.com2def.netB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fed0104
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+2abc2com2def2netB
+substrings
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..ab51a63
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_basic/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/model.onnx b/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/model.onnx
new file mode 100644
index 0000000..c4f1c6b
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..751f726
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2	o-n-n--x-2	o-n----nxB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f39d78f
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..313d76c
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_consecutive_delimiters/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/model.onnx b/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/model.onnx
new file mode 100644
index 0000000..01a9202
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a710bd9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2
hello world !2  hello   world !2 hello world   ! B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..017497d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+2hello2world2
!2hello2world2
!2hello2world2
!B
+substrings
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..9d75a40
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_empty_string_delimiter/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_string_split_empty_tensor/model.onnx b/onnx/backend/test/data/node/test_string_split_empty_tensor/model.onnx
new file mode 100644
index 0000000..ad30769
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_empty_tensor/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0d7883a
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f64ff24
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..11caf82
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_empty_tensor/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_string_split_maxsplit/model.onnx b/onnx/backend/test/data/node/test_string_split_maxsplit/model.onnx
new file mode 100644
index 0000000..3fdd5d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_maxsplit/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c5aabf7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2hello world2def.net2o n n x2the quick brown foxB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..270cc0e
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..0d3afb8
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_maxsplit/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_string_split_no_delimiter/model.onnx b/onnx/backend/test/data/node/test_string_split_no_delimiter/model.onnx
new file mode 100644
index 0000000..303571e
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_no_delimiter/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a710bd9
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2
hello world !2  hello   world !2 hello world   ! B
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..017497d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+2hello2world2
!2hello2world2
!2hello2world2
!B
+substrings
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..9d75a40
Binary files /dev/null and b/onnx/backend/test/data/node/test_string_split_no_delimiter/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/model.onnx b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/model.onnx
new file mode 100644
index 0000000..b022e86
Binary files /dev/null and b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..179b510
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2tuesday2	wednesday2thursdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cdc27a7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_lower/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2tuesday2	wednesday2thursdayB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/model.onnx b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/model.onnx
new file mode 100644
index 0000000..f0dd2e9
Binary files /dev/null and b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..179b510
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2tuesday2	wednesday2thursdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cdc27a7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2tuesday2	wednesday2thursdayB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/model.onnx b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/model.onnx
new file mode 100644
index 0000000..158bc91
Binary files /dev/null and b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..179b510
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2tuesday2	wednesday2thursdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f99dcd8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_export_monday_casesensintive_upper/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2TUESDAY2	WEDNESDAY2THURSDAYB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/model.onnx b/onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/model.onnx
new file mode 100644
index 0000000..4e95034
Binary files /dev/null and b/onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f8443f6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2mondayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fc66148
Binary files /dev/null and b/onnx/backend/test/data/node/test_strnormalizer_export_monday_empty_output/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/model.onnx b/onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/model.onnx
new file mode 100644
index 0000000..dda0e14
Binary files /dev/null and b/onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0b3e995
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
2Monday2tuesday2	wednesday2Monday2tuesday2	wednesdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7db720d
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_export_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
2TUESDAY2	WEDNESDAY2TUESDAY2	WEDNESDAYB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/model.onnx b/onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/model.onnx
new file mode 100644
index 0000000..6f7e783
Binary files /dev/null and b/onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a2b8405
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2tuesdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc7045a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_strnormalizer_nostopwords_nochangecase/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2monday2tuesdayB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sub/model.onnx b/onnx/backend/test/data/node/test_sub/model.onnx
new file mode 100644
index 0000000..50eb77b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sub/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sub/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sub/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sub/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sub/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1424d72
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sub/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ�
^&,�Z��[*P���ܿ3�5>;�;W�п���>�Dh���T=��:?>�ב?������>�O/���^�~/�Ѓ���
f=�#����f?Ok�>��Ŀ�?��?@�?7>8�l��F��?5mξy�?	FU>z?�u�>��4?G,<h��?>�
>���>�?^���A���b*x?�(�����?��Ӿ3Y?��"�?���?,�?��g?Iy\�}�?�7���mM?r?���N4?�l?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sub/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sub/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad0a46b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sub/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
zJ�
��@a|B?w\�?5�}@>V�?�S�k#%@>8�(�M?b��>�����?̸��ҡ�?�*=�]�?"Z@{T�>�?�i�����$}�,�>�HK?�H?�jV���� ���D�&@�n�>=�?�"X��K���F=��K4�~��"�?�_�)��}L4��;�����<߾�;{??�)?�m�C�V�h1�?�[b���ؿi�0����Rj�>��E���u>?����wa�;�>�˟�,y��
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sub_bcast/model.onnx b/onnx/backend/test/data/node/test_sub_bcast/model.onnx
new file mode 100644
index 0000000..651fff1
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_bcast/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..dcbe531
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
B
yJ^&,�Z��[*P���ܿ3�5>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d037b77
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_bcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_example/model.onnx b/onnx/backend/test/data/node/test_sub_example/model.onnx
new file mode 100644
index 0000000..5eefbc5
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..62e4e87
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ce0065b
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sub_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e2d7772
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_int16/model.onnx b/onnx/backend/test/data/node/test_sub_int16/model.onnx
new file mode 100644
index 0000000..52c5b83
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_int16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sub_int16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sub_int16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3871caa
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_int16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_int16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sub_int16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bd30340
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_int16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_int16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sub_int16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8134817
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_int16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_int8/model.onnx b/onnx/backend/test/data/node/test_sub_int8/model.onnx
new file mode 100644
index 0000000..eacc75e
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_int8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sub_int8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sub_int8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..380b166
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sub_int8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ<


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sub_int8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sub_int8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b60d9ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_int8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_int8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sub_int8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3933d29
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sub_int8/test_data_set_0/output_0.pb
@@ -0,0 +1,8 @@
+B
zJ<
+
+	
+		
+
+
+

+
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sub_uint16/model.onnx b/onnx/backend/test/data/node/test_sub_uint16/model.onnx
new file mode 100644
index 0000000..96092e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint16/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a5233c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..6dc2255
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7022a38
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint16/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint32/model.onnx b/onnx/backend/test/data/node/test_sub_uint32/model.onnx
new file mode 100644
index 0000000..214d757
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint32/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d8255a3
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..f0fce0f
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..61c30d5
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint32/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint64/model.onnx b/onnx/backend/test/data/node/test_sub_uint64/model.onnx
new file mode 100644
index 0000000..1d605b6
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a32c354
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..880eddd
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dabc5b3
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint8/model.onnx b/onnx/backend/test/data/node/test_sub_uint8/model.onnx
new file mode 100644
index 0000000..9403754
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint8/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d793e49
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
xJ<


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..fa2e2c2
Binary files /dev/null and b/onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d8d02cb
--- /dev/null
+++ b/onnx/backend/test/data/node/test_sub_uint8/test_data_set_0/output_0.pb
@@ -0,0 +1,5 @@
+B
zJ<


+
+


+
+
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_sum_example/model.onnx b/onnx/backend/test/data/node/test_sum_example/model.onnx
new file mode 100644
index 0000000..dd93a33
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..20406f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e6c4d11
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..81b0033
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_example/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_sum_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sum_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..17070ed
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sum_one_input/model.onnx b/onnx/backend/test/data/node/test_sum_one_input/model.onnx
new file mode 100644
index 0000000..39653d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_one_input/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..20406f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bf4d7ff
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_one_input/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sum_two_inputs/model.onnx b/onnx/backend/test/data/node/test_sum_two_inputs/model.onnx
new file mode 100644
index 0000000..28207da
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_two_inputs/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..20406f1
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e6c4d11
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f7b367c
Binary files /dev/null and b/onnx/backend/test/data/node/test_sum_two_inputs/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_swish/model.onnx b/onnx/backend/test/data/node/test_swish/model.onnx
new file mode 100644
index 0000000..cacddf0
Binary files /dev/null and b/onnx/backend/test/data/node/test_swish/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_swish/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_swish/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f4082e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_swish/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_swish/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_swish/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..39e3b33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_swish/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ��6@Ae{@��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_swish_expanded/model.onnx b/onnx/backend/test/data/node/test_swish_expanded/model.onnx
new file mode 100644
index 0000000..5bfb2ca
Binary files /dev/null and b/onnx/backend/test/data/node/test_swish_expanded/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_swish_expanded/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_swish_expanded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f4082e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_swish_expanded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_swish_expanded/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_swish_expanded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..39e3b33
--- /dev/null
+++ b/onnx/backend/test/data/node/test_swish_expanded/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ��6@Ae{@��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tan/model.onnx b/onnx/backend/test/data/node/test_tan/model.onnx
new file mode 100644
index 0000000..3d0edfc
Binary files /dev/null and b/onnx/backend/test/data/node/test_tan/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tan/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tan/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_tan/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tan/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tan/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e1a4ad5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_tan/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
R������>�R�?=����JQ�f�����?-/�k%ԽF��>��>��A[�s?pm�=�u�>5z�>&PAzU����>s꒿��*?�D?!�?��j��I�����̎;=]�A��T�A�0A��>�h�>�P��P@@!���6k!>��4@��%@��оD����e޿
������@�> �7���RmB���{?Y~�Ap1]��Ο�̛�>pw�ԟ������>�m�=�ğ>xZ<�~R¾
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tan_example/model.onnx b/onnx/backend/test/data/node/test_tan_example/model.onnx
new file mode 100644
index 0000000..f03792d
Binary files /dev/null and b/onnx/backend/test/data/node/test_tan_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tan_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tan_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_tan_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tan_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tan_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..92f2324
Binary files /dev/null and b/onnx/backend/test/data/node/test_tan_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tanh/model.onnx b/onnx/backend/test/data/node/test_tanh/model.onnx
new file mode 100644
index 0000000..15ae7f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_tanh/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tanh/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tanh/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_tanh/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tanh/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tanh/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..33af657
--- /dev/null
+++ b/onnx/backend/test/data/node/test_tanh/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
meq?M��>�@?�Ez?3t?�{@�e=?%���ҽ}(�>&}>L�e?�E$?���=Al�>dŤ>Mqg?�.O�Z@�>�u1�p�|�G�?F�2?De!��z?|�e��K;=�w=��0i?�Bf?�h>��>�5��ov��F��7�>θW?ޙU?�����:����G�
�c�	�o�q�u?#y���Ҿ^\Y�;�&?�yl�7�V�)�6��ļ>�����S����n��>��=7O�>�����
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tanh_example/model.onnx b/onnx/backend/test/data/node/test_tanh_example/model.onnx
new file mode 100644
index 0000000..e882d38
Binary files /dev/null and b/onnx/backend/test/data/node/test_tanh_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tanh_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tanh_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8a94457
Binary files /dev/null and b/onnx/backend/test/data/node/test_tanh_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tanh_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tanh_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0459e73
Binary files /dev/null and b/onnx/backend/test/data/node/test_tanh_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter/model.onnx b/onnx/backend/test/data/node/test_tensorscatter/model.onnx
new file mode 100644
index 0000000..eb8d8be
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..db48f5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..03e026a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a43f589
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..55a6ec7
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_3d/model.onnx b/onnx/backend/test/data/node/test_tensorscatter_3d/model.onnx
new file mode 100644
index 0000000..0025b71
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b907c43
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ef13aff
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..4db8bcd
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..792a1c1
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_circular/model.onnx b/onnx/backend/test/data/node/test_tensorscatter_circular/model.onnx
new file mode 100644
index 0000000..1ba4c46
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_circular/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..db48f5d
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8311f2a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..5c51ba2
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3011037
Binary files /dev/null and b/onnx/backend/test/data/node/test_tensorscatter_circular/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/model.onnx b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/model.onnx
new file mode 100644
index 0000000..65cd6fb
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c13901a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3cac8ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/model.onnx b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/model.onnx
new file mode 100644
index 0000000..063a561
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c13901a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1cf93cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_onlybigrams_skip5/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/model.onnx b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/model.onnx
new file mode 100644
index 0000000..7008601
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c13901a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..caacc10
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_batch_uniandbigrams_skip5/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/model.onnx b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/model.onnx
new file mode 100644
index 0000000..ff76a4a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..26da97a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e536cb1
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_only_bigrams_skip0/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/model.onnx b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/model.onnx
new file mode 100644
index 0000000..66dea1a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..26da97a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..de25e49
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_levelempty/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/model.onnx b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/model.onnx
new file mode 100644
index 0000000..a3ea155
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..26da97a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..38d3b92
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_onlybigrams_skip5/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/model.onnx b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/model.onnx
new file mode 100644
index 0000000..639140c
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..26da97a
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dee2414
Binary files /dev/null and b/onnx/backend/test/data/node/test_tfidfvectorizer_tf_uniandbigrams_skip5/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu/model.onnx b/onnx/backend/test/data/node/test_thresholdedrelu/model.onnx
new file mode 100644
index 0000000..32d9a52
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..785edda
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_default/model.onnx b/onnx/backend/test/data/node/test_thresholdedrelu_default/model.onnx
new file mode 100644
index 0000000..bc48614
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..199a6a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/model.onnx
new file mode 100644
index 0000000..5253df6
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..199a6a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_default_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_example/model.onnx b/onnx/backend/test/data/node/test_thresholdedrelu_example/model.onnx
new file mode 100644
index 0000000..9745441
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..13c6863
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1734d48
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/model.onnx
new file mode 100644
index 0000000..a39594f
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..13c6863
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1734d48
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_example_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/model.onnx b/onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/model.onnx
new file mode 100644
index 0000000..a04631b
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..785edda
Binary files /dev/null and b/onnx/backend/test/data/node/test_thresholdedrelu_expanded_ver18/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tile/model.onnx b/onnx/backend/test/data/node/test_tile/model.onnx
new file mode 100644
index 0000000..536a8dd
Binary files /dev/null and b/onnx/backend/test/data/node/test_tile/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tile/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tile/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7a5f0f8
--- /dev/null
+++ b/onnx/backend/test/data/node/test_tile/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tile/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tile/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..33f6604
Binary files /dev/null and b/onnx/backend/test/data/node/test_tile/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_tile/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tile/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dc79fc5
--- /dev/null
+++ b/onnx/backend/test/data/node/test_tile/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+
B
zJ��	?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>?�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^??�7?�N?w}?H��>?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?��z?��L?G�>��G?�9�=��z?��L?G�>��G?�9�=��#?4�>��q?ڗ?�N�>��#?4�>��q?ڗ?�N�>�s�>.4F?���>�?�<�s�>.4F?���>�?�<\?N�?c�?y�q?Ƌ.?\?N�?c�?y�q?Ƌ.?k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>k�>���>��2?��v=9�*?k�>���>��2?��v=9�*?�+?�nW>A>��>L8�>�+?�nW>A>��>L8�>j�?a��>}?���=��U>j�?a��>}?���=��U>R.%>2'?p��>I��>�Jz>R.%>2'?p��>I��>�Jz>��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=��">]�=7(?�
>�LI>��">]�=7(?�
>�LI>�ɼ>�,R?	��=��V?>��=�ɼ>�,R?	��=��V?>��=?�y?
��>
z?(�?a@=??�y?
��>
z?(�?a@=?a� =̐>�)�=���>�'�=a� =̐>�)�=���>�'�=�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;�΢>G�>�_�=�E1?�?�΢>G�>�_�=�E1?�?"�>��?�c�=;q?[�m?"�>��?�c�=;q?[�m?x�>h�*?�>8a7?	-�>x�>h�*?�>8a7?	-�>��;>�%?���<j5T?�ܙ;��;>�%?���<j5T?�ܙ;b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?b�-?|>�>�5<?�Qv?%�~>b�-?|>�>�5<?�Qv?%�~>?�??�od>\�s??�??�od>\�s?���>=�X?3?�I�>UP?���>=�X?3?�I�>UP?��>��a?M�?i�a?�I1?��>��a?M�?i�a?�I1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tile_precomputed/model.onnx b/onnx/backend/test/data/node/test_tile_precomputed/model.onnx
new file mode 100644
index 0000000..33b2cd6
Binary files /dev/null and b/onnx/backend/test/data/node/test_tile_precomputed/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..188fd6d
Binary files /dev/null and b/onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d57e6d6
Binary files /dev/null and b/onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..449a9c0
Binary files /dev/null and b/onnx/backend/test/data/node/test_tile_precomputed/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k/model.onnx b/onnx/backend/test/data/node/test_top_k/model.onnx
new file mode 100644
index 0000000..ffdd6cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_top_k/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_top_k/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3a5dd6d
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_top_k/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e2082f
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_top_k/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..80bb4fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_top_k/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..d21d603
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_negative_axis/model.onnx b/onnx/backend/test/data/node/test_top_k_negative_axis/model.onnx
new file mode 100644
index 0000000..59b6076
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_negative_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3a5dd6d
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e2082f
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..80bb4fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..d21d603
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_negative_axis/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values/model.onnx b/onnx/backend/test/data/node/test_top_k_same_values/model.onnx
new file mode 100644
index 0000000..a325cc7
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2061215
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e2082f
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f2c4c9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..8bb0da2
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_2d/model.onnx b/onnx/backend/test/data/node/test_top_k_same_values_2d/model.onnx
new file mode 100644
index 0000000..8ce3de5
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9762d13
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e2082f
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3ea1931
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..eb43509
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_2d/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_largest/model.onnx b/onnx/backend/test/data/node/test_top_k_same_values_largest/model.onnx
new file mode 100644
index 0000000..e0a6735
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_largest/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2061215
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e2082f
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f2c4c9a
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..8bb0da2
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_same_values_largest/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_smallest/model.onnx b/onnx/backend/test/data/node/test_top_k_smallest/model.onnx
new file mode 100644
index 0000000..7ceec6f
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_smallest/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..82c518c
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e2082f
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..06b30d0
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..cd82f00
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_smallest/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_uint64/model.onnx b/onnx/backend/test/data/node/test_top_k_uint64/model.onnx
new file mode 100644
index 0000000..c643c98
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_uint64/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5c5b902
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1e2082f
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5c8f240
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..d21d603
Binary files /dev/null and b/onnx/backend/test/data/node/test_top_k_uint64/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout/model.onnx b/onnx/backend/test/data/node/test_training_dropout/model.onnx
new file mode 100644
index 0000000..2fb3db0
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2c1bf8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f66a23b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+	B
tJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dcbd20d
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_default/model.onnx b/onnx/backend/test/data/node/test_training_dropout_default/model.onnx
new file mode 100644
index 0000000..2a02f26
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b5d0231
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f66a23b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+	B
tJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..579996a
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_default/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_default_mask/model.onnx b/onnx/backend/test/data/node/test_training_dropout_default_mask/model.onnx
new file mode 100644
index 0000000..73f140c
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_default_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b5d0231
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f66a23b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+	B
tJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..579996a
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..646972b
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_default_mask/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_mask/model.onnx b/onnx/backend/test/data/node/test_training_dropout_mask/model.onnx
new file mode 100644
index 0000000..7a2cf92
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2c1bf8d
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f66a23b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+	B
tJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dcbd20d
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..c165477
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_mask/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio/model.onnx b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/model.onnx
new file mode 100644
index 0000000..2551754
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a1b82ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f66a23b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+	B
tJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad67ee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_zero_ratio/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/model.onnx b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/model.onnx
new file mode 100644
index 0000000..58821f2
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a1b82ab
Binary files /dev/null and b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..f66a23b
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+	B
tJ


\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ad67ee7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..de98527
--- /dev/null
+++ b/onnx/backend/test/data/node/test_training_dropout_zero_ratio_mask/test_data_set_0/output_1.pb
@@ -0,0 +1 @@
+	B
zJ<




























































\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_0/model.onnx b/onnx/backend/test/data/node/test_transpose_all_permutations_0/model.onnx
new file mode 100644
index 0000000..955346f
Binary files /dev/null and b/onnx/backend/test/data/node/test_transpose_all_permutations_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..36a37a6
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_0/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
+transposedJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_1/model.onnx b/onnx/backend/test/data/node/test_transpose_all_permutations_1/model.onnx
new file mode 100644
index 0000000..abef217
Binary files /dev/null and b/onnx/backend/test/data/node/test_transpose_all_permutations_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6c4bed4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_1/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
+transposedJ`?H��>��v?�7?QY%?rR�>�N?n�>~�J?w}?<Kd?�e?^k?
��<��z?��l?�&U?��L?Z{�=H5G?G�>�p�=�^?��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_2/model.onnx b/onnx/backend/test/data/node/test_transpose_all_permutations_2/model.onnx
new file mode 100644
index 0000000..d4f6b03
Binary files /dev/null and b/onnx/backend/test/data/node/test_transpose_all_permutations_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..931c9d0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_2/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
+transposedJ`?�7?�N?w}?^k?��l?Z{�=�p�=H��>QY%?n�><Kd?
��<�&U?H5G?�^?��v?rR�>~�J?�e?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_3/model.onnx b/onnx/backend/test/data/node/test_transpose_all_permutations_3/model.onnx
new file mode 100644
index 0000000..809f658
Binary files /dev/null and b/onnx/backend/test/data/node/test_transpose_all_permutations_3/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fcc0cd0
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_3/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
+transposedJ`?^k?�7?��l?�N?Z{�=w}?�p�=H��>
��<QY%?�&U?n�>H5G?<Kd?�^?��v?��z?rR�>��L?~�J?G�>�e?��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_4/model.onnx b/onnx/backend/test/data/node/test_transpose_all_permutations_4/model.onnx
new file mode 100644
index 0000000..316ed3d
Binary files /dev/null and b/onnx/backend/test/data/node/test_transpose_all_permutations_4/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c17d014
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_4/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
+transposedJ`?H��>��v?^k?
��<��z?�7?QY%?rR�>��l?�&U?��L?�N?n�>~�J?Z{�=H5G?G�>w}?<Kd?�e?�p�=�^?��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_5/model.onnx b/onnx/backend/test/data/node/test_transpose_all_permutations_5/model.onnx
new file mode 100644
index 0000000..9250931
Binary files /dev/null and b/onnx/backend/test/data/node/test_transpose_all_permutations_5/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cb9b3ba
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_all_permutations_5/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
+transposedJ`?^k?H��>
��<��v?��z?�7?��l?QY%?�&U?rR�>��L?�N?Z{�=n�>H5G?~�J?G�>w}?�p�=<Kd?�^?�e?��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_default/model.onnx b/onnx/backend/test/data/node/test_transpose_default/model.onnx
new file mode 100644
index 0000000..131e4e4
Binary files /dev/null and b/onnx/backend/test/data/node/test_transpose_default/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_transpose_default/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_transpose_default/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d80707a
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_default/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
BdataJ`?�7?�N?w}?H��>QY%?n�><Kd?��v?rR�>~�J?�e?^k?��l?Z{�=�p�=
��<�&U?H5G?�^?��z?��L?G�>��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_transpose_default/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_transpose_default/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cb9b3ba
--- /dev/null
+++ b/onnx/backend/test/data/node/test_transpose_default/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
B
+transposedJ`?^k?H��>
��<��v?��z?�7?��l?QY%?�&U?rR�>��L?�N?Z{�=n�>H5G?~�J?G�>w}?�p�=<Kd?�^?�e?��G?
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tril/model.onnx b/onnx/backend/test/data/node/test_tril/model.onnx
new file mode 100644
index 0000000..d94cee7
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tril/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tril/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tril/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8c3e2fc
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_neg/model.onnx b/onnx/backend/test/data/node/test_tril_neg/model.onnx
new file mode 100644
index 0000000..ba5f543
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_neg/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..987a501
--- /dev/null
+++ b/onnx/backend/test/data/node/test_tril_neg/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
kJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tril_neg/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tril_neg/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d5929cd
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_neg/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_one_row_neg/model.onnx b/onnx/backend/test/data/node/test_tril_one_row_neg/model.onnx
new file mode 100644
index 0000000..c90b476
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_one_row_neg/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cfa55bc
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..acfbd93
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_one_row_neg/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_out_neg/model.onnx b/onnx/backend/test/data/node/test_tril_out_neg/model.onnx
new file mode 100644
index 0000000..db80b43
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_out_neg/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d030429
--- /dev/null
+++ b/onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
kJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6c82a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_out_neg/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_out_pos/model.onnx b/onnx/backend/test/data/node/test_tril_out_pos/model.onnx
new file mode 100644
index 0000000..b712970
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_out_pos/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a86e8a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c3c8fcd
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_out_pos/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_pos/model.onnx b/onnx/backend/test/data/node/test_tril_pos/model.onnx
new file mode 100644
index 0000000..b8b82ee
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_pos/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..93ddef1
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_pos/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_pos/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tril_pos/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..84a768b
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_pos/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_square/model.onnx b/onnx/backend/test/data/node/test_tril_square/model.onnx
new file mode 100644
index 0000000..be3a374
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_square/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tril_square/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tril_square/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1568e16
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_square/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_square/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tril_square/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9affaa1
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_square/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_square_neg/model.onnx b/onnx/backend/test/data/node/test_tril_square_neg/model.onnx
new file mode 100644
index 0000000..359ac50
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_square_neg/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1568e16
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..987a501
--- /dev/null
+++ b/onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
kJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..df10c85
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_square_neg/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_zero/model.onnx b/onnx/backend/test/data/node/test_tril_zero/model.onnx
new file mode 100644
index 0000000..87a2abf
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_zero/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b98f9e6
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a86e8a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_zero/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_tril_zero/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_tril_zero/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8e36092
Binary files /dev/null and b/onnx/backend/test/data/node/test_tril_zero/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu/model.onnx b/onnx/backend/test/data/node/test_triu/model.onnx
new file mode 100644
index 0000000..f0a6a9e
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_triu/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_triu/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_triu/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..094a1f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_neg/model.onnx b/onnx/backend/test/data/node/test_triu_neg/model.onnx
new file mode 100644
index 0000000..35ae23e
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_neg/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..987a501
--- /dev/null
+++ b/onnx/backend/test/data/node/test_triu_neg/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
kJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_triu_neg/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_triu_neg/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8637547
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_neg/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_one_row/model.onnx b/onnx/backend/test/data/node/test_triu_one_row/model.onnx
new file mode 100644
index 0000000..3e08823
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_one_row/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cfa55bc
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e0b32ce
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0744d8e
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_one_row/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_out_neg_out/model.onnx b/onnx/backend/test/data/node/test_triu_out_neg_out/model.onnx
new file mode 100644
index 0000000..3593ec5
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_out_neg_out/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d030429
--- /dev/null
+++ b/onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
kJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c3c8fcd
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_out_neg_out/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_out_pos/model.onnx b/onnx/backend/test/data/node/test_triu_out_pos/model.onnx
new file mode 100644
index 0000000..3e7a6a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_out_pos/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a86e8a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d6c82a9
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_out_pos/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_pos/model.onnx b/onnx/backend/test/data/node/test_triu_pos/model.onnx
new file mode 100644
index 0000000..d352b55
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_pos/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a6f69b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..93ddef1
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_pos/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_pos/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_triu_pos/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..56997dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_pos/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_square/model.onnx b/onnx/backend/test/data/node/test_triu_square/model.onnx
new file mode 100644
index 0000000..1a359bc
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_square/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_triu_square/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_triu_square/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1568e16
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_square/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_square/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_triu_square/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0069cec
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_square/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_square_neg/model.onnx b/onnx/backend/test/data/node/test_triu_square_neg/model.onnx
new file mode 100644
index 0000000..51ad94d
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_square_neg/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1568e16
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..987a501
--- /dev/null
+++ b/onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+B
kJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..303e32d
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_square_neg/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_zero/model.onnx b/onnx/backend/test/data/node/test_triu_zero/model.onnx
new file mode 100644
index 0000000..ef05385
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_zero/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c30a052
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..a86e8a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_zero/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_triu_zero/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_triu_zero/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1975dd0
Binary files /dev/null and b/onnx/backend/test/data/node/test_triu_zero/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_length_1/model.onnx b/onnx/backend/test/data/node/test_unique_length_1/model.onnx
new file mode 100644
index 0000000..722f6bb
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_length_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..82675bc
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8f7688a
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..5a8fa97
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..63eadf3
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..a4dd8f8
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_length_1/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/model.onnx b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/model.onnx
new file mode 100644
index 0000000..d812faa
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f94f9f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..73a7522
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..57e4810
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..03a9fb8
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..ad48f76
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_not_sorted_without_axis/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis/model.onnx b/onnx/backend/test/data/node/test_unique_sorted_with_axis/model.onnx
new file mode 100644
index 0000000..0083689
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5564781
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4111655
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..d679fa0
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..ae8834e
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..8d59403
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/model.onnx b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/model.onnx
new file mode 100644
index 0000000..c169aac
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c682d60
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8fa28ba
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..73c400b
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..2659385
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..5624ec3
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_axis_3d/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/model.onnx b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/model.onnx
new file mode 100644
index 0000000..965f580
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f33ae11
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d06b0dc
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..51a5f28
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..21d3dd9
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..8d59403
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_with_negative_axis/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_without_axis/model.onnx b/onnx/backend/test/data/node/test_unique_sorted_without_axis/model.onnx
new file mode 100644
index 0000000..b237eb3
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_without_axis/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f94f9f7
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..aceca5b
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_1.pb b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..3bbef85
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_2.pb b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..e65e069
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_3.pb b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_3.pb
new file mode 100644
index 0000000..65370a0
Binary files /dev/null and b/onnx/backend/test/data/node/test_unique_sorted_without_axis/test_data_set_0/output_3.pb differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_0/model.onnx b/onnx/backend/test/data/node/test_unsqueeze_axis_0/model.onnx
new file mode 100644
index 0000000..016c1fa
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_axis_0/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ec9874a
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5cfc6be
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_axis_0/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_1/model.onnx b/onnx/backend/test/data/node/test_unsqueeze_axis_1/model.onnx
new file mode 100644
index 0000000..9f175a1
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_axis_1/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..3179943
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..56042ab
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_axis_1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_2/model.onnx b/onnx/backend/test/data/node/test_unsqueeze_axis_2/model.onnx
new file mode 100644
index 0000000..cee708a
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_axis_2/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e8256ea
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4e331e4
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_axis_2/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_negative_axes/model.onnx b/onnx/backend/test/data/node/test_unsqueeze_negative_axes/model.onnx
new file mode 100644
index 0000000..ed0dcec
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_negative_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..55c2bdc
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


B
xJ<x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f4bbd3
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
BaxesJ��������
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4ef93c7
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_negative_axes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



B
yJ<x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_three_axes/model.onnx b/onnx/backend/test/data/node/test_unsqueeze_three_axes/model.onnx
new file mode 100644
index 0000000..ed30eb9
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_three_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7fff38d
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6c8b881
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_three_axes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_two_axes/model.onnx b/onnx/backend/test/data/node/test_unsqueeze_two_axes/model.onnx
new file mode 100644
index 0000000..002a3e2
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_two_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bcf4f4e
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0f34445
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_two_axes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/model.onnx b/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/model.onnx
new file mode 100644
index 0000000..7a0073f
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bae0ffd
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
B
xJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..b22e7e7
Binary files /dev/null and b/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6c8b881
--- /dev/null
+++ b/onnx/backend/test/data/node/test_unsqueeze_unsorted_axes/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+



B
yJ�
x��?h��>��z?�j@$�?�.z��8s?b��hdӽ�9�>(�>�%�?^�B?�0�=B�>]ת>�=�?R�iJ�>�Z�/d#��S'?�K]?��=��C@�(��Hm;= �?�2�?��?��>���>�Ec������!��� >*z�?��?�Oƾmǚ��6��&õ�gڿ��?�x�FKྙ[���	G?4�ο��Y�L=e��> �����k��QN�>.:�=�ݚ>�b"�6���
\ No newline at end of file
diff --git a/onnx/backend/test/data/node/test_upsample_nearest/model.onnx b/onnx/backend/test/data/node/test_upsample_nearest/model.onnx
new file mode 100644
index 0000000..b049f22
Binary files /dev/null and b/onnx/backend/test/data/node/test_upsample_nearest/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..b41f51b
Binary files /dev/null and b/onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..c1adc83
Binary files /dev/null and b/onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..617f127
Binary files /dev/null and b/onnx/backend/test/data/node/test_upsample_nearest/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_where_example/model.onnx b/onnx/backend/test/data/node/test_where_example/model.onnx
new file mode 100644
index 0000000..c380e28
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_where_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_where_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..deccba9
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_where_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_where_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f5057b
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_where_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_where_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..02ce320
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_example/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_where_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_where_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..13d0f88
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_where_long_example/model.onnx b/onnx/backend/test/data/node/test_where_long_example/model.onnx
new file mode 100644
index 0000000..55a58da
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_long_example/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..deccba9
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..567dbeb
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_2.pb b/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..e4d7a0c
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..00461d2
Binary files /dev/null and b/onnx/backend/test/data/node/test_where_long_example/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_wrap_pad/model.onnx b/onnx/backend/test/data/node/test_wrap_pad/model.onnx
new file mode 100644
index 0000000..0efd86d
Binary files /dev/null and b/onnx/backend/test/data/node/test_wrap_pad/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..384f945
Binary files /dev/null and b/onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..131ea5f
Binary files /dev/null and b/onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9dabedb
Binary files /dev/null and b/onnx/backend/test/data/node/test_wrap_pad/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor2d/model.onnx b/onnx/backend/test/data/node/test_xor2d/model.onnx
new file mode 100644
index 0000000..f32e424
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d954177
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..2f37772
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_xor2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_xor2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2ede816
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor3d/model.onnx b/onnx/backend/test/data/node/test_xor3d/model.onnx
new file mode 100644
index 0000000..3746b43
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..402cb45
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..825b4f4
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_xor3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_xor3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5aaed12
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor4d/model.onnx b/onnx/backend/test/data/node/test_xor4d/model.onnx
new file mode 100644
index 0000000..0a83c6a
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3c2fb94
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..925bab6
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_xor4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_xor4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4b38cb4
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast3v1d/model.onnx b/onnx/backend/test/data/node/test_xor_bcast3v1d/model.onnx
new file mode 100644
index 0000000..447f9d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast3v1d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5cc32fe
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1500686
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..191b7b0
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast3v1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast3v2d/model.onnx b/onnx/backend/test/data/node/test_xor_bcast3v2d/model.onnx
new file mode 100644
index 0000000..e83e4af
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast3v2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d784193
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8bab0d3
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..dadeaaa
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast3v2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v2d/model.onnx b/onnx/backend/test/data/node/test_xor_bcast4v2d/model.onnx
new file mode 100644
index 0000000..c930bbf
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v2d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..22944e3
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..d7cba2c
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9266653
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v3d/model.onnx b/onnx/backend/test/data/node/test_xor_bcast4v3d/model.onnx
new file mode 100644
index 0000000..ae23efe
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v3d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..70f33b9
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..7e83c14
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..854b39a
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v4d/model.onnx b/onnx/backend/test/data/node/test_xor_bcast4v4d/model.onnx
new file mode 100644
index 0000000..2d6d17b
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v4d/model.onnx differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_0.pb b/onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..024a348
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_1.pb b/onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..8e18502
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/output_0.pb b/onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bb78baf
Binary files /dev/null and b/onnx/backend/test/data/node/test_xor_bcast4v4d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/model.onnx
new file mode 100644
index 0000000..a61f144
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e0b0a85
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
J�
����_��?}j��QT���3�n���=��?��!@�>��>�Q?��f�? ��>�Ku=@f"=7
�>[�y?��r��p��A˘�k�>�ޢ?{.r>7�@�|ѿ�E��^��?ՏȾ��=
�?��̿�Nd=��ྥ�2Z�>I��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..03fd37f
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
JH��=��^	�a4�>
+��>{�>�Lt>�Y^>gl�����V9C?��?Nt����>�N�>Y�E��5���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/model.onnx b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/model.onnx
new file mode 100644
index 0000000..a61f144
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..197e186
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0fbcdcd
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_AvgPool1d_stride/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
JH}�?���>�X?�,�}���}+��ǀ��ž��?����Sd���>)���@�"�p9J�r�?�)?f��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/model.onnx
new file mode 100644
index 0000000..c78cd2f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7dcb965
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fd330e3
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/model.onnx b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/model.onnx
new file mode 100644
index 0000000..c78cd2f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0240b9e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3cd0ca3
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool2d_stride/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/model.onnx
new file mode 100644
index 0000000..c63e3f7
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..35b2395
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..106cb68
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/model.onnx b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/model.onnx
new file mode 100644
index 0000000..4ca534c
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ab216b1
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d1cd503
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
J�
�bҽ�#?G	�=?}���\�?ا>n�J=T0r>�^�>'��>��=�5��5��=�ʚ>9�Z>��ž���rl�`���n�� s���+�|�r=/f��~��R������(����<��[�:�>_w�>a�2�	��=���>��6?L�>��>b��l�����>��%�#X~=��>��,�<
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/model.onnx b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/model.onnx
new file mode 100644
index 0000000..7a7de25
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1e043b4
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f0a24db
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_AvgPool3d_stride1_pad0_gpu_input/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
J�
e8���L���;A��p�\3�>g}%>q�A>S��>?���a*<�;
+�_���(ͽ�A�<��>��C�5�?�;�>���>�.�>��>ۖ�>�B�>Vp>G\�>$u�>떣>�m
+>oȋ>�w�>q��>YU>\@�<U�>nq����Z���;��=Pἂjd<��
?�<>�N>ko
= ��>ƍ�=r[>-�Q=
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/model.onnx b/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/model.onnx
new file mode 100644
index 0000000..72e5c03
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7e38106
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d080c14
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_BatchNorm1d_3d_input_eval/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
J�
*F�>Fr�>�\�aX?��ݾ��>���<�5?b�#��Q=ˀ�<���=rH�<�U�����E���s'7��y�>y���P��>���=��d?���?��ֽ"v��D_��VJ���p�<R=����g�`�D>}�ʽ�i?=�>��1?�%�>����g��-�=چr<wW��~��[�=Jhe��D�=�!2�U�
��=�����WU>�e"?���<&p=�
��c��<}:�;�(�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/model.onnx b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/model.onnx
new file mode 100644
index 0000000..c48391d
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1797472
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c39a86e
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_eval/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
J�L�+���U���0?���?B"��!O����>�J�"W1?u�-��x�=�>?�K�?8�=�},?�gk�LJ���z�2��?FdD><��=�Ѧ>&)?�X�808���g�����ʩ/?�pY�	�?��q��ꤾ	�B=�/�����?n.�> 8������"�M��R�>:�3�m����Ph�-���`ʽ���= ��>CK
?S���!��>֖�>/�:=�L�=_�¿�Yo>׼�>O��+�%�=ㅫ�=t�=��?����Кq={�#?���>�_��#T��=_l�>&y?2�7> 0ξK͕�C^=��*km?��d>�p�:�����oH��G4>�r>�)�=��7��L�>��<ߑ	�}J�>u�>| ��$?��o?�K�>��;��վN�?�zӽ�s�MgQ�@0��G�?��C?h���e9�Ags>8v@������?�y(?sX?U}��F�����U��
+1���1���?�d�?�>�b��Cq����=O��>+@&?_տ�_6E?-Y�hȭ?�`	�6��>����_�ܾ�g<����(!>��d?49���2����>��?w��>�F?�����_n?Qbr?�Δ>�#�?�U:���¾�5?0Dd>�n>4�T?b��?���IRZ�F����"?��;\4�>�ξ�O�>SU	?~�j��.�`4?���=(�?�S�?�E?&��d����=����!��q?��@>*��>
��>�Ϊ���k�&!�>�龳SL=��X>�Ɗ>U ?Zp*�G?�`��"=������<��mb��ﳮ�&H�>�>����>�Տ�
*�1f�=9 �
+��=��H�7�����ʽ��#�0b�>E�=�0���6:?�=
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/model.onnx b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/model.onnx
new file mode 100644
index 0000000..ac74d9e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..aef7a40
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6c4c145
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm2d_momentum_eval/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/model.onnx b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/model.onnx
new file mode 100644
index 0000000..4e4dcd4
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..af6f3f5
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a3dba04
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_eval/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/model.onnx b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/model.onnx
new file mode 100644
index 0000000..bb99ae8
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..48d2edc
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7d83957
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_BatchNorm3d_momentum_eval/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/model.onnx
new file mode 100644
index 0000000..e5f864b
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..57c22a7
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4ba361f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ConstantPad2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv1d/model.onnx
new file mode 100644
index 0000000..f9734dc
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f8b50b0
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..26464d7
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/model.onnx
new file mode 100644
index 0000000..15e7716
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9f0198e
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
+
J��ZY>�����0a�i����N�3��?[�S��{�?c���¾�a?L"�>
�?�6?��?~Az?R瀿�y��3�/>w�@�ο���>�̾�pƑ�%�>���3��=|�������?}$��
�?����;�򔭿�^��L[?s�>jI >�N.�5��;��(�sd��bz?O?���z��߿f��>�>-����>�"�>�&�>����e�/>(v��?g�GX�=i�]+�?V�?2�-����ي0���I>N�6?�X,��ۧ?�M<?�t!����=O
��>
�ҾHλ?9�e�ࢠ���>���g<��
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8e8c8ee
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_dilated/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/model.onnx
new file mode 100644
index 0000000..c94c054
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..42b05e7
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3ca2280
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_groups/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/model.onnx
new file mode 100644
index 0000000..f67f087
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1921dc0
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a01d23d
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/model.onnx
new file mode 100644
index 0000000..a4952d6
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/model.onnx
@@ -0,0 +1,31 @@
+pytorch0.3:�
+f
+
0
+
1
+
2
3"Conv*
+	dilations@
�
*
+group
�
*
+kernel_shape@�
*
+pads@
@
�
*
+strides@
�
torch-jit-export*�

B
1J�
�F>,�Ƚ��
+���z�:�I>��P<�!�=���b=N��Ӽ��>���>}�?�/9J��2'����
+�>�7�<��������#%=x1h=h�T=��)="�><��=��R���pMH��>��&>�ۗ;@��xN�=G���%>46>�W^>�Y!�s){���[��ՠ=̂�=6\��ab>���=�!�>*
B
2JH�$>��u>!!��'0�Z
+
0
+

+

+
+
Z
+
1
+

+
+
+Z
+
2
+
+

+b
+
3
+

+

+
+
B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3ca9bc7
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


J˗?B��̟����
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8d22eed
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad1size1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


J������7�I�Ⱦ\�e=
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/model.onnx
new file mode 100644
index 0000000..6cad902
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9ce039a
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/input_0.pb
@@ -0,0 +1,4 @@
+
+
J��(v=Z���Wn:�
+���\��>+m�>|1�t�)�w������)1��;߿w�>��?r�پ)�)?���ŧ^?}"����ʿ�i��ÔG?�e?;j?�¾�*�?�슾x�^?��5�
+�������bξ[�>2�[?��?�!&?&v��j*�?8~?�W?���?��?\�?Q�n>\n<�f뾊q���5??�Ͼ�&E���w���2=�~Ӿw�ǿ�F�?��?�Տ=�O�����L��>�5>R���{�?/}8����5t�?�g�=�T6?�Z��αE����ג�;���v�>J�>�Ǿ�$�>����b�?�!�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..86801f6
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/model.onnx
new file mode 100644
index 0000000..f4c699d
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4582b04
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+


J�v7����Z�>���?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3db772d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv1d_pad2size1/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


JVrA��K�>Xe@�l�]=
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/model.onnx
new file mode 100644
index 0000000..3b3b334
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..805c053
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1c4d08e
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv1d_stride/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
J�
D��>d
g�B45?,�l=��>}��?2J?qp<��U��y��ܺ1�~?�Hv��i�����`�ӾRA��T�)����t">t����N?�"�d>et?���>(�^>hPb=�Pn?f��64�>��.���?]���+\�HR$��䁼0�6�0���h�D�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d/model.onnx
new file mode 100644
index 0000000..8d726dd
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..796ab0d
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..aaced42
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/model.onnx
new file mode 100644
index 0000000..38bb364
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..040d7b6
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a370707
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/model.onnx
new file mode 100644
index 0000000..4f945f0
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..07c64eb
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b1f7a35
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_padded/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/model.onnx
new file mode 100644
index 0000000..1124f00
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..730c1a1
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ccd62e8
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_strided/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
J�
4��������~�ll�=�`���H�=X��<r齋�t>0�Q<���<	�Y?��>:��=��^�r��=|;�><���~!���~>�6	�G�&>o޷>�?ʳ彘�$<�(��P=���>�#�>z2#�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/model.onnx
new file mode 100644
index 0000000..964382a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5b8e465
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..621ce66
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_depthwise_with_multiplier/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/model.onnx
new file mode 100644
index 0000000..21e16f2
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5f8b5ca
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..be46da4
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_dilated/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/model.onnx
new file mode 100644
index 0000000..d70fea2
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0d40425
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c1539b0
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/model.onnx
new file mode 100644
index 0000000..e22d875
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f1b2fde
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..25c8320
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_groups_thnn/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/model.onnx
new file mode 100644
index 0000000..29dc21b
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cfdddd4
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
J�1{e�����I(������?�2�?ɂ���R��d`>
S#�E�?���>�)s>)��>�쀿C�I�&	W@|?kLA@���>�1ֿSĐ>k����?����d&�
+#?�:w�ף���D��R�N��_{�<,7?�u7?�mW?�X���+�?5��N�^?ͪ?�	@_H?�Y�>3<�?��'?�:U�ս���x?
\�?A۹�85���7�>�?�J�m\�?����w֍�I̿���?�I�>�2|?���>l䏿��?�Ő�r�=��2��VF>���>��)�@�忰��?��	���?ӛ����8����?'p?uԍ>�����Ph=�wc����D�%���J���̿5IU=(�d>��B��/�>�)s�B�>;���1�ɿLۿ�A1?�p�>�}?>+�	��@7�>�>>@��V?��_��۴�$�?��@�Δ�Ȟ?�Vy�k�\<��$�
���2�f�ھ����
+>·�?a��>�Q���@��X;�Z?5��>�UR>Q)�
Q��
�J?�K>�
����>��{?�u�ן:=0ZN���]>���?O��>����iC�>�7�=	�|?�8��󾪾�6?T�1?���:M;>�X�>���?�ӾB�Ͽ���>�F���1���)ÿY�?�쾻?���?{������?��a?G����EQ=�c�>�0?nX@?��J=UIY?4q:�M��>�ɒ�>�
?�tԿ��ΞK?q�t��׿��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..81e66f3
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_no_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/model.onnx
new file mode 100644
index 0000000..40a5574
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..12dded9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..25cda76
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/model.onnx
new file mode 100644
index 0000000..688189e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fc3f7a3
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..664b0a3
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv2d_strided/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
J�
��.g?���Λd?d�>���b�?��#?Z�羾o���㺾��@����>r�L>���?��Q>j
+�`p��8�N�I:1���?|��>�W?�{�=~��?X�+?@�;X
+t?�\�j��?J�|>��Y�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv3d/model.onnx
new file mode 100644
index 0000000..4ed6910
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..31459d9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..400829c
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv3d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
J�g�l��aI?�Ѿ�d:?$7=�����r{�vc�?%�j��
>S�ƾ�޾���=����5�>J�����=r�@���'?��W?t@����?:�>��S?�Ѿ�ډ>P�V>'C�=j��ӹ?����̂Ͼ�#�>2Ǿ^����Y�h]g?�#��0��>�o��|hY�F™<>��r�L?l0{?j��n?j����I6?���>ڿ>
��*ώ���?.�T�qQ<?�Y(??x>^!�?��=�{ɾ~�h��'\?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/model.onnx
new file mode 100644
index 0000000..71b9899
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..53e728a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9b543bd
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/model.onnx
new file mode 100644
index 0000000..3ffa618
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..06d839e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..66cd9ff
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_dilated_strided/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/model.onnx
new file mode 100644
index 0000000..5192555
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..dade2b9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a472744
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv3d_groups/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
J�e�v=&�����>��S?wXt���>`��:��A����G�s?�)|����-��=@��>�|>?h�>��>0���!d>��U=G�>j��>�*�>zq;�����ҹ�T���*]<�a�>e>֬����>*y����
?���=���beK>�d5�	?QGҾ��G��&l����=��0>
�<4��>⯖�7��>��B���=�$�ڽ��D<�a��Y��3�>c�?7/�����=�C�=s.��>>X��>�q�}��>����e>��S�����{��>��?�;�׼q{�=�s>�mY�>�=�0ü�ݺ�Me�=p�>���=+'c��o%���L���߽(�?6�>�Mо�9�>�C�>2��=���=^�fx���>(�W?��J�	��>ٶ1>��&�D)�=��H�Q���+��7��pl>�Kv��)�=��龬Yf���B>��>�i��DH>���>�G�>h镽/��=��f�t+M���=}��#?Đ�������(�_�R���>��g>��H~?�ľ����@Ͻ�K�%Z�>�`�=X�#�V�f=E��>�3!?Ngc=1j?�.�>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/model.onnx
new file mode 100644
index 0000000..c673034
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e5e14f4
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..421613c
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Conv3d_no_bias/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
J����y�����=�Ij=

+?��q����=��3>�M⾂k�>��������H���=.?uľV�+>���=��ݾr��>�U>}vv����:>�5>�!?1�����;=��?�.���p��~b�|5K�p��?9�>�N}��8#?����>I��>)Ⱦ�⏁<~�ƽ�NH?�)M=�UF<{�׼0�?;
S?�������D��=P]?n��=��>��)��|H�7B��:W@?]G���z?cp���^>h/ľ
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/model.onnx
new file mode 100644
index 0000000..8f23c1a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5c9d07b
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..32988e5
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/model.onnx
new file mode 100644
index 0000000..d4b4021
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..664147e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..db2ecc8
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Conv3d_stride_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/model.onnx
new file mode 100644
index 0000000..63a9e92
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cc0efbf
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1638dbe
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/model.onnx b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/model.onnx
new file mode 100644
index 0000000..00dd792
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..77f7709
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6ff7064
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ConvTranspose2d_no_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ELU/model.onnx b/onnx/backend/test/data/pytorch-converted/test_ELU/model.onnx
new file mode 100644
index 0000000..06ea9da
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ELU/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..22f9b86
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
JxUÑ?��.>u�??� ?(t?�7�[	˿�!>��v��\����m?�ќ>xH���x��<l�X��B>D!��
�����5F���~��荾`���?�xU?���
u��֎�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a0c07ed
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_ELU/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
JxUÑ?��.>u�??� ?(t?������˿�!>r	���&�ȯ���m?�ќ>vڿ#Yܾ�C��BF���B>b�w,�� D\�y���J��w���B�R��?�xU?���������
�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Embedding/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Embedding/model.onnx
new file mode 100644
index 0000000..c34571d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Embedding/model.onnx
@@ -0,0 +1,17 @@
+pytorch0.3:�

+
+
1
+
0
2"Gathertorch-jit-export*;
B
1J0��>O�Ǿ����?4B�?���>��L��VX?���>`�?j�����>Z
+
0
+
+

+Z
+
1
+

+
+b
+
2
+

+

+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9ad4256
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9827178
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Embedding/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

J0��>O�Ǿ����?4B�?���>��>O�Ǿ����?4B�?���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/model.onnx
new file mode 100644
index 0000000..c1b34d5
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/model.onnx
@@ -0,0 +1,17 @@
+pytorch0.3:�

+
+
1
+
0
2"Gathertorch-jit-export*;
B
1J0"K����忌��?E7�?�+;�����f?�~@�E�>����g���]<Z
+
0
+
+

+Z
+
1
+

+
+b
+
2
+

+

+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9ad4256
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..50e7a0e
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Embedding_sparse/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

J0"K����忌��?E7�?�+;���"K����忌��?E7�?�+;���
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_GLU/model.onnx b/onnx/backend/test/data/pytorch-converted/test_GLU/model.onnx
new file mode 100644
index 0000000..20e4f68
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_GLU/model.onnx
@@ -0,0 +1,17 @@
+pytorch0.3:�

+&
+
0
1
2"Split*
+axis���������
�

+
+
2
3"Sigmoid
+
+
1
+
3
4"Multorch-jit-exportZ
+
0
+

+
+b
+
4
+

+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0844973
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2450672
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_GLU/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_GLU_dim/model.onnx b/onnx/backend/test/data/pytorch-converted/test_GLU_dim/model.onnx
new file mode 100644
index 0000000..5c09745
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_GLU_dim/model.onnx
@@ -0,0 +1,19 @@
+pytorch0.3:�

+
+
0
1
2"Split*
+axis
�

+
+
2
3"Sigmoid
+
+
1
+
3
4"Multorch-jit-exportZ
+
0
+

+
+
+b
+
4
+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fb60a4e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e867885
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_GLU_dim/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/model.onnx b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/model.onnx
new file mode 100644
index 0000000..f76bccb
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/model.onnx
@@ -0,0 +1,15 @@
+pytorch0.3:h
+"
+
0
1"	LeakyRelu*
+alpha
+�#<�

torch-jit-exportZ
+
0
+

+
+
+b
+
1
+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bf61309
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..52c6ddd
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
JxR(�>eF���|)�<�M��>����l�^�M?���?y��?�����J!?�f�?�td�����K�
Q�?�����]0?Y��?��
>JŠ?K�,�;ə�.E��^��?}k���i�>Ӥ�?�o<�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/model.onnx b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/model.onnx
new file mode 100644
index 0000000..2179d51
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..709beb5
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
Jx;Eȿ�M�����"V�;� ��>�?
+t �s�v?Dɒ?�59>���=G�?M1��T�?!e�??X�=�dS��Z�?w>�?B�?�󳿺u�Dw>T:�>m�x? Q?�'?��ž!~&�=q�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6680542
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_LeakyReLU_with_negval/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
Jx;EH��M����x�"V�;����>�?
+t��s�v?Dɒ?�59>���=G�?M1���T�?!e�??X�=�dӾ�Z�?w>�?B�?��3��ua�Dw>T:�>m�x? Q?�'?��E�!~��=q��
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Linear/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Linear/model.onnx
new file mode 100644
index 0000000..cb2d07e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Linear/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..74eb4dd
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/input_0.pb
@@ -0,0 +1,3 @@
+
+
J�
�P8?��@�=��J���>`�?�z?�a�?|B��[�=�db���˽I0?DB���G���J�>�KϿ>,�?D=?��ǰԾ�<?��u�"�C@��t�Ñ�?��>��U=�
R?b�3?���
+U��,��`��>�}?/)+?�{��o�?CU>>ނ��
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8b63e16
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Linear/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/model.onnx
new file mode 100644
index 0000000..0eec363
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1ee643b
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..27e6172
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Linear_no_bias/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/model.onnx b/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/model.onnx
new file mode 100644
index 0000000..d2873a7
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/model.onnx
@@ -0,0 +1,15 @@
+pytorch0.3:]
+
+
0
1"
+LogSoftmax*
+axis
�
torch-jit-exportZ
+
0
+

+
+
+b
+
1
+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..feb3a96
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5ebe29f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_LogSoftmax/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/model.onnx
new file mode 100644
index 0000000..f13f33f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3e9a9c1
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e9a1974
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
+

JPvjF>��x�a
+?��>�?��P?M*�?	;@�̀?P+@�L�?��!?���>vxt?�,?<Rb?�>�v�>��?��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/model.onnx b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/model.onnx
new file mode 100644
index 0000000..f13f33f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4f1303d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/input_0.pb
@@ -0,0 +1,4 @@
+
+
J�>@�?S��Ѓ�?�dm��)!??2C���;��}�
+	޾��!>R�n=$���tnS?0�?2n>?y�XW�>I�B?����lN�5��>���?��?�����)�����7�U%5=/��>4�	=ZWپ��]�ME��<��gl�?
+e���}@��оY*�=Ȑ`�ߗ��/Z��j
?q�>#~9?�՛�@.��|?E>~O��3\��л����q<�>�ǫ>���9��
b�KF�M�?+}����?$�>t5?�.d�N"@�~��$����=��n?�b@5��j�ɿ;�}��4�\��������_�@Q���
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1a55ea3
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
+

JP>@�?�)!?��!>0�?I�B?���?U%5=/��>gl�?�}@j
?#~9?|?E>q<�>M�?���?N"@�b@�4�_�@
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/model.onnx b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/model.onnx
new file mode 100644
index 0000000..55d8627
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/model.onnx
@@ -0,0 +1,19 @@
+model:�

+V
+
X
Y"MaxPool*
+	dilations@
+�
*
+kernel_shape@�
�
*
+pads@d@d�
*
+strides@
+�
graphZ
+
X
+

+

+

+�
b
+
Y
+

+

+

+��
B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..404980a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..55cbd61
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool1d_stride_padding_dilation/test_data_set_0/output_0.pb
@@ -0,0 +1,154 @@
+

��

J���o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?�o?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?*�?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?./?u{?u{?u{?u{?u{?u{?u{?u{?u{?u{?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?�J?V�~?V�~?V�~?V�~?V�~?V�~?V�~?V�~?V�~?V�~?V�~?V�~?V�~?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?"�{?
+{?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|?�|? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �? �?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?�t?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?h�y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?.�?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?r(~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?ݐ~?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?I�z?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?????�O?�O?�O?�O?�O?�O?�O?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?Nh?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?R�~?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?c�?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?x{?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z?>�z? _}? _}? _}? _}? _}? _}? _}? _}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?A�}?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?Of?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?-�}?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?\ ?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?�x?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?~�}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?.)}?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?{~?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?݆?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?�x}?6}?6}?6}?6}?6}?6}?6}?6}?6}?6}?6}?6}?6}?6}?6}?6}?6}?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?,�~?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?Z?~?~?~?~?~?~?~?~?~?~?~?~?~?~?~?~?~?~?~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?�|~?~?~?~?~?~?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}? }? }? }? }? }? }? }? }? }? }?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?U�?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?P'?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�R|?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?dPz?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?w�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?0�?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?�N~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?U~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?Ӂ~?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????�d|?�d|?�d|?�d|?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?/}?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?e-?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?|�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?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�?VC?VC?VC?VC?VC?VC?VC?VC?VC?VC?VC?VC?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?:~?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?3�}?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?>q?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?'?�}~?�}~?�}~?�}~?�}~?�}~?�}~?�}~?�}~?�}~?�}~?�}~?�}~?�}~?�}~?�}~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?U�}?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?�r|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?Y|?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?;�?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?&?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�:?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?�r?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?6J~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?�3~?v}?v}?v}?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?
�?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?1Z?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?E
+~?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?��{?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?k
?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?WZ?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?�U?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?�-?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?s~?s~?s~?s~?s~?s~?s~?s~?s~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?f�~?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?چ?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?�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?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?6i?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?�G?��|?��|?��|?��|?��|?��|?��|?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?1F|?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�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?1�}?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?y{?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?c�~?�Y|?�Y|?�Y|?�Y|?�Y|?�Y|?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?T�?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?�J~?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?x}?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?Ǹ{?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?L:?�X|?�X|?�X|?�X|?�X|?�X|?�X|?�X|?�X|?�X|?�X|?�X|?�X|?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?I}?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�R~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?�9~?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?o4?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?#?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?��y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?
+�y?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��|?��{?��{?��{?��{?��{?��{?��{?��{?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�c?�c?�c?�c?�c?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�]?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?q�?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?]�}?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?�9?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?6�?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?�v?O�}?O�}?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?D?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?�;z?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?}�|?��~?��~?��~?��~?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?�T?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?M}?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~?$�~??????????????????????????????????????????????????????????????Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?Lp?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?�K?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?w�{?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?��z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?̺z?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?�s~?�s~?�s~?�s~?�s~?�s~?�s~?�s~?�s~?�s~?�s~?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?D�|?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?�L~?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?n�{?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?!?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?F�?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?��~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?M�~?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?c�}?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?��}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?��{?��{?��{?��{?��{?1�z?1�z?1�z?1�z?1�z?1�z?1�z?1�z?1�z?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?�}?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?9�~?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?�Q?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?��?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?�~?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?f?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?D~?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/model.onnx
new file mode 100644
index 0000000..2623bfa
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/model.onnx
@@ -0,0 +1,18 @@
+pytorch0.3:�

+K
+
0
1"MaxPool*
+kernel_shape@@�
*
+pads@
@
@
@
�
*
+strides@@�
torch-jit-exportZ
+
0
+

+

+
+
+b
+
1
+

+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7bdc39a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7e9c172
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/model.onnx b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/model.onnx
new file mode 100644
index 0000000..9dd1d96
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/model.onnx
@@ -0,0 +1,25 @@
+model:�

+_
+
X
Y"MaxPool*
+	dilations@
+@
+�
*
+kernel_shape@<@P�
*
+pads@
+@@
+@�
*
+strides@
+@
+�
graphZ
+
X
+

+

+

+�
+�b
+
Y
+

+

+

++
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..95b500e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..245275b
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool2d_stride_padding_dilation/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

+
J�!L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?L�?L�?L�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/model.onnx
new file mode 100644
index 0000000..c4e7ff9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..38cb6ec
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b9a9377
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
J�
���?�@@ն�?�6�?�r?,2�?�ov?���?銐?<$�?�sh?}o?M}�?�j?�Ņ?��q?m��?���?B��?r�`@jG@D�?�/?��?^�a?gѡ?���?]��?��t?-4@0�?�H@>��?R�@�Y@	�@7�b?���?�;�?���?�۲?�k�?}F�?�i@��?�с?���?�	@
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/model.onnx b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/model.onnx
new file mode 100644
index 0000000..c4e7ff9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c02235e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4d6265a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/model.onnx b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/model.onnx
new file mode 100644
index 0000000..800a943
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/model.onnx
@@ -0,0 +1,20 @@
+pytorch0.3:�

+S
+
0
1"MaxPool*
+kernel_shape@@@�
*
+pads@
@
@
@
@
@
�
*
+strides@@@�
torch-jit-exportZ
+
0
+

+
+
+
+
+b
+
1
+

+
+
+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0c06719
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8788f48
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_MaxPool3d_stride_padding/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/model.onnx
new file mode 100644
index 0000000..845140f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e1ef88b
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..51f7449
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/model.onnx b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/model.onnx
new file mode 100644
index 0000000..22ef010
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6fc59db
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/input_0.pb
@@ -0,0 +1,2 @@
+
J`0�m�|���0]�i�=������H����?�q>i�<�ݿ޿i>?��`=X1�u~!>	�־����
+����>��$��p@�f�>�/��5~?��(�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f337dc9
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_PReLU_1d_multiparam/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
J`0�m�|���0]�i�=������H����?�q>i�<�ݿ޾i>?��`=X1�u~!>	�ֽ����
+����>��$��p@�f�>�/��5~?��(�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/model.onnx
new file mode 100644
index 0000000..9c9569f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7d2bcfa
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/input_0.pb
@@ -0,0 +1,3 @@
+
J�o�U�,�?���np�����Etk����>$7��M(ÿi�+?.S�?3�'?��S?d(��?Z�<�@���׾�E��pKd�B9?�Y�d��=큺�l�Ǿ�6
+�fE@Mbo�`�־`��?��ٿ(l���J>��_�>�X��,����?]5
�_��8�N�4@,w�=�,�?h�&�b�����
+@Y�p�1˅�[07��rҼ^S2>�28?G1E�e�@���(^p?�K�>�YȾ�(^�j	@�EV?�%(���.�^��k�-?�69?8�����?�3>�^����=���?�H���OK�st���7�b�;�F��>Zs��;?_P��
��fb��f�?1R�>���>�:��߭��z�?_mp=�Q��x�l�F`����,�C�?AO�?�����!�̨�?]��?ɜ,�h폾G��>U1�?Yo�=h"@t�L?��9?����OP?]�?b�=��(���L>)Ӎ>+]����[��}��
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e64acb3
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
J�o�U�,�?���np�����Etk����>$7��M(þi�+?.S�?3�'?��S?d(��?Z�<�@���׽�E��pKd�B9?�Y�d��=큺�l�ǽ�6
+�fE@Mbo�`�ֽ`��?��پ(l���J>��_�>�X��,����?]5
�_��8�N�4@,w�=�,�?h�&�b�����
+@Y�p�1˅�[07��rһ^S2>�28?G1E�e�@���(^p?�K�>�YȽ�(^�j	@�EV?�%(���.�^��k�-?�69?8�����?�3>�^����=���?�H���OK�st���7�b�;�F��>Zs��;?_P��
��fb��f�?1R�>���>�:��߭��z�?_mp=�Q��x�l�F`����,�C�?AO�?�����!�̨�?]��?ɜ,�h폽G��>U1�?Yo�=h"@t�L?��9?����OP?]�?b�=��(���L>)Ӎ>+]����[��}��
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/model.onnx b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/model.onnx
new file mode 100644
index 0000000..7514db5
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..66574fa
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/input_0.pb
@@ -0,0 +1,3 @@
+
J��??
�?�����?;Y����;S3�?���>?�`�ǡs�K��{�5�!�)�����
H��-R?�?��־̯�>ʹ�?7��?x�e���$>��ؾ�錿g�i?�8�>�I5?�Y<�5Q?[�
+�*,����@���M#�?��̾ɔ�?w"��W���k��Fe�>2UQ?Jv��	2�?�f%?�׺i㗾$i澍ň����>��ž���?_	�������!��>�<��p?�'½�v?Qo>�I��>J�� ����)�_?�����5��o���wT@I�>,ܴ>?�㾨�ҿ��8��Sȿ�I?-��s]ʾ	�<>V&��e�?#[ݾ��,@@
X?��>���?�l
�a��>Q�ٿ�3�?�J��k�>�d�p�ÿ��^��f
���?W�o?`;ƾ���K	@��'@�f�>��|?n᫾��¿-����1�31��
@�8]?�ޚ��>?��2>��)�^aѾ��B?4ʦ�/�
+@
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4c894ac
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_PReLU_2d_multiparam/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
J��??
�?�����?;Y����;S3�?���>?�`�ǡs�K��{�5�!�)�����
H��-R?�?��ֽ̯�>ʹ�?7��?x�e���$>��ؽ�錾g�i?�8�>�I5?�Y<�5Q?[�
+�*,����@���M#�?��̽ɔ�?w"��W���k��Fe�>2UQ?Jv��	2�?�f%?�׹i㗽$i潍ň����>��Ž���?_	�������!��>�<��p?�'¼�v?Qo>�I��>J�� ����)�_?�����5��o���wT@I�>,ܴ>?�㽨�Ҿ��8��SȾ�I?-��s]ʽ	�<>V&��e�?#[ݽ��,@@
X?��>���?�l
�a��>Q�پ�3�?�J��k�>�d�p�þ��^��f
���?W�o?`;ƽ���K	@��'@�f�>��|?n᫽��¾-����1�31��
@�8]?�ޚ��>?��2>��)�^aѽ��B?4ʦ�/�
+@
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/model.onnx
new file mode 100644
index 0000000..86f03ea
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1f7722f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fa73e76
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/model.onnx b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/model.onnx
new file mode 100644
index 0000000..28fb1ce
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3425361
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4212453
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PReLU_3d_multiparam/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/model.onnx b/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/model.onnx
new file mode 100644
index 0000000..ea52e4b
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..134b4a7
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d00751e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PixelShuffle/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/model.onnx b/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/model.onnx
new file mode 100644
index 0000000..819c9d7
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ddce6fd
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..733e897
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_PoissonNLLLLoss_no_reduce/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ReLU/model.onnx b/onnx/backend/test/data/pytorch-converted/test_ReLU/model.onnx
new file mode 100644
index 0000000..85a3866
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_ReLU/model.onnx
@@ -0,0 +1,15 @@
+pytorch0.3:Z
+
+
0
1"Relutorch-jit-exportZ
+
0
+

+
+
+
+b
+
1
+

+
+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8501131
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..eeef2a8
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ReLU/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/model.onnx
new file mode 100644
index 0000000..f36d03d
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..cbc7642
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..13d0c1e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ReflectionPad2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/model.onnx
new file mode 100644
index 0000000..a449c6b
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d436d1e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..894beb4
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ReplicationPad2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_SELU/model.onnx b/onnx/backend/test/data/pytorch-converted/test_SELU/model.onnx
new file mode 100644
index 0000000..2f782c7
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_SELU/model.onnx
@@ -0,0 +1,13 @@
+pytorch0.3:R
+
+
0
1"Selutorch-jit-exportZ
+
0
+

+
+
+b
+
1
+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..935024f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7dc9d09
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_SELU/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
JxPO1?�`>�{Y���{?	:>Ձ��y�>>k�R��9E?��j��^?w��>��?�ٜ��J]��k�?� �?���h�?Q䛿)��>
�?�hB�V�	@6拿W-��KLa>	�?X�`>G1y�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Sigmoid/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Sigmoid/model.onnx
new file mode 100644
index 0000000..d8d517c
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Sigmoid/model.onnx
@@ -0,0 +1,15 @@
+pytorch0.3:]
+
+
0
1"Sigmoidtorch-jit-exportZ
+
0
+

+
+
+
+b
+
1
+

+
+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..12a9d7a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e886ad8
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Sigmoid/test_data_set_0/output_0.pb
@@ -0,0 +1,4 @@
+
J���'?�M?���>E��>9�?i=�>�7�>��?�,?g;?�[?�-�>T`>���>�F?��?P�i>SC?4�>"?�8?�?GC�>�+?�&;?�
+/?��>$(�>���=�>C�
?74?��>�3�>d?w��>](Z?xM?)6�>vVD?1��>�Ĥ>.�q>�Z�>7��>']?~.�>W�G?��>A�7?Q�>X,�>h;?s#9?y�	?$��>3%H?V?h�b?}�?7�
?��0?{�:?���>�
+?�\�>׈�>#7J=�E9?�m�>M?��>}�3?�آ>��7?�@>�?�	?4z�>#"�>�z�>�R0?<]I?C�I>Z��>˲?���>��\?�B�>G">�b?�ad>K��>�K�>��7?�$>?���>��%?��=��,?��
+?�(?�
�>5�>?(�?�*?�#?+�?��a?��(>{�?�F�>���>q	�=���>��;=���>�?/�"?#1?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softmax/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Softmax/model.onnx
new file mode 100644
index 0000000..f85bbd8
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Softmax/model.onnx
@@ -0,0 +1,14 @@
+pytorch0.3:Z
+
+
0
1"Softmax*
+axis
�
torch-jit-exportZ
+
0
+

+
+
+b
+
1
+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..9ff4e66
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..138808d
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Softmax/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softmin/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Softmin/model.onnx
new file mode 100644
index 0000000..4e5d278
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Softmin/model.onnx
@@ -0,0 +1,16 @@
+pytorch0.3:g
+
+
0
1"Neg
+
+
1
2"Softmax*
+axis
�
torch-jit-exportZ
+
0
+

+
+
+b
+
2
+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..85bde81
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f8b9ae1
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Softmin/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softplus/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Softplus/model.onnx
new file mode 100644
index 0000000..189f8c4
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Softplus/model.onnx
@@ -0,0 +1,13 @@
+pytorch0.3:N
+
+
0
1"Softplustorch-jit-exportZ
+
0
+

+
+
+b
+
1
+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..acee251
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..37dca8e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Softplus/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softsign/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Softsign/model.onnx
new file mode 100644
index 0000000..65056c6
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Softsign/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..281cc67
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c47d24b
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Softsign/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
Jxe�=>�G?�*�I=	2u�$Ÿ>��ce,>����H?u�R��N?J?	�܅��u4�>�%��t�<U7y�S
��L���C�>?$����V<��
+?!����+?��?<��>:`�>�%?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Tanh/model.onnx b/onnx/backend/test/data/pytorch-converted/test_Tanh/model.onnx
new file mode 100644
index 0000000..fe0b3ad
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_Tanh/model.onnx
@@ -0,0 +1,15 @@
+pytorch0.3:Z
+
+
0
1"Tanhtorch-jit-exportZ
+
0
+

+
+
+
+b
+
1
+

+
+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..c586ea2
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ac6ebcc
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_Tanh/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/model.onnx b/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/model.onnx
new file mode 100644
index 0000000..27b1189
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7eb4115
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0970c17
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_ZeroPad2d/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/model.onnx b/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/model.onnx
new file mode 100644
index 0000000..4033cba
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/model.onnx
@@ -0,0 +1,17 @@
+pytorch0.3:m
+
+
0
1"
+LogSoftmax*
+axis�
torch-jit-exportZ
+
0
+

+
+
+
+b
+
1
+

+
+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..d47c763
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6fa8700
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_log_softmax_dim3/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
J�
�]��<���鿂i
+�8�V�Fꕿ�>���⸿�����
�Z1߿cW���[���_���'�ۀ�J����0!�v�M;�i_���#�
��v��S#������OҿP
�ޡ
�x�A�������T�/�t�������4ƿ�5 �s�\=@�FHe��Y�T|߿@ο�k��-��剿yt�]4E�
a�c�7����
+ƿ�������Cj�������������m���^i���0e�Lz�-�G����Y�6�I��� ����-;��M��|��׹P���bA���!i�,���{3��V߿Y��8����/�
� �F(W��g���Ͽna�aWC�8N�v�ȿ@ض��Y��N��L�翍�+���e�����@!�^��b	��]Ŀ5B�L�E���Z��$��10��a�>�5�eY"��$q���D�&� ��3h���R����	�kbX���&�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/model.onnx b/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/model.onnx
new file mode 100644
index 0000000..9f7d149
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/model.onnx
@@ -0,0 +1,13 @@
+pytorch0.3:h
+(
+
0
1"
+LogSoftmax*
+axis���������
�
torch-jit-exportZ
+
0
+

	
+
+�
b
+
1
+

	
+
+�
B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2ef8dd5
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..acff15a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_log_softmax_lastdim/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/model.onnx b/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/model.onnx
new file mode 100644
index 0000000..a34503c
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/model.onnx
@@ -0,0 +1,16 @@
+pytorch0.3:j
+
+
0
1"Softmax*
+axis�
torch-jit-exportZ
+
0
+

+
+
+
+b
+
1
+

+
+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bb547fc
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/input_0.pb
@@ -0,0 +1,4 @@
+
J�/�?�����u>:*$@σ?���<U?@��a���ҿ#ܾ�✽X��?�}>?`V�~^�����?�'��0�����>d@}�z����Z\�,�Y?N~ؿd��?��Ͼ���fr�?��/�f{�ˠ�m3�h��?��T�œg�lp�E�Ir;��M�?f�l?ݞ�>:u$@$+�"�꿼T���ӿު)?��H=o=x>��J�}*�?�}���Ć>��V�
+�����^�윋�jq�='��п6��XQ>�_z��2�?�{���˿�?�&�ta?F���ﾥ%��XH�>��?^ⶾ��;�
+t9��W?�Ԩ���N�!/?��E��K�5�j>
�����0��տ�3߿��?:�
�D�?
3��5�K?�����?�K`��͠�ts弢R/>����u�>��G?k8k>BO
+�V'�>J����ߜ=H0��h��?��f?g�C?�J��M�?q���/�ڼJL��'�m��wW?��?>n4�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9375777
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_softmax_functional_dim3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/model.onnx b/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/model.onnx
new file mode 100644
index 0000000..7b38e74
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/model.onnx
@@ -0,0 +1,12 @@
+pytorch0.3:\
+
+
0
1"Softmax*
+axis
�
torch-jit-exportZ
+
0
+

	
+
+�
b
+
1
+

	
+
+�
B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..7b12bdd
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f956baa
Binary files /dev/null and b/onnx/backend/test/data/pytorch-converted/test_softmax_lastdim/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/model.onnx
new file mode 100644
index 0000000..16c52f0
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/model.onnx
@@ -0,0 +1,18 @@
+pytorch0.3:|
+-
+
0
+
1
2"Add*
+	broadcast
�
*
+axis
�
torch-jit-exportZ
+
0
+
+
+Z
+
1
+
+
+b
+
2
+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a0d2d26
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..948cb91
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1715303
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_broadcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/model.onnx
new file mode 100644
index 0000000..fad8c21
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..33a258a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..53f2359
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b1a57c6
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_broadcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/model.onnx
new file mode 100644
index 0000000..16c52f0
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/model.onnx
@@ -0,0 +1,18 @@
+pytorch0.3:|
+-
+
0
+
1
2"Add*
+	broadcast
�
*
+axis
�
torch-jit-exportZ
+
0
+
+
+Z
+
1
+
+
+b
+
2
+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..6c141d6
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..898ed45
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b47da30
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_right_broadcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/model.onnx
new file mode 100644
index 0000000..1ee79c1
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..18ef0b4
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e87593e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b86dc4e
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_add_size1_singleton_broadcast/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/model.onnx
new file mode 100644
index 0000000..fddcecc
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..81f27c3
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2736941
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_addconstant/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_addmm/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/model.onnx
new file mode 100644
index 0000000..30e98f8
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..46defa5
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4058421
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
J0��l>�m1?󡈾�k@\-�=뜄�6��uo��&�܄b?ܫ��KD?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_2.pb b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..a261289
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/input_2.pb
@@ -0,0 +1 @@
+
J�A!�sB����P�M�_?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..54189fa
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_addmm/test_data_set_0/output_0.pb
@@ -0,0 +1,2 @@
+
J 
+��>�qX�A03>f���O�+�`�{=~$ɾJ��@
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_basic/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_basic/model.onnx
new file mode 100644
index 0000000..fab370f
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_basic/model.onnx
@@ -0,0 +1,25 @@
+pytorch0.3:�

+
+
0
+
1
2"Add
+
+
0
+
2
3"Mul
+
+
3
4"Tanh
+
+
4
5"Sigmoid
+
+
5
6"Negtorch-jit-exportZ
+
0
+
+

+
Z
+
1
+
+

+
b
+
6
+
+

+
B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..1f5217d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

J���>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1a2665c
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

J333?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..9bd4068
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_basic/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

J%�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_chunk/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_chunk/model.onnx
new file mode 100644
index 0000000..799c699
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_chunk/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ecf85f8
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a91b406
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..be699d3
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_chunk/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_clip/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_clip/model.onnx
new file mode 100644
index 0000000..b0f5a3d
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_clip/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb8549c
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..59a58ab
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_clip/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_concat2/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_concat2/model.onnx
new file mode 100644
index 0000000..a482e15
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_concat2/model.onnx
@@ -0,0 +1,17 @@
+pytorch0.3:q
+
+
0
+
1
2"Concat*
+axis
�
torch-jit-exportZ
+
0
+

+
+Z
+
1
+

+
+b
+
2
+

+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..46defa5
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..ebccd1a
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
J��l>�m1?󡈾�k@\-�=뜄�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..aa26c9c
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_concat2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_conv/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_conv/model.onnx
new file mode 100644
index 0000000..4f89250
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_conv/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2ea8bc7
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..6024f55
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_conv/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
0&
J��s[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?[�I?�R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��R=��ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>�ʡ>{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?{�7?���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>���>ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<ܩ�<�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>�θ>��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?��
?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?���?�jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG��jG�ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ��ؿ���T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T��T�%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>%.8>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/model.onnx
new file mode 100644
index 0000000..a8c08dd
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..5c72b83
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3ec8ce6
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_convtranspose/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_exp/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_exp/model.onnx
new file mode 100644
index 0000000..e00c935
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_exp/model.onnx
@@ -0,0 +1,11 @@
+pytorch0.3:I
+
+
0
1"Exptorch-jit-exportZ
+
0
+

+
+b
+
1
+

+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb8549c
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..16f1417
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_exp/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+
J0�?�i�?�1�>z��?1�
+?���?�A�?l��?&
+D?�R
A�Í?��E?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_flatten/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_flatten/model.onnx
new file mode 100644
index 0000000..2a12bb9
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_flatten/model.onnx
@@ -0,0 +1,14 @@
+pytorch0.3:b
+
+
0
1"Flatten*
+axis
�
torch-jit-exportZ
+
0
+

+

+
+
+b
+
1
+

+

+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d210d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

J`���A����&>J�a�s�\=�+?�[t��[ﾵ#?��6�ң��h�Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c96305a
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_flatten/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

J`���A����&>J�a�s�\=�+?�[t��[ﾵ#?��6�ң��h�Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_index/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_index/model.onnx
new file mode 100644
index 0000000..3105314
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_index/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..bf5caf9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..17817b9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_index/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_max/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_max/model.onnx
new file mode 100644
index 0000000..f101689
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_max/model.onnx
@@ -0,0 +1,16 @@
+pytorch0.3:a
+
+
0
+
1
2"Maxtorch-jit-exportZ
+
0
+

+
+Z
+
1
+

+
+b
+
2
+

+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb8549c
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1039245
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
J06��uo��&�܄b?ܫ��KD?�A!�sB����P�M�_?~.�CE"?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..4b30d1a
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_max/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
J0L�<=��>&�܄b?ܫ��KD?��l>�m1?��P��k@\-�=CE"?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/model.onnx
new file mode 100644
index 0000000..bbc7d87
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3234051
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..80f6c34
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_maxpool/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_min/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_min/model.onnx
new file mode 100644
index 0000000..c54d85e
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_min/model.onnx
@@ -0,0 +1,16 @@
+pytorch0.3:a
+
+
0
+
1
2"Mintorch-jit-exportZ
+
0
+

+
+Z
+
1
+

+
+b
+
2
+

+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb8549c
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..1039245
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
J06��uo��&�܄b?ܫ��KD?�A!�sB����P�M�_?~.�CE"?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..3cd39d4
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_min/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_mm/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_mm/model.onnx
new file mode 100644
index 0000000..24c8dab
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_mm/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..46defa5
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..4058421
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+
J0��l>�m1?󡈾�k@\-�=뜄�6��uo��&�܄b?ܫ��KD?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..1d9fa36
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_mm/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
J �=>��w���A>FĈ�4���f!A?~��3�?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/model.onnx
new file mode 100644
index 0000000..7b10bf4
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..4fd37a7
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..8de33f5
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_non_float_params/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_pad/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_pad/model.onnx
new file mode 100644
index 0000000..7defd21
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_pad/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..89c8be4
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7d0b678
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_pad/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_params/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_params/model.onnx
new file mode 100644
index 0000000..db792b6
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_params/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..2ce0726
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..11edd1c
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_params/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
JPS9��&;��&;��&;�
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_permute2/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_permute2/model.onnx
new file mode 100644
index 0000000..29a0ef8
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_permute2/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..fa58081
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fa58081
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_permute2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_pow/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_pow/model.onnx
new file mode 100644
index 0000000..da08c59
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_pow/model.onnx
@@ -0,0 +1,22 @@
+pytorch0.3:y
+
+
0
+
1
2"Powtorch-jit-exportZ
+
0
+

+

+
+
+Z
+
1
+

+

+
+
+b
+
2
+

+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d210d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

J`���A����&>J�a�s�\=�+?�[t��[ﾵ#?��6�ң��h�Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..466211c
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/input_1.pb
@@ -0,0 +1 @@
+

J`oFD?"�<�3�<��?������>#�e?���t�l?�l?��:>���>*���>W>K?��=˨���p_?�WD?!齚\q��A?
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c9345f3
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_pow/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/model.onnx
new file mode 100644
index 0000000..31ef5d8
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d210d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

J`���A����&>J�a�s�\=�+?�[t��[ﾵ#?��6�ң��h�Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..d52124c
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

J �E>�9�4���w"�-����
�>ٍ�>|��=
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/model.onnx
new file mode 100644
index 0000000..96c0f35
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/model.onnx
@@ -0,0 +1,18 @@
+pytorch0.3:~
+0
+
0
1"
+ReduceMean*
+axes@�
*
+keepdims
�
torch-jit-exportZ
+
0
+

+

+
+
+b
+
1
+

+

+
+

+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d210d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

J`���A����&>J�a�s�\=�+?�[t��[ﾵ#?��6�ң��h�Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..18f97ce
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_mean_keepdim/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+


J �E>�9�4���w"�-����
�>ٍ�>|��=
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/model.onnx
new file mode 100644
index 0000000..20954be
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d210d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

J`���A����&>J�a�s�\=�+?�[t��[ﾵ#?��6�ң��h�Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..57122fd
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+

J �??��
+�*�z�R����@�b
+�?�TZ?��g>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/model.onnx
new file mode 100644
index 0000000..88c5e99
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/model.onnx
@@ -0,0 +1,17 @@
+pytorch0.3:}
+/
+
0
1"	ReduceSum*
+axes@�
*
+keepdims
�
torch-jit-exportZ
+
0
+

+

+
+
+b
+
1
+

+

+
+

+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d210d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

J`���A����&>J�a�s�\=�+?�[t��[ﾵ#?��6�ң��h�Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..16181cf
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_reduced_sum_keepdim/test_data_set_0/output_0.pb
@@ -0,0 +1,3 @@
+


J �??��
+�*�z�R����@�b
+�?�TZ?��g>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_repeat/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_repeat/model.onnx
new file mode 100644
index 0000000..af49df0
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_repeat/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d210d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

J`���A����&>J�a�s�\=�+?�[t��[ﾵ#?��6�ң��h�Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5e6abb4
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_repeat/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
	
J����A����&>J�a����A����&>J�a����A����&>J�a����A����&>J�a�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[ﾵ#?��6�ң��h��#?��6�ң��h��#?��6�ң��h��#?��6�ң��h����A����&>J�a����A����&>J�a����A����&>J�a����A����&>J�a�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[ﾵ#?��6�ң��h��#?��6�ң��h��#?��6�ң��h��#?��6�ң��h����A����&>J�a����A����&>J�a����A����&>J�a����A����&>J�a�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[ﾵ#?��6�ң��h��#?��6�ң��h��#?��6�ң��h��#?��6�ң��h�Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>���A����&>J�a����A����&>J�a����A����&>J�a����A����&>J�a�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[ﾵ#?��6�ң��h��#?��6�ң��h��#?��6�ң��h��#?��6�ң��h����A����&>J�a����A����&>J�a����A����&>J�a����A����&>J�a�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[ﾵ#?��6�ң��h��#?��6�ң��h��#?��6�ң��h��#?��6�ң��h����A����&>J�a����A����&>J�a����A����&>J�a����A����&>J�a�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[�s�\=�+?�[t��[ﾵ#?��6�ң��h��#?��6�ң��h��#?��6�ң��h��#?��6�ң��h�Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}�ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>�{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/model.onnx
new file mode 100644
index 0000000..3035fd9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..08ae34f
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

JL�<=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..2283882
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_repeat_dim_overflow/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

J�
L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>L�<=��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_selu/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_selu/model.onnx
new file mode 100644
index 0000000..817529b
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_selu/model.onnx
@@ -0,0 +1,15 @@
+pytorch0.3:Z
+
+
0
1"Selutorch-jit-exportZ
+
0
+

+

+
+
+b
+
1
+

+

+
+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..64d210d
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

J`���A����&>J�a�s�\=�+?�[t��[ﾵ#?��6�ң��h�Y�x?����w�?�vL?ܿ!�	(�?ѱ-�]�}��{���8�>,\ξK��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..5150742
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_selu/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

J`eL>�\(0�3t/>Mڃ���g=_�3?J�нb(�
Q+?̲e��ڔ���?����?!(5����?y�V?Ͽ/��?Rp��В�������߉>LL�A��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/model.onnx
new file mode 100644
index 0000000..c44b76f
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/model.onnx
@@ -0,0 +1,11 @@
+pytorch0.3:J
+
+
0
1"Sqrttorch-jit-exportZ
+
0
+

+
+b
+
1
+

+
+B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..eb8549c
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..0f842e9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_sqrt/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/model.onnx
new file mode 100644
index 0000000..ed37c04
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/model.onnx differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..82ad99f
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..87c18ab
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/model.onnx
new file mode 100644
index 0000000..82c60e0
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/model.onnx
@@ -0,0 +1,33 @@
+pytorch0.3:�

+
+
0
+
1
+
2
3"Sum
+
+
0
4"Neg
+
+
1
5"Negtorch-jit-exportZ
+
0
+
+

+
Z
+
1
+
+

+
Z
+
2
+
+

+
b
+
3
+
+

+
b
+
4
+
+

+
b
+
5
+
+

+
B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a8370e6
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..be699d3
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_2.pb b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..4c97715
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..84e53e7
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_1.pb b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..952ac13
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_2.pb b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c334c0a
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_symbolic_override_nested/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_view/model.onnx b/onnx/backend/test/data/pytorch-operator/test_operator_view/model.onnx
new file mode 100644
index 0000000..6f249ca
--- /dev/null
+++ b/onnx/backend/test/data/pytorch-operator/test_operator_view/model.onnx
@@ -0,0 +1,12 @@
+pytorch0.3:V
+
+
0
1"Flatten*
+axis
�
torch-jit-exportZ
+
0
+
+

+
b
+
1
+

+

+
B
\ No newline at end of file
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/input_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..17817b9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/output_0.pb b/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bf5caf9
Binary files /dev/null and b/onnx/backend/test/data/pytorch-operator/test_operator_view/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/real/test_bvlc_alexnet/data.json b/onnx/backend/test/data/real/test_bvlc_alexnet/data.json
new file mode 100644
index 0000000..8172a83
--- /dev/null
+++ b/onnx/backend/test/data/real/test_bvlc_alexnet/data.json
@@ -0,0 +1 @@
+{"atol": 1e-07, "model_name": "bvlc_alexnet", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_bvlc_alexnet.onnx"}
\ No newline at end of file
diff --git a/onnx/backend/test/data/real/test_densenet121/data.json b/onnx/backend/test/data/real/test_densenet121/data.json
new file mode 100644
index 0000000..69bac6c
--- /dev/null
+++ b/onnx/backend/test/data/real/test_densenet121/data.json
@@ -0,0 +1 @@
+{"atol": 1e-07, "model_name": "densenet121", "rtol": 0.002, "url": "onnx/backend/test/data/light/light_densenet121.onnx"}
\ No newline at end of file
diff --git a/onnx/backend/test/data/real/test_inception_v1/data.json b/onnx/backend/test/data/real/test_inception_v1/data.json
new file mode 100644
index 0000000..50272a3
--- /dev/null
+++ b/onnx/backend/test/data/real/test_inception_v1/data.json
@@ -0,0 +1 @@
+{"atol": 1e-07, "model_name": "inception_v1", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_inception_v1.onnx"}
\ No newline at end of file
diff --git a/onnx/backend/test/data/real/test_inception_v2/data.json b/onnx/backend/test/data/real/test_inception_v2/data.json
new file mode 100644
index 0000000..7c26928
--- /dev/null
+++ b/onnx/backend/test/data/real/test_inception_v2/data.json
@@ -0,0 +1 @@
+{"atol": 1e-07, "model_name": "inception_v2", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_inception_v2.onnx"}
\ No newline at end of file
diff --git a/onnx/backend/test/data/real/test_resnet50/data.json b/onnx/backend/test/data/real/test_resnet50/data.json
new file mode 100644
index 0000000..f5a100e
--- /dev/null
+++ b/onnx/backend/test/data/real/test_resnet50/data.json
@@ -0,0 +1 @@
+{"atol": 1e-07, "model_name": "resnet50", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_resnet50.onnx"}
\ No newline at end of file
diff --git a/onnx/backend/test/data/real/test_shufflenet/data.json b/onnx/backend/test/data/real/test_shufflenet/data.json
new file mode 100644
index 0000000..6bb5a0b
--- /dev/null
+++ b/onnx/backend/test/data/real/test_shufflenet/data.json
@@ -0,0 +1 @@
+{"atol": 1e-07, "model_name": "shufflenet", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_shufflenet.onnx"}
\ No newline at end of file
diff --git a/onnx/backend/test/data/real/test_squeezenet/data.json b/onnx/backend/test/data/real/test_squeezenet/data.json
new file mode 100644
index 0000000..fb0e7f2
--- /dev/null
+++ b/onnx/backend/test/data/real/test_squeezenet/data.json
@@ -0,0 +1 @@
+{"atol": 1e-07, "model_name": "squeezenet", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_squeezenet.onnx"}
\ No newline at end of file
diff --git a/onnx/backend/test/data/real/test_vgg19/data.json b/onnx/backend/test/data/real/test_vgg19/data.json
new file mode 100644
index 0000000..2ad3c4f
--- /dev/null
+++ b/onnx/backend/test/data/real/test_vgg19/data.json
@@ -0,0 +1 @@
+{"atol": 1e-07, "model_name": "vgg19", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_vgg19.onnx"}
\ No newline at end of file
diff --git a/onnx/backend/test/data/real/test_zfnet512/data.json b/onnx/backend/test/data/real/test_zfnet512/data.json
new file mode 100644
index 0000000..4fabcd5
--- /dev/null
+++ b/onnx/backend/test/data/real/test_zfnet512/data.json
@@ -0,0 +1 @@
+{"atol": 1e-07, "model_name": "zfnet512", "rtol": 0.001, "url": "onnx/backend/test/data/light/light_zfnet512.onnx"}
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model1/model.onnx b/onnx/backend/test/data/simple/test_expand_shape_model1/model.onnx
new file mode 100644
index 0000000..d86246d
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model1/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..254eb74
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..acdfc52
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..08fa83e
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model2/model.onnx b/onnx/backend/test/data/simple/test_expand_shape_model2/model.onnx
new file mode 100644
index 0000000..6f55552
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model2/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..254eb74
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e9774d7
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..81ce284
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model3/model.onnx b/onnx/backend/test/data/simple/test_expand_shape_model3/model.onnx
new file mode 100644
index 0000000..a8d1b86
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model3/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..254eb74
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..5d78a13
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..48cfc3f
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model4/model.onnx b/onnx/backend/test/data/simple/test_expand_shape_model4/model.onnx
new file mode 100644
index 0000000..85f94b5
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model4/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..254eb74
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..eade368
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ed9aa9e
Binary files /dev/null and b/onnx/backend/test/data/simple/test_expand_shape_model4/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add/model.onnx b/onnx/backend/test/data/simple/test_gradient_of_add/model.onnx
new file mode 100644
index 0000000..6cee309
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f445042
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbb9486
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..ceda7e2
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_1.pb b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..01af236
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_2.pb b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..d2945a7
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/model.onnx b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/model.onnx
new file mode 100644
index 0000000..6bf8cdd
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f445042
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cbb9486
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..660fb53
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_1.pb b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_1.pb
new file mode 100644
index 0000000..e8046aa
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_2.pb b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_2.pb
new file mode 100644
index 0000000..c71c241
Binary files /dev/null and b/onnx/backend/test/data/simple/test_gradient_of_add_and_mul/test_data_set_0/output_2.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model1/model.onnx b/onnx/backend/test/data/simple/test_sequence_model1/model.onnx
new file mode 100644
index 0000000..ec0ae3f
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model1/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8cec7a7
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..e827c24
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_2.pb b/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..48d4444
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..26aa749
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model1/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model2/model.onnx b/onnx/backend/test/data/simple/test_sequence_model2/model.onnx
new file mode 100644
index 0000000..8effac3
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model2/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8cec7a7
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cf99238
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_2.pb b/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3497261
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b883804
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model2/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model3/model.onnx b/onnx/backend/test/data/simple/test_sequence_model3/model.onnx
new file mode 100644
index 0000000..7164714
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model3/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8cec7a7
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cf99238
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_2.pb b/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3497261
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..b883804
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model3/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model4/model.onnx b/onnx/backend/test/data/simple/test_sequence_model4/model.onnx
new file mode 100644
index 0000000..b1ffeb6
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model4/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8cec7a7
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cf99238
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_2.pb b/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3497261
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f5cbdf2
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model4/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model5/model.onnx b/onnx/backend/test/data/simple/test_sequence_model5/model.onnx
new file mode 100644
index 0000000..830a058
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model5/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8cec7a7
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..cf99238
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_2.pb b/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_2.pb
new file mode 100644
index 0000000..3497261
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/input_2.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..07b7cdf
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model5/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model6/model.onnx b/onnx/backend/test/data/simple/test_sequence_model6/model.onnx
new file mode 100644
index 0000000..8cd34cc
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model6/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..8cec7a7
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..84d6871
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model6/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model7/model.onnx b/onnx/backend/test/data/simple/test_sequence_model7/model.onnx
new file mode 100644
index 0000000..1839420
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model7/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..3c26343
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+B
XJ�
�_V��?3�`����?K�nk�I�?��cۮo�?��)�?[��!*��?�Ya�m
�?�:�g��?63IS��?B�KN��?(�?��U�?"�	���?-6��k-�?%X�|��?��Jk/�?�ҽN�?��"�!��?{ �_Ҥ�?������?'�z�#��?���i�P�?�!4����?�)����?2,�R��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..c8e878e
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_sequence_model7/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+BoutJ`-6��k-�?%X�|��?��Jk/�?�ҽN�?��"�!��?{ �_Ҥ�?������?'�z�#��?���i�P�?�!4����?�)����?2,�R��?
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_sequence_model8/model.onnx b/onnx/backend/test/data/simple/test_sequence_model8/model.onnx
new file mode 100644
index 0000000..fa0d71a
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model8/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..65193ec
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_1.pb b/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_1.pb
new file mode 100644
index 0000000..bb1a32b
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/input_1.pb differ
diff --git a/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..a9977c1
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sequence_model8/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_shrink/model.onnx b/onnx/backend/test/data/simple/test_shrink/model.onnx
new file mode 100644
index 0000000..4f1a7f1
Binary files /dev/null and b/onnx/backend/test/data/simple/test_shrink/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_shrink/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_shrink/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..79ecbb4
Binary files /dev/null and b/onnx/backend/test/data/simple/test_shrink/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_shrink/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_shrink/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..236d0ac
Binary files /dev/null and b/onnx/backend/test/data/simple/test_shrink/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sign_model/model.onnx b/onnx/backend/test/data/simple/test_sign_model/model.onnx
new file mode 100644
index 0000000..b3c2f96
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sign_model/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..ff9c47f
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/input_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..e3843ba
Binary files /dev/null and b/onnx/backend/test/data/simple/test_sign_model/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_single_relu_model/model.onnx b/onnx/backend/test/data/simple/test_single_relu_model/model.onnx
new file mode 100644
index 0000000..f1da029
Binary files /dev/null and b/onnx/backend/test/data/simple/test_single_relu_model/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..e5097e0
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+

B
xJx��?h��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7038f87
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_single_relu_model/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+

B
yJx��?h��>
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/model.onnx b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/model.onnx
new file mode 100644
index 0000000..06aa614
Binary files /dev/null and b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..179b510
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2tuesday2	wednesday2thursdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cdc27a7
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_lower/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2tuesday2	wednesday2thursdayB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/model.onnx b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/model.onnx
new file mode 100644
index 0000000..bb71475
Binary files /dev/null and b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..179b510
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2tuesday2	wednesday2thursdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..cdc27a7
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_nochangecase/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2tuesday2	wednesday2thursdayB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/model.onnx b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/model.onnx
new file mode 100644
index 0000000..a2139b9
Binary files /dev/null and b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..179b510
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2tuesday2	wednesday2thursdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..f99dcd8
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_monday_casesensintive_upper/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2TUESDAY2	WEDNESDAY2THURSDAYB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/model.onnx b/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/model.onnx
new file mode 100644
index 0000000..626bdf3
Binary files /dev/null and b/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..f8443f6
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2mondayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..fc66148
Binary files /dev/null and b/onnx/backend/test/data/simple/test_strnorm_model_monday_empty_output/test_data_set_0/output_0.pb differ
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/model.onnx b/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/model.onnx
new file mode 100644
index 0000000..14919dc
Binary files /dev/null and b/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..0b3e995
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+
2Monday2tuesday2	wednesday2Monday2tuesday2	wednesdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..7db720d
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_monday_insensintive_upper_twodim/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+
2TUESDAY2	WEDNESDAY2TUESDAY2	WEDNESDAYB
y
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/model.onnx b/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/model.onnx
new file mode 100644
index 0000000..543b3d4
Binary files /dev/null and b/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/model.onnx differ
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/input_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/input_0.pb
new file mode 100644
index 0000000..a2b8405
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/input_0.pb
@@ -0,0 +1 @@
+2monday2tuesdayB
x
\ No newline at end of file
diff --git a/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/output_0.pb b/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/output_0.pb
new file mode 100644
index 0000000..bc7045a
--- /dev/null
+++ b/onnx/backend/test/data/simple/test_strnorm_model_nostopwords_nochangecase/test_data_set_0/output_0.pb
@@ -0,0 +1 @@
+2monday2tuesdayB
y
\ No newline at end of file
diff --git a/onnx/backend/test/loader/__init__.py b/onnx/backend/test/loader/__init__.py
new file mode 100644
index 0000000..530fdf1
--- /dev/null
+++ b/onnx/backend/test/loader/__init__.py
@@ -0,0 +1,66 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import json
+import os
+
+from onnx.backend.test.case.test_case import TestCase
+
+DATA_DIR = os.path.join(
+    os.path.dirname(os.path.realpath(os.path.dirname(__file__))), "data"
+)
+
+
+def load_model_tests(
+    data_dir: str = DATA_DIR,
+    kind: str | None = None,
+) -> list[TestCase]:
+    """Load model test cases from on-disk data files."""
+    supported_kinds = os.listdir(data_dir)
+    if kind not in supported_kinds:
+        raise ValueError(f"kind must be one of {supported_kinds}")
+
+    testcases = []
+
+    kind_dir = os.path.join(data_dir, kind)
+    for test_name in os.listdir(kind_dir):
+        case_dir = os.path.join(kind_dir, test_name)
+        # skip the non-dir files, such as generated __init__.py.
+        rtol = 1e-3
+        atol = 1e-7
+        if not os.path.isdir(case_dir):
+            continue
+        if os.path.exists(os.path.join(case_dir, "model.onnx")):
+            url = None
+            model_name = test_name[len("test_")]
+            model_dir: str | None = case_dir
+            if os.path.exists(os.path.join(case_dir, "data.json")):
+                with open(os.path.join(case_dir, "data.json")) as f:
+                    data = json.load(f)
+                    rtol = data.get("rtol", rtol)
+                    atol = data.get("atol", atol)
+        else:
+            with open(os.path.join(case_dir, "data.json")) as f:
+                data = json.load(f)
+                url = data["url"]
+                model_name = data["model_name"]
+                rtol = data.get("rtol", rtol)
+                atol = data.get("atol", atol)
+                model_dir = None
+        testcases.append(
+            TestCase(
+                name=test_name,
+                url=url,
+                model_name=model_name,
+                model_dir=model_dir,
+                model=None,
+                data_sets=None,
+                kind=kind,
+                rtol=rtol,
+                atol=atol,
+            )
+        )
+
+    return testcases
diff --git a/onnx/backend/test/report/__init__.py b/onnx/backend/test/report/__init__.py
new file mode 100644
index 0000000..8b5ec9e
--- /dev/null
+++ b/onnx/backend/test/report/__init__.py
@@ -0,0 +1,50 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import pytest
+
+from onnx.backend.test.report.coverage import Coverage
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import _pytest
+
+_coverage = Coverage()
+_marks: dict[str, Sequence[Any]] = {}
+
+
+def _add_mark(mark: Any, bucket: str) -> None:
+    proto = mark.args[0]
+    if isinstance(proto, list):
+        assert len(proto) == 1
+        proto = proto[0]
+    if proto is not None:
+        _coverage.add_proto(proto, bucket, mark.args[1] == "RealModel")
+
+
+def pytest_runtest_call(item: _pytest.nodes.Item) -> None:
+    mark = item.get_closest_marker("onnx_coverage")
+    if mark:
+        assert item.nodeid not in _marks
+        _marks[item.nodeid] = mark
+
+
+def pytest_runtest_logreport(report: Any) -> None:
+    if report.when == "call" and report.outcome == "passed" and report.nodeid in _marks:
+        mark = _marks[report.nodeid]
+        _add_mark(mark, "passed")
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_terminal_summary(
+    terminalreporter: _pytest.terminal.TerminalReporter,
+    exitstatus: int,  # noqa: ARG001
+) -> None:
+    for mark in _marks.values():
+        _add_mark(mark, "loaded")
+    _coverage.report_text(terminalreporter)
diff --git a/onnx/backend/test/report/base.py b/onnx/backend/test/report/base.py
new file mode 100644
index 0000000..7284f10
--- /dev/null
+++ b/onnx/backend/test/report/base.py
@@ -0,0 +1,8 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+
+class ReporterBase:
+    pass
diff --git a/onnx/backend/test/report/coverage.py b/onnx/backend/test/report/coverage.py
new file mode 100644
index 0000000..6d1765f
--- /dev/null
+++ b/onnx/backend/test/report/coverage.py
@@ -0,0 +1,266 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import csv
+import datetime
+import os
+from collections import OrderedDict, defaultdict
+from typing import IO, Any
+
+from tabulate import tabulate
+
+import onnx
+from onnx import GraphProto, defs, helper
+
+_all_schemas = defs.get_all_schemas()
+
+
+class AttrCoverage:
+    def __init__(self) -> None:
+        self.name: str | None = None
+        self.values: set[str] = set()
+
+    def add(self, attr: onnx.AttributeProto) -> None:
+        assert self.name in {None, attr.name}
+        self.name = attr.name
+        value = helper.get_attribute_value(attr)
+        # Turn list into tuple so we can put it into set
+        # As value can be string, don't blindly turn `collections.Iterable`
+        # into tuple.
+        if isinstance(value, list):
+            value = tuple(value)
+        self.values.add(str(value))
+
+
+class NodeCoverage:
+    def __init__(self) -> None:
+        self.op_type: str | None = None
+        self.attr_coverages: dict[str, AttrCoverage] = defaultdict(AttrCoverage)
+
+    def add(self, node: onnx.NodeProto) -> None:
+        assert self.op_type in [None, node.op_type]
+
+        if self.op_type is None:
+            self.op_type = node.op_type
+            assert self.op_type is not None
+            self.schema = defs.get_schema(self.op_type, domain=node.domain)
+
+        for attr in node.attribute:
+            self.attr_coverages[attr.name].add(attr)
+
+
+class ModelCoverage:
+    def __init__(self) -> None:
+        self.name: str | None = None
+        self.graph: GraphProto | None = None
+        self.node_coverages: dict[str, NodeCoverage] = defaultdict(NodeCoverage)
+
+    def add(self, model: onnx.ModelProto) -> None:
+        assert self.name in [None, model.graph.name]
+
+        if self.name is None:
+            self.name = model.graph.name
+            assert self.name is not None
+            self.graph = model.graph
+
+        for node in model.graph.node:
+            self.node_coverages[node.op_type].add(node)
+
+
+class Coverage:
+    def __init__(self) -> None:
+        self.buckets: dict[str, dict[str, NodeCoverage]] = {
+            "loaded": defaultdict(NodeCoverage),
+            "passed": defaultdict(NodeCoverage),
+        }
+        self.models: dict[str, dict[str, ModelCoverage]] = {
+            "loaded": defaultdict(ModelCoverage),
+            "passed": defaultdict(ModelCoverage),
+        }
+
+    def add_node(self, node: onnx.NodeProto, bucket: str) -> None:
+        self.buckets[bucket][node.op_type].add(node)
+
+    def add_graph(self, graph: onnx.GraphProto, bucket: str) -> None:
+        for node in graph.node:
+            self.add_node(node, bucket)
+
+    def add_model(self, model: onnx.ModelProto, bucket: str, is_model: bool) -> None:
+        self.add_graph(model.graph, bucket)
+        # Only add model if name does not start with test
+        if is_model:
+            self.models[bucket][model.graph.name].add(model)
+
+    def add_proto(self, proto: onnx.ModelProto, bucket: str, is_model: bool) -> None:
+        assert isinstance(proto, onnx.ModelProto)
+        self.add_model(proto, bucket, is_model)
+
+    def report_text(self, writer: IO[str]) -> None:
+        writer.write("---------- onnx coverage: ----------\n")
+        writer.write(
+            f"Operators (passed/loaded/total): {len(self.buckets['passed'])}/{len(self.buckets['loaded'])}/{len(_all_schemas)}\n"
+        )
+        writer.write("------------------------------------\n")
+
+        rows = []
+        passed = []
+        all_ops: list[str] = []
+        experimental: list[str] = []
+        for op_cov in self.buckets["passed"].values():
+            covered_attrs = [
+                f"{attr_cov.name}: {len(attr_cov.values)}"
+                for attr_cov in op_cov.attr_coverages.values()
+            ]
+            uncovered_attrs = [
+                f"{attr}: 0"
+                for attr in op_cov.schema.attributes
+                if attr not in op_cov.attr_coverages
+            ]
+            attrs = sorted(covered_attrs) + sorted(uncovered_attrs)
+            if attrs:
+                attrs_column = os.linesep.join(attrs)
+            else:
+                attrs_column = "No attributes"
+            rows.append([op_cov.op_type, attrs_column])
+            passed.append(op_cov.op_type)
+        writer.write(
+            tabulate(
+                rows,
+                headers=["Operator", "Attributes\n(name: #values)"],
+                tablefmt="plain",
+            )
+        )
+        writer.write("\n")
+        if os.environ.get("CSVDIR") is not None:
+            self.report_csv(all_ops, passed, experimental)
+
+    # This function writes the coverage report to a set of CSV files for
+    # the Backend Scoreboard (onnx.ai/backend-scoreboard). To enable this
+    # feature, set a CSVDIR environment variable locally with the directory
+    # where you would like the files to be written, relative to the
+    # directory from which you're running pytest.  The format of the CSV
+    # files is a column naming each op or model and columns for each
+    # backend with indications of whether the tests passed or failed for
+    # each row.
+    def report_csv(
+        self, all_ops: list[str], passed: list[str | None], experimental: list[str]
+    ) -> None:
+        for schema in _all_schemas:
+            if schema.domain in {"", "ai.onnx"}:
+                all_ops.append(schema.name)
+                if schema.support_level == defs.OpSchema.SupportType.EXPERIMENTAL:
+                    experimental.append(schema.name)
+        all_ops.sort()
+        nodes_path = os.path.join(str(os.environ.get("CSVDIR")), "nodes.csv")
+        models_path = os.path.join(str(os.environ.get("CSVDIR")), "models.csv")
+        existing_nodes: OrderedDict[str, dict[str, str]] = OrderedDict()
+        existing_models: OrderedDict[str, dict[str, str]] = OrderedDict()
+        frameworks: list[str] = []
+        if os.path.isfile(nodes_path):
+            with open(nodes_path) as nodes_file:
+                reader = csv.DictReader(nodes_file)
+                assert reader.fieldnames
+                frameworks = list(reader.fieldnames)
+                for row in reader:
+                    op = row["Op"]
+                    del row["Op"]
+                    existing_nodes[str(op)] = row
+        if os.path.isfile(models_path):
+            with open(models_path) as models_file:
+                reader = csv.DictReader(models_file)
+                for row in reader:
+                    model = row["Model"]
+                    del row["Model"]
+                    existing_models[str(model)] = row
+        backend = os.environ.get("BACKEND")
+        other_frameworks = frameworks[1:]
+        with open(nodes_path, "w") as nodes_file:
+            if "Op" not in frameworks:
+                frameworks.append("Op")
+            if backend not in frameworks:
+                frameworks.append(str(backend))
+            else:
+                other_frameworks.remove(str(backend))
+            node_writer = csv.DictWriter(nodes_file, fieldnames=frameworks)
+            node_writer.writeheader()
+            for node in all_ops:
+                node_name = node
+                if node in experimental:
+                    node_name = node + " (Experimental)"
+                if node_name not in existing_nodes:
+                    # Also add Skipped for other nodes
+                    existing_nodes[node_name] = OrderedDict()
+                    for other_framework in other_frameworks:
+                        existing_nodes[node_name][other_framework] = "Skipped!"
+                if node in passed:
+                    existing_nodes[node_name][str(backend)] = "Passed!"
+                else:
+                    existing_nodes[node_name][str(backend)] = "Failed!"
+            summaries: dict[Any, Any] = {}
+            if "Summary" in existing_nodes:
+                summaries = existing_nodes["Summary"]
+                del existing_nodes["Summary"]
+            summaries[str(backend)] = f"{len(passed)}/{len(all_ops)} node tests passed"
+            summaries["Op"] = "Summary"
+            for node in existing_nodes:
+                existing_nodes[node]["Op"] = str(node)
+                node_writer.writerow(existing_nodes[node])
+            node_writer.writerow(summaries)
+        with open(models_path, "w") as models_file:
+            frameworks[0] = "Model"
+            model_writer = csv.DictWriter(models_file, fieldnames=frameworks)
+            model_writer.writeheader()
+            # Consider both buckets
+            num_models = 0
+            for bucket in self.models:
+                for model in self.models[bucket]:
+                    # Both analyze and run the model on the backend
+                    num_covered = 0
+                    for node in self.models[bucket][model].node_coverages:
+                        if node in passed:
+                            num_covered += 1
+                    # TODO: Identify if there are models that are being
+                    # skipped/not loaded, but that are in other frameworks
+                    msg = "Passed!"
+                    if bucket == "loaded":
+                        if model in self.models["passed"]:
+                            continue
+                        msg = "Failed!"
+                    num_models += 1
+                    if model not in existing_models:
+                        # Also add Skipped for other models
+                        existing_models[model] = OrderedDict()
+                        for other_framework in other_frameworks:
+                            existing_models[model][other_framework] = "Skipped!"
+                    existing_models[model][str(backend)] = str(
+                        f"{num_covered}/{len(self.models[bucket][model].node_coverages)} nodes covered: {msg}"
+                    )
+            summaries.clear()
+            if "Summary" in existing_models:
+                summaries = existing_models["Summary"]
+                del existing_models["Summary"]
+            if str(backend) in summaries:
+                del summaries[str(backend)]
+            summaries[str(backend)] = (
+                f"{len(self.models['passed'])}/{num_models} model tests passed"
+            )
+            summaries["Model"] = "Summary"
+            for model in existing_models:
+                existing_models[model]["Model"] = model
+                model_writer.writerow(existing_models[model])
+            model_writer.writerow(summaries)
+        with open(
+            os.path.join(str(os.environ.get("CSVDIR")), "metadata.csv"),
+            "w",
+        ) as metadata_file:
+            metadata_writer = csv.writer(metadata_file)
+            metadata_writer.writerow(
+                [
+                    "Latest Update",
+                    datetime.datetime.now(tz=datetime.timezone.utc)
+                    .isoformat()
+                    .replace("T", " "),
+                ]
+            )
diff --git a/onnx/backend/test/runner/__init__.py b/onnx/backend/test/runner/__init__.py
new file mode 100644
index 0000000..d6b8d0a
--- /dev/null
+++ b/onnx/backend/test/runner/__init__.py
@@ -0,0 +1,529 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import functools
+import glob
+import os
+import re
+import shutil
+import sys
+import tempfile
+import time
+import unittest
+from collections import defaultdict
+from re import Pattern
+from typing import TYPE_CHECKING, Any
+from urllib.request import urlretrieve
+
+import numpy as np
+
+import onnx
+import onnx.reference
+from onnx import ONNX_ML, ModelProto, NodeProto, TypeProto, ValueInfoProto, numpy_helper
+from onnx.backend.test.loader import load_model_tests
+from onnx.backend.test.runner.item import TestItem
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Sequence
+
+    from onnx.backend.base import Backend
+    from onnx.backend.test.case.test_case import TestCase
+
+
+class BackendIsNotSupposedToImplementIt(unittest.SkipTest):
+    pass
+
+
+def retry_execute(times: int) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    assert times >= 1
+
+    def wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(func)
+        def wrapped(*args: Any, **kwargs: Any) -> Any:
+            for i in range(1, times + 1):
+                try:
+                    return func(*args, **kwargs)
+                except Exception:  # noqa: PERF203
+                    print(f"{i} times tried")
+                    if i == times:
+                        raise
+                    time.sleep(5 * i)
+            return None
+
+        return wrapped
+
+    return wrapper
+
+
+class Runner:
+    def __init__(
+        self,
+        backend: type[Backend],
+        parent_module: str | None = None,
+        test_kwargs: dict | None = None,
+    ) -> None:
+        self.backend = backend
+        self._parent_module = parent_module
+        self._include_patterns: set[Pattern[str]] = set()
+        self._exclude_patterns: set[Pattern[str]] = set()
+        self._xfail_patterns: set[Pattern[str]] = set()
+        self._test_kwargs: dict = test_kwargs or {}
+
+        # This is the source of the truth of all test functions.
+        # Properties `test_cases`, `test_suite` and `tests` will be
+        # derived from it.
+        # {category: {name: func}}
+        self._test_items: dict[str, dict[str, TestItem]] = defaultdict(dict)
+
+        for rt in load_model_tests(kind="node"):
+            self._add_model_test(rt, "Node")
+
+        for rt in load_model_tests(kind="real"):
+            self._add_model_test(rt, "Real")
+
+        for rt in load_model_tests(kind="simple"):
+            self._add_model_test(rt, "Simple")
+
+        for ct in load_model_tests(kind="pytorch-converted"):
+            self._add_model_test(ct, "PyTorchConverted")
+
+        for test_case in load_model_tests(kind="pytorch-operator"):
+            self._add_model_test(test_case, "PyTorchOperator")
+
+    def _get_test_case(self, name: str) -> type[unittest.TestCase]:
+        test_case = type(str(name), (unittest.TestCase,), {})
+        if self._parent_module:
+            test_case.__module__ = self._parent_module
+        return test_case
+
+    def include(self, pattern: str) -> Runner:
+        self._include_patterns.add(re.compile(pattern))
+        return self
+
+    def exclude(self, pattern: str) -> Runner:
+        self._exclude_patterns.add(re.compile(pattern))
+        return self
+
+    def xfail(self, pattern: str) -> Runner:
+        self._xfail_patterns.add(re.compile(pattern))
+        return self
+
+    def enable_report(self) -> Runner:
+        import pytest  # noqa: PLC0415
+
+        for category, items_map in self._test_items.items():
+            for item in items_map.values():
+                item.func = pytest.mark.onnx_coverage(item.proto, category)(item.func)
+        return self
+
+    @property
+    def _filtered_test_items(self) -> dict[str, dict[str, TestItem]]:
+        filtered: dict[str, dict[str, TestItem]] = {}
+        for category, items_map in self._test_items.items():
+            filtered[category] = {}
+            for name, item in items_map.items():
+                if self._include_patterns and (
+                    not any(include.search(name) for include in self._include_patterns)
+                ):
+                    item.func = unittest.skip("no matched include pattern")(item.func)
+                for exclude in self._exclude_patterns:
+                    if exclude.search(name):
+                        item.func = unittest.skip(
+                            f'matched exclude pattern "{exclude.pattern}"'
+                        )(item.func)
+                for xfail in self._xfail_patterns:
+                    if xfail.search(name):
+                        item.func = unittest.expectedFailure(item.func)
+                filtered[category][name] = item
+        return filtered
+
+    @property
+    def test_cases(self) -> dict[str, type[unittest.TestCase]]:
+        """List of test cases to be applied on the parent scope
+        Example usage:
+            globals().update(BackendTest(backend).test_cases)
+        """
+        test_cases = {}
+        for category, items_map in self._filtered_test_items.items():
+            test_case_name = f"OnnxBackend{category}Test"
+            test_case = self._get_test_case(test_case_name)
+            for name, item in sorted(items_map.items()):
+                setattr(test_case, name, item.func)
+            test_cases[test_case_name] = test_case
+        return test_cases
+
+    @property
+    def test_suite(self) -> unittest.TestSuite:
+        """TestSuite that can be run by TestRunner
+        Example usage:
+            unittest.TextTestRunner().run(BackendTest(backend).test_suite)
+        """
+        suite = unittest.TestSuite()
+        for case in sorted(
+            self.test_cases.values(), key=lambda cl: cl.__class__.__name__
+        ):
+            suite.addTests(unittest.defaultTestLoader.loadTestsFromTestCase(case))
+        return suite
+
+    # For backward compatibility (we used to expose `.tests`)
+    @property
+    def tests(self) -> type[unittest.TestCase]:
+        """One single unittest.TestCase that hosts all the test functions
+        Example usage:
+            onnx_backend_tests = BackendTest(backend).tests
+        """
+        tests = self._get_test_case("OnnxBackendTest")
+        for items_map in sorted(
+            self._filtered_test_items.values(), key=lambda cl: cl.__class__.__name__
+        ):
+            for name, item in sorted(items_map.items()):
+                setattr(tests, name, item.func)
+        return tests
+
+    @classmethod
+    def assert_similar_outputs(
+        cls,
+        ref_outputs: Sequence[Any],
+        outputs: Sequence[Any],
+        rtol: float,
+        atol: float,
+        model_dir: str | None = None,
+    ) -> None:
+        try:
+            np.testing.assert_equal(len(outputs), len(ref_outputs))
+        except TypeError as e:
+            raise TypeError(
+                f"Unable to compare expected type {type(ref_outputs)} "
+                f"and runtime type {type(outputs)} (known test={model_dir or '?'!r})"
+            ) from e
+        for i in range(len(outputs)):
+            if isinstance(outputs[i], (list, tuple)):
+                if not isinstance(ref_outputs[i], (list, tuple)):
+                    raise AssertionError(  # noqa: TRY004
+                        f"Unexpected type {type(outputs[i])} for outputs[{i}]. Expected "
+                        f"type is {type(ref_outputs[i])} (known test={model_dir or '?'!r})."
+                    )
+                for j in range(len(outputs[i])):
+                    cls.assert_similar_outputs(
+                        ref_outputs[i][j],
+                        outputs[i][j],
+                        rtol,
+                        atol,
+                        model_dir=model_dir,
+                    )
+            else:
+                np.testing.assert_array_equal(
+                    outputs[i].shape,
+                    ref_outputs[i].shape,
+                    err_msg=f"Output {i} has incorrect shape",
+                )
+                if ref_outputs[i].dtype == object:
+                    # Strings
+                    np.testing.assert_array_equal(outputs[i], ref_outputs[i])
+                else:
+                    np.testing.assert_equal(outputs[i].dtype, ref_outputs[i].dtype)
+                    np.testing.assert_allclose(
+                        outputs[i], ref_outputs[i], rtol=rtol, atol=atol
+                    )
+
+    @classmethod
+    @retry_execute(3)
+    def download_model(
+        cls,
+        model_test: TestCase,
+        models_dir: str,
+    ) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            try:
+                assert model_test.url
+                print(
+                    f"Start downloading model {model_test.model_name} from {model_test.url}"
+                )
+                filename = os.path.join(tmpdir, "file")
+                urlretrieve(model_test.url, filename)
+                print("Done")
+                onnx.utils._extract_model_safe(filename, models_dir)
+            except Exception as e:
+                print(f"Failed to prepare data for model {model_test.model_name}: {e}")
+                raise
+
+    @classmethod
+    def prepare_model_data(cls, model_test: TestCase) -> str:
+        onnx_home = os.path.expanduser(
+            os.getenv("ONNX_HOME", os.path.join("~", ".onnx"))
+        )
+        models_dir = os.getenv("ONNX_MODELS", os.path.join(onnx_home, "models"))
+        model_dir: str = os.path.join(models_dir, model_test.model_name)
+        if not os.path.exists(os.path.join(model_dir, "model.onnx")):
+            if os.path.exists(model_dir):
+                bi = 0
+                while True:
+                    dest = f"{model_dir}.old.{bi}"
+                    if os.path.exists(dest):
+                        bi += 1
+                        continue
+                    shutil.move(model_dir, dest)
+                    break
+            os.makedirs(model_dir)
+
+            cls.download_model(model_test=model_test, models_dir=models_dir)
+        return model_dir
+
+    def _add_test(
+        self,
+        category: str,
+        test_name: str,
+        test_func: Callable[..., Any],
+        report_item: list[ModelProto | NodeProto | None],
+        devices: Iterable[str] = ("CPU", "CUDA"),
+        **kwargs: Any,
+    ) -> None:
+        # We don't prepend the 'test_' prefix to improve greppability
+        if not test_name.startswith("test_"):
+            raise ValueError(f"Test name must start with test_: {test_name}")
+
+        def add_device_test(device: str) -> None:
+            device_test_name = f"{test_name}_{device.lower()}"
+            if device_test_name in self._test_items[category]:
+                raise ValueError(
+                    f'Duplicated test name "{device_test_name}" in category "{category}"'
+                )
+
+            @unittest.skipIf(
+                not self.backend.supports_device(device),
+                f"Backend doesn't support device {device}",
+            )
+            @functools.wraps(test_func)
+            def device_test_func(*args: Any, **device_test_kwarg: Any) -> Any:
+                try:
+                    merged_kwargs = {**kwargs, **device_test_kwarg}
+                    return test_func(*args, device, **merged_kwargs)
+                except BackendIsNotSupposedToImplementIt as e:
+                    # hacky verbose reporting
+                    if "-v" in sys.argv or "--verbose" in sys.argv:
+                        print(f"Test {device_test_name} is effectively skipped: {e}")
+
+            self._test_items[category][device_test_name] = TestItem(
+                device_test_func, report_item
+            )
+
+        for device in devices:
+            add_device_test(device)
+
+    @staticmethod
+    def generate_dummy_data(
+        x: ValueInfoProto, seed: int = 0, name: str = "", random: bool = False
+    ) -> np.ndarray:
+        """Generates a random tensor based on the input definition."""
+        if not x.type.tensor_type:
+            raise NotImplementedError(
+                f"Input expected to have tensor type. "
+                f"Unable to generate random data for model {name!r} and input {x}."
+            )
+        if x.type.tensor_type.elem_type != 1:
+            raise NotImplementedError(
+                f"Currently limited to float tensors. "
+                f"Unable to generate random data for model {name!r} and input {x}."
+            )
+        shape = tuple(
+            d.dim_value if d.HasField("dim_value") else 1
+            for d in x.type.tensor_type.shape.dim
+        )
+        if random:
+            gen = np.random.default_rng(seed=seed)
+            return gen.random(shape, np.float32)
+        n = np.prod(shape)
+        return (np.arange(n).reshape(shape) / n).astype(np.float32)
+
+    def _add_model_test(self, model_test: TestCase, kind: str) -> None:
+        # model is loaded at runtime, note sometimes it could even
+        # never loaded if the test skipped
+        model_marker: list[ModelProto | NodeProto | None] = [None]
+
+        def run(test_self: Any, device: str, **kwargs) -> None:  # noqa: ARG001
+            if model_test.url is not None and model_test.url.startswith(
+                "onnx/backend/test/data/light/"
+            ):
+                # testing local files
+                model_pb_path = os.path.normpath(
+                    os.path.join(
+                        os.path.dirname(__file__),
+                        "..",
+                        "..",
+                        "..",
+                        "..",
+                        model_test.url,
+                    )
+                )
+                if not os.path.exists(model_pb_path):
+                    raise FileNotFoundError(f"Unable to find model {model_pb_path!r}.")
+                onnx_home = os.path.expanduser(
+                    os.getenv("ONNX_HOME", os.path.join("~", ".onnx"))
+                )
+                models_dir = os.getenv(
+                    "ONNX_MODELS", os.path.join(onnx_home, "models", "light")
+                )
+                model_dir: str = os.path.join(models_dir, model_test.model_name)
+                if not os.path.exists(model_dir):
+                    os.makedirs(model_dir)
+                use_dummy = True
+            else:
+                if model_test.model_dir is None:
+                    model_dir = self.prepare_model_data(model_test)
+                else:
+                    model_dir = model_test.model_dir
+                model_pb_path = os.path.join(model_dir, "model.onnx")
+                use_dummy = False
+
+            if not ONNX_ML and "ai_onnx_ml" in model_dir:
+                return
+
+            model = onnx.load(model_pb_path)
+            model_marker[0] = model
+            if (
+                hasattr(self.backend, "is_compatible")
+                and callable(self.backend.is_compatible)
+                and not self.backend.is_compatible(model)
+            ):
+                raise unittest.SkipTest("Not compatible with backend")
+
+            prepared_model = self.backend.prepare(model, device, **kwargs)
+            assert prepared_model is not None
+
+            if use_dummy:
+                # When the backend test goes through a test involving a
+                # model stored in onnx/backend/test/data/light,
+                # this function generates expected output coming from
+                # from ReferenceEvaluator run with random inputs.
+                # A couple of models include many Conv operators and the
+                # python implementation is slow (such as test_bvlc_alexnet).
+                with open(model_pb_path, "rb") as f:
+                    onx = onnx.load(f)
+
+                test_data_set = os.path.join(model_dir, "test_data_set_0")
+                if not os.path.exists(test_data_set):
+                    os.mkdir(test_data_set)
+                feeds = {}
+                inits = {i.name for i in onx.graph.initializer}
+                n_input = 0
+                inputs = []
+                for i in range(len(onx.graph.input)):
+                    if onx.graph.input[i].name in inits:
+                        continue
+                    name = os.path.join(test_data_set, f"input_{n_input}.pb")
+                    inputs.append(name)
+                    n_input += 1
+                    x = onx.graph.input[i]
+                    value = self.generate_dummy_data(
+                        x, seed=0, name=model_test.model_name, random=False
+                    )
+                    feeds[x.name] = value
+                    with open(name, "wb") as f:
+                        f.write(onnx.numpy_helper.from_array(value).SerializeToString())
+
+                # loads expected output if any available
+                prefix = os.path.splitext(model_pb_path)[0]
+                expected_outputs = []
+                for i in range(len(onx.graph.output)):
+                    name = f"{prefix}_output_{i}.pb"
+                    if os.path.exists(name):
+                        expected_outputs.append(name)
+                        continue
+                    expected_outputs = None
+                    break
+
+                if expected_outputs is None:
+                    ref = onnx.reference.ReferenceEvaluator(onx)
+                    outputs = ref.run(None, feeds)
+                    for i, o in enumerate(outputs):
+                        name = os.path.join(test_data_set, f"output_{i}.pb")
+                        with open(name, "wb") as f:
+                            f.write(onnx.numpy_helper.from_array(o).SerializeToString())
+                else:
+                    for i, o in enumerate(expected_outputs):
+                        name = os.path.join(test_data_set, f"output_{i}.pb")
+                        shutil.copy(o, name)
+            else:
+                # TODO after converting all npz files to protobuf, we can delete this.
+                for test_data_npz in glob.glob(
+                    os.path.join(model_dir, "test_data_*.npz")
+                ):
+                    test_data = np.load(test_data_npz, encoding="bytes")
+                    inputs = list(test_data["inputs"])
+                    outputs = list(prepared_model.run(inputs))
+                    ref_outputs = tuple(
+                        np.array(x) if not isinstance(x, (list, dict)) else x
+                        for f in test_data["outputs"]
+                    )
+                    self.assert_similar_outputs(
+                        ref_outputs,
+                        outputs,
+                        rtol=kwargs.get("rtol", model_test.rtol),
+                        atol=kwargs.get("atol", model_test.atol),
+                        model_dir=model_dir,
+                    )
+
+            for test_data_dir in glob.glob(os.path.join(model_dir, "test_data_set*")):
+                inputs = []
+                inputs_num = len(glob.glob(os.path.join(test_data_dir, "input_*.pb")))
+                for i in range(inputs_num):
+                    input_file = os.path.join(test_data_dir, f"input_{i}.pb")
+                    self._load_proto(input_file, inputs, model.graph.input[i].type)
+                ref_outputs = []
+                ref_outputs_num = len(
+                    glob.glob(os.path.join(test_data_dir, "output_*.pb"))
+                )
+                for i in range(ref_outputs_num):
+                    output_file = os.path.join(test_data_dir, f"output_{i}.pb")
+                    self._load_proto(
+                        output_file, ref_outputs, model.graph.output[i].type
+                    )
+                outputs = list(prepared_model.run(inputs))
+                self.assert_similar_outputs(
+                    ref_outputs,
+                    outputs,
+                    rtol=kwargs.get("rtol", model_test.rtol),
+                    atol=kwargs.get("atol", model_test.atol),
+                    model_dir=model_dir,
+                )
+
+        if model_test.name in self._test_kwargs:
+            self._add_test(
+                kind + "Model",
+                model_test.name,
+                run,
+                model_marker,
+                **self._test_kwargs[model_test.name],
+            )
+        else:
+            self._add_test(kind + "Model", model_test.name, run, model_marker)
+
+    def _load_proto(
+        self,
+        proto_filename: str,
+        target_list: list[np.ndarray | list[Any]],
+        model_type_proto: TypeProto,
+    ) -> None:
+        with open(proto_filename, "rb") as f:
+            protobuf_content = f.read()
+            if model_type_proto.HasField("sequence_type"):
+                sequence = onnx.SequenceProto()
+                sequence.ParseFromString(protobuf_content)
+                target_list.append(numpy_helper.to_list(sequence))
+            elif model_type_proto.HasField("tensor_type"):
+                tensor = onnx.TensorProto()
+                tensor.ParseFromString(protobuf_content)
+                t = numpy_helper.to_array(tensor)
+                assert isinstance(t, np.ndarray)
+                target_list.append(t)
+            elif model_type_proto.HasField("optional_type"):
+                optional = onnx.OptionalProto()
+                optional.ParseFromString(protobuf_content)
+                target_list.append(numpy_helper.to_optional(optional))  # type: ignore[arg-type]
+            else:
+                print(
+                    "Loading proto of that specific type (Map/Sparse Tensor) is currently not supported"
+                )
diff --git a/onnx/backend/test/runner/item.py b/onnx/backend/test/runner/item.py
new file mode 100644
index 0000000..205ded9
--- /dev/null
+++ b/onnx/backend/test/runner/item.py
@@ -0,0 +1,21 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import dataclasses
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from onnx import ModelProto, NodeProto
+
+# A container that hosts the test function and the associated
+# test item (ModelProto)
+
+
+@dataclasses.dataclass
+class TestItem:
+    func: Callable[..., Any]
+    proto: list[ModelProto | NodeProto | None]
diff --git a/onnx/backend/test/stat_coverage.py b/onnx/backend/test/stat_coverage.py
new file mode 100644
index 0000000..33abdce
--- /dev/null
+++ b/onnx/backend/test/stat_coverage.py
@@ -0,0 +1,299 @@
+#!/usr/bin/env python
+
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+from typing import IO, TYPE_CHECKING, Any
+
+from onnx import AttributeProto, defs, load
+from onnx.backend.test.case import collect_snippets
+from onnx.backend.test.loader import load_model_tests
+from onnx.backend.test.runner import Runner
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def is_ml(schemas: Sequence[defs.OpSchema]) -> bool:
+    return any(s.domain == "ai.onnx.ml" for s in schemas)
+
+
+def gen_outlines(f: IO[Any], ml: bool) -> None:
+    f.write("# Test Coverage Report")
+    if ml:
+        f.write(" (ONNX-ML Operators)\n")
+    else:
+        f.write(" (ONNX Core Operators)\n")
+    f.write("## Outlines\n")
+    f.write("* [Node Test Coverage](#node-test-coverage)\n")
+    f.write("* [Model Test Coverage](#model-test-coverage)\n")
+    f.write("* [Overall Test Coverage](#overall-test-coverage)\n")
+
+
+common_covered: Sequence[str] = []
+experimental_covered: Sequence[str] = []
+
+
+def gen_node_test_coverage(
+    schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool
+) -> None:
+    global common_covered  # noqa: PLW0603
+    global experimental_covered  # noqa: PLW0603
+    generators = set(
+        {
+            "Multinomial",
+            "RandomNormal",
+            "RandomNormalLike",
+            "RandomUniform",
+            "RandomUniformLike",
+        }
+    )
+    node_tests = collect_snippets()
+    common_covered = sorted(
+        s.name
+        for s in schemas
+        if s.name in node_tests
+        and s.support_level == defs.OpSchema.SupportType.COMMON
+        and (s.domain == "ai.onnx.ml") == ml
+    )
+    common_no_cover = sorted(
+        s.name
+        for s in schemas
+        if s.name not in node_tests
+        and s.support_level == defs.OpSchema.SupportType.COMMON
+        and (s.domain == "ai.onnx.ml") == ml
+    )
+    common_generator = sorted(name for name in common_no_cover if name in generators)
+    experimental_covered = sorted(
+        s.name
+        for s in schemas
+        if s.name in node_tests
+        and s.support_level == defs.OpSchema.SupportType.EXPERIMENTAL
+        and (s.domain == "ai.onnx.ml") == ml
+    )
+    experimental_no_cover = sorted(
+        s.name
+        for s in schemas
+        if s.name not in node_tests
+        and s.support_level == defs.OpSchema.SupportType.EXPERIMENTAL
+        and (s.domain == "ai.onnx.ml") == ml
+    )
+    experimental_generator = sorted(
+        name for name in experimental_no_cover if name in generators
+    )
+    num_common = len(common_covered) + len(common_no_cover) - len(common_generator)
+    num_experimental = (
+        len(experimental_covered)
+        + len(experimental_no_cover)
+        - len(experimental_generator)
+    )
+    f.write("# Node Test Coverage\n")
+    f.write("## Summary\n")
+    if num_common:
+        f.write(
+            f"Node tests have covered {len(common_covered)}/{num_common} "
+            f"({len(common_covered) / float(num_common) * 100:.2f}%, {len(common_generator)} "
+            f"generators excluded) common operators.\n\n"
+        )
+    else:
+        f.write("Node tests have covered 0/0 (N/A) common operators. \n\n")
+    if num_experimental:
+        f.write(
+            "Node tests have covered {}/{} ({:.2f}%, {} generators excluded) "  # noqa: UP032
+            "experimental operators.\n\n".format(
+                len(experimental_covered),
+                num_experimental,
+                (len(experimental_covered) / float(num_experimental) * 100),
+                len(experimental_generator),
+            )
+        )
+    else:
+        f.write("Node tests have covered 0/0 (N/A) experimental operators.\n\n")
+    titles = [
+        "&#x1F49A;Covered Common Operators",
+        "&#x1F494;No Cover Common Operators",
+        "&#x1F49A;Covered Experimental Operators",
+        "&#x1F494;No Cover Experimental Operators",
+    ]
+    all_lists = [
+        common_covered,
+        common_no_cover,
+        experimental_covered,
+        experimental_no_cover,
+    ]
+    for t in titles:
+        f.write(f"* [{t[9:]}](#{t[9:].lower().replace(' ', '-')})\n")
+    f.write("\n")
+    for t, l in zip(titles, all_lists, strict=False):  # noqa: E741
+        f.write(f"## {t}\n")
+        for s in l:
+            f.write(f"### {s}")
+            if s in node_tests:
+                f.write(
+                    f"\nThere are {len(node_tests[s])} test cases, listed as following:\n"
+                )
+                for summary, code in sorted(node_tests[s]):
+                    f.write("<details>\n")
+                    f.write(f"<summary>{summary}</summary>\n\n")
+                    f.write(f"```python\n{code}\n```\n\n")
+                    f.write("</details>\n")
+            else:  # noqa: PLR5501
+                if s in generators:
+                    f.write(" (random generator operator)\n")
+                else:
+                    f.write(" (call for test cases)\n")
+            f.write("\n\n")
+        f.write("<br/>\n\n")
+
+
+def gen_model_test_coverage(
+    schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool
+) -> None:
+    f.write("# Model Test Coverage\n")
+    # Process schemas
+    schema_dict = {}
+    for schema in schemas:
+        schema_dict[schema.name] = schema
+    # Load models from each model test using Runner.prepare_model_data
+    # Need to grab associated nodes
+    attrs: dict[str, dict[str, list[Any]]] = {}
+    model_paths: list[Any] = []
+    for rt in load_model_tests(kind="real"):
+        if rt.url.startswith("onnx/backend/test/data/light/"):
+            # testing local files
+            model_name = os.path.normpath(
+                os.path.join(os.path.dirname(__file__), "..", "..", "..", rt.url)
+            )
+            if not os.path.exists(model_name):
+                raise FileNotFoundError(f"Unable to find model {model_name!r}.")
+            model_paths.append(model_name)
+        else:
+            model_dir = Runner.prepare_model_data(rt)
+            model_paths.append(os.path.join(model_dir, "model.onnx"))
+    model_paths.sort()
+    model_written = False
+    for model_pb_path in model_paths:
+        model = load(model_pb_path)
+        if ml:
+            ml_present = False
+            for opset in model.opset_import:
+                if opset.domain == "ai.onnx.ml":
+                    ml_present = True
+            if not ml_present:
+                continue
+            model_written = True
+        f.write(f"## {model.graph.name}\n")
+        # Deconstruct model
+        num_covered = 0
+        for node in model.graph.node:
+            if node.op_type in common_covered or node.op_type in experimental_covered:
+                num_covered += 1
+                # Add details of which nodes are/aren't covered
+                # Iterate through and store each node's attributes
+                for attr in node.attribute:
+                    if node.op_type not in attrs:
+                        attrs[node.op_type] = {}
+                    if attr.name not in attrs[node.op_type]:
+                        attrs[node.op_type][attr.name] = []
+                    if attr.type == AttributeProto.FLOAT:
+                        if attr.f not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.f)
+                    elif attr.type == AttributeProto.INT:
+                        if attr.i not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.i)
+                    elif attr.type == AttributeProto.STRING:
+                        if attr.s not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.s)
+                    elif attr.type == AttributeProto.TENSOR:
+                        if attr.t not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.t)
+                    elif attr.type == AttributeProto.GRAPH:
+                        if attr.g not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.g)
+                    elif attr.type == AttributeProto.FLOATS:
+                        if attr.floats not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.floats)
+                    elif attr.type == AttributeProto.INTS:
+                        if attr.ints not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.ints)
+                    elif attr.type == AttributeProto.STRINGS:
+                        if attr.strings not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.strings)
+                    elif attr.type == AttributeProto.TENSORS:
+                        if attr.tensors not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.tensors)
+                    elif attr.type == AttributeProto.GRAPHS:
+                        if attr.graphs not in attrs[node.op_type][attr.name]:
+                            attrs[node.op_type][attr.name].append(attr.graphs)
+        f.write(
+            f"\n{model.graph.name} has {num_covered} nodes. "
+            f"Of these, {len(model.graph.node)} are covered by node tests "
+            f"({100.0 * float(num_covered) / float(len(model.graph.node))}%)\n\n\n"
+        )
+        # Iterate through attrs, print
+        f.write("<details>\n")
+        f.write("<summary>nodes</summary>\n\n")
+        for op in sorted(attrs):
+            f.write("<details>\n")
+            # Get total number of attributes for node schema
+            f.write(
+                f"<summary>{op}: {len(attrs[op])} out of {len(schema_dict[op].attributes)} attributes covered</summary>\n\n"
+            )
+            for attribute in sorted(schema_dict[op].attributes):
+                if attribute in attrs[op]:
+                    f.write(f"{attribute}: {len(attrs[op][attribute])}\n")
+                else:
+                    f.write(f"{attribute}: 0\n")
+            f.write("</details>\n")
+        f.write("</details>\n\n\n")
+    if not model_written and ml:
+        f.write("No model tests present for selected domain\n")
+
+
+def gen_overall_test_coverage(
+    f: IO[Any],
+) -> None:
+    f.write("# Overall Test Coverage\n")
+    f.write("## To be filled.\n")
+
+
+def gen_spdx(f: IO[Any]) -> None:
+    # REUSE-IgnoreStart
+    # This source file intentionally writes an SPDX header into the generated
+    # output file. The literal string would confuse the REUSE linter when
+    # scanning this source file; ignore this region for REUSE.
+    f.write("<!--- SPDX-License-Identifier: Apache-2.0 -->\n")
+    # REUSE-IgnoreEnd
+
+
+def main() -> None:
+    base_dir = os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
+    )
+    docs_dir = os.path.join(base_dir, "docs")
+    schemas = defs.get_all_schemas()
+
+    has_ml = is_ml(schemas)
+    fname = os.path.join(docs_dir, "TestCoverage.md")
+    with open(fname, "w+", newline="", encoding="utf-8") as f:  # type: ignore[assignment]
+        gen_spdx(f)
+        gen_outlines(f, False)
+        gen_node_test_coverage(schemas, f, False)
+        gen_model_test_coverage(schemas, f, False)
+        gen_overall_test_coverage(f)
+
+    if has_ml:
+        fname = os.path.join(docs_dir, "TestCoverage-ml.md")
+        with open(fname, "w+", newline="", encoding="utf-8") as f:  # type: ignore[assignment]
+            gen_spdx(f)
+            gen_outlines(f, True)
+            gen_node_test_coverage(schemas, f, True)
+            gen_model_test_coverage(schemas, f, True)
+            gen_overall_test_coverage(f)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/bin/__init__.py b/onnx/bin/__init__.py
new file mode 100644
index 0000000..c974daf
--- /dev/null
+++ b/onnx/bin/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
diff --git a/onnx/bin/checker.py b/onnx/bin/checker.py
new file mode 100644
index 0000000..26f337e
--- /dev/null
+++ b/onnx/bin/checker.py
@@ -0,0 +1,27 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import argparse
+
+from onnx import NodeProto, checker, load
+
+
+def check_model() -> None:
+    parser = argparse.ArgumentParser("check-model")
+    parser.add_argument("model_pb", type=argparse.FileType("rb"))
+    args = parser.parse_args()
+
+    model = load(args.model_pb)
+    checker.check_model(model)
+
+
+def check_node() -> None:
+    parser = argparse.ArgumentParser("check-node")
+    parser.add_argument("node_pb", type=argparse.FileType("rb"))
+    args = parser.parse_args()
+
+    node = NodeProto()
+    node.ParseFromString(args.node_pb.read())
+    checker.check_node(node)
diff --git a/onnx/checker.cc b/onnx/checker.cc
new file mode 100644
index 0000000..567d7e0
--- /dev/null
+++ b/onnx/checker.cc
@@ -0,0 +1,1550 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/checker.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <filesystem> // NOLINT(build/c++17)
+#include <iostream>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "onnx/common/file_utils.h"
+#include "onnx/common/path.h"
+#include "onnx/common/proto_util.h"
+#include "onnx/common/safe_math.h"
+#include "onnx/common/scoped_resource.h"
+#include "onnx/defs/tensor_proto_util.h"
+#include "onnx/shape_inference/implementation.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+#include <fcntl.h>
+#include <io.h>
+#else
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+// Kernel-level path containment: prefer openat2 (Linux 5.6+) or
+// O_RESOLVE_BENEATH (FreeBSD 13+, macOS 15+) when available.
+#ifdef __linux__
+#include <sys/syscall.h>
+#ifdef SYS_openat2
+#define ONNX_HAS_OPENAT2
+#if __has_include(<linux/openat2.h>)
+#include <linux/openat2.h>
+#else
+struct open_how {
+  uint64_t flags;
+  uint64_t mode;
+  uint64_t resolve;
+};
+#define RESOLVE_NO_SYMLINKS 0x04
+#define RESOLVE_BENEATH 0x08
+#endif
+#endif // SYS_openat2
+#endif // __linux__
+
+#ifdef O_RESOLVE_BENEATH
+#define ONNX_HAS_RESOLVE_BENEATH
+#endif
+
+#endif // _WIN32
+
+namespace ONNX_NAMESPACE {
+namespace checker {
+
+#define enforce_has_field(proto, field)                                              \
+  do {                                                                               \
+    if (!(proto).has_##field()) {                                                    \
+      fail_check("Field '", #field, "' of '", #proto, "' is required but missing."); \
+    }                                                                                \
+  } while (0)
+
+#define enforce_non_empty_field(proto, field)                                            \
+  do {                                                                                   \
+    if ((proto).field().empty()) {                                                       \
+      fail_check("Field '", #field, "' of '", #proto, "' is required to be non-empty."); \
+    }                                                                                    \
+  } while (0)
+
+void check_value_info(const ValueInfoProto& value_info, const CheckerContext& ctx) {
+  enforce_non_empty_field(value_info, name);
+  // Relax constraint for subgraph input/output.
+  if (!ctx.is_main_graph())
+    return;
+  enforce_has_field(value_info, type);
+  const auto value_case = value_info.type().value_case();
+  switch (value_case) {
+    case TypeProto::kTensorType: {
+      const auto& type = value_info.type().tensor_type();
+      enforce_has_field(type, elem_type);
+      enforce_has_field(type, shape);
+    } break;
+    case TypeProto::kOptionalType: {
+      const auto& type = value_info.type().optional_type();
+      enforce_has_field(type, elem_type);
+    } break;
+    case TypeProto::kSequenceType: {
+      const auto& type = value_info.type().sequence_type();
+      enforce_has_field(type, elem_type);
+    } break;
+    case TypeProto::kMapType: {
+      const auto& type = value_info.type().map_type();
+      enforce_has_field(type, key_type);
+      enforce_has_field(type, value_type);
+    } break;
+#ifdef ONNX_ML
+    case TypeProto::kOpaqueType:
+      break;
+#endif
+    case TypeProto::kSparseTensorType: {
+      const auto& type = value_info.type().sparse_tensor_type();
+      enforce_has_field(type, elem_type);
+      enforce_has_field(type, shape);
+    } break;
+
+    default:
+      fail_check("Unrecognized type value case (value_info name: ", value_info.name(), "): ", value_case);
+  }
+}
+
+void check_tensor(const TensorProto& tensor, const CheckerContext& ctx) {
+  enforce_has_field(tensor, data_type);
+  if (tensor.data_type() == TensorProto::UNDEFINED) {
+    fail_check("setting data_type field (tensor name: ", tensor.name(), ") to UNDEFINED is not allowed");
+  }
+
+  int num_value_fields = 0;
+
+  const char* value_field = nullptr;
+
+#define check_data_field(field)               \
+  bool has_##field = !tensor.field().empty(); \
+  if (has_##field) {                          \
+    ++num_value_fields;                       \
+    value_field = #field;                     \
+  }
+
+  check_data_field(float_data);
+  check_data_field(int32_data);
+  check_data_field(string_data);
+  check_data_field(int64_data);
+  check_data_field(raw_data);
+  check_data_field(double_data);
+  check_data_field(uint64_data);
+
+#undef check_data_field
+
+  bool stored_externally = tensor.has_data_location() && tensor.data_location() == TensorProto::EXTERNAL;
+  if (stored_externally) {
+    if (num_value_fields != 0) {
+      fail_check(
+          "Data of TensorProto ( tensor name: ",
+          tensor.name(),
+          ") is stored externally and should not have data field.",
+          value_field);
+    }
+
+    bool has_location = false;
+    for (const StringStringEntryProto& entry : tensor.external_data()) {
+      if (entry.has_key() && entry.has_value() && entry.key() == "location") {
+        has_location = true;
+        resolve_external_data_location(ctx.get_model_dir(), entry.value(), tensor.name());
+      }
+    }
+    if (!has_location) {
+      fail_check("TensorProto ( tensor name: ", tensor.name(), ") is stored externally but doesn't have a location.");
+    }
+    return;
+  }
+  int64_t nelem =
+      safe_dim_product(tensor.dims(), [&](const char* msg) { fail_check(msg, " (tensor name: ", tensor.name(), ")"); });
+  if (nelem == 0 && num_value_fields != 0) {
+    fail_check("TensorProto (tensor name: ", tensor.name(), ") is 0-element but contains data!");
+  }
+  if (nelem != 0 && num_value_fields != 1) {
+    fail_check("TensorProto (tensor name: ", tensor.name(), ") should contain one and only one value field.");
+  }
+  if (has_raw_data) {
+    if (tensor.data_type() == TensorProto::STRING) {
+      fail_check("STRING data (tensor name: ", tensor.name(), ") should not be stored in raw_data field");
+    }
+    // Validate that raw_data is large enough for the declared packed sub-byte type and shape.
+    int64_t expected_bytes = 0;
+    switch (tensor.data_type()) {
+      case TensorProto::UINT4:
+      case TensorProto::INT4:
+      case TensorProto::FLOAT4E2M1:
+        expected_bytes = (nelem + 1) / 2; // 2 elements per byte, ceiling division
+        break;
+      case TensorProto::UINT2:
+      case TensorProto::INT2:
+        expected_bytes = (nelem + 3) / 4; // 4 elements per byte, ceiling division
+        break;
+      default:
+        break;
+    }
+    if (expected_bytes > 0 && static_cast<int64_t>(tensor.raw_data().size()) < expected_bytes) {
+      fail_check(
+          "TensorProto (tensor name: ",
+          tensor.name(),
+          ") raw_data size (",
+          tensor.raw_data().size(),
+          " bytes) is too small for the declared shape and packed type (",
+          expected_bytes,
+          " bytes required).");
+    }
+    return;
+  } else {
+#define check_field(field)               \
+  if (nelem != 0 && !has_##field) {      \
+    fail_check(                          \
+        "values of data_type '",         \
+        tensor.data_type(),              \
+        "' should be stored in field '", \
+        #field,                          \
+        "' instead of '",                \
+        value_field,                     \
+        "'");                            \
+  }
+
+    switch (tensor.data_type()) {
+      case TensorProto::FLOAT:
+      case TensorProto::COMPLEX64:
+        check_field(float_data);
+        break;
+
+      case TensorProto::DOUBLE:
+      case TensorProto::COMPLEX128:
+        check_field(double_data);
+        break;
+
+      case TensorProto::INT32:
+      case TensorProto::UINT8:
+      case TensorProto::INT8:
+      case TensorProto::UINT16:
+      case TensorProto::INT16:
+      case TensorProto::BOOL:
+      case TensorProto::FLOAT16:
+      case TensorProto::BFLOAT16:
+      case TensorProto::FLOAT8E4M3FN:
+      case TensorProto::FLOAT8E4M3FNUZ:
+      case TensorProto::FLOAT8E5M2:
+      case TensorProto::FLOAT8E5M2FNUZ:
+      case TensorProto::FLOAT8E8M0:
+      case TensorProto::UINT4:
+      case TensorProto::INT4:
+      case TensorProto::FLOAT4E2M1:
+        check_field(int32_data);
+        if (nelem > 0) {
+          // Each int32 stores 4 bytes = 8 4-bit elements.
+          const int64_t expected_int32s = (nelem + 7) / 8;
+          if (static_cast<int64_t>(tensor.int32_data().size()) < expected_int32s) {
+            fail_check(
+                "TensorProto (tensor name: ",
+                tensor.name(),
+                ") int32_data size (",
+                tensor.int32_data().size(),
+                ") is too small for the declared shape and packed type (",
+                expected_int32s,
+                " int32 values required).");
+          }
+        }
+        break;
+      case TensorProto::UINT2:
+      case TensorProto::INT2:
+        check_field(int32_data);
+        if (nelem > 0) {
+          // Each int32 stores 4 bytes = 16 2-bit elements.
+          const int64_t expected_int32s = (nelem + 15) / 16;
+          if (static_cast<int64_t>(tensor.int32_data().size()) < expected_int32s) {
+            fail_check(
+                "TensorProto (tensor name: ",
+                tensor.name(),
+                ") int32_data size (",
+                tensor.int32_data().size(),
+                ") is too small for the declared shape and packed type (",
+                expected_int32s,
+                " int32 values required).");
+          }
+        }
+        break;
+
+      case TensorProto::INT64:
+        check_field(int64_data);
+        break;
+
+      case TensorProto::UINT32:
+      case TensorProto::UINT64:
+        check_field(uint64_data);
+        break;
+
+      case TensorProto::STRING:
+        check_field(string_data);
+        break;
+
+      default:
+        fail_check("Unrecognized data_type (tensor name: ", tensor.name(), "): ", tensor.data_type());
+    }
+  }
+
+#undef check_field
+}
+
+void check_sequence(const SequenceProto& sequence, const CheckerContext& ctx) {
+  enforce_has_field(sequence, elem_type);
+  if (sequence.elem_type() == SequenceProto::TENSOR) {
+    for (const TensorProto& tensor : sequence.tensor_values()) {
+      check_tensor(tensor, ctx);
+    }
+  } else if (sequence.elem_type() == SequenceProto::SPARSE_TENSOR) {
+    for (const SparseTensorProto& sparse_tensor : sequence.sparse_tensor_values()) {
+      check_sparse_tensor(sparse_tensor, ctx);
+    }
+  } else if (sequence.elem_type() == SequenceProto::SEQUENCE) {
+    for (const SequenceProto& seq : sequence.sequence_values()) {
+      check_sequence(seq, ctx);
+    }
+  } else if (sequence.elem_type() == SequenceProto::MAP) {
+    for (const MapProto& map : sequence.map_values()) {
+      check_map(map, ctx);
+    }
+  } else {
+    fail_check(
+        "Sequence ( Structure name: ",
+        sequence.name(),
+        ", elem_type: ",
+        sequence.elem_type(),
+        ") is not have a valid element type.");
+  }
+}
+
+void check_optional(const OptionalProto& optional, const CheckerContext& ctx) {
+  enforce_has_field(optional, elem_type);
+  if (optional.elem_type() == OptionalProto::UNDEFINED) {
+    return;
+  } else if (optional.elem_type() == OptionalProto::TENSOR) {
+    if (optional.has_tensor_value())
+      check_tensor(optional.tensor_value(), ctx);
+  } else if (optional.elem_type() == OptionalProto::SPARSE_TENSOR) {
+    if (optional.has_sparse_tensor_value())
+      check_sparse_tensor(optional.sparse_tensor_value(), ctx);
+  } else if (optional.elem_type() == OptionalProto::SEQUENCE) {
+    if (optional.has_sequence_value())
+      check_sequence(optional.sequence_value(), ctx);
+  } else if (optional.elem_type() == OptionalProto::MAP) {
+    if (optional.has_map_value())
+      check_map(optional.map_value(), ctx);
+  } else {
+    fail_check(
+        "Optional ( Structure name: ",
+        optional.name(),
+        ", elem_type: ",
+        optional.elem_type(),
+        ") is not have a valid element type.");
+  }
+}
+
+void check_map(const MapProto& map, const CheckerContext& ctx) {
+  enforce_has_field(map, key_type);
+  if (map.key_type() == TensorProto::UNDEFINED) {
+    fail_check("setting key_type field (map name: ", map.name(), ") to UNDEFINED is not allowed");
+  }
+  // Check if key is a valid type, specifically INT8, INT16, INT32, INT64,
+  // UINT8, UINT16, UINT32, UINT64, or STRING.
+  if ((map.key_type() == TensorProto::FLOAT) || (map.key_type() == TensorProto::BOOL) ||
+      (map.key_type() == TensorProto::FLOAT16) || (map.key_type() == TensorProto::COMPLEX64) ||
+      (map.key_type() == TensorProto::COMPLEX128)) {
+    fail_check(
+        "setting key_type field (map name: ",
+        map.name(),
+        ") to invalid TensorProto key_type ",
+        map.key_type(),
+        " is not allowed");
+  }
+
+  // MapProto will use either keys or string_keys, so only one should be > 0.
+  if ((map.keys_size() > 0) && (map.string_keys_size() > 0)) {
+    fail_check("Map (name: ", map.name(), ") should not contain more than one keys field.");
+  }
+
+  int num_keys = map.keys_size() + map.string_keys_size();
+  int num_values = 0;
+
+  enforce_has_field(map, values);
+  check_sequence(map.values(), ctx);
+
+  if (map.values().elem_type() == SequenceProto::TENSOR) {
+    num_values = map.values().tensor_values_size();
+  } else if (map.values().elem_type() == SequenceProto::SPARSE_TENSOR) {
+    num_values = map.values().sparse_tensor_values_size();
+  } else if (map.values().elem_type() == SequenceProto::SEQUENCE) {
+    num_values = map.values().sequence_values_size();
+  } else if (map.values().elem_type() == SequenceProto::MAP) {
+    num_values = map.values().map_values_size();
+  }
+
+  if (num_keys != num_values) {
+    fail_check("Length of map keys and map values are not the same (map name: ", map.name(), ")");
+  }
+}
+
+// Check that the index data stored in a SparseTensorProto is valid.
+// indices: a 1-dimensional tensor; indices[i] represents the
+// linearized index value for the i-th nonzero value.
+static void
+check_sparse_tensor_indices_1(const TensorProto& indices, const SparseTensorProto& sparse_tensor_proto, size_t nnz) {
+  int dense_rank = sparse_tensor_proto.dims_size();
+  int64_t dense_size = 1;
+  for (int i = 0; i < dense_rank; ++i)
+    dense_size *= sparse_tensor_proto.dims(i);
+  if (static_cast<size_t>(indices.dims(0)) != nnz) {
+    fail_check("Sparse tensor indices (", indices.name(), ") has ", indices.dims(0), " values, but NNZ is ", nnz);
+  }
+
+  // Check if indices appear in ascending order, and if they have valid
+  // values. The i-th value in index_data is the linear index of the i-th
+  // non-zero value.
+  const std::vector<int64_t> index_data = ParseData<int64_t>(&indices);
+
+  int64_t prev_index = -1;
+  for (size_t i = 0; i < nnz; ++i) {
+    int64_t curr_index = index_data[i]; // linearized index of i-th value
+    if (curr_index < 0 || curr_index >= dense_size) {
+      fail_check(
+          "Sparse tensor (",
+          indices.name(),
+          ") index value at position [",
+          i,
+          "] out of range [0, ",
+          dense_size - 1,
+          "]");
+    }
+    if (curr_index <= prev_index) {
+      fail_check("Sparse tensor (", indices.name(), ") index value at position [", i, "] not in sorted order.");
+    }
+    prev_index = curr_index;
+  }
+}
+
+// Check that the index data stored in a SparseTensorProto is valid.
+// indices: a 2-dimensional tensor; indices[i,j] represents the j-th
+// index value for the i-th nonzero value.
+static void
+check_sparse_tensor_indices_2(const TensorProto& indices, const SparseTensorProto& sparse_tensor_proto, size_t nnz) {
+  int dense_rank = sparse_tensor_proto.dims_size();
+  if (static_cast<size_t>(indices.dims(0)) != nnz) {
+    fail_check("Sparse tensor indices (", indices.name(), ") first dimension size does not equal NNZ.");
+  }
+  if (indices.dims(1) != dense_rank) {
+    fail_check("Sparse tensor indices (", indices.name(), ") second dimension size does not match rank of tensor.");
+  }
+
+  // Check if indices appear in ascending order, and if they have valid
+  // values.
+  const std::vector<int64_t> index_data = ParseData<int64_t>(&indices);
+  int64_t prev_index = -1;
+  for (size_t i = 0; i < nnz; ++i) {
+    int64_t curr_index = 0; // linearized index of i-th value
+    for (int j = 0; j < dense_rank; ++j) {
+      auto index_ij = index_data[i * dense_rank + j];
+      if ((index_ij < 0) || (index_ij >= sparse_tensor_proto.dims(j))) {
+        fail_check("Sparse tensor (", indices.name(), ") index value at position [", i, ",", j, "] out of range.");
+      }
+      curr_index = curr_index * sparse_tensor_proto.dims(j) + index_ij;
+    }
+    if (curr_index <= prev_index) {
+      fail_check(
+          "Sparse tensor (", indices.name(), ") index value at position [", i, "] not in lexicographic sorted order.");
+    }
+    prev_index = curr_index;
+  }
+}
+
+void check_sparse_tensor(const SparseTensorProto& sparse_tensor_proto, const CheckerContext& ctx) {
+  enforce_has_field(sparse_tensor_proto, values);
+
+  const TensorProto& values = sparse_tensor_proto.values();
+  check_tensor(values, ctx);
+
+  // values must be a tensor of shape [NNZ]
+  // Currently we restrict the value associated with a particular index-tuple
+  // to be a single value. In the future, if there is a requirement,
+  // we may extend this to permit the value to be a "sub-tensor", in which
+  // case values will have dimension > 1.
+  if (values.dims_size() != 1) {
+    fail_check("Sparse tensor values (", values.name(), ") must have rank 1.");
+  }
+  size_t nnz = static_cast<size_t>(values.dims(0));
+  int dense_rank = sparse_tensor_proto.dims_size();
+  if (dense_rank == 0) {
+    fail_check("Sparse tensor (", values.name(), ") must have a dense-rank > 0");
+  }
+  for (int i = 0; i < dense_rank; ++i) {
+    if (sparse_tensor_proto.dims(i) <= 0) {
+      fail_check("Sparse tensor (", values.name(), ") dimensions are not positive.");
+    }
+  }
+
+  if (sparse_tensor_proto.has_indices()) {
+    const TensorProto& indices = sparse_tensor_proto.indices();
+    check_tensor(indices, ctx);
+    if (indices.data_type() != TensorProto::INT64) {
+      fail_check("Sparse tensor indices (", indices.name(), ") must have INT64 type.");
+    }
+    switch (indices.dims().size()) {
+      case 1:
+        // Indices in linearized format
+        check_sparse_tensor_indices_1(indices, sparse_tensor_proto, nnz);
+        return;
+      case 2:
+        // Check COO-style index. E.g., an index for a 3D tensor is a 3-tuple.
+        check_sparse_tensor_indices_2(indices, sparse_tensor_proto, nnz);
+        return;
+      default:
+        fail_check("Sparse tensor indices (", indices.name(), ") must have rank 1 or 2.");
+    }
+  } else if (nnz != 0) {
+    fail_check("Sparse tensor (", values.name(), ") has no index values.");
+  }
+}
+
+// NB: This is a generic "attribute well-formedness" check, it doesn't
+// actually test if an attribute is valid per a schema
+void check_attribute(const AttributeProto& attr, const CheckerContext& ctx, const LexicalScopeContext& lex_ctx) {
+  enforce_non_empty_field(attr, name);
+
+  if (ctx.get_ir_version() >= 0x00000002) {
+    enforce_has_field(attr, type);
+  }
+
+  int used_fields = 0;
+
+#define check_type(expected_type)                                                     \
+  if (attr.has_type() && attr.type() != (expected_type)) {                            \
+    fail_check("type field and data field mismatch in attribute ", attr.name(), "."); \
+  }
+
+#define check_singular_field(field, type) \
+  if (attr.has_##field()) {               \
+    ++used_fields;                        \
+    check_type(type);                     \
+  }
+
+#define check_repeated_field(field, type) \
+  if (attr.field##_size() > 0) {          \
+    ++used_fields;                        \
+    check_type(type);                     \
+  }
+
+  check_singular_field(f, AttributeProto::FLOAT);
+  check_singular_field(i, AttributeProto::INT);
+  check_singular_field(s, AttributeProto::STRING);
+  check_singular_field(t, AttributeProto::TENSOR);
+  check_singular_field(g, AttributeProto::GRAPH);
+  check_singular_field(tp, AttributeProto::TYPE_PROTO);
+  check_singular_field(sparse_tensor, AttributeProto::SPARSE_TENSOR);
+  check_repeated_field(floats, AttributeProto::FLOATS);
+  check_repeated_field(ints, AttributeProto::INTS);
+  check_repeated_field(strings, AttributeProto::STRINGS);
+  check_repeated_field(tensors, AttributeProto::TENSORS);
+  check_repeated_field(graphs, AttributeProto::GRAPHS);
+  check_repeated_field(sparse_tensors, AttributeProto::SPARSE_TENSORS);
+  check_repeated_field(type_protos, AttributeProto::TYPE_PROTOS);
+
+#undef check_type
+#undef check_singular_field
+#undef check_repeated_field
+
+  // Normally, used_fields is expected to be 1.
+  // In proto3, when the value to be set is type default value (say 0 for
+  // int), used_fields may be 0.
+  if (used_fields > 1) {
+    fail_check("Attribute (name: ", attr.name(), ") should not contain more than one value field.");
+  }
+
+  if (!ctx.is_main_graph()) {
+    // It's an attribute of a node in function body.
+    if (attr.has_ref_attr_name() && used_fields != 0) {
+      // The attribute proto is supposed to refer to data outside and does not
+      // have its own value field set.
+      fail_check("Attribute (name: ", attr.name(), ") should refer to attribute in parent node.");
+    }
+  }
+
+  if (attr.has_t()) {
+    check_tensor(attr.t(), ctx);
+  }
+
+  if (attr.has_sparse_tensor()) {
+    check_sparse_tensor(attr.sparse_tensor(), ctx);
+  }
+
+  if (attr.has_g()) {
+    CheckerContext subgraph_ctx(ctx);
+    subgraph_ctx.set_is_main_graph(false);
+    check_graph(attr.g(), subgraph_ctx, lex_ctx);
+  }
+
+  for (const auto& tensor : attr.tensors()) {
+    check_tensor(tensor, ctx);
+  }
+  for (const auto& sparse_tensor : attr.sparse_tensors()) {
+    check_sparse_tensor(sparse_tensor, ctx);
+  }
+  if (!attr.graphs().empty()) {
+    CheckerContext subgraph_ctx(ctx);
+    subgraph_ctx.set_is_main_graph(false);
+    for (const auto& graph : attr.graphs()) {
+      check_graph(graph, subgraph_ctx, lex_ctx);
+    }
+  }
+}
+
+static void print_warning_if_has_experimental(const std::unordered_set<std::string>& used_experimental_ops) {
+  if (!used_experimental_ops.empty()) {
+    std::string all_experimental_ops;
+    for (const auto& op : used_experimental_ops) {
+      all_experimental_ops += " " + op + ",";
+    }
+    // Remove the last comma which is unnecessary
+    all_experimental_ops.pop_back();
+    std::cout << "Warning: Model contains experimental ops:" + all_experimental_ops << '\n';
+  }
+}
+
+void check_node(const NodeProto& node, const CheckerContext& ctx, const LexicalScopeContext& lex_ctx) {
+  enforce_non_empty_field(node, op_type);
+
+  if (node.input().empty() && node.output().empty()) {
+    fail_check("NodeProto (name: ", node.name(), ", type: ", node.op_type(), ") has zero input and zero output.");
+  }
+
+  // Resolve domain for node
+  const auto& opset_imports = ctx.get_opset_imports();
+  auto dit = opset_imports.find(node.domain());
+  if (dit == opset_imports.end()) {
+    // Both "" (ONNX_DOMAIN) and "ai.onnx" (AI_ONNX_DOMAIN) refer to the default ONNX domain
+    if (node.domain() == ONNX_DOMAIN) {
+      dit = opset_imports.find(AI_ONNX_DOMAIN);
+    }
+    if (dit == opset_imports.end()) {
+      fail_check("No opset import for domain '" + node.domain() + "'");
+    }
+  }
+  auto domain_version = dit->second;
+
+  // for ops referencing local functions, there is no schema to verify it.
+  // will add a check to verify consistency between these ops and local functions.
+  std::unordered_set<std::string> seen_attr_names{};
+  for (const auto& attr : node.attribute()) {
+    if (!seen_attr_names.insert(attr.name()).second) {
+      fail_check("Attribute '", attr.name(), "' appeared multiple times.");
+    }
+
+    check_attribute(attr, ctx, lex_ctx);
+  }
+
+  // This issue will be caught by check_graph instead
+  if (check_is_experimental_op(node)) {
+    return;
+  }
+
+  const auto* const schema = ctx.get_schema_registry()->GetSchema(node.op_type(), domain_version, node.domain());
+  if (!schema) {
+    if (node.domain() == ONNX_DOMAIN || node.domain() == AI_ONNX_ML_DOMAIN || node.domain() == "ai.onnx" ||
+        node.domain() == AI_ONNX_TRAINING_DOMAIN || ctx.check_custom_domain()) {
+      // fail the checker if op is in built-in domains or if it has no schema when `check_custom_domain` is true
+      fail_check(
+          "No Op registered for " + node.op_type() + " with domain_version of " +
+          ONNX_NAMESPACE::to_string(domain_version));
+    }
+  } else if (schema->Deprecated()) {
+    fail_check(
+        "Op registered for " + node.op_type() + " is deprecated in domain_version of " +
+        ONNX_NAMESPACE::to_string(domain_version));
+  } else {
+    schema->Verify(node);
+  }
+}
+
+void check_graph(const GraphProto& graph, const CheckerContext& ctx, const LexicalScopeContext& parent_lex) {
+  enforce_non_empty_field(graph, name);
+
+  for (const auto& value_info : graph.input()) {
+    check_value_info(value_info, ctx);
+  }
+  for (const auto& value_info : graph.output()) {
+    check_value_info(value_info, ctx);
+  }
+
+  // Inherit values available in outer scope
+  // Note that we do not allow shadowing, so the presence of an already-defined
+  // name is always an error.
+  LexicalScopeContext lex_ctx{parent_lex};
+
+  for (const auto& value_info : graph.input()) {
+    // TODO(ONNX): If shadowing isn't allowed, this should maybe use
+    // this_or_ancestor_graph_has
+    if (lex_ctx.this_graph_has(value_info.name())) {
+      fail_check(
+          "Graph must be in single static assignment (SSA) form, however '",
+          value_info.name(),
+          "' has been used as graph input names multiple times.");
+    }
+    lex_ctx.add(value_info.name());
+  }
+
+  std::unordered_set<std::string> initializer_name_checker;
+
+  for (const auto& init : graph.initializer()) {
+    enforce_has_field(init, name);
+    const auto& name = init.name();
+    if (name.empty()) {
+      fail_check("Tensor initializers must have a non-empty name");
+    }
+
+    if (!initializer_name_checker.emplace(name).second) {
+      fail_check(name + " initializer name is not unique");
+    }
+
+    check_tensor(init, ctx);
+
+    if (ctx.get_ir_version() <= 0x00000003) {
+      // Initializers are a subset of graph inputs for IR_VERSION <= 3
+      if (!lex_ctx.this_graph_has(name)) {
+        fail_check(name + " in initializer but not in graph input");
+      }
+    } else {
+      // An initializer is allowed to have the same name as an input,
+      // but is not required to (for IR_VERSION >= 4)
+      lex_ctx.add(name);
+    }
+  }
+
+  for (const auto& sparse_init : graph.sparse_initializer()) {
+    const auto& values = sparse_init.values();
+    enforce_has_field(values, name);
+    const auto& name = values.name();
+    if (name.empty()) {
+      fail_check("Sparse tensor initializers must have a non-empty name");
+    }
+    if (!initializer_name_checker.insert(name).second) {
+      fail_check(name + " sparse initializer name is not unique across initializers and sparse_initializers");
+    }
+    check_sparse_tensor(sparse_init, ctx);
+    lex_ctx.add(name);
+  }
+  std::unordered_set<std::string> used_experimental_ops;
+  for (const auto& node : graph.node()) {
+    // nodes must be in topologically sorted order
+    for (const auto& input : node.input()) {
+      // explicit optional input
+      if (input.empty()) {
+        continue;
+      }
+      if (!lex_ctx.this_or_ancestor_graph_has(input)) {
+        fail_check(
+            "Nodes in a graph must be topologically sorted, however input '",
+            input,
+            "' of node: \n",
+            "name: ",
+            node.name(),
+            " OpType: ",
+            node.op_type(),
+            "\n is not output of any previous nodes.");
+      }
+    }
+
+    if (check_is_experimental_op(node)) {
+      used_experimental_ops.insert(node.op_type());
+    }
+
+    // This needs to happen before SSA check since we don't want to recurse and
+    // find that outputs from control flow ops are colliding with names in the
+    // inner block
+
+    ONNX_TRY {
+      check_node(node, ctx, lex_ctx);
+    }
+    ONNX_CATCH(ValidationError & ex) {
+      ONNX_HANDLE_EXCEPTION([&]() {
+        ex.AppendContext("Bad node spec for node. Name: " + node.name() + " OpType: " + node.op_type());
+        // Rethrow without copying to avoid triggering
+        // bugprone-exception-copy-constructor-throws.
+        // The in-place AppendContext modification is preserved because
+        // `ex` is a reference to the active exception object.
+        throw;
+      });
+    }
+    // check for SSA form
+    for (const auto& output : node.output()) {
+      // optional output
+      if (output.empty()) {
+        continue;
+      }
+
+      if (lex_ctx.this_or_ancestor_graph_has(output)) {
+        fail_check(
+            "Graph must be in single static assignment (SSA) form, however '",
+            output,
+            "' has been used as output names multiple times.");
+      }
+      lex_ctx.add(output);
+    }
+  }
+  for (const auto& value_info : graph.output()) {
+    if (!lex_ctx.this_graph_has(value_info.name())) {
+      fail_check("Graph output '", value_info.name(), "' is not an output of any node in graph.");
+    }
+  }
+
+  print_warning_if_has_experimental(used_experimental_ops);
+}
+
+// Utilify function to get the imported version of domain from opset imports
+// Returns -1 if requested domain is not found in the opset_imports
+static int get_version_for_domain(
+    const std::string& domain,
+    const std::unordered_map<std::string, int>& opset_imports) {
+  auto it = opset_imports.find(domain);
+  if (it == opset_imports.end()) {
+    return -1;
+  }
+
+  return it->second;
+}
+
+void check_opset_compatibility(
+    const NodeProto& node,
+    const CheckerContext& ctx,
+    const std::unordered_map<std::string, int>& func_opset_imports,
+    const std::unordered_map<std::string, int>& model_opset_imports) {
+  auto func_opset_version = get_version_for_domain(node.domain(), func_opset_imports);
+  auto model_opset_version = get_version_for_domain(node.domain(), model_opset_imports);
+
+  if (func_opset_version == -1) {
+    fail_check("No Opset registered for domain " + node.domain());
+  }
+
+  if (model_opset_version == -1) {
+    // model does not include opset import for a node present in function body.
+    // This is ok as along as the opset import is present in function level opset imports.
+    return;
+  }
+
+  if (func_opset_version == model_opset_version) {
+    // both versions are same, no need to verify schema.
+    return;
+  }
+
+  const auto* const schema_for_model_import =
+      ctx.get_schema_registry()->GetSchema(node.op_type(), model_opset_version, node.domain());
+
+  const auto* const schema_for_function_import =
+      ctx.get_schema_registry()->GetSchema(node.op_type(), func_opset_version, node.domain());
+
+  if (!schema_for_model_import && !schema_for_function_import) {
+    // the op belongs to a custom domain so we cannot verify schema
+    return;
+  }
+
+  // if schema is present for 1 but not other or the schema since versions do not match then raise an error
+  if (!schema_for_model_import || !schema_for_function_import ||
+      schema_for_function_import->since_version() != schema_for_model_import->since_version()) {
+    fail_check(
+        "Opset import for domain " + node.domain() + " in function op " + node.op_type() +
+        "is not compatible with the version imported by model. FunctionOp imports version " +
+        ONNX_NAMESPACE::to_string(func_opset_version) + " whereas model imports version " +
+        ONNX_NAMESPACE::to_string(model_opset_version));
+  }
+}
+
+namespace {
+
+using FuncPtr = const FunctionProto*;
+using CallGraph = std::unordered_map<FuncPtr, std::unordered_set<FuncPtr>>;
+
+// Limits to reject obviously malicious models early.
+constexpr int kMaxModelLocalFunctions = 10000;
+constexpr size_t kMaxFunctionCallDepth = 100;
+
+enum class VisitState : uint8_t { Unvisited, InPath, Done };
+
+// Iterative DFS to detect cycles in the function call graph.
+// Uses an explicit stack to avoid stack overflow on deeply-chained models.
+void DetectCycleDFS(
+    FuncPtr root,
+    const CallGraph& call_graph,
+    std::unordered_map<FuncPtr, VisitState>& state,
+    std::vector<FuncPtr>& path) {
+  // Each frame tracks the current function and an iterator into its callees.
+  using Iter = std::unordered_set<FuncPtr>::const_iterator;
+  struct Frame {
+    FuncPtr func;
+    Iter cur;
+    Iter end;
+  };
+  std::vector<Frame> stack;
+
+  auto push = [&](FuncPtr func) {
+    state[func] = VisitState::InPath;
+    path.push_back(func);
+    if (path.size() > kMaxFunctionCallDepth) {
+      fail_check(
+          "Function call chain depth exceeds limit (",
+          kMaxFunctionCallDepth,
+          "). The model may be malformed or malicious.");
+    }
+    auto it = call_graph.find(func);
+    if (it != call_graph.end()) {
+      stack.push_back({func, it->second.begin(), it->second.end()});
+    } else {
+      stack.push_back({func, {}, {}});
+    }
+  };
+
+  push(root);
+
+  while (!stack.empty()) {
+    auto& frame = stack.back();
+
+    if (frame.cur == frame.end) {
+      // All callees processed — backtrack.
+      path.pop_back();
+      state[frame.func] = VisitState::Done;
+      stack.pop_back();
+      continue;
+    }
+
+    FuncPtr callee = *frame.cur;
+    ++frame.cur;
+
+    auto s = state[callee];
+    if (s == VisitState::InPath) {
+      auto start = std::find(path.begin(), path.end(), callee);
+      std::string cycle;
+      for (auto cit = start; cit != path.end(); ++cit)
+        cycle += (cit == start ? "" : " -> ") + GetFunctionImplId(**cit);
+      fail_check(
+          "Cycle detected in model-local function references: ",
+          cycle,
+          " -> ",
+          GetFunctionImplId(*callee),
+          ". Self-referencing or cyclically-referencing functions would cause infinite recursion.");
+    } else if (s == VisitState::Unvisited) {
+      push(callee);
+    }
+  }
+}
+
+// Collect callee edges from a list of nodes into the callee set. A node in a
+// function body may carry subgraphs (via GRAPH / GRAPHS attributes on control-flow
+// ops such as If/Loop/Scan) whose own nodes can also call model-local functions, so
+// we descend recursively to detect cycles hidden at any nesting level. This follows the
+// same subgraph descent as the existing checker recursion (check_graph -> check_node ->
+// check_attribute -> check_graph) and does not add a new unbounded-recursion characteristic.
+void CollectCalleeEdges(
+    const google::protobuf::RepeatedPtrField<NodeProto>& nodes,
+    const std::unordered_map<std::string, FuncPtr>& func_by_key,
+    std::unordered_set<FuncPtr>& callees) {
+  for (const auto& node : nodes) {
+    auto it = func_by_key.find(GetCalleeId(node));
+    if (it != func_by_key.end()) {
+      callees.insert(it->second);
+    }
+    // has_g() guards the singular GRAPH attribute; graphs() is the repeated GRAPHS field.
+    for (const auto& attr : node.attribute()) {
+      if (attr.has_g()) {
+        CollectCalleeEdges(attr.g().node(), func_by_key, callees);
+      }
+      for (const auto& subgraph : attr.graphs()) {
+        CollectCalleeEdges(subgraph.node(), func_by_key, callees);
+      }
+    }
+  }
+}
+
+} // namespace
+
+void check_function_call_cycles(const ModelProto& model) {
+  if (model.functions_size() > kMaxModelLocalFunctions) {
+    fail_check(
+        "Model contains ",
+        model.functions_size(),
+        " local functions, exceeding the limit of ",
+        kMaxModelLocalFunctions,
+        ". The model may be malformed or malicious.");
+  }
+
+  // Build function map: callee key -> FunctionProto pointer.
+  // Duplicate keys could mask cycles, so reject them here.
+  std::unordered_map<std::string, FuncPtr> func_by_key;
+  for (const auto& f : model.functions()) {
+    const auto function_impl_id = GetFunctionImplId(f);
+    const bool inserted = func_by_key.emplace(function_impl_id, &f).second;
+    if (!inserted) {
+      fail_check("Model contains multiple local functions with the same implementation id '", function_impl_id, "'.");
+    }
+  }
+
+  // Build adjacency list of FuncPtr edges. FuncPtr points into model.functions(), which
+  // outlives this local map, so storing raw pointers as graph nodes is safe here.
+  CallGraph call_graph;
+  for (const auto& entry : func_by_key) {
+    const auto* func = entry.second;
+    CollectCalleeEdges(func->node(), func_by_key, call_graph[func]);
+  }
+
+  std::unordered_map<FuncPtr, VisitState> state;
+  std::vector<FuncPtr> path;
+  for (const auto& entry : func_by_key) {
+    if (state[entry.second] == VisitState::Unvisited) {
+      DetectCycleDFS(entry.second, call_graph, state, path);
+    }
+  }
+}
+
+void check_model_local_functions(
+    const ModelProto& model,
+    const CheckerContext& ctx,
+    const LexicalScopeContext& parent_lex) {
+  // make a copy of model opset imports to maintain a main copy of opset imports across the model and
+  // all model local functions to verify opset compatibility
+  std::unordered_map<std::string, int> model_opset_imports(ctx.get_opset_imports());
+
+  // merge the opset imports from every function in model_opset_imports
+  // only add the opset import if an entry for it does not exist in model_opset_imports
+  // if there is an entry then the compatibility will be checked later on in check_opset_compatibility
+  // called by check_function.
+  for (const auto& function_proto : model.functions()) {
+    for (const auto& opset_import : function_proto.opset_import()) {
+      if (get_version_for_domain(opset_import.domain(), model_opset_imports) == -1) {
+        model_opset_imports[opset_import.domain()] = opset_import.version();
+      }
+    }
+  }
+
+  check_function_call_cycles(model);
+
+  CheckerContext ctx_copy = ctx;
+  ctx_copy.set_opset_imports(model_opset_imports);
+
+  for (const auto& function_proto : model.functions()) {
+    check_function(function_proto, ctx_copy, parent_lex);
+  }
+}
+
+void check_function(const FunctionProto& function, const CheckerContext& ctx, const LexicalScopeContext& parent_lex) {
+  enforce_non_empty_field(function, name);
+
+  if (ctx.get_ir_version() >= 0x00000008) {
+    enforce_has_field(function, domain);
+  }
+
+  const auto& model_opset_imports = ctx.get_opset_imports();
+  CheckerContext ctx_copy = ctx;
+
+  std::unordered_map<std::string, int> func_opset_imports;
+  for (const auto& relied_opset : function.opset_import()) {
+    func_opset_imports[relied_opset.domain()] = static_cast<int>(relied_opset.version());
+  }
+
+  ctx_copy.set_opset_imports(func_opset_imports);
+
+  LexicalScopeContext lex_ctx{parent_lex};
+
+  for (const auto& input : function.input()) {
+    // TODO(ONNX): If shadowing isn't allowed, this should maybe use
+    // this_or_ancestor_graph_has
+    if (lex_ctx.this_graph_has(input)) {
+      fail_check(
+          "Graph must be in single static assignment (SSA) form, however '", input, "' has been used multiple times.");
+    }
+    lex_ctx.add(input);
+  }
+
+  std::unordered_set<std::string> outputs;
+  for (const auto& output : function.output()) {
+    if (!outputs.insert(output).second) {
+      fail_check("function (", function.name(), ") should not have duplicate outputs specified.");
+    }
+  }
+
+  std::unordered_set<std::string> attrs;
+  for (const auto& attr : function.attribute()) {
+    if (!attrs.insert(attr).second) {
+      fail_check("function (", function.name(), ") should not have duplicate attributes specified.");
+    }
+  }
+  std::unordered_set<std::string> used_experimental_ops;
+  for (const auto& node : function.node()) {
+    // nodes must be in topologically sorted order
+    for (const auto& input : node.input()) {
+      // explicit optional input
+      if (input.empty()) {
+        continue;
+      }
+      if (!lex_ctx.this_graph_has(input)) {
+        fail_check(
+            "Nodes in a function must be topologically sorted, however input '",
+            input,
+            "' of node: \n",
+            "Name: ",
+            node.name(),
+            " OpType: ",
+            node.op_type(),
+            "\n is neither output of any previous nodes nor input of the function.");
+      }
+    }
+
+    // check whether the opset version imported for a domain by function and model are
+    // compatible
+    if (!ctx_copy.skip_opset_compatibility_check())
+      check_opset_compatibility(node, ctx_copy, func_opset_imports, model_opset_imports);
+    if (check_is_experimental_op(node)) {
+      used_experimental_ops.insert(node.op_type());
+    }
+    check_node(node, ctx_copy, lex_ctx);
+
+    // check for SSA form
+    for (const auto& output : node.output()) {
+      // optional output
+      if (output.empty()) {
+        continue;
+      }
+      if (lex_ctx.this_or_ancestor_graph_has(output)) {
+        fail_check(
+            "Function must be in single static assignment (SSA) form, however '",
+            output,
+            "' has been used as output names multiple times.");
+      }
+      lex_ctx.add(output);
+    }
+  }
+  print_warning_if_has_experimental(used_experimental_ops);
+}
+
+static void check_model(const ModelProto& model, CheckerContext& ctx) {
+  if (!model.ir_version()) {
+    fail_check("The model does not have an ir_version set properly.");
+  }
+  if (model.ir_version() > IR_VERSION) {
+    fail_check("Your model ir_version ", model.ir_version(), " is higher than the checker's (", IR_VERSION, ").");
+  }
+  if (model.metadata_props_size() > 1) {
+    std::unordered_set<std::string> keys;
+    for (const StringStringEntryProto& entry : model.metadata_props()) {
+      auto i = keys.insert(entry.key());
+      if (!i.second) {
+        fail_check("Your model has duplicate keys in metadata_props.");
+      }
+    }
+  }
+  ctx.set_ir_version(static_cast<int>(model.ir_version()));
+  std::unordered_map<std::string, int> opset_imports;
+  for (const auto& opset_import : model.opset_import()) {
+    opset_imports[opset_import.domain()] = static_cast<int>(opset_import.version());
+  }
+  if (model.ir_version() >= 3) {
+    if (opset_imports.empty()) {
+      fail_check("model with IR version >= 3 must specify opset_import for ONNX");
+    }
+  } else {
+    if (opset_imports.empty()) {
+      opset_imports[ONNX_DOMAIN] = 1;
+    } else {
+      fail_check("model with IR version < 3 cannot have opset_import specified");
+    }
+  }
+  ctx.set_opset_imports(opset_imports);
+  LexicalScopeContext lex_ctx;
+  check_graph(model.graph(), ctx, lex_ctx);
+
+  if (ctx.get_ir_version() >= 0x00000008) {
+    check_model_local_functions(model, ctx, lex_ctx);
+    // TODO(ONNX): check consistency between local functions and ops referencing it.
+  }
+}
+
+void check_model(
+    const std::string& model_path,
+    bool full_check,
+    bool skip_opset_compatibility_check,
+    bool check_custom_domain) {
+  ModelProto model;
+  LoadProtoFromPath(model_path, model);
+
+  CheckerContext ctx;
+  std::string model_dir;
+  size_t pos = model_path.find_last_of("\\/");
+  if (pos != std::string::npos) {
+    model_dir = model_path.substr(0, pos + 1);
+  }
+  ctx.set_model_dir(model_dir);
+  ctx.set_skip_opset_compatibility_check(skip_opset_compatibility_check);
+  ctx.set_check_custom_domain(check_custom_domain);
+  check_model(model, ctx);
+
+  if (full_check) {
+    ShapeInferenceOptions options{true, 1, false};
+    ONNX_NAMESPACE::shape_inference::InferShapes(model, ctx.get_schema_registry(), options);
+  }
+}
+
+void check_model(
+    const ModelProto& model,
+    bool full_check,
+    bool skip_opset_compatibility_check,
+    bool check_custom_domain) {
+  CheckerContext ctx;
+  ctx.set_skip_opset_compatibility_check(skip_opset_compatibility_check);
+  ctx.set_check_custom_domain(check_custom_domain);
+  check_model(model, ctx);
+  if (full_check) {
+    ShapeInferenceOptions options{true, 1, false};
+    // Do not update the model in place by the check from shape inference
+    // because checker should not modify the original model
+    ModelProto copy = model;
+    ONNX_NAMESPACE::shape_inference::InferShapes(copy, ctx.get_schema_registry(), options);
+  }
+}
+
+using ONNX_NAMESPACE::ScopedFd;
+using ONNX_NAMESPACE::utf8_to_path;
+#ifdef _WIN32
+using ONNX_NAMESPACE::ScopedHandle;
+#endif
+
+#ifdef _WIN32
+// Compare two BY_HANDLE_FILE_INFORMATION structs by volume + file index (inode equivalent).
+static bool same_file(const BY_HANDLE_FILE_INFORMATION& a, const BY_HANDLE_FILE_INFORMATION& b) {
+  return a.dwVolumeSerialNumber == b.dwVolumeSerialNumber && a.nFileIndexHigh == b.nFileIndexHigh &&
+      a.nFileIndexLow == b.nFileIndexLow;
+}
+#endif
+
+// Canonicalize data_path, verify containment within base_dir.
+static std::filesystem::path verify_path_containment(
+    const std::filesystem::path& data_path,
+    const std::string& base_dir,
+    const std::string& tensor_name) {
+  std::error_code ec;
+  auto canonical_data = std::filesystem::weakly_canonical(data_path, ec);
+  if (ec) {
+    fail_check("Tensor ", tensor_name, " external data path could not be canonicalized: ", ec.message());
+  }
+  auto canonical_base = std::filesystem::weakly_canonical(utf8_to_path(base_dir), ec);
+  if (ec) {
+    fail_check("Tensor ", tensor_name, " base directory could not be canonicalized: ", ec.message());
+  }
+  auto base_str = canonical_base.native();
+  if (!base_str.empty() && base_str.back() != std::filesystem::path::preferred_separator) {
+    base_str += std::filesystem::path::preferred_separator;
+  }
+  if (canonical_data.native().find(base_str) != 0 && canonical_data != canonical_base) { // NOSONAR
+    fail_check("Tensor ", tensor_name, " external data resolves outside model directory.");
+  }
+  return canonical_data;
+}
+
+std::filesystem::path resolve_external_data_location(
+    const std::string& base_dir,
+    const std::string& location,
+    const std::string& tensor_name) {
+  auto base_dir_path = utf8_to_path(base_dir);
+  auto file_path = utf8_to_path(location);
+  if (file_path.empty()) {
+    fail_check("Location of external TensorProto ( tensor name: ", tensor_name, ") should not be empty.");
+  }
+  if (file_path.is_absolute()) {
+    fail_check(
+        "Location of external TensorProto ( tensor name: ",
+        tensor_name,
+        ") should be a relative path, but it is an absolute path: ",
+        location);
+  }
+  auto relative_path = file_path.lexically_normal().make_preferred();
+  if (relative_path.native().find(std::filesystem::path("..").native()) != std::filesystem::path::string_type::npos) {
+    fail_check(
+        "Data of TensorProto ( tensor name: ",
+        tensor_name,
+        ") should be file inside '",
+        base_dir,
+        "', but '",
+        location,
+        "' points outside the directory.");
+  }
+  auto data_path = base_dir_path / relative_path;
+  auto data_path_str = path_to_utf8(data_path);
+  // Do not allow symlinks or directories.
+  if (data_path.empty() || std::filesystem::is_symlink(data_path)) {
+    fail_check(
+        "Data of TensorProto ( tensor name: ",
+        tensor_name,
+        ") should be stored in ",
+        data_path_str,
+        ", but it is a symbolic link.");
+  }
+  // Verify canonical containment (catches parent-dir symlinks).
+  if (data_path_str[0] != '#') {
+    verify_path_containment(data_path, base_dir, tensor_name);
+  }
+  if (data_path_str[0] != '#' && !std::filesystem::is_regular_file(data_path)) {
+    fail_check(
+        "Data of TensorProto ( tensor name: ",
+        tensor_name,
+        ") should be stored in ",
+        data_path_str,
+        ", but it is not regular file.");
+  }
+  // Do not allow hardlinks, as they can be used to read arbitrary files.
+  if (data_path_str[0] != '#' && std::filesystem::hard_link_count(data_path) > 1) {
+    fail_check(
+        "Data of TensorProto ( tensor name: ",
+        tensor_name,
+        ") should be stored in ",
+        data_path_str,
+        ", but it has multiple hard links, indicating a potential hardlink attack.");
+  }
+  return data_path;
+}
+
+static std::filesystem::path
+validate_write_location(const std::string& base_dir, const std::string& location, const std::string& tensor_name) {
+  auto file_path = utf8_to_path(location);
+  if (file_path.empty() || file_path.is_absolute()) {
+    fail_check("External data location for tensor ", tensor_name, " is empty or absolute: ", location);
+  }
+  auto rel = file_path.lexically_normal().make_preferred();
+  if (rel == std::filesystem::path(".")) {
+    fail_check("External data location for tensor ", tensor_name, " is invalid: ", location);
+  }
+  if (rel.native().find(std::filesystem::path("..").native()) !=
+      std::filesystem::path::string_type::npos) { // NOSONAR — C++17, no contains
+    fail_check("External data location for tensor ", tensor_name, " contains '..': ", location);
+  }
+  return utf8_to_path(base_dir) / rel;
+}
+
+#ifdef _WIN32
+
+int64_t open_external_data(
+    const std::string& base_dir,
+    const std::string& location,
+    const std::string& tensor_name,
+    bool read_only) {
+  std::filesystem::path data_path;
+  if (read_only) {
+    data_path = resolve_external_data_location(base_dir, location, tensor_name);
+  } else {
+    data_path = validate_write_location(base_dir, location, tensor_name);
+    // Pre-open parent-dir check (final-component-only flags don't protect parents).
+    verify_path_containment(data_path.parent_path(), base_dir, tensor_name);
+  }
+
+  // CreateFileW with FILE_FLAG_OPEN_REPARSE_POINT: opens reparse point itself
+  // (symlink/junction) without following, and returns CRT-independent HANDLE.
+  DWORD access = read_only ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE);
+  DWORD creation = read_only ? OPEN_EXISTING : OPEN_ALWAYS;
+  HANDLE h = CreateFileW(
+      data_path.native().c_str(),
+      access,
+      FILE_SHARE_READ,
+      nullptr,
+      creation,
+      FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OPEN_REPARSE_POINT,
+      nullptr);
+  if (h == INVALID_HANDLE_VALUE) {
+    fail_check("Cannot open external data for tensor ", tensor_name);
+  }
+  ScopedHandle guard(h);
+
+  // Reject symlinks/junctions.
+  BY_HANDLE_FILE_INFORMATION file_info;
+  if (!GetFileInformationByHandle(h, &file_info)) {
+    fail_check("Tensor ", tensor_name, " external data: cannot query file information.");
+  }
+  if (file_info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+    fail_check("Tensor ", tensor_name, " external data is a reparse point (symlink/junction).");
+  }
+
+  // Inode comparison: open canonical path, compare volume + file index.
+  auto canonical_data = verify_path_containment(data_path, base_dir, tensor_name);
+  HANDLE h2 = CreateFileW(
+      canonical_data.native().c_str(),
+      0,
+      FILE_SHARE_READ | FILE_SHARE_WRITE,
+      nullptr,
+      OPEN_EXISTING,
+      FILE_FLAG_OPEN_REPARSE_POINT,
+      nullptr);
+  if (h2 == INVALID_HANDLE_VALUE) {
+    fail_check("Tensor ", tensor_name, " external data: cannot open canonical path for verification.");
+  }
+  ScopedHandle guard2(h2);
+  BY_HANDLE_FILE_INFORMATION canon_info;
+  if (!GetFileInformationByHandle(h2, &canon_info)) {
+    fail_check("Tensor ", tensor_name, " external data: cannot query canonical path file information.");
+  }
+  if (!same_file(file_info, canon_info)) {
+    fail_check("Tensor ", tensor_name, " external data: fd/path mismatch (possible TOCTOU attack).");
+  }
+
+  // Hardlink check (fail closed).
+  if (file_info.nNumberOfLinks > 1) {
+    fail_check("Tensor ", tensor_name, " external data has multiple hard links (possible hardlink attack).");
+  }
+
+  // Convert HANDLE → CRT fd so callers get a uniform fd on all platforms.
+  HANDLE h_released = guard.release();
+  int flags = read_only ? (_O_RDONLY | _O_BINARY) : (_O_RDWR | _O_BINARY);
+  int fd = _open_osfhandle(reinterpret_cast<intptr_t>(h_released), flags);
+  if (fd < 0) {
+    CloseHandle(h_released);
+    fail_check("Cannot convert handle to fd for tensor ", tensor_name);
+  }
+  return static_cast<int64_t>(fd);
+}
+
+#else // POSIX
+
+// Try kernel-level contained open.
+// Returns fd >= 0 on success, -1 if feature unavailable (fall through to legacy).
+// Calls fail_check on kernel rejection (symlink, escape) — does NOT fall through.
+static int try_kernel_contained_open(
+    const std::string& base_dir,
+    const std::string& location,
+    [[maybe_unused]] const std::string& tensor_name,
+    [[maybe_unused]] bool read_only) {
+  int raw_dirfd = open(base_dir.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC);
+  if (raw_dirfd < 0) {
+    return -1;
+  }
+  ScopedFd dirfd_guard(raw_dirfd);
+  auto rel = std::filesystem::path(location).lexically_normal().string();
+  int fd = -1;
+
+#ifdef ONNX_HAS_OPENAT2
+  static thread_local bool openat2_supported = true;
+  if (openat2_supported) {
+    struct open_how how = {};
+    how.flags =
+        read_only ? static_cast<uint64_t>(O_RDONLY | O_CLOEXEC) : static_cast<uint64_t>(O_CREAT | O_RDWR | O_CLOEXEC);
+    how.mode = read_only ? 0 : 0600;
+    how.resolve = RESOLVE_BENEATH | RESOLVE_NO_SYMLINKS;
+    fd = static_cast<int>(syscall(SYS_openat2, raw_dirfd, rel.c_str(), &how, sizeof(how)));
+    if (fd < 0) {
+      if (errno == ENOSYS) {
+        openat2_supported = false; // kernel too old, fall through
+      } else {
+        fail_check("Cannot open external data for tensor ", tensor_name, " (kernel rejected path)");
+      }
+    }
+  }
+#elif defined(ONNX_HAS_RESOLVE_BENEATH)
+  int flags = O_RESOLVE_BENEATH | O_CLOEXEC;
+#ifdef O_NOFOLLOW
+  flags |= O_NOFOLLOW;
+#endif
+  if (read_only) {
+    fd = openat(raw_dirfd, rel.c_str(), flags | O_RDONLY);
+  } else {
+    fd = openat(raw_dirfd, rel.c_str(), flags | O_CREAT | O_RDWR, 0600);
+  }
+  if (fd < 0) {
+    fail_check("Cannot open external data for tensor ", tensor_name);
+  }
+#endif
+
+  return fd;
+}
+
+int64_t open_external_data(
+    const std::string& base_dir,
+    const std::string& location,
+    const std::string& tensor_name,
+    bool read_only) {
+  // Pre-open validation (defense-in-depth).
+  std::filesystem::path data_path;
+  if (read_only) {
+    data_path = resolve_external_data_location(base_dir, location, tensor_name);
+  } else {
+    data_path = validate_write_location(base_dir, location, tensor_name);
+    // Pre-open parent-dir check (final-component-only flags don't protect parents).
+    verify_path_containment(data_path.parent_path(), base_dir, tensor_name);
+  }
+
+  // Try kernel-level contained open (openat2 or O_RESOLVE_BENEATH).
+  int fd = try_kernel_contained_open(base_dir, location, tensor_name, read_only);
+  bool kernel_verified = (fd >= 0);
+
+  // Fallback: open() + O_NOFOLLOW + post-open inode verification.
+  if (fd < 0) {
+    int flags = read_only ? O_RDONLY : (O_CREAT | O_RDWR);
+#ifdef O_CLOEXEC
+    flags |= O_CLOEXEC;
+#endif
+#ifdef O_NOFOLLOW
+    flags |= O_NOFOLLOW;
+#endif
+    fd = read_only ? open(data_path.c_str(), flags) : open(data_path.c_str(), flags, 0600);
+    if (fd == -1) {
+      fail_check("Cannot open external data for tensor ", tensor_name);
+    }
+  }
+  ScopedFd guard(fd);
+
+  // Post-open checks (fail closed).
+  struct stat fd_stat{};
+  if (fstat(fd, &fd_stat) != 0) {
+    fail_check("Tensor ", tensor_name, " external data: fstat failed.");
+  }
+  if (!kernel_verified) {
+    // Verify containment via canonical path + inode comparison.
+    auto canonical_data = verify_path_containment(data_path, base_dir, tensor_name);
+    struct stat path_stat{};
+    if (stat(canonical_data.c_str(), &path_stat) != 0) {
+      fail_check("Tensor ", tensor_name, " external data: cannot stat canonical path.");
+    }
+    if (path_stat.st_dev != fd_stat.st_dev || path_stat.st_ino != fd_stat.st_ino) {
+      fail_check("Tensor ", tensor_name, " external data: fd/path mismatch (possible TOCTOU attack).");
+    }
+  }
+  if (fd_stat.st_nlink > 1) {
+    fail_check("Tensor ", tensor_name, " external data has multiple hard links (possible hardlink attack).");
+  }
+
+  return guard.release();
+}
+
+#endif
+
+static const std::unordered_set<std::string> experimental_ops = {
+    "ATen",
+    "Affine",
+    "ConstantFill",
+    "Crop",
+    "DynamicSlice",
+    "GRUUnit",
+    "GivenTensorFill",
+    "ImageScaler",
+    "ParametricSoftplus",
+    "Scale",
+    "ScaledTanh"};
+
+bool check_is_experimental_op(const NodeProto& node) {
+  return (node.domain() == ONNX_DOMAIN || node.domain() == "ai.onnx") && experimental_ops.count(node.op_type());
+}
+
+#undef enforce_has_field
+#undef enforce_non_empty_field
+
+} // namespace checker
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/checker.h b/onnx/checker.h
new file mode 100644
index 0000000..b6d29d7
--- /dev/null
+++ b/onnx/checker.h
@@ -0,0 +1,204 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <filesystem>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+#include "onnx/defs/schema.h"
+#include "onnx/onnx-data.pb.h"
+#include "onnx/string_utils.h"
+
+namespace ONNX_NAMESPACE {
+namespace checker {
+// std::string member means copy may throw when allocation fails
+// NOLINTNEXTLINE(bugprone-exception-copy-constructor-throws)
+class ValidationError final : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+  const char* what() const noexcept override {
+    if (!expanded_message_.empty()) {
+      return expanded_message_.c_str();
+    }
+    return std::runtime_error::what();
+  }
+  void AppendContext(const std::string& context) {
+    expanded_message_ = ONNX_NAMESPACE::MakeString(std::runtime_error::what(), "\n\n==> Context: ", context);
+  }
+
+ private:
+  std::string expanded_message_;
+};
+
+#define fail_check(...) ONNX_THROW_EX(ONNX_NAMESPACE::checker::ValidationError(ONNX_NAMESPACE::MakeString(__VA_ARGS__)))
+
+class CheckerContext final {
+ public:
+  int get_ir_version() const {
+    return ir_version_;
+  }
+  void set_ir_version(int v) {
+    ir_version_ = v;
+  }
+  const std::unordered_map<std::string, int>& get_opset_imports() const {
+    return opset_imports_;
+  }
+  void set_opset_imports(std::unordered_map<std::string, int> imps) {
+    opset_imports_ = std::move(imps);
+  }
+  bool is_main_graph() const {
+    return is_main_graph_;
+  }
+  void set_is_main_graph(bool is_main_graph) {
+    is_main_graph_ = is_main_graph;
+  }
+
+  void set_schema_registry(const ISchemaRegistry* schema_registry) {
+    schema_registry_ = schema_registry;
+  }
+
+  const ISchemaRegistry* get_schema_registry() const {
+    return schema_registry_;
+  }
+
+  void set_model_dir(const std::string& model_dir) {
+    model_dir_ = model_dir;
+  }
+
+  const std::string& get_model_dir() const {
+    return model_dir_;
+  }
+
+  bool skip_opset_compatibility_check() const {
+    return skip_opset_compatibility_check_;
+  }
+
+  void set_skip_opset_compatibility_check(bool value) {
+    skip_opset_compatibility_check_ = value;
+  }
+
+  bool check_custom_domain() const {
+    return check_custom_domain_;
+  }
+
+  void set_check_custom_domain(bool value) {
+    check_custom_domain_ = value;
+  }
+
+  explicit CheckerContext() = default;
+
+ private:
+  int ir_version_{-1};
+  std::unordered_map<std::string, int> opset_imports_;
+  bool is_main_graph_ = true;
+  const ISchemaRegistry* schema_registry_ = OpSchemaRegistry::Instance();
+  std::string model_dir_;
+  bool skip_opset_compatibility_check_ = false;
+  bool check_custom_domain_ = false;
+};
+
+class LexicalScopeContext final {
+ public:
+  LexicalScopeContext() = default;
+  ~LexicalScopeContext() = default;
+
+  // Construct an instance with the lexical scope from the parent graph to allow
+  // lookup of names from that scope via this_or_ancestor_graph_has.
+  // The caller must ensure parent_context remains valid for the entire lifetime
+  // of the new instance. Alternatively, if that cannot be guaranteed, create an
+  // instance with the default constructor and populate output_names with the
+  // values from the parent scope so the values are copied instead.
+  LexicalScopeContext(const LexicalScopeContext& parent_context) : parent_context_{&parent_context} {}
+  LexicalScopeContext& operator=(const LexicalScopeContext& parent_context) {
+    if (this == &parent_context) {
+      return *this;
+    }
+    parent_context_ = &parent_context;
+    return *this;
+  }
+  LexicalScopeContext(LexicalScopeContext&&) = delete;
+  LexicalScopeContext& operator=(LexicalScopeContext&&) = delete;
+
+  void add(const std::string& name) {
+    output_names.insert(name);
+  }
+
+  bool this_graph_has(const std::string& name) const {
+    return output_names.count(name) > 0;
+  }
+
+  bool this_or_ancestor_graph_has(const std::string& name) const {
+    return this_graph_has(name) || (parent_context_ && parent_context_->this_or_ancestor_graph_has(name));
+  }
+
+  // public for backwards compatibility. please prefer the public interface of
+  // this class over directly changing output_names
+  std::unordered_set<std::string> output_names;
+
+ private:
+  const LexicalScopeContext* parent_context_{nullptr};
+};
+
+using IR_VERSION_TYPE = decltype(Version::IR_VERSION);
+void check_value_info(const ValueInfoProto& value_info, const CheckerContext& /*ctx*/);
+void check_tensor(const TensorProto& tensor, const CheckerContext& /*ctx*/);
+void check_sparse_tensor(const SparseTensorProto& sparse_tensor, const CheckerContext& /*ctx*/);
+void check_sequence(const SequenceProto& sequence, const CheckerContext& /*ctx*/);
+void check_map(const MapProto& map, const CheckerContext& /*ctx*/);
+void check_optional(const OptionalProto& opt, const CheckerContext& /*ctx*/);
+void check_attribute(const AttributeProto& attr, const CheckerContext& /*ctx*/, const LexicalScopeContext& /*lex_ctx*/);
+void check_node(const NodeProto& node, const CheckerContext& /*ctx*/, const LexicalScopeContext& /*lex_ctx*/);
+void check_graph(const GraphProto& graph, const CheckerContext& /*ctx*/, const LexicalScopeContext& /*parent_lex*/);
+void check_function(
+    const FunctionProto& function,
+    const CheckerContext& /*ctx*/,
+    const LexicalScopeContext& /*parent_lex*/);
+
+// Check schema compatibility for 2 opset versions for a given node.
+// Checks whether the schema for 2 versions is same, this is true when the opschema
+// does not change between versions.
+ONNX_API void check_opset_compatibility(
+    const NodeProto& node,
+    const CheckerContext& ctx,
+    const std::unordered_map<std::string, int>& func_opset_imports,
+    const std::unordered_map<std::string, int>& model_opset_imports);
+
+// Checks all model local functions present in ModelProto
+ONNX_API void
+check_model_local_functions(const ModelProto& model, const CheckerContext& ctx, const LexicalScopeContext& parent_lex);
+
+// Checks for cycles in model-local function call graph.
+// Throws ValidationError if any function directly or indirectly references itself.
+ONNX_API void check_function_call_cycles(const ModelProto& model);
+
+ONNX_API void check_model(
+    const ModelProto& model,
+    bool full_check = false,
+    bool skip_opset_compatibility_check = false,
+    bool check_custom_domain = false);
+ONNX_API void check_model(
+    const std::string& model_path,
+    bool full_check = false,
+    bool skip_opset_compatibility_check = false,
+    bool check_custom_domain = false);
+std::filesystem::path resolve_external_data_location(
+    const std::string& base_dir,
+    const std::string& location,
+    const std::string& tensor_name);
+// Returns a CRT file descriptor on all platforms.
+// The caller owns the fd and must close it.
+int64_t open_external_data(
+    const std::string& base_dir,
+    const std::string& location,
+    const std::string& tensor_name,
+    bool read_only);
+ONNX_API bool check_is_experimental_op(const NodeProto& node);
+
+} // namespace checker
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/checker.py b/onnx/checker.py
new file mode 100644
index 0000000..5188dc5
--- /dev/null
+++ b/onnx/checker.py
@@ -0,0 +1,171 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Graph utilities for checking whether an ONNX proto message is legal."""
+
+from __future__ import annotations
+
+__all__ = [
+    "check_attribute",
+    "check_function",
+    "check_graph",
+    "check_model",
+    "check_node",
+    "check_sparse_tensor",
+    "check_tensor",
+    "check_value_info",
+    "DEFAULT_CONTEXT",
+    "LEXICAL_SCOPE_CONTEXT",
+    "ValidationError",
+    "C",
+    "MAXIMUM_PROTOBUF",
+]
+
+import os
+from typing import TYPE_CHECKING
+
+import onnx.defs
+import onnx.onnx_cpp2py_export.checker as C  # noqa: N812
+from onnx.onnx_pb import IR_VERSION
+
+if TYPE_CHECKING:
+    from google.protobuf.message import Message
+
+# Maximum single-protobuf size; matches the C++ parser limit in proto_utils.h (2 GiB - 1 byte)
+MAXIMUM_PROTOBUF = 2147483647
+
+
+# NB: Please don't edit this context!
+DEFAULT_CONTEXT = C.CheckerContext()
+DEFAULT_CONTEXT.ir_version = IR_VERSION
+# TODO: Maybe ONNX-ML should also be defaulted?
+DEFAULT_CONTEXT.opset_imports = {"": onnx.defs.onnx_opset_version()}
+
+LEXICAL_SCOPE_CONTEXT = C.LexicalScopeContext()
+
+
+def _ensure_proto_type(proto: Message, proto_type: type[Message]) -> None:
+    if not isinstance(proto, proto_type):
+        raise TypeError(
+            f"The proto message needs to be of type '{proto_type.__name__}'"
+        )
+
+
+def check_value_info(
+    value_info: onnx.ValueInfoProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+) -> None:
+    _ensure_proto_type(value_info, onnx.ValueInfoProto)
+    return C.check_value_info(value_info.SerializeToString(), ctx)
+
+
+def check_tensor(
+    tensor: onnx.TensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+) -> None:
+    _ensure_proto_type(tensor, onnx.TensorProto)
+    return C.check_tensor(tensor.SerializeToString(), ctx)
+
+
+def check_attribute(
+    attr: onnx.AttributeProto,
+    ctx: C.CheckerContext = DEFAULT_CONTEXT,
+    lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
+) -> None:
+    _ensure_proto_type(attr, onnx.AttributeProto)
+    return C.check_attribute(attr.SerializeToString(), ctx, lexical_scope_ctx)
+
+
+def check_node(
+    node: onnx.NodeProto,
+    ctx: C.CheckerContext = DEFAULT_CONTEXT,
+    lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
+) -> None:
+    _ensure_proto_type(node, onnx.NodeProto)
+    return C.check_node(node.SerializeToString(), ctx, lexical_scope_ctx)
+
+
+def check_function(
+    function: onnx.FunctionProto,
+    ctx: C.CheckerContext | None = None,
+    lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
+) -> None:
+    _ensure_proto_type(function, onnx.FunctionProto)
+    if ctx is None:
+        ctx = C.CheckerContext()
+        ctx.ir_version = onnx.helper.find_min_ir_version_for(
+            function.opset_import, ignore_unknown=True
+        )
+        ctx.opset_imports = {
+            domain_version.domain: domain_version.version
+            for domain_version in function.opset_import
+        }
+    C.check_function(function.SerializeToString(), ctx, lexical_scope_ctx)
+
+
+def check_graph(
+    graph: onnx.GraphProto,
+    ctx: C.CheckerContext = DEFAULT_CONTEXT,
+    lexical_scope_ctx: C.LexicalScopeContext = LEXICAL_SCOPE_CONTEXT,
+) -> None:
+    _ensure_proto_type(graph, onnx.GraphProto)
+    return C.check_graph(graph.SerializeToString(), ctx, lexical_scope_ctx)
+
+
+def check_sparse_tensor(
+    sparse: onnx.SparseTensorProto, ctx: C.CheckerContext = DEFAULT_CONTEXT
+) -> None:
+    _ensure_proto_type(sparse, onnx.SparseTensorProto)
+    C.check_sparse_tensor(sparse.SerializeToString(), ctx)
+
+
+def check_model(
+    model: onnx.ModelProto | str | bytes | os.PathLike,
+    full_check: bool = False,
+    skip_opset_compatibility_check: bool = False,
+    check_custom_domain: bool = False,
+) -> None:
+    """Check the consistency of a model.
+
+    An exception will be raised if the model's ir_version is not set
+    properly or is higher than checker's ir_version, or if the model
+    has duplicate keys in metadata_props.
+
+    If IR version >= 3, the model must specify opset_import.
+    If IR version < 3, the model cannot have any opset_import specified.
+
+    Args:
+        model: Model to check. If model is a path, the function checks model
+            path first. If the model bytes size is larger than 2GB, function
+            should be called using model path.
+        full_check: If True, the function also runs shape inference check.
+        skip_opset_compatibility_check: If True, the function skips the check for
+            opset compatibility.
+        check_custom_domain: If True, the function will check all domains. Otherwise
+            only check built-in domains.
+    """
+    # If model is a path instead of ModelProto
+    if isinstance(model, (str, os.PathLike)):
+        C.check_model_path(
+            os.fspath(model),
+            full_check,
+            skip_opset_compatibility_check,
+            check_custom_domain,
+        )
+    else:
+        protobuf_string = (
+            model if isinstance(model, bytes) else model.SerializeToString()
+        )
+        # If the protobuf is larger than 2GiB,
+        # remind users should use the model path to check
+        if len(protobuf_string) > MAXIMUM_PROTOBUF:
+            raise ValueError(
+                "This protobuf of onnx model is too large (>2GiB). Call check_model with model path instead."
+            )
+        C.check_model(
+            protobuf_string,
+            full_check,
+            skip_opset_compatibility_check,
+            check_custom_domain,
+        )
+
+
+ValidationError = C.ValidationError
diff --git a/onnx/common/CMakeLists.txt b/onnx/common/CMakeLists.txt
new file mode 100644
index 0000000..d14e08e
--- /dev/null
+++ b/onnx/common/CMakeLists.txt
@@ -0,0 +1,34 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+configure_file(
+    version.h.in
+    ${CMAKE_CURRENT_BINARY_DIR}/version.h
+    @ONLY
+)
+
+target_sources(onnx PRIVATE
+    array_ref.h
+    assertions.cc
+    assertions.h
+    common.h
+    constants.h
+    file_utils.h
+    graph_node_list.h
+    interned_strings.cc
+    interned_strings.h
+    ir_pb_converter.cc
+    ir_pb_converter.h
+    ir.h
+    model_helpers.cc
+    model_helpers.h
+    path.h
+    platform_helpers.h
+    proto_util.h
+    scoped_resource.h
+    status.cc
+    status.h
+    tensor.h
+    visitor.h
+    ${CMAKE_CURRENT_BINARY_DIR}/version.h
+)
diff --git a/onnx/common/array_ref.h b/onnx/common/array_ref.h
new file mode 100644
index 0000000..c9604c5
--- /dev/null
+++ b/onnx/common/array_ref.h
@@ -0,0 +1,201 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+//===--- 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.
+//
+//===----------------------------------------------------------------------===//
+
+// ONNX: modified from llvm::ArrayRef.
+// 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...
+
+#pragma once
+#include <array>
+#include <cassert>
+#include <vector>
+
+namespace ONNX_NAMESPACE {
+/// ArrayRef - Represent 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.
+///
+/// This is intended to be trivially copyable, so it should be passed by
+/// value.
+template <typename T>
+class ArrayRef {
+ public:
+  using iterator = const T*;
+  using const_iterator = const T*;
+  using size_type = size_t;
+
+  using reverse_iterator = std::reverse_iterator<iterator>;
+
+ 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*/ ArrayRef() : Data(nullptr), Length(0) {}
+
+  /// Construct an ArrayRef from a single element.
+  // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit)
+  /*implicit*/ ArrayRef(const T& OneElt) : Data(&OneElt), Length(1) {}
+
+  /// Construct an ArrayRef from a pointer and length.
+  /*implicit*/ ArrayRef(const T* data, size_t length) : Data(data), Length(length) {}
+
+  /// Construct an ArrayRef from a range.
+  ArrayRef(const T* begin, const T* end) : Data(begin), Length(end - begin) {}
+
+  /// Construct an ArrayRef from a std::vector.
+  template <typename A>
+  // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit)
+  /*implicit*/ ArrayRef(const std::vector<T, A>& Vec) : Data(Vec.data()), Length(Vec.size()) {}
+
+  /// Construct an ArrayRef from a std::array
+  template <size_t N>
+  // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit)
+  /*implicit*/ constexpr ArrayRef(const std::array<T, N>& Arr) : Data(Arr.data()), Length(N) {}
+
+  /// Construct an ArrayRef from a C array.
+  template <size_t N>
+  // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit)
+  /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
+
+  /// Construct an ArrayRef from a std::initializer_list.
+  /*implicit*/ ArrayRef(const std::initializer_list<T>& Vec)
+      : Data(Vec.begin() == Vec.end() ? static_cast<T*>(nullptr) : Vec.begin()), Length(Vec.size()) {}
+
+  /// @}
+  /// @name Simple Operations
+  /// @{
+
+  iterator begin() const {
+    return Data;
+  }
+  iterator end() const {
+    return Data + Length;
+  }
+
+  reverse_iterator rbegin() const {
+    return reverse_iterator(end());
+  }
+  reverse_iterator rend() const {
+    return reverse_iterator(begin());
+  }
+
+  /// empty - Check if the array is empty.
+  bool empty() const {
+    return Length == 0;
+  }
+
+  const T* data() const {
+    return Data;
+  }
+
+  /// size - Get the array size.
+  size_t size() const {
+    return Length;
+  }
+
+  /// front - Get the first element.
+  const T& front() const {
+    assert(!empty());
+    return Data[0];
+  }
+
+  /// back - Get the last element.
+  const T& back() const {
+    assert(!empty());
+    return Data[Length - 1];
+  }
+
+  /// equals - Check for element-wise equality.
+  bool equals(ArrayRef RHS) const {
+    if (Length != RHS.Length)
+      return false;
+    return std::equal(begin(), end(), RHS.begin());
+  }
+
+  /// slice(n, m) - Chop off the first N elements of the array, and keep M
+  /// elements in the array.
+  ArrayRef<T> slice(size_t N, size_t M) const {
+    assert(N + M <= size() && "Invalid specifier");
+    return ArrayRef<T>(data() + N, M);
+  }
+
+  /// slice(n) - Chop off the first N elements of the array.
+  ArrayRef<T> slice(size_t N) const {
+    return slice(N, size() - N);
+  }
+
+  /// @}
+  /// @name Operator Overloads
+  /// @{
+  const T& operator[](size_t Index) const {
+    assert(Index < Length && "Invalid index!");
+    return Data[Index];
+  }
+
+  /// Vector compatibility
+  const T& at(size_t Index) const {
+    assert(Index < Length && "Invalid index!");
+    return Data[Index];
+  }
+
+  /// Disallow accidental assignment from a temporary.
+  ///
+  /// The declaration here is extra complicated so that "arrayRef = {}"
+  /// continues to select the move assignment operator.
+  template <typename U>
+  std::enable_if_t<std::is_same_v<U, T>, ArrayRef<T>>& operator=(U&& Temporary) = delete;
+
+  /// Disallow accidental assignment from a temporary.
+  ///
+  /// The declaration here is extra complicated so that "arrayRef = {}"
+  /// continues to select the move assignment operator.
+  template <typename U>
+  std::enable_if_t<std::is_same_v<U, T>, ArrayRef<T>>& operator=(std::initializer_list<U>) = delete;
+
+  /// @}
+  /// @name Expensive Operations
+  /// @{
+  std::vector<T> vec() const {
+    return std::vector<T>(Data, Data + Length);
+  }
+
+  /// @}
+  /// @name Conversion operators
+  /// @{
+  /// NOLINTNEXTLINE(google-explicit-constructor)
+  operator std::vector<T>() const {
+    return std::vector<T>(Data, Data + Length);
+  }
+
+  /// @}
+};
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/assertions.cc b/onnx/common/assertions.cc
new file mode 100644
index 0000000..6695901
--- /dev/null
+++ b/onnx/common/assertions.cc
@@ -0,0 +1,24 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+#include "onnx/common/assertions.h"
+
+#include <string>
+
+#include "onnx/common/common.h"
+
+namespace ONNX_NAMESPACE {
+
+void throw_assert_error(const std::string& msg) {
+  ONNX_THROW_EX(assert_error(msg));
+}
+
+void throw_tensor_error(const std::string& msg) {
+  ONNX_THROW_EX(tensor_error(msg));
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/assertions.h b/onnx/common/assertions.h
new file mode 100644
index 0000000..b713473
--- /dev/null
+++ b/onnx/common/assertions.h
@@ -0,0 +1,62 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+#include "onnx/string_utils.h"
+
+namespace ONNX_NAMESPACE {
+
+struct assert_error : public std::runtime_error {
+ public:
+  explicit assert_error(const std::string& msg) : runtime_error(msg) {}
+};
+
+struct tensor_error : public assert_error {
+ public:
+  explicit tensor_error(const std::string& msg) : assert_error(msg) {}
+};
+
+[[noreturn]] void throw_assert_error(const std::string& /*msg*/);
+
+[[noreturn]] void throw_tensor_error(const std::string& /*msg*/);
+
+} // namespace ONNX_NAMESPACE
+
+#if defined(__GNUC__) || defined(__ICL) || defined(__clang__)
+#define _ONNX_EXPECT(x, y) (__builtin_expect((x), (y)))
+#else
+#define _ONNX_EXPECT(x, y) (x)
+#endif
+
+// The message arguments are concatenated with std::stringstream (via MakeString),
+// so std::string, std::string_view, and numbers are all supported directly without
+// format specifiers or .c_str().
+#define ONNX_ASSERT(cond)                                                                                           \
+  if (_ONNX_EXPECT(!(cond), 0)) { /* NOLINT(readability-simplify-boolean-expr) */                                   \
+    std::string error_msg =                                                                                         \
+        ::ONNX_NAMESPACE::MakeString(__FILE__, ":", __LINE__, ": ", __func__, ": Assertion `", #cond, "` failed."); \
+    throw_assert_error(error_msg);                                                                                  \
+  }
+
+#define ONNX_ASSERTM(cond, ...)                                                                      \
+  /* NOLINTNEXTLINE */                                                                               \
+  if (_ONNX_EXPECT(!(cond), 0)) {                                                                    \
+    std::string error_msg = ::ONNX_NAMESPACE::MakeString(                                            \
+        __FILE__, ":", __LINE__, ": ", __func__, ": Assertion `", #cond, "` failed: ", __VA_ARGS__); \
+    throw_assert_error(error_msg);                                                                   \
+  }
+
+#define TENSOR_ASSERTM(cond, ...)                                                                    \
+  if (_ONNX_EXPECT(!(cond), 0)) {                                                                    \
+    std::string error_msg = ::ONNX_NAMESPACE::MakeString(                                            \
+        __FILE__, ":", __LINE__, ": ", __func__, ": Assertion `", #cond, "` failed: ", __VA_ARGS__); \
+    throw_tensor_error(error_msg);                                                                   \
+  }
diff --git a/onnx/common/common.h b/onnx/common/common.h
new file mode 100644
index 0000000..7141986
--- /dev/null
+++ b/onnx/common/common.h
@@ -0,0 +1,54 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#define ONNX_UNUSED_PARAMETER(x) (void)(x)
+
+#ifdef ONNX_NO_EXCEPTIONS
+#include <iostream>
+#define ONNX_THROW(...)                                   \
+  do {                                                    \
+    std::cerr << ONNX_NAMESPACE::MakeString(__VA_ARGS__); \
+    abort();                                              \
+  } while (false)
+
+#define ONNX_THROW_EX(ex)                             \
+  do {                                                \
+    std::cerr << ex.what() << std::endl; /* NOLINT */ \
+    abort();                                          \
+  } while (false)
+
+#define ONNX_TRY if (true)
+#define ONNX_CATCH(x) else if (false)
+#define ONNX_HANDLE_EXCEPTION(func)
+
+#else
+#define ONNX_THROW(...) throw std::runtime_error(ONNX_NAMESPACE::MakeString(__VA_ARGS__))
+#define ONNX_THROW_EX(ex) throw ex
+
+#define ONNX_TRY try
+#define ONNX_CATCH(x) catch (x)
+#define ONNX_HANDLE_EXCEPTION(func) func()
+#endif
+
+// Macros to disable the copy and/or assignment methods
+// These are usually placed in the private: declarations for a class.
+
+#define ONNX_DISALLOW_COPY(TypeName) TypeName(const TypeName&) = delete
+
+#define ONNX_DISALLOW_ASSIGNMENT(TypeName) TypeName& operator=(const TypeName&) = delete
+
+#define ONNX_DISALLOW_COPY_AND_ASSIGNMENT(TypeName) \
+  ONNX_DISALLOW_COPY(TypeName);                     \
+  ONNX_DISALLOW_ASSIGNMENT(TypeName)
+
+// NOLINTBEGIN(bugprone-macro-parentheses)
+#define ONNX_DISALLOW_MOVE(TypeName) \
+  TypeName(TypeName&&) = delete;     \
+  TypeName& operator=(TypeName&&) = delete
+// NOLINTEND(bugprone-macro-parentheses)
+
+#define ONNX_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(TypeName) \
+  ONNX_DISALLOW_COPY_AND_ASSIGNMENT(TypeName);           \
+  ONNX_DISALLOW_MOVE(TypeName)
diff --git a/onnx/common/constants.h b/onnx/common/constants.h
new file mode 100644
index 0000000..272b5c2
--- /dev/null
+++ b/onnx/common/constants.h
@@ -0,0 +1,46 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+namespace ONNX_NAMESPACE {
+// For ONNX op/function registration.
+
+// ONNX domains.
+constexpr const char* AI_ONNX_ML_DOMAIN = "ai.onnx.ml";
+constexpr const char* AI_ONNX_TRAINING_DOMAIN = "ai.onnx.training";
+constexpr const char* AI_ONNX_PREVIEW_DOMAIN = "ai.onnx.preview";
+constexpr const char* AI_ONNX_PREVIEW_TRAINING_DOMAIN = "ai.onnx.preview.training";
+// The following two are equivalent in an onnx proto representation.
+constexpr const char* ONNX_DOMAIN = "";
+constexpr const char* AI_ONNX_DOMAIN = "ai.onnx";
+
+inline std::string NormalizeDomain(const std::string& domain) {
+  return (domain == AI_ONNX_DOMAIN) ? ONNX_DOMAIN : domain;
+}
+
+inline bool IsOnnxDomain(const std::string& domain) {
+  return (domain == AI_ONNX_DOMAIN) || (domain == ONNX_DOMAIN);
+}
+
+constexpr bool OPTIONAL_VALUE = false;
+
+// For dimension denotation.
+constexpr const char* DATA_BATCH = "DATA_BATCH";
+constexpr const char* DATA_CHANNEL = "DATA_CHANNEL";
+constexpr const char* DATA_TIME = "DATA_TIME";
+constexpr const char* DATA_FEATURE = "DATA_FEATURE";
+constexpr const char* FILTER_IN_CHANNEL = "FILTER_IN_CHANNEL";
+constexpr const char* FILTER_OUT_CHANNEL = "FILTER_OUT_CHANNEL";
+constexpr const char* FILTER_SPATIAL = "FILTER_SPATIAL";
+
+// For type denotation.
+constexpr const char* TENSOR = "TENSOR";
+constexpr const char* IMAGE = "IMAGE";
+constexpr const char* AUDIO = "AUDIO";
+constexpr const char* TEXT = "TEXT";
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/file_utils.h b/onnx/common/file_utils.h
new file mode 100644
index 0000000..50d5454
--- /dev/null
+++ b/onnx/common/file_utils.h
@@ -0,0 +1,38 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <filesystem> // NOLINT(build/c++17)
+#include <fstream>
+#include <string>
+
+#ifdef _WIN32
+#include "onnx/common/path.h"
+#endif
+#include "onnx/checker.h"
+
+namespace ONNX_NAMESPACE {
+
+template <typename T>
+void LoadProtoFromPath(const std::string& proto_path, T& proto) {
+#ifdef _WIN32
+  std::filesystem::path proto_u8_path(utf8str_to_wstring(proto_path));
+#else
+  std::filesystem::path proto_u8_path(proto_path);
+#endif
+  std::fstream proto_stream(proto_u8_path, std::ios::in | std::ios::binary);
+  if (!proto_stream.good()) {
+    fail_check("Unable to open proto file: ", proto_path, ". Please check if it is a valid proto. ");
+  }
+  std::string data{std::istreambuf_iterator<char>{proto_stream}, std::istreambuf_iterator<char>{}};
+  if (!proto_stream.good()) {
+    fail_check("Unable to read proto file: ", proto_path, ". Please check if it is a valid proto. ");
+  }
+  if (!ParseProtoFromBytes(&proto, data.c_str(), data.size())) {
+    fail_check(
+        "Unable to parse proto from file: ", proto_path, ". Please check if it is a valid protobuf file of proto. ");
+  }
+}
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/graph_node_list.h b/onnx/common/graph_node_list.h
new file mode 100644
index 0000000..66ab3dc
--- /dev/null
+++ b/onnx/common/graph_node_list.h
@@ -0,0 +1,165 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ONNX_COMMON_GRAPH_NODE_LIST_H_
+#define ONNX_COMMON_GRAPH_NODE_LIST_H_
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+#include <cstdint>
+#include <iterator>
+
+#include "onnx/common/assertions.h"
+
+namespace ONNX_NAMESPACE {
+
+// Intrusive doubly linked lists with sane reverse iterators.
+// The header file is named graph_node_list.h because it is ONLY
+// used for Graph's Node lists, and if you want to use it for other
+// things, you will have to do some refactoring.
+//
+// At the moment, the templated type T must support a few operations:
+//
+//  - It must have a field: T* next_in_graph[2] = { nullptr, nullptr };
+//    which are used for the intrusive linked list pointers.
+//
+//  - It must have a method 'destroy()', which removes T from the
+//    list and frees a T.
+//
+// In practice, we are only using it with Node and const Node.  'destroy()'
+// needs to be renegotiated if you want to use this somewhere else.
+//
+// Besides the benefits of being intrusive, unlike std::list, these lists handle
+// forward and backward iteration uniformly because we require a
+// "before-first-element" sentinel.  This means that reverse iterators
+// physically point to the element they logically point to, rather than
+// the off-by-one behavior for all standard library reverse iterators.
+
+static constexpr size_t kNextDirection = 0;
+static constexpr size_t kPrevDirection = 1;
+
+template <typename T>
+struct generic_graph_node_list;
+
+template <typename T>
+struct generic_graph_node_list_iterator;
+
+struct Node;
+using graph_node_list = generic_graph_node_list<Node>;
+using const_graph_node_list = generic_graph_node_list<const Node>;
+using graph_node_list_iterator = generic_graph_node_list_iterator<Node>;
+using const_graph_node_list_iterator = generic_graph_node_list_iterator<const Node>;
+
+template <typename T>
+struct generic_graph_node_list_iterator final {
+  using iterator_category = std::bidirectional_iterator_tag;
+  using value_type = T*;
+  using difference_type = int64_t;
+  using pointer = T**;
+  using reference = T*&;
+  generic_graph_node_list_iterator() : cur(nullptr), d(kNextDirection) {}
+  generic_graph_node_list_iterator(T* cur, size_t d) : cur(cur), d(d) {}
+  T* operator*() const {
+    return cur;
+  }
+  T* operator->() const {
+    return cur;
+  }
+  generic_graph_node_list_iterator& operator++() {
+    ONNX_ASSERT(cur)
+    cur = cur->next_in_graph[d];
+    return *this;
+  }
+  generic_graph_node_list_iterator operator++(int) {
+    generic_graph_node_list_iterator old = *this;
+    ++(*this);
+    return old;
+  }
+  generic_graph_node_list_iterator& operator--() {
+    ONNX_ASSERT(cur)
+    cur = cur->next_in_graph[reverseDir()];
+    return *this;
+  }
+  generic_graph_node_list_iterator operator--(int) {
+    generic_graph_node_list_iterator old = *this;
+    --(*this);
+    return old;
+  }
+
+  // erase cur without invalidating this iterator
+  // named differently from destroy so that ->/. bugs do not
+  // silently cause the wrong one to be called.
+  // iterator will point to the previous entry after call
+  void destroyCurrent() {
+    T* n = cur;
+    cur = cur->next_in_graph[reverseDir()];
+    n->destroy();
+  }
+  generic_graph_node_list_iterator reverse() {
+    return generic_graph_node_list_iterator(cur, reverseDir());
+  }
+
+ private:
+  size_t reverseDir() {
+    return d == kNextDirection ? kPrevDirection : kNextDirection;
+  }
+  T* cur;
+  size_t d; // direction 0 is forward 1 is reverse, see next_in_graph
+};
+
+template <typename T>
+struct generic_graph_node_list final {
+  using iterator = generic_graph_node_list_iterator<T>;
+  using const_iterator = generic_graph_node_list_iterator<const T>;
+  generic_graph_node_list_iterator<T> begin() {
+    return generic_graph_node_list_iterator<T>(head->next_in_graph[d], d);
+  }
+  generic_graph_node_list_iterator<const T> begin() const {
+    return generic_graph_node_list_iterator<const T>(head->next_in_graph[d], d);
+  }
+  generic_graph_node_list_iterator<T> end() {
+    return generic_graph_node_list_iterator<T>(head, d);
+  }
+  generic_graph_node_list_iterator<const T> end() const {
+    return generic_graph_node_list_iterator<const T>(head, d);
+  }
+  generic_graph_node_list_iterator<T> rbegin() {
+    return reverse().begin();
+  }
+  generic_graph_node_list_iterator<const T> rbegin() const {
+    return reverse().begin();
+  }
+  generic_graph_node_list_iterator<T> rend() {
+    return reverse().end();
+  }
+  generic_graph_node_list_iterator<const T> rend() const {
+    return reverse().end();
+  }
+  generic_graph_node_list reverse() {
+    return generic_graph_node_list(head, d == kNextDirection ? kPrevDirection : kNextDirection);
+  }
+  generic_graph_node_list reverse() const {
+    return generic_graph_node_list(head, d == kNextDirection ? kPrevDirection : kNextDirection);
+  }
+  generic_graph_node_list(T* head, size_t d) : head(head), d(d) {}
+
+ private:
+  T* head;
+  size_t d;
+};
+
+template <typename T>
+static inline bool operator==(generic_graph_node_list_iterator<T> a, generic_graph_node_list_iterator<T> b) {
+  return *a == *b;
+}
+
+template <typename T>
+static inline bool operator!=(generic_graph_node_list_iterator<T> a, generic_graph_node_list_iterator<T> b) {
+  return *a != *b;
+}
+
+} // namespace ONNX_NAMESPACE
+
+#endif // ONNX_COMMON_GRAPH_NODE_LIST_H_
diff --git a/onnx/common/interned_strings.cc b/onnx/common/interned_strings.cc
new file mode 100644
index 0000000..c2e6721
--- /dev/null
+++ b/onnx/common/interned_strings.cc
@@ -0,0 +1,80 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+#include "onnx/common/interned_strings.h"
+
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include "onnx/common/assertions.h"
+
+namespace ONNX_NAMESPACE {
+namespace {
+
+struct InternedStrings {
+  InternedStrings() {
+#define REGISTER_SYMBOL(s)   \
+  string_to_sym_[#s] = k##s; \
+  sym_to_string_[k##s] = #s;
+    FORALL_BUILTIN_SYMBOLS(REGISTER_SYMBOL)
+#undef REGISTER_SYMBOL
+  }
+  uint32_t symbol(const std::string& s) {
+    std::lock_guard<std::mutex> guard(mutex_);
+    auto it = string_to_sym_.find(s);
+    if (it != string_to_sym_.end())
+      return it->second;
+    uint32_t k = next_sym++;
+    string_to_sym_[s] = k;
+    sym_to_string_[k] = s;
+    return k;
+  }
+  const char* string(Symbol sym) {
+    // Builtin Symbols are also in the maps, but
+    // we can bypass the need to acquire a lock
+    // to read the map for Builtins because we already
+    // know their string value
+    switch (sym) {
+#define DEFINE_CASE(s) \
+  case k##s:           \
+    return #s;
+      FORALL_BUILTIN_SYMBOLS(DEFINE_CASE)
+#undef DEFINE_CASE
+      default:
+        return customString(sym);
+    }
+  }
+
+ private:
+  const char* customString(Symbol sym) {
+    std::lock_guard<std::mutex> guard(mutex_);
+    auto it = sym_to_string_.find(sym);
+    ONNX_ASSERT(it != sym_to_string_.end())
+    return it->second.c_str();
+  }
+  std::unordered_map<std::string, uint32_t> string_to_sym_;
+  std::unordered_map<uint32_t, std::string> sym_to_string_;
+  uint32_t next_sym{kLastSymbol};
+  std::mutex mutex_;
+};
+
+InternedStrings& globalStrings() {
+  static InternedStrings s;
+  return s;
+}
+
+} // namespace
+
+const char* Symbol::toString() const {
+  return globalStrings().string(*this);
+}
+
+Symbol::Symbol(const std::string& s) : value(globalStrings().symbol(s)) {}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/interned_strings.h b/onnx/common/interned_strings.h
new file mode 100644
index 0000000..67e1031
--- /dev/null
+++ b/onnx/common/interned_strings.h
@@ -0,0 +1,247 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+#pragma once
+#include <cstdint>
+#include <string>
+
+namespace ONNX_NAMESPACE {
+
+#define FORALL_BUILTIN_SYMBOLS(_)   \
+  _(spatial)                        \
+  _(select_last_index)              \
+  _(coordinate_transformation_mode) \
+  _(PythonOp)                       \
+  _(CppOp)                          \
+  _(Param)                          \
+  _(Select)                         \
+  _(Return)                         \
+  _(Eval)                           \
+  _(add)                            \
+  _(Add)                            \
+  _(Div)                            \
+  _(Mul)                            \
+  _(Neg)                            \
+  _(Sub)                            \
+  _(Pow)                            \
+  _(Sigmoid)                        \
+  _(ArgMax)                         \
+  _(Concat)                         \
+  _(Softmax)                        \
+  _(LogSoftmax)                     \
+  _(Dropout)                        \
+  _(Tanh)                           \
+  _(mul)                            \
+  _(neg)                            \
+  _(sigmoid)                        \
+  _(tanh)                           \
+  _(Constant)                       \
+  _(cat)                            \
+  _(Slice)                          \
+  _(Squeeze)                        \
+  _(Undefined)                      \
+  _(FusionGroup)                    \
+  _(MatMul)                         \
+  _(Gemm)                           \
+  _(Tile)                           \
+  _(SubConstant)                    \
+  _(Scale)                          \
+  _(Transpose)                      \
+  _(Pad)                            \
+  _(Reshape)                        \
+  _(split)                          \
+  _(chunk)                          \
+  _(Offset)                         \
+  _(value)                          \
+  _(Subgraph)                       \
+  _(BatchNormalization)             \
+  _(Conv)                           \
+  _(ConvTranspose)                  \
+  _(is_test)                        \
+  _(epsilon)                        \
+  _(expand)                         \
+  _(Expand)                         \
+  _(order)                          \
+  _(momentum)                       \
+  _(consumed_inputs)                \
+  _(kernels)                        \
+  _(kernel_shape)                   \
+  _(kernel)                         \
+  _(scale)                          \
+  _(strides)                        \
+  _(stride)                         \
+  _(pads)                           \
+  _(pad)                            \
+  _(beta)                           \
+  _(alpha)                          \
+  _(dilations)                      \
+  _(dilation)                       \
+  _(broadcast)                      \
+  _(axis)                           \
+  _(ratio)                          \
+  _(size)                           \
+  _(dim)                            \
+  _(keepdims)                       \
+  _(perm)                           \
+  _(shape)                          \
+  _(axes)                           \
+  _(group)                          \
+  _(inplace)                        \
+  _(transA)                         \
+  _(transB)                         \
+  _(other)                          \
+  _(__and__)                        \
+  _(__lshift__)                     \
+  _(__or__)                         \
+  _(__rshift__)                     \
+  _(__xor__)                        \
+  _(abs)                            \
+  _(acos)                           \
+  _(asin)                           \
+  _(atan)                           \
+  _(atan2)                          \
+  _(ceil)                           \
+  _(clamp)                          \
+  _(cos)                            \
+  _(cosh)                           \
+  _(div)                            \
+  _(eq)                             \
+  _(equal)                          \
+  _(Exp)                            \
+  _(ends)                           \
+  _(expm1)                          \
+  _(floor)                          \
+  _(fmod)                           \
+  _(frac)                           \
+  _(ge)                             \
+  _(gt)                             \
+  _(le)                             \
+  _(lerp)                           \
+  _(lgamma)                         \
+  _(Log)                            \
+  _(log1p)                          \
+  _(lt)                             \
+  _(max)                            \
+  _(min)                            \
+  _(ne)                             \
+  _(ones)                           \
+  _(pow)                            \
+  _(reciprocal)                     \
+  _(remainder)                      \
+  _(round)                          \
+  _(rsqrt)                          \
+  _(sin)                            \
+  _(sinh)                           \
+  _(Sqrt)                           \
+  _(sub)                            \
+  _(starts)                         \
+  _(tan)                            \
+  _(trunc)                          \
+  _(zeros)                          \
+  _(exponent)                       \
+  _(device)                         \
+  _(mode)                           \
+  _(Identity)                       \
+  _(Loop)                           \
+  _(If)                             \
+  _(body)                           \
+  _(then_branch)                    \
+  _(else_branch)                    \
+  _(Captured)                       \
+  _(__control_inputs)               \
+  _(count_include_pad)              \
+  _(storage_order)                  \
+  _(Unsqueeze)                      \
+  _(ReduceL1)                       \
+  _(ReduceL2)                       \
+  _(ReduceLogSum)                   \
+  _(ReduceLogSumExp)                \
+  _(ReduceMax)                      \
+  _(ReduceMean)                     \
+  _(ReduceMin)                      \
+  _(ReduceProd)                     \
+  _(ReduceSum)                      \
+  _(ReduceSumSquare)                \
+  _(Cast)                           \
+  _(to)                             \
+  _(PRelu)                          \
+  _(Greater)                        \
+  _(Less)                           \
+  _(scales)                         \
+  _(Upsample)                       \
+  _(RNN)                            \
+  _(layout)                         \
+  _(k)                              \
+  _(Flatten)                        \
+  _(ScatterElements)                \
+  _(Resize)                         \
+  _(ceil_mode)                      \
+  _(num_outputs)                    \
+  _(start)                          \
+  _(end)                            \
+  _(num_groups)                     \
+  _(stash_type)                     \
+  _(block_size)                     \
+  _(output_dtype)
+
+enum BuiltinSymbol : std::uint8_t {
+#define DEFINE_SYMBOL(s) k##s,
+  FORALL_BUILTIN_SYMBOLS(DEFINE_SYMBOL)
+#undef DEFINE_SYMBOL
+      kLastSymbol, // where we start counting for new symbols
+};
+
+struct Symbol {
+  Symbol() = default;
+  // NOLINTNEXTLINE(google-explicit-constructor, runtime/explicit)
+  /*implicit*/ Symbol(BuiltinSymbol value) : value(value) {}
+  explicit Symbol(const std::string& s);
+  explicit Symbol(uint32_t value) : value(value) {}
+
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  operator uint32_t() const {
+    return value;
+  }
+  const char* toString() const;
+
+ private:
+  uint32_t value{0};
+};
+
+static inline bool operator==(Symbol lhs, Symbol rhs) {
+  return static_cast<uint32_t>(lhs) == static_cast<uint32_t>(rhs);
+}
+// necessary to prevent ambiguous overload resolutions
+static inline bool operator==(BuiltinSymbol lhs, Symbol rhs) {
+  return static_cast<uint32_t>(lhs) == static_cast<uint32_t>(rhs);
+}
+static inline bool operator==(Symbol lhs, BuiltinSymbol rhs) {
+  return static_cast<uint32_t>(lhs) == static_cast<uint32_t>(rhs);
+}
+
+inline Symbol
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 5
+operator"" _sym // gcc 4.8.5 insists on having a space (hard error).
+#else
+operator""_sym // clang 17 generates a deprecation warning if there is a space.
+#endif
+    (const char* s, size_t /*unused*/) {
+  return Symbol(s);
+}
+
+} // namespace ONNX_NAMESPACE
+
+// make symbol behave like an integer in hash tables
+namespace std {
+template <>
+struct hash<ONNX_NAMESPACE::Symbol> {
+  std::size_t operator()(ONNX_NAMESPACE::Symbol s) const {
+    return std::hash<uint32_t>()(static_cast<uint32_t>(s));
+  }
+};
+
+} // namespace std
diff --git a/onnx/common/ir.h b/onnx/common/ir.h
new file mode 100644
index 0000000..832e8ec
--- /dev/null
+++ b/onnx/common/ir.h
@@ -0,0 +1,1424 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <charconv>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "onnx/common/array_ref.h"
+#include "onnx/common/assertions.h"
+#include "onnx/common/common.h"
+#include "onnx/common/graph_node_list.h"
+#include "onnx/common/interned_strings.h"
+#include "onnx/common/tensor.h"
+#include "onnx/string_utils.h"
+
+namespace ONNX_NAMESPACE {
+
+// internal/private API
+static inline std::string toVarName(size_t i) {
+  std::ostringstream oss;
+  oss << "_v_" << i;
+  return oss.str();
+}
+
+// Graph represents one "function" of computation.
+// It uses a simple ownership model where the graph owns all the nodes inside it.
+// All references inside the graph are raw pointers.
+// Destroying the Graph will invalidate any pointers to nodes in the graph.
+struct Graph;
+
+// Node is the base class of the IR graph. It represents one computation
+// and dependencies on a list of Values. The "prim-ops", so to speak.
+struct Node;
+
+// A Value represents an input or output to node that is either a
+// Tensor or an opaque Handle object, as determined by type().
+struct Value;
+
+class ResourceGuard final {
+  std::function<void()> destructor_;
+
+ public:
+  ONNX_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(ResourceGuard);
+
+  explicit ResourceGuard(std::function<void()> destructor) : destructor_(std::move(destructor)) {}
+
+  ~ResourceGuard() {
+    destructor_();
+  }
+};
+
+struct Dimension final {
+  Dimension() : is_unknown(true), is_int(false), dim(-1) {}
+  explicit Dimension(std::string param) : is_unknown(false), is_int(false), dim(-1), param(std::move(param)) {}
+  explicit Dimension(int64_t dim) : is_unknown(false), is_int(true), dim(dim) {}
+
+  bool is_unknown;
+  bool is_int;
+  int64_t dim;
+  std::string param;
+};
+
+enum class AttributeKind : uint8_t {
+  // float, float list, int, int list, string, string list,
+  // tensor, tensor list, subgraph, subgraph list. type proto, type proto list
+  f,
+  fs,
+  i,
+  is,
+  s,
+  ss,
+  t,
+  ts,
+  g,
+  gs,
+  tp,
+  tps
+};
+
+static inline const char* toString(AttributeKind kind) {
+  // NOLINTNEXTLINE(modernize-avoid-c-arrays)
+  static constexpr const char* names[] = {"f", "fs", "i", "is", "s", "ss", "t", "ts", "g", "gs", "tp", "tps"};
+  ONNX_ASSERT(size_t(kind) < std::size(names))
+  return names[static_cast<int>(kind)];
+}
+
+struct AttributeValue {
+  explicit AttributeValue(Symbol name) : name(name) {}
+  using Ptr = std::unique_ptr<AttributeValue>;
+  Symbol name;
+  virtual AttributeKind kind() const = 0;
+  virtual Ptr clone() const = 0;
+  virtual ~AttributeValue() = default;
+};
+
+template <typename T, AttributeKind Kind>
+struct ScalarAttributeValue final : public AttributeValue {
+  using ConstructorType = const T&;
+  using ValueType = T;
+  ScalarAttributeValue(Symbol name, ConstructorType value_) : AttributeValue(name), value_(value_) {}
+  ValueType& value() {
+    return value_;
+  }
+  Ptr clone() const override {
+    return std::make_unique<ScalarAttributeValue>(name, value_);
+  }
+  AttributeKind kind() const override {
+    return Kind;
+  }
+
+ private:
+  ValueType value_;
+};
+
+template <typename T, AttributeKind Kind>
+struct VectorAttributeValue final : public AttributeValue {
+  using ConstructorType = const std::vector<T>&&;
+  using ValueType = std::vector<T>;
+  VectorAttributeValue(Symbol name, ValueType value_) : AttributeValue(name), value_(std::move(value_)) {}
+  ValueType& value() {
+    return value_;
+  }
+  AttributeKind kind() const override {
+    return Kind;
+  }
+  std::unique_ptr<AttributeValue> clone() const override {
+    return std::make_unique<VectorAttributeValue>(name, ValueType(value_));
+  }
+
+ private:
+  ValueType value_;
+};
+
+using FloatAttr = ScalarAttributeValue<double, AttributeKind::f>;
+using FloatsAttr = VectorAttributeValue<double, AttributeKind::fs>;
+using IntAttr = ScalarAttributeValue<int64_t, AttributeKind::i>;
+using IntsAttr = VectorAttributeValue<int64_t, AttributeKind::is>;
+using StringAttr = ScalarAttributeValue<std::string, AttributeKind::s>;
+using StringsAttr = VectorAttributeValue<std::string, AttributeKind::ss>;
+using TensorAttr = ScalarAttributeValue<Tensor, AttributeKind::t>;
+using TensorsAttr = VectorAttributeValue<Tensor, AttributeKind::ts>;
+using GraphAttr = ScalarAttributeValue<std::shared_ptr<Graph>, AttributeKind::g>;
+using GraphsAttr = VectorAttributeValue<std::shared_ptr<Graph>, AttributeKind::gs>;
+using TypeProtoAttr = ScalarAttributeValue<TypeProto, AttributeKind::tp>;
+using TypeProtosAttr = VectorAttributeValue<TypeProto, AttributeKind::tps>;
+
+// CRTP so that Node which inherits Attributes can be return for
+// method chaining e.g:
+// Node * n = g->create(kSelect)->set_i(kOffset,3)->set_f(kValue,3.5);
+// we return Derived* pointers because Nodes are normally held as pointers.
+template <typename Derived>
+struct Attributes {
+  // NOLINTNEXTLINE(bugprone-crtp-constructor-accessibility)
+  Attributes() = default;
+
+  void copyAttributes(const Attributes& rhs) {
+    values_.clear();
+    values_.reserve(rhs.values_.size());
+    for (const auto& i : rhs.values_) {
+      values_.push_back(i->clone());
+    }
+  }
+  bool hasAttribute(Symbol name) const {
+    return find(name, false) != values_.end();
+  }
+  AttributeKind kindOf(Symbol name) const {
+    return (*find(name, true))->kind();
+  }
+  Derived* removeAttribute(Symbol name) {
+    values_.erase(find(name, true));
+    return This();
+  }
+  bool hasAttributes() const {
+    return !values_.empty();
+  }
+  // The names are returned in order, since name actually is the index.
+  std::vector<Symbol> attributeNames() const {
+    std::vector<Symbol> names;
+    names.reserve(values_.size());
+    for (const auto& a : values_)
+      names.push_back(a->name);
+    return names;
+  }
+
+#define CREATE_ACCESSOR(Kind, method)                                           \
+  Derived* method##_(Symbol name, Kind##Attr::ConstructorType v) {              \
+    return set<Kind##Attr>(name, std::forward<Kind##Attr::ConstructorType>(v)); \
+  }                                                                             \
+  const Kind##Attr::ValueType& method(Symbol name) const {                      \
+    return get<Kind##Attr>(name);                                               \
+  }
+  CREATE_ACCESSOR(Float, f)
+  CREATE_ACCESSOR(Floats, fs)
+  CREATE_ACCESSOR(String, s)
+  CREATE_ACCESSOR(Strings, ss)
+  CREATE_ACCESSOR(Int, i)
+  CREATE_ACCESSOR(Ints, is)
+  CREATE_ACCESSOR(Tensor, t)
+  CREATE_ACCESSOR(Tensors, ts)
+  CREATE_ACCESSOR(Graph, g)
+  CREATE_ACCESSOR(Graphs, gs)
+  CREATE_ACCESSOR(TypeProto, tp)
+  CREATE_ACCESSOR(TypeProtos, tps)
+
+#undef CREATE_ACCESSOR
+
+ private:
+  Derived* This() {
+    return static_cast<Derived*>(this);
+  }
+  template <typename T>
+  Derived* set(Symbol name, typename T::ConstructorType v) {
+    auto it = find(name, false);
+    auto nv = std::make_unique<T>(name, std::forward<typename T::ConstructorType>(v));
+    if (it == values_.end()) {
+      values_.push_back(std::move(nv));
+    } else {
+      *it = std::move(nv);
+    }
+    return This();
+  }
+  template <typename T>
+  typename T::ValueType& get(Symbol name) const {
+    auto it = find(name, true);
+    T* child = static_cast<T*>(it->get());
+    return child->value();
+  }
+  using AVPtr = AttributeValue::Ptr;
+  // NB: For determinism, we use a vector rather than a hash map.  This does
+  // mean that lookups are O(n), so you shouldn't use Attributes to store
+  // a big pile of messages.
+  std::vector<AVPtr> values_;
+  using iterator = std::vector<AVPtr>::iterator;
+  iterator find(Symbol name, bool required) {
+    auto it = std::find_if(values_.begin(), values_.end(), [&](const AVPtr& v) { return v->name == name; });
+    ONNX_ASSERT(!required || it != values_.end())
+    return it;
+  }
+  using const_iterator = std::vector<AVPtr>::const_iterator;
+  const_iterator find(Symbol name, bool required) const {
+    auto it = std::find_if(values_.begin(), values_.end(), [&](const AVPtr& v) { return v->name == name; });
+    ONNX_ASSERTM(!required || it != values_.end(), "required undefined attribute '", name.toString(), "'")
+    return it;
+  }
+};
+
+// Each use is represented by this type, see Node::uses()
+// 'user' is the consumer of the value, offset is the index into
+// 'user's input this where the produces will be found.
+struct Use final {
+  Use(Node* user, size_t offset) : user(user), offset(offset) {}
+  Node* user;
+  size_t offset;
+};
+
+static inline bool operator==(const Use& a, const Use& b) {
+  return a.user == b.user && a.offset == b.offset;
+}
+
+// the list types are intentionally simple, but we type-def
+// them here so if we need to change them, refactoring will be easier
+using node_list = std::vector<Node*>;
+using value_list = std::vector<Value*>;
+using use_list = std::vector<Use>;
+using NodeKind = Symbol;
+
+struct Value final {
+  ONNX_DISALLOW_COPY_AND_ASSIGNMENT(Value);
+  Value(Node& node, size_t offset);
+  Value(Value&&) = default;
+  Value& operator=(Value&&) = default;
+  ~Value() = default;
+
+ private:
+  friend struct Node;
+  friend struct Graph;
+  Node* node_;
+  size_t offset_;
+  size_t unique_ = 0; // unique id
+  size_t stage_ = 0; // 0-forward, 1-backward, 2-double-backward,...
+  use_list uses_in_current_graph_;
+  bool has_unique_name_{false};
+  std::string unique_name_;
+  int32_t elem_type_{ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED};
+  bool has_sizes_{false};
+  std::vector<Dimension> sizes_;
+  std::unique_ptr<TypeProto> type_;
+
+ public:
+  Value* setElemType(int32_t elem_type) {
+    elem_type_ = elem_type;
+    return this;
+  }
+  int32_t elemType() const {
+    return elem_type_;
+  }
+  bool has_sizes() const {
+    return has_sizes_;
+  }
+  Value* setSizes(std::vector<Dimension> sizes) {
+    has_sizes_ = true;
+    sizes_ = std::move(sizes);
+    return this;
+  }
+  Value* wipeSizes() {
+    has_sizes_ = false;
+    sizes_ = std::vector<Dimension>();
+    return this;
+  }
+  const std::vector<Dimension>& sizes() const {
+    return sizes_;
+  }
+  size_t unique() const {
+    return unique_;
+  }
+  bool has_unique_name() const {
+    return has_unique_name_;
+  }
+  std::string uniqueName() const {
+    if (has_unique_name())
+      return unique_name_;
+    return toVarName(unique());
+  }
+  Value* setUniqueName(const std::string& name, bool update_related_names = true);
+  Value* setStage(size_t s) {
+    stage_ = s;
+    return this;
+  }
+  size_t stage() const {
+    return stage_;
+  }
+  Node* node() {
+    return node_;
+  }
+  size_t offset() const {
+    return offset_;
+  }
+  const Node* node() const {
+    return node_;
+  }
+  Graph* owningGraph();
+  const Graph* owningGraph() const;
+  use_list uses() const;
+
+  // Replaces all uses of this node with 'newValue'.
+  //
+  // Given:   %3 = f(%1, %2)
+  //          %4 = g(%3)
+  //          %5 = h(%3, %3)
+  // Execute: %3.replaceAllUsesWith(%6)
+  // Result:  %3 = f(%1, %2)
+  //          %4 = g(%6)
+  //          %5 = h(%6, %6)
+  void replaceAllUsesWith(Value* newValue);
+
+  Value* copyMetadata(const Value* from) {
+    setElemType(from->elemType());
+    setSizes(from->sizes());
+    if (from->has_unique_name()) {
+      setUniqueName(from->uniqueName());
+    }
+    return this;
+  }
+
+  std::unique_ptr<TypeProto>& type() {
+    return type_;
+  }
+};
+
+struct Node : public Attributes<Node> {
+  ONNX_DISALLOW_COPY_AND_ASSIGNMENT(Node);
+  friend struct Graph;
+  friend struct Value;
+  friend graph_node_list;
+  friend const_graph_node_list;
+  friend graph_node_list_iterator;
+  friend const_graph_node_list_iterator;
+
+ private:
+  // each node but Return/Param
+  // is associated with exactly one place in the node list...
+  // of the graph_
+  // this circular is a doubly-linked list, the Return node is used as the sentinel for the beginning and end of the
+  // list such that the list never has null pointers next_in_graph[0] is next pointer next_in_graph[1] is prev pointer
+  // using an array to allow the same iterator class for forward and reverse node lists
+  // This list represents a topological sort
+
+  std::array<Node*, 2> next_in_graph{nullptr, nullptr};
+  Node*& next() {
+    return next_in_graph[kNextDirection];
+  }
+  Node*& prev() {
+    return next_in_graph[kPrevDirection];
+  }
+  Node* const& next() const {
+    return next_in_graph[kNextDirection];
+  }
+  Node* const& prev() const {
+    return next_in_graph[kPrevDirection];
+  }
+
+  const NodeKind kind_;
+  std::vector<Value*> inputs_;
+  std::vector<Value*> outputs_;
+  Graph* graph_;
+  size_t stage_;
+  bool has_name_{false};
+  std::string name_;
+  bool has_domain_{false};
+  std::string domain_;
+  bool has_doc_string_{false};
+  std::string doc_string_;
+  bool has_overload_{false};
+  std::string overload_;
+
+  // Constructed only by the friend Graph factory, so every Node stays graph-owned.
+  Node(Graph& graph, NodeKind kind); // defined after graph
+
+ public:
+  bool has_name() const {
+    return has_name_;
+  }
+  const std::string& name() const {
+    return name_;
+  }
+  void setName(std::string name) {
+    has_name_ = true;
+    name_ = std::move(name);
+  }
+  bool has_domain() const {
+    return has_domain_;
+  }
+  const std::string& domain() const {
+    return domain_;
+  }
+  void setDomain(std::string domain) {
+    has_domain_ = true;
+    domain_ = std::move(domain);
+  }
+  bool has_overload() const {
+    return has_overload_;
+  }
+  const std::string& overload() const {
+    return overload_;
+  }
+  void setOverload(std::string overload) {
+    has_overload_ = true;
+    overload_ = std::move(overload);
+  }
+  bool has_doc_string() const {
+    return has_doc_string_;
+  }
+  const std::string& docString() const {
+    return doc_string_;
+  }
+  void setDocString(std::string doc_string) {
+    has_doc_string_ = true;
+    doc_string_ = std::move(doc_string);
+  }
+  NodeKind kind() const {
+    return kind_;
+  }
+  Graph* owningGraph() {
+    return graph_;
+  }
+  const Graph* owningGraph() const {
+    return graph_;
+  }
+  size_t stage() const {
+    return stage_;
+  }
+  Node* setStage(size_t s) {
+    stage_ = s;
+    return this;
+  }
+  // NB: This returns an ArrayRef; that means that it will
+  // get invalidated if you resize inputs (e.g., using addInput)
+  // We can't return a std::vector<Node*>& because there's no
+  // way to soundly cast to std::vector<const Node*> (an insane
+  // implementation of std::vector could make this representationally
+  // different.)
+  ArrayRef<Value*> inputs() {
+    return inputs_;
+  }
+  ArrayRef<const Value*> inputs() const {
+    // Vectors are not convertible in const-ness of elements, but
+    // raw pointers are.
+    return {inputs_.data(), inputs_.size()};
+  }
+  // NB: This returns an ArrayRef; that means that it will
+  // get invalidated if you resize inputs (e.g., using addInput)
+  // We can't return a std::vector<Node*>& because there's no
+  // way to soundly cast to std::vector<const Node*> (an insane
+  // implementation of std::vector could make this representationally
+  // different.)
+  ArrayRef<Value*> outputs() {
+    return outputs_;
+  }
+  ArrayRef<const Value*> outputs() const {
+    // Vectors are not convertible in const-ness of elements, but
+    // raw pointers are.
+    return {outputs_.data(), outputs_.size()};
+  }
+  bool hasUses() const {
+    for (const auto* o : outputs()) {
+      if (!o->uses().empty())
+        return true;
+    }
+    return false;
+  }
+  void replaceAllUsesWith(Node* n) {
+    ONNX_ASSERT(outputs().size() == n->outputs().size())
+    size_t nOutputs = outputs().size();
+    for (size_t i = 0; i < nOutputs; i++) {
+      outputs()[i]->replaceAllUsesWith(n->outputs()[i]);
+    }
+  }
+  // lots of things like chunk have a single input or single output, so we have a
+  // helper to make accessing it easier
+  Value* input() {
+    ONNX_ASSERT(inputs_.size() == 1)
+    return inputs_.at(0);
+  }
+  Value* output() {
+    ONNX_ASSERT(outputs_.size() == 1)
+    return outputs_.at(0);
+  }
+  const Value* input() const {
+    ONNX_ASSERT(inputs_.size() == 1)
+    return inputs_.at(0);
+  }
+  const Value* output() const {
+    ONNX_ASSERT(outputs_.size() == 1)
+    return outputs_.at(0);
+  }
+  // Access a particular input.  This is a checked index.
+  Value* input(size_t i) {
+    return inputs_.at(i);
+  }
+  const Value* input(size_t i) const {
+    return inputs_.at(i);
+  }
+
+  // Graphs
+
+  // Note [Topological invariant]
+  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  // We always maintain an up-to-date topological ordering of all nodes via
+  // the next()/prev() links.  All transformations to graphs must preserve
+  // this topological ordering: for example, it is only valid to 'addInput'
+  // with an input which is topologically before the current node.
+  //
+  // Usually, it is obvious whether or not topological order is maintained;
+  // for example, if you are adding nodes to the end of the topsort, it's
+  // impossible for them to refer to inputs that are not in the topsort.
+  // If it is not obvious, please comment accordingly.
+
+  // Add 'node' as an input to 'this' at the end of existing
+  // arguments.  Returns the added node for ease of chaining.
+  //
+  // Given:   %3 = f(%1, %2)
+  // Execute: %3.addInput(%4)
+  // Result:  %3 = f(%1, %2, %4)
+  Value* addInput(Value* node) {
+    ONNX_ASSERT(graph_ == node->owningGraph())
+    node->uses_in_current_graph_.emplace_back(this, inputs_.size());
+    inputs_.push_back(node);
+    return node;
+  }
+
+  // Replace the input of 'this' at position 'i' with
+  // 'newValue', returning the old node.
+  //
+  // Given:   %3 = f(%1, %2)
+  // Execute: %3.replaceInput(1, %4)
+  // Result:  %3 = f(%1, %4)
+  Value* replaceInput(size_t i, Value* newValue) {
+    ONNX_ASSERT(newValue->owningGraph() == graph_)
+    Value* old = dropInput(i);
+    inputs_[i] = newValue;
+    newValue->uses_in_current_graph_.emplace_back(this, i);
+    return old;
+  }
+
+  // Replace all occurrences of 'from' in the inputs of this
+  // node with 'to'. Corresponds to llvm's replaceUsesOfWith.
+  //
+  // Given:   %3 = f(%1, %2, %1)
+  // Execute: %3.replaceInputWith(%1, %4)
+  // Result:  %3 = f(%4, %2, %4)
+  void replaceInputWith(Value* from, Value* to) {
+    ONNX_ASSERT(from->owningGraph() == graph_)
+    ONNX_ASSERT(to->owningGraph() == graph_)
+    size_t i = 0;
+    for (const auto* input : inputs()) {
+      if (input == from)
+        replaceInput(i, to);
+      i++;
+    }
+  }
+
+  Value* addOutput();
+
+  void eraseOutput(size_t i);
+
+  // Insert unattached 'this' node after 'n' in the topological order.
+  // Returns this (for chaining).
+  //
+  // Given:   %3 = f(%1, %2)
+  //          %4 = g(%3)
+  // and unattached: %5 = h(%1)
+  // Execute: %5.insertBefore(%4)
+  // Result:  %3 = f(%1, %2)
+  //          %5 = h(%1)
+  //          %4 = g(%3)
+  Node* insertBefore(Node* n) {
+    ONNX_ASSERT(n->inGraphList())
+    insertAfter(n->prev());
+    return this;
+  }
+
+  // Insert unattached 'this' node after 'n' in the topological order.
+  // Returns this (for chaining).
+  //
+  // Given: %3 = f(%1, %2)
+  //        %4 = g(%3)
+  // and unattached: %5 = h(%1)
+  // Execute: %5.insertAfter(%4)
+  // Result:  %3 = f(%1, %2)
+  //          %4 = g(%3)
+  //          %5 = h(%1)
+  Node* insertAfter(Node* n) {
+    ONNX_ASSERT(!inGraphList() && n->inGraphList())
+    Node* next = n->next();
+    n->next() = this;
+    this->prev() = n;
+    this->next() = next;
+    next->prev() = this;
+    return this;
+  }
+
+  // Move 'this' (already in the graph) after 'n' in the topological order.
+  //
+  // Given: %2 = f(%1)
+  //        %3 = g(%1)
+  // Execute: %2.moveAfter(%3)
+  // Result: %3 = g(%1)
+  //         %2 = f(%1)
+  //
+  void moveAfter(Node* n) {
+    removeFromList();
+    insertAfter(n);
+  }
+
+  // Move a node 'n' (already in the graph) before 'this' in the topological order.
+  //
+  // Given: %2 = f(%1)
+  //        %3 = g(%1)
+  // Execute: %3.moveBefore(%2)
+  // Result: %3 = g(%1)
+  //         %2 = f(%1)
+  void moveBefore(Node* n) {
+    removeFromList();
+    insertBefore(n);
+  }
+
+  // Remove the input at 'i' from this node.
+  //
+  // WARNING: This is O(n) in the number of inputs, so avoid repeatedly calling
+  // removeInput.
+  //
+  // Given: %3 = f(%1, %2)
+  // Execute: %3.removeInput(1)
+  // Result: %3 = f(%1)
+  void removeInput(size_t i) {
+    dropInput(i);
+    // everything after this input shifts left,
+    // so we need to update their use offsets to match
+    for (size_t j = i + 1; j < inputs_.size(); j++) {
+      auto it = findUseForInput(j);
+      it->offset--;
+    }
+    inputs_.erase(inputs_.begin() + i);
+  }
+
+  // Remove all inputs from a node.
+  //
+  // Given: %3 = f(%1, %2)
+  // Execute: %3.removeAllInputs()
+  // Result: %3 = f()
+  void removeAllInputs() {
+    for (size_t i = 0; i < inputs().size(); ++i)
+      dropInput(i);
+    inputs_.clear();
+  }
+
+  // Check whether this node is before node n in the graph.
+  bool isBefore(const Node* n);
+
+  // iterators of the node list starting at this node
+  // useful for resuming a search starting at this node
+  graph_node_list_iterator iterator();
+  graph_node_list_iterator reverseIterator();
+  const_graph_node_list_iterator iterator() const;
+  const_graph_node_list_iterator reverseIterator() const;
+
+  // Remove 'this' from the instruction list and deallocate it.
+  //
+  // Invariant: no outputs of 'this' may have any uses.
+  //
+  // Given: %2 = f(%1)
+  //        %3 = g(%1)
+  // Execute: %2.destroy()
+  // Result: %3 = g(%1)
+  void destroy();
+
+  // Dynamically cast this node to the subclass indicated by the
+  // template variable, returning nullptr if the cast is invalid..
+  //
+  // Example usage: if(auto s = n.cast<Select>()) { ... }
+  //
+  template <typename T>
+  T* cast() {
+    if (T::Kind == kind())
+      return static_cast<T*>(this);
+    return nullptr;
+  }
+  template <typename T>
+  const T* cast() const {
+    if (T::Kind == kind())
+      return static_cast<const T*>(this);
+    return nullptr;
+  }
+  template <typename T>
+  T* expect() {
+    ONNX_ASSERTM(T::Kind == kind(), "expected a ", T::Kind.toString(), " but found a ", kind().toString())
+    return static_cast<T*>(this);
+  }
+  template <typename T>
+  const T* expect() const {
+    ONNX_ASSERTM(T::Kind == kind(), "expected a ", T::Kind.toString(), " but found a ", kind().toString())
+    return static_cast<const T*>(this);
+  }
+
+  virtual ~Node() = default;
+
+ private:
+  // Lookup iterator in use list of _input i_ that corresponds to its use of _this_
+  use_list::iterator findUseForInput(size_t i) {
+    auto& input_uses = inputs_[i]->uses_in_current_graph_;
+    // O(N) on the use list, but unless we get nodes with +100 uses
+    // vector traversal still is probably faster than linked list
+    auto use_it = std::find(input_uses.begin(), input_uses.end(), Use(this, i));
+    ONNX_ASSERT(use_it != input_uses.end())
+    return use_it;
+  }
+
+  // remove the use of input i, this sets input i to nullptr, but
+  // is only used internally to Node before setting it to a new value
+  // or erasing the entry from the list.
+  Value* dropInput(size_t i) {
+    ONNX_ASSERT(i < inputs_.size())
+    auto* input_node = inputs_[i];
+    auto use_it = findUseForInput(i);
+    input_node->uses_in_current_graph_.erase(use_it);
+    inputs_[i] = nullptr;
+    return input_node;
+  }
+
+  bool inGraphList() const {
+    ONNX_ASSERT(next() != nullptr || prev() == nullptr)
+    return next() != nullptr;
+  }
+  void removeFromList() {
+    ONNX_ASSERT(inGraphList())
+    Node* next = this->next();
+    Node* prev = this->prev();
+    prev->next() = next;
+    next->prev() = prev;
+    this->next() = nullptr;
+    this->prev() = nullptr;
+  }
+};
+
+// A class with the same properties as OperatorSetIdProto, but without protobuf
+// overhead, resulting in a simpler and more readable workflow.
+class OpSetID final {
+ private:
+  std::string domain_;
+  int64_t version_;
+
+ public:
+  explicit OpSetID(const OperatorSetIdProto& proto) : domain_(proto.domain()), version_(proto.version()) {}
+
+  // Default Domain Constructor
+  explicit OpSetID(const int64_t version) : version_(version) {}
+
+  explicit OpSetID(std::string domain, int64_t version) : domain_(std::move(domain)), version_(version) {}
+
+  // target must be in the form "<domain>$<version>"
+  std::string toString() const {
+    return domain_ + "$" + ONNX_NAMESPACE::to_string(version_);
+  }
+
+  // target must be in the form "<domain>$<version>"
+  static OpSetID fromString(const std::string& target) {
+    ONNX_TRY {
+      auto pos = target.find('$');
+      if (pos == std::string::npos) {
+        ONNX_THROW("Invalid OpSetID string '", target, "': must be in the form \"<domain>$<version>\"");
+      }
+      std::string new_domain = target.substr(0, pos);
+      const char* version_start = target.data() + pos + 1;
+      const char* version_end = target.data() + target.size();
+      int64_t new_version = 0;
+      auto result = std::from_chars(version_start, version_end, new_version);
+      if (result.ec != std::errc{} || result.ptr != version_end) {
+        ONNX_THROW("Invalid OpSetID string '", target, "': must be in the form \"<domain>$<version>\"");
+      }
+      return OpSetID(new_domain, new_version);
+    }
+    ONNX_CATCH(const std::runtime_error& e) {
+      ONNX_HANDLE_EXCEPTION([&]() { ONNX_ASSERTM(false, "Error in fromString: ", e.what()) });
+    }
+
+    // The control will never reach here.
+    // In the default build where exceptions are turned on in case of any error
+    // the control will enter catch block where an exception will be thrown again.
+    // In case of "no exception build" the code aborts at the site of first exception.
+    // Adding this to appease the warning "control may reach end of non-void function"
+    // as the mac build fails when ONNX_WERROR==ON
+    return OpSetID("", 0);
+  }
+
+  const std::string& domain() const {
+    return domain_;
+  }
+
+  int64_t version() const {
+    return version_;
+  }
+
+  void incrementVersion(int64_t step) {
+    version_ += step;
+  }
+
+  void setVersion(int64_t newVal) {
+    version_ = newVal;
+  }
+};
+
+struct Graph final {
+  ONNX_DISALLOW_COPY_AND_ASSIGNMENT(Graph);
+  friend struct Node;
+  friend struct Value;
+
+ private:
+  // only used to keep track of allocated nodes
+  // actual representation of Graph is done with
+  // inputs, outputs, nodes
+
+  std::unordered_map<const Node*, std::unique_ptr<const Node>> all_nodes;
+  std::unordered_map<const Value*, std::unique_ptr<const Value>> all_values;
+  size_t next_unique_{0};
+
+  size_t new_node_stage_{0};
+
+  // holds outputs in a way that can be reflected
+  // as a Use object
+  // also used as the beginning/end of the circular node list to avoid
+  // having corner cases where the list is empty.
+  Node* const output_;
+  Node* const input_;
+  // Create an independent node list for those initializers do not exist in input
+  Node* const initializer_node_;
+
+  std::vector<Tensor> initializers_;
+  std::vector<std::string> initializer_names_;
+
+  bool has_name_{false};
+  std::string name_;
+  bool has_doc_string_{false};
+  std::string doc_string_;
+
+  std::vector<OpSetID> opset_versions_;
+
+  bool isNameUnique(const std::string& name) const {
+    if (std::find(initializer_names_.cbegin(), initializer_names_.cend(), name) != initializer_names_.cend()) {
+      return false;
+    }
+    const auto f = [&name](const Value* v) { return v->uniqueName() == name; };
+    for (const auto& node_entry : all_nodes) {
+      const Node* node = node_entry.first;
+      for (const auto& attr : node->attributeNames()) {
+        if (node->kindOf(attr) == AttributeKind::g) {
+          const auto& subgraph = node->g(attr);
+          if (!subgraph->isNameUnique(name)) {
+            return false;
+          }
+        } else if (node->kindOf(attr) == AttributeKind::gs) {
+          for (const auto& subgraph : node->gs(attr)) {
+            if (!subgraph->isNameUnique(name)) {
+              return false;
+            }
+          }
+        }
+      }
+      const auto* const found_in = std::find_if(node->inputs().begin(), node->inputs().end(), f);
+      if (found_in != node->inputs().end()) {
+        return false;
+      }
+      const auto* const found_out = std::find_if(node->outputs().begin(), node->outputs().end(), f);
+      if (found_out != node->outputs().end()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+ public:
+  Graph() : output_(initOutput(create(kReturn, 0))), input_(create(kParam, 0)), initializer_node_(create(kParam, 0)) {}
+
+  bool has_doc_string() const {
+    return has_doc_string_;
+  }
+  const std::string& docString() const {
+    return doc_string_;
+  }
+  void setDocString(std::string doc_string) {
+    has_doc_string_ = true;
+    doc_string_ = std::move(doc_string);
+  }
+
+  void addInitializer(Tensor& initializer) {
+    if (initializer.name().empty()) {
+      initializer.setName(getNextUniqueName());
+    }
+    initializers_.push_back(initializer);
+    initializer_names_.push_back(initializer.name());
+  }
+
+  // For IR >= 4, initializer is not required to exist in input
+  // Add initializer into initializer node list and return its Value
+  Value* addInitializerAndCreateValue(Tensor& initializer) {
+    addInitializer(initializer);
+    auto* init_value = initializer_node_->addOutput();
+    std::vector<Dimension> dim_sizes{initializer.sizes().cbegin(), initializer.sizes().cend()};
+    init_value->setUniqueName(initializer.name());
+    init_value->setSizes(dim_sizes);
+    init_value->setElemType(initializer.elem_type());
+    return init_value;
+  }
+
+  void eraseInitializer(const std::string& name) {
+    initializers_.erase(
+        std::remove_if(
+            initializers_.begin(),
+            initializers_.end(),
+            [&name](Tensor& initializer) { return initializer.name() == name; }),
+        initializers_.end());
+    initializer_names_.erase(
+        std::remove(initializer_names_.begin(), initializer_names_.end(), name), initializer_names_.end());
+    for (size_t i = 0; i < initializer_node_->outputs().size(); i++) {
+      if (initializer_node_->outputs()[i]->uniqueName() == name) {
+        initializer_node_->eraseOutput(i);
+        break;
+      }
+    }
+  }
+  void clearInitializers() {
+    initializers_.clear();
+    initializer_names_.clear();
+  }
+  const std::vector<Tensor>& initializers() const {
+    return initializers_;
+  }
+  const std::vector<std::string>& initializer_names() const {
+    return initializer_names_;
+  }
+  std::vector<Tensor>::const_iterator getInitializer(const std::string& name) const {
+    for (auto it = initializers_.cbegin(); it != initializers_.cend(); ++it) {
+      if (name == it->name()) {
+        return it;
+      }
+    }
+    return initializers_.end();
+  }
+  bool is_constant_initializer(const Value* value) const {
+    return value->node() == initializer_node_;
+  }
+  ArrayRef<Value*> inputs() {
+    return input_->outputs();
+  }
+  ArrayRef<const Value*> inputs() const {
+    const auto& inputs = input_->outputs();
+    return {inputs.data(), inputs.size()};
+  }
+  ArrayRef<Value*> outputs() {
+    return output_->inputs();
+  }
+  ArrayRef<const Value*> outputs() const {
+    return static_cast<const Node*>(output_)->inputs();
+  }
+  graph_node_list nodes() {
+    return graph_node_list(output_, kNextDirection);
+  }
+  const_graph_node_list nodes() const {
+    return const_graph_node_list(output_, kNextDirection);
+  }
+
+  std::vector<OpSetID>& opset_versions_mutable() {
+    return opset_versions_;
+  }
+
+  size_t getNextUnique() {
+    std::string next_unique_name = toVarName(++next_unique_);
+    while (!isNameUnique(next_unique_name)) {
+      next_unique_name = toVarName(++next_unique_);
+    }
+    return next_unique_;
+  }
+
+  std::string getNextUniqueName() {
+    return toVarName(getNextUnique());
+  }
+
+  // These invocations of begin() on output of function are OK
+  // because graph_node_list is non-owning, so it doesn't matter
+  // if it immediately dies after the invocation.
+  graph_node_list_iterator begin() {
+    return nodes().begin();
+  }
+  const_graph_node_list_iterator begin() const {
+    return nodes().begin();
+  }
+  graph_node_list_iterator end() {
+    return nodes().end();
+  }
+  const_graph_node_list_iterator end() const {
+    return nodes().end();
+  }
+  graph_node_list_iterator rbegin() {
+    return nodes().rbegin();
+  }
+  const_graph_node_list_iterator rbegin() const {
+    return nodes().rbegin();
+  }
+  graph_node_list_iterator rend() {
+    return nodes().rend();
+  }
+  const_graph_node_list_iterator rend() const {
+    return nodes().rend();
+  }
+  Node* return_node() {
+    return output_;
+  }
+  const Node* return_node() const {
+    return output_;
+  }
+
+  Value* addInput() {
+    return input_->addOutput();
+  }
+  void eraseInput(size_t i) {
+    input_->eraseOutput(i);
+  }
+  void advanceStage() {
+    new_node_stage_++;
+  }
+  void setStage(size_t new_stage) {
+    new_node_stage_ = new_stage;
+  }
+  size_t stage() const {
+    return new_node_stage_;
+  }
+  ResourceGuard setStageTemporary(size_t s) {
+    auto prev_stage = new_node_stage_;
+    new_node_stage_ = s;
+    return ResourceGuard([prev_stage, this]() { this->new_node_stage_ = prev_stage; });
+  }
+
+  size_t registerOutput(Value* n) {
+    output_->addInput(n);
+    return outputs().size() - 1;
+  }
+
+  Node* create(NodeKind kind, size_t num_outputs = 1) {
+    std::unique_ptr<Node> node_owner(new Node(*this, kind));
+    Node* n = node_owner.get();
+    all_nodes.emplace(n, std::move(node_owner));
+    for (size_t i = 0; i < num_outputs; i++)
+      n->addOutput();
+    return n;
+  }
+
+  // Allocate a Value owned by this graph.
+  Value* createValue(Node& node, size_t offset);
+
+  Node* create(NodeKind kind, ArrayRef<Value*> inputs, size_t num_outputs = 1) {
+    auto* n = create(kind, num_outputs);
+    for (auto* i : inputs)
+      n->addInput(i);
+    return n;
+  }
+
+  Node* appendNode(Node* n) {
+    ONNX_ASSERT(n->graph_ == this && !n->inGraphList())
+    n->insertBefore(output_);
+    return n;
+  }
+
+  Node* prependNode(Node* n) {
+    ONNX_ASSERT(n->graph_ == this && !n->inGraphList())
+    n->insertAfter(output_);
+    return n;
+  }
+
+  // Adds to graph initializer list, initializer names list, and as a graph input
+  // Also syncs the initializer name, tensor name, and value name
+  // Create an initializer whose value is stored in input
+  Value* addInitializerAndInput(const Tensor& initializer, const std::string& name) {
+    Tensor initializerCopy = initializer;
+    std::vector<Dimension> dim_sizes{initializerCopy.sizes().cbegin(), initializerCopy.sizes().cend()};
+    Value* new_init = addInput();
+    initializerCopy.setName(name);
+    new_init->setUniqueName(name);
+    new_init->setSizes(dim_sizes);
+    new_init->setElemType(initializerCopy.elem_type());
+    addInitializer(initializerCopy);
+    return new_init;
+  }
+
+  Value* addInitializerAndInput(const Tensor& initializer) {
+    return addInitializerAndInput(initializer, getNextUniqueName());
+  }
+
+  // Erases from graph initializer list, initializer names list, and as a graph input
+  // Must have no uses
+  void eraseInitializerAndInput(Value* v) {
+    Node* node = v->node();
+    const size_t offset = v->offset();
+    eraseInitializer(v->uniqueName());
+    if (node == input_) {
+      eraseInput(offset);
+    }
+  }
+
+  ~Graph() = default;
+
+  std::string toString() const {
+    std::ostringstream oss;
+    oss << *this;
+    return oss.str();
+  }
+
+  bool has_name() const {
+    return has_name_;
+  }
+
+  const std::string& name() const {
+    return name_;
+  }
+
+  void setName(std::string name) {
+    has_name_ = true;
+    name_ = std::move(name);
+  }
+
+  friend std::ostream& operator<<(std::ostream& out, const Graph& g);
+
+  void forSelfAndEachSubGraph(const std::function<void(Graph*)>& fn) {
+    fn(this);
+
+    for (const auto& node_entry : all_nodes) {
+      const Node* node = node_entry.first;
+      for (const auto& attr : node->attributeNames()) {
+        if (node->kindOf(attr) == AttributeKind::g) {
+          std::shared_ptr<Graph> subgraph = node->g(attr);
+          subgraph->forSelfAndEachSubGraph(fn);
+        } else if (node->kindOf(attr) == AttributeKind::gs) {
+          for (const auto& subgraph : node->gs(attr)) {
+            subgraph->forSelfAndEachSubGraph(fn);
+          }
+        }
+      }
+    }
+  }
+
+  void forSelfAndEachSubGraph(const std::function<void(const Graph*)>& fn) const {
+    std::function<void(Graph*)> tmp_fn = [fn](Graph* graph) { fn(graph); };
+    const_cast<Graph*>(this)->forSelfAndEachSubGraph(tmp_fn);
+  }
+
+  void forEachNode(const std::function<void(Node*)>& fn) {
+    forSelfAndEachSubGraph([&fn](Graph* graph) {
+      for (Node* node : graph->nodes()) {
+        fn(node);
+      }
+    });
+  }
+
+  void forEachNode(const std::function<void(const Node*)>& fn) const {
+    std::function<void(Node*)> tmp_fn = [fn](Node* node) { fn(node); };
+    const_cast<Graph*>(this)->forEachNode(tmp_fn);
+  }
+
+ private:
+  // should only be called in the constructor
+  Node* initOutput(Node* p) {
+    p->next() = p;
+    p->prev() = p;
+    p->setStage(std::numeric_limits<size_t>::max());
+    return p;
+  }
+
+  void freeNode(Node* n) {
+    auto it = all_nodes.find(n);
+    ONNX_ASSERT(it != all_nodes.end())
+    all_nodes.erase(it);
+  }
+  void freeValue(Value* v) {
+    auto it = all_values.find(v);
+    ONNX_ASSERT(it != all_values.end())
+    all_values.erase(it);
+  }
+};
+
+inline Value::Value(Node& node, size_t offset)
+    : node_(&node), offset_(offset), unique_(node.graph_->getNextUnique()), stage_(node.graph_->new_node_stage_) {}
+
+inline Graph* Value::owningGraph() {
+  return node()->owningGraph();
+}
+
+inline const Graph* Value::owningGraph() const {
+  return node()->owningGraph();
+}
+
+// `captured` nodes in subgraph determines which value it captures
+// by storing the value's unique name, so old unique names in `captured` nodes
+// should also be updated.
+// Initializer names are also stored in graph.initializer_names_, it should be
+// updated too.
+inline Value* Value::setUniqueName(const std::string& name, bool update_related_names) {
+  if (has_unique_name() && update_related_names) {
+    auto* graph = owningGraph();
+    auto old_name = unique_name_;
+    for (size_t i = 0; i < owningGraph()->initializer_names_.size(); i++) {
+      auto& initializer_name = owningGraph()->initializer_names_[i];
+      if (initializer_name == old_name) {
+        initializer_name = name;
+        owningGraph()->initializers_[i].setName(name);
+      }
+    }
+    graph->forEachNode([this, &name, &old_name](Node* node) {
+      if (node->owningGraph() == this->owningGraph()) {
+        // skip non-subgraph
+        return;
+      }
+      if (node->kind() == kCaptured) {
+        Value* output = node->output();
+        if (output->uniqueName() == old_name) {
+          output->setUniqueName(name, false);
+        }
+      }
+    });
+  }
+  unique_name_ = name;
+  has_unique_name_ = true;
+  return this;
+}
+
+inline void Value::replaceAllUsesWith(Value* newValue) {
+  auto* graph = owningGraph();
+  ONNX_ASSERT(graph == newValue->owningGraph())
+  // propagate sizes and elem type
+  if (this->has_sizes()) {
+    newValue->setSizes(this->sizes());
+  }
+  if (this->elemType() != ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED) {
+    newValue->setElemType(this->elemType());
+  }
+  const auto unique_name = this->uniqueName();
+  // We do not want the optimization to change the graph output name
+  if (std::find(graph->outputs().rbegin(), graph->outputs().rend(), this) != graph->outputs().rend()) {
+    newValue->setUniqueName(unique_name);
+    // The "unique" semantic of unique_name should be kept or uses()
+    // will return an incorrect result when the value is used in subgraph
+    this->setUniqueName(graph->getNextUniqueName(), false);
+  }
+  newValue->uses_in_current_graph_.reserve(this->uses_in_current_graph_.size());
+  for (auto u : uses_in_current_graph_) {
+    u.user->inputs_[u.offset] = newValue;
+    newValue->uses_in_current_graph_.push_back(u);
+  }
+  graph->forEachNode([this, &newValue, &unique_name](Node* node) {
+    if (node->owningGraph() == this->owningGraph()) {
+      // skip non-subgraph
+      return;
+    }
+    if (node->kind() == kCaptured) {
+      Value* output = node->output();
+      if (output->uniqueName() == unique_name) {
+        output->setUniqueName(newValue->uniqueName());
+      }
+    }
+  });
+  uses_in_current_graph_.clear();
+  assert(this->uses().empty());
+}
+
+inline Node::Node(Graph& graph, NodeKind kind) : kind_(kind), graph_(&graph), stage_(graph.new_node_stage_) {}
+
+inline Value* Graph::createValue(Node& node, size_t offset) {
+  auto value = std::make_unique<Value>(node, offset);
+  Value* v = value.get();
+  all_values.emplace(v, std::move(value));
+  return v;
+}
+
+inline Value* Node::addOutput() {
+  Value* v = graph_->createValue(*this, outputs_.size());
+  outputs_.push_back(v);
+  return v;
+}
+
+inline void Node::eraseOutput(size_t i) {
+  ONNX_ASSERT(i < outputs_.size())
+  ONNX_ASSERT(outputs_[i]->uses().empty())
+  Value* n = outputs_[i];
+  outputs_.erase(outputs_.begin() + i);
+  owningGraph()->freeValue(n);
+  for (size_t j = i; j < outputs_.size(); j++) {
+    outputs_[j]->offset_--;
+  }
+}
+
+inline bool Node::isBefore(const Node* n) {
+  if (n == nullptr || this == n) {
+    // Bail out early.
+    return false;
+  }
+  // return true if node is Param (in initializers)
+  if (kind_ == kParam) {
+    return true;
+  }
+  // return false if target node is Param (in initializers)
+  if (n->kind() == kParam) {
+    return false;
+  }
+  ONNX_ASSERT(n->inGraphList())
+  for (Node* p = next(); p != *graph_->end(); p = p->next()) {
+    if (p == n) {
+      return true;
+    }
+  }
+  return false;
+}
+
+inline void Node::destroy() {
+  ONNX_ASSERT(inGraphList())
+  while (!outputs().empty())
+    eraseOutput(outputs().size() - 1);
+  removeAllInputs();
+  removeFromList();
+  graph_->freeNode(this);
+}
+
+/************* All nodes not required to be defined before Graph **************/
+
+inline graph_node_list_iterator Node::iterator() {
+  return graph_node_list_iterator(this, 0);
+}
+inline graph_node_list_iterator Node::reverseIterator() {
+  return iterator().reverse();
+}
+inline const_graph_node_list_iterator Node::iterator() const {
+  return const_graph_node_list_iterator(this, 0);
+}
+inline const_graph_node_list_iterator Node::reverseIterator() const {
+  return iterator().reverse();
+}
+
+// Returns a list about which nodes are using this value,
+// nodes in subgraph are also included.
+// This method is usually used to check whether it is
+// safe to delete a Value.
+inline use_list Value::uses() const {
+  use_list all_uses = uses_in_current_graph_;
+  owningGraph()->forEachNode([this, &all_uses](const Node* node) {
+    if (node->owningGraph() == this->owningGraph()) {
+      // skip non-subgraph
+      return;
+    }
+    if (node->kind() == kCaptured) {
+      const Value* output = node->outputs()[0];
+      if (output->uniqueName() == this->uniqueName()) {
+        const auto output_uses = output->uses();
+        all_uses.insert(all_uses.end(), output_uses.begin(), output_uses.end());
+      }
+    }
+  });
+  return all_uses;
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/ir_pb_converter.cc b/onnx/common/ir_pb_converter.cc
new file mode 100644
index 0000000..2189689
--- /dev/null
+++ b/onnx/common/ir_pb_converter.cc
@@ -0,0 +1,771 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+#include "onnx/common/ir_pb_converter.h"
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace ONNX_NAMESPACE {
+
+// Part 1: convert ONNX Protobuf to IR
+static std::unique_ptr<Graph> graphProtoToGraph(const GraphProto& gp, bool nested, int64_t ir_version = IR_VERSION);
+
+static Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
+  Tensor ret;
+
+  ret.sizes().reserve(tp.dims_size());
+  for (int i = 0; i < tp.dims_size(); i++) {
+    ret.sizes().push_back(tp.dims(i));
+  }
+
+  ret.elem_type() = tp.data_type();
+  switch (tp.data_type()) {
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT:
+    case ONNX_NAMESPACE::TensorProto_DataType_COMPLEX64: {
+      ret.floats().reserve(tp.float_data_size());
+      for (int i = 0; i < tp.float_data_size(); i++) {
+        ret.floats().push_back(tp.float_data(i));
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_BOOL:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT2:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT2:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT4:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT4:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT8:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT32:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT8:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FN:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E8M0:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT4E2M1: {
+      ret.int32s().reserve(tp.int32_data_size());
+      for (int i = 0; i < tp.int32_data_size(); i++) {
+        ret.int32s().push_back(tp.int32_data(i));
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_INT64: {
+      ret.int64s().reserve(tp.int64_data_size());
+      for (int i = 0; i < tp.int64_data_size(); i++) {
+        ret.int64s().push_back(tp.int64_data(i));
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT32:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT64: {
+      ret.uint64s().reserve(tp.uint64_data_size());
+      for (int i = 0; i < tp.uint64_data_size(); i++) {
+        ret.uint64s().push_back(tp.uint64_data(i));
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_DOUBLE:
+    case ONNX_NAMESPACE::TensorProto_DataType_COMPLEX128: {
+      ret.doubles().reserve(tp.double_data_size());
+      for (int i = 0; i < tp.double_data_size(); i++) {
+        ret.doubles().push_back(tp.double_data(i));
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_STRING: {
+      ret.strings().reserve(tp.string_data_size());
+      for (int i = 0; i < tp.string_data_size(); i++) {
+        ret.strings().push_back(tp.string_data(i));
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED:
+      [[fallthrough]];
+    default:
+      fail_convert("Unknown tensor data type");
+  }
+
+  // The only way to know if we should be using raw_data or
+  // <type>_data is to look at which of them is size zero.
+  if (tp.has_raw_data()) {
+    ret.set_raw_data(tp.raw_data());
+  }
+
+  if (tp.has_name()) {
+    ret.setName(tp.name());
+  }
+  if (tp.has_segment()) {
+    ret.set_segment_begin_and_end(tp.segment().begin(), tp.segment().end());
+  }
+
+  for (int i = 0; i < tp.external_data_size(); i++) {
+    ret.external_data().emplace_back(tp.external_data(i).key(), tp.external_data(i).value());
+  }
+  if (tp.has_data_location()) {
+    ret.data_location() = tp.data_location();
+  }
+  return ret;
+}
+
+static void convertAttribute(const ONNX_NAMESPACE::AttributeProto& ap, Node& n, const int64_t ir_version = IR_VERSION) {
+  Symbol sym = Symbol(ap.name());
+  switch (ap.type()) {
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_FLOAT:
+      n.f_(sym, ap.f());
+      break;
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_FLOATS: {
+      std::vector<double> floats;
+      floats.reserve(ap.floats_size());
+      for (int i = 0; i < ap.floats_size(); i++) {
+        floats.push_back(ap.floats(i));
+      }
+      n.fs_(sym, std::move(floats));
+      break;
+    }
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_INT:
+      n.i_(sym, ap.i());
+      break;
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_INTS: {
+      std::vector<int64_t> ints;
+      ints.reserve(ap.ints_size());
+      for (int i = 0; i < ap.ints_size(); i++) {
+        ints.push_back(ap.ints(i));
+      }
+      n.is_(sym, std::move(ints));
+      break;
+    }
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_STRING:
+      n.s_(sym, ap.s());
+      break;
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_STRINGS: {
+      std::vector<std::string> strings;
+      strings.reserve(ap.strings_size());
+      for (int i = 0; i < ap.strings_size(); i++) {
+        strings.push_back(ap.strings(i));
+      }
+      n.ss_(sym, std::move(strings));
+      break;
+    }
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_TENSOR:
+      n.t_(sym, tensorProtoToTensor(ap.t()));
+      break;
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_TENSORS: {
+      std::vector<Tensor> tensors;
+      tensors.reserve(ap.tensors_size());
+      for (int i = 0; i < ap.tensors_size(); i++) {
+        tensors.emplace_back(tensorProtoToTensor(ap.tensors(i)));
+      }
+      n.ts_(sym, std::move(tensors));
+      break;
+    }
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_TYPE_PROTO:
+      n.tp_(sym, ap.tp());
+      break;
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_TYPE_PROTOS: {
+      std::vector<TypeProto> types;
+      types.reserve(ap.type_protos_size());
+      for (int i = 0; i < ap.type_protos_size(); i++) {
+        types.push_back(ap.type_protos(i));
+      }
+      n.tps_(sym, std::move(types));
+      break;
+    }
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_GRAPH:
+      n.g_(sym, graphProtoToGraph(ap.g(), true, ir_version));
+      break;
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_GRAPHS: {
+      std::vector<std::shared_ptr<Graph>> graphs;
+      graphs.reserve(ap.graphs_size());
+      for (int i = 0; i < ap.graphs_size(); i++) {
+        graphs.push_back(graphProtoToGraph(ap.graphs(i), true, ir_version));
+      }
+      n.gs_(sym, std::move(graphs));
+      break;
+    }
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_SPARSE_TENSOR:
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_SPARSE_TENSORS:
+      fail_convert("Sparse tensors not supported.");
+      break;
+    case ONNX_NAMESPACE::AttributeProto_AttributeType_UNDEFINED:
+      fail_convert("Unknown tensor data type");
+      break;
+  }
+}
+
+static void convertAttributes(const ONNX_NAMESPACE::NodeProto& np, Node& n, const int64_t ir_version = IR_VERSION) {
+  for (int i = 0; i < np.attribute_size(); i++) {
+    convertAttribute(np.attribute(i), n, ir_version);
+  }
+}
+
+static std::vector<Dimension> tensorShapeProtoToDimensions(const ONNX_NAMESPACE::TensorShapeProto& tsp) {
+  std::vector<Dimension> dims;
+  dims.reserve(tsp.dim_size());
+  for (int i = 0; i < tsp.dim_size(); i++) {
+    if (tsp.dim(i).has_dim_value()) {
+      dims.emplace_back(tsp.dim(i).dim_value());
+    } else if (tsp.dim(i).has_dim_param()) {
+      dims.emplace_back(tsp.dim(i).dim_param());
+    } else {
+      // a dimension that has neither dim_value nor dim_param set
+      // represents an unknown dimension unrelated to other unknown dimensions.
+      dims.emplace_back();
+    }
+  }
+  return dims;
+}
+
+static Value* createDummyValue(
+    const std::unique_ptr<Graph>& g,
+    const std::string& name,
+    std::unordered_map<std::string, Value*>& value_by_name_of) {
+  auto* undef = g->create(kCaptured, 1);
+  g->appendNode(undef);
+  Value* v = undef->outputs()[0];
+  v->setUniqueName(name);
+  value_by_name_of[name] = v;
+  return v;
+}
+
+std::unique_ptr<Graph> graphProtoToGraph(const ONNX_NAMESPACE::GraphProto& gp, bool nested, const int64_t ir_version) {
+  auto g = std::make_unique<Graph>();
+
+  if (gp.has_name()) {
+    g->setName(gp.name());
+  }
+  if (gp.has_doc_string()) {
+    g->setDocString(gp.doc_string());
+  }
+
+  // Values are created (as in `new Value(..)`) by the Node that
+  // outputs them. Therefore we initialize the Nodes and Values in
+  // several stages.
+  //
+  // 1) add all input (to the graph) Values, owned by the sentinel Param node
+  // 2) add all Nodes and their output Values, but don't initialize inputs
+  // 3) initialize inputs of all Nodes
+  // 4) initialize inputs of the Return sentinel node
+  // 5) fill in type info for graph outputs, and register them as outputs
+  // 6) fill in type info for Values from the value_info list in the graph
+
+  // In ONNX proto land, Values are just strings. We are going to make
+  // objects out of them, and equal strings must be mapped to the same
+  // Value object.
+  std::unordered_map<std::string, Value*> value_by_name_of;
+
+  // We initialize Node inputs in a separate pass from the Nodes
+  // themselves. To do so, we need to have access to the names of the
+  // inputs.
+  std::unordered_map<Node*, std::vector<std::string>> inputs_by_node;
+
+  {
+    // ONNX represents optional arguments in two ways
+    //  - they are simply not provided
+    //  - OR the empty string is passed as the input name
+    // This is to handle that second case, which needs a dummy node to
+    // be representable in the graph IR.
+    auto* n = g->create(kUndefined, 1);
+    g->appendNode(n);
+    n->outputs()[0]->setUniqueName("");
+    value_by_name_of[""] = n->outputs()[0];
+  }
+
+  for (int i = 0; i < gp.input_size(); i++) {
+    const auto& vip = gp.input(i);
+    auto* v = g->addInput();
+    const auto& tensor_type = vip.type().tensor_type();
+    if (tensor_type.has_elem_type()) {
+      v->setElemType(tensor_type.elem_type());
+    }
+    if (tensor_type.has_shape()) {
+      v->setSizes(tensorShapeProtoToDimensions(tensor_type.shape()));
+    }
+    if (!vip.type().has_tensor_type()) {
+      v->type() = std::make_unique<TypeProto>(vip.type());
+    }
+    v->setUniqueName(vip.name());
+    value_by_name_of[vip.name()] = v;
+  }
+
+  // initializers should be added before all nodes,
+  // otherwise getNextUnique() may conflicts with an existing initializer name.
+  for (int i = 0; i < gp.initializer_size(); ++i) {
+    auto init = tensorProtoToTensor(gp.initializer(i));
+    // If ir_version >= 4, initializer does not have to be included in input
+    // Create a Value from initializer by addInitializerNode if name does not exist in input
+    // and save it into value_by_name_of for later use (node input)
+    if (ir_version >= 4 && value_by_name_of.count(init.name()) == 0) {
+      value_by_name_of[init.name()] = g->addInitializerAndCreateValue(init);
+    } else {
+      // If ir_version < 4 or the initializer exists in input
+      // Simply add initializer without creating new value
+      // which means it will prioritize input value over initializer value if both exist
+      g->addInitializer(init);
+    }
+  }
+
+  for (int i = 0; i < gp.node_size(); i++) {
+    const auto& np = gp.node(i);
+    auto* n = g->create(Symbol(np.op_type()), /* num_outputs = */ np.output_size());
+    g->appendNode(n);
+    for (int j = 0; j < np.output_size(); j++) {
+      auto* out = n->outputs()[j];
+      // we don't know the real type here, so that's done in a later pass
+      out->setElemType(ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED);
+      out->setUniqueName(np.output(j));
+      value_by_name_of[np.output(j)] = out;
+    }
+    convertAttributes(np, *n, ir_version);
+    std::vector<std::string> inputs;
+    inputs.reserve(np.input_size());
+    for (int j = 0; j < np.input_size(); j++) {
+      inputs.push_back(np.input(j));
+    }
+    inputs_by_node[n] = inputs;
+    if (np.has_doc_string()) {
+      n->setDocString(np.doc_string());
+    }
+    if (np.has_name()) {
+      n->setName(np.name());
+    }
+    if (np.has_domain()) {
+      n->setDomain(np.domain());
+    }
+    if (np.has_overload()) {
+      n->setOverload(np.overload());
+    }
+  }
+
+  for (auto* n : g->nodes()) {
+    auto search = inputs_by_node.find(n);
+    if (search == inputs_by_node.end()) {
+      continue;
+    }
+    for (const auto& input : search->second) {
+      if (!value_by_name_of.count(input) && nested) {
+        // Undefined reference to an input in a nested block. This may be a
+        // captured value. Create a dummy node that we ignore later.
+        createDummyValue(g, input, value_by_name_of);
+      }
+
+      if (!value_by_name_of.count(input)) {
+        fail_convert("Input ", input, " is undefined!");
+      }
+      n->addInput(value_by_name_of.at(input));
+    }
+  }
+
+  for (int i = 0; i < gp.output_size(); i++) {
+    const auto& output = gp.output(i);
+    const std::string& output_name = output.name();
+    auto it = value_by_name_of.find(output_name);
+    Value* output_value = nullptr;
+    if (it != value_by_name_of.end()) {
+      output_value = it->second;
+    } else if (nested) {
+      // Undefined reference: a value captured from an enclosing scope.
+      output_value = createDummyValue(g, output_name, value_by_name_of);
+    } else {
+      fail_convert("Output ", output_name, " is undefined!");
+    }
+    const auto& output_tensor_type = output.type().tensor_type();
+    if (output_tensor_type.has_elem_type()) {
+      output_value->setElemType(output_tensor_type.elem_type());
+    }
+    if (output_tensor_type.has_shape()) {
+      output_value->setSizes(tensorShapeProtoToDimensions(output_tensor_type.shape()));
+    }
+    if (!output.type().has_tensor_type()) {
+      output_value->type() = std::make_unique<TypeProto>(output.type());
+    }
+    g->registerOutput(output_value);
+  }
+
+  for (int i = 0; i < gp.value_info_size(); i++) {
+    const auto& tensor_type = gp.value_info(i).type().tensor_type();
+    auto it = value_by_name_of.find(gp.value_info(i).name());
+    if (it == value_by_name_of.end()) {
+      // Ideally the model should not have a value_info whose name does not exist in the graph (unused); simply skip it
+      continue;
+    }
+    Value* v = it->second;
+    if (tensor_type.has_elem_type()) {
+      v->setElemType(tensor_type.elem_type());
+    }
+    if (tensor_type.has_shape()) {
+      v->setSizes(tensorShapeProtoToDimensions(tensor_type.shape()));
+    }
+    if (!gp.value_info(i).type().has_tensor_type()) {
+      v->type() = std::make_unique<TypeProto>(gp.value_info(i).type());
+    }
+  }
+
+  return g;
+}
+
+std::unique_ptr<Graph> ImportModelProto(const ModelProto& mp) {
+  if (!mp.has_ir_version()) {
+    return nullptr;
+  }
+  if (mp.ir_version() <= 1) {
+    // ir_version=1 is not supported and ir_version=0 is illegal
+    return nullptr;
+  }
+
+  std::unique_ptr<Graph> g(graphProtoToGraph(mp.graph(), false, mp.ir_version()));
+  for (int i = 0; i < mp.opset_import_size(); i++) {
+    OpSetID new_opset_version(mp.opset_import(i).domain(), mp.opset_import(i).version());
+    g->forSelfAndEachSubGraph(
+        [&new_opset_version](Graph* graph) { graph->opset_versions_mutable().emplace_back(new_opset_version); });
+  }
+  return g;
+}
+
+// Part 2: convert IR to ONNX Protobuf
+static std::string value_name(const Value& n) {
+  return n.uniqueName();
+}
+
+static void encodeGraph(GraphProto& p_g, const std::shared_ptr<Graph>& g);
+
+static void encodeTensor(ONNX_NAMESPACE::TensorProto& p, const Tensor& tensor) {
+  if (tensor.hasName()) {
+    p.set_name(tensor.name());
+  }
+  if (tensor.is_segment()) {
+    ONNX_NAMESPACE::TensorProto_Segment segment;
+    segment.set_begin(tensor.segment_begin());
+    segment.set_end(tensor.segment_end());
+    p.mutable_segment()->CopyFrom(segment);
+  }
+  for (auto d : tensor.sizes()) {
+    p.add_dims(d);
+  }
+  p.set_data_type(tensor.elem_type());
+  switch (tensor.elem_type()) {
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT:
+    case ONNX_NAMESPACE::TensorProto_DataType_COMPLEX64: {
+      for (float x : tensor.floats()) {
+        p.add_float_data(x);
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FN:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E4M3FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT8E5M2FNUZ:
+    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT4E2M1:
+    case ONNX_NAMESPACE::TensorProto_DataType_BOOL:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT2:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT2:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT4:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT4:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT8:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT16:
+    case ONNX_NAMESPACE::TensorProto_DataType_INT32:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT8:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT16: {
+      for (int32_t x : tensor.int32s()) {
+        p.add_int32_data(x);
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_INT64: {
+      for (int64_t x : tensor.int64s()) {
+        p.add_int64_data(x);
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT32:
+    case ONNX_NAMESPACE::TensorProto_DataType_UINT64: {
+      for (uint64_t x : tensor.uint64s()) {
+        p.add_uint64_data(x);
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_DOUBLE:
+    case ONNX_NAMESPACE::TensorProto_DataType_COMPLEX128: {
+      for (double x : tensor.doubles()) {
+        p.add_double_data(x);
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_STRING: {
+      for (const std::string& x : tensor.strings()) {
+        p.add_string_data(x);
+      }
+      break;
+    }
+    case ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED:
+      [[fallthrough]];
+    default:
+      fail_convert("Unknown tensor data type");
+  }
+  if (tensor.is_raw_data()) {
+    p.set_raw_data(tensor.raw());
+  }
+  if (!tensor.external_data().empty()) {
+    for (const auto& [key, value] : tensor.external_data()) {
+      auto* external_data = p.add_external_data();
+      external_data->set_key(key);
+      external_data->set_value(value);
+    }
+  }
+  if (tensor.has_data_location()) {
+    p.set_data_location(tensor.data_location());
+  }
+}
+
+static void addAttribute(ONNX_NAMESPACE::NodeProto& n_p, const Node& n, Symbol name) {
+  auto* attr = n_p.add_attribute();
+  attr->set_name(name.toString());
+  switch (n.kindOf(name)) {
+    case AttributeKind::f: {
+      attr->set_f(static_cast<float>(n.f(name)));
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_FLOAT);
+    } break;
+    case AttributeKind::fs: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_FLOATS);
+      for (const auto& v : n.fs(name))
+        attr->add_floats(static_cast<float>(v));
+    } break;
+    case AttributeKind::i: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_INT);
+      attr->set_i(n.i(name));
+    } break;
+    case AttributeKind::is: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_INTS);
+      for (const auto& v : n.is(name))
+        attr->add_ints(v);
+    } break;
+    case AttributeKind::s: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_STRING);
+      attr->set_s(n.s(name));
+    } break;
+    case AttributeKind::ss: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_STRINGS);
+      for (const auto& v : n.ss(name))
+        attr->add_strings(v);
+    } break;
+    case AttributeKind::t: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_TENSOR);
+      auto* t = attr->mutable_t();
+      encodeTensor(*t, n.t(name));
+    } break;
+    case AttributeKind::ts: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_TENSORS);
+      for (const auto& v : n.ts(name)) {
+        auto* t = attr->add_tensors();
+        encodeTensor(*t, v);
+      }
+    } break;
+    case AttributeKind::g: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_GRAPH);
+      auto* g = attr->mutable_g();
+      encodeGraph(*g, n.g(name));
+    } break;
+    case AttributeKind::gs: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_GRAPHS);
+      for (const auto& v : n.gs(name)) {
+        auto* g = attr->add_graphs();
+        encodeGraph(*g, v);
+      }
+    } break;
+    case AttributeKind::tp: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_TYPE_PROTO);
+      auto* tp = attr->mutable_tp();
+      tp->CopyFrom(n.tp(name));
+    } break;
+    case AttributeKind::tps: {
+      attr->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType_TYPE_PROTOS);
+      for (const auto& v : n.tps(name)) {
+        auto* tp = attr->add_type_protos();
+        tp->CopyFrom(v);
+      }
+    } break;
+  }
+}
+
+static void encodeTypeProtoTensorType(ONNX_NAMESPACE::TypeProto_Tensor& tensor_type, const Value& n) {
+  if (n.elemType() != 0) {
+    tensor_type.set_elem_type(n.elemType());
+  }
+  if (n.has_sizes()) {
+    ONNX_NAMESPACE::TensorShapeProto* shape = tensor_type.mutable_shape();
+    for (const Dimension& d : n.sizes()) {
+      auto* dim = shape->add_dim();
+      if (!d.is_unknown) {
+        if (d.is_int) {
+          dim->set_dim_value(d.dim);
+        } else {
+          dim->set_dim_param(d.param);
+        }
+      }
+    }
+  }
+}
+
+static void encodeValueInfo(ONNX_NAMESPACE::ValueInfoProto& v, Value& n) {
+  v.set_name(value_name(n));
+  if (n.elemType() != 0 || n.has_sizes()) {
+    ONNX_NAMESPACE::TypeProto* t = v.mutable_type();
+    ONNX_NAMESPACE::TypeProto_Tensor* tensor_type = t->mutable_tensor_type();
+    encodeTypeProtoTensorType(*tensor_type, n);
+  } else if (n.type()) {
+    v.mutable_type()->CopyFrom(*n.type());
+  }
+}
+
+static void encodeGraph(GraphProto& p_g, const std::shared_ptr<Graph>& g) {
+  if (g->has_name()) {
+    p_g.set_name(g->name());
+  }
+
+  if (g->has_doc_string()) {
+    p_g.set_doc_string(g->docString());
+  }
+
+  for (auto* input : g->inputs()) {
+    ONNX_NAMESPACE::ValueInfoProto* v = p_g.add_input();
+    encodeValueInfo(*v, *input);
+  }
+  for (auto* output : g->outputs()) {
+    ONNX_NAMESPACE::ValueInfoProto* v = p_g.add_output();
+    encodeValueInfo(*v, *output);
+  }
+
+  std::unordered_set<Value*> graph_outputs(g->outputs().begin(), g->outputs().end());
+
+  for (auto* node : g->nodes()) {
+    if (node->kind() == kUndefined || node->kind() == kCaptured) {
+      // Undefined nodes are used to represent optional inputs that are not
+      // provided.
+      continue;
+    }
+    auto* p_n = p_g.add_node();
+    for (auto* input : node->inputs()) {
+      if (input->node()->kind() == kUndefined) {
+        p_n->add_input("");
+      } else {
+        p_n->add_input(value_name(*input));
+      }
+    }
+    for (auto* output : node->outputs()) {
+      p_n->add_output(value_name(*output));
+      // only save it if
+      //  - it has actual information worth saving
+      //  - it's not already saved in the graph outputs value info
+      if (graph_outputs.find(output) != graph_outputs.end()) {
+        continue;
+      }
+      if (output->elemType() == TensorProto_DataType_UNDEFINED && output->sizes().empty()) {
+        continue;
+      }
+      ValueInfoProto* v = p_g.add_value_info();
+      encodeValueInfo(*v, *output);
+    }
+    p_n->set_op_type(node->kind().toString());
+    for (auto attr_name : node->attributeNames()) {
+      addAttribute(*p_n, *node, attr_name);
+    }
+    if (node->has_doc_string()) {
+      p_n->set_doc_string(node->docString());
+    }
+    if (node->has_name()) {
+      p_n->set_name(node->name());
+    }
+    if (node->has_domain()) {
+      p_n->set_domain(node->domain());
+    }
+    if (node->has_overload()) {
+      p_n->set_overload(node->overload());
+    }
+  }
+
+  auto num_initializers = g->initializers().size();
+  for (unsigned int i = 0; i < num_initializers; i++) {
+    auto* p = p_g.add_initializer();
+    p->set_name(g->initializer_names()[i]);
+    encodeTensor(*p, g->initializers()[i]);
+  }
+}
+
+void ExportModelProto(ModelProto* p_m, const std::shared_ptr<Graph>& g) {
+  GraphProto* p_g = p_m->mutable_graph();
+  encodeGraph(*p_g, g);
+  // Add new opset_versions
+  p_m->clear_opset_import();
+  for (const OpSetID& opset : g->opset_versions_mutable()) {
+    OperatorSetIdProto* opset_version_output = p_m->add_opset_import();
+    opset_version_output->set_domain(opset.domain());
+    opset_version_output->set_version(opset.version());
+  }
+}
+
+ModelProto PrepareOutput(const ModelProto& mp_in) {
+  ModelProto mp_out{};
+
+  if (mp_in.has_ir_version()) {
+    mp_out.set_ir_version(mp_in.ir_version());
+  }
+  if (mp_in.has_producer_name()) {
+    mp_out.set_producer_name(mp_in.producer_name());
+  }
+  if (mp_in.has_producer_version()) {
+    mp_out.set_producer_version(mp_in.producer_version());
+  }
+  if (mp_in.has_domain()) {
+    mp_out.set_domain(mp_in.domain());
+  }
+  if (mp_in.has_model_version()) {
+    mp_out.set_model_version(mp_in.model_version());
+  }
+  if (mp_in.has_doc_string()) {
+    mp_out.set_doc_string(mp_in.doc_string());
+  }
+  for (int i = 0; i < mp_in.opset_import_size(); i++) {
+    const auto& oi_in = mp_in.opset_import(i);
+    auto* oi_out = mp_out.add_opset_import();
+    if (oi_in.has_domain()) {
+      oi_out->set_domain(oi_in.domain());
+    }
+    if (oi_in.has_version()) {
+      oi_out->set_version(oi_in.version());
+    }
+  }
+  for (int i = 0; i < mp_in.metadata_props_size(); i++) {
+    const auto& pp_in = mp_in.metadata_props(i);
+    auto* pp_out = mp_out.add_metadata_props();
+    if (pp_in.has_key()) {
+      pp_out->set_key(pp_in.key());
+    }
+    if (pp_in.has_value()) {
+      pp_out->set_value(pp_in.value());
+    }
+  }
+
+  return mp_out;
+}
+
+void assertNonNull(const std::shared_ptr<Graph>& g) {
+  ONNX_ASSERTM(
+      g.get() != nullptr,
+      "Warning: onnx version converter is unable to parse input model. "
+      "(The IR version of the ONNX model may be too old.)")
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/ir_pb_converter.h b/onnx/common/ir_pb_converter.h
new file mode 100644
index 0000000..177d445
--- /dev/null
+++ b/onnx/common/ir_pb_converter.h
@@ -0,0 +1,47 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+#pragma once
+#include <memory>
+#include <string>
+
+#include "onnx/common/common.h"
+#include "onnx/common/ir.h"
+
+namespace ONNX_NAMESPACE {
+
+class ConvertError final : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+
+  explicit ConvertError(const std::string& message) : std::runtime_error(message) {}
+
+  const char* what() const noexcept override {
+    if (!expanded_message_.empty()) {
+      return expanded_message_.c_str();
+    }
+    return std::runtime_error::what();
+  }
+
+  void AppendContext(const std::string& context) {
+    expanded_message_ = MakeString(std::runtime_error::what(), "\n\n==> Context: ", context);
+  }
+
+ private:
+  std::string expanded_message_;
+};
+
+#define fail_convert(...) ONNX_THROW_EX(ConvertError(MakeString(__VA_ARGS__)))
+
+void ExportModelProto(ModelProto* p_m, const std::shared_ptr<Graph>& g);
+
+std::unique_ptr<Graph> ImportModelProto(const ModelProto& mp);
+
+ONNX_API ModelProto PrepareOutput(const ModelProto& mp_in);
+
+void assertNonNull(const std::shared_ptr<Graph>& g);
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/model_helpers.cc b/onnx/common/model_helpers.cc
new file mode 100644
index 0000000..ad7799c
--- /dev/null
+++ b/onnx/common/model_helpers.cc
@@ -0,0 +1,37 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/common/model_helpers.h"
+
+#include <string>
+#include <vector>
+
+namespace ONNX_NAMESPACE {
+
+Common::Status BuildNode(
+    const std::string& name,
+    const std::string& domain,
+    const std::string& doc_string,
+    const std::string& op_type,
+    std::vector<std::string> const& inputs,
+    std::vector<std::string> const& outputs,
+    NodeProto* node) {
+  if (node == nullptr) {
+    return Common::Status(
+        Common::StatusCategory::CHECKER, Common::StatusCode::INVALID_ARGUMENT, "node_proto should not be nullptr.");
+  }
+  node->set_name(name);
+  node->set_domain(domain);
+  node->set_doc_string(doc_string);
+  node->set_op_type(op_type);
+  for (const auto& input : inputs) {
+    node->add_input(input);
+  }
+  for (const auto& output : outputs) {
+    node->add_output(output);
+  }
+
+  return Common::Status::OK();
+}
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/model_helpers.h b/onnx/common/model_helpers.h
new file mode 100644
index 0000000..f07dc5c
--- /dev/null
+++ b/onnx/common/model_helpers.h
@@ -0,0 +1,26 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "onnx/common/status.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+
+// Helper function for register nodes in
+// a FunctionProto. Attributes need to be
+// registered separately.
+Common::Status BuildNode(
+    const std::string& name,
+    const std::string& domain,
+    const std::string& doc_string,
+    const std::string& op_type,
+    std::vector<std::string> const& inputs,
+    std::vector<std::string> const& outputs,
+    /*OUT*/ NodeProto* node);
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/path.h b/onnx/common/path.h
new file mode 100644
index 0000000..861184b
--- /dev/null
+++ b/onnx/common/path.h
@@ -0,0 +1,88 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <filesystem>
+#include <string>
+
+#ifdef _WIN32
+// windows.h has preproc definitions for min and max, which prevents from using std::min and std::max.
+//  defining NOMINMAX disables the preproc macro.
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+
+#include "onnx/checker.h"
+#endif
+
+namespace ONNX_NAMESPACE {
+
+#ifdef _WIN32
+inline std::wstring utf8str_to_wstring(const std::string& utf8str) {
+  if (utf8str.empty()) {
+    return std::wstring();
+  }
+  int len = static_cast<int>(utf8str.size());
+  auto size_required =
+      MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS | MB_PRECOMPOSED, utf8str.data(), len, nullptr, 0);
+  if (size_required == 0) {
+    auto last_error = GetLastError();
+    fail_check("MultiByteToWideChar in utf8str_to_wstring returned error:", last_error);
+  }
+  std::wstring ws_str(size_required, 0);
+  auto converted_size = MultiByteToWideChar(
+      CP_UTF8, MB_ERR_INVALID_CHARS | MB_PRECOMPOSED, utf8str.data(), len, &ws_str[0], size_required);
+  if (converted_size == 0) {
+    auto last_error = GetLastError();
+    fail_check("MultiByteToWideChar in utf8str_to_wstring returned error:", last_error);
+  }
+  return ws_str;
+}
+
+inline std::string wstring_to_utf8str(const std::wstring& ws_str) {
+  if (ws_str.empty()) {
+    return std::string();
+  }
+  int len = static_cast<int>(ws_str.size());
+  auto size_required =
+      WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ws_str.data(), len, nullptr, 0, nullptr, nullptr);
+  if (size_required == 0) {
+    auto last_error = GetLastError();
+    fail_check("WideCharToMultiByte in wstring_to_utf8str returned error:", last_error);
+  }
+  std::string utf8str(size_required, 0);
+  auto converted_size = WideCharToMultiByte(
+      CP_UTF8, WC_ERR_INVALID_CHARS, ws_str.data(), len, &utf8str[0], size_required, nullptr, nullptr);
+  if (converted_size == 0) {
+    auto last_error = GetLastError();
+    fail_check("WideCharToMultiByte in wstring_to_utf8str returned error:", last_error);
+  }
+  return utf8str;
+}
+
+#endif
+
+// Construct a std::filesystem::path from a UTF-8 string.
+// On Windows, converts via wide-char so the result is independent of the
+// active code page.  On POSIX, UTF-8 is the native encoding.
+inline std::filesystem::path utf8_to_path(const std::string& utf8) {
+#ifdef _WIN32
+  return std::filesystem::path(utf8str_to_wstring(utf8));
+#else
+  return std::filesystem::path(utf8);
+#endif
+}
+
+// Return the UTF-8 representation of a filesystem path.
+inline std::string path_to_utf8(const std::filesystem::path& p) {
+#ifdef _WIN32
+  return wstring_to_utf8str(p.wstring());
+#else
+  return p.string();
+#endif
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/platform_helpers.h b/onnx/common/platform_helpers.h
new file mode 100644
index 0000000..c7bc32a
--- /dev/null
+++ b/onnx/common/platform_helpers.h
@@ -0,0 +1,17 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstdint>
+
+namespace ONNX_NAMESPACE {
+
+// Determine if the processor is little endian or not
+inline bool is_processor_little_endian() {
+  constexpr std::int32_t value = 1;
+  return reinterpret_cast<const std::uint8_t*>(&value)[0] == 1;
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/proto_util.h b/onnx/common/proto_util.h
new file mode 100644
index 0000000..598d2d8
--- /dev/null
+++ b/onnx/common/proto_util.h
@@ -0,0 +1,41 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+#include "onnx/common/constants.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+
+// ONNX (model-local) function identifiers are a tuple (domain, op, overload).
+// The pair (domain, op) represents a specification of a function, while
+// overload is used to disambiguate between multiple (specialized) implementations of
+// the same specification. Overload is optional and can be empty.
+// Multiple overloads may be used to distinguish implementations specialized
+// for a specific type or rank of input tensors or for specific attribute values.
+
+// A single string representation of (domain, op)
+using FunctionSpecId = std::string;
+
+// A single string representation of (domain, op, overload)
+using FunctionImplId = std::string;
+
+inline FunctionImplId GetFunctionImplId(const std::string& domain, const std::string& op, const std::string& overload) {
+  if (overload.empty())
+    return NormalizeDomain(domain) + "::" + op;
+  return NormalizeDomain(domain) + "::" + op + "::" + overload;
+}
+
+inline FunctionImplId GetFunctionImplId(const FunctionProto& function) {
+  return GetFunctionImplId(function.domain(), function.name(), function.overload());
+}
+
+inline FunctionImplId GetCalleeId(const NodeProto& node) {
+  return GetFunctionImplId(node.domain(), node.op_type(), node.overload());
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/safe_math.h b/onnx/common/safe_math.h
new file mode 100644
index 0000000..32219e2
--- /dev/null
+++ b/onnx/common/safe_math.h
@@ -0,0 +1,69 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <limits>
+
+namespace ONNX_NAMESPACE {
+
+// Returns true on overflow. Uses __builtin on GCC/Clang, manual check on MSVC.
+// Precondition: a and b must be non-negative. The MSVC fallback only handles
+// non-negative inputs correctly; passing a negative value can silently overflow.
+// safe_dim_product enforces this by checking each dim before calling, and the
+// accumulated result stays non-negative because we abort on overflow.
+inline bool checked_mul_overflow(int64_t a, int64_t b, int64_t* result) {
+#if defined(__GNUC__) || defined(__clang__)
+  return __builtin_mul_overflow(a, b, result);
+#else
+  assert(a >= 0 && b >= 0 && "checked_mul_overflow requires non-negative inputs on MSVC");
+  if (a > 0 && b > std::numeric_limits<int64_t>::max() / a) {
+    return true;
+  }
+  *result = a * b;
+  return false;
+#endif
+}
+
+// Safe product of dims over an iterator range. Calls on_error(const char*) on
+// negative dim or overflow. on_error must not return (i.e. must throw or abort).
+template <typename Iter, typename ErrorHandler>
+[[nodiscard]] inline int64_t safe_dim_product(Iter begin, Iter end, ErrorHandler on_error) {
+  int64_t result = 1;
+  for (auto it = begin; it != end; ++it) {
+    auto dim = static_cast<int64_t>(*it);
+    if (dim < 0) {
+      on_error("Negative dimension value");
+      return result; // unreachable if on_error throws; guards against misuse
+    }
+    if (checked_mul_overflow(result, dim, &result)) {
+      on_error("Tensor dimension product overflow");
+      return result;
+    }
+  }
+  return result;
+}
+
+// Container overload — delegates to the iterator-pair version.
+template <typename DimsContainer, typename ErrorHandler>
+[[nodiscard]] inline int64_t safe_dim_product(const DimsContainer& dims, ErrorHandler on_error) {
+  return safe_dim_product(std::begin(dims), std::end(dims), on_error);
+}
+
+// Safe cast from int64_t to size_t. Calls on_error if the value exceeds
+// size_t range (relevant for 32-bit platforms where size_t is 32 bits).
+// value must be non-negative (callers ensure this via prior overflow checks).
+template <typename ErrorHandler>
+[[nodiscard]] inline size_t safe_cast_to_size(int64_t value, ErrorHandler on_error) {
+  if (static_cast<uint64_t>(value) > std::numeric_limits<size_t>::max()) {
+    on_error("Value too large for this platform");
+  }
+  return static_cast<size_t>(value);
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/scoped_resource.h b/onnx/common/scoped_resource.h
new file mode 100644
index 0000000..525e4d6
--- /dev/null
+++ b/onnx/common/scoped_resource.h
@@ -0,0 +1,86 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+
+#ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <io.h>
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+namespace ONNX_NAMESPACE {
+
+// Generic RAII guard for resources identified by a sentinel "invalid" value and
+// a free-function closer.  Non-copyable, non-movable.
+//
+// Usage:
+//   using ScopedFd = ScopedResource<-1, close_fd>;
+//   ScopedFd guard(fd);          // destructor calls close_fd(fd)
+//   int raw = guard.release();   // relinquish ownership
+template <auto Invalid, void (*Close)(decltype(Invalid))>
+class ScopedResource {
+  using T = decltype(Invalid);
+  T val_;
+
+ public:
+  explicit ScopedResource(T v) : val_(v) {}
+  ~ScopedResource() {
+    if (val_ != Invalid) {
+      Close(val_);
+    }
+  }
+  T get() const {
+    return val_;
+  }
+  T release() {
+    T tmp = val_;
+    val_ = Invalid;
+    return tmp;
+  }
+  ScopedResource(const ScopedResource&) = delete;
+  ScopedResource& operator=(const ScopedResource&) = delete;
+};
+
+// Platform-specific type aliases.
+
+#ifdef _WIN32
+inline void close_handle(HANDLE h) {
+  CloseHandle(h);
+}
+using ScopedHandle = ScopedResource<INVALID_HANDLE_VALUE, close_handle>;
+#endif
+
+inline void close_fd(int fd) {
+#ifdef _WIN32
+  _close(fd);
+#else
+  close(fd);
+#endif
+}
+using ScopedFd = ScopedResource<-1, close_fd>;
+
+// RAII guard that invokes a callable on destruction (scope exit).
+template <typename F>
+class ScopeExit {
+  F fn_;
+
+ public:
+  explicit ScopeExit(F fn) : fn_(std::move(fn)) {}
+  ~ScopeExit() noexcept {
+    static_assert(std::is_nothrow_invocable_v<F&>, "ScopeExit callable must be noexcept");
+    fn_();
+  }
+  ScopeExit(const ScopeExit&) = delete;
+  ScopeExit& operator=(const ScopeExit&) = delete;
+};
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/status.cc b/onnx/common/status.cc
new file mode 100644
index 0000000..94549fe
--- /dev/null
+++ b/onnx/common/status.cc
@@ -0,0 +1,89 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/common/status.h"
+
+#include <cassert>
+#include <memory>
+#include <string>
+
+#include "onnx/string_utils.h"
+
+namespace ONNX_NAMESPACE {
+namespace Common {
+
+Status::Status(StatusCategory category, StatusCode code, const std::string& msg) {
+  assert(StatusCode::OK != code);
+  state_ = std::make_unique<State>(category, code, msg);
+}
+
+Status::Status(StatusCategory category, StatusCode code) : Status(category, code, EmptyString()) {}
+
+bool Status::IsOK() const noexcept {
+  return (state_ == nullptr);
+}
+
+StatusCategory Status::Category() const noexcept {
+  return IsOK() ? StatusCategory::NONE : state_->category;
+}
+
+StatusCode Status::Code() const noexcept {
+  return IsOK() ? StatusCode::OK : state_->code;
+}
+
+const std::string& Status::ErrorMessage() const {
+  return IsOK() ? EmptyString() : state_->msg;
+}
+
+std::string Status::ToString() const {
+  if (state_ == nullptr) {
+    return std::string("OK");
+  }
+
+  std::string result;
+
+  if (StatusCategory::CHECKER == state_->category) {
+    result += "[CheckerError]";
+  } else if (StatusCategory::OPTIMIZER == state_->category) {
+    result += "[OptimizerError]";
+  }
+
+  result += " : ";
+  result += ONNX_NAMESPACE::to_string(static_cast<int>(Code()));
+  std::string msg;
+
+  switch (Code()) {
+    case StatusCode::INVALID_ARGUMENT:
+      msg = "INVALID_ARGUMENT";
+      break;
+    case StatusCode::INVALID_PROTOBUF:
+      msg = "INVALID_PROTOBUF";
+      break;
+    case StatusCode::FAIL:
+      msg = "FAIL";
+      break;
+    default:
+      msg = "GENERAL ERROR";
+      break;
+  }
+  result += " : ";
+  result += msg;
+  result += " : ";
+  result += state_->msg;
+
+  return result;
+}
+
+const Status& Status::OK() noexcept {
+  static Status s_ok;
+  return s_ok;
+}
+
+const std::string& Status::EmptyString() {
+  static std::string empty_str;
+  return empty_str;
+}
+
+} // namespace Common
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/status.h b/onnx/common/status.h
new file mode 100644
index 0000000..f7696d2
--- /dev/null
+++ b/onnx/common/status.h
@@ -0,0 +1,99 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <utility>
+
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+namespace Common {
+
+enum class StatusCategory : std::uint8_t {
+  NONE = 0,
+  CHECKER = 1,
+  OPTIMIZER = 2,
+};
+
+enum class StatusCode : std::uint8_t {
+  OK = 0,
+  FAIL = 1,
+  INVALID_ARGUMENT = 2,
+  INVALID_PROTOBUF = 3,
+};
+
+class Status {
+ public:
+  Status() noexcept = default;
+
+  Status(StatusCategory category, StatusCode code, const std::string& msg);
+
+  Status(StatusCategory category, StatusCode code);
+
+  Status(const Status& other) {
+    *this = other;
+  }
+
+  Status& operator=(const Status& other) {
+    if (&other != this) {
+      if (nullptr == other.state_) {
+        state_.reset();
+      } else if (state_ != other.state_) {
+        state_ = std::make_unique<State>(*other.state_);
+      }
+    }
+    return *this;
+  }
+
+  Status(Status&&) = default;
+  Status& operator=(Status&&) = default;
+  ~Status() = default;
+
+  ONNX_API bool IsOK() const noexcept;
+
+  ONNX_API StatusCode Code() const noexcept;
+
+  ONNX_API StatusCategory Category() const noexcept;
+
+  ONNX_API const std::string& ErrorMessage() const;
+
+  ONNX_API std::string ToString() const;
+
+  bool operator==(const Status& other) const {
+    return (this->state_ == other.state_) || (ToString() == other.ToString());
+  }
+
+  bool operator!=(const Status& other) const {
+    return !(*this == other);
+  }
+
+  ONNX_API static const Status& OK() noexcept;
+
+ private:
+  struct State {
+    State(StatusCategory cat_, StatusCode code_, std::string msg_)
+        : category(cat_), code(code_), msg(std::move(msg_)) {}
+
+    StatusCategory category = StatusCategory::NONE;
+    StatusCode code{};
+    std::string msg;
+  };
+
+  static const std::string& EmptyString();
+
+  // state_ == nullptr when if status code is OK.
+  std::unique_ptr<State> state_;
+};
+
+inline std::ostream& operator<<(std::ostream& out, const Status& status) {
+  return out << status.ToString();
+}
+
+} // namespace Common
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/tensor.h b/onnx/common/tensor.h
new file mode 100644
index 0000000..95f3e80
--- /dev/null
+++ b/onnx/common/tensor.h
@@ -0,0 +1,236 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// ATTENTION: The code in this file is highly EXPERIMENTAL.
+// Adventurous users should note that the APIs will probably change.
+
+#pragma once
+
+#include <cmath>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/common/assertions.h"
+#include "onnx/common/safe_math.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+
+struct Tensor final {
+ private:
+  bool is_segment_{false};
+  int64_t segment_begin_{0};
+  int64_t segment_end_{0};
+  bool has_name_{false};
+  std::string name_;
+  int32_t elem_type_{ONNX_NAMESPACE::TensorProto_DataType_UNDEFINED};
+  std::vector<int64_t> sizes_;
+
+  std::vector<float> float_data_;
+  std::vector<double> double_data_;
+  std::vector<int32_t> int32_data_;
+  std::vector<int64_t> int64_data_;
+  std::vector<uint64_t> uint64_data_;
+  std::vector<std::string> string_data_;
+
+  bool is_raw_data_{false};
+  std::string raw_data_;
+
+  std::vector<std::pair<std::string, std::string>> external_data_;
+  ONNX_NAMESPACE::TensorProto_DataLocation data_location_{ONNX_NAMESPACE::TensorProto_DataLocation_DEFAULT};
+
+ public:
+  const std::vector<int64_t>& sizes() const {
+    return sizes_;
+  }
+  std::vector<int64_t>& sizes() {
+    return sizes_;
+  }
+  /// if tensor is a scalar, the sizes is empty, but the element number is actually 1.
+  /// size_from_dim() cannot handle this case, while elem_num() handles it correctly
+  int64_t elem_num() const {
+    return safe_dim_product(sizes_, [](const char* msg) { throw tensor_error(msg); });
+  }
+  int64_t size_from_dim(int dim) const {
+    if (dim < 0) {
+      dim += static_cast<int>(sizes_.size());
+    }
+    ONNX_ASSERT(dim >= 0 && static_cast<size_t>(dim) < sizes_.size())
+    return safe_dim_product(sizes_.begin() + dim, sizes_.end(), [](const char* msg) { throw tensor_error(msg); });
+  }
+
+  int32_t elem_type() const {
+    return elem_type_;
+  }
+
+  int32_t& elem_type() {
+    return elem_type_;
+  }
+
+  std::vector<std::string>& strings() {
+    return string_data_;
+  }
+
+  const std::vector<std::string>& strings() const {
+    return string_data_;
+  }
+
+  std::vector<float>& floats() {
+    return float_data_;
+  }
+
+  const std::vector<float>& floats() const {
+    return float_data_;
+  }
+
+  std::vector<double>& doubles() {
+    return double_data_;
+  }
+
+  const std::vector<double>& doubles() const {
+    return double_data_;
+  }
+
+  std::vector<int32_t>& int32s() {
+    return int32_data_;
+  }
+
+  const std::vector<int32_t>& int32s() const {
+    return int32_data_;
+  }
+
+  std::vector<int64_t>& int64s() {
+    return int64_data_;
+  }
+
+  const std::vector<int64_t>& int64s() const {
+    return int64_data_;
+  }
+
+  std::vector<uint64_t>& uint64s() {
+    return uint64_data_;
+  }
+
+  const std::vector<uint64_t>& uint64s() const {
+    return uint64_data_;
+  }
+
+  const std::string& raw() const {
+    return raw_data_;
+  }
+
+  void set_raw_data(std::string raw_data) {
+    is_raw_data_ = true;
+    raw_data_ = std::move(raw_data);
+  }
+
+  template <typename T>
+  T* data();
+
+  template <typename T>
+  const T* data() const;
+
+  bool is_segment() const {
+    return is_segment_;
+  }
+
+  int64_t segment_begin() const {
+    return segment_begin_;
+  }
+
+  int64_t segment_end() const {
+    return segment_end_;
+  }
+
+  void set_segment_begin_and_end(int64_t begin, int64_t end) {
+    is_segment_ = true;
+    segment_begin_ = begin;
+    segment_end_ = end;
+  }
+
+  bool hasName() const {
+    return has_name_;
+  }
+
+  const std::string& name() const {
+    return name_;
+  }
+
+  void setName(std::string name) {
+    has_name_ = true;
+    name_ = std::move(name);
+  }
+
+  bool is_raw_data() const {
+    return is_raw_data_;
+  }
+
+  const std::vector<std::pair<std::string, std::string>>& external_data() const {
+    return external_data_;
+  }
+
+  std::vector<std::pair<std::string, std::string>>& external_data() {
+    return external_data_;
+  }
+
+  bool has_data_location() const {
+    return data_location_ != ONNX_NAMESPACE::TensorProto_DataLocation_DEFAULT;
+  }
+
+  const ONNX_NAMESPACE::TensorProto_DataLocation& data_location() const {
+    return data_location_;
+  }
+
+  ONNX_NAMESPACE::TensorProto_DataLocation& data_location() {
+    return data_location_;
+  }
+};
+
+template <>
+inline std::string* Tensor::data<std::string>() {
+  ONNX_ASSERTM(
+      !is_raw_data(),
+      "data type is string. string content is required to be stored in repeated bytes string_data field."
+      "raw_data type cannot be string.")
+  return string_data_.data();
+}
+template <>
+inline const std::string* Tensor::data<std::string>() const {
+  ONNX_ASSERTM(
+      !is_raw_data(),
+      "data type is string. string content is required to be stored in repeated bytes string_data field."
+      "raw_data type cannot be string.")
+  return string_data_.data();
+}
+
+// NOLINTBEGIN(bugprone-macro-parentheses)
+#define define_data(type, field)                              \
+  template <>                                                 \
+  inline type* Tensor::data<type>() {                         \
+    if (is_raw_data_) {                                       \
+      return reinterpret_cast<type*>(raw_data_.data());       \
+    } else {                                                  \
+      return field.data();                                    \
+    }                                                         \
+  }                                                           \
+                                                              \
+  template <>                                                 \
+  inline const type* Tensor::data<type>() const {             \
+    if (is_raw_data_) {                                       \
+      return reinterpret_cast<const type*>(raw_data_.data()); \
+    } else {                                                  \
+      return field.data();                                    \
+    }                                                         \
+  }
+// NOLINTEND(bugprone-macro-parentheses)
+
+define_data(float, float_data_)
+define_data(double, double_data_)
+define_data(int32_t, int32_data_)
+define_data(int64_t, int64_data_)
+define_data(uint64_t, uint64_data_)
+#undef define_data
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/version.h.in b/onnx/common/version.h.in
new file mode 100644
index 0000000..b3868a1
--- /dev/null
+++ b/onnx/common/version.h.in
@@ -0,0 +1,20 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Auto-generated from version.h.in by CMake. Do not edit version.h directly.
+
+#pragma once
+
+#define ONNX_VERSION_MAJOR @ONNX_VERSION_MAJOR@
+#define ONNX_VERSION_MINOR @ONNX_VERSION_MINOR@
+#define ONNX_VERSION_PATCH @ONNX_VERSION_PATCH@
+#define ONNX_VERSION_STRING "@ONNX_VERSION@"
+
+namespace ONNX_NAMESPACE {
+
+// Represents the current ONNX version string for this build.
+// This may be a development or release-candidate version, not necessarily the most recent release.
+constexpr const char* LAST_RELEASE_VERSION = ONNX_VERSION_STRING;
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/common/visitor.h b/onnx/common/visitor.h
new file mode 100644
index 0000000..4ded8b2
--- /dev/null
+++ b/onnx/common/visitor.h
@@ -0,0 +1,118 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+namespace internal {
+
+// Visitor: A readonly visitor class for ONNX Proto objects.
+// This class is restricted to Nodes, Graphs, Attributes, and Functions.
+// The VisitX methods invoke ProcessX, and if that returns true, will
+// continue to visit all children of the X.
+
+struct Visitor {
+  virtual void VisitGraph(const GraphProto& graph) {
+    if (ProcessGraph(graph))
+      for (const auto& node : graph.node())
+        VisitNode(node);
+  }
+
+  virtual void VisitFunction(const FunctionProto& function) {
+    if (ProcessFunction(function))
+      for (const auto& node : function.node())
+        VisitNode(node);
+  }
+
+  virtual void VisitNode(const NodeProto& node) {
+    if (ProcessNode(node)) {
+      for (const auto& attr : node.attribute()) {
+        VisitAttribute(attr);
+      }
+    }
+  }
+
+  virtual void VisitAttribute(const AttributeProto& attr) {
+    if (ProcessAttribute(attr)) {
+      if (attr.has_g()) {
+        VisitGraph(attr.g());
+      }
+      for (const auto& graph : attr.graphs())
+        VisitGraph(graph);
+    }
+  }
+
+  virtual bool ProcessGraph(const GraphProto& graph [[maybe_unused]]) {
+    return true;
+  }
+
+  virtual bool ProcessFunction(const FunctionProto& function [[maybe_unused]]) {
+    return true;
+  }
+
+  virtual bool ProcessNode(const NodeProto& node [[maybe_unused]]) {
+    return true;
+  }
+
+  virtual bool ProcessAttribute(const AttributeProto& attr [[maybe_unused]]) {
+    return true;
+  }
+
+  virtual ~Visitor() = default;
+};
+
+// MutableVisitor: A version of Visitor that allows mutation of the visited objects.
+struct MutableVisitor {
+  virtual void VisitGraph(GraphProto& graph) {
+    if (ProcessGraph(graph))
+      for (auto& node : *(graph.mutable_node()))
+        VisitNode(node);
+  }
+
+  virtual void VisitFunction(FunctionProto& function) {
+    if (ProcessFunction(function))
+      for (auto& node : *(function.mutable_node()))
+        VisitNode(node);
+  }
+
+  virtual void VisitNode(NodeProto& node) {
+    if (ProcessNode(node)) {
+      for (auto& attr : *(node.mutable_attribute())) {
+        VisitAttribute(attr);
+      }
+    }
+  }
+
+  virtual void VisitAttribute(AttributeProto& attr) {
+    if (ProcessAttribute(attr)) {
+      if (attr.has_g()) {
+        VisitGraph(*attr.mutable_g());
+      }
+      for (auto& graph : *(attr.mutable_graphs()))
+        VisitGraph(graph);
+    }
+  }
+
+  virtual bool ProcessGraph(GraphProto& graph [[maybe_unused]]) {
+    return true;
+  }
+
+  virtual bool ProcessFunction(FunctionProto& function [[maybe_unused]]) {
+    return true;
+  }
+
+  virtual bool ProcessNode(NodeProto& node [[maybe_unused]]) {
+    return true;
+  }
+
+  virtual bool ProcessAttribute(AttributeProto& attr [[maybe_unused]]) {
+    return true;
+  }
+
+  virtual ~MutableVisitor() = default;
+};
+
+} // namespace internal
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/compose.py b/onnx/compose.py
new file mode 100644
index 0000000..eaa5dcf
--- /dev/null
+++ b/onnx/compose.py
@@ -0,0 +1,756 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from onnx import (
+    AttributeProto,
+    GraphProto,
+    ModelProto,
+    TensorProto,
+    checker,
+    helper,
+    utils,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping
+
+
+def check_overlapping_names(
+    g1: GraphProto, g2: GraphProto, io_map: list[tuple[str, str]] | None = None
+) -> list[tuple[str, list[str]]]:
+    """Checks whether there are name collisions between two graphs
+
+    Returns a list of tuples where the first element represents the member containing overlapping names
+    (One of: "node", "edge", "value_info", "initializer", "sparse_initializer"), and the
+    second element contains a list of names that appear in both graphs on that category.
+
+    Optionally, it takes an io_map, representing the output/inputs to be connected. It provided, overlapping
+    present in the io_map argument will be ignored.
+    """
+    if not isinstance(g1, GraphProto):
+        raise TypeError("g1 argument is not an ONNX graph")
+    if not isinstance(g2, GraphProto):
+        raise TypeError("g2 argument is not an ONNX graph")
+
+    def _overlapping(c1: list[str], c2: list[str]) -> list[str]:
+        return list(set(c1) & set(c2))
+
+    def _edge_names(graph: GraphProto, exclude: set[str] | None = None) -> list[str]:
+        if exclude is None:
+            exclude = set()
+        edges = []
+        for n in graph.node:
+            for i in n.input:
+                if i != "" and i not in exclude:
+                    edges.append(i)  # noqa: PERF401
+            for o in n.output:
+                if o != "" and o not in exclude:
+                    edges.append(o)  # noqa: PERF401
+        return edges
+
+    result = []
+
+    if not io_map:
+        io_map = []
+    io_map_inputs = {elem[1] for elem in io_map}
+
+    # Edges already cover input/output
+    overlap = _overlapping(_edge_names(g1), _edge_names(g2, exclude=io_map_inputs))
+    if overlap:
+        result.append(("edge", overlap))
+
+    overlap = _overlapping(
+        [e.name for e in g1.value_info], [e.name for e in g2.value_info]
+    )
+    if overlap:
+        result.append(("value_info", overlap))
+
+    overlap = _overlapping(
+        [e.name for e in g1.initializer], [e.name for e in g2.initializer]
+    )
+    if overlap:
+        result.append(("initializer", overlap))
+
+    overlap = _overlapping(
+        [e.values.name for e in g1.sparse_initializer],
+        [e.values.name for e in g2.sparse_initializer],
+    ) + _overlapping(
+        [e.indices.name for e in g1.sparse_initializer],
+        [e.indices.name for e in g2.sparse_initializer],
+    )
+    if overlap:
+        result.append(("sparse_initializer", overlap))
+
+    return result
+
+
+def merge_graphs(
+    g1: GraphProto,
+    g2: GraphProto,
+    io_map: list[tuple[str, str]],
+    inputs: list[str] | None = None,
+    outputs: list[str] | None = None,
+    prefix1: str | None = None,
+    prefix2: str | None = None,
+    name: str | None = None,
+    doc_string: str | None = None,
+) -> GraphProto:
+    """Combines two ONNX graphs into a single one.
+
+    The combined graph is defined by connecting the specified set of outputs/inputs. Those inputs/outputs
+    not specified in the io_map argument will remain as inputs/outputs of the combined graph.
+
+    Arguments:
+        g1 (GraphProto): First graph
+        g2 (GraphProto): Second graph
+        io_map (list of pairs of string): The pairs of names [(out0, in0), (out1, in1), ...]
+                                          representing outputs of the first graph and inputs of the second
+                                          to be connected
+        inputs (list of string): Optional list of inputs to be included in the combined graph
+                                 By default, all inputs not present in the ``io_map`` argument will be
+                                 included in the combined model
+        outputs (list of string): Optional list of outputs to be included in the combined graph
+                                  By default, all outputs not present in the ``io_map`` argument will be
+                                  included in the combined model
+        prefix1 (string): Optional prefix to be added to all names in g1
+        prefix2 (string): Optional prefix to be added to all names in g2
+        name (string): Optional name for the combined graph
+                       By default, the name is g1.name and g2.name concatenated with an underscore delimiter
+        doc_string (string): Optional docstring for the combined graph
+                             If not provided, a default docstring with the concatenation of g1 and g2 docstrings is used
+
+    Returns:
+        GraphProto
+    """
+    if not isinstance(g1, GraphProto):
+        raise TypeError("g1 argument is not an ONNX graph")
+    if not isinstance(g2, GraphProto):
+        raise TypeError("g2 argument is not an ONNX graph")
+
+    # Prefixing names in the graph if requested, adjusting io_map accordingly
+    if prefix1 or prefix2:
+        if prefix1:
+            g1_copy = GraphProto()
+            g1_copy.CopyFrom(g1)
+            g1 = g1_copy
+            g1 = add_prefix_graph(g1, prefix=prefix1)
+        if prefix2:
+            g2_copy = GraphProto()
+            g2_copy.CopyFrom(g2)
+            g2 = g2_copy
+            g2 = add_prefix_graph(g2, prefix=prefix2)
+        io_map = [
+            (
+                prefix1 + io[0] if prefix1 else io[0],
+                prefix2 + io[1] if prefix2 else io[1],
+            )
+            for io in io_map
+        ]
+
+    io_map_g1_outs = {io[0] for io in io_map}
+    io_map_g2_ins = {io[1] for io in io_map}
+    reversed_io_map = {in_name: out_name for out_name, in_name in io_map}
+    g1_outs = {o.name for o in g1.output}
+    g2_ins = {i.name for i in g2.input}
+
+    # If necessary extract subgraphs
+    if inputs or outputs:
+        if not inputs:
+            g1_inputs = [i.name for i in g1.input]
+            g2_inputs = [i.name for i in g2.input]
+        else:
+            input_set = set(inputs)
+            g1_inputs = [i.name for i in g1.input if i.name in input_set]
+            g2_inputs = [
+                i.name
+                for i in g2.input
+                if i.name in input_set or i.name in io_map_g2_ins
+            ]
+
+        if not outputs:
+            g1_outputs = [o.name for o in g1.output]
+            g2_outputs = [o.name for o in g2.output]
+        else:
+            output_set = set(outputs)
+            g1_outputs = [
+                o.name
+                for o in g1.output
+                if o.name in output_set or o.name in io_map_g1_outs
+            ]
+            g2_outputs = [o.name for o in g2.output if o.name in output_set]
+
+        if len(g1_inputs) < len(g1.input) or len(g1_outputs) < len(g1.output):
+            e1 = utils.Extractor(helper.make_model(g1))
+            g1 = e1.extract_model(g1_inputs, g1_outputs).graph
+
+        if len(g2_inputs) < len(g2.input) or len(g2_outputs) < len(g2.output):
+            e2 = utils.Extractor(helper.make_model(g2))
+            g2 = e2.extract_model(g2_inputs, g2_outputs).graph
+
+    # Check that input/output names specified in the io_map argument are valid input/output names
+    for g1_out_name, g2_in_name in io_map:
+        if g1_out_name not in g1_outs:
+            raise ValueError(f"Output {g1_out_name} is not present in g1")
+        if g2_in_name not in g2_ins:
+            raise ValueError(f"Input {g2_in_name} is not present in g2")
+
+    # Check for name collision
+    overlapping_names = check_overlapping_names(g1, g2, io_map)
+    if len(overlapping_names) > 0:
+        category, names = overlapping_names[0]
+        raise ValueError(
+            "Cant merge two graphs with overlapping names. "
+            f"Found repeated {category} names: "
+            + ", ".join(names)
+            + "\n"
+            + "Consider using ``onnx.compose.add_prefix`` to add a prefix to names in one of the graphs."
+        )
+
+    g = GraphProto()
+
+    g.node.extend(g1.node)
+    g2_nodes_begin = len(g.node)
+    g.node.extend(g2.node)
+    g2_nodes_end = len(g.node)
+
+    # Search inputs of the subgraph recursively
+    def connect_io(sub_graph: GraphProto, start: int, end: int) -> None:
+        for node_idx in range(start, end):
+            node = sub_graph.node[node_idx]
+            for attr in node.attribute:
+                if attr.type == AttributeProto.GRAPH:
+                    connect_io(attr.g, 0, len(attr.g.node))
+                elif attr.type == AttributeProto.GRAPHS:
+                    for sub_g in attr.graphs:
+                        connect_io(sub_g, 0, len(sub_g.node))
+
+            for index, name_ in enumerate(node.input):
+                if name_ in reversed_io_map:
+                    node.input[index] = reversed_io_map[name_]
+
+    # Connecting outputs of the first graph with the inputs of the second
+    connect_io(g, g2_nodes_begin, g2_nodes_end)
+
+    if inputs:
+        input_set = set(inputs)
+        g.input.extend([i for i in g1.input if i.name in input_set])
+        g.input.extend([i for i in g2.input if i.name in input_set])
+    else:
+        g.input.extend(g1.input)
+        g.input.extend([i for i in g2.input if i.name not in io_map_g2_ins])
+
+    if outputs:
+        output_set = set(outputs)
+        g.output.extend([o for o in g1.output if o.name in output_set])
+        g.output.extend([o for o in g2.output if o.name in output_set])
+    else:
+        g.output.extend([o for o in g1.output if o.name not in io_map_g1_outs])
+        g.output.extend(g2.output)
+
+    g.initializer.extend(g1.initializer)
+    g.initializer.extend(
+        [init for init in g2.initializer if init.name not in io_map_g2_ins]
+    )
+
+    g.sparse_initializer.extend(g1.sparse_initializer)
+    g.sparse_initializer.extend(
+        [
+            init
+            for init in g2.sparse_initializer
+            if init.values.name not in io_map_g2_ins
+        ]
+    )
+
+    g.value_info.extend(g1.value_info)
+    g.value_info.extend([vi for vi in g2.value_info if vi.name not in io_map_g2_ins])
+    value_info_names = {vi.name for vi in g.value_info}
+    output_names = {o.name for o in g.output}
+    g.value_info.extend(
+        [
+            o
+            for o in g1.output
+            if o.name in io_map_g1_outs
+            and o.name not in value_info_names
+            and o.name not in output_names
+        ]
+    )
+
+    g.name = name if name is not None else f"{g1.name}_{g2.name}"
+
+    if doc_string is None:
+        doc_string = (
+            f"Graph combining {g1.name} and {g2.name}\n"
+            + g1.name
+            + "\n\n"
+            + g1.doc_string
+            + "\n\n"
+            + g2.name
+            + "\n\n"
+            + g2.doc_string
+        )
+    g.doc_string = doc_string
+
+    return g
+
+
+def merge_models(
+    m1: ModelProto,
+    m2: ModelProto,
+    io_map: list[tuple[str, str]],
+    inputs: list[str] | None = None,
+    outputs: list[str] | None = None,
+    prefix1: str | None = None,
+    prefix2: str | None = None,
+    name: str | None = None,
+    doc_string: str | None = None,
+    producer_name: str | None = "onnx.compose.merge_models",
+    producer_version: str | None = "1.0",
+    domain: str | None = "",
+    model_version: int | None = 1,
+) -> ModelProto:
+    """Combines two ONNX models into a single one.
+
+    The combined model is defined by connecting the specified set of outputs/inputs.
+    Those inputs/outputs not specified in the io_map argument will remain as
+    inputs/outputs of the combined model.
+
+    Both models should have the same IR version, and same operator sets imported.
+
+    Arguments:
+        m1 (ModelProto): First model
+        m2 (ModelProto): Second model
+        io_map (list of pairs of string): The pairs of names [(out0, in0), (out1, in1), ...]
+                                          representing outputs of the first graph and inputs of the second
+                                          to be connected
+        inputs (list of string): Optional list of inputs to be included in the combined graph
+                                 By default, all inputs not present in the ``io_map`` argument will be
+                                 included in the combined model
+        outputs (list of string): Optional list of outputs to be included in the combined graph
+                                  By default, all outputs not present in the ``io_map`` argument will be
+                                  included in the combined model
+        prefix1 (string): Optional prefix to be added to all names in m1
+        prefix2 (string): Optional prefix to be added to all names in m2
+        name (string): Optional name for the combined graph
+                       By default, the name is g1.name and g2.name concatenated with an underscore delimiter
+        doc_string (string): Optional docstring for the combined graph
+                             If not provided, a default docstring with the concatenation of g1 and g2 docstrings is used
+        producer_name (string): Optional producer name for the combined model. Default: 'onnx.compose'
+        producer_version (string): Optional producer version for the combined model. Default: "1.0"
+        domain (string): Optional domain of the combined model. Default: ""
+        model_version (int): Optional version of the graph encoded. Default: 1
+
+    Returns:
+        ModelProto
+    """
+    if not isinstance(m1, ModelProto):
+        raise TypeError("m1 argument is not an ONNX model")
+    if not isinstance(m2, ModelProto):
+        raise TypeError("m2 argument is not an ONNX model")
+
+    if m1.ir_version != m2.ir_version:
+        raise ValueError(
+            f"IR version mismatch {m1.ir_version} != {m2.ir_version}."
+            " Both models should have the same IR version"
+        )
+    ir_version = m1.ir_version
+
+    opset_import_map: MutableMapping[str, int] = {}
+    opset_imports = list(m1.opset_import) + list(m2.opset_import)
+
+    for entry in opset_imports:
+        if entry.domain in opset_import_map:
+            found_version = opset_import_map[entry.domain]
+            if entry.version != found_version:
+                raise ValueError(
+                    "Can't merge two models with different operator set ids for a given domain. "
+                    f"Got: {m1.opset_import} and {m2.opset_import}"
+                )
+        else:
+            opset_import_map[entry.domain] = entry.version
+
+    # Prefixing names in the graph if requested, adjusting io_map accordingly
+    if prefix1 or prefix2:
+        if prefix1:
+            m1_copy = ModelProto()
+            m1_copy.CopyFrom(m1)
+            m1 = m1_copy
+            m1 = add_prefix(m1, prefix=prefix1)
+        if prefix2:
+            m2_copy = ModelProto()
+            m2_copy.CopyFrom(m2)
+            m2 = m2_copy
+            m2 = add_prefix(m2, prefix=prefix2)
+        io_map = [
+            (
+                prefix1 + io[0] if prefix1 else io[0],
+                prefix2 + io[1] if prefix2 else io[1],
+            )
+            for io in io_map
+        ]
+
+    graph = merge_graphs(
+        m1.graph,
+        m2.graph,
+        io_map,
+        inputs=inputs,
+        outputs=outputs,
+        name=name,
+        doc_string=doc_string,
+    )
+    model = helper.make_model(
+        graph,
+        producer_name=producer_name,
+        producer_version=producer_version,
+        domain=domain,
+        model_version=model_version,
+        opset_imports=opset_imports,
+        ir_version=ir_version,
+    )
+
+    # Merging model metadata props
+    model_props = {}
+    for meta_entry in m1.metadata_props:
+        model_props[meta_entry.key] = meta_entry.value
+    for meta_entry in m2.metadata_props:
+        if meta_entry.key in model_props:
+            value = model_props[meta_entry.key]
+            if value != meta_entry.value:
+                raise ValueError(
+                    "Can't merge models with different values for the same model metadata property."
+                    f" Found: property = {meta_entry.key}, with values {value} and {meta_entry.value}."
+                )
+        else:
+            model_props[meta_entry.key] = meta_entry.value
+    helper.set_model_props(model, model_props)
+
+    # Merging functions
+    function_overlap = list(
+        {f.name for f in m1.functions} & {f.name for f in m2.functions}
+    )
+    if function_overlap:
+        raise ValueError(
+            "Can't merge models with overlapping local function names."
+            " Found in both graphs: " + ", ".join(function_overlap)
+        )
+    model.functions.MergeFrom(m1.functions)
+    model.functions.MergeFrom(m2.functions)
+
+    checker.check_model(model)
+    return model
+
+
+def add_prefix_graph(
+    graph: GraphProto,
+    prefix: str,
+    rename_nodes: bool | None = True,
+    rename_edges: bool | None = True,
+    rename_inputs: bool | None = True,
+    rename_outputs: bool | None = True,
+    rename_initializers: bool | None = True,
+    rename_value_infos: bool | None = True,
+    inplace: bool | None = False,
+    name_map: dict[str, str] | None = None,
+) -> GraphProto:
+    """Adds a prefix to names of elements in a graph: nodes, edges, inputs, outputs,
+    initializers, sparse initializer, value infos.
+
+    It can be used as a utility before merging graphs that have overlapping names.
+    Empty names are not prefixed.
+
+    Arguments:
+        graph (GraphProto): Graph
+        prefix (str): Prefix to be added to each name in the graph
+        rename_nodes (bool): Whether to prefix node names
+        rename_edges (bool): Whether to prefix node edge names
+        rename_inputs (bool): Whether to prefix input names
+        rename_outputs (bool): Whether to prefix output names
+        rename_initializers (bool): Whether to prefix initializer and sparse initializer names
+        rename_value_infos (bool): Whether to prefix value info names
+        inplace (bool): If True, mutates the graph directly.
+                        Otherwise, a copy will be created
+        name_map: (Dict): shared name_map in subgraph
+
+    Returns:
+        GraphProto
+    """
+    if not isinstance(graph, GraphProto):
+        raise TypeError("graph argument is not an ONNX graph")
+
+    if not inplace:
+        g = GraphProto()
+        g.CopyFrom(graph)
+    else:
+        g = graph
+
+    def _prefixed(prefix: str, name: str) -> str:
+        return prefix + name if len(name) > 0 else name
+
+    if name_map is None:
+        name_map = {}
+
+    if rename_edges:
+        # See https://github.com/onnx/onnx/pull/6869#issuecomment-2852719536.
+        # Consider only intermediate nodes, that are not connected to graph outputs.
+        # Rename graph inputs or outputs separately based on rename_inputs/rename_outputs flags.
+        graph_output_names = {o.name for o in g.output}
+        for n in g.node:
+            for e in n.output:
+                if e not in graph_output_names:
+                    name_map[e] = _prefixed(prefix, e)
+
+    if rename_inputs:
+        for entry in g.input:
+            name_map[entry.name] = _prefixed(prefix, entry.name)
+    if rename_outputs:
+        for entry in g.output:
+            name_map[entry.name] = _prefixed(prefix, entry.name)
+
+    if rename_nodes:
+        for n in g.node:
+            n.name = _prefixed(prefix, n.name)
+            for attribute in n.attribute:
+                if attribute.HasField("g"):
+                    add_prefix_graph(
+                        attribute.g, prefix, inplace=True, name_map=name_map
+                    )
+                for sub_g in attribute.graphs:
+                    add_prefix_graph(sub_g, prefix, inplace=True, name_map=name_map)
+
+    if rename_initializers:
+        for init in g.initializer:
+            name_map[init.name] = _prefixed(prefix, init.name)
+        for sparse_init in g.sparse_initializer:
+            name_map[sparse_init.values.name] = _prefixed(
+                prefix, sparse_init.values.name
+            )
+            name_map[sparse_init.indices.name] = _prefixed(
+                prefix, sparse_init.indices.name
+            )
+
+    if rename_value_infos:
+        for entry in g.value_info:
+            name_map[entry.name] = _prefixed(prefix, entry.name)
+
+    for n in g.node:
+        for i, output in enumerate(n.output):
+            if n.output[i] in name_map:
+                n.output[i] = name_map[output]
+        for i, input_ in enumerate(n.input):
+            if n.input[i] in name_map:
+                n.input[i] = name_map[input_]
+
+    for in_desc in g.input:
+        if in_desc.name in name_map:
+            in_desc.name = name_map[in_desc.name]
+    for out_desc in g.output:
+        if out_desc.name in name_map:
+            out_desc.name = name_map[out_desc.name]
+
+    for initializer in g.initializer:
+        if initializer.name in name_map:
+            initializer.name = name_map[initializer.name]
+    for sparse_initializer in g.sparse_initializer:
+        if sparse_initializer.values.name in name_map:
+            sparse_initializer.values.name = name_map[sparse_initializer.values.name]
+        if sparse_initializer.indices.name in name_map:
+            sparse_initializer.indices.name = name_map[sparse_initializer.indices.name]
+
+    for value_info in g.value_info:
+        if value_info.name in name_map:
+            value_info.name = name_map[value_info.name]
+
+    return g
+
+
+def add_prefix(
+    model: ModelProto,
+    prefix: str,
+    rename_nodes: bool | None = True,
+    rename_edges: bool | None = True,
+    rename_inputs: bool | None = True,
+    rename_outputs: bool | None = True,
+    rename_initializers: bool | None = True,
+    rename_value_infos: bool | None = True,
+    rename_functions: bool | None = True,
+    inplace: bool | None = False,
+) -> ModelProto:
+    """Adds a prefix to names of elements in a graph: nodes, edges, inputs, outputs,
+    initializers, sparse initializer, value infos, and local functions.
+
+    It can be used as a utility before merging graphs that have overlapping names.
+    Empty names are not _prefixed.
+
+    Arguments:
+        model (ModelProto): Model
+        prefix (str): Prefix to be added to each name in the graph
+        rename_nodes (bool): Whether to prefix node names
+        rename_edges (bool): Whether to prefix node edge names
+        rename_inputs (bool): Whether to prefix input names
+        rename_outputs (bool): Whether to prefix output names
+        rename_initializers (bool): Whether to prefix initializer and sparse initializer names
+        rename_value_infos (bool): Whether to prefix value info nanes
+        rename_functions (bool): Whether to prefix local function names
+        inplace (bool): If True, mutates the model directly.
+                        Otherwise, a copy will be created
+
+    Returns:
+        ModelProto
+    """
+    if not isinstance(model, ModelProto):
+        raise TypeError("model argument is not an ONNX model")
+
+    if not inplace:
+        m = ModelProto()
+        m.CopyFrom(model)
+        model = m
+
+    add_prefix_graph(
+        model.graph,
+        prefix,
+        rename_nodes=rename_nodes,
+        rename_edges=rename_edges,
+        rename_inputs=rename_inputs,
+        rename_outputs=rename_outputs,
+        rename_initializers=rename_initializers,
+        rename_value_infos=rename_value_infos,
+        inplace=True,  # No need to create a copy, since it's a new model
+    )
+
+    if rename_functions:
+        f_name_map = {}
+        for f in model.functions:
+            new_f_name = prefix + f.name
+            f_name_map[f.name] = new_f_name
+            f.name = new_f_name
+        # Adjust references to local functions in other local function
+        # definitions
+        for f in model.functions:
+            for n in f.node:
+                if n.op_type in f_name_map:
+                    n.op_type = f_name_map[n.op_type]
+        # Adjust references to local functions in the graph
+        for n in model.graph.node:
+            if n.op_type in f_name_map:
+                n.op_type = f_name_map[n.op_type]
+
+    return model
+
+
+def expand_out_dim_graph(
+    graph: GraphProto,
+    dim_idx: int,
+    inplace: bool | None = False,
+) -> GraphProto:
+    """Inserts an extra dimension with extent 1 to each output in the graph.
+
+    Inserts an Unsqueeze node for each output. It can be used as a utility before merging graphs,
+    for example when the second one expects a batch dimension.
+
+    Arguments:
+        graph (GraphProto): Graph
+        dim_idx (int): Index of the dimension to be inserted.
+                       A negative value means counting dimensions from the back.
+        inplace (bool): If True, mutates the model directly.
+                        Otherwise, a copy will be created
+
+    Returns:
+        GraphProto
+    """
+    if not isinstance(graph, GraphProto):
+        raise TypeError("graph argument is not an ONNX graph")
+
+    if not inplace:
+        g = GraphProto()
+        g.CopyFrom(graph)
+    else:
+        g = graph
+
+    orig_out_names = [output.name for output in g.output]
+
+    for n in g.node:
+        for i, out in enumerate(n.output):
+            if out in orig_out_names:
+                n.output[i] = out + f"_collapsed_dim_{dim_idx}"
+        for i, inp in enumerate(n.input):
+            if inp in orig_out_names:
+                n.input[i] = inp + f"_collapsed_dim_{dim_idx}"
+
+    expand_dim_k = g.name + "_expand_out_dim_idx"
+    g.node.append(
+        helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=[expand_dim_k],
+            name=f"{expand_dim_k}-constant",
+            value=helper.make_tensor(
+                name=f"{expand_dim_k}-value",
+                data_type=TensorProto.INT64,
+                dims=[
+                    1,
+                ],
+                vals=[
+                    dim_idx,
+                ],
+            ),
+        )
+    )
+
+    for _ in range(len(g.output)):
+        o = g.output.pop(0)
+        prev_output = o.name + f"_collapsed_dim_{dim_idx}"
+        g.node.append(
+            helper.make_node(
+                "Unsqueeze",
+                inputs=[prev_output, expand_dim_k],
+                outputs=[o.name],
+                name=f"unsqueeze-{o.name}",
+            )
+        )
+        new_shape = [d.dim_value for d in o.type.tensor_type.shape.dim]
+        new_shape.insert(dim_idx, 1)
+        g.output.append(
+            helper.make_tensor_value_info(
+                o.name, o.type.tensor_type.elem_type, new_shape
+            )
+        )
+    return g
+
+
+def expand_out_dim(
+    model: ModelProto,
+    dim_idx: int,
+    inplace: bool | None = False,
+) -> ModelProto:
+    """Inserts an extra dimension with extent 1 to each output in the graph.
+
+    Inserts an Unsqueeze node for each output. It can be used as a utility before merging graphs,
+    for example when the second one expects a batch dimension.
+
+    Arguments:
+        model (ModelProto): Model
+        dim_idx (int): Index of the dimension to be inserted.
+                       A negative value means counting dimensions from the back.
+        inplace (bool): If True, mutates the model directly.
+                        Otherwise, a copy will be created
+
+    Returns:
+        ModelProto
+    """
+    if not isinstance(model, ModelProto):
+        raise TypeError("model argument is not an ONNX model")
+
+    if not inplace:
+        m = ModelProto()
+        m.CopyFrom(model)
+        model = m
+
+    expand_out_dim_graph(
+        model.graph,
+        dim_idx,
+        inplace=True,  # No need to create a copy, since it's a new model
+    )
+    return model
diff --git a/onnx/cpp2py_export.cc b/onnx/cpp2py_export.cc
new file mode 100644
index 0000000..771fcd5
--- /dev/null
+++ b/onnx/cpp2py_export.cc
@@ -0,0 +1,814 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <nanobind/nanobind.h>
+#include <nanobind/operators.h>
+#include <nanobind/stl/function.h>
+#include <nanobind/stl/pair.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/unordered_map.h>
+#include <nanobind/stl/unordered_set.h>
+#include <nanobind/stl/vector.h>
+
+#include <algorithm>
+#include <climits>
+#include <limits>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "onnx/checker.h"
+#include "onnx/common/ir_pb_converter.h"
+#include "onnx/defs/parser.h"
+#include "onnx/defs/printer.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/shape_inference.h"
+#include "onnx/inliner/inliner.h"
+#include "onnx/py_utils.h"
+#include "onnx/shape_inference/implementation.h"
+#include "onnx/version_converter/convert.h"
+
+#ifdef ONNX_USE_LITE_PROTO
+using BASE_PROTO_TYPE = ::google::protobuf::MessageLite;
+#else
+using BASE_PROTO_TYPE = ::google::protobuf::Message;
+#endif
+
+// Generic type caster template for ONNX Proto classes
+#define ONNX_DEFINE_TYPE_CASTER(ProtoType, PythonClassName)                                       \
+  template <>                                                                                     \
+  struct nanobind::detail::type_caster<ONNX_NAMESPACE::ProtoType> {                               \
+   public:                                                                                        \
+    NB_TYPE_CASTER(ONNX_NAMESPACE::ProtoType, nanobind::detail::const_name(PythonClassName));     \
+                                                                                                  \
+    bool from_python(handle py_proto, uint8_t, cleanup_list*) noexcept {                          \
+      try {                                                                                       \
+        if (!nanobind::hasattr(py_proto, "SerializeToString")) {                                  \
+          return false;                                                                           \
+        }                                                                                         \
+        auto serialized = nanobind::cast<nanobind::bytes>(py_proto.attr("SerializeToString")());  \
+        return ParseProtoFromPyBytes(&value, serialized);                                         \
+      } catch (...) {                                                                             \
+        /* from_python is noexcept: nanobind::cast (cast_error) and ParseProtoFromPyBytes      */ \
+        /* (bad_alloc) can throw non-python_error types, which would otherwise call terminate. */ \
+        return false;                                                                             \
+      }                                                                                           \
+    }                                                                                             \
+                                                                                                  \
+    static handle from_cpp(                                                                       \
+        const ONNX_NAMESPACE::ProtoType& cpp_proto,                                               \
+        rv_policy /* policy */,                                                                   \
+        cleanup_list* /* cleanup */) noexcept {                                                   \
+      try {                                                                                       \
+        std::string serialized = cpp_proto.SerializeAsString();                                   \
+        auto py_proto = nanobind::module_::import_("onnx").attr(#ProtoType)();                    \
+        py_proto.attr("ParseFromString")(nanobind::bytes(serialized.c_str(), serialized.size())); \
+        return py_proto.release();                                                                \
+      } catch (...) {                                                                             \
+        return handle();                                                                          \
+      }                                                                                           \
+    }                                                                                             \
+  };
+
+// Define type casters for common ONNX proto types
+ONNX_DEFINE_TYPE_CASTER(AttributeProto, "onnx.AttributeProto")
+ONNX_DEFINE_TYPE_CASTER(TypeProto, "onnx.TypeProto")
+ONNX_DEFINE_TYPE_CASTER(TensorShapeProto, "onnx.TensorShapeProto")
+ONNX_DEFINE_TYPE_CASTER(TensorProto, "onnx.TensorProto")
+ONNX_DEFINE_TYPE_CASTER(SparseTensorProto, "onnx.SparseTensorProto")
+ONNX_DEFINE_TYPE_CASTER(ValueInfoProto, "onnx.ValueInfoProto")
+ONNX_DEFINE_TYPE_CASTER(NodeProto, "onnx.NodeProto")
+ONNX_DEFINE_TYPE_CASTER(GraphProto, "onnx.GraphProto")
+ONNX_DEFINE_TYPE_CASTER(ModelProto, "onnx.ModelProto")
+ONNX_DEFINE_TYPE_CASTER(FunctionProto, "onnx.FunctionProto")
+
+namespace ONNX_NAMESPACE {
+namespace nb = nanobind;
+
+// Serialize a proto message into Python bytes.
+static nb::bytes ProtoToBytes(const BASE_PROTO_TYPE& proto) {
+  std::string out = proto.SerializeAsString();
+  return nb::bytes(out.data(), out.size());
+}
+
+// Parse a vector of Python bytes into a vector of protos.
+template <typename ProtoType>
+static std::vector<ProtoType> ParseProtoVector(const std::vector<nb::bytes>& bytes_vec) {
+  std::vector<ProtoType> protos(bytes_vec.size());
+  for (size_t i = 0; i < bytes_vec.size(); ++i) {
+    ParseProtoFromPyBytes(&protos[i], bytes_vec[i]);
+  }
+  return protos;
+}
+
+// Cast a proto pointer to a Python object, returning None when null.
+template <typename T>
+static nb::object CastOrNone(const T* ptr) {
+  return ptr ? nb::cast(*ptr) : nb::none();
+}
+
+template <typename ProtoType>
+static std::tuple<bool, nb::bytes, nb::bytes> Parse(const char* cstr) {
+  ProtoType proto{};
+  OnnxParser parser(cstr);
+  auto status = parser.Parse(proto);
+  const std::string& error_msg = status.ErrorMessage();
+  return std::make_tuple(status.IsOK(), nb::bytes(error_msg.c_str(), error_msg.size()), ProtoToBytes(proto));
+}
+
+template <typename ProtoType>
+static std::string ProtoBytesToText(const nb::bytes& bytes) {
+  ProtoType proto{};
+  ParseProtoFromPyBytes(&proto, bytes);
+  return ProtoToString(proto);
+}
+
+template <typename T, typename Ts = std::remove_const_t<T>>
+static std::pair<std::vector<Ts>, std::unordered_map<std::string, T*>> ParseProtoFromBytesMap(
+    const std::unordered_map<std::string, nb::bytes>& bytesMap) {
+  std::vector<Ts> values(bytesMap.size());
+  std::unordered_map<std::string, T*> result;
+  size_t i = 0;
+  for (const auto& [key, bytes] : bytesMap) {
+    ParseProtoFromPyBytes(&values[i], bytes);
+    result[key] = &values[i];
+    i++;
+  }
+  // C++ guarantees that the pointers remain valid after std::vector<Ts> is moved.
+  return std::make_pair(std::move(values), result);
+}
+
+static std::unordered_map<std::string, nb::bytes> CallNodeInferenceFunction(
+    OpSchema* schema,
+    const nb::bytes& nodeBytes,
+    const std::unordered_map<std::string, nb::bytes>& valueTypesByNameBytes,
+    const std::unordered_map<std::string, nb::bytes>& inputDataByNameBytes,
+    const std::unordered_map<std::string, nb::bytes>& inputSparseDataByNameBytes,
+    std::unordered_map<std::string, int> opsetImports,
+    const int irVersion) {
+  NodeProto node{};
+  ParseProtoFromPyBytes(&node, nodeBytes);
+  // Early fail if node is badly defined - may throw ValidationError
+  schema->Verify(node);
+
+  // Convert arguments to C++ types, allocating memory
+  const auto& valueTypes = ParseProtoFromBytesMap<TypeProto>(valueTypesByNameBytes);
+  const auto& inputData = ParseProtoFromBytesMap<const TensorProto>(inputDataByNameBytes);
+  const auto& inputSparseData = ParseProtoFromBytesMap<const SparseTensorProto>(inputSparseDataByNameBytes);
+  if (opsetImports.empty()) {
+    opsetImports[schema->domain()] = schema->SinceVersion();
+  }
+
+  shape_inference::GraphInferenceContext graphInferenceContext(
+      valueTypes.second, opsetImports, nullptr, {}, OpSchemaRegistry::Instance(), nullptr, irVersion);
+  // Construct inference context and get results - may throw InferenceError
+  // TODO(ONNX): if it is desirable for infer_node_outputs to provide check_type, strict_mode, data_prop,
+  // we can add them to the Python API. For now we just assume the default options.
+  ShapeInferenceOptions options{false, 0, false};
+  shape_inference::InferenceContextImpl ctx(
+      node, valueTypes.second, inputData.second, inputSparseData.second, options, nullptr, &graphInferenceContext);
+  schema->GetTypeAndShapeInferenceFunction()(ctx);
+  // Verify the inference succeeded - may also throw ValidationError
+  // Note that input types were not validated until now (except that their count was correct)
+  schema->CheckInputOutputType(ctx);
+
+  // Convert back into bytes returned to Python
+  std::unordered_map<std::string, nb::bytes> typeProtoBytes;
+  for (size_t i = 0; i < ctx.allOutputTypes_.size(); i++) {
+    const auto& proto = ctx.allOutputTypes_[i];
+    if (proto.IsInitialized()) {
+      typeProtoBytes[node.output(static_cast<int>(i))] = ProtoToBytes(proto);
+    }
+  }
+
+  return typeProtoBytes;
+}
+
+template <typename T>
+static std::tuple<std::vector<T>, std::vector<const T*>> ConvertPyObjToPtr(const std::vector<nb::object>& pyObjs) {
+  std::vector<T> objs;
+  std::vector<const T*> ptrs;
+  objs.reserve(pyObjs.size());
+  ptrs.reserve(pyObjs.size());
+  for (const auto& obj : pyObjs) {
+    if (obj.is_none()) {
+      ptrs.push_back(nullptr);
+      continue;
+    }
+    objs.emplace_back(nanobind::cast<T>(obj));
+    ptrs.push_back(&objs.back());
+  }
+  return std::make_tuple(std::move(objs), std::move(ptrs));
+}
+
+// Build a binding that parses a proto from Python bytes and runs the given
+// checker function on it. The proto type and the trailing context arguments
+// are deduced from the checker's signature, so this covers both the 2-arg
+// (CheckerContext) and 3-arg (CheckerContext + LexicalScopeContext) checkers.
+template <typename ProtoType, typename... Ctx>
+static auto MakeChecker(void (*check_fn)(const ProtoType&, const Ctx&...)) {
+  return [check_fn](const nb::bytes& bytes, const Ctx&... ctx) {
+    ProtoType proto{};
+    ParseProtoFromPyBytes(&proto, bytes);
+    check_fn(proto, ctx...);
+  };
+}
+
+NB_MODULE(onnx_cpp2py_export, onnx_cpp2py_export) {
+  // Disabling nanobind leak warnings
+  // TODO(#7283): Avoid leaks if possible
+  nb::set_leak_warnings(false);
+
+  onnx_cpp2py_export.doc() = "Python interface to ONNX";
+
+  onnx_cpp2py_export.attr("ONNX_ML") = nb::bool_(
+#ifdef ONNX_ML
+      true
+#else // ONNX_ML
+      false
+#endif // ONNX_ML
+  );
+
+  // Submodule `schema`
+  auto defs = onnx_cpp2py_export.def_submodule("defs");
+  defs.doc() = "Schema submodule";
+  nb::exception<SchemaError>(defs, "SchemaError"); // NOLINT(bugprone-unused-raii,bugprone-throw-keyword-missing)
+
+  nb::class_<OpSchema> op_schema(defs, "OpSchema", "Schema of an operator.");
+
+  // Define the class enums first because they are used as default values in function definitions
+  nb::enum_<OpSchema::FormalParameterOption>(op_schema, "FormalParameterOption", nb::is_arithmetic())
+      .value("Single", OpSchema::Single)
+      .value("Optional", OpSchema::Optional)
+      .value("Variadic", OpSchema::Variadic);
+
+  nb::enum_<OpSchema::DifferentiationCategory>(op_schema, "DifferentiationCategory", nb::is_arithmetic())
+      .value("Unknown", OpSchema::Unknown)
+      .value("Differentiable", OpSchema::Differentiable)
+      .value("NonDifferentiable", OpSchema::NonDifferentiable);
+
+  nb::enum_<OpSchema::NodeDeterminism>(op_schema, "NodeDeterminism")
+      .value("Deterministic", OpSchema::NodeDeterminism::Deterministic)
+      .value("NonDeterministic", OpSchema::NodeDeterminism::NonDeterministic)
+      .value("Unknown", OpSchema::NodeDeterminism::Unknown);
+
+  nb::enum_<AttributeProto::AttributeType>(op_schema, "AttrType", nb::is_arithmetic())
+      .value("FLOAT", AttributeProto::FLOAT)
+      .value("INT", AttributeProto::INT)
+      .value("STRING", AttributeProto::STRING)
+      .value("TENSOR", AttributeProto::TENSOR)
+      .value("GRAPH", AttributeProto::GRAPH)
+      .value("FLOATS", AttributeProto::FLOATS)
+      .value("INTS", AttributeProto::INTS)
+      .value("STRINGS", AttributeProto::STRINGS)
+      .value("TENSORS", AttributeProto::TENSORS)
+      .value("GRAPHS", AttributeProto::GRAPHS)
+      .value("SPARSE_TENSOR", AttributeProto::SPARSE_TENSOR)
+      .value("SPARSE_TENSORS", AttributeProto::SPARSE_TENSORS)
+      .value("TYPE_PROTO", AttributeProto::TYPE_PROTO)
+      .value("TYPE_PROTOS", AttributeProto::TYPE_PROTOS);
+
+  nb::enum_<OpSchema::SupportType>(op_schema, "SupportType", nb::is_arithmetic())
+      .value("COMMON", OpSchema::SupportType::COMMON)
+      .value("EXPERIMENTAL", OpSchema::SupportType::EXPERIMENTAL);
+
+  nb::class_<OpSchema::Attribute>(op_schema, "Attribute")
+      .def(
+          "__init__",
+          [](OpSchema::Attribute* self,
+             std::string name,
+             AttributeProto::AttributeType type,
+             std::string description,
+             bool required) {
+            // Construct an attribute.
+            // Use a lambda to swap the order of the arguments to match the Python API
+            new (self) OpSchema::Attribute(std::move(name), std::move(description), type, required);
+          },
+          nb::arg("name"),
+          nb::arg("type"),
+          nb::arg("description") = "",
+          nb::kw_only(),
+          nb::arg("required") = true)
+      .def(
+          "__init__",
+          [](OpSchema::Attribute* self, std::string name, const nb::object& default_value, std::string description) {
+            // Construct an attribute with a default value.
+            // Attributes with default values are not required
+            auto bytes = nb::cast<nb::bytes>(default_value.attr("SerializeToString")());
+            AttributeProto proto{};
+            ParseProtoFromPyBytes(&proto, bytes);
+            new (self) OpSchema::Attribute(std::move(name), std::move(description), std::move(proto));
+          },
+          nb::arg("name"),
+          nb::arg("default_value"), // type: onnx.AttributeProto
+          nb::arg("description") = "")
+      .def_ro("name", &OpSchema::Attribute::name)
+      .def_ro("description", &OpSchema::Attribute::description)
+      .def_ro("type", &OpSchema::Attribute::type)
+      .def_prop_ro(
+          "_default_value", [](OpSchema::Attribute* attr) -> nb::bytes { return ProtoToBytes(attr->default_value); })
+      .def_ro("required", &OpSchema::Attribute::required);
+
+  nb::class_<OpSchema::TypeConstraintParam>(op_schema, "TypeConstraintParam")
+      .def(
+          nb::init<std::string, std::vector<std::string>, std::string>(),
+          nb::arg("type_param_str"),
+          nb::arg("allowed_type_strs"),
+          nb::arg("description") = "")
+      .def_ro("type_param_str", &OpSchema::TypeConstraintParam::type_param_str)
+      .def_ro("allowed_type_strs", &OpSchema::TypeConstraintParam::allowed_type_strs)
+      .def_ro("description", &OpSchema::TypeConstraintParam::description);
+
+  nb::class_<OpSchema::FormalParameter>(op_schema, "FormalParameter")
+      .def(
+          "__init__",
+          [](OpSchema::FormalParameter* self,
+             std::string name,
+             std::string type_str,
+             const std::string& description,
+             OpSchema::FormalParameterOption param_option,
+             bool is_homogeneous,
+             int min_arity,
+             OpSchema::DifferentiationCategory differentiation_category) {
+            // Use a lambda to swap the order of the arguments to match the Python API
+            new (self) OpSchema::FormalParameter(
+                std::move(name),
+                description,
+                std::move(type_str),
+                param_option,
+                is_homogeneous,
+                min_arity,
+                differentiation_category);
+          },
+          nb::arg("name"),
+          nb::arg("type_str"),
+          nb::arg("description") = "",
+          nb::kw_only(),
+          nb::arg("param_option") = OpSchema::Single,
+          nb::arg("is_homogeneous") = true,
+          nb::arg("min_arity") = 1,
+          nb::arg("differentiation_category") = OpSchema::DifferentiationCategory::Unknown)
+
+      .def_prop_ro("name", &OpSchema::FormalParameter::GetName)
+      .def_prop_ro("types", &OpSchema::FormalParameter::GetTypes)
+      .def_prop_ro("type_str", &OpSchema::FormalParameter::GetTypeStr)
+      .def_prop_ro("description", &OpSchema::FormalParameter::GetDescription)
+      .def_prop_ro("option", &OpSchema::FormalParameter::GetOption)
+      .def_prop_ro("is_homogeneous", &OpSchema::FormalParameter::GetIsHomogeneous)
+      .def_prop_ro("min_arity", &OpSchema::FormalParameter::GetMinArity)
+      .def_prop_ro("differentiation_category", &OpSchema::FormalParameter::GetDifferentiationCategory);
+
+  op_schema
+      .def(
+          "__init__",
+          [](OpSchema* self,
+             std::string name,
+             std::string domain,
+             int since_version,
+             const std::string& doc,
+             std::vector<OpSchema::FormalParameter> inputs,
+             std::vector<OpSchema::FormalParameter> outputs,
+             std::vector<std::tuple<std::string, std::vector<std::string>, std::string>> type_constraints,
+             std::vector<OpSchema::Attribute> attributes,
+             OpSchema::NodeDeterminism node_determinism) {
+            new (self) OpSchema();
+
+            self->SetName(std::move(name)).SetDomain(std::move(domain)).SinceVersion(since_version).SetDoc(doc);
+            self->SetNodeDeterminism(node_determinism);
+            // Add inputs and outputs
+            for (size_t i = 0; i < inputs.size(); ++i) {
+              self->Input(static_cast<int>(i), std::move(inputs[i]));
+            }
+            for (size_t i = 0; i < outputs.size(); ++i) {
+              self->Output(static_cast<int>(i), std::move(outputs[i]));
+            }
+            // Add type constraints
+            for (auto& [type_str, constraints, description] : type_constraints) {
+              self->TypeConstraint(std::move(type_str), std::move(constraints), std::move(description));
+            }
+            // Add attributes
+            for (auto& attribute : attributes) {
+              self->Attr(std::move(attribute));
+            }
+
+            self->Finalize();
+          },
+          nb::arg("name"),
+          nb::arg("domain"),
+          nb::arg("since_version"),
+          nb::arg("doc") = "",
+          nb::kw_only(),
+          nb::arg("inputs") = std::vector<OpSchema::FormalParameter>{},
+          nb::arg("outputs") = std::vector<OpSchema::FormalParameter>{},
+          nb::arg("type_constraints") = std::vector<std::tuple<
+              std::string /* type_str */,
+              std::vector<std::string> /* constraints */,
+              std::string /* description */>>{},
+          nb::arg("attributes") = std::vector<OpSchema::Attribute>{},
+          nb::arg("node_determinism") = OpSchema::NodeDeterminism::Unknown)
+      .def_prop_rw("name", &OpSchema::Name, [](OpSchema& self, const std::string& name) { self.SetName(name); })
+      .def_prop_rw(
+          "domain", &OpSchema::domain, [](OpSchema& self, const std::string& domain) { self.SetDomain(domain); })
+      .def_prop_rw("doc", &OpSchema::doc, [](OpSchema& self, const std::string& doc) { self.SetDoc(doc); })
+      .def_prop_ro("file", &OpSchema::file)
+      .def_prop_ro("line", &OpSchema::line)
+      .def_prop_ro("support_level", &OpSchema::support_level)
+      .def_prop_ro("since_version", &OpSchema::since_version)
+      .def_prop_ro("deprecated", &OpSchema::deprecated)
+      .def_prop_ro("function_opset_versions", &OpSchema::function_opset_versions)
+      .def_prop_ro("context_dependent_function_opset_versions", &OpSchema::context_dependent_function_opset_versions)
+      .def_prop_ro(
+          "all_function_opset_versions",
+          [](OpSchema* op) -> std::vector<int> {
+            std::vector<int> all_function_opset_versions = op->function_opset_versions();
+            std::vector<int> context_dependent_function_opset_versions =
+                op->context_dependent_function_opset_versions();
+            all_function_opset_versions.insert(
+                all_function_opset_versions.end(),
+                context_dependent_function_opset_versions.begin(),
+                context_dependent_function_opset_versions.end());
+            std::sort(all_function_opset_versions.begin(), all_function_opset_versions.end());
+            all_function_opset_versions.erase(
+                std::unique(all_function_opset_versions.begin(), all_function_opset_versions.end()),
+                all_function_opset_versions.end());
+            return all_function_opset_versions;
+          })
+      .def_prop_ro("min_input", &OpSchema::min_input)
+      .def_prop_ro("max_input", &OpSchema::max_input)
+      .def_prop_ro("min_output", &OpSchema::min_output)
+      .def_prop_ro("max_output", &OpSchema::max_output)
+      .def_prop_ro("attributes", &OpSchema::attributes)
+      .def_prop_ro("inputs", &OpSchema::inputs)
+      .def_prop_ro("outputs", &OpSchema::outputs)
+      .def_prop_ro("has_type_and_shape_inference_function", &OpSchema::has_type_and_shape_inference_function)
+      .def_prop_ro("has_data_propagation_function", &OpSchema::has_data_propagation_function)
+      .def_prop_ro("type_constraints", &OpSchema::typeConstraintParams)
+      .def_prop_ro("node_determinism", &OpSchema::GetNodeDeterminism)
+      .def_static("is_infinite", [](int v) { return v == std::numeric_limits<int>::max(); })
+      .def(
+          "_infer_node_outputs",
+          CallNodeInferenceFunction,
+          nb::arg("nodeBytes"),
+          nb::arg("valueTypesByNameBytes"),
+          nb::arg("inputDataByNameBytes") = std::unordered_map<std::string, nb::bytes>{},
+          nb::arg("inputSparseDataByNameBytes") = std::unordered_map<std::string, nb::bytes>{},
+          nb::arg("opsetImports") = std::unordered_map<std::string, int>{},
+          nb::arg("irVersion") = static_cast<int>(IR_VERSION))
+      .def_prop_ro("has_function", &OpSchema::HasFunction)
+      .def_prop_ro(
+          "_function_body",
+          [](OpSchema* op) -> nb::bytes {
+            return op->HasFunction() ? ProtoToBytes(*op->GetFunction()) : nb::bytes("", 0);
+          })
+      .def(
+          "get_function_with_opset_version",
+          [](OpSchema* op, int opset_version) -> nb::bytes {
+            const FunctionProto* function_proto = op->GetFunction(opset_version);
+            return function_proto ? ProtoToBytes(*function_proto) : nb::bytes("", 0);
+          })
+      .def_prop_ro("has_context_dependent_function", &OpSchema::HasContextDependentFunction)
+      .def(
+          "get_context_dependent_function",
+          [](OpSchema* op, const nb::bytes& bytes, const std::vector<nb::bytes>& input_types_bytes) -> nb::bytes {
+            NodeProto proto{};
+            ParseProtoFromPyBytes(&proto, bytes);
+            if (op->HasContextDependentFunction()) {
+              std::vector<TypeProto> input_types = ParseProtoVector<TypeProto>(input_types_bytes);
+              FunctionBodyBuildContextImpl ctx(proto, input_types);
+              FunctionProto func_proto;
+              op->BuildContextDependentFunction(ctx, func_proto);
+              return ProtoToBytes(func_proto);
+            }
+            return nb::bytes("", 0);
+          })
+      .def(
+          "get_context_dependent_function_with_opset_version",
+          [](OpSchema* op, int opset_version, const nb::bytes& bytes, const std::vector<nb::bytes>& input_types_bytes)
+              -> nb::bytes {
+            NodeProto proto{};
+            ParseProtoFromPyBytes(&proto, bytes);
+            if (op->HasContextDependentFunctionWithOpsetVersion(opset_version)) {
+              std::vector<TypeProto> input_types = ParseProtoVector<TypeProto>(input_types_bytes);
+              FunctionBodyBuildContextImpl ctx(proto, input_types);
+              FunctionProto func_proto;
+              op->BuildContextDependentFunction(ctx, func_proto, opset_version);
+              return ProtoToBytes(func_proto);
+            }
+            return nb::bytes("", 0);
+          })
+      .def(
+          "set_type_and_shape_inference_function",
+          [](OpSchema& op, const std::function<void(InferenceContext*)>& func) -> OpSchema& {
+            auto wrapper = [=](InferenceContext& ctx) { func(&ctx); };
+            return op.TypeAndShapeInferenceFunction(wrapper);
+          },
+          nb::rv_policy::reference_internal)
+      .def("get_type_and_shape_inference_function", &OpSchema::GetTypeAndShapeInferenceFunction);
+
+  defs.def(
+          "has_schema",
+          [](const std::string& op_type, const std::string& domain) -> bool {
+            return OpSchemaRegistry::Schema(op_type, domain) != nullptr;
+          },
+          nb::arg("op_type"),
+          nb::arg("domain") = ONNX_DOMAIN)
+      .def(
+          "has_schema",
+          [](const std::string& op_type, int max_inclusive_version, const std::string& domain) -> bool {
+            return OpSchemaRegistry::Schema(op_type, max_inclusive_version, domain) != nullptr;
+          },
+          nb::arg("op_type"),
+          nb::arg("max_inclusive_version"),
+          nb::arg("domain") = ONNX_DOMAIN)
+      .def(
+          "schema_version_map",
+          []() -> std::unordered_map<std::string, std::pair<int, int>> {
+            return OpSchemaRegistry::DomainToVersionRange::Instance().Map();
+          })
+      .def(
+          "get_schema",
+          [](const std::string& op_type, const int max_inclusive_version, const std::string& domain) -> OpSchema {
+            const auto* const schema = OpSchemaRegistry::Schema(op_type, max_inclusive_version, domain);
+            if (!schema) {
+              fail_schema(
+                  "No schema registered for '" + op_type + "' version '" + std::to_string(max_inclusive_version) +
+                  "' and domain '" + domain + "'!");
+            }
+            return *schema;
+          },
+          nb::arg("op_type"),
+          nb::arg("max_inclusive_version"),
+          nb::arg("domain") = ONNX_DOMAIN,
+          "Return the schema of the operator *op_type* and for a specific version.")
+      .def(
+          "get_schema",
+          [](const std::string& op_type, const std::string& domain) -> OpSchema {
+            const auto* const schema = OpSchemaRegistry::Schema(op_type, domain);
+            if (!schema) {
+              fail_schema("No schema registered for '" + op_type + "' and domain '" + domain + "'!");
+            }
+            return *schema;
+          },
+          nb::arg("op_type"),
+          nb::arg("domain") = ONNX_DOMAIN,
+          "Return the schema of the operator *op_type* and for a specific version.")
+      .def(
+          "get_all_schemas",
+          []() -> std::vector<OpSchema> { return OpSchemaRegistry::get_all_schemas(); },
+          "Return the schema of all existing operators for the latest version.")
+      .def(
+          "get_all_schemas_with_history",
+          []() -> std::vector<OpSchema> { return OpSchemaRegistry::get_all_schemas_with_history(); },
+          "Return the schema of all existing operators and all versions.")
+      .def(
+          "set_domain_to_version",
+          [](const std::string& domain, int min_version, int max_version, int last_release_version) {
+            auto& obj = OpSchemaRegistry::DomainToVersionRange::Instance();
+            if (obj.Map().count(domain) == 0) {
+              obj.AddDomainToVersion(domain, min_version, max_version, last_release_version);
+            } else {
+              obj.UpdateDomainToVersion(domain, min_version, max_version, last_release_version);
+            }
+          },
+          nb::arg("domain"),
+          nb::arg("min_version"),
+          nb::arg("max_version"),
+          nb::arg("last_release_version") = -1,
+          "Set the version range and last release version of the specified domain.")
+      .def(
+          "register_schema",
+          [](OpSchema schema) { RegisterSchema(std::move(schema), 0, true, true); },
+          nb::arg("schema"),
+          "Register a user provided OpSchema.")
+      .def(
+          "deregister_schema",
+          &DeregisterSchema,
+          nb::arg("op_type"),
+          nb::arg("version"),
+          nb::arg("domain"),
+          "Deregister the specified OpSchema.");
+
+  // Submodule `checker`
+  auto checker = onnx_cpp2py_export.def_submodule("checker");
+  checker.doc() = "Checker submodule";
+
+  nb::class_<checker::CheckerContext> checker_context(checker, "CheckerContext");
+  checker_context.def(nb::init<>())
+      .def_prop_rw("ir_version", &checker::CheckerContext::get_ir_version, &checker::CheckerContext::set_ir_version)
+      .def_prop_rw(
+          "opset_imports", &checker::CheckerContext::get_opset_imports, &checker::CheckerContext::set_opset_imports);
+
+  nb::class_<checker::LexicalScopeContext> lexical_scope_context(checker, "LexicalScopeContext");
+  lexical_scope_context.def(nb::init<>());
+
+  nb::exception<checker::ValidationError>( // NOLINT(bugprone-unused-raii,bugprone-throw-keyword-missing)
+      checker,
+      "ValidationError");
+
+  checker.def("check_value_info", MakeChecker(checker::check_value_info));
+  checker.def("check_tensor", MakeChecker(checker::check_tensor));
+  checker.def("check_sparse_tensor", MakeChecker(checker::check_sparse_tensor));
+  checker.def("check_attribute", MakeChecker(checker::check_attribute));
+  checker.def("check_node", MakeChecker(checker::check_node));
+  checker.def("check_function", MakeChecker(checker::check_function));
+  checker.def("check_graph", MakeChecker(checker::check_graph));
+
+  checker.def(
+      "check_model",
+      [](const nb::bytes& bytes, bool full_check, bool skip_opset_compatibility_check, bool check_custom_domain)
+          -> void {
+        ModelProto proto{};
+        ParseProtoFromPyBytes(&proto, bytes);
+        checker::check_model(proto, full_check, skip_opset_compatibility_check, check_custom_domain);
+      },
+      nb::arg("bytes"),
+      nb::arg("full_check") = false,
+      nb::arg("skip_opset_compatibility_check") = false,
+      nb::arg("check_custom_domain") = false);
+
+  checker.def(
+      "check_model_path",
+      static_cast<void (*)(
+          const std::string& path, bool full_check, bool skip_opset_compatibility_check, bool check_custom_domain)>(
+          &checker::check_model),
+      nb::arg("path"),
+      nb::arg("full_check") = false,
+      nb::arg("skip_opset_compatibility_check") = false,
+      nb::arg("check_custom_domain") = false);
+
+  checker.def("_open_external_data", &checker::open_external_data);
+
+  // Submodule `version_converter`
+  auto version_converter = onnx_cpp2py_export.def_submodule("version_converter");
+  version_converter.doc() = "VersionConverter submodule";
+  nb::exception<ConvertError>( // NOLINT(bugprone-unused-raii,bugprone-throw-keyword-missing)
+      version_converter,
+      "ConvertError");
+
+  version_converter.def("convert_version", [](const nb::bytes& bytes, int target) {
+    ModelProto proto{};
+    ParseProtoFromPyBytes(&proto, bytes);
+    shape_inference::InferShapes(proto);
+    return ProtoToBytes(version_conversion::ConvertVersion(proto, target));
+  });
+
+  // Submodule `inliner`
+  auto inliner = onnx_cpp2py_export.def_submodule("inliner");
+  inliner.doc() = "Inliner submodule";
+
+  inliner.def("inline_local_functions", [](const nb::bytes& bytes, bool convert_version) {
+    ModelProto model{};
+    ParseProtoFromPyBytes(&model, bytes);
+    inliner::InlineLocalFunctions(model, convert_version);
+    return ProtoToBytes(model);
+  });
+
+  // inline_selected_functions: Inlines all functions specified in function_ids, unless
+  // exclude is true, in which case it inlines all functions except those specified in
+  // function_ids.
+  inliner.def(
+      "inline_selected_functions",
+      [](const nb::bytes& bytes, std::vector<std::pair<std::string, std::string>> function_ids, bool exclude) {
+        ModelProto model{};
+        ParseProtoFromPyBytes(&model, bytes);
+        auto function_id_set = inliner::FunctionIdSet::Create(std::move(function_ids), exclude);
+        inliner::InlineSelectedLocalFunctions(model, *function_id_set);
+        return ProtoToBytes(model);
+      });
+
+  inliner.def(
+      "inline_selected_functions2",
+      [](const nb::bytes& bytes, std::vector<std::pair<std::string, std::string>> function_ids, bool exclude) {
+        ModelProto model{};
+        ParseProtoFromPyBytes(&model, bytes);
+        auto function_id_set = inliner::FunctionIdSet::Create(std::move(function_ids), exclude);
+        inliner::InlineSelectedFunctions(model, *function_id_set, nullptr);
+        return ProtoToBytes(model);
+      });
+
+  // Submodule `shape_inference`
+  auto shape_inference = onnx_cpp2py_export.def_submodule("shape_inference");
+  shape_inference.doc() = "Shape Inference submodule";
+  nb::exception<InferenceError>( // NOLINT(bugprone-unused-raii,bugprone-throw-keyword-missing)
+      shape_inference,
+      "InferenceError");
+
+  nb::class_<InferenceContext> inference_context(shape_inference, "InferenceContext", "Inference context");
+
+  inference_context.def("get_attribute", [](InferenceContext& self, const std::string& name) {
+    return CastOrNone(self.getAttribute(name));
+  });
+  inference_context.def("get_num_inputs", &InferenceContext::getNumInputs);
+  inference_context.def(
+      "get_input_type", [](InferenceContext& self, size_t idx) { return CastOrNone(self.getInputType(idx)); });
+  inference_context.def("has_input", &InferenceContext::hasInput);
+  inference_context.def(
+      "get_input_data", [](InferenceContext& self, size_t idx) { return CastOrNone(self.getInputData(idx)); });
+  inference_context.def("get_num_outputs", &InferenceContext::getNumOutputs);
+  inference_context.def(
+      "get_output_type", [](InferenceContext& self, size_t idx) { return CastOrNone(self.getOutputType(idx)); });
+  inference_context.def("set_output_type", [](InferenceContext& self, size_t idx, const TypeProto& src) {
+    auto* dst = self.getOutputType(idx);
+    if (dst == nullptr) {
+      return false;
+    }
+    dst->CopyFrom(src);
+    return true;
+  });
+  inference_context.def("has_output", &InferenceContext::hasOutput);
+  inference_context.def(
+      "get_graph_attribute_inferencer",
+      &InferenceContext::getGraphAttributeInferencer,
+      nb::rv_policy::reference_internal);
+  inference_context.def("get_input_sparse_data", [](InferenceContext& self, size_t idx) {
+    return CastOrNone(self.getInputSparseData(idx));
+  });
+  inference_context.def(
+      "get_symbolic_input", [](InferenceContext& self, size_t idx) { return CastOrNone(self.getSymbolicInput(idx)); });
+  inference_context.def("get_display_name", &InferenceContext::getDisplayName);
+
+  nb::class_<GraphInferencer> graph_inferencer(shape_inference, "GraphInferencer", "Graph Inferencer");
+  graph_inferencer.def(
+      "do_inferencing",
+      [](GraphInferencer& self,
+         const std::vector<nb::object>& inputTypesObj,
+         const std::vector<nb::object>& inputDataObj) {
+        auto inputTypesTuple = ConvertPyObjToPtr<ONNX_NAMESPACE::TypeProto>(inputTypesObj);
+        auto inputDataTuple = ConvertPyObjToPtr<ONNX_NAMESPACE::TensorProto>(inputDataObj);
+        auto ret = self.doInferencing(std::get<1>(inputTypesTuple), std::get<1>(inputDataTuple));
+        std::vector<nb::object> ret_obj(ret.size());
+        for (size_t i = 0; i < ret.size(); ++i) {
+          ret_obj[i] = nb::cast(ret[i]);
+        }
+        return ret_obj;
+      });
+
+  shape_inference.def(
+      "infer_shapes",
+      [](const nb::bytes& bytes, bool check_type, bool strict_mode, bool data_prop) {
+        ModelProto proto{};
+        ParseProtoFromPyBytes(&proto, bytes);
+        ShapeInferenceOptions options{check_type, strict_mode ? 1 : 0, data_prop};
+        shape_inference::InferShapes(proto, OpSchemaRegistry::Instance(), options);
+        return ProtoToBytes(proto);
+      },
+      nb::arg("bytes"),
+      nb::arg("check_type") = false,
+      nb::arg("strict_mode") = false,
+      nb::arg("data_prop") = false);
+
+  shape_inference.def(
+      "infer_shapes_path",
+      [](const std::string& model_path,
+         const std::string& output_path,
+         bool check_type,
+         bool strict_mode,
+         bool data_prop) -> void {
+        ShapeInferenceOptions options{check_type, strict_mode ? 1 : 0, data_prop};
+        shape_inference::InferShapes(model_path, output_path, OpSchemaRegistry::Instance(), options);
+      });
+
+  shape_inference.def(
+      "infer_function_output_types",
+      [](const nb::bytes& function_proto_bytes,
+         const std::vector<nb::bytes>& input_types_bytes,
+         const std::vector<nb::bytes>& attributes_bytes) -> std::vector<nb::bytes> {
+        FunctionProto proto{};
+        ParseProtoFromPyBytes(&proto, function_proto_bytes);
+
+        std::vector<TypeProto> input_types = ParseProtoVector<TypeProto>(input_types_bytes);
+        std::vector<AttributeProto> attributes = ParseProtoVector<AttributeProto>(attributes_bytes);
+
+        std::vector<TypeProto> output_types = shape_inference::InferFunctionOutputTypes(proto, input_types, attributes);
+        std::vector<nb::bytes> result;
+        result.reserve(output_types.size());
+        for (const auto& type_proto : output_types) {
+          result.push_back(ProtoToBytes(type_proto));
+        }
+        return result;
+      });
+
+  // Submodule `parser`
+  auto parser = onnx_cpp2py_export.def_submodule("parser");
+  parser.doc() = "Parser submodule";
+
+  parser.def("parse_model", Parse<ModelProto>);
+  parser.def("parse_graph", Parse<GraphProto>);
+  parser.def("parse_function", Parse<FunctionProto>);
+  parser.def("parse_node", Parse<NodeProto>);
+
+  // Submodule `printer`
+  auto printer = onnx_cpp2py_export.def_submodule("printer");
+  printer.doc() = "Printer submodule";
+
+  printer.def("model_to_text", ProtoBytesToText<ModelProto>);
+  printer.def("function_to_text", ProtoBytesToText<FunctionProto>);
+  printer.def("graph_to_text", ProtoBytesToText<GraphProto>);
+  printer.def("node_to_text", ProtoBytesToText<NodeProto>);
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/CMakeLists.txt b/onnx/defs/CMakeLists.txt
new file mode 100644
index 0000000..835b815
--- /dev/null
+++ b/onnx/defs/CMakeLists.txt
@@ -0,0 +1,54 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    attr_proto_util.cc
+    attr_proto_util.h
+    data_propagators.h
+    data_type_utils.cc
+    data_type_utils.h
+    doc_strings.cc
+    doc_strings.h
+    function.cc
+    function.h
+    operator_sets.h
+    operator_sets_ml.h
+    operator_sets_preview.h
+    operator_sets_training.h
+    parser.cc
+    parser.h
+    printer.cc
+    printer.h
+    schema.cc
+    schema.h
+    shape_inference.cc
+    shape_inference.h
+    tensor_proto_util.cc
+    tensor_proto_util.h
+    tensor_util.cc
+    tensor_util.h
+)
+
+add_subdirectory(controlflow)
+add_subdirectory(generator)
+add_subdirectory(image)
+add_subdirectory(logical)
+add_subdirectory(math)
+add_subdirectory(nn)
+add_subdirectory(object_detection)
+add_subdirectory(optional)
+add_subdirectory(preview)
+add_subdirectory(quantization)
+add_subdirectory(reduction)
+add_subdirectory(rnn)
+add_subdirectory(sequence)
+add_subdirectory(tensor)
+add_subdirectory(text)
+add_subdirectory(traditionalml)
+add_subdirectory(training)
+
+# These files exhibit issues in unity builds, so we disable them.
+set_source_files_properties(schema.cc tensor_proto_util.cc
+    TARGET_DIRECTORY onnx
+    PROPERTIES SKIP_UNITY_BUILD_INCLUSION TRUE
+)
diff --git a/onnx/defs/__init__.py b/onnx/defs/__init__.py
new file mode 100644
index 0000000..911bc9d
--- /dev/null
+++ b/onnx/defs/__init__.py
@@ -0,0 +1,158 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = [
+    "C",
+    "ONNX_DOMAIN",
+    "ONNX_ML_DOMAIN",
+    "AI_ONNX_PREVIEW_DOMAIN",
+    "AI_ONNX_PREVIEW_TRAINING_DOMAIN",
+    "has",
+    "register_schema",
+    "deregister_schema",
+    "get_schema",
+    "get_all_schemas",
+    "get_all_schemas_with_history",
+    "onnx_opset_version",
+    "get_function_ops",
+    "OpSchema",
+    "SchemaError",
+]
+
+import onnx
+import onnx.onnx_cpp2py_export.defs as C  # noqa: N812
+
+ONNX_DOMAIN = ""
+ONNX_ML_DOMAIN = "ai.onnx.ml"
+AI_ONNX_PREVIEW_DOMAIN = "ai.onnx.preview"
+AI_ONNX_PREVIEW_TRAINING_DOMAIN = "ai.onnx.preview.training"
+
+
+has = C.has_schema
+get_schema = C.get_schema
+get_all_schemas = C.get_all_schemas
+get_all_schemas_with_history = C.get_all_schemas_with_history
+deregister_schema = C.deregister_schema
+
+
+def onnx_opset_version() -> int:
+    """Return current opset for domain `ai.onnx`."""
+    return C.schema_version_map()[ONNX_DOMAIN][1]
+
+
+def onnx_ml_opset_version() -> int:
+    """Return current opset for domain `ai.onnx.ml`."""
+    return C.schema_version_map()[ONNX_ML_DOMAIN][1]
+
+
+@property  # type: ignore[misc]
+def _function_proto(self):
+    func_proto = onnx.FunctionProto()
+    func_proto.ParseFromString(self._function_body)
+    return func_proto
+
+
+OpSchema = C.OpSchema
+OpSchema.function_body = _function_proto  # type: ignore[method-assign]
+
+
+@property  # type: ignore[misc]
+def _non_deterministic(self):
+    """Check if the operator is non-deterministic."""
+    return self.node_determinism != OpSchema.NodeDeterminism.Deterministic
+
+
+OpSchema.non_deterministic = _non_deterministic  # type: ignore[attr-defined]
+
+
+@property  # type: ignore[misc]
+def _attribute_default_value(self):
+    attr = onnx.AttributeProto()
+    attr.ParseFromString(self._default_value)
+    return attr
+
+
+OpSchema.Attribute.default_value = _attribute_default_value  # type: ignore[method-assign]
+
+
+def _op_schema_repr(self) -> str:
+    return f"""\
+OpSchema(
+    name={self.name!r},
+    domain={self.domain!r},
+    since_version={self.since_version!r},
+    doc={self.doc!r},
+    type_constraints={self.type_constraints!r},
+    inputs={self.inputs!r},
+    outputs={self.outputs!r},
+    attributes={self.attributes!r}
+)"""
+
+
+OpSchema.__repr__ = _op_schema_repr  # type: ignore[method-assign]
+
+
+def _op_schema_formal_parameter_repr(self) -> str:
+    return (
+        f"OpSchema.FormalParameter(name={self.name!r}, type_str={self.type_str!r}, "
+        f"description={self.description!r}, param_option={self.option!r}, "
+        f"is_homogeneous={self.is_homogeneous!r}, min_arity={self.min_arity!r}, "
+        f"differentiation_category={self.differentiation_category!r})"
+    )
+
+
+OpSchema.FormalParameter.__repr__ = _op_schema_formal_parameter_repr  # type: ignore[method-assign]
+
+
+def _op_schema_type_constraint_param_repr(self) -> str:
+    return (
+        f"OpSchema.TypeConstraintParam(type_param_str={self.type_param_str!r}, "
+        f"allowed_type_strs={self.allowed_type_strs!r}, description={self.description!r})"
+    )
+
+
+OpSchema.TypeConstraintParam.__repr__ = _op_schema_type_constraint_param_repr  # type: ignore[method-assign]
+
+
+def _op_schema_attribute_repr(self) -> str:
+    return (
+        f"OpSchema.Attribute(name={self.name!r}, type={self.type!r}, description={self.description!r}, "
+        f"default_value={self.default_value!r}, required={self.required!r})"
+    )
+
+
+OpSchema.Attribute.__repr__ = _op_schema_attribute_repr  # type: ignore[method-assign]
+
+
+def get_function_ops() -> list[OpSchema]:
+    """Return operators defined as functions."""
+    schemas = C.get_all_schemas()
+    return [
+        schema
+        for schema in schemas
+        if schema.has_function or schema.has_context_dependent_function  # type: ignore[attr-defined]
+    ]
+
+
+SchemaError = C.SchemaError
+
+
+def register_schema(schema: OpSchema) -> None:
+    """Register a user provided OpSchema.
+
+    The function extends available operator set versions for the provided domain if necessary.
+
+    Args:
+        schema: The OpSchema to register.
+    """
+    version_map = C.schema_version_map()
+    domain = schema.domain
+    version = schema.since_version
+    min_version, max_version = version_map.get(domain, (version, version))
+    if domain not in version_map or not (min_version <= version <= max_version):
+        min_version = min(min_version, version)
+        max_version = max(max_version, version)
+        C.set_domain_to_version(schema.domain, min_version, max_version)
+    C.register_schema(schema)
diff --git a/onnx/defs/attr_proto_util.cc b/onnx/defs/attr_proto_util.cc
new file mode 100644
index 0000000..ace0851
--- /dev/null
+++ b/onnx/defs/attr_proto_util.cc
@@ -0,0 +1,73 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/attr_proto_util.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace ONNX_NAMESPACE {
+
+#define ADD_BASIC_ATTR_IMPL(type, enumType, field)                  \
+  AttributeProto MakeAttribute(std::string attr_name, type value) { \
+    AttributeProto a;                                               \
+    a.set_name(std::move(attr_name));                               \
+    a.set_type(enumType);                                           \
+    a.set_##field(value);                                           \
+    return a;                                                       \
+  }
+
+#define ADD_ATTR_IMPL(type, enumType, field)                        \
+  AttributeProto MakeAttribute(std::string attr_name, type value) { \
+    AttributeProto a;                                               \
+    a.set_name(std::move(attr_name));                               \
+    a.set_type(enumType);                                           \
+    *(a.mutable_##field()) = std::move(value);                      \
+    return a;                                                       \
+  }
+
+#define ADD_LIST_ATTR_IMPL(type, enumType, field)                                 \
+  AttributeProto MakeAttribute(std::string attr_name, std::vector<type> values) { \
+    AttributeProto a;                                                             \
+    a.set_name(std::move(attr_name));                                             \
+    a.set_type(enumType);                                                         \
+    for (auto&& val : std::move(values)) {                                        \
+      *(a.mutable_##field()->Add()) = std::move(val);                             \
+    }                                                                             \
+    return a;                                                                     \
+  }
+
+ADD_BASIC_ATTR_IMPL(float, AttributeProto_AttributeType_FLOAT, f)
+ADD_BASIC_ATTR_IMPL(int64_t, AttributeProto_AttributeType_INT, i)
+ADD_BASIC_ATTR_IMPL(int, AttributeProto_AttributeType_INT, i)
+ADD_BASIC_ATTR_IMPL(std::string, AttributeProto_AttributeType_STRING, s)
+ADD_ATTR_IMPL(TensorProto, AttributeProto_AttributeType_TENSOR, t)
+ADD_ATTR_IMPL(GraphProto, AttributeProto_AttributeType_GRAPH, g)
+ADD_ATTR_IMPL(TypeProto, AttributeProto_AttributeType_TYPE_PROTO, tp)
+// NOLINTNEXTLINE(performance-unnecessary-value-param)
+ADD_LIST_ATTR_IMPL(float, AttributeProto_AttributeType_FLOATS, floats)
+// NOLINTNEXTLINE(performance-unnecessary-value-param)
+ADD_LIST_ATTR_IMPL(int64_t, AttributeProto_AttributeType_INTS, ints)
+ADD_LIST_ATTR_IMPL(std::string, AttributeProto_AttributeType_STRINGS, strings)
+ADD_LIST_ATTR_IMPL(TensorProto, AttributeProto_AttributeType_TENSORS, tensors)
+ADD_LIST_ATTR_IMPL(GraphProto, AttributeProto_AttributeType_GRAPHS, graphs)
+ADD_LIST_ATTR_IMPL(TypeProto, AttributeProto_AttributeType_TYPE_PROTOS, type_protos)
+
+AttributeProto MakeRefAttribute(const std::string& attr_name, AttributeProto_AttributeType type) {
+  return MakeRefAttribute(attr_name, attr_name, type);
+}
+
+AttributeProto MakeRefAttribute(
+    const std::string& attr_name,
+    const std::string& referred_attr_name,
+    AttributeProto_AttributeType type) {
+  AttributeProto a;
+  a.set_name(attr_name);
+  a.set_ref_attr_name(referred_attr_name);
+  a.set_type(type);
+  return a;
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/attr_proto_util.h b/onnx/defs/attr_proto_util.h
new file mode 100644
index 0000000..7e42960
--- /dev/null
+++ b/onnx/defs/attr_proto_util.h
@@ -0,0 +1,44 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "onnx/onnx-operators_pb.h"
+
+namespace ONNX_NAMESPACE {
+
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, float value);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, int64_t value);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, int value);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, std::string value);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, TensorProto value);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, GraphProto value);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, TypeProto value);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, std::vector<float> values);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, std::vector<int64_t> values);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, std::vector<std::string> values);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, std::vector<TensorProto> values);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, std::vector<GraphProto> values);
+ONNX_API AttributeProto MakeAttribute(std::string attr_name, std::vector<TypeProto> values);
+
+// Make a "reference" attribute for a node in a function body.
+// <attr_name> specifies the attribute name of both the function node and its
+// function body node. They're using the same attribute name.
+// <type> specifies the attribute type.
+AttributeProto MakeRefAttribute(const std::string& attr_name, AttributeProto_AttributeType type);
+
+// Make a "reference" attribute for a node in a function body.
+// <attr_name> specifies the attribute name of the function body node.
+// <referred_attr_name> specifies the referred attribute name of the function
+// node.
+// <type> specifies the attribute type.
+AttributeProto MakeRefAttribute(
+    const std::string& attr_name,
+    const std::string& referred_attr_name,
+    AttributeProto_AttributeType type);
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/controlflow/CMakeLists.txt b/onnx/defs/controlflow/CMakeLists.txt
new file mode 100644
index 0000000..0011f05
--- /dev/null
+++ b/onnx/defs/controlflow/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+    utils.cc
+    utils.h
+)
diff --git a/onnx/defs/controlflow/defs.cc b/onnx/defs/controlflow/defs.cc
new file mode 100644
index 0000000..8569f2e
--- /dev/null
+++ b/onnx/defs/controlflow/defs.cc
@@ -0,0 +1,194 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <cassert>
+#include <string>
+#include <vector>
+
+#include "onnx/defs/controlflow/utils.h"
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+using SupportType = OpSchema::SupportType;
+
+static std::vector<std::string> control_flow_types_ir13() {
+  auto t = OpSchema::all_tensor_types_ir13();
+  auto s = OpSchema::all_tensor_sequence_types_ir13();
+  auto o = OpSchema::all_optional_types_ir13();
+  t.insert(t.end(), s.begin(), s.end());
+  t.insert(t.end(), o.begin(), o.end());
+  return t;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    If,
+    25,
+    OpSchema()
+        .SetDoc("If conditional")
+        .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
+        .Output(
+            0,
+            "outputs",
+            "Values that are live-out to the enclosing scope. The return values in "
+            "the `then_branch` and `else_branch` must be of the same data type. "
+            "The `then_branch` and `else_branch` may produce tensors with the same "
+            "element type and different shapes. "
+            "If corresponding outputs from the then-branch and the else-branch have "
+            "static shapes S1 and S2, then the shape of the corresponding output "
+            "variable of the if-node (if present) must be compatible with both S1 "
+            "and S2 as it represents the union of both possible shapes."
+            "For example, if in a model file, the first "
+            "output of `then_branch` is typed float tensor with shape [2] and the "
+            "first output of `else_branch` is another float tensor with shape [3], "
+            "If's first output should have (a) no shape set, or (b) "
+            "a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) "
+            "a shape of rank 1 with a unique `dim_param`. "
+            "In contrast, the first output cannot have the shape [2] since [2] and "
+            "[3] are not compatible.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "then_branch",
+            "Graph to run if condition is true. Has N outputs: values you wish to "
+            "be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the else_branch.",
+            AttributeProto::GRAPH)
+        .Attr(
+            "else_branch",
+            "Graph to run if condition is false. Has N outputs: values you wish to"
+            " be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the then_branch.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir13(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv13.")
+        .TypeConstraint("B", {types::Bool}, "Only bool")
+        .TypeAndShapeInferenceFunction(IfInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Loop,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_Loop_ver23)
+        .Input(
+            0,
+            "M",
+            "A maximum trip-count for the loop specified at runtime. Optional."
+            " Pass empty string to skip.",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "cond",
+            "A boolean termination condition. Optional. Pass empty string to skip.",
+            "B",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "v_initial",
+            "The initial values of any loop-carried dependencies (values that "
+            "change across loop iterations)",
+            "V",
+            OpSchema::Variadic,
+            false,
+            0)
+        .Output(
+            0,
+            "v_final_and_scan_outputs",
+            "Final N loop carried dependency values then K scan_outputs. "
+            "Scan outputs must be Tensors.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has 2+N inputs: (iteration_num, "
+            "condition, loop carried dependencies...). It has 1+N+K outputs: "
+            "(condition, loop carried dependencies..., scan_outputs...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "output value at the end of each iteration of the loop. It is an error"
+            " if the dimensions or data type of these scan_outputs change across loop"
+            " iterations.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir13(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv13.")
+        .TypeConstraint("I", {types::Int64}, "tensor of int64, which should be a scalar.")
+        .TypeConstraint("B", {types::Bool}, "tensor of bool, which should be a scalar.")
+        .TypeAndShapeInferenceFunction(LoopInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scan,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_scan_24)
+        .Input(
+            0,
+            "initial_state_and_scan_inputs",
+            "Initial values of the loop's N state variables followed by M scan_inputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "final_state_and_scan_outputs",
+            "Final values of the loop's N state variables followed by K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has N+M inputs: "
+            "(loop state variables..., scan_input_elts...). It has N+K outputs: "
+            "(loop state variables..., scan_output_elts...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "scan_output_elt value at the end of each iteration of the loop. It is an error"
+            " if the dimensions of these values change across loop iterations.",
+            AttributeProto::GRAPH,
+            true)
+        .Attr("num_scan_inputs", "An attribute specifying the number of scan_inputs M. ", AttributeProto::INT, true)
+        .Attr(
+            "scan_input_directions",
+            "An optional list of M flags. The i-th element of the list specifies the direction "
+            "to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 "
+            "indicates reverse direction. "
+            "If omitted, all scan_input tensors will be scanned in the forward direction.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_directions",
+            "An optional list of K flags, one for each scan_output. The i-th element of the list "
+            "specifies whether the i-th scan_output should be constructed by appending or "
+            "prepending a new value in each iteration: 0 indicates appending and 1 "
+            "indicates prepending. "
+            "If omitted, all scan_output tensors will be produced by appending a value "
+            "in each iteration.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_input_axes",
+            "An optional list of M flags. The i-th element of the list specifies the axis "
+            "to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will "
+            "be used as the scan axis for every scan_input. Negative value for an axis means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_axes",
+            "An optional list of K flags. The i-th element of the list specifies the axis "
+            "for the i-th scan_output. The scan outputs are accumulated along the specified "
+            "axis. If omitted, 0 will be used as the scan axis for every scan_output. "
+            "Negative value for an axis means counting dimensions from the back. Accepted "
+            "range is [-r, r-1].",
+            AttributeProto::INTS,
+            false)
+        .TypeConstraint("V", OpSchema::all_tensor_types_ir13(), "All Tensor types up to IRv13.")
+        .TypeAndShapeInferenceFunction(ScanInferenceFunction)); // Shares same shape inference as opset 11
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/controlflow/old.cc b/onnx/defs/controlflow/old.cc
new file mode 100644
index 0000000..5991d80
--- /dev/null
+++ b/onnx/defs/controlflow/old.cc
@@ -0,0 +1,2708 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+#include <vector>
+
+#include "onnx/defs/controlflow/utils.h"
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+using SupportType = OpSchema::SupportType;
+
+static std::vector<std::string> control_flow_types_ir12() {
+  auto t = OpSchema::all_tensor_types_ir12();
+  auto s = OpSchema::all_tensor_sequence_types_ir12();
+  auto o = OpSchema::all_optional_types_ir12();
+  t.insert(t.end(), s.begin(), s.end());
+  t.insert(t.end(), o.begin(), o.end());
+  return t;
+}
+
+static std::vector<std::string> control_flow_types_ir11() {
+  auto t = OpSchema::all_tensor_types_ir11();
+  auto s = OpSchema::all_tensor_sequence_types_ir11();
+  auto o = OpSchema::all_optional_types_ir11();
+  t.insert(t.end(), s.begin(), s.end());
+  t.insert(t.end(), o.begin(), o.end());
+  return t;
+}
+
+static std::vector<std::string> control_flow_types_ir10() {
+  auto t = OpSchema::all_tensor_types_ir10();
+  auto s = OpSchema::all_tensor_sequence_types_ir10();
+  auto o = OpSchema::all_optional_types_ir10();
+  t.insert(t.end(), s.begin(), s.end());
+  t.insert(t.end(), o.begin(), o.end());
+  return t;
+}
+
+static std::vector<std::string> control_flow_types_ir9() {
+  auto t = OpSchema::all_tensor_types_ir9();
+  auto s = OpSchema::all_tensor_sequence_types_ir9();
+  auto o = OpSchema::all_optional_types_ir9();
+  t.insert(t.end(), s.begin(), s.end());
+  t.insert(t.end(), o.begin(), o.end());
+  return t;
+}
+
+static std::vector<std::string> control_flow_types_ir4() {
+  auto t = OpSchema::all_tensor_types_ir4();
+  auto s = OpSchema::all_tensor_sequence_types_ir4();
+  auto o = OpSchema::all_optional_types_ir4();
+  t.insert(t.end(), s.begin(), s.end());
+  t.insert(t.end(), o.begin(), o.end());
+  return t;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    If,
+    24,
+    OpSchema()
+        .SetDoc("If conditional")
+        .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
+        .Output(
+            0,
+            "outputs",
+            "Values that are live-out to the enclosing scope. The return values in "
+            "the `then_branch` and `else_branch` must be of the same data type. "
+            "The `then_branch` and `else_branch` may produce tensors with the same "
+            "element type and different shapes. "
+            "If corresponding outputs from the then-branch and the else-branch have "
+            "static shapes S1 and S2, then the shape of the corresponding output "
+            "variable of the if-node (if present) must be compatible with both S1 "
+            "and S2 as it represents the union of both possible shapes."
+            "For example, if in a model file, the first "
+            "output of `then_branch` is typed float tensor with shape [2] and the "
+            "first output of `else_branch` is another float tensor with shape [3], "
+            "If's first output should have (a) no shape set, or (b) "
+            "a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) "
+            "a shape of rank 1 with a unique `dim_param`. "
+            "In contrast, the first output cannot have the shape [2] since [2] and "
+            "[3] are not compatible.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "then_branch",
+            "Graph to run if condition is true. Has N outputs: values you wish to "
+            "be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the else_branch.",
+            AttributeProto::GRAPH)
+        .Attr(
+            "else_branch",
+            "Graph to run if condition is false. Has N outputs: values you wish to"
+            " be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the then_branch.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir12(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.")
+        .TypeConstraint("B", {types::Bool}, "Only bool")
+        .TypeAndShapeInferenceFunction(IfInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    If,
+    23,
+    OpSchema()
+        .SetDoc("If conditional")
+        .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
+        .Output(
+            0,
+            "outputs",
+            "Values that are live-out to the enclosing scope. The return values in "
+            "the `then_branch` and `else_branch` must be of the same data type. "
+            "The `then_branch` and `else_branch` may produce tensors with the same "
+            "element type and different shapes. "
+            "If corresponding outputs from the then-branch and the else-branch have "
+            "static shapes S1 and S2, then the shape of the corresponding output "
+            "variable of the if-node (if present) must be compatible with both S1 "
+            "and S2 as it represents the union of both possible shapes."
+            "For example, if in a model file, the first "
+            "output of `then_branch` is typed float tensor with shape [2] and the "
+            "first output of `else_branch` is another float tensor with shape [3], "
+            "If's first output should have (a) no shape set, or (b) "
+            "a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) "
+            "a shape of rank 1 with a unique `dim_param`. "
+            "In contrast, the first output cannot have the shape [2] since [2] and "
+            "[3] are not compatible.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "then_branch",
+            "Graph to run if condition is true. Has N outputs: values you wish to "
+            "be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the else_branch.",
+            AttributeProto::GRAPH)
+        .Attr(
+            "else_branch",
+            "Graph to run if condition is false. Has N outputs: values you wish to"
+            " be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the then_branch.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir11(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.")
+        .TypeConstraint("B", {types::Bool}, "Only bool")
+        .TypeAndShapeInferenceFunction(IfInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    If,
+    21,
+    OpSchema()
+        .SetDoc("If conditional")
+        .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
+        .Output(
+            0,
+            "outputs",
+            "Values that are live-out to the enclosing scope. The return values in "
+            "the `then_branch` and `else_branch` must be of the same data type. "
+            "The `then_branch` and `else_branch` may produce tensors with the same "
+            "element type and different shapes. "
+            "If corresponding outputs from the then-branch and the else-branch have "
+            "static shapes S1 and S2, then the shape of the corresponding output "
+            "variable of the if-node (if present) must be compatible with both S1 "
+            "and S2 as it represents the union of both possible shapes."
+            "For example, if in a model file, the first "
+            "output of `then_branch` is typed float tensor with shape [2] and the "
+            "first output of `else_branch` is another float tensor with shape [3], "
+            "If's first output should have (a) no shape set, or (b) "
+            "a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) "
+            "a shape of rank 1 with a unique `dim_param`. "
+            "In contrast, the first output cannot have the shape [2] since [2] and "
+            "[3] are not compatible.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "then_branch",
+            "Graph to run if condition is true. Has N outputs: values you wish to "
+            "be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the else_branch.",
+            AttributeProto::GRAPH)
+        .Attr(
+            "else_branch",
+            "Graph to run if condition is false. Has N outputs: values you wish to"
+            " be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the then_branch.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir10(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv10.")
+        .TypeConstraint("B", {types::Bool}, "Only bool")
+        .TypeAndShapeInferenceFunction(IfInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    If,
+    19,
+    OpSchema()
+        .SetDoc("If conditional")
+        .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
+        .Output(
+            0,
+            "outputs",
+            "Values that are live-out to the enclosing scope. The return values in "
+            "the `then_branch` and `else_branch` must be of the same data type. "
+            "The `then_branch` and `else_branch` may produce tensors with the same "
+            "element type and different shapes. "
+            "If corresponding outputs from the then-branch and the else-branch have "
+            "static shapes S1 and S2, then the shape of the corresponding output "
+            "variable of the if-node (if present) must be compatible with both S1 "
+            "and S2 as it represents the union of both possible shapes."
+            "For example, if in a model file, the first "
+            "output of `then_branch` is typed float tensor with shape [2] and the "
+            "first output of `else_branch` is another float tensor with shape [3], "
+            "If's first output should have (a) no shape set, or (b) "
+            "a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) "
+            "a shape of rank 1 with a unique `dim_param`. "
+            "In contrast, the first output cannot have the shape [2] since [2] and "
+            "[3] are not compatible.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "then_branch",
+            "Graph to run if condition is true. Has N outputs: values you wish to "
+            "be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the else_branch.",
+            AttributeProto::GRAPH)
+        .Attr(
+            "else_branch",
+            "Graph to run if condition is false. Has N outputs: values you wish to"
+            " be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the then_branch.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir9(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv9.")
+        .TypeConstraint("B", {types::Bool}, "Only bool")
+        .TypeAndShapeInferenceFunction(IfInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    If,
+    16,
+    OpSchema()
+        .SetDoc("If conditional")
+        .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
+        .Output(
+            0,
+            "outputs",
+            "Values that are live-out to the enclosing scope. The return values in "
+            "the `then_branch` and `else_branch` must be of the same data type. "
+            "The `then_branch` and `else_branch` may produce tensors with the same "
+            "element type and different shapes. "
+            "If corresponding outputs from the then-branch and the else-branch have "
+            "static shapes S1 and S2, then the shape of the corresponding output "
+            "variable of the if-node (if present) must be compatible with both S1 "
+            "and S2 as it represents the union of both possible shapes."
+            "For example, if in a model file, the first "
+            "output of `then_branch` is typed float tensor with shape [2] and the "
+            "first output of `else_branch` is another float tensor with shape [3], "
+            "If's first output should have (a) no shape set, or (b) "
+            "a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) "
+            "a shape of rank 1 with a unique `dim_param`. "
+            "In contrast, the first output cannot have the shape [2] since [2] and "
+            "[3] are not compatible.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "then_branch",
+            "Graph to run if condition is true. Has N outputs: values you wish to "
+            "be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the else_branch.",
+            AttributeProto::GRAPH)
+        .Attr(
+            "else_branch",
+            "Graph to run if condition is false. Has N outputs: values you wish to"
+            " be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the then_branch.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir4(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv4.")
+        .TypeConstraint("B", {types::Bool}, "Only bool")
+        .TypeAndShapeInferenceFunction(IfInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Loop,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_Loop_ver23)
+        .Input(
+            0,
+            "M",
+            "A maximum trip-count for the loop specified at runtime. Optional."
+            " Pass empty string to skip.",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "cond",
+            "A boolean termination condition. Optional. Pass empty string to skip.",
+            "B",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "v_initial",
+            "The initial values of any loop-carried dependencies (values that "
+            "change across loop iterations)",
+            "V",
+            OpSchema::Variadic,
+            false,
+            0)
+        .Output(
+            0,
+            "v_final_and_scan_outputs",
+            "Final N loop carried dependency values then K scan_outputs. "
+            "Scan outputs must be Tensors.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has 2+N inputs: (iteration_num, "
+            "condition, loop carried dependencies...). It has 1+N+K outputs: "
+            "(condition, loop carried dependencies..., scan_outputs...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "output value at the end of each iteration of the loop. It is an error"
+            " if the dimensions or data type of these scan_outputs change across loop"
+            " iterations.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir12(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.")
+        .TypeConstraint("I", {types::Int64}, "tensor of int64, which should be a scalar.")
+        .TypeConstraint("B", {types::Bool}, "tensor of bool, which should be a scalar.")
+        .TypeAndShapeInferenceFunction(LoopInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Loop,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_Loop_ver23)
+        .Input(
+            0,
+            "M",
+            "A maximum trip-count for the loop specified at runtime. Optional."
+            " Pass empty string to skip.",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "cond",
+            "A boolean termination condition. Optional. Pass empty string to skip.",
+            "B",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "v_initial",
+            "The initial values of any loop-carried dependencies (values that "
+            "change across loop iterations)",
+            "V",
+            OpSchema::Variadic,
+            false,
+            0)
+        .Output(
+            0,
+            "v_final_and_scan_outputs",
+            "Final N loop carried dependency values then K scan_outputs. "
+            "Scan outputs must be Tensors.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has 2+N inputs: (iteration_num, "
+            "condition, loop carried dependencies...). It has 1+N+K outputs: "
+            "(condition, loop carried dependencies..., scan_outputs...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "output value at the end of each iteration of the loop. It is an error"
+            " if the dimensions or data type of these scan_outputs change across loop"
+            " iterations.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir11(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv11.")
+        .TypeConstraint("I", {types::Int64}, "tensor of int64, which should be a scalar.")
+        .TypeConstraint("B", {types::Bool}, "tensor of bool, which should be a scalar.")
+        .TypeAndShapeInferenceFunction(LoopInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Loop,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_Loop_ver23)
+        .Input(
+            0,
+            "M",
+            "A maximum trip-count for the loop specified at runtime. Optional."
+            " Pass empty string to skip.",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "cond",
+            "A boolean termination condition. Optional. Pass empty string to skip.",
+            "B",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "v_initial",
+            "The initial values of any loop-carried dependencies (values that "
+            "change across loop iterations)",
+            "V",
+            OpSchema::Variadic,
+            false,
+            0)
+        .Output(
+            0,
+            "v_final_and_scan_outputs",
+            "Final N loop carried dependency values then K scan_outputs. "
+            "Scan outputs must be Tensors.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has 2+N inputs: (iteration_num, "
+            "condition, loop carried dependencies...). It has 1+N+K outputs: "
+            "(condition, loop carried dependencies..., scan_outputs...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "output value at the end of each iteration of the loop. It is an error"
+            " if the dimensions or data type of these scan_outputs change across loop"
+            " iterations.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir10(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv10.")
+        .TypeConstraint("I", {types::Int64}, "tensor of int64, which should be a scalar.")
+        .TypeConstraint("B", {types::Bool}, "tensor of bool, which should be a scalar.")
+        .TypeAndShapeInferenceFunction(LoopInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Loop,
+    19,
+    OpSchema()
+        .SetDoc(kDoc_Loop_ver23)
+        .Input(
+            0,
+            "M",
+            "A maximum trip-count for the loop specified at runtime. Optional."
+            " Pass empty string to skip.",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "cond",
+            "A boolean termination condition. Optional. Pass empty string to skip.",
+            "B",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "v_initial",
+            "The initial values of any loop-carried dependencies (values that "
+            "change across loop iterations)",
+            "V",
+            OpSchema::Variadic,
+            false,
+            0)
+        .Output(
+            0,
+            "v_final_and_scan_outputs",
+            "Final N loop carried dependency values then K scan_outputs. "
+            "Scan outputs must be Tensors.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has 2+N inputs: (iteration_num, "
+            "condition, loop carried dependencies...). It has 1+N+K outputs: "
+            "(condition, loop carried dependencies..., scan_outputs...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "output value at the end of each iteration of the loop. It is an error"
+            " if the dimensions or data type of these scan_outputs change across loop"
+            " iterations.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir9(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv9.")
+        .TypeConstraint("I", {types::Int64}, "tensor of int64, which should be a scalar.")
+        .TypeConstraint("B", {types::Bool}, "tensor of bool, which should be a scalar.")
+        .TypeAndShapeInferenceFunction(LoopInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Loop,
+    16,
+    OpSchema()
+        .SetDoc(kDoc_Loop_ver23)
+        .Input(
+            0,
+            "M",
+            "A maximum trip-count for the loop specified at runtime. Optional."
+            " Pass empty string to skip.",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "cond",
+            "A boolean termination condition. Optional. Pass empty string to skip.",
+            "B",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "v_initial",
+            "The initial values of any loop-carried dependencies (values that "
+            "change across loop iterations)",
+            "V",
+            OpSchema::Variadic,
+            false,
+            0)
+        .Output(
+            0,
+            "v_final_and_scan_outputs",
+            "Final N loop carried dependency values then K scan_outputs. "
+            "Scan outputs must be Tensors.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has 2+N inputs: (iteration_num, "
+            "condition, loop carried dependencies...). It has 1+N+K outputs: "
+            "(condition, loop carried dependencies..., scan_outputs...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "output value at the end of each iteration of the loop. It is an error"
+            " if the dimensions or data type of these scan_outputs change across loop"
+            " iterations.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            control_flow_types_ir4(),
+            "All Tensor, Sequence(Tensor), Optional(Tensor), and Optional(Sequence(Tensor)) types up to IRv4.")
+        .TypeConstraint("I", {types::Int64}, "tensor of int64, which should be a scalar.")
+        .TypeConstraint("B", {types::Bool}, "tensor of bool, which should be a scalar.")
+        .TypeAndShapeInferenceFunction(LoopInferenceFunction));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scan,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_scan_24)
+        .Input(
+            0,
+            "initial_state_and_scan_inputs",
+            "Initial values of the loop's N state variables followed by M scan_inputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "final_state_and_scan_outputs",
+            "Final values of the loop's N state variables followed by K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has N+M inputs: "
+            "(loop state variables..., scan_input_elts...). It has N+K outputs: "
+            "(loop state variables..., scan_output_elts...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "scan_output_elt value at the end of each iteration of the loop. It is an error"
+            " if the dimensions of these values change across loop iterations.",
+            AttributeProto::GRAPH,
+            true)
+        .Attr("num_scan_inputs", "An attribute specifying the number of scan_inputs M. ", AttributeProto::INT, true)
+        .Attr(
+            "scan_input_directions",
+            "An optional list of M flags. The i-th element of the list specifies the direction "
+            "to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 "
+            "indicates reverse direction. "
+            "If omitted, all scan_input tensors will be scanned in the forward direction.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_directions",
+            "An optional list of K flags, one for each scan_output. The i-th element of the list "
+            "specifies whether the i-th scan_output should be constructed by appending or "
+            "prepending a new value in each iteration: 0 indicates appending and 1 "
+            "indicates prepending. "
+            "If omitted, all scan_output tensors will be produced by appending a value "
+            "in each iteration.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_input_axes",
+            "An optional list of M flags. The i-th element of the list specifies the axis "
+            "to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will "
+            "be used as the scan axis for every scan_input. Negative value for an axis means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_axes",
+            "An optional list of K flags. The i-th element of the list specifies the axis "
+            "for the i-th scan_output. The scan outputs are accumulated along the specified "
+            "axis. If omitted, 0 will be used as the scan axis for every scan_output. "
+            "Negative value for an axis means counting dimensions from the back. Accepted "
+            "range is [-r, r-1].",
+            AttributeProto::INTS,
+            false)
+        .TypeConstraint("V", OpSchema::all_tensor_types_ir12(), "All Tensor types up to IRv12.")
+        .TypeAndShapeInferenceFunction(ScanInferenceFunction)); // Shares same shape inference as opset 11
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scan,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_scan_24)
+        .Input(
+            0,
+            "initial_state_and_scan_inputs",
+            "Initial values of the loop's N state variables followed by M scan_inputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "final_state_and_scan_outputs",
+            "Final values of the loop's N state variables followed by K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has N+M inputs: "
+            "(loop state variables..., scan_input_elts...). It has N+K outputs: "
+            "(loop state variables..., scan_output_elts...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "scan_output_elt value at the end of each iteration of the loop. It is an error"
+            " if the dimensions of these values change across loop iterations.",
+            AttributeProto::GRAPH,
+            true)
+        .Attr("num_scan_inputs", "An attribute specifying the number of scan_inputs M. ", AttributeProto::INT, true)
+        .Attr(
+            "scan_input_directions",
+            "An optional list of M flags. The i-th element of the list specifies the direction "
+            "to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 "
+            "indicates reverse direction. "
+            "If omitted, all scan_input tensors will be scanned in the forward direction.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_directions",
+            "An optional list of K flags, one for each scan_output. The i-th element of the list "
+            "specifies whether the i-th scan_output should be constructed by appending or "
+            "prepending a new value in each iteration: 0 indicates appending and 1 "
+            "indicates prepending. "
+            "If omitted, all scan_output tensors will be produced by appending a value "
+            "in each iteration.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_input_axes",
+            "An optional list of M flags. The i-th element of the list specifies the axis "
+            "to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will "
+            "be used as the scan axis for every scan_input. Negative value for an axis means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_axes",
+            "An optional list of K flags. The i-th element of the list specifies the axis "
+            "for the i-th scan_output. The scan outputs are accumulated along the specified "
+            "axis. If omitted, 0 will be used as the scan axis for every scan_output. "
+            "Negative value for an axis means counting dimensions from the back. Accepted "
+            "range is [-r, r-1].",
+            AttributeProto::INTS,
+            false)
+        .TypeConstraint("V", OpSchema::all_tensor_types_ir11(), "All Tensor types up to IRv11.")
+        .TypeAndShapeInferenceFunction(ScanInferenceFunction)); // Shares same shape inference as opset 11
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scan,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_scan_24)
+        .Input(
+            0,
+            "initial_state_and_scan_inputs",
+            "Initial values of the loop's N state variables followed by M scan_inputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "final_state_and_scan_outputs",
+            "Final values of the loop's N state variables followed by K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has N+M inputs: "
+            "(loop state variables..., scan_input_elts...). It has N+K outputs: "
+            "(loop state variables..., scan_output_elts...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "scan_output_elt value at the end of each iteration of the loop. It is an error"
+            " if the dimensions of these values change across loop iterations.",
+            AttributeProto::GRAPH,
+            true)
+        .Attr("num_scan_inputs", "An attribute specifying the number of scan_inputs M. ", AttributeProto::INT, true)
+        .Attr(
+            "scan_input_directions",
+            "An optional list of M flags. The i-th element of the list specifies the direction "
+            "to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 "
+            "indicates reverse direction. "
+            "If omitted, all scan_input tensors will be scanned in the forward direction.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_directions",
+            "An optional list of K flags, one for each scan_output. The i-th element of the list "
+            "specifies whether the i-th scan_output should be constructed by appending or "
+            "prepending a new value in each iteration: 0 indicates appending and 1 "
+            "indicates prepending. "
+            "If omitted, all scan_output tensors will be produced by appending a value "
+            "in each iteration.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_input_axes",
+            "An optional list of M flags. The i-th element of the list specifies the axis "
+            "to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will "
+            "be used as the scan axis for every scan_input. Negative value for an axis means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_axes",
+            "An optional list of K flags. The i-th element of the list specifies the axis "
+            "for the i-th scan_output. The scan outputs are accumulated along the specified "
+            "axis. If omitted, 0 will be used as the scan axis for every scan_output. "
+            "Negative value for an axis means counting dimensions from the back. Accepted "
+            "range is [-r, r-1].",
+            AttributeProto::INTS,
+            false)
+        .TypeConstraint("V", OpSchema::all_tensor_types_ir10(), "All Tensor types up to IRv10.")
+        .TypeAndShapeInferenceFunction(ScanInferenceFunction)); // Shares same shape inference as opset 11
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scan,
+    19,
+    OpSchema()
+        .SetDoc(kDoc_scan_24)
+        .Input(
+            0,
+            "initial_state_and_scan_inputs",
+            "Initial values of the loop's N state variables followed by M scan_inputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "final_state_and_scan_outputs",
+            "Final values of the loop's N state variables followed by K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has N+M inputs: "
+            "(loop state variables..., scan_input_elts...). It has N+K outputs: "
+            "(loop state variables..., scan_output_elts...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "scan_output_elt value at the end of each iteration of the loop. It is an error"
+            " if the dimensions of these values change across loop iterations.",
+            AttributeProto::GRAPH,
+            true)
+        .Attr("num_scan_inputs", "An attribute specifying the number of scan_inputs M. ", AttributeProto::INT, true)
+        .Attr(
+            "scan_input_directions",
+            "An optional list of M flags. The i-th element of the list specifies the direction "
+            "to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 "
+            "indicates reverse direction. "
+            "If omitted, all scan_input tensors will be scanned in the forward direction.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_directions",
+            "An optional list of K flags, one for each scan_output. The i-th element of the list "
+            "specifies whether the i-th scan_output should be constructed by appending or "
+            "prepending a new value in each iteration: 0 indicates appending and 1 "
+            "indicates prepending. "
+            "If omitted, all scan_output tensors will be produced by appending a value "
+            "in each iteration.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_input_axes",
+            "An optional list of M flags. The i-th element of the list specifies the axis "
+            "to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will "
+            "be used as the scan axis for every scan_input. Negative value for an axis means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_axes",
+            "An optional list of K flags. The i-th element of the list specifies the axis "
+            "for the i-th scan_output. The scan outputs are accumulated along the specified "
+            "axis. If omitted, 0 will be used as the scan axis for every scan_output. "
+            "Negative value for an axis means counting dimensions from the back. Accepted "
+            "range is [-r, r-1].",
+            AttributeProto::INTS,
+            false)
+        .TypeConstraint("V", OpSchema::all_tensor_types_ir9(), "All Tensor types up to IRv9.")
+        .TypeAndShapeInferenceFunction(ScanInferenceFunction)); // Shares same shape inference as opset 11
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scan,
+    16,
+    OpSchema()
+        .SetDoc(kDoc_scan_24)
+        .Input(
+            0,
+            "initial_state_and_scan_inputs",
+            "Initial values of the loop's N state variables followed by M scan_inputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "final_state_and_scan_outputs",
+            "Final values of the loop's N state variables followed by K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has N+M inputs: "
+            "(loop state variables..., scan_input_elts...). It has N+K outputs: "
+            "(loop state variables..., scan_output_elts...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "scan_output_elt value at the end of each iteration of the loop. It is an error"
+            " if the dimensions of these values change across loop iterations.",
+            AttributeProto::GRAPH,
+            true)
+        .Attr("num_scan_inputs", "An attribute specifying the number of scan_inputs M. ", AttributeProto::INT, true)
+        .Attr(
+            "scan_input_directions",
+            "An optional list of M flags. The i-th element of the list specifies the direction "
+            "to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 "
+            "indicates reverse direction. "
+            "If omitted, all scan_input tensors will be scanned in the forward direction.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_directions",
+            "An optional list of K flags, one for each scan_output. The i-th element of the list "
+            "specifies whether the i-th scan_output should be constructed by appending or "
+            "prepending a new value in each iteration: 0 indicates appending and 1 "
+            "indicates prepending. "
+            "If omitted, all scan_output tensors will be produced by appending a value "
+            "in each iteration.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_input_axes",
+            "An optional list of M flags. The i-th element of the list specifies the axis "
+            "to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will "
+            "be used as the scan axis for every scan_input. Negative value for an axis means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_axes",
+            "An optional list of K flags. The i-th element of the list specifies the axis "
+            "for the i-th scan_output. The scan outputs are accumulated along the specified "
+            "axis. If omitted, 0 will be used as the scan axis for every scan_output. "
+            "Negative value for an axis means counting dimensions from the back. Accepted "
+            "range is [-r, r-1].",
+            AttributeProto::INTS,
+            false)
+        .TypeConstraint("V", OpSchema::all_tensor_types_ir4(), "All Tensor types up to IRv4.")
+        .TypeAndShapeInferenceFunction(ScanInferenceFunction)); // Shares same shape inference as opset 11
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void ScanInferenceFunction_opset8(InferenceContext& ctx) {
+  // NOTE:
+  // The first input to Scan is sequence_lens. We skip that when processing
+  // inputs in many places below, so the - 1 in multiple places is due to that.
+  auto num_inputs = ctx.getNumInputs();
+  auto num_scan_inputs = narrow<size_t>(getRequiredAttributeInt(ctx, "num_scan_inputs"));
+  // Guard the subtraction below; opset 8's first input is sequence_lens, hence the + 1.
+  if (num_scan_inputs + 1 > num_inputs) {
+    fail_shape_inference(
+        "num_scan_inputs (",
+        num_scan_inputs,
+        ") plus the sequence_lens input cannot exceed the number of Scan inputs (",
+        num_inputs,
+        ").");
+  }
+  auto num_loop_state_vars = num_inputs - 1 - num_scan_inputs;
+
+  std::vector<TypeProto> temporary_type_protos;
+  temporary_type_protos.reserve(num_inputs);
+
+  std::vector<const TypeProto*> subgraph_input_types;
+
+  TensorShapeProto_Dimension batch_size_dim;
+  TensorShapeProto_Dimension sequence_len_dim;
+
+  for (size_t i = 1; i < num_inputs; ++i) {
+    bool is_loop_state_var = (i - 1) < num_loop_state_vars;
+    bool has_shape = hasInputShape(ctx, i);
+    const auto* const input_type = ctx.getInputType(i);
+
+    // Enforce type constraint for inputs
+    if (!input_type || !input_type->has_tensor_type()) {
+      fail_type_inference("Scan input ", i, " was not a tensor.");
+    }
+
+    if (is_loop_state_var) {
+      // If it's a loop state variable we can propagate type and shape 1:1 to
+      // the matching Scan output.
+      // We can also pass through the type and shape to the subgraph but need to
+      // remove the batch size dimension from the shape.
+      propagateElemTypeFromInputToOutput(ctx, i, i - 1);
+
+      if (has_shape) {
+        propagateShapeFromInputToOutput(ctx, i, i - 1);
+
+        // remove batch size dimension and add to subgraph_input_types
+        temporary_type_protos.emplace_back(RemoveDimensionsFromShape(*input_type, 1));
+        subgraph_input_types.emplace_back(&temporary_type_protos.back());
+      } else {
+        subgraph_input_types.emplace_back(input_type);
+      }
+    } else {
+      // For other inputs there is no fixed relationships to the Scan outputs,
+      // so we don't propagate type/shape information.
+      // We can pass through the type and shape to the subgraph inputs but need
+      // to remove the batch size and sequence length dimensions from the shape.
+      if (has_shape) {
+        // remove batch size and sequence length dimensions and add to
+        // subgraph_input_types
+        temporary_type_protos.emplace_back(RemoveDimensionsFromShape(*input_type, 2));
+        subgraph_input_types.emplace_back(&temporary_type_protos.back());
+
+        // update batch_size and sequence_len if a value is available
+        const auto& shape = input_type->tensor_type().shape();
+        if (shape.dim_size() > 2) {
+          const auto& dims = shape.dim();
+          mergeInDimensionInfo(dims.Get(0), batch_size_dim, 0);
+          mergeInDimensionInfo(dims.Get(1), sequence_len_dim, 1);
+        }
+      } else {
+        subgraph_input_types.emplace_back(input_type);
+      }
+    }
+  }
+
+  // Run inferencing on the subgraph
+  std::vector<const TypeProto*> output_types;
+
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("body");
+  if (graphInferencer) {
+    std::vector<const TensorProto*> input_data;
+    for (size_t i = 1; i < num_inputs; ++i) {
+      input_data.emplace_back(ctx.getInputData(i));
+    }
+
+    output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  // if empty(), assume inferencing was skipped
+  if (!output_types.empty()) {
+    auto num_outputs = ctx.getNumOutputs();
+    if (output_types.size() != num_outputs) {
+      fail_type_inference(
+          "Graph attribute inferencing returned type information for ",
+          output_types.size(),
+          " outputs. Expected ",
+          num_outputs);
+    }
+
+    // propagate type/shape information for loop state variables and outputs
+    for (size_t i = 0; i < num_outputs; ++i) {
+      const bool is_loop_state_var = i < num_loop_state_vars;
+      const auto* const subgraph_output_type = output_types[i];
+      auto* scan_output_type = ctx.getOutputType(i);
+
+      if (!subgraph_output_type->has_tensor_type()) {
+        fail_type_inference("Scan 'body' subgraph outputs should all be tensors but output ", i, " was not");
+      }
+
+      // propagate output type. loop state vars were done in the above code.
+      if (!is_loop_state_var) {
+        scan_output_type->mutable_tensor_type()->set_elem_type(subgraph_output_type->tensor_type().elem_type());
+      }
+
+      // propagate shape
+      if (subgraph_output_type->tensor_type().has_shape()) {
+        // we need to add in the batch size and sequence length values if
+        // available before merging with any existing info. Create a copy of the
+        // inferred type info from the subgraph to do that.
+        TypeProto inferred_type(*subgraph_output_type);
+        auto* mutable_inferred_tensor_type = inferred_type.mutable_tensor_type();
+        auto* mutable_inferred_shape = mutable_inferred_tensor_type->mutable_shape();
+
+        mutable_inferred_shape->clear_dim();
+        *mutable_inferred_shape->add_dim() = batch_size_dim;
+
+        if (!is_loop_state_var) {
+          *mutable_inferred_shape->add_dim() = sequence_len_dim;
+        }
+
+        for (const auto& dim : subgraph_output_type->tensor_type().shape().dim()) {
+          (*mutable_inferred_shape->add_dim()) = dim;
+        }
+
+        auto* mutable_scan_output_tensor_type = scan_output_type->mutable_tensor_type();
+
+        mergeInShapeInfo(*mutable_inferred_tensor_type, *mutable_scan_output_tensor_type);
+      }
+    }
+  }
+}
+
+static int handle_negative_axis_validate_opset9(const std::string& attrib, int axis, int rank) {
+  if (-rank > axis || axis >= rank) {
+    fail_shape_inference(attrib, " axis value ", axis, " is invalid for a tensor of rank ", rank);
+  }
+  return (axis >= 0 ? axis : axis + rank);
+}
+
+static void ScanInferenceFunction_opset9(InferenceContext& ctx) {
+  auto num_inputs = ctx.getNumInputs();
+  auto num_scan_inputs = narrow<size_t>(getRequiredAttributeInt(ctx, "num_scan_inputs"));
+  auto num_outputs = ctx.getNumOutputs();
+  auto num_loop_state_vars = ValidateScanCountsAndGetNumLoopStateVars(num_inputs, num_scan_inputs, num_outputs);
+  auto num_scan_outputs = num_outputs - num_loop_state_vars;
+
+  std::vector<int64_t> axes, output_axes;
+  if (getRepeatedAttribute(ctx, "scan_input_axes", axes)) {
+    if (axes.size() != num_scan_inputs) {
+      fail_shape_inference(
+          "Number of scan input axes specified (",
+          axes.size(),
+          ") is not equal to number of scan inputs (",
+          num_scan_inputs,
+          ").");
+    }
+  } else {
+    axes.insert(axes.end(), num_scan_inputs, 0);
+  }
+
+  if (getRepeatedAttribute(ctx, "scan_output_axes", output_axes)) {
+    if (output_axes.size() != num_scan_outputs) {
+      fail_shape_inference(
+          "Number of scan output axes specified (",
+          output_axes.size(),
+          ") is not equal to number of scan outputs (",
+          num_scan_outputs,
+          ").");
+    }
+  } else {
+    output_axes.insert(output_axes.end(), num_scan_outputs, 0);
+  }
+
+  std::vector<TypeProto> temporary_type_protos;
+  temporary_type_protos.reserve(num_inputs);
+
+  std::vector<const TypeProto*> subgraph_input_types;
+
+  TensorShapeProto_Dimension sequence_len_dim;
+
+  for (size_t i = 0; i < num_inputs; ++i) {
+    bool is_loop_state_var = i < num_loop_state_vars;
+    bool has_shape = hasInputShape(ctx, i);
+    const auto* const input_type = ctx.getInputType(i);
+
+    // Enforce type constraint for inputs
+    if (!input_type || !input_type->has_tensor_type()) {
+      fail_type_inference("Scan input ", i, " was not a tensor.");
+    }
+
+    if (is_loop_state_var) {
+      // If it's a loop state variable we can propagate type and shape 1:1 to
+      // the matching Scan output.
+      // We can also pass through the type and shape to the subgraph but need to
+      // remove the batch size dimension from the shape.
+      propagateElemTypeFromInputToOutput(ctx, i, i);
+      if (has_shape)
+        propagateShapeFromInputToOutput(ctx, i, i);
+
+      subgraph_input_types.emplace_back(input_type);
+    } else {
+      // For other inputs there is no fixed relationships to the Scan outputs,
+      // so we don't propagate type/shape information.
+      // We can pass through the type and shape to the subgraph inputs but
+      // need to remove the sequence length dimensions from the shape.
+      if (has_shape) {
+        const auto& shape = input_type->tensor_type().shape();
+
+        // remove sequence length dimensions and add to subgraph_input_types
+        int axis = static_cast<int>(axes[i - num_loop_state_vars]);
+        axis = handle_negative_axis_validate_opset9("scan_input_axes", axis, shape.dim_size());
+
+        // update sequence_len if a value is available
+
+        const auto& dims = shape.dim();
+        mergeInDimensionInfo(dims.Get(axis), sequence_len_dim, 1);
+
+        temporary_type_protos.emplace_back(RemoveIthDimensionFromShape(*input_type, axis));
+        subgraph_input_types.emplace_back(&temporary_type_protos.back());
+
+      } else {
+        subgraph_input_types.emplace_back(input_type);
+      }
+    }
+  }
+
+  // Run inferencing on the subgraph
+  std::vector<const TypeProto*> output_types;
+
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("body");
+  if (graphInferencer) {
+    std::vector<const TensorProto*> input_data;
+    input_data.reserve(num_inputs);
+    for (size_t i = 0; i < num_inputs; ++i) {
+      // ctx.getInputData(i), the input to scan, does not represent the input to
+      // scan body. So, we pass in null, to represent an unknown value.
+      input_data.emplace_back(nullptr);
+    }
+
+    output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  // if empty(), assume inferencing was skipped
+  if (!output_types.empty()) {
+    if (output_types.size() != num_outputs) {
+      fail_type_inference(
+          "Graph attribute inferencing returned type information for ",
+          output_types.size(),
+          " outputs. Expected ",
+          num_outputs);
+    }
+
+    // propagate type/shape information for loop state variables and outputs
+    for (size_t i = 0; i < num_outputs; ++i) {
+      const bool is_loop_state_var = i < num_loop_state_vars;
+      const auto* const subgraph_output_type = output_types[i];
+      auto* scan_output_type = ctx.getOutputType(i);
+      auto* mutable_scan_output_tensor_type = scan_output_type->mutable_tensor_type();
+
+      if (!subgraph_output_type->has_tensor_type()) {
+        fail_type_inference("Scan 'body' subgraph outputs should all be tensors but output ", i, " was not");
+      }
+      const auto& subgraph_output_tensor_type = subgraph_output_type->tensor_type();
+
+      if (is_loop_state_var) {
+        // merge shape; type already propagated
+        mergeInShapeInfo(subgraph_output_tensor_type, *mutable_scan_output_tensor_type);
+      } else {
+        scan_output_type->mutable_tensor_type()->set_elem_type(subgraph_output_tensor_type.elem_type());
+
+        // propagate shape
+        if (subgraph_output_tensor_type.has_shape()) {
+          // infer shape of scan-output from the shape of scan-output-element
+          // by adding sequence-length at the correct axis position
+          const TensorShapeProto& subgraph_output_shape = subgraph_output_tensor_type.shape();
+          TensorShapeProto inferred_shape;
+
+          auto subgraph_output_rank = subgraph_output_shape.dim_size();
+          auto output_rank = subgraph_output_rank + 1;
+          int output_axis = static_cast<int>(output_axes[i - num_loop_state_vars]);
+          output_axis = handle_negative_axis_validate_opset9("scan_output_axes", output_axis, output_rank);
+
+          for (int j = 0; j < output_axis; ++j)
+            *(inferred_shape.add_dim()) = subgraph_output_shape.dim(j);
+          *(inferred_shape.add_dim()) = sequence_len_dim;
+          for (int j = output_axis; j < subgraph_output_rank; ++j)
+            *(inferred_shape.add_dim()) = subgraph_output_shape.dim(j);
+
+          // Merge inferred shape with existing shape information
+          mergeInShapeInfo(inferred_shape, *mutable_scan_output_tensor_type);
+        }
+      }
+    }
+  }
+}
+
+static constexpr const char* scan_opset8_doc = R"DOC(
+Scan can be used to iterate over one or more scan_input tensors,
+constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+generalizations of RNN-like constructs for sequence-to-sequence processing.
+Other tensors (referred to as state_variables here) can be used to carry a state
+when iterating from one element to another (similar to hidden-state in RNNs, also referred
+to as loop-carried dependences in the context of loops). All these tensors are required to
+have the same shape in each iteration of the loop (a restriction imposed to enable efficient
+memory allocation). Many common usages involve a single scan_input tensor (where functionality
+similar to scan, fold and map can be obtained). When more than one scan_input is used,
+a behavior similar to zip is obtained.
+
+The attribute body must be a graph, specifying the computation to be performed in
+every iteration. It takes as input the current values of the state_variables and
+the current iterated element of the scan_inputs. It must return the (updated) values
+of the state_variables and zero or more scan_output_element tensors. The values of the
+scan_output_element tensors are concatenated over all the iterations to produce the
+scan_output values of the scan construct (similar to the concatenated intermediate
+hidden-state values of RNN-like constructs).
+
+The scan operation returns the final values of the state_variables as well as the
+scan_outputs.
+
+The operation supports batching, and the batch-axis is required to be 0.
+When multiple scan_input tensors are used, they must all have the same batch-size,
+and they must all have the same maximum-sequence-length (the dimensionality of the
+sequence axis or scan axis). The sequence axis or scan axis is required to be 1.
+
+The operation has an optional sequence_lens input (of shape [BATCH_SIZE]) to
+allow variable length sequences of length <= the maximum-sequence-length. If this
+input is not specified, all sequences are assumed to be of length equal to
+maximum-sequence-length. For variable length input sequences, the scan_outputs
+will consist of a sequence of same length as the input, padded to the
+maximum-sequence-length.
+
+The optional attribute directions can be used to scan a sequence in the reverse direction.
+If this attribute is omitted, all sequences are scanned in the forward direction.
+A bidirectional scan be performed by specifying the same tensor input twice in the
+scan_inputs, once with a forward direction, and once with a backward direction.
+
+Note that because of the ONNX restriction that only the last parameter of an operator can
+be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+Similarly, the final-states and scan-outputs are listed together as one output parameter.
+The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+The behavior of
+
+    Scan <
+        num_scan_inputs = m,
+        body = loop-body
+    > (sequence_lengths, init_1, ..., init_n, scan_1, ..., scan_m)
+
+is equivalent to the following pseudo-code:
+
+    // T.shape[0] denotes the batch-size of T
+    // The batch-size of scan_1, ..., scan_m are all required to be equal
+    batch_size = scan_1.shape[0];
+
+    // scan_i.shape[1] denotes the (max) sequence-length of scan_i
+    // scan_i.shape[1] is required to be equal to scan_j.shape[1] for all i,j.
+    max_sequence_length = scan_1.shape[1];
+
+    for (int batch = 0; batch < batch_size; ++batch) {
+        // initialize state-variables
+        st_1 = init_1; ... st_n = init_n;
+        // initialize scan-output variables: [] denotes an empty tensor
+        scan_out_1 = []; ...; scan_out_k = [];
+        // identify number of iterations:
+        N = (sequence_lengths specified) ? sequence_lengths[batch] : max_sequence_length;
+
+        // execute loop
+        for (int t = 0; t < N; ++t) {
+            // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+            // of rank one less than T obtained by indexing T at position t along axis k.
+            si_1 = (scan_1<axis=0>[batch])<axis=1>[t];
+            ... ;
+            si_m = (scan_m<axis=0>[batch])<axis=1>[t];
+            // execute loop-body
+            st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+            // accumulate the scan-output elements
+            scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+        }
+        // accumulate the outputs for this batch:
+        bst_1[batch] = st_1; ..., bst_n[batch] = st_n;
+        // Note scan-outputs will have size max_sequence_length, but only first N values will be meaningful.
+        // The remaining values have an undefined value.
+        b_scan_out_1[batch] = scan_out_1; ...; b_scan_out_k[batch] = scan_out_k;
+    }
+    return bst_1, ..., bst_n, b_scan_out_1, ..., b_scan_out_k;
+
+
+
+*Sample usage: Encoding RNN using a Scan*
+
+The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+%Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+    graph rnn-encoding {
+      %H_0 = ...
+      %X = ...
+      %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1]("", %H_0, %X)
+      return %Y, %Y_h
+    }
+
+    graph rnn-cell-1 (
+      %H_tminus1[FLOAT, tensor]
+      %X_t[FLOAT, tensor]
+    ) {
+      %Wi = ...
+      %Ri = ...
+      %Wbi = ...
+      %Rbi = ...
+      %t1 = X_t * (Wi^T)
+      %t2 = H_tminus1*(Ri^T)
+      %t3 = Add(%t1, %t2)
+      %t4 = Add(%t3, %Wbi)
+      %t5 = Add(%t4, %Rbi)
+      %Ht = Tanh(%t5)
+      %Accumulate = Identity(%Ht)
+      return %Ht, %Accumulate
+    }
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scan,
+    8,
+    OpSchema()
+        .SetDoc(scan_opset8_doc)
+        .Input(
+            0,
+            "sequence_lens",
+            "Optional tensor specifying lengths of the sequences in a batch. "
+            "If this input is not specified, all sequences are assumed to be of "
+            "the maximum sequence length (the dimension of the sequence axis of "
+            "the scan_input tensors).",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "initial_state_and_scan_inputs",
+            "Initial values of the loop's N state variables followed by M scan_inputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "final_state_and_scan_outputs",
+            "Final values of the loop's N state variables followed by K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has N+M inputs: "
+            "(loop state variables..., scan_input_elts...). It has N+K outputs: "
+            "(loop state variables..., scan_output_elts...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "scan_output_elt value at the end of each iteration of the loop. It is an error"
+            " if the dimensions of these values change across loop iterations.",
+            AttributeProto::GRAPH,
+            true)
+        .Attr("num_scan_inputs", "An attribute specifying the number of scan_inputs M. ", AttributeProto::INT, true)
+        .Attr(
+            "directions",
+            "An optional list of M flags. The i-th element of the list specifies the direction "
+            "to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 "
+            "indicates reverse direction. "
+            "If omitted, all scan_input tensors will be scanned in the forward direction.",
+            AttributeProto::INTS,
+            false)
+        .TypeConstraint("I", {types::Int64}, "Int64 tensor")
+        .TypeConstraint("V", OpSchema::all_tensor_types(), "All Tensor types")
+        .TypeAndShapeInferenceFunction(ScanInferenceFunction_opset8));
+
+static void LoopInferenceFunction_opset8(InferenceContext& ctx) {
+  auto num_inputs = ctx.getNumInputs();
+  auto num_loop_state_vars = num_inputs - 2; // skip 'M' and 'cond'
+
+  std::vector<const TypeProto*> subgraph_input_types;
+
+  std::vector<TypeProto> temporary_type_protos;
+  temporary_type_protos.reserve(num_inputs - 2);
+
+  // create TypeProto to validate iteration number type is the same as the
+  // optional 'M' input for max iterations.
+  TypeProto iter_num_type;
+  iter_num_type.mutable_tensor_type()->set_elem_type(TensorProto_DataType_INT64);
+  subgraph_input_types.emplace_back(&iter_num_type);
+
+  // 'cond'
+  subgraph_input_types.emplace_back(ctx.getInputType(1));
+
+  // loop state value types get propagated to outputs, but shape may change
+  // across iterations so don't propagate it to the outputs and don't pass it
+  // into the subgraph inferencing
+  for (size_t i = 2; i < num_inputs; ++i) {
+    propagateElemTypeFromInputToOutput(ctx, i, i - 2);
+
+    // copy so we can remove the shape before passing to the subgraph
+    // inferencing
+    temporary_type_protos.emplace_back(*ctx.getInputType(i));
+    auto& input_type = temporary_type_protos.back();
+    input_type.mutable_tensor_type()->clear_shape();
+
+    subgraph_input_types.emplace_back(&input_type);
+  }
+
+  // Run inferencing on the subgraph
+  std::vector<const TypeProto*> subgraph_output_types;
+
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("body");
+  if (graphInferencer) {
+    std::vector<const TensorProto*> input_data;
+    input_data.emplace_back(nullptr); // iteration number
+    for (size_t i = 1; i < num_inputs; ++i) {
+      input_data.emplace_back(ctx.getInputData(i));
+    }
+
+    subgraph_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  // if empty(), assume inferencing was skipped
+  if (!subgraph_output_types.empty()) {
+    auto num_outputs = ctx.getNumOutputs();
+
+    // subgraph outputs the condition value first but that is only used
+    // internally and not returned by Loop.
+    if (subgraph_output_types.size() != num_outputs + 1) {
+      fail_type_inference(
+          "Graph attribute inferencing returned type information for ",
+          subgraph_output_types.size(),
+          " outputs. Expected ",
+          num_outputs + 1);
+    }
+
+    // check loop state values match. we should already have type/shape info
+    for (size_t i = 0; i < num_outputs; ++i) {
+      const auto* const subgraph_output_type = subgraph_output_types[i + 1]; // skip 'cond'
+      auto* loop_output_type = ctx.getOutputType(i);
+
+      const bool is_loop_state_var = i < num_loop_state_vars;
+
+      if (!subgraph_output_type->has_tensor_type()) {
+        fail_type_inference(
+            "Loop 'body' subgraph outputs should all be tensors but output ",
+            i,
+            " was ",
+            subgraph_output_type->value_case());
+      }
+
+      // if there's an existing type check it matches. otherwise propagate
+      propagateElemTypeWithValidation(subgraph_output_type, loop_output_type);
+
+      if (is_loop_state_var) {
+        // shape may change across iterations so ignore.
+      } else {
+        // propagate shape
+        if (subgraph_output_type->tensor_type().has_shape()) {
+          // per iteration output. first dimension will be number of iterations
+          // but we don't know that value yet
+          TypeProto inferred_type(*subgraph_output_type);
+          auto* mutable_inferred_tensor_type = inferred_type.mutable_tensor_type();
+          auto* mutable_inferred_shape = mutable_inferred_tensor_type->mutable_shape();
+
+          mutable_inferred_shape->clear_dim();
+
+          // add empty dimension for number of iterations
+          mutable_inferred_shape->add_dim();
+
+          // add dimensions from subgraph output shape
+          for (const auto& dim : subgraph_output_type->tensor_type().shape().dim()) {
+            (*mutable_inferred_shape->add_dim()) = dim;
+          }
+
+          mergeInShapeInfo(*mutable_inferred_tensor_type, *loop_output_type->mutable_tensor_type());
+        }
+      }
+    }
+  }
+}
+
+static constexpr const char* Loop_ver1_doc = R"DOC(
+Generic Looping construct. This loop has multiple termination conditions:
+
+1) Trip count. Iteration count specified at runtime. Set by
+   specifying the input M. Optional. Set to empty string to omit.
+   Note that a static trip count (specified at graph construction time) can be
+   specified by passing in a constant node for input M.
+2) Loop termination condition. This is an input to the op that determines
+   whether to run the first iteration and also a loop-carried dependency for
+   the body graph. The body graph must yield a value for the condition variable,
+   whether this input is provided or not.
+
+This table summarizes the operating modes of this operator with equivalent
+C-style code:
+
+Operator inputs defined as (max_trip_count, condition_var).
+
+    input ("", ""):
+        for (int i=0; ; ++i) {
+          cond = ... // Note this value is ignored, but is required in the body
+        }
+
+    input ("", cond) // Note this is analogous to a while loop
+        bool cond = ...;
+        for (int i=0; cond; ++i) {
+          cond = ...;
+        }
+
+    input ("", 1) // Note this is analogous to a do-while loop
+        bool cond = true
+        for (int i=0; cond; ++i) {
+          cond = ...;
+        }
+
+    input (trip_count, "") // Note this is analogous to a for loop
+        int trip_count = ...
+        for (int i=0; i < trip_count; ++i) {
+          cond = ...; // ignored
+        }
+
+    input (trip_count, cond)
+        int trip_count = ...;
+        bool cond = ...;
+        for (int i=0; i < trip_count && cond; ++i) {
+          cond = ...;
+        }
+
+
+*Sample usage - cond as well as trip count*
+
+    graph predict-net {
+      %a = Constant[value = <Scalar Tensor [3]>]()
+      %b = Constant[value = <Scalar Tensor [6]>]()
+      %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+      %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+      %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+      return
+    }
+
+    graph body-net (
+      %i[INT32, scalar]
+      %keepgoing[BOOL, scalar]
+      %b[INT32, scalar]
+    ) {
+      %my_local = Add(%a, %b)
+      %b_out = Sub(%a, %b)
+      %keepgoing_out = Greater(%my_local, %b_out)
+      %user_defined_vals = Add(%b, %b)
+      return %keepgoing_out, %b_out, %user_defined_vals
+    }
+
+*Sample equivalent C code*
+
+    {
+      /* User-defined code (enclosing scope) */
+      int a = 3, b = 6;
+      bool keepgoing = true; // Analogous to input cond
+      /* End user-defined code */
+
+      /* Implicitly-defined code */
+      const int max_trip_count = 10; // Analogous to input M
+      int user_defined_vals[]; // Imagine this is resizable
+      /* End implicitly-defined code */
+      for (int i=0; i < max_trip_count && keepgoing; ++i) {
+        /* User-defined code (loop body) */
+        int my_local = a + b; // Reading values in the enclosing scope is fine
+        b = a - b; // writes fine if we specify b as a loop-carried dependency
+        keepgoing = my_local > b; // keepgoing is a loop-carried dependency
+        user_defined_vals[i] = b + b;
+        /* End user-defined code */
+      }
+      // my_local = 123; // Can't do this. my_local was defined in the body
+
+      // These below values are live-out from the loop and therefore accessible
+      b_out; user_defined_vals; keepgoing_out;
+    }
+
+There are several things of note in this code snippet:
+
+1) Values from the enclosing scope (i.e. variable a here) are in scope and can
+   be referenced in the inputs of the loop.
+2) Any variables which you wish to make available in the enclosing scope (i.e.
+   the variables b and keepgoing) must be declared as either loop-carried
+   dependencies (both at the op inputs and output and at the body net input and
+   output) or scan_outputs.
+3) Values created in the body cannot be accessed in the enclosing scope.
+
+Note that the semantics of this op support "diagonal" or "wavefront" execution.
+(See Step 3 here for an example:
+https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+Frontends should emit multi-layer RNNs as a series of While operators (with
+time being the inner looping dimension), with each successive layer consuming
+the scan_outputs from the previous layer, possibly going through several
+point-wise operators (e.g. dropout, residual connections, linear layer).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Loop,
+    1,
+    OpSchema()
+        .SetDoc(Loop_ver1_doc)
+        .Input(
+            0,
+            "M",
+            "A maximum trip-count for the loop specified at runtime. Optional."
+            " Pass empty string to skip.",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "cond",
+            "A boolean termination condition. Optional. Pass empty string to skip.",
+            "B",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "v_initial",
+            "The initial values of any loop-carried dependencies (values that "
+            "change across loop iterations)",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "v_final_and_scan_outputs",
+            "Final N loop carried dependency values then K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has 2+N inputs: (iteration_num, "
+            "condition, loop carried dependencies...). It has 1+N+K outputs: "
+            "(condition, loop carried dependencies..., scan_outputs...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "output value at the end of each iteration of the loop. It is an error"
+            " if the dimensions or data type of these scan_outputs change across loop"
+            " iterations.",
+            AttributeProto::GRAPH)
+        .TypeConstraint("V", OpSchema::all_tensor_types(), "All Tensor types")
+        .TypeConstraint("I", {types::Int64}, "tensor of int64, which should be a scalar.")
+        .TypeConstraint("B", {types::Bool}, "tensor of bool, which should be a scalar.")
+        .TypeAndShapeInferenceFunction(LoopInferenceFunction_opset8));
+
+static void LoopInferenceFunction_opset11(InferenceContext& ctx) {
+  auto num_inputs = ctx.getNumInputs();
+  auto num_loop_state_vars = num_inputs - 2; // skip 'M' and 'cond'
+
+  std::vector<const TypeProto*> subgraph_input_types;
+
+  std::vector<TypeProto> temporary_type_protos;
+  temporary_type_protos.reserve(num_inputs - 2);
+
+  // create TypeProto to validate iteration number type is the same as the
+  // optional 'M' input for max iterations.
+  TypeProto iter_num_type;
+  iter_num_type.mutable_tensor_type()->set_elem_type(TensorProto_DataType_INT64);
+  subgraph_input_types.emplace_back(&iter_num_type);
+
+  // 'cond'
+  subgraph_input_types.emplace_back(ctx.getInputType(1));
+
+  // loop state value types get propagated to outputs, but shape may change
+  // across iterations so don't propagate it to the outputs and don't pass it
+  // into the subgraph inferencing
+  for (size_t i = 2; i < num_inputs; ++i) {
+    propagateElemTypeFromInputToOutput(ctx, i, i - 2);
+
+    // copy so we can remove the shape before passing to the subgraph
+    // inferencing
+    temporary_type_protos.emplace_back(*ctx.getInputType(i));
+    auto& input_type = temporary_type_protos.back();
+    input_type.mutable_tensor_type()->clear_shape();
+
+    subgraph_input_types.emplace_back(&input_type);
+  }
+
+  // Run inferencing on the subgraph
+  std::vector<const TypeProto*> subgraph_output_types;
+
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("body");
+  if (graphInferencer) {
+    std::vector<const TensorProto*> input_data;
+    input_data.emplace_back(nullptr); // iteration number
+    for (size_t i = 1; i < num_inputs; ++i) {
+      input_data.emplace_back(ctx.getInputData(i));
+    }
+
+    subgraph_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  // if empty(), assume inferencing was skipped
+  if (!subgraph_output_types.empty()) {
+    auto num_outputs = ctx.getNumOutputs();
+
+    // subgraph outputs the condition value first but that is only used
+    // internally and not returned by Loop.
+    if (subgraph_output_types.size() != num_outputs + 1) {
+      fail_type_inference(
+          "Graph attribute inferencing returned type information for ",
+          subgraph_output_types.size(),
+          " outputs. Expected ",
+          num_outputs + 1);
+    }
+
+    // check loop state values match. we should already have type/shape info
+    for (size_t i = 0; i < num_outputs; ++i) {
+      const auto* const subgraph_output_type = subgraph_output_types[i + 1]; // skip 'cond'
+      auto* loop_output_type = ctx.getOutputType(i);
+
+      const bool is_loop_state_var = i < num_loop_state_vars;
+
+      if (!subgraph_output_type->has_tensor_type()) {
+        fail_type_inference(
+            "Loop 'body' subgraph outputs should all be tensors but output ",
+            i,
+            " was ",
+            subgraph_output_type->value_case());
+      }
+
+      // if there's an existing type check it matches. otherwise propagate
+      propagateElemTypeWithValidation(subgraph_output_type, loop_output_type);
+
+      if (is_loop_state_var) {
+        // shape may change across iterations so ignore.
+      } else {
+        // propagate shape
+        if (subgraph_output_type->tensor_type().has_shape()) {
+          // per iteration output. first dimension will be number of iterations
+          // but we don't know that value yet
+          TypeProto inferred_type(*subgraph_output_type);
+          auto* mutable_inferred_tensor_type = inferred_type.mutable_tensor_type();
+          auto* mutable_inferred_shape = mutable_inferred_tensor_type->mutable_shape();
+
+          mutable_inferred_shape->clear_dim();
+
+          // add empty dimension for number of iterations
+          mutable_inferred_shape->add_dim();
+
+          // add dimensions from subgraph output shape
+          for (const auto& dim : subgraph_output_type->tensor_type().shape().dim()) {
+            (*mutable_inferred_shape->add_dim()) = dim;
+          }
+
+          mergeInShapeInfo(*mutable_inferred_tensor_type, *loop_output_type->mutable_tensor_type());
+        }
+      }
+    }
+  }
+}
+
+static constexpr const char* Loop_ver11_doc = R"DOC(
+Generic Looping construct. This loop has multiple termination conditions:
+
+1) Trip count. Iteration count specified at runtime. Set by
+   specifying the input M. Optional. Set to empty string to omit.
+   Note that a static trip count (specified at graph construction time) can be
+   specified by passing in a constant node for input M.
+2) Loop termination condition. This is an input to the op that determines
+   whether to run the first iteration and also a loop-carried dependency for
+   the body graph. The body graph must yield a value for the condition variable,
+   whether this input is provided or not.
+
+This table summarizes the operating modes of this operator with equivalent
+C-style code:
+
+Operator inputs defined as (max_trip_count, condition_var).
+
+    input ("", ""):
+        for (int i=0; ; ++i) {
+          cond = ... // Note this value is ignored, but is required in the body
+        }
+
+    input ("", cond) // Note this is analogous to a while loop
+        bool cond = ...;
+        for (int i=0; cond; ++i) {
+          cond = ...;
+        }
+
+    input ("", 1) // Note this is analogous to a do-while loop
+        bool cond = true
+        for (int i=0; cond; ++i) {
+          cond = ...;
+        }
+
+    input (trip_count, "") // Note this is analogous to a for loop
+        int trip_count = ...
+        for (int i=0; i < trip_count; ++i) {
+          cond = ...; // ignored
+        }
+
+    input (trip_count, cond)
+        int trip_count = ...;
+        bool cond = ...;
+        for (int i=0; i < trip_count && cond; ++i) {
+          cond = ...;
+        }
+
+
+*Sample usage - cond as well as trip count*
+
+    graph predict-net {
+      %a = Constant[value = <Scalar Tensor [3]>]()
+      %b = Constant[value = <Scalar Tensor [6]>]()
+      %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+      %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+      %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+      return
+    }
+
+    graph body-net (
+      %i[INT32, scalar]           // iteration number
+      %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+      %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+    ) {
+      %my_local = Add(%a, %b_in)
+      %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+      %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+      %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+      return %keepgoing_out, %b_out, %user_defined_val
+    }
+
+*Sample equivalent C code*
+
+    {
+      /* User-defined code (enclosing scope) */
+      int a = 3, b = 6;
+      bool keepgoing = true; // Analogous to input cond
+      /* End user-defined code */
+
+      /* Implicitly-defined code */
+      const int max_trip_count = 10; // Analogous to input M
+      int user_defined_vals[]; // Imagine this is resizable
+      /* End implicitly-defined code */
+      /* initialize loop-carried variables and scan-output variables */
+      bool keepgoing_out = keepgoing
+      int b_out = b
+
+      for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+        /* Implicitly-defined code: bind actual parameter values
+           to formal parameter variables of loop-body */
+        bool keepgoing_in = keepgoing_out;
+        bool b_in = b_out;
+
+        /* User-defined code (loop body) */
+        int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+        b_out = a - b_in;
+        keepgoing_out = my_local > b_out;
+        user_defined_val = b_in + b_in; // b_in and b_out are different variables
+        /* End user-defined code */
+
+        /* Implicitly defined-code */
+        user_defined_vals[i] = user_defined_val // accumulate scan-output values
+      }
+      // int t = my_local; // Can't do this. my_local is not accessible here.
+
+      // The values below are bound to the output variables of the loop and therefore accessible
+      // b_out; user_defined_vals; keepgoing_out;
+    }
+
+There are several things of note in this code snippet:
+
+1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+   be referenced in the inputs of the loop.
+2) Any values computed in the loop body that needs to be used in a subsequent
+   iteration or after the loop are modeled using a pair of variables in the loop-body,
+   consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+   These are referred to as loop-carried dependences. The loop operation node
+   supplies the input value of the input variable for the first iteration, and
+   returns the output value of the output variable produced by the final
+   iteration.
+3) Scan_output variables are used to implicitly concatenate values computed across
+   all the iterations. In the above example, the value of user_defined_val computed
+   over all iterations are concatenated and returned as the value of user_defined_vals
+   after the loop.
+4) Values created in the body cannot be accessed in the enclosing scope,
+   except using the mechanism described above.
+
+Note that the semantics of this op support "diagonal" or "wavefront" execution.
+(See Step 3 here for an example:
+https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+Frontends should emit multi-layer RNNs as a series of While operators (with
+time being the inner looping dimension), with each successive layer consuming
+the scan_outputs from the previous layer, possibly going through several
+point-wise operators (e.g. dropout, residual connections, linear layer).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Loop,
+    11,
+    OpSchema()
+        .SetDoc(Loop_ver11_doc)
+        .Input(
+            0,
+            "M",
+            "A maximum trip-count for the loop specified at runtime. Optional."
+            " Pass empty string to skip.",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "cond",
+            "A boolean termination condition. Optional. Pass empty string to skip.",
+            "B",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "v_initial",
+            "The initial values of any loop-carried dependencies (values that "
+            "change across loop iterations)",
+            "V",
+            OpSchema::Variadic,
+            false,
+            0)
+        .Output(
+            0,
+            "v_final_and_scan_outputs",
+            "Final N loop carried dependency values then K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has 2+N inputs: (iteration_num, "
+            "condition, loop carried dependencies...). It has 1+N+K outputs: "
+            "(condition, loop carried dependencies..., scan_outputs...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "output value at the end of each iteration of the loop. It is an error"
+            " if the dimensions or data type of these scan_outputs change across loop"
+            " iterations.",
+            AttributeProto::GRAPH)
+        .TypeConstraint("V", OpSchema::all_tensor_types(), "All Tensor types")
+        .TypeConstraint("I", {types::Int64}, "tensor of int64, which should be a scalar.")
+        .TypeConstraint("B", {types::Bool}, "tensor of bool, which should be a scalar.")
+        .TypeAndShapeInferenceFunction(LoopInferenceFunction_opset11));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scan,
+    9,
+    OpSchema()
+        .SetDoc(kDoc_scan_24)
+        .Input(
+            0,
+            "initial_state_and_scan_inputs",
+            "Initial values of the loop's N state variables followed by M scan_inputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "final_state_and_scan_outputs",
+            "Final values of the loop's N state variables followed by K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has N+M inputs: "
+            "(loop state variables..., scan_input_elts...). It has N+K outputs: "
+            "(loop state variables..., scan_output_elts...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "scan_output_elt value at the end of each iteration of the loop. It is an error"
+            " if the dimensions of these values change across loop iterations.",
+            AttributeProto::GRAPH,
+            true)
+        .Attr("num_scan_inputs", "An attribute specifying the number of scan_inputs M. ", AttributeProto::INT, true)
+        .Attr(
+            "scan_input_directions",
+            "An optional list of M flags. The i-th element of the list specifies the direction "
+            "to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 "
+            "indicates reverse direction. "
+            "If omitted, all scan_input tensors will be scanned in the forward direction.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_directions",
+            "An optional list of K flags, one for each scan_output. The i-th element of the list "
+            "specifies whether the i-th scan_output should be constructed by appending or "
+            "prepending a new value in each iteration: 0 indicates appending and 1 "
+            "indicates prepending. "
+            "If omitted, all scan_output tensors will be produced by appending a value "
+            "in each iteration.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_input_axes",
+            "An optional list of M flags. The i-th element of the list specifies the axis "
+            "to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will "
+            "be used as the scan axis for every scan_input.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_axes",
+            "An optional list of K flags. The i-th element of the list specifies the axis "
+            "for the i-th scan_output. The scan outputs are accumulated along the specified "
+            "axis. If omitted, 0 will be used as the scan axis for every scan_output.",
+            AttributeProto::INTS,
+            false)
+        .TypeConstraint("V", OpSchema::all_tensor_types(), "All Tensor types")
+        .TypeAndShapeInferenceFunction(ScanInferenceFunction_opset9));
+
+static void IfInferenceFunction_opset1(InferenceContext& ctx) {
+  // there are no inputs so we just need to run the subgraph inferencing for
+  // then/else subgraphs and apply those to the outputs.
+  std::vector<const TypeProto*> subgraph_input_types; // none
+  std::vector<const TensorProto*> input_data; // none
+
+  std::vector<const TypeProto*> then_output_types;
+  std::vector<const TypeProto*> else_output_types;
+
+  // Run inferencing on the subgraph
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("then_branch");
+  if (graphInferencer) {
+    then_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  graphInferencer = ctx.getGraphAttributeInferencer("else_branch");
+  if (graphInferencer) {
+    else_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  auto num_outputs = ctx.getNumOutputs();
+  auto num_then_outputs = then_output_types.size();
+  auto num_else_outputs = else_output_types.size();
+
+  // the output types for then and else should be the same
+  if (num_then_outputs != num_else_outputs) {
+    fail_type_inference(
+        "then_branch and else_branch produce different number of outputs. ",
+        num_then_outputs,
+        " != ",
+        num_else_outputs);
+  }
+
+  if (num_then_outputs != num_outputs) {
+    fail_type_inference("If node has ", num_outputs, " but subgraphs produce ", num_then_outputs);
+  }
+
+  for (size_t i = 0, end = then_output_types.size(); i < end; ++i) {
+    const auto* const then_output = then_output_types[i];
+    const auto* const else_output = else_output_types[i];
+
+    if (then_output->value_case() != else_output->value_case()) {
+      fail_type_inference(
+          "Mismatched type for output ", i, " then=", then_output->value_case(), " else=", else_output->value_case());
+    }
+
+    auto* if_output = ctx.getOutputType(i);
+    *if_output = *then_output;
+
+    if (then_output->has_tensor_type()) {
+      auto then_elem_type = then_output->tensor_type().elem_type();
+      auto else_elem_type = else_output->tensor_type().elem_type();
+
+      if (then_elem_type != else_elem_type) {
+        fail_type_inference(
+            "Mismatched tensor element type for output ", i, " then=", then_elem_type, " else=", else_elem_type);
+      }
+
+      // merge the 'else' shape information to check it's consistent and
+      // augment the 'if' output if possible
+      mergeInShapeInfo(else_output->tensor_type(), *if_output->mutable_tensor_type());
+    }
+  }
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    If,
+    1,
+    OpSchema()
+        .SetDoc("If conditional")
+        .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
+        .Output(
+            0,
+            "outputs",
+            "Values that are live-out to the enclosing scope. The return values in "
+            "the `then_branch` and `else_branch` must be of the same shape and same "
+            "data type.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "then_branch",
+            "Graph to run if condition is true. Has N outputs: values you wish to "
+            "be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the else_branch.",
+            AttributeProto::GRAPH)
+        .Attr(
+            "else_branch",
+            "Graph to run if condition is false. Has N outputs: values you wish to"
+            " be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the then_branch.",
+            AttributeProto::GRAPH)
+        .TypeConstraint("V", OpSchema::all_tensor_types(), "All Tensor types")
+        .TypeConstraint("B", {types::Bool}, "Only bool")
+        .TypeAndShapeInferenceFunction(IfInferenceFunction_opset1));
+
+static void IfInferenceFunction_opset11(InferenceContext& ctx) {
+  // there are no inputs so we just need to run the subgraph inferencing for
+  // then/else subgraphs and apply those to the outputs.
+  std::vector<const TypeProto*> subgraph_input_types; // none
+  std::vector<const TensorProto*> input_data; // none
+
+  std::vector<const TypeProto*> then_output_types;
+  std::vector<const TypeProto*> else_output_types;
+
+  // Run inferencing on the subgraph
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("then_branch");
+  if (graphInferencer) {
+    then_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  graphInferencer = ctx.getGraphAttributeInferencer("else_branch");
+  if (graphInferencer) {
+    else_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  auto num_outputs = ctx.getNumOutputs();
+  auto num_then_outputs = then_output_types.size();
+  auto num_else_outputs = else_output_types.size();
+
+  // the output types for then and else should be the same
+  if (num_then_outputs != num_else_outputs) {
+    fail_type_inference(
+        "then_branch and else_branch produce different number of outputs. ",
+        num_then_outputs,
+        " != ",
+        num_else_outputs);
+  }
+
+  if (num_then_outputs != num_outputs) {
+    fail_type_inference("If node has ", num_outputs, " but subgraphs produce ", num_then_outputs);
+  }
+
+  for (size_t i = 0, end = then_output_types.size(); i < end; ++i) {
+    const auto* const then_output = then_output_types[i];
+    const auto* const else_output = else_output_types[i];
+
+    if (then_output->value_case() != else_output->value_case()) {
+      fail_type_inference(
+          "Mismatched type for output ", i, " then=", then_output->value_case(), " else=", else_output->value_case());
+    }
+
+    auto* if_output = ctx.getOutputType(i);
+    *if_output = *then_output;
+
+    if (then_output->has_tensor_type()) {
+      auto then_elem_type = then_output->tensor_type().elem_type();
+      auto else_elem_type = else_output->tensor_type().elem_type();
+
+      if (then_elem_type != else_elem_type) {
+        fail_type_inference(
+            "Mismatched tensor element type for output ", i, " then=", then_elem_type, " else=", else_elem_type);
+      }
+
+      UnionShapeInfo(else_output->tensor_type().shape(), *if_output->mutable_tensor_type());
+    }
+  }
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    If,
+    11,
+    OpSchema()
+        .SetDoc("If conditional")
+        .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
+        .Output(
+            0,
+            "outputs",
+            "Values that are live-out to the enclosing scope. The return values in "
+            "the `then_branch` and `else_branch` must be of the same data type. "
+            "The `then_branch` and `else_branch` may produce tensors with the same "
+            "element type and different shapes. "
+            "If corresponding outputs from the then-branch and the else-branch have "
+            "static shapes S1 and S2, then the shape of the corresponding output "
+            "variable of the if-node (if present) must be compatible with both S1 "
+            "and S2 as it represents the union of both possible shapes."
+            "For example, if in a model file, the first "
+            "output of `then_branch` is typed float tensor with shape [2] and the "
+            "first output of `else_branch` is another float tensor with shape [3], "
+            "If's first output should have (a) no shape set, or (b) "
+            "a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) "
+            "a shape of rank 1 with a unique `dim_param`. "
+            "In contrast, the first output cannot have the shape [2] since [2] and "
+            "[3] are not compatible.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "then_branch",
+            "Graph to run if condition is true. Has N outputs: values you wish to "
+            "be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the else_branch.",
+            AttributeProto::GRAPH)
+        .Attr(
+            "else_branch",
+            "Graph to run if condition is false. Has N outputs: values you wish to"
+            " be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the then_branch.",
+            AttributeProto::GRAPH)
+        .TypeConstraint("V", OpSchema::all_tensor_types(), "All Tensor types")
+        .TypeConstraint("B", {types::Bool}, "Only bool")
+        .TypeAndShapeInferenceFunction(IfInferenceFunction_opset11));
+
+static void IfInferenceFunction_opset13(InferenceContext& ctx) {
+  // there are no inputs so we just need to run the subgraph inferencing for
+  // then/else subgraphs and apply those to the outputs.
+  std::vector<const TypeProto*> subgraph_input_types; // none
+  std::vector<const TensorProto*> input_data; // none
+
+  std::vector<const TypeProto*> then_output_types;
+  std::vector<const TypeProto*> else_output_types;
+
+  // Run inferencing on the subgraph
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("then_branch");
+  if (graphInferencer) {
+    then_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  graphInferencer = ctx.getGraphAttributeInferencer("else_branch");
+  if (graphInferencer) {
+    else_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  auto num_outputs = ctx.getNumOutputs();
+  auto num_then_outputs = then_output_types.size();
+  auto num_else_outputs = else_output_types.size();
+
+  // the output types for then and else should be the same
+  if (num_then_outputs != num_else_outputs) {
+    fail_type_inference(
+        "then_branch and else_branch produce different number of outputs. ",
+        num_then_outputs,
+        " != ",
+        num_else_outputs);
+  }
+
+  if (num_then_outputs != num_outputs) {
+    fail_type_inference("If node has ", num_outputs, " but subgraphs produce ", num_then_outputs);
+  }
+
+  for (size_t i = 0, end = then_output_types.size(); i < end; ++i) {
+    const auto* const then_output = then_output_types[i];
+    const auto* const else_output = else_output_types[i];
+
+    auto* if_output = ctx.getOutputType(i);
+    *if_output = *then_output;
+
+    UnionTypeInfo(*else_output, *if_output);
+  }
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    If,
+    13,
+    OpSchema()
+        .SetDoc("If conditional")
+        .Input(0, "cond", "Condition for the if. The tensor must contain a single element.", "B")
+        .Output(
+            0,
+            "outputs",
+            "Values that are live-out to the enclosing scope. The return values in "
+            "the `then_branch` and `else_branch` must be of the same data type. "
+            "The `then_branch` and `else_branch` may produce tensors with the same "
+            "element type and different shapes. "
+            "If corresponding outputs from the then-branch and the else-branch have "
+            "static shapes S1 and S2, then the shape of the corresponding output "
+            "variable of the if-node (if present) must be compatible with both S1 "
+            "and S2 as it represents the union of both possible shapes."
+            "For example, if in a model file, the first "
+            "output of `then_branch` is typed float tensor with shape [2] and the "
+            "first output of `else_branch` is another float tensor with shape [3], "
+            "If's first output should have (a) no shape set, or (b) "
+            "a shape of rank 1 with neither `dim_value` nor `dim_param` set, or (c) "
+            "a shape of rank 1 with a unique `dim_param`. "
+            "In contrast, the first output cannot have the shape [2] since [2] and "
+            "[3] are not compatible.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "then_branch",
+            "Graph to run if condition is true. Has N outputs: values you wish to "
+            "be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the else_branch.",
+            AttributeProto::GRAPH)
+        .Attr(
+            "else_branch",
+            "Graph to run if condition is false. Has N outputs: values you wish to"
+            " be live-out to the enclosing scope. The number of outputs must match"
+            " the number of outputs in the then_branch.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types();
+              auto s = OpSchema::all_tensor_sequence_types();
+              t.insert(t.end(), s.begin(), s.end());
+              return t;
+            }(),
+            "All Tensor and Sequence types")
+        .TypeConstraint("B", {types::Bool}, "Only bool")
+        .TypeAndShapeInferenceFunction(IfInferenceFunction_opset13));
+
+static void LoopInferenceFunction_opset13(InferenceContext& ctx) {
+  auto num_inputs = ctx.getNumInputs();
+  assert(num_inputs >= 2);
+  auto num_loop_state_vars = num_inputs - 2; // skip 'M' and 'cond'
+
+  std::vector<const TypeProto*> subgraph_input_types;
+  subgraph_input_types.reserve(num_inputs);
+
+  std::vector<TypeProto> temporary_type_protos;
+  temporary_type_protos.reserve(num_inputs - 2);
+
+  // create TypeProto to validate iteration number type is the same as the
+  // optional 'M' input for max iterations.
+  TypeProto iter_num_type;
+  iter_num_type.mutable_tensor_type()->set_elem_type(TensorProto_DataType_INT64);
+  subgraph_input_types.emplace_back(&iter_num_type);
+
+  // 'cond'
+  subgraph_input_types.emplace_back(ctx.getInputType(1));
+
+  // loop state value types get propagated to outputs, but shape may change
+  // across iterations so don't propagate it to the outputs and don't pass it
+  // into the subgraph inferencing
+  for (size_t i = 2; i < num_inputs; ++i) {
+    propagateElemTypeFromInputToOutput(ctx, i, i - 2);
+
+    // copy so we can remove the shape before passing to the subgraph
+    // inferencing
+    temporary_type_protos.emplace_back(*ctx.getInputType(i));
+    auto& input_type = temporary_type_protos.back();
+
+    if (input_type.has_tensor_type()) {
+      input_type.mutable_tensor_type()->clear_shape();
+    } else if (input_type.has_sequence_type()) {
+      auto& seq_type = *input_type.mutable_sequence_type();
+      if (seq_type.has_elem_type() && seq_type.elem_type().has_tensor_type()) {
+        seq_type.mutable_elem_type()->mutable_tensor_type()->clear_shape();
+      }
+    }
+
+    subgraph_input_types.emplace_back(&input_type);
+  }
+
+  // Run inferencing on the subgraph
+  std::vector<const TypeProto*> subgraph_output_types;
+
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("body");
+  if (graphInferencer) {
+    std::vector<const TensorProto*> input_data;
+    input_data.emplace_back(nullptr); // iteration number
+    for (size_t i = 1; i < num_inputs; ++i) {
+      input_data.emplace_back(ctx.getInputData(i));
+    }
+
+    subgraph_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  // if empty(), assume inferencing was skipped
+  if (!subgraph_output_types.empty()) {
+    auto num_outputs = ctx.getNumOutputs();
+
+    // subgraph outputs the condition value first but that is only used
+    // internally and not returned by Loop.
+    if (subgraph_output_types.size() != num_outputs + 1) {
+      fail_type_inference(
+          "Graph attribute inferencing returned type information for ",
+          subgraph_output_types.size(),
+          " outputs. Expected ",
+          num_outputs + 1);
+    }
+
+    // check loop state values match. we should already have type/shape info
+    for (size_t i = 0; i < num_outputs; ++i) {
+      const auto* const subgraph_output_type = subgraph_output_types[i + 1]; // skip 'cond'
+      auto* loop_output_type = ctx.getOutputType(i);
+
+      const bool is_loop_state_var = i < num_loop_state_vars;
+
+      if (!subgraph_output_type->has_tensor_type() && !subgraph_output_type->has_sequence_type()) {
+        fail_type_inference(
+            "Loop 'body' subgraph outputs should all be tensors or sequences but output ",
+            i,
+            " was ",
+            subgraph_output_type->value_case());
+      }
+
+      if (!is_loop_state_var && !subgraph_output_type->has_tensor_type()) {
+        fail_type_inference(
+            "Loop 'body' subgraph scan outputs should all be tensors but output ",
+            i,
+            " was ",
+            subgraph_output_type->value_case());
+      }
+
+      // if there's an existing type check it matches. otherwise propagate
+      propagateElemTypeWithValidation(subgraph_output_type, loop_output_type);
+
+      if (is_loop_state_var) {
+        // shape may change across iterations so ignore.
+      } else {
+        // propagate shape
+        if (subgraph_output_type->tensor_type().has_shape()) {
+          // per iteration output. first dimension will be number of iterations
+          // but we don't know that value yet
+          TypeProto inferred_type(*subgraph_output_type);
+          auto* mutable_inferred_tensor_type = inferred_type.mutable_tensor_type();
+          auto* mutable_inferred_shape = mutable_inferred_tensor_type->mutable_shape();
+
+          mutable_inferred_shape->clear_dim();
+
+          // add empty dimension for number of iterations
+          mutable_inferred_shape->add_dim();
+
+          // add dimensions from subgraph output shape
+          for (const auto& dim : subgraph_output_type->tensor_type().shape().dim()) {
+            (*mutable_inferred_shape->add_dim()) = dim;
+          }
+
+          mergeInShapeInfo(*mutable_inferred_tensor_type, *loop_output_type->mutable_tensor_type());
+        }
+      }
+    }
+  }
+}
+
+static constexpr const char* Loop_ver13_doc = R"DOC(
+Generic Looping construct. This loop has multiple termination conditions:
+
+1) Trip count. Iteration count specified at runtime. Set by
+   specifying the input M. Optional. Set to empty string to omit.
+   Note that a static trip count (specified at graph construction time) can be
+   specified by passing in a constant node for input M.
+2) Loop termination condition. This is an input to the op that determines
+   whether to run the first iteration and also a loop-carried dependency for
+   the body graph. The body graph must yield a value for the condition variable,
+   whether this input is provided or not.
+
+This table summarizes the operating modes of this operator with equivalent
+C-style code:
+
+Operator inputs defined as (max_trip_count, condition_var).
+
+    input ("", ""):
+        for (int i=0; ; ++i) {
+          cond = ... // Note this value is ignored, but is required in the body
+        }
+
+    input ("", cond) // Note this is analogous to a while loop
+        bool cond = ...;
+        for (int i=0; cond; ++i) {
+          cond = ...;
+        }
+
+    input ("", 1) // Note this is analogous to a do-while loop
+        bool cond = true
+        for (int i=0; cond; ++i) {
+          cond = ...;
+        }
+
+    input (trip_count, "") // Note this is analogous to a for loop
+        int trip_count = ...
+        for (int i=0; i < trip_count; ++i) {
+          cond = ...; // ignored
+        }
+
+    input (trip_count, cond)
+        int trip_count = ...;
+        bool cond = ...;
+        for (int i=0; i < trip_count && cond; ++i) {
+          cond = ...;
+        }
+
+
+*Sample usage - cond as well as trip count*
+
+    graph predict-net {
+      %a = Constant[value = <Scalar Tensor [3]>]()
+      %b = Constant[value = <Scalar Tensor [6]>]()
+      %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+      %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+      %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+      return
+    }
+
+    graph body-net (
+      %i[INT32, scalar]           // iteration number
+      %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+      %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+    ) {
+      %my_local = Add(%a, %b_in)
+      %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+      %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+      %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+      return %keepgoing_out, %b_out, %user_defined_val
+    }
+
+*Sample equivalent C code*
+
+    {
+      /* User-defined code (enclosing scope) */
+      int a = 3, b = 6;
+      bool keepgoing = true; // Analogous to input cond
+      /* End user-defined code */
+
+      /* Implicitly-defined code */
+      const int max_trip_count = 10; // Analogous to input M
+      int user_defined_vals[]; // Imagine this is resizable
+      /* End implicitly-defined code */
+      /* initialize loop-carried variables and scan-output variables */
+      bool keepgoing_out = keepgoing
+      int b_out = b
+
+      for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+        /* Implicitly-defined code: bind actual parameter values
+           to formal parameter variables of loop-body */
+        bool keepgoing_in = keepgoing_out;
+        bool b_in = b_out;
+
+        /* User-defined code (loop body) */
+        int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+        b_out = a - b_in;
+        keepgoing_out = my_local > b_out;
+        user_defined_val = b_in + b_in; // b_in and b_out are different variables
+        /* End user-defined code */
+
+        /* Implicitly defined-code */
+        user_defined_vals[i] = user_defined_val // accumulate scan-output values
+      }
+      // int t = my_local; // Can't do this. my_local is not accessible here.
+
+      // The values below are bound to the output variables of the loop and therefore accessible
+      // b_out; user_defined_vals; keepgoing_out;
+    }
+
+There are several things of note in this code snippet:
+
+1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+   be referenced in the inputs of the loop.
+2) Any values computed in the loop body that needs to be used in a subsequent
+   iteration or after the loop are modeled using a pair of variables in the loop-body,
+   consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+   These are referred to as loop-carried dependences. The loop operation node
+   supplies the input value of the input variable for the first iteration, and
+   returns the output value of the output variable produced by the final
+   iteration.
+3) Scan_output variables are used to implicitly concatenate values computed across
+   all the iterations. In the above example, the value of user_defined_val computed
+   over all iterations are concatenated and returned as the value of user_defined_vals
+   after the loop.
+4) Values created in the body cannot be accessed in the enclosing scope,
+   except using the mechanism described above.
+
+Note that the semantics of this op support "diagonal" or "wavefront" execution.
+(See Step 3 here for an example:
+https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+Frontends should emit multi-layer RNNs as a series of While operators (with
+time being the inner looping dimension), with each successive layer consuming
+the scan_outputs from the previous layer, possibly going through several
+point-wise operators (e.g. dropout, residual connections, linear layer).
+
+The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Loop,
+    13,
+    OpSchema()
+        .SetDoc(Loop_ver13_doc)
+        .Input(
+            0,
+            "M",
+            "A maximum trip-count for the loop specified at runtime. Optional."
+            " Pass empty string to skip.",
+            "I",
+            OpSchema::Optional)
+        .Input(
+            1,
+            "cond",
+            "A boolean termination condition. Optional. Pass empty string to skip.",
+            "B",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "v_initial",
+            "The initial values of any loop-carried dependencies (values that "
+            "change across loop iterations)",
+            "V",
+            OpSchema::Variadic,
+            false,
+            0)
+        .Output(
+            0,
+            "v_final_and_scan_outputs",
+            "Final N loop carried dependency values then K scan_outputs. "
+            "Scan outputs must be Tensors.",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has 2+N inputs: (iteration_num, "
+            "condition, loop carried dependencies...). It has 1+N+K outputs: "
+            "(condition, loop carried dependencies..., scan_outputs...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "output value at the end of each iteration of the loop. It is an error"
+            " if the dimensions or data type of these scan_outputs change across loop"
+            " iterations.",
+            AttributeProto::GRAPH)
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types();
+              auto s = OpSchema::all_tensor_sequence_types();
+              t.insert(t.end(), s.begin(), s.end());
+              return t;
+            }(),
+            "All Tensor and Sequence types")
+        .TypeConstraint("I", {types::Int64}, "tensor of int64, which should be a scalar.")
+        .TypeConstraint("B", {types::Bool}, "tensor of bool, which should be a scalar.")
+        .TypeAndShapeInferenceFunction(LoopInferenceFunction_opset13));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scan,
+    11,
+    OpSchema()
+        .SetDoc(kDoc_scan_24)
+        .Input(
+            0,
+            "initial_state_and_scan_inputs",
+            "Initial values of the loop's N state variables followed by M scan_inputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "final_state_and_scan_outputs",
+            "Final values of the loop's N state variables followed by K scan_outputs",
+            "V",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "body",
+            "The graph run each iteration. It has N+M inputs: "
+            "(loop state variables..., scan_input_elts...). It has N+K outputs: "
+            "(loop state variables..., scan_output_elts...). Each "
+            "scan_output is created by concatenating the value of the specified "
+            "scan_output_elt value at the end of each iteration of the loop. It is an error"
+            " if the dimensions of these values change across loop iterations.",
+            AttributeProto::GRAPH,
+            true)
+        .Attr("num_scan_inputs", "An attribute specifying the number of scan_inputs M. ", AttributeProto::INT, true)
+        .Attr(
+            "scan_input_directions",
+            "An optional list of M flags. The i-th element of the list specifies the direction "
+            "to be scanned for the i-th scan_input tensor: 0 indicates forward direction and 1 "
+            "indicates reverse direction. "
+            "If omitted, all scan_input tensors will be scanned in the forward direction.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_directions",
+            "An optional list of K flags, one for each scan_output. The i-th element of the list "
+            "specifies whether the i-th scan_output should be constructed by appending or "
+            "prepending a new value in each iteration: 0 indicates appending and 1 "
+            "indicates prepending. "
+            "If omitted, all scan_output tensors will be produced by appending a value "
+            "in each iteration.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_input_axes",
+            "An optional list of M flags. The i-th element of the list specifies the axis "
+            "to be scanned (the sequence axis) for the i-th scan_input. If omitted, 0 will "
+            "be used as the scan axis for every scan_input. Negative value for an axis means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "scan_output_axes",
+            "An optional list of K flags. The i-th element of the list specifies the axis "
+            "for the i-th scan_output. The scan outputs are accumulated along the specified "
+            "axis. If omitted, 0 will be used as the scan axis for every scan_output. "
+            "Negative value for an axis means counting dimensions from the back. Accepted "
+            "range is [-r, r-1].",
+            AttributeProto::INTS,
+            false)
+        .TypeConstraint("V", OpSchema::all_tensor_types(), "All Tensor types")
+        .TypeAndShapeInferenceFunction(ScanInferenceFunction));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/controlflow/utils.cc b/onnx/defs/controlflow/utils.cc
new file mode 100644
index 0000000..26cebd0
--- /dev/null
+++ b/onnx/defs/controlflow/utils.cc
@@ -0,0 +1,377 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/controlflow/utils.h"
+
+#include <string>
+#include <vector>
+
+namespace ONNX_NAMESPACE {
+
+void ClearShape(TypeProto& input_type) {
+  if (input_type.has_tensor_type()) {
+    input_type.mutable_tensor_type()->clear_shape();
+  } else if (input_type.has_sequence_type()) {
+    auto& seq_type = *input_type.mutable_sequence_type();
+    if (seq_type.has_elem_type()) {
+      ClearShape(*(seq_type.mutable_elem_type()));
+    }
+  } else if (input_type.has_optional_type()) {
+    auto& opt_type = *input_type.mutable_optional_type();
+    if (opt_type.has_elem_type()) {
+      ClearShape(*(opt_type.mutable_elem_type()));
+    }
+  }
+}
+
+void IfInferenceFunction(InferenceContext& ctx) {
+  // there are no inputs so we just need to run the subgraph inferencing for
+  // then/else subgraphs and apply those to the outputs.
+  std::vector<const TypeProto*> subgraph_input_types; // none
+  std::vector<const TensorProto*> input_data; // none
+
+  std::vector<const TypeProto*> then_output_types;
+  std::vector<const TypeProto*> else_output_types;
+
+  // Run inferencing on the subgraph
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("then_branch");
+  if (graphInferencer) {
+    then_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  graphInferencer = ctx.getGraphAttributeInferencer("else_branch");
+  if (graphInferencer) {
+    else_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  auto num_outputs = ctx.getNumOutputs();
+  auto num_then_outputs = then_output_types.size();
+  auto num_else_outputs = else_output_types.size();
+
+  // the output types for then and else should be the same
+  if (num_then_outputs != num_else_outputs) {
+    fail_type_inference(
+        "then_branch and else_branch produce different number of outputs. ",
+        num_then_outputs,
+        " != ",
+        num_else_outputs);
+  }
+
+  if (num_then_outputs != num_outputs) {
+    fail_type_inference("If node has ", num_outputs, " but subgraphs produce ", num_then_outputs);
+  }
+
+  for (size_t i = 0, end = then_output_types.size(); i < end; ++i) {
+    const auto* const then_output = then_output_types[i];
+    const auto* const else_output = else_output_types[i];
+
+    auto* if_output = ctx.getOutputType(i);
+    *if_output = *then_output;
+
+    UnionTypeInfo(*else_output, *if_output);
+  }
+}
+
+void LoopInferenceFunction(InferenceContext& ctx) {
+  auto num_inputs = ctx.getNumInputs();
+  assert(num_inputs >= 2);
+  auto num_loop_state_vars = num_inputs - 2; // skip 'M' and 'cond'
+
+  std::vector<const TypeProto*> subgraph_input_types;
+  subgraph_input_types.reserve(num_inputs);
+
+  std::vector<TypeProto> temporary_type_protos;
+  temporary_type_protos.reserve(num_inputs - 2);
+
+  // create TypeProto to validate iteration number type is the same as the
+  // optional 'M' input for max iterations.
+  TypeProto iter_num_type;
+  iter_num_type.mutable_tensor_type()->set_elem_type(TensorProto_DataType_INT64);
+  subgraph_input_types.push_back(&iter_num_type);
+
+  // 'cond'
+  subgraph_input_types.push_back(ctx.getInputType(1));
+
+  // loop state value types get propagated to outputs, but shape may change
+  // across iterations so don't propagate it to the outputs and don't pass it
+  // into the subgraph inferencing
+  for (size_t i = 2; i < num_inputs; ++i) {
+    propagateElemTypeFromInputToOutput(ctx, i, i - 2);
+
+    // copy so we can remove the shape before passing to the subgraph
+    // inferencing
+    temporary_type_protos.push_back(*ctx.getInputType(i));
+    auto& input_type = temporary_type_protos.back();
+
+    ClearShape(input_type);
+    subgraph_input_types.push_back(&input_type);
+  }
+
+  // Run inferencing on the subgraph
+  std::vector<const TypeProto*> subgraph_output_types;
+
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("body");
+  if (graphInferencer) {
+    std::vector<const TensorProto*> input_data;
+    input_data.push_back(nullptr); // iteration number
+    for (size_t i = 1; i < num_inputs; ++i) {
+      input_data.push_back(ctx.getInputData(i));
+    }
+
+    subgraph_output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  // if empty(), assume inferencing was skipped
+  if (!subgraph_output_types.empty()) {
+    auto num_outputs = ctx.getNumOutputs();
+
+    // subgraph outputs the condition value first but that is only used
+    // internally and not returned by Loop.
+    if (subgraph_output_types.size() != num_outputs + 1) {
+      fail_type_inference(
+          "Graph attribute inferencing returned type information for ",
+          subgraph_output_types.size(),
+          " outputs. Expected ",
+          num_outputs + 1);
+    }
+
+    // check loop state values match. we should already have type/shape info
+    for (size_t i = 0; i < num_outputs; ++i) {
+      const auto* const subgraph_output_type = subgraph_output_types[i + 1]; // skip 'cond'
+      auto* loop_output_type = ctx.getOutputType(i);
+
+      const bool is_loop_state_var = i < num_loop_state_vars;
+
+      if (!subgraph_output_type->has_tensor_type() && !subgraph_output_type->has_sequence_type() &&
+          !subgraph_output_type->has_optional_type()) {
+        fail_type_inference(
+            "Loop 'body' subgraph outputs should all be tensors or sequences or optionals, but output ",
+            i,
+            " was ",
+            subgraph_output_type->value_case());
+      }
+
+      if (!is_loop_state_var && !subgraph_output_type->has_tensor_type()) {
+        fail_type_inference(
+            "Loop 'body' subgraph scan outputs should all be tensors but output ",
+            i,
+            " was ",
+            subgraph_output_type->value_case());
+      }
+
+      // if there's an existing type check it matches. otherwise propagate
+      propagateElemTypeWithValidation(subgraph_output_type, loop_output_type);
+
+      if (is_loop_state_var) {
+        // shape may change across iterations so ignore.
+      } else {
+        // propagate shape
+        if (subgraph_output_type->tensor_type().has_shape()) {
+          // per iteration output. first dimension will be number of iterations
+          // but we don't know that value yet
+          TypeProto inferred_type(*subgraph_output_type);
+          auto* mutable_inferred_tensor_type = inferred_type.mutable_tensor_type();
+          auto* mutable_inferred_shape = mutable_inferred_tensor_type->mutable_shape();
+
+          mutable_inferred_shape->clear_dim();
+
+          // add empty dimension for number of iterations
+          mutable_inferred_shape->add_dim();
+
+          // add dimensions from subgraph output shape
+          for (const auto& dim : subgraph_output_type->tensor_type().shape().dim()) {
+            (*mutable_inferred_shape->add_dim()) = dim;
+          }
+
+          mergeInShapeInfo(*mutable_inferred_tensor_type, *loop_output_type->mutable_tensor_type());
+        }
+      }
+    }
+  }
+}
+
+int handle_negative_axis_validate(const std::string& attrib, int axis, int rank) {
+  if (-rank > axis || axis >= rank) {
+    fail_shape_inference(attrib, " axis value ", axis, " is invalid for a tensor of rank ", rank);
+  }
+  return (axis >= 0 ? axis : axis + rank);
+}
+
+size_t ValidateScanCountsAndGetNumLoopStateVars(size_t num_inputs, size_t num_scan_inputs, size_t num_outputs) {
+  // Guard the subtractions below against underflow.
+  if (num_scan_inputs > num_inputs) {
+    fail_shape_inference(
+        "num_scan_inputs (", num_scan_inputs, ") cannot exceed the number of Scan inputs (", num_inputs, ").");
+  }
+  size_t num_loop_state_vars = num_inputs - num_scan_inputs;
+  if (num_loop_state_vars > num_outputs) {
+    fail_shape_inference(
+        "The number of outputs of the Scan (",
+        num_outputs,
+        ") should equal the sum of the number of loop state variables (",
+        num_loop_state_vars,
+        ") and the number of scan-outputs.");
+  }
+  return num_loop_state_vars;
+}
+
+void ScanInferenceFunction(InferenceContext& ctx) {
+  auto num_inputs = ctx.getNumInputs();
+  auto num_scan_inputs = narrow<size_t>(getRequiredAttributeInt(ctx, "num_scan_inputs"));
+  auto num_outputs = ctx.getNumOutputs();
+  auto num_loop_state_vars = ValidateScanCountsAndGetNumLoopStateVars(num_inputs, num_scan_inputs, num_outputs);
+  auto num_scan_outputs = num_outputs - num_loop_state_vars;
+
+  std::vector<int64_t> axes, output_axes;
+  if (getRepeatedAttribute(ctx, "scan_input_axes", axes)) {
+    if (axes.size() != num_scan_inputs) {
+      fail_shape_inference(
+          "Number of scan input axes specified (",
+          axes.size(),
+          ") is not equal to number of scan inputs (",
+          num_scan_inputs,
+          ").");
+    }
+  } else {
+    axes.insert(axes.end(), num_scan_inputs, 0);
+  }
+
+  if (getRepeatedAttribute(ctx, "scan_output_axes", output_axes)) {
+    if (output_axes.size() != num_scan_outputs) {
+      fail_shape_inference(
+          "Number of scan output axes specified (",
+          output_axes.size(),
+          ") is not equal to number of scan outputs (",
+          num_scan_outputs,
+          ").");
+    }
+  } else {
+    output_axes.insert(output_axes.end(), num_scan_outputs, 0);
+  }
+
+  std::vector<TypeProto> temporary_type_protos;
+  temporary_type_protos.reserve(num_inputs);
+
+  std::vector<const TypeProto*> subgraph_input_types;
+  subgraph_input_types.reserve(num_inputs);
+
+  TensorShapeProto_Dimension sequence_len_dim;
+
+  for (size_t i = 0; i < num_inputs; ++i) {
+    bool is_loop_state_var = i < num_loop_state_vars;
+    bool has_shape = hasInputShape(ctx, i);
+    const auto* const input_type = ctx.getInputType(i);
+
+    // Enforce type constraint for inputs
+    if (!input_type || !input_type->has_tensor_type()) {
+      fail_type_inference("Scan input ", i, " was not a tensor.");
+    }
+
+    if (is_loop_state_var) {
+      // If it's a loop state variable we can propagate type and shape 1:1 to
+      // the matching Scan output.
+      // We can also pass through the type and shape to the subgraph but need to
+      // remove the batch size dimension from the shape.
+      propagateElemTypeFromInputToOutput(ctx, i, i);
+      if (has_shape)
+        propagateShapeFromInputToOutput(ctx, i, i);
+
+      subgraph_input_types.push_back(input_type);
+    } else {
+      // For other inputs there is no fixed relationships to the Scan outputs,
+      // so we don't propagate type/shape information.
+      // We can pass through the type and shape to the subgraph inputs but
+      // need to remove the sequence length dimensions from the shape.
+      if (has_shape) {
+        const auto& shape = input_type->tensor_type().shape();
+
+        // remove sequence length dimensions and add to subgraph_input_types
+        int axis = static_cast<int>(axes[i - num_loop_state_vars]);
+        axis = handle_negative_axis_validate("scan_input_axes", axis, shape.dim_size());
+
+        // update sequence_len if a value is available
+
+        const auto& dims = shape.dim();
+        mergeInDimensionInfo(dims.Get(axis), sequence_len_dim, 1);
+
+        temporary_type_protos.emplace_back(RemoveIthDimensionFromShape(*input_type, axis));
+        subgraph_input_types.emplace_back(&temporary_type_protos.back());
+
+      } else {
+        subgraph_input_types.push_back(input_type);
+      }
+    }
+  }
+
+  // Run inferencing on the subgraph
+  std::vector<const TypeProto*> output_types;
+
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("body");
+  if (graphInferencer) {
+    std::vector<const TensorProto*> input_data;
+    input_data.reserve(num_inputs);
+    for (size_t i = 0; i < num_inputs; ++i) {
+      // ctx.getInputData(i), the input to scan, does not represent the input to
+      // scan body. So, we pass in null, to represent an unknown value.
+      input_data.push_back(nullptr);
+    }
+
+    output_types = graphInferencer->doInferencing(subgraph_input_types, input_data);
+  }
+
+  // if empty(), assume inferencing was skipped
+  if (!output_types.empty()) {
+    if (output_types.size() != num_outputs) {
+      fail_type_inference(
+          "Graph attribute inferencing returned type information for ",
+          output_types.size(),
+          " outputs. Expected ",
+          num_outputs);
+    }
+
+    // propagate type/shape information for loop state variables and outputs
+    for (size_t i = 0; i < num_outputs; ++i) {
+      const bool is_loop_state_var = i < num_loop_state_vars;
+      const auto* const subgraph_output_type = output_types[i];
+      auto* scan_output_type = ctx.getOutputType(i);
+      auto* mutable_scan_output_tensor_type = scan_output_type->mutable_tensor_type();
+
+      if (!subgraph_output_type->has_tensor_type()) {
+        fail_type_inference("Scan 'body' subgraph outputs should all be tensors but output ", i, " was not");
+      }
+      const auto& subgraph_output_tensor_type = subgraph_output_type->tensor_type();
+
+      if (is_loop_state_var) {
+        // merge shape; type already propagated
+        mergeInShapeInfo(subgraph_output_tensor_type, *mutable_scan_output_tensor_type);
+      } else {
+        scan_output_type->mutable_tensor_type()->set_elem_type(subgraph_output_tensor_type.elem_type());
+
+        // propagate shape
+        if (subgraph_output_tensor_type.has_shape()) {
+          // infer shape of scan-output from the shape of scan-output-element
+          // by adding sequence-length at the correct axis position
+          const TensorShapeProto& subgraph_output_shape = subgraph_output_tensor_type.shape();
+          TensorShapeProto inferred_shape;
+
+          auto subgraph_output_rank = subgraph_output_shape.dim_size();
+          auto output_rank = subgraph_output_rank + 1;
+          int output_axis = static_cast<int>(output_axes[i - num_loop_state_vars]);
+          output_axis = handle_negative_axis_validate("scan_output_axes", output_axis, output_rank);
+
+          for (int j = 0; j < output_axis; ++j)
+            *(inferred_shape.add_dim()) = subgraph_output_shape.dim(j);
+          *(inferred_shape.add_dim()) = sequence_len_dim;
+          for (int j = output_axis; j < subgraph_output_rank; ++j)
+            *(inferred_shape.add_dim()) = subgraph_output_shape.dim(j);
+
+          // Merge inferred shape with existing shape information
+          mergeInShapeInfo(inferred_shape, *mutable_scan_output_tensor_type);
+        }
+      }
+    }
+  }
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/controlflow/utils.h b/onnx/defs/controlflow/utils.h
new file mode 100644
index 0000000..950d606
--- /dev/null
+++ b/onnx/defs/controlflow/utils.h
@@ -0,0 +1,27 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+
+void ClearShape(TypeProto& input_type);
+
+int handle_negative_axis_validate(const std::string& attrib, int axis, int rank);
+
+// Guards the Scan input/output count subtractions against underflow and returns
+// the loop state variable count. Shared by the current and opset-9 paths.
+size_t ValidateScanCountsAndGetNumLoopStateVars(size_t num_inputs, size_t num_scan_inputs, size_t num_outputs);
+
+void IfInferenceFunction(InferenceContext& ctx);
+
+void LoopInferenceFunction(InferenceContext& ctx);
+
+void ScanInferenceFunction(InferenceContext& ctx);
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/data_propagators.h b/onnx/defs/data_propagators.h
new file mode 100644
index 0000000..2eb1215
--- /dev/null
+++ b/onnx/defs/data_propagators.h
@@ -0,0 +1,88 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <utility>
+
+#include "onnx/defs/shape_inference.h"
+
+namespace ONNX_NAMESPACE {
+
+inline void appendDimToTensorShapeProto(TensorShapeProto& tsp, const TensorShapeProto* input_data, int index) {
+  if (index >= input_data->dim_size() || index < -input_data->dim_size()) {
+    fail_shape_inference("indices must be in [-rank, rank-1].");
+  } else {
+    *tsp.add_dim() = input_data->dim((index < 0) ? input_data->dim_size() + index : index);
+  }
+}
+
+// Returns true if the given axis attribute is 0
+inline bool axisIsZero(DataPropagationContext& ctx, bool defaultZero = false) {
+  const auto* axisAttr = ctx.getAttribute("axis");
+  // if axis is not defined
+  if (!axisAttr) {
+    if (defaultZero) {
+      return true;
+    } else {
+      fail_shape_inference("Required attribute axis is missing");
+      return false;
+    }
+  }
+  int axis = static_cast<int>(axisAttr->i());
+  if (axis >= 0) {
+    return axis == 0;
+  }
+  // For negative axes, we need rank information to determine if it is equivalent to axis 0
+  const TypeProto* type = ctx.getInputType(0);
+  if ((type == nullptr) || (!type->has_tensor_type()) || (!type->tensor_type().has_shape())) {
+    return false;
+  }
+
+  int rank = type->tensor_type().shape().dim_size();
+  if (axis < -rank || axis >= rank) {
+    fail_shape_inference("axis must be in [-rank, rank-1].");
+    return false;
+  }
+  axis += rank;
+  // Only supports axis = 0 since the data comes from Shape
+  return axis == 0;
+}
+
+inline void PropagateShapeDataFromInputToOutput(DataPropagationContext& ctx, int idx) {
+  // propagate input data
+  const auto* const input_data = ctx.getInputData(idx);
+  if (input_data != nullptr) {
+    TensorShapeProto tsp;
+    tsp.CopyFrom(*input_data);
+    ctx.addOutputData(0, std::move(tsp));
+  }
+}
+
+inline void GatherOp13DataPropagator(DataPropagationContext& ctx) {
+  if (!axisIsZero(ctx, true)) {
+    return;
+  }
+  const auto* const input_data = ctx.getInputData(0);
+  if (input_data == nullptr) {
+    return;
+  }
+  const auto* const input_indices = ctx.getInputData(1);
+  if (input_indices == nullptr) {
+    return;
+  }
+  TensorShapeProto tsp;
+  for (int i = 0; i < input_indices->dim_size(); ++i) {
+    if (input_indices->dim(i).has_dim_value()) {
+      appendDimToTensorShapeProto(tsp, input_data, input_indices->dim(i).dim_value());
+    } else {
+      return;
+    }
+  }
+  if (tsp.dim_size() > 0) {
+    ctx.addOutputData(0, std::move(tsp));
+  }
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/data_type_utils.cc b/onnx/defs/data_type_utils.cc
new file mode 100644
index 0000000..6243371
--- /dev/null
+++ b/onnx/defs/data_type_utils.cc
@@ -0,0 +1,405 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/data_type_utils.h"
+
+#include <cctype>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace ONNX_NAMESPACE {
+namespace Utils {
+namespace {
+
+// Singleton wrapper around allowed data types.
+// This implements construct on first use which is needed to ensure
+// static objects are initialized before use. Ops registration does not work
+// properly without this.
+class TypesWrapper final {
+ public:
+  static TypesWrapper& GetTypesWrapper();
+
+  std::unordered_set<std::string>& GetAllowedDataTypes();
+
+  std::unordered_map<std::string, int32_t>& TypeStrToTensorDataType();
+
+  std::unordered_map<int32_t, std::string>& TensorDataTypeToTypeStr();
+
+  ~TypesWrapper() = default;
+  TypesWrapper(const TypesWrapper&) = delete;
+  void operator=(const TypesWrapper&) = delete;
+
+ private:
+  TypesWrapper();
+
+  std::unordered_map<std::string, int> type_str_to_tensor_data_type_;
+  std::unordered_map<int, std::string> tensor_data_type_to_type_str_;
+  std::unordered_set<std::string> allowed_data_types_;
+};
+
+// Simple class which contains pointers to external string buffer and a size.
+// This can be used to track a "valid" range/slice of the string.
+// Caller should ensure StringRange is not used after external storage has
+// been freed.
+class StringRange final {
+ public:
+  StringRange(const char* data, size_t size);
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  StringRange(const std::string& str);
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  StringRange(const char* data);
+  const char* Data() const;
+  size_t Size() const;
+  // Used only when ONNX_ML is enabled; suppress GCC -Wunused-function.
+  [[maybe_unused]] bool Empty() const;
+  bool StartsWith(const StringRange& str) const;
+  bool EndsWith(const StringRange& str) const;
+  bool LStrip();
+  bool LStrip(size_t size);
+  bool LStrip(StringRange str);
+  bool RStrip();
+  bool RStrip(size_t size);
+  bool RStrip(StringRange str);
+  bool LAndRStrip();
+  void ParensWhitespaceStrip();
+  size_t Find(char ch) const;
+
+ private:
+  std::string_view view_;
+};
+
+} // namespace
+
+std::unordered_map<std::string, TypeProto>& DataTypeUtils::GetTypeStrToProtoMap() {
+  static std::unordered_map<std::string, TypeProto> map;
+  return map;
+}
+
+std::mutex& DataTypeUtils::GetTypeStrLock() {
+  static std::mutex lock;
+  return lock;
+}
+
+DataType DataTypeUtils::ToType(const TypeProto& type_proto) {
+  auto typeStr = ToString(type_proto);
+  std::lock_guard<std::mutex> lock(GetTypeStrLock());
+  auto it = GetTypeStrToProtoMap().find(typeStr);
+  if (it == GetTypeStrToProtoMap().end()) {
+    TypeProto type;
+    FromString(typeStr, type);
+    GetTypeStrToProtoMap()[typeStr] = type;
+    it = GetTypeStrToProtoMap().find(typeStr);
+  }
+  return &(it->first);
+}
+
+DataType DataTypeUtils::ToType(const std::string& type_str) {
+  TypeProto type;
+  FromString(type_str, type);
+  return ToType(type);
+}
+
+const TypeProto& DataTypeUtils::ToTypeProto(const DataType& data_type) {
+  std::lock_guard<std::mutex> lock(GetTypeStrLock());
+  auto it = GetTypeStrToProtoMap().find(*data_type);
+  if (GetTypeStrToProtoMap().end() == it) {
+    ONNX_THROW_EX(std::invalid_argument("Invalid data type " + *data_type));
+  }
+  return it->second;
+}
+
+std::string DataTypeUtils::ToString(const TypeProto& type_proto, const std::string& left, const std::string& right) {
+  switch (type_proto.value_case()) {
+    case TypeProto::ValueCase::kTensorType: {
+      // Note: We do not distinguish tensors with zero rank (a shape consisting
+      // of an empty sequence of dimensions) here.
+      return left + "tensor(" + ToDataTypeString(type_proto.tensor_type().elem_type()) + ")" + right;
+    }
+    case TypeProto::ValueCase::kSequenceType: {
+      return ToString(type_proto.sequence_type().elem_type(), left + "seq(", ")" + right);
+    }
+    case TypeProto::ValueCase::kOptionalType: {
+      return ToString(type_proto.optional_type().elem_type(), left + "optional(", ")" + right);
+    }
+    case TypeProto::ValueCase::kMapType: {
+      std::string map_str = "map(" + ToDataTypeString(type_proto.map_type().key_type()) + ",";
+      return ToString(type_proto.map_type().value_type(), left + map_str, ")" + right);
+    }
+#ifdef ONNX_ML
+    case TypeProto::ValueCase::kOpaqueType: {
+      std::string result;
+      const auto& op_type = type_proto.opaque_type();
+      result.append(left).append("opaque(");
+      if (op_type.has_domain() && !op_type.domain().empty()) {
+        result.append(op_type.domain()).append(",");
+      }
+      if (op_type.has_name() && !op_type.name().empty()) {
+        result.append(op_type.name());
+      }
+      result.append(")").append(right);
+      return result;
+    }
+#endif
+    case TypeProto::ValueCase::kSparseTensorType: {
+      // Note: We do not distinguish tensors with zero rank (a shape consisting
+      // of an empty sequence of dimensions) here.
+      return left + "sparse_tensor(" + ToDataTypeString(type_proto.sparse_tensor_type().elem_type()) + ")" + right;
+    }
+    default:
+      ONNX_THROW_EX(
+          std::invalid_argument("Unsupported type proto value case:" + std::to_string(type_proto.value_case())));
+  }
+}
+
+std::string DataTypeUtils::ToDataTypeString(int32_t tensor_data_type) {
+  TypesWrapper& t = TypesWrapper::GetTypesWrapper();
+  auto iter = t.TensorDataTypeToTypeStr().find(tensor_data_type);
+  if (t.TensorDataTypeToTypeStr().end() == iter) {
+    ONNX_THROW_EX(std::invalid_argument("Invalid tensor data type " + std::to_string(tensor_data_type) + "."));
+  }
+  return iter->second;
+}
+
+void DataTypeUtils::FromString(const std::string& type_str, TypeProto& type_proto) {
+  StringRange s(type_str);
+  type_proto.Clear();
+  if (s.LStrip("seq")) {
+    s.ParensWhitespaceStrip();
+    FromString(std::string(s.Data(), s.Size()), *type_proto.mutable_sequence_type()->mutable_elem_type());
+    return;
+  } else if (s.LStrip("optional")) {
+    s.ParensWhitespaceStrip();
+    FromString(std::string(s.Data(), s.Size()), *type_proto.mutable_optional_type()->mutable_elem_type());
+    return;
+  } else if (s.LStrip("map")) {
+    s.ParensWhitespaceStrip();
+    size_t key_size = s.Find(',');
+    StringRange k(s.Data(), key_size);
+    std::string key(k.Data(), k.Size());
+    s.LStrip(key_size);
+    s.LStrip(",");
+    StringRange v(s.Data(), s.Size());
+    auto key_type = FromDataTypeString(key);
+    type_proto.mutable_map_type()->set_key_type(key_type);
+    FromString(std::string(v.Data(), v.Size()), *type_proto.mutable_map_type()->mutable_value_type());
+    return;
+  }
+#ifdef ONNX_ML
+  if (s.LStrip("opaque")) {
+    auto* opaque_type = type_proto.mutable_opaque_type();
+    s.ParensWhitespaceStrip();
+    if (!s.Empty()) {
+      size_t cm = s.Find(',');
+      if (cm != std::string::npos) {
+        if (cm > 0) {
+          opaque_type->mutable_domain()->assign(s.Data(), cm);
+        }
+        s.LStrip(cm + 1); // skip comma
+      }
+      if (!s.Empty()) {
+        opaque_type->mutable_name()->assign(s.Data(), s.Size());
+      }
+    }
+    return;
+  }
+#endif
+  if (s.LStrip("sparse_tensor")) {
+    s.ParensWhitespaceStrip();
+    auto e = FromDataTypeString(std::string(s.Data(), s.Size()));
+    type_proto.mutable_sparse_tensor_type()->set_elem_type(e);
+  } else if (s.LStrip("tensor")) {
+    s.ParensWhitespaceStrip();
+    auto e = FromDataTypeString(std::string(s.Data(), s.Size()));
+    type_proto.mutable_tensor_type()->set_elem_type(e);
+  } else {
+    // Scalar
+    auto e = FromDataTypeString(std::string(s.Data(), s.Size()));
+    TypeProto::Tensor* t = type_proto.mutable_tensor_type();
+    t->set_elem_type(e);
+    // Call mutable_shape() to initialize a shape with no dimension.
+    t->mutable_shape();
+  }
+} // namespace Utils
+
+bool DataTypeUtils::IsValidDataTypeString(const std::string& type_str) {
+  TypesWrapper& t = TypesWrapper::GetTypesWrapper();
+  const auto& allowedSet = t.GetAllowedDataTypes();
+  return (allowedSet.find(type_str) != allowedSet.end());
+}
+
+int32_t DataTypeUtils::FromDataTypeString(const std::string& type_str) {
+  if (!IsValidDataTypeString(type_str)) {
+    ONNX_THROW_EX(
+        std::invalid_argument(
+            "DataTypeUtils::FromDataTypeString - Received invalid data type string '" + type_str + "'."));
+  }
+
+  TypesWrapper& t = TypesWrapper::GetTypesWrapper();
+  return t.TypeStrToTensorDataType()[type_str];
+}
+
+namespace {
+
+StringRange::StringRange(const char* p_data, size_t p_size)
+    : view_(p_data != nullptr ? std::string_view{p_data, p_size} : std::string_view{}) {
+  assert(p_data != nullptr);
+  LAndRStrip();
+}
+
+StringRange::StringRange(const std::string& p_str) : view_(p_str) {
+  LAndRStrip();
+}
+
+StringRange::StringRange(const char* p_data) : view_(p_data) {
+  LAndRStrip();
+}
+
+const char* StringRange::Data() const {
+  return view_.data();
+}
+
+size_t StringRange::Size() const {
+  return view_.size();
+}
+
+bool StringRange::Empty() const {
+  return view_.empty();
+}
+
+bool StringRange::StartsWith(const StringRange& str) const {
+  return view_.substr(0, str.view_.size()) == str.view_;
+}
+
+bool StringRange::EndsWith(const StringRange& str) const {
+  return view_.size() >= str.view_.size() && view_.substr(view_.size() - str.view_.size()) == str.view_;
+}
+
+bool StringRange::LStrip() {
+  size_t count = 0;
+  while (count < view_.size() && isspace(static_cast<unsigned char>(view_[count]))) {
+    ++count;
+  }
+  if (count > 0) {
+    return LStrip(count);
+  }
+  return false;
+}
+
+bool StringRange::LStrip(size_t size) {
+  if (size <= view_.size()) {
+    view_.remove_prefix(size);
+    return true;
+  }
+  return false;
+}
+
+bool StringRange::LStrip(StringRange str) {
+  if (StartsWith(str)) {
+    return LStrip(str.view_.size());
+  }
+  return false;
+}
+
+bool StringRange::RStrip() {
+  size_t count = 0;
+  while (count < view_.size() && isspace(static_cast<unsigned char>(view_[view_.size() - 1 - count]))) {
+    ++count;
+  }
+  if (count > 0) {
+    return RStrip(count);
+  }
+  return false;
+}
+
+bool StringRange::RStrip(size_t size) {
+  if (size <= view_.size()) {
+    view_.remove_suffix(size);
+    return true;
+  }
+  return false;
+}
+
+bool StringRange::RStrip(StringRange str) {
+  if (EndsWith(str)) {
+    return RStrip(str.view_.size());
+  }
+  return false;
+}
+
+bool StringRange::LAndRStrip() {
+  bool l = LStrip();
+  bool r = RStrip();
+  return l || r;
+}
+
+void StringRange::ParensWhitespaceStrip() {
+  LStrip();
+  LStrip("(");
+  LAndRStrip();
+  RStrip(")");
+  RStrip();
+}
+
+size_t StringRange::Find(const char ch) const {
+  return view_.find(ch);
+}
+
+TypesWrapper& TypesWrapper::GetTypesWrapper() {
+  static TypesWrapper types;
+  return types;
+}
+
+std::unordered_set<std::string>& TypesWrapper::GetAllowedDataTypes() {
+  return allowed_data_types_;
+}
+
+std::unordered_map<std::string, int>& TypesWrapper::TypeStrToTensorDataType() {
+  return type_str_to_tensor_data_type_;
+}
+
+std::unordered_map<int, std::string>& TypesWrapper::TensorDataTypeToTypeStr() {
+  return tensor_data_type_to_type_str_;
+}
+
+TypesWrapper::TypesWrapper() {
+  // DataType strings. These should match the DataTypes defined in onnx.proto
+  type_str_to_tensor_data_type_["float"] = TensorProto_DataType_FLOAT;
+  type_str_to_tensor_data_type_["float16"] = TensorProto_DataType_FLOAT16;
+  type_str_to_tensor_data_type_["bfloat16"] = TensorProto_DataType_BFLOAT16;
+  type_str_to_tensor_data_type_["double"] = TensorProto_DataType_DOUBLE;
+  type_str_to_tensor_data_type_["int8"] = TensorProto_DataType_INT8;
+  type_str_to_tensor_data_type_["int16"] = TensorProto_DataType_INT16;
+  type_str_to_tensor_data_type_["int32"] = TensorProto_DataType_INT32;
+  type_str_to_tensor_data_type_["int64"] = TensorProto_DataType_INT64;
+  type_str_to_tensor_data_type_["uint8"] = TensorProto_DataType_UINT8;
+  type_str_to_tensor_data_type_["uint16"] = TensorProto_DataType_UINT16;
+  type_str_to_tensor_data_type_["uint32"] = TensorProto_DataType_UINT32;
+  type_str_to_tensor_data_type_["uint64"] = TensorProto_DataType_UINT64;
+  type_str_to_tensor_data_type_["complex64"] = TensorProto_DataType_COMPLEX64;
+  type_str_to_tensor_data_type_["complex128"] = TensorProto_DataType_COMPLEX128;
+  type_str_to_tensor_data_type_["string"] = TensorProto_DataType_STRING;
+  type_str_to_tensor_data_type_["bool"] = TensorProto_DataType_BOOL;
+  type_str_to_tensor_data_type_["float8e4m3fn"] = TensorProto_DataType_FLOAT8E4M3FN;
+  type_str_to_tensor_data_type_["float8e4m3fnuz"] = TensorProto_DataType_FLOAT8E4M3FNUZ;
+  type_str_to_tensor_data_type_["float8e5m2"] = TensorProto_DataType_FLOAT8E5M2;
+  type_str_to_tensor_data_type_["float8e5m2fnuz"] = TensorProto_DataType_FLOAT8E5M2FNUZ;
+  type_str_to_tensor_data_type_["float8e8m0"] = TensorProto_DataType_FLOAT8E8M0;
+  type_str_to_tensor_data_type_["uint4"] = TensorProto_DataType_UINT4;
+  type_str_to_tensor_data_type_["int4"] = TensorProto_DataType_INT4;
+  type_str_to_tensor_data_type_["uint2"] = TensorProto_DataType_UINT2;
+  type_str_to_tensor_data_type_["int2"] = TensorProto_DataType_INT2;
+  type_str_to_tensor_data_type_["float4e2m1"] = TensorProto_DataType_FLOAT4E2M1;
+
+  for (auto& [type_str, data_type] : type_str_to_tensor_data_type_) {
+    tensor_data_type_to_type_str_[data_type] = type_str;
+    allowed_data_types_.insert(type_str);
+  }
+}
+
+} // namespace
+
+} // namespace Utils
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/data_type_utils.h b/onnx/defs/data_type_utils.h
new file mode 100644
index 0000000..126cdb4
--- /dev/null
+++ b/onnx/defs/data_type_utils.h
@@ -0,0 +1,72 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ONNX_DEFS_DATA_TYPE_UTILS_H_
+#define ONNX_DEFS_DATA_TYPE_UTILS_H_
+
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include "onnx/common/common.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+// String pointer as unique TypeProto identifier.
+using DataType = const std::string*;
+
+namespace Utils {
+
+// Data type utility, which maintains a global type string to TypeProto map.
+// DataType (string pointer) is used as unique data type identifier for
+// efficiency.
+//
+// Grammar for data type string:
+// <type> ::= <data_type> |
+//            tensor(<data_type>) |
+//            seq(<type>) |
+//            map(<data_type>, <type>)
+// <data_type> :: = float | int32 | string | bool | uint8
+//                | int8 | uint16 | int16 | int64 | float16 | double
+//
+// NOTE: <type> ::= <data_type> means the data is scalar (zero dimension).
+//
+// Example: float, tensor(float), etc.
+//
+class DataTypeUtils final {
+ public:
+  // If the DataType input is invalid, this function will throw std::invalid_argument exception.
+  // If ONNX_NO_EXCEPTIONS is set it will abort.
+  static DataType ToType(const std::string& type_str);
+
+  // If the DataType input is invalid, this function will throw std::invalid_argument exception.
+  // If ONNX_NO_EXCEPTIONS is set it will abort.
+  static DataType ToType(const TypeProto& type_proto);
+
+  // If the DataType input is invalid, this function will throw std::invalid_argument exception.
+  // If ONNX_NO_EXCEPTIONS is set it will abort.
+  static const TypeProto& ToTypeProto(const DataType& data_type);
+  static std::string ToDataTypeString(int32_t tensor_data_type);
+
+ private:
+  static void FromString(const std::string& type_str, TypeProto& type_proto);
+
+  static int32_t FromDataTypeString(const std::string& type_str);
+
+  static std::string ToString(const TypeProto& type_proto, const std::string& left = "", const std::string& right = "");
+
+  // If int32_t input is invalid, this function will throw an exception.
+  // If ONNX_NO_EXCEPTIONS is set it will abort.
+
+  static bool IsValidDataTypeString(const std::string& type_str);
+
+  static std::unordered_map<std::string, TypeProto>& GetTypeStrToProtoMap();
+
+  // Returns lock used for concurrent updates to TypeStrToProtoMap.
+  static std::mutex& GetTypeStrLock();
+};
+} // namespace Utils
+} // namespace ONNX_NAMESPACE
+
+#endif // ONNX_DEFS_DATA_TYPE_UTILS_H_
diff --git a/onnx/defs/doc_strings.cc b/onnx/defs/doc_strings.cc
new file mode 100644
index 0000000..abab301
--- /dev/null
+++ b/onnx/defs/doc_strings.cc
@@ -0,0 +1,1395 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/doc_strings.h"
+
+namespace ONNX_NAMESPACE {
+#ifndef __ONNX_NO_DOC_STRINGS
+const char kDoc_GRU_ver14[] = R"DOC(
+Computes an one-layer GRU. This operator is usually supported via some custom
+implementation such as CuDNN.
+
+Notations:
+
+* `X` - input tensor
+* `z` - update gate
+* `r` - reset gate
+* `h` - hidden gate
+* `t` - time step (t-1 means previous time step)
+* `W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+* `R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+* `Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+* `Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+* `WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+* `RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+* `WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+* `RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+* `H` - Hidden state
+* `num_directions` - 2 if direction == bidirectional else 1
+
+Activation functions:
+
+* Relu(x)                - max(0, x)
+* Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+* Sigmoid(x)             - 1/(1 + e^{-x})
+
+NOTE:
+  Below are optional
+
+* Affine(x)              - alpha * x + beta
+* LeakyRelu(x)           - x if x >= 0 else alpha * x
+* ThresholdedRelu(x)     - x if x >= alpha else 0
+* ScaledTanh(x)          - alpha * Tanh(beta * x)
+* HardSigmoid(x)         - min(max(alpha * x + beta, 0), 1)
+* Elu(x)                 - x if x >= 0 else alpha * (e^x - 1)
+* Softsign(x)            - x/(1 + |x|)
+* Softplus(x)            - log(1 + e^x)
+
+Equations (Default: f=Sigmoid, g=Tanh):
+
+* zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz)
+* rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr)
+* ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # default, when linear_before_reset = 0
+* ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset != 0
+* Ht = (1 - zt) (.) ht + zt (.) Ht-1
+)DOC";
+
+const char kDoc_Squeeze_ver24[] = R"DOC(
+Remove single-dimensional entries from the shape of a tensor.
+Takes an input `axes` with a list of axes to squeeze.
+If `axes` is not provided, all the single dimensions will be removed from
+the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+)DOC";
+
+const char kDoc_MaxUnpool_ver11[] = R"DOC(
+MaxUnpool essentially computes the partial inverse of the MaxPool op.
+ The input information to this op is typically the output information from a MaxPool op. The first
+ input tensor X is the tensor that needs to be unpooled, which is typically the pooled tensor (first output)
+ from MaxPool. The second input tensor, I, contains the indices to the (locally maximal) elements corresponding
+ to the elements in the first input tensor X. Input tensor I is typically the second output of the MaxPool op.
+ The third (optional) input is a tensor that specifies the output size of the unpooling operation.
+
+MaxUnpool is intended to do 'partial' inverse of the MaxPool op. 'Partial' because all the non-maximal
+ values from the original input to MaxPool are set to zero in the output of the MaxUnpool op. Pooling
+ the result of an unpooling operation should give back the original input to the unpooling op.
+
+MaxUnpool can produce the same output size for several input sizes, which makes unpooling op ambiguous.
+ The third input argument, output_size, is meant to disambiguate the op and produce output tensor of
+ known/predictable size.
+
+In addition to the inputs, MaxUnpool takes three attributes, namely kernel_shape, strides, and pads,
+ which define the exact unpooling op. The attributes typically have the same values as the corresponding
+ pooling op that the unpooling op is trying to invert.
+)DOC";
+
+const char kDoc_Size_ver24[] = R"DOC(
+Takes a tensor as input and outputs a int64 scalar that equals to the total number of elements of the input tensor.
+)DOC";
+
+const char kDoc_Range_ver11[] = R"DOC(
+Generate a tensor containing a sequence of numbers that begin at `start` and extends by increments of `delta`
+up to `limit` (exclusive).
+
+The number of elements in the output of range is computed as below:
+```
+number_of_elements = max( ceil( (limit - start) / delta ) , 0 )
+```
+The pseudocode determining the contents of the output is shown below:
+```
+for(int i=0; i<number_of_elements; ++i) {
+  output[i] =  start + (i * delta);
+}
+```
+Example 1:
+```
+Inputs: start = 3, limit = 9, delta = 3
+Output: [3, 6]
+```
+Example 2:
+```
+Inputs: start = 10, limit = 4, delta = -2
+Output: [10, 8, 6]
+```
+)DOC";
+
+const char kDoc_Range_ver27[] = R"DOC(
+Generate a tensor containing a sequence of numbers that begin at `start` and extends by increments of `delta`
+up to `limit` (exclusive).
+
+The number of elements in the output of range is computed as below:
+```
+number_of_elements = max( ceil( (limit - start) / delta ) , 0 )
+```
+The pseudocode determining the contents of the output is shown below:
+```
+for(int i=0; i<number_of_elements; ++i) {
+  output[i] =  start + (i * delta);
+}
+```
+Example 1:
+```
+Inputs: start = 3, limit = 9, delta = 3
+Output: [3, 6]
+```
+Example 2:
+```
+Inputs: start = 10, limit = 4, delta = -2
+Output: [10, 8, 6]
+```
+
+For `float16` and `bfloat16` inputs, the `stash_type` attribute controls the precision used for
+intermediate accumulation. Setting `stash_type` to `1` (float) causes `start`, `limit`, and
+`delta` to be cast to 32-bit float before the loop, with the output cast back to the original
+type. This avoids precision loss for large ranges where successive additions in float16 or
+bfloat16 would otherwise be inexact (e.g. `x + 1 == x` for large `x`).
+)DOC";
+
+const char kDoc_RandomUniform_ver1[] = R"DOC(
+Generate a tensor with random values drawn from a uniform distribution. The shape
+of the tensor is specified by the `shape` argument and the range by `low` and `high`.
+
+The data type is specified by the 'dtype' argument. The 'dtype' argument must
+be one of the data types specified in the 'DataType' enum field in the
+TensorProto message.
+)DOC";
+
+const char kDoc_DequantizeLinear_ver24[] = R"DOC(
+The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the
+full-precision tensor. The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point`
+must have the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
+a 1-D tensor for per-axis quantization, or have a rank identical to the input for blocked quantization.
+See QuantizeLinear for details on quantization granularity.
+
+`x_zero_point` and `x` must have the same type. `x` and `y` must have the same shape. In the case of dequantizing
+`int32`, there's no zero point (zero point is supposed to be 0).
+`zero-point` is usually not used in the case of float8 and 4-bit types quantization, but the dequantization formula remains the same
+for consistency. The output type is determined by the attribute `output_dtype`. If `output_dtype` is not supplied then the output type
+is the same as `x_scale`. The output type also determines the precision of the multiplication operation.
+
+)DOC";
+
+const char kDoc_RandomNormal_ver1[] = R"DOC(
+Generate a tensor with random values drawn from a normal distribution. The shape
+of the tensor is specified by the `shape` argument and the parameter of the normal distribution
+specified by `mean` and `scale`.
+
+The data type is specified by the 'dtype' argument. The 'dtype' argument must
+be one of the data types specified in the 'DataType' enum field in the
+TensorProto message.
+)DOC";
+
+const char kDoc_Round_ver11[] = R"DOC(
+Round takes one input Tensor and rounds the values, element-wise, meaning
+it finds the nearest integer for each value.
+In case of halves, the rule is to round them to the nearest even integer.
+If input x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+The output tensor has the same shape and type as the input.
+
+Examples:
+```
+round([0.9]) = [1.0]
+round([2.5]) = [2.0]
+round([2.3]) = [2.0]
+round([1.5]) = [2.0]
+round([-4.5]) = [-4.0]
+```
+)DOC";
+
+const char kDoc_SpaceToDepth_ver1[] =
+    R"DOC(SpaceToDepth rearranges blocks of spatial data into depth. More specifically,
+this op outputs a copy of the input tensor where values from the height and width dimensions
+are moved to the depth dimension.
+)DOC";
+
+const char kDoc_InstanceNormalization_ver6[] = R"DOC(
+Carries out instance normalization as described in the paper
+https://arxiv.org/abs/1607.08022.
+
+y = scale * (x - mean) / sqrt(variance + epsilon) + B,
+where mean and variance are computed per instance per channel.
+
+)DOC";
+
+const char kDoc_ThresholdedRelu_ver10[] = R"DOC(
+ThresholdedRelu takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the rectified linear function, y = x for x > alpha, y = 0 otherwise,
+is applied to the tensor elementwise.
+)DOC";
+
+const char kDoc_Acosh_ver9[] = R"DOC(
+Calculates the hyperbolic arccosine of the given input tensor element-wise.
+)DOC";
+
+const char kDoc_Dropout_ver13[] = R"DOC(
+Dropout takes an input floating-point tensor, an optional input ratio (floating-point scalar) and an optional input training_mode (boolean scalar). It produces two tensor outputs,
+output (floating-point tensor) and mask (optional `Tensor<bool>`). If `training_mode` is true then the output Y will be a random dropout;
+Note that this Dropout scales the masked input data by the following equation, so to convert the trained model into inference mode,
+the user can simply not pass `training_mode` input or set it to false.
+```
+output = scale * data * mask,
+```
+where
+```
+scale = 1. / (1. - ratio).
+```
+)DOC";
+
+const char kDoc_DeformConv_ver19[] = R"DOC(
+Performs deformable convolution as described in https://arxiv.org/abs/1703.06211 and https://arxiv.org/abs/1811.11168.
+This operator specification supports the general N-D case. Note that most common use cases have 2D or 3D data.
+)DOC";
+
+const char kDoc_Softplus_ver1[] = R"DOC(
+Softplus takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the softplus function, y = ln(exp(x) + 1), is applied to
+the tensor elementwise.
+)DOC";
+
+const char kDoc_Tile_ver6[] = R"DOC(Constructs a tensor by tiling a given tensor.
+This is the same as function `tile` in Numpy, but no broadcast.
+For example A = [[1, 2], [3, 4]], B = [1, 2], tile(A, B) = [[1, 2, 1, 2], [3, 4, 3, 4]]
+)DOC";
+
+const char kDoc_Unsqueeze_ver24[] = R"DOC(
+Insert single-dimensional entries to the shape of an input tensor (`data`).
+Takes one required input `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).
+
+For example, given an input tensor (`data`) of shape [3, 4, 5], then
+Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].
+
+The input `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
+The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
+Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
+The order of values in `axes` does not matter and can come in any order.
+)DOC";
+
+const char kDoc_ConstantOfShape_ver24[] = R"DOC(
+Generate a tensor with given value and shape.
+)DOC";
+
+const char kDoc_Elu_ver6[] = R"DOC(
+Elu takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the function `f(x) = alpha * (exp(x) - 1.) for x <
+0`, `f(x) = x for x >= 0`., is applied to the tensor elementwise.
+
+)DOC";
+
+const char kDoc_CumSum_ver11[] = R"DOC(
+Performs cumulative sum of the input elements along the given axis.
+By default, it will do the sum inclusively meaning the first element is copied as is.
+Through an `exclusive` attribute, this behavior can change to exclude the first element.
+It can also perform summation in the opposite direction of the axis. For that, set `reverse` attribute to 1.
+
+Example:
+```
+input_x = [1, 2, 3]
+axis=0
+output = [1, 3, 6]
+exclusive=1
+output = [0, 1, 3]
+exclusive=0
+reverse=1
+output = [6, 5, 3]
+exclusive=1
+reverse=1
+output = [5, 3, 0]
+```
+ )DOC";
+
+const char kDoc_Acos_ver7[] = R"DOC(
+Calculates the arccosine (inverse of cosine) of the given input tensor, element-wise.
+)DOC";
+
+const char kDoc_LSTM_ver14[] = R"DOC(
+Computes an one-layer LSTM. This operator is usually supported via some
+custom implementation such as CuDNN.
+
+Notations:
+
+* `X` - input tensor
+* `i` - input gate
+* `o` - output gate
+* `f` - forget gate
+* `c` - cell gate
+* `t` - time step (t-1 means previous time step)
+* `W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
+* `R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
+* `Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
+* `Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
+* `P[iof]`  - P peephole weight vector for input, output, and forget gates
+* `WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
+* `RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
+* `WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
+* `RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
+* `PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
+* `H` - Hidden state
+* `num_directions` - 2 if direction == bidirectional else 1
+
+Activation functions:
+
+* Relu(x)                - max(0, x)
+* Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+* Sigmoid(x)             - 1/(1 + e^{-x})
+
+NOTE: Below are optional
+
+* Affine(x)              - alpha*x + beta
+* LeakyRelu(x)           - x if x >= 0 else alpha * x
+* ThresholdedRelu(x)     - x if x >= alpha else 0
+* ScaledTanh(x)          - alpha*Tanh(beta*x)
+* HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+* Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+* Softsign(x)            - x/(1 + |x|)
+* Softplus(x)            - log(1 + e^x)
+
+Equations (Default: f=Sigmoid, g=Tanh, h=Tanh):
+
+* it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi)
+* ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf)
+* ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc)
+* Ct = ft (.) Ct-1 + it (.) ct
+* ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.) Ct + Wbo + Rbo)
+* Ht = ot (.) h(Ct)
+)DOC";
+
+const char kDoc_Bernoulli_ver15[] = R"DOC(
+Draws binary random numbers (0 or 1) from a Bernoulli distribution. The input tensor should be a tensor
+containing probabilities p (a value in the range [0,1]) to be used for drawing the binary random number,
+where an output of 1 is produced with probability p and an output of 0 is produced with probability (1-p).
+
+This operator is non-deterministic and may not produce the same values in different
+implementations (even if a seed is specified).
+)DOC";
+
+const char kDoc_Softsign_ver1[] = R"DOC(
+Calculates the softsign (x/(1+|x|)) of the given input tensor element-wise.
+)DOC";
+
+const char kDoc_Selu_ver6[] = R"DOC(
+Selu takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the scaled exponential linear unit function,
+`y = gamma * (alpha * e^x - alpha) for x <= 0`, `y = gamma * x for x > 0`,
+is applied to the tensor elementwise.
+)DOC";
+
+const char kDoc_Shape_ver24[] = R"DOC(
+Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+Optional attributes start and end can be used to compute a slice of the input tensor's shape.
+If start axis is omitted, the slice starts from axis 0.
+The end axis, if specified, is exclusive (and the returned value will not include the size of that axis).
+If the end axis is omitted, the axes upto the last one will be included.
+Negative axes indicate counting back from the last axis.
+Note that axes will be clamped to the range [0, r], where r is the
+rank of the input tensor if they are out-of-range (after adding r in the case of
+negative axis). Thus, specifying any end value > r is equivalent to specifying an end
+value of r, and specifying any start value < -r is equivalent to specifying a start
+value of 0. If start > end, the result will be an empty shape.
+
+Examples:
+
+```
+Input tensor with shape: [2, 3, 4]
+No attributes specified.
+Output: [2, 3, 4]
+```
+
+```
+Input tensor with shape: [2, 3, 4]
+start: -1
+Output: [4]
+```
+
+```
+Input tensor with shape: [2, 3, 4]
+end: -1
+Output: [2, 3]
+```
+
+```
+Input tensor with shape: [2, 3, 4]
+start: 1
+end: 2
+Output: [3]
+```
+)DOC";
+
+const char kDoc_Upsample_ver7[] = R"DOC(
+Upsample the input tensor.
+Each dimension value of the output tensor is:
+  output_dimension = floor(input_dimension * scale).
+)DOC";
+
+const char kDoc_Tanh_ver6[] = R"DOC(
+Calculates the hyperbolic tangent of the given input tensor element-wise.
+)DOC";
+
+const char kDoc_Cast_ver24[] = R"DOC(
+The operator casts the elements of a given input tensor to a data type
+specified by the 'to' argument and returns an output tensor of the same size in
+the converted type. The 'to' argument must be one of the data types specified
+in the 'DataType' enum field in the TensorProto message.
+
+Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+(e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+yield result 100. There are some string literals reserved for special floating-point values;
+"+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+to string tensors, plain floating-point representation (such as "314.15926") would be used.
+Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+Conversion from a numerical type to any numerical type is always allowed.
+User must be aware of precision loss and value change caused by range difference between two types.
+For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+In more detail, the conversion among numerical types should follow these rules
+if the destination type is not a float 8 type.
+
+* Casting from floating point to:
+  * floating point: +/- infinity if OOR (out of range).
+  * fixed point: undefined if OOR.
+  * bool: +/- 0.0 to False; all else to True.
+* Casting from fixed point to:
+  * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+  * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+    signed types). For example, 200 (int16) -> -56 (int8).
+  * bool: zero to False; nonzero to True.
+* Casting from bool to:
+  * floating point: `{1.0, 0.0}`.
+  * fixed point: `{1, 0}`.
+  * bool: no change.
+
+Float 8 types (E4M3FN, E4M3FNUZ, E5M2, E5M2FNUZ) were introduced to speed up the training of
+deep models. By default the conversion of a float *x* obeys
+to the following rules. `[x]` means the value rounded to
+the target mantissa width.
+
+| x                 | E4M3FN   | E4M3FNUZ | E5M2     | E5M2FNUZ |
+| ----------------- | -------- | -------- | -------- | -------- |
+| 0                 | 0        | 0        | 0        | 0        |
+| -0                | -0       | 0        | -0       | 0        |
+| NaN               | NaN      | NaN      | NaN      | NaN      |
+| Inf               | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+| -Inf              | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+| \[x\] > FLT_MAX   | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+| \[x\] \< -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+| else              | RNE      | RNE      | RNE      | RNE      |
+
+The behavior changes if the parameter 'saturate' is set to False.
+The rules then become:
+
+| x                 | E4M3FN | E4M3FNUZ | E5M2 | E5M2FNUZ |
+| ----------------- | ------ | -------- | ---- | -------- |
+| 0                 | 0      | 0        | 0    | 0        |
+| -0                | -0     | 0        | -0   | 0        |
+| NaN               | NaN    | NaN      | NaN  | NaN      |
+| -NaN              | -NaN   | NaN      | -NaN | NaN      |
+| Inf               | NaN    | NaN      | Inf  | NaN      |
+| -Inf              | -NaN   | NaN      | -Inf | NaN      |
+| \[x\] > FLT_MAX   | NaN    | NaN      | Inf  | NaN      |
+| \[x\] \< -FLT_MAX | NaN    | NaN      | -Inf | NaN      |
+| else              | RNE    | RNE      | RNE  | RNE      |
+
+FLOAT8E8M0 type was introduced to enable [Microscaling (MX) formats](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf).
+When casting to FLOAT8E8M0, the rounding behavior can be specified using the `round_mode` and `saturate` attributes.
+The current CUDA behavior is to round up and saturate. Casting negative values to FLOAT8E8M0 gives undefined behavior.
+The following table describes the casting behavior of special values to FLOAT8E8M0 in the two most common cases.
+
+| x                 | saturate + up | non-saturate + nearest |
+| ----------------- | ------------- | ---------------------  |
+| 0                 | 0             | NaN                    |
+| -0                | Unspecified   | Unspecified            |
+| NaN               | NaN           | NaN                    |
+| Inf               | E8M0_MAX      | NaN                    |
+| x > E8M0_MAX      | E8M0_MAX      | NaN                    |
+| x < E8M0_MIN      | E8M0_MIN      | NaN                    |
+| x < 0             | Unspecified   | Unspecified            |
+)DOC";
+
+const char kDoc_Multinomial_ver7[] = R"DOC(
+Generate a tensor of samples from a multinomial distribution according to the probabilities
+of each of the possible outcomes.
+)DOC";
+
+const char kDoc_Constant_ver24[] = R"DOC(
+This operator produces a constant tensor. Exactly one of the provided attributes, either value, sparse_value,
+or value_* must be specified.
+)DOC";
+
+const char kDoc_Where_ver9[] = R"DOC(
+Return elements, either from X or Y, depending on condition.
+Where behaves like
+[numpy.where](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html)
+with three parameters.
+
+)DOC";
+
+const char kDoc_CastLike_ver24[] = R"DOC(
+The operator casts the elements of a given input tensor (the first input) to
+the same data type as the elements of the second input tensor.
+See documentation of the Cast operator for further details.
+)DOC";
+
+const char kDoc_GridSample_ver20[] = R"DOC(
+Given an input `X` and a flow-field `grid`, computes the output `Y` using `X` values and pixel locations from the `grid`.
+For spatial input `X` with shape (N, C, H, W), the `grid` will have shape (N, H_out, W_out, 2),
+the output `Y` will have shape (N, C, H_out, W_out). For volumetric input `X` with shape (N, C, D, H, W),
+the `grid` will have shape (N, D_out, H_out, W_out, 3), the output `Y` will have shape (N, C, D_out, H_out, W_out).
+More generally, for an input `X` of rank r+2 with shape (N, C, d1, d2, ..., dr),
+the `grid` will have shape (N, D1_out, D2_out, ..., Dr_out, r), the output `Y` will have shape (N, C, D1_out, D2_out, ..., Dr_out).
+
+The tensor `X` contains values at centers of square pixels (voxels, etc) locations such as (n, c, d1_in, d2_in, ..., dr_in).
+The (n, d1_out, d2_out, ..., dr_out, :) values from the tensor `grid` are the normalized positions for interpolating the values
+at the (n, c, d1_out, d2_out, ..., dr_out) locations from the output tensor `Y` using a specified interpolation method (the mode)
+and a padding mode (for `grid` positions falling outside the 2-dimensional image).
+
+For example, the values in `grid[n, h_out, w_out, :]` are size-2 vectors specifying normalized positions in the 2-dimensional space of `X`.
+They are used to interpolate output values of `Y[n, c, h_out, w_out]`.
+
+The GridSample operator is often used in doing grid generator and sampler in the
+[Spatial Transformer Networks](https://arxiv.org/abs/1506.02025).
+See also in [torch.nn.functional.grid_sample](https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html).
+)DOC";
+
+const char kDoc_Atanh_ver9[] = R"DOC(
+Calculates the hyperbolic arctangent of the given input tensor element-wise.
+)DOC";
+
+const char kDoc_Flatten_ver24[] = R"DOC(
+Flattens the input tensor into a 2D matrix. If input tensor has shape
+(d_0, d_1, ... d_n) then the output will have shape
+(d_0 X d_1 ... d_(axis-1), d_axis X d_(axis+1) ... X dn).
+)DOC";
+
+const char kDoc_Reciprocal_ver6[] = R"DOC(
+Reciprocal takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the reciprocal is, y = 1/x, is applied to
+the tensor elementwise.
+)DOC";
+
+const char kDoc_Pow_ver13[] = R"DOC(
+Pow takes input data (Tensor<T>) and exponent Tensor, and
+produces one output data (Tensor<T>) where the function `f(x) = x^exponent`,
+is applied to the data tensor elementwise.
+)DOC";
+
+const char kDoc_Tan_ver7[] = R"DOC(
+Calculates the tangent of the given input tensor, element-wise.
+)DOC";
+
+const char kDoc_mish_ver18[] = R"DOC(
+Mish: A Self Regularized Non-Monotonic Neural Activation Function.
+
+Perform the linear unit element-wise on the input tensor X using formula:
+
+```
+mish(x) = x * tanh(softplus(x)) = x * tanh(ln(1 + e^{x}))
+```
+)DOC";
+
+const char kDoc_RoiAlign_ver16[] = R"DOC(
+Region of Interest (RoI) align operation described in the
+[Mask R-CNN paper](https://arxiv.org/abs/1703.06870).
+RoiAlign consumes an input tensor X and region of interests (rois)
+to apply pooling across each RoI; it produces a 4-D tensor of shape
+(num_rois, C, output_height, output_width).
+
+RoiAlign is proposed to avoid the misalignment by removing
+quantizations while converting from original image into feature
+map and from feature map into RoI feature; in each ROI bin,
+the value of the sampled locations are computed directly
+through bilinear interpolation.
+)DOC";
+
+const char kDoc_LeakyRelu_ver1[] = R"DOC(
+LeakyRelu takes input data (Tensor<T>) and an argument alpha, and produces one
+output data (Tensor<T>) where the function `f(x) = alpha * x for x < 0`,
+`f(x) = x for x >= 0`, is applied to the data tensor elementwise.
+)DOC";
+
+const char kDoc_Det_ver11[] = R"DOC(
+Det calculates determinant of a square matrix or batches of square matrices.
+Det takes one input tensor of shape `[*, M, M]`, where `*` is zero or more batch dimensions,
+and the inner-most 2 dimensions form square matrices.
+The output is a tensor of shape `[*]`, containing the determinants of all input submatrices.
+e.g., When the input is 2-D, the output is a scalar(shape is empty: `[]`).
+)DOC";
+
+const char kDoc_RandomUniformLike_ver1[] = R"DOC(
+Generate a tensor with random values drawn from a uniform distribution.
+The shape of the output tensor is copied from the shape of the input tensor,
+and the parameters of the uniform distribution are specified by `low` and `high`.
+
+The data type is specified by the 'dtype' argument, or copied from the input tensor if not provided.
+The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+TensorProto message and be valid as an output type.
+)DOC";
+
+const char kDoc_Relu_ver6[] = R"DOC(
+Relu takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the rectified linear function, y = max(0, x), is applied to
+the tensor elementwise.
+)DOC";
+
+const char kDoc_RandomNormalLike_ver1[] = R"DOC(
+Generate a tensor with random values drawn from a normal distribution.
+The shape of the output tensor is copied from the shape of the input tensor,
+and the parameters of the normal distribution are specified by `mean` and `scale`.
+
+The data type is specified by the 'dtype' argument, or copied from the input tensor if not provided.
+The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+TensorProto message, and be valid as an output type.
+)DOC";
+
+const char kDoc_Exp_ver6[] = R"DOC(
+Calculates the exponential of the given input tensor, element-wise.
+)DOC";
+
+const char kDoc_Sign_ver9[] = R"DOC(
+Calculate the sign of the given input tensor element-wise.
+If input > 0, output 1. if input < 0, output -1. if input == 0, output 0.
+)DOC";
+
+const char kDoc_Cosh_ver9[] = R"DOC(
+Calculates the hyperbolic cosine of the given input tensor element-wise.
+)DOC";
+
+const char kDoc_Sigmoid_ver6[] = R"DOC(
+Sigmoid takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the sigmoid function, y = 1 / (1 + exp(-x)), is applied to the
+tensor elementwise.
+)DOC";
+
+const char kDoc_HardSigmoid_ver6[] = R"DOC(
+HardSigmoid takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the HardSigmoid function, y = max(0, min(1, alpha * x + beta)),
+is applied to the tensor elementwise.
+)DOC";
+
+const char kDoc_LpNormalization_ver1[] = R"DOC(
+Given a matrix, apply Lp-normalization along the provided axis.
+The output is computed as: `output = input / Lp_norm(input, axis)`.
+When the Lp norm is zero (i.e., all elements along the axis are zero),
+the output is defined to be zero to avoid division by zero.
+)DOC";
+
+const char kDoc_Erf_ver9[] = R"DOC(
+Computes the error function of the given input tensor element-wise.
+)DOC";
+
+const char kDoc_Asinh_ver9[] = R"DOC(
+Calculates the hyperbolic arcsine of the given input tensor element-wise.
+)DOC";
+
+const char kDoc_Sinh_ver9[] = R"DOC(
+Calculates the hyperbolic sine of the given input tensor element-wise.
+)DOC";
+
+const char kDoc_Atan_ver7[] = R"DOC(
+Calculates the arctangent (inverse of tangent) of the given input tensor, element-wise.
+)DOC";
+
+const char kDoc_Sqrt_ver6[] = R"DOC(
+Square root takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the square root is, y = x^0.5, is applied to
+the tensor elementwise. If x is negative, then it will return NaN.
+)DOC";
+
+const char kDoc_Asin_ver7[] = R"DOC(
+Calculates the arcsine (inverse of sine) of the given input tensor, element-wise.
+)DOC";
+
+const char kDoc_Expand_ver8[] = R"DOC(
+Broadcast the input tensor following the given shape and the broadcast rule.
+The broadcast rule is similar to numpy.array(input) * numpy.ones(shape):
+Dimensions are right alignment;
+Two corresponding dimensions must have the same value, or one of them is equal to 1.
+Also, this operator is similar to numpy.broadcast_to(input, shape),
+but the major difference is numpy.broadcast_to() does not allow shape to be smaller than input.size().
+It is possible that the output.shape is not equal to shape, when some dimensions in shape is equal to 1,
+or the shape.ndim < input.shape.ndim.
+)DOC";
+
+const char kDoc_scan_24[] = R"DOC(
+Scan can be used to iterate over one or more scan_input tensors,
+constructing zero or more scan_output tensors. It combines ideas from general recurrences,
+functional programming constructs such as scan, fold, map, and zip, and is intended to enable
+generalizations of RNN-like constructs for sequence-to-sequence processing.
+Other tensors (referred to as state_variables here) can be used to carry a state
+when iterating from one element to another (similar to hidden-state in RNNs, also referred
+to as loop-carried dependences in the context of loops).
+Many common usages involve a single scan_input tensor (where functionality
+similar to scan, fold and map can be obtained). When more than one scan_input is used,
+a behavior similar to zip is obtained.
+
+The attribute body must be a graph, specifying the computation to be performed in
+every iteration. It takes as input the current values of the state_variables and
+the current iterated element of the scan_inputs. It must return the (updated) values
+of the state_variables and zero or more scan_output_element tensors. The values of the
+scan_output_element tensors are concatenated over all the iterations to produce the
+scan_output values of the scan construct (similar to the concatenated intermediate
+hidden-state values of RNN-like constructs). All the output tensors (state_variables as
+well as scan_output_element tensors) are required to have the same shape in each iteration
+of the loop (a restriction imposed to enable efficient memory allocation).
+
+Note that the iterated element passed to the body subgraph does not have a sequence
+axis. It will have a rank one less than the rank of the corresponding scan_input.
+
+The scan operation returns the final values of the state_variables as well as the
+scan_outputs.
+
+The optional attribute scan_input_directions specifies the direction (forward or backward)
+for each scan input. If this attribute is omitted, all sequences are scanned in the forward
+direction. A bidirectional scan may be performed by specifying the same tensor input twice
+in the scan_inputs, once with a forward direction, and once with a backward direction.
+
+The scan_output of the operation is produced by concatenating the scan_output_element
+values produced by the body in each iteration.  The optional attribute scan_output_directions
+specifies the direction in which scan_output is constructed (by appending or prepending the
+scan_output_element to scan_output in each iteration) for each scan_output. If this attribute
+is omitted, the scan_output_element is appended to the scan_output in each iteration.
+
+The optional attribute scan_input_axes specifies the axis to be scanned for each scan_input.
+If omitted, every scan_input will be scanned in axis 0. For example, if axis 0 is the
+batch axis and axis 1 is the time axis (to be scanned), specify an axis value of 1.
+Note that scanning a non-zero axis may be less efficient than scanning axis zero.
+
+The optional attribute scan_output_axes specifies the axis along which the scan_outputs
+are accumulated for each scan_output. For example, if axis 1 is the time axis (to be
+scanned) for both inputs and outputs, specify a scan_input axis and scan_output axis
+value of 1.
+
+Note that because of the ONNX restriction that only the last parameter of an operator can
+be variadic, the initial-states and scan-inputs are listed together as one input parameter.
+Similarly, the final-states and scan-outputs are listed together as one output parameter.
+The attribute num_scan_inputs indicates the number M of scan-inputs.
+
+The behavior of
+
+    Scan <
+        num_scan_inputs = m,
+        body = loop-body,
+        scan_input_axes = [axis_1, ..., axis_m]
+    > (init_1, ..., init_n, scan_1, ..., scan_m)
+
+is equivalent to the following pseudo-code:
+
+    // scan_i.shape[axis_i] denotes the (max) sequence-length of scan_i
+    // scan_i.shape[axis_i] is required to be equal to scan_j.shape[axis_j] for all i,j.
+    sequence_length = scan_1.shape[axis_1];
+
+    // initialize state-variables
+    st_1 = init_1; ... st_n = init_n;
+    // initialize scan-output variables: [] denotes an empty tensor
+    scan_out_1 = []; ...; scan_out_k = [];
+    // identify number of iterations:
+
+    // execute loop
+    for (int t = 0; t < sequence_length; ++t) {
+        // generate the scan-input elements: the notation T<axis=k>[t] indicates the sub-tensor
+        // of rank one less than T obtained by indexing T at position t along axis k.
+        si_1 = scan_1<axis=axis_1>[t];
+        ... ;
+        si_m = scan_m<axis=axis_m>[t];
+        // execute loop-body
+        st_1, ..., st_n, so_1, ..., so_k = loop-body(st_1, ..., st_n, si_1, ..., si_m)
+        // accumulate the scan-output elements
+        scan_out_1 = Concat<axis=0>(scan_out_1, so_1); ... ; scan_out_k = Concat<axis=0>(scan_out_k, so_k);
+    }
+
+    return st_1, ..., st_n, scan_out_1, ..., scan_out_k;
+
+*Sample usage: Encoding RNN using a Scan*
+
+The following example shows how a simple RNN over an input tensor %X, with weight tensor %Wi,
+recurrence weight tensor %Ri, bias tensors %Wbi and %Rbi, and initial hidden-state %H_0 can
+be encoded as a ScanLoop. Note that the loop-body is a nested graph, and it directly computes
+%Wi, %Ri, %Wbi, and %Rbi (typically constants or initializers in the body graph). If these
+values are computed in the outer graph, they need to be passed in as extra state_variables.
+
+    graph rnn-encoding {
+      %H_0 = ...
+      %X = ...
+      %Y_h, %Y = Scan[body = <graph rnn-cell-1>, num_scan_inputs=1](%H_0, %X)
+      return %Y, %Y_h
+    }
+
+    graph rnn-cell-1 (
+      %H_tminus1[FLOAT, tensor]
+      %X_t[FLOAT, tensor]
+    ) {
+      %Wi = ...
+      %Ri = ...
+      %Wbi = ...
+      %Rbi = ...
+      %t1 = X_t * (Wi^T)
+      %t2 = H_tminus1*(Ri^T)
+      %t3 = Add(%t1, %t2)
+      %t4 = Add(%t3, %Wbi)
+      %t5 = Add(%t4, %Rbi)
+      %Ht = Tanh(%t5)
+      %Accumulate = Identity(%Ht)
+      return %Ht, %Accumulate
+    }
+
+)DOC";
+
+const char kDoc_Pad_ver24[] = R"DOC(
+Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+a padded tensor (`output`) is generated.
+
+The four supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+3) `edge` - pads with the edge values of array
+
+4) `wrap` - wrap-around padding as if the data tensor forms a torus
+
+
+Example 1 (`constant` mode):
+
+Insert 0 pads to the beginning of the second dimension.
+
+```
+data = [
+    [1.0, 1.2],
+    [2.3, 3.4],
+    [4.5, 5.7],
+]
+
+pads = [0, 2, 0, 0]
+
+mode = 'constant'
+
+constant_value = 0.0
+
+output = [
+    [0.0, 0.0, 1.0, 1.2],
+    [0.0, 0.0, 2.3, 3.4],
+    [0.0, 0.0, 4.5, 5.7],
+]
+```
+
+Example 2 (`reflect` mode):
+
+```
+data = [
+    [1.0, 1.2],
+    [2.3, 3.4],
+    [4.5, 5.7],
+]
+
+pads = [0, 2, 0, 0]
+
+mode = 'reflect'
+
+output = [
+    [1.0, 1.2, 1.0, 1.2],
+    [2.3, 3.4, 2.3, 3.4],
+    [4.5, 5.7, 4.5, 5.7],
+]
+```
+
+Example 3 (`edge` mode):
+
+```
+data = [
+    [1.0, 1.2],
+    [2.3, 3.4],
+    [4.5, 5.7],
+]
+
+pads = [0, 2, 0, 0]
+
+mode = 'edge'
+
+output = [
+    [1.0, 1.0, 1.0, 1.2],
+    [2.3, 2.3, 2.3, 3.4],
+    [4.5, 4.5, 4.5, 5.7],
+]
+```
+
+Example 4 (`wrap` mode):
+
+```
+data = [
+    [1.0, 1.2],
+    [2.3, 3.4],
+    [4.5, 5.7],
+]
+
+pads = [2, 1, 1, 1]
+
+mode = 'wrap'
+
+output = [
+    [3.4, 2.3, 3.4, 2.3],
+    [5.7, 4.5, 5.7, 4.5],
+    [1.2, 1.0, 1.2, 1.0],
+    [3.4, 2.3, 3.4, 2.3],
+    [5.7, 4.5, 5.7, 4.5],
+    [1.2, 1.0, 1.2, 1.0],
+]
+```
+)DOC";
+
+const char kDoc_Cos_ver7[] = R"DOC(
+Calculates the cosine of the given input tensor, element-wise.
+)DOC";
+
+const char kDoc_HardSwish_ver14[] = R"DOC(
+HardSwish takes one input data (Tensor<T>) and produces one output data (Tensor<T>) where
+the HardSwish function, y = x * max(0, min(1, alpha * x + beta)) = x * HardSigmoid<alpha, beta>(x),
+where alpha = 1/6 and beta = 0.5, is applied to the tensor elementwise.
+)DOC";
+
+const char kDoc_MatMul_ver9[] = R"DOC(
+Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+)DOC";
+
+const char kDoc_NegativeLogLikelihoodLoss_ver13[] = R"DOC(
+A NegativeLogLikelihoodLoss operator computes (weighted) negative log likelihood loss.
+Its "input" tensor has the shape of (N, C, d1, d2, ..., dk) where k >= 0.
+The "input" tensor contains log-probabilities for input[n, :, d_1, d_2,..., d_k] being in a class of [0, C).
+The operator's "target" input tensor has the shape of (N, d1, d2, ..., dk). It encodes class labels (one of C classes)
+or it may contain a special value (indicated by an attribute ignore_index) for N x d1 x d2 x ... x dk samples.
+The loss value for input[n, :, d_1, d_2,...d_k] being classified as class c = target[n][d_1][d_2]...[d_k] is computed as:
+
+```
+loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k].
+```
+
+When an optional "weight" is provided, the sample loss is calculated as:
+
+```
+loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k] * weight[c].
+```
+
+loss is zero for the case when target-value equals ignore_index.
+
+```
+loss[n][d_1][d_2]...[d_k] = 0, when target[n][d_1][d_2]...[d_k] = ignore_index
+```
+
+If "reduction" attribute is set to "none", the operator's output will be the above loss with shape (N, d1, d2, ..., dk).
+If "reduction" attribute is set to "mean" (the default attribute value), the output loss is (weight) averaged:
+
+```
+mean(loss), if "weight" is not provided,
+```
+
+or if weight is provided,
+
+```
+sum(loss) / sum(weight[target[n][d_1][d_2]...[d_k]]]), for all samples.
+```
+
+If "reduction" attribute is set to "sum", the output is a scalar: `sum(loss)`.
+
+See also https://pytorch.org/docs/stable/nn.html#torch.nn.NLLLoss.
+
+Example 1:
+
+```
+// negative log likelihood loss, "none" reduction
+N, C, d1 = 2, 3, 2
+input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+          [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+target = [[2, 1], [0, 2]]
+
+loss = np.zeros((N, d1))
+for n in range(N):
+    for d_1 in range(d1):
+        c = target[n][d_1]
+        loss[n][d_1] = -input[n][c][d_1]
+
+// print(loss)
+// [[-3. -2.]
+//  [-0. -2.]]
+```
+
+Example 2:
+
+```
+// weighted negative log likelihood loss, sum reduction
+N, C, d1 = 2, 3, 2
+input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+        [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+target = [[2, 1], [0, 2]]
+weight = [0.2, 0.3, 0.1]
+loss = np.zeros((N, d1))
+for n in range(N):
+    for d_1 in range(d1):
+        c = target[n][d_1]
+        loss[n][d_1] = -input[n][c][d_1] * weight[c]
+
+loss = np.sum(loss)
+// print(loss)
+// -1.1
+```
+
+Example 3:
+
+```
+// weighted negative log likelihood loss, mean reduction
+N, C, d1 = 2, 3, 2
+input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+        [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+target = [[2, 1], [0, 2]]
+weight = [0.2, 0.3, 0.1]
+loss = np.zeros((N, d1))
+weight_total = 0
+for n in range(N):
+    for d_1 in range(d1):
+        c = target[n][d_1]
+        loss[n][d_1] = -input[n][c][d_1] * weight[c]
+        weight_total = weight_total + weight[c]
+
+loss = np.sum(loss) / weight_total
+// print(loss)
+// -1.57
+```
+)DOC";
+
+const char kDoc_Sin_ver7[] = R"DOC(
+Calculates the sine of the given input tensor, element-wise.
+)DOC";
+
+const char kDoc_Loop_ver23[] = R"DOC(
+Generic Looping construct. This loop has multiple termination conditions:
+
+1) Trip count. Iteration count specified at runtime. Set by
+   specifying the input M. Optional. Set to empty string to omit.
+   Note that a static trip count (specified at graph construction time) can be
+   specified by passing in a constant node for input M.
+2) Loop termination condition. This is an input to the op that determines
+   whether to run the first iteration and also a loop-carried dependency for
+   the body graph. The body graph must yield a value for the condition variable,
+   whether this input is provided or not.
+
+This table summarizes the operating modes of this operator with equivalent
+C-style code:
+
+Operator inputs defined as (max_trip_count, condition_var).
+
+* input ("", ""):
+        for (int i=0; ; ++i) {
+          cond = ... // Note this value is ignored, but is required in the body
+        }
+
+* input ("", cond) // Note this is analogous to a while loop
+        bool cond = ...;
+        for (int i=0; cond; ++i) {
+          cond = ...;
+        }
+
+* input ("", 1) // Note this is analogous to a do-while loop
+        bool cond = true
+        for (int i=0; cond; ++i) {
+          cond = ...;
+        }
+
+* input (trip_count, "") // Note this is analogous to a for loop
+        int trip_count = ...
+        for (int i=0; i < trip_count; ++i) {
+          cond = ...; // ignored
+        }
+
+* input (trip_count, cond)
+        int trip_count = ...;
+        bool cond = ...;
+        for (int i=0; i < trip_count && cond; ++i) {
+          cond = ...;
+        }
+
+
+*Sample usage - cond as well as trip count*
+
+    graph predict-net {
+      %a = Constant[value = <Scalar Tensor [3]>]()
+      %b = Constant[value = <Scalar Tensor [6]>]()
+      %keepgoing = Constant[value = <Scalar Tensor [1]>]()
+      %max_trip_count = Constant[value = <Scalar Tensor [10]>]()
+      %keepgoing_out, %b_out, %user_defined_vals = Loop[body = <graph body-net>](%max_trip_count, %keepgoing, %b)
+      return
+    }
+
+    graph body-net (
+      %i[INT32, scalar]           // iteration number
+      %keepgoing_in[BOOL, scalar] // incoming loop-termination-condition; not used
+      %b_in[INT32, scalar]        // incoming value of loop-carried-dependency b
+    ) {
+      %my_local = Add(%a, %b_in)
+      %b_out = Sub(%a, %b_in) // outgoing value of loop-carried-dependency b
+      %keepgoing_out = Greater(%my_local, %b_out) // outgoing loop-termination-condition
+      %user_defined_val = Add(%b_in, %b_in) // scan-output value to be accumulated
+      return %keepgoing_out, %b_out, %user_defined_val
+    }
+
+*Sample equivalent C code*
+
+    {
+      /* User-defined code (enclosing scope) */
+      int a = 3, b = 6;
+      bool keepgoing = true; // Analogous to input cond
+      /* End user-defined code */
+
+      /* Implicitly-defined code */
+      const int max_trip_count = 10; // Analogous to input M
+      int user_defined_vals[]; // Imagine this is resizable
+      /* End implicitly-defined code */
+      /* initialize loop-carried variables and scan-output variables */
+      bool keepgoing_out = keepgoing
+      int b_out = b
+
+      for (int i=0; i < max_trip_count && keepgoing_out; ++i) {
+        /* Implicitly-defined code: bind actual parameter values
+           to formal parameter variables of loop-body */
+        bool keepgoing_in = keepgoing_out;
+        bool b_in = b_out;
+
+        /* User-defined code (loop body) */
+        int my_local = a + b_in; // Reading value "a" from the enclosing scope is fine
+        b_out = a - b_in;
+        keepgoing_out = my_local > b_out;
+        user_defined_val = b_in + b_in; // b_in and b_out are different variables
+        /* End user-defined code */
+
+        /* Implicitly defined-code */
+        user_defined_vals[i] = user_defined_val // accumulate scan-output values
+      }
+      // int t = my_local; // Can't do this. my_local is not accessible here.
+
+      // The values below are bound to the output variables of the loop and therefore accessible
+      // b_out; user_defined_vals; keepgoing_out;
+    }
+
+There are several things of note in this code snippet:
+
+1) Values from the enclosing scope (i.e. variable "a" here) are in scope and can
+   be referenced in the inputs of the loop.
+2) Any values computed in the loop body that needs to be used in a subsequent
+   iteration or after the loop are modeled using a pair of variables in the loop-body,
+   consisting of an input variable (eg., b_in) and an output variable (eg., b_out).
+   These are referred to as loop-carried dependences. The loop operation node
+   supplies the input value of the input variable for the first iteration, and
+   returns the output value of the output variable produced by the final
+   iteration.
+3) Scan_output variables are used to implicitly concatenate values computed across
+   all the iterations. In the above example, the value of user_defined_val computed
+   over all iterations are concatenated and returned as the value of user_defined_vals
+   after the loop.
+4) Values created in the body cannot be accessed in the enclosing scope,
+   except using the mechanism described above.
+
+Note that the semantics of this op support "diagonal" or "wavefront" execution.
+(See Step 3 here for an example:
+https://devblogs.nvidia.com/optimizing-recurrent-neural-networks-cudnn-5/).
+Frontends should emit multi-layer RNNs as a series of While operators (with
+time being the inner looping dimension), with each successive layer consuming
+the scan_outputs from the previous layer, possibly going through several
+point-wise operators (e.g. dropout, residual connections, linear layer).
+
+The input/output of subgraph (produced by loop node) matching is based on order instead of name. The implementation will figure out the names based on this order.
+)DOC";
+
+const char kDoc_RNN_ver14[] = R"DOC(
+Computes an one-layer simple RNN. This operator is usually supported
+via some custom implementation such as CuDNN.
+
+Notations:
+
+* `X` - input tensor
+* `i` - input gate
+* `t` - time step (t-1 means previous time step)
+* `Wi` - W parameter weight matrix for input gate
+* `Ri` - R recurrence weight matrix for input gate
+* `Wbi` - W parameter bias vector for input gate
+* `Rbi` - R parameter bias vector for input gate
+* `WBi` - W parameter weight matrix for backward input gate
+* `RBi` - R recurrence weight matrix for backward input gate
+* `WBbi` - WR bias vectors for backward input gate
+* `RBbi` - RR bias vectors for backward input gate
+* `H` - Hidden state
+* `num_directions` - 2 if direction == bidirectional else 1
+
+Activation functions:
+
+* Relu(x)                - max(0, x)
+* Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+* Sigmoid(x)             - 1/(1 + e^{-x})
+
+NOTE: Below are optional
+
+* Affine(x)              - alpha*x + beta
+* LeakyRelu(x)           - x if x >= 0 else alpha * x
+* ThresholdedRelu(x)     - x if x >= alpha else 0
+* ScaledTanh(x)          - alpha*Tanh(beta*x)
+* HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+* Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+* Softsign(x)            - x/(1 + |x|)
+* Softplus(x)            - log(1 + e^x)
+
+Equations (Default: f=Tanh):
+
+* Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi)
+)DOC";
+
+const char kDoc_NonMaxSuppression_ver10[] = R"DOC(
+Filter out boxes that have high intersection-over-union (IOU) overlap with previously selected boxes.
+Bounding boxes with score less than score_threshold are removed. Bounding box format is indicated by attribute center_point_box.
+Boxes are suppressed if their IOU with a previously selected box is strictly greater than iou_threshold (i.e., boxes with IOU exactly equal to the threshold are kept).
+Note that this algorithm is agnostic to where the origin is in the coordinate system and more generally is invariant to
+orthogonal transformations and translations of the coordinate system; thus translating or reflections of the coordinate system
+result in the same boxes being selected by the algorithm.
+The selected_indices output is a set of integers indexing into the input collection of bounding boxes representing the selected boxes.
+The bounding box coordinates corresponding to the selected indices can then be obtained using the Gather or GatherND operation.
+)DOC";
+
+const char kDoc_Log_ver6[] = R"DOC(
+Calculates the natural log of the given input tensor, element-wise.
+)DOC";
+
+const char kDoc_EyeLike_ver9[] = R"DOC(
+Generate a 2D tensor (matrix) with ones on the diagonal and zeros everywhere else. Only 2D
+tensors are supported, i.e. input T1 must be of rank 2. The shape of the output tensor is the
+same as the input tensor. The data type can be specified by the 'dtype' argument. If
+'dtype' is not specified, then the type of input tensor is used. By default, the main diagonal
+is populated with ones, but attribute 'k' can be used to populate upper or lower diagonals.
+The 'dtype' argument must be one of the data types specified in the 'DataType' enum field in the
+TensorProto message and be valid as an output type.
+)DOC";
+
+const char kDoc_Reshape_ver24[] = R"DOC(
+Reshape the input tensor similar to numpy.reshape.
+First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+At most one dimension of the new shape can be -1. In this case, the value is
+inferred from the size of the tensor and the remaining dimensions. A dimension
+could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+from the input tensor). If 'allowzero' is set, and the new shape includes 0, the
+dimension will be set explicitly to zero (i.e. not taken from input tensor).
+Shape (second input) could be an empty shape, which means converting to a scalar.
+The input tensor's shape and the output tensor's shape are required to have the same number of elements.
+
+If the attribute 'allowzero' is set, it is invalid for the specified shape to
+contain both a zero value and -1, as the value of the dimension corresponding
+to -1 cannot be determined uniquely.
+)DOC";
+
+const char kDoc_Compress_ver9[] = R"DOC(
+    Selects slices from an input tensor along a given axis where condition evaluates to True for each axis index.
+    In case axis is not provided, input is flattened before elements are selected.
+    Compress behaves like numpy.compress: https://docs.scipy.org/doc/numpy/reference/generated/numpy.compress.html
+    )DOC";
+
+const char kDoc_PRelu_ver7[] = R"DOC(
+PRelu takes input data (Tensor<T>) and slope tensor as input, and produces one
+output data (Tensor<T>) where the function `f(x) = slope * x for x < 0`,
+`f(x) = x for x >= 0`., is applied to the data tensor elementwise.
+)DOC";
+
+const char kDoc_Neg_ver6[] = R"DOC(
+Neg takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where each element flipped sign, y = -x, is applied to
+the tensor elementwise.
+)DOC";
+
+const char kDoc_BitCast_ver26[] = R"DOC(
+Reinterprets the binary representation of a tensor as a different data type,
+specified by the 'to' attribute. Unlike Cast, BitCast preserves the exact bit
+pattern without any value conversion.
+
+The target data type must have the same bit-width as the input data type.
+The output tensor has the same shape as the input tensor.
+All types except string are supported. Implementations must treat the
+underlying bytes as little endian.
+)DOC";
+
+#else
+const char kDoc_GRU_ver14[] = "";
+const char kDoc_Squeeze_ver24[] = "";
+const char kDoc_MaxUnpool_ver11[] = "";
+const char kDoc_Size_ver24[] = "";
+const char kDoc_RandomUniform_ver1[] = "";
+const char kDoc_Range_ver11[] = "";
+const char kDoc_Range_ver27[] = "";
+const char kDoc_DequantizeLinear_ver24[] = "";
+const char kDoc_RandomNormal_ver1[] = "";
+const char kDoc_Round_ver11[] = "";
+const char kDoc_SpaceToDepth_ver1[] = "";
+const char kDoc_InstanceNormalization_ver6[] = "";
+const char kDoc_ThresholdedRelu_ver10[] = "";
+const char kDoc_Acosh_ver9[] = "";
+const char kDoc_Dropout_ver13[] = "";
+const char kDoc_DeformConv_ver19[] = "";
+const char kDoc_Softplus_ver1[] = "";
+const char kDoc_Tile_ver6[] = "";
+const char kDoc_Unsqueeze_ver24[] = "";
+const char kDoc_ConstantOfShape_ver24[] = "";
+const char kDoc_Elu_ver6[] = "";
+const char kDoc_CumSum_ver11[] = "";
+const char kDoc_Acos_ver7[] = "";
+const char kDoc_LSTM_ver14[] = "";
+const char kDoc_Bernoulli_ver15[] = "";
+const char kDoc_Softsign_ver1[] = "";
+const char kDoc_Selu_ver6[] = "";
+const char kDoc_Shape_ver24[] = "";
+const char kDoc_Upsample_ver7[] = "";
+const char kDoc_Tanh_ver6[] = "";
+const char kDoc_Cast_ver24[] = "";
+const char kDoc_Multinomial_ver7[] = "";
+const char kDoc_Constant_ver24[] = "";
+const char kDoc_Where_ver9[] = "";
+const char kDoc_CastLike_ver24[] = "";
+const char kDoc_GridSample_ver20[] = "";
+const char kDoc_Atanh_ver9[] = "";
+const char kDoc_Flatten_ver24[] = "";
+const char kDoc_Reciprocal_ver6[] = "";
+const char kDoc_Pow_ver13[] = "";
+const char kDoc_Tan_ver7[] = "";
+const char kDoc_mish_ver18[] = "";
+const char kDoc_RoiAlign_ver16[] = "";
+const char kDoc_LeakyRelu_ver1[] = "";
+const char kDoc_Det_ver11[] = "";
+const char kDoc_RandomUniformLike_ver1[] = "";
+const char kDoc_Relu_ver6[] = "";
+const char kDoc_RandomNormalLike_ver1[] = "";
+const char kDoc_Exp_ver6[] = "";
+const char kDoc_Sign_ver9[] = "";
+const char kDoc_Cosh_ver9[] = "";
+const char kDoc_Sigmoid_ver6[] = "";
+const char kDoc_HardSigmoid_ver6[] = "";
+const char kDoc_LpNormalization_ver1[] = "";
+const char kDoc_Erf_ver9[] = "";
+const char kDoc_Asinh_ver9[] = "";
+const char kDoc_Sinh_ver9[] = "";
+const char kDoc_Atan_ver7[] = "";
+const char kDoc_Sqrt_ver6[] = "";
+const char kDoc_Asin_ver7[] = "";
+const char kDoc_Expand_ver8[] = "";
+const char kDoc_scan_24[] = "";
+const char kDoc_Pad_ver24[] = "";
+const char kDoc_Cos_ver7[] = "";
+const char kDoc_HardSwish_ver14[] = "";
+const char kDoc_MatMul_ver9[] = "";
+const char kDoc_NegativeLogLikelihoodLoss_ver13[] = "";
+const char kDoc_Sin_ver7[] = "";
+const char kDoc_Loop_ver23[] = "";
+const char kDoc_RNN_ver14[] = "";
+const char kDoc_NonMaxSuppression_ver10[] = "";
+const char kDoc_Log_ver6[] = "";
+const char kDoc_EyeLike_ver9[] = "";
+const char kDoc_Reshape_ver24[] = "";
+const char kDoc_Compress_ver9[] = "";
+const char kDoc_PRelu_ver7[] = "";
+const char kDoc_Neg_ver6[] = "";
+const char kDoc_BitCast_ver26[] = "";
+#endif
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/doc_strings.h b/onnx/defs/doc_strings.h
new file mode 100644
index 0000000..5ebb787
--- /dev/null
+++ b/onnx/defs/doc_strings.h
@@ -0,0 +1,86 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+namespace ONNX_NAMESPACE {
+extern const char kDoc_Acos_ver7[];
+extern const char kDoc_Acosh_ver9[];
+extern const char kDoc_Asin_ver7[];
+extern const char kDoc_Asinh_ver9[];
+extern const char kDoc_Atan_ver7[];
+extern const char kDoc_Atanh_ver9[];
+extern const char kDoc_Bernoulli_ver15[];
+extern const char kDoc_BitCast_ver26[];
+extern const char kDoc_Cast_ver24[];
+extern const char kDoc_CastLike_ver24[];
+extern const char kDoc_Compress_ver9[];
+extern const char kDoc_Constant_ver24[];
+extern const char kDoc_ConstantOfShape_ver24[];
+extern const char kDoc_Cos_ver7[];
+extern const char kDoc_Cosh_ver9[];
+extern const char kDoc_CumSum_ver11[];
+extern const char kDoc_DeformConv_ver19[];
+extern const char kDoc_DequantizeLinear_ver24[];
+extern const char kDoc_Det_ver11[];
+extern const char kDoc_Dropout_ver13[];
+extern const char kDoc_Elu_ver6[];
+extern const char kDoc_Erf_ver9[];
+extern const char kDoc_Exp_ver6[];
+extern const char kDoc_Expand_ver8[];
+extern const char kDoc_EyeLike_ver9[];
+extern const char kDoc_Flatten_ver24[];
+extern const char kDoc_GridSample_ver20[];
+extern const char kDoc_GRU_ver14[];
+extern const char kDoc_HardSigmoid_ver6[];
+extern const char kDoc_HardSwish_ver14[];
+extern const char kDoc_InstanceNormalization_ver6[];
+extern const char kDoc_LeakyRelu_ver1[];
+extern const char kDoc_Log_ver6[];
+extern const char kDoc_Loop_ver23[];
+extern const char kDoc_LpNormalization_ver1[];
+extern const char kDoc_LSTM_ver14[];
+extern const char kDoc_MatMul_ver9[];
+extern const char kDoc_MaxUnpool_ver11[];
+extern const char kDoc_mish_ver18[];
+extern const char kDoc_Multinomial_ver7[];
+extern const char kDoc_Neg_ver6[];
+extern const char kDoc_NegativeLogLikelihoodLoss_ver13[];
+extern const char kDoc_NonMaxSuppression_ver10[];
+extern const char kDoc_Pad_ver24[];
+extern const char kDoc_Pow_ver13[];
+extern const char kDoc_PRelu_ver7[];
+extern const char kDoc_RandomNormal_ver1[];
+extern const char kDoc_RandomNormalLike_ver1[];
+extern const char kDoc_RandomUniform_ver1[];
+extern const char kDoc_Range_ver11[];
+extern const char kDoc_Range_ver27[];
+extern const char kDoc_RandomUniformLike_ver1[];
+extern const char kDoc_Reciprocal_ver6[];
+extern const char kDoc_Relu_ver6[];
+extern const char kDoc_Reshape_ver24[];
+extern const char kDoc_RNN_ver14[];
+extern const char kDoc_RoiAlign_ver16[];
+extern const char kDoc_Round_ver11[];
+extern const char kDoc_scan_24[];
+extern const char kDoc_Selu_ver6[];
+extern const char kDoc_Shape_ver24[];
+extern const char kDoc_Sigmoid_ver6[];
+extern const char kDoc_Sign_ver9[];
+extern const char kDoc_Sin_ver7[];
+extern const char kDoc_Sinh_ver9[];
+extern const char kDoc_Size_ver24[];
+extern const char kDoc_Softplus_ver1[];
+extern const char kDoc_Softsign_ver1[];
+extern const char kDoc_SpaceToDepth_ver1[];
+extern const char kDoc_Sqrt_ver6[];
+extern const char kDoc_Squeeze_ver24[];
+extern const char kDoc_Tan_ver7[];
+extern const char kDoc_Tanh_ver6[];
+extern const char kDoc_ThresholdedRelu_ver10[];
+extern const char kDoc_Tile_ver6[];
+extern const char kDoc_Unsqueeze_ver24[];
+extern const char kDoc_Upsample_ver7[];
+extern const char kDoc_Where_ver9[];
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/function.cc b/onnx/defs/function.cc
new file mode 100644
index 0000000..4f40fe0
--- /dev/null
+++ b/onnx/defs/function.cc
@@ -0,0 +1,226 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/function.h"
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "onnx/defs/schema.h"
+#include "onnx/inliner/inliner.h"
+
+static std::string InternalTensorNameGenerator(const std::string& node_name, const std::string& internal_name) {
+  std::string new_name = "Func_" + node_name + internal_name;
+  return new_name;
+}
+
+namespace ONNX_NAMESPACE {
+void FunctionExpandHelper(
+    const NodeProto& node,
+    const FunctionProto& func,
+    GraphProto& g,
+    const std::string& node_prefix) {
+  // Create a temporary unique node prefix for tensor names
+  std::string uniq_prefix = node_prefix;
+  if (uniq_prefix.empty()) {
+    const void* address = static_cast<const void*>(&node);
+    std::stringstream ss;
+    ss << address;
+    uniq_prefix = ss.str();
+  }
+  std::string node_name = node.has_name() ? node.name() : func.name() + uniq_prefix;
+  std::unordered_map<std::string, std::string> io_names_map;
+  std::unordered_map<std::string, AttributeProto> attr_map;
+
+  for (int idx = 0; idx < node.input_size(); ++idx) {
+    if (idx >= func.input_size()) {
+      ONNX_THROW("Input for function node " + node_name + " is out of bounds");
+    }
+    io_names_map[func.input().Get(idx)] = node.input().Get(idx);
+  }
+  for (int idx = 0; idx < node.output_size(); ++idx) {
+    if (idx >= func.output_size()) {
+      ONNX_THROW("Output for function node " + node_name + " is out of bounds");
+    }
+    // If the node output is missing, the corresponding function output should
+    // be treated as an internal value (not as missing) because it could also be
+    // an intermediate value.
+    if (node.output().Get(idx).empty()) {
+      continue;
+    }
+    io_names_map[func.output().Get(idx)] = node.output().Get(idx);
+  }
+
+  for (const auto& attr : node.attribute()) {
+    attr_map[attr.name()] = attr;
+  }
+
+  // For undefined attributes of the function node
+  // add default values obtained from the function schema.
+  // get the domain version for function schema
+  int domain_version = -1;
+  for (const auto& opset_import : func.opset_import()) {
+    if (opset_import.domain() == node.domain()) {
+      domain_version = static_cast<int>(opset_import.version());
+    }
+  }
+  if (domain_version == -1) {
+    ONNX_THROW("No opset import registered for domain '" + node.domain() + "' in function proto");
+  }
+
+  const OpSchemaRegistry* schema_registry = OpSchemaRegistry::Instance();
+  const auto* const schema = schema_registry->GetSchema(node.op_type(), domain_version, node.domain());
+  if (schema == nullptr) {
+    ONNX_THROW(
+        "No schema registered for op '" + node.op_type() + "' in domain '" + node.domain() + "' at version " +
+        std::to_string(domain_version) + " while expanding function node " + node_name);
+  }
+  const auto& default_attrs = schema->attributes();
+
+  for (const auto& [attr_name, attr] : default_attrs) {
+    if (!attr_map.count(attr_name)) {
+      attr_map[attr_name] = attr.default_value;
+    }
+  }
+
+  for (const auto& function_node : func.node()) {
+    NodeProto* new_node = g.add_node();
+    new_node->CopyFrom(function_node);
+    new_node->clear_input();
+    new_node->clear_output();
+    new_node->clear_attribute();
+    for (const auto& input : function_node.input()) {
+      if (io_names_map.count(input)) {
+        new_node->add_input(io_names_map[input]);
+      } else {
+        new_node->add_input(InternalTensorNameGenerator(node_name, input));
+      }
+    }
+    for (const auto& output : function_node.output()) {
+      if (io_names_map.count(output)) {
+        new_node->add_output(io_names_map[output]);
+      } else {
+        new_node->add_output(InternalTensorNameGenerator(node_name, output));
+      }
+    }
+    for (const auto& attr : function_node.attribute()) {
+      if (attr.has_ref_attr_name()) {
+        if (attr_map.count(attr.ref_attr_name())) {
+          AttributeProto* new_attr = new_node->add_attribute();
+          new_attr->CopyFrom(attr_map[attr.ref_attr_name()]);
+          new_attr->set_name(attr.name());
+        }
+      } else {
+        AttributeProto* new_attr = new_node->add_attribute();
+        new_attr->CopyFrom(attr);
+      }
+    }
+  }
+}
+
+std::vector<NodeProto> FunctionBodyHelper::BuildNodes(const std::vector<NodeDef>& node_defs) {
+  std::vector<NodeProto> nodes(node_defs.size());
+
+  for (size_t i = 0; i < node_defs.size(); i++) {
+    const NodeDef& node = node_defs[i];
+    NodeProto& n = nodes[i];
+
+    n.set_op_type(node.op_type);
+    n.set_domain(node.domain);
+    for (const auto& i : node.inputs) {
+      n.add_input(i);
+    }
+    for (const auto& o : node.outputs) {
+      n.add_output(o);
+    }
+    for (const auto& attr : node.attributes) {
+      *(n.add_attribute()) = attr.proto;
+    }
+  }
+
+  return nodes;
+}
+
+void FunctionBodyHelper::BuildNodes(FunctionProto& functionProto, const std::vector<NodeDef>& node_defs) {
+  for (const auto& node : node_defs) {
+    auto* np = functionProto.add_node();
+
+    np->set_op_type(node.op_type);
+    np->set_domain(node.domain);
+    for (const auto& inp : node.inputs) {
+      np->add_input(inp);
+    }
+    for (const auto& o : node.outputs) {
+      np->add_output(o);
+    }
+    for (const auto& attr : node.attributes) {
+      *(np->add_attribute()) = attr.proto;
+    }
+  }
+}
+
+bool FunctionBodyHelper::BuildFunctionProto(
+    FunctionProto& functionProto,
+    const OpSchema& schema,
+    const std::vector<NodeDef>& node_defs,
+    const std::vector<OperatorSetIdProto>& relied_opsets) {
+  BuildNodes(functionProto, node_defs);
+
+  for (const auto& relied_opset : relied_opsets) {
+    *(functionProto.mutable_opset_import()->Add()) = relied_opset;
+  }
+
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+FunctionBuilder& FunctionBuilder::AddInlinedCall(
+    std::initializer_list<std::string_view> outputs,
+    const GraphProto& graph,
+    std::initializer_list<std::string_view> inputs,
+    std::string_view prefix) {
+  // Create a renamer with the given prefix
+  inliner::Renamer renamer(std::string(prefix), graph);
+
+  // Bind formal inputs to actual inputs
+  const auto* input_it = inputs.begin();
+  for (const auto& graph_input : graph.input()) {
+    if (input_it != inputs.end()) {
+      renamer.BindName(graph_input.name(), std::string(*input_it));
+      ++input_it;
+    }
+  }
+
+  // Bind formal outputs to actual outputs
+  const auto* output_it = outputs.begin();
+  for (const auto& graph_output : graph.output()) {
+    if (output_it != outputs.end()) {
+      renamer.BindName(graph_output.name(), std::string(*output_it));
+      ++output_it;
+    }
+  }
+
+  // Add Constant nodes for every initializer in the graph
+  for (const auto& initializer : graph.initializer()) {
+    std::string const_name = renamer.BindToUniqueName(initializer.name());
+    Const(const_name, initializer);
+  }
+
+  // Add a copy of every node in the graph with renamed variables
+  for (const auto& node : graph.node()) {
+    NodeProto new_node;
+    new_node.CopyFrom(node);
+
+    // Rename the node using the renamer
+    renamer.RenameNode(new_node);
+
+    // Add the node to the function
+    *funProto.add_node() = new_node;
+  }
+
+  return *this;
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/function.h b/onnx/defs/function.h
new file mode 100644
index 0000000..57b61dc
--- /dev/null
+++ b/onnx/defs/function.h
@@ -0,0 +1,247 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "onnx/common/status.h"
+#include "onnx/defs/attr_proto_util.h"
+#include "onnx/defs/parser.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/tensor_proto_util.h"
+
+namespace ONNX_NAMESPACE {
+// Helper function to expand a function node given the function proto
+ONNX_API void FunctionExpandHelper(
+    const NodeProto& node,
+    const FunctionProto& func,
+    GraphProto& g,
+    const std::string& node_prefix = "");
+
+class FunctionBodyHelper {
+ public:
+  struct AttributeProtoWrapper {
+    AttributeProto proto;
+
+    AttributeProtoWrapper() = default;
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    AttributeProtoWrapper(AttributeProto attr_prot) : proto(std::move(attr_prot)) {}
+
+    template <typename T>
+    AttributeProtoWrapper(const std::string& attr_name, const T& value) : proto(MakeAttribute(attr_name, value)) {}
+  };
+
+  struct NodeDef {
+    NodeDef(
+        std::vector<std::string> outputs,
+        std::string op_type,
+        std::vector<std::string> inputs,
+        std::vector<AttributeProtoWrapper> attributes = {},
+        std::string domain = "")
+        : outputs(std::move(outputs)),
+          op_type(std::move(op_type)),
+          inputs(std::move(inputs)),
+          attributes(std::move(attributes)),
+          domain(std::move(domain)) {}
+
+    std::vector<std::string> outputs;
+    std::string op_type;
+    std::vector<std::string> inputs;
+    std::vector<AttributeProtoWrapper> attributes;
+    std::string domain;
+  };
+
+  /*
+  BuildNodes() is an utility function for easily define a Function Body.
+
+  To build a simple node:
+    {{"Z"}, "Add", {"X", "Y"}} represents Z = Add(X,Y)
+
+  To build a node with attribute:
+    {{"Y"}, "Concat", {"X1", "X2", "X3"}, {{"axis", 1}}}
+      represents Y = Concat(X1,X2,X3) with axis = 1
+    The attribute type are inferred from the attribute value's c++ type
+    Supported value types are
+      int64_t -> int, vector<int64_t> -> ints
+      float -> float, vector<float> -> floats
+      string -> string, vector<string> ->strings
+    For referring an attribute from parent, use:
+      {MakeRefAttribute("axes", AttributeProto::INTS)}}
+
+  To build a node which belongs to a domain other than onnx standard domain:
+    {{"Z"}, "Foo", {"X", "Y"}, "customdomain"} represents Z = customdomain.Foo(X,Y)
+    or
+    {{"Y"}, "Bar", {"X1", "X2", "X3"}, {{"axis", 1}}, "customdomain"}
+      represents Y = customdomain.Bar(X1,X2,X3) with axis = 1
+
+  For more examples, please find the references of this function
+  */
+  ONNX_API static std::vector<NodeProto> BuildNodes(const std::vector<NodeDef>& node_defs);
+
+  ONNX_API static void BuildNodes(FunctionProto& functionProto, const std::vector<NodeDef>& node_defs);
+
+  ONNX_API static bool BuildFunctionProto(
+      FunctionProto& functionProto,
+      const OpSchema& schema,
+      const std::vector<NodeDef>& node_defs,
+      const std::vector<OperatorSetIdProto>& relied_opsets);
+
+  template <typename T>
+  ONNX_API static NodeDef Const(const std::string& name, const T& value) {
+    return NodeDef{{name}, "Constant", {}, {{"value", ToTensor<T>(value)}}};
+  }
+
+  template <typename T>
+  ONNX_API static NodeDef Const(const std::string& name, const std::vector<T>& values) {
+    return NodeDef{{name}, "Constant", {}, {{"value", ToTensor<T>(values)}}};
+  }
+};
+
+class FunctionBuilder {
+ public:
+  explicit FunctionBuilder(FunctionProto& funProto_) : funProto(funProto_) {}
+
+  ONNX_API FunctionBuilder& Add(const char* nodes_txt) {
+    OnnxParser parser(nodes_txt);
+    auto& nodes = *funProto.mutable_node();
+
+    while (!parser.EndOfInput()) {
+      auto status = parser.Parse(*nodes.Add());
+      if (!status.IsOK())
+        ONNX_THROW_EX(std::logic_error("Error parsing node:" + status.ErrorMessage()));
+    }
+
+    return *this;
+  }
+
+  ONNX_API FunctionBuilder& Add(const char* node_txt, const AttributeProto& attr) {
+    OnnxParser parser(node_txt);
+    auto& node = *funProto.add_node();
+    auto status = parser.Parse(node);
+    if (!status.IsOK()) {
+      ONNX_THROW_EX(std::logic_error("Error parsing node:" + status.ErrorMessage()));
+    }
+
+    if (!parser.EndOfInput()) {
+      ONNX_THROW_EX(std::logic_error("Error unexpected extra input in node:" + status.ErrorMessage()));
+    }
+
+    *node.add_attribute() = attr;
+
+    return *this;
+  }
+
+  template <typename T>
+  ONNX_API FunctionBuilder& Add(const char* node_txt, const std::string& attr_name, const T& attr_value) {
+    return Add(node_txt, MakeAttribute(attr_name, attr_value));
+  }
+
+  template <typename T>
+  ONNX_API FunctionBuilder& AddAttributeToNode(const std::string& attr_name, const T& attr_value) {
+    auto& nodes = *funProto.mutable_node();
+    int nodes_size = nodes.size();
+    if (nodes_size != 0) {
+      auto& node = *funProto.mutable_node(nodes_size - 1);
+      *node.add_attribute() = MakeAttribute(attr_name, attr_value);
+    } else {
+      ONNX_THROW_EX(std::logic_error("Error adding attribute to node of a graph with no nodes"));
+    }
+    return *this;
+  }
+
+  template <typename T, typename... Args>
+  ONNX_API FunctionBuilder& AddAttributes(const std::string& attr_name, const T& attr_value, Args... args) {
+    AddAttributeToNode(attr_name, attr_value);
+    if constexpr (sizeof...(args) > 0) {
+      AddAttributes(args...);
+    }
+    return *this;
+  }
+
+  // Adds variable number of attributes to a node
+  template <typename... Args>
+  ONNX_API FunctionBuilder& Add(const char* node_txt, const Args&... args) {
+    Add(node_txt);
+    if constexpr (sizeof...(args) % 2 == 0) {
+      AddAttributes(args...);
+    }
+    return *this;
+  }
+
+  ONNX_API FunctionBuilder& Const(const std::string& name, const TensorProto& tensor) {
+    std::string constant_op(name);
+    constant_op += " = Constant()";
+    return Add(constant_op.c_str(), MakeAttribute("value", tensor));
+  }
+
+  // Creates a scalar constant (a tensor of rank zero).
+  template <typename T>
+  ONNX_API FunctionBuilder& Const(const std::string& name, T const_value) {
+    std::string constant_op(name);
+    constant_op += " = Constant()";
+    return Add(constant_op.c_str(), MakeAttribute("value", ToTensor(const_value)));
+  }
+
+  // Creates a 1D tensor constant consisting of a single value.
+  template <typename T>
+  ONNX_API FunctionBuilder& Const1D(const std::string& name, T const_value) {
+    std::string constant_op(name);
+    constant_op += " = Constant()";
+    auto tensor = ToTensor(const_value);
+    tensor.add_dims(1);
+    return Add(constant_op.c_str(), MakeAttribute("value", tensor));
+  }
+
+  // Creates a 1D tensor constant consisting of zero or more values.
+  template <typename T>
+  ONNX_API FunctionBuilder& Const(const std::string& name, const std::vector<T>& values) {
+    std::string constant_op(name);
+    constant_op += " = Constant()";
+    auto tensor = ToTensor(values);
+    tensor.add_dims(values.size()); // Treat as 1D tensor.
+
+    return Add(constant_op.c_str(), MakeAttribute("value", tensor));
+  }
+
+  ONNX_API FunctionBuilder& AddOpset(const char* domain, int version) {
+    auto* opset = funProto.add_opset_import();
+    opset->set_domain(domain);
+    opset->set_version(version);
+    return *this;
+  }
+
+  /**
+   * @brief Adds an inlined call to a graph as a sequence of nodes in the function.
+   *
+   * This method effectively inlines the logic from the given graph into the function
+   * being constructed. It:
+   * - Adds a Constant node for every initializer in the graph
+   * - Adds a copy of every node in the graph
+   * - Renames formal input parameters to match actual inputs
+   * - Renames formal output parameters to match actual outputs
+   * - Renames all other intermediate values with a unique prefix
+   * - Leaves references to undefined names (outer scope variables) unchanged
+   *
+   * @param outputs List of output variable names for the inlined call
+   * @param graph The graph to inline
+   * @param inputs List of input variable names for the inlined call
+   * @param prefix Prefix to add to intermediate variable names for uniqueness
+   * @return Reference to this FunctionBuilder for method chaining
+   */
+  ONNX_API FunctionBuilder& AddInlinedCall(
+      std::initializer_list<std::string_view> outputs,
+      const GraphProto& graph,
+      std::initializer_list<std::string_view> inputs,
+      std::string_view prefix);
+
+ private:
+  FunctionProto& funProto;
+};
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/gen_doc.py b/onnx/defs/gen_doc.py
new file mode 100644
index 0000000..6095499
--- /dev/null
+++ b/onnx/defs/gen_doc.py
@@ -0,0 +1,440 @@
+#!/usr/bin/env python
+
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+import numpy as np
+
+from onnx import defs, helper
+from onnx.backend.sample.ops import collect_sample_implementations
+from onnx.backend.test.case import collect_snippets
+from onnx.defs import ONNX_ML_DOMAIN, OpSchema
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+SNIPPETS = collect_snippets()
+SAMPLE_IMPLEMENTATIONS = collect_sample_implementations()
+ONNX_ML = not bool(os.getenv("ONNX_ML") == "0")
+
+
+def display_number(v: int) -> str:
+    if defs.OpSchema.is_infinite(v):
+        return "&#8734;"
+    return str(v)
+
+
+def should_render_domain(domain: str, output: str) -> bool:
+    is_ml = "-ml" in output
+    if domain == ONNX_ML_DOMAIN:
+        return is_ml
+    return not is_ml
+
+
+def format_name_with_domain(domain: str, schema_name: str) -> str:
+    if domain:
+        return f"{domain}.{schema_name}"
+    return schema_name
+
+
+def format_function_versions(function_versions: Sequence[int]) -> str:
+    return f"{', '.join([str(v) for v in function_versions])}"
+
+
+def format_versions(versions: Sequence[OpSchema], changelog: str) -> str:
+    return f"{', '.join(display_version_link(format_name_with_domain(v.domain, v.name), v.since_version, changelog) for v in versions[::-1])}"
+
+
+def display_attr_type(v: OpSchema.AttrType) -> str:
+    assert isinstance(v, OpSchema.AttrType)
+    s = str(v)
+    s = s[s.rfind(".") + 1 :].lower()
+    if s[-1] == "s":
+        s = "list of " + s
+    return s
+
+
+def display_domain(domain: str) -> str:
+    if domain:
+        return f"the '{domain}' operator set"
+    return "the default ONNX operator set"
+
+
+def display_domain_short(domain: str) -> str:
+    if domain:
+        return domain
+    return "ai.onnx (default)"
+
+
+def display_version_link(name: str, version: int, changelog: str) -> str:
+    name_with_ver = f"{name}-{version}"
+    return f'<a href="{changelog}#{name_with_ver}">{version}</a>'
+
+
+def generate_formal_parameter_tags(formal_parameter: OpSchema.FormalParameter) -> str:
+    tags: list[str] = []
+    if OpSchema.FormalParameterOption.Optional == formal_parameter.option:
+        tags = ["optional"]
+    elif OpSchema.FormalParameterOption.Variadic == formal_parameter.option:
+        if formal_parameter.is_homogeneous:
+            tags = ["variadic"]
+        else:
+            tags = ["variadic", "heterogeneous"]
+    differentiable: OpSchema.DifferentiationCategory = (
+        OpSchema.DifferentiationCategory.Differentiable
+    )
+    non_differentiable: OpSchema.DifferentiationCategory = (
+        OpSchema.DifferentiationCategory.NonDifferentiable
+    )
+    if differentiable == formal_parameter.differentiation_category:
+        tags.append("differentiable")
+    elif non_differentiable == formal_parameter.differentiation_category:
+        tags.append("non-differentiable")
+
+    return "" if len(tags) == 0 else " (" + ", ".join(tags) + ")"
+
+
+def display_schema(
+    schema: OpSchema, versions: Sequence[OpSchema], changelog: str
+) -> str:
+    s = ""
+
+    # doc
+    if schema.doc:
+        s += "\n"
+        s += "\n".join(
+            ("  " + line).rstrip() for line in schema.doc.lstrip().splitlines()
+        )
+        s += "\n"
+
+    # since version
+    s += "\n#### Version\n"
+    if schema.support_level == OpSchema.SupportType.EXPERIMENTAL:
+        s += "\nNo versioning maintained for experimental ops."
+    else:
+        s += (
+            "\nThis version of the operator has been "
+            + ("deprecated" if schema.deprecated else "available")
+            + f" since version {schema.since_version}"
+        )
+        s += f" of {display_domain(schema.domain)}.\n"
+        if len(versions) > 1:
+            # TODO: link to the Changelog.md
+            s += "\nOther versions of this operator: {}\n".format(
+                ", ".join(
+                    display_version_link(
+                        format_name_with_domain(v.domain, v.name),
+                        v.since_version,
+                        changelog,
+                    )
+                    for v in versions[:-1]
+                )
+            )
+
+    # If this schema is deprecated, don't display any of the following sections
+    if schema.deprecated:
+        return s
+
+    # attributes
+    if schema.attributes:
+        s += "\n#### Attributes\n\n"
+        s += "<dl>\n"
+        for _, attr in sorted(schema.attributes.items()):
+            # option holds either required or default value
+            opt = ""
+            if attr.required:
+                opt = "required"
+            elif attr.default_value.name:
+                default_value = helper.get_attribute_value(attr.default_value)
+                doc_string = attr.default_value.doc_string
+
+                def format_value(value: Any) -> str:
+                    if isinstance(value, float):
+                        formatted = str(np.round(value, 5))
+                        # use default formatting, unless too long.
+                        if len(formatted) > 10:  # noqa: PLR2004
+                            formatted = str(f"({value:e})")
+                        return formatted
+                    if isinstance(value, (bytes, bytearray)):
+                        return str(value.decode("utf-8"))
+                    return str(value)
+
+                if isinstance(default_value, list):
+                    default_value = [format_value(val) for val in default_value]
+                else:
+                    default_value = format_value(default_value)
+                opt = f"default is {default_value}{doc_string}"
+
+            s += f"<dt><tt>{attr.name}</tt> : {display_attr_type(attr.type)}{f' ({opt})' if opt else ''}</dt>\n"
+            s += f"<dd>{attr.description}</dd>\n"
+        s += "</dl>\n"
+
+    # inputs
+    s += "\n#### Inputs"
+    if schema.min_input != schema.max_input:
+        s += f" ({display_number(schema.min_input)} - {display_number(schema.max_input)})"
+    s += "\n\n"
+    if schema.inputs:
+        s += "<dl>\n"
+        for input_ in schema.inputs:
+            option_str = generate_formal_parameter_tags(input_)
+            s += f"<dt><tt>{input_.name}</tt>{option_str} : {input_.type_str}</dt>\n"
+            s += f"<dd>{input_.description}</dd>\n"
+        s += "</dl>\n"
+
+    # outputs
+    s += "\n#### Outputs"
+    if schema.min_output != schema.max_output:
+        s += f" ({display_number(schema.min_output)} - {display_number(schema.max_output)})"
+    s += "\n\n"
+
+    if schema.outputs:
+        s += "<dl>\n"
+        for output in schema.outputs:
+            option_str = generate_formal_parameter_tags(output)
+            s += f"<dt><tt>{output.name}</tt>{option_str} : {output.type_str}</dt>\n"
+            s += f"<dd>{output.description}</dd>\n"
+        s += "</dl>\n"
+
+    # type constraints
+    s += "\n#### Type Constraints"
+    s += "\n\n"
+    if schema.type_constraints:
+        s += "<dl>\n"
+        for type_constraint in schema.type_constraints:
+            allowedTypes = type_constraint.allowed_type_strs
+            if len(allowedTypes) > 0:
+                allowedTypeStr = allowedTypes[0]
+            for allowedType in allowedTypes[1:]:
+                allowedTypeStr += ", " + allowedType
+            s += f"<dt><tt>{type_constraint.type_param_str}</tt> : {allowedTypeStr}</dt>\n"
+            s += f"<dd>{type_constraint.description}</dd>\n"
+        s += "</dl>\n"
+
+    # Function Body
+    # TODO: this should be refactored to show the function body graph's picture (DAG).
+    # if schema.has_function or schema.has_context_dependent_function:  # type: ignore[attr-defined]
+    #    s += '\n#### Function\n'
+    #    s += '\nThe Function can be represented as a function.\n'
+
+    return s
+
+
+def support_level_str(level: OpSchema.SupportType) -> str:
+    return (
+        "<sub>experimental</sub> " if level == OpSchema.SupportType.EXPERIMENTAL else ""
+    )
+
+
+class Args(NamedTuple):
+    output: str
+    changelog: str
+
+
+def main(args: Args) -> None:
+    base_dir = os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    )
+    docs_dir = os.path.join(base_dir, "docs")
+
+    with open(
+        os.path.join(docs_dir, args.changelog), "w", newline="", encoding="utf-8"
+    ) as fout:
+        # REUSE-IgnoreStart
+        # This source file intentionally writes an SPDX header into the generated
+        # output file. The literal string would confuse the REUSE linter when
+        # scanning this source file; ignore this region for REUSE.
+        fout.write("<!--- SPDX-License-Identifier: Apache-2.0 -->\n")
+        # REUSE-IgnoreEnd
+        fout.write("## Operator Changelog\n")
+        fout.write(
+            "*This file is automatically generated from the\n"
+            "            [def files](/onnx/defs) via [this script](/onnx/defs/gen_doc.py).\n"
+            "            Do not modify directly and instead edit operator definitions.*\n"
+            "\n"
+            "For an operator input/output's differentiability, it can be differentiable,\n"
+            "            non-differentiable, or undefined. If a variable's differentiability\n"
+            "            is not specified, that variable has undefined differentiability.\n"
+        )
+
+        # domain -> version -> [schema]
+        dv_index: dict[str, dict[int, list[OpSchema]]] = defaultdict(
+            lambda: defaultdict(list)
+        )
+        for schema in defs.get_all_schemas_with_history():
+            dv_index[schema.domain][schema.since_version].append(schema)
+
+        fout.write("\n")
+
+        for domain, versionmap in sorted(dv_index.items()):
+            if not should_render_domain(domain, args.output):
+                continue
+
+            s = f"# {display_domain_short(domain)}\n"
+
+            for version, unsorted_schemas in sorted(versionmap.items()):
+                s += f"## Version {version} of {display_domain(domain)}\n"
+                for schema in sorted(unsorted_schemas, key=lambda s: s.name):
+                    name_with_ver = f"{format_name_with_domain(domain, schema.name)}-{schema.since_version}"
+                    s += (
+                        '### <a name="{}"></a>**{}**'
+                        + (" (deprecated)" if schema.deprecated else "")
+                        + "</a>\n"
+                    ).format(name_with_ver, name_with_ver)
+                    s += display_schema(schema, [schema], args.changelog)
+                    s += "\n"
+
+            fout.write(s)
+
+    with open(
+        os.path.join(docs_dir, args.output), "w", newline="", encoding="utf-8"
+    ) as fout:
+        # REUSE-IgnoreStart
+        # This source file intentionally writes an SPDX header into the generated
+        # output file. The literal string would confuse the REUSE linter when
+        # scanning this source file; ignore this region for REUSE.
+        fout.write("<!--- SPDX-License-Identifier: Apache-2.0 -->\n")
+        # REUSE-IgnoreEnd
+        fout.write("## Operator Schemas\n")
+        fout.write(
+            "*This file is automatically generated from the\n"
+            "            [def files](/onnx/defs) via [this script](/onnx/defs/gen_doc.py).\n"
+            "            Do not modify directly and instead edit operator definitions.*\n"
+            "\n"
+            "For an operator input/output's differentiability, it can be differentiable,\n"
+            "            non-differentiable, or undefined. If a variable's differentiability\n"
+            "            is not specified, that variable has undefined differentiability.\n"
+        )
+
+        # domain -> support level -> name -> [schema]
+        index: dict[str, dict[int, dict[str, list[OpSchema]]]] = defaultdict(
+            lambda: defaultdict(lambda: defaultdict(list))
+        )
+        for schema in defs.get_all_schemas_with_history():
+            index[schema.domain][int(schema.support_level)][schema.name].append(schema)
+
+        fout.write("\n")
+
+        # Preprocess the Operator Schemas
+        # [(domain, [(support_level, [(schema name, current schema, all versions schemas)])])]
+        operator_schemas: list[
+            tuple[str, list[tuple[int, list[tuple[str, OpSchema, list[OpSchema]]]]]]
+        ] = []
+        existing_ops: set[str] = set()
+        for domain, _supportmap in sorted(index.items()):
+            if not should_render_domain(domain, args.output):
+                continue
+
+            processed_supportmap = []
+            for _support, _namemap in sorted(_supportmap.items()):
+                processed_namemap = []
+                for n, unsorted_versions in sorted(_namemap.items()):
+                    versions = sorted(unsorted_versions, key=lambda s: s.since_version)
+                    schema = versions[-1]
+                    if schema.name in existing_ops:
+                        continue
+                    existing_ops.add(schema.name)
+                    processed_namemap.append((n, schema, versions))
+                processed_supportmap.append((_support, processed_namemap))
+            operator_schemas.append((domain, processed_supportmap))
+
+        # Table of contents
+        for domain, supportmap in operator_schemas:
+            s = f"### {display_domain_short(domain)}\n"
+            fout.write(s)
+
+            fout.write("|**Operator**|**Since version**||\n")
+            fout.write("|-|-|-|\n")
+
+            function_ops = []
+            for _, namemap in supportmap:
+                for n, schema, versions in namemap:
+                    if schema.has_function or schema.has_context_dependent_function:  # type: ignore[attr-defined]
+                        function_versions = schema.all_function_opset_versions  # type: ignore[attr-defined]
+                        function_ops.append((n, schema, versions, function_versions))
+                        continue
+                    s = '|{}<a href="#{}">{}</a>{}|{}|\n'.format(
+                        support_level_str(schema.support_level),
+                        format_name_with_domain(domain, n),
+                        format_name_with_domain(domain, n),
+                        " (deprecated)" if schema.deprecated else "",
+                        format_versions(versions, args.changelog),
+                    )
+                    fout.write(s)
+            if function_ops:
+                fout.write("|**Function**|**Since version**|**Function version**|\n")
+                for n, schema, versions, function_versions in function_ops:
+                    s = '|{}<a href="#{}">{}</a>|{}|{}|\n'.format(  # noqa: UP032
+                        support_level_str(schema.support_level),
+                        format_name_with_domain(domain, n),
+                        format_name_with_domain(domain, n),
+                        format_versions(versions, args.changelog),
+                        format_function_versions(function_versions),
+                    )
+                    fout.write(s)
+
+            fout.write("\n")
+
+        fout.write("\n")
+
+        for domain, supportmap in operator_schemas:
+            s = f"## {display_domain_short(domain)}\n"
+            fout.write(s)
+
+            for _, namemap in supportmap:
+                for op_type, schema, versions in namemap:
+                    # op_type
+                    s = (
+                        '### {}<a name="{}"></a><a name="{}">**{}**'
+                        + (" (deprecated)" if schema.deprecated else "")
+                        + "</a>\n"
+                    ).format(
+                        support_level_str(schema.support_level),
+                        format_name_with_domain(domain, op_type),
+                        format_name_with_domain(domain, op_type.lower()),
+                        format_name_with_domain(domain, op_type),
+                    )
+
+                    s += display_schema(schema, versions, args.changelog)
+
+                    s += "\n\n"
+
+                    if op_type in SNIPPETS:
+                        s += "#### Examples\n\n"
+                        for summary, code in sorted(SNIPPETS[op_type]):
+                            s += "<details>\n"
+                            s += f"<summary>{summary}</summary>\n\n"
+                            s += f"```python\n{code}\n```\n\n"
+                            s += "</details>\n"
+                            s += "\n\n"
+                    if op_type.lower() in SAMPLE_IMPLEMENTATIONS:
+                        s += "#### Sample Implementation\n\n"
+                        s += "<details>\n"
+                        s += f"<summary>{op_type}</summary>\n\n"
+                        s += f"```python\n{SAMPLE_IMPLEMENTATIONS[op_type.lower()]}\n```\n\n"
+                        s += "</details>\n"
+                        s += "\n\n"
+
+                    fout.write(s)
+
+
+if __name__ == "__main__":
+    if ONNX_ML:
+        main(
+            Args(
+                "Operators-ml.md",
+                "Changelog-ml.md",
+            )
+        )
+    main(
+        Args(
+            "Operators.md",
+            "Changelog.md",
+        )
+    )
diff --git a/onnx/defs/gen_shape_inference_information.py b/onnx/defs/gen_shape_inference_information.py
new file mode 100644
index 0000000..41ea793
--- /dev/null
+++ b/onnx/defs/gen_shape_inference_information.py
@@ -0,0 +1,31 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx import defs
+
+
+def main() -> None:
+    # domain -> support level -> name -> [schema]
+    with_inference = []
+    without_inference = []
+    for schema in defs.get_all_schemas():
+        domain, name, has_inference = (
+            schema.domain,
+            schema.name,
+            schema.has_type_and_shape_inference_function,
+        )
+        elem = (domain, name)
+        if has_inference:
+            with_inference.append(elem)
+        else:
+            without_inference.append(elem)
+    print(len(with_inference), "operators have a type/shape inference function.")
+    print(len(without_inference), "do not. These are:")
+    for domain, name in sorted(without_inference):
+        print(domain, name)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/defs/generator/CMakeLists.txt b/onnx/defs/generator/CMakeLists.txt
new file mode 100644
index 0000000..0011f05
--- /dev/null
+++ b/onnx/defs/generator/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+    utils.cc
+    utils.h
+)
diff --git a/onnx/defs/generator/defs.cc b/onnx/defs/generator/defs.cc
new file mode 100644
index 0000000..4272b7b
--- /dev/null
+++ b/onnx/defs/generator/defs.cc
@@ -0,0 +1,510 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <cmath>
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/generator/utils.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_Constant_ver24)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Attr(
+            "value_int",
+            "The value for the sole element for the scalar, int64, output tensor.",
+            AttributeProto::INT,
+            false)
+        .Attr(
+            "value_ints",
+            "The values for the elements for the 1D, int64, output tensor.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "value_float",
+            "The value for the sole element for the scalar, float32, output tensor.",
+            AttributeProto::FLOAT,
+            false)
+        .Attr(
+            "value_floats",
+            "The values for the elements for the 1D, float32, output tensor.",
+            AttributeProto::FLOATS,
+            false)
+        .Attr(
+            "value_string",
+            "The value for the sole element for the scalar, UTF-8 string, output tensor.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "value_strings",
+            "The values for the elements for the 1D, UTF-8 string, output tensor.",
+            AttributeProto::STRINGS,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir13(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(ConstantOpInference));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ConstantOfShape,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_ConstantOfShape_ver24)
+        .Attr(
+            "value",
+            "(Optional) The value of the output elements."
+            "Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Input(
+            0,
+            "input",
+            "1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar."
+            " All values must be >= 0.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor of shape specified by 'input'."
+            "If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'."
+            "If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype "
+            "defaults to float32.",
+            "T2")
+        .TypeConstraint("T1", {types::Int64}, "Constrain input types.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,      types::Float,          types::Double,     types::Int8,           types::Int16,
+             types::Int32,        types::Int64,          types::UInt8,      types::UInt16,         types::UInt32,
+             types::UInt64,       types::UInt4,          types::Int4,       types::Bool,           types::BFloat16,
+             types::Float8E4M3FN, types::Float8E4M3FNUZ, types::Float8E5M2, types::Float8E5M2FNUZ, types::Float4E2M1,
+             types::Float8E8M0,   types::UInt2,          types::Int2},
+            "Constrain output types to be numerics or boolean.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("value") != nullptr) {
+            propagateElemTypeFromDtypeToOutput(ctx, ctx.getAttribute("value"), 0);
+          } else {
+            propagateElemTypeFromDtypeToOutput(ctx, TensorProto::FLOAT, 0);
+          }
+
+          bool found = false;
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
+          if (found) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    EyeLike,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_EyeLike_ver9)
+        .Attr(
+            "k",
+            "(Optional) Index of the diagonal to be populated with ones. Default is 0."
+            " If T2 is the output, this op sets T2[i, i+k] = 1. k = 0 populates the main diagonal, "
+            "k > 0 populates an upper diagonal,  and k < 0 populates a lower diagonal.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "dtype",
+            "(Optional) The data type for the elements of the output tensor. If not specified,"
+            " the data type of the input tensor T1 is used.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "2D input tensor to copy shape, and optionally, type information from.", "T1")
+        .Output(0, "output", "Output tensor, same shape as input tensor T1.", "T2")
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_non_complex_numeric_types_plus_bool_ir4(),
+            "Constrain input types. Strings and complex are not supported.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_complex_numeric_types_plus_bool_ir4(),
+            "Constrain output types. Strings and complex are not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("dtype") != nullptr) {
+            propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0);
+          } else {
+            propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          }
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() != 2) {
+              fail_shape_inference("Input tensor must be 2-dimensional");
+            }
+          }
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RandomUniform,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_RandomUniform_ver1)
+        .Attr("low", "Lower boundary of the output values.", AttributeProto::FLOAT, 0.0f)
+        .Attr("high", "Upper boundary of the output values.", AttributeProto::FLOAT, 1.0f)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "The data type for the elements of the output tensor. If not specified, default is TensorProto::FLOAT.",
+            AttributeProto::INT,
+            static_cast<int64_t>(TensorProto::FLOAT))
+        .Attr("shape", "The shape of the output tensor.", AttributeProto::INTS)
+        .Output(0, "output", "Output tensor of random values drawn from uniform distribution", "T")
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0, TensorProto::FLOAT);
+          propagateShapeFromAttributeToOutput(ctx, "shape", 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RandomNormal,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_RandomNormal_ver1)
+        .Attr("mean", "The mean of the normal distribution.", AttributeProto::FLOAT, 0.0f)
+        .Attr("scale", "The standard deviation of the normal distribution.", AttributeProto::FLOAT, 1.0f)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "The data type for the elements of the output tensor. Default is TensorProto::FLOAT.",
+            AttributeProto::INT,
+            static_cast<int64_t>(TensorProto::FLOAT))
+        .Attr("shape", "The shape of the output tensor.", AttributeProto::INTS)
+        .Output(0, "output", "Output tensor of random values drawn from normal distribution", "T")
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0, TensorProto::FLOAT);
+          propagateShapeFromAttributeToOutput(ctx, "shape", 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RandomUniformLike,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_RandomUniformLike_ver1)
+        .Attr("low", "Lower boundary of the output values.", AttributeProto::FLOAT, 0.0f)
+        .Attr("high", "Upper boundary of the output values.", AttributeProto::FLOAT, 1.0f)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "(Optional) The data type for the elements of the output tensor, if not specified, we will use "
+            "the data type of the input tensor.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "Input tensor to copy shape and optionally type information from.", "T1")
+        .Output(0, "output", "Output tensor of random values drawn from uniform distribution", "T2")
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types_ir4(),
+            "Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.")
+        .TypeConstraint("T2", OpSchema::all_float_types_ir4(), "Constrain output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("dtype") != nullptr)
+            propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0);
+          else
+            propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RandomNormalLike,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_RandomNormalLike_ver1)
+        .Attr("mean", "The mean of the normal distribution.", AttributeProto::FLOAT, 0.0f)
+        .Attr("scale", "The standard deviation of the normal distribution.", AttributeProto::FLOAT, 1.0f)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "(Optional) The data type for the elements of the output tensor, if not specified, we will use "
+            "the data type of the input tensor.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "Input tensor to copy shape and optionally type information from.", "T1")
+        .Output(0, "output", "Output tensor of random values drawn from normal distribution", "T2")
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types_ir4(),
+            "Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.")
+        .TypeConstraint("T2", OpSchema::all_float_types_ir4(), "Constrain output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("dtype") != nullptr)
+            propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0);
+          else
+            propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Multinomial,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_Multinomial_ver7)
+        .Attr("sample_size", "Number of times to sample.", AttributeProto::INT, static_cast<int64_t>(1))
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "(Optional) The data type for the elements of the output tensor, if not specified, we will use int32.",
+            AttributeProto::INT,
+            static_cast<int64_t>(TensorProto::INT32))
+        .Input(
+            0,
+            "input",
+            "Input tensor with shape [batch_size, class_size], where class_size is the number of all possible outcomes. Each value along the axis zero represents the unnormalized log-probability of each corresponding outcome in a batch.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor with shape [batch_size, sample_size], where sample_size is the number of times to sample. Each value along the axis zero represents the outcome of the corresponding sample in a batch.",
+            "T2")
+        .TypeConstraint("T1", OpSchema::all_float_types_ir4(), "Constrain input types to float tensors.")
+        .TypeConstraint("T2", {types::Int32, types::Int64}, "Constrain output types to integral tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto dtype = ctx.getAttribute("dtype");
+          auto dataType = TensorProto_DataType::TensorProto_DataType_INT32;
+          if (dtype != nullptr) {
+            dataType = static_cast<TensorProto_DataType>(dtype->i());
+            if (dataType != TensorProto_DataType::TensorProto_DataType_INT32 &&
+                dataType != TensorProto_DataType::TensorProto_DataType_INT64) {
+              fail_type_inference("Output type must be int32 or int64");
+            }
+          }
+          updateOutputElemType(ctx, 0, dataType);
+
+          TensorShapeProto::Dimension batch_size, sample_size;
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() != 2) {
+              fail_shape_inference("Input tensor must have rank 2");
+            }
+            batch_size = input_shape.dim(0);
+          } // else statically-unknown batch-size
+          sample_size.set_dim_value(getAttribute(ctx, "sample_size", 1));
+          updateOutputShape(ctx, 0, {batch_size, sample_size});
+        }));
+
+static bool
+BuildFunctionBodyRange27(const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) {
+  if (ctx.getInputType(0) == nullptr) {
+    return false;
+  }
+  int64_t T = ctx.getInputType(0)->tensor_type().elem_type();
+  bool needs_stash =
+      (T == static_cast<int64_t>(TensorProto_DataType_FLOAT16) ||
+       T == static_cast<int64_t>(TensorProto_DataType_BFLOAT16));
+
+  int64_t stash_type = T;
+  if (needs_stash) {
+    const auto* stash_attr = ctx.getAttribute("stash_type");
+    stash_type = (stash_attr != nullptr) ? stash_attr->i() : static_cast<int64_t>(TensorProto_DataType_FLOAT);
+    if (stash_type != static_cast<int64_t>(TensorProto_DataType_FLOAT) &&
+        stash_type != static_cast<int64_t>(TensorProto_DataType_DOUBLE))
+      // return false so no inline function body is emitted; the model checker
+      // will catch the invalid attribute value during validation.
+      return false;
+  }
+
+  FunctionBuilder builder(functionProto);
+  if (needs_stash && stash_type != T) {
+    // Cast inputs to stash_type for higher-precision loop accumulation,
+    // then cast the collected output back to T.
+    builder.Add("start_s = Cast (start)", "to", stash_type)
+        .Add("limit_s = Cast (limit)", "to", stash_type)
+        .Add("delta_s = Cast (delta)", "to", stash_type)
+        .Add("sub_result = Sub (limit_s, start_s)")
+        .Add("div_result = Div (sub_result, delta_s)")
+        .Add("ceil_result = Ceil (div_result)")
+        .Add("ceil_relu = Relu (ceil_result)")
+        .Add("n = Cast (ceil_relu)", "to", static_cast<int64_t>(TensorProto_DataType_INT64))
+        .Add("loop_cond = Cast (ceil_relu)", "to", static_cast<int64_t>(TensorProto_DataType_BOOL))
+        .Add(R"ONNX(variadic_output, output_s = Loop (n, loop_cond, start_s)
+          <body = loop_body (int64 i, bool cond_in, prev) => (cond_out, current, range) {
+            cond_out = Identity (cond_in)
+            current = Add (prev, delta_s)
+            range = Identity (prev)
+          }>)ONNX")
+        .Add("output = Cast (output_s)", "to", T);
+  } else {
+    builder.Add("sub_result = Sub (limit, start)")
+        .Add("sub_result_casted = Cast (sub_result)", "to", static_cast<int64_t>(TensorProto_DataType_FLOAT))
+        .Add("delta_casted = Cast (delta)", "to", static_cast<int64_t>(TensorProto_DataType_FLOAT))
+        .Add("div_result = Div (sub_result_casted, delta_casted)")
+        .Add("ceil_result = Ceil (div_result)")
+        .Add("ceil_result_relu = Relu (ceil_result)")
+        .Add("ceil_result_relu_int = Cast (ceil_result_relu)", "to", static_cast<int64_t>(TensorProto_DataType_INT64))
+        .Add("ceil_result_relu_bool = Cast (ceil_result_relu)", "to", static_cast<int64_t>(TensorProto_DataType_BOOL))
+        .Add(R"ONNX(variadic_output, output = Loop (ceil_result_relu_int, ceil_result_relu_bool, start)
+          <body = loop_body_attribute (int64 i, bool cond, prev) => (cond_out, current, range) {
+            cond_out = Identity (cond)
+            current = Add (prev, delta)
+            range = Identity (prev)
+          }>)ONNX");
+  }
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Range,
+    27,
+    OpSchema()
+        .SetDoc(kDoc_Range_ver27)
+        .Attr(
+            "stash_type",
+            "The data type used for intermediate computation when T is float16 or bfloat16. "
+            "Defaults to 1 (float). Has no effect for other types.",
+            AttributeProto::INT,
+            static_cast<int64_t>(TensorProto_DataType_FLOAT))
+        .Input(0, "start", "Scalar. First entry for the range of output values.", "T")
+        .Input(1, "limit", "Scalar. Exclusive upper limit for the range of output values.", "T")
+        .Input(2, "delta", "Scalar. Value to step by.", "T")
+        .Output(0, "output", "A 1-D tensor with same type as the inputs containing generated range of values.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int16, types::Int32, types::Int64, types::Float16, types::BFloat16},
+            "Constrain input types to common numeric type tensors.")
+        .SetContextDependentFunctionBodyBuilder(BuildFunctionBodyRange27)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          const auto start_initializer = ctx.getInputData(0);
+          const auto limit_initializer = ctx.getInputData(1);
+          const auto delta_initializer = ctx.getInputData(2);
+
+          // Output is always 1-D
+          auto output_dim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+
+          // If any of Range's inputs are not initializers, the output dimension
+          // value would remain unknown.
+          if (start_initializer != nullptr && limit_initializer != nullptr && delta_initializer != nullptr) {
+            // Make sure the input types are homogeneous
+            if ((start_initializer->data_type() != limit_initializer->data_type()) ||
+                (start_initializer->data_type() != delta_initializer->data_type())) {
+              fail_shape_inference("All inputs to 'Range' op must be of the same type");
+            }
+
+            // Explicitly compute the output dimension if Range's inputs are
+            // stored in initializer list.
+            if (start_initializer->data_type() == TensorProto::FLOAT) {
+              output_dim->set_dim_value(
+                  compute_output_dim_for_range<float>(start_initializer, limit_initializer, delta_initializer));
+            } else if (start_initializer->data_type() == TensorProto::INT32) {
+              output_dim->set_dim_value(
+                  compute_output_dim_for_range<int32_t>(start_initializer, limit_initializer, delta_initializer));
+            } else if (start_initializer->data_type() == TensorProto::INT64) {
+              output_dim->set_dim_value(
+                  compute_output_dim_for_range<int64_t>(start_initializer, limit_initializer, delta_initializer));
+            } else if (start_initializer->data_type() == TensorProto::DOUBLE) {
+              output_dim->set_dim_value(
+                  compute_output_dim_for_range<double>(start_initializer, limit_initializer, delta_initializer));
+            } else {
+              // float16, bfloat16, int16, and other types without a native C++
+              // range-computation type — stop with rank inference, no action here
+            }
+
+            return;
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Bernoulli,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_Bernoulli_ver15)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "The data type for the elements of the output tensor. if not specified, we will use "
+            "the data type of the input tensor.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "All values in input have to be in the range:[0, 1].", "T1")
+        .Output(0, "output", "The returned output tensor only has values 0 or 1, same shape as input tensor.", "T2")
+        .TypeConstraint("T1", OpSchema::all_float_types_ir4(), "Constrain input types to float tensors.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_complex_numeric_types_plus_bool_ir4(),
+            "Constrain output types to all numeric tensors and bool tensors.")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          if (ctx.getAttribute("dtype") != nullptr)
+            propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0);
+          else
+            propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              if (ctx.getInputType(0) == nullptr) {
+                // we cannot create a correct function body without knowing the input type
+                return false;
+              }
+              auto input_type = ctx.getInputType(0)->tensor_type().elem_type();
+              auto dtype = ctx.getAttribute("dtype") != nullptr
+                  ? static_cast<TensorProto_DataType>(ctx.getAttribute("dtype")->i())
+                  : input_type;
+              FunctionBuilder builder(functionProto);
+              builder
+                  .Add(
+                      "X_random = RandomUniformLike <low = 0.0, high = 1.0, seed = @seed> (input)",
+                      "dtype",
+                      static_cast<int64_t>(input_type))
+                  .Add("X_greater = Greater (X_random, input)")
+                  .Add("output = Cast (X_greater)", "to", static_cast<int64_t>(dtype));
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/generator/old.cc b/onnx/defs/generator/old.cc
new file mode 100644
index 0000000..0d2c356
--- /dev/null
+++ b/onnx/defs/generator/old.cc
@@ -0,0 +1,1034 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/generator/utils.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Bernoulli,
+    15,
+    OpSchema()
+        .SetDoc(kDoc_Bernoulli_ver15)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "The data type for the elements of the output tensor. if not specified, we will use "
+            "the data type of the input tensor.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "All values in input have to be in the range:[0, 1].", "T1")
+        .Output(0, "output", "The returned output tensor only has values 0 or 1, same shape as input tensor.", "T2")
+        .TypeConstraint("T1", {types::Float16, types::Float, types::Double}, "Constrain input types to float tensors.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::BFloat16,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::Bool},
+            "Constrain output types to all numeric tensors and bool tensors.")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          if (ctx.getAttribute("dtype") != nullptr)
+            propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0);
+          else
+            propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              if (ctx.getInputType(0) == nullptr) {
+                // we cannot create a correct function body without knowing the input type
+                return false;
+              }
+              auto input_type = ctx.getInputType(0)->tensor_type().elem_type();
+              auto dtype = ctx.getAttribute("dtype") != nullptr
+                  ? static_cast<TensorProto_DataType>(ctx.getAttribute("dtype")->i())
+                  : input_type;
+              FunctionBuilder builder(functionProto);
+              builder
+                  .Add(
+                      "X_random = RandomUniformLike <low = 0.0, high = 1.0, seed = @seed> (input)", "dtype", input_type)
+                  .Add("X_greater = Greater (X_random, input)")
+                  .Add("output = Cast (X_greater)", "to", dtype);
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Multinomial,
+    7,
+    OpSchema()
+        .SetDoc(kDoc_Multinomial_ver7)
+        .Attr("sample_size", "Number of times to sample.", AttributeProto::INT, static_cast<int64_t>(1))
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "(Optional) The data type for the elements of the output tensor, if not specified, we will use int32.",
+            AttributeProto::INT,
+            static_cast<int64_t>(TensorProto::INT32))
+        .Input(
+            0,
+            "input",
+            "Input tensor with shape [batch_size, class_size], where class_size is the number of all possible outcomes. Each value along the axis zero represents the unnormalized log-probability of each corresponding outcome in a batch.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor with shape [batch_size, sample_size], where sample_size is the number of times to sample. Each value along the axis zero represents the outcome of the corresponding sample in a batch.",
+            "T2")
+        .TypeConstraint("T1", {types::Float16, types::Float, types::Double}, "Constrain input types to float tensors.")
+        .TypeConstraint("T2", {types::Int32, types::Int64}, "Constrain output types to integral tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto dtype = ctx.getAttribute("dtype");
+          auto dataType = TensorProto_DataType::TensorProto_DataType_INT32;
+          if (dtype != nullptr) {
+            dataType = static_cast<TensorProto_DataType>(dtype->i());
+            if (dataType != TensorProto_DataType::TensorProto_DataType_INT32 &&
+                dataType != TensorProto_DataType::TensorProto_DataType_INT64) {
+              fail_type_inference("Output type must be int32 or int64");
+            }
+          }
+          updateOutputElemType(ctx, 0, dataType);
+
+          TensorShapeProto::Dimension batch_size, sample_size;
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() != 2) {
+              fail_shape_inference("Input tensor must have rank 2");
+            }
+            batch_size = input_shape.dim(0);
+          } // else statically-unknown batch-size
+          sample_size.set_dim_value(getAttribute(ctx, "sample_size", 1));
+          updateOutputShape(ctx, 0, {batch_size, sample_size});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RandomNormalLike,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_RandomNormalLike_ver1)
+        .Attr("mean", "The mean of the normal distribution.", AttributeProto::FLOAT, 0.0f)
+        .Attr("scale", "The standard deviation of the normal distribution.", AttributeProto::FLOAT, 1.0f)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "(Optional) The data type for the elements of the output tensor, if not specified, we will use "
+            "the data type of the input tensor.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "Input tensor to copy shape and optionally type information from.", "T1")
+        .Output(0, "output", "Output tensor of random values drawn from normal distribution", "T2")
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types(),
+            "Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.")
+        .TypeConstraint("T2", {types::Float16, types::Float, types::Double}, "Constrain output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("dtype") != nullptr)
+            propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0);
+          else
+            propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RandomUniformLike,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_RandomUniformLike_ver1)
+        .Attr("low", "Lower boundary of the output values.", AttributeProto::FLOAT, 0.0f)
+        .Attr("high", "Upper boundary of the output values.", AttributeProto::FLOAT, 1.0f)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "(Optional) The data type for the elements of the output tensor, if not specified, we will use "
+            "the data type of the input tensor.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "Input tensor to copy shape and optionally type information from.", "T1")
+        .Output(0, "output", "Output tensor of random values drawn from uniform distribution", "T2")
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types(),
+            "Constrain to any tensor type. If the dtype attribute is not provided this must be a valid output type.")
+        .TypeConstraint("T2", {types::Float16, types::Float, types::Double}, "Constrain output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("dtype") != nullptr)
+            propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0);
+          else
+            propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RandomNormal,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_RandomNormal_ver1)
+        .Attr("mean", "The mean of the normal distribution.", AttributeProto::FLOAT, 0.0f)
+        .Attr("scale", "The standard deviation of the normal distribution.", AttributeProto::FLOAT, 1.0f)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "The data type for the elements of the output tensor. Default is TensorProto::FLOAT.",
+            AttributeProto::INT,
+            static_cast<int64_t>(TensorProto::FLOAT))
+        .Attr("shape", "The shape of the output tensor.", AttributeProto::INTS)
+        .Output(0, "output", "Output tensor of random values drawn from normal distribution", "T")
+        .TypeConstraint("T", {types::Float16, types::Float, types::Double}, "Constrain output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0, TensorProto::FLOAT);
+          propagateShapeFromAttributeToOutput(ctx, "shape", 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RandomUniform,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_RandomUniform_ver1)
+        .Attr("low", "Lower boundary of the output values.", AttributeProto::FLOAT, 0.0f)
+        .Attr("high", "Upper boundary of the output values.", AttributeProto::FLOAT, 1.0f)
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dtype",
+            "The data type for the elements of the output tensor. If not specified, default is TensorProto::FLOAT.",
+            AttributeProto::INT,
+            static_cast<int64_t>(TensorProto::FLOAT))
+        .Attr("shape", "The shape of the output tensor.", AttributeProto::INTS)
+        .Output(0, "output", "Output tensor of random values drawn from uniform distribution", "T")
+        .TypeConstraint("T", {types::Float16, types::Float, types::Double}, "Constrain output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0, TensorProto::FLOAT);
+          propagateShapeFromAttributeToOutput(ctx, "shape", 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    EyeLike,
+    9,
+    OpSchema()
+        .SetDoc(kDoc_EyeLike_ver9)
+        .Attr(
+            "k",
+            "(Optional) Index of the diagonal to be populated with ones. Default is 0."
+            " If T2 is the output, this op sets T2[i, i+k] = 1. k = 0 populates the main diagonal, "
+            "k > 0 populates an upper diagonal,  and k < 0 populates a lower diagonal.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "dtype",
+            "(Optional) The data type for the elements of the output tensor. If not specified,"
+            "the data type of the input tensor T1 is used. If input tensor T1 is also not"
+            "specified, then type defaults to 'float'.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "2D input tensor to copy shape, and optionally, type information from.", "T1")
+        .Output(0, "output", "Output tensor, same shape as input tensor T1.", "T2")
+        .TypeConstraint(
+            "T1",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool},
+            "Constrain input types. Strings and complex are not supported.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool},
+            "Constrain output types. Strings and complex are not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("dtype") != nullptr) {
+            propagateElemTypeFromAttributeToOutput(ctx, "dtype", 0);
+          } else {
+            propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          }
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() != 2) {
+              fail_shape_inference("Input tensor must be 2-dimensional");
+            }
+          }
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_Constant_ver24)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Attr(
+            "value_int",
+            "The value for the sole element for the scalar, int64, output tensor.",
+            AttributeProto::INT,
+            false)
+        .Attr(
+            "value_ints",
+            "The values for the elements for the 1D, int64, output tensor.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "value_float",
+            "The value for the sole element for the scalar, float32, output tensor.",
+            AttributeProto::FLOAT,
+            false)
+        .Attr(
+            "value_floats",
+            "The values for the elements for the 1D, float32, output tensor.",
+            AttributeProto::FLOATS,
+            false)
+        .Attr(
+            "value_string",
+            "The value for the sole element for the scalar, UTF-8 string, output tensor.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "value_strings",
+            "The values for the elements for the 1D, UTF-8 string, output tensor.",
+            AttributeProto::STRINGS,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir12(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(ConstantOpInference));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_Constant_ver24)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Attr(
+            "value_int",
+            "The value for the sole element for the scalar, int64, output tensor.",
+            AttributeProto::INT,
+            false)
+        .Attr(
+            "value_ints",
+            "The values for the elements for the 1D, int64, output tensor.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "value_float",
+            "The value for the sole element for the scalar, float32, output tensor.",
+            AttributeProto::FLOAT,
+            false)
+        .Attr(
+            "value_floats",
+            "The values for the elements for the 1D, float32, output tensor.",
+            AttributeProto::FLOATS,
+            false)
+        .Attr(
+            "value_string",
+            "The value for the sole element for the scalar, UTF-8 string, output tensor.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "value_strings",
+            "The values for the elements for the 1D, UTF-8 string, output tensor.",
+            AttributeProto::STRINGS,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir11(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(ConstantOpInference));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_Constant_ver24)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Attr(
+            "value_int",
+            "The value for the sole element for the scalar, int64, output tensor.",
+            AttributeProto::INT,
+            false)
+        .Attr(
+            "value_ints",
+            "The values for the elements for the 1D, int64, output tensor.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "value_float",
+            "The value for the sole element for the scalar, float32, output tensor.",
+            AttributeProto::FLOAT,
+            false)
+        .Attr(
+            "value_floats",
+            "The values for the elements for the 1D, float32, output tensor.",
+            AttributeProto::FLOATS,
+            false)
+        .Attr(
+            "value_string",
+            "The value for the sole element for the scalar, UTF-8 string, output tensor.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "value_strings",
+            "The values for the elements for the 1D, UTF-8 string, output tensor.",
+            AttributeProto::STRINGS,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir10(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(ConstantOpInference));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    19,
+    OpSchema()
+        .SetDoc(kDoc_Constant_ver24)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Attr(
+            "value_int",
+            "The value for the sole element for the scalar, int64, output tensor.",
+            AttributeProto::INT,
+            false)
+        .Attr(
+            "value_ints",
+            "The values for the elements for the 1D, int64, output tensor.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "value_float",
+            "The value for the sole element for the scalar, float32, output tensor.",
+            AttributeProto::FLOAT,
+            false)
+        .Attr(
+            "value_floats",
+            "The values for the elements for the 1D, float32, output tensor.",
+            AttributeProto::FLOATS,
+            false)
+        .Attr(
+            "value_string",
+            "The value for the sole element for the scalar, UTF-8 string, output tensor.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "value_strings",
+            "The values for the elements for the 1D, UTF-8 string, output tensor.",
+            AttributeProto::STRINGS,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir9(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(ConstantOpInference));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Constant_ver24)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Attr(
+            "value_int",
+            "The value for the sole element for the scalar, int64, output tensor.",
+            AttributeProto::INT,
+            false)
+        .Attr(
+            "value_ints",
+            "The values for the elements for the 1D, int64, output tensor.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "value_float",
+            "The value for the sole element for the scalar, float32, output tensor.",
+            AttributeProto::FLOAT,
+            false)
+        .Attr(
+            "value_floats",
+            "The values for the elements for the 1D, float32, output tensor.",
+            AttributeProto::FLOATS,
+            false)
+        .Attr(
+            "value_string",
+            "The value for the sole element for the scalar, UTF-8 string, output tensor.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "value_strings",
+            "The values for the elements for the 1D, UTF-8 string, output tensor.",
+            AttributeProto::STRINGS,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(ConstantOpInference));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    12,
+    OpSchema()
+        .SetDoc(kDoc_Constant_ver24)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Attr(
+            "value_int",
+            "The value for the sole element for the scalar, int64, output tensor.",
+            AttributeProto::INT,
+            false)
+        .Attr(
+            "value_ints",
+            "The values for the elements for the 1D, int64, output tensor.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "value_float",
+            "The value for the sole element for the scalar, float32, output tensor.",
+            AttributeProto::FLOAT,
+            false)
+        .Attr(
+            "value_floats",
+            "The values for the elements for the 1D, float32, output tensor.",
+            AttributeProto::FLOATS,
+            false)
+        .Attr(
+            "value_string",
+            "The value for the sole element for the scalar, UTF-8 string, output tensor.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "value_strings",
+            "The values for the elements for the 1D, UTF-8 string, output tensor.",
+            AttributeProto::STRINGS,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(ConstantOpInference));
+
+static constexpr const char* Constant_ver1_doc = R"DOC(A constant tensor.)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    1,
+    OpSchema()
+        .SetDoc(Constant_ver1_doc)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto attr_proto = ctx.getAttribute("value");
+          if (nullptr == attr_proto)
+            return; // attribute not present
+          if (!attr_proto->has_t())
+            return; // attribute has no tensor value
+          const TensorProto& tensor_proto = attr_proto->t();
+          updateOutputElemType(ctx, 0, tensor_proto.data_type());
+          updateOutputShape(ctx, 0, tensor_proto);
+        }));
+
+static const char* const Constant_ver9_doc = Constant_ver1_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    9,
+    OpSchema()
+        .SetDoc(Constant_ver9_doc)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto attr_proto = ctx.getAttribute("value");
+          if (nullptr == attr_proto || !attr_proto->has_t())
+            fail_shape_inference("Attribute 'value' of Constant node must exist with 'Tensor' data.");
+          const TensorProto& tensor_proto = attr_proto->t();
+          updateOutputElemType(ctx, 0, tensor_proto.data_type());
+          updateOutputShape(ctx, 0, tensor_proto);
+        }));
+
+static constexpr const char* Constant_ver11_doc = R"DOC(
+A constant tensor. Exactly one of the two attributes, either value or sparse_value,
+must be specified.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Constant,
+    11,
+    OpSchema()
+        .SetDoc(Constant_ver11_doc)
+        .Attr("value", "The value for the elements of the output tensor.", AttributeProto::TENSOR, false)
+        .Attr(
+            "sparse_value",
+            "The value for the elements of the output tensor in sparse format.",
+            AttributeProto::SPARSE_TENSOR,
+            false)
+        .Output(0, "output", "Output tensor containing the same value of the provided tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto value = ctx.getAttribute("value");
+          auto sparse_value = ctx.getAttribute("sparse_value");
+
+          if ((nullptr != value) && (nullptr != sparse_value))
+            fail_shape_inference(
+                "Only one of the attributes 'value' or 'sparse_value' must be specified for a Constant node.");
+
+          if (nullptr != value) {
+            // OpSchema::Verify check ensures that the attribute value has_t():
+            const TensorProto& tensor_proto = value->t();
+            updateOutputElemType(ctx, 0, tensor_proto.data_type());
+            updateOutputShape(ctx, 0, tensor_proto);
+            return;
+          }
+
+          if (nullptr != sparse_value) {
+            // OpSchema::Verify check ensures that the attribute value
+            // has_sparse_tensor():
+            const SparseTensorProto& sparse = sparse_value->sparse_tensor();
+            // checker.cc::check_sparse_tensor checks that the sparse-value is
+            // well-formed
+            updateOutputElemType(ctx, 0, sparse.values().data_type());
+            auto output_shape = getOutputShape(ctx, 0);
+            for (int i = 0; i < sparse.dims_size(); ++i)
+              appendDim(output_shape, sparse.dims(i));
+            return;
+          }
+          fail_shape_inference(
+              "One of the attributes 'value' or 'sparse_value' must be specified for a Constant node.");
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ConstantOfShape,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_ConstantOfShape_ver24)
+        .Attr(
+            "value",
+            "(Optional) The value of the output elements."
+            "Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Input(
+            0,
+            "input",
+            "1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar."
+            " All values must be >= 0.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor of shape specified by 'input'."
+            "If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'."
+            "If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype "
+            "defaults to float32.",
+            "T2")
+        .TypeConstraint("T1", {types::Int64}, "Constrain input types.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,      types::Float,          types::Double,     types::Int8,           types::Int16,
+             types::Int32,        types::Int64,          types::UInt8,      types::UInt16,         types::UInt32,
+             types::UInt64,       types::UInt4,          types::Int4,       types::Bool,           types::BFloat16,
+             types::Float8E4M3FN, types::Float8E4M3FNUZ, types::Float8E5M2, types::Float8E5M2FNUZ, types::Float4E2M1,
+             types::Float8E8M0},
+            "Constrain output types to be numerics or boolean.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("value") != nullptr) {
+            propagateElemTypeFromDtypeToOutput(ctx, ctx.getAttribute("value"), 0);
+          } else {
+            propagateElemTypeFromDtypeToOutput(ctx, TensorProto::FLOAT, 0);
+          }
+
+          bool found = false;
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
+          if (found) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ConstantOfShape,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_ConstantOfShape_ver24)
+        .Attr(
+            "value",
+            "(Optional) The value of the output elements."
+            "Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Input(
+            0,
+            "input",
+            "1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar."
+            " All values must be >= 0.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor of shape specified by 'input'."
+            "If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'."
+            "If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype "
+            "defaults to float32.",
+            "T2")
+        .TypeConstraint("T1", {types::Int64}, "Constrain input types.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,      types::Float,          types::Double,     types::Int8,           types::Int16,
+             types::Int32,        types::Int64,          types::UInt8,      types::UInt16,         types::UInt32,
+             types::UInt64,       types::UInt4,          types::Int4,       types::Bool,           types::BFloat16,
+             types::Float8E4M3FN, types::Float8E4M3FNUZ, types::Float8E5M2, types::Float8E5M2FNUZ, types::Float4E2M1},
+            "Constrain output types to be numerics or boolean.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("value") != nullptr) {
+            propagateElemTypeFromDtypeToOutput(ctx, ctx.getAttribute("value"), 0);
+          } else {
+            propagateElemTypeFromDtypeToOutput(ctx, TensorProto::FLOAT, 0);
+          }
+
+          bool found = false;
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
+          if (found) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ConstantOfShape,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_ConstantOfShape_ver24)
+        .Attr(
+            "value",
+            "(Optional) The value of the output elements."
+            "Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Input(
+            0,
+            "input",
+            "1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar."
+            " All values must be >= 0.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor of shape specified by 'input'."
+            "If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'."
+            "If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype "
+            "defaults to float32.",
+            "T2")
+        .TypeConstraint("T1", {types::Int64}, "Constrain input types.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::UInt4,
+             types::Int4,
+             types::Bool,
+             types::BFloat16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "Constrain output types to be numerics or boolean.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("value") != nullptr) {
+            propagateElemTypeFromDtypeToOutput(ctx, ctx.getAttribute("value"), 0);
+          } else {
+            propagateElemTypeFromDtypeToOutput(ctx, TensorProto::FLOAT, 0);
+          }
+
+          bool found = false;
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
+          if (found) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ConstantOfShape,
+    20,
+    OpSchema()
+        .SetDoc(kDoc_ConstantOfShape_ver24)
+        .Attr(
+            "value",
+            "(Optional) The value of the output elements."
+            "Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Input(
+            0,
+            "input",
+            "1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar."
+            " All values must be >= 0.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor of shape specified by 'input'."
+            "If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'."
+            "If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype "
+            "defaults to float32.",
+            "T2")
+        .TypeConstraint("T1", {types::Int64}, "Constrain input types.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::BFloat16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "Constrain output types to be numerics.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("value") != nullptr) {
+            propagateElemTypeFromDtypeToOutput(ctx, ctx.getAttribute("value"), 0);
+          } else {
+            propagateElemTypeFromDtypeToOutput(ctx, TensorProto::FLOAT, 0);
+          }
+
+          bool found = false;
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
+          if (found) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ConstantOfShape,
+    9,
+    OpSchema()
+        .SetDoc(kDoc_ConstantOfShape_ver24)
+        .Attr(
+            "value",
+            "(Optional) The value of the output elements."
+            "Should be a one-element tensor. If not specified, it defaults to a tensor of value 0 and datatype float32",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Input(
+            0,
+            "input",
+            "1D tensor. The shape of the expected output tensor. If empty tensor is given, the output would be a scalar."
+            " All values must be >= 0.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor of shape specified by 'input'."
+            "If attribute 'value' is specified, the value and datatype of the output tensor is taken from 'value'."
+            "If attribute 'value' is not specified, the value in the output defaults to 0, and the datatype "
+            "defaults to float32.",
+            "T2")
+        .TypeConstraint("T1", {types::Int64}, "Constrain input types.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool},
+            "Constrain output types to be numerics.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getAttribute("value") != nullptr) {
+            propagateElemTypeFromDtypeToOutput(ctx, ctx.getAttribute("value"), 0);
+          } else {
+            propagateElemTypeFromDtypeToOutput(ctx, TensorProto::FLOAT, 0);
+          }
+
+          bool found = false;
+          TensorShapeProto output_shape = getShapeInput(ctx, 0, true, found);
+          if (found) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = output_shape;
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Range,
+    11,
+    OpSchema()
+        .SetDoc(kDoc_Range_ver11)
+        .Input(0, "start", "Scalar. First entry for the range of output values.", "T")
+        .Input(1, "limit", "Scalar. Exclusive upper limit for the range of output values.", "T")
+        .Input(2, "delta", "Scalar. Value to step by.", "T")
+        .Output(0, "output", "A 1-D tensor with same type as the inputs containing generated range of values.", "T")
+        .TypeConstraint(
+            "T",
+            {"tensor(float)", "tensor(double)", "tensor(int16)", "tensor(int32)", "tensor(int64)"},
+            "Constrain input types to common numeric type tensors.")
+        .FunctionBody(R"ONNX(
+          {
+            sub_result = Sub (limit, start)
+            sub_result_casted = Cast <to = 1> (sub_result)
+            delta_casted = Cast <to = 1> (delta)
+            div_result = Div (sub_result_casted, delta_casted)
+            ceil_result = Ceil (div_result)
+            ceil_result_relu = Relu (ceil_result)
+            ceil_result_relu_int = Cast <to = 7> (ceil_result_relu)
+            ceil_result_relu_bool = Cast <to = 9> (ceil_result_relu)
+            variadic_output, output = Loop (ceil_result_relu_int, ceil_result_relu_bool, start)
+              <body = loop_body_attribute (int64 i, bool cond, prev) => (cond_out, current, range) {
+                cond_out = Identity (cond)
+                current = Add (prev, delta)
+                range = Identity (prev)
+              }>
+          }
+        )ONNX")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          const auto start_initializer = ctx.getInputData(0);
+          const auto limit_initializer = ctx.getInputData(1);
+          const auto delta_initializer = ctx.getInputData(2);
+
+          // Output is always 1-D
+          auto output_dim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+
+          // If any of Range's inputs are not initializers, the output dimension
+          // value would remain unknown.
+          if (start_initializer != nullptr && limit_initializer != nullptr && delta_initializer != nullptr) {
+            // Make sure the input types are homogeneous
+            if ((start_initializer->data_type() != limit_initializer->data_type()) ||
+                (start_initializer->data_type() != delta_initializer->data_type())) {
+              fail_shape_inference("All inputs to 'Range' op must be of the same type");
+            }
+
+            // Explicitly compute the output dimension if Range's inputs are
+            // stored in initializer list.
+            if (start_initializer->data_type() == TensorProto::FLOAT) {
+              output_dim->set_dim_value(
+                  compute_output_dim_for_range<float>(start_initializer, limit_initializer, delta_initializer));
+            } else if (start_initializer->data_type() == TensorProto::INT32) {
+              output_dim->set_dim_value(
+                  compute_output_dim_for_range<int32_t>(start_initializer, limit_initializer, delta_initializer));
+            } else if (start_initializer->data_type() == TensorProto::INT64) {
+              output_dim->set_dim_value(
+                  compute_output_dim_for_range<int64_t>(start_initializer, limit_initializer, delta_initializer));
+            } else if (start_initializer->data_type() == TensorProto::DOUBLE) {
+              output_dim->set_dim_value(
+                  compute_output_dim_for_range<double>(start_initializer, limit_initializer, delta_initializer));
+            } else {
+              // int16 has no explicit shape computation here -
+              // stop with rank inference, no action here
+            }
+
+            return;
+          }
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/generator/utils.cc b/onnx/defs/generator/utils.cc
new file mode 100644
index 0000000..8eacc2d
--- /dev/null
+++ b/onnx/defs/generator/utils.cc
@@ -0,0 +1,111 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/generator/utils.h"
+
+#include <algorithm>
+#include <vector>
+
+namespace ONNX_NAMESPACE {
+
+void ConstantOpInference(InferenceContext& ctx) {
+  const auto* const value = ctx.getAttribute("value");
+  const auto* const sparse_value = ctx.getAttribute("sparse_value");
+  const auto* const value_int = ctx.getAttribute("value_int");
+  const auto* const value_ints = ctx.getAttribute("value_ints");
+  const auto* const value_float = ctx.getAttribute("value_float");
+  const auto* const value_floats = ctx.getAttribute("value_floats");
+  const auto* const value_string = ctx.getAttribute("value_string");
+  const auto* const value_strings = ctx.getAttribute("value_strings");
+
+  std::vector<bool> non_null_attr = {
+      (nullptr != value),
+      (nullptr != sparse_value),
+      (nullptr != value_int),
+      (nullptr != value_ints),
+      (nullptr != value_float),
+      (nullptr != value_floats),
+      (nullptr != value_string),
+      (nullptr != value_strings)};
+
+  if (std::count(non_null_attr.begin(), non_null_attr.end(), true) != 1) {
+    fail_shape_inference(
+        "One and only one of the attributes 'value', 'value_*' or 'sparse_value' must be specified for a Constant node.");
+  }
+
+  if (nullptr != value) {
+    // OpSchema::Verify check ensures that the attribute value has_t():
+    const TensorProto& tensor_proto = value->t();
+    updateOutputElemType(ctx, 0, tensor_proto.data_type());
+    updateOutputShape(ctx, 0, tensor_proto);
+    return;
+  }
+
+  if (nullptr != value_int) {
+    // OpSchema::Verify check ensures that the attribute value has_i():
+    if (!value_int->has_i()) {
+      fail_shape_inference("Attribute 'value_int' expect an integer.");
+    }
+    updateOutputElemType(ctx, 0, TensorProto::INT64);
+    updateOutputShape(ctx, 0, TensorShapeProto());
+    return;
+  }
+
+  if (nullptr != value_ints) {
+    updateOutputElemType(ctx, 0, TensorProto::INT64);
+    appendDim(getOutputShape(ctx, 0), value_ints->ints_size());
+    return;
+  }
+
+  if (nullptr != value_float) {
+    // OpSchema::Verify check ensures that the attribute value has_i():
+    if (!value_float->has_f()) {
+      fail_shape_inference("Attribute 'value_float' expect a float.");
+    }
+    updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+    updateOutputShape(ctx, 0, TensorShapeProto());
+    return;
+  }
+
+  if (nullptr != value_floats) {
+    updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+    appendDim(getOutputShape(ctx, 0), value_floats->floats_size());
+    return;
+  }
+
+  if (nullptr != value_string) {
+    // OpSchema::Verify check ensures that the attribute value has_i():
+    if (!value_string->has_s()) {
+      fail_shape_inference("Attribute 'value_string' expect a string.");
+    }
+    updateOutputElemType(ctx, 0, TensorProto::STRING);
+    updateOutputShape(ctx, 0, TensorShapeProto());
+    return;
+  }
+
+  if (nullptr != value_strings) {
+    updateOutputElemType(ctx, 0, TensorProto::STRING);
+    appendDim(getOutputShape(ctx, 0), value_strings->strings_size());
+    return;
+  }
+
+  if (nullptr != sparse_value) {
+    // OpSchema::Verify check ensures that the attribute value
+    // has_sparse_tensor():
+    const SparseTensorProto& sparse = sparse_value->sparse_tensor();
+    // checker.cc::check_sparse_tensor checks that the sparse-value is
+    // well-formed
+    updateOutputElemType(ctx, 0, sparse.values().data_type());
+    auto* output_shape = getOutputShape(ctx, 0);
+    for (int i = 0; i < sparse.dims_size(); ++i)
+      appendDim(output_shape, sparse.dims(i));
+    return;
+  }
+
+  fail_shape_inference(
+      "TypeAndShapeInferenceFunction implementation incomplete: "
+      "this line should never be reached.");
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/generator/utils.h b/onnx/defs/generator/utils.h
new file mode 100644
index 0000000..899a02b
--- /dev/null
+++ b/onnx/defs/generator/utils.h
@@ -0,0 +1,34 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/tensor_proto_util.h"
+
+namespace ONNX_NAMESPACE {
+
+void ConstantOpInference(InferenceContext& ctx);
+
+template <typename T>
+int64_t compute_output_dim_for_range(const TensorProto* start, const TensorProto* limit, const TensorProto* delta) {
+  if (!start->dims().empty() || !limit->dims().empty() || !delta->dims().empty()) {
+    fail_shape_inference("Input to 'Range' op should be scalars (Tensor with only one element and shape empty)");
+  }
+
+  const auto start_data = ParseData<T>(start);
+  const auto limit_data = ParseData<T>(limit);
+  const auto delta_data = ParseData<T>(delta);
+
+  int64_t n = static_cast<int64_t>(ceil((1.0 * (limit_data[0] - start_data[0])) / delta_data[0]));
+
+  n = std::max<int64_t>(n, 0);
+
+  return n;
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/image/CMakeLists.txt b/onnx/defs/image/CMakeLists.txt
new file mode 100644
index 0000000..ebc1561
--- /dev/null
+++ b/onnx/defs/image/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+)
diff --git a/onnx/defs/image/defs.cc b/onnx/defs/image/defs.cc
new file mode 100644
index 0000000..48cf499
--- /dev/null
+++ b/onnx/defs/image/defs.cc
@@ -0,0 +1,68 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static constexpr const char* ImageDecoder_ver20_doc =
+    R"DOC(Loads and decodes and image from a file. If it can't decode for any reason (e.g. corrupted encoded
+stream, invalid format, it will return an empty matrix).
+The following image formats are supported:
+* BMP
+* JPEG (note: Lossless JPEG support is optional)
+* JPEG2000
+* TIFF
+* PNG
+* WebP
+* Portable image format (PBM, PGM, PPM, PXM, PNM)
+Decoded images follow a channel-last layout: (Height, Width, Channels).
+**JPEG chroma upsampling method:**
+When upsampling the chroma components by a factor of 2, the pixels are linearly interpolated so that the
+centers of the output pixels are 1/4 and 3/4 of the way between input pixel centers.
+When rounding, 0.5 is rounded down and up at alternative pixels locations to prevent bias towards
+larger values (ordered dither pattern).
+Considering adjacent input pixels A, B, and C, B is upsampled to pixels B0 and B1 so that
+```
+B0 = round_half_down((1/4) * A + (3/4) * B)
+B1 = round_half_up((3/4) * B + (1/4) * C)
+```
+This method,  is the default chroma upsampling method in the well-established libjpeg-turbo library,
+also referred as "smooth" or "fancy" upsampling.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ImageDecoder,
+    20,
+    OpSchema()
+        .SetDoc(ImageDecoder_ver20_doc)
+        .Attr(
+            "pixel_format",
+            "Pixel format. Can be one of \"RGB\", \"BGR\", or \"Grayscale\".",
+            AttributeProto::STRING,
+            std::string("RGB"))
+        .Input(0, "encoded_stream", "Encoded stream", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "image", "Decoded image", "T2", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T1", {types::UInt8}, "Constrain input types to 8-bit unsigned integer tensor.")
+        .TypeConstraint("T2", {types::UInt8}, "Constrain output types to 8-bit unsigned integer tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() != 1) {
+              fail_shape_inference("Input tensor must be 1-dimensional");
+            }
+          }
+          propagateElemTypeFromDtypeToOutput(ctx, TensorProto::UINT8, 0);
+          auto output_type = ctx.getOutputType(0);
+          auto sh = output_type->mutable_tensor_type()->mutable_shape();
+          sh->clear_dim();
+          sh->add_dim();
+          sh->add_dim();
+          sh->add_dim();
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/logical/CMakeLists.txt b/onnx/defs/logical/CMakeLists.txt
new file mode 100644
index 0000000..0804eec
--- /dev/null
+++ b/onnx/defs/logical/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+)
diff --git a/onnx/defs/logical/defs.cc b/onnx/defs/logical/defs.cc
new file mode 100644
index 0000000..22c30b9
--- /dev/null
+++ b/onnx/defs/logical/defs.cc
@@ -0,0 +1,349 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+inline static void unaryLogicalOpInference(InferenceContext& ctx) {
+  // Type inference
+  updateOutputElemType(ctx, 0, TensorProto::BOOL);
+  // Shape inference
+  if (hasInputShape(ctx, 0)) {
+    propagateShapeFromInputToOutput(ctx, 0, 0);
+  }
+}
+
+static void binaryLogicalOpInference(InferenceContext& ctx) {
+  // Type inference
+  updateOutputElemType(ctx, 0, TensorProto::BOOL);
+  // Shape inference
+  if (hasNInputShapes(ctx, 2))
+    bidirectionalBroadcastShapeInference(
+        ctx.getInputType(0)->tensor_type().shape(),
+        ctx.getInputType(1)->tensor_type().shape(),
+        *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+}
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+std::function<void(OpSchema&)> BinaryLogicDocGenerator(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Returns the tensor resulted from performing the `{name}` logical operation
+elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "A",
+        "First input operand for the logical operator.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Input(
+        1,
+        "B",
+        "Second input operand for the logical operator.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Output(0, "C", "Result tensor.", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable);
+    schema.TypeAndShapeInferenceFunction(binaryLogicalOpInference);
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    And,
+    7,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("and"))
+        .TypeConstraint("T", {types::Bool}, "Constrain input to boolean tensor.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Or,
+    7,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("or"))
+        .TypeConstraint("T", {types::Bool}, "Constrain input to boolean tensor.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Xor,
+    7,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("xor"))
+        .TypeConstraint("T", {types::Bool}, "Constrain input to boolean tensor.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Greater,
+    13,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("greater"))
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Less,
+    13,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("less"))
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Equal,
+    19,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("equal"))
+        .TypeConstraint(
+            "T",
+            {types::Bool,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::Float16,
+             types::Float,
+             types::Double,
+             types::BFloat16,
+             types::String},
+            "Constrain input types to all (non-complex) tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+static constexpr const char* Not_ver1_doc = R"DOC(
+Returns the negation of the input tensor element-wise.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Not,
+    1,
+    OpSchema()
+        .SetDoc(Not_ver1_doc)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T", {types::Bool}, "Constrain input/output to boolean tensors.")
+        .TypeAndShapeInferenceFunction(unaryLogicalOpInference));
+
+static constexpr const char* BitShift_ver11_doc = R"DOC(
+Bitwise shift operator performs element-wise operation. For each input element, if the
+attribute "direction" is "RIGHT", this operator moves its binary representation toward
+the right side so that the input value is effectively decreased. If the attribute "direction"
+is "LEFT", bits of binary representation moves toward the left side, which results the
+increase of its actual value. The input X is the tensor to be shifted and another input
+Y specifies the amounts of shifting. For example, if "direction" is "Right", X is [1, 4],
+and S is [1, 1], the corresponding output Z would be [0, 2]. If "direction" is "LEFT" with
+X=[1, 2] and S=[1, 2], the corresponding output Y would be [2, 8].
+
+Because this operator supports Numpy-style broadcasting, X's and Y's shapes are
+not necessarily identical.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BitShift,
+    11,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(BitShift_ver11_doc) + GenerateBroadcastingDocMul()))
+        .Input(
+            0,
+            "X",
+            "First operand, input to be shifted.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(1, "Y", "Second operand, amounts of shift.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Z", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {types::UInt8, types::UInt16, types::UInt32, types::UInt64},
+            "Constrain input and output types to integer tensors.")
+        .Attr(
+            "direction",
+            "Direction of moving bits. It can be either \"RIGHT\" (for right shift) "
+            "or \"LEFT\" (for left shift).",
+            AttributeProto::STRING)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // Shape inference
+          if (hasNInputShapes(ctx, 2))
+            bidirectionalBroadcastShapeInference(
+                ctx.getInputType(0)->tensor_type().shape(),
+                ctx.getInputType(1)->tensor_type().shape(),
+                *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LessOrEqual,
+    16,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("less_equal"))
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor.")
+        .TypeAndShapeInferenceFunction(binaryLogicalOpInference)
+        .FunctionBody(R"ONNX(
+        {
+            O1 = Less (A, B)
+            O2 = Equal (A, B)
+            C = Or (O1, O2)
+        }
+        )ONNX"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GreaterOrEqual,
+    16,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("greater_equal"))
+        .TypeConstraint("T", OpSchema::all_numeric_types_ir4(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor.")
+        .TypeAndShapeInferenceFunction(binaryLogicalOpInference)
+        .FunctionBody(R"ONNX(
+        {
+            O1 = Greater (A, B)
+            O2 = Equal (A, B)
+            C = Or (O1, O2)
+        }
+        )ONNX"));
+
+static constexpr const char* BitwiseNot_ver18_doc = R"DOC(
+Returns the bitwise not of the input tensor element-wise.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BitwiseNot,
+    18,
+    OpSchema()
+        .SetDoc(BitwiseNot_ver18_doc)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64},
+            "Constrain input/output to integer tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static std::function<void(OpSchema&)> BinaryBitwiseDocGenerator(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Returns the tensor resulting from performing the bitwise `{name}` operation
+elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "A",
+        "First input operand for the bitwise operator.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Input(
+        1,
+        "B",
+        "Second input operand for the bitwise operator.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Output(0, "C", "Result tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable);
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      // Type inference
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      // Shape inference
+      if (hasNInputShapes(ctx, 2))
+        bidirectionalBroadcastShapeInference(
+            ctx.getInputType(0)->tensor_type().shape(),
+            ctx.getInputType(1)->tensor_type().shape(),
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BitwiseAnd,
+    18,
+    OpSchema()
+        .FillUsing(BinaryBitwiseDocGenerator("and"))
+        .TypeConstraint(
+            "T",
+            {types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64},
+            "Constrain input to integer tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BitwiseOr,
+    18,
+    OpSchema()
+        .FillUsing(BinaryBitwiseDocGenerator("or"))
+        .TypeConstraint(
+            "T",
+            {types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64},
+            "Constrain input to integer tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BitwiseXor,
+    18,
+    OpSchema()
+        .FillUsing(BinaryBitwiseDocGenerator("xor"))
+        .TypeConstraint(
+            "T",
+            {types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64},
+            "Constrain input to integer tensors."));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/logical/old.cc b/onnx/defs/logical/old.cc
new file mode 100644
index 0000000..de8dce4
--- /dev/null
+++ b/onnx/defs/logical/old.cc
@@ -0,0 +1,265 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+#include <string>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset12(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Returns the tensor resulted from performing the `{name}` logical operation
+elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    schema.SetDoc(doc);
+    schema.Input(0, "A", "First input operand for the logical operator.", "T");
+    schema.Input(1, "B", "Second input operand for the logical operator.", "T");
+    schema.Output(0, "C", "Result tensor.", "T1");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      // Type inference
+      updateOutputElemType(ctx, 0, TensorProto::BOOL);
+      // Shape inference
+      if (hasNInputShapes(ctx, 2))
+        bidirectionalBroadcastShapeInference(
+            ctx.getInputType(0)->tensor_type().shape(),
+            ctx.getInputType(1)->tensor_type().shape(),
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Greater,
+    9,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset12("greater"))
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Less,
+    9,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset12("less"))
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Equal,
+    11,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset12("equal"))
+        .TypeConstraint(
+            "T",
+            {types::Bool,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::Float16,
+             types::Float,
+             types::Double},
+            "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+inline static void logicalOpInference_opset1(InferenceContext& ctx) {
+  updateOutputElemType(ctx, 0, TensorProto::BOOL);
+  if (hasInputShape(ctx, 0)) {
+    propagateShapeFromInputToOutput(ctx, 0, 0);
+  }
+}
+
+static std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset1(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Returns the tensor resulted from performing the `{name}` logical operation
+elementwise on the input tensors `A` and `B`.
+
+If broadcasting is enabled, the right-hand-side argument will be broadcasted
+to match the shape of left-hand-side argument. See the doc of `Add` for a
+detailed description of the broadcasting rules.
+)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc);
+    schema.Attr("broadcast", "Enable broadcasting", AttributeProto::INT, static_cast<int64_t>(0));
+    schema.Attr("axis", "If set, defines the broadcast dimensions.", AttributeProto::INT, OPTIONAL_VALUE);
+    schema.Input(0, "A", "Left input tensor for the logical operator.", "T");
+    schema.Input(1, "B", "Right input tensor for the logical operator.", "T");
+    schema.Output(0, "C", "Result tensor.", "T1");
+    schema.TypeAndShapeInferenceFunction(logicalOpInference_opset1);
+  };
+}
+
+static std::function<void(OpSchema&)> BinaryLogicDocGenerator_opset7(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Returns the tensor resulted from performing the `{name}` logical operation
+elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    schema.SetDoc(doc);
+    schema.Input(0, "A", "First input operand for the logical operator.", "T");
+    schema.Input(1, "B", "Second input operand for the logical operator.", "T");
+    schema.Output(0, "C", "Result tensor.", "T1");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      updateOutputElemType(ctx, 0, TensorProto::BOOL);
+      if (hasNInputShapes(ctx, 2))
+        bidirectionalBroadcastShapeInference(
+            ctx.getInputType(0)->tensor_type().shape(),
+            ctx.getInputType(1)->tensor_type().shape(),
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    And,
+    1,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset1("and"))
+        .TypeConstraint("T", {types::Bool}, "Constrain input to boolean tensor.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Or,
+    1,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset1("or"))
+        .TypeConstraint("T", {types::Bool}, "Constrain input to boolean tensor.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Xor,
+    1,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset1("xor"))
+        .TypeConstraint("T", {types::Bool}, "Constrain input to boolean tensor.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Greater,
+    1,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset1("greater"))
+        .TypeConstraint("T", {types::Float16, types::Float, types::Double}, "Constrain input to float tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Less,
+    1,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset1("less"))
+        .TypeConstraint("T", {types::Float16, types::Float, types::Double}, "Constrain input to float tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Equal,
+    1,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset1("equal"))
+        .TypeConstraint("T", {types::Bool, types::Int32, types::Int64}, "Constrain input to integral tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Equal,
+    7,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset7("equal"))
+        .TypeConstraint("T", {types::Bool, types::Int32, types::Int64}, "Constrain input to integral tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Greater,
+    7,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset7("greater"))
+        .TypeConstraint("T", {types::Float16, types::Float, types::Double}, "Constrain input to float tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Less,
+    7,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator_opset7("less"))
+        .TypeConstraint("T", {types::Float16, types::Float, types::Double}, "Constrain input to float tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+// Shares same doc generator as newer opset 16 version.
+extern std::function<void(OpSchema&)> BinaryLogicDocGenerator(const char* name);
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LessOrEqual,
+    12,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("less_equal"))
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor.")
+        .TypeAndShapeInferenceFunction(InferenceFunction())
+        .FunctionBody(R"ONNX(
+        {
+            O1 = Less (A, B)
+            O2 = Equal (A, B)
+            C = Or (O1, O2)
+        }
+        )ONNX"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GreaterOrEqual,
+    12,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("greater_equal"))
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor.")
+        .TypeAndShapeInferenceFunction(InferenceFunction())
+        .FunctionBody(R"ONNX(
+        {
+            O1 = Greater (A, B)
+            O2 = Equal (A, B)
+            C = Or (O1, O2)
+        }
+        )ONNX"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Equal,
+    13,
+    OpSchema()
+        .FillUsing(BinaryLogicDocGenerator("equal"))
+        .TypeConstraint(
+            "T",
+            {types::Bool,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::Float16,
+             types::Float,
+             types::Double,
+             types::BFloat16},
+            "Constrain input types to all numeric tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output to boolean tensor."));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/math/CMakeLists.txt b/onnx/defs/math/CMakeLists.txt
new file mode 100644
index 0000000..0011f05
--- /dev/null
+++ b/onnx/defs/math/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+    utils.cc
+    utils.h
+)
diff --git a/onnx/defs/math/defs.cc b/onnx/defs/math/defs.cc
new file mode 100644
index 0000000..b5fc8d0
--- /dev/null
+++ b/onnx/defs/math/defs.cc
@@ -0,0 +1,3101 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <map>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "onnx/common/assertions.h"
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/math/utils.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static void MathOpDataPropagator(DataPropagationContext& ctx, const std::string& op_type) {
+  const auto* const input_0 = ctx.getInputData(0);
+  const auto* const input_1 = ctx.getInputData(1);
+  if (input_0 == nullptr || input_1 == nullptr) {
+    return;
+  }
+  int size_0 = input_0->dim_size();
+  int size_1 = input_1->dim_size();
+  // Fails to broadcast if the ranks are different and no any rank is 1
+  if (size_0 != size_1 && size_0 != 1 && size_1 != 1) {
+    fail_shape_inference("Invalid rank for ", op_type, " broadcasting: (", size_0, ") vs (", size_1, ").");
+  }
+  TensorShapeProto tsp;
+  int size_out = size_0 == 1 ? size_1 : size_0;
+  for (int i = 0; i < size_out; ++i) {
+    const auto& input_dim_0 = input_0->dim(size_0 == 1 ? 0 : i);
+    const auto& input_dim_1 = input_1->dim(size_1 == 1 ? 0 : i);
+    if (input_dim_0.has_dim_value() && input_dim_1.has_dim_value()) {
+      tsp.mutable_dim()->Add()->set_dim_value(
+          defs::math::utils::MathOpTwoIntegers(op_type, input_dim_0.dim_value(), input_dim_1.dim_value()));
+    } else {
+      // Cannot compute the value; simply add an empty dim without value and param
+      tsp.mutable_dim()->Add();
+    }
+  }
+  ctx.addOutputData(0, std::move(tsp));
+}
+
+static std::function<void(OpSchema&)> MathDocGenerator(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    if (std::string(name) == "division") {
+      POPULATE_OP_DOC_STR(
+          doc = R"DOC(
+Performs element-wise binary {name} (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+
+For integer inputs, the result is computed using truncating division (rounding toward zero).
+(Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+)DOC";
+          ReplaceAll(doc, "{name}", name);
+          ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    } else {
+      POPULATE_OP_DOC_STR(
+          doc = R"DOC(
+Performs element-wise binary {name} (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+
+(Opset 14 change): Extend supported types to include uint8, int8, uint16, and int16.
+)DOC";
+          ReplaceAll(doc, "{name}", name);
+          ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    }
+    schema.SetDoc(doc);
+    schema.Input(0, "A", "First operand.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.Input(1, "B", "Second operand.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "C",
+        "Result, has same element type as two inputs",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", OpSchema::all_numeric_types_ir4(), "Constrain input and output types to all numeric tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (hasNInputShapes(ctx, 2))
+        bidirectionalBroadcastShapeInference(
+            ctx.getInputType(0)->tensor_type().shape(),
+            ctx.getInputType(1)->tensor_type().shape(),
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Add,
+    14,
+    OpSchema().FillUsing(MathDocGenerator("addition")).PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+      MathOpDataPropagator(ctx, "Add");
+    }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sub,
+    14,
+    OpSchema()
+        .FillUsing(MathDocGenerator("subtraction"))
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { MathOpDataPropagator(ctx, "Sub"); }));
+
+static constexpr const char* Mod_doc = R"DOC(
+Performs an element-wise binary modulo operation.
+The semantics and supported data types depend on the value of the `fmod` attribute which must be `0` (default), or `1`.
+
+If the `fmod` attribute is set to `0`, `T` is constrained to integer data types and the semantics follow that of the Python `%`-operator.
+The sign of the result is that of the divisor.
+
+If `fmod` is set to `1`, the behavior of this operator follows that of the `fmod` function in C and `T` is constrained to floating point data types.
+The result of this operator is the remainder of the division operation `x / y` where `x` and `y` are respective elements of `A` and `B`. The result is exactly the value `x - n * y`, where `n` is `x / y` with its fractional part truncated.
+The returned value has the same sign as `x` (except if `x` is `-0`) and is less or equal to `|y|` in magnitude.
+The following special cases apply when `fmod` is set to `1`:
+- If `x` is `-0` and `y` is greater than zero, either `+0` or `-0` may be returned.
+- If `x` is `±∞` and `y` is not `NaN`, `NaN` is returned.
+- If `y` is `±0` and `x` is not `NaN`, `NaN` should be returned.
+- If `y` is `±∞` and `x` is finite, `x` is returned.
+- If either argument is `NaN`, `NaN` is returned.
+
+This operator supports **multidirectional (i.e., NumPy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Mod,
+    13,
+    OpSchema()
+        .SetDoc(Mod_doc)
+        .Attr(
+            "fmod",
+            "Whether the operator should behave like fmod (default=0 meaning it will do integer mods); Set this to 1 to force fmod treatment",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "A", "Dividend tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(1, "B", "Divisor tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "C", "Remainder tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_numeric_types_ir4(),
+            "Constrain input and output types to high-precision numeric tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2))
+            bidirectionalBroadcastShapeInference(
+                ctx.getInputType(0)->tensor_type().shape(),
+                ctx.getInputType(1)->tensor_type().shape(),
+                *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Mul,
+    14,
+    OpSchema()
+        .FillUsing(MathDocGenerator("multiplication"))
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { MathOpDataPropagator(ctx, "Mul"); }));
+
+ONNX_OPERATOR_SET_SCHEMA(Div, 14, OpSchema().FillUsing(MathDocGenerator("division")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Neg,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Neg_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float,
+             types::Int32,
+             types::Int8,
+             types::Int16,
+             types::Int64,
+             types::Float16,
+             types::Double,
+             types::BFloat16},
+            "Constrain input and output types to signed numeric tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* Abs_ver13_doc = R"DOC(
+Absolute takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where absolute value, y = abs(x), is applied to
+the tensor elementwise.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Abs,
+    13,
+    OpSchema()
+        .SetDoc(Abs_ver13_doc)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_numeric_types_ir4(),
+            "Constrain input and output types to all numeric tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reciprocal,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Reciprocal_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* Floor_ver13_doc = R"DOC(
+Floor takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the floor is, y = floor(x), is applied to
+the tensor elementwise. If x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Floor,
+    13,
+    OpSchema()
+        .SetDoc(Floor_ver13_doc)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* Ceil_ver13_doc = R"DOC(
+Ceil takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the ceil is, y = ceil(x), is applied to
+the tensor elementwise. If x is integral, +0, -0, NaN,  or infinite, x itself is returned.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Ceil,
+    13,
+    OpSchema()
+        .SetDoc(Ceil_ver13_doc)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sqrt,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Sqrt_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Relu,
+    14,
+    OpSchema()
+        .SetDoc(kDoc_Relu_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float,
+             types::Int32,
+             types::Int8,
+             types::Int16,
+             types::Int64,
+             types::Float16,
+             types::Double,
+             types::BFloat16},
+            "Constrain input and output types to signed numeric tensors.")
+        .FunctionBody(
+            R"ONNX(
+          {
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            Y = Max (X, ZeroCast)
+          }
+        )ONNX",
+            18)
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LeakyRelu,
+    16,
+    OpSchema()
+        .Attr("alpha", "Coefficient of leakage.", AttributeProto::FLOAT, 0.01f)
+        .SetDoc(kDoc_LeakyRelu_ver1)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::BFloat16, types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike(Zero, X)
+            XLessThanZero = Less(X, ZeroCast)
+            AlphaMulX = Mul (AlphaCast, X)
+            Y = Where (XLessThanZero, AlphaMulX, X)
+          }
+        )ONNX"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ThresholdedRelu,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_ThresholdedRelu_ver10)
+        .Attr("alpha", "Threshold value", AttributeProto::FLOAT, 1.0f)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            AlphaLessThanX = Less(AlphaCast, X)
+            Y = Where(AlphaLessThanX, X, ZeroCast)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Selu,
+    22,
+    OpSchema()
+        .Attr(
+            "alpha",
+            "Coefficient of SELU default to 1.67326319217681884765625 "
+            "(i.e., float32 approximation of 1.6732632423543772848170429916717).",
+            AttributeProto::FLOAT,
+            1.67326319217681884765625f)
+        .Attr(
+            "gamma",
+            "Coefficient of SELU default to 1.05070102214813232421875 "
+            "(i.e., float32 approximation of 1.0507009873554804934193349852946).",
+            AttributeProto::FLOAT,
+            1.05070102214813232421875f)
+        .SetDoc(kDoc_Selu_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Gamma = Constant <value_float: float = @gamma>()
+            GammaCast = CastLike (Gamma, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            ExpX = Exp (X)
+            AlphaMulExpX = Mul(AlphaCast, ExpX)
+            AlphaMulExpXSubAlpha = Sub (AlphaMulExpX, AlphaCast)
+            Neg = Mul (GammaCast, AlphaMulExpXSubAlpha)
+            Pos = Mul (GammaCast, X)
+            XLessThanZero = Less (X, ZeroCast)
+            Y = Where(XLessThanZero, Neg, Pos)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Elu,
+    22,
+    OpSchema()
+        .Attr("alpha", "Coefficient of ELU.", AttributeProto::FLOAT, 1.0f)
+        .SetDoc(kDoc_Elu_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            One = Constant <value = float {1.0}>()
+            OneCast = CastLike (One, X)
+            XLessThanZero = Less (X, ZeroCast)
+            ExpX = Exp (X)
+            ExpXSubOne = Sub (ExpX, OneCast)
+            AlphaMulExpXSubOne = Mul (AlphaCast, ExpXSubOne)
+            Y = Where(XLessThanZero, AlphaMulExpXSubOne, X)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Mish,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_mish_ver18)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input X and output types to float tensors.")
+        .FunctionBody(R"ONNX(
+          {
+            Softplus_X = Softplus (X)
+            TanHSoftplusX = Tanh (Softplus_X)
+            Y = Mul (X, TanHSoftplusX)
+           }
+        )ONNX")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* celu_ver28_doc = R"DOC(
+Continuously Differentiable Exponential Linear Units:
+Perform the linear unit element-wise on the input tensor X
+using formula:
+
+```
+max(0,x) + min(0,alpha*(exp(x/alpha)-1))
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Celu,
+    28,
+    OpSchema()
+        .SetDoc(celu_ver28_doc)
+        .Attr(
+            "alpha",
+            "The Alpha value in Celu formula which control the shape of "
+            "the unit. The default value is 1.0.",
+            AttributeProto::FLOAT,
+            1.0f)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            XScaled = Div (X, AlphaCast)
+            EluResult = Elu <alpha = 1.0> (XScaled)
+            Y = Mul (AlphaCast, EluResult)
+          }
+        )ONNX"));
+
+static constexpr const char* gelu_ver20_doc = R"DOC(
+Gelu takes one input data (Tensor<T>) and produces one
+output data (Tensor<T>) where the gaussian error linear units function,
+$y = 0.5 * x * (1 + erf(x/sqrt(2)))$ is applied to the tensor elementwise.
+If the attribute "approximate" is set to "tanh", the function estimation,
+$y = 0.5 * x * (1 + Tanh(sqrt(2/\pi) * (x + 0.044715 * x^3)))$ is used and applied
+to the tensor elementwise.
+
+)DOC";
+
+static constexpr const char* gelu_default_approx = "none";
+
+static bool BuildContextDependentFunctionBodyGelu(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  const auto* const approx_attr_proto = ctx.getAttribute("approximate");
+  std::string approximate =
+      approx_attr_proto != nullptr && approx_attr_proto->has_s() ? approx_attr_proto->s() : gelu_default_approx;
+  FunctionBuilder builder(functionProto);
+
+  if (approximate == "tanh") {
+    builder.Add(R"(
+              Half = Constant <value = float {0.5}>()
+              HalfCast = CastLike (Half, X)
+              One = Constant <value = float {1.0}>()
+              OneCast = CastLike (One, X)
+              TwoOverPi = Constant <value = float {0.63661977236}>()
+              TwoOverPiCast = CastLike (TwoOverPi, X)
+              C0 = Constant <value = float {0.044715}>()
+              C0Cast = CastLike (C0, X)
+              SqrtTwoOverPi = Sqrt (TwoOverPiCast)
+              Three = Constant <value = float {3.0}>()
+              ThreeCast = CastLike (Three, X)
+              XCubed = Pow (X, ThreeCast)
+              XCubedC0 = Mul (C0Cast, XCubed)
+              XC0XCubed = Sum (X, XCubedC0)
+              TanhInput = Mul (SqrtTwoOverPi, XC0XCubed)
+              ErfApprox = Tanh (TanhInput)
+              PhiApprox = Sum (OneCast, ErfApprox)
+              MultX = Mul (HalfCast, X)
+              Y = Mul (MultX, PhiApprox)
+              )");
+  } else {
+    builder.Add(R"(
+              Half = Constant <value = float {0.5}>()
+              HalfCast = CastLike (Half, X)
+              One = Constant <value = float {1.0}>()
+              OneCast = CastLike (One, X)
+              Two = Constant <value = float {2.0}>()
+              TwoCast = CastLike (Two, X)
+              SqrtTwo = Sqrt (TwoCast)
+              XSqrt = Div (X, SqrtTwo)
+              ErfXSqrt = Erf(XSqrt)
+              Phi = Sum (OneCast, ErfXSqrt)
+              MultX = Mul (HalfCast, X)
+              Y = Mul (MultX, Phi)
+              )");
+  }
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gelu,
+    20,
+    OpSchema()
+        .SetDoc(gelu_ver20_doc)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Attr(
+            "approximate",
+            "Gelu approximation algorithm: `\"tanh\"`, `\"none\"`(default)."
+            "`\"none\"`: do not use approximation."
+            "`\"tanh\"`: use tanh approximation.",
+            AttributeProto::STRING,
+            gelu_default_approx)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBodyGelu)
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* Swish_ver24_doc = R"DOC(
+Swish function takes one input data (Tensor<T>) and produces one output data (Tensor<T>) of the same shape,
+where $Swish(x) = x * sigmoid(alpha * x)$.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Swish,
+    24,
+    OpSchema()
+        .Attr("alpha", "Coefficient to multiply with input before sigmoid.", AttributeProto::FLOAT, 1.0f)
+        .SetDoc(Swish_ver24_doc)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::BFloat16, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+            {
+                Alpha = Constant <value_float: float = @alpha>()
+                AlphaCast = CastLike (Alpha, X)
+                AlphaMulX = Mul (AlphaCast, X)
+                SigmoidAlphaMulX = Sigmoid(AlphaMulX)
+                Y = Mul (X, SigmoidAlphaMulX)
+            }
+            )ONNX"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Exp,
+    13,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Exp_ver6,
+            "The exponential of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Log,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Log_ver6)
+        .Input(0, "input", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "The natural log of the input tensor computed "
+            "element-wise",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Tanh,
+    13,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Tanh_ver6,
+            "The hyperbolic tangent values of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pow,
+    15,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_Pow_ver13) + GenerateBroadcastingDocMul()))
+        .Input(0, "X", "First operand, base of the exponent.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "Y",
+            "Second operand, power of the exponent.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(0, "Z", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Int32, types::Int64, types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input X and output types to float/int tensors.")
+        .TypeConstraint(
+            "T1",
+            {types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::Float16,
+             types::Float,
+             types::Double,
+             types::BFloat16},
+            "Constrain input Y types to float/int tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2))
+            bidirectionalBroadcastShapeInference(
+                ctx.getInputType(0)->tensor_type().shape(),
+                ctx.getInputType(1)->tensor_type().shape(),
+                *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    PRelu,
+    16,
+    OpSchema()
+        .SetDoc(
+            GET_OP_DOC_STR(std::string(kDoc_PRelu_ver7) + GenerateBroadcastingDocUni("tensor slope", "input tensor X")))
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "slope",
+            "Slope tensor. The shape of slope can be smaller than first input X; "
+            "if so, its shape must be unidirectional broadcastable to X",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor (same size as X)", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::BFloat16,
+             types::Float16,
+             types::Float,
+             types::Double,
+             types::UInt32,
+             types::UInt64,
+             types::Int32,
+             types::Int64},
+            "Constrain input and output types to float/int tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(R"ONNX(
+        {
+          Zero = Constant <value = float {0.0}>()
+          ZeroCast = CastLike(Zero, X)
+          XLessThanZero = Less (X, ZeroCast)
+          SlopeMulX = Mul (slope, X)
+          Y = Where(XLessThanZero, SlopeMulX, X)
+        }
+        )ONNX"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sigmoid,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Sigmoid_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    HardSigmoid,
+    22,
+    OpSchema()
+        .Attr("alpha", "Value of alpha.", AttributeProto::FLOAT, 0.2f)
+        .Attr("beta", "Value of beta.", AttributeProto::FLOAT, 0.5f)
+        .SetDoc(kDoc_HardSigmoid_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Beta = Constant <value_float: float = @beta>()
+            BetaCast = CastLike (Beta, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            One = Constant <value = float {1.0}>()
+            OneCast = CastLike (One, X)
+            AlphaMulX = Mul (X, AlphaCast)
+            AlphaMulXAddBeta = Add (AlphaMulX, BetaCast)
+            MinOneOrAlphaMulXAddBeta = Min (AlphaMulXAddBeta, OneCast)
+            Y = Max(MinOneOrAlphaMulXAddBeta, ZeroCast)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    HardSwish,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_HardSwish_ver14)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(R"ONNX(
+          {
+            HS_X = HardSigmoid<alpha = 0.16666667163372, beta = 0.5>(X)
+            Y = Mul (X, HS_X)
+          }
+        )ONNX"));
+
+// Generate opschema for element-wise ops. Leaves type constraint "T"
+// unspecified.
+static std::function<void(OpSchema&)> ElementwiseMultiOpDocGenerator(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Element-wise {name} of each of the input tensors (with Numpy-style broadcasting support).
+All inputs and outputs must have the same data type.
+{broadcast_doc}
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "data_0",
+        "List of tensors for " + std::string(name) + ".",
+        "T",
+        OpSchema::Variadic,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(0, name, "Output tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      int num_inputs = static_cast<int>(ctx.getNumInputs());
+      std::vector<const TensorShapeProto*> shapes;
+      shapes.reserve(num_inputs);
+      for (int i = 0; i < num_inputs; ++i) {
+        const auto* const input_type = ctx.getInputType(i);
+        if (nullptr == input_type || !input_type->has_tensor_type() || !input_type->tensor_type().has_shape()) {
+          return;
+        }
+        shapes.push_back(&input_type->tensor_type().shape());
+      }
+
+      multidirectionalBroadcastShapeInference(shapes, *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Max,
+    13,
+    OpSchema()
+        .FillUsing(ElementwiseMultiOpDocGenerator("max"))
+        .TypeConstraint(
+            "T",
+            OpSchema::all_numeric_types_ir4(),
+            "Constrain input and output types to numeric tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Min,
+    13,
+    OpSchema()
+        .FillUsing(ElementwiseMultiOpDocGenerator("min"))
+        .TypeConstraint(
+            "T",
+            OpSchema::all_numeric_types_ir4(),
+            "Constrain input and output types to numeric tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sum,
+    13,
+    OpSchema()
+        .FillUsing(ElementwiseMultiOpDocGenerator("sum"))
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Mean,
+    13,
+    OpSchema()
+        .FillUsing(ElementwiseMultiOpDocGenerator("mean"))
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Clip_ver13_doc = R"DOC(
+Clip operator limits the given input within an interval. The interval is
+specified by the inputs 'min' and 'max'. They default to
+numeric_limits::lowest() and numeric_limits::max(), respectively.
+When 'min' is greater than 'max', the clip operator sets all the 'input' values to
+the value of 'max'. Thus, this is equivalent to 'Min(max, Max(input, min))'.
+)DOC";
+
+static bool BuildContextDependentFunctionBodyClip(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  bool has_min = ctx.hasInput(1);
+  bool has_max = ctx.hasInput(2);
+
+  FunctionBuilder builder(functionProto);
+  if (!has_min && !has_max) {
+    builder.Add("output = Identity (input)");
+  } else if (has_min && !has_max) {
+    builder.Add("input_less_than_min = Less (input, min)");
+    builder.Add("output = Where (input_less_than_min, min, input)");
+  } else if (!has_min && has_max) {
+    builder.Add("input_large_than_max = Less (max, input)");
+    builder.Add("output = Where (input_large_than_max, max, input)");
+  } else {
+    builder.Add("input_less_than_min = Less (input, min)");
+    builder.Add("tmp = Where (input_less_than_min, min, input)");
+    builder.Add("output_large_than_max = Less (max, tmp)");
+    builder.Add("output = Where (output_large_than_max, max, tmp)");
+  }
+
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Clip,
+    13,
+    OpSchema()
+        .SetDoc(Clip_ver13_doc)
+        .Input(
+            0,
+            "input",
+            "Input tensor whose elements to be clipped",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "min",
+            "Minimum value, under which element is replaced by min. "
+            "It must be a scalar(tensor of empty shape).",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "max",
+            "Maximum value, above which element is replaced by max. "
+            "It must be a scalar(tensor of empty shape).",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor with clipped input elements",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_numeric_types_ir4(),
+            "Constrain input and output types to all numeric tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBodyClip)
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static std::function<void(OpSchema&)>
+SoftmaxFamilyDocGenerator(const char* name, const char* description, const char* equation) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+The operator computes the {description} values for the given input:
+
+ {equation}
+
+The "axis" attribute indicates the dimension along which {name}
+will be performed. The output tensor has the same shape
+and contains the {name} values of the corresponding input.
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{description}", description);
+        ReplaceAll(doc, "{equation}", equation););
+    std::string axis_attr;
+    POPULATE_OP_DOC_STR(
+        axis_attr = R"DOC(
+Describes the dimension {name} will be performed on.
+Negative value means counting dimensions
+from the back. Accepted range is [-r, r-1] where r = rank(input).
+)DOC";
+        ReplaceAll(axis_attr, "{name}", name););
+    schema.SetDoc(doc);
+    schema.Attr("axis", axis_attr, AttributeProto::INT, static_cast<int64_t>(-1));
+    schema.Input(
+        0, "input", "The input tensor of rank >= axis.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "output",
+        "The output values with the same shape as the input tensor.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T",
+        {types::Float16, types::Float, types::Double, types::BFloat16},
+        "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([name](InferenceContext& ctx) {
+      // Type inference
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+      // Shape inference starts
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+
+      // Validate the value of 'axis'
+      const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      int r = input_shape.dim_size();
+      if (r == 0) {
+        fail_shape_inference("Input rank must be >= 1 for ", name, ".");
+      }
+      int axis = static_cast<int>(getAttribute(ctx, "axis", -1));
+      if (axis < -r || axis >= r) {
+        fail_shape_inference("'axis' must be in [", -r, " , ", (r - 1), "]. Its actual value is: ", axis);
+      }
+
+      // Shape inference
+      propagateShapeFromInputToOutput(ctx, 0, 0);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Softmax,
+    13,
+    OpSchema()
+        .FillUsing(SoftmaxFamilyDocGenerator(
+            "Softmax",
+            "normalized exponential",
+            "Softmax(input, axis) = Exp(input) / ReduceSum(Exp(input), axis=axis, keepdims=1) "))
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        // function body builder for opset version 13 (the default opset version is the same
+        // as the operator's since_version.
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              int64_t axis = ctx.getAttribute("axis") != nullptr ? ctx.getAttribute("axis")->i() : -1;
+              FunctionBuilder builder(functionProto);
+              builder.Const1D("axes", axis)
+                  .Add("X_ReduceMax = ReduceMax <keepdims = 1> (input)", "axes", std::vector<int64_t>({axis}))
+                  .Add(R"(
+                    X_Sub = Sub (input, X_ReduceMax)
+                    X_Exp = Exp (X_Sub)
+                    X_ReduceSum = ReduceSum <keepdims = 1> (X_Exp, axes)
+                    output = Div (X_Exp, X_ReduceSum)
+                )");
+
+              schema.BuildFunction(functionProto);
+              return true;
+            })
+        // function body builder for opset version 18.
+        // ReduceSum is updated in opset 18 to have axes as the second input.
+        // Therefore function body for opset version 18
+        // is different than the one defined using opset version 13.
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              int64_t axis = ctx.getAttribute("axis") != nullptr ? ctx.getAttribute("axis")->i() : -1;
+              FunctionBuilder builder(functionProto);
+              builder.Const1D("axes", axis).Add("X_ReduceMax = ReduceMax <keepdims = 1> (input, axes)").Add(R"(
+                    X_Sub = Sub (input, X_ReduceMax)
+                    X_Exp = Exp (X_Sub)
+                    X_ReduceSum = ReduceSum <keepdims = 1> (X_Exp, axes)
+                    output = Div (X_Exp, X_ReduceSum)
+                )");
+
+              schema.BuildFunction(functionProto);
+              return true;
+            },
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LogSoftmax,
+    13,
+    OpSchema()
+        .FillUsing(SoftmaxFamilyDocGenerator(
+            "LogSoftmax",
+            "log of softmax",
+            "LogSoftmax(input, axis) = Log(Softmax(input, axis=axis))"))
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        // Function for opset 13
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              const int64_t axis = ctx.getAttribute("axis") != nullptr ? ctx.getAttribute("axis")->i() : -1;
+              FunctionBuilder builder(functionProto);
+              builder.Const1D("axes", axis)
+                  .Add("X_ReduceMax = ReduceMax <keepdims = 1> (input)", "axes", std::vector<int64_t>({axis}))
+                  .Add(R"(
+                    X_Sub = Sub (input, X_ReduceMax)
+                    X_Exp = Exp (X_Sub)
+                    X_ReduceSum = ReduceSum <keepdims = 1> (X_Exp, axes)
+                    X_Log = Log (X_ReduceSum)
+                    output = Sub (X_Sub, X_Log)
+                )");
+
+              schema.BuildFunction(functionProto);
+              return true;
+            },
+            13)
+        // Function for opset 18
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              const int64_t axis = ctx.getAttribute("axis") != nullptr ? ctx.getAttribute("axis")->i() : -1;
+              FunctionBuilder builder(functionProto);
+              builder.Const1D("axes", axis).Add("X_ReduceMax = ReduceMax <keepdims = 1> (input, axes)").Add(R"(
+                    X_Sub = Sub (input, X_ReduceMax)
+                    X_Exp = Exp (X_Sub)
+                    X_ReduceSum = ReduceSum <keepdims = 1> (X_Exp, axes)
+                    X_Log = Log (X_ReduceSum)
+                    output = Sub (X_Sub, X_Log)
+                )");
+
+              schema.BuildFunction(functionProto);
+              return true;
+            },
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Hardmax,
+    13,
+    OpSchema().FillUsing(SoftmaxFamilyDocGenerator(
+        "Hardmax",
+        "hardmax",
+        "Hardmax(element in input, axis) = 1 if the element is the first maximum value along the specified axis, 0 otherwise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Softsign,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_Softsign_ver1)
+        .Input(0, "input", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "The softsign (x/(1+|x|)) values of the input tensor computed element-wise",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            One = Constant <value = float {1.0}>()
+            OneCast = CastLike (One, input)
+            AbsInput = Abs(input)
+            OneAddAbsInput = Add (OneCast, AbsInput)
+            output = Div(input, OneAddAbsInput)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Softplus,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_Softplus_ver1)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+            {
+              exp_x = Exp (X)
+              one = Constant <value = float {1.0}>()
+              one_cast = CastLike (one, X)
+              exp_x_add_one = Add (exp_x, one_cast)
+              Y = Log (exp_x_add_one)
+            }
+            )ONNX",
+            18));
+
+static constexpr const char* Gemm_ver13_doc = R"DOC(General Matrix multiplication:
+https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+
+* A' = transpose(A) if transA else A
+* B' = transpose(B) if transB else B
+
+Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M),
+input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N),
+and output tensor Y has shape (M, N). A will be transposed before doing the
+computation if attribute transA is non-zero, same for B and transB.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gemm,
+    13,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(
+            std::string(Gemm_ver13_doc) + GenerateBroadcastingDocUni("tensor C", "tensor A * B") + "\n" +
+            GenerateOptionalArgumentsDoc()))
+        .Input(
+            0,
+            "A",
+            "Input tensor A. "
+            "The shape of A should be (M, K) if transA is 0, "
+            "or (K, M) if transA is non-zero.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "B",
+            "Input tensor B. "
+            "The shape of B should be (K, N) if transB is 0, "
+            "or (N, K) if transB is non-zero.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "C",
+            "Optional input tensor C. "
+            "If not specified, the computation is done as if C is a scalar 0. "
+            "The shape of C should be unidirectional broadcastable to (M, N).",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor of shape (M, N).", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::UInt32,
+             types::UInt64,
+             types::Int32,
+             types::Int64,
+             types::BFloat16},
+            "Constrain input and output types to float/int tensors.")
+        .Attr("transA", "Whether A should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("transB", "Whether B should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("alpha", "Scalar multiplier for the product of input tensors A * B.", AttributeProto::FLOAT, 1.0f)
+        .Attr("beta", "Scalar multiplier for input tensor C.", AttributeProto::FLOAT, 1.0f)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto transAAttr = ctx.getAttribute("transA");
+          bool transA = transAAttr ? static_cast<int>(transAAttr->i()) != 0 : false;
+          auto transBAttr = ctx.getAttribute("transB");
+          bool transB = transBAttr ? static_cast<int>(transBAttr->i()) != 0 : false;
+          // Gemm computes Y = alpha * A' * B' + beta * C
+          // A' is A or A^T depending on transA; B' is B or B^T depending on transB
+          Dim M, N, K;
+          if (transA) {
+            ctx.unifyInputShape(0, {K, M});
+          } else {
+            ctx.unifyInputShape(0, {M, K});
+          }
+          if (transB) {
+            ctx.unifyInputShape(1, {N, K});
+          } else {
+            ctx.unifyInputShape(1, {K, N});
+          }
+          // Output shape is (M, N)
+          updateOutputShape(ctx, 0, {M, N});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MatMul,
+    13,
+    OpSchema()
+        .Input(0, "A", "N-dimensional matrix A", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(1, "B", "N-dimensional matrix B", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Matrix multiply results from A * B", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::UInt32,
+             types::UInt64,
+             types::Int32,
+             types::Int64,
+             types::BFloat16},
+            "Constrain input and output types to float/int tensors.")
+        .SetDoc(kDoc_MatMul_ver9)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          defs::math::utils::MatMulShapeInference(ctx, 0, 1);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    TopK,
+    24,
+    OpSchema().FillUsing(defs::math::utils::TopKOpGenerator(OpSchema::all_numeric_types_ir4())));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sin,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Sin_ver7,
+            "The sine of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cos,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Cos_ver7,
+            "The cosine of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Tan,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Tan_ver7,
+            "The tangent of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Asin,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Asin_ver7,
+            "The arcsine of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Acos,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Acos_ver7,
+            "The arccosine of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Atan,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Atan_ver7,
+            "The arctangent of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Expand,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Expand_ver8)
+        .Input(0, "input", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "shape",
+            "A 1-D tensor indicates the shape you want to expand to, following the broadcast rule",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "output", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          // For shape inference, we need both input shape
+          if (hasNInputShapes(ctx, 2)) {
+            const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            bool found = false;
+            TensorShapeProto second_shape = getShapeInput(ctx, 1, found);
+            if (found) {
+              bidirectionalBroadcastShapeInference(input_shape, second_shape, *getOutputShape(ctx, 0));
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sinh,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Sinh_ver9,
+            "The hyperbolic sine values of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cosh,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Cosh_ver9,
+            "The hyperbolic cosine values of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Asinh,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Asinh_ver9,
+            "The hyperbolic arcsine values of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Acosh,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Acosh_ver9,
+            "The hyperbolic arccosine values of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Atanh,
+    22,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Atanh_ver9,
+            "The hyperbolic arctangent values of the input tensor computed element-wise")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sign,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Sign_ver9)
+        .Input(0, "input", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "The sign of the input tensor "
+            "computed element-wise. It has the same shape and type of the input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_numeric_types_ir4(),
+            "Constrain input and output types to all numeric tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Erf,
+    13,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Erf_ver9,
+            "The error function of the input tensor computed element-wise. "
+            "It has the same shape and type of the input.")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QLinearMatMul,
+    21,
+    OpSchema()
+        .SetDoc(defs::math::utils::QLinearMatMulDoc())
+        .Input(0, "a", "N-dimensional quantized matrix a", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Input(1, "a_scale", "scale of quantized input a", "TS", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "a_zero_point",
+            "zero point of quantized input a",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(3, "b", "N-dimensional quantized matrix b", "T2", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Input(4, "b_scale", "scale of quantized input b", "TS", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Input(
+            5,
+            "b_zero_point",
+            "zero point of quantized input b",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            6,
+            "y_scale",
+            "scale of quantized output y",
+            "TS",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            7,
+            "y_zero_point",
+            "zero point of quantized output y",
+            "T3",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "y",
+            "Quantized matrix multiply results from a * b",
+            "T3",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("TS", {types::Float, types::Float16, types::BFloat16}, "Constrain scales.")
+        .TypeConstraint(
+            "T1",
+            {types::Int8,
+             types::UInt8,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "The type of input a and its zeropoint.")
+        .TypeConstraint(
+            "T2",
+            {types::Int8,
+             types::UInt8,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "The type of input b and its zeropoint.")
+        .TypeConstraint(
+            "T3",
+            {types::Int8,
+             types::UInt8,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "The type of the output and its zeropoint.")
+        .TypeAndShapeInferenceFunction(defs::math::utils::QLinearMatMulShapeInference));
+
+static constexpr const char* MatMulInteger_ver10_doc = R"DOC(
+Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+The production MUST never overflow. The accumulation may overflow if and only if in 32 bits.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MatMulInteger,
+    10,
+    OpSchema()
+        .SetDoc(MatMulInteger_ver10_doc)
+        .Input(0, "A", "N-dimensional matrix A", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Input(1, "B", "N-dimensional matrix B", "T2", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "a_zero_point",
+            "Zero point tensor for input 'A'. It's optional and default value is 0. It could be a scalar or N-D tensor. "
+            "Scalar refers to per tensor quantization whereas N-D refers to per row quantization. "
+            "If the input is 2D of shape [M, K] then zero point tensor may be an M element vector [zp_1, zp_2, ..., zp_M]. "
+            "If the input is N-D tensor with shape [D1, D2, M, K] then zero point tensor may have shape [D1, D2, M, 1]. ",
+            "T1",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            3,
+            "b_zero_point",
+            "Zero point tensor for input 'B'. It's optional and default value is 0. It could be a scalar or a N-D tensor, "
+            "Scalar refers to per tensor quantization whereas N-D refers to per col quantization. "
+            "If the input is 2D of shape [K, N] then zero point tensor may be an N element vector [zp_1, zp_2, ..., zp_N]. "
+            "If the input is N-D tensor with shape [D1, D2, K, N] then zero point tensor may have shape [D1, D2, 1, N]. ",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "Y",
+            "Matrix multiply results from A * B",
+            "T3",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T1", {types::Int8, types::UInt8}, "Constrain input A data type to 8-bit integer tensor.")
+        .TypeConstraint("T2", {types::Int8, types::UInt8}, "Constrain input B data type to 8-bit integer tensor.")
+        .TypeConstraint("T3", {types::Int32}, "Constrain output Y data type as 32-bit integer tensor.")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto a_type = ctx.getInputType(0);
+          auto b_type = ctx.getInputType(1);
+          auto y_type = ctx.getOutputType(0);
+          if (nullptr == a_type || nullptr == b_type || nullptr == y_type ||
+              a_type->value_case() != ONNX_NAMESPACE::TypeProto::kTensorType ||
+              b_type->value_case() != ONNX_NAMESPACE::TypeProto::kTensorType) {
+            fail_type_inference("inputs are expected to have tensor type and output type should not be null.");
+          }
+
+          // Right now we only support int32
+          y_type->mutable_tensor_type()->set_elem_type(ONNX_NAMESPACE::TensorProto::INT32);
+
+          defs::math::utils::MatMulShapeInference(ctx, 0, 1);
+        }));
+
+static const char* const CumProd_ver26_doc = R"DOC(
+Performs cumulative product of the input elements along the given axis.
+By default, it will do the product inclusively meaning the first element is copied as is.
+Through an `exclusive` attribute, this behavior can change to exclude the first element.
+It can also perform product in the opposite direction of the axis. For that, set `reverse` attribute to 1.
+
+Example:
+```
+input_x = [1, 2, 3]
+axis=0
+output = [1, 2, 6]
+exclusive=1
+output = [1, 1, 2]
+exclusive=0
+reverse=1
+output = [6, 6, 3]
+exclusive=1
+reverse=1
+output = [6, 3, 1]
+```
+ )DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CumProd,
+    26,
+    OpSchema()
+        .SetDoc(CumProd_ver26_doc)
+        .Attr(
+            "exclusive",
+            "If set to 1 will return exclusive product in which the top element is not included."
+            " In other terms, if set to 1, the j-th output element would be the product of the first (j-1) elements."
+            " Otherwise, it would be the product of the first j elements.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "reverse",
+            "If set to 1 will perform the products in reverse direction.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "x",
+            "An input tensor that is to be processed.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "axis",
+            "A 0-D tensor. Must be in the range [-rank(x), rank(x)-1]. "
+            "Negative value means counting dimensions from the back.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "y",
+            "Output tensor of the same type as 'x' with cumulative products of the x's elements",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::numeric_types_for_math_reduction_ir4(),
+            "Constrain input and output types to numeric tensors.")
+        .TypeConstraint("T2", {types::Int32, types::Int64}, "axis tensor can be int32 or int64 only")
+        .TypeAndShapeInferenceFunction(ONNX_NAMESPACE::propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CumSum,
+    14,
+    OpSchema()
+        .SetDoc(kDoc_CumSum_ver11)
+        .Attr(
+            "exclusive",
+            "If set to 1 will return exclusive sum in which the top element is not included."
+            " In other terms, if set to 1, the j-th output element would be the sum of the first (j-1) elements."
+            " Otherwise, it would be the sum of the first j elements.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "reverse",
+            "If set to 1 will perform the sums in reverse direction.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "x",
+            "An input tensor that is to be processed.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "axis",
+            "A 0-D tensor. Must be in the range [-rank(x), rank(x)-1]. "
+            "Negative value means counting dimensions from the back.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "y",
+            "Output tensor of the same type as 'x' with cumulative sums of the x's elements",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::numeric_types_for_math_reduction_ir4(),
+            "Constrain input and output types to numeric tensors.")
+        .TypeConstraint("T2", {types::Int32, types::Int64}, "axis tensor can be int32 or int64 only")
+        .TypeAndShapeInferenceFunction(ONNX_NAMESPACE::propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Round,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_Round_ver11)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Det,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_Det_ver11)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_float_types_ir4(),
+            "Constrain input and output types to floating-point tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference: input [..., M, M] -> output [...]
+          if (hasInputShape(ctx, 0)) {
+            const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            const int rank = static_cast<int>(input_shape.dim_size());
+
+            if (rank < 2) {
+              fail_shape_inference("Input rank must be >= 2.");
+            }
+
+            // Validate the inner-most 2 dims are square
+            Dim M;
+            unifyDim(input_shape.dim(rank - 2), M);
+            unifyDim(input_shape.dim(rank - 1), M);
+
+            // Output is the batch prefix (all dims except the last 2)
+            TensorShapeProto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+            for (int i = 0; i < rank - 2; ++i) {
+              *output_shape->add_dim() = input_shape.dim(i);
+            }
+          }
+        }));
+
+static bool BuildContextDependentFunctionBody(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  if (ctx.getInputType(0) == nullptr) {
+    // we cannot create a correct function body without knowing the input type
+    return false;
+  }
+  auto input_type = ctx.getInputType(0)->tensor_type().elem_type();
+  bool float_input = input_type == TensorProto_DataType_FLOAT;
+  const auto* const reduction_attr_proto = ctx.getAttribute("reduction");
+  std::string reduction_attr =
+      reduction_attr_proto != nullptr && reduction_attr_proto->has_s() ? reduction_attr_proto->s() : "mean";
+
+  FunctionBuilder builder(functionProto);
+  builder.Const1D("const_zero", static_cast<int64_t>(0))
+      .Const1D("const_one", static_cast<int64_t>(1))
+      .Const1D("axes", static_cast<int64_t>(1))
+      .Add("expanded_target = Unsqueeze (target, axes)");
+
+  if (ctx.getAttribute("ignore_index") == nullptr) {
+    builder.Add(R"(
+      input_gather_element = GatherElements <axis = 1> (input, expanded_target)
+      loss_NCdd = Neg (input_gather_element)
+      loss_N1dd = Slice (loss_NCdd, const_zero, const_one, const_one)
+    )");
+
+    if (!ctx.hasInput(2)) {
+      if (reduction_attr == "none") {
+        builder.Add("loss = Squeeze (loss_N1dd, axes)");
+      } else {
+        builder.Add("loss_Ndd = Squeeze (loss_N1dd, axes)");
+        if (reduction_attr == "mean") {
+          builder.Add("loss = ReduceMean <keepdims = 0> (loss_Ndd)");
+        } else {
+          builder.Add("loss = ReduceSum <keepdims = 0> (loss_Ndd)");
+        }
+      }
+    } else {
+      builder.Add("weight_gather = Gather (weight, target)");
+      builder.Add("loss_unweighted = Squeeze (loss_N1dd, axes)");
+      if (reduction_attr == "none") {
+        builder.Add("loss = Mul (loss_unweighted, weight_gather)");
+      } else {
+        builder.Add("loss_Ndd = Mul (loss_unweighted, weight_gather)");
+        if (reduction_attr == "mean") {
+          builder.Add(R"(
+            loss_sum = ReduceSum <keepdims = 0> (loss_Ndd)
+            weight_gather_sum = ReduceSum <keepdims = 0> (weight_gather)
+            loss = Div (loss_sum, weight_gather_sum)
+          )");
+        } else {
+          builder.Add("loss = ReduceSum <keepdims = 0> (loss_Ndd)");
+        }
+      }
+    }
+  } else {
+    builder.Const1D("const_ignore_index", ctx.getAttribute("ignore_index")->i());
+    builder.Add(R"(
+      const_zero_target_typed = Sub (expanded_target, expanded_target)
+      expanded_target_int64 = Cast <to = 7> (expanded_target)
+      mask = Equal (expanded_target_int64, const_ignore_index)
+      transform_targets = Where (mask, const_zero_target_typed, expanded_target)
+    )");
+    builder.Add("input_gather_element = GatherElements <axis = 1> (input, transform_targets)");
+    builder.Const1D("const_zero_float", 0.0f);
+    if (!float_input) {
+      builder.Add("const_zero_casted = Cast (const_zero_float)", "to", static_cast<int64_t>(input_type))
+          .Add("input_gather_element_transform = Where (mask, const_zero_casted, input_gather_element)");
+    } else {
+      builder.Add("input_gather_element_transform = Where (mask, const_zero_float, input_gather_element)");
+    }
+    builder.Add("loss_NCdd = Neg (input_gather_element_transform)");
+    builder.Add("loss_N1dd = Slice (loss_NCdd, const_zero, const_one, const_one)");
+
+    if (!ctx.hasInput(2)) {
+      builder.Add("squeeze_mask = Squeeze (mask, axes)");
+      builder.Const1D("const_one_float", 1.0f);
+      if (!float_input) {
+        builder.Add("const_one_casted = Cast (const_one_float)", "to", static_cast<int64_t>(input_type))
+            .Add("weight_gather = Where (squeeze_mask, const_zero_casted, const_one_casted)");
+      } else {
+        builder.Add("weight_gather = Where (squeeze_mask, const_zero_float, const_one_float)");
+      }
+
+    } else {
+      builder.Add("weight_gather_temp = Gather (weight, transform_targets)");
+      builder.Add(
+          float_input ? "weight_gather_temp_1 = Where (mask, const_zero_float, weight_gather_temp)"
+                      : "weight_gather_temp_1 = Where (mask, const_zero_casted, weight_gather_temp)");
+      builder.Add("weight_gather = Squeeze (weight_gather_temp_1, axes)");
+    }
+
+    builder.Add("loss_unweighted = Squeeze (loss_N1dd, axes)");
+    if (reduction_attr == "none") {
+      builder.Add("loss = Mul (loss_unweighted, weight_gather)");
+    } else {
+      builder.Add("loss_Ndd = Mul (loss_unweighted, weight_gather)");
+      if (reduction_attr == "mean") {
+        builder.Add(R"(
+            loss_sum = ReduceSum <keepdims = 0> (loss_Ndd)
+            weight_gather_sum = ReduceSum <keepdims = 0> (weight_gather)
+            loss = Div (loss_sum, weight_gather_sum)
+        )");
+      } else {
+        builder.Add("loss = ReduceSum <keepdims = 0> (loss_Ndd)");
+      }
+    }
+  }
+
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    NegativeLogLikelihoodLoss,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_NegativeLogLikelihoodLoss_ver13)
+        .Input(
+            0,
+            "input",
+            "Input tensor of shape (N, C) or (N, C, d1, d2, ..., dk).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "target",
+            "Target tensor of shape (N) or (N, d1, d2, ..., dk). Target element value shall be in range of [0, C). "
+            "If ignore_index is specified, it may have a value outside [0, C) and the target values should either be "
+            "in the range [0, C) or have the value ignore_index.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "weight",
+            "Optional rescaling weight tensor. "
+            "If given, it has to be a tensor of size C. Otherwise, it is treated as if having all ones.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "loss", "The negative log likelihood loss", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Attr(
+            "reduction",
+            "Type of reduction to apply to loss: none, sum, mean (default). "
+            "'none': the output is the loss for each sample. "
+            "'sum': the output will be summed. "
+            "'mean': the sum of the output will be divided by the sum of applied weights.",
+            AttributeProto::STRING,
+            std::string("mean"))
+        .Attr(
+            "ignore_index",
+            "Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.",
+            AttributeProto::INT,
+            false)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_float_types_ir4(),
+            "Constrain input, weight, and output types to floating-point tensors.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain target to integer types")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBody)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          // input: [N, C, d1, ..., dk], target: [N, d1, ..., dk], weight (optional): [C]
+          if (!hasNInputShapes(ctx, 2)) {
+            return;
+          }
+
+          const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+
+          const int input_rank = static_cast<int>(input_shape.dim_size());
+          const int target_rank = input_rank - 1;
+
+          if (input_rank < 2) {
+            fail_shape_inference("Input rank must be >= 2. input_rank=", input_rank);
+          }
+          checkInputRank(ctx, 1, target_rank);
+
+          // input: [N, C, d1, ..., dk], target: [N, d1, ..., dk]
+          // Build dims array for target shape: [N, d1, ..., dk]
+          Dim C;
+          std::vector<Dim> target_dims(target_rank);
+          // Unify target dims against both inputs
+          for (int i = 0; i < target_rank; i++) {
+            unifyInputDim(ctx, 1, i, target_dims[i]);
+            // input[0]=N matches target[0], input[2..]=d1..dk matches target[1..]
+            int input_i = (i == 0) ? 0 : i + 1;
+            unifyInputDim(ctx, 0, input_i, target_dims[i]);
+          }
+          unifyInputDim(ctx, 0, 1, C);
+
+          // Optional weight input: shape [C]
+          if (ctx.getNumInputs() == 3 && hasInputShape(ctx, 2)) {
+            ctx.unifyInputShape(2, {C});
+          }
+
+          if (getAttribute(ctx, "reduction", "mean") == "none") {
+            // output tensor is of shape (N, d1, d2, ..., dk)
+            TensorShapeProto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+            for (int i = 0; i < target_rank; i++) {
+              *output_shape->add_dim() = target_dims[i];
+            }
+          } else {
+            // output is a scalar (empty shape)
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          }
+        }));
+
+static void einsumShapeInference(ONNX_NAMESPACE::InferenceContext& ctx, std::string const& equation) {
+  // Only accept letters for indices
+  auto is_letter = [](char c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); };
+
+  const size_t num_inputs = ctx.getNumInputs();
+  if (num_inputs < 1 || !hasNInputShapes(ctx, num_inputs)) {
+    return;
+  }
+  ONNX_NAMESPACE::TensorShapeProto output_shape;
+  std::string left_equation;
+
+  auto mid_index = equation.find("->");
+  if (mid_index != std::string::npos) {
+    // Separate right and left hand sides of the equation
+    left_equation = equation.substr(0, mid_index);
+  } else {
+    // No right hand side
+    left_equation = equation;
+  }
+
+  std::string term;
+  size_t num_operands = 0;
+  size_t num_ellipsis = 0;
+  size_t num_ellipsis_indices = 0;
+
+  // Parse the left-hand side
+  std::stringstream str(left_equation);
+  std::map<char, size_t> label_maps;
+  std::unordered_set<char> repeated_labels;
+  ONNX_NAMESPACE::TensorShapeProto dims_value, ellipsis_dims_value;
+  size_t num_labels = 0;
+  bool ellipsis_flag = true;
+
+  while (!str.eof()) {
+    std::getline(str, term, ',');
+    auto ellipsis_index = term.find("...");
+    if (num_inputs <= num_operands) {
+      fail_shape_inference("Number of input tensors does not match the operands in the equation.");
+    }
+    const auto& shape = ctx.getInputType(num_operands)->tensor_type().shape();
+    size_t rank = shape.dim_size();
+    size_t ellipsis_dims = 0;
+
+    size_t term_size = 0; // number of legal indices for the current term
+    size_t num_illegal_char = 0; // number of illegal char before the current 'index' in the current term
+
+    for (char index : term) {
+      if (is_letter(index)) {
+        term_size += 1;
+      }
+    }
+
+    // Validate that term_size is compatible with rank before accessing dimensions
+    if (ellipsis_index != std::string::npos) {
+      // For ellipsis case, rank must be at least term_size
+      if (rank < term_size) {
+        fail_shape_inference(
+            "Ellipsis represents incompatible dimensions for input ",
+            num_operands,
+            ". Rank ",
+            rank,
+            " is less than term size ",
+            term_size,
+            ".");
+      }
+    } else {
+      // For non-ellipsis case, rank must equal term_size
+      if (rank != term_size) {
+        fail_shape_inference(
+            "Rank of input ", num_operands, " (", rank, ") does not match the equation indices (", term_size, ").");
+      }
+    }
+
+    for (size_t index = 0; index < term.size(); ++index) {
+      if (index == ellipsis_index) {
+        // find ellipsis and record the dims represented by ellipsis
+        ellipsis_dims = rank - term_size;
+        if (ellipsis_flag) {
+          ellipsis_flag = false;
+          for (size_t i = 0; i < ellipsis_dims; i++) {
+            *ellipsis_dims_value.add_dim() = shape.dim(index + i - num_illegal_char);
+          }
+        } else {
+          for (size_t i = 0; i < ellipsis_dims; i++) {
+            const auto shape_dim = shape.dim(index + i - num_illegal_char);
+            auto* const current_dim = ellipsis_dims_value.mutable_dim(i);
+            if (shape_dim.has_dim_value() && current_dim->has_dim_value() &&
+                shape_dim.dim_value() > current_dim->dim_value() && current_dim->dim_value() == 1) {
+              current_dim->set_dim_value(shape_dim.dim_value());
+            }
+          }
+        }
+        index += 2; // skip the rest of dots
+        num_illegal_char += 3;
+        continue;
+
+      } else if (!is_letter(term[index])) {
+        num_illegal_char += 1;
+        continue;
+      }
+
+      const auto inserted = label_maps.emplace(term[index], num_labels).second;
+      if (inserted) {
+        *dims_value.add_dim() = shape.dim(index + ellipsis_dims - num_illegal_char);
+        ++num_labels;
+      } else {
+        repeated_labels.insert(term[index]);
+      }
+    }
+
+    if (ellipsis_index != std::string::npos) {
+      // If there is an ellipsis, the number of dimensions it represents
+      // must be total dim - letter dimensions
+      if (num_ellipsis == 0) {
+        num_ellipsis_indices = rank - term_size;
+      } else { // ellipsis has been seen before. Check that if dimensions
+               // are compatible
+        if (num_ellipsis_indices != rank - term_size) {
+          fail_shape_inference("Ellipsis represents incompatible dimensions.");
+        }
+      }
+      num_ellipsis++;
+    }
+    num_operands++;
+  }
+
+  if (num_inputs != num_operands) {
+    fail_shape_inference("Number of input tensors does not match the operands in the equation.");
+  }
+
+  // Parse the provided right-hand side
+  if (mid_index != std::string::npos) {
+    std::string right_equation = equation.substr(mid_index + 2);
+    auto right_ellipsis_index = right_equation.find("...");
+
+    for (size_t index = 0; index < right_equation.size(); ++index) {
+      // If there's an ellipsis, add its corresponding dimensions
+      if (index == right_ellipsis_index) {
+        for (size_t i = 0; i < num_ellipsis_indices; i++) {
+          *output_shape.add_dim() = ellipsis_dims_value.dim(i);
+        }
+        index += 2; // skip the rest of dots
+        continue;
+      }
+
+      if (is_letter(right_equation[index])) {
+        *output_shape.add_dim() = dims_value.dim(label_maps[right_equation[index]]);
+      }
+    }
+  } else { // Infer the dimension for right-hand side
+    // If there's an ellipsis, add its corresponding dimensions
+    for (size_t i = 0; i < num_ellipsis_indices; i++) {
+      *output_shape.add_dim() = ellipsis_dims_value.dim(i);
+    }
+    // If no explicit output was given, generate an implicit output by ordering all the
+    // labels in alphabetic order (by ASCII value consistent with numpy, so Z < a).
+    // Exclude any labels that occurred more than once, as these cancel out.
+    for (const auto& [label, dim_idx] : label_maps) {
+      if (repeated_labels.count(label) == 0) {
+        *output_shape.add_dim() = dims_value.dim(dim_idx);
+      }
+    }
+  }
+
+  updateOutputShape(ctx, 0, output_shape);
+}
+
+static constexpr const char* Einsum_ver12_doc = R"DOC(
+An einsum of the form `term1, term2 -> output-term` produces an output tensor using the following equation
+
+```
+output[output-term] = reduce-sum( input1[term1] * input2[term2] )
+```
+
+where the reduce-sum performs a summation over all the indices occurring in the input terms (term1, term2)
+that do not occur in the output-term.
+
+The Einsum operator evaluates algebraic tensor operations on a sequence of tensors, using the Einstein summation
+convention. The equation string contains a comma-separated sequence of lower case letters. Each term corresponds to
+an operand tensor, and the characters within the terms correspond to operands dimensions.
+
+This sequence may be followed by "->" to separate the left and right hand side of the equation.
+If the equation contains "->" followed by the right-hand side, the explicit (not classical) form of the Einstein
+summation is performed, and the right-hand side indices indicate output tensor dimensions. In other cases,
+output indices are (implicitly) set to the alphabetically sorted sequence of indices appearing exactly once in the
+equation.
+
+When a dimension character is repeated in the left-hand side, it represents summation along the dimension.
+
+The equation may contain ellipsis ("...") to enable broadcasting. Ellipsis must indicate a fixed number of dimensions.
+Specifically, every occurrence of ellipsis in the equation must represent the same number of dimensions.
+The right-hand side may contain exactly one ellipsis. In implicit mode, the ellipsis dimensions are set to the
+beginning of the output. The equation string may contain space (U+0020) character.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Einsum,
+    12,
+    OpSchema()
+        .SetDoc(Einsum_ver12_doc)
+        .Attr("equation", "Einsum expression string.", AttributeProto::STRING)
+        .Input(0, "Inputs", "Operands", "T", OpSchema::Variadic, true, 1, OpSchema::Differentiable)
+        .Output(0, "Output", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_numeric_types(),
+            "Constrain input and output types to all numerical tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          std::string equation = getAttribute(ctx, "equation", "");
+          if (equation.empty()) {
+            return;
+          }
+
+          equation.erase(std::remove(equation.begin(), equation.end(), ' '),
+                         equation.end()); // Remove space char
+          einsumShapeInference(ctx, equation);
+        }));
+
+static constexpr const char* reduction_doc_sce =
+    "Type of reduction to apply to loss: none, sum, mean(default). "
+    "'none': no reduction will be applied, "
+    "'sum': the output will be summed. "
+    "'mean': the sum of the output will be divided by the number of "
+    "elements in the output.";
+
+static constexpr const char* SoftmaxCrossEntropyLoss_ver13_doc =
+    R"DOC(Loss function that measures the softmax cross entropy
+between 'scores' and 'labels'.
+This operator first computes a loss tensor whose shape is identical to the labels input.
+If the input is 2-D with shape (N, C), the loss tensor may be a N-element vector L = (l_1, l_2, ..., l_N).
+If the input is N-D tensor with shape (N, C, D1, D2, ..., Dk),
+the loss tensor L may have (N, D1, D2, ..., Dk) as its shape and L[i,][j_1][j_2]...[j_k] denotes a scalar element in L.
+After L is available, this operator can optionally do a reduction operator.
+
+* shape(scores): (N, C) where C is the number of classes, or (N, C, D1, D2,..., Dk),
+  with K >= 1 in case of K-dimensional loss.
+* shape(labels): (N) where each value is 0 <= labels[i] <= C-1, or (N, D1, D2,..., Dk),
+  with K >= 1 in case of K-dimensional loss.
+
+The loss for one sample, l_i, can calculated as follows:
+```
+l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk], where i is the index of classes.
+```
+or
+```
+l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk] * weights[c], if 'weights' is provided.
+```
+
+loss is zero for the case when label-value equals ignore_index.
+```
+l[i][d1][d2]...[dk]  = 0, when labels[n][d1][d2]...[dk] = ignore_index
+```
+
+where:
+```
+p = Softmax(scores)
+y = Log(p)
+c = labels[i][d1][d2]...[dk]
+```
+
+Finally, L is optionally reduced:
+
+* If reduction = 'none', the output is L with shape (N, D1, D2, ..., Dk).
+* If reduction = 'sum', the output is scalar: Sum(L).
+* If reduction = 'mean', the output is scalar: ReduceMean(L), or if weight is provided: `ReduceSum(L) / ReduceSum(W)`,
+  where tensor W is of shape `(N, D1, D2, ..., Dk)` and `W[n][d1][d2]...[dk] = weights[labels[i][d1][d2]...[dk]]`.
+)DOC";
+
+static bool BuildContextDependentFunctionBodySCE(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  FunctionBuilder builder(functionProto);
+  // Using stable implementation of LogSoftmax
+  builder //
+      .Const("Shape3D", std::vector<int64_t>({0, 0, -1})) //
+      .Add(R"(
+        X_NCD = Reshape (scores, Shape3D)
+        X_NDC = Transpose <perm = [0, 2, 1]> (X_NCD)
+        X_LogSM = LogSoftmax <axis = 2> (X_NDC)
+        X_LogSM_NCD = Transpose <perm = [0, 2, 1]> (X_LogSM)
+        X_shape = Shape (scores)
+        X_Log = Reshape (X_LogSM_NCD, X_shape)
+      )");
+
+  // Review(mzs): Ideally we want to reuse the output from Log for sub-graph
+  // output as well but looking at the graph resolve code it does not include
+  // graph outputs as intermediate outputs, hence if intermediate X_log is
+  // renamed as log_prob then it will be treated as graph output and will not be
+  // available to NegativeLogLikelihoodLoss. May be my understanding is
+  // incorrect or there is a bug in function population code in ORTbut I will
+  // dig further to be 100%. In the meantime we just replicate the log.
+  if (ctx.hasOutput(1)) {
+    builder.Add("log_prob = Identity (X_Log)");
+  }
+
+  builder.Add(
+      ctx.hasInput(2)
+          ? "output = NegativeLogLikelihoodLoss <reduction : string = @reduction, ignore_index : int = @ignore_index> (X_Log, labels, weights)"
+          : "output = NegativeLogLikelihoodLoss <reduction : string = @reduction, ignore_index : int = @ignore_index> (X_Log, labels)");
+
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SoftmaxCrossEntropyLoss,
+    13,
+    OpSchema()
+        .SetDoc(SoftmaxCrossEntropyLoss_ver13_doc)
+        .Attr("reduction", reduction_doc_sce, AttributeProto::STRING, std::string("mean"))
+        .Attr(
+            "ignore_index",
+            "Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.",
+            AttributeProto::INT,
+            false)
+        .Input(
+            0,
+            "scores",
+            "The predicted outputs with shape [batch_size, class_size], or "
+            "[batch_size, class_size, D1, D2 , ..., Dk], where K is the number of dimensions.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "labels",
+            "The ground truth output tensor, with shape [batch_size], or "
+            "[batch_size, D1, D2, ..., Dk], where K is the number of dimensions. "
+            "Labels element value shall be in range of [0, C). "
+            "If ignore_index is specified, it may have a value outside [0, C) and the label values should either be "
+            "in the range [0, C) or have the value ignore_index.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "weights",
+            "A manual rescaling weight given to each class. If given, it has to "
+            "be a 1D Tensor assigning weight to each of the classes. Otherwise, "
+            "it is treated as if having all ones.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Weighted loss float Tensor. If reduction is 'none', this has the "
+            "shape of [batch_size], or [batch_size, D1, D2, ..., Dk] in case of "
+            "K-dimensional loss. Otherwise, it is a scalar.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            1,
+            "log_prob",
+            "Log probability tensor. If the output of softmax is prob, its value is log(prob).",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain target to integer types")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBodySCE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          std::string reduction = getAttribute(ctx, "reduction", "mean");
+          if (reduction == "none") {
+            if (hasInputShape(ctx, 1)) {
+              propagateShapeFromInputToOutput(ctx, 1, 0);
+            }
+          } else {
+            updateOutputShape(ctx, 0, TensorShapeProto());
+          }
+
+          if (ctx.getNumOutputs() == 2) {
+            propagateElemTypeFromInputToOutput(ctx, 0, 1);
+            propagateShapeFromInputToOutput(ctx, 0, 1);
+          }
+        }));
+
+static constexpr const char* DFT_ver20_doc =
+    R"DOC(Computes the discrete Fourier Transform (DFT) of the input.
+
+Assuming the input has shape `[M, N]`, where `N` is the dimension over which the
+DFT is computed and `M` denotes the conceptual "all other dimensions,"
+the DFT `y[m, k]` of shape `[M, N]` is defined as
+
+$$y[m, k] = \sum_{n=0}^{N-1} e^{-2 \pi j \frac{k n}{N} } x[m, n] ,$$
+
+and the inverse transform is defined as
+
+$$x[m, n] = \frac{1}{N} \sum_{k=0}^{N-1} e^{2 \pi j \frac{k n}{N} } y[m, k] ,$$
+
+where $j$ is the imaginary unit.
+
+The actual shape of the output is specified in the "output" section.
+
+Reference: https://docs.scipy.org/doc/scipy/tutorial/fft.html
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DFT,
+    20,
+    OpSchema()
+        .SetDoc(DFT_ver20_doc)
+        .Attr(
+            "onesided",
+            "If `onesided` is `1`, only values for `k` in `[0, 1, 2, ..., floor(n_fft/2) + 1]` are used or returned "
+            "because the real-to-complex Fourier transform satisfies the conjugate symmetry, i.e., `X[m, k] = X[m, n_fft-k]*`, "
+            "where `m` denotes \"all other dimensions\" DFT was not applied on. "
+            "When `onesided=1` and `inverse=0` (forward DFT), only real input is supported and a one-sided complex spectrum is returned (RFFT). "
+            "When `onesided=1` and `inverse=1` (inverse DFT), only complex input is supported and a full real signal is returned (IRFFT). "
+            "Value can be `0` or `1`. Default is `0`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "inverse",
+            "Whether to perform the inverse discrete Fourier Transform. Default is 0, which corresponds to `false`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "input",
+            "For real input, the following shape is expected: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][1]`. "
+            "For complex input, the following shape is expected: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][2]`. "
+            "The final dimension represents the real and imaginary parts of the value in that order.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            1,
+            "dft_length",
+            "The length of the signal as a scalar. "
+            "If greater than the axis dimension, the signal will be zero-padded up to `dft_length`. "
+            "If less than the axis dimension, only the first `dft_length` values will be used as the signal. "
+            "If not provided, the default `dft_length = signal_dim_axis`, except for the IRFFT case (`onesided=1`, `inverse=1`), in which case the default dft_length is `2 * (signal_dim_axis - 1)`.",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "axis",
+            "The axis as a scalar on which to perform the DFT. Default is `-2` (last signal axis). "
+            "Negative value means counting dimensions from the back. Accepted range is $[-r, -2] \\cup [0, r-2]$ where `r = rank(input)`. "
+            "The last dimension is for representing complex numbers and thus is an invalid axis.",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "The Fourier Transform of the input vector. "
+            "For standard DFT (`onesided=0`), the output shape is: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][2]` (complex), with `signal_dim_axis = dft_length`. "
+            "For RFFT (`onesided=1`, `inverse=0`), the output shape is: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][2]` (one-sided complex), with `signal_dim_axis = floor(dft_length/2) + 1`. "
+            "For IRFFT (`onesided=1`, `inverse=1`), the output shape is: `[signal_dim0][signal_dim1][signal_dim2]...[signal_dimN][1]` (real), where `signal_dim_axis = dft_length`.",
+            "T1")
+        .TypeConstraint("T1", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeConstraint("T2", {types::Int32, types::Int64}, "Constrain scalar length types to integers.")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          bool is_onesided = static_cast<bool>(getAttribute(ctx, "onesided", 0));
+          bool inverse = static_cast<bool>(getAttribute(ctx, "inverse", 0));
+
+          const size_t input_arg_index = 0;
+          const size_t dft_length_arg_index = 1;
+          const size_t axis_arg_index = 2;
+          const size_t output_index = 0;
+
+          propagateElemTypeFromInputToOutput(ctx, input_arg_index, output_index);
+          if (!hasInputShape(ctx, input_arg_index)) {
+            // If no shape is available for the input, skip shape inference...
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, input_arg_index);
+
+          // The last dimension is the real and imaginary parts of the value.
+          const int64_t rank = input_shape.dim_size();
+          if (rank < 2) {
+            fail_shape_inference("input tensor must have rank >= 2, including the complex dimension.");
+          }
+
+          // check the inputs are correct types for one-sided DFT
+          if (is_onesided) {
+            auto last_dim = input_shape.dim(rank - 1);
+            if (inverse) {
+              // Check last dimension is 2 (complex input required)
+              if (last_dim.has_dim_value() && last_dim.dim_value() != 2) {
+                fail_shape_inference("inverse one-sided DFT requires complex input (last dimension must be 2)");
+              }
+            } else {
+              // Check last dimension is 1 (real input required)
+              if (last_dim.has_dim_value() && last_dim.dim_value() != 1) {
+                fail_shape_inference("one-sided DFT requires real input (last dimension must be 1)");
+              }
+            }
+          }
+
+          // In general the output shape will match the input shape exactly
+          // So initialize the output shape with the input shape
+          TensorShapeProto result_shape_proto = input_shape;
+
+          // Handle when axis is an input but is not statically known
+          if (ctx.hasInput(axis_arg_index) && ctx.getInputData(axis_arg_index) == nullptr) {
+            // Axis is an input but is not statically known
+            if (is_onesided || ctx.hasInput(dft_length_arg_index)) {
+              // We don't know which axis is the signal dimension, so we cannot infer shape
+              // when onesided is enabled or when dft_length_arg_index is provided
+              TensorShapeProto new_shape_proto{};
+              for (int i = 0; i < rank; ++i) {
+                new_shape_proto.add_dim();
+              }
+              // Set last dimension based on operation type
+              ONNX_ASSERTM(
+                  rank == static_cast<int64_t>(new_shape_proto.dim_size()),
+                  "rank should be equal to new_shape_proto.dim_size()")
+              if (inverse && is_onesided) {
+                // IRFFT: output is real-valued
+                new_shape_proto.mutable_dim(rank - 1)->set_dim_value(1);
+              } else {
+                // Complex output
+                new_shape_proto.mutable_dim(rank - 1)->set_dim_value(2);
+              }
+              updateOutputShape(ctx, output_index, new_shape_proto);
+              return;
+            } else {
+              // Set last dimension based on operation type
+              int dim_size = result_shape_proto.dim_size();
+              if (inverse && is_onesided) {
+                // IRFFT: output is real-valued
+                result_shape_proto.mutable_dim(dim_size - 1)->set_dim_value(1);
+              } else {
+                // Complex output
+                result_shape_proto.mutable_dim(dim_size - 1)->set_dim_value(2);
+              }
+              updateOutputShape(ctx, output_index, result_shape_proto);
+              return;
+            }
+          }
+
+          // Get the axis where the DFT will be performed
+          int64_t axis;
+          if (!ctx.hasInput(axis_arg_index)) {
+            // axis is not an input. We use -2 by default
+            axis = -2;
+          } else {
+            const TensorProto* axis_tensor = ctx.getInputData(axis_arg_index);
+            ONNX_ASSERTM(axis_tensor != nullptr, "axis should not be nullptr at this point")
+            // TODO(justinchuby): Create invariance checking functions to ensure shapes and sizes
+            // to abstract the following logic out.
+            if (axis_tensor->dims_size() != 0) {
+              fail_shape_inference("axis input must be a scalar.");
+            }
+            axis = defs::math::utils::GetScalarValueFromTensor<int64_t>(axis_tensor);
+          }
+
+          // NOLINTNEXTLINE(readability-simplify-boolean-expr)
+          if (!(-rank <= axis && axis != -1 && axis < rank - 1)) {
+            fail_shape_inference(
+                "axis attribute value ",
+                axis,
+                " is invalid for a tensor of rank ",
+                rank,
+                ". Valid values are '-rank <= axis && axis != -1 && axis < rank - 1'");
+          }
+
+          auto axis_idx = (axis >= 0 ? axis : axis + rank);
+
+          // If dft_length is specified, then we should honor the shape.
+          // Set the output dimension to match the dft_length on the axis.
+          if (ctx.hasInput(dft_length_arg_index)) {
+            // dft_length is provided
+            const TensorProto* dft_length = ctx.getInputData(dft_length_arg_index);
+            if (dft_length == nullptr) {
+              // If we cannot read the dft_length, we cannot infer shape on the signal axis
+              result_shape_proto.mutable_dim(axis_idx)->clear_dim_value();
+            } else {
+              if (dft_length->dims_size() != 0) {
+                fail_shape_inference("dft_length input must be a scalar.");
+              }
+              auto dft_length_value = defs::math::utils::GetScalarValueFromTensor<int64_t>(dft_length);
+
+              // For RFFT, output size on signal axis is floor(dft_length/2) + 1
+              if (is_onesided && !inverse) {
+                // RFFT: one-sided output
+                auto half_signal_size = (dft_length_value >> 1) + 1;
+                result_shape_proto.mutable_dim(axis_idx)->set_dim_value(half_signal_size);
+              } else {
+                // Standard FFT/IFFT and IRFFT: full length
+                result_shape_proto.mutable_dim(axis_idx)->set_dim_value(dft_length_value);
+              }
+            }
+          } else if (is_onesided) {
+            auto axis_dimension = result_shape_proto.dim(axis_idx);
+            if (axis_dimension.has_dim_value()) {
+              auto axis_dimension_value = axis_dimension.dim_value();
+              if (inverse) {
+                // IRFFT without explicit dft_length: cannot reliably infer full signal length
+                // Default to even length: N = 2 * (input_size - 1)
+                auto full_signal_size = 2 * (axis_dimension_value - 1);
+                result_shape_proto.mutable_dim(axis_idx)->set_dim_value(full_signal_size);
+              } else {
+                // RFFT without explicit dft_length: infer one-sided output size from input
+                auto half_signal_size = (axis_dimension_value >> 1) + 1;
+                result_shape_proto.mutable_dim(axis_idx)->set_dim_value(half_signal_size);
+              }
+            } else {
+              result_shape_proto.mutable_dim(axis_idx)->clear_dim_value();
+              result_shape_proto.mutable_dim(axis_idx)->clear_dim_param();
+            }
+          }
+
+          // Set the last dimension based on whether output is real or complex
+          if (is_onesided && inverse) {
+            // IRFFT: complex input -> real output (last dim = 1)
+            result_shape_proto.mutable_dim(static_cast<int>(rank - 1))->set_dim_value(1);
+          } else {
+            // All other cases: complex output (last dim = 2)
+            result_shape_proto.mutable_dim(static_cast<int>(rank - 1))->set_dim_value(2);
+          }
+
+          updateOutputShape(ctx, output_index, result_shape_proto);
+        }));
+
+static std::function<void(OpSchema&)> CosineSumWindowOpDocGenerator(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Generates a {name} window as described in the paper https://ieeexplore.ieee.org/document/1455106.
+)DOC";
+        ReplaceAll(doc, "{name}", name););
+
+    schema.SetDoc(doc);
+    schema.Attr(
+        "output_datatype",
+        "The data type of the output tensor. "
+        "Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T2. "
+        "The default value is 1 = FLOAT. ",
+        AttributeProto::INT,
+        static_cast<int64_t>(TensorProto_DataType_FLOAT));
+    schema.Attr(
+        "periodic",
+        "If 1, returns a window to be used as periodic function. If 0, return a symmetric window. "
+        "When 'periodic' is specified, hann computes a window of length size + 1 and returns the first size points. "
+        "The default value is 1. ",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Input(
+        0,
+        "size",
+        "A scalar value indicating the length of the window.",
+        "T1",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    std::string output_doc("A {name} window with length: size. The output has the shape: [size].");
+    ReplaceAll(output_doc, "{name}", name);
+    schema.Output(0, "output", output_doc, "T2", OpSchema::Single, true, 1, OpSchema::NonDifferentiable);
+    schema.TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+      // Update the output data type to the output_datatype
+      auto output_datatype = getAttribute(ctx, "output_datatype", static_cast<int64_t>(TensorProto_DataType_FLOAT));
+      updateOutputElemType(ctx, 0, output_datatype);
+
+      if (!hasInputShape(ctx, 0)) {
+        // If no shape is available for the input, skip shape inference.
+        return;
+      }
+
+      const auto* const size = ctx.getInputData(0);
+      if (size == nullptr) {
+        // Size is not available, so return early
+        return;
+      }
+
+      if (size->dims_size() != 0) {
+        fail_shape_inference("size input must be a scalar.");
+      }
+
+      auto size_value = defs::math::utils::GetScalarValueFromTensor<int64_t>(size);
+      if (size_value <= 0) {
+        fail_shape_inference("size input must be greater than 0.");
+      }
+
+      ONNX_NAMESPACE::TensorShapeProto result_shape;
+      result_shape.add_dim()->set_dim_value(size_value);
+      updateOutputShape(ctx, 0, result_shape);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    HannWindow,
+    17,
+    OpSchema()
+        .FillUsing(CosineSumWindowOpDocGenerator("Hann"))
+        .TypeConstraint("T1", {types::Int32, types::Int64}, "Constrain the input size to int32_t or int64_t.")
+        .TypeConstraint("T2", OpSchema::all_numeric_types_ir4(), "Constrain output types to numeric tensors.")
+        .FunctionBody(R"ONNX(
+        {
+          A0 = Constant <value = float {0.5}>()
+          A1 = Constant <value = float {0.5}>()
+          A2 = Constant <value = float {0.0}>()
+          Zero = Constant <value = float {0.0}>()
+          One = Constant <value = float {1.0}>()
+          Two = Constant <value = float {2.0}>()
+          Tau = Constant <value = float {6.2831853}>()
+          Periodic_Size_FP = Cast <to = 1> (size)
+          Symmetric_Size_FP = Sub(Periodic_Size_FP, One)
+          IsPeriodic = Constant <value_int : int = @periodic>()
+          IsPeriodic_FP = Cast <to = 1> (IsPeriodic)
+          IsSymmetric_FP = Sub(One, IsPeriodic_FP)
+          Periodic_Component = Mul(Periodic_Size_FP, IsPeriodic_FP)
+          Symmetric_Component = Mul(Symmetric_Size_FP, IsSymmetric_FP)
+          Size_FP = Add(Periodic_Component, Symmetric_Component)
+          AngularIncrement = Div (Tau, Size_FP)
+          Range = Range (Zero, Periodic_Size_FP, One)
+          RangeAngular = Mul (Range, AngularIncrement)
+          TwoRangeAngular = Mul (RangeAngular, Two)
+          CosTwoRangeAngular = Cos (TwoRangeAngular)
+          A2_Component = Mul (A2, CosTwoRangeAngular)
+          CosRangeAngular = Cos (RangeAngular)
+          A1_Component = Mul (A1, CosRangeAngular)
+          Temp0 = Sub (A0, A1_Component)
+          Temp1 = Add (Temp0, A2_Component)
+          output = Cast <to : int = @output_datatype> (Temp1)
+        }
+        )ONNX"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    HammingWindow,
+    17,
+    OpSchema()
+        .FillUsing(CosineSumWindowOpDocGenerator("Hamming"))
+        .TypeConstraint("T1", {types::Int32, types::Int64}, "Constrain the input size to int32_t or int64_t.")
+        .TypeConstraint("T2", OpSchema::all_numeric_types_ir4(), "Constrain output types to numeric tensors.")
+        .FunctionBody(R"ONNX(
+        {
+          A0 = Constant <value = float {0.54347826087}>()
+          A1 = Constant <value = float {0.45652173913}>()
+          A2 = Constant <value = float {0.0}>()
+          Zero = Constant <value = float {0.0}>()
+          One = Constant <value = float {1.0}>()
+          Two = Constant <value = float {2.0}>()
+          Tau = Constant <value = float {6.2831853}>()
+          Periodic_Size_FP = Cast <to = 1> (size)
+          Symmetric_Size_FP = Sub(Periodic_Size_FP, One)
+          IsPeriodic = Constant <value_int : int = @periodic>()
+          IsPeriodic_FP = Cast <to = 1> (IsPeriodic)
+          IsSymmetric_FP = Sub(One, IsPeriodic_FP)
+          Periodic_Component = Mul(Periodic_Size_FP, IsPeriodic_FP)
+          Symmetric_Component = Mul(Symmetric_Size_FP, IsSymmetric_FP)
+          Size_FP = Add(Periodic_Component, Symmetric_Component)
+          AngularIncrement = Div (Tau, Size_FP)
+          Range = Range (Zero, Periodic_Size_FP, One)
+          RangeAngular = Mul (Range, AngularIncrement)
+          TwoRangeAngular = Mul (RangeAngular, Two)
+          CosTwoRangeAngular = Cos (TwoRangeAngular)
+          A2_Component = Mul (A2, CosTwoRangeAngular)
+          CosRangeAngular = Cos (RangeAngular)
+          A1_Component = Mul (A1, CosRangeAngular)
+          Temp0 = Sub (A0, A1_Component)
+          Temp1 = Add (Temp0, A2_Component)
+          output = Cast <to : int = @output_datatype> (Temp1)
+        }
+        )ONNX"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BlackmanWindow,
+    17,
+    OpSchema()
+        .FillUsing(CosineSumWindowOpDocGenerator("Blackman"))
+        .TypeConstraint("T1", {types::Int32, types::Int64}, "Constrain the input size to int32_t or int64_t.")
+        .TypeConstraint("T2", OpSchema::all_numeric_types_ir4(), "Constrain output types to numeric tensors.")
+        .FunctionBody(R"ONNX(
+        {
+          A0 = Constant <value = float {0.42}>()
+          A1 = Constant <value = float {0.5}>()
+          A2 = Constant <value = float {0.08}>()
+          Zero = Constant <value = float {0.0}>()
+          One = Constant <value = float {1.0}>()
+          Two = Constant <value = float {2.0}>()
+          Tau = Constant <value = float {6.2831853}>()
+          Periodic_Size_FP = Cast <to = 1> (size)
+          Symmetric_Size_FP = Sub(Periodic_Size_FP, One)
+          IsPeriodic = Constant <value_int : int = @periodic>()
+          IsPeriodic_FP = Cast <to = 1> (IsPeriodic)
+          IsSymmetric_FP = Sub(One, IsPeriodic_FP)
+          Periodic_Component = Mul(Periodic_Size_FP, IsPeriodic_FP)
+          Symmetric_Component = Mul(Symmetric_Size_FP, IsSymmetric_FP)
+          Size_FP = Add(Periodic_Component, Symmetric_Component)
+          AngularIncrement = Div (Tau, Size_FP)
+          Range = Range (Zero, Periodic_Size_FP, One)
+          RangeAngular = Mul (Range, AngularIncrement)
+          TwoRangeAngular = Mul (RangeAngular, Two)
+          CosTwoRangeAngular = Cos (TwoRangeAngular)
+          A2_Component = Mul (A2, CosTwoRangeAngular)
+          CosRangeAngular = Cos (RangeAngular)
+          A1_Component = Mul (A1, CosRangeAngular)
+          Temp0 = Sub (A0, A1_Component)
+          Temp1 = Add (Temp0, A2_Component)
+          output = Cast <to : int = @output_datatype> (Temp1)
+        }
+        )ONNX"));
+
+static constexpr const char* MelWeightMatrix_ver17_doc = R"DOC(
+Generate a MelWeightMatrix that can be used to re-weight a Tensor containing a linearly sampled frequency spectra (from DFT or STFT) into num_mel_bins frequency information based on the [lower_edge_hertz, upper_edge_hertz] range on the mel scale.
+This function defines the mel scale in terms of a frequency in hertz according to the following formula:
+
+    mel(f) = 2595 * log10(1 + f/700)
+
+In the returned matrix, all the triangles (filterbanks) have a peak value of 1.0.
+
+The returned MelWeightMatrix can be used to right-multiply a spectrogram S of shape [frames, num_spectrogram_bins] of linear scale spectrum values (e.g. STFT magnitudes) to generate a "mel spectrogram" M of shape [frames, num_mel_bins].
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MelWeightMatrix,
+    17,
+    OpSchema()
+        .SetDoc(MelWeightMatrix_ver17_doc)
+        .Attr(
+            "output_datatype",
+            "The data type of the output tensor. "
+            "Strictly must be one of the values from DataType enum in TensorProto whose values correspond to T3. "
+            "The default value is 1 = FLOAT. ",
+            AttributeProto::INT,
+            static_cast<int64_t>(TensorProto_DataType_FLOAT))
+        .Input(
+            0,
+            "num_mel_bins",
+            "The number of bands in the mel spectrum.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            1,
+            "dft_length",
+            "The size of the original DFT. "
+            "The size of the original DFT is used to infer the size of the onesided DFT, which is understood to be floor(dft_length/2) + 1, i.e. the spectrogram only contains the nonredundant DFT bins.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "sample_rate",
+            "Samples per second of the input signal used to create the spectrogram. Used to figure out the frequencies corresponding to each spectrogram bin, which dictates how they are mapped into the mel scale.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            3,
+            "lower_edge_hertz",
+            "Lower bound on the frequencies to be included in the mel spectrum. This corresponds to the lower edge of the lowest triangular band.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            4,
+            "upper_edge_hertz",
+            "The desired top edge of the highest frequency band.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "The Mel Weight Matrix. "
+            "The output has the shape: [floor(dft_length/2) + 1][num_mel_bins].",
+            "T3",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T1", {types::Int32, types::Int64}, "Constrain to integer tensors.")
+        .TypeConstraint(
+            "T2",
+            {types::Float, types::Float16, types::Double, types::BFloat16},
+            "Constrain to float tensors")
+        .TypeConstraint("T3", OpSchema::all_numeric_types_ir4(), "Constrain to any numerical types.")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto output_datatype = getAttribute(ctx, "output_datatype", static_cast<int64_t>(TensorProto_DataType_FLOAT));
+          updateOutputElemType(ctx, 0, output_datatype);
+
+          if (!hasInputShape(ctx, 0) || !hasInputShape(ctx, 1)) {
+            return;
+          }
+
+          const auto num_mel_bins = ctx.getInputData(0);
+          const auto dft_length = ctx.getInputData(1);
+          if (nullptr == num_mel_bins || nullptr == dft_length) {
+            return;
+          }
+
+          int64_t num_mel_bins_value = -1;
+          int64_t dft_length_value = -1;
+          if (num_mel_bins->dims_size() != 0) {
+            fail_shape_inference("num_mel_bins input must be scalar.");
+          }
+          num_mel_bins_value = defs::math::utils::GetScalarValueFromTensor<int64_t>(num_mel_bins);
+
+          if (dft_length->dims_size() != 0) {
+            fail_shape_inference("dft_length input must be scalar.");
+          }
+          dft_length_value = defs::math::utils::GetScalarValueFromTensor<int64_t>(dft_length);
+
+          if (num_mel_bins_value > 0 && dft_length_value > 0) {
+            ONNX_NAMESPACE::TensorShapeProto result_shape;
+            result_shape.add_dim()->set_dim_value(static_cast<int64_t>((dft_length_value >> 1) + 1));
+            result_shape.add_dim()->set_dim_value(num_mel_bins_value);
+            updateOutputShape(ctx, 0, result_shape);
+          }
+        }));
+
+static constexpr const char* STFT_ver17_doc = R"DOC(Computes the Short-time Fourier Transform of the signal.)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    STFT,
+    17,
+    OpSchema()
+        .SetDoc(STFT_ver17_doc)
+        .Attr(
+            "onesided",
+            "If onesided is 1, only values for w in [0, 1, 2, ..., floor(n_fft/2) + 1] are returned because "
+            "the real-to-complex Fourier transform satisfies the conjugate symmetry, i.e., X[m, w] = X[m,w]=X[m,n_fft-w]*. "
+            "Note if the input or window tensors are complex, then onesided output is not possible. "
+            "Enabling onesided with real inputs performs a Real-valued fast Fourier transform (RFFT)."
+            "When invoked with real or complex valued input, the default value is 1. "
+            "Values can be 0 or 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Input(
+            0,
+            "signal",
+            "Input tensor representing a real or complex valued signal. "
+            "For real input, the following shape is expected: [batch_size][signal_length][1]. "
+            "For complex input, the following shape is expected: [batch_size][signal_length][2], where "
+            "[batch_size][signal_length][0] represents the real component and [batch_size][signal_length][1] represents the imaginary component of the signal.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            1,
+            "frame_step",
+            "The number of samples to step between successive DFTs.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "window",
+            "A tensor representing the window that will be slid over the signal."
+            "The window must have rank 1 with shape: [window_shape]. "
+            "It's an optional value. ",
+            "T1",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            3,
+            "frame_length",
+            "A scalar representing the size of the DFT. "
+            "It's an optional value.",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "The Short-time Fourier Transform of the signals."
+            "If onesided is 1, the output has the shape: [batch_size][frames][dft_unique_bins][2], where dft_unique_bins is frame_length // 2 + 1 (the unique components of the DFT) "
+            "If onesided is 0, the output has the shape: [batch_size][frames][frame_length][2], where frame_length is the length of the DFT.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Float16, types::Double, types::BFloat16},
+            "Constrain signal and output to float tensors.")
+        .TypeConstraint("T2", {types::Int32, types::Int64}, "Constrain scalar length types to int64_t.")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Get signal size
+          // The signal size is needed to perform inference because the size of the signal
+          // is needed to compute the number of DFTs in the output.
+          //
+          // 1) Check if shape exists, return if not
+          // 2) Get the shape
+          // 3) Check if signal dim value exists, return if not
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, 0);
+          if (input_shape.dim_size() < 2) {
+            fail_shape_inference("First input should have at least 2 dimensions in ", ctx.getDisplayName(), ".");
+          }
+          auto signal_dim = input_shape.dim(1);
+          if (!signal_dim.has_dim_value()) {
+            return;
+          }
+          auto signal_size = signal_dim.dim_value();
+
+          // The frame step is a required input.
+          // Its value is needed to compute the number output nDFTs, so return early is missing.
+          const auto frame_step = ctx.getInputData(1);
+          if (nullptr == frame_step) {
+            return;
+          }
+          auto frame_step_value = defs::math::utils::GetScalarValueFromTensor<int64_t>(frame_step);
+
+          // Determine the size of the DFT based on the 2 optional inputs window and frame_length.
+          // One must be set.
+          int64_t dft_size = -1;
+          const TensorProto* frame_length = nullptr;
+          if (ctx.hasInput(3)) {
+            frame_length = ctx.getInputData(3);
+            if (frame_length == nullptr) {
+              // If we cannot read the frame_length, we cannot infer shape
+              // return...
+              return;
+            }
+          }
+
+          const TensorShapeProto* window_shape = nullptr;
+          if (ctx.getNumInputs() >= 3) {
+            window_shape = getOptionalInputShape(ctx, 2);
+          } else {
+            window_shape = nullptr;
+          }
+
+          if (window_shape == nullptr && frame_length == nullptr) {
+            // STFT expects to have at least one of these inputs set: [window, frame_length],
+            // but they may not be available at shape inference time
+            return;
+          } else if (window_shape != nullptr && frame_length != nullptr) {
+            if (frame_length->dims_size() != 0) {
+              fail_shape_inference("frame_length input must be scalar.");
+            }
+            auto frame_length_value = defs::math::utils::GetScalarValueFromTensor<int64_t>(frame_length);
+
+            // Ensure that the window length and the dft_length match.
+            if (window_shape->dim_size() != 1) {
+              fail_shape_inference("window input must have rank = 1.");
+            }
+            if (window_shape->dim(0).has_dim_value()) {
+              auto window_length = window_shape->dim(0).dim_value();
+              if (window_length != frame_length_value) {
+                fail_type_inference(
+                    "If STFT has both a window input and frame_length specified, the dimension of the window must match the frame_length specified!");
+              }
+            }
+
+            dft_size = frame_length_value;
+          } else if (window_shape != nullptr) {
+            // Ensure that the window length and the dft_length match.
+            if (window_shape->dim_size() != 1) {
+              fail_shape_inference("window input must have rank = 1.");
+            }
+            if (window_shape->dim(0).has_dim_value()) {
+              dft_size = window_shape->dim(0).dim_value();
+            } else {
+              // Cannot determine the window size, and there is no frame_length,
+              // So shape inference cannot proceed.
+              return;
+            }
+          } else if (frame_length != nullptr) {
+            if (frame_length->dims_size() != 0) {
+              fail_shape_inference("frame_length input must be scalar.");
+            }
+            dft_size = defs::math::utils::GetScalarValueFromTensor<int64_t>(frame_length);
+          }
+
+          bool is_onesided = static_cast<bool>(getAttribute(ctx, "onesided", 0));
+          int64_t dft_unique_bins = is_onesided ? ((dft_size >> 1) + 1) : dft_size;
+
+          auto n_dfts = static_cast<int64_t>((signal_size - dft_size) / static_cast<float>(frame_step_value)) + 1;
+
+          // The output has the following shape: [batch_size][frames][dft_unique_bins][2]
+          ONNX_NAMESPACE::TensorShapeProto result_shape_proto;
+          auto batch_dim = result_shape_proto.add_dim();
+
+          if (input_shape.dim(0).has_dim_value()) {
+            batch_dim->set_dim_value(input_shape.dim(0).dim_value()); // batch size
+          }
+
+          result_shape_proto.add_dim()->set_dim_value(n_dfts);
+          result_shape_proto.add_dim()->set_dim_value(dft_unique_bins);
+          result_shape_proto.add_dim()->set_dim_value(2);
+          updateOutputShape(ctx, 0, result_shape_proto);
+        }));
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/math/old.cc b/onnx/defs/math/old.cc
new file mode 100644
index 0000000..55c492d
--- /dev/null
+++ b/onnx/defs/math/old.cc
@@ -0,0 +1,3642 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <functional>
+#include <limits>
+#include <string>
+#include <vector>
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/math/utils.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/tensor_proto_util.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static bool BuildContextDependentFunctionBody_opset13(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  if (ctx.getInputType(0) == nullptr) {
+    // we cannot create a correct function body without knowing the input type
+    return false;
+  }
+  auto input_type = ctx.getInputType(0)->tensor_type().elem_type();
+  bool float_input = input_type == TensorProto_DataType_FLOAT;
+  const auto* const reduction_attr_proto = ctx.getAttribute("reduction");
+  std::string reduction_attr =
+      reduction_attr_proto != nullptr && reduction_attr_proto->has_s() ? reduction_attr_proto->s() : "mean";
+
+  FunctionBuilder builder(functionProto);
+  builder.Const1D("const_zero", static_cast<int64_t>(0))
+      .Const1D("const_one", static_cast<int64_t>(1))
+      .Const1D("axes", static_cast<int64_t>(1))
+      .Add("expanded_target = Unsqueeze (target, axes)");
+
+  if (ctx.getAttribute("ignore_index") == nullptr) {
+    builder.Add(R"(
+      input_gather_element = GatherElements <axis = 1> (input, expanded_target)
+      loss_NCdd = Neg (input_gather_element)
+      loss_N1dd = Slice (loss_NCdd, const_zero, const_one, const_one)
+    )");
+
+    if (!ctx.hasInput(2)) {
+      if (reduction_attr == "none") {
+        builder.Add("loss = Squeeze (loss_N1dd, axes)");
+      } else {
+        builder.Add("loss_Ndd = Squeeze (loss_N1dd, axes)");
+        if (reduction_attr == "mean") {
+          builder.Add("loss = ReduceMean <keepdims = 0> (loss_Ndd)");
+        } else {
+          builder.Add("loss = ReduceSum <keepdims = 0> (loss_Ndd)");
+        }
+      }
+    } else {
+      builder.Add("weight_gather = Gather (weight, target)");
+      builder.Add("loss_unweighted = Squeeze (loss_N1dd, axes)");
+      if (reduction_attr == "none") {
+        builder.Add("loss = Mul (loss_unweighted, weight_gather)");
+      } else {
+        builder.Add("loss_Ndd = Mul (loss_unweighted, weight_gather)");
+        if (reduction_attr == "mean") {
+          builder.Add(R"(
+            loss_sum = ReduceSum <keepdims = 0> (loss_Ndd)
+            weight_gather_sum = ReduceSum <keepdims = 0> (weight_gather)
+            loss = Div (loss_sum, weight_gather_sum)
+          )");
+        } else {
+          builder.Add("loss = ReduceSum <keepdims = 0> (loss_Ndd)");
+        }
+      }
+    }
+  } else {
+    builder.Const1D("const_ignore_index", ctx.getAttribute("ignore_index")->i());
+    builder.Add(R"(
+      const_zero_target_typed = Sub (expanded_target, expanded_target)
+      expanded_target_int64 = Cast <to = 7> (expanded_target)
+      mask = Equal (expanded_target_int64, const_ignore_index)
+      transform_targets = Where (mask, const_zero_target_typed, expanded_target)
+    )");
+    builder.Add("input_gather_element = GatherElements <axis = 1> (input, transform_targets)");
+    builder.Const1D("const_zero_float", 0.0f);
+    if (!float_input) {
+      builder.Add("const_zero_casted = Cast (const_zero_float)", "to", static_cast<int64_t>(input_type))
+          .Add("input_gather_element_transform = Where (mask, const_zero_casted, input_gather_element)");
+    } else {
+      builder.Add("input_gather_element_transform = Where (mask, const_zero_float, input_gather_element)");
+    }
+    builder.Add("loss_NCdd = Neg (input_gather_element_transform)");
+    builder.Add("loss_N1dd = Slice (loss_NCdd, const_zero, const_one, const_one)");
+
+    if (!ctx.hasInput(2)) {
+      builder.Add("squeeze_mask = Squeeze (mask, axes)");
+      builder.Const1D("const_one_float", 1.0f);
+      if (!float_input) {
+        builder.Add("const_one_casted = Cast (const_one_float)", "to", static_cast<int64_t>(input_type))
+            .Add("weight_gather = Where (squeeze_mask, const_zero_casted, const_one_casted)");
+      } else {
+        builder.Add("weight_gather = Where (squeeze_mask, const_zero_float, const_one_float)");
+      }
+
+    } else {
+      builder.Add("weight_gather_temp = Gather (weight, transform_targets)");
+      builder.Add(
+          float_input ? "weight_gather_temp_1 = Where (mask, const_zero_float, weight_gather_temp)"
+                      : "weight_gather_temp_1 = Where (mask, const_zero_casted, weight_gather_temp)");
+      builder.Add("weight_gather = Squeeze (weight_gather_temp_1, axes)");
+    }
+
+    builder.Add("loss_unweighted = Squeeze (loss_N1dd, axes)");
+    if (reduction_attr == "none") {
+      builder.Add("loss = Mul (loss_unweighted, weight_gather)");
+    } else {
+      builder.Add("loss_Ndd = Mul (loss_unweighted, weight_gather)");
+      if (reduction_attr == "mean") {
+        builder.Add(R"(
+            loss_sum = ReduceSum <keepdims = 0> (loss_Ndd)
+            weight_gather_sum = ReduceSum <keepdims = 0> (weight_gather)
+            loss = Div (loss_sum, weight_gather_sum)
+        )");
+      } else {
+        builder.Add("loss = ReduceSum <keepdims = 0> (loss_Ndd)");
+      }
+    }
+  }
+
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    NegativeLogLikelihoodLoss,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_NegativeLogLikelihoodLoss_ver13)
+        .Input(
+            0,
+            "input",
+            "Input tensor of shape (N, C) or (N, C, d1, d2, ..., dk).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "target",
+            "Target tensor of shape (N) or (N, d1, d2, ..., dk). Target element value shall be in range of [0, C). "
+            "If ignore_index is specified, it may have a value outside [0, C) and the target values should either be "
+            "in the range [0, C) or have the value ignore_index.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "weight",
+            "Optional rescaling weight tensor. "
+            "If given, it has to be a tensor of size C. Otherwise, it is treated as if having all ones.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "loss", "The negative log likelihood loss", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Attr(
+            "reduction",
+            "Type of reduction to apply to loss: none, sum, mean (default). "
+            "'none': the output is the loss for each sample. "
+            "'sum': the output will be summed. "
+            "'mean': the sum of the output will be divided by the sum of applied weights.",
+            AttributeProto::STRING,
+            std::string("mean"))
+        .Attr(
+            "ignore_index",
+            "Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.",
+            AttributeProto::INT,
+            false)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input, weight, and output types to floating-point tensors.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain target to integer types")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBody_opset13)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          if (hasNInputShapes(ctx, 2)) {
+            const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            const TensorShapeProto& target_shape = ctx.getInputType(1)->tensor_type().shape();
+
+            const int input_rank = static_cast<int>(input_shape.dim_size());
+            const int target_rank = static_cast<int>(target_shape.dim_size());
+
+            if (input_rank < 2) {
+              fail_shape_inference("Input rank must be >= 2.");
+            }
+            if (target_rank != input_rank - 1) {
+              fail_shape_inference("Target rank must be 1 less than the input rank.");
+            }
+
+            // match input dimensions (N, C, d1, ..., dk) with target
+            // dimensions of (C, d1, ..., dk)
+            for (int dim = 0; dim < target_rank; dim++) {
+              const auto input_dim = dim == 0 ? input_shape.dim(dim) : input_shape.dim(dim + 1);
+              const auto target_dim = target_shape.dim(dim);
+              if (input_dim.has_dim_value() && target_dim.has_dim_value() &&
+                  input_dim.dim_value() != target_dim.dim_value())
+                fail_shape_inference("Input and target dimension value mismatch.");
+            }
+
+            if (ctx.getNumInputs() == 3 && hasInputShape(ctx, 2)) {
+              const TensorShapeProto& weight_shape = ctx.getInputType(2)->tensor_type().shape();
+              if (weight_shape.dim_size() != 1) {
+                fail_shape_inference("Weight rank must be 1.");
+              }
+            }
+
+            TensorShapeProto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+            if (getAttribute(ctx, "reduction", "mean") == "none") {
+              // output tensor is of shape (N, d1, d2, ..., dk) if
+              // reduction attribute is "none".
+              for (int i = 0; i < input_rank - 1; i++) {
+                auto dim = output_shape->add_dim();
+                if (i == 0)
+                  *dim = input_shape.dim(i);
+                else
+                  *dim = input_shape.dim(i + 1);
+              }
+            }
+            // otherwise output is a scalar.
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Det,
+    11,
+    OpSchema()
+        .SetDoc(kDoc_Det_ver11)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to floating-point tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          if (hasInputShape(ctx, 0)) {
+            const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            TensorShapeProto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+            const int rank = static_cast<int>(input_shape.dim_size());
+
+            if (rank < 2) {
+              fail_shape_inference("Input rank must be >= 2.");
+            }
+
+            const auto mat_w = input_shape.dim(rank - 1);
+            const auto mat_h = input_shape.dim(rank - 2);
+            if (mat_w.has_dim_value() && mat_h.has_dim_value() && (mat_w.dim_value() != mat_h.dim_value())) {
+              fail_shape_inference(
+                  "The inner-most 2 dimensions must have the same size (mat_w:",
+                  mat_w.dim_value(),
+                  " != mat_h:",
+                  mat_h.dim_value(),
+                  ").");
+            }
+
+            for (int i = 0; i < rank - 2; ++i) {
+              auto dim = output_shape->add_dim();
+              *dim = input_shape.dim(i);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Round,
+    11,
+    OpSchema()
+        .SetDoc(kDoc_Round_ver11)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Atanh,
+    9,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Atanh_ver9,
+            "The hyperbolic arctangent values of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Acosh,
+    9,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Acosh_ver9,
+            "The hyperbolic arccosine values of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Asinh,
+    9,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Asinh_ver9,
+            "The hyperbolic arcsine values of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cosh,
+    9,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Cosh_ver9,
+            "The hyperbolic cosine values of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sinh,
+    9,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Sinh_ver9,
+            "The hyperbolic sine values of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Atan,
+    7,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Atan_ver7,
+            "The arctangent of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Acos,
+    7,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Acos_ver7,
+            "The arccosine of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Asin,
+    7,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Asin_ver7,
+            "The arcsine of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Tan,
+    7,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Tan_ver7,
+            "The tangent of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cos,
+    7,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Cos_ver7,
+            "The cosine of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sin,
+    7,
+    OpSchema().FillUsing(
+        defs::math::utils::UnaryFloatMathOpGenerator(
+            kDoc_Sin_ver7,
+            "The sine of the input tensor computed element-wise",
+            {types::Float16, types::Float, types::Double})));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Softplus,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Softplus_ver1)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+            {
+              exp_x = Exp (X)
+              one = Constant <value = float {1.0}>()
+              one_cast = CastLike (one, X)
+              exp_x_add_one = Add (exp_x, one_cast)
+              Y = Log (exp_x_add_one)
+            }
+            )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Softsign,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Softsign_ver1)
+        .Input(0, "input", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "The softsign (x/(1+|x|)) values of the input tensor computed element-wise",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            One = Constant <value = float {1.0}>()
+            OneCast = CastLike (One, input)
+            AbsInput = Abs(input)
+            OneAddAbsInput = Add (OneCast, AbsInput)
+            output = Div(input, OneAddAbsInput)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    HardSwish,
+    14,
+    OpSchema()
+        .SetDoc(kDoc_HardSwish_ver14)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(R"ONNX(
+          {
+            HS_X = HardSigmoid<alpha = 0.16666667163372, beta = 0.5>(X)
+            Y = Mul (X, HS_X)
+          }
+        )ONNX"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    HardSigmoid,
+    6,
+    OpSchema()
+        .Attr("alpha", "Value of alpha.", AttributeProto::FLOAT, 0.2f)
+        .Attr("beta", "Value of beta.", AttributeProto::FLOAT, 0.5f)
+        .SetDoc(kDoc_HardSigmoid_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Beta = Constant <value_float: float = @beta>()
+            BetaCast = CastLike (Beta, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            One = Constant <value = float {1.0}>()
+            OneCast = CastLike (One, X)
+            AlphaMulX = Mul (X, AlphaCast)
+            AlphaMulXAddBeta = Add (AlphaMulX, BetaCast)
+            MinOneOrAlphaMulXAddBeta = Min (AlphaMulXAddBeta, OneCast)
+            Y = Max(MinOneOrAlphaMulXAddBeta, ZeroCast)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Mish,
+    18,
+    OpSchema()
+        .SetDoc(kDoc_mish_ver18)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input X and output types to float tensors.")
+        .FunctionBody(R"ONNX(
+          {
+            Softplus_X = Softplus (X)
+            TanHSoftplusX = Tanh (Softplus_X)
+            Y = Mul (X, TanHSoftplusX)
+           }
+        )ONNX")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Elu,
+    6,
+    OpSchema()
+        .Attr("alpha", "Coefficient of ELU.", AttributeProto::FLOAT, 1.0f)
+        .SetDoc(kDoc_Elu_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            One = Constant <value = float {1.0}>()
+            OneCast = CastLike (One, X)
+            XLessThanZero = Less (X, ZeroCast)
+            ExpX = Exp (X)
+            ExpXSubOne = Sub (ExpX, OneCast)
+            AlphaMulExpXSubOne = Mul (AlphaCast, ExpXSubOne)
+            Y = Where(XLessThanZero, AlphaMulExpXSubOne, X)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Selu,
+    6,
+    OpSchema()
+        .Attr(
+            "alpha",
+            "Coefficient of SELU default to 1.67326319217681884765625 "
+            "(i.e., float32 approximation of 1.6732632423543772848170429916717).",
+            AttributeProto::FLOAT,
+            1.67326319217681884765625f)
+        .Attr(
+            "gamma",
+            "Coefficient of SELU default to 1.05070102214813232421875 "
+            "(i.e., float32 approximation of 1.0507009873554804934193349852946).",
+            AttributeProto::FLOAT,
+            1.05070102214813232421875f)
+        .SetDoc(kDoc_Selu_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Gamma = Constant <value_float: float = @gamma>()
+            GammaCast = CastLike (Gamma, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            ExpX = Exp (X)
+            AlphaMulExpX = Mul(AlphaCast, ExpX)
+            AlphaMulExpXSubAlpha = Sub (AlphaMulExpX, AlphaCast)
+            Neg = Mul (GammaCast, AlphaMulExpXSubAlpha)
+            Pos = Mul (GammaCast, X)
+            XLessThanZero = Less (X, ZeroCast)
+            Y = Where(XLessThanZero, Neg, Pos)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ThresholdedRelu,
+    10,
+    OpSchema()
+        .SetDoc(kDoc_ThresholdedRelu_ver10)
+        .Attr("alpha", "Threshold value", AttributeProto::FLOAT, 1.0f)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Alpha = Constant <value_float: float = @alpha>()
+            AlphaCast = CastLike (Alpha, X)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, X)
+            AlphaLessThanX = Less(AlphaCast, X)
+            Y = Where(AlphaLessThanX, X, ZeroCast)
+          }
+        )ONNX",
+            18));
+
+static std::function<void(OpSchema&)> MathDocGenerator_opset13(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    if (std::string(name) == "division") {
+      POPULATE_OP_DOC_STR(
+          doc = R"DOC(
+Performs element-wise binary {name} (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+
+For integer inputs, the result is computed using truncating division (rounding toward zero).
+)DOC";
+          ReplaceAll(doc, "{name}", name);
+          ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    } else {
+      POPULATE_OP_DOC_STR(
+          doc = R"DOC(
+Performs element-wise binary {name} (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+)DOC";
+          ReplaceAll(doc, "{name}", name);
+          ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    }
+    schema.SetDoc(doc);
+    schema.Input(0, "A", "First operand.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.Input(1, "B", "Second operand.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "C",
+        "Result, has same element type as two inputs",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T",
+        OpSchema::numeric_types_for_math_reduction_ir4(),
+        "Constrain input and output types to high-precision numeric tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (hasNInputShapes(ctx, 2))
+        bidirectionalBroadcastShapeInference(
+            ctx.getInputType(0)->tensor_type().shape(),
+            ctx.getInputType(1)->tensor_type().shape(),
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(Add, 13, OpSchema().FillUsing(MathDocGenerator_opset13("addition")));
+
+ONNX_OPERATOR_SET_SCHEMA(Sub, 13, OpSchema().FillUsing(MathDocGenerator_opset13("subtraction")));
+
+ONNX_OPERATOR_SET_SCHEMA(Mul, 13, OpSchema().FillUsing(MathDocGenerator_opset13("multiplication")));
+
+ONNX_OPERATOR_SET_SCHEMA(Div, 13, OpSchema().FillUsing(MathDocGenerator_opset13("division")));
+
+static std::function<void(OpSchema&)> MathDocGenerator_opset_7(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    if (std::string(name) == "division") {
+      POPULATE_OP_DOC_STR(
+          doc = R"DOC(
+Performs element-wise binary {name} (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+
+For integer inputs, the result is computed using truncating division (rounding toward zero).
+)DOC";
+          ReplaceAll(doc, "{name}", name);
+          ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    } else {
+      POPULATE_OP_DOC_STR(
+          doc = R"DOC(
+Performs element-wise binary {name} (with Numpy-style broadcasting support).
+
+{broadcast_doc}
+)DOC";
+          ReplaceAll(doc, "{name}", name);
+          ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    }
+    schema.SetDoc(doc);
+    schema.Input(0, "A", "First operand.", "T");
+    schema.Input(1, "B", "Second operand.", "T");
+    schema.Output(0, "C", "Result, has same element type as two inputs", "T");
+    schema.TypeConstraint(
+        "T",
+        OpSchema::numeric_types_for_math_reduction(),
+        "Constrain input and output types to high-precision numeric tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (hasNInputShapes(ctx, 2))
+        bidirectionalBroadcastShapeInference(
+            ctx.getInputType(0)->tensor_type().shape(),
+            ctx.getInputType(1)->tensor_type().shape(),
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(Add, 7, OpSchema().FillUsing(MathDocGenerator_opset_7("addition")));
+
+ONNX_OPERATOR_SET_SCHEMA(Sub, 7, OpSchema().FillUsing(MathDocGenerator_opset_7("subtraction")));
+
+ONNX_OPERATOR_SET_SCHEMA(Mul, 7, OpSchema().FillUsing(MathDocGenerator_opset_7("multiplication")));
+
+ONNX_OPERATOR_SET_SCHEMA(Div, 7, OpSchema().FillUsing(MathDocGenerator_opset_7("division")));
+
+static std::function<void(OpSchema&)> SoftmaxFamilyDocGenerator_opset_11(const char* name, const char* description) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+The operator computes the {name} ({description}) values for each layer in the batch
+ of the given input.
+
+The input does not need to explicitly be a 2D vector; rather, it will be
+coerced into one. For an arbitrary n-dimensional tensor
+input \in [a_0, a_1, ..., a_{k-1}, a_k, ..., a_{n-1}] and k is
+the axis provided, then input will be coerced into a 2-dimensional tensor with
+dimensions [a_0 * ... * a_{k-1}, a_k * ... * a_{n-1}]. For the default
+case where axis=1, this means the input tensor will be coerced into a 2D tensor
+of dimensions [a_0, a_1 * ... * a_{n-1}], where a_0 is often the batch size.
+In this situation, we must have a_0 = N and a_1 * ... * a_{n-1} = D.
+Each of these dimensions must be matched correctly, or else the operator
+will throw errors. The output tensor has the same shape
+and contains the {name} values of the corresponding input.
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{description}", description););
+    schema.SetDoc(doc);
+    schema.Attr(
+        "axis",
+        "Describes the axis of the inputs when coerced "
+        "to 2D; defaults to one because the 0th axis most likely describes "
+        "the batch_size. Negative value means counting dimensions "
+        "from the back. Accepted range is [-r, r-1] where r = rank(input).",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Input(
+        0,
+        "input",
+        "The input tensor that's coerced into a 2D matrix of size (NxD) "
+        "as described above.",
+        "T");
+    schema.Output(
+        0,
+        "output",
+        "The output values with the same "
+        "shape as input tensor (the original size without coercion).",
+        "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([name](InferenceContext& ctx) {
+      // Type inference
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+      // Shape inference starts
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+
+      // Validate the value of 'axis'
+      const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      int r = input_shape.dim_size();
+      if (r == 0) {
+        fail_shape_inference("Input rank must be >= 1 for ", name, ".");
+      }
+      int axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+      if (axis < -r || axis >= r) {
+        fail_shape_inference("'axis' must be in [", -r, " , ", (r - 1), "]. Its actual value is: ", axis);
+      }
+
+      // Shape inference
+      propagateShapeFromInputToOutput(ctx, 0, 0);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Softmax,
+    11,
+    OpSchema().FillUsing(SoftmaxFamilyDocGenerator_opset_11("softmax", "normalized exponential")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LogSoftmax,
+    11,
+    OpSchema().FillUsing(SoftmaxFamilyDocGenerator_opset_11("logsoftmax", "log of softmax")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Hardmax,
+    11,
+    OpSchema().FillUsing(
+        SoftmaxFamilyDocGenerator_opset_11("hardmax", "1 for the first maximum value, and 0 for all others")));
+
+static constexpr const char* Mod_doc_10 = R"DOC(
+  Performs element-wise binary modulus (with Numpy-style broadcasting support).
+    The sign of the remainder is the same as that of the Divisor.
+
+    Mod operator can also behave like C fmod() or numpy.fmod. In this case, the sign of the remainder however, will be the same as the Dividend
+    (in contrast to integer mod). To force a behavior like numpy.fmod() an 'fmod' Attribute is provided.
+    This attribute is set to 0 by default causing the behavior to be like integer mod.
+    Setting this attribute to 1 causes the remainder to be calculated similar to that of numpy.fmod().
+
+    If the input type is floating point, then `fmod` attribute must be set to 1.
+
+    In case of dividend being zero, the results will be platform dependent.
+
+  This operator supports **multidirectional (i.e., Numpy-style) broadcasting**; for more details please check [the doc](Broadcasting.md).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Mod,
+    10,
+    OpSchema()
+        .SetDoc(Mod_doc_10)
+        .Attr(
+            "fmod",
+            "Whether the operator should behave like fmod (default=0 meaning it will do integer mods); Set this to 1 to force fmod treatment",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "A", "Dividend tensor", "T")
+        .Input(1, "B", "Divisor tensor", "T")
+        .Output(0, "C", "Remainder tensor", "T")
+        .TypeConstraint(
+            "T",
+            OpSchema::all_numeric_types(),
+            "Constrain input and output types to high-precision numeric tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2))
+            bidirectionalBroadcastShapeInference(
+                ctx.getInputType(0)->tensor_type().shape(),
+                ctx.getInputType(1)->tensor_type().shape(),
+                *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Neg,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_Neg_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Int32, types::Int8, types::Int16, types::Int64, types::Float16, types::Double},
+            "Constrain input and output types to signed numeric tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* Abs_ver6_doc = R"DOC(
+Absolute takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the absolute is, y = abs(x), is applied to
+the tensor elementwise.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Abs,
+    6,
+    OpSchema()
+        .SetDoc(Abs_ver6_doc)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input and output types to all numeric tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reciprocal,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_Reciprocal_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* Floor_ver6_doc = R"DOC(
+Floor takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the floor is, y = floor(x), is applied to
+the tensor elementwise.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Floor,
+    6,
+    OpSchema()
+        .SetDoc(Floor_ver6_doc)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* Ceil_ver6_doc = R"DOC(
+Ceil takes one input data (Tensor<T>) and produces one output data
+(Tensor<T>) where the ceil is, y = ceil(x), is applied to
+the tensor elementwise.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Ceil,
+    6,
+    OpSchema()
+        .SetDoc(Ceil_ver6_doc)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sqrt,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_Sqrt_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Relu,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_Relu_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Relu,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Relu_ver6)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Exp,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_Exp_ver6)
+        .Input(0, "input", "Input tensor", "T")
+        .Output(
+            0,
+            "output",
+            "The exponential of the input tensor computed "
+            "element-wise",
+            "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Log,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_Log_ver6)
+        .Input(0, "input", "Input tensor", "T")
+        .Output(
+            0,
+            "output",
+            "The natural log of the input tensor computed "
+            "element-wise",
+            "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Tanh,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_Tanh_ver6)
+        .Input(0, "input", "Input tensor", "T")
+        .Output(
+            0,
+            "output",
+            "The hyperbolic tangent values of the input tensor "
+            "computed element-wise",
+            "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pow,
+    13,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_Pow_ver13) + GenerateBroadcastingDocMul()))
+        .Input(0, "X", "First operand, base of the exponent.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "Y",
+            "Second operand, power of the exponent.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(0, "Z", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Int32, types::Int64, types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input X and output types to float/int tensors.")
+        .TypeConstraint(
+            "T1",
+            {types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::Float16,
+             types::Float,
+             types::Double},
+            "Constrain input Y types to float/int tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2))
+            bidirectionalBroadcastShapeInference(
+                ctx.getInputType(0)->tensor_type().shape(),
+                ctx.getInputType(1)->tensor_type().shape(),
+                *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pow,
+    12,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_Pow_ver13) + GenerateBroadcastingDocMul()))
+        .Input(0, "X", "First operand, base of the exponent.", "T")
+        .Input(1, "Y", "Second operand, power of the exponent.", "T1")
+        .Output(0, "Z", "Output tensor.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Int32, types::Int64, types::Float16, types::Float, types::Double},
+            "Constrain input X and output types to float/int tensors.")
+        .TypeConstraint(
+            "T1",
+            {types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::Float16,
+             types::Float,
+             types::Double},
+            "Constrain input Y types to float/int tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2))
+            bidirectionalBroadcastShapeInference(
+                ctx.getInputType(0)->tensor_type().shape(),
+                ctx.getInputType(1)->tensor_type().shape(),
+                *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sigmoid,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_Sigmoid_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+// Generate opschema for element-wise ops. Leaves type constraint "T"
+// unspecified.
+static std::function<void(OpSchema&)> ElementwiseMultiOpDocGenerator_opset8(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Element-wise {name} of each of the input tensors (with Numpy-style broadcasting support).
+All inputs and outputs must have the same data type.
+{broadcast_doc}
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    schema.SetDoc(doc);
+    schema.Input(0, "data_0", "List of tensors for " + std::string(name) + ".", "T", OpSchema::Variadic);
+    schema.Output(0, name, "Output tensor.", "T");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      auto num_inputs = ctx.getNumInputs();
+      std::vector<const TensorShapeProto*> shapes;
+      for (size_t i = 0; i < num_inputs; ++i) {
+        const auto* const input_type = ctx.getInputType(i);
+        if (nullptr == input_type || !input_type->has_tensor_type() || !input_type->tensor_type().has_shape()) {
+          return;
+        }
+        shapes.push_back(&input_type->tensor_type().shape());
+      }
+
+      multidirectionalBroadcastShapeInference(shapes, *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Max,
+    12,
+    OpSchema()
+        .FillUsing(ElementwiseMultiOpDocGenerator_opset8("max"))
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input and output types to numeric tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Min,
+    12,
+    OpSchema()
+        .FillUsing(ElementwiseMultiOpDocGenerator_opset8("min"))
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input and output types to numeric tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sum,
+    8,
+    OpSchema()
+        .FillUsing(ElementwiseMultiOpDocGenerator_opset8("sum"))
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Mean,
+    8,
+    OpSchema()
+        .FillUsing(ElementwiseMultiOpDocGenerator_opset8("mean"))
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Clip_ver12_doc = R"DOC(
+Clip operator limits the given input within an interval. The interval is
+specified by the inputs 'min' and 'max'. They default to
+numeric_limits::lowest() and numeric_limits::max(), respectively.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Clip,
+    12,
+    OpSchema()
+        .SetDoc(Clip_ver12_doc)
+        .Input(0, "input", "Input tensor whose elements to be clipped", "T")
+        .Input(
+            1,
+            "min",
+            "Minimum value, under which element is replaced by min. "
+            "It must be a scalar(tensor of empty shape).",
+            "T",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "max",
+            "Maximum value, above which element is replaced by max. "
+            "It must be a scalar(tensor of empty shape).",
+            "T",
+            OpSchema::Optional)
+        .Output(0, "output", "Output tensor with clipped input elements", "T")
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input and output types to all numeric tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* Gemm_ver11_doc = R"DOC(General Matrix multiplication:
+https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+
+A' = transpose(A) if transA else A
+
+B' = transpose(B) if transB else B
+
+Compute Y = alpha * A' * B' + beta * C, where input tensor A has shape (M, K) or (K, M),
+input tensor B has shape (K, N) or (N, K), input tensor C is broadcastable to shape (M, N),
+and output tensor Y has shape (M, N). A will be transposed before doing the
+computation if attribute transA is non-zero, same for B and transB.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gemm,
+    11,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(
+            std::string(Gemm_ver11_doc) + GenerateBroadcastingDocUni("tensor C", "tensor A * B") + "\n" +
+            GenerateOptionalArgumentsDoc()))
+        .Input(
+            0,
+            "A",
+            "Input tensor A. "
+            "The shape of A should be (M, K) if transA is 0, "
+            "or (K, M) if transA is non-zero.",
+            "T")
+        .Input(
+            1,
+            "B",
+            "Input tensor B. "
+            "The shape of B should be (K, N) if transB is 0, "
+            "or (N, K) if transB is non-zero.",
+            "T")
+        .Input(
+            2,
+            "C",
+            "Optional input tensor C. "
+            "If not specified, the computation is done as if C is a scalar 0. "
+            "The shape of C should be unidirectional broadcastable to (M, N).",
+            "T",
+            OpSchema::Optional)
+        .Output(0, "Y", "Output tensor of shape (M, N).", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::UInt32, types::UInt64, types::Int32, types::Int64},
+            "Constrain input and output types to float/int tensors.")
+        .Attr("transA", "Whether A should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("transB", "Whether B should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("alpha", "Scalar multiplier for the product of input tensors A * B.", AttributeProto::FLOAT, 1.0f)
+        .Attr("beta", "Scalar multiplier for input tensor C.", AttributeProto::FLOAT, 1.0f)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2)) {
+            auto transAAttr = ctx.getAttribute("transA");
+            bool transA = transAAttr ? static_cast<int>(transAAttr->i()) != 0 : false;
+            auto transBAttr = ctx.getAttribute("transB");
+            bool transB = transBAttr ? static_cast<int>(transBAttr->i()) != 0 : false;
+            auto& first_input_shape = getInputShape(ctx, 0);
+            auto& second_input_shape = getInputShape(ctx, 1);
+            if (first_input_shape.dim_size() != 2) {
+              fail_shape_inference("First input does not have rank 2");
+            }
+            if (second_input_shape.dim_size() != 2) {
+              fail_shape_inference("Second input does not have rank 2");
+            }
+            updateOutputShape(ctx, 0, {first_input_shape.dim(transA ? 1 : 0), second_input_shape.dim(transB ? 0 : 1)});
+          }
+        }));
+
+static void matmulShapeInference_opset_9(ONNX_NAMESPACE::InferenceContext& ctx, size_t input1Idx, size_t input2Idx) {
+  if (!hasInputShape(ctx, input1Idx) || !hasInputShape(ctx, input2Idx)) {
+    return;
+  }
+
+  const auto shape0 = ctx.getInputType(input1Idx)->tensor_type().shape();
+  const auto shape1 = ctx.getInputType(input2Idx)->tensor_type().shape();
+
+  if (shape0.dim_size() == 0 || shape1.dim_size() == 0) {
+    fail_shape_inference("Input tensors of wrong rank (0).");
+  }
+
+  ONNX_NAMESPACE::TensorShapeProto shapeL, shapeR;
+
+  // First promote each shape to at least rank-2. This logic is
+  // specific to matmul, not generic broadcasting.
+  {
+    if (shape0.dim_size() == 1) {
+      shapeL.add_dim()->set_dim_value(1);
+      *shapeL.add_dim() = shape0.dim(0);
+    } else {
+      *shapeL.mutable_dim() = shape0.dim();
+    }
+    if (shape1.dim_size() == 1) {
+      *shapeR.add_dim() = shape1.dim(0);
+      shapeR.add_dim()->set_dim_value(1);
+    } else {
+      *shapeR.mutable_dim() = shape1.dim();
+    }
+  }
+
+  // Check for compatible matrix multiply dimensions
+  {
+    const auto& dimL = shapeL.dim(shapeL.dim_size() - 1);
+    const auto& dimR = shapeR.dim(shapeR.dim_size() - 2);
+    if (dimL.has_dim_value() && dimR.has_dim_value() && dimL.dim_value() != dimR.dim_value()) {
+      fail_shape_inference("Incompatible dimensions for matrix multiplication");
+    }
+  }
+
+  ONNX_NAMESPACE::TensorShapeProto resultShape;
+
+  // Now call out to generic multidimensional broadcasting for
+  // the broadcastable prefixes.
+  {
+    ONNX_NAMESPACE::TensorShapeProto prefixShapeL, prefixShapeR;
+    for (int i = 0; i < shapeL.dim_size() - 2; ++i) {
+      *prefixShapeL.add_dim() = shapeL.dim(i);
+    }
+    for (int i = 0; i < shapeR.dim_size() - 2; ++i) {
+      *prefixShapeR.add_dim() = shapeR.dim(i);
+    }
+    bidirectionalBroadcastShapeInference(prefixShapeL, prefixShapeR, resultShape);
+  }
+
+  // Back to matmul-specific. Add the trailing dimensions back in.
+  {
+    if (shape0.dim_size() != 1) {
+      *resultShape.add_dim() = shapeL.dim(shapeL.dim_size() - 2);
+    }
+    if (shape1.dim_size() != 1) {
+      *resultShape.add_dim() = shapeR.dim(shapeR.dim_size() - 1);
+    }
+  }
+
+  *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = resultShape;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MatMul,
+    9,
+    OpSchema()
+        .Input(0, "A", "N-dimensional matrix A", "T")
+        .Input(1, "B", "N-dimensional matrix B", "T")
+        .Output(0, "Y", "Matrix multiply results from A * B", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::UInt32, types::UInt64, types::Int32, types::Int64},
+            "Constrain input and output types to float/int tensors.")
+        .SetDoc(kDoc_MatMul_ver9)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          matmulShapeInference_opset_9(ctx, 0, 1);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Expand,
+    8,
+    OpSchema()
+        .SetDoc(kDoc_Expand_ver8)
+        .Input(0, "input", "Input tensor", "T")
+        .Input(
+            1,
+            "shape",
+            "A 1-D tensor indicates the shape you want to expand to, following the broadcast rule",
+            "tensor(int64)")
+        .Output(0, "output", "Output tensor", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          // For shape inference, we need both input shape
+          const auto shape_initializer = ctx.getInputData(1);
+          if (hasNInputShapes(ctx, 2)) {
+            const auto& shape_input_shape = ctx.getInputType(1)->tensor_type().shape();
+            if (shape_input_shape.dim_size() != 1) {
+              fail_shape_inference("'shape' input must be 1D tensor");
+            }
+
+            const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            TensorShapeProto second_shape;
+            if (nullptr != shape_initializer) {
+              const auto shape_data = ParseData<int64_t>(shape_initializer);
+
+              for (const auto& e : shape_data) {
+                auto dim = second_shape.add_dim();
+                dim->set_dim_value(e);
+              }
+            } else if (shape_input_shape.dim(0).has_dim_value()) {
+              // Attempt rank inference using shape of shape input
+              int64_t dim_value = shape_input_shape.dim(0).dim_value();
+              for (int64_t i = 0; i < dim_value; ++i) {
+                second_shape.add_dim();
+              }
+            } else {
+              return;
+            }
+            bidirectionalBroadcastShapeInference(input_shape, second_shape, *getOutputShape(ctx, 0));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sign,
+    9,
+    OpSchema()
+        .SetDoc(kDoc_Sign_ver9)
+        .Input(0, "input", "Input tensor", "T")
+        .Output(
+            0,
+            "output",
+            "The sign of the input tensor "
+            "computed element-wise. It has the same shape and type of the input.",
+            "T")
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input and output types to all numeric tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Erf,
+    9,
+    OpSchema()
+        .SetDoc(kDoc_Erf_ver9)
+        .Input(0, "input", "Input tensor", "T")
+        .Output(
+            0,
+            "output",
+            "The error function of the input tensor "
+            "computed element-wise. It has the same shape and type of the input.",
+            "T")
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input and output types to all numeric tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CumSum,
+    11,
+    OpSchema()
+        .SetDoc(kDoc_CumSum_ver11)
+        .Attr(
+            "exclusive",
+            "If set to 1 will return exclusive sum in which the top element is not included."
+            " In other terms, if set to 1, the j-th output element would be the sum of the first (j-1) elements."
+            " Otherwise, it would be the sum of the first j elements.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "reverse",
+            "If set to 1 will perform the sums in reverse direction.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "x",
+            "An input tensor that is to be processed.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "axis",
+            "A 0-D tensor. Must be in the range [-rank(x), rank(x)-1]. "
+            "Negative value means counting dimensions from the back.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "y",
+            "Output tensor of the same type as 'x' with cumulative sums of the x's elements",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::UInt32, types::UInt64, types::Int32, types::Int64, types::Float, types::Double},
+            "Input can be of any tensor type.")
+        .TypeConstraint("T2", {types::Int32, types::Int64}, "axis tensor can be int32 or int64 only")
+        .TypeAndShapeInferenceFunction(ONNX_NAMESPACE::propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* NegativeLogLikelihoodLoss_ver12_doc = R"DOC(
+A NegativeLogLikelihoodLoss operator computes (weighted) negative log likelihood loss.
+Its "input" tensor has the shape of (N, C, d1, d2, ..., dk) where k >= 0.
+The "input" tensor contains log-probabilities for input[n, :, d_1, d_2,..., d_k] being in a class of [0, C).
+The operator's "target" input tensor has the shape of (N, d1, d2, ..., dk). It encodes class labels (one of C classes)
+or it may contain a special value (indicated by an attribute ignore_index) for N x d1 x d2 x ... x dk samples.
+The loss value for input[n, :, d_1, d_2,...d_k] being classified as class c = target[n][d_1][d_2]...[d_k] is computed as:
+    loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k].
+When an optional "weight" is provided, the sample loss is calculated as:
+    loss[n][d_1][d_2]...[d_k] = -input[n][c][d_1][d_2]...[d_k] * weight[c].
+loss is zero for the case when target-value equals ignore_index.
+
+    loss[n][d_1][d_2]...[d_k] = 0, when target[n][d_1][d_2]...[d_k] = ignore_index
+If "reduction" attribute is set to "none", the operator's output will be the above loss with shape (N, d1, d2, ..., dk).
+If "reduction" attribute is set to "mean" (the default attribute value), the output loss is (weight) averaged:
+    mean(loss), if "weight" is not provided,
+or if weight is provided,
+    sum(loss) / sum(weight[target[n][d_1][d_2]...[d_k]]]), for all samples.
+If "reduction" attribute is set to "sum", the output is a scalar:
+    sum(loss).
+See also https://pytorch.org/docs/stable/nn.html#torch.nn.NLLLoss.
+Example 1:
+    // negative log likelihood loss, "none" reduction
+    N, C, d1 = 2, 3, 2
+    input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+             [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+    target = [[2, 1], [0, 2]]
+    loss = np.zeros((N, d1))
+    for n in range(N):
+        for d_1 in range(d1):
+            c = target[n][d_1]
+            loss[n][d_1] = -input[n][c][d_1]
+    // print(loss)
+    // [[-3. -2.]
+    //  [-0. -2.]]
+Example 2:
+    // weighted negative log likelihood loss, sum reduction
+    N, C, d1 = 2, 3, 2
+    input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+            [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+    target = [[2, 1], [0, 2]]
+    weight = [0.2, 0.3, 0.1]
+    loss = np.zeros((N, d1))
+    for n in range(N):
+        for d_1 in range(d1):
+            c = target[n][d_1]
+            loss[n][d_1] = -input[n][c][d_1] * weight[c]
+    loss = np.sum(loss)
+    // print(loss)
+    // -1.1
+Example 3:
+    // weighted negative log likelihood loss, mean reduction
+    N, C, d1 = 2, 3, 2
+    input = [[[1.0, 2.0], [2.0, 2.0], [3.0, 2.0]],
+            [[0.0, 1.0], [2.0, 2.0], [1.0, 2]]]
+    target = [[2, 1], [0, 2]]
+    weight = [0.2, 0.3, 0.1]
+    loss = np.zeros((N, d1))
+    weight_total = 0
+    for n in range(N):
+        for d_1 in range(d1):
+            c = target[n][d_1]
+            loss[n][d_1] = -input[n][c][d_1] * weight[c]
+            weight_total = weight_total + weight[c]
+    loss = np.sum(loss) / weight_total
+    // print(loss)
+    // -1.57
+)DOC";
+
+static TensorProto ToDimensionOneFloatTensor_old(float value) {
+  auto t = ToTensor(std::vector<float>({value}));
+  t.add_dims(1);
+  return t;
+}
+
+static TensorProto ToDimensionOneTensor_old(int32_t value) {
+  auto t = ToTensor(std::vector<int32_t>({value}));
+  t.add_dims(1);
+  return t;
+}
+
+static TensorProto ToDimensionOneInt64Tensor_old(int64_t value) {
+  auto t = ToTensor(std::vector<int64_t>({value}));
+  t.add_dims(1);
+  return t;
+}
+
+static TensorProto ToDimensionOneInt64Tensor_old(const std::vector<int64_t>& value) {
+  auto t = ToTensor(value);
+  t.add_dims(static_cast<int64_t>(value.size()));
+  return t;
+}
+
+static bool BuildContextDependentFunctionBody_opset12(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  if (ctx.getInputType(0) == nullptr) {
+    // we cannot create a correct function body without knowing the input type
+    return false;
+  }
+  auto input_type = ctx.getInputType(0)->tensor_type().elem_type();
+  bool float_input = input_type == TensorProto_DataType_FLOAT;
+  const auto* const reduction_attr_proto = ctx.getAttribute("reduction");
+  std::string reduction_attr =
+      reduction_attr_proto != nullptr && reduction_attr_proto->has_s() ? reduction_attr_proto->s() : "mean";
+  std::vector<FunctionBodyHelper::NodeDef> body;
+  body.reserve(23);
+  body.push_back({{"const_zero"}, "Constant", {}, {MakeAttribute("value", ToDimensionOneTensor_old(0))}});
+
+  body.push_back({{"const_one"}, "Constant", {}, {MakeAttribute("value", ToDimensionOneTensor_old(1))}});
+
+  body.push_back({{"expanded_target"}, "Unsqueeze", {"target"}, {MakeAttribute("axes", std::vector<int64_t>({1}))}});
+
+  if (ctx.getAttribute("ignore_index") == nullptr) {
+    body.push_back(
+        {{"input_gather_element"},
+         "GatherElements",
+         {"input", "expanded_target"},
+         {MakeAttribute("axis", static_cast<int64_t>(1))}});
+
+    body.push_back({{"loss_NCdd"}, "Neg", {"input_gather_element"}});
+
+    body.push_back({{"loss_N1dd"}, "Slice", {"loss_NCdd", "const_zero", "const_one", "const_one"}});
+
+    if (!ctx.hasInput(2)) {
+      if (reduction_attr == "none") {
+        body.push_back({{"loss"}, "Squeeze", {"loss_N1dd"}, {MakeAttribute("axes", std::vector<int64_t>({1}))}});
+      } else {
+        body.push_back({{"loss_Ndd"}, "Squeeze", {"loss_N1dd"}, {MakeAttribute("axes", std::vector<int64_t>({1}))}});
+        if (reduction_attr == "mean") {
+          body.push_back({{"loss"}, "ReduceMean", {"loss_Ndd"}, {MakeAttribute("keepdims", static_cast<int64_t>(0))}});
+        } else {
+          body.push_back({{"loss"}, "ReduceSum", {"loss_Ndd"}, {MakeAttribute("keepdims", static_cast<int64_t>(0))}});
+        }
+      }
+    } else {
+      body.push_back({{"weight_gather"}, "Gather", {"weight", "target"}});
+      body.push_back(
+          {{"loss_unweighted"}, "Squeeze", {"loss_N1dd"}, {MakeAttribute("axes", std::vector<int64_t>({1}))}});
+      if (reduction_attr == "none") {
+        body.push_back({{"loss"}, "Mul", {"loss_unweighted", "weight_gather"}});
+      } else {
+        body.push_back({{"loss_Ndd"}, "Mul", {"loss_unweighted", "weight_gather"}});
+        if (reduction_attr == "mean") {
+          body.push_back(
+              {{"loss_sum"}, "ReduceSum", {"loss_Ndd"}, {MakeAttribute("keepdims", static_cast<int64_t>(0))}});
+          body.push_back(
+              {{"weight_gather_sum"},
+               "ReduceSum",
+               {"weight_gather"},
+               {MakeAttribute("keepdims", static_cast<int64_t>(0))}});
+          body.push_back({{"loss"}, "Div", {"loss_sum", "weight_gather_sum"}});
+        } else {
+          body.push_back({{"loss"}, "ReduceSum", {"loss_Ndd"}, {MakeAttribute("keepdims", static_cast<int64_t>(0))}});
+        }
+      }
+    }
+  } else {
+    body.push_back(
+        {{"const_ignore_index"},
+         "Constant",
+         {},
+         {MakeAttribute("value", ToDimensionOneInt64Tensor_old(ctx.getAttribute("ignore_index")->i()))}});
+
+    body.push_back({{"const_zero_target_typed"}, "Sub", {"expanded_target", "expanded_target"}});
+    body.push_back(
+        {{"expanded_target_int64"},
+         "Cast",
+         {"expanded_target"},
+         {MakeAttribute("to", static_cast<int64_t>(TensorProto_DataType::TensorProto_DataType_INT64))}});
+
+    body.push_back({{"mask"}, "Equal", {"expanded_target_int64", "const_ignore_index"}});
+    body.push_back({{"transform_targets"}, "Where", {"mask", "const_zero_target_typed", "expanded_target"}});
+    body.push_back(
+        {{"input_gather_element"},
+         "GatherElements",
+         {"input", "transform_targets"},
+         {MakeAttribute("axis", static_cast<int64_t>(1))}});
+    body.push_back(
+        {{"const_zero_float"}, "Constant", {}, {MakeAttribute("value", ToDimensionOneFloatTensor_old(0.0f))}});
+    if (!float_input) {
+      body.push_back(
+          {{"const_zero_casted"},
+           "Cast",
+           {"const_zero_float"},
+           {MakeAttribute("to", static_cast<int64_t>(input_type))}});
+    }
+    body.push_back(
+        {{"input_gather_element_transform"},
+         "Where",
+         {"mask", float_input ? "const_zero_float" : "const_zero_casted", "input_gather_element"}});
+    body.push_back({{"loss_NCdd"}, "Neg", {"input_gather_element_transform"}});
+    body.push_back({{"loss_N1dd"}, "Slice", {"loss_NCdd", "const_zero", "const_one", "const_one"}});
+
+    if (!ctx.hasInput(2)) {
+      body.push_back({{"squeeze_mask"}, "Squeeze", {"mask"}, {MakeAttribute("axes", std::vector<int64_t>({1}))}});
+
+      body.push_back(
+          {{"const_one_float"}, "Constant", {}, {MakeAttribute("value", ToDimensionOneFloatTensor_old(1.0f))}});
+      if (!float_input) {
+        body.push_back(
+            {{"const_one_casted"},
+             "Cast",
+             {"const_one_float"},
+             {MakeAttribute("to", static_cast<int64_t>(input_type))}});
+      }
+      body.push_back(
+          {{"weight_gather"},
+           "Where",
+           {"squeeze_mask",
+            float_input ? "const_zero_float" : "const_zero_casted",
+            float_input ? "const_one_float" : "const_one_casted"}});
+
+    } else {
+      body.push_back({{"weight_gather_temp"}, "Gather", {"weight", "transform_targets"}});
+
+      body.push_back(
+          {{"weight_gather_temp_1"},
+           "Where",
+           {"mask", float_input ? "const_zero_float" : "const_zero_casted", "weight_gather_temp"}});
+
+      body.push_back(
+          {{"weight_gather"}, "Squeeze", {"weight_gather_temp_1"}, {MakeAttribute("axes", std::vector<int64_t>({1}))}});
+    }
+
+    body.push_back({{"loss_unweighted"}, "Squeeze", {"loss_N1dd"}, {MakeAttribute("axes", std::vector<int64_t>({1}))}});
+    if (reduction_attr == "none") {
+      body.push_back({{"loss"}, "Mul", {"loss_unweighted", "weight_gather"}});
+    } else {
+      body.push_back({{"loss_Ndd"}, "Mul", {"loss_unweighted", "weight_gather"}});
+      if (reduction_attr == "mean") {
+        body.push_back({{"loss_sum"}, "ReduceSum", {"loss_Ndd"}, {MakeAttribute("keepdims", static_cast<int64_t>(0))}});
+        body.push_back(
+            {{"weight_gather_sum"},
+             "ReduceSum",
+             {"weight_gather"},
+             {MakeAttribute("keepdims", static_cast<int64_t>(0))}});
+        body.push_back({{"loss"}, "Div", {"loss_sum", "weight_gather_sum"}});
+      } else {
+        body.push_back({{"loss"}, "ReduceSum", {"loss_Ndd"}, {MakeAttribute("keepdims", static_cast<int64_t>(0))}});
+      }
+    }
+  }
+
+  auto func_nodes = FunctionBodyHelper::BuildNodes(body);
+  for (const auto& node : func_nodes) {
+    auto* new_node = functionProto.add_node();
+    new_node->CopyFrom(node);
+  }
+
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    NegativeLogLikelihoodLoss,
+    12,
+    OpSchema()
+        .SetDoc(NegativeLogLikelihoodLoss_ver12_doc)
+        .Input(0, "input", "Input tensor of shape (N, C) or (N, C, d1, d2, ..., dk).", "T")
+        .Input(
+            1,
+            "target",
+            "Target tensor of shape (N) or (N, d1, d2, ..., dk). Target element value shall be in range of [0, C). "
+            "If ignore_index is specified, it may have a value outside [0, C) and the target values should either be "
+            "in the range [0, C) or have the value ignore_index.",
+            "Tind")
+        .Input(
+            2,
+            "weight",
+            "Optional rescaling weight tensor. "
+            "If given, it has to be a tensor of size C. Otherwise, it is treated as if having all ones.",
+            "T",
+            OpSchema::Optional)
+        .Output(0, "loss", "The negative log likelihood loss", "T")
+        .Attr(
+            "reduction",
+            "Type of reduction to apply to loss: none, sum, mean (default). "
+            "'none': the output is the loss for each sample. "
+            "'sum': the output will be summed. "
+            "'mean': the sum of the output will be divided by the sum of applied weights.",
+            AttributeProto::STRING,
+            std::string("mean"))
+        .Attr(
+            "ignore_index",
+            "Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.",
+            AttributeProto::INT,
+            false)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input, weight, and output types to floating-point tensors.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain target to integer types")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBody_opset12)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          if (hasNInputShapes(ctx, 2)) {
+            const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            const TensorShapeProto& target_shape = ctx.getInputType(1)->tensor_type().shape();
+
+            const int input_rank = static_cast<int>(input_shape.dim_size());
+            const int target_rank = static_cast<int>(target_shape.dim_size());
+
+            if (input_rank < 2) {
+              fail_shape_inference("Input rank must be >= 2. input_rank=", input_rank);
+            }
+            if (target_rank != input_rank - 1) {
+              fail_shape_inference(
+                  "Target rank must be 1 less than the input rank. input_rank=",
+                  input_rank,
+                  ", target_rank=",
+                  target_rank);
+            }
+
+            // match input dimensions (N, C, d1, ..., dk) with target
+            // dimensions of (C, d1, ..., dk)
+            for (int dim = 0; dim < target_rank; dim++) {
+              const auto input_dim = dim == 0 ? input_shape.dim(dim) : input_shape.dim(dim + 1);
+              const auto target_dim = target_shape.dim(dim);
+              if (input_dim.has_dim_value() && target_dim.has_dim_value() &&
+                  input_dim.dim_value() != target_dim.dim_value())
+                fail_shape_inference(
+                    "Input and target dimension value mismatch. input_dim_value=",
+                    input_dim.dim_value(),
+                    " target_dim_value=",
+                    target_dim.dim_value());
+            }
+
+            if (ctx.getNumInputs() == 3 && hasInputShape(ctx, 2)) {
+              const TensorShapeProto& weight_shape = ctx.getInputType(2)->tensor_type().shape();
+              const auto weight_rank = weight_shape.dim_size();
+              if (weight_rank != 1) {
+                fail_shape_inference("Weight rank must be 1. weight_rank=", weight_rank);
+              }
+            }
+
+            TensorShapeProto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+            if (getAttribute(ctx, "reduction", "mean") == "none") {
+              // output tensor is of shape (N, d1, d2, ..., dk) if
+              // reduction attribute is "none".
+              for (int i = 0; i < input_rank - 1; i++) {
+                auto dim = output_shape->add_dim();
+                if (i == 0)
+                  *dim = input_shape.dim(i);
+                else
+                  *dim = input_shape.dim(i + 1);
+              }
+            }
+            // otherwise output is a scalar.
+          }
+        }));
+
+static constexpr const char* reduction_doc_sce_opset12 =
+    "Type of reduction to apply to loss: none, sum, mean(default). "
+    "'none': no reduction will be applied, "
+    "'sum': the output will be summed. "
+    "'mean': the sum of the output will be divided by the number of "
+    "elements in the output.";
+
+static constexpr const char* SoftmaxCrossEntropyLoss_ver12_doc =
+    R"DOC(Loss function that measures the softmax cross entropy
+between 'scores' and 'labels'.
+This operator first computes a loss tensor whose shape is identical to the labels input.
+If the input is 2-D with shape (N, C), the loss tensor may be a N-element vector L = (l_1, l_2, ..., l_N).
+If the input is N-D tensor with shape (N, C, D1, D2, ..., Dk),
+the loss tensor L may have (N, D1, D2, ..., Dk) as its shape and L[i,][j_1][j_2]...[j_k] denotes a scalar element in L.
+After L is available, this operator can optionally do a reduction operator.
+
+shape(scores): (N, C) where C is the number of classes, or (N, C, D1, D2,..., Dk),
+        with K >= 1 in case of K-dimensional loss.
+shape(labels): (N) where each value is 0 <= labels[i] <= C-1, or (N, D1, D2,..., Dk),
+        with K >= 1 in case of K-dimensional loss.
+
+The loss for one sample, l_i, can calculated as follows:
+    l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk], where i is the index of classes.
+or
+    l[i][d1][d2]...[dk] = -y[i][c][d1][d2]..[dk] * weights[c], if 'weights' is provided.
+
+loss is zero for the case when label-value equals ignore_index.
+    l[i][d1][d2]...[dk]  = 0, when labels[n][d1][d2]...[dk] = ignore_index
+
+where:
+    p = Softmax(scores)
+    y = Log(p)
+    c = labels[i][d1][d2]...[dk]
+
+Finally, L is optionally reduced:
+If reduction = 'none', the output is L with shape (N, D1, D2, ..., Dk).
+If reduction = 'sum', the output is scalar: Sum(L).
+If reduction = 'mean', the output is scalar: ReduceMean(L), or if weight is provided: ReduceSum(L) / ReduceSum(W),
+where tensor W is of shape (N, D1, D2, ..., Dk) and W[n][d1][d2]...[dk] = weights[labels[i][d1][d2]...[dk]].
+)DOC";
+
+static bool BuildContextDependentFunctionBodySCE_opset12(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  std::vector<FunctionBodyHelper::NodeDef> body;
+  body.reserve(9);
+
+  // Using stable implementation of LogSoftmax
+  body.push_back({{"Shape3D"}, "Constant", {}, {MakeAttribute("value", ToDimensionOneInt64Tensor_old({0, 0, -1}))}});
+  body.push_back({{"X_NCD"}, "Reshape", {"scores", "Shape3D"}});
+  body.push_back({{"X_NDC"}, "Transpose", {"X_NCD"}, {MakeAttribute("perm", std::vector<int64_t>({0, 2, 1}))}});
+  body.push_back({{"X_LogSM"}, "LogSoftmax", {"X_NDC"}, {MakeAttribute("axis", static_cast<int64_t>(2))}});
+  body.push_back({{"X_LogSM_NCD"}, "Transpose", {"X_LogSM"}, {MakeAttribute("perm", std::vector<int64_t>({0, 2, 1}))}});
+  body.push_back({{"X_shape"}, "Shape", {"scores"}});
+  body.push_back({{"X_Log"}, "Reshape", {"X_LogSM_NCD", "X_shape"}});
+
+  // Review(mzs): Ideally we want to reuse the output from Log for sub-graph
+  // output as well but looking at the graph resolve code it does not include
+  // graph outputs as intermediate outputs, hence if intermediate X_log is
+  // renamed as log_prob then it will be treated as graph output and will not be
+  // available to NegativeLogLikelihoodLoss. May be my understanding is
+  // incorrect or there is a bug in function population code in ORTbut I will
+  // dig further to be 100%. In the meantime we just replicate the log.
+  if (ctx.hasOutput(1)) {
+    body.push_back({{"log_prob"}, "Identity", {"X_Log"}});
+  }
+
+  std::vector<std::string> input_tensor_names{"X_Log", "labels"};
+  std::vector<FunctionBodyHelper::AttributeProtoWrapper> attributes{
+      MakeRefAttribute("reduction", AttributeProto::STRING)};
+  // Add weights as input if needed.
+  if (ctx.hasInput(2)) {
+    input_tensor_names.emplace_back("weights");
+  }
+
+  // add ignore_index attributes if needed.
+  if (ctx.getAttribute("ignore_index") != nullptr) {
+    attributes.emplace_back(MakeRefAttribute("ignore_index", AttributeProto::INT));
+  }
+
+  body.push_back({{"output"}, "NegativeLogLikelihoodLoss", input_tensor_names, attributes});
+
+  auto func_nodes = FunctionBodyHelper::BuildNodes(body);
+  for (const auto& node : func_nodes) {
+    auto* new_node = functionProto.add_node();
+    new_node->CopyFrom(node);
+  }
+
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SoftmaxCrossEntropyLoss,
+    12,
+    OpSchema()
+        .SetDoc(SoftmaxCrossEntropyLoss_ver12_doc)
+        .Attr("reduction", reduction_doc_sce_opset12, AttributeProto::STRING, std::string("mean"))
+        .Attr(
+            "ignore_index",
+            "Specifies a target value that is ignored and does not contribute to the input gradient. It's an optional value.",
+            AttributeProto::INT,
+            false)
+        .Input(
+            0,
+            "scores",
+            "The predicted outputs with shape [batch_size, class_size], or "
+            "[batch_size, class_size, D1, D2 , ..., Dk], where K is the number of dimensions.",
+            "T")
+        .Input(
+            1,
+            "labels",
+            "The ground truth output tensor, with shape [batch_size], or "
+            "[batch_size, D1, D2, ..., Dk], where K is the number of dimensions. "
+            "Labels element value shall be in range of [0, C). "
+            "If ignore_index is specified, it may have a value outside [0, C) and the label values should either be "
+            "in the range [0, C) or have the value ignore_index.",
+            "Tind")
+        .Input(
+            2,
+            "weights",
+            "A manual rescaling weight given to each class. If given, it has to "
+            "be a 1D Tensor assigning weight to each of the classes. Otherwise, "
+            "it is treated as if having all ones.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "output",
+            "Weighted loss float Tensor. If reduction is 'none', this has the "
+            "shape of [batch_size], or [batch_size, D1, D2, ..., Dk] in case of "
+            "K-dimensional loss. Otherwise, it is a scalar.",
+            "T")
+        .Output(
+            1,
+            "log_prob",
+            "Log probability tensor. If the output of softmax is prob, its value is log(prob).",
+            "T",
+            OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain target to integer types")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBodySCE_opset12)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          std::string reduction = getAttribute(ctx, "reduction", "mean");
+          if (reduction == "none") {
+            if (hasInputShape(ctx, 1)) {
+              propagateShapeFromInputToOutput(ctx, 1, 0);
+            }
+          } else {
+            updateOutputShape(ctx, 0, TensorShapeProto());
+          }
+
+          if (ctx.getNumOutputs() == 2) {
+            propagateElemTypeFromInputToOutput(ctx, 0, 1);
+            propagateShapeFromInputToOutput(ctx, 0, 1);
+          }
+        }));
+
+static std::function<void(OpSchema&)> SoftmaxFamilyDocGenerator_opset1(const char* name, const char* description) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+The operator computes the {name} ({description}) values for each layer in the batch
+ of the given input. The input is a 2-D tensor (Tensor<float>) of size
+(batch_size x input_feature_dimensions). The output tensor has the same shape
+and contains the {name} values of the corresponding input.
+
+Input does not need to explicitly be a 2D vector; rather, it will be
+coerced into one. For an arbitrary n-dimensional tensor
+input \in [a_0, a_1, ..., a_{k-1}, a_k, ..., a_{n-1}] and k is
+the axis provided, then input will be coerced into a 2-dimensional tensor with
+dimensions [a_0 * ... * a_{k-1}, a_k * ... * a_{n-1}]. For the default
+case where axis=1, this means the input tensor will be coerced into a 2D tensor
+of dimensions [a_0, a_1 * ... * a_{n-1}], where a_0 is often the batch size.
+In this situation, we must have a_0 = N and a_1 * ... * a_{n-1} = D.
+Each of these dimensions must be matched correctly, or else the operator
+will throw errors.
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{description}", description););
+    schema.SetDoc(doc);
+    schema.Attr(
+        "axis",
+        "Describes the axis of the inputs when coerced "
+        "to 2D; defaults to one because the 0th axis most likely describes "
+        "the batch_size",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Input(
+        0,
+        "input",
+        "The input tensor that's coerced into a 2D matrix of size (NxD) "
+        "as described above.",
+        "T");
+    schema.Output(
+        0,
+        "output",
+        "The output values with the same "
+        "shape as input tensor (the original size without coercion).",
+        "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput);
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Softmax,
+    1,
+    OpSchema().FillUsing(SoftmaxFamilyDocGenerator_opset1("softmax", "normalized exponential")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LogSoftmax,
+    1,
+    OpSchema().FillUsing(SoftmaxFamilyDocGenerator_opset1("logsoftmax", "log of softmax")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Hardmax,
+    1,
+    OpSchema().FillUsing(
+        SoftmaxFamilyDocGenerator_opset1("hardmax", "1 for the first maximum value, and 0 for all others")));
+
+static constexpr const char* kBroadcastDoc_old = R"DOC(
+If necessary the right-hand-side argument will be broadcasted to match the
+shape of left-hand-side argument. When broadcasting is specified, the second
+tensor can either be of element size 1 (including a scalar tensor and any
+tensor with rank equal to or smaller than the first tensor), or having its
+shape as a contiguous subset of the first tensor's shape. The starting of the
+mutually equal shape is specified by the argument "axis", and if it is not set,
+suffix matching is assumed. 1-dim expansion doesn't work yet.
+
+For example, the following tensor shapes are supported (with broadcast=1):
+
+  shape(A) = (2, 3, 4, 5), shape(B) = (,), i.e. B is a scalar tensor
+  shape(A) = (2, 3, 4, 5), shape(B) = (1, 1), i.e. B is an 1-element tensor
+  shape(A) = (2, 3, 4, 5), shape(B) = (5,)
+  shape(A) = (2, 3, 4, 5), shape(B) = (4, 5)
+  shape(A) = (2, 3, 4, 5), shape(B) = (3, 4), with axis=1
+  shape(A) = (2, 3, 4, 5), shape(B) = (2), with axis=0
+
+Attribute `broadcast=1` needs to be passed to enable broadcasting.
+)DOC";
+
+static std::function<void(OpSchema&)> MathDocGenerator_old(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Performs element-wise binary {name} (with limited broadcast support).
+{broadcast_doc})DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", kBroadcastDoc_old););
+    schema.SetDoc(doc);
+    schema.Attr("broadcast", "Pass 1 to enable broadcasting", AttributeProto::INT, static_cast<int64_t>(0));
+
+    // This attribute was added via AllowConsumed API in OpSchema.
+    // After removing the API, we're now using the Attr API to simulate the old
+    // definition.
+    schema.Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "axis", "If set, defines the broadcast dimensions. See doc for details.", AttributeProto::INT, OPTIONAL_VALUE);
+    schema.Input(0, "A", "First operand, should share the type with the second operand.", "T");
+    schema.Input(
+        1,
+        "B",
+        "Second operand. With broadcasting can be of smaller size than A. "
+        "If broadcasting is disabled it should be of the same size.",
+        "T");
+    schema.Output(0, "C", "Result, has same dimensions and type as A", "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+  };
+}
+
+static std::function<void(OpSchema&)> MathDocGenerator_old_opset6(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    if (std::string(name) == "division") {
+      POPULATE_OP_DOC_STR(
+          doc = R"DOC(
+Performs element-wise binary {name} (with limited broadcast support).
+{broadcast_doc}
+
+For integer inputs, the result is computed using truncating division (rounding toward zero).
+)DOC";
+          ReplaceAll(doc, "{name}", name);
+          ReplaceAll(doc, "{broadcast_doc}", kBroadcastDoc_old););
+    } else {
+      POPULATE_OP_DOC_STR(
+          doc = R"DOC(
+Performs element-wise binary {name} (with limited broadcast support).
+{broadcast_doc})DOC";
+          ReplaceAll(doc, "{name}", name);
+          ReplaceAll(doc, "{broadcast_doc}", kBroadcastDoc_old););
+    }
+    schema.SetDoc(doc);
+    schema.Attr("broadcast", "Pass 1 to enable broadcasting", AttributeProto::INT, static_cast<int64_t>(0));
+    schema.Attr(
+        "axis", "If set, defines the broadcast dimensions. See doc for details.", AttributeProto::INT, OPTIONAL_VALUE);
+    schema.Input(0, "A", "First operand, should share the type with the second operand.", "T");
+    schema.Input(
+        1,
+        "B",
+        "Second operand. With broadcasting can be of smaller size than A. "
+        "If broadcasting is disabled it should be of the same size.",
+        "T");
+    schema.Output(0, "C", "Result, has same dimensions and type as A", "T");
+    schema.TypeConstraint(
+        "T",
+        OpSchema::numeric_types_for_math_reduction(),
+        "Constrain input and output types to high-precision numeric tensors.");
+    schema.TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput);
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(Add, 1, OpSchema().FillUsing(MathDocGenerator_old("addition")));
+
+ONNX_OPERATOR_SET_SCHEMA(Sub, 1, OpSchema().FillUsing(MathDocGenerator_old("subtraction")));
+
+ONNX_OPERATOR_SET_SCHEMA(Mul, 1, OpSchema().FillUsing(MathDocGenerator_old("multiplication")));
+
+ONNX_OPERATOR_SET_SCHEMA(Div, 1, OpSchema().FillUsing(MathDocGenerator_old("division")));
+
+ONNX_OPERATOR_SET_SCHEMA(Add, 6, OpSchema().FillUsing(MathDocGenerator_old_opset6("addition")));
+
+ONNX_OPERATOR_SET_SCHEMA(Sub, 6, OpSchema().FillUsing(MathDocGenerator_old_opset6("subtraction")));
+
+ONNX_OPERATOR_SET_SCHEMA(Mul, 6, OpSchema().FillUsing(MathDocGenerator_old_opset6("multiplication")));
+
+ONNX_OPERATOR_SET_SCHEMA(Div, 6, OpSchema().FillUsing(MathDocGenerator_old_opset6("division")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pow,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Pow_ver13 + std::string(kBroadcastDoc_old))
+        .Input(0, "X", "Input tensor of any shape, base of the exponent.", "T")
+        .Input(
+            1,
+            "Y",
+            "Input tensor of any shape broadcastable to X shape, "
+            "the exponent component.",
+            "T")
+        .Attr("broadcast", "Pass 1 to enable broadcasting", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr(
+            "axis",
+            "If set, defines the broadcast dimensions. See doc for details.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Output(0, "Z", "Output tensor (same size as X)", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pow,
+    7,
+    OpSchema()
+        .SetDoc(std::string(kDoc_Pow_ver13) + GenerateBroadcastingDocMul())
+        .Input(0, "X", "First operand, base of the exponent.", "T")
+        .Input(1, "Y", "Second operand, power of the exponent.", "T")
+        .Output(0, "Z", "Output tensor.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2))
+            bidirectionalBroadcastShapeInference(
+                ctx.getInputType(0)->tensor_type().shape(),
+                ctx.getInputType(1)->tensor_type().shape(),
+                *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Neg,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Neg_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static const char* const Abs_ver1_doc = Abs_ver6_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Abs,
+    1,
+    OpSchema()
+        .SetDoc(Abs_ver1_doc)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reciprocal,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Reciprocal_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static const char* const Floor_ver1_doc = Floor_ver6_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Floor,
+    1,
+    OpSchema()
+        .SetDoc(Floor_ver1_doc)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static const char* const Ceil_ver1_doc = Ceil_ver6_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Ceil,
+    1,
+    OpSchema()
+        .SetDoc(Ceil_ver1_doc)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sqrt,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Sqrt_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Relu,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Relu_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LeakyRelu,
+    1,
+    OpSchema()
+        .Attr("alpha", "Coefficient of leakage default to 0.01.", AttributeProto::FLOAT, 0.01f)
+        .SetDoc(kDoc_LeakyRelu_ver1)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Selu,
+    1,
+    OpSchema()
+        .Attr("alpha", "Coefficient of SELU default to 1.6732.", AttributeProto::FLOAT, 1.6732f)
+        .Attr("gamma", "Coefficient of SELU default to 1.0507.", AttributeProto::FLOAT, 1.0507f)
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .SetDoc(kDoc_Selu_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Elu,
+    1,
+    OpSchema()
+        .Attr("alpha", "Coefficient of ELU default to 1.0.", AttributeProto::FLOAT, 1.0f)
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .SetDoc(kDoc_Elu_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Exp,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Exp_ver6)
+        .Input(0, "input", "Input tensor", "T")
+        .Output(
+            0,
+            "output",
+            "The exponential of the input tensor computed "
+            "element-wise",
+            "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Log,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Log_ver6)
+        .Input(0, "input", "Input tensor", "T")
+        .Output(
+            0,
+            "output",
+            "The natural log of the input tensor computed "
+            "element-wise",
+            "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Tanh,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Tanh_ver6)
+        .Input(0, "input", "1-D input tensor", "T")
+        .Output(
+            0,
+            "output",
+            "The hyperbolic tangent values of the input tensor "
+            "computed element-wise",
+            "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* PRelu_ver1_doc = R"DOC(
+
+PRelu takes input data (Tensor<T>) and slope tensor as input, and produces one
+output data (Tensor<T>) where the function `f(x) = slope * x for x < 0`,
+`f(x) = x for x >= 0`., is applied to the data tensor elementwise.
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    PRelu,
+    1,
+    OpSchema()
+        .SetDoc(PRelu_ver1_doc)
+        .Input(0, "X", "Input tensor", "T")
+        .Input(
+            1,
+            "slope",
+            "Slope tensor. If `Slope` is of size 1, the value is shared"
+            "across different channels",
+            "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    PRelu,
+    6,
+    OpSchema()
+        .SetDoc(PRelu_ver1_doc)
+        .Input(0, "X", "Input tensor", "T")
+        .Input(
+            1,
+            "slope",
+            "Slope tensor. If `Slope` is of size 1, the value is shared"
+            "across different channels",
+            "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    PRelu,
+    7,
+    OpSchema()
+        .SetDoc(
+            GET_OP_DOC_STR(std::string(PRelu_ver1_doc) + GenerateBroadcastingDocUni("tensor slope", "input tensor X")))
+        .Input(0, "X", "Input tensor", "T")
+        .Input(
+            1,
+            "slope",
+            "Slope tensor. The shape of slope can be smaller than first input X; "
+            "if so, its shape must be unidirectional broadcastable to X",
+            "T")
+        .Output(0, "Y", "Output tensor (same size as X)", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sigmoid,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Sigmoid_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    HardSigmoid,
+    1,
+    OpSchema()
+        .Attr("alpha", "Value of alpha default to 0.2", AttributeProto::FLOAT, 0.2f)
+        .Attr("beta", "Value of beta default to 0.5", AttributeProto::FLOAT, 0.5f)
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .SetDoc(kDoc_HardSigmoid_ver6)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Max_ver1_doc = R"DOC(
+Element-wise max of each of the input tensors. All inputs and outputs must
+have the same shape and data type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Max,
+    1,
+    OpSchema()
+        .SetDoc(Max_ver1_doc)
+        .Input(0, "data_0", "List of tensors for Max.", "T", OpSchema::Variadic)
+        .Output(0, "max", "Output tensor. Same dimension as inputs.", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Min_ver1_doc = R"DOC(
+Element-wise min of each of the input tensors. All inputs and outputs must
+have the same shape and data type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Min,
+    1,
+    OpSchema()
+        .SetDoc(Min_ver1_doc)
+        .Input(0, "data_0", "List of tensors for Min", "T", OpSchema::Variadic)
+        .Output(0, "min", "Output tensor. Same dimension as inputs.", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Sum_ver1_doc = R"DOC(
+Element-wise sum of each of the input tensors. All inputs and outputs must
+have the same shape and data type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sum,
+    1,
+    OpSchema()
+        .SetDoc(Sum_ver1_doc)
+        .Input(0, "data_0", "List of tensors for Sum.", "T", OpSchema::Variadic)
+        .Output(0, "sum", "Output tensor. Same dimension as inputs.", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Mean_ver1_doc = R"DOC(
+Element-wise mean of each of the input tensors. All inputs and outputs must
+have the same shape and data type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Mean,
+    1,
+    OpSchema()
+        .SetDoc(Mean_ver1_doc)
+        .Input(0, "data_0", "List of tensors for Mean.", "T", OpSchema::Variadic)
+        .Output(0, "mean", "Output tensor. Same dimension as inputs.", "T")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Clip_ver1_doc = R"DOC(
+Clip operator limits the given input within an interval. The interval is
+specified with arguments 'min' and 'max'. They default to
+numeric_limits::lowest() and numeric_limits::max() respectively.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Clip,
+    1,
+    OpSchema()
+        .SetDoc(Clip_ver1_doc)
+        .Attr("min", "Minimum value, under which element is replaced by min", AttributeProto::FLOAT, OPTIONAL_VALUE)
+        .Attr("max", "Maximum value, above which element is replaced by max", AttributeProto::FLOAT, OPTIONAL_VALUE)
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Input(0, "input", "Input tensor whose elements to be clipped", "T")
+        .Output(0, "output", "Output tensor with clipped input elements", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Gemm_ver1_doc = R"DOC(General Matrix multiplication:
+https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms#Level_3
+Compute Y = alpha * A * B + beta * C, where input tensor A has
+dimension (M X K), input tensor B has dimension (K X N), input tensor C and
+output tensor Y have dimension (M X N).
+If attribute broadcast is non-zero, input tensor C will be broadcasted to match
+the dimension requirement. A will be transposed before doing the computation
+if attribute transA is non-zero, same for B and transB.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gemm,
+    1,
+    OpSchema()
+        .SetDoc(Gemm_ver1_doc)
+        .Input(0, "A", "Input tensor A", "T")
+        .Input(1, "B", "Input tensor B", "T")
+        .Input(2, "C", "Input tensor C, can be inplace.", "T")
+        .Output(0, "Y", "Output tensor.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("transA", "Whether A should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("transB", "Whether B should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("broadcast", "Whether C should be broadcasted", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr(
+            "alpha",
+            "Scalar multiplier for the product of input tensors A * B, the default value is 1.0.",
+            AttributeProto::FLOAT,
+            1.0f)
+        .Attr("beta", "Scalar multiplier for input tensor C, the default value is 1.0.", AttributeProto::FLOAT, 1.0f));
+
+static const char* const Gemm_ver6_doc = Gemm_ver1_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gemm,
+    6,
+    OpSchema()
+        .SetDoc(Gemm_ver6_doc)
+        .Input(0, "A", "Input tensor A", "T")
+        .Input(1, "B", "Input tensor B", "T")
+        .Input(2, "C", "Input tensor C", "T")
+        .Output(0, "Y", "Output tensor.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .Attr("transA", "Whether A should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("transB", "Whether B should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("broadcast", "Whether C should be broadcasted", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr(
+            "alpha",
+            "Scalar multiplier for the product of input tensors A * B, the default value is 1.0.",
+            AttributeProto::FLOAT,
+            1.0f)
+        .Attr("beta", "Scalar multiplier for input tensor C, the default value is 1.0.", AttributeProto::FLOAT, 1.0f)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2)) {
+            auto transAAttr = ctx.getAttribute("transA");
+            bool transA = transAAttr ? static_cast<int>(transAAttr->i()) != 0 : false;
+            auto transBAttr = ctx.getAttribute("transB");
+            bool transB = transBAttr ? static_cast<int>(transBAttr->i()) != 0 : false;
+
+            checkInputRank(ctx, 0, 2);
+            checkInputRank(ctx, 1, 2);
+
+            auto& first_input_shape = getInputShape(ctx, 0);
+            auto& second_input_shape = getInputShape(ctx, 1);
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
+                first_input_shape.dim(transA ? 1 : 0);
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
+                second_input_shape.dim(transB ? 0 : 1);
+          } else if (
+              hasInputShape(ctx, 2) &&
+              (!ctx.getAttribute("broadcast") || static_cast<int>(ctx.getAttribute("broadcast")->i()) == 0)) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = ctx.getInputType(2)->tensor_type().shape();
+          }
+        }));
+
+static const char* const Gemm_ver7_doc = Gemm_ver11_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gemm,
+    7,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(Gemm_ver7_doc) + GenerateBroadcastingDocUni("tensor C", "tensor A * B")))
+        .Input(
+            0,
+            "A",
+            "Input tensor A. "
+            "The shape of A should be (M, K) if transA is 0, "
+            "or (K, M) if transA is non-zero.",
+            "T")
+        .Input(
+            1,
+            "B",
+            "Input tensor B. "
+            "The shape of B should be (K, N) if transB is 0, "
+            "or (N, K) if transB is non-zero.",
+            "T")
+        .Input(
+            2,
+            "C",
+            "Input tensor C. "
+            "The shape of C should be unidirectional broadcastable to (M, N).",
+            "T")
+        .Output(0, "Y", "Output tensor of shape (M, N).", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .Attr("transA", "Whether A should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("transB", "Whether B should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("alpha", "Scalar multiplier for the product of input tensors A * B.", AttributeProto::FLOAT, 1.0f)
+        .Attr("beta", "Scalar multiplier for input tensor C.", AttributeProto::FLOAT, 1.0f)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2)) {
+            auto transAAttr = ctx.getAttribute("transA");
+            bool transA = transAAttr ? static_cast<int>(transAAttr->i()) != 0 : false;
+            auto transBAttr = ctx.getAttribute("transB");
+            bool transB = transBAttr ? static_cast<int>(transBAttr->i()) != 0 : false;
+            auto& first_input_shape = getInputShape(ctx, 0);
+            auto& second_input_shape = getInputShape(ctx, 1);
+            if (first_input_shape.dim_size() != 2) {
+              fail_shape_inference("First input does not have rank 2");
+            }
+            if (second_input_shape.dim_size() != 2) {
+              fail_shape_inference("Second input does not have rank 2");
+            }
+            updateOutputShape(ctx, 0, {first_input_shape.dim(transA ? 1 : 0), second_input_shape.dim(transB ? 0 : 1)});
+          }
+        }));
+
+static const char* const Gemm_ver9_doc = Gemm_ver11_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gemm,
+    9,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(Gemm_ver9_doc) + GenerateBroadcastingDocUni("tensor C", "tensor A * B")))
+        .Input(
+            0,
+            "A",
+            "Input tensor A. "
+            "The shape of A should be (M, K) if transA is 0, "
+            "or (K, M) if transA is non-zero.",
+            "T")
+        .Input(
+            1,
+            "B",
+            "Input tensor B. "
+            "The shape of B should be (K, N) if transB is 0, "
+            "or (N, K) if transB is non-zero.",
+            "T")
+        .Input(
+            2,
+            "C",
+            "Input tensor C. "
+            "The shape of C should be unidirectional broadcastable to (M, N).",
+            "T")
+        .Output(0, "Y", "Output tensor of shape (M, N).", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::UInt32, types::UInt64, types::Int32, types::Int64},
+            "Constrain input and output types to float/int tensors.")
+        .Attr("transA", "Whether A should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("transB", "Whether B should be transposed", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("alpha", "Scalar multiplier for the product of input tensors A * B.", AttributeProto::FLOAT, 1.0f)
+        .Attr("beta", "Scalar multiplier for input tensor C.", AttributeProto::FLOAT, 1.0f)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2)) {
+            auto transAAttr = ctx.getAttribute("transA");
+            bool transA = transAAttr ? static_cast<int>(transAAttr->i()) != 0 : false;
+            auto transBAttr = ctx.getAttribute("transB");
+            bool transB = transBAttr ? static_cast<int>(transBAttr->i()) != 0 : false;
+            auto& first_input_shape = getInputShape(ctx, 0);
+            auto& second_input_shape = getInputShape(ctx, 1);
+            if (first_input_shape.dim_size() != 2) {
+              fail_shape_inference("First input does not have rank 2");
+            }
+            if (second_input_shape.dim_size() != 2) {
+              fail_shape_inference("Second input does not have rank 2");
+            }
+            updateOutputShape(ctx, 0, {first_input_shape.dim(transA ? 1 : 0), second_input_shape.dim(transB ? 0 : 1)});
+          }
+        }));
+
+static const char* const Max_ver6_doc = Max_ver1_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Max,
+    6,
+    OpSchema()
+        .SetDoc(Max_ver6_doc)
+        .Input(0, "data_0", "List of tensors for Max.", "T", OpSchema::Variadic)
+        .Output(0, "max", "Output tensor. Same dimension as inputs.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static const char* const Min_ver6_doc = Min_ver1_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Min,
+    6,
+    OpSchema()
+        .SetDoc(Min_ver6_doc)
+        .Input(0, "data_0", "List of tensors for Min", "T", OpSchema::Variadic)
+        .Output(0, "min", "Output tensor. Same dimension as inputs.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static const char* const Sum_ver6_doc = Sum_ver1_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Sum,
+    6,
+    OpSchema()
+        .SetDoc(Sum_ver6_doc)
+        .Input(0, "data_0", "List of tensors for Sum.", "T", OpSchema::Variadic)
+        .Output(0, "sum", "Output tensor. Same dimension as inputs.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static const char* const Mean_ver6_doc = Mean_ver1_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Mean,
+    6,
+    OpSchema()
+        .SetDoc(Mean_ver6_doc)
+        .Input(0, "data_0", "List of tensors for Mean.", "T", OpSchema::Variadic)
+        .Output(0, "mean", "Output tensor. Same dimension as inputs.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MatMul,
+    1,
+    OpSchema()
+        .Input(0, "A", "N-dimensional matrix A", "T")
+        .Input(1, "B", "N-dimensional matrix B", "T")
+        .Output(0, "Y", "Matrix multiply results from A * B", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .SetDoc(kDoc_MatMul_ver9)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 2)) {
+            return;
+          }
+
+          const auto shape0 = ctx.getInputType(0)->tensor_type().shape();
+          const auto shape1 = ctx.getInputType(1)->tensor_type().shape();
+
+          if (shape0.dim_size() == 0 || shape1.dim_size() == 0) {
+            fail_shape_inference("Input tensors of wrong rank (0).");
+          }
+
+          TensorShapeProto shapeL, shapeR;
+
+          // First promote each shape to at least rank-2. This logic is
+          // specific to matmul, not generic broadcasting.
+          {
+            if (shape0.dim_size() == 1) {
+              shapeL.add_dim()->set_dim_value(1);
+              *shapeL.add_dim() = shape0.dim(0);
+            } else {
+              *shapeL.mutable_dim() = shape0.dim();
+            }
+            if (shape1.dim_size() == 1) {
+              *shapeR.add_dim() = shape1.dim(0);
+              shapeR.add_dim()->set_dim_value(1);
+            } else {
+              *shapeR.mutable_dim() = shape1.dim();
+            }
+          }
+
+          // Check for compatible matrix multiply dimensions
+          {
+            auto const& dimL = shapeL.dim(shapeL.dim_size() - 1);
+            auto const& dimR = shapeR.dim(shapeR.dim_size() - 2);
+            if (dimL.has_dim_value() && dimR.has_dim_value() && dimL.dim_value() != dimR.dim_value()) {
+              fail_shape_inference("Incompatible dimensions for matrix multiplication");
+              ;
+            }
+          }
+
+          TensorShapeProto resultShape;
+
+          // Now call out to generic multidimensional broadcasting for
+          // the broadcastable prefixes.
+          {
+            TensorShapeProto prefixShapeL, prefixShapeR;
+            for (int i = 0; i < shapeL.dim_size() - 2; ++i) {
+              *prefixShapeL.add_dim() = shapeL.dim(i);
+            }
+            for (int i = 0; i < shapeR.dim_size() - 2; ++i) {
+              *prefixShapeR.add_dim() = shapeR.dim(i);
+            }
+            bidirectionalBroadcastShapeInference(prefixShapeL, prefixShapeR, resultShape);
+          }
+
+          // Back to matmul-specific. Add the trailing dimensions back in.
+          {
+            if (shape0.dim_size() != 1) {
+              *resultShape.add_dim() = shapeL.dim(shapeL.dim_size() - 2);
+            }
+            if (shape1.dim_size() != 1) {
+              *resultShape.add_dim() = shapeR.dim(shapeR.dim_size() - 1);
+            }
+          }
+
+          *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = resultShape;
+        }));
+
+static constexpr const char* TopK_ver1_doc = R"DOC(
+Retrieve the top-K elements along a specified axis. Given an input tensor of
+shape [a_0, a_1, ..., a_{n-1}] and integer argument k, return two outputs:
+  -Value tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}]
+    which contains the values of the top k elements along the specified axis
+  -Index tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] which
+   contains the indices of the top k elements (original indices from the input
+   tensor).
+Given two equivalent values, this operator uses the indices along the axis  as
+ a tiebreaker. That is, the element with the lower index will appear first.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    TopK,
+    1,
+    OpSchema()
+        .SetDoc(TopK_ver1_doc)
+        .Input(0, "X", "Tensor of shape [a_0, a_1, ..., a_{n-1}]", "T")
+        .Output(
+            0,
+            "Values",
+            "Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] "
+            "containing top K values from the input tensor",
+            "T")
+        .Output(
+            1,
+            "Indices",
+            "Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] "
+            "containing the corresponding input tensor indices for the top K "
+            "values.",
+            "I")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint("I", {types::Int64}, "Constrain index tensor to int64")
+        .Attr("k", "Number of top elements to retrieve", AttributeProto::INT, true)
+        .Attr("axis", "Dimension on which to do the sort.", AttributeProto::INT, static_cast<int64_t>(-1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference:
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          updateOutputElemType(ctx, 1, TensorProto::INT64);
+
+          // Shape inference:
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int64_t rank = input_shape.dim_size();
+          int64_t axis = getAttribute(ctx, "axis", -1);
+          if (axis < 0)
+            axis += rank;
+          if (axis < 0 || axis >= rank) {
+            fail_shape_inference("Invalid value for attribute axis");
+          }
+          int64_t k = getAttribute(ctx, "k", -1);
+          if (k <= 0) {
+            fail_shape_inference("Invalid value for attribute k");
+          }
+          TensorShapeProto result_shape = input_shape;
+          result_shape.mutable_dim(static_cast<int>(axis))->set_dim_value(k);
+          updateOutputShape(ctx, 0, result_shape);
+          updateOutputShape(ctx, 1, result_shape);
+        }));
+
+static constexpr const char* TopK_ver10_doc = R"DOC(
+Retrieve the top-K elements along a specified axis. Given an input tensor of
+shape [a_0, a_1, ..., a_{n-1}] and integer argument k, return two outputs:
+  -Value tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}]
+    which contains the values of the top k elements along the specified axis
+  -Index tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] which
+   contains the indices of the top k elements (original indices from the input
+   tensor).
+
+Given two equivalent values, this operator uses the indices along the axis  as
+ a tiebreaker. That is, the element with the lower index will appear first.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    TopK,
+    10,
+    OpSchema()
+        .SetDoc(TopK_ver10_doc)
+        .Input(0, "X", "Tensor of shape [a_0, a_1, ..., a_{n-1}]", "T")
+        .Input(
+            1,
+            "K",
+            "A 1-D tensor containing a single positive value corresponding to the number of top elements to retrieve",
+            "tensor(int64)")
+        .Output(
+            0,
+            "Values",
+            "Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] "
+            "containing top K values from the input tensor",
+            "T")
+        .Output(
+            1,
+            "Indices",
+            "Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] "
+            "containing the corresponding input tensor indices for the top K "
+            "values.",
+            "I")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint("I", {types::Int64}, "Constrain index tensor to int64")
+        .Attr("axis", "Dimension on which to do the sort.", AttributeProto::INT, static_cast<int64_t>(-1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference:
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          updateOutputElemType(ctx, 1, TensorProto::INT64);
+          // Shape inference:
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int64_t rank = input_shape.dim_size();
+          int64_t axis = getAttribute(ctx, "axis", -1);
+          if (axis < 0)
+            axis += rank;
+          if (axis < 0 || axis >= rank) {
+            fail_shape_inference("Invalid value for attribute axis");
+          }
+
+          const auto& axis_dim = input_shape.dim(static_cast<int>(axis));
+          const auto k = ctx.getInputData(1);
+
+          // Infer output shape if:
+          // (1) 'K' is available
+          // (2) axis_dim has dim value
+          // Otherwise cannot reliably compute output shape as axis dim value is
+          // unknown and hence cannot determine if axis dim value >= k (which
+          // should be enforced)
+          if (nullptr != k && axis_dim.has_dim_value()) {
+            int64_t k_value = 0;
+            if (k->dims_size() != 1 || k->dims(0) != 1) {
+              fail_shape_inference("K input must be a one-dimensional tensor of size 1.");
+            }
+
+            if (k->data_type() == TensorProto::INT64) {
+              const auto data = ParseData<int64_t>(k);
+              k_value = data[0];
+            } else {
+              fail_shape_inference("K input must be of type int64.");
+            }
+
+            if (axis_dim.dim_value() < k_value) {
+              fail_shape_inference("Axis has less than the requested k elements.");
+            }
+
+            TensorShapeProto result_shape = input_shape;
+            result_shape.mutable_dim(static_cast<int>(axis))->set_dim_value(k_value);
+
+            updateOutputShape(ctx, 0, result_shape);
+            updateOutputShape(ctx, 1, result_shape);
+
+            return;
+          }
+
+          // Infer output shapes' rank in any case
+          auto output_shape_0 = getOutputShape(ctx, 0);
+          auto output_shape_1 = getOutputShape(ctx, 1);
+          for (int i = 0; i < input_shape.dim_size(); ++i) {
+            output_shape_0->add_dim();
+            output_shape_1->add_dim();
+          }
+
+          return;
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    TopK,
+    11,
+    OpSchema().FillUsing(defs::math::utils::TopKOpGenerator(OpSchema::all_numeric_types())));
+
+static const char* const Clip_ver6_doc = Clip_ver1_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Clip,
+    6,
+    OpSchema()
+        .SetDoc(Clip_ver6_doc)
+        .Attr(
+            "min",
+            "Minimum value, under which element is replaced by min",
+            AttributeProto::FLOAT,
+            std::numeric_limits<float>::lowest())
+        .Attr(
+            "max",
+            "Maximum value, above which element is replaced by max",
+            AttributeProto::FLOAT,
+            std::numeric_limits<float>::max())
+        .Input(0, "input", "Input tensor whose elements to be clipped", "T")
+        .Output(0, "output", "Output tensor with clipped input elements", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static const char* const Clip_ver11_doc = Clip_ver12_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Clip,
+    11,
+    OpSchema()
+        .SetDoc(Clip_ver11_doc)
+        .Input(0, "input", "Input tensor whose elements to be clipped", "T")
+        .Input(
+            1,
+            "min",
+            "Minimum value, under which element is replaced by min. "
+            "It must be a scalar(tensor of empty shape).",
+            "T",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "max",
+            "Maximum value, above which element is replaced by max. "
+            "It must be a scalar(tensor of empty shape).",
+            "T",
+            OpSchema::Optional)
+        .Output(0, "output", "Output tensor with clipped input elements", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static std::function<void(OpSchema&)> ElementwiseMultiOpDocGenerator_old(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Element-wise {name} of each of the input tensors (with Numpy-style broadcasting support).
+All inputs and outputs must have the same data type.
+{broadcast_doc}
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    schema.SetDoc(doc);
+    schema.Input(0, "data_0", "List of tensors for " + std::string(name) + ".", "T", OpSchema::Variadic);
+    schema.Output(0, name, "Output tensor.", "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      auto num_inputs = ctx.getNumInputs();
+      std::vector<const TensorShapeProto*> shapes;
+      for (size_t i = 0; i < num_inputs; ++i) {
+        const auto* const input_type = ctx.getInputType(i);
+        if (nullptr == input_type || !input_type->has_tensor_type() || !input_type->tensor_type().has_shape()) {
+          return;
+        }
+        shapes.push_back(&input_type->tensor_type().shape());
+      }
+
+      multidirectionalBroadcastShapeInference(shapes, *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(Max, 8, OpSchema().FillUsing(ElementwiseMultiOpDocGenerator_old("max")));
+
+ONNX_OPERATOR_SET_SCHEMA(Min, 8, OpSchema().FillUsing(ElementwiseMultiOpDocGenerator_old("min")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LeakyRelu,
+    6,
+    OpSchema()
+        .Attr("alpha", "Coefficient of leakage.", AttributeProto::FLOAT, 0.01f)
+        .SetDoc(kDoc_LeakyRelu_ver1)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    PRelu,
+    9,
+    OpSchema()
+        .SetDoc(
+            GET_OP_DOC_STR(std::string(PRelu_ver1_doc) + GenerateBroadcastingDocUni("tensor slope", "input tensor X")))
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "slope",
+            "Slope tensor. The shape of slope can be smaller than first input X; "
+            "if so, its shape must be unidirectional broadcastable to X",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor (same size as X)", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::UInt32, types::UInt64, types::Int32, types::Int64},
+            "Constrain input and output types to float/int tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* DFT_ver17_doc = R"DOC(Computes the discrete Fourier transform of input.)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DFT,
+    17,
+    OpSchema()
+        .SetDoc(DFT_ver17_doc)
+        .Attr(
+            "onesided",
+            "If onesided is 1, only values for w in [0, 1, 2, ..., floor(n_fft/2) + 1] are used or returned because "
+            "the real-to-complex Fourier transform satisfies the conjugate symmetry, i.e., X[m, w] = X[m, n_fft-w]*. "
+            "When onesided=1 and inverse=0 (forward DFT), only real input is supported and a one-sided complex spectrum is returned (RFFT). "
+            "When onesided=1 and inverse=1 (inverse DFT), only complex input is supported and a full real signal is returned (IRFFT). "
+            "When invoked with real or complex valued input, the default value is 0. "
+            "Values can be 0 or 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "axis",
+            "The axis on which to perform the DFT. By default this value is set to 1, which corresponds to the first dimension after the batch index. "
+            "Negative value means counting dimensions from the back. Accepted range is $[-r, -2] \\cup [0, r-2]$ where `r = rank(input)`. "
+            "The last dimension is for representing complex numbers and thus is an invalid axis.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "inverse",
+            "Whether to perform the inverse discrete fourier transform. By default this value is set to 0, which corresponds to false.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "input",
+            "For real input, the following shape is expected: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][1]. "
+            "For complex input, the following shape is expected: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][2]. "
+            "The first dimension is the batch dimension. "
+            "The following N dimensions correspond to the signal's dimensions. "
+            "The final dimension represents the real and imaginary parts of the value in that order.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            1,
+            "dft_length",
+            "The length of the signal as a scalar. "
+            "If greater than the axis dimension, the signal will be zero-padded up to dft_length. "
+            "If less than the axis dimension, only the first dft_length values will be used as the signal. "
+            "If not provided, the default dft_length = signal_dim_axis, except for the IRFFT case (onesided=1, inverse=1), in which case the default dft_length is 2 * (signal_dim_axis - 1). "
+            "It's an optional value.",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "The Fourier Transform of the input vector. "
+            "For standard DFT (onesided=0), the output shape is: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][2] (complex), with signal_dim_axis = dft_length. "
+            "For RFFT (onesided=1, inverse=0), the output shape is: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][2] (one-sided complex), with signal_dim_axis = floor(dft_length/2) + 1. "
+            "For IRFFT (onesided=1, inverse=1), the output shape is: [batch_idx][signal_dim1][signal_dim2]...[signal_dimN][1] (real), where signal_dim_axis = dft_length.",
+            "T1")
+        .TypeConstraint(
+            "T1",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint("T2", {types::Int32, types::Int64}, "Constrain scalar length types to int64_t.")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          bool is_onesided = static_cast<bool>(getAttribute(ctx, "onesided", 0));
+          bool inverse = static_cast<bool>(getAttribute(ctx, "inverse", 0));
+
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasInputShape(ctx, 0)) {
+            // If no shape is available for the input, skip shape inference...
+            return;
+          }
+
+          // In general the output shape will match the input shape exactly
+          // So initialize the output shape with the input shape
+          auto& input_shape = getInputShape(ctx, 0);
+          ONNX_NAMESPACE::TensorShapeProto result_shape_proto = input_shape;
+
+          // Get the axis where the DFT will be performed.
+          auto axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+          // The last dimension is the real and imaginary parts of the value.
+          const int64_t rank = input_shape.dim_size();
+          if (rank < 2) {
+            fail_shape_inference("input tensor must have rank >= 2, including the complex dimension.");
+          }
+
+          // check the inputs are correct types for one-sided DFT
+          if (is_onesided) {
+            auto last_dim = input_shape.dim(rank - 1);
+            if (inverse) {
+              // Check last dimension is 2 (complex input required)
+              if (last_dim.has_dim_value() && last_dim.dim_value() != 2) {
+                fail_shape_inference("inverse one-sided DFT requires complex input (last dimension must be 2)");
+              }
+            } else {
+              // Check last dimension is 1 (real input required)
+              if (last_dim.has_dim_value() && last_dim.dim_value() != 1) {
+                fail_shape_inference("one-sided DFT requires real input (last dimension must be 1)");
+              }
+            }
+          }
+          // NOLINTNEXTLINE(readability-simplify-boolean-expr)
+          if (!(-rank <= axis && axis != -1 && axis < rank - 1)) {
+            fail_shape_inference(
+                "axis attribute value ",
+                axis,
+                " is invalid for a tensor of rank ",
+                rank,
+                ". Valid values are '-rank <= axis && axis != -1 && axis < rank - 1'");
+          }
+
+          int axis_idx = static_cast<int>(axis >= 0 ? axis : axis + rank);
+
+          // If dft_length is specified, then we should honor the shape.
+          // Set the output dimension to match the dft_length on the axis.
+          const TensorProto* dft_length = nullptr;
+          if (ctx.hasInput(1)) {
+            dft_length = ctx.getInputData(1);
+            if (dft_length == nullptr) {
+              // If we cannot read the dft_length, we cannot infer shape
+              // return...
+              return;
+            }
+          }
+
+          if (nullptr != dft_length) {
+            if (dft_length->dims_size() != 0) {
+              fail_shape_inference("dft_length input must be a scalar.");
+            }
+            auto dft_length_value = defs::math::utils::GetScalarValueFromTensor<int64_t>(dft_length);
+
+            // For RFFT, output size on signal axis is floor(dft_length/2) + 1
+            if (is_onesided && !inverse) {
+              // RFFT: one-sided output
+              auto half_signal_size = (dft_length_value >> 1) + 1;
+              result_shape_proto.mutable_dim(axis_idx)->set_dim_value(half_signal_size);
+            } else {
+              // Standard FFT/IFFT and IRFFT: full length
+              result_shape_proto.mutable_dim(axis_idx)->set_dim_value(dft_length_value);
+            }
+          } else if (is_onesided) {
+            auto axis_dimension = result_shape_proto.dim(axis_idx);
+            if (axis_dimension.has_dim_value()) {
+              auto axis_dimension_value = axis_dimension.dim_value();
+              if (inverse) {
+                // IRFFT without explicit dft_length: cannot reliably infer full signal length
+                // Default to even length: N = 2 * (input_size - 1)
+                auto full_signal_size = 2 * (axis_dimension_value - 1);
+                result_shape_proto.mutable_dim(axis_idx)->set_dim_value(full_signal_size);
+              } else {
+                // RFFT without explicit dft_length: infer one-sided output size from input
+                auto half_signal_size = (axis_dimension_value >> 1) + 1;
+                result_shape_proto.mutable_dim(axis_idx)->set_dim_value(half_signal_size);
+              }
+            } else {
+              result_shape_proto.mutable_dim(axis_idx)->clear_dim_value();
+              result_shape_proto.mutable_dim(axis_idx)->clear_dim_param();
+            }
+          }
+
+          // Set the last dimension based on whether output is real or complex
+          auto dim_size = static_cast<int64_t>(result_shape_proto.dim_size());
+          if (is_onesided && inverse) {
+            // IRFFT: complex input -> real output (last dim = 1)
+            result_shape_proto.mutable_dim(static_cast<int>(dim_size - 1))->set_dim_value(1);
+          } else {
+            // All other cases: complex output (last dim = 2)
+            result_shape_proto.mutable_dim(static_cast<int>(dim_size - 1))->set_dim_value(2);
+          }
+
+          updateOutputShape(ctx, 0, result_shape_proto);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QLinearMatMul,
+    10,
+    OpSchema()
+        .SetDoc(defs::math::utils::QLinearMatMulDoc())
+        .Input(0, "a", "N-dimensional quantized matrix a", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Input(
+            1,
+            "a_scale",
+            "scale of quantized input a",
+            "tensor(float)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "a_zero_point",
+            "zero point of quantized input a",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(3, "b", "N-dimensional quantized matrix b", "T2", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Input(
+            4,
+            "b_scale",
+            "scale of quantized input b",
+            "tensor(float)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            5,
+            "b_zero_point",
+            "zero point of quantized input b",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            6,
+            "y_scale",
+            "scale of quantized output y",
+            "tensor(float)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            7,
+            "y_zero_point",
+            "zero point of quantized output y",
+            "T3",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "y",
+            "Quantized matrix multiply results from a * b",
+            "T3",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T1",
+            {types::Int8, types::UInt8},
+            "Constrain input a and its zero point data type to 8-bit integer tensor.")
+        .TypeConstraint(
+            "T2",
+            {types::Int8, types::UInt8},
+            "Constrain input b and its zero point data type to 8-bit integer tensor.")
+        .TypeConstraint(
+            "T3",
+            {types::Int8, types::UInt8},
+            "Constrain output y and its zero point data type to 8-bit integer tensor.")
+        .TypeAndShapeInferenceFunction(defs::math::utils::QLinearMatMulShapeInference));
+
+static constexpr const char* celu_ver12_doc = R"DOC(
+Continuously Differentiable Exponential Linear Units:
+Perform the linear unit element-wise on the input tensor X
+using formula:
+
+```
+max(0,x) + min(0,alpha*(exp(x/alpha)-1))
+```
+)DOC";
+
+static float celu_ver12_default_alpha = 1.0;
+
+static bool BuildContextDependentFunctionBodyCelu(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  float alpha = ctx.getAttribute("alpha") != nullptr ? ctx.getAttribute("alpha")->f() : celu_ver12_default_alpha;
+  FunctionBuilder builder(functionProto);
+  builder.Const("alpha", std::vector<float>{alpha}).Add(R"(
+            X_alpha = Div (X, alpha)
+            Elu_Result = Elu <alpha = 1.0>(X_alpha)
+            Y = Mul (alpha, Elu_Result)
+        )");
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Celu,
+    12,
+    OpSchema()
+        .SetDoc(celu_ver12_doc)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Attr(
+            "alpha",
+            "The Alpha value in Celu formula which control the shape of "
+            "the unit. The default value is 1.0.",
+            AttributeProto::FLOAT,
+            celu_ver12_default_alpha)
+        .TypeConstraint("T", {types::Float}, "Constrain input and output types to float32 tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBodyCelu)
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/math/utils.cc b/onnx/defs/math/utils.cc
new file mode 100644
index 0000000..cbca415
--- /dev/null
+++ b/onnx/defs/math/utils.cc
@@ -0,0 +1,289 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/math/utils.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+namespace defs {
+namespace math {
+namespace utils {
+
+static constexpr const char* TopK_ver11_doc = R"DOC(
+Retrieve the top-K largest or smallest elements along a specified axis. Given an input tensor of
+shape [a_0, a_1, ..., a_{n-1}] and integer argument k, return two outputs:
+
+* Value tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}]
+  which contains the values of the top k elements along the specified axis
+* Index tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] which
+  contains the indices of the top k elements (original indices from the input
+  tensor).
+
+* If "largest" is 1 (the default value) then the k largest elements are returned.
+* If "sorted" is 1 (the default value) then the resulting k elements will be sorted.
+* If "sorted" is 0, order of returned 'Values' and 'Indices' are undefined.
+
+Given two equivalent values, this operator uses the indices along the axis as
+a tiebreaker. That is, the element with the lower index will appear first.
+)DOC";
+
+std::function<void(OpSchema&)> TopKOpGenerator(std::vector<std::string> allowed_types) {
+  return [allowed_types = std::move(allowed_types)](OpSchema& schema) {
+    schema.SetDoc(TopK_ver11_doc)
+        .Input(
+            0,
+            "X",
+            "Tensor of shape [a_0, a_1, ..., a_{n-1}]",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "K",
+            "A 1-D tensor containing a single positive value corresponding to the number of top elements to retrieve",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "Values",
+            "Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] "
+            "containing top K values from the input tensor",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            1,
+            "Indices",
+            "Tensor of shape [a_0, a_1, ..., a_{axis-1}, k, a_{axis+1}, ... a_{n-1}] "
+            "containing the corresponding input tensor indices for the top K "
+            "values.",
+            "I",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T", allowed_types, "Constrain input and output types to numeric tensors.")
+        .TypeConstraint("I", {types::Int64}, "Constrain index tensor to int64")
+        .Attr(
+            "axis",
+            "Dimension on which to do the sort. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INT,
+            static_cast<int64_t>(-1))
+        .Attr(
+            "largest",
+            "Whether to return the top-K largest or smallest elements.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr("sorted", "Whether to return the elements in sorted order.", AttributeProto::INT, static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference:
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          updateOutputElemType(ctx, 1, TensorProto::INT64);
+          // Shape inference:
+          if (!hasInputShape(ctx, 0))
+            return;
+          const auto& input_shape = getInputShape(ctx, 0);
+          int64_t rank = input_shape.dim_size();
+          int64_t axis = getAttribute(ctx, "axis", -1);
+          if (axis < 0)
+            axis += rank;
+          if (axis < 0 || axis >= rank) {
+            fail_shape_inference("Invalid value for attribute axis");
+          }
+
+          const auto& axis_dim = input_shape.dim(static_cast<int>(axis));
+          const auto* const k = ctx.getInputData(1);
+
+          // Infer output shape if:
+          // (1) 'K' is available
+          // (2) axis_dim has dim value
+          // Otherwise cannot reliably compute output shape as axis dim value is
+          // unknown and hence cannot determine if axis dim value >= k (which
+          // should be enforced)
+          if (nullptr != k && axis_dim.has_dim_value()) {
+            int64_t k_value = 0;
+            if (k->dims_size() != 1 || k->dims(0) != 1) {
+              fail_shape_inference("K input must be a one-dimensional tensor of size 1.");
+            }
+            if (k->data_type() == TensorProto::INT64) {
+              const auto data = ParseData<int64_t>(k);
+              k_value = data[0];
+            } else {
+              fail_shape_inference("K input must be of type int64.");
+            }
+            if (axis_dim.dim_value() < k_value) {
+              fail_shape_inference("Axis has less than the requested k elements.");
+            }
+
+            TensorShapeProto result_shape = input_shape;
+            result_shape.mutable_dim(static_cast<int>(axis))->set_dim_value(k_value);
+
+            updateOutputShape(ctx, 0, result_shape);
+            updateOutputShape(ctx, 1, result_shape);
+
+            return;
+          }
+
+          // Infer output shapes' rank in any case
+          auto* output_shape_0 = getOutputShape(ctx, 0);
+          auto* output_shape_1 = getOutputShape(ctx, 1);
+          for (int i = 0; i < input_shape.dim_size(); ++i) {
+            output_shape_0->add_dim();
+            output_shape_1->add_dim();
+          }
+
+          return;
+        });
+  };
+}
+
+std::function<void(OpSchema&)>
+UnaryFloatMathOpGenerator(const char* doc, const char* output_description, std::vector<std::string> allowed_types) {
+  return [doc, output_description, allowed_types = std::move(allowed_types)](OpSchema& schema) {
+    schema.SetDoc(doc)
+        .Input(0, "input", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", output_description, "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", allowed_types, "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput);
+  };
+}
+
+int MathOpTwoIntegers(const std::string& op_type, int a, int b) {
+  if (op_type == "Add") {
+    return a + b;
+  } else if (op_type == "Sub") {
+    return a - b;
+  } else if (op_type == "Mul") {
+    return a * b;
+  }
+  fail_shape_inference("Wrong op_type name for running propagation: ", op_type);
+}
+
+void MatMulShapeInference(ONNX_NAMESPACE::InferenceContext& ctx, int input1Idx, int input2Idx) {
+  if (!hasInputShape(ctx, input1Idx) || !hasInputShape(ctx, input2Idx)) {
+    return;
+  }
+
+  const auto shape0 = ctx.getInputType(input1Idx)->tensor_type().shape();
+  const auto shape1 = ctx.getInputType(input2Idx)->tensor_type().shape();
+
+  if (shape0.dim_size() == 0 || shape1.dim_size() == 0) {
+    fail_shape_inference("Input tensors of wrong rank (0).");
+  }
+
+  ONNX_NAMESPACE::TensorShapeProto shapeL, shapeR;
+
+  // First promote each shape to at least rank-2. This logic is
+  // specific to matmul, not generic broadcasting.
+  {
+    if (shape0.dim_size() == 1) {
+      shapeL.add_dim()->set_dim_value(1);
+      *shapeL.add_dim() = shape0.dim(0);
+    } else {
+      *shapeL.mutable_dim() = shape0.dim();
+    }
+    if (shape1.dim_size() == 1) {
+      *shapeR.add_dim() = shape1.dim(0);
+      shapeR.add_dim()->set_dim_value(1);
+    } else {
+      *shapeR.mutable_dim() = shape1.dim();
+    }
+  }
+
+  // Check for compatible matrix multiply dimensions
+  {
+    const auto& dimL = shapeL.dim(shapeL.dim_size() - 1);
+    const auto& dimR = shapeR.dim(shapeR.dim_size() - 2);
+    if (dimL.has_dim_value() && dimR.has_dim_value() && dimL.dim_value() != dimR.dim_value()) {
+      fail_shape_inference("Incompatible dimensions for matrix multiplication");
+    }
+  }
+
+  ONNX_NAMESPACE::TensorShapeProto resultShape;
+
+  // Now call out to generic multidimensional broadcasting for
+  // the broadcastable prefixes.
+  {
+    ONNX_NAMESPACE::TensorShapeProto prefixShapeL, prefixShapeR;
+    for (int i = 0; i < shapeL.dim_size() - 2; ++i) {
+      *prefixShapeL.add_dim() = shapeL.dim(i);
+    }
+    for (int i = 0; i < shapeR.dim_size() - 2; ++i) {
+      *prefixShapeR.add_dim() = shapeR.dim(i);
+    }
+    bidirectionalBroadcastShapeInference(prefixShapeL, prefixShapeR, resultShape);
+  }
+
+  // Back to matmul-specific. Add the trailing dimensions back in.
+  {
+    if (shape0.dim_size() != 1) {
+      *resultShape.add_dim() = shapeL.dim(shapeL.dim_size() - 2);
+    }
+    if (shape1.dim_size() != 1) {
+      *resultShape.add_dim() = shapeR.dim(shapeR.dim_size() - 1);
+    }
+  }
+
+  *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape() = resultShape;
+}
+
+void QLinearMatMulShapeInference(ONNX_NAMESPACE::InferenceContext& ctx) {
+  const auto* const a_type = ctx.getInputType(0);
+  const auto* const b_type = ctx.getInputType(3);
+  if (nullptr == a_type || nullptr == b_type || a_type->value_case() != ONNX_NAMESPACE::TypeProto::kTensorType ||
+      b_type->value_case() != ONNX_NAMESPACE::TypeProto::kTensorType) {
+    fail_type_inference("inputs are expected to have tensor type.");
+  }
+
+  const auto* const a_zero_point_type = ctx.getInputType(2);
+  if (nullptr == a_zero_point_type ||
+      a_zero_point_type->tensor_type().elem_type() != a_type->tensor_type().elem_type()) {
+    fail_type_inference("input and zero_point pair is expected to have be same type.");
+  }
+
+  const auto* const b_zero_point_type = ctx.getInputType(5);
+  if (nullptr == b_zero_point_type ||
+      b_zero_point_type->tensor_type().elem_type() != b_type->tensor_type().elem_type()) {
+    fail_type_inference("input and zero_point pair is expected to have same type.");
+  }
+
+  propagateElemTypeFromInputToOutput(ctx, 7, 0);
+
+  MatMulShapeInference(ctx, 0, 3);
+}
+
+const char* QLinearMatMulDoc() {
+  static constexpr const char* QLinearMatMul_doc = R"DOC(
+Matrix product that behaves like [numpy.matmul](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+It consumes two quantized input tensors, their scales and zero points, scale and zero point of output,
+and computes the quantized output. The quantization formula is y = saturate((x / y_scale) + y_zero_point).
+For (x / y_scale), it is rounding to nearest ties to even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+Scale and zero point must have same shape. They must be either scalar (per tensor) or N-D tensor
+(per row for 'a' and per column for 'b'). Scalar refers to per tensor quantization whereas N-D refers to per row
+or per column quantization. If the input is 2D of shape [M, K] then zero point and scale tensor may be
+an M element vector [v_1, v_2, ..., v_M] for per row quantization and K element vector of shape [v_1, v_2, ..., v_K]
+for per column quantization. If the input is N-D tensor with shape [D1, D2, M, K] then zero point and scale tensor may
+have shape [D1, D2, M, 1] for per row quantization and shape [D1, D2, 1, K] for per column quantization.
+Production must never overflow, and accumulation may overflow if and only if in 32 bits.
+)DOC";
+  return QLinearMatMul_doc;
+}
+
+} // namespace utils
+} // namespace math
+} // namespace defs
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/math/utils.h b/onnx/defs/math/utils.h
new file mode 100644
index 0000000..e5aeb6f
--- /dev/null
+++ b/onnx/defs/math/utils.h
@@ -0,0 +1,60 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/shape_inference.h"
+#include "onnx/defs/tensor_proto_util.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+namespace defs {
+namespace math {
+namespace utils {
+
+std::function<void(OpSchema&)> TopKOpGenerator(std::vector<std::string> allowed_types);
+
+// Unary elementwise ops on float types: T input -> T output, no attrs, no function body.
+std::function<void(OpSchema&)> UnaryFloatMathOpGenerator(
+    const char* doc,
+    const char* output_description,
+    std::vector<std::string> allowed_types = OpSchema::all_float_types_ir4());
+
+template <typename T>
+T GetScalarValueFromTensor(const ONNX_NAMESPACE::TensorProto* t) {
+  if (t == nullptr) {
+    return T{};
+  }
+
+  auto data_type = t->data_type();
+  switch (data_type) {
+    case ONNX_NAMESPACE::TensorProto::FLOAT:
+      return static_cast<T>(ONNX_NAMESPACE::ParseData<float>(t).at(0));
+    case ONNX_NAMESPACE::TensorProto::DOUBLE:
+      return static_cast<T>(ONNX_NAMESPACE::ParseData<double>(t).at(0));
+    case ONNX_NAMESPACE::TensorProto::INT32:
+      return static_cast<T>(ONNX_NAMESPACE::ParseData<int32_t>(t).at(0));
+    case ONNX_NAMESPACE::TensorProto::INT64:
+      return static_cast<T>(ONNX_NAMESPACE::ParseData<int64_t>(t).at(0));
+    default:
+      fail_shape_inference("Unsupported input data type of ", data_type);
+  }
+}
+
+void MatMulShapeInference(ONNX_NAMESPACE::InferenceContext& ctx, int input1Idx, int input2Idx);
+
+void QLinearMatMulShapeInference(ONNX_NAMESPACE::InferenceContext& ctx);
+
+const char* QLinearMatMulDoc();
+
+int MathOpTwoIntegers(const std::string& op_type, int a, int b);
+
+} // namespace utils
+} // namespace math
+} // namespace defs
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/nn/CMakeLists.txt b/onnx/defs/nn/CMakeLists.txt
new file mode 100644
index 0000000..0011f05
--- /dev/null
+++ b/onnx/defs/nn/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+    utils.cc
+    utils.h
+)
diff --git a/onnx/defs/nn/defs.cc b/onnx/defs/nn/defs.cc
new file mode 100644
index 0000000..424bd61
--- /dev/null
+++ b/onnx/defs/nn/defs.cc
@@ -0,0 +1,4788 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "onnx/common/assertions.h"
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/nn/utils.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+static constexpr const char* pads_doc =
+    "Padding for the beginning and ending along each spatial axis, it can take any value greater "
+    "than or equal to 0. The value represent the number of pixels added to the beginning "
+    "and end part of the corresponding axis. `pads` format should be as follow "
+    "[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels "
+    "added at the beginning of axis `i` and xi_end, the number of pixels added at "
+    "the end of axis `i`. This attribute cannot be used simultaneously with "
+    "auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.";
+static constexpr const char* conv_auto_pad_doc =
+    "auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where "
+    "default value is NOTSET, which means explicit padding is used. "
+    "SAME_UPPER or SAME_LOWER mean pad the input so that "
+    "`output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. "
+    "The padding is split between the two sides equally or almost equally (depending "
+    "on whether it is even or odd). In case the padding is an odd number, the extra "
+    "padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.";
+static constexpr const char* conv_transpose_auto_pad_doc =
+    "auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where "
+    "default value is NOTSET, which means explicit padding is used. "
+    "SAME_UPPER or SAME_LOWER mean pad the input so that "
+    "`output_shape[i] = input_shape[i] * strides[i]` for each axis `i`. "
+    "The padding is split between the two sides equally or almost equally (depending "
+    "on whether it is even or odd). In case the padding is an odd number, the extra "
+    "padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.";
+
+ONNX_API void convPoolShapeInference(
+    InferenceContext& ctx,
+    bool use_dilation,
+    bool require_kernel_shape,
+    int input1Idx,
+    int input2Idx) {
+  // we need the first input shape for this inference.
+  if (!hasInputShape(ctx, input1Idx)) {
+    return;
+  }
+
+  // if kernel shape is an input (and not attribute)
+  // we need the shape of the second input.
+  if (!require_kernel_shape && !hasInputShape(ctx, input2Idx)) {
+    return;
+  }
+
+  auto input_shape = ctx.getInputType(input1Idx)->tensor_type().shape();
+  if (input_shape.dim_size() < 3) {
+    fail_shape_inference("Input tensor must have at least 3 dimensions");
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  // Only MaxPool and Conv support dilation. For
+  // simplicity of the code, we just treat the rest of them as having all-1s
+  // dilation.
+  std::vector<int64_t> dilations;
+  if (use_dilation && getRepeatedAttribute(ctx, "dilations", dilations)) {
+    if (dilations.size() != n_input_dims) {
+      fail_shape_inference("Attribute dilations has incorrect size");
+    }
+    if (std::any_of(dilations.begin(), dilations.end(), [](int64_t d) { return d <= 0; })) {
+      fail_shape_inference("Attribute dilations must only contain positive values");
+    }
+  } else {
+    dilations.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> strides = defs::nn::utils::getConvPoolStrides(ctx, n_input_dims);
+
+  std::vector<int64_t> kernel_shape;
+  if (getRepeatedAttribute(ctx, "kernel_shape", kernel_shape)) {
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute kernel_shape has incorrect size");
+    }
+  } else if (require_kernel_shape) {
+    fail_shape_inference("Attribute kernel_shape must be specified");
+  } else {
+    auto second_input_shape = ctx.getInputType(input2Idx)->tensor_type().shape();
+    for (int i = 2; i < second_input_shape.dim_size(); ++i) {
+      if (!second_input_shape.dim(i).has_dim_value()) {
+        return;
+      }
+      kernel_shape.push_back(second_input_shape.dim(i).dim_value());
+    }
+    // Reject weight/input spatial-rank mismatch; prevents OOB read of dilations/pads below.
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference(
+          "Number of spatial dimensions in the weight tensor (",
+          kernel_shape.size(),
+          ") does not match the number of spatial dimensions in the input tensor (",
+          n_input_dims,
+          ").");
+    }
+  }
+
+  if (std::any_of(kernel_shape.begin(), kernel_shape.end(), [](int64_t k) { return k <= 0; })) {
+    fail_shape_inference("Attribute kernel_shape must only contain positive values");
+  }
+
+  std::vector<int64_t> effective_kernel_shape = kernel_shape;
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
+    // accounting for dilation, how big is the kernel in this dimension
+    effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
+  }
+
+  std::vector<int64_t> pads;
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() != n_input_dims * 2) {
+      fail_shape_inference("Attribute pads has incorrect size");
+    }
+    if (std::any_of(pads.begin(), pads.end(), [](int64_t p) { return p < 0; })) {
+      fail_shape_inference("Attribute pads must not contain negative values");
+    }
+  } else {
+    pads.assign(n_input_dims * 2, 0);
+    const auto* const auto_pad_attr = ctx.getAttribute("auto_pad");
+    if ((nullptr != auto_pad_attr) && (auto_pad_attr->s() != "VALID")) {
+      int input_dims_size = static_cast<int>(n_input_dims);
+      for (int i = 0; i < input_dims_size; ++i) {
+        int64_t residual = 0;
+        int64_t stride = strides[i];
+        if (stride > 1) {
+          if (!input_shape.dim(2 + i).has_dim_value()) {
+            continue;
+          }
+          residual = input_shape.dim(2 + i).dim_value();
+          if (residual < 0) {
+            continue;
+          }
+          residual %= stride;
+        }
+        if (i >= static_cast<int>(effective_kernel_shape.size())) {
+          fail_shape_inference("kernel shape should have ", input_dims_size, " values in ", ctx.getDisplayName(), ".");
+        }
+        int64_t total_pad = residual == 0 ? effective_kernel_shape[i] - stride : effective_kernel_shape[i] - residual;
+        total_pad = std::max<int64_t>(total_pad, 0);
+        int64_t half_pad_small = total_pad >> 1;
+        int64_t half_pad_big = total_pad - half_pad_small;
+        if (auto_pad_attr->s() == "SAME_UPPER") {
+          pads[i] = half_pad_small;
+          pads[i + input_dims_size] = half_pad_big;
+        } else if (auto_pad_attr->s() == "SAME_LOWER") {
+          pads[i] = half_pad_big;
+          pads[i + input_dims_size] = half_pad_small;
+        }
+      }
+    }
+  }
+
+  auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  if (require_kernel_shape) {
+    // add the first two dimensions from the input.
+    *output_shape->add_dim() = input_shape.dim(0);
+    *output_shape->add_dim() = input_shape.dim(1);
+  } else {
+    *output_shape->add_dim() = input_shape.dim(0);
+    const auto& second_input_shape = getInputShape(ctx, input2Idx);
+    if (second_input_shape.dim_size() < 1) {
+      fail_shape_inference("Second input tensor has wrong dimension");
+    }
+    *output_shape->add_dim() = second_input_shape.dim(0);
+  }
+
+  int kernel_shape_size = static_cast<int>(kernel_shape.size());
+  for (int i = 0; i < kernel_shape_size; ++i) {
+    auto* newdim = output_shape->add_dim();
+    if (!input_shape.dim(2 + i).has_dim_value()) {
+      continue;
+    }
+    // how big is the input, including padding
+    int64_t input_size = input_shape.dim(2 + i).dim_value();
+    int64_t effective_input_size = input_size + pads[i] + pads[i + kernel_shape_size];
+
+    // default is floor mode .i.e. ceil_mode is set to 0
+    auto ceil_mode = getAttribute(ctx, "ceil_mode", 0);
+
+    int64_t output_size =
+        (effective_input_size - effective_kernel_shape[i] + (ceil_mode ? strides[i] - 1 : 0)) / strides[i] + 1;
+    if (ceil_mode == 1 && (output_size - 1) * strides[i] >= (input_size + pads[i])) {
+      // we need to match pytorch's behavior of "Sliding windows that would start in the right padded region are
+      // ignored." (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool1d.html#maxpool1d). this code follows the
+      // same logic as PyTorch's C++ implementation:
+      // https://github.com/pytorch/pytorch/blob/f1cdb39da3850c47d51ec6a5b1ae864c32b3accf/aten/src/ATen/native/Pool.h#L54C21-L54C21
+      --output_size;
+    }
+
+    newdim->set_dim_value(output_size);
+  }
+
+  if (ctx.getNumOutputs() > 1) {
+    // MaxPool with two outputs case.
+    auto* second_output_shape = ctx.getOutputType(1)->mutable_tensor_type()->mutable_shape();
+    second_output_shape->CopyFrom(*output_shape);
+  }
+}
+
+static std::vector<std::string> GetSupportedDataTypesForPoolingOps(bool supports8bit) {
+  if (supports8bit) {
+    return OpSchema::all_float_types_plus_Xint8_ir4();
+  }
+  return OpSchema::all_float_types_ir4();
+}
+
+static std::function<void(OpSchema&)> PoolOpSchemaGenerator(
+    const char* name,
+    const char* opName,
+    const char* additionalDescription,
+    bool use_dilation,
+    bool supports8bit = false) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ {name} consumes an input tensor X and applies {opName} pooling across
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ {opName} pooling consisting of computing the {opName} on all values of a
+ subset of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing. The output spatial shape is calculated differently
+ depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
+ With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):
+ ```
+ output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+ ```
+ or
+ ```
+ output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+ ```
+ if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`. Sliding windows that would start in the right padded region are ignored.
+
+ `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+ ```
+ VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+ ```
+ or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):
+ ```
+ VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i]) + 1
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1
+ ```
+ And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+ ```
+ pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]
+ ```
+ {additionalDescription}
+ )DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{opName}", opName);
+        ReplaceAll(doc, "{additionalDescription}", additionalDescription);
+        ReplaceAll(
+            doc,
+            "{kernelSpatialShape}",
+            use_dilation ? "((kernel_spatial_shape[i] - 1) * dilations[i] + 1)" : "kernel_spatial_shape[i]"););
+    schema.SetDoc(doc);
+    schema.Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", conv_auto_pad_doc, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "ceil_mode",
+        "Whether to use ceil or floor (default) to compute the output shape.",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data. For non image case, the "
+        "dimensions are in the form of "
+        "(N x C x D1 x D2 ... Dn), where N is the batch "
+        "size. Optionally, if dimension denotation is "
+        "in effect, the operation expects the input "
+        "data tensor to arrive with the dimension denotation "
+        "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from average or max pooling across "
+        "the input tensor. Dimensions will vary based "
+        "on various kernel, stride, and pad sizes. Floor value of "
+        "the dimension is used",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T",
+        GetSupportedDataTypesForPoolingOps(supports8bit),
+        supports8bit ? "Constrain input and output types to float and 8 bit tensors."
+                     : "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([use_dilation](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (ctx.getNumOutputs() > 1) {
+        // MaxPool with two outputs case.
+        auto* output_type = ctx.getOutputType(1);
+        if (output_type->value_case() == TypeProto::kTensorType ||
+            output_type->value_case() == TypeProto::VALUE_NOT_SET) {
+          output_type->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+        }
+      }
+      convPoolShapeInference(ctx, use_dilation, true, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    AveragePool,
+    22,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator(
+            "AveragePool",
+            "average",
+            "The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).",
+            true, /* use_dilation: dilations attribute has been added in opset 19. */
+            false /* supports8bit: does not support 8bit. */))
+        .Attr(
+            "dilations",
+            "Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "count_include_pad",
+            "Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0)));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MaxPool,
+    22,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator(
+            "MaxPool",
+            "max",
+            "The output of each pooling window is maximum number of elements exclude pad. ",
+            true,
+            true))
+        .Attr(
+            "storage_order",
+            "The storage order of the tensor. 0 is row major, and 1 is column major. "
+            "This attribute is used only to convert an n-tuple index value into "
+            "a single integer value for producing the second output. ",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "dilations",
+            "Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Output(
+            1,
+            "Indices",
+            "Indices tensor from max pooling across the input tensor. "
+            "The dimensions of indices are the same as output tensor. "
+            "The values in indices of are the indices of the selected values during pooling. "
+            "The indices are computed as flatten 1-D tensor, "
+            "and the indices do not consider padding. "
+            "So the values in indices are in [0, N x C x D1 x ... x Dn).",
+            "I",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("I", {types::Int64}, "Constrain index tensor to int64"));
+
+static void maxUnpoolShapeInference(InferenceContext& ctx) {
+  // we need at least two inputs to have a shape for this inference.
+  if (ctx.getNumInputs() != 2 && ctx.getNumInputs() != 3) {
+    fail_type_inference("MaxUnpool op must have either two or three inputs.");
+  }
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+  if (!hasInputShape(ctx, 0)) {
+    return; // If first input does not have shape, we cannot infer much.
+  }
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() < 2) {
+    fail_shape_inference("Input tensor X must have at least 2 dimensions.");
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  std::vector<int64_t> pads;
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() != n_input_dims * 2) {
+      fail_shape_inference("Attribute pads has incorrect size.");
+    }
+  } else {
+    pads.assign(n_input_dims * 2, 0);
+  }
+
+  std::vector<int64_t> strides;
+  if (getRepeatedAttribute(ctx, "strides", strides)) {
+    if (strides.size() != n_input_dims) {
+      fail_shape_inference("Attribute strides has incorrect size.");
+    }
+  } else {
+    strides.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> kernel_shape;
+  if (getRepeatedAttribute(ctx, "kernel_shape", kernel_shape)) {
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute kernel_shape has incorrect size.");
+    }
+  } else {
+    fail_shape_inference("Attribute kernel_shape must be specified.");
+  }
+
+  if (ctx.getNumInputs() == 3) {
+    // If the third input, output_size, is specified, then use that instead
+    // of inferring shape from inputs.
+    if (hasInputShape(ctx, 2)) {
+      const auto& output_shape = getInputShape(ctx, 2);
+      if (output_shape.dim_size() != 1) {
+        fail_type_inference("'output_shape' must be rank 1 tensor.");
+      }
+      if (output_shape.dim(0).has_dim_value() &&
+          static_cast<int>(output_shape.dim(0).dim_value()) != input_shape.dim_size()) {
+        fail_shape_inference("'output_shape' must have same number of elements as the shape of input tensor X.");
+      }
+    }
+    return; // 'output_shape' is specified as input. Actual shape will be
+            // determined at runtime.
+  }
+
+  if (!hasInputShape(ctx, 1)) {
+    return; // If indices input does not have shape, we cannot infer output shape.
+  }
+  auto indices_shape = ctx.getInputType(1)->tensor_type().shape();
+  if (indices_shape.dim_size() < 2) {
+    fail_shape_inference("Indices tensor I must have at least 2 dimensions.");
+  }
+
+  auto* final_output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  *final_output_shape->add_dim() = input_shape.dim(0);
+  *final_output_shape->add_dim() = indices_shape.dim(1); // channels should be the second dim of second input.
+
+  int kernel_shape_size = static_cast<int>(kernel_shape.size());
+  for (int i = 0; i < kernel_shape_size; ++i) {
+    auto* newdim = final_output_shape->add_dim();
+    if (!input_shape.dim(2 + i).has_dim_value()) {
+      continue;
+    }
+
+    int64_t newdim_value = strides[i] * (input_shape.dim(2 + i).dim_value() - 1);
+    newdim_value += kernel_shape[i];
+    newdim_value -= pads[i];
+    newdim_value -= pads[i + kernel_shape_size];
+
+    // add in the initial position
+    newdim->set_dim_value(newdim_value);
+  }
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MaxUnpool,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_MaxUnpool_ver11)
+        .Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS)
+        .Attr(
+            "strides",
+            "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("pads", pads_doc, AttributeProto::INTS, OPTIONAL_VALUE)
+        .Input(
+            0,
+            "X",
+            "Input data tensor that has to be unpooled. "
+            "This tensor is typically the first output of the MaxPool op."
+            "Dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non-image case, the "
+            "dimensions are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the batch "
+            "size. Optionally, if dimension denotation is "
+            "in effect, the operation expects the input "
+            "data tensor to arrive with the dimension denotation "
+            "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "I",
+            "Input data tensor containing the indices corresponding to "
+            "elements in the first input tensor X."
+            "This tensor is typically the second output of the MaxPool op."
+            "Dimensions must be the same as input tensor X. "
+            "The indices are linear, i.e. computed considering the tensor as flattened 1-D tensor, "
+            "assuming row-major storage. Also, the linear indices should not consider padding. "
+            "So the values in indices are in the range [0, N x C x D1 x ... x Dn).",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "output_shape",
+            "The shape of the output can be explicitly set which will cause pads values to be auto generated. If 'output_shape' is specified, "
+            "'pads' values are ignored.",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output data tensor that contains the result of the unpooling.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T1", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain index tensor to int64")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { maxUnpoolShapeInference(ctx); }));
+
+static std::function<void(OpSchema&)> LpPoolOpSchemaGenerator(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ {name} consumes an input tensor X and applies Lp pooling across
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ Lp pooling consisting of computing the Lp norm on all values of a subset
+ of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing. The output spatial shape will be following:
+ ```
+ output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+ ```
+ or
+ ```
+ output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+ ```
+ if ceil_mode is enabled `pad_shape[i]` is the sum of pads along axis `i`.
+
+ `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+ ```
+ VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+ ```
+ And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+ ```
+ pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]
+ ```)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc);
+    schema.Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "dilations",
+        "dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", conv_auto_pad_doc, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "p", "p value of the Lp norm used to pool over the input data.", AttributeProto::INT, static_cast<int64_t>(2));
+    schema.Attr(
+        "ceil_mode",
+        "Whether to use ceil or floor (default) to compute the output shape.",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data. For non image case, the "
+        "dimensions are in the form of "
+        "(N x C x D1 x D2 ... Dn), where N is the "
+        "batch size.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from Lp pooling across the input "
+        "tensor. Dimensions will vary based on various kernel, stride, and pad "
+        "sizes.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      convPoolShapeInference(ctx, true, true, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(LpPool, 22, OpSchema().FillUsing(LpPoolOpSchemaGenerator("LpPool")));
+
+// For ROI pool operations.
+static void roiPoolTypeShapeInference(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // rois is the second input.
+  if (!hasNInputShapes(ctx, 2)) {
+    return;
+  }
+
+  // X: [N, C, H, W], rois: [num_rois, 5]
+  Dim N, C, H, W, num_rois, five;
+  five.set_dim_value(5);
+  ctx.unifyInputShape(0, {N, C, H, W});
+  ctx.unifyInputShape(1, {num_rois, five});
+
+  std::vector<int64_t> pooled_shape;
+  if (getRepeatedAttribute(ctx, "pooled_shape", pooled_shape)) {
+    if (pooled_shape.size() != 2) {
+      fail_shape_inference("Attribute pooled_shape has incorrect length");
+    }
+    for (auto dim : pooled_shape) {
+      if (dim <= 0) {
+        fail_shape_inference("Attribute pooled_shape must only contain positive values");
+      }
+    }
+  } else {
+    fail_shape_inference("Attribute pooled_shape must be specified");
+  }
+
+  // output: (num_rois, C, pooled_shape[0], pooled_shape[1])
+  Dim pooled_h, pooled_w;
+  pooled_h.set_dim_value(pooled_shape[0]);
+  pooled_w.set_dim_value(pooled_shape[1]);
+  updateOutputShape(ctx, 0, {num_rois, C, pooled_h, pooled_w});
+}
+
+static std::function<void(OpSchema&)> RoiPoolOpSchemaGenerator(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ ROI {name} pool consumes an input tensor X and region of interests (RoIs) to
+ apply {name} pooling across each RoI, to produce output 4-D tensor of shape
+ (num_rois, channels, pooled_shape[0], pooled_shape[1]).)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc);
+    schema.Attr("pooled_shape", "ROI pool output shape (height, width).", AttributeProto::INTS);
+    schema.Attr(
+        "spatial_scale",
+        "Multiplicative spatial scale factor to translate ROI coordinates from their input scale to the scale used when pooling.",
+        AttributeProto::FLOAT,
+        1.f);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        1,
+        "rois",
+        "RoIs (Regions of Interest) to pool over. Should "
+        "be a 2-D tensor of shape (num_rois, 5) given as "
+        "[[batch_id, x1, y1, x2, y2], ...].",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Output(
+        0,
+        "Y",
+        "RoI pooled output 4-D tensor of shape (num_rois, channels, pooled_shape[0], pooled_shape[1]).",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) { roiPoolTypeShapeInference(ctx); });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(MaxRoiPool, 22, OpSchema().FillUsing(RoiPoolOpSchemaGenerator("max")));
+
+static std::function<void(OpSchema&)> ConvOpSchemaGenerator(const char* filter_desc) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+The convolution operator consumes an input tensor and {filter_desc}, and
+computes the output.)DOC";
+        ReplaceAll(doc, "{filter_desc}", filter_desc););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from previous layer; "
+        "has size (N x C x H x W), where N is the batch size, "
+        "C is the number of channels, and H and W are the "
+        "height and width. Note that this is for the 2D image. "
+        "Otherwise the size is (N x C x D1 x D2 ... x Dn). "
+        "Optionally, if dimension denotation is "
+        "in effect, the operation expects input data tensor "
+        "to arrive with the dimension denotation of [DATA_BATCH, "
+        "DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        1,
+        "W",
+        "The weight tensor that will be used in the "
+        "convolutions; has size (M x C/group x kH x kW), where C "
+        "is the number of channels, and kH and kW are the "
+        "height and width of the kernel, and M is the number "
+        "of feature maps. For more than 2 dimensions, the "
+        "kernel shape will be (M x C/group x k1 x k2 x ... x kn), "
+        "where (k1 x k2 x ... kn) is the dimension of the kernel. "
+        "Optionally, if dimension denotation is in effect, "
+        "the operation expects the weight tensor to arrive "
+        "with the dimension denotation of [FILTER_OUT_CHANNEL, "
+        "FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. "
+        "Assuming zero based indices for the shape array, "
+        "X.shape[1] == (W.shape[1] * group) == C and "
+        "W.shape[0] mod G == 0. Or in other words "
+        "FILTER_IN_CHANNEL multiplied by the number of groups "
+        "should be equal to DATA_CHANNEL and the number of "
+        "feature maps M should be a multiple of the number of "
+        "groups G.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        2,
+        "B",
+        "Optional 1D bias to be added to the convolution, has size of M.",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor that contains the result of the "
+        "convolution. The output dimensions are functions "
+        "of the kernel size, stride size, and pad lengths.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.");
+    schema.Attr(
+        "kernel_shape",
+        "The shape of the convolution kernel. If not present, should be inferred from input W.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "dilations",
+        "dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults is 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", conv_auto_pad_doc, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "group",
+        "number of groups input channels and output channels are divided into.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      convPoolShapeInference(ctx, true, false, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(Conv, 22, OpSchema().FillUsing(ConvOpSchemaGenerator("a filter")));
+
+static constexpr const char* QLinearConv_ver10_doc = R"DOC(
+The convolution operator consumes a quantized input tensor, its scale and zero point,
+a quantized filter, its scale and zero point, and output's scale and zero point,
+and computes the quantized output. Each scale and zero-point pair must have same shape.
+It means they must be either scalars (per tensor) or 1-D tensors (per output channel).
+Each input or output and its related zero point must have same type.
+When bias is present it must be quantized using scale = input scale * weight scale and
+zero point as 0.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QLinearConv,
+    10,
+    OpSchema()
+        .SetDoc(QLinearConv_ver10_doc)
+        .Input(
+            0,
+            "x",
+            "Input data tensor from previous layer; "
+            "has size (N x C x H x W), where N is the batch size, "
+            "C is the number of channels, and H and W are the "
+            "height and width. Note that this is for the 2D image. "
+            "Otherwise the size is (N x C x D1 x D2 ... x Dn). "
+            "Optionally, if dimension denotation is "
+            "in effect, the operation expects input data tensor "
+            "to arrive with the dimension denotation of [DATA_BATCH, "
+            "DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+            "T1")
+        .Input(
+            1,
+            "x_scale",
+            "Scale tensor for input 'x'. It's a scalar, which means a per-tensor/layer quantization.",
+            "tensor(float)")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point tensor for input 'x'. It's a scalar, which means a per-tensor/layer quantization.",
+            "T1")
+        .Input(
+            3,
+            "w",
+            "The weight tensor that will be used in the "
+            "convolutions; has size (M x C/group x kH x kW), where C "
+            "is the number of channels, and kH and kW are the "
+            "height and width of the kernel, and M is the number "
+            "of feature maps. For more than 2 dimensions, the "
+            "kernel shape will be (M x C/group x k1 x k2 x ... x kn), "
+            "where (k1 x k2 x ... kn) is the dimension of the kernel. "
+            "Optionally, if dimension denotation is in effect, "
+            "the operation expects the weight tensor to arrive "
+            "with the dimension denotation of [FILTER_OUT_CHANNEL, "
+            "FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. "
+            "X.shape[1] == (W.shape[1] * group) == C "
+            "(assuming zero based indices for the shape array). "
+            "Or in other words FILTER_IN_CHANNEL should be equal to DATA_CHANNEL. ",
+            "T2")
+        .Input(
+            4,
+            "w_scale",
+            "Scale tensor for input 'w'. It could be a scalar or a 1-D tensor, which means a per-tensor/layer or per output channel quantization. If it's a 1-D tensor, its number of elements should be equal to the number of output channels (M).",
+            "tensor(float)")
+        .Input(
+            5,
+            "w_zero_point",
+            "Zero point tensor for input 'w'. It could be a scalar or a 1-D tensor, which means a per-tensor/layer or per output channel quantization. If it's a 1-D tensor, its number of elements should be equal to the number of output channels (M).",
+            "T2")
+        .Input(
+            6,
+            "y_scale",
+            "Scale tensor for output 'y'. It's a scalar, which means a per-tensor/layer quantization.",
+            "tensor(float)")
+        .Input(
+            7,
+            "y_zero_point",
+            "Zero point tensor for output 'y'. It's a scalar, which means a per-tensor/layer quantization.",
+            "T3")
+        .Input(
+            8,
+            "B",
+            "Optional 1D bias to be added to the convolution, has size of M. "
+            "Bias must be quantized using scale = x_scale * w_scale and zero_point = 0",
+            "T4",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "y",
+            "Output data tensor that contains the result of the "
+            "convolution. The output dimensions are functions "
+            "of the kernel size, stride size, and pad lengths.",
+            "T3")
+        .TypeConstraint("T1", {types::Int8, types::UInt8}, "Constrain input type to 8-bit integer tensor.")
+        .TypeConstraint("T2", {types::Int8, types::UInt8}, "Constrain filter type to 8-bit integer tensor.")
+        .TypeConstraint("T3", {types::Int8, types::UInt8}, "Constrain output type to 8-bit integer tensor.")
+        .TypeConstraint("T4", {types::Int32}, "Constrain bias type to 32-bit integer tensor.")
+        .Attr("auto_pad", conv_auto_pad_doc, AttributeProto::STRING, std::string("NOTSET"))
+        .Attr(
+            "kernel_shape",
+            "The shape of the convolution kernel. If not present, should be inferred from input 'w'.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dilations",
+            "dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "strides",
+            "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "pads",
+            "Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0."
+            "The value represent the number of pixels added to the beginning and end part of the corresponding axis."
+            "`pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of"
+            "pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`."
+            "This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults"
+            "to 0 along start and end of each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "group",
+            "number of groups input channels and output channels are divided into. default is 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto x_type = ctx.getInputType(0);
+          auto w_type = ctx.getInputType(3);
+          if (nullptr == x_type || nullptr == w_type || x_type->value_case() != TypeProto::kTensorType ||
+              w_type->value_case() != TypeProto::kTensorType) {
+            fail_type_inference("inputs are expected to have tensor type in ", ctx.getDisplayName(), ".");
+          }
+
+          auto x_zero_point_type = ctx.getInputType(2);
+          if (nullptr == x_zero_point_type ||
+              x_zero_point_type->tensor_type().elem_type() != x_type->tensor_type().elem_type()) {
+            fail_type_inference(
+                "input and zero_point pair is expected to have be same type in ", ctx.getDisplayName(), ".");
+          }
+
+          auto w_zero_point_type = ctx.getInputType(5);
+          if (nullptr == w_zero_point_type ||
+              w_zero_point_type->tensor_type().elem_type() != w_type->tensor_type().elem_type()) {
+            fail_type_inference(
+                "weight and zero_point pair is expected to have same type in ", ctx.getDisplayName(), ".");
+          }
+
+          propagateElemTypeFromInputToOutput(ctx, 7, 0);
+
+          convPoolShapeInference(ctx, true, false, 0, 3);
+        }));
+
+static constexpr const char* ConvInteger_ver10_doc = R"DOC(
+The integer convolution operator consumes an input tensor, its zero-point, a filter, and its zero-point,
+and computes the output. The production MUST never overflow. The accumulation may overflow if and only if in 32 bits.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ConvInteger,
+    10,
+    OpSchema()
+        .SetDoc(ConvInteger_ver10_doc)
+        .Input(
+            0,
+            "x",
+            "Input data tensor from previous layer; "
+            "has size (N x C x H x W), where N is the batch size, "
+            "C is the number of channels, and H and W are the "
+            "height and width. Note that this is for the 2D image. "
+            "Otherwise the size is (N x C x D1 x D2 ... x Dn). "
+            "Optionally, if dimension denotation is "
+            "in effect, the operation expects input data tensor "
+            "to arrive with the dimension denotation of [DATA_BATCH, "
+            "DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+            "T1")
+        .Input(
+            1,
+            "w",
+            "The weight tensor that will be used in the "
+            "convolutions; has size (M x C/group x kH x kW), where C "
+            "is the number of channels, and kH and kW are the "
+            "height and width of the kernel, and M is the number "
+            "of feature maps. For more than 2 dimensions, the "
+            "kernel shape will be (M x C/group x k1 x k2 x ... x kn), "
+            "where (k1 x k2 x ... kn) is the dimension of the kernel. "
+            "Optionally, if dimension denotation is in effect, "
+            "the operation expects the weight tensor to arrive "
+            "with the dimension denotation of [FILTER_OUT_CHANNEL, "
+            "FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. "
+            "X.shape[1] == (W.shape[1] * group) == C "
+            "(assuming zero based indices for the shape array). "
+            "Or in other words FILTER_IN_CHANNEL should be equal to DATA_CHANNEL. ",
+            "T2")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point tensor for input 'x'. It's optional and default value is 0. It's a scalar, which means a per-tensor/layer quantization.",
+            "T1",
+            OpSchema::Optional)
+        .Input(
+            3,
+            "w_zero_point",
+            "Zero point tensor for input 'w'. It's optional and default value is 0.  It could be a scalar or a 1-D tensor, "
+            "which means a per-tensor/layer or per output channel quantization. If it's a 1-D tensor, its number "
+            "of elements should be equal to the number of output channels (M)",
+            "T2",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "y",
+            "Output data tensor that contains the result of the "
+            "convolution. The output dimensions are functions "
+            "of the kernel size, stride size, and pad lengths.",
+            "T3")
+        .TypeConstraint(
+            "T1",
+            {types::Int8, types::UInt8},
+            "Constrain input x and its zero point data type to 8-bit integer tensor.")
+        .TypeConstraint(
+            "T2",
+            {types::Int8, types::UInt8},
+            "Constrain input w and its zero point data type to 8-bit integer tensor.")
+        .TypeConstraint("T3", {types::Int32}, "Constrain output y data type to 32-bit integer tensor.")
+        .Attr("auto_pad", conv_auto_pad_doc, AttributeProto::STRING, std::string("NOTSET"))
+        .Attr(
+            "kernel_shape",
+            "The shape of the convolution kernel. If not present, should be inferred from input 'w'.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "dilations",
+            "dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "strides",
+            "Stride along each spatial axis. If not present, the stride defaults to 1 along each axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "pads",
+            "Padding for the beginning and ending along each spatial axis, it can take any value greater than or equal to 0."
+            "The value represent the number of pixels added to the beginning and end part of the corresponding axis."
+            "`pads` format should be as follow [x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of"
+            "pixels added at the beginning of axis `i` and xi_end, the number of pixels added at the end of axis `i`."
+            "This attribute cannot be used simultaneously with auto_pad attribute. If not present, the padding defaults"
+            "to 0 along start and end of each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "group",
+            "number of groups input channels and output channels are divided into. default is 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto x_type = ctx.getInputType(0);
+          auto w_type = ctx.getInputType(1);
+          auto y_type = ctx.getOutputType(0);
+          if (nullptr == x_type || nullptr == w_type || nullptr == y_type ||
+              x_type->value_case() != TypeProto::kTensorType || w_type->value_case() != TypeProto::kTensorType) {
+            fail_type_inference("inputs are expected to have tensor type and output type should not be null.");
+          }
+
+          // Right now we only support int32
+          y_type->mutable_tensor_type()->set_elem_type(TensorProto::INT32);
+
+          convPoolShapeInference(ctx, true, false, 0, 1);
+        }));
+
+ONNX_API void convTransposeShapeInference(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // we need at least two inputs to have a shape for this inference.
+  if (!hasNInputShapes(ctx, 2)) {
+    return;
+  }
+
+  int64_t group = getAttribute(ctx, "group", 1);
+  if (group <= 0) {
+    fail_shape_inference("Attribute group must be > 0 for ConvTranspose. group=", group, ".");
+  }
+
+  auto validate_input_channels_for_group = [](const TensorShapeProto& input_shape_proto, int64_t channel_group) {
+    if (input_shape_proto.dim_size() < 2) {
+      return;
+    }
+
+    const auto& input_channels_dim = input_shape_proto.dim(1);
+    if (input_channels_dim.has_dim_value() && input_channels_dim.dim_value() % channel_group != 0) {
+      fail_shape_inference(
+          "Input channels C must be divisible by group for ConvTranspose. C=",
+          input_channels_dim.dim_value(),
+          " group=",
+          channel_group,
+          ".");
+    }
+  };
+
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() < 3) {
+    fail_shape_inference(
+        "Input tensor must have at least 3 dimensions (N x C x D1...Dn). Got: ", input_shape.dim_size());
+  }
+  validate_input_channels_for_group(input_shape, group);
+
+  // Weight tensor (input 1) must also have at least 3 dimensions (C x M/group x k1...kn).
+  auto weight_shape = ctx.getInputType(1)->tensor_type().shape();
+  if (weight_shape.dim_size() < 3) {
+    fail_shape_inference(
+        "Weight tensor must have at least 3 dimensions (C x M/group x k1...kn). Got: ", weight_shape.dim_size());
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  std::vector<int64_t> dilations;
+  if (getRepeatedAttribute(ctx, "dilations", dilations)) {
+    if (dilations.size() != n_input_dims) {
+      fail_shape_inference("Attribute dilations has incorrect size");
+    }
+    if (std::any_of(dilations.begin(), dilations.end(), [](int64_t d) { return d <= 0; })) {
+      fail_shape_inference("Attribute dilations must only contain positive values");
+    }
+  } else {
+    dilations.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> strides;
+  if (getRepeatedAttribute(ctx, "strides", strides)) {
+    if (strides.size() != n_input_dims) {
+      fail_shape_inference("Attribute strides has incorrect size");
+    }
+    if (std::any_of(strides.begin(), strides.end(), [](int64_t s) { return s <= 0; })) {
+      fail_shape_inference("Attribute strides must only contain positive values");
+    }
+  } else {
+    strides.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> kernel_shape;
+  if (getRepeatedAttribute(ctx, "kernel_shape", kernel_shape)) {
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute kernel_shape has incorrect size");
+    }
+  } else {
+    for (int i = 2; i < weight_shape.dim_size(); ++i) {
+      if (!weight_shape.dim(i).has_dim_value()) {
+        return;
+      }
+      kernel_shape.push_back(weight_shape.dim(i).dim_value());
+    }
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Weight tensor spatial rank does not match input tensor spatial rank");
+    }
+  }
+
+  if (std::any_of(kernel_shape.begin(), kernel_shape.end(), [](int64_t k) { return k <= 0; })) {
+    fail_shape_inference("Attribute kernel_shape must only contain positive values");
+  }
+
+  std::vector<int64_t> effective_kernel_shape = kernel_shape;
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
+    // accounting for dilation, how big is the kernel in this dimension
+    effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
+  }
+
+  std::vector<int64_t> pads;
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() != n_input_dims * 2) {
+      fail_shape_inference("Attribute pads has incorrect size");
+    }
+    if (std::any_of(pads.begin(), pads.end(), [](int64_t p) { return p < 0; })) {
+      fail_shape_inference("Attribute pads must not contain negative values");
+    }
+    const auto* const auto_pad_attr = ctx.getAttribute("auto_pad");
+    if (nullptr != auto_pad_attr && auto_pad_attr->s() != "NOTSET") {
+      fail_shape_inference("The pads attribute cannot be used simultaneously with auto_pad attribute");
+    }
+  } else {
+    pads.assign(n_input_dims * 2, 0);
+    const auto* const auto_pad_attr = ctx.getAttribute("auto_pad");
+    if ((nullptr != auto_pad_attr) && (auto_pad_attr->s() != "VALID")) {
+      int input_dims_size = static_cast<int>(n_input_dims);
+      for (int i = 0; i < input_dims_size; ++i) {
+        int64_t total_pad = effective_kernel_shape[i] - strides[i];
+        total_pad = std::max<int64_t>(total_pad, 0);
+        int64_t half_pad_small = total_pad >> 1;
+        int64_t half_pad_big = total_pad - half_pad_small;
+        if (auto_pad_attr->s() == "SAME_UPPER") {
+          pads[i] = half_pad_small;
+          pads[i + input_dims_size] = half_pad_big;
+        } else if (auto_pad_attr->s() == "SAME_LOWER") {
+          pads[i] = half_pad_big;
+          pads[i + input_dims_size] = half_pad_small;
+        }
+      }
+    }
+  }
+
+  std::vector<int64_t> output_shape;
+  bool output_shape_presented = true;
+  if (getRepeatedAttribute(ctx, "output_shape", output_shape)) {
+    if (output_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute output_shape has incorrect size");
+    }
+    if (std::any_of(output_shape.begin(), output_shape.end(), [](int64_t s) { return s < 0; })) {
+      fail_shape_inference("Attribute output_shape must not contain negative values");
+    }
+  } else {
+    output_shape_presented = false;
+  }
+
+  std::vector<int64_t> output_padding;
+  if (getRepeatedAttribute(ctx, "output_padding", output_padding)) {
+    if (output_padding.size() != n_input_dims) { // Added only to one side.
+      fail_shape_inference("Attribute output_padding has incorrect size");
+    }
+    if (std::any_of(output_padding.begin(), output_padding.end(), [](int64_t p) { return p < 0; })) {
+      fail_shape_inference("Attribute output_padding must not contain negative values");
+    }
+  } else {
+    output_padding.assign(n_input_dims, 0);
+  }
+
+  auto* final_output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  *final_output_shape->add_dim() = input_shape.dim(0);
+  *final_output_shape->add_dim() = weight_shape.dim(1) * group; // channels should be the second dim of second input
+                                                                // multiply group.
+
+  int size_of_output = 0;
+  if (output_shape_presented) {
+    size_of_output = static_cast<int>(output_shape.size());
+    for (int i = 0; i < size_of_output; ++i) {
+      if (input_shape.dim(i + 2).has_dim_value()) {
+        if (output_shape[i] < input_shape.dim(i + 2).dim_value()) {
+          // TODO(ONNX): throw exception?
+          return; // output shape value cannot be smaller than the input shape
+                  // value
+        }
+      }
+      final_output_shape->add_dim()->set_dim_value(output_shape[i]);
+    }
+    return;
+  } else {
+    size_of_output = input_shape.dim_size() - 2;
+    for (int i = 0; i < size_of_output; ++i) {
+      if (input_shape.dim(i + 2).has_dim_value()) {
+        int64_t output_shape_dim = strides[i] * (input_shape.dim(i + 2).dim_value() - 1) + output_padding[i] +
+            effective_kernel_shape[i] - pads[i] - pads[i + n_input_dims];
+        final_output_shape->add_dim()->set_dim_value(output_shape_dim);
+      } else {
+        final_output_shape->add_dim();
+      }
+    }
+    return;
+  }
+}
+
+static std::function<void(OpSchema&)> ConvTransposeOpSchemaGenerator(const char* filter_desc) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+The convolution transpose operator consumes an input tensor and {filter_desc},
+and computes the output.
+
+If the pads parameter is provided the shape of the output is calculated via the following equation:
+
+  output_shape[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - pads[start_i] - pads[end_i]
+
+output_shape can also be explicitly specified in which case pads values are auto generated using these equations:
+
+  total_padding[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - output_shape[i]
+  If (auto_pads == SAME_UPPER): pads[start_i] = total_padding[i]/2; pads[end_i] = total_padding[i] - (total_padding[i]/2)
+  Else: pads[start_i] = total_padding[i] - (total_padding[i]/2); pads[end_i] = (total_padding[i]/2).
+
+    )DOC";
+        ReplaceAll(doc, "{filter_desc}", filter_desc););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from previous layer; has size (N x C x H x W)"
+        ", where N is the batch size, C is the number of channels, and"
+        " H and W are the height and width. Note that this is for the 2D image. "
+        "Otherwise the size is (N x C x D1 x D2 ... x Dn)",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        1,
+        "W",
+        "The weight tensor that will be used in the "
+        "convolutions; has size (C x M/group x kH x kW), where C "
+        "is the number of channels, and kH and kW are the "
+        "height and width of the kernel, and M is the number "
+        "of feature maps. For more than 2 dimensions, the "
+        "weight shape will be (C x M/group x k1 x k2 x ... x kn), "
+        "where (k1 x k2 x ... x kn) is the dimension of the kernel. "
+        "The number of channels in the output should be equal to W.shape[1] * group "
+        "(assuming zero based indices of the shape array)",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        2,
+        "B",
+        "Optional 1D bias to be added to the convolution, has size of M.",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor that contains the result of the convolution. The "
+        "output dimensions are functions of the kernel size, stride size, "
+        "pad lengths and group count. "
+        "The number of channels in the output should be equal to W.shape[1] * group "
+        "(assuming zero based indices of the shape array)",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.");
+    schema.Attr(
+        "kernel_shape",
+        "The shape of the convolution kernel. If not present, should be inferred from input W.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "output_shape",
+        "The shape of the output can be explicitly set which will cause pads values to be auto generated. If output_shape is specified "
+        "pads values are ignored. See doc for details for equations to generate pads. Note that the output_shape attribute value "
+        "should not include dimensions for batch size and channels, which are automatically inferred.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "output_padding",
+        "Additional elements added to the side with higher coordinate indices in the output. "
+        "Each padding value in \"output_padding\" must be less than the corresponding stride/dilation dimension. "
+        "By default, this attribute is a zero vector. "
+        "Note that this attribute doesn't directly affect the computed output values. "
+        "It only controls the selection of the computed values, "
+        "so changing this attribute only adds or removes output elements. "
+        "If \"output_shape\" is explicitly provided, "
+        "\"output_padding\" does not contribute additional size to \"output_shape\" but "
+        "participates in the computation of the needed padding amount. "
+        "This is also called adjs or adjustment in some frameworks.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "dilations",
+        "dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", conv_transpose_auto_pad_doc, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "group",
+        "number of groups input channels and output channels are divided into.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) { convTransposeShapeInference(ctx); });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(ConvTranspose, 22, OpSchema().FillUsing(ConvTransposeOpSchemaGenerator("a filter")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DeformConv,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_DeformConv_ver19)
+        .Input(
+            0,
+            "X",
+            "Input data tensor. For 2D image data, it has shape (N, C, H, W) where N is the batch size, "
+            "C is the number of input channels, and H and W are the height and width. "
+            "In general, the shape is (N, C, D1, D2, ... , Dn) for n-dimensional data, where "
+            "D1 to Dn are the spatial dimension sizes. Most common use cases have n = 2 or 3.",
+            "T")
+        .Input(
+            1,
+            "W",
+            "Weight tensor that will be used in the convolutions. It has shape (oC, C/group, kH, kW), "
+            "where oC is the number of output channels and kH and kW are the kernel height and width. "
+            "For more than 2 dimensions, it has shape (oC, C/group, k1, k2, ... , kn).",
+            "T")
+        .Input(
+            2,
+            "offset",
+            "Offset tensor denoting the offset for the sampling locations in the convolution kernel. "
+            "It has shape (N, offset_group * kH * kW * 2, oH, oW) for 2D data or "
+            "(N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Use linear interpolation"
+            "for fractional offset values. Sampling locations outside of the padded input tensor gives zero.",
+            "T")
+        .Input(
+            3,
+            "B",
+            "Optional 1D bias of length oC to be added to the convolution. Default is a tensor of zeros.",
+            "T",
+            OpSchema::Optional)
+        .Input(
+            4,
+            "mask",
+            "The mask tensor to be applied to each position in the convolution kernel. "
+            "It has shape (N, offset_group * kH * kW, oH, oW) for 2D data or "
+            "(N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Default is a "
+            "tensor of ones.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "Y",
+            "Output data tensor that contains the result of convolution. It has shape (N, oC, oH, oW) "
+            "for 2D data or (N, oC, o1, o2, ..., on) for nD data",
+            "T")
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .Attr(
+            "dilations",
+            "Dilation value along each spatial axis of the kernel. Default is 1 along each axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "group",
+            "Number of groups the input and output channels, C and oC, are divided into. C and oC must both "
+            "be divisible by group. Default is 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "kernel_shape",
+            "Shape of the convolution kernel. If not present, it is inferred from the shape of input W.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "offset_group",
+            "Number of groups of offset. C must be divisible by offset_group. Default is 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "pads",
+            "Padding for the beginning and end along each spatial axis. The values represent the number of pixels "
+            "added to the beginning and end of the corresponding axis and can take any nonnegative value. "
+            "The format should be as follows: [x1_begin, x2_begin, ..., x1_end, x2_end, ...], where xi_begin "
+            "is the number of pixels added at the beginning of axis `i` and xi_end is the number of pixels "
+            "added at the end of axis `i`. Default is 0 along each axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "strides",
+            "Stride along each spatial axis. Default is 1 along each axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          convPoolShapeInference(ctx, true, false, 0, 1);
+        }));
+
+// For GlobalPool operations.
+ONNX_API void globalPoolTypeShapeInference(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // needs at least one input with shape.
+  if (!hasNInputShapes(ctx, 1)) {
+    return;
+  }
+
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() < 2) {
+    return;
+  }
+
+  // X: [N, C, D1, ..., Dn] -> Y: [N, C, 1, 1, ..., 1]
+  Dim N, C;
+  ctx.unifyInputShapePrefix(0, {N, C});
+
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+  auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+  *output_shape->add_dim() = N;
+  *output_shape->add_dim() = C;
+
+  for (size_t i = 0; i < n_input_dims; ++i) {
+    output_shape->add_dim()->set_dim_value(1);
+  }
+}
+
+static std::function<void(OpSchema&)> GlobalPoolingOpSchemaGenerator(const char* op_type, const char* op) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ Global{op_type} consumes an input tensor X and applies {op} pooling across
+ the values in the same channel. This is equivalent to {op_type} with kernel size
+ equal to the spatial dimension of input tensor.)DOC";
+        ReplaceAll(doc, "{op_type}", op_type);
+        ReplaceAll(doc, "{op}", op););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the width "
+        "of the data. For non image case, the dimensions are "
+        "in the form of (N x C x D1 x D2 ... Dn), "
+        "where N is the batch size.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from pooling across the input "
+        "tensor. The output tensor has the same rank as the input. "
+        "The first two dimensions of output shape are the same as "
+        "the input (N x C), while the other dimensions are all 1.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) { globalPoolTypeShapeInference(ctx); });
+  };
+}
+ONNX_OPERATOR_SET_SCHEMA(
+    GlobalAveragePool,
+    22,
+    OpSchema().FillUsing(GlobalPoolingOpSchemaGenerator("AveragePool", "average")));
+ONNX_OPERATOR_SET_SCHEMA(GlobalMaxPool, 22, OpSchema().FillUsing(GlobalPoolingOpSchemaGenerator("MaxPool", "max")));
+
+static std::function<void(OpSchema&)> GlobalLpPoolingOpSchemaGenerator(const char* op_type, const char* op) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ Global{op_type} consumes an input tensor X and applies {op} pooling across
+ the values in the same channel. This is equivalent to {op_type} with kernel size
+ equal to the spatial dimension of input tensor.)DOC";
+        ReplaceAll(doc, "{op_type}", op_type);
+        ReplaceAll(doc, "{op}", op););
+    schema.SetDoc(doc);
+    schema.Attr(
+        "p", "p value of the Lp norm used to pool over the input data.", AttributeProto::INT, static_cast<int64_t>(2));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the width "
+        "of the data. For non image case, the dimensions are "
+        "in the form of (N x C x D1 x D2 ... Dn), "
+        "where N is the batch size.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from pooling across the input "
+        "tensor. The output tensor has the same rank as the input. "
+        "The first two dimensions of output shape are the same as "
+        "the input (N x C), while the other dimensions are all 1.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) { globalPoolTypeShapeInference(ctx); });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(GlobalLpPool, 22, OpSchema().FillUsing(GlobalLpPoolingOpSchemaGenerator("LpPool", "lp pool")));
+
+static constexpr const char* BatchNormalization_ver15_doc = R"DOC(
+Carries out batch normalization as described in the paper
+https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+There are five required inputs 'X', 'scale', 'B', 'input_mean' and
+'input_var'.
+Note that 'input_mean' and 'input_var' are expected to be the estimated
+statistics in inference mode (training_mode=False, default),
+and the running statistics in training mode (training_mode=True).
+There are multiple cases for the number of outputs, which we list below:
+
+* Output case #1: Y, running_mean, running_var (training_mode=True)
+* Output case #2: Y (training_mode=False)
+
+When training_mode=False, extra outputs are invalid.
+The outputs are updated as follows when training_mode=True:
+```
+running_mean = input_mean * momentum + current_mean * (1 - momentum)
+running_var = input_var * momentum + current_var * (1 - momentum)
+
+Y = (X - current_mean) / sqrt(current_var + epsilon) * scale + B
+```
+where:
+```
+current_mean = ReduceMean(X, axis=all_except_channel_index)
+current_var =  ReduceVar(X, axis=all_except_channel_index)
+```
+Notice that `ReduceVar` refers to the population variance, and it equals to
+`sum(sqrd(x_i - x_avg)) / N`
+where `N` is the population size (this formula does not use sample size `N - 1`).
+
+The computation of ReduceMean and ReduceVar uses float to avoid overflow for float16 inputs.
+
+When training_mode=False:
+```
+Y = (X - input_mean) / sqrt(input_var + epsilon) * scale + B
+```
+
+For previous (depreciated) non-spatial cases, implementors are suggested
+to flatten the input shape to (N x C * D1 * D2 * ... * Dn) before a BatchNormalization Op.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BatchNormalization,
+    15,
+    OpSchema()
+        .NumOutputs({1, 3})
+        .SetDoc(BatchNormalization_ver15_doc + GenerateOptionalArgumentsDoc())
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Attr(
+            "momentum",
+            "Factor used in computing the running mean and variance."
+            "e.g., running_mean = running_mean * momentum + mean * (1 - momentum).",
+            AttributeProto::FLOAT,
+            0.9f)
+        .Attr(
+            "training_mode",
+            "If set to true, it indicates BatchNormalization is being used for training, and outputs 1 "
+            "and 2 are to be computed.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "dimensions are in the form of (N x C x D1 x D2 ... Dn), "
+            "where N is the batch size, C is the number of channels. "
+            "Statistics are computed for every channel of C over N and D1 to Dn dimensions. "
+            "For image data, input dimensions become (N x C x H x W). "
+            "The op also accepts single dimension input of size N in which case C is assumed to be 1",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(1, "scale", "Scale tensor of shape (C).", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(2, "B", "Bias tensor of shape (C).", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            3,
+            "input_mean",
+            "running (training) or estimated (testing) mean tensor of shape (C).",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            4,
+            "input_var",
+            "running (training) or estimated (testing) variance tensor of shape (C).",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "Y",
+            "The output tensor of the same shape as X",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            1,
+            "running_mean",
+            "The running mean after the BatchNormalization operator.",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            2,
+            "running_var",
+            "The running variance after the BatchNormalization operator. This op uses the population size (N) for "
+            "calculating variance, and not the sample size N-1.",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint(
+            "T1",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain scale and bias types to float tensors.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain mean and variance types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateShapeAndTypeFromFirstInput(ctx);
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+
+          // Inputs 1 to 4 must be of rank 1.
+          checkInputRank(ctx, 1, 1);
+          checkInputRank(ctx, 2, 1);
+          checkInputRank(ctx, 3, 1);
+          checkInputRank(ctx, 4, 1);
+
+          Dim num_channels;
+
+          if (hasInputShape(ctx, 0)) {
+            if (getInputShape(ctx, 0).dim_size() > 1)
+              unifyInputDim(ctx, 0, 1, num_channels);
+            else
+              unifyDim(num_channels, 1);
+          }
+
+          unifyInputDim(ctx, 1, 0, num_channels);
+          unifyInputDim(ctx, 2, 0, num_channels);
+          unifyInputDim(ctx, 3, 0, num_channels);
+          unifyInputDim(ctx, 4, 0, num_channels);
+
+          if (ctx.getAttribute("training_mode") && static_cast<int>(ctx.getAttribute("training_mode")->i()) != 0) {
+            if (ctx.getNumOutputs() != 3)
+              fail_shape_inference("This number of op outputs should be 3 when Training_mode = True, but it is not.");
+          } else {
+            if (ctx.getNumOutputs() != 1)
+              fail_shape_inference("This number of op outputs should be 1 when Training_mode = False, but it is not.");
+          }
+
+          if (ctx.getNumOutputs() > 1) {
+            TensorShapeProto outputs_shape;
+            *outputs_shape.add_dim() = num_channels; // channel
+
+            propagateElemTypeFromInputToOutput(ctx, 3, 1);
+            updateOutputShape(ctx, 1, outputs_shape);
+
+            if (ctx.getNumOutputs() > 2) {
+              propagateElemTypeFromInputToOutput(ctx, 4, 2);
+              updateOutputShape(ctx, 2, outputs_shape);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    InstanceNormalization,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_InstanceNormalization_ver6)
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Input(
+            0,
+            "input",
+            "Input data tensor from the previous operator; "
+            "dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non image case, the "
+            "dimensions are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the batch "
+            "size.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "scale",
+            "The input 1-dimensional scale tensor of size C.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "B",
+            "The input 1-dimensional bias tensor of size C.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "The output tensor of the same shape as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { propagateShapeAndTypeFromFirstInput(ctx); }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LpNormalization,
+    22,
+    OpSchema()
+        .Input(0, "input", "Input matrix", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Matrix after normalization", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .SetDoc(kDoc_LpNormalization_ver1)
+        .Attr(
+            "axis",
+            "The axis on which to apply normalization, -1 mean last axis.",
+            AttributeProto::INT,
+            static_cast<int64_t>(-1))
+        .Attr(
+            "p",
+            "The order of the normalization, only 1 or 2 are supported.",
+            AttributeProto::INT,
+            static_cast<int64_t>(2))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { propagateShapeAndTypeFromFirstInput(ctx); }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Dropout,
+    22,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_Dropout_ver13) + GenerateOptionalArgumentsDoc()))
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "data", "The input data as Tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "ratio",
+            "The ratio of random dropout, with value in [0, 1). If set to 0, "
+            "the output would be a simple copy of the input. "
+            "If it's non-zero, output will be a random dropout of the scaled input, which is typically "
+            "the case during training. It is an optional value, if not specified it will default to 0.5.",
+            "T1",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "training_mode",
+            "If set to true then it indicates dropout is being used for training. It is an optional value hence unless "
+            "specified explicitly, it is false. If it is false, ratio is ignored and the operation mimics inference mode where "
+            "nothing will be dropped from the input data and if mask is requested as output it will contain all ones.",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "output", "The output.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(1, "mask", "The output mask.", "T2", OpSchema::Optional, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir10(), "Constrain input and output types to float tensors.")
+        .TypeConstraint("T1", OpSchema::all_float_types_ir10(), "Constrain input 'ratio' types to float tensors.")
+        .TypeConstraint("T2", {types::Bool}, "Constrain output 'mask' types to boolean tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasInputShape(ctx, 0)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+
+          if (ctx.getNumInputs() > 1 && hasInputShape(ctx, 1)) {
+            auto& ratio_input_shape = getInputShape(ctx, 1);
+            if (static_cast<int>(ratio_input_shape.dim_size()) != 0) {
+              fail_shape_inference("Ratio of Dropout must be a scalar.");
+            }
+          }
+
+          if (ctx.getNumInputs() > 2 && hasInputShape(ctx, 2)) {
+            auto& training_mode_input_shape = getInputShape(ctx, 2);
+            if (static_cast<int>(training_mode_input_shape.dim_size()) != 0) {
+              fail_shape_inference("training_mode of Dropout must be a scalar.");
+            }
+          }
+
+          if (ctx.getNumOutputs() == 2) {
+            updateOutputElemType(ctx, 1, TensorProto::BOOL);
+            if (hasNInputShapes(ctx, 1)) {
+              propagateShapeFromInputToOutput(ctx, 0, 1);
+            }
+          }
+        }));
+
+static constexpr const char* Shrink_ver9_doc = R"DOC(
+Shrink takes one input data (Tensor<numeric>) and produces one Tensor output,
+having same datatype and shape with input. It has two attributes, lambd and
+bias. The formula of this operator is: If x < -lambd, y = x + bias;
+If x > lambd, y = x - bias; Otherwise, y = 0.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Shrink,
+    9,
+    OpSchema()
+        .SetDoc(Shrink_ver9_doc)
+        .Attr("lambd", "The lambd value for the Shrink formulation. Default is 0.5.", AttributeProto::FLOAT, 0.5f)
+        .Attr("bias", "The bias value added to output. Default is 0.", AttributeProto::FLOAT, 0.0f)
+        .Input(0, "input", "The input data as Tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "The output.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input to only numeric types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput)
+        .FunctionBody(
+            R"ONNX(
+          {
+            Lambd = Constant <value_float: float = @lambd>()
+            LambdCast = CastLike (Lambd, input)
+            Bias = Constant <value_float: float = @bias>()
+            BiasCast = CastLike (Bias, input)
+            Zero = Constant <value = float {0.0}>()
+            ZeroCast = CastLike (Zero, input)
+            NegLmbda = Neg (LambdCast)
+            InputLessThanNegLambda = Less (input, NegLmbda)
+            InputAddBias = Add (input, BiasCast)
+            InputSubBias = Sub (input, BiasCast)
+            LambdaLessThanInput = Less (LambdCast, input)
+            InputSubBiasOrZero = Where (LambdaLessThanInput, InputSubBias, ZeroCast)
+            output = Where(InputLessThanNegLambda, InputAddBias, InputSubBiasOrZero)
+          }
+        )ONNX",
+            18));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Flatten,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_Flatten_ver24)
+        .Input(0, "input", "A tensor of rank >= axis.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "A 2D tensor with the contents of the input tensor, "
+            "with input dimensions up to axis flattened to the outer dimension "
+            "of the output and remaining input dimensions flattened into the inner "
+            "dimension of the output.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir13(),
+            "Constrain input and output to all tensor types up to IRv13.")
+        .Attr(
+            "axis",
+            "Indicate up to which input dimensions "
+            "(exclusive) should be flattened to the outer dimension of the output. "
+            "The value for axis must be in the range [-r, r], where r is the rank of the input tensor. "
+            "Negative value means counting dimensions from the back. "
+            "When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), "
+            "where the shape of the input tensor is (d_0, d_1, ... d_n). ",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int rank = static_cast<int>(input_shape.dim_size());
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+          if (axis < 0) {
+            axis += rank;
+          }
+          if (axis > rank || axis < 0) {
+            fail_shape_inference("Invalid value(", axis, ") for attribute 'axis'");
+          }
+          // TODO(ONNX): is the operation defined for input-rank < 2?
+          updateOutputShape(ctx, 0, {multiplyDims(input_shape, 0, axis), multiplyDims(input_shape, axis, rank)});
+        }));
+
+static constexpr const char* LRN_ver13_doc = R"DOC(
+Local Response Normalization proposed in the [AlexNet paper](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf).
+It normalizes over local input regions.
+The local region is defined across the channels. For an element `X[n, c, d1, ..., dk]` in a tensor
+of shape `(N x C x D1 x D2, ..., Dk)`, its region is
+`{X[n, i, d1, ..., dk] | max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))}`.
+
+`square_sum[n, c, d1, ..., dk] = sum(X[n, i, d1, ..., dk] ^ 2)`,
+where `max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))`.
+
+`Y[n, c, d1, ..., dk] = X[n, c, d1, ..., dk] / (bias + alpha / size * square_sum[n, c, d1, ..., dk] ) ^ beta`
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LRN,
+    13,
+    OpSchema()
+        .Attr("size", "The number of channels to sum over", AttributeProto::INT)
+        .Attr("alpha", "Scaling parameter.", AttributeProto::FLOAT, 0.0001f)
+        .Attr("beta", "The exponent.", AttributeProto::FLOAT, 0.75f)
+        .Attr("bias", "", AttributeProto::FLOAT, 1.0f)
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non image case, the "
+            "dimensions are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the batch "
+            "size. Optionally, if dimension denotation is "
+            "in effect, the operation expects the input "
+            "data tensor to arrive with the dimension denotation "
+            "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "Y",
+            "Output tensor, which has the shape and type as input tensor",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output "
+            " types to float tensors.")
+        .SetDoc(LRN_ver13_doc)
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* TfIdfVectorizer_ver9_doc = R"DOC(
+This transform extracts n-grams from the input sequence and save them as a vector. Input can
+be either a 1-D or 2-D tensor. For 1-D input, output is the n-gram representation of that input.
+For 2-D input, the output is also a  2-D tensor whose i-th row is the n-gram representation of the i-th input row.
+More specifically, if input shape is [C], the corresponding output shape would be [max(ngram_indexes) + 1].
+If input shape is [N, C], this operator produces a [N, max(ngram_indexes) + 1]-tensor.
+
+In contrast to standard n-gram extraction, here, the indexes of extracting an n-gram from the original
+sequence are not necessarily consecutive numbers. The discontinuity between indexes are controlled by the number of skips.
+If the number of skips is 2, we should skip two tokens when scanning through the original sequence.
+Let's consider an example. Assume that input sequence is [94, 17, 36, 12, 28] and the number of skips is 2.
+The associated 2-grams are [94, 12] and [17, 28] respectively indexed by [0, 3] and [1, 4].
+If the number of skips becomes 0, the 2-grams generated are [94, 17], [17, 36], [36, 12], [12, 28]
+indexed by [0, 1], [1, 2], [2, 3], [3, 4], respectively.
+
+The output vector (denoted by Y) stores the count of each n-gram;
+Y[ngram_indexes[i]] indicates the times that the i-th n-gram is found. The attribute ngram_indexes is used to determine the mapping
+between index i and the corresponding n-gram's output coordinate. If pool_int64s is [94, 17, 17, 36], ngram_indexes is [1, 0],
+ngram_counts=[0, 0], then the Y[0] (first element in Y) and Y[1] (second element in Y) are the counts of [17, 36] and [94, 17],
+respectively. An n-gram which cannot be found in pool_strings/pool_int64s should be ignored and has no effect on the output.
+Note that we may consider all skips up to S when generating the n-grams.
+
+The examples used above are true if mode is "TF". If mode is "IDF", all the counts larger than 1 would be truncated to 1 and
+the i-th element in weights would be used to scale (by multiplication) the count of the i-th n-gram in pool. If mode is "TFIDF",
+this operator first computes the counts of all n-grams and then scale them by the associated values in the weights attribute.
+
+Only one of pool_strings and pool_int64s can be set. If pool_int64s is set, the input should be an integer tensor.
+If pool_strings is set, the input must be a string tensor.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    TfIdfVectorizer,
+    9,
+    OpSchema()
+        .Input(0, "X", "Input for n-gram extraction", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "Ngram results", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T", {types::String, types::Int32, types::Int64}, "Input is either string UTF-8 or int32/int64")
+        .TypeConstraint("T1", {types::Float}, "1-D tensor of floats")
+        .Attr(
+            "max_gram_length",
+            "Maximum n-gram length. If this value is 3, 3-grams will be used to generate the output.",
+            AttributeProto::INT)
+        .Attr(
+            "min_gram_length",
+            "Minimum n-gram length. If this value is 2 and max_gram_length is 3, output may contain counts of 2-grams and 3-grams.",
+            AttributeProto::INT)
+        .Attr(
+            "max_skip_count",
+            "Maximum number of items (integers/strings) to be skipped when constructing an n-gram from X. "
+            "If max_skip_count=1, min_gram_length=2, max_gram_length=3, this operator may generate 2-grams "
+            "with skip_count=0 and skip_count=1, and 3-grams with skip_count=0 and skip_count=1",
+            AttributeProto::INT)
+        .Attr(
+            "pool_strings",
+            "List of strings n-grams learned from the training set. Either this or pool_int64s attributes must be present but not both. "
+            "It's an 1-D tensor starting with the collections of all 1-grams and ending with the collections of n-grams. "
+            "The i-th element in pool stores the n-gram that should be mapped to coordinate ngram_indexes[i] in the output vector.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "pool_int64s",
+            "List of int64 n-grams learned from the training set. Either this or pool_strings attributes must be present but not both. "
+            "It's an 1-D tensor starting with the collections of all 1-grams and ending with the collections of n-grams. "
+            "The i-th element in pool stores the n-gram that should be mapped to coordinate ngram_indexes[i] in the output vector.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "ngram_counts",
+            "The starting indexes of 1-grams, 2-grams, and so on in pool. "
+            "It is useful when determining the boundary between two consecutive collections of n-grams. "
+            "For example, if ngram_counts is [0, 17, 36], the first index (zero-based) of 1-gram/2-gram/3-gram "
+            "in pool are 0/17/36. This format is essentially identical to CSR (or CSC) sparse matrix format, "
+            "and we choose to use this due to its popularity.",
+            AttributeProto::INTS)
+        .Attr(
+            "ngram_indexes",
+            "list of int64s (type: AttributeProto::INTS). This list is parallel to the specified 'pool_*' attribute. "
+            "The i-th element in ngram_indexes indicate the coordinate of the i-th n-gram in the output tensor.",
+            AttributeProto::INTS)
+        .Attr(
+            "weights",
+            "list of floats. This attribute stores the weight of each n-gram in pool. The i-th element in weights "
+            "is the weight of the i-th n-gram in pool. Its length equals to the size of ngram_indexes. "
+            "By default, weights is an all-one tensor.This attribute is used when mode is \"IDF\" or \"TFIDF\" "
+            "to scale the associated word counts.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "mode",
+            "The weighting criteria. It can be one of \"TF\" (term frequency), "
+            "\"IDF\" (inverse document frequency), and \"TFIDF\" (the combination of TF and IDF)",
+            AttributeProto::STRING)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto output_elem_type = ctx.getOutputType(0)->mutable_tensor_type();
+          output_elem_type->set_elem_type(TensorProto::FLOAT);
+
+          if (hasInputShape(ctx, 0)) {
+            std::vector<int64_t> ngram_indexes;
+            getRepeatedAttribute(ctx, "ngram_indexes", ngram_indexes);
+            if (ngram_indexes.empty() ||
+                !std::all_of(ngram_indexes.cbegin(), ngram_indexes.cend(), [](int64_t i) { return i >= 0; })) {
+              fail_shape_inference("ngram_indexes must be non-empty with no negative values");
+            }
+
+            auto greatest_hit = std::max_element(ngram_indexes.cbegin(), ngram_indexes.cend());
+            auto max_last_axis = *greatest_hit + 1;
+
+            TensorShapeProto output_shape;
+            auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            auto dim_size = input_shape.dim_size();
+            if (dim_size == 1) {
+              output_shape.add_dim()->set_dim_value(max_last_axis);
+            } else if (dim_size == 2) {
+              *output_shape.add_dim() = input_shape.dim(0);
+              output_shape.add_dim()->set_dim_value(max_last_axis);
+            } else {
+              fail_shape_inference("Input tensor must have rank 1 or 2");
+            }
+            updateOutputShape(ctx, 0, output_shape);
+          }
+        })
+        .SetDoc(TfIdfVectorizer_ver9_doc));
+
+static constexpr const char* mvn_ver13_doc = R"DOC(
+      A MeanVarianceNormalization Function: Perform mean variance normalization
+      on the input tensor X using formula: `(X-EX)/sqrt(E(X-EX)^2)`
+)DOC";
+
+static const std::vector<int64_t> mvn_default_axes = {0, 2, 3};
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MeanVarianceNormalization,
+    13,
+    OpSchema()
+        .SetDoc(mvn_ver13_doc)
+        .Input(0, "X", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "Y", "Output tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Attr(
+            "axes",
+            "A list of integers, along which to reduce. The default is to "
+            "calculate along axes [0,2,3] for calculating mean and variance "
+            "along each channel. Two variables with the same C-coordinate "
+            "are associated with the same mean and variance.",
+            AttributeProto::INTS,
+            mvn_default_axes)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to all numeric tensors.")
+        .FunctionBody(R"ONNX(
+        {
+          Exponent = Constant <value = float {2.0}>()
+          Epsilon = Constant <value = float {1e-9}>()
+          X_RM = ReduceMean <axes : ints = @axes> (X)
+          EX_squared = Pow (X_RM, Exponent)
+          X_squared = Pow (X, Exponent)
+          E_Xsquared = ReduceMean <axes : ints = @axes> (X_squared)
+          Variance = Sub (E_Xsquared, EX_squared)
+          STD = Sqrt (Variance)
+          X_variance = Sub (X, X_RM)
+          Processed_STD = Add (STD, Epsilon)
+          Y = Div (X_variance, Processed_STD)
+        }
+        )ONNX")
+        .FunctionBody(
+            R"ONNX(
+        {
+          Exponent = Constant <value = float {2.0}>()
+          Epsilon = Constant <value = float {1e-9}>()
+          axes = Constant <value_ints: ints = @axes>()
+          X_RM = ReduceMean (X, axes)
+          EX_squared = Pow (X_RM, Exponent)
+          X_squared = Pow (X, Exponent)
+          E_Xsquared = ReduceMean (X_squared, axes)
+          Variance = Sub (E_Xsquared, EX_squared)
+          STD = Sqrt (Variance)
+          X_variance = Sub (X, X_RM)
+          Processed_STD = Add (STD, Epsilon)
+          Y = Div (X_variance, Processed_STD)
+        }
+        )ONNX",
+            18));
+
+static void col2imShapeInference(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // All inputs shapes are required
+  if (!hasNInputShapes(ctx, 3)) {
+    return;
+  }
+
+  // We assume image_shape has correct spatial dimensions for next validations
+  // An alternative is get the the number of spatial dimensions as an input argument
+  Dim n_input_dims;
+  unifyInputDim(ctx, 1, 0, n_input_dims);
+
+  unifyInputDim(ctx, 2, 0, n_input_dims);
+  checkInputRank(ctx, 1, 1);
+  checkInputRank(ctx, 2, 1);
+  std::vector<int64_t> image_shape = {};
+  const TensorProto* image_shape_data = ctx.getInputData(1);
+  if (image_shape_data) {
+    image_shape = ParseData<int64_t>(image_shape_data);
+    unifyDim(n_input_dims, image_shape.size());
+  }
+
+  std::vector<int64_t> pads = {};
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() % 2) {
+      fail_shape_inference("Attribute pads must have an even size");
+    }
+    unifyDim(n_input_dims, pads.size() / 2);
+  }
+
+  std::vector<int64_t> dilations = {};
+  if (getRepeatedAttribute(ctx, "dilations", dilations)) {
+    unifyDim(n_input_dims, dilations.size());
+  }
+
+  std::vector<int64_t> strides = {};
+  if (getRepeatedAttribute(ctx, "strides", strides)) {
+    unifyDim(n_input_dims, strides.size());
+  }
+
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() != 3) {
+    fail_shape_inference("input must have rank 3.");
+  }
+
+  std::vector<int64_t> block_shape = {};
+  const TensorProto* block_shape_data = ctx.getInputData(2);
+  if (block_shape_data) {
+    block_shape = ParseData<int64_t>(block_shape_data);
+    unifyDim(n_input_dims, block_shape.size());
+  }
+  unifyInputDim(ctx, 2, 0, n_input_dims);
+
+  int block_shape_size = 0;
+  if (static_cast<int>(block_shape.size()) > 0) {
+    block_shape_size = 1;
+    for (const auto& dim : block_shape) {
+      block_shape_size *= dim;
+    }
+  }
+  // If we haven't inferred the number of image dimensions, we can't set inferred shape.
+  if (!n_input_dims.has_dim_value()) {
+    return;
+  }
+
+  // Final shape will be (N, C, dim_1, ..., dim_N)
+  auto* final_image_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  // Dimensions N and C are always present
+  Dim N, C;
+  if (ctx.getInputType(0)->tensor_type().shape().dim(0).has_dim_value()) {
+    N = input_shape.dim(0); // Otherwise, N is unknown.
+  }
+  *final_image_shape->add_dim() = N;
+
+  if (block_shape_size > 0) {
+    C = input_shape.dim(1) / block_shape_size; // Otherwise, C is unknown.
+  }
+  *final_image_shape->add_dim() = C;
+
+  // Image dimensions are dynamic
+  for (auto i = 0; i < n_input_dims.dim_value(); ++i) {
+    Dim image_dim_i;
+    if (!image_shape.empty()) {
+      image_dim_i.set_dim_value(image_shape[i]); // Otherwise, spatial dimensions are unknown
+    }
+    *final_image_shape->add_dim() = image_dim_i;
+  }
+}
+
+static constexpr const char* Col2Im_ver18_doc = R"DOC(
+The operator rearranges column blocks back into a multidimensional image
+
+Col2Im behaves similarly to PyTorch's fold https://pytorch.org/docs/stable/generated/torch.nn.Fold.html,
+but it only supports *batched* multi-dimensional image tensors.
+Another implementation in Python with N-dimension support can be found at https://github.com/f-dangel/unfoldNd/.
+
+NOTE:
+  Although specifying image_shape looks redundant because it could be calculated from
+  convolution formulas, it is required as input for more advanced scenarios as explained
+  at PyTorch's implementation (https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/Col2Im.cpp#L10)
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Col2Im,
+    18,
+    OpSchema()
+        .Attr(
+            "dilations",
+            "1-dimensional tensor with dilation value along each spatial axis of the image. "
+            "If not present, the dilation defaults to 1 along each spatial axis of the image.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "pads",
+            "1-dimensional tensor with padding value for the beginning and ending along each spatial axis, "
+            "it can take any value greater than or equal to 0. "
+            "The value represent the number of pixels added to the beginning "
+            "and end part of the corresponding axis. `pads` format should be as follow "
+            "[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin is the number of pixels "
+            "added at the beginning of axis `i` and xi_end is the number of pixels added at the end of axis `i`. "
+            "If not present, the padding defaults to 0 along start and end of each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "strides",
+            "1-dimensional tensor with stride value along each spatial axis. "
+            "If not present, the stride defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .SetDoc(Col2Im_ver18_doc)
+        .Input(
+            0,
+            "input",
+            "Input data tensor to be rearranged from column blocks back into an image."
+            " This is a 3-dimensional tensor containing [N, C * n-ary-product(block_shape), L],"
+            " where N is batch dimension, C is image channel dimension and L is number of blocks."
+            "The blocks are enumerated in increasing lexicographic-order of their indices."
+            "For example, with an image-size 10*20 and block-size 9*18, there would be 2*3 blocks,"
+            " enumerated in the order block(0, 0), block(0, 1), block(0, 2), block(1, 0), block(1, 1), block(1, 2).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "image_shape",
+            "The shape of the spatial dimensions of the image after rearranging the column blocks."
+            "This is a 1-dimensional tensor with size of at least 2, containing the value [H_img, W_img] "
+            " for a 2-D image or [dim_i1, dim_i2, ..., dim_iN] for a N-D image.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "block_shape",
+            "The shape of the block to apply on the input."
+            "This is a 1-dimensional tensor of size of at least 2, containing the value [H_block, W_block] "
+            " for a 2-D image or [dim_b1, dim_b2, ..., dim_bN] for a N-D block."
+            "This is the block-shape before dilation is applied to it.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor produced by rearranging blocks into an image.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir4(),
+            "Constrain input and output types to all numeric tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { col2imShapeInference(ctx); }));
+
+static constexpr const char* LayerNormalization_ver17_doc = R"DOC(
+      This is layer normalization defined in ONNX as function.
+      The overall computation can be split into two stages.
+      The first stage is standardization, which makes the
+      normalized elements have zero mean and unit variances.
+      The computation required by standardization can be
+      described by the following equations.
+      ```
+      Mean = ReduceMean<axes=normalized_axes>(X)
+      D = Sub(X, Mean)
+      DD = Mul(D, D)
+      Var = ReduceMean<axes=normalized_axes>(DD)
+      VarEps = Add(Var, epsilon)
+      StdDev = Sqrt(VarEps)
+      InvStdDev = Reciprocal(StdDev)
+      Normalized = Mul(D, InvStdDev)
+      ```
+      where `normalized_axes` is `[axis, ..., rank of X - 1]`.
+      The variables `Var` and `StdDev` stand for variance and
+      standard deviation, respectively. The second output is
+      `Mean` and the last one is `InvStdDev`.
+      Depending on `stash_type` attribute, the actual computation
+      must happen in different floating-point precision.
+      For example, if `stash_type` is 1, this operator casts
+      all input variables to 32-bit float, perform the computation, and
+      finally cast `Normalized` back to the original type of `X`.
+      The second stage then scales and shifts the outcome of the
+      first stage using
+      ```
+      NormalizedScaled = Mul(Normalized, Scale)
+      Y = Add(NormalizedScaled, B)
+      ```
+      The second stage doesn't depends on `stash_type`.
+      All equations are in [this syntax](https://github.com/onnx/onnx/blob/main/docs/Syntax.md).
+      The same variable (i.e., input, output, and attribute) uses
+      the same name in the equations above and this operator's definition.
+      Let `d[i]` indicate the i-th dimension of `X`.
+      If `X`'s shape is `[d[0], ..., d[axis-1], d[axis], ..., d[rank-1]]`,
+      the shape of `Mean` and `InvStdDev` is `[d[0], ..., d[axis-1], 1, ..., 1]`.
+      `Y` and `X` have the same shape. This operator supports unidirectional broadcasting
+      (tensors `Scale` and `B` should be unidirectional broadcastable to tensor `X`);
+      for more details please check [the doc](Broadcasting.md).
+)DOC";
+
+static bool BuildContextDependentFunctionBodyLayerNormalization(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto,
+    int sinceVersion) {
+  ONNX_ASSERT(sinceVersion == 17 || sinceVersion == 18)
+  // LayerNormalization <axis, epsilon, stash_type> (X, Scale, B) => (Y, Mean?, InvStdDev?)
+  const auto* const tp = ctx.getInputType(0);
+  if ((tp == nullptr) || (!tp->has_tensor_type()))
+    return false;
+  int64_t T = tp->tensor_type().elem_type();
+
+  const auto* const type_attr = ctx.getAttribute("stash_type");
+  int64_t U =
+      (type_attr != nullptr) ? type_attr->i() : static_cast<int64_t>(ONNX_NAMESPACE::TensorProto_DataType_FLOAT);
+  if ((U != ONNX_NAMESPACE::TensorProto_DataType_FLOAT) && (U != ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16))
+    return false; // Error
+
+  const auto* const axis_attr = ctx.getAttribute("axis");
+  int64_t axis = (axis_attr != nullptr) ? axis_attr->i() : -1;
+  const auto* const epsilon_attr = ctx.getAttribute("epsilon");
+  float epsilon = (epsilon_attr != nullptr) ? epsilon_attr->f() : 1e-5f;
+
+  auto mktensor = [](int64_t val) -> ONNX_NAMESPACE::TensorProto {
+    auto tp = ONNX_NAMESPACE::ToTensor(std::vector<int64_t>{val});
+    tp.add_dims(1);
+    return tp;
+  };
+  // The treatment of "axis" is different in "LayerNormalization" and in Reduction operations.
+  // This complicates the function definition, requiring reshaping inputs/outputs.
+  // Input X shape: [d[0], ..., d[axis-1], d[axis], ..., d[rank-1]]
+  // This is treated as a 2D shape [d[0] * ... * d[axis-1], d[axis] * ... * d[rank-1]]
+  // Normalization is applied to the second dimension.
+  // Output Y has same shape as X
+  // Outputs Mean and InvStdDev have shape: [d[0], ..., d[axis-1], 1, ..., 1]
+  FunctionBuilder builder(functionProto);
+  builder.Const("FloatEpsilon", ToTensor<float>(epsilon))
+      .Add("Epsilon = Cast (FloatEpsilon)", "to", U)
+      .Add("XShape = Shape (X)") // shape of input tensor: 1D tensor
+      .Add("Rank = Size (XShape)") // rank of input tensor: scalar
+      .Add("Zero1D = Constant()", "value", mktensor(0)) // [0] : 1D tensor
+      .Add("Axis1D = Constant()", "value", mktensor(axis)) // [axis] : 1D tensor
+      .Add("PrefixShape = Slice (XShape, Zero1D, Axis1D)") // [d[0], ..., d[axis-1]]
+      .Add(
+          axis >= 0 // number of axes that are reduced =
+              ? "NumReducedAxes = Sub (Rank, Axis1D)" // [rank - axis]: 1D tensor
+              : "NumReducedAxes = Neg (Axis1D)") // [-axis] : 1D tensor
+      .Add(
+          "SuffixShape = ConstantOfShape (NumReducedAxes)",
+          "value",
+          mktensor(1)) // [1, ..., 1] for reduced axes
+      .Add("ReducedShape = Concat <axis = 0> (PrefixShape, SuffixShape)") // [d[0], ..., d[axis-1], 1, ..., 1]
+      .Add("X2D = Flatten (X)", "axis", axis)
+      .Add("XU = Cast (X2D)", "to", U);
+  if (sinceVersion == 17) {
+    builder.Add("Mean2D = ReduceMean <axes = [1]> (XU)")
+        .Add("Square = Mul (XU, XU)")
+        .Add("MeanOfSquare = ReduceMean <axes = [1]> (Square)");
+  } else if (sinceVersion == 18) {
+    builder.Add("Axes_1 = Constant()", "value", mktensor(1))
+        .Add("Mean2D = ReduceMean (XU, Axes_1)")
+        .Add("Square = Mul (XU, XU)")
+        .Add("MeanOfSquare = ReduceMean (Square, Axes_1)");
+  }
+  builder.Add("SquareOfMean = Mul (Mean2D, Mean2D)")
+      .Add("Var = Sub (MeanOfSquare, SquareOfMean)")
+      .Add("VarPlusEpsilon = Add (Var, Epsilon)")
+      .Add("StdDev = Sqrt (VarPlusEpsilon)")
+      .Add("Deviation = Sub (XU, Mean2D)")
+      .Add("Normalized = Div (Deviation, StdDev)")
+      .Add("NormalizedT = Cast (Normalized)", "to", T)
+      .Add("Scale2D = Flatten <axis = 0> (Scale)")
+      .Add("Scaled = Mul (NormalizedT, Scale2D)");
+  if (ctx.hasInput(2)) {
+    builder.Add("B2D = Flatten <axis=0> (B)");
+    builder.Add("Biased = Add (Scaled, B2D)");
+  } else {
+    builder.Add("Biased = Identity (Scaled)");
+  }
+  builder.Add("Y = Reshape (Biased, XShape)");
+  builder.Add("InvStdDev2D = Reciprocal (StdDev)");
+  if (ctx.hasOutput(1))
+    builder.Add("Mean = Reshape (Mean2D, ReducedShape)");
+  if (ctx.hasOutput(2))
+    builder.Add("InvStdDev = Reshape (InvStdDev2D, ReducedShape)");
+
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+static bool BuildContextDependentFunctionBodyLayerNormalizationVer17(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  return BuildContextDependentFunctionBodyLayerNormalization(ctx, schema, functionProto, 17);
+}
+
+static bool BuildContextDependentFunctionBodyLayerNormalizationVer18(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  return BuildContextDependentFunctionBodyLayerNormalization(ctx, schema, functionProto, 18);
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LayerNormalization,
+    17,
+    OpSchema()
+        .SetDoc(LayerNormalization_ver17_doc)
+        .Attr(
+            "axis",
+            "The first normalization dimension. If rank(X) is r, axis' allowed range is [-r, r). "
+            "Negative value means counting dimensions from the back.",
+            AttributeProto::INT,
+            static_cast<int64_t>(-1))
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Attr(
+            "stash_type",
+            "Type of Mean and InvStdDev. This also specifies stage one's computation precision.",
+            AttributeProto::INT,
+            static_cast<int64_t>(ONNX_NAMESPACE::TensorProto_DataType_FLOAT))
+        .AllowUncheckedAttributes()
+        .Input(0, "X", "Tensor to be normalized.", "T")
+        .Input(1, "Scale", "Scale tensor.", "T")
+        .Input(2, "B", "Bias tensor.", "T", OpSchema::Optional)
+        .Output(0, "Y", "Normalized tensor.", "T")
+        .Output(1, "Mean", "Saved mean used during training to speed up gradient computation", "U", OpSchema::Optional)
+        .Output(
+            2,
+            "InvStdDev",
+            "Saved inverse standard deviation used during training to speed up gradient computation.",
+            "U",
+            OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input types and output Y type to float tensors.")
+        .TypeConstraint("U", {types::Float, types::BFloat16}, "Type of Mean and InvStdDev tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBodyLayerNormalizationVer17, 17)
+        .SetContextDependentFunctionBodyBuilder(BuildContextDependentFunctionBodyLayerNormalizationVer18, 18)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateShapeAndTypeFromFirstInput(ctx);
+          auto stash_type = static_cast<int64_t>(ONNX_NAMESPACE::TensorProto_DataType_FLOAT);
+          auto stash_type_proto = ctx.getAttribute("stash_type");
+          if (stash_type_proto) {
+            stash_type = stash_type_proto->i();
+          }
+          if (ctx.getNumOutputs() > 1) {
+            auto output_type = ctx.getOutputType(1);
+            output_type->mutable_tensor_type()->set_elem_type(static_cast<int32_t>(stash_type));
+          }
+          if (ctx.getNumOutputs() > 2) {
+            auto output_type = ctx.getOutputType(2);
+            output_type->mutable_tensor_type()->set_elem_type(static_cast<int32_t>(stash_type));
+          }
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, 0);
+          int64_t input_ndim = input_shape.dim_size();
+          int64_t axis = -1;
+          auto axis_proto = ctx.getAttribute("axis");
+          if (axis_proto) {
+            axis = axis_proto->i();
+          }
+          if (axis < 0) {
+            // Convert negative axis value to equivalent
+            // positive value.
+            axis += input_ndim;
+          }
+          if (axis < 0) {
+            fail_shape_inference(
+                "Unexpected axis value (",
+                axis,
+                ") rank of first input is ",
+                input_ndim,
+                " in ",
+                ctx.getDisplayName(),
+                ".");
+          }
+          if (ctx.getNumOutputs() > 1) {
+            auto mean_shape = ctx.getOutputType(1)->mutable_tensor_type()->mutable_shape();
+            mean_shape->CopyFrom(input_shape);
+            for (int d = static_cast<int>(axis); d < input_ndim; ++d)
+              mean_shape->mutable_dim(d)->set_dim_value(1);
+          }
+
+          if (ctx.getNumOutputs() > 2) {
+            auto inv_std_dev_shape = ctx.getOutputType(2)->mutable_tensor_type()->mutable_shape();
+            inv_std_dev_shape->CopyFrom(input_shape);
+            for (int d = static_cast<int>(axis); d < input_ndim; ++d)
+              inv_std_dev_shape->mutable_dim(d)->set_dim_value(1);
+          }
+        }));
+
+static constexpr const char* GroupNormalization_ver21_doc = R"DOC(
+A GroupNormalization function. Carries out group normalization as described in
+the paper https://arxiv.org/abs/1803.08494
+
+This operator transforms input according to
+```
+y = scale * (x - mean) / sqrt(variance + epsilon) + bias,
+```
+where the mean and variance are computed per instance per group of channels, and
+`scale` and `bias` should be specified for each channel. The number of
+groups `num_groups` should be divisible by the number of channels so that there are
+an equal number of channels per group.
+
+The overall computation has two stages: the first stage normalizes the elements to
+have zero mean and unit variance for each instance in each group, and the second
+stage scales and shifts the results of the first stage. The floating-point precision
+used in the first stage is determined by the `stash_type` attribute. For example,
+if `stash_type` is 1, the operator casts all input variables to 32-bit float,
+performs the computation, and finally casts the normalized results back to the
+original type of `X`. The second stage does not depend on `stash_type`.
+
+When the number of groups is the same as the number of channels, this operator is
+equivalent to InstanceNormalization. When there is only one group, this operator
+is equivalent to LayerNormalization.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GroupNormalization,
+    21,
+    OpSchema()
+        .SetDoc(GroupNormalization_ver21_doc)
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Attr(
+            "num_groups",
+            "The number of groups of channels. It should be a divisor of the number of channels `C`.",
+            AttributeProto::INT,
+            true)
+        .Attr(
+            "stash_type",
+            "The floating-point precision used in stage one of the computation.",
+            AttributeProto::INT,
+            static_cast<int64_t>(ONNX_NAMESPACE::TensorProto_DataType_FLOAT))
+        .Input(
+            0,
+            "X",
+            "Input data tensor. Dimensions for image cases are `(N x C x H x W)`, where `N` is the batch size, "
+            "`C` is the number of channels, and `H` and `W` are the height and width of the data. Statistics are "
+            "computed for every group of channels over `C`, `H`, and `W`. For non-image cases, the dimensions are "
+            "in the form of `(N x C x D1 x D2 ... Dn)`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(1, "scale", "Scale tensor of shape `(C)`.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(2, "bias", "Bias tensor of shape `(C)`.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "Y",
+            "The output tensor of the same shape as `X`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) {
+              // GroupNormalization <epsilon, num_groups> (X, scale, bias) => (Y)
+              auto tp = ctx.getInputType(0);
+              if ((tp == nullptr) || (!tp->has_tensor_type()))
+                return false;
+              int64_t in_type = tp->tensor_type().elem_type();
+
+              auto epsilon_attr = ctx.getAttribute("epsilon");
+              float epsilon = (epsilon_attr != nullptr) ? epsilon_attr->f() : 1e-5f;
+              auto num_groups_attr = ctx.getAttribute("num_groups");
+              if (num_groups_attr == nullptr)
+                return false;
+              int64_t num_groups = num_groups_attr->i();
+
+              auto stash_type_attr = ctx.getAttribute("stash_type");
+              int64_t stash_type = (stash_type_attr != nullptr)
+                  ? stash_type_attr->i()
+                  : static_cast<int64_t>(ONNX_NAMESPACE::TensorProto_DataType_FLOAT);
+              if ((stash_type != ONNX_NAMESPACE::TensorProto_DataType_FLOAT) &&
+                  (stash_type != ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16) &&
+                  (stash_type != ONNX_NAMESPACE::TensorProto_DataType_FLOAT16) &&
+                  (stash_type != ONNX_NAMESPACE::TensorProto_DataType_DOUBLE))
+                return false; // Error
+
+              FunctionBuilder builder(functionProto);
+              builder.Const1D("FloatEpsilon", epsilon)
+                  .Add("Epsilon = Cast (FloatEpsilon)", "to", stash_type)
+                  .Add("XU = Cast (X)", "to", stash_type)
+                  .Add("XShape = Shape (XU)") // shape of input tensor: 1D tensor
+                  .Add("C = Shape <start = 1, end = 2> (X)")
+                  .Const1D("NumGroups", num_groups)
+                  .Add("GroupSize = Div (C, NumGroups)")
+                  .Add("N = Shape <start = 0, end = 1> (X)") // batch size
+                  .Add("InstanceShape = Shape <start = 2> (X)") // data instance shape
+
+                  // NewShape = [N, num_groups, group_size, H, W, (...)]
+                  .Add("NewShape = Concat <axis = 0> (N, NumGroups, GroupSize, InstanceShape)")
+                  .Add("XReshaped = Reshape (XU, NewShape)")
+
+                  // Flatten into 3D tensor: [N, num_groups, group_size x H x W (x ...)]
+                  .Add("Shape3D = Constant <value_ints = [0, 0, -1]> ()")
+                  .Add("X3D = Reshape (XReshaped, Shape3D)")
+
+                  // Calculate statistics
+                  .Const1D("Axes2", static_cast<int64_t>(2))
+                  .Add("Mean = ReduceMean (X3D, Axes2)")
+                  .Add("Square = Mul (X3D, X3D)")
+                  .Add("MeanOfSquare = ReduceMean (Square, Axes2)")
+                  .Add("SquareOfMean = Mul (Mean, Mean)")
+                  .Add("Var = Sub (MeanOfSquare, SquareOfMean)")
+                  .Add("VarPlusEpsilon = Add (Var, Epsilon)")
+                  .Add("StdDev = Sqrt (VarPlusEpsilon)")
+                  .Add("Deviation = Sub (X3D, Mean)")
+                  .Add("NormalizedU = Div (Deviation, StdDev)")
+
+                  // Reshape to [N, C, H x W (x ...)] and cast to original type
+                  .Add("NormalizedOriginalShape = Reshape (NormalizedU, XShape)")
+                  .Add("NormalizedNC = Reshape (NormalizedOriginalShape, Shape3D)")
+                  .Add("NormalizedT = Cast (NormalizedNC)", "to", in_type)
+
+                  // Reshape scale and bias to [1, C, 1] for broadcasting
+                  .Add("ScaleShape = Constant <value_ints = [1, -1, 1]> ()")
+                  .Add("ScaleT = Cast (scale)", "to", in_type)
+                  .Add("BiasT = Cast (bias)", "to", in_type)
+                  .Add("ScaleReshaped = Reshape (ScaleT, ScaleShape)")
+                  .Add("BiasReshaped = Reshape (BiasT, ScaleShape)")
+
+                  // Calculate scaled and biased output
+                  .Add("Scaled = Mul (ScaleReshaped, NormalizedT)")
+                  .Add("Biased = Add (Scaled, BiasReshaped)")
+                  .Add("Y = Reshape (Biased, XShape)");
+
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+
+static constexpr const char* RMSNormalization_ver23_doc = R"DOC(
+      This is RMS normalization defined in ONNX as function as described in the paper https://arxiv.org/pdf/1910.07467.
+      The overall computation can be split into two stages. The root mean squared norm is taken over the last D dimensions,
+      where D is the dimension of normalized_shape. For example, if normalized_shape is (3, 5) (a 2-dimensional shape),
+      the rms norm is computed over the last 2 dimensions of the input. The computation required by standardization can be
+      described by the following equations.
+      ```
+      XSquared = Mul(X, X)
+      XSquaredMean = ReduceMean<axes=normalized_axes>(XSquared)
+      MeanSquareEpsilon = Add(XSquaredMean, epsilon)
+      RMS = Sqrt(MeanSquareEpsilon)
+      Normalized = Div(X, RMS)
+      ```
+      where `normalized_axes` is `[axis, ..., rank of X - 1]`. The variables `RMS` stand for root mean square,
+      Depending on `stash_type` attribute, the actual computation
+      must happen in different floating-point precision.
+      For example, if `stash_type` is 1, this operator casts
+      all input variables to 32-bit float, perform the computation, and
+      finally cast `Normalized` back to the original type of `X`.
+      The second stage then scales the outcome of the first stage using:
+      ```
+      Y= Mul(Normalized, Scale)
+      ```
+      Let `d[i]` indicate the i-th dimension of `X`.
+      If `X`'s shape is `[d[0], ..., d[axis-1], d[axis], ..., d[rank-1]]`,
+      the shape of `RMS` is `[d[0], ..., d[axis-1], 1, ..., 1]`.
+      `Y` and `X` have the same shape. This operator supports unidirectional broadcasting
+      (`Scale` should be unidirectional broadcastable to tensor `X`);
+      for more details please check [the doc](Broadcasting.md).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RMSNormalization,
+    23,
+    OpSchema()
+        .SetDoc(RMSNormalization_ver23_doc)
+        .Attr(
+            "axis",
+            "The first normalization dimension. If rank(X) is r, axis' allowed range is [-r, r). "
+            "Negative value means counting dimensions from the back.",
+            AttributeProto::INT,
+            static_cast<int64_t>(-1))
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Attr(
+            "stash_type",
+            "The floating-point precision used in stage one of the computation.",
+            AttributeProto::INT,
+            static_cast<int64_t>(ONNX_NAMESPACE::TensorProto_DataType_FLOAT))
+        .Input(
+            0,
+            "X",
+            "The input tensor to be normalized. "
+            "In general, the shape is (D1, D2, ... , Dn) for n-dimensional data, where "
+            "the root mean squared norm is taken over the last D dimensions, D is determined by the axis attribute.",
+            "T")
+        .Input(1, "scale", "Scale tensor. Scale tensor shape should be broadcastable to the normalized shape.", "V")
+        .Output(0, "Y", "Output data tensor. Same shape as X", "V")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input X type to float tensors.")
+        .TypeConstraint(
+            "V",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain output Y and scale type to float tensors.")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          propagateShapeAndTypeFromFirstInput(ctx);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          int64_t input_ndim = input_shape.dim_size();
+          int64_t axis = -1;
+          auto axis_proto = ctx.getAttribute("axis");
+          if (axis_proto) {
+            axis = axis_proto->i();
+          }
+          if (axis < 0) {
+            // Convert negative axis value to equivalent
+            // positive value.
+            axis += input_ndim;
+          }
+          if (axis < 0) {
+            fail_shape_inference(
+                "Unexpected axis value (",
+                axis,
+                ") rank of first input is ",
+                input_ndim,
+                " in ",
+                ctx.getDisplayName(),
+                ".");
+          }
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder([](const FunctionBodyBuildContext& ctx,
+                                                   const OpSchema& schema,
+                                                   FunctionProto& functionProto) {
+          // RMSNormalization <axis, epsilon, stash_type> (X, Scale) => (Y)
+          auto tp = ctx.getInputType(0);
+          if ((tp == nullptr) || (!tp->has_tensor_type()))
+            return false;
+          int64_t T = tp->tensor_type().elem_type();
+
+          auto type_attr = ctx.getAttribute("stash_type");
+          int64_t U = (type_attr != nullptr) ? type_attr->i()
+                                             : static_cast<int64_t>(ONNX_NAMESPACE::TensorProto_DataType_FLOAT);
+          if ((U != ONNX_NAMESPACE::TensorProto_DataType_FLOAT) &&
+              (U != ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16) &&
+              (U != ONNX_NAMESPACE::TensorProto_DataType_FLOAT16) && (U != ONNX_NAMESPACE::TensorProto_DataType_DOUBLE))
+            return false; // Error
+
+          auto axis_attr = ctx.getAttribute("axis");
+          int64_t axis = (axis_attr != nullptr) ? axis_attr->i() : -1;
+          auto epsilon_attr = ctx.getAttribute("epsilon");
+          float epsilon = (epsilon_attr != nullptr) ? epsilon_attr->f() : 1e-5f;
+
+          FunctionBuilder builder(functionProto);
+          builder.Const("FloatEpsilon", ToTensor<float>(epsilon))
+              .Add("Epsilon = Cast (FloatEpsilon)", "to", U)
+              .Add("XShape = Shape (X)") // shape of input tensor: 1D tensor
+              .Add("Rank = Size (XShape)") // rank of input tensor: scalar
+              .Const("Axis", axis) // axis : scalar
+              .Add(
+                  axis >= 0 // number of axes that are reduced =
+                      ? "PosAxis = Identity (Axis)" // axis: scalar
+                      : "PosAxis = Add (Rank, Axis)") // rank + axis : scalar
+              .Const("One", static_cast<int64_t>(1))
+              .Add("ReduceAxes = Range(PosAxis, Rank, One)")
+              .Add("XU = Cast (X)", "to", U);
+          builder.Add("XSquared = Mul (XU, XU)")
+              .Add("XSquaredMean = ReduceMean (XSquared, ReduceAxes)")
+              .Add("MeanSquareEpsilon = Add (XSquaredMean, Epsilon)")
+              .Add("RMS = Sqrt (MeanSquareEpsilon)")
+              .Add("Normalized = Div (XU, RMS)")
+              .Add("NormalizedT = Cast (Normalized)", "to", T);
+          builder.Add("Y = Mul (NormalizedT, scale)");
+
+          schema.BuildFunction(functionProto);
+          return true;
+        }));
+
+static constexpr const char* RotaryEmbedding_ver23_doc = R"DOC(
+RotaryEmbedding is the implementation of rotary positional embeddings (RoPE) based on the paper https://arxiv.org/pdf/2104.09864.
+The key advantage of RoPE is that it allows the model to understand both the absolute position of a token and the relative distances
+between tokens. This is achieved through a rotational mechanism where the extent of rotation is computed based on the token's absolute position (position_ids).
+
+The rotational mechanism is defined by sine and cosine functions that are used to represent the rotation angles.
+For each token in the sequence, its positional embedding is computed by rotating its embedding vector. This is done by splitting the
+embedding vector either into two halves or interleaving every alternate token and applying the rotation matrix to each half of the embedding vector.
+The rotation matrix is parameterized by the token's position in the sequence. The rotated halves of the embedding vector are concatenated
+to form the final positional embedding for each token. The rotated positional embeddings are used in the self-attention mechanism.
+The rotation ensures that the model captures both absolute and relative positional information.
+
+Rotary embeddings are defined using the following algorithm:
+
+```python
+def rotary_embedding(
+    input: np.ndarray,
+    cos_cache: np.ndarray,
+    sin_cache: np.ndarray,
+    position_ids: np.ndarray | None = None,
+    interleaved=None,
+    rotary_embedding_dim=None,
+    num_heads=None,
+) -> np.ndarray:
+    original_input_shape = input.shape
+    # First ensure input to be processed has shape [batch_size, seq_len, num_heads, head_size]
+    if len(input.shape) == 4:
+        input = np.transpose(input, (0, 2, 1, 3))
+    batch_size = input.shape[0]
+    sequence_length = input.shape[1]
+    if len(input.shape) == 3:
+        hidden_size = input.shape[2]
+        assert num_heads != 0
+        head_size = int(hidden_size / num_heads)
+        new_shape = [batch_size, sequence_length, num_heads, head_size]
+        input = np.reshape(input, new_shape)
+    assert len(input.shape) == 4
+    head_size = input.shape[3]
+
+    # Fully or partially perform rotation on input based on rotary_embedding_dim attribute
+    if rotary_embedding_dim is None or rotary_embedding_dim == 0:
+        # If rotary_embedding_dim not provided, perform full rotation by using head_size
+        rotary_embedding_dim = head_size
+    x_rotate = input[:, :, :, :rotary_embedding_dim]
+    x_not_rotate = input[:, :, :, rotary_embedding_dim:]
+    rotary_embedding_dim_half = int(rotary_embedding_dim / 2)
+
+    # Retrieve sin and cos caches using position ids
+    if position_ids is not None:
+        cos_cache = cos_cache[
+            position_ids
+        ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+        sin_cache = sin_cache[
+            position_ids
+        ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+
+    # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+    if cos_cache.shape[-1] != rotary_embedding_dim_half:
+        raise ValueError(
+            f"Last dimension of cos cache ({cos_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+        )
+    if sin_cache.shape[-1] != rotary_embedding_dim_half:
+        raise ValueError(
+            f"Last dimension of sin cache ({sin_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+        )
+
+    cos_cache = np.expand_dims(
+        cos_cache, axis=2
+    )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
+    sin_cache = np.expand_dims(
+        sin_cache, axis=2
+    )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
+
+    # Either divide the input in halves or interleave (based on interleaved attribute)
+    if interleaved:
+        x1 = x_rotate[:, :, :, 0::2]
+        x2 = x_rotate[:, :, :, 1::2]
+    else:
+        x1, x2 = np.split(x_rotate, 2, axis=-1)
+
+    # Calculate real and imaginary values
+    real = (cos_cache * x1) - (sin_cache * x2)
+    imag = (sin_cache * x1) + (cos_cache * x2)
+
+    # Inserted rotated embeddings back to the original input
+    if interleaved:
+        # x_rotate[:, :, :, 0::2] = real
+        # x_rotate[:, :, :, 1::2] = imag
+        real = np.expand_dims(real, axis=-1)
+        imag = np.expand_dims(imag, axis=-1)
+        x_rotate_concat = np.concatenate((real, imag), axis=-1)
+        x_rotate = np.reshape(x_rotate_concat, x_rotate.shape)
+    else:
+        x_rotate = np.concatenate((real, imag), axis=-1)
+    output = np.concatenate((x_rotate, x_not_rotate), axis=-1)
+    if len(original_input_shape) == 3:
+        output = np.reshape(output, original_input_shape)
+    else:
+        output = np.transpose(output, (0, 2, 1, 3))
+    return output
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RotaryEmbedding,
+    23,
+    OpSchema()
+        .SetDoc(RotaryEmbedding_ver23_doc)
+        .Attr(
+            "interleaved",
+            "Rotate using interleaved pattern. Default value is 0 (False).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "rotary_embedding_dim",
+            "Rotary embedding dimension used to apply partial rotary embeddings.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "num_heads",
+            "Number of attention heads. Must be provided when input is a 3D tensor. ",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(
+            0,
+            "X",
+            "The input tensor representing the token embeddings. "
+            "4D tensor with shape `(batch_size, num_heads, sequence_length, head_size)` or 3D tensor with shape `(batch_size, sequence_length, hidden_size)`. "
+            "For cases with a 4D input tensor, `head_size` has to be even. For cases with a 3D input tensor, `num_heads` attribute must be provided and "
+            "`hidden_size` must be an even multiple of `num_heads` where `hidden_size = num_heads * head_size`",
+            "T")
+        .Input(
+            1,
+            "cos_cache",
+            "The cosine values for the rotation. "
+            "2D tensor with shape `(max_position_id_plus_1, head_size / 2)` for full rotation or `(max_position_id_plus_1, rotary_embedding_dim / 2)` "
+            "for partial rotation when `position_ids` are provided. 3D tensor with shape `(batch_size, sequence_length, head_size / 2)` "
+            "for full rotation or `(batch_size, sequence_length, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are not provided. "
+            "`max_position_id_plus_1` is a parameter to the model.",
+            "T")
+        .Input(
+            2,
+            "sin_cache",
+            "The sine values for the rotation. "
+            "2D tensor with shape `(max_position_id_plus_1, head_size / 2)` for full rotation or `(max_position_id_plus_1, rotary_embedding_dim / 2)` "
+            "for partial rotation when `position_ids` are provided. 3D tensor with shape `(batch_size, sequence_length, head_size / 2)` "
+            "for full rotation or `(batch_size, sequence_length, rotary_embedding_dim / 2)` for partial rotation when `position_ids` are not provided. "
+            "`max_position_id_plus_1` is a parameter to the model.",
+            "T")
+        .Input(
+            3,
+            "position_ids",
+            "The position indices for the tokens. 2D tensor with shape `(batch_size, sequence_length)`",
+            "M",
+            OpSchema::Optional)
+        .Output(0, "Y", "Tensor with same shape as input.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Float16, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint("M", {types::Int64}, "Constrain input and output types to integer tensors.")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+
+          // we need at least one input to have a shape for this inference.
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+          if ((input_shape.dim_size() < 3) || (input_shape.dim_size() > 4)) {
+            fail_shape_inference("Input tensor must have at least 3 and at most 4 dimensions");
+          }
+
+          auto num_heads_attr = ctx.getAttribute("num_heads");
+          if ((input_shape.dim_size() == 3) && (num_heads_attr == nullptr)) {
+            fail_shape_inference("Input shape is 3D, num_heads attribute must be provided");
+          }
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder([](const FunctionBodyBuildContext& ctx,
+                                                   const OpSchema& schema,
+                                                   FunctionProto& functionProto) {
+          // RotaryEmbedding <scale, interleaved, rotary_embedding_dim, num_heads> (X, position_ids, cos_cache,
+          // sin_cache) => Y
+
+          int64_t int_type = ONNX_NAMESPACE::TensorProto_DataType_INT64;
+          auto interleaved_attr = ctx.getAttribute("interleaved");
+          int64_t interleaved = (interleaved_attr != nullptr) ? interleaved_attr->i() : 0;
+          auto rotary_embedding_dim_attr = ctx.getAttribute("rotary_embedding_dim");
+          int64_t rotary_embedding_dim = (rotary_embedding_dim_attr != nullptr) ? rotary_embedding_dim_attr->i() : 0;
+          auto num_heads_attr = ctx.getAttribute("num_heads");
+          int64_t num_heads = (num_heads_attr != nullptr) ? num_heads_attr->i() : 0;
+
+          // Ensure that num_heads does not control reshaping of input tensor
+          // when input tensor is 4D
+          int64_t is_input_4d = 1;
+          auto x_tp = ctx.getInputType(0);
+          if ((x_tp == nullptr) || (!x_tp->has_tensor_type()))
+            return false;
+          if (!(x_tp->tensor_type().has_shape())) {
+            return false;
+          }
+          if (x_tp->tensor_type().shape().dim_size() == 4) {
+            is_input_4d = 1;
+          } else if (x_tp->tensor_type().shape().dim_size() == 3) {
+            is_input_4d = 0;
+          } else {
+            return false;
+          }
+
+          FunctionBuilder builder(functionProto);
+          // Set input tensor to the correct shape if input shape is 3D
+          // NewShape = [batch_size, sequence_length, num_heads, head_size]
+
+          // Reshape tensor to 4D if input is 3D
+          builder.Const1D("Zero1D", static_cast<int64_t>(0))
+              .Const1D("NumHeads", num_heads) // num_heads
+              .Const1D("NegOne", static_cast<int64_t>(-1)); // head_size, inferred from other dimensions
+
+          if (is_input_4d == 0) {
+            builder.Add("NewShape = Concat <axis = 0> (Zero1D, Zero1D, NumHeads, NegOne)")
+                .Add("XIn = Reshape (X, NewShape)"); // new shape of input tensor: 4D tensor
+          } else {
+            builder.Add("XIn = Transpose <perm = [0, 2, 1, 3]> (X)");
+          }
+
+          // Rotary embedding dimension is the value along which the input is to be split
+          // There are two cases for the rotary embedding dimension:
+          // 1. Complete rotation: rotary embedding dimension defaults to head_size, rotary_embedding_dim = cos.shape[3]
+          // * 2 or head_size
+          // 2. Partial rotation: rotary embedding dimension is provided, rotary_embedding_dim = rotary_embedding_dim
+
+          builder.Add("HeadSize = Shape <start = 3, end = 4> (XIn)");
+          if (rotary_embedding_dim > 0) {
+            builder.Const1D("RotaryEmbedDim", rotary_embedding_dim);
+          } else {
+            builder.Add("RotaryEmbedDim = Identity(HeadSize)");
+          }
+          builder.Const1D("Two1D", static_cast<int64_t>(2))
+              .Add("NoRotateLength = Sub(HeadSize, RotaryEmbedDim)")
+              .Add("RotateSplitLengths = Concat <axis = 0> (RotaryEmbedDim, NoRotateLength)");
+          // shape of input to rotate = input[:,:,:,:rotary_embedding_dim]
+          // shape of input not to rotate = input[:,:,:,rotary_embedding_dim:]
+          builder.Add("XToRotate, XNoRotate = Split <axis = -1> (XIn, RotateSplitLengths)");
+
+          // Gather the cos and sine matrices from the respective caches using position ids if provided.
+          // Otherwise Gather op functions as an Identity op.
+          // Unsqueeze applied to make cos and sin matrices have dimensions that are
+          // valid for multiplication with input when is split. For cases where rotary_embedding_dim is provided,
+          // slice the matrix values until that index only
+          if (ctx.hasInput(3)) {
+            builder
+                .Add("CosCacheGather = Gather(cos_cache, position_ids)") // shape of cos matrix: [batch_size,
+                                                                         // sequence_length, head_size / 2]
+                .Add("SinCacheGather = Gather(sin_cache, position_ids)"); // shape of cos matrix: [batch_size,
+                                                                          // sequence_length, head_size / 2]
+          } else {
+            builder
+                .Add("CosCacheGather = Identity(cos_cache)") // shape of cos matrix: [batch_size, sequence_length,
+                                                             // head_size / 2]
+                .Add("SinCacheGather = Identity(sin_cache)"); // shape of cos matrix: [batch_size, sequence_length,
+                                                              // head_size / 2]
+          }
+
+          builder.Add("RotaryEmbedDimHalf = Div(RotaryEmbedDim, Two1D)")
+              .Add("RotaryEmbedDimHalfInt = Cast (RotaryEmbedDimHalf)", "to", int_type)
+              .Add(
+                  "CosCacheSliced = Slice(CosCacheGather, Zero1D, RotaryEmbedDimHalfInt, Two1D)") // shape of cos
+                                                                                                  // matrix:
+                                                                                                  // [batch_size,
+                                                                                                  // sequence_length,
+                                                                                                  // rotary_embedding_dim
+                                                                                                  // / 2]
+              .Add(
+                  "SinCacheSliced = Slice(SinCacheGather, Zero1D, RotaryEmbedDimHalfInt, Two1D)") // shape of sin
+                                                                                                  // matrix:
+                                                                                                  // [batch_size,
+                                                                                                  // sequence_length,
+                                                                                                  // rotary_embedding_dim
+                                                                                                  // / 2]
+              .Add("CosCacheUnsqueezed = Unsqueeze(CosCacheSliced, Two1D)") // shape of cos matrix: [batch_size,
+                                                                            // sequence_length, 1, rotary_embedding_dim
+                                                                            // / 2]
+              .Add("SinCacheUnsqueezed = Unsqueeze(SinCacheSliced, Two1D)"); // shape of sin matrix: [batch_size,
+                                                                             // sequence_length, 1, rotary_embedding_dim
+                                                                             // / 2]
+
+          // Create slices of inputs to multiply with sin and cos matrices based on interleaved parameter
+          // Choose the correct slices based on interleaved parameter
+          // real = cos_x * x1 - sin_x * x2
+          // imag = sin_x * x1 + cos_x * x2
+          if (interleaved == 0) {
+            // For non-interleaved (basic) rotation, slices are created as follows,
+            builder.Add(
+                "X1, X2 = Split <axis = -1, num_outputs = 2> (XToRotate)"); // shape of X1 =
+                                                                            // input[:,:,:,:rotary_embedding_dim/2],
+                                                                            // X2 =
+                                                                            // input[:,:,:,rotary_embedding_dim/2:rotary_embedding_dim]
+          } else {
+            // For interleaved rotation, slices are created as follows,
+            builder.Const1D("One1D", static_cast<int64_t>(1))
+                .Const1D("AxesRotaryDim", static_cast<int64_t>(3))
+                .Add("RotaryEmbedDimInclusive = Add(RotaryEmbedDim, One1D)")
+                .Add(
+                    "X1 = Slice(XToRotate, Zero1D, RotaryEmbedDim, AxesRotaryDim, Two1D)") // shape of X1 =
+                                                                                           // input[:,:,:,0:rotary_embedding_dim:2]
+                .Add(
+                    "X2 = Slice(XToRotate, One1D, RotaryEmbedDimInclusive, AxesRotaryDim, Two1D)"); // shape of
+                                                                                                    // X2 =
+                                                                                                    // input[:,:,:,1:rotary_embedding_dim:2]
+          }
+
+          builder.Add("CosX1 = Mul(CosCacheUnsqueezed, X1)")
+              .Add("SinX2 = Mul(SinCacheUnsqueezed, X2)")
+              .Add("Real = Sub(CosX1, SinX2)")
+              .Add("SinX1 = Mul(SinCacheUnsqueezed, X1)")
+              .Add("CosX2 = Mul(CosCacheUnsqueezed, X2)")
+              .Add("Imaginary = Add(SinX1, CosX2)");
+
+          // Insert the real and imaginary values into the original input to be rotated based on interleaved parameter
+          if (interleaved == 0) {
+            builder.Add("XRotated = Concat <axis = -1> (Real, Imaginary)");
+          } else {
+            builder
+                .Add("RealInterleave = Unsqueeze(Real, NegOne)") // shape of indices =
+                                                                 // input[:,:,:,0:rotary_embedding_dim:2, 1]
+                .Add("ImaginaryInterleave = Unsqueeze(Imaginary, NegOne)") // shape of indices =
+                                                                           // input[:,:,:,1:rotary_embedding_dim+1:2, 1]
+                .Add("XRotatedInterleavedConcat = Concat <axis = -1> (RealInterleave, ImaginaryInterleave)")
+                .Add("XRotatedShape = Shape(XToRotate)")
+                .Add("XRotated = Reshape(XRotatedInterleavedConcat, XRotatedShape)");
+          }
+
+          // Combine rotated parts with non-rotated parts
+          builder.Add("XConcat = Concat <axis = -1> (XRotated, XNoRotate)");
+
+          if (is_input_4d == 0) {
+            builder.Add("YTransposed = Identity(XConcat)");
+          } else {
+            builder.Add("YTransposed = Transpose <perm = [0, 2, 1, 3]> (XConcat)");
+          }
+          // Reshape back to 3D shape if input is a 3D tensor
+          builder.Add("XShape = Shape(X)").Add("Y = Reshape(YTransposed, XShape)");
+
+          schema.BuildFunction(functionProto);
+          return true;
+        }));
+
+static constexpr const char* Attention_ver24_doc = R"DOC(
+
+Computes scaled dot product attention on query, key and value tensors, using an optional attention mask if passed.
+
+This operator covers self and cross variants of the attention operation based on sequence lengths of K, Q and V.
+
+For self attention, `kv_sequence_length` equals to `q_sequence_length`.
+
+For cross attention, query and key might have different lengths.
+
+This operator also covers the 3 following variants based on the number of heads:
+1) Multi-headed Attention (MHA): Described in the paper https://arxiv.org/pdf/1706.03762, `q_num_heads = kv_num_heads`.
+2) Group-query Attention (GQA): Described in the paper https://arxiv.org/pdf/2305.13245, `q_num_heads > kv_num_heads`, `q_num_heads % kv_num_heads == 0`.
+3) Multi-query Attention (MQA): Described in the paper https://arxiv.org/pdf/1911.02150, `q_num_heads > kv_num_heads`, `kv_num_heads=1`.
+
+Attention bias to be added is calculated based on `attn_mask` input and `is_causal` attribute:
+1) `attn_mask`: A boolean mask where a value of `True` indicates that the element should take part in attention or a float mask of the same type as query, key, value that is added to the attention score.
+2) If `is_causal` is set to `1`, causal masking is applied with bottom-right (offset-aware) alignment: query `i` attends key `j` iff `j <= i + offset`, as illustrated below.
+
+```
+  2D causal mask for Attention (PR onnx/onnx#8068)
+   S_q=4 queries, S_k=8 keys
+   Rule: query i attends key j iff j <= i + offset
+         offset = nonpad_kv_seqlen - S_q
+
+   nonpad_kv_seqlen=4, offset=4-4=0
+
+          k0  k1  k2  k3  k4  k5  k6  k7
+         +----+----+----+----+----+----+----+----+
+    q0   | ## |    |    |    |    |    |    |    |
+         +----+----+----+----+----+----+----+----+
+    q1   | ## | ## |    |    |    |    |    |    |
+         +----+----+----+----+----+----+----+----+
+    q2   | ## | ## | ## |    |    |    |    |    |
+         +----+----+----+----+----+----+----+----+
+    q3   | ## | ## | ## | ## |    |    |    |    |
+         +----+----+----+----+----+----+----+----+
+
+
+   nonpad_kv_seqlen=8, offset=8-4=4
+
+          k0  k1  k2  k3  k4  k5  k6  k7
+         +----+----+----+----+----+----+----+----+
+    q0   | ## | ## | ## | ## | ## |    |    |    |
+         +----+----+----+----+----+----+----+----+
+    q1   | ## | ## | ## | ## | ## | ## |    |    |
+         +----+----+----+----+----+----+----+----+
+    q2   | ## | ## | ## | ## | ## | ## | ## |    |
+         +----+----+----+----+----+----+----+----+
+    q3   | ## | ## | ## | ## | ## | ## | ## | ## |
+         +----+----+----+----+----+----+----+----+
+```
+
+With `nonpad_kv_seqlen=4` (offset=0), the mask is the standard lower-triangular. With `nonpad_kv_seqlen=8` (offset=4), the diagonal shifts right by 4, so each query sees the 4 additional valid cached keys.
+
+`offset` is the count of valid keys preceding the current query block: `offset = past_sequence_length` when `past_key` is provided; `offset = nonpad_kv_seqlen - q_sequence_length` (per batch) when an external cache is indicated by `nonpad_kv_seqlen` without `past_key`; `offset = 0` when neither is provided (the no-cache case, which reduces to the standard lower-triangular mask). When `offset < 0` (`nonpad_kv_seqlen < q_sequence_length`, i.e. more query tokens than cached keys) the leading query rows have an empty key set (no key satisfies `j <= i + offset`) and are fully masked. The causal frontier is computed independently of `attn_mask` and is then composed with it additively: a boolean `attn_mask` intersects the allowed set (its disallowed positions contribute `-inf` to the bias), while a float `attn_mask` is added to the attention scores rather than disabling positions. A fully-masked query row (no key attended, including the negative-offset leading rows) produces a zero output row, not `NaN`, for both `Y` and the mode-`3` `qk_matmul_output` debug output; the mode-`3` `qk_matmul_output` is emitted at the operator's output precision (`T1`).
+
+Errata (in-place behavioral correction, no opset bump): the reference implementation and backend tests were incorrect when `nonpad_kv_seqlen != q_sequence_length` (nonzero bottom-right offset, top-left instead of bottom-right causal alignment) and produced `NaN` for fully-masked rows; corrected in version 1.23. This fixed three behaviors described above: external-cache bottom-right causal alignment (`offset = nonpad_kv_seqlen - q_sequence_length`), zero (non-`NaN`) output for fully-masked rows including the mode-`3` `qk_matmul_output`, and the mode-`3` `qk_matmul_output` precision (`T1`).
+
+With respect to KV cache update, this operator allows the following two use cases:
+
+1) Cache update happens inside the Attention operator. In this case, the `K` and `V` inputs contain only the incoming
+tokens for the current autoregressive step, and the four optional inputs/outputs past and present key and value are
+all needed. The Attention op performs a Concat operation on the past and incoming key and value to form the present
+key and value, respectively. Note that this only works correctly for the special case where the past key and value
+do not contain padded tokens.
+2) Cache update happens outside the Attention operator (for example, through the `TensorScatter` operator). In this
+case, the `K` and `V` inputs correspond to the entire cache tensor, so the four optional inputs/outputs past and
+present key and value should not be used. An additional input `nonpad_kv_seqlen` of shape (batch_size,) may be
+provided to indicate the number of non-padding tokens in each sample of the batch to save unnecessary computation.
+Here, the kv_sequence dimension of `attn_mask` can be shorter than `K` and `V`, but still needs to be at least as long
+as the maximum value of `nonpad_kv_seqlen`.
+
+Both past and present state key/values are optional. They shall be used together, and not allowed to use only one of them.
+The following pattern is applied to the Q, K and V inputs after appropriate reshaping of K and V inputs based on sequence lengths and num heads provided:
+
+```
+  The following pattern is applied by this operator:
+      Q          K          V
+      |          |          |
+Q*sqrt(scale) K*sqrt(scale) |
+      |          |          |
+      |       Transpose     |
+      |          |          |
+      ---MatMul---          |
+            |               |
+  softcap (if provided)     |
+            |               |
+ at_mask---Add              |
+            |               |
+         Softmax            |
+            |               |
+            -----MatMul------
+                   |
+                   Y
+```
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Attention,
+    24,
+    OpSchema()
+        .SetDoc(Attention_ver24_doc)
+        .Attr(
+            "is_causal",
+            "If set to `1`, causal masking is applied. For a square Q/K (no cache offset) this is a "
+            "lower-triangular matrix. In general the mask is bottom-right (offset-aware): query in-block "
+            "index `i` attends key `j` iff `j <= i + offset`, where `offset` is the count of valid keys "
+            "preceding the query block (`past_sequence_length` for an internal `past_key` cache, or "
+            "`nonpad_kv_seqlen - q_sequence_length` per batch for an external cache). When `offset = 0` "
+            "this reduces to the lower-triangular (top-left) mask.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "scale",
+            "Scaling factor applied to $Q*K^T$. Default value is `1/sqrt(head_size)`. To prevent "
+            "[numerical overflow](https://tinyurl.com/sudb9s96), scale `Q`, `K` by `sqrt(scale)` before matmul.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "q_num_heads",
+            "Number of heads of query. Must be used with 3D inputs of Q, K and V. ",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "kv_num_heads",
+            "Number of heads of key and value. Must be used with 3D inputs of Q, K and V. ",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "softmax_precision",
+            "The floating-point precision used in softmax computation. "
+            "If softmax precision is not provided, the same precision as the input of softmax (Q and K) is used.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "softcap",
+            "Softcap value for attention weights. Default value is 0.",
+            AttributeProto::FLOAT,
+            static_cast<float>(0))
+        .Attr(
+            "qk_matmul_output_mode",
+            "If set to `0`, qk_matmul_output is the output of qk matmul. "
+            "If set to `1`, qk_matmul_output is the output after the softcap operation (before mask addition). "
+            "If set to `2`, qk_matmul_output includes the attention mask and softcap (if provided) applied to the output of qk matmul. "
+            "If set to `3`, qk_matmul_output is the output after the softmax operation. "
+            "In mode `3`, a fully-masked query row (every key disallowed) is a zero row, "
+            "consistent with the corresponding row of the primary output `Y`: the "
+            "fully-masked-row guard is applied before this output is produced. "
+            "The mode-`3` output is emitted at the operator's output precision (`T1`); when "
+            "`softmax_precision` differs from `T1` this is a cast of the softmax result to `T1`. "
+            "Default value is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "Q",
+            "Query tensor. "
+            "4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, q_hidden_size)`. "
+            "For cases with a 3D input tensor, `q_hidden_size = q_num_heads * head_size`",
+            "T1")
+        .Input(
+            1,
+            "K",
+            "Key tensor. "
+            "4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, k_hidden_size)`. "
+            "For cases with a 3D input tensor, `k_hidden_size = kv_num_heads * head_size`",
+            "T1")
+        .Input(
+            2,
+            "V",
+            "Value tensor. "
+            "4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, v_hidden_size)`. "
+            "For cases with a 3D input tensor, `v_hidden_size = kv_num_heads * v_head_size`",
+            "T2")
+        .Input(
+            3,
+            "attn_mask",
+            "Attention mask. "
+            "Shape must be broadcastable to `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` "
+            "where `total_sequence_length = past_sequence_length + kv_sequence_length.` "
+            "The last dimension can also be shorter than `total_sequence_length` and will be padded to `total_sequence_length` with negative infinity. "
+            "Two types of masks are supported: a boolean mask where a value of `True` indicates that the element should take part in attention, "
+            "or a float mask of the same type as query, key, value that is added to the attention score.",
+            "U",
+            OpSchema::Optional)
+        .Input(
+            4,
+            "past_key",
+            "past state cache for key with shape `(batch_size, kv_num_heads, past_sequence_length, head_size)`",
+            "T1",
+            OpSchema::Optional)
+        .Input(
+            5,
+            "past_value",
+            "past state cache for value with shape `(batch_size, kv_num_heads, past_sequence_length, v_head_size)`",
+            "T2",
+            OpSchema::Optional)
+        .Input(
+            6,
+            "nonpad_kv_seqlen",
+            "A vector of integers of shape `(batch_size,)` that indicates the number of valid (ie, non-padding) "
+            "tokens in each sample. A padding mask can be derived from this. This should not be used together with "
+            "`past_key` and `past_value` inputs or `present_key` and `present_value` outputs "
+            "(See the KV cache use cases in the operator description).",
+            "tensor(int64)",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "Y",
+            "The output tensor . "
+            "4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, hidden_size)`. "
+            "For cases with a 3D input tensor, `hidden_size = q_num_heads * v_head_size`",
+            "T1")
+        .Output(
+            1,
+            "present_key",
+            "Updated key cache with shape `(batch_size, kv_num_heads, total_sequence_length, head_size)` "
+            "where `total_sequence_length = past_sequence_length + kv_sequence_length`.",
+            "T1",
+            OpSchema::Optional)
+        .Output(
+            2,
+            "present_value",
+            "Updated value cache with shape `(batch_size, kv_num_heads, total_sequence_length, v_head_size)` "
+            "where `total_sequence_length = past_sequence_length + kv_sequence_length`.",
+            "T2",
+            OpSchema::Optional)
+        .Output(
+            3,
+            "qk_matmul_output",
+            "The output of QK matmul. "
+            "4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` "
+            "where `total_sequence_length = past_sequence_length + kv_sequence_length`.",
+            "T1",
+            OpSchema::Optional)
+        .TypeConstraint("T1", OpSchema::all_float_types_ir4(), "Constrain Q and K inputs types to float tensors.")
+        .TypeConstraint("T2", OpSchema::all_float_types_ir4(), "Constrain V input types to float tensors.")
+        .TypeConstraint(
+            "U",
+            OpSchema::all_non_complex_numeric_types_plus_bool_ir4(),
+            "Constrain output 'mask' types to boolean tensors and input types.")
+        .TypeAndShapeInferenceFunction(defs::nn::utils::AttentionPropagateElemTypeFromInputToOutput)
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder([](const FunctionBodyBuildContext& ctx,
+                                                   const OpSchema& schema,
+                                                   FunctionProto& functionProto) {
+          // ScaledDotProductAttention <scale, is_causal, q_num_heads, kv_numheads> (Q, K, V, attn_mask, past_key,
+          // past_value) => (Y, present_key?, present_value?)
+          int64_t int_type = ONNX_NAMESPACE::TensorProto_DataType_INT64;
+          int64_t float_type = ONNX_NAMESPACE::TensorProto_DataType_FLOAT;
+
+          // Get input types
+          auto t_qk = ctx.getInputType(0);
+          if ((t_qk == nullptr) || (!t_qk->has_tensor_type()))
+            return false;
+          int64_t T1 = t_qk->tensor_type().elem_type();
+
+          // Determine precision types for Softmax
+          auto softmax_precision_attr = ctx.getAttribute("softmax_precision");
+          int64_t softmax_precision = (softmax_precision_attr != nullptr) ? softmax_precision_attr->i() : T1;
+          if ((softmax_precision != ONNX_NAMESPACE::TensorProto_DataType_FLOAT) &&
+              (softmax_precision != ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16) &&
+              (softmax_precision != ONNX_NAMESPACE::TensorProto_DataType_FLOAT16) &&
+              (softmax_precision != ONNX_NAMESPACE::TensorProto_DataType_DOUBLE))
+            return false; // Error
+
+          // If shape is 3D, q_num_heads and kv_num_heads is provided,
+          // for 4D cases, set num_heads to zero for reshape purposes
+          auto q_num_heads_attr = ctx.getAttribute("q_num_heads");
+          int64_t q_num_heads = (q_num_heads_attr != nullptr) ? q_num_heads_attr->i() : 0;
+          auto kv_num_heads_attr = ctx.getAttribute("kv_num_heads");
+          int64_t kv_num_heads = (kv_num_heads_attr != nullptr) ? kv_num_heads_attr->i() : 0;
+          auto is_causal_attr = ctx.getAttribute("is_causal");
+          int64_t is_causal = (is_causal_attr != nullptr) ? is_causal_attr->i() : 0;
+
+          // Determine if input is 3D (requires reshape and transpose) or 4D (direct reshape)
+          bool is_3d_input = (q_num_heads > 0 && kv_num_heads > 0);
+
+          FunctionBuilder builder(functionProto);
+          builder
+              .Add("BatchSize = Shape <start = 0, end = 1> (Q)") // batch size
+              .Add("QSeqLen = Shape <start = -2, end = -1> (Q)") // q_sequence_length
+              .Add("KVSeqLen = Shape <start = -2, end = -1> (K)"); // kv_sequence_length
+
+          if (is_3d_input) {
+            // For 3D inputs: First reshape to [batch_size, seq_length, num_heads, head_size]
+            // then transpose to [batch_size, num_heads, seq_length, head_size]
+            builder
+                .Const1D("QNumHeadsAttr", q_num_heads) // q_num_heads from attrs
+                .Const1D("KVNumHeadsAttr", kv_num_heads) // kv_num_heads from attrs
+                .Const1D("NegOne", static_cast<int64_t>(-1)); // head_size, inferred from other dimensions
+
+            builder.Add("QIntermediateShape = Concat <axis = 0> (BatchSize, QSeqLen, QNumHeadsAttr, NegOne)")
+                .Add("KVIntermediateShape = Concat <axis = 0> (BatchSize, KVSeqLen, KVNumHeadsAttr, NegOne)")
+                .Add("QIntermediate = Reshape (Q, QIntermediateShape)")
+                .Add("KIntermediate = Reshape (K, KVIntermediateShape)")
+                .Add("VIntermediate = Reshape (V, KVIntermediateShape)")
+                // Then transpose to [batch_size, num_heads, seq_length, head_size]
+                .Add("QReshaped = Transpose <perm = [0, 2, 1, 3]> (QIntermediate)")
+                .Add("KReshaped = Transpose <perm = [0, 2, 1, 3]> (KIntermediate)")
+                .Add("VReshaped = Transpose <perm = [0, 2, 1, 3]> (VIntermediate)");
+          } else {
+            // For 4D inputs: Already in desired shape [batch_size, num_heads, seq_length, head_size]
+            builder.Add("QReshaped = Identity(Q)").Add("KReshaped = Identity(K)").Add("VReshaped = Identity(V)");
+          }
+
+          builder
+              .Add("QNumHeads = Shape <start = 1, end = 2> (QReshaped)") // q_num_heads
+              .Add("KVNumHeads = Shape <start = 1, end = 2> (KReshaped)"); // kv_num_heads
+
+          // Calculate scaling factor if scale attribute not provided
+          auto scale_attr = ctx.getAttribute("scale");
+          float scale = (scale_attr != nullptr) ? scale_attr->f() : static_cast<float>(1);
+          builder
+              .Add("QKHeadSize = Shape <start = 3, end = 4> (QReshaped)") // head_size for Q and K
+              .Add("QKHeadSizeF = Cast (QKHeadSize)", "to", float_type)
+              .Add("VHeadSize = Shape <start = 3, end = 4> (VReshaped)") // head_size for V
+              .Add("SqrtHeadSize = Sqrt(QKHeadSizeF)")
+              .Const1D("One1D", static_cast<int64_t>(1))
+              .Const1D("NegOne1D", static_cast<int64_t>(-1))
+              .Const1D("One1DF", static_cast<float>(1))
+              .Const1D("Zero1D", static_cast<int64_t>(0))
+              .Add("CalculatedScale = Div(One1DF, SqrtHeadSize)")
+              .Const("ScaleF", ToTensor<float>(scale))
+              .Add(scale_attr != nullptr ? "ScaleFactor = Identity(ScaleF)" : "ScaleFactor = Identity(CalculatedScale)")
+              .Add("ScaleFactorSqrt = Sqrt(ScaleFactor)")
+              .Add("ScaleFactorF = Cast (ScaleFactorSqrt)", "to", T1);
+
+          // Update key and value caches for past and present states
+
+          if (ctx.hasInput(4)) {
+            builder.Add("PresentKey = Concat <axis = 2> (past_key, KReshaped)");
+            builder.Add("PastKVSeqLen =  Shape <start = -2, end = -1> (past_key)");
+          } else {
+            builder.Add("PresentKey = Identity (KReshaped)");
+            builder.Const1D("PastKVSeqLen", static_cast<int64_t>(0));
+          }
+          // External/static cache bottom-right offset (per batch): nonpad_kv_seqlen - q_len.
+          // Only meaningful when is_causal=1, nonpad present (input 6), and no past_key (input 4).
+          if (is_causal == 1 && ctx.hasInput(6) && !ctx.hasInput(4)) {
+            builder.Add("CausalOffsetPerBatch = Sub(nonpad_kv_seqlen, QSeqLen)"); // (batch,)
+          }
+          if (ctx.hasOutput(1)) {
+            builder.Add("present_key = Identity (PresentKey)");
+          }
+
+          if (ctx.hasInput(5)) {
+            builder.Add("PresentValue = Concat <axis = 2> (past_value, VReshaped)");
+          } else {
+            builder.Add("PresentValue = Identity (VReshaped)");
+          }
+          if (ctx.hasOutput(2)) {
+            builder.Add("present_value = Identity (PresentValue)");
+          }
+
+          if (!defs::nn::utils::AttentionAppendFunctionCausalMask(ctx, builder, true))
+            return false;
+
+          // Add padding mask if kv_nonpad_seqlen is provided
+          if (ctx.hasInput(6)) {
+            builder
+                .Add("KVSeqLenExpanded = Unsqueeze(nonpad_kv_seqlen, One1D)") // [batch_size, 1]
+                .Add("KVSeqLen0D = Squeeze(KVSeqLen)")
+                .Const("Zero0D", static_cast<int64_t>(0))
+                .Const("One0D", static_cast<int64_t>(1))
+                .Add("Range = Range(Zero0D, KVSeqLen0D, One0D)") // [KVSeqLen,]
+                .Add("PaddingMaskBool = Less(Range, KVSeqLenExpanded)") // [batch_size, KVSeqLen]
+                .Add("PaddingMaskFloat = Where(PaddingMaskBool, ScalarZero, FloatNegInf)") // [batch_size, KVSeqLen]
+                .Add("PaddingMask3D = Unsqueeze(PaddingMaskFloat, One1D)") // [batch_size, 1, KVSeqLen]
+                .Add("PaddingMask4D = Unsqueeze(PaddingMask3D, One1D)") // [batch_size, 1, 1, KVSeqLen]
+                .Add("AttnBiasCausalPad = Add(AttnBiasCausalOrNot, PaddingMask4D)");
+          } else {
+            builder.Add("AttnBiasCausalPad = Identity(AttnBiasCausalOrNot)");
+          }
+          builder.Add("AttnBiasT = Cast (AttnBiasCausalPad)", "to", T1);
+
+          // Group Query Attention is applied if the following are satisfied
+          // 1) q_num_heads != kv_num_heads
+          // 2) q_num_heads % kv_num_heads == 0
+          // 3) kv_num_heads == k_num_heads == v_num_heads
+          builder.Add("NGQACond1 = Equal(QNumHeads, KVNumHeads)")
+              .Add("GQACond1 = Not(NGQACond1)")
+              .Add("DivNumHeads = Div(QNumHeads, KVNumHeads)")
+              .Add("IDivNumHeads = Cast(DivNumHeads)", "to", int_type)
+              .Add("RemainderNumHeads = Mod(QNumHeads, KVNumHeads)")
+              .Add("GQACond2 = Equal(RemainderNumHeads, Zero1D)")
+              .Add("GQACond = And(GQACond1, GQACond2)")
+              .Add("InterleaveDim = Where(GQACond, IDivNumHeads, One1D)");
+
+          // repeat kv (repeat_interleave)
+          builder.Const1D("Two1D", static_cast<int64_t>(2))
+              .Add("KUnsqueezed = Unsqueeze(PresentKey, Two1D)") // [B, Hk, 1, T, Dk]
+              .Add("VUnsqueezed = Unsqueeze(PresentValue, Two1D)"); // [B, Hk, 1, T, Dv]
+
+          // Build expand shape: [B, Hk, repeats, T, Dk]
+          builder
+              .Add("KExpandShape = Concat <axis = 0> (BatchSize, KVNumHeads, InterleaveDim, NewKVSeqLen, QKHeadSize)")
+              .Add("KExpanded = Expand(KUnsqueezed, KExpandShape)");
+          builder.Add("VExpandShape = Concat <axis = 0> (BatchSize, KVNumHeads, InterleaveDim, NewKVSeqLen, VHeadSize)")
+              .Add("VExpanded = Expand(VUnsqueezed, VExpandShape)");
+
+          // Reshape to [B, Hq, T, Dk] where Hq = Hk * repeats
+          builder.Add("KAttentionShape = Concat <axis = 0> (BatchSize, QNumHeads, NewKVSeqLen, QKHeadSize)")
+              .Add("VAttentionShape = Concat <axis = 0> (BatchSize, QNumHeads, NewKVSeqLen, VHeadSize)")
+              .Add("KAttentionInput = Reshape(KExpanded, KAttentionShape)")
+              .Add("VAttentionInput = Reshape(VExpanded, VAttentionShape)");
+
+          // The following pattern is applied
+          //      Q          K          V
+          //      |          |          |
+          //     Q*scale    K*scale     |
+          //      |          |          |
+          //      |       Transpose     |
+          //      |          |          |
+          //      ---MatMul---          |
+          //            |               |
+          //  softcap (if provided)     |
+          //            |               |
+          // at_mask---Add              |
+          //            |               |
+          //         Softmax            |
+          //            |               |
+          //            -----MatMul------
+          //                    |
+          //                    Y
+          builder.Add("KTranspose = Transpose <perm = [0, 1, 3, 2]> (KAttentionInput)")
+              .Add("QScaled = Mul(QReshaped, ScaleFactorF)")
+              .Add("KScaled = Mul(KTranspose, ScaleFactorF)")
+              .Add("QKAttnWeight = MatMul(QScaled, KScaled)")
+              .Add("QKAttnCast = Cast (QKAttnWeight)", "to", T1);
+
+          // Apply softcap before bias/mask addition.
+          // Softcap must come before mask so that -inf mask values remain -inf
+          // (zero probability in softmax). If applied after, -inf maps to
+          // -softcap (finite), leaking probability to masked positions.
+          auto softcap_attr = ctx.getAttribute("softcap");
+          float softcap_val = (softcap_attr != nullptr) ? softcap_attr->f() : static_cast<float>(0);
+          if (softcap_val != 0) {
+            builder.Const1D("Softcap", softcap_val)
+                .Add("SoftcapF = Cast (Softcap)", "to", T1)
+                .Add("SoftcapDiv = Div(QKAttnCast, SoftcapF)")
+                .Add("SoftcapTanh = Tanh(SoftcapDiv)")
+                .Add("QKAttnSoftcapped = Mul(SoftcapTanh, SoftcapF)")
+                .Add("QKAttnWeightSoftcap = Add(QKAttnSoftcapped, AttnBiasT)");
+          } else {
+            builder.Add("QKAttnWeightSoftcap = Add(QKAttnCast, AttnBiasT)");
+          }
+          builder.Add("SoftmaxCast = Cast (QKAttnWeightSoftcap)", "to", softmax_precision)
+              .Add("AttnWeightSoftmax = Softmax (SoftmaxCast)")
+              .Add("SoftmaxOut = Cast (AttnWeightSoftmax)", "to", T1);
+
+          // Fully-masked-row guard: a query row whose additive bias (AttnBiasT) is
+          // entirely -inf (every key disallowed by the combined causal + attn_mask
+          // constraints) softmaxes to NaN. Detect such rows on the additive bias
+          // row-max and zero their probabilities with Where (not Mul; NaN * 0 = NaN)
+          // BEFORE the P @ V contraction so 0 @ V = 0. The guard runs before the
+          // mode-3 output capture so the exposed qk_matmul_output row is also zeroed,
+          // consistent with Y. Mirrors the reference impl so primary == _expanded
+          // bit-for-bit; a no-op for rows with any allowed key.
+          builder.Add("BiasRowMaxAxes = Constant <value = int64[1] {-1}> ()")
+              .Add("BiasRowMax = ReduceMax(AttnBiasT, BiasRowMaxAxes)") // keepdims=1 (default)
+              .Add("FloatNegInfT = CastLike(FloatNegInf, AttnBiasT)")
+              .Add("RowAllMasked = Equal(BiasRowMax, FloatNegInfT)")
+              .Add("ZeroProbT = CastLike(ScalarZero, SoftmaxOut)")
+              .Add("SoftmaxOutSafe = Where(RowAllMasked, ZeroProbT, SoftmaxOut)");
+
+          // QK MatMul output if required
+          auto qk_matmul_output_mode_attr = ctx.getAttribute("qk_matmul_output_mode");
+          int64_t qk_matmul_output_mode = (qk_matmul_output_mode_attr != nullptr) ? qk_matmul_output_mode_attr->i() : 0;
+          if (ctx.hasOutput(3)) {
+            if (qk_matmul_output_mode == 1) {
+              // Mode 1: after softcap (before bias addition)
+              if (softcap_val != 0) {
+                builder.Add("qk_matmul_output = Identity(QKAttnSoftcapped)");
+              } else {
+                // No softcap applied, same as raw QK
+                builder.Add("qk_matmul_output = Identity(QKAttnCast)");
+              }
+            } else if (qk_matmul_output_mode == 2) {
+              // Mode 2: QK + softcap + bias (after softcap + bias addition)
+              builder.Add("qk_matmul_output = Identity(QKAttnWeightSoftcap)");
+            } else if (qk_matmul_output_mode == 3) {
+              // Mode 3: post-softmax, after the fully-masked-row guard (a fully-masked
+              // row is zeroed, consistent with the primary output Y).
+              builder.Add("qk_matmul_output = Identity(SoftmaxOutSafe)");
+            } else {
+              builder.Add("qk_matmul_output = Identity(QKAttnWeight)");
+            }
+          }
+
+          builder.Add("YPreReshape = MatMul(SoftmaxOutSafe, VAttentionInput)");
+          // Reshape Y to 3D if input is a 3D tensor
+          if (is_3d_input) {
+            builder.Add("YTranspose = Transpose <perm = [0, 2, 1, 3]> (YPreReshape)")
+                .Add("YNewShape = Concat <axis = 0> (Zero1D, Zero1D, NegOne)")
+                .Add("Y = Reshape(YTranspose, YNewShape)");
+          } else {
+            builder.Add("Y = Identity(YPreReshape)");
+          }
+
+          schema.BuildFunction(functionProto);
+          return true;
+        }));
+
+static constexpr const char* CausalConvWithState_ver27_doc = R"DOC(
+
+Stateful causal 1D depthwise convolution.
+
+Used by Gated DeltaNet (Qwen3.5) and Mamba (Jamba, FalconMamba) as a preprocessing step.
+Replaces the 3-op pattern (Concat + Conv + Slice) with a single fused operation.
+
+The convolution is causal (looks only at current and past positions) and depthwise
+(each channel is convolved independently with its own kernel).
+
+The input, weight, past_state, output, and present_state tensors are rank-3 with
+shape (batch_size, channels, length). The optional bias input is rank-1 with
+shape (channels). For higher-dimensional data, use Reshape nodes before and
+after this operator to pack extra dimensions into the batch or channel axis.
+
+Weight layout: (channels, 1, k) for depthwise convolution.
+The carry state stores the last (k-1) positions for incremental decode.
+
+The optional activation attribute supports fused SiLU/Swish activation.
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CausalConvWithState,
+    27,
+    OpSchema()
+        .SetDoc(CausalConvWithState_ver27_doc)
+        .Attr(
+            "activation",
+            "Fused activation function. One of: 'silu', 'swish', 'none'. "
+            "Default is 'none'.",
+            AttributeProto::STRING,
+            std::string("none"))
+        .Input(
+            0,
+            "input",
+            "Input tensor with shape (batch_size, channels, length). Channels-first layout.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "weight",
+            "Depthwise convolution kernel with shape (channels, 1, k) where k is the kernel size. "
+            "The middle dim of size 1 follows the ONNX `Conv` weight layout `(M, C/group, k1, ..., kn)`: "
+            "since this op is always depthwise, `group = channels`, so `C/group = 1`. "
+            "Keeping this layout makes the weight tensor a drop-in for a depthwise `Conv(group=channels)` "
+            "weight, so `Conv` <-> `CausalConvWithState` rewrites require no reshape.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "bias",
+            "Optional per-channel bias with shape (channels).",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            3,
+            "past_state",
+            "Carry state from previous step with shape (batch_size, channels, k - 1). "
+            "If not provided, padding is zero.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Convolution output with same shape as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            1,
+            "present_state",
+            "Updated carry state with shape (batch_size, channels, k - 1). "
+            "Contains the last (k - 1) values of the effective padded/concatenated "
+            "sequence along the causal axis, including any values from past_state "
+            "or zero-padding when the current input is shorter than k - 1.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // --- Validate activation attribute ---
+          // Reject unknown values here (rather than in the function-body builder)
+          // so checker/shape-inference users get a clear error even when the op
+          // is never inlined. Allowed values mirror the schema doc string and
+          // the Python reference implementation.
+          auto* activation_attr = ctx.getAttribute("activation");
+          if (activation_attr != nullptr && activation_attr->has_s()) {
+            const std::string& activation = activation_attr->s();
+            if (activation != "none" && activation != "silu" && activation != "swish") {
+              fail_shape_inference(
+                  "CausalConvWithState: unsupported activation value '",
+                  activation,
+                  "'. Supported values are 'none', 'silu', and 'swish'.");
+            }
+          }
+
+          // --- Type inference ---
+          // All inputs and outputs share the same type T.
+          propagateElemTypeFromInputToOutput(ctx, 0, 0); // input -> output
+          propagateElemTypeFromInputToOutput(ctx, 0, 1); // input -> present_state
+
+          // --- Output 0: same shape as input (B, C, L) ---
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+
+          // --- Shape inference via dimension unification ---
+          // Declare logical dims and unify each input against its expected shape.
+          // unifyInputShape implicitly validates the rank of each provided input
+          // and propagates the most-informative known value across inputs that
+          // share a dim (e.g. B and C across input/weight/bias/past_state, and
+          // K between weight and past_state).
+          Dim B, C, L, One, K, KMinus1;
+          One.set_dim_value(1);
+          ctx.unifyInputShape(0, {B, C, L});
+          ctx.unifyInputShape(1, {C, One, K});
+          if (ctx.hasInput(2)) {
+            ctx.unifyInputShape(2, {C});
+          }
+          if (ctx.hasInput(3)) {
+            ctx.unifyInputShape(3, {B, C, KMinus1});
+          }
+
+          // Connect KMinus1 to K (when K is known) using Dim arithmetic.
+          // If both are known via past_state and weight, unifyDim checks they agree.
+          unifyDim(K - 1, KMinus1);
+
+          if (K.has_dim_value() && K.dim_value() < 1) {
+            fail_shape_inference("Kernel size k must be >= 1, got ", K.dim_value());
+          }
+
+          // --- Output 1: present_state shape (B, C, k - 1) ---
+          updateOutputShape(ctx, 1, {B, C, KMinus1});
+        })
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) {
+              // CausalConvWithState <activation> (input, weight, bias?, past_state?)
+              //   => (output, present_state)
+              //
+              // Reference decomposition:
+              //   1. Left-pad input with past_state (or zeros if absent) along axis 2
+              //   2. Depthwise Conv1d (group=C, no padding) on the padded input
+              //   3. Optional SiLU/Swish activation
+              //   4. Slice last (k-1) positions from padded input as present_state
+
+              // --- Step 1: Extract static channel count for Conv group attribute ---
+              // Conv's group attribute must be a compile-time integer. Prefer the
+              // input channel dimension when concrete; otherwise fall back to the
+              // leading weight dimension, which for depthwise weights is C and is
+              // typically statically known because weights are commonly
+              // initializers.
+              auto* input_type = ctx.getInputType(0);
+              if (input_type == nullptr || !input_type->has_tensor_type() || !input_type->tensor_type().has_shape() ||
+                  input_type->tensor_type().shape().dim_size() < 2) {
+                return false;
+              }
+              int64_t C = 0;
+              if (input_type->tensor_type().shape().dim(1).has_dim_value()) {
+                C = input_type->tensor_type().shape().dim(1).dim_value();
+              } else {
+                auto* weight_type = ctx.getInputType(1);
+                if (weight_type == nullptr || !weight_type->has_tensor_type() ||
+                    !weight_type->tensor_type().has_shape() || weight_type->tensor_type().shape().dim_size() < 1 ||
+                    !weight_type->tensor_type().shape().dim(0).has_dim_value()) {
+                  return false;
+                }
+                C = weight_type->tensor_type().shape().dim(0).dim_value();
+              }
+
+              // Read the activation attribute (default: "none")
+              auto* activation_attr = ctx.getAttribute("activation");
+              std::string activation =
+                  (activation_attr != nullptr && activation_attr->has_s()) ? activation_attr->s() : "none";
+
+              FunctionBuilder builder(functionProto);
+
+              // --- Shared kernel-size helpers (used by Step 2 zero-pad and Step 5 slice) ---
+              builder.Const1D("One1D", static_cast<int64_t>(1)).Add(R"ONNX(
+                KernelSize = Shape <start = 2, end = 3> (weight)
+                Km1 = Sub (KernelSize, One1D)
+              )ONNX");
+
+              // --- Step 2: Build the left-padded input (B, C, L+k-1) ---
+              if (ctx.hasInput(3)) {
+                // past_state is provided: concat it on the left along axis 2
+                builder.Add("PaddedInput = Concat <axis = 2> (past_state, input)");
+              } else {
+                // No past_state: zero-pad on the left by (k-1)
+                builder.Add(R"ONNX(
+                  BatchDim = Shape <start = 0, end = 1> (input)
+                  ChannelDim = Shape <start = 1, end = 2> (input)
+                  ZeroPadShape = Concat <axis = 0> (BatchDim, ChannelDim, Km1)
+                  ZeroPad = ConstantOfShape (ZeroPadShape)
+                  ZeroPadCast = CastLike (ZeroPad, input)
+                  PaddedInput = Concat <axis = 2> (ZeroPadCast, input)
+                )ONNX");
+              }
+
+              // --- Step 3: Depthwise Conv1d (group=C, valid padding) ---
+              if (ctx.hasInput(2)) {
+                // Bias provided: pass directly to Conv
+                builder.Add("ConvOut = Conv (PaddedInput, weight, bias)", "group", C);
+              } else {
+                // No bias
+                builder.Add("ConvOut = Conv (PaddedInput, weight)", "group", C);
+              }
+
+              // --- Step 4: Optional fused activation ---
+              if (activation == "silu" || activation == "swish") {
+                // Upcast Sigmoid/Mul to float32 to match the Python reference
+                // implementation, which evaluates SiLU in float32 for fp16/bf16
+                // inputs and casts back. For float32 inputs the Cast/CastLike
+                // pair is a no-op that runtimes fold away.
+                builder.Add(R"ONNX(
+                  ConvOutFloat = Cast <to = 1> (ConvOut)
+                  ConvSigmoid = Sigmoid (ConvOutFloat)
+                  MulOutFloat = Mul (ConvOutFloat, ConvSigmoid)
+                  output = CastLike (MulOutFloat, ConvOut)
+                )ONNX");
+              } else if (activation == "none") {
+                builder.Add("output = Identity (ConvOut)");
+              } else {
+                // Unsupported activation values are rejected up front by
+                // TypeAndShapeInferenceFunction; if we somehow reach the body
+                // builder with an unknown value (e.g. inference was bypassed),
+                // decline to build a function body rather than throw.
+                return false;
+              }
+
+              // --- Step 5: Slice last (k-1) positions from PaddedInput as present_state ---
+              // present_state = PaddedInput[:, :, L : L+(k-1)]
+              // Compute start/end from PaddedInput's actual length so the k=1 (Km1=0)
+              // edge case yields an empty (B, C, 0) slice. A negative start index
+              // would not work here because Slice treats -0 as 0, returning the full
+              // padded sequence instead of an empty tensor.
+              builder
+                  .Add(R"ONNX(
+                    PadLen = Shape <start = 2, end = 3> (PaddedInput)
+                    StartIdx = Sub (PadLen, Km1)
+                  )ONNX")
+                  .Const("SliceAxes", std::vector<int64_t>{2})
+                  .Add("present_state = Slice (PaddedInput, StartIdx, PadLen, SliceAxes)");
+
+              schema.BuildFunction(functionProto);
+              return true;
+            })
+        .TypeConstraint(
+            "T",
+            {"tensor(float)", "tensor(float16)", "tensor(bfloat16)"},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* LinearAttention_ver27_doc = R"DOC(
+Unified linear attention operator for autoregressive decoding (T=1) and prefill (T>1).
+
+The query, key, value, and (where applicable) decay/beta inputs use 3D packed format
+[B, T, H*D], where heads are flattened into the last dimension; q_num_heads and
+kv_num_heads are always required and are used to unpack to 4D internally for computation.
+The optional past_state and present_state are 4D with shape (B, H_kv, d_k, d_v).
+
+Group-query attention (GQA) is supported: q_num_heads must be a positive multiple of
+kv_num_heads. When q_num_heads == kv_num_heads this reduces to multi-headed linear
+attention; when q_num_heads > kv_num_heads each KV head (and its recurrent state) is
+shared by `q_num_heads / kv_num_heads` query heads (multi-query attention is the
+special case kv_num_heads == 1).
+
+The update_rule attribute selects the recurrence type:
+- "linear": S_t = S_{t-1} + k_t ⊗ v_t; o_t = scale * q_t^T S_t
+- "gated": S_t = exp(g_t) * S_{t-1} + k_t ⊗ v_t; o_t = scale * q_t^T S_t
+- "delta": S_t = S_{t-1} + β_t * k_t ⊗ (v_t - S_{t-1}^T k_t); o_t = scale * q_t^T S_t
+- "gated_delta": S_t = exp(g_t) * S_{t-1} + β_t * k_t ⊗ (v_t - exp(g_t) * S_{t-1}^T k_t); o_t = scale * q_t^T S_t
+
+where g_t is the decay (in log-space), β_t is the update rate, and ⊗ denotes outer product.
+
+Semantics: Equivalent to running the recurrent update sequentially for each token,
+but may be implemented using chunk-parallel algorithms for GPU efficiency.
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LinearAttention,
+    27,
+    OpSchema()
+        .SetDoc(LinearAttention_ver27_doc)
+        .Attr(
+            "update_rule",
+            "The update rule for the linear attention recurrence. "
+            "One of: 'linear', 'gated', 'delta', 'gated_delta'. Default is 'gated_delta'.",
+            AttributeProto::STRING,
+            std::string("gated_delta"))
+        .Attr(
+            "scale",
+            "Output scaling factor. When 0.0 (default), derives d_k = query.shape[-1] / q_num_heads "
+            "and uses 1/sqrt(d_k). Set explicitly to override.",
+            AttributeProto::FLOAT,
+            0.0f)
+        .Attr("q_num_heads", "Number of query heads. Always required.", AttributeProto::INT)
+        .Attr("kv_num_heads", "Number of key/value heads. Always required.", AttributeProto::INT)
+        .Attr(
+            "chunk_size",
+            "Chunk size for the chunk-parallel WY decomposition during prefill (T>1). "
+            "Tuning hint; does not affect output correctness.",
+            AttributeProto::INT,
+            static_cast<int64_t>(64))
+        .Input(
+            0,
+            "query",
+            "Query vectors with 3D packed shape (B, T, H_q * d_k). "
+            "Heads are packed into the last dimension.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "key",
+            "Key vectors with 3D packed shape (B, T, H_kv * d_k). "
+            "Should be L2-normalized for delta/gated_delta modes.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "value",
+            "Value vectors with 3D packed shape (B, T, H_kv * d_v).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            3,
+            "past_state",
+            "Recurrent state from previous step with shape (B, H_kv, d_k, d_v). "
+            "Always 4D. If not provided, defaults to zeros.",
+            "S",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            4,
+            "decay",
+            "Exponential decay gate in log-space. 3D packed shape: "
+            "(B, T, H_kv * d_k) for per-key-dimension decay (GLA/RWKV-6), or "
+            "(B, T, H_kv) for per-head scalar decay (DeltaNet/RetNet). "
+            "Required for 'gated' and 'gated_delta' modes.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            5,
+            "beta",
+            "Update rate (sigmoid output). 3D packed shape: "
+            "(B, T, H_kv) or (B, T, 1). "
+            "Required for 'delta' and 'gated_delta' modes.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Attention output with 3D packed shape (B, T, H_q * d_v).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            1,
+            "present_state",
+            "Updated recurrent state with shape (B, H_kv, d_k, d_v). Always 4D.",
+            "S",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {"tensor(float16)", "tensor(bfloat16)", "tensor(float)"},
+            "Constrain activation input and output types to float16, bfloat16, or float32 tensors.")
+        .TypeConstraint(
+            "S",
+            {"tensor(float16)", "tensor(bfloat16)", "tensor(float)"},
+            "Constrain state types to float16, bfloat16, or float32 tensors. "
+            "Should be float32 or the same as T for numerical stability on long sequences.")
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) {
+              // LinearAttention <update_rule, scale, q_num_heads, kv_num_heads, chunk_size>
+              //   (query, key, value, past_state?, decay?, beta?)
+              //   => (output, present_state)
+              //
+              // Reference decomposition (sequential recurrence via Scan):
+              //   1. Reshape/transpose 3D packed inputs (B, T, H*D) -> 4D (B, H, T, D)
+              //   2. Initialize state (past_state or zeros), shape (B, H_kv, d_k, d_v)
+              //   3. Compute scale factor (attribute or 1/sqrt(d_k))
+              //   4. Run Scan over T axis with body implementing one recurrence step
+              //   5. Transpose/reshape 4D outputs back to 3D (B, T, H_q*d_v)
+
+              // --- Step 1: Extract attributes and validate ---
+              auto* update_rule_attr = ctx.getAttribute("update_rule");
+              std::string update_rule =
+                  (update_rule_attr != nullptr && update_rule_attr->has_s()) ? update_rule_attr->s() : "gated_delta";
+
+              auto* q_num_heads_attr = ctx.getAttribute("q_num_heads");
+              auto* kv_num_heads_attr = ctx.getAttribute("kv_num_heads");
+              if (q_num_heads_attr == nullptr || !q_num_heads_attr->has_i() || kv_num_heads_attr == nullptr ||
+                  !kv_num_heads_attr->has_i()) {
+                return false;
+              }
+              int64_t q_num_heads = q_num_heads_attr->i();
+              int64_t kv_num_heads = kv_num_heads_attr->i();
+
+              auto* scale_attr = ctx.getAttribute("scale");
+              float scale = (scale_attr != nullptr && scale_attr->has_f()) ? scale_attr->f() : 0.0f;
+
+              // Per-rule presence of optional inputs
+              bool has_decay = (update_rule == "gated" || update_rule == "gated_delta");
+              bool has_beta = (update_rule == "delta" || update_rule == "gated_delta");
+
+              // Need query type (for CastLike on zero state) — checked indirectly via input 0 presence.
+              if (ctx.getInputType(0) == nullptr) {
+                return false;
+              }
+
+              // GQA: q_num_heads must be a positive multiple of kv_num_heads.
+              // group_size == 1 is the standard MHA case (no expansion); group_size > 1
+              // means each KV head is shared by `group_size` query heads.
+              if (q_num_heads <= 0 || kv_num_heads <= 0 || q_num_heads % kv_num_heads != 0) {
+                return false;
+              }
+              int64_t group_size = q_num_heads / kv_num_heads;
+
+              FunctionBuilder builder(functionProto);
+
+              // --- Step 2: Pre-Scan 3D -> 4D reshape and transpose ---
+              // Inputs arrive packed as (B, T, H*D). Reshape to (B, T, H, D) then
+              // transpose to (B, H, T, D) so the Scan iterates along the T axis.
+              builder.Const1D("NegOne1D", static_cast<int64_t>(-1))
+                  .Const1D("One1D", static_cast<int64_t>(1))
+                  .Const1D("HqConst", q_num_heads)
+                  .Const1D("HkvConst", kv_num_heads)
+                  .Add(R"ONNX(
+                BatchDim = Shape <start = 0, end = 1> (query)
+                SeqLenDim = Shape <start = 1, end = 2> (query)
+              )ONNX");
+
+              // Inputs are reshaped to (B, T, H, D), then transposed so the T axis is
+              // first: (T, B, H, D). The leading T axis is consumed by Scan (which
+              // only supports scan_input_axes=0 in the ONNX reference runtime).
+
+              // Query: (B, T, H_q*d_k) -> (B, T, H_q, d_k) -> (T, B, H_q, d_k)
+              builder.Add(R"ONNX(
+                QShape4D = Concat <axis = 0> (BatchDim, SeqLenDim, HqConst, NegOne1D)
+                QReshaped = Reshape (query, QShape4D)
+                Q4D = Transpose <perm = [1, 0, 2, 3]> (QReshaped)
+              )ONNX");
+
+              // Key/Value/Decay all share H_kv as the head dimension; -1 absorbs
+              // d_k (key/decay) or d_v (value), and degenerates to 1 for per-head
+              // scalar decay of shape (B, T, H_kv).
+              builder.Add(R"ONNX(
+                KVShape4D = Concat <axis = 0> (BatchDim, SeqLenDim, HkvConst, NegOne1D)
+                KReshaped = Reshape (key, KVShape4D)
+                K4D = Transpose <perm = [1, 0, 2, 3]> (KReshaped)
+                VReshaped = Reshape (value, KVShape4D)
+                V4D = Transpose <perm = [1, 0, 2, 3]> (VReshaped)
+              )ONNX");
+
+              if (has_decay) {
+                // Decay: (B, T, H_kv*d_k) -> (T, B, H_kv, d_k), or
+                //        (B, T, H_kv)      -> (T, B, H_kv, 1)   [broadcastable].
+                builder.Add(R"ONNX(
+                  DecayReshaped = Reshape (decay, KVShape4D)
+                  Decay4D = Transpose <perm = [1, 0, 2, 3]> (DecayReshaped)
+                )ONNX");
+              }
+
+              if (has_beta) {
+                // Beta: (B, T, H_kv) or (B, T, 1) -> reshape (B, T, -1, 1)
+                //       -> transpose (T, B, H_kv_or_1, 1) [broadcastable head dim].
+                builder.Add(R"ONNX(
+                  BetaShape4D = Concat <axis = 0> (BatchDim, SeqLenDim, NegOne1D, One1D)
+                  BetaReshaped = Reshape (beta, BetaShape4D)
+                  Beta4D = Transpose <perm = [1, 0, 2, 3]> (BetaReshaped)
+                )ONNX");
+              }
+
+              // --- Step 3: Initialize recurrence state (B, H_kv, d_k, d_v) ---
+              // Compute d_k and d_v as 1D shape tensors for downstream use
+              // (state shape here, scale factor in Step 4).
+              builder.Add(R"ONNX(
+                QLastDim = Shape <start = 2, end = 3> (query)
+                VLastDim = Shape <start = 2, end = 3> (value)
+                DkDim = Div (QLastDim, HqConst)
+                DvDim = Div (VLastDim, HkvConst)
+              )ONNX");
+
+              // State and scale are kept in float32 inside the body to match the
+              // Python reference's fp32 accumulation. `present_state` is cast back
+              // to S (past_state's dtype, or query's dtype when past_state is
+              // absent) after the Scan; `output` is cast back to T inside the body.
+              if (ctx.hasInput(3)) {
+                // past_state has shape (B, H_kv, d_k, d_v) and dtype S.
+                // Upcast to float32 for accumulation regardless of S.
+                builder.Add("State0 = Cast <to = 1> (past_state)");
+              } else {
+                // ConstantOfShape with default value yields float32 already; no
+                // cast required. S anchor for the post-Scan cast defaults to T
+                // (query's dtype) in this case.
+                builder.Add(R"ONNX(
+                  StateShape = Concat <axis = 0> (BatchDim, HkvConst, DkDim, DvDim)
+                  State0 = ConstantOfShape (StateShape)
+                )ONNX");
+              }
+
+              // --- Step 4: Compute scale factor (scalar, float32) ---
+              // If `scale` attribute is non-zero, use it directly; otherwise
+              // derive 1/sqrt(d_k) from query's last dim. ScaleFactor stays in
+              // float32 to multiply against the float32 read result inside the
+              // body; the body casts the final output back to T.
+              if (scale != 0.0f) {
+                builder.Const("ScaleFactor", scale);
+              } else {
+                builder.Add(R"ONNX(
+                  DkScalar = Squeeze (DkDim)
+                  DkFloat = Cast <to = 1> (DkScalar)
+                  SqrtDk = Sqrt (DkFloat)
+                  ScaleFactor = Reciprocal (SqrtDk)
+                )ONNX");
+              }
+
+              // --- Step 4b: Precompute GQA expand/read shapes (only when group_size > 1) ---
+              // GQA expansion uses the same Unsqueeze + Expand + Reshape pattern as the
+              // standard Attention op. The state lives at H_kv heads (one state per
+              // KV head — recurrence is per-KV-head); only the read step needs to
+              // broadcast it across the `group_size` query heads sharing that KV head.
+              // Shapes are computed once outside the Scan body and captured inside
+              // by name.
+              if (group_size > 1) {
+                builder.Const1D("GroupSize", group_size).Const1D("Two1D", static_cast<int64_t>(2)).Add(R"ONNX(
+                  StateExpandShape = Concat <axis = 0> (BatchDim, HkvConst, GroupSize, DkDim, DvDim)
+                  StateReadShape = Concat <axis = 0> (BatchDim, HqConst, DkDim, DvDim)
+                )ONNX");
+              }
+
+              // --- Step 5: Scan node with body subgraph ---
+              // The body implements one recurrence step. We write one complete
+              // body per update_rule (linear / gated / delta / gated_delta) so
+              // the recurrence is readable inline rather than assembled from
+              // fragments. ScaleFactor (and, for group_size > 1,
+              // StateExpandShape / StateReadShape) are referenced from the
+              // enclosing scope (Scan subgraphs may capture outer-scope
+              // tensors by name).
+              //
+              // The body always accumulates in float32 to match the Python
+              // reference: each sliced T-typed input (q_t/k_t/v_t/decay_t/beta_t)
+              // is cast to float32 at body entry; state_in/state_out stay
+              // in float32 throughout; output_t is cast back to T (anchored on
+              // q_t) before being emitted as a per-step Scan output. The post-
+              // Scan code casts FinalState back to S.
+              //
+              // Axes constants used inside the body for Unsqueeze/Squeeze:
+              // NegOne1D was added in Step 2; Two1D is set up in Step 4b
+              // when group_size > 1.
+              builder.Const1D("NegTwo1D", static_cast<int64_t>(-2));
+
+              // Read block (shared across all update_rules; differs only by GQA):
+              // output_t = ScaleFactor * (q_t^T @ state_out), then CastLike to T.
+              // For GQA (group_size > 1) the per-KV-head state must first be
+              // repeat-interleaved across the `group_size` query heads sharing
+              // each KV head, using the same Unsqueeze + Expand + Reshape
+              // pattern as the standard Attention op. `StateExpandShape` and
+              // `StateReadShape` are captured from the enclosing scope.
+              const std::string read_block = (group_size > 1) ? R"ONNX(
+                StateUnsq = Unsqueeze (state_out, Two1D)
+                StateExpanded = Expand (StateUnsq, StateExpandShape)
+                StateForRead = Reshape (StateExpanded, StateReadShape)
+                QtRow = Unsqueeze (q_t_f, NegTwo1D)
+                ReadOut = MatMul (QtRow, StateForRead)
+                ReadSq = Squeeze (ReadOut, NegTwo1D)
+                output_t_f = Mul (ScaleFactor, ReadSq)
+                output_t = CastLike (output_t_f, q_t)
+              )ONNX"
+                                                              : R"ONNX(
+                QtRow = Unsqueeze (q_t_f, NegTwo1D)
+                ReadOut = MatMul (QtRow, state_out)
+                ReadSq = Squeeze (ReadOut, NegTwo1D)
+                output_t_f = Mul (ScaleFactor, ReadSq)
+                output_t = CastLike (output_t_f, q_t)
+              )ONNX";
+
+              // One complete recurrence body per update_rule. Each body:
+              //   * casts its T-typed inputs to float32,
+              //   * computes state_out = (decayed) state_in + KtCol @ WriteRow,
+              //     where WriteRow comes from v_t_f directly (linear/gated) or
+              //     from a delta-rule correction Delta = beta * (v - retrieved).
+              std::string body;
+              std::string body_inputs;
+              std::string scan_inputs;
+              int64_t num_scan_inputs;
+              if (update_rule == "linear") {
+                body_inputs = "state_in, q_t, k_t, v_t";
+                scan_inputs = "State0, Q4D, K4D, V4D";
+                num_scan_inputs = 3;
+                body = R"ONNX(
+                q_t_f = Cast <to = 1> (q_t)
+                k_t_f = Cast <to = 1> (k_t)
+                v_t_f = Cast <to = 1> (v_t)
+                KtCol = Unsqueeze (k_t_f, NegOne1D)
+                WriteRow = Unsqueeze (v_t_f, NegTwo1D)
+                Outer = MatMul (KtCol, WriteRow)
+                state_out = Add (state_in, Outer)
+              )ONNX";
+              } else if (update_rule == "gated") {
+                body_inputs = "state_in, q_t, k_t, v_t, decay_t";
+                scan_inputs = "State0, Q4D, K4D, V4D, Decay4D";
+                num_scan_inputs = 4;
+                body = R"ONNX(
+                q_t_f = Cast <to = 1> (q_t)
+                k_t_f = Cast <to = 1> (k_t)
+                v_t_f = Cast <to = 1> (v_t)
+                decay_t_f = Cast <to = 1> (decay_t)
+                DecayExp = Exp (decay_t_f)
+                DecayExpUnsq = Unsqueeze (DecayExp, NegOne1D)
+                DecayedState = Mul (state_in, DecayExpUnsq)
+                KtCol = Unsqueeze (k_t_f, NegOne1D)
+                WriteRow = Unsqueeze (v_t_f, NegTwo1D)
+                Outer = MatMul (KtCol, WriteRow)
+                state_out = Add (DecayedState, Outer)
+              )ONNX";
+              } else if (update_rule == "delta") {
+                body_inputs = "state_in, q_t, k_t, v_t, beta_t";
+                scan_inputs = "State0, Q4D, K4D, V4D, Beta4D";
+                num_scan_inputs = 4;
+                body = R"ONNX(
+                q_t_f = Cast <to = 1> (q_t)
+                k_t_f = Cast <to = 1> (k_t)
+                v_t_f = Cast <to = 1> (v_t)
+                beta_t_f = Cast <to = 1> (beta_t)
+                KtCol = Unsqueeze (k_t_f, NegOne1D)
+                StateT = Transpose <perm = [0, 1, 3, 2]> (state_in)
+                Retrieved = MatMul (StateT, KtCol)
+                RetrievedSq = Squeeze (Retrieved, NegOne1D)
+                Diff = Sub (v_t_f, RetrievedSq)
+                Delta = Mul (beta_t_f, Diff)
+                WriteRow = Unsqueeze (Delta, NegTwo1D)
+                Outer = MatMul (KtCol, WriteRow)
+                state_out = Add (state_in, Outer)
+              )ONNX";
+              } else { // gated_delta
+                body_inputs = "state_in, q_t, k_t, v_t, decay_t, beta_t";
+                scan_inputs = "State0, Q4D, K4D, V4D, Decay4D, Beta4D";
+                num_scan_inputs = 5;
+                body = R"ONNX(
+                q_t_f = Cast <to = 1> (q_t)
+                k_t_f = Cast <to = 1> (k_t)
+                v_t_f = Cast <to = 1> (v_t)
+                decay_t_f = Cast <to = 1> (decay_t)
+                beta_t_f = Cast <to = 1> (beta_t)
+                DecayExp = Exp (decay_t_f)
+                DecayExpUnsq = Unsqueeze (DecayExp, NegOne1D)
+                DecayedState = Mul (state_in, DecayExpUnsq)
+                KtCol = Unsqueeze (k_t_f, NegOne1D)
+                StateT = Transpose <perm = [0, 1, 3, 2]> (DecayedState)
+                Retrieved = MatMul (StateT, KtCol)
+                RetrievedSq = Squeeze (Retrieved, NegOne1D)
+                Diff = Sub (v_t_f, RetrievedSq)
+                Delta = Mul (beta_t_f, Diff)
+                WriteRow = Unsqueeze (Delta, NegTwo1D)
+                Outer = MatMul (KtCol, WriteRow)
+                state_out = Add (DecayedState, Outer)
+              )ONNX";
+              }
+
+              // Assemble Scan node text. Body name is arbitrary.
+              // We omit scan_input_axes/scan_output_axes (default 0); Q/K/V/decay/beta
+              // were already pre-transposed so the T axis is the leading dimension.
+              std::string scan_text =
+                  "FinalState, OutputAccum = Scan <\n"
+                  "  num_scan_inputs = " +
+                  std::to_string(num_scan_inputs) +
+                  ",\n"
+                  "  body = linear_attn_step (" +
+                  body_inputs + ") => (state_out, output_t) {\n" + body + read_block +
+                  "              }\n"
+                  "> (" +
+                  scan_inputs + ")";
+
+              builder.Add(scan_text.c_str());
+
+              // --- Step 6: Post-Scan 4D -> 3D reshape and present_state ---
+              // OutputAccum: (T, B, H_q, d_v) -> Transpose to (B, T, H_q, d_v)
+              // -> Reshape to (B, T, H_q * d_v). Already T-typed (cast inside body).
+              // present_state: cast FinalState (float32) back to S.
+              //   * With past_state: anchor on past_state's dtype.
+              //   * Without past_state: default S to T (query's dtype).
+              builder.Add(R"ONNX(
+                OutputTransposed = Transpose <perm = [1, 0, 2, 3]> (OutputAccum)
+                OutputShape3D = Concat <axis = 0> (BatchDim, SeqLenDim, NegOne1D)
+                output = Reshape (OutputTransposed, OutputShape3D)
+              )ONNX");
+              if (ctx.hasInput(3)) {
+                builder.Add("present_state = CastLike (FinalState, past_state)");
+              } else {
+                builder.Add("present_state = CastLike (FinalState, query)");
+              }
+
+              schema.BuildFunction(functionProto);
+              return true;
+            })
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          // Read required attributes
+          auto* q_num_heads_attr = ctx.getAttribute("q_num_heads");
+          auto* kv_num_heads_attr = ctx.getAttribute("kv_num_heads");
+          int64_t q_num_heads = (q_num_heads_attr && q_num_heads_attr->has_i()) ? q_num_heads_attr->i() : 0;
+          int64_t kv_num_heads = (kv_num_heads_attr && kv_num_heads_attr->has_i()) ? kv_num_heads_attr->i() : 0;
+
+          // GQA constraint: q_num_heads must be a positive multiple of kv_num_heads.
+          // q_num_heads == kv_num_heads is MHA; q_num_heads > kv_num_heads with the
+          // divisibility rule is GQA (or MQA when kv_num_heads == 1). Non-positive
+          // head counts are rejected here so that downstream divisions and the
+          // function body always see strictly positive values.
+          if (q_num_heads <= 0) {
+            fail_type_inference("q_num_heads must be > 0, got ", q_num_heads);
+          }
+          if (kv_num_heads <= 0) {
+            fail_type_inference("kv_num_heads must be > 0, got ", kv_num_heads);
+          }
+          if (q_num_heads % kv_num_heads != 0) {
+            fail_type_inference(
+                "q_num_heads (", q_num_heads, ") must be a multiple of kv_num_heads (", kv_num_heads, ")");
+          }
+
+          // Read update_rule attribute with default
+          auto* update_rule_attr = ctx.getAttribute("update_rule");
+          std::string update_rule = (update_rule_attr != nullptr) ? update_rule_attr->s() : "gated_delta";
+
+          // Validate update_rule value
+          if (update_rule != "linear" && update_rule != "gated" && update_rule != "delta" &&
+              update_rule != "gated_delta") {
+            fail_type_inference("update_rule must be one of: 'linear', 'gated', 'delta', 'gated_delta'");
+          }
+
+          // Validate update_rule vs optional inputs (decay=input 4, beta=input 5).
+          const bool has_past_state = ctx.hasInput(3);
+          const bool has_decay = ctx.hasInput(4);
+          const bool has_beta = ctx.hasInput(5);
+
+          if (update_rule == "linear") {
+            if (has_decay) {
+              fail_type_inference("update_rule 'linear' forbids decay input");
+            }
+            if (has_beta) {
+              fail_type_inference("update_rule 'linear' forbids beta input");
+            }
+          } else if (update_rule == "gated") {
+            if (!has_decay) {
+              fail_type_inference("update_rule 'gated' requires decay input");
+            }
+            if (has_beta) {
+              fail_type_inference("update_rule 'gated' forbids beta input");
+            }
+          } else if (update_rule == "delta") {
+            if (has_decay) {
+              fail_type_inference("update_rule 'delta' forbids decay input");
+            }
+            if (!has_beta) {
+              fail_type_inference("update_rule 'delta' requires beta input");
+            }
+          } else if (update_rule == "gated_delta") {
+            if (!has_decay) {
+              fail_type_inference("update_rule 'gated_delta' requires decay input");
+            }
+            if (!has_beta) {
+              fail_type_inference("update_rule 'gated_delta' requires beta input");
+            }
+          }
+
+          // --- Type propagation ---
+          // output: type T from query.
+          //
+          // present_state uses the separately-declared state type S only when S can be
+          // anchored by the optional past_state input. When past_state is omitted,
+          // type inference cannot independently infer S, so present_state explicitly
+          // falls back to type T from query on the first step. Callers that require an
+          // fp32 state while using lower-precision query activations must therefore
+          // provide past_state with the desired state element type.
+          // (The spec recommends S == float32 or S == T for numerical stability.)
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (has_past_state && ctx.getInputType(3) != nullptr && ctx.getInputType(3)->has_tensor_type()) {
+            propagateElemTypeFromInputToOutput(ctx, 3, 1);
+          } else {
+            // No past_state is available to anchor S, so present_state defaults to T.
+            propagateElemTypeFromInputToOutput(ctx, 0, 1);
+          }
+
+          // --- Shape inference via dimension unification ---
+          // Declare logical dims and unify each input against its expected shape.
+          // unifyInputShape validates the rank of each provided input and merges
+          // the most-informative known value across inputs that share a dim
+          // (B and T across Q/K/V/decay/beta/past_state; H_kv between past_state
+          // and the kv_num_heads attribute; d_k between past_state, Q (via
+          // QPack/q_num_heads) and K; d_v between past_state and V).
+          Dim B, T, QPack, KPack, VPack, Hkv, Dk, Dv;
+          if (kv_num_heads > 0) {
+            Hkv.set_dim_value(kv_num_heads);
+          }
+          ctx.unifyInputShape(0, {B, T, QPack});
+          ctx.unifyInputShape(1, {B, T, KPack});
+          ctx.unifyInputShape(2, {B, T, VPack});
+          if (has_past_state) {
+            ctx.unifyInputShape(3, {B, Hkv, Dk, Dv});
+          }
+          // decay shape: (B, T, H_kv * d_k) for per-key-dim or (B, T, H_kv) for
+          // per-head. Both are rank-3; we only constrain B and T.
+          if (has_decay) {
+            Dim DecayLast;
+            ctx.unifyInputShape(4, {B, T, DecayLast});
+          }
+          // beta shape: (B, T, H_kv) or (B, T, 1). Both rank-3; only B, T checked.
+          if (has_beta) {
+            Dim BetaLast;
+            ctx.unifyInputShape(5, {B, T, BetaLast});
+          }
+
+          // Derive d_k from Q (via q_num_heads) and K (via kv_num_heads).
+          // Multiple sources for the same logical dim are unified, so an
+          // inconsistency between Q and K (e.g. mismatched d_k) fails here.
+          // Reject packed last dims that are not divisible by their head count
+          // up-front so the resulting integer-division d_k actually corresponds
+          // to a shape the function body can reshape to (B, T, H, D).
+          if (q_num_heads > 0 && QPack.has_dim_value()) {
+            if (QPack.dim_value() % q_num_heads != 0) {
+              fail_shape_inference(
+                  "Packed query last dim (",
+                  QPack.dim_value(),
+                  ") must be divisible by q_num_heads (",
+                  q_num_heads,
+                  ")");
+            }
+            unifyDim(Dk, QPack.dim_value() / q_num_heads);
+          }
+          if (kv_num_heads > 0 && KPack.has_dim_value()) {
+            if (KPack.dim_value() % kv_num_heads != 0) {
+              fail_shape_inference(
+                  "Packed key last dim (",
+                  KPack.dim_value(),
+                  ") must be divisible by kv_num_heads (",
+                  kv_num_heads,
+                  ")");
+            }
+            unifyDim(Dk, KPack.dim_value() / kv_num_heads);
+          }
+          // Derive d_v from V.
+          if (kv_num_heads > 0 && VPack.has_dim_value()) {
+            if (VPack.dim_value() % kv_num_heads != 0) {
+              fail_shape_inference(
+                  "Packed value last dim (",
+                  VPack.dim_value(),
+                  ") must be divisible by kv_num_heads (",
+                  kv_num_heads,
+                  ")");
+            }
+            unifyDim(Dv, VPack.dim_value() / kv_num_heads);
+          }
+
+          // Strict validation of decay/beta last dims, deferred until d_k and H_kv
+          // are derived above. The earlier unifyInputShape calls only checked rank
+          // and B/T; here we reject concrete last dims that the function body and
+          // Python reference cannot broadcast correctly.
+          //   decay last dim must be H_kv (per-head scalar form) or H_kv * d_k
+          //     (per-key-dim form). When d_k is unknown we still require divisibility
+          //     by H_kv.
+          //   beta  last dim must be 1 (broadcast) or H_kv (per-head).
+          if (has_decay && kv_num_heads > 0) {
+            auto* decay_type = ctx.getInputType(4);
+            if (decay_type != nullptr && decay_type->has_tensor_type() && decay_type->tensor_type().has_shape() &&
+                decay_type->tensor_type().shape().dim_size() == 3 &&
+                decay_type->tensor_type().shape().dim(2).has_dim_value()) {
+              const int64_t decay_last = decay_type->tensor_type().shape().dim(2).dim_value();
+              if (Dk.has_dim_value()) {
+                const int64_t dk = Dk.dim_value();
+                if (decay_last != kv_num_heads && decay_last != kv_num_heads * dk) {
+                  fail_shape_inference(
+                      "decay last dim (",
+                      decay_last,
+                      ") must be kv_num_heads (",
+                      kv_num_heads,
+                      ") or kv_num_heads * d_k (",
+                      kv_num_heads * dk,
+                      ")");
+                }
+              } else if (decay_last != kv_num_heads && decay_last % kv_num_heads != 0) {
+                fail_shape_inference(
+                    "decay last dim (",
+                    decay_last,
+                    ") must be kv_num_heads (",
+                    kv_num_heads,
+                    ") or a multiple of kv_num_heads");
+              }
+            }
+          }
+          if (has_beta && kv_num_heads > 0) {
+            auto* beta_type = ctx.getInputType(5);
+            if (beta_type != nullptr && beta_type->has_tensor_type() && beta_type->tensor_type().has_shape() &&
+                beta_type->tensor_type().shape().dim_size() == 3 &&
+                beta_type->tensor_type().shape().dim(2).has_dim_value()) {
+              const int64_t beta_last = beta_type->tensor_type().shape().dim(2).dim_value();
+              if (beta_last != 1 && beta_last != kv_num_heads) {
+                fail_shape_inference("beta last dim (", beta_last, ") must be 1 or kv_num_heads (", kv_num_heads, ")");
+              }
+            }
+          }
+
+          // Output 0: (B, T, H_q * d_v) — 3D packed.
+          Dim OutLast;
+          if (q_num_heads > 0 && Dv.has_dim_value()) {
+            OutLast.set_dim_value(q_num_heads * Dv.dim_value());
+          }
+          updateOutputShape(ctx, 0, {B, T, OutLast});
+
+          // Output 1: present_state (B, H_kv, d_k, d_v) — always 4D.
+          updateOutputShape(ctx, 1, {B, Hkv, Dk, Dv});
+        }));
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/nn/old.cc b/onnx/defs/nn/old.cc
new file mode 100644
index 0000000..3518a41
--- /dev/null
+++ b/onnx/defs/nn/old.cc
@@ -0,0 +1,4633 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <cmath>
+#include <string>
+#include <vector>
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/nn/utils.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+// For GlobalPool operations.
+static void globalPoolTypeShapeInference_opset2(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // needs at least one input with shape.
+  if (!hasNInputShapes(ctx, 1)) {
+    return;
+  }
+
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() < 2) {
+    return;
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  // (N, C, 1, 1, ..., 1)
+  auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+  *output_shape->add_dim() = input_shape.dim(0);
+  *output_shape->add_dim() = input_shape.dim(1);
+
+  for (size_t i = 0; i < n_input_dims; ++i) {
+    output_shape->add_dim()->set_dim_value(1);
+  }
+}
+
+static std::function<void(OpSchema&)> GlobalLpPoolingOpSchemaGenerator_opset2(const char* op_type, const char* op) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ Global{op_type} consumes an input tensor X and applies {op} pooling across
+ the values in the same channel. This is equivalent to {op_type} with kernel size
+ equal to the spatial dimension of input tensor.)DOC";
+        ReplaceAll(doc, "{op_type}", op_type);
+        ReplaceAll(doc, "{op}", op););
+    schema.SetDoc(doc);
+    schema.Attr(
+        "p", "p value of the Lp norm used to pool over the input data.", AttributeProto::INT, static_cast<int64_t>(2));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the width "
+        "of the data. For non image case, the dimensions are "
+        "in the form of (N x C x D1 x D2 ... Dn), "
+        "where N is the batch size.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from pooling across the input "
+        "tensor. The output tensor has the same rank as the input. "
+        "The first two dimensions of output shape are the same as "
+        "the input (N x C), while the other dimensions are all 1.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) { globalPoolTypeShapeInference_opset2(ctx); });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GlobalLpPool,
+    2,
+    OpSchema().FillUsing(GlobalLpPoolingOpSchemaGenerator_opset2("LpPool", "lp pool")));
+
+constexpr const char* pads_doc_opset11 =
+    "Padding for the beginning and ending along each spatial axis, it can take any value greater "
+    "than or equal to 0. The value represent the number of pixels added to the beginning "
+    "and end part of the corresponding axis. `pads` format should be as follow "
+    "[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels "
+    "added at the beginning of axis `i` and xi_end, the number of pixels added at "
+    "the end of axis `i`. This attribute cannot be used simultaneously with "
+    "auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.";
+constexpr const char* conv_auto_pad_doc_opset19 =
+    "auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where "
+    "default value is NOTSET, which means explicit padding is used. "
+    "SAME_UPPER or SAME_LOWER mean pad the input so that "
+    "`output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. "
+    "The padding is split between the two sides equally or almost equally (depending "
+    "on whether it is even or odd). In case the padding is an odd number, the extra "
+    "padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.";
+constexpr const char* conv_transpose_auto_pad_doc_opset19 =
+    "auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where "
+    "default value is NOTSET, which means explicit padding is used. "
+    "SAME_UPPER or SAME_LOWER mean pad the input so that "
+    "`output_shape[i] = input_shape[i] * strides[i]` for each axis `i`. "
+    "The padding is split between the two sides equally or almost equally (depending "
+    "on whether it is even or odd). In case the padding is an odd number, the extra "
+    "padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.";
+
+static void convPoolShapeInference_opset19(
+    InferenceContext& ctx,
+    bool use_dilation,
+    bool require_kernel_shape,
+    int input1Idx,
+    int input2Idx) {
+  // we need the first input shape for this inference.
+  if (!hasInputShape(ctx, input1Idx)) {
+    return;
+  }
+
+  // if kernel shape is an input (and not attribute)
+  // we need the shape of the second input.
+  if (!require_kernel_shape && !hasInputShape(ctx, input2Idx)) {
+    return;
+  }
+
+  auto input_shape = ctx.getInputType(input1Idx)->tensor_type().shape();
+  if (input_shape.dim_size() < 3) {
+    fail_shape_inference("Input tensor must have at least 3 dimensions");
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  // Only MaxPool and Conv support dilation. For
+  // simplicity of the code, we just treat the rest of them as having all-1s
+  // dilation.
+  std::vector<int64_t> dilations;
+  if (use_dilation && getRepeatedAttribute(ctx, "dilations", dilations)) {
+    if (dilations.size() != n_input_dims) {
+      fail_shape_inference("Attribute dilations has incorrect size");
+    }
+    if (std::any_of(dilations.begin(), dilations.end(), [](int64_t d) { return d <= 0; })) {
+      fail_shape_inference("Attribute dilations must only contain positive values");
+    }
+  } else {
+    dilations.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> strides = defs::nn::utils::getConvPoolStrides(ctx, n_input_dims);
+
+  std::vector<int64_t> kernel_shape;
+  if (getRepeatedAttribute(ctx, "kernel_shape", kernel_shape)) {
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute kernel_shape has incorrect size");
+    }
+  } else if (require_kernel_shape) {
+    fail_shape_inference("Attribute kernel_shape must be specified");
+  } else {
+    auto second_input_shape = ctx.getInputType(input2Idx)->tensor_type().shape();
+    for (int i = 2; i < second_input_shape.dim_size(); ++i) {
+      if (!second_input_shape.dim(i).has_dim_value()) {
+        return;
+      }
+      kernel_shape.push_back(second_input_shape.dim(i).dim_value());
+    }
+    // Reject weight/input spatial-rank mismatch; prevents OOB read of dilations/pads below.
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference(
+          "Number of spatial dimensions in the weight tensor (",
+          kernel_shape.size(),
+          ") does not match the number of spatial dimensions in the input tensor (",
+          n_input_dims,
+          ").");
+    }
+  }
+
+  if (std::any_of(kernel_shape.begin(), kernel_shape.end(), [](int64_t k) { return k <= 0; })) {
+    fail_shape_inference("Attribute kernel_shape must only contain positive values");
+  }
+
+  std::vector<int64_t> effective_kernel_shape = kernel_shape;
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
+    // accounting for dilation, how big is the kernel in this dimension
+    effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
+  }
+
+  std::vector<int64_t> pads;
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() != n_input_dims * 2) {
+      fail_shape_inference("Attribute pads has incorrect size");
+    }
+    if (std::any_of(pads.begin(), pads.end(), [](int64_t p) { return p < 0; })) {
+      fail_shape_inference("Attribute pads must not contain negative values");
+    }
+  } else {
+    pads.assign(n_input_dims * 2, 0);
+    const auto* const auto_pad_attr = ctx.getAttribute("auto_pad");
+    if ((nullptr != auto_pad_attr) && (auto_pad_attr->s() != "VALID")) {
+      auto input_dims_size = n_input_dims;
+      for (size_t i = 0; i < input_dims_size; ++i) {
+        int64_t residual = 0;
+        int64_t stride = strides[i];
+        if (stride > 1) {
+          if (!input_shape.dim(2 + i).has_dim_value()) {
+            continue;
+          }
+          residual = input_shape.dim(2 + i).dim_value();
+          if (residual < 0) {
+            continue;
+          }
+          residual %= stride;
+        }
+        if (i >= effective_kernel_shape.size()) {
+          fail_shape_inference("kernel shape should have ", input_dims_size, " values in ", ctx.getDisplayName(), ".");
+        }
+        int64_t total_pad = residual == 0 ? effective_kernel_shape[i] - stride : effective_kernel_shape[i] - residual;
+        total_pad = std::max<int64_t>(total_pad, 0);
+        int64_t half_pad_small = total_pad >> 1;
+        int64_t half_pad_big = total_pad - half_pad_small;
+        if (auto_pad_attr->s() == "SAME_UPPER") {
+          pads[i] = half_pad_small;
+          pads[i + input_dims_size] = half_pad_big;
+        } else if (auto_pad_attr->s() == "SAME_LOWER") {
+          pads[i] = half_pad_big;
+          pads[i + input_dims_size] = half_pad_small;
+        }
+      }
+    }
+  }
+
+  auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  if (require_kernel_shape) {
+    // add the first two dimensions from the input.
+    *output_shape->add_dim() = input_shape.dim(0);
+    *output_shape->add_dim() = input_shape.dim(1);
+  } else {
+    *output_shape->add_dim() = input_shape.dim(0);
+    const auto& second_input_shape = getInputShape(ctx, input2Idx);
+    if (second_input_shape.dim_size() < 1) {
+      fail_shape_inference("Second input tensor has wrong dimension");
+    }
+    *output_shape->add_dim() = second_input_shape.dim(0);
+  }
+
+  int kernel_shape_size = static_cast<int>(kernel_shape.size());
+  for (int i = 0; i < kernel_shape_size; ++i) {
+    auto* newdim = output_shape->add_dim();
+    if (!input_shape.dim(2 + i).has_dim_value()) {
+      continue;
+    }
+    // how big is the input, including padding
+    int64_t effective_input_size = input_shape.dim(2 + i).dim_value();
+    effective_input_size += pads[i];
+    effective_input_size += pads[i + kernel_shape_size];
+
+    // default is floor mode .i.e. ceil_mode is set to 0
+    auto ceil_mode = getAttribute(ctx, "ceil_mode", 0);
+
+    // how many times we can move the kernel from it's initial position, based
+    // on the stride
+    int64_t strided_kernel_positions = 0;
+
+    if (ceil_mode == 1)
+      strided_kernel_positions = static_cast<int64_t>(
+          std::ceil((effective_input_size - effective_kernel_shape[i]) / static_cast<float>(strides[i])));
+    else
+      strided_kernel_positions = (effective_input_size - effective_kernel_shape[i]) / strides[i];
+
+    // add in the initial position
+    newdim->set_dim_value(1 + strided_kernel_positions);
+  }
+
+  if (ctx.getNumOutputs() > 1) {
+    // MaxPool with two outputs case.
+    auto* second_output_shape = ctx.getOutputType(1)->mutable_tensor_type()->mutable_shape();
+    second_output_shape->CopyFrom(*output_shape);
+  }
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Dropout,
+    13,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_Dropout_ver13) + GenerateOptionalArgumentsDoc()))
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "data", "The input data as Tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "ratio",
+            "The ratio of random dropout, with value in [0, 1). If this input was not set, "
+            "or if it was set to 0, the output would be a simple copy of the input. "
+            "If it's non-zero, output will be a random dropout of the scaled input, which is typically "
+            "the case during training. It is an optional value, if not specified it will default to 0.5.",
+            "T1",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "training_mode",
+            "If set to true then it indicates dropout is being used for training. It is an optional value hence unless "
+            "specified explicitly, it is false. If it is false, ratio is ignored and the operation mimics inference mode where "
+            "nothing will be dropped from the input data and if mask is requested as output it will contain all ones.",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "output", "The output.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(1, "mask", "The output mask.", "T2", OpSchema::Optional, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint(
+            "T1",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input 'ratio' types to float tensors.")
+        .TypeConstraint("T2", {types::Bool}, "Constrain output 'mask' types to boolean tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasInputShape(ctx, 0)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+
+          if (ctx.getNumInputs() > 1 && hasInputShape(ctx, 1)) {
+            auto& ratio_input_shape = getInputShape(ctx, 1);
+            if (static_cast<int>(ratio_input_shape.dim_size()) != 0) {
+              fail_shape_inference("Ratio of Dropout must be a scalar.");
+            }
+          }
+
+          if (ctx.getNumInputs() > 2 && hasInputShape(ctx, 2)) {
+            auto& training_mode_input_shape = getInputShape(ctx, 2);
+            if (static_cast<int>(training_mode_input_shape.dim_size()) != 0) {
+              fail_shape_inference("training_mode of Dropout must be a scalar.");
+            }
+          }
+
+          if (ctx.getNumOutputs() == 2) {
+            updateOutputElemType(ctx, 1, TensorProto::BOOL);
+            if (hasNInputShapes(ctx, 1)) {
+              propagateShapeFromInputToOutput(ctx, 0, 1);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LpNormalization,
+    1,
+    OpSchema()
+        .Input(0, "input", "Input matrix", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Matrix after normalization", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .SetDoc(kDoc_LpNormalization_ver1)
+        .Attr(
+            "axis",
+            "The axis on which to apply normalization, -1 mean last axis.",
+            AttributeProto::INT,
+            static_cast<int64_t>(-1))
+        .Attr(
+            "p",
+            "The order of the normalization, only 1 or 2 are supported.",
+            AttributeProto::INT,
+            static_cast<int64_t>(2))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { propagateShapeAndTypeFromFirstInput(ctx); }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    InstanceNormalization,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_InstanceNormalization_ver6)
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Input(
+            0,
+            "input",
+            "Input data tensor from the previous operator; "
+            "dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non image case, the "
+            "dimensions are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the batch "
+            "size.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "scale",
+            "The input 1-dimensional scale tensor of size C.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "B",
+            "The input 1-dimensional bias tensor of size C.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "The output tensor of the same shape as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { propagateShapeAndTypeFromFirstInput(ctx); }));
+
+static void maxUnpoolShapeInference_opset11(InferenceContext& ctx) {
+  // we need at least two inputs to have a shape for this inference.
+  if (ctx.getNumInputs() != 2 && ctx.getNumInputs() != 3) {
+    fail_type_inference("MaxUnpool op must have either two or three inputs.");
+  }
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+  if (!hasInputShape(ctx, 0)) {
+    return; // If first input does not have shape, we cannot infer much.
+  }
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() < 2) {
+    fail_shape_inference("Input tensor X must have at least 2 dimensions.");
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  std::vector<int64_t> pads;
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() != n_input_dims * 2) {
+      fail_shape_inference("Attribute pads has incorrect size.");
+    }
+  } else {
+    pads.assign(n_input_dims * 2, 0);
+  }
+
+  std::vector<int64_t> strides;
+  if (getRepeatedAttribute(ctx, "strides", strides)) {
+    if (strides.size() != n_input_dims) {
+      fail_shape_inference("Attribute strides has incorrect size.");
+    }
+  } else {
+    strides.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> kernel_shape;
+  if (getRepeatedAttribute(ctx, "kernel_shape", kernel_shape)) {
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute kernel_shape has incorrect size.");
+    }
+  } else {
+    fail_shape_inference("Attribute kernel_shape must be specified.");
+  }
+
+  if (ctx.getNumInputs() == 3) {
+    // If the third input, output_size, is specified, then use that instead
+    // of inferring shape from inputs.
+    if (hasInputShape(ctx, 2)) {
+      const auto& output_shape = getInputShape(ctx, 2);
+      if (output_shape.dim_size() != 1) {
+        fail_type_inference("'output_shape' must be rank 1 tensor.");
+      }
+      if (output_shape.dim(0).has_dim_value() &&
+          static_cast<int>(output_shape.dim(0).dim_value()) != input_shape.dim_size()) {
+        fail_shape_inference("'output_shape' must have same number of elements as the shape of input tensor X.");
+      }
+    }
+    return; // 'output_shape' is specified as input. Actual shape will be
+            // determined at runtime.
+  }
+
+  if (!hasInputShape(ctx, 1)) {
+    return; // If indices input does not have shape, we cannot infer output shape.
+  }
+  auto indices_shape = ctx.getInputType(1)->tensor_type().shape();
+  if (indices_shape.dim_size() < 2) {
+    fail_shape_inference("Indices tensor I must have at least 2 dimensions.");
+  }
+
+  auto* final_output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  *final_output_shape->add_dim() = input_shape.dim(0);
+  *final_output_shape->add_dim() = indices_shape.dim(1); // channels should be the second dim of second input.
+
+  int kernel_shape_size = static_cast<int>(kernel_shape.size());
+  for (int i = 0; i < kernel_shape_size; ++i) {
+    auto* newdim = final_output_shape->add_dim();
+    if (!input_shape.dim(2 + i).has_dim_value()) {
+      continue;
+    }
+
+    int64_t newdim_value = strides[i] * (input_shape.dim(2 + i).dim_value() - 1);
+    newdim_value += kernel_shape[i];
+    newdim_value -= pads[i];
+    newdim_value -= pads[i + kernel_shape_size];
+
+    // add in the initial position
+    newdim->set_dim_value(newdim_value);
+  }
+}
+
+// For GlobalPool operations.
+static void globalPoolTypeShapeInference_opset1(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // needs at least one input with shape.
+  if (!hasNInputShapes(ctx, 1)) {
+    return;
+  }
+
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() < 2) {
+    return;
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  // (N, C, 1, 1, ..., 1)
+  auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+  *output_shape->add_dim() = input_shape.dim(0);
+  *output_shape->add_dim() = input_shape.dim(1);
+
+  for (size_t i = 0; i < n_input_dims; ++i) {
+    output_shape->add_dim()->set_dim_value(1);
+  }
+}
+
+static std::function<void(OpSchema&)> GlobalPoolingOpSchemaGenerator_opset1(const char* op_type, const char* op) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ Global{op_type} consumes an input tensor X and applies {op} pooling across
+ the values in the same channel. This is equivalent to {op_type} with kernel size
+ equal to the spatial dimension of input tensor.)DOC";
+        ReplaceAll(doc, "{op_type}", op_type);
+        ReplaceAll(doc, "{op}", op););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the width "
+        "of the data. For non image case, the dimensions are "
+        "in the form of (N x C x D1 x D2 ... Dn), "
+        "where N is the batch size.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from pooling across the input "
+        "tensor. The output tensor has the same rank as the input. "
+        "The first two dimensions of output shape are the same as "
+        "the input (N x C), while the other dimensions are all 1.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) { globalPoolTypeShapeInference_opset1(ctx); });
+  };
+}
+ONNX_OPERATOR_SET_SCHEMA(
+    GlobalAveragePool,
+    1,
+    OpSchema().FillUsing(GlobalPoolingOpSchemaGenerator_opset1("AveragePool", "average")));
+ONNX_OPERATOR_SET_SCHEMA(
+    GlobalMaxPool,
+    1,
+    OpSchema().FillUsing(GlobalPoolingOpSchemaGenerator_opset1("MaxPool", "max")));
+
+static void convTransposeShapeInference_opset11(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // we need at least two inputs to have a shape for this inference.
+  if (!hasNInputShapes(ctx, 2)) {
+    return;
+  }
+
+  int64_t group = getAttribute(ctx, "group", 1);
+  if (group <= 0) {
+    fail_shape_inference("Attribute group must be > 0 for ConvTranspose. group=", group, ".");
+  }
+
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() < 3) {
+    fail_shape_inference(
+        "Input tensor must have at least 3 dimensions (N x C x D1...Dn). Got: ", input_shape.dim_size());
+  }
+  const auto& input_channels_dim = input_shape.dim(1);
+  if (input_channels_dim.has_dim_value() && input_channels_dim.dim_value() % group != 0) {
+    fail_shape_inference(
+        "Input channels C must be divisible by group for ConvTranspose. C=",
+        input_channels_dim.dim_value(),
+        " group=",
+        group,
+        ".");
+  }
+
+  // Weight tensor (input 1) must also have at least 3 dimensions (C x M/group x k1...kn).
+  auto weight_shape = ctx.getInputType(1)->tensor_type().shape();
+  if (weight_shape.dim_size() < 3) {
+    fail_shape_inference(
+        "Weight tensor must have at least 3 dimensions (C x M/group x k1...kn). Got: ", weight_shape.dim_size());
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  std::vector<int64_t> dilations;
+  if (getRepeatedAttribute(ctx, "dilations", dilations)) {
+    if (dilations.size() != n_input_dims) {
+      fail_shape_inference("Attribute dilations has incorrect size");
+    }
+    if (std::any_of(dilations.begin(), dilations.end(), [](int64_t d) { return d <= 0; })) {
+      fail_shape_inference("Attribute dilations must only contain positive values");
+    }
+  } else {
+    dilations.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> strides;
+  if (getRepeatedAttribute(ctx, "strides", strides)) {
+    if (strides.size() != n_input_dims) {
+      fail_shape_inference("Attribute strides has incorrect size");
+    }
+    if (std::any_of(strides.begin(), strides.end(), [](int64_t s) { return s <= 0; })) {
+      fail_shape_inference("Attribute strides must only contain positive values");
+    }
+  } else {
+    strides.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> kernel_shape;
+  if (getRepeatedAttribute(ctx, "kernel_shape", kernel_shape)) {
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute kernel_shape has incorrect size");
+    }
+  } else {
+    for (int i = 2; i < weight_shape.dim_size(); ++i) {
+      if (!weight_shape.dim(i).has_dim_value()) {
+        return;
+      }
+      kernel_shape.push_back(weight_shape.dim(i).dim_value());
+    }
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Weight tensor spatial rank does not match input tensor spatial rank");
+    }
+  }
+
+  if (std::any_of(kernel_shape.begin(), kernel_shape.end(), [](int64_t k) { return k <= 0; })) {
+    fail_shape_inference("Attribute kernel_shape must only contain positive values");
+  }
+
+  std::vector<int64_t> effective_kernel_shape = kernel_shape;
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
+    // accounting for dilation, how big is the kernel in this dimension
+    effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
+  }
+
+  std::vector<int64_t> pads;
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() != n_input_dims * 2) {
+      fail_shape_inference("Attribute pads has incorrect size");
+    }
+    if (std::any_of(pads.begin(), pads.end(), [](int64_t p) { return p < 0; })) {
+      fail_shape_inference("Attribute pads must not contain negative values");
+    }
+    const auto* const auto_pad_attr = ctx.getAttribute("auto_pad");
+    if (nullptr != auto_pad_attr && auto_pad_attr->s() != "NOTSET") {
+      fail_shape_inference("The pads attribute cannot be used simultaneously with auto_pad attribute");
+    }
+  } else {
+    pads.assign(n_input_dims * 2, 0);
+    const auto* const auto_pad_attr = ctx.getAttribute("auto_pad");
+    if ((nullptr != auto_pad_attr) && (auto_pad_attr->s() != "VALID")) {
+      int input_dims_size = static_cast<int>(n_input_dims);
+      for (int i = 0; i < input_dims_size; ++i) {
+        int64_t total_pad = effective_kernel_shape[i] - strides[i];
+        total_pad = std::max<int64_t>(total_pad, 0);
+        int64_t half_pad_small = total_pad >> 1;
+        int64_t half_pad_big = total_pad - half_pad_small;
+        if (auto_pad_attr->s() == "SAME_UPPER") {
+          pads[i] = half_pad_small;
+          pads[i + input_dims_size] = half_pad_big;
+        } else if (auto_pad_attr->s() == "SAME_LOWER") {
+          pads[i] = half_pad_big;
+          pads[i + input_dims_size] = half_pad_small;
+        }
+      }
+    }
+  }
+
+  std::vector<int64_t> output_shape;
+  bool output_shape_presented = true;
+  if (getRepeatedAttribute(ctx, "output_shape", output_shape)) {
+    if (output_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute output_shape has incorrect size");
+    }
+    if (std::any_of(output_shape.begin(), output_shape.end(), [](int64_t s) { return s < 0; })) {
+      fail_shape_inference("Attribute output_shape must not contain negative values");
+    }
+  } else {
+    output_shape_presented = false;
+  }
+
+  std::vector<int64_t> output_padding;
+  if (getRepeatedAttribute(ctx, "output_padding", output_padding)) {
+    if (output_padding.size() != n_input_dims) { // Added only to one side.
+      fail_shape_inference("Attribute output_padding has incorrect size");
+    }
+    if (std::any_of(output_padding.begin(), output_padding.end(), [](int64_t p) { return p < 0; })) {
+      fail_shape_inference("Attribute output_padding must not contain negative values");
+    }
+  } else {
+    output_padding.assign(n_input_dims, 0);
+  }
+
+  auto* final_output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  *final_output_shape->add_dim() = input_shape.dim(0);
+  *final_output_shape->add_dim() = weight_shape.dim(1) * group; // channels should be the second dim of second input
+                                                                // multiply group.
+
+  int size_of_output = 0;
+  if (output_shape_presented) {
+    size_of_output = static_cast<int>(output_shape.size());
+    for (int i = 0; i < size_of_output; ++i) {
+      if (input_shape.dim(i + 2).has_dim_value()) {
+        if (output_shape[i] < input_shape.dim(i + 2).dim_value()) {
+          // TODO(ONNX): throw exception?
+          return; // output shape value cannot be smaller than the input shape
+                  // value
+        }
+      }
+      final_output_shape->add_dim()->set_dim_value(output_shape[i]);
+    }
+    return;
+  } else {
+    size_of_output = input_shape.dim_size() - 2;
+    for (int i = 0; i < size_of_output; ++i) {
+      if (input_shape.dim(i + 2).has_dim_value()) {
+        int64_t output_shape_dim = strides[i] * (input_shape.dim(i + 2).dim_value() - 1) + output_padding[i] +
+            effective_kernel_shape[i] - pads[i] - pads[i + n_input_dims];
+        final_output_shape->add_dim()->set_dim_value(output_shape_dim);
+      } else {
+        final_output_shape->add_dim();
+      }
+    }
+    return;
+  }
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DeformConv,
+    19,
+    OpSchema()
+        .SetDoc(kDoc_DeformConv_ver19)
+        .Input(
+            0,
+            "X",
+            "Input data tensor. For 2D image data, it has shape (N, C, H, W) where N is the batch size, "
+            "C is the number of input channels, and H and W are the height and width. "
+            "In general, the shape is (N, C, D1, D2, ... , Dn) for n-dimensional data, where "
+            "D1 to Dn are the spatial dimension sizes. Most common use cases have n = 2 or 3.",
+            "T")
+        .Input(
+            1,
+            "W",
+            "Weight tensor that will be used in the convolutions. It has shape (oC, C/group, kH, kW), "
+            "where oC is the number of output channels and kH and kW are the kernel height and width. "
+            "For more than 2 dimensions, it has shape (oC, C/group, k1, k2, ... , kn).",
+            "T")
+        .Input(
+            2,
+            "offset",
+            "Offset tensor denoting the offset for the sampling locations in the convolution kernel. "
+            "It has shape (N, offset_group * kH * kW * 2, oH, oW) for 2D data or "
+            "(N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Use linear interpolation"
+            "for fractional offset values. Sampling locations outside of the padded input tensor gives zero.",
+            "T")
+        .Input(
+            3,
+            "B",
+            "Optional 1D bias of length oC to be added to the convolution. Default is a tensor of zeros.",
+            "T",
+            OpSchema::Optional)
+        .Input(
+            4,
+            "mask",
+            "The mask tensor to be applied to each position in the convolution kernel. "
+            "It has shape (N, offset_group * kH * kW, oH, oW) for 2D data or "
+            "(N, offset_group * k1 * k2 * ... * kn * n, o1, o2, ... , on) for nD data. Default is a "
+            "tensor of ones.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "Y",
+            "Output data tensor that contains the result of convolution. It has shape (N, oC, oH, oW) "
+            "for 2D data or (N, oC, o1, o2, ..., on) for nD data",
+            "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .Attr(
+            "dilations",
+            "Dilation value along each spatial axis of the kernel. Default is 1 along each axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "group",
+            "Number of groups the input and output channels, C and oC, are divided into. C and oC must both "
+            "be divisible by group. Default is 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "kernel_shape",
+            "Shape of the convolution kernel. If not present, it is inferred from the shape of input W.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "offset_group",
+            "Number of groups of offset. C must be divisible by offset_group. Default is 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "pads",
+            "Padding for the beginning and end along each spatial axis. The values represent the number of pixels "
+            "added to the beginning and end of the corresponding axis and can take any nonnegative value. "
+            "The format should be as follows: [x1_begin, x2_begin, ..., x1_end, x2_end, ...], where xi_begin "
+            "is the number of pixels added at the beginning of axis `i` and xi_end is the number of pixels "
+            "added at the end of axis `i`. Default is 0 along each axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "strides",
+            "Stride along each spatial axis. Default is 1 along each axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          convPoolShapeInference_opset19(ctx, true, false, 0, 1);
+        }));
+
+static std::function<void(OpSchema&)> ConvTransposeOpSchemaGenerator_opset11(const char* filter_desc) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+The convolution transpose operator consumes an input tensor and {filter_desc},
+and computes the output.
+
+If the pads parameter is provided the shape of the output is calculated via the following equation:
+
+  output_shape[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - pads[start_i] - pads[end_i]
+
+output_shape can also be explicitly specified in which case pads values are auto generated using these equations:
+
+  total_padding[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - output_shape[i]
+  If (auto_pads == SAME_UPPER): pads[start_i] = total_padding[i]/2; pads[end_i] = total_padding[i] - (total_padding[i]/2)
+  Else: pads[start_i] = total_padding[i] - (total_padding[i]/2); pads[end_i] = (total_padding[i]/2).
+
+    )DOC";
+        ReplaceAll(doc, "{filter_desc}", filter_desc););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from previous layer; has size (N x C x H x W)"
+        ", where N is the batch size, C is the number of channels, and"
+        " H and W are the height and width. Note that this is for the 2D image. "
+        "Otherwise the size is (N x C x D1 x D2 ... x Dn)",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        1,
+        "W",
+        "The weight tensor that will be used in the "
+        "convolutions; has size (C x M/group x kH x kW), where C "
+        "is the number of channels, and kH and kW are the "
+        "height and width of the kernel, and M is the number "
+        "of feature maps. For more than 2 dimensions, the "
+        "weight shape will be (C x M/group x k1 x k2 x ... x kn), "
+        "where (k1 x k2 x ... x kn) is the dimension of the kernel. "
+        "The number of channels in the output should be equal to W.shape[1] * group "
+        "(assuming zero based indices of the shape array)",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        2,
+        "B",
+        "Optional 1D bias to be added to the convolution, has size of M.",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor that contains the result of the convolution. The "
+        "output dimensions are functions of the kernel size, stride size, "
+        "pad lengths and group count. "
+        "The number of channels in the output should be equal to W.shape[1] * group "
+        "(assuming zero based indices of the shape array)",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.Attr(
+        "kernel_shape",
+        "The shape of the convolution kernel. If not present, should be inferred from input W.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "output_shape",
+        "The shape of the output can be explicitly set which will cause pads values to be auto generated. If output_shape is specified "
+        "pads values are ignored. See doc for details for equations to generate pads. Note that the output_shape attribute value "
+        "should not include dimensions for batch size and channels, which are automatically inferred.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "output_padding",
+        "Additional elements added to the side with higher coordinate indices in the output. "
+        "Each padding value in \"output_padding\" must be less than the corresponding stride/dilation dimension. "
+        "By default, this attribute is a zero vector. "
+        "Note that this attribute doesn't directly affect the computed output values. "
+        "It only controls the selection of the computed values, "
+        "so changing this attribute only adds or removes output elements. "
+        "If \"output_shape\" is explicitly provided, "
+        "\"output_padding\" does not contribute additional size to \"output_shape\" but "
+        "participates in the computation of the needed padding amount. "
+        "This is also called adjs or adjustment in some frameworks.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "dilations",
+        "dilation value along each spatial axis of the filter. If not present, the dilation defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", conv_transpose_auto_pad_doc_opset19, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc_opset11, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "group",
+        "number of groups input channels and output channels are divided into.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) { convTransposeShapeInference_opset11(ctx); });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(ConvTranspose, 11, OpSchema().FillUsing(ConvTransposeOpSchemaGenerator_opset11("a filter")));
+
+static std::function<void(OpSchema&)> ConvOpSchemaGenerator_opset11(const char* filter_desc) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+The convolution operator consumes an input tensor and {filter_desc}, and
+computes the output.)DOC";
+        ReplaceAll(doc, "{filter_desc}", filter_desc););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from previous layer; "
+        "has size (N x C x H x W), where N is the batch size, "
+        "C is the number of channels, and H and W are the "
+        "height and width. Note that this is for the 2D image. "
+        "Otherwise the size is (N x C x D1 x D2 ... x Dn). "
+        "Optionally, if dimension denotation is "
+        "in effect, the operation expects input data tensor "
+        "to arrive with the dimension denotation of [DATA_BATCH, "
+        "DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        1,
+        "W",
+        "The weight tensor that will be used in the "
+        "convolutions; has size (M x C/group x kH x kW), where C "
+        "is the number of channels, and kH and kW are the "
+        "height and width of the kernel, and M is the number "
+        "of feature maps. For more than 2 dimensions, the "
+        "kernel shape will be (M x C/group x k1 x k2 x ... x kn), "
+        "where (k1 x k2 x ... kn) is the dimension of the kernel. "
+        "Optionally, if dimension denotation is in effect, "
+        "the operation expects the weight tensor to arrive "
+        "with the dimension denotation of [FILTER_OUT_CHANNEL, "
+        "FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. "
+        "Assuming zero based indices for the shape array, "
+        "X.shape[1] == (W.shape[1] * group) == C and "
+        "W.shape[0] mod G == 0. Or in other words "
+        "FILTER_IN_CHANNEL multiplied by the number of groups "
+        "should be equal to DATA_CHANNEL and the number of "
+        "feature maps M should be a multiple of the number of "
+        "groups G.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        2,
+        "B",
+        "Optional 1D bias to be added to the convolution, has size of M.",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor that contains the result of the "
+        "convolution. The output dimensions are functions "
+        "of the kernel size, stride size, and pad lengths.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.Attr(
+        "kernel_shape",
+        "The shape of the convolution kernel. If not present, should be inferred from input W.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "dilations",
+        "dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults is 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", conv_auto_pad_doc_opset19, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc_opset11, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "group",
+        "number of groups input channels and output channels are divided into.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      convPoolShapeInference_opset19(ctx, true, false, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(Conv, 11, OpSchema().FillUsing(ConvOpSchemaGenerator_opset11("a filter")));
+
+static void roiPoolTypeShapeInference_opset1(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // rois is the second input.
+  if (!hasNInputShapes(ctx, 2)) {
+    return;
+  }
+
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  auto rios_shape = ctx.getInputType(1)->tensor_type().shape();
+
+  if (input_shape.dim_size() < 4) {
+    fail_shape_inference("Input tensor must have at least 4 dimensions");
+  }
+  if (rios_shape.dim_size() != 2) {
+    fail_shape_inference("RoIs tensor must have 2 dimensions");
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  std::vector<int64_t> pooled_shape;
+  if (getRepeatedAttribute(ctx, "pooled_shape", pooled_shape)) {
+    if (pooled_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute pooled_shape has incorrect length");
+    }
+    for (auto dim : pooled_shape) {
+      if (dim <= 0) {
+        fail_shape_inference("Attribute pooled_shape must only contain positive values");
+      }
+    }
+  } else {
+    fail_shape_inference("Attribute pooled_shape must be specified");
+  }
+
+  // (num_rois, channels, pooled_shape[0], pooled_shape[1])
+  auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  *output_shape->add_dim() = rios_shape.dim(0);
+  *output_shape->add_dim() = input_shape.dim(1);
+  output_shape->add_dim()->set_dim_value(pooled_shape[0]);
+  output_shape->add_dim()->set_dim_value(pooled_shape[1]);
+}
+
+static std::function<void(OpSchema&)> RoiPoolOpSchemaGenerator_opset1(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ ROI {name} pool consumes an input tensor X and region of interests (RoIs) to
+ apply {name} pooling across each RoI, to produce output 4-D tensor of shape
+ (num_rois, channels, pooled_shape[0], pooled_shape[1]).)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc);
+    schema.Attr("pooled_shape", "ROI pool output shape (height, width).", AttributeProto::INTS);
+    schema.Attr(
+        "spatial_scale",
+        "Multiplicative spatial scale factor to translate ROI coordinates from their input scale to the scale used when pooling.",
+        AttributeProto::FLOAT,
+        1.f);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        1,
+        "rois",
+        "RoIs (Regions of Interest) to pool over. Should "
+        "be a 2-D tensor of shape (num_rois, 5) given as "
+        "[[batch_id, x1, y1, x2, y2], ...].",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Output(
+        0,
+        "Y",
+        "RoI pooled output 4-D tensor of shape (num_rois, channels, pooled_shape[0], pooled_shape[1]).",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) { roiPoolTypeShapeInference_opset1(ctx); });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(MaxRoiPool, 1, OpSchema().FillUsing(RoiPoolOpSchemaGenerator_opset1("max")));
+
+static std::function<void(OpSchema&)> LpPoolOpSchemaGenerator_opset18(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ {name} consumes an input tensor X and applies Lp pooling across
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ Lp pooling consisting of computing the Lp norm on all values of a subset
+ of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing. The output spatial shape will be following:
+ ```
+ output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+ ```
+ or
+ ```
+ output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+ ```
+ if ceil_mode is enabled `pad_shape[i]` is the sum of pads along axis `i`.
+
+ `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+ ```
+ VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+ ```
+ And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+ ```
+ pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]
+ ```)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc);
+    schema.Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "dilations",
+        "dilation value along each spatial axis of the filter. If not present, the dilation defaults is 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", conv_auto_pad_doc_opset19, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc_opset11, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "p", "p value of the Lp norm used to pool over the input data.", AttributeProto::INT, static_cast<int64_t>(2));
+    schema.Attr(
+        "ceil_mode",
+        "Whether to use ceil or floor (default) to compute the output shape.",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data. For non image case, the "
+        "dimensions are in the form of "
+        "(N x C x D1 x D2 ... Dn), where N is the "
+        "batch size.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from Lp pooling across the input "
+        "tensor. Dimensions will vary based on various kernel, stride, and pad "
+        "sizes.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      convPoolShapeInference_opset19(ctx, true, true, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(LpPool, 18, OpSchema().FillUsing(LpPoolOpSchemaGenerator_opset18("LpPool")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MaxUnpool,
+    11,
+    OpSchema()
+        .SetDoc(kDoc_MaxUnpool_ver11)
+        .Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS)
+        .Attr(
+            "strides",
+            "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("pads", pads_doc_opset11, AttributeProto::INTS, OPTIONAL_VALUE)
+        .Input(
+            0,
+            "X",
+            "Input data tensor that has to be unpooled. "
+            "This tensor is typically the first output of the MaxPool op."
+            "Dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non-image case, the "
+            "dimensions are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the batch "
+            "size. Optionally, if dimension denotation is "
+            "in effect, the operation expects the input "
+            "data tensor to arrive with the dimension denotation "
+            "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "I",
+            "Input data tensor containing the indices corresponding to "
+            "elements in the first input tensor X."
+            "This tensor is typically the second output of the MaxPool op."
+            "Dimensions must be the same as input tensor X. "
+            "The indices are linear, i.e. computed considering the tensor as flattened 1-D tensor, "
+            "assuming row-major storage. Also, the linear indices should not consider padding. "
+            "So the values in indices are in the range [0, N x C x D1 x ... x Dn).",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "output_shape",
+            "The shape of the output can be explicitly set which will cause pads values to be auto generated. If 'output_shape' is specified, "
+            "'pads' values are ignored.",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output data tensor that contains the result of the unpooling.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain index tensor to int64")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { maxUnpoolShapeInference_opset11(ctx); }));
+
+static std::vector<std::string> GetSupportedDataTypesForPoolingOps_opset19(bool supports8bit) {
+  if (supports8bit) {
+    return {types::Float16, types::Float, types::Double, types::Int8, types::UInt8};
+  }
+  return {types::Float16, types::Float, types::Double};
+}
+
+static std::function<void(OpSchema&)> PoolOpSchemaGenerator_opset19(
+    const char* name,
+    const char* opName,
+    const char* additionalDescription,
+    bool use_dilation,
+    bool supports8bit = false) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ {name} consumes an input tensor X and applies {opName} pooling across
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ {opName} pooling consisting of computing the {opName} on all values of a
+ subset of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing. The output spatial shape is calculated differently
+ depending on whether explicit padding is used, where pads is employed, or auto padding is used, where auto_pad is utilized.
+ With explicit padding (https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html?highlight=maxpool#torch.nn.MaxPool2d):
+ ```
+ output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+ ```
+ or
+ ```
+ output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - dilation[i] * (kernel_shape[i] - 1) - 1) / strides_spatial_shape[i] + 1)
+ ```
+ if ceil_mode is enabled. `pad_shape[i]` is the sum of pads along axis `i`.
+
+ `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+ ```
+ VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+ ```
+ or when ceil_mode is disabled (https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D):
+ ```
+ VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i]) + 1
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor((input_spatial_shape[i] - 1) / strides_spatial_shape[i]) + 1
+ ```
+ And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+ ```
+ pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]
+ ```
+ {additionalDescription}
+ )DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{opName}", opName);
+        ReplaceAll(doc, "{additionalDescription}", additionalDescription);
+        ReplaceAll(
+            doc,
+            "{kernelSpatialShape}",
+            use_dilation ? "((kernel_spatial_shape[i] - 1) * dilations[i] + 1)" : "kernel_spatial_shape[i]"););
+    schema.SetDoc(doc);
+    schema.Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", conv_auto_pad_doc_opset19, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc_opset11, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "ceil_mode",
+        "Whether to use ceil or floor (default) to compute the output shape.",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data. For non image case, the "
+        "dimensions are in the form of "
+        "(N x C x D1 x D2 ... Dn), where N is the batch "
+        "size. Optionally, if dimension denotation is "
+        "in effect, the operation expects the input "
+        "data tensor to arrive with the dimension denotation "
+        "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from average or max pooling across "
+        "the input tensor. Dimensions will vary based "
+        "on various kernel, stride, and pad sizes. Floor value of "
+        "the dimension is used",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T",
+        GetSupportedDataTypesForPoolingOps_opset19(supports8bit),
+        supports8bit ? "Constrain input and output types to float and 8 bit tensors."
+                     : "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([use_dilation](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (ctx.getNumOutputs() > 1) {
+        // MaxPool with two outputs case.
+        auto* output_type = ctx.getOutputType(1);
+        if (output_type->value_case() == TypeProto::kTensorType ||
+            output_type->value_case() == TypeProto::VALUE_NOT_SET) {
+          output_type->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+        }
+      }
+      convPoolShapeInference_opset19(ctx, use_dilation, true, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    AveragePool,
+    19,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator_opset19(
+            "AveragePool",
+            "average",
+            "The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).",
+            true, /* use_dilation: dilations attribute has been added in opset 19. */
+            false /* supports8bit: does not support 8bit. */))
+        .Attr(
+            "dilations",
+            "Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "count_include_pad",
+            "Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0)));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MaxPool,
+    12,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator_opset19(
+            "MaxPool",
+            "max",
+            "The output of each pooling window is maximum number of elements exclude pad. ",
+            true,
+            true))
+        .Attr(
+            "storage_order",
+            "The storage order of the tensor. 0 is row major, and 1 is column major. "
+            "This attribute is used only to convert an n-tuple index value into "
+            "a single integer value for producing the second output. ",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "dilations",
+            "Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Output(
+            1,
+            "Indices",
+            "Indices tensor from max pooling across the input tensor. "
+            "The dimensions of indices are the same as output tensor. "
+            "The values in indices of are the indices of the selected values during pooling. "
+            "The indices are computed as flatten 1-D tensor, "
+            "and the indices do not consider padding. "
+            "So the values in indices are in [0, N x C x D1 x ... x Dn).",
+            "I",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("I", {types::Int64}, "Constrain index tensor to int64"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Dropout,
+    12,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_Dropout_ver13) + GenerateOptionalArgumentsDoc()))
+        .Attr(
+            "seed",
+            "(Optional) Seed to the random generator, if not specified we will auto generate one.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "data", "The input data as Tensor.", "T")
+        .Input(
+            1,
+            "ratio",
+            "The ratio of random dropout, with value in [0, 1). If this input was not set, "
+            "or if it was set to 0, the output would be a simple copy of the input. "
+            "If it's non-zero, output will be a random dropout of the scaled input, which is typically "
+            "the case during training. It is an optional value, if not specified it will default to 0.5.",
+            "T1",
+            OpSchema::Optional)
+        .Input(
+            2,
+            "training_mode",
+            "If set to true then it indicates dropout is being used for training. It is an optional value hence unless "
+            "specified explicitly, it is false. If it is false, ratio is ignored and the operation mimics inference mode where "
+            "nothing will be dropped from the input data and if mask is requested as output it will contain all ones.",
+            "T2",
+            OpSchema::Optional)
+        .Output(0, "output", "The output.", "T")
+        .Output(1, "mask", "The output mask.", "T2", OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint(
+            "T1",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input 'ratio' types to float tensors.")
+        .TypeConstraint("T2", {types::Bool}, "Constrain output 'mask' types to boolean tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasInputShape(ctx, 0)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+
+          if (ctx.getNumInputs() > 1 && hasInputShape(ctx, 1)) {
+            auto& ratio_input_shape = getInputShape(ctx, 1);
+            if (static_cast<int>(ratio_input_shape.dim_size()) != 0) {
+              fail_shape_inference("Ratio of Dropout must be a scalar.");
+            }
+          }
+
+          if (ctx.getNumInputs() > 2 && hasInputShape(ctx, 2)) {
+            auto& training_mode_input_shape = getInputShape(ctx, 2);
+            if (static_cast<int>(training_mode_input_shape.dim_size()) != 0) {
+              fail_shape_inference("training_mode of Dropout must be a scalar.");
+            }
+          }
+
+          if (ctx.getNumOutputs() == 2) {
+            updateOutputElemType(ctx, 1, TensorProto::BOOL);
+            if (hasNInputShapes(ctx, 1)) {
+              propagateShapeFromInputToOutput(ctx, 0, 1);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Flatten,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_Flatten_ver24)
+        .Input(0, "input", "A tensor of rank >= axis.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "A 2D tensor with the contents of the input tensor, "
+            "with input dimensions up to axis flattened to the outer dimension "
+            "of the output and remaining input dimensions flattened into the inner "
+            "dimension of the output.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir12(),
+            "Constrain input and output to all tensor types up to IRv12.")
+        .Attr(
+            "axis",
+            "Indicate up to which input dimensions "
+            "(exclusive) should be flattened to the outer dimension of the output. "
+            "The value for axis must be in the range [-r, r], where r is the rank of the input tensor. "
+            "Negative value means counting dimensions from the back. "
+            "When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), "
+            "where the shape of the input tensor is (d_0, d_1, ... d_n). ",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int rank = static_cast<int>(input_shape.dim_size());
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+          if (axis < 0) {
+            axis += rank;
+          }
+          if (axis > rank || axis < 0) {
+            fail_shape_inference("Invalid value(", axis, ") for attribute 'axis'");
+          }
+          updateOutputShape(ctx, 0, {multiplyDims(input_shape, 0, axis), multiplyDims(input_shape, axis, rank)});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Flatten,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_Flatten_ver24)
+        .Input(0, "input", "A tensor of rank >= axis.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "A 2D tensor with the contents of the input tensor, "
+            "with input dimensions up to axis flattened to the outer dimension "
+            "of the output and remaining input dimensions flattened into the inner "
+            "dimension of the output.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir11(),
+            "Constrain input and output to all tensor types up to IRv10.")
+        .Attr(
+            "axis",
+            "Indicate up to which input dimensions "
+            "(exclusive) should be flattened to the outer dimension of the output. "
+            "The value for axis must be in the range [-r, r], where r is the rank of the input tensor. "
+            "Negative value means counting dimensions from the back. "
+            "When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), "
+            "where the shape of the input tensor is (d_0, d_1, ... d_n). ",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int rank = static_cast<int>(input_shape.dim_size());
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+          if (axis < 0) {
+            axis += rank;
+          }
+          if (axis > rank || axis < 0) {
+            fail_shape_inference("Invalid value(", axis, ") for attribute 'axis'");
+          }
+          updateOutputShape(ctx, 0, {multiplyDims(input_shape, 0, axis), multiplyDims(input_shape, axis, rank)});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Flatten,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_Flatten_ver24)
+        .Input(0, "input", "A tensor of rank >= axis.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "A 2D tensor with the contents of the input tensor, "
+            "with input dimensions up to axis flattened to the outer dimension "
+            "of the output and remaining input dimensions flattened into the inner "
+            "dimension of the output.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir10(),
+            "Constrain input and output to all tensor types up to IRv10.")
+        .Attr(
+            "axis",
+            "Indicate up to which input dimensions "
+            "(exclusive) should be flattened to the outer dimension of the output. "
+            "The value for axis must be in the range [-r, r], where r is the rank of the input tensor. "
+            "Negative value means counting dimensions from the back. "
+            "When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), "
+            "where the shape of the input tensor is (d_0, d_1, ... d_n). ",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int rank = static_cast<int>(input_shape.dim_size());
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+          if (axis < 0) {
+            axis += rank;
+          }
+          if (axis > rank || axis < 0) {
+            fail_shape_inference("Invalid value(", axis, ") for attribute 'axis'");
+          }
+          updateOutputShape(ctx, 0, {multiplyDims(input_shape, 0, axis), multiplyDims(input_shape, axis, rank)});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Flatten,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Flatten_ver24)
+        .Input(0, "input", "A tensor of rank >= axis.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "A 2D tensor with the contents of the input tensor, "
+            "with input dimensions up to axis flattened to the outer dimension "
+            "of the output and remaining input dimensions flattened into the inner "
+            "dimension of the output.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output to all tensor types.")
+        .Attr(
+            "axis",
+            "Indicate up to which input dimensions "
+            "(exclusive) should be flattened to the outer dimension of the output. "
+            "The value for axis must be in the range [-r, r], where r is the rank of the input tensor. "
+            "Negative value means counting dimensions from the back. "
+            "When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), "
+            "where the shape of the input tensor is (d_0, d_1, ... d_n). ",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int rank = static_cast<int>(input_shape.dim_size());
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+          if (axis < 0) {
+            axis += rank;
+          }
+          if (axis > rank || axis < 0) {
+            fail_shape_inference("Invalid value(", axis, ") for attribute 'axis'");
+          }
+          updateOutputShape(ctx, 0, {multiplyDims(input_shape, 0, axis), multiplyDims(input_shape, axis, rank)});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Flatten,
+    11,
+    OpSchema()
+        .SetDoc(kDoc_Flatten_ver24)
+        .Input(0, "input", "A tensor of rank >= axis.", "T")
+        .Output(
+            0,
+            "output",
+            "A 2D tensor with the contents of the input tensor, "
+            "with input dimensions up to axis flattened to the outer dimension "
+            "of the output and remaining input dimensions flattened into the inner "
+            "dimension of the output.",
+            "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output to all tensor types.")
+        .Attr(
+            "axis",
+            "Indicate up to which input dimensions "
+            "(exclusive) should be flattened to the outer dimension of the output. "
+            "The value for axis must be in the range [-r, r], where r is the rank of the input tensor. "
+            "Negative value means counting dimensions from the back. "
+            "When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), "
+            "where the shape of the input tensor is (d_0, d_1, ... d_n). ",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int rank = static_cast<int>(input_shape.dim_size());
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+          if (axis < 0) {
+            axis += rank;
+          }
+          if (axis > rank || axis < 0) {
+            fail_shape_inference("Invalid value(", axis, ") for attribute 'axis'");
+          }
+          updateOutputShape(ctx, 0, {multiplyDims(input_shape, 0, axis), multiplyDims(input_shape, axis, rank)});
+        }));
+
+static constexpr const char* LRN_ver1_doc = R"DOC(
+Local Response Normalization proposed in the [AlexNet paper](https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf).
+It normalizes over local input regions.
+The local region is defined across the channels. For an element X[n, c, d1, ..., dk] in a tensor
+of shape (N x C x D1 x D2, ..., Dk), its region is
+{X[n, i, d1, ..., dk] | max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2))}.
+
+square_sum[n, c, d1, ..., dk] = sum(X[n, i, d1, ..., dk] ^ 2),
+where max(0, c - floor((size - 1) / 2)) <= i <= min(C - 1, c + ceil((size - 1) / 2)).
+
+Y[n, c, d1, ..., dk] = X[n, c, d1, ..., dk] / (bias + alpha / size * square_sum[n, c, d1, ..., dk] ) ^ beta
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LRN,
+    1,
+    OpSchema()
+        .Attr("size", "The number of channels to sum over", AttributeProto::INT)
+        .Attr("alpha", "Scaling parameter.", AttributeProto::FLOAT, 0.0001f)
+        .Attr("beta", "The exponent.", AttributeProto::FLOAT, 0.75f)
+        .Attr("bias", "", AttributeProto::FLOAT, 1.0f)
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non image case, the "
+            "dimensions are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the batch "
+            "size. Optionally, if dimension denotation is "
+            "in effect, the operation expects the input "
+            "data tensor to arrive with the dimension denotation "
+            "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+            "T")
+        .Output(0, "Y", "Output tensor, which has the shape and type as input tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output "
+            " types to float tensors.")
+        .SetDoc(LRN_ver1_doc)
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* mvn_ver9_doc = R"DOC(
+      A MeanVarianceNormalization Function: Perform mean variance normalization
+      on the input tensor X using formula: <br/> ``` (X-EX)/sqrt(E(X-EX)^2) ```
+)DOC";
+
+static const std::vector<int64_t> old_mvn_default_axes = {0, 2, 3};
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MeanVarianceNormalization,
+    9,
+    OpSchema()
+        .SetDoc(mvn_ver9_doc)
+        .Input(0, "X", "Input tensor", "T")
+        .Output(0, "Y", "Output tensor", "T")
+        .Attr(
+            "axes",
+            "A list of integers, along which to reduce. The default is to "
+            "calculate along axes [0,2,3] for calculating mean and variance "
+            "along each channel. Two variables with the same C-coordinate "
+            "are associated with the same mean and variance.",
+            AttributeProto::INTS,
+            old_mvn_default_axes)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to all numeric tensors.")
+        .FunctionBody(
+            FunctionBodyHelper::BuildNodes(
+                {// nodes: {outputs, op, inputs, attributes}
+                 FunctionBodyHelper::Const<float>("Exponent", 2.0f),
+                 FunctionBodyHelper::Const<float>("Epsilon", static_cast<float>(1e-9)),
+                 {{"X_RM"}, "ReduceMean", {"X"}, {MakeRefAttribute("axes", AttributeProto::INTS)}},
+                 {{"EX_squared"}, "Pow", {"X_RM", "Exponent"}},
+                 {{"X_squared"}, "Pow", {"X", "Exponent"}},
+                 {{"E_Xsquared"}, "ReduceMean", {"X_squared"}, {MakeRefAttribute("axes", AttributeProto::INTS)}},
+                 {{"Variance"}, "Sub", {"E_Xsquared", "EX_squared"}},
+                 {{"STD"}, "Sqrt", {"Variance"}},
+                 {{"X_variance"}, "Sub", {"X", "X_RM"}},
+                 {{"Processed_STD"}, "Add", {"STD", "Epsilon"}},
+                 {{"Y"}, "Div", {"X_variance", "Processed_STD"}}})));
+
+constexpr const char* pads_doc2 =
+    "Padding for the beginning and ending along each spatial axis, it can take any value greater "
+    "than or equal to 0. The value represent the number of pixels added to the beginning "
+    "and end part of the corresponding axis. `pads` format should be as follow "
+    "[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels "
+    "added at the beginning of axis `i` and xi_end, the number of pixels added at "
+    "the end of axis `i`. This attribute cannot be used simultaneously with "
+    "auto_pad attribute. If not present, the padding defaults to 0 along start and end of each spatial axis.";
+constexpr const char* auto_pad_doc2 =
+    "auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where "
+    "default value is NOTSET, which means explicit padding is used. "
+    "SAME_UPPER or SAME_LOWER mean pad the input so that the output spatial size match the input."
+    "In case of odd number add the extra padding at the end for SAME_UPPER and at the "
+    "beginning for SAME_LOWER. VALID mean no padding.";
+constexpr const char* auto_pad_doc3 =
+    "auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where "
+    "default value is NOTSET, which means explicit padding is used. "
+    "SAME_UPPER or SAME_LOWER mean pad the input so that "
+    "`output_shape[i] = ceil(input_shape[i] / strides[i])` for each axis `i`. "
+    "The padding is split between the two sides equally or almost equally (depending "
+    "on whether it is even or odd). In case the padding is an odd number, the extra "
+    "padding is added at the end for SAME_UPPER and at the beginning for SAME_LOWER.";
+
+static void convPoolShapeInference_opset1_to_11(
+    InferenceContext& ctx,
+    bool use_dilation,
+    bool require_kernel_shape,
+    int input1Idx,
+    int input2Idx) {
+  // we need the first input shape for this inference.
+  if (!hasInputShape(ctx, input1Idx)) {
+    return;
+  }
+
+  // if kernel shape is an input (and not attribute)
+  // we need the shape of the second input.
+  if (!require_kernel_shape && !hasInputShape(ctx, input2Idx)) {
+    return;
+  }
+
+  auto input_shape = ctx.getInputType(input1Idx)->tensor_type().shape();
+  if (input_shape.dim_size() < 3) {
+    fail_shape_inference("Input tensor must have at least 3 dimensions");
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  // Only MaxPool and Conv support dilation. For
+  // simplicity of the code, we just treat the rest of them as having all-1s
+  // dilation.
+  std::vector<int64_t> dilations;
+  if (use_dilation && getRepeatedAttribute(ctx, "dilations", dilations)) {
+    if (dilations.size() != n_input_dims) {
+      fail_shape_inference("Attribute dilations has incorrect size");
+    }
+    if (std::any_of(dilations.begin(), dilations.end(), [](int64_t d) { return d <= 0; })) {
+      fail_shape_inference("Attribute dilations must only contain positive values");
+    }
+  } else {
+    dilations.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> strides = defs::nn::utils::getConvPoolStrides(ctx, n_input_dims);
+
+  std::vector<int64_t> kernel_shape;
+  if (getRepeatedAttribute(ctx, "kernel_shape", kernel_shape)) {
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute kernel_shape has incorrect size");
+    }
+  } else if (require_kernel_shape) {
+    fail_shape_inference("Attribute kernel_shape must be specified");
+  } else {
+    auto second_input_shape = ctx.getInputType(input2Idx)->tensor_type().shape();
+    for (int i = 2; i < second_input_shape.dim_size(); ++i) {
+      if (!second_input_shape.dim(i).has_dim_value()) {
+        return;
+      }
+      kernel_shape.push_back(second_input_shape.dim(i).dim_value());
+    }
+    // Reject weight/input spatial-rank mismatch; prevents OOB read of dilations/pads below.
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference(
+          "Number of spatial dimensions in the weight tensor (",
+          kernel_shape.size(),
+          ") does not match the number of spatial dimensions in the input tensor (",
+          n_input_dims,
+          ").");
+    }
+  }
+
+  if (std::any_of(kernel_shape.begin(), kernel_shape.end(), [](int64_t k) { return k <= 0; })) {
+    fail_shape_inference("Attribute kernel_shape must only contain positive values");
+  }
+
+  std::vector<int64_t> effective_kernel_shape = kernel_shape;
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
+    // accounting for dilation, how big is the kernel in this dimension
+    effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
+  }
+
+  std::vector<int64_t> pads;
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() != n_input_dims * 2) {
+      fail_shape_inference("Attribute pads has incorrect size");
+    }
+    if (std::any_of(pads.begin(), pads.end(), [](int64_t p) { return p < 0; })) {
+      fail_shape_inference("Attribute pads must not contain negative values");
+    }
+  } else {
+    pads.assign(n_input_dims * 2, 0);
+    const auto* const auto_pad_attr = ctx.getAttribute("auto_pad");
+    if ((nullptr != auto_pad_attr) && (auto_pad_attr->s() != "VALID")) {
+      int input_dims_size = static_cast<int>(n_input_dims);
+      for (int i = 0; i < input_dims_size; ++i) {
+        int64_t residual = 0;
+        int64_t stride = strides[i];
+        if (stride > 1) {
+          if (!input_shape.dim(2 + i).has_dim_value()) {
+            continue;
+          }
+          residual = input_shape.dim(2 + i).dim_value();
+          if (residual < 0) {
+            continue;
+          }
+          residual %= stride;
+        }
+        int64_t total_pad = residual == 0 ? effective_kernel_shape[i] - stride : effective_kernel_shape[i] - residual;
+        total_pad = std::max<int64_t>(total_pad, 0);
+        int64_t half_pad_small = total_pad >> 1;
+        int64_t half_pad_big = total_pad - half_pad_small;
+        if (auto_pad_attr->s() == "SAME_UPPER") {
+          pads[i] = half_pad_small;
+          pads[i + input_dims_size] = half_pad_big;
+        } else if (auto_pad_attr->s() == "SAME_LOWER") {
+          pads[i] = half_pad_big;
+          pads[i + input_dims_size] = half_pad_small;
+        }
+      }
+    }
+  }
+
+  auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  if (require_kernel_shape) {
+    // add the first two dimensions from the input.
+    *output_shape->add_dim() = input_shape.dim(0);
+    *output_shape->add_dim() = input_shape.dim(1);
+  } else {
+    *output_shape->add_dim() = input_shape.dim(0);
+    const auto& second_input_shape = getInputShape(ctx, input2Idx);
+    if (second_input_shape.dim_size() < 1) {
+      fail_shape_inference("Second input tensor has wrong dimension");
+    }
+    *output_shape->add_dim() = second_input_shape.dim(0);
+  }
+
+  int kernel_shape_size = static_cast<int>(kernel_shape.size());
+  for (int i = 0; i < kernel_shape_size; ++i) {
+    auto* newdim = output_shape->add_dim();
+    if (!input_shape.dim(2 + i).has_dim_value()) {
+      continue;
+    }
+    // how big is the input, including padding
+    int64_t effective_input_size = input_shape.dim(2 + i).dim_value();
+    effective_input_size += pads[i];
+    effective_input_size += pads[i + kernel_shape_size];
+
+    // default is floor mode .i.e. ceil_mode is set to 0
+    auto ceil_mode = getAttribute(ctx, "ceil_mode", 0);
+
+    // how many times we can move the kernel from it's initial position, based
+    // on the stride
+    int64_t strided_kernel_positions = 0;
+
+    if (ceil_mode == 1)
+      strided_kernel_positions = static_cast<int64_t>(
+          std::ceil((effective_input_size - effective_kernel_shape[i]) / static_cast<float>(strides[i])));
+    else
+      strided_kernel_positions = (effective_input_size - effective_kernel_shape[i]) / strides[i];
+
+    // add in the initial position
+    newdim->set_dim_value(1 + strided_kernel_positions);
+  }
+
+  if (ctx.getNumOutputs() > 1) {
+    // MaxPool with two outputs case.
+    auto* second_output_shape = ctx.getOutputType(1)->mutable_tensor_type()->mutable_shape();
+    second_output_shape->CopyFrom(*output_shape);
+  }
+}
+
+static std::function<void(OpSchema&)>
+PoolOpSchemaGenerator_opset1_to_8(const char* name, const char* opName, const char* additionalDescription) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ {name} consumes an input tensor X and applies {opName} pooling across
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ {opName} pooling consisting of computing the {opName} on all values of a
+ subset of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing. The output spatial shape will be following:
+ ```
+ output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - kernel_spatial_shape[i]) / strides_spatial_shape[i] + 1)
+
+ * pad_shape[i] is sum of pads along axis i
+ ```
+
+ `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+ ```
+ VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - kernel_spatial_shape[i] + 1) / strides_spatial_shape[i])
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+ ```
+ And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+ ```
+ pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + kernel_spatial_shape[i] - input_spatial_shape[i]
+ ```
+ {additionalDescription}
+ )DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{opName}", opName);
+        ReplaceAll(doc, "{additionalDescription}", additionalDescription););
+    schema.SetDoc(doc);
+    schema.Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS);
+    schema.Attr("strides", "Stride along each spatial axis.", AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr("auto_pad", auto_pad_doc2, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc2, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data. For non image case, the "
+        "dimensions are in the form of "
+        "(N x C x D1 x D2 ... Dn), where N is the batch "
+        "size. Optionally, if dimension denotation is "
+        "in effect, the operation expects the input "
+        "data tensor to arrive with the dimension denotation "
+        "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+        "T");
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from average or max pooling across "
+        "the input tensor. Dimensions will vary based "
+        "on various kernel, stride, and pad sizes. Floor value of "
+        "the dimension is used",
+        "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (ctx.getNumOutputs() > 1) {
+        // MaxPool with two outputs case.
+        auto* output_type = ctx.getOutputType(1);
+        if (output_type->value_case() == TypeProto::kTensorType ||
+            output_type->value_case() == TypeProto::VALUE_NOT_SET) {
+          output_type->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+        }
+      }
+      convPoolShapeInference_opset1_to_11(ctx, false, true, 0, 1);
+    });
+  };
+}
+
+static std::function<void(OpSchema&)> PoolOpSchemaGenerator_opset10_to_11(
+    const char* name,
+    const char* opName,
+    const char* additionalDescription,
+    bool use_dilation,
+    int opsetNum) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ {name} consumes an input tensor X and applies {opName} pooling across
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ {opName} pooling consisting of computing the {opName} on all values of a
+ subset of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing. The output spatial shape will be following:
+ ```
+ output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+ ```
+ or
+ ```
+ output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+ ```
+ if ceil_mode is enabled
+
+ ```
+ * pad_shape[i] is sum of pads along axis i
+ ```
+
+ `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following:
+ ```
+ VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+ ```
+ And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+ ```
+ pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]
+ ```
+ {additionalDescription}
+ )DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{opName}", opName);
+        ReplaceAll(doc, "{additionalDescription}", additionalDescription);
+        ReplaceAll(
+            doc,
+            "{kernelSpatialShape}",
+            use_dilation ? "((kernel_spatial_shape[i] - 1) * dilations[i] + 1)" : "kernel_spatial_shape[i]"););
+    schema.SetDoc(doc);
+    schema.Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS);
+    schema.Attr(
+        "strides",
+        opsetNum == 11
+            ? "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis."
+            : "Stride along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", auto_pad_doc2, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc2, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "ceil_mode",
+        "Whether to use ceil or floor (default) to compute the output shape.",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data. For non image case, the "
+        "dimensions are in the form of "
+        "(N x C x D1 x D2 ... Dn), where N is the batch "
+        "size. Optionally, if dimension denotation is "
+        "in effect, the operation expects the input "
+        "data tensor to arrive with the dimension denotation "
+        "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+        "T");
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from average or max pooling across "
+        "the input tensor. Dimensions will vary based "
+        "on various kernel, stride, and pad sizes. Floor value of "
+        "the dimension is used",
+        "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([use_dilation](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (ctx.getNumOutputs() > 1) {
+        // MaxPool with two outputs case.
+        auto* output_type = ctx.getOutputType(1);
+        if (output_type->value_case() == TypeProto::kTensorType ||
+            output_type->value_case() == TypeProto::VALUE_NOT_SET) {
+          output_type->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+        }
+      }
+      convPoolShapeInference_opset1_to_11(ctx, use_dilation, true, 0, 1);
+    });
+  };
+}
+
+static std::vector<std::string> GetSupportedDataTypesForPoolingOps_opset11(bool supports8bit) {
+  if (supports8bit) {
+    return {types::Float16, types::Float, types::Double, types::Int8, types::UInt8};
+  }
+  return {types::Float16, types::Float, types::Double};
+}
+
+static std::function<void(OpSchema&)> PoolOpSchemaGenerator_opset11(
+    const char* name,
+    const char* opName,
+    const char* additionalDescription,
+    bool use_dilation,
+    bool supports8bit = false) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ {name} consumes an input tensor X and applies {opName} pooling across
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ {opName} pooling consisting of computing the {opName} on all values of a
+ subset of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing. The output spatial shape will be following:
+ ```
+ output_spatial_shape[i] = floor((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+ ```
+ or
+ ```
+ output_spatial_shape[i] = ceil((input_spatial_shape[i] + pad_shape[i] - {kernelSpatialShape}) / strides_spatial_shape[i] + 1)
+ ```
+ if ceil_mode is enabled
+
+ ```
+ * pad_shape[i] is sum of pads along axis i
+ ```
+
+ `auto_pad` is a DEPRECATED attribute. If you are using them currently, the output spatial shape will be following when ceil_mode is enabled:
+ ```
+ VALID: output_spatial_shape[i] = ceil((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides_spatial_shape[i])
+ ```
+or when ceil_mode is disabled:
+ ```
+ VALID: output_spatial_shape[i] = floor((input_spatial_shape[i] - {kernelSpatialShape} + 1) / strides_spatial_shape[i])
+ SAME_UPPER or SAME_LOWER: output_spatial_shape[i] = floor(input_spatial_shape[i] / strides_spatial_shape[i])
+ ```
+
+ And pad shape will be following if `SAME_UPPER` or `SAME_LOWER`:
+ ```
+ pad_shape[i] = (output_spatial_shape[i] - 1) * strides_spatial_shape[i] + {kernelSpatialShape} - input_spatial_shape[i]
+ ```
+ {additionalDescription}
+ )DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(doc, "{opName}", opName);
+        ReplaceAll(doc, "{additionalDescription}", additionalDescription);
+        ReplaceAll(
+            doc,
+            "{kernelSpatialShape}",
+            use_dilation ? "((kernel_spatial_shape[i] - 1) * dilations[i] + 1)" : "kernel_spatial_shape[i]"););
+    schema.SetDoc(doc);
+    schema.Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", auto_pad_doc3, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc2, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "ceil_mode",
+        "Whether to use ceil or floor (default) to compute the output shape.",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data. For non image case, the "
+        "dimensions are in the form of "
+        "(N x C x D1 x D2 ... Dn), where N is the batch "
+        "size. Optionally, if dimension denotation is "
+        "in effect, the operation expects the input "
+        "data tensor to arrive with the dimension denotation "
+        "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from average or max pooling across "
+        "the input tensor. Dimensions will vary based "
+        "on various kernel, stride, and pad sizes. Floor value of "
+        "the dimension is used",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T",
+        GetSupportedDataTypesForPoolingOps_opset11(supports8bit),
+        supports8bit ? "Constrain input and output types to float and 8 bit tensors."
+                     : "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([use_dilation](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (ctx.getNumOutputs() > 1) {
+        // MaxPool with two outputs case.
+        auto* output_type = ctx.getOutputType(1);
+        if (output_type->value_case() == TypeProto::kTensorType ||
+            output_type->value_case() == TypeProto::VALUE_NOT_SET) {
+          output_type->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+        }
+      }
+      convPoolShapeInference_opset1_to_11(ctx, use_dilation, true, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    AveragePool,
+    1,
+    OpSchema().FillUsing(PoolOpSchemaGenerator_opset1_to_8(
+        "AveragePool",
+        "average",
+        "The output of each pooling window is divided by the number of elements exclude pad.")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    AveragePool,
+    7,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator_opset1_to_8(
+            "AveragePool",
+            "average",
+            "The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero)."))
+        .Attr(
+            "count_include_pad",
+            "Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0)));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    AveragePool,
+    10,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator_opset10_to_11(
+            "AveragePool",
+            "average",
+            "The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).",
+            false,
+            10))
+        .Attr(
+            "count_include_pad",
+            "Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0)));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    AveragePool,
+    11,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator_opset11(
+            "AveragePool",
+            "average",
+            "The output of each pooling window is divided by the number of elements (exclude pad when attribute count_include_pad is zero).",
+            true,
+            false))
+        .Attr(
+            "count_include_pad",
+            "Whether include pad pixels when calculating values for the edges. Default is 0, doesn't count include pad.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0)));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MaxPool,
+    1,
+    OpSchema().FillUsing(PoolOpSchemaGenerator_opset1_to_8(
+        "MaxPool",
+        "max",
+        "The output of each pooling window is maximum number of elements exclude pad.")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MaxPool,
+    8,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator_opset1_to_8(
+            "MaxPool",
+            "max",
+            "The output of each pooling window is maximum number of elements exclude pad."))
+        .Attr(
+            "storage_order",
+            "The storage order of the tensor. 0 is row major, and 1 is column major.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Output(
+            1,
+            "Indices",
+            "Indices tensor from max pooling across the input tensor. "
+            "The dimensions of indices are the same as output tensor. "
+            "The values in indices of are the indices of the selected values during pooling. "
+            "The indices are computed as flatten 1-D tensor, "
+            "and the indices do not consider padding. "
+            "So the values in indices are in [0, N x C x D1 x ... x Dn).",
+            "I",
+            OpSchema::Optional)
+        .TypeConstraint("I", {types::Int64}, "Constrain index tensor to int64"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MaxPool,
+    10,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator_opset10_to_11(
+            "MaxPool",
+            "max",
+            "The output of each pooling window is maximum number of elements exclude pad.",
+            true,
+            10))
+        .Attr(
+            "storage_order",
+            "The storage order of the tensor. 0 is row major, and 1 is column major.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr("dilations", "Dilation value along each spatial axis of filter.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Output(
+            1,
+            "Indices",
+            "Indices tensor from max pooling across the input tensor. "
+            "The dimensions of indices are the same as output tensor. "
+            "The values in indices of are the indices of the selected values during pooling. "
+            "The indices are computed as flatten 1-D tensor, "
+            "and the indices do not consider padding. "
+            "So the values in indices are in [0, N x C x D1 x ... x Dn).",
+            "I",
+            OpSchema::Optional)
+        .TypeConstraint("I", {types::Int64}, "Constrain index tensor to int64"));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MaxPool,
+    11,
+    OpSchema()
+        .FillUsing(PoolOpSchemaGenerator_opset10_to_11(
+            "MaxPool",
+            "max",
+            "The output of each pooling window is maximum number of elements exclude pad.",
+            true,
+            11))
+        .Attr(
+            "storage_order",
+            "The storage order of the tensor. 0 is row major, and 1 is column major.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "dilations",
+            "Dilation value along each spatial axis of filter. If not present, the dilation defaults to 1 along each spatial axis.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Output(
+            1,
+            "Indices",
+            "Indices tensor from max pooling across the input tensor. "
+            "The dimensions of indices are the same as output tensor. "
+            "The values in indices of are the indices of the selected values during pooling. "
+            "The indices are computed as flatten 1-D tensor, "
+            "and the indices do not consider padding. "
+            "So the values in indices are in [0, N x C x D1 x ... x Dn).",
+            "I",
+            OpSchema::Optional)
+        .TypeConstraint("I", {types::Int64}, "Constrain index tensor to int64"));
+
+static void maxUnpoolShapeInference_opset9(InferenceContext& ctx) {
+  // we need at least two inputs to have a shape for this inference.
+  if (ctx.getNumInputs() != 2 && ctx.getNumInputs() != 3) {
+    fail_type_inference("MaxUnpool op must have either two or three inputs.");
+  }
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+  if (!hasInputShape(ctx, 0)) {
+    return; // If first input does not have shape, we cannot infer much.
+  }
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() < 2) {
+    fail_shape_inference("Input tensor X must have at least 2 dimensions.");
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  std::vector<int64_t> pads;
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() != n_input_dims * 2) {
+      fail_shape_inference("Attribute pads has incorrect size.");
+    }
+  } else {
+    pads.assign(n_input_dims * 2, 0);
+  }
+
+  std::vector<int64_t> strides;
+  if (getRepeatedAttribute(ctx, "strides", strides)) {
+    if (strides.size() != n_input_dims) {
+      fail_shape_inference("Attribute strides has incorrect size.");
+    }
+  } else {
+    strides.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> kernel_shape;
+  if (getRepeatedAttribute(ctx, "kernel_shape", kernel_shape)) {
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute kernel_shape has incorrect size.");
+    }
+  } else {
+    fail_shape_inference("Attribute kernel_shape must be specified.");
+  }
+
+  if (ctx.getNumInputs() == 3) {
+    // If the third input, output_size, is specified, then use that instead
+    // of inferring shape from inputs.
+    if (hasInputShape(ctx, 2)) {
+      const auto& output_shape = getInputShape(ctx, 2);
+      if (output_shape.dim_size() != 1) {
+        fail_type_inference("'output_shape' must be rank 1 tensor.");
+      }
+      if (output_shape.dim(0).has_dim_value() &&
+          static_cast<int>(output_shape.dim(0).dim_value()) != input_shape.dim_size()) {
+        fail_shape_inference("'output_shape' must have same number of elements as the shape of input tensor X.");
+      }
+    }
+    return; // 'output_shape' is specified as input. Actual shape will be
+            // determined at runtime.
+  }
+
+  if (!hasInputShape(ctx, 1)) {
+    return; // If indices input does not have shape, we cannot infer output shape.
+  }
+  auto indices_shape = ctx.getInputType(1)->tensor_type().shape();
+  if (indices_shape.dim_size() < 2) {
+    fail_shape_inference("Indices tensor I must have at least 2 dimensions.");
+  }
+
+  auto* final_output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  *final_output_shape->add_dim() = input_shape.dim(0);
+  *final_output_shape->add_dim() = indices_shape.dim(1); // channels should be the second dim of second input.
+
+  int kernel_shape_size = static_cast<int>(kernel_shape.size());
+  for (int i = 0; i < kernel_shape_size; ++i) {
+    auto* newdim = final_output_shape->add_dim();
+    if (!input_shape.dim(2 + i).has_dim_value()) {
+      continue;
+    }
+
+    int64_t newdim_value = strides[i] * (input_shape.dim(2 + i).dim_value() - 1);
+    newdim_value += kernel_shape[i];
+    newdim_value -= pads[i];
+    newdim_value -= pads[i + kernel_shape_size];
+
+    // add in the initial position
+    newdim->set_dim_value(newdim_value);
+  }
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    MaxUnpool,
+    9,
+    OpSchema()
+        .SetDoc(kDoc_MaxUnpool_ver11)
+        .Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS)
+        .Attr("strides", "Stride along each spatial axis.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("pads", pads_doc2, AttributeProto::INTS, OPTIONAL_VALUE)
+        .Input(
+            0,
+            "X",
+            "Input data tensor that has to be unpooled. "
+            "This tensor is typically the first output of the MaxPool op."
+            "Dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non-image case, the "
+            "dimensions are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the batch "
+            "size. Optionally, if dimension denotation is "
+            "in effect, the operation expects the input "
+            "data tensor to arrive with the dimension denotation "
+            "of [DATA_BATCH, DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+            "T1")
+        .Input(
+            1,
+            "I",
+            "Input data tensor containing the indices corresponding to "
+            "elements in the first input tensor X."
+            "This tensor is typically the second output of the MaxPool op."
+            "Dimensions must be the same as input tensor X. "
+            "The indices are linear, i.e. computed considering the tensor as flattened 1-D tensor, "
+            "assuming row-major storage. Also, the linear indices should not consider padding. "
+            "So the values in indices are in the range [0, N x C x D1 x ... x Dn).",
+            "T2")
+        .Input(
+            2,
+            "output_shape",
+            "The shape of the output can be explicitly set which will cause pads values to be auto generated. If 'output_shape' is specified, "
+            "'pads' values are ignored.",
+            "T2",
+            OpSchema::Optional)
+        .Output(0, "output", "Output data tensor that contains the result of the unpooling.", "T1")
+        .TypeConstraint(
+            "T1",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain index tensor to int64")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { maxUnpoolShapeInference_opset9(ctx); }));
+
+constexpr const char* pads_doc1 =
+    "Padding for the beginning and ending along each axis, it can take any value greater "
+    "than or equal to 0. The value represent the number of pixels added to the beginning "
+    "and end part of the corresponding axis. `pads` format should be as follow "
+    "[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels "
+    "added at the beginning of axis `i` and xi_end, the number of pixels added at "
+    "the end of axis `i`. This attribute cannot be used simultaneously with "
+    "auto_pad attribute.";
+constexpr const char* auto_pad_doc1 =
+    "auto_pad must be either NOTSET, SAME_UPPER, SAME_LOWER or VALID. Where "
+    "default value is NOTSET, which means explicit padding is used. "
+    "SAME_UPPER or SAME_LOWER mean pad the input so that the output size match the input."
+    "In case of odd number add the extra padding at the end for SAME_UPPER and at the "
+    "beginning for SAME_LOWER. VALID mean no padding. DEPRECATION NOTE: auto_pad is "
+    "only intended to support legacy uses, and for framework authors, one is explicitly "
+    "encouraged to use explicit padding specified in the pads attribute.";
+
+constexpr const char* LpPool_ver1_doc = R"DOC(
+ LpPool consumes an input tensor X and applies Lp pooling across the
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ Lp pooling consisting of computing the Lp norm on all values of a subset
+ of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing.)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LpPool,
+    1,
+    OpSchema()
+        .SetDoc(LpPool_ver1_doc)
+        .Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("strides", "Stride along each axis.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("auto_pad", auto_pad_doc1, AttributeProto::STRING, std::string("NOTSET"))
+        .Attr("pads", pads_doc1, AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "p",
+            "p value of the Lp norm used to pool over the input data, default is 2.0.",
+            AttributeProto::FLOAT,
+            2.0f)
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non image case, the "
+            "dimension are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the "
+            "batch size.",
+            "T")
+        .Output(
+            0,
+            "Y",
+            "Output data tensor from Lp pooling across the input "
+            "tensor. Dimensions will vary based on various kernel, stride, and pad "
+            "sizes.",
+            "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static std::function<void(OpSchema&)> LpPoolOpSchemaGenerator_opset2(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ {name} consumes an input tensor X and applies Lp pooling across
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ Lp pooling consisting of computing the Lp norm on all values of a subset
+ of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing.)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc);
+    schema.Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS);
+    schema.Attr("strides", "Stride along each spatial axis.", AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr("auto_pad", auto_pad_doc2, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc2, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "p", "p value of the Lp norm used to pool over the input data.", AttributeProto::INT, static_cast<int64_t>(2));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data. For non image case, the "
+        "dimensions are in the form of "
+        "(N x C x D1 x D2 ... Dn), where N is the "
+        "batch size.",
+        "T");
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from Lp pooling across the input "
+        "tensor. Dimensions will vary based on various kernel, stride, and pad "
+        "sizes.",
+        "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      convPoolShapeInference_opset1_to_11(ctx, false, true, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(LpPool, 2, OpSchema().FillUsing(LpPoolOpSchemaGenerator_opset2("LpPool")));
+
+static constexpr const char* GlobalLpPool_ver1_doc = R"DOC(
+ GlobalLpPool consumes an input tensor X and applies lp pool pooling across the
+ the values in the same channel. This is equivalent to LpPool with kernel size
+ equal to the spatial dimension of input tensor.)DOC";
+
+static std::function<void(OpSchema&)> LpPoolOpSchemaGenerator_opset11(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+ {name} consumes an input tensor X and applies Lp pooling across
+ the tensor according to kernel sizes, stride sizes, and pad lengths.
+ Lp pooling consisting of computing the Lp norm on all values of a subset
+ of the input tensor according to the kernel size and downsampling the
+ data into the output tensor Y for further processing.)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc);
+    schema.Attr("kernel_shape", "The size of the kernel along each axis.", AttributeProto::INTS);
+    schema.Attr(
+        "strides",
+        "Stride along each spatial axis. If not present, the stride defaults to 1 along each spatial axis.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr("auto_pad", auto_pad_doc3, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc2, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "p", "p value of the Lp norm used to pool over the input data.", AttributeProto::INT, static_cast<int64_t>(2));
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from the previous operator; "
+        "dimensions for image case are (N x C x H x W), "
+        "where N is the batch size, C is the number of "
+        "channels, and H and W are the height and the "
+        "width of the data. For non image case, the "
+        "dimensions are in the form of "
+        "(N x C x D1 x D2 ... Dn), where N is the "
+        "batch size.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor from Lp pooling across the input "
+        "tensor. Dimensions will vary based on various kernel, stride, and pad "
+        "sizes.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      convPoolShapeInference_opset1_to_11(ctx, false, true, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(LpPool, 11, OpSchema().FillUsing(LpPoolOpSchemaGenerator_opset11("LpPool")));
+
+static std::function<void(OpSchema&)> ConvOpSchemaGenerator_opset1(const char* filter_desc) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+The convolution operator consumes an input tensor and {filter_desc}, and
+computes the output.)DOC";
+        ReplaceAll(doc, "{filter_desc}", filter_desc););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from previous layer; "
+        "has size (N x C x H x W), where N is the batch size, "
+        "C is the number of channels, and H and W are the "
+        "height and width. Note that this is for the 2D image. "
+        "Otherwise the size is (N x C x D1 x D2 ... x Dn). "
+        "Optionally, if dimension denotation is "
+        "in effect, the operation expects input data tensor "
+        "to arrive with the dimension denotation of [DATA_BATCH, "
+        "DATA_CHANNEL, DATA_FEATURE, DATA_FEATURE ...].",
+        "T");
+    schema.Input(
+        1,
+        "W",
+        "The weight tensor that will be used in the "
+        "convolutions; has size (M x C/group x kH x kW), where C "
+        "is the number of channels, and kH and kW are the "
+        "height and width of the kernel, and M is the number "
+        "of feature maps. For more than 2 dimensions, the "
+        "kernel shape will be (M x C/group x k1 x k2 x ... x kn), "
+        "where (k1 x k2 x ... kn) is the dimension of the kernel. "
+        "Optionally, if dimension denotation is in effect, "
+        "the operation expects the weight tensor to arrive "
+        "with the dimension denotation of [FILTER_OUT_CHANNEL, "
+        "FILTER_IN_CHANNEL, FILTER_SPATIAL, FILTER_SPATIAL ...]. "
+        "X.shape[1] == (W.shape[1] * group) == C "
+        "(assuming zero based indices for the shape array). "
+        "Or in other words FILTER_IN_CHANNEL should be equal to DATA_CHANNEL. ",
+        "T");
+    schema.Input(2, "B", "Optional 1D bias to be added to the convolution, has size of M.", "T", OpSchema::Optional);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor that contains the result of the "
+        "convolution. The output dimensions are functions "
+        "of the kernel size, stride size, and pad lengths.",
+        "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.Attr(
+        "kernel_shape",
+        "The shape of the convolution kernel. If not present, should be inferred from input W.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "dilations", "dilation value along each spatial axis of the filter.", AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr("strides", "Stride along each spatial axis.", AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr("auto_pad", auto_pad_doc2, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc2, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "group",
+        "number of groups input channels and output channels are divided into.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      convPoolShapeInference_opset1_to_11(ctx, true, false, 0, 1);
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(Conv, 1, OpSchema().FillUsing(ConvOpSchemaGenerator_opset1("a filter")));
+
+static void convTransposeShapeInference_opset1(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // we need at least two inputs to have a shape for this inference.
+  if (!hasNInputShapes(ctx, 2)) {
+    return;
+  }
+
+  int64_t group = getAttribute(ctx, "group", 1);
+  if (group <= 0) {
+    fail_shape_inference("Attribute group must be > 0 for ConvTranspose. group=", group, ".");
+  }
+
+  auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+  if (input_shape.dim_size() < 3) {
+    fail_shape_inference(
+        "Input tensor must have at least 3 dimensions (N x C x D1...Dn). Got: ", input_shape.dim_size());
+  }
+  const auto& input_channels_dim = input_shape.dim(1);
+  if (input_channels_dim.has_dim_value() && input_channels_dim.dim_value() % group != 0) {
+    fail_shape_inference(
+        "Input channels C must be divisible by group for ConvTranspose. C=",
+        input_channels_dim.dim_value(),
+        " group=",
+        group,
+        ".");
+  }
+
+  // Weight tensor (input 1) must also have at least 3 dimensions (C x M/group x k1...kn).
+  auto weight_shape = ctx.getInputType(1)->tensor_type().shape();
+  if (weight_shape.dim_size() < 3) {
+    fail_shape_inference(
+        "Weight tensor must have at least 3 dimensions (C x M/group x k1...kn). Got: ", weight_shape.dim_size());
+  }
+
+  // first dim is the batch axis and the next is the number of channels.
+  size_t n_input_dims = static_cast<size_t>(input_shape.dim_size() - 2);
+
+  std::vector<int64_t> dilations;
+  if (getRepeatedAttribute(ctx, "dilations", dilations)) {
+    if (dilations.size() != n_input_dims) {
+      fail_shape_inference("Attribute dilations has incorrect size");
+    }
+    if (std::any_of(dilations.begin(), dilations.end(), [](int64_t d) { return d <= 0; })) {
+      fail_shape_inference("Attribute dilations must only contain positive values");
+    }
+  } else {
+    dilations.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> strides;
+  if (getRepeatedAttribute(ctx, "strides", strides)) {
+    if (strides.size() != n_input_dims) {
+      fail_shape_inference("Attribute strides has incorrect size");
+    }
+    if (std::any_of(strides.begin(), strides.end(), [](int64_t s) { return s <= 0; })) {
+      fail_shape_inference("Attribute strides must only contain positive values");
+    }
+  } else {
+    strides.assign(n_input_dims, 1);
+  }
+
+  std::vector<int64_t> kernel_shape;
+  if (getRepeatedAttribute(ctx, "kernel_shape", kernel_shape)) {
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute kernel_shape has incorrect size");
+    }
+  } else {
+    for (int i = 2; i < weight_shape.dim_size(); ++i) {
+      if (!weight_shape.dim(i).has_dim_value()) {
+        return;
+      }
+      kernel_shape.push_back(weight_shape.dim(i).dim_value());
+    }
+    if (kernel_shape.size() != n_input_dims) {
+      fail_shape_inference("Weight tensor spatial rank does not match input tensor spatial rank");
+    }
+  }
+
+  if (std::any_of(kernel_shape.begin(), kernel_shape.end(), [](int64_t k) { return k <= 0; })) {
+    fail_shape_inference("Attribute kernel_shape must only contain positive values");
+  }
+
+  std::vector<int64_t> effective_kernel_shape = kernel_shape;
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
+    // accounting for dilation, how big is the kernel in this dimension
+    effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
+  }
+
+  std::vector<int64_t> pads;
+  if (getRepeatedAttribute(ctx, "pads", pads)) {
+    if (pads.size() != n_input_dims * 2) {
+      fail_shape_inference("Attribute pads has incorrect size");
+    }
+    if (std::any_of(pads.begin(), pads.end(), [](int64_t p) { return p < 0; })) {
+      fail_shape_inference("Attribute pads must not contain negative values");
+    }
+  } else {
+    pads.assign(n_input_dims * 2, 0);
+    const auto* const auto_pad_attr = ctx.getAttribute("auto_pad");
+    if ((nullptr != auto_pad_attr) && (auto_pad_attr->s() != "VALID")) {
+      int input_dims_size = static_cast<int>(n_input_dims);
+      for (int i = 0; i < input_dims_size; ++i) {
+        int64_t total_pad = effective_kernel_shape[i] - strides[i];
+        total_pad = std::max<int64_t>(total_pad, 0);
+        int64_t half_pad_small = total_pad >> 1;
+        int64_t half_pad_big = total_pad - half_pad_small;
+        if (auto_pad_attr->s() == "SAME_UPPER") {
+          pads[i] = half_pad_small;
+          pads[i + input_dims_size] = half_pad_big;
+        } else if (auto_pad_attr->s() == "SAME_LOWER") {
+          pads[i] = half_pad_big;
+          pads[i + input_dims_size] = half_pad_small;
+        }
+      }
+    }
+  }
+
+  std::vector<int64_t> output_shape;
+  bool output_shape_presented = true;
+  if (getRepeatedAttribute(ctx, "output_shape", output_shape)) {
+    if (output_shape.size() != n_input_dims) {
+      fail_shape_inference("Attribute output_shape has incorrect size");
+    }
+    if (std::any_of(output_shape.begin(), output_shape.end(), [](int64_t s) { return s < 0; })) {
+      fail_shape_inference("Attribute output_shape must not contain negative values");
+    }
+  } else {
+    output_shape_presented = false;
+  }
+
+  std::vector<int64_t> output_padding;
+  if (getRepeatedAttribute(ctx, "output_padding", output_padding)) {
+    if (output_padding.size() != n_input_dims) { // Added only to one side.
+      fail_shape_inference("Attribute output_padding has incorrect size");
+    }
+    if (std::any_of(output_padding.begin(), output_padding.end(), [](int64_t p) { return p < 0; })) {
+      fail_shape_inference("Attribute output_padding must not contain negative values");
+    }
+  } else {
+    output_padding.assign(n_input_dims, 0);
+  }
+
+  auto* final_output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+  *final_output_shape->add_dim() = input_shape.dim(0);
+  *final_output_shape->add_dim() = weight_shape.dim(1) * group; // channels should be the second dim of second input
+                                                                // multiply group.
+
+  int size_of_output = 0;
+  if (output_shape_presented) {
+    size_of_output = static_cast<int>(output_shape.size());
+    for (int i = 0; i < size_of_output; ++i) {
+      if (input_shape.dim(i + 2).has_dim_value()) {
+        if (output_shape[i] < input_shape.dim(i + 2).dim_value()) {
+          // TODO(ONNX): throw exception?
+          return; // output shape value cannot be smaller than the input shape
+                  // value
+        }
+      }
+      final_output_shape->add_dim()->set_dim_value(output_shape[i]);
+    }
+    return;
+  } else {
+    size_of_output = input_shape.dim_size() - 2;
+    for (int i = 0; i < size_of_output; ++i) {
+      if (input_shape.dim(i + 2).has_dim_value()) {
+        int64_t output_shape_dim = strides[i] * (input_shape.dim(i + 2).dim_value() - 1) + output_padding[i] +
+            effective_kernel_shape[i] - pads[i] - pads[i + n_input_dims];
+        final_output_shape->add_dim()->set_dim_value(output_shape_dim);
+      } else {
+        final_output_shape->add_dim();
+      }
+    }
+    return;
+  }
+}
+
+static std::function<void(OpSchema&)> ConvTransposeOpSchemaGenerator_opset1(const char* filter_desc) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+The convolution transpose operator consumes an input tensor and {filter_desc},
+and computes the output.
+
+If the pads parameter is provided the shape of the output is calculated via the following equation:
+
+  output_shape[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - pads[start_i] - pads[end_i]
+
+output_shape can also be explicitly specified in which case pads values are auto generated using these equations:
+
+  total_padding[i] = stride[i] * (input_size[i] - 1) + output_padding[i] + ((kernel_shape[i] - 1) * dilations[i] + 1) - output_shape[i]
+  If (auto_pads != SAME_UPPER): pads[start_i] = total_padding[i]/2; pads[end_i] = total_padding[i] - (total_padding[i]/2)
+  Else: pads[start_i] = total_padding[i] - (total_padding[i]/2); pads[end_i] = (total_padding[i]/2).
+
+    )DOC";
+        ReplaceAll(doc, "{filter_desc}", filter_desc););
+    schema.SetDoc(doc);
+    schema.Input(
+        0,
+        "X",
+        "Input data tensor from previous layer; has size (N x C x H x W)"
+        ", where N is the batch size, C is the number of channels, and"
+        " H and W are the height and width. Note that this is for the 2D image. "
+        "Otherwise the size is (N x C x D1 x D2 ... x Dn)",
+        "T");
+    schema.Input(
+        1,
+        "W",
+        "The weight tensor that will be used in the "
+        "convolutions; has size (C x M/group x kH x kW), where C "
+        "is the number of channels, and kH and kW are the "
+        "height and width of the kernel, and M is the number "
+        "of feature maps. For more than 2 dimensions, the "
+        "weight shape will be (C x M/group x k1 x k2 x ... x kn), "
+        "where (k1 x k2 x ... x kn) is the dimension of the kernel. "
+        "The number of channels in the output should be equal to W.shape[1] * group "
+        "(assuming zero based indices of the shape array)",
+        "T");
+    schema.Input(2, "B", "Optional 1D bias to be added to the convolution, has size of M.", "T", OpSchema::Optional);
+    schema.Output(
+        0,
+        "Y",
+        "Output data tensor that contains the result of the convolution. The "
+        "output dimensions are functions of the kernel size, stride size, "
+        "pad lengths and group count. "
+        "The number of channels in the output should be equal to W.shape[1] * group "
+        "(assuming zero based indices of the shape array)",
+        "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.Attr(
+        "kernel_shape",
+        "The shape of the convolution kernel. If not present, should be inferred from input W.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "output_shape",
+        "The shape of the output can be explicitly set which will cause pads values to be auto generated. If output_shape is specified "
+        "pads values are ignored. See doc for details for equations to generate pads",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "output_padding",
+        "The zero-padding added to one side of the output."
+        " This is also called adjs/adjustment in some frameworks.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "dilations", "dilation value along each spatial axis of the filter.", AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr("strides", "Stride along each spatial axis.", AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr("auto_pad", auto_pad_doc2, AttributeProto::STRING, std::string("NOTSET"));
+    schema.Attr("pads", pads_doc2, AttributeProto::INTS, OPTIONAL_VALUE);
+    schema.Attr(
+        "group",
+        "number of groups input channels and output channels are divided into.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) { convTransposeShapeInference_opset1(ctx); });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(ConvTranspose, 1, OpSchema().FillUsing(ConvTransposeOpSchemaGenerator_opset1("a filter")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GlobalLpPool,
+    1,
+    OpSchema()
+        .SetDoc(GlobalLpPool_ver1_doc)
+        .Attr(
+            "p",
+            "p value of the Lp norm used to pool over the input data, default is 2.0.",
+            AttributeProto::FLOAT,
+            2.0f)
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the width "
+            "of the data. For non image case, the dimension are "
+            "in the form of (N x C x D1 x D2 ... Dn), "
+            "where N is the batch size.",
+            "T")
+        .Output(
+            0,
+            "Y",
+            "Output data tensor from pooling across the input "
+            "tensor. Dimensions will be N x C x 1 x 1",
+            "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* BatchNormalization_ver1_doc = R"DOC(
+Carries out batch normalization as described in the paper
+https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+there are multiple cases for the number of outputs, which we list below:
+
+Output case #1: Y, mean, var, saved_mean, saved_var (training mode)
+Output case #2: Y (test mode)
+    )DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BatchNormalization,
+    1,
+    OpSchema()
+        .NumOutputs({1, 5})
+        .SetDoc(BatchNormalization_ver1_doc)
+        .Attr(
+            "spatial",
+            "If true, compute the mean and variance across all spatial elements "
+            "If false, compute the mean and variance across per feature."
+            "Default is 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "is_test",
+            "If set to nonzero, run spatial batch normalization in test mode, default is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "epsilon",
+            "The epsilon value to use to avoid division by zero, default is 1e-5f.",
+            AttributeProto::FLOAT,
+            1e-5f)
+        .Attr(
+            "momentum",
+            "Factor used in computing the running mean and variance."
+            "e.g., running_mean = running_mean * momentum + mean * (1 - momentum), default is 0.9f.",
+            AttributeProto::FLOAT,
+            0.9f)
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS)
+        .Input(0, "X", "The input 4-dimensional tensor of shape NCHW.", "T")
+        .Input(
+            1,
+            "scale",
+            "The scale as a 1-dimensional tensor of size C to be applied to the "
+            "output.",
+            "T")
+        .Input(
+            2,
+            "B",
+            "The bias as a 1-dimensional tensor of size C to be applied to the "
+            "output.",
+            "T")
+        .Input(
+            3,
+            "mean",
+            "The running mean (training) or the estimated mean (testing) "
+            "as a 1-dimensional tensor of size C.",
+            "T")
+        .Input(
+            4,
+            "var",
+            "The running variance (training) or the estimated "
+            "variance (testing) as a 1-dimensional tensor of size C.",
+            "T")
+        .Output(0, "Y", "The output 4-dimensional tensor of the same shape as X.", "T")
+        .Output(
+            1,
+            "mean",
+            "The running mean after the BatchNormalization operator. Must be in-place "
+            "with the input mean. Should not be used for testing.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            2,
+            "var",
+            "The running variance after the BatchNormalization operator. Must be "
+            "in-place with the input var. Should not be used for testing.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            3,
+            "saved_mean",
+            "Saved mean used during training to speed up gradient "
+            "computation. Should not be used for testing.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            4,
+            "saved_var",
+            "Saved variance used during training to speed up "
+            "gradient computation. Should not be used for testing.",
+            "T",
+            OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* BatchNormalization_ver9_doc = R"DOC(
+Carries out batch normalization as described in the paper
+https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+there are multiple cases for the number of outputs, which we list below:
+
+Output case #1: Y, mean, var, saved_mean, saved_var (training mode)
+Output case #2: Y (test mode)
+
+For previous (depreciated) non-spatial cases, implementors are suggested
+to flatten the input shape to (N x C*D1*D2 ..*Dn) before a BatchNormalization Op.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BatchNormalization,
+    9,
+    OpSchema()
+        .NumOutputs({1, 5})
+        .SetDoc(BatchNormalization_ver9_doc + GenerateOptionalArgumentsDoc())
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Attr(
+            "momentum",
+            "Factor used in computing the running mean and variance."
+            "e.g., running_mean = running_mean * momentum + mean * (1 - momentum).",
+            AttributeProto::FLOAT,
+            0.9f)
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "dimensions are in the form of (N x C x D1 x D2 ... Dn), "
+            "where N is the batch size, C is the number of channels. "
+            "Statistics are computed for every channel of C over N and D1 to Dn dimensions. "
+            "For image data, input dimensions become (N x C x H x W). "
+            "The op also accepts single dimension input of size N in which case C is assumed to be 1",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(1, "scale", "Scale tensor of shape (C).", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(2, "B", "Bias tensor of shape (C).", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            3,
+            "mean",
+            "running (training) or estimated (testing) mean tensor of shape (C).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            4,
+            "var",
+            "running (training) or estimated (testing) variance tensor of shape (C).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "Y",
+            "The output tensor of the same shape as X",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            1,
+            "mean",
+            "The running mean after the BatchNormalization operator.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            2,
+            "var",
+            "The running variance after the BatchNormalization operator.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            3,
+            "saved_mean",
+            "Saved mean used during training to speed up gradient "
+            "computation.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            4,
+            "saved_var",
+            "Saved variance used during training to speed up "
+            "gradient computation.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { propagateShapeAndTypeFromFirstInput(ctx); }));
+
+static constexpr const char* BatchNormalization_ver14_doc = R"DOC(
+Carries out batch normalization as described in the paper
+https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+There are five required inputs 'X', 'scale', 'B', 'input_mean' and
+'input_var'.
+Note that 'input_mean' and 'input_var' are expected to be the estimated
+statistics in inference mode (training_mode=False, default),
+and the running statistics in training mode (training_mode=True).
+There are multiple cases for the number of outputs, which we list below:
+
+Output case #1: Y, running_mean, running_var (training_mode=True)
+Output case #2: Y (training_mode=False)
+
+When training_mode=False, extra outputs are invalid.
+The outputs are updated as follows when training_mode=True:
+```
+running_mean = input_mean * momentum + current_mean * (1 - momentum)
+running_var = input_var * momentum + current_var * (1 - momentum)
+
+Y = (X - current_mean) / sqrt(current_var + epsilon) * scale + B
+
+where:
+
+current_mean = ReduceMean(X, axis=all_except_channel_index)
+current_var =  ReduceVar(X, axis=all_except_channel_index)
+
+Notice that ReduceVar refers to the population variance, and it equals to
+sum(sqrd(x_i - x_avg)) / N
+where N is the population size (this formula does not use sample size N - 1).
+
+```
+
+When training_mode=False:
+```
+Y = (X - input_mean) / sqrt(input_var + epsilon) * scale + B
+```
+
+For previous (depreciated) non-spatial cases, implementors are suggested
+to flatten the input shape to (N x C * D1 * D2 * ... * Dn) before a BatchNormalization Op.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BatchNormalization,
+    14,
+    OpSchema()
+        .NumOutputs({1, 3})
+        .SetDoc(BatchNormalization_ver14_doc + GenerateOptionalArgumentsDoc())
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Attr(
+            "momentum",
+            "Factor used in computing the running mean and variance."
+            "e.g., running_mean = running_mean * momentum + mean * (1 - momentum).",
+            AttributeProto::FLOAT,
+            0.9f)
+        .Attr(
+            "training_mode",
+            "If set to true, it indicates BatchNormalization is being used for training, and outputs 1, "
+            "2, 3, and 4 would be populated.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "dimensions are in the form of (N x C x D1 x D2 ... Dn), "
+            "where N is the batch size, C is the number of channels. "
+            "Statistics are computed for every channel of C over N and D1 to Dn dimensions. "
+            "For image data, input dimensions become (N x C x H x W). "
+            "The op also accepts single dimension input of size N in which case C is assumed to be 1",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(1, "scale", "Scale tensor of shape (C).", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(2, "B", "Bias tensor of shape (C).", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            3,
+            "input_mean",
+            "running (training) or estimated (testing) mean tensor of shape (C).",
+            "U",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            4,
+            "input_var",
+            "running (training) or estimated (testing) variance tensor of shape (C).",
+            "U",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "Y",
+            "The output tensor of the same shape as X",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            1,
+            "running_mean",
+            "The running mean after the BatchNormalization operator.",
+            "U",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            2,
+            "running_var",
+            "The running variance after the BatchNormalization operator. This op uses the population size (N) for "
+            "calculating variance, and not the sample size N-1.",
+            "U",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint(
+            "U",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain mean and variance types to float tensors. It allows all float type for U.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateShapeAndTypeFromFirstInput(ctx);
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+
+          // Inputs 1 to 4 must be of rank 1.
+          checkInputRank(ctx, 1, 1);
+          checkInputRank(ctx, 2, 1);
+          checkInputRank(ctx, 3, 1);
+          checkInputRank(ctx, 4, 1);
+
+          Dim num_channels;
+
+          if (hasInputShape(ctx, 0)) {
+            if (getInputShape(ctx, 0).dim_size() > 1)
+              unifyInputDim(ctx, 0, 1, num_channels);
+            else
+              unifyDim(num_channels, 1);
+          }
+
+          unifyInputDim(ctx, 1, 0, num_channels);
+          unifyInputDim(ctx, 2, 0, num_channels);
+          unifyInputDim(ctx, 3, 0, num_channels);
+          unifyInputDim(ctx, 4, 0, num_channels);
+
+          if (ctx.getAttribute("training_mode") && static_cast<int>(ctx.getAttribute("training_mode")->i()) != 0) {
+            if (ctx.getNumOutputs() != 3)
+              fail_shape_inference("This number of op outputs should be 3 when Training_mode = True, but it is not.");
+          } else {
+            if (ctx.getNumOutputs() != 1)
+              fail_shape_inference("This number of op outputs should be 1 when Training_mode = False, but it is not.");
+          }
+
+          if (ctx.getNumOutputs() > 1) {
+            TensorShapeProto outputs_shape;
+            *outputs_shape.add_dim() = num_channels; // channel
+
+            propagateElemTypeFromInputToOutput(ctx, 3, 1);
+            updateOutputShape(ctx, 1, outputs_shape);
+
+            if (ctx.getNumOutputs() > 2) {
+              propagateElemTypeFromInputToOutput(ctx, 4, 2);
+              updateOutputShape(ctx, 2, outputs_shape);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    InstanceNormalization,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_InstanceNormalization_ver6)
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "epsilon",
+            "The epsilon value to use to avoid division by zero, default is 1e-5f.",
+            AttributeProto::FLOAT,
+            1e-5f)
+        .Input(0, "input", "The input 4-dimensional tensor of shape NCHW.", "T")
+        .Input(1, "scale", "The input 1-dimensional scale tensor of size C.", "T")
+        .Input(2, "B", "The input 1-dimensional bias tensor of size C.", "T")
+        .Output(0, "output", "The output 4-dimensional tensor of the same shape as input.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Dropout_old_doc = R"DOC(
+Dropout takes one input data (Tensor<float>) and produces two Tensor outputs,
+output (Tensor<float>) and mask (Tensor<bool>). Depending on whether it is in
+test mode or not, the output Y will either be a random dropout, or a simple
+copy of the input. Note that our implementation of Dropout does scaling in
+the training phase, so during testing nothing needs to be done.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Dropout,
+    1,
+    OpSchema()
+        .SetDoc(Dropout_old_doc)
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .Attr("ratio", "(float, default 0.5) the ratio of random dropout", AttributeProto::FLOAT, 0.5f)
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "is_test",
+            "(int, default 0) if nonzero, run dropout in test mode where "
+            "the output is simply Y = X.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "The input data as Tensor.", "T")
+        .Output(0, "output", "The output.", "T")
+        .Output(
+            1,
+            "mask",
+            "The output mask. If is_test is nonzero, this output is not filled.",
+            "T",
+            OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Dropout,
+    6,
+    OpSchema()
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .SetDoc(Dropout_old_doc)
+        .Attr("ratio", "(float, default 0.5) the ratio of random dropout", AttributeProto::FLOAT, 0.5f)
+        .Attr(
+            "is_test",
+            "(int, default 0) if nonzero, run dropout in test mode where "
+            "the output is simply Y = X.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "The input data as Tensor.", "T")
+        .Output(0, "output", "The output.", "T")
+        .Output(
+            1,
+            "mask",
+            "The output mask. If is_test is nonzero, this output is not filled.",
+            "T",
+            OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static const char* const Dropout_ver7_doc = Dropout_old_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Dropout,
+    7,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(Dropout_ver7_doc) + GenerateOptionalArgumentsDoc()))
+        .Attr("ratio", "The ratio of random dropout", AttributeProto::FLOAT, 0.5f)
+        .Input(0, "data", "The input data as Tensor.", "T")
+        .Output(0, "output", "The output.", "T")
+        .Output(1, "mask", "The output mask.", "T", OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+static constexpr const char* Dropout_ver10_doc = R"DOC(
+Dropout takes one input floating tensor and produces two tensor outputs,
+output (floating tensor) and mask (`Tensor<bool>`). Depending on whether it is
+in test mode or not, the output Y will either be a random dropout, or a simple
+copy of the input. Note that our implementation of Dropout does scaling in
+the training phase, so during testing nothing needs to be done.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Dropout,
+    10,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(Dropout_ver10_doc) + GenerateOptionalArgumentsDoc()))
+        .Attr("ratio", "The ratio of random dropout", AttributeProto::FLOAT, 0.5f)
+        .Input(0, "data", "The input data as Tensor.", "T")
+        .Output(0, "output", "The output.", "T")
+        .Output(1, "mask", "The output mask.", "T1", OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain output mask types to boolean tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateShapeAndTypeFromFirstInput(ctx);
+          if (ctx.getNumOutputs() == 2) {
+            updateOutputElemType(ctx, 1, TensorProto::BOOL);
+            if (hasNInputShapes(ctx, 1)) {
+              propagateShapeFromInputToOutput(ctx, 0, 1);
+            }
+          }
+        }));
+
+static constexpr const char* BatchNorm_ver6_doc = R"DOC(
+Carries out batch normalization as described in the paper
+https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+there are multiple cases for the number of outputs, which we list below:
+
+Output case #1: Y, mean, var, saved_mean, saved_var (training mode)
+Output case #2: Y (test mode)
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BatchNormalization,
+    6,
+    OpSchema()
+        .NumOutputs({1, 5})
+        .SetDoc(BatchNorm_ver6_doc)
+        .Attr(
+            "spatial",
+            "If true, compute the mean and variance across all spatial elements "
+            "If false, compute the mean and variance across per feature."
+            "Default is 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "is_test",
+            "If set to nonzero, run spatial batch normalization in test mode, default is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "epsilon",
+            "The epsilon value to use to avoid division by zero, default is 1e-5f.",
+            AttributeProto::FLOAT,
+            1e-5f)
+        .Attr(
+            "momentum",
+            "Factor used in computing the running mean and variance."
+            "e.g., running_mean = running_mean * momentum + mean * (1 - momentum), default is 0.9f.",
+            AttributeProto::FLOAT,
+            0.9f)
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non image case, the "
+            "dimensions are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the batch "
+            "size.",
+            "T")
+        .Input(
+            1,
+            "scale",
+            "The scale as a 1-dimensional tensor of size C to be applied to the "
+            "output.",
+            "T")
+        .Input(
+            2,
+            "B",
+            "The bias as a 1-dimensional tensor of size C to be applied to the "
+            "output.",
+            "T")
+        .Input(
+            3,
+            "mean",
+            "The running mean (training) or the estimated mean (testing) "
+            "as a 1-dimensional tensor of size C.",
+            "T")
+        .Input(
+            4,
+            "var",
+            "The running variance (training) or the estimated "
+            "variance (testing) as a 1-dimensional tensor of size C.",
+            "T")
+        .Output(0, "Y", "The output tensor of the same shape as X.", "T")
+        .Output(
+            1,
+            "mean",
+            "The running mean after the BatchNormalization operator. Must be in-place "
+            "with the input mean. Should not be used for testing.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            2,
+            "var",
+            "The running variance after the BatchNormalization operator. Must be "
+            "in-place with the input var. Should not be used for testing.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            3,
+            "saved_mean",
+            "Saved mean used during training to speed up gradient "
+            "computation. Should not be used for testing.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            4,
+            "saved_var",
+            "Saved variance used during training to speed up "
+            "gradient computation. Should not be used for testing.",
+            "T",
+            OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { propagateShapeAndTypeFromFirstInput(ctx); }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Flatten,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Flatten_ver24)
+        .Input(0, "input", "A tensor of rank >= axis.", "T")
+        .Output(
+            0,
+            "output",
+            "A 2D tensor with the contents of the input tensor, "
+            "with input dimensions up to axis flattened to the outer dimension "
+            "of the output and remaining input dimensions flattened into the inner "
+            "dimension of the output.",
+            "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .Attr(
+            "axis",
+            "Indicate up to which input dimensions "
+            "(exclusive) should be flattened to the outer dimension of the output. "
+            "The value for axis must be in the range [0, R], where R is the rank of the input tensor. "
+            "When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), "
+            "where the shape of the input tensor is (d_0, d_1, ... d_n). ",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int rank = static_cast<int>(input_shape.dim_size());
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+          if (axis > rank || axis < 0) {
+            fail_shape_inference("Invalid value(", axis, ") for attribute 'axis'");
+          }
+          updateOutputShape(ctx, 0, {multiplyDims(input_shape, 0, axis), multiplyDims(input_shape, axis, rank)});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Flatten,
+    9,
+    OpSchema()
+        .SetDoc(kDoc_Flatten_ver24)
+        .Input(0, "input", "A tensor of rank >= axis.", "T")
+        .Output(
+            0,
+            "output",
+            "A 2D tensor with the contents of the input tensor, "
+            "with input dimensions up to axis flattened to the outer dimension "
+            "of the output and remaining input dimensions flattened into the inner "
+            "dimension of the output.",
+            "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output to all tensor types.")
+        .Attr(
+            "axis",
+            "Indicate up to which input dimensions "
+            "(exclusive) should be flattened to the outer dimension of the output. "
+            "The value for axis must be in the range [0, R], where R is the rank of the input tensor. "
+            "When axis = 0, the shape of the output tensor is (1, (d_0 X d_1 ... d_n), "
+            "where the shape of the input tensor is (d_0, d_1, ... d_n). ",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasInputShape(ctx, 0))
+            return;
+          auto& input_shape = getInputShape(ctx, 0);
+          int rank = static_cast<int>(input_shape.dim_size());
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 1));
+          if (axis > rank || axis < 0) {
+            fail_shape_inference("Invalid value(", axis, ") for attribute 'axis'");
+          }
+          updateOutputShape(ctx, 0, {multiplyDims(input_shape, 0, axis), multiplyDims(input_shape, axis, rank)});
+        }));
+
+static constexpr const char* BatchNormalization_ver7_doc = R"DOC(
+    Carries out batch normalization as described in the paper
+    https://arxiv.org/abs/1502.03167. Depending on the mode it is being run,
+    there are multiple cases for the number of outputs, which we list below:
+
+    Output case #1: Y, mean, var, saved_mean, saved_var (training mode)
+    Output case #2: Y (test mode)
+        )DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BatchNormalization,
+    7,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(BatchNormalization_ver7_doc) + GenerateOptionalArgumentsDoc()))
+        .NumOutputs({1, 5})
+        .Attr(
+            "spatial",
+            "If true, compute the mean and variance across per activation. "
+            "If false, compute the mean and variance across per feature over "
+            "each mini-batch.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Attr(
+            "momentum",
+            "Factor used in computing the running mean and variance."
+            "e.g., running_mean = running_mean * momentum + mean * (1 - momentum).",
+            AttributeProto::FLOAT,
+            0.9f)
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "dimensions for image case are (N x C x H x W), "
+            "where N is the batch size, C is the number of "
+            "channels, and H and W are the height and the "
+            "width of the data. For non image case, the "
+            "dimensions are in the form of "
+            "(N x C x D1 x D2 ... Dn), where N is the batch "
+            "size.",
+            "T")
+        .Input(
+            1,
+            "scale",
+            "If spatial is true, the dimension of scale is (C). "
+            "If spatial is false, the dimensions of scale are "
+            "(C x D1 x ... x Dn)",
+            "T")
+        .Input(
+            2,
+            "B",
+            "If spatial is true, the dimension of bias is (C). "
+            "If spatial is false, the dimensions of bias are "
+            "(C x D1 x ... x Dn)",
+            "T")
+        .Input(
+            3,
+            "mean",
+            "If spatial is true, the dimension of the running mean "
+            "(training) or the estimated mean (testing) is (C). "
+            "If spatial is false, the dimensions of the running mean "
+            "(training) or the estimated mean (testing) are (C x D1 x ... x Dn).",
+            "T")
+        .Input(
+            4,
+            "var",
+            "If spatial is true, the dimension of the running variance"
+            "(training) or the estimated variance (testing) is (C). "
+            "If spatial is false, the dimensions of the running variance"
+            "(training) or the estimated variance (testing) are (C x D1 x ... x Dn).",
+            "T")
+        .Output(0, "Y", "The output tensor of the same shape as X", "T")
+        .Output(1, "mean", "The running mean after the BatchNormalization operator.", "T", OpSchema::Optional)
+        .Output(2, "var", "The running variance after the BatchNormalization operator.", "T", OpSchema::Optional)
+        .Output(
+            3,
+            "saved_mean",
+            "Saved mean used during training to speed up gradient "
+            "computation.",
+            "T",
+            OpSchema::Optional)
+        .Output(
+            4,
+            "saved_var",
+            "Saved variance used during training to speed up "
+            "gradient computation.",
+            "T",
+            OpSchema::Optional)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { propagateShapeAndTypeFromFirstInput(ctx); }));
+
+static constexpr const char* GroupNormalization_ver18_doc = R"DOC(
+A GroupNormalization function. Carries out group normalization as described in
+the paper https://arxiv.org/abs/1803.08494
+
+This operator transforms input according to
+```
+y = scale * (x - mean) / sqrt(variance + epsilon) + bias,
+```
+where the mean and variance are computed per instance per group of channels, and
+`scale` and `bias` should be specified for each group of channels. The number of
+groups `num_groups` should be divisible by the number of channels so that there are
+an equal number of channels per group.
+
+When the number of groups is the same as the number of channels, this operator is
+equivalent to InstanceNormalization. When there is only one group, this operator
+is equivalent to LayerNormalization.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GroupNormalization,
+    18,
+    OpSchema()
+        .Deprecate()
+        .SetDoc(GroupNormalization_ver18_doc)
+        .Attr("epsilon", "The epsilon value to use to avoid division by zero.", AttributeProto::FLOAT, 1e-5f)
+        .Attr(
+            "num_groups",
+            "The number of groups of channels. It should be a divisor of the number of channels `C`.",
+            AttributeProto::INT,
+            true)
+        .Input(
+            0,
+            "X",
+            "Input data tensor. Dimensions for image cases are `(N x C x H x W)`, where `N` is the batch size, "
+            "`C` is the number of channels, and `H` and `W` are the height and width of the data. Statistics are "
+            "computed for every group of channels over `C`, `H`, and `W`. For non-image cases, the dimensions are "
+            "in the form of `(N x C x D1 x D2 ... Dn)`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "scale",
+            "Scale tensor of shape `(num_groups)`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "bias",
+            "Bias tensor of shape `(num_groups)`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "Y",
+            "The output tensor of the same shape as `X`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input and output types to float tensors.")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) {
+              // GroupNormalization <epsilon, num_groups> (X, scale, bias) => (Y)
+              auto tp = ctx.getInputType(0);
+              if ((tp == nullptr) || (!tp->has_tensor_type()))
+                return false;
+              int64_t T = tp->tensor_type().elem_type();
+
+              auto epsilon_attr = ctx.getAttribute("epsilon");
+              float epsilon = (epsilon_attr != nullptr) ? epsilon_attr->f() : 1e-5f;
+              auto num_groups_attr = ctx.getAttribute("num_groups");
+              if (num_groups_attr == nullptr)
+                return false;
+              int64_t num_groups = num_groups_attr->i();
+
+              FunctionBuilder builder(functionProto);
+              builder.Const1D("FloatEpsilon", epsilon)
+                  .Add("Epsilon = Cast (FloatEpsilon)", "to", T)
+                  .Add("XShape = Shape (X)") // shape of input tensor: 1D tensor
+                  .Add("C = Shape <start = 1, end = 2> (X)")
+                  .Const1D("NumGroups", num_groups)
+                  .Add("GroupSize = Div (C, NumGroups)")
+                  .Add("N = Shape <start = 0, end = 1> (X)") // batch size
+                  .Add("InstanceShape = Shape <start = 2> (X)") // data instance shape
+
+                  // NewShape = [N, num_groups, group_size, H, W, (...)]
+                  .Add("NewShape = Concat <axis = 0> (N, NumGroups, GroupSize, InstanceShape)")
+                  .Add("XReshaped = Reshape (X, NewShape)")
+
+                  // Flatten into 3D tensor: [N, num_groups, group_size x H x W (x ...)]
+                  .Add("Shape3D = Constant <value_ints = [0, 0, -1]> ()")
+                  .Add("X3D = Reshape(XReshaped, Shape3D)")
+
+                  // Calculate statistics
+                  .Const1D("Axes2", static_cast<int64_t>(2))
+                  .Add("Mean = ReduceMean (X3D, Axes2)")
+                  .Add("Square = Mul (X3D, X3D)")
+                  .Add("MeanOfSquare = ReduceMean (Square, Axes2)")
+                  .Add("SquareOfMean = Mul (Mean, Mean)")
+                  .Add("Var = Sub (MeanOfSquare, SquareOfMean)")
+                  .Add("VarPlusEpsilon = Add (Var, Epsilon)")
+                  .Add("StdDev = Sqrt (VarPlusEpsilon)")
+                  .Add("Deviation = Sub (X3D, Mean)")
+                  .Add("Normalized = Div (Deviation, StdDev)")
+
+                  // Reshape scale and bias for broadcasting
+                  .Add("ScaleShape = Constant <value_ints = [1, -1, 1]> ()")
+                  .Add("ScaleT = Cast (scale)", "to", T)
+                  .Add("BiasT = Cast (bias)", "to", T)
+                  .Add("ScaleReshaped = Reshape (ScaleT, ScaleShape)")
+                  .Add("BiasReshaped = Reshape (BiasT, ScaleShape)")
+
+                  // Calculate scaled and biased output
+                  .Add("Scaled = Mul (ScaleReshaped, Normalized)")
+                  .Add("Biased = Add (Scaled, BiasReshaped)")
+                  .Add("Y = Reshape (Biased, XShape)");
+
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+
+static constexpr const char* Attention_ver23_doc = R"DOC(
+
+Computes scaled dot product attention on query, key and value tensors, using an optional attention mask if passed.
+
+This operator covers self and cross variants of the attention operation based on sequence lengths of K, Q and V.
+
+For self attention, `kv_sequence_length` equals to `q_sequence_length`.
+
+For cross attention, query and key might have different lengths.
+
+This operator also covers the 3 following variants based on the number of heads:
+1) Multi-headed Attention (MHA): Described in the paper https://arxiv.org/pdf/1706.03762, `q_num_heads = kv_num_heads`.
+2) Group-query Attention (GQA): Described in the paper https://arxiv.org/pdf/2305.13245, `q_num_heads > kv_num_heads`, `q_num_heads % kv_num_heads == 0`.
+3) Multi-query Attention (MQA): Described in the paper https://arxiv.org/pdf/1911.02150, `q_num_heads > kv_num_heads`, `kv_num_heads=1`.
+
+Attention bias to be added is calculated based on `attn_mask` input and `is_causal` attribute:
+1) `attn_mask`: A boolean mask where a value of `True` indicates that the element should take part in attention or a float mask of the same type as query, key, value that is added to the attention score.
+2) If `is_causal` is set to `1`, causal masking is applied with bottom-right (offset-aware) alignment: query `i` attends key `j` iff `j <= i + past_sequence_length` (the count of cached keys in `past_key`); for a square Q/K this is the standard lower-triangular mask. The causal frontier is computed independently of the `attn_mask` input and is then composed with it additively, by summing their attention biases: a boolean `attn_mask` intersects the allowed set (its disallowed positions contribute `-inf` to the bias), while a float `attn_mask` is added to the attention scores rather than disabling positions. A fully-masked query row (every key's combined additive bias is `-inf`, e.g. an all-`False` boolean `attn_mask` row) produces a zero output row (matching prevailing runtime practice), not `NaN`.
+
+Errata (in-place behavioral correction, no opset bump): a fully-masked query row (e.g. an all-`False` boolean `attn_mask` row) now produces a zero output row instead of `NaN`, and the same zero-row guard applies to the mode-`3` `qk_matmul_output` debug output; this only replaces previously-`NaN` outputs. The mode-`3` `qk_matmul_output` is also now emitted at the operator's output precision (`T1`), matching the reference implementation, which affects only its dtype and only when `softmax_precision` differs from `T1`. No numerically useful, well-defined result of the released opset is otherwise changed.
+
+Both past and present state key/values are optional. They shall be used together, and not allowed to use only one of them.
+The following pattern is applied to the Q, K and V inputs after appropriate reshaping of K and V inputs based on sequence lengths and num heads provided:
+
+```
+  The following pattern is applied by this operator:
+      Q          K          V
+      |          |          |
+Q*sqrt(scale) K*sqrt(scale) |
+      |          |          |
+      |       Transpose     |
+      |          |          |
+      ---MatMul---          |
+            |               |
+  softcap (if provided)     |
+            |               |
+ at_mask---Add              |
+            |               |
+         Softmax            |
+            |               |
+            -----MatMul------
+                   |
+                   Y
+```
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Attention,
+    23,
+    OpSchema()
+        .SetDoc(Attention_ver23_doc)
+        .Attr(
+            "is_causal",
+            "If set to `1`, causal masking is applied with bottom-right (offset-aware) alignment: "
+            "query `i` attends key `j` iff `j <= i + past_sequence_length` (the count of cached keys in "
+            "`past_key`); for a square Q/K this is the standard lower-triangular mask.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "scale",
+            "Scaling factor applied to $Q*K^T$. Default value is `1/sqrt(head_size)`. To prevent "
+            "[numerical overflow](https://tinyurl.com/sudb9s96), scale `Q`, `K` by `sqrt(scale)` before matmul.",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "q_num_heads",
+            "Number of heads of query. Must be used with 3D inputs of Q, K and V. ",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "kv_num_heads",
+            "Number of heads of key and value. Must be used with 3D inputs of Q, K and V. ",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "softmax_precision",
+            "The floating-point precision used in softmax computation. "
+            "If softmax precision is not provided, the same precision as the input of softmax (Q and K) is used.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "softcap",
+            "Softcap value for attention weights. Default value is 0.",
+            AttributeProto::FLOAT,
+            static_cast<float>(0))
+        .Attr(
+            "qk_matmul_output_mode",
+            "If set to `0`, qk_matmul_output is the output of qk matmul. "
+            "If set to `1`, qk_matmul_output is the output after the softcap operation (before mask addition). "
+            "If set to `2`, qk_matmul_output includes the attention mask and softcap (if provided) applied to the output of qk matmul. "
+            "If set to `3`, qk_matmul_output is the output after the softmax operation. "
+            "In mode `3`, a fully-masked query row (every key disallowed, e.g. an all-`False` boolean `attn_mask` row) "
+            "is a zero row, consistent with the corresponding row of the primary output `Y`: the "
+            "fully-masked-row guard is applied before this output is produced. "
+            "The mode-`3` output is emitted at the operator's output precision (`T1`); when "
+            "`softmax_precision` differs from `T1` this is a cast of the softmax result to `T1`. "
+            "Default value is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "Q",
+            "Query tensor. "
+            "4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, q_hidden_size)`. "
+            "For cases with a 3D input tensor, `q_hidden_size = q_num_heads * head_size`",
+            "T1")
+        .Input(
+            1,
+            "K",
+            "Key tensor. "
+            "4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, k_hidden_size)`. "
+            "For cases with a 3D input tensor, `k_hidden_size = kv_num_heads * head_size`",
+            "T1")
+        .Input(
+            2,
+            "V",
+            "Value tensor. "
+            "4D tensor with shape `(batch_size, kv_num_heads, kv_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, kv_sequence_length, v_hidden_size)`. "
+            "For cases with a 3D input tensor, `v_hidden_size = kv_num_heads * v_head_size`",
+            "T2")
+        .Input(
+            3,
+            "attn_mask",
+            "Attention mask. "
+            "Shape must be broadcastable to "
+            "4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` "
+            "where `total_sequence_length = past_sequence_length + kv_sequence_length.` "
+            "Two types of masks are supported. A boolean mask where a value of `True` indicates that the element should take part in attention. "
+            "Also supports a float mask of the same type as query, key, value that is added to the attention score.",
+            "U",
+            OpSchema::Optional)
+        .Input(
+            4,
+            "past_key",
+            "past state cache for key with shape `(batch_size, kv_num_heads, past_sequence_length, head_size)`",
+            "T1",
+            OpSchema::Optional)
+        .Input(
+            5,
+            "past_value",
+            "past state cache for value with shape `(batch_size, kv_num_heads, past_sequence_length, v_head_size)`",
+            "T2",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "Y",
+            "The output tensor . "
+            "4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, v_head_size)` or 3D tensor with shape `(batch_size, q_sequence_length, hidden_size)`. "
+            "For cases with a 3D input tensor, `hidden_size = q_num_heads * v_head_size`",
+            "T1")
+        .Output(
+            1,
+            "present_key",
+            "Updated key cache with shape `(batch_size, kv_num_heads, total_sequence_length, head_size)` "
+            "where `total_sequence_length = past_sequence_length + kv_sequence_length`.",
+            "T1",
+            OpSchema::Optional)
+        .Output(
+            2,
+            "present_value",
+            "Updated value cache with shape `(batch_size, kv_num_heads, total_sequence_length, v_head_size)` "
+            "where `total_sequence_length = past_sequence_length + kv_sequence_length`.",
+            "T2",
+            OpSchema::Optional)
+        .Output(
+            3,
+            "qk_matmul_output",
+            "The output of QK matmul. "
+            "4D tensor with shape `(batch_size, q_num_heads, q_sequence_length, total_sequence_length)` "
+            "where `total_sequence_length = past_sequence_length + kv_sequence_length`.",
+            "T1",
+            OpSchema::Optional)
+        .TypeConstraint("T1", OpSchema::all_float_types_ir4(), "Constrain Q and K inputs types to float tensors.")
+        .TypeConstraint("T2", OpSchema::all_float_types_ir4(), "Constrain V input types to float tensors.")
+        .TypeConstraint(
+            "U",
+            OpSchema::all_non_complex_numeric_types_plus_bool_ir4(),
+            "Constrain output 'mask' types to boolean tensors and input types.")
+        .TypeAndShapeInferenceFunction(defs::nn::utils::AttentionPropagateElemTypeFromInputToOutput)
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder([](const FunctionBodyBuildContext& ctx,
+                                                   const OpSchema& schema,
+                                                   FunctionProto& functionProto) {
+          // ScaledDotProductAttention <scale, is_causal, q_num_heads, kv_numheads> (Q, K, V, attn_mask, past_key,
+          // past_value) => (Y, present_key?, present_value?)
+          int64_t int_type = ONNX_NAMESPACE::TensorProto_DataType_INT64;
+          int64_t float_type = ONNX_NAMESPACE::TensorProto_DataType_FLOAT;
+
+          // Get input types
+          auto t_qk = ctx.getInputType(0);
+          if ((t_qk == nullptr) || (!t_qk->has_tensor_type()))
+            return false;
+          int64_t T1 = t_qk->tensor_type().elem_type();
+
+          // Determine precision types for Softmax
+          auto softmax_precision_attr = ctx.getAttribute("softmax_precision");
+          int64_t softmax_precision = (softmax_precision_attr != nullptr) ? softmax_precision_attr->i() : T1;
+          if ((softmax_precision != ONNX_NAMESPACE::TensorProto_DataType_FLOAT) &&
+              (softmax_precision != ONNX_NAMESPACE::TensorProto_DataType_BFLOAT16) &&
+              (softmax_precision != ONNX_NAMESPACE::TensorProto_DataType_FLOAT16) &&
+              (softmax_precision != ONNX_NAMESPACE::TensorProto_DataType_DOUBLE))
+            return false; // Error
+
+          // If shape is 3D, q_num_heads and kv_num_heads is provided,
+          // for 4D cases, set num_heads to zero for reshape purposes
+          auto q_num_heads_attr = ctx.getAttribute("q_num_heads");
+          int64_t q_num_heads = (q_num_heads_attr != nullptr) ? q_num_heads_attr->i() : 0;
+          auto kv_num_heads_attr = ctx.getAttribute("kv_num_heads");
+          int64_t kv_num_heads = (kv_num_heads_attr != nullptr) ? kv_num_heads_attr->i() : 0;
+
+          // Determine if input is 3D (requires reshape and transpose) or 4D (direct reshape)
+          bool is_3d_input = (q_num_heads > 0 && kv_num_heads > 0);
+
+          FunctionBuilder builder(functionProto);
+          builder
+              .Add("BatchSize = Shape <start = 0, end = 1> (Q)") // batch size
+              .Add("QSeqLen = Shape <start = -2, end = -1> (Q)") // q_sequence_length
+              .Add("KVSeqLen = Shape <start = -2, end = -1> (K)"); // kv_sequence_length
+          if (is_3d_input) {
+            // For 3D inputs: First reshape to [batch_size, seq_length, num_heads, head_size]
+            // then transpose to [batch_size, num_heads, seq_length, head_size]
+            builder
+                .Const1D("QNumHeadsAttr", q_num_heads) // q_num_heads from attrs
+                .Const1D("KVNumHeadsAttr", kv_num_heads) // kv_num_heads from attrs
+                .Const1D("NegOne", static_cast<int64_t>(-1)); // head_size, inferred from other dimensions
+
+            builder.Add("QIntermediateShape = Concat <axis = 0> (BatchSize, QSeqLen, QNumHeadsAttr, NegOne)")
+                .Add("KVIntermediateShape = Concat <axis = 0> (BatchSize, KVSeqLen, KVNumHeadsAttr, NegOne)")
+                .Add("QIntermediate = Reshape (Q, QIntermediateShape)")
+                .Add("KIntermediate = Reshape (K, KVIntermediateShape)")
+                .Add("VIntermediate = Reshape (V, KVIntermediateShape)")
+                // Then transpose to [batch_size, num_heads, seq_length, head_size]
+                .Add("QReshaped = Transpose <perm = [0, 2, 1, 3]> (QIntermediate)")
+                .Add("KReshaped = Transpose <perm = [0, 2, 1, 3]> (KIntermediate)")
+                .Add("VReshaped = Transpose <perm = [0, 2, 1, 3]> (VIntermediate)");
+          } else {
+            // For 4D inputs: Already in desired shape [batch_size, num_heads, seq_length, head_size]
+            builder.Add("QReshaped = Identity(Q)").Add("KReshaped = Identity(K)").Add("VReshaped = Identity(V)");
+          }
+
+          builder
+              .Add("QNumHeads = Shape <start = 1, end = 2> (QReshaped)") // q_num_heads
+              .Add("KVNumHeads = Shape <start = 1, end = 2> (KReshaped)"); // kv_num_heads
+
+          // Calculate scaling factor if scale attribute not provided
+          auto scale_attr = ctx.getAttribute("scale");
+          float scale = (scale_attr != nullptr) ? scale_attr->f() : static_cast<float>(1);
+          builder
+              .Add("QKHeadSize = Shape <start = 3, end = 4> (QReshaped)") // head_size for Q and K
+              .Add("QKHeadSizeF = Cast (QKHeadSize)", "to", float_type)
+              .Add("VHeadSize = Shape <start = 3, end = 4> (VReshaped)") // head_size for V
+              .Add("SqrtHeadSize = Sqrt(QKHeadSizeF)")
+              .Const1D("One1D", static_cast<int64_t>(1))
+              .Const1D("One1DF", static_cast<float>(1))
+              .Const1D("Zero1D", static_cast<int64_t>(0))
+              .Add("CalculatedScale = Div(One1DF, SqrtHeadSize)")
+              .Const("ScaleF", ToTensor<float>(scale))
+              .Add(scale_attr != nullptr ? "ScaleFactor = Identity(ScaleF)" : "ScaleFactor = Identity(CalculatedScale)")
+              .Add("ScaleFactorSqrt = Sqrt(ScaleFactor)")
+              .Add("ScaleFactorF = Cast (ScaleFactorSqrt)", "to", T1);
+
+          // Update key and value caches for past and present states
+
+          if (ctx.hasInput(4)) {
+            builder.Add("PresentKey = Concat <axis = 2> (past_key, KReshaped)");
+            builder.Add("PastKVSeqLen =  Shape <start = -2, end = -1> (past_key)");
+          } else {
+            builder.Add("PresentKey = Identity (KReshaped)");
+            builder.Const1D("PastKVSeqLen", static_cast<int64_t>(0));
+          }
+          if (ctx.hasOutput(1)) {
+            builder.Add("present_key = Identity (PresentKey)");
+          }
+
+          if (ctx.hasInput(5)) {
+            builder.Add("PresentValue = Concat <axis = 2> (past_value, VReshaped)");
+          } else {
+            builder.Add("PresentValue = Identity (VReshaped)");
+          }
+          if (ctx.hasOutput(2)) {
+            builder.Add("present_value = Identity (PresentValue)");
+          }
+
+          if (!defs::nn::utils::AttentionAppendFunctionCausalMask(ctx, builder, false))
+            return false;
+          builder.Add("AttnBiasT = Cast (AttnBiasCausalOrNot)", "to", T1);
+
+          // Group Query Attention is applied if the following are satisfied
+          // 1) q_num_heads != kv_num_heads
+          // 2) q_num_heads % kv_num_heads == 0
+          // 3) kv_num_heads == k_num_heads == v_num_heads
+          builder.Add("NGQACond1 = Equal(QNumHeads, KVNumHeads)")
+              .Add("GQACond1 = Not(NGQACond1)")
+              .Add("DivNumHeads = Div(QNumHeads, KVNumHeads)")
+              .Add("IDivNumHeads = Cast(DivNumHeads)", "to", int_type)
+              .Add("RemainderNumHeads = Mod(QNumHeads, KVNumHeads)")
+              .Add("GQACond2 = Equal(RemainderNumHeads, Zero1D)")
+              .Add("GQACond = And(GQACond1, GQACond2)")
+              .Add("InterleaveDim = Where(GQACond, IDivNumHeads, One1D)");
+
+          // repeat kv (repeat_interleave)
+          builder.Const1D("Two1D", static_cast<int64_t>(2))
+              .Add("KUnsqueezed = Unsqueeze(PresentKey, Two1D)") // [B, Hk, 1, T, Dk]
+              .Add("VUnsqueezed = Unsqueeze(PresentValue, Two1D)"); // [B, Hk, 1, T, Dv]
+
+          // Build expand shape: [B, Hk, repeats, T, Dk]
+          builder
+              .Add("KExpandShape = Concat <axis = 0> (BatchSize, KVNumHeads, InterleaveDim, NewKVSeqLen, QKHeadSize)")
+              .Add("KExpanded = Expand(KUnsqueezed, KExpandShape)");
+          builder.Add("VExpandShape = Concat <axis = 0> (BatchSize, KVNumHeads, InterleaveDim, NewKVSeqLen, VHeadSize)")
+              .Add("VExpanded = Expand(VUnsqueezed, VExpandShape)");
+
+          // Reshape to [B, Hq, T, Dk] where Hq = Hk * repeats
+          builder.Add("KAttentionShape = Concat <axis = 0> (BatchSize, QNumHeads, NewKVSeqLen, QKHeadSize)")
+              .Add("VAttentionShape = Concat <axis = 0> (BatchSize, QNumHeads, NewKVSeqLen, VHeadSize)")
+              .Add("KAttentionInput = Reshape(KExpanded, KAttentionShape)")
+              .Add("VAttentionInput = Reshape(VExpanded, VAttentionShape)");
+
+          // The following pattern is applied
+          //      Q          K          V
+          //      |          |          |
+          //     Q*scale    K*scale     |
+          //      |          |          |
+          //      |       Transpose     |
+          //      |          |          |
+          //      ---MatMul---          |
+          //            |               |
+          //  softcap (if provided)     |
+          //            |               |
+          // at_mask---Add              |
+          //            |               |
+          //         Softmax            |
+          //            |               |
+          //            -----MatMul------
+          //                    |
+          //                    Y
+          builder.Add("KTranspose = Transpose <perm = [0, 1, 3, 2]> (KAttentionInput)")
+              .Add("QScaled = Mul(QReshaped, ScaleFactorF)")
+              .Add("KScaled = Mul(KTranspose, ScaleFactorF)")
+              .Add("QKAttnWeight = MatMul(QScaled, KScaled)")
+              .Add("QKAttnCast = Cast (QKAttnWeight)", "to", T1);
+
+          // Apply softcap before bias/mask addition.
+          // Softcap must come before mask so that -inf mask values remain -inf
+          // (zero probability in softmax). If applied after, -inf maps to
+          // -softcap (finite), leaking probability to masked positions.
+          auto softcap_attr = ctx.getAttribute("softcap");
+          float softcap_val = (softcap_attr != nullptr) ? softcap_attr->f() : static_cast<float>(0);
+          if (softcap_val != 0) {
+            builder.Const1D("Softcap", softcap_val)
+                .Add("SoftcapF = Cast (Softcap)", "to", T1)
+                .Add("SoftcapDiv = Div(QKAttnCast, SoftcapF)")
+                .Add("SoftcapTanh = Tanh(SoftcapDiv)")
+                .Add("QKAttnSoftcapped = Mul(SoftcapTanh, SoftcapF)")
+                .Add("QKAttnWeightSoftcap = Add(QKAttnSoftcapped, AttnBiasT)");
+          } else {
+            builder.Add("QKAttnWeightSoftcap = Add(QKAttnCast, AttnBiasT)");
+          }
+          builder.Add("SoftmaxCast = Cast (QKAttnWeightSoftcap)", "to", softmax_precision)
+              .Add("AttnWeightSoftmax = Softmax (SoftmaxCast)")
+              .Add("SoftmaxOut = Cast (AttnWeightSoftmax)", "to", T1);
+
+          // Fully-masked-row guard: a query row whose additive bias (AttnBiasT) is
+          // entirely -inf softmaxes to NaN. Detect such rows on the additive bias
+          // row-max and zero their probabilities with Where (not Mul; NaN * 0 = NaN)
+          // BEFORE the P @ V contraction so 0 @ V = 0. The guard runs before the
+          // mode-3 output capture so the exposed qk_matmul_output row is also zeroed,
+          // consistent with Y. Mirrors the reference impl so primary == _expanded
+          // bit-for-bit. In v23 the only reachable fully-masked rows come from an
+          // all-False bool attn_mask (no nonpad/external cache).
+          builder.Add("BiasRowMaxAxes = Constant <value = int64[1] {-1}> ()")
+              .Add("BiasRowMax = ReduceMax(AttnBiasT, BiasRowMaxAxes)") // keepdims=1 (default)
+              .Add("FloatNegInfT = CastLike(FloatNegInf, AttnBiasT)")
+              .Add("RowAllMasked = Equal(BiasRowMax, FloatNegInfT)")
+              .Add("ZeroProbT = CastLike(ScalarZero, SoftmaxOut)")
+              .Add("SoftmaxOutSafe = Where(RowAllMasked, ZeroProbT, SoftmaxOut)");
+
+          // QK MatMul output if required
+          auto qk_matmul_output_mode_attr = ctx.getAttribute("qk_matmul_output_mode");
+          int64_t qk_matmul_output_mode = (qk_matmul_output_mode_attr != nullptr) ? qk_matmul_output_mode_attr->i() : 0;
+          if (ctx.hasOutput(3)) {
+            if (qk_matmul_output_mode == 1) {
+              // Mode 1: after softcap (before bias addition)
+              if (softcap_val != 0) {
+                builder.Add("qk_matmul_output = Identity(QKAttnSoftcapped)");
+              } else {
+                // No softcap applied, same as raw QK
+                builder.Add("qk_matmul_output = Identity(QKAttnCast)");
+              }
+            } else if (qk_matmul_output_mode == 2) {
+              // Mode 2: QK + softcap + bias (after softcap + bias addition)
+              builder.Add("qk_matmul_output = Identity(QKAttnWeightSoftcap)");
+            } else if (qk_matmul_output_mode == 3) {
+              // Mode 3: post-softmax, after the fully-masked-row guard (a fully-masked
+              // row is zeroed, consistent with the primary output Y).
+              builder.Add("qk_matmul_output = Identity(SoftmaxOutSafe)");
+            } else {
+              builder.Add("qk_matmul_output = Identity(QKAttnWeight)");
+            }
+          }
+
+          builder.Add("YPreReshape = MatMul(SoftmaxOutSafe, VAttentionInput)");
+          // Reshape Y to 3D if input is a 3D tensor
+          if (is_3d_input) {
+            builder.Add("YTranspose = Transpose <perm = [0, 2, 1, 3]> (YPreReshape)")
+                .Add("YNewShape = Concat <axis = 0> (Zero1D, Zero1D, NegOne)")
+                .Add("Y = Reshape(YTranspose, YNewShape)");
+          } else {
+            builder.Add("Y = Identity(YPreReshape)");
+          }
+
+          schema.BuildFunction(functionProto);
+          return true;
+        }));
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/nn/utils.cc b/onnx/defs/nn/utils.cc
new file mode 100644
index 0000000..fc5e62d
--- /dev/null
+++ b/onnx/defs/nn/utils.cc
@@ -0,0 +1,259 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/nn/utils.h"
+
+#include <algorithm>
+
+namespace ONNX_NAMESPACE {
+namespace defs {
+namespace nn {
+namespace utils {
+
+std::vector<int64_t> getConvPoolStrides(InferenceContext& ctx, size_t n_input_dims) {
+  std::vector<int64_t> strides;
+  if (getRepeatedAttribute(ctx, "strides", strides)) {
+    if (strides.size() != n_input_dims) {
+      fail_shape_inference("Attribute strides has incorrect size");
+    }
+    if (std::any_of(strides.begin(), strides.end(), [](int64_t s) { return s <= 0; })) {
+      fail_shape_inference("Attribute strides must only contain positive values");
+    }
+  } else {
+    strides.assign(n_input_dims, 1);
+  }
+  return strides;
+}
+
+void AttentionPropagateElemTypeFromInputToOutput(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  int64_t kv_sequence_length = -1;
+  ONNX_NAMESPACE::TensorShapeProto output_shape;
+  ONNX_NAMESPACE::TensorShapeProto qk_matmul_shape;
+  if (hasInputShape(ctx, 0)) {
+    const auto& query_shape = getInputShape(ctx, 0);
+    const auto& query_dims = query_shape.dim();
+    if ((query_dims.size() != 3) && (query_dims.size() != 4)) {
+      fail_shape_inference("Inputs 0 (query) shall be 3 or 4 dimensions");
+    }
+
+    if (query_dims.size() == 3) {
+      const auto* const q_num_heads_attr = ctx.getAttribute("q_num_heads");
+      if (q_num_heads_attr == nullptr) {
+        fail_type_inference("3D inputs expected to have q_num_heads attribute.");
+      }
+      const auto* const kv_num_heads_attr = ctx.getAttribute("kv_num_heads");
+      if (kv_num_heads_attr == nullptr) {
+        fail_type_inference("3D inputs expected to have q_num_heads attribute.");
+      }
+    }
+
+    *output_shape.add_dim() = query_dims[0]; // batch_size
+    *output_shape.add_dim() = query_dims[1]; // num_heads for 4D, sequence_length for 3D
+
+    *qk_matmul_shape.add_dim() = query_dims[0]; // batch_size
+
+    if (hasInputShape(ctx, 1)) {
+      const auto& key_shape = getInputShape(ctx, 1);
+      const auto& key_dims = key_shape.dim();
+      if ((key_dims.size() != 3) && (key_dims.size() != 4)) {
+        fail_shape_inference("Inputs 1 (key) shall be 3 or 4 dimensions");
+      }
+    }
+
+    if (hasInputShape(ctx, 2)) {
+      const auto& value_shape = getInputShape(ctx, 2);
+      const auto& value_dims = value_shape.dim();
+      if ((value_dims.size() != 3) && (value_dims.size() != 4)) {
+        fail_shape_inference("Inputs 2 (value) shall be 3 or 4 dimensions");
+      }
+
+      // Update Output Shape for 4D inputs
+      // Input 0 (query) has shape (batch_size, q_num_heads, q_sequence_length, head_size)
+      // Input 1 (key) has shape (batch_size, kv_num_heads, kv_sequence_length, head_size)
+      // Input 2 (value) has shape (batch_size, kv_num_heads, kv_sequence_length, v_head_size)
+      // Output 0 has shape (batch_size, q_num_heads, q_sequence_length, v_head_size)
+      if (value_dims.size() == 4 && query_dims.size() == 4) {
+        kv_sequence_length = value_dims[2].dim_value();
+        *output_shape.add_dim() = query_dims[2]; // sequence_length
+        *output_shape.add_dim() = value_dims[3]; // head_size
+        updateOutputShape(ctx, 0, output_shape);
+        // Update qk_matmul_shape
+        *qk_matmul_shape.add_dim() = query_dims[1]; // q_num_heads
+        *qk_matmul_shape.add_dim() = query_dims[2]; // q_sequence_length
+        qk_matmul_shape.add_dim()->set_dim_value(kv_sequence_length);
+      }
+
+      // Update Output Shape for 3D inputs
+      // Input 0 (query) has shape (batch_size, q_sequence_length, q_hidden_size),
+      // q_hidden_size = q_num_heads * head_size
+      // Input 1 (key) has shape (batch_size, kv_sequence_length, k_hidden_size),
+      // k_hidden_size = kv_num_heads * head_size
+      // Input 2 (value) has shape (batch_size, kv_sequence_length, v_hidden_size),
+      // v_hidden_size = kv_num_heads * v_head_size
+      // Output 0 has shape (batch_size, q_sequence_length, hidden_size),
+      // hidden_size = q_num_heads * v_head_size
+      if (value_dims.size() == 3 && query_dims.size() == 3) {
+        kv_sequence_length = value_dims[1].dim_value();
+        const auto* const q_num_heads_attr = ctx.getAttribute("q_num_heads");
+        if (q_num_heads_attr == nullptr) {
+          fail_type_inference("3D inputs expected to have q_num_heads attribute.");
+        }
+        const auto* const kv_num_heads_attr = ctx.getAttribute("kv_num_heads");
+        if (kv_num_heads_attr == nullptr) {
+          fail_type_inference("3D inputs expected to have kv_num_heads attribute.");
+        }
+        int64_t q_num_heads = q_num_heads_attr->i();
+        int64_t kv_num_heads = kv_num_heads_attr->i();
+        // Calculate v_head_size
+        int64_t v_head_size = value_dims[2].dim_value() / kv_num_heads;
+        output_shape.add_dim()->set_dim_value(v_head_size * q_num_heads);
+        updateOutputShape(ctx, 0, output_shape);
+        // Update qk_matmul_shape
+        qk_matmul_shape.add_dim()->set_dim_value(q_num_heads);
+        *qk_matmul_shape.add_dim() = query_dims[1];
+        qk_matmul_shape.add_dim()->set_dim_value(kv_sequence_length);
+      }
+    }
+  }
+
+  if (ctx.hasOutput(3)) { // has qk_matmul_output
+    propagateElemTypeFromInputToOutput(ctx, 0, 3);
+    updateOutputShape(ctx, 3, qk_matmul_shape);
+  }
+
+  if (ctx.hasOutput(1) && ctx.hasOutput(2)) { // has present outputs
+    if (ctx.hasInput(4) && ctx.hasInput(5)) { // has past_key
+      // copy the type from query to present key and value
+      propagateElemTypeFromInputToOutput(ctx, 4, 1);
+      propagateElemTypeFromInputToOutput(ctx, 5, 2);
+
+      if (hasInputShape(ctx, 4) && hasInputShape(ctx, 5)) {
+        const auto& past_key_shape = getInputShape(ctx, 4);
+        const auto& past_key_dims = past_key_shape.dim();
+        const auto& past_value_shape = getInputShape(ctx, 5);
+        const auto& past_value_dims = past_value_shape.dim();
+
+        // past key has shape (batch_size, kv_num_heads, past_sequence_length, head_size)
+        if (past_key_dims.size() != 4) {
+          fail_shape_inference("The past_key input shall be 4 dimensions");
+        }
+        // past value has shape (batch_size, kv_num_heads, past_sequence_length, v_head_size)
+        if (past_value_dims.size() != 4) {
+          fail_shape_inference("The past_value input shall be 4 dimensions");
+        }
+
+        if (kv_sequence_length > 0 && past_key_dims[2].has_dim_value()) {
+          int64_t total_sequence_length = kv_sequence_length + past_key_dims[2].dim_value();
+
+          ONNX_NAMESPACE::TensorShapeProto present_key_shape;
+          for (const auto& dim : past_key_dims) {
+            *present_key_shape.add_dim() = dim;
+          }
+
+          ONNX_NAMESPACE::TensorShapeProto present_value_shape;
+          for (const auto& dim : past_value_dims) {
+            *present_value_shape.add_dim() = dim;
+          }
+
+          if (ctx.hasOutput(3)) { // has qk_matmul_output with bias
+            qk_matmul_shape.mutable_dim(3)->set_dim_value(total_sequence_length);
+            updateOutputShape(ctx, 3, qk_matmul_shape);
+          }
+
+          // shape of present key/value is (batch_size, kv_num_heads, total_sequence_length, head_size)
+          present_key_shape.mutable_dim(2)->set_dim_value(total_sequence_length);
+          present_value_shape.mutable_dim(2)->set_dim_value(total_sequence_length);
+
+          updateOutputShape(ctx, 1, present_key_shape);
+          updateOutputShape(ctx, 2, present_value_shape);
+        }
+      }
+    }
+  }
+}
+
+bool AttentionAppendFunctionCausalMask(const FunctionBodyBuildContext& ctx, FunctionBuilder& builder, bool padding) {
+  builder.Add("NewKVSeqLen =  Shape <start = -2, end = -1> (PresentKey)")
+      .Add("AttnBiasShape = Concat <axis = 0> (QSeqLen, NewKVSeqLen)");
+  float neg_inf = -std::numeric_limits<float>::infinity();
+  builder.Const1D("FloatNegInf", neg_inf);
+  builder.Const1D("ScalarZero", 0.f);
+
+  // If attn_mask is provided
+  if (ctx.hasInput(3)) {
+    const auto* const up = ctx.getInputType(3);
+    if ((up == nullptr) || (!up->has_tensor_type()))
+      return false;
+    int64_t U = up->tensor_type().elem_type();
+    builder.Add(
+        U == ONNX_NAMESPACE::TensorProto_DataType_BOOL ? "AttnBiasShort = Where(attn_mask, ScalarZero, FloatNegInf)"
+                                                       : "AttnBiasShort = Identity(attn_mask)");
+    // If attn_mask has a shorter kv sequence length, we pad it to NewKVSeqLen with FloatNegInf
+    if (padding) {
+      builder.Add("MaskKVSeqLen = Shape <start = -1> (attn_mask)")
+          .Add("PaddingKVSeqLen = Sub(NewKVSeqLen, MaskKVSeqLen)")
+          .Add("Pads = Concat <axis = 0> (Zero1D, PaddingKVSeqLen)")
+          .Add("FloatNegInfCast = CastLike(FloatNegInf, AttnBiasShort)")
+          .Add("AttnBias = Pad(AttnBiasShort, Pads, FloatNegInfCast, NegOne1D)");
+    } else {
+      builder.Add("AttnBias = Identity(AttnBiasShort)");
+    }
+  } else {
+    builder.Add("AttnBias = ConstantOfShape(AttnBiasShape)");
+  }
+
+  // If is_causal is set to true, causal masking is applied with bottom-right
+  // (offset-aware) alignment: a query at in-block index i attends key j iff
+  // j <= i + offset, where offset is the number of valid keys preceding the query block.
+  // For an internal past_key cache offset is the scalar PastKVSeqLen; for an external
+  // (static) cache (nonpad_kv_seqlen present, no past_key) offset is per batch and the
+  // builder scope holds CausalOffsetPerBatch (= nonpad_kv_seqlen - q_len).
+  // When both attn_mask and is_causal are set, the two are combined: a boolean
+  // attn_mask intersects with the causal frontier (a position is attended only if
+  // allowed by both), while a float attn_mask is added as a bias to the causal
+  // bias rather than strictly disabling positions (matching defs.cc).
+  const auto* const is_causal_attr = ctx.getAttribute("is_causal");
+  int64_t is_causal = (is_causal_attr != nullptr) ? is_causal_attr->i() : 0;
+  const bool external_cache_offset = (is_causal == 1) && ctx.hasInput(6) && !ctx.hasInput(4);
+  if (is_causal == 1) {
+    builder.Const1D("Zero", static_cast<int64_t>(0))
+        .Const1D("One", static_cast<int64_t>(1))
+        .Add("ZeroNoDim = Squeeze(Zero, Zero)")
+        .Add("OneNoDim = Squeeze(One, Zero)")
+        .Add("SequenceLength = Gather(AttnBiasShape, ZeroNoDim)")
+        .Add("TotalSequenceLength = Gather(AttnBiasShape, OneNoDim)")
+        .Add("RangeRow = Range(ZeroNoDim, SequenceLength, OneNoDim)")
+        .Add("RangeRow2D = Unsqueeze(RangeRow, One)")
+        .Add("RangeCol = Range(ZeroNoDim, TotalSequenceLength, OneNoDim)")
+        .Add("RangeCol2D = Unsqueeze(RangeCol, Zero)");
+    if (external_cache_offset) {
+      // Per-batch bottom-right frontier: broadcast the (batch,) offset into a 4D
+      // (batch, 1, q, total) boolean mask so it composes with the (batch,1,1,kv)
+      // padding mask added by the caller.
+      builder.Const("Axes01", std::vector<int64_t>{0, 1})
+          .Const("Axes123", std::vector<int64_t>{1, 2, 3})
+          .Add("RangeRow4D = Unsqueeze(RangeRow2D, Axes01)") // (1, 1, q, 1)
+          .Add("RangeCol4D = Unsqueeze(RangeCol2D, Axes01)") // (1, 1, 1, total)
+          .Add("OffsetB4D = Unsqueeze(CausalOffsetPerBatch, Axes123)") // (batch, 1, 1, 1)
+          .Add("RowPlusOff = Add(RangeRow4D, OffsetB4D)") // (batch, 1, q, 1)
+          .Add("BoolMaskTri = Less(RowPlusOff, RangeCol4D)"); // (batch, 1, q, total)
+    } else {
+      // Internal cache / no cache: scalar offset (PastKVSeqLen), 2D (q, total) mask.
+      builder.Add("RangeRow2DPast = Add(RangeRow2D, PastKVSeqLen)")
+          .Add("BoolMaskTri = Less(RangeRow2DPast, RangeCol2D)");
+    }
+    builder.Add("MaskTri = Where(BoolMaskTri, FloatNegInf, ScalarZero)")
+        .Add("AttnBiasCausalOrNot = Add(AttnBias, MaskTri)");
+  } else {
+    builder.Add("AttnBiasCausalOrNot = Identity(AttnBias)");
+  }
+  return true;
+}
+
+} // namespace utils
+} // namespace nn
+} // namespace defs
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/nn/utils.h b/onnx/defs/nn/utils.h
new file mode 100644
index 0000000..9f3fa38
--- /dev/null
+++ b/onnx/defs/nn/utils.h
@@ -0,0 +1,32 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <vector>
+
+#include "onnx/common/assertions.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+namespace defs {
+namespace nn {
+namespace utils {
+
+/**
+ * Reads and validates the 'strides' attribute for Conv/Pool shape inference.
+ * Returns the attribute value or a default value if the attribute is not present.
+ */
+std::vector<int64_t> getConvPoolStrides(InferenceContext& ctx, size_t n_input_dims);
+
+/** Implements shape and type propagation for Attention (23-). */
+void AttentionPropagateElemTypeFromInputToOutput(InferenceContext& ctx);
+
+/** Implements CausalMask for Attention. */
+bool AttentionAppendFunctionCausalMask(const FunctionBodyBuildContext& ctx, FunctionBuilder& builder, bool padding);
+
+} // namespace utils
+} // namespace nn
+} // namespace defs
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/object_detection/CMakeLists.txt b/onnx/defs/object_detection/CMakeLists.txt
new file mode 100644
index 0000000..0804eec
--- /dev/null
+++ b/onnx/defs/object_detection/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+)
diff --git a/onnx/defs/object_detection/defs.cc b/onnx/defs/object_detection/defs.cc
new file mode 100644
index 0000000..34b4c66
--- /dev/null
+++ b/onnx/defs/object_detection/defs.cc
@@ -0,0 +1,169 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RoiAlign,
+    22,
+    OpSchema()
+        .SetDoc(kDoc_RoiAlign_ver16)
+        .Attr(
+            "spatial_scale",
+            "Multiplicative spatial scale factor to translate ROI coordinates "
+            "from their input spatial scale to the scale used when pooling, "
+            "i.e., spatial scale of the input feature map X relative to the "
+            "input image. E.g.; default is 1.0f. ",
+            AttributeProto::FLOAT,
+            1.f)
+        .Attr("output_height", "default 1; Pooled output Y's height.", AttributeProto::INT, static_cast<int64_t>(1))
+        .Attr("output_width", "default 1; Pooled output Y's width.", AttributeProto::INT, static_cast<int64_t>(1))
+        .Attr(
+            "sampling_ratio",
+            "Number of sampling points in the interpolation grid used to compute "
+            "the output value of each pooled output bin. If > 0, then exactly "
+            "sampling_ratio x sampling_ratio grid points are used. If == 0, then "
+            "an adaptive number of grid points are used (computed as "
+            "ceil(roi_width / output_width), and likewise for height). Default is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "mode",
+            "The pooling method. Two modes are supported: 'avg' and 'max'. "
+            "Default is 'avg'.",
+            AttributeProto::STRING,
+            std::string("avg"))
+        .Attr(
+            "coordinate_transformation_mode",
+            "Allowed values are 'half_pixel' and 'output_half_pixel'. "
+            "Use the value 'half_pixel' to pixel shift the input coordinates by -0.5 (the recommended behavior). "
+            "Use the value 'output_half_pixel' to omit the pixel shift for the input (use this for a "
+            "backward-compatible behavior).",
+            AttributeProto::STRING,
+            std::string("half_pixel"))
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "4-D feature map of shape (N, C, H, W), "
+            "where N is the batch size, C is the number of channels, "
+            "and H and W are the height and the width of the data.",
+            "T1")
+        .Input(
+            1,
+            "rois",
+            "RoIs (Regions of Interest) to pool over; rois is "
+            "2-D input of shape (num_rois, 4) given as "
+            "[[x1, y1, x2, y2], ...]. "
+            "The RoIs' coordinates are in the coordinate system of the input image. "
+            "Each coordinate set has a 1:1 correspondence with the 'batch_indices' input.",
+            "T1")
+        .Input(
+            2,
+            "batch_indices",
+            "1-D tensor of shape (num_rois,) with each element denoting "
+            "the index of the corresponding image in the batch.",
+            "T2")
+        .Output(
+            0,
+            "Y",
+            "RoI pooled output, 4-D tensor of shape "
+            "(num_rois, C, output_height, output_width). The r-th batch element Y[r-1] "
+            "is a pooled feature map corresponding to the r-th RoI X[r-1].",
+            "T1")
+        .TypeConstraint("T1", OpSchema::all_float_types_ir4(), "Constrain types to float tensors.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain types to int tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          size_t input_param = 0, rois_param = 1, batch_index_param = 2;
+
+          // X: [N, C, H, W], rois: [num_rois, 4], batch_indices: [num_rois]
+          Dim N, C, H, W, num_rois, four;
+          four.set_dim_value(4);
+
+          ctx.unifyInputShape(input_param, {N, C, H, W});
+          ctx.unifyInputShape(rois_param, {num_rois, four});
+          ctx.unifyInputShape(batch_index_param, {num_rois});
+
+          Dim ht, width;
+          unifyDim(ht, getAttribute(ctx, "output_height", 1));
+          unifyDim(width, getAttribute(ctx, "output_width", 1));
+
+          // output: [num_rois, C, output_height, output_width]
+          updateOutputShape(ctx, 0, {num_rois, C, ht, width});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    NonMaxSuppression,
+    11,
+    OpSchema()
+        .Input(
+            0,
+            "boxes",
+            "An input tensor with shape [num_batches, spatial_dimension, 4]. The single box data format is indicated by center_point_box.",
+            "tensor(float)")
+        .Input(1, "scores", "An input tensor with shape [num_batches, num_classes, spatial_dimension]", "tensor(float)")
+        .Input(
+            2,
+            "max_output_boxes_per_class",
+            "Integer representing the maximum number of boxes to be selected per batch per class. It is a scalar. Default to 0, which means no output.",
+            "tensor(int64)",
+            OpSchema::Optional)
+        .Input(
+            3,
+            "iou_threshold",
+            "Float representing the threshold for deciding whether boxes overlap too much with respect to IOU. Boxes with IoU strictly greater than this threshold are suppressed. It is scalar. Value range [0, 1]. Default to 0.",
+            "tensor(float)",
+            OpSchema::Optional)
+        .Input(
+            4,
+            "score_threshold",
+            "Float representing the threshold for deciding when to remove boxes based on score. It is a scalar.",
+            "tensor(float)",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "selected_indices",
+            "selected indices from the boxes tensor. [num_selected_indices, 3], the selected index format is [batch_index, class_index, box_index].",
+            "tensor(int64)")
+        .Attr(
+            "center_point_box",
+            "Integer indicate the format of the box data. The default is 0. "
+            "0 - the box data is supplied as [y1, x1, y2, x2] where (y1, x1) and (y2, x2) are the coordinates of any diagonal pair of box corners "
+            "and the coordinates can be provided as normalized (i.e., lying in the interval [0, 1]) or absolute. Mostly used for TF models. "
+            "1 - the box data is supplied as [x_center, y_center, width, height]. Mostly used for Pytorch models.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .SetDoc(kDoc_NonMaxSuppression_ver10)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference - Output is always of type INT64
+          auto selected_indices_type = ctx.getOutputType(0)->mutable_tensor_type();
+          selected_indices_type->set_elem_type(TensorProto_DataType::TensorProto_DataType_INT64);
+
+          // Shape inference
+          // The exact shape cannot be determined as it depends on the input and
+          // other input configurations for the op But part of the shape can be
+          // established
+
+          auto selected_indices_shape = getOutputShape(ctx, 0);
+          selected_indices_shape->clear_dim();
+
+          // Output is 2D always
+
+          // The value of the first dim is determined by input data
+          // hence its value cannot be determined statically
+          selected_indices_shape->add_dim();
+
+          // The value of the second dim is 3
+          selected_indices_shape->add_dim()->set_dim_value(3);
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/object_detection/old.cc b/onnx/defs/object_detection/old.cc
new file mode 100644
index 0000000..73ebbe7
--- /dev/null
+++ b/onnx/defs/object_detection/old.cc
@@ -0,0 +1,252 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RoiAlign,
+    16,
+    OpSchema()
+        .SetDoc(kDoc_RoiAlign_ver16)
+        .Attr(
+            "spatial_scale",
+            "Multiplicative spatial scale factor to translate ROI coordinates "
+            "from their input spatial scale to the scale used when pooling, "
+            "i.e., spatial scale of the input feature map X relative to the "
+            "input image. E.g.; default is 1.0f. ",
+            AttributeProto::FLOAT,
+            1.f)
+        .Attr("output_height", "default 1; Pooled output Y's height.", AttributeProto::INT, static_cast<int64_t>(1))
+        .Attr("output_width", "default 1; Pooled output Y's width.", AttributeProto::INT, static_cast<int64_t>(1))
+        .Attr(
+            "sampling_ratio",
+            "Number of sampling points in the interpolation grid used to compute "
+            "the output value of each pooled output bin. If > 0, then exactly "
+            "sampling_ratio x sampling_ratio grid points are used. If == 0, then "
+            "an adaptive number of grid points are used (computed as "
+            "ceil(roi_width / output_width), and likewise for height). Default is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "mode",
+            "The pooling method. Two modes are supported: 'avg' and 'max'. "
+            "Default is 'avg'.",
+            AttributeProto::STRING,
+            std::string("avg"))
+        .Attr(
+            "coordinate_transformation_mode",
+            "Allowed values are 'half_pixel' and 'output_half_pixel'. "
+            "Use the value 'half_pixel' to pixel shift the input coordinates by -0.5 (the recommended behavior). "
+            "Use the value 'output_half_pixel' to omit the pixel shift for the input (use this for a "
+            "backward-compatible behavior).",
+            AttributeProto::STRING,
+            std::string("half_pixel"))
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "4-D feature map of shape (N, C, H, W), "
+            "where N is the batch size, C is the number of channels, "
+            "and H and W are the height and the width of the data.",
+            "T1")
+        .Input(
+            1,
+            "rois",
+            "RoIs (Regions of Interest) to pool over; rois is "
+            "2-D input of shape (num_rois, 4) given as "
+            "[[x1, y1, x2, y2], ...]. "
+            "The RoIs' coordinates are in the coordinate system of the input image. "
+            "Each coordinate set has a 1:1 correspondence with the 'batch_indices' input.",
+            "T1")
+        .Input(
+            2,
+            "batch_indices",
+            "1-D tensor of shape (num_rois,) with each element denoting "
+            "the index of the corresponding image in the batch.",
+            "T2")
+        .Output(
+            0,
+            "Y",
+            "RoI pooled output, 4-D tensor of shape "
+            "(num_rois, C, output_height, output_width). The r-th batch element Y[r-1] "
+            "is a pooled feature map corresponding to the r-th RoI X[r-1].",
+            "T1")
+        .TypeConstraint("T1", {types::Float16, types::Float, types::Double}, "Constrain types to float tensors.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain types to int tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          size_t input_param = 0, rois_param = 1, batch_index_param = 2;
+
+          checkInputRank(ctx, input_param, 4);
+          checkInputRank(ctx, rois_param, 2);
+          checkInputRank(ctx, batch_index_param, 1);
+
+          // Output dimensions, initialized to an unknown-dimension-value
+          Dim num_rois, C, ht, width;
+
+          // Get value of C from dim 1 of input_param, if available
+          unifyInputDim(ctx, input_param, 1, C);
+
+          // Get value of num_rois from dim 0 of rois_param, if available
+          unifyInputDim(ctx, rois_param, 0, num_rois);
+          // ... or from dim 0 of batch_index_param, if available
+          unifyInputDim(ctx, batch_index_param, 0, num_rois);
+
+          // Get height from attribute, using default-value of 1
+          unifyDim(ht, getAttribute(ctx, "output_height", 1));
+
+          // Get width from attribute, using default-value of 1
+          unifyDim(width, getAttribute(ctx, "output_width", 1));
+
+          // set output shape:
+          updateOutputShape(ctx, 0, {num_rois, C, ht, width});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RoiAlign,
+    10,
+    OpSchema()
+        .SetDoc(kDoc_RoiAlign_ver16)
+        .Attr(
+            "spatial_scale",
+            "Multiplicative spatial scale factor to translate ROI coordinates "
+            "from their input spatial scale to the scale used when pooling, "
+            "i.e., spatial scale of the input feature map X relative to the "
+            "input image. E.g.; default is 1.0f. ",
+            AttributeProto::FLOAT,
+            1.f)
+        .Attr("output_height", "default 1; Pooled output Y's height.", AttributeProto::INT, static_cast<int64_t>(1))
+        .Attr("output_width", "default 1; Pooled output Y's width.", AttributeProto::INT, static_cast<int64_t>(1))
+        .Attr(
+            "sampling_ratio",
+            "Number of sampling points in the interpolation grid used to compute "
+            "the output value of each pooled output bin. If > 0, then exactly "
+            "sampling_ratio x sampling_ratio grid points are used. If == 0, then "
+            "an adaptive number of grid points are used (computed as "
+            "ceil(roi_width / output_width), and likewise for height). Default is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "mode",
+            "The pooling method. Two modes are supported: 'avg' and 'max'. "
+            "Default is 'avg'.",
+            AttributeProto::STRING,
+            std::string("avg"))
+        .Input(
+            0,
+            "X",
+            "Input data tensor from the previous operator; "
+            "4-D feature map of shape (N, C, H, W), "
+            "where N is the batch size, C is the number of channels, "
+            "and H and W are the height and the width of the data.",
+            "T1")
+        .Input(
+            1,
+            "rois",
+            "RoIs (Regions of Interest) to pool over; rois is "
+            "2-D input of shape (num_rois, 4) given as "
+            "[[x1, y1, x2, y2], ...]. "
+            "The RoIs' coordinates are in the coordinate system of the input image. "
+            "Each coordinate set has a 1:1 correspondence with the 'batch_indices' input.",
+            "T1")
+        .Input(
+            2,
+            "batch_indices",
+            "1-D tensor of shape (num_rois,) with each element denoting "
+            "the index of the corresponding image in the batch.",
+            "T2")
+        .Output(
+            0,
+            "Y",
+            "RoI pooled output, 4-D tensor of shape "
+            "(num_rois, C, output_height, output_width). The r-th batch element Y[r-1] "
+            "is a pooled feature map corresponding to the r-th RoI X[r-1].",
+            "T1")
+        .TypeConstraint("T1", {types::Float16, types::Float, types::Double}, "Constrain types to float tensors.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain types to int tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          size_t input_param = 0, rois_param = 1, batch_index_param = 2;
+
+          checkInputRank(ctx, input_param, 4);
+          checkInputRank(ctx, rois_param, 2);
+          checkInputRank(ctx, batch_index_param, 1);
+
+          // Output dimensions, initialized to an unknown-dimension-value
+          Dim num_rois, C, ht, width;
+
+          // Get value of C from dim 1 of input_param, if available
+          unifyInputDim(ctx, input_param, 1, C);
+
+          // Get value of num_rois from dim 0 of rois_param, if available
+          unifyInputDim(ctx, rois_param, 0, num_rois);
+          // ... or from dim 0 of batch_index_param, if available
+          unifyInputDim(ctx, batch_index_param, 0, num_rois);
+
+          // Get height from attribute, using default-value of 1
+          unifyDim(ht, getAttribute(ctx, "output_height", 1));
+
+          // Get width from attribute, using default-value of 1
+          unifyDim(width, getAttribute(ctx, "output_width", 1));
+
+          // set output shape:
+          updateOutputShape(ctx, 0, {num_rois, C, ht, width});
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    NonMaxSuppression,
+    10,
+    OpSchema()
+        .Input(
+            0,
+            "boxes",
+            "An input tensor with shape [num_batches, spatial_dimension, 4]. The single box data format is indicated by center_point_box.",
+            "tensor(float)")
+        .Input(1, "scores", "An input tensor with shape [num_batches, num_classes, spatial_dimension]", "tensor(float)")
+        .Input(
+            2,
+            "max_output_boxes_per_class",
+            "Integer representing the maximum number of boxes to be selected per batch per class. It is a scalar. Default to 0, which means no output.",
+            "tensor(int64)",
+            OpSchema::Optional)
+        .Input(
+            3,
+            "iou_threshold",
+            "Float representing the threshold for deciding whether boxes overlap too much with respect to IOU. It is scalar. Value range [0, 1]. Default to 0.",
+            "tensor(float)",
+            OpSchema::Optional)
+        .Input(
+            4,
+            "score_threshold",
+            "Float representing the threshold for deciding when to remove boxes based on score. It is a scalar.",
+            "tensor(float)",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "selected_indices",
+            "selected indices from the boxes tensor. [num_selected_indices, 3], the selected index format is [batch_index, class_index, box_index].",
+            "tensor(int64)")
+        .Attr(
+            "center_point_box",
+            "Integer indicate the format of the box data. The default is 0. "
+            "0 - the box data is supplied as [y1, x1, y2, x2] where (y1, x1) and (y2, x2) are the coordinates of any diagonal pair of box corners "
+            "and the coordinates can be provided as normalized (i.e., lying in the interval [0, 1]) or absolute. Mostly used for TF models. "
+            "1 - the box data is supplied as [x_center, y_center, width, height]. Mostly used for Pytorch models.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .SetDoc(kDoc_NonMaxSuppression_ver10)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto selected_indices_type = ctx.getOutputType(0)->mutable_tensor_type();
+          selected_indices_type->set_elem_type(::ONNX_NAMESPACE::TensorProto_DataType::TensorProto_DataType_INT64);
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/operator_sets.h b/onnx/defs/operator_sets.h
new file mode 100644
index 0000000..de67758
--- /dev/null
+++ b/onnx/defs/operator_sets.h
@@ -0,0 +1,1575 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+
+// Forward declarations for ai.onnx version 1
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Abs);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Add);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, And);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ArgMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ArgMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, AveragePool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, BatchNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Ceil);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Clip);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Concat);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Conv);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ConvTranspose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, DepthToSpace);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Div);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Dropout);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Elu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Equal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Exp);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Flatten);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Floor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, GRU);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Gather);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Gemm);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, GlobalAveragePool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, GlobalLpPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, GlobalMaxPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Greater);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, HardSigmoid);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Hardmax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Identity);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, If);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, InstanceNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LRN);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LSTM);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LeakyRelu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Less);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Log);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LogSoftmax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LpNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LpPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, MatMul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Max);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, MaxPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, MaxRoiPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Mean);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Min);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Mul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Neg);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Not);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Or);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, PRelu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Pow);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RNN);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RandomNormal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RandomNormalLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RandomUniform);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RandomUniformLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Reciprocal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceL1);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceL2);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceLogSum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceLogSumExp);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceMean);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceProd);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceSum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceSumSquare);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Relu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Reshape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Selu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Shape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Sigmoid);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Size);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Slice);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Softmax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Softplus);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Softsign);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, SpaceToDepth);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Split);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Sqrt);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Squeeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Sub);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Sum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Tanh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Tile);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, TopK);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Transpose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Unsqueeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Upsample);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Xor);
+
+// Iterate over schema from ai.onnx version 1
+class OpSet_Onnx_ver1 {
+ public:
+  ONNX_API static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Abs)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Add)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, And)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ArgMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ArgMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, AveragePool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, BatchNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Ceil)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Clip)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Concat)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Conv)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ConvTranspose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, DepthToSpace)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Div)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Dropout)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Elu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Equal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Exp)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Flatten)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Floor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, GRU)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Gather)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Gemm)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, GlobalAveragePool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, GlobalLpPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, GlobalMaxPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Greater)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, HardSigmoid)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Hardmax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Identity)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, If)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, InstanceNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LRN)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LSTM)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LeakyRelu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Less)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Log)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LogSoftmax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LpNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, LpPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, MatMul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Max)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, MaxPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, MaxRoiPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Mean)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Min)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Mul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Neg)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Not)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Or)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, PRelu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Pow)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RNN)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RandomNormal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RandomNormalLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RandomUniform)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, RandomUniformLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Reciprocal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceL1)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceL2)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceLogSum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceLogSumExp)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceMean)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceProd)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceSum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, ReduceSumSquare)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Relu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Reshape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Selu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Shape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Sigmoid)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Size)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Slice)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Softmax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Softplus)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Softsign)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, SpaceToDepth)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Split)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Sqrt)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Squeeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Sub)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Sum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Tanh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Tile)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, TopK)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Transpose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Unsqueeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Upsample)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 1, Xor)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 2
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 2, GlobalLpPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 2, LpPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 2, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 2, Split);
+
+// Iterate over schema from ai.onnx version 2
+class OpSet_Onnx_ver2 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 2, GlobalLpPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 2, LpPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 2, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 2, Split)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 3
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 3, GRU);
+
+// Iterate over schema from ai.onnx version 3
+class OpSet_Onnx_ver3 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 3, GRU)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 4
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 4, Concat);
+
+// Iterate over schema from ai.onnx version 4
+class OpSet_Onnx_ver4 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 4, Concat)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 5
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 5, Reshape);
+
+// Iterate over schema from ai.onnx version 5
+class OpSet_Onnx_ver5 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 5, Reshape)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 6
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Abs);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Add);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, BatchNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Ceil);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Clip);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Div);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Dropout);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Elu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Exp);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Floor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Gemm);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, HardSigmoid);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, InstanceNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, LeakyRelu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Log);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Max);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Mean);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Min);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Mul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Neg);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, PRelu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Reciprocal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Relu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Selu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Sigmoid);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Sqrt);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Sub);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Sum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Tanh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Tile);
+
+// Iterate over schema from ai.onnx version 6
+class OpSet_Onnx_ver6 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Abs)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Add)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, BatchNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Ceil)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Clip)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Div)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Dropout)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Elu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Exp)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Floor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Gemm)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, HardSigmoid)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, InstanceNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, LeakyRelu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Log)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Max)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Mean)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Min)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Mul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Neg)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, PRelu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Reciprocal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Relu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Selu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Sigmoid)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Sqrt)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Sub)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Sum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Tanh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 6, Tile)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 7
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Acos);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Add);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, And);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Asin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Atan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, AveragePool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, BatchNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Cos);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Div);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Dropout);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Equal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Gemm);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Greater);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, GRU);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Less);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, LSTM);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Mul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Or);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Pow);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, RNN);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Sin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Sub);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Tan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Upsample);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Multinomial);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Xor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, PRelu);
+
+// Iterate over schema from ai.onnx version 7
+class OpSet_Onnx_ver7 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Acos)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Add)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, And)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Asin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Atan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, AveragePool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, BatchNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Cos)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Div)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Dropout)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Equal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Gemm)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Greater)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, GRU)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Less)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, LSTM)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Mul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Or)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Pow)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, RNN)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Sin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Sub)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Tan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Upsample)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Multinomial)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, Xor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 7, PRelu)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 8
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Expand);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Max);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Min);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Sum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Mean);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, MaxPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Scan);
+
+// Iterate over schema from ai.onnx version 8
+class OpSet_Onnx_ver8 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Expand)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Min)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Max)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Sum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Mean)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, MaxPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 8, Scan)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 9
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, BatchNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Compress);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, ConstantOfShape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, EyeLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Greater);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Less);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Upsample);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, MaxUnpool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, MatMul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, OneHot);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, PRelu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Gemm);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Flatten);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Sinh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Cosh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Asinh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Acosh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Atanh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Shrink);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, IsNaN);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Sign);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Scan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Erf);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Scatter);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Where);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, NonZero);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, TfIdfVectorizer);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, MeanVarianceNormalization);
+
+// Iterate over schema from ai.onnx version 9
+class OpSet_Onnx_ver9 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, BatchNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Compress)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, ConstantOfShape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, EyeLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Greater)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Less)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Upsample)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, MaxUnpool)>());
+    // Add more types' support to Constant/MatMul/PRelu/Gemm/Flatten op.
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, MatMul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, OneHot)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, PRelu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Gemm)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Flatten)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Scatter)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Sinh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Cosh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Asinh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Acosh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Atanh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Shrink)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, IsNaN)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Sign)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Scan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Erf)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, Where)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, NonZero)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, TfIdfVectorizer)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 9, MeanVarianceNormalization)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 10
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, StringNormalizer);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Upsample);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Resize);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, TopK);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, MaxPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Mod);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, AveragePool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Slice);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, ThresholdedRelu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Dropout);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, MatMulInteger);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, QLinearMatMul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, ConvInteger);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, QLinearConv);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, QuantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, DequantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, IsInf);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, NonMaxSuppression);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, ReverseSequence);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, RoiAlign);
+
+// Iterate over schema from ai.onnx version 10
+class OpSet_Onnx_ver10 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Upsample)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Resize)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, StringNormalizer)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, TopK)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, MaxPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Mod)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, AveragePool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Slice)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, ThresholdedRelu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, Dropout)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, MatMulInteger)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, QLinearMatMul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, ConvInteger)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, QLinearConv)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, QuantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, DequantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, IsInf)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, NonMaxSuppression)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, ReverseSequence)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 10, RoiAlign)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 11
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, CumSum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Round);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, BitShift);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Unique);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, TopK);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, DepthToSpace);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Equal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, DynamicQuantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, GatherElements);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ScatterElements);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Scatter);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Clip);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Resize);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Range);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Det);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ScatterND);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, GatherND);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Gather);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, OneHot);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Slice);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Squeeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Unsqueeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Flatten);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ArgMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ArgMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceL1);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceL2);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceLogSum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceLogSumExp);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceMean);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceProd);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceSum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceSumSquare);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Compress);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Concat);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Hardmax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, LogSoftmax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Softmax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Scan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Split);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, AveragePool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, MaxPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, MaxUnpool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, LpPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Conv);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ConvTranspose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceEmpty);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceConstruct);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceInsert);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceAt);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceErase);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceLength);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SplitToSequence);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ConcatFromSequence);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Gemm);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, If);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, NonMaxSuppression);
+
+// Iterate over schema from ai.onnx version 11
+class OpSet_Onnx_ver11 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, BitShift)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Unique)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, CumSum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Round)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, TopK)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, DepthToSpace)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Equal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, DynamicQuantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, GatherElements)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ScatterElements)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Scatter)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Clip)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Resize)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Range)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Det)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ScatterND)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, GatherND)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Gather)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, OneHot)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Slice)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Squeeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Unsqueeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Flatten)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ArgMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ArgMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceL1)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceL2)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceLogSum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceLogSumExp)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceMean)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceProd)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceSum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ReduceSumSquare)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Compress)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Concat)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Hardmax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, LogSoftmax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Softmax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Scan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Split)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, AveragePool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, MaxPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, MaxUnpool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, LpPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Conv)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ConvTranspose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceEmpty)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceConstruct)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceInsert)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceAt)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceErase)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SequenceLength)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, SplitToSequence)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, ConcatFromSequence)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, Gemm)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, If)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 11, NonMaxSuppression)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 12
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, ArgMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, ArgMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Clip);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Einsum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, MaxPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, ReduceMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, ReduceMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, GatherND);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, NegativeLogLikelihoodLoss);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Dropout);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Celu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Max);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Min);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, LessOrEqual);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, GreaterOrEqual);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, SoftmaxCrossEntropyLoss);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Pow);
+
+// Iterate over schema from ai.onnx version 12
+class OpSet_Onnx_ver12 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, ArgMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, ArgMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Clip)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Einsum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, MaxPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, ReduceMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, ReduceMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, GatherND)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, NegativeLogLikelihoodLoss)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Dropout)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Celu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Max)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Min)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, LessOrEqual)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, GreaterOrEqual)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, SoftmaxCrossEntropyLoss)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 12, Pow)>());
+  }
+};
+// Forward declarations for ai.onnx version 13
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Greater);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Less);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Equal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Add);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sub);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Mul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Div);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Softmax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, LogSoftmax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Hardmax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Mod);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Neg);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Abs);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Reciprocal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Floor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Ceil);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sqrt);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Relu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Exp);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Log);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Tanh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Pow);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sigmoid);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Max);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Min);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Mean);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Clip);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Gemm);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, MatMul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Expand);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sign);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Erf);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, SoftmaxCrossEntropyLoss);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, NegativeLogLikelihoodLoss);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Dropout);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Flatten);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, LRN);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, MeanVarianceNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceSum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceSumSquare);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceMean);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceProd);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceLogSum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceLogSumExp);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceL1);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceL2);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ArgMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ArgMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Reshape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Shape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Size);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Concat);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Split);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Slice);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Transpose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ScatterND);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ScatterElements);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Gather);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, GatherElements);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Squeeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Unsqueeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, SpaceToDepth);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, DepthToSpace);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Tile);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Resize);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Identity);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, IsNaN);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, NonZero);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, GatherND);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, QuantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, DequantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, If);
+
+// Iterate over schema from ai.onnx version 13
+class OpSet_Onnx_ver13 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Greater)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Less)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Equal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Add)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sub)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Mul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Div)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Softmax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, LogSoftmax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Hardmax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Mod)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Neg)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Abs)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Reciprocal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Floor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Ceil)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sqrt)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Relu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Exp)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Log)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Tanh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Pow)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sigmoid)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Max)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Min)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Mean)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Clip)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Gemm)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, MatMul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Expand)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Sign)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Erf)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, SoftmaxCrossEntropyLoss)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, NegativeLogLikelihoodLoss)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Dropout)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Flatten)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, LRN)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, MeanVarianceNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceSum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceSumSquare)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceMean)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceProd)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceLogSum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceLogSumExp)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceL1)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ReduceL2)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ArgMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ArgMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Reshape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Shape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Size)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Concat)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Split)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Slice)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Transpose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ScatterND)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, ScatterElements)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Gather)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, GatherElements)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Squeeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Unsqueeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, SpaceToDepth)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, DepthToSpace)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Tile)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Resize)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Identity)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, IsNaN)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, NonZero)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, GatherND)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, QuantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, DequantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 13, If)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 14
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, CumSum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Relu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Reshape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, GRU);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, LSTM);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, RNN);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Trilu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, BatchNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, HardSwish);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Add);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Sub);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Mul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Div);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Identity);
+
+// Iterate over schema from ai.onnx version 14
+class OpSet_Onnx_ver14 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, CumSum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Relu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Reshape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, GRU)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, LSTM)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, RNN)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Trilu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, BatchNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, HardSwish)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Add)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Sub)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Mul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Div)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 14, Identity)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 15
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, BatchNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, Bernoulli);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, Pow);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, Optional);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, OptionalHasElement);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, OptionalGetElement);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, CastLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, Shape);
+
+// Iterate over schema from ai.onnx version 15
+class OpSet_Onnx_ver15 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, BatchNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, Bernoulli)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, Pow)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, Optional)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, OptionalHasElement)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, OptionalGetElement)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, CastLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 15, Shape)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 16
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, RoiAlign);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, ScatterND);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, ScatterElements);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, If);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, Identity);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, Where);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, GridSample);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, Scan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, LessOrEqual);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, GreaterOrEqual);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, LeakyRelu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, PRelu);
+
+// Iterate over schema from ai.onnx version 16
+class OpSet_Onnx_ver16 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, RoiAlign)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, ScatterND)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, ScatterElements)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, If)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, Identity)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, Where)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, GridSample)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, Scan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, LessOrEqual)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, GreaterOrEqual)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, LeakyRelu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 16, PRelu)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 17
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, LayerNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, SequenceMap);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, DFT);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, HannWindow);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, HammingWindow);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, BlackmanWindow);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, MelWeightMatrix);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, STFT);
+
+// Iterate over schema from ai.onnx version 17
+class OpSet_Onnx_ver17 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, LayerNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, SequenceMap)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, DFT)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, HannWindow)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, HammingWindow)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, BlackmanWindow)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, MelWeightMatrix)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 17, STFT)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 18
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, CenterCropPad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Resize);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Mish);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, OptionalGetElement);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, OptionalHasElement);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Split);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Col2Im);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ScatterND);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ScatterElements);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceSumSquare);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceLogSum);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceLogSumExp);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceL1);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceL2);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceMean);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceProd);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, BitwiseAnd);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, BitwiseOr);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, BitwiseXor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, BitwiseNot);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, GroupNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, LpPool);
+
+// Iterate over schema from ai.onnx version 18
+class OpSet_Onnx_ver18 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, CenterCropPad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Resize)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Mish)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, OptionalGetElement)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Split)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, OptionalHasElement)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, Col2Im)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ScatterND)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ScatterElements)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceSumSquare)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceLogSum)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceLogSumExp)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceL1)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceL2)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceMean)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, ReduceProd)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, BitwiseAnd)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, BitwiseOr)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, BitwiseXor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, BitwiseNot)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, GroupNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 18, LpPool)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 19
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Equal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, AveragePool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, CastLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, DeformConv);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, DequantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Identity);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, If);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, QuantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Resize);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Reshape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Scan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Shape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Size);
+
+// Iterate over schema from ai.onnx version 19
+class OpSet_Onnx_ver19 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Equal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, AveragePool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, CastLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, DeformConv)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, DequantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Identity)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, If)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, QuantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Reshape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Resize)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Scan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Shape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 19, Size)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 20
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, AffineGrid);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, ConstantOfShape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, DFT);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, Gelu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, GridSample);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, ImageDecoder);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, IsInf);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, IsNaN);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, ReduceMax);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, ReduceMin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, RegexFullMatch);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, StringConcat);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, StringSplit);
+
+// Iterate over schema from ai.onnx version 20
+class OpSet_Onnx_ver20 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, AffineGrid)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, ConstantOfShape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, DFT)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, Gelu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, GridSample)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, ImageDecoder)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, IsInf)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, IsNaN)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, ReduceMax)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, ReduceMin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, RegexFullMatch)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, StringConcat)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 20, StringSplit)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 21
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, CastLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, ConstantOfShape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, DequantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Flatten);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, GroupNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Identity);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, If);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, QLinearMatMul);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, QuantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Reshape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Scan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Shape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Size);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Squeeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Transpose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Unsqueeze);
+
+// Iterate over schema from ai.onnx version 21
+class OpSet_Onnx_ver21 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, CastLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, ConstantOfShape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, DequantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Flatten)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, GroupNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Identity)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, If)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, QLinearMatMul)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, QuantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Reshape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Scan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Shape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Size)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Squeeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Transpose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 21, Unsqueeze)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 22
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, EyeLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RandomUniform);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RandomNormal);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RandomUniformLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RandomNormalLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Multinomial);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Bernoulli);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, ThresholdedRelu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Selu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Elu);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Mish);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, HardSigmoid);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, HardSwish);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Softsign);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Softplus);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Sin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Cos);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Tan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Asin);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Acos);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Atan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Sinh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Cosh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Asinh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Acosh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Atanh);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Round);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Det);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, NegativeLogLikelihoodLoss);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, AveragePool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, MaxPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, MaxUnpool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, LpPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, MaxRoiPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Conv);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, ConvTranspose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, DeformConv);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GlobalAveragePool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GlobalMaxPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GlobalLpPool);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, InstanceNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, LpNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Dropout);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RoiAlign);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RNN);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GRU);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, LSTM);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GridSample);
+
+// Iterate over schema from ai.onnx version 22
+class OpSet_Onnx_ver22 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, EyeLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RandomUniform)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RandomNormal)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RandomUniformLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RandomNormalLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Multinomial)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Bernoulli)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, ThresholdedRelu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Selu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Elu)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Mish)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, HardSigmoid)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, HardSwish)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Softsign)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Softplus)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Sin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Cos)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Tan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Asin)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Acos)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Atan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Sinh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Cosh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Asinh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Acosh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Atanh)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Round)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Det)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, NegativeLogLikelihoodLoss)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, AveragePool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, MaxPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, MaxUnpool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, LpPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, MaxRoiPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Conv)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, ConvTranspose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, DeformConv)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GlobalAveragePool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GlobalMaxPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GlobalLpPool)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, InstanceNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, LpNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, Dropout)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RoiAlign)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, RNN)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GRU)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, LSTM)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 22, GridSample)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 23
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Attention);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, CastLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, ConstantOfShape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, DequantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Flatten);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Identity);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, If);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, QuantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Reshape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, RMSNormalization);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, RotaryEmbedding);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Scan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Shape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Size);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Squeeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Transpose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Unsqueeze);
+
+// Iterate over schema from ai.onnx version 23
+class OpSet_Onnx_ver23 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Attention)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, CastLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, ConstantOfShape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, DequantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Flatten)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Identity)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, If)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, QuantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Reshape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, RMSNormalization)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, RotaryEmbedding)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Scan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Shape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Size)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Squeeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Transpose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 23, Unsqueeze)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 24
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Attention);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, CastLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, ConstantOfShape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, DequantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Flatten);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Identity);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, If);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, QuantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Reshape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Scan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Shape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Size);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Swish);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, SplitToSequence);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Squeeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, TopK);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Transpose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Unsqueeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, TensorScatter);
+
+// Iterate over schema from ai.onnx version 24
+class OpSet_Onnx_ver24 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Attention)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, CastLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, ConstantOfShape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, DequantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Flatten)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Identity)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, If)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, QuantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Reshape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Scan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Shape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Size)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Swish)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, SplitToSequence)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Squeeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, TopK)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Transpose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, Unsqueeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 24, TensorScatter)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 25
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Cast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, CastLike);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Constant);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, ConstantOfShape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, DequantizeLinear);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Flatten);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Identity);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Reshape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Shape);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Size);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, If);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Loop);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Scan);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Pad);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Squeeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Transpose);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Unsqueeze);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, QuantizeLinear);
+
+// Iterate over schema from ai.onnx version 25
+class OpSet_Onnx_ver25 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Cast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, CastLike)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Constant)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, ConstantOfShape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, DequantizeLinear)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Flatten)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Identity)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Reshape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Shape)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Size)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, If)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Loop)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Scan)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Pad)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Squeeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Transpose)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, Unsqueeze)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 25, QuantizeLinear)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 26
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 26, BitCast);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 26, CumProd);
+
+// Iterate over schema from ai.onnx version 26
+class OpSet_Onnx_ver26 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 26, BitCast)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 26, CumProd)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 27
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 27, CausalConvWithState);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 27, LinearAttention);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 27, Range);
+
+// Iterate over schema from ai.onnx version 27
+class OpSet_Onnx_ver27 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 27, CausalConvWithState)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 27, LinearAttention)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 27, Range)>());
+  }
+};
+
+// Forward declarations for ai.onnx version 28
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 28, Celu);
+
+// Iterate over schema from ai.onnx version 28
+class OpSet_Onnx_ver28 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(Onnx, 28, Celu)>());
+  }
+};
+
+ONNX_API inline void RegisterOnnxOperatorSetSchema() {
+  RegisterOpSetSchema<OpSet_Onnx_ver1>();
+  RegisterOpSetSchema<OpSet_Onnx_ver2>();
+  RegisterOpSetSchema<OpSet_Onnx_ver3>();
+  RegisterOpSetSchema<OpSet_Onnx_ver4>();
+  RegisterOpSetSchema<OpSet_Onnx_ver5>();
+  RegisterOpSetSchema<OpSet_Onnx_ver6>();
+  RegisterOpSetSchema<OpSet_Onnx_ver7>();
+  RegisterOpSetSchema<OpSet_Onnx_ver8>();
+  RegisterOpSetSchema<OpSet_Onnx_ver9>();
+  RegisterOpSetSchema<OpSet_Onnx_ver10>();
+  RegisterOpSetSchema<OpSet_Onnx_ver11>();
+  RegisterOpSetSchema<OpSet_Onnx_ver12>();
+  RegisterOpSetSchema<OpSet_Onnx_ver13>();
+  RegisterOpSetSchema<OpSet_Onnx_ver14>();
+  RegisterOpSetSchema<OpSet_Onnx_ver15>();
+  RegisterOpSetSchema<OpSet_Onnx_ver16>();
+  RegisterOpSetSchema<OpSet_Onnx_ver17>();
+  RegisterOpSetSchema<OpSet_Onnx_ver18>();
+  RegisterOpSetSchema<OpSet_Onnx_ver19>();
+  RegisterOpSetSchema<OpSet_Onnx_ver20>();
+  RegisterOpSetSchema<OpSet_Onnx_ver21>();
+  RegisterOpSetSchema<OpSet_Onnx_ver22>();
+  RegisterOpSetSchema<OpSet_Onnx_ver23>();
+  RegisterOpSetSchema<OpSet_Onnx_ver24>();
+  RegisterOpSetSchema<OpSet_Onnx_ver25>();
+  RegisterOpSetSchema<OpSet_Onnx_ver26>();
+  RegisterOpSetSchema<OpSet_Onnx_ver27>();
+  RegisterOpSetSchema<OpSet_Onnx_ver28>();
+  // 0 means all versions of ONNX schema have been loaded
+  OpSchemaRegistry::SetLoadedSchemaVersion(0);
+}
+
+ONNX_API inline void RegisterOnnxOperatorSetSchema(int target_version, bool fail_duplicate_schema = true) {
+  // Update here if opset_version bumps
+  // These calls for schema registration here are required to be in descending order for this to work correctly
+  //
+  // Version-specific registration sees duplicate schema version request as error if fail_duplicate_schema
+  RegisterOpSetSchema<OpSet_Onnx_ver28>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver27>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver26>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver25>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver24>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver23>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver22>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver21>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver20>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver19>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver18>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver17>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver16>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver15>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver14>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver13>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver12>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver11>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver10>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver9>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver8>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver7>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver6>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver5>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver4>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver3>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver2>(target_version, fail_duplicate_schema);
+  RegisterOpSetSchema<OpSet_Onnx_ver1>(target_version, fail_duplicate_schema);
+  // Sets to record the loaded version and prevent the full operator check in Debug mode
+  OpSchemaRegistry::SetLoadedSchemaVersion(target_version);
+}
+
+ONNX_API inline void DeregisterOnnxOperatorSetSchema() {
+  OpSchemaRegistry::OpSchemaDeregisterAll(ONNX_DOMAIN);
+  // -1 means no ONNX schema is loaded
+  OpSchemaRegistry::SetLoadedSchemaVersion(-1);
+}
+
+// Returns true if ONNX was built with static schema registration disabled
+// (i.e., with __ONNX_DISABLE_STATIC_REGISTRATION defined).
+//
+// When static registration is disabled, the linking module is responsible for
+// calling the desired registration methods to register the required opsets:
+//   - RegisterOnnxOperatorSetSchema() for ai.onnx domain operators
+//   - RegisterOnnxMLOperatorSetSchema() for ai.onnx.ml domain operators (if ONNX_ML is enabled)
+//   - RegisterOnnxTrainingOperatorSetSchema() for ai.onnx.training domain operators
+//   - RegisterOnnxPreviewOperatorSetSchema() for ai.onnx.preview domain operators
+//
+// When static registration is enabled (this function returns false), the above
+// opsets are automatically registered during ONNX library initialization, and
+// the linking module should not call the registration methods again to avoid
+// duplicate schema registration errors.
+ONNX_API bool IsOnnxStaticRegistrationDisabled();
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/operator_sets_ml.h b/onnx/defs/operator_sets_ml.h
new file mode 100644
index 0000000..3006ab1
--- /dev/null
+++ b/onnx/defs/operator_sets_ml.h
@@ -0,0 +1,109 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#ifdef ONNX_ML
+
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+
+// Forward declarations for ai.onnx.ml version 1
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, ArrayFeatureExtractor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, Binarizer);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, CastMap);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, CategoryMapper);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, DictVectorizer);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, FeatureVectorizer);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, Imputer);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, LabelEncoder);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, LinearClassifier);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, LinearRegressor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, Normalizer);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, OneHotEncoder);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, SVMClassifier);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, SVMRegressor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, Scaler);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, TreeEnsembleClassifier);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, TreeEnsembleRegressor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, ZipMap);
+
+// Iterate over schema from ai.onnx.ml version 1
+class OpSet_OnnxML_ver1 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, ArrayFeatureExtractor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, Binarizer)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, CastMap)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, CategoryMapper)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, DictVectorizer)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, FeatureVectorizer)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, Imputer)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, LabelEncoder)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, LinearClassifier)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, LinearRegressor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, Normalizer)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, OneHotEncoder)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, SVMClassifier)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, SVMRegressor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, Scaler)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, TreeEnsembleClassifier)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, TreeEnsembleRegressor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 1, ZipMap)>());
+  }
+};
+
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 2, LabelEncoder);
+
+class OpSet_OnnxML_ver2 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 2, LabelEncoder)>());
+  }
+};
+
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 3, TreeEnsembleClassifier);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 3, TreeEnsembleRegressor);
+
+class OpSet_OnnxML_ver3 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 3, TreeEnsembleClassifier)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 3, TreeEnsembleRegressor)>());
+  }
+};
+
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 4, LabelEncoder);
+
+class OpSet_OnnxML_ver4 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 4, LabelEncoder)>());
+  }
+};
+
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 5, TreeEnsemble);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 5, TreeEnsembleRegressor);
+class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 5, TreeEnsembleClassifier);
+
+class OpSet_OnnxML_ver5 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 5, TreeEnsemble)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 5, TreeEnsembleRegressor)>());
+    fn(GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxML, 5, TreeEnsembleClassifier)>());
+  }
+};
+
+ONNX_API inline void RegisterOnnxMLOperatorSetSchema() {
+  RegisterOpSetSchema<OpSet_OnnxML_ver1>();
+  RegisterOpSetSchema<OpSet_OnnxML_ver2>();
+  RegisterOpSetSchema<OpSet_OnnxML_ver3>();
+  RegisterOpSetSchema<OpSet_OnnxML_ver4>();
+  RegisterOpSetSchema<OpSet_OnnxML_ver5>();
+}
+} // namespace ONNX_NAMESPACE
+
+#endif
diff --git a/onnx/defs/operator_sets_preview.h b/onnx/defs/operator_sets_preview.h
new file mode 100644
index 0000000..3ddae9a
--- /dev/null
+++ b/onnx/defs/operator_sets_preview.h
@@ -0,0 +1,39 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+
+// Declare preview operators.
+
+class ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, Gradient);
+class ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, Momentum);
+class ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, Adagrad);
+class ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, Adam);
+class ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, FlexAttention);
+
+// Iterate over schema from ai.onnx.preview* version 1
+class OpSet_OnnxPreview_ver1 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& fn) {
+    fn(GetOpSchema<ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, Gradient)>());
+    fn(GetOpSchema<ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, Momentum)>());
+    fn(GetOpSchema<ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, Adagrad)>());
+    fn(GetOpSchema<ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, Adam)>());
+    fn(GetOpSchema<ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(1, FlexAttention)>());
+  }
+};
+
+// Register preview operators.
+ONNX_API inline void RegisterOnnxPreviewOperatorSetSchema() {
+  // Preview operators should have only one version.
+  // If changes are needed for a specific preview operator,
+  // its spec should be modified without increasing its version.
+  RegisterOpSetSchema<OpSet_OnnxPreview_ver1>();
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/operator_sets_training.h b/onnx/defs/operator_sets_training.h
new file mode 100644
index 0000000..c980b3d
--- /dev/null
+++ b/onnx/defs/operator_sets_training.h
@@ -0,0 +1,24 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+
+// Declare training operators.
+
+// Iterate over schema from ai.onnx.training version 1
+class OpSet_OnnxTraining_ver1 {
+ public:
+  static void ForEachSchema(const std::function<void(OpSchema&&)>& /* fn */) {}
+};
+
+// Register training operators.
+ONNX_API inline void RegisterOnnxTrainingOperatorSetSchema() {
+  RegisterOpSetSchema<OpSet_OnnxTraining_ver1>();
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/optional/CMakeLists.txt b/onnx/defs/optional/CMakeLists.txt
new file mode 100644
index 0000000..0804eec
--- /dev/null
+++ b/onnx/defs/optional/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+)
diff --git a/onnx/defs/optional/defs.cc b/onnx/defs/optional/defs.cc
new file mode 100644
index 0000000..808d603
--- /dev/null
+++ b/onnx/defs/optional/defs.cc
@@ -0,0 +1,154 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+#include <vector>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+static std::vector<std::string> optional_and_tensor_types() {
+  auto optional_types = OpSchema::all_optional_types();
+  auto tensor_types = OpSchema::all_tensor_types();
+  auto sequence_types = OpSchema::all_tensor_sequence_types();
+  optional_types.insert(optional_types.end(), tensor_types.begin(), tensor_types.end());
+  optional_types.insert(optional_types.end(), sequence_types.begin(), sequence_types.end());
+  return optional_types;
+}
+
+static constexpr const char* Optional_ver15_doc = R"DOC(
+Constructs an optional-type value containing either an empty optional of a certain type specified by the attribute,
+or a non-empty value containing the input element.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Optional,
+    15,
+    OpSchema()
+        .SetDoc(Optional_ver15_doc)
+        .Input(0, "input", "The input element.", "V", OpSchema::Optional)
+        .Attr("type", "Type of the element in the optional output", AttributeProto::TYPE_PROTO, OPTIONAL_VALUE)
+        .Output(0, "output", "The optional output enclosing the input element.", "O")
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types();
+              auto s = OpSchema::all_tensor_sequence_types();
+              t.insert(t.end(), s.begin(), s.end());
+              return t;
+            }(),
+            "Constrain input type to all tensor and sequence types.")
+        .TypeConstraint(
+            "O",
+            OpSchema::all_optional_types(),
+            "Constrain output type to all optional tensor or optional sequence types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const size_t numOutputs = ctx.getNumOutputs();
+          if (numOutputs != 1) {
+            fail_type_inference("Optional is expected to have an output.");
+          }
+
+          const size_t numInputs = ctx.getNumInputs();
+          const auto attr_proto = ctx.getAttribute("type");
+
+          if ((numInputs == 0) && (attr_proto != nullptr)) {
+            if (!attr_proto->has_tp())
+              fail_type_inference("Attribute 'type' should be a TypeProto and it should specify a type.");
+            auto attr_tp = attr_proto->tp();
+
+            ctx.getOutputType(0)->mutable_optional_type()->mutable_elem_type()->CopyFrom(attr_tp);
+          } else if (numInputs == 1) {
+            auto input_type = ctx.getInputType(0);
+            if (input_type == nullptr) {
+              fail_type_inference("Input type is null. Type information is expected for the input.");
+            }
+            ctx.getOutputType(0)->mutable_optional_type()->mutable_elem_type()->CopyFrom(*input_type);
+          } else {
+            fail_type_inference("Optional is expected to have either an input or the type attribute set.");
+          }
+        }));
+
+static constexpr const char* OptionalHasElement_ver18_doc = R"DOC(
+Returns true if (1) the input is an optional-type and contains an element,
+or, (2) the input is a tensor or sequence type.
+If the input is not provided or is an empty optional-type, this op returns false.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    OptionalHasElement,
+    18,
+    OpSchema()
+        .SetDoc(OptionalHasElement_ver18_doc)
+        .Input(0, "input", "The optional input.", "O", OpSchema::Optional)
+        .Output(
+            0,
+            "output",
+            "A scalar boolean tensor. If true, it indicates that optional-type input contains an element. Otherwise, it is empty.",
+            "B")
+        .TypeConstraint(
+            "O",
+            optional_and_tensor_types(),
+            "Constrain input type to optional tensor and optional sequence types.")
+        .TypeConstraint("B", {types::Bool}, "Constrain output to a boolean tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const size_t numInputs = ctx.getNumInputs();
+          if (numInputs != 0 && numInputs != 1) {
+            fail_type_inference("OptionalHasElement is expected to have 0 or 1 input.");
+          }
+          const size_t numOutputs = ctx.getNumOutputs();
+          if (numOutputs != 1) {
+            fail_type_inference("OptionalHasElement is expected to have 1 output.");
+          }
+          auto output_tensor_type = ctx.getOutputType(0)->mutable_tensor_type();
+          output_tensor_type->set_elem_type(TensorProto::BOOL);
+          output_tensor_type->mutable_shape()->Clear();
+        }));
+
+static constexpr const char* OptionalGetElement_ver18_doc = R"DOC(
+If the input is a tensor or sequence type, it returns the input.
+If the input is an optional type, it outputs the element in the input.
+It is an error if the input is an empty optional-type (i.e. does not have an element) and the behavior is undefined in this case.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    OptionalGetElement,
+    18,
+    OpSchema()
+        .SetDoc(OptionalGetElement_ver18_doc)
+        .Input(0, "input", "The optional input.", "O")
+        .Output(0, "output", "Output element in the optional input.", "V")
+        .TypeConstraint(
+            "O",
+            optional_and_tensor_types(),
+            "Constrain input type to optional tensor and optional sequence types.")
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types();
+              auto s = OpSchema::all_tensor_sequence_types();
+              t.insert(t.end(), s.begin(), s.end());
+              return t;
+            }(),
+            "Constrain output type to all tensor or sequence types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const size_t numInputs = ctx.getNumInputs();
+          if (numInputs != 1) {
+            fail_type_inference("OptionalGetElement must have an input element.");
+          }
+          auto input_type = ctx.getInputType(0);
+          if (input_type == nullptr) {
+            fail_type_inference("Input type is null. Input must have Type information.");
+          }
+          if (input_type->has_optional_type()) {
+            if (!input_type->optional_type().has_elem_type()) {
+              fail_type_inference("Optional-type input must contain an element with type information.");
+            }
+            ctx.getOutputType(0)->CopyFrom(input_type->optional_type().elem_type());
+          } else {
+            propagateShapeAndTypeFromFirstInput(ctx);
+          }
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/optional/old.cc b/onnx/defs/optional/old.cc
new file mode 100644
index 0000000..4103c6f
--- /dev/null
+++ b/onnx/defs/optional/old.cc
@@ -0,0 +1,83 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+static constexpr const char* OptionalHasElement_ver1_doc = R"DOC(
+Returns true if the optional-type input contains an element. If it is an empty optional-type, this op returns false.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    OptionalHasElement,
+    15,
+    OpSchema()
+        .SetDoc(OptionalHasElement_ver1_doc)
+        .Input(0, "input", "The optional input.", "O")
+        .Output(
+            0,
+            "output",
+            "A scalar boolean tensor. If true, it indicates that optional-type input contains an element. Otherwise, it is empty.",
+            "B")
+        .TypeConstraint(
+            "O",
+            OpSchema::all_optional_types(),
+            "Constrain input type to optional tensor and optional sequence types.")
+        .TypeConstraint("B", {types::Bool}, "Constrain output to a boolean tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const size_t numInputs = ctx.getNumInputs();
+          if (numInputs != 1) {
+            fail_type_inference("OptionalHasElement is expected to have 1 input.");
+          }
+          const size_t numOutputs = ctx.getNumOutputs();
+          if (numOutputs != 1) {
+            fail_type_inference("OptionalHasElement is expected to have 1 output.");
+          }
+          auto output_tensor_type = ctx.getOutputType(0)->mutable_tensor_type();
+          output_tensor_type->set_elem_type(TensorProto::BOOL);
+          output_tensor_type->mutable_shape()->Clear();
+        }));
+
+static constexpr const char* OptionalGetElement_ver1_doc = R"DOC(
+Outputs the element in the optional-type input. It is an error if the input value does not have an element
+and the behavior is undefined in this case.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    OptionalGetElement,
+    15,
+    OpSchema()
+        .SetDoc(OptionalGetElement_ver1_doc)
+        .Input(0, "input", "The optional input.", "O")
+        .Output(0, "output", "Output element in the optional input.", "V")
+        .TypeConstraint(
+            "O",
+            OpSchema::all_optional_types(),
+            "Constrain input type to optional tensor and optional sequence types.")
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types();
+              auto s = OpSchema::all_tensor_sequence_types();
+              t.insert(t.end(), s.begin(), s.end());
+              return t;
+            }(),
+            "Constrain output type to all tensor or sequence types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const size_t numInputs = ctx.getNumInputs();
+          if (numInputs != 1) {
+            fail_type_inference("OptionalGetElement must have an input element.");
+          }
+          auto input_type = ctx.getInputType(0);
+          if (input_type == nullptr) {
+            fail_type_inference("Input type is null. Input must have Type information.");
+          }
+          if (!input_type->has_optional_type() || !input_type->optional_type().has_elem_type()) {
+            fail_type_inference("Input must be an optional-type value containing an element with type information.");
+          }
+          ctx.getOutputType(0)->CopyFrom(input_type->optional_type().elem_type());
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/parser.cc b/onnx/defs/parser.cc
new file mode 100644
index 0000000..7fb89d9
--- /dev/null
+++ b/onnx/defs/parser.cc
@@ -0,0 +1,1056 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Experimental language syntax and parser for ONNX. Please note that the syntax as formalized
+// by this parser is preliminary and may change.
+
+#include "onnx/defs/parser.h"
+
+// POSIX locale extensions (newlocale, freelocale, strtof_l, strtod_l) are needed
+// for the fallback path on platforms without floating-point std::from_chars.
+#if !defined(__cpp_lib_to_chars) || __cpp_lib_to_chars < 201611L
+#include <locale.h> // NOLINT(modernize-deprecated-headers)
+#endif
+
+#include <cctype>
+#include <cerrno>
+#include <charconv>
+#include <cstdlib>
+#include <limits>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <unordered_map>
+
+#include "onnx/common/common.h"
+
+// Locale-independent float/double parsing implementation.
+// Uses std::from_chars when the stdlib supports it (__cpp_lib_to_chars >= 201611L),
+// otherwise falls back to strtof_l/strtod_l with an explicit "C" locale.
+
+#if defined(__cpp_lib_to_chars) && __cpp_lib_to_chars >= 201611L
+
+namespace ONNX_NAMESPACE {
+
+float LocaleIndependentStof(const std::string& s) {
+  float val = 0.0f;
+  const char* const begin = s.data();
+  const char* const end = begin + s.size();
+  auto result = std::from_chars(begin, end, val);
+  if (result.ec != std::errc{} || result.ptr != end) {
+    ONNX_THROW("Failed to parse float from string: " + s);
+  }
+  return val;
+}
+
+double LocaleIndependentStod(const std::string& s) {
+  double val = 0.0;
+  const char* const begin = s.data();
+  const char* const end = begin + s.size();
+  auto result = std::from_chars(begin, end, val);
+  if (result.ec != std::errc{} || result.ptr != end) {
+    ONNX_THROW("Failed to parse double from string: " + s);
+  }
+  return val;
+}
+
+} // namespace ONNX_NAMESPACE
+
+#else // Fallback for platforms without floating-point from_chars (e.g. Apple Clang)
+
+namespace {
+
+#ifdef _WIN32
+struct CLocale {
+  _locale_t loc;
+  CLocale() : loc(_create_locale(LC_ALL, "C")) {}
+  ~CLocale() {
+    if (loc)
+      _free_locale(loc);
+  }
+  CLocale(const CLocale&) = delete;
+  CLocale& operator=(const CLocale&) = delete;
+};
+#else // POSIX (Linux, macOS)
+struct CLocale {
+  locale_t loc;
+  CLocale() : loc(newlocale(LC_ALL_MASK, "C", nullptr)) {}
+  ~CLocale() {
+    if (loc)
+      freelocale(loc);
+  }
+  CLocale(const CLocale&) = delete;
+  CLocale& operator=(const CLocale&) = delete;
+};
+#endif
+
+const CLocale& GetCLocale() {
+  static const CLocale instance;
+  return instance;
+}
+
+} // anonymous namespace
+
+namespace ONNX_NAMESPACE {
+
+float LocaleIndependentStof(const std::string& s) {
+  const auto& cloc = GetCLocale();
+  if (!cloc.loc) {
+    ONNX_THROW("Failed to create C locale for float parsing");
+  }
+  char* end = nullptr;
+  errno = 0;
+#ifdef _WIN32
+  float val = _strtof_l(s.c_str(), &end, cloc.loc);
+#else
+  float val = strtof_l(s.c_str(), &end, cloc.loc);
+#endif
+  if (end == s.c_str() || end != s.c_str() + s.size() || errno == ERANGE) {
+    ONNX_THROW("Failed to parse float from string: " + s);
+  }
+  return val;
+}
+
+double LocaleIndependentStod(const std::string& s) {
+  const auto& cloc = GetCLocale();
+  if (!cloc.loc) {
+    ONNX_THROW("Failed to create C locale for double parsing");
+  }
+  char* end = nullptr;
+  errno = 0;
+#ifdef _WIN32
+  double val = _strtod_l(s.c_str(), &end, cloc.loc);
+#else
+  double val = strtod_l(s.c_str(), &end, cloc.loc);
+#endif
+  if (end == s.c_str() || end != s.c_str() + s.size() || errno == ERANGE) {
+    ONNX_THROW("Failed to parse double from string: " + s);
+  }
+  return val;
+}
+
+} // namespace ONNX_NAMESPACE
+
+#endif // __cpp_lib_to_chars
+
+#define PARSE_TOKEN(x) CHECK_PARSER_STATUS(ParserBase::Parse(x))
+#define PARSE(...) CHECK_PARSER_STATUS(Parse(__VA_ARGS__))
+#define MATCH(...) CHECK_PARSER_STATUS(Match(__VA_ARGS__))
+
+namespace ONNX_NAMESPACE {
+
+Common::Status ParserBase::Parse(Literal& result) {
+  bool decimal_point = false;
+  auto nextch = NextChar();
+  size_t from = pos_;
+  if (nextch == '"') {
+    ++pos_;
+    bool has_escape = false;
+    while (!AtEnd() && (Cur() != '"')) {
+      if (Cur() == '\\') {
+        has_escape = true;
+        ++pos_;
+        if (AtEnd())
+          return ParseError("Incomplete string literal.");
+      }
+      ++pos_;
+    }
+    if (AtEnd())
+      return ParseError("Incomplete string literal.");
+    ++pos_;
+    result.type = LiteralType::STRING_LITERAL;
+    if (has_escape) {
+      std::string& target = result.value;
+      target.clear();
+      target.reserve(pos_ - from - 2); // upper bound
+      // input_[from] is the starting quote. input_[pos_-1] is the ending quote.
+      // Copy what is in-between, except for the escape character
+      while (++from < pos_ - 1) {
+        // Copy current char, if not escape, or next char otherwise.
+        target.push_back(input_[from] != '\\' ? input_[from] : input_[++from]);
+      }
+    } else {
+      result.value = std::string(input_.substr(from + 1, pos_ - from - 2)); // skip enclosing quotes
+    }
+    return Common::Status::OK();
+  }
+
+  // Simplify the next ifs by consuming a possible negative sign.
+  if (nextch == '-') {
+    ++pos_;
+    nextch = NextChar();
+  }
+
+  // Check for float literals that start with alphabet characters.
+  if (isalpha(nextch)) {
+    // Has to be a special float literal now: (-)*(nan|inf|infinity).
+    if (NextIsValidFloatString()) {
+      while (!AtEnd() && IsAlpha(Cur())) {
+        ++pos_;
+      }
+      ONNX_TRY {
+        static_cast<void>(LocaleIndependentStof(std::string(input_.substr(from, pos_ - from))));
+        result.type = LiteralType::FLOAT_LITERAL;
+        result.value = std::string(input_.substr(from, pos_ - from));
+      }
+      ONNX_CATCH(...) {
+        ONNX_HANDLE_EXCEPTION([&]() { return ParseError("Encountered invalid float literal!"); });
+      }
+    } else {
+      return ParseError("Encountered invalid float literal!");
+    }
+    return Common::Status::OK();
+  }
+
+  // Checking for numeric ints or float literal.
+  if (isdigit(nextch)) {
+    ++pos_;
+
+    while (!AtEnd() && (IsDigit(Cur()) || (Cur() == '.'))) {
+      if (Cur() == '.') {
+        if (decimal_point)
+          break; // Only one decimal point allowed in numeric literal
+        decimal_point = true;
+      }
+      ++pos_;
+    }
+
+    if (pos_ == from)
+      return ParseError("Value expected but not found.");
+
+    // Optional exponent syntax: (e|E)(+|-)?[0-9]+
+    if (!AtEnd() && ((Cur() == 'e') || (Cur() == 'E'))) {
+      decimal_point = true; // treat as float-literal
+      ++pos_;
+      if (!AtEnd() && ((Cur() == '+') || (Cur() == '-')))
+        ++pos_;
+      while (!AtEnd() && IsDigit(Cur()))
+        ++pos_;
+    }
+
+    result.value = std::string(input_.substr(from, pos_ - from));
+    result.type = decimal_point ? LiteralType::FLOAT_LITERAL : LiteralType::INT_LITERAL;
+  }
+  return Common::Status::OK();
+}
+
+bool ParserBase::NextIsValidFloatString() {
+  auto nextch = NextChar();
+  const size_t from = pos_;
+  constexpr int INFINITY_LENGTH = 8;
+
+  if (isalpha(nextch)) {
+    while (!AtEnd() && IsAlpha(Cur()) && (pos_ - from) <= INFINITY_LENGTH) {
+      ++pos_;
+    }
+
+    if (!AtEnd() && IsDigit(Cur())) { // No trailing digits
+      pos_ = from;
+      return false;
+    }
+
+    std::string candidate = std::string(input_.substr(from, pos_ - from));
+
+    // Reset parser location before continuing.
+    pos_ = from;
+
+    std::transform(
+        candidate.begin(), candidate.end(), candidate.begin(), [](unsigned char c) { return std::tolower(c); });
+    if (candidate == std::string_view("inf") || candidate == std::string_view("infinity") ||
+        candidate == std::string_view("nan")) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Parsing an IdList (list of identifiers separated by commas, where identifiers are allowed to be empty).
+// Used to represent the list of inputs or outputs of a node.
+// An empty identifier may be represented by an empty string "" or by nothing followed by a single comma.
+// "Op()" has no operands
+// "Op(,x)" has two operands, the first being empty.
+// 'Op("")' has one operand, which is an empty string.
+// 'Op(,)' has one operand, which is an empty string.
+// Thus, this will also allow a trailing comma after a non-empty identifier with no effect.
+// 'Op(x,)' has one operand, which is 'x'.
+//
+// This is mostly for some backward compatibility. "" is a simpler way to represent an
+// empty identifier that is less confusing and is recommended.
+
+Common::Status OnnxParser::Parse(IdList& idlist) {
+  idlist.Clear();
+  std::string id;
+  bool found = false;
+  CHECK_PARSER_STATUS(ParseOptionalQuotableIdentifier(id, found));
+  if (!found)
+    return Common::Status::OK();
+  *idlist.Add() = id;
+  while (Matches(',')) {
+    CHECK_PARSER_STATUS(ParseOptionalQuotableIdentifier(id, found));
+    if (!found)
+      break;
+    *idlist.Add() = id;
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(char open, IdList& idlist, char close) {
+  idlist.Clear();
+  if (Matches(open)) {
+    PARSE(idlist);
+    MATCH(close);
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(IdList& idlist, AttrList& attrlist) {
+  idlist.Clear();
+  attrlist.Clear();
+  do {
+    std::string id;
+    CHECK_PARSER_STATUS(ParseQuotableIdentifier(id));
+    auto next = NextChar();
+    if (next == ':' || next == '=')
+      Parse(*attrlist.Add(), id);
+    else
+      *idlist.Add() = id;
+  } while (Matches(','));
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(char open, IdList& idlist, AttrList& attrlist, char close) {
+  if (Matches(open)) {
+    PARSE(idlist, attrlist);
+    MATCH(close);
+  } else {
+    idlist.Clear();
+    attrlist.Clear();
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(TensorShapeProto& shape) {
+  shape.clear_dim();
+  do {
+    if (Matches('?')) {
+      shape.add_dim();
+    } else if (NextChar() == '"') {
+      // Check for a quoted string as symbolic dim ...
+      std::string id;
+      CHECK_PARSER_STATUS(ParserBase::Parse(id));
+      shape.add_dim()->set_dim_param(id);
+    } else {
+      // Check for a symbolic identifier ...
+      auto id = ParseOptionalIdentifier();
+      if (!id.empty()) {
+        shape.add_dim()->set_dim_param(id);
+      } else {
+        // ...or a integer value
+        int64_t dimval = 0;
+        PARSE_TOKEN(dimval);
+        shape.add_dim()->set_dim_value(dimval);
+      }
+    }
+  } while (Matches(','));
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(TypeProto& typeProto) {
+  std::string id;
+  CHECK_PARSER_STATUS(ParseIdentifier(id));
+  int dtype = PrimitiveTypeNameMap::Lookup(id);
+  if (dtype != 0) {
+    auto* tensortype = typeProto.mutable_tensor_type();
+    tensortype->set_elem_type(dtype);
+    tensortype->clear_shape();
+    // Grammar:
+    // float indicates scalar (rank 0)
+    // float [] indicates unknown rank tensor (not a zero rank tensor)
+    // float [one-or-more-dimensions] indicates tensor of known rank > 0.
+    if (Matches('[')) {
+      if (!Matches(']')) {
+        PARSE(*tensortype->mutable_shape());
+        MATCH(']');
+      }
+    } else {
+      // Create shape with zero dimensions for scalar
+      (void)(tensortype->mutable_shape());
+    }
+  } else {
+    switch (KeyWordMap::Lookup(id)) {
+      case KeyWordMap::KeyWord::SEQ_TYPE: {
+        // Grammar: seq ( type )
+        MATCH('(');
+        auto* seqtype = typeProto.mutable_sequence_type();
+        PARSE(*seqtype->mutable_elem_type());
+        MATCH(')');
+        break;
+      }
+      case KeyWordMap::KeyWord::MAP_TYPE: {
+        // Grammar: map ( prim-type , type )
+        MATCH('(');
+        auto* maptype = typeProto.mutable_map_type();
+        CHECK_PARSER_STATUS(ParseIdentifier(id));
+        dtype = PrimitiveTypeNameMap::Lookup(id);
+        if (dtype == 0) {
+          return ParseError("Expecting primitive type as map key type.");
+        }
+        maptype->set_key_type(dtype);
+        MATCH(',');
+        PARSE(*maptype->mutable_value_type());
+        MATCH(')');
+        break;
+      }
+      case KeyWordMap::KeyWord::OPTIONAL_TYPE: {
+        // Grammar: optional ( type )
+        MATCH('(');
+        auto* opttype = typeProto.mutable_optional_type();
+        PARSE(*opttype->mutable_elem_type());
+        MATCH(')');
+        break;
+      }
+      case KeyWordMap::KeyWord::SPARSE_TENSOR_TYPE: {
+        // Grammar: sparse_tensor ( tensor-type )
+        MATCH('(');
+        CHECK_PARSER_STATUS(ParseIdentifier(id));
+        dtype = PrimitiveTypeNameMap::Lookup(id);
+        if (dtype != 0) {
+          auto* sparsetype = typeProto.mutable_sparse_tensor_type();
+          sparsetype->set_elem_type(dtype);
+          sparsetype->clear_shape();
+          // Grammar:
+          // float indicates scalar (rank 0)
+          // float [] indicates unknown rank tensor (not a zero rank tensor)
+          // float [one-or-more-dimensions] indicates tensor of known rank > 0.
+          if (Matches('[')) {
+            if (!Matches(']')) {
+              PARSE(*sparsetype->mutable_shape());
+              MATCH(']');
+            }
+          } else {
+            // Create shape with zero dimensions for scalar
+            (void)(sparsetype->mutable_shape());
+          }
+        } else {
+          return ParseError("Unexpected type in sparse-tensor element type.");
+        }
+        MATCH(')');
+        break;
+      }
+      default:
+        return ParseError("Unexpected type.");
+    }
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(ValueInfoProto& valueinfo) {
+  if (NextIsType())
+    PARSE(*valueinfo.mutable_type());
+  std::string name;
+  CHECK_PARSER_STATUS(ParseQuotableIdentifier(name));
+  valueinfo.set_name(name);
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(char open, ValueInfoList& vilist, char close) {
+  MATCH(open);
+  if (!Matches(close)) {
+    do {
+      PARSE(*vilist.Add());
+    } while (Matches(','));
+    MATCH(close);
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::ParseGraphInputOutput(ValueInfoList& vilist) {
+  vilist.Clear();
+  PARSE('(', vilist, ')');
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::ParseFunctionInputOutput(IdList& idlist, ValueInfoList& vilist) {
+  // Do not clear vilist, as it accumulates values over inputs and outputs.
+  idlist.Clear();
+  MATCH('(');
+  if (!Matches(')')) {
+    do {
+      // Function inputs/outputs can be optionally typed.
+      // Syntax: Name | Type Name
+      // The name is added to idlist. If the optional type is present, an entry is
+      // added to vilist.
+
+      std::string* name = idlist.Add();
+      ValueInfoProto* vi = nullptr;
+
+      if (NextIsType()) {
+        vi = vilist.Add();
+        PARSE(*(vi->mutable_type()));
+      }
+      CHECK_PARSER_STATUS(ParseQuotableIdentifier(*name));
+      if (vi != nullptr)
+        vi->set_name(*name);
+    } while (Matches(','));
+    MATCH(')');
+  }
+  return Common::Status::OK();
+}
+
+// Each input element is a value-info with an optional initializer of the form "= initial-value".
+// The value-info is added to the "inputs", while the initializer is added to initializers.
+Common::Status OnnxParser::ParseInput(ValueInfoList& inputs, TensorList& initializers) {
+  inputs.Clear();
+  if (Matches('(')) {
+    if (!Matches(')')) {
+      do {
+        ValueInfoProto vi;
+        PARSE(vi);
+        *inputs.Add() = vi;
+        if (Matches('=')) {
+          // default value for input
+          TensorProto& tp = *initializers.Add();
+          tp.set_name(vi.name());
+          CHECK_PARSER_STATUS(Parse(tp, vi.type()));
+        }
+      } while (Matches(','));
+      MATCH(')');
+    }
+  }
+  return Common::Status::OK();
+}
+
+// This is handled slightly different from the inputs.
+// Each element is either a value-info or an initializer.
+// A value-info is added to the "value_infos", while an initializer is added to initializers.
+Common::Status OnnxParser::ParseValueInfo(ValueInfoList& value_infos, TensorList& initializers) {
+  value_infos.Clear();
+  if (Matches('<')) {
+    if (!Matches('>')) {
+      do {
+        ValueInfoProto vi;
+        PARSE(vi);
+        if (Matches('=')) {
+          // initializer
+          TensorProto& tp = *initializers.Add();
+          tp.set_name(vi.name());
+          CHECK_PARSER_STATUS(Parse(tp, vi.type()));
+        } else {
+          // valueinfo
+          *value_infos.Add() = vi;
+        }
+      } while (Matches(','));
+      MATCH('>');
+    }
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(StringStringList& stringStringList) {
+  std::string strval;
+  do {
+    auto* metadata = stringStringList.Add();
+    PARSE_TOKEN(strval);
+    metadata->set_key(strval);
+    MATCH(':');
+    PARSE_TOKEN(strval);
+    metadata->set_value(strval);
+  } while (Matches(','));
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(TensorProto& tensorProto) {
+  tensorProto = TensorProto();
+  // Parse the concrete tensor-type with numeric dimensions:
+  TypeProto typeProto;
+  PARSE(typeProto);
+  *tensorProto.mutable_name() = ParseOptionalIdentifier();
+  (void)Matches('='); // Optional, to unify handling of initializers as well as tensor-protos in other contexts
+  return Parse(tensorProto, typeProto);
+}
+
+// Parse TensorProto data given its type:
+Common::Status OnnxParser::Parse(TensorProto& tensorProto, const TypeProto& tensorTypeProto) {
+  if (!tensorTypeProto.has_tensor_type())
+    return ParseError("Error parsing TensorProto (expected a tensor type).");
+  auto elem_type = tensorTypeProto.tensor_type().elem_type();
+  tensorProto.set_data_type(elem_type);
+  if (!tensorTypeProto.tensor_type().has_shape())
+    return ParseError("Error parsing TensorProto (expected a tensor shape).");
+  for (const auto& dim : tensorTypeProto.tensor_type().shape().dim()) {
+    if (!dim.has_dim_value())
+      return ParseError("Error parsing TensorProto shape (expected numeric dimension).");
+    auto dimval = dim.dim_value();
+    tensorProto.add_dims(dimval);
+  }
+
+  // tensorProto.mutable_int64_data()->Reserve(n);
+  // Parse the actual values:
+
+  int64_t intval = 0;
+  uint64_t uintval = 0;
+  float floatval = 0.0;
+  double dblval = 0.0;
+  std::string strval;
+  if (Matches('{')) {
+    if (!Matches('}')) {
+      do {
+        switch (static_cast<TensorProto::DataType>(elem_type)) {
+          case TensorProto::DataType::TensorProto_DataType_INT2:
+          case TensorProto::DataType::TensorProto_DataType_INT4:
+          case TensorProto::DataType::TensorProto_DataType_INT8:
+          case TensorProto::DataType::TensorProto_DataType_INT16:
+          case TensorProto::DataType::TensorProto_DataType_INT32:
+          case TensorProto::DataType::TensorProto_DataType_UINT2:
+          case TensorProto::DataType::TensorProto_DataType_UINT4:
+          case TensorProto::DataType::TensorProto_DataType_UINT8:
+          case TensorProto::DataType::TensorProto_DataType_UINT16:
+          case TensorProto::DataType::TensorProto_DataType_FLOAT16:
+          case TensorProto::DataType::TensorProto_DataType_BFLOAT16:
+          case TensorProto::DataType::TensorProto_DataType_FLOAT8E4M3FN:
+          case TensorProto::DataType::TensorProto_DataType_FLOAT8E4M3FNUZ:
+          case TensorProto::DataType::TensorProto_DataType_FLOAT8E5M2:
+          case TensorProto::DataType::TensorProto_DataType_FLOAT8E5M2FNUZ:
+          case TensorProto::DataType::TensorProto_DataType_FLOAT8E8M0:
+          case TensorProto::DataType::TensorProto_DataType_BOOL:
+          case TensorProto::DataType::TensorProto_DataType_FLOAT4E2M1:
+            PARSE_TOKEN(intval);
+            if (intval > std::numeric_limits<int32_t>::max() || intval < std::numeric_limits<int32_t>::min()) {
+              return ParseError("Mismatch between data type and value: %d, %d", elem_type, intval);
+            }
+            // NOLINTNEXTLINE(bugprone-narrowing-conversions)
+            tensorProto.add_int32_data(intval);
+            break;
+          case TensorProto::DataType::TensorProto_DataType_INT64:
+            PARSE_TOKEN(intval);
+            tensorProto.add_int64_data(intval);
+            break;
+          case TensorProto::DataType::TensorProto_DataType_UINT32:
+          case TensorProto::DataType::TensorProto_DataType_UINT64:
+            PARSE_TOKEN(uintval);
+            tensorProto.add_uint64_data(uintval);
+            break;
+          case TensorProto::DataType::TensorProto_DataType_COMPLEX64:
+          case TensorProto::DataType::TensorProto_DataType_FLOAT:
+            PARSE_TOKEN(floatval);
+            tensorProto.add_float_data(floatval);
+            break;
+          case TensorProto::DataType::TensorProto_DataType_COMPLEX128:
+          case TensorProto::DataType::TensorProto_DataType_DOUBLE:
+            PARSE_TOKEN(dblval);
+            tensorProto.add_double_data(dblval);
+            break;
+          case TensorProto::DataType::TensorProto_DataType_STRING:
+            PARSE_TOKEN(strval);
+            tensorProto.add_string_data(strval);
+            break;
+          default:
+            return ParseError("Unhandled type: %d", elem_type);
+        }
+      } while (Matches(','));
+      MATCH('}');
+    }
+  } else if (Matches('[')) {
+    tensorProto.set_data_location(TensorProto::DataLocation::TensorProto_DataLocation_EXTERNAL);
+    auto& externalData = *tensorProto.mutable_external_data();
+    PARSE(externalData);
+    MATCH(']');
+  }
+  return Common::Status::OK();
+}
+
+bool OnnxParser::NextIsIdentifier() {
+  auto id = PeekIdentifier();
+  return !(id.empty());
+}
+
+bool OnnxParser::NextIsType() {
+  auto id = PeekIdentifier();
+  if (PrimitiveTypeNameMap::IsTypeName(id))
+    return true;
+  switch (KeyWordMap::Lookup(id)) {
+    case KeyWordMap::KeyWord::SEQ_TYPE:
+    case KeyWordMap::KeyWord::MAP_TYPE:
+    case KeyWordMap::KeyWord::OPTIONAL_TYPE:
+    case KeyWordMap::KeyWord::SPARSE_TENSOR_TYPE:
+      return true;
+    default:
+      return false;
+  }
+}
+
+Common::Status OnnxParser::ParseSingleAttributeValue(AttributeProto& attr, AttributeProto_AttributeType expected) {
+  // Parse a single-value
+  auto next = NextChar();
+  if (isalpha(next) || next == '_') {
+    if (NextIsType()) {
+      TypeProto typeProto;
+      CHECK_PARSER_STATUS(Parse(typeProto));
+      next = NextChar();
+      if ((next == '{') || (next == '=') || (NextIsIdentifier())) {
+        attr.set_type(AttributeProto_AttributeType_TENSOR);
+        auto& tensorProto = *attr.mutable_t();
+        CHECK_PARSER_STATUS(ParseOptionalQuotableIdentifier(*tensorProto.mutable_name()));
+        (void)Matches('='); // Optional, to unify handling of initializers
+        CHECK_PARSER_STATUS(Parse(tensorProto, typeProto));
+      } else {
+        attr.set_type(AttributeProto_AttributeType_TYPE_PROTO);
+        attr.mutable_tp()->CopyFrom(typeProto);
+      }
+    } else {
+      if (NextIsValidFloatString()) {
+        Literal literal;
+        PARSE_TOKEN(literal);
+        attr.set_type(AttributeProto_AttributeType_FLOAT);
+        attr.set_f(LocaleIndependentStof(literal.value));
+      } else {
+        attr.set_type(AttributeProto_AttributeType_GRAPH);
+        PARSE(*attr.mutable_g());
+      }
+    }
+  } else if (Matches('@')) {
+    std::string name;
+    CHECK_PARSER_STATUS(ParseQuotableIdentifier(name));
+    attr.set_ref_attr_name(name);
+  } else {
+    Literal literal;
+    PARSE_TOKEN(literal);
+    switch (literal.type) {
+      case LiteralType::UNDEFINED:
+        return ParseError("Internal error");
+      case LiteralType::INT_LITERAL:
+        attr.set_type(AttributeProto_AttributeType_INT);
+        attr.set_i(std::stoll(literal.value));
+        break;
+      case LiteralType::FLOAT_LITERAL:
+        attr.set_type(AttributeProto_AttributeType_FLOAT);
+        attr.set_f(LocaleIndependentStof(literal.value));
+        break;
+      case LiteralType::STRING_LITERAL:
+        attr.set_type(AttributeProto_AttributeType_STRING);
+        attr.set_s(literal.value);
+        break;
+    }
+  }
+  if ((expected != AttributeProto_AttributeType_UNDEFINED) && (expected != attr.type())) {
+    // Mismatch between type-annotation and attribute-value. We do an implicit cast
+    // only in the special case of FLOAT type and integral value like 2
+    if ((expected == AttributeProto_AttributeType_FLOAT) && (attr.type() == AttributeProto_AttributeType_INT)) {
+      attr.set_type(AttributeProto_AttributeType_FLOAT);
+      attr.set_f(static_cast<float>(attr.i()));
+      attr.clear_i();
+    } else {
+      return ParseError(
+          "Mismatch between expected type ",
+          AttributeProto_AttributeType_Name(expected),
+          " and specified value's type",
+          AttributeProto_AttributeType_Name(attr.type()));
+    }
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(AttributeProto& attr) {
+  attr.Clear();
+  std::string name;
+  CHECK_PARSER_STATUS(ParseIdentifier(name));
+  return Parse(attr, name);
+}
+
+static bool IsSingletonAttribute(AttributeProto_AttributeType type) {
+  switch (type) {
+    case AttributeProto_AttributeType_FLOAT:
+    case AttributeProto_AttributeType_INT:
+    case AttributeProto_AttributeType_STRING:
+    case AttributeProto_AttributeType_TENSOR:
+    case AttributeProto_AttributeType_GRAPH:
+    case AttributeProto_AttributeType_SPARSE_TENSOR:
+    case AttributeProto_AttributeType_TYPE_PROTO:
+      return true;
+    default:
+      return false;
+  }
+}
+
+static AttributeProto_AttributeType ToSingletonType(AttributeProto_AttributeType type) {
+  switch (type) {
+    case AttributeProto_AttributeType_FLOATS:
+      return AttributeProto_AttributeType_FLOAT;
+    case AttributeProto_AttributeType_INTS:
+      return AttributeProto_AttributeType_INT;
+    case AttributeProto_AttributeType_STRINGS:
+      return AttributeProto_AttributeType_STRING;
+    case AttributeProto_AttributeType_TENSORS:
+      return AttributeProto_AttributeType_TENSOR;
+    case AttributeProto_AttributeType_GRAPHS:
+      return AttributeProto_AttributeType_GRAPH;
+    case AttributeProto_AttributeType_SPARSE_TENSORS:
+      return AttributeProto_AttributeType_SPARSE_TENSOR;
+    case AttributeProto_AttributeType_TYPE_PROTOS:
+      return AttributeProto_AttributeType_TYPE_PROTO;
+    default:
+      return type;
+  }
+}
+
+Common::Status OnnxParser::Parse(AttributeProto& attr, std::string& name) {
+  attr.set_name(name);
+  if (Matches(':')) {
+    CHECK_PARSER_STATUS(ParseIdentifier(name));
+    int attrtype = AttributeTypeNameMap::Lookup(name);
+    if (attrtype != 0) {
+      attr.set_type(static_cast<AttributeProto_AttributeType>(attrtype));
+    } else {
+      return ParseError("Unexpected attribute type.");
+    }
+  }
+  MATCH('=');
+  if (NextChar() == '[') {
+    // Parse a list of values. For an empty list, the type MUST be specified
+    // using the type-annotation syntax of ": type".
+    MATCH('[');
+    if (NextChar() != ']') {
+      do {
+        AttributeProto nextval;
+        auto expected_type = ToSingletonType(attr.type());
+        CHECK_PARSER_STATUS(ParseSingleAttributeValue(nextval, expected_type));
+        switch (nextval.type()) {
+          case AttributeProto_AttributeType_INT:
+            attr.set_type(AttributeProto_AttributeType_INTS);
+            attr.add_ints(nextval.i());
+            break;
+          case AttributeProto_AttributeType_FLOAT:
+            attr.set_type(AttributeProto_AttributeType_FLOATS);
+            attr.add_floats(nextval.f());
+            break;
+          case AttributeProto_AttributeType_STRING:
+            attr.add_strings(nextval.s());
+            attr.set_type(AttributeProto_AttributeType_STRINGS);
+            break;
+          default:
+            break;
+        }
+      } while (Matches(','));
+    } else {
+      if (attr.type() == AttributeProto_AttributeType_UNDEFINED)
+        return ParseError("Empty list attribute value requires type annotation.");
+      if (IsSingletonAttribute(attr.type()))
+        return ParseError("Singleton attribute value cannot be specified as a list.");
+    }
+    MATCH(']');
+  } else {
+    CHECK_PARSER_STATUS(ParseSingleAttributeValue(attr, attr.type()));
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(AttrList& attrlist) {
+  attrlist.Clear();
+  if (Matches('<')) {
+    do {
+      PARSE(*attrlist.Add());
+    } while (Matches(','));
+    MATCH('>');
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(NodeProto& node) {
+  if (Matches('[')) {
+    CHECK_PARSER_STATUS(ParseOptionalQuotableIdentifier(*node.mutable_name()));
+    MATCH(']');
+  }
+  PARSE(*node.mutable_output());
+  MATCH('=');
+  std::string domain;
+  std::string id = ParseOptionalIdentifier();
+  while (Matches('.')) {
+    if (!domain.empty())
+      domain += ".";
+    domain += id;
+    CHECK_PARSER_STATUS(ParseIdentifier(id));
+  }
+  node.set_domain(domain);
+  node.set_op_type(id);
+
+  if (Matches(':')) {
+    std::string overload;
+    CHECK_PARSER_STATUS(ParseIdentifier(overload));
+    node.set_overload(overload);
+  }
+  PARSE(*node.mutable_attribute());
+  MATCH('(');
+  PARSE(*node.mutable_input());
+  MATCH(')');
+  if (node.attribute_size() == 0) {
+    // Permit attributes to be specified before or after parameters.
+    PARSE(*node.mutable_attribute());
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(NodeList& nodelist) {
+  nodelist.Clear();
+  MATCH('{');
+  while (!Matches('}')) {
+    PARSE(*nodelist.Add());
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(GraphProto& graph) {
+  std::string id;
+  CHECK_PARSER_STATUS(ParseQuotableIdentifier(id));
+  return Parse(id, graph);
+}
+
+Common::Status OnnxParser::Parse(std::string name, GraphProto& graph) {
+  graph.set_name(name);
+  graph.mutable_initializer()->Clear();
+  CHECK_PARSER_STATUS(ParseInput(*graph.mutable_input(), *graph.mutable_initializer()));
+  MATCH('=');
+  MATCH('>', false);
+  CHECK_PARSER_STATUS(ParseGraphInputOutput(*graph.mutable_output()));
+  CHECK_PARSER_STATUS(ParseValueInfo(*graph.mutable_value_info(), *graph.mutable_initializer()));
+  return Parse(*graph.mutable_node());
+}
+
+Common::Status OnnxParser::Parse(FunctionProto& fn) {
+  fn.Clear();
+  std::string strval;
+  if (Matches('<')) {
+    do {
+      KeyWordMap::KeyWord keyword = KeyWordMap::KeyWord::NONE;
+      PARSE_TOKEN(keyword);
+      MATCH(':');
+      switch (keyword) {
+        case KeyWordMap::KeyWord::OPSET_IMPORT:
+          PARSE(*fn.mutable_opset_import());
+          break;
+        case KeyWordMap::KeyWord::DOC_STRING:
+          PARSE_TOKEN(strval);
+          fn.set_doc_string(strval);
+          break;
+        case KeyWordMap::KeyWord::DOMAIN_KW:
+          PARSE_TOKEN(strval);
+          fn.set_domain(strval);
+          break;
+        case KeyWordMap::KeyWord::OVERLOAD_KW:
+          PARSE_TOKEN(strval);
+          fn.set_overload(strval);
+          break;
+        default:
+          return ParseError("Unhandled keyword.");
+      }
+    } while (Matches(','));
+    MATCH('>');
+  }
+  std::string id;
+  CHECK_PARSER_STATUS(ParseQuotableIdentifier(id));
+  fn.set_name(id);
+
+  PARSE('<', *fn.mutable_attribute(), *fn.mutable_attribute_proto(), '>');
+  fn.mutable_value_info()->Clear();
+  CHECK_PARSER_STATUS(ParseFunctionInputOutput(*fn.mutable_input(), *fn.mutable_value_info()));
+  MATCH('=');
+  MATCH('>', false);
+  CHECK_PARSER_STATUS(ParseFunctionInputOutput(*fn.mutable_output(), *fn.mutable_value_info()));
+  if (NextChar() == '<') {
+    PARSE('<', *fn.mutable_value_info(), '>');
+  }
+  return Parse(*fn.mutable_node());
+}
+
+Common::Status OnnxParser::Parse(OpsetIdList& opsets) {
+  std::string strval;
+  int64_t intval = 0;
+  MATCH('[');
+  if (!Matches(']')) {
+    do {
+      auto* import = opsets.Add();
+      PARSE_TOKEN(strval);
+      import->set_domain(strval);
+      MATCH(':');
+      PARSE_TOKEN(intval);
+      import->set_version(intval);
+    } while (Matches(','));
+    MATCH(']');
+  }
+  return Common::Status::OK();
+}
+
+Common::Status OnnxParser::Parse(ModelProto& model) {
+  model.Clear();
+  std::string strval;
+  int64_t intval = 0;
+  if (Matches('<')) {
+    do {
+      KeyWordMap::KeyWord keyword = KeyWordMap::KeyWord::NONE;
+      PARSE_TOKEN(keyword);
+      MATCH(':');
+      switch (keyword) {
+        case KeyWordMap::KeyWord::IR_VERSION:
+          PARSE_TOKEN(intval);
+          model.set_ir_version(intval);
+          break;
+        case KeyWordMap::KeyWord::OPSET_IMPORT:
+          PARSE(*model.mutable_opset_import());
+          break;
+        case KeyWordMap::KeyWord::PRODUCER_NAME:
+          PARSE_TOKEN(strval);
+          model.set_producer_name(strval);
+          break;
+        case KeyWordMap::KeyWord::PRODUCER_VERSION:
+          PARSE_TOKEN(strval);
+          model.set_producer_version(strval);
+          break;
+        case KeyWordMap::KeyWord::DOMAIN_KW:
+          PARSE_TOKEN(strval);
+          model.set_domain(strval);
+          break;
+        case KeyWordMap::KeyWord::MODEL_VERSION:
+          PARSE_TOKEN(intval);
+          model.set_model_version(intval);
+          break;
+        case KeyWordMap::KeyWord::DOC_STRING:
+          PARSE_TOKEN(strval);
+          model.set_doc_string(strval);
+          break;
+        case KeyWordMap::KeyWord::METADATA_PROPS: {
+          auto& metadata_props = *model.mutable_metadata_props();
+          MATCH('[');
+          if (!Matches(']')) {
+            PARSE(metadata_props);
+            MATCH(']');
+          }
+          break;
+        }
+        default:
+          return ParseError("Unhandled keyword.");
+      }
+    } while (Matches(','));
+    MATCH('>');
+  }
+  PARSE(*model.mutable_graph());
+
+  auto* functions = model.mutable_functions();
+  while (!EndOfInput()) {
+    PARSE(*functions->Add());
+  }
+  return Common::Status::OK();
+}
+const std::unordered_map<std::string, KeyWordMap::KeyWord>& KeyWordMap::Instance() {
+  static KeyWordMap instance;
+  return instance.map_;
+}
+
+const std::string& KeyWordMap::ToString(KeyWord kw) {
+  static std::string undefined("undefined");
+  for (const auto& pair : Instance()) {
+    if (pair.second == kw)
+      return pair.first;
+  }
+  return undefined;
+}
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/parser.h b/onnx/defs/parser.h
new file mode 100644
index 0000000..7cef3e6
--- /dev/null
+++ b/onnx/defs/parser.h
@@ -0,0 +1,510 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Experimental language syntax and parser for ONNX. Please note that the syntax as formalized
+// by this parser is preliminary and may change.
+
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+#include "onnx/common/common.h"
+#include "onnx/common/status.h"
+#include "onnx/onnx_pb.h"
+#include "onnx/string_utils.h"
+
+namespace ONNX_NAMESPACE {
+
+// Locale-independent string-to-float/double conversion (defined in parser.cc).
+ONNX_API float LocaleIndependentStof(const std::string& s);
+ONNX_API double LocaleIndependentStod(const std::string& s);
+
+using IdList = google::protobuf::RepeatedPtrField<std::string>;
+
+using NodeList = google::protobuf::RepeatedPtrField<NodeProto>;
+
+using AttrList = google::protobuf::RepeatedPtrField<AttributeProto>;
+
+using ValueInfoList = google::protobuf::RepeatedPtrField<ValueInfoProto>;
+
+using TensorList = google::protobuf::RepeatedPtrField<TensorProto>;
+
+using OpsetIdList = google::protobuf::RepeatedPtrField<OperatorSetIdProto>;
+
+using StringStringList = google::protobuf::RepeatedPtrField<StringStringEntryProto>;
+
+#define CHECK_PARSER_STATUS(status) \
+  {                                 \
+    auto local_status_ = status;    \
+    if (!local_status_.IsOK())      \
+      return local_status_;         \
+  }
+
+template <typename Map>
+// NOLINTNEXTLINE(bugprone-crtp-constructor-accessibility)
+class StringIntMap {
+ public:
+  static const std::unordered_map<std::string, int32_t>& Instance() {
+    static Map instance;
+    return instance.map_;
+  }
+
+  static int32_t Lookup(const std::string& dtype) {
+    auto it = Instance().find(dtype);
+    if (it != Instance().end())
+      return it->second;
+    return 0;
+  }
+
+  static const std::string& ToString(int32_t dtype) {
+    static std::string undefined("undefined");
+    for (const auto& [name, value] : Instance()) {
+      if (value == dtype)
+        return name;
+    }
+    return undefined;
+  }
+
+ protected:
+  std::unordered_map<std::string, int32_t> map_;
+};
+
+class PrimitiveTypeNameMap : public StringIntMap<PrimitiveTypeNameMap> {
+ public:
+  PrimitiveTypeNameMap() : StringIntMap() {
+    map_["float"] = TensorProto_DataType_FLOAT;
+    map_["uint8"] = TensorProto_DataType_UINT8;
+    map_["int8"] = TensorProto_DataType_INT8;
+    map_["uint16"] = TensorProto_DataType_UINT16;
+    map_["int16"] = TensorProto_DataType_INT16;
+    map_["int32"] = TensorProto_DataType_INT32;
+    map_["int64"] = TensorProto_DataType_INT64;
+    map_["string"] = TensorProto_DataType_STRING;
+    map_["bool"] = TensorProto_DataType_BOOL;
+    map_["float16"] = TensorProto_DataType_FLOAT16;
+    map_["double"] = TensorProto_DataType_DOUBLE;
+    map_["uint32"] = TensorProto_DataType_UINT32;
+    map_["uint64"] = TensorProto_DataType_UINT64;
+    map_["complex64"] = TensorProto_DataType_COMPLEX64;
+    map_["complex128"] = TensorProto_DataType_COMPLEX128;
+    map_["bfloat16"] = TensorProto_DataType_BFLOAT16;
+    map_["float8e4m3fn"] = TensorProto_DataType_FLOAT8E4M3FN;
+    map_["float8e4m3fnuz"] = TensorProto_DataType_FLOAT8E4M3FNUZ;
+    map_["float8e5m2"] = TensorProto_DataType_FLOAT8E5M2;
+    map_["float8e5m2fnuz"] = TensorProto_DataType_FLOAT8E5M2FNUZ;
+    map_["float8e8m0"] = TensorProto_DataType_FLOAT8E8M0;
+    map_["uint4"] = TensorProto_DataType_UINT4;
+    map_["int4"] = TensorProto_DataType_INT4;
+    map_["float4e2m1"] = TensorProto_DataType_FLOAT4E2M1;
+    map_["uint2"] = TensorProto_DataType_UINT2;
+    map_["int2"] = TensorProto_DataType_INT2;
+  }
+
+  static bool IsTypeName(const std::string& dtype) {
+    return Lookup(dtype) != 0;
+  }
+};
+
+class AttributeTypeNameMap : public StringIntMap<AttributeTypeNameMap> {
+ public:
+  AttributeTypeNameMap() : StringIntMap() {
+    map_["float"] = AttributeProto_AttributeType_FLOAT;
+    map_["int"] = AttributeProto_AttributeType_INT;
+    map_["string"] = AttributeProto_AttributeType_STRING;
+    map_["tensor"] = AttributeProto_AttributeType_TENSOR;
+    map_["graph"] = AttributeProto_AttributeType_GRAPH;
+    map_["sparse_tensor"] = AttributeProto_AttributeType_SPARSE_TENSOR;
+    map_["type_proto"] = AttributeProto_AttributeType_TYPE_PROTO;
+    map_["floats"] = AttributeProto_AttributeType_FLOATS;
+    map_["ints"] = AttributeProto_AttributeType_INTS;
+    map_["strings"] = AttributeProto_AttributeType_STRINGS;
+    map_["tensors"] = AttributeProto_AttributeType_TENSORS;
+    map_["graphs"] = AttributeProto_AttributeType_GRAPHS;
+    map_["sparse_tensors"] = AttributeProto_AttributeType_SPARSE_TENSORS;
+    map_["type_protos"] = AttributeProto_AttributeType_TYPE_PROTOS;
+  }
+};
+
+class KeyWordMap {
+ public:
+  enum class KeyWord : std::uint8_t {
+    NONE,
+    IR_VERSION,
+    OPSET_IMPORT,
+    PRODUCER_NAME,
+    PRODUCER_VERSION,
+    DOMAIN_KW,
+    MODEL_VERSION,
+    DOC_STRING,
+    METADATA_PROPS,
+    SEQ_TYPE,
+    MAP_TYPE,
+    OPTIONAL_TYPE,
+    SPARSE_TENSOR_TYPE,
+    OVERLOAD_KW
+  };
+
+  KeyWordMap() {
+    map_["ir_version"] = KeyWord::IR_VERSION;
+    map_["opset_import"] = KeyWord::OPSET_IMPORT;
+    map_["producer_name"] = KeyWord::PRODUCER_NAME;
+    map_["producer_version"] = KeyWord::PRODUCER_VERSION;
+    map_["domain"] = KeyWord::DOMAIN_KW;
+    map_["model_version"] = KeyWord::MODEL_VERSION;
+    map_["doc_string"] = KeyWord::DOC_STRING;
+    map_["metadata_props"] = KeyWord::METADATA_PROPS;
+    map_["seq"] = KeyWord::SEQ_TYPE;
+    map_["map"] = KeyWord::MAP_TYPE;
+    map_["optional"] = KeyWord::OPTIONAL_TYPE;
+    map_["sparse_tensor"] = KeyWord::SPARSE_TENSOR_TYPE;
+    map_["overload"] = KeyWord::OVERLOAD_KW;
+  }
+
+  static const std::unordered_map<std::string, KeyWord>& Instance();
+
+  static KeyWord Lookup(const std::string& id) {
+    auto it = Instance().find(id);
+    if (it != Instance().end())
+      return it->second;
+    return KeyWord::NONE;
+  }
+
+  static const std::string& ToString(KeyWord kw);
+
+ private:
+  std::unordered_map<std::string, KeyWord> map_;
+};
+
+class ParserBase {
+ public:
+  explicit ParserBase(std::string_view input) : input_(input) {}
+
+  void SavePos() {
+    saved_pos_ = pos_;
+  }
+
+  void RestorePos() {
+    pos_ = saved_pos_;
+  }
+
+  std::string GetCurrentPos() {
+    uint32_t line = 1, col = 1;
+    for (size_t i = 0; i < pos_; ++i) {
+      if (input_[i] == '\n') {
+        ++line;
+        col = 1;
+      } else {
+        ++col;
+      }
+    }
+    return ONNX_NAMESPACE::MakeString("(line: ", line, " column: ", col, ")");
+  }
+
+  // Return a suitable suffix of what has been parsed to provide error message context:
+  // return the line containing the last non-space character preceding the error (if it exists).
+  std::string GetErrorContext() {
+    if (input_.empty())
+      return std::string();
+    // Special case: a parse-error at end of input starts from the last character.
+    size_t p = (pos_ < input_.size()) ? pos_ : input_.size() - 1;
+    while ((p > 0) && IsSpace(input_[p]))
+      --p;
+    while ((p > 0) && (input_[p] != '\n'))
+      --p;
+    // Start at character after '\n' unless we are at start of input
+    size_t context_start = (p > 0) ? (p + 1) : 0;
+    size_t context_end = context_start;
+    while ((context_end < input_.size()) && (input_[context_end] != '\n'))
+      ++context_end;
+    return std::string(input_.substr(context_start, context_end - context_start));
+  }
+
+  template <typename... Args>
+  Common::Status ParseError(const Args&... args) {
+    return Common::Status(
+        Common::StatusCategory::NONE,
+        Common::StatusCode::FAIL,
+        ONNX_NAMESPACE::MakeString(
+            "[ParseError at position ", GetCurrentPos(), "]\n", "Error context: ", GetErrorContext(), "\n", args...));
+  }
+
+  void SkipWhiteSpace() {
+    do {
+      while (!AtEnd() && IsSpace(Cur()))
+        ++pos_;
+      if (AtEnd() || (Cur() != '#'))
+        return;
+      // Skip rest of the line; the loop then consumes the newline as whitespace.
+      pos_ = std::min(input_.find('\n', pos_), input_.size());
+    } while (true);
+  }
+
+  int NextChar(bool skipspace = true) {
+    if (skipspace)
+      SkipWhiteSpace();
+    // Return as unsigned char so the value is safe to pass to ctype functions.
+    return AtEnd() ? 0 : static_cast<unsigned char>(Cur());
+  }
+
+  bool Matches(char ch, bool skipspace = true) {
+    if (skipspace)
+      SkipWhiteSpace();
+    if (!AtEnd() && (Cur() == ch)) {
+      ++pos_;
+      return true;
+    }
+    return false;
+  }
+
+  Common::Status Match(char ch, bool skipspace = true) {
+    if (!Matches(ch, skipspace))
+      return ParseError("Expected character ", ch, " not found.");
+    return Common::Status::OK();
+  }
+
+  bool EndOfInput() {
+    SkipWhiteSpace();
+    return AtEnd();
+  }
+
+  enum class LiteralType : std::uint8_t { UNDEFINED, INT_LITERAL, FLOAT_LITERAL, STRING_LITERAL };
+
+  struct Literal {
+    LiteralType type{LiteralType::UNDEFINED};
+    std::string value;
+  };
+
+  Common::Status Parse(Literal& result);
+
+  Common::Status Parse(int64_t& val) {
+    Literal literal;
+    CHECK_PARSER_STATUS(Parse(literal))
+    if (literal.type != LiteralType::INT_LITERAL)
+      return ParseError("Integer value expected, but not found.");
+    val = std::stoll(literal.value);
+    return Common::Status::OK();
+  }
+
+  Common::Status Parse(uint64_t& val) {
+    Literal literal;
+    CHECK_PARSER_STATUS(Parse(literal))
+    if (literal.type != LiteralType::INT_LITERAL)
+      return ParseError("Integer value expected, but not found.");
+    val = std::stoull(literal.value);
+    return Common::Status::OK();
+  }
+
+  Common::Status Parse(float& val) {
+    Literal literal;
+    CHECK_PARSER_STATUS(Parse(literal))
+    switch (literal.type) {
+      case LiteralType::INT_LITERAL:
+      case LiteralType::FLOAT_LITERAL:
+        val = LocaleIndependentStof(literal.value);
+        break;
+      default:
+        return ParseError("Unexpected literal type.");
+    }
+    return Common::Status::OK();
+  }
+
+  Common::Status Parse(double& val) {
+    Literal literal;
+    CHECK_PARSER_STATUS(Parse(literal))
+    switch (literal.type) {
+      case LiteralType::INT_LITERAL:
+      case LiteralType::FLOAT_LITERAL:
+        val = LocaleIndependentStod(literal.value);
+        break;
+      default:
+        return ParseError("Unexpected literal type.");
+    }
+    return Common::Status::OK();
+  }
+
+  // Parse a string-literal enclosed within double-quotes.
+  Common::Status Parse(std::string& val) {
+    Literal literal;
+    CHECK_PARSER_STATUS(Parse(literal))
+    if (literal.type != LiteralType::STRING_LITERAL)
+      return ParseError("String value expected, but not found.");
+    val = literal.value;
+    return Common::Status::OK();
+  }
+
+  // Parse an identifier, including keywords. If none found, this will
+  // return an empty-string identifier.
+  std::string ParseOptionalIdentifier() {
+    SkipWhiteSpace();
+    size_t from = pos_;
+    if (!AtEnd() && (IsAlpha(Cur()) || (Cur() == '_'))) {
+      ++pos_;
+      while (!AtEnd() && (IsAlnum(Cur()) || (Cur() == '_')))
+        ++pos_;
+    }
+    return std::string(input_.substr(from, pos_ - from));
+  }
+
+  Common::Status ParseIdentifier(std::string& id) {
+    id = ParseOptionalIdentifier();
+    if (id.empty())
+      return ParseError("Identifier expected but not found.");
+    return Common::Status::OK();
+  }
+
+  Common::Status ParseQuotableIdentifier(std::string& id) {
+    if (NextChar() == '"') {
+      return Parse(id);
+    }
+    return ParseIdentifier(id);
+  }
+
+  Common::Status ParseOptionalQuotableIdentifier(std::string& id) {
+    if (NextChar() == '"') {
+      return Parse(id);
+    }
+    id = ParseOptionalIdentifier();
+    return Common::Status::OK();
+  }
+
+  // Parse an optional quotable identifier, and return whether an identifier was found
+  // in the output parameter 'id_found'.
+  // A empty string followed by a comma is considered to be a valid, but empty, identifier.
+  // This helps handle the following different cases:
+  // "Op()" has no operands
+  // "Op(,x)" has two operands, the first being empty.
+  // 'Op("")' has one operand, which is an empty string.
+  // 'Op(,)' has one operand, which is an empty string.
+  // Thus, this will also allow a trailing comma after a non-empty identifier with no effect.
+  // 'Op(x,)' has one operand, which is 'x'.
+  //
+  // This is mostly for some backward compatibility. "" is a simpler way to represent an
+  // empty identifier that is less confusing and is recommended.
+  Common::Status ParseOptionalQuotableIdentifier(std::string& id, bool& id_found) {
+    if (NextChar() == '"') {
+      id_found = true;
+      return Parse(id);
+    }
+    id = ParseOptionalIdentifier();
+    id_found = !id.empty() || NextChar() == ',';
+    return Common::Status::OK();
+  }
+
+  std::string PeekIdentifier() {
+    SavePos();
+    auto id = ParseOptionalIdentifier();
+    RestorePos();
+    return id;
+  }
+
+  Common::Status Parse(KeyWordMap::KeyWord& keyword) {
+    std::string id;
+    CHECK_PARSER_STATUS(ParseIdentifier(id))
+    keyword = KeyWordMap::Lookup(id);
+    return Common::Status::OK();
+  }
+
+ protected:
+  // True when the cursor has consumed all input.
+  bool AtEnd() const {
+    return pos_ >= input_.size();
+  }
+  // Character at the cursor; only valid when !AtEnd().
+  char Cur() const {
+    return input_[pos_];
+  }
+  // ctype wrappers that pass the character as unsigned char (UB otherwise for bytes > 127).
+  static bool IsSpace(char c) {
+    return std::isspace(static_cast<unsigned char>(c));
+  }
+  static bool IsAlpha(char c) {
+    return std::isalpha(static_cast<unsigned char>(c));
+  }
+  static bool IsAlnum(char c) {
+    return std::isalnum(static_cast<unsigned char>(c));
+  }
+  static bool IsDigit(char c) {
+    return std::isdigit(static_cast<unsigned char>(c));
+  }
+
+  std::string_view input_;
+  size_t pos_ = 0;
+  size_t saved_pos_ = 0;
+
+  bool NextIsValidFloatString();
+};
+
+class OnnxParser : public ParserBase {
+ public:
+  using ParserBase::ParserBase;
+
+  ONNX_API Common::Status Parse(TensorShapeProto& shape);
+
+  ONNX_API Common::Status Parse(TypeProto& typeProto);
+
+  ONNX_API Common::Status Parse(StringStringList& stringStringList);
+
+  ONNX_API Common::Status Parse(TensorProto& tensorProto);
+
+  ONNX_API Common::Status Parse(AttributeProto& attr);
+
+  ONNX_API Common::Status Parse(AttributeProto& attr, std::string& name);
+
+  ONNX_API Common::Status Parse(AttrList& attrlist);
+
+  ONNX_API Common::Status Parse(NodeProto& node);
+
+  ONNX_API Common::Status Parse(NodeList& nodelist);
+
+  ONNX_API Common::Status Parse(GraphProto& graph);
+
+  ONNX_API Common::Status Parse(FunctionProto& fn);
+
+  ONNX_API Common::Status Parse(ModelProto& model);
+
+  template <typename T>
+  static Common::Status Parse(T& parsedData, std::string_view input) {
+    OnnxParser parser(input);
+    return parser.Parse(parsedData);
+  }
+
+ private:
+  Common::Status Parse(std::string name, GraphProto& graph);
+
+  Common::Status Parse(IdList& idlist);
+
+  Common::Status Parse(char open, IdList& idlist, char close);
+
+  Common::Status Parse(IdList& idlist, AttrList& attrlist);
+
+  Common::Status Parse(char open, IdList& idlist, AttrList& attrlist, char close);
+
+  Common::Status ParseSingleAttributeValue(AttributeProto& attr, AttributeProto_AttributeType expected);
+
+  Common::Status Parse(ValueInfoProto& valueinfo);
+
+  Common::Status ParseGraphInputOutput(ValueInfoList& vilist);
+
+  Common::Status ParseFunctionInputOutput(IdList& idlist, ValueInfoList& vilist);
+
+  Common::Status Parse(char open, ValueInfoList& vilist, char close);
+
+  Common::Status ParseInput(ValueInfoList& inputs, TensorList& initializers);
+
+  Common::Status ParseValueInfo(ValueInfoList& value_infos, TensorList& initializers);
+
+  Common::Status Parse(TensorProto& tensorProto, const TypeProto& tensorTypeProto);
+
+  Common::Status Parse(OpsetIdList& opsets);
+
+  bool NextIsType();
+
+  bool NextIsIdentifier();
+};
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/preview/CMakeLists.txt b/onnx/defs/preview/CMakeLists.txt
new file mode 100644
index 0000000..ebc1561
--- /dev/null
+++ b/onnx/defs/preview/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+)
diff --git a/onnx/defs/preview/defs.cc b/onnx/defs/preview/defs.cc
new file mode 100644
index 0000000..6f1a302
--- /dev/null
+++ b/onnx/defs/preview/defs.cc
@@ -0,0 +1,511 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <algorithm>
+#include <optional>
+
+#include "onnx/defs/function.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/shape_inference.h"
+
+namespace ONNX_NAMESPACE {
+
+// ---------------------------------------------------------------------------
+// FlexAttention Constants
+// ---------------------------------------------------------------------------
+
+// Expected number of inputs for modifier subgraphs: (tensor_in)
+static constexpr int kModifierInputCount = 1;
+
+static constexpr const char* FlexAttention_ver1_doc = R"DOC(
+Computes scaled dot-product attention over rank-4 (batched, multi-head) inputs,
+with optional user-provided customization subgraphs at two stages:
+
+1. score_mod: Modify the attention score tensor after Q·K^T
+2. prob_mod: Modify the probability tensor after Softmax
+
+This operator mirrors the capabilities of PyTorch's flex_attention:
+https://docs.pytorch.org/docs/stable/nn.attention.flex_attention.html
+
+Input Shapes (MUST be rank-4 tensors):
+- Q: `(batch_size, q_num_heads, q_sequence_length, head_size)`
+- K: `(batch_size, kv_num_heads, kv_sequence_length, head_size)`
+- V: `(batch_size, kv_num_heads, kv_sequence_length, v_head_size)`
+
+Output Shape:
+- Y: `(batch_size, q_num_heads, q_sequence_length, v_head_size)`
+
+FlexAttention Computation:
+```
+Scores = (Q @ K^T) * scale
+Scores = score_mod(Scores)             # if 'score_mod' is provided
+Probs = Softmax(Scores, axis=-1)
+Probs = prob_mod(Probs)                # if 'prob_mod' is provided
+Y = Probs @ V
+```
+
+Grouped Query Attention (GQA):
+When `q_num_heads != kv_num_heads`, each K/V head is shared by a contiguous
+group of query heads in head-index order. Let
+`group_size = q_num_heads / kv_num_heads`; then query head `h` uses K/V head
+`floor(h / group_size)`. `q_num_heads` must be a multiple of
+`kv_num_heads`.
+
+Modifier Subgraphs (score_mod, prob_mod):
+Each modifier subgraph takes exactly one rank-4 tensor input and must produce
+exactly one rank-4 tensor output of the same shape and element type.
+- score_mod input/output shape: `(batch_size, q_num_heads, q_sequence_length, kv_sequence_length)`
+- prob_mod  input/output shape: `(batch_size, q_num_heads, q_sequence_length, kv_sequence_length)`
+The element type is determined by softmax_precision (defaults to float32 for
+non-double inputs, otherwise double).
+
+Masking can be expressed in score_mod by writing masked positions as -inf (or a
+large negative value appropriate for the target precision).
+)DOC";
+
+// ---------------------------------------------------------------------------
+// Type Utilities
+// ---------------------------------------------------------------------------
+
+// Returns true if the element type supports softmax computation.
+// Softmax requires floating-point types for numerical stability.
+static bool IsValidSoftmaxElementType(int32_t elem_type) {
+  switch (elem_type) {
+    case TensorProto::FLOAT:
+    case TensorProto::FLOAT16:
+    case TensorProto::BFLOAT16:
+    case TensorProto::DOUBLE:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// Determines the element type for softmax computation.
+// Priority:
+//   1. Use explicit softmax_precision attribute if provided
+//   2. Default to float32 for all non-double input types
+//   3. Keep double as double
+static int32_t GetSoftmaxElementType(int32_t input_elem_type, const AttributeProto* softmax_precision_attr) {
+  // Honor explicit precision setting
+  if (softmax_precision_attr != nullptr) {
+    return static_cast<int32_t>(softmax_precision_attr->i());
+  }
+  return input_elem_type == TensorProto::DOUBLE ? TensorProto::DOUBLE : TensorProto::FLOAT;
+}
+
+// ---------------------------------------------------------------------------
+// Modifier Graph Validation
+// ---------------------------------------------------------------------------
+
+// Validates a modifier graph attribute for function builder context.
+// Returns true if the graph is valid or not provided.
+static bool ValidateModifierGraphForBuilder(const AttributeProto* attr) {
+  if (attr == nullptr) {
+    return true; // Optional attribute not provided.
+  }
+  if (!attr->has_g()) {
+    return false; // Attribute exists but is not a graph.
+  }
+  const auto& graph = attr->g();
+  return graph.input_size() == kModifierInputCount && graph.output_size() == 1;
+}
+
+// Checks if a modifier graph is a trivial identity (passes through first input unchanged).
+static bool IsIdentityModifierGraph(const AttributeProto* attr) {
+  if (attr == nullptr || !attr->has_g()) {
+    return false;
+  }
+  const auto& graph = attr->g();
+  return graph.node_size() == 0 && graph.input_size() == kModifierInputCount && graph.output_size() == 1 &&
+      graph.input(0).name() == graph.output(0).name();
+}
+
+// ---------------------------------------------------------------------------
+// Shape Inference
+// ---------------------------------------------------------------------------
+
+// Validates a modifier graph attribute during shape inference.
+// Checks I/O counts, element types, and scalar requirements.
+static void ValidateModifierGraph(
+    const AttributeProto* attr,
+    const std::string& attr_name,
+    std::optional<int32_t> expected_output_elem_type) {
+  if (!attr) {
+    return;
+  }
+  if (!attr->has_g()) {
+    fail_shape_inference("Attribute ", attr_name, " must be a graph.");
+  }
+
+  const auto& graph = attr->g();
+
+  // Validate I/O counts.
+  if (graph.input_size() != kModifierInputCount) {
+    fail_shape_inference(
+        "Attribute ", attr_name, " expected ", kModifierInputCount, " input but graph has ", graph.input_size(), ".");
+  }
+  if (graph.output_size() != 1) {
+    fail_shape_inference("Attribute ", attr_name, " must have exactly one output.");
+  }
+
+  // Helper: validate element type.
+  auto validate_dtype = [&](const ValueInfoProto& vi, int32_t expected, const char* desc) {
+    if (!vi.has_type() || !vi.type().has_tensor_type())
+      return;
+    if (vi.type().tensor_type().elem_type() != expected) {
+      fail_shape_inference(
+          "Attribute ",
+          attr_name,
+          " ",
+          desc,
+          " type mismatch. Expected ",
+          expected,
+          ", got ",
+          vi.type().tensor_type().elem_type(),
+          ".");
+    }
+  };
+
+  // Validate input element types.
+  if (expected_output_elem_type.has_value() && graph.input_size() >= 1) {
+    validate_dtype(graph.input(0), expected_output_elem_type.value(), "input(0)");
+  }
+
+  // Validate output type and shape.
+  if (graph.output(0).has_type()) {
+    const auto& type = graph.output(0).type();
+    if (!type.has_tensor_type()) {
+      fail_shape_inference("Attribute ", attr_name, " output must be a tensor.");
+    }
+    const auto& tensor = type.tensor_type();
+    if (expected_output_elem_type.has_value() && tensor.elem_type() != expected_output_elem_type.value()) {
+      fail_shape_inference(
+          "Attribute ",
+          attr_name,
+          " output type mismatch. Expected ",
+          expected_output_elem_type.value(),
+          ", got ",
+          tensor.elem_type(),
+          ".");
+    }
+  }
+
+  // Validate modifier tensor ranks and compatibility when specified.
+  if (graph.input(0).has_type() && graph.input(0).type().has_tensor_type()) {
+    const auto& input_tensor = graph.input(0).type().tensor_type();
+    if (input_tensor.has_shape() && input_tensor.shape().dim_size() != 4) {
+      fail_shape_inference("Attribute ", attr_name, " input must be rank-4 tensor when shape is specified.");
+    }
+  }
+  if (graph.output(0).has_type() && graph.output(0).type().has_tensor_type()) {
+    const auto& output_tensor = graph.output(0).type().tensor_type();
+    if (output_tensor.has_shape() && output_tensor.shape().dim_size() != 4) {
+      fail_shape_inference("Attribute ", attr_name, " output must be rank-4 tensor when shape is specified.");
+    }
+  }
+  if (graph.input(0).has_type() && graph.output(0).has_type() && graph.input(0).type().has_tensor_type() &&
+      graph.output(0).type().has_tensor_type()) {
+    const auto& in_shape = graph.input(0).type().tensor_type().shape();
+    const auto& out_shape = graph.output(0).type().tensor_type().shape();
+    const int dim_count = std::min(in_shape.dim_size(), out_shape.dim_size());
+    for (int i = 0; i < dim_count; ++i) {
+      if (in_shape.dim(i).has_dim_value() && out_shape.dim(i).has_dim_value() &&
+          in_shape.dim(i).dim_value() != out_shape.dim(i).dim_value()) {
+        fail_shape_inference("Attribute ", attr_name, " output shape must match input shape when specified.");
+      }
+    }
+  }
+}
+
+static void FlexAttentionShapeInference(InferenceContext& ctx) {
+  // Require Q, K, V inputs.
+  if (ctx.getNumInputs() < 3) {
+    fail_type_inference("FlexAttention requires query, key, and value inputs.");
+  }
+
+  const auto* q_type = ctx.getInputType(0);
+  const auto* k_type = ctx.getInputType(1);
+  const auto* v_type = ctx.getInputType(2);
+  if (!q_type || !k_type || !v_type) {
+    return;
+  }
+  if (!q_type->has_tensor_type() || !k_type->has_tensor_type() || !v_type->has_tensor_type()) {
+    fail_type_inference("Inputs 0, 1, and 2 are required tensor types.");
+  }
+
+  // Validate element type consistency.
+  const auto q_elem_type = q_type->tensor_type().elem_type();
+  const auto k_elem_type = k_type->tensor_type().elem_type();
+  const auto v_elem_type = v_type->tensor_type().elem_type();
+  if (q_elem_type != k_elem_type || q_elem_type != v_elem_type) {
+    fail_type_inference("Inputs query, key, and value must have the same element type.");
+  }
+
+  // Set output element type.
+  auto* output_type = ctx.getOutputType(0)->mutable_tensor_type();
+  output_type->set_elem_type(q_elem_type);
+
+  // Validate input ranks.
+  const auto& q_shape = q_type->tensor_type().shape();
+  const auto& k_shape = k_type->tensor_type().shape();
+  const auto& v_shape = v_type->tensor_type().shape();
+  if (q_shape.dim_size() != 4 || k_shape.dim_size() != 4 || v_shape.dim_size() != 4) {
+    fail_shape_inference(
+        "FlexAttention requires rank-4 inputs: "
+        "Q (B, Hq, L, Dqk), K (B, Hkv, S, Dqk), V (B, Hkv, S, Dv).");
+  }
+
+  // Validate K and V share the same number of heads.
+  if (k_shape.dim(1).has_dim_value() && v_shape.dim(1).has_dim_value() &&
+      k_shape.dim(1).dim_value() != v_shape.dim(1).dim_value()) {
+    fail_shape_inference("Key and value must share the same head dimension.");
+  }
+
+  // Validate K and V share the same sequence length.
+  if (k_shape.dim(2).has_dim_value() && v_shape.dim(2).has_dim_value() &&
+      k_shape.dim(2).dim_value() != v_shape.dim(2).dim_value()) {
+    fail_shape_inference("Key and value must share the same sequence length.");
+  }
+
+  // Validate Q and K share the same embedding dimension.
+  if (q_shape.dim(3).has_dim_value() && k_shape.dim(3).has_dim_value() &&
+      q_shape.dim(3).dim_value() != k_shape.dim(3).dim_value()) {
+    fail_shape_inference("Query and key must share the same embedding dimension.");
+  }
+
+  // Validate Grouped Query Attention (GQA) configuration.
+  if (q_shape.dim(1).has_dim_value() && k_shape.dim(1).has_dim_value()) {
+    const auto hq = q_shape.dim(1).dim_value();
+    const auto hkv = k_shape.dim(1).dim_value();
+    if (hq != hkv && (hkv <= 0 || (hq % hkv) != 0)) {
+      fail_shape_inference("q_num_heads must be a multiple of kv_num_heads when they differ.");
+    }
+  }
+
+  // Set output shape: (B, Hq, L, Dv).
+  auto* output_shape = output_type->mutable_shape();
+  output_shape->clear_dim();
+  *output_shape->add_dim() = q_shape.dim(0); // Batch
+  *output_shape->add_dim() = q_shape.dim(1); // Query heads
+  *output_shape->add_dim() = q_shape.dim(2); // Query sequence length
+  *output_shape->add_dim() = v_shape.dim(3); // Value head size
+
+  // Merge batch dimension info from all inputs.
+  mergeInDimensionInfo(k_shape.dim(0), *output_shape->mutable_dim(0), 0);
+  mergeInDimensionInfo(v_shape.dim(0), *output_shape->mutable_dim(0), 0);
+  if (q_shape.dim(1).has_dim_value() && k_shape.dim(1).has_dim_value() &&
+      q_shape.dim(1).dim_value() == k_shape.dim(1).dim_value()) {
+    mergeInDimensionInfo(k_shape.dim(1), *output_shape->mutable_dim(1), 1);
+  }
+
+  // Validate softmax precision.
+  const int32_t softmax_elem_type = GetSoftmaxElementType(q_elem_type, ctx.getAttribute("softmax_precision"));
+  if (!IsValidSoftmaxElementType(softmax_elem_type)) {
+    fail_type_inference("softmax_precision must be specified when inputs are not float/float16/bfloat16/double.");
+  }
+
+  // Validate modifier graphs.
+  ValidateModifierGraph(ctx.getAttribute("score_mod"), "score_mod", softmax_elem_type);
+  ValidateModifierGraph(ctx.getAttribute("prob_mod"), "prob_mod", softmax_elem_type);
+}
+
+// ---------------------------------------------------------------------------
+// Function Body Builder
+// ---------------------------------------------------------------------------
+
+// Builds the function body for FlexAttention.
+// The following pattern is applied:
+//
+//      Q          K          V
+//      |          |          |
+//      |       Transpose     |
+//      |          |          |
+//      ---MatMul---          |
+//            |               |
+//         * scale            |
+//            |               |
+//      [score_mod]           |
+//            |               |
+//         Softmax            |
+//            |               |
+//       [prob_mod]           |
+//            |               |
+//            -----MatMul------
+//                   |
+//                   Y
+//
+static bool BuildFlexAttentionFunctionBody(
+    const FunctionBodyBuildContext& ctx,
+    const OpSchema& schema,
+    FunctionProto& functionProto) {
+  // Validate and extract input types
+  const auto* q_type = ctx.getInputType(0);
+  const auto* k_type = ctx.getInputType(1);
+  const auto* v_type = ctx.getInputType(2);
+
+  if (!q_type || !k_type || !v_type || !q_type->has_tensor_type() || !k_type->has_tensor_type() ||
+      !v_type->has_tensor_type()) {
+    return false;
+  }
+
+  const int64_t input_elem_type = q_type->tensor_type().elem_type();
+  if (k_type->tensor_type().elem_type() != input_elem_type || v_type->tensor_type().elem_type() != input_elem_type) {
+    return false;
+  }
+
+  // Determine softmax precision
+  const int32_t softmax_precision =
+      GetSoftmaxElementType(static_cast<int32_t>(input_elem_type), ctx.getAttribute("softmax_precision"));
+  if (!IsValidSoftmaxElementType(softmax_precision)) {
+    return false;
+  }
+
+  const auto* scale_attr = ctx.getAttribute("scale");
+  const float scale = scale_attr ? scale_attr->f() : 1.0f;
+
+  // Validate modifier graphs
+  const auto* score_mod_attr = ctx.getAttribute("score_mod");
+  const auto* prob_mod_attr = ctx.getAttribute("prob_mod");
+
+  if (!ValidateModifierGraphForBuilder(score_mod_attr) || !ValidateModifierGraphForBuilder(prob_mod_attr)) {
+    return false;
+  }
+
+  // Check which modifier graphs are needed.
+  const bool need_score_mod = score_mod_attr && !IsIdentityModifierGraph(score_mod_attr);
+  const bool need_prob_mod = prob_mod_attr && !IsIdentityModifierGraph(prob_mod_attr);
+
+  // Build the function graph
+  constexpr int64_t kFloat32 = TensorProto_DataType_FLOAT;
+
+  FunctionBuilder builder(functionProto);
+
+  // Extract shape information.
+  builder.Add("BatchSize = Shape <start = 0, end = 1> (Q)").Add("KVSeqLen = Shape <start = -2, end = -1> (K)");
+
+  builder.Add("QNumHeads = Shape <start = 1, end = 2> (Q)").Add("KVNumHeads = Shape <start = 1, end = 2> (K)");
+
+  // Handle Grouped Query Attention (GQA) by sharing each K/V head across
+  // contiguous query-head groups when needed.
+  builder.Add("KVRepeat = Div (QNumHeads, KVNumHeads)")
+      .Const1D("Axis2", static_cast<int64_t>(2))
+      // K: [B, Hkv, S, E] -> [B, Hq, S, E]
+      .Add("KUnsqueezed = Unsqueeze(K, Axis2)")
+      .Add("KHeadSize1D = Shape <start = 3, end = 4> (K)")
+      .Add("KExpandShape = Concat <axis = 0> (BatchSize, KVNumHeads, KVRepeat, KVSeqLen, KHeadSize1D)")
+      .Add("KExpanded = Expand(KUnsqueezed, KExpandShape)")
+      .Add("KAlignedShape = Concat <axis = 0> (BatchSize, QNumHeads, KVSeqLen, KHeadSize1D)")
+      .Add("KAligned = Reshape(KExpanded, KAlignedShape)")
+      // V: same transformation
+      .Add("VUnsqueezed = Unsqueeze(V, Axis2)")
+      .Add("VHeadSize1D = Shape <start = 3, end = 4> (V)")
+      .Add("VExpandShape = Concat <axis = 0> (BatchSize, KVNumHeads, KVRepeat, KVSeqLen, VHeadSize1D)")
+      .Add("VExpanded = Expand(VUnsqueezed, VExpandShape)")
+      .Add("VAlignedShape = Concat <axis = 0> (BatchSize, QNumHeads, KVSeqLen, VHeadSize1D)")
+      .Add("VAligned = Reshape(VExpanded, VAlignedShape)");
+
+  // Compute scaling factor.
+  if (scale_attr != nullptr) {
+    builder.Const("ScaleFactorF32", ToTensor<float>(scale));
+  } else {
+    builder.Add("QShapeAll = Shape(Q)")
+        .Const("Idx3Head", ToTensor<int64_t>(3))
+        .Add("QKHeadSize = Gather <axis = 0> (QShapeAll, Idx3Head)")
+        .Add("QKHeadSizeF = Cast (QKHeadSize)", "to", kFloat32)
+        .Add("SqrtHeadSize = Sqrt(QKHeadSizeF)")
+        .Const("OneF", ToTensor<float>(1.0f))
+        .Add("CalculatedScale = Div(OneF, SqrtHeadSize)")
+        .Add("ScaleFactorF32 = Identity(CalculatedScale)");
+  }
+  builder.Add("ScaleFactorSqrtF32 = Sqrt(ScaleFactorF32)")
+      .Add("ScaleFactorSqrt = Cast (ScaleFactorSqrtF32)", "to", input_elem_type);
+
+  // Compute attention scores by pre-scaling Q and K with sqrt(scale).
+  builder.Add("QScaled = Mul(Q, ScaleFactorSqrt)")
+      .Add("KScaled = Mul(KAligned, ScaleFactorSqrt)")
+      .Add("KTranspose = Transpose <perm = [0, 1, 3, 2]> (KScaled)")
+      .Add("Score = MatMul(QScaled, KTranspose)")
+      .Add("SoftmaxCast = Cast (Score)", "to", softmax_precision);
+
+  // Apply score_mod.
+  if (need_score_mod) {
+    builder.AddInlinedCall({"ScoreAfterScoreMod"}, score_mod_attr->g(), {"SoftmaxCast"}, "ScoreMod_");
+  } else {
+    builder.Add("ScoreAfterScoreMod = Identity(SoftmaxCast)");
+  }
+
+  // Apply Softmax.
+  builder.Add("Prob = Softmax <axis = 3> (ScoreAfterScoreMod)");
+
+  // Apply prob_mod.
+  if (need_prob_mod) {
+    builder.AddInlinedCall({"ProbAfterProbMod"}, prob_mod_attr->g(), {"Prob"}, "ProbMod_");
+  } else {
+    builder.Add("ProbAfterProbMod = Identity(Prob)");
+  }
+
+  // Compute final output: Prob @ V.
+  if (static_cast<int64_t>(softmax_precision) != input_elem_type) {
+    builder.Add("VSp = Cast (VAligned)", "to", softmax_precision)
+        .Add("YSp = MatMul (ProbAfterProbMod, VSp)")
+        .Add("Y = Cast (YSp)", "to", input_elem_type);
+  } else {
+    builder.Add("Y = MatMul (ProbAfterProbMod, VAligned)");
+  }
+
+  // Finalize function.
+  schema.BuildFunction(functionProto);
+
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Operator Schema Registration
+// ---------------------------------------------------------------------------
+
+ONNX_PREVIEW_OPERATOR_SET_SCHEMA(
+    FlexAttention,
+    1,
+    OpSchema()
+        .SetDoc(FlexAttention_ver1_doc)
+        .Input(0, "Q", "Query tensor with shape `(batch_size, q_num_heads, q_seq_len, head_size)`.", "T1")
+        .Input(1, "K", "Key tensor with shape `(batch_size, kv_num_heads, kv_seq_len, head_size)`.", "T1")
+        .Input(2, "V", "Value tensor with shape `(batch_size, kv_num_heads, kv_seq_len, v_head_size)`.", "T1")
+        .Output(0, "Y", "Output tensor with shape `(batch_size, q_num_heads, q_seq_len, v_head_size)`.", "T1")
+        .Attr(
+            "scale",
+            "Scaling factor for Q*K^T. Defaults to 1/sqrt(head_size).",
+            AttributeProto::FLOAT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "softmax_precision",
+            "Floating-point precision for softmax computation. "
+            "Defaults to float32 for non-double inputs, otherwise uses double. "
+            "Must be explicitly specified for non-float types.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Attr(
+            "score_mod",
+            "Optional score modifier subgraph with 1 rank-4 tensor input and 1 rank-4 tensor output "
+            "of the same shape and element type: (scores) -> scores_out. "
+            "scores has softmax_precision element type and shape (B, Hq, L, S). "
+            "The output must preserve the input shape.",
+            AttributeProto::GRAPH,
+            OPTIONAL_VALUE)
+        .Attr(
+            "prob_mod",
+            "Optional probability modifier subgraph with 1 rank-4 tensor input and 1 rank-4 tensor output "
+            "of the same shape and element type: (probs) -> probs_out. "
+            "probs has softmax_precision element type and shape (B, Hq, L, S). "
+            "The output must preserve the input shape.",
+            AttributeProto::GRAPH,
+            OPTIONAL_VALUE)
+        .TypeConstraint("T1", OpSchema::all_float_types_ir4(), "Constrain Q, K, V to float tensors.")
+        .TypeAndShapeInferenceFunction(FlexAttentionShapeInference)
+        .SetSupportLevel(OpSchema::SupportType::EXPERIMENTAL)
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildFlexAttentionFunctionBody));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/printer.cc b/onnx/defs/printer.cc
new file mode 100644
index 0000000..d441775
--- /dev/null
+++ b/onnx/defs/printer.cc
@@ -0,0 +1,533 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/printer.h"
+
+#include <iomanip>
+#include <string>
+
+#include "onnx/defs/tensor_proto_util.h"
+
+namespace ONNX_NAMESPACE {
+namespace {
+
+using StringStringEntryProtos = google::protobuf::RepeatedPtrField<StringStringEntryProto>;
+
+bool IsValidIdentifier(const std::string& str) {
+  // Check if str is a valid identifier
+  const char* next_ = str.c_str();
+  const char* end_ = next_ + str.size();
+  if (next_ == end_)
+    return false; // empty string is not a valid identifier
+  if (!isalpha(*next_) && (*next_ != '_'))
+    return false; // first character must be a letter or '_'
+  ++next_;
+  while ((next_ < end_) && (isalnum(*next_) || (*next_ == '_')))
+    ++next_;
+  return next_ == end_;
+}
+
+class ProtoPrinter {
+ public:
+  explicit ProtoPrinter(std::ostream& os) : output_(os) {}
+
+  void print(const TensorShapeProto_Dimension& dim);
+
+  void print(const TensorShapeProto& shape);
+
+  void print(const TypeProto_Tensor& tensortype);
+
+  void print(const TypeProto& type);
+
+  void print(const TypeProto_Sequence& seqType);
+
+  void print(const TypeProto_Map& mapType);
+
+  void print(const TypeProto_Optional& optType);
+
+  void print(const TypeProto_SparseTensor& sparseType);
+
+  void print(const TensorProto& tensor, bool is_initializer = false);
+
+  void print(const ValueInfoProto& value_info);
+
+  void print(const ValueInfoList& vilist);
+
+  void print(const AttributeProto& attr);
+
+  void print(const AttrList& attrlist);
+
+  void print(const NodeProto& node);
+
+  void print(const NodeList& nodelist);
+
+  void print(const GraphProto& graph);
+
+  void print(const FunctionProto& fn);
+
+  void print(const ModelProto& model);
+
+  void print(const OperatorSetIdProto& opset);
+
+  void print(const OpsetIdList& opsets);
+
+  void print(const StringStringEntryProtos& stringStringProtos) {
+    printSet("[", ", ", "]", stringStringProtos);
+  }
+
+  void print(const StringStringEntryProto& metadata) {
+    printQuoted(metadata.key());
+    output_ << ": ";
+    printQuoted(metadata.value());
+  }
+
+ private:
+  void printId(const std::string& str) {
+    if (IsValidIdentifier(str))
+      output_ << str;
+    else
+      printQuoted(str);
+  }
+
+  template <typename T>
+  void print(const T& prim) {
+    output_ << prim;
+  }
+
+  void printQuoted(const std::string& str) {
+    output_ << "\"";
+    for (char ch : str) {
+      if ((ch == '\\') || (ch == '"'))
+        output_ << '\\';
+      output_ << ch;
+    }
+    output_ << "\"";
+  }
+
+  template <typename T>
+  void printKeyValuePair(KeyWordMap::KeyWord key, const T& val, bool addsep = true) {
+    if (addsep)
+      output_ << "," << '\n';
+    output_ << std::setw(indent_level) << ' ' << KeyWordMap::ToString(key) << ": ";
+    print(val);
+  }
+
+  void printKeyValuePair(KeyWordMap::KeyWord key, const std::string& val) {
+    output_ << "," << '\n';
+    output_ << std::setw(indent_level) << ' ' << KeyWordMap::ToString(key) << ": ";
+    printQuoted(val);
+  }
+
+  template <typename Collection>
+  void printSet(const char* open, const char* separator, const char* close, const Collection& coll) {
+    const char* sep = "";
+    output_ << open;
+    for (auto& elt : coll) {
+      output_ << sep;
+      print(elt);
+      sep = separator;
+    }
+    output_ << close;
+  }
+
+  template <typename Collection>
+  void printIdSet(const char* open, const char* separator, const char* close, const Collection& coll) {
+    const char* sep = "";
+    output_ << open;
+    for (auto& elt : coll) {
+      output_ << sep;
+      printId(elt);
+      sep = separator;
+    }
+    output_ << close;
+  }
+
+  std::ostream& output_;
+  int indent_level = 3;
+
+  void indent() {
+    indent_level += 3;
+  }
+
+  void outdent() {
+    indent_level -= 3;
+  }
+};
+
+void ProtoPrinter::print(const TensorShapeProto_Dimension& dim) {
+  if (dim.has_dim_value()) {
+    output_ << dim.dim_value();
+  } else if (dim.has_dim_param()) {
+    if (IsValidIdentifier(dim.dim_param()))
+      output_ << dim.dim_param();
+    else
+      printQuoted(dim.dim_param());
+  } else {
+    output_ << "?";
+  }
+}
+
+void ProtoPrinter::print(const TensorShapeProto& shape) {
+  printSet("[", ",", "]", shape.dim());
+}
+
+void ProtoPrinter::print(const TypeProto_Tensor& tensortype) {
+  output_ << PrimitiveTypeNameMap::ToString(tensortype.elem_type());
+  if (tensortype.has_shape()) {
+    if (tensortype.shape().dim_size() > 0) {
+      print(tensortype.shape());
+    }
+  } else {
+    output_ << "[]";
+  }
+}
+
+void ProtoPrinter::print(const TypeProto_Sequence& seqType) {
+  output_ << "seq(";
+  print(seqType.elem_type());
+  output_ << ")";
+}
+
+void ProtoPrinter::print(const TypeProto_Map& mapType) {
+  output_ << "map(" << PrimitiveTypeNameMap::ToString(mapType.key_type()) << ", ";
+  print(mapType.value_type());
+  output_ << ")";
+}
+
+void ProtoPrinter::print(const TypeProto_Optional& optType) {
+  output_ << "optional(";
+  print(optType.elem_type());
+  output_ << ")";
+}
+
+void ProtoPrinter::print(const TypeProto_SparseTensor& sparseType) {
+  output_ << "sparse_tensor(" << PrimitiveTypeNameMap::ToString(sparseType.elem_type());
+  if (sparseType.has_shape()) {
+    if (sparseType.shape().dim_size() > 0) {
+      print(sparseType.shape());
+    }
+  } else {
+    output_ << "[]";
+  }
+
+  output_ << ")";
+}
+
+void ProtoPrinter::print(const TypeProto& type) {
+  if (type.has_tensor_type())
+    print(type.tensor_type());
+  else if (type.has_sequence_type())
+    print(type.sequence_type());
+  else if (type.has_map_type())
+    print(type.map_type());
+  else if (type.has_optional_type())
+    print(type.optional_type());
+  else if (type.has_sparse_tensor_type())
+    print(type.sparse_tensor_type());
+}
+
+void ProtoPrinter::print(const TensorProto& tensor, bool is_initializer) {
+  output_ << PrimitiveTypeNameMap::ToString(tensor.data_type());
+  if (tensor.dims_size() > 0)
+    printSet("[", ",", "]", tensor.dims());
+
+  if (!tensor.name().empty()) {
+    output_ << " ";
+    printId(tensor.name());
+  }
+  if (is_initializer) {
+    output_ << " = ";
+  }
+  // TODO(ONNX): does not yet handle all types
+  if (tensor.has_data_location() && tensor.data_location() == TensorProto_DataLocation_EXTERNAL) {
+    print(tensor.external_data());
+  } else if (tensor.has_raw_data()) {
+    switch (static_cast<TensorProto::DataType>(tensor.data_type())) {
+      case TensorProto::DataType::TensorProto_DataType_INT32:
+        printSet(" {", ",", "}", ParseData<int32_t>(&tensor));
+        break;
+      case TensorProto::DataType::TensorProto_DataType_INT64:
+        printSet(" {", ",", "}", ParseData<int64_t>(&tensor));
+        break;
+      case TensorProto::DataType::TensorProto_DataType_FLOAT:
+        printSet(" {", ",", "}", ParseData<float>(&tensor));
+        break;
+      case TensorProto::DataType::TensorProto_DataType_DOUBLE:
+        printSet(" {", ",", "}", ParseData<double>(&tensor));
+        break;
+      default:
+        output_ << "..."; // ParseData not instantiated for other types.
+        break;
+    }
+  } else {
+    switch (static_cast<TensorProto::DataType>(tensor.data_type())) {
+      case TensorProto::DataType::TensorProto_DataType_INT8:
+      case TensorProto::DataType::TensorProto_DataType_INT16:
+      case TensorProto::DataType::TensorProto_DataType_INT32:
+      case TensorProto::DataType::TensorProto_DataType_UINT8:
+      case TensorProto::DataType::TensorProto_DataType_UINT16:
+      case TensorProto::DataType::TensorProto_DataType_BOOL:
+        printSet(" {", ",", "}", tensor.int32_data());
+        break;
+      case TensorProto::DataType::TensorProto_DataType_INT64:
+        printSet(" {", ",", "}", tensor.int64_data());
+        break;
+      case TensorProto::DataType::TensorProto_DataType_UINT32:
+      case TensorProto::DataType::TensorProto_DataType_UINT64:
+        printSet(" {", ",", "}", tensor.uint64_data());
+        break;
+      case TensorProto::DataType::TensorProto_DataType_FLOAT:
+        printSet(" {", ",", "}", tensor.float_data());
+        break;
+      case TensorProto::DataType::TensorProto_DataType_DOUBLE:
+        printSet(" {", ",", "}", tensor.double_data());
+        break;
+      case TensorProto::DataType::TensorProto_DataType_STRING: {
+        const char* sep = "{";
+        for (const auto& elt : tensor.string_data()) {
+          output_ << sep;
+          printQuoted(elt);
+          sep = ", ";
+        }
+        output_ << "}";
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+
+void ProtoPrinter::print(const ValueInfoProto& value_info) {
+  print(value_info.type());
+  output_ << " ";
+  printId(value_info.name());
+}
+
+void ProtoPrinter::print(const ValueInfoList& vilist) {
+  printSet("(", ", ", ")", vilist);
+}
+
+void ProtoPrinter::print(const AttributeProto& attr) {
+  // Special case of attr-ref:
+  if (attr.has_ref_attr_name()) {
+    output_ << attr.name() << ": " << AttributeTypeNameMap::ToString(attr.type()) << " = @" << attr.ref_attr_name();
+    return;
+  }
+  // General case:
+  output_ << attr.name() << ": " << AttributeTypeNameMap::ToString(attr.type()) << " = ";
+  switch (attr.type()) {
+    case AttributeProto_AttributeType_INT:
+      output_ << attr.i();
+      break;
+    case AttributeProto_AttributeType_INTS:
+      printSet("[", ", ", "]", attr.ints());
+      break;
+    case AttributeProto_AttributeType_FLOAT:
+      output_ << attr.f();
+      break;
+    case AttributeProto_AttributeType_FLOATS:
+      printSet("[", ", ", "]", attr.floats());
+      break;
+    case AttributeProto_AttributeType_STRING:
+      printQuoted(attr.s());
+      break;
+    case AttributeProto_AttributeType_STRINGS: {
+      const char* sep = "[";
+      for (const auto& elt : attr.strings()) {
+        output_ << sep;
+        printQuoted(elt);
+        sep = ", ";
+      }
+      output_ << "]";
+      break;
+    }
+    case AttributeProto_AttributeType_GRAPH:
+      indent();
+      print(attr.g());
+      outdent();
+      break;
+    case AttributeProto_AttributeType_GRAPHS:
+      indent();
+      printSet("[", ", ", "]", attr.graphs());
+      outdent();
+      break;
+    case AttributeProto_AttributeType_TENSOR:
+      print(attr.t());
+      break;
+    case AttributeProto_AttributeType_TENSORS:
+      printSet("[", ", ", "]", attr.tensors());
+      break;
+    case AttributeProto_AttributeType_TYPE_PROTO:
+      print(attr.tp());
+      break;
+    case AttributeProto_AttributeType_TYPE_PROTOS:
+      printSet("[", ", ", "]", attr.type_protos());
+      break;
+    default:
+      break;
+  }
+}
+
+void ProtoPrinter::print(const AttrList& attrlist) {
+  printSet(" <", ", ", ">", attrlist);
+}
+
+void ProtoPrinter::print(const NodeProto& node) {
+  output_ << std::setw(indent_level) << ' ';
+  if (node.has_name()) {
+    output_ << "[";
+    printId(node.name());
+    output_ << "] ";
+  }
+  printIdSet("", ", ", "", node.output());
+  output_ << " = ";
+  if (!node.domain().empty())
+    output_ << node.domain() << ".";
+  output_ << node.op_type();
+  if (!node.overload().empty())
+    output_ << ":" << node.overload();
+  bool has_subgraph = false;
+  for (const auto& attr : node.attribute())
+    if (attr.has_g() || (attr.graphs_size() > 0))
+      has_subgraph = true;
+  if ((!has_subgraph) && (node.attribute_size() > 0))
+    print(node.attribute());
+  printIdSet(" (", ", ", ")", node.input());
+  if (has_subgraph && (node.attribute_size() > 0))
+    print(node.attribute());
+  output_ << "\n";
+}
+
+void ProtoPrinter::print(const NodeList& nodelist) {
+  output_ << "{\n";
+  for (const auto& node : nodelist) {
+    print(node);
+  }
+  if (indent_level > 3)
+    output_ << std::setw(indent_level - 3) << "   ";
+  output_ << "}";
+}
+
+void ProtoPrinter::print(const GraphProto& graph) {
+  printId(graph.name());
+  output_ << " " << graph.input() << " => " << graph.output() << " ";
+  if ((graph.initializer_size() > 0) || (graph.value_info_size() > 0)) {
+    output_ << '\n' << std::setw(indent_level) << ' ' << '<';
+    const char* sep = "";
+    for (const auto& init : graph.initializer()) {
+      output_ << sep;
+      print(init, true);
+      sep = ", ";
+    }
+    for (const auto& vi : graph.value_info()) {
+      output_ << sep;
+      print(vi);
+      sep = ", ";
+    }
+    output_ << ">" << '\n';
+  }
+  print(graph.node());
+}
+
+void ProtoPrinter::print(const ModelProto& model) {
+  output_ << "<\n";
+  printKeyValuePair(KeyWordMap::KeyWord::IR_VERSION, model.ir_version(), false);
+  printKeyValuePair(KeyWordMap::KeyWord::OPSET_IMPORT, model.opset_import());
+  if (model.has_producer_name())
+    printKeyValuePair(KeyWordMap::KeyWord::PRODUCER_NAME, model.producer_name());
+  if (model.has_producer_version())
+    printKeyValuePair(KeyWordMap::KeyWord::PRODUCER_VERSION, model.producer_version());
+  if (model.has_domain())
+    printKeyValuePair(KeyWordMap::KeyWord::DOMAIN_KW, model.domain());
+  if (model.has_model_version())
+    printKeyValuePair(KeyWordMap::KeyWord::MODEL_VERSION, model.model_version());
+  if (model.has_doc_string())
+    printKeyValuePair(KeyWordMap::KeyWord::DOC_STRING, model.doc_string());
+  if (model.metadata_props_size() > 0)
+    printKeyValuePair(KeyWordMap::KeyWord::METADATA_PROPS, model.metadata_props());
+  output_ << '\n' << ">" << '\n';
+
+  print(model.graph());
+  for (const auto& fn : model.functions()) {
+    output_ << '\n';
+    print(fn);
+  }
+}
+
+void ProtoPrinter::print(const OperatorSetIdProto& opset) {
+  printQuoted(opset.domain());
+  output_ << " : " << opset.version();
+}
+
+void ProtoPrinter::print(const OpsetIdList& opsets) {
+  printSet("[", ", ", "]", opsets);
+}
+
+void ProtoPrinter::print(const FunctionProto& fn) {
+  output_ << "<\n";
+  output_ << "  "
+          << "domain: ";
+  printQuoted(fn.domain());
+  output_ << ",\n";
+  if (!fn.overload().empty()) {
+    output_ << "  "
+            << "overload: ";
+    printQuoted(fn.overload());
+    output_ << ",\n";
+  }
+
+  output_ << "  "
+          << "opset_import: ";
+  printSet("[", ",", "]", fn.opset_import());
+  output_ << "\n>\n";
+  printId(fn.name());
+  output_ << " ";
+  if (fn.attribute_size() > 0)
+    printSet("<", ",", ">", fn.attribute());
+  printIdSet("(", ", ", ")", fn.input());
+  output_ << " => ";
+  printIdSet("(", ", ", ")", fn.output());
+  output_ << "\n";
+  print(fn.node());
+}
+
+} // namespace
+
+#define DEF_OP(T)                                              \
+  std::ostream& operator<<(std::ostream& os, const T& proto) { \
+    ProtoPrinter printer(os);                                  \
+    printer.print(proto);                                      \
+    return os;                                                 \
+  }
+
+DEF_OP(TensorShapeProto_Dimension)
+
+DEF_OP(TensorShapeProto)
+
+DEF_OP(TypeProto_Tensor)
+
+DEF_OP(TypeProto)
+
+DEF_OP(TensorProto)
+
+DEF_OP(ValueInfoProto)
+
+DEF_OP(ValueInfoList)
+
+DEF_OP(AttributeProto)
+
+DEF_OP(AttrList)
+
+DEF_OP(NodeProto)
+
+DEF_OP(NodeList)
+
+DEF_OP(GraphProto)
+
+DEF_OP(FunctionProto)
+
+DEF_OP(ModelProto)
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/printer.h b/onnx/defs/printer.h
new file mode 100644
index 0000000..98d695f
--- /dev/null
+++ b/onnx/defs/printer.h
@@ -0,0 +1,50 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <iostream>
+#include <string>
+
+#include "onnx/defs/parser.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+
+std::ostream& operator<<(std::ostream& os, const TensorShapeProto_Dimension& dim);
+
+std::ostream& operator<<(std::ostream& os, const TensorShapeProto& shape);
+
+std::ostream& operator<<(std::ostream& os, const TypeProto_Tensor& tensortype);
+
+std::ostream& operator<<(std::ostream& os, const TypeProto& type);
+
+std::ostream& operator<<(std::ostream& os, const TensorProto& tensor);
+
+std::ostream& operator<<(std::ostream& os, const ValueInfoProto& value_info);
+
+std::ostream& operator<<(std::ostream& os, const ValueInfoList& vilist);
+
+std::ostream& operator<<(std::ostream& os, const AttributeProto& attr);
+
+std::ostream& operator<<(std::ostream& os, const AttrList& attrlist);
+
+std::ostream& operator<<(std::ostream& os, const NodeProto& node);
+
+std::ostream& operator<<(std::ostream& os, const NodeList& nodelist);
+
+std::ostream& operator<<(std::ostream& os, const GraphProto& graph);
+
+std::ostream& operator<<(std::ostream& os, const FunctionProto& fn);
+
+std::ostream& operator<<(std::ostream& os, const ModelProto& model);
+
+template <typename ProtoType>
+std::string ProtoToString(const ProtoType& proto) {
+  std::stringstream ss;
+  ss << proto;
+  return ss.str();
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/quantization/CMakeLists.txt b/onnx/defs/quantization/CMakeLists.txt
new file mode 100644
index 0000000..0804eec
--- /dev/null
+++ b/onnx/defs/quantization/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+)
diff --git a/onnx/defs/quantization/defs.cc b/onnx/defs/quantization/defs.cc
new file mode 100644
index 0000000..1979931
--- /dev/null
+++ b/onnx/defs/quantization/defs.cc
@@ -0,0 +1,320 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static constexpr const char* QuantizeLinear_ver25_doc = R"DOC(
+The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
+low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
+granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
+
+Saturation is done according to:
+- uint16: [0, 65535]
+- int16: [-32768, 32767]
+- uint8: [0, 255]
+- int8: [-128, 127]
+- uint4: [0, 15]
+- int4: [-8, 7]
+- uint2: [0, 3]
+- int2: [-2, 1]
+
+For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+
+`y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 and 4bit types, but the quantization
+formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+`x` and `y_scale` are allowed to have different types. The type of `y_scale` determines the precision of the division operation between `x` and
+`y_scale`, unless the `precision` attribute is specified.
+
+There are three supported quantization granularities, determined by the shape of `y_scale`.
+In all cases, `y_zero_point` must have the same shape as `y_scale`.
+- Per-tensor (per-layer) quantization: `y_scale` is a scalar.
+- Per-axis quantization: The scale must be a 1-D tensor, with the length of the quantization axis. For an input shape
+ `(D0, ..., Di, ..., Dn)` and `axis=i`, `y_scale` is a 1-D tensor of length `Di`.
+- Blocked quantization: The scale's shape is identical to the input's shape, except for one dimension, in which
+  blocking is performed. Given `x` shape `(D0, ..., Di, ..., Dn)`, `axis=i`, and block size `B`: `y_scale` shape is
+  `(D0, ..., ceil(Di/B), ..., Dn)`.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QuantizeLinear,
+    25,
+    OpSchema()
+        .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
+        .Input(
+            1,
+            "y_scale",
+            "Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for "
+            "per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the "
+            "input, except for one dimension in which blocking is performed.",
+            "T2")
+        .Input(
+            2,
+            "y_zero_point",
+            "Zero point for doing quantization to get `y`. Shape must match `y_scale`. "
+            "Default is uint8 with zero point of 0 if it's not specified.",
+            "T3",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input `x`.", "T3")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked "
+            "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, "
+            "rendering the axis unnecessary in this scenario.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 quantization "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "All cases are fully described in two tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T3`). "
+            "If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. "
+            "If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T3`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "precision",
+            "(Optional) The precision of the division operation between `x` and `y_scale`. If not provided, "
+            "it will be the same as the type of `y_scale`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Float16, types::BFloat16, types::Int32},
+            "The type of the input 'x'.")
+        .TypeConstraint(
+            "T2",
+            {types::Float, types::Float16, types::BFloat16, types::Int32, types::Float8E8M0},
+            "The type of the input 'y_scale'.")
+        .TypeConstraint(
+            "T3",
+            {types::Int8,
+             types::UInt8,
+             types::Int16,
+             types::UInt16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ,
+             types::UInt4,
+             types::Int4,
+             types::Float4E2M1,
+             types::UInt2,
+             types::Int2},
+            "The type of the input `y_zero_point` and the output `y`.")
+        .SetDoc(QuantizeLinear_ver25_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto const zp_type = ctx.hasInput(2) ? ctx.getInputType(2) : nullptr;
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (zp_type != nullptr) {
+            auto const zp_elem_type = static_cast<TensorProto_DataType>(getTensorElementType(*zp_type));
+            if (output_dtype != TensorProto::UNDEFINED && output_dtype != zp_elem_type) {
+              fail_type_inference(
+                  "output_dtype ",
+                  TensorProto_DataType_Name(output_dtype),
+                  " does not match y_zero_point type ",
+                  TensorProto_DataType_Name(zp_elem_type),
+                  ".");
+            }
+            propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          } else if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 0);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::UINT8);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DequantizeLinear,
+    25,
+    OpSchema()
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
+        .Input(
+            1,
+            "x_scale",
+            "Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for "
+            "per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as "
+            "the input, except for one dimension in which blocking is performed.",
+            "T2")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point for input `x`. Shape must match x_scale. "
+            "It's optional. Zero point is 0 when it's not specified.",
+            "T1",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "y",
+            "N-D full precision output tensor. It has the same shape as input `x`. The data type is specified "
+            "by the `output_dtype` attribute or, in its absence, the type of `x_scale`.",
+            "T3")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked "
+            "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `x_scale` data type (`T2`)",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {types::Int8,
+             types::UInt8,
+             types::Int16,
+             types::UInt16,
+             types::Int32,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ,
+             types::UInt4,
+             types::Int4,
+             types::Float4E2M1,
+             types::UInt2,
+             types::Int2},
+            "The type of the inputs 'x_zero_point' and 'x'.")
+        .TypeConstraint(
+            "T2",
+            {types::Float, types::Float16, types::BFloat16, types::Float8E8M0},
+            "The type of the input 'x_scale'.")
+        .TypeConstraint("T3", {types::Float, types::Float16, types::BFloat16}, "The type of the output 'y'.")
+        .SetDoc(kDoc_DequantizeLinear_ver24)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 0);
+          } else {
+            propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static constexpr const char* DynamicQuantizeLinear_ver11_doc = R"DOC(
+A Function to fuse calculation for Scale, Zero Point and FP32->8Bit conversion of FP32 Input data.
+Outputs Scale, ZeroPoint and Quantized Input for a given FP32 Input.
+Scale is calculated as:
+```
+y_scale = (maximum(0, max(x)) - minimum(0, min(x))) / (qmax - qmin)
+```
+
+* where qmax and qmin are max and min values for quantization range i.e. [0, 255] in case of uint8
+* data range is adjusted to include 0.
+
+Zero point is calculated as:
+```
+intermediate_zero_point = qmin - min(x)/y_scale
+y_zero_point = cast(round(saturate(intermediate_zero_point)))
+```
+
+* where qmax and qmin are max and min values for quantization range .i.e [0, 255] in case of uint8
+* for saturation, it saturates to [0, 255] if it's uint8, or [-127, 127] if it's int8. Right now only uint8 is supported.
+* rounding to nearest ties to even.
+
+Data quantization formula is:
+```
+y = saturate (round (x / y_scale) + y_zero_point)
+```
+
+* for saturation, it saturates to [0, 255] if it's uint8, or [-127, 127] if it's int8. Right now only uint8 is supported.
+* rounding to nearest ties to even.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DynamicQuantizeLinear,
+    11,
+    OpSchema()
+        .SetDoc(DynamicQuantizeLinear_ver11_doc)
+        .Input(0, "x", "Input tensor", "T1")
+        .Output(0, "y", "Quantized output tensor", "T2")
+        .Output(
+            1,
+            "y_scale",
+            "Output scale. It's a scalar, which means a per-tensor/layer quantization.",
+            "tensor(float)")
+        .Output(
+            2,
+            "y_zero_point",
+            "Output zero point. It's a scalar, which means a per-tensor/layer quantization.",
+            "T2")
+        .TypeConstraint("T1", {types::Float}, "Constrain 'x' to float tensor.")
+        .TypeConstraint("T2", {types::UInt8}, "Constrain 'y_zero_point' and 'y' to 8-bit unsigned integer tensor.")
+        .FunctionBody(R"ONNX(
+        {
+           Q_Min = Constant<value = float {0.0}>()
+           Q_Max = Constant<value = float {255.0}>()
+           X_Min = ReduceMin <keepdims = 0> (x)
+           X_Min_Adjusted = Min (X_Min, Q_Min)
+           X_Max = ReduceMax <keepdims = 0> (x)
+           X_Max_Adjusted = Max (X_Max, Q_Min)
+           X_Range = Sub (X_Max_Adjusted, X_Min_Adjusted)
+           Scale = Div (X_Range, Q_Max)
+           Min_Scaled = Div (X_Min_Adjusted, Scale)
+           Initial_ZeroPoint_FP = Sub (Q_Min, Min_Scaled)
+           Clipped_ZeroPoint_FP = Clip (Initial_ZeroPoint_FP, Q_Min, Q_Max)
+           Rounded_ZeroPoint_FP = Round (Clipped_ZeroPoint_FP)
+           Zeropoint = Cast <to = 2> (Rounded_ZeroPoint_FP)
+           y_scale = Identity (Scale)
+           y_zero_point = Identity (Zeropoint)
+           y = QuantizeLinear (x, Scale, Zeropoint)
+        }
+        )ONNX")
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          updateOutputElemType(ctx, 0, TensorProto::UINT8);
+          updateOutputElemType(ctx, 1, TensorProto::FLOAT);
+          updateOutputElemType(ctx, 2, TensorProto::UINT8);
+
+          ctx.getOutputType(1)->mutable_tensor_type()->mutable_shape();
+          ctx.getOutputType(2)->mutable_tensor_type()->mutable_shape();
+
+          if (!hasInputShape(ctx, 0))
+            return;
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/quantization/old.cc b/onnx/defs/quantization/old.cc
new file mode 100644
index 0000000..78b3775
--- /dev/null
+++ b/onnx/defs/quantization/old.cc
@@ -0,0 +1,921 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static constexpr const char* QuantizeLinear_ver24_doc = R"DOC(
+The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
+low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
+granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
+
+Saturation is done according to:
+- uint16: [0, 65535]
+- int16: [-32768, 32767]
+- uint8: [0, 255]
+- int8: [-128, 127]
+- uint4: [0, 15]
+- int4: [-8, 7]
+
+For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+
+`y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 and 4bit types, but the quantization
+formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+`x` and `y_scale` are allowed to have different types. The type of `y_scale` determines the precision of the division operation between `x` and
+`y_scale`, unless the `precision` attribute is specified.
+
+There are three supported quantization granularities, determined by the shape of `y_scale`.
+In all cases, `y_zero_point` must have the same shape as `y_scale`.
+- Per-tensor (per-layer) quantization: `y_scale` is a scalar.
+- Per-axis quantization: The scale must be a 1-D tensor, with the length of the quantization axis. For an input shape
+ `(D0, ..., Di, ..., Dn)` and `axis=i`, `y_scale` is a 1-D tensor of length `Di`.
+- Blocked quantization: The scale's shape is identical to the input's shape, except for one dimension, in which
+  blocking is performed. Given `x` shape `(D0, ..., Di, ..., Dn)`, `axis=i`, and block size `B`: `y_scale` shape is
+  `(D0, ..., ceil(Di/B), ..., Dn)`.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QuantizeLinear,
+    24,
+    OpSchema()
+        .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
+        .Input(
+            1,
+            "y_scale",
+            "Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for "
+            "per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the "
+            "input, except for one dimension in which blocking is performed.",
+            "T2")
+        .Input(
+            2,
+            "y_zero_point",
+            "Zero point for doing quantization to get `y`. Shape must match `y_scale`. "
+            "Default is uint8 with zero point of 0 if it's not specified.",
+            "T3",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input `x`.", "T3")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked "
+            "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, "
+            "rendering the axis unnecessary in this scenario.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 quantization "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "All cases are fully described in two tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T3`). "
+            "If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. "
+            "If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T3`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "precision",
+            "(Optional) The precision of the division operation between `x` and `y_scale`. If not provided, "
+            "it will be the same as the type of `y_scale`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Float16, types::BFloat16, types::Int32},
+            "The type of the input 'x'.")
+        .TypeConstraint(
+            "T2",
+            {types::Float, types::Float16, types::BFloat16, types::Int32, types::Float8E8M0},
+            "The type of the input 'y_scale'.")
+        .TypeConstraint(
+            "T3",
+            {types::Int8,
+             types::UInt8,
+             types::Int16,
+             types::UInt16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ,
+             types::UInt4,
+             types::Int4,
+             types::Float4E2M1},
+            "The type of the input `y_zero_point` and the output `y`.")
+        .SetDoc(QuantizeLinear_ver24_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto const zp_type = ctx.hasInput(2) ? ctx.getInputType(2) : nullptr;
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (zp_type != nullptr) {
+            auto const zp_elem_type = static_cast<TensorProto_DataType>(getTensorElementType(*zp_type));
+            if (output_dtype != TensorProto::UNDEFINED && output_dtype != zp_elem_type) {
+              fail_type_inference(
+                  "output_dtype ",
+                  TensorProto_DataType_Name(output_dtype),
+                  " does not match y_zero_point type ",
+                  TensorProto_DataType_Name(zp_elem_type),
+                  ".");
+            }
+            propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          } else if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 0);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::UINT8);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DequantizeLinear,
+    24,
+    OpSchema()
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
+        .Input(
+            1,
+            "x_scale",
+            "Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for "
+            "per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as "
+            "the input, except for one dimension in which blocking is performed.",
+            "T2")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point for input `x`. Shape must match x_scale. "
+            "It's optional. Zero point is 0 when it's not specified.",
+            "T1",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "y",
+            "N-D full precision output tensor. It has the same shape as input `x`. The data type is specified "
+            "by the `output_dtype` attribute or, in its absence, the type of `x_scale`.",
+            "T3")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked "
+            "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `x_scale` data type (`T2`)",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {types::Int8,
+             types::UInt8,
+             types::Int16,
+             types::UInt16,
+             types::Int32,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ,
+             types::UInt4,
+             types::Int4,
+             types::Float4E2M1},
+            "The type of the inputs 'x_zero_point' and 'x'.")
+        .TypeConstraint(
+            "T2",
+            {types::Float, types::Float16, types::BFloat16, types::Float8E8M0},
+            "The type of the input 'x_scale'.")
+        .TypeConstraint("T3", {types::Float, types::Float16, types::BFloat16}, "The type of the output 'y'.")
+        .SetDoc(kDoc_DequantizeLinear_ver24)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 0);
+          } else {
+            propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static const char* const QuantizeLinear_ver23_doc = QuantizeLinear_ver24_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QuantizeLinear,
+    23,
+    OpSchema()
+        .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
+        .Input(
+            1,
+            "y_scale",
+            "Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for "
+            "per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the "
+            "input, except for one dimension in which blocking is performed.",
+            "T2")
+        .Input(
+            2,
+            "y_zero_point",
+            "Zero point for doing quantization to get `y`. Shape must match `y_scale`."
+            "Default is uint8 with zero point of 0 if it's not specified.",
+            "T3",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input `x`.", "T3")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked "
+            "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, "
+            "rendering the axis unnecessary in this scenario.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 quantization "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "All cases are fully described in two tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T3`). "
+            "If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. "
+            "If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T3`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "precision",
+            "(Optional) The precision of the division operation between `x` and `y_scale`. If not provided, "
+            "it will be the same as the type of `y_scale`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Float16, types::BFloat16, types::Int32},
+            "The type of the input 'x'.")
+        .TypeConstraint(
+            "T2",
+            {types::Float, types::Float16, types::BFloat16, types::Int32},
+            "The type of the input 'y_scale'.")
+        .TypeConstraint(
+            "T3",
+            {types::Int8,
+             types::UInt8,
+             types::Int16,
+             types::UInt16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ,
+             types::UInt4,
+             types::Int4,
+             types::Float4E2M1},
+            "The type of the input `y_zero_point` and the output `y`.")
+        .SetDoc(QuantizeLinear_ver23_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto const zp_type = ctx.hasInput(2) ? ctx.getInputType(2) : nullptr;
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (zp_type != nullptr) {
+            auto const zp_elem_type = static_cast<TensorProto_DataType>(getTensorElementType(*zp_type));
+            if (output_dtype != TensorProto::UNDEFINED && output_dtype != zp_elem_type) {
+              fail_type_inference(
+                  "output_dtype ",
+                  TensorProto_DataType_Name(output_dtype),
+                  " does not match y_zero_point type ",
+                  TensorProto_DataType_Name(zp_elem_type),
+                  ".");
+            }
+            propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          } else if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 0);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::UINT8);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DequantizeLinear,
+    23,
+    OpSchema()
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
+        .Input(
+            1,
+            "x_scale",
+            "Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for "
+            "per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as "
+            "the input, except for one dimension in which blocking is performed.",
+            "T2")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point for input `x`. Shape must match x_scale. "
+            "It's optional. Zero point is 0 when it's not specified.",
+            "T1",
+            OpSchema::Optional)
+        .Output(
+            0,
+            "y",
+            "N-D full precision output tensor. It has the same shape as input `x`. The data type is specified "
+            "by the `output_dtype` attribute or, in its absence, the type of `x_scale`.",
+            "T3")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked "
+            "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `x_scale` data type (`T2`)",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {types::Int8,
+             types::UInt8,
+             types::Int16,
+             types::UInt16,
+             types::Int32,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ,
+             types::UInt4,
+             types::Int4,
+             types::Float4E2M1},
+            "The type of the inputs 'x_zero_point' and 'x'.")
+        .TypeConstraint("T2", {types::Float, types::Float16, types::BFloat16}, "The type of the input 'x_scale'.")
+        .TypeConstraint("T3", {types::Float, types::Float16, types::BFloat16}, "The type of the output 'y'.")
+        .SetDoc(kDoc_DequantizeLinear_ver24)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 0);
+          } else {
+            propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static constexpr const char* QuantizeLinear_ver21_doc = R"DOC(
+The linear quantization operator consumes a high-precision tensor, a scale, and a zero point to compute the
+low-precision/quantized tensor. The scale factor and zero point must have the same shape, determining the quantization
+granularity. The quantization formula is `y = saturate((x / y_scale) + y_zero_point)`.
+Saturation is done according to:
+- uint16: [0, 65535]
+- int16: [-32768, 32767]
+- uint8: [0, 255]
+- int8: [-128, 127]
+- uint4: [0, 15]
+- int4: [-8, 7]
+For `(x / y_scale)`, it rounds to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+`y_zero_point` and `y` must have the same type. `y_zero_point` is usually not used for quantization to float8 types, but the quantization
+formula remains the same for consistency, and the type of the attribute `y_zero_point` still determines the quantization type.
+There are three supported quantization granularities, determined by the shape of `y_scale`.
+In all cases, `y_zero_point` must have the same shape as `y_scale`.
+- Per-tensor (per-layer) quantization: `y_scale` is a scalar.
+- Per-axis quantization: The scale must be a 1-D tensor, with the length of the quantization axis. For an input shape
+ `(D0, ..., Di, ..., Dn)` and `axis=i`, `y_scale` is a 1-D tensor of length `Di`.
+- Blocked quantization: The scale's shape is identical to the input's shape, except for one dimension, in which
+  blocking is performed. Given `x` shape `(D0, ..., Di, ..., Dn)`, `axis=i`, and block size `B`: `y_scale` shape is
+  `(D0, ..., ceil(Di/B), ..., Dn)`.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QuantizeLinear,
+    21,
+    OpSchema()
+        .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
+        .Input(
+            1,
+            "y_scale",
+            "Scale for doing quantization to get `y`. For per-tensor/layer quantization the scale is a scalar, for "
+            "per-axis quantization it is a 1-D Tensor and for blocked quantization it has the same shape as the "
+            "input, except for one dimension in which blocking is performed.",
+            "T1")
+        .Input(
+            2,
+            "y_zero_point",
+            "Zero point for doing quantization to get `y`. Shape must match `y_scale`."
+            "Default is uint8 with zero point of 0 if it's not specified.",
+            "T2",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input `x`.", "T2")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis and blocked "
+            "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, "
+            "rendering the axis unnecessary in this scenario.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 quantization "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "All cases are fully described in two tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "output_dtype",
+            "(Optional) The output data type. If not supplied, the output data type is inferred from `y_zero_point` data type (`T2`). "
+            "If neither `output_dtype` nor `y_zero_point` are supplied, output data type is uint8. "
+            "If both `output_dtype` and `y_zero_point` are specified, `output_dtype` must be `T2`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Float16, types::BFloat16, types::Int32},
+            "The type of the input 'x'.")
+        .TypeConstraint(
+            "T2",
+            {types::Int8,
+             types::UInt8,
+             types::Int16,
+             types::UInt16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ,
+             types::UInt4,
+             types::Int4},
+            "The type of the input `y_zero_point` and the output `y`.")
+        .SetDoc(QuantizeLinear_ver21_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto const zp_type = ctx.hasInput(2) ? ctx.getInputType(2) : nullptr;
+          auto const output_dtype =
+              static_cast<TensorProto_DataType>(getAttribute(ctx, "output_dtype", TensorProto::UNDEFINED));
+          if (zp_type != nullptr) {
+            auto const zp_elem_type = static_cast<TensorProto_DataType>(getTensorElementType(*zp_type));
+            if (output_dtype != TensorProto::UNDEFINED && output_dtype != zp_elem_type) {
+              fail_type_inference(
+                  "output_dtype ",
+                  TensorProto_DataType_Name(output_dtype),
+                  " does not match y_zero_point type ",
+                  TensorProto_DataType_Name(zp_elem_type),
+                  ".");
+            }
+            propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          } else if (output_dtype != TensorProto::UNDEFINED) {
+            propagateElemTypeFromAttributeToOutput(ctx, "output_dtype", 0);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::UINT8);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static constexpr const char* DequantizeLinear_ver21_doc = R"DOC(
+The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the
+full-precision tensor. The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point`
+must have the same shape, determining the quantization's granularity: a scalar for per-tensor/per-layer quantization,
+a 1-D tensor for per-axis quantization, or have a rank identical to the input for blocked quantization.
+See QuantizeLinear for details on quantization granularity.
+`x_zero_point` and `x` must have the same type. `x` and `y` must have the same shape. In the case of dequantizing
+`int32`, there's no zero point (zero point is supposed to be 0).
+`zero-point` is usually not used in the case of float8 types quantization, but the dequantization formula remains the same
+for consistency, and `x_scale` still determines the output type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DequantizeLinear,
+    21,
+    OpSchema()
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
+        .Input(
+            1,
+            "x_scale",
+            "Scale for input `x`. For per-tensor/layer dequantization the scale is a scalar, for "
+            "per per-axis dequantization it is a 1-D Tensor and for blocked dequantization it has the same shape as "
+            "the input, except for one dimension in which blocking is performed.",
+            "T2")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point for input `x`. Shape must match x_scale. "
+            "It's optional. Zero point is 0 when it's not specified.",
+            "T1",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D full precision output tensor. It has same shape as input `x`.", "T2")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used for per-axis and blocked "
+            "quantization. Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "block_size",
+            "(Optional) The size of the quantization block (number of times every scale is replicated). Used only for "
+            "blocked quantization. The block size is a positive integer. Given `x` shape `(D0, ..., Di, ..., Dn)`, "
+            "`y_scale` shape `(S0, ... Si, ...Sn)` and `axis=i`, the accepted range is "
+            "`[ceil(Di/Si), ceil(Di/(Si-1))-1]`",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .TypeConstraint(
+            "T1",
+            {types::Int8,
+             types::UInt8,
+             types::Int16,
+             types::UInt16,
+             types::Int32,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ,
+             types::UInt4,
+             types::Int4},
+            "The type of the inputs 'x_zero_point' and 'x'.")
+        .TypeConstraint("T2", {types::Float, types::Float16, types::BFloat16}, "'x_scale' determines the output type.")
+        .SetDoc(DequantizeLinear_ver21_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static constexpr const char* QuantizeLinear_ver19_doc = R"DOC(
+The linear quantization operator. It consumes a high precision tensor, a scale, and a zero point to compute the low precision / quantized tensor.
+The scale factor and zero point must have same shape, and can be either a scalar for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+The quantization formula is `y = saturate ((x / y_scale) + y_zero_point)`.
+For saturation, it saturates to [0, 255] if it's uint8, or [-128, 127] if it's int8.
+For (x / y_scale), it's rounding to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details.
+'y_zero_point' and 'y' must have same type.
+'y_zero_point' is usually not used for quantization to float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz,
+but the quantization formula remains the same for consistency and
+the type of the attribute 'y_zero_point' still determines the quantization type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QuantizeLinear,
+    19,
+    OpSchema()
+        .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
+        .Input(
+            1,
+            "y_scale",
+            "Scale for doing quantization to get 'y'. It can be a scalar, which means per-tensor/layer quantization, "
+            "or a 1-D Tensor for per-axis quantization.",
+            "T1")
+        .Input(
+            2,
+            "y_zero_point",
+            "Zero point for doing quantization to get 'y'. Shape must match y_scale. "
+            "Default is uint8 with zero point of 0 if it's not specified.",
+            "T2",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input 'x'.", "T2")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the quantization dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 quantization "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "All cases are fully described in two tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Float16, types::BFloat16, types::Int32},
+            "Constrain 'x' to float, float16, bfloat16 or int32 tensor.")
+        .TypeConstraint(
+            "T2",
+            {types::Int8,
+             types::UInt8,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "Constrain 'y_zero_point' and 'y' to 8-bit integer/float tensor.")
+        .SetDoc(QuantizeLinear_ver19_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          if (ctx.hasInput(2)) {
+            propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::UINT8);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static constexpr const char* DequantizeLinear_ver19_doc = R"DOC(
+The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the full precision tensor.
+The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point` must have same shape, and can be either a scalar
+for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+`x_zero_point` and `x` must have same type. `x` and `y` must have same shape. In the case of dequantizing int32,
+there's no zero point (zero point is supposed to be 0).
+`zero-point` is usually not used in the case of float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz quantization,
+but the dequantization formula remains the same for consistency and 'x_scale' still determines the output type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DequantizeLinear,
+    19,
+    OpSchema()
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T1")
+        .Input(
+            1,
+            "x_scale",
+            "Scale for input 'x'. It can be a scalar, which means a per-tensor/layer dequantization, "
+            "or a 1-D tensor for per-axis dequantization.",
+            "T2")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point for input 'x'. Shape must match x_scale. "
+            "It's optional. Zero point is 0 when it's not specified.",
+            "T1",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D full precision output tensor. It has same shape as input 'x'.", "T2")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Used only for per-axis quantization. "
+            "Negative value means counting dimensions from the back. Accepted range is `[-r, r-1]` "
+            "where `r = rank(input)`. When the rank of the input is 1, per-tensor quantization is applied, "
+            "rendering the axis unnecessary in this scenario.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeConstraint(
+            "T1",
+            {types::Int8,
+             types::UInt8,
+             types::Int32,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "Constrain 'x_zero_point' and 'x' to 8-bit integer or float, or /32-bit integer tensor.")
+        .TypeConstraint("T2", {types::Float, types::Float16, types::BFloat16}, "'x_scale' determines the output type.")
+        .SetDoc(DequantizeLinear_ver19_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static constexpr const char* QuantizeLinear_ver13_doc = R"DOC(
+The linear quantization operator. It consumes a high precision tensor, a scale, and a zero point to compute the low precision / quantized tensor.
+The scale factor and zero point must have same shape, and can be either a scalar for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+The quantization formula is y = saturate ((x / y_scale) + y_zero_point).
+For saturation, it saturates to [0, 255] if it's uint8, or [-128, 127] if it's int8.
+For (x / y_scale), it's rounding to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details. 'y_zero_point' and 'y' must have same type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QuantizeLinear,
+    13,
+    OpSchema()
+        .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
+        .Input(
+            1,
+            "y_scale",
+            "Scale for doing quantization to get 'y'. It can be a scalar, which means per-tensor/layer quantization, "
+            "or a 1-D Tensor for per-axis quantization.",
+            "tensor(float)")
+        .Input(
+            2,
+            "y_zero_point",
+            "Zero point for doing quantization to get 'y'. Shape must match y_scale. "
+            "Default is uint8 with zero point of 0 if it's not specified.",
+            "T2",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input 'x'.", "T2")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the quantization dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeConstraint("T1", {types::Float, types::Int32}, "Constrain 'x' to float or int32 tensor.")
+        .TypeConstraint("T2", {types::Int8, types::UInt8}, "Constrain 'y_zero_point' and 'y' to 8-bit integer tensor.")
+        .SetDoc(QuantizeLinear_ver13_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          if (ctx.hasInput(2)) {
+            propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::UINT8);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static constexpr const char* DequantizeLinear_ver13_doc = R"DOC(
+The linear dequantization operator. It consumes a quantized tensor, a scale, and a zero point to compute the full precision tensor.
+The dequantization formula is `y = (x - x_zero_point) * x_scale`. `x_scale` and `x_zero_point` must have same shape, and can be either a scalar
+for per-tensor / per layer quantization, or a 1-D tensor for per-axis quantization.
+`x_zero_point` and `x` must have same type. `x` and `y` must have same shape. In the case of dequantizing int32,
+there's no zero point (zero point is supposed to be 0).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DequantizeLinear,
+    13,
+    OpSchema()
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T")
+        .Input(
+            1,
+            "x_scale",
+            "Scale for input 'x'. It can be a scalar, which means a per-tensor/layer dequantization, "
+            "or a 1-D tensor for per-axis dequantization.",
+            "tensor(float)")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point for input 'x'. Shape must match x_scale. "
+            "It's optional. Zero point is 0 when it's not specified.",
+            "T",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D full precision output tensor. It has same shape as input 'x'.", "tensor(float)")
+        .Attr(
+            "axis",
+            "(Optional) The axis of the dequantizing dimension of the input tensor. Ignored for per-tensor quantization. Negative value means counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeConstraint(
+            "T",
+            {types::Int8, types::UInt8, types::Int32},
+            "Constrain 'x_zero_point' and 'x' to 8-bit/32-bit integer tensor.")
+        .SetDoc(DequantizeLinear_ver13_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto y_type = ctx.getOutputType(0);
+          // only float is supported
+          y_type->mutable_tensor_type()->set_elem_type(ONNX_NAMESPACE::TensorProto::FLOAT);
+
+          if (!hasInputShape(ctx, 0))
+            return;
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static constexpr const char* QuantizeLinear_ver10_doc = R"DOC(
+The linear per-tensor/layer quantization operator. It consumes a high precision tensor, a scale, a zero point to compute the low precision / quantized tensor.
+The quantization formula is y = saturate ((x / y_scale) + y_zero_point). For saturation, it saturates to [0, 255] if it's uint8, or [-128, 127] if it's int8.
+For (x / y_scale), it's rounding to the nearest even. Refer to https://en.wikipedia.org/wiki/Rounding for details. 'y_zero_point' and 'y' must have same type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    QuantizeLinear,
+    10,
+    OpSchema()
+        .Input(0, "x", "N-D full precision Input tensor to be quantized.", "T1")
+        .Input(
+            1,
+            "y_scale",
+            "Scale for doing quantization to get 'y'. It's a scalar, which means a per-tensor/layer quantization.",
+            "tensor(float)")
+        .Input(
+            2,
+            "y_zero_point",
+            "Zero point for doing quantization to get 'y'. It's a scalar, which means a per-tensor/layer quantization. "
+            "Default value is uint8 typed 0 if it's not specified.",
+            "T2",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D quantized output tensor. It has same shape as input 'x'.", "T2")
+        .TypeConstraint("T1", {types::Float, types::Int32}, "Constrain 'x' to float or int32 tensor.")
+        .TypeConstraint("T2", {types::Int8, types::UInt8}, "Constrain 'y_zero_point' and 'y' to 8-bit integer tensor.")
+        .SetDoc(QuantizeLinear_ver10_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          if (ctx.hasInput(2)) {
+            propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::UINT8);
+          }
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+static constexpr const char* DequantizeLinear_ver10_doc = R"DOC(
+The linear dequantization operator. It consumes a quantized tensor, a scale, a zero point to compute the full precision tensor.
+The dequantization formula is y = (x - x_zero_point) * x_scale. 'x_scale' and 'x_zero_point' are both scalars.
+'x_zero_point' and 'x' must have same type. 'x' and 'y' must have same shape. In the case of dequantizing int32,
+there's no zero point (zero point is supposed to be 0).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DequantizeLinear,
+    10,
+    OpSchema()
+        .Input(0, "x", "N-D quantized input tensor to be de-quantized.", "T")
+        .Input(
+            1,
+            "x_scale",
+            "Scale for input 'x'. It's a scalar, which means a per-tensor/layer quantization.",
+            "tensor(float)")
+        .Input(
+            2,
+            "x_zero_point",
+            "Zero point for input 'x'. It's a scalar, which means a per-tensor/layer quantization. "
+            "It's optional. 0 is the default value when it's not specified.",
+            "T",
+            OpSchema::Optional)
+        .Output(0, "y", "N-D full precision output tensor. It has same shape as input 'x'.", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {types::Int8, types::UInt8, types::Int32},
+            "Constrain 'x_zero_point' and 'x' to 8-bit/32-bit integer tensor.")
+        .SetDoc(DequantizeLinear_ver10_doc)
+        .TypeAndShapeInferenceFunction([](ONNX_NAMESPACE::InferenceContext& ctx) {
+          auto y_type = ctx.getOutputType(0);
+          // only float is supported
+          y_type->mutable_tensor_type()->set_elem_type(ONNX_NAMESPACE::TensorProto::FLOAT);
+
+          if (!hasInputShape(ctx, 0))
+            return;
+
+          auto& input_shape = getInputShape(ctx, 0);
+          updateOutputShape(ctx, 0, input_shape);
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/reduction/CMakeLists.txt b/onnx/defs/reduction/CMakeLists.txt
new file mode 100644
index 0000000..0011f05
--- /dev/null
+++ b/onnx/defs/reduction/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+    utils.cc
+    utils.h
+)
diff --git a/onnx/defs/reduction/defs.cc b/onnx/defs/reduction/defs.cc
new file mode 100644
index 0000000..9597e3a
--- /dev/null
+++ b/onnx/defs/reduction/defs.cc
@@ -0,0 +1,183 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <functional>
+#include <string>
+
+#include "onnx/defs/reduction/utils.h"
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ReduceMax,
+    20,
+    OpSchema().FillUsing(ReduceOpGenerator("max", EMPTY_MIN, true, true, nullptr, nullptr, true)));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ReduceMin,
+    20,
+    OpSchema().FillUsing(ReduceOpGenerator("min", EMPTY_MAX, true, true, nullptr, nullptr, true)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceSum, 13, OpSchema().FillUsing(ReduceOpDynamicAxes("sum", EMPTY_ZERO)));
+
+static constexpr const char* reduce_sum_square_func_body = R"ONNX(
+  {
+    data_square = Mul(data, data)
+    reduced = ReduceSum<keepdims: int = @keepdims, noop_with_empty_axes: int = @noop_with_empty_axes>(data_square, axes)
+  }
+  )ONNX";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ReduceSumSquare,
+    18,
+    OpSchema().FillUsing(ReduceFunctionOp("sum square", EMPTY_ZERO, reduce_sum_square_func_body)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMean, 18, OpSchema().FillUsing(ReduceOpDynamicAxes("mean", EMPTY_UNDEFINED)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceProd, 18, OpSchema().FillUsing(ReduceOpDynamicAxes("product", EMPTY_ONE)));
+
+static constexpr const char* reduce_log_sum_func_body = R"ONNX(
+  {
+    reduced_sum = ReduceSum<keepdims: int = @keepdims, noop_with_empty_axes: int = @noop_with_empty_axes>(data, axes)
+    reduced = Log (reduced_sum)
+  }
+  )ONNX";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ReduceLogSum,
+    18,
+    OpSchema().FillUsing(ReduceFunctionOp("log sum", EMPTY_MINUS_INF, reduce_log_sum_func_body)));
+
+static constexpr const char* reduce_log_sum_exp_func_body = R"ONNX(
+  {
+    data_double = Cast<to = 11>(data)
+    data_exp = Exp (data_double)
+    reduced_sum = ReduceSum<keepdims: int = @keepdims, noop_with_empty_axes: int = @noop_with_empty_axes>(data_exp, axes)
+    reduced_double = Log (reduced_sum)
+    reduced = CastLike(reduced_double, data)
+  }
+  )ONNX";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ReduceLogSumExp,
+    18,
+    OpSchema().FillUsing(ReduceFunctionOp("log sum exponent", EMPTY_MINUS_INF, reduce_log_sum_exp_func_body)));
+
+static constexpr const char* reduce_l1_func_body = R"ONNX(
+  {
+    data_abs = Abs(data)
+    reduced = ReduceSum<keepdims: int = @keepdims, noop_with_empty_axes: int = @noop_with_empty_axes>(data_abs, axes)
+  }
+  )ONNX";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ReduceL1,
+    18,
+    OpSchema().FillUsing(ReduceFunctionOp("L1 norm", EMPTY_ZERO, reduce_l1_func_body)));
+
+static constexpr const char* reduce_l2_func_body = R"ONNX(
+  {
+    data_square = Mul(data, data)
+    sum_square = ReduceSum<keepdims: int = @keepdims, noop_with_empty_axes: int = @noop_with_empty_axes>(data_square, axes)
+    sum_square_dbl = Cast <to = 1>(sum_square)
+    sqrt = Sqrt(sum_square_dbl)
+    reduced = CastLike(sqrt, data)
+  }
+  )ONNX";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ReduceL2,
+    18,
+    OpSchema().FillUsing(ReduceFunctionOp("L2 norm", EMPTY_ZERO, reduce_l2_func_body)));
+
+static std::function<void(OpSchema&)> ArgReduceDocGenerator(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Computes the indices of the {name} elements of the input tensor's element along the
+provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+If keepdims equals 0, then the resulting tensor has the reduced dimension pruned.
+If select_last_index is True (default False), the index of the last occurrence of the {name}
+is selected if the {name} appears more than once in the input. Otherwise the index of the
+first occurrence is selected.
+The type of the output tensor is integer.)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc.c_str());
+    schema.Attr(
+        "axis",
+        "The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Attr(
+        "keepdims",
+        "Keep the reduced dimension or not, default 1 means keep reduced dimension.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Attr(
+        "select_last_index",
+        "Whether to select the last index or the first index if the {name} appears in multiple indices, default is False (first index).",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable);
+    schema.Output(
+        0,
+        "reduced",
+        "Reduced output tensor with integer data type.",
+        "tensor(int64)",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.TypeConstraint(
+        "T", OpSchema::all_numeric_types_ir4(), "Constrain input and output types to all numeric tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      // set output element type to int64
+      updateOutputElemType(ctx, 0, TensorProto_DataType_INT64);
+
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+
+      const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+      int64_t input_ndim = input_shape.dim_size();
+      int64_t axis = 0; // default to 0
+      const auto* const axis_proto = ctx.getAttribute("axis");
+      if (axis_proto) {
+        axis = axis_proto->i();
+        if (axis < -input_ndim || axis >= input_ndim) {
+          fail_shape_inference("'axis' must be in [-rank(indices), rank(indices)-1]");
+        }
+        if (axis < 0)
+          axis += input_ndim;
+      }
+
+      int64_t keep_dims = 1;
+      const auto* const attr_proto = ctx.getAttribute("keepdims");
+      if (attr_proto) {
+        keep_dims = attr_proto->i();
+      }
+      // do we need handle negative axis?
+      for (int i = 0; i < input_ndim; ++i) {
+        if (i != axis) {
+          auto* dim = output_shape->add_dim();
+          dim->CopyFrom(input_shape.dim(i));
+        } else {
+          if (keep_dims == 1) {
+            auto* dim = output_shape->add_dim();
+            dim->set_dim_value(1);
+          }
+        }
+      }
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(ArgMax, 13, OpSchema().FillUsing(ArgReduceDocGenerator("max")));
+
+ONNX_OPERATOR_SET_SCHEMA(ArgMin, 13, OpSchema().FillUsing(ArgReduceDocGenerator("min")));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/reduction/old.cc b/onnx/defs/reduction/old.cc
new file mode 100644
index 0000000..a011810
--- /dev/null
+++ b/onnx/defs/reduction/old.cc
@@ -0,0 +1,455 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "onnx/defs/reduction/utils.h"
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+
+static std::vector<std::string> GetSupportedDataTypesForReductionOps_opset12(bool supports8bit) {
+  if (supports8bit) {
+    auto data_types = OpSchema::numeric_types_for_math_reduction();
+    data_types.emplace_back("tensor(uint8)");
+    data_types.emplace_back("tensor(int8)");
+
+    return data_types;
+  }
+
+  return OpSchema::numeric_types_for_math_reduction();
+}
+
+static std::function<void(OpSchema&)> ReduceDocGenerator_opset12(
+    const char* name,
+    bool supports_8bit_datatypes = false) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Computes the {name} of the input tensor's element along the provided axes. The resulting
+tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+the resulted tensor have the reduced dimension pruned.
+
+The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+False instead of True.)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc.c_str());
+    schema.Attr(
+        "axes",
+        "A list of integers, along which to reduce. The default is to reduce over "
+        "all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "keepdims",
+        "Keep the reduced dimension or not, default 1 means keep reduced dimension.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Input(0, "data", "An input tensor.", "T");
+    schema.Output(0, "reduced", "Reduced output tensor.", "T");
+    schema.TypeConstraint(
+        "T",
+        GetSupportedDataTypesForReductionOps_opset12(supports_8bit_datatypes),
+        supports_8bit_datatypes ? "Constrain input and output types to high-precision and 8 bit numeric tensors."
+                                : "Constrain input and output types to high-precision numeric tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+
+      int64_t keep_dims = 1;
+      const auto* const attr_proto = ctx.getAttribute("keepdims");
+      if (attr_proto) {
+        keep_dims = attr_proto->i();
+      }
+      const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      int64_t input_ndim = input_shape.dim_size();
+      auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+      std::vector<int64_t> axes;
+      const auto* const axes_proto = ctx.getAttribute("axes");
+      if (axes_proto)
+        axes.assign(axes_proto->ints().begin(), axes_proto->ints().end());
+
+      for (int64_t& axe : axes) {
+        if (axe < -input_ndim || axe >= input_ndim) {
+          fail_shape_inference("axis must be in [-rank, rank-1]. input rank was ", input_ndim);
+        }
+        if (axe < 0)
+          axe += input_ndim;
+      }
+      // do we need handle negative axis?
+      for (int i = 0; i < input_ndim; ++i) {
+        // axes empty means reduce all dim
+        if (!axes.empty() && std::find(axes.begin(), axes.end(), i) == axes.end()) {
+          auto* dim = output_shape->add_dim();
+          dim->CopyFrom(input_shape.dim(i));
+        } else {
+          if (keep_dims == 1) {
+            auto* dim = output_shape->add_dim();
+            dim->set_dim_value(1);
+          }
+        }
+      }
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMax, 12, OpSchema().FillUsing(ReduceDocGenerator_opset12("max", true)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMin, 12, OpSchema().FillUsing(ReduceDocGenerator_opset12("min", true)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceSum, 11, OpSchema().FillUsing(ReduceDocGenerator_opset12("sum")));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceSumSquare, 11, OpSchema().FillUsing(ReduceDocGenerator_opset12("sum square")));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMean, 11, OpSchema().FillUsing(ReduceDocGenerator_opset12("mean")));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceProd, 11, OpSchema().FillUsing(ReduceDocGenerator_opset12("product")));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceLogSum, 11, OpSchema().FillUsing(ReduceDocGenerator_opset12("log sum")));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceLogSumExp, 11, OpSchema().FillUsing(ReduceDocGenerator_opset12("log sum exponent")));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceL1, 11, OpSchema().FillUsing(ReduceDocGenerator_opset12("L1 norm")));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceL2, 11, OpSchema().FillUsing(ReduceDocGenerator_opset12("L2 norm")));
+
+static std::function<void(OpSchema&)> ArgReduceDocGenerator_opset12(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Computes the indices of the {name} elements of the input tensor's element along the
+provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+If keepdims equal 0, then the resulting tensor has the reduced dimension pruned.
+If select_last_index is True (default False), the index of the last occurrence of the {name}
+is selected if the {name} appears more than once in the input. Otherwise the index of the
+first occurrence is selected.
+The type of the output tensor is integer.)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc.c_str());
+    schema.Attr(
+        "axis",
+        "The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Attr(
+        "keepdims",
+        "Keep the reduced dimension or not, default 1 means keep reduced dimension.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Attr(
+        "select_last_index",
+        "Whether to select the last index or the first index if the {name} appears in multiple indices, default is False (first index).",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Input(0, "data", "An input tensor.", "T");
+    schema.Output(0, "reduced", "Reduced output tensor with integer data type.", "tensor(int64)");
+    schema.TypeConstraint(
+        "T", OpSchema::all_numeric_types(), "Constrain input and output types to all numeric tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      // set output element type to int64
+      updateOutputElemType(ctx, 0, TensorProto_DataType_INT64);
+
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+
+      const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+      int64_t input_ndim = input_shape.dim_size();
+      int64_t axis = 0; // default to 0
+      const auto* const axis_proto = ctx.getAttribute("axis");
+      if (axis_proto) {
+        axis = axis_proto->i();
+        if (axis < -input_ndim || axis >= input_ndim) {
+          fail_shape_inference("'axis' must be in [-rank(indices), rank(indices)-1]");
+        }
+        if (axis < 0)
+          axis += input_ndim;
+      }
+
+      int64_t keep_dims = 1;
+      const auto* const attr_proto = ctx.getAttribute("keepdims");
+      if (attr_proto) {
+        keep_dims = attr_proto->i();
+      }
+      // do we need handle negative axis?
+      for (int i = 0; i < input_ndim; ++i) {
+        if (i != axis) {
+          auto* dim = output_shape->add_dim();
+          dim->CopyFrom(input_shape.dim(i));
+        } else {
+          if (keep_dims == 1) {
+            auto* dim = output_shape->add_dim();
+            dim->set_dim_value(1);
+          }
+        }
+      }
+    });
+  };
+} // namespace ONNX_NAMESPACE
+
+ONNX_OPERATOR_SET_SCHEMA(ArgMax, 12, OpSchema().FillUsing(ArgReduceDocGenerator_opset12("max")));
+
+ONNX_OPERATOR_SET_SCHEMA(ArgMin, 12, OpSchema().FillUsing(ArgReduceDocGenerator_opset12("min")));
+
+static std::function<void(OpSchema&)>
+ReduceDocGenerator_opset1(const char* name, const char* empty_value, int opset = 1) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Computes the {name} of the input tensor's element along the provided axes. The resulting
+tensor has the same rank as the input if keepdims equals 1. If keepdims equal 0, then
+the resulted tensor have the reduced dimension pruned. Input tensors of rank zero are
+valid. Reduction over an empty set of values yields {empty_value}.
+
+The above behavior is similar to numpy, with the exception that numpy defaults keepdims to
+False instead of True.)DOC";
+        ReplaceAll(doc, "{name}", name););
+    ReplaceAll(doc, "{empty_value}", empty_value);
+    schema.SetDoc(doc.c_str());
+    schema.Attr(
+        "axes",
+        opset >= 11 ? "A list of integers, along which to reduce. The default is to reduce over "
+                      "all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data)."
+                    : "A list of integers, along which to reduce. The default is to reduce over "
+                      "all the dimensions of the input tensor.",
+        AttributeProto::INTS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "keepdims",
+        "Keep the reduced dimension or not, default 1 means keep reduced dimension.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Input(0, "data", "An input tensor.", "T");
+    schema.Output(0, "reduced", "Reduced output tensor.", "T");
+    schema.TypeConstraint(
+        "T",
+        OpSchema::numeric_types_for_math_reduction(),
+        "Constrain input and output types to high-precision numeric tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+
+      int64_t keep_dims = 1;
+      const auto* const attr_proto = ctx.getAttribute("keepdims");
+      if (attr_proto) {
+        keep_dims = attr_proto->i();
+      }
+      const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      int64_t input_ndim = input_shape.dim_size();
+      auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+      std::vector<int64_t> axes;
+      const auto* const axes_proto = ctx.getAttribute("axes");
+      if (axes_proto)
+        axes.assign(axes_proto->ints().begin(), axes_proto->ints().end());
+
+      for (int64_t& axe : axes) {
+        if (axe < 0)
+          axe += input_ndim;
+      }
+      // do we need handle negative axis?
+      for (int i = 0; i < input_ndim; ++i) {
+        // axes empty means reduce all dim
+        if (!axes.empty() && std::find(axes.begin(), axes.end(), i) == axes.end()) {
+          auto* dim = output_shape->add_dim();
+          dim->CopyFrom(input_shape.dim(i));
+        } else {
+          if (keep_dims == 1) {
+            auto* dim = output_shape->add_dim();
+            dim->set_dim_value(1);
+          }
+        }
+      }
+    });
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMax, 1, OpSchema().FillUsing(ReduceDocGenerator_opset1("max", EMPTY_MIN)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMin, 1, OpSchema().FillUsing(ReduceDocGenerator_opset1("min", EMPTY_MAX)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceSum, 1, OpSchema().FillUsing(ReduceDocGenerator_opset1("sum", EMPTY_ZERO)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceSumSquare, 1, OpSchema().FillUsing(ReduceDocGenerator_opset1("sum square", EMPTY_ZERO)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMean, 1, OpSchema().FillUsing(ReduceDocGenerator_opset1("mean", EMPTY_UNDEFINED)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceProd, 1, OpSchema().FillUsing(ReduceDocGenerator_opset1("product", EMPTY_ONE)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceLogSum, 1, OpSchema().FillUsing(ReduceDocGenerator_opset1("log sum", EMPTY_MINUS_INF)));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ReduceLogSumExp,
+    1,
+    OpSchema().FillUsing(ReduceDocGenerator_opset1("log sum exponent", EMPTY_MINUS_INF)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceL1, 1, OpSchema().FillUsing(ReduceDocGenerator_opset1("L1 norm", EMPTY_ZERO)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceL2, 1, OpSchema().FillUsing(ReduceDocGenerator_opset1("L2 norm", EMPTY_ZERO)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMax, 11, OpSchema().FillUsing(ReduceDocGenerator_opset1("max", EMPTY_MIN, 11)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMin, 11, OpSchema().FillUsing(ReduceDocGenerator_opset1("min", EMPTY_MAX, 11)));
+
+static std::function<void(OpSchema&)> ArgReduceDocGenerator_opset1(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Computes the indices of the {name} elements of the input tensor's element along the
+provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+If keepdims equal 0, then the resulted tensor have the reduced dimension pruned.
+The type of the output tensor is integer.)DOC";
+        ReplaceAll(doc, "{name}", name););
+    schema.SetDoc(doc.c_str());
+    schema.Attr("axis", "The axis in which to compute the arg indices.", AttributeProto::INT, static_cast<int64_t>(0));
+    schema.Attr(
+        "keepdims",
+        "Keep the reduced dimension or not, default 1 means keep reduced dimension.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Input(0, "data", "An input tensor.", "T");
+    schema.Output(0, "reduced", "Reduced output tensor with integer data type.", "tensor(int64)");
+    schema.TypeConstraint(
+        "T", OpSchema::all_numeric_types(), "Constrain input and output types to all numeric tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      // set output element type to int64
+      updateOutputElemType(ctx, 0, TensorProto_DataType_INT64);
+
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+
+      const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+      int64_t input_ndim = input_shape.dim_size();
+      int64_t axis = 0; // default to 0
+      const auto* const axis_proto = ctx.getAttribute("axis");
+      if (axis_proto) {
+        axis = axis_proto->i();
+        if (axis < 0)
+          axis += input_ndim;
+      }
+
+      int64_t keep_dims = 1;
+      const auto* const attr_proto = ctx.getAttribute("keepdims");
+      if (attr_proto) {
+        keep_dims = attr_proto->i();
+      }
+      // do we need handle negative axis?
+      for (int i = 0; i < input_ndim; ++i) {
+        if (i != axis) {
+          auto* dim = output_shape->add_dim();
+          dim->CopyFrom(input_shape.dim(i));
+        } else {
+          if (keep_dims == 1) {
+            auto* dim = output_shape->add_dim();
+            dim->set_dim_value(1);
+          }
+        }
+      }
+    });
+  };
+} // namespace ONNX_NAMESPACE
+
+ONNX_OPERATOR_SET_SCHEMA(ArgMax, 1, OpSchema().FillUsing(ArgReduceDocGenerator_opset1("max")));
+
+ONNX_OPERATOR_SET_SCHEMA(ArgMin, 1, OpSchema().FillUsing(ArgReduceDocGenerator_opset1("min")));
+
+static std::function<void(OpSchema&)> ArgReduceDocGenerator_opset11(const char* name) {
+  return [=](OpSchema& schema) {
+    std::string doc = R"DOC(
+Computes the indices of the {name} elements of the input tensor's element along the
+provided axis. The resulting tensor has the same rank as the input if keepdims equals 1.
+If keepdims equal 0, then the resulting tensor has the reduced dimension pruned.
+The input tensor must not be empty.
+The type of the output tensor is integer.)DOC";
+    ReplaceAll(doc, "{name}", name);
+    schema.SetDoc(doc.c_str());
+    schema.Attr(
+        "axis",
+        "The axis in which to compute the arg indices. Accepted range is [-r, r-1] where r = rank(data).",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Attr(
+        "keepdims",
+        "Keep the reduced dimension or not, default 1 means keep reduced dimension.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Input(0, "data", "An input tensor.", "T");
+    schema.Output(0, "reduced", "Reduced output tensor with integer data type.", "tensor(int64)");
+    schema.TypeConstraint(
+        "T", OpSchema::all_numeric_types(), "Constrain input and output types to all numeric tensors.");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      // set output element type to int64
+      updateOutputElemType(ctx, 0, TensorProto_DataType_INT64);
+
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+
+      const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+      int64_t input_ndim = input_shape.dim_size();
+      int64_t axis = 0; // default to 0
+      const auto* const axis_proto = ctx.getAttribute("axis");
+      if (axis_proto) {
+        axis = axis_proto->i();
+        if (axis < -input_ndim || axis >= input_ndim) {
+          fail_shape_inference("'axis' must be in [-rank(indices), rank(indices)-1]");
+        }
+        if (axis < 0)
+          axis += input_ndim;
+      }
+
+      int64_t keep_dims = 1;
+      const auto* const attr_proto = ctx.getAttribute("keepdims");
+      if (attr_proto) {
+        keep_dims = attr_proto->i();
+      }
+      // do we need handle negative axis?
+      for (int i = 0; i < input_ndim; ++i) {
+        if (i != axis) {
+          auto* dim = output_shape->add_dim();
+          dim->CopyFrom(input_shape.dim(i));
+        } else {
+          if (keep_dims == 1) {
+            auto* dim = output_shape->add_dim();
+            dim->set_dim_value(1);
+          }
+        }
+      }
+    });
+  };
+} // namespace ONNX_NAMESPACE
+
+ONNX_OPERATOR_SET_SCHEMA(ArgMax, 11, OpSchema().FillUsing(ArgReduceDocGenerator_opset11("max")));
+ONNX_OPERATOR_SET_SCHEMA(ArgMin, 11, OpSchema().FillUsing(ArgReduceDocGenerator_opset11("min")));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMax, 13, OpSchema().FillUsing(ReduceOpGenerator("max", EMPTY_MIN, true)));
+ONNX_OPERATOR_SET_SCHEMA(ReduceMin, 13, OpSchema().FillUsing(ReduceOpGenerator("min", EMPTY_MAX, true)));
+ONNX_OPERATOR_SET_SCHEMA(ReduceSumSquare, 13, OpSchema().FillUsing(ReduceOpGenerator("sum square", EMPTY_ZERO)));
+ONNX_OPERATOR_SET_SCHEMA(ReduceMean, 13, OpSchema().FillUsing(ReduceOpGenerator("mean", EMPTY_UNDEFINED)));
+ONNX_OPERATOR_SET_SCHEMA(ReduceProd, 13, OpSchema().FillUsing(ReduceOpGenerator("product", EMPTY_ONE)));
+ONNX_OPERATOR_SET_SCHEMA(ReduceLogSum, 13, OpSchema().FillUsing(ReduceOpGenerator("log sum", EMPTY_MINUS_INF)));
+ONNX_OPERATOR_SET_SCHEMA(
+    ReduceLogSumExp,
+    13,
+    OpSchema().FillUsing(ReduceOpGenerator("log sum exponent", EMPTY_MINUS_INF)));
+ONNX_OPERATOR_SET_SCHEMA(ReduceL1, 13, OpSchema().FillUsing(ReduceOpGenerator("L1 norm", EMPTY_ZERO)));
+ONNX_OPERATOR_SET_SCHEMA(ReduceL2, 13, OpSchema().FillUsing(ReduceOpGenerator("L2 norm", EMPTY_ZERO)));
+
+ONNX_OPERATOR_SET_SCHEMA(ReduceMax, 18, OpSchema().FillUsing(ReduceOpGenerator("max", EMPTY_MIN, true, true)));
+ONNX_OPERATOR_SET_SCHEMA(ReduceMin, 18, OpSchema().FillUsing(ReduceOpGenerator("min", EMPTY_MAX, true, true)));
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/reduction/utils.cc b/onnx/defs/reduction/utils.cc
new file mode 100644
index 0000000..d09e33b
--- /dev/null
+++ b/onnx/defs/reduction/utils.cc
@@ -0,0 +1,172 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/reduction/utils.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace ONNX_NAMESPACE {
+
+static std::vector<std::string> GetSupportedDataTypesForReductionOps(bool supports8bit, bool supports_bool) {
+  auto data_types = OpSchema::numeric_types_for_math_reduction_ir4();
+  if (supports8bit) {
+    data_types.emplace_back("tensor(uint8)");
+    data_types.emplace_back("tensor(int8)");
+  }
+  if (supports_bool) {
+    data_types.emplace_back("tensor(bool)");
+  }
+
+  return data_types;
+}
+
+std::function<void(OpSchema&)> ReduceOpGenerator(
+    const char* name,
+    const char* empty_value,
+    bool supports_8bit_datatypes,
+    bool axes_input,
+    const char* func_body,
+    const ContextDependentFunctionBodyBuilder& function_builder,
+    bool supports_boolean_datatype /* = false */) {
+  return [=](OpSchema& schema) {
+    std::string doc = R"DOC(
+Computes the {name} of the input tensor's elements along the provided axes. The resulting
+tensor has the same rank as the input if `keepdims` equals 1. If `keepdims` equals 0, then
+the resulting tensor has the reduced dimension pruned. Input tensors of rank zero are
+valid. Reduction over an empty set of values yields {empty_value}.
+)DOC";
+    if (supports_boolean_datatype) {
+      doc += R"DOC(
+
+If the input data type is Boolean, the comparison should consider `False < True`.)DOC";
+    }
+    doc += R"DOC(
+
+The above behavior is similar to numpy, with the exception that numpy defaults `keepdims`
+to `False` instead of `True`.)DOC";
+
+    ReplaceAll(doc, "{name}", name);
+    ReplaceAll(doc, "{empty_value}", empty_value);
+    POPULATE_OP_DOC_STR(doc = doc;);
+    schema.SetDoc(doc.c_str());
+    schema.Attr(
+        "keepdims",
+        "Keep the reduced dimension or not, default 1 means keep reduced dimension.",
+        AttributeProto::INT,
+        static_cast<int64_t>(1));
+    schema.Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    if (axes_input) {
+      schema.Attr(
+          "noop_with_empty_axes",
+          "Defines behavior when axes is not provided or is empty. "
+          "If false (default), reduction happens over all axes (similar to the case "
+          "when `axis=None` in numpy). "
+          "If true, reduction happens over an empty set of axes (similar to the case "
+          "when `axis=()` in numpy). "
+          "Note that reduction over an empty set of axes means that the reduction step "
+          "behaves like a no-op (identity function), but composite-reduction operators "
+          "will still perform the non-reduction steps as needed. "
+          "Thus, ReduceLogSum returns the Log of input tensor, and ReduceSumSquare "
+          "returns the Square of the input tensor, in this case.",
+          AttributeProto::INT,
+          static_cast<int64_t>(0));
+      schema.Input(
+          1,
+          "axes",
+          "Optional input list of integers, along which to reduce. "
+          "The default is to reduce over empty axes. "
+          "When axes is empty (either not provided or explicitly empty), behavior depends on 'noop_with_empty_axes': "
+          "reduction over all axes if 'noop_with_empty_axes' is false, "
+          "and reduction over the empty set of axes when 'noop_with_empty_axes' is true. "
+          "Accepted range is [-r, r-1] where r = rank(data).",
+          "tensor(int64)",
+          OpSchema::Optional,
+          true,
+          1,
+          OpSchema::NonDifferentiable);
+    } else {
+      schema.Attr(
+          "axes",
+          "A list of integers, along which to reduce. The default is to reduce over "
+          "all the dimensions of the input tensor. Accepted range is [-r, r-1] where r = rank(data).",
+          AttributeProto::INTS,
+          OPTIONAL_VALUE);
+    }
+    schema.Output(0, "reduced", "Reduced output tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T",
+        GetSupportedDataTypesForReductionOps(supports_8bit_datatypes, supports_boolean_datatype),
+        supports_boolean_datatype ? "Constrain input and output types to numeric and Boolean tensors."
+                                  : "Constrain input and output types to numeric tensors.");
+    if (func_body) {
+      schema.FunctionBody(func_body);
+    } else if (function_builder) {
+      schema.SetContextDependentFunctionBodyBuilder(function_builder);
+    }
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+
+      int64_t keep_dims = 1, noop_with_empty_axes = 0;
+      const auto* const attr_proto = ctx.getAttribute("keepdims");
+      if (attr_proto) {
+        keep_dims = attr_proto->i();
+      }
+      const auto* const noop_attr_proto = ctx.getAttribute("noop_with_empty_axes");
+      if (noop_attr_proto) {
+        noop_with_empty_axes = noop_attr_proto->i();
+      }
+      std::vector<int64_t> axes;
+      if (ctx.hasInput(1)) { // axes is input
+        if (ctx.getAttribute("axes")) {
+          fail_shape_inference("axes as an input and attribute cannot be specified at the same time.");
+        }
+
+        const TensorProto* axesInitializer = ctx.getInputData(1);
+        if (axesInitializer == nullptr) {
+          // skip if axes is not an initializer
+          return;
+        }
+        std::vector<int64_t> axes_values = ParseData<int64_t>(axesInitializer);
+        axes.assign(axes_values.begin(), axes_values.end());
+      } else { // axes is attribute
+        const auto* const axes_proto = ctx.getAttribute("axes");
+        if (axes_proto)
+          axes.assign(axes_proto->ints().begin(), axes_proto->ints().end());
+      }
+      const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      if (noop_with_empty_axes && axes.empty()) {
+        propagateShapeFromInputToOutput(ctx, 0, 0);
+        return;
+      }
+      int64_t input_ndim = input_shape.dim_size();
+      auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+      for (int64_t& axe : axes) {
+        if (axe < -input_ndim || axe >= input_ndim) {
+          fail_shape_inference("axis must be in [-rank, rank-1]. Input rank was ", input_ndim);
+        }
+        if (axe < 0)
+          axe += input_ndim;
+      }
+      for (int i = 0; i < input_ndim; ++i) {
+        // axes empty means reduce all dim
+        if (!axes.empty() && std::find(axes.begin(), axes.end(), i) == axes.end()) {
+          auto* dim = output_shape->add_dim();
+          dim->CopyFrom(input_shape.dim(i));
+        } else {
+          if (keep_dims == 1) {
+            auto* dim = output_shape->add_dim();
+            dim->set_dim_value(1);
+          }
+        }
+      }
+    });
+  };
+}
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/reduction/utils.h b/onnx/defs/reduction/utils.h
new file mode 100644
index 0000000..a7d887b
--- /dev/null
+++ b/onnx/defs/reduction/utils.h
@@ -0,0 +1,42 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cmath>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/tensor_proto_util.h"
+
+namespace ONNX_NAMESPACE {
+
+// Constants used to indicate value returned by reduction of an empty set of values.
+constexpr const char* EMPTY_ZERO = "0";
+constexpr const char* EMPTY_ONE = "1";
+constexpr const char* EMPTY_UNDEFINED = "undefined";
+constexpr const char* EMPTY_MIN =
+    "minus infinity (if supported by the datatype) or the minimum value of the data type otherwise";
+constexpr const char* EMPTY_MAX =
+    "plus infinity (if supported by the datatype) or the maximum value of the data type otherwise";
+constexpr const char* EMPTY_MINUS_INF = "minus infinity (if supported by the datatype) or undefined otherwise";
+
+std::function<void(OpSchema&)> ReduceOpGenerator(
+    const char* name,
+    const char* empty_value,
+    bool supports_8bit_datatypes = false,
+    bool axes_input = false,
+    const char* func_body = nullptr,
+    const ContextDependentFunctionBodyBuilder& function_builder = nullptr,
+    bool supports_boolean_datatype = false);
+
+inline std::function<void(OpSchema&)> ReduceOpDynamicAxes(const char* name, const char* empty_value) {
+  return ReduceOpGenerator(name, empty_value, false, true, nullptr, nullptr, false);
+}
+
+inline std::function<void(OpSchema&)>
+ReduceFunctionOp(const char* name, const char* empty_value, const char* func_body) {
+  return ReduceOpGenerator(name, empty_value, false, true, func_body);
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/rnn/CMakeLists.txt b/onnx/defs/rnn/CMakeLists.txt
new file mode 100644
index 0000000..0804eec
--- /dev/null
+++ b/onnx/defs/rnn/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+)
diff --git a/onnx/defs/rnn/defs.cc b/onnx/defs/rnn/defs.cc
new file mode 100644
index 0000000..fc2ea70
--- /dev/null
+++ b/onnx/defs/rnn/defs.cc
@@ -0,0 +1,373 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+#include <vector>
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+ONNX_API void RNNShapeInference(InferenceContext& ctx) {
+  Dim num_directions, seq_length, batch_size, hidden_size, input_size;
+
+  auto direction = getAttribute(ctx, "direction", "forward");
+  if ((direction == "forward") || (direction == "reverse"))
+    num_directions.set_dim_value(1);
+  else if (direction == "bidirectional")
+    num_directions.set_dim_value(2);
+  // else leave num_directions unknown in case of incorrect attribute value
+
+  auto hidden_size_value = getAttribute(ctx, "hidden_size", -1);
+  if (hidden_size_value > 0)
+    hidden_size.set_dim_value(hidden_size_value);
+
+  auto layout_value = getAttribute(ctx, "layout", 0);
+
+  // X: [seq_length, batch_size, input_size] (layout=0) or [batch_size, seq_length, input_size] (layout=1)
+  if (layout_value == 0) {
+    ctx.unifyInputShape(0, {seq_length, batch_size, input_size});
+  } else {
+    ctx.unifyInputShape(0, {batch_size, seq_length, input_size});
+  }
+
+  auto num_outputs = ctx.getNumOutputs();
+
+  if (num_outputs > 0) {
+    // Y
+    propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+    if (layout_value == 0) {
+      updateOutputShape(ctx, 0, {seq_length, num_directions, batch_size, hidden_size});
+    } else {
+      updateOutputShape(ctx, 0, {batch_size, seq_length, num_directions, hidden_size});
+    }
+  }
+
+  if (num_outputs > 1) {
+    // Y_h
+    propagateElemTypeFromInputToOutput(ctx, 0, 1);
+
+    if (layout_value == 0) {
+      updateOutputShape(ctx, 1, {num_directions, batch_size, hidden_size});
+    } else {
+      updateOutputShape(ctx, 1, {batch_size, num_directions, hidden_size});
+    }
+  }
+
+  if (num_outputs > 2) {
+    // Y_c : only in the case of LSTM
+    propagateElemTypeFromInputToOutput(ctx, 0, 2);
+
+    if (layout_value == 0) {
+      updateOutputShape(ctx, 2, {num_directions, batch_size, hidden_size});
+    } else {
+      updateOutputShape(ctx, 2, {batch_size, num_directions, hidden_size});
+    }
+  }
+}
+
+static std::function<void(OpSchema&)> RNNDocGenerator(const char* /*name*/) {
+  return [=](OpSchema& schema) {
+    schema.Attr(
+        "direction",
+        "Specify if the RNN is forward, reverse, or bidirectional. "
+        "Must be one of forward (default), reverse, or bidirectional.",
+        AttributeProto::STRING,
+        std::string("forward"));
+    schema.Attr(
+        "layout",
+        "The shape format of inputs X, initial_h and outputs Y, Y_h. "
+        "If 0, the following shapes are expected: "
+        "X.shape = [seq_length, batch_size, input_size], "
+        "Y.shape = [seq_length, num_directions, batch_size, hidden_size], "
+        "initial_h.shape = Y_h.shape = [num_directions, batch_size, hidden_size]. "
+        "If 1, the following shapes are expected: "
+        "X.shape = [batch_size, seq_length, input_size], "
+        "Y.shape = [batch_size, seq_length, num_directions, hidden_size], "
+        "initial_h.shape = Y_h.shape = [batch_size, num_directions, hidden_size].",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Attr("hidden_size", "Number of neurons in the hidden layer", AttributeProto::INT, OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_alpha",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM. Default values are the same as of corresponding ONNX operators."
+        "For example with LeakyRelu, the default alpha is 0.01.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_beta",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM. Default values are the same as of corresponding ONNX operators.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "clip",
+        "Cell clip threshold. Clipping bounds the elements of a tensor "
+        "in the range of [-threshold, +threshold] and is applied to the input "
+        "of activations. No clip if not specified.",
+        AttributeProto::FLOAT,
+        OPTIONAL_VALUE);
+    schema.Input(
+        0,
+        "X",
+        "The input sequences packed (and potentially padded) into one 3-D "
+        "tensor with the shape of `[seq_length, batch_size, input_size]`.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        4,
+        "sequence_lens",
+        "Optional tensor specifying lengths of the sequences in a batch. "
+        "If not specified - assumed all sequences in the batch to have "
+        "length `seq_length`. It has shape `[batch_size]`.",
+        "T1",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Input(
+        5,
+        "initial_h",
+        "Optional initial value of the hidden. If not specified - assumed "
+        "to be 0. It has shape `[num_directions, batch_size, hidden_size]`.",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Output(
+        0,
+        "Y",
+        "A tensor that concats all the intermediate output values of the hidden. "
+        "It has shape `[seq_length, num_directions, batch_size, hidden_size]`. ",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        1,
+        "Y_h",
+        "The last output value of the hidden. It has shape "
+        "`[num_directions, batch_size, hidden_size]`.",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint("T", OpSchema::all_float_types_ir4(), "Constrain input and output types to float tensors.");
+    schema.TypeConstraint("T1", {types::Int32}, "Constrain seq_lens to integer tensor.");
+    schema.TypeAndShapeInferenceFunction(RNNShapeInference);
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RNN,
+    22,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_RNN_ver14) + GenerateOptionalArgumentsDoc()))
+        .Attr(
+            "activations",
+            "One (or two if bidirectional) activation function for "
+            "input gate. The activation function must be one of the activation "
+            "functions specified above. Optional: Default `Tanh` if not specified.",
+            AttributeProto::STRINGS,
+            std::vector<std::string>{"Tanh", "Tanh"})
+        .Input(
+            1,
+            "W",
+            "The weight tensor for input gate. Concatenation of `Wi` and `WBi` "
+            "(if bidirectional). The tensor has shape "
+            "`[num_directions, hidden_size, input_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `Ri` and `RBi` "
+            "(if bidirectional). The tensor has shape "
+            "`[num_directions, hidden_size, hidden_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            3,
+            "B",
+            "The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` "
+            "and `[WBbi, RBbi]` (if bidirectional). The tensor has shape "
+            "`[num_directions, 2*hidden_size]`. Optional: If not specified - assumed "
+            "to be 0.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .FillUsing(RNNDocGenerator("RNN")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GRU,
+    22,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_GRU_ver14) + GenerateOptionalArgumentsDoc()))
+        .Attr(
+            "activations",
+            "A list of 2 (or 4 if bidirectional) activation functions "
+            "for update, reset, and hidden gates. The activation functions must be one "
+            "of the activation functions specified above. Optional: See the equations "
+            "for default if not specified.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "linear_before_reset",
+            "When computing the output of the hidden gate, "
+            "apply the linear transformation before multiplying by the output of the "
+            "reset gate.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            1,
+            "W",
+            "The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, input_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, hidden_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            3,
+            "B",
+            "The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and "
+            "`[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor "
+            "has shape `[num_directions, 6*hidden_size]`. Optional: If not specified "
+            "- assumed to be 0",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .FillUsing(RNNDocGenerator("GRU")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LSTM,
+    22,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_LSTM_ver14) + GenerateOptionalArgumentsDoc()))
+        .Attr(
+            "activations",
+            "A list of 3 (or 6 if bidirectional) activation functions "
+            "for input, output, forget, cell, and hidden. The activation functions must "
+            "be one of the activation functions specified above. Optional: See the equations "
+            "for default if not specified.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "layout",
+            "The shape format of inputs X, initial_h, initial_c and outputs Y, Y_h, Y_c. "
+            "If 0, the following shapes are expected: "
+            "X.shape = [seq_length, batch_size, input_size], "
+            "Y.shape = [seq_length, num_directions, batch_size, hidden_size], "
+            "initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = "
+            "[num_directions, batch_size, hidden_size]. "
+            "If 1, the following shapes are expected: "
+            "X.shape = [batch_size, seq_length, input_size], "
+            "Y.shape = [batch_size, seq_length, num_directions, hidden_size], "
+            "initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = "
+            "[batch_size, num_directions, hidden_size].",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr("input_forget", "Couple the input and forget gates if 1.", AttributeProto::INT, static_cast<int64_t>(0))
+        .Input(
+            1,
+            "W",
+            "The weight tensor for the gates. Concatenation of `W[iofc]` and "
+            "`WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape "
+            "`[num_directions, 4*hidden_size, input_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `R[iofc]` and "
+            "`RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 4*hidden_size, hidden_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            3,
+            "B",
+            "The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, "
+            "and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This "
+            "tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not "
+            "specified - assumed to be 0.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            6,
+            "initial_c",
+            "Optional initial value of the cell. If not specified - assumed "
+            "to be 0. It has shape `[num_directions, batch_size, hidden_size]`.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            7,
+            "P",
+            "The weight tensor for peepholes. Concatenation of `P[iof]` and "
+            "`PB[iof]` (if bidirectional) along dimension 0. It has shape "
+            "`[num_directions, 3*hidde_size]`. Optional: If not specified - "
+            "assumed to be 0.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .FillUsing(RNNDocGenerator("LSTM"))
+        .Output(
+            2,
+            "Y_c",
+            "The last output value of the cell. It has shape "
+            "`[num_directions, batch_size, hidden_size]`.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable));
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/rnn/old.cc b/onnx/defs/rnn/old.cc
new file mode 100644
index 0000000..bf5b44f
--- /dev/null
+++ b/onnx/defs/rnn/old.cc
@@ -0,0 +1,1490 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+#include <vector>
+
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static void RNNShapeInference_opset14(InferenceContext& ctx) {
+  TensorShapeProto::Dimension num_directions, seq_length, batch_size, hidden_size;
+
+  auto direction = getAttribute(ctx, "direction", "forward");
+  if ((direction == "forward") || (direction == "reverse"))
+    num_directions.set_dim_value(1);
+  else if (direction == "bidirectional")
+    num_directions.set_dim_value(2);
+  // else leave num_directions unknown in case of incorrect attribute value
+
+  auto hidden_size_value = getAttribute(ctx, "hidden_size", -1);
+  if (hidden_size_value > 0)
+    hidden_size.set_dim_value(hidden_size_value);
+
+  auto layout_value = getAttribute(ctx, "layout", 0);
+
+  if (hasInputShape(ctx, 0)) {
+    const auto& first_input_shape = getInputShape(ctx, 0);
+    if (first_input_shape.dim_size() != 3) {
+      fail_shape_inference("First input tensor must have rank 3");
+    }
+    seq_length = first_input_shape.dim((layout_value == 0) ? 0 : 1);
+    batch_size = first_input_shape.dim((layout_value == 0) ? 1 : 0);
+  }
+
+  auto num_outputs = ctx.getNumOutputs();
+
+  if (num_outputs > 0) {
+    // Y
+    propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+    if (layout_value == 0) {
+      auto dims = {seq_length, num_directions, batch_size, hidden_size};
+      updateOutputShape(ctx, 0, dims);
+    } else {
+      auto dims = {batch_size, seq_length, num_directions, hidden_size};
+      updateOutputShape(ctx, 0, dims);
+    }
+  }
+
+  if (num_outputs > 1) {
+    // Y_h
+    propagateElemTypeFromInputToOutput(ctx, 0, 1);
+
+    if (layout_value == 0) {
+      auto dims = {num_directions, batch_size, hidden_size};
+      updateOutputShape(ctx, 1, dims);
+    } else {
+      auto dims = {batch_size, num_directions, hidden_size};
+      updateOutputShape(ctx, 1, dims);
+    }
+  }
+
+  if (num_outputs > 2) {
+    // Y_c : only in the case of LSTM
+    propagateElemTypeFromInputToOutput(ctx, 0, 2);
+
+    if (layout_value == 0) {
+      auto dims = {num_directions, batch_size, hidden_size};
+      updateOutputShape(ctx, 2, dims);
+    } else {
+      auto dims = {batch_size, num_directions, hidden_size};
+      updateOutputShape(ctx, 2, dims);
+    }
+  }
+}
+static std::function<void(OpSchema&)> RNNDocGenerator_opset14(const char* /*name*/) {
+  return [=](OpSchema& schema) {
+    schema.Attr(
+        "direction",
+        "Specify if the RNN is forward, reverse, or bidirectional. "
+        "Must be one of forward (default), reverse, or bidirectional.",
+        AttributeProto::STRING,
+        std::string("forward"));
+    schema.Attr(
+        "layout",
+        "The shape format of inputs X, initial_h and outputs Y, Y_h. "
+        "If 0, the following shapes are expected: "
+        "X.shape = [seq_length, batch_size, input_size], "
+        "Y.shape = [seq_length, num_directions, batch_size, hidden_size], "
+        "initial_h.shape = Y_h.shape = [num_directions, batch_size, hidden_size]. "
+        "If 1, the following shapes are expected: "
+        "X.shape = [batch_size, seq_length, input_size], "
+        "Y.shape = [batch_size, seq_length, num_directions, hidden_size], "
+        "initial_h.shape = Y_h.shape = [batch_size, num_directions, hidden_size].",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Attr("hidden_size", "Number of neurons in the hidden layer", AttributeProto::INT, OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_alpha",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM. Default values are the same as of corresponding ONNX operators."
+        "For example with LeakyRelu, the default alpha is 0.01.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_beta",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM. Default values are the same as of corresponding ONNX operators.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "clip",
+        "Cell clip threshold. Clipping bounds the elements of a tensor "
+        "in the range of [-threshold, +threshold] and is applied to the input "
+        "of activations. No clip if not specified.",
+        AttributeProto::FLOAT,
+        OPTIONAL_VALUE);
+    schema.Input(
+        0,
+        "X",
+        "The input sequences packed (and potentially padded) into one 3-D "
+        "tensor with the shape of `[seq_length, batch_size, input_size]`.",
+        "T",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Input(
+        4,
+        "sequence_lens",
+        "Optional tensor specifying lengths of the sequences in a batch. "
+        "If not specified - assumed all sequences in the batch to have "
+        "length `seq_length`. It has shape `[batch_size]`.",
+        "T1",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Input(
+        5,
+        "initial_h",
+        "Optional initial value of the hidden. If not specified - assumed "
+        "to be 0. It has shape `[num_directions, batch_size, hidden_size]`.",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Output(
+        0,
+        "Y",
+        "A tensor that concats all the intermediate output values of the hidden. "
+        "It has shape `[seq_length, num_directions, batch_size, hidden_size]`. ",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.Output(
+        1,
+        "Y_h",
+        "The last output value of the hidden. It has shape "
+        "`[num_directions, batch_size, hidden_size]`.",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::Differentiable);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeConstraint("T1", {types::Int32}, "Constrain seq_lens to integer tensor.");
+    schema.TypeAndShapeInferenceFunction(RNNShapeInference_opset14);
+  };
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GRU,
+    14,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_GRU_ver14) + GenerateOptionalArgumentsDoc()))
+        .Attr(
+            "activations",
+            "A list of 2 (or 4 if bidirectional) activation functions "
+            "for update, reset, and hidden gates. The activation functions must be one "
+            "of the activation functions specified above. Optional: See the equations "
+            "for default if not specified.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "linear_before_reset",
+            "When computing the output of the hidden gate, "
+            "apply the linear transformation before multiplying by the output of the "
+            "reset gate.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            1,
+            "W",
+            "The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, input_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, hidden_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            3,
+            "B",
+            "The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and "
+            "`[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor "
+            "has shape `[num_directions, 6*hidden_size]`. Optional: If not specified "
+            "- assumed to be 0",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .FillUsing(RNNDocGenerator_opset14("GRU")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LSTM,
+    14,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_LSTM_ver14) + GenerateOptionalArgumentsDoc()))
+        .Attr(
+            "activations",
+            "A list of 3 (or 6 if bidirectional) activation functions "
+            "for input, output, forget, cell, and hidden. The activation functions must "
+            "be one of the activation functions specified above. Optional: See the equations "
+            "for default if not specified.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "layout",
+            "The shape format of inputs X, initial_h, initial_c and outputs Y, Y_h, Y_c. "
+            "If 0, the following shapes are expected: "
+            "X.shape = [seq_length, batch_size, input_size], "
+            "Y.shape = [seq_length, num_directions, batch_size, hidden_size], "
+            "initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = "
+            "[num_directions, batch_size, hidden_size]. "
+            "If 1, the following shapes are expected: "
+            "X.shape = [batch_size, seq_length, input_size], "
+            "Y.shape = [batch_size, seq_length, num_directions, hidden_size], "
+            "initial_h.shape = Y_h.shape = initial_c.shape = Y_c.shape = "
+            "[batch_size, num_directions, hidden_size].",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr("input_forget", "Couple the input and forget gates if 1.", AttributeProto::INT, static_cast<int64_t>(0))
+        .Input(
+            1,
+            "W",
+            "The weight tensor for the gates. Concatenation of `W[iofc]` and "
+            "`WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape "
+            "`[num_directions, 4*hidden_size, input_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `R[iofc]` and "
+            "`RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 4*hidden_size, hidden_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            3,
+            "B",
+            "The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, "
+            "and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This "
+            "tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not "
+            "specified - assumed to be 0.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            6,
+            "initial_c",
+            "Optional initial value of the cell. If not specified - assumed "
+            "to be 0. It has shape `[num_directions, batch_size, hidden_size]`.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            7,
+            "P",
+            "The weight tensor for peepholes. Concatenation of `P[iof]` and "
+            "`PB[iof]` (if bidirectional) along dimension 0. It has shape "
+            "`[num_directions, 3*hidde_size]`. Optional: If not specified - "
+            "assumed to be 0.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .FillUsing(RNNDocGenerator_opset14("LSTM"))
+        .Output(
+            2,
+            "Y_c",
+            "The last output value of the cell. It has shape "
+            "`[num_directions, batch_size, hidden_size]`.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RNN,
+    14,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_RNN_ver14) + GenerateOptionalArgumentsDoc()))
+        .Attr(
+            "activations",
+            "One (or two if bidirectional) activation function for "
+            "input gate. The activation function must be one of the activation "
+            "functions specified above. Optional: Default `Tanh` if not specified.",
+            AttributeProto::STRINGS,
+            std::vector<std::string>{"Tanh", "Tanh"})
+        .Input(
+            1,
+            "W",
+            "The weight tensor for input gate. Concatenation of `Wi` and `WBi` "
+            "(if bidirectional). The tensor has shape "
+            "`[num_directions, hidden_size, input_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `Ri` and `RBi` "
+            "(if bidirectional). The tensor has shape "
+            "`[num_directions, hidden_size, hidden_size]`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            3,
+            "B",
+            "The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` "
+            "and `[WBbi, RBbi]` (if bidirectional). The tensor has shape "
+            "`[num_directions, 2*hidden_size]`. Optional: If not specified - assumed "
+            "to be 0.",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .FillUsing(RNNDocGenerator_opset14("RNN")));
+
+static std::function<void(OpSchema&)> RNNDocGeneratorOld(const char* /*name*/) {
+  return [=](OpSchema& schema) {
+    schema.Attr(
+        "direction",
+        "Specify if the RNN is forward, reverse, or bidirectional. "
+        "Must be one of forward (default), reverse, or bidirectional.",
+        AttributeProto::STRING,
+        std::string("foward")); // reviewdog:ignore[misspell], don't fix that typo, it's fixed in newer versions
+    schema.Attr("hidden_size", "Number of neurons in the hidden layer", AttributeProto::INT, OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_alpha",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_beta",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "output_sequence",
+        "The sequence output for the hidden is optional if 0. Default 0.",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Attr(
+        "clip",
+        "Cell clip threshold. Clipping bounds the elements of a tensor "
+        "in the range of [-threshold, +threshold] and is applied to the input "
+        "of activations. No clip if not specified.",
+        AttributeProto::FLOAT,
+        OPTIONAL_VALUE);
+    schema.Input(
+        0,
+        "X",
+        "The input sequences packed (and potentially padded) into one 3-D "
+        "tensor with the shape of `[seq_length, batch_size, input_size]`.",
+        "T");
+    schema.Input(
+        4,
+        "sequence_lens",
+        "Optional tensor specifying lengths of the sequences in a batch. "
+        "If not specified - assumed all sequences in the batch to have "
+        "length `seq_length`. It has shape `[batch_size]`.",
+        "T1",
+        OpSchema::Optional);
+    schema.Input(
+        5,
+        "initial_h",
+        "Optional initial value of the hidden. If not specified - assumed "
+        "to be 0. It has shape `[num_directions, batch_size, hidden_size]`.",
+        "T",
+        OpSchema::Optional);
+    schema.Output(
+        0,
+        "Y",
+        "A tensor that concats all the intermediate output values of the hidden. "
+        "It has shape `[seq_length, num_directions, batch_size, hidden_size]`. "
+        "It is optional if `output_sequence` is 0.",
+        "T",
+        OpSchema::Optional);
+    schema.Output(
+        1,
+        "Y_h",
+        "The last output value of the hidden. It has shape "
+        "`[num_directions, batch_size, hidden_size]`.",
+        "T");
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeConstraint("T1", {types::Int32}, "Constrain seq_lens to integer tensor.");
+  };
+}
+
+static constexpr const char* GRU_ver1_doc = R"DOC(
+Computes an one-layer GRU. This operator is usually supported via some custom
+implementation such as CuDNN.
+
+Notations:
+
+`X` - input tensor
+
+`z` - update gate
+
+`r` - reset gate
+
+`h` - hidden gate
+
+`t` - time step (t-1 means previous time step)
+
+`W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+
+`R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+
+`Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+
+`Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+
+`WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+
+`RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+
+`WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+
+`RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+
+`H` - Hidden state
+
+`num_directions` - 2 if direction == bidirectional else 1
+
+Activation functions:
+
+  Relu(x)                - max(0, x)
+
+  Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+  Sigmoid(x)             - 1/(1 + e^{-x})
+
+  (NOTE: Below are optional)
+
+  Affine(x)              - alpha*x + beta
+
+  LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+  ThresholdedRelu(x)     - x if x >= alpha else 0
+
+  ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+  HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+  Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+  Softsign(x)            - x/(1 + |x|)
+
+  Softplus(x)            - log(1 + e^x)
+
+Equations (Default: f=Sigmoid, g=Tanh):
+
+  - zt = f(Xt*(Wz^T) + Ht-1*Rz + Wbz + Rbz)
+
+  - rt = f(Xt*(Wr^T) + Ht-1*Rr + Wbr + Rbr)
+
+  - ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*Rh + Rbh + Wbh) # default, when linear_before_reset = 0
+
+  - ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*Rh + Rbh) + Wbh) # when linear_before_reset != 0
+
+  - Ht = (1 - zt) (.) ht + zt (.) Ht-1
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GRU,
+    1,
+    OpSchema()
+        .SetDoc(GRU_ver1_doc)
+        .Attr(
+            "activations",
+            "A list of 2 (or 4 if bidirectional) activation functions "
+            "for update, reset, and hidden gates. The activation functions must be one "
+            "of the activation functions specified above. Optional: See the equations "
+            "for default if not specified.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Input(
+            1,
+            "W",
+            "The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, input_size]`.",
+            "T")
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, hidden_size]`.",
+            "T")
+        .Input(
+            3,
+            "B",
+            "The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and "
+            "`[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor "
+            "has shape `[num_directions, 6*hidden_size]`. Optional: If not specified "
+            "- assumed to be 0",
+            "T",
+            OpSchema::Optional)
+        .FillUsing(RNNDocGeneratorOld("GRU")));
+
+// Versions 1 to 6 of RNN/LSTM and versions 3 to 6 of GRU:
+
+static void RNNShapeInference_opset1_to_6(InferenceContext& ctx) {
+  TensorShapeProto::Dimension num_directions, seq_length, batch_size, hidden_size;
+
+  auto direction = getAttribute(ctx, "direction", "forward");
+  if ((direction == "forward") || (direction == "reverse"))
+    num_directions.set_dim_value(1);
+  else if (direction == "bidirectional")
+    num_directions.set_dim_value(2);
+  // else leave num_directions unknown in case of incorrect attribute value
+
+  auto hidden_size_value = getAttribute(ctx, "hidden_size", -1);
+  if (hidden_size_value > 0)
+    hidden_size.set_dim_value(hidden_size_value);
+
+  if (hasInputShape(ctx, 0)) {
+    const auto& first_input_shape = getInputShape(ctx, 0);
+    if (first_input_shape.dim_size() != 3) {
+      fail_shape_inference("First input tensor must have rank 3");
+    } else {
+      seq_length = first_input_shape.dim(0);
+      batch_size = first_input_shape.dim(1);
+    }
+  }
+
+  // The treatment of outputs is a bit complicated because of the combination of
+  // optional outputs and the output_sequence attribute.
+  bool output_sequence = (getAttribute(ctx, "output_sequence", 0) != 0);
+  auto num_outputs = ctx.getNumOutputs();
+
+  if (num_outputs == 0)
+    return; // Unlikely, but seems legal.
+
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+  if (num_outputs > 1)
+    propagateElemTypeFromInputToOutput(ctx, 0, 1);
+  if (num_outputs > 2)
+    propagateElemTypeFromInputToOutput(ctx, 0, 2);
+
+  if (output_sequence) {
+    // No ambiguity in spec
+    updateOutputShape(ctx, 0, {seq_length, num_directions, batch_size, hidden_size}); // Y
+    if (num_outputs > 1)
+      updateOutputShape(ctx, 1, {num_directions, batch_size, hidden_size}); // Y_h
+    if (num_outputs > 2)
+      updateOutputShape(ctx, 2, {num_directions, batch_size, hidden_size}); // Y_c
+  } else {
+    // Documentation suggests that the output Y is absent in this case
+    // Different tests seem to disagree on whether Y_h and Y_c, if present,
+    // should be in positions 0 & 1 or 1 & 2. updateOutputShape(ctx, 0,
+    // {num_directions, batch_size, hidden_size});  // Y_h if (num_outputs > 1)
+    // updateOutputShape(ctx, 1, {num_directions, batch_size, hidden_size});  //
+    // Y_c
+  }
+}
+
+static std::function<void(OpSchema&)> RNNDocGenerator_opset1_to_6(const char* /*name*/) {
+  return [=](OpSchema& schema) {
+    schema.Attr(
+        "direction",
+        "Specify if the RNN is forward, reverse, or bidirectional. "
+        "Must be one of forward (default), reverse, or bidirectional.",
+        AttributeProto::STRING,
+        std::string("forward"));
+    schema.Attr("hidden_size", "Number of neurons in the hidden layer", AttributeProto::INT, OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_alpha",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM. Default values are the same as of corresponding ONNX operators."
+        "For example with LeakyRelu, the default alpha is 0.01.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_beta",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM. Default values are the same as of corresponding ONNX operators.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "output_sequence",
+        "The sequence output for the hidden is optional if 0. Default 0.",
+        AttributeProto::INT,
+        static_cast<int64_t>(0));
+    schema.Attr(
+        "clip",
+        "Cell clip threshold. Clipping bounds the elements of a tensor "
+        "in the range of [-threshold, +threshold] and is applied to the input "
+        "of activations. No clip if not specified.",
+        AttributeProto::FLOAT,
+        OPTIONAL_VALUE);
+    schema.Input(
+        0,
+        "X",
+        "The input sequences packed (and potentially padded) into one 3-D "
+        "tensor with the shape of `[seq_length, batch_size, input_size]`.",
+        "T");
+    schema.Input(
+        4,
+        "sequence_lens",
+        "Optional tensor specifying lengths of the sequences in a batch. "
+        "If not specified - assumed all sequences in the batch to have "
+        "length `seq_length`. It has shape `[batch_size]`.",
+        "T1",
+        OpSchema::Optional);
+    schema.Input(
+        5,
+        "initial_h",
+        "Optional initial value of the hidden. If not specified - assumed "
+        "to be 0. It has shape `[num_directions, batch_size, hidden_size]`.",
+        "T",
+        OpSchema::Optional);
+    schema.Output(
+        0,
+        "Y",
+        "A tensor that concats all the intermediate output values of the hidden. "
+        "It has shape `[seq_length, num_directions, batch_size, hidden_size]`. "
+        "It is optional if `output_sequence` is 0.",
+        "T",
+        OpSchema::Optional);
+    schema.Output(
+        1,
+        "Y_h",
+        "The last output value of the hidden. It has shape "
+        "`[num_directions, batch_size, hidden_size]`.",
+        "T",
+        OpSchema::Optional);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeConstraint("T1", {types::Int32}, "Constrain seq_lens to integer tensor.");
+    schema.TypeAndShapeInferenceFunction(RNNShapeInference_opset1_to_6);
+  };
+}
+
+static constexpr const char* RNN_ver1_doc = R"DOC(
+Computes an one-layer simple RNN. This operator is usually supported
+via some custom implementation such as CuDNN.
+
+Notations:
+
+`X` - input tensor
+
+`i` - input gate
+
+`t` - time step (t-1 means previous time step)
+
+`Wi` - W parameter weight matrix for input gate
+
+`Ri` - R recurrence weight matrix for input gate
+
+`Wbi` - W parameter bias vector for input gate
+
+`Rbi` - R parameter bias vector for input gate
+
+`WBi` - W parameter weight matrix for backward input gate
+
+`RBi` - R recurrence weight matrix for backward input gate
+
+`WBbi` - WR bias vectors for backward input gate
+
+`RBbi` - RR bias vectors for backward input gate
+
+`H` - Hidden state
+
+`num_directions` - 2 if direction == bidirectional else 1
+
+Activation functions:
+
+  Relu(x)                - max(0, x)
+
+  Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+  Sigmoid(x)             - 1/(1 + e^{-x})
+
+  (NOTE: Below are optional)
+
+  Affine(x)              - alpha*x + beta
+
+  LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+  ThresholdedRelu(x)     - x if x >= alpha else 0
+
+  ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+  HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+  Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+  Softsign(x)            - x/(1 + |x|)
+
+  Softplus(x)            - log(1 + e^x)
+
+Equations (Default: f=Tanh):
+
+  - Ht = f(Xt*(Wi^T) + Ht-1*Ri + Wbi + Rbi)
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RNN,
+    1,
+    OpSchema()
+        .SetDoc(RNN_ver1_doc)
+        .Attr(
+            "activations",
+            "One (or two if bidirectional) activation function for "
+            "input gate. The activation function must be one of the activation "
+            "functions specified above. Optional: Default `Tanh` if not specified.",
+            AttributeProto::STRINGS,
+            std::vector<std::string>{"Tanh", "Tanh"})
+        .Input(
+            1,
+            "W",
+            "The weight tensor for input gate. Concatenation of `Wi` and `WBi` "
+            "(if bidirectional). The tensor has shape "
+            "`[num_directions, hidden_size, input_size]`.",
+            "T")
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `Ri` and `RBi` "
+            "(if bidirectional). The tensor has shape "
+            "`[num_directions, hidden_size, hidden_size]`.",
+            "T")
+        .Input(
+            3,
+            "B",
+            "The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` "
+            "and `[WBbi, RBbi]` (if bidirectional). The tensor has shape "
+            "`[num_directions, 2*hidden_size]`. Optional: If not specified - assumed "
+            "to be 0.",
+            "T",
+            OpSchema::Optional)
+        .FillUsing(RNNDocGenerator_opset1_to_6("RNN")));
+
+static const char* const GRU_ver3_doc = GRU_ver1_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GRU,
+    3,
+    OpSchema()
+        .SetDoc(GRU_ver3_doc)
+        .Attr(
+            "activations",
+            "A list of 2 (or 4 if bidirectional) activation functions "
+            "for update, reset, and hidden gates. The activation functions must be one "
+            "of the activation functions specified above. Optional: See the equations "
+            "for default if not specified.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "linear_before_reset",
+            "When computing the output of the hidden gate, "
+            "apply the linear transformation before multiplying by the output of the "
+            "reset gate.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            1,
+            "W",
+            "The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, input_size]`.",
+            "T")
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, hidden_size]`.",
+            "T")
+        .Input(
+            3,
+            "B",
+            "The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and "
+            "`[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor "
+            "has shape `[num_directions, 6*hidden_size]`. Optional: If not specified "
+            "- assumed to be 0",
+            "T",
+            OpSchema::Optional)
+        .FillUsing(RNNDocGenerator_opset1_to_6("GRU")));
+
+static constexpr const char* LSTM_ver1_doc = R"DOC(
+Computes an one-layer LSTM. This operator is usually supported via some
+custom implementation such as CuDNN.
+
+Notations:
+
+`X` - input tensor
+
+`i` - input gate
+
+`o` - output gate
+
+`f` - forget gate
+
+`c` - cell gate
+
+`t` - time step (t-1 means previous time step)
+
+`W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
+
+`R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
+
+`Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
+
+`Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
+
+`P[iof]`  - P peephole weight vector for input, output, and forget gates
+
+`WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
+
+`RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
+
+`WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
+
+`RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
+
+`PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
+
+`H` - Hidden state
+
+`num_directions` - 2 if direction == bidirectional else 1
+
+Activation functions:
+
+  Relu(x)                - max(0, x)
+
+  Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+  Sigmoid(x)             - 1/(1 + e^{-x})
+
+  (NOTE: Below are optional)
+
+  Affine(x)              - alpha*x + beta
+
+  LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+  ThresholdedRelu(x)     - x if x >= alpha else 0
+
+  ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+  HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+  Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+  Softsign(x)            - x/(1 + |x|)
+
+  Softplus(x)            - log(1 + e^x)
+
+Equations (Default: f=Sigmoid, g=Tanh, h=Tanh):
+
+  - it = f(Xt*(Wi^T) + Ht-1*Ri + Pi (.) Ct-1 + Wbi + Rbi)
+
+  - ft = f(Xt*(Wf^T) + Ht-1*Rf + Pf (.) Ct-1 + Wbf + Rbf)
+
+  - ct = g(Xt*(Wc^T) + Ht-1*Rc + Wbc + Rbc)
+
+  - Ct = ft (.) Ct-1 + it (.) ct
+
+  - ot = f(Xt*(Wo^T) + Ht-1*Ro + Po (.) Ct + Wbo + Rbo)
+
+  - Ht = ot (.) h(Ct)
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LSTM,
+    1,
+    OpSchema()
+        .SetDoc(LSTM_ver1_doc)
+        .Attr(
+            "activations",
+            "A list of 3 (or 6 if bidirectional) activation functions "
+            "for input, output, forget, cell, and hidden. The activation functions must "
+            "be one of the activation functions specified above. Optional: See the equations "
+            "for default if not specified.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "input_forget",
+            "Couple the input and forget gates if 1, default 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            1,
+            "W",
+            "The weight tensor for the gates. Concatenation of `W[iofc]` and "
+            "`WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape "
+            "`[num_directions, 4*hidden_size, input_size]`.",
+            "T")
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `R[iofc]` and "
+            "`RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 4*hidden_size, hidden_size]`.",
+            "T")
+        .Input(
+            3,
+            "B",
+            "The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, "
+            "and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This "
+            "tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not "
+            "specified - assumed to be 0.",
+            "T",
+            OpSchema::Optional)
+        .Input(
+            6,
+            "initial_c",
+            "Optional initial value of the cell. If not specified - assumed "
+            "to be 0. It has shape `[num_directions, batch_size, hidden_size]`.",
+            "T",
+            OpSchema::Optional)
+        .Input(
+            7,
+            "P",
+            "The weight tensor for peepholes. Concatenation of `P[iof]` and "
+            "`PB[iof]` (if bidirectional) along dimension 0. It has shape "
+            "`[num_directions, 3*hidde_size]`. Optional: If not specified - "
+            "assumed to be 0.",
+            "T",
+            OpSchema::Optional)
+        .FillUsing(RNNDocGenerator_opset1_to_6("LSTM"))
+        .Output(
+            2,
+            "Y_c",
+            "The last output value of the cell. It has shape "
+            "`[num_directions, batch_size, hidden_size]`.",
+            "T",
+            OpSchema::Optional));
+
+} // namespace ONNX_NAMESPACE
+
+// Versions 7 to 13 of RNN/LSTM/GRU
+
+namespace ONNX_NAMESPACE {
+static void RNNShapeInference_opset7_to_13(InferenceContext& ctx) {
+  TensorShapeProto::Dimension num_directions, seq_length, batch_size, hidden_size;
+
+  auto direction = getAttribute(ctx, "direction", "forward");
+  if ((direction == "forward") || (direction == "reverse"))
+    num_directions.set_dim_value(1);
+  else if (direction == "bidirectional")
+    num_directions.set_dim_value(2);
+  // else leave num_directions unknown in case of incorrect attribute value
+
+  auto hidden_size_value = getAttribute(ctx, "hidden_size", -1);
+  if (hidden_size_value > 0)
+    hidden_size.set_dim_value(hidden_size_value);
+
+  if (hasInputShape(ctx, 0)) {
+    const auto& first_input_shape = getInputShape(ctx, 0);
+    if (first_input_shape.dim_size() != 3) {
+      fail_shape_inference("First input tensor must have rank 3");
+    }
+    seq_length = first_input_shape.dim(0);
+    batch_size = first_input_shape.dim(1);
+  }
+
+  auto num_outputs = ctx.getNumOutputs();
+
+  if (num_outputs > 0) {
+    // Y
+    propagateElemTypeFromInputToOutput(ctx, 0, 0);
+    updateOutputShape(ctx, 0, {seq_length, num_directions, batch_size, hidden_size});
+  }
+
+  if (num_outputs > 1) {
+    // Y_h
+    propagateElemTypeFromInputToOutput(ctx, 0, 1);
+    updateOutputShape(ctx, 1, {num_directions, batch_size, hidden_size});
+  }
+
+  if (num_outputs > 2) {
+    // Y_c : only in the case of LSTM
+    propagateElemTypeFromInputToOutput(ctx, 0, 2);
+    updateOutputShape(ctx, 2, {num_directions, batch_size, hidden_size});
+  }
+}
+
+static std::function<void(OpSchema&)> RNNDocGenerator_opset7_to_13(const char* /*name*/) {
+  return [=](OpSchema& schema) {
+    schema.Attr(
+        "direction",
+        "Specify if the RNN is forward, reverse, or bidirectional. "
+        "Must be one of forward (default), reverse, or bidirectional.",
+        AttributeProto::STRING,
+        std::string("forward"));
+    schema.Attr("hidden_size", "Number of neurons in the hidden layer", AttributeProto::INT, OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_alpha",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM. Default values are the same as of corresponding ONNX operators."
+        "For example with LeakyRelu, the default alpha is 0.01.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "activation_beta",
+        "Optional scaling values used by some activation functions. The values "
+        "are consumed in the order of activation functions, for example (f, g, h) "
+        "in LSTM. Default values are the same as of corresponding ONNX operators.",
+        AttributeProto::FLOATS,
+        OPTIONAL_VALUE);
+    schema.Attr(
+        "clip",
+        "Cell clip threshold. Clipping bounds the elements of a tensor "
+        "in the range of [-threshold, +threshold] and is applied to the input "
+        "of activations. No clip if not specified.",
+        AttributeProto::FLOAT,
+        OPTIONAL_VALUE);
+    schema.Input(
+        0,
+        "X",
+        "The input sequences packed (and potentially padded) into one 3-D "
+        "tensor with the shape of `[seq_length, batch_size, input_size]`.",
+        "T");
+    schema.Input(
+        4,
+        "sequence_lens",
+        "Optional tensor specifying lengths of the sequences in a batch. "
+        "If not specified - assumed all sequences in the batch to have "
+        "length `seq_length`. It has shape `[batch_size]`.",
+        "T1",
+        OpSchema::Optional);
+    schema.Input(
+        5,
+        "initial_h",
+        "Optional initial value of the hidden. If not specified - assumed "
+        "to be 0. It has shape `[num_directions, batch_size, hidden_size]`.",
+        "T",
+        OpSchema::Optional);
+    schema.Output(
+        0,
+        "Y",
+        "A tensor that concats all the intermediate output values of the hidden. "
+        "It has shape `[seq_length, num_directions, batch_size, hidden_size]`. ",
+        "T",
+        OpSchema::Optional);
+    schema.Output(
+        1,
+        "Y_h",
+        "The last output value of the hidden. It has shape "
+        "`[num_directions, batch_size, hidden_size]`.",
+        "T",
+        OpSchema::Optional);
+    schema.TypeConstraint(
+        "T", {types::Float16, types::Float, types::Double}, "Constrain input and output types to float tensors.");
+    schema.TypeConstraint("T1", {types::Int32}, "Constrain seq_lens to integer tensor.");
+    schema.TypeAndShapeInferenceFunction(RNNShapeInference_opset7_to_13);
+  };
+}
+
+static constexpr const char* RNN_ver7_doc = R"DOC(
+Computes an one-layer simple RNN. This operator is usually supported
+via some custom implementation such as CuDNN.
+
+Notations:
+
+`X` - input tensor
+
+`i` - input gate
+
+`t` - time step (t-1 means previous time step)
+
+`Wi` - W parameter weight matrix for input gate
+
+`Ri` - R recurrence weight matrix for input gate
+
+`Wbi` - W parameter bias vector for input gate
+
+`Rbi` - R parameter bias vector for input gate
+
+`WBi` - W parameter weight matrix for backward input gate
+
+`RBi` - R recurrence weight matrix for backward input gate
+
+`WBbi` - WR bias vectors for backward input gate
+
+`RBbi` - RR bias vectors for backward input gate
+
+`H` - Hidden state
+
+`num_directions` - 2 if direction == bidirectional else 1
+
+Activation functions:
+
+  Relu(x)                - max(0, x)
+
+  Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+  Sigmoid(x)             - 1/(1 + e^{-x})
+
+  (NOTE: Below are optional)
+
+  Affine(x)              - alpha*x + beta
+
+  LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+  ThresholdedRelu(x)     - x if x >= alpha else 0
+
+  ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+  HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+  Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+  Softsign(x)            - x/(1 + |x|)
+
+  Softplus(x)            - log(1 + e^x)
+
+Equations (Default: f=Tanh):
+
+  - Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi)
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    RNN,
+    7,
+    OpSchema()
+        .SetDoc(RNN_ver7_doc + GenerateOptionalArgumentsDoc())
+        .Attr(
+            "activations",
+            "One (or two if bidirectional) activation function for "
+            "input gate. The activation function must be one of the activation "
+            "functions specified above. Optional: Default `Tanh` if not specified.",
+            AttributeProto::STRINGS,
+            std::vector<std::string>{"Tanh", "Tanh"})
+        .Input(
+            1,
+            "W",
+            "The weight tensor for input gate. Concatenation of `Wi` and `WBi` "
+            "(if bidirectional). The tensor has shape "
+            "`[num_directions, hidden_size, input_size]`.",
+            "T")
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `Ri` and `RBi` "
+            "(if bidirectional). The tensor has shape "
+            "`[num_directions, hidden_size, hidden_size]`.",
+            "T")
+        .Input(
+            3,
+            "B",
+            "The bias tensor for input gate. Concatenation of `[Wbi, Rbi]` "
+            "and `[WBbi, RBbi]` (if bidirectional). The tensor has shape "
+            "`[num_directions, 2*hidden_size]`. Optional: If not specified - assumed "
+            "to be 0.",
+            "T",
+            OpSchema::Optional)
+        .FillUsing(RNNDocGenerator_opset7_to_13("RNN")));
+
+static constexpr const char* GRU_ver7_doc = R"DOC(
+Computes an one-layer GRU. This operator is usually supported via some custom
+implementation such as CuDNN.
+
+Notations:
+
+`X` - input tensor
+
+`z` - update gate
+
+`r` - reset gate
+
+`h` - hidden gate
+
+`t` - time step (t-1 means previous time step)
+
+`W[zrh]` - W parameter weight matrix for update, reset, and hidden gates
+
+`R[zrh]` - R recurrence weight matrix for update, reset, and hidden gates
+
+`Wb[zrh]` - W bias vectors for update, reset, and hidden gates
+
+`Rb[zrh]` - R bias vectors for update, reset, and hidden gates
+
+`WB[zrh]` - W parameter weight matrix for backward update, reset, and hidden gates
+
+`RB[zrh]` - R recurrence weight matrix for backward update, reset, and hidden gates
+
+`WBb[zrh]` - W bias vectors for backward update, reset, and hidden gates
+
+`RBb[zrh]` - R bias vectors for backward update, reset, and hidden gates
+
+`H` - Hidden state
+
+`num_directions` - 2 if direction == bidirectional else 1
+
+Activation functions:
+
+  Relu(x)                - max(0, x)
+
+  Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+  Sigmoid(x)             - 1/(1 + e^{-x})
+
+  (NOTE: Below are optional)
+
+  Affine(x)              - alpha*x + beta
+
+  LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+  ThresholdedRelu(x)     - x if x >= alpha else 0
+
+  ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+  HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+  Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+  Softsign(x)            - x/(1 + |x|)
+
+  Softplus(x)            - log(1 + e^x)
+
+Equations (Default: f=Sigmoid, g=Tanh):
+
+  - zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz)
+
+  - rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr)
+
+  - ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # default, when linear_before_reset = 0
+
+  - ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset != 0
+
+  - Ht = (1 - zt) (.) ht + zt (.) Ht-1
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GRU,
+    7,
+    OpSchema()
+        .SetDoc(GRU_ver7_doc + GenerateOptionalArgumentsDoc())
+        .Attr(
+            "activations",
+            "A list of 2 (or 4 if bidirectional) activation functions "
+            "for update, reset, and hidden gates. The activation functions must be one "
+            "of the activation functions specified above. Optional: See the equations "
+            "for default if not specified.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "linear_before_reset",
+            "When computing the output of the hidden gate, "
+            "apply the linear transformation before multiplying by the output of the "
+            "reset gate.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            1,
+            "W",
+            "The weight tensor for the gates. Concatenation of `W[zrh]` and `WB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, input_size]`.",
+            "T")
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `R[zrh]` and `RB[zrh]` "
+            "(if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 3*hidden_size, hidden_size]`.",
+            "T")
+        .Input(
+            3,
+            "B",
+            "The bias tensor for the gates. Concatenation of `[Wb[zrh], Rb[zrh]]` and "
+            "`[WBb[zrh], RBb[zrh]]` (if bidirectional) along dimension 0. This tensor "
+            "has shape `[num_directions, 6*hidden_size]`. Optional: If not specified "
+            "- assumed to be 0",
+            "T",
+            OpSchema::Optional)
+        .FillUsing(RNNDocGenerator_opset7_to_13("GRU")));
+
+static constexpr const char* LSTM_ver7_doc = R"DOC(
+Computes an one-layer LSTM. This operator is usually supported via some
+custom implementation such as CuDNN.
+
+Notations:
+
+`X` - input tensor
+
+`i` - input gate
+
+`o` - output gate
+
+`f` - forget gate
+
+`c` - cell gate
+
+`t` - time step (t-1 means previous time step)
+
+`W[iofc]` - W parameter weight matrix for input, output, forget, and cell gates
+
+`R[iofc]` - R recurrence weight matrix for input, output, forget, and cell gates
+
+`Wb[iofc]` - W bias vectors for input, output, forget, and cell gates
+
+`Rb[iofc]` - R bias vectors for input, output, forget, and cell gates
+
+`P[iof]`  - P peephole weight vector for input, output, and forget gates
+
+`WB[iofc]` - W parameter weight matrix for backward input, output, forget, and cell gates
+
+`RB[iofc]` - R recurrence weight matrix for backward input, output, forget, and cell gates
+
+`WBb[iofc]` - W bias vectors for backward input, output, forget, and cell gates
+
+`RBb[iofc]` - R bias vectors for backward input, output, forget, and cell gates
+
+`PB[iof]`  - P peephole weight vector for backward input, output, and forget gates
+
+`H` - Hidden state
+
+`num_directions` - 2 if direction == bidirectional else 1
+
+Activation functions:
+
+  Relu(x)                - max(0, x)
+
+  Tanh(x)                - (1 - e^{-2x})/(1 + e^{-2x})
+
+  Sigmoid(x)             - 1/(1 + e^{-x})
+
+  (NOTE: Below are optional)
+
+  Affine(x)              - alpha*x + beta
+
+  LeakyRelu(x)           - x if x >= 0 else alpha * x
+
+  ThresholdedRelu(x)     - x if x >= alpha else 0
+
+  ScaledTanh(x)          - alpha*Tanh(beta*x)
+
+  HardSigmoid(x)         - min(max(alpha*x + beta, 0), 1)
+
+  Elu(x)                 - x if x >= 0 else alpha*(e^x - 1)
+
+  Softsign(x)            - x/(1 + |x|)
+
+  Softplus(x)            - log(1 + e^x)
+
+Equations (Default: f=Sigmoid, g=Tanh, h=Tanh):
+
+  - it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Pi (.) Ct-1 + Wbi + Rbi)
+
+  - ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Pf (.) Ct-1 + Wbf + Rbf)
+
+  - ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc)
+
+  - Ct = ft (.) Ct-1 + it (.) ct
+
+  - ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Po (.) Ct + Wbo + Rbo)
+
+  - Ht = ot (.) h(Ct)
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    LSTM,
+    7,
+    OpSchema()
+        .SetDoc(LSTM_ver7_doc + GenerateOptionalArgumentsDoc())
+        .Attr(
+            "activations",
+            "A list of 3 (or 6 if bidirectional) activation functions "
+            "for input, output, forget, cell, and hidden. The activation functions must "
+            "be one of the activation functions specified above. Optional: See the equations "
+            "for default if not specified.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("input_forget", "Couple the input and forget gates if 1.", AttributeProto::INT, static_cast<int64_t>(0))
+        .Input(
+            1,
+            "W",
+            "The weight tensor for the gates. Concatenation of `W[iofc]` and "
+            "`WB[iofc]` (if bidirectional) along dimension 0. The tensor has shape "
+            "`[num_directions, 4*hidden_size, input_size]`.",
+            "T")
+        .Input(
+            2,
+            "R",
+            "The recurrence weight tensor. Concatenation of `R[iofc]` and "
+            "`RB[iofc]` (if bidirectional) along dimension 0. This tensor has shape "
+            "`[num_directions, 4*hidden_size, hidden_size]`.",
+            "T")
+        .Input(
+            3,
+            "B",
+            "The bias tensor for input gate. Concatenation of `[Wb[iofc], Rb[iofc]]`, "
+            "and `[WBb[iofc], RBb[iofc]]` (if bidirectional) along dimension 0. This "
+            "tensor has shape `[num_directions, 8*hidden_size]`. Optional: If not "
+            "specified - assumed to be 0.",
+            "T",
+            OpSchema::Optional)
+        .Input(
+            6,
+            "initial_c",
+            "Optional initial value of the cell. If not specified - assumed "
+            "to be 0. It has shape `[num_directions, batch_size, hidden_size]`.",
+            "T",
+            OpSchema::Optional)
+        .Input(
+            7,
+            "P",
+            "The weight tensor for peepholes. Concatenation of `P[iof]` and "
+            "`PB[iof]` (if bidirectional) along dimension 0. It has shape "
+            "`[num_directions, 3*hidde_size]`. Optional: If not specified - "
+            "assumed to be 0.",
+            "T",
+            OpSchema::Optional)
+        .FillUsing(RNNDocGenerator_opset7_to_13("LSTM"))
+        .Output(
+            2,
+            "Y_c",
+            "The last output value of the cell. It has shape "
+            "`[num_directions, batch_size, hidden_size]`.",
+            "T",
+            OpSchema::Optional));
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/schema.cc b/onnx/defs/schema.cc
new file mode 100644
index 0000000..babba0d
--- /dev/null
+++ b/onnx/defs/schema.cc
@@ -0,0 +1,1705 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/schema.h"
+
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "onnx/checker.h"
+#include "onnx/defs/operator_sets.h"
+#include "onnx/defs/operator_sets_preview.h"
+#include "onnx/defs/operator_sets_training.h"
+#include "onnx/defs/type_builders.h"
+
+#ifdef ONNX_ML
+#include "onnx/defs/operator_sets_ml.h"
+#endif
+
+#ifndef NDEBUG
+#include "onnx/common/assertions.h"
+#endif
+#include "onnx/defs/parser.h"
+
+namespace ONNX_NAMESPACE {
+// -1 means ONNX schema hasn't been loaded yet
+// 0 means all versions of ONNX schema have been loaded
+// Other positive integer means the ONNX schemas for the specified version have been loaded
+int OpSchemaRegistry::loaded_schema_version = -1;
+
+// By default if opset_version_to_load=0, it registers all opset schema for all opset versions
+// Otherwise, it only registers the latest schema according to opset_version_to_load
+void RegisterSchema(
+    const OpSchema& schema,
+    int opset_version_to_load,
+    bool fail_duplicate_schema,
+    bool fail_with_exception) {
+  RegisterSchema(OpSchema(schema), opset_version_to_load, fail_duplicate_schema, fail_with_exception);
+}
+void RegisterSchema(
+    OpSchema&& schema,
+    int opset_version_to_load,
+    bool fail_duplicate_schema,
+    bool fail_with_exception) {
+  if (fail_with_exception) {
+    OpSchemaRegistry::OpSchemaRegisterOnce::OpSchemaRegisterImpl(
+        std::move(schema), opset_version_to_load, fail_duplicate_schema);
+  } else {
+    OpSchemaRegistry::OpSchemaRegisterOnce::OpSchemaRegisterNoExcept(
+        std::move(schema), opset_version_to_load, fail_duplicate_schema);
+  }
+}
+
+// The (name, version, domain) must match the target exactly
+// Otherwise will raise an SchemaError
+void DeregisterSchema(const std::string& op_type, int version, const std::string& domain) {
+  OpSchemaRegistry::OpSchemaDeregister(op_type, version, domain);
+}
+
+#ifndef NDEBUG
+DbgOperatorSetTracker& DbgOperatorSetTracker::Instance() {
+  static DbgOperatorSetTracker instance;
+  return instance;
+}
+#endif
+
+const std::string& OpSchema::FormalParameter::GetName() const {
+  return name_;
+}
+
+const DataTypeSet& OpSchema::FormalParameter::GetTypes() const {
+  return type_set_;
+}
+
+DataTypeSet& OpSchema::FormalParameter::MutableTypes() {
+  return type_set_;
+}
+
+const std::string& OpSchema::FormalParameter::GetTypeStr() const {
+  return type_str_;
+}
+
+const std::string& OpSchema::FormalParameter::GetDescription() const {
+  return description_;
+}
+
+OpSchema::FormalParameterOption OpSchema::FormalParameter::GetOption() const {
+  return param_option_;
+}
+
+bool OpSchema::FormalParameter::GetIsHomogeneous() const {
+  return is_homogeneous_;
+}
+
+int OpSchema::FormalParameter::GetMinArity() const {
+  return min_arity_;
+}
+
+OpSchema::DifferentiationCategory OpSchema::FormalParameter::GetDifferentiationCategory() const {
+  return differentiation_category_;
+}
+
+OpSchemaRegistry* OpSchemaRegistry::Instance() {
+  static OpSchemaRegistry instance;
+  return &instance;
+}
+
+void OpSchema::CheckInputOutputType(struct InferenceContext& ctx) const {
+  std::unordered_map<std::string, std::string> type_constraints;
+  // Check the number of inputs / output.
+  VerifyInputNum(ctx.getNumInputs());
+  VerifyOutputNum(ctx.getNumOutputs());
+
+  // check all input types
+  for (size_t in_idx = 0; in_idx < ctx.getNumInputs(); ++in_idx) {
+    // If the last input is Variadic by definition, checker still needs to check the rest of actual input's type
+    const auto& param = (in_idx < inputs_.size()) ? inputs_[in_idx] : inputs_.back();
+    const auto& type_str = param.GetTypeStr();
+    const auto& param_type = ctx.getInputType(in_idx);
+    const auto& all_types = param.GetTypes();
+    if (nullptr == param_type || param_type->value_case() == TypeProto::VALUE_NOT_SET) {
+      continue;
+    } else if (!all_types.empty() && all_types.find(Utils::DataTypeUtils::ToType(*param_type)) == all_types.end()) {
+      fail_check(
+          param.GetName(),
+          " typestr: ",
+          type_str,
+          ", has unsupported type: ",
+          *Utils::DataTypeUtils::ToType(*param_type));
+    }
+    if (param.GetIsHomogeneous()) {
+      const auto& type_proto = Utils::DataTypeUtils::ToType(*param_type);
+      auto [it, inserted] = type_constraints.emplace(type_str, *type_proto);
+      if (!inserted) {
+        // failed to insert a new element due to a duplication, now check consistency
+        if (it->second != *type_proto) {
+          fail_check(param.GetName(), " has inconsistent type ", *Utils::DataTypeUtils::ToType(*param_type));
+        }
+      }
+    }
+  } // for inputs
+  // check all output types
+  for (size_t out_idx = 0; out_idx < ctx.getNumOutputs(); ++out_idx) {
+    // If the last output is Variadic by definition, checker still needs to check the rest of actual output's type
+    const auto& param = (out_idx < outputs_.size()) ? outputs_[out_idx] : outputs_.back();
+    const auto& type_str = param.GetTypeStr();
+    const auto& param_type = ctx.getOutputType(out_idx);
+    const auto& all_types = param.GetTypes();
+    bool output_type_found = true;
+    // infer type if necessary
+    if (param_type->value_case() == TypeProto::VALUE_NOT_SET) {
+      if (all_types.size() == 1) {
+        *param_type = Utils::DataTypeUtils::ToTypeProto(*all_types.begin());
+      } else if (type_constraints.find(type_str) != type_constraints.end()) {
+        const auto* const data_type = Utils::DataTypeUtils::ToType(type_constraints[type_str]);
+        *param_type = Utils::DataTypeUtils::ToTypeProto(data_type);
+      } else {
+        output_type_found = false;
+      }
+    }
+    if (!output_type_found) {
+      continue;
+    }
+    if (!all_types.empty() && all_types.find(Utils::DataTypeUtils::ToType(*param_type)) == all_types.end()) {
+      fail_check(param.GetName(), " has unsupported type ", *Utils::DataTypeUtils::ToType(*param_type));
+    }
+    if (param.GetIsHomogeneous()) {
+      const auto& type_proto = Utils::DataTypeUtils::ToType(*param_type);
+      if (type_constraints.find(type_str) == type_constraints.end()) {
+        type_constraints[type_str] = *type_proto;
+      } else if (type_constraints[type_str] != *type_proto) {
+        fail_check(param.GetName(), " has inconsistent type ", *Utils::DataTypeUtils::ToType(*param_type));
+      }
+    } // else
+  } // for outputs
+}
+
+void OpSchema::Verify(const NodeProto& node) const {
+  if (deprecated_) {
+    fail_check("Operator '", name_, "' has been deprecated since version ", since_version_);
+  }
+
+  VerifyInputNum(node.input_size(), node.name());
+  VerifyOutputNum(node.output_size(), node.name());
+
+  // Check the values of inputs / outputs
+  for (int in_idx = 0; in_idx < node.input_size(); ++in_idx) {
+    if (in_idx >= static_cast<int>(inputs_.size())) {
+      if (!inputs_.empty() && Variadic == inputs_.back().GetOption()) {
+        // The last input formal parameter should be variadic.
+        break;
+      } else {
+        fail_check(
+            "Node (",
+            node.name(),
+            ") has more inputs (",
+            node.input_size(),
+            ") than declared (",
+            inputs_.size(),
+            ") in op definition.");
+      }
+    }
+    if (node.input(in_idx).empty() && (Single == inputs_[in_idx].GetOption())) {
+      fail_check("Node (", node.name(), ")'s input ", in_idx, " is marked single but has an empty string in the graph");
+    }
+  }
+
+  for (int out_idx = 0; out_idx < node.output_size(); ++out_idx) {
+    if (out_idx >= static_cast<int>(outputs_.size())) {
+      if (!outputs_.empty() && Variadic == outputs_.back().GetOption()) {
+        // The last output formal parameter should be variadic.
+        break;
+      } else {
+        fail_check(
+            "Node (",
+            node.name(),
+            ") has more outputs (",
+            node.output_size(),
+            ") than declared (",
+            outputs_.size(),
+            ") in op definition.");
+      }
+    }
+
+    if (node.output(out_idx).empty() && (Single == outputs_[out_idx].GetOption())) {
+      fail_check(
+          "Node (", node.name(), ")'s output ", out_idx, " is marked single but has an empty string in the graph");
+    }
+  }
+
+  // An internal symbol is defined as starting with two underscores. Attributes
+  // with names meeting this condition are considered implementation details
+  // and should be ignored for the purpose of schema checking.
+  auto isInternalSymbol = [](const std::string& sym) -> bool {
+    return sym.length() >= 2 && sym[0] == '_' && sym[1] == '_';
+  };
+
+  // Check attributes
+  std::unordered_set<std::string> seen_attr_names{};
+  for (const auto& attr_proto : node.attribute()) {
+    const auto& name = attr_proto.name();
+
+    if (!seen_attr_names.insert(name).second) {
+      fail_check("Attribute '", name, "' appeared multiple times.");
+    }
+
+    const auto search = attributes_.find(name);
+    AttributeProto::AttributeType expected_type{};
+    if (search != attributes_.end()) {
+      expected_type = search->second.type;
+    } else if (allows_unchecked_attributes_ || isInternalSymbol(name)) {
+      continue;
+    } else {
+      fail_check("Unrecognized attribute: ", name, " for operator ", node.op_type());
+    }
+
+    // Type would be UNDEFINED if not set
+    if (attr_proto.type() != expected_type) {
+      fail_check(
+          "Mismatched attribute type in '",
+          node.name() + " : " + name,
+          "'. Expected: '",
+          AttributeProto_AttributeType_Name(expected_type),
+          "', actual: '",
+          AttributeProto_AttributeType_Name(attr_proto.type()),
+          "'");
+    }
+
+    // ref_attr_name is only valid when non-empty
+    // we simply read default value if not present
+    if (!attr_proto.ref_attr_name().empty()) {
+      continue;
+    }
+
+    switch (expected_type) {
+      // if attr_proto().type() != UNDEFINED
+      // we consider primitive types to be set even
+      // if proto3 did not output default values into the stream
+      // in which case we will read the default
+      case AttributeProto::FLOAT:
+      case AttributeProto::INT:
+      case AttributeProto::STRING:
+        break;
+      case AttributeProto::TENSOR:
+        if (!attr_proto.has_t()) {
+          fail_check("Attribute '", name, "' is expected to have field 't'");
+        }
+        break;
+      case AttributeProto::SPARSE_TENSOR:
+        if (!attr_proto.has_sparse_tensor()) {
+          fail_check("Attribute '", name, "' is expected to have field 'sparse_tensor'");
+        }
+        break;
+      case AttributeProto::GRAPH:
+        if (!attr_proto.has_g()) {
+          fail_check("Attribute '", name, "' is expected to have field 'g'");
+        }
+        break;
+      case AttributeProto::TYPE_PROTO:
+        if (!attr_proto.has_tp()) {
+          fail_check("Attribute '", name, "' is expected to have field 'type_proto'");
+        }
+        break;
+      case AttributeProto::INTS:
+      case AttributeProto::FLOATS:
+      case AttributeProto::TENSORS:
+      case AttributeProto::STRINGS:
+      case AttributeProto::SPARSE_TENSORS:
+      case AttributeProto::GRAPHS:
+      case AttributeProto::TYPE_PROTOS:
+        // No check ... whether an empty list is a valid value for the attribute
+        // is op specific.
+        break;
+      default:
+        fail_check("Attribute '", name, " has unknown expected type");
+    }
+  }
+  for (const auto& [_, attr] : attributes_) {
+    if (!attr.required) {
+      continue;
+    }
+    if (!seen_attr_names.count(attr.name)) {
+      fail_check("Required attribute '", attr.name, "' is missing.");
+    }
+  }
+
+  // Phew. All verifications passed.
+}
+
+std::string OpSchema::VerifyFailPrefix(std::string_view node_name) const {
+  std::string str = "Node";
+  if (!node_name.empty()) {
+    str = str + "(" + std::string(node_name) + ")";
+  }
+  str = str + " with schema(" + domain() + "::" + Name() + ":" + std::to_string(since_version()) + ")";
+  return str;
+}
+
+void OpSchema::VerifyInputNum(int input_num, std::string_view node_name) const {
+  if (input_num < min_input_ || input_num > max_input_) {
+    fail_check(
+        VerifyFailPrefix(node_name),
+        " has input size ",
+        input_num,
+        " not in range [min=",
+        min_input_,
+        ", max=",
+        max_input_,
+        "].");
+  }
+
+  if (!num_inputs_allowed_(input_num)) {
+    fail_check(VerifyFailPrefix(node_name), " has input size ", input_num, " not in allowed input sizes.");
+  }
+}
+
+void OpSchema::VerifyOutputNum(int output_num, std::string_view node_name) const {
+  if (output_num < min_output_ || output_num > max_output_) {
+    fail_check(
+        VerifyFailPrefix(node_name),
+        " has output size ",
+        output_num,
+        " not in range [min=",
+        min_output_,
+        ", max=",
+        max_output_,
+        "].");
+  }
+
+  if (!num_outputs_allowed_(output_num)) {
+    fail_check(VerifyFailPrefix(node_name), " has output size ", output_num, " not in allowed output sizes.");
+  }
+}
+
+OpSchema& OpSchema::SinceVersion(OperatorSetVersion v) {
+  since_version_ = v;
+
+  // SinceVersion is called after FunctionBody and SetContextDependentFunctionBodyBuilder are called
+  // when defining a op.
+  // FunctionBody() and SetContextDependentFunctionBodyBuilder() use -1 as the default opset_version
+  // default opset_version is for a FunctionProto of the same opset_version as the op's since_version_.
+  // It is indexed with -1 so we need to reindex it with since_version_.
+  //
+  // FunctionProtos of non-default opset_versions are for models whose opset version is higher than the op's
+  // opset version such that ops used in the default function_proto are no longer valid. For example:
+  // A model of opset version 18 contains a LayerNormalization op.
+  // LayerNormalization is function op whese function body uses ReduceMean op.
+  // LayerNormalization's since_version is 17 thus it is good for the model of opset 18.
+  // however, if a runtime needs to inline LayerNormalization, the inlined model has a ReduceMean op.
+  // ReduceMean in opset 18 is different from opset 17.
+  // This requires us to define more than one function body
+  auto it = opset_version_to_function_builder_.find(OpSchema::kUninitializedSinceVersion);
+  if (it != opset_version_to_function_builder_.end()) {
+    opset_version_to_function_builder_[since_version_] = it->second;
+    opset_version_to_function_builder_.erase(it);
+  }
+
+  auto it_function_body = opset_version_to_function_body_.find(OpSchema::kUninitializedSinceVersion);
+  if (it_function_body != opset_version_to_function_body_.end()) {
+    opset_version_to_function_body_[since_version_] = it_function_body->second;
+    UpdateFunctionProtoOpsetImportVersion(*opset_version_to_function_body_[since_version_], since_version_);
+    opset_version_to_function_body_.erase(it_function_body);
+  }
+
+  return *this;
+}
+
+OpSchema& OpSchema::Deprecate() {
+  deprecated_ = true;
+  return *this;
+}
+
+OpSchema& OpSchema::NumInputs(std::unordered_set<int> allowed_input_nums) {
+  num_inputs_allowed_ = [allowed_input_nums = std::move(allowed_input_nums)](int n) -> bool {
+    return allowed_input_nums.count(n);
+  };
+  return *this;
+}
+
+OpSchema& OpSchema::NumOutputs(std::unordered_set<int> allowed_output_nums) {
+  num_outputs_allowed_ = [allowed_output_nums = std::move(allowed_output_nums)](int n) -> bool {
+    return allowed_output_nums.count(n) > 0;
+  };
+  return *this;
+}
+
+OpSchema& OpSchema::TypeAndShapeInferenceFunction(InferenceFunction inferenceFunction) {
+  tensor_inference_function_ = std::move(inferenceFunction);
+  return *this;
+}
+
+OpSchema& OpSchema::PartialDataPropagationFunction(DataPropagationFunction dataPropagationFunction) {
+  data_propagation_function_ = std::move(dataPropagationFunction);
+  return *this;
+}
+
+OpSchema& OpSchema::SetSupportLevel(SupportType support) {
+  support_ = support;
+  return *this;
+}
+
+// Functions to specify name for the operator schema.
+OpSchema& OpSchema::SetName(std::string name) {
+  name_ = std::move(name);
+  return *this;
+}
+
+OpSchema& OpSchema::SetName(const char* name) {
+  return SetName(std::string(name));
+}
+
+// Functions to specify code location for the operator schema.
+OpSchema& OpSchema::SetLocation(std::string file, int line) {
+  file_ = std::move(file);
+  line_ = line;
+  return *this;
+}
+
+OpSchema& OpSchema::SetLocation(const char* file, int line) {
+  return SetLocation(std::string(file), line);
+}
+
+OpSchema& OpSchema::SetDomain(std::string domain) {
+  domain_ = std::move(domain);
+  return *this;
+}
+
+OpSchema& OpSchema::SetDomain(const char* domain) {
+  return SetDomain(std::string(domain));
+}
+
+OpSchema& OpSchema::Attr(Attribute attr) {
+  auto name = attr.name; // copy name so we can move attr in the next line
+  attributes_.emplace(std::move(name), std::move(attr));
+  return *this;
+}
+
+OpSchema& OpSchema::Attr(std::string name, std::string description, AttributeProto::AttributeType type, bool required) {
+  Attr(Attribute{std::move(name), std::move(description), type, required});
+  return *this;
+}
+
+OpSchema& OpSchema::Attr(const char* name, const char* description, AttributeProto::AttributeType type, bool required) {
+  return Attr(std::string(name), std::string(description), type, required);
+}
+
+OpSchema& OpSchema::Attr(
+    const char* name,
+    const char* description,
+    AttributeProto::AttributeType type,
+    const char* defaultValue) {
+  return Attr(std::string(name), std::string(description), type, std::string(defaultValue));
+}
+
+#define ATTR_SETTER_WITH_SINGLE_VALUE(type, field, attrtype)                                                           \
+  OpSchema& OpSchema::Attr(                                                                                            \
+      std::string name, std::string description, AttributeProto::AttributeType attr_type, const type& default_value) { \
+    if ((attrtype) != attr_type) {                                                                                     \
+      fail_schema("Attribute specification type mismatch.");                                                           \
+    }                                                                                                                  \
+    AttributeProto a;                                                                                                  \
+    a.set_name(name);                                                                                                  \
+    a.set_##field(default_value);                                                                                      \
+    a.set_type(attr_type);                                                                                             \
+    Attr(Attribute(std::move(name), std::move(description), std::move(a)));                                            \
+    return *this;                                                                                                      \
+  }                                                                                                                    \
+  OpSchema& OpSchema::Attr(                                                                                            \
+      const char* name, const char* description, AttributeProto::AttributeType attr_type, const type& default_value) { \
+    return Attr(std::string(name), std::string(description), attr_type, default_value);                                \
+  }
+
+#define ATTR_SETTER_WITH_LIST_VALUE(type, field, attrtype)                  \
+  OpSchema& OpSchema::Attr(                                                 \
+      std::string name,                                                     \
+      std::string description,                                              \
+      AttributeProto::AttributeType attr_type,                              \
+      const std::vector<type>& default_value) {                             \
+    if ((attrtype) != attr_type) {                                          \
+      fail_schema("Attribute specification type mismatch.");                \
+    }                                                                       \
+    AttributeProto a;                                                       \
+    a.set_name(name);                                                       \
+    a.set_type(attr_type);                                                  \
+    for (const auto& v : default_value) {                                   \
+      a.add_##field(v);                                                     \
+    }                                                                       \
+    Attr(Attribute(std::move(name), std::move(description), std::move(a))); \
+    return *this;                                                           \
+  }
+
+#define ATTR_SETTER_WITH_SINGLE_COMPLEXVALUE(type, field, attrtype)                                                    \
+  OpSchema& OpSchema::Attr(                                                                                            \
+      std::string name, std::string description, AttributeProto::AttributeType attr_type, const type& default_value) { \
+    if ((attrtype) != attr_type) {                                                                                     \
+      fail_schema("Attribute specification type mismatch.");                                                           \
+    }                                                                                                                  \
+    AttributeProto a;                                                                                                  \
+    a.set_name(name);                                                                                                  \
+    *(a.mutable_##field()) = default_value;                                                                            \
+    a.set_type(attr_type);                                                                                             \
+    Attr(Attribute(std::move(name), std::move(description), a));                                                       \
+    return *this;                                                                                                      \
+  }
+
+#define ATTR_SETTER_WITH_LIST_COMPLEXVALUE(type, field, attrtype)           \
+  OpSchema& OpSchema::Attr(                                                 \
+      std::string name,                                                     \
+      std::string description,                                              \
+      AttributeProto::AttributeType attr_type,                              \
+      const std::vector<type>& default_value) {                             \
+    if ((attrtype) != attr_type) {                                          \
+      fail_schema("Attribute specification type mismatch.");                \
+    }                                                                       \
+    AttributeProto a;                                                       \
+    a.set_name(name);                                                       \
+    a.set_type(attr_type);                                                  \
+    for (const auto& v : default_value) {                                   \
+      *(a.add_##field()) = v;                                               \
+    }                                                                       \
+    Attr(Attribute(std::move(name), std::move(description), std::move(a))); \
+    return *this;                                                           \
+  }
+
+ATTR_SETTER_WITH_SINGLE_VALUE(int64_t, i, AttributeProto::INT)
+ATTR_SETTER_WITH_SINGLE_VALUE(float, f, AttributeProto::FLOAT)
+ATTR_SETTER_WITH_SINGLE_VALUE(std::string, s, AttributeProto::STRING)
+ATTR_SETTER_WITH_SINGLE_COMPLEXVALUE(TensorProto, t, AttributeProto::TENSOR)
+ATTR_SETTER_WITH_SINGLE_COMPLEXVALUE(GraphProto, g, AttributeProto::GRAPH)
+ATTR_SETTER_WITH_SINGLE_COMPLEXVALUE(TypeProto, tp, AttributeProto::TYPE_PROTO)
+ATTR_SETTER_WITH_LIST_VALUE(int64_t, ints, AttributeProto::INTS)
+ATTR_SETTER_WITH_LIST_VALUE(float, floats, AttributeProto::FLOATS)
+ATTR_SETTER_WITH_LIST_COMPLEXVALUE(std::string, strings, AttributeProto::STRINGS)
+ATTR_SETTER_WITH_LIST_COMPLEXVALUE(TensorProto, tensors, AttributeProto::TENSORS)
+ATTR_SETTER_WITH_LIST_COMPLEXVALUE(GraphProto, graphs, AttributeProto::GRAPHS)
+ATTR_SETTER_WITH_LIST_COMPLEXVALUE(TypeProto, type_protos, AttributeProto::TYPE_PROTOS)
+
+OpSchema& OpSchema::AllowUncheckedAttributes() {
+  allows_unchecked_attributes_ = true;
+  return *this;
+}
+
+OpSchema& OpSchema::Input(int n, FormalParameter formal_parameter) {
+  if (inputs_.size() <= static_cast<size_t>(n)) {
+    inputs_.resize(n + 1);
+  }
+  inputs_[n] = std::move(formal_parameter);
+  return *this;
+}
+
+OpSchema& OpSchema::Input(
+    int n,
+    std::string name,
+    const std::string& description,
+    std::string type_str,
+    OpSchema::FormalParameterOption param_option,
+    bool is_homogeneous,
+    int min_arity,
+    DifferentiationCategory differentiation_category) {
+  return Input(
+      n,
+      FormalParameter(
+          std::move(name),
+#ifndef __ONNX_NO_DOC_STRINGS
+          description,
+#else
+          std::string(),
+#endif
+          std::move(type_str),
+          param_option,
+          is_homogeneous,
+          min_arity,
+          differentiation_category));
+}
+
+OpSchema& OpSchema::Input(
+    int n,
+    const char* name,
+    const char* description,
+    const char* type_str,
+    FormalParameterOption param_option,
+    bool is_homogeneous,
+    int min_arity,
+    DifferentiationCategory differentiation_category) {
+  return Input(
+      n,
+      std::string(name),
+#ifndef __ONNX_NO_DOC_STRINGS
+      std::string(description),
+#else
+      std::string(),
+#endif
+      std::string(type_str),
+      param_option,
+      is_homogeneous,
+      min_arity,
+      differentiation_category);
+}
+
+OpSchema& OpSchema::Output(int n, FormalParameter formal_parameter) {
+  if (outputs_.size() <= static_cast<size_t>(n)) {
+    outputs_.resize(n + 1);
+  }
+  outputs_[n] = std::move(formal_parameter);
+  return *this;
+}
+
+OpSchema& OpSchema::Output(
+    int n,
+    std::string name,
+    const std::string& description,
+    std::string type_str,
+    OpSchema::FormalParameterOption param_option,
+    bool is_homogeneous,
+    int min_arity,
+    DifferentiationCategory differentiation_category) {
+  return Output(
+      n,
+      FormalParameter(
+          std::move(name),
+#ifndef __ONNX_NO_DOC_STRINGS
+          description,
+#else
+          std::string(),
+#endif
+          std::move(type_str),
+          param_option,
+          is_homogeneous,
+          min_arity,
+          differentiation_category));
+}
+
+OpSchema& OpSchema::Output(
+    int n,
+    const char* name,
+    const char* description,
+    const char* type_str,
+    FormalParameterOption param_option,
+    bool is_homogeneous,
+    int min_arity,
+    DifferentiationCategory differentiation_category) {
+  return Output(
+      n,
+      std::string(name),
+#ifndef __ONNX_NO_DOC_STRINGS
+      std::string(description),
+#else
+      std::string(),
+#endif
+      std::string(type_str),
+      param_option,
+      is_homogeneous,
+      min_arity,
+      differentiation_category);
+}
+
+OpSchema&
+OpSchema::TypeConstraint(std::string type_str, std::vector<std::string> constraints, std::string description) {
+  if (type_constraints_.end() != type_constraints_.find(type_str)) {
+    fail_schema("Duplicate type constraint name");
+  }
+
+  DataTypeSet d;
+  for (const auto& t : constraints) {
+    d.insert(Utils::DataTypeUtils::ToType(t));
+  }
+  type_constraints_.emplace(type_str, std::make_pair(d, description));
+  type_constraint_params_.emplace_back(std::move(type_str), std::move(constraints), std::move(description));
+  return *this;
+}
+
+OpSchema& OpSchema::TypeConstraint(
+    const char* type_str,
+    std::initializer_list<const char*> constraints,
+    const char* description) {
+  std::vector<std::string> constraints_vector;
+  constraints_vector.reserve(constraints.size());
+  for (const auto* const constraint : constraints) {
+    constraints_vector.emplace_back(constraint);
+  }
+
+  return TypeConstraint(std::string(type_str), constraints_vector, std::string(description));
+}
+
+void OpSchema::ParseAndSetTypes(
+    /*out*/ std::vector<OpSchema::FormalParameter>* formal_parameters) {
+  for (auto& formal_parameter : *formal_parameters) {
+    const auto& type = formal_parameter.GetTypeStr();
+    DataTypeSet allowed_types;
+    if (auto it = type_constraints_.find(type); it != type_constraints_.end()) {
+      auto& [types, description] = it->second;
+      allowed_types = types;
+    } else {
+      allowed_types.emplace(Utils::DataTypeUtils::ToType(type));
+    }
+
+    formal_parameter.MutableTypes() = allowed_types;
+  }
+}
+
+OpSchema& OpSchema::SetContextDependentFunctionBodyBuilder(
+    ContextDependentFunctionBodyBuilder functionBuilder,
+    int opset_version) {
+  if (opset_version == OpSchema::kUninitializedSinceVersion && since_version_ != OpSchema::kUninitializedSinceVersion) {
+    opset_version_to_function_builder_[since_version_] = std::move(functionBuilder);
+  } else {
+    opset_version_to_function_builder_[opset_version] = std::move(functionBuilder);
+  }
+  return *this;
+}
+
+bool OpSchema::BuildContextDependentFunction(
+    const FunctionBodyBuildContext& ctx,
+    FunctionProto& function_proto,
+    int requested_opset_version) const {
+  if (requested_opset_version == OpSchema::kUninitializedSinceVersion)
+    requested_opset_version = since_version_;
+
+  auto it = opset_version_to_function_builder_.upper_bound(requested_opset_version);
+  if (opset_version_to_function_builder_.empty() || it == opset_version_to_function_builder_.begin()) {
+    ONNX_THROW_EX(
+        std::out_of_range(
+            std::string("Cannot find a function builder that satisfies the requested opset version: op_type = ") +
+            this->name_ + ", opset_version = " + std::to_string(requested_opset_version) + "."));
+  } else {
+    --it;
+    const ContextDependentFunctionBodyBuilder& body_builder = it->second;
+    if (!body_builder(ctx, *this, function_proto)) {
+      return false;
+    }
+    //// default opset import may have been added to function_proto by OpSchema::BuildFunction
+    //// we need to update its version with the specified opset_version
+    UpdateFunctionProtoOpsetImportVersion(function_proto, requested_opset_version);
+    ValidateReferencedOpsInFunction(&function_proto, requested_opset_version, it->first);
+    return true;
+  }
+}
+
+// A function of a schema (either stored in opset_version_to_function_body_ or built with one of function builder
+// in opset_version_to_function_builder_) has predefined opset_imports. Before returning the function, we shall
+// update the predefined opset_imports so that it is consistent with the requested version.
+// Note that this call only update opset_import of the default domain.
+// TODO(ONNX): extend this call to work for no-default domains.
+void OpSchema::UpdateFunctionProtoOpsetImportVersion(FunctionProto& function_proto, int requested_opset_version) const {
+  bool opset_import_exist = false;
+  for (int i = 0; i < function_proto.opset_import_size(); i++) {
+    auto* schema_opset = function_proto.mutable_opset_import(i);
+    if (schema_opset->domain() == domain_) {
+      if (schema_opset->version() != requested_opset_version) {
+        schema_opset->set_version(requested_opset_version);
+      }
+      opset_import_exist = true;
+    }
+  }
+
+  if (!opset_import_exist) {
+    auto* schema_opset = function_proto.mutable_opset_import()->Add();
+    schema_opset->set_domain(domain_);
+    schema_opset->set_version(requested_opset_version);
+  }
+}
+
+OpSchema& OpSchema::FunctionBody(const char* func_body, int opset_version) {
+  if (opset_version == OpSchema::kUninitializedSinceVersion && since_version_ != OpSchema::kUninitializedSinceVersion) {
+    opset_version = since_version_;
+  }
+  auto function_proto = std::make_shared<FunctionProto>();
+  OnnxParser parser(func_body);
+  auto status = parser.Parse(*function_proto->mutable_node());
+  if (!status.IsOK())
+    ONNX_THROW_EX(std::logic_error("Error parsing function body:" + status.ErrorMessage()));
+  if (!parser.EndOfInput())
+    ONNX_THROW_EX(std::logic_error("Extra unparsed input unexpected."));
+
+  // opset import may have been set
+  // we may need to update its version with the specified opset_version
+  UpdateFunctionProtoOpsetImportVersion(*function_proto, opset_version);
+
+  opset_version_to_function_body_.emplace(opset_version, function_proto);
+  return *this;
+}
+
+OpSchema& OpSchema::FunctionBody(const std::vector<NodeProto>& func_nodes, int opset_version) {
+  if (opset_version == OpSchema::kUninitializedSinceVersion && since_version_ != OpSchema::kUninitializedSinceVersion) {
+    opset_version = since_version_;
+  }
+  auto function_proto = std::make_shared<FunctionProto>();
+  for (const auto& node : func_nodes) {
+    auto* new_node = function_proto->add_node();
+    new_node->CopyFrom(node);
+  }
+
+  // opset import may have been set
+  // we may need to update its version with the specified opset_version
+  UpdateFunctionProtoOpsetImportVersion(*function_proto, opset_version);
+  opset_version_to_function_body_.emplace(opset_version, std::move(function_proto));
+  return *this;
+}
+
+OpSchema& OpSchema::FunctionBody(
+    const std::vector<NodeProto>& func_nodes,
+    const std::vector<OperatorSetIdProto>& relied_opsets,
+    int opset_version) {
+  if (opset_version == OpSchema::kUninitializedSinceVersion && since_version_ != OpSchema::kUninitializedSinceVersion) {
+    opset_version = since_version_;
+  }
+
+  auto function_proto = std::make_shared<FunctionProto>();
+  for (const auto& relied_opset : relied_opsets) {
+    *(function_proto->mutable_opset_import()->Add()) = relied_opset;
+  }
+
+  for (const auto& node : func_nodes) {
+    auto* new_node = function_proto->add_node();
+    new_node->CopyFrom(node);
+  }
+  // opset import may have been set
+  // we may need to update its version with the specified opset_version
+  UpdateFunctionProtoOpsetImportVersion(*function_proto, opset_version);
+  opset_version_to_function_body_.emplace(opset_version, std::move(function_proto));
+  return *this;
+}
+
+const FunctionProto* OpSchema::GetFunction(int requested_opset_version, bool validate) const {
+  if (opset_version_to_function_body_.empty())
+    return nullptr;
+  // Return latest FunctionProto when opset version request is not set
+  if (requested_opset_version == OpSchema::kUninitializedSinceVersion) {
+    return opset_version_to_function_body_.rbegin()->second.get();
+  }
+  auto it = opset_version_to_function_body_.upper_bound(requested_opset_version);
+  if (it != opset_version_to_function_body_.begin()) {
+    --it;
+    const auto& [function_since_version, func_ptr] = *it;
+    const FunctionProto* function = func_ptr.get();
+    if (!validate || ValidateReferencedOpsInFunction(function, requested_opset_version, function_since_version)) {
+      return function;
+    }
+  }
+  return nullptr;
+}
+
+// when requesting a function at loading time,
+// requested_opset_version does not have to be the same as function_since_version.
+// When they are not the same, it is necessary to verify that ops used to define the function
+// are not updated between function_since_version and requested_opset_version (include requested_opset_version).
+// this call only validate ops in the default domain.
+// TODO(ONNX): validate ops in other domains.
+bool OpSchema::ValidateReferencedOpsInFunction(
+    const FunctionProto* function,
+    int requested_opset_version,
+    int function_since_version,
+    std::unordered_set<std::string>* updated_ops) const {
+  bool all_ops_are_invalid = true;
+  if (requested_opset_version == function_since_version) {
+    return all_ops_are_invalid;
+  }
+  for (const auto& node : function->node()) {
+    if (node.domain().empty() || node.domain() == "ai.onnx") {
+      const OpSchema* op1 =
+          OpSchemaRegistry::Instance()->GetSchema(node.op_type(), requested_opset_version, node.domain());
+      const OpSchema* op2 =
+          OpSchemaRegistry::Instance()->GetSchema(node.op_type(), function_since_version, node.domain());
+      if (op1 != op2) {
+        if (updated_ops) {
+          updated_ops->insert(node.op_type());
+        }
+        all_ops_are_invalid = false;
+      }
+    }
+  }
+
+  return all_ops_are_invalid;
+}
+
+OpSchema& OpSchema::FillUsing(const std::function<void(OpSchema&)>& populator) {
+  if (populator) {
+    populator(*this);
+  }
+  return *this;
+}
+
+void OpSchema::BuildFunction(FunctionProto& function_body) const {
+  function_body.set_name(this->name_);
+  function_body.set_doc_string(this->doc_);
+  function_body.set_domain(this->domain_);
+  for (const auto& i : inputs_) {
+    function_body.add_input(i.GetName());
+  }
+  for (const auto& o : outputs_) {
+    function_body.add_output(o.GetName());
+  }
+  for (const auto& a : attributes_) {
+    function_body.add_attribute(a.first);
+  }
+
+  // In a typical onnx function where the function and all the
+  // ops in function body belong to the same domain we implicitly add
+  // {domain_, since_version_} to function opset imports if it is not already added.
+  // This is simply for convienince. If any of the function body ops do not belong to same
+  // domain as function itself, then the function author needs to explicitly add all the relevant
+  // opset imports.
+  if (function_body.opset_import().empty()) {
+    auto* schema_opset = function_body.mutable_opset_import()->Add();
+    schema_opset->set_domain(domain_);
+    schema_opset->set_version(since_version_);
+  }
+}
+
+const std::vector<std::string>& OpSchema::numeric_types_for_math_reduction_ir9() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::BFLOAT16,
+       TensorProto::FLOAT8E4M3FN,
+       TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2,
+       TensorProto::FLOAT8E5M2FNUZ});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::numeric_types_for_math_reduction_ir4() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::BFLOAT16});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::numeric_types_for_math_reduction() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types_ir12() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,        TensorProto::UINT16,         TensorProto::UINT32,     TensorProto::UINT64,
+       TensorProto::INT8,         TensorProto::INT16,          TensorProto::INT32,      TensorProto::INT64,
+       TensorProto::FLOAT16,      TensorProto::FLOAT,          TensorProto::DOUBLE,     TensorProto::BFLOAT16,
+       TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ, TensorProto::FLOAT8E5M2, TensorProto::FLOAT8E5M2FNUZ,
+       TensorProto::UINT4,        TensorProto::INT4,           TensorProto::FLOAT4E2M1, TensorProto::FLOAT8E8M0});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types_ir13() {
+  static const auto v = types::Tensors({TensorProto::UINT8,        TensorProto::UINT16,
+                                        TensorProto::UINT32,       TensorProto::UINT64,
+                                        TensorProto::INT8,         TensorProto::INT16,
+                                        TensorProto::INT32,        TensorProto::INT64,
+                                        TensorProto::FLOAT16,      TensorProto::FLOAT,
+                                        TensorProto::DOUBLE,       TensorProto::BFLOAT16,
+                                        TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ,
+                                        TensorProto::FLOAT8E5M2,   TensorProto::FLOAT8E5M2FNUZ,
+                                        TensorProto::UINT4,        TensorProto::INT4,
+                                        TensorProto::FLOAT4E2M1,   TensorProto::FLOAT8E8M0,
+                                        TensorProto::UINT2,        TensorProto::INT2});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types_ir11() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,
+       TensorProto::UINT16,
+       TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT8,
+       TensorProto::INT16,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::BFLOAT16,
+       TensorProto::FLOAT8E4M3FN,
+       TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2,
+       TensorProto::FLOAT8E5M2FNUZ,
+       TensorProto::UINT4,
+       TensorProto::INT4,
+       TensorProto::FLOAT4E2M1});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types_ir10() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,
+       TensorProto::UINT16,
+       TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT8,
+       TensorProto::INT16,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::BFLOAT16,
+       TensorProto::FLOAT8E4M3FN,
+       TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2,
+       TensorProto::FLOAT8E5M2FNUZ,
+       TensorProto::UINT4,
+       TensorProto::INT4});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types_ir9() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,
+       TensorProto::UINT16,
+       TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT8,
+       TensorProto::INT16,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::BFLOAT16,
+       TensorProto::FLOAT8E4M3FN,
+       TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2,
+       TensorProto::FLOAT8E5M2FNUZ});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types_ir4() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,
+       TensorProto::UINT16,
+       TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT8,
+       TensorProto::INT16,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::BFLOAT16});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_types() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,
+       TensorProto::UINT16,
+       TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT8,
+       TensorProto::INT16,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_numeric_sequence_types() {
+  static const auto v = types::Sequence(
+      types::Tensors(
+          {TensorProto::UINT8,
+           TensorProto::UINT16,
+           TensorProto::UINT32,
+           TensorProto::UINT64,
+           TensorProto::INT8,
+           TensorProto::INT16,
+           TensorProto::INT32,
+           TensorProto::INT64,
+           TensorProto::FLOAT16,
+           TensorProto::FLOAT,
+           TensorProto::DOUBLE}));
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,
+       TensorProto::UINT16,
+       TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT8,
+       TensorProto::INT16,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::STRING,
+       TensorProto::BOOL,
+       TensorProto::COMPLEX64,
+       TensorProto::COMPLEX128});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types_ir4() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,
+       TensorProto::UINT16,
+       TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT8,
+       TensorProto::INT16,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::BFLOAT16,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::STRING,
+       TensorProto::BOOL,
+       TensorProto::COMPLEX64,
+       TensorProto::COMPLEX128});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_non_complex_numeric_types_plus_bool_ir4() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,
+       TensorProto::UINT16,
+       TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT8,
+       TensorProto::INT16,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::BFLOAT16,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::BOOL});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_float_types_ir4() {
+  static const auto v =
+      types::Tensors({TensorProto::BFLOAT16, TensorProto::FLOAT16, TensorProto::FLOAT, TensorProto::DOUBLE});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_float_types_plus_Xint8_ir4() {
+  static const auto v = types::Tensors(
+      {TensorProto::BFLOAT16,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::INT8,
+       TensorProto::UINT8});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_float_types_ir9() {
+  static const auto v = types::Tensors(
+      {TensorProto::BFLOAT16,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::FLOAT8E4M3FN,
+       TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2,
+       TensorProto::FLOAT8E5M2FNUZ});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types_ir9() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,        TensorProto::UINT16,         TensorProto::UINT32,     TensorProto::UINT64,
+       TensorProto::INT8,         TensorProto::INT16,          TensorProto::INT32,      TensorProto::INT64,
+       TensorProto::BFLOAT16,     TensorProto::FLOAT16,        TensorProto::FLOAT,      TensorProto::DOUBLE,
+       TensorProto::STRING,       TensorProto::BOOL,           TensorProto::COMPLEX64,  TensorProto::COMPLEX128,
+       TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ, TensorProto::FLOAT8E5M2, TensorProto::FLOAT8E5M2FNUZ});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types_ir10() {
+  static const auto v =
+      types::Tensors({TensorProto::UINT8,      TensorProto::UINT16,         TensorProto::UINT32,
+                      TensorProto::UINT64,     TensorProto::INT8,           TensorProto::INT16,
+                      TensorProto::INT32,      TensorProto::INT64,          TensorProto::BFLOAT16,
+                      TensorProto::FLOAT16,    TensorProto::FLOAT,          TensorProto::DOUBLE,
+                      TensorProto::STRING,     TensorProto::BOOL,           TensorProto::COMPLEX64,
+                      TensorProto::COMPLEX128, TensorProto::FLOAT8E4M3FN,   TensorProto::FLOAT8E4M3FNUZ,
+                      TensorProto::FLOAT8E5M2, TensorProto::FLOAT8E5M2FNUZ, TensorProto::UINT4,
+                      TensorProto::INT4});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_non_complex_tensor_types_ir10() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,      TensorProto::UINT16,         TensorProto::UINT32,       TensorProto::UINT64,
+       TensorProto::INT8,       TensorProto::INT16,          TensorProto::INT32,        TensorProto::INT64,
+       TensorProto::BFLOAT16,   TensorProto::FLOAT16,        TensorProto::FLOAT,        TensorProto::DOUBLE,
+       TensorProto::STRING,     TensorProto::BOOL,           TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2, TensorProto::FLOAT8E5M2FNUZ, TensorProto::UINT4,        TensorProto::INT4});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types_ir11() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,        TensorProto::UINT16,         TensorProto::UINT32,     TensorProto::UINT64,
+       TensorProto::INT8,         TensorProto::INT16,          TensorProto::INT32,      TensorProto::INT64,
+       TensorProto::BFLOAT16,     TensorProto::FLOAT16,        TensorProto::FLOAT,      TensorProto::DOUBLE,
+       TensorProto::STRING,       TensorProto::BOOL,           TensorProto::COMPLEX64,  TensorProto::COMPLEX128,
+       TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ, TensorProto::FLOAT8E5M2, TensorProto::FLOAT8E5M2FNUZ,
+       TensorProto::UINT4,        TensorProto::INT4,           TensorProto::FLOAT4E2M1});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_non_complex_tensor_types_ir11() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,      TensorProto::UINT16,         TensorProto::UINT32,       TensorProto::UINT64,
+       TensorProto::INT8,       TensorProto::INT16,          TensorProto::INT32,        TensorProto::INT64,
+       TensorProto::BFLOAT16,   TensorProto::FLOAT16,        TensorProto::FLOAT,        TensorProto::DOUBLE,
+       TensorProto::STRING,     TensorProto::BOOL,           TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2, TensorProto::FLOAT8E5M2FNUZ, TensorProto::UINT4,        TensorProto::INT4,
+       TensorProto::FLOAT4E2M1});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types_ir12() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,        TensorProto::UINT16,         TensorProto::UINT32,     TensorProto::UINT64,
+       TensorProto::INT8,         TensorProto::INT16,          TensorProto::INT32,      TensorProto::INT64,
+       TensorProto::BFLOAT16,     TensorProto::FLOAT16,        TensorProto::FLOAT,      TensorProto::DOUBLE,
+       TensorProto::STRING,       TensorProto::BOOL,           TensorProto::COMPLEX64,  TensorProto::COMPLEX128,
+       TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ, TensorProto::FLOAT8E5M2, TensorProto::FLOAT8E5M2FNUZ,
+       TensorProto::UINT4,        TensorProto::INT4,           TensorProto::FLOAT4E2M1, TensorProto::FLOAT8E8M0});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_non_complex_tensor_types_ir12() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,      TensorProto::UINT16,         TensorProto::UINT32,       TensorProto::UINT64,
+       TensorProto::INT8,       TensorProto::INT16,          TensorProto::INT32,        TensorProto::INT64,
+       TensorProto::BFLOAT16,   TensorProto::FLOAT16,        TensorProto::FLOAT,        TensorProto::DOUBLE,
+       TensorProto::STRING,     TensorProto::BOOL,           TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2, TensorProto::FLOAT8E5M2FNUZ, TensorProto::UINT4,        TensorProto::INT4,
+       TensorProto::FLOAT4E2M1, TensorProto::FLOAT8E8M0});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_types_ir13() {
+  static const auto v = types::Tensors({TensorProto::UINT8,        TensorProto::UINT16,
+                                        TensorProto::UINT32,       TensorProto::UINT64,
+                                        TensorProto::INT8,         TensorProto::INT16,
+                                        TensorProto::INT32,        TensorProto::INT64,
+                                        TensorProto::BFLOAT16,     TensorProto::FLOAT16,
+                                        TensorProto::FLOAT,        TensorProto::DOUBLE,
+                                        TensorProto::STRING,       TensorProto::BOOL,
+                                        TensorProto::COMPLEX64,    TensorProto::COMPLEX128,
+                                        TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ,
+                                        TensorProto::FLOAT8E5M2,   TensorProto::FLOAT8E5M2FNUZ,
+                                        TensorProto::UINT4,        TensorProto::INT4,
+                                        TensorProto::FLOAT4E2M1,   TensorProto::FLOAT8E8M0,
+                                        TensorProto::UINT2,        TensorProto::INT2});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_non_complex_tensor_types_ir13() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,      TensorProto::UINT16,         TensorProto::UINT32,       TensorProto::UINT64,
+       TensorProto::INT8,       TensorProto::INT16,          TensorProto::INT32,        TensorProto::INT64,
+       TensorProto::BFLOAT16,   TensorProto::FLOAT16,        TensorProto::FLOAT,        TensorProto::DOUBLE,
+       TensorProto::STRING,     TensorProto::BOOL,           TensorProto::FLOAT8E4M3FN, TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2, TensorProto::FLOAT8E5M2FNUZ, TensorProto::UINT4,        TensorProto::INT4,
+       TensorProto::FLOAT4E2M1, TensorProto::FLOAT8E8M0,     TensorProto::UINT2,        TensorProto::INT2});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_non_string_tensor_types_ir13() {
+  static const auto v = types::Tensors(
+      {TensorProto::UINT8,
+       TensorProto::UINT16,
+       TensorProto::UINT32,
+       TensorProto::UINT64,
+       TensorProto::INT8,
+       TensorProto::INT16,
+       TensorProto::INT32,
+       TensorProto::INT64,
+       TensorProto::BFLOAT16,
+       TensorProto::FLOAT16,
+       TensorProto::FLOAT,
+       TensorProto::DOUBLE,
+       TensorProto::BOOL,
+       TensorProto::COMPLEX64,
+       TensorProto::COMPLEX128,
+       TensorProto::FLOAT8E4M3FN,
+       TensorProto::FLOAT8E4M3FNUZ,
+       TensorProto::FLOAT8E5M2,
+       TensorProto::FLOAT8E5M2FNUZ,
+       TensorProto::UINT4,
+       TensorProto::INT4,
+       TensorProto::FLOAT4E2M1,
+       TensorProto::FLOAT8E8M0,
+       TensorProto::UINT2,
+       TensorProto::INT2});
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types() {
+  static const auto v = types::Sequence(all_tensor_types());
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types_ir4() {
+  static const auto v = types::Sequence(all_tensor_types_ir4());
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types_ir9() {
+  static const auto v = types::Sequence(all_tensor_types_ir9());
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types_ir10() {
+  static const auto v = types::Sequence(all_tensor_types_ir10());
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types_ir11() {
+  static const auto v = types::Sequence(all_tensor_types_ir11());
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types_ir12() {
+  static const auto v = types::Sequence(all_tensor_types_ir12());
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_tensor_sequence_types_ir13() {
+  static const auto v = types::Sequence(all_tensor_types_ir13());
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types() {
+  static const auto v =
+      types::Concat(types::Optional(all_tensor_sequence_types()), types::Optional(all_tensor_types()));
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types_ir4() {
+  static const auto v =
+      types::Concat(types::Optional(all_tensor_sequence_types_ir4()), types::Optional(all_tensor_types_ir4()));
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types_ir9() {
+  static const auto v =
+      types::Concat(types::Optional(all_tensor_sequence_types_ir4()), types::Optional(all_tensor_types_ir9()));
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types_ir10() {
+  static const auto v =
+      types::Concat(types::Optional(all_tensor_sequence_types_ir4()), types::Optional(all_tensor_types_ir10()));
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types_ir11() {
+  static const auto v =
+      types::Concat(types::Optional(all_tensor_sequence_types_ir4()), types::Optional(all_tensor_types_ir11()));
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types_ir12() {
+  static const auto v =
+      types::Concat(types::Optional(all_tensor_sequence_types_ir4()), types::Optional(all_tensor_types_ir12()));
+  return v;
+}
+
+const std::vector<std::string>& OpSchema::all_optional_types_ir13() {
+  static const auto v =
+      types::Concat(types::Optional(all_tensor_sequence_types_ir4()), types::Optional(all_tensor_types_ir13()));
+  return v;
+}
+
+void OpSchema::Finalize() {
+#define ENFORCE(x)                                                                                      \
+  do {                                                                                                  \
+    if (!(x))                                                                                           \
+      ONNX_THROW_EX(std::logic_error("ONNX Schema " + name_ + ": failed validating the check: " + #x)); \
+  } while (0)
+
+  // Calculate min/max number of inputs.
+  // <Min number of inputs> = <number of "single" inputs> + <number of
+  // "optional" but not trailing inputs>. <Max number of inputs> = <number of
+  // all inputs or std::numeric_limits<int>::max() (if the last input is
+  // variadic).
+
+  max_input_ = 0;
+  min_input_ = 0;
+  min_output_ = 0;
+  max_output_ = 0;
+
+  // Flag indicates whether an optional input is trailing one (there's no single
+  // or variadic input behind).
+  for (size_t i = 0; i < inputs_.size(); ++i) {
+    switch (inputs_[i].GetOption()) {
+      case OpSchema::Single:
+        ++max_input_;
+        min_input_ = max_input_;
+        break;
+      case OpSchema::Optional:
+        ++max_input_;
+        break;
+      case OpSchema::Variadic:
+        // Only last input formal parameter could be variadic.
+        ENFORCE((inputs_.size() - 1) == i);
+        min_input_ = max_input_ + inputs_[i].GetMinArity();
+        max_input_ = std::numeric_limits<int>::max();
+        break;
+    }
+  }
+
+  // Calculate min/max number of outputs.
+  for (size_t i = 0; i < outputs_.size(); ++i) {
+    switch (outputs_[i].GetOption()) {
+      case OpSchema::Single:
+        ++max_output_;
+        min_output_ = max_output_;
+        break;
+      case OpSchema::Optional:
+        ++max_output_;
+        break;
+      case OpSchema::Variadic:
+        // Only last output formal parameter could be variadic.
+        ENFORCE((outputs_.size() - 1) == i);
+        min_output_ = max_output_ + outputs_[i].GetMinArity();
+        max_output_ = std::numeric_limits<int>::max();
+        break;
+    }
+  }
+
+  // all inputs and outputs have names
+  for (const auto& it : inputs_) {
+    ENFORCE(!(it.GetName().empty()));
+  }
+  for (const auto& it : outputs_) {
+    ENFORCE(!(it.GetName().empty()));
+  }
+
+  ParseAndSetTypes(&inputs_);
+  ParseAndSetTypes(&outputs_);
+
+  for (auto& [_, func_body] : opset_version_to_function_body_) {
+    BuildFunction(*func_body);
+  }
+}
+
+OpSchema::NodeDeterminism OpSchema::GetNodeDeterminism() const {
+  if (node_determinism_ == NodeDeterminism::Unknown) {
+    for (const auto& [_, attr] : attributes()) {
+      switch (attr.type) {
+        case AttributeProto::GRAPH:
+        case AttributeProto::GRAPHS:
+          return NodeDeterminism::NonDeterministic;
+        default:
+          break;
+      }
+    }
+
+    if (HasContextDependentFunction()) {
+      return NodeDeterminism::Unknown;
+    } else if (const FunctionProto* func_proto = GetFunction(); func_proto) {
+      const OpSchemaRegistry& reg = *OpSchemaRegistry::Instance();
+      std::unordered_map<std::string, int64_t> domain_to_opset_version;
+      for (const auto& opset : func_proto->opset_import()) {
+        domain_to_opset_version[opset.domain()] = opset.version();
+      }
+      for (const NodeProto& n : func_proto->node()) {
+        const int64_t opset = domain_to_opset_version[n.domain()];
+        const OpSchema* sch = reg.GetSchema(n.op_type(), static_cast<int>(opset), n.domain());
+        if (!sch) {
+          return NodeDeterminism::Unknown;
+        }
+        switch (sch->GetNodeDeterminism()) {
+          case NodeDeterminism::NonDeterministic:
+            return NodeDeterminism::NonDeterministic;
+          case NodeDeterminism::Unknown:
+            return NodeDeterminism::Unknown;
+          default:
+            break;
+        }
+      }
+    }
+    return NodeDeterminism::Deterministic;
+  }
+  return node_determinism_;
+}
+
+OpSchema& OpSchema::SetNodeDeterminism(NodeDeterminism node_determinism) {
+  this->node_determinism_ = node_determinism;
+  return *this;
+}
+
+std::ostream& operator<<(std::ostream& out, const OpSchema& schema) {
+  if (!schema.attributes_.empty()) {
+    out << "Attributes:" << '\n';
+    for (const auto& [_, attr] : schema.attributes_) {
+      out << "  " << attr.name << " : " << attr.description << '\n';
+    }
+  }
+  if (schema.max_input_ > 0) {
+    out << "Inputs:" << '\n';
+    if (!schema.inputs_.empty()) {
+      for (size_t i = 0; i < schema.inputs_.size(); ++i) {
+        const auto& p = schema.inputs_[i];
+        const auto& name = p.GetName();
+        const auto& description = p.GetDescription();
+        const auto& type_str = p.GetTypeStr();
+        out << "  " << i << ", " << (!name.empty() ? name : "(unnamed)") << " : "
+            << (!description.empty() ? description : "(no doc)") << " : "
+            << (!type_str.empty() ? type_str : "(no type)") << '\n';
+      }
+    } else {
+      out << "  (no explicit description available)" << '\n';
+    }
+  }
+  if (schema.max_output_ > 0) {
+    out << "Outputs:" << '\n';
+    if (!schema.outputs_.empty()) {
+      for (size_t i = 0; i < schema.outputs_.size(); ++i) {
+        const auto& p = schema.outputs_[i];
+        const auto& name = p.GetName();
+        const auto& description = p.GetDescription();
+        const auto& type_str = p.GetTypeStr();
+        out << "  " << i << ", " << (!name.empty() ? name : "(unnamed)") << " : "
+            << (!description.empty() ? description : "(no doc)") << " : "
+            << (!type_str.empty() ? type_str : "(no type)") << '\n';
+      }
+    } else {
+      out << "  (no explicit description available)" << '\n';
+    }
+  }
+  out << '\n';
+  if (schema.doc()) {
+    out << schema.doc();
+  } else {
+    out << "(no documentation yet)" << '\n';
+  }
+  out << '\n';
+  if (schema.line_) {
+    out << "Defined at " << schema.file_ << ":" << schema.line_ << '\n';
+  }
+  return out;
+}
+
+OpSchemaRegistry::DomainToVersionRange& OpSchemaRegistry::DomainToVersionRange::Instance() {
+  static DomainToVersionRange domain_to_version_range;
+  return domain_to_version_range;
+}
+
+// Private method used by OpSchemaRegisterOnce and OpSchemaRegistry::map()
+OpName_Domain_Version_Schema_Map& OpSchemaRegistry::GetMapWithoutEnsuringRegistration() {
+  static OpName_Domain_Version_Schema_Map map;
+  return map;
+}
+
+OpName_Domain_Version_Schema_Map& OpSchemaRegistry::map() {
+  auto& map = GetMapWithoutEnsuringRegistration();
+
+  // The following class is used to register operators the
+  // first time this method is called, in a thread-safe fashion.
+  class SchemasRegisterer {
+   public:
+    SchemasRegisterer() {
+      // In debug builds, the number of schema registered in this constructor
+      // is compared against the number of calls to schema registration macros.
+#ifndef NDEBUG
+      size_t dbg_initial_schema_count = GetRegisteredSchemaCount();
+#endif
+
+      RegisterOnnxOperatorSetSchema();
+
+#ifdef ONNX_ML
+      RegisterOnnxMLOperatorSetSchema();
+#endif
+
+      // Invoke register of training operators.
+      RegisterOnnxTrainingOperatorSetSchema();
+
+      // Invoke register of experimental operators.
+      RegisterOnnxPreviewOperatorSetSchema();
+
+#ifndef NDEBUG
+      size_t dbg_registered_schema_count = GetRegisteredSchemaCount() - dbg_initial_schema_count;
+      // Check enabled only if schemas for all opset versions are loaded
+      if (OpSchemaRegistry::Instance()->GetLoadedSchemaVersion() == 0) {
+        ONNX_ASSERTM(
+            dbg_registered_schema_count == ONNX_DBG_GET_COUNT_IN_OPSETS(),
+            dbg_registered_schema_count,
+            " schema were exposed from operator sets and automatically placed into the static registry.  ",
+            ONNX_DBG_GET_COUNT_IN_OPSETS(),
+            " were expected based on calls to registration macros. Operator set functions may need to be updated.")
+      }
+#endif
+    }
+
+   private:
+#ifndef NDEBUG
+    static size_t GetRegisteredSchemaCount() {
+      size_t count = 0;
+      for (auto& x : GetMapWithoutEnsuringRegistration()) {
+        for (auto& y : x.second) {
+          count += y.second.size();
+        }
+      }
+      return count;
+    }
+#endif
+  };
+
+#ifndef __ONNX_DISABLE_STATIC_REGISTRATION
+  static SchemasRegisterer schemasRegisterer;
+#endif
+
+  return map;
+}
+
+size_t ReplaceAll(std::string& s, const char* from, const char* to) {
+  size_t numReplaced = 0;
+  std::string::size_type lenFrom = std::strlen(from);
+  std::string::size_type lenTo = std::strlen(to);
+  for (std::string::size_type pos = s.find(from); pos != std::string::npos; pos = s.find(from, pos + lenTo)) {
+    s.replace(pos, lenFrom, to);
+    numReplaced++;
+  }
+  return numReplaced;
+}
+
+bool IsOnnxStaticRegistrationDisabled() {
+#ifdef __ONNX_DISABLE_STATIC_REGISTRATION
+  return true;
+#else
+  return false;
+#endif
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/schema.h b/onnx/defs/schema.h
new file mode 100644
index 0000000..8c00772
--- /dev/null
+++ b/onnx/defs/schema.h
@@ -0,0 +1,1433 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstring>
+#include <functional>
+#include <initializer_list>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "onnx/common/common.h"
+#include "onnx/common/constants.h"
+#include "onnx/defs/data_type_utils.h"
+#include "onnx/defs/shape_inference.h"
+
+namespace ONNX_NAMESPACE {
+
+struct FunctionBodyBuildContext {
+  virtual const AttributeProto* getAttribute(const std::string& name) const = 0;
+  virtual bool hasInput(int inputIndex) const = 0;
+  virtual bool hasOutput(int inputIndex) const = 0;
+  // getInputType(i) should return null for missing optional inputs, or if
+  // type-inference could not infer the input-type (erroneous model).
+  virtual const TypeProto* getInputType(int inputIndex) const = 0;
+  virtual ~FunctionBodyBuildContext() = default;
+};
+
+struct FunctionBodyBuildContextImpl : public FunctionBodyBuildContext {
+  // Input_types: use a default TypeProto for missing types. We use a different convention
+  // here (from FunctionBodyBuildContext) to simplify python interoperability.
+  // The default value for input_types is included only for backward compatibility.
+  // It can be used for functions that do not depend on the type-context, but
+  // will not be sufficient for functions that do use the type-context.
+  explicit FunctionBodyBuildContextImpl(const NodeProto& node_proto, const std::vector<TypeProto>& input_types = {})
+      : node_proto_(node_proto), input_types_(input_types) {
+    for (const auto& attr : node_proto.attribute()) {
+      attributesByName_[attr.name()] = &attr;
+    }
+  }
+
+  const AttributeProto* getAttribute(const std::string& name) const override {
+    auto iter = attributesByName_.find(name);
+    if (iter == attributesByName_.end()) {
+      return nullptr;
+    } else {
+      return iter->second;
+    }
+  }
+
+  bool hasInput(int inputIndex) const override {
+    if (inputIndex >= node_proto_.input_size())
+      return false;
+    return !node_proto_.input(inputIndex).empty();
+  }
+
+  bool hasOutput(int inputIndex) const override {
+    if (inputIndex >= node_proto_.output_size())
+      return false;
+    return !node_proto_.output(inputIndex).empty();
+  }
+
+  const TypeProto* getInputType(int inputIndex) const override {
+    if (inputIndex < 0)
+      return nullptr;
+    size_t j = static_cast<size_t>(inputIndex);
+    if (j >= input_types_.size())
+      return nullptr;
+    // Convert default value (no variant set) into null.
+    if (input_types_[j].value_case() == TypeProto::ValueCase::VALUE_NOT_SET)
+      return nullptr;
+    return &input_types_[j];
+  }
+
+  std::unordered_map<std::string, const AttributeProto*> attributesByName_;
+
+  NodeProto node_proto_;
+  std::vector<TypeProto> input_types_;
+};
+
+using FunctionBodyQueryFunction = std::function<bool(FunctionBodyBuildContext&)>;
+
+class OpSchema;
+using ContextDependentFunctionBodyBuilder =
+    std::function<bool(const FunctionBodyBuildContext&, const OpSchema&, FunctionProto&)>;
+
+class SchemaError final : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+
+  explicit SchemaError(const std::string& message) : std::runtime_error(message) {}
+
+  ONNX_API const char* what() const noexcept override {
+    if (!expanded_message_.empty()) {
+      return expanded_message_.c_str();
+    }
+    return std::runtime_error::what();
+  }
+
+  ONNX_API void AppendContext(const std::string& context) {
+    expanded_message_ = ONNX_NAMESPACE::MakeString(std::runtime_error::what(), "\n\n==> Context: ", context);
+  }
+
+ private:
+  std::string expanded_message_;
+};
+
+#define fail_schema(...) ONNX_THROW_EX(ONNX_NAMESPACE::SchemaError(ONNX_NAMESPACE::MakeString(__VA_ARGS__)))
+
+using OperatorSetVersion = int;
+
+using DataTypeSet = std::unordered_set<DataType>;
+
+// Type constraint map. Key is type string. Value is data type set and
+// description.
+using TypeConstraintMap = std::unordered_map<std::string, std::pair<DataTypeSet, std::string>>;
+
+/**
+ * @brief A class to record the schema of an op.
+ *
+ * OpSchema records the common interface of an op specified by its name.
+ *
+ * To register an OpSchema, one can use the macro ONNX_OPERATOR_SCHEMA(name) and
+ * then append the various functions in the class. For example, for an op
+ * that takes in two inputs, one output, and the first input and output
+ * could be in-place, can be written as
+ *
+ *     ONNX_OPERATOR_SCHEMA(name)
+ *         .NumInputs(2).NumOutputs(1).AllowConsumed({{0, 0}});
+ *
+ * To manufacture methods that may be used to register an OpSchema
+ * non-statically, the following may be used:
+ *
+ *     ONNX_OPERATOR_SET_SCHEMA(name, version, OpSchema()
+ *         .NumInputs(2).NumOutputs(1).AllowConsumed({{0, 0}}));
+ */
+class OpSchema final {
+ public:
+  static constexpr int kUninitializedSinceVersion = -1;
+  // Formal parameter options.
+  enum FormalParameterOption : uint8_t {
+    // The formal parameter is single and not optional.
+    // Number of supplied actual parameters must be 1.
+    Single = 0,
+    // The formal parameter is single and optional.
+    // Number of supplied actual parameters may be 0 or 1.
+    Optional = 1,
+    // The formal parameter is variadic.
+    // Number of supplied actual parameters must be N or more, where
+    // the minimum value N is indicated separately (default value 1).
+    Variadic = 2,
+  };
+  enum DifferentiationCategory : uint8_t {
+    // Whether this formal parameter is differentiable or not cannot
+    // be statically determined. It also covers variadic formal
+    // parameters which contain both of differentiable and
+    // non-differentiable variables.
+    Unknown = 0,
+    // This formal parameter is differentiable. That is, this formal
+    // parameter can be differentiable input of Gradient operator.
+    Differentiable = 1,
+    // This formal parameter is not differentiable. That is, this formal
+    // parameter can not be differentiable input of Gradient operator.
+    NonDifferentiable = 2
+  };
+  enum class NodeDeterminism : uint8_t {
+    Unknown = 0,
+    NonDeterministic = 1,
+    Deterministic = 2,
+  };
+
+  // Formal parameter representation, including input/output name, typeStr,
+  // description, and type constraints.
+  class FormalParameter final {
+   public:
+    // Constructor.
+    FormalParameter() = default;
+
+    explicit FormalParameter(
+        std::string name,
+        DataTypeSet allowed_type_set,
+        std::string type_str,
+        std::string description [[maybe_unused]],
+        FormalParameterOption param_option = Single,
+        bool is_homogeneous = true,
+        int min_arity = 1,
+        DifferentiationCategory differentiation_category = Unknown)
+        : name_(std::move(name)),
+          type_set_(std::move(allowed_type_set)),
+          type_str_(std::move(type_str)),
+#ifndef __ONNX_NO_DOC_STRINGS
+          description_(std::move(description)),
+#endif
+          param_option_(param_option),
+          is_homogeneous_(is_homogeneous),
+          min_arity_(min_arity),
+          differentiation_category_(differentiation_category) {
+    }
+
+    explicit FormalParameter(
+        std::string name,
+        std::string description [[maybe_unused]],
+        std::string type_str,
+        FormalParameterOption param_option = Single,
+        bool is_homogeneous = true,
+        int min_arity = 1,
+        DifferentiationCategory differentiation_category = Unknown)
+        : name_(std::move(name)),
+          type_str_(std::move(type_str)),
+#ifndef __ONNX_NO_DOC_STRINGS
+          description_(std::move(description)),
+#endif
+          param_option_(param_option),
+          is_homogeneous_(is_homogeneous),
+          min_arity_(min_arity),
+          differentiation_category_(differentiation_category) {
+    }
+
+    // Get formal parameter name.
+    ONNX_API const std::string& GetName() const;
+
+    // Get allowed data types.
+    ONNX_API const DataTypeSet& GetTypes() const;
+
+    // Get formal parameter type string.
+    ONNX_API const std::string& GetTypeStr() const;
+
+    // Get formal parameter description.
+    ONNX_API const std::string& GetDescription() const;
+
+    // Get the parameter option, it could be Single, Optional or Variadic.
+    ONNX_API FormalParameterOption GetOption() const;
+
+    // Get whether a variadic parameter requires all to be of same type
+    ONNX_API bool GetIsHomogeneous() const;
+
+    // Get minimum arity. Applicable only in the Variadic case.
+    ONNX_API int GetMinArity() const;
+
+    // Get the differentiation property of this formal parameter.
+    ONNX_API DifferentiationCategory GetDifferentiationCategory() const;
+
+   private:
+    friend class OpSchema;
+
+    DataTypeSet& MutableTypes();
+
+    // Formal parameter name.
+    std::string name_;
+
+    // A set of data types supported for <*this> formal parameter.
+    // It should contain at least one element if this formal parameter is good.
+    DataTypeSet type_set_;
+
+    // The <parameter type> string specified when registering an op.
+    // It could be a supported data type or a type constraint key, which
+    // maps to a set of supported data types.
+    std::string type_str_;
+
+    // Formal parameter description.
+    std::string description_;
+
+    // Formal parameter option.
+    FormalParameterOption param_option_{};
+
+    // For variadic parameters, a flag indicating if all parameters must be of
+    // same type
+    bool is_homogeneous_{};
+
+    // Minimum number of parameters expected. Applicable only for Variadic.
+    int min_arity_{};
+
+    // True if this parameter can be an differentiable inputs of Gradient.
+    // Otherwise, using this parameter as an differentiable inputs of Gradient
+    // is prohibited.
+    DifferentiationCategory differentiation_category_{};
+  };
+
+  enum class SupportType : uint8_t {
+    COMMON, // Supported by all frameworks that support this IR.
+    EXPERIMENTAL, // This OP is experimental and can be changed or removed in
+                  // the future.
+  };
+
+  OpSchema() : OpSchema("unknown", "unknown", 0) {}
+  OpSchema(std::string name, std::string file, int line)
+      : name_(std::move(name)), file_(std::move(file)), line_(line), support_(SupportType::COMMON) {}
+
+  /**
+   * @brief Returns the file that the op schema is registered from.
+   */
+  ONNX_API const std::string& file() const {
+    return file_;
+  }
+
+  /**
+   * @brief Returns the line in file that the op schema is registered from.
+   */
+  ONNX_API int line() const {
+    return line_;
+  }
+
+  /**
+   * @brief Returns the support level of the op schema.
+   */
+  ONNX_API SupportType support_level() const {
+    return support_;
+  }
+
+  /**
+   * @brief Returns the docstring of the op schema.
+   */
+  ONNX_API const char* doc() const {
+    return doc_.empty() ? nullptr : doc_.c_str();
+  }
+
+  // Check if input and output types fall into valid set and match each other
+  ONNX_API void CheckInputOutputType(struct InferenceContext& /*ctx*/) const;
+
+  /**
+   * @brief Verifies if a NodeProto matches the pattern specified in
+   * the schema.
+   */
+  void Verify(const NodeProto& node) const;
+
+  // Functions to set the property of the operator schemas.
+  // Sets the number of inputs, either a fixed number or a min and a max.
+
+  /**
+   * The earliest operator set version which this operator was
+   * present in.  If an operator has had no BC-breaking changes,
+   * this is simply the first operator set the operator was a member
+   * of; if it has had BC-breaking changes, then for the semantics
+   * /as described/ in the OpSchema entry, this version describes
+   * the operator set which introduced the BC-breaking change.
+   *
+   * For example, suppose op Foo was added in v3, and had a BC-breaking
+   * change in v6.  Then there will be an op schema entry for Foo with
+   * SinceVersion(3), and another, updated op schema entry for Foo
+   * with SinceVersion(6).
+   */
+  ONNX_API OpSchema& SinceVersion(OperatorSetVersion n); // aka int
+
+  /**
+   * Marks this op as deprecated as of it's since_version. This will cause the
+   * Schema() lookup functions to return nullptr when the version is in the
+   * deprecated range.
+   */
+  ONNX_API OpSchema& Deprecate();
+
+  ONNX_API bool Deprecated() const {
+    return deprecated_;
+  }
+
+  /**
+   * @brief Input could be one of the values specified in allowed_input_nums.
+   */
+  ONNX_API OpSchema& NumInputs(std::unordered_set<int> allowed_input_nums);
+
+  /**
+   * @brief Output could be one of the values specified in allowed_output_nums.
+   */
+  ONNX_API OpSchema& NumOutputs(std::unordered_set<int> allowed_output_nums);
+
+  // Shape Inference
+  //
+  // Note that signatures are defined to allow for forward-declaring
+  // any structs used from ir.h
+  ONNX_API OpSchema& TypeAndShapeInferenceFunction(InferenceFunction inferenceFunction);
+  InferenceFunction GetTypeAndShapeInferenceFunction() const {
+    if (tensor_inference_function_) {
+      return tensor_inference_function_;
+    }
+    return dummyInferenceFunction;
+  }
+
+  ONNX_API OpSchema& PartialDataPropagationFunction(DataPropagationFunction dataPropagationFunction);
+  ONNX_API DataPropagationFunction GetDataPropagationFunction() const {
+    if (data_propagation_function_) {
+      return data_propagation_function_;
+    }
+    return dummyDataPropagationFunction;
+  }
+
+  // Set the support level for the op schema.
+  ONNX_API OpSchema& SetSupportLevel(SupportType supportType);
+
+  // Functions to do documentation for the operator schema.
+  // This may be disabled to save memory.
+  ONNX_API OpSchema& SetDoc(const char* doc [[maybe_unused]]) {
+#ifndef __ONNX_NO_DOC_STRINGS
+    SetDoc(std::string(doc));
+#endif
+    return *this;
+  }
+
+  ONNX_API OpSchema& SetDoc(const std::string& doc [[maybe_unused]]) {
+#ifndef __ONNX_NO_DOC_STRINGS
+    doc_ = doc;
+#endif
+    return *this;
+  }
+
+  // Functions to specify name for the operator schema.
+  ONNX_API OpSchema& SetName(const char* name);
+  ONNX_API OpSchema& SetName(std::string name);
+
+  // Functions to specify code location for the operator schema.
+  ONNX_API OpSchema& SetLocation(const char* file, int line);
+  ONNX_API OpSchema& SetLocation(std::string file, int line);
+
+  // Functions to specify domain for the operator schema.
+  // Default domain value (ONNX_DOMAIN) means it's ONNX domain.
+  ONNX_API OpSchema& SetDomain(const char* domain);
+  ONNX_API OpSchema& SetDomain(std::string domain);
+
+  struct Attribute final {
+    Attribute(std::string name_, std::string description_, AttributeProto::AttributeType type_, bool required_)
+        : name(std::move(name_)), description(std::move(description_)), type(type_), required(required_) {}
+
+    Attribute(std::string name_, std::string description_, AttributeProto default_value_)
+        : name(std::move(name_)),
+          description(std::move(description_)),
+          type(default_value_.type()),
+          required(false),
+          default_value(std::move(default_value_)) {}
+
+    const std::string name;
+    const std::string description;
+    AttributeProto::AttributeType type;
+    bool required;
+    AttributeProto default_value;
+  };
+
+  ONNX_API OpSchema& Attr(Attribute attr);
+
+// Register "optional" attribute with default value.
+#define ATTR_SETTER_WITH_DEFAULT_VALUE(TypeName)                                                                    \
+  OpSchema& Attr(                                                                                                   \
+      std::string name, std::string description, AttributeProto::AttributeType type, const TypeName& defaultValue); \
+  /* non-STL wrapper to reduce binary size */                                                                       \
+  OpSchema& Attr(                                                                                                   \
+      const char* name, const char* description, AttributeProto::AttributeType type, const TypeName& defaultValue); \
+  OpSchema& Attr(                                                                                                   \
+      std::string name,                                                                                             \
+      std::string description,                                                                                      \
+      AttributeProto::AttributeType type,                                                                           \
+      const std::vector<TypeName>& defaultValue);
+
+  ATTR_SETTER_WITH_DEFAULT_VALUE(int64_t)
+  ATTR_SETTER_WITH_DEFAULT_VALUE(float)
+  ATTR_SETTER_WITH_DEFAULT_VALUE(std::string)
+  // Overload for const char* default value to prevent implicit conversion to bool
+  OpSchema&
+  Attr(const char* name, const char* description, AttributeProto::AttributeType type, const char* defaultValue);
+  ATTR_SETTER_WITH_DEFAULT_VALUE(TensorProto)
+  ATTR_SETTER_WITH_DEFAULT_VALUE(GraphProto)
+  ATTR_SETTER_WITH_DEFAULT_VALUE(TypeProto)
+
+  ONNX_API OpSchema& Attr(
+      std::string name,
+      std::string description,
+      std::string conditionExplanation,
+      AttributeProto::AttributeType attr_type);
+
+  // Register "required" attribute without default value.
+  ONNX_API OpSchema&
+  Attr(std::string name, std::string description, AttributeProto::AttributeType type, bool required = true);
+
+  // Non-STL wrapper to reduce binary size
+  ONNX_API OpSchema&
+  Attr(const char* name, const char* description, AttributeProto::AttributeType type, bool required = true);
+
+  ONNX_API OpSchema& AllowUncheckedAttributes();
+
+  // Type constraint.
+  struct TypeConstraintParam final {
+    TypeConstraintParam(
+        std::string type_param_str_,
+        std::vector<std::string> allowed_type_strs_,
+        std::string description_)
+        : type_param_str(std::move(type_param_str_)),
+          allowed_type_strs(std::move(allowed_type_strs_)),
+          description(std::move(description_)) {}
+
+    // Type parameter string, for example, "T", "T1", etc.
+    std::string type_param_str;
+    // Allowed type strings for <*this> type parameter, for example,
+    // "tensor(float)".
+    std::vector<std::string> allowed_type_strs;
+    // Type parameter description.
+    std::string description;
+  };
+
+  // Grammar for type strings used in Input(), Output().
+  // <type> ::= <data_type> |
+  //            tensor(<data_type>) |
+  //            seq(<type>) |
+  //            map(<data_type>, <type>) |
+  //            <type_parameter>
+  // <data_type> :: = float | int32 | string | bool | uint8
+  //                | int8 | uint16 | int16 | int64 | float16 | double
+  // <type_parameter> ::= any type parameter string, say "T".
+  //
+  // NOTE: 1) <type_parameter> will always be together with a type constraints
+  // specification.
+  //       2) <type> ::= <data_type> means the data is scalar (zero dimension).
+  //
+  // Example:
+  // ONNX_OPERATOR_SET_SCHEMA(Sum, 1, OpSchema()
+  // .Input(0, "input_a", "the first input", "T")
+  // .Input(1, "input_b", "the second input", "T")
+  // .Output(0, "sum", "the sum of two numbers", "T")
+  // .TypeConstraint("T", {"float", "double", "int32"}, "allowed data types for
+  // sum."))
+  //
+  // Optional = true means that the input might have empty input value
+  // (represented as "") in the graph even though the later inputs have values.
+  // It's useful for complex situation when there are several independent
+  // optional inputs.
+  ONNX_API OpSchema& Input(int n, FormalParameter formal_parameter);
+
+  ONNX_API OpSchema& Input(
+      int n,
+      std::string name,
+      const std::string& description,
+      std::string type_str,
+      FormalParameterOption param_option = Single,
+      bool is_homogeneous = true,
+      int min_arity = 1,
+      DifferentiationCategory differentiation_category = Unknown);
+
+  // Non-STL wrapper to reduce binary size
+  ONNX_API OpSchema& Input(
+      int n,
+      const char* name,
+      const char* description,
+      const char* type_str,
+      FormalParameterOption param_option = Single,
+      bool is_homogeneous = true,
+      int min_arity = 1,
+      DifferentiationCategory differentiation_category = Unknown);
+
+  ONNX_API OpSchema& Output(int n, FormalParameter formal_parameter);
+
+  ONNX_API OpSchema& Output(
+      int n,
+      std::string name,
+      const std::string& description,
+      std::string type_str,
+      FormalParameterOption param_option = Single,
+      bool is_homogeneous = true,
+      int min_arity = 1,
+      DifferentiationCategory differentiation_category = Unknown);
+
+  // Non-STL wrapper to reduce binary size
+  ONNX_API OpSchema& Output(
+      int n,
+      const char* name,
+      const char* description,
+      const char* type_str,
+      FormalParameterOption param_option = Single,
+      bool is_homogeneous = true,
+      int min_arity = 1,
+      DifferentiationCategory differentiation_category = Unknown);
+
+  ONNX_API OpSchema&
+  TypeConstraint(std::string type_str, std::vector<std::string> constraints, std::string description);
+
+  // Non-STL wrapper to reduce binary size
+  ONNX_API OpSchema&
+  TypeConstraint(const char* type_str, std::initializer_list<const char*> constraints, const char* description);
+
+  // Convenience members for types
+
+  // All high-precision numeric types.
+  ONNX_API static const std::vector<std::string>& numeric_types_for_math_reduction_ir10() {
+    return numeric_types_for_math_reduction_ir9();
+  }
+
+  ONNX_API static const std::vector<std::string>& numeric_types_for_math_reduction_ir9();
+
+  ONNX_API static const std::vector<std::string>& numeric_types_for_math_reduction_ir4();
+
+  ONNX_API static const std::vector<std::string>& numeric_types_for_math_reduction();
+
+  ONNX_API static const std::vector<std::string>& all_numeric_types_ir13();
+
+  ONNX_API static const std::vector<std::string>& all_numeric_types_ir12();
+
+  ONNX_API static const std::vector<std::string>& all_numeric_types_ir11();
+
+  ONNX_API static const std::vector<std::string>& all_numeric_types_ir10();
+
+  ONNX_API static const std::vector<std::string>& all_numeric_types_ir9();
+
+  ONNX_API static const std::vector<std::string>& all_numeric_types_ir4();
+
+  ONNX_API static const std::vector<std::string>& all_numeric_types();
+
+  ONNX_API static const std::vector<std::string>& all_numeric_sequence_types();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_types();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_types_ir4();
+
+  ONNX_API static const std::vector<std::string>& all_non_complex_numeric_types_plus_bool_ir4();
+
+  ONNX_API static const std::vector<std::string>& all_float_types_ir4();
+
+  ONNX_API static const std::vector<std::string>& all_float_types_plus_Xint8_ir4();
+
+  ONNX_API static const std::vector<std::string>& all_float_types_ir9();
+
+  ONNX_API static const std::vector<std::string>& all_float_types_ir10() {
+    return all_float_types_ir9();
+  }
+
+  ONNX_API static const std::vector<std::string>& all_tensor_types_ir9();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_types_ir10();
+
+  ONNX_API static const std::vector<std::string>& all_non_complex_tensor_types_ir10();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_types_ir11();
+
+  ONNX_API static const std::vector<std::string>& all_non_complex_tensor_types_ir11();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_types_ir12();
+
+  ONNX_API static const std::vector<std::string>& all_non_complex_tensor_types_ir12();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_types_ir13();
+
+  ONNX_API static const std::vector<std::string>& all_non_complex_tensor_types_ir13();
+
+  ONNX_API static const std::vector<std::string>& all_non_string_tensor_types_ir13();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_sequence_types();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_sequence_types_ir4();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_sequence_types_ir9();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_sequence_types_ir10();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_sequence_types_ir11();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_sequence_types_ir12();
+
+  ONNX_API static const std::vector<std::string>& all_tensor_sequence_types_ir13();
+
+  ONNX_API static const std::vector<std::string>& all_optional_types();
+
+  ONNX_API static const std::vector<std::string>& all_optional_types_ir4();
+
+  ONNX_API static const std::vector<std::string>& all_optional_types_ir9();
+
+  ONNX_API static const std::vector<std::string>& all_optional_types_ir10();
+
+  ONNX_API static const std::vector<std::string>& all_optional_types_ir11();
+
+  ONNX_API static const std::vector<std::string>& all_optional_types_ir12();
+
+  ONNX_API static const std::vector<std::string>& all_optional_types_ir13();
+
+  // Calls the passed function with `this` as an argument. Useful for
+  // adding docs for templated/macro ops.
+  ONNX_API OpSchema& FillUsing(const std::function<void(OpSchema&)>& populator);
+
+  friend std::ostream& operator<<(std::ostream& out, const OpSchema& schema);
+
+  ONNX_API const std::string& domain() const {
+    return domain_;
+  }
+
+  ONNX_API const std::unordered_map<std::string, Attribute>& attributes() const {
+    return attributes_;
+  }
+
+  // Get input formal parameters.
+  ONNX_API const std::vector<FormalParameter>& inputs() const {
+    return inputs_;
+  }
+
+  // Get output formal parameters.
+  ONNX_API const std::vector<FormalParameter>& outputs() const {
+    return outputs_;
+  }
+
+  ONNX_API const std::vector<TypeConstraintParam>& typeConstraintParams() const {
+    return type_constraint_params_;
+  }
+
+  ONNX_API const TypeConstraintMap& typeConstraintMap() const {
+    return type_constraints_;
+  }
+
+  ONNX_API const std::string& Name() const {
+    return name_;
+  }
+
+  ONNX_API OperatorSetVersion SinceVersion() const {
+    return since_version_;
+  }
+
+  ONNX_API int since_version() const {
+    return since_version_;
+  }
+
+  ONNX_API bool deprecated() const {
+    return deprecated_;
+  }
+
+  ONNX_API int min_input() const {
+    return min_input_;
+  }
+
+  ONNX_API int max_input() const {
+    return max_input_;
+  }
+
+  ONNX_API int min_output() const {
+    return min_output_;
+  }
+
+  ONNX_API int max_output() const {
+    return max_output_;
+  }
+
+  ONNX_API bool has_type_and_shape_inference_function() const {
+    return static_cast<bool>(tensor_inference_function_);
+  }
+
+  ONNX_API bool has_data_propagation_function() const {
+    return static_cast<bool>(data_propagation_function_);
+  }
+
+  ONNX_API std::vector<int> function_opset_versions() const {
+    std::vector<int> opset_versions;
+    opset_versions.reserve(opset_version_to_function_body_.size());
+    for (const auto& pair : opset_version_to_function_body_) {
+      opset_versions.push_back(pair.first);
+    }
+    return opset_versions;
+  }
+
+  ONNX_API bool HasFunction() const {
+    return !opset_version_to_function_body_.empty();
+  }
+
+  ONNX_API OpSchema& FunctionBody(
+      const std::vector<NodeProto>& func_nodes,
+      int opset_version = kUninitializedSinceVersion);
+
+  ONNX_API OpSchema& FunctionBody(
+      const std::vector<NodeProto>& func_nodes,
+      const std::vector<OperatorSetIdProto>& opsets,
+      int opset_version = kUninitializedSinceVersion);
+
+  ONNX_API OpSchema& FunctionBody(const char* func_body, int opset_version = kUninitializedSinceVersion);
+
+  // since_version_ of an OpSchema tells the last opset version when an op is defined.
+  // When the op's definition is changed, a new OpSchema (of the same op_type) is created
+  // with a newer since_version_, reflecting the opset version at the time of change.
+  // For a function op, operators used to define its function body may change
+  // while there is no change to the function op definition itself.
+  // When this happens, multiple function bodies are provided, each for a specific opset version.
+  //
+  // Take LogSoftmax for example. Its latest opset version is 13.
+  // In LogSoftmax's function body, ReduceMax (with since_version_ 1, 11, 12, 18) is used.
+  // When a model containing LogSoftmax with opset_import version within 13 to 17 is loaded, function body
+  // with opset_version 13 is used for inlining.
+  // When the same model but opset_import version 18 is loaded, function body
+  // with opset_version 18 is used for inlining.
+  // Clearly function body for opset_import version 13 will not work
+  // in a model with opset_import version 18 because the function body make wrong use of ReduceMax(18).
+  // Inside GetFunction we ensure that ops being used to construct a function body do not endure such
+  // issue.
+  ONNX_API const FunctionProto* GetFunction(
+      int requested_opset_version = OpSchema::kUninitializedSinceVersion,
+      bool validate = false) const;
+
+  ONNX_API std::vector<int> context_dependent_function_opset_versions() const {
+    std::vector<int> opset_versions;
+    opset_versions.reserve(opset_version_to_function_builder_.size());
+    for (const auto& pair : opset_version_to_function_builder_) {
+      opset_versions.push_back(pair.first);
+    }
+    return opset_versions;
+  }
+
+  ONNX_API bool HasContextDependentFunction() const {
+    return !opset_version_to_function_builder_.empty();
+  }
+
+  ONNX_API bool HasContextDependentFunctionWithOpsetVersion(int opset_version) const {
+    return opset_version_to_function_builder_.find(opset_version) != opset_version_to_function_builder_.end();
+  }
+
+  ONNX_API OpSchema& SetContextDependentFunctionBodyBuilder(
+      ContextDependentFunctionBodyBuilder /*functionBuilder*/,
+      int opset_version = kUninitializedSinceVersion);
+
+  ONNX_API bool BuildContextDependentFunction(
+      const FunctionBodyBuildContext& ctx,
+      FunctionProto& function_proto,
+      int requested_opset_version = OpSchema::kUninitializedSinceVersion) const;
+
+  // Verifies that the schema is valid and all specifications are compatible.
+  // It will also parse all type strings specified for inputs/outputs into valid
+  // TypeProto and create global unique string pointer as the DataType for
+  // efficiency.
+  ONNX_API void Finalize();
+
+  // Build function with information stored in opschema
+  ONNX_API void BuildFunction(FunctionProto& function_body) const;
+
+  ONNX_API NodeDeterminism GetNodeDeterminism() const;
+  ONNX_API OpSchema& SetNodeDeterminism(NodeDeterminism node_determinism);
+
+ private:
+  void ParseAndSetTypes(
+      /*out*/ std::vector<OpSchema::FormalParameter>* formal_parameters);
+  bool ValidateReferencedOpsInFunction(
+      const FunctionProto* function,
+      int requested_opset_version,
+      int function_since_version,
+      std::unordered_set<std::string>* updated_ops = nullptr) const;
+  void UpdateFunctionProtoOpsetImportVersion(FunctionProto& function_proto, int opset_version) const;
+
+  /**
+   * @brief A common function to generate a prefix string for use in fail_check during the verify function.
+   * @param  node_name If empty, the returned string will not include the node name.
+   * @return std::string The prefix string.
+   */
+  std::string VerifyFailPrefix(std::string_view node_name) const;
+
+  /**
+   * @brief Verifies if the input number matches the pattern specified in the schema.
+   * @param input_num The number of inputs to be verified against the schema.
+   * @param node_name The prefix string used if the check fails.
+   */
+  void VerifyInputNum(int input_num, std::string_view node_name = "") const;
+
+  /**
+   * @brief Verifies if the output number matches the pattern specified in the schema.
+   * @param output_num The number of outputs to be verified against the schema.
+   * @param node_name The prefix string used if the check fails.
+   */
+  void VerifyOutputNum(int output_num, std::string_view node_name = "") const;
+
+  std::string name_;
+  std::string file_;
+  std::string doc_;
+  // Default domain value ("") means it's ONNX domain.
+  std::string domain_ = ONNX_DOMAIN;
+  std::unordered_map<std::string, Attribute> attributes_;
+  bool allows_unchecked_attributes_ = false;
+  std::vector<FormalParameter> inputs_;
+  std::vector<FormalParameter> outputs_;
+  std::vector<TypeConstraintParam> type_constraint_params_;
+  TypeConstraintMap type_constraints_;
+  int line_ = 0;
+  SupportType support_;
+  int min_input_ = 0;
+  int max_input_ = 0;
+  int min_output_ = 0;
+  int max_output_ = 0;
+  // The default is a little goofy, since it is never what you want
+  OperatorSetVersion since_version_ = kUninitializedSinceVersion;
+  bool deprecated_{};
+  std::function<bool(int)> num_inputs_allowed_ = [](int) { return true; };
+  std::function<bool(int)> num_outputs_allowed_ = [](int) { return true; };
+  InferenceFunction tensor_inference_function_;
+  DataPropagationFunction data_propagation_function_;
+
+  std::map<int, std::shared_ptr<FunctionProto>> opset_version_to_function_body_;
+  std::map<int, ContextDependentFunctionBodyBuilder> opset_version_to_function_builder_;
+
+  NodeDeterminism node_determinism_ = NodeDeterminism::Unknown;
+};
+
+// Map type to store operator schemas. The format is,
+// <OpName, <Domain, <OperatorSetVersion, OpSchema>>>.
+using OpName_Domain_Version_Schema_Map =
+    std::unordered_map<std::string, std::unordered_map<std::string, std::map<OperatorSetVersion, OpSchema>>>;
+
+class ISchemaRegistry {
+ public:
+  virtual ~ISchemaRegistry() = default;
+
+  ONNX_API virtual const OpSchema*
+  // NOLINTNEXTLINE(google-default-arguments)
+  GetSchema(const std::string& key, int maxInclusiveVersion, const std::string& domain = ONNX_DOMAIN) const = 0;
+};
+
+/**
+ * @brief A registry to hold all the operator schemas.
+ */
+class OpSchemaRegistry final : public ISchemaRegistry {
+ public:
+  // A singleton class to store domain to min/max op_set version map, as well as
+  // domain to last-release op_set version map.
+  class DomainToVersionRange final {
+   public:
+    DomainToVersionRange() {
+      // Increase the highest version when you make BC-breaking changes to the
+      // operator schema on specific domain. Update the lowest version when it's
+      // determined to remove too old version history.
+      map_[ONNX_DOMAIN] = std::make_pair(1, 28);
+      map_[AI_ONNX_ML_DOMAIN] = std::make_pair(1, 5);
+      map_[AI_ONNX_TRAINING_DOMAIN] = std::make_pair(1, 1);
+      map_[AI_ONNX_PREVIEW_DOMAIN] = std::make_pair(1, 1);
+      // ONNX's preview domain contains operators subject to change, so
+      // versioning is not meaningful and that domain should have only one
+      // version.
+      map_[AI_ONNX_PREVIEW_TRAINING_DOMAIN] = std::make_pair(1, 1);
+      // Version corresponding last release of ONNX. Update this to match with
+      // the max version above in a *release* version of ONNX. But in other
+      // versions, the max version may be ahead of the last-release-version.
+      last_release_version_map_[ONNX_DOMAIN] = 27;
+      last_release_version_map_[AI_ONNX_ML_DOMAIN] = 5;
+      last_release_version_map_[AI_ONNX_TRAINING_DOMAIN] = 1;
+      last_release_version_map_[AI_ONNX_PREVIEW_DOMAIN] = 1;
+      last_release_version_map_[AI_ONNX_PREVIEW_TRAINING_DOMAIN] = 1;
+    }
+
+    ONNX_API const std::unordered_map<std::string, std::pair<int, int>>& Map() const {
+      return map_;
+    }
+
+    ONNX_API const std::unordered_map<std::string, int>& LastReleaseVersionMap() const {
+      return last_release_version_map_;
+    }
+
+    // Add customized domain to min/max version.
+    // Onnx partners are able to use onnx operator schema api to
+    // register customized op in their own domain.
+    // Can optionally specify last_release_version (to make it similar to
+    // standard ONNX domains as above). Custom-domains are free to interpret
+    // this as appropriate (that is, as relative to releases of custom-domain
+    // as opposed to ONNX releases).
+    ONNX_API void
+    AddDomainToVersion(const std::string& domain, int min_version, int max_version, int last_release_version = -1) {
+      std::lock_guard<std::mutex> lock(mutex_);
+      if (map_.count(domain) != 0) {
+        std::stringstream err;
+        err << "Trying to add a domain to DomainToVersion map, but the domain is already exist with version range ("
+            << map_.at(domain).first << ", " << map_.at(domain).second << "). domain: \"" << domain << "\"" << '\n';
+        fail_schema(err.str());
+      }
+      if (last_release_version_map_.count(domain) != 0) {
+        std::stringstream err;
+        err << "Trying to add a domain to LastReleaseVersion map, but the domain is already exist with last version: "
+            << last_release_version_map_.at(domain) << ", domain: \"" << domain << "\"" << '\n';
+        fail_schema(err.str());
+      }
+      map_[domain] = std::make_pair(min_version, max_version);
+      // If a last-release-version is not explicitly specified, use max as
+      // last-release-version.
+      if (last_release_version == -1) {
+        last_release_version = max_version;
+      }
+      last_release_version_map_[domain] = last_release_version;
+    }
+
+    ONNX_API void
+    UpdateDomainToVersion(const std::string& domain, int min_version, int max_version, int last_release_version = -1) {
+      std::lock_guard<std::mutex> lock(mutex_);
+      if (map_.count(domain) == 0) {
+        std::stringstream err;
+        err << "Trying to update a domain in DomainToVersion map, but the domain has not been add. domain: \"" << domain
+            << "\"" << '\n';
+        fail_schema(err.str());
+      }
+      if (last_release_version_map_.count(domain) == 0) {
+        std::stringstream err;
+        err << "Trying to update a domain in LastReleaseVersion map, but the domain has not been add. domain: \""
+            << domain << "\"" << '\n';
+        fail_schema(err.str());
+      }
+      map_.at(domain).first = min_version;
+      map_.at(domain).second = max_version;
+      // Correspond to `AddDomainToVersion`
+      if (last_release_version == -1) {
+        last_release_version = max_version;
+      }
+      last_release_version_map_.at(domain) = last_release_version;
+    }
+
+    ONNX_API static DomainToVersionRange& Instance();
+
+   private:
+    // Key: domain. Value: <lowest version, highest version> pair.
+    std::unordered_map<std::string, std::pair<int, int>> map_;
+
+    // Key: domain. Value: most recent release opset version. Note that
+    // the highest opset version may be ahead of the most recent release's opset
+    // version.
+    std::unordered_map<std::string, int> last_release_version_map_;
+
+    std::mutex mutex_;
+  };
+
+  class OpSchemaRegisterOnce final {
+   public:
+    // Export to cpp custom register macro.
+    // DO NOT decorate the constructor as "explicit" because that breaks the macro ONNX_OPERATOR_SCHEMA_UNIQ.
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    OpSchemaRegisterOnce( // NOSONAR
+        OpSchema op_schema,
+        int opset_version_to_load = 0,
+        bool fail_duplicate_schema = true) {
+      OpSchemaRegisterNoExcept(std::move(op_schema), opset_version_to_load, fail_duplicate_schema);
+    }
+    ONNX_API static void
+    OpSchemaRegisterNoExcept(OpSchema&& op_schema, int opset_version_to_load = 0, bool fail_duplicate_schema = true) {
+      ONNX_TRY {
+        OpSchemaRegisterImpl(std::move(op_schema), opset_version_to_load, fail_duplicate_schema);
+      }
+      ONNX_CATCH(const std::exception& e) {
+        ONNX_HANDLE_EXCEPTION([&]() { std::cerr << "Schema error: " << e.what() << '\n'; });
+      }
+    }
+    ONNX_API static void
+    OpSchemaRegisterImpl(OpSchema&& op_schema, int opset_version_to_load = 0, bool fail_duplicate_schema = true) {
+      op_schema.Finalize();
+      auto& m = GetMapWithoutEnsuringRegistration();
+      const auto& op_name = op_schema.Name();
+      const auto& op_domain = op_schema.domain();
+      auto& schema_ver_map = m[op_name][op_domain];
+      auto ver = op_schema.SinceVersion();
+      if (OpSchema::kUninitializedSinceVersion == ver) {
+        op_schema.SinceVersion(1);
+        ver = op_schema.SinceVersion();
+      }
+
+      // Stops because the exact opset_version is registered
+      if (schema_ver_map.count(ver)) {
+        if (fail_duplicate_schema) {
+          const auto& schema = schema_ver_map[ver];
+          std::stringstream err;
+          err << "Trying to register schema with name " << op_name << " (domain: " << op_domain << " version: " << ver
+              << ") from file " << op_schema.file() << " line " << op_schema.line()
+              << ", but it is already registered from file " << schema.file() << " line " << schema.line() << '\n';
+          fail_schema(err.str());
+        }
+        return;
+      }
+
+      if (opset_version_to_load != 0) {
+        // Stops because the opset_version is higher than opset_version_to_load
+        if (ver > opset_version_to_load) {
+          return;
+        }
+
+        // Stops because a later version is registered within target opset version
+        if (!schema_ver_map.empty()) {
+          int max_registered_ver_le_target = GetMaxRegisteredVerWithinTarget(schema_ver_map, opset_version_to_load);
+          if (max_registered_ver_le_target >= ver) {
+            return;
+          }
+        }
+      }
+
+      CheckDomainAndVersionToRegister(op_schema, op_name, op_domain);
+      schema_ver_map.insert(std::pair<int, OpSchema&&>(ver, std::move(op_schema)));
+    }
+
+   private:
+    // Gets the maximum version from given map that is less or equal to target version
+    static int GetMaxRegisteredVerWithinTarget(const std::map<OperatorSetVersion, OpSchema>& m, int target_ver) {
+      // std::map is sorted on key
+      // reverse iterator returns the largest element keyed on the integer version
+      for (auto&& it = m.rbegin(); it != m.rend(); it++) {
+        const auto& registered_ver = it->first;
+        if (registered_ver <= target_ver) {
+          return registered_ver;
+        }
+      }
+      return -1;
+    }
+
+    ONNX_API static void CheckDomainAndVersionToRegister(
+        const OpSchema& op_schema,
+        const std::string& op_name,
+        const std::string& op_domain) {
+      auto ver_range_map = DomainToVersionRange::Instance().Map();
+      auto ver_range_it = ver_range_map.find(op_domain);
+      auto ver = op_schema.SinceVersion();
+
+      if (ver_range_it == ver_range_map.end()) {
+        std::stringstream err;
+        err << "Trying to register schema with name " << op_name << " (domain: " << op_domain << " version: " << ver
+            << ") from file " << op_schema.file() << " line " << op_schema.line() << ", but its domain is not"
+            << " known by the checker." << '\n';
+
+        fail_schema(err.str());
+      }
+      auto lower_bound_incl = ver_range_it->second.first;
+      auto upper_bound_incl = ver_range_it->second.second;
+      if (lower_bound_incl > ver || upper_bound_incl < ver) {
+        std::stringstream err;
+        err << "Trying to register schema with name " << op_name << " (domain: " << op_domain << " version: " << ver
+            << ") from file " << op_schema.file() << " line " << op_schema.line() << ", but its version is not "
+            << "in the inclusive range [" << lower_bound_incl << ", " << upper_bound_incl
+            << "] (usually, this means you "
+            << "bumped the operator version but "
+            << "forgot to update the version range in DomainToVersionRange "
+            << "in onnx/defs/schema.h)." << '\n';
+        fail_schema(err.str());
+      }
+    }
+  };
+
+  static void
+  OpSchemaDeregister(const std::string& op_type, const int version, const std::string& domain = ONNX_DOMAIN) {
+    auto& schema_map = GetMapWithoutEnsuringRegistration();
+    if (schema_map.count(op_type) && schema_map[op_type].count(domain) && schema_map[op_type][domain].count(version)) {
+      schema_map[op_type][domain].erase(version);
+    } else {
+      std::stringstream err;
+      err << "Attempting to deregister an unregistered schema with name: " << op_type << " domain: " << domain
+          << " version: " << version << '\n';
+      fail_schema(err.str());
+    }
+  }
+
+  // Deregister all ONNX opset schemas from domain
+  // Domain with default value ONNX_DOMAIN means ONNX.
+  static void OpSchemaDeregisterAll(const std::string& domain = ONNX_DOMAIN) {
+    auto& schema_map = GetMapWithoutEnsuringRegistration();
+    // schema_map stores operator schemas in the format of
+    // <OpName, <Domain, <OperatorSetVersion, OpSchema>>>
+    for (auto&& [_, domain_map] : schema_map) {
+      if (domain_map.count(domain)) {
+        auto& opset_version_schema_map = domain_map[domain];
+        // Invalidates ver-schema pairs and frees memory, leaving m[op_name][op_domain] empty
+        opset_version_schema_map.clear();
+        domain_map.erase(domain);
+      }
+    }
+  }
+
+  // Return the latest schema for an operator in specified domain.
+  // Domain with default value ONNX_DOMAIN means ONNX.
+  static const OpSchema* Schema(const std::string& key, const std::string& domain = ONNX_DOMAIN) {
+    auto& m = map();
+    if (m.count(key) && m[key].count(domain)) {
+      const auto& schema_ver_map = m[key][domain];
+      if (!schema_ver_map.empty()) {
+        return &m[key][domain].rbegin()->second;
+      }
+    }
+    return nullptr;
+  }
+
+  // Return the schema with biggest version, which is not greater than specified
+  // <maxInclusiveVersion> in specified domain. Domain with default value
+  // ONNX_DOMAIN means ONNX.
+  ONNX_API static const OpSchema*
+  Schema(const std::string& key, const int maxInclusiveVersion, const std::string& domain = ONNX_DOMAIN) {
+    auto& m = map();
+    if (m.count(key) && m[key].count(domain)) {
+      const auto& schema_ver_map = m[key][domain];
+      if (!schema_ver_map.empty()) {
+        auto pos = m[key][domain].lower_bound(maxInclusiveVersion);
+        if (m[key][domain].begin() == pos && pos->first > maxInclusiveVersion) {
+          // All versions are greater than specified version.
+          return nullptr;
+        }
+        if (m[key][domain].end() == pos || pos->first > maxInclusiveVersion) {
+          // All versions are less than specified version, or,
+          // The <pos> version is greater than specified version.
+          pos--;
+        }
+
+        // Schema with exact version as specified one exists.
+        return &(pos->second);
+      }
+    }
+    return nullptr;
+  }
+
+  ONNX_API static OpSchemaRegistry* Instance();
+
+  // NOLINTNEXTLINE(google-default-arguments)
+  ONNX_API const OpSchema* GetSchema(
+      const std::string& key,
+      const int maxInclusiveVersion,
+      const std::string& domain = ONNX_DOMAIN) const override {
+    return Schema(key, maxInclusiveVersion, domain);
+  }
+  ONNX_API static void SetLoadedSchemaVersion(int target_version) {
+    loaded_schema_version = target_version;
+  }
+  ONNX_API static int GetLoadedSchemaVersion() {
+    return loaded_schema_version;
+  }
+
+ private:
+  // OpSchemaRegistry should not need to be instantiated except statically
+  // within this class
+  OpSchemaRegistry() = default;
+
+  /**
+   * @brief Returns the underlying string to OpSchema map.
+   *
+   * You should not manually manipulate the map object returned. Instead, use
+   * the macros defined such as ONNX_OPERATOR_SET_SCHEMA to register your
+   * operator schema.
+   *
+   * We wrap it inside a function to avoid the static initialization order
+   * fiasco.
+   *
+   * With the change in function visibility, the
+   * GetMapWithoutEnsuringRegistration() and map() methods cannot be used
+   * to access the schema map directly from outside the OpSchemaRegistry class.
+   * Hence the ONNX_API macro is used to ensure that the methods are
+   * accessible from other translation units providing backward compatibility.
+   */
+  ONNX_API static OpName_Domain_Version_Schema_Map& GetMapWithoutEnsuringRegistration();
+  ONNX_API static OpName_Domain_Version_Schema_Map& map();
+  static int loaded_schema_version;
+
+ public:
+  static std::vector<OpSchema> get_all_schemas_with_history() {
+    std::vector<OpSchema> r;
+    for (auto& x : map()) {
+      for (auto& y : x.second) {
+        for (auto& z : y.second) {
+          r.emplace_back(z.second);
+        }
+      }
+    }
+    return r;
+  }
+
+  static std::vector<OpSchema> get_all_schemas() {
+    std::vector<OpSchema> r;
+    for (auto& x : map()) {
+      for (auto& y : x.second) {
+        if (!y.second.empty()) {
+          r.emplace_back(y.second.rbegin()->second);
+        }
+      }
+    }
+    return r;
+  }
+};
+
+ONNX_API void RegisterSchema(
+    const OpSchema& schema,
+    int opset_version_to_load = 0,
+    bool fail_duplicate_schema = true,
+    bool fail_with_exception = false);
+ONNX_API void RegisterSchema(
+    OpSchema&& schema,
+    int opset_version_to_load = 0,
+    bool fail_duplicate_schema = true,
+    bool fail_with_exception = false);
+ONNX_API void DeregisterSchema(const std::string& op_type, int version, const std::string& domain);
+
+// Registers the latest opset schema before opset_version_to_load
+// By default opset_version_to_load=0 means it will register all versions
+template <class T>
+ONNX_API void RegisterOpSetSchema(int opset_version_to_load = 0, bool fail_duplicate_schema = true) {
+  T::ForEachSchema([opset_version_to_load, fail_duplicate_schema](OpSchema&& schema) {
+    RegisterSchema(std::move(schema), opset_version_to_load, fail_duplicate_schema);
+  });
+}
+
+// Forward declaration for the non-specialized GetOpSchema method.  This
+// enforces a consistent signature on functions that query individual schema,
+// which are defined as specializations of this function.
+template <typename T>
+ONNX_API OpSchema GetOpSchema();
+
+#define ONNX_OPERATOR_SET_SCHEMA(name, ver, impl) ONNX_OPERATOR_SET_SCHEMA_EX(name, Onnx, ONNX_DOMAIN, ver, true, impl)
+
+#define ONNX_ML_OPERATOR_SET_SCHEMA(name, ver, impl) \
+  ONNX_OPERATOR_SET_SCHEMA_EX(name, OnnxML, AI_ONNX_ML_DOMAIN, ver, true, impl)
+
+#define ONNX_TRAINING_OPERATOR_SET_SCHEMA(name, ver, impl) \
+  ONNX_OPERATOR_SET_SCHEMA_EX(name, OnnxTraining, AI_ONNX_TRAINING_DOMAIN, ver, true, impl)
+
+#define ONNX_PREVIEW_OPERATOR_SET_SCHEMA(name, ver, impl) \
+  ONNX_OPERATOR_SET_SCHEMA_EX(name, OnnxPreview, AI_ONNX_PREVIEW_DOMAIN, ver, true, impl)
+
+#define ONNX_PREVIEW_TRAINING_OPERATOR_SET_SCHEMA(name, ver, impl) \
+  ONNX_OPERATOR_SET_SCHEMA_EX(name, OnnxPreview, AI_ONNX_PREVIEW_TRAINING_DOMAIN, ver, true, impl)
+
+#ifdef NDEBUG
+#define ONNX_DBG_INCREMENT_COUNT_IN_OPSETS() 0
+#define ONNX_OPERATOR_SET_SCHEMA_DEBUG_VARIABLE(name, domain, ver, dbg_included_in_static_opset) \
+  static size_t dbg_count_check_##name##_##domain##_ver##ver [[maybe_unused]] = 0
+#else
+class DbgOperatorSetTracker {
+ public:
+  ONNX_API static DbgOperatorSetTracker& Instance();
+
+  ONNX_API size_t IncrementCount() {
+    return ++count_;
+  }
+
+  ONNX_API size_t GetCount() const {
+    return count_;
+  }
+
+ private:
+  size_t count_ = 0;
+};
+#define ONNX_DBG_INCREMENT_COUNT_IN_OPSETS() DbgOperatorSetTracker::Instance().IncrementCount()
+#define ONNX_OPERATOR_SET_SCHEMA_DEBUG_VARIABLE(name, domain, ver, dbg_included_in_static_opset) \
+  static size_t dbg_count_check_##name##_##domain##_ver##ver [[maybe_unused]] =                  \
+      (dbg_included_in_static_opset) ? ONNX_DBG_INCREMENT_COUNT_IN_OPSETS() : 0;
+#endif
+
+// Defines specialization of GetOpSchema for a class whose name is determined
+// based on a convention using name, domain, and version.  Operator schema are
+// normally included in operator sets and registered in OpSchemaRegistry::map().
+// In this case, callers should set dbg_included_in_static_opset to true.  This
+// assists with runtime validation in DEBUG builds ensuring the intended set
+// of operator schema is registered.
+
+#define ONNX_OPERATOR_SET_SCHEMA_EX(name, domain, domain_str, ver, dbg_included_in_static_opset, impl)    \
+  class ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(domain, ver, name);                                           \
+  template <>                                                                                             \
+  ONNX_API OpSchema GetOpSchema<ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(domain, ver, name)>() {               \
+    return (impl).SetName(#name).SetDomain(domain_str).SinceVersion(ver).SetLocation(__FILE__, __LINE__); \
+  }                                                                                                       \
+  ONNX_OPERATOR_SET_SCHEMA_DEBUG_VARIABLE(name, domain, ver, dbg_included_in_static_opset)
+#ifndef NDEBUG
+#define ONNX_DBG_GET_COUNT_IN_OPSETS() DbgOperatorSetTracker::Instance().GetCount()
+
+#endif
+
+// Naming convention for operator schema classes
+#define ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(domain, ver, name) name##_##domain##_ver##ver
+
+// Naming convention for preview operator schema classes
+#define ONNX_PREVIEW_OPERATOR_SET_SCHEMA_CLASS_NAME(ver, name) \
+  ONNX_OPERATOR_SET_SCHEMA_CLASS_NAME(OnnxPreview, ver, name)
+
+// Helper function
+size_t ReplaceAll(std::string& s, const char* from, const char* to);
+
+// Legacy macros to register schema at static initialization
+#define ONNX_OPERATOR_SCHEMA(name) ONNX_OPERATOR_SCHEMA_UNIQ_HELPER(__COUNTER__, name)
+#define ONNX_OPERATOR_SCHEMA_UNIQ_HELPER(Counter, name) ONNX_OPERATOR_SCHEMA_UNIQ(Counter, name)
+#define ONNX_OPERATOR_SCHEMA_UNIQ(Counter, name)                                                       \
+  static ONNX_NAMESPACE::OpSchemaRegistry::OpSchemaRegisterOnce op_schema_register_once##name##Counter \
+      [[maybe_unused]] = ONNX_NAMESPACE::OpSchema(#name, __FILE__, __LINE__)
+
+ONNX_API inline std::string GenerateOptionalArgumentsDoc() {
+  return "This operator has **optional** inputs/outputs. "
+         "See [the doc](IR.md) for more details about the representation of "
+         "optional arguments. An empty string may be used in the place of "
+         "an actual argument's name to indicate a missing argument. "
+         "Trailing optional arguments (those not followed by an argument "
+         "that is present) may also be simply omitted.\n";
+}
+
+ONNX_API inline std::string GenerateBroadcastingDocMul() {
+  return "This operator supports **multidirectional (i.e., Numpy-style) broadcasting**;"
+         " for more details please check [the doc](Broadcasting.md).";
+}
+
+ONNX_API inline std::string GenerateBroadcastingDocUni(const char* from, const char* to) {
+  std::string ret = "This operator supports **unidirectional broadcasting** (";
+  ret = ret + from + " should be unidirectional broadcastable to " + to +
+      ");"
+      " for more details please check [the doc](Broadcasting.md).";
+  return ret;
+}
+
+/*
+ * Macros for setting operator documentation
+ * Use this macro for simple SetDoc() calls that generate documentation
+ * directly. This is the macro to use in almost all cases.
+ * Sample usage guidelines:
+ * const char* doc_str = "foo";
+ * SetDoc(GET_OP_DOC_STR(doc_str))
+ *
+ * SetDoc(GET_OP_DOC_STR(
+            std::string(BitShift_ver11_doc) + GenerateBroadcastingDocMul()))
+ */
+#ifndef __ONNX_NO_DOC_STRINGS
+#define GET_OP_DOC_STR(doc_str) (doc_str)
+#else
+#define GET_OP_DOC_STR(doc_str) ("")
+#endif
+
+/*
+ * Use this macro when the documentation needs to be populated in some
+ * complicated way like string substitutions, etc before calling SetDoc.
+ * Sample usage guidelines:
+    std::string doc;
+    POPULATE_OP_DOC_STR(
+        doc = R"DOC(
+Returns the tensor resulted from performing the `{name}` logical operation
+elementwise on the input tensors `A` and `B` (with Numpy-style broadcasting
+support).
+
+{broadcast_doc}
+)DOC";
+        ReplaceAll(doc, "{name}", name);
+        ReplaceAll(
+            doc, "{broadcast_doc}", GenerateBroadcastingDocMul().c_str()););
+    schema.SetDoc(doc);
+ *
+ */
+#ifndef __ONNX_NO_DOC_STRINGS
+#define POPULATE_OP_DOC_STR(DocPopulatorCode) \
+  do {                                        \
+    DocPopulatorCode                          \
+  } while (0)
+#else
+#define POPULATE_OP_DOC_STR(DocPopulatorCode)
+#endif
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/sequence/CMakeLists.txt b/onnx/defs/sequence/CMakeLists.txt
new file mode 100644
index 0000000..0011f05
--- /dev/null
+++ b/onnx/defs/sequence/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+    utils.cc
+    utils.h
+)
diff --git a/onnx/defs/sequence/defs.cc b/onnx/defs/sequence/defs.cc
new file mode 100644
index 0000000..6064607
--- /dev/null
+++ b/onnx/defs/sequence/defs.cc
@@ -0,0 +1,630 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/defs/function.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/sequence/utils.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static constexpr const char* SequenceEmpty_ver11_doc = R"DOC(
+Construct an empty tensor sequence, with given data type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SequenceEmpty,
+    11,
+    OpSchema()
+        .SetDoc(SequenceEmpty_ver11_doc)
+        .Attr(
+            "dtype",
+            "(Optional) The data type of the tensors in the output sequence. "
+            "The default type is 'float'.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Output(0, "output", "Empty sequence.", "S")
+        .TypeConstraint("S", OpSchema::all_tensor_sequence_types(), "Constrain output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const auto attr_proto = ctx.getAttribute("dtype");
+          auto elem_type = TensorProto::FLOAT;
+          if (nullptr != attr_proto) {
+            if (!attr_proto->has_i()) {
+              fail_type_inference("Attribute dtype should be of integer type and specify a type.");
+            }
+            auto attr_value = attr_proto->i();
+            elem_type = static_cast<TensorProto_DataType>(attr_value);
+          }
+          ctx.getOutputType(0)->mutable_sequence_type()->mutable_elem_type()->mutable_tensor_type()->set_elem_type(
+              elem_type);
+        }));
+
+static constexpr const char* SequenceConstruct_ver11_doc = R"DOC(
+Construct a tensor sequence containing 'inputs' tensors.
+All tensors in 'inputs' must have the same data type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SequenceConstruct,
+    11,
+    OpSchema()
+        .SetDoc(SequenceConstruct_ver11_doc)
+        .Input(0, "inputs", "Tensors.", "T", OpSchema::Variadic)
+        .Output(0, "output_sequence", "Sequence enclosing the input tensors.", "S")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input types to any tensor type.")
+        .TypeConstraint("S", OpSchema::all_tensor_sequence_types(), "Constrain output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const size_t numInputs = ctx.getNumInputs();
+          if (numInputs < 1) {
+            fail_type_inference("SequenceConstruct is expected to have at least 1 input.");
+          }
+
+          std::vector<int> input_elem_types;
+          input_elem_types.reserve(numInputs);
+          for (size_t i = 0; i < numInputs; ++i) {
+            auto input_type = ctx.getInputType(i);
+            if (nullptr == input_type) {
+              fail_type_inference("Input type for input at index ", i, " is null. Type info is expected.");
+            }
+            input_elem_types.emplace_back(input_type->tensor_type().elem_type());
+          }
+          if (std::adjacent_find(input_elem_types.begin(), input_elem_types.end(), std::not_equal_to()) !=
+              input_elem_types.end()) {
+            // not all input elem types are the same.
+            fail_type_inference("Element type of inputs are expected to be the same.");
+          }
+
+          auto output_tensor_type =
+              ctx.getOutputType(0)->mutable_sequence_type()->mutable_elem_type()->mutable_tensor_type();
+
+          output_tensor_type->set_elem_type(static_cast<TensorProto_DataType>(input_elem_types[0]));
+
+          if (!hasNInputShapes(ctx, numInputs)) {
+            return;
+          }
+
+          *(output_tensor_type->mutable_shape()) = ctx.getInputType(0)->tensor_type().shape();
+
+          for (size_t i = 1; i < numInputs; ++i) {
+            const auto& input_shape = ctx.getInputType(i)->tensor_type().shape();
+            UnionShapeInfo(input_shape, *output_tensor_type);
+          }
+        }));
+
+static constexpr const char* SequenceInsert_ver11_doc = R"DOC(
+Outputs a tensor sequence that inserts 'tensor' into 'input_sequence' at 'position'.
+'tensor' must have the same data type as 'input_sequence'.
+Accepted range for 'position' is in `[-n, n]`, where `n` is the number of tensors in 'input_sequence'.
+Negative value means counting positions from the back.
+'position' is optional, by default it inserts 'tensor' to the back of 'input_sequence'.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SequenceInsert,
+    11,
+    OpSchema()
+        .SetDoc(SequenceInsert_ver11_doc)
+        .Input(0, "input_sequence", "Input sequence.", "S")
+        .Input(1, "tensor", "Input tensor to be inserted into the input sequence.", "T")
+        .Input(
+            2,
+            "position",
+            "Position in the sequence where the new tensor is inserted. "
+            "It is optional and default is to insert to the back of the sequence. "
+            "Negative value means counting positions from the back. "
+            "Accepted range in `[-n, n]`, "
+            "where `n` is the number of tensors in 'input_sequence'. "
+            "It is an error if any of the index values are out of bounds. "
+            "It must be a scalar(tensor of empty shape).",
+            "I",
+            OpSchema::Optional)
+        .Output(0, "output_sequence", "Output sequence that contains the inserted tensor at given position.", "S")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain to any tensor type.")
+        .TypeConstraint("S", OpSchema::all_tensor_sequence_types(), "Constrain to any tensor type.")
+        .TypeConstraint(
+            "I",
+            {types::Int32, types::Int64},
+            "Constrain position to integral tensor. It must be a scalar(tensor of empty shape).")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const auto input0_type = ctx.getInputType(0);
+          const auto input1_type = ctx.getInputType(1);
+          if (nullptr == input0_type || nullptr == input1_type) {
+            fail_type_inference("Input Sequence and Tensor are expected to have type info. Current type is null.");
+          }
+          const auto seq_elem_type = input0_type->sequence_type().elem_type().tensor_type().elem_type();
+          const auto tensor_elem_type = input1_type->tensor_type().elem_type();
+          if (seq_elem_type != tensor_elem_type) {
+            fail_type_inference(
+                "Input Sequence and Tensor are expected to have the same elem type. Sequence=",
+                seq_elem_type,
+                " Tensor=",
+                tensor_elem_type);
+          }
+
+          auto output_tensor_type =
+              ctx.getOutputType(0)->mutable_sequence_type()->mutable_elem_type()->mutable_tensor_type();
+          output_tensor_type->set_elem_type(seq_elem_type);
+
+          if (!hasNInputShapes(ctx, 2)) {
+            return;
+          }
+
+          *(output_tensor_type->mutable_shape()) = input0_type->sequence_type().elem_type().tensor_type().shape();
+
+          UnionShapeInfo(input1_type->tensor_type().shape(), *output_tensor_type);
+        }));
+
+static constexpr const char* SequenceAt_ver11_doc = R"DOC(
+Outputs a tensor copy from the tensor at 'position' in 'input_sequence'.
+Accepted range for 'position' is in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'.
+Negative value means counting positions from the back.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SequenceAt,
+    11,
+    OpSchema()
+        .SetDoc(SequenceAt_ver11_doc)
+        .Input(0, "input_sequence", "Input sequence.", "S")
+        .Input(
+            1,
+            "position",
+            "Position of the tensor in the sequence. "
+            "Negative value means counting positions from the back. "
+            "Accepted range in `[-n, n - 1]`, "
+            "where `n` is the number of tensors in 'input_sequence'. "
+            "It is an error if any of the index values are out of bounds. "
+            "It must be a scalar(tensor of empty shape).",
+            "I")
+        .Output(0, "tensor", "Output tensor at the specified position in the input sequence.", "T")
+        .TypeConstraint("S", OpSchema::all_tensor_sequence_types(), "Constrain to any tensor type.")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain to any tensor type.")
+        .TypeConstraint(
+            "I",
+            {types::Int32, types::Int64},
+            "Constrain position to integral tensor. It must be a scalar(tensor of empty shape).")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const auto input0_type = ctx.getInputType(0);
+          if (nullptr == input0_type) {
+            fail_type_inference("Input type for input at index 0 is null. Type info is expected.");
+          }
+          ctx.getOutputType(0)->CopyFrom(input0_type->sequence_type().elem_type());
+        }));
+
+static constexpr const char* SequenceErase_ver11_doc = R"DOC(
+Outputs a tensor sequence that removes the tensor at 'position' from 'input_sequence'.
+Accepted range for 'position' is in `[-n, n - 1]`, where `n` is the number of tensors in 'input_sequence'.
+Negative value means counting positions from the back.
+'position' is optional, by default it erases the last tensor from 'input_sequence'.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SequenceErase,
+    11,
+    OpSchema()
+        .SetDoc(SequenceErase_ver11_doc)
+        .Input(0, "input_sequence", "Input sequence.", "S")
+        .Input(
+            1,
+            "position",
+            "Position of the tensor in the sequence. "
+            "Negative value means counting positions from the back. "
+            "Accepted range in `[-n, n - 1]`, "
+            "where `n` is the number of tensors in 'input_sequence'. "
+            "It is an error if any of the index values are out of bounds. "
+            "It must be a scalar(tensor of empty shape).",
+            "I",
+            OpSchema::Optional)
+        .Output(0, "output_sequence", "Output sequence that has the tensor at the specified position removed.", "S")
+        .TypeConstraint("S", OpSchema::all_tensor_sequence_types(), "Constrain to any tensor type.")
+        .TypeConstraint(
+            "I",
+            {types::Int32, types::Int64},
+            "Constrain position to integral tensor. It must be a scalar(tensor of empty shape).")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const auto input0_type = ctx.getInputType(0);
+          if (nullptr == input0_type) {
+            fail_type_inference("Input type for input at index 0 is null. Type info is expected.")
+          }
+          ctx.getOutputType(0)->CopyFrom(*input0_type);
+        }));
+
+static constexpr const char* SequenceLength_ver11_doc = R"DOC(
+Produces a scalar(tensor of empty shape) containing the number of tensors in 'input_sequence'.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SequenceLength,
+    11,
+    OpSchema()
+        .SetDoc(SequenceLength_ver11_doc)
+        .Input(0, "input_sequence", "Input sequence.", "S")
+        .Output(0, "length", "Length of input sequence. It must be a scalar(tensor of empty shape).", "I")
+        .TypeConstraint("S", OpSchema::all_tensor_sequence_types(), "Constrain to any tensor type.")
+        .TypeConstraint(
+            "I",
+            {types::Int64},
+            "Constrain output to integral tensor. It must be a scalar(tensor of empty shape).")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto output_tensor_type = ctx.getOutputType(0)->mutable_tensor_type();
+          output_tensor_type->set_elem_type(TensorProto::INT64);
+          output_tensor_type->mutable_shape()->Clear();
+        }));
+
+// Updated operators that consume/produce sequence of tensors.
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SplitToSequence,
+    24,
+    OpSchema().FillUsing(
+        defs::sequence::utils::SplitToSequenceOpGenerator(
+            OpSchema::all_tensor_types_ir4(),
+            OpSchema::all_tensor_sequence_types_ir4())));
+
+static constexpr const char* ConcatFromSequence_ver11_doc = R"DOC(
+Concatenate a sequence of tensors into a single tensor.
+All input tensors must have the same shape, except for the dimension size of the axis to concatenate on.
+By default 'new_axis' is 0, the behavior is similar to numpy.concatenate.
+When 'new_axis' is 1, the behavior is similar to numpy.stack.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ConcatFromSequence,
+    11,
+    OpSchema()
+        .Attr(
+            "axis",
+            "Which axis to concat on. Accepted range in `[-r, r - 1]`, "
+            "where `r` is the rank of input tensors. "
+            "When `new_axis` is 1, accepted range is `[-r - 1, r]`. ",
+            AttributeProto::INT)
+        .Attr(
+            "new_axis",
+            "Insert and concatenate on a new axis or not, "
+            "default 0 means do not insert new axis.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .SetDoc(ConcatFromSequence_ver11_doc)
+        .Input(0, "input_sequence", "Sequence of tensors for concatenation", "S")
+        .Output(0, "concat_result", "Concatenated tensor", "T")
+        .TypeConstraint("S", OpSchema::all_tensor_sequence_types(), "Constrain input types to any tensor type.")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const auto input0_type = ctx.getInputType(0);
+          if (nullptr == input0_type) {
+            fail_type_inference("Input type for input at index 0 is null. Type info is expected.")
+          }
+          auto elem_type = input0_type->sequence_type().elem_type().tensor_type().elem_type();
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(elem_type);
+
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          auto axis_attr = ctx.getAttribute("axis");
+          if (!axis_attr) {
+            fail_shape_inference("Required attribute axis is missing");
+          }
+          int axis = static_cast<int>(axis_attr->i());
+
+          int new_axis = 0;
+          auto new_axis_attr = ctx.getAttribute("new_axis");
+          if (new_axis_attr) {
+            new_axis = static_cast<int>(new_axis_attr->i());
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->sequence_type().elem_type().tensor_type().shape();
+          auto rank = input_shape.dim_size();
+          if (1 != new_axis && 0 != new_axis) {
+            fail_shape_inference("new_axis must be either 0 or 1");
+          }
+
+          auto upper_bound = 1 == new_axis ? rank : rank - 1;
+          auto lower_bound = 1 == new_axis ? -rank - 1 : -rank;
+
+          if (axis < lower_bound || axis > upper_bound) {
+            fail_shape_inference(
+                "Invalid value of attribute 'axis'. Accepted range=[",
+                lower_bound,
+                ", ",
+                upper_bound,
+                "], Value=",
+                axis);
+          }
+
+          if (axis < 0) {
+            axis += (upper_bound + 1);
+          }
+
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int i = 0; i <= upper_bound; ++i) {
+            output_shape->add_dim();
+            if (i != axis) {
+              output_shape->mutable_dim(i)->CopyFrom(input_shape.dim((i > axis && new_axis) ? i - 1 : i));
+            }
+          }
+        }));
+
+static constexpr const char* SequenceMap_ver17_doc = R"DOC(
+Applies a sub-graph to each sample in the input sequence(s).
+
+Inputs can be either tensors or sequences, with the exception of the first input which must
+be a sequence. The length of the first input sequence will determine the number of samples in the
+outputs. Any other sequence inputs should have the same number of samples. The number of inputs
+and outputs, should match the one of the subgraph.
+
+For each i-th element in the output, a sample will be extracted from the input sequence(s) at
+the i-th position and the sub-graph will be applied to it.
+The outputs will contain the outputs of the sub-graph for each sample, in the same order as in
+the input.
+
+This operator assumes that processing each sample is independent and could executed in parallel
+or in any order. Users cannot expect any specific ordering in which each subgraph is computed.)DOC";
+
+static void SequenceMapInferenceFunction(InferenceContext& ctx) {
+  auto num_inputs = ctx.getNumInputs();
+  assert(num_inputs > 0);
+
+  auto num_outputs = ctx.getNumOutputs();
+  assert(num_outputs > 0);
+
+  std::vector<TypeProto> tmp_type_protos(num_inputs);
+  std::vector<const TypeProto*> subgraph_input_types;
+  subgraph_input_types.reserve(num_inputs);
+  for (size_t inputIndex = 0; inputIndex < num_inputs; inputIndex++) {
+    const auto* const input_type = ctx.getInputType(inputIndex);
+    if (input_type == nullptr) {
+      fail_type_inference("Input ", inputIndex, " expected to have type info");
+    }
+    if (input_type->value_case() == TypeProto::kSequenceType) {
+      tmp_type_protos[inputIndex].CopyFrom(input_type->sequence_type().elem_type());
+      subgraph_input_types.push_back(&tmp_type_protos[inputIndex]);
+    } else {
+      if (inputIndex == 0)
+        fail_type_inference("Input ", inputIndex, " expected to be a sequence type");
+      subgraph_input_types.push_back(input_type);
+    }
+  }
+
+  GraphInferencer* graphInferencer = ctx.getGraphAttributeInferencer("body");
+  if (!graphInferencer)
+    fail_type_inference("Graph attribute inferencer for \"body\" not available");
+
+  std::vector<const TensorProto*> input_data(num_inputs, nullptr);
+  std::vector<const TypeProto*> subgraph_output_types =
+      graphInferencer->doInferencing(subgraph_input_types, input_data);
+
+  // if empty(), assume inferencing was skipped
+  if (!subgraph_output_types.empty()) {
+    if (subgraph_output_types.size() != num_outputs) {
+      fail_type_inference(
+          "Graph attribute inferencing returned type information for ",
+          subgraph_output_types.size(),
+          " outputs. Expected ",
+          num_outputs);
+    }
+
+    for (size_t outputIndex = 0; outputIndex < num_outputs; outputIndex++) {
+      const auto* const subgraph_output_type = subgraph_output_types[outputIndex];
+      ctx.getOutputType(outputIndex)->mutable_sequence_type()->mutable_elem_type()->CopyFrom(*subgraph_output_type);
+    }
+  }
+}
+
+static bool
+BuildSequenceMapBodyFunc(const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) {
+  schema.BuildFunction(functionProto);
+
+  // variadic input/outputs will be expanded
+  functionProto.clear_input();
+  functionProto.clear_output();
+
+  const auto* const body_attr = ctx.getAttribute("body");
+  if (!body_attr || !body_attr->has_g())
+    ONNX_THROW_EX(std::invalid_argument("Invalid ``body`` argument. Expected a graph"));
+  const GraphProto& body = body_attr->g();
+
+  auto g_inputs = body.input();
+  int ninputs = g_inputs.size();
+  if (ninputs < 1)
+    ONNX_THROW_EX(std::invalid_argument("Expected 1 or more inputs."));
+
+  auto g_outputs = body.output();
+  int noutputs = g_outputs.size();
+  if (noutputs < 1)
+    ONNX_THROW_EX(std::invalid_argument("Expected 1 or more outputs."));
+
+  if (!ctx.hasInput(0))
+    ONNX_THROW_EX(std::invalid_argument("Input 0 expected but not provided"));
+
+  const auto* const first_input_type = ctx.getInputType(0);
+  assert(first_input_type);
+  if (!first_input_type->has_sequence_type())
+    ONNX_THROW_EX(std::invalid_argument("Expected a sequence type for input 0"));
+
+  auto const& schema_inputs = schema.inputs();
+  auto const& input_0_name = schema_inputs[0].GetName();
+  auto const& input_1_name = schema_inputs[1].GetName(); // variadic input
+
+  *functionProto.add_input() = input_0_name;
+  for (int i = 1; i < ninputs; i++) {
+    if (!ctx.hasInput(i))
+      ONNX_THROW_EX(std::invalid_argument(MakeString("Input ", i, " expected but not provided")));
+    *functionProto.add_input() = MakeString(input_1_name, "_", i);
+  }
+
+  auto const& schema_outputs = schema.outputs();
+  auto output_0_name = schema_outputs[0].GetName();
+  for (int i = 0; i < noutputs; i++) {
+    if (!ctx.hasOutput(i))
+      ONNX_THROW_EX(std::invalid_argument(MakeString("Output ", i, " expected but not provided")));
+    *functionProto.add_output() = MakeString(output_0_name, "_", i);
+  }
+
+  // Loop body subgraph
+  const std::string loopbody_graph_name("SequenceMap_loop_body");
+  GraphProto loopbody_graph;
+  loopbody_graph.set_name(loopbody_graph_name);
+  {
+    TypeProto int64_type;
+    int64_type.mutable_tensor_type()->set_elem_type(TensorProto_DataType_INT64);
+    int64_type.mutable_tensor_type()->mutable_shape()->Clear();
+
+    TypeProto bool_type;
+    bool_type.mutable_tensor_type()->set_elem_type(TensorProto_DataType_BOOL);
+    bool_type.mutable_tensor_type()->mutable_shape()->Clear();
+
+    ValueInfoProto iter_count;
+    std::string iter_count_name = loopbody_graph_name + "_itercount";
+    iter_count.set_name(iter_count_name);
+    *iter_count.mutable_type() = int64_type;
+    *loopbody_graph.add_input() = iter_count;
+
+    ValueInfoProto cond_in;
+    std::string cond_in_name = loopbody_graph_name + "_cond_in";
+    cond_in.set_name(cond_in_name);
+    *cond_in.mutable_type() = bool_type;
+    *loopbody_graph.add_input() = cond_in;
+
+    ValueInfoProto cond_out;
+    std::string cond_out_name = loopbody_graph_name + "_cond_out";
+    cond_out.set_name(cond_out_name);
+    *cond_out.mutable_type() = bool_type;
+    *loopbody_graph.add_output() = cond_out;
+
+    NodeProto cond_identity;
+    cond_identity.set_domain(ONNX_DOMAIN);
+    cond_identity.set_op_type("Identity");
+    cond_identity.add_input(cond_in_name);
+    cond_identity.add_output(cond_out_name);
+    *loopbody_graph.add_node() = cond_identity;
+
+    for (int inputIndex = 0; inputIndex < ninputs; inputIndex++) {
+      const auto* const input_type = ctx.getInputType(inputIndex);
+      if (input_type && input_type->has_sequence_type()) {
+        // If it's a sequence input, extract ``iter_count`` element
+        NodeProto seq_at_node;
+        seq_at_node.set_domain(ONNX_DOMAIN);
+        seq_at_node.set_op_type("SequenceAt");
+        seq_at_node.add_input(functionProto.input(inputIndex));
+        seq_at_node.add_input(iter_count_name);
+        seq_at_node.add_output(g_inputs.Get(inputIndex).name());
+        *loopbody_graph.add_node() = std::move(seq_at_node);
+      } else {
+        // If not a sequence, simply connect
+        NodeProto identity;
+        identity.set_domain(ONNX_DOMAIN);
+        identity.set_op_type("Identity");
+        identity.add_input(functionProto.input(inputIndex));
+        identity.add_output(g_inputs.Get(inputIndex).name());
+        *loopbody_graph.add_node() = std::move(identity);
+      }
+    }
+
+    for (const auto& item : body.node())
+      *loopbody_graph.add_node() = item;
+    for (const auto& item : body.value_info())
+      *loopbody_graph.add_value_info() = item;
+    for (const auto& item : body.initializer())
+      *loopbody_graph.add_initializer() = item;
+    for (const auto& item : body.sparse_initializer())
+      *loopbody_graph.add_sparse_initializer() = item;
+
+    for (int outputIndex = 0; outputIndex < noutputs; outputIndex++) {
+      const auto& body_out_i = body.output(outputIndex);
+      assert(body_out_i.type().has_tensor_type());
+      std::string prefix = loopbody_graph_name + "_" + body_out_i.name();
+      std::string loopbody_in_name = prefix + "_in";
+
+      ValueInfoProto tmp;
+      *tmp.mutable_type()->mutable_sequence_type()->mutable_elem_type()->mutable_tensor_type() =
+          body_out_i.type().tensor_type();
+      tmp.set_name(loopbody_in_name);
+      *loopbody_graph.add_input() = tmp;
+
+      std::string loopbody_out_name = prefix + "_out";
+      tmp.set_name(loopbody_out_name);
+      *loopbody_graph.add_output() = tmp;
+
+      NodeProto seq_insert_node;
+      seq_insert_node.set_domain(ONNX_DOMAIN);
+      seq_insert_node.set_op_type("SequenceInsert");
+      seq_insert_node.add_input(loopbody_in_name);
+      seq_insert_node.add_input(body_out_i.name());
+      seq_insert_node.add_output(loopbody_out_name);
+      *loopbody_graph.add_node() = seq_insert_node;
+    }
+  }
+
+  std::vector<FunctionBodyHelper::NodeDef> nodes;
+
+  // TODO(ONNX): figure out a way to prevent name collisions?
+  auto first_input_name = functionProto.input(0);
+  std::string prefix = MakeString("SequenceMap_", first_input_name);
+  std::string seqlen = prefix + "_seqlen";
+  nodes.push_back({{seqlen}, "SequenceLength", {first_input_name}});
+
+  std::string cond_bool = prefix + "_cond";
+  nodes.push_back(FunctionBodyHelper::Const<bool>(cond_bool, true));
+
+  std::vector<std::string> loop_node_inputs = {seqlen, cond_bool};
+  std::vector<std::string> loop_node_outputs;
+  for (int outputIndex = 0; outputIndex < noutputs; outputIndex++) {
+    auto output_name = functionProto.output(outputIndex);
+    std::string out_prefix = MakeString("SequenceMap_", output_name);
+
+    std::string seqempty_name = out_prefix + "_seqempty";
+    int64_t dtype = g_outputs.Get(outputIndex).type().tensor_type().elem_type();
+    nodes.push_back({{seqempty_name}, "SequenceEmpty", {}, {MakeAttribute("dtype", dtype)}});
+    loop_node_inputs.emplace_back(std::move(seqempty_name));
+    loop_node_outputs.emplace_back(std::move(output_name));
+  }
+
+  nodes.push_back({loop_node_outputs, "Loop", loop_node_inputs, {MakeAttribute("body", loopbody_graph)}});
+
+  auto func_nodes = FunctionBodyHelper::BuildNodes(nodes);
+  for (const auto& node : func_nodes) {
+    auto* new_node = functionProto.add_node();
+    new_node->CopyFrom(node);
+  }
+
+  return true;
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SequenceMap,
+    17,
+    OpSchema()
+        .SetDoc(SequenceMap_ver17_doc)
+        .Attr(
+            "body",
+            "The graph to be run for each sample in the sequence(s). "
+            "It should have as many inputs and outputs as inputs and "
+            "outputs to the SequenceMap function.",
+            AttributeProto::GRAPH)
+        .Input(0, "input_sequence", "Input sequence.", "S")
+        .Input(1, "additional_inputs", "Additional inputs to the graph", "V", OpSchema::Variadic, false, 0)
+        .Output(0, "out_sequence", "Output sequence(s)", "S", OpSchema::Variadic, false)
+        .TypeConstraint("S", OpSchema::all_tensor_sequence_types(), "Constrain input types to any sequence type.")
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types();
+              auto s = OpSchema::all_tensor_sequence_types();
+              t.insert(t.end(), s.begin(), s.end());
+              return t;
+            }(),
+            "Constrain to any tensor or sequence type.")
+        // Setting `NonDeterministic` since it needs to be evaluated after function inlining
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::NonDeterministic)
+        .SetContextDependentFunctionBodyBuilder(BuildSequenceMapBodyFunc)
+        .TypeAndShapeInferenceFunction(SequenceMapInferenceFunction));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/sequence/old.cc b/onnx/defs/sequence/old.cc
new file mode 100644
index 0000000..23e65c6
--- /dev/null
+++ b/onnx/defs/sequence/old.cc
@@ -0,0 +1,18 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/sequence/utils.h"
+
+namespace ONNX_NAMESPACE {
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SplitToSequence,
+    11,
+    OpSchema().FillUsing(
+        defs::sequence::utils::SplitToSequenceOpGenerator(
+            OpSchema::all_tensor_types(),
+            OpSchema::all_tensor_sequence_types())));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/sequence/utils.cc b/onnx/defs/sequence/utils.cc
new file mode 100644
index 0000000..1451312
--- /dev/null
+++ b/onnx/defs/sequence/utils.cc
@@ -0,0 +1,194 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+#include "onnx/defs/sequence/utils.h"
+
+#include <algorithm>
+#include <numeric>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+namespace defs {
+namespace sequence {
+namespace utils {
+
+// Common documentation for SplitToSequence operator, versions 11 and 24
+static constexpr const char* SplitToSequence_ver11_doc =
+    R"DOC(
+Split a tensor into a sequence of tensors, along the specified 'axis'.
+Lengths of the parts can be specified using the optional argument 'split'.
+If the argument `split' is not specified, a default scalar value of 1
+is used as the value of `split'.
+'split' must contain only positive numbers.
+'split' is either a scalar (tensor of empty shape), or a 1-D tensor.
+If 'split' is a scalar, then 'input' will be split into chunks all of size 'split'
+if possible. The last chunk alone may be smaller than 'split' if the 'input' size
+along the given axis 'axis' is not divisible by 'split'.
+If 'split' is a 1-dimensional tensor, the input tensor is split into 'size(split)' chunks,
+with lengths of the parts on 'axis' specified in 'split'. In this scenario, the sum of entries
+in 'split' must be equal to the dimension size of input tensor on 'axis'.
+)DOC";
+
+std::function<void(OpSchema&)> SplitToSequenceOpGenerator(
+    std::vector<std::string> input_types,
+    std::vector<std::string> output_types) {
+  return [input_types = std::move(input_types), output_types = std::move(output_types)](OpSchema& schema) {
+    schema.Input(0, "input", "The tensor to split", "T")
+        .Input(
+            1,
+            "split",
+            "Length of each output. "
+            "It can be either a scalar(tensor of empty shape), or a 1-D tensor. All values must be >= 0. ",
+            "I",
+            OpSchema::Optional)
+        .Output(0, "output_sequence", "One or more outputs forming a sequence of tensors after splitting", "S")
+        .TypeConstraint("T", input_types, "Constrain input types to all tensor types.")
+        .TypeConstraint("I", {types::Int32, types::Int64}, "Constrain split size to integral tensor.")
+        .TypeConstraint("S", output_types, "Constrain output types to all tensor types.")
+        .Attr(
+            "axis",
+            "Which axis to split on. "
+            "A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1].",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "keepdims",
+            "Keep the split dimension or not. Default 1, which means we keep split dimension. "
+            "If input 'split' is specified, this attribute is ignored.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .SetDoc(SplitToSequence_ver11_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          const auto* const input0_type = ctx.getInputType(0);
+          if (nullptr == input0_type) {
+            fail_type_inference("Input type for input at index 0 is null. Type info is expected.")
+          }
+          ctx.getOutputType(0)->mutable_sequence_type()->mutable_elem_type()->mutable_tensor_type()->set_elem_type(
+              input0_type->tensor_type().elem_type());
+
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+
+          const auto& inputShape = input0_type->tensor_type().shape();
+
+          int r = inputShape.dim_size();
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 0));
+          if (axis < -r || axis > r - 1) {
+            fail_shape_inference("Invalid value of attribute 'axis'. Rank=", r, " Value=", axis);
+          }
+          if (axis < 0) {
+            axis += r;
+          }
+
+          size_t num_inputs = ctx.getNumInputs();
+          int64_t splitSize = 1;
+          int64_t keepdims = 1;
+          if (num_inputs == 1) {
+            // input split is omitted, default to split by 1.
+            const auto* const attr_proto = ctx.getAttribute("keepdims");
+            if (attr_proto) {
+              keepdims = attr_proto->i();
+            }
+          } else {
+            splitSize = [&]() -> int64_t {
+              // Need input split shape info and initializer data to infer split sizes.
+              if (!hasInputShape(ctx, 1)) {
+                return -1;
+              }
+              const TensorProto* splitInitializer = ctx.getInputData(1);
+              if (nullptr == splitInitializer || !splitInitializer->has_data_type()) {
+                return -1;
+              }
+
+              std::vector<int64_t> splitSizes;
+              if (splitInitializer->data_type() == TensorProto::INT64) {
+                const auto data = ParseData<int64_t>(splitInitializer);
+                splitSizes.insert(splitSizes.end(), data.begin(), data.end());
+              } else if (splitInitializer->data_type() == TensorProto::INT32) {
+                const auto data = ParseData<int32_t>(splitInitializer);
+                splitSizes.insert(splitSizes.end(), data.begin(), data.end());
+              } else {
+                // unaccepted data type
+                fail_shape_inference("Only supports `int32_t` or `int64_t` inputs for split");
+              }
+
+              if (splitSizes.empty()) {
+                fail_shape_inference("Input 'split' can not be empty.");
+              }
+
+              const auto& splitDim = inputShape.dim(axis);
+              if (!splitDim.has_dim_value()) {
+                // Unable to verify nor infer exact split dimension size.
+                return -1;
+              }
+
+              int64_t splitDimValue = splitDim.dim_value();
+              const auto& splitShape = getInputShape(ctx, 1);
+              if (splitShape.dim_size() == 0) {
+                // split is scalar
+                if (splitDimValue % splitSizes[0] == 0) {
+                  // all output chunks have the same shape, assign that to output sequence shape.
+                  return splitSizes[0];
+                }
+                return -1;
+              } else {
+                // split is 1-D tensor
+                int64_t splitSizesSum = std::accumulate(splitSizes.begin(), splitSizes.end(), static_cast<int64_t>(0));
+                if (splitDimValue != splitSizesSum) {
+                  fail_shape_inference(
+                      "Sum of split values not equal to 'input' dim size on 'axis'. 'axis' dim size=",
+                      splitDimValue,
+                      " sum of split values=",
+                      splitSizesSum);
+                }
+                if (std::adjacent_find(splitSizes.begin(), splitSizes.end(), std::not_equal_to()) == splitSizes.end()) {
+                  // all split sizes are the same.
+                  return splitSizes[0];
+                }
+                return -1;
+              }
+            }();
+          }
+
+          if (keepdims) {
+            auto* outputShape = ctx.getOutputType(0)
+                                    ->mutable_sequence_type()
+                                    ->mutable_elem_type()
+                                    ->mutable_tensor_type()
+                                    ->mutable_shape();
+            *outputShape = inputShape;
+            auto* dim = outputShape->mutable_dim(axis);
+            // Tensors in sequence could not have different shapes explicitly.
+            // Only assign dim_value when all chunks have the same shape.
+            if (splitSize > 0) {
+              dim->set_dim_value(splitSize);
+            } else {
+              dim->clear_dim_value();
+              dim->clear_dim_param();
+            }
+          } else {
+            TensorShapeProto* outputShape = ctx.getOutputType(0)
+                                                ->mutable_sequence_type()
+                                                ->mutable_elem_type()
+                                                ->mutable_tensor_type()
+                                                ->mutable_shape();
+            for (int i = 0; i < inputShape.dim_size(); ++i) {
+              if (i != axis) {
+                auto* dim = outputShape->add_dim();
+                dim->CopyFrom(inputShape.dim(i));
+              }
+            }
+          }
+        });
+  };
+}
+
+} // namespace utils
+} // namespace sequence
+} // namespace defs
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/sequence/utils.h b/onnx/defs/sequence/utils.h
new file mode 100644
index 0000000..52bbd65
--- /dev/null
+++ b/onnx/defs/sequence/utils.h
@@ -0,0 +1,27 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/shape_inference.h"
+#include "onnx/defs/tensor_proto_util.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+namespace defs {
+namespace sequence {
+namespace utils {
+
+std::function<void(OpSchema&)> SplitToSequenceOpGenerator(
+    std::vector<std::string> input_types,
+    std::vector<std::string> output_types);
+
+}
+} // namespace sequence
+} // namespace defs
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/shape_inference.cc b/onnx/defs/shape_inference.cc
new file mode 100644
index 0000000..23d6e3e
--- /dev/null
+++ b/onnx/defs/shape_inference.cc
@@ -0,0 +1,610 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/shape_inference.h"
+
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/defs/data_type_utils.h"
+#include "onnx/defs/tensor_proto_util.h"
+
+namespace ONNX_NAMESPACE {
+
+// Note: for all methods below for propagating type or shape, callers are
+// responsible to handle optional inputs/outputs and ensure that the specified
+// index value is less than NumInputs/NumOutputs.
+// Supports mixed tensor and sparse tensor
+void propagateElemTypeFromTensorInputToOutput(InferenceContext& ctx, size_t inputIndex, size_t outputIndex) {
+  const auto* const input_type = ctx.getInputType(inputIndex);
+  if (nullptr == input_type) {
+    fail_type_inference("Input type was null");
+  }
+
+  const auto input_value_case = input_type->value_case();
+  if (input_value_case != TypeProto::kTensorType && input_value_case != TypeProto::kSparseTensorType) {
+    fail_type_inference(
+        "Input ", inputIndex, " expected to have tensor or sparse tensor type. Got: ", input_value_case);
+  }
+
+  const auto input_elem_type = getTensorElementType(*input_type);
+  if (input_elem_type == TensorProto::UNDEFINED) {
+    fail_type_inference("Element type of input ", inputIndex, " unknown");
+  }
+  auto* output_type = ctx.getOutputType(outputIndex);
+  const auto output_value_case = output_type->value_case();
+  if (output_value_case == TypeProto::kTensorType || output_value_case == TypeProto::kSparseTensorType) {
+    setTensorElementType(input_elem_type, output_value_case, *output_type);
+  } else if (output_value_case == TypeProto::VALUE_NOT_SET) {
+    // Assume output will have the same type
+    setTensorElementType(input_elem_type, input_value_case, *output_type);
+  } else {
+    // This is not expected to happen
+    fail_type_inference(
+        "Output ", outputIndex, " expected to have tensor or sparse tensor type. Got: ", output_value_case);
+  }
+}
+
+static void propagateElemTypeFromSequenceInputToOutput(InferenceContext& ctx, size_t inputIndex, size_t outputIndex) {
+  const auto* const input_type = ctx.getInputType(inputIndex);
+  if (nullptr == input_type || input_type->value_case() != TypeProto::kSequenceType) {
+    fail_type_inference("Input ", inputIndex, " expected to have sequence type");
+  }
+  auto input_seq_type = input_type->sequence_type();
+  if (!input_seq_type.has_elem_type()) {
+    fail_type_inference("Element type of sequence input ", inputIndex, " unknown");
+  }
+
+  auto* output_type = ctx.getOutputType(outputIndex);
+  output_type->mutable_sequence_type()->mutable_elem_type()->CopyFrom(input_seq_type.elem_type());
+}
+
+static void propagateElemTypeFromOptionalInputToOutput(InferenceContext& ctx, size_t inputIndex, size_t outputIndex) {
+  const auto* const input_type = ctx.getInputType(inputIndex);
+  if (nullptr == input_type || input_type->value_case() != TypeProto::kOptionalType) {
+    fail_type_inference("Input ", inputIndex, " expected to have optional type");
+  }
+  auto input_opt_type = input_type->optional_type();
+  if (!input_opt_type.has_elem_type()) {
+    fail_type_inference("Element type of optional input ", inputIndex, " unknown");
+  }
+
+  auto* output_type = ctx.getOutputType(outputIndex);
+  output_type->mutable_optional_type()->mutable_elem_type()->CopyFrom(input_opt_type.elem_type());
+}
+
+static void propagateElemTypeFromMapInputToOutput(InferenceContext& ctx, size_t inputIndex, size_t outputIndex) {
+  const auto* const input_type = ctx.getInputType(inputIndex);
+  if (nullptr == input_type || input_type->value_case() != TypeProto::kMapType) {
+    fail_type_inference("Input ", inputIndex, " expected to have map type");
+  }
+  auto input_map_type = input_type->map_type();
+  if (!input_map_type.has_key_type()) {
+    fail_type_inference("Key type of map input ", inputIndex, " unknown");
+  }
+  if (!input_map_type.has_value_type()) {
+    fail_type_inference("Value type of map input ", inputIndex, " unknown");
+  }
+
+  auto* output_type = ctx.getOutputType(outputIndex);
+  output_type->mutable_map_type()->set_key_type(input_map_type.key_type());
+  output_type->mutable_map_type()->mutable_value_type()->CopyFrom(input_map_type.value_type());
+}
+
+void propagateElemTypeFromInputToOutput(InferenceContext& ctx, size_t inputIndex, size_t outputIndex) {
+  const auto* const input_type = ctx.getInputType(inputIndex);
+  if (nullptr == input_type) {
+    fail_type_inference("Input ", inputIndex, " expected to have type but instead is null");
+  }
+  const auto input_value_case = input_type->value_case();
+  if (input_value_case == TypeProto::kTensorType || input_value_case == TypeProto::kSparseTensorType) {
+    propagateElemTypeFromTensorInputToOutput(ctx, inputIndex, outputIndex);
+  } else if (input_value_case == TypeProto::kSequenceType) {
+    propagateElemTypeFromSequenceInputToOutput(ctx, inputIndex, outputIndex);
+  } else if (input_value_case == TypeProto::kOptionalType) {
+    propagateElemTypeFromOptionalInputToOutput(ctx, inputIndex, outputIndex);
+  } else if (input_value_case == TypeProto::kMapType) {
+    propagateElemTypeFromMapInputToOutput(ctx, inputIndex, outputIndex);
+  }
+}
+
+/*
+Merge shape information from a source shape into a target shape.
+* merges each TensorShapeProto_Dimension separately.
+* prefer values over params.
+* If both have values, values must match.
+* prefer target param over source param if mismatched.
+* Fail if there are mismatches in number of dimensions or dimension values.
+*/
+static void mergeInShapeInfo(const TensorShapeProto& source, TensorShapeProto& target) {
+  auto num_source_dims = source.dim_size();
+  auto num_target_dims = target.dim_size();
+  if (num_source_dims != num_target_dims) {
+    fail_shape_inference(
+        "Mismatch between number of inferred and declared dimensions. inferred=",
+        num_source_dims,
+        " declared=",
+        num_target_dims);
+  }
+
+  const auto& source_dims = source.dim();
+  auto* target_dims = target.mutable_dim();
+
+  for (int i = 0, end = source_dims.size(); i < end; ++i) {
+    const auto& source_dim = source_dims.Get(i);
+    auto& target_dim = *target_dims->Mutable(i);
+    mergeInDimensionInfo(source_dim, target_dim, i);
+  }
+}
+
+void mergeInShapeInfo(const TensorShapeProto& source_shape, TypeProto_Tensor& target_type) {
+  if (target_type.has_shape()) {
+    // merge with existing info.
+    mergeInShapeInfo(source_shape, *target_type.mutable_shape());
+  } else {
+    // copy to target
+    (*target_type.mutable_shape()) = source_shape;
+  }
+}
+
+void mergeInShapeInfo(const TensorShapeProto& source_shape, TypeProto_SparseTensor& target_type) {
+  if (target_type.has_shape()) {
+    // merge with existing info.
+    mergeInShapeInfo(source_shape, *target_type.mutable_shape());
+  } else {
+    // copy to target
+    (*target_type.mutable_shape()) = source_shape;
+  }
+}
+
+/*
+Merge the shape information from two TypeProto_Tensor instances.
+Values are merged into target from source.
+If target has no shape information, copy from source.
+If source has no shape information, ignore source.
+If both have shape information:
+- merge each TensorShapeProto_Dimension separately.
+- Prefer values over params. If both have values, values must match.
+- Prefer target param over source param if mismatched.
+Fail if there are mismatches in number of dimensions or dimension values.
+*/
+void mergeInShapeInfo(const TypeProto_Tensor& source, TypeProto_Tensor& target) {
+  if (source.has_shape())
+    mergeInShapeInfo(source.shape(), target);
+}
+
+void mergeInShapeInfo(const TypeProto_SparseTensor& source, TypeProto_SparseTensor& target) {
+  if (source.has_shape())
+    mergeInShapeInfo(source.shape(), target);
+}
+
+/// <summary>
+/// Utility function for UnionShapeInfoForTensor.
+/// Both shapes must be of the same rank
+/// </summary>
+/// <param name="source_shape"></param>
+/// <param name="target_shape">destination shape</param>
+static void UnionShapeInfo(const TensorShapeProto& source_shape, TensorShapeProto& target_shape) {
+  auto source_rank = source_shape.dim_size();
+  for (int i = 0; i < source_rank; ++i) {
+    const auto& source_dim = source_shape.dim(i);
+    const auto target_dim = target_shape.dim(i);
+    bool is_dims_conflict = [&]() {
+      if (source_dim.has_dim_value()) {
+        return !target_dim.has_dim_value() || target_dim.dim_value() != source_dim.dim_value();
+      }
+
+      if (source_dim.has_dim_param()) {
+        return !(target_dim.has_dim_param() && target_dim.dim_param() == source_dim.dim_param());
+      }
+
+      return (target_dim.has_dim_value() || target_dim.has_dim_param());
+    }();
+    if (is_dims_conflict && (target_dim.has_dim_value() || target_dim.has_dim_param())) {
+      auto* dim = target_shape.mutable_dim(i);
+      dim->clear_dim_value();
+      dim->clear_dim_param();
+    }
+  }
+}
+
+template <typename TENSOR_TYPE>
+static void UnionShapeInfoForTensor(const TensorShapeProto& source_shape, TENSOR_TYPE& target_type) {
+  if (target_type.has_shape()) {
+    TensorShapeProto* target_shape = target_type.mutable_shape();
+
+    auto source_rank = source_shape.dim_size();
+    auto target_rank = target_shape->dim_size();
+    if (source_rank != target_rank) {
+      target_type.clear_shape();
+      return;
+    }
+
+    UnionShapeInfo(source_shape, *target_shape);
+  }
+}
+
+void UnionShapeInfo(const TensorShapeProto& source_shape, TypeProto_Tensor& target_type) {
+  UnionShapeInfoForTensor(source_shape, target_type);
+}
+
+static void UnionShapeInfo(const TypeProto_Tensor& source_type, TypeProto_Tensor& target_type) {
+  // The union of a tensor of unknown rank and a tensor of known rank is a tensor of unknown rank.
+  // Hence, if the source_type had unknown rank, we clear the shape of the target_type.
+  // Otherwise, UnionShapeInfoForTensor handles the rest.
+  if (source_type.has_shape()) {
+    UnionShapeInfoForTensor(source_type.shape(), target_type);
+  } else {
+    target_type.clear_shape();
+  }
+}
+
+static void UnionShapeInfo(const TypeProto_SparseTensor& source_type, TypeProto_SparseTensor& target_type) {
+  // The union of a tensor of unknown rank and a tensor of known rank is a tensor of unknown rank.
+  // Hence, if the source_type had unknown rank, we clear the shape of the target_type.
+  // Otherwise, UnionShapeInfoForTensor handles the rest.
+  if (source_type.has_shape()) {
+    UnionShapeInfoForTensor(source_type.shape(), target_type);
+  } else {
+    target_type.clear_shape();
+  }
+}
+
+void UnionShapeInfo(const TensorShapeProto& source_shape, TypeProto_SparseTensor& target_type) {
+  UnionShapeInfoForTensor(source_shape, target_type);
+}
+
+void UnionTypeInfo(const TypeProto& source_type, TypeProto& target_type) {
+  if (source_type.value_case() != target_type.value_case()) {
+    fail_type_inference(
+        "Mismatched type:", " inferred=", source_type.value_case(), " declared=", target_type.value_case());
+  }
+
+  const auto target_case = target_type.value_case();
+  if (target_case == TypeProto::ValueCase::kTensorType) {
+    auto source_elem_type = source_type.tensor_type().elem_type();
+    auto target_elem_type = target_type.tensor_type().elem_type();
+
+    if (source_elem_type != target_elem_type) {
+      fail_type_inference(
+          "Mismatched tensor element type:",
+          " inferred=",
+          Utils::DataTypeUtils::ToDataTypeString(source_elem_type),
+          " declared=",
+          Utils::DataTypeUtils::ToDataTypeString(target_elem_type));
+    }
+
+    UnionShapeInfo(source_type.tensor_type(), *target_type.mutable_tensor_type());
+  } else if (target_case == TypeProto::ValueCase::kSparseTensorType) {
+    auto source_elem_type = source_type.sparse_tensor_type().elem_type();
+    auto target_elem_type = target_type.sparse_tensor_type().elem_type();
+    if (source_elem_type != target_elem_type) {
+      fail_type_inference(
+          "Mismatched sparse tensor element type:",
+          " inferred=",
+          Utils::DataTypeUtils::ToDataTypeString(source_elem_type),
+          " declared=",
+          Utils::DataTypeUtils::ToDataTypeString(target_elem_type));
+    }
+    UnionShapeInfo(source_type.sparse_tensor_type(), *target_type.mutable_sparse_tensor_type());
+  } else if (target_case == TypeProto::ValueCase::kSequenceType) {
+    if (!source_type.sequence_type().has_elem_type()) {
+      fail_type_inference("source sequence type missing element type.");
+    }
+    if (!target_type.sequence_type().has_elem_type()) {
+      fail_type_inference("target sequence type missing element type.");
+    }
+    UnionTypeInfo(source_type.sequence_type().elem_type(), *target_type.mutable_sequence_type()->mutable_elem_type());
+  } else if (target_case == TypeProto::ValueCase::kOptionalType) {
+    if (!source_type.optional_type().has_elem_type()) {
+      fail_type_inference("source optional type missing element type.");
+    }
+    if (!target_type.optional_type().has_elem_type()) {
+      fail_type_inference("target optional type missing element type.");
+    }
+    UnionTypeInfo(source_type.optional_type().elem_type(), *target_type.mutable_optional_type()->mutable_elem_type());
+  } else if (target_case == TypeProto::ValueCase::kMapType) {
+    if (!source_type.map_type().has_key_type()) {
+      fail_type_inference("source map type missing key type.");
+    }
+    if (!target_type.map_type().has_key_type()) {
+      fail_type_inference("target map type missing key type.");
+    }
+    auto source_key_type = source_type.map_type().key_type();
+    auto target_key_type = target_type.map_type().key_type();
+    if (source_key_type != target_key_type) {
+      fail_type_inference(
+          "Mismatched map tensor key type:",
+          " inferred=",
+          Utils::DataTypeUtils::ToDataTypeString(source_key_type),
+          " declared=",
+          Utils::DataTypeUtils::ToDataTypeString(target_key_type));
+    }
+
+    if (!source_type.map_type().has_value_type()) {
+      fail_type_inference("source map type missing value type.");
+    }
+    if (!target_type.map_type().has_value_type()) {
+      fail_type_inference("target map type missing value type.");
+    }
+    UnionTypeInfo(source_type.map_type().value_type(), *target_type.mutable_map_type()->mutable_value_type());
+  }
+}
+
+// Supports both Tensor and SparseTensor
+// This does not fail if input_type is Tensor and output type is SparseTensor
+// or the other way around. This is to support mixed cases when an op receives
+// sparse input and outputs dense or vice-versa.
+// If the output value_case is not set, then
+// the input value_case is propagated.
+static void propagateTensorElemTypeWithValidation(const TypeProto& input_type, TypeProto& output_type) {
+  int32_t input_elem_type = TensorProto::UNDEFINED;
+  const auto input_value_case = input_type.value_case();
+  if (input_value_case == TypeProto::kTensorType || input_value_case == TypeProto::kSparseTensorType) {
+    input_elem_type = getTensorElementType(input_type);
+    if (input_elem_type == TensorProto::UNDEFINED) {
+      fail_type_inference("Element type of tensor or sparse tensor input was unknown");
+    }
+  } else {
+    fail_type_inference("Input was expected to have tensor or sparse tensor type. Got ", input_value_case);
+  }
+
+  const auto output_value_case = output_type.value_case();
+  if (output_value_case == TypeProto::VALUE_NOT_SET) {
+    setTensorElementType(input_elem_type, input_value_case, output_type);
+  } else if (output_value_case == TypeProto::kTensorType || output_value_case == TypeProto::kSparseTensorType) {
+    const auto output_elem_type = getTensorElementType(output_type);
+    if (output_elem_type != TensorProto::UNDEFINED) {
+      if (input_elem_type != output_elem_type) {
+        fail_type_inference(
+            "Input element type of ", input_elem_type, " does not match existing output type of ", output_elem_type);
+      }
+    } else {
+      setTensorElementType(input_elem_type, output_value_case, output_type);
+    }
+  } else {
+    // This is not expected to happen
+    fail_type_inference("Output was expected to have tensor type. Got ", output_value_case);
+  }
+}
+
+static void propagateSequenceElemTypeWithValidation(const TypeProto& input_type, TypeProto& output_type) {
+  if (input_type.value_case() != TypeProto::kSequenceType) {
+    fail_type_inference("Input was expected to have sequence type. Got ", input_type.value_case());
+  }
+
+  const auto& input_seq_type = input_type.sequence_type();
+
+  if (input_seq_type.has_elem_type()) {
+    propagateElemTypeWithValidation(
+        &input_seq_type.elem_type(), output_type.mutable_sequence_type()->mutable_elem_type());
+  } else {
+    fail_type_inference("Element type of sequence input was unknown");
+  }
+}
+
+static void propagateOptionalElemTypeWithValidation(const TypeProto& input_type, TypeProto& output_type) {
+  if (input_type.value_case() != TypeProto::kOptionalType) {
+    fail_type_inference("Input was expected to have optional type. Got ", input_type.value_case());
+  }
+
+  const auto& input_opt_type = input_type.optional_type();
+
+  if (input_opt_type.has_elem_type()) {
+    propagateElemTypeWithValidation(
+        &input_opt_type.elem_type(), output_type.mutable_optional_type()->mutable_elem_type());
+  } else {
+    fail_type_inference("Element type of optional input was unknown");
+  }
+}
+
+static void propagateMapElemTypeWithValidation(const TypeProto& input_type, TypeProto& output_type) {
+  if (input_type.value_case() != TypeProto::kMapType) {
+    fail_type_inference("Input was expected to have map type. Got ", input_type.value_case());
+  }
+
+  const auto& input_map_type = input_type.map_type();
+
+  if (!input_map_type.has_key_type()) {
+    fail_type_inference("Key type of map input was unknown");
+  }
+  if (!input_map_type.has_value_type()) {
+    fail_type_inference("Value type of map input was unknown");
+  }
+  output_type.mutable_map_type()->set_key_type(input_map_type.key_type());
+  propagateElemTypeWithValidation(&input_map_type.value_type(), output_type.mutable_map_type()->mutable_value_type());
+}
+
+// propagate the element type from an input type to an output type.
+// if an existing output element type exists, validate it matches.
+void propagateElemTypeWithValidation(const TypeProto* input_type, TypeProto* output_type) {
+  if (nullptr == input_type) {
+    fail_type_inference("Input type was null");
+  }
+  if (nullptr == output_type) {
+    fail_type_inference("Output type was null");
+  }
+
+  const auto input_value_case = input_type->value_case();
+  if (input_value_case == TypeProto::kTensorType || input_value_case == TypeProto::kSparseTensorType) {
+    propagateTensorElemTypeWithValidation(*input_type, *output_type);
+  } else if (input_value_case == TypeProto::kSequenceType) {
+    propagateSequenceElemTypeWithValidation(*input_type, *output_type);
+  } else if (input_value_case == TypeProto::kOptionalType) {
+    propagateOptionalElemTypeWithValidation(*input_type, *output_type);
+  } else if (input_value_case == TypeProto::kMapType) {
+    propagateMapElemTypeWithValidation(*input_type, *output_type);
+  } else {
+    fail_type_inference(
+        "Input was expected to have either tensor, sequence, optional or map type. Got ", input_value_case);
+  }
+}
+
+TensorShapeProto getShapeInput(const InferenceContext& ctx, size_t input_index, bool& found) {
+  return getShapeInput(ctx, input_index, false, found);
+}
+
+TensorShapeProto
+getShapeInput(const InferenceContext& ctx, size_t input_index, bool fail_if_negative_value, bool& found) {
+  TensorShapeProto shape_input;
+
+  found = false;
+
+  // First, check initializer.
+  const TensorProto* shape_initializer = ctx.getInputData(input_index);
+  if (shape_initializer) {
+    const std::vector<int64_t> shape_data = ParseData<int64_t>(shape_initializer);
+    for (const int64_t& e : shape_data) {
+      shape_input.add_dim()->set_dim_value(e);
+    }
+    found = true;
+  }
+
+  // Then, check symbolic input.
+  const TensorShapeProto* symbolic_input = ctx.getSymbolicInput(input_index);
+  if (!found && symbolic_input) {
+    shape_input.CopyFrom(*symbolic_input);
+    found = true;
+  }
+
+  // Try rank inference.
+  if (!found && hasInputShape(ctx, input_index)) {
+    const TensorShapeProto& shape_input_shape = getInputShape(ctx, input_index);
+    if (shape_input_shape.dim_size() != 1) {
+      fail_shape_inference("shape input must be 1D tensor");
+    }
+    if (shape_input_shape.dim(0).has_dim_value()) {
+      // Attempt rank inference using shape of shape input
+      int64_t dim_value = shape_input_shape.dim(0).dim_value();
+      for (int64_t i = 0; i < dim_value; ++i) {
+        shape_input.add_dim();
+      }
+      found = true;
+    }
+  }
+
+  if (found && fail_if_negative_value) {
+    int dims_size = shape_input.dim_size();
+    for (int i = 0; i < dims_size; ++i) {
+      const auto& dim = shape_input.dim(i);
+      if (dim.has_dim_value() && dim.dim_value() < 0) {
+        fail_shape_inference("shape input tensor must have non-negative elements");
+      }
+    }
+  }
+
+  return shape_input;
+}
+
+template <typename Container>
+std::string stringify(const Container& elements) {
+  std::stringstream ss;
+  for (const auto& element : elements) {
+    ss << element << ", ";
+  }
+  return ss.str();
+}
+
+std::pair<int, int> getAttributeProtoElemTypeAndLength(const AttributeProto* attr_proto) {
+  if (attr_proto->ints_size()) {
+    return {TensorProto_DataType_INT64, attr_proto->ints_size()};
+  } else if (attr_proto->floats_size()) {
+    return {TensorProto_DataType_FLOAT, attr_proto->floats_size()};
+  } else if (attr_proto->strings_size()) {
+    return {TensorProto_DataType_STRING, attr_proto->strings_size()};
+  } else if (attr_proto->has_t()) {
+    if (attr_proto->t().dims_size() != 1) {
+      fail_type_inference(
+          "Attribute ", attr_proto->name(), " expected to be a 1D tensor but was ", attr_proto->t().dims_size(), "D");
+    }
+    const int64_t dim0 = attr_proto->t().dims(0);
+    if (dim0 < 0 || dim0 > static_cast<int64_t>(std::numeric_limits<int>::max())) {
+      fail_type_inference(
+          "Attribute ",
+          attr_proto->name(),
+          " has tensor dimension ",
+          dim0,
+          " which is out of valid range [0, INT_MAX]");
+    }
+    return {attr_proto->t().data_type(), static_cast<int>(dim0)};
+  }
+  return {TensorProto::UNDEFINED, 0};
+}
+
+std::pair<int, int> getAttributeElementTypeAndLength(
+    const InferenceContext& ctx,
+    const std::initializer_list<std::string>& attribute_names) {
+  // Get element type and lengths of 1D attribute lists
+  int32_t elem_type = TensorProto::UNDEFINED;
+  int32_t length = 0;
+  for (const auto& attribute : attribute_names) {
+    const AttributeProto* attr_proto = ctx.getAttribute(attribute);
+    if (attr_proto != nullptr) {
+      if (elem_type != TensorProto::UNDEFINED) {
+        // Another attribute was already set
+        fail_shape_inference("One and only one attribute must be set out of ", stringify(attribute_names));
+      }
+      std::tie(elem_type, length) = getAttributeProtoElemTypeAndLength(attr_proto);
+    }
+  }
+  return {elem_type, length};
+}
+
+// NOLINTNEXTLINE(readability-make-member-function-const)
+void InferenceContext::unifyInputShape(size_t input_index, std::initializer_list<std::reference_wrapper<Dim>> dims) {
+  if (!hasInputShape(*this, input_index)) {
+    return;
+  }
+  const auto& input_shape = getInputShape(*this, input_index);
+  if (static_cast<size_t>(input_shape.dim_size()) != dims.size()) {
+    fail_shape_inference(
+        "Input ",
+        input_index,
+        " expected to have rank ",
+        dims.size(),
+        " but has rank ",
+        input_shape.dim_size(),
+        " in ",
+        getDisplayName(),
+        ".");
+  }
+  int i = 0;
+  for (const auto& dim_ref : dims) {
+    const Dim& input_dim = input_shape.dim(i);
+    unifyDim(input_dim, dim_ref.get());
+    ++i;
+  }
+}
+
+// NOLINTNEXTLINE(readability-make-member-function-const)
+void InferenceContext::unifyInputShapePrefix(
+    size_t input_index,
+    std::initializer_list<std::reference_wrapper<Dim>> prefix) {
+  if (!hasInputShape(*this, input_index)) {
+    return;
+  }
+  const auto& input_shape = getInputShape(*this, input_index);
+  if (static_cast<size_t>(input_shape.dim_size()) < prefix.size()) {
+    fail_shape_inference(
+        "Input ",
+        input_index,
+        " expected to have rank >= ",
+        prefix.size(),
+        " but has rank ",
+        input_shape.dim_size(),
+        " in ",
+        getDisplayName(),
+        ".");
+  }
+  int i = 0;
+  for (const auto& dim_ref : prefix) {
+    const Dim& input_dim = input_shape.dim(i);
+    unifyDim(input_dim, dim_ref.get());
+    ++i;
+  }
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/shape_inference.h b/onnx/defs/shape_inference.h
new file mode 100644
index 0000000..a259d30
--- /dev/null
+++ b/onnx/defs/shape_inference.h
@@ -0,0 +1,1018 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/common/common.h"
+#include "onnx/proto_utils.h"
+#include "onnx/string_utils.h"
+
+namespace ONNX_NAMESPACE {
+
+using Dim = TensorShapeProto_Dimension;
+
+struct ShapeInferenceOptions {
+  // Checks the type-equality for input and output
+  bool check_type;
+  // 1: Will throw any node level shape infer errors
+  // 0: Won't throw node-level shape infer errors, but other errors
+  // like merging existing shape with inferred etc are thrown
+  int error_mode;
+  // Enables data propagation for limited operators
+  // to perform shape computation
+  bool enable_data_propagation;
+  explicit ShapeInferenceOptions(bool check_type_val = false, int strict_mode_val = 0, bool data_prop_val = false)
+      : check_type(check_type_val), error_mode(strict_mode_val), enable_data_propagation(data_prop_val) {}
+};
+
+// Maintains a SymbolTable for symbolic shape inference
+class SymbolTable {
+ public:
+  // Adds existing symbols from a main graph or subgraph
+  virtual void addFromGraph(const GraphProto& g) = 0;
+  // Creates a new symbol which is not duplicate as any existing one
+  std::string createNew() {
+    return createNew("unk__");
+  }
+  virtual std::string createNew(const std::string& symbol_prefix) = 0;
+  virtual ~SymbolTable() = default;
+};
+
+class GraphInferencer {
+ public:
+  // Perform inferencing on the graph contained in GraphInferencer.
+  // Returns the graph output types post-inferencing.
+  virtual std::vector<const TypeProto*> doInferencing(
+      const std::vector<const TypeProto*>& inputTypes,
+      const std::vector<const TensorProto*>& inputData) = 0;
+  virtual ~GraphInferencer() = default;
+};
+
+// Exception class used for handling errors in type and shape inference
+
+class InferenceError final : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+
+  explicit InferenceError(const std::string& message) : std::runtime_error(message) {}
+
+  const char* what() const noexcept override {
+    if (!expanded_message_.empty()) {
+      return expanded_message_.c_str();
+    }
+    return std::runtime_error::what();
+  }
+
+  void AppendContext(const std::string& context) {
+    expanded_message_ = ONNX_NAMESPACE::MakeString(std::runtime_error::what(), "\n\n==> Context: ", context);
+  }
+
+ private:
+  std::string expanded_message_;
+};
+
+#define fail_type_inference(...) \
+  ONNX_THROW_EX(ONNX_NAMESPACE::InferenceError(ONNX_NAMESPACE::MakeString("[TypeInferenceError] ", __VA_ARGS__)));
+
+#define fail_shape_inference(...) \
+  ONNX_THROW_EX(ONNX_NAMESPACE::InferenceError(ONNX_NAMESPACE::MakeString("[ShapeInferenceError] ", __VA_ARGS__)));
+
+struct InferenceContext {
+  virtual const AttributeProto* getAttribute(const std::string& name) const = 0;
+  virtual size_t getNumInputs() const = 0;
+  virtual const TypeProto* getInputType(size_t index) const = 0;
+  virtual bool hasInput(size_t index) const {
+    // The default implementation below is used for backward-compatibility
+    // for implementations of InferenceContext that don't provide an explicit
+    // implementation. This works for normal usage, but may be imprecise in
+    // the edge-case where an input is supplied but has no known type.
+    // However, inference-methods work only under the assumption that the
+    // input-types of all inputs are known.
+    return ((index < getNumInputs()) && (getInputType(index) != nullptr));
+  }
+  virtual const TensorProto* getInputData(size_t index) const = 0;
+  virtual size_t getNumOutputs() const = 0;
+  virtual TypeProto* getOutputType(size_t index) = 0;
+  virtual bool hasOutput(size_t index) {
+    return (index < getNumOutputs() && (getOutputType(index) != nullptr));
+  }
+  virtual GraphInferencer* getGraphAttributeInferencer(const std::string& attribute_name) = 0;
+  virtual ~InferenceContext() = default;
+  virtual const SparseTensorProto* getInputSparseData(size_t index) const = 0;
+  // Gets the shape inputs computed by partial data propagation.
+  virtual const TensorShapeProto* getSymbolicInput(size_t index) const = 0;
+  // To display a name the user can use to narrow its search.
+  virtual std::string getDisplayName() const {
+    return "";
+  }
+
+  // Non-virtual convenience methods for shape inference.
+
+  // unifyInputShape: unifies all dimensions of an input with the given dim references.
+  // Requires the input to have rank exactly equal to the number of dims provided.
+  void unifyInputShape(size_t input_index, std::initializer_list<std::reference_wrapper<Dim>> dims);
+
+  // unifyInputShapePrefix: unifies the first N dimensions of an input with the given dim references.
+  // Requires the input to have rank at least equal to the number of dims provided.
+  void unifyInputShapePrefix(size_t input_index, std::initializer_list<std::reference_wrapper<Dim>> prefix);
+};
+
+// We use data propagation to perform partial evaluation of the model, to compute statically
+// known information about tensor values. It is intended to improve the precision of shape
+// inference. We reuse TensorShapeProto to represent the statically known values. One
+// limitation of this is that TensorShapeProto can represent only integer values.
+// As an example, data-propagation is intended to handle code-fragments like below:
+//   shape = Shape(X)
+//   batchsize = Slice(shape, [0], [1])
+//   newshape = Concat (batchsize, [1024, 1024])
+//   Z = Reshape(Y, newshape)
+// If the shape of X is statically known, then data-propagation should be able to determine
+// the value of newshape, as well as the shape of Z.
+struct DataPropagationContext {
+  virtual const AttributeProto* getAttribute(const std::string& name) const = 0;
+  virtual size_t getNumInputs() const = 0;
+  virtual const TypeProto* getInputType(size_t index) const = 0;
+  virtual size_t getNumOutputs() const = 0;
+  virtual const TypeProto* getOutputType(size_t index) const = 0;
+  virtual ~DataPropagationContext() = default;
+  virtual const TensorShapeProto* getInputData(size_t index) = 0;
+  virtual void addOutputData(size_t index, TensorShapeProto&& tp) = 0;
+};
+
+using InferenceFunction = std::function<void(InferenceContext&)>;
+using DataPropagationFunction = std::function<void(DataPropagationContext&)>;
+
+// This no-op inference function is used for operators without an
+// inference implementation.
+inline void dummyInferenceFunction(InferenceContext& /*unused*/) {}
+
+// This no-op data propagation function is used for operators without a defined data propagator
+inline void dummyDataPropagationFunction(DataPropagationContext& /*unused*/) {}
+
+template <typename T>
+inline bool getRepeatedAttribute(InferenceContext& ctx, const std::string& attr_name, std::vector<T>& values) {
+  const auto* attr = ctx.getAttribute(attr_name);
+  if (attr) {
+    values = RetrieveValues<T>(*attr);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// Throws InferenceError if the attribute is missing. Returning by reference
+// prevents callers from accidentally skipping the null check.
+inline const AttributeProto& getRequiredAttribute(const InferenceContext& ctx, const std::string& name) {
+  const auto* attr = ctx.getAttribute(name);
+  if (attr == nullptr) {
+    fail_shape_inference("Required attribute '", name, "' is missing");
+  }
+  return *attr;
+}
+
+inline int64_t getRequiredAttributeInt(const InferenceContext& ctx, const std::string& name) {
+  const auto& attr = getRequiredAttribute(ctx, name);
+  if (!attr.has_i()) {
+    fail_shape_inference("Required attribute '", name, "' must be an integer");
+  }
+  return attr.i();
+}
+
+// Works for both InferenceContext and DataPropagationContext.
+template <typename Context>
+int64_t getAttribute(const Context& ctx, const std::string& attributeName, int64_t defaultValue) {
+  const auto* attr_proto = ctx.getAttribute(attributeName);
+  if ((nullptr != attr_proto) && attr_proto->has_i())
+    return attr_proto->i();
+  else if (nullptr != attr_proto)
+    return 0; // protobuf default for integers
+  else
+    return defaultValue;
+}
+
+inline std::string
+getAttribute(const InferenceContext& ctx, const std::string& attributeName, const std::string& defaultValue) {
+  const auto* attr_proto = ctx.getAttribute(attributeName);
+  if ((nullptr != attr_proto) && attr_proto->has_s())
+    return attr_proto->s();
+  else if (nullptr != attr_proto)
+    return ""; // protobuf default for strings
+  else
+    return defaultValue;
+}
+
+inline TensorShapeProto::Dimension operator*(
+    const TensorShapeProto::Dimension& dim1,
+    const TensorShapeProto::Dimension& dim2) {
+  TensorShapeProto::Dimension result;
+  if (dim1.has_dim_value() && dim2.has_dim_value()) {
+    result.set_dim_value(dim1.dim_value() * dim2.dim_value());
+  } else if (dim1.has_dim_value() && (dim1.dim_value() == 1)) {
+    return dim2;
+  } else if (dim2.has_dim_value() && (dim2.dim_value() == 1)) {
+    return dim1;
+  }
+  return result;
+}
+
+template <typename Container>
+std::string stringify(const Container& elements);
+
+std::pair<int, int> getAttributeProtoElemTypeAndLength(const AttributeProto* attr_proto);
+
+std::pair<int, int> getAttributeElementTypeAndLength(
+    const InferenceContext& ctx,
+    const std::initializer_list<std::string>& attribute_names);
+
+inline TensorShapeProto::Dimension operator*(const TensorShapeProto::Dimension& dim1, int64_t dim2) {
+  TensorShapeProto::Dimension result;
+  if (dim1.has_dim_value()) {
+    result.set_dim_value(dim1.dim_value() * dim2);
+  } else if (dim2 == 1) {
+    return dim1;
+  }
+  return result;
+}
+
+inline TensorShapeProto::Dimension operator/(const TensorShapeProto::Dimension& dim1, int64_t dim2) {
+  TensorShapeProto::Dimension result;
+  if (dim1.has_dim_value()) {
+    result.set_dim_value(dim1.dim_value() / dim2);
+  } else if (dim2 == 1) {
+    return dim1;
+  }
+  return result;
+}
+
+inline TensorShapeProto::Dimension operator+(const TensorShapeProto::Dimension& dim1, int64_t dim2) {
+  TensorShapeProto::Dimension result;
+  if (dim1.has_dim_value()) {
+    result.set_dim_value(dim1.dim_value() + dim2);
+  } else if (dim2 == 0) {
+    return dim1;
+  }
+  return result;
+}
+
+inline TensorShapeProto::Dimension operator-(const TensorShapeProto::Dimension& dim1, int64_t dim2) {
+  TensorShapeProto::Dimension result;
+  if (dim1.has_dim_value()) {
+    result.set_dim_value(dim1.dim_value() - dim2);
+  } else if (dim2 == 0) {
+    return dim1;
+  }
+  return result;
+}
+
+// if from >= upto_exclusive, return 1.
+// Caller must make sure upto_exclusive is less than or equal to shape.size()
+// Caller must make sure from>=0
+inline TensorShapeProto::Dimension multiplyDims(const TensorShapeProto& shape, int from, int upto_exclusive) {
+  TensorShapeProto::Dimension dim;
+  dim.set_dim_value(1);
+  for (int i = from; i < upto_exclusive; ++i) {
+    dim = dim * shape.dim(i);
+  }
+  return dim;
+}
+
+inline int32_t getTensorElementType(const TypeProto& type) {
+  int32_t result = TensorProto::UNDEFINED;
+  const auto value_case = type.value_case();
+  if (value_case == TypeProto::kTensorType) {
+    result = type.tensor_type().elem_type();
+  } else if (value_case == TypeProto::kSparseTensorType) {
+    result = type.sparse_tensor_type().elem_type();
+  }
+  return result;
+}
+
+inline void setTensorElementType(int32_t elem_type, TypeProto::ValueCase value_case, TypeProto& type) {
+  if (value_case == TypeProto::kTensorType) {
+    type.mutable_tensor_type()->set_elem_type(elem_type);
+  } else if (value_case == TypeProto::kSparseTensorType) {
+    type.mutable_sparse_tensor_type()->set_elem_type(elem_type);
+  }
+}
+
+ONNX_API void propagateElemTypeWithValidation(const TypeProto* input_type, TypeProto* output_type);
+
+ONNX_API void propagateElemTypeFromInputToOutput(InferenceContext& ctx, size_t inputIndex, size_t outputIndex);
+
+ONNX_API void propagateElemTypeFromTensorInputToOutput(InferenceContext& ctx, size_t inputIndex, size_t outputIndex);
+
+inline void propagateElemTypeFromDtypeToOutput(
+    InferenceContext& ctx,
+    const int data_type,
+    size_t outputIndex,
+    TypeProto::ValueCase expected_value_case = TypeProto::kTensorType) {
+  const auto attribute_tensor_datatype = data_type;
+  auto* output_type = ctx.getOutputType(outputIndex);
+  const auto output_value_case = output_type->value_case();
+  if (output_value_case == TypeProto::VALUE_NOT_SET || output_value_case == expected_value_case) {
+    setTensorElementType(attribute_tensor_datatype, expected_value_case, *output_type);
+  } else {
+    // This is not expected to happen
+    fail_type_inference(
+        "Output ",
+        outputIndex,
+        " expected to have: ",
+        expected_value_case,
+        " or UNDEFINED. Got: ",
+        output_value_case,
+        " in ",
+        ctx.getDisplayName(),
+        ".");
+  }
+}
+
+inline void propagateElemTypeFromDtypeToOutput(InferenceContext& ctx, const AttributeProto* attr, size_t outputIndex) {
+  int32_t data_type = TensorProto::UNDEFINED;
+  TypeProto::ValueCase expected_value_case = TypeProto::VALUE_NOT_SET;
+  const auto attr_type = attr->type();
+  if (attr_type == AttributeProto::TENSOR) {
+    if (attr->t().dims().size() != 1) {
+      fail_type_inference("Attribute expected to have a one-dim tensor in ", ctx.getDisplayName(), ".");
+    }
+    data_type = attr->t().data_type();
+    expected_value_case = TypeProto::kTensorType;
+  } else if (attr_type == AttributeProto::SPARSE_TENSOR) {
+    if (attr->sparse_tensor().dims().size() != 1) {
+      fail_type_inference("Attribute expected to have a one-dim sparse tensor in ", ctx.getDisplayName(), ".");
+    }
+    data_type = attr->sparse_tensor().values().data_type();
+    expected_value_case = TypeProto::kSparseTensorType;
+  } else {
+    fail_type_inference("Attribute expected to have tensor or sparse tensor type in ", ctx.getDisplayName(), ".");
+  }
+
+  propagateElemTypeFromDtypeToOutput(ctx, data_type, outputIndex, expected_value_case);
+}
+
+inline bool hasShape(const TypeProto& type) {
+  if (type.has_tensor_type()) {
+    return type.tensor_type().has_shape();
+  } else if (type.has_sparse_tensor_type()) {
+    return type.sparse_tensor_type().has_shape();
+  } else if (type.has_sequence_type() && type.sequence_type().has_elem_type()) {
+    return hasShape(type.sequence_type().elem_type());
+  } else if (type.has_optional_type() && type.optional_type().has_elem_type()) {
+    return hasShape(type.optional_type().elem_type());
+  }
+  return false;
+}
+
+template <typename Context>
+inline bool hasInputShape(const Context& ctx, size_t n) {
+  return ctx.getNumInputs() > n && ctx.getInputType(n) && hasShape(*ctx.getInputType(n));
+}
+
+template <typename Context>
+inline bool hasNInputShapes(const Context& ctx, size_t n) {
+  for (size_t i = 0; i < n; i++) {
+    if (!hasInputShape(ctx, i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline const TensorShapeProto& getInputShape(const InferenceContext& ctx, size_t n) {
+  const auto* input_type = ctx.getInputType(n);
+  if (input_type == nullptr) {
+    fail_type_inference("Input ", n, " is null in ", ctx.getDisplayName(), ".");
+  }
+  const auto value_case = input_type->value_case();
+  if (value_case != TypeProto::kTensorType && value_case != TypeProto::kSparseTensorType) {
+    fail_type_inference("Input ", n, "expected to be a tensor or a sparse tensor type in ", ctx.getDisplayName(), ".");
+  }
+  if (!hasShape(*input_type)) {
+    fail_shape_inference("Input ", n, " must have a non null shape in ", ctx.getDisplayName(), ".");
+  }
+  if (value_case == TypeProto::kTensorType) {
+    return input_type->tensor_type().shape();
+  } else {
+    return input_type->sparse_tensor_type().shape();
+  }
+}
+
+inline const TensorShapeProto* getOptionalInputShape(const InferenceContext& ctx, size_t n) {
+  const auto* input_type = ctx.getInputType(n);
+
+  if (input_type == nullptr) {
+    return nullptr;
+  }
+
+  const auto value_case = input_type->value_case();
+  if (value_case != TypeProto::kTensorType && value_case != TypeProto::kSparseTensorType) {
+    fail_type_inference("Input ", n, "expected to be a tensor or a sparse tensor type in ", ctx.getDisplayName(), ".");
+  }
+  if (value_case == TypeProto::kTensorType) {
+    return &input_type->tensor_type().shape();
+  } else {
+    return &input_type->sparse_tensor_type().shape();
+  }
+}
+
+// Caller must make sure fromDimIndex is strictly less than shape.dim_size()
+inline void appendSingleDimCopiedFromInputTypeToOutputType(
+    InferenceContext& ctx,
+    size_t inputIndex,
+    size_t outputIndex,
+    size_t fromDimIndex) {
+  auto* output_type = ctx.getOutputType(outputIndex);
+  const auto output_value_case = output_type->value_case();
+  const auto* input_type = ctx.getInputType(inputIndex);
+  if (!input_type) {
+    fail_type_inference("Input: ", inputIndex, " is null.");
+  }
+  const auto input_value_case = input_type->value_case();
+  if (output_value_case != input_value_case) {
+    fail_type_inference(
+        "Input: ",
+        inputIndex,
+        " type: ",
+        input_value_case,
+        " does not match type of output: ",
+        outputIndex,
+        "type: ",
+        output_value_case,
+        " in ",
+        ctx.getDisplayName(),
+        ".");
+  }
+  if (TypeProto::kTensorType == input_value_case) {
+    auto* dim = output_type->mutable_tensor_type()->mutable_shape()->add_dim();
+    *dim = input_type->tensor_type().shape().dim(static_cast<int>(fromDimIndex));
+  } else if (TypeProto::kSparseTensorType == input_value_case) {
+    auto* dim = output_type->mutable_sparse_tensor_type()->mutable_shape()->add_dim();
+    *dim = input_type->sparse_tensor_type().shape().dim(static_cast<int>(fromDimIndex));
+  } else {
+    fail_type_inference(
+        "Input ",
+        inputIndex,
+        " and Output ",
+        outputIndex,
+        " expected to have tensor or sparse tensor type in ",
+        ctx.getDisplayName(),
+        ".");
+  }
+}
+
+inline void propagateShape(const TypeProto* from_type, TypeProto* to_type) {
+  const auto from_type_case = from_type->value_case();
+  const auto to_type_case = to_type->value_case();
+  if (from_type_case != to_type_case) {
+    fail_shape_inference(
+        "Mismatch between inferred and declared type. Inferred=", from_type_case, " Declared=", to_type_case);
+  }
+
+  if (TypeProto::kTensorType == from_type_case || TypeProto::kSparseTensorType == from_type_case) {
+    // If input shape is "unknown", the corresponding should be "unknown" too.
+    // The way to make output shape unknown is not to assign it any value.
+    if (hasShape(*from_type)) {
+      if (TypeProto::kTensorType == from_type_case) {
+        *to_type->mutable_tensor_type()->mutable_shape() = from_type->tensor_type().shape();
+      } else {
+        *to_type->mutable_sparse_tensor_type()->mutable_shape() = from_type->sparse_tensor_type().shape();
+      }
+    }
+  } else if (TypeProto::kSequenceType == from_type_case) {
+    propagateShape(&from_type->sequence_type().elem_type(), to_type->mutable_sequence_type()->mutable_elem_type());
+  } else if (TypeProto::kOptionalType == from_type_case) {
+    propagateShape(&from_type->optional_type().elem_type(), to_type->mutable_optional_type()->mutable_elem_type());
+  } else if (TypeProto::kMapType == from_type_case) {
+    propagateShape(&from_type->map_type().value_type(), to_type->mutable_map_type()->mutable_value_type());
+  } else {
+    fail_shape_inference("Unsupported Source/Target type=", from_type_case);
+  }
+}
+
+inline void propagateShapeFromInputToOutput(InferenceContext& ctx, size_t inputIndex, size_t outputIndex) {
+  auto* output_type = ctx.getOutputType(outputIndex);
+  const auto* input_type = ctx.getInputType(inputIndex);
+
+  propagateShape(input_type, output_type);
+}
+
+ONNX_API inline void propagateShapeAndTypeFromFirstInput(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+  if (!hasNInputShapes(ctx, 1)) {
+    return;
+  }
+  propagateShapeFromInputToOutput(ctx, 0, 0);
+}
+
+inline void updateOutputElemType(
+    InferenceContext& ctx,
+    size_t outputIndex,
+    int32_t elemType,
+    TypeProto::ValueCase expected_type = TypeProto::kTensorType) {
+  auto* output_type = ctx.getOutputType(outputIndex);
+  if (output_type == nullptr) {
+    fail_type_inference("Output ", outputIndex, " is null");
+  }
+  if (output_type->value_case() == expected_type || output_type->value_case() == TypeProto::VALUE_NOT_SET) {
+    setTensorElementType(elemType, expected_type, *output_type);
+  } else {
+    // This is not expected to happen
+    fail_type_inference(
+        "Output ",
+        outputIndex,
+        " expected to have tensor or sparse tensor type: ",
+        expected_type,
+        " in ",
+        ctx.getDisplayName(),
+        ".");
+  }
+}
+
+// Infer type of an output from the value of a specified attribute, which is
+// expected to have a valid value representing a TensorProto_DataType.
+inline void propagateElemTypeFromAttributeToOutput(
+    InferenceContext& ctx,
+    const std::string& attributeName,
+    size_t outputIndex,
+    TypeProto::ValueCase expected_type,
+    TensorProto_DataType default_value = TensorProto::UNDEFINED) {
+  const auto* attr_proto = ctx.getAttribute(attributeName);
+  if (nullptr == attr_proto) { // attribute not present
+    if (default_value != TensorProto::UNDEFINED) {
+      updateOutputElemType(ctx, outputIndex, default_value, expected_type);
+      return;
+    } else {
+      fail_type_inference("Value of attribute ", attributeName, " not specified in ", ctx.getDisplayName(), ".");
+    }
+  }
+  if (!attr_proto->has_i()) {
+    fail_type_inference(
+        "Attribute ", attributeName, " should be of integer type and specify a type in ", ctx.getDisplayName(), ".");
+  }
+  auto attr_value = attr_proto->i();
+  auto elem_type = static_cast<TensorProto_DataType>(attr_value);
+  if (!TensorProto_DataType_IsValid(elem_type)) {
+    fail_type_inference("Attribute ", attributeName, " does not specify a valid type in ", ctx.getDisplayName(), ".");
+  }
+  updateOutputElemType(ctx, outputIndex, elem_type, expected_type);
+}
+
+inline void propagateElemTypeFromAttributeToOutput(
+    InferenceContext& ctx,
+    const std::string& attributeName,
+    size_t outputIndex,
+    TensorProto_DataType default_value = TensorProto::UNDEFINED) {
+  propagateElemTypeFromAttributeToOutput(ctx, attributeName, outputIndex, TypeProto::kTensorType, default_value);
+}
+
+inline TensorShapeProto* getTensorMutableShape(TypeProto::ValueCase value_case, TypeProto& type) {
+  if (value_case == TypeProto::kTensorType || value_case == TypeProto::kSparseTensorType) {
+    return type.mutable_tensor_type()->mutable_shape();
+  }
+  return nullptr;
+}
+
+inline TensorShapeProto*
+getOutputShape(InferenceContext& ctx, size_t n, TypeProto::ValueCase default_type = TypeProto::kTensorType) {
+  auto* output_type = ctx.getOutputType(n);
+  if (output_type == nullptr) {
+    fail_type_inference("Output ", n, " expected to have tensor or sparse type in ", ctx.getDisplayName(), ".");
+  }
+  const auto output_value_case = output_type->value_case();
+  if (output_value_case == TypeProto::kTensorType || output_value_case == TypeProto::kSparseTensorType) {
+    auto* output_shape = getTensorMutableShape(output_value_case, *output_type);
+    if (output_shape == nullptr) {
+      fail_type_inference("Output ", n, " expected to have tensor or sparse type in ", ctx.getDisplayName(), ".");
+    }
+    return output_shape;
+  } else if (output_value_case == TypeProto::VALUE_NOT_SET) {
+    auto* output_shape = getTensorMutableShape(default_type, *output_type);
+    if (output_shape == nullptr) {
+      fail_type_inference("Output ", n, " expected to have tensor or sparse type in ", ctx.getDisplayName(), ".");
+    }
+    return output_shape;
+  } else {
+    fail_type_inference("Output ", n, " expected to have tensor type in ", ctx.getDisplayName(), ".");
+  }
+}
+
+inline void appendDim(TensorShapeProto* shape, int64_t dim_value) {
+  shape->add_dim()->set_dim_value(dim_value);
+}
+
+inline void updateOutputShape(
+    InferenceContext& ctx,
+    size_t outputIndex,
+    const TensorShapeProto& shape,
+    TypeProto::ValueCase default_type = TypeProto::kTensorType) {
+  auto* output_shape = getOutputShape(ctx, outputIndex, default_type);
+  *output_shape = shape;
+}
+
+inline void updateOutputShape(
+    InferenceContext& ctx,
+    size_t outputIndex,
+    const TensorProto& tensorProto,
+    TypeProto::ValueCase default_type = TypeProto::kTensorType) {
+  auto* output_shape = getOutputShape(ctx, outputIndex, default_type);
+  for (auto d : tensorProto.dims()) {
+    auto* dim = output_shape->add_dim();
+    dim->set_dim_value(d);
+  }
+}
+
+inline void updateOutputShape(
+    InferenceContext& ctx,
+    size_t outputIndex,
+    std::initializer_list<TensorShapeProto::Dimension> dims,
+    TypeProto::ValueCase default_type = TypeProto::kTensorType) {
+  auto* output_shape = getOutputShape(ctx, outputIndex, default_type);
+  for (const auto& d : dims) {
+    auto* dim = output_shape->add_dim();
+    *dim = d;
+  }
+}
+
+// Get shape input by first checking initializer and then propagated symbolic data.
+// If neither is available, try rank inference.
+// When one of above succeeds, `true` is stored in `found`.
+// Otherwise, `false` is stored, which means that returned TensorShapeProto does not make sense.
+TensorShapeProto getShapeInput(const InferenceContext& ctx, size_t input_index, bool& found);
+
+// Argument `fail_if_negative_value` is used to control whether negative values are allowed in the shape. The shape
+// check would fail if not.
+TensorShapeProto
+getShapeInput(const InferenceContext& ctx, size_t input_index, bool fail_if_negative_value, bool& found);
+
+// Infer shape of an output from the value of a specified attribute, which is
+// expected to be a list of integers specifying a valid shape.
+inline void propagateShapeFromAttributeToOutput(
+    InferenceContext& ctx,
+    const std::string& attributeName,
+    size_t outputIndex,
+    TypeProto::ValueCase default_type = TypeProto::kTensorType) {
+  const auto* attr_proto = ctx.getAttribute(attributeName);
+  if ((nullptr == attr_proto) || (!attr_proto->has_type()) ||
+      (attr_proto->type() != AttributeProto_AttributeType_INTS)) {
+    fail_shape_inference("Attribute ", attributeName, " should specify a shape in ", ctx.getDisplayName(), ".");
+  }
+  const auto& int_list = attr_proto->ints();
+  TensorShapeProto shape;
+  for (auto dim_size : int_list) {
+    if (dim_size < 0) {
+      fail_shape_inference("Negative values are not allowed in a shape specification in ", ctx.getDisplayName(), ".");
+    }
+    shape.add_dim()->set_dim_value(dim_size);
+  }
+
+  updateOutputShape(ctx, outputIndex, shape, default_type);
+}
+
+inline void multidirectionalBroadcastShapeInference(
+    const std::vector<const TensorShapeProto*>& shapes,
+    TensorShapeProto& resultShape) {
+  int result_shape_size = 0;
+  // Get the result shape size.
+  for (const auto* shape : shapes) {
+    result_shape_size = std::max(shape->dim_size(), result_shape_size);
+  }
+
+  for (int i = 0; i < result_shape_size; ++i) {
+    int64_t dim_value = 1;
+    TensorShapeProto_Dimension symbolic_dim;
+    int num_symbolic_dims = 0;
+    for (const auto* shape : shapes) {
+      if (i < result_shape_size - shape->dim_size()) {
+        // Shape j will be filled with 1 at dimension i;
+        continue;
+      }
+
+      auto dim_i_j = shape->dim(i - result_shape_size + shape->dim_size());
+      if (dim_i_j.has_dim_value()) {
+        if (dim_i_j.dim_value() != 1) {
+          if (dim_value != dim_i_j.dim_value() && dim_value != 1) {
+            fail_shape_inference("Incompatible dimensions");
+          } else {
+            dim_value = dim_i_j.dim_value();
+          }
+        }
+      } else {
+        if (num_symbolic_dims == 0) {
+          symbolic_dim = dim_i_j;
+          ++num_symbolic_dims;
+        } else if (dim_i_j.dim_param() != symbolic_dim.dim_param()) {
+          ++num_symbolic_dims;
+        }
+      }
+    }
+
+    if (dim_value != 1 || num_symbolic_dims == 0) {
+      resultShape.add_dim()->set_dim_value(dim_value);
+    } else if (num_symbolic_dims == 1) {
+      *resultShape.add_dim() = symbolic_dim;
+    } else {
+      resultShape.add_dim();
+    }
+  }
+}
+
+inline void bidirectionalBroadcastShapeInference(
+    const TensorShapeProto& shapeL,
+    const TensorShapeProto& shapeR,
+    TensorShapeProto& resultShape) {
+  std::vector<const TensorShapeProto*> shapes;
+  shapes.push_back(&shapeL);
+  shapes.push_back(&shapeR);
+  multidirectionalBroadcastShapeInference(shapes, resultShape);
+}
+
+/*
+Merge the dimension information from two TensorShapeProto_Dimension instances.
+Values are merged into target from source.
+If target has no dimension information, copy from source.
+If source has no dimension information, ignore source.
+If both have dimension information:
+ - Prefer values over params. If both have values, values must match.
+ - Prefer target param over source param if mismatched.
+Fail if there are mismatches in dimension values.
+Currently, there is no way to refine/update dimension information for the
+source from information available in the target.
+*/
+inline void mergeInDimensionInfo(
+    const TensorShapeProto_Dimension& source_dim,
+    TensorShapeProto_Dimension& target_dim,
+    int dim_index) {
+  // if source has value, merge into target
+  // else if target has value, preserve it
+  // else merge params
+  if (source_dim.has_dim_value()) {
+    auto source_value = source_dim.dim_value();
+    if (target_dim.has_dim_value()) {
+      auto target_value = target_dim.dim_value();
+      if (target_value != source_value) {
+        fail_shape_inference(
+            "Can't merge shape info. "
+            "Both inferred and declared dimension have values but they differ. Inferred=",
+            source_value,
+            " Declared=",
+            target_value,
+            " Dimension=",
+            dim_index);
+      }
+    } else {
+      target_dim.set_dim_value(source_value);
+    }
+  } else if (target_dim.has_dim_value() || target_dim.has_dim_param()) {
+    // if target has a value we preserve it so do nothing
+    // prefer target param over source
+  } else if (source_dim.has_dim_param()) {
+    target_dim.set_dim_param(source_dim.dim_param());
+  }
+}
+
+void mergeInShapeInfo(const TensorShapeProto& source_shape, TypeProto_Tensor& target_type);
+
+void mergeInShapeInfo(const TensorShapeProto& source_shape, TypeProto_SparseTensor& target_type);
+
+/*
+Merge the shape information from two TypeProto_Tensor instances.
+Values are merged into target from source.
+If target has no shape information, copy from source.
+If source has no shape information, ignore source.
+If both have shape information:
+- merge each TensorShapeProto_Dimension separately.
+- Prefer values over params. If both have values, values must match.
+- Prefer target param over source param if mismatched.
+Fail if there are mismatches in number of dimensions or dimension values.
+*/
+void mergeInShapeInfo(const TypeProto_Tensor& source, TypeProto_Tensor& target);
+
+void mergeInShapeInfo(const TypeProto_SparseTensor& source, TypeProto_SparseTensor& target);
+
+// Return a copy of a type, with a specified dimension removed from its shape.
+inline TypeProto RemoveIthDimensionFromShape(const TypeProto& proto, int removed_dim) {
+  TypeProto t(proto);
+  auto* mutable_shape = t.mutable_tensor_type()->mutable_shape();
+  mutable_shape->clear_dim();
+
+  const auto& dims = proto.tensor_type().shape().dim();
+
+  for (int j = 0, end = dims.size(); j < end; ++j) {
+    if (j != removed_dim)
+      (*mutable_shape->add_dim()) = dims.Get(j);
+  }
+
+  return t;
+}
+
+// Return a copy of a type, with specified number of dimensions removed from the
+// beginning.
+inline TypeProto RemoveDimensionsFromShape(const TypeProto& proto, int num_dimensions) {
+  TypeProto t(proto);
+  auto* mutable_shape = t.mutable_tensor_type()->mutable_shape();
+  mutable_shape->clear_dim();
+
+  const auto& dims = proto.tensor_type().shape().dim();
+
+  // skip first num_dimensions
+  for (int j = num_dimensions, end = dims.size(); j < end; ++j) {
+    (*mutable_shape->add_dim()) = dims.Get(j);
+  }
+
+  return t;
+}
+
+// Checked narrowing cast — throws InferenceError on lossy conversion
+// (sign change or truncation). Matches gsl::narrow:
+// https://github.com/microsoft/GSL/blob/main/include/gsl/narrow
+template <class T, class U>
+static constexpr T narrow(U&& u) {
+  const U original = u;
+  const T result = static_cast<T>(std::forward<U>(u));
+  if (static_cast<U>(result) != original || ((result < T{}) != (original < U{}))) {
+    fail_shape_inference("narrow: value ", original, " cannot be represented in target type");
+  }
+  return result;
+}
+
+inline void checkInputRank(const InferenceContext& ctx, size_t input_index, int expected_rank) {
+  // We check the rank only if a rank is known for the input:
+  if (hasInputShape(ctx, input_index)) {
+    auto rank = getInputShape(ctx, input_index).dim_size();
+    if (rank != expected_rank) {
+      fail_shape_inference(
+          "Input ",
+          input_index,
+          " expected to have rank ",
+          expected_rank,
+          " but has rank ",
+          rank,
+          " in ",
+          ctx.getDisplayName(),
+          ".");
+    }
+  }
+}
+
+// Unification (between dimensions and/or shapes) is at the heart of
+// shape-inference. The current inference algorithm can check input
+// shapes/dimensions of a node and update the output shapes/dimensions. It
+// cannot currently update input shapes and dimensions (even though in some
+// contexts this inference is possible). Hence, we have the variants below to
+// support "const" and "mutable" dimensions/shapes in unification.
+
+inline void checkDimEquality(int64_t value1, int64_t value2) {
+  if (value1 != value2) {
+    fail_shape_inference("Dimension mismatch in unification between ", value1, " and ", value2);
+  }
+}
+
+inline void unifyDim(const Dim& dim1, const Dim& dim2) {
+  if (dim1.has_dim_value() && dim2.has_dim_value())
+    checkDimEquality(dim1.dim_value(), dim2.dim_value());
+}
+
+// TODO(ONNX): The functionality of unifyDim is similar to that of
+// mergeInDimensionInfo. However, the error messages are different. Leaving this
+// duplication in-place to preserve error message content.
+inline void unifyDim(const Dim& source_dim, Dim& target_dim) {
+  if (source_dim.has_dim_value()) {
+    auto source_value = source_dim.dim_value();
+    if (target_dim.has_dim_value()) {
+      auto target_value = target_dim.dim_value();
+      checkDimEquality(source_value, target_value);
+    } else {
+      target_dim.set_dim_value(source_value);
+    }
+  } else if (target_dim.has_dim_value() || target_dim.has_dim_param()) {
+    // if target has a value we preserve it.
+    // we cannot set source dim value.
+    // prefer target param over source
+    // we cannot currently unify the dim_params
+  } else if (source_dim.has_dim_param()) {
+    target_dim.set_dim_param(source_dim.dim_param());
+  }
+}
+
+inline void unifyInputDim(const InferenceContext& ctx, size_t input_index, int dim_index, Dim& dim) {
+  // We unify the dimensions only if it is available for specified input:
+  if (hasInputShape(ctx, input_index)) {
+    const auto& input_shape = getInputShape(ctx, input_index);
+    // This shape is expected to have rank > dim_index:
+    if (input_shape.dim_size() <= dim_index) {
+      fail_shape_inference(
+          "Input ",
+          input_index,
+          " expected to have rank >",
+          dim_index,
+          " but has rank ",
+          input_shape.dim_size(),
+          " in ",
+          ctx.getDisplayName(),
+          ".");
+    }
+    const Dim& input_dim = input_shape.dim(dim_index);
+    // Now, unify dim and input_dim:
+    unifyDim(input_dim, dim);
+  }
+}
+
+// unifyInputShape: unifies all dimensions of an input with the given dim references.
+// Requires the input to have rank exactly equal to the number of dims provided.
+inline void
+unifyInputShape(InferenceContext& ctx, size_t input_index, std::initializer_list<std::reference_wrapper<Dim>> dims) {
+  ctx.unifyInputShape(input_index, dims);
+}
+
+// unifyInputShapePrefix: unifies the first N dimensions of an input with the given dim references.
+// Requires the input to have rank at least equal to the number of dims provided.
+inline void unifyInputShapePrefix(
+    InferenceContext& ctx,
+    size_t input_index,
+    std::initializer_list<std::reference_wrapper<Dim>> prefix) {
+  ctx.unifyInputShapePrefix(input_index, prefix);
+}
+
+// unifyDim: unifies a dimension with a constant value. If the dimension
+// already has a value, we check for equality of new value with old value.
+inline void unifyDim(Dim& dim, int64_t value) {
+  if (dim.has_dim_value()) {
+    checkDimEquality(dim.dim_value(), value);
+  } else {
+    dim.set_dim_value(value);
+  }
+}
+
+// target-shape = Union (target-shape, source_shape)
+// Example 1: same rank, different dimensions
+//    input1 shape: (2, 3, 4, 'x')
+//    input2 shape: (2, 'y', 5, 'x')
+//    output shape: (2, None, None, 'x')
+// Example 2: different rank
+//    input1 shape: (2, 3, 4, 'x')
+//    input2 shape: (2, 3, 4)
+//    output shape: None
+void UnionShapeInfo(const TensorShapeProto& source_shape, TypeProto_Tensor& target_type);
+
+void UnionShapeInfo(const TensorShapeProto& source_shape, TypeProto_SparseTensor& target_type);
+
+// target-type = Union (target-type, source-type)
+// target and source are required to have the same type.
+// Example 1: same tensor type, different shape
+//    source: tensor elem_type: int64, shape: (2, 3, 4, 'x')
+//    target: tensor elem_type: int64, shape: (2, 'y', 5, 'x')
+//    output: tensor elem_type: int64, shape: (2, None, None, 'x')
+// Example 2: same sequence type, different shape
+//    source: sequence of tensor, elem_type: float, shape: (2, 3, 4)
+//    target: sequence of tensor, elem_type: float, shape: None
+//    output: sequence of tensor, elem_type: float, shape: None
+void UnionTypeInfo(const TypeProto& source_type, TypeProto& target_type);
+
+// adjustNegativeAxes: Negative axes values are translated to the right axis in the positive range
+template <typename Axes>
+void adjustNegativeAxes(Axes& axes, int rank) {
+  std::transform(
+      axes.begin(), axes.end(), axes.begin(), [&](int64_t axis) -> int64_t { return axis < 0 ? axis + rank : axis; });
+}
+
+// checkAxesRange: Checks that values are within the range [-rank, rank)
+template <typename Axes>
+void checkAxesRange(Axes& axes, int rank) {
+  for (auto axis : axes) {
+    if (axis < -rank || axis > (rank - 1))
+      fail_shape_inference("Unexpected axis value: ", axis, ". Expected range [", -rank, ", ", rank, ")");
+  }
+}
+
+// checkDuplicateAxes: Check that there are no duplicated axes
+template <typename Axes>
+void checkDuplicateAxes(Axes& axes, int rank) {
+  std::vector<bool> tmp(static_cast<size_t>(rank), false);
+  for (auto axis : axes) {
+    size_t actual_axis = static_cast<size_t>(axis < 0 ? axis + rank : axis);
+    if (tmp[actual_axis])
+      fail_shape_inference("Axis ", axis, " is referred to more than once.");
+    tmp[actual_axis] = true;
+  }
+}
+
+// Shape inference functions for various ONNX operators.
+// Users can use these functions to implement shape inference for custom operators
+// by calling them in their own inference functions.
+ONNX_API void RNNShapeInference(InferenceContext& ctx);
+ONNX_API void convPoolShapeInference(
+    InferenceContext& ctx,
+    bool use_dilation,
+    bool require_kernel_shape,
+    int input1Idx,
+    int input2Idx);
+ONNX_API void convTransposeShapeInference(InferenceContext& ctx);
+ONNX_API void globalPoolTypeShapeInference(InferenceContext& ctx);
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/tensor/CMakeLists.txt b/onnx/defs/tensor/CMakeLists.txt
new file mode 100644
index 0000000..0011f05
--- /dev/null
+++ b/onnx/defs/tensor/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+    utils.cc
+    utils.h
+)
diff --git a/onnx/defs/tensor/defs.cc b/onnx/defs/tensor/defs.cc
new file mode 100644
index 0000000..c43eb9d
--- /dev/null
+++ b/onnx/defs/tensor/defs.cc
@@ -0,0 +1,3891 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <cmath>
+#include <numeric>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/common/safe_math.h"
+#include "onnx/defs/data_propagators.h"
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/tensor/utils.h"
+#include "onnx/defs/tensor_proto_util.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cast,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_Cast_ver24)
+        .Attr(
+            "to",
+            "The data type to which the elements of the input tensor are cast. "
+            "Strictly must be one of the types from DataType enum in TensorProto",
+            AttributeProto::INT)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. "
+            "All cases are fully described in the tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "round_mode",
+            "Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. "
+            "`up`: round to nearest value away from zero, "
+            "`down`: round to nearest value towards zero, "
+            "`nearest`: round to nearest value and ties round up.",
+            AttributeProto::STRING,
+            std::string("up"))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as input with type "
+            "specified by the 'to' argument",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_non_complex_tensor_types_ir13(),
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_complex_tensor_types_ir13(),
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "to", 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CastLike,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_CastLike_ver24)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. "
+            "Please refer to operator Cast description for further details.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "round_mode",
+            "Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. "
+            "`up`: round to nearest value away from zero, "
+            "`down`: round to nearest value towards zero, "
+            "`nearest`: round to nearest value and ties round up. "
+            "Please refer to operator Cast description for further details.",
+            AttributeProto::STRING,
+            std::string("up"))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "target_type",
+            "The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor produced by casting the first input tensor to have the same type as the second input tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_non_complex_tensor_types_ir13(),
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_complex_tensor_types_ir13(),
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              auto target_type = ctx.getInputType(1);
+              if ((target_type == nullptr) || (!target_type->has_tensor_type())) {
+                // we cannot create a correct function body without knowing the target element type
+                return false;
+              }
+              auto target_elt_type = target_type->tensor_type().elem_type();
+              FunctionBuilder builder(functionProto);
+              builder.Add(MakeString(
+                              "output = Cast <to= ",
+                              static_cast<int64_t>(target_elt_type),
+                              ", saturate: int = @saturate> (input)")
+                              .c_str());
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    BitCast,
+    26,
+    OpSchema()
+        .SetDoc(kDoc_BitCast_ver26)
+        .Attr(
+            "to",
+            "The data type to which the input tensor is bitwise reinterpreted. "
+            "Must be one of the non-string types from DataType enum in TensorProto. "
+            "The target type must have the same bit-width as the input type.",
+            AttributeProto::INT)
+        .Input(0, "input", "Input tensor to be bitcast.", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as the input.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_non_string_tensor_types_ir13(),
+            "Constrain input types. Bitcasting from string is not supported.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_string_tensor_types_ir13(),
+            "Constrain output types. Bitcasting to string is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto get_bit_size = [](int element_type) -> int {
+            switch (element_type) {
+              case TensorProto::FLOAT:
+              case TensorProto::INT32:
+              case TensorProto::UINT32:
+                return 32;
+              case TensorProto::DOUBLE:
+              case TensorProto::INT64:
+              case TensorProto::UINT64:
+              case TensorProto::COMPLEX64:
+                return 64;
+              case TensorProto::COMPLEX128:
+                return 128;
+              case TensorProto::FLOAT16:
+              case TensorProto::BFLOAT16:
+              case TensorProto::INT16:
+              case TensorProto::UINT16:
+                return 16;
+              case TensorProto::INT8:
+              case TensorProto::UINT8:
+              case TensorProto::BOOL:
+              case TensorProto::FLOAT8E4M3FN:
+              case TensorProto::FLOAT8E4M3FNUZ:
+              case TensorProto::FLOAT8E5M2:
+              case TensorProto::FLOAT8E5M2FNUZ:
+              case TensorProto::FLOAT8E8M0:
+                return 8;
+              case TensorProto::INT4:
+              case TensorProto::UINT4:
+              case TensorProto::FLOAT4E2M1:
+                return 4;
+              case TensorProto::INT2:
+              case TensorProto::UINT2:
+                return 2;
+              default:
+                return 0;
+            }
+          };
+
+          // Validate that input and output types have the same bit-width
+          auto input_type = ctx.getInputType(0);
+          if (input_type && input_type->has_tensor_type()) {
+            auto input_element_type = input_type->tensor_type().elem_type();
+            auto* to_attr = ctx.getAttribute("to");
+            if (to_attr) {
+              auto output_element_type = static_cast<int32_t>(to_attr->i());
+              int input_element_bit_size = get_bit_size(input_element_type);
+              int output_element_bit_size = get_bit_size(output_element_type);
+              if (input_element_bit_size != 0 && output_element_bit_size != 0 &&
+                  input_element_bit_size != output_element_bit_size) {
+                fail_shape_inference(
+                    "BitCast requires input and output types to have the same bit-width, but input type has ",
+                    input_element_bit_size,
+                    " bits and output type has ",
+                    output_element_bit_size,
+                    " bits.");
+              }
+            }
+          }
+
+          propagateElemTypeFromAttributeToOutput(ctx, "to", 0);
+
+          // Same bit-width: output shape equals input shape
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reshape,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_Reshape_ver24)
+        .Attr(
+            "allowzero",
+            "(Optional) By default, when any value in the 'shape' input is equal to zero "
+            "the corresponding dimension value is copied from the input tensor dynamically. "
+            "allowzero=1 indicates that if any value in the 'shape' input is set to zero, "
+            "the zero value is honored, similar to NumPy.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "shape",
+            "Specified shape for output.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "reshaped", "Reshaped data.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir13(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          bool found;
+          TensorShapeProto targetShapeProto = getShapeInput(ctx, 1, found);
+          if (!found) {
+            return;
+          }
+
+          int allowzero = static_cast<int>(getAttribute(ctx, "allowzero", 0));
+
+          // Iterate through targetShape, adding dimensions in the outputShape
+          // TensorProto. If the targetShape dimension is -1, we do not set the
+          // dimension value in this iteration, but we record the Dimension. If
+          // targetShape dimension is 0, we attempt to propagate the dimension
+          // value/param. If the value cannot be inferred, we set the flag in
+          // the unresolveZeros vector. If targetShape dimension is positive, we
+          // set the dimension value in the outputShape. We track the product of
+          // the dimensions we are setting outputShape in the outputProduct
+          // variable. The outputProduct will potentially be used for inferring
+          // a dimension marked -1.
+          auto outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          TensorShapeProto::Dimension* negativeOneDim = nullptr;
+          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
+          std::vector<bool> unresolvedZeros(targetShapeProto.dim_size(), false);
+          int64_t outputProduct = 1;
+          bool outputProductValid = true;
+          for (int i = 0; i < static_cast<int>(targetShapeProto.dim_size()); ++i) {
+            // Add a new dimension to outputShape
+            auto new_dim = outputShape->add_dim();
+            if (targetShapeProto.dim(i).has_dim_param()) {
+              // There is a tricky edge case here. It is possible that the value of
+              // symbolic dim can be -1 or 0 at runtime. In that case simply propagating this
+              // symbol can be erroneous. This should be a very rare scenario and in such a
+              // case an option is to turn off data propagation during shape inference.
+              new_dim->set_dim_param(targetShapeProto.dim(i).dim_param());
+              outputProductValid = false;
+            } else {
+              if (!targetShapeProto.dim(i).has_dim_value()) {
+                outputProductValid = false;
+                // treat this dim as unknown dim
+                continue;
+              }
+
+              const auto dim_value = targetShapeProto.dim(i).dim_value();
+
+              if (dim_value == -1) {
+                // Check if multiple -1's. If not, set negativeOneDim, marking
+                // this dimension to potentially be filled in later.
+                if (negativeOneDim) {
+                  fail_shape_inference("Target shape may not have multiple -1 dimensions.");
+                }
+                negativeOneDim = new_dim;
+              } else if (dim_value == 0) {
+                // Check if data input has a shape and if the index i is within
+                // its bounds. If these conditions are satisfied, any dimension
+                // value/param should be propagated. If dimension value cannot be
+                // inferred, set the corresponding  unresolvedZeros flag to true.
+                // If allowzero is set however, do not propagate values, since output
+                // dimension is explicitly zero.
+                if (allowzero == 0) {
+                  unresolvedZeros[i] = true;
+                  if (dataInputTensorType.has_shape()) {
+                    if (i >= dataInputTensorType.shape().dim_size()) {
+                      fail_shape_inference("Invalid position of 0.");
+                    }
+                    if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                      const auto& input_dim_value = dataInputTensorType.shape().dim(i).dim_value();
+                      new_dim->set_dim_value(input_dim_value);
+                      if (checked_mul_overflow(outputProduct, input_dim_value, &outputProduct)) {
+                        fail_shape_inference("Dimension product overflow in Reshape");
+                      }
+                      unresolvedZeros[i] = false;
+                    } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
+                      new_dim->set_dim_param(dataInputTensorType.shape().dim(i).dim_param());
+                    }
+                  }
+                } else {
+                  new_dim->set_dim_value(dim_value);
+                  if (checked_mul_overflow(outputProduct, dim_value, &outputProduct)) {
+                    fail_shape_inference("Dimension product overflow in Reshape");
+                  }
+                }
+              } else if (dim_value > 0) {
+                // Set the dimension value to dim_value
+                new_dim->set_dim_value(dim_value);
+                if (checked_mul_overflow(outputProduct, dim_value, &outputProduct)) {
+                  fail_shape_inference("Dimension product overflow in Reshape");
+                }
+              } else {
+                // Check if value is less than -1; fail if so
+                fail_shape_inference("Invalid dimension value: ", dim_value);
+              }
+            }
+          }
+          // If negativeOneDim has been set, we attempt to infer its value. This
+          // can be done if all dimension values for the data input tensor shape
+          // are known other than the ones corresponding to unresolvedZeros
+          // flags.
+          if (negativeOneDim && outputProductValid) {
+            // First, attempt to compute product of data input shape dimensions
+            // that are not marked by unresolvedZeros. If not possible, set the
+            // inputProductValid flag to false.
+            if (!outputProduct) {
+              fail_shape_inference("Invalid Target shape product of 0. Product cannot be 0 in combination with -1");
+            }
+            int64_t inputProduct = 1;
+            bool inputProductValid = true;
+            if (!dataInputTensorType.has_shape()) {
+              inputProductValid = false;
+            } else {
+              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  if (checked_mul_overflow(
+                          inputProduct, dataInputTensorType.shape().dim(i).dim_value(), &inputProduct)) {
+                    fail_shape_inference("Dimension product overflow in Reshape");
+                  }
+                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
+                  inputProductValid = false;
+                  break;
+                }
+              }
+            }
+            if (inputProductValid) {
+              if (inputProduct % outputProduct != 0) {
+                fail_shape_inference("Dimension could not be inferred: incompatible shapes");
+              }
+              negativeOneDim->set_dim_value(inputProduct / outputProduct);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Shape,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_Shape_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "shape", "Shape of the input tensor", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr(
+            "start",
+            "(Optional) Starting axis for slicing the shape. Default value is 0."
+            "Negative value means counting dimensions from the back.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "end",
+            "(Optional) Ending axis for slicing the shape. "
+            "Negative value means counting dimensions from the back. "
+            "If omitted, sizes of all axes upto (including) the last one will be included.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir13(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          auto output_length = output_shape->add_dim();
+
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          int64_t rank = static_cast<int64_t>(ctx.getInputType(0)->tensor_type().shape().dim_size());
+          int64_t start = getAttribute(ctx, "start", 0);
+          if (start < 0)
+            start += rank;
+          start = (start < 0) ? 0 : (start > rank) ? rank : start;
+          int64_t end = getAttribute(ctx, "end", rank);
+          if (end < 0)
+            end += rank;
+          end = (end < 0) ? 0 : (end > rank) ? rank : end;
+          output_length->set_dim_value((end - start) < 0 ? 0 : (end - start));
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            int64_t rank = static_cast<int64_t>(input_shape.dim_size());
+            int64_t start = getAttribute(ctx, "start", 0);
+            if (start < 0)
+              start += rank;
+            start = (start < 0) ? 0 : (start > rank) ? rank : start;
+            int64_t end = getAttribute(ctx, "end", rank);
+            if (end < 0)
+              end += rank;
+            end = (end < 0) ? 0 : (end > rank) ? rank : end;
+            TensorShapeProto output_shape;
+            for (int64_t d = start; d < end; ++d) {
+              *output_shape.add_dim() = input_shape.dim(static_cast<int>(d));
+            }
+            ctx.addOutputData(0, std::move(output_shape));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Size,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_Size_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "size",
+            "Total number of elements of the input tensor",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir13(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor, which should be a scalar though.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          const auto input_data = ctx.getInputData(0);
+          if (input_data != nullptr) {
+            TensorShapeProto tsp;
+            tsp.mutable_dim()->Add()->set_dim_value(input_data->dim_size());
+            ctx.addOutputData(0, std::move(tsp));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Concat,
+    13,
+    OpSchema()
+        .Attr(
+            "axis",
+            "Which axis to concat on. A negative value means counting dimensions from the back. "
+            "Accepted range is [-r, r-1] where r = rank(inputs)..",
+            AttributeProto::INT)
+        .SetDoc(
+            "Concatenate a list of tensors into a single tensor. "
+            "All input tensors must have the same shape, except for the dimension size of the axis to concatenate on.")
+        .Input(
+            0,
+            "inputs",
+            "List of tensors for concatenation",
+            "T",
+            OpSchema::Variadic,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(0, "concat_result", "Concatenated tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto numInputs = ctx.getNumInputs();
+          if (numInputs < 1 || !hasNInputShapes(ctx, numInputs)) {
+            return;
+          }
+
+          auto rank = ctx.getInputType(0)->tensor_type().shape().dim_size();
+
+          auto axisAttr = ctx.getAttribute("axis");
+          if (!axisAttr) {
+            fail_shape_inference("Required attribute axis is missing");
+          }
+          int axis = static_cast<int>(axisAttr->i());
+          if (axis < -rank || axis >= rank) {
+            fail_shape_inference("axis must be in [-rank, rank-1].");
+          }
+          if (axis < 0) {
+            axis += rank;
+          }
+
+          if (numInputs == 1) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+            return;
+          }
+
+          bool all_lengths_known = true;
+          int total_length = 0;
+
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int64_t i = 0; i < rank; ++i) {
+            output_shape->add_dim();
+          }
+
+          for (size_t i = 0; i < numInputs; i++) {
+            const auto& shape = ctx.getInputType(i)->tensor_type().shape();
+            if (shape.dim_size() != rank) {
+              fail_shape_inference(
+                  "All inputs to Concat must have same rank. Input ", i, " has rank ", shape.dim_size(), " != ", rank);
+            }
+            for (int j = 0; j < rank; j++) {
+              if (j == axis) {
+                if (shape.dim(j).has_dim_value()) {
+                  total_length += static_cast<int>(shape.dim(j).dim_value());
+                } else {
+                  all_lengths_known = false;
+                }
+              } else {
+                auto& output_dim = *output_shape->mutable_dim(j);
+                const auto& input_dim = shape.dim(j);
+                mergeInDimensionInfo(input_dim, output_dim, j);
+              }
+            }
+          }
+
+          if (all_lengths_known) {
+            output_shape->mutable_dim(axis)->set_dim_value(total_length);
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          if (!axisIsZero(ctx)) {
+            return;
+          }
+          TensorShapeProto tsp;
+          for (size_t i = 0; i < ctx.getNumInputs(); ++i) {
+            const auto input_data = ctx.getInputData(i);
+            if (input_data == nullptr) {
+              return;
+            }
+            for (int j = 0; j < input_data->dim_size(); ++j) {
+              *tsp.add_dim() = input_data->dim(j);
+            }
+          }
+          if (tsp.dim_size() > 0) {
+            ctx.addOutputData(0, std::move(tsp));
+          }
+        }));
+
+static constexpr const char* Split_ver18_doc =
+    R"DOC(Split a tensor into a list of tensors, along the specified 'axis'.
+Either input 'split' or the attribute 'num_outputs' should be specified, but not both.
+If the attribute 'num_outputs' is specified, then the tensor is split into equal sized parts.
+If the tensor is not evenly splittable into `num_outputs`, the last chunk will be smaller.
+If the input 'split' is specified, it indicates the sizes of each output in the split.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Split,
+    18,
+    OpSchema()
+        .Input(0, "input", "The tensor to split", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "split",
+            "Optional length of each output. Values should be >= 0."
+            "Sum of the values must be equal to the dim value at 'axis' specified.",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "outputs",
+            "One or more outputs forming list of tensors after splitting",
+            "T",
+            OpSchema::Variadic,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .Attr(
+            "axis",
+            "Which axis to split on. "
+            "A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] "
+            "where r = rank(input).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "num_outputs",
+            "Number of outputs to split parts of the tensor into. "
+            "If the tensor is not evenly splittable the last chunk will be smaller.",
+            AttributeProto::INT,
+            false)
+        .SetDoc(Split_ver18_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          for (size_t i = 0; i < ctx.getNumOutputs(); ++i) {
+            propagateElemTypeFromInputToOutput(ctx, 0, i);
+          }
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          const auto& shape = ctx.getInputType(0)->tensor_type().shape();
+          int rank = shape.dim_size();
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 0));
+          if (axis < -rank || axis >= rank) {
+            fail_type_inference("Invalid value of attribute 'axis'. Rank=", rank, " Value=", axis);
+          }
+          if (axis < 0) {
+            axis += rank;
+          }
+          const auto& split_dim = shape.dim(axis);
+          if (!split_dim.has_dim_value()) {
+            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
+              *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
+              ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->Clear();
+            }
+            return;
+          }
+          int split_dim_value = static_cast<int>(split_dim.dim_value());
+
+          std::vector<int64_t> split;
+          const auto num_outputs_attr = ctx.getAttribute("num_outputs");
+          if (ctx.hasInput(1) && num_outputs_attr) {
+            fail_shape_inference("Both 'split' input and 'num_outputs' attribute were given");
+          }
+          if (ctx.hasInput(1)) { //'split' is input
+            auto split_proto = ctx.getInputData(1);
+            if (split_proto == nullptr) {
+              // skip if split is not an initializer
+              return;
+            }
+            split = ParseData<int64_t>(split_proto);
+            if (split.size() != ctx.getNumOutputs()) {
+              fail_shape_inference(
+                  "Mismatch between number of splits (", split.size(), ") and outputs (", ctx.getNumOutputs(), ")");
+            }
+            int64_t total_dim = 0;
+            for (int64_t d : split) {
+              total_dim += d;
+            }
+            if (total_dim != split_dim_value) {
+              fail_shape_inference(
+                  "Mismatch between the sum of 'split' (",
+                  total_dim,
+                  ") and the split dimension of the input (",
+                  split_dim_value,
+                  ")");
+            }
+          } else { // no value available for 'split'
+            if (num_outputs_attr) {
+              const auto num_outputs = num_outputs_attr->i();
+              if (num_outputs < 1) {
+                fail_shape_inference("Attribute `num_outputs` value cannot be lower than 1");
+              }
+              if (split_dim_value % num_outputs == 0) { // tensor is evenly splittable
+                int chunk_size = split_dim_value / num_outputs;
+                split.resize(num_outputs, chunk_size);
+              } else { // tensor needs to be split unevenly
+                int chunk_size = (split_dim_value / num_outputs) + 1;
+                int last_chunk_size = split_dim_value - (chunk_size * (num_outputs - 1));
+                split.resize(num_outputs - 1, chunk_size);
+                split.push_back(last_chunk_size);
+              }
+            } else {
+              fail_shape_inference("Neither 'split' input nor 'num_outputs' attribute has been given");
+            }
+          }
+          for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
+            *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
+            ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->set_dim_value(split[i]);
+          }
+        }));
+
+static constexpr const char* Slice_ver13_doc = R"DOC(
+Produces a slice of the input tensor along multiple axes. Similar to numpy:
+https://numpy.org/doc/stable/user/basics.indexing.html?highlight=slice#slicing-and-striding
+
+Slice uses the `starts`, `ends`, `axes` and `steps` inputs to select a sub-tensor
+of its input `data` tensor.
+
+An effective `starts[i]`, `ends[i]`, and `steps[i]` must be computed for each `i`
+in `[0, ... r-1]` where `r = rank(input)` as follows:
+
+If `axes` are omitted, they are set to `[0, ..., r-1]`.
+If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
+
+The effective values are initialized as `start[i] = 0`, `ends[i] = dims[i]` where
+`dims` are the dimensions of `input` and `steps[i] = 1`.
+
+All negative elements of `axes` are made non-negative by adding `r` to them, where
+`r =rank(input)`.
+
+All negative values in `starts[i]` and `ends[i]` have `dims[axes[i]]` added to them,
+where `dims` are the dimensions of `input`. Then `start[axes[i]]` is the adjusted
+`starts[i]` is clamped into the range `[0, dims[axes[i]]]` for positive stepping
+and `[0, dims[axes[i]]-1]` for negative stepping.
+
+The clamping for the adjusted `ends[i]` depends on the sign of `steps[i]` and must
+accommodate copying 0 through `dims[axes[i]]` elements, so for positive stepping
+`ends[axes[i]]` is clamped to `[0, dims[axes[i]]]`, while for negative stepping it
+is clamped to `[-1, dims[axes[i]]-1]`.
+
+Finally, `steps[axes[i]] = steps[i]`.
+
+For slicing to the end of a dimension with unknown size, it is recommended to pass
+in `INT_MAX` when slicing forward and 'INT_MIN' when slicing backward.
+
+Example 1:
+
+```
+data = [
+    [1, 2, 3, 4],
+    [5, 6, 7, 8],
+]
+axes = [0, 1]
+starts = [1, 0]
+ends = [2, 3]
+steps = [1, 2]
+result = [
+    [5, 7],
+]
+```
+
+Example 2:
+
+```
+data = [
+    [1, 2, 3, 4],
+    [5, 6, 7, 8],
+]
+starts = [0, 1]
+ends = [-1, 1000]
+result = [
+    [2, 3, 4],
+]
+```
+)DOC";
+
+static void processSliceInputs(const int64_t input_dim_size_or_value, int64_t& start, int64_t& end, int64_t step) {
+  // process step
+  if (step == 0) {
+    fail_shape_inference("'step' cannot be 0 for Slice");
+  }
+  // Empty dimension: clamp bounds are invalid when dimension size is 0,
+  // so short-circuit to produce a zero-length output.
+  if (input_dim_size_or_value == 0) {
+    start = 0;
+    end = 0;
+    return;
+  }
+  // process start
+  if (start < 0)
+    start += input_dim_size_or_value;
+  if (step < 0)
+    start = std::clamp(start, static_cast<int64_t>(0), input_dim_size_or_value - 1);
+  else
+    start = std::clamp(start, static_cast<int64_t>(0), input_dim_size_or_value);
+  // process end
+  if (end < 0)
+    end += input_dim_size_or_value;
+  if (step < 0)
+    end = std::clamp(end, static_cast<int64_t>(-1), input_dim_size_or_value - 1);
+  else
+    end = std::clamp(end, static_cast<int64_t>(0), input_dim_size_or_value);
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Slice,
+    13,
+    OpSchema()
+        .SetDoc(Slice_ver13_doc)
+        .Input(
+            0,
+            "data",
+            "Tensor of data to extract slices from.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "starts",
+            "1-D tensor of starting indices of corresponding axis in `axes`",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "ends",
+            "1-D tensor of ending indices (exclusive) of corresponding axis in `axes`",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            3,
+            "axes",
+            "1-D tensor of axes that `starts` and `ends` apply to. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an "
+            "axis is repeated.",
+            "Tind",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            4,
+            "steps",
+            "1-D tensor of slice step of corresponding axis in `axes`. "
+            "Negative value means slicing backward. 'steps' cannot be 0. "
+            "Defaults to 1s.",
+            "Tind",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "output", "Sliced data tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          size_t num_inputs = ctx.getNumInputs();
+          if (num_inputs != 3 && num_inputs != 4 && num_inputs != 5) {
+            fail_type_inference("Slice op must have either three, four or five inputs.");
+          }
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          // Shape Inference if
+          //     1. 2nd and 3rd input data (starts, ends) are available.
+          // and 2. 4th and 5th optional input (axes, steps) are either not set,
+          // or set and is initializer.
+          const TensorProto* startsInitializer = ctx.getInputData(1);
+          const TensorProto* endsInitializer = ctx.getInputData(2);
+          const TensorProto* axesInitializer = hasInputShape(ctx, 3) ? ctx.getInputData(3) : nullptr;
+          const TensorProto* stepsInitializer = hasInputShape(ctx, 4) ? ctx.getInputData(4) : nullptr;
+
+          if (!startsInitializer || !endsInitializer || (hasInputShape(ctx, 3) && !ctx.getInputData(3)) ||
+              (hasInputShape(ctx, 4) && !ctx.getInputData(4))) {
+            const auto input_rank = ctx.getInputType(0)->tensor_type().shape().dim_size();
+            // we can infer the output rank - it never changes
+            for (int i = 0; i < input_rank; ++i) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+            }
+            return;
+          }
+
+          // don't know data_type- can't proceed
+          if (!startsInitializer->has_data_type())
+            return;
+
+          auto get_initializer_data = [](const TensorProto* initializer) -> std::vector<int64_t> {
+            std::vector<int64_t> vec;
+            if (initializer->data_type() == TensorProto::INT64) {
+              const auto data = ParseData<int64_t>(initializer);
+              vec.insert(vec.end(), data.begin(), data.end());
+            } else if (initializer->data_type() == TensorProto::INT32) {
+              const auto data = ParseData<int32_t>(initializer);
+              vec.insert(vec.end(), data.begin(), data.end());
+            } else {
+              // unaccepted data type
+              fail_shape_inference("Only supports `int32_t` or `int64_t` inputs for starts/ends/axes/steps");
+            }
+            return vec;
+          };
+
+          std::vector<int64_t> starts = get_initializer_data(startsInitializer);
+          std::vector<int64_t> ends = get_initializer_data(endsInitializer);
+
+          if (starts.size() != ends.size()) {
+            fail_shape_inference("Incorrect or missing input value for starts and ends");
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_rank = input_shape.dim_size();
+          std::vector<int64_t> axes(starts.size());
+          if (!axesInitializer) {
+            std::iota(axes.begin(), axes.end(), 0);
+          } else {
+            axes = get_initializer_data(axesInitializer);
+            if (axes.size() != starts.size()) {
+              fail_shape_inference("Input axes has incorrect length");
+            }
+          }
+          checkAxesRange(axes, input_rank);
+          adjustNegativeAxes(axes, input_rank);
+          checkDuplicateAxes(axes, input_rank);
+          std::vector<int64_t> steps;
+          if (!stepsInitializer) {
+            steps = std::vector<int64_t>(starts.size(), 1);
+          } else {
+            steps = get_initializer_data(stepsInitializer);
+            if (steps.size() != axes.size()) {
+              fail_shape_inference("Input steps has incorrect length");
+            }
+          }
+
+          for (int i = 0; i < input_rank; ++i) {
+            // first update rank of output dim
+            auto output_dim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+            const auto& input_dim = input_shape.dim(i);
+            if (input_dim.has_dim_value()) {
+              output_dim->set_dim_value(input_dim.dim_value());
+            } else if (input_dim.has_dim_param()) {
+              output_dim->set_dim_param(input_dim.dim_param());
+            }
+          }
+
+          size_t axes_size = axes.size();
+          for (size_t axis_index = 0; axis_index < axes_size; ++axis_index) {
+            auto axis = axes[axis_index] < 0 ? axes[axis_index] + static_cast<int64_t>(input_rank) : axes[axis_index];
+
+            auto input_dim = ctx.getInputType(0)->tensor_type().shape().dim(static_cast<int>(axis));
+
+            // input dim value is missing - cannot perform shape inference for
+            // this axis
+            if (!input_dim.has_dim_value()) {
+              // Clear any previously propagated dim_param and leave this dimension "empty",
+              // before moving on to the next dimension
+              ctx.getOutputType(0)
+                  ->mutable_tensor_type()
+                  ->mutable_shape()
+                  ->mutable_dim(static_cast<int>(axis))
+                  ->clear_dim_param();
+              continue;
+            }
+            auto start = starts[axis_index];
+            auto end = ends[axis_index];
+            auto step = steps[axis_index];
+            processSliceInputs(input_dim.dim_value(), start, end, step);
+
+            // find output dim value for this axis
+            auto temp = static_cast<int64_t>(ceil(1.0 * (end - start) / step));
+            if (temp < 0)
+              temp = 0;
+
+            // assign output value
+            ctx.getOutputType(0)
+                ->mutable_tensor_type()
+                ->mutable_shape()
+                ->mutable_dim(static_cast<int>(axis))
+                ->set_dim_value(temp);
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          const auto input_data = ctx.getInputData(0);
+          const auto starts = ctx.getInputData(1);
+          const auto ends = ctx.getInputData(2);
+          bool axes_specified = ctx.getNumInputs() >= 4;
+          bool steps_specified = ctx.getNumInputs() >= 5;
+
+          const TensorShapeProto* axes = nullptr;
+          const TensorShapeProto* steps = nullptr;
+          if (axes_specified) {
+            axes = ctx.getInputData(3);
+            if (axes == nullptr) {
+              return;
+            }
+          }
+          if (steps_specified) {
+            steps = ctx.getInputData(4);
+            if (steps == nullptr) {
+              return;
+            }
+          }
+
+          if (input_data == nullptr || starts == nullptr || ends == nullptr) {
+            return;
+          }
+          if (starts->dim_size() != ends->dim_size()) {
+            fail_shape_inference(
+                "Input rank for starts and ends should be the same: (",
+                starts->dim_size(),
+                ") vs (",
+                ends->dim_size(),
+                ").");
+          }
+          // Only supports axis = 0 since the data comes from Shape
+          if ((!axes_specified || (axes->dim_size() == 1 && axes->dim(0).dim_value() == 0)) &&
+              starts->dim_size() == 1 && ends->dim_size() == 1) {
+            auto start = starts->dim(0).dim_value();
+            auto end = ends->dim(0).dim_value();
+            int64_t step = 1; // Default step is 1
+            if (steps_specified) {
+              if (steps->dim_size() != 1) {
+                return;
+              }
+              if (!steps->dim(0).has_dim_value()) {
+                return;
+              }
+              step = steps->dim(0).dim_value();
+            }
+            processSliceInputs(input_data->dim_size(), start, end, step);
+
+            TensorShapeProto tsp;
+            if (step > 0) {
+              for (int i = start; i < end; i += step) {
+                *tsp.add_dim() = input_data->dim(i);
+              }
+            } else {
+              for (int i = start; i > end; i += step) {
+                *tsp.add_dim() = input_data->dim(i);
+              }
+            }
+            if (tsp.dim_size() > 0) {
+              ctx.addOutputData(0, std::move(tsp));
+            }
+          }
+        }));
+
+const char* Transpose_doc = R"DOC(
+Returns a transpose of the input tensor. (Similar to `numpy.transpose`).
+The optional attribute `perm` must be a permutation of the dimensions of
+the input tensor. Axis `i` of the output tensor corresponds to the axis
+`perm[i]` of the input tensor.
+For example, when perm=(1, 0, 2), given an input tensor of shape (1, 2, 3),
+the output shape will be (2, 1, 3).
+When perm=(1, 2, 0), given an input tensor of shape (1, 2, 3),
+the output shape will be (2, 3, 1).
+If the attribute `perm` is omitted, its default value is `(n-1, ..., 0)`,
+where `n` is the rank of the input tensor.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Transpose,
+    25,
+    OpSchema()
+        .SetDoc(Transpose_doc)
+        .Attr(
+            "perm",
+            "A list of integers. By default, reverse the dimensions, "
+            "otherwise permute the axes according to the values given. "
+            "Its length must be equal to the rank of the input.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "transposed", "Transposed output.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir13(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          auto input_type = ctx.getInputType(0);
+          const TensorShapeProto& shape = input_type->tensor_type().shape();
+          std::vector<int64_t> perm;
+          bool has_perm_attr = getRepeatedAttribute(ctx, "perm", perm);
+          if (!has_perm_attr) {
+            perm.reserve(shape.dim_size());
+            for (int i = shape.dim_size() - 1; i >= 0; --i)
+              perm.push_back(i);
+          } else if (!perm.empty()) {
+            // check if every index is valid
+            std::vector<bool> seen(shape.dim_size(), false);
+            for (int64_t fromDimIndex : perm) {
+              if (fromDimIndex < 0 || fromDimIndex >= shape.dim_size()) {
+                std::ostringstream oss;
+                oss << "Invalid attribute perm {" << perm[0];
+                for (size_t i = 1; i != perm.size(); ++i) {
+                  oss << ", " << perm[i];
+                }
+                oss << "}, input shape = {";
+                if (shape.dim_size() > 0) {
+                  oss << shape.dim(0).dim_value();
+                  for (int i = 1; i != shape.dim_size(); ++i) {
+                    oss << ", " << shape.dim(i).dim_value();
+                  }
+                  oss << "}";
+                }
+                fail_type_inference(oss.str());
+              } else {
+                // check if any perm is repeated
+                if (seen[fromDimIndex]) {
+                  fail_type_inference("Attribute perm for Transpose has repeated value: ", fromDimIndex);
+                }
+                seen[fromDimIndex] = true;
+              }
+            }
+          }
+
+          getOutputShape(ctx, 0);
+
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          for (int64_t i : perm) {
+            appendSingleDimCopiedFromInputTypeToOutputType(ctx, 0, 0, static_cast<size_t>(i));
+          }
+        }));
+
+static constexpr const char* Scatter_ver11_doc = R"DOC(
+This operator is deprecated. Please use ScatterElements, which provides the same functionality.
+
+Scatter takes three inputs `data`, `updates`, and `indices` of the same
+rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+(by default, the outer-most axis, that is axis 0). The output of the operation
+is produced by creating a copy of the input `data`, and then updating its value
+to values specified by `updates` at specific index positions specified by
+`indices`. Its output shape is the same as the shape of `data`.
+
+For each entry in `updates`, the target index in `data` is obtained by combining
+the corresponding entry in `indices` with the index of the entry itself: the
+index-value for dimension = axis is obtained from the value of the corresponding
+entry in `indices` and the index-value for dimension != axis is obtained from the
+index of the entry itself.
+
+For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
+is performed as below:
+```
+  output[indices[i][j]][j] = updates[i][j] if axis = 0,
+  output[i][indices[i][j]] = updates[i][j] if axis = 1,
+```
+
+This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+
+Example 1:
+```
+  data = [
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+  ]
+  indices = [
+      [1, 0, 2],
+      [0, 2, 1],
+  ]
+  updates = [
+      [1.0, 1.1, 1.2],
+      [2.0, 2.1, 2.2],
+  ]
+  output = [
+      [2.0, 1.1, 0.0]
+      [1.0, 0.0, 2.2]
+      [0.0, 2.1, 1.2]
+  ]
+```
+Example 2:
+```
+  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+  indices = [[1, 3]]
+  updates = [[1.1, 2.1]]
+  axis = 1
+  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scatter,
+    11,
+    OpSchema()
+        .Deprecate()
+        .SetDoc(Scatter_ver11_doc)
+        .Attr(
+            "axis",
+            "Which axis to scatter on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be "
+            "within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "updates",
+            "Tensor of rank r >=1 (same rank and shape as indices)",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of rank r >= 1 (same rank as input).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Input and output types can be of any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* ScatterND_ver18_doc = R"DOC(
+ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
+and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
+is produced by creating a copy of the input `data`, and then updating its value to values
+specified by `updates` at specific index positions specified by `indices`. Its output shape
+is the same as the shape of `data`.
+
+`indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
+`indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
+Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
+update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
+update to a slice of the tensor. Index values are allowed to be negative, as per the usual
+convention for counting backwards from the end, but are expected in the valid range.
+
+`updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
+first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
+The remaining dimensions of `updates` correspond to the dimensions of the
+replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
+corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
+must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
+of shapes.
+
+The `output` is calculated via the following equation:
+
+```
+output = np.copy(data)
+update_indices = indices.shape[:-1]
+for idx in np.ndindex(update_indices):
+    output[tuple(indices[idx])] = updates[idx]
+```
+
+The order of iteration in the above loop is not specified.
+In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
+This ensures that the output value does not depend on the iteration order.
+
+`reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+tensor into `output` at the specified `indices`.
+In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+then indices[idx1] != indices[idx2]. This ensures that the output value does not depend on the iteration order.
+When `reduction` is set to some reduction function `f`, `output` is calculated as follows:
+
+```
+output = np.copy(data)
+update_indices = indices.shape[:-1]
+for idx in np.ndindex(update_indices):
+    output[tuple(indices[idx])] = f(output[tuple(indices[idx])], updates[idx])
+```
+
+where the `f` is `+`, `*`, `max` or `min` as specified.
+
+This operator is the inverse of GatherND.
+
+(Opset 18 change): Adds max/min to the set of allowed reduction ops.
+
+Example 1:
+```
+data    = [1, 2, 3, 4, 5, 6, 7, 8]
+indices = [[4], [3], [1], [7]]
+updates = [9, 10, 11, 12]
+output  = [1, 11, 3, 10, 9, 6, 7, 12]
+```
+
+Example 2:
+```
+data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+            [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+            [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+            [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+indices = [[0], [2]]
+updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+            [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
+output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+            [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+            [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+            [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ScatterND,
+    18,
+    OpSchema()
+        .SetDoc(ScatterND_ver18_doc)
+        .Attr(
+            "reduction",
+            "Type of reduction to apply: none (default), add, mul, max, min. "
+            "'none': no reduction applied. "
+            "'add':  reduction using the addition operation. "
+            "'mul':  reduction using the addition operation. "
+            "'max': reduction using the maximum operation."
+            "'min': reduction using the minimum operation.",
+            AttributeProto::STRING,
+            std::string("none"))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of rank q >= 1.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "updates",
+            "Tensor of rank q + r - indices_shape[-1] - 1.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(0, "output", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* ScatterElements_ver18_doc = R"DOC(
+ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
+rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+(by default, the outer-most axis, that is axis 0). The output of the operation
+is produced by creating a copy of the input `data`, and then updating its value
+to values specified by `updates` at specific index positions specified by
+`indices`. Its output shape is the same as the shape of `data`.
+
+For each entry in `updates`, the target index in `data` is obtained by combining
+the corresponding entry in `indices` with the index of the entry itself: the
+index-value for dimension = axis is obtained from the value of the corresponding
+entry in `indices` and the index-value for dimension != axis is obtained from the
+index of the entry itself.
+
+`reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+tensor into `output` at the specified `indices`.
+In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+then indices[idx1] != indices[idx2]. For instance, in a 2-D tensor case, the update
+corresponding to the [i][j] entry is performed as below:
+```
+output[indices[i][j]][j] = updates[i][j] if axis = 0,
+output[i][indices[i][j]] = updates[i][j] if axis = 1,
+```
+When `reduction` is set to some reduction function `f`, the update corresponding to the [i][j] entry is performed as below:
+```
+output[indices[i][j]][j] = f(output[indices[i][j]][j], updates[i][j]) if axis = 0,
+output[i][indices[i][j]] = f(output[i][indices[i][j]], updates[i][j]) if axis = 1,
+```
+where the `f` is `+`, `*`, `max` or `min` as specified.
+
+This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+
+(Opset 18 change): Adds max/min to the set of allowed reduction ops.
+
+Example 1:
+```
+data = [
+    [0.0, 0.0, 0.0],
+    [0.0, 0.0, 0.0],
+    [0.0, 0.0, 0.0],
+]
+indices = [
+    [1, 0, 2],
+    [0, 2, 1],
+]
+updates = [
+    [1.0, 1.1, 1.2],
+    [2.0, 2.1, 2.2],
+]
+output = [
+    [2.0, 1.1, 0.0]
+    [1.0, 0.0, 2.2]
+    [0.0, 2.1, 1.2]
+]
+```
+Example 2:
+```
+data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+indices = [[1, 3]]
+updates = [[1.1, 2.1]]
+axis = 1
+output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ScatterElements,
+    18,
+    OpSchema()
+        .SetDoc(ScatterElements_ver18_doc)
+        .Attr(
+            "axis",
+            "Which axis to scatter on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "reduction",
+            "Type of reduction to apply: none (default), add, mul, max, min. "
+            "'none': no reduction applied. "
+            "'add':  reduction using the addition operation. "
+            "'mul': reduction using the multiplication operation."
+            "'max': reduction using the maximum operation."
+            "'min': reduction using the minimum operation.",
+            AttributeProto::STRING,
+            std::string("none"))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be "
+            "within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "updates",
+            "Tensor of rank r >=1 (same rank and shape as indices)",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of rank r >= 1 (same rank as input).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Input and output types can be of any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* Gather_ver13_doc = R"DOC(
+Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
+entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
+them in an output tensor of rank q + (r - 1).
+
+It is an indexing operation that indexes into the input `data` along a single (specified) axis.
+Each entry in `indices` produces a `r-1` dimensional slice of the input tensor.
+The entire operation produces, conceptually, a `q`-dimensional tensor of `r-1` dimensional slices,
+which is arranged into a `q + (r-1)`-dimensional tensor, with the `q` dimensions taking the
+place of the original `axis` that is being indexed into.
+
+The following few examples illustrate how `Gather` works for specific shapes of `data`,
+`indices`, and given value of `axis`:
+| data shape | indices shape | axis | output shape | output equation |
+| --- | --- | --- | --- | --- |
+| (P, Q) | ( )  (a scalar)   | 0 | (Q)       | output[q] = data[indices, q] |
+| (P, Q, R) | ( )  (a scalar)   | 1 | (P, R)       | output[p, r] = data[p, indices, r] |
+| (P, Q) | (R, S) | 0 | (R, S, Q) | output[r, s, q] = data[ [indices[r, s], q] |
+| (P, Q) | (R, S) | 1 | (P, R, S) | output[p, r, s] = data[ p, indices[r, s]] |
+
+More generally, if `axis = 0`, let `k = indices[i_{0}, ..., i_{q-1}]`
+then `output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[k , j_{0}, ..., j_{r-2}]`:
+
+```
+data = [
+    [1.0, 1.2],
+    [2.3, 3.4],
+    [4.5, 5.7],
+]
+indices = [
+    [0, 1],
+    [1, 2],
+]
+output = [
+    [
+        [1.0, 1.2],
+        [2.3, 3.4],
+    ],
+    [
+        [2.3, 3.4],
+        [4.5, 5.7],
+    ],
+]
+```
+
+If `axis = 1`, let `k = indices[i_{0}, ..., i_{q-1}]`
+then `output[j_{0}, i_{0}, ..., i_{q-1}, j_{1}, ..., j_{r-2}] = input[j_{0}, k, j_{1}, ..., j_{r-2}]`:
+
+```
+data = [
+    [1.0, 1.2, 1.9],
+    [2.3, 3.4, 3.9],
+    [4.5, 5.7, 5.9],
+]
+indices = [
+    [0, 2],
+]
+axis = 1,
+output = [
+        [[1.0, 1.9]],
+        [[2.3, 3.9]],
+        [[4.5, 5.9]],
+]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gather,
+    13,
+    OpSchema()
+        .SetDoc(Gather_ver13_doc)
+        .Attr(
+            "axis",
+            "Which axis to gather on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds [-s, s-1] "
+            "along axis of size s. It is an error if any of the index values are out of bounds.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "output", "Tensor of rank q + (r - 1).", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 2)) {
+            return;
+          }
+          const TensorShapeProto& data_shape = ctx.getInputType(0)->tensor_type().shape();
+          const TensorShapeProto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
+          int r = data_shape.dim_size();
+          if (r < 1) {
+            fail_shape_inference("data tensor must have rank >= 1");
+          }
+          int q = indices_shape.dim_size();
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 0));
+          if (axis < -r || axis >= r) {
+            fail_shape_inference("axis must be in [-r, r-1]");
+          }
+          if (axis < 0) {
+            axis += r;
+          }
+          int out_rank = q + r - 1;
+          if (out_rank == 0) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          }
+          for (int i = 0; i < out_rank; ++i) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = (i < axis) ? data_shape.dim(i)
+                                                                                                  : // i < axis < r
+                (i >= axis && i < axis + q) ? indices_shape.dim(i - axis)
+                                            : // i - axis < q
+                data_shape.dim(i - q + 1); // i < out_rank < q + r - 1
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { GatherOp13DataPropagator(ctx); }));
+
+static constexpr const char* GatherElements_ver13_doc = R"DOC(
+
+GatherElements takes two inputs `data` and `indices` of the same rank r >= 1
+and an optional attribute `axis` that identifies an axis of `data`
+(by default, the outer-most axis, that is axis 0). It is an indexing operation
+that produces its output by indexing into the input data tensor at index
+positions determined by elements of the `indices` tensor.
+Its output shape is the same as the shape of `indices` and consists of one value
+(gathered from the `data`) for each element in `indices`.
+
+For instance, in the 3-D case (r = 3), the output produced is determined
+by the following equations:
+```
+out[i][j][k] = input[index[i][j][k]][j][k] if axis = 0,
+out[i][j][k] = input[i][index[i][j][k]][k] if axis = 1,
+out[i][j][k] = input[i][j][index[i][j][k]] if axis = 2,
+```
+
+This operator is also the inverse of ScatterElements. It is similar to Torch's gather operation.
+
+Example 1:
+```
+data = [
+    [1, 2],
+    [3, 4],
+]
+indices = [
+    [0, 0],
+    [1, 0],
+]
+axis = 1
+output = [
+    [1, 1],
+    [4, 3],
+]
+```
+Example 2:
+```
+data = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9],
+]
+indices = [
+    [1, 2, 0],
+    [2, 0, 0],
+]
+axis = 0
+output = [
+    [4, 8, 3],
+    [7, 2, 3],
+]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GatherElements,
+    13,
+    OpSchema()
+        .SetDoc(GatherElements_ver13_doc)
+        .Attr(
+            "axis",
+            "Which axis to gather on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, with the same rank r as the input. All index values are expected to be "
+            "within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of the same shape as indices.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // propagate indices' shape to output if it exists
+          if (hasInputShape(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 1, 0);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Squeeze,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_Squeeze_ver24)
+        .Input(
+            0,
+            "data",
+            "Tensors with at least max(dims) dimensions.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "1D tensor of integers indicating the dimensions to squeeze. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "squeezed",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir13(),
+            "Constrain input and output types to all tensor types up to IRv13.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          std::vector<int64_t> axes;
+          size_t num_inputs = ctx.getNumInputs();
+          bool axes_not_specified = false;
+
+          if ((num_inputs == 2) && ctx.getInputType(1)) { //'axes' is input
+            auto axes_proto = ctx.getInputData(1);
+            if (axes_proto == nullptr) {
+              // skip if axes is not an initializer
+              return;
+            }
+            axes = ParseData<int64_t>(axes_proto);
+          } else {
+            // axes not specified
+            axes_not_specified = true;
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          checkAxesRange(axes, input_ndim);
+          adjustNegativeAxes(axes, input_ndim);
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (!input_shape.dim(i).has_dim_value() && axes_not_specified) {
+              // if dim has a symbolic value and the axes spec want to act on all dims,
+              // return early because we can't infer the shape
+              return;
+            }
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (axes_not_specified && input_shape.dim(i).dim_value() == 1) {
+              // if axes not specified, do not keep shape if the dimension is equal to one
+              continue;
+            } else if (!axes_not_specified && std::find(axes.begin(), axes.end(), i) != axes.end()) {
+              // if axes wants to explicitly act on this dim, fail explicitly only if the
+              // dim is numerical and != 1. If the dim is 1 or symbolic, remove it. If
+              // the dim is symbolic, runtime engines should check that the dimension is
+              // actually 1 when the op is evaluated
+              if (input_shape.dim(i).has_dim_value() && input_shape.dim(i).dim_value() != 1) {
+                fail_shape_inference(
+                    "Dimension of input ", i, " must be 1 instead of ", input_shape.dim(i).dim_value());
+              }
+            } else {
+              *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = input_shape.dim(i);
+            }
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Unsqueeze,
+    25,
+    OpSchema()
+        .SetDoc(kDoc_Unsqueeze_ver24)
+        .Input(0, "data", "Original tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "1D tensor of integers indicating the dimensions to be inserted. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(expanded).",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "expanded",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir13(),
+            "Constrain input and output types to all tensor types up to IRv13.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          std::vector<int64_t> axes;
+          auto axes_proto = ctx.getInputData(1);
+          if (axes_proto == nullptr) {
+            // skip if axes is not an initializer
+            return;
+          }
+          axes = ParseData<int64_t>(axes_proto);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          const auto output_ndim = input_ndim + static_cast<int>(axes.size());
+          checkAxesRange(axes, output_ndim);
+          adjustNegativeAxes(axes, output_ndim);
+          checkDuplicateAxes(axes, output_ndim);
+          // sort after correcting negative axes values (if any)
+          std::sort(axes.begin(), axes.end());
+
+          int j = 0;
+          for (int i = 0; i < input_ndim; ++i) {
+            while (static_cast<size_t>(j) < axes.size() &&
+                   axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+              ++j;
+            }
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
+                ctx.getInputType(0)->tensor_type().shape().dim(i);
+          }
+          while (static_cast<size_t>(j) < axes.size() &&
+                 axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+            ++j;
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SpaceToDepth,
+    13,
+    OpSchema()
+        .Attr("blocksize", "Blocks of [blocksize, blocksize] are moved.", AttributeProto::INT)
+        .SetDoc(kDoc_SpaceToDepth_ver1)
+        .Input(
+            0,
+            "input",
+            "Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth"
+            ", H is the height and W is the width.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor of [N, C * blocksize * blocksize, H/blocksize, W/blocksize].",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto blocksize = getAttribute(ctx, "blocksize", 0);
+          if (blocksize <= 0) {
+            fail_shape_inference("Blocksize must be positive");
+          }
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() == 4) {
+              updateOutputShape(
+                  ctx,
+                  0,
+                  {input_shape.dim(0),
+                   input_shape.dim(1) * (blocksize * blocksize),
+                   input_shape.dim(2) / blocksize,
+                   input_shape.dim(3) / blocksize});
+            } else {
+              fail_shape_inference("Input tensor must be 4-dimensional");
+            }
+          }
+        }));
+
+static constexpr const char* DepthToSpace_ver13_doc =
+    R"DOC(DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
+This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
+the input tensor where values from the depth dimension are moved in spatial blocks to the height
+and width dimensions. By default, `mode` = `DCR`.
+In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the
+following order: depth, column, and then row. The output y is computed from the input x as below:
+
+```
+b, c, h, w = x.shape
+tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])
+tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])
+y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])
+```
+
+In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the
+following order: column, row, and the depth. The output y is computed from the input x as below:
+
+```
+b, c, h, w = x.shape
+tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])
+tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])
+y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DepthToSpace,
+    13,
+    OpSchema()
+        .Attr("blocksize", "Blocks of [blocksize, blocksize] are moved.", AttributeProto::INT)
+        .Attr(
+            "mode",
+            "DCR (default) for depth-column-row order re-arrangement. Use CRD for column-row-depth order.",
+            AttributeProto::STRING,
+            std::string("DCR"))
+        .SetDoc(DepthToSpace_ver13_doc)
+        .Input(
+            0,
+            "input",
+            "Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth"
+            ", H is the height and W is the width.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto blocksize = getAttribute(ctx, "blocksize", 0);
+          if (blocksize <= 0) {
+            fail_shape_inference("Blocksize must be positive");
+          }
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() == 4) {
+              updateOutputShape(
+                  ctx,
+                  0,
+                  {input_shape.dim(0),
+                   input_shape.dim(1) / (blocksize * blocksize),
+                   input_shape.dim(2) * blocksize,
+                   input_shape.dim(3) * blocksize});
+            } else {
+              fail_shape_inference("Input tensor must be 4-dimensional");
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Tile,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Tile_ver6)
+        .Input(0, "input", "Input tensor of any shape.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "repeats",
+            "1D int64 tensor of the same length as input's dimension number, "
+            "includes numbers of repeated copies along input's dimensions.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor of the same dimensions and type as tensor input. "
+            "output_dim[i] = input_dim[i] * repeats[i]",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain repeat's type to int64 tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // Shape inference
+
+          // Needs at least the first input to proceed
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_rank = input_shape.dim_size();
+
+          const auto repeats_inputs = ctx.getInputData(1);
+
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          if (nullptr != repeats_inputs && hasNInputShapes(ctx, 2)) {
+            // shape inference is possible only when 'repeats' is an initializer
+            const auto& repeats_shape = ctx.getInputType(1)->tensor_type().shape();
+            if (repeats_shape.dim_size() != 1 || repeats_inputs->data_type() != TensorProto::INT64) {
+              fail_shape_inference("'Repeats' input must be 1D tensor of type int64");
+            }
+
+            const auto repeats_data = ParseData<int64_t>(repeats_inputs);
+
+            if (repeats_data.size() != static_cast<size_t>(input_rank)) {
+              fail_shape_inference(
+                  "'Repeats' input has incorrect number of values. "
+                  "The number of values in 'repeats' must be equal "
+                  "to the number of input dimensions.");
+            }
+
+            for (int i = 0; i < input_rank; ++i) {
+              const auto& input_dim = input_shape.dim(i);
+              auto output_dim = output_shape->add_dim();
+              if (input_dim.has_dim_value()) {
+                output_dim->set_dim_value(input_dim.dim_value() * repeats_data[i]);
+              }
+            }
+          } else {
+            // Infer output shape's rank in any case (if repeats data is not
+            // available)
+            auto output_shape_0 = getOutputShape(ctx, 0);
+            for (int i = 0; i < input_rank; ++i) {
+              output_shape_0->add_dim();
+            }
+          }
+          return;
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Upsample,
+    10,
+    OpSchema()
+        .Deprecate()
+        .Attr(
+            "mode",
+            "Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)",
+            AttributeProto::STRING,
+            std::string("nearest"))
+        .Input(0, "X", "N-D tensor", "T", OpSchema::Single)
+        .Input(
+            1,
+            "scales",
+            "The scale array along each dimension. It takes value greater than or equal to 1."
+            " The number of elements of 'scales' should be the same as the rank of input 'X'.",
+            "tensor(float)",
+            OpSchema::Single)
+        .Output(0, "Y", "N-D tensor after resizing", "T", OpSchema::Single)
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input 'X' and output 'Y' to all tensor types.")
+        .SetDoc(kDoc_Upsample_ver7)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset7_to_10(ctx); }));
+
+static constexpr const char* Resize_ver19_doc = R"DOC(
+Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
+Each dimension value of the output tensor is:
+```
+output_dimension = floor(input_dimension * (roi_end - roi_start) * scale)
+```
+if input \"sizes\" is not specified.
+)DOC";
+
+static constexpr const char* Resize_ver19_attr_coordinate_transformation_mode_doc = R"DOC(
+This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor.
+
+The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
+Denote `x_resized` as the coordinate of axis x in the resized tensor,
+ `x_original` as the coordinate of axis x in the original tensor,
+ `length_original` as the length of the original tensor in axis x,
+ `length_resized` as the length of the resized tensor in axis x,
+ `scale = length_resized / length_original`,
+ `output_width` the target length on the axis x which can be a fractional number when it is calculated out of a scale factor,
+ and `output_width_int` the effective output width as an integer.
+
+if coordinate_transformation_mode is `"half_pixel"`,
+```
+x_original = (x_resized + 0.5) / scale - 0.5
+```
+
+if coordinate_transformation_mode is `"half_pixel_symmetric"`,
+```
+adjustment = output_width_int / output_width
+center = input_width / 2
+offset = center * (1 - adjustment)
+x_ori = offset + (x + 0.5) / scale - 0.5
+```
+
+if coordinate_transformation_mode is `"pytorch_half_pixel"`,
+```
+x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0
+```
+
+if coordinate_transformation_mode is `"align_corners"`,
+```
+x_original = x_resized * (length_original - 1) / (length_resized - 1)
+```
+
+if coordinate_transformation_mode is `"asymmetric"`,
+```
+x_original = x_resized / scale
+```
+
+if coordinate_transformation_mode is `"tf_crop_and_resize"`,
+```
+x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1)
+```
+.)DOC";
+
+static constexpr const char* Resize_ver19_attr_keep_aspect_ratio_policy_doc = R"DOC(
+This attribute describes how to interpret the `sizes` input with regard to keeping the original aspect ratio of the input, and it is not applicable when
+the `scales` input is used.
+
+Given a set of `sizes`, associated with a subset of `axes` (explicitly provided or default), and assuming `d = axes[i]`, with `i` being the index of the provided `sizes`.
+
+If `keep_aspect_ratio_policy` is `"stretch"`, the original aspect ratio is disregarded, and the input is resized to the specified size:
+`out_size[d] = sizes[i]`
+
+If `keep_aspect_ratio_policy` is `"not_larger"`, the sizes are adjusted so that no extent of the output is larger than the specified size, while keeping the original aspect ratio:
+```
+scale = Min(sizes[i] / in_size[d])
+out_size[d] = round_int(scale * in_size[d])
+```
+
+If `keep_aspect_ratio_policy` is `"not_smaller"`, the sizes are adjusted so that no extent of the output is smaller than the specified size, while keeping the original aspect ratio:
+```
+scale = Max(sizes[i] / in_size[d])
+out_size[d] = round_int(scale * in_size[d])
+```
+
+For non-resizable axes (those not specified in `axes`), the output size will be equal to the input size.
+
+Note: `round_int` stands for computing the nearest integer value, rounding halfway cases up.)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Resize,
+    19,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Three interpolation modes: \"nearest\" (default), \"linear\" and \"cubic\". "
+            "The \"linear\" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). "
+            "The \"cubic\" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor).",
+            AttributeProto::STRING,
+            std::string("nearest"))
+        .Attr(
+            "cubic_coeff_a",
+            "The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75"
+            " (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. "
+            "This attribute is valid only if mode is \"cubic\".",
+            AttributeProto::FLOAT,
+            static_cast<float>(-0.75))
+        .Attr(
+            "exclude_outside",
+            "If set to 1, the weight of sampling locations outside the tensor will be set to 0"
+            " and the weight will be renormalized so that their sum is 1.0. The default value is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "coordinate_transformation_mode",
+            Resize_ver19_attr_coordinate_transformation_mode_doc,
+            AttributeProto::STRING,
+            std::string("half_pixel"))
+        .Attr(
+            "nearest_mode",
+            "Four modes: \"round_prefer_floor\" (default, as known as round half down), \"round_prefer_ceil\" (as known as round half up), \"floor\", \"ceil\". Only used by nearest interpolation. It indicates how to get \"nearest\" pixel in input tensor from x_original, so this attribute is valid only if \"mode\" is \"nearest\".",
+            AttributeProto::STRING,
+            std::string("round_prefer_floor"))
+        .Attr(
+            "extrapolation_value",
+            "When coordinate_transformation_mode is \"tf_crop_and_resize\" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f.",
+            AttributeProto::FLOAT,
+            static_cast<float>(0))
+        .Attr(
+            "antialias",
+            "If set to 1, \"linear\" and \"cubic\" interpolation modes will use an antialiasing filter when downscaling. "
+            "Antialiasing is achieved by stretching the resampling filter by a factor max(1, 1 / scale), which means that when downsampling, more input pixels contribute to an output pixel.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "axes",
+            "If provided, it specifies a subset of axes that 'roi', 'scales' and 'sizes' refer to. "
+            "If not provided, all axes are assumed [0, 1, ..., r-1], where r = rank(data). "
+            "Non-specified dimensions are interpreted as non-resizable. "
+            "Negative value means counting dimensions from the back. Accepted range is [-r, r-1], where r = rank(data). "
+            "Behavior is undefined if an axis is repeated.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "keep_aspect_ratio_policy",
+            Resize_ver19_attr_keep_aspect_ratio_policy_doc,
+            AttributeProto::STRING,
+            std::string("stretch"))
+        .Input(0, "X", "N-D tensor", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "roi",
+            "1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X or the length of axes, if provided. "
+            "The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is \"tf_crop_and_resize\"",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "scales",
+            "The scale array along each dimension. It takes value greater than 0. If it's less than 1,"
+            " it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should"
+            " be the same as the rank of input 'X' or the length of 'axes', if provided. "
+            "One of 'scales' and 'sizes' MUST be specified and it is an error if both are specified. If 'sizes' is needed, the user can use an empty string as the name of 'scales' in this operator's input list.",
+            "tensor(float)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            3,
+            "sizes",
+            "Target size of the output tensor. Its interpretation depends on the 'keep_aspect_ratio_policy' value."
+            "The number of elements of 'sizes' should be the same as the"
+            " rank of input 'X', or the length of 'axes', if provided. Only one of 'scales' and 'sizes' can be specified. ",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "Y", "N-D tensor after resizing", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types_ir4(),
+            "Constrain input 'X' and output 'Y' to all tensor types.")
+        .TypeConstraint("T2", {types::Float16, types::Float, types::Double}, "Constrain roi type to float or double.")
+        .SetDoc(Resize_ver19_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset18_to_19(ctx); }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GridSample,
+    22,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Three interpolation modes: linear (default), nearest and cubic. "
+            "The \"linear\" mode includes linear and N-linear interpolation modes depending on the number of spatial dimensions "
+            "of the input tensor (i.e. linear for 1 spatial dimension, bilinear for 2 spatial dimensions, etc.). "
+            "The \"cubic\" mode also includes N-cubic interpolation modes following the same rules. The \"nearest\" mode rounds "
+            "to the nearest even index when the sampling point falls halfway between two indices.",
+            AttributeProto::STRING,
+            std::string("linear"))
+        .Attr(
+            "padding_mode",
+            "Support padding modes for outside grid values: `zeros`(default), `border`, `reflection`. "
+            "zeros: use 0 for out-of-bound grid locations, "
+            "border: use border values for out-of-bound grid locations, "
+            "reflection: use values at locations reflected by the border for out-of-bound grid locations. "
+            "If index 0 represents the margin pixel, the reflected value at index -1 will be the same as the value at index 1. "
+            "For location far away from the border, it will keep being reflected until becoming in bound. "
+            "If pixel location x = -3.5 reflects by border -1 and becomes x' = 1.5, then reflects by border 1 and becomes x'' = 0.5.",
+            AttributeProto::STRING,
+            std::string("zeros"))
+        .Attr(
+            "align_corners",
+            "If align_corners=1, the extrema (-1 and 1) are considered as referring to the center points of the input's corner pixels (voxels, etc.). "
+            "If align_corners=0, they are instead considered as referring to the corner points of the input's corner pixels (voxels, etc.), "
+            "making the sampling more resolution agnostic.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "X",
+            "Input tensor of rank r+2 that has shape (N, C, D1, D2, ..., Dr), where N is the batch size, "
+            "C is the number of channels, D1, D2, ..., Dr are the spatial dimensions.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "grid",
+            "Input offset of shape (N, D1_out, D2_out, ..., Dr_out, r), where D1_out, D2_out, ..., "
+            "Dr_out are the spatial dimensions of the grid and output, and r is the number of spatial dimensions. "
+            "Grid specifies the sampling locations normalized by the input spatial dimensions. "
+            "Therefore, it should have most values in the range of [-1, 1]. If the grid has values outside the range of [-1, 1], "
+            "the corresponding outputs will be handled as defined by padding_mode. Following computer vision convention, "
+            "the coordinates in the length-r location vector are listed from the innermost tensor dimension to the outermost, "
+            "the opposite of regular tensor indexing.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "Y",
+            "Output tensor of rank r+2 that has shape (N, C, D1_out, D2_out, ..., Dr_out) of the sampled values. "
+            "For integer input types, intermediate values are computed as floating point and cast to integer at the end.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types_ir4(),
+            "Constrain input `X` and output `Y` types to all tensor types.")
+        .TypeConstraint("T2", OpSchema::all_float_types_ir4(), "Constrain grid types to float tensors.")
+        .SetDoc(kDoc_GridSample_ver20)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { gridSampleShapeInference(ctx); }));
+
+static constexpr const char* AffineGrid_ver20_doc = R"DOC(
+Generates a 2D or 3D flow field (sampling grid), given a batch of affine matrices theta
+(https://pytorch.org/docs/stable/generated/torch.nn.functional.affine_grid.html).
+An affine matrix `theta` is applied to a position tensor represented in its homogeneous expression. Here is an example in 3D:
+```
+[r00, r01, r02, t0]   [x]   [x']
+[r10, r11, r12, t1] * [y] = [y']
+[r20, r21, r22, t2]   [z]   [z']
+[0,   0,   0,   1 ]   [1]   [1 ]
+```
+where `(x, y, z)` is the position in the original space, `(x', y', z')` is the position in the output space.
+The last row is always `[0, 0, 0, 1]` and is not stored in the affine matrix. Therefore we have `theta` of shape `(N, 2, 3)` for 2D or `(N, 3, 4)` for 3D.
+
+Input `size` is used to define grid of positions evenly spaced in the original 2D or 3D space, with dimensions ranging from `-1` to `1`.
+The output `grid` contains positions in the output space.
+
+When `align_corners=1`, consider `-1` and `1` to refer to the centers of the corner pixels (mark `v` in illustration).
+```
+v            v            v            v
+|-------------------|------------------|
+-1                  0                  1
+```
+When `align_corners=0`, consider `-1` and `1` to refer to the outer edge of the corner pixels.
+```
+    v        v         v         v
+|------------------|-------------------|
+-1                 0                   1
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    AffineGrid,
+    20,
+    OpSchema()
+        .Attr(
+            "align_corners",
+            "if align_corners=1, consider -1 and 1 to refer to the centers of the corner pixels. "
+            "if align_corners=0, consider -1 and 1 to refer to the outer edge the corner pixels.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "theta",
+            "input batch of affine matrices with shape (N, 2, 3) for 2D or (N, 3, 4) for 3D",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            1,
+            "size",
+            "the target output image size (N, C, H, W) for 2D or (N, C, D, H, W) for 3D",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "grid",
+            "output tensor of shape (N, H, W, 2) of 2D sample coordinates or (N, D, H, W, 3) of 3D sample coordinates.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T1", OpSchema::all_float_types_ir4(), "Constrain grid types to float tensors.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain size's type to int64 tensors.")
+        .SetDoc(AffineGrid_ver20_doc)
+        .FunctionBody(R"ONNX(
+        {
+          # naming one: 1, one_f: 1.0, one_1d: [1], one_f_1d: [1.0]
+          one = Constant <value_int: int=1> ()
+          two = Constant <value_int: int=2> ()
+          zero = Constant <value_int: int=0> ()
+          four = Constant <value_int: int=4> ()
+          one_1d = Constant <value_ints: ints = [1]> ()
+          zero_1d = Constant <value_ints: ints = [0]> ()
+
+          minus_one = Constant <value_int: int=-1> ()
+          minus_one_f = CastLike (minus_one, theta)
+          zero_f = CastLike (zero, theta)
+          one_f = CastLike (one, theta)
+          two_f = CastLike (two, theta)
+
+          constant_align_corners = Constant <value_int: int=@align_corners> ()
+          constant_align_corners_equal_zero = Equal (constant_align_corners, zero)
+
+          size_ndim = Size (size)
+          condition_is_2d = Equal (size_ndim, four)
+
+          N, C, D, H, W = If (condition_is_2d) <
+              then_branch = g1 () => (N_then, C_then, D_then, H_then, W_then) {
+                  N_then, C_then, H_then, W_then = Split <num_outputs: int=4> (size)
+                  D_then = Identity (one_1d)
+              },
+              else_branch = g2 () => (N_else, C_else, D_else, H_else, W_else) {
+                  N_else, C_else, D_else, H_else, W_else = Split <num_outputs: int=5> (size)
+              }
+          >
+          size_NCDHW = Concat <axis=0> (N, C, D, H, W)
+
+          theta_3d = If (condition_is_2d) <
+              then_branch = g3 () => (theta_then) { # theta: N by 2 by 3 => N by 3 by 4
+                  # use of thetaN23 is a way to make shape inference happy when theta is N by 3 by 4.
+                  gather_idx_6 = Constant <value_ints: ints = [0, 1, 2, 0, 1, 2]> ()
+                  shape_23 = Constant <value_ints: ints = [2, 3]> ()
+                  gather_idx_23 = Reshape (gather_idx_6, shape_23)
+                  shape_N23 = Concat <axis=0>(N, shape_23)
+                  gather_idx_N23 = Expand (gather_idx_23, shape_N23)
+                  thetaN23 = GatherElements <axis=2> (theta, gather_idx_N23) # N by 2 by 3 => N by 3 by 2
+
+                  r1, r2 = Split <axis: int=1, num_outputs: int=2> (thetaN23) # N by 1 by 3
+                  r1_ = Squeeze (r1) # N by 3
+                  r2_ = Squeeze (r2)
+                  r11, r12, t1 = Split <axis: int=1, num_outputs: int=3> (r1_) # N by 1
+                  r21, r22, t2 = Split <axis: int=1, num_outputs: int=3> (r2_)
+
+                  r11_shape = Shape (r21)
+                  float_zero_1d_ = ConstantOfShape (r11_shape) # N by 1
+                  float_zero_1d = CastLike (float_zero_1d_, theta)
+                  float_one_1d = Add (float_zero_1d, one_f) # N by 1
+
+                  R1 = Concat <axis=1>(r11, r12, float_zero_1d, t1) # N by 4
+                  R2 = Concat <axis=1>(r21, r22, float_zero_1d, t2)
+                  R3 = Concat <axis=1>(float_zero_1d, float_zero_1d, float_one_1d, float_zero_1d)
+
+                  R1_ = Unsqueeze (R1, one_1d) # N by 1 by 4
+                  R2_ = Unsqueeze (R2, one_1d)
+                  R3_ = Unsqueeze (R3, one_1d)
+                  theta_then = Concat <axis=1> (R1_, R2_, R3_) # N by 3 by 4
+                  # theta_then = Identity (theta)
+              },
+              else_branch = g4 () => (theta_else) {
+                  theta_else = Identity (theta)
+              }
+          >
+
+          two_1d = Constant <value_ints=[2]> ()
+          three_1d = Constant <value_ints=[3]> ()
+          five_1d = Constant <value_ints=[5]> ()
+          constant_D_H_W_shape = Slice (size_NCDHW, two_1d, five_1d) # [N, C, D, H, W] => [D, H, W]
+          zeros_D_H_W_ = ConstantOfShape (constant_D_H_W_shape)
+          zeros_D_H_W = CastLike (zeros_D_H_W_, theta)
+          ones_D_H_W = Add (zeros_D_H_W, one_f)
+
+          D_float = CastLike (D, zero_f)
+          H_float = CastLike (H, zero_f)
+          W_float = CastLike (W, zero_f)
+          start_d, step_d, start_h, step_h, start_w, step_w = If (constant_align_corners_equal_zero) <
+              then_branch = h1 () => (start_d_then, step_d_then, start_h_then, step_h_then, start_w_then, step_w_then) { # => (float, float, float, float, float, float)
+                  step_d_then = Div (two_f, D_float)
+                  step_h_then = Div (two_f, H_float)
+                  step_w_then = Div (two_f, W_float)
+
+                  step_d_half = Div (step_d_then, two_f)
+                  start_d_then = Add (minus_one_f, step_d_half)
+
+                  step_h_half = Div (step_h_then, two_f)
+                  start_h_then = Add (minus_one_f, step_h_half)
+
+                  step_w_half = Div (step_w_then, two_f)
+                  start_w_then = Add (minus_one_f, step_w_half)
+              },
+              else_branch = h2 () => (start_d_else, step_d_else, start_h_else, step_h_else, start_w_else, step_w_else) { # => (float, float, float, float, float, float)
+                  D_float_nimus_one = Sub (D_float, one_f)
+                  H_float_nimus_one = Sub (H_float, one_f)
+                  W_float_nimus_one = Sub (W_float, one_f)
+                  # avoid divide by 0
+                  D_equals_one = Equal (D, one)
+                  step_d_else = If (D_equals_one) <
+                      then_branch = g5 () => (step_d_else_then) {
+                          step_d_else_then = Identity (zero_f)
+                      },
+                      else_branch = g6 () => (step_d_else_else) {
+                          step_d_else_else = Div (two_f, D_float_nimus_one)
+                      }
+                  >
+                  step_h_else = Div (two_f, H_float_nimus_one)
+                  step_w_else = Div (two_f, W_float_nimus_one)
+                  start_d_else = Identity (minus_one_f)
+                  start_h_else = Identity (minus_one_f)
+                  start_w_else = Identity (minus_one_f)
+              }
+          >
+          grid_w_steps_int = Range (zero, W, one)
+          grid_w_steps_float = CastLike (grid_w_steps_int, step_w)
+          grid_w_steps = Mul (grid_w_steps_float, step_w)
+          grid_w_0 = Add (start_w, grid_w_steps)
+
+          grid_h_steps_int = Range (zero, H, one)
+          grid_h_steps_float = CastLike (grid_h_steps_int, step_h)
+          grid_h_steps = Mul (grid_h_steps_float, step_h)
+          grid_h_0 = Add (start_h, grid_h_steps)
+
+          grid_d_steps_int = Range (zero, D, one)
+          grid_d_steps_float = CastLike (grid_d_steps_int, step_d)
+          grid_d_steps = Mul (grid_d_steps_float, step_d)
+          grid_d_0 = Add (start_d, grid_d_steps)
+
+          zeros_H_W_D = Transpose <perm = [1, 2, 0]> (zeros_D_H_W)
+          grid_d_1 = Add (zeros_H_W_D, grid_d_0)
+          grid_d = Transpose <perm = [2, 0, 1]> (grid_d_1)
+
+          zeros_D_W_H = Transpose <perm = [0, 2, 1]> (zeros_D_H_W)
+          grid_h_1 = Add (zeros_D_W_H, grid_h_0)
+          grid_h = Transpose <perm = [0, 2, 1]> (grid_h_1)
+
+          grid_w = Add (grid_w_0, zeros_D_H_W)
+
+          grid_w_usqzed = Unsqueeze (grid_w, minus_one)
+          grid_h_usqzed = Unsqueeze (grid_h, minus_one)
+          grid_d_usqzed = Unsqueeze (grid_d, minus_one)
+          ones_D_H_W_usqzed = Unsqueeze (ones_D_H_W, minus_one)
+          original_grid = Concat <axis=-1> (grid_w_usqzed, grid_h_usqzed, grid_d_usqzed, ones_D_H_W_usqzed)
+
+          constant_shape_DHW_4 = Constant <value_ints: ints = [-1, 4]> ()
+          original_grid_DHW_4 = Reshape (original_grid, constant_shape_DHW_4)
+          original_grid_4_DHW_ = Transpose (original_grid_DHW_4)
+
+          original_grid_4_DHW = CastLike (original_grid_4_DHW_, theta_3d)
+          grid_N_3_DHW = MatMul (theta_3d, original_grid_4_DHW)
+          grid_N_DHW_3 = Transpose <perm = [0, 2, 1]> (grid_N_3_DHW)
+          N_D_H_W_3 = Concat <axis=-1> (N, D, H, W, three_1d)
+          grid_3d_else_ = Reshape (grid_N_DHW_3, N_D_H_W_3)
+          grid_3d = CastLike (grid_3d_else_, theta_3d)
+
+          # grid = Identity (grid_3d)
+          grid = If (condition_is_2d) <
+              then_branch = g1 () => (grid_then) { # [N, D=1, H, W, 3] => [N, H, W, 2]
+                  grid_squeezed = Squeeze (grid_3d, one_1d)  # [N, H, W, 3]
+                  grid_then = Slice (grid_squeezed, zero_1d, two_1d, three_1d) # [N, H, W, 2]
+              },
+              else_branch = g2 () => (grid_else) {
+                  grid_else = Identity (grid_3d)
+              }
+          >
+        }
+        )ONNX")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          checkInputRank(ctx, 1, 1);
+
+          bool found;
+          TensorShapeProto size_proto = getShapeInput(ctx, 1, found);
+          if (!found) {
+            return;
+          }
+
+          const auto size_length = size_proto.dim_size();
+          if (size_length != 4 && size_length != 5) {
+            fail_shape_inference("Length of input 'size' is ", size_length, ". It must be 4 for 2D or 5 for 5D.");
+          }
+
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          const auto& N = size_proto.dim(0);
+          *output_shape->add_dim() = N;
+          // const auto& C = size_proto.dim(1); // C is not used
+          if (size_length == 4) {
+            // 2D case: size shape (N, C, H, W), output shape (N, C, H, W, 2)
+            const auto& H = size_proto.dim(2);
+            const auto& W = size_proto.dim(3);
+            *output_shape->add_dim() = H;
+            *output_shape->add_dim() = W;
+            output_shape->add_dim()->set_dim_value(2);
+          } else if (size_length == 5) {
+            // 3D case: size shape (N, C, D, H, W), output shape (N, C, D, H, W, 3)
+            const auto& D = size_proto.dim(2);
+            const auto& H = size_proto.dim(3);
+            const auto& W = size_proto.dim(4);
+            *output_shape->add_dim() = D;
+            *output_shape->add_dim() = H;
+            *output_shape->add_dim() = W;
+            output_shape->add_dim()->set_dim_value(3);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Identity,
+    25,
+    OpSchema()
+        .SetDoc("Identity operator")
+        .Input(0, "input", "Input tensor", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Tensor to copy input into.", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types_ir13();
+              auto s = OpSchema::all_tensor_sequence_types();
+              auto o = OpSchema::all_optional_types();
+              t.insert(t.end(), s.begin(), s.end());
+              t.insert(t.end(), o.begin(), o.end());
+              return t;
+            }(),
+            "Constrain input and output types to all tensor, sequence, and optional types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Compress,
+    11,
+    OpSchema()
+        .SetDoc(kDoc_Compress_ver9)
+        .Attr(
+            "axis",
+            "(Optional) Axis along which to take slices. If not specified, "
+            "input is flattened before elements being selected. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "condition",
+            "Rank 1 tensor of booleans to indicate which slices or data elements to be selected. "
+            "Its length can be less than the input length along the axis "
+            "or the flattened input size if axis is not specified. "
+            "In such cases data slices or elements exceeding the condition length are discarded.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of rank r if axis is specified. Otherwise output is a Tensor of rank 1.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain to boolean tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto axisAttr = ctx.getAttribute("axis");
+          if (hasInputShape(ctx, 0)) {
+            const TensorShapeProto& indices_shape = ctx.getInputType(0)->tensor_type().shape();
+            int r = indices_shape.dim_size();
+            if (r < 1) {
+              fail_shape_inference("Indices tensor must have rank >= 1");
+            }
+            if (axisAttr) {
+              int axis = static_cast<int>(axisAttr->i());
+              if (axis < -r || axis >= r) {
+                fail_shape_inference("'axis' must be in [-rank(indices), rank(indices)-1]");
+              }
+              if (axis < 0) {
+                axis += r;
+              }
+              TensorShapeProto* shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+              for (int i = 0; i < indices_shape.dim_size(); i++) {
+                auto dim = shape->add_dim();
+                if (i != axis) {
+                  *dim = indices_shape.dim(i);
+                }
+              }
+            }
+          }
+          if (!axisAttr) {
+            updateOutputShape(ctx, 0, {Dim()});
+          }
+        }));
+
+static constexpr const char* OneHot_ver11_doc = R"DOC(
+    Produces a one-hot tensor based on inputs.
+    The locations represented by the index values in the 'indices' input tensor will have 'on_value'
+    and the other locations will have 'off_value' in the output tensor, where 'on_value' and 'off_value'
+    are specified as part of required input argument 'values', which is a two-element tensor of format
+    [off_value, on_value]. The rank of the output tensor will be one greater than the rank of the
+    input tensor. The additional dimension is for one-hot representation. The additional dimension will
+    be inserted at the position specified by 'axis'. If 'axis' is not specified then then additional
+    dimension will be inserted as the innermost dimension, i.e. axis=-1. The size of the additional
+    dimension is specified by required scalar input 'depth'. The type of the output tensor is the same
+    as the type of the 'values' input. Any entries in the 'indices' input tensor with values outside
+    the range [-depth, depth-1] will result in one-hot representation with all 'off_value' values in the
+    output tensor.
+
+    when axis = 0:
+    output[input[i, j, k], i, j, k] = 1 for all i, j, k and 0 otherwise.
+
+    when axis = -1:
+    output[i, j, k, input[i, j, k]] = 1 for all i, j, k and 0 otherwise.
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    OneHot,
+    11,
+    OpSchema()
+        .SetDoc(OneHot_ver11_doc)
+        .Attr(
+            "axis",
+            "(Optional) Axis along which one-hot representation in added. Default: axis=-1. "
+            "axis=-1 means that the additional dimension will be inserted as the "
+            "innermost/last dimension in the output tensor. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r-1, r] where r = rank(indices).",
+            AttributeProto::INT,
+            static_cast<int64_t>(-1))
+        .Input(
+            0,
+            "indices",
+            "Input tensor containing indices. Any entries in the 'indices' input tensor with "
+            "values outside the range [-depth, depth-1] will result in one-hot representation with all "
+            "'off_value' values in the output tensor."
+            "In case 'indices' is of non-integer type, the values will be casted to int64 before use.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            1,
+            "depth",
+            "Scalar or Rank 1 tensor containing exactly one element, specifying the number of classes "
+            "in one-hot tensor. This is also the size of the one-hot dimension (specified by 'axis' attribute) "
+            "added on in the output tensor. The values in the 'indices' input tensor are expected to be "
+            "in the range [-depth, depth-1]. "
+            "In case 'depth' is of non-integer type, it will be casted to int64 before use.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "values",
+            "Rank 1 tensor containing exactly two elements, in the format [off_value, on_value], "
+            "where 'on_value' is the value used for filling locations specified in 'indices' input "
+            "tensor, and 'off_value' is the value used for filling locations other than those specified "
+            "in 'indices' input tensor. ",
+            "T3",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of rank one greater than input tensor 'indices', i.e. rank(output) = rank(indices) + 1. "
+            "The data type for the elements of the output tensor is the same as the type of input 'values' "
+            "is used.",
+            "T3",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T1", OpSchema::all_numeric_types(), "Constrain input to only numeric types.")
+        .TypeConstraint("T2", OpSchema::all_numeric_types(), "Constrain input to only numeric types.")
+        .TypeConstraint("T3", OpSchema::all_tensor_types(), "Constrain to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Check that the node has three inputs.
+          if (ctx.getNumInputs() != 3) {
+            fail_type_inference("OneHot node must have three inputs.");
+          }
+          // Input 'depth' must be a scalar or a single-element vector.
+          // TODO(ONNX): Ideally to match spec for this input only Scalar should
+          // be allowed. Making this change now can affect backward
+          // compatibility for this op. Since this does not seem like a good
+          // justification to update version for this op, allowing both scalar
+          // and 1 element vector for now. In future when version update for
+          // this op is done we should only allow scalar or change the spec to
+          // allow both.
+          std::optional<int64_t> depth_value;
+          if (hasInputShape(ctx, 1)) {
+            auto& depth_shape = getInputShape(ctx, 1);
+            if (const TensorProto* depth_data = ctx.getInputData(1)) {
+              if (depth_data->data_type() == TensorProto::INT64) {
+                depth_value = ParseData<int64_t>(depth_data)[0];
+              } else if (depth_data->data_type() == TensorProto::INT32) {
+                depth_value = ParseData<int32_t>(depth_data)[0];
+              } else if (depth_data->data_type() == TensorProto::FLOAT) {
+                depth_value = static_cast<int64_t>(ParseData<float>(depth_data)[0]);
+              }
+            }
+            if (depth_shape.dim_size() != 0 && depth_shape.dim_size() != 1) {
+              fail_type_inference("Input 'depth' must be a scalar or rank 1 tensor.");
+            }
+            if (depth_shape.dim_size() == 1 && depth_shape.dim(0).has_dim_value() &&
+                depth_shape.dim(0).dim_value() != 1) {
+              fail_type_inference("Input 'depth' must have exactly one element.");
+            }
+          }
+          // Input 'values' must be a two-element vector.
+          if (hasInputShape(ctx, 2)) {
+            auto& values_shape = getInputShape(ctx, 2);
+            if (values_shape.dim_size() != 1) {
+              fail_type_inference("Input 'values' must be rank 1 tensor.");
+            }
+            if (values_shape.dim(0).has_dim_value() && values_shape.dim(0).dim_value() != 2) {
+              fail_type_inference("Input 'values' must have exactly two elements.");
+            }
+          }
+          // Set output type to be the same as the third input, 'values'.
+          propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          // Set the output shape, if input 0 (indices) shape is available.
+          if (hasInputShape(ctx, 0)) {
+            const TensorShapeProto& indices_shape = ctx.getInputType(0)->tensor_type().shape();
+            int r = indices_shape.dim_size();
+            if (r < 1) {
+              fail_shape_inference("Indices tensor must have rank >= 1");
+            }
+            int out_rank = r + 1;
+            int axis = static_cast<int>(getAttribute(ctx, "axis", -1));
+            if (axis < -out_rank || axis >= out_rank) {
+              fail_shape_inference("'axis' must be in [-rank(indices), rank(indices)-1]");
+            }
+            if (axis < 0) {
+              axis += out_rank;
+            }
+            auto output_shape = getOutputShape(ctx, 0);
+            for (int i = 0; i < out_rank; ++i) {
+              auto dim = output_shape->add_dim();
+              if (i < axis) {
+                if (indices_shape.dim(i).has_dim_value()) {
+                  dim->set_dim_value(indices_shape.dim(i).dim_value());
+                } else if (indices_shape.dim(i).has_dim_param()) {
+                  dim->set_dim_param(indices_shape.dim(i).dim_param());
+                }
+              } else if (i > axis) {
+                if (indices_shape.dim(i - 1).has_dim_value()) {
+                  dim->set_dim_value(indices_shape.dim(i - 1).dim_value());
+                } else if (indices_shape.dim(i - 1).has_dim_param()) {
+                  dim->set_dim_param(indices_shape.dim(i - 1).dim_param());
+                }
+              } else if (depth_value) {
+                dim->set_dim_value(*depth_value);
+              }
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    IsNaN,
+    20,
+    OpSchema()
+        .SetDoc(R"DOC(Returns which elements of the input are NaN.)DOC")
+        .Input(0, "X", "input", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "output", "T2", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T1", OpSchema::all_float_types_ir9(), "Constrain input types to float tensors.")
+        .TypeConstraint("T2", {types::Bool}, "Constrain output types to boolean tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          updateOutputElemType(ctx, 0, TensorProto::BOOL);
+          if (hasInputShape(ctx, 0)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    IsInf,
+    20,
+    OpSchema()
+        .SetDoc(R"DOC(Map infinity to true and other values to false.)DOC")
+        .Input(0, "X", "input", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "output", "T2", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr(
+            "detect_positive",
+            "(Optional) Whether map positive infinity to true. Default to 1 "
+            "so that positive infinity induces true. Set this attribute to 0 "
+            "if positive infinity should be mapped to false.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "detect_negative",
+            "(Optional) Whether map negative infinity to true. Default to 1 "
+            "so that negative infinity induces true. Set this attribute to 0 "
+            "if negative infinity should be mapped to false.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeConstraint("T1", OpSchema::all_float_types_ir9(), "Constrain input types to float tensors.")
+        .TypeConstraint("T2", {types::Bool}, "Constrain output types to boolean tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          updateOutputElemType(ctx, 0, TensorProto::BOOL);
+          if (hasInputShape(ctx, 0)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Where,
+    16,
+    OpSchema()
+        .SetDoc(GET_OP_DOC_STR(std::string(kDoc_Where_ver9) + GenerateBroadcastingDocMul()))
+        .Input(
+            0,
+            "condition",
+            "When True (nonzero), yield X, otherwise yield Y",
+            "B",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            1,
+            "X",
+            "values selected at indices where condition is True",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "Y",
+            "values selected at indices where condition is False",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of shape equal to the broadcasted shape of condition, X, and Y.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("B", {types::Bool}, "Constrain to boolean tensors.")
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir4(),
+            "Constrain input and output types to all tensor types (including bfloat).")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (hasNInputShapes(ctx, 3)) {
+            std::vector<const TensorShapeProto*> shapes;
+            shapes.push_back(&ctx.getInputType(0)->tensor_type().shape());
+            shapes.push_back(&ctx.getInputType(1)->tensor_type().shape());
+            shapes.push_back(&ctx.getInputType(2)->tensor_type().shape());
+            multidirectionalBroadcastShapeInference(
+                shapes, *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    NonZero,
+    13,
+    OpSchema()
+        .SetDoc(NonZero_ver9_doc)
+        .Input(0, "X", "input", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "output", "tensor(int64)", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          updateOutputElemType(ctx, 0, TensorProto::INT64);
+          TensorShapeProto output_shape;
+          auto dim = output_shape.add_dim();
+          if (hasInputShape(ctx, 0)) {
+            const TensorShapeProto& input_shape = getInputShape(ctx, 0);
+            dim->set_dim_value(input_shape.dim_size());
+          }
+          output_shape.add_dim();
+          updateOutputShape(ctx, 0, output_shape);
+        }));
+
+static constexpr const char* ReverseSequence_ver10_doc = R"DOC(
+Reverse batch of sequences having different lengths specified by `sequence_lens`.
+
+For each slice i iterating on batch axis, the operator reverses the first sequence_lens[i] elements on time axis,
+and copies elements whose index's beyond sequence_lens[i] to the output. So the output slice i contains reversed
+sequences on the first sequence_lens[i] elements, then have original values copied for the other elements.
+
+Example 1:
+  input = [[0.0, 4.0, 8.0,  12.0],
+           [1.0, 5.0, 9.0,  13.0],
+           [2.0, 6.0, 10.0, 14.0],
+           [3.0, 7.0, 11.0, 15.0]]
+  sequence_lens = [4, 3, 2, 1]
+  time_axis = 0
+  batch_axis = 1
+
+  output = [[3.0, 6.0, 9.0,  12.0],
+            [2.0, 5.0, 8.0,  13.0],
+            [1.0, 4.0, 10.0, 14.0],
+            [0.0, 7.0, 11.0, 15.0]]
+
+Example 2:
+  input = [[0.0,  1.0,  2.0,  3.0 ],
+           [4.0,  5.0,  6.0,  7.0 ],
+           [8.0,  9.0,  10.0, 11.0],
+           [12.0, 13.0, 14.0, 15.0]]
+  sequence_lens = [1, 2, 3, 4]
+  time_axis = 1
+  batch_axis = 0
+
+  output = [[0.0,  1.0,  2.0,  3.0 ],
+            [5.0,  4.0,  6.0,  7.0 ],
+            [10.0, 9.0,  8.0,  11.0],
+            [15.0, 14.0, 13.0, 12.0]]
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ReverseSequence,
+    10,
+    OpSchema()
+        .SetDoc(ReverseSequence_ver10_doc)
+        .Attr(
+            "time_axis",
+            "(Optional) Specify which axis is time axis. Must be one of 0 (default), or 1.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "batch_axis",
+            "(Optional) Specify which axis is batch axis. Must be one of 1 (default), or 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Input(0, "input", "Tensor of rank r >= 2.", "T", OpSchema::Single)
+        .Input(
+            1,
+            "sequence_lens",
+            "Tensor specifying lengths of the sequences in a batch. It has shape `[batch_size]`.",
+            "tensor(int64)",
+            OpSchema::Single)
+        .Output(0, "Y", "Tensor with same shape of input.", "T", OpSchema::Single)
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Input and output types can be of any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 2)) {
+            return;
+          }
+
+          auto& first_input_shape = getInputShape(ctx, 0);
+          if (first_input_shape.dim_size() < 2) {
+            fail_shape_inference("'input' must have rank >= 2");
+          }
+          auto& seq_len_input_shape = getInputShape(ctx, 1);
+          if (seq_len_input_shape.dim_size() != 1) {
+            fail_shape_inference("'sequence_lens' must have rank of 1");
+          }
+
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+
+static constexpr const char* Unique_ver11_doc = R"DOC(
+Find the unique elements of a tensor. When an optional attribute 'axis' is provided, unique subtensors sliced along the 'axis' are returned.
+Otherwise the input tensor is flattened and unique values of the flattened tensor are returned.
+
+This operator returns the unique values or sliced unique subtensors of the input tensor and three optional outputs.
+The first output tensor 'Y' contains all unique values or subtensors of the input.
+The second optional output tensor 'indices' contains indices of 'Y' elements' first occurrence in 'X'.
+The third optional output tensor 'inverse_indices' contains, for elements of 'X', its corresponding indices in 'Y'.
+The fourth optional output tensor 'counts' contains the count of each element of 'Y' in the input.
+
+Outputs are either sorted in ascending order or optionally in the order of the first occurrence of the values in the input.
+
+https://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html
+
+Example 1:
+```
+input_X = [2, 1, 1, 3, 4, 3]
+attribute_sorted = 0
+attribute_axis = None
+output_Y = [2, 1, 3, 4]
+output_indices = [0, 1, 3, 4]
+output_inverse_indices = [0, 1, 1, 2, 3, 2]
+output_counts = [1, 2, 2, 1]
+```
+
+Example 2:
+```
+input_X = [[1, 3], [2, 3]]
+attribute_sorted = 1
+attribute_axis = None
+output_Y = [1, 2, 3]
+output_indices = [0, 2, 1]
+output_inverse_indices = [0, 2, 1, 2]
+output_counts = [1, 1, 2]
+```
+
+Example 3:
+```
+input_X = [[1, 0, 0], [1, 0, 0], [2, 3, 4]]
+attribute_sorted = 1
+attribute_axis = 0
+output_Y = [[1, 0, 0], [2, 3, 4]]
+output_indices = [0, 2]
+output_inverse_indices = [0, 0, 1]
+output_counts = [2, 1]
+```
+
+Example 4:
+```
+input_x = [[[1., 1.], [0., 1.], [2., 1.], [0., 1.]],
+            [[1., 1.], [0., 1.], [2., 1.], [0., 1.]]]
+attribute_sorted = 1
+attribute_axis = 1
+```
+
+intermediate data are presented below for better understanding:
+there are 4 subtensors sliced along axis 1 of input_x (shape = (2, 4, 2)):
+```
+A: [[1, 1], [1, 1]],
+   [[0, 1], [0, 1]],
+   [[2, 1], [2, 1]],
+   [[0, 1], [0, 1]].
+```
+
+there are 3 unique subtensors:
+```
+[[1, 1], [1, 1]],
+[[0, 1], [0, 1]],
+[[2, 1], [2, 1]].
+```
+
+sorted unique subtensors:
+```
+B: [[0, 1], [0, 1]],
+   [[1, 1], [1, 1]],
+   [[2, 1], [2, 1]].
+```
+
+output_Y is constructed from B:
+```
+[[[0. 1.], [1. 1.], [2. 1.]],
+ [[0. 1.], [1. 1.], [2. 1.]]]
+```
+
+output_indices is to map from B to A:
+```
+[1, 0, 2]
+```
+
+output_inverse_indices is to map from A to B:
+```
+[1, 0, 2, 0]
+```
+
+output_counts:
+```
+[2, 1, 1]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Unique,
+    11,
+    OpSchema()
+        .SetDoc(Unique_ver11_doc)
+        .Attr(
+            "sorted",
+            "(Optional) Whether to sort the unique elements in ascending order before returning as output. "
+            "Must be one of 0, or 1 (default).",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "axis",
+            "(Optional) The dimension to apply unique. If not specified, the unique elements of the "
+            "flattened input are returned. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(input).",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(
+            0,
+            "X",
+            "A N-D input tensor that is to be processed.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "Y",
+            "A tensor of the same type as 'X' "
+            "containing all the unique values or subtensors sliced along a provided 'axis' in 'X', either sorted "
+            "or maintained in the same order they occur in input 'X'",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            1,
+            "indices",
+            "A 1-D INT64 tensor "
+            "containing indices of 'Y' elements' first occurrence in 'X'. "
+            "When 'axis' is provided, it contains indices to subtensors in input 'X' on the 'axis'. "
+            "When 'axis' is not provided, it contains indices to values in the flattened input tensor. ",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            2,
+            "inverse_indices",
+            "A 1-D INT64 tensor "
+            "containing, for elements of 'X', its corresponding indices in 'Y'. "
+            "When 'axis' is provided, it contains indices to subtensors in output 'Y' on the 'axis'. "
+            "When 'axis' is not provided, it contains indices to values in output 'Y'. ",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            3,
+            "counts",
+            "A 1-D INT64 tensor containing "
+            "the count of each element "
+            "of 'Y' in input 'X'",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Input can be of any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          const TypeProto* xTensorProto = ctx.getInputType(0);
+          TypeProto* yTensorProto = ctx.getOutputType(0);
+          TypeProto* indicesTensorProto = nullptr;
+          TypeProto* inverseIndicesTensorProto = nullptr;
+          TypeProto* countsTensorProto = nullptr;
+
+          // 'indices', 'inverse_indices', and 'counts' are 1-D tensors of
+          // unknown dimension.
+          // Shape inference will happen even in case of empty optional outputs,
+          // graph-level shape inference should not propagate the shape downstream for empty optional outputs.
+          auto num_outputs = ctx.getNumOutputs();
+          if (num_outputs >= 2) {
+            indicesTensorProto = ctx.getOutputType(1);
+            updateOutputElemType(ctx, 1, TensorProto::INT64);
+            indicesTensorProto->mutable_tensor_type()->mutable_shape()->add_dim();
+          }
+
+          if (num_outputs >= 3) {
+            inverseIndicesTensorProto = ctx.getOutputType(2);
+            updateOutputElemType(ctx, 2, TensorProto::INT64);
+            inverseIndicesTensorProto->mutable_tensor_type()->mutable_shape()->add_dim();
+          }
+
+          if (num_outputs >= 4) {
+            countsTensorProto = ctx.getOutputType(3);
+            updateOutputElemType(ctx, 3, TensorProto::INT64);
+            countsTensorProto->mutable_tensor_type()->mutable_shape()->add_dim();
+          }
+
+          auto axisAttr = ctx.getAttribute("axis");
+          if (!axisAttr) {
+            // 'axis' is not provided. Input 'X' is flattened.
+            // 'Y' is a 1-D tensor of unknown dimension.
+            yTensorProto->mutable_tensor_type()->mutable_shape()->add_dim();
+          } else {
+            // 'axis' is provided.
+            int axis = static_cast<int>(axisAttr->i());
+            if (!xTensorProto->tensor_type().has_shape()) {
+              return;
+            }
+            const TensorShapeProto& input_shape = xTensorProto->tensor_type().shape();
+            int rank = input_shape.dim_size();
+            if (axis < 0)
+              axis += rank;
+            if (axis < 0 || axis >= rank) {
+              fail_shape_inference("Invalid value for attribute axis");
+            }
+            // 'Y' has the same shape as 'X' except in the 'axis' dimension
+            // which is unknown.
+            for (int i = 0; i < input_shape.dim_size(); i++) {
+              auto dim = yTensorProto->mutable_tensor_type()->mutable_shape()->add_dim();
+              if (i != axis) {
+                *dim = input_shape.dim(i);
+              }
+            }
+          }
+        }));
+
+static constexpr const char* GatherND_ver13_doc = R"DOC(
+Given `data` tensor of rank `r` >= 1, `indices` tensor of rank `q` >= 1, and `batch_dims` integer `b`, this operator gathers
+slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1 - b`.
+
+`indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
+where each element defines a slice of `data`
+
+`batch_dims` (denoted as `b`) is an integer indicating the number of batch dimensions, i.e the leading `b` number of dimensions of
+`data` tensor and `indices` are representing the batches, and the gather starts from the `b+1` dimension.
+
+Some salient points about the inputs' rank and shape:
+
+1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`
+
+2) The first `b` dimensions of the shape of `indices` tensor and `data` tensor must be equal.
+
+3) b < min(q, r) is to be honored.
+
+4) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r-b` (inclusive)
+
+5) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
+   It is an error if any of the index values are out of bounds.
+
+The output is computed as follows:
+
+The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.
+
+1) If `indices_shape[-1] > r-b` => error condition
+
+2) If `indices_shape[-1] == r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensors
+   containing 1-D tensors of dimension `r-b`, where `N` is an integer equals to the product of 1 and all the elements in the batch dimensions
+   of the indices_shape. Let us think of each such `r-b` ranked tensor as `indices_slice`. Each *scalar value* corresponding to `data[0:b-1,indices_slice]`
+   is filled into the corresponding location of the `(q-b-1)`-dimensional tensor to form the `output` tensor (Example 1 below)
+
+3) If `indices_shape[-1] < r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensor
+   containing 1-D tensors of dimension `< r-b`. Let us think of each such tensors as `indices_slice`. Each *tensor slice* corresponding
+   to `data[0:b-1, indices_slice , :]` is filled into the corresponding location of the `(q-b-1)`-dimensional tensor
+   to form the `output` tensor (Examples 2, 3, 4 and 5 below)
+
+This operator is the inverse of `ScatterND`.
+
+**Example 1**
+
+```
+batch_dims = 0
+data    = [[0,1],[2,3]]   # data_shape    = [2, 2]
+indices = [[0,0],[1,1]]   # indices_shape = [2, 2]
+output  = [0,3]           # output_shape  = [2]
+```
+
+**Example 2**
+
+```
+batch_dims = 0
+data    = [[0,1],[2,3]]  # data_shape    = [2, 2]
+indices = [[1],[0]]      # indices_shape = [2, 1]
+output  = [[2,3],[0,1]]  # output_shape  = [2, 2]
+```
+
+**Example 3**
+
+```
+batch_dims = 0
+data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
+indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]
+output  = [[2,3],[4,5]]                 # output_shape  = [2, 2]
+```
+
+**Example 4**
+
+```
+batch_dims = 0
+data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
+indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]
+output  = [[[2,3]],[[4,5]]]             # output_shape  = [2, 1, 2]
+```
+
+**Example 5**
+
+```
+batch_dims = 1
+data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape    = [2, 2, 2]
+indices = [[1],[0]]                     # indices_shape = [2, 1]
+output  = [[2,3],[4,5]]                 # output_shape  = [2, 2]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GatherND,
+    13,
+    OpSchema()
+        .SetDoc(GatherND_ver13_doc)
+        .Attr(
+            "batch_dims",
+            "The number of batch dimensions. The gather of indexing starts from dimension of data[batch_dims:]",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] "
+            "along axis of size s. It is an error if any of the index values are out of bounds.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of rank q + r - indices_shape[-1] - 1.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          if (!hasNInputShapes(ctx, 2)) {
+            // cannot proceed with shape or rank inference
+            return;
+          }
+
+          const auto& data_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto data_rank = data_shape.dim_size();
+
+          const auto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
+          const auto indices_rank = indices_shape.dim_size();
+
+          int64_t batch_dims_data = getAttribute(ctx, "batch_dims", 0);
+          if (data_rank < 1 || indices_rank < 1) {
+            fail_shape_inference(
+                "Both `data` and `indices` input tensors in GatherND op "
+                "need to have rank larger than 0.");
+          }
+
+          // cannot ascertain if the input shapes are valid if shape of
+          // `indices` is missing last dimension value so return at this point
+          if (!indices_shape.dim(indices_rank - 1).has_dim_value()) {
+            return;
+          }
+
+          const auto last_index_dimension = indices_shape.dim(indices_rank - 1).dim_value() + batch_dims_data;
+
+          if (last_index_dimension > data_rank) {
+            fail_shape_inference(
+                "Last dimension of `indices` input tensor in GatherND op "
+                "must not be larger than the rank of `data` tensor");
+          }
+
+          for (int i = 0; i < indices_rank - 1; ++i) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = indices_shape.dim(i);
+          }
+
+          for (int i = static_cast<int>(last_index_dimension); i < data_rank; ++i) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = data_shape.dim(i);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    25,
+    OpSchema().FillUsing(PadDocGenerator(
+        kDoc_Pad_ver24,
+        "Supported modes: `constant`(default), `reflect`, `edge`, `wrap`",
+        OpSchema::all_tensor_types_ir13(),
+        "Constrain input and output types to all tensor types up to IRv13.")));
+
+static constexpr const char* Trilu_ver14_doc = R"DOC(
+Given a 2-D matrix or batches of 2-D matrices, returns the upper or lower triangular part of the tensor(s).
+The attribute "upper" determines whether the upper or lower part is retained. If set to true,
+the upper triangular matrix is retained. Lower triangular matrix is retained otherwise.
+Default value for the "upper" attribute is true.
+Trilu takes one input tensor of shape [*, N, M], where * is zero or more batch dimensions. The upper triangular part consists
+of the elements on and above the given diagonal (k). The lower triangular part consists of elements on and below the diagonal.
+All other elements in the matrix are set to zero.
+If k = 0, the triangular part on and above/below the main diagonal is retained.
+If upper is set to true, a positive k retains the upper triangular matrix excluding the main diagonal and (k-1) diagonals above it.
+A negative k value retains the main diagonal and |k| diagonals below it.
+If upper is set to false, a positive k retains the lower triangular matrix including the main diagonal and k diagonals above it.
+A negative k value excludes the main diagonal and (|k|-1) diagonals below it.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Trilu,
+    14,
+    OpSchema()
+        .SetDoc(Trilu_ver14_doc)
+        .Attr(
+            "upper",
+            "Boolean. Indicates whether upper or lower part of matrix is retained. Default is true.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Input(
+            0,
+            "input",
+            "Input tensor of rank 2 or higher.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "k",
+            "A 0-D tensor containing a single value corresponding to the number diagonals above or below the main diagonal to exclude or include. "
+            "Default value is 0 if it's not specified.",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor of the same type and shape as the input tensor.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // Shape inference needs the input data shape
+          if (hasInputShape(ctx, 0)) {
+            const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            const int rank = static_cast<int>(input_shape.dim_size());
+            if (rank < 2) {
+              fail_shape_inference("Input rank must be >= 2.")
+            }
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* CenterCropPad_ver18_doc = R"DOC(
+Center crop or pad an input to given dimensions.
+
+The crop/pad dimensions can be specified for a subset of the `axes`; unspecified dimensions will remain unchanged.
+
+If the input dimensions are larger than the target crop dimensions, a centered cropping window will be extracted
+from the input. The starting value for the cropping window is rounded down, which means that if the difference
+between the input shape and the crop shape is odd, the cropping window will be shifted half a pixel to the left
+of the input center.
+
+If the input dimensions are smaller than the target crop dimensions, the input will be padded equally on both sides
+to center it in the output. In cases where the total number of padding pixels is odd, an additional pixel will be
+added to the right side.
+
+The padding value used is zero.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CenterCropPad,
+    18,
+    OpSchema()
+        .SetDoc(CenterCropPad_ver18_doc)
+        .Input(
+            0,
+            "input_data",
+            "Input to extract the centered crop from.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "shape",
+            "1-D tensor representing the cropping window dimensions.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "output_data", "Output data.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Attr(
+            "axes",
+            "If provided, it specifies a subset of axes that 'shape' refer to. "
+            "If not provided, all axes are assumed [0, 1, ..., r-1], where r = rank(data). "
+            "Negative value means counting dimensions from the back. Accepted range is [-r, r-1], where r = rank(data). "
+            "Behavior is undefined if an axis is repeated.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (ctx.getNumInputs() != 2) {
+            fail_type_inference("CenterCropPad op must have 2 inputs.");
+          }
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          // Shape Inference if shape is initializer
+          const TensorProto* cropShapeInitializer = ctx.getInputData(1);
+          if (!cropShapeInitializer) {
+            return;
+          }
+
+          // don't know data_type - can't proceed
+          if (!cropShapeInitializer->has_data_type())
+            return;
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const int64_t input_rank = input_shape.dim_size();
+
+          std::vector<int64_t> shape;
+          if (cropShapeInitializer->data_type() == TensorProto::INT64) {
+            const auto data = ParseData<int64_t>(cropShapeInitializer);
+            shape.insert(shape.end(), data.begin(), data.end());
+          } else if (cropShapeInitializer->data_type() == TensorProto::INT32) {
+            const auto data = ParseData<int32_t>(cropShapeInitializer);
+            shape.insert(shape.end(), data.begin(), data.end());
+          } else {
+            // unaccepted data type
+            fail_shape_inference("`shape` only supports `int32_t` or `int64_t` inputs");
+          }
+
+          auto axes_attr = ctx.getAttribute("axes");
+          std::vector<int64_t> axes;
+          if (axes_attr) {
+            axes = RetrieveValues<int64_t>(*axes_attr);
+            checkAxesRange(axes, input_rank);
+            adjustNegativeAxes(axes, input_rank);
+            checkDuplicateAxes(axes, input_rank);
+          } else {
+            axes.resize(input_rank);
+            std::iota(axes.begin(), axes.end(), 0);
+          }
+
+          if (shape.size() != axes.size()) {
+            fail_shape_inference(
+                "Number of elements of input 'shape' (",
+                shape.size(),
+                ") does not match the number of axes (",
+                axes.size(),
+                ").");
+          }
+
+          // Populating default dims
+          std::vector<TensorShapeProto_Dimension*> out_dims(input_rank);
+          auto output_shape = getOutputShape(ctx, 0);
+          for (int i = 0; i < input_rank; ++i) {
+            out_dims[i] = output_shape->add_dim();
+            const auto& input_dim = input_shape.dim(i);
+            if (input_dim.has_dim_value()) {
+              out_dims[i]->set_dim_value(input_dim.dim_value());
+            } else if (input_dim.has_dim_param()) {
+              out_dims[i]->set_dim_param(input_dim.dim_param());
+            }
+          }
+          int j = 0;
+          for (int axis : axes) {
+            out_dims[axis]->set_dim_value(shape[j++]);
+          }
+        })
+        .SetContextDependentFunctionBodyBuilder([](const FunctionBodyBuildContext& ctx,
+                                                   const OpSchema& schema,
+                                                   FunctionProto& functionProto) {
+          FunctionBuilder builder(functionProto);
+          builder.Const("k2", std::vector<int64_t>{2});
+
+          auto axes_attr = ctx.getAttribute("axes");
+          if (axes_attr) { // axes provided, need to work on a subset of dimensions
+            builder.Add("axes_input = Constant <value_ints : ints = @axes>()");
+            builder.Add("x_shape_alldims = Shape (input_data)").Add("x_shape = Gather (x_shape_alldims, axes_input)");
+          } else { // axes not provided, assuming all dims
+            builder.Add("x_shape = Shape (input_data)");
+          }
+
+          // First: Pad step
+          builder.Add("padded_sh = Max(x_shape, shape)")
+              .Add("pad_amount = Sub(padded_sh, x_shape)")
+              .Add("pad_amount_left = Div(pad_amount, k2)")
+              .Add("pad_amount_right = Sub(pad_amount, pad_amount_left)")
+              .Add("pads = Concat <axis = 0> (pad_amount_left, pad_amount_right)");
+          if (axes_attr)
+            builder.Add("padded_input = Pad (input_data, pads, , axes_input)");
+          else
+            builder.Add("padded_input = Pad (input_data, pads)");
+
+          // Second: Slice step
+          if (axes_attr) {
+            builder.Add("x_shape_alldims2 = Shape (padded_input)")
+                .Add("x_shape2 = Gather (x_shape_alldims2, axes_input)");
+          } else {
+            builder.Add("x_shape2 = Shape (padded_input)");
+          }
+
+          builder.Add("sh_diff = Sub (x_shape2, shape)")
+              .Add("start_dims = Div (sh_diff, k2)")
+              .Add("end_dims = Add (start_dims, shape)");
+          if (axes_attr)
+            builder.Add("output_data = Slice (padded_input, start_dims, end_dims, axes_input)");
+          else
+            builder.Add("output_data = Slice (padded_input, start_dims, end_dims)");
+
+          schema.BuildFunction(functionProto);
+          return true;
+        }));
+
+static constexpr const char* TensorScatter_ver24_doc = R"DOC(
+TensorScatter is a generic tensor update operation, motivated by the requirements for KV cache updates for Attention
+ops commonly found in LLMs. It is a functional operation that models an in-place update to a KV cache buffer.
+
+The past and present cache tensors have the same shape (batch_size, D1, D2, ..., max_sequence_length, ..., Dn), with
+the sequence dimension (indicated by the `axis` attribute) being max_sequence_length, so the sizes of these tensors do
+not need to grow between iterations. The `update` tensor's shape only differs from the cache tensors in the sequence
+dimension: (batch_size, D1, D2, ..., sequence_length, ..., Dn), where sequence_length <= max_sequence_length.
+
+The optional `write_indices` input indicates the write index for each sample in the batch, assumed to be zero
+if not provided. When the `mode` attribute is set to "circular", the write index is modulo max_sequence_length.
+The operation can be described using the following pseudocode:
+
+```
+for prefix_idx in np.ndindex(past_cache.shape[:axis]):
+    batch_idx = prefix_idx[0]
+    for sequence_idx in range(sequence_length):
+        cache_idx = (*prefix_idx, write_indices[batch_idx] + sequence_idx)
+        if mode == "circular":
+            cache_idx = tuple(np.mod(np.asarray(cache_idx), max_sequence_length))
+        update_idx = (*prefix_idx, sequence_idx)
+        present_cache[cache_idx] = update[update_idx]
+```
+
+During the prefill phase of attention, only the first two inputs are needed. During the decode phase, `write_indices`
+is also needed so that the incoming key or value update can be appended after the last valid token for each sample
+in the batch.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    TensorScatter,
+    24,
+    OpSchema()
+        .SetDoc(TensorScatter_ver24_doc)
+        .Attr(
+            "axis",
+            "Sequence dimension of the `past_cache` and `update` tensors. It cannot be 0 (the batch dimension). Default is -2.",
+            AttributeProto::INT,
+            static_cast<int64_t>(-2))
+        .Attr(
+            "mode",
+            "Write mode of cache update. Supported modes include `linear` and `circular`. `linear` mode requires "
+            "write_indices+sequence_length<=max_sequence_length. For `circular` mode, the updates happen in "
+            "wrap-around fashion, ie, the update index is modulo `max_sequence_length`",
+            AttributeProto::STRING,
+            std::string("linear"))
+        .Input(
+            0,
+            "past_cache",
+            "Past state cache for key or value with shape `(batch_size, D1, D2, ..., max_sequence_length, ..., Dn)`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "update",
+            "New update tensor with shape `(batch_size, D1, D2, ..., sequence_length, ..., Dn)`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "write_indices",
+            "Write indices for the incoming update tensor in the cache. Shape is `(batch_size,)`. Assumed to be all zeros if not provided.",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "present_cache",
+            "Updated cache. Same shape as `past_cache`.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir12(), "Constrain input and output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Check that updates and past_cache have the same rank
+          if (hasInputShape(ctx, 0) && hasInputShape(ctx, 1)) {
+            const auto& past_cache_shape = getInputShape(ctx, 0);
+            const auto& update_shape = getInputShape(ctx, 1);
+            const int past_cache_rank = static_cast<int>(past_cache_shape.dim_size());
+            const int update_rank = static_cast<int>(update_shape.dim_size());
+
+            if (past_cache_rank != update_rank) {
+              fail_shape_inference(
+                  "past_cache and update must have the same rank. past_cache_rank=",
+                  past_cache_rank,
+                  ", update_rank=",
+                  update_rank);
+            }
+
+            // Check that all dimensions match except the axis dimension
+            // Read axis from attribute, default is -2
+            auto axis_attr = ctx.getAttribute("axis");
+            int64_t axis = axis_attr ? axis_attr->i() : -2;
+
+            // Handle negative axis
+            if (axis < 0) {
+              axis += past_cache_rank;
+            }
+
+            // Validate axis is within bounds
+            if (axis <= 0 || axis >= past_cache_rank) {
+              fail_shape_inference("axis ", axis, " is out of range for rank ", past_cache_rank);
+            }
+            for (int i = 0; i < past_cache_rank; ++i) {
+              if (i != axis) {
+                // All dimensions except axis should match
+                Dim dim;
+                unifyInputDim(ctx, 0, i, dim);
+                unifyInputDim(ctx, 1, i, dim);
+              }
+            }
+          }
+
+          // Check that write_indices is of shape (batch_size,)
+          if (hasInputShape(ctx, 2)) {
+            checkInputRank(ctx, 2, 1);
+            Dim batch_size;
+            unifyInputDim(ctx, 0, 0, batch_size);
+            unifyInputDim(ctx, 2, 0, batch_size);
+          }
+
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/tensor/old.cc b/onnx/defs/tensor/old.cc
new file mode 100644
index 0000000..a69560f
--- /dev/null
+++ b/onnx/defs/tensor/old.cc
@@ -0,0 +1,7803 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <cmath>
+#include <numeric>
+#include <optional>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "onnx/common/safe_math.h"
+#include "onnx/defs/data_propagators.h"
+#include "onnx/defs/doc_strings.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/tensor/utils.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static void checked_mul_into(int64_t& accumulator, int64_t value) {
+  if (checked_mul_overflow(accumulator, value, &accumulator)) {
+    fail_shape_inference("Dimension product overflow in Reshape");
+  }
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GridSample,
+    20,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Three interpolation modes: linear (default), nearest and cubic. "
+            "The \"linear\" mode includes linear and N-linear interpolation modes depending on the number of spatial dimensions "
+            "of the input tensor (i.e. linear for 1 spatial dimension, bilinear for 2 spatial dimensions, etc.). "
+            "The \"cubic\" mode also includes N-cubic interpolation modes following the same rules. The \"nearest\" mode rounds "
+            "to the nearest even index when the sampling point falls halfway between two indices.",
+            AttributeProto::STRING,
+            std::string("linear"))
+        .Attr(
+            "padding_mode",
+            "Support padding modes for outside grid values: `zeros`(default), `border`, `reflection`. "
+            "zeros: use 0 for out-of-bound grid locations, "
+            "border: use border values for out-of-bound grid locations, "
+            "reflection: use values at locations reflected by the border for out-of-bound grid locations. "
+            "If index 0 represents the margin pixel, the reflected value at index -1 will be the same as the value at index 1. "
+            "For location far away from the border, it will keep being reflected until becoming in bound. "
+            "If pixel location x = -3.5 reflects by border -1 and becomes x' = 1.5, then reflects by border 1 and becomes x'' = 0.5.",
+            AttributeProto::STRING,
+            std::string("zeros"))
+        .Attr(
+            "align_corners",
+            "If align_corners=1, the extrema (-1 and 1) are considered as referring to the center points of the input's corner pixels (voxels, etc.). "
+            "If align_corners=0, they are instead considered as referring to the corner points of the input's corner pixels (voxels, etc.), "
+            "making the sampling more resolution agnostic.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "X",
+            "Input tensor of rank r+2 that has shape (N, C, D1, D2, ..., Dr), where N is the batch size, "
+            "C is the number of channels, D1, D2, ..., Dr are the spatial dimensions.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "grid",
+            "Input offset of shape (N, D1_out, D2_out, ..., Dr_out, r), where D1_out, D2_out, ..., "
+            "Dr_out are the spatial dimensions of the grid and output, and r is the number of spatial dimensions. "
+            "Grid specifies the sampling locations normalized by the input spatial dimensions. "
+            "Therefore, it should have most values in the range of [-1, 1]. If the grid has values outside the range of [-1, 1], "
+            "the corresponding outputs will be handled as defined by padding_mode. Following computer vision convention, "
+            "the coordinates in the length-r location vector are listed from the innermost tensor dimension to the outermost, "
+            "the opposite of regular tensor indexing.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "Y",
+            "Output tensor of rank r+2 that has shape (N, C, D1_out, D2_out, ..., Dr_out) of the sampled values. "
+            "For integer input types, intermediate values are computed as floating point and cast to integer at the end.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types(),
+            "Constrain input `X` and output `Y` types to all tensor types.")
+        .TypeConstraint("T2", {types::Float16, types::Float, types::Double}, "Constrain grid types to float tensors.")
+        .SetDoc(kDoc_GridSample_ver20)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { gridSampleShapeInference(ctx); }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cast,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_Cast_ver24)
+        .Attr(
+            "to",
+            "The data type to which the elements of the input tensor are cast. "
+            "Strictly must be one of the types from DataType enum in TensorProto",
+            AttributeProto::INT)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. "
+            "All cases are fully described in the tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "round_mode",
+            "Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. "
+            "`up`: round to nearest value away from zero, "
+            "`down`: round to nearest value towards zero, "
+            "`nearest`: round to nearest value and ties round up.",
+            AttributeProto::STRING,
+            std::string("up"))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as input with type "
+            "specified by the 'to' argument",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_non_complex_tensor_types_ir12(),
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_complex_tensor_types_ir12(),
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "to", 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+static constexpr const char* Cast_ver23_doc = R"DOC(
+The operator casts the elements of a given input tensor to a data type
+specified by the 'to' argument and returns an output tensor of the same size in
+the converted type. The 'to' argument must be one of the data types specified
+in the 'DataType' enum field in the TensorProto message.
+
+Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+(e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+yield result 100. There are some string literals reserved for special floating-point values;
+"+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+to string tensors, plain floating-point representation (such as "314.15926") would be used.
+Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+Conversion from a numerical type to any numerical type is always allowed.
+User must be aware of precision loss and value change caused by range difference between two types.
+For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+In more detail, the conversion among numerical types should follow these rules
+if the destination type is not a float 8 type.
+
+* Casting from floating point to:
+  * floating point: +/- infinity if OOR (out of range).
+  * fixed point: undefined if OOR.
+  * bool: +/- 0.0 to False; all else to True.
+* Casting from fixed point to:
+  * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+  * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+    signed types). For example, 200 (int16) -> -56 (int8).
+  * bool: zero to False; nonzero to True.
+* Casting from bool to:
+  * floating point: `{1.0, 0.0}`.
+  * fixed point: `{1, 0}`.
+  * bool: no change.
+
+Float 8 type were introduced to speed up the training of
+deep models. By default the conversion of a float *x* obeys
+to the following rules. `[x]` means the value rounded to
+the target mantissa width.
+
+| x                 | E4M3FN   | E4M3FNUZ | E5M2     | E5M2FNUZ |
+| ----------------- | -------- | -------- | -------- | -------- |
+| 0                 | 0        | 0        | 0        | 0        |
+| -0                | -0       | 0        | -0       | 0        |
+| NaN               | NaN      | NaN      | NaN      | NaN      |
+| Inf               | FLT_MAX  | NaN      | FLT_MAX  | NaN      |
+| -Inf              | -FLT_MAX | NaN      | -FLT_MAX | NaN      |
+| \[x\] > FLT_MAX   | FLT_MAX  | FLT_MAX  | FLT_MAX  | FLT_MAX  |
+| \[x\] \< -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX | -FLT_MAX |
+| else              | RNE      | RNE      | RNE      | RNE      |
+
+The behavior changes if the parameter 'saturate' is set to False.
+The rules then become:
+
+| x                 | E4M3FN | E4M3FNUZ | E5M2 | E5M2FNUZ |
+| ----------------- | ------ | -------- | ---- | -------- |
+| 0                 | 0      | 0        | 0    | 0        |
+| -0                | -0     | 0        | -0   | 0        |
+| NaN               | NaN    | NaN      | NaN  | NaN      |
+| -NaN              | -NaN   | NaN      | -NaN | NaN      |
+| Inf               | NaN    | NaN      | Inf  | NaN      |
+| -Inf              | -NaN   | NaN      | -Inf | NaN      |
+| \[x\] > FLT_MAX   | NaN    | NaN      | Inf  | NaN      |
+| \[x\] \< -FLT_MAX | NaN    | NaN      | -Inf | NaN      |
+| else              | RNE    | RNE      | RNE  | RNE      |
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cast,
+    23,
+    OpSchema()
+        .SetDoc(Cast_ver23_doc)
+        .Attr(
+            "to",
+            "The data type to which the elements of the input tensor are cast. "
+            "Strictly must be one of the types from DataType enum in TensorProto",
+            AttributeProto::INT)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "All cases are fully described in two tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as input with type "
+            "specified by the 'to' argument",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_non_complex_tensor_types_ir11(),
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_complex_tensor_types_ir11(),
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "to", 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+static const char* const Cast_ver19_doc = Cast_ver23_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cast,
+    21,
+    OpSchema()
+        .SetDoc(Cast_ver19_doc)
+        .Attr(
+            "to",
+            "The data type to which the elements of the input tensor are cast. "
+            "Strictly must be one of the types from DataType enum in TensorProto",
+            AttributeProto::INT)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "All cases are fully described in two tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as input with type "
+            "specified by the 'to' argument",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            {types::Float16,        types::Float,      types::Double,         types::Int8,     types::Int16,
+             types::Int32,          types::Int64,      types::UInt8,          types::UInt16,   types::UInt32,
+             types::UInt64,         types::Bool,       types::String,         types::BFloat16, types::Float8E4M3FN,
+             types::Float8E4M3FNUZ, types::Float8E5M2, types::Float8E5M2FNUZ, types::UInt4,    types::Int4},
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,        types::Float,      types::Double,         types::Int8,     types::Int16,
+             types::Int32,          types::Int64,      types::UInt8,          types::UInt16,   types::UInt32,
+             types::UInt64,         types::Bool,       types::String,         types::BFloat16, types::Float8E4M3FN,
+             types::Float8E4M3FNUZ, types::Float8E5M2, types::Float8E5M2FNUZ, types::UInt4,    types::Int4},
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "to", 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cast,
+    19,
+    OpSchema()
+        .SetDoc(Cast_ver19_doc)
+        .Attr(
+            "to",
+            "The data type to which the elements of the input tensor are cast. "
+            "Strictly must be one of the types from DataType enum in TensorProto",
+            AttributeProto::INT)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "All cases are fully described in two tables inserted in the operator description.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as input with type "
+            "specified by the 'to' argument",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String,
+             types::BFloat16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String,
+             types::BFloat16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "to", 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+static constexpr const char* Cast_ver13_doc = R"DOC(
+The operator casts the elements of a given input tensor to a data type
+specified by the 'to' argument and returns an output tensor of the same size in
+the converted type. The 'to' argument must be one of the data types specified
+in the 'DataType' enum field in the TensorProto message.
+
+Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+(e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+yield result 100. There are some string literals reserved for special floating-point values;
+"+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+to string tensors, plain floating-point representation (such as "314.15926") would be used.
+Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+Conversion from a numerical type to any numerical type is always allowed.
+User must be aware of precision loss and value change caused by range difference between two types.
+For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+
+In more detail, the conversion among numerical types should follow these rules:
+
+* Casting from floating point to:
+  * floating point: +/- infinity if OOR (out of range).
+  * fixed point: undefined if OOR.
+  * bool: +/- 0.0 to False; all else to True.
+* Casting from fixed point to:
+  * floating point: +/- infinity if OOR. (+ infinity in the case of uint)
+  * fixed point: when OOR, discard higher bits and reinterpret (with respect to two's complement representation for
+    signed types). For example, 200 (int16) -> -56 (int8).
+  * bool: zero to False; nonzero to True.
+* Casting from bool to:
+  * floating point: `{1.0, 0.0}`.
+  * fixed point: `{1, 0}`.
+  * bool: no change.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cast,
+    13,
+    OpSchema()
+        .SetDoc(Cast_ver13_doc)
+        .Attr(
+            "to",
+            "The data type to which the elements of the input tensor are cast. "
+            "Strictly must be one of the types from DataType enum in TensorProto",
+            AttributeProto::INT)
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as input with type "
+            "specified by the 'to' argument",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String,
+             types::BFloat16},
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String,
+             types::BFloat16},
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "to", 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CastLike,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_CastLike_ver24)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz, float8e8m0). It is true by default. "
+            "Please refer to operator Cast description for further details.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "round_mode",
+            "Rounding mode for conversion to float8e8m0. It only applies to casting to float8e8m0 and is `up` by default. "
+            "`up`: round to nearest value away from zero, "
+            "`down`: round to nearest value towards zero, "
+            "`nearest`: round to nearest value and ties round up. "
+            "Please refer to operator Cast description for further details.",
+            AttributeProto::STRING,
+            std::string("up"))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "target_type",
+            "The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor produced by casting the first input tensor to have the same type as the second input tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_non_complex_tensor_types_ir12(),
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_complex_tensor_types_ir12(),
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              auto target_type = ctx.getInputType(1);
+              if ((target_type == nullptr) || (!target_type->has_tensor_type())) {
+                // we cannot create a correct function body without knowing the target element type
+                return false;
+              }
+              auto target_elt_type = target_type->tensor_type().elem_type();
+              FunctionBuilder builder(functionProto);
+              builder.Add(MakeString(
+                              "output = Cast <to= ",
+                              static_cast<int64_t>(target_elt_type),
+                              ", saturate: int = @saturate> (input)")
+                              .c_str());
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CastLike,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_CastLike_ver24)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "Please refer to operator Cast description for further details.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "target_type",
+            "The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor produced by casting the first input tensor to have the same type as the second input tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_non_complex_tensor_types_ir11(),
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_complex_tensor_types_ir11(),
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              auto target_type = ctx.getInputType(1);
+              if ((target_type == nullptr) || (!target_type->has_tensor_type())) {
+                // we cannot create a correct function body without knowing the target element type
+                return false;
+              }
+              auto target_elt_type = target_type->tensor_type().elem_type();
+              FunctionBuilder builder(functionProto);
+              builder.Add(MakeString(
+                              "output = Cast <to= ",
+                              static_cast<int64_t>(target_elt_type),
+                              ", saturate: int = @saturate> (input)")
+                              .c_str());
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CastLike,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_CastLike_ver24)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "Please refer to operator Cast description for further details.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "target_type",
+            "The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor produced by casting the first input tensor to have the same type as the second input tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_non_complex_tensor_types_ir10(),
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            OpSchema::all_non_complex_tensor_types_ir10(),
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              auto target_type = ctx.getInputType(1);
+              if ((target_type == nullptr) || (!target_type->has_tensor_type())) {
+                // we cannot create a correct function body without knowing the target element type
+                return false;
+              }
+              auto target_elt_type = target_type->tensor_type().elem_type();
+              FunctionBuilder builder(functionProto);
+              builder.Add(MakeString(
+                              "output = Cast <to= ",
+                              static_cast<int64_t>(target_elt_type),
+                              ", saturate: int = @saturate> (input)")
+                              .c_str());
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CastLike,
+    19,
+    OpSchema()
+        .SetDoc(kDoc_CastLike_ver24)
+        .Attr(
+            "saturate",
+            "The parameter defines how the conversion behaves if an input value is out of "
+            "range of the destination type. It only applies for float 8 conversion "
+            "(float8e4m3fn, float8e4m3fnuz, float8e5m2, float8e5m2fnuz). It is true by default. "
+            "Please refer to operator Cast description for further details.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "target_type",
+            "The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor produced by casting the first input tensor to have the same type as the second input tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String,
+             types::BFloat16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String,
+             types::BFloat16,
+             types::Float8E4M3FN,
+             types::Float8E4M3FNUZ,
+             types::Float8E5M2,
+             types::Float8E5M2FNUZ},
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              auto target_type = ctx.getInputType(1);
+              if ((target_type == nullptr) || (!target_type->has_tensor_type())) {
+                // we cannot create a correct function body without knowing the target element type
+                return false;
+              }
+              auto target_elt_type = target_type->tensor_type().elem_type();
+              FunctionBuilder builder(functionProto);
+              builder.Add(MakeString(
+                              "output = Cast <to= ",
+                              static_cast<int64_t>(target_elt_type),
+                              ", saturate: int = @saturate> (input)")
+                              .c_str());
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    CastLike,
+    15,
+    OpSchema()
+        .SetDoc(kDoc_CastLike_ver24)
+        .Input(0, "input", "Input tensor to be cast.", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "target_type",
+            "The (first) input tensor will be cast to produce a tensor of the same type as this (second input) tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "output",
+            "Output tensor produced by casting the first input tensor to have the same type as the second input tensor.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String,
+             types::BFloat16},
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String,
+             types::BFloat16},
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        })
+        .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+        .SetContextDependentFunctionBodyBuilder(
+            [](const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) -> bool {
+              auto target_type = ctx.getInputType(1);
+              if ((target_type == nullptr) || (!target_type->has_tensor_type())) {
+                // we cannot create a correct function body without knowing the target element type
+                return false;
+              }
+              auto target_elt_type = target_type->tensor_type().elem_type();
+              FunctionBuilder builder(functionProto);
+              builder.Add("output = Cast (input)", "to", static_cast<int64_t>(target_elt_type));
+              schema.BuildFunction(functionProto);
+              return true;
+            }));
+
+static constexpr const char* Cast_ver9_doc = R"DOC(
+The operator casts the elements of a given input tensor to a data type
+specified by the 'to' argument and returns an output tensor of the same size in
+the converted type. The 'to' argument must be one of the data types specified
+in the 'DataType' enum field in the TensorProto message.
+
+Casting from string tensor in plain (e.g., "3.14" and "1000") and scientific numeric representations
+(e.g., "1e-5" and "1E8") to float types is supported. For example, converting string "100.5" to an integer may
+yield result 100. There are some string literals reserved for special floating-point values;
+"+INF" (and "INF"), "-INF", and "NaN" are positive infinity, negative infinity, and not-a-number, respectively.
+Any string which can exactly match "+INF" in a case-insensitive way would be mapped to positive infinite. Similarly,
+this case-insensitive rule is applied to "INF" and "NaN". When casting from numeric tensors
+to string tensors, plain floating-point representation (such as "314.15926") would be used.
+Converting non-numerical-literal string such as "Hello World!" is an undefined behavior. Cases
+of converting string representing floating-point arithmetic value, such as "2.718", to INT is an undefined behavior.
+
+Conversion from a numerical type to any numerical type is always allowed.
+User must be aware of precision loss and value change caused by range difference between two types.
+For example, a 64-bit float 3.1415926459 may be round to a 32-bit float 3.141592. Similarly, converting
+an integer 36 to Boolean may produce 1 because we truncate bits which can't be stored in the targeted type.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cast,
+    9,
+    OpSchema()
+        .SetDoc(Cast_ver9_doc)
+        .Attr(
+            "to",
+            "The data type to which the elements of the input tensor are cast. "
+            "Strictly must be one of the types from DataType enum in TensorProto",
+            AttributeProto::INT)
+        .Input(0, "input", "Input tensor to be cast.", "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as input with type "
+            "specified by the 'to' argument",
+            "T2")
+        .TypeConstraint(
+            "T1",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String},
+            "Constrain input types. Casting from complex is not supported.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool,
+             types::String},
+            "Constrain output types. Casting to complex is not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "to", 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* GridSample_ver16_doc = R"DOC(
+Given an input `X` and a flow-field `grid`, computes the output `Y` using `X` values and pixel locations from `grid`.
+Currently, only spatial (4-D) inputs are supported. For input `X` with shape (N, C, H, W) and `grid` with shape (N, H_out, W_out, 2),
+the output `Y` will have shape (N, C, H_out, W_out).
+
+The tensor `X` contains values at centers of square pixels in a H by W 2-dimensional image.
+The tensor `grid` describes normalized positions where the output `Y` is to be computed
+using a specified interpolation method (the mode) and a padding mode (for grid positions falling outside the 2-dimensional image).
+
+Elements in `grid[N, H_out, W_out]` are size-2 vectors specifying positions in the 2-dimensional space of `X`.
+They are used to interpolate output values of `Y[N, C, H_out, W_out]`.
+
+The GridSample operator is often used in doing grid generator and sampler in the [Spatial Transformer Networks](https://arxiv.org/abs/1506.02025).
+See also in [torch.nn.functional.grid_sample](https://pytorch.org/docs/master/generated/torch.nn.functional.grid_sample.html#torch-nn-functional-grid-sample).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GridSample,
+    16,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Three interpolation modes: bilinear (default), nearest and bicubic.",
+            AttributeProto::STRING,
+            std::string("bilinear"))
+        .Attr(
+            "padding_mode",
+            "Support padding modes for outside grid values: `zeros`(default), `border`, `reflection`. "
+            "zeros: use 0 for out-of-bound grid locations, "
+            "border: use border values for out-of-bound grid locations, "
+            "reflection: use values at locations reflected by the border for out-of-bound grid locations. "
+            "If index 0 represents the margin pixel, the reflected value at index -1 will be the same as the value at index 1. "
+            "For location far away from the border, it will keep being reflected until becoming in bound. "
+            "If pixel location x = -3.5 reflects by border -1 and becomes x' = 1.5, then reflects by border 1 and becomes x'' = 0.5.",
+            AttributeProto::STRING,
+            std::string("zeros"))
+        .Attr(
+            "align_corners",
+            "If align_corners=1, the extrema (-1 and 1) are considered as referring to the center points of the input's corner pixels. "
+            "If align_corners=0, they are instead considered as referring to the corner points of the input's corner pixels, making the sampling more resolution agnostic.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(
+            0,
+            "X",
+            "4-D tensor of shape (N, C, H, W), "
+            "where N is the batch size, C is the numbers of channels, "
+            "H and W are the height and width of the input data.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "grid",
+            "Input offset, 4-D tensor of shape (N, H_out, W_out, 2), "
+            "where H_out and W_out are the height and width of grid and output, "
+            "Grid specifies the sampling pixel locations normalized by the input spatial dimensions. "
+            "Therefore, it should have most values in the range of [-1, 1]. "
+            "If grid has values outside the range of [-1, 1], the corresponding outputs will be handled as defined by padding_mode.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "Y",
+            "4-D tensor of shape (N, C, H_out, W_out) of sampled values. "
+            "For integer input types, intermediate values are computed as floating point and cast to integer at the end.",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types(),
+            "Constrain input `X` and output `Y` types to all tensor types.")
+        .TypeConstraint("T2", {types::Float16, types::Float, types::Double}, "Constrain grid types to float tensors.")
+        .SetDoc(GridSample_ver16_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { gridSampleShapeInference(ctx); }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reshape,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_Reshape_ver24)
+        .Attr(
+            "allowzero",
+            "(Optional) By default, when any value in the 'shape' input is equal to zero "
+            "the corresponding dimension value is copied from the input tensor dynamically. "
+            "allowzero=1 indicates that if any value in the 'shape' input is set to zero, "
+            "the zero value is honored, similar to NumPy.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "shape",
+            "Specified shape for output.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "reshaped", "Reshaped data.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir12(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          bool found;
+          TensorShapeProto targetShapeProto = getShapeInput(ctx, 1, found);
+          if (!found) {
+            return;
+          }
+
+          int allowzero = static_cast<int>(getAttribute(ctx, "allowzero", 0));
+
+          // Iterate through targetShape, adding dimensions in the outputShape
+          // TensorProto. If the targetShape dimension is -1, we do not set the
+          // dimension value in this iteration, but we record the Dimension. If
+          // targetShape dimension is 0, we attempt to propagate the dimension
+          // value/param. If the value cannot be inferred, we set the flag in
+          // the unresolveZeros vector. If targetShape dimension is positive, we
+          // set the dimension value in the outputShape. We track the product of
+          // the dimensions we are setting outputShape in the outputProduct
+          // variable. The outputProduct will potentially be used for inferring
+          // a dimension marked -1.
+          auto outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          TensorShapeProto::Dimension* negativeOneDim = nullptr;
+          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
+          std::vector<bool> unresolvedZeros(targetShapeProto.dim_size(), false);
+          int64_t outputProduct = 1;
+          bool outputProductValid = true;
+          for (int i = 0; i < static_cast<int>(targetShapeProto.dim_size()); ++i) {
+            // Add a new dimension to outputShape
+            auto new_dim = outputShape->add_dim();
+            if (targetShapeProto.dim(i).has_dim_param()) {
+              // There is a tricky edge case here. It is possible that the value of
+              // symbolic dim can be -1 or 0 at runtime. In that case simply propagating this
+              // symbol can be erroneous. This should be a very rare scenario and in such a
+              // case an option is to turn off data propagation during shape inference.
+              new_dim->set_dim_param(targetShapeProto.dim(i).dim_param());
+              outputProductValid = false;
+            } else {
+              if (!targetShapeProto.dim(i).has_dim_value()) {
+                outputProductValid = false;
+                // treat this dim as unknown dim
+                continue;
+              }
+
+              const auto dim_value = targetShapeProto.dim(i).dim_value();
+
+              if (dim_value == -1) {
+                // Check if multiple -1's. If not, set negativeOneDim, marking
+                // this dimension to potentially be filled in later.
+                if (negativeOneDim) {
+                  fail_shape_inference("Target shape may not have multiple -1 dimensions.");
+                }
+                negativeOneDim = new_dim;
+              } else if (dim_value == 0) {
+                // Check if data input has a shape and if the index i is within
+                // its bounds. If these conditions are satisfied, any dimension
+                // value/param should be propagated. If dimension value cannot be
+                // inferred, set the corresponding  unresolvedZeros flag to true.
+                // If allowzero is set however, do not propagate values, since output
+                // dimension is explicitly zero.
+                if (allowzero == 0) {
+                  unresolvedZeros[i] = true;
+                  if (dataInputTensorType.has_shape()) {
+                    if (i >= dataInputTensorType.shape().dim_size()) {
+                      fail_shape_inference("Invalid position of 0.");
+                    }
+                    if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                      const auto& input_dim_value = dataInputTensorType.shape().dim(i).dim_value();
+                      new_dim->set_dim_value(input_dim_value);
+                      checked_mul_into(outputProduct, input_dim_value);
+                      unresolvedZeros[i] = false;
+                    } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
+                      new_dim->set_dim_param(dataInputTensorType.shape().dim(i).dim_param());
+                    }
+                  }
+                } else {
+                  new_dim->set_dim_value(dim_value);
+                  checked_mul_into(outputProduct, dim_value);
+                }
+              } else if (dim_value > 0) {
+                // Set the dimension value to dim_value
+                new_dim->set_dim_value(dim_value);
+                checked_mul_into(outputProduct, dim_value);
+              } else {
+                // Check if value is less than -1; fail if so
+                fail_shape_inference("Invalid dimension value: ", dim_value);
+              }
+            }
+          }
+          // If negativeOneDim has been set, we attempt to infer its value. This
+          // can be done if all dimension values for the data input tensor shape
+          // are known other than the ones corresponding to unresolvedZeros
+          // flags.
+          if (negativeOneDim && outputProductValid) {
+            // First, attempt to compute product of data input shape dimensions
+            // that are not marked by unresolvedZeros. If not possible, set the
+            // inputProductValid flag to false.
+            if (!outputProduct) {
+              fail_shape_inference("Invalid Target shape product of 0. Product cannot be 0 in combination with -1");
+            }
+            int64_t inputProduct = 1;
+            bool inputProductValid = true;
+            if (!dataInputTensorType.has_shape()) {
+              inputProductValid = false;
+            } else {
+              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  checked_mul_into(inputProduct, dataInputTensorType.shape().dim(i).dim_value());
+                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
+                  inputProductValid = false;
+                  break;
+                }
+              }
+            }
+            if (inputProductValid) {
+              if (inputProduct % outputProduct != 0) {
+                fail_shape_inference("Dimension could not be inferred: incompatible shapes");
+              }
+              negativeOneDim->set_dim_value(inputProduct / outputProduct);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reshape,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_Reshape_ver24)
+        .Attr(
+            "allowzero",
+            "(Optional) By default, when any value in the 'shape' input is equal to zero "
+            "the corresponding dimension value is copied from the input tensor dynamically. "
+            "allowzero=1 indicates that if any value in the 'shape' input is set to zero, "
+            "the zero value is honored, similar to NumPy.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "shape",
+            "Specified shape for output.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "reshaped", "Reshaped data.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir11(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          bool found;
+          TensorShapeProto targetShapeProto = getShapeInput(ctx, 1, found);
+          if (!found) {
+            return;
+          }
+
+          int allowzero = static_cast<int>(getAttribute(ctx, "allowzero", 0));
+
+          // Iterate through targetShape, adding dimensions in the outputShape
+          // TensorProto. If the targetShape dimension is -1, we do not set the
+          // dimension value in this iteration, but we record the Dimension. If
+          // targetShape dimension is 0, we attempt to propagate the dimension
+          // value/param. If the value cannot be inferred, we set the flag in
+          // the unresolveZeros vector. If targetShape dimension is positive, we
+          // set the dimension value in the outputShape. We track the product of
+          // the dimensions we are setting outputShape in the outputProduct
+          // variable. The outputProduct will potentially be used for inferring
+          // a dimension marked -1.
+          auto outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          TensorShapeProto::Dimension* negativeOneDim = nullptr;
+          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
+          std::vector<bool> unresolvedZeros(targetShapeProto.dim_size(), false);
+          int64_t outputProduct = 1;
+          bool outputProductValid = true;
+          for (int i = 0; i < static_cast<int>(targetShapeProto.dim_size()); ++i) {
+            // Add a new dimension to outputShape
+            auto new_dim = outputShape->add_dim();
+            if (targetShapeProto.dim(i).has_dim_param()) {
+              // There is a tricky edge case here. It is possible that the value of
+              // symbolic dim can be -1 or 0 at runtime. In that case simply propagating this
+              // symbol can be erroneous. This should be a very rare scenario and in such a
+              // case an option is to turn off data propagation during shape inference.
+              new_dim->set_dim_param(targetShapeProto.dim(i).dim_param());
+              outputProductValid = false;
+            } else {
+              if (!targetShapeProto.dim(i).has_dim_value()) {
+                outputProductValid = false;
+                // treat this dim as unknown dim
+                continue;
+              }
+
+              const auto dim_value = targetShapeProto.dim(i).dim_value();
+
+              if (dim_value == -1) {
+                // Check if multiple -1's. If not, set negativeOneDim, marking
+                // this dimension to potentially be filled in later.
+                if (negativeOneDim) {
+                  fail_shape_inference("Target shape may not have multiple -1 dimensions.");
+                }
+                negativeOneDim = new_dim;
+              } else if (dim_value == 0) {
+                // Check if data input has a shape and if the index i is within
+                // its bounds. If these conditions are satisfied, any dimension
+                // value/param should be propagated. If dimension value cannot be
+                // inferred, set the corresponding  unresolvedZeros flag to true.
+                // If allowzero is set however, do not propagate values, since output
+                // dimension is explicitly zero.
+                if (allowzero == 0) {
+                  unresolvedZeros[i] = true;
+                  if (dataInputTensorType.has_shape()) {
+                    if (i >= dataInputTensorType.shape().dim_size()) {
+                      fail_shape_inference("Invalid position of 0.");
+                    }
+                    if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                      const auto& input_dim_value = dataInputTensorType.shape().dim(i).dim_value();
+                      new_dim->set_dim_value(input_dim_value);
+                      checked_mul_into(outputProduct, input_dim_value);
+                      unresolvedZeros[i] = false;
+                    } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
+                      new_dim->set_dim_param(dataInputTensorType.shape().dim(i).dim_param());
+                    }
+                  }
+                } else {
+                  new_dim->set_dim_value(dim_value);
+                  checked_mul_into(outputProduct, dim_value);
+                }
+              } else if (dim_value > 0) {
+                // Set the dimension value to dim_value
+                new_dim->set_dim_value(dim_value);
+                checked_mul_into(outputProduct, dim_value);
+              } else {
+                // Check if value is less than -1; fail if so
+                fail_shape_inference("Invalid dimension value: ", dim_value);
+              }
+            }
+          }
+          // If negativeOneDim has been set, we attempt to infer its value. This
+          // can be done if all dimension values for the data input tensor shape
+          // are known other than the ones corresponding to unresolvedZeros
+          // flags.
+          if (negativeOneDim && outputProductValid) {
+            // First, attempt to compute product of data input shape dimensions
+            // that are not marked by unresolvedZeros. If not possible, set the
+            // inputProductValid flag to false.
+            if (!outputProduct) {
+              fail_shape_inference("Invalid Target shape product of 0. Product cannot be 0 in combination with -1");
+            }
+            int64_t inputProduct = 1;
+            bool inputProductValid = true;
+            if (!dataInputTensorType.has_shape()) {
+              inputProductValid = false;
+            } else {
+              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  checked_mul_into(inputProduct, dataInputTensorType.shape().dim(i).dim_value());
+                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
+                  inputProductValid = false;
+                  break;
+                }
+              }
+            }
+            if (inputProductValid) {
+              if (inputProduct % outputProduct != 0) {
+                fail_shape_inference("Dimension could not be inferred: incompatible shapes");
+              }
+              negativeOneDim->set_dim_value(inputProduct / outputProduct);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reshape,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_Reshape_ver24)
+        .Attr(
+            "allowzero",
+            "(Optional) By default, when any value in the 'shape' input is equal to zero "
+            "the corresponding dimension value is copied from the input tensor dynamically. "
+            "allowzero=1 indicates that if any value in the 'shape' input is set to zero, "
+            "the zero value is honored, similar to NumPy.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "shape",
+            "Specified shape for output.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "reshaped", "Reshaped data.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir10(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          bool found;
+          TensorShapeProto targetShapeProto = getShapeInput(ctx, 1, found);
+          if (!found) {
+            return;
+          }
+
+          int allowzero = static_cast<int>(getAttribute(ctx, "allowzero", 0));
+
+          // Iterate through targetShape, adding dimensions in the outputShape
+          // TensorProto. If the targetShape dimension is -1, we do not set the
+          // dimension value in this iteration, but we record the Dimension. If
+          // targetShape dimension is 0, we attempt to propagate the dimension
+          // value/param. If the value cannot be inferred, we set the flag in
+          // the unresolveZeros vector. If targetShape dimension is positive, we
+          // set the dimension value in the outputShape. We track the product of
+          // the dimensions we are setting outputShape in the outputProduct
+          // variable. The outputProduct will potentially be used for inferring
+          // a dimension marked -1.
+          auto outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          TensorShapeProto::Dimension* negativeOneDim = nullptr;
+          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
+          std::vector<bool> unresolvedZeros(targetShapeProto.dim_size(), false);
+          int64_t outputProduct = 1;
+          bool outputProductValid = true;
+          for (int i = 0; i < static_cast<int>(targetShapeProto.dim_size()); ++i) {
+            // Add a new dimension to outputShape
+            auto new_dim = outputShape->add_dim();
+            if (targetShapeProto.dim(i).has_dim_param()) {
+              // There is a tricky edge case here. It is possible that the value of
+              // symbolic dim can be -1 or 0 at runtime. In that case simply propagating this
+              // symbol can be erroneous. This should be a very rare scenario and in such a
+              // case an option is to turn off data propagation during shape inference.
+              new_dim->set_dim_param(targetShapeProto.dim(i).dim_param());
+              outputProductValid = false;
+            } else {
+              if (!targetShapeProto.dim(i).has_dim_value()) {
+                outputProductValid = false;
+                // treat this dim as unknown dim
+                continue;
+              }
+
+              const auto dim_value = targetShapeProto.dim(i).dim_value();
+
+              if (dim_value == -1) {
+                // Check if multiple -1's. If not, set negativeOneDim, marking
+                // this dimension to potentially be filled in later.
+                if (negativeOneDim) {
+                  fail_shape_inference("Target shape may not have multiple -1 dimensions.");
+                }
+                negativeOneDim = new_dim;
+              } else if (dim_value == 0) {
+                // Check if data input has a shape and if the index i is within
+                // its bounds. If these conditions are satisfied, any dimension
+                // value/param should be propagated. If dimension value cannot be
+                // inferred, set the corresponding  unresolvedZeros flag to true.
+                // If allowzero is set however, do not propagate values, since output
+                // dimension is explicitly zero.
+                if (allowzero == 0) {
+                  unresolvedZeros[i] = true;
+                  if (dataInputTensorType.has_shape()) {
+                    if (i >= dataInputTensorType.shape().dim_size()) {
+                      fail_shape_inference("Invalid position of 0.");
+                    }
+                    if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                      const auto& input_dim_value = dataInputTensorType.shape().dim(i).dim_value();
+                      new_dim->set_dim_value(input_dim_value);
+                      checked_mul_into(outputProduct, input_dim_value);
+                      unresolvedZeros[i] = false;
+                    } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
+                      new_dim->set_dim_param(dataInputTensorType.shape().dim(i).dim_param());
+                    }
+                  }
+                } else {
+                  new_dim->set_dim_value(dim_value);
+                  checked_mul_into(outputProduct, dim_value);
+                }
+              } else if (dim_value > 0) {
+                // Set the dimension value to dim_value
+                new_dim->set_dim_value(dim_value);
+                checked_mul_into(outputProduct, dim_value);
+              } else {
+                // Check if value is less than -1; fail if so
+                fail_shape_inference("Invalid dimension value: ", dim_value);
+              }
+            }
+          }
+          // If negativeOneDim has been set, we attempt to infer its value. This
+          // can be done if all dimension values for the data input tensor shape
+          // are known other than the ones corresponding to unresolvedZeros
+          // flags.
+          if (negativeOneDim && outputProductValid) {
+            // First, attempt to compute product of data input shape dimensions
+            // that are not marked by unresolvedZeros. If not possible, set the
+            // inputProductValid flag to false.
+            if (!outputProduct) {
+              fail_shape_inference("Invalid Target shape product of 0. Product cannot be 0 in combination with -1");
+            }
+            int64_t inputProduct = 1;
+            bool inputProductValid = true;
+            if (!dataInputTensorType.has_shape()) {
+              inputProductValid = false;
+            } else {
+              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  checked_mul_into(inputProduct, dataInputTensorType.shape().dim(i).dim_value());
+                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
+                  inputProductValid = false;
+                  break;
+                }
+              }
+            }
+            if (inputProductValid) {
+              if (inputProduct % outputProduct != 0) {
+                fail_shape_inference("Dimension could not be inferred: incompatible shapes");
+              }
+              negativeOneDim->set_dim_value(inputProduct / outputProduct);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reshape,
+    19,
+    OpSchema()
+        .SetDoc(kDoc_Reshape_ver24)
+        .Attr(
+            "allowzero",
+            "(Optional) By default, when any value in the 'shape' input is equal to zero "
+            "the corresponding dimension value is copied from the input tensor dynamically. "
+            "allowzero=1 indicates that if any value in the 'shape' input is set to zero, "
+            "the zero value is honored, similar to NumPy.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "shape",
+            "Specified shape for output.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "reshaped", "Reshaped data.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir9(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          bool found;
+          TensorShapeProto targetShapeProto = getShapeInput(ctx, 1, found);
+          if (!found) {
+            return;
+          }
+
+          int allowzero = static_cast<int>(getAttribute(ctx, "allowzero", 0));
+
+          // Iterate through targetShape, adding dimensions in the outputShape
+          // TensorProto. If the targetShape dimension is -1, we do not set the
+          // dimension value in this iteration, but we record the Dimension. If
+          // targetShape dimension is 0, we attempt to propagate the dimension
+          // value/param. If the value cannot be inferred, we set the flag in
+          // the unresolveZeros vector. If targetShape dimension is positive, we
+          // set the dimension value in the outputShape. We track the product of
+          // the dimensions we are setting outputShape in the outputProduct
+          // variable. The outputProduct will potentially be used for inferring
+          // a dimension marked -1.
+          auto outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          TensorShapeProto::Dimension* negativeOneDim = nullptr;
+          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
+          std::vector<bool> unresolvedZeros(targetShapeProto.dim_size(), false);
+          int64_t outputProduct = 1;
+          bool outputProductValid = true;
+          for (int i = 0; i < static_cast<int>(targetShapeProto.dim_size()); ++i) {
+            // Add a new dimension to outputShape
+            auto new_dim = outputShape->add_dim();
+            if (targetShapeProto.dim(i).has_dim_param()) {
+              // There is a tricky edge case here. It is possible that the value of
+              // symbolic dim can be -1 or 0 at runtime. In that case simply propagating this
+              // symbol can be erroneous. This should be a very rare scenario and in such a
+              // case an option is to turn off data propagation during shape inference.
+              new_dim->set_dim_param(targetShapeProto.dim(i).dim_param());
+              outputProductValid = false;
+            } else {
+              if (!targetShapeProto.dim(i).has_dim_value()) {
+                outputProductValid = false;
+                // treat this dim as unknown dim
+                continue;
+              }
+
+              const auto dim_value = targetShapeProto.dim(i).dim_value();
+
+              if (dim_value == -1) {
+                // Check if multiple -1's. If not, set negativeOneDim, marking
+                // this dimension to potentially be filled in later.
+                if (negativeOneDim) {
+                  fail_shape_inference("Target shape may not have multiple -1 dimensions.");
+                }
+                negativeOneDim = new_dim;
+              } else if (dim_value == 0) {
+                // Check if data input has a shape and if the index i is within
+                // its bounds. If these conditions are satisfied, any dimension
+                // value/param should be propagated. If dimension value cannot be
+                // inferred, set the corresponding  unresolvedZeros flag to true.
+                // If allowzero is set however, do not propagate values, since output
+                // dimension is explicitly zero.
+                if (allowzero == 0) {
+                  unresolvedZeros[i] = true;
+                  if (dataInputTensorType.has_shape()) {
+                    if (i >= dataInputTensorType.shape().dim_size()) {
+                      fail_shape_inference("Invalid position of 0.");
+                    }
+                    if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                      const auto& input_dim_value = dataInputTensorType.shape().dim(i).dim_value();
+                      new_dim->set_dim_value(input_dim_value);
+                      checked_mul_into(outputProduct, input_dim_value);
+                      unresolvedZeros[i] = false;
+                    } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
+                      new_dim->set_dim_param(dataInputTensorType.shape().dim(i).dim_param());
+                    }
+                  }
+                } else {
+                  new_dim->set_dim_value(dim_value);
+                  checked_mul_into(outputProduct, dim_value);
+                }
+              } else if (dim_value > 0) {
+                // Set the dimension value to dim_value
+                new_dim->set_dim_value(dim_value);
+                checked_mul_into(outputProduct, dim_value);
+              } else {
+                // Check if value is less than -1; fail if so
+                fail_shape_inference("Invalid dimension value: ", dim_value);
+              }
+            }
+          }
+          // If negativeOneDim has been set, we attempt to infer its value. This
+          // can be done if all dimension values for the data input tensor shape
+          // are known other than the ones corresponding to unresolvedZeros
+          // flags.
+          if (negativeOneDim && outputProductValid) {
+            // First, attempt to compute product of data input shape dimensions
+            // that are not marked by unresolvedZeros. If not possible, set the
+            // inputProductValid flag to false.
+            if (!outputProduct) {
+              fail_shape_inference("Invalid Target shape product of 0. Product cannot be 0 in combination with -1");
+            }
+            int64_t inputProduct = 1;
+            bool inputProductValid = true;
+            if (!dataInputTensorType.has_shape()) {
+              inputProductValid = false;
+            } else {
+              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  checked_mul_into(inputProduct, dataInputTensorType.shape().dim(i).dim_value());
+                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
+                  inputProductValid = false;
+                  break;
+                }
+              }
+            }
+            if (inputProductValid) {
+              if (inputProduct % outputProduct != 0) {
+                fail_shape_inference("Dimension could not be inferred: incompatible shapes");
+              }
+              negativeOneDim->set_dim_value(inputProduct / outputProduct);
+            }
+          }
+        }));
+
+static constexpr const char* Reshape_ver13_doc = R"DOC(
+Reshape the input tensor similar to numpy.reshape.
+First input is the data tensor, second input is a shape tensor which specifies the output shape. It outputs the reshaped tensor.
+At most one dimension of the new shape can be -1. In this case, the value is
+inferred from the size of the tensor and the remaining dimensions. A dimension
+could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+from the input tensor). Shape (second input) could be an empty shape, which means converting to a scalar.
+The input tensor's shape and the output tensor's shape are required to have the same number of elements.)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reshape,
+    13,
+    OpSchema()
+        .SetDoc(Reshape_ver13_doc)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "shape",
+            "Specified shape for output.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "reshaped", "Reshaped data.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // Shape Inference if 2nd input data (the target shape) is available
+          const TensorProto* targetShapeInitializer = ctx.getInputData(1);
+          if (!targetShapeInitializer) {
+            return;
+          }
+          // Make targetShape (0 -> same as originalShape, -1 -> inferred).
+          // The targetShape vector represents the specified shape for output.
+          std::vector<int64_t> targetShape = ParseData<int64_t>(targetShapeInitializer);
+          // Iterate through targetShape, adding dimensions in the outputShape
+          // TensorProto. If the targetShape dimension is -1, we do not set the
+          // dimension value in this iteration, but we record the Dimension. If
+          // targetShape dimension is 0, we attempt to propagate the dimension
+          // value/param. If the value cannot be inferred, we set the flag in
+          // the unresolveZeros vector. If targetShape dimension is positive, we
+          // set the dimension value in the outputShape. We track the product of
+          // the dimensions we are setting outputShape in the outputProduct
+          // variable. The outputProduct will potentially be used for inferring
+          // a dimension marked -1.
+          auto outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          TensorShapeProto::Dimension* negativeOneDim = nullptr;
+          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
+          std::vector<bool> unresolvedZeros(targetShape.size(), false);
+          int64_t outputProduct = 1;
+          for (size_t i = 0; i < targetShape.size(); ++i) {
+            // Add a new dimension to outputShape
+            auto new_dim = outputShape->add_dim();
+            if (targetShape[i] == -1) {
+              // Check if multiple -1's. If not, set negativeOneDim, marking
+              // this dimension to potentially be filled in later.
+              if (negativeOneDim) {
+                fail_shape_inference("Target shape may not have multiple -1 dimensions");
+              }
+              negativeOneDim = new_dim;
+            } else if (targetShape[i] == 0) {
+              // Check if data input has a shape and if the index i is within
+              // its bounds. If these conditions are satisfied, any dimension
+              // value/param should be propagated. If dimension value cannot be
+              // inferred, set the corresponding  unresolvedZeros flag to true.
+              unresolvedZeros[i] = true;
+              if (dataInputTensorType.has_shape()) {
+                if (i >= static_cast<size_t>(dataInputTensorType.shape().dim_size())) {
+                  fail_shape_inference("Invalid position of 0");
+                }
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  const auto& dim_value = dataInputTensorType.shape().dim(i).dim_value();
+                  new_dim->set_dim_value(dim_value);
+                  checked_mul_into(outputProduct, dim_value);
+                  unresolvedZeros[i] = false;
+                } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
+                  const auto& dim_param = dataInputTensorType.shape().dim(i).dim_param();
+                  new_dim->set_dim_param(dim_param);
+                }
+              }
+            } else if (targetShape[i] > 0) {
+              // Set the dimension value to targetShape[i]
+              new_dim->set_dim_value(targetShape[i]);
+              checked_mul_into(outputProduct, targetShape[i]);
+            } else {
+              // Check if value is less than -1; fail if so
+              fail_shape_inference("Invalid dimension value: ", targetShape[i]);
+            }
+          }
+
+          // If negativeOneDim has been set, we attempt to infer its value. This
+          // can be done if all dimension values for the data input tensor shape
+          // are known other than the ones corresponding to unresolvedZeros
+          // flags.
+          if (negativeOneDim) {
+            // First, attempt to compute product of data input shape dimensions
+            // that are not marked by unresolvedZeros. If not possible, set the
+            // inputProductValid flag to false.
+            if (!outputProduct) {
+              fail_shape_inference("Invalid Target shape product of 0");
+            }
+            int64_t inputProduct = 1;
+            bool inputProductValid = true;
+            if (!dataInputTensorType.has_shape()) {
+              inputProductValid = false;
+            } else {
+              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  checked_mul_into(inputProduct, dataInputTensorType.shape().dim(i).dim_value());
+                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
+                  inputProductValid = false;
+                  break;
+                }
+              }
+            }
+            if (inputProductValid) {
+              if (inputProduct % outputProduct != 0) {
+                fail_shape_inference("Dimension could not be inferred: incompatible shapes");
+              }
+              negativeOneDim->set_dim_value(inputProduct / outputProduct);
+            }
+          }
+        }));
+
+static const char* const Reshape_ver5_doc = Reshape_ver13_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reshape,
+    5,
+    OpSchema()
+        .SetDoc(Reshape_ver5_doc)
+        .Input(0, "data", "An input tensor.", "T")
+        .Input(1, "shape", "Specified shape for output.", "tensor(int64)")
+        .Output(0, "reshaped", "Reshaped data.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // Shape Inference if 2nd input data (the target shape) is available
+          const TensorProto* targetShapeInitializer = ctx.getInputData(1);
+          if (!targetShapeInitializer) {
+            return;
+          }
+          // Make targetShape (0 -> same as originalShape, -1 -> inferred).
+          // The targetShape vector represents the specified shape for output.
+          std::vector<int64_t> targetShape = ParseData<int64_t>(targetShapeInitializer);
+
+          // Iterate through targetShape, adding dimensions in the outputShape
+          // TensorProto. If the targetShape dimension is -1, we do not set the
+          // dimension value in this iteration, but we record the Dimension. If
+          // targetShape dimension is 0, we attempt to propagate the dimension
+          // value/param. If the value cannot be inferred, we set the flag in
+          // the unresolveZeros vector. If targetShape dimension is positive, we
+          // set the dimension value in the outputShape. We track the product of
+          // the dimensions we are setting outputShape in the outputProduct
+          // variable. The outputProduct will potentially be used for inferring
+          // a dimension marked -1.
+          auto outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          TensorShapeProto::Dimension* negativeOneDim = nullptr;
+          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
+          std::vector<bool> unresolvedZeros(targetShape.size(), false);
+          int64_t outputProduct = 1;
+          for (int i = 0; i < static_cast<int>(targetShape.size()); ++i) {
+            // Add a new dimension to outputShape
+            auto new_dim = outputShape->add_dim();
+            if (targetShape[i] == -1) {
+              // Check if multiple -1's. If not, set negativeOneDim, marking
+              // this dimension to potentially be filled in later.
+              if (negativeOneDim) {
+                fail_shape_inference("Target shape may not have multiple -1 dimensions");
+              }
+              negativeOneDim = new_dim;
+            } else if (targetShape[i] == 0) {
+              // Check if data input has a shape and if the index i is within
+              // its bounds. If these conditions are satisfied, any dimension
+              // value/param should be propagated. If dimension value cannot be
+              // inferred, set the corresponding  unresolvedZeros flag to true.
+              unresolvedZeros[i] = true;
+              if (dataInputTensorType.has_shape()) {
+                if (i >= dataInputTensorType.shape().dim_size()) {
+                  fail_shape_inference("Invalid position of 0");
+                }
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  const auto& dim_value = dataInputTensorType.shape().dim(i).dim_value();
+                  new_dim->set_dim_value(dim_value);
+                  checked_mul_into(outputProduct, dim_value);
+                  unresolvedZeros[i] = false;
+                } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
+                  const auto& dim_param = dataInputTensorType.shape().dim(i).dim_param();
+                  new_dim->set_dim_param(dim_param);
+                }
+              }
+            } else if (targetShape[i] > 0) {
+              // Set the dimension value to targetShape[i]
+              new_dim->set_dim_value(targetShape[i]);
+              checked_mul_into(outputProduct, targetShape[i]);
+            } else {
+              // Check if value is less than -1; fail if so
+              fail_shape_inference("Invalid dimension value: ", targetShape[i]);
+            }
+          }
+
+          // If negativeOneDim has been set, we attempt to infer its value. This
+          // can be done if all dimension values for the data input tensor shape
+          // are known other than the ones corresponding to unresolvedZeros
+          // flags.
+          if (negativeOneDim) {
+            // First, attempt to compute product of data input shape dimensions
+            // that are not marked by unresolvedZeros. If not possible, set the
+            // inputProductValid flag to false.
+            if (!outputProduct) {
+              fail_shape_inference("Invalid Target shape product of 0");
+            }
+            int64_t inputProduct = 1;
+            bool inputProductValid = true;
+            if (!dataInputTensorType.has_shape()) {
+              inputProductValid = false;
+            } else {
+              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  checked_mul_into(inputProduct, dataInputTensorType.shape().dim(i).dim_value());
+                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
+                  inputProductValid = false;
+                  break;
+                }
+              }
+            }
+            if (inputProductValid) {
+              if (inputProduct % outputProduct != 0) {
+                fail_shape_inference("Dimension could not be inferred: incompatible shapes");
+              }
+              negativeOneDim->set_dim_value(inputProduct / outputProduct);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Shape,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_Shape_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "shape", "Shape of the input tensor", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr(
+            "start",
+            "(Optional) Starting axis for slicing the shape. Default value is 0."
+            "Negative value means counting dimensions from the back.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "end",
+            "(Optional) Ending axis for slicing the shape. "
+            "Negative value means counting dimensions from the back. "
+            "If omitted, sizes of all axes upto (including) the last one will be included.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir12(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          auto output_length = output_shape->add_dim();
+
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          int64_t rank = static_cast<int64_t>(ctx.getInputType(0)->tensor_type().shape().dim_size());
+          int64_t start = getAttribute(ctx, "start", 0);
+          if (start < 0)
+            start += rank;
+          start = (start < 0) ? 0 : (start > rank) ? rank : start;
+          int64_t end = getAttribute(ctx, "end", rank);
+          if (end < 0)
+            end += rank;
+          end = (end < 0) ? 0 : (end > rank) ? rank : end;
+          output_length->set_dim_value((end - start) < 0 ? 0 : (end - start));
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            int64_t rank = static_cast<int64_t>(input_shape.dim_size());
+            int64_t start = getAttribute(ctx, "start", 0);
+            if (start < 0)
+              start += rank;
+            start = (start < 0) ? 0 : (start > rank) ? rank : start;
+            int64_t end = getAttribute(ctx, "end", rank);
+            if (end < 0)
+              end += rank;
+            end = (end < 0) ? 0 : (end > rank) ? rank : end;
+            TensorShapeProto output_shape;
+            for (int64_t d = start; d < end; ++d) {
+              *output_shape.add_dim() = input_shape.dim(static_cast<int>(d));
+            }
+            ctx.addOutputData(0, std::move(output_shape));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Shape,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_Shape_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "shape", "Shape of the input tensor", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr(
+            "start",
+            "(Optional) Starting axis for slicing the shape. Default value is 0."
+            "Negative value means counting dimensions from the back.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "end",
+            "(Optional) Ending axis for slicing the shape. "
+            "Negative value means counting dimensions from the back. "
+            "If omitted, sizes of all axes upto (including) the last one will be included.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir11(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          auto output_length = output_shape->add_dim();
+
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          int64_t rank = static_cast<int64_t>(ctx.getInputType(0)->tensor_type().shape().dim_size());
+          int64_t start = getAttribute(ctx, "start", 0);
+          if (start < 0)
+            start += rank;
+          start = (start < 0) ? 0 : (start > rank) ? rank : start;
+          int64_t end = getAttribute(ctx, "end", rank);
+          if (end < 0)
+            end += rank;
+          end = (end < 0) ? 0 : (end > rank) ? rank : end;
+          output_length->set_dim_value((end - start) < 0 ? 0 : (end - start));
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            int64_t rank = static_cast<int64_t>(input_shape.dim_size());
+            int64_t start = getAttribute(ctx, "start", 0);
+            if (start < 0)
+              start += rank;
+            start = (start < 0) ? 0 : (start > rank) ? rank : start;
+            int64_t end = getAttribute(ctx, "end", rank);
+            if (end < 0)
+              end += rank;
+            end = (end < 0) ? 0 : (end > rank) ? rank : end;
+            TensorShapeProto output_shape;
+            for (int64_t d = start; d < end; ++d) {
+              *output_shape.add_dim() = input_shape.dim(static_cast<int>(d));
+            }
+            ctx.addOutputData(0, std::move(output_shape));
+          }
+        }));
+
+static constexpr const char* Shape_ver13_doc = R"DOC(
+Takes a tensor as input and outputs an 1D int64 tensor containing the shape of the input tensor.
+)DOC";
+
+// Data propagation function for Shape op
+// Propagates input shape to output shape
+static void ShapeOp13DataPropagator(DataPropagationContext& ctx) {
+  if (!hasNInputShapes(ctx, 1)) {
+    return;
+  }
+  if (ctx.getInputType(0)->tensor_type().has_shape()) {
+    auto input_shape = ctx.getInputType(0)->tensor_type().shape();
+    TensorShapeProto tsp;
+    tsp.CopyFrom(input_shape);
+    ctx.addOutputData(0, std::move(tsp));
+  }
+}
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Shape,
+    13,
+    OpSchema()
+        .SetDoc(Shape_ver13_doc)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "shape", "Shape of the input tensor", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          auto output_length = output_shape->add_dim();
+
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          if (ctx.getInputType(0)->tensor_type().has_shape()) {
+            output_length->set_dim_value(ctx.getInputType(0)->tensor_type().shape().dim_size());
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { ShapeOp13DataPropagator(ctx); }));
+
+static const char* const Shape_ver1_doc = Shape_ver13_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Shape,
+    1,
+    OpSchema()
+        .SetDoc(Shape_ver1_doc)
+        .Input(0, "data", "An input tensor.", "T")
+        .Output(0, "shape", "Shape of the input tensor", "T1")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          auto output_length = output_shape->add_dim();
+
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          if (ctx.getInputType(0)->tensor_type().has_shape()) {
+            output_length->set_dim_value(ctx.getInputType(0)->tensor_type().shape().dim_size());
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { ShapeOp13DataPropagator(ctx); }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Size,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_Size_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "size",
+            "Total number of elements of the input tensor",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir12(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor, which should be a scalar though.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          const auto input_data = ctx.getInputData(0);
+          if (input_data != nullptr) {
+            TensorShapeProto tsp;
+            tsp.mutable_dim()->Add()->set_dim_value(input_data->dim_size());
+            ctx.addOutputData(0, std::move(tsp));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Size,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_Size_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "size",
+            "Total number of elements of the input tensor",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir11(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor, which should be a scalar though.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          const auto input_data = ctx.getInputData(0);
+          if (input_data != nullptr) {
+            TensorShapeProto tsp;
+            tsp.mutable_dim()->Add()->set_dim_value(input_data->dim_size());
+            ctx.addOutputData(0, std::move(tsp));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Size,
+    1,
+    OpSchema()
+        .SetDoc(kDoc_Size_ver24)
+        .Input(0, "data", "An input tensor.", "T")
+        .Output(0, "size", "Total number of elements of the input tensor", "T1")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor, which should be a scalar though.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Concat,
+    11,
+    OpSchema()
+        .Attr(
+            "axis",
+            "Which axis to concat on. A negative value means counting dimensions from the back. "
+            "Accepted range is [-r, r-1] where r = rank(inputs)..",
+            AttributeProto::INT)
+        .SetDoc(
+            "Concatenate a list of tensors into a single tensor. "
+            "All input tensors must have the same shape, except for the dimension size of the axis to concatenate on.")
+        .Input(0, "inputs", "List of tensors for concatenation", "T", OpSchema::Variadic)
+        .Output(0, "concat_result", "Concatenated tensor", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto numInputs = ctx.getNumInputs();
+          if (numInputs < 1 || !hasNInputShapes(ctx, numInputs)) {
+            return;
+          }
+
+          auto rank = ctx.getInputType(0)->tensor_type().shape().dim_size();
+
+          auto axisAttr = ctx.getAttribute("axis");
+          if (!axisAttr) {
+            fail_shape_inference("Required attribute axis is missing");
+          }
+          int axis = static_cast<int>(axisAttr->i());
+          if (axis < -rank || axis >= rank) {
+            fail_shape_inference("axis must be in [-rank, rank-1].");
+          }
+          if (axis < 0) {
+            axis += rank;
+          }
+
+          if (numInputs == 1) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+            return;
+          }
+
+          bool all_lengths_known = true;
+          int total_length = 0;
+
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int64_t i = 0; i < rank; ++i) {
+            output_shape->add_dim();
+          }
+
+          for (size_t i = 0; i < numInputs; i++) {
+            const auto& shape = ctx.getInputType(i)->tensor_type().shape();
+            if (shape.dim_size() != rank) {
+              fail_shape_inference(
+                  "All inputs to Concat must have same rank. Input ", i, " has rank ", shape.dim_size(), " != ", rank);
+            }
+            for (int j = 0; j < rank; j++) {
+              if (j == axis) {
+                if (shape.dim(j).has_dim_value()) {
+                  total_length += static_cast<int>(shape.dim(j).dim_value());
+                } else {
+                  all_lengths_known = false;
+                }
+              } else {
+                auto& output_dim = *output_shape->mutable_dim(j);
+                const auto& input_dim = shape.dim(j);
+                mergeInDimensionInfo(input_dim, output_dim, j);
+              }
+            }
+          }
+
+          if (all_lengths_known) {
+            output_shape->mutable_dim(axis)->set_dim_value(total_length);
+          }
+        }));
+
+static constexpr const char* Split_ver11_doc =
+    R"DOC(Split a tensor into a list of tensors, along the specified
+'axis'. Lengths of the parts can be specified using argument 'split'.
+Otherwise, the tensor is split to equal sized parts.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Split,
+    11,
+    OpSchema()
+        .Input(0, "input", "The tensor to split", "T")
+        .Output(0, "outputs", "One or more outputs forming list of tensors after splitting", "T", OpSchema::Variadic)
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .Attr(
+            "axis",
+            "Which axis to split on. "
+            "A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] "
+            "where r = rank(input).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr("split", "length of each output. Values should be >= 0.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .SetDoc(Split_ver11_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); ++i) {
+            propagateElemTypeFromInputToOutput(ctx, 0, i);
+          }
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          const auto& shape = ctx.getInputType(0)->tensor_type().shape();
+          int rank = shape.dim_size();
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 0));
+          if (axis < -rank || axis >= rank) {
+            fail_type_inference("Invalid value of attribute 'axis'. Rank=", rank, " Value=", axis);
+          }
+          if (axis < 0) {
+            axis += rank;
+          }
+          const auto& split_dim = shape.dim(axis);
+          if (!split_dim.has_dim_value()) {
+            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
+              *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
+              ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->Clear();
+            }
+            return;
+          }
+          int split_dim_value = static_cast<int>(split_dim.dim_value());
+
+          std::vector<int64_t> split;
+          if (getRepeatedAttribute(ctx, "split", split)) {
+            if (split.size() != ctx.getNumOutputs()) {
+              fail_shape_inference(
+                  "Mismatch between number of splits (", split.size(), ") and outputs (", ctx.getNumOutputs(), ")");
+            }
+            int64_t total_dim = 0;
+            for (int64_t d : split) {
+              total_dim += d;
+            }
+            if (total_dim != split_dim_value) {
+              fail_shape_inference(
+                  "Mismatch between the sum of 'split' (",
+                  total_dim,
+                  ") and the split dimension of the input (",
+                  split_dim_value,
+                  ")");
+            }
+          } else {
+            int num_outputs = static_cast<int>(ctx.getNumOutputs());
+            if (split_dim_value % num_outputs != 0) {
+              fail_shape_inference("The input is not evenly splittable");
+            }
+            int chunk_size = split_dim_value / num_outputs;
+            for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); i++) {
+              split.push_back(chunk_size);
+            }
+          }
+          for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
+            *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
+            ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->set_dim_value(split[i]);
+          }
+        }));
+
+static constexpr const char* Split_ver13_doc =
+    R"DOC(Split a tensor into a list of tensors, along the specified
+'axis'. Lengths of the parts can be specified using input 'split'.
+Otherwise, the tensor is split to equal sized parts.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Split,
+    13,
+    OpSchema()
+        .Input(0, "input", "The tensor to split", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "split",
+            "Optional length of each output. Values should be >= 0."
+            "Sum of the values must be equal to the dim value at 'axis' specified.",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "outputs",
+            "One or more outputs forming list of tensors after splitting",
+            "T",
+            OpSchema::Variadic,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .Attr(
+            "axis",
+            "Which axis to split on. "
+            "A negative value means counting dimensions from the back. Accepted range is [-rank, rank-1] "
+            "where r = rank(input).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .SetDoc(Split_ver13_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); ++i) {
+            propagateElemTypeFromInputToOutput(ctx, 0, i);
+          }
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          const auto& shape = ctx.getInputType(0)->tensor_type().shape();
+          int rank = shape.dim_size();
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 0));
+          if (axis < -rank || axis >= rank) {
+            fail_type_inference("Invalid value of attribute 'axis'. Rank=", rank, " Value=", axis);
+          }
+          if (axis < 0) {
+            axis += rank;
+          }
+          const auto& split_dim = shape.dim(axis);
+          if (!split_dim.has_dim_value()) {
+            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
+              *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
+              ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->Clear();
+            }
+            return;
+          }
+          int split_dim_value = static_cast<int>(split_dim.dim_value());
+
+          std::vector<int64_t> split;
+          size_t num_inputs = ctx.getNumInputs();
+          if ((num_inputs == 2) && ctx.getInputType(1)) { //'split' is input
+            auto split_proto = ctx.getInputData(1);
+            if (split_proto == nullptr) {
+              // skip if split is not an initializer
+              return;
+            }
+            split = ParseData<int64_t>(split_proto);
+            if (split.size() != ctx.getNumOutputs()) {
+              fail_shape_inference(
+                  "Mismatch between number of splits (", split.size(), ") and outputs (", ctx.getNumOutputs(), ")");
+            }
+            int64_t total_dim = 0;
+            for (int64_t d : split) {
+              total_dim += d;
+            }
+            if (total_dim != split_dim_value) {
+              fail_shape_inference(
+                  "Mismatch between the sum of 'split' (",
+                  total_dim,
+                  ") and the split dimension of the input (",
+                  split_dim_value,
+                  ")");
+            }
+          } else { // no value available for 'split'
+            int num_outputs = static_cast<int>(ctx.getNumOutputs());
+            if (split_dim_value % num_outputs != 0) {
+              fail_shape_inference("The input is not evenly splittable");
+            }
+            int chunk_size = split_dim_value / num_outputs;
+            split.reserve(ctx.getNumOutputs());
+            for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); i++) {
+              split.push_back(chunk_size);
+            }
+          }
+          for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
+            *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
+            ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->set_dim_value(split[i]);
+          }
+        }));
+
+static constexpr const char* Slice_ver11_doc = R"DOC(
+Produces a slice of the input tensor along multiple axes. Similar to numpy:
+https://numpy.org/doc/stable/reference/routines.indexing.html
+Slices uses `starts`, `ends`, `axes` and `steps` inputs to specify the start and end
+dimension and step for each axis in the list of axes, it uses this information to
+slice the input `data` tensor. If a negative value is passed for any of the
+start or end indices, it represents number of elements before the end of that
+dimension. If the value passed to start or end is larger than the `n` (the
+number of elements in this dimension), it represents `n`. For slicing to the
+end of a dimension with unknown size, it is recommended to pass in `INT_MAX`
+when slicing forward and 'INT_MIN' when slicing backward.
+If a negative value is passed for step, it represents slicing backward.
+However step value cannot be 0.
+If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
+If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
+Example 1:
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  axes = [0, 1]
+  starts = [1, 0]
+  ends = [2, 3]
+  steps = [1, 2]
+  result = [
+      [5, 7],
+  ]
+Example 2:
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  starts = [0, 1]
+  ends = [-1, 1000]
+  result = [
+      [2, 3, 4],
+  ]
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Slice,
+    11,
+    OpSchema()
+        .SetDoc(Slice_ver11_doc)
+        .Input(0, "data", "Tensor of data to extract slices from.", "T")
+        .Input(1, "starts", "1-D tensor of starting indices of corresponding axis in `axes`", "Tind")
+        .Input(2, "ends", "1-D tensor of ending indices (exclusive) of corresponding axis in `axes`", "Tind")
+        .Input(
+            3,
+            "axes",
+            "1-D tensor of axes that `starts` and `ends` apply to. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            "Tind",
+            OpSchema::Optional)
+        .Input(
+            4,
+            "steps",
+            "1-D tensor of slice step of corresponding axis in `axes`. "
+            "Negative value means slicing backward. 'steps' cannot be 0. "
+            "Defaults to 1.",
+            "Tind",
+            OpSchema::Optional)
+        .Output(0, "output", "Sliced data tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          size_t num_inputs = ctx.getNumInputs();
+          if (num_inputs != 3 && num_inputs != 4 && num_inputs != 5) {
+            fail_type_inference("Slice op must have either three, four or five inputs.");
+          }
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          // Shape Inference if
+          //     1. 2nd and 3rd input data (starts, ends) are available.
+          // and 2. 4th and 5th optional input (axes, steps) are either not set,
+          // or set and is initializer.
+          const TensorProto* startsInitializer = ctx.getInputData(1);
+          const TensorProto* endsInitializer = ctx.getInputData(2);
+          const TensorProto* axesInitializer = hasInputShape(ctx, 3) ? ctx.getInputData(3) : nullptr;
+          const TensorProto* stepsInitializer = hasInputShape(ctx, 4) ? ctx.getInputData(4) : nullptr;
+
+          if (!startsInitializer || !endsInitializer || (hasInputShape(ctx, 3) && !ctx.getInputData(3)) ||
+              (hasInputShape(ctx, 4) && !ctx.getInputData(4))) {
+            const auto input_rank = ctx.getInputType(0)->tensor_type().shape().dim_size();
+            // we can infer the output rank - it never changes
+            for (int i = 0; i < input_rank; ++i) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+            }
+            return;
+          }
+
+          // don't know data_type- can't proceed
+          if (!startsInitializer->has_data_type())
+            return;
+
+          auto get_initializer_data = [](const TensorProto* initializer) -> std::vector<int64_t> {
+            std::vector<int64_t> vec;
+            if (initializer->data_type() == TensorProto::INT64) {
+              const auto data = ParseData<int64_t>(initializer);
+              vec.insert(vec.end(), data.begin(), data.end());
+            } else if (initializer->data_type() == TensorProto::INT32) {
+              const auto data = ParseData<int32_t>(initializer);
+              vec.insert(vec.end(), data.begin(), data.end());
+            } else {
+              // unaccepted data type
+              fail_shape_inference("Only supports `int32_t` or `int64_t` inputs for starts/ends/axes/steps");
+            }
+            return vec;
+          };
+
+          std::vector<int64_t> starts = get_initializer_data(startsInitializer);
+          std::vector<int64_t> ends = get_initializer_data(endsInitializer);
+
+          if (starts.size() != ends.size()) {
+            fail_shape_inference("Incorrect or missing input value for starts and ends");
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_rank = input_shape.dim_size();
+          std::vector<int64_t> axes(starts.size());
+          if (!axesInitializer) {
+            std::iota(axes.begin(), axes.end(), 0);
+          } else {
+            axes = get_initializer_data(axesInitializer);
+            if (axes.size() != starts.size()) {
+              fail_shape_inference("Input axes has incorrect length");
+            }
+          }
+
+          std::vector<int64_t> steps;
+          if (!stepsInitializer) {
+            steps = std::vector<int64_t>(starts.size(), 1);
+          } else {
+            steps = get_initializer_data(stepsInitializer);
+            if (steps.size() != axes.size()) {
+              fail_shape_inference("Input steps has incorrect length");
+            }
+          }
+
+          for (int i = 0; i < input_rank; ++i) {
+            // first update rank of output dim
+            auto output_dim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+            const auto& input_dim = input_shape.dim(i);
+            if (input_dim.has_dim_value()) {
+              output_dim->set_dim_value(input_dim.dim_value());
+            } else if (input_dim.has_dim_param()) {
+              output_dim->set_dim_param(input_dim.dim_param());
+            }
+          }
+
+          std::unordered_set<int64_t> unique_axes;
+          size_t axes_size = axes.size();
+          for (size_t axis_index = 0; axis_index < axes_size; ++axis_index) {
+            auto axis = axes[axis_index] < 0 ? axes[axis_index] + static_cast<int64_t>(input_rank) : axes[axis_index];
+
+            if (axis >= static_cast<int64_t>(input_rank) || axis < 0) {
+              fail_shape_inference("Input axes has invalid data");
+            }
+
+            if (unique_axes.find(axis) != unique_axes.end()) {
+              fail_shape_inference("'axes' has duplicates");
+            }
+
+            unique_axes.insert(axis);
+
+            auto input_dim = ctx.getInputType(0)->tensor_type().shape().dim(static_cast<int>(axis));
+
+            // input dim value is missing - cannot perform shape inference for
+            // this axis
+            if (!input_dim.has_dim_value()) {
+              // Clear any previously propagated dim_param and leave this
+              // dimension "empty", before moving on to the next dimension
+              ctx.getOutputType(0)
+                  ->mutable_tensor_type()
+                  ->mutable_shape()
+                  ->mutable_dim(static_cast<int>(axis))
+                  ->clear_dim_param();
+              continue;
+            }
+
+            const auto input_dim_value = input_dim.dim_value();
+
+            // Empty dimension: clamp bounds are invalid when dimension size is 0,
+            // so short-circuit to produce a zero-length output.
+            if (input_dim_value == 0) {
+              ctx.getOutputType(0)
+                  ->mutable_tensor_type()
+                  ->mutable_shape()
+                  ->mutable_dim(static_cast<int>(axis))
+                  ->set_dim_value(0);
+              continue;
+            }
+
+            // process step
+            auto step = steps[axis_index];
+            if (step == 0) {
+              fail_shape_inference("'step' cannot be 0");
+            }
+
+            // process start
+            auto start = starts[axis_index];
+            if (start < 0)
+              start += input_dim_value;
+            if (step < 0)
+              start = std::clamp(start, static_cast<int64_t>(0), input_dim_value - 1);
+            else
+              start = std::clamp(start, static_cast<int64_t>(0), input_dim_value);
+
+            // process end
+            auto end = ends[axis_index];
+            if (end < static_cast<int64_t>(0))
+              end += input_dim_value;
+            if (step < static_cast<int64_t>(0))
+              end = std::clamp(end, static_cast<int64_t>(-1), input_dim_value);
+            else
+              end = std::clamp(end, static_cast<int64_t>(0), input_dim_value);
+
+            // find output dim value for this axis
+            auto temp = static_cast<int64_t>(ceil(1.0 * (end - start) / step));
+            if (temp < 0)
+              temp = 0;
+
+            // assign output value
+            ctx.getOutputType(0)
+                ->mutable_tensor_type()
+                ->mutable_shape()
+                ->mutable_dim(static_cast<int>(axis))
+                ->set_dim_value(temp);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Transpose,
+    24,
+    OpSchema()
+        .SetDoc(Transpose_doc)
+        .Attr(
+            "perm",
+            "A list of integers. By default, reverse the dimensions, "
+            "otherwise permute the axes according to the values given. "
+            "Its length must be equal to the rank of the input.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "transposed", "Transposed output.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir12(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          auto input_type = ctx.getInputType(0);
+          const TensorShapeProto& shape = input_type->tensor_type().shape();
+          std::vector<int64_t> perm;
+          bool has_perm_attr = getRepeatedAttribute(ctx, "perm", perm);
+          if (!has_perm_attr) {
+            perm.reserve(shape.dim_size());
+            for (int i = shape.dim_size() - 1; i >= 0; --i)
+              perm.push_back(i);
+          } else if (!perm.empty()) {
+            // check if every index is valid
+            std::vector<bool> seen(shape.dim_size(), false);
+            for (int64_t fromDimIndex : perm) {
+              if (fromDimIndex < 0 || fromDimIndex >= shape.dim_size()) {
+                std::ostringstream oss;
+                oss << "Invalid attribute perm {" << perm[0];
+                for (size_t i = 1; i != perm.size(); ++i) {
+                  oss << ", " << perm[i];
+                }
+                oss << "}, input shape = {";
+                if (shape.dim_size() > 0) {
+                  oss << shape.dim(0).dim_value();
+                  for (int i = 1; i != shape.dim_size(); ++i) {
+                    oss << ", " << shape.dim(i).dim_value();
+                  }
+                  oss << "}";
+                }
+                fail_type_inference(oss.str());
+              } else {
+                // check if any perm is repeated
+                if (seen[fromDimIndex]) {
+                  fail_type_inference("Attribute perm for Transpose has repeated value: ", fromDimIndex);
+                }
+                seen[fromDimIndex] = true;
+              }
+            }
+          }
+
+          getOutputShape(ctx, 0);
+
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          for (int64_t i : perm) {
+            appendSingleDimCopiedFromInputTypeToOutputType(ctx, 0, 0, static_cast<size_t>(i));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Transpose,
+    23,
+    OpSchema()
+        .SetDoc(Transpose_doc)
+        .Attr(
+            "perm",
+            "A list of integers. By default, reverse the dimensions, "
+            "otherwise permute the axes according to the values given. "
+            "Its length must be equal to the rank of the input.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "transposed", "Transposed output.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir11(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          auto input_type = ctx.getInputType(0);
+          const TensorShapeProto& shape = input_type->tensor_type().shape();
+          std::vector<int64_t> perm;
+          bool has_perm_attr = getRepeatedAttribute(ctx, "perm", perm);
+          if (!has_perm_attr) {
+            perm.reserve(shape.dim_size());
+            for (int i = shape.dim_size() - 1; i >= 0; --i)
+              perm.push_back(i);
+          } else if (!perm.empty()) {
+            // check if every index is valid
+            std::vector<bool> seen(shape.dim_size(), false);
+            for (int64_t fromDimIndex : perm) {
+              if (fromDimIndex < 0 || fromDimIndex >= shape.dim_size()) {
+                std::ostringstream oss;
+                oss << "Invalid attribute perm {" << perm[0];
+                for (size_t i = 1; i != perm.size(); ++i) {
+                  oss << ", " << perm[i];
+                }
+                oss << "}, input shape = {";
+                if (shape.dim_size() > 0) {
+                  oss << shape.dim(0).dim_value();
+                  for (int i = 1; i != shape.dim_size(); ++i) {
+                    oss << ", " << shape.dim(i).dim_value();
+                  }
+                  oss << "}";
+                }
+                fail_type_inference(oss.str());
+              } else {
+                // check if any perm is repeated
+                if (seen[fromDimIndex]) {
+                  fail_type_inference("Attribute perm for Transpose has repeated value: ", fromDimIndex);
+                }
+                seen[fromDimIndex] = true;
+              }
+            }
+          }
+
+          getOutputShape(ctx, 0);
+
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          for (int64_t i : perm) {
+            appendSingleDimCopiedFromInputTypeToOutputType(ctx, 0, 0, static_cast<size_t>(i));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Transpose,
+    21,
+    OpSchema()
+        .SetDoc(Transpose_doc)
+        .Attr(
+            "perm",
+            "A list of integers. By default, reverse the dimensions, "
+            "otherwise permute the axes according to the values given. "
+            "Its length must be equal to the rank of the input.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "transposed", "Transposed output.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir10(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          auto input_type = ctx.getInputType(0);
+          const TensorShapeProto& shape = input_type->tensor_type().shape();
+          std::vector<int64_t> perm;
+          bool has_perm_attr = getRepeatedAttribute(ctx, "perm", perm);
+          if (!has_perm_attr) {
+            perm.reserve(shape.dim_size());
+            for (int i = shape.dim_size() - 1; i >= 0; --i)
+              perm.push_back(i);
+          } else if (!perm.empty()) {
+            // check if every index is valid
+            std::vector<bool> seen(shape.dim_size(), false);
+            for (int64_t fromDimIndex : perm) {
+              if (fromDimIndex < 0 || fromDimIndex >= shape.dim_size()) {
+                std::ostringstream oss;
+                oss << "Invalid attribute perm {" << perm[0];
+                for (size_t i = 1; i != perm.size(); ++i) {
+                  oss << ", " << perm[i];
+                }
+                oss << "}, input shape = {";
+                if (shape.dim_size() > 0) {
+                  oss << shape.dim(0).dim_value();
+                  for (int i = 1; i != shape.dim_size(); ++i) {
+                    oss << ", " << shape.dim(i).dim_value();
+                  }
+                  oss << "}";
+                }
+                fail_type_inference(oss.str());
+              } else {
+                // check if any perm is repeated
+                if (seen[fromDimIndex]) {
+                  fail_type_inference("Attribute perm for Transpose has repeated value: ", fromDimIndex);
+                }
+                seen[fromDimIndex] = true;
+              }
+            }
+          }
+
+          getOutputShape(ctx, 0);
+
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          for (int64_t i : perm) {
+            appendSingleDimCopiedFromInputTypeToOutputType(ctx, 0, 0, static_cast<size_t>(i));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Transpose,
+    13,
+    OpSchema()
+        .SetDoc(Transpose_doc)
+        .Attr(
+            "perm",
+            "A list of integers. By default, reverse the dimensions, "
+            "otherwise permute the axes according to the values given.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "transposed", "Transposed output.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          auto input_type = ctx.getInputType(0);
+          const TensorShapeProto& shape = input_type->tensor_type().shape();
+          std::vector<int64_t> perm;
+          bool has_perm_attr = getRepeatedAttribute(ctx, "perm", perm);
+          if (!has_perm_attr) {
+            perm.reserve(shape.dim_size());
+            for (int i = shape.dim_size() - 1; i >= 0; --i)
+              perm.push_back(i);
+          } else if (!perm.empty()) {
+            // check if every index is valid
+            std::vector<bool> seen(shape.dim_size(), false);
+            for (int64_t fromDimIndex : perm) {
+              if (fromDimIndex < 0 || fromDimIndex >= shape.dim_size()) {
+                std::ostringstream oss;
+                oss << "Invalid attribute perm {" << perm[0];
+                for (size_t i = 1; i != perm.size(); ++i) {
+                  oss << ", " << perm[i];
+                }
+                oss << "}, input shape = {";
+                if (shape.dim_size() > 0) {
+                  oss << shape.dim(0).dim_value();
+                  for (int i = 1; i != shape.dim_size(); ++i) {
+                    oss << ", " << shape.dim(i).dim_value();
+                  }
+                  oss << "}";
+                }
+                fail_type_inference(oss.str());
+              } else {
+                // check if any perm is repeated
+                if (seen[fromDimIndex]) {
+                  fail_type_inference("Attribute perm for Transpose has repeated value: ", fromDimIndex);
+                }
+                seen[fromDimIndex] = true;
+              }
+            }
+          }
+
+          getOutputShape(ctx, 0);
+
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          for (int64_t i : perm) {
+            appendSingleDimCopiedFromInputTypeToOutputType(ctx, 0, 0, static_cast<size_t>(i));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Transpose,
+    1,
+    OpSchema()
+        .SetDoc(Transpose_doc)
+        .Attr(
+            "perm",
+            "A list of integers. By default, reverse the dimensions, "
+            "otherwise permute the axes according to the values given.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Input(0, "data", "An input tensor.", "T")
+        .Output(0, "transposed", "Transposed output.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          auto input_type = ctx.getInputType(0);
+          const TensorShapeProto& shape = input_type->tensor_type().shape();
+          std::vector<int64_t> perm;
+          bool has_perm_attr = getRepeatedAttribute(ctx, "perm", perm);
+          if (!has_perm_attr) {
+            for (int i = shape.dim_size() - 1; i >= 0; --i)
+              perm.push_back(i);
+          } else if (!perm.empty()) {
+            // check if every index is valid
+            std::vector<bool> seen(shape.dim_size(), false);
+            for (int64_t fromDimIndex : perm) {
+              if (fromDimIndex < 0 || fromDimIndex >= shape.dim_size()) {
+                std::ostringstream oss;
+                oss << "Invalid attribute perm {" << perm[0];
+                for (size_t i = 1; i != perm.size(); ++i) {
+                  oss << ", " << perm[i];
+                }
+                oss << "}, input shape = {";
+                if (shape.dim_size() > 0) {
+                  oss << shape.dim(0).dim_value();
+                  for (int i = 1; i != shape.dim_size(); ++i) {
+                    oss << ", " << shape.dim(i).dim_value();
+                  }
+                  oss << "}";
+                }
+                fail_type_inference(oss.str());
+              } else {
+                // check if any perm is repeated
+                if (seen[fromDimIndex]) {
+                  fail_type_inference("Attribute perm for Transpose has repeated value: ", fromDimIndex);
+                }
+                seen[fromDimIndex] = true;
+              }
+            }
+          }
+
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          for (int64_t i : perm) {
+            appendSingleDimCopiedFromInputTypeToOutputType(ctx, 0, 0, static_cast<size_t>(i));
+          }
+        }));
+
+static constexpr const char* ScatterND_ver16_doc = R"DOC(
+ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
+and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
+is produced by creating a copy of the input `data`, and then updating its value to values
+specified by `updates` at specific index positions specified by `indices`. Its output shape
+is the same as the shape of `data`.
+
+`indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
+ `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
+Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
+update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
+update to a slice of the tensor. Index values are allowed to be negative, as per the usual
+convention for counting backwards from the end, but are expected in the valid range.
+
+`updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
+first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
+The remaining dimensions of `updates` correspond to the dimensions of the
+replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
+corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
+must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
+of shapes.
+
+The `output` is calculated via the following equation:
+    output = np.copy(data)
+    update_indices = indices.shape[:-1]
+    for idx in np.ndindex(update_indices):
+        output[tuple(indices[idx])] = updates[idx]
+The order of iteration in the above loop is not specified.
+In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
+This ensures that the output value does not depend on the iteration order.
+
+`reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+tensor into `output` at the specified `indices`.
+In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+then indices[idx1] != indices[idx2]. This ensures that the output value does not depend on the iteration order.
+When `reduction` is set to "add", `output` is calculated as follows:
+    output = np.copy(data)
+    update_indices = indices.shape[:-1]
+    for idx in np.ndindex(update_indices):
+        output[tuple(indices[idx])] += updates[idx]
+When `reduction` is set to "mul", `output` is calculated as follows:
+    output = np.copy(data)
+    update_indices = indices.shape[:-1]
+    for idx in np.ndindex(update_indices):
+        output[tuple(indices[idx])] *= updates[idx]
+This operator is the inverse of GatherND.
+Example 1:
+```
+  data    = [1, 2, 3, 4, 5, 6, 7, 8]
+  indices = [[4], [3], [1], [7]]
+  updates = [9, 10, 11, 12]
+  output  = [1, 11, 3, 10, 9, 6, 7, 12]
+```
+Example 2:
+```
+  data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+  indices = [[0], [2]]
+  updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
+  output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ScatterND,
+    16,
+    OpSchema()
+        .SetDoc(ScatterND_ver16_doc)
+        .Attr(
+            "reduction",
+            "Type of reduction to apply: none (default), add, mul. "
+            "'none': no reduction applied. "
+            "'add':  reduction using the addition operation. "
+            "'mul': reduction using the multiplication operation.",
+            AttributeProto::STRING,
+            std::string("none"))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of rank q >= 1.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "updates",
+            "Tensor of rank q + r - indices_shape[-1] - 1.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(0, "output", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* ScatterND_ver13_doc = R"DOC(
+ScatterND takes three inputs `data` tensor of rank r >= 1, `indices` tensor of rank q >= 1,
+and `updates` tensor of rank q + r - indices.shape[-1] - 1. The output of the operation
+is produced by creating a copy of the input `data`, and then updating its value to values
+specified by `updates` at specific index positions specified by `indices`. Its output shape
+is the same as the shape of `data`. Note that `indices` should not have duplicate entries.
+That is, two or more `updates` for the same index-location is not supported.
+
+`indices` is an integer tensor. Let k denote indices.shape[-1], the last dimension in the shape of `indices`.
+ `indices` is treated as a (q-1)-dimensional tensor of k-tuples, where each k-tuple is a partial-index into `data`.
+Hence, k can be a value at most the rank of `data`. When k equals rank(data), each update entry specifies an
+update to a single element of the tensor. When k is less than rank(data) each update entry specifies an
+update to a slice of the tensor. Index values are allowed to be negative, as per the usual
+convention for counting backwards from the end, but are expected in the valid range.
+
+`updates` is treated as a (q-1)-dimensional tensor of replacement-slice-values. Thus, the
+first (q-1) dimensions of updates.shape must match the first (q-1) dimensions of indices.shape.
+The remaining dimensions of `updates` correspond to the dimensions of the
+replacement-slice-values. Each replacement-slice-value is a (r-k) dimensional tensor,
+corresponding to the trailing (r-k) dimensions of `data`.  Thus, the shape of `updates`
+must equal indices.shape[0:q-1] ++ data.shape[k:r-1], where ++ denotes the concatenation
+of shapes.
+
+The `output` is calculated via the following equation:
+
+    output = np.copy(data)
+    update_indices = indices.shape[:-1]
+    for idx in np.ndindex(update_indices):
+        output[tuple(indices[idx])] = updates[idx]
+
+The order of iteration in the above loop is not specified.
+In particular, indices should not have duplicate entries: that is, if idx1 != idx2, then indices[idx1] != indices[idx2].
+This ensures that the output value does not depend on the iteration order.
+
+This operator is the inverse of GatherND.
+
+Example 1:
+```
+  data    = [1, 2, 3, 4, 5, 6, 7, 8]
+  indices = [[4], [3], [1], [7]]
+  updates = [9, 10, 11, 12]
+  output  = [1, 11, 3, 10, 9, 6, 7, 12]
+```
+
+Example 2:
+```
+  data    = [[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]],
+             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+  indices = [[0], [2]]
+  updates = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]]
+  output  = [[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]],
+             [[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]],
+             [[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]],
+             [[8, 7, 6, 5], [4, 3, 2, 1], [1, 2, 3, 4], [5, 6, 7, 8]]]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ScatterND,
+    13,
+    OpSchema()
+        .SetDoc(ScatterND_ver13_doc)
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of rank q >= 1.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "updates",
+            "Tensor of rank q + r - indices_shape[-1] - 1.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(0, "output", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static const char* const ScatterND_ver11_doc = ScatterND_ver13_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ScatterND,
+    11,
+    OpSchema()
+        .SetDoc(ScatterND_ver11_doc)
+        .Input(0, "data", "Tensor of rank r >= 1.", "T")
+        .Input(1, "indices", "Tensor of rank q >= 1.", "tensor(int64)")
+        .Input(2, "updates", "Tensor of rank q + r - indices_shape[-1] - 1.", "T")
+        .Output(0, "output", "Tensor of rank r >= 1.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* ScatterElements_ver16_doc = R"DOC(
+ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
+rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+(by default, the outer-most axis, that is axis 0). The output of the operation
+is produced by creating a copy of the input `data`, and then updating its value
+to values specified by `updates` at specific index positions specified by
+`indices`. Its output shape is the same as the shape of `data`.
+For each entry in `updates`, the target index in `data` is obtained by combining
+the corresponding entry in `indices` with the index of the entry itself: the
+index-value for dimension = axis is obtained from the value of the corresponding
+entry in `indices` and the index-value for dimension != axis is obtained from the
+index of the entry itself.
+`reduction` allows specification of an optional reduction operation, which is applied to all values in `updates`
+tensor into `output` at the specified `indices`.
+In cases where `reduction` is set to "none", indices should not have duplicate entries: that is, if idx1 != idx2,
+then indices[idx1] != indices[idx2]. For instance, in a 2-D tensor case, the update
+corresponding to the [i][j] entry is performed as below:
+```
+  output[indices[i][j]][j] = updates[i][j] if axis = 0,
+  output[i][indices[i][j]] = updates[i][j] if axis = 1,
+```
+When `reduction` is set to "add", the update corresponding to the [i][j] entry is performed as below:
+```
+  output[indices[i][j]][j] += updates[i][j] if axis = 0,
+  output[i][indices[i][j]] += updates[i][j] if axis = 1,
+```
+When `reduction` is set to "mul", the update corresponding to the [i][j] entry is performed as below:
+```
+  output[indices[i][j]][j] *= updates[i][j] if axis = 0,
+  output[i][indices[i][j]] *= updates[i][j] if axis = 1,
+```
+This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+Example 1:
+```
+  data = [
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+  ]
+  indices = [
+      [1, 0, 2],
+      [0, 2, 1],
+  ]
+  updates = [
+      [1.0, 1.1, 1.2],
+      [2.0, 2.1, 2.2],
+  ]
+  output = [
+      [2.0, 1.1, 0.0]
+      [1.0, 0.0, 2.2]
+      [0.0, 2.1, 1.2]
+  ]
+```
+Example 2:
+```
+  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+  indices = [[1, 3]]
+  updates = [[1.1, 2.1]]
+  axis = 1
+  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ScatterElements,
+    16,
+    OpSchema()
+        .SetDoc(ScatterElements_ver16_doc)
+        .Attr(
+            "axis",
+            "Which axis to scatter on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "reduction",
+            "Type of reduction to apply: none (default), add, mul. "
+            "'none': no reduction applied. "
+            "'add':  reduction using the addition operation. "
+            "'mul': reduction using the multiplication operation.",
+            AttributeProto::STRING,
+            std::string("none"))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be "
+            "within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "updates",
+            "Tensor of rank r >=1 (same rank and shape as indices)",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of rank r >= 1 (same rank as input).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Input and output types can be of any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* ScatterElements_ver13_doc = R"DOC(
+ScatterElements takes three inputs `data`, `updates`, and `indices` of the same
+rank r >= 1 and an optional attribute axis that identifies an axis of `data`
+(by default, the outer-most axis, that is axis 0). The output of the operation
+is produced by creating a copy of the input `data`, and then updating its value
+to values specified by `updates` at specific index positions specified by
+`indices`. Its output shape is the same as the shape of `data`.
+
+For each entry in `updates`, the target index in `data` is obtained by combining
+the corresponding entry in `indices` with the index of the entry itself: the
+index-value for dimension = axis is obtained from the value of the corresponding
+entry in `indices` and the index-value for dimension != axis is obtained from the
+index of the entry itself.
+
+For instance, in a 2-D tensor case, the update corresponding to the [i][j] entry
+is performed as below:
+```
+  output[indices[i][j]][j] = updates[i][j] if axis = 0,
+  output[i][indices[i][j]] = updates[i][j] if axis = 1,
+```
+
+This operator is the inverse of GatherElements. It is similar to Torch's Scatter operation.
+
+Example 1:
+```
+  data = [
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+  ]
+  indices = [
+      [1, 0, 2],
+      [0, 2, 1],
+  ]
+  updates = [
+      [1.0, 1.1, 1.2],
+      [2.0, 2.1, 2.2],
+  ]
+  output = [
+      [2.0, 1.1, 0.0]
+      [1.0, 0.0, 2.2]
+      [0.0, 2.1, 1.2]
+  ]
+```
+Example 2:
+```
+  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+  indices = [[1, 3]]
+  updates = [[1.1, 2.1]]
+  axis = 1
+  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ScatterElements,
+    13,
+    OpSchema()
+        .SetDoc(ScatterElements_ver13_doc)
+        .Attr(
+            "axis",
+            "Which axis to scatter on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be "
+            "within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.",
+            "Tind",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "updates",
+            "Tensor of rank r >=1 (same rank and shape as indices)",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of rank r >= 1 (same rank as input).",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Input and output types can be of any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static const char* const ScatterElements_ver11_doc = ScatterElements_ver13_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    ScatterElements,
+    11,
+    OpSchema()
+        .SetDoc(ScatterElements_ver11_doc)
+        .Attr(
+            "axis",
+            "Which axis to scatter on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T")
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, of r >= 1 (same rank as input). All index values are expected to be "
+            "within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.",
+            "Tind")
+        .Input(2, "updates", "Tensor of rank r >=1 (same rank and shape as indices)", "T")
+        .Output(0, "output", "Tensor of rank r >= 1 (same rank as input).", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Input and output types can be of any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* Gather_ver11_doc = R"DOC(
+Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
+entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
+them in an output tensor of rank q + (r - 1).
+
+axis = 0 :
+
+Let
+k = indices[i_{0}, ..., i_{q-1}]
+Then
+output[i_{0}, ..., i_{q-1}, j_{0}, ..., j_{r-2}] = input[k , j_{0}, ..., j_{r-2}]
+
+```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+  indices = [
+      [0, 1],
+      [1, 2],
+  ]
+  output = [
+      [
+          [1.0, 1.2],
+          [2.3, 3.4],
+      ],
+      [
+          [2.3, 3.4],
+          [4.5, 5.7],
+      ],
+  ]
+```
+axis = 1 :
+
+Let
+k = indices[i_{0}, ..., i_{q-1}]
+Then
+output[j_{0}, i_{0}, ..., i_{q-1}, j_{1}, ..., j_{r-2}] = input[j_{0}, k, j_{1}, ..., j_{r-2}]
+
+```
+  data = [
+      [1.0, 1.2, 1.9],
+      [2.3, 3.4, 3.9],
+      [4.5, 5.7, 5.9],
+  ]
+  indices = [
+      [0, 2],
+  ]
+  axis = 1,
+  output = [
+      [[1.0, 1.9]],
+      [[2.3, 3.9]],
+      [[4.5, 5.9]],
+  ]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gather,
+    11,
+    OpSchema()
+        .SetDoc(Gather_ver11_doc)
+        .Attr(
+            "axis",
+            "Which axis to gather on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T")
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds [-s, s-1] "
+            "along axis of size s. It is an error if any of the index values are out of bounds.",
+            "Tind")
+        .Output(0, "output", "Tensor of rank q + (r - 1).", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 2)) {
+            return;
+          }
+          const TensorShapeProto& data_shape = ctx.getInputType(0)->tensor_type().shape();
+          const TensorShapeProto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
+          int r = data_shape.dim_size();
+          if (r < 1) {
+            fail_shape_inference("data tensor must have rank >= 1");
+          }
+          int q = indices_shape.dim_size();
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 0));
+          if (axis < -r || axis >= r) {
+            fail_shape_inference("axis must be in [-r, r-1]");
+          }
+          if (axis < 0) {
+            axis += r;
+          }
+          int out_rank = q + r - 1;
+          if (out_rank == 0) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          }
+          for (int i = 0; i < out_rank; ++i) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = (i < axis) ? data_shape.dim(i)
+                                                                                                  : // i < axis < r
+                (i >= axis && i < axis + q) ? indices_shape.dim(i - axis)
+                                            : // i - axis < q
+                data_shape.dim(i - q + 1); // i < out_rank < q + r - 1
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { GatherOp13DataPropagator(ctx); }));
+
+static constexpr const char* GatherElements_ver11_doc = R"DOC(
+
+GatherElements takes two inputs `data` and `indices` of the same rank r >= 1
+and an optional attribute `axis` that identifies an axis of `data`
+(by default, the outer-most axis, that is axis 0). It is an indexing operation
+that produces its output by indexing into the input data tensor at index
+positions determined by elements of the `indices` tensor.
+Its output shape is the same as the shape of `indices` and consists of one value
+(gathered from the `data`) for each element in `indices`.
+
+For instance, in the 3-D case (r = 3), the output produced is determined
+by the following equations:
+```
+  out[i][j][k] = input[index[i][j][k]][j][k] if axis = 0,
+  out[i][j][k] = input[i][index[i][j][k]][k] if axis = 1,
+  out[i][j][k] = input[i][j][index[i][j][k]] if axis = 2,
+```
+
+This operator is also the inverse of ScatterElements. It is similar to Torch's gather operation.
+
+Example 1:
+```
+  data = [
+      [1, 2],
+      [3, 4],
+  ]
+  indices = [
+      [0, 0],
+      [1, 0],
+  ]
+  axis = 1
+  output = [
+      [
+        [1, 1],
+        [4, 3],
+      ],
+  ]
+```
+Example 2:
+```
+  data = [
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9],
+  ]
+  indices = [
+      [1, 2, 0],
+      [2, 0, 0],
+  ]
+  axis = 0
+  output = [
+      [
+        [4, 8, 3],
+        [7, 2, 3],
+      ],
+  ]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GatherElements,
+    11,
+    OpSchema()
+        .SetDoc(GatherElements_ver11_doc)
+        .Attr(
+            "axis",
+            "Which axis to gather on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T")
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, with the same rank r as the input. All index values are expected to be "
+            "within bounds [-s, s-1] along axis of size s. It is an error if any of the index values are out of bounds.",
+            "Tind")
+        .Output(0, "output", "Tensor of the same shape as indices.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // propagate indices' shape to output if it exists
+          if (hasInputShape(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 1, 0);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Squeeze,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_Squeeze_ver24)
+        .Input(
+            0,
+            "data",
+            "Tensors with at least max(dims) dimensions.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "1D tensor of integers indicating the dimensions to squeeze. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "squeezed",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir12(),
+            "Constrain input and output types to all tensor types up to IRv12.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          std::vector<int64_t> axes;
+          size_t num_inputs = ctx.getNumInputs();
+          bool axes_not_specified = false;
+
+          if ((num_inputs == 2) && ctx.getInputType(1)) { //'axes' is input
+            auto axes_proto = ctx.getInputData(1);
+            if (axes_proto == nullptr) {
+              // skip if axes is not an initializer
+              return;
+            }
+            axes = ParseData<int64_t>(axes_proto);
+          } else {
+            // axes not specified
+            axes_not_specified = true;
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          checkAxesRange(axes, input_ndim);
+          adjustNegativeAxes(axes, input_ndim);
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (!input_shape.dim(i).has_dim_value() && axes_not_specified) {
+              // if dim has a symbolic value and the axes spec want to act on all dims,
+              // return early because we can't infer the shape
+              return;
+            }
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (axes_not_specified && input_shape.dim(i).dim_value() == 1) {
+              // if axes not specified, do not keep shape if the dimension is equal to one
+              continue;
+            } else if (!axes_not_specified && std::find(axes.begin(), axes.end(), i) != axes.end()) {
+              // if axes wants to explicitly act on this dim, fail explicitly only if the
+              // dim is numerical and != 1. If the dim is 1 or symbolic, remove it. If
+              // the dim is symbolic, runtime engines should check that the dimension is
+              // actually 1 when the op is evaluated
+              if (input_shape.dim(i).has_dim_value() && input_shape.dim(i).dim_value() != 1) {
+                fail_shape_inference(
+                    "Dimension of input ", i, " must be 1 instead of ", input_shape.dim(i).dim_value());
+              }
+            } else {
+              *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = input_shape.dim(i);
+            }
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Squeeze,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_Squeeze_ver24)
+        .Input(
+            0,
+            "data",
+            "Tensors with at least max(dims) dimensions.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "1D tensor of integers indicating the dimensions to squeeze. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "squeezed",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir11(),
+            "Constrain input and output types to all tensor types up to IRv11.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          std::vector<int64_t> axes;
+          size_t num_inputs = ctx.getNumInputs();
+          bool axes_not_specified = false;
+
+          if ((num_inputs == 2) && ctx.getInputType(1)) { //'axes' is input
+            auto axes_proto = ctx.getInputData(1);
+            if (axes_proto == nullptr) {
+              // skip if axes is not an initializer
+              return;
+            }
+            axes = ParseData<int64_t>(axes_proto);
+          } else {
+            // axes not specified
+            axes_not_specified = true;
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          checkAxesRange(axes, input_ndim);
+          adjustNegativeAxes(axes, input_ndim);
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (!input_shape.dim(i).has_dim_value() && axes_not_specified) {
+              // if dim has a symbolic value and the axes spec want to act on all dims,
+              // return early because we can't infer the shape
+              return;
+            }
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (axes_not_specified && input_shape.dim(i).dim_value() == 1) {
+              // if axes not specified, do not keep shape if the dimension is equal to one
+              continue;
+            } else if (!axes_not_specified && std::find(axes.begin(), axes.end(), i) != axes.end()) {
+              // if axes wants to explicitly act on this dim, fail explicitly only if the
+              // dim is numerical and != 1. If the dim is 1 or symbolic, remove it. If
+              // the dim is symbolic, runtime engines should check that the dimension is
+              // actually 1 when the op is evaluated
+              if (input_shape.dim(i).has_dim_value() && input_shape.dim(i).dim_value() != 1) {
+                fail_shape_inference(
+                    "Dimension of input ", i, " must be 1 instead of ", input_shape.dim(i).dim_value());
+              }
+            } else {
+              *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = input_shape.dim(i);
+            }
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Squeeze,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_Squeeze_ver24)
+        .Input(
+            0,
+            "data",
+            "Tensors with at least max(dims) dimensions.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "List of integers indicating the dimensions to squeeze. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "squeezed",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir10(),
+            "Constrain input and output types to all tensor types up to IRv10.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          std::vector<int64_t> axes;
+          size_t num_inputs = ctx.getNumInputs();
+          bool axes_not_specified = false;
+
+          if ((num_inputs == 2) && ctx.getInputType(1)) { //'axes' is input
+            auto axes_proto = ctx.getInputData(1);
+            if (axes_proto == nullptr) {
+              // skip if axes is not an initializer
+              return;
+            }
+            axes = ParseData<int64_t>(axes_proto);
+          } else {
+            // axes not specified
+            axes_not_specified = true;
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          checkAxesRange(axes, input_ndim);
+          adjustNegativeAxes(axes, input_ndim);
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (!input_shape.dim(i).has_dim_value() && axes_not_specified) {
+              // if dim has a symbolic value and the axes spec want to act on all dims,
+              // return early because we can't infer the shape
+              return;
+            }
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (axes_not_specified && input_shape.dim(i).dim_value() == 1) {
+              // if axes not specified, do not keep shape if the dimension is equal to one
+              continue;
+            } else if (!axes_not_specified && std::find(axes.begin(), axes.end(), i) != axes.end()) {
+              // if axes wants to explicitly act on this dim, fail explicitly only if the
+              // dim is numerical and != 1. If the dim is 1 or symbolic, remove it. If
+              // the dim is symbolic, runtime engines should check that the dimension is
+              // actually 1 when the op is evaluated
+              if (input_shape.dim(i).has_dim_value() && input_shape.dim(i).dim_value() != 1) {
+                fail_shape_inference(
+                    "Dimension of input ", i, " must be 1 instead of ", input_shape.dim(i).dim_value());
+              }
+            } else {
+              *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = input_shape.dim(i);
+            }
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Squeeze,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Squeeze_ver24)
+        .Input(
+            0,
+            "data",
+            "Tensors with at least max(dims) dimensions.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "List of integers indicating the dimensions to squeeze. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "squeezed",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          std::vector<int64_t> axes;
+          size_t num_inputs = ctx.getNumInputs();
+          bool axes_not_specified = false;
+
+          if ((num_inputs == 2) && ctx.getInputType(1)) { //'axes' is input
+            auto axes_proto = ctx.getInputData(1);
+            if (axes_proto == nullptr) {
+              // skip if axes is not an initializer
+              return;
+            }
+            axes = ParseData<int64_t>(axes_proto);
+          } else {
+            // axes not specified
+            axes_not_specified = true;
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          checkAxesRange(axes, input_ndim);
+          adjustNegativeAxes(axes, input_ndim);
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (!input_shape.dim(i).has_dim_value() && axes_not_specified) {
+              // if dim has a symbolic value and the axes spec want to act on all dims,
+              // return early because we can't infer the shape
+              return;
+            }
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int i = 0; i < input_ndim; ++i) {
+            if (axes_not_specified && input_shape.dim(i).dim_value() == 1) {
+              // if axes not specified, do not keep shape if the dimension is equal to one
+              continue;
+            } else if (!axes_not_specified && std::find(axes.begin(), axes.end(), i) != axes.end()) {
+              // if axes wants to explicitly act on this dim, fail explicitly only if the
+              // dim is numerical and != 1. If the dim is 1 or symbolic, remove it. If
+              // the dim is symbolic, runtime engines should check that the dimension is
+              // actually 1 when the op is evaluated
+              if (input_shape.dim(i).has_dim_value() && input_shape.dim(i).dim_value() != 1) {
+                fail_shape_inference(
+                    "Dimension of input ", i, " must be 1 instead of ", input_shape.dim(i).dim_value());
+              }
+            } else {
+              *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = input_shape.dim(i);
+            }
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+static constexpr const char* Squeeze_ver11_doc = R"DOC(
+Remove single-dimensional entries from the shape of a tensor.
+Takes a  parameter `axes` with a list of axes to squeeze.
+If `axes` is not provided, all the single dimensions will be removed from
+the shape. If an axis is selected with shape entry not equal to one, an error is raised.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Squeeze,
+    11,
+    OpSchema()
+        .Attr(
+            "axes",
+            "List of integers indicating the dimensions to squeeze. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(data).",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .SetDoc(Squeeze_ver11_doc)
+        .Input(0, "data", "Tensors with at least max(dims) dimensions.", "T")
+        .Output(0, "squeezed", "Reshaped tensor with same data as input.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
+            return;
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          std::vector<int64_t> axes;
+          if (!getRepeatedAttribute(ctx, "axes", axes)) {
+            for (int i = 0; i < input_ndim; ++i) {
+              if (!input_shape.dim(i).has_dim_value()) {
+                return;
+              }
+              if (input_shape.dim(i).dim_value() == 1) {
+                axes.push_back(i);
+              }
+            }
+          }
+
+          std::transform(axes.begin(), axes.end(), axes.begin(), [&](int64_t axis) -> int64_t {
+            return axis < 0 ? axis + input_ndim : axis;
+          });
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          for (int i = 0; i < input_ndim; ++i) {
+            if (std::find(axes.begin(), axes.end(), i) != axes.end()) {
+              if (input_shape.dim(i).has_dim_value() && input_shape.dim(i).dim_value() != 1) {
+                fail_shape_inference(
+                    "Dimension of input ", i, " must be 1 instead of ", input_shape.dim(i).dim_value());
+              }
+            } else {
+              *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = input_shape.dim(i);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Unsqueeze,
+    24,
+    OpSchema()
+        .SetDoc(kDoc_Unsqueeze_ver24)
+        .Input(0, "data", "Original tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "1D tensor of integers indicating the dimensions to be inserted. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(expanded).",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "expanded",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir12(),
+            "Constrain input and output types to all tensor types up to IRv12.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          std::vector<int64_t> axes;
+          auto axes_proto = ctx.getInputData(1);
+          if (axes_proto == nullptr) {
+            // skip if axes is not an initializer
+            return;
+          }
+          axes = ParseData<int64_t>(axes_proto);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          const auto output_ndim = input_ndim + static_cast<int>(axes.size());
+          checkAxesRange(axes, output_ndim);
+          adjustNegativeAxes(axes, output_ndim);
+          checkDuplicateAxes(axes, output_ndim);
+          // sort after correcting negative axes values (if any)
+          std::sort(axes.begin(), axes.end());
+
+          int j = 0;
+          for (int i = 0; i < input_ndim; ++i) {
+            while (static_cast<size_t>(j) < axes.size() &&
+                   axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+              ++j;
+            }
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
+                ctx.getInputType(0)->tensor_type().shape().dim(i);
+          }
+          while (static_cast<size_t>(j) < axes.size() &&
+                 axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+            ++j;
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Unsqueeze,
+    23,
+    OpSchema()
+        .SetDoc(kDoc_Unsqueeze_ver24)
+        .Input(0, "data", "Original tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "1D tensor of integers indicating the dimensions to be inserted. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(expanded).",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "expanded",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir11(),
+            "Constrain input and output types to all tensor types up to IRv11.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          std::vector<int64_t> axes;
+          auto axes_proto = ctx.getInputData(1);
+          if (axes_proto == nullptr) {
+            // skip if axes is not an initializer
+            return;
+          }
+          axes = ParseData<int64_t>(axes_proto);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          const auto output_ndim = input_ndim + static_cast<int>(axes.size());
+          checkAxesRange(axes, output_ndim);
+          adjustNegativeAxes(axes, output_ndim);
+          checkDuplicateAxes(axes, output_ndim);
+          // sort after correcting negative axes values (if any)
+          std::sort(axes.begin(), axes.end());
+
+          int j = 0;
+          for (int i = 0; i < input_ndim; ++i) {
+            while (static_cast<size_t>(j) < axes.size() &&
+                   axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+              ++j;
+            }
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
+                ctx.getInputType(0)->tensor_type().shape().dim(i);
+          }
+          while (static_cast<size_t>(j) < axes.size() &&
+                 axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+            ++j;
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Unsqueeze,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_Unsqueeze_ver24)
+        .Input(0, "data", "Original tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "List of integers indicating the dimensions to be inserted. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(expanded).",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "expanded",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint(
+            "T",
+            OpSchema::all_tensor_types_ir10(),
+            "Constrain input and output types to all tensor types up to IRv10.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          std::vector<int64_t> axes;
+          auto axes_proto = ctx.getInputData(1);
+          if (axes_proto == nullptr) {
+            // skip if axes is not an initializer
+            return;
+          }
+          axes = ParseData<int64_t>(axes_proto);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          const auto output_ndim = input_ndim + static_cast<int>(axes.size());
+          checkAxesRange(axes, output_ndim);
+          adjustNegativeAxes(axes, output_ndim);
+          checkDuplicateAxes(axes, output_ndim);
+          // sort after correcting negative axes values (if any)
+          std::sort(axes.begin(), axes.end());
+
+          int j = 0;
+          for (int i = 0; i < input_ndim; ++i) {
+            while (static_cast<size_t>(j) < axes.size() &&
+                   axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+              ++j;
+            }
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
+                ctx.getInputType(0)->tensor_type().shape().dim(i);
+          }
+          while (static_cast<size_t>(j) < axes.size() &&
+                 axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+            ++j;
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Unsqueeze,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Unsqueeze_ver24)
+        .Input(0, "data", "Original tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "axes",
+            "List of integers indicating the dimensions to be inserted. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(expanded).",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "expanded",
+            "Reshaped tensor with same data as input.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          std::vector<int64_t> axes;
+          auto axes_proto = ctx.getInputData(1);
+          if (axes_proto == nullptr) {
+            // skip if axes is not an initializer
+            return;
+          }
+          axes = ParseData<int64_t>(axes_proto);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          const auto output_ndim = input_ndim + static_cast<int>(axes.size());
+          checkAxesRange(axes, output_ndim);
+          adjustNegativeAxes(axes, output_ndim);
+          checkDuplicateAxes(axes, output_ndim);
+          // sort after correcting negative axes values (if any)
+          std::sort(axes.begin(), axes.end());
+
+          int j = 0;
+          for (int i = 0; i < input_ndim; ++i) {
+            while (static_cast<size_t>(j) < axes.size() &&
+                   axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+              ++j;
+            }
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
+                ctx.getInputType(0)->tensor_type().shape().dim(i);
+          }
+          while (static_cast<size_t>(j) < axes.size() &&
+                 axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+            ++j;
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          PropagateShapeDataFromInputToOutput(ctx, 0);
+        }));
+
+static constexpr const char* Unsqueeze_ver11_doc = R"DOC(
+Insert single-dimensional entries to the shape of an input tensor (`data`).
+Takes one required argument `axes` - which contains a list of dimension indices and this operator will insert a dimension of value `1` into the corresponding index of the output tensor (`expanded`).
+
+For example:
+  Given an input tensor (`data`) of shape [3, 4, 5], then
+  Unsqueeze(data, axes=[0, 4]) outputs a tensor (`expanded`) containing same data as `data` but with shape [1, 3, 4, 5, 1].
+
+The attribute `axes` should not contain any duplicate entries. It is an error if it contains duplicates.
+The rank of the output tensor (`output_rank`) is the rank of the input tensor (`data`) plus the number of values in `axes`.
+Each value in `axes` should be within the (inclusive) range [-output_rank , output_rank - 1].
+The order of values in `axes` does not matter and can come in any order.
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Unsqueeze,
+    11,
+    OpSchema()
+        .Attr(
+            "axes",
+            "List of integers indicating the dimensions to be inserted. Negative value means counting dimensions "
+            "from the back. Accepted range is [-r, r-1] where r = rank(expanded).",
+            AttributeProto::INTS)
+        .SetDoc(Unsqueeze_ver11_doc)
+        .Input(0, "data", "Original tensor", "T")
+        .Output(0, "expanded", "Reshaped tensor with same data as input.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          std::vector<int64_t> axes;
+          if (!getRepeatedAttribute(ctx, "axes", axes)) {
+            return;
+          }
+
+          // validate 'axes' for duplicate entries
+          std::unordered_set<int64_t> unique_values;
+          for (const auto val : axes) {
+            if (unique_values.find(val) != unique_values.end()) {
+              fail_shape_inference("'axes' attribute must not contain any duplicates");
+            }
+            unique_values.insert(val);
+          }
+
+          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
+            return;
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          const auto output_ndim = input_ndim + static_cast<int>(axes.size());
+          for (auto& axe : axes) {
+            if (axe < -output_ndim || axe >= output_ndim) {
+              fail_shape_inference("values in 'axes' are beyond the bounds of the computed output shape");
+            }
+            if (axe < 0) {
+              axe += output_ndim;
+            }
+          }
+
+          // sort after correcting negative axes values (if any) in the previous
+          // step
+          std::sort(axes.begin(), axes.end());
+
+          int j = 0;
+          for (int i = 0; i < input_ndim; ++i) {
+            while (static_cast<size_t>(j) < axes.size() &&
+                   axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+              ++j;
+            }
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
+                ctx.getInputType(0)->tensor_type().shape().dim(i);
+          }
+          while (static_cast<size_t>(j) < axes.size() &&
+                 axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+            ++j;
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    SpaceToDepth,
+    1,
+    OpSchema()
+        .Attr("blocksize", "Blocks of [blocksize, blocksize] are moved.", AttributeProto::INT)
+        .SetDoc(kDoc_SpaceToDepth_ver1)
+        .Input(
+            0,
+            "input",
+            "Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth"
+            ", H is the height and W is the width.",
+            "T")
+        .Output(0, "output", "Output tensor of [N, C * blocksize * blocksize, H/blocksize, W/blocksize].", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto blocksize = getAttribute(ctx, "blocksize", 0);
+          if (blocksize <= 0) {
+            fail_shape_inference("Blocksize must be positive");
+          }
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() == 4) {
+              updateOutputShape(
+                  ctx,
+                  0,
+                  {input_shape.dim(0),
+                   input_shape.dim(1) * (blocksize * blocksize),
+                   input_shape.dim(2) / blocksize,
+                   input_shape.dim(3) / blocksize});
+            } else {
+              fail_shape_inference("Input tensor must be 4-dimensional");
+            }
+          }
+        }));
+
+static constexpr const char* DepthToSpace_ver11_doc =
+    R"DOC(DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
+This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
+the input tensor where values from the depth dimension are moved in spatial blocks to the height
+and width dimensions. By default, `mode` = `DCR`.
+In the DCR mode, elements along the depth dimension from the input tensor are rearranged in the
+following order: depth, column, and then row. The output y is computed from the input x as below:
+
+b, c, h, w = x.shape
+
+tmp = np.reshape(x, [b, blocksize, blocksize, c // (blocksize**2), h, w])
+
+tmp = np.transpose(tmp, [0, 3, 4, 1, 5, 2])
+
+y = np.reshape(tmp, [b, c // (blocksize**2), h * blocksize, w * blocksize])
+
+
+In the CRD mode, elements along the depth dimension from the input tensor are rearranged in the
+following order: column, row, and the depth. The output y is computed from the input x as below:
+
+b, c, h, w = x.shape
+
+tmp = np.reshape(x, [b, c // (blocksize ** 2), blocksize, blocksize, h, w])
+
+tmp = np.transpose(tmp, [0, 1, 4, 2, 5, 3])
+
+y = np.reshape(tmp, [b, c // (blocksize ** 2), h * blocksize, w * blocksize])
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DepthToSpace,
+    11,
+    OpSchema()
+        .Attr("blocksize", "Blocks of [blocksize, blocksize] are moved.", AttributeProto::INT)
+        .Attr(
+            "mode",
+            "DCR (default) for depth-column-row order re-arrangement. Use CRD for column-row-depth order.",
+            AttributeProto::STRING,
+            std::string("DCR"))
+        .SetDoc(DepthToSpace_ver11_doc)
+        .Input(
+            0,
+            "input",
+            "Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth"
+            ", H is the height and W is the width.",
+            "T")
+        .Output(0, "output", "Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto blocksize = getAttribute(ctx, "blocksize", 0);
+          if (blocksize <= 0) {
+            fail_shape_inference("Blocksize must be positive");
+          }
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() == 4) {
+              updateOutputShape(
+                  ctx,
+                  0,
+                  {input_shape.dim(0),
+                   input_shape.dim(1) / (blocksize * blocksize),
+                   input_shape.dim(2) * blocksize,
+                   input_shape.dim(3) * blocksize});
+            } else {
+              fail_shape_inference("Input tensor must be 4-dimensional");
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Tile,
+    6,
+    OpSchema()
+        .SetDoc(kDoc_Tile_ver6)
+        .Input(0, "input", "Input tensor of any shape.", "T")
+        .Input(
+            1,
+            "repeats",
+            "1D int64 tensor of the same length as input's dimension number, "
+            "includes numbers of repeated copies along input's dimensions.",
+            "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor of the same dimensions and type as tensor input. "
+            "output_dim[i] = input_dim[i] * repeats[i]",
+            "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain repeat's type to int64 tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // Shape inference
+
+          // Needs at least the first input to proceed
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_rank = input_shape.dim_size();
+
+          const auto repeats_inputs = ctx.getInputData(1);
+
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          if (nullptr != repeats_inputs && hasNInputShapes(ctx, 2)) {
+            // shape inference is possible only when 'repeats' is an initializer
+            const auto& repeats_shape = ctx.getInputType(1)->tensor_type().shape();
+            if (repeats_shape.dim_size() != 1 || repeats_inputs->data_type() != TensorProto::INT64) {
+              fail_shape_inference("'Repeats' input must be 1D tensor of type int64");
+            }
+
+            const auto repeats_data = ParseData<int64_t>(repeats_inputs);
+
+            if (repeats_data.size() != static_cast<size_t>(input_rank)) {
+              fail_shape_inference(
+                  "'Repeats' input has incorrect number of values. "
+                  "The number of values in 'repeats' must be equal "
+                  "to the number of input dimensions.");
+            }
+
+            for (int i = 0; i < input_rank; ++i) {
+              const auto& input_dim = input_shape.dim(i);
+              auto output_dim = output_shape->add_dim();
+              if (input_dim.has_dim_value()) {
+                output_dim->set_dim_value(input_dim.dim_value() * repeats_data[i]);
+              }
+            }
+          } else {
+            // Infer output shape's rank in any case (if repeats data is not
+            // available)
+            auto output_shape_0 = getOutputShape(ctx, 0);
+            for (int i = 0; i < input_rank; ++i) {
+              output_shape_0->add_dim();
+            }
+          }
+          return;
+        }));
+
+static constexpr const char* Resize_ver18_doc = R"DOC(
+Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
+Each dimension value of the output tensor is: <br/>
+  `output_dimension = floor(input_dimension * (roi_end - roi_start) * scale)` <br/>
+if input \"sizes\" is not specified.
+)DOC";
+
+static constexpr const char* Resize_ver18_attr_coordinate_transformation_mode_doc = R"DOC(
+This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. <br/>
+
+The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
+Denote x_resized as the coordinate of axis x in the resized tensor, x_original as the coordinate of axis x in the original tensor, `length_original` as the length of the original tensor in axis x, length_resized as the length of the resized tensor in axis x, roi_x = (start_x, end_x) of the axis x in input "roi", `scale = length_resized / length_original`, <br/>
+
+if coordinate_transformation_mode is `"half_pixel"`, <br/>
+`x_original = (x_resized + 0.5) / scale - 0.5` <br/>
+
+if coordinate_transformation_mode is `"pytorch_half_pixel"`, <br/>
+`x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0` <br/>
+
+if coordinate_transformation_mode is `"align_corners"`, <br/>
+`x_original = x_resized * (length_original - 1) / (length_resized - 1)` <br/>
+
+if coordinate_transformation_mode is `"asymmetric"`, <br/>
+`x_original = x_resized / scale` <br/>
+
+if coordinate_transformation_mode is `"tf_crop_and_resize"`, <br/>
+`x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1)`
+.)DOC";
+
+static constexpr const char* Resize_ver18_attr_keep_aspect_ratio_policy_doc = R"DOC(
+This attribute describes how to interpret the `sizes` input with regard to keeping the original aspect ratio of the input, and it is not applicable when
+the `scales` input is used. <br/>
+
+Given a set of `sizes`, associated with a subset of `axes` (explicitly provided or default), and assuming `d = axes[i]`, with `i` being the index of the provided `sizes`. <br/>
+
+If `keep_aspect_ratio_policy` is `"stretch"`, the original aspect ratio is disregarded, and the input is resized to the specified size: <br/>
+`out_size[d] = sizes[i]` <br/>
+
+If `keep_aspect_ratio_policy` is `"not_larger"`, the sizes are adjusted so that no extent of the output is larger than the specified size, while keeping the original aspect ratio: <br/>
+`scale = Min(sizes[i] / in_size[d])` <br/>
+`out_size[d] = round_int(scale * in_size[d])` <br/>
+
+If `keep_aspect_ratio_policy` is `"not_smaller"`, the sizes are adjusted so that no extent of the output is smaller than the specified size, while keeping the original aspect ratio: <br/>
+`scale = Max(sizes[i] / in_size[d])` <br/>
+`out_size[d] = round_int(scale * in_size[d])` <br/>
+
+For non-resizable axes (those not specified in `axes`), the output size will be equal to the input size.
+
+Note: `round_int` stands for computing the nearest integer value, rounding halfway cases up.)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Resize,
+    18,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Three interpolation modes: \"nearest\" (default), \"linear\" and \"cubic\". "
+            "The \"linear\" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). "
+            "The \"cubic\" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor).",
+            AttributeProto::STRING,
+            std::string("nearest"))
+        .Attr(
+            "cubic_coeff_a",
+            "The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75"
+            " (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. "
+            "This attribute is valid only if mode is \"cubic\".",
+            AttributeProto::FLOAT,
+            static_cast<float>(-0.75))
+        .Attr(
+            "exclude_outside",
+            "If set to 1, the weight of sampling locations outside the tensor will be set to 0"
+            " and the weight will be renormalized so that their sum is 1.0. The default value is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "coordinate_transformation_mode",
+            Resize_ver18_attr_coordinate_transformation_mode_doc,
+            AttributeProto::STRING,
+            std::string("half_pixel"))
+        .Attr(
+            "nearest_mode",
+            "Four modes: \"round_prefer_floor\" (default, as known as round half down), \"round_prefer_ceil\" (as known as round half up), \"floor\", \"ceil\". Only used by nearest interpolation. It indicates how to get \"nearest\" pixel in input tensor from x_original, so this attribute is valid only if \"mode\" is \"nearest\".",
+            AttributeProto::STRING,
+            std::string("round_prefer_floor"))
+        .Attr(
+            "extrapolation_value",
+            "When coordinate_transformation_mode is \"tf_crop_and_resize\" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f.",
+            AttributeProto::FLOAT,
+            static_cast<float>(0))
+        .Attr(
+            "antialias",
+            "If set to 1, \"linear\" and \"cubic\" interpolation modes will use an antialiasing filter when downscaling. "
+            "Antialiasing is achieved by stretching the resampling filter by a factor max(1, 1 / scale), which means that when downsampling, more input pixels contribute to an output pixel.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "axes",
+            "If provided, it specifies a subset of axes that 'roi', 'scales' and 'sizes' refer to. "
+            "If not provided, all axes are assumed [0, 1, ..., r-1], where r = rank(data). "
+            "Non-specified dimensions are interpreted as non-resizable. "
+            "Negative value means counting dimensions from the back. Accepted range is [-r, r-1], where r = rank(data). "
+            "Behavior is undefined if an axis is repeated.",
+            AttributeProto::INTS,
+            false)
+        .Attr(
+            "keep_aspect_ratio_policy",
+            Resize_ver18_attr_keep_aspect_ratio_policy_doc,
+            AttributeProto::STRING,
+            std::string("stretch"))
+        .Input(0, "X", "N-D tensor", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "roi",
+            "1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X or the length of axes, if provided. "
+            "The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is \"tf_crop_and_resize\"",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "scales",
+            "The scale array along each dimension. It takes value greater than 0. If it's less than 1,"
+            " it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should"
+            " be the same as the rank of input 'X' or the length of 'axes', if provided. "
+            "One of 'scales' and 'sizes' MUST be specified and it is an error if both are specified. If 'sizes' is needed, the user can use an empty string as the name of 'scales' in this operator's input list.",
+            "tensor(float)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            3,
+            "sizes",
+            "Target size of the output tensor. Its interpretation depends on the 'keep_aspect_ratio_policy' value."
+            "The number of elements of 'sizes' should be the same as the"
+            " rank of input 'X', or the length of 'axes', if provided. Only one of 'scales' and 'sizes' can be specified. ",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "Y", "N-D tensor after resizing", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types_ir4(),
+            "Constrain input 'X' and output 'Y' to all tensor types.")
+        .TypeConstraint("T2", {types::Float16, types::Float, types::Double}, "Constrain roi type to float or double.")
+        .SetDoc(Resize_ver18_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset13_to_18(ctx); }));
+
+static constexpr const char* Resize_ver13_doc = R"DOC(
+Resize the input tensor. In general, it calculates every value in the output tensor as a weighted average of neighborhood (a.k.a. sampling locations) in the input tensor.
+Each dimension value of the output tensor is:
+  output_dimension = floor(input_dimension * (roi_end - roi_start) * scale) if input \"sizes\" is not specified.
+)DOC";
+
+static constexpr const char* Resize_ver13_attr_coordinate_transformation_mode_doc = R"DOC(
+This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. <br/>
+
+The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
+Denote x_resized as the coordinate of axis x in the resized tensor, x_original as the coordinate of axis x in the original tensor, length_original as the length of the original tensor in axis x, length_resized as the length of the resized tensor in axis x, roi_x = (start_x, end_x) of the axis x in input "roi", scale = length_resized / length_original, <br/>
+
+if coordinate_transformation_mode is "half_pixel", <br/>
+x_original = (x_resized + 0.5) / scale - 0.5, <br/>
+
+if coordinate_transformation_mode is "pytorch_half_pixel", <br/>
+x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0, <br/>
+
+if coordinate_transformation_mode is "align_corners", <br/>
+x_original = x_resized * (length_original - 1) / (length_resized - 1), <br/>
+
+if coordinate_transformation_mode is "asymmetric", <br/>
+x_original = x_resized / scale, <br/>
+
+if coordinate_transformation_mode is "tf_crop_and_resize", <br/>
+x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1).)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Resize,
+    13,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Three interpolation modes: nearest (default), linear and cubic. "
+            "The \"linear\" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). "
+            "The \"cubic\" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor).",
+            AttributeProto::STRING,
+            std::string("nearest"))
+        .Attr(
+            "cubic_coeff_a",
+            "The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75"
+            " (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. "
+            "This attribute is valid only if \"mode\" is \"cubic\".",
+            AttributeProto::FLOAT,
+            static_cast<float>(-0.75))
+        .Attr(
+            "exclude_outside",
+            "If set to 1, the weight of sampling locations outside the tensor will be set to 0"
+            " and the weight will be renormalized so that their sum is 1.0. The default value is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "coordinate_transformation_mode",
+            Resize_ver13_attr_coordinate_transformation_mode_doc,
+            AttributeProto::STRING,
+            std::string("half_pixel"))
+        .Attr(
+            "nearest_mode",
+            "Four modes: round_prefer_floor (default, as known as round half down), round_prefer_ceil (as known as round half up), floor, ceil. Only used by nearest interpolation. It indicates how to get \"nearest\" pixel in input tensor from x_original, so this attribute is valid only if \"mode\" is \"nearest\".",
+            AttributeProto::STRING,
+            std::string("round_prefer_floor"))
+        .Attr(
+            "extrapolation_value",
+            "When coordinate_transformation_mode is \"tf_crop_and_resize\" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f.",
+            AttributeProto::FLOAT,
+            static_cast<float>(0))
+        .Input(0, "X", "N-D tensor", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "roi",
+            "1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is \"tf_crop_and_resize\"",
+            "T2",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "scales",
+            "The scale array along each dimension. It takes value greater than 0. If it's less than 1,"
+            " it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should"
+            " be the same as the rank of input 'X'. One of 'scales' and 'sizes' MUST be specified and it is an error if both are specified. If 'sizes' is needed, the user can use an empty string as the name of 'scales' in this operator's input list.",
+            "tensor(float)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            3,
+            "sizes",
+            "The size of the output tensor. The number of elements of 'sizes' should be the same as the"
+            " rank of input 'X'. Only one of 'scales' and 'sizes' can be specified.",
+            "tensor(int64)",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "Y", "N-D tensor after resizing", "T1", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "T1",
+            OpSchema::all_tensor_types_ir4(),
+            "Constrain input 'X' and output 'Y' to all tensor types.")
+        .TypeConstraint("T2", {types::Float16, types::Float, types::Double}, "Constrain roi type to float or double.")
+        .SetDoc(Resize_ver13_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset13_to_18(ctx); }));
+
+static const char* const Resize_ver11_doc = Resize_ver13_doc;
+
+static constexpr const char* Resize_attr_coordinate_transformation_mode_ver11_doc = R"DOC(
+This attribute describes how to transform the coordinate in the resized tensor to the coordinate in the original tensor. <br/>
+
+The coordinate of each dimension is transformed individually. Let's describe a case using axis x as an example.
+Denote x_resized as the coordinate of axis x in the resized tensor, x_original as the coordinate of axis x in the original tensor, length_original as the length of the original tensor in axis x, length_resized as the length of the resized tensor in axis x, roi_x = (start_x, end_x) of the axis x in input "roi", scale = length_resized / length_original, <br/>
+
+if coordinate_transformation_mode is "half_pixel", <br/>
+x_original = (x_resized + 0.5) / scale - 0.5, <br/>
+
+if coordinate_transformation_mode is "pytorch_half_pixel", <br/>
+x_original = length_resized > 1 ? (x_resized + 0.5) / scale - 0.5 : 0, <br/>
+
+if coordinate_transformation_mode is "align_corners", <br/>
+x_original = x_resized * (length_original - 1) / (length_resized - 1), <br/>
+
+if coordinate_transformation_mode is "asymmetric", <br/>
+x_original = x_resized / scale, <br/>
+
+if coordinate_transformation_mode is "tf_half_pixel_for_nn", <br/>
+x_original = (x_resized + 0.5) / scale, <br/>
+
+if coordinate_transformation_mode is "tf_crop_and_resize", <br/>
+x_original = length_resized > 1 ? start_x * (length_original - 1) + x_resized * (end_x - start_x) * (length_original - 1) / (length_resized - 1) : 0.5 * (start_x + end_x) * (length_original - 1).)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Resize,
+    11,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Three interpolation modes: nearest (default), linear and cubic. "
+            "The \"linear\" mode includes linear interpolation for 1D tensor and N-linear interpolation for N-D tensor (for example, bilinear interpolation for 2D tensor). "
+            "The \"cubic\" mode includes cubic interpolation for 1D tensor and N-cubic interpolation for N-D tensor (for example, bicubic interpolation for 2D tensor).",
+            AttributeProto::STRING,
+            std::string("nearest"))
+        .Attr(
+            "cubic_coeff_a",
+            "The coefficient 'a' used in cubic interpolation. Two common choice are -0.5 (in some cases of TensorFlow) and -0.75"
+            " (in PyTorch). Check out Equation (4) in https://ieeexplore.ieee.org/document/1163711 for the details. "
+            "This attribute is valid only if \"mode\" is \"cubic\".",
+            AttributeProto::FLOAT,
+            static_cast<float>(-0.75))
+        .Attr(
+            "exclude_outside",
+            "If set to 1, the weight of sampling locations outside the tensor will be set to 0"
+            " and the weight will be renormalized so that their sum is 1.0. The default value is 0.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "coordinate_transformation_mode",
+            Resize_attr_coordinate_transformation_mode_ver11_doc,
+            AttributeProto::STRING,
+            std::string("half_pixel"))
+        .Attr(
+            "nearest_mode",
+            "Four modes: round_prefer_floor (default, as known as round half down), round_prefer_ceil (as known as round half up), floor, ceil. Only used by nearest interpolation. It indicates how to get \"nearest\" pixel in input tensor from x_original, so this attribute is valid only if \"mode\" is \"nearest\".",
+            AttributeProto::STRING,
+            std::string("round_prefer_floor"))
+        .Attr(
+            "extrapolation_value",
+            "When coordinate_transformation_mode is \"tf_crop_and_resize\" and x_original is outside the range [0, length_original - 1], this value is used as the corresponding output value. Default is 0.0f.",
+            AttributeProto::FLOAT,
+            static_cast<float>(0))
+        .Input(0, "X", "N-D tensor", "T1")
+        .Input(
+            1,
+            "roi",
+            "1-D tensor given as [start1, ..., startN, end1, ..., endN], where N is the rank of X. The RoIs' coordinates are normalized in the coordinate system of the input image. It only takes effect when coordinate_transformation_mode is \"tf_crop_and_resize\"",
+            "T2")
+        .Input(
+            2,
+            "scales",
+            "The scale array along each dimension. It takes value greater than 0. If it's less than 1,"
+            " it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should"
+            " be the same as the rank of input 'X'. If 'size' is needed, the user must set 'scales' to an empty tensor.",
+            "tensor(float)")
+        .Input(
+            3,
+            "sizes",
+            "The size of the output tensor. The number of elements of 'sizes' should be the same as the"
+            " rank of input 'X'. May only be set if 'scales' is set to an empty tensor.",
+            "tensor(int64)",
+            OpSchema::Optional)
+        .Output(0, "Y", "N-D tensor after resizing", "T1")
+        .TypeConstraint("T1", OpSchema::all_tensor_types(), "Constrain input 'X' and output 'Y' to all tensor types.")
+        .TypeConstraint("T2", {types::Float16, types::Float, types::Double}, "Constrain roi type to float or double.")
+        .SetDoc(Resize_ver11_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset11_to_12(ctx); }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Identity,
+    24,
+    OpSchema()
+        .SetDoc("Identity operator")
+        .Input(0, "input", "Input tensor", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Tensor to copy input into.", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types_ir12();
+              auto s = OpSchema::all_tensor_sequence_types();
+              auto o = OpSchema::all_optional_types();
+              t.insert(t.end(), s.begin(), s.end());
+              t.insert(t.end(), o.begin(), o.end());
+              return t;
+            }(),
+            "Constrain input and output types to all tensor, sequence, and optional types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Identity,
+    23,
+    OpSchema()
+        .SetDoc("Identity operator")
+        .Input(0, "input", "Input tensor", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Tensor to copy input into.", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types_ir11();
+              auto s = OpSchema::all_tensor_sequence_types();
+              auto o = OpSchema::all_optional_types();
+              t.insert(t.end(), s.begin(), s.end());
+              t.insert(t.end(), o.begin(), o.end());
+              return t;
+            }(),
+            "Constrain input and output types to all tensor, sequence, and optional types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Identity,
+    21,
+    OpSchema()
+        .SetDoc("Identity operator")
+        .Input(0, "input", "Input tensor", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Tensor to copy input into.", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types_ir10();
+              auto s = OpSchema::all_tensor_sequence_types();
+              auto o = OpSchema::all_optional_types();
+              t.insert(t.end(), s.begin(), s.end());
+              t.insert(t.end(), o.begin(), o.end());
+              return t;
+            }(),
+            "Constrain input and output types to all tensor, sequence, and optional types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Identity,
+    19,
+    OpSchema()
+        .SetDoc("Identity operator")
+        .Input(0, "input", "Input tensor", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Tensor to copy input into.", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types_ir9();
+              auto s = OpSchema::all_tensor_sequence_types();
+              auto o = OpSchema::all_optional_types();
+              t.insert(t.end(), s.begin(), s.end());
+              t.insert(t.end(), o.begin(), o.end());
+              return t;
+            }(),
+            "Constrain input and output types to all tensor, sequence, and optional types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Identity,
+    13,
+    OpSchema()
+        .SetDoc("Identity operator")
+        .Input(0, "input", "Input tensor", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Tensor to copy input into.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Identity,
+    1,
+    OpSchema()
+        .SetDoc("Identity operator")
+        .Input(0, "input", "Input tensor", "T")
+        .Output(0, "output", "Tensor to copy input into.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    IsNaN,
+    9,
+    OpSchema()
+        .SetDoc(R"DOC(Returns which elements of the input are NaN.)DOC")
+        .Input(0, "X", "input", "T1")
+        .Output(0, "Y", "output", "T2")
+        .TypeConstraint("T1", {types::Float16, types::Float, types::Double}, "Constrain input types to float tensors.")
+        .TypeConstraint("T2", {types::Bool}, "Constrain output types to boolean tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          updateOutputElemType(ctx, 0, TensorProto::BOOL);
+          if (hasInputShape(ctx, 0)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    IsNaN,
+    13,
+    OpSchema()
+        .SetDoc(R"DOC(Returns which elements of the input are NaN.)DOC")
+        .Input(0, "X", "input", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "output", "T2", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint(
+            "T1",
+            {types::Float16, types::Float, types::Double, types::BFloat16},
+            "Constrain input types to float tensors.")
+        .TypeConstraint("T2", {types::Bool}, "Constrain output types to boolean tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          updateOutputElemType(ctx, 0, TensorProto::BOOL);
+          if (hasInputShape(ctx, 0)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    IsInf,
+    10,
+    OpSchema()
+        .SetDoc(R"DOC(Map infinity to true and other values to false.)DOC")
+        .Input(0, "X", "input", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Y", "output", "T2", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr(
+            "detect_positive",
+            "(Optional) Whether map positive infinity to true. Default to 1 "
+            "so that positive infinity induces true. Set this attribute to 0 "
+            "if positive infinity should be mapped to false.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .Attr(
+            "detect_negative",
+            "(Optional) Whether map negative infinity to true. Default to 1 "
+            "so that negative infinity induces true. Set this attribute to 0 "
+            "if negative infinity should be mapped to false.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeConstraint("T1", {types::Float, types::Double}, "Constrain input types to float tensors.")
+        .TypeConstraint("T2", {types::Bool}, "Constrain output types to boolean tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          updateOutputElemType(ctx, 0, TensorProto::BOOL);
+          if (hasInputShape(ctx, 0)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+const char* NonZero_ver9_doc = R"DOC(
+    Returns the indices of the elements that are non-zero
+    (in row-major order - by dimension).
+    NonZero behaves similar to numpy.nonzero:
+    https://docs.scipy.org/doc/numpy/reference/generated/numpy.nonzero.html,
+    but for scalar input, NonZero produces output shape (0, N) instead of (1, N), which is different from Numpy's behavior.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    NonZero,
+    9,
+    OpSchema()
+        .SetDoc(NonZero_ver9_doc)
+        .Input(0, "X", "input", "T")
+        .Output(0, "Y", "output", "tensor(int64)")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          updateOutputElemType(ctx, 0, TensorProto::INT64);
+          TensorShapeProto output_shape;
+          auto dim = output_shape.add_dim();
+          if (hasInputShape(ctx, 0)) {
+            const TensorShapeProto& input_shape = getInputShape(ctx, 0);
+            dim->set_dim_value(input_shape.dim_size());
+          }
+          output_shape.add_dim();
+          updateOutputShape(ctx, 0, output_shape);
+        }));
+
+static constexpr const char* GatherND_ver12_doc = R"DOC(
+Given `data` tensor of rank `r` >= 1, `indices` tensor of rank `q` >= 1, and `batch_dims` integer `b`, this operator gathers
+slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1 - b`.
+
+`indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
+where each element defines a slice of `data`
+
+`batch_dims` (denoted as `b`) is an integer indicating the number of batch dimensions, i.e the leading `b` number of dimensions of
+`data` tensor and `indices` are representing the batches, and the gather starts from the `b+1` dimension.
+
+Some salient points about the inputs' rank and shape:
+
+1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`
+
+2) The first `b` dimensions of the shape of `indices` tensor and `data` tensor must be equal.
+
+3) b < min(q, r) is to be honored.
+
+4) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r-b` (inclusive)
+
+5) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
+   It is an error if any of the index values are out of bounds.
+
+The output is computed as follows:
+
+The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.
+
+1) If `indices_shape[-1] > r-b` => error condition
+
+2) If `indices_shape[-1] == r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensors
+   containing 1-D tensors of dimension `r-b`, where `N` is an integer equals to the product of 1 and all the elements in the batch dimensions
+   of the indices_shape. Let us think of each such `r-b` ranked tensor as `indices_slice`. Each *scalar value* corresponding to `data[0:b-1,indices_slice]`
+   is filled into the corresponding location of the `(q-b-1)`-dimensional tensor to form the `output` tensor (Example 1 below)
+
+3) If `indices_shape[-1] < r-b`, since the rank of `indices` is `q`, `indices` can be thought of as `N` `(q-b-1)`-dimensional tensor
+   containing 1-D tensors of dimension `< r-b`. Let us think of each such tensors as `indices_slice`. Each *tensor slice* corresponding
+   to `data[0:b-1, indices_slice , :]` is filled into the corresponding location of the `(q-b-1)`-dimensional tensor
+   to form the `output` tensor (Examples 2, 3, 4 and 5 below)
+
+This operator is the inverse of `ScatterND`.
+
+`Example 1`
+
+  batch_dims = 0
+
+  data    = [[0,1],[2,3]]   # data_shape = [2, 2]
+
+  indices = [[0,0],[1,1]]   # indices_shape = [2, 2]
+
+  output  = [0,3]           # output_shape = [2]
+
+`Example 2`
+
+  batch_dims = 0
+
+  data    = [[0,1],[2,3]]  # data_shape = [2, 2]
+
+  indices = [[1],[0]]      # indices_shape = [2, 1]
+
+  output  = [[2,3],[0,1]]  # output_shape = [2, 2]
+
+`Example 3`
+
+  batch_dims = 0
+
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+  indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]
+
+  output  = [[2,3],[4,5]]                 # output_shape = [2, 2]
+
+`Example 4`
+
+  batch_dims = 0
+
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+  indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]
+
+  output  = [[[2,3]],[[4,5]]]             # output_shape = [2, 1, 2]
+
+`Example 5`
+
+  batch_dims = 1
+
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+  indices = [[1],[0]]             # indices_shape = [2, 1]
+
+  output  = [[2,3],[4,5]]             # output_shape = [2, 2]
+
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GatherND,
+    12,
+    OpSchema()
+        .SetDoc(GatherND_ver12_doc)
+        .Attr(
+            "batch_dims",
+            "The number of batch dimensions. The gather of indexing starts from dimension of data[batch_dims:]",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T")
+        .Input(
+            1,
+            "indices",
+            "Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] "
+            "along axis of size s. It is an error if any of the index values are out of bounds.",
+            "tensor(int64)")
+        .Output(0, "output", "Tensor of rank q + r - indices_shape[-1] - 1.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          if (!hasNInputShapes(ctx, 2)) {
+            // cannot proceed with shape or rank inference
+            return;
+          }
+
+          const auto& data_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto data_rank = data_shape.dim_size();
+
+          const auto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
+          const auto indices_rank = indices_shape.dim_size();
+
+          int64_t batch_dims_data = getAttribute(ctx, "batch_dims", 0);
+          if (data_rank < 1 || indices_rank < 1) {
+            fail_shape_inference(
+                "Both `data` and `indices` input tensors in GatherND op "
+                "need to have rank larger than 0.");
+          }
+
+          // cannot ascertain if the input shapes are valid if shape of
+          // `indices` is missing last dimension value so return at this point
+          if (!indices_shape.dim(indices_rank - 1).has_dim_value()) {
+            return;
+          }
+
+          const auto last_index_dimension = indices_shape.dim(indices_rank - 1).dim_value() + batch_dims_data;
+
+          if (last_index_dimension > data_rank) {
+            fail_shape_inference(
+                "Last dimension of `indices` input tensor in GatherND op "
+                "must not be larger than the rank of `data` tensor");
+          }
+
+          for (int i = 0; i < indices_rank - 1; ++i) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = indices_shape.dim(i);
+          }
+
+          for (int i = static_cast<int>(last_index_dimension); i < data_rank; ++i) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = data_shape.dim(i);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    24,
+    OpSchema().FillUsing(PadDocGenerator(
+        kDoc_Pad_ver24,
+        "Supported modes: `constant`(default), `reflect`, `edge`, `wrap`",
+        OpSchema::all_tensor_types_ir12(),
+        "Constrain input and output types to all tensor types up to IRv12.")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    23,
+    OpSchema().FillUsing(PadDocGenerator(
+        kDoc_Pad_ver24,
+        "Supported modes: `constant`(default), `reflect`, `edge`, `wrap`",
+        OpSchema::all_tensor_types_ir11(),
+        "Constrain input and output types to all tensor types up to IRv11.")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    21,
+    OpSchema().FillUsing(PadDocGenerator(
+        kDoc_Pad_ver24,
+        "Supported modes: `constant`(default), `reflect`, `edge`, `wrap`",
+        OpSchema::all_tensor_types_ir10(),
+        "Constrain input and output types to all tensor types up to IRv10.")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    19,
+    OpSchema().FillUsing(
+        PadDocGenerator(kDoc_Pad_ver24, "Supported modes: `constant`(default), `reflect`, `edge`, `wrap`")));
+
+static constexpr const char* Pad_ver11_doc = R"DOC(
+Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+a padded tensor (`output`) is generated.
+
+The three supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0)
+
+2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+3) `edge` - pads with the edge values of array
+
+
+Example 1 (`constant` mode):
+  Insert 0 pads to the beginning of the second dimension.
+
+  data =
+  [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'constant'
+
+  constant_value = 0.0
+
+  output =
+  [
+      [0.0, 0.0, 1.0, 1.2],
+      [0.0, 0.0, 2.3, 3.4],
+      [0.0, 0.0, 4.5, 5.7],
+  ]
+
+
+Example 2 (`reflect` mode):
+  data =
+  [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'reflect'
+
+  output =
+  [
+      [1.0, 1.2, 1.0, 1.2],
+      [2.3, 3.4, 2.3, 3.4],
+      [4.5, 5.7, 4.5, 5.7],
+  ]
+
+
+Example 3 (`edge` mode):
+  data =
+  [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'edge'
+
+  output =
+  [
+      [1.0, 1.0, 1.0, 1.2],
+      [2.3, 2.3, 2.3, 3.4],
+      [4.5, 4.5, 4.5, 5.7],
+  ]
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    11,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Supported modes: `constant`(default), `reflect`, `edge`",
+            AttributeProto::STRING,
+            std::string("constant"))
+        .SetDoc(Pad_ver11_doc)
+        .Input(0, "data", "Input tensor.", "T")
+        .Input(
+            1,
+            "pads",
+            "Tensor of integers indicating the number of padding elements to add or remove (if negative) "
+            "at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. "
+            "`pads` should be a 1D tensor of shape [2 * input_rank]. "
+            "`pads` format should be: [x1_begin, x2_begin,...,x1_end, x2_end,...], "
+            "where xi_begin is the number of pad values added at the beginning of axis `i` and "
+            "xi_end, the number of pad values added at the end of axis `i`.",
+            "tensor(int64)")
+        .Input(
+            2,
+            "constant_value",
+            "(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0).",
+            "T",
+            OpSchema::Optional)
+        .Output(0, "output", "Tensor after padding.", "T")
+        .TypeConstraint("T", OpSchema::all_numeric_types(), "Constrain input and output to only numeric types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // Shape inference needs the input data shape
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_rank = input_shape.dim_size();
+
+          // Infer output shape if 'pads' tensor is available
+          const auto pads_initializer = ctx.getInputData(1);
+          if (nullptr != pads_initializer) {
+            if (pads_initializer->dims_size() != 1 || pads_initializer->data_type() != TensorProto::INT64) {
+              fail_shape_inference("'pads' input must be a 1D (shape: [2 * input_rank]) tensor of type int64");
+            }
+
+            const auto pads_data = ParseData<int64_t>(pads_initializer);
+            if (pads_data.size() != static_cast<size_t>(2 * input_rank)) {
+              fail_shape_inference("Pads has incorrect number of values");
+            }
+
+            auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+            for (int i = 0; i < input_rank; ++i) {
+              const auto& input_dim = input_shape.dim(i);
+              auto output_dim = output_shape->add_dim();
+              if (input_dim.has_dim_value()) {
+                output_dim->set_dim_value(input_dim.dim_value() + pads_data[i] + pads_data[i + input_rank]);
+              } else if (pads_data[i] + pads_data[i + input_rank] == 0) {
+                *output_dim = input_dim;
+              }
+            }
+          } else {
+            // Infer output shapes' rank in any case
+            auto output_shape_0 = getOutputShape(ctx, 0);
+            for (int i = 0; i < input_rank; ++i) {
+              output_shape_0->add_dim();
+            }
+          }
+          return;
+        }));
+
+static constexpr const char* Cast_ver1_doc = R"DOC(
+The operator casts the elements of a given input tensor to a data type
+specified by the 'to' argument and returns an output tensor of the same size in
+the converted type. The 'to' argument must be one of the data types specified
+in the 'DataType' enum field in the TensorProto message.
+NOTE: Casting to and from strings is not supported yet.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cast,
+    1,
+    OpSchema()
+        .SetDoc(Cast_ver1_doc)
+        .Attr(
+            "to",
+            "The data type to which the elements of the input tensor are cast. "
+            "Strictly must be one of the types from DataType enum in TensorProto",
+            AttributeProto::STRING)
+        .Input(0, "input", "Input tensor to be cast.", "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as input with type "
+            "specified by the 'to' argument",
+            "T2")
+        .TypeConstraint(
+            "T1",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool},
+            "Constrain input types. Casting from strings and complex are not supported.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool},
+            "Constrain output types. Casting to strings and complex are not supported."));
+
+static const char* const Cast_ver6_doc = Cast_ver1_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Cast,
+    6,
+    OpSchema()
+        .SetDoc(Cast_ver6_doc)
+        .Attr(
+            "to",
+            "The data type to which the elements of the input tensor are cast. "
+            "Strictly must be one of the types from DataType enum in TensorProto",
+            AttributeProto::INT)
+        .Input(0, "input", "Input tensor to be cast.", "T1")
+        .Output(
+            0,
+            "output",
+            "Output tensor with the same shape as input with type "
+            "specified by the 'to' argument",
+            "T2")
+        .TypeConstraint(
+            "T1",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool},
+            "Constrain input types. Casting from strings and complex are not supported.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16,
+             types::Float,
+             types::Double,
+             types::Int8,
+             types::Int16,
+             types::Int32,
+             types::Int64,
+             types::UInt8,
+             types::UInt16,
+             types::UInt32,
+             types::UInt64,
+             types::Bool},
+            "Constrain output types. Casting to strings and complex are not supported.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromAttributeToOutput(ctx, "to", 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* Concat_ver1_doc = R"DOC(Concatenate a list of tensors into a single tensor)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Concat,
+    1,
+    OpSchema()
+        .Attr("axis", "Which axis to concat on.  Default value is 1.", AttributeProto::INT, OPTIONAL_VALUE)
+        .SetDoc(Concat_ver1_doc)
+        .Input(0, "inputs", "List of tensors for concatenation", "T", OpSchema::Variadic)
+        .Output(0, "concat_result", "Concatenated tensor", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain output types to float tensors."));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Concat,
+    4,
+    OpSchema()
+        .Attr("axis", "Which axis to concat on", AttributeProto::INT)
+        .SetDoc("Concatenate a list of tensors into a single tensor")
+        .Input(0, "inputs", "List of tensors for concatenation", "T", OpSchema::Variadic)
+        .Output(0, "concat_result", "Concatenated tensor", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto numInputs = ctx.getNumInputs();
+          if (numInputs < 1 || !hasNInputShapes(ctx, numInputs)) {
+            return;
+          }
+
+          auto rank = ctx.getInputType(0)->tensor_type().shape().dim_size();
+
+          auto axisAttr = ctx.getAttribute("axis");
+          if (!axisAttr) {
+            fail_shape_inference("Required attribute axis is missing");
+          }
+          int axis = static_cast<int>(axisAttr->i());
+          if (rank <= axis) {
+            fail_shape_inference("rank must be greater than axis");
+          }
+          if (axis < 0) {
+            return;
+          }
+
+          bool all_lengths_known = true;
+          int total_length = 0;
+
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int64_t i = 0; i < rank; ++i) {
+            output_shape->add_dim();
+          }
+
+          for (size_t i = 0; i < numInputs; i++) {
+            const auto& shape = ctx.getInputType(i)->tensor_type().shape();
+            if (shape.dim_size() != rank) {
+              fail_shape_inference("All inputs to Concat must have same rank");
+            }
+            for (int j = 0; j < rank; j++) {
+              if (j == axis) {
+                if (shape.dim(j).has_dim_value()) {
+                  total_length += static_cast<int>(shape.dim(j).dim_value());
+                } else {
+                  all_lengths_known = false;
+                }
+              } else {
+                auto& output_dim = *output_shape->mutable_dim(j);
+                const auto& input_dim = shape.dim(j);
+                mergeInDimensionInfo(input_dim, output_dim, j);
+              }
+            }
+          }
+
+          if (all_lengths_known) {
+            output_shape->mutable_dim(axis)->set_dim_value(total_length);
+          }
+        }));
+
+static constexpr const char* Split_ver1_doc =
+    R"DOC(Split a tensor into a list of tensors, along the specified
+'axis'. The lengths of the split can be specified using argument 'axis' or
+optional second input blob to the operator. Otherwise, the tensor is split
+to equal sized parts.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Split,
+    1,
+    OpSchema()
+        .Input(0, "input", "The tensor to split", "T")
+        .Input(1, "split", "Optional list of output lengths (see also arg 'split')", "T", OpSchema::Optional)
+        .Output(0, "outputs...", "One or more outputs forming list of tensors after splitting", "T", OpSchema::Variadic)
+        .TypeConstraint("T", {types::Float16, types::Float, types::Double}, "Constrain input types to float tensors.")
+        .Attr("axis", "Which axis to split on", AttributeProto::INT, OPTIONAL_VALUE)
+        .Attr("split", "length of each output", AttributeProto::INTS, OPTIONAL_VALUE)
+        .SetDoc(Split_ver1_doc));
+
+static constexpr const char* Pad_ver1_doc = R"DOC(
+Given `data` tensor, paddings, mode, and value.
+Example:
+  Insert 0 paddings to the beginning of the second dimension.
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+  paddings = [0, 0, 2, 0]
+  output = [
+      [
+          [0.0, 0.0, 1.0, 1.2],
+          [0.0, 0.0, 2.3, 3.4],
+          [0.0, 0.0, 4.5, 5.7],
+      ],
+  ]
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    1,
+    OpSchema()
+        .Attr(
+            "paddings",
+            "List of integers indicate the padding element count at the "
+            "beginning and end of each axis, for 2D it is the number of pixel. "
+            "`paddings` rank should be double of the input's rank. `paddings` format should be as follow "
+            "[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels "
+            "added at the beginning of axis `i` and xi_end, the number of pixels added at "
+            "the end of axis `i`.",
+            AttributeProto::INTS)
+        .Attr("mode", "Three modes: constant(default), reflect, edge", AttributeProto::STRING, std::string("constant"))
+        .Attr("value", "One float, indicates the value to be filled, default is 0", AttributeProto::FLOAT, 0.0f)
+        .SetDoc(Pad_ver1_doc)
+        .Input(0, "data", "Input tensor.", "T")
+        .Output(0, "output", "Tensor after padding.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Reshape_ver1_doc = R"DOC(
+Reshape the input tensor similar to numpy.reshape.
+It takes a tensor as input and an argument `shape`. It outputs the reshaped tensor.
+At most one dimension of the new shape can be -1. In this case, the value is
+inferred from the size of the tensor and the remaining dimensions. A dimension
+could also be 0, in which case the actual dimension value is unchanged (i.e. taken
+from the input tensor). Shape (second input) could be an empty shape, which means converting to a scalar.
+The input tensor's shape and the output tensor's shape are required to have the same number of elements.)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reshape,
+    1,
+    OpSchema()
+        .SetDoc(Reshape_ver1_doc)
+        .Attr("shape", "New shape", AttributeProto::INTS, OPTIONAL_VALUE)
+        // This attribute was added via AllowConsumed API in OpSchema.
+        // After removing the API, we're now using the Attr API to simulate the
+        // old definition.
+        .Attr("consumed_inputs", "legacy optimization attribute.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Input(0, "data", "An input tensor.", "T")
+        .Output(0, "reshaped", "Reshaped data.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors."));
+
+static constexpr const char* Upsample_ver1_doc = R"DOC(
+Upsample the input tensor.
+The width and height of the output tensor are:
+  output_width = floor(input_width * width_scale),
+  output_height = floor(input_height * height_scale).
+Example:
+  Given `data` tensor, width_scale, height_scale, mode,
+  Upsample the input 4-D tensor in nearest mode:
+  data = [[[
+      [1, 2],
+      [3, 4]
+  ]]]
+  width_scale = 2
+  height_scale = 2
+  mode = "nearest"
+  output = [[[
+      [1, 1, 2, 2],
+      [1, 1, 2, 2],
+      [3, 3, 4, 4],
+      [3, 3, 4, 4]
+  ]]]
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Tile,
+    1,
+    OpSchema()
+        .SetDoc("Repeat the elements of a tensor along an axis.")
+        .Input(0, "input", "Input tensor of any shape.", "T")
+        .Input(1, "tiles", "Number of repeated copies to make of the input tensor.", "T")
+        .Input(2, "axis", "Axis along which to repeat.", "T")
+        .Output(0, "output", "Output tensor of same shape and type as input.", "T")
+        .TypeConstraint("T", {types::Float16, types::Float, types::Double}, "Constrain input types to float tensors.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain tiles and axis's type to int64 tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // Only rank of output can be inferred. We can do better if second
+          // input is a constant, but this requires extending InferenceContext
+          // interface to get values of constant inputs.
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Upsample,
+    1,
+    OpSchema()
+        .SetSupportLevel(OpSchema::SupportType::EXPERIMENTAL)
+        .Attr(
+            "width_scale",
+            "The scale along width dimension. It takes value greater than or equal to 1.",
+            AttributeProto::FLOAT)
+        .Attr(
+            "height_scale",
+            "The scale along height dimension. It takes value greater than or equal to 1.",
+            AttributeProto::FLOAT)
+        .Attr(
+            "mode",
+            "Two interpolation modes: nearest(default), bilinear",
+            AttributeProto::STRING,
+            std::string("nearest"))
+        .Input(0, "X", "4-D tensor, [N,C,H,W]", "T")
+        .Output(0, "Y", "4-D tensor after resizing, [N,C,H,W]", "T")
+        .TypeConstraint(
+            "T",
+            {types::Bool, types::Int32, types::Int64, types::Float16, types::Float, types::Double},
+            "Constrain output types to bool, int32, int64, float16, float, double tensors.")
+        .SetDoc(Upsample_ver1_doc));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Upsample,
+    7,
+    OpSchema()
+        .Attr(
+            "scales",
+            "The scale array along each dimension. It takes value greater than or equal to 1."
+            " The number of elements of 'scales' should be the same as the rank of input 'X'.",
+            AttributeProto::FLOATS)
+        .Attr(
+            "mode",
+            "Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)",
+            AttributeProto::STRING,
+            std::string("nearest"))
+        .Input(0, "X", "N-D tensor", "T")
+        .Output(0, "Y", "N-D tensor after resizing", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .SetDoc(kDoc_Upsample_ver7)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          const auto& input_shape = getInputShape(ctx, 0);
+          auto output_shape = getOutputShape(ctx, 0);
+          const auto scales = ctx.getAttribute("scales");
+
+          if (output_shape->dim_size() > 0) {
+            if (output_shape->dim_size() != input_shape.dim_size()) {
+              fail_shape_inference(
+                  "Ranks inferred (",
+                  input_shape.dim_size(),
+                  ") is not equal to the existing rank value (",
+                  output_shape->dim_size(),
+                  ").");
+            }
+          } else { // Infer the rank of output anyway
+            for (int i = 0; i < input_shape.dim_size(); ++i) {
+              output_shape->add_dim();
+            }
+          }
+
+          if (nullptr != scales) {
+            // Infer output shape's dimension value if 'scales' is known.
+            if (scales->type() == AttributeProto_AttributeType_FLOATS) {
+              const std::vector<float> scales_data(scales->floats().begin(), scales->floats().end());
+              if (scales_data.size() != static_cast<size_t>(input_shape.dim_size())) {
+                fail_shape_inference("Number of elements of attribute 'scales' must be same as rank of input 'X'");
+              }
+              resizeShapeInferenceHelper_opset7_to_10(input_shape, scales_data, output_shape);
+            } else {
+              fail_shape_inference("Attribute 'scales' must have floats type.");
+            } // scales->type() == float
+          } else {
+            fail_shape_inference("Attribute 'scales' is required.");
+          } // nullptr != scales
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Upsample,
+    9,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)",
+            AttributeProto::STRING,
+            std::string("nearest"))
+        .Input(0, "X", "N-D tensor", "T")
+        .Input(
+            1,
+            "scales",
+            "The scale array along each dimension. It takes value greater than or equal to 1."
+            " The number of elements of 'scales' should be the same as the rank of input 'X'.",
+            "tensor(float)")
+        .Output(0, "Y", "N-D tensor after resizing", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input 'X' and output 'Y' to all tensor types.")
+        .SetDoc(kDoc_Upsample_ver7)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset7_to_10(ctx); }));
+
+static constexpr const char* Resize_ver10_doc = R"DOC(
+Resize the input tensor.
+Each dimension value of the output tensor is:
+  output_dimension = floor(input_dimension * scale).
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Resize,
+    10,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Two interpolation modes: nearest (default), and linear (including bilinear, trilinear, etc)",
+            AttributeProto::STRING,
+            std::string("nearest"))
+        .Input(0, "X", "N-D tensor", "T")
+        .Input(
+            1,
+            "scales",
+            "The scale array along each dimension. It takes value greater than 0. If it's less than 1,"
+            " it's sampling down, otherwise, it's upsampling. The number of elements of 'scales' should"
+            " be the same as the rank of input 'X'.",
+            "tensor(float)")
+        .Output(0, "Y", "N-D tensor after resizing", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input 'X' and output 'Y' to all tensor types.")
+        .SetDoc(Resize_ver10_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { resizeShapeInference_opset7_to_10(ctx); }));
+
+static constexpr const char* Slice_ver1_doc = R"DOC(
+Produces a slice of the input tensor along multiple axes. Similar to numpy:
+https://numpy.org/doc/stable/reference/routines.indexing.html
+Slices uses `axes`, `starts` and `ends` attributes to specify the start and end
+dimension for each axis in the list of axes, it uses this information to
+slice the input `data` tensor. If a negative value is passed for any of the
+start or end indices, it represent number of elements before the end of that
+dimension. If the value passed to start or end is larger than the `n` (the
+number of elements in this dimension), it represents `n`. For slicing to the
+end of a dimension with unknown size, it is recommended to pass in `INT_MAX`.
+If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
+Example 1:
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  axes = [0, 1]
+  starts = [1, 0]
+  ends = [2, 3]
+  result = [
+      [5, 6, 7],
+  ]
+Example 2:
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  starts = [0, 1]
+  ends = [-1, 1000]
+  result = [
+      [2, 3, 4],
+  ]
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Slice,
+    1,
+    OpSchema()
+        .SetDoc(Slice_ver1_doc)
+        .Input(0, "data", "Tensor of data to extract slices from.", "T")
+        .Attr(
+            "axes",
+            "Axes that `starts` and `ends` apply to. "
+            "It's optional. If not present, will be treated as "
+            "[0, 1, ..., len(`starts`) - 1].",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("starts", "Starting indices of corresponding axis in `axes`", AttributeProto::INTS)
+        .Attr("ends", "Ending indices (exclusive) of corresponding axis in axes`", AttributeProto::INTS)
+        .Output(0, "output", "Sliced data tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          std::vector<int64_t> starts;
+          std::vector<int64_t> ends;
+          if (!getRepeatedAttribute(ctx, "starts", starts) || !getRepeatedAttribute(ctx, "ends", ends) ||
+              starts.size() != ends.size()) {
+            fail_shape_inference("Incorrect or missing attribute value for starts and ends");
+          }
+
+          std::vector<int64_t> axes;
+          if (!getRepeatedAttribute(ctx, "axes", axes)) {
+            for (size_t i = 0; i < starts.size(); ++i) {
+              axes.push_back(i);
+            }
+          } else if (axes.size() != starts.size()) {
+            fail_shape_inference("Attribute axes has incorrect length");
+          } else if (!std::is_sorted(axes.begin(), axes.end())) {
+            // TODO(ONNX) support shape inference for unsorted axes
+            return;
+          }
+
+          auto is_negative = [](int64_t index) { return index < 0; };
+          if (std::any_of(axes.begin(), axes.end(), is_negative)) {
+            // Negative axes were not explicitly discussed in the spec before opset-10.
+            // Hence, they are officially not part of the spec, but some models/runtimes may use them.
+            // So we perform simple rank inference in this case.
+            for (size_t i = 0; static_cast<int64_t>(i) < ctx.getInputType(0)->tensor_type().shape().dim_size(); ++i) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+            }
+            return;
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (size_t i = 0, j = 0; static_cast<int64_t>(i) < ctx.getInputType(0)->tensor_type().shape().dim_size();
+               ++i) {
+            auto newdim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+            if (j < axes.size() && static_cast<size_t>(axes[j]) == i) {
+              // There's a lot of potential behaviors. For now just
+              // handle some simple cases.
+              const auto& dim = ctx.getInputType(0)->tensor_type().shape().dim(i);
+              if (dim.has_dim_value()) {
+                auto dim_value = dim.dim_value();
+                if (starts[j] < 0) {
+                  starts[j] += dim_value;
+                }
+                if (ends[j] < 0) {
+                  ends[j] += dim_value;
+                }
+                if (starts[j] >= 0 && ends[j] >= 0) {
+                  auto newval = std::min(dim_value, ends[j]) - starts[j];
+                  if (newval >= 0) {
+                    newdim->set_dim_value(newval);
+                  }
+                }
+              }
+              ++j;
+            } else {
+              *newdim = ctx.getInputType(0)->tensor_type().shape().dim(i);
+            }
+          }
+        }));
+
+static constexpr const char* Slice_ver10_doc = R"DOC(
+Produces a slice of the input tensor along multiple axes. Similar to numpy:
+https://numpy.org/doc/stable/reference/routines.indexing.html
+Slices uses `starts`, `ends`, `axes` and `steps` inputs to specify the start and end
+dimension and step for each axis in the list of axes, it uses this information to
+slice the input `data` tensor. If a negative value is passed for any of the
+start or end indices, it represent number of elements before the end of that
+dimension. If the value passed to start or end is larger than the `n` (the
+number of elements in this dimension), it represents `n`. For slicing to the
+end of a dimension with unknown size, it is recommended to pass in `INT_MAX`.
+If a negative value is passed for step, it represents slicing backward.
+If `axes` are omitted, they are set to `[0, ..., ndim-1]`.
+If `steps` are omitted, they are set to `[1, ..., 1]` of length `len(starts)`
+Example 1:
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  axes = [0, 1]
+  starts = [1, 0]
+  ends = [2, 3]
+  steps = [1, 2]
+  result = [
+      [5, 7],
+  ]
+Example 2:
+  data = [
+      [1, 2, 3, 4],
+      [5, 6, 7, 8],
+  ]
+  starts = [0, 1]
+  ends = [-1, 1000]
+  result = [
+      [2, 3, 4],
+  ]
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Slice,
+    10,
+    OpSchema()
+        .SetDoc(Slice_ver10_doc)
+        .Input(0, "data", "Tensor of data to extract slices from.", "T")
+        .Input(1, "starts", "1-D tensor of starting indices of corresponding axis in `axes`", "Tind")
+        .Input(2, "ends", "1-D tensor of ending indices (exclusive) of corresponding axis in `axes`", "Tind")
+        .Input(3, "axes", "1-D tensor of axes that `starts` and `ends` apply to.", "Tind", OpSchema::Optional)
+        .Input(
+            4,
+            "steps",
+            "1-D tensor of slice step of corresponding axis in `axes`. Default to 1. ",
+            "Tind",
+            OpSchema::Optional)
+        .Output(0, "output", "Sliced data tensor.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          size_t num_inputs = ctx.getNumInputs();
+          if (num_inputs != 3 && num_inputs != 4 && num_inputs != 5) {
+            fail_type_inference("Slice op must have either three, four or five inputs.");
+          }
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          // Shape Inference if
+          //     1. 2nd and 3rd input data (starts, ends) are available.
+          // and 2. 4th and 5th optional input (axes, steps) are either not set,
+          // or set and is initializer.
+          const TensorProto* startsInitializer = ctx.getInputData(1);
+          const TensorProto* endsInitializer = ctx.getInputData(2);
+          const TensorProto* axesInitializer = hasInputShape(ctx, 3) ? ctx.getInputData(3) : nullptr;
+          const TensorProto* stepsInitializer = hasInputShape(ctx, 4) ? ctx.getInputData(4) : nullptr;
+
+          if (!startsInitializer || !endsInitializer || (hasInputShape(ctx, 3) && !ctx.getInputData(3)) ||
+              (hasInputShape(ctx, 4) && !ctx.getInputData(4))) {
+            const auto input_rank = ctx.getInputType(0)->tensor_type().shape().dim_size();
+            // we can infer the output rank - it never changes
+            for (int i = 0; i < input_rank; ++i) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+            }
+            return;
+          }
+
+          // don't know data_type- can't proceed
+          if (!startsInitializer->has_data_type())
+            return;
+
+          auto get_initializer_data = [](const TensorProto* initializer) -> std::vector<int64_t> {
+            std::vector<int64_t> vec;
+            if (initializer->data_type() == TensorProto::INT64) {
+              const auto data = ParseData<int64_t>(initializer);
+              vec.insert(vec.end(), data.begin(), data.end());
+            } else if (initializer->data_type() == TensorProto::INT32) {
+              const auto data = ParseData<int32_t>(initializer);
+              vec.insert(vec.end(), data.begin(), data.end());
+            } else {
+              // unaccepted data type
+              fail_shape_inference("Only supports `int32_t` or `int64_t` inputs for starts/ends/axes/steps");
+            }
+            return vec;
+          };
+
+          std::vector<int64_t> starts = get_initializer_data(startsInitializer);
+          std::vector<int64_t> ends = get_initializer_data(endsInitializer);
+
+          if (starts.size() != ends.size()) {
+            fail_shape_inference("Incorrect or missing input value for starts and ends");
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_rank = input_shape.dim_size();
+          std::vector<int64_t> axes(starts.size());
+          if (!axesInitializer) {
+            std::iota(axes.begin(), axes.end(), 0);
+          } else {
+            axes = get_initializer_data(axesInitializer);
+            if (axes.size() != starts.size()) {
+              fail_shape_inference("Input axes has incorrect length");
+            }
+          }
+
+          std::vector<int64_t> steps;
+          if (!stepsInitializer) {
+            steps = std::vector<int64_t>(starts.size(), 1);
+          } else {
+            steps = get_initializer_data(stepsInitializer);
+            if (steps.size() != axes.size()) {
+              fail_shape_inference("Input steps has incorrect length");
+            }
+          }
+
+          for (int i = 0; i < input_rank; ++i) {
+            // first update rank of output dim
+            auto output_dim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+            const auto& input_dim = input_shape.dim(i);
+            if (input_dim.has_dim_value()) {
+              output_dim->set_dim_value(input_dim.dim_value());
+            } else if (input_dim.has_dim_param()) {
+              output_dim->set_dim_param(input_dim.dim_param());
+            }
+          }
+
+          std::unordered_set<int64_t> unique_axes;
+          size_t axes_size = axes.size();
+          for (size_t axis_index = 0; axis_index < axes_size; ++axis_index) {
+            auto axis = axes[axis_index] < 0 ? axes[axis_index] + static_cast<int64_t>(input_rank) : axes[axis_index];
+
+            if (axis >= static_cast<int64_t>(input_rank) || axis < 0) {
+              fail_shape_inference("Input axes has invalid data");
+            }
+
+            if (unique_axes.find(axis) != unique_axes.end()) {
+              fail_shape_inference("'axes' has duplicates");
+            }
+
+            unique_axes.insert(axis);
+            auto input_dim = ctx.getInputType(0)->tensor_type().shape().dim(axis);
+
+            // input dim value is missing - cannot perform shape inference for
+            // this axis
+            if (!input_dim.has_dim_value())
+              continue;
+
+            const auto input_dim_value = input_dim.dim_value();
+
+            // Empty dimension: clamp bounds are invalid when dimension size is 0,
+            // so short-circuit to produce a zero-length output.
+            if (input_dim_value == 0) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->set_dim_value(0);
+              continue;
+            }
+
+            // process step
+            auto step = steps[axis_index];
+            if (step == 0) {
+              fail_shape_inference("'step' cannot be 0");
+            }
+
+            // process start
+            auto start = starts[axis_index];
+            if (start < 0)
+              start += input_dim_value;
+            if (step < 0)
+              start = std::clamp(start, static_cast<int64_t>(0), input_dim_value - 1);
+            else
+              start = std::clamp(start, static_cast<int64_t>(0), input_dim_value);
+
+            // process end
+            auto end = ends[axis_index];
+            if (end < static_cast<int64_t>(0))
+              end += input_dim_value;
+            if (step < static_cast<int64_t>(0))
+              end = std::clamp(end, static_cast<int64_t>(-1), input_dim_value);
+            else
+              end = std::clamp(end, static_cast<int64_t>(0), input_dim_value);
+
+            // find output dim value for this axis
+            auto temp = static_cast<int64_t>(ceil(1.0 * (end - start) / step));
+            if (temp < 0)
+              temp = 0;
+
+            // assign output value
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->set_dim_value(temp);
+          }
+        }));
+
+static constexpr const char* Scatter_ver9_doc = R"DOC(
+Given `data`, `updates` and `indices` input tensors of rank r >= 1, write the values provided by `updates`
+into the first input, `data`, along `axis` dimension of `data` (by default outer-most one as axis=0) at corresponding `indices`.
+For each entry in `updates`, the target index in `data` is specified by corresponding entry in `indices`
+for dimension = axis, and index in source for dimension != axis. For instance, in a 2-D tensor case,
+data[indices[i][j]][j] = updates[i][j] if axis = 0, or data[i][indices[i][j]] = updates[i][j] if axis = 1,
+where i and j are loop counters from 0 up to the respective size in `updates` - 1.
+Example 1:
+  data = [
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+      [0.0, 0.0, 0.0],
+  ]
+  indices = [
+      [1, 0, 2],
+      [0, 2, 1],
+  ]
+  updates = [
+      [1.0, 1.1, 1.2],
+      [2.0, 2.1, 2.2],
+  ]
+  output = [
+      [2.0, 1.1, 0.0]
+      [1.0, 0.0, 2.2]
+      [0.0, 2.1, 1.2]
+  ]
+Example 2:
+  data = [[1.0, 2.0, 3.0, 4.0, 5.0]]
+  indices = [[1, 3]]
+  updates = [[1.1, 2.1]]
+  axis = 1
+  output = [[1.0, 1.1, 3.0, 2.1, 5.0]]
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Scatter,
+    9,
+    OpSchema()
+        .SetDoc(Scatter_ver9_doc)
+        .Attr(
+            "axis",
+            "Which axis to scatter on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1]",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T")
+        .Input(1, "indices", "Tensor of int32/int64 indices, of r >= 1 (same rank as input).", "Tind")
+        .Input(2, "updates", "Tensor of rank r >=1 (same rank and shape as indices)", "T")
+        .Output(0, "output", "Tensor of rank r >= 1 (same rank as input).", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Input and output types can be of any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 1)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* DepthToSpace_ver1_doc =
+    R"DOC(DepthToSpace rearranges (permutes) data from depth into blocks of spatial data.
+This is the reverse transformation of SpaceToDepth. More specifically, this op outputs a copy of
+the input tensor where values from the depth dimension are moved in spatial blocks to the height
+and width dimensions.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    DepthToSpace,
+    1,
+    OpSchema()
+        .Attr("blocksize", "Blocks of [blocksize, blocksize] are moved.", AttributeProto::INT)
+        .SetDoc(DepthToSpace_ver1_doc)
+        .Input(
+            0,
+            "input",
+            "Input tensor of [N,C,H,W], where N is the batch axis, C is the channel or depth"
+            ", H is the height and W is the width.",
+            "T")
+        .Output(0, "output", "Output tensor of [N, C/(blocksize * blocksize), H * blocksize, W * blocksize].", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          auto blocksize = getAttribute(ctx, "blocksize", 0);
+          if (blocksize <= 0) {
+            fail_shape_inference("Blocksize must be positive");
+          }
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = getInputShape(ctx, 0);
+            if (input_shape.dim_size() == 4) {
+              updateOutputShape(
+                  ctx,
+                  0,
+                  {input_shape.dim(0),
+                   input_shape.dim(1) / (blocksize * blocksize),
+                   input_shape.dim(2) * blocksize,
+                   input_shape.dim(3) * blocksize});
+            } else {
+              fail_shape_inference("Input tensor must be 4-dimensional");
+            }
+          }
+        }));
+
+static constexpr const char* Gather_ver1_doc = R"DOC(
+Given `data` tensor of rank r >= 1, and `indices` tensor of rank q, gather
+entries of the axis dimension of `data` (by default outer-most one as axis=0) indexed by `indices`, and concatenates
+them in an output tensor of rank q + (r - 1).
+Example 1:
+```
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+  indices = [
+      [0, 1],
+      [1, 2],
+  ]
+  output = [
+      [
+          [1.0, 1.2],
+          [2.3, 3.4],
+      ],
+      [
+          [2.3, 3.4],
+          [4.5, 5.7],
+      ],
+  ]
+```
+Example 2:
+```
+  data = [
+      [1.0, 1.2, 1.9],
+      [2.3, 3.4, 3.9],
+      [4.5, 5.7, 5.9],
+  ]
+  indices = [
+      [0, 2],
+  ]
+  axis = 1,
+  output = [
+      [[1.0, 1.9]],
+      [[2.3, 3.9]],
+      [[4.5, 5.9]],
+  ]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Gather,
+    1,
+    OpSchema()
+        .SetDoc(Gather_ver1_doc)
+        .Attr(
+            "axis",
+            "Which axis to gather on. Negative value means "
+            "counting dimensions from the back. Accepted range is [-r, r-1]",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "Tensor of rank r >= 1.", "T")
+        .Input(
+            1,
+            "indices",
+            "Tensor of int32/int64 indices, of any rank q. All index values are expected to be within bounds. "
+            "It is an error if any of the index values are out of bounds.",
+            "Tind")
+        .Output(0, "output", "Tensor of rank q + (r - 1).", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to any tensor type.")
+        .TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 2)) {
+            return;
+          }
+          const TensorShapeProto& data_shape = ctx.getInputType(0)->tensor_type().shape();
+          const TensorShapeProto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
+          int r = data_shape.dim_size();
+          if (r < 1) {
+            fail_shape_inference("data tensor must have rank >= 1");
+          }
+          int q = indices_shape.dim_size();
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 0));
+          if (axis < -r || axis >= r) {
+            fail_shape_inference("axis must be in [-r, r-1]");
+          }
+          if (axis < 0) {
+            axis += r;
+          }
+          int out_rank = q + r - 1;
+
+          if (out_rank == 0) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          }
+          for (int i = 0; i < out_rank; ++i) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = (i < axis) ? data_shape.dim(i)
+                                                                                                  : // i < axis < r
+                (i >= axis && i < axis + q) ? indices_shape.dim(i - axis)
+                                            : // i - axis < q
+                data_shape.dim(i - q + 1); // i < out_rank < q + r - 1
+          }
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) { GatherOp13DataPropagator(ctx); }));
+
+static const char* const Squeeze_ver1_doc = Squeeze_ver11_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Squeeze,
+    1,
+    OpSchema()
+        .Attr(
+            "axes",
+            "List of non-negative integers, indicate the dimensions to squeeze.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .SetDoc(Squeeze_ver1_doc)
+        .Input(0, "data", "Tensors with at least max(dims) dimensions.", "T")
+        .Output(0, "squeezed", "Reshaped tensor with same data as input.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
+            return;
+          }
+
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          std::vector<int64_t> axes;
+          if (!getRepeatedAttribute(ctx, "axes", axes)) {
+            for (int i = 0; i < input_ndim; ++i) {
+              if (!input_shape.dim(i).has_dim_value()) {
+                return;
+              }
+              if (input_shape.dim(i).dim_value() == 1) {
+                axes.push_back(i);
+              }
+            }
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          for (int i = 0, j = 0; i < input_shape.dim_size(); ++i) {
+            if (static_cast<size_t>(j) < axes.size() && axes[j] == i) {
+              if (input_shape.dim(i).has_dim_value() && input_shape.dim(i).dim_value() != 1) {
+                fail_shape_inference(
+                    "Dimension of input ", i, " must be 1 instead of ", input_shape.dim(i).dim_value());
+              }
+              ++j;
+            } else {
+              *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = input_shape.dim(i);
+            }
+          }
+        }));
+
+static constexpr const char* Unsqueeze_ver1_doc = R"DOC(
+Insert single-dimensional entries to the shape of a tensor.
+Takes one required argument `axes`, a list of dimensions that will be inserted.
+Dimension indices in `axes` are as seen in the output tensor. For example:
+  Given a tensor such that tensor with shape [3, 4, 5], then
+  Unsqueeze(tensor, axes=[0, 4]) has shape [1, 3, 4, 5, 1]
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Unsqueeze,
+    1,
+    OpSchema()
+        .Attr("axes", "List of non-negative integers, indicate the dimensions to be inserted", AttributeProto::INTS)
+        .SetDoc(Unsqueeze_ver1_doc)
+        .Input(0, "data", "Original tensor", "T")
+        .Output(0, "expanded", "Reshaped tensor with same data as input.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          std::vector<int64_t> axes;
+          if (!getRepeatedAttribute(ctx, "axes", axes)) {
+            return;
+          }
+          std::sort(axes.begin(), axes.end());
+
+          if (!ctx.getInputType(0)->tensor_type().has_shape()) {
+            return;
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          int j = 0;
+          for (int i = 0; i < ctx.getInputType(0)->tensor_type().shape().dim_size(); ++i) {
+            while (static_cast<size_t>(j) < axes.size() &&
+                   axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+              ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+              ++j;
+            }
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() =
+                ctx.getInputType(0)->tensor_type().shape().dim(i);
+          }
+          while (static_cast<size_t>(j) < axes.size() &&
+                 axes[j] == ctx.getOutputType(0)->tensor_type().shape().dim_size()) {
+            ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(1);
+            ++j;
+          }
+        }));
+
+static constexpr const char* OneHot_ver9_doc = R"DOC(
+    Produces a one-hot tensor based on inputs.
+    The locations represented by the index values in the 'indices' input tensor will have 'on_value'
+    and the other locations will have 'off_value' in the output tensor, where 'on_value' and 'off_value'
+    are specified as part of required input argument 'values', which is a two-element tensor of format
+    [off_value, on_value]. The rank of the output tensor will be one greater than the rank of the
+    input tensor. The additional dimension is for one-hot representation. The additional dimension will
+    be inserted at the position specified by 'axis'. If 'axis' is not specified then then additional
+    dimension will be inserted as the innermost dimension, i.e. axis=-1. The size of the additional
+    dimension is specified by required scalar input 'depth'. The type of the output tensor is the same
+    as the type of the 'values' input. Any entries in the 'indices' input tensor with values outside
+    the range [0, depth) will result in one-hot representation with all 'off_value' values in the
+    output tensor.
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    OneHot,
+    9,
+    OpSchema()
+        .SetDoc(OneHot_ver9_doc)
+        .Attr(
+            "axis",
+            "(Optional) Axis along which one-hot representation in added. Default: axis=-1. "
+            "axis=-1 means that the additional dimension will be inserted as the "
+            "innermost/last dimension in the output tensor.",
+            AttributeProto::INT,
+            static_cast<int64_t>(-1))
+        .Input(
+            0,
+            "indices",
+            "Input tensor containing indices. The values must be non-negative integers. "
+            "Any entries in the 'indices' input tensor with values outside the range [0, depth) "
+            "will result in one-hot representation with all 'off_value' values in the output tensor."
+            "In case 'indices' is of non-integer type, the values will be casted to int64 before use.",
+            "T1")
+        .Input(
+            1,
+            "depth",
+            "Scalar or rank 1 tensor containing exactly one element, specifying the number of classes "
+            "in one-hot tensor. This is also the size of the one-hot dimension (specified by 'axis' attribute) "
+            "added on in the output tensor. The values in the 'indices' input tensor are expected to be "
+            "in the range [0, depth). "
+            "In case 'depth' is of non-integer type, it will be casted to int64 before use.",
+            "T2")
+        .Input(
+            2,
+            "values",
+            "Rank 1 tensor containing exactly two elements, in the format [off_value, on_value], "
+            "where 'on_value' is the value used for filling locations specified in 'indices' input "
+            "tensor, and 'off_value' is the value used for filling locations other than those specified "
+            "in 'indices' input tensor. ",
+            "T3")
+        .Output(
+            0,
+            "output",
+            "Tensor of rank one greater than input tensor 'indices', i.e. rank(output) = rank(indices) + 1. "
+            "The data type for the elements of the output tensor is the same as the type of input 'values' "
+            "is used.",
+            "T3")
+        .TypeConstraint("T1", OpSchema::all_numeric_types(), "Constrain input to only numeric types.")
+        .TypeConstraint("T2", OpSchema::all_numeric_types(), "Constrain input to only numeric types.")
+        .TypeConstraint("T3", OpSchema::all_tensor_types(), "Constrain to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Check that the node has three inputs.
+          if (ctx.getNumInputs() != 3) {
+            fail_type_inference("OneHot node must have three inputs.");
+          }
+          // Input 'depth' must be a scalar or a single-element vector.
+          // TODO(ONNX): Ideally to match spec for this input only allow Scalar should
+          // be allowed. Making this change now can affect backward
+          // compatibility for this op. Since this does not seem like a good
+          // justification to update version for this op, allowing both scalar
+          // and 1 element vector for now. In future when version update for
+          // this op is done we should only allow scalar or change the spec to
+          // allow both.
+          std::optional<int64_t> depth_value;
+          if (hasInputShape(ctx, 1)) {
+            auto& depth_shape = getInputShape(ctx, 1);
+            if (const TensorProto* depth_data = ctx.getInputData(1)) {
+              if (depth_data->data_type() == TensorProto::INT64) {
+                depth_value = ParseData<int64_t>(depth_data)[0];
+              } else if (depth_data->data_type() == TensorProto::INT32) {
+                depth_value = ParseData<int32_t>(depth_data)[0];
+              } else if (depth_data->data_type() == TensorProto::FLOAT) {
+                depth_value = static_cast<int64_t>(ParseData<float>(depth_data)[0]);
+              }
+            }
+            if (depth_shape.dim_size() != 0 && depth_shape.dim_size() != 1) {
+              fail_type_inference("Input 'depth' must be a scalar or rank 1 tensor.");
+            }
+            if (depth_shape.dim_size() == 1 && depth_shape.dim(0).has_dim_value() &&
+                depth_shape.dim(0).dim_value() != 1) {
+              fail_type_inference("Input 'depth' must have exactly one element.");
+            }
+          }
+          // Input 'values' must be a two-element vector.
+          if (hasInputShape(ctx, 2)) {
+            auto& values_shape = getInputShape(ctx, 2);
+            if (values_shape.dim_size() != 1) {
+              fail_type_inference("Input 'values' must be rank 1 tensor.");
+            }
+            if (values_shape.dim(0).has_dim_value() && values_shape.dim(0).dim_value() != 2) {
+              fail_type_inference("Input 'values' must have exactly two elements.");
+            }
+          }
+          // Set output type to be the same as the third input, 'values'.
+          propagateElemTypeFromInputToOutput(ctx, 2, 0);
+          // Set the output shape, if input 0 (indices) shape is available.
+          if (hasInputShape(ctx, 0)) {
+            const TensorShapeProto& indices_shape = ctx.getInputType(0)->tensor_type().shape();
+            int r = indices_shape.dim_size();
+            if (r < 1) {
+              fail_shape_inference("Indices tensor must have rank >= 1");
+            }
+            int out_rank = r + 1;
+            int axis = static_cast<int>(getAttribute(ctx, "axis", -1));
+            if (axis < -out_rank || axis >= out_rank) {
+              fail_shape_inference("'axis' must be in [-rank(indices)-1, rank(indices)]");
+            }
+            if (axis < 0) {
+              axis += out_rank;
+            }
+            auto output_shape = getOutputShape(ctx, 0);
+            for (int i = 0; i < out_rank; ++i) {
+              auto dim = output_shape->add_dim();
+              if (i < axis) {
+                if (indices_shape.dim(i).has_dim_value()) {
+                  dim->set_dim_value(indices_shape.dim(i).dim_value());
+                } else if (indices_shape.dim(i).has_dim_param()) {
+                  dim->set_dim_param(indices_shape.dim(i).dim_param());
+                }
+              } else if (i > axis) {
+                if (indices_shape.dim(i - 1).has_dim_value()) {
+                  dim->set_dim_value(indices_shape.dim(i - 1).dim_value());
+                } else if (indices_shape.dim(i - 1).has_dim_param()) {
+                  dim->set_dim_param(indices_shape.dim(i - 1).dim_param());
+                }
+              } else if (depth_value) {
+                dim->set_dim_value(*depth_value);
+              }
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Compress,
+    9,
+    OpSchema()
+        .SetDoc(kDoc_Compress_ver9)
+        .Attr(
+            "axis",
+            "(Optional) Axis along which to take slices. If not specified, "
+            "input is flattened before elements being selected.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .Input(0, "input", "Tensor of rank r >= 1.", "T")
+        .Input(
+            1,
+            "condition",
+            "Rank 1 tensor of booleans to indicate which slices or data elements to be selected. "
+            "Its length can be less than the input length alone the axis "
+            "or the flattened input size if axis is not specified. "
+            "In such cases data slices or elements exceeding the condition length are discarded.",
+            "T1")
+        .Output(0, "output", "Tensor of rank r if axis is specified. Otherwise output is a Tensor of rank 1.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeConstraint("T1", {types::Bool}, "Constrain to boolean tensors."));
+
+static const char* const Split_ver2_doc = Split_ver11_doc;
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Split,
+    2,
+    OpSchema()
+        .Input(0, "input", "The tensor to split", "T")
+        .Output(0, "outputs", "One or more outputs forming list of tensors after splitting", "T", OpSchema::Variadic)
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .Attr("axis", "Which axis to split on. ", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr("split", "length of each output", AttributeProto::INTS, OPTIONAL_VALUE)
+        .SetDoc(Split_ver2_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); ++i) {
+            propagateElemTypeFromInputToOutput(ctx, 0, i);
+          }
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          const auto& shape = ctx.getInputType(0)->tensor_type().shape();
+          int rank = shape.dim_size();
+          int axis = static_cast<int>(getAttribute(ctx, "axis", 0));
+          if (axis < -rank || axis >= rank) {
+            fail_type_inference("Invalid value of attribute 'axis'. Rank=", rank, " Value=", axis);
+          }
+          // Previously Split-2 does not mention how to deal with negative axis
+          // However, there is an existing test onnx/backend/test/data/pytorch-converted/test_GLU
+          // using Split-2 with negative axis and it is hard to be regenerated.
+          // To compromise, handle negative axis for Split-2 here.
+          if (axis < 0) {
+            axis += rank;
+          }
+          const auto& split_dim = shape.dim(axis);
+          if (!split_dim.has_dim_value()) {
+            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
+              *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
+              ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->Clear();
+            }
+            return;
+          }
+          int split_dim_value = static_cast<int>(split_dim.dim_value());
+
+          std::vector<int64_t> split;
+          if (getRepeatedAttribute(ctx, "split", split)) {
+            if (split.size() != ctx.getNumOutputs()) {
+              fail_shape_inference(
+                  "Mismatch between number of splits (", split.size(), ") and outputs (", ctx.getNumOutputs(), ")");
+            }
+            int64_t total_dim = 0;
+            for (int64_t d : split) {
+              total_dim += d;
+            }
+            if (total_dim != split_dim_value) {
+              fail_shape_inference(
+                  "Mismatch between the sum of 'split' (",
+                  total_dim,
+                  ") and the split dimension of the input (",
+                  split_dim_value,
+                  ")");
+            }
+          } else {
+            int num_outputs = static_cast<int>(ctx.getNumOutputs());
+            if (split_dim_value % num_outputs != 0) {
+              fail_shape_inference("The input is not evenly splittable");
+            }
+            int chunk_size = split_dim_value / num_outputs;
+            for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
+              split.push_back(chunk_size);
+            }
+          }
+          for (size_t i = 0; i < ctx.getNumOutputs(); i++) {
+            *ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape() = shape;
+            ctx.getOutputType(i)->mutable_tensor_type()->mutable_shape()->mutable_dim(axis)->set_dim_value(split[i]);
+          }
+        }));
+
+static constexpr const char* Pad_ver2_doc = R"DOC(
+Given `data` tensor, pads, mode, and value.
+Example:
+  Insert 0 pads to the beginning of the second dimension.
+  data = [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+  pads = [0, 2, 0, 0]
+  output = [
+      [
+          [0.0, 0.0, 1.0, 1.2],
+          [0.0, 0.0, 2.3, 3.4],
+          [0.0, 0.0, 4.5, 5.7],
+      ],
+  ]
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    2,
+    OpSchema()
+        .Attr(
+            "pads",
+            "List of integers indicating the number of padding elements to add or remove (if negative) "
+            "at the beginning and end of each axis. For 2D it is the number of pixels. "
+            "`pads` rank should be double of the input's rank. `pads` format should be as follow "
+            "[x1_begin, x2_begin...x1_end, x2_end,...], where xi_begin the number of pixels "
+            "added at the beginning of axis `i` and xi_end, the number of pixels added at "
+            "the end of axis `i`.",
+            AttributeProto::INTS)
+        .Attr("mode", "Three modes: constant(default), reflect, edge", AttributeProto::STRING, std::string("constant"))
+        .Attr("value", "One float, indicates the value to be filled.", AttributeProto::FLOAT, 0.0f)
+        .SetDoc(Pad_ver2_doc)
+        .Input(0, "data", "Input tensor.", "T")
+        .Output(0, "output", "Tensor after padding.", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float16, types::Float, types::Double},
+            "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+
+          std::vector<int64_t> pads;
+          if (!getRepeatedAttribute(ctx, "pads", pads)) {
+            fail_shape_inference("Attribute value for pads is required");
+          }
+          if (pads.size() != static_cast<size_t>(input_shape.dim_size() * 2)) {
+            fail_shape_inference("Attribute pads has incorrect length");
+            ;
+          }
+
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+          for (int i = 0; i < input_shape.dim_size(); ++i) {
+            auto newdim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
+            if (ctx.getInputType(0)->tensor_type().shape().dim(i).has_dim_value()) {
+              newdim->set_dim_value(
+                  ctx.getInputType(0)->tensor_type().shape().dim(i).dim_value() + pads[i] +
+                  pads[input_shape.dim_size() + i]);
+            } else if (pads[i] + pads[input_shape.dim_size() + i] == 0) {
+              *newdim = input_shape.dim(i);
+            }
+          }
+        }));
+
+static constexpr const char* GatherND_ver11_doc = R"DOC(
+Given `data` tensor of rank `r` >= 1, and `indices` tensor of rank `q` >= 1, this operator gathers
+slices of `data` into an output tensor of rank `q + r - indices_shape[-1] - 1`.
+
+`indices` is an q-dimensional integer tensor, best thought of as a `(q-1)`-dimensional tensor of index-tuples into `data`,
+where each element defines a slice of `data`
+
+Some salient points about the inputs' rank and shape:
+
+1) r >= 1 and q >= 1 are to be honored. There is no dependency condition to be met between ranks `r` and `q`
+
+2) The `indices_shape[-1]` should have a value between 1 (inclusive) and rank `r` (inclusive)
+
+3) All values in `indices` are expected to be within bounds [-s, s-1] along axis of size `s` (i.e.) `-data_shape[i] <= indices[...,i] <= data_shape[i] - 1`.
+   It is an error if any of the index values are out of bounds.
+
+The output is computed as follows:
+
+The output tensor is obtained by mapping each index-tuple in the `indices` tensor to the corresponding slice of the input `data`.
+
+1) If `indices_shape[-1] > r` => error condition
+
+2) If `indices_shape[-1] == r`, since the rank of `indices` is `q`, `indices` can be thought of as a `(q-1)`-dimensional tensor
+   containing 1-D tensors of dimension `r`. Let us think of each such `r` ranked tensor as `indices_slice`.
+   Each *scalar value* corresponding to `data[indices_slice]` is filled into the corresponding location of the `(q-1)`-dimensional tensor
+   to form the `output` tensor (Example 1 below)
+
+3) If `indices_shape[-1] < r`, since the rank of `indices` is `q`, `indices` can be thought of as a `(q-1)`-dimensional tensor
+   containing 1-D tensors of dimension `< r`. Let us think of each such tensors as `indices_slice`.
+   Each *tensor slice* corresponding to `data[indices_slice , :]` is filled into the corresponding location of the `(q-1)`-dimensional tensor
+   to form the `output` tensor (Examples 2, 3, and 4 below)
+
+This operator is the inverse of `ScatterND`.
+
+`Example 1`
+
+  data    = [[0,1],[2,3]]   # data_shape = [2, 2]
+
+  indices = [[0,0],[1,1]]   # indices_shape = [2, 2]
+
+  output  = [0,3]           # output_shape = [2]
+
+`Example 2`
+
+  data    = [[0,1],[2,3]]  # data_shape = [2, 2]
+
+  indices = [[1],[0]]      # indices_shape = [2, 1]
+
+  output  = [[2,3],[0,1]]  # output_shape = [2, 2]
+
+`Example 3`
+
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+  indices = [[0,1],[1,0]]                 # indices_shape = [2, 2]
+
+  output  = [[2,3],[4,5]]                 # output_shape = [2, 2]
+
+`Example 4`
+
+  data    = [[[0,1],[2,3]],[[4,5],[6,7]]] # data_shape = [2, 2, 2]
+
+  indices = [[[0,1]],[[1,0]]]             # indices_shape = [2, 1, 2]
+
+  output  = [[[2,3]],[[4,5]]]             # output_shape = [2, 1, 2]
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    GatherND,
+    11,
+    OpSchema()
+        .SetDoc(GatherND_ver11_doc)
+        .Input(0, "data", "Tensor of rank r >= 1.", "T")
+        .Input(
+            1,
+            "indices",
+            "Tensor of rank q >= 1. All index values are expected to be within bounds [-s, s-1] "
+            "along axis of size s. It is an error if any of the index values are out of bounds.",
+            "tensor(int64)")
+        .Output(0, "output", "Tensor of rank q + r - indices_shape[-1] - 1.", "T")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to any tensor type.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+          // Shape inference
+          if (!hasNInputShapes(ctx, 2)) {
+            // cannot proceed with shape or rank inference
+            return;
+          }
+
+          const auto& data_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto data_rank = data_shape.dim_size();
+
+          const auto& indices_shape = ctx.getInputType(1)->tensor_type().shape();
+          const auto indices_rank = indices_shape.dim_size();
+
+          if (data_rank < 1 || indices_rank < 1) {
+            fail_shape_inference(
+                "Both `data` and `indices` input tensors in GatherND op "
+                "need to have rank larger than 0.");
+          }
+
+          // cannot ascertain if the input shapes are valid if shape of
+          // `indices` is missing last dimension value so return at this point
+          if (!indices_shape.dim(indices_rank - 1).has_dim_value()) {
+            return;
+          }
+
+          const auto last_index_dimension = indices_shape.dim(indices_rank - 1).dim_value();
+
+          if (last_index_dimension > data_rank) {
+            fail_shape_inference(
+                "Last dimension of `indices` input tensor in GatherND op "
+                "must not be larger than the rank of `data` tensor");
+          }
+
+          for (int i = 0; i < indices_rank - 1; ++i) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = indices_shape.dim(i);
+          }
+
+          for (int i = static_cast<int>(last_index_dimension); i < data_rank; ++i) {
+            *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim() = data_shape.dim(i);
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Identity,
+    14,
+    OpSchema()
+        .SetDoc("Identity operator")
+        .Input(0, "input", "Input tensor", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Tensor to copy input into.", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types_ir4();
+              auto s = OpSchema::all_tensor_sequence_types();
+              t.insert(t.end(), s.begin(), s.end());
+              return t;
+            }(),
+            "Constrain input and output types to all tensor and sequence types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Where,
+    9,
+    OpSchema()
+        .SetDoc(kDoc_Where_ver9 + GenerateBroadcastingDocMul())
+        .Input(
+            0,
+            "condition",
+            "When True (nonzero), yield X, otherwise yield Y",
+            "B",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            1,
+            "X",
+            "values selected at indices where condition is True",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Input(
+            2,
+            "Y",
+            "values selected at indices where condition is False",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .Output(
+            0,
+            "output",
+            "Tensor of shape equal to the broadcasted shape of condition, X, and Y.",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::Differentiable)
+        .TypeConstraint("B", {types::Bool}, "Constrain to boolean tensors.")
+        .TypeConstraint("T", OpSchema::all_tensor_types(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 1, 0);
+          if (hasNInputShapes(ctx, 3)) {
+            std::vector<const TensorShapeProto*> shapes;
+            shapes.push_back(&ctx.getInputType(0)->tensor_type().shape());
+            shapes.push_back(&ctx.getInputType(1)->tensor_type().shape());
+            shapes.push_back(&ctx.getInputType(2)->tensor_type().shape());
+            multidirectionalBroadcastShapeInference(
+                shapes, *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+          }
+        }));
+
+static constexpr const char* Pad_ver13_doc = R"DOC(
+Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+a padded tensor (`output`) is generated.
+
+The three supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+3) `edge` - pads with the edge values of array
+
+
+Example 1 (`constant` mode):
+  Insert 0 pads to the beginning of the second dimension.
+
+  data =
+  [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'constant'
+
+  constant_value = 0.0
+
+  output =
+  [
+      [0.0, 0.0, 1.0, 1.2],
+      [0.0, 0.0, 2.3, 3.4],
+      [0.0, 0.0, 4.5, 5.7],
+  ]
+
+
+Example 2 (`reflect` mode):
+  data =
+  [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'reflect'
+
+  output =
+  [
+      [1.0, 1.2, 1.0, 1.2],
+      [2.3, 3.4, 2.3, 3.4],
+      [4.5, 5.7, 4.5, 5.7],
+  ]
+
+
+Example 3 (`edge` mode):
+  data =
+  [
+      [1.0, 1.2],
+      [2.3, 3.4],
+      [4.5, 5.7],
+  ]
+
+  pads = [0, 2, 0, 0]
+
+  mode = 'edge'
+
+  output =
+  [
+      [1.0, 1.0, 1.0, 1.2],
+      [2.3, 2.3, 2.3, 3.4],
+      [4.5, 4.5, 4.5, 5.7],
+  ]
+
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    13,
+    OpSchema()
+        .Attr(
+            "mode",
+            "Supported modes: `constant`(default), `reflect`, `edge`",
+            AttributeProto::STRING,
+            std::string("constant"))
+        .SetDoc(Pad_ver13_doc)
+        .Input(0, "data", "Input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "pads",
+            "Tensor of integers indicating the number of padding elements to add or remove (if negative) "
+            "at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. "
+            "`pads` should be a 1D tensor of shape [2 * input_rank]. "
+            "`pads` format should be: [x1_begin, x2_begin,...,x1_end, x2_end,...], "
+            "where xi_begin is the number of pad values added at the beginning of axis `i` and "
+            "xi_end, the number of pad values added at the end of axis `i`.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(
+            2,
+            "constant_value",
+            "(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, "
+            "empty string or False).",
+            "T",
+            OpSchema::Optional,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "output", "Tensor after padding.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          // Shape inference needs the input data shape
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_rank = input_shape.dim_size();
+
+          // Infer output shape if 'pads' tensor is available
+          const auto pads_initializer = ctx.getInputData(1);
+          if (nullptr != pads_initializer) {
+            if (pads_initializer->dims_size() != 1 || pads_initializer->data_type() != TensorProto::INT64) {
+              fail_shape_inference("'pads' input must be a 1D (shape: [2 * input_rank]) tensor of type int64");
+            }
+
+            const auto pads_data = ParseData<int64_t>(pads_initializer);
+            if (pads_data.size() != static_cast<size_t>(2 * input_rank)) {
+              fail_shape_inference("Pads has incorrect number of values");
+            }
+
+            auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+            for (int i = 0; i < input_rank; ++i) {
+              const auto& input_dim = input_shape.dim(i);
+              auto output_dim = output_shape->add_dim();
+              if (input_dim.has_dim_value()) {
+                output_dim->set_dim_value(input_dim.dim_value() + pads_data[i] + pads_data[i + input_rank]);
+              } else if (pads_data[i] + pads_data[i + input_rank] == 0) {
+                *output_dim = input_dim;
+              }
+            }
+          } else {
+            // Infer output shapes' rank in any case
+            auto output_shape_0 = getOutputShape(ctx, 0);
+            for (int i = 0; i < input_rank; ++i) {
+              output_shape_0->add_dim();
+            }
+          }
+          return;
+        }));
+
+static constexpr const char* Pad_ver18_doc = R"DOC(
+Given a tensor containing the data to be padded (`data`), a tensor containing the number of start and end pad values for axis (`pads`), (optionally) a `mode`, and (optionally) `constant_value`,
+a padded tensor (`output`) is generated.
+
+The three supported `modes` are (similar to corresponding modes supported by `numpy.pad`):
+
+1) `constant`(default) - pads with a given constant value as specified by `constant_value` (which defaults to 0, empty string, or False)
+
+2) `reflect` - pads with the reflection of the vector mirrored on the first and last values of the vector along each axis
+
+3) `edge` - pads with the edge values of array
+
+
+Example 1 (`constant` mode):
+
+Insert 0 pads to the beginning of the second dimension.
+
+```
+data = [
+    [1.0, 1.2],
+    [2.3, 3.4],
+    [4.5, 5.7],
+]
+
+pads = [0, 2, 0, 0]
+
+mode = 'constant'
+
+constant_value = 0.0
+
+output = [
+    [0.0, 0.0, 1.0, 1.2],
+    [0.0, 0.0, 2.3, 3.4],
+    [0.0, 0.0, 4.5, 5.7],
+]
+```
+
+Example 2 (`reflect` mode):
+
+```
+data = [
+    [1.0, 1.2],
+    [2.3, 3.4],
+    [4.5, 5.7],
+]
+
+pads = [0, 2, 0, 0]
+
+mode = 'reflect'
+
+output = [
+    [1.0, 1.2, 1.0, 1.2],
+    [2.3, 3.4, 2.3, 3.4],
+    [4.5, 5.7, 4.5, 5.7],
+]
+```
+
+Example 3 (`edge` mode):
+
+```
+data = [
+    [1.0, 1.2],
+    [2.3, 3.4],
+    [4.5, 5.7],
+]
+
+pads = [0, 2, 0, 0]
+
+mode = 'edge'
+
+output = [
+    [1.0, 1.0, 1.0, 1.2],
+    [2.3, 2.3, 2.3, 3.4],
+    [4.5, 4.5, 4.5, 5.7],
+]
+```
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Pad,
+    18,
+    OpSchema().FillUsing(PadDocGenerator(Pad_ver18_doc, "Supported modes: `constant`(default), `reflect`, `edge`")));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Identity,
+    16,
+    OpSchema()
+        .SetDoc("Identity operator")
+        .Input(0, "input", "Input tensor", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Output(0, "output", "Tensor to copy input into.", "V", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint(
+            "V",
+            []() {
+              auto t = OpSchema::all_tensor_types_ir4();
+              auto s = OpSchema::all_tensor_sequence_types();
+              auto o = OpSchema::all_optional_types();
+              t.insert(t.end(), s.begin(), s.end());
+              t.insert(t.end(), o.begin(), o.end());
+              return t;
+            }(),
+            "Constrain input and output types to all tensor, sequence, and optional types.")
+        .TypeAndShapeInferenceFunction(propagateShapeAndTypeFromFirstInput));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Reshape,
+    14,
+    OpSchema()
+        .SetDoc(kDoc_Reshape_ver24)
+        .Attr(
+            "allowzero",
+            "(Optional) By default, when any value in the 'shape' input is equal to zero "
+            "the corresponding dimension value is copied from the input tensor dynamically. "
+            "allowzero=1 indicates that if any value in the 'shape' input is set to zero, "
+            "the zero value is honored, similar to NumPy.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .Input(
+            1,
+            "shape",
+            "Specified shape for output.",
+            "tensor(int64)",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(0, "reshaped", "Reshaped data.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Constrain input and output types to all tensor types.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Type inference
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          bool found;
+          TensorShapeProto targetShapeProto = getShapeInput(ctx, 1, found);
+          if (!found) {
+            return;
+          }
+
+          int allowzero = static_cast<int>(getAttribute(ctx, "allowzero", 0));
+
+          // Iterate through targetShape, adding dimensions in the outputShape
+          // TensorProto. If the targetShape dimension is -1, we do not set the
+          // dimension value in this iteration, but we record the Dimension. If
+          // targetShape dimension is 0, we attempt to propagate the dimension
+          // value/param. If the value cannot be inferred, we set the flag in
+          // the unresolveZeros vector. If targetShape dimension is positive, we
+          // set the dimension value in the outputShape. We track the product of
+          // the dimensions we are setting outputShape in the outputProduct
+          // variable. The outputProduct will potentially be used for inferring
+          // a dimension marked -1.
+          auto outputShape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          TensorShapeProto::Dimension* negativeOneDim = nullptr;
+          const auto& dataInputTensorType = ctx.getInputType(0)->tensor_type();
+          std::vector<bool> unresolvedZeros(targetShapeProto.dim_size(), false);
+          int64_t outputProduct = 1;
+          bool outputProductValid = true;
+          for (int i = 0; i < static_cast<int>(targetShapeProto.dim_size()); ++i) {
+            // Add a new dimension to outputShape
+            auto new_dim = outputShape->add_dim();
+            if (targetShapeProto.dim(i).has_dim_param()) {
+              // There is a tricky edge case here. It is possible that the value of
+              // symbolic dim can be -1 or 0 at runtime. In that case simply propagating this
+              // symbol can be erroneous. This should be a very rare scenario and in such a
+              // case an option is to turn off data propagation during shape inference.
+              new_dim->set_dim_param(targetShapeProto.dim(i).dim_param());
+              outputProductValid = false;
+            } else {
+              if (!targetShapeProto.dim(i).has_dim_value()) {
+                outputProductValid = false;
+                // treat this dim as unknown dim
+                continue;
+              }
+
+              const auto dim_value = targetShapeProto.dim(i).dim_value();
+
+              if (dim_value == -1) {
+                // Check if multiple -1's. If not, set negativeOneDim, marking
+                // this dimension to potentially be filled in later.
+                if (negativeOneDim) {
+                  fail_shape_inference("Target shape may not have multiple -1 dimensions.");
+                }
+                negativeOneDim = new_dim;
+              } else if (dim_value == 0) {
+                // Check if data input has a shape and if the index i is within
+                // its bounds. If these conditions are satisfied, any dimension
+                // value/param should be propagated. If dimension value cannot be
+                // inferred, set the corresponding  unresolvedZeros flag to true.
+                // If allowzero is set however, do not propagate values, since output
+                // dimension is explicitly zero.
+                if (allowzero == 0) {
+                  unresolvedZeros[i] = true;
+                  if (dataInputTensorType.has_shape()) {
+                    if (i >= dataInputTensorType.shape().dim_size()) {
+                      fail_shape_inference("Invalid position of 0.");
+                    }
+                    if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                      const auto& input_dim_value = dataInputTensorType.shape().dim(i).dim_value();
+                      new_dim->set_dim_value(input_dim_value);
+                      checked_mul_into(outputProduct, input_dim_value);
+                      unresolvedZeros[i] = false;
+                    } else if (dataInputTensorType.shape().dim(i).has_dim_param()) {
+                      new_dim->set_dim_param(dataInputTensorType.shape().dim(i).dim_param());
+                    }
+                  }
+                } else {
+                  new_dim->set_dim_value(dim_value);
+                  checked_mul_into(outputProduct, dim_value);
+                }
+              } else if (dim_value > 0) {
+                // Set the dimension value to dim_value
+                new_dim->set_dim_value(dim_value);
+                checked_mul_into(outputProduct, dim_value);
+              } else {
+                // Check if value is less than -1; fail if so
+                fail_shape_inference("Invalid dimension value: ", dim_value);
+              }
+            }
+          }
+          // If negativeOneDim has been set, we attempt to infer its value. This
+          // can be done if all dimension values for the data input tensor shape
+          // are known other than the ones corresponding to unresolvedZeros
+          // flags.
+          if (negativeOneDim && outputProductValid) {
+            // First, attempt to compute product of data input shape dimensions
+            // that are not marked by unresolvedZeros. If not possible, set the
+            // inputProductValid flag to false.
+            if (!outputProduct) {
+              fail_shape_inference("Invalid Target shape product of 0. Product cannot be 0 in combination with -1");
+            }
+            int64_t inputProduct = 1;
+            bool inputProductValid = true;
+            if (!dataInputTensorType.has_shape()) {
+              inputProductValid = false;
+            } else {
+              for (int i = 0; i < dataInputTensorType.shape().dim_size(); ++i) {
+                if (dataInputTensorType.shape().dim(i).has_dim_value()) {
+                  checked_mul_into(inputProduct, dataInputTensorType.shape().dim(i).dim_value());
+                } else if (i >= static_cast<int>(unresolvedZeros.size()) || !unresolvedZeros[i]) {
+                  inputProductValid = false;
+                  break;
+                }
+              }
+            }
+            if (inputProductValid) {
+              if (inputProduct % outputProduct != 0) {
+                fail_shape_inference("Dimension could not be inferred: incompatible shapes");
+              }
+              negativeOneDim->set_dim_value(inputProduct / outputProduct);
+            }
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Shape,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_Shape_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "shape", "Shape of the input tensor", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr(
+            "start",
+            "(Optional) Starting axis for slicing the shape. Default value is 0."
+            "Negative value means counting dimensions from the back.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "end",
+            "(Optional) Ending axis for slicing the shape. "
+            "Negative value means counting dimensions from the back. "
+            "If omitted, sizes of all axes upto (including) the last one will be included.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir10(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          auto output_length = output_shape->add_dim();
+
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          int64_t rank = static_cast<int64_t>(ctx.getInputType(0)->tensor_type().shape().dim_size());
+          int64_t start = getAttribute(ctx, "start", 0);
+          if (start < 0)
+            start += rank;
+          start = (start < 0) ? 0 : (start > rank) ? rank : start;
+          int64_t end = getAttribute(ctx, "end", rank);
+          if (end < 0)
+            end += rank;
+          end = (end < 0) ? 0 : (end > rank) ? rank : end;
+          output_length->set_dim_value((end - start) < 0 ? 0 : (end - start));
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            int64_t rank = static_cast<int64_t>(input_shape.dim_size());
+            int64_t start = getAttribute(ctx, "start", 0);
+            if (start < 0)
+              start += rank;
+            start = (start < 0) ? 0 : (start > rank) ? rank : start;
+            int64_t end = getAttribute(ctx, "end", rank);
+            if (end < 0)
+              end += rank;
+            end = (end < 0) ? 0 : (end > rank) ? rank : end;
+            TensorShapeProto output_shape;
+            for (int64_t d = start; d < end; ++d) {
+              *output_shape.add_dim() = input_shape.dim(static_cast<int>(d));
+            }
+            ctx.addOutputData(0, std::move(output_shape));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Shape,
+    19,
+    OpSchema()
+        .SetDoc(kDoc_Shape_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "shape", "Shape of the input tensor", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr(
+            "start",
+            "(Optional) Starting axis for slicing the shape. Default value is 0."
+            "Negative value means counting dimensions from the back.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "end",
+            "(Optional) Ending axis for slicing the shape. "
+            "Negative value means counting dimensions from the back. "
+            "If omitted, sizes of all axes upto (including) the last one will be included.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir9(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          auto output_length = output_shape->add_dim();
+
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          int64_t rank = static_cast<int64_t>(ctx.getInputType(0)->tensor_type().shape().dim_size());
+          int64_t start = getAttribute(ctx, "start", 0);
+          if (start < 0)
+            start += rank;
+          start = (start < 0) ? 0 : (start > rank) ? rank : start;
+          int64_t end = getAttribute(ctx, "end", rank);
+          if (end < 0)
+            end += rank;
+          end = (end < 0) ? 0 : (end > rank) ? rank : end;
+          output_length->set_dim_value((end - start) < 0 ? 0 : (end - start));
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            int64_t rank = static_cast<int64_t>(input_shape.dim_size());
+            int64_t start = getAttribute(ctx, "start", 0);
+            if (start < 0)
+              start += rank;
+            start = (start < 0) ? 0 : (start > rank) ? rank : start;
+            int64_t end = getAttribute(ctx, "end", rank);
+            if (end < 0)
+              end += rank;
+            end = (end < 0) ? 0 : (end > rank) ? rank : end;
+            TensorShapeProto output_shape;
+            for (int64_t d = start; d < end; ++d) {
+              *output_shape.add_dim() = input_shape.dim(static_cast<int>(d));
+            }
+            ctx.addOutputData(0, std::move(output_shape));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Shape,
+    15,
+    OpSchema()
+        .SetDoc(kDoc_Shape_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "shape", "Shape of the input tensor", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr(
+            "start",
+            "(Optional) Starting axis for slicing the shape. Default value is 0."
+            "Negative value means counting dimensions from the back.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "end",
+            "(Optional) Ending axis for slicing the shape. "
+            "Negative value means counting dimensions from the back. "
+            "If omitted, sizes of all axes upto (including) the last one will be included.",
+            AttributeProto::INT,
+            OPTIONAL_VALUE)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          auto output_length = output_shape->add_dim();
+
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+
+          int64_t rank = static_cast<int64_t>(ctx.getInputType(0)->tensor_type().shape().dim_size());
+          int64_t start = getAttribute(ctx, "start", 0);
+          if (start < 0)
+            start += rank;
+          start = (start < 0) ? 0 : (start > rank) ? rank : start;
+          int64_t end = getAttribute(ctx, "end", rank);
+          if (end < 0)
+            end += rank;
+          end = (end < 0) ? 0 : (end > rank) ? rank : end;
+          output_length->set_dim_value((end - start) < 0 ? 0 : (end - start));
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          if (hasInputShape(ctx, 0)) {
+            auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            int64_t rank = static_cast<int64_t>(input_shape.dim_size());
+            int64_t start = getAttribute(ctx, "start", 0);
+            if (start < 0)
+              start += rank;
+            start = (start < 0) ? 0 : (start > rank) ? rank : start;
+            int64_t end = getAttribute(ctx, "end", rank);
+            if (end < 0)
+              end += rank;
+            end = (end < 0) ? 0 : (end > rank) ? rank : end;
+            TensorShapeProto output_shape;
+            for (int64_t d = start; d < end; ++d) {
+              *output_shape.add_dim() = input_shape.dim(static_cast<int>(d));
+            }
+            ctx.addOutputData(0, std::move(output_shape));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Size,
+    21,
+    OpSchema()
+        .SetDoc(kDoc_Size_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "size",
+            "Total number of elements of the input tensor",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir10(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor, which should be a scalar though.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          const auto input_data = ctx.getInputData(0);
+          if (input_data != nullptr) {
+            TensorShapeProto tsp;
+            tsp.mutable_dim()->Add()->set_dim_value(input_data->dim_size());
+            ctx.addOutputData(0, std::move(tsp));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Size,
+    19,
+    OpSchema()
+        .SetDoc(kDoc_Size_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "size",
+            "Total number of elements of the input tensor",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir9(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor, which should be a scalar though.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          const auto input_data = ctx.getInputData(0);
+          if (input_data != nullptr) {
+            TensorShapeProto tsp;
+            tsp.mutable_dim()->Add()->set_dim_value(input_data->dim_size());
+            ctx.addOutputData(0, std::move(tsp));
+          }
+        }));
+
+ONNX_OPERATOR_SET_SCHEMA(
+    Size,
+    13,
+    OpSchema()
+        .SetDoc(kDoc_Size_ver24)
+        .Input(0, "data", "An input tensor.", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(
+            0,
+            "size",
+            "Total number of elements of the input tensor",
+            "T1",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T", OpSchema::all_tensor_types_ir4(), "Input tensor can be of arbitrary type.")
+        .TypeConstraint("T1", {types::Int64}, "Constrain output to int64 tensor, which should be a scalar though.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+        })
+        .PartialDataPropagationFunction([](DataPropagationContext& ctx) {
+          const auto input_data = ctx.getInputData(0);
+          if (input_data != nullptr) {
+            TensorShapeProto tsp;
+            tsp.mutable_dim()->Add()->set_dim_value(input_data->dim_size());
+            ctx.addOutputData(0, std::move(tsp));
+          }
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/tensor/utils.cc b/onnx/defs/tensor/utils.cc
new file mode 100644
index 0000000..f61dd93
--- /dev/null
+++ b/onnx/defs/tensor/utils.cc
@@ -0,0 +1,503 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/tensor/utils.h"
+
+#include <algorithm>
+#include <limits>
+#include <numeric>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/defs/tensor_proto_util.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+void resizeShapeInferenceHelper(
+    const TensorShapeProto& input_shape,
+    const std::vector<int64_t>& sizes_data,
+    TensorShapeProto* output_shape) {
+  if (!sizes_data.empty()) {
+    for (int i = 0; i < input_shape.dim_size(); ++i) {
+      auto* dim = output_shape->mutable_dim(i);
+      if (sizes_data[i] > 0) {
+        dim->set_dim_value(sizes_data[i]);
+      }
+    }
+    return;
+  }
+}
+
+void KeepAspectRatioHelper(
+    KeepAspectRatioPolicy policy,
+    const TensorShapeProto& input_shape,
+    const std::vector<int64_t>& axes,
+    std::vector<int64_t>& sizes_data) {
+  if (policy != KeepAspectRatioPolicy::NOT_LARGER && policy != KeepAspectRatioPolicy::NOT_SMALLER) {
+    return;
+  }
+  double scale = policy == KeepAspectRatioPolicy::NOT_LARGER ? std::numeric_limits<double>::max()
+                                                             : std::numeric_limits<double>::lowest();
+  std::function<double(double, double)> reduce_f;
+  if (policy == KeepAspectRatioPolicy::NOT_LARGER) {
+    reduce_f = [](double a, double b) { return std::min(a, b); };
+  } else {
+    reduce_f = [](double a, double b) { return std::max(a, b); };
+  }
+
+  bool has_unknown_dim = false;
+  for (size_t i = 0; i < sizes_data.size(); i++) {
+    int d = axes.empty() ? i : axes[i];
+    if (!input_shape.dim(d).has_dim_value()) {
+      has_unknown_dim = true;
+      break;
+    }
+    double s = sizes_data[i] / static_cast<double>(input_shape.dim(d).dim_value());
+    scale = reduce_f(scale, s);
+  }
+  // If there's at least one unknown dim we can't infer the output shape, since it
+  // will depend on the original aspect ratio of the input.
+  for (size_t i = 0; i < sizes_data.size(); i++) {
+    int d = axes.empty() ? i : axes[i];
+    sizes_data[i] = has_unknown_dim
+        ? -1
+        : static_cast<int64_t>(std::round(scale * static_cast<double>(input_shape.dim(d).dim_value())));
+  }
+}
+
+void gridSampleShapeInference(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+
+  // If there is any input shape unknown, skip the shape inference.
+  if (!hasNInputShapes(ctx, 2)) {
+    return;
+  }
+
+  // Grid sample input tensor indices.
+  size_t const input_param = 0, grid_param = 1;
+
+  auto const& input_shape = getInputShape(ctx, input_param);
+  auto const& grid_shape = getInputShape(ctx, grid_param);
+
+  if (input_shape.dim_size() != grid_shape.dim_size()) {
+    fail_shape_inference(
+        "The input tensor and grid tensor must have the same rank for GridSample. ",
+        "Got input tensor rank: ",
+        input_shape.dim_size(),
+        ". ",
+        "Got grid tensor rank: ",
+        grid_shape.dim_size(),
+        ". ");
+  }
+
+  int const num_dims = input_shape.dim_size();
+
+  if (num_dims < 3) {
+    fail_shape_inference(
+        "The input tensor and grid tensor ranks must be >= 3. ",
+        "Got input tensor and grid tensor ranks: ",
+        num_dims,
+        ". ");
+  }
+  auto const& last_dim = grid_shape.dim(num_dims - 1);
+  if (last_dim.has_dim_value() && (last_dim.dim_value() != num_dims - 2)) {
+    fail_shape_inference(
+        "The last dimension of the grid tensor must be the rank of the grid tensor - 2. ",
+        "Got grid tensor rank: ",
+        num_dims,
+        "Got the last dimension of the grid tensor: ",
+        last_dim.dim_value(),
+        ". ");
+  }
+
+  auto* output_shape = getOutputShape(ctx, 0);
+  // N
+  Dim& N = *(output_shape->add_dim());
+  // The first call sets the dimension using the dimensions from input_shape.
+  unifyDim(input_shape.dim(0), N);
+  // The second call checks the dimension using the dimensions from grid_shape.
+  unifyDim(grid_shape.dim(0), N);
+  // C
+  Dim& C = *(output_shape->add_dim());
+  unifyDim(input_shape.dim(1), C);
+  // Other Dimensions.
+  for (int i = 0; i < num_dims - 2; ++i) {
+    Dim& D = *(output_shape->add_dim());
+    unifyDim(grid_shape.dim(1 + i), D);
+  }
+}
+
+void resizeShapeInferenceHelper(
+    const TensorShapeProto& input_shape,
+    const std::vector<float>& scales_data,
+    TensorShapeProto* output_shape) {
+  // Newer opsets reuse the frozen opset 7-10 helper; give this its own body when they diverge.
+  resizeShapeInferenceHelper_opset7_to_10(input_shape, scales_data, output_shape);
+}
+
+static void resizeShapeInferenceVersioned(InferenceContext& ctx, int opset_version) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+  if (!hasNInputShapes(ctx, 1)) {
+    return;
+  }
+  const auto& input_shape = getInputShape(ctx, 0);
+  auto* output_shape = getOutputShape(ctx, 0);
+
+  bool hasScalesInput = ctx.hasInput(2);
+  bool hasSizesInput = ctx.hasInput(3);
+
+  const TensorProto* scales = 2 < ctx.getNumInputs() ? ctx.getInputData(2) : nullptr;
+  std::vector<int64_t> sizes_data;
+  if (3 < ctx.getNumInputs()) {
+    bool found_sizes = false;
+    const auto sizes_shape = getShapeInput(ctx, 3, found_sizes);
+    // If sizes is an empty shape, assume it's not provided
+    if (found_sizes) {
+      if (sizes_shape.dim_size() == 0) {
+        hasSizesInput = false;
+      } else {
+        for (int i = 0; i < sizes_shape.dim_size(); ++i) {
+          sizes_data.push_back(sizes_shape.dim(i).dim_value());
+        }
+      }
+    }
+  }
+
+  // If scales is an empty constant, assume it's not provided
+  if (scales && ParseData<float>(scales).empty()) {
+    hasScalesInput = false;
+    scales = nullptr;
+  }
+
+  if (opset_version >= 13) {
+    if (hasScalesInput + hasSizesInput != 1) {
+      fail_shape_inference("Either `sizes` or `scales` must be provided, but not both of them");
+    }
+  }
+
+  const auto* const keep_aspect_ratio_policy_attr = ctx.getAttribute("keep_aspect_ratio_policy");
+  KeepAspectRatioPolicy keep_aspect_ratio_policy = KeepAspectRatioPolicy::STRETCH;
+  if (keep_aspect_ratio_policy_attr && keep_aspect_ratio_policy_attr->has_s()) {
+    auto str = keep_aspect_ratio_policy_attr->s();
+    if (str == "stretch") {
+      keep_aspect_ratio_policy = KeepAspectRatioPolicy::STRETCH;
+    } else if (str == "not_larger") {
+      keep_aspect_ratio_policy = KeepAspectRatioPolicy::NOT_LARGER;
+    } else if (str == "not_smaller") {
+      keep_aspect_ratio_policy = KeepAspectRatioPolicy::NOT_SMALLER;
+    } else {
+      fail_shape_inference("Unknown value for `keep_aspect_ratio_policy`: ", str, ".");
+    }
+  }
+
+  if (hasScalesInput && keep_aspect_ratio_policy != KeepAspectRatioPolicy::STRETCH) {
+    fail_shape_inference(
+        "Providing `scales` is incompatible with a `keep_aspect_ratio_policy` other than \"stretch\".");
+  }
+
+  if (output_shape->dim_size() > 0) {
+    if (output_shape->dim_size() != input_shape.dim_size()) {
+      fail_shape_inference(
+          "Ranks inferred (",
+          input_shape.dim_size(),
+          ") is not equal to the existing rank value (",
+          output_shape->dim_size(),
+          ").");
+    }
+  } else { // Infer the rank of output anyway
+    for (int i = 0; i < input_shape.dim_size(); ++i) {
+      output_shape->add_dim();
+    }
+  }
+
+  const auto* const axes_attr = ctx.getAttribute("axes");
+  size_t rank_x = input_shape.dim_size();
+  std::vector<int64_t> axes;
+  if (axes_attr) {
+    axes = RetrieveValues<int64_t>(*axes_attr);
+    checkAxesRange(axes, rank_x);
+    adjustNegativeAxes(axes, rank_x);
+    checkDuplicateAxes(axes, rank_x);
+  }
+  if (hasSizesInput) {
+    if (!axes.empty()) {
+      if (sizes_data.size() != axes.size()) {
+        fail_shape_inference(
+            "Number of elements of input 'sizes' (",
+            sizes_data.size(),
+            ") does not match the number of axes (",
+            axes.size(),
+            ").");
+      }
+    } else {
+      // sizes_data contains scales for all axes
+      if (sizes_data.size() != rank_x) {
+        fail_shape_inference(
+            "Number of elements of input 'sizes' (",
+            sizes_data.size(),
+            ") must be same as rank of input 'X' (",
+            rank_x,
+            ").");
+      }
+    }
+
+    // Process sizes_data according to the selected policy
+    KeepAspectRatioHelper(keep_aspect_ratio_policy, input_shape, axes, sizes_data);
+
+    // If axes subset is provided, populate new sizes_data with all dims
+    if (!axes.empty()) {
+      std::vector<int64_t> tmp(rank_x);
+      for (size_t i = 0; i < rank_x; i++) {
+        tmp[i] = input_shape.dim(i).has_dim_value() ? input_shape.dim(i).dim_value() : -1;
+      }
+      for (size_t i = 0; i < axes.size(); i++) {
+        int d = axes[i];
+        tmp[d] = sizes_data[i];
+      }
+      std::swap(tmp, sizes_data);
+    }
+
+    resizeShapeInferenceHelper(input_shape, sizes_data, output_shape);
+  } else if (nullptr != scales) {
+    // Infer output shape's dimension value if 'scales' is known.
+    if (scales->data_type() == TensorProto::FLOAT) {
+      auto scales_data = ParseData<float>(scales);
+
+      if (!axes.empty()) {
+        // scales_data contains scales for a subset of axes. The rest should not be resized
+        if (scales_data.size() != axes.size()) {
+          fail_shape_inference(
+              "Number of elements of input 'scales' (",
+              scales_data.size(),
+              ") does not match the number of axes (",
+              axes.size(),
+              ").");
+        }
+
+        std::vector<float> tmp(rank_x, 1.0f);
+        for (size_t i = 0; i < axes.size(); i++) {
+          int d = axes[i];
+          tmp[d] = scales_data[i];
+        }
+        std::swap(tmp, scales_data);
+      } else {
+        // scales_data contains scales for all axes
+        if (scales_data.size() != static_cast<size_t>(input_shape.dim_size())) {
+          fail_shape_inference("Number of elements of input 'scales' must be same as rank of input 'X'");
+        }
+      }
+      resizeShapeInferenceHelper(input_shape, scales_data, output_shape);
+    } else {
+      fail_shape_inference("Input 'scales' must have float element type.");
+    }
+  } // nullptr != scales
+}
+
+void resizeShapeInference_opset18_to_19(InferenceContext& ctx) {
+  resizeShapeInferenceVersioned(ctx, 19);
+}
+
+void resizeShapeInference_opset13_to_18(InferenceContext& ctx) {
+  resizeShapeInferenceVersioned(ctx, 13);
+}
+
+void resizeShapeInference_opset11_to_12(InferenceContext& ctx) {
+  resizeShapeInferenceVersioned(ctx, 11);
+}
+
+void resizeShapeInferenceHelper_opset7_to_10(
+    const TensorShapeProto& input_shape,
+    const std::vector<float>& scales_data,
+    TensorShapeProto* output_shape) {
+  for (int i = 0; i < input_shape.dim_size(); ++i) {
+    auto* dim = output_shape->mutable_dim(i);
+    // If input_shape has dim_value, we calculate the scaled result
+    // If input_shape doesn's have one, we leave it here
+    if (input_shape.dim(i).has_dim_value()) {
+      int64_t dim_value = static_cast<int64_t>(
+          std::floor(static_cast<double>(input_shape.dim(i).dim_value()) * static_cast<double>(scales_data[i])));
+      // If output_shape has dim_value, we validate the calculated result
+      // If output_shape doesn's have one, we set it to the scaled result
+      if (dim->has_dim_value()) {
+        if (static_cast<int64_t>(dim->dim_value()) != dim_value) {
+          fail_shape_inference(
+              "Dimension value inferred (",
+              dim_value,
+              ") is not equal to the existing dim value (",
+              dim->dim_value(),
+              ").");
+        }
+      } else {
+        dim->set_dim_value(dim_value);
+      } // dim->has_dim_value()
+    } // input_shape.dim(i).has_dim_value()
+  }
+}
+
+void resizeShapeInference_opset7_to_10(InferenceContext& ctx) {
+  propagateElemTypeFromInputToOutput(ctx, 0, 0);
+  if (!hasNInputShapes(ctx, 1)) {
+    return;
+  }
+  const auto& input_shape = getInputShape(ctx, 0);
+  auto* output_shape = getOutputShape(ctx, 0);
+  const auto* const scales = ctx.getInputData(1);
+
+  if (output_shape->dim_size() > 0) {
+    if (output_shape->dim_size() != input_shape.dim_size()) {
+      fail_shape_inference(
+          "Ranks inferred (",
+          input_shape.dim_size(),
+          ") is not equal to the existing rank value (",
+          output_shape->dim_size(),
+          ").");
+    }
+  } else { // Infer the rank of output anyway
+    for (int i = 0; i < input_shape.dim_size(); ++i) {
+      output_shape->add_dim();
+    }
+  }
+
+  if (nullptr != scales) {
+    // Infer output shape's dimension value if 'scales' is known.
+    if (scales->data_type() == TensorProto::FLOAT) {
+      const auto scales_data = ParseData<float>(scales);
+      if (scales_data.size() != static_cast<size_t>(input_shape.dim_size())) {
+        fail_shape_inference("Number of elements of input 'scales' must be same as rank of input 'X'");
+      }
+      resizeShapeInferenceHelper_opset7_to_10(input_shape, scales_data, output_shape);
+    } else {
+      fail_shape_inference("Input 'scales' must have float element type.");
+    } // nullptr != scales
+  }
+}
+
+std::function<void(OpSchema&)> PadDocGenerator(
+    const char* description,
+    const char* mode_description,
+    std::vector<std::string> op_schema,
+    std::string op_schema_description) {
+  return [=, op_schema = std::move(op_schema), op_schema_description = std::move(op_schema_description)](
+             OpSchema& schema) {
+    schema.SetDoc(description);
+    schema.Attr("mode", mode_description, AttributeProto::STRING, std::string("constant"));
+    schema.Input(0, "data", "Input tensor.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.Input(
+        1,
+        "pads",
+        "Tensor of integers indicating the number of padding elements to add or remove (if negative) "
+        "at the beginning and end of each axis. For 2D input tensor, it is the number of pixels. "
+        "`pads` should be a 1D tensor of shape [2 * num_axes] where `num_axes` refers to the number "
+        "of elements in the `axes` input or the input rank if `axes` are not provided explicitly. "
+        "`pads` format should be: [x1_begin, x2_begin, ..., x1_end, x2_end,...], "
+        "where xi_begin is the number of pad values added at the beginning of axis `axes[i]` and "
+        "xi_end, the number of pad values added at the end of axis `axes[i]`.",
+        "tensor(int64)",
+        OpSchema::Single,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Input(
+        2,
+        "constant_value",
+        "(Optional) A scalar value to be used if the mode chosen is `constant` (by default it is 0, "
+        "empty string or False).",
+        "T",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+    schema.Input(
+        3,
+        "axes",
+        "1-D tensor of axes that `pads` apply to. Negative value means counting dimensions "
+        "from the back. Accepted range is [-r, r-1] where r = rank(data). Behavior is undefined if an "
+        "axis is repeated. If not provided, all axes are assumed (`[0, 1, ..., input_rank-1]`).",
+        "Tind",
+        OpSchema::Optional,
+        true,
+        1,
+        OpSchema::NonDifferentiable);
+
+    schema.Output(0, "output", "Tensor after padding.", "T", OpSchema::Single, true, 1, OpSchema::Differentiable);
+    schema.TypeConstraint("T", op_schema, op_schema_description);
+    schema.TypeConstraint("Tind", {types::Int32, types::Int64}, "Constrain indices to integer types");
+    schema.TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+      // Type inference
+      propagateElemTypeFromInputToOutput(ctx, 0, 0);
+      // Shape inference needs the input data shape
+      if (!hasNInputShapes(ctx, 1)) {
+        return;
+      }
+      const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+      const auto input_rank = input_shape.dim_size();
+
+      std::vector<int64_t> axes;
+      if (hasInputShape(ctx, 3)) { //'axes' input
+        const auto* const axes_initializer = ctx.getInputData(3);
+        if (axes_initializer == nullptr)
+          return; // can't do shape inference then
+
+        axes = ParseData<int64_t>(axes_initializer);
+        checkAxesRange(axes, input_rank);
+        adjustNegativeAxes(axes, input_rank);
+        checkDuplicateAxes(axes, input_rank);
+      } else {
+        axes.resize(input_rank);
+        std::iota(axes.begin(), axes.end(), 0);
+      }
+
+      auto num_axes = axes.size();
+      auto* output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+
+      // Populating default dims
+      std::vector<TensorShapeProto_Dimension*> out_dims(input_rank);
+      for (int i = 0; i < input_rank; ++i) {
+        out_dims[i] = output_shape->add_dim();
+      }
+
+      // Shape Inference if
+      //     1. 'pads' are available.
+      // and 2. 'axes' are available, or default.
+      const TensorProto* pads_initializer = ctx.getInputData(1);
+      if (nullptr != pads_initializer && !axes.empty()) {
+        if (pads_initializer->dims_size() != 1 || pads_initializer->data_type() != TensorProto::INT64) {
+          fail_shape_inference("'pads' input must be a 1D (shape: [2 * num_axes]) tensor of type int64");
+        }
+
+        const auto pads_data = ParseData<int64_t>(pads_initializer);
+        if (pads_data.size() != 2 * num_axes) {
+          fail_shape_inference(
+              "Pads has incorrect number of values. Expected 2 * ",
+              num_axes,
+              " values. Got ",
+              pads_data.size(),
+              " values.");
+        }
+
+        // Set default dim values
+        for (int i = 0; i < input_rank; ++i) {
+          const auto& input_dim = input_shape.dim(i);
+          if (input_dim.has_dim_value()) {
+            out_dims[i]->set_dim_value(input_dim.dim_value());
+          }
+        }
+
+        for (size_t i = 0; i < num_axes; ++i) {
+          auto axis = axes[i];
+          const auto& input_dim = input_shape.dim(axis);
+          auto& out_dim = *out_dims[axis];
+          auto total_pad = pads_data[i] + pads_data[num_axes + i];
+          if (input_dim.has_dim_value()) {
+            out_dim.set_dim_value(input_dim.dim_value() + total_pad);
+          } else if (total_pad == 0) {
+            out_dim = input_dim;
+          }
+        }
+      }
+    });
+  };
+}
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/tensor/utils.h b/onnx/defs/tensor/utils.h
new file mode 100644
index 0000000..8ec921f
--- /dev/null
+++ b/onnx/defs/tensor/utils.h
@@ -0,0 +1,60 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cmath>
+#include <string>
+#include <vector>
+
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+// The below is called by ops after opset 11, inclusively.
+void resizeShapeInference(InferenceContext& ctx);
+
+void gridSampleShapeInference(InferenceContext& ctx);
+
+void resizeShapeInferenceHelper(
+    const TensorShapeProto& input_shape,
+    const std::vector<float>& scales_data,
+    TensorShapeProto* output_shape);
+
+void resizeShapeInferenceHelper(
+    const TensorShapeProto& input_shape,
+    const std::vector<int64_t>& sizes_data,
+    TensorShapeProto* output_shape);
+
+// Functions called by ops between opset versions in the name inclusively:
+void resizeShapeInference_opset7_to_10(InferenceContext& ctx);
+void resizeShapeInference_opset11_to_12(InferenceContext& ctx);
+void resizeShapeInference_opset13_to_18(InferenceContext& ctx);
+void resizeShapeInference_opset18_to_19(InferenceContext& ctx);
+
+void resizeShapeInferenceHelper_opset7_to_10(
+    const TensorShapeProto& input_shape,
+    const std::vector<float>& scales_data,
+    TensorShapeProto* output_shape);
+
+enum class KeepAspectRatioPolicy : std::uint8_t {
+  STRETCH,
+  NOT_LARGER,
+  NOT_SMALLER,
+};
+
+void KeepAspectRatioHelper(
+    KeepAspectRatioPolicy policy,
+    const TensorShapeProto& input_shape,
+    const std::vector<int64_t>& axes,
+    std::vector<int64_t>& sizes_data);
+
+extern const char* NonZero_ver9_doc;
+extern const char* Transpose_doc;
+
+std::function<void(OpSchema&)> PadDocGenerator(
+    const char* description,
+    const char* mode_description,
+    std::vector<std::string> op_schema = OpSchema::all_tensor_types_ir4(),
+    std::string op_schema_description = "Constrain input and output types to all tensor types.");
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/tensor_proto_util.cc b/onnx/defs/tensor_proto_util.cc
new file mode 100644
index 0000000..faebe61
--- /dev/null
+++ b/onnx/defs/tensor_proto_util.cc
@@ -0,0 +1,155 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/tensor_proto_util.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "onnx/common/platform_helpers.h"
+#include "onnx/common/safe_math.h"
+#include "onnx/defs/data_type_utils.h"
+#include "onnx/defs/shape_inference.h"
+
+namespace ONNX_NAMESPACE {
+
+#define DEFINE_TO_TENSOR_ONE(type, enumType, field) \
+  template <>                                       \
+  TensorProto ToTensor<type>(const type& value) {   \
+    TensorProto t;                                  \
+    t.set_data_type(enumType);                      \
+    t.add_##field##_data(value);                    \
+    return t;                                       \
+  }
+
+#define DEFINE_TO_TENSOR_LIST(type, enumType, field)            \
+  template <>                                                   \
+  TensorProto ToTensor<type>(const std::vector<type>& values) { \
+    TensorProto t;                                              \
+    t.clear_##field##_data();                                   \
+    t.set_data_type(enumType);                                  \
+    for (const auto& val : values) {                            \
+      t.add_##field##_data(val);                                \
+    }                                                           \
+    return t;                                                   \
+  }
+
+#define DEFINE_PARSE_DATA(type, typed_data_fetch, tensorproto_datatype)                                              \
+  template <>                                                                                                        \
+  std::vector<type> ParseData(const TensorProto* tensor_proto) {                                                     \
+    if (!tensor_proto->has_data_type() || tensor_proto->data_type() == TensorProto_DataType_UNDEFINED) {             \
+      fail_shape_inference("The type of tensor: ", tensor_proto->name(), " is undefined so it cannot be parsed.");   \
+    } else if (tensor_proto->data_type() != (tensorproto_datatype)) {                                                \
+      fail_shape_inference(                                                                                          \
+          "ParseData type mismatch for tensor: ",                                                                    \
+          tensor_proto->name(),                                                                                      \
+          ". Expected:",                                                                                             \
+          Utils::DataTypeUtils::ToDataTypeString(tensorproto_datatype),                                              \
+          " Actual:",                                                                                                \
+          Utils::DataTypeUtils::ToDataTypeString(tensor_proto->data_type()));                                        \
+    }                                                                                                                \
+    int64_t num_elements = safe_dim_product(tensor_proto->dims(), [&](const char* msg) {                             \
+      fail_shape_inference(msg, " for tensor: ", tensor_proto->name());                                              \
+    });                                                                                                              \
+    std::vector<type> res;                                                                                           \
+    if (tensor_proto->has_data_location() && tensor_proto->data_location() == TensorProto_DataLocation_EXTERNAL) {   \
+      fail_shape_inference(                                                                                          \
+          "Cannot parse data from external tensors. Please ",                                                        \
+          "load external data into raw data for tensor: ",                                                           \
+          tensor_proto->name());                                                                                     \
+    } else if (!tensor_proto->has_raw_data()) {                                                                      \
+      const auto& data = tensor_proto->typed_data_fetch();                                                           \
+      if (data.size() != num_elements) {                                                                             \
+        fail_shape_inference(                                                                                        \
+            "Data size mismatch. Tensor: ",                                                                          \
+            tensor_proto->name(),                                                                                    \
+            " expected num elements ",                                                                               \
+            num_elements,                                                                                            \
+            " does not match the actual num elements ",                                                              \
+            data.size());                                                                                            \
+      }                                                                                                              \
+      res.insert(res.end(), data.begin(), data.end());                                                               \
+      return res;                                                                                                    \
+    }                                                                                                                \
+    if (tensor_proto->data_type() == TensorProto_DataType_STRING) {                                                  \
+      fail_shape_inference(                                                                                          \
+          tensor_proto->name(),                                                                                      \
+          " data type is string. string",                                                                            \
+          " content is required to be stored in repeated bytes string_data field.",                                  \
+          " raw_data type cannot be string.");                                                                       \
+    }                                                                                                                \
+    /* The given tensor does have raw_data itself so parse it by given type */                                       \
+    /* make copy as we may have to reverse bytes */                                                                  \
+    std::string raw_data = tensor_proto->raw_data();                                                                 \
+    constexpr size_t element_size = sizeof(type);                                                                    \
+    int64_t required_bytes;                                                                                          \
+    if (checked_mul_overflow(num_elements, static_cast<int64_t>(element_size), &required_bytes)) {                   \
+      fail_shape_inference("Tensor byte size overflow for tensor: ", tensor_proto->name());                          \
+    }                                                                                                                \
+    const size_t required_bytes_sz = safe_cast_to_size(                                                              \
+        required_bytes, [&](const char* msg) { fail_shape_inference(msg, " for tensor: ", tensor_proto->name()); }); \
+    if (raw_data.size() < required_bytes_sz) {                                                                       \
+      fail_shape_inference(                                                                                          \
+          "Data size mismatch. Tensor: ",                                                                            \
+          tensor_proto->name(),                                                                                      \
+          " does not have sufficient raw_data. Required bytes: ",                                                    \
+          required_bytes,                                                                                            \
+          ", actual bytes: ",                                                                                        \
+          raw_data.size());                                                                                          \
+    }                                                                                                                \
+    /* in case raw_data has extra bytes, we only parse the required bytes according to tensor shape */               \
+    raw_data.resize(required_bytes_sz);                                                                              \
+    /* okay to remove const qualifier as we have already made a copy */                                              \
+    char* bytes = raw_data.data();                                                                                   \
+    /* onnx is little endian serialized always-tweak byte order if needed */                                         \
+    if (!is_processor_little_endian()) {                                                                             \
+      const size_t num_elements = raw_data.size() / element_size;                                                    \
+      for (size_t i = 0; i < num_elements; ++i) {                                                                    \
+        char* start_byte = bytes + i * element_size;                                                                 \
+        char* end_byte = start_byte + element_size - 1;                                                              \
+        /* keep swapping */                                                                                          \
+        for (size_t count = 0; count < element_size / 2; ++count) {                                                  \
+          char temp = *start_byte;                                                                                   \
+          *start_byte = *end_byte;                                                                                   \
+          *end_byte = temp;                                                                                          \
+          ++start_byte;                                                                                              \
+          --end_byte;                                                                                                \
+        }                                                                                                            \
+      }                                                                                                              \
+    }                                                                                                                \
+    /* raw_data.c_str()/bytes is a byte array and may not be properly  */                                            \
+    /* aligned for the underlying type */                                                                            \
+    /* We need to copy the raw_data.c_str()/bytes as byte instead of  */                                             \
+    /* copying as the underlying type, otherwise we may hit memory   */                                              \
+    /* misalignment issues on certain platforms, such as arm32-v7a */                                                \
+    res.resize(required_bytes_sz / element_size);                                                                    \
+    memcpy(reinterpret_cast<char*>(res.data()), bytes, required_bytes_sz);                                           \
+    return res;                                                                                                      \
+  }
+
+DEFINE_TO_TENSOR_ONE(float, TensorProto_DataType_FLOAT, float)
+DEFINE_TO_TENSOR_ONE(bool, TensorProto_DataType_BOOL, int32)
+DEFINE_TO_TENSOR_ONE(int32_t, TensorProto_DataType_INT32, int32)
+DEFINE_TO_TENSOR_ONE(int64_t, TensorProto_DataType_INT64, int64)
+DEFINE_TO_TENSOR_ONE(uint64_t, TensorProto_DataType_UINT64, uint64)
+DEFINE_TO_TENSOR_ONE(double, TensorProto_DataType_DOUBLE, double)
+DEFINE_TO_TENSOR_ONE(std::string, TensorProto_DataType_STRING, string)
+
+DEFINE_TO_TENSOR_LIST(float, TensorProto_DataType_FLOAT, float)
+DEFINE_TO_TENSOR_LIST(bool, TensorProto_DataType_BOOL, int32)
+DEFINE_TO_TENSOR_LIST(int32_t, TensorProto_DataType_INT32, int32)
+DEFINE_TO_TENSOR_LIST(int64_t, TensorProto_DataType_INT64, int64)
+DEFINE_TO_TENSOR_LIST(uint64_t, TensorProto_DataType_UINT64, uint64)
+DEFINE_TO_TENSOR_LIST(double, TensorProto_DataType_DOUBLE, double)
+DEFINE_TO_TENSOR_LIST(std::string, TensorProto_DataType_STRING, string)
+
+DEFINE_PARSE_DATA(int32_t, int32_data, TensorProto_DataType_INT32)
+DEFINE_PARSE_DATA(int64_t, int64_data, TensorProto_DataType_INT64)
+DEFINE_PARSE_DATA(float, float_data, TensorProto_DataType_FLOAT)
+DEFINE_PARSE_DATA(double, double_data, TensorProto_DataType_DOUBLE)
+
+#undef DEFINE_PARSE_DATA
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/tensor_proto_util.h b/onnx/defs/tensor_proto_util.h
new file mode 100644
index 0000000..46d058a
--- /dev/null
+++ b/onnx/defs/tensor_proto_util.h
@@ -0,0 +1,21 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <vector>
+
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+
+template <typename T>
+ONNX_API TensorProto ToTensor(const T& value);
+
+template <typename T>
+ONNX_API TensorProto ToTensor(const std::vector<T>& values);
+
+template <typename T>
+std::vector<T> ParseData(const TensorProto* tensor_proto);
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/tensor_util.cc b/onnx/defs/tensor_util.cc
new file mode 100644
index 0000000..e38e9d4
--- /dev/null
+++ b/onnx/defs/tensor_util.cc
@@ -0,0 +1,63 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+#include "onnx/defs/tensor_util.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "onnx/common/platform_helpers.h"
+
+namespace ONNX_NAMESPACE {
+
+#define DEFINE_PARSE_DATA(type, typed_data_fetch)                          \
+  template <>                                                              \
+  std::vector<type> ParseData(const Tensor* tensor) {                      \
+    std::vector<type> res;                                                 \
+    if (!tensor->is_raw_data()) {                                          \
+      const auto& data = tensor->typed_data_fetch();                       \
+      res.insert(res.end(), data.begin(), data.end());                     \
+      return res;                                                          \
+    }                                                                      \
+    /* make copy as we may have to reverse bytes */                        \
+    std::string raw_data = tensor->raw();                                  \
+    /* okay to remove const qualifier as we have already made a copy */    \
+    char* bytes = raw_data.data();                                         \
+    /*onnx is little endian serialized always-tweak byte order if needed*/ \
+    if (!is_processor_little_endian()) {                                   \
+      const size_t element_size = sizeof(type);                            \
+      const size_t num_elements = raw_data.size() / element_size;          \
+      for (size_t i = 0; i < num_elements; ++i) {                          \
+        char* start_byte = bytes + i * element_size;                       \
+        char* end_byte = start_byte + element_size - 1;                    \
+        /* keep swapping */                                                \
+        for (size_t count = 0; count < element_size / 2; ++count) {        \
+          char temp = *start_byte;                                         \
+          *start_byte = *end_byte;                                         \
+          *end_byte = temp;                                                \
+          ++start_byte;                                                    \
+          --end_byte;                                                      \
+        }                                                                  \
+      }                                                                    \
+    }                                                                      \
+    /* raw_data.c_str()/bytes is a byte array and may not be properly  */  \
+    /* aligned for the underlying type */                                  \
+    /* We need to copy the raw_data.c_str()/bytes as byte instead of  */   \
+    /* copying as the underlying type, otherwise we may hit memory   */    \
+    /* misalignment issues on certain platforms, such as arm32-v7a */      \
+    const size_t raw_data_size = raw_data.size();                          \
+    res.resize(raw_data_size / sizeof(type));                              \
+    memcpy(reinterpret_cast<char*>(res.data()), bytes, raw_data_size);     \
+    return res;                                                            \
+  }
+
+DEFINE_PARSE_DATA(int32_t, int32s)
+DEFINE_PARSE_DATA(int64_t, int64s)
+DEFINE_PARSE_DATA(float, floats)
+DEFINE_PARSE_DATA(double, doubles)
+DEFINE_PARSE_DATA(uint64_t, uint64s)
+
+#undef DEFINE_PARSE_DATA
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/tensor_util.h b/onnx/defs/tensor_util.h
new file mode 100644
index 0000000..7bcf76f
--- /dev/null
+++ b/onnx/defs/tensor_util.h
@@ -0,0 +1,16 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <vector>
+
+#include "onnx/common/tensor.h"
+
+namespace ONNX_NAMESPACE {
+
+template <typename T>
+std::vector<T> ParseData(const Tensor* tensor);
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/text/CMakeLists.txt b/onnx/defs/text/CMakeLists.txt
new file mode 100644
index 0000000..ebc1561
--- /dev/null
+++ b/onnx/defs/text/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+)
diff --git a/onnx/defs/text/defs.cc b/onnx/defs/text/defs.cc
new file mode 100644
index 0000000..5e3f59b
--- /dev/null
+++ b/onnx/defs/text/defs.cc
@@ -0,0 +1,203 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <string>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+static constexpr const char* StringConcat_doc =
+    R"DOC(StringConcat concatenates string tensors elementwise (with NumPy-style broadcasting support))DOC";
+ONNX_OPERATOR_SET_SCHEMA(
+    StringConcat,
+    20,
+    OpSchema()
+        .Input(
+            0,
+            "X",
+            "Tensor to prepend in concatenation",
+            "T",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Input(1, "Y", "Tensor to append in concatenation", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Output(0, "Z", "Concatenated string tensor", "T", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .TypeConstraint("T", {types::String}, "Inputs and outputs must be UTF-8 strings")
+        .SetDoc(StringConcat_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (hasNInputShapes(ctx, 2))
+            bidirectionalBroadcastShapeInference(
+                ctx.getInputType(0)->tensor_type().shape(),
+                ctx.getInputType(1)->tensor_type().shape(),
+                *ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape());
+        }));
+
+static constexpr const char* RegexFullMatch_doc =
+    R"DOC(RegexFullMatch performs a full regex match on each element of the input tensor. If an element fully matches the regex pattern specified as an attribute, the corresponding element in the output is True and it is False otherwise. [RE2](https://github.com/google/re2/wiki/Syntax) regex syntax is used.)DOC";
+ONNX_OPERATOR_SET_SCHEMA(
+    RegexFullMatch,
+    20,
+    OpSchema()
+        .Input(0, "X", "Tensor with strings to match on.", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr("pattern", "Regex pattern to match on. This must be valid RE2 syntax.", AttributeProto::STRING, false)
+        .Output(
+            0,
+            "Y",
+            "Tensor of bools indicating if each input string fully matches the regex pattern specified.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T1", {types::String}, "Inputs must be UTF-8 strings")
+        .TypeConstraint(
+            "T2",
+            {types::Bool},
+            "Outputs are bools and are True where there is a full regex match and False otherwise.")
+        .SetDoc(RegexFullMatch_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          updateOutputElemType(ctx, 0, TensorProto::BOOL);
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+
+static constexpr const char* StringSplit_doc =
+    R"DOC(StringSplit splits a string tensor's elements into substrings based on a delimiter attribute and a maxsplit attribute.
+
+The first output of this operator is a tensor of strings representing the substrings from splitting each input string on the `delimiter` substring. This tensor has one additional rank compared to the input tensor in order to store the substrings for each input element (where the input tensor is not empty). Note that, in order to ensure the same number of elements are present in the final dimension, this tensor will pad empty strings as illustrated in the examples below. Consecutive delimiters are not grouped together and are deemed to delimit empty strings, except if the `delimiter` is unspecified or is the empty string (""). In the case where the `delimiter` is unspecified or the empty string, consecutive whitespace characters are regarded as a single separator and leading or trailing whitespace is removed in the output.
+
+The second output tensor represents the number of substrings generated. `maxsplit` can be used to limit the number of splits performed - after the `maxsplit`th split if the string is not fully split, the trailing suffix of input string after the final split point is also added. For elements where fewer splits are possible than specified in `maxsplit`, it has no effect.)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    StringSplit,
+    20,
+    OpSchema()
+        .Input(0, "X", "Tensor of strings to split.", "T1", OpSchema::Single, true, 1, OpSchema::NonDifferentiable)
+        .Attr(
+            "delimiter",
+            "Delimiter to split on. If left unset or set to the empty string (\"\"), the input is split on consecutive whitespace.",
+            AttributeProto::STRING,
+            false)
+        .Attr(
+            "maxsplit",
+            "Maximum number of splits (from left to right). If left unset (or if the number of possible splits are less than maxsplit), it will make as many splits as possible. Note that the maximum possible number of substrings returned with `maxsplit` specified is `maxsplit+1` since the remaining suffix after the `maxsplit`th split is included in the output.",
+            AttributeProto::INT,
+            false)
+        .Output(
+            0,
+            "Y",
+            "Tensor of substrings representing the outcome of splitting the strings in the input on the delimiter. Note that to ensure the same number of elements are present in the final rank, this tensor will pad any necessary empty strings.",
+            "T2",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .Output(
+            1,
+            "Z",
+            "The number of substrings generated for each input element.",
+            "T3",
+            OpSchema::Single,
+            true,
+            1,
+            OpSchema::NonDifferentiable)
+        .TypeConstraint("T1", {types::String}, "The input must be a UTF-8 string tensor")
+        .TypeConstraint("T2", {types::String}, "Tensor of substrings.")
+        .TypeConstraint("T3", {types::Int64}, "The number of substrings generated.")
+        .SetDoc(StringSplit_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+          const TypeProto* input_type = ctx.getInputType(0);
+          if (input_type == nullptr || !input_type->has_tensor_type() ||
+              input_type->tensor_type().elem_type() != TensorProto::STRING) {
+            return;
+          }
+
+          // We produce a string tensor per input element. Therefore we have one additional rank with a runtime
+          // dependent number of elements. All except the final dimension of the output shape can be inferred directly
+          // from the input.
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+          getOutputShape(ctx, 0)->add_dim();
+
+          // The output tensor containing the number of substrings has identical shape to the input but produces int32
+          // results.
+          ctx.getOutputType(1)->mutable_tensor_type()->set_elem_type(TensorProto::INT64);
+          propagateShapeFromInputToOutput(ctx, 0, 1);
+        }));
+
+static constexpr const char* StringNormalizer_ver10_doc = R"DOC(
+StringNormalization performs string operations for basic cleaning.
+This operator has only one input (denoted by X) and only one output
+(denoted by Y). This operator first examines the elements in the X,
+and removes elements specified in "stopwords" attribute.
+After removing stop words, the intermediate result can be further lowercased,
+uppercased, or just returned depending the "case_change_action" attribute.
+This operator only accepts [C]- and [1, C]-tensor.
+If all elements in X are dropped, the output will be the empty value of string tensor with shape [1]
+if input shape is [C] and shape [1, 1] if input shape is [1, C].
+)DOC";
+
+ONNX_OPERATOR_SET_SCHEMA(
+    StringNormalizer,
+    10,
+    OpSchema()
+        .Input(0, "X", "UTF-8 strings to normalize", "tensor(string)")
+        .Output(0, "Y", "UTF-8 Normalized strings", "tensor(string)")
+        .Attr(
+            std::string("case_change_action"),
+            std::string(
+                "string enum that cases output to be lowercased/uppercases/unchanged."
+                " Valid values are \"LOWER\", \"UPPER\", \"NONE\". Default is \"NONE\""),
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            std::string("is_case_sensitive"),
+            std::string("Boolean. Whether the identification of stop words in X is case-sensitive. Default is false"),
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "stopwords",
+            "List of stop words. If not set, no word would be removed from X.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "locale",
+            "Environment dependent string that denotes the locale according to which output strings needs to be upper/lowercased."
+            "Default en_US or platform specific equivalent as decided by the implementation.",
+            AttributeProto::STRING,
+            OPTIONAL_VALUE)
+        .SetDoc(StringNormalizer_ver10_doc)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto output_elem_type = ctx.getOutputType(0)->mutable_tensor_type();
+          output_elem_type->set_elem_type(TensorProto::STRING);
+          if (!hasInputShape(ctx, 0)) {
+            return;
+          }
+          TensorShapeProto output_shape;
+          auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          auto dim_size = input_shape.dim_size();
+          // Last axis dimension is unknown if we have stop-words since we do
+          // not know how many stop-words are dropped
+          if (dim_size == 1) {
+            // Unknown output dimension
+            output_shape.add_dim();
+          } else if (dim_size == 2) {
+            // Copy B-dim
+            auto& b_dim = input_shape.dim(0);
+            if (!b_dim.has_dim_value() || b_dim.dim_value() != 1) {
+              fail_shape_inference("Input shape must have either [C] or [1,C] dimensions where C > 0");
+            }
+            *output_shape.add_dim() = b_dim;
+            output_shape.add_dim();
+          } else {
+            fail_shape_inference("Input shape must have either [C] or [1,C] dimensions where C > 0");
+          }
+          updateOutputShape(ctx, 0, output_shape);
+        }));
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/traditionalml/CMakeLists.txt b/onnx/defs/traditionalml/CMakeLists.txt
new file mode 100644
index 0000000..e27fa8d
--- /dev/null
+++ b/onnx/defs/traditionalml/CMakeLists.txt
@@ -0,0 +1,8 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+    old.cc
+    utils.h
+)
diff --git a/onnx/defs/traditionalml/defs.cc b/onnx/defs/traditionalml/defs.cc
new file mode 100644
index 0000000..16a2680
--- /dev/null
+++ b/onnx/defs/traditionalml/defs.cc
@@ -0,0 +1,1271 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "onnx/common/safe_math.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/traditionalml/utils.h"
+#include "onnx/defs/type_builders.h"
+
+#ifdef ONNX_ML
+namespace ONNX_NAMESPACE {
+static constexpr const char* ArrayFeatureExtractor_ver1_doc = R"DOC(
+    Select elements of the input tensor based on the indices passed.<br>
+    The indices are applied to the last axes of the tensor.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    ArrayFeatureExtractor,
+    1,
+    OpSchema()
+        .SetDoc(ArrayFeatureExtractor_ver1_doc)
+        .Input(0, "X", "Data to be selected", "T")
+        .Input(1, "Y", "The indices, based on 0 as the first index of any dimension.", "tensor(int64)")
+        .Output(0, "Z", "Selected output data as an array", "T")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          propagateElemTypeFromInputToOutput(ctx, 0, 0);
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          const auto input_ndim = input_shape.dim_size();
+          if (input_ndim == 1) {
+            return;
+          }
+          auto output_shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          // This operator only applies to the last dimension; thus -1
+          for (int i = 0; i < input_ndim - 1; ++i) {
+            *output_shape->add_dim() = input_shape.dim(i);
+          }
+
+          // value of the output's last dimension is the total amount of indices
+          // set Unknown length for the last dimension if it cannot be calculated
+          auto last_dim = output_shape->add_dim();
+          if (hasInputShape(ctx, 1)) {
+            const auto& indices_shape = getInputShape(ctx, 1);
+            if (indices_shape.dim_size() > 0) {
+              int64_t num_indices = 1;
+              std::string single_symbolic_dim;
+              for (int i = 0; i < indices_shape.dim_size(); i++) {
+                if (indices_shape.dim(i).has_dim_value()) {
+                  if (checked_mul_overflow(num_indices, indices_shape.dim(i).dim_value(), &num_indices)) {
+                    fail_shape_inference("Dimension product overflow in ArrayFeatureExtractor");
+                  }
+                } else if (indices_shape.dim(i).has_dim_param()) {
+                  if (single_symbolic_dim.empty()) {
+                    // it is possible to set symbolic dimension param if the rest dim values are all
+                    // value 1
+                    single_symbolic_dim = indices_shape.dim(i).dim_param();
+                  } else {
+                    return;
+                  }
+                } else {
+                  return;
+                }
+              }
+              if (single_symbolic_dim.empty()) {
+                last_dim->set_dim_value(num_indices);
+              } else if (num_indices == 1) {
+                last_dim->set_dim_param(single_symbolic_dim);
+              }
+            }
+          }
+        })
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32, types::String},
+            "The input must be a tensor of a numeric type or string. The output will be of the same tensor type."));
+
+static constexpr const char* Binarizer_ver1_doc = R"DOC(
+    Maps the values of the input tensor to either 0 or 1, element-wise, based on the outcome of a comparison against a threshold value.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    Binarizer,
+    1,
+    OpSchema()
+        .SetDoc(Binarizer_ver1_doc)
+        .Input(0, "X", "Data to be binarized", "T")
+        .Output(0, "Y", "Binarized output data", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input must be a tensor of a numeric type. The output will be of the same tensor type.")
+        .Attr("threshold", "Values greater than this are mapped to 1, others to 0.", AttributeProto::FLOAT, 0.f)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) { propagateShapeAndTypeFromFirstInput(ctx); }));
+
+static constexpr const char* CastMap_ver1_doc = R"DOC(
+    Converts a map to a tensor.<br>The map key must be an int64 and the values will be ordered
+    in ascending order based on this key.<br>The operator supports dense packing or sparse packing.
+    If using sparse packing, the key cannot exceed the max_map-1 value.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    CastMap,
+    1,
+    OpSchema()
+        .SetDoc(CastMap_ver1_doc)
+        .Input(0, "X", "The input map that is to be cast to a tensor", "T1")
+        .Output(0, "Y", "A tensor representing the same data as the input map, ordered by their keys", "T2")
+        .TypeConstraint(
+            "T1",
+            {types::Map<TensorProto::INT64>("string"), types::Map<TensorProto::INT64>("float")},
+            "The input must be an integer map to either string or float.")
+        .TypeConstraint(
+            "T2",
+            {types::String, types::Float, types::Int64},
+            "The output is a 1-D tensor of string, float, or integer.")
+        .Attr(
+            "cast_to",
+            "A string indicating the desired element type of the output tensor, one of 'TO_FLOAT', 'TO_STRING', "
+            "'TO_INT64'.",
+            AttributeProto::STRING,
+            std::string("TO_FLOAT"))
+        .Attr(
+            "map_form",
+            "Indicates whether to only output as many values as are in the input (dense), or position the input based "
+            "on using the key of the map as the index of the output (sparse).<br>One of 'DENSE', 'SPARSE'.",
+            AttributeProto::STRING,
+            std::string("DENSE"))
+        .Attr(
+            "max_map",
+            "If the value of map_form is 'SPARSE,' this attribute indicates the total length of the output tensor.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto cast_to_attr = ctx.getAttribute("cast_to");
+          auto output_type = ctx.getOutputType(0)->mutable_tensor_type();
+          if (nullptr == cast_to_attr) {
+            output_type->set_elem_type(TensorProto::FLOAT);
+            return;
+          }
+          auto& cast_to = cast_to_attr->s();
+          if ("TO_FLOAT" == cast_to) {
+            output_type->set_elem_type(TensorProto::FLOAT);
+          } else if ("TO_INT64" == cast_to) {
+            output_type->set_elem_type(TensorProto::INT64);
+          } else if ("TO_STRING" == cast_to) {
+            output_type->set_elem_type(TensorProto::STRING);
+          }
+        }));
+
+static constexpr const char* CategoryMapper_ver1_doc = R"DOC(
+    Converts strings to integers and vice versa.<br>
+    Two sequences of equal length are used to map between integers and strings,
+    with strings and integers at the same index detailing the mapping.<br>
+    Each operator converts either integers to strings or strings to integers, depending
+    on which default value attribute is provided. Only one default value attribute
+    should be defined.<br>
+    If the string default value is set, it will convert integers to strings.
+    If the int default value is set, it will convert strings to integers.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    CategoryMapper,
+    1,
+    OpSchema()
+        .SetDoc(CategoryMapper_ver1_doc)
+        .Input(0, "X", "Input data", "T1")
+        .Output(0, "Y", "Output data. If strings are input, the output values are integers, and vice versa.", "T2")
+        .TypeConstraint(
+            "T1",
+            {types::String, types::Int64},
+            "The input must be a tensor of strings or integers, either [N,C] or [C].")
+        .TypeConstraint(
+            "T2",
+            {types::String, types::Int64},
+            "The output is a tensor of strings or integers. Its shape will be the same as the input shape.")
+        .Attr(
+            "cats_strings",
+            "The strings of the map. This sequence must be the same length as the 'cats_int64s' sequence",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "cats_int64s",
+            "The integers of the map. This sequence must be the same length as the 'cats_strings' sequence.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "default_string",
+            "A string to use when an input integer value is not found in the map.<br>One and only one of the "
+            "'default_*' attributes must be defined.",
+            AttributeProto::STRING,
+            std::string("_Unused"))
+        .Attr(
+            "default_int64",
+            "An integer to use when an input string value is not found in the map.<br>One and only one of the "
+            "'default_*' attributes must be defined.",
+            AttributeProto::INT,
+            static_cast<int64_t>(-1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto cats_int64s = ctx.getAttribute("cats_int64s");
+          if (cats_int64s == nullptr) {
+            fail_shape_inference("Attribute 'cats_int64s' is required.");
+          }
+          auto cats_strings = ctx.getAttribute("cats_strings");
+          if (cats_strings == nullptr) {
+            fail_shape_inference("Attribute 'cats_strings' is required.");
+          }
+          if (cats_int64s->ints_size() != cats_strings->strings_size()) {
+            fail_shape_inference("Attributes 'cats_int64s' and 'cats_strings' are required to be the same length.");
+          }
+          if (nullptr == ctx.getInputType(0)) {
+            return;
+          }
+          auto input_elem_type = ctx.getInputType(0)->tensor_type().elem_type();
+          if (TensorProto::STRING == input_elem_type) {
+            updateOutputElemType(ctx, 0, TensorProto::INT64);
+          } else if (TensorProto::INT64 == input_elem_type) {
+            updateOutputElemType(ctx, 0, TensorProto::STRING);
+          }
+          if (hasInputShape(ctx, 0)) {
+            propagateShapeFromInputToOutput(ctx, 0, 0);
+          }
+        }));
+
+static constexpr const char* DictVectorizer_ver1_doc = R"DOC(
+    Uses an index mapping to convert a dictionary to an array.<br>
+    Given a dictionary, each key is looked up in the vocabulary attribute corresponding to
+    the key type. The index into the vocabulary array at which the key is found is then
+    used to index the output 1-D tensor 'Y' and insert into it the value found in the dictionary 'X'.<br>
+    The key type of the input map must correspond to the element type of the defined vocabulary attribute.
+    Therefore, the output array will be equal in length to the index mapping vector parameter.
+    All keys in the input dictionary must be present in the index mapping vector.
+    For each item in the input dictionary, insert its value in the output array.
+    Any keys not present in the input dictionary, will be zero in the output array.<br>
+    For example: if the ``string_vocabulary`` parameter is set to ``["a", "c", "b", "z"]``,
+    then an input of ``{"a": 4, "c": 8}`` will produce an output of ``[4, 8, 0, 0]``.
+    )DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    DictVectorizer,
+    1,
+    OpSchema()
+        .SetDoc(DictVectorizer_ver1_doc)
+        .Input(0, "X", "A dictionary.", "T1")
+        .Output(0, "Y", "A 1-D tensor holding values from the input dictionary.", "T2")
+        .TypeConstraint(
+            "T1",
+            {types::Map<TensorProto::STRING>("int64"),
+             types::Map<TensorProto::INT64>("string"),
+             types::Map<TensorProto::INT64>("float"),
+             types::Map<TensorProto::INT64>("double"),
+             types::Map<TensorProto::STRING>("float"),
+             types::Map<TensorProto::STRING>("double")},
+            "The input must be a map from strings or integers to either strings or a numeric type. The key and value "
+            "types cannot be the same.")
+        .TypeConstraint(
+            "T2",
+            {types::Int64, types::Float, types::Double, types::String},
+            "The output will be a tensor of the value type of the input map. It's shape will be [1,C], where C is the "
+            "length of the input dictionary.")
+        .Attr(
+            "string_vocabulary",
+            "A string vocabulary array.<br>One and only one of the vocabularies must be defined.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "int64_vocabulary",
+            "An integer vocabulary array.<br>One and only one of the vocabularies must be defined.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto input_elem_type = ctx.getInputType(0)->map_type().value_type().tensor_type().elem_type();
+          auto output_elem_type = ctx.getOutputType(0)->mutable_tensor_type();
+          output_elem_type->set_elem_type(input_elem_type);
+        }));
+
+static constexpr const char* FeatureVectorizer_ver1_doc = R"DOC(
+    Concatenates input tensors into one continuous output.<br>
+    All input shapes are 2-D and are concatenated along the second dimension. 1-D tensors are treated as [1,C].
+    Inputs are copied to the output maintaining the order of the input arguments.<br>
+    All inputs must be integers or floats, while the output will be all floating point values.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    FeatureVectorizer,
+    1,
+    OpSchema()
+        .SetDoc(FeatureVectorizer_ver1_doc)
+        .Input(0, "X", "An ordered collection of tensors, all with the same element type.", "T1", OpSchema::Variadic)
+        .Output(0, "Y", "The output array, elements ordered as the inputs.", "tensor(float)")
+        .TypeConstraint(
+            "T1",
+            {types::Int32, types::Int64, types::Float, types::Double},
+            "The input type must be a tensor of a numeric type.")
+        .Attr("inputdimensions", "The size of each input in the input list", AttributeProto::INTS, OPTIONAL_VALUE));
+
+static constexpr const char* Imputer_ver1_doc = R"DOC(
+    Replaces inputs that equal one value with another, leaving all other elements alone.<br>
+    This operator is typically used to replace missing values in situations where they have a canonical
+    representation, such as -1, 0, NaN, or some extreme value.<br>
+    One and only one of imputed_value_floats or imputed_value_int64s should be defined -- floats if the input tensor
+    holds floats, integers if the input tensor holds integers. The imputed values must all fit within the
+    width of the tensor element type. One and only one of the replaced_value_float or replaced_value_int64 should be defined,
+    which one depends on whether floats or integers are being processed.<br>
+    The imputed_value attribute length can be 1 element, or it can have one element per input feature.<br>In other words, if the input tensor has the shape [*,F], then the length of the attribute array may be 1 or F. If it is 1, then it is broadcast along the last dimension and applied to each feature.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    Imputer,
+    1,
+    OpSchema()
+        .SetDoc(Imputer_ver1_doc)
+        .Input(0, "X", "Data to be processed.", "T")
+        .Output(0, "Y", "Imputed output data", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input type must be a tensor of a numeric type, either [N,C] or [C]. The output type will be of the "
+            "same tensor type and shape.")
+        .Attr("imputed_value_floats", "Value(s) to change to", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("replaced_value_float", "A value that needs replacing.", AttributeProto::FLOAT, 0.f)
+        .Attr("imputed_value_int64s", "Value(s) to change to.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("replaced_value_int64", "A value that needs replacing.", AttributeProto::INT, static_cast<int64_t>(0)));
+
+static constexpr const char* LabelEncoder_ver4_doc = R"DOC(
+    Maps each element in the input tensor to another value.<br>
+    The mapping is determined by the two parallel attributes, 'keys_*' and
+    'values_*' attribute. The i-th value in the specified 'keys_*' attribute
+    would be mapped to the i-th value in the specified 'values_*' attribute. It
+    implies that input's element type and the element type of the specified
+    'keys_*' should be identical while the output type is identical to the
+    specified 'values_*' attribute. Note that the 'keys_*' and 'values_*' attributes
+    must have the same length. If an input element can not be found in the
+    specified 'keys_*' attribute, the 'default_*' that matches the specified
+    'values_*' attribute may be used as its output value. The type of the 'default_*'
+    attribute must match the 'values_*' attribute chosen. <br>
+    Let's consider an example which maps a string tensor to an integer tensor.
+    Assume and 'keys_strings' is ["Amy", "Sally"], 'values_int64s' is [5, 6],
+    and 'default_int64' is '-1'.  The input ["Dori", "Amy", "Amy", "Sally",
+    "Sally"] would be mapped to [-1, 5, 5, 6, 6].<br>
+    Since this operator is an one-to-one mapping, its input and output shapes
+    are the same. Notice that only one of 'keys_*'/'values_*' can be set.<br>
+    Float keys with value 'NaN' match any input 'NaN' value regardless of bit
+    value. If a key is repeated, the last key takes precedence.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    LabelEncoder,
+    4,
+    OpSchema()
+        .SetDoc(LabelEncoder_ver4_doc)
+        .Input(0, "X", "Input data. It must have the same element type as the keys_* attribute set.", "T1")
+        .Output(0, "Y", "Output data. This tensor's element type is based on the values_* attribute set.", "T2")
+        .TypeConstraint(
+            "T1",
+            {types::String, types::Int64, types::Float, types::Int32, types::Int16, types::Double},
+            "The input type is a tensor of any shape.")
+        .TypeConstraint(
+            "T2",
+            {types::String, types::Int64, types::Float, types::Int32, types::Int16, types::Double},
+            "Output type is determined by the specified 'values_*' attribute.")
+        .Attr(
+            "keys_tensor",
+            "Keys encoded as a 1D tensor. One and only one of 'keys_*'s should be set.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr("keys_strings", "A list of strings.", AttributeProto::STRINGS, OPTIONAL_VALUE)
+        .Attr("keys_int64s", "A list of ints.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("keys_floats", "A list of floats.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "values_tensor",
+            "Values encoded as a 1D tensor. One and only one of 'values_*'s should be set.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr("values_strings", "A list of strings.", AttributeProto::STRINGS, OPTIONAL_VALUE)
+        .Attr("values_int64s", "A list of ints.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("values_floats", "A list of floats.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("default_string", "A string.", AttributeProto::STRING, std::string("_Unused"))
+        .Attr("default_int64", "An integer.", AttributeProto::INT, static_cast<int64_t>(-1))
+        .Attr("default_float", "A float.", AttributeProto::FLOAT, -0.f)
+        .Attr(
+            "default_tensor",
+            "A default tensor. {\"_Unused\"} if values_* has string type, {-1} if values_* has integral type, and "
+            "{-0.f} if values_* has float type.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto [key_type, key_length] =
+              getAttributeElementTypeAndLength(ctx, {"keys_tensor", "keys_strings", "keys_int64s", "keys_floats"});
+          if (key_type == TensorProto::UNDEFINED) {
+            fail_shape_inference("At least one of keys_tensor, keys_strings, keys_int64s, keys_floats must be set.");
+          }
+          if (key_type != ctx.getInputType(0)->tensor_type().elem_type()) {
+            fail_shape_inference(
+                "The input type was ",
+                ctx.getInputType(0)->tensor_type().elem_type(),
+                " and the key type ",
+                key_type,
+                " are different, which is not permitted for LabelEncoders.");
+          }
+
+          auto [value_type, value_length] = getAttributeElementTypeAndLength(
+              ctx, {"values_tensor", "values_strings", "values_int64s", "values_floats"});
+          if (value_type == TensorProto::UNDEFINED) {
+            fail_shape_inference(
+                "At least one of values_tensor, values_strings, values_int64s, values_floats must be set.");
+          }
+          if (value_length != key_length) {
+            fail_shape_inference(
+                "The number of keys ",
+                key_length,
+                " and the number of values ",
+                value_length,
+                " must be the same in the LabelEncoder.");
+          }
+
+          auto default_attr = ctx.getAttribute("default_tensor");
+          if (nullptr != default_attr && default_attr->has_t() && default_attr->t().has_data_type() &&
+              default_attr->t().data_type() != TensorProto_DataType_UNDEFINED) {
+            auto default_tensor = default_attr->t();
+            if (default_tensor.data_type() != value_type) {
+              fail_shape_inference(
+                  "The default tensor type ",
+                  default_tensor.data_type(),
+                  " and the value type ",
+                  value_type,
+                  " must be the same in the LabelEncoder.");
+            }
+            if (1 != default_tensor.dims_size() || 1 != default_tensor.dims(0)) {
+              fail_shape_inference("The default tensor must be a singleton 1D tensor.");
+            }
+          }
+          // Propagate shape from input type and assign output type based on value type
+          ctx.getOutputType(0)->mutable_tensor_type()->set_elem_type(value_type);
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+
+static constexpr const char* LinearClassifier_ver1_doc = R"DOC(
+    Linear classifier
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    LinearClassifier,
+    1,
+    OpSchema()
+        .SetDoc(LinearClassifier_ver1_doc)
+        .Input(0, "X", "Data to be classified.", "T1")
+        .Output(0, "Y", "Classification outputs (one class per example).", "T2")
+        .Output(1, "Z", "Classification scores ([N,E] - one score for each class and example", "tensor(float)")
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input must be a tensor of a numeric type, and of shape [N,C] or [C]. In the latter case, it will be "
+            "treated as [1,C]")
+        .TypeConstraint("T2", {types::String, types::Int64}, "The output will be a tensor of strings or integers.")
+        .Attr("coefficients", "A collection of weights of the model(s).", AttributeProto::FLOATS)
+        .Attr("intercepts", "A collection of intercepts.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "multi_class",
+            "Indicates whether to do OvR or multinomial (0=OvR is the default).",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "classlabels_strings",
+            "Class labels when using string labels. One and only one 'classlabels' attribute must be defined.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_ints",
+            "Class labels when using integer labels. One and only one 'classlabels' attribute must be defined.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the scores vector.<br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' "
+            "'SOFTMAX_ZERO,' or 'PROBIT'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          std::vector<std::string> label_strs;
+          std::vector<int64_t> label_ints;
+
+          auto labels_strings_present = getRepeatedAttribute(ctx, "classlabels_strings", label_strs);
+          bool using_strings = (labels_strings_present && !label_strs.empty());
+
+          if (!using_strings) {
+            getRepeatedAttribute(ctx, "classlabels_ints", label_ints);
+          }
+
+          // Type inference
+          auto output_elem_type = ctx.getOutputType(0)->mutable_tensor_type();
+          if (using_strings) {
+            output_elem_type->set_elem_type(TensorProto::STRING);
+          } else {
+            output_elem_type->set_elem_type(TensorProto::INT64);
+          }
+
+          // second output is always of float type
+          ctx.getOutputType(1)->mutable_tensor_type()->set_elem_type(TensorProto::FLOAT);
+
+          // Shape/Rank inference begins
+
+          // establish the number of classes
+          std::vector<float> intercepts;
+          getRepeatedAttribute(ctx, "intercepts", intercepts);
+          int class_count = static_cast<int>(intercepts.size());
+          if (intercepts.size() == 1 &&
+              ((using_strings && label_strs.size() == 2) || (!using_strings && label_ints.size() == 2))) {
+            class_count = 2;
+          }
+
+          TensorShapeProto_Dimension batch_size_dim, class_count_dim;
+          class_count_dim.set_dim_value(class_count);
+
+          if (hasNInputShapes(ctx, 1)) {
+            const auto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+            const auto input_rank = input_shape.dim_size();
+            if (input_rank == 1) {
+              // if input_rank is 1, batch_size is interpreted to be 1
+              batch_size_dim.set_dim_value(1);
+            } else if (input_rank == 2) {
+              batch_size_dim = input_shape.dim(0);
+            } else {
+              fail_shape_inference("Input's shape should be 1D or 2D");
+            }
+          }
+
+          updateOutputShape(ctx, 0, {batch_size_dim});
+          updateOutputShape(ctx, 1, {batch_size_dim, class_count_dim});
+        }));
+
+static constexpr const char* LinearRegressor_ver1_doc = R"DOC(
+    Generalized linear regression evaluation.<br>
+    If targets is set to 1 (default) then univariate regression is performed.<br>
+    If targets is set to M then M sets of coefficients must be passed in as a sequence
+    and M results will be output for each input n in N.<br>
+    The coefficients array is of length n, and the coefficients for each target are contiguous.
+    Intercepts are optional but if provided must match the number of targets.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    LinearRegressor,
+    1,
+    OpSchema()
+        .SetDoc(LinearRegressor_ver1_doc)
+        .Input(0, "X", "Data to be regressed.", "T")
+        .Output(0, "Y", "Regression outputs (one per target, per example).", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input must be a tensor of a numeric type.")
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the regression output vector.<br>One of 'NONE,' 'SOFTMAX,' "
+            "'LOGISTIC,' 'SOFTMAX_ZERO,' or 'PROBIT'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr("coefficients", "Weights of the model(s).", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("intercepts", "Weights of the intercepts, if used.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "targets",
+            "The total number of regression targets, 1 if not defined.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1)));
+
+static constexpr const char* Normalizer_ver1_doc = R"DOC(
+    Normalize the input.  There are three normalization modes, which have the corresponding formulas,
+    defined using element-wise infix operators '/' and '^' and tensor-wide functions 'max' and 'sum':<br>
+<br>
+    Max: Y = X / max(X)<br>
+    L1:  Y = X / sum(X)<br>
+    L2:  Y = sqrt(X^2 / sum(X^2)}<br>
+    In all modes, if the divisor is zero, Y == X.
+<br>
+    For batches, that is, [N,C] tensors, normalization is done along the C axis. In other words, each row
+    of the batch is normalized independently.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    Normalizer,
+    1,
+    OpSchema()
+        .SetDoc(Normalizer_ver1_doc)
+        .Input(0, "X", "Data to be encoded, a tensor of shape [N,C] or [C]", "T")
+        .Output(0, "Y", "Encoded output data", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input must be a tensor of a numeric type.")
+        .Attr("norm", "One of 'MAX,' 'L1,' 'L2'", AttributeProto::STRING, std::string("MAX")));
+
+static constexpr const char* OneHotEncoder_ver1_doc = R"DOC(
+    Replace each input element with an array of ones and zeros, where a single
+    one is placed at the index of the category that was passed in. The total category count
+    will determine the size of the extra dimension of the output array Y.<br>
+    For example, if we pass a tensor with a single value of 4, and a category count of 8,
+    the output will be a tensor with ``[0,0,0,0,1,0,0,0]``.<br>
+    This operator assumes every input feature is from the same set of categories.<br>
+    If the input is a tensor of float, int32, or double, the data will be cast
+    to integers and the cats_int64s category list will be used for the lookups.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    OneHotEncoder,
+    1,
+    OpSchema()
+        .SetDoc(OneHotEncoder_ver1_doc)
+        .Input(0, "X", "Data to be encoded.", "T")
+        .Output(0, "Y", "Encoded output data, having one more dimension than X.", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {types::String, types::Int64, types::Int32, types::Float, types::Double},
+            "The input must be a tensor of a numeric type.")
+        .Attr(
+            "cats_int64s",
+            "List of categories, ints.<br>One and only one of the 'cats_*' attributes must be defined.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "cats_strings",
+            "List of categories, strings.<br>One and only one of the 'cats_*' attributes must be defined.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "zeros",
+            "If true and category is not present, will return all zeros; if false and a category if not found, the "
+            "operator will fail.",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          std::vector<int64_t> cats_int64s;
+          bool has_int64s = getRepeatedAttribute(ctx, "cats_int64s", cats_int64s);
+          std::vector<std::string> cats_strings;
+          bool has_strings = getRepeatedAttribute(ctx, "cats_strings", cats_strings);
+          if (has_int64s == has_strings) {
+            fail_shape_inference("Exactly one of 'cats_*' attributes must be provided.");
+          }
+          // Check if input shape is available before accessing it
+          if (!hasNInputShapes(ctx, 1)) {
+            return;
+          }
+          const TensorShapeProto& input_shape = ctx.getInputType(0)->tensor_type().shape();
+          TensorShapeProto* shape = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape();
+          for (int i = 0; i < input_shape.dim_size(); i++) {
+            *shape->add_dim() = input_shape.dim(i);
+          }
+          shape->add_dim()->set_dim_value(std::max(cats_int64s.size(), cats_strings.size()));
+          updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+        }));
+
+static constexpr const char* Scaler_ver1_doc = R"DOC(
+    Rescale input data, for example to standardize features by removing the mean and scaling to unit variance.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    Scaler,
+    1,
+    OpSchema()
+        .SetDoc(Scaler_ver1_doc)
+        .Input(0, "X", "Data to be scaled.", "T")
+        .Output(0, "Y", "Scaled output data.", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input must be a tensor of a numeric type.")
+        .Attr(
+            "offset",
+            "First, offset by this.<br>Can be length of features in an [N,F] tensor or length 1, in which case it "
+            "applies to all features, regardless of dimension count.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "scale",
+            "Second, multiply by this.<br>Can be length of features in an [N,F] tensor or length 1, in which case it "
+            "applies to all features, regardless of dimension count.<br>Must be same length as 'offset'",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE));
+
+static constexpr const char* SVMClassifier_ver1_doc = R"DOC(
+    Support Vector Machine classifier
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    SVMClassifier,
+    1,
+    OpSchema()
+        .SetDoc(SVMClassifier_ver1_doc)
+        .Input(0, "X", "Data to be classified.", "T1")
+        .Output(0, "Y", "Classification outputs (one class per example).", "T2")
+        .Output(
+            1,
+            "Z",
+            "Class scores (one per class per example), if prob_a and prob_b are provided they are probabilities for "
+            "each class, otherwise they are raw scores.",
+            "tensor(float)")
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input must be a tensor of a numeric type, either [C] or [N,C].")
+        .TypeConstraint(
+            "T2",
+            {types::String, types::Int64},
+            "The output type will be a tensor of strings or integers, depending on which of the classlabels_* "
+            "attributes is used. Its size will match the batch size of the input.")
+        .Attr(
+            "kernel_type",
+            "The kernel type, one of 'LINEAR,' 'POLY,' 'RBF,' 'SIGMOID'.",
+            AttributeProto::STRING,
+            std::string("LINEAR"))
+        .Attr(
+            "kernel_params",
+            "List of 3 elements containing gamma, coef0, and degree, in that order. Zero if unused for the kernel.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr("vectors_per_class", "", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("support_vectors", "", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("coefficients", "", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("prob_a", "First set of probability coefficients.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "prob_b",
+            "Second set of probability coefficients. This array must be same size as prob_a.<br>If these are provided "
+            "then output Z are probability estimates, otherwise they are raw scores.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr("rho", "", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            "classlabels_strings",
+            "Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_ints",
+            "Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          std::vector<std::string> label_strs;
+          auto result = getRepeatedAttribute(ctx, "classlabels_strings", label_strs);
+          bool using_strings = (result && !label_strs.empty());
+          auto output_elem_type = ctx.getOutputType(0)->mutable_tensor_type();
+          if (using_strings) {
+            output_elem_type->set_elem_type(TensorProto::STRING);
+          } else {
+            output_elem_type->set_elem_type(TensorProto::INT64);
+          }
+        }));
+
+static constexpr const char* SVMRegressor_ver1_doc = R"DOC(
+    Support Vector Machine regression prediction and one-class SVM anomaly detection.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    SVMRegressor,
+    1,
+    OpSchema()
+        .SetDoc(SVMRegressor_ver1_doc)
+        .Input(0, "X", "Data to be regressed.", "T")
+        .Output(0, "Y", "Regression outputs (one score per target per example).", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input type must be a tensor of a numeric type, either [C] or [N,C].")
+        .Attr(
+            "kernel_type",
+            "The kernel type, one of 'LINEAR,' 'POLY,' 'RBF,' 'SIGMOID'.",
+            AttributeProto::STRING,
+            std::string("LINEAR"))
+        .Attr(
+            "kernel_params",
+            "List of 3 elements containing gamma, coef0, and degree, in that order. Zero if unused for the kernel.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr("support_vectors", "Chosen support vectors", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "one_class",
+            "Flag indicating whether the regression is a one-class SVM or not.",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr("coefficients", "Support vector coefficients.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("n_supports", "The number of support vectors.", AttributeProto::INT, static_cast<int64_t>(0))
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT.'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr("rho", "", AttributeProto::FLOATS, OPTIONAL_VALUE));
+
+static constexpr const char* TreeEnsembleClassifier_ver5_doc = R"DOC(
+    This operator is DEPRECATED. Please use TreeEnsemble with provides similar functionality.
+    In order to determine the top class, the ArgMax node can be applied to the output of TreeEnsemble.
+    To encode class labels, use a LabelEncoder operator.
+    Tree Ensemble classifier. Returns the top class for each of N inputs.<br>
+    The attributes named 'nodes_X' form a sequence of tuples, associated by
+    index into the sequences, which must all be of equal length. These tuples
+    define the nodes.<br>
+    Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves.
+    A leaf may have multiple votes, where each vote is weighted by
+    the associated class_weights index.<br>
+    One and only one of classlabels_strings or classlabels_int64s
+    will be defined. The class_ids are indices into this list.
+    All fields ending with <i>_as_tensor</i> can be used instead of the
+    same parameter without the suffix if the element type is double and not float.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    TreeEnsembleClassifier,
+    5,
+    OpSchema()
+        .Deprecate()
+        .SetDoc(TreeEnsembleClassifier_ver5_doc)
+        .Input(0, "X", "Input of shape [N,F]", "T1")
+        .Output(0, "Y", "N, Top class for each point", "T2")
+        .Output(1, "Z", "The class score for each class, for each point, a tensor of shape [N,E].", "tensor(float)")
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input type must be a tensor of a numeric type.")
+        .TypeConstraint(
+            "T2",
+            {types::String, types::Int64},
+            "The output type will be a tensor of strings or integers, depending on which of the classlabels_* "
+            "attributes is used.")
+        .Attr("nodes_treeids", "Tree id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_nodeids",
+            "Node id for each node. Ids may restart at zero for each tree, but it not required to.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_featureids", "Feature id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values_as_tensor",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates_as_tensor",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_modes",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_truenodeids", "Child node if expression is true.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("nodes_falsenodeids", "Child node if expression is false.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_missing_value_tracks_true",
+            "For each node, define what to do in the presence of a missing value: if a value is missing (NaN), use the "
+            "'true' or 'false' branch based on the value in this array.<br>This attribute may be left undefined, and "
+            "the default value is false (0) for all nodes.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("class_treeids", "The id of the tree that this node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_nodeids", "node id that this weight is for.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_ids", "The index of the class list that each weight is for.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_weights", "The weight for the class in class_id.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "class_weights_as_tensor",
+            "The weight for the class in class_id.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_strings",
+            "Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_int64s",
+            "Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br> One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT.'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            "base_values",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "base_values_as_tensor",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE));
+
+static constexpr const char* TreeEnsembleRegressor_ver5_doc = R"DOC(
+    This operator is DEPRECATED. Please use TreeEnsemble instead which provides the same
+    functionality.<br>
+    Tree Ensemble regressor.  Returns the regressed values for each input in N.<br>
+    All args with nodes_ are fields of a tuple of tree nodes, and
+    it is assumed they are the same length, and an index i will decode the
+    tuple across these inputs.  Each node id can appear only once
+    for each tree id.<br>
+    All fields prefixed with target_ are tuples of votes at the leaves.<br>
+    A leaf may have multiple votes, where each vote is weighted by
+    the associated target_weights index.<br>
+    All fields ending with <i>_as_tensor</i> can be used instead of the
+    same parameter without the suffix if the element type is double and not float.
+    All trees must have their node ids start at 0 and increment by 1.<br>
+    Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    TreeEnsembleRegressor,
+    5,
+    OpSchema()
+        .Deprecate()
+        .SetDoc(TreeEnsembleRegressor_ver5_doc)
+        .Input(0, "X", "Input of shape [N,F]", "T")
+        .Output(0, "Y", "N classes", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input type must be a tensor of a numeric type.")
+        .Attr("nodes_treeids", "Tree id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_nodeids",
+            "Node id for each node. Node ids must restart at zero for each tree and increase sequentially.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_featureids", "Feature id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values_as_tensor",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates_as_tensor",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_modes",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_truenodeids", "Child node if expression is true", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("nodes_falsenodeids", "Child node if expression is false", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_missing_value_tracks_true",
+            "For each node, define what to do in the presence of a NaN: use the 'true' (if the attribute value is 1) "
+            "or 'false' (if the attribute value is 0) branch based on the value in this array.<br>This attribute may "
+            "be left undefined and the default value is false (0) for all nodes.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("target_treeids", "The id of the tree that each node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_nodeids", "The node id of each weight", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_ids", "The index of the target that each weight is for", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_weights", "The weight for each target", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("target_weights_as_tensor", "The weight for each target", AttributeProto::TENSOR, OPTIONAL_VALUE)
+        .Attr("n_targets", "The total number of targets.", AttributeProto::INT, OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            "aggregate_function",
+            "Defines how to aggregate leaf values within a target. <br>One of 'AVERAGE,' 'SUM,' 'MIN,' 'MAX.'",
+            AttributeProto::STRING,
+            std::string("SUM"))
+        .Attr(
+            "base_values",
+            "Base values for regression, added to final prediction after applying aggregate_function; the size must be "
+            "the same as the classes or can be left unassigned (assumed 0)",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "base_values_as_tensor",
+            "Base values for regression, added to final prediction after applying aggregate_function; the size must be "
+            "the same as the classes or can be left unassigned (assumed 0)",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE));
+
+static constexpr const char* TreeEnsemble_ver5_doc = R"DOC(
+    Tree Ensemble operator.  Returns the regressed values for each input in a batch.
+    Inputs have dimensions `[N, F]` where `N` is the input batch size and `F` is the number of input features.
+    Outputs have dimensions `[N, num_targets]` where `N` is the batch size and `num_targets` is the number of targets, which is a configurable attribute.
+
+    The encoding of this attribute is split along interior nodes and the leaves of the trees. Notably, attributes with the prefix `nodes_*` are associated with interior nodes, and attributes with the prefix `leaf_*` are associated with leaves.
+    The attributes `nodes_*` must all have the same length and encode a sequence of tuples, as defined by taking all the `nodes_*` fields at a given position.
+
+    All fields prefixed with `leaf_*` represent tree leaves, and similarly define tuples of leaves and must have identical length.
+
+    This operator can be used to implement both the previous `TreeEnsembleRegressor` and `TreeEnsembleClassifier` nodes.
+    The `TreeEnsembleRegressor` node maps directly to this node and requires changing how the nodes are represented.
+    The `TreeEnsembleClassifier` node can be implemented by adding a `ArgMax` node after this node to determine the top class.
+    To encode class labels, a `LabelEncoder` or `GatherND` operator may be used.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    TreeEnsemble,
+    5,
+    OpSchema()
+        .SetDoc(TreeEnsemble_ver5_doc)
+        .Input(0, "X", "Input of shape [Batch Size, Number of Features]", "T")
+        .Output(0, "Y", "Output of shape [Batch Size, Number of targets]", "T")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Float16},
+            "The input type must be a tensor of a numeric type.")
+        .Attr("nodes_featureids", "Feature id for each node.", AttributeProto::INTS, true)
+        .Attr(
+            "nodes_splits",
+            "Thresholds to do the splitting on for each node with mode that is not 'BRANCH_MEMBER'.",
+            AttributeProto::TENSOR,
+            true)
+        .Attr(
+            "nodes_hitrates",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_modes",
+            "The comparison operation performed by the node. This is encoded as an enumeration of 0 ('BRANCH_LEQ'), 1 "
+            "('BRANCH_LT'), 2 ('BRANCH_GTE'), 3 ('BRANCH_GT'), 4 ('BRANCH_EQ'), 5 ('BRANCH_NEQ'), and 6 "
+            "('BRANCH_MEMBER'). Note this is a tensor of type uint8.",
+            AttributeProto::TENSOR,
+            true)
+        .Attr(
+            "nodes_truenodeids",
+            "If `nodes_trueleafs` is false at an entry, this represents the position of the true branch node. This "
+            "position can be used to index into a `nodes_*` entry. If `nodes_trueleafs` is false, it is an index into "
+            "the leaf_* attributes.",
+            AttributeProto::INTS,
+            true)
+        .Attr(
+            "nodes_falsenodeids",
+            "If `nodes_falseleafs` is false at an entry, this represents the position of the false branch node. This "
+            "position can be used to index into a `nodes_*` entry. If `nodes_falseleafs` is false, it is an index into "
+            "the leaf_* attributes.",
+            AttributeProto::INTS,
+            true)
+        .Attr(
+            "nodes_trueleafs",
+            "1 if true branch is leaf for each node and 0 an interior node. To represent a tree that is a leaf (only "
+            "has one node), one can do so by having a single `nodes_*` entry with true and false branches referencing "
+            "the same `leaf_*` entry",
+            AttributeProto::INTS,
+            true)
+        .Attr(
+            "nodes_falseleafs",
+            "1 if false branch is leaf for each node and 0 if an interior node. To represent a tree that is a leaf "
+            "(only has one node), one can do so by having a single `nodes_*` entry with true and false branches "
+            "referencing the same `leaf_*` entry",
+            AttributeProto::INTS,
+            true)
+        .Attr(
+            "nodes_missing_value_tracks_true",
+            "For each node, define whether to follow the true branch (if attribute value is 1) or false branch (if "
+            "attribute value is 0) in the presence of a NaN input feature. This attribute may be left undefined and "
+            "the default value is false (0) for all nodes.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "tree_roots",
+            "Index into `nodes_*` for the root of each tree. The tree structure is derived from the branching of each "
+            "node.",
+            AttributeProto::INTS,
+            true)
+        .Attr(
+            "membership_values",
+            "Members to test membership of for each set membership node. List all of the members to test again in the "
+            "order that the 'BRANCH_MEMBER' mode appears in `node_modes`, delimited by `NaN`s. Will have the same "
+            "number "
+            "of sets of values as nodes with mode 'BRANCH_MEMBER'. This may be omitted if the node doesn't contain any "
+            "'BRANCH_MEMBER' nodes.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "leaf_targetids",
+            "The index of the target that this leaf contributes to (this must be in range `[0, n_targets)`).",
+            AttributeProto::INTS,
+            true)
+        .Attr("leaf_weights", "The weight for each leaf.", AttributeProto::TENSOR, true)
+        .Attr("n_targets", "The total number of targets.", AttributeProto::INT, OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br>One of 'NONE' (0), 'SOFTMAX' (1), 'LOGISTIC' (2), "
+            "'SOFTMAX_ZERO' (3) or 'PROBIT' (4), defaults to 'NONE' (0)",
+            AttributeProto::INT,
+            static_cast<int64_t>(0))
+        .Attr(
+            "aggregate_function",
+            "Defines how to aggregate leaf values within a target. <br>One of 'AVERAGE' (0) 'SUM' (1) 'MIN' (2) 'MAX "
+            "(3) defaults to 'SUM' (1)",
+            AttributeProto::INT,
+            static_cast<int64_t>(1))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          checkInputRank(ctx, 0, 2);
+          auto nodes_splits = ctx.getAttribute("nodes_splits");
+          if (nullptr == nodes_splits) {
+            fail_shape_inference("Attribute 'nodes_splits' is required.");
+          }
+          if (nodes_splits->t().dims_size() != 1) {
+            fail_shape_inference("Attribute 'nodes_splits' must be 1D.");
+          }
+          auto input_type = ctx.getInputType(0)->tensor_type().elem_type();
+          // Check that input type is same as split type
+          if (input_type != nodes_splits->t().data_type()) {
+            fail_shape_inference(
+                "Attribute 'nodes_splits' must have same type as input. Input type is ",
+                input_type,
+                " and attribute type is ",
+                nodes_splits->t().data_type());
+          }
+
+          // Expected nodes_* length
+          auto expected_length = nodes_splits->t().dims(0);
+          // Validate all nodes_* attributes that are set have the same length and are 1D.
+          AssertAttributeProtoTypeAndLength(
+              ctx.getAttribute("nodes_featureids"), expected_length, TensorProto_DataType_INT64, true);
+          AssertAttributeProtoTypeAndLength(
+              ctx.getAttribute("nodes_hitrates"), expected_length, TensorProto_DataType_FLOAT, false);
+          AssertAttributeProtoTypeAndLength(
+              ctx.getAttribute("nodes_modes"), expected_length, TensorProto_DataType_UINT8, true);
+          AssertAttributeProtoTypeAndLength(
+              ctx.getAttribute("nodes_truenodeids"), expected_length, TensorProto_DataType_INT64, true);
+          AssertAttributeProtoTypeAndLength(
+              ctx.getAttribute("nodes_falsenodeids"), expected_length, TensorProto_DataType_INT64, true);
+          AssertAttributeProtoTypeAndLength(
+              ctx.getAttribute("nodes_trueleafs"), expected_length, TensorProto_DataType_INT64, true);
+          AssertAttributeProtoTypeAndLength(
+              ctx.getAttribute("nodes_falseleafs"), expected_length, TensorProto_DataType_INT64, true);
+          AssertAttributeProtoTypeAndLength(
+              ctx.getAttribute("nodes_missing_value_tracks_true"), expected_length, TensorProto_DataType_INT64, false);
+
+          // The set membership values and the splits must have the same type as the input.
+          auto membership_values = ctx.getAttribute("membership_values");
+          if (nullptr != membership_values && membership_values->t().data_type() != input_type) {
+            fail_shape_inference(
+                "Attribute 'membership_values' must have same type as input. Input type is ",
+                input_type,
+                " and attribute type is ",
+                membership_values->t().data_type());
+          }
+          AssertAttributeProtoTypeAndLength(
+              ctx.getAttribute("nodes_splits"), expected_length, static_cast<TensorProto_DataType>(input_type), true);
+
+          // Validate all leaf_* attributes that are set have the same length and are 1D.
+          auto leaf_targetids = ctx.getAttribute("leaf_targetids");
+          auto leaf_weights = ctx.getAttribute("leaf_weights");
+          if (nullptr != leaf_targetids && nullptr != leaf_weights) {
+            if (leaf_targetids->ints_size() != leaf_weights->t().dims(0)) {
+              fail_shape_inference(
+                  "Attribute 'leaf_targetids' must have same length as attribute 'leaf_weights'. 'leaf_targetids' "
+                  "length is ",
+                  leaf_targetids->ints_size(),
+                  " and 'leaf_weights' length is ",
+                  leaf_weights->t().dims(0));
+            }
+          } else {
+            fail_shape_inference("Attributes 'leaf_targetids' and 'leaf_weights' must both be set.");
+          }
+
+          // Validate weights have same type as input.
+          if (leaf_weights->t().data_type() != input_type) {
+            fail_shape_inference(
+                "Attribute 'leaf_weights' must have same type as input. Input type is ",
+                input_type,
+                " and attribute type is ",
+                leaf_weights->t().data_type());
+          }
+
+          checkInputRank(ctx, 0, 2);
+
+          Dim N, E;
+          unifyInputDim(ctx, 0, 0, N);
+          if (nullptr != ctx.getAttribute("n_targets")) {
+            unifyDim(E, ctx.getAttribute("n_targets")->i());
+          }
+          updateOutputElemType(ctx, 0, input_type);
+          updateOutputShape(ctx, 0, {N, E});
+        }));
+
+static constexpr const char* ZipMap_ver1_doc = R"DOC(
+    Creates a map from the input and the attributes.<br>
+    The values are provided by the input tensor, while the keys are specified by the attributes.
+    Must provide keys in either classlabels_strings or classlabels_int64s (but not both).<br>
+    The columns of the tensor correspond one-by-one to the keys specified by the attributes. There must be as many columns as keys.<br>
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    ZipMap,
+    1,
+    OpSchema()
+        .SetDoc(ZipMap_ver1_doc)
+        .Input(0, "X", "The input values", "tensor(float)")
+        .Output(0, "Z", "The output map", "T")
+        .TypeConstraint(
+            "T",
+            {types::Sequence(types::Map<TensorProto::STRING>("float")),
+             types::Sequence(types::Map<TensorProto::INT64>("float"))},
+            "The output will be a sequence of string or integer maps to float.")
+        .Attr(
+            "classlabels_strings",
+            "The keys when using string keys.<br>One and only one of the 'classlabels_*' attributes must be defined.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_int64s",
+            "The keys when using int keys.<br>One and only one of the 'classlabels_*' attributes must be defined.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          std::vector<std::string> classlabels_strings;
+          bool result = getRepeatedAttribute(ctx, "classlabels_strings", classlabels_strings);
+          auto output_map_type = ctx.getOutputType(0)->mutable_sequence_type()->mutable_elem_type()->mutable_map_type();
+          auto output_value_tensor_type = output_map_type->mutable_value_type()->mutable_tensor_type();
+          output_value_tensor_type->set_elem_type(TensorProto::FLOAT);
+          output_value_tensor_type->mutable_shape(); // Initialize to scalar
+          if (hasInputShape(ctx, 0) && getInputShape(ctx, 0).dim_size() != 1 && getInputShape(ctx, 0).dim_size() != 2) {
+            fail_shape_inference("ZipMap input shape should be 1D or 2D.")
+          }
+          if (result && !classlabels_strings.empty()) {
+            output_map_type->set_key_type(TensorProto::STRING);
+          }
+          std::vector<int64_t> classlabels_int64s;
+          result = getRepeatedAttribute(ctx, "classlabels_int64s", classlabels_int64s);
+          if (result && !classlabels_int64s.empty()) {
+            output_map_type->set_key_type(TensorProto::INT64);
+          }
+        }));
+
+} // namespace ONNX_NAMESPACE
+#endif
diff --git a/onnx/defs/traditionalml/old.cc b/onnx/defs/traditionalml/old.cc
new file mode 100644
index 0000000..32d399d
--- /dev/null
+++ b/onnx/defs/traditionalml/old.cc
@@ -0,0 +1,658 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+#include <vector>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+#ifdef ONNX_ML
+namespace ONNX_NAMESPACE {
+static constexpr const char* LabelEncoder_ver1_doc = R"DOC(
+    Converts strings to integers and vice versa.<br>
+    If the string default value is set, it will convert integers to strings.
+    If the int default value is set, it will convert strings to integers.<br>
+    Each operator converts either integers to strings or strings to integers, depending
+    on which default value attribute is provided. Only one default value attribute
+    should be defined.<br>
+    When converting from integers to strings, the string is fetched from the
+    'classes_strings' list, by simple indexing.<br>
+    When converting from strings to integers, the string is looked up in the list
+    and the index at which it is found is used as the converted value.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    LabelEncoder,
+    1,
+    OpSchema()
+        .SetDoc(LabelEncoder_ver1_doc)
+        .Input(0, "X", "Input data.", "T1")
+        .Output(0, "Y", "Output data. If strings are input, the output values are integers, and vice versa.", "T2")
+        .TypeConstraint(
+            "T1",
+            {types::String, types::Int64},
+            "The input type must be a tensor of integers or strings, of any shape.")
+        .TypeConstraint(
+            "T2",
+            {types::String, types::Int64},
+            "The output type will be a tensor of strings or integers, and will have the same shape as the input.")
+        .Attr("classes_strings", "A list of labels.", AttributeProto::STRINGS, OPTIONAL_VALUE)
+        .Attr(
+            "default_int64",
+            "An integer to use when an input string value is not found in the map.<br>One and only one of the "
+            "'default_*' attributes must be defined.",
+            AttributeProto::INT,
+            static_cast<int64_t>(-1))
+        .Attr(
+            "default_string",
+            "A string to use when an input integer value is not found in the map.<br>One and only one of the "
+            "'default_*' attributes must be defined.",
+            AttributeProto::STRING,
+            std::string("_Unused"))
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto input_elem_type = ctx.getInputType(0)->tensor_type().elem_type();
+          auto output_elem_type = ctx.getOutputType(0)->mutable_tensor_type();
+          if (TensorProto::STRING == input_elem_type) {
+            output_elem_type->set_elem_type(TensorProto::INT64);
+          } else if (TensorProto::INT64 == input_elem_type) {
+            output_elem_type->set_elem_type(TensorProto::STRING);
+          }
+        }));
+
+static constexpr const char* TreeEnsembleClassifier_ver1_doc = R"DOC(
+    Tree Ensemble classifier.  Returns the top class for each of N inputs.<br>
+    The attributes named 'nodes_X' form a sequence of tuples, associated by
+    index into the sequences, which must all be of equal length. These tuples
+    define the nodes.<br>
+    Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves.
+    A leaf may have multiple votes, where each vote is weighted by
+    the associated class_weights index.<br>
+    One and only one of classlabels_strings or classlabels_int64s
+    will be defined. The class_ids are indices into this list.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    TreeEnsembleClassifier,
+    1,
+    OpSchema()
+        .SetDoc(TreeEnsembleClassifier_ver1_doc)
+        .Input(0, "X", "Input of shape [N,F]", "T1")
+        .Output(0, "Y", "N, Top class for each point", "T2")
+        .Output(1, "Z", "The class score for each class, for each point, a tensor of shape [N,E].", "tensor(float)")
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input type must be a tensor of a numeric type.")
+        .TypeConstraint(
+            "T2",
+            {types::String, types::Int64},
+            "The output type will be a tensor of strings or integers, depending on which of the classlabels_* "
+            "attributes is used.")
+        .Attr("nodes_treeids", "Tree id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_nodeids",
+            "Node id for each node. Ids may restart at zero for each tree, but it not required to.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_featureids", "Feature id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_modes",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_truenodeids", "Child node if expression is true.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("nodes_falsenodeids", "Child node if expression is false.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_missing_value_tracks_true",
+            "For each node, define what to do in the presence of a missing value: if a value is missing (NaN), use the "
+            "'true' or 'false' branch based on the value in this array.<br>This attribute may be left undefined, and "
+            "the default value is false (0) for all nodes.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("class_treeids", "The id of the tree that this node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_nodeids", "node id that this weight is for.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_ids", "The index of the class list that each weight is for.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_weights", "The weight for the class in class_id.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_strings",
+            "Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_int64s",
+            "Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br> One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT.'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            "base_values",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          std::vector<std::string> label_strs;
+          auto result = getRepeatedAttribute(ctx, "classlabels_strings", label_strs);
+          bool using_strings = (result && !label_strs.empty());
+          auto output_elem_type = ctx.getOutputType(0)->mutable_tensor_type();
+          if (using_strings) {
+            output_elem_type->set_elem_type(TensorProto::STRING);
+          } else {
+            output_elem_type->set_elem_type(TensorProto::INT64);
+          }
+        }));
+
+static constexpr const char* TreeEnsembleClassifier_ver3_doc = R"DOC(
+    Tree Ensemble classifier. Returns the top class for each of N inputs.<br>
+    The attributes named 'nodes_X' form a sequence of tuples, associated by
+    index into the sequences, which must all be of equal length. These tuples
+    define the nodes.<br>
+    Similarly, all fields prefixed with 'class_' are tuples of votes at the leaves.
+    A leaf may have multiple votes, where each vote is weighted by
+    the associated class_weights index.<br>
+    One and only one of classlabels_strings or classlabels_int64s
+    will be defined. The class_ids are indices into this list.
+    All fields ending with <i>_as_tensor</i> can be used instead of the
+    same parameter without the suffix if the element type is double and not float.
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    TreeEnsembleClassifier,
+    3,
+    OpSchema()
+        .SetDoc(TreeEnsembleClassifier_ver3_doc)
+        .Input(0, "X", "Input of shape [N,F]", "T1")
+        .Output(0, "Y", "N, Top class for each point", "T2")
+        .Output(1, "Z", "The class score for each class, for each point, a tensor of shape [N,E].", "tensor(float)")
+        .TypeConstraint(
+            "T1",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input type must be a tensor of a numeric type.")
+        .TypeConstraint(
+            "T2",
+            {types::String, types::Int64},
+            "The output type will be a tensor of strings or integers, depending on which of the classlabels_* "
+            "attributes is used.")
+        .Attr("nodes_treeids", "Tree id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_nodeids",
+            "Node id for each node. Ids may restart at zero for each tree, but it not required to.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_featureids", "Feature id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values_as_tensor",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates_as_tensor",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_modes",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_truenodeids", "Child node if expression is true.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("nodes_falsenodeids", "Child node if expression is false.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_missing_value_tracks_true",
+            "For each node, define what to do in the presence of a missing value: if a value is missing (NaN), use the "
+            "'true' or 'false' branch based on the value in this array.<br>This attribute may be left undefined, and "
+            "the default value is false (0) for all nodes.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("class_treeids", "The id of the tree that this node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_nodeids", "node id that this weight is for.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_ids", "The index of the class list that each weight is for.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("class_weights", "The weight for the class in class_id.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "class_weights_as_tensor",
+            "The weight for the class in class_id.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_strings",
+            "Class labels if using string labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "classlabels_int64s",
+            "Class labels if using integer labels.<br>One and only one of the 'classlabels_*' attributes must be "
+            "defined.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br> One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT.'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            "base_values",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "base_values_as_tensor",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto nodes_values = ctx.getAttribute("nodes_values");
+          auto nodes_values_as_tensor = ctx.getAttribute("nodes_values_as_tensor");
+          auto nodes_hitrates = ctx.getAttribute("nodes_hitrates");
+          auto nodes_hitrates_as_tensor = ctx.getAttribute("nodes_hitrates_as_tensor");
+          auto class_weights = ctx.getAttribute("class_weights");
+          auto class_weights_as_tensor = ctx.getAttribute("class_weights_as_tensor");
+          auto base_values = ctx.getAttribute("base_values");
+          auto base_values_as_tensor = ctx.getAttribute("base_values_as_tensor");
+
+          if (nullptr != nodes_values && nullptr != nodes_values_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'nodes_values', 'nodes_values_as_tensor' should be specified.");
+          }
+          if (nullptr != nodes_hitrates && nullptr != nodes_hitrates_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'nodes_hitrates', 'nodes_hitrates_as_tensor' should be specified.");
+          }
+          if (nullptr != class_weights && nullptr != class_weights_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'class_weights', 'class_weights_as_tensor' should be specified.");
+          }
+          if (nullptr != base_values && nullptr != base_values_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'base_values', 'base_values_as_tensor' should be specified.");
+          }
+
+          std::vector<std::string> classlabels_strings;
+          auto result = getRepeatedAttribute(ctx, "classlabels_strings", classlabels_strings);
+          bool using_strings = (result && !classlabels_strings.empty());
+          if (using_strings) {
+            updateOutputElemType(ctx, 0, TensorProto::STRING);
+          } else {
+            updateOutputElemType(ctx, 0, TensorProto::INT64);
+          }
+          updateOutputElemType(ctx, 1, TensorProto::FLOAT);
+
+          checkInputRank(ctx, 0, 2);
+          Dim N, E;
+          unifyInputDim(ctx, 0, 0, N);
+
+          if (using_strings) {
+            unifyDim(E, classlabels_strings.size());
+          } else {
+            std::vector<int64_t> classlabels_int64s;
+            result = getRepeatedAttribute(ctx, "classlabels_int64s", classlabels_int64s);
+            if (!result || classlabels_int64s.empty()) {
+              fail_shape_inference("Non of classlabels_int64s or classlabels_strings is set.");
+            }
+            unifyDim(E, classlabels_int64s.size());
+          }
+          updateOutputShape(ctx, 0, {N});
+          updateOutputShape(ctx, 1, {N, E});
+        }));
+
+static constexpr const char* TreeEnsembleRegressor_ver1_doc = R"DOC(
+    Tree Ensemble regressor.  Returns the regressed values for each input in N.<br>
+    All args with nodes_ are fields of a tuple of tree nodes, and
+    it is assumed they are the same length, and an index i will decode the
+    tuple across these inputs.  Each node id can appear only once
+    for each tree id.<br>
+    All fields prefixed with target_ are tuples of votes at the leaves.<br>
+    A leaf may have multiple votes, where each vote is weighted by
+    the associated target_weights index.<br>
+    All trees must have their node ids start at 0 and increment by 1.<br>
+    Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    TreeEnsembleRegressor,
+    1,
+    OpSchema()
+        .SetDoc(TreeEnsembleRegressor_ver1_doc)
+        .Input(0, "X", "Input of shape [N,F]", "T")
+        .Output(0, "Y", "N classes", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input type must be a tensor of a numeric type.")
+        .Attr("nodes_treeids", "Tree id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_nodeids",
+            "Node id for each node. Node ids must restart at zero for each tree and increase sequentially.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_featureids", "Feature id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_modes",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_truenodeids", "Child node if expression is true", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("nodes_falsenodeids", "Child node if expression is false", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_missing_value_tracks_true",
+            "For each node, define what to do in the presence of a NaN: use the 'true' (if the attribute value is 1) "
+            "or 'false' (if the attribute value is 0) branch based on the value in this array.<br>This attribute may "
+            "be left undefined and the default value is false (0) for all nodes.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("target_treeids", "The id of the tree that each node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_nodeids", "The node id of each weight", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_ids", "The index of the target that each weight is for", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_weights", "The weight for each target", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("n_targets", "The total number of targets.", AttributeProto::INT, OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            "aggregate_function",
+            "Defines how to aggregate leaf values within a target. <br>One of 'AVERAGE,' 'SUM,' 'MIN,' 'MAX.'",
+            AttributeProto::STRING,
+            std::string("SUM"))
+        .Attr(
+            "base_values",
+            "Base values for classification, added to final class score; the size must be the same as the classes or "
+            "can be left unassigned (assumed 0)",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE));
+
+static constexpr const char* TreeEnsembleRegressor_ver3_doc = R"DOC(
+    Tree Ensemble regressor.  Returns the regressed values for each input in N.<br>
+    All args with nodes_ are fields of a tuple of tree nodes, and
+    it is assumed they are the same length, and an index i will decode the
+    tuple across these inputs.  Each node id can appear only once
+    for each tree id.<br>
+    All fields prefixed with target_ are tuples of votes at the leaves.<br>
+    A leaf may have multiple votes, where each vote is weighted by
+    the associated target_weights index.<br>
+    All fields ending with <i>_as_tensor</i> can be used instead of the
+    same parameter without the suffix if the element type is double and not float.
+    All trees must have their node ids start at 0 and increment by 1.<br>
+    Mode enum is BRANCH_LEQ, BRANCH_LT, BRANCH_GTE, BRANCH_GT, BRANCH_EQ, BRANCH_NEQ, LEAF
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    TreeEnsembleRegressor,
+    3,
+    OpSchema()
+        .SetDoc(TreeEnsembleRegressor_ver3_doc)
+        .Input(0, "X", "Input of shape [N,F]", "T")
+        .Output(0, "Y", "N classes", "tensor(float)")
+        .TypeConstraint(
+            "T",
+            {types::Float, types::Double, types::Int64, types::Int32},
+            "The input type must be a tensor of a numeric type.")
+        .Attr("nodes_treeids", "Tree id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_nodeids",
+            "Node id for each node. Node ids must restart at zero for each tree and increase sequentially.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_featureids", "Feature id for each node.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_values_as_tensor",
+            "Thresholds to do the splitting on for each node.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_hitrates_as_tensor",
+            "Popularity of each node, used for performance and may be omitted.",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .Attr(
+            "nodes_modes",
+            "The node kind, that is, the comparison to make at the node. There is no comparison to make at a leaf "
+            "node.<br>One of 'BRANCH_LEQ', 'BRANCH_LT', 'BRANCH_GTE', 'BRANCH_GT', 'BRANCH_EQ', 'BRANCH_NEQ', 'LEAF'",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("nodes_truenodeids", "Child node if expression is true", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("nodes_falsenodeids", "Child node if expression is false", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr(
+            "nodes_missing_value_tracks_true",
+            "For each node, define what to do in the presence of a NaN: use the 'true' (if the attribute value is 1) "
+            "or 'false' (if the attribute value is 0) branch based on the value in this array.<br>This attribute may "
+            "be left undefined and the default value is false (0) for all nodes.",
+            AttributeProto::INTS,
+            OPTIONAL_VALUE)
+        .Attr("target_treeids", "The id of the tree that each node is in.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_nodeids", "The node id of each weight", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_ids", "The index of the target that each weight is for", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("target_weights", "The weight for each target", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("target_weights_as_tensor", "The weight for each target", AttributeProto::TENSOR, OPTIONAL_VALUE)
+        .Attr("n_targets", "The total number of targets.", AttributeProto::INT, OPTIONAL_VALUE)
+        .Attr(
+            "post_transform",
+            "Indicates the transform to apply to the score. <br>One of 'NONE,' 'SOFTMAX,' 'LOGISTIC,' 'SOFTMAX_ZERO,' "
+            "or 'PROBIT'",
+            AttributeProto::STRING,
+            std::string("NONE"))
+        .Attr(
+            "aggregate_function",
+            "Defines how to aggregate leaf values within a target. <br>One of 'AVERAGE,' 'SUM,' 'MIN,' 'MAX.'",
+            AttributeProto::STRING,
+            std::string("SUM"))
+        .Attr(
+            "base_values",
+            "Base values for regression, added to final prediction after applying aggregate_function; the size must be "
+            "the same as the classes or can be left unassigned (assumed 0)",
+            AttributeProto::FLOATS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "base_values_as_tensor",
+            "Base values for regression, added to final prediction after applying aggregate_function; the size must be "
+            "the same as the classes or can be left unassigned (assumed 0)",
+            AttributeProto::TENSOR,
+            OPTIONAL_VALUE)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          auto nodes_values = ctx.getAttribute("nodes_values");
+          auto nodes_values_as_tensor = ctx.getAttribute("nodes_values_as_tensor");
+          auto nodes_hitrates = ctx.getAttribute("nodes_hitrates");
+          auto nodes_hitrates_as_tensor = ctx.getAttribute("nodes_hitrates_as_tensor");
+          auto target_weights = ctx.getAttribute("target_weights");
+          auto target_weights_as_tensor = ctx.getAttribute("target_weights_as_tensor");
+          auto base_values = ctx.getAttribute("base_values");
+          auto base_values_as_tensor = ctx.getAttribute("base_values_as_tensor");
+
+          if (nullptr != nodes_values && nullptr != nodes_values_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'nodes_values', 'nodes_values_as_tensor' should be specified.");
+          }
+          if (nullptr != nodes_hitrates && nullptr != nodes_hitrates_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'nodes_hitrates', 'nodes_hitrates_as_tensor' should be specified.");
+          }
+          if (nullptr != target_weights && nullptr != target_weights_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'target_weights', 'target_weights_as_tensor' should be specified.");
+          }
+          if (nullptr != base_values && nullptr != base_values_as_tensor) {
+            fail_shape_inference(
+                "Only one of the attributes 'base_values', 'base_values_as_tensor' should be specified.");
+          }
+
+          checkInputRank(ctx, 0, 2);
+          Dim N, E;
+          unifyInputDim(ctx, 0, 0, N);
+          if (nullptr != ctx.getAttribute("n_targets")) {
+            unifyDim(E, ctx.getAttribute("n_targets")->i());
+          }
+          updateOutputElemType(ctx, 0, TensorProto::FLOAT);
+          updateOutputShape(ctx, 0, {N, E});
+        }));
+
+static constexpr const char* LabelEncoder_ver2_doc = R"DOC(
+    Maps each element in the input tensor to another value.<br>
+    The mapping is determined by the two parallel attributes, 'keys_*' and
+    'values_*' attribute. The i-th value in the specified 'keys_*' attribute
+    would be mapped to the i-th value in the specified 'values_*' attribute. It
+    implies that input's element type and the element type of the specified
+    'keys_*' should be identical while the output type is identical to the
+    specified 'values_*' attribute. If an input element can not be found in the
+    specified 'keys_*' attribute, the 'default_*' that matches the specified
+    'values_*' attribute may be used as its output value.<br>
+    Let's consider an example which maps a string tensor to an integer tensor.
+    Assume and 'keys_strings' is ["Amy", "Sally"], 'values_int64s' is [5, 6],
+    and 'default_int64' is '-1'.  The input ["Dori", "Amy", "Amy", "Sally",
+    "Sally"] would be mapped to [-1, 5, 5, 6, 6].<br>
+    Since this operator is an one-to-one mapping, its input and output shapes
+    are the same. Notice that only one of 'keys_*'/'values_*' can be set.<br>
+    For key look-up, bit-wise comparison is used so even a float NaN can be
+    mapped to a value in 'values_*' attribute.<br>
+)DOC";
+
+ONNX_ML_OPERATOR_SET_SCHEMA(
+    LabelEncoder,
+    2,
+    OpSchema()
+        .SetDoc(LabelEncoder_ver2_doc)
+        .Input(0, "X", "Input data. It can be either tensor or scalar.", "T1")
+        .Output(0, "Y", "Output data.", "T2")
+        .TypeConstraint("T1", {types::String, types::Int64, types::Float}, "The input type is a tensor of any shape.")
+        .TypeConstraint(
+            "T2",
+            {types::String, types::Int64, types::Float},
+            "Output type is determined by the specified 'values_*' attribute.")
+        .Attr(
+            "keys_strings",
+            "A list of strings. One and only one of 'keys_*'s should be set.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("keys_int64s", "A list of ints.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("keys_floats", "A list of floats.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr(
+            "values_strings",
+            "A list of strings. One and only one of 'value_*'s should be set.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr("values_int64s", "A list of ints.", AttributeProto::INTS, OPTIONAL_VALUE)
+        .Attr("values_floats", "A list of floats.", AttributeProto::FLOATS, OPTIONAL_VALUE)
+        .Attr("default_string", "A string.", AttributeProto::STRING, std::string("_Unused"))
+        .Attr("default_int64", "An integer.", AttributeProto::INT, static_cast<int64_t>(-1))
+        .Attr("default_float", "A float.", AttributeProto::FLOAT, -0.f)
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Label encoder is one-to-one mapping.
+          if (ctx.getNumInputs() != 1) {
+            fail_shape_inference("Label encoder has only one input.");
+          }
+          if (ctx.getNumOutputs() != 1) {
+            fail_shape_inference("Label encoder has only one output.");
+          }
+
+          // Load all key_* attributes.
+          std::vector<std::string> keys_strings;
+          bool keys_strings_result = getRepeatedAttribute(ctx, "keys_strings", keys_strings);
+          std::vector<int64_t> keys_int64s;
+          bool keys_int64s_result = getRepeatedAttribute(ctx, "keys_int64s", keys_int64s);
+          std::vector<float> keys_floats;
+          bool keys_floats_result = getRepeatedAttribute(ctx, "keys_floats", keys_floats);
+
+          // Check if only one keys_* attribute is set.
+          if (static_cast<int>(keys_strings_result) + static_cast<int>(keys_int64s_result) +
+                  static_cast<int>(keys_floats_result) !=
+              1) {
+            fail_shape_inference("Only one of keys_*'s can be set in label encoder.");
+          }
+
+          // Check if the specified keys_* matches input type.
+          auto input_elem_type = ctx.getInputType(0)->tensor_type().elem_type();
+          if (keys_strings_result && input_elem_type != TensorProto::STRING) {
+            fail_shape_inference("Input type is not string tensor but key_strings is set");
+          }
+          if (keys_int64s_result && input_elem_type != TensorProto::INT64) {
+            fail_shape_inference("Input type is not int64 tensor but keys_int64s is set");
+          }
+          if (keys_floats_result && input_elem_type != TensorProto::FLOAT) {
+            fail_shape_inference("Input type is not float tensor but keys_floats is set");
+          }
+
+          // Load all values_* attributes.
+          std::vector<std::string> values_strings;
+          bool values_strings_result = getRepeatedAttribute(ctx, "values_strings", values_strings);
+          std::vector<int64_t> values_int64s;
+          bool values_int64s_result = getRepeatedAttribute(ctx, "values_int64s", values_int64s);
+          std::vector<float> values_floats;
+          bool values_floats_result = getRepeatedAttribute(ctx, "values_floats", values_floats);
+
+          // Check if only one values_* attribute is set.
+          if (static_cast<int>(values_strings_result) + static_cast<int>(values_int64s_result) +
+                  static_cast<int>(values_floats_result) !=
+              1) {
+            fail_shape_inference("Only one of values_*'s can be set in label encoder.");
+          }
+
+          // Assign output type based on the specified values_*.
+          auto output_elem_type = ctx.getOutputType(0)->mutable_tensor_type();
+          if (values_strings_result)
+            output_elem_type->set_elem_type(TensorProto::STRING);
+          if (values_int64s_result)
+            output_elem_type->set_elem_type(TensorProto::INT64);
+          if (values_floats_result)
+            output_elem_type->set_elem_type(TensorProto::FLOAT);
+
+          // Input and output shapes are the same.
+          propagateShapeFromInputToOutput(ctx, 0, 0);
+        }));
+} // namespace ONNX_NAMESPACE
+#endif
diff --git a/onnx/defs/traditionalml/utils.h b/onnx/defs/traditionalml/utils.h
new file mode 100644
index 0000000..d0d0946
--- /dev/null
+++ b/onnx/defs/traditionalml/utils.h
@@ -0,0 +1,35 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ONNX_DEFS_TRADITIONALML_UTILS_H_
+#define ONNX_DEFS_TRADITIONALML_UTILS_H_
+
+#include "onnx/defs/shape_inference.h"
+
+namespace ONNX_NAMESPACE {
+
+inline void AssertAttributeProtoTypeAndLength(
+    const AttributeProto* attr_proto,
+    int expected_length,
+    TensorProto_DataType expected_type,
+    bool required) {
+  if (nullptr == attr_proto) {
+    if (required) {
+      fail_shape_inference("Unspecified required attribute.");
+    }
+    return;
+  }
+  const auto& [type, length] = getAttributeProtoElemTypeAndLength(attr_proto);
+  if (type != expected_type) {
+    fail_shape_inference(
+        "Attribute '", attr_proto->name(), "' must have type ", TensorProto_DataType_Name(expected_type), ".");
+  }
+  if (length != expected_length) {
+    fail_shape_inference("Attribute '", attr_proto->name(), "' must have ", expected_length, " elements.");
+  }
+}
+
+} // namespace ONNX_NAMESPACE
+
+#endif // ONNX_DEFS_TRADITIONALML_UTILS_H_
diff --git a/onnx/defs/training/CMakeLists.txt b/onnx/defs/training/CMakeLists.txt
new file mode 100644
index 0000000..ebc1561
--- /dev/null
+++ b/onnx/defs/training/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    defs.cc
+)
diff --git a/onnx/defs/training/defs.cc b/onnx/defs/training/defs.cc
new file mode 100644
index 0000000..6fcfbe5
--- /dev/null
+++ b/onnx/defs/training/defs.cc
@@ -0,0 +1,621 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE {
+
+static constexpr const char* Gradient_ver1_doc = R"DOC(
+Gradient operator computes the partial derivatives of a specific tensor w.r.t.
+some other tensors. This operator is widely used in gradient-based training
+algorithms. To illustrate its use, let's consider a computation graph,
+
+```
+X -----.
+       |
+       v
+W --> Conv --> H --> Gemm --> Y
+                      ^
+                      |
+                      Z
+```
+
+, where W and Z are trainable tensors. Note that operators' attributes are
+omitted for the sake of simplicity. Let dY/dW (dY/dZ) be the gradient of
+Y with respect to W (Z). The user can compute gradient by inserting Gradient
+operator to form another graph shown below.
+
+```
+W --> Conv --> H --> Gemm --> Y
+|      ^              ^
+|      |              |
+|      X              Z
+|      |              |
+|      |   .----------'
+|      |   |  (W/Z/X is the 1st/2nd/3rd input of Gradient as shown in
+|      |   |   "xs" followed by "zs")
+|      v   v
+'---> Gradient(xs=["W", "Z"], zs=["X"], y="Y")
+       |   |
+       |   '-----------------------------------> dY/dW (1st output of Gradient)
+       |
+       '---------------------------------------> dY/dZ (2nd output of Gradient)
+```
+
+By definition, the tensor "y" is a function of independent variables in "xs"
+and "zs". Since we only compute the gradient of "y" w.r.t. the differentiable
+variables in "xs", this Gradient only outputs dY/dW and dY/dZ. Note that "H"
+cannot appear in "xs" and "zs". The reason is that "H" can be determined by
+tensors "W" and "X" and therefore "H" is not an independent variable.
+
+All outputs are optional. If needed, for example, user can assign an empty
+string to the 1st output name of that Gradient to skip the generation of dY/dW.
+Note that the concept of optional outputs can also be found in ONNX's RNN, GRU,
+and LSTM.
+
+Gradient operator can compute derivative against intermediate tensors. For
+example, the gradient of Y with respect to H can be done via
+
+```
+W --> Conv --> H --> Gemm --> Y
+       ^       |      ^
+       |       |      |
+       X       |      Z
+       .-------'      |
+       |   .----------'
+       |   | (H/Z is the 1st/2nd input of Gradient as shown in "xs")
+       v   v
+      Gradient(xs=["H", "Z"], y="Y")
+       |   |
+       |   '-----------------------------------> dY/dH (1st output of Gradient)
+       |
+       '---------------------------------------> dY/dZ (2nd output of Gradient)
+```
+
+It is possible to represent high-order differentiation using Gradient operators.
+For example, given the following linear model:
+
+```
+W --> Gemm --> Y --> Loss --> O
+       ^              ^
+       |              |
+       X              L
+```
+
+To compute the 2nd order derivative of O with respect to W (denoted by
+d^2O/dW^2), one can do
+
+```
+W --> Gemm --> Y --> Loss --> O
+|      ^              ^
+|      |              |
+|      X .------------L
+|      | |            |
+|      | |            v
++------+-+> Gradient(xs=["X", "W"], zs=["L"], y="O") ---> dO/dX (1st output of Gradient)
+|      | |    |
+|      | |    '---> dO/dW (2nd output of Gradient)
+|      v v
+'---> Gradient(xs=["X", "W"], zs=["L"], y="dO/dW") ---> d(dO/dW)dX (1st output of
+       |                                                  Gradient)
+       |
+       |
+       '---> d^2O/dW^2 (2nd output of Gradient)
+```
+
+The tensors named in attributes "xs", "zs", and "y" define the differentiated
+computation graph, and the inputs to Gradient node define the values at
+which the gradient is computed. We can feed different tensors to the identified
+graph. For example, one can compute the gradient of Y with respect to H at
+a specific value of H, H_1, by providing that value as an input to the Gradient
+node.
+
+```
+W --> Conv --> H --> Gemm --> Y
+       ^              ^
+       |              |
+       X              Z
+
+          Z_1 (2nd input of Gradient)
+           |
+           v
+H_1 --> Gradient(xs=["H", "Z"], y="Y") ---> dY/dH when H = H_1 and Y = Y_1.
+           |
+           '------------------------------> dY/dZ (2nd output of Gradient)
+```
+
+When the inputs of Gradient are the tensors named in "xs" and "zs", the
+computation can be optimized. More specifically, intermediate variables in
+forward pass can be reused if the gradient is computed via reverse-mode
+auto-differentiation.
+
+)DOC";
+
+ONNX_PREVIEW_TRAINING_OPERATOR_SET_SCHEMA(
+    Gradient,
+    1,
+    OpSchema()
+        .SetDoc(Gradient_ver1_doc)
+        .Input(
+            0,
+            "Inputs",
+            "The values fed into graph identified by the attributes. "
+            "The i-th input is the value of the i-th tensor specified in the "
+            "concatenated list of the attribute \"xs\" and the attribute "
+            " \"zs\". For example, if xs=[\"A\", \"B\"] and zs=[\"C\"], the "
+            "first input is used as the value of symbol \"A\" and the 3rd "
+            "input is substituted for all the occurrences of \"C\".",
+            "T1",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "Outputs",
+            "The gradient of the tensor specified by the attribute \"y\" "
+            "with respect to each of tensors specified in the "
+            "attribute \"xs\". The i-th output is the gradient of \"y\" with "
+            "respect to the i-th tensor specified in the attribute \"xs\".",
+            "T2",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "xs",
+            "Input tensor names of the differentiated sub-graph. It "
+            "contains only the necessary differentiated "
+            "inputs of a (sub-)graph. Variables (usually called "
+            "intermediate variables) that can be generated from inputs "
+            "cannot be included in this attribute.",
+            AttributeProto::STRINGS)
+        .Attr(
+            "zs",
+            "Input tensor names of the differentiated sub-graph. It "
+            "contains only the necessary non-differentiated "
+            "inputs of a (sub-)graph. Variables (usually called "
+            "intermediate variables) that can be generated from inputs "
+            "cannot be included in this attribute.",
+            AttributeProto::STRINGS,
+            OPTIONAL_VALUE)
+        .Attr(
+            "y",
+            "The targeted tensor. It can be viewed as the output of the "
+            "differentiated function. The attribute \"xs\" and attribute "
+            "\"zs\" are the minimal independent variable set that determines "
+            "the value of \"y\".",
+            AttributeProto::STRING)
+        .TypeConstraint("T1", OpSchema::all_tensor_types(), "Allow outputs to be any kind of tensor.")
+        .TypeConstraint(
+            "T2",
+            {types::Float16, types::Float, types::Double},
+            "Allow inputs to be any kind of floating-point tensor."));
+
+static constexpr const char* Adagrad_ver1_doc = R"DOC(
+    Compute one iteration of ADAGRAD, a stochastic gradient based optimization
+    algorithm. This operator can conduct the optimization of multiple tensor variables.
+
+    Let's define the behavior of this operator. As you can imagine, ADAGRAD requires
+    some parameters:
+
+     - The initial learning-rate "R".
+     - The update count "T". That is, the number of training iterations conducted.
+     - A L2-norm regularization coefficient "norm_coefficient".
+     - A learning-rate decay factor "decay_factor".
+     - A small constant "epsilon" to avoid dividing-by-zero.
+
+    At each ADAGRAD iteration, the optimized tensors are moved along a direction
+    computed based on their estimated gradient and accumulated squared gradient. Assume
+    that only a single tensor "X" is updated by this operator. We need the value of "X",
+    its gradient "G", and its accumulated squared gradient "H". Therefore, variables in
+    this operator's input list are sequentially "R", "T", "X", "G", and "H". Other
+    parameters are given as attributes because they are usually constants. Also, the
+    corresponding output tensors are the new value of "X" (called "X_new"), and then
+    the new accumulated squared gradient (called "H_new"). Those outputs are computed
+    from the given inputs following the pseudo code below.
+
+    Let "+", "-", "*", and "/" are all element-wise arithmetic operations with
+    numpy-style broadcasting support. The pseudo code to compute those outputs is:
+
+      // Compute a scalar learning-rate factor. At the first update of X, T is generally
+      // 0 (0-based update index) or 1 (1-based update index).
+      r = R / (1 + T * decay_factor);
+
+      // Add gradient of 0.5 * norm_coefficient * ||X||_2^2, where ||X||_2 is the 2-norm.
+      G_regularized = norm_coefficient * X + G;
+
+      // Compute new accumulated squared gradient.
+      H_new = H + G_regularized * G_regularized;
+
+      // Compute the adaptive part of per-coordinate learning rate. Note that Sqrt(...)
+      // computes element-wise square-root.
+      H_adaptive = Sqrt(H_new) + epsilon
+
+      // Compute the new value of "X".
+      X_new = X - r * G_regularized / H_adaptive;
+
+    If one assign this operators to optimize multiple inputs, for example, "X_1" and "X_2", the same
+    pseudo code may be extended to handle all tensors jointly. More specifically, we can view "X" as a
+    concatenation of "X_1" and "X_2" (of course, their gradient and accumulate gradient should
+    be concatenated too) and then just reuse the entire pseudo code.
+
+    Note that ADAGRAD was first proposed in http://jmlr.org/papers/volume12/duchi11a/duchi11a.pdf.
+    In that reference paper, this operator is a special case of the Figure 1's composite mirror
+    descent update.
+)DOC";
+
+ONNX_PREVIEW_TRAINING_OPERATOR_SET_SCHEMA(
+    Adagrad,
+    1,
+    OpSchema()
+        .SetDoc(Adagrad_ver1_doc)
+        .Input(0, "R", "The initial learning rate.", "T1")
+        .Input(1, "T", "The update count of \"X\". It should be a scalar.", "T2")
+        .Input(
+            2,
+            "inputs",
+            "The current values of optimized tensors, followed by their "
+            "respective gradients, followed by their respective accumulated squared gradients."
+            "For example, if two tensor \"X_1\" and \"X_2\" "
+            "are optimized, "
+            "The input list would be "
+            "[\"X_1\", \"X_2\", "
+            "gradient of \"X_1\", "
+            "gradient of \"X_2\", "
+            "accumulated squared gradient of \"X_1\", "
+            "accumulated squared gradient of \"X_2\"].",
+            "T3",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "outputs",
+            "Updated values of optimized tensors, followed by their updated "
+            "values of accumulated squared gradients. For example, "
+            "if two tensor \"X_1\" and \"X_2\" are "
+            "optimized, the output list would be [new value of \"X_1,\" new value of \"X_2\" "
+            "new accumulated squared gradient of \"X_1\", new accumulated squared gradient of \"X_2\"].",
+            "T3",
+            OpSchema::Variadic,
+            false)
+        .Attr("epsilon", "Small scalar to avoid dividing by zero.", AttributeProto::FLOAT, 1e-6f)
+        .Attr(
+            "decay_factor",
+            "The decay factor of learning rate after one update."
+            "The effective learning rate is computed by r = R / (1 + T * decay_factor). "
+            "Default to 0 so that increasing update counts doesn't reduce the learning rate.",
+            AttributeProto::FLOAT,
+            0.0f)
+        .Attr(
+            "norm_coefficient",
+            "Regularization coefficient in 0.5 * norm_coefficient * ||X||_2^2. Default to 0, "
+            "which means no regularization.",
+            AttributeProto::FLOAT,
+            0.0f)
+        .TypeConstraint("T1", {types::Float, types::Double}, "Constrain input types to float scalars.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain input types to 64-bit integer scalars.")
+        .TypeConstraint("T3", {types::Float, types::Double}, "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // In comments below, we assume that the input list is
+          // [R, T, X1, X2, G1, G2, H1, H2] and the output list is
+          // [X1_new, X2_new, H1_new, H2_new].
+
+          // Compute the number of tuples (X, G, H).
+          auto num_optimized_tensors = (ctx.getNumInputs() - 2) / 3;
+          for (size_t i = 0; i < num_optimized_tensors; ++i) {
+            // Pass X1's and X2's shapes to X1_new and X2_new, respectively.
+            size_t i_in = 2 + i;
+            size_t i_out = i;
+            propagateElemTypeFromInputToOutput(ctx, i_in, i_out);
+            propagateShapeFromInputToOutput(ctx, i_in, i_out);
+
+            // Pass H1's and H2's shapes to H1_new and H2_new, respectively.
+            i_in = 2 + 2 * num_optimized_tensors + i;
+            i_out = i + num_optimized_tensors;
+            propagateElemTypeFromInputToOutput(ctx, i_in, i_out);
+            propagateShapeFromInputToOutput(ctx, i_in, i_out);
+          }
+        }));
+
+static constexpr const char* Momentum_ver1_doc = R"DOC(
+    Compute one iteration of stochastic gradient update with momentum.
+    This operator can conduct the optimization of multiple tensor variables.
+
+    Let's define the behavior of this operator. As you can imagine, SG with momentum requires
+    several parameters:
+
+     - The learning-rate "R".
+     - The update count "T". That is, the number of conducted training iterations. It should
+       be zero in the first training iteration.
+     - A L2-norm regularization coefficient "norm_coefficient".
+     - A decay coefficient of previous accumulated gradient (i.e., momentum) "alpha".
+     - The scaling coefficient of current gradient "beta".
+     - An attribute to choose either standard momentum or Nesterov's momentum "mode" should
+       be used.
+
+    For the sake of simplicity, assume that there is only one tensor (called "X") to be optimized.
+    Other necessary inputs are "X"'s gradient (called "G") and "X"'s momentum (called "V"). This
+    Momentum operator maps all these inputs to the new value of "X" (called "X_new") and its new
+    momentum (called "V_new").
+
+    This operator supports two different momentum algorithms. Set the attribute "mode" to
+    "nesterov" if Nesterov's momentum is desired. Otherwise, set the attribute "model" to
+    "standard" to use standard momentum. Computation details are described subsequently.
+
+    Let "+", "-", "*", and "/" are all element-wise operations with numpy-style broadcasting.
+
+    Pseudo code for SG with standard momentum:
+
+      // Add gradient of 0.5 * norm_coefficient * ||X||^2, where ||X|| is the sum of squared
+      // values of all elements in X.
+      G_regularized = norm_coefficient * X + G
+
+      // In the first training iteration, beta should always be 1.
+      beta_adjusted = T > 0 ? beta : 1
+
+      // Compute the current momentum based on previous momentum and the current gradient.
+      V_new = alpha * V + beta_adjusted * G_regularized
+
+      // Update X.
+      X_new = X - R * V_new
+
+    Pseudo code for SG with Nesterov's momentum:
+
+      // Add gradient of 0.5 * norm_coefficient * ||X||^2, where ||X|| is the sum of squared
+      // values of all elements in X.
+      G_regularized = norm_coefficient * X + G;
+
+      // In the first training iteration, beta should always be 1.
+      beta_adjusted = T > 0 ? beta : 1
+
+      // Compute the current momentum based on previous momentum and the current gradient.
+      V_new = alpha * V + beta_adjusted * G_regularized;
+
+      // Compute final update direction and then update X.
+      X_new = X - R * (G_regularized + alpha * V_new)
+
+    If one assign this operators to optimize multiple inputs, for example, "X_1" and "X_2". The same
+    pseudo code would be extended to handle all tensors jointly. More specifically, we can view "X" as a
+    concatenation of "X_1" and "X_2" (of course, their gradient and accumulate gradient should
+    be concatenated too) and then our pseudo code becomes applicable.
+)DOC";
+
+ONNX_PREVIEW_TRAINING_OPERATOR_SET_SCHEMA(
+    Momentum,
+    1,
+    OpSchema()
+        .SetDoc(Momentum_ver1_doc)
+        .Input(0, "R", "The learning rate.", "T1")
+        .Input(1, "T", "Update count of \"X\". It should be a scalar.", "T2")
+        .Input(
+            2,
+            "inputs",
+            "It sequentially contains the current values of optimized tensors, then their "
+            "gradient tensors, and finally their momentum tensors. For example, if two tensors "
+            "\"X_1\" and \"X_2\" are optimized, The expected input list would be "
+            "[\"X_1\", \"X_2\", gradient of \"X_1\", gradient of \"X_2\", momentum of \"X_1\", momentum of \"X_2\"].",
+            "T3",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "outputs",
+            "It sequentially contains the new values of optimized tensors and then the new "
+            "values of their momentum tensors. For example, if two tensors \"X_1\" and \"X_2\" are "
+            "optimized, the output list would be [new value of \"X_1,\" new value of \"X_2\" "
+            "new momentum of \"X_1\", new momentum of \"X_2\"].",
+            "T3",
+            OpSchema::Variadic,
+            false)
+        .Attr("alpha", "The decay factor of momentum. It should be a scalar.", AttributeProto::FLOAT)
+        .Attr(
+            "beta",
+            "The coefficient of gradient in computing new momentum. It should be a scalar.",
+            AttributeProto::FLOAT)
+        .Attr("norm_coefficient", "Coefficient of 0.5 * norm_coefficient * ||X||^2.", AttributeProto::FLOAT)
+        .Attr(
+            "mode",
+            "Its value should be either \"nesterov\" or \"standard\". The value \"nesterov\" leads "
+            "to the use of Nesterov's momentum while \"standard\" invokes stochastic gradient method "
+            "using standard momentum",
+            AttributeProto::STRING)
+        .TypeConstraint("T1", {types::Float, types::Double}, "Constrain input types to float scalars.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain input types to 64-bit integer scalars.")
+        .TypeConstraint("T3", {types::Float, types::Double}, "Constrain input types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Assume that the input list is [R, T, X1, X2, G1, G2, V1, V2] and
+          // output list is [X1_new, X2_new, V1_new, V2_new] for explaining
+          // the code below in a simpler way.
+
+          // The count of input tensors excluding "R" and "T".
+          auto num_adjustable_tensors = ctx.getNumInputs() - 2;
+
+          // Check number of (optimized tensor, gradient, momentum) tuples.
+          if (num_adjustable_tensors % 3 != 0) {
+            fail_shape_inference(
+                "The sum of optimized tensor count and momentum tensor count ",
+                "should be a multiple of 2 in the input list of Momentum operator");
+          }
+
+          // The count of "X1" and "X2".
+          auto num_optimized_tensors = num_adjustable_tensors / 3;
+          for (size_t i = 0; i < num_optimized_tensors; ++i) {
+            // Pass X1's/X2's shapes to X1_new/X2_new.
+            size_t i_in = 2 + i;
+            size_t i_out = i;
+            propagateElemTypeFromInputToOutput(ctx, i_in, i_out);
+            propagateShapeFromInputToOutput(ctx, i_in, i_out);
+            // Pass V1's/V2's shapes to V1_new/V2_new.
+            i_in = 2 + 2 * num_optimized_tensors + i;
+            i_out = i + num_optimized_tensors;
+            propagateElemTypeFromInputToOutput(ctx, i_in, i_out);
+            propagateShapeFromInputToOutput(ctx, i_in, i_out);
+          }
+        }));
+
+static constexpr const char* Adam_ver1_doc = R"DOC(
+    Compute one iteration of Adam, a stochastic gradient based optimization
+    algorithm. This operator can conduct the optimization of multiple tensor variables.
+
+    Let's define the behavior of this operator. First of all, Adam requires
+    some parameters:
+
+     - The learning-rate "R".
+     - The update count "T". That is, the number of training iterations conducted.
+     - A L2-norm regularization coefficient "norm_coefficient".
+     - A small constant "epsilon" to avoid dividing-by-zero.
+     - Two coefficients, "alpha" and "beta".
+
+    At each Adam iteration, the optimized tensors are moved along a direction
+    computed based on their exponentially-averaged historical gradient and
+    exponentially-averaged historical squared gradient. Assume that only a tensor
+    "X" is being optimized. The rest of required information is
+
+     - the value of "X",
+     - "X"'s gradient (denoted by "G"),
+     - "X"'s exponentially-averaged historical gradient (denoted by "V"), and
+     - "X"'s exponentially-averaged historical squared gradient (denoted by "H").
+
+    Some of those parameters are passed into this operator as input tensors and others
+    are stored as this operator's attributes. Specifically, this operator's input tensor
+    list is ["R", "T", "X", "G", "V", "H"]. That is, "R" is the first input, "T" is
+    the second input, and so on. Other parameters are given as attributes because they
+    are constants. Moreover, the corresponding output tensors are
+
+     - the new value of "X" (called "X_new"),
+     - the new exponentially-averaged historical gradient (denoted by "V_new"), and
+     - the new exponentially-averaged historical squared gradient (denoted by "H_new").
+
+    Those outputs are computed following the pseudo code below.
+
+    Let "+", "-", "*", and "/" are all element-wise arithmetic operations with
+    numpy-style broadcasting support. The pseudo code to compute those outputs is:
+
+      // Add gradient of 0.5 * norm_coefficient * ||X||_2^2, where ||X||_2 is the 2-norm.
+      G_regularized = norm_coefficient * X + G
+
+      // Update exponentially-averaged historical gradient.
+      V_new = alpha * V + (1 - alpha) * G_regularized
+
+      // Update exponentially-averaged historical squared gradient.
+      H_new = beta * H + (1 - beta) * G_regularized * G_regularized
+
+      // Compute the element-wise square-root of H_new. V_new will be element-wisely
+      // divided by H_sqrt for a better update direction.
+      H_sqrt = Sqrt(H_new) + epsilon
+
+      // Compute learning-rate. Note that "alpha**T"/"beta**T" is alpha's/beta's T-th power.
+      R_adjusted = T > 0 ? R * Sqrt(1 - beta**T) / (1 - alpha**T) : R
+
+      // Compute new value of "X".
+      X_new = X - R_adjusted * V_new / H_sqrt
+
+      // Post-update regularization.
+      X_final = (1 - norm_coefficient_post) * X_new
+
+    If there are multiple inputs to be optimized, the pseudo code will be applied
+    independently to each of them.
+)DOC";
+
+ONNX_PREVIEW_TRAINING_OPERATOR_SET_SCHEMA(
+    Adam,
+    1,
+    OpSchema()
+        .SetDoc(Adam_ver1_doc)
+        .Input(0, "R", "The initial learning rate.", "T1")
+        .Input(1, "T", "The update count of \"X\". It should be a scalar.", "T2")
+        .Input(
+            2,
+            "inputs",
+            "The tensors to be optimized, followed by their respective gradients, "
+            "followed by their respective accumulated gradients (aka momentum), "
+            "followed by their respective accumulated squared gradients. For example, "
+            "to optimize tensors \"X_1\" and \"X_2,\", the input list would be "
+            "[\"X_1\", \"X_2\", "
+            "gradient of \"X_1\", gradient of \"X_2\", "
+            "accumulated gradient of \"X_1\", accumulated gradient of \"X_2\", "
+            "accumulated squared gradient of \"X_1\", accumulated squared gradient of \"X_2\"].",
+            "T3",
+            OpSchema::Variadic,
+            false)
+        .Output(
+            0,
+            "outputs",
+            "New values of optimized tensors, "
+            "followed by their respective new accumulated gradients, "
+            "followed by their respective new accumulated squared gradients. "
+            "For example, if two tensors \"X_1\" and \"X_2\" are optimized, "
+            "the outputs list would be "
+            "[new value of \"X_1\", new value of \"X_2\", "
+            "new accumulated gradient of \"X_1\", "
+            "new accumulated gradient of \"X_2\", "
+            "new accumulated squared gradient of \"X_1\", "
+            "new accumulated squared gradient of \"X_2\"].",
+            "T3",
+            OpSchema::Variadic,
+            false)
+        .Attr(
+            "alpha",
+            "Coefficient of previously accumulated gradient in running average. Default to 0.9.",
+            AttributeProto::FLOAT,
+            0.9f)
+        .Attr(
+            "beta",
+            "Coefficient of previously accumulated squared-gradient in running average. Default to 0.999.",
+            AttributeProto::FLOAT,
+            0.999f)
+        .Attr(
+            "norm_coefficient",
+            "Regularization coefficient of 0.5 * norm_coefficient * ||X||_2^2. Default to 0, "
+            "which means no regularization.",
+            AttributeProto::FLOAT,
+            0.0f)
+        .Attr(
+            "norm_coefficient_post",
+            "Regularization coefficient of 0.5 * norm_coefficient * ||X||_2^2. Default to 0, "
+            "which means no regularization.",
+            AttributeProto::FLOAT,
+            0.0f)
+        .Attr("epsilon", "Small scalar to avoid dividing by zero.", AttributeProto::FLOAT, 1e-6f)
+        .TypeConstraint("T1", {types::Float, types::Double}, "Constrain input types to float scalars.")
+        .TypeConstraint("T2", {types::Int64}, "Constrain input types to 64-bit integer scalars.")
+        .TypeConstraint("T3", {types::Float, types::Double}, "Constrain input and output types to float tensors.")
+        .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
+          // Assume that the input list is [R, T, X1, X2, G1, G2, V1, V2, H1, H2] and
+          // output list is [X1_new, X2_new, V1_new, V2_new, H1_new, H2_new] for explaining
+          // the code below in a simpler way.
+
+          // The count of input tensors excluding "R" and "T".
+          auto num_adjustable_tensors = ctx.getNumInputs() - 2;
+
+          // Check number of (optimized tensor, gradient, momentum) tuples.
+          if (num_adjustable_tensors % 4 != 0) {
+            fail_shape_inference(
+                "The sum of optimized tensor count, gradient tensor count, momentum tensor count, ",
+                "accumulated squared-gradient tensor count should be a multiple of 4 in the ",
+                "\"inputs\" of Adam operator.");
+          }
+
+          // The count of "X1" and "X2".
+          auto num_optimized_tensors = num_adjustable_tensors / 4;
+          for (size_t i = 0; i < num_optimized_tensors; ++i) {
+            // Pass X1's/X2's shapes to X1_new/X2_new.
+            size_t i_in = 2 + i;
+            size_t i_out = i;
+            propagateElemTypeFromInputToOutput(ctx, i_in, i_out);
+            propagateShapeFromInputToOutput(ctx, i_in, i_out);
+
+            // Pass V1's/V2's shapes to V1_new/V2_new.
+            i_in = 2 + 2 * num_optimized_tensors + i;
+            i_out = num_optimized_tensors + i;
+            propagateElemTypeFromInputToOutput(ctx, i_in, i_out);
+            propagateShapeFromInputToOutput(ctx, i_in, i_out);
+
+            // Pass H1's/H2's shapes to H1_new/H2_new.
+            i_in = 2 + 3 * num_optimized_tensors + i;
+            i_out = 2 * num_optimized_tensors + i;
+            propagateElemTypeFromInputToOutput(ctx, i_in, i_out);
+            propagateShapeFromInputToOutput(ctx, i_in, i_out);
+          }
+        }));
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/defs/type_builders.h b/onnx/defs/type_builders.h
new file mode 100644
index 0000000..b848071
--- /dev/null
+++ b/onnx/defs/type_builders.h
@@ -0,0 +1,132 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <initializer_list>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/defs/data_type_utils.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE::types {
+
+// Authoring DSL for op schema type strings. Factories return canonical
+// std::string forms ("tensor(float)", "seq(...)", "map(int64, ...)") that
+// drop into the existing string-based OpSchema API. Output is byte-identical
+// to hand-written strings.
+
+namespace internal {
+// Element-type name as it appears inside tensor(...) / sparse_tensor(...) /
+// map(...). Propagates std::invalid_argument if `e` is an unknown enum.
+inline std::string ElemStr(TensorProto::DataType e) {
+  return Utils::DataTypeUtils::ToDataTypeString(static_cast<int32_t>(e));
+}
+} // namespace internal
+
+inline std::string Tensor(TensorProto::DataType e) {
+  return "tensor(" + internal::ElemStr(e) + ")";
+}
+
+inline std::string SparseTensor(TensorProto::DataType e) {
+  return "sparse_tensor(" + internal::ElemStr(e) + ")";
+}
+
+inline std::string Sequence(std::string inner) {
+  return "seq(" + std::move(inner) + ")";
+}
+
+inline std::string Optional(std::string inner) {
+  return "optional(" + std::move(inner) + ")";
+}
+
+// `Key` must be an integer type or STRING (the ONNX-supported map key types).
+// Enforced at compile time via static_assert.
+template <TensorProto::DataType Key>
+inline std::string Map(std::string value) {
+  static_assert(
+      Key == TensorProto::INT8 || Key == TensorProto::INT16 || Key == TensorProto::INT32 || Key == TensorProto::INT64 ||
+          Key == TensorProto::UINT8 || Key == TensorProto::UINT16 || Key == TensorProto::UINT32 ||
+          Key == TensorProto::UINT64 || Key == TensorProto::STRING,
+      "invalid ONNX map key type — must be an integer type or STRING");
+  // Space after the comma matches existing hand-written schema sources.
+  return "map(" + internal::ElemStr(Key) + ", " + std::move(value) + ")";
+}
+
+// Prebuilt "tensor(<elem>)" strings — one per element type.
+inline constexpr const char* Float16 = "tensor(float16)";
+inline constexpr const char* Float = "tensor(float)";
+inline constexpr const char* Double = "tensor(double)";
+inline constexpr const char* BFloat16 = "tensor(bfloat16)";
+inline constexpr const char* Int8 = "tensor(int8)";
+inline constexpr const char* Int16 = "tensor(int16)";
+inline constexpr const char* Int32 = "tensor(int32)";
+inline constexpr const char* Int64 = "tensor(int64)";
+inline constexpr const char* UInt8 = "tensor(uint8)";
+inline constexpr const char* UInt16 = "tensor(uint16)";
+inline constexpr const char* UInt32 = "tensor(uint32)";
+inline constexpr const char* UInt64 = "tensor(uint64)";
+inline constexpr const char* Bool = "tensor(bool)";
+inline constexpr const char* String = "tensor(string)";
+inline constexpr const char* Complex64 = "tensor(complex64)";
+inline constexpr const char* Complex128 = "tensor(complex128)";
+inline constexpr const char* Float8E4M3FN = "tensor(float8e4m3fn)";
+inline constexpr const char* Float8E4M3FNUZ = "tensor(float8e4m3fnuz)";
+inline constexpr const char* Float8E5M2 = "tensor(float8e5m2)";
+inline constexpr const char* Float8E5M2FNUZ = "tensor(float8e5m2fnuz)";
+inline constexpr const char* Float4E2M1 = "tensor(float4e2m1)";
+inline constexpr const char* Float8E8M0 = "tensor(float8e8m0)";
+inline constexpr const char* UInt4 = "tensor(uint4)";
+inline constexpr const char* Int4 = "tensor(int4)";
+inline constexpr const char* UInt2 = "tensor(uint2)";
+inline constexpr const char* Int2 = "tensor(int2)";
+
+// Vector helpers: build type-string lists from element types, or wrap each
+// entry of an existing list with seq(...) / optional(...).
+
+inline std::vector<std::string> Tensors(std::initializer_list<TensorProto::DataType> elems) {
+  std::vector<std::string> out;
+  out.reserve(elems.size());
+  for (auto e : elems) {
+    out.push_back(Tensor(e));
+  }
+  return out;
+}
+
+inline std::vector<std::string> SparseTensors(std::initializer_list<TensorProto::DataType> elems) {
+  std::vector<std::string> out;
+  out.reserve(elems.size());
+  for (auto e : elems) {
+    out.push_back(SparseTensor(e));
+  }
+  return out;
+}
+
+inline std::vector<std::string> Sequence(const std::vector<std::string>& inner) {
+  std::vector<std::string> out;
+  out.reserve(inner.size());
+  for (const auto& s : inner) {
+    out.push_back(Sequence(s));
+  }
+  return out;
+}
+
+inline std::vector<std::string> Optional(const std::vector<std::string>& inner) {
+  std::vector<std::string> out;
+  out.reserve(inner.size());
+  for (const auto& s : inner) {
+    out.push_back(Optional(s));
+  }
+  return out;
+}
+
+inline std::vector<std::string> Concat(std::vector<std::string> a, const std::vector<std::string>& b) {
+  a.reserve(a.size() + b.size());
+  a.insert(a.end(), b.begin(), b.end());
+  return a;
+}
+
+} // namespace ONNX_NAMESPACE::types
diff --git a/onnx/external_data_helper.py b/onnx/external_data_helper.py
new file mode 100644
index 0000000..75c9098
--- /dev/null
+++ b/onnx/external_data_helper.py
@@ -0,0 +1,414 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+import re
+import sys
+import uuid
+import warnings
+from itertools import chain
+from typing import IO, TYPE_CHECKING
+
+import onnx.checker as onnx_checker
+import onnx.onnx_cpp2py_export.checker as c_checker
+from onnx.onnx_pb import (
+    AttributeProto,
+    FunctionProto,
+    GraphProto,
+    ModelProto,
+    TensorProto,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+
+
+def _open_external_data_fd(
+    base_dir: str, location: str, tensor_name: str, read_only: bool
+) -> int:
+    """Open external data via C++ and return a CRT file descriptor."""
+    return c_checker._open_external_data(base_dir, location, tensor_name, read_only)
+
+
+# Security: 3-layer defense against malicious external_data entries (GHSA-538c-55jv-c5g9)
+#
+# Layer 1 (here) — Attribute whitelist: Only spec-defined keys are accepted.
+#   Unknown keys are warned and ignored, preventing arbitrary attribute injection (CWE-915).
+#
+# Layer 2 (ExternalDataInfo.__init__) — Bounds validation: offset and length must be
+#   non-negative integers. Catches invalid values at parse time (CWE-400).
+#
+# Layer 3 (load_external_data_for_tensor) — File-size validation: offset and length are
+#   checked against actual file size before reading. This is the critical safety net that
+#   prevents memory exhaustion regardless of how the model was constructed (CWE-400).
+#
+# 'basepath' is included because set_external_data() and model_container
+# write it to protobuf entries; it must survive save/load round-trips.
+_ALLOWED_EXTERNAL_DATA_KEYS = frozenset(
+    {"location", "offset", "length", "checksum", "basepath"}
+)
+_SORTED_ALLOWED_KEYS = sorted(_ALLOWED_EXTERNAL_DATA_KEYS)
+_MAX_UNKNOWN_KEYS_IN_WARNING = 10
+_MAX_KEY_DISPLAY_LENGTH = 100
+
+
+class ExternalDataInfo:
+    def __init__(self, tensor: TensorProto) -> None:
+        self.location = ""
+        self.offset = None
+        self.length = None
+        self.checksum = None
+        self.basepath = ""
+
+        unknown_keys: set[str] = set()
+        unknown_key_count = 0
+        for entry in tensor.external_data:
+            # Layer 1: reject unknown keys (CWE-915 defense-in-depth)
+            if entry.key in _ALLOWED_EXTERNAL_DATA_KEYS:
+                setattr(self, entry.key, entry.value)
+            else:
+                unknown_key_count += 1
+                if len(unknown_keys) < _MAX_UNKNOWN_KEYS_IN_WARNING:
+                    truncated = entry.key[:_MAX_KEY_DISPLAY_LENGTH]
+                    if len(entry.key) > _MAX_KEY_DISPLAY_LENGTH:
+                        truncated += "..."
+                    unknown_keys.add(truncated)
+
+        if unknown_keys:
+            shown = sorted(unknown_keys)
+            extra = unknown_key_count - len(shown)
+            key_list = repr(shown)
+            if extra > 0:
+                key_list += f" and {extra} more"
+            warnings.warn(
+                f"Ignoring unknown external data key(s) {key_list} "
+                f"for tensor {tensor.name!r}. "
+                f"Allowed keys: {_SORTED_ALLOWED_KEYS}",
+                stacklevel=2,
+            )
+
+        if self.offset is not None:
+            self.offset = int(self.offset)
+            if self.offset < 0:
+                raise ValueError(
+                    f"External data offset must be non-negative, got {self.offset} "
+                    f"for tensor {tensor.name!r}"
+                )
+
+        if self.length is not None:
+            self.length = int(self.length)
+            if self.length < 0:
+                raise ValueError(
+                    f"External data length must be non-negative, got {self.length} "
+                    f"for tensor {tensor.name!r}"
+                )
+
+
+def _validate_external_data_file_bounds(
+    data_file: IO[bytes],
+    info: ExternalDataInfo,
+    tensor_name: str,
+) -> bytes:
+    """Validate offset/length against actual file size and read data.
+
+    Layer 3 defense-in-depth (CWE-400): prevents memory exhaustion even if the
+    model was crafted via direct protobuf APIs that bypass Python parsing.
+
+    Returns the raw bytes read from the file.
+    """
+    file_size = os.fstat(data_file.fileno()).st_size
+
+    if info.offset is not None:
+        if info.offset > file_size:
+            raise ValueError(
+                f"External data offset ({info.offset}) exceeds file size "
+                f"({file_size}) for tensor {tensor_name!r}"
+            )
+        data_file.seek(info.offset)
+
+    if info.length is not None:
+        read_start = info.offset if info.offset is not None else 0
+        available = file_size - read_start
+        if info.length > available:
+            raise ValueError(
+                f"External data length ({info.length}) exceeds available data "
+                f"({available} bytes from offset {read_start}) "
+                f"for tensor {tensor_name!r}"
+            )
+        return data_file.read(info.length)
+    return data_file.read()
+
+
+def load_external_data_for_tensor(tensor: TensorProto, base_dir: str) -> None:
+    """Loads data from an external file for tensor.
+    Ideally TensorProto should not hold any raw data but if it does it will be ignored.
+
+    Arguments:
+        tensor: a TensorProto object.
+        base_dir: directory that contains the external data.
+    """
+    info = ExternalDataInfo(tensor)
+    fd = _open_external_data_fd(base_dir, info.location, tensor.name, True)
+    with os.fdopen(fd, "rb") as data_file:
+        tensor.raw_data = _validate_external_data_file_bounds(
+            data_file, info, tensor.name
+        )
+
+
+def load_external_data_for_model(model: ModelProto, base_dir: str) -> None:
+    """Loads external tensors into model
+
+    Arguments:
+        model: ModelProto to load external data to
+        base_dir: directory that contains external data
+    """
+    for tensor in _get_all_tensors(model):
+        if uses_external_data(tensor):
+            load_external_data_for_tensor(tensor, base_dir)
+            # After loading raw_data from external_data, change the state of tensors
+            tensor.data_location = TensorProto.DEFAULT
+            # and remove external data
+            del tensor.external_data[:]
+
+
+def set_external_data(
+    tensor: TensorProto,
+    location: str,
+    offset: int | None = None,
+    length: int | None = None,
+    checksum: str | None = None,
+    basepath: str | None = None,
+) -> None:
+    if not tensor.HasField("raw_data"):
+        raise ValueError(
+            f"Tensor {tensor.name} does not have raw_data field. Cannot set external data for this tensor."
+        )
+
+    del tensor.external_data[:]
+    tensor.data_location = TensorProto.EXTERNAL
+    for k, v in {
+        "location": location,
+        "offset": int(offset) if offset is not None else None,
+        "length": int(length) if length is not None else None,
+        "checksum": checksum,
+        "basepath": basepath,
+    }.items():
+        if v is not None:
+            entry = tensor.external_data.add()
+            entry.key = k
+            entry.value = str(v)
+
+
+def convert_model_to_external_data(
+    model: ModelProto,
+    all_tensors_to_one_file: bool = True,
+    location: str | None = None,
+    size_threshold: int = 1024,
+    convert_attribute: bool = False,
+) -> None:
+    """Call to set all tensors with raw data as external data. This call should precede 'save_model'.
+    'save_model' saves all the tensors data as external data after calling this function.
+
+    Arguments:
+        model (ModelProto): Model to be converted.
+        all_tensors_to_one_file (bool): If true, save all tensors to one external file specified by location.
+            If false, save each tensor to a file named with the tensor name.
+        location: specify the external file relative to the model that all tensors to save to.
+            Path is relative to the model path.
+            If not specified, will use the model name.
+        size_threshold: Threshold for size of data. Only when tensor's data is >= the size_threshold
+            it will be converted to external data. To convert every tensor with raw data to external data set size_threshold=0.
+        convert_attribute (bool): If true, convert all tensors to external data
+                       If false, convert only non-attribute tensors to external data
+
+    Raise:
+        ValueError: If location is not a relative path.
+        FileExistsError: If a file already exists in location.
+    """
+    tensors = _get_initializer_tensors(model)
+    if convert_attribute:
+        tensors = _get_all_tensors(model)
+
+    if all_tensors_to_one_file:
+        file_name = str(uuid.uuid1()) + ".data"
+        if location:
+            if os.path.isabs(location):
+                raise ValueError(
+                    "location must be a relative path that is relative to the model path."
+                )
+            if os.path.exists(location):
+                raise FileExistsError(f"External data file exists in {location}.")
+            file_name = location
+        for tensor in tensors:
+            if (
+                tensor.HasField("raw_data")
+                and sys.getsizeof(tensor.raw_data) >= size_threshold
+            ):
+                set_external_data(tensor, file_name)
+    else:
+        for tensor in tensors:
+            if (
+                tensor.HasField("raw_data")
+                and sys.getsizeof(tensor.raw_data) >= size_threshold
+            ):
+                tensor_location = tensor.name
+                if not _is_valid_filename(tensor_location):
+                    tensor_location = str(uuid.uuid1())
+                set_external_data(tensor, tensor_location)
+
+
+def convert_model_from_external_data(model: ModelProto) -> None:
+    """Call to set all tensors which use external data as embedded data.
+    save_model saves all the tensors data as embedded data after
+    calling this function.
+
+    Arguments:
+        model (ModelProto): Model to be converted.
+    """
+    for tensor in _get_all_tensors(model):
+        if uses_external_data(tensor):
+            if not tensor.HasField("raw_data"):
+                raise ValueError("raw_data field doesn't exist.")
+            del tensor.external_data[:]
+            tensor.data_location = TensorProto.DEFAULT
+
+
+def save_external_data(tensor: TensorProto, base_path: str) -> None:
+    """Writes tensor data to an external file according to information in the `external_data` field.
+    The function checks the external is a valid name and located in folder `base_path`.
+
+    Arguments:
+        tensor (TensorProto): Tensor object to be serialized
+        base_path: System path of a folder where tensor data is to be stored
+
+    Raises:
+        ValueError: If the external file is invalid.
+    """
+    info = ExternalDataInfo(tensor)
+
+    if not tensor.HasField("raw_data"):
+        raise onnx_checker.ValidationError("raw_data field doesn't exist.")
+
+    fd = _open_external_data_fd(base_path, info.location, tensor.name, False)
+    with os.fdopen(fd, "r+b") as data_file:
+        data_file.seek(0, 2)
+        if info.offset is not None:
+            # Pad file to required offset if needed
+            file_size = data_file.tell()
+            if info.offset > file_size:
+                data_file.write(b"\0" * (info.offset - file_size))
+
+            data_file.seek(info.offset)
+        offset = data_file.tell()
+        data_file.write(tensor.raw_data)
+        set_external_data(tensor, info.location, offset, data_file.tell() - offset)
+
+
+def _get_all_tensors(onnx_model_proto: ModelProto) -> Iterable[TensorProto]:
+    """Scan an ONNX model for all tensors and return as an iterator."""
+    return chain(
+        _get_initializer_tensors(onnx_model_proto),
+        _get_attribute_tensors(onnx_model_proto),
+    )
+
+
+def _recursive_attribute_processor(
+    attribute: AttributeProto, func: Callable[[GraphProto], Iterable[TensorProto]]
+) -> Iterable[TensorProto]:
+    """Create an iterator through processing ONNX model attributes with functor."""
+    if attribute.type == AttributeProto.GRAPH:
+        yield from func(attribute.g)
+    if attribute.type == AttributeProto.GRAPHS:
+        for graph in attribute.graphs:
+            yield from func(graph)
+
+
+def _get_initializer_tensors_from_graph(graph: GraphProto, /) -> Iterable[TensorProto]:
+    """Create an iterator of initializer tensors from ONNX model graph."""
+    yield from graph.initializer
+    for node in graph.node:
+        for attribute in node.attribute:
+            yield from _recursive_attribute_processor(
+                attribute, _get_initializer_tensors_from_graph
+            )
+
+
+def _get_initializer_tensors(onnx_model_proto: ModelProto) -> Iterable[TensorProto]:
+    """Create an iterator of initializer tensors from ONNX model."""
+    yield from _get_initializer_tensors_from_graph(onnx_model_proto.graph)
+
+
+def _get_attribute_tensors_from_graph(
+    graph_or_function: GraphProto | FunctionProto, /
+) -> Iterable[TensorProto]:
+    """Create an iterator of tensors from node attributes of an ONNX model graph/function."""
+    for node in graph_or_function.node:
+        for attribute in node.attribute:
+            if attribute.HasField("t"):
+                yield attribute.t
+            yield from attribute.tensors
+            yield from _recursive_attribute_processor(
+                attribute, _get_attribute_tensors_from_graph
+            )
+
+
+def _get_attribute_tensors(onnx_model_proto: ModelProto) -> Iterable[TensorProto]:
+    """Create an iterator of tensors from node attributes of an ONNX model."""
+    yield from _get_attribute_tensors_from_graph(onnx_model_proto.graph)
+    for function in onnx_model_proto.functions:
+        yield from _get_attribute_tensors_from_graph(function)
+
+
+def _is_valid_filename(filename: str) -> bool:
+    """Utility to check whether the provided filename is valid."""
+    exp = re.compile('^[^<>:;,?"*|/]+$')
+    match = exp.match(filename)
+    return bool(match)
+
+
+def uses_external_data(tensor: TensorProto) -> bool:
+    """Returns true if the tensor stores data in an external location."""
+    return (
+        tensor.HasField("data_location")
+        and tensor.data_location == TensorProto.EXTERNAL
+    )
+
+
+def remove_external_data_field(tensor: TensorProto, field_key: str) -> None:
+    """Removes a field from a Tensor's external_data key-value store.
+
+    Modifies tensor object in place.
+
+    Arguments:
+        tensor (TensorProto): Tensor object from which value will be removed
+        field_key (string): The key of the field to be removed
+    """
+    for i, field in enumerate(tensor.external_data):
+        if field.key == field_key:
+            del tensor.external_data[i]
+
+
+def write_external_data_tensors(model: ModelProto, filepath: str) -> ModelProto:
+    """Serializes data for all the tensors which have data location set to TensorProto.External.
+
+    Note: This function also strips basepath information from all tensors' external_data fields.
+
+    Arguments:
+        model (ModelProto): Model object which is the source of tensors to serialize.
+        filepath: System path to the directory which should be treated as base path for external data.
+
+    Returns:
+        ModelProto: The modified model object.
+    """
+    for tensor in _get_all_tensors(model):
+        # Writing to external data happens in 2 passes:
+        # 1. Tensors with raw data which pass the necessary conditions (size threshold etc) are marked for serialization
+        # 2. The raw data in these tensors is serialized to a file
+        # Thus serialize only if tensor has raw data and it was marked for serialization
+        if uses_external_data(tensor) and tensor.HasField("raw_data"):
+            save_external_data(tensor, filepath)
+            tensor.ClearField("raw_data")
+
+    return model
diff --git a/onnx/frontend/__init__.py b/onnx/frontend/__init__.py
new file mode 100644
index 0000000..c974daf
--- /dev/null
+++ b/onnx/frontend/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
diff --git a/onnx/fuzz/README.md b/onnx/fuzz/README.md
new file mode 100644
index 0000000..bbfa0af
--- /dev/null
+++ b/onnx/fuzz/README.md
@@ -0,0 +1,113 @@
+<!-- Copyright (c) ONNX Project Contributors -->
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+
+# ONNX OSS-Fuzz Harnesses
+
+This directory contains [atheris](https://github.com/google/atheris)-based Python fuzz
+targets used by [OSS-Fuzz](https://github.com/google/oss-fuzz) to continuously test ONNX
+for crashes, hangs, and sanitizer violations.
+
+## Harnesses
+
+| File | Entry point fuzzed | Input path |
+|---|---|---|
+| `fuzz_checker.py` | `checker.check_model` | Raw bytes → protobuf parser |
+| `fuzz_compose.py` | `compose.merge_models` | Raw (length-prefixed model pair) **and** structured (toggle byte) |
+| `fuzz_model_loader.py` | `load_model_from_string` + `checker.check_model` | Raw bytes → protobuf parser |
+| `fuzz_parser.py` | `parser.parse_model` | UTF-8 text (ONNX text format) |
+| `fuzz_shape_inference.py` | `shape_inference.infer_shapes` | Raw bytes **and** structured model (toggle byte) |
+| `fuzz_version_converter.py` | `version_converter.convert_version` | Raw bytes → protobuf parser |
+| `make_seed_corpus.py` | *(seed generator, not a fuzzer)* | Produces seed zips for OSS-Fuzz |
+
+## CI regression check
+
+[`.github/workflows/fuzz.yml`](../../.github/workflows/fuzz.yml) runs each harness in this
+repo's own CI (a short smoke run on PRs/pushes that touch `onnx/`, a longer nightly run) as
+a regression check — e.g. to catch a harness failing to import or a documented harness file
+going missing. This is separate from, and much shallower than, OSS-Fuzz's own continuous
+fuzzing campaigns; OSS-Fuzz findings are not surfaced in this repo's CI.
+
+## How OSS-Fuzz uses these files
+
+The companion OSS-Fuzz project ([google/oss-fuzz#15382](https://github.com/google/oss-fuzz/pull/15382))
+clones this repository and runs each `fuzz_*.py` file via `compile_python_fuzzer`.
+The `build.sh` in that repo references these files from `$SRC/onnx/fuzz/` so that the
+harnesses are version-controlled here alongside the code they test.
+
+## Running a harness locally
+
+Atheris requires a libFuzzer-instrumented Python build; the easiest way is via the
+OSS-Fuzz Docker image. For quick local smoke-tests you can run without fuzzing by
+passing `-runs=0` (just loads the harness):
+
+```bash
+pip install atheris
+python onnx/fuzz/fuzz_checker.py -runs=1000
+python onnx/fuzz/fuzz_compose.py -runs=1000
+python onnx/fuzz/fuzz_parser.py -runs=1000
+python onnx/fuzz/fuzz_shape_inference.py -runs=1000
+python onnx/fuzz/fuzz_version_converter.py -runs=1000
+```
+
+To generate the seed corpora that OSS-Fuzz uses as starting inputs. The 5th
+argument (`compose_seeds.zip`) is optional, so existing 4-zip invocations keep
+working unchanged:
+
+```bash
+python onnx/fuzz/make_seed_corpus.py \
+    /tmp/vc_seeds.zip /tmp/parser_seeds.zip /tmp/checker_seeds.zip \
+    /tmp/shape_inference_seeds.zip [/tmp/compose_seeds.zip]  # 5th arg optional
+```
+
+## Design notes
+
+### Why `except Exception: return`?
+
+Fuzz targets must never crash on expected errors — only on *unexpected* ones
+(memory corruption, hangs, sanitizer reports). All protobuf parse failures,
+`ValidationError`, `InferenceError`, `DecodeError`, etc. are expected when the
+fuzzer feeds random bytes. Swallowing them lets libFuzzer keep searching for
+inputs that cause real bugs.
+
+### Why `TestOneInput`?
+
+`TestOneInput` is the [required entry-point name](https://github.com/google/atheris#usage)
+for atheris harnesses. Ruff's `N802` (lowercase function names) is suppressed for
+`onnx/fuzz/**` in `pyproject.toml` for this reason.
+
+### `fuzz_shape_inference.py` toggle byte
+
+The shape inference harness exercises two code paths per iteration, selected by
+the last byte of the input:
+
+| Bit | Meaning |
+|---|---|
+| `0x01` | `strict_mode=True` |
+| `0x02` | `check_type=True` |
+| `0x04` | Use structured model builder (If/Loop/Scan subgraphs) instead of raw bytes |
+
+This lets a single harness cover both the protobuf-parser path and the recursive
+subgraph visitor without needing separate fuzzers.
+
+### `fuzz_compose.py` toggle byte
+
+The compose harness drives two ModelProtos plus an io_map into
+`compose.merge_models`. The last byte selects the input strategy:
+
+| Bit | Meaning |
+|---|---|
+| `0x01` | pass `prefix1`/`prefix2` (collision-resolution path) |
+| `0x04` | structured: build both models from `FuzzedDataProvider` (else raw: a 4-byte length prefix splits the remaining bytes into m1 \| m2) |
+| `0x08` | random io_map (else derive it from m1's output names and m2's input names) |
+
+`merge_models` transitively exercises `merge_graphs`, `check_overlapping_names`,
+the recursive `connect_io` subgraph rewrite, `add_prefix`, and a final
+`checker.check_model` on the merged result.
+
+## Adding a new harness
+
+1. Create `onnx/fuzz/fuzz_<name>.py` following the pattern of an existing harness.
+2. If the fuzzer benefits from seed inputs, add them to `make_seed_corpus.py` and
+   wire up the output zip in the OSS-Fuzz `build.sh`.
+3. Open a PR here; once merged, update the OSS-Fuzz `build.sh` if a new seed zip
+   was added.
diff --git a/onnx/fuzz/fuzz_checker.py b/onnx/fuzz/fuzz_checker.py
new file mode 100644
index 0000000..0af74f2
--- /dev/null
+++ b/onnx/fuzz/fuzz_checker.py
@@ -0,0 +1,27 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import sys
+
+import atheris
+
+with atheris.instrument_imports():
+    from onnx import checker
+
+
+def TestOneInput(data):
+    try:
+        checker.check_model(data, full_check=True)
+    except Exception:
+        return
+
+
+def main():
+    atheris.instrument_all()
+    atheris.Setup(sys.argv, TestOneInput, enable_python_coverage=True)
+    atheris.Fuzz()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/fuzz/fuzz_compose.py b/onnx/fuzz/fuzz_compose.py
new file mode 100644
index 0000000..f0ccfa7
--- /dev/null
+++ b/onnx/fuzz/fuzz_compose.py
@@ -0,0 +1,147 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Atheris fuzz harness for onnx.compose.
+
+Two input paths are exercised per iteration, selected by a fuzzer-controlled
+toggle byte read from the *tail* of the input:
+
+* Raw    -> a 4-byte big-endian length prefix splits the remaining bytes
+  into m1 | m2, each parsed via onnx.load_model_from_string. Catches
+  protobuf parser bugs and bugs reachable only through crafted serialized
+  models the structured builder will not produce.
+
+* Structured -> helper.make_model from FuzzedDataProvider builds two small
+  linear graphs with predictable input/output names, so merge_models
+  reaches its connect_io/add_prefix logic on most iterations rather than
+  only when the parser happens to accept a random byte string.
+
+Further bits of the toggle byte select prefix1/prefix2 (add_prefix
+collision-resolution path) and a randomized (vs. derived) io_map, so a
+single harness covers merge_models, merge_graphs, check_overlapping_names,
+the recursive connect_io subgraph rewrite, and add_prefix.
+"""
+
+from __future__ import annotations
+
+import random
+import struct
+import sys
+
+import atheris
+
+with atheris.instrument_imports():
+    from onnx import (
+        TensorProto,
+        checker,
+        compose,
+        defs,
+        helper,
+        load_model_from_string,
+    )
+
+_UNARY = ("Relu", "Sigmoid", "Tanh", "Abs", "Neg", "Identity")
+
+
+def _value_info(name):
+    return helper.make_tensor_value_info(name, TensorProto.FLOAT, ["N"])
+
+
+def _build_model(fdp, tag, opset):
+    """Build a small linear graph with predictable input/output names.
+
+    Naming the sole input/output `In<tag>`/`Out<tag>` lets the derived
+    io_map (m1's outputs -> m2's inputs) connect on most iterations, so
+    merge_models' rewrite logic is reached without relying on the raw
+    protobuf parser to produce compatible names. `opset` is shared between
+    both models: merge_models rejects mismatched opset_import up front, so
+    picking it independently per model would make the structured path
+    rarely reach the merge/connect logic it exists to exercise.
+    """
+    n_ops = fdp.ConsumeIntInRange(0, 4)
+    last = f"In{tag}"
+    nodes = []
+    for i in range(n_ops):
+        op = _UNARY[fdp.ConsumeIntInRange(0, len(_UNARY) - 1)]
+        nxt = f"v{tag}_{i}"
+        nodes.append(helper.make_node(op, [last], [nxt]))
+        last = nxt
+    out_name = f"Out{tag}"
+    nodes.append(helper.make_node("Identity", [last], [out_name]))
+    graph = helper.make_graph(
+        nodes, f"g{tag}", [_value_info(f"In{tag}")], [_value_info(out_name)]
+    )
+    return helper.make_model(graph, opset_imports=[helper.make_opsetid("", opset)])
+
+
+def _derived_io_map(m1, m2):
+    outs = [o.name for o in m1.graph.output]
+    ins = [i.name for i in m2.graph.input]
+    return list(zip(outs, ins, strict=False))
+
+
+def _random_io_map(data, m1, m2):
+    outs = [o.name for o in m1.graph.output]
+    ins = [i.name for i in m2.graph.input]
+    if not outs or not ins:
+        return []
+    rng = random.Random(data)
+    rng.shuffle(outs)
+    rng.shuffle(ins)
+    n = rng.randint(0, min(len(outs), len(ins)))
+    return list(zip(outs[:n], ins[:n], strict=True))
+
+
+def TestOneInput(data):
+    # Toggles live in the trailing byte; see module docstring and
+    # onnx/fuzz/README.md's "fuzz_compose.py toggle byte" table.
+    if len(data) < 2:
+        return
+    toggles = data[-1]
+    body = data[:-1]
+    use_prefix = bool(toggles & 0x01)
+    use_structured = bool(toggles & 0x04)
+    use_random_io_map = bool(toggles & 0x08)
+    # bits 0x02, 0x10..0x80 are reserved for future toggles; mutations
+    # against them are harmless until claimed.
+
+    try:
+        if use_structured:
+            fdp = atheris.FuzzedDataProvider(body)
+            opset = fdp.ConsumeIntInRange(7, defs.onnx_opset_version())
+            m1 = _build_model(fdp, 1, opset)
+            m2 = _build_model(fdp, 2, opset)
+        else:
+            if len(body) < 4:
+                return
+            (n1,) = struct.unpack(">I", body[:4])
+            rest = body[4:]
+            if n1 > len(rest):
+                return
+            m1 = load_model_from_string(rest[:n1])
+            m2 = load_model_from_string(rest[n1:])
+
+        io_map = (
+            _random_io_map(body, m1, m2)
+            if use_random_io_map
+            else _derived_io_map(m1, m2)
+        )
+
+        prefix1 = "g1_" if use_prefix else None
+        prefix2 = "g2_" if use_prefix else None
+        merged = compose.merge_models(m1, m2, io_map, prefix1=prefix1, prefix2=prefix2)
+        checker.check_model(merged, full_check=True)
+    except Exception:
+        # Malformed fuzz inputs raise a broad set of expected exceptions
+        # (ValidationError, TypeError, ValueError, DecodeError, ...).
+        # Real bugs surface as crashes, hangs, or sanitizer reports.
+        return
+
+
+def main():
+    atheris.instrument_all()
+    atheris.Setup(sys.argv, TestOneInput, enable_python_coverage=True)
+    atheris.Fuzz()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/fuzz/fuzz_model_loader.py b/onnx/fuzz/fuzz_model_loader.py
new file mode 100644
index 0000000..f8163eb
--- /dev/null
+++ b/onnx/fuzz/fuzz_model_loader.py
@@ -0,0 +1,31 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import sys
+
+import atheris
+
+with atheris.instrument_imports():
+    import onnx
+
+
+def TestOneInput(data):
+    try:
+        model = onnx.load_model_from_string(data)
+        _ = len(model.graph.node)
+        _ = len(model.graph.input)
+        _ = len(model.graph.output)
+        onnx.checker.check_model(model)
+    except Exception:
+        return
+
+
+def main():
+    atheris.instrument_all()
+    atheris.Setup(sys.argv, TestOneInput, enable_python_coverage=True)
+    atheris.Fuzz()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/fuzz/fuzz_parser.py b/onnx/fuzz/fuzz_parser.py
new file mode 100644
index 0000000..ba3e1ad
--- /dev/null
+++ b/onnx/fuzz/fuzz_parser.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import sys
+
+import atheris
+
+with atheris.instrument_imports():
+    from onnx import parser
+
+
+def TestOneInput(data):
+    try:
+        text = data.decode("utf-8", "surrogatepass")
+        parser.parse_model(text)
+    except Exception:
+        return
+
+
+def main():
+    atheris.instrument_all()
+    atheris.Setup(sys.argv, TestOneInput, enable_python_coverage=True)
+    atheris.Fuzz()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/fuzz/fuzz_shape_inference.py b/onnx/fuzz/fuzz_shape_inference.py
new file mode 100644
index 0000000..6da23a8
--- /dev/null
+++ b/onnx/fuzz/fuzz_shape_inference.py
@@ -0,0 +1,189 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Atheris fuzz harness for onnx.shape_inference.
+
+Two input paths are exercised per iteration, selected by a fuzzer-controlled
+toggle byte read from the *tail* of the input (so the head remains a valid
+candidate for the raw-bytes path):
+
+* Raw bytes  -> onnx.load_model_from_string  -> infer_shapes
+  Catches protobuf parser bugs and bugs reachable only through crafted
+  serialized models the structured builder will not produce.
+
+* Structured -> helper.make_model from FuzzedDataProvider -> infer_shapes
+  Constructs ModelProto objects whose graphs include subgraph-bearing
+  ops (If / Loop / Scan) so the recursive visitor inside shape_inference
+  is reached on most iterations rather than only when the parser happens
+  to accept a random byte string.
+
+Both strict_mode values and both check_type values are sampled.
+"""
+
+from __future__ import annotations
+
+import sys
+
+import atheris
+
+with atheris.instrument_imports():
+    import onnx
+    from onnx import TensorProto, helper, shape_inference
+
+# Elementwise unary ops with trivial shape inference rules. Useful as
+# filler nodes so generated graphs have non-trivial bodies that exercise
+# the per-op inference dispatch table.
+_UNARY = (
+    "Relu",
+    "Sigmoid",
+    "Tanh",
+    "Abs",
+    "Neg",
+    "Exp",
+    "Log",
+    "Sqrt",
+    "Identity",
+    "Floor",
+    "Ceil",
+)
+
+# Ops that carry one or more subgraph attributes. Each forces the recursive
+# shape-inference visitor to descend, which is the path the known DoS lives
+# on. Loop/Scan exercise different subgraph-context plumbing than If.
+_SUBGRAPH_OPS = ("If", "Loop", "Scan")
+
+
+def _const_bool(name, value=True):
+    tensor = helper.make_tensor(name, TensorProto.BOOL, [], [value])
+    return helper.make_node("Constant", [], [name], value=tensor)
+
+
+def _build_branch(fdp, depth, max_depth):
+    """Build a self-contained subgraph.
+
+    Self-contained means the subgraph produces its own starting tensor via
+    a Constant node, so the branch does not depend on outer-scope captures
+    we did not declare. With probability the branch nests one of
+    If/Loop/Scan, which is what drives the recursion inside shape_inference.
+    Loop and Scan body subgraphs are deliberately not signature-conformant;
+    the recursive visitor descends before signature checks run, so the
+    recursion path is still exercised even when inference ultimately fails.
+    """
+    nodes = []
+    start = f"s_{depth}"
+    start_tensor = helper.make_tensor(start, TensorProto.FLOAT, [1], [0.0])
+    nodes.append(helper.make_node("Constant", [], [start], value=start_tensor))
+
+    if depth < max_depth and fdp.ConsumeBool():
+        sub_op = _SUBGRAPH_OPS[fdp.ConsumeIntInRange(0, len(_SUBGRAPH_OPS) - 1)]
+        out = f"sub_{depth}"
+        body = _build_branch(fdp, depth + 1, max_depth)
+        if sub_op == "If":
+            cond = f"c_{depth}"
+            nodes.append(_const_bool(cond))
+            else_body = _build_branch(fdp, depth + 1, max_depth)
+            nodes.append(
+                helper.make_node(
+                    "If",
+                    [cond],
+                    [out],
+                    then_branch=body,
+                    else_branch=else_body,
+                )
+            )
+        elif sub_op == "Loop":
+            trip = f"M_{depth}"
+            trip_t = helper.make_tensor(trip, TensorProto.INT64, [], [1])
+            nodes.append(helper.make_node("Constant", [], [trip], value=trip_t))
+            cond = f"c_{depth}"
+            nodes.append(_const_bool(cond))
+            nodes.append(
+                helper.make_node(
+                    "Loop",
+                    [trip, cond],
+                    [out],
+                    body=body,
+                )
+            )
+        else:  # Scan
+            nodes.append(
+                helper.make_node(
+                    "Scan",
+                    [start],
+                    [out],
+                    body=body,
+                    num_scan_inputs=1,
+                )
+            )
+        last = out
+    else:
+        last = start
+        n_ops = fdp.ConsumeIntInRange(0, 4)
+        for i in range(n_ops):
+            op = _UNARY[fdp.ConsumeIntInRange(0, len(_UNARY) - 1)]
+            nxt = f"v_{depth}_{i}"
+            nodes.append(helper.make_node(op, [last], [nxt]))
+            last = nxt
+
+    return helper.make_graph(
+        nodes,
+        f"branch_{depth}",
+        inputs=[],
+        outputs=[helper.make_tensor_value_info(last, TensorProto.FLOAT, None)],
+    )
+
+
+def _build_model(fdp):
+    # Top-level graph mirrors a branch but lives at depth 0 and chooses its
+    # own opset version so different shape-inference codepaths (per-opset
+    # schemas) are reached.
+    max_depth = fdp.ConsumeIntInRange(0, 80)
+    graph = _build_branch(fdp, depth=0, max_depth=max_depth)
+    opset = fdp.ConsumeIntInRange(7, 27)
+    return helper.make_model(
+        graph,
+        opset_imports=[helper.make_opsetid("", opset)],
+    )
+
+
+def TestOneInput(data):
+    # Toggles live in the trailing byte. On the structured path we slice the
+    # byte off before handing the rest to FuzzedDataProvider. On the raw path
+    # we pass the full `data` to the protobuf parser unchanged: seed models
+    # are complete serialized ModelProtos, so slicing the tail would truncate
+    # every seed. The trailing toggle byte becomes part of the raw input,
+    # which libFuzzer mutates freely anyway.
+    if len(data) < 2:
+        return
+    toggles = data[-1]
+    strict = bool(toggles & 0x01)
+    check_type = bool(toggles & 0x02)
+    use_structured = bool(toggles & 0x04)
+    # bits 0x08..0x80 are reserved for future toggles; mutations against
+    # them are harmless until claimed.
+
+    try:
+        if use_structured:
+            fdp = atheris.FuzzedDataProvider(data[:-1])
+            model = _build_model(fdp)
+        else:
+            model = onnx.load_model_from_string(data)
+        shape_inference.infer_shapes(
+            model,
+            check_type=check_type,
+            strict_mode=strict,
+        )
+    except Exception:
+        # Malformed fuzz inputs raise a broad set of expected exceptions
+        # (ValidationError, InferenceError, DecodeError, ValueError, ...).
+        # Real bugs surface as crashes, hangs, or sanitizer reports.
+        return
+
+
+def main():
+    atheris.instrument_all()
+    atheris.Setup(sys.argv, TestOneInput, enable_python_coverage=True)
+    atheris.Fuzz()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/fuzz/fuzz_version_converter.py b/onnx/fuzz/fuzz_version_converter.py
new file mode 100644
index 0000000..b99ca04
--- /dev/null
+++ b/onnx/fuzz/fuzz_version_converter.py
@@ -0,0 +1,57 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import sys
+
+import atheris
+
+with atheris.instrument_imports():
+    import onnx
+    from onnx import version_converter
+
+
+def _default_opset_version(model):
+    for opset in model.opset_import:
+        if opset.domain in ("", "ai.onnx"):
+            return opset.version
+    return None
+
+
+def _candidate_target_versions(model):
+    current = _default_opset_version(model)
+    latest = onnx.defs.onnx_opset_version()
+    if current is None:
+        return [latest]
+
+    targets = []
+    if current > 1:
+        targets.append(current - 1)
+    if current < latest:
+        targets.append(current + 1)
+    if latest not in targets and current != latest:
+        targets.append(latest)
+    return targets
+
+
+def TestOneInput(data):
+    try:
+        model = onnx.load_model_from_string(data)
+    except Exception:
+        return
+
+    for target_version in _candidate_target_versions(model):
+        try:
+            version_converter.convert_version(model, target_version)
+        except Exception:
+            continue
+
+
+def main():
+    atheris.instrument_all()
+    atheris.Setup(sys.argv, TestOneInput, enable_python_coverage=True)
+    atheris.Fuzz()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/fuzz/make_seed_corpus.py b/onnx/fuzz/make_seed_corpus.py
new file mode 100644
index 0000000..7b1679a
--- /dev/null
+++ b/onnx/fuzz/make_seed_corpus.py
@@ -0,0 +1,550 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import struct
+import sys
+import zipfile
+from typing import TYPE_CHECKING
+
+from onnx import TensorProto, helper
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+
+def _make_model(
+    op_type: str, opset_version: int, inputs: list[str], attrs=None
+) -> bytes:
+    if attrs is None:
+        attrs = {}
+
+    graph_inputs = []
+    if "X" in inputs:
+        graph_inputs.append(helper.make_tensor_value_info("X", TensorProto.FLOAT, [1]))
+    if "scales" in inputs:
+        graph_inputs.append(
+            helper.make_tensor_value_info("scales", TensorProto.FLOAT, [1])
+        )
+
+    graph_outputs = [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1])]
+    node = helper.make_node(op_type, inputs, ["Y"], **attrs)
+    graph = helper.make_graph(
+        [node], f"{op_type.lower()}-seed", graph_inputs, graph_outputs
+    )
+    model = helper.make_model(
+        graph,
+        producer_name="oss-fuzz",
+        opset_imports=[helper.make_opsetid("", opset_version)],
+    )
+    return model.SerializeToString()
+
+
+def _make_model_unchecked(
+    op_type: str,
+    opset_version: int,
+    node_inputs: list[str],
+    node_outputs: list[str],
+    graph_inputs: list[str],
+    graph_outputs: list[str],
+    attrs=None,
+) -> bytes:
+    """Serialized ModelProto with explicit, possibly inconsistent graph I/O.
+
+    The graph output need not be produced by the node, so the result can carry
+    a topological gap (an output or node input that nothing produces) to seed
+    the version converter's undefined-name handling.
+    """
+    if attrs is None:
+        attrs = {}
+
+    def vi(name: str):
+        return helper.make_tensor_value_info(name, TensorProto.FLOAT, [1])
+
+    node = helper.make_node(op_type, node_inputs, node_outputs, **attrs)
+    graph = helper.make_graph(
+        [node],
+        f"{op_type.lower()}-unchecked",
+        [vi(n) for n in graph_inputs],
+        [vi(n) for n in graph_outputs],
+    )
+    model = helper.make_model(
+        graph,
+        producer_name="oss-fuzz",
+        opset_imports=[helper.make_opsetid("", opset_version)],
+    )
+    return model.SerializeToString()
+
+
+# Text-format seeds for fuzz_parser, extracted from onnx/test/parser_test.py.
+# Each string is a valid input to onnx.parser.parse_model().
+_PARSER_SEEDS: dict[str, str] = {
+    # Minimal 3-op linear model; exercises basic node and graph parsing.
+    "basic_matmul_softmax.txt": """\
+< ir_version: 7,
+  opset_import: ["" : 10]
+>
+agraph (float[N, 128] X, float[128, 10] W, float[10] B) => (float[N] C)
+{
+   T = MatMul(X, W)
+   S = Add(T, B)
+   C = Softmax(S)
+}
+""",
+    # Multiple opset imports; exercises opset_import list parsing.
+    "multi_opset.txt": """\
+< ir_version: 7,
+  opset_import: ["" : 10, "com.microsoft" : 1]
+>
+agraph (float[N, 128] X, float[128, 10] W, float[10] B) => (float[N] C)
+{
+   T = MatMul(X, W)
+   S = Add(T, B)
+   C = Softmax(S)
+}
+""",
+    # All top-level metadata fields; exercises producer_name, doc_string, etc.
+    "model_with_metadata.txt": """\
+< ir_version: 9,
+  opset_import: ["" : 15],
+  producer_name: "oss-fuzz-seed",
+  producer_version: "1.0",
+  model_version: 1,
+  doc_string: "seed model for fuzz_parser"
+>
+agraph (float[N] x) => (float[N] y)
+{
+   y = Relu(x)
+}
+""",
+    # Model with a local function definition and attribute references;
+    # exercises the function-proto and attribute-default parsing paths.
+    "function_with_attributes.txt": """\
+< ir_version: 9,
+  opset_import: ["" : 15, "custom_domain" : 1],
+  producer_name: "oss-fuzz-seed",
+  producer_version: "1.0",
+  model_version: 1,
+  doc_string: "model with local function"
+>
+agraph (float[N] x) => (float[N] out)
+{
+   out = custom_domain.Selu<alpha=2.0, gamma=3.0>(x)
+}
+< domain: "custom_domain",
+  opset_import: ["" : 15],
+  doc_string: "custom Selu function"
+>
+Selu
+<alpha: float=1.6732631921768188, gamma: float=1.0507010221481323>
+(X) => (C)
+{
+    constant_alpha = Constant<value_float: float=@alpha>()
+    constant_gamma = Constant<value_float: float=@gamma>()
+    alpha_x = CastLike(constant_alpha, X)
+    gamma_x = CastLike(constant_gamma, X)
+    exp_x = Exp(X)
+    alpha_x_exp_x = Mul(alpha_x, exp_x)
+    alpha_x_exp_x_ = Sub(alpha_x_exp_x, alpha_x)
+    neg = Mul(gamma_x, alpha_x_exp_x_)
+    pos = Mul(gamma_x, X)
+    _zero = Constant<value_float=0.0>()
+    zero = CastLike(_zero, X)
+    less_eq = LessOrEqual(X, zero)
+    C = Where(less_eq, neg, pos)
+}
+""",
+    # Cast op with a type initializer; exercises initializer and attribute parsing.
+    "cast_with_initializer.txt": """\
+< ir_version: 10,
+  opset_import: ["" : 19]
+>
+agraph (float[N] X) => (int64[N] C)
+< int64[1] weight = {0}
+>
+{
+   C = Cast<to=7>(X)
+}
+""",
+    # Special float literal values (inf, -inf, nan); exercises the float
+    # literal parser branches that differ from ordinary decimal parsing.
+    "float_special_values.txt": """\
+< ir_version: 8,
+  opset_import: ["" : 18]
+>
+agraph (float[1] X) => (float[1] Y)
+{
+    pos_inf = Constant<value_float=inf>()
+    neg_inf = Constant<value_float=-inf>()
+    not_a_num = Constant<value_float=nan>()
+    Y = Add(X, pos_inf)
+}
+""",
+}
+
+
+# Seed models for fuzz_shape_inference. Each seed is a complete serialized
+# ModelProto with no trailing bytes: the harness's raw path passes the full
+# input to onnx.load_model_from_string, which rejects any trailing bytes, so
+# the toggle byte comes from the model bytes themselves (libFuzzer mutates
+# it freely). When the toggle's structured bit is clear, the seed loads and
+# reaches infer_shapes directly.
+
+
+def _si_linear() -> bytes:
+    """Linear chain Relu -> Sigmoid; exercises unary shape pass-through."""
+    X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 4])
+    Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 4])
+    graph = helper.make_graph(
+        [
+            helper.make_node("Relu", ["X"], ["T"]),
+            helper.make_node("Sigmoid", ["T"], ["Y"]),
+        ],
+        "linear",
+        [X],
+        [Y],
+    )
+    return helper.make_model(
+        graph, opset_imports=[helper.make_opsetid("", 15)]
+    ).SerializeToString()
+
+
+def _si_concat() -> bytes:
+    """Concat on axis 0; exercises variadic-input shape-data propagation."""
+    A = helper.make_tensor_value_info("A", TensorProto.FLOAT, [2, 4])
+    B = helper.make_tensor_value_info("B", TensorProto.FLOAT, [3, 4])
+    Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [5, 4])
+    graph = helper.make_graph(
+        [helper.make_node("Concat", ["A", "B"], ["Y"], axis=0)],
+        "concat",
+        [A, B],
+        [Y],
+    )
+    return helper.make_model(
+        graph, opset_imports=[helper.make_opsetid("", 15)]
+    ).SerializeToString()
+
+
+def _si_matmul() -> bytes:
+    """MatMul [4,8] x [8,2] -> [4,2]; exercises 2-D shape propagation."""
+    A = helper.make_tensor_value_info("A", TensorProto.FLOAT, [4, 8])
+    B = helper.make_tensor_value_info("B", TensorProto.FLOAT, [8, 2])
+    Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [4, 2])
+    graph = helper.make_graph(
+        [helper.make_node("MatMul", ["A", "B"], ["Y"])],
+        "matmul",
+        [A, B],
+        [Y],
+    )
+    return helper.make_model(
+        graph, opset_imports=[helper.make_opsetid("", 15)]
+    ).SerializeToString()
+
+
+def _si_reshape() -> bytes:
+    """Reshape driven by a Constant shape tensor; exercises shape-data propagation."""
+    X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [2, 4])
+    Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [8, 1])
+    shape_tensor = helper.make_tensor("shape", TensorProto.INT64, [2], [8, 1])
+    graph = helper.make_graph(
+        [
+            helper.make_node("Constant", [], ["shape_out"], value=shape_tensor),
+            helper.make_node("Reshape", ["X", "shape_out"], ["Y"]),
+        ],
+        "reshape",
+        [X],
+        [Y],
+    )
+    return helper.make_model(
+        graph, opset_imports=[helper.make_opsetid("", 15)]
+    ).SerializeToString()
+
+
+def _si_if() -> bytes:
+    """If op with then/else branches; exercises subgraph-recursive shape inference."""
+    cond_t = helper.make_tensor("cv", TensorProto.BOOL, [], [True])
+    cond_node = helper.make_node("Constant", [], ["cond"], value=cond_t)
+
+    def _branch(name: str, value: float):
+        t = helper.make_tensor(name, TensorProto.FLOAT, [1], [value])
+        return helper.make_graph(
+            [helper.make_node("Constant", [], [name], value=t)],
+            f"{name}_graph",
+            [],
+            [helper.make_tensor_value_info(name, TensorProto.FLOAT, [1])],
+        )
+
+    if_node = helper.make_node(
+        "If",
+        ["cond"],
+        ["result"],
+        then_branch=_branch("then_out", 1.0),
+        else_branch=_branch("else_out", 0.0),
+    )
+    graph = helper.make_graph(
+        [cond_node, if_node],
+        "if_graph",
+        [],
+        [helper.make_tensor_value_info("result", TensorProto.FLOAT, [1])],
+    )
+    return helper.make_model(
+        graph, opset_imports=[helper.make_opsetid("", 15)]
+    ).SerializeToString()
+
+
+def _si_loop() -> bytes:
+    """Loop op with scan output; exercises Loop-subgraph recursive descent."""
+    trip_t = helper.make_tensor("trip", TensorProto.INT64, [], [3])
+    trip_node = helper.make_node("Constant", [], ["trip_count"], value=trip_t)
+    cond_t = helper.make_tensor("ci", TensorProto.BOOL, [], [True])
+    cond_node = helper.make_node("Constant", [], ["cond"], value=cond_t)
+
+    body_cond_t = helper.make_tensor("bc", TensorProto.BOOL, [], [True])
+    scan_t = helper.make_tensor("sv", TensorProto.FLOAT, [1], [1.0])
+    body = helper.make_graph(
+        [
+            helper.make_node("Constant", [], ["cond_out"], value=body_cond_t),
+            helper.make_node("Constant", [], ["scan_out"], value=scan_t),
+        ],
+        "loop_body",
+        [
+            helper.make_tensor_value_info("iter_count", TensorProto.INT64, []),
+            helper.make_tensor_value_info("cond_in", TensorProto.BOOL, []),
+        ],
+        [
+            helper.make_tensor_value_info("cond_out", TensorProto.BOOL, []),
+            helper.make_tensor_value_info("scan_out", TensorProto.FLOAT, [1]),
+        ],
+    )
+    loop_node = helper.make_node(
+        "Loop", ["trip_count", "cond"], ["loop_out"], body=body
+    )
+    graph = helper.make_graph(
+        [trip_node, cond_node, loop_node],
+        "loop_graph",
+        [],
+        [helper.make_tensor_value_info("loop_out", TensorProto.FLOAT, None)],
+    )
+    return helper.make_model(
+        graph, opset_imports=[helper.make_opsetid("", 15)]
+    ).SerializeToString()
+
+
+# Seed models for fuzz_compose. Each seed is a model pair packed for the
+# harness's raw path: a 4-byte big-endian length prefix for m1's serialized
+# bytes, followed by m2's serialized bytes, then a trailing toggle byte.
+# Toggle 0x00 = raw path + derived io_map; 0x01 also sets prefix1/prefix2.
+# The harness derives the io_map from m1's output names and m2's input names,
+# so each pair reaches merge_models logic on the first iteration.
+def _compose_value_info(name: str):
+    return helper.make_tensor_value_info(name, TensorProto.FLOAT, ["N", "M"])
+
+
+def _compose_model(graph):
+    return helper.make_model(graph, opset_imports=[helper.make_opsetid("", 15)])
+
+
+def _compose_pack(m1, m2, toggle: int) -> bytes:
+    b1: bytes = m1.SerializeToString()
+    b2: bytes = m2.SerializeToString()
+    return struct.pack(">I", len(b1)) + b1 + b2 + bytes([toggle])
+
+
+def _compose_linear() -> bytes:
+    """Simplest valid merge: Relu output -> Sigmoid input (derived io_map)."""
+    m1 = _compose_model(
+        helper.make_graph(
+            [helper.make_node("Relu", ["X"], ["Y"])],
+            "m1",
+            [_compose_value_info("X")],
+            [_compose_value_info("Y")],
+        )
+    )
+    m2 = _compose_model(
+        helper.make_graph(
+            [helper.make_node("Sigmoid", ["Yin"], ["Z"])],
+            "m2",
+            [_compose_value_info("Yin")],
+            [_compose_value_info("Z")],
+        )
+    )
+    return _compose_pack(m1, m2, 0x00)
+
+
+def _compose_multi() -> bytes:
+    """Three outputs wired to three inputs; exercises variadic io_map."""
+    m1 = _compose_model(
+        helper.make_graph(
+            [
+                helper.make_node("Add", ["X", "X"], ["O0"]),
+                helper.make_node("Sub", ["X", "X"], ["O1"]),
+                helper.make_node("Mul", ["X", "X"], ["O2"]),
+            ],
+            "m1",
+            [_compose_value_info("X")],
+            [_compose_value_info(n) for n in ("O0", "O1", "O2")],
+        )
+    )
+    m2 = _compose_model(
+        helper.make_graph(
+            [
+                helper.make_node("Add", ["I0", "I1"], ["S"]),
+                helper.make_node("Mul", ["S", "I2"], ["D"]),
+            ],
+            "m2",
+            [_compose_value_info(n) for n in ("I0", "I1", "I2")],
+            [_compose_value_info("D")],
+        )
+    )
+    return _compose_pack(m1, m2, 0x00)
+
+
+def _compose_if() -> bytes:
+    """m2 contains an If whose branches reference its input; exercises the
+    recursive connect_io subgraph rewrite during merge.
+    """
+    m1 = _compose_model(
+        helper.make_graph(
+            [helper.make_node("Relu", ["X"], ["Y"])],
+            "m1",
+            [_compose_value_info("X")],
+            [_compose_value_info("Y")],
+        )
+    )
+    cond = helper.make_node(
+        "Constant",
+        [],
+        ["c"],
+        value=helper.make_tensor("cv", TensorProto.BOOL, [], [True]),
+    )
+    then_g = helper.make_graph(
+        [helper.make_node("Relu", ["Yin"], ["tr"])],
+        "then",
+        [],
+        [_compose_value_info("tr")],
+    )
+    else_g = helper.make_graph(
+        [helper.make_node("Neg", ["Yin"], ["er"])],
+        "else",
+        [],
+        [_compose_value_info("er")],
+    )
+    if_node = helper.make_node(
+        "If", ["c"], ["Z"], then_branch=then_g, else_branch=else_g
+    )
+    m2 = _compose_model(
+        helper.make_graph(
+            [cond, if_node],
+            "m2",
+            [_compose_value_info("Yin")],
+            [_compose_value_info("Z")],
+        )
+    )
+    return _compose_pack(m1, m2, 0x00)
+
+
+def _compose_prefix() -> bytes:
+    """Identical model merged with itself; all names collide, so the seed
+    sets the prefix toggle (0x01) to exercise add_prefix collision
+    resolution.
+    """
+    graph = helper.make_graph(
+        [helper.make_node("Add", ["A", "B"], ["C"])],
+        "m",
+        [_compose_value_info("A"), _compose_value_info("B")],
+        [_compose_value_info("C")],
+    )
+    m1 = _compose_model(graph)
+    m2 = _compose_model(graph)
+    return _compose_pack(m1, m2, 0x01)
+
+
+def _write_zip(path: str, entries: Mapping[str, bytes | str]) -> None:
+    with zipfile.ZipFile(path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for name, entry in entries.items():
+            zf.writestr(name, entry.encode() if isinstance(entry, str) else entry)
+
+
+_USAGE = "Usage: {prog} <version_converter_out.zip> <parser_out.zip> <checker_out.zip> <shape_inference_out.zip> [compose_out.zip]\n"
+
+
+def main() -> int:
+    if len(sys.argv) not in (5, 6):
+        sys.stderr.write(_USAGE.format(prog=sys.argv[0]))
+        return 2
+    version_converter_out = sys.argv[1]
+    parser_out = sys.argv[2]
+    checker_out = sys.argv[3]
+    shape_inference_out = sys.argv[4]
+    compose_out = sys.argv[5] if len(sys.argv) == 6 else None
+
+    version_converter_seeds = {
+        "cast_9_missing_input.onnx": _make_model(
+            "Cast", 9, [], {"to": TensorProto.FLOAT}
+        ),
+        "softmax_12_missing_input.onnx": _make_model("Softmax", 12, []),
+        "softmax_13_missing_input.onnx": _make_model("Softmax", 13, []),
+        "upsample_6_missing_input.onnx": _make_model("Upsample", 6, []),
+        "upsample_9_missing_scales.onnx": _make_model("Upsample", 9, ["X"]),
+        "upsample_9_valid.onnx": _make_model("Upsample", 9, ["X", "scales"]),
+        # Models with a topological gap (an output or node input that nothing
+        # produces) seed graphProtoToGraph's undefined-name handling directly.
+        "identity_13_output_undefined.onnx": _make_model_unchecked(
+            "Identity", 13, ["X"], ["Y"], ["X"], ["Z"]
+        ),
+        "add_13_output_partial_undefined.onnx": _make_model_unchecked(
+            "Add", 13, ["X", "X"], ["Y"], ["X"], ["Y", "Z"]
+        ),
+        "add_13_node_input_undefined.onnx": _make_model_unchecked(
+            "Add", 13, ["X", "W"], ["Y"], ["X"], ["Y"]
+        ),
+    }
+
+    # Seed models for fuzz_checker: valid serialized ModelProtos covering a
+    # range of op types and opset versions so the checker reaches real
+    # validation logic rather than dying at protobuf parse on every iteration.
+    checker_seeds = {
+        "relu_15.onnx": _make_model("Relu", 15, ["X"]),
+        "sigmoid_13.onnx": _make_model("Sigmoid", 13, ["X"]),
+        "tanh_13.onnx": _make_model("Tanh", 13, ["X"]),
+        "abs_13.onnx": _make_model("Abs", 13, ["X"]),
+        "cast_19.onnx": _make_model("Cast", 19, ["X"], {"to": TensorProto.INT64}),
+        "softmax_13.onnx": _make_model("Softmax", 13, ["X"]),
+    }
+
+    # Seed models for fuzz_shape_inference covering both the per-op dispatch
+    # table (Concat / MatMul / Reshape data propagation, unary chains) and the
+    # recursive subgraph visitor (If / Loop). Each seed is a complete
+    # serialized ModelProto with no trailing bytes, so the harness's raw path
+    # loads it directly via onnx.load_model_from_string.
+    shape_inference_seeds = {
+        "linear_relu_sigmoid.onnx": _si_linear(),
+        "concat_axis0.onnx": _si_concat(),
+        "matmul_4x8_8x2.onnx": _si_matmul(),
+        "reshape_2x4_to_8x1.onnx": _si_reshape(),
+        "if_then_else.onnx": _si_if(),
+        "loop_scan_output.onnx": _si_loop(),
+    }
+
+    _write_zip(version_converter_out, version_converter_seeds)
+    _write_zip(parser_out, _PARSER_SEEDS)
+    _write_zip(checker_out, checker_seeds)
+    _write_zip(shape_inference_out, shape_inference_seeds)
+
+    if compose_out is not None:
+        # Seed models for fuzz_compose covering: a minimal valid merge, a
+        # variadic three-pair io_map, an If subgraph (recursive connect_io
+        # rewrite), and a full name collision resolved via prefixing.
+        compose_seeds = {
+            "compose_linear.bin": _compose_linear(),
+            "compose_multi.bin": _compose_multi(),
+            "compose_if.bin": _compose_if(),
+            "compose_prefix.bin": _compose_prefix(),
+        }
+        _write_zip(compose_out, compose_seeds)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/onnx/gen_proto.py b/onnx/gen_proto.py
new file mode 100755
index 0000000..e4f1916
--- /dev/null
+++ b/onnx/gen_proto.py
@@ -0,0 +1,272 @@
+#!/usr/bin/env python
+
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import argparse
+import glob
+import os
+import re
+import subprocess
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+autogen_header = """\
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+"""
+
+LITE_OPTION = """
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
+"""
+
+DEFAULT_PACKAGE_NAME = "onnx"
+
+IF_ONNX_ML_REGEX = re.compile(r"\s*//\s*#if\s+ONNX-ML\s*$")
+ENDIF_ONNX_ML_REGEX = re.compile(r"\s*//\s*#endif\s*$")
+ELSE_ONNX_ML_REGEX = re.compile(r"\s*//\s*#else\s*$")
+
+
+def process_ifs(lines: Iterable[str], onnx_ml: bool) -> Iterable[str]:
+    in_if = 0
+    for line in lines:
+        if IF_ONNX_ML_REGEX.match(line):
+            assert in_if == 0
+            in_if = 1
+        elif ELSE_ONNX_ML_REGEX.match(line):
+            assert in_if == 1
+            in_if = 2
+        elif ENDIF_ONNX_ML_REGEX.match(line):
+            assert in_if in (1, 2)
+            in_if = 0
+        else:  # noqa: PLR5501
+            if in_if == 0:
+                yield line
+            elif in_if == 1 and onnx_ml:
+                yield line
+            elif in_if == 2 and not onnx_ml:  # noqa: PLR2004
+                yield line
+
+
+IMPORT_REGEX = re.compile(r'(\s*)import\s*"([^"]*)\.proto";\s*$')
+PACKAGE_NAME_REGEX = re.compile(r"\{PACKAGE_NAME\}")
+ML_REGEX = re.compile(r"(.*)\-ml")
+
+
+def process_package_name(lines: Iterable[str], package_name: str) -> Iterable[str]:
+    need_rename = package_name != DEFAULT_PACKAGE_NAME
+    for line in lines:
+        m = IMPORT_REGEX.match(line) if need_rename else None
+        if m:
+            include_name = m.group(2)
+            ml = ML_REGEX.match(include_name)
+            if ml:
+                include_name = f"{ml.group(1)}_{package_name}-ml"
+            else:
+                include_name = f"{include_name}_{package_name}"
+            yield m.group(1) + f'import "{include_name}.proto";'
+        else:
+            yield PACKAGE_NAME_REGEX.sub(package_name, line)
+
+
+PROTO_SYNTAX_REGEX = re.compile(r'(\s*)syntax\s*=\s*"proto2"\s*;\s*$')
+OPTIONAL_REGEX = re.compile(r"(\s*)optional\s(.*)$")
+
+
+def convert_to_proto3(lines: Iterable[str]) -> Iterable[str]:
+    for line in lines:
+        # Set the syntax specifier
+        m = PROTO_SYNTAX_REGEX.match(line)
+        if m:
+            yield m.group(1) + 'syntax = "proto3";'
+            continue
+
+        # Remove optional keywords
+        m = OPTIONAL_REGEX.match(line)
+        if m:
+            yield m.group(1) + m.group(2)
+            continue
+
+        # Rewrite import
+        m = IMPORT_REGEX.match(line)
+        if m:
+            yield m.group(1) + f'import "{m.group(2)}.proto3";'
+            continue
+
+        yield line
+
+
+def gen_proto3_code(
+    protoc_path: str, proto3_path: str, include_path: str, cpp_out: str, python_out: str
+) -> None:
+    print(f"Generate pb3 code using {protoc_path}")
+    build_args = [protoc_path, proto3_path, "-I", include_path]
+    build_args.extend(["--cpp_out", cpp_out, "--python_out", python_out])
+    subprocess.run(build_args, check=True)  # noqa: S603
+
+
+def translate(source: str, proto: int, onnx_ml: bool, package_name: str) -> str:
+    lines: Iterable[str] = source.splitlines()
+    lines = process_ifs(lines, onnx_ml=onnx_ml)
+    lines = process_package_name(lines, package_name=package_name)
+    if proto == 3:  # noqa: PLR2004
+        lines = convert_to_proto3(lines)
+    else:
+        assert proto == 2  # noqa: PLR2004
+    return os.linesep.join(lines)
+
+
+def qualify(f: str, pardir: str | None = None) -> str:
+    if pardir is None:
+        pardir = os.path.realpath(os.path.dirname(__file__))
+    return os.path.join(pardir, f)
+
+
+def convert(
+    stem: str,
+    package_name: str,
+    output: str,
+    do_onnx_ml: bool = False,
+    lite: bool = False,
+    protoc_path: str = "",
+) -> None:
+    proto_in = qualify(f"{stem}.in.proto")
+    need_rename = package_name != DEFAULT_PACKAGE_NAME
+    # Having a separate variable for import_ml ensures that the import statements for the generated
+    # proto files can be set separately from the ONNX_ML environment variable setting.
+    import_ml = do_onnx_ml
+    # We do not want to generate the onnx-data-ml.proto files for onnx-data.in.proto,
+    # as there is no change between onnx-data.proto and the ML version.
+    if "onnx-data" in proto_in:
+        do_onnx_ml = False
+    if do_onnx_ml:
+        proto_base = f"{stem}_{package_name}-ml" if need_rename else f"{stem}-ml"
+    else:
+        proto_base = f"{stem}_{package_name}" if need_rename else f"{stem}"
+    proto = qualify(f"{proto_base}.proto", pardir=output)
+    proto3 = qualify(f"{proto_base}.proto3", pardir=output)
+
+    print(f"Processing {proto_in}")
+    with open(proto_in, encoding="utf-8") as fin:
+        source = fin.read()
+        print(f"Writing {proto}")
+        with open(proto, "w", newline="", encoding="utf-8") as fout:
+            fout.write(autogen_header)
+            fout.write(
+                translate(source, proto=2, onnx_ml=import_ml, package_name=package_name)
+            )
+            if lite:
+                fout.write(LITE_OPTION)
+        print(f"Writing {proto3}")
+        with open(proto3, "w", newline="", encoding="utf-8") as fout:
+            fout.write(autogen_header)
+            fout.write(
+                translate(source, proto=3, onnx_ml=import_ml, package_name=package_name)
+            )
+            if lite:
+                fout.write(LITE_OPTION)
+        if protoc_path:
+            porto3_dir = os.path.dirname(proto3)
+            base_dir = os.path.dirname(porto3_dir)
+            gen_proto3_code(protoc_path, proto3, base_dir, base_dir, base_dir)
+            pb3_files = glob.glob(os.path.join(porto3_dir, f"{proto_base}.proto3.*"))
+            for pb3_file in pb3_files:
+                print(f"Removing {pb3_file}")
+                os.remove(pb3_file)
+
+        if need_rename:
+            if do_onnx_ml:
+                proto_header = qualify(f"{stem}-ml.pb.h", pardir=output)
+            else:
+                proto_header = qualify(f"{stem}.pb.h", pardir=output)
+            print(f"Writing {proto_header}")
+            with open(proto_header, "w", newline="", encoding="utf-8") as fout:
+                fout.write("#pragma once\n")
+                fout.write(f'#include "{proto_base}.pb.h"\n')
+
+    # Generate py mapping
+    # "-" is invalid in python module name, replaces '-' with '_'
+    pb_py = qualify(f"{stem.replace('-', '_')}_pb.py", pardir=output)
+    if need_rename:
+        pb2_py = qualify(f"{proto_base.replace('-', '_')}_pb2.py", pardir=output)
+    else:  # noqa: PLR5501
+        if do_onnx_ml:
+            pb2_py = qualify(f"{stem.replace('-', '_')}_ml_pb2.py", pardir=output)
+        else:
+            pb2_py = qualify(f"{stem.replace('-', '_')}_pb2.py", pardir=output)
+
+    print(f"generating {pb_py}")
+    with open(pb_py, "w", encoding="utf-8") as f:
+        f.write(
+            dedent(
+                f"""\
+                # This file is generated by 'gen_proto.py'. DO NOT EDIT!
+
+
+                from .{os.path.splitext(os.path.basename(pb2_py))[0]} import *  # noqa
+                """
+            )
+        )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Generates .proto file variations from .in.proto"
+    )
+    parser.add_argument(
+        "-p",
+        "--package",
+        default="onnx",
+        help="package name in the generated proto files (default: %(default)s)",
+    )
+    parser.add_argument("-m", "--ml", action="store_true", help="ML mode")
+    parser.add_argument(
+        "-l",
+        "--lite",
+        action="store_true",
+        help="generate lite proto to use with protobuf-lite",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        default=os.path.realpath(os.path.dirname(__file__)),
+        help="output directory (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--protoc_path", default="", help="path to protoc for proto3 file validation"
+    )
+    parser.add_argument(
+        "stems",
+        nargs="*",
+        default=["onnx", "onnx-operators", "onnx-data"],
+        help="list of .in.proto file stems (default: %(default)s)",
+    )
+    args = parser.parse_args()
+
+    if not os.path.exists(args.output):
+        os.makedirs(args.output)
+
+    for stem in args.stems:
+        convert(
+            stem,
+            package_name=args.package,
+            output=args.output,
+            do_onnx_ml=args.ml,
+            lite=args.lite,
+            protoc_path=args.protoc_path,
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/onnx/helper.py b/onnx/helper.py
new file mode 100644
index 0000000..69f34c6
--- /dev/null
+++ b/onnx/helper.py
@@ -0,0 +1,1381 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import collections.abc
+import functools
+import math
+import numbers
+import typing
+from typing import TYPE_CHECKING, Any, TypeVar
+
+import google.protobuf.message
+import numpy as np
+import typing_extensions
+
+import onnx
+from onnx import _mapping, defs
+from onnx.onnx_data_pb import MapProto, OptionalProto, SequenceProto
+from onnx.onnx_pb import (
+    AttributeProto,
+    FunctionProto,
+    GraphProto,
+    ModelProto,
+    NodeProto,
+    OperatorSetIdProto,
+    TensorProto,
+    TensorShapeProto,
+    TrainingInfoProto,
+    TypeProto,
+    ValueInfoProto,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, KeysView, Sequence
+
+    from google.protobuf.internal.containers import RepeatedCompositeFieldContainer
+
+VersionRowType = tuple[str, int, int, int] | tuple[str, int, int, int, int]
+VersionTableType = list[VersionRowType]
+AssignmentBindingType = list[tuple[str, str]]
+
+# This is a copy of the documented version in https://github.com/onnx/onnx/blob/main/docs/Versioning.md#released-versions
+# Both must be updated whenever a new version of ONNX is released.
+VERSION_TABLE: VersionTableType = [
+    # Release-version, IR version, ai.onnx version, ai.onnx.ml version, (optional) ai.onnx.training version
+    ("1.0", 3, 1, 1),
+    ("1.1", 3, 5, 1),
+    ("1.1.2", 3, 6, 1),
+    ("1.2", 3, 7, 1),
+    ("1.3", 3, 8, 1),
+    ("1.4.1", 4, 9, 1),
+    ("1.5.0", 5, 10, 1),
+    ("1.6.0", 6, 11, 2),
+    ("1.7.0", 7, 12, 2, 1),
+    ("1.8.0", 7, 13, 2, 1),
+    ("1.8.1", 7, 13, 2, 1),
+    ("1.9.0", 7, 14, 2, 1),
+    ("1.10.0", 8, 15, 2, 1),
+    ("1.10.1", 8, 15, 2, 1),
+    ("1.10.2", 8, 15, 2, 1),
+    ("1.11.0", 8, 16, 3, 1),
+    ("1.12.0", 8, 17, 3, 1),
+    ("1.13.0", 8, 18, 3, 1),
+    ("1.13.1", 8, 18, 3, 1),
+    ("1.14.0", 9, 19, 3, 1),
+    ("1.14.1", 9, 19, 3, 1),
+    ("1.15.0", 9, 20, 4, 1),
+    ("1.16.0", 10, 21, 5, 1),
+    ("1.16.1", 10, 21, 5, 1),
+    ("1.16.2", 10, 21, 5, 1),
+    ("1.17.0", 10, 22, 5, 1),
+    ("1.18.0", 11, 23, 5, 1),
+    ("1.19.0", 12, 24, 5, 1),
+    ("1.19.1", 12, 24, 5, 1),
+    ("1.20.0", 13, 25, 5, 1),
+    ("1.20.1", 13, 25, 5, 1),
+    ("1.21.0", 13, 26, 5, 1),
+    ("1.22.0", 13, 27, 5, 1),
+    ("1.23.0", 13, 28, 5, 1),
+]
+
+VersionMapType = dict[tuple[str, int], int]
+
+
+def _create_op_set_id_version_map(table: VersionTableType) -> VersionMapType:
+    """Create a map from (opset-domain, opset-version) to ir-version from above table."""
+    result: VersionMapType = {}
+    for row in table:
+        ir_version = row[1]
+        for pair in zip(
+            ["ai.onnx", "ai.onnx.ml", "ai.onnx.training"],
+            row[2:],
+            strict=False,
+        ):
+            if pair not in result:
+                result[pair] = ir_version
+                if pair[0] == "ai.onnx":
+                    result["ai.onnx.preview", pair[1]] = ir_version
+                if pair[0] == "ai.onnx.training":
+                    result["ai.onnx.preview.training", pair[1]] = ir_version
+    return result
+
+
+OP_SET_ID_VERSION_MAP = _create_op_set_id_version_map(VERSION_TABLE)
+
+
+def find_min_ir_version_for(
+    opsetidlist: Sequence[OperatorSetIdProto], ignore_unknown: bool = False
+) -> int:
+    """Given list of opset ids, determine minimum IR version required.
+
+    Args:
+        opsetidlist: A sequence of OperatorSetIdProto.
+        ignore_unknown: If True, ignore unknown domain and return default minimum
+            version for that domain.
+
+    Returns:
+        The minimum IR version required (integer)
+    """
+    default_min_version = 3
+
+    def find_min(domain: str | None, version: int) -> int:
+        key = (domain or "ai.onnx", version)
+        if key in OP_SET_ID_VERSION_MAP:
+            return OP_SET_ID_VERSION_MAP[key]
+        if ignore_unknown:
+            return default_min_version
+        raise ValueError("Unsupported opset-version.")
+
+    if opsetidlist:
+        return max(find_min(x.domain, x.version) for x in opsetidlist)
+    return default_min_version  # if no opsets specified
+
+
+def make_node(
+    op_type: str,
+    inputs: Sequence[str],
+    outputs: Sequence[str],
+    name: str | None = None,
+    doc_string: str | None = None,
+    domain: str | None = None,
+    overload: str | None = None,
+    **kwargs: Any,
+) -> NodeProto:
+    """Construct a NodeProto.
+
+    Args:
+        op_type (string): The name of the operator to construct
+        inputs (list of string): list of input names
+        outputs (list of string): list of output names
+        name (string, default None): optional unique identifier for NodeProto
+        doc_string (string, default None): optional documentation string for NodeProto
+        domain (string, default None): optional domain for NodeProto.
+            If it's None, we will just use default domain (which is empty)
+        overload (string, default None): optional field, used to
+            resolve calls to model-local functions
+        **kwargs (dict): the attributes of the node.  The acceptable values
+            are documented in :func:`make_attribute`.
+
+    Returns:
+        NodeProto
+    """
+    node = NodeProto()
+    node.op_type = op_type
+    node.input.extend(inputs)
+    node.output.extend(outputs)
+    if name:
+        node.name = name
+    if doc_string:
+        node.doc_string = doc_string
+    if domain is not None:
+        node.domain = domain
+    if overload is not None:
+        node.overload = overload
+    if kwargs:
+        node.attribute.extend(
+            make_attribute(key, value)
+            for key, value in sorted(kwargs.items())
+            if value is not None
+        )
+    return node
+
+
+def make_operatorsetid(
+    domain: str,
+    version: int,
+) -> OperatorSetIdProto:
+    """Construct an OperatorSetIdProto.
+
+    Args:
+        domain (string): The domain of the operator set id
+        version (integer): Version of operator set id
+    Returns:
+        OperatorSetIdProto
+    """
+    operatorsetid = OperatorSetIdProto()
+    operatorsetid.domain = domain
+    operatorsetid.version = version
+    return operatorsetid
+
+
+def make_graph(
+    nodes: Sequence[NodeProto],
+    name: str,
+    inputs: Sequence[ValueInfoProto],
+    outputs: Sequence[ValueInfoProto],
+    initializer: Sequence[TensorProto] | None = None,
+    doc_string: str | None = None,
+    value_info: Sequence[ValueInfoProto] | None = None,
+    sparse_initializer: Sequence[onnx.SparseTensorProto] | None = None,
+) -> GraphProto:
+    """Construct a GraphProto
+
+    Args:
+        nodes: list of NodeProto
+        name (string): graph name
+        inputs: list of ValueInfoProto
+        outputs: list of ValueInfoProto
+        initializer: list of TensorProto
+        doc_string (string): graph documentation
+        value_info: list of ValueInfoProto
+        sparse_initializer: list of onnx.SparseTensorProto
+    Returns:
+        GraphProto
+    """
+    if initializer is None:
+        initializer = []
+    if sparse_initializer is None:
+        sparse_initializer = []
+    if value_info is None:
+        value_info = []
+    graph = GraphProto()
+    graph.node.extend(nodes)
+    graph.name = name
+    graph.input.extend(inputs)
+    graph.output.extend(outputs)
+    graph.initializer.extend(initializer)
+    graph.sparse_initializer.extend(sparse_initializer)
+    graph.value_info.extend(value_info)
+    if doc_string:
+        graph.doc_string = doc_string
+    return graph
+
+
+def make_opsetid(domain: str, version: int) -> OperatorSetIdProto:
+    """Construct an OperatorSetIdProto.
+
+    Args:
+        domain (string): The domain of the operator set id
+        version (integer): Version of operator set id
+    Returns:
+        OperatorSetIdProto
+    """
+    opsetid = OperatorSetIdProto()
+    opsetid.domain = domain
+    opsetid.version = version
+    return opsetid
+
+
+def make_function(
+    domain: str,
+    fname: str,
+    inputs: Sequence[str],
+    outputs: Sequence[str],
+    nodes: Sequence[NodeProto],
+    opset_imports: Sequence[OperatorSetIdProto],
+    attributes: Sequence[str] | None = None,
+    attribute_protos: Sequence[AttributeProto] | None = None,
+    doc_string: str | None = None,
+    overload: str | None = None,
+    value_info: Sequence[ValueInfoProto] | None = None,
+) -> FunctionProto:
+    if attributes is None:
+        attributes = []
+    if attribute_protos is None:
+        attribute_protos = []
+    if value_info is None:
+        value_info = []
+    f = FunctionProto()
+    f.domain = domain
+    f.name = fname
+    f.input.extend(inputs)
+    f.output.extend(outputs)
+    f.node.extend(nodes)
+    f.opset_import.extend(opset_imports)
+    f.attribute.extend(attributes)
+    f.attribute_proto.extend(attribute_protos)
+    if doc_string:
+        f.doc_string = doc_string
+    if overload is not None:
+        f.overload = overload
+    f.value_info.extend(value_info)
+    return f
+
+
+def make_model(graph: GraphProto, **kwargs: Any) -> ModelProto:
+    """Construct a ModelProto
+
+    Args:
+        graph (GraphProto): *make_graph* returns
+        **kwargs: any attribute to add to the returned instance
+    Returns:
+        ModelProto
+    """
+    model = ModelProto()
+    # Touch model.ir_version so it is stored as the version from which it is
+    # generated.
+    model.ir_version = onnx.IR_VERSION
+    model.graph.CopyFrom(graph)
+
+    opset_imports: Sequence[OperatorSetIdProto] | None = kwargs.pop(
+        "opset_imports", None
+    )
+    if opset_imports is not None:
+        model.opset_import.extend(opset_imports)
+    else:
+        # Default import
+        imp = model.opset_import.add()
+        imp.version = defs.onnx_opset_version()
+
+    functions: Sequence[FunctionProto] | None = kwargs.pop("functions", None)
+    if functions is not None:
+        model.functions.extend(functions)
+
+    for k, v in kwargs.items():
+        # TODO: Does this work with repeated fields?
+        setattr(model, k, v)
+    return model
+
+
+# An extension of make_model that infers an IR_VERSION for the model,
+# if not specified, using a best-effort-basis.
+def make_model_gen_version(graph: GraphProto, **kwargs: Any) -> ModelProto:
+    ir_version_field = "ir_version"
+    if ir_version_field not in kwargs:
+        opset_imports_field = "opset_imports"
+        imports = kwargs.get(opset_imports_field, [])
+        kwargs[ir_version_field] = find_min_ir_version_for(imports)
+    return make_model(graph, **kwargs)
+
+
+def set_metadata_props(
+    proto: (
+        ModelProto
+        | GraphProto
+        | FunctionProto
+        | NodeProto
+        | TensorProto
+        | ValueInfoProto
+    ),
+    dict_value: dict[str, str],
+) -> None:
+    del proto.metadata_props[:]
+    for k, v in dict_value.items():
+        entry = proto.metadata_props.add()
+        entry.key = k
+        entry.value = v
+
+
+def set_model_props(model: ModelProto, dict_value: dict[str, str]) -> None:
+    set_metadata_props(model, dict_value)
+
+
+def make_tensor(
+    name: str,
+    data_type: int,
+    dims: Sequence[int],
+    vals: Sequence[int | float] | bytes | np.ndarray,
+    raw: bool = False,
+) -> TensorProto:
+    """Make a TensorProto with specified arguments.  If raw is False, this
+    function will choose the corresponding proto field to store the
+    values based on data_type. If raw is True, use "raw_data" proto
+    field to store the values, and values should be of type bytes in
+    this case.
+
+    Args:
+        name: tensor name
+        data_type: a value such as onnx.TensorProto.FLOAT
+        dims: shape
+        vals: values
+        raw: if True, vals contains the serialized content of the tensor,
+            otherwise, vals should be a list of values of the type defined by ``data_type``.
+
+    Returns:
+        TensorProto
+    """
+    tensor = TensorProto()
+    tensor.data_type = data_type
+    tensor.name = name
+    tensor.dims.extend(dims)
+
+    if data_type == TensorProto.STRING and raw:
+        raise TypeError("Can not use raw_data to store string type.")
+
+    np_dtype = tensor_dtype_to_np_dtype(data_type)
+
+    if raw:
+        # NumPy doesn't have INT2/INT4/FP4. It is packed in couples to UINT8 buffers.
+        if data_type in {TensorProto.UINT4, TensorProto.INT4, TensorProto.FLOAT4E2M1}:
+            expected_size_bytes = 0.5
+        elif data_type in {TensorProto.UINT2, TensorProto.INT2}:
+            expected_size_bytes = 0.25
+        else:
+            expected_size_bytes = np_dtype.itemsize
+        expected_size_bytes *= math.prod(dims)
+        expected_size_bytes = math.ceil(expected_size_bytes)
+        if isinstance(vals, np.ndarray):
+            if data_type in {
+                TensorProto.INT4,
+                TensorProto.UINT4,
+                TensorProto.FLOAT4E2M1,
+            }:
+                vals = onnx.numpy_helper._pack_4bitx2(vals)
+            elif data_type in {TensorProto.UINT2, TensorProto.INT2}:
+                vals = onnx.numpy_helper._pack_2bitx4(vals)
+
+            raw_data = onnx.numpy_helper.tobytes_little_endian(vals)
+        elif isinstance(vals, bytes):
+            raw_data = vals
+        else:
+            raise TypeError(
+                f"Raw data must be bytes or numpy.ndarray, but got {type(vals)}."
+            )
+        if len(raw_data) != expected_size_bytes:
+            raise ValueError(
+                f"Raw data size does not match tensor's size. Expected {expected_size_bytes} bytes, but got {len(raw_data)} bytes."
+            )
+        tensor.raw_data = raw_data
+        return tensor
+
+    assert not raw, "Bug: raw should be False at this point."
+
+    if data_type == TensorProto.STRING:
+        vals = np.array(vals).flatten()
+        if len(vals) != 0:
+            vals = np.vectorize(_to_bytes)(vals)  # Convert to bytes
+    elif data_type in {
+        TensorProto.FLOAT8E4M3FN,
+        TensorProto.FLOAT8E4M3FNUZ,
+        TensorProto.FLOAT8E5M2,
+        TensorProto.FLOAT8E5M2FNUZ,
+    }:
+        # Float8 values are by default casted using saturating cast.
+        vals = onnx.numpy_helper.saturate_cast(np.asarray(vals), np_dtype).flatten()
+    elif data_type == TensorProto.FLOAT8E8M0:
+        vals = onnx.numpy_helper.to_float8e8m0(
+            np.asarray(vals), saturate=True, round_mode="up"
+        ).flatten()
+    else:
+        vals = np.asarray(vals, dtype=np_dtype).flatten()
+
+    expected_elements = math.prod(dims)
+    if len(vals) != expected_elements:
+        raise ValueError(
+            f"Number of values ({len(vals)}) does not match tensor "
+            f"dimensions requiring {expected_elements} elements."
+        )
+    if data_type == TensorProto.COMPLEX128:
+        vals = vals.view(np.float64)  # type: ignore[union-attr]
+    elif data_type == TensorProto.COMPLEX64:
+        vals = vals.view(np.float32)  # type: ignore[union-attr]
+    elif data_type in {TensorProto.BFLOAT16, TensorProto.FLOAT16}:
+        vals = vals.view(np.uint16)  # type: ignore[union-attr]
+    elif data_type in {
+        TensorProto.FLOAT8E4M3FN,
+        TensorProto.FLOAT8E4M3FNUZ,
+        TensorProto.FLOAT8E5M2,
+        TensorProto.FLOAT8E5M2FNUZ,
+        TensorProto.FLOAT8E8M0,
+    }:
+        vals = vals.view(np.uint8)  # type: ignore[union-attr]
+    elif data_type in {TensorProto.UINT4, TensorProto.INT4, TensorProto.FLOAT4E2M1}:
+        # Convert to packed 4-bit representation
+        vals = onnx.numpy_helper._pack_4bitx2(vals)  # type: ignore[arg-type]
+    elif data_type in {TensorProto.UINT2, TensorProto.INT2}:
+        # Convert to packed 2-bit representation
+        vals = onnx.numpy_helper._pack_2bitx4(vals)  # type: ignore[arg-type]
+    elif data_type == TensorProto.BOOL:
+        vals = vals.astype(np.uint8)  # type: ignore[union-attr]
+
+    field = tensor_dtype_to_field(data_type)
+    getattr(tensor, field).extend(vals)
+    return tensor
+
+
+def make_sparse_tensor(
+    values: TensorProto, indices: TensorProto, dims: Sequence[int]
+) -> onnx.SparseTensorProto:
+    """Construct a SparseTensorProto
+
+    Args:
+        values (TensorProto): the values
+        indices (TensorProto): the indices
+        dims: the shape
+
+    Returns:
+        SparseTensorProto
+    """
+    sparse = onnx.SparseTensorProto()
+    sparse.values.CopyFrom(values)
+    sparse.indices.CopyFrom(indices)
+    sparse.dims.extend(dims)
+    return sparse
+
+
+def make_sequence(
+    name: str,
+    elem_type: SequenceProto.DataType,
+    values: Sequence[Any],
+) -> SequenceProto:
+    """Make a Sequence with specified value arguments."""
+    sequence = SequenceProto()
+    sequence.name = name
+    sequence.elem_type = elem_type  # type: ignore[assignment]
+
+    if elem_type == SequenceProto.UNDEFINED:
+        return sequence
+
+    attribute: RepeatedCompositeFieldContainer | None = None
+    if elem_type == SequenceProto.TENSOR:
+        attribute = sequence.tensor_values
+    elif elem_type == SequenceProto.SPARSE_TENSOR:
+        attribute = sequence.sparse_tensor_values
+    elif elem_type == SequenceProto.SEQUENCE:
+        attribute = sequence.sequence_values
+    elif elem_type == SequenceProto.MAP:
+        attribute = sequence.map_values
+    elif elem_type == OptionalProto.OPTIONAL:
+        attribute = sequence.optional_values
+    else:
+        raise TypeError("The element type in the input sequence is not supported.")
+
+    attribute.extend(values)
+    return sequence
+
+
+def make_map(
+    name: str, key_type: int, keys: list[Any], values: SequenceProto
+) -> MapProto:
+    """Make a Map with specified key-value pair arguments.
+
+    Criteria for conversion:
+    - Keys and Values must have the same number of elements
+    - Every key in keys must be of the same type
+    - Every value in values must be of the same type
+    """
+    map_proto = MapProto()
+    valid_key_int_types = [
+        TensorProto.INT8,
+        TensorProto.INT16,
+        TensorProto.INT32,
+        TensorProto.INT64,
+        TensorProto.UINT8,
+        TensorProto.UINT16,
+        TensorProto.UINT32,
+        TensorProto.UINT64,
+    ]
+    map_proto.name = name
+    map_proto.key_type = key_type
+    if key_type == TensorProto.STRING:
+        map_proto.string_keys.extend(keys)
+    elif key_type in valid_key_int_types:
+        map_proto.keys.extend(keys)
+    map_proto.values.CopyFrom(values)
+    return map_proto
+
+
+def make_optional(
+    name: str,
+    elem_type: OptionalProto.DataType,
+    value: google.protobuf.message.Message | None,
+) -> OptionalProto:
+    """Make an Optional with specified value arguments."""
+    optional = OptionalProto()
+    optional.name = name
+    optional.elem_type = elem_type  # type: ignore[assignment]
+
+    if elem_type == OptionalProto.UNDEFINED:
+        return optional
+    attribute: google.protobuf.message.Message | None = None
+    if elem_type == OptionalProto.TENSOR:
+        attribute = optional.tensor_value
+    elif elem_type == OptionalProto.SPARSE_TENSOR:
+        attribute = optional.sparse_tensor_value
+    elif elem_type == OptionalProto.SEQUENCE:
+        attribute = optional.sequence_value
+    elif elem_type == OptionalProto.MAP:
+        attribute = optional.map_value
+    elif elem_type == OptionalProto.OPTIONAL:
+        attribute = optional.optional_value
+    else:
+        raise TypeError("The element type in the input optional is not supported.")
+
+    assert value is not None
+    attribute.CopyFrom(value)  # type: ignore[arg-type]
+    return optional
+
+
+def _to_bytes(value: str | bytes) -> bytes:
+    """Coerce a string (or bytes) value into UTF-8 bytes."""
+    if isinstance(value, str):
+        return value.encode("utf-8")
+    return value
+
+
+def make_attribute(
+    key: str,
+    value: Any,
+    doc_string: str | None = None,
+    attr_type: int | None = None,
+) -> AttributeProto:
+    """Makes an AttributeProto based on the value type."""
+    attr = AttributeProto()
+    attr.name = key
+    if doc_string:
+        attr.doc_string = doc_string
+
+    # Singular cases
+    if isinstance(value, numbers.Integral):
+        attr.i = int(value)
+        attr.type = AttributeProto.INT
+    elif isinstance(value, numbers.Real):
+        attr.f = float(value)
+        attr.type = AttributeProto.FLOAT
+    elif isinstance(value, (str, bytes)):
+        # Encode strings into utf-8
+        attr.s = _to_bytes(value)
+        attr.type = AttributeProto.STRING
+    elif isinstance(value, TensorProto):
+        attr.t.CopyFrom(value)
+        attr.type = AttributeProto.TENSOR
+    elif isinstance(value, onnx.SparseTensorProto):
+        attr.sparse_tensor.CopyFrom(value)
+        attr.type = AttributeProto.SPARSE_TENSOR
+    elif isinstance(value, GraphProto):
+        attr.g.CopyFrom(value)
+        attr.type = AttributeProto.GRAPH
+    elif isinstance(value, TypeProto):
+        attr.tp.CopyFrom(value)
+        attr.type = AttributeProto.TYPE_PROTO
+    # Iterable cases
+    elif isinstance(value, collections.abc.Iterable):
+        value = list(value)
+        if len(value) == 0 and attr_type is None:
+            raise ValueError(
+                f"Could not infer attribute `{key}` type from empty iterator"
+            )
+        if attr_type is None:
+            types = {type(v) for v in value}
+            for exp_t, exp_enum in (
+                (numbers.Integral, AttributeProto.INTS),
+                (numbers.Real, AttributeProto.FLOATS),
+                ((str, bytes), AttributeProto.STRINGS),
+                (TensorProto, AttributeProto.TENSORS),
+                (onnx.SparseTensorProto, AttributeProto.SPARSE_TENSORS),
+                (GraphProto, AttributeProto.GRAPHS),
+                (TypeProto, AttributeProto.TYPE_PROTOS),
+            ):
+                if all(issubclass(t, exp_t) for t in types):
+                    attr_type = exp_enum
+                    break
+            if attr_type is None:
+                raise ValueError(
+                    "Could not infer the attribute type from the elements of the passed Iterable value."
+                )
+
+        if attr_type == AttributeProto.INTS:
+            attr.ints.extend(value)
+            attr.type = AttributeProto.INTS
+        elif attr_type == AttributeProto.FLOATS:
+            attr.floats.extend(value)
+            attr.type = AttributeProto.FLOATS
+        elif attr_type == AttributeProto.STRINGS:
+            attr.strings.extend(_to_bytes(v) for v in value)
+            attr.type = AttributeProto.STRINGS
+        elif attr_type == AttributeProto.TENSORS:
+            attr.tensors.extend(value)
+            attr.type = AttributeProto.TENSORS
+        elif attr_type == AttributeProto.SPARSE_TENSORS:
+            attr.sparse_tensors.extend(value)
+            attr.type = AttributeProto.SPARSE_TENSORS
+        elif attr_type == AttributeProto.GRAPHS:
+            attr.graphs.extend(value)
+            attr.type = AttributeProto.GRAPHS
+        elif attr_type == AttributeProto.TYPE_PROTOS:
+            attr.type_protos.extend(value)
+            attr.type = AttributeProto.TYPE_PROTOS
+        else:
+            raise AssertionError  # Should not reach since `ValueError` must be raised in attr_type checking
+    else:
+        raise TypeError(f"'{value}' is not an accepted attribute value.")
+
+    if attr_type is not None and attr.type != attr_type:
+        raise TypeError(
+            f"Inferred attribute type '{_attr_type_to_str(attr.type)}'({attr.type}) mismatched with specified type '{_attr_type_to_str(attr_type)}'({attr_type})"
+        )
+    return attr
+
+
+def make_attribute_ref(
+    name: str,
+    attr_type: AttributeProto.AttributeType,
+    doc_string: str | None = None,
+    *,
+    ref_attr_name: str | None = None,
+) -> AttributeProto:
+    """Make an AttributeProto holding a reference to the parent function's attribute.
+
+    The returned attribute carries no value of its own; at instantiation time its
+    value is supplied by the parent function's attribute named ``ref_attr_name``.
+    When ``ref_attr_name`` is not provided, it defaults to ``name``. Reference
+    attributes are only valid inside a function (sub-graph).
+
+    Args:
+        name: The name of this attribute as used inside the function body.
+        attr_type: The type of the attribute.
+        doc_string: Optional human-readable documentation for the attribute.
+        ref_attr_name: The name of the parent function's attribute being referenced.
+    """
+    if ref_attr_name is None:
+        ref_attr_name = name
+    if not ref_attr_name:
+        raise ValueError("ref_attr_name must be non-empty")
+
+    attr = AttributeProto()
+    attr.name = name
+    attr.type = attr_type  # type: ignore[assignment]
+    attr.ref_attr_name = ref_attr_name
+    if doc_string:
+        attr.doc_string = doc_string
+    return attr
+
+
+def get_attribute_value(attr: AttributeProto) -> Any:  # noqa: PLR0911
+    if attr.ref_attr_name:
+        raise ValueError(f"Cannot get value of reference attribute: {attr}")
+    if attr.type == AttributeProto.FLOAT:
+        return attr.f
+    if attr.type == AttributeProto.INT:
+        return attr.i
+    if attr.type == AttributeProto.STRING:
+        return attr.s
+    if attr.type == AttributeProto.TENSOR:
+        return attr.t
+    if attr.type == AttributeProto.SPARSE_TENSOR:
+        return attr.sparse_tensor
+    if attr.type == AttributeProto.GRAPH:
+        return attr.g
+    if attr.type == AttributeProto.TYPE_PROTO:
+        return attr.tp
+    if attr.type == AttributeProto.FLOATS:
+        return list(attr.floats)
+    if attr.type == AttributeProto.INTS:
+        return list(attr.ints)
+    if attr.type == AttributeProto.STRINGS:
+        return list(attr.strings)
+    if attr.type == AttributeProto.TENSORS:
+        return list(attr.tensors)
+    if attr.type == AttributeProto.SPARSE_TENSORS:
+        return list(attr.sparse_tensors)
+    if attr.type == AttributeProto.GRAPHS:
+        return list(attr.graphs)
+    if attr.type == AttributeProto.TYPE_PROTOS:
+        return list(attr.type_protos)
+    if attr.type == AttributeProto.UNDEFINED:
+        return None
+    raise ValueError(f"Unsupported ONNX attribute: {attr}")
+
+
+def get_node_attr_value(node: NodeProto, attr_name: str) -> Any:
+    matching = [x for x in node.attribute if x.name == attr_name]
+    if len(matching) > 1:
+        raise ValueError(f"Node has multiple attributes with name {attr_name}")
+    if len(matching) < 1:
+        raise ValueError(f"Node has no attribute with name {attr_name}")
+    return get_attribute_value(matching[0])
+
+
+def make_empty_tensor_value_info(name: str) -> ValueInfoProto:
+    value_info_proto = ValueInfoProto()
+    value_info_proto.name = name
+    return value_info_proto
+
+
+def make_tensor_type_proto(
+    elem_type: int,
+    shape: Sequence[str | int | None] | None,
+    shape_denotation: list[str] | None = None,
+) -> TypeProto:
+    """Makes a Tensor TypeProto based on the data type and shape."""
+    type_proto = TypeProto()
+    tensor_type_proto = type_proto.tensor_type
+    tensor_type_proto.elem_type = elem_type
+    tensor_shape_proto = tensor_type_proto.shape
+
+    if shape is not None:
+        # You might think this is a no-op (extending a normal Python
+        # list by [] certainly is), but protobuf lists work a little
+        # differently; if a field is never set, it is omitted from the
+        # resulting protobuf; a list that is explicitly set to be
+        # empty will get an (empty) entry in the protobuf. This
+        # difference is visible to our consumers, so make sure we emit
+        # an empty shape!
+        tensor_shape_proto.dim.extend([])
+
+        if shape_denotation and len(shape_denotation) != len(shape):
+            raise ValueError(
+                "Invalid shape_denotation. Must be of the same length as shape."
+            )
+
+        for i, d in enumerate(shape):
+            dim = tensor_shape_proto.dim.add()
+            if d is None:
+                pass
+            elif isinstance(d, int):
+                dim.dim_value = d
+            elif isinstance(d, str):
+                dim.dim_param = d
+            else:
+                raise ValueError(
+                    f"Invalid item in shape: {d}. Needs to be of int or str."
+                )
+
+            if shape_denotation:
+                dim.denotation = shape_denotation[i]
+
+    return type_proto
+
+
+def make_tensor_value_info(
+    name: str,
+    elem_type: int,
+    shape: Sequence[str | int | None] | None,
+    doc_string: str = "",
+    shape_denotation: list[str] | None = None,
+) -> ValueInfoProto:
+    """Makes a ValueInfoProto based on the data type and shape."""
+    value_info_proto = ValueInfoProto()
+    value_info_proto.name = name
+    if doc_string:
+        value_info_proto.doc_string = doc_string
+
+    tensor_type_proto = make_tensor_type_proto(elem_type, shape, shape_denotation)
+    value_info_proto.type.CopyFrom(tensor_type_proto)
+    return value_info_proto
+
+
+def make_sparse_tensor_type_proto(
+    elem_type: int,
+    shape: Sequence[str | int | None] | None,
+    shape_denotation: list[str] | None = None,
+) -> TypeProto:
+    """Makes a SparseTensor TypeProto based on the data type and shape."""
+    type_proto = TypeProto()
+    sparse_tensor_type_proto = type_proto.sparse_tensor_type
+    sparse_tensor_type_proto.elem_type = elem_type
+    sparse_tensor_shape_proto = sparse_tensor_type_proto.shape
+
+    if shape is not None:
+        # You might think this is a no-op (extending a normal Python
+        # list by [] certainly is), but protobuf lists work a little
+        # differently; if a field is never set, it is omitted from the
+        # resulting protobuf; a list that is explicitly set to be
+        # empty will get an (empty) entry in the protobuf. This
+        # difference is visible to our consumers, so make sure we emit
+        # an empty shape!
+        sparse_tensor_shape_proto.dim.extend([])
+
+        if shape_denotation and len(shape_denotation) != len(shape):
+            raise ValueError(
+                "Invalid shape_denotation. Must be of the same length as shape."
+            )
+
+        for i, d in enumerate(shape):
+            dim = sparse_tensor_shape_proto.dim.add()
+            if d is None:
+                pass
+            elif isinstance(d, int):
+                dim.dim_value = d
+            elif isinstance(d, str):
+                dim.dim_param = d
+            else:
+                raise ValueError(
+                    f"Invalid item in shape: {d}. Needs to be of int or text."
+                )
+
+            if shape_denotation:
+                dim.denotation = shape_denotation[i]
+
+    return type_proto
+
+
+def make_sparse_tensor_value_info(
+    name: str,
+    elem_type: int,
+    shape: Sequence[str | int | None] | None,
+    doc_string: str = "",
+    shape_denotation: list[str] | None = None,
+) -> ValueInfoProto:
+    """Makes a SparseTensor ValueInfoProto based on the data type and shape."""
+    value_info_proto = ValueInfoProto()
+    value_info_proto.name = name
+    if doc_string:
+        value_info_proto.doc_string = doc_string
+
+    sparse_tensor_type_proto = make_sparse_tensor_type_proto(
+        elem_type, shape, shape_denotation
+    )
+    value_info_proto.type.sparse_tensor_type.CopyFrom(
+        sparse_tensor_type_proto.sparse_tensor_type
+    )
+    return value_info_proto
+
+
+def make_sequence_type_proto(
+    inner_type_proto: TypeProto,
+) -> TypeProto:
+    """Makes a sequence TypeProto."""
+    type_proto = TypeProto()
+    type_proto.sequence_type.elem_type.CopyFrom(inner_type_proto)
+    return type_proto
+
+
+def make_optional_type_proto(
+    inner_type_proto: TypeProto,
+) -> TypeProto:
+    """Makes an optional TypeProto."""
+    type_proto = TypeProto()
+    type_proto.optional_type.elem_type.CopyFrom(inner_type_proto)
+    return type_proto
+
+
+def make_map_type_proto(
+    key_type: int,
+    value_type: TypeProto,
+) -> TypeProto:
+    """Makes a map TypeProto."""
+    type_proto = TypeProto()
+    type_proto.map_type.key_type = key_type
+    type_proto.map_type.value_type.CopyFrom(value_type)
+    return type_proto
+
+
+def make_value_info(
+    name: str,
+    type_proto: TypeProto,
+    doc_string: str = "",
+) -> ValueInfoProto:
+    """Makes a ValueInfoProto with the given type_proto."""
+    value_info_proto = ValueInfoProto()
+    value_info_proto.name = name
+    if doc_string:
+        value_info_proto.doc_string = doc_string
+
+    value_info_proto.type.CopyFrom(type_proto)
+    return value_info_proto
+
+
+def _sanitize_str(s: str | bytes) -> str:
+    if isinstance(s, str):
+        sanitized = s
+    elif isinstance(s, bytes):
+        sanitized = s.decode("utf-8", errors="ignore")
+    else:
+        sanitized = str(s)
+    if len(sanitized) < 64:  # noqa: PLR2004
+        return sanitized
+    return sanitized[:64] + f"...<+len={(len(sanitized) - 64)}>"
+
+
+def make_tensor_sequence_value_info(
+    name: str,
+    elem_type: int,
+    shape: Sequence[str | int | None] | None,
+    doc_string: str = "",
+    elem_shape_denotation: list[str] | None = None,
+) -> ValueInfoProto:
+    """Makes a Sequence[Tensors] ValueInfoProto based on the data type and shape."""
+    value_info_proto = ValueInfoProto()
+    value_info_proto.name = name
+    if doc_string:
+        value_info_proto.doc_string = doc_string
+
+    tensor_type_proto = make_tensor_type_proto(elem_type, shape, elem_shape_denotation)
+    sequence_type_proto = make_sequence_type_proto(tensor_type_proto)
+    value_info_proto.type.sequence_type.CopyFrom(sequence_type_proto.sequence_type)
+
+    return value_info_proto
+
+
+def printable_attribute(
+    attr: AttributeProto, subgraphs: bool = False
+) -> str | tuple[str, list[GraphProto]]:
+    content = []
+    content.append(attr.name)
+    content.append("=")
+
+    def str_float(f: float) -> str:
+        # NB: Different Python versions print different numbers of trailing
+        # decimals, specifying this explicitly keeps it consistent for all
+        # versions
+        return f"{f:.15g}"
+
+    def str_int(i: int) -> str:
+        return str(i)
+
+    _T = TypeVar("_T")
+
+    def str_list(str_elem: Callable[[_T], str], xs: Sequence[_T]) -> str:
+        return "[" + ", ".join(map(str_elem, xs)) + "]"
+
+    # for now, this logic should continue to work as long as we are running on a proto3
+    # implementation. If/when we switch to proto3, we will need to use attr.type
+
+    # To support printing subgraphs, if we find a graph attribute, print out
+    # its name here and pass the graph itself up to the caller for later
+    # printing.
+    graphs = []
+    if attr.HasField("f"):
+        content.append(str_float(attr.f))
+    elif attr.HasField("i"):
+        content.append(str_int(attr.i))
+    elif attr.HasField("s"):
+        # TODO: Bit nervous about Python 2 / Python 3 determinism implications
+        content.append(repr(_sanitize_str(attr.s)))
+    elif attr.HasField("t"):
+        if len(attr.t.dims) > 0:
+            content.append("<Tensor>")
+        else:
+            # special case to print scalars
+            field = tensor_dtype_to_field(attr.t.data_type)
+            content.append(f"<Scalar Tensor {getattr(attr.t, field)}>")
+    elif attr.HasField("g"):
+        content.append(f"<graph {attr.g.name}>")
+        graphs.append(attr.g)
+    elif attr.HasField("tp"):
+        content.append(f"<Type Proto {attr.tp}>")
+    elif attr.HasField("sparse_tensor"):
+        content.append("<Sparse Tensor>")
+    elif attr.floats:
+        content.append(str_list(str_float, attr.floats))
+    elif attr.ints:
+        content.append(str_list(str_int, attr.ints))
+    elif attr.strings:
+        # TODO: Bit nervous about Python 2 / Python 3 determinism implications
+        content.append(str(list(map(_sanitize_str, attr.strings))))
+    elif attr.tensors:
+        content.append("[<Tensor>, ...]")
+    elif attr.sparse_tensors:
+        content.append("[<Sparse Tensor>, ...]")
+    elif attr.type_protos:
+        content.append("[")
+        for i, tp in enumerate(attr.type_protos):
+            comma = "," if i != len(attr.type_protos) - 1 else ""
+            content.append(f"<Type Proto {tp}>{comma}")
+        content.append("]")
+    elif attr.graphs:
+        content.append("[")
+        for i, g in enumerate(attr.graphs):
+            comma = "," if i != len(attr.graphs) - 1 else ""
+            content.append(f"<graph {g.name}>{comma}")
+        content.append("]")
+        graphs.extend(attr.graphs)
+    else:
+        content.append("<Unknown>")
+    if subgraphs:
+        return " ".join(content), graphs
+    return " ".join(content)
+
+
+def printable_dim(dim: TensorShapeProto.Dimension) -> str:
+    which = dim.WhichOneof("value")
+    if which is None:
+        return "?"
+    return str(getattr(dim, which))
+
+
+def printable_type(t: TypeProto) -> str:
+    if t.WhichOneof("value") == "tensor_type":
+        s: str = TensorProto.DataType.Name(t.tensor_type.elem_type)  # type: ignore[arg-type]
+        if t.tensor_type.HasField("shape"):
+            if len(t.tensor_type.shape.dim):
+                s += str(", " + "x".join(map(printable_dim, t.tensor_type.shape.dim)))
+            else:
+                s += ", scalar"
+        return s
+    if t.WhichOneof("value") is None:
+        return ""
+    return f"Unknown type {t.WhichOneof('value')}"
+
+
+def printable_value_info(v: ValueInfoProto) -> str:
+    s = f"%{v.name}"
+    if v.type:
+        s = f"{s}[{printable_type(v.type)}]"
+    return s
+
+
+def printable_tensor_proto(t: TensorProto) -> str:
+    s = f"%{t.name}["
+    s += TensorProto.DataType.Name(t.data_type)  # type: ignore[arg-type]
+    if t.dims is not None:
+        if len(t.dims):
+            s += str(", " + "x".join(map(str, t.dims)))
+        else:
+            s += ", scalar"
+    s += "]"
+    return s
+
+
+def printable_node(
+    node: NodeProto, prefix: str = "", subgraphs: bool = False
+) -> str | tuple[str, list[GraphProto]]:
+    content = []
+    if len(node.output):
+        content.append(", ".join([f"%{name}" for name in node.output]))
+        content.append("=")
+    # To deal with nested graphs
+    graphs: list[GraphProto] = []
+    printed_attrs = []
+    for attr in node.attribute:
+        if subgraphs:
+            printed_attr_subgraphs = printable_attribute(attr, subgraphs)
+            if not isinstance(printed_attr_subgraphs[1], list):
+                raise TypeError(
+                    f"printed_attr_subgraphs[1] must be an instance of {list}."
+                )
+            graphs.extend(printed_attr_subgraphs[1])
+            printed_attrs.append(printed_attr_subgraphs[0])
+        else:
+            printed = printable_attribute(attr)
+            if not isinstance(printed, str):
+                raise TypeError(f"printed must be an instance of {str}.")
+            printed_attrs.append(printed)
+    printed_attributes = ", ".join(sorted(printed_attrs))
+    printed_inputs = ", ".join([f"%{name}" for name in node.input])
+    if node.attribute:
+        content.append(f"{node.op_type}[{printed_attributes}]({printed_inputs})")
+    else:
+        content.append(f"{node.op_type}({printed_inputs})")
+    if subgraphs:
+        return prefix + " ".join(content), graphs
+    return prefix + " ".join(content)
+
+
+@typing_extensions.deprecated(
+    "Deprecated since 1.19. Consider using onnx.printer.to_text() instead."
+)
+def printable_graph(graph: GraphProto, prefix: str = "") -> str:
+    """Display a GraphProto as a string.
+
+    .. deprecated:: 1.19
+        Consider using :func:`onnx.printer.to_text` instead.
+
+    Args:
+        graph (GraphProto): the graph to display
+        prefix (string): prefix of every line
+
+    Returns:
+        string
+    """
+    content = []
+    indent = prefix + "  "
+    # header
+    header = ["graph", graph.name]
+    initializers = {t.name for t in graph.initializer}
+    if len(graph.input):
+        header.append("(")
+        in_strs = []  # required inputs
+        in_with_init_strs: list = []  # optional inputs with initializer providing default value
+        for inp in graph.input:
+            if inp.name not in initializers:
+                in_strs.append(printable_value_info(inp))
+            else:
+                in_with_init_strs.append(printable_value_info(inp))
+        if in_strs:
+            content.append(prefix + " ".join(header))
+            header = []
+            for line in in_strs:
+                content.append(prefix + "  " + line)  # noqa: PERF401
+        header.append(")")
+
+        if in_with_init_strs:
+            header.append("optional inputs with matching initializers (")
+            content.append(prefix + " ".join(header))
+            header = []
+            for line in in_with_init_strs:
+                content.append(prefix + "  " + line)  # noqa: PERF401
+            header.append(")")
+
+        # from IR 4 onwards an initializer is not required to have a matching graph input
+        # so output the name, type and shape of those as well
+        if len(in_with_init_strs) < len(initializers):
+            graph_inputs = {i.name for i in graph.input}
+            init_strs = [
+                printable_tensor_proto(i)
+                for i in graph.initializer
+                if i.name not in graph_inputs
+            ]
+            header.append("initializers (")
+            content.append(prefix + " ".join(header))
+            header = []
+            for line in init_strs:
+                content.append(prefix + "  " + line)  # noqa: PERF401
+            header.append(")")
+
+    header.append("{")
+    content.append(prefix + " ".join(header))
+    graphs: list[GraphProto] = []
+    # body
+    for node in graph.node:
+        contents_subgraphs = printable_node(node, indent, subgraphs=True)
+        if not isinstance(contents_subgraphs[1], list):
+            raise TypeError(f"contents_subgraphs[1] must be an instance of {list}.")
+        content.append(contents_subgraphs[0])
+        graphs.extend(contents_subgraphs[1])
+    # tail
+    tail = ["return"]
+    if len(graph.output):
+        tail.append(", ".join([f"%{out.name}" for out in graph.output]))
+    content.append(indent + " ".join(tail))
+    # closing bracket
+    content.append(prefix + "}")
+    for g in graphs:
+        content.append("\n" + printable_graph(g))  # noqa: PERF401
+    return "\n".join(content)
+
+
+def strip_doc_string(proto: google.protobuf.message.Message) -> None:
+    """Empties `doc_string` field on any nested protobuf messages"""
+    if not isinstance(proto, google.protobuf.message.Message):
+        raise TypeError(
+            f"proto must be an instance of {google.protobuf.message.Message}."
+        )
+    for descriptor in proto.DESCRIPTOR.fields:
+        if descriptor.name == "doc_string":
+            proto.ClearField(descriptor.name)
+        elif descriptor.type == descriptor.TYPE_MESSAGE:
+            if descriptor.label == descriptor.LABEL_REPEATED:
+                for x in getattr(proto, descriptor.name):
+                    strip_doc_string(x)
+            elif proto.HasField(descriptor.name):
+                strip_doc_string(getattr(proto, descriptor.name))
+
+
+def make_training_info(
+    algorithm: GraphProto,
+    algorithm_bindings: AssignmentBindingType,
+    initialization: GraphProto | None,
+    initialization_bindings: AssignmentBindingType | None,
+) -> TrainingInfoProto:
+    training_info = TrainingInfoProto()
+    training_info.algorithm.CopyFrom(algorithm)
+    for k, v in algorithm_bindings:
+        binding = training_info.update_binding.add()
+        binding.key = k
+        binding.value = v
+
+    if initialization:
+        training_info.initialization.CopyFrom(initialization)
+    if initialization_bindings:
+        for k, v in initialization_bindings:
+            binding = training_info.initialization_binding.add()
+            binding.key = k
+            binding.value = v
+
+    return training_info
+
+
+# Following functions are used for mapping
+def tensor_dtype_to_np_dtype(tensor_dtype: int) -> np.dtype:
+    """Convert a TensorProto's data_type to corresponding numpy dtype. It can be used while making tensor.
+
+    Args:
+        tensor_dtype: TensorProto's data_type
+
+    Returns:
+        numpy's data_type
+    """
+    return _mapping.TENSOR_TYPE_MAP[tensor_dtype].np_dtype
+
+
+def tensor_dtype_to_storage_tensor_dtype(tensor_dtype: int) -> int:
+    """Convert a TensorProto's data_type to corresponding data_type for storage.
+
+    Args:
+        tensor_dtype: TensorProto's data_type
+
+    Returns:
+        data_type for storage
+    """
+    return _mapping.TENSOR_TYPE_MAP[tensor_dtype].storage_dtype
+
+
+def tensor_dtype_to_string(tensor_dtype: int) -> str:
+    """Get the name of given TensorProto's data_type.
+
+    Args:
+        tensor_dtype: TensorProto's data_type
+
+    Returns:
+        the name of data_type
+    """
+    return _mapping.TENSOR_TYPE_MAP[tensor_dtype].name
+
+
+@functools.lru_cache(None)
+def tensor_dtype_to_field(tensor_dtype: int) -> str:
+    """Convert a TensorProto's data_type to corresponding field name for storage. It can be used while making tensors.
+
+    Args:
+        tensor_dtype: TensorProto's data_type
+
+    Returns:
+        field name
+    """
+    storage_tensor_type_to_field = {
+        int(TensorProto.FLOAT): "float_data",
+        int(TensorProto.INT32): "int32_data",
+        int(TensorProto.INT64): "int64_data",
+        int(TensorProto.DOUBLE): "double_data",
+        int(TensorProto.UINT32): "uint64_data",
+        int(TensorProto.UINT64): "uint64_data",
+        int(TensorProto.STRING): "string_data",
+    }
+    return storage_tensor_type_to_field[
+        _mapping.TENSOR_TYPE_MAP[tensor_dtype].storage_dtype
+    ]
+
+
+@functools.lru_cache(None)
+def np_dtype_to_tensor_dtype(np_dtype: np.dtype) -> TensorProto.DataType:
+    """Convert a numpy's dtype to corresponding tensor type. It can be used while converting numpy arrays to tensors.
+
+    Args:
+        np_dtype: numpy's data_type
+
+    Returns:
+        TensorsProto's data_type
+    """
+    _np_dtype_to_tensor_dtype = {
+        v.np_dtype: k for k, v in _mapping.TENSOR_TYPE_MAP.items()
+    }
+    if np_dtype in _np_dtype_to_tensor_dtype:
+        return typing.cast("TensorProto.DataType", _np_dtype_to_tensor_dtype[np_dtype])
+    if np.issubdtype(np_dtype, np.str_):
+        return TensorProto.STRING  # type: ignore[return-value]
+
+    raise ValueError(
+        f"Unable to convert type {np_dtype!r} into TensorProto element type."
+    )
+
+
+def get_all_tensor_dtypes() -> KeysView[int]:
+    """Get all tensor types from TensorProto.
+
+    Returns:
+        all tensor types from TensorProto
+    """
+    return _mapping.TENSOR_TYPE_MAP.keys()
+
+
+_ATTRIBUTE_TYPE_TO_STR: dict[int, str] = {
+    k: v for v, k in AttributeProto.AttributeType.items()
+}
+
+
+def _attr_type_to_str(attr_type: int) -> str:
+    """Convert AttributeProto type to string.
+
+    Args:
+        attr_type: AttributeProto type.
+
+    Returns:
+        String representing the supplied attr_type.
+    """
+    if attr_type in AttributeProto.AttributeType.values():
+        return _ATTRIBUTE_TYPE_TO_STR[attr_type]
+    return AttributeProto.AttributeType.keys()[0]
diff --git a/onnx/inliner.py b/onnx/inliner.py
new file mode 100644
index 0000000..332b592
--- /dev/null
+++ b/onnx/inliner.py
@@ -0,0 +1,60 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import onnx
+import onnx.onnx_cpp2py_export.inliner as C  # noqa: N812
+
+
+def inline_local_functions(
+    model: onnx.ModelProto, convert_version: bool = False
+) -> onnx.ModelProto:
+    """Inline model-local functions in given model.
+
+    Arguments:
+        model: an ONNX ModelProto
+        convert_version: if true, try to apply automatic version-conversion to functions requiring a
+            different (ONNX) opset version from the model.
+
+    Returns:
+        ModelProto with all calls to model-local functions inlined (recursively)
+    """
+    result = C.inline_local_functions(model.SerializeToString(), convert_version)
+    inlined_model = onnx.ModelProto()
+    inlined_model.ParseFromString(result)
+    return inlined_model
+
+
+def inline_selected_functions(
+    model: onnx.ModelProto,
+    function_ids: list[tuple[str, str]],
+    exclude: bool = False,
+    inline_schema_functions: bool = False,
+) -> onnx.ModelProto:
+    """Inline selected functions in given model.
+
+    Arguments:
+        model: an ONNX ModelProto
+        function_ids: list of functions to include/exclude when inlining. Each
+            element is a tuple of (function domain, function name).
+        exclude: if true, inlines all functions except those specified in function_ids.
+           if false, inlines all functions specified in function_ids.
+        inline_schema_functions: if true, inlines schema-defined functions as well
+            as model-local functions. Otherwise, only model-local functions are inlined.
+
+    Returns:
+        ModelProto with all calls to model-local functions inlined (recursively)
+    """
+    if inline_schema_functions:
+        result = C.inline_selected_functions2(
+            model.SerializeToString(), function_ids, exclude
+        )
+    else:
+        result = C.inline_selected_functions(
+            model.SerializeToString(), function_ids, exclude
+        )
+    inlined_model = onnx.ModelProto()
+    inlined_model.ParseFromString(result)
+    return inlined_model
diff --git a/onnx/inliner/CMakeLists.txt b/onnx/inliner/CMakeLists.txt
new file mode 100644
index 0000000..dd1f4f0
--- /dev/null
+++ b/onnx/inliner/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    inliner.cc
+    inliner.h
+)
diff --git a/onnx/inliner/inliner.cc b/onnx/inliner/inliner.cc
new file mode 100644
index 0000000..ce9450d
--- /dev/null
+++ b/onnx/inliner/inliner.cc
@@ -0,0 +1,806 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/inliner/inliner.h"
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "onnx/checker.h"
+#include "onnx/common/assertions.h"
+#include "onnx/common/constants.h"
+#include "onnx/common/proto_util.h"
+#include "onnx/common/visitor.h"
+#include "onnx/defs/parser.h"
+#include "onnx/shape_inference/attribute_binder.h"
+#include "onnx/shape_inference/implementation.h"
+#include "onnx/version_converter/convert.h"
+
+namespace ONNX_NAMESPACE {
+namespace inliner {
+
+namespace { // internal/private API
+
+using OpsetMapBase = std::unordered_map<std::string, int64_t>;
+
+// A representation of the opset versions required by a model or a function.
+// Used to check for compatibility between a model and a function or between
+// two functions.
+struct OpsetMap : public OpsetMapBase {
+ public:
+  // Construct a map representing the opset versions required by a model.
+  explicit OpsetMap(const ModelProto& model) {
+    (void)Add(model.opset_import());
+  }
+
+  // Adds the opset versions required by a function to the map. Returns true
+  // iff the function is compatible with the map, i.e., if the function does
+  // not require a different version for any domain already in the map.
+  bool Add(const FunctionProto& function) {
+    return Add(function.opset_import());
+  }
+
+  // Returns the set of mismatches in the opset requirements of given
+  // function and the map.
+  OpsetMapBase Mismatches(const FunctionProto& function) const {
+    return Mismatches(function.opset_import());
+  }
+
+ private:
+  OpsetMapBase Mismatches(const google::protobuf::RepeatedPtrField<OperatorSetIdProto>& list) const {
+    OpsetMapBase result;
+    for (const auto& pair : list) {
+      auto iter = this->find(NormalizeDomain(pair.domain()));
+      if ((iter != this->end()) && (iter->second != pair.version()))
+        result.insert(*iter);
+    }
+    return result;
+  }
+
+  bool Add(const google::protobuf::RepeatedPtrField<OperatorSetIdProto>& list) {
+    for (const auto& pair : list) {
+      auto domain = NormalizeDomain(pair.domain());
+      auto version = pair.version();
+      auto iter = this->find(domain);
+      if (iter != this->end()) {
+        if (iter->second != version)
+          return false;
+      } else {
+        (*this)[domain] = version;
+      }
+    }
+    return true;
+  }
+};
+
+using RepeatedNodeProto = google::protobuf::RepeatedPtrField<NodeProto>;
+
+} // namespace
+
+// NOLINTBEGIN(misc-use-internal-linkage): used by Renamer::Impl (pimpl with external linkage)
+class NameGenerator : private internal::Visitor {
+ public:
+  explicit NameGenerator(const GraphProto& graph) : index_(0) {
+    NameGenerator::VisitGraph(graph);
+  }
+
+  explicit NameGenerator(const FunctionProto& function) : index_(0) {
+    NameGenerator::VisitFunction(function);
+  }
+
+  void ResetFor(const GraphProto& graph) {
+    index_ = 0;
+    existing_names_.clear();
+    NameGenerator::VisitGraph(graph);
+  }
+
+  void ResetFor(const FunctionProto& function) {
+    index_ = 0;
+    existing_names_.clear();
+    NameGenerator::VisitFunction(function);
+  }
+
+  // Creates a new unique name, based on a suggested name, and adds it to the set
+  // of existing names. Returns the newly created name.
+  std::string CreateNew(const std::string& suggested) {
+    std::string name = suggested;
+    while (existing_names_.count(name) > 0) {
+      name = suggested + "_" + std::to_string(index_++);
+    }
+    existing_names_.insert(name);
+    return name;
+  }
+
+  void Add(const std::string& name) {
+    // We don't bother to check for empty string names. Ok to add them.
+    existing_names_.insert(name);
+  }
+
+  bool ProcessGraph(const GraphProto& graph) override {
+    for (const auto& x : graph.input())
+      Add(x.name());
+    for (const auto& x : graph.initializer())
+      Add(x.name());
+    // Adding graph outputs is redundant for a valid graph, but we do it anyway,
+    // to produce better results for invalid graphs.
+    for (const auto& x : graph.output())
+      Add(x.name());
+    return true;
+  }
+
+  bool ProcessFunction(const FunctionProto& function) override {
+    for (const auto& x : function.input())
+      Add(x);
+    for (const auto& x : function.output())
+      Add(x);
+    return true;
+  }
+
+  bool ProcessNode(const NodeProto& node) override {
+    // We use a single name-space for node names and variable names, to keep name-generation simple.
+    Add(node.name());
+    for (const std::string& name : node.input()) {
+      Add(name);
+    }
+    for (const std::string& name : node.output()) {
+      Add(name);
+    }
+    return true;
+  }
+
+ private:
+  unsigned int index_;
+  std::unordered_set<std::string> existing_names_;
+};
+
+class InliningRenamer : public internal::MutableVisitor {
+ private:
+  std::string suffix;
+  NameGenerator& generator;
+
+ protected:
+  std::vector<std::unordered_map<std::string, std::string>> rename_scopes;
+
+ public:
+  InliningRenamer(std::string suffix_, NameGenerator& generator_) : suffix(std::move(suffix_)), generator(generator_) {
+    // Create an empty mapping for the top-level scope.
+    rename_scopes.emplace_back();
+  }
+
+  // We use a two-level renaming scheme to generate names for variables when inlined in the
+  // main graph. First, we add a suffix (specific to the call-site being inlined).
+  // Thus, "temp" in called-function becomes "temp__1" for the first inlined function-call
+  // and "temp__2" for the second inlined function-call. In addition, there is a subsequent
+  // iterative check that ensures that this names does not clash with any pre-existing names,
+  // and tries another counter-based suffix in the case of a clash, stopping when successful.
+  std::string MakeUnique(const std::string& name) {
+    return generator.CreateNew(name + suffix);
+  }
+
+  /**
+   * @brief Binds a formal parameter name to an actual parameter name.
+   *
+   * @param formal_name The formal parameter name to bind.
+   * @param actual_name The actual parameter name to bind to.
+   */
+  void BindFormalToActual(const std::string& formal_name, const std::string& actual_name) {
+    auto& current_scope = rename_scopes.back();
+    current_scope[formal_name] = actual_name;
+  }
+
+  /**
+   * @brief Creates a unique name for the given name and binds it.
+   *
+   * This method creates a unique name based on the suffix and binds the original
+   * name to the unique name for later reference renaming.
+   *
+   * @param original_name The name to create a unique version of.
+   * @return The unique name that was created and bound.
+   */
+  std::string BindToUniqueName(const std::string& original_name) {
+    // First create the unique name using MakeUnique
+    std::string unique_name = MakeUnique(original_name);
+
+    // Then bind the original name to the unique name
+    auto& current_scope = rename_scopes.back();
+    current_scope[original_name] = unique_name;
+
+    return unique_name;
+  }
+
+  template <bool isOutput>
+  void Bind(
+      google::protobuf::RepeatedPtrField<std::string>& formals,
+      const google::protobuf::RepeatedPtrField<std::string>& actuals) {
+    // Every formal parameter name FP should be replace by the corresponding actual parameter name AP.
+    // However, if AP is empty, it is a missing optional parameter. This does not make any difference
+    // for inputs. However, for outputs we use a unique dummy name to handle the case that it
+    // is used in an output-context where it is not optional.
+    ONNX_ASSERTM(
+        actuals.size() <= formals.size(), "Number of actual parameters cannot exceed number of formal parameters")
+    auto& current_scope = rename_scopes.back();
+    int i = 0;
+    for (; i < actuals.size(); ++i) {
+      std::string& formal = *formals.Mutable(i);
+      std::string rename_as = actuals.Get(i);
+      if (isOutput)
+        if (rename_as.empty())
+          rename_as = MakeUnique(formal);
+      current_scope[formal] = rename_as;
+      if (!rename_as.empty())
+        formal = rename_as;
+    }
+    for (; i < formals.size(); ++i) {
+      std::string& formal = *formals.Mutable(i);
+      std::string rename_as = isOutput ? MakeUnique(formal) : std::string();
+      current_scope[formal] = rename_as;
+      if (!rename_as.empty())
+        formal = rename_as;
+    }
+  }
+
+  // Process a node:
+  bool ProcessNode(NodeProto& node) override {
+    if (!node.name().empty())
+      node.set_name(MakeUnique(node.name()));
+
+    for (auto& x : *node.mutable_input()) {
+      LookupOrRename(x, false);
+    }
+    for (auto& y : *node.mutable_output()) {
+      LookupOrRename(y, true);
+    }
+    return true; // Process attribute subgraphs in traversal
+  }
+
+  // Process a sub-graph, contained as an attribute in a control-flow op node.
+  // Since we need both pre-processing and post-processing in the traversal, we
+  // override the VisitGraph method.
+  void VisitGraph(GraphProto& graph) override {
+    rename_scopes.emplace_back();
+    for (auto& x : *graph.mutable_input())
+      Rename(*x.mutable_name());
+    for (auto& init : *graph.mutable_initializer())
+      Rename(*init.mutable_name());
+    for (auto& y : *graph.mutable_output())
+      Rename(*y.mutable_name());
+    for (auto& n : *graph.mutable_node())
+      VisitNode(n);
+    rename_scopes.pop_back();
+  }
+
+ private:
+  // Replace given name with a unique version of the name, and cache the
+  // renaming-binding in current scope.
+  void Rename(std::string& name) {
+    auto new_name = MakeUnique(name);
+    auto& current_scope = rename_scopes.back();
+    current_scope[name] = new_name;
+    name = new_name;
+  }
+
+  void LookupOrRename(std::string& name, bool is_new_def) {
+    if (name.empty())
+      return;
+    for (auto i = rename_scopes.size(); i > 0; --i) {
+      const auto& map = rename_scopes[i - 1];
+      auto iter = map.find(name);
+      if (iter != map.end()) {
+        name = iter->second;
+        return;
+      }
+    }
+    if (is_new_def) {
+      Rename(name);
+    }
+    // Otherwise, it is a reference to an outer-scope variable that should not be renamed.
+  }
+
+ public:
+  // Renames variables in a FunctionProto for inlining a particular call-site. This does the following:
+  // (i)  Rename all intermediate variables in the function to ensure that they are unique (wrt the main graph).
+  // (ii) Rename inputs and outputs using names of actual parameters.
+  static void
+  Rename(const NodeProto& callnode, FunctionProto& callee, std::string unique_suffix, NameGenerator& generator) {
+    InliningRenamer renamer(std::move(unique_suffix), generator);
+
+    renamer.Bind<false>(*callee.mutable_input(), callnode.input());
+    renamer.Bind<true>(*callee.mutable_output(), callnode.output());
+
+    renamer.VisitFunction(callee);
+    for (auto& v : *callee.mutable_value_info())
+      renamer.LookupOrRename(*v.mutable_name(), false);
+  }
+};
+// NOLINTEND(misc-use-internal-linkage)
+
+namespace {
+
+// Identify the set of all "input" variables used by a given node.
+// This includes the variables listed as node.input, as well as
+// implicit inputs referred to in any graph-valued-attribute of the node.
+// In the case of variables referenced in sub-graphs, only non-local variables
+// are treated as implicit inputs.
+
+class ComputeInputs : private internal::Visitor {
+ private:
+  std::vector<std::unordered_set<std::string>> namescopes;
+
+  bool InNestedScope() const {
+    return !namescopes.empty();
+  }
+
+  std::unordered_set<std::string>& CurrentScope() {
+    return namescopes.back();
+  }
+
+  bool IsLocalVar(const std::string& name) const {
+    for (const auto& scope : namescopes) {
+      if (scope.count(name) > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  void VisitGraph(const GraphProto& graph) override {
+    namescopes.emplace_back();
+    for (const auto& x : graph.input())
+      CurrentScope().insert(x.name());
+    for (const auto& init : graph.initializer())
+      CurrentScope().insert(init.name());
+    for (const auto& n : graph.node())
+      VisitNode(n);
+    namescopes.pop_back();
+  }
+
+  bool ProcessNode(const NodeProto& node) override {
+    for (const auto& var : node.input()) {
+      if (!var.empty() && !IsLocalVar(var)) {
+        result.push_back(var);
+      }
+    }
+    if (InNestedScope()) {
+      for (const auto& var : node.output()) {
+        if (!var.empty()) {
+          CurrentScope().insert(var);
+        }
+      }
+    }
+    return true; // process sub-graphs
+  }
+
+ public:
+  std::vector<std::string> result;
+
+  explicit ComputeInputs(const NodeProto& node) {
+    result.reserve(node.input_size());
+    ComputeInputs::VisitNode(node);
+  }
+};
+
+std::vector<std::string> GetUsedVars(const NodeProto& node) {
+  return ComputeInputs(node).result;
+}
+
+using ConstNodeMap = std::unordered_map<std::string, const NodeProto*>;
+
+ConstNodeMap FindConstantNodes(const GraphProto& graph) {
+  ConstNodeMap result;
+  for (const NodeProto& node : graph.node()) {
+    if (IsOnnxDomain(node.domain()) && (node.op_type() == "Constant")) {
+      result[node.output(0)] = &node;
+    }
+  }
+  return result;
+}
+
+const TypeProto& GetType(const ModelProto& model, const std::string& var) {
+  for (const auto& vi : model.graph().value_info()) {
+    if (vi.name() == var)
+      return vi.type();
+  }
+  for (const auto& vi : model.graph().input()) {
+    if (vi.name() == var)
+      return vi.type();
+  }
+  for (const auto& vi : model.graph().output()) {
+    if (vi.name() == var)
+      return vi.type();
+  }
+  ONNX_ASSERTM(false, "Type unknown for ", var)
+}
+
+void ConvertVersion(ModelProto& model, const NodeProto& call_node, FunctionProto& function, int target_version) {
+  shape_inference::InferShapes(model);
+
+  ModelProto function_as_model;
+  function_as_model.set_ir_version(model.ir_version());
+  *function_as_model.mutable_opset_import() = function.opset_import();
+
+  GraphProto& graph = *function_as_model.mutable_graph();
+  // The graph's inputs are all the variables used in the call_node.
+  auto used_vars = GetUsedVars(call_node);
+  auto constant_node_map = FindConstantNodes(model.graph());
+
+  RepeatedNodeProto& function_nodes = *function.mutable_node();
+  RepeatedNodeProto& nodes = *graph.mutable_node();
+  nodes.Reserve(function_nodes.size() + used_vars.size());
+
+  auto* inputs = graph.mutable_input();
+  for (const auto& var : used_vars) {
+    auto* new_input = inputs->Add();
+    new_input->set_name(var);
+    *new_input->mutable_type() = GetType(model, var);
+    // Create a copy of constants used by the call_node.
+    // We do not handle initializers-as-constants for now.
+    auto it = constant_node_map.find(var);
+    if (it != constant_node_map.end()) {
+      *nodes.Add() = *(it->second);
+    }
+  }
+
+  // outputs: from call_node node outputs
+  auto* outputs = graph.mutable_output();
+  for (const auto& var : call_node.output()) {
+    if (!var.empty()) {
+      auto* new_output = outputs->Add();
+      new_output->set_name(var);
+      *new_output->mutable_type() = GetType(model, var);
+    }
+  }
+
+  for (auto& function_node : function_nodes)
+    *nodes.Add() = std::move(function_node);
+  function_nodes.Clear();
+
+  auto converted = ONNX_NAMESPACE::version_conversion::ConvertVersion(function_as_model, target_version);
+
+  function_nodes.Swap(converted.mutable_graph()->mutable_node());
+
+  // Append new initializers to main graph initializers
+  for (const auto& added_initializer : converted.graph().initializer())
+    *model.mutable_graph()->mutable_initializer()->Add() = added_initializer;
+  for (const auto& added_initializer : converted.graph().sparse_initializer())
+    *model.mutable_graph()->mutable_sparse_initializer()->Add() = added_initializer;
+}
+
+int64_t GetDomainVersion(const ModelProto& model, const std::string& domain) {
+  for (const auto& opset : model.opset_import()) {
+    if (opset.domain() == domain) {
+      return opset.version();
+    }
+  }
+  return 0;
+}
+
+class VectorSet : public FunctionIdSet {
+ public:
+  VectorSet(FunctionIdVector&& function_ids, bool invert) : function_ids_(std::move(function_ids)), invert_(invert) {}
+
+  bool Contains(const std::string& function_domain, const std::string& function_name) const override {
+    bool found =
+        std::find(function_ids_.begin(), function_ids_.end(), std::make_pair(function_domain, function_name)) !=
+        function_ids_.end();
+    return invert_ ? !found : found;
+  }
+
+ private:
+  FunctionIdVector function_ids_;
+  bool invert_;
+};
+
+constexpr int64_t kNoConversion = -1;
+using FunctionMap = std::unordered_map<FunctionImplId, std::pair<const FunctionProto*, int64_t>>;
+
+using NodeList = google::protobuf::RepeatedPtrField<NodeProto>;
+
+struct InlinerImpl {
+  ModelProto& model;
+  const FunctionIdSet& to_inline;
+  const FunctionMap* function_map;
+  const ISchemaRegistry* schema_registry = nullptr;
+  NameGenerator name_generator;
+  int inline_count = 0;
+
+  // Construct inliner for inlining call-sites inside main graph of a model.
+  InlinerImpl(
+      ModelProto& model_,
+      const FunctionIdSet& to_inline_,
+      const FunctionMap* function_map_,
+      const ISchemaRegistry* schema_registry_)
+      : model(model_),
+        to_inline(to_inline_),
+        function_map(function_map_),
+        schema_registry(schema_registry_),
+        name_generator(model_.graph()) {}
+
+  ~InlinerImpl() = default;
+
+  bool GetCallee(const NodeProto& node, FunctionProto& callee, int64_t& target_version) {
+    const std::string& domain = node.domain();
+    const std::string& function_name = node.op_type();
+    if (!to_inline.Contains(domain, function_name)) {
+      return false;
+    }
+
+    if (function_map != nullptr) {
+      if (auto iter = this->function_map->find(GetCalleeId(node)); iter != this->function_map->end()) {
+        const auto& [func_ptr, version] = iter->second;
+        callee = *func_ptr;
+        target_version = version;
+        return true;
+      }
+    }
+    if (schema_registry != nullptr) {
+      int64_t domain_version = GetDomainVersion(model, domain);
+      const auto* const op_schema = schema_registry->GetSchema(node.op_type(), domain_version, domain);
+
+      if (op_schema == nullptr) {
+        // If the schema is not found, we cannot inline the function.
+        return false;
+      }
+
+      if (op_schema->HasFunction()) {
+        const FunctionProto* function_ptr = op_schema->GetFunction(domain_version, false);
+        if (function_ptr != nullptr) {
+          callee = *function_ptr;
+          target_version = kNoConversion;
+          return true;
+        }
+      }
+
+      // Check if this node has a schema defined function proto.
+      if (op_schema->HasContextDependentFunction()) {
+        shape_inference::InferShapes(model); // TODO(ONNX): do shape inference incrementally
+        std::vector<TypeProto> input_types;
+        for (const auto& input : node.input()) {
+          input_types.emplace_back(GetType(model, input));
+        }
+        ONNX_NAMESPACE::FunctionBodyBuildContextImpl function_body_ctx(node, input_types);
+        target_version = kNoConversion;
+        return op_schema->BuildContextDependentFunction(function_body_ctx, callee, domain_version);
+      }
+    }
+    return false;
+  }
+
+  /** Shared utility function used for inlining into either a GraphProto or a FunctionProto.
+   * @param nodes Mutable list of nodes (of function or graph)
+   * @param value_infos Mutable list of value_infos (of function or graph)
+   */
+  void Process(NodeList& nodes, ValueInfoList& value_infos) {
+    NodeList original_nodes;
+    // Move all nodes into original_nodes
+    original_nodes.Swap(&nodes);
+
+    std::function<void(NodeProto & node)> append_node = [&](NodeProto& node) {
+      FunctionProto callee;
+      int64_t target_version = kNoConversion;
+      if (GetCallee(node, callee, target_version)) {
+        // Bind attribute parameters
+        internal::AttributeBinder::BindAttributes(node, callee);
+
+        // Rename variable names in callee
+        InliningRenamer::Rename(node, callee, "__" + std::to_string(++(this->inline_count)), this->name_generator);
+        if (target_version != kNoConversion) {
+          ConvertVersion(model, node, callee, target_version);
+        }
+        std::unordered_set<std::string> actual_parameters;
+        for (const auto& x : node.input())
+          actual_parameters.insert(x);
+        for (const auto& x : node.output())
+          actual_parameters.insert(x);
+        // Append valueinfos of called function
+        for (const auto& callee_vi : callee.value_info()) {
+          if (actual_parameters.count(callee_vi.name()) == 0) {
+            *value_infos.Add() = callee_vi;
+          }
+        }
+        // Append nodes of called function
+        for (auto& callee_node : *callee.mutable_node())
+          append_node(callee_node);
+      } else {
+        // Append node without inlining.
+        for (auto& attr : *node.mutable_attribute()) {
+          if (attr.has_g()) {
+            ProcessGraph(*attr.mutable_g());
+          }
+          for (auto& g : *attr.mutable_graphs()) {
+            ProcessGraph(g);
+          }
+        }
+
+        *nodes.Add() = std::move(node);
+      }
+    };
+    for (auto& node : original_nodes) {
+      append_node(node);
+    }
+  }
+
+  /** Utility function used for inlining into a GraphProto.
+   * @param graph Mutable graph
+   */
+  void ProcessGraph(GraphProto& graph) {
+    auto* nodes = graph.mutable_node();
+    auto* value_infos = graph.mutable_value_info();
+    Process(*nodes, *value_infos);
+  }
+
+  /** Utility function used for inlining into a FunctionProto.
+   * @param function Mutable function
+   */
+  void ProcessFunction(FunctionProto& function) {
+    auto* nodes = function.mutable_node();
+    auto* value_infos = function.mutable_value_info();
+    Process(*nodes, *value_infos);
+  }
+
+  // Erase every model-local function whose id appears in `inlined`.
+  static void RemoveInlinedFunctions(ModelProto& model, const FunctionMap& inlined) {
+    auto* local_functions = model.mutable_functions();
+    for (auto it = local_functions->begin(); it != local_functions->end();) {
+      if (inlined.count(GetFunctionImplId(*it)) > 0)
+        it = local_functions->erase(it);
+      else
+        ++it;
+    }
+  }
+
+  static void InlineLocalFunctions(ModelProto& model, bool convert_version) {
+    checker::check_function_call_cycles(model);
+    FunctionIdVector empty_set;
+    VectorSet all_functions(std::move(empty_set), true);
+    OpsetMap model_imports(model);
+    FunctionMap map;
+
+    // For every function, we check if there is a mismatch between the opset versions
+    // required for the function and the model. If there is no mismatch, we can inline
+    // this function. If there is a mismatch only for the standard ONNX domain, we
+    // can inline after version-conversion (if the version-conversion is successful).
+    // Otherwise, we cannot inline, since currently version-conversion supports only
+    // standard ONNX domain.
+
+    for (const auto& function : model.functions()) {
+      auto mismatches = model_imports.Mismatches(function);
+      auto iter = mismatches.find(ONNX_DOMAIN);
+      int64_t target_onnx_version = kNoConversion;
+      if (convert_version && (iter != mismatches.end())) {
+        target_onnx_version = iter->second;
+        mismatches.erase(iter);
+      }
+      if (mismatches.empty()) {
+        map[GetFunctionImplId(function)] = std::pair<const FunctionProto*, int64_t>(&function, target_onnx_version);
+      }
+    }
+
+    InlinerImpl inliner(model, all_functions, &map, nullptr);
+    inliner.ProcessGraph(*model.mutable_graph());
+
+    // Remove the model-local functions we inlined. Functions with a mismatched opset
+    // version are not in `map`, so they are left for other handling (eg. a version-adapter).
+    RemoveInlinedFunctions(model, map);
+  }
+
+  static void
+  InlineSelectedFunctions(ModelProto& model, const FunctionIdSet& to_inline, const ISchemaRegistry* schema_registry) {
+    checker::check_function_call_cycles(model);
+    OpsetMap model_imports(model);
+    FunctionMap map;
+    std::vector<FunctionProto*> non_inlined_functions;
+
+    // If there is any mismatch between the opset versions required for any of the
+    // functions and the model, the inliner will fail.
+
+    for (auto& function : *model.mutable_functions()) {
+      if (!model_imports.Add(function))
+        ONNX_THROW("Model has functions with incompatible opset versions.");
+      if (to_inline.Contains(function.domain(), function.name())) {
+        map[GetFunctionImplId(function)] = std::pair<const FunctionProto*, int64_t>(&function, kNoConversion);
+      } else {
+        non_inlined_functions.push_back(&function);
+      }
+    }
+
+    InlinerImpl inliner(model, to_inline, &map, schema_registry);
+    inliner.ProcessGraph(*model.mutable_graph());
+
+    for (auto* function_ptr : non_inlined_functions) {
+      inliner.ProcessFunction(*function_ptr);
+    }
+
+    // Remove all inlined model-local functions.
+    RemoveInlinedFunctions(model, map);
+  }
+
+  static void InlineSelectedLocalFunctions(ModelProto& model, const FunctionIdSet& to_inline) {
+    InlineSelectedFunctions(model, to_inline, nullptr);
+  }
+};
+
+} // namespace
+
+// Public API implementation:
+
+std::unique_ptr<FunctionIdSet> ONNX_NAMESPACE::inliner::FunctionIdSet::Create(
+    FunctionIdVector&& function_ids,
+    bool invert) {
+  return std::make_unique<VectorSet>(std::move(function_ids), invert);
+}
+
+void InlineLocalFunctions(ModelProto& model, bool convert_version) {
+  InlinerImpl::InlineLocalFunctions(model, convert_version);
+}
+
+void InlineSelectedLocalFunctions(ModelProto& model, const FunctionIdSet& to_inline) {
+  InlinerImpl::InlineSelectedLocalFunctions(model, to_inline);
+}
+
+void InlineSelectedFunctions(ModelProto& model, const FunctionIdSet& to_inline) {
+  InlineSelectedLocalFunctions(model, to_inline);
+}
+
+void InlineSelectedFunctions(
+    ModelProto& model,
+    const FunctionIdSet& to_inline,
+    const ISchemaRegistry* schema_registry) {
+  if (schema_registry == nullptr) {
+    schema_registry = OpSchemaRegistry::Instance();
+  }
+  InlinerImpl::InlineSelectedFunctions(model, to_inline, schema_registry);
+}
+
+// Implementation of the Renamer class using InliningRenamer directly
+class Renamer::Impl {
+ private:
+  NameGenerator generator_;
+  InliningRenamer renamer_;
+
+ public:
+  Impl(const std::string& prefix, const GraphProto& graph) : generator_(graph), renamer_("__" + prefix, generator_) {}
+
+  Impl(const std::string& prefix, const FunctionProto& function)
+      : generator_(function), renamer_("__" + prefix, generator_) {}
+
+  InliningRenamer& GetRenamer() {
+    return renamer_;
+  }
+
+  void BindName(const std::string& formal_name, const std::string& actual_name) {
+    renamer_.BindFormalToActual(formal_name, actual_name);
+  }
+
+  void RenameNode(NodeProto& node) {
+    // Use the InliningRenamer's ProcessNode method which handles graph-value attributes
+    renamer_.ProcessNode(node);
+  }
+};
+
+Renamer::Renamer(const std::string& prefix, const GraphProto& graph) : pImpl_(std::make_unique<Impl>(prefix, graph)) {}
+
+Renamer::Renamer(const std::string& prefix, const FunctionProto& function)
+    : pImpl_(std::make_unique<Impl>(prefix, function)) {}
+
+Renamer::~Renamer() = default;
+
+void Renamer::BindName(const std::string& formal_name, const std::string& actual_name) {
+  pImpl_->BindName(formal_name, actual_name);
+}
+
+void Renamer::RenameNode(NodeProto& node) {
+  pImpl_->RenameNode(node);
+}
+
+std::string Renamer::BindToUniqueName(const std::string& original_name) {
+  return pImpl_->GetRenamer().BindToUniqueName(original_name);
+}
+
+} // namespace inliner
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/inliner/inliner.h b/onnx/inliner/inliner.h
new file mode 100644
index 0000000..c883309
--- /dev/null
+++ b/onnx/inliner/inliner.h
@@ -0,0 +1,148 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ONNX_INLINER_INLINER_H_
+#define ONNX_INLINER_INLINER_H_
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/defs/schema.h"
+#include "onnx/onnx_pb.h"
+
+namespace ONNX_NAMESPACE {
+namespace inliner {
+
+// IR version 10 introduces overloaded function names. The following APIs to specify
+// functions to be inlined currently allow only specifying (domain, name). Thus,
+// either all overloads of a function are inlined or none.
+// The older-style ids are used below for backward compatibility.
+
+// A FunctionId is a pair of strings (domain, function name).
+using FunctionId = std::pair<std::string, std::string>;
+
+// A vector of FunctionIds.
+using FunctionIdVector = std::vector<FunctionId>;
+
+// Interface used to represent a set of function ids for the inliner.
+class FunctionIdSet {
+ public:
+  virtual bool Contains(const std::string& function_domain, const std::string& function_name) const = 0;
+  virtual ~FunctionIdSet() = default;
+
+  // Factory methods for creating FunctionIdSet instances.
+
+  // Creates a set representing the elements in the given vector, if invert is false.
+  // Otherwise, creates a set representing elements not in the given vector.
+  static std::unique_ptr<FunctionIdSet> Create(FunctionIdVector&& function_ids, bool invert = false);
+};
+
+/**
+ * @brief Inlines the schema-defined functions in the given model that are in the given set.
+ * @param model The model in which functions will be inlined.
+ * @param to_inline The set of functions to inline.
+ * @param schema_registry The schema registry used for function lookup. If nullptr,
+ *        the default schema registry is used.
+ * @note Only call-sites in the main graph are inlined.
+ */
+void InlineSelectedFunctions(ModelProto& model, const FunctionIdSet& to_inline, const ISchemaRegistry* schema_registry);
+
+/**
+ * @brief Inlines the model-local functions in the given model that are in the given set.
+ *
+ * This function processes the model and replaces all call-sites of the specified
+ * model-local functions with their inlined implementations. The inlined functions
+ * are also removed from the model's list of functions.
+ *
+ * @param model The model in which functions will be inlined.
+ * @param to_inline The set of functions to inline.
+ *
+ * @note This function does not perform schema-defined function inlining. For schema-defined
+ *       function inlining, use InlineSelectedFunctions instead.
+ */
+void InlineSelectedLocalFunctions(ModelProto& model, const FunctionIdSet& to_inline);
+
+/**
+ * @brief Inlines the model-local functions in the given model that are in the given set.
+ * @deprecated This function is deprecated. Use InlineSelectedLocalFunctions instead,
+ * to avoid confusion with the overloaded version of InlineSelectedFunctions that
+ * inlines schema-defined functions as well.
+ */
+void InlineSelectedFunctions(ModelProto& model, const FunctionIdSet& to_inline);
+
+// Inlines all model-local functions in the given model. This supports version
+// conversion, an advanced feature that is not enabled by default. When enabled,
+// the inliner will attempt to convert the version of the inlined function to
+// match the version of the model. If not enabled, the inliner will only inline
+// functions that use opset versions that are compatible with the model.
+void InlineLocalFunctions(ModelProto& model, bool convert_version = false);
+
+/**
+ * @brief A utility class for renaming variables during graph inlining operations.
+ *
+ * This class provides a simplified interface to the InliningRenamer functionality,
+ * allowing users to bind formal parameter names to actual parameter names and
+ * rename nodes with unique prefixes.
+ */
+class Renamer {
+ public:
+  /**
+   * @brief Constructs a Renamer with the given prefix.
+   *
+   * @param prefix The prefix to add to intermediate variable names to ensure uniqueness.
+   * @param graph The graph context for name generation.
+   */
+  explicit Renamer(const std::string& prefix, const GraphProto& graph);
+
+  /**
+   * @brief Constructs a Renamer with the given prefix.
+   *
+   * @param prefix The prefix to add to intermediate variable names to ensure uniqueness.
+   * @param function The function context for name generation.
+   */
+  explicit Renamer(const std::string& prefix, const FunctionProto& function);
+
+  /**
+   * @brief Destructor.
+   */
+  ~Renamer();
+
+  /**
+   * @brief Binds a formal parameter name to an actual parameter name.
+   *
+   * @param formal_name The formal parameter name in the source graph.
+   * @param actual_name The actual parameter name to use in the target.
+   */
+  void BindName(const std::string& formal_name, const std::string& actual_name);
+
+  /**
+   * @brief Creates a unique name for the given name and binds it.
+   *
+   * This method creates a unique name based on the prefix and binds the original
+   * name to the unique name for later reference renaming.
+   *
+   * @param original_name The name to create a unique version of.
+   * @return The unique name that was created and bound.
+   */
+  std::string BindToUniqueName(const std::string& original_name);
+
+  /**
+   * @brief Renames all variables in the given node according to the current bindings.
+   *
+   * @param node The node to rename. Input and output names will be updated in place.
+   */
+  void RenameNode(NodeProto& node);
+
+ private:
+  // Pimpl pattern to hide internal implementation details
+  class Impl;
+  std::unique_ptr<Impl> pImpl_;
+};
+
+} // namespace inliner
+} // namespace ONNX_NAMESPACE
+
+#endif // ONNX_INLINER_INLINER_H_
diff --git a/onnx/model_container.py b/onnx/model_container.py
new file mode 100644
index 0000000..173a5b8
--- /dev/null
+++ b/onnx/model_container.py
@@ -0,0 +1,346 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Implements function make_large_model to easily create and save models
+bigger than 2 Gb.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+import onnx
+import onnx.external_data_helper as ext_data
+import onnx.helper
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+
+def _set_external_data(
+    tensor: onnx.TensorProto,
+    location: str,
+    offset: int | None = None,
+    length: int | None = None,
+    checksum: str | None = None,
+    basepath: str | None = None,
+) -> None:
+    del tensor.external_data[:]
+    tensor.data_location = onnx.TensorProto.EXTERNAL
+    for k, v in {
+        "location": location,
+        "offset": offset,
+        "length": length,
+        "checksum": checksum,
+        "basepath": basepath,
+    }.items():
+        if v is not None:
+            entry = tensor.external_data.add()
+            entry.key = k
+            entry.value = str(v)
+
+
+def _enumerate_subgraphs(graph):
+    for node in graph.node:
+        for att in node.attribute:
+            if att.HasField("g"):
+                yield att.g
+                yield from _enumerate_subgraphs(att.g)
+            for sub_g in att.graphs:
+                yield sub_g
+                yield from _enumerate_subgraphs(sub_g)
+
+
+def make_large_tensor_proto(
+    location: str, tensor_name: str, tensor_type: int, shape: tuple[int, ...]
+) -> onnx.TensorProto:
+    """Create an external tensor.
+
+    Arguments:
+        location: unique identifier (not necessary a path)
+        tensor_name: tensor name in the graph
+        tensor_type: onnx type
+        shape: shape the of the initializer
+
+    Returns:
+        the created tensor
+    """
+    tensor_location = location
+    tensor = onnx.TensorProto()
+    tensor.name = tensor_name
+    _set_external_data(tensor, tensor_location)
+    tensor.data_type = tensor_type
+    tensor.dims.extend(shape)
+    return tensor
+
+
+class ModelContainer:
+    """Implements an API to store large tensors outside the main ModelProto,
+    it avoids copying large initializers when defining the model and these initializers
+    are never serialized through protobuf.
+    No tensor is stored on disk until the user explicitly saves the model.
+    """
+
+    def __init__(self) -> None:
+        self.model_proto_: onnx.ModelProto | None = None
+        self.large_initializers: dict[str, np.ndarray] = {}
+
+    def check_model(self):
+        if self.model_proto is not None:
+            onnx.checker.check_model(self.model_proto)
+
+    def __getitem__(self, name: str) -> np.ndarray:
+        """Returns an external tensor given its name."""
+        if name not in self.large_initializers:
+            raise ValueError(
+                f"Unable to find large tensor {name!r} among {sorted(self.large_initializers)}."
+            )
+        return self.large_initializers[name]
+
+    @property
+    def model_proto(self) -> onnx.ModelProto:
+        if self.model_proto_ is None:
+            raise RuntimeError("ModelContainer is empty.")
+        return self.model_proto_
+
+    @model_proto.setter
+    def model_proto(self, model_proto: onnx.ModelProto):
+        self.model_proto_ = model_proto
+        self.graphs_ = list(self.enumerate_graph_protos())
+
+    def enumerate_graph_protos(self) -> Iterable[onnx.GraphProto]:
+        """Enumerates all GraphProtos in a model."""
+        yield self.model_proto.graph
+        yield from _enumerate_subgraphs(self.model_proto.graph)
+
+    def is_in_memory_external_initializer(self, name: str) -> bool:
+        """Tells if an initializer name is an external initializer stored in memory.
+        The name must start with '#' in that case.
+        """
+        return name.startswith("#")
+
+    def set_large_initializers(self, large_initializers: dict[str, np.ndarray]):
+        """Adds all large tensors (not stored in the model)."""
+        for k in large_initializers:
+            if not self.is_in_memory_external_initializer(k):
+                raise ValueError(
+                    f"The location {k!r} must start with '#' to be ignored by check model."
+                )
+        self.large_initializers = large_initializers
+
+    def check_large_initializers(self) -> None:
+        for tensor in ext_data._get_all_tensors(self.model_proto):
+            if not ext_data.uses_external_data(tensor):
+                continue
+            prop: onnx.StringStringEntryProto | None = None
+            for ext in tensor.external_data:
+                if ext.key == "location":
+                    prop = ext
+            if prop is None:
+                raise RuntimeError(
+                    f"No location found for tensor name {tensor.name!r}."
+                )
+            if prop.value not in self.large_initializers:
+                raise RuntimeError(
+                    f"Unable to find large tensor named {tensor.name!r} "
+                    f"with location {prop.value!r} in "
+                    f"{sorted(self.large_initializers)}."
+                )
+
+    def _save_external(
+        self, file_path: str, all_tensors_to_one_file: bool
+    ) -> onnx.ModelProto:
+        """Save the large model into a main onnx file and one file
+        per tensor. Follows the same format as :func:`write_external_data_tensors
+        <onnx.external_data_helper.write_external_data_tensors>`.
+        The main model needs to be modified to update the file location,
+        the function returns this modified copy.
+
+        Arguments:
+            file_path: model file
+            all_tensors_to_one_file: all tensors in one file
+
+        Returns:
+            modified main model proto
+        """
+
+        def _clean_name(prefix: str, name: str, unique_names: dict[str, int]) -> str:
+            if prefix:
+                name = f"{prefix}-{name}"
+            for c in ":/\\;,!":
+                name = name.replace(c, "")
+            base_name = name
+            if name in unique_names:
+                i = unique_names[name] + 1
+                unique_names[name] = i
+                return f"{base_name}_{i}"
+            unique_names[name] = 1
+            return name
+
+        unique_names: dict[str, int] = {}
+        folder = os.path.dirname(file_path)
+        if not os.path.exists(folder):
+            raise FileNotFoundError(f"Folder {folder!r} does not exist.")
+        proto = self.model_proto.SerializeToString()
+        copy = onnx.ModelProto()
+        copy.ParseFromString(proto)
+        prefix = os.path.splitext(os.path.split(file_path)[-1])[0]
+
+        if all_tensors_to_one_file:
+            file_weight = f"{os.path.split(file_path)[1]}.weight"
+            full_file_weight = f"{file_path}.weight"
+            offset = 0
+            with open(full_file_weight, "wb") as f:
+                pass
+
+        for tensor in ext_data._get_all_tensors(copy):
+            if not ext_data.uses_external_data(tensor):
+                continue
+            prop: onnx.StringStringEntryProto | None = None
+            for ext in tensor.external_data:
+                if ext.key == "location":
+                    prop = ext
+            if prop is None:
+                raise RuntimeError(
+                    f"No location found for tensor name {tensor.name!r}."
+                )
+            if prop.value not in self.large_initializers:
+                raise RuntimeError(
+                    f"Unable to find large tensor named {tensor.name!r} "
+                    f"with location {prop.value!r} in "
+                    f"{sorted(self.large_initializers)}."
+                )
+            np_tensor = self.large_initializers[prop.value]
+
+            tensor_bytes = onnx.numpy_helper.tobytes_little_endian(np_tensor)
+
+            if all_tensors_to_one_file:
+                _set_external_data(
+                    tensor,
+                    location=file_weight,
+                    offset=offset,
+                    length=len(tensor_bytes),
+                )
+                offset += len(tensor_bytes)
+                with open(full_file_weight, "ab") as f:
+                    f.write(tensor_bytes)
+            else:
+                name = f"{_clean_name(prefix, prop.value, unique_names)}.weight"
+                _set_external_data(tensor, location=name)
+                full_name = os.path.join(folder, name)
+                prop.value = name
+                with open(full_name, "wb") as f:
+                    f.write(tensor_bytes)
+
+        with open(file_path, "wb") as f:
+            f.write(copy.SerializeToString())
+        return copy
+
+    def save(
+        self,
+        file_path: str,
+        all_tensors_to_one_file: bool = False,
+    ) -> onnx.ModelProto:
+        """Save the large model.
+        The function returns a ModelProto,
+        the current one if the model did not need any modification,
+        a modified copy of it if it required changes such as giving file names
+        to every external tensor.
+
+        Arguments:
+            file_path: model file
+            all_tensors_to_one_file: saves all large tensors in one file or
+                one file per lerge tensor
+
+        Returns:
+            the saved ModelProto
+        """
+        return self._save_external(
+            file_path, all_tensors_to_one_file=all_tensors_to_one_file
+        )
+
+    def load(self, file_path: str, load_large_initializers: bool = True):
+        """Load the large model.
+
+        Arguments:
+            file_path: model file
+            load_large_initializers: loads the large initializers,
+                if not done, the model is incomplete but it can be used to
+                look into the model without executing it and method
+                :meth:`_load_large_initializers` can be used to load them later
+        """
+        self.model_proto_ = onnx.load_model(file_path, load_external_data=False)
+        if load_large_initializers:
+            self._load_large_initializers(file_path)
+
+    def _load_large_initializers(self, file_path):
+        """Loads large initializers.
+
+        Arguments:
+            file_path: model file, the weight are expected to be in the same folder as this file
+        """
+        if self.model_proto_ is None:
+            raise RuntimeError("A model must be loaded before loading the weights.")
+        self.large_initializers = {}
+        base_dir = os.path.dirname(file_path)
+        for i, tensor in enumerate(ext_data._get_all_tensors(self.model_proto_)):
+            if not ext_data.uses_external_data(tensor):
+                continue
+
+            info = ext_data.ExternalDataInfo(tensor)
+            key = f"#t{i}"
+            _set_external_data(tensor, location=key)
+
+            fd = ext_data._open_external_data_fd(
+                base_dir, info.location, tensor.name, True
+            )
+            with os.fdopen(fd, "rb") as data_file:
+                raw_data = ext_data._validate_external_data_file_bounds(
+                    data_file, info, tensor.name
+                )
+
+                dtype = onnx.helper.tensor_dtype_to_np_dtype(tensor.data_type)
+                shape = tuple(tensor.dims)
+
+                if sys.byteorder == "big":
+                    np_tensor = (
+                        np.frombuffer(raw_data, dtype=dtype).byteswap().reshape(shape)
+                    )
+                else:
+                    np_tensor = np.frombuffer(raw_data, dtype=dtype).reshape(shape)
+
+                self.large_initializers[key] = np_tensor
+
+
+def make_large_model(
+    graph: onnx.GraphProto,
+    large_initializers: dict[str, np.ndarray] | None = None,
+    **kwargs: Any,
+) -> ModelContainer:
+    """Construct a ModelContainer
+
+    C API and Python API of protobuf do not operate without serializing
+    the protos. This function uses the Python API of ModelContainer.
+
+    Arguments:
+        graph: *make_graph* returns
+        large_initializers: dictionary `name: large tensor`,
+            large tensor is any python object supporting the DLPack protocol,
+            the ownership the tensor is transferred to the ModelContainer,
+            the tensor must define method `tobytes` like numpy tensors
+        **kwargs: any attribute to add to the returned instance
+
+    Returns:
+        ModelContainer
+    """
+    model = onnx.helper.make_model(graph, **kwargs)
+    large_model = ModelContainer()
+    large_model.model_proto = model
+    if large_initializers:
+        large_model.set_large_initializers(large_initializers)
+        large_model.check_large_initializers()
+    return large_model
diff --git a/onnx/numpy_helper.py b/onnx/numpy_helper.py
new file mode 100644
index 0000000..74aea0c
--- /dev/null
+++ b/onnx/numpy_helper.py
@@ -0,0 +1,662 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import math
+import sys
+from typing import TYPE_CHECKING, Any
+
+import ml_dtypes
+import numpy as np
+import numpy.typing as npt
+
+import onnx.external_data_helper
+from onnx import helper
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def to_float8e8m0(
+    x: np.ndarray,
+    saturate: bool = True,
+    round_mode: str = "up",
+) -> np.ndarray:
+    """Convert float32 NumPy array to float8e8m0 representation. If the input
+    is not a float32 array, it will be cast to one first.
+
+    Args:
+        x: Input array to convert.
+        saturate: Whether to saturate at max/min float8e8m0 value.
+        round_mode: "nearest", "up", or "down".
+
+    Returns:
+        np.ndarray: Array of ml_dtypes.float8_e8m0fnu values.
+    """
+    x_f32 = np.asarray(x, dtype=np.float32)
+    f_bits = x_f32.view(np.uint32)
+
+    # Extract exponent bits
+    exponent = (f_bits >> 23) & 0xFF
+    exponent = exponent.astype(
+        np.uint16
+    )  # use uint16 to prevent overflow during computation
+
+    # Identify NaN or Inf
+    special_mask = exponent == 0xFF  # noqa: PLR2004
+    output = np.zeros_like(exponent, dtype=np.uint8)
+    output[special_mask] = 0xFF  # Preserve NaN/Inf as max exponent
+
+    # Process normal numbers
+    normal_mask = ~special_mask
+
+    if round_mode == "nearest":
+        # Get guard, round, sticky, and least significant bits
+        g = ((f_bits & 0x400000) > 0).astype(np.uint8)
+        r = ((f_bits & 0x200000) > 0).astype(np.uint8)
+        s = ((f_bits & 0x1FFFFF) > 0).astype(np.uint8)
+        lsb = (exponent > 0).astype(np.uint8)
+
+        round_up = (g == 1) & ((r == 1) | (s == 1) | (lsb == 1))
+
+        increment = np.zeros_like(exponent)
+        increment[round_up & normal_mask] = 1
+
+        if saturate:
+            max_mask = (exponent == 0xFE) & round_up & normal_mask  # noqa: PLR2004
+            increment[max_mask] = 0  # Don't overflow past max value
+
+        exponent += increment
+
+    elif round_mode == "up":
+        has_fraction = (f_bits & 0x7FFFFF) > 0
+        round_up = has_fraction & normal_mask
+
+        if saturate:
+            max_mask = (exponent == 0xFE) & round_up  # noqa: PLR2004
+            round_up[max_mask] = False
+
+        exponent += round_up.astype(np.uint16)
+
+    elif round_mode == "down":
+        pass  # No rounding needed
+
+    else:
+        raise ValueError(f"Unsupported rounding mode: {round_mode}")
+
+    # Clip exponent to uint8 range
+    exponent = exponent.astype(np.uint8)
+
+    output[normal_mask] = exponent[normal_mask]
+
+    return output.view(ml_dtypes.float8_e8m0fnu)
+
+
+def _unpack_4bit(
+    data: npt.NDArray[np.uint8], dims: Sequence[int]
+) -> npt.NDArray[np.uint8]:
+    """Convert a packed uint4 array to unpacked uint4 array represented as uint8.
+
+    Args:
+        data: A numpy array.
+        dims: The dimensions are used to reshape the unpacked buffer.
+
+    Returns:
+        A numpy array of int8/uint8 reshaped to dims.
+    """
+    result = np.empty([data.size * 2], dtype=data.dtype)
+    array_low = data & np.uint8(0x0F)
+    array_high = data & np.uint8(0xF0)
+    array_high >>= np.uint8(4)
+    result[0::2] = array_low
+    result[1::2] = array_high
+    expected_elements = math.prod(dims)
+    if result.size == expected_elements + 1:
+        # handle single-element padding due to odd number of elements
+        result = result[:-1]
+    if expected_elements > result.size:
+        raise ValueError(
+            f"Packed 4-bit data ({data.size} bytes, {result.size} elements unpacked) "
+            f"is too small for the declared shape {list(dims)} "
+            f"({expected_elements} elements required)."
+        )
+    result.resize(dims, refcheck=False)
+    return result
+
+
+def _pack_4bitx2(array: np.ndarray) -> npt.NDArray[np.uint8]:
+    """Convert a numpy array to flatten, packed int4/uint4. Elements must be in the correct range."""
+    # Create a 1D copy
+    array_flat = array.ravel().view(np.uint8).copy()
+    size = array.size
+    odd_sized = size % 2 == 1
+    if odd_sized:
+        array_flat.resize([size + 1], refcheck=False)
+    array_flat &= 0x0F
+    array_flat[1::2] <<= 4
+    return array_flat[0::2] | array_flat[1::2]
+
+
+def _unpack_2bit(
+    data: npt.NDArray[np.uint8], dims: Sequence[int]
+) -> npt.NDArray[np.uint8]:
+    """Convert a packed uint2 array to unpacked uint2 array represented as uint8.
+
+    Args:
+        data: A numpy array.
+        dims: The dimensions are used to reshape the unpacked buffer.
+
+    Returns:
+        A numpy array of int8/uint8 reshaped to dims.
+    """
+    result = np.empty([data.size * 4], dtype=data.dtype)
+    result[0::4] = data & 0x03
+    result[1::4] = (data >> 2) & 0x03
+    result[2::4] = (data >> 4) & 0x03
+    result[3::4] = (data >> 6) & 0x03
+    expected_elements = math.prod(dims)
+    if result.size > expected_elements:
+        # handle padding due to non multiple of 4 elements
+        result = result[:expected_elements]
+    if expected_elements > result.size:
+        raise ValueError(
+            f"Packed 2-bit data ({data.size} bytes, {result.size} elements unpacked) "
+            f"is too small for the declared shape {list(dims)} "
+            f"({expected_elements} elements required)."
+        )
+    result.resize(dims, refcheck=False)
+    return result
+
+
+def _pack_2bitx4(array: np.ndarray) -> npt.NDArray[np.uint8]:
+    """Convert a numpy array to flatten, packed int2/uint2. Elements must be in the correct range."""
+    # Create a 1D copy
+    array_flat = array.ravel().view(np.uint8).copy()
+    size = array.size
+    pad_len = size % 4
+    if pad_len:
+        array_flat.resize([size + (4 - pad_len)], refcheck=False)
+    array_flat &= 0x03
+    array_flat[1::4] <<= 2
+    array_flat[2::4] <<= 4
+    array_flat[3::4] <<= 6
+    return array_flat[0::4] | array_flat[1::4] | array_flat[2::4] | array_flat[3::4]
+
+
+def to_array(tensor: onnx.TensorProto, base_dir: str = "") -> np.ndarray:  # noqa: PLR0911
+    """Converts a tensor def object to a numpy array.
+
+    This function uses ml_dtypes if the dtype is not a native numpy dtype.
+
+    Args:
+        tensor: a TensorProto object.
+        base_dir: if external tensor exists, base_dir can help to find the path to it
+
+    Returns:
+        arr: the converted array.
+    """
+    if tensor.HasField("segment"):
+        raise ValueError("Currently not supporting loading segments.")
+    if tensor.data_type == onnx.TensorProto.UNDEFINED:
+        raise TypeError("The element type in the input tensor is UNDEFINED.")
+
+    tensor_dtype = tensor.data_type
+    np_dtype = helper.tensor_dtype_to_np_dtype(tensor_dtype)
+    storage_np_dtype = helper.tensor_dtype_to_np_dtype(
+        helper.tensor_dtype_to_storage_tensor_dtype(tensor_dtype)
+    )
+    storage_field = helper.tensor_dtype_to_field(tensor_dtype)
+    dims = tensor.dims
+
+    if tensor.data_type == onnx.TensorProto.STRING:
+        utf8_strings = getattr(tensor, storage_field)
+        ss = [s.decode("utf-8") for s in utf8_strings]
+        return np.asarray(ss).astype(np_dtype).reshape(dims)
+
+    # Load raw data from external tensor if it exists
+    if onnx.external_data_helper.uses_external_data(tensor):
+        onnx.external_data_helper.load_external_data_for_tensor(tensor, base_dir)
+
+    if tensor.HasField("raw_data"):
+        # Raw_bytes support: using frombuffer.
+        raw_data = tensor.raw_data
+        if sys.byteorder == "big":
+            # Convert endian from little to big
+            raw_data = np.frombuffer(raw_data, dtype=np_dtype).byteswap().tobytes()
+
+        if tensor_dtype in {
+            onnx.TensorProto.INT4,
+            onnx.TensorProto.UINT4,
+            onnx.TensorProto.FLOAT4E2M1,
+        }:
+            data = np.frombuffer(raw_data, dtype=np.uint8)
+            return _unpack_4bit(data, dims).view(np_dtype)
+
+        if tensor_dtype in {
+            onnx.TensorProto.UINT2,
+            onnx.TensorProto.INT2,
+        }:
+            data = np.frombuffer(raw_data, dtype=np.uint8)
+            return _unpack_2bit(data, dims).view(np_dtype)
+
+        return np.frombuffer(raw_data, dtype=np_dtype).reshape(dims)
+
+    if tensor_dtype in {
+        onnx.TensorProto.BFLOAT16,
+        onnx.TensorProto.FLOAT16,
+        onnx.TensorProto.INT16,
+        onnx.TensorProto.UINT16,
+    }:
+        return (
+            np.array(tensor.int32_data, dtype=np.int32)
+            .view(np.uint32)
+            .astype(np.uint16)
+            .reshape(dims)
+            .view(np_dtype)
+        )
+
+    if tensor_dtype in {
+        onnx.TensorProto.FLOAT8E4M3FN,
+        onnx.TensorProto.FLOAT8E4M3FNUZ,
+        onnx.TensorProto.FLOAT8E5M2,
+        onnx.TensorProto.FLOAT8E5M2FNUZ,
+        onnx.TensorProto.FLOAT8E8M0,
+        onnx.TensorProto.BOOL,
+    }:
+        return (
+            np.array(tensor.int32_data, dtype=np.int32)
+            .view(np.uint32)
+            .astype(np.uint8)
+            .view(np_dtype)
+            .reshape(dims)
+        )
+
+    if tensor_dtype in {
+        onnx.TensorProto.UINT4,
+        onnx.TensorProto.INT4,
+        onnx.TensorProto.FLOAT4E2M1,
+    }:
+        data = (
+            np.array(tensor.int32_data, dtype=np.int32).view(np.uint32).astype(np.uint8)
+        )
+        return _unpack_4bit(data, dims).view(np_dtype)
+
+    if tensor_dtype in {
+        onnx.TensorProto.UINT2,
+        onnx.TensorProto.INT2,
+    }:
+        data = (
+            np.array(tensor.int32_data, dtype=np.int32).view(np.uint32).astype(np.uint8)
+        )
+        return _unpack_2bit(data, dims).view(np_dtype)
+
+    data = getattr(tensor, storage_field)
+    if tensor_dtype in (onnx.TensorProto.COMPLEX64, onnx.TensorProto.COMPLEX128):
+        return np.array(data, dtype=storage_np_dtype).view(dtype=np_dtype).reshape(dims)
+
+    return np.asarray(data, dtype=storage_np_dtype).astype(np_dtype).reshape(dims)
+
+
+def tobytes_little_endian(array: np.ndarray) -> bytes:
+    """Converts an array into bytes in little endian byte order.
+
+    Args:
+        array: a numpy array.
+
+    Returns:
+        bytes: Byte representation of passed array in little endian byte order.
+
+    .. versionadded:: 1.20
+    """
+    if array.dtype.byteorder == ">" or (
+        sys.byteorder == "big" and array.dtype.byteorder == "="
+    ):
+        # Ensure that the bytes will be in little-endian byte-order.
+        array = array.astype(array.dtype.newbyteorder("<"))
+
+    return array.tobytes()
+
+
+def from_array(array: np.ndarray, /, name: str | None = None) -> onnx.TensorProto:
+    """Converts an array into a TensorProto including
+
+    Args:
+        array: a numpy array.
+        name: (optional) the name of the tensor.
+
+    Returns:
+        TensorProto: the converted tensor def.
+    """
+    tensor = onnx.TensorProto()
+    tensor.dims.extend(array.shape)
+    if name:
+        tensor.name = name
+    if array.dtype == object or np.issubdtype(array.dtype, np.str_):
+        # Special care for strings.
+        tensor.data_type = onnx.TensorProto.STRING
+        # TODO: Introduce full string support.
+        # We flatten the array in case there are n-D arrays are specified
+        # If you want more complex shapes then follow the below instructions.
+        # Unlike other types where the shape is automatically inferred from
+        # nested arrays of values, the only reliable way now to feed strings
+        # is to put them into a flat array then specify type astype(object)
+        # (otherwise all strings may have different types depending on their length)
+        # and then specify shape .reshape([x, y, z])
+        flat_array = array.flatten()
+        for e in flat_array:
+            if isinstance(e, str):
+                tensor.string_data.append(e.encode("utf-8"))
+            elif isinstance(e, bytes):
+                tensor.string_data.append(e)
+            else:
+                raise NotImplementedError(
+                    f"Unrecognized object in the object array, expect a string, or array of bytes: {type(e)}"
+                )
+        return tensor
+
+    dtype = helper.np_dtype_to_tensor_dtype(array.dtype)
+    if dtype in {
+        onnx.TensorProto.INT4,
+        onnx.TensorProto.UINT4,
+        onnx.TensorProto.FLOAT4E2M1,
+    }:
+        # Pack the array into int4
+        array = _pack_4bitx2(array)
+
+    if dtype in {
+        onnx.TensorProto.UINT2,
+        onnx.TensorProto.INT2,
+    }:
+        # Pack the array into int2
+        array = _pack_2bitx4(array)
+
+    tensor.raw_data = tobytes_little_endian(array)
+    tensor.data_type = dtype  # type: ignore[assignment]
+    return tensor
+
+
+def to_list(sequence: onnx.SequenceProto) -> list[Any]:
+    """Converts a sequence def to a Python list.
+
+    Args:
+        sequence: a SequenceProto object.
+
+    Returns:
+        list: the converted list.
+    """
+    elem_type = sequence.elem_type
+    if elem_type == onnx.SequenceProto.TENSOR:
+        return [to_array(v) for v in sequence.tensor_values]
+    if elem_type == onnx.SequenceProto.SPARSE_TENSOR:
+        return [to_array(v) for v in sequence.sparse_tensor_values]  # type: ignore[arg-type]
+    if elem_type == onnx.SequenceProto.SEQUENCE:
+        return [to_list(v) for v in sequence.sequence_values]
+    if elem_type == onnx.SequenceProto.MAP:
+        return [to_dict(v) for v in sequence.map_values]
+    raise TypeError("The element type in the input sequence is not supported.")
+
+
+def from_list(
+    lst: list[Any], name: str | None = None, dtype: int | None = None
+) -> onnx.SequenceProto:
+    """Converts a list into a sequence def.
+
+    Args:
+        lst: a Python list
+        name: (optional) the name of the sequence.
+        dtype: (optional) type of element in the input list, used for specifying
+                          sequence values when converting an empty list.
+
+    Returns:
+        SequenceProto: the converted sequence def.
+    """
+    sequence = onnx.SequenceProto()
+    if name:
+        sequence.name = name
+
+    if dtype is not None:
+        elem_type = dtype
+    elif len(lst) > 0:
+        first_elem = lst[0]
+        if isinstance(first_elem, dict):
+            elem_type = onnx.SequenceProto.MAP
+        elif isinstance(first_elem, list):
+            elem_type = onnx.SequenceProto.SEQUENCE
+        else:
+            elem_type = onnx.SequenceProto.TENSOR
+    else:
+        # if empty input list and no dtype specified
+        # choose sequence of tensors on default
+        elem_type = onnx.SequenceProto.TENSOR
+    sequence.elem_type = elem_type
+
+    if (len(lst) > 0) and not all(isinstance(elem, type(lst[0])) for elem in lst):
+        raise TypeError(
+            "The element type in the input list is not the same "
+            "for all elements and therefore is not supported as a sequence."
+        )
+
+    if elem_type == onnx.SequenceProto.TENSOR:
+        for tensor in lst:
+            sequence.tensor_values.extend([from_array(np.asarray(tensor))])
+    elif elem_type == onnx.SequenceProto.SEQUENCE:
+        for seq in lst:
+            sequence.sequence_values.extend([from_list(seq)])
+    elif elem_type == onnx.SequenceProto.MAP:
+        for mapping in lst:
+            sequence.map_values.extend([from_dict(mapping)])
+    else:
+        raise TypeError(
+            "The element type in the input list is not a tensor, "
+            "sequence, or map and is not supported."
+        )
+    return sequence
+
+
+def to_dict(map_proto: onnx.MapProto) -> dict[Any, Any]:
+    """Converts a map def to a Python dictionary.
+
+    Args:
+        map_proto: a MapProto object.
+
+    Returns:
+        The converted dictionary.
+    """
+    key_list: list[Any] = []
+    if map_proto.key_type == onnx.TensorProto.STRING:
+        key_list = list(map_proto.string_keys)
+    else:
+        key_list = list(map_proto.keys)
+
+    value_list = to_list(map_proto.values)
+    if len(key_list) != len(value_list):
+        raise IndexError(
+            f"Length of keys and values for MapProto (map name: {map_proto.name}) are not the same."
+        )
+    return dict(zip(key_list, value_list, strict=False))
+
+
+def from_dict(dict_: dict[Any, Any], name: str | None = None) -> onnx.MapProto:
+    """Converts a Python dictionary into a map def.
+
+    Args:
+        dict_: Python dictionary
+        name: (optional) the name of the map.
+
+    Returns:
+        MapProto: the converted map def.
+    """
+    map_proto = onnx.MapProto()
+    if name:
+        map_proto.name = name
+    if not dict_:
+        raise ValueError("Cannot convert an empty dictionary to MapProto.")
+    keys = list(dict_)
+    raw_key_type = np.result_type(keys[0])
+    key_type = helper.np_dtype_to_tensor_dtype(raw_key_type)
+
+    valid_key_int_types = {
+        onnx.TensorProto.INT8,
+        onnx.TensorProto.INT16,
+        onnx.TensorProto.INT32,
+        onnx.TensorProto.INT64,
+        onnx.TensorProto.UINT8,
+        onnx.TensorProto.UINT16,
+        onnx.TensorProto.UINT32,
+        onnx.TensorProto.UINT64,
+    }
+
+    if not (all(np.result_type(key) == raw_key_type for key in keys)):
+        raise TypeError(
+            "The key type in the input dictionary is not the same "
+            "for all keys and therefore is not valid as a map."
+        )
+
+    values = list(dict_.values())
+    raw_value_type = np.result_type(values[0])
+    if not all(np.result_type(val) == raw_value_type for val in values):
+        raise TypeError(
+            "The value type in the input dictionary is not the same "
+            "for all values and therefore is not valid as a map."
+        )
+
+    value_seq = from_list(values)
+
+    map_proto.key_type = key_type  # type: ignore[assignment]
+    if key_type == onnx.TensorProto.STRING:
+        map_proto.string_keys.extend(keys)
+    elif key_type in valid_key_int_types:
+        map_proto.keys.extend(keys)
+    else:
+        raise TypeError(f"Unsupported map key type: {key_type}")
+    map_proto.values.CopyFrom(value_seq)
+    return map_proto
+
+
+def to_optional(optional: onnx.OptionalProto) -> Any | None:
+    """Converts an optional def to a Python optional.
+
+    Args:
+        optional: an OptionalProto object.
+
+    Returns:
+        opt: the converted optional.
+    """
+    elem_type = optional.elem_type
+    if elem_type == onnx.OptionalProto.UNDEFINED:
+        return None
+    if elem_type == onnx.OptionalProto.TENSOR:
+        return to_array(optional.tensor_value)
+    if elem_type == onnx.OptionalProto.SPARSE_TENSOR:
+        return to_array(optional.sparse_tensor_value)  # type: ignore[arg-type]
+    if elem_type == onnx.OptionalProto.SEQUENCE:
+        return to_list(optional.sequence_value)
+    if elem_type == onnx.OptionalProto.MAP:
+        return to_dict(optional.map_value)
+    if elem_type == onnx.OptionalProto.OPTIONAL:
+        return to_optional(optional.optional_value)
+    raise TypeError("The element type in the input optional is not supported.")
+
+
+def from_optional(
+    opt: Any | None, name: str | None = None, dtype: int | None = None
+) -> onnx.OptionalProto:
+    """Converts an optional value into a Optional def.
+
+    Args:
+        opt: a Python optional
+        name: (optional) the name of the optional.
+        dtype: (optional) type of element in the input, used for specifying
+                          optional values when converting empty none. dtype must
+                          be a valid OptionalProto.DataType value
+
+    Returns:
+        optional: the converted optional def.
+    """
+    # TODO: create a map and replace conditional branches
+    optional = onnx.OptionalProto()
+    if name:
+        optional.name = name
+
+    if dtype is not None:
+        # dtype must be a valid onnx.OptionalProto.DataType
+        if dtype not in onnx.OptionalProto.DataType.values():
+            raise TypeError(f"{dtype} must be a valid OptionalProto.DataType.")
+        elem_type = dtype
+    elif isinstance(opt, dict):
+        elem_type = onnx.OptionalProto.MAP
+    elif isinstance(opt, list):
+        elem_type = onnx.OptionalProto.SEQUENCE
+    elif opt is None:
+        elem_type = onnx.OptionalProto.UNDEFINED
+    else:
+        elem_type = onnx.OptionalProto.TENSOR
+
+    optional.elem_type = elem_type
+
+    if opt is not None:
+        if elem_type == onnx.OptionalProto.TENSOR:
+            optional.tensor_value.CopyFrom(from_array(opt))
+        elif elem_type == onnx.OptionalProto.SEQUENCE:
+            optional.sequence_value.CopyFrom(from_list(opt))
+        elif elem_type == onnx.OptionalProto.MAP:
+            optional.map_value.CopyFrom(from_dict(opt))
+        else:
+            raise TypeError(
+                "The element type in the input is not a tensor, "
+                "sequence, or map and is not supported."
+            )
+    return optional
+
+
+def create_random_int(
+    input_shape: tuple[int], dtype: np.dtype, seed: int = 1
+) -> np.ndarray:
+    """Create random integer array for backend/test/case/node.
+
+    Args:
+        input_shape: The shape for the returned integer array.
+        dtype: The NumPy data type for the returned integer array.
+        seed: The seed for np.random.
+
+    Returns:
+        np.ndarray: Random integer array.
+    """
+    np.random.seed(seed)
+    if dtype in (
+        np.uint8,
+        np.uint16,
+        np.uint32,
+        np.uint64,
+        np.int8,
+        np.int16,
+        np.int32,
+        np.int64,
+    ):
+        # the range of np.random.randint is int32; set a fixed boundary if overflow
+        end = min(np.iinfo(dtype).max, np.iinfo(np.int32).max)
+        start = max(np.iinfo(dtype).min, np.iinfo(np.int32).min)
+        return np.random.randint(start, end, size=input_shape).astype(dtype)
+    raise TypeError(f"{dtype} is not supported by create_random_int.")
+
+
+def saturate_cast(x: np.ndarray, dtype: np.dtype) -> np.ndarray:
+    """Saturate cast for numeric types.
+
+    This function ensures that values outside the representable range
+    of the target dtype are clamped to the maximum or minimum representable
+    value of that dtype.
+    """
+    if np.issubdtype(dtype, np.integer) or dtype in (
+        ml_dtypes.int4,
+        ml_dtypes.uint4,
+        ml_dtypes.int2,
+        ml_dtypes.uint2,
+    ):
+        info = ml_dtypes.iinfo(dtype)
+        x = np.round(x)
+    else:
+        info = ml_dtypes.finfo(dtype)  # type: ignore[assignment]
+
+    return np.clip(x, info.min, info.max).astype(dtype)  # type: ignore[no-any-return]
diff --git a/onnx/onnx-data.in.proto b/onnx/onnx-data.in.proto
new file mode 100644
index 0000000..7e247c8
--- /dev/null
+++ b/onnx/onnx-data.in.proto
@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: Apache-2.0
+
+
+syntax = "proto2";
+
+package {PACKAGE_NAME};
+// #if ONNX-ML
+import "onnx/onnx-ml.proto";
+// #else
+import "onnx/onnx.proto";
+// #endif
+
+// This file contains the proto definitions for MapProto and
+// SequenceProto. These protos are used to represent the data structures
+// of maps and sequence for use in test data or ModelProto.
+
+// Sequences
+//
+// Defines a dense, ordered, collection of elements that are of homogeneous types.
+// Sequences can be made out of tensors, maps, or sequences.
+//
+// If a sequence is made out of tensors, the tensors must have the same element
+// type (i.e. int32). In some cases, the tensors in a sequence can have different
+// shapes.  Whether the tensors can have different shapes or not depends on the
+// type/shape associated with the corresponding "ValueInfo". For example,
+// "Sequence<Tensor<float, [M,N]>" means that all tensors have same shape. However,
+// "Sequence<Tensor<float, [omitted,omitted]>" means they can have different
+// shapes (all of rank 2), where "omitted" means the corresponding dimension has
+// no symbolic/constant value. Finally, "Sequence<Tensor<float, omitted>>" means
+// that the different tensors can have different ranks, when the "shape" itself
+// is omitted from the tensor-type. For a more complete description, refer to
+// https://github.com/onnx/onnx/blob/main/docs/IR.md#static-tensor-shapes.
+//
+message SequenceProto {
+
+  optional string name = 1;
+
+  enum DataType {
+    UNDEFINED = 0;
+    TENSOR = 1;
+    SPARSE_TENSOR = 2;
+    SEQUENCE = 3;
+    MAP = 4;
+    OPTIONAL = 5;
+  }
+
+  // The data type of the element.
+  // This field MUST have a valid SequenceProto.DataType value
+  optional int32 elem_type = 2;
+
+  // For TensorProto values.
+  // When this field is present, the elem_type field MUST be TENSOR.
+  repeated TensorProto tensor_values = 3;
+
+  // For SparseTensorProto values.
+  // When this field is present, the elem_type field MUST be SPARSE_TENSOR.
+  repeated SparseTensorProto sparse_tensor_values = 4;
+
+  // For SequenceProto values, allowing sequences to be of themselves.
+  // When this field is present, the elem_type field MUST be SEQUENCE.
+  repeated SequenceProto sequence_values = 5;
+
+  // For MapProto values.
+  // When this field is present, the elem_type field MUST be MAP.
+  repeated MapProto map_values = 6;
+
+  // For OptionalProto values.
+  // When this field is present, the elem_type field MUST be Optional.
+  repeated OptionalProto optional_values = 7;
+
+}
+
+
+// Maps
+//
+// Specifies an associative table, defined by keys and values.
+// MapProto is formed with a repeated field of keys (of type INT8, INT16, INT32,
+// INT64, UINT8, UINT16, UINT32, UINT64, or STRING) and values (of type TENSOR,
+// SPARSE_TENSOR, SEQUENCE, or MAP). Key types and value types have to remain
+// the same throughout the instantiation of the MapProto.
+//
+message MapProto {
+
+  optional string name = 1;
+
+  // All MapProto data types must have the same length of keys and values.
+
+  // The data type of the key.
+  // This field MUST have a valid TensorProto.DataType value of
+  // INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64, or STRING
+  optional int32 key_type = 2;
+
+  // Every element of keys has to be one of the following data types
+  // INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64, or STRING.
+  // The integer cases are represented by the repeated int64 field keys below.
+  repeated int64 keys = 3;
+
+  // If keys are strings, they are represented by the repeated bytes field
+  // string_keys below.
+  repeated bytes string_keys = 4;
+
+  // MapProto values are represented in a SequenceProto of the same length as the
+  // repeated keys field and have to be one of the following data types
+  // TENSOR, SPARSE_TENSOR, MAP, SEQUENCE.
+  optional SequenceProto values = 5;
+}
+
+// Optional
+//
+//
+message OptionalProto {
+
+  optional string name = 1;
+
+  enum DataType {
+    UNDEFINED = 0;
+    TENSOR = 1;
+    SPARSE_TENSOR = 2;
+    SEQUENCE = 3;
+    MAP = 4;
+    OPTIONAL = 5;
+  }
+
+  // The data type of the element, identifies if the OptionalProto value
+  // is Tensor, Sparse Tensor, Sequence, Map, or Optional.
+  // The type of the optional value MUST match the elem_type specified.
+  // This field MUST have a valid OptionalProto.DataType value.
+  optional int32 elem_type = 2;
+
+  // For TensorProto value.
+  // When this field is present, the elem_type field MUST be TENSOR.
+  optional TensorProto tensor_value = 3;
+
+  // For SparseTensorProto value.
+  // When this field is present, the elem_type field MUST be SPARSE_TENSOR.
+  optional SparseTensorProto sparse_tensor_value = 4;
+
+  // For SequenceProto value.
+  // When this field is present, the elem_type field MUST be SEQUENCE.
+  optional SequenceProto sequence_value = 5;
+
+  // For MapProto value.
+  // When this field is present, the elem_type field MUST be MAP.
+  optional MapProto map_value = 6;
+
+  // For OptionalProto value, allowing optional to be of itself (completeness)
+  // When this field is present, the elem_type field MUST be OPTIONAL.
+  optional OptionalProto optional_value = 7;
+
+}
diff --git a/onnx/onnx-data.proto b/onnx/onnx-data.proto
new file mode 100644
index 0000000..95a3b35
--- /dev/null
+++ b/onnx/onnx-data.proto
@@ -0,0 +1,155 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// SPDX-License-Identifier: Apache-2.0
+
+
+syntax = "proto2";
+
+package onnx;
+import "onnx/onnx-ml.proto";
+
+// This file contains the proto definitions for MapProto and
+// SequenceProto. These protos are used to represent the data structures
+// of maps and sequence for use in test data or ModelProto.
+
+// Sequences
+//
+// Defines a dense, ordered, collection of elements that are of homogeneous types.
+// Sequences can be made out of tensors, maps, or sequences.
+//
+// If a sequence is made out of tensors, the tensors must have the same element
+// type (i.e. int32). In some cases, the tensors in a sequence can have different
+// shapes.  Whether the tensors can have different shapes or not depends on the
+// type/shape associated with the corresponding "ValueInfo". For example,
+// "Sequence<Tensor<float, [M,N]>" means that all tensors have same shape. However,
+// "Sequence<Tensor<float, [omitted,omitted]>" means they can have different
+// shapes (all of rank 2), where "omitted" means the corresponding dimension has
+// no symbolic/constant value. Finally, "Sequence<Tensor<float, omitted>>" means
+// that the different tensors can have different ranks, when the "shape" itself
+// is omitted from the tensor-type. For a more complete description, refer to
+// https://github.com/onnx/onnx/blob/main/docs/IR.md#static-tensor-shapes.
+//
+message SequenceProto {
+
+  optional string name = 1;
+
+  enum DataType {
+    UNDEFINED = 0;
+    TENSOR = 1;
+    SPARSE_TENSOR = 2;
+    SEQUENCE = 3;
+    MAP = 4;
+    OPTIONAL = 5;
+  }
+
+  // The data type of the element.
+  // This field MUST have a valid SequenceProto.DataType value
+  optional int32 elem_type = 2;
+
+  // For TensorProto values.
+  // When this field is present, the elem_type field MUST be TENSOR.
+  repeated TensorProto tensor_values = 3;
+
+  // For SparseTensorProto values.
+  // When this field is present, the elem_type field MUST be SPARSE_TENSOR.
+  repeated SparseTensorProto sparse_tensor_values = 4;
+
+  // For SequenceProto values, allowing sequences to be of themselves.
+  // When this field is present, the elem_type field MUST be SEQUENCE.
+  repeated SequenceProto sequence_values = 5;
+
+  // For MapProto values.
+  // When this field is present, the elem_type field MUST be MAP.
+  repeated MapProto map_values = 6;
+
+  // For OptionalProto values.
+  // When this field is present, the elem_type field MUST be Optional.
+  repeated OptionalProto optional_values = 7;
+
+}
+
+
+// Maps
+//
+// Specifies an associative table, defined by keys and values.
+// MapProto is formed with a repeated field of keys (of type INT8, INT16, INT32,
+// INT64, UINT8, UINT16, UINT32, UINT64, or STRING) and values (of type TENSOR,
+// SPARSE_TENSOR, SEQUENCE, or MAP). Key types and value types have to remain
+// the same throughout the instantiation of the MapProto.
+//
+message MapProto {
+
+  optional string name = 1;
+
+  // All MapProto data types must have the same length of keys and values.
+
+  // The data type of the key.
+  // This field MUST have a valid TensorProto.DataType value of
+  // INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64, or STRING
+  optional int32 key_type = 2;
+
+  // Every element of keys has to be one of the following data types
+  // INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64, or STRING.
+  // The integer cases are represented by the repeated int64 field keys below.
+  repeated int64 keys = 3;
+
+  // If keys are strings, they are represented by the repeated bytes field
+  // string_keys below.
+  repeated bytes string_keys = 4;
+
+  // MapProto values are represented in a SequenceProto of the same length as the
+  // repeated keys field and have to be one of the following data types
+  // TENSOR, SPARSE_TENSOR, MAP, SEQUENCE.
+  optional SequenceProto values = 5;
+}
+
+// Optional
+//
+//
+message OptionalProto {
+
+  optional string name = 1;
+
+  enum DataType {
+    UNDEFINED = 0;
+    TENSOR = 1;
+    SPARSE_TENSOR = 2;
+    SEQUENCE = 3;
+    MAP = 4;
+    OPTIONAL = 5;
+  }
+
+  // The data type of the element, identifies if the OptionalProto value
+  // is Tensor, Sparse Tensor, Sequence, Map, or Optional.
+  // The type of the optional value MUST match the elem_type specified.
+  // This field MUST have a valid OptionalProto.DataType value.
+  optional int32 elem_type = 2;
+
+  // For TensorProto value.
+  // When this field is present, the elem_type field MUST be TENSOR.
+  optional TensorProto tensor_value = 3;
+
+  // For SparseTensorProto value.
+  // When this field is present, the elem_type field MUST be SPARSE_TENSOR.
+  optional SparseTensorProto sparse_tensor_value = 4;
+
+  // For SequenceProto value.
+  // When this field is present, the elem_type field MUST be SEQUENCE.
+  optional SequenceProto sequence_value = 5;
+
+  // For MapProto value.
+  // When this field is present, the elem_type field MUST be MAP.
+  optional MapProto map_value = 6;
+
+  // For OptionalProto value, allowing optional to be of itself (completeness)
+  // When this field is present, the elem_type field MUST be OPTIONAL.
+  optional OptionalProto optional_value = 7;
+
+}
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx-data.proto3 b/onnx/onnx-data.proto3
new file mode 100644
index 0000000..6175ef5
--- /dev/null
+++ b/onnx/onnx-data.proto3
@@ -0,0 +1,155 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// SPDX-License-Identifier: Apache-2.0
+
+
+syntax = "proto3";
+
+package onnx;
+import "onnx/onnx-ml.proto3";
+
+// This file contains the proto definitions for MapProto and
+// SequenceProto. These protos are used to represent the data structures
+// of maps and sequence for use in test data or ModelProto.
+
+// Sequences
+//
+// Defines a dense, ordered, collection of elements that are of homogeneous types.
+// Sequences can be made out of tensors, maps, or sequences.
+//
+// If a sequence is made out of tensors, the tensors must have the same element
+// type (i.e. int32). In some cases, the tensors in a sequence can have different
+// shapes.  Whether the tensors can have different shapes or not depends on the
+// type/shape associated with the corresponding "ValueInfo". For example,
+// "Sequence<Tensor<float, [M,N]>" means that all tensors have same shape. However,
+// "Sequence<Tensor<float, [omitted,omitted]>" means they can have different
+// shapes (all of rank 2), where "omitted" means the corresponding dimension has
+// no symbolic/constant value. Finally, "Sequence<Tensor<float, omitted>>" means
+// that the different tensors can have different ranks, when the "shape" itself
+// is omitted from the tensor-type. For a more complete description, refer to
+// https://github.com/onnx/onnx/blob/main/docs/IR.md#static-tensor-shapes.
+//
+message SequenceProto {
+
+  string name = 1;
+
+  enum DataType {
+    UNDEFINED = 0;
+    TENSOR = 1;
+    SPARSE_TENSOR = 2;
+    SEQUENCE = 3;
+    MAP = 4;
+    OPTIONAL = 5;
+  }
+
+  // The data type of the element.
+  // This field MUST have a valid SequenceProto.DataType value
+  int32 elem_type = 2;
+
+  // For TensorProto values.
+  // When this field is present, the elem_type field MUST be TENSOR.
+  repeated TensorProto tensor_values = 3;
+
+  // For SparseTensorProto values.
+  // When this field is present, the elem_type field MUST be SPARSE_TENSOR.
+  repeated SparseTensorProto sparse_tensor_values = 4;
+
+  // For SequenceProto values, allowing sequences to be of themselves.
+  // When this field is present, the elem_type field MUST be SEQUENCE.
+  repeated SequenceProto sequence_values = 5;
+
+  // For MapProto values.
+  // When this field is present, the elem_type field MUST be MAP.
+  repeated MapProto map_values = 6;
+
+  // For OptionalProto values.
+  // When this field is present, the elem_type field MUST be Optional.
+  repeated OptionalProto optional_values = 7;
+
+}
+
+
+// Maps
+//
+// Specifies an associative table, defined by keys and values.
+// MapProto is formed with a repeated field of keys (of type INT8, INT16, INT32,
+// INT64, UINT8, UINT16, UINT32, UINT64, or STRING) and values (of type TENSOR,
+// SPARSE_TENSOR, SEQUENCE, or MAP). Key types and value types have to remain
+// the same throughout the instantiation of the MapProto.
+//
+message MapProto {
+
+  string name = 1;
+
+  // All MapProto data types must have the same length of keys and values.
+
+  // The data type of the key.
+  // This field MUST have a valid TensorProto.DataType value of
+  // INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64, or STRING
+  int32 key_type = 2;
+
+  // Every element of keys has to be one of the following data types
+  // INT8, INT16, INT32, INT64, UINT8, UINT16, UINT32, UINT64, or STRING.
+  // The integer cases are represented by the repeated int64 field keys below.
+  repeated int64 keys = 3;
+
+  // If keys are strings, they are represented by the repeated bytes field
+  // string_keys below.
+  repeated bytes string_keys = 4;
+
+  // MapProto values are represented in a SequenceProto of the same length as the
+  // repeated keys field and have to be one of the following data types
+  // TENSOR, SPARSE_TENSOR, MAP, SEQUENCE.
+  SequenceProto values = 5;
+}
+
+// Optional
+//
+//
+message OptionalProto {
+
+  string name = 1;
+
+  enum DataType {
+    UNDEFINED = 0;
+    TENSOR = 1;
+    SPARSE_TENSOR = 2;
+    SEQUENCE = 3;
+    MAP = 4;
+    OPTIONAL = 5;
+  }
+
+  // The data type of the element, identifies if the OptionalProto value
+  // is Tensor, Sparse Tensor, Sequence, Map, or Optional.
+  // The type of the optional value MUST match the elem_type specified.
+  // This field MUST have a valid OptionalProto.DataType value.
+  int32 elem_type = 2;
+
+  // For TensorProto value.
+  // When this field is present, the elem_type field MUST be TENSOR.
+  TensorProto tensor_value = 3;
+
+  // For SparseTensorProto value.
+  // When this field is present, the elem_type field MUST be SPARSE_TENSOR.
+  SparseTensorProto sparse_tensor_value = 4;
+
+  // For SequenceProto value.
+  // When this field is present, the elem_type field MUST be SEQUENCE.
+  SequenceProto sequence_value = 5;
+
+  // For MapProto value.
+  // When this field is present, the elem_type field MUST be MAP.
+  MapProto map_value = 6;
+
+  // For OptionalProto value, allowing optional to be of itself (completeness)
+  // When this field is present, the elem_type field MUST be OPTIONAL.
+  OptionalProto optional_value = 7;
+
+}
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx-ml.proto b/onnx/onnx-ml.proto
new file mode 100644
index 0000000..f08edca
--- /dev/null
+++ b/onnx/onnx-ml.proto
@@ -0,0 +1,1016 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// SPDX-License-Identifier: Apache-2.0
+
+
+syntax = "proto2";
+
+package onnx;
+
+// Overview
+//
+// ONNX is an open specification that is comprised of the following components:
+//
+// 1)  A definition of an extensible computation graph model.
+// 2)  Definitions of standard data types.
+// 3)  Definitions of built-in operators.
+//
+// This document describes the syntax of models and their computation graphs,
+// as well as the standard data types. Together, they are referred to as the ONNX
+// Intermediate Representation, or 'IR' for short.
+//
+// The normative semantic specification of the ONNX IR is found in docs/IR.md.
+// Definitions of the built-in neural network operators may be found in docs/Operators.md.
+// Definitions of the built-in classical machine learning operators may be found in
+// docs/Operators-ml.md.
+
+// Notes
+//
+// Protobuf compatibility
+//
+// To simplify framework compatibility, ONNX is defined using the subset of protobuf
+// that is compatible with both protobuf v2 and v3. This means that we do not use any
+// protobuf features that are only available in one of the two versions.
+//
+// Here are the most notable contortions we have to carry out to work around
+// these limitations:
+//
+//   - No 'map' (added protobuf 3.0). We instead represent mappings as lists
+//     of key-value pairs, where order does not matter and duplicates
+//     are not allowed.
+
+
+// Versioning
+//
+// ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md
+//
+// To be compatible with both proto2 and proto3, we will use a version number
+// that is not defined by the default value but an explicit enum number.
+enum Version {
+  // proto3 requires the first enum value to be zero.
+  // We add this just to appease the compiler.
+  _START_VERSION = 0;
+  // The version field is always serialized and we will use it to store the
+  // version that the  graph is generated from. This helps us set up version
+  // control.
+  // For the IR, we are using simple numbers starting with 0x00000001,
+  // which was the version we published on Oct 10, 2017.
+  IR_VERSION_2017_10_10 = 0x0000000000000001;
+
+  // IR_VERSION 2 published on Oct 30, 2017
+  // - Added type discriminator to AttributeProto to support proto3 users
+  IR_VERSION_2017_10_30 = 0x0000000000000002;
+
+  // IR VERSION 3 published on Nov 3, 2017
+  // - For operator versioning:
+  //    - Added new message OperatorSetIdProto
+  //    - Added opset_import in ModelProto
+  // - For vendor extensions, added domain in NodeProto
+  IR_VERSION_2017_11_3 = 0x0000000000000003;
+
+  // IR VERSION 4 published on Jan 22, 2019
+  // - Relax constraint that initializers should be a subset of graph inputs
+  // - Add type BFLOAT16
+  IR_VERSION_2019_1_22 = 0x0000000000000004;
+
+  // IR VERSION 5 published on March 18, 2019
+  // - Add message TensorAnnotation.
+  // - Add quantization annotation in GraphProto to map tensor with its scale and zero point quantization parameters.
+  IR_VERSION_2019_3_18 = 0x0000000000000005;
+
+  // IR VERSION 6 published on Sep 19, 2019
+  // - Add support for sparse tensor constants stored in model.
+  //   - Add message SparseTensorProto
+  //   - Add sparse initializers
+  IR_VERSION_2019_9_19 = 0x0000000000000006;
+
+  // IR VERSION 7 published on May 8, 2020
+  // - Add support to allow function body graph to rely on multiple external operator sets.
+  // - Add a list to promote inference graph's initializers to global and
+  //   mutable variables. Global variables are visible in all graphs of the
+  //   stored models.
+  // - Add message TrainingInfoProto to store initialization
+  //   method and training algorithm. The execution of TrainingInfoProto
+  //   can modify the values of mutable variables.
+  // - Implicitly add inference graph into each TrainingInfoProto's algorithm.
+  IR_VERSION_2020_5_8 = 0x0000000000000007;
+
+  // IR VERSION 8 published on July 30, 2021
+  // Introduce TypeProto.SparseTensor
+  // Introduce TypeProto.Optional
+  // Added a list of FunctionProtos local to the model
+  // Deprecated since_version and operator status from FunctionProto
+  IR_VERSION_2021_7_30 = 0x0000000000000008;
+
+  // IR VERSION 9 published on May 5, 2023
+  // Added AttributeProto to FunctionProto so that default attribute values can be set.
+  // Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ.
+  IR_VERSION_2023_5_5 = 0x0000000000000009;
+
+  // IR VERSION 10 published on March 25, 2024
+  // Added UINT4, INT4, overload field for functions and metadata_props on multiple proto definitions.
+  IR_VERSION_2024_3_25 = 0x000000000000000A;
+
+  // IR VERSION 11 published on May 12, 2025
+  // Added FLOAT4E2M1, multi-device protobuf classes.
+  IR_VERSION_2025_05_12 = 0x000000000000000B;
+
+  // IR VERSION 12 published on August 26, 2025
+  // Added FLOAT8E8M0.
+  IR_VERSION_2025_08_26 = 0x000000000000000C;
+
+  // IR VERSION 13 published on November 6, 2025
+  // Added UINT2, INT2.
+  IR_VERSION = 0x000000000000000D;
+}
+
+// Attributes
+//
+// A named attribute containing either singular float, integer, string, graph,
+// and tensor values, or repeated float, integer, string, graph, and tensor values.
+// An AttributeProto MUST contain the name field, and *only one* of the
+// following content fields, effectively enforcing a C/C++ union equivalent.
+message AttributeProto {
+  reserved 12, 16 to 19;
+  reserved "v";
+
+  // Note: this enum is structurally identical to the OpSchema::AttrType
+  // enum defined in schema.h.  If you rev one, you likely need to rev the other.
+  enum AttributeType {
+    UNDEFINED = 0;
+    FLOAT = 1;
+    INT = 2;
+    STRING = 3;
+    TENSOR = 4;
+    GRAPH = 5;
+    SPARSE_TENSOR = 11;
+    TYPE_PROTO = 13;
+
+    FLOATS = 6;
+    INTS = 7;
+    STRINGS = 8;
+    TENSORS = 9;
+    GRAPHS = 10;
+    SPARSE_TENSORS = 12;
+    TYPE_PROTOS = 14;
+  }
+
+  // The name field MUST be present for this version of the IR.
+  optional string name = 1;           // namespace Attribute
+
+  // if ref_attr_name is not empty, ref_attr_name is the attribute name in parent function.
+  // In this case, this AttributeProto does not contain data, and it's a reference of attribute
+  // in parent scope.
+  // NOTE: This should ONLY be used in function (sub-graph). It's invalid to be used in main graph.
+  optional string ref_attr_name = 21;
+
+  // A human-readable documentation for this attribute. Markdown is allowed.
+  optional string doc_string = 13;
+
+  // The type field MUST be present for this version of the IR.
+  // For 0.0.1 versions of the IR, this field was not defined, and
+  // implementations needed to use has_field heuristics to determine
+  // which value field was in use.  For IR_VERSION 0.0.2 or later, this
+  // field MUST be set and match the f|i|s|t|... field in use.  This
+  // change was made to accommodate proto3 implementations.
+  optional AttributeType type = 20;   // discriminator that indicates which field below is in use
+
+  // Exactly ONE of the following fields must be present for this version of the IR
+  optional float f = 2;               // float
+  optional int64 i = 3;               // int
+  optional bytes s = 4;               // UTF-8 string
+  optional TensorProto t = 5;         // tensor value
+  optional GraphProto g = 6;          // graph
+  optional SparseTensorProto sparse_tensor = 22;  // sparse tensor value
+  // Do not use field below, it's deprecated.
+  // optional ValueProto v = 12;         // value - subsumes everything but graph
+  optional TypeProto tp = 14;          // type proto
+
+  repeated float floats = 7;          // list of floats
+  repeated int64 ints = 8;            // list of ints
+  repeated bytes strings = 9;         // list of UTF-8 strings
+  repeated TensorProto tensors = 10;  // list of tensors
+  repeated GraphProto graphs = 11;    // list of graph
+  repeated SparseTensorProto sparse_tensors = 23; // list of sparse tensors
+  repeated TypeProto type_protos = 15;// list of type protos
+}
+
+// Defines information on value, including the name, the type, and
+// the shape of the value.
+message ValueInfoProto {
+  // This field MUST be present in this version of the IR.
+  optional string name = 1;     // namespace Value
+  // This field MUST be present in this version of the IR for
+  // inputs and outputs of the top-level graph.
+  optional TypeProto type = 2;
+  // A human-readable documentation for this value. Markdown is allowed.
+  optional string doc_string = 3;
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 4;
+}
+
+// Nodes
+//
+// Computation graphs are made up of a DAG of nodes, which represent what is
+// commonly called a "layer" or "pipeline stage" in machine learning frameworks.
+//
+// For example, it can be a node of type "Conv" that takes in an image, a filter
+// tensor and a bias tensor, and produces the convolved output.
+message NodeProto {
+  repeated string input = 1;    // namespace Value
+  repeated string output = 2;   // namespace Value
+
+  // An optional identifier for this node in a graph.
+  // This field MAY be absent in this version of the IR.
+  optional string name = 3;     // namespace Node
+
+  // The symbolic identifier of the Operator to execute.
+  optional string op_type = 4;  // namespace Operator
+  // The domain of the OperatorSet that specifies the operator named by op_type.
+  optional string domain = 7;   // namespace Domain
+  // Overload identifier, used only to map this to a model-local function.
+  optional string overload = 8;
+
+  // Additional named attributes.
+  repeated AttributeProto attribute = 5;
+
+  // A human-readable documentation for this node. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 9;
+
+  // Configuration of multi-device annotations.
+  repeated NodeDeviceConfigurationProto device_configurations = 10;
+}
+
+// IntIntListEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message IntIntListEntryProto {
+  optional int64 key = 1;
+  repeated int64 value = 2;
+};
+
+// Multi-device configuration proto for NodeProto.
+message NodeDeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // ID of the configuration. MUST match the name of a DeviceConfigurationProto.
+    optional string configuration_id = 1;
+    // Sharding spec for the node.
+    repeated ShardingSpecProto sharding_spec = 2;
+    // Pipeline stage of this node.
+    optional int32 pipeline_stage = 3;
+}
+
+// ShardingSpecProto: This describes the sharding spec for a specific
+// input or output tensor of a node.
+message ShardingSpecProto {
+  // This field MUST be present for this version of the IR.
+  // Identifies the input or output of the node that is being sharded.
+  // Required to match a name specified in the node's input or output list of ValueInfoProtos.
+  // It is called `logical tensor` in subsequent descriptions.
+  optional string tensor_name = 1;
+
+  // The following is the list of devices across which the logical
+  // tensor is sharded or replicated.
+  repeated int64 device = 2;
+
+  // Each element v in above field devices may represent either a
+  // device or a set of devices (when we want the same shard/tensor
+  // to be replicated across a subset of devices), as indicated by
+  // the following optional map. If the map contains an entry for v,
+  // then v represents a device group, and the map indicates the set
+  // of devices in that group.
+  repeated IntIntListEntryProto index_to_device_group_map = 3;
+
+  // The following is the sharded-shape of the tensor, consisting of
+  // the sharding-spec for each axis of the tensor.
+  repeated ShardedDimProto sharded_dim = 4;
+}
+
+// ShardedDimProto: This describes the sharding spec for a single
+// axis of a sharded tensor.
+message ShardedDimProto {
+  // This field MUST be present for this version of the IR.
+  // The axis this sharding corresponds to. Must be in the range of
+  // [-r, r - 1], where r is the rank of the tensor. Negative axis values means
+  // counting from the back.
+  optional int64 axis = 1;
+
+  // Describes how the tensor on the provided axis is sharded.
+  // The common-case is described by a single instance of SimpleShardedDimProto.
+  // Multiple instances can be used to handle cases where a sharded
+  // tensor is reshaped, fusing multiple axes into one.
+  repeated SimpleShardedDimProto simple_sharding = 2;
+}
+
+// SimpleShardedDimProto: Indicates that N blocks are divided into M shards.
+// N is allowed to be symbolic where M is required to be a constant.
+message SimpleShardedDimProto {
+    // Dimension value to be sharded.
+    oneof dim {
+        int64 dim_value = 1;
+        string dim_param = 2;
+    }
+
+    // This field MUST be present for this version of the IR.
+    // Number of shards to split dim into.
+    optional int64 num_shards = 3;
+}
+
+// Training information
+// TrainingInfoProto stores information for training a model.
+// In particular, this defines two functionalities: an initialization-step
+// and a training-algorithm-step. Initialization resets the model
+// back to its original state as if no training has been performed.
+// Training algorithm improves the model based on input data.
+//
+// The semantics of the initialization-step is that the initializers
+// in ModelProto.graph and in TrainingInfoProto.algorithm are first
+// initialized as specified by the initializers in the graph, and then
+// updated by the "initialization_binding" in every instance in
+// ModelProto.training_info.
+//
+// The field "algorithm" defines a computation graph which represents a
+// training algorithm's step. After the execution of a
+// TrainingInfoProto.algorithm, the initializers specified by "update_binding"
+// may be immediately updated. If the targeted training algorithm contains
+// consecutive update steps (such as block coordinate descent methods),
+// the user needs to create a TrainingInfoProto for each step.
+message TrainingInfoProto {
+  // This field describes a graph to compute the initial tensors
+  // upon starting the training process. Initialization graph has no input
+  // and can have multiple outputs. Usually, trainable tensors in neural
+  // networks are randomly initialized. To achieve that, for each tensor,
+  // the user can put a random number operator such as RandomNormal or
+  // RandomUniform in TrainingInfoProto.initialization.node and assign its
+  // random output to the specific tensor using "initialization_binding".
+  // This graph can also set the initializers in "algorithm" in the same
+  // TrainingInfoProto; a use case is resetting the number of training
+  // iteration to zero.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Thus, no initializer would be changed by default.
+  optional GraphProto initialization = 1;
+
+  // This field represents a training algorithm step. Given required inputs,
+  // it computes outputs to update initializers in its own or inference graph's
+  // initializer lists. In general, this field contains loss node, gradient node,
+  // optimizer node, increment of iteration count.
+  //
+  // An execution of the training algorithm step is performed by executing the
+  // graph obtained by combining the inference graph (namely "ModelProto.graph")
+  // and the "algorithm" graph. That is, the actual
+  // input/initializer/output/node/value_info/sparse_initializer list of
+  // the training graph is the concatenation of
+  // "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer"
+  // and "algorithm.input/initializer/output/node/value_info/sparse_initializer"
+  // in that order. This combined graph must satisfy the normal ONNX conditions.
+  // Now, let's provide a visualization of graph combination for clarity.
+  // Let the inference graph (i.e., "ModelProto.graph") be
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d
+  // and the "algorithm" graph be
+  //    tensor_d -> Add -> tensor_e
+  // The combination process results
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add -> tensor_e
+  //
+  // Notice that an input of a node in the "algorithm" graph may reference the
+  // output of a node in the inference graph (but not the other way round). Also, inference
+  // node cannot reference inputs of "algorithm". With these restrictions, inference graph
+  // can always be run independently without training information.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Evaluating the default training step never
+  // update any initializers.
+  optional GraphProto algorithm = 2;
+
+  // This field specifies the bindings from the outputs of "initialization" to
+  // some initializers in "ModelProto.graph.initializer" and
+  // the "algorithm.initializer" in the same TrainingInfoProto.
+  // See "update_binding" below for details.
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "initialization".
+  repeated StringStringEntryProto initialization_binding = 3;
+
+  // Gradient-based training is usually an iterative procedure. In one gradient
+  // descent iteration, we apply
+  //
+  // x = x - r * g
+  //
+  // where "x" is the optimized tensor, "r" stands for learning rate, and "g" is
+  // gradient of "x" with respect to a chosen loss. To avoid adding assignments
+  // into the training graph, we split the update equation into
+  //
+  // y = x - r * g
+  // x = y
+  //
+  // The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To
+  // tell that "y" should be assigned to "x", the field "update_binding" may
+  // contain a key-value pair of strings, "x" (key of StringStringEntryProto)
+  // and "y" (value of StringStringEntryProto).
+  // For a neural network with multiple trainable (mutable) tensors, there can
+  // be multiple key-value pairs in "update_binding".
+  //
+  // The initializers appears as keys in "update_binding" are considered
+  // mutable variables. This implies some behaviors
+  // as described below.
+  //
+  //  1. We have only unique keys in all "update_binding"s so that two
+  //     variables may not have the same name. This ensures that one
+  //     variable is assigned up to once.
+  //  2. The keys must appear in names of "ModelProto.graph.initializer" or
+  //     "TrainingInfoProto.algorithm.initializer".
+  //  3. The values must be output names of "algorithm" or "ModelProto.graph.output".
+  //  4. Mutable variables are initialized to the value specified by the
+  //     corresponding initializer, and then potentially updated by
+  //     "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s.
+  //
+  // This field usually contains names of trainable tensors
+  // (in ModelProto.graph), optimizer states such as momentums in advanced
+  // stochastic gradient methods (in TrainingInfoProto.graph),
+  // and number of training iterations (in TrainingInfoProto.graph).
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "algorithm".
+  repeated StringStringEntryProto update_binding = 4;
+}
+
+// Models
+//
+// ModelProto is a top-level file/container format for bundling a ML model and
+// associating its computation graph with metadata.
+//
+// The semantics of the model are described by the associated GraphProto's.
+message ModelProto {
+  // The version of the IR this model targets. See Version enum above.
+  // This field MUST be present.
+  optional int64 ir_version = 1;
+
+  // The OperatorSets this model relies on.
+  // All ModelProtos MUST have at least one entry that
+  // specifies which version of the ONNX OperatorSet is
+  // being imported.
+  //
+  // All nodes in the ModelProto's graph will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets.
+  repeated OperatorSetIdProto opset_import = 8;
+
+  // The name of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  optional string producer_name = 2;
+
+  // The version of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  optional string producer_version = 3;
+
+  // Domain name of the model.
+  // We use reverse domain names as name space indicators. For example:
+  // `com.facebook.fair` or `com.microsoft.cognitiveservices`
+  //
+  // Together with `model_version` and GraphProto.name, this forms the unique identity of
+  // the graph.
+  optional string domain = 4;
+
+  // The version of the graph encoded. See Version enum below.
+  optional int64 model_version = 5;
+
+  // A human-readable documentation for this model. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // The parameterized graph that is evaluated to execute the model.
+  optional GraphProto graph = 7;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+
+  // Training-specific information. Sequentially executing all stored
+  // `TrainingInfoProto.algorithm`s and assigning their outputs following
+  // the corresponding `TrainingInfoProto.update_binding`s is one training
+  // iteration. Similarly, to initialize the model
+  // (as if training hasn't happened), the user should sequentially execute
+  // all stored `TrainingInfoProto.initialization`s and assigns their outputs
+  // using `TrainingInfoProto.initialization_binding`s.
+  //
+  // If this field is empty, the training behavior of the model is undefined.
+  repeated TrainingInfoProto training_info = 20;
+
+  // A list of function protos local to the model.
+  //
+  // The (domain, name, overload) tuple must be unique across the function protos in this list.
+  // In case of any conflicts the behavior (whether the model local functions are given higher priority,
+  // or standard operator sets are given higher priority or this is treated as error) is defined by
+  // the runtimes.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto and other model local FunctionProtos.
+  // Example, if same operator set say 'A' is imported by a FunctionProto and ModelProto
+  // or by 2 FunctionProtos then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same for every node in the function body.
+  //
+  // One FunctionProto can reference other FunctionProto in the model, however, recursive reference
+  // is not allowed.
+  repeated FunctionProto functions = 25;
+
+  // Describes different target configurations for a multi-device use case.
+  // A model MAY describe multiple multi-device configurations for execution.
+  repeated DeviceConfigurationProto configuration = 26;
+};
+
+// DeviceConfigurationProto describes a multi-device configuration for a model.
+message DeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // Name of the configuration.
+    optional string name = 1;
+    // This field MUST be present for this version of the IR.
+    // Number of devices inside this configuration.
+    optional int32 num_devices = 2;
+    // Optional names of the devices. MUST be length of num_devices if provided.
+    repeated string device = 3;
+}
+
+// StringStringEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message StringStringEntryProto {
+  optional string key = 1;
+  optional string value = 2;
+};
+
+message TensorAnnotation {
+  optional string tensor_name = 1;
+  // <key, value> pairs to annotate tensor specified by <tensor_name> above.
+  // The keys used in the mapping below must be pre-defined in ONNX spec.
+  // For example, for 8-bit linear quantization case, 'SCALE_TENSOR', 'ZERO_POINT_TENSOR' will be pre-defined as
+  // quantization parameter keys.
+  repeated StringStringEntryProto quant_parameter_tensor_names = 2;
+}
+
+
+
+// Graphs
+//
+// A graph defines the computational logic of a model and is comprised of a parameterized
+// list of nodes that form a directed acyclic graph based on their inputs and outputs.
+// This is the equivalent of the "network" or "graph" in many deep learning
+// frameworks.
+message GraphProto {
+  // The nodes in the graph, sorted topologically.
+  repeated NodeProto node = 1;
+
+  // The name of the graph.
+  optional string name = 2;   // namespace Graph
+
+  // A list of named tensor values, used to specify constant inputs of the graph.
+  // Each initializer (both TensorProto as well SparseTensorProto) MUST have a name.
+  // The name MUST be unique across both initializer and sparse_initializer,
+  // but the name MAY also appear in the input list.
+  repeated TensorProto initializer = 5;
+
+  // Initializers (see above) stored in sparse format.
+  repeated SparseTensorProto sparse_initializer = 15;
+
+  // A human-readable documentation for this graph. Markdown is allowed.
+  optional string doc_string = 10;
+
+  // The inputs and outputs of the graph.
+  repeated ValueInfoProto input = 11;
+  repeated ValueInfoProto output = 12;
+
+  // Information for the values in the graph. The ValueInfoProto.name's
+  // must be distinct. It is optional for a value to appear in value_info list.
+  repeated ValueInfoProto value_info = 13;
+
+  // This field carries information to indicate the mapping among a tensor and its
+  // quantization parameter tensors. For example:
+  // For tensor 'a', it may have {'SCALE_TENSOR', 'a_scale'} and {'ZERO_POINT_TENSOR', 'a_zero_point'} annotated,
+  // which means, tensor 'a_scale' and tensor 'a_zero_point' are scale and zero point of tensor 'a' in the model.
+  repeated TensorAnnotation quantization_annotation = 14;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+
+  reserved 3, 4, 6 to 9;
+  reserved "ir_version", "producer_version", "producer_tag", "domain";
+}
+
+// Tensors
+//
+// A serialized tensor value.
+message TensorProto {
+  enum DataType {
+    UNDEFINED = 0;
+    // Basic types.
+    FLOAT = 1;   // float
+    UINT8 = 2;   // uint8_t
+    INT8 = 3;    // int8_t
+    UINT16 = 4;  // uint16_t
+    INT16 = 5;   // int16_t
+    INT32 = 6;   // int32_t
+    INT64 = 7;   // int64_t
+    STRING = 8;  // string
+    BOOL = 9;    // bool
+
+    // IEEE754 half-precision floating-point format (16 bits wide).
+    // This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
+    FLOAT16 = 10;
+
+    DOUBLE = 11;
+    UINT32 = 12;
+    UINT64 = 13;
+    COMPLEX64 = 14;     // complex with float32 real and imaginary components
+    COMPLEX128 = 15;    // complex with float64 real and imaginary components
+
+    // Non-IEEE floating-point format based on IEEE754 single-precision
+    // floating-point number truncated to 16 bits.
+    // This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
+    BFLOAT16 = 16;
+
+    // Non-IEEE floating-point format based on papers
+    // FP8 Formats for Deep Learning, https://arxiv.org/abs/2209.05433,
+    // 8-bit Numerical Formats For Deep Neural Networks, https://arxiv.org/pdf/2206.02915.pdf.
+    // Operators supported FP8 are Cast, CastLike, QuantizeLinear, DequantizeLinear.
+    // The computation usually happens inside a block quantize / dequantize
+    // fused by the runtime.
+    FLOAT8E4M3FN = 17;    // float 8, mostly used for coefficients, supports nan, not inf
+    FLOAT8E4M3FNUZ = 18;  // float 8, mostly used for coefficients, supports nan, not inf, no negative zero
+    FLOAT8E5M2 = 19;      // follows IEEE 754, supports nan, inf, mostly used for gradients
+    FLOAT8E5M2FNUZ = 20;  // follows IEEE 754, supports nan, not inf, mostly used for gradients, no negative zero
+
+    // 4-bit integer data types
+    UINT4 = 21;  // Unsigned integer in range [0, 15]
+    INT4 = 22;   // Signed integer in range [-8, 7], using two's-complement representation
+
+    // 4-bit floating point data types
+    FLOAT4E2M1 = 23;
+
+    // E8M0 type used as the scale for microscaling (MX) formats:
+    // https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
+    FLOAT8E8M0 = 24;
+
+    // 2-bit integer data type
+    UINT2 = 25; // Unsigned integer in range [0, 3]
+    INT2 = 26;  // Signed integer in range [-2, 1], using two's complement representation
+
+    // Future extensions go here.
+  }
+
+  // The shape of the tensor.
+  repeated int64 dims = 1;
+
+  // The data type of the tensor.
+  // This field MUST have a valid TensorProto.DataType value
+  optional int32 data_type = 2;
+
+  // For very large tensors, we may want to store them in chunks, in which
+  // case the following fields will specify the segment that is stored in
+  // the current TensorProto.
+  message Segment {
+    optional int64 begin = 1;
+    optional int64 end = 2;
+  }
+  optional Segment segment = 3;
+
+  // Tensor content must be organized in row-major order.
+  //
+  // Depending on the data_type field, exactly one of the fields below with
+  // name ending in _data is used to store the elements of the tensor.
+
+  // For float and complex64 values
+  // Complex64 tensors are encoded as a single array of floats,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
+  repeated float float_data = 4 [packed = true];
+
+  // For int32, uint8, int8, uint16, int16, uint4, int4, uint2, int2, bool, (b)float16, float8, and float4:
+  // - (b)float16 and float8 values MUST be converted bit-wise into an unsigned integer
+  //   representation before being written to the buffer.
+  // - Each pair of uint4, int4, and float4 values MUST be packed as two 4-bit elements into a single byte.
+  //   The first element is stored in the 4 least significant bits (LSB),
+  //   and the second element is stored in the 4 most significant bits (MSB).
+  // - Each group of four uint2, int2 values MUST be packed as four 2-bit elements into a single byte.
+  //   The elements are packed from LSB to MSB, with the first element in bits 0-1, second element in bits 2-3,
+  //   third element in bits 4-5, and fourth element in bits 6-7.
+  //
+  // Consequently:
+  // - For data types with a bit-width of 8 or greater, each `int32_data` stores one element.
+  // - For 4-bit data types, each `int32_data` stores two elements.
+  // - For 2-bit data types, each `int32_data` stores four elements.
+  //
+  // When this field is present, the data_type field MUST be
+  // INT32, INT16, INT8, INT4, INT2, UINT16, UINT8, UINT4, UINT2, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ, FLOAT8E8M0, FLOAT4E2M1
+  repeated int32 int32_data = 5 [packed = true];
+
+  // For strings.
+  // Each element of string_data is a UTF-8 encoded Unicode
+  // string. No trailing null, no leading BOM. The protobuf "string"
+  // scalar type is not used to match ML community conventions.
+  // When this field is present, the data_type field MUST be STRING
+  repeated bytes string_data = 6;
+
+  // For int64.
+  // When this field is present, the data_type field MUST be INT64
+  repeated int64 int64_data = 7 [packed = true];
+
+  // Optionally, a name for the tensor.
+  optional string name = 8; // namespace Value
+
+  // A human-readable documentation for this tensor. Markdown is allowed.
+  optional string doc_string = 12;
+
+  // Serializations can either use one of the fields above, or use this
+  // raw bytes field. The only exception is the string case, where one is
+  // required to store the content in the repeated bytes string_data field.
+  //
+  // When this raw_data field is used to store tensor value, elements MUST
+  // be stored in as fixed-width, little-endian order.
+  // Floating-point data types MUST be stored in IEEE 754 format.
+  // Complex64 elements must be written as two consecutive FLOAT values, real component first.
+  // Complex128 elements must be written as two consecutive DOUBLE values, real component first.
+  // Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
+  // uint4 and int4 values must be packed to 4bitx2, the first element is stored in the 4 LSB and the second element is stored in the 4 MSB.
+  // uint2 and int2 values must be packed to 2bitx4, with elements packed from LSB to MSB in a single byte as: x0 | (x1 << 2) | (x2 << 4) | (x3 << 6)
+  // where x0, x1, x2, x3 are consecutive elements.
+  //
+  // Note: the advantage of specific field rather than the raw_data field is
+  // that in some cases (e.g. int data), protobuf does a better packing via
+  // variable length storage, and may lead to smaller binary footprint.
+  // When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
+  optional bytes raw_data = 9;
+
+  // Data can be stored inside the protobuf file using type-specific fields or raw_data.
+  // Alternatively, raw bytes data can be stored in an external file, using the external_data field.
+  // external_data stores key-value pairs describing data location. Recognized keys are:
+  // - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
+  //                           protobuf model was stored
+  // - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
+  //                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
+  // - "length" (optional) - number of bytes containing data. Integer stored as string.
+  // - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
+  repeated StringStringEntryProto external_data = 13;
+
+  // Location of the data for this tensor. MUST be one of:
+  // - DEFAULT - data stored inside the protobuf message. Data is stored in raw_data (if set) otherwise in type-specified field.
+  // - EXTERNAL - data stored in an external location as described by external_data field.
+  enum DataLocation {
+    DEFAULT = 0;
+    EXTERNAL = 1;
+  }
+
+  // If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
+  optional DataLocation data_location = 14;
+
+  // For double
+  // Complex128 tensors are encoded as a single array of doubles,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
+  repeated double double_data = 10 [packed = true];
+
+  // For uint64 and uint32 values
+  // When this field is present, the data_type field MUST be
+  // UINT32 or UINT64
+  repeated uint64 uint64_data = 11 [packed = true];
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+}
+
+// A serialized sparse-tensor value
+message SparseTensorProto {
+  // The sequence of non-default values are encoded as a tensor of shape [NNZ].
+  // The default-value is zero for numeric tensors, and empty-string for string tensors.
+  // values must have a non-empty name present which serves as a name for SparseTensorProto
+  // when used in sparse_initializer list.
+  optional TensorProto values = 1;
+
+  // The indices of the non-default values, which may be stored in one of two formats.
+  // (a) Indices can be a tensor of shape [NNZ, rank] with the [i,j]-th value
+  // corresponding to the j-th index of the i-th value (in the values tensor).
+  // (b) Indices can be a tensor of shape [NNZ], in which case the i-th value
+  // must be the linearized-index of the i-th value (in the values tensor).
+  // The linearized-index can be converted into an index tuple (k_1,...,k_rank)
+  // using the shape provided below.
+  // The indices must appear in ascending order without duplication.
+  // In the first format, the ordering is lexicographic-ordering:
+  // e.g., index-value [1,4] must appear before [2,1]
+  optional TensorProto indices = 2;
+
+  // The shape of the underlying dense-tensor: [dim_1, dim_2, ... dim_rank]
+  repeated int64 dims = 3;
+}
+
+// Defines a tensor shape. A dimension can be either an integer value
+// or a symbolic variable. A symbolic variable represents an unknown
+// dimension.
+message TensorShapeProto {
+  message Dimension {
+    oneof value {
+      int64 dim_value = 1;
+      string dim_param = 2;   // namespace Shape
+    };
+    // Standard denotation can optionally be used to denote tensor
+    // dimensions with standard semantic descriptions to ensure
+    // that operations are applied to the correct axis of a tensor.
+    // Refer to https://github.com/onnx/onnx/blob/main/docs/DimensionDenotation.md#denotation-definition
+    // for pre-defined dimension denotations.
+    optional string denotation = 3;
+  };
+  repeated Dimension dim = 1;
+}
+
+// Types
+//
+// The standard ONNX data types.
+message TypeProto {
+
+  message Tensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    optional int32 elem_type = 1;
+    optional TensorShapeProto shape = 2;
+  }
+
+  // repeated T
+  message Sequence {
+    // The type and optional shape of each element of the sequence.
+    // This field MUST be present for this version of the IR.
+    optional TypeProto elem_type = 1;
+  };
+
+  // map<K,V>
+  message Map {
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    // This field MUST refer to an integral type ([U]INT{8|16|32|64}) or STRING
+    optional int32 key_type = 1;
+    // This field MUST be present for this version of the IR.
+    optional TypeProto value_type = 2;
+  };
+
+  // wrapper for Tensor, Sequence, or Map
+  message Optional {
+    // The type and optional shape of the element wrapped.
+    // This field MUST be present for this version of the IR.
+    // Possible values correspond to OptionalProto.DataType enum
+    optional TypeProto elem_type = 1;
+  };
+
+
+  message SparseTensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    optional int32 elem_type = 1;
+    optional TensorShapeProto shape = 2;
+  }
+
+
+  message Opaque {
+    // When missing, the domain is the same as the model's.
+    optional string domain = 1;
+    // The name is optional but significant when provided.
+    optional string name = 2;
+    // parameters that help defining the type
+    // DEPRECATED do not use.
+    // repeated TypeProto parameters = 3;
+  }
+
+
+  oneof value {
+    // The type of a tensor.
+    Tensor tensor_type = 1;
+
+    // NOTE:  DNN-only implementations of ONNX MAY elect to not support non-tensor values
+    //        as input and output to graphs and nodes. These types are needed to naturally
+    //        support classical ML operators.  DNN operators SHOULD restrict their input
+    //        and output types to tensors.
+
+    // The type of a sequence.
+    Sequence sequence_type = 4;
+
+    // The type of a map.
+    Map map_type = 5;
+
+    // The type of an optional.
+    Optional optional_type = 9;
+
+
+    // Type of the sparse tensor
+    SparseTensor sparse_tensor_type = 8;
+
+
+    Opaque opaque_type = 7;
+
+  }
+
+  // An optional denotation can be used to denote the whole
+  // type with a standard semantic description as to what is
+  // stored inside. Refer to https://github.com/onnx/onnx/blob/main/docs/TypeDenotation.md#type-denotation-definition
+  // for pre-defined type denotations.
+  optional string denotation = 6;
+}
+
+// Operator Sets
+//
+// OperatorSets are uniquely identified by a (domain, opset_version) pair.
+message OperatorSetIdProto {
+  // The domain of the operator set being identified.
+  // The empty string ("") or absence of this field implies the operator
+  // set that is defined as part of the ONNX specification.
+  // This field MUST be present in this version of the IR when referring to any other operator set.
+  optional string domain = 1;
+
+  // The version of the operator set being identified.
+  // This field MUST be present in this version of the IR.
+  optional int64 version = 2;
+}
+
+// Operator/function status.
+enum OperatorStatus {
+    EXPERIMENTAL = 0;
+    STABLE = 1;
+}
+
+message FunctionProto {
+  // The name of the function, similar to op_type in NodeProto.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  optional string name = 1;
+
+  // Deprecated since IR Version 8
+  // optional int64 since_version = 2;
+  reserved 2;
+  reserved "since_version";
+
+  // Deprecated since IR Version 8
+  // optional OperatorStatus status = 3;
+  reserved 3;
+  reserved "status";
+
+  // The inputs and outputs of the function.
+  repeated string input = 4;
+  repeated string output = 5;
+
+  // The attribute parameters of the function.
+  // It is for function parameters without default values.
+  repeated string attribute = 6;
+
+  // The attribute protos of the function.
+  // It is for function attributes with default values.
+  // A function attribute shall be represented either as
+  // a string attribute or an AttributeProto, not both.
+  repeated AttributeProto attribute_proto = 11;
+
+  // The nodes in the function.
+  repeated NodeProto node = 7;
+  // A human-readable documentation for this function. Markdown is allowed.
+  optional string doc_string = 8;
+
+  // The OperatorSets this function body (graph) relies on.
+  //
+  // All nodes in the function body (graph) will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets. This means at most one version can be relied
+  // for one domain.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto. Example, if same operator set say 'A' is imported by FunctionProto
+  // and ModelProto then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same.
+
+  repeated OperatorSetIdProto opset_import = 9;
+
+  // The domain which this function belongs to.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  optional string domain = 10;
+
+  // The overload identifier of the function.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  optional string overload = 13;
+
+  // Information for the values in the function. The ValueInfoProto.name's
+  // must be distinct and refer to names in the function (including inputs,
+  // outputs, and intermediate values). It is optional for a value to appear
+  // in value_info list.
+  repeated ValueInfoProto value_info = 12;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+}
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx-ml.proto3 b/onnx/onnx-ml.proto3
new file mode 100644
index 0000000..57382d9
--- /dev/null
+++ b/onnx/onnx-ml.proto3
@@ -0,0 +1,1016 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// SPDX-License-Identifier: Apache-2.0
+
+
+syntax = "proto3";
+
+package onnx;
+
+// Overview
+//
+// ONNX is an open specification that is comprised of the following components:
+//
+// 1)  A definition of an extensible computation graph model.
+// 2)  Definitions of standard data types.
+// 3)  Definitions of built-in operators.
+//
+// This document describes the syntax of models and their computation graphs,
+// as well as the standard data types. Together, they are referred to as the ONNX
+// Intermediate Representation, or 'IR' for short.
+//
+// The normative semantic specification of the ONNX IR is found in docs/IR.md.
+// Definitions of the built-in neural network operators may be found in docs/Operators.md.
+// Definitions of the built-in classical machine learning operators may be found in
+// docs/Operators-ml.md.
+
+// Notes
+//
+// Protobuf compatibility
+//
+// To simplify framework compatibility, ONNX is defined using the subset of protobuf
+// that is compatible with both protobuf v2 and v3. This means that we do not use any
+// protobuf features that are only available in one of the two versions.
+//
+// Here are the most notable contortions we have to carry out to work around
+// these limitations:
+//
+//   - No 'map' (added protobuf 3.0). We instead represent mappings as lists
+//     of key-value pairs, where order does not matter and duplicates
+//     are not allowed.
+
+
+// Versioning
+//
+// ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md
+//
+// To be compatible with both proto2 and proto3, we will use a version number
+// that is not defined by the default value but an explicit enum number.
+enum Version {
+  // proto3 requires the first enum value to be zero.
+  // We add this just to appease the compiler.
+  _START_VERSION = 0;
+  // The version field is always serialized and we will use it to store the
+  // version that the  graph is generated from. This helps us set up version
+  // control.
+  // For the IR, we are using simple numbers starting with 0x00000001,
+  // which was the version we published on Oct 10, 2017.
+  IR_VERSION_2017_10_10 = 0x0000000000000001;
+
+  // IR_VERSION 2 published on Oct 30, 2017
+  // - Added type discriminator to AttributeProto to support proto3 users
+  IR_VERSION_2017_10_30 = 0x0000000000000002;
+
+  // IR VERSION 3 published on Nov 3, 2017
+  // - For operator versioning:
+  //    - Added new message OperatorSetIdProto
+  //    - Added opset_import in ModelProto
+  // - For vendor extensions, added domain in NodeProto
+  IR_VERSION_2017_11_3 = 0x0000000000000003;
+
+  // IR VERSION 4 published on Jan 22, 2019
+  // - Relax constraint that initializers should be a subset of graph inputs
+  // - Add type BFLOAT16
+  IR_VERSION_2019_1_22 = 0x0000000000000004;
+
+  // IR VERSION 5 published on March 18, 2019
+  // - Add message TensorAnnotation.
+  // - Add quantization annotation in GraphProto to map tensor with its scale and zero point quantization parameters.
+  IR_VERSION_2019_3_18 = 0x0000000000000005;
+
+  // IR VERSION 6 published on Sep 19, 2019
+  // - Add support for sparse tensor constants stored in model.
+  //   - Add message SparseTensorProto
+  //   - Add sparse initializers
+  IR_VERSION_2019_9_19 = 0x0000000000000006;
+
+  // IR VERSION 7 published on May 8, 2020
+  // - Add support to allow function body graph to rely on multiple external operator sets.
+  // - Add a list to promote inference graph's initializers to global and
+  //   mutable variables. Global variables are visible in all graphs of the
+  //   stored models.
+  // - Add message TrainingInfoProto to store initialization
+  //   method and training algorithm. The execution of TrainingInfoProto
+  //   can modify the values of mutable variables.
+  // - Implicitly add inference graph into each TrainingInfoProto's algorithm.
+  IR_VERSION_2020_5_8 = 0x0000000000000007;
+
+  // IR VERSION 8 published on July 30, 2021
+  // Introduce TypeProto.SparseTensor
+  // Introduce TypeProto.Optional
+  // Added a list of FunctionProtos local to the model
+  // Deprecated since_version and operator status from FunctionProto
+  IR_VERSION_2021_7_30 = 0x0000000000000008;
+
+  // IR VERSION 9 published on May 5, 2023
+  // Added AttributeProto to FunctionProto so that default attribute values can be set.
+  // Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ.
+  IR_VERSION_2023_5_5 = 0x0000000000000009;
+
+  // IR VERSION 10 published on March 25, 2024
+  // Added UINT4, INT4, overload field for functions and metadata_props on multiple proto definitions.
+  IR_VERSION_2024_3_25 = 0x000000000000000A;
+
+  // IR VERSION 11 published on May 12, 2025
+  // Added FLOAT4E2M1, multi-device protobuf classes.
+  IR_VERSION_2025_05_12 = 0x000000000000000B;
+
+  // IR VERSION 12 published on August 26, 2025
+  // Added FLOAT8E8M0.
+  IR_VERSION_2025_08_26 = 0x000000000000000C;
+
+  // IR VERSION 13 published on November 6, 2025
+  // Added UINT2, INT2.
+  IR_VERSION = 0x000000000000000D;
+}
+
+// Attributes
+//
+// A named attribute containing either singular float, integer, string, graph,
+// and tensor values, or repeated float, integer, string, graph, and tensor values.
+// An AttributeProto MUST contain the name field, and *only one* of the
+// following content fields, effectively enforcing a C/C++ union equivalent.
+message AttributeProto {
+  reserved 12, 16 to 19;
+  reserved "v";
+
+  // Note: this enum is structurally identical to the OpSchema::AttrType
+  // enum defined in schema.h.  If you rev one, you likely need to rev the other.
+  enum AttributeType {
+    UNDEFINED = 0;
+    FLOAT = 1;
+    INT = 2;
+    STRING = 3;
+    TENSOR = 4;
+    GRAPH = 5;
+    SPARSE_TENSOR = 11;
+    TYPE_PROTO = 13;
+
+    FLOATS = 6;
+    INTS = 7;
+    STRINGS = 8;
+    TENSORS = 9;
+    GRAPHS = 10;
+    SPARSE_TENSORS = 12;
+    TYPE_PROTOS = 14;
+  }
+
+  // The name field MUST be present for this version of the IR.
+  string name = 1;           // namespace Attribute
+
+  // if ref_attr_name is not empty, ref_attr_name is the attribute name in parent function.
+  // In this case, this AttributeProto does not contain data, and it's a reference of attribute
+  // in parent scope.
+  // NOTE: This should ONLY be used in function (sub-graph). It's invalid to be used in main graph.
+  string ref_attr_name = 21;
+
+  // A human-readable documentation for this attribute. Markdown is allowed.
+  string doc_string = 13;
+
+  // The type field MUST be present for this version of the IR.
+  // For 0.0.1 versions of the IR, this field was not defined, and
+  // implementations needed to use has_field heuristics to determine
+  // which value field was in use.  For IR_VERSION 0.0.2 or later, this
+  // field MUST be set and match the f|i|s|t|... field in use.  This
+  // change was made to accommodate proto3 implementations.
+  AttributeType type = 20;   // discriminator that indicates which field below is in use
+
+  // Exactly ONE of the following fields must be present for this version of the IR
+  float f = 2;               // float
+  int64 i = 3;               // int
+  bytes s = 4;               // UTF-8 string
+  TensorProto t = 5;         // tensor value
+  GraphProto g = 6;          // graph
+  SparseTensorProto sparse_tensor = 22;  // sparse tensor value
+  // Do not use field below, it's deprecated.
+  // optional ValueProto v = 12;         // value - subsumes everything but graph
+  TypeProto tp = 14;          // type proto
+
+  repeated float floats = 7;          // list of floats
+  repeated int64 ints = 8;            // list of ints
+  repeated bytes strings = 9;         // list of UTF-8 strings
+  repeated TensorProto tensors = 10;  // list of tensors
+  repeated GraphProto graphs = 11;    // list of graph
+  repeated SparseTensorProto sparse_tensors = 23; // list of sparse tensors
+  repeated TypeProto type_protos = 15;// list of type protos
+}
+
+// Defines information on value, including the name, the type, and
+// the shape of the value.
+message ValueInfoProto {
+  // This field MUST be present in this version of the IR.
+  string name = 1;     // namespace Value
+  // This field MUST be present in this version of the IR for
+  // inputs and outputs of the top-level graph.
+  TypeProto type = 2;
+  // A human-readable documentation for this value. Markdown is allowed.
+  string doc_string = 3;
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 4;
+}
+
+// Nodes
+//
+// Computation graphs are made up of a DAG of nodes, which represent what is
+// commonly called a "layer" or "pipeline stage" in machine learning frameworks.
+//
+// For example, it can be a node of type "Conv" that takes in an image, a filter
+// tensor and a bias tensor, and produces the convolved output.
+message NodeProto {
+  repeated string input = 1;    // namespace Value
+  repeated string output = 2;   // namespace Value
+
+  // An optional identifier for this node in a graph.
+  // This field MAY be absent in this version of the IR.
+  string name = 3;     // namespace Node
+
+  // The symbolic identifier of the Operator to execute.
+  string op_type = 4;  // namespace Operator
+  // The domain of the OperatorSet that specifies the operator named by op_type.
+  string domain = 7;   // namespace Domain
+  // Overload identifier, used only to map this to a model-local function.
+  string overload = 8;
+
+  // Additional named attributes.
+  repeated AttributeProto attribute = 5;
+
+  // A human-readable documentation for this node. Markdown is allowed.
+  string doc_string = 6;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 9;
+
+  // Configuration of multi-device annotations.
+  repeated NodeDeviceConfigurationProto device_configurations = 10;
+}
+
+// IntIntListEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message IntIntListEntryProto {
+  int64 key = 1;
+  repeated int64 value = 2;
+};
+
+// Multi-device configuration proto for NodeProto.
+message NodeDeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // ID of the configuration. MUST match the name of a DeviceConfigurationProto.
+    string configuration_id = 1;
+    // Sharding spec for the node.
+    repeated ShardingSpecProto sharding_spec = 2;
+    // Pipeline stage of this node.
+    int32 pipeline_stage = 3;
+}
+
+// ShardingSpecProto: This describes the sharding spec for a specific
+// input or output tensor of a node.
+message ShardingSpecProto {
+  // This field MUST be present for this version of the IR.
+  // Identifies the input or output of the node that is being sharded.
+  // Required to match a name specified in the node's input or output list of ValueInfoProtos.
+  // It is called `logical tensor` in subsequent descriptions.
+  string tensor_name = 1;
+
+  // The following is the list of devices across which the logical
+  // tensor is sharded or replicated.
+  repeated int64 device = 2;
+
+  // Each element v in above field devices may represent either a
+  // device or a set of devices (when we want the same shard/tensor
+  // to be replicated across a subset of devices), as indicated by
+  // the following optional map. If the map contains an entry for v,
+  // then v represents a device group, and the map indicates the set
+  // of devices in that group.
+  repeated IntIntListEntryProto index_to_device_group_map = 3;
+
+  // The following is the sharded-shape of the tensor, consisting of
+  // the sharding-spec for each axis of the tensor.
+  repeated ShardedDimProto sharded_dim = 4;
+}
+
+// ShardedDimProto: This describes the sharding spec for a single
+// axis of a sharded tensor.
+message ShardedDimProto {
+  // This field MUST be present for this version of the IR.
+  // The axis this sharding corresponds to. Must be in the range of
+  // [-r, r - 1], where r is the rank of the tensor. Negative axis values means
+  // counting from the back.
+  int64 axis = 1;
+
+  // Describes how the tensor on the provided axis is sharded.
+  // The common-case is described by a single instance of SimpleShardedDimProto.
+  // Multiple instances can be used to handle cases where a sharded
+  // tensor is reshaped, fusing multiple axes into one.
+  repeated SimpleShardedDimProto simple_sharding = 2;
+}
+
+// SimpleShardedDimProto: Indicates that N blocks are divided into M shards.
+// N is allowed to be symbolic where M is required to be a constant.
+message SimpleShardedDimProto {
+    // Dimension value to be sharded.
+    oneof dim {
+        int64 dim_value = 1;
+        string dim_param = 2;
+    }
+
+    // This field MUST be present for this version of the IR.
+    // Number of shards to split dim into.
+    int64 num_shards = 3;
+}
+
+// Training information
+// TrainingInfoProto stores information for training a model.
+// In particular, this defines two functionalities: an initialization-step
+// and a training-algorithm-step. Initialization resets the model
+// back to its original state as if no training has been performed.
+// Training algorithm improves the model based on input data.
+//
+// The semantics of the initialization-step is that the initializers
+// in ModelProto.graph and in TrainingInfoProto.algorithm are first
+// initialized as specified by the initializers in the graph, and then
+// updated by the "initialization_binding" in every instance in
+// ModelProto.training_info.
+//
+// The field "algorithm" defines a computation graph which represents a
+// training algorithm's step. After the execution of a
+// TrainingInfoProto.algorithm, the initializers specified by "update_binding"
+// may be immediately updated. If the targeted training algorithm contains
+// consecutive update steps (such as block coordinate descent methods),
+// the user needs to create a TrainingInfoProto for each step.
+message TrainingInfoProto {
+  // This field describes a graph to compute the initial tensors
+  // upon starting the training process. Initialization graph has no input
+  // and can have multiple outputs. Usually, trainable tensors in neural
+  // networks are randomly initialized. To achieve that, for each tensor,
+  // the user can put a random number operator such as RandomNormal or
+  // RandomUniform in TrainingInfoProto.initialization.node and assign its
+  // random output to the specific tensor using "initialization_binding".
+  // This graph can also set the initializers in "algorithm" in the same
+  // TrainingInfoProto; a use case is resetting the number of training
+  // iteration to zero.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Thus, no initializer would be changed by default.
+  GraphProto initialization = 1;
+
+  // This field represents a training algorithm step. Given required inputs,
+  // it computes outputs to update initializers in its own or inference graph's
+  // initializer lists. In general, this field contains loss node, gradient node,
+  // optimizer node, increment of iteration count.
+  //
+  // An execution of the training algorithm step is performed by executing the
+  // graph obtained by combining the inference graph (namely "ModelProto.graph")
+  // and the "algorithm" graph. That is, the actual
+  // input/initializer/output/node/value_info/sparse_initializer list of
+  // the training graph is the concatenation of
+  // "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer"
+  // and "algorithm.input/initializer/output/node/value_info/sparse_initializer"
+  // in that order. This combined graph must satisfy the normal ONNX conditions.
+  // Now, let's provide a visualization of graph combination for clarity.
+  // Let the inference graph (i.e., "ModelProto.graph") be
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d
+  // and the "algorithm" graph be
+  //    tensor_d -> Add -> tensor_e
+  // The combination process results
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add -> tensor_e
+  //
+  // Notice that an input of a node in the "algorithm" graph may reference the
+  // output of a node in the inference graph (but not the other way round). Also, inference
+  // node cannot reference inputs of "algorithm". With these restrictions, inference graph
+  // can always be run independently without training information.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Evaluating the default training step never
+  // update any initializers.
+  GraphProto algorithm = 2;
+
+  // This field specifies the bindings from the outputs of "initialization" to
+  // some initializers in "ModelProto.graph.initializer" and
+  // the "algorithm.initializer" in the same TrainingInfoProto.
+  // See "update_binding" below for details.
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "initialization".
+  repeated StringStringEntryProto initialization_binding = 3;
+
+  // Gradient-based training is usually an iterative procedure. In one gradient
+  // descent iteration, we apply
+  //
+  // x = x - r * g
+  //
+  // where "x" is the optimized tensor, "r" stands for learning rate, and "g" is
+  // gradient of "x" with respect to a chosen loss. To avoid adding assignments
+  // into the training graph, we split the update equation into
+  //
+  // y = x - r * g
+  // x = y
+  //
+  // The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To
+  // tell that "y" should be assigned to "x", the field "update_binding" may
+  // contain a key-value pair of strings, "x" (key of StringStringEntryProto)
+  // and "y" (value of StringStringEntryProto).
+  // For a neural network with multiple trainable (mutable) tensors, there can
+  // be multiple key-value pairs in "update_binding".
+  //
+  // The initializers appears as keys in "update_binding" are considered
+  // mutable variables. This implies some behaviors
+  // as described below.
+  //
+  //  1. We have only unique keys in all "update_binding"s so that two
+  //     variables may not have the same name. This ensures that one
+  //     variable is assigned up to once.
+  //  2. The keys must appear in names of "ModelProto.graph.initializer" or
+  //     "TrainingInfoProto.algorithm.initializer".
+  //  3. The values must be output names of "algorithm" or "ModelProto.graph.output".
+  //  4. Mutable variables are initialized to the value specified by the
+  //     corresponding initializer, and then potentially updated by
+  //     "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s.
+  //
+  // This field usually contains names of trainable tensors
+  // (in ModelProto.graph), optimizer states such as momentums in advanced
+  // stochastic gradient methods (in TrainingInfoProto.graph),
+  // and number of training iterations (in TrainingInfoProto.graph).
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "algorithm".
+  repeated StringStringEntryProto update_binding = 4;
+}
+
+// Models
+//
+// ModelProto is a top-level file/container format for bundling a ML model and
+// associating its computation graph with metadata.
+//
+// The semantics of the model are described by the associated GraphProto's.
+message ModelProto {
+  // The version of the IR this model targets. See Version enum above.
+  // This field MUST be present.
+  int64 ir_version = 1;
+
+  // The OperatorSets this model relies on.
+  // All ModelProtos MUST have at least one entry that
+  // specifies which version of the ONNX OperatorSet is
+  // being imported.
+  //
+  // All nodes in the ModelProto's graph will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets.
+  repeated OperatorSetIdProto opset_import = 8;
+
+  // The name of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  string producer_name = 2;
+
+  // The version of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  string producer_version = 3;
+
+  // Domain name of the model.
+  // We use reverse domain names as name space indicators. For example:
+  // `com.facebook.fair` or `com.microsoft.cognitiveservices`
+  //
+  // Together with `model_version` and GraphProto.name, this forms the unique identity of
+  // the graph.
+  string domain = 4;
+
+  // The version of the graph encoded. See Version enum below.
+  int64 model_version = 5;
+
+  // A human-readable documentation for this model. Markdown is allowed.
+  string doc_string = 6;
+
+  // The parameterized graph that is evaluated to execute the model.
+  GraphProto graph = 7;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+
+  // Training-specific information. Sequentially executing all stored
+  // `TrainingInfoProto.algorithm`s and assigning their outputs following
+  // the corresponding `TrainingInfoProto.update_binding`s is one training
+  // iteration. Similarly, to initialize the model
+  // (as if training hasn't happened), the user should sequentially execute
+  // all stored `TrainingInfoProto.initialization`s and assigns their outputs
+  // using `TrainingInfoProto.initialization_binding`s.
+  //
+  // If this field is empty, the training behavior of the model is undefined.
+  repeated TrainingInfoProto training_info = 20;
+
+  // A list of function protos local to the model.
+  //
+  // The (domain, name, overload) tuple must be unique across the function protos in this list.
+  // In case of any conflicts the behavior (whether the model local functions are given higher priority,
+  // or standard operator sets are given higher priority or this is treated as error) is defined by
+  // the runtimes.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto and other model local FunctionProtos.
+  // Example, if same operator set say 'A' is imported by a FunctionProto and ModelProto
+  // or by 2 FunctionProtos then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same for every node in the function body.
+  //
+  // One FunctionProto can reference other FunctionProto in the model, however, recursive reference
+  // is not allowed.
+  repeated FunctionProto functions = 25;
+
+  // Describes different target configurations for a multi-device use case.
+  // A model MAY describe multiple multi-device configurations for execution.
+  repeated DeviceConfigurationProto configuration = 26;
+};
+
+// DeviceConfigurationProto describes a multi-device configuration for a model.
+message DeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // Name of the configuration.
+    string name = 1;
+    // This field MUST be present for this version of the IR.
+    // Number of devices inside this configuration.
+    int32 num_devices = 2;
+    // Optional names of the devices. MUST be length of num_devices if provided.
+    repeated string device = 3;
+}
+
+// StringStringEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message StringStringEntryProto {
+  string key = 1;
+  string value = 2;
+};
+
+message TensorAnnotation {
+  string tensor_name = 1;
+  // <key, value> pairs to annotate tensor specified by <tensor_name> above.
+  // The keys used in the mapping below must be pre-defined in ONNX spec.
+  // For example, for 8-bit linear quantization case, 'SCALE_TENSOR', 'ZERO_POINT_TENSOR' will be pre-defined as
+  // quantization parameter keys.
+  repeated StringStringEntryProto quant_parameter_tensor_names = 2;
+}
+
+
+
+// Graphs
+//
+// A graph defines the computational logic of a model and is comprised of a parameterized
+// list of nodes that form a directed acyclic graph based on their inputs and outputs.
+// This is the equivalent of the "network" or "graph" in many deep learning
+// frameworks.
+message GraphProto {
+  // The nodes in the graph, sorted topologically.
+  repeated NodeProto node = 1;
+
+  // The name of the graph.
+  string name = 2;   // namespace Graph
+
+  // A list of named tensor values, used to specify constant inputs of the graph.
+  // Each initializer (both TensorProto as well SparseTensorProto) MUST have a name.
+  // The name MUST be unique across both initializer and sparse_initializer,
+  // but the name MAY also appear in the input list.
+  repeated TensorProto initializer = 5;
+
+  // Initializers (see above) stored in sparse format.
+  repeated SparseTensorProto sparse_initializer = 15;
+
+  // A human-readable documentation for this graph. Markdown is allowed.
+  string doc_string = 10;
+
+  // The inputs and outputs of the graph.
+  repeated ValueInfoProto input = 11;
+  repeated ValueInfoProto output = 12;
+
+  // Information for the values in the graph. The ValueInfoProto.name's
+  // must be distinct. It is optional for a value to appear in value_info list.
+  repeated ValueInfoProto value_info = 13;
+
+  // This field carries information to indicate the mapping among a tensor and its
+  // quantization parameter tensors. For example:
+  // For tensor 'a', it may have {'SCALE_TENSOR', 'a_scale'} and {'ZERO_POINT_TENSOR', 'a_zero_point'} annotated,
+  // which means, tensor 'a_scale' and tensor 'a_zero_point' are scale and zero point of tensor 'a' in the model.
+  repeated TensorAnnotation quantization_annotation = 14;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+
+  reserved 3, 4, 6 to 9;
+  reserved "ir_version", "producer_version", "producer_tag", "domain";
+}
+
+// Tensors
+//
+// A serialized tensor value.
+message TensorProto {
+  enum DataType {
+    UNDEFINED = 0;
+    // Basic types.
+    FLOAT = 1;   // float
+    UINT8 = 2;   // uint8_t
+    INT8 = 3;    // int8_t
+    UINT16 = 4;  // uint16_t
+    INT16 = 5;   // int16_t
+    INT32 = 6;   // int32_t
+    INT64 = 7;   // int64_t
+    STRING = 8;  // string
+    BOOL = 9;    // bool
+
+    // IEEE754 half-precision floating-point format (16 bits wide).
+    // This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
+    FLOAT16 = 10;
+
+    DOUBLE = 11;
+    UINT32 = 12;
+    UINT64 = 13;
+    COMPLEX64 = 14;     // complex with float32 real and imaginary components
+    COMPLEX128 = 15;    // complex with float64 real and imaginary components
+
+    // Non-IEEE floating-point format based on IEEE754 single-precision
+    // floating-point number truncated to 16 bits.
+    // This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
+    BFLOAT16 = 16;
+
+    // Non-IEEE floating-point format based on papers
+    // FP8 Formats for Deep Learning, https://arxiv.org/abs/2209.05433,
+    // 8-bit Numerical Formats For Deep Neural Networks, https://arxiv.org/pdf/2206.02915.pdf.
+    // Operators supported FP8 are Cast, CastLike, QuantizeLinear, DequantizeLinear.
+    // The computation usually happens inside a block quantize / dequantize
+    // fused by the runtime.
+    FLOAT8E4M3FN = 17;    // float 8, mostly used for coefficients, supports nan, not inf
+    FLOAT8E4M3FNUZ = 18;  // float 8, mostly used for coefficients, supports nan, not inf, no negative zero
+    FLOAT8E5M2 = 19;      // follows IEEE 754, supports nan, inf, mostly used for gradients
+    FLOAT8E5M2FNUZ = 20;  // follows IEEE 754, supports nan, not inf, mostly used for gradients, no negative zero
+
+    // 4-bit integer data types
+    UINT4 = 21;  // Unsigned integer in range [0, 15]
+    INT4 = 22;   // Signed integer in range [-8, 7], using two's-complement representation
+
+    // 4-bit floating point data types
+    FLOAT4E2M1 = 23;
+
+    // E8M0 type used as the scale for microscaling (MX) formats:
+    // https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
+    FLOAT8E8M0 = 24;
+
+    // 2-bit integer data type
+    UINT2 = 25; // Unsigned integer in range [0, 3]
+    INT2 = 26;  // Signed integer in range [-2, 1], using two's complement representation
+
+    // Future extensions go here.
+  }
+
+  // The shape of the tensor.
+  repeated int64 dims = 1;
+
+  // The data type of the tensor.
+  // This field MUST have a valid TensorProto.DataType value
+  int32 data_type = 2;
+
+  // For very large tensors, we may want to store them in chunks, in which
+  // case the following fields will specify the segment that is stored in
+  // the current TensorProto.
+  message Segment {
+    int64 begin = 1;
+    int64 end = 2;
+  }
+  Segment segment = 3;
+
+  // Tensor content must be organized in row-major order.
+  //
+  // Depending on the data_type field, exactly one of the fields below with
+  // name ending in _data is used to store the elements of the tensor.
+
+  // For float and complex64 values
+  // Complex64 tensors are encoded as a single array of floats,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
+  repeated float float_data = 4 [packed = true];
+
+  // For int32, uint8, int8, uint16, int16, uint4, int4, uint2, int2, bool, (b)float16, float8, and float4:
+  // - (b)float16 and float8 values MUST be converted bit-wise into an unsigned integer
+  //   representation before being written to the buffer.
+  // - Each pair of uint4, int4, and float4 values MUST be packed as two 4-bit elements into a single byte.
+  //   The first element is stored in the 4 least significant bits (LSB),
+  //   and the second element is stored in the 4 most significant bits (MSB).
+  // - Each group of four uint2, int2 values MUST be packed as four 2-bit elements into a single byte.
+  //   The elements are packed from LSB to MSB, with the first element in bits 0-1, second element in bits 2-3,
+  //   third element in bits 4-5, and fourth element in bits 6-7.
+  //
+  // Consequently:
+  // - For data types with a bit-width of 8 or greater, each `int32_data` stores one element.
+  // - For 4-bit data types, each `int32_data` stores two elements.
+  // - For 2-bit data types, each `int32_data` stores four elements.
+  //
+  // When this field is present, the data_type field MUST be
+  // INT32, INT16, INT8, INT4, INT2, UINT16, UINT8, UINT4, UINT2, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ, FLOAT8E8M0, FLOAT4E2M1
+  repeated int32 int32_data = 5 [packed = true];
+
+  // For strings.
+  // Each element of string_data is a UTF-8 encoded Unicode
+  // string. No trailing null, no leading BOM. The protobuf "string"
+  // scalar type is not used to match ML community conventions.
+  // When this field is present, the data_type field MUST be STRING
+  repeated bytes string_data = 6;
+
+  // For int64.
+  // When this field is present, the data_type field MUST be INT64
+  repeated int64 int64_data = 7 [packed = true];
+
+  // Optionally, a name for the tensor.
+  string name = 8; // namespace Value
+
+  // A human-readable documentation for this tensor. Markdown is allowed.
+  string doc_string = 12;
+
+  // Serializations can either use one of the fields above, or use this
+  // raw bytes field. The only exception is the string case, where one is
+  // required to store the content in the repeated bytes string_data field.
+  //
+  // When this raw_data field is used to store tensor value, elements MUST
+  // be stored in as fixed-width, little-endian order.
+  // Floating-point data types MUST be stored in IEEE 754 format.
+  // Complex64 elements must be written as two consecutive FLOAT values, real component first.
+  // Complex128 elements must be written as two consecutive DOUBLE values, real component first.
+  // Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
+  // uint4 and int4 values must be packed to 4bitx2, the first element is stored in the 4 LSB and the second element is stored in the 4 MSB.
+  // uint2 and int2 values must be packed to 2bitx4, with elements packed from LSB to MSB in a single byte as: x0 | (x1 << 2) | (x2 << 4) | (x3 << 6)
+  // where x0, x1, x2, x3 are consecutive elements.
+  //
+  // Note: the advantage of specific field rather than the raw_data field is
+  // that in some cases (e.g. int data), protobuf does a better packing via
+  // variable length storage, and may lead to smaller binary footprint.
+  // When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
+  bytes raw_data = 9;
+
+  // Data can be stored inside the protobuf file using type-specific fields or raw_data.
+  // Alternatively, raw bytes data can be stored in an external file, using the external_data field.
+  // external_data stores key-value pairs describing data location. Recognized keys are:
+  // - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
+  //                           protobuf model was stored
+  // - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
+  //                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
+  // - "length" (optional) - number of bytes containing data. Integer stored as string.
+  // - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
+  repeated StringStringEntryProto external_data = 13;
+
+  // Location of the data for this tensor. MUST be one of:
+  // - DEFAULT - data stored inside the protobuf message. Data is stored in raw_data (if set) otherwise in type-specified field.
+  // - EXTERNAL - data stored in an external location as described by external_data field.
+  enum DataLocation {
+    DEFAULT = 0;
+    EXTERNAL = 1;
+  }
+
+  // If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
+  DataLocation data_location = 14;
+
+  // For double
+  // Complex128 tensors are encoded as a single array of doubles,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
+  repeated double double_data = 10 [packed = true];
+
+  // For uint64 and uint32 values
+  // When this field is present, the data_type field MUST be
+  // UINT32 or UINT64
+  repeated uint64 uint64_data = 11 [packed = true];
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+}
+
+// A serialized sparse-tensor value
+message SparseTensorProto {
+  // The sequence of non-default values are encoded as a tensor of shape [NNZ].
+  // The default-value is zero for numeric tensors, and empty-string for string tensors.
+  // values must have a non-empty name present which serves as a name for SparseTensorProto
+  // when used in sparse_initializer list.
+  TensorProto values = 1;
+
+  // The indices of the non-default values, which may be stored in one of two formats.
+  // (a) Indices can be a tensor of shape [NNZ, rank] with the [i,j]-th value
+  // corresponding to the j-th index of the i-th value (in the values tensor).
+  // (b) Indices can be a tensor of shape [NNZ], in which case the i-th value
+  // must be the linearized-index of the i-th value (in the values tensor).
+  // The linearized-index can be converted into an index tuple (k_1,...,k_rank)
+  // using the shape provided below.
+  // The indices must appear in ascending order without duplication.
+  // In the first format, the ordering is lexicographic-ordering:
+  // e.g., index-value [1,4] must appear before [2,1]
+  TensorProto indices = 2;
+
+  // The shape of the underlying dense-tensor: [dim_1, dim_2, ... dim_rank]
+  repeated int64 dims = 3;
+}
+
+// Defines a tensor shape. A dimension can be either an integer value
+// or a symbolic variable. A symbolic variable represents an unknown
+// dimension.
+message TensorShapeProto {
+  message Dimension {
+    oneof value {
+      int64 dim_value = 1;
+      string dim_param = 2;   // namespace Shape
+    };
+    // Standard denotation can optionally be used to denote tensor
+    // dimensions with standard semantic descriptions to ensure
+    // that operations are applied to the correct axis of a tensor.
+    // Refer to https://github.com/onnx/onnx/blob/main/docs/DimensionDenotation.md#denotation-definition
+    // for pre-defined dimension denotations.
+    string denotation = 3;
+  };
+  repeated Dimension dim = 1;
+}
+
+// Types
+//
+// The standard ONNX data types.
+message TypeProto {
+
+  message Tensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    int32 elem_type = 1;
+    TensorShapeProto shape = 2;
+  }
+
+  // repeated T
+  message Sequence {
+    // The type and optional shape of each element of the sequence.
+    // This field MUST be present for this version of the IR.
+    TypeProto elem_type = 1;
+  };
+
+  // map<K,V>
+  message Map {
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    // This field MUST refer to an integral type ([U]INT{8|16|32|64}) or STRING
+    int32 key_type = 1;
+    // This field MUST be present for this version of the IR.
+    TypeProto value_type = 2;
+  };
+
+  // wrapper for Tensor, Sequence, or Map
+  message Optional {
+    // The type and optional shape of the element wrapped.
+    // This field MUST be present for this version of the IR.
+    // Possible values correspond to OptionalProto.DataType enum
+    TypeProto elem_type = 1;
+  };
+
+
+  message SparseTensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    int32 elem_type = 1;
+    TensorShapeProto shape = 2;
+  }
+
+
+  message Opaque {
+    // When missing, the domain is the same as the model's.
+    string domain = 1;
+    // The name is optional but significant when provided.
+    string name = 2;
+    // parameters that help defining the type
+    // DEPRECATED do not use.
+    // repeated TypeProto parameters = 3;
+  }
+
+
+  oneof value {
+    // The type of a tensor.
+    Tensor tensor_type = 1;
+
+    // NOTE:  DNN-only implementations of ONNX MAY elect to not support non-tensor values
+    //        as input and output to graphs and nodes. These types are needed to naturally
+    //        support classical ML operators.  DNN operators SHOULD restrict their input
+    //        and output types to tensors.
+
+    // The type of a sequence.
+    Sequence sequence_type = 4;
+
+    // The type of a map.
+    Map map_type = 5;
+
+    // The type of an optional.
+    Optional optional_type = 9;
+
+
+    // Type of the sparse tensor
+    SparseTensor sparse_tensor_type = 8;
+
+
+    Opaque opaque_type = 7;
+
+  }
+
+  // An optional denotation can be used to denote the whole
+  // type with a standard semantic description as to what is
+  // stored inside. Refer to https://github.com/onnx/onnx/blob/main/docs/TypeDenotation.md#type-denotation-definition
+  // for pre-defined type denotations.
+  string denotation = 6;
+}
+
+// Operator Sets
+//
+// OperatorSets are uniquely identified by a (domain, opset_version) pair.
+message OperatorSetIdProto {
+  // The domain of the operator set being identified.
+  // The empty string ("") or absence of this field implies the operator
+  // set that is defined as part of the ONNX specification.
+  // This field MUST be present in this version of the IR when referring to any other operator set.
+  string domain = 1;
+
+  // The version of the operator set being identified.
+  // This field MUST be present in this version of the IR.
+  int64 version = 2;
+}
+
+// Operator/function status.
+enum OperatorStatus {
+    EXPERIMENTAL = 0;
+    STABLE = 1;
+}
+
+message FunctionProto {
+  // The name of the function, similar to op_type in NodeProto.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  string name = 1;
+
+  // Deprecated since IR Version 8
+  // optional int64 since_version = 2;
+  reserved 2;
+  reserved "since_version";
+
+  // Deprecated since IR Version 8
+  // optional OperatorStatus status = 3;
+  reserved 3;
+  reserved "status";
+
+  // The inputs and outputs of the function.
+  repeated string input = 4;
+  repeated string output = 5;
+
+  // The attribute parameters of the function.
+  // It is for function parameters without default values.
+  repeated string attribute = 6;
+
+  // The attribute protos of the function.
+  // It is for function attributes with default values.
+  // A function attribute shall be represented either as
+  // a string attribute or an AttributeProto, not both.
+  repeated AttributeProto attribute_proto = 11;
+
+  // The nodes in the function.
+  repeated NodeProto node = 7;
+  // A human-readable documentation for this function. Markdown is allowed.
+  string doc_string = 8;
+
+  // The OperatorSets this function body (graph) relies on.
+  //
+  // All nodes in the function body (graph) will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets. This means at most one version can be relied
+  // for one domain.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto. Example, if same operator set say 'A' is imported by FunctionProto
+  // and ModelProto then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same.
+
+  repeated OperatorSetIdProto opset_import = 9;
+
+  // The domain which this function belongs to.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  string domain = 10;
+
+  // The overload identifier of the function.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  string overload = 13;
+
+  // Information for the values in the function. The ValueInfoProto.name's
+  // must be distinct and refer to names in the function (including inputs,
+  // outputs, and intermediate values). It is optional for a value to appear
+  // in value_info list.
+  repeated ValueInfoProto value_info = 12;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+}
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx-operators-ml.proto b/onnx/onnx-operators-ml.proto
new file mode 100644
index 0000000..825c884
--- /dev/null
+++ b/onnx/onnx-operators-ml.proto
@@ -0,0 +1,136 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// Copyright (c) ONNX Project Contributors.
+// Licensed under the Apache-2.0 license.
+
+syntax = "proto2";
+
+package onnx;
+import "onnx/onnx-ml.proto";
+
+//
+// This file contains the proto definitions for OperatorSetProto and
+// OperatorProto.  OperatorSetProtos are used to describe a versioned
+// set of operators that can be used by a ModelProto.
+//
+// Like ModelProto, OperatorSetProto is defined as a top-level file/wire
+// format, however their usage is different.
+//
+// ModelProto files are used to describe executable graphs that can be
+// executed directly by a framework, runtime, or engine.
+//
+// OperatorSetProto files are used to describe a set of operators that are
+// available in a given environment.  The file TBD.TBD is the OperatorSetProto
+// that describes the ONNX standard operators.
+//
+
+// An OperatorProto represents the immutable specification of the signature
+// and semantics of an operator.
+//
+// Operators are declared as part of an OperatorSet, which also defines the
+// domain name for the set.
+//
+// Operators are uniquely identified by a three part identifier
+//   (domain, op_type, since_version)
+// where
+//   *domain* is the domain of an operator set that
+//      contains this operator specification.
+//
+//   *op_type* is the name of the operator as referenced by a
+//      NodeProto.op_type
+//
+//   *since_version* is the version of the operator set that
+//      this operator was initially declared in.
+//
+message OperatorProto {
+  // The name of the operator within a domain.
+  // This field MUST be present in this version of the IR.
+  optional string op_type = 1;
+
+  // The version of the operator set that first introduced this
+  // operator. This value MUST be the same value as the
+  // opset_version of the operator set that first published this operator.
+  // Subsequent versions of the operator set MUST NOT alter the signature
+  // or semantics of the operator once published as STABLE.
+  // This field MUST be present in this version of the IR.
+  optional int64 since_version = 2;
+
+  // This field indicates whether the syntax, semantics, or presence
+  // of this operator is in an experimental or stable stage. Once an
+  // operator is published as STABLE, it's syntax and semantics MUST NOT
+  // change in subsequent versions of the operator set.
+  // When an operator is published as EXPERIMENTAL, the syntax and semantics
+  // of the operator MAY change across operator set versions.
+  // Operators "become" stable by deprecating the experimental version and
+  // introducing a new stable operator with the same op_type.
+  optional OperatorStatus status = 3;
+
+  // Eventually we will declare the signature of the operator here
+
+  // A human-readable documentation for this operator. Markdown is allowed.
+  optional string doc_string = 10;
+}
+
+// An OperatorSetProto represents an immutable set of immutable operator
+// specifications.
+//
+// The domain of the set (OperatorSetProto.domain) is a reverse-DNS name
+// that disambiguates operator sets defined by independent entities.
+//
+// The version of the set (opset_version) is a monotonically increasing
+// integer that indicates changes to the membership of the operator set.
+//
+//
+// Operator sets are uniquely identified by a two part identifier (domain, opset_version)
+//
+// Like ModelProto, OperatorSetProto is intended as a top-level file/wire format,
+// and thus has the standard format headers in addition to the operator set information.
+//
+message OperatorSetProto {
+  // All OperatorSetProtos start with a distinguished byte sequence to disambiguate
+  // protobuf files containing OperatorSets from other content.
+  // This field MUST be "ONNXOPSET"
+  // This field MUST be present in this version of the IR
+  optional string magic = 1;
+
+  // All OperatorSetProtos indicate the version of the IR syntax and semantics
+  // they adhere to. It is always IR_VERSION.
+  // This field MUST be present in this version of the IR
+  optional int64 ir_version = 2;
+
+  // The prerelease component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  optional string ir_version_prerelease = 3;
+
+  // The build metadata component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  optional string ir_build_metadata = 7;
+
+  // Domain name of the operator set, in reverse DNS form (e.g., com.acme.dnnops).
+  optional string domain = 4;
+
+  // The version of the set of operators. This is a simple int value
+  // that is monotonically increasing as new versions of the operator set
+  // are published. All operators in this set MUST have since_version
+  // <= opset_version.
+  optional int64 opset_version = 5;
+
+  // A human-readable documentation for this set of operators. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // The operators specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos in operator
+  repeated OperatorProto operator = 8;
+
+  // The functions specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos/FunctionProtos in operator/functions
+  repeated FunctionProto functions = 9;
+}
+
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx-operators-ml.proto3 b/onnx/onnx-operators-ml.proto3
new file mode 100644
index 0000000..5af19f3
--- /dev/null
+++ b/onnx/onnx-operators-ml.proto3
@@ -0,0 +1,136 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// Copyright (c) ONNX Project Contributors.
+// Licensed under the Apache-2.0 license.
+
+syntax = "proto3";
+
+package onnx;
+import "onnx/onnx-ml.proto3";
+
+//
+// This file contains the proto definitions for OperatorSetProto and
+// OperatorProto.  OperatorSetProtos are used to describe a versioned
+// set of operators that can be used by a ModelProto.
+//
+// Like ModelProto, OperatorSetProto is defined as a top-level file/wire
+// format, however their usage is different.
+//
+// ModelProto files are used to describe executable graphs that can be
+// executed directly by a framework, runtime, or engine.
+//
+// OperatorSetProto files are used to describe a set of operators that are
+// available in a given environment.  The file TBD.TBD is the OperatorSetProto
+// that describes the ONNX standard operators.
+//
+
+// An OperatorProto represents the immutable specification of the signature
+// and semantics of an operator.
+//
+// Operators are declared as part of an OperatorSet, which also defines the
+// domain name for the set.
+//
+// Operators are uniquely identified by a three part identifier
+//   (domain, op_type, since_version)
+// where
+//   *domain* is the domain of an operator set that
+//      contains this operator specification.
+//
+//   *op_type* is the name of the operator as referenced by a
+//      NodeProto.op_type
+//
+//   *since_version* is the version of the operator set that
+//      this operator was initially declared in.
+//
+message OperatorProto {
+  // The name of the operator within a domain.
+  // This field MUST be present in this version of the IR.
+  string op_type = 1;
+
+  // The version of the operator set that first introduced this
+  // operator. This value MUST be the same value as the
+  // opset_version of the operator set that first published this operator.
+  // Subsequent versions of the operator set MUST NOT alter the signature
+  // or semantics of the operator once published as STABLE.
+  // This field MUST be present in this version of the IR.
+  int64 since_version = 2;
+
+  // This field indicates whether the syntax, semantics, or presence
+  // of this operator is in an experimental or stable stage. Once an
+  // operator is published as STABLE, it's syntax and semantics MUST NOT
+  // change in subsequent versions of the operator set.
+  // When an operator is published as EXPERIMENTAL, the syntax and semantics
+  // of the operator MAY change across operator set versions.
+  // Operators "become" stable by deprecating the experimental version and
+  // introducing a new stable operator with the same op_type.
+  OperatorStatus status = 3;
+
+  // Eventually we will declare the signature of the operator here
+
+  // A human-readable documentation for this operator. Markdown is allowed.
+  string doc_string = 10;
+}
+
+// An OperatorSetProto represents an immutable set of immutable operator
+// specifications.
+//
+// The domain of the set (OperatorSetProto.domain) is a reverse-DNS name
+// that disambiguates operator sets defined by independent entities.
+//
+// The version of the set (opset_version) is a monotonically increasing
+// integer that indicates changes to the membership of the operator set.
+//
+//
+// Operator sets are uniquely identified by a two part identifier (domain, opset_version)
+//
+// Like ModelProto, OperatorSetProto is intended as a top-level file/wire format,
+// and thus has the standard format headers in addition to the operator set information.
+//
+message OperatorSetProto {
+  // All OperatorSetProtos start with a distinguished byte sequence to disambiguate
+  // protobuf files containing OperatorSets from other content.
+  // This field MUST be "ONNXOPSET"
+  // This field MUST be present in this version of the IR
+  string magic = 1;
+
+  // All OperatorSetProtos indicate the version of the IR syntax and semantics
+  // they adhere to. It is always IR_VERSION.
+  // This field MUST be present in this version of the IR
+  int64 ir_version = 2;
+
+  // The prerelease component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  string ir_version_prerelease = 3;
+
+  // The build metadata component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  string ir_build_metadata = 7;
+
+  // Domain name of the operator set, in reverse DNS form (e.g., com.acme.dnnops).
+  string domain = 4;
+
+  // The version of the set of operators. This is a simple int value
+  // that is monotonically increasing as new versions of the operator set
+  // are published. All operators in this set MUST have since_version
+  // <= opset_version.
+  int64 opset_version = 5;
+
+  // A human-readable documentation for this set of operators. Markdown is allowed.
+  string doc_string = 6;
+
+  // The operators specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos in operator
+  repeated OperatorProto operator = 8;
+
+  // The functions specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos/FunctionProtos in operator/functions
+  repeated FunctionProto functions = 9;
+}
+
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx-operators.in.proto b/onnx/onnx-operators.in.proto
new file mode 100644
index 0000000..8fcc7dd
--- /dev/null
+++ b/onnx/onnx-operators.in.proto
@@ -0,0 +1,131 @@
+// Copyright (c) ONNX Project Contributors.
+// Licensed under the Apache-2.0 license.
+
+syntax = "proto2";
+
+package {PACKAGE_NAME};
+// #if ONNX-ML
+import "onnx/onnx-ml.proto";
+// #else
+import "onnx/onnx.proto";
+// #endif
+
+//
+// This file contains the proto definitions for OperatorSetProto and
+// OperatorProto.  OperatorSetProtos are used to describe a versioned
+// set of operators that can be used by a ModelProto.
+//
+// Like ModelProto, OperatorSetProto is defined as a top-level file/wire
+// format, however their usage is different.
+//
+// ModelProto files are used to describe executable graphs that can be
+// executed directly by a framework, runtime, or engine.
+//
+// OperatorSetProto files are used to describe a set of operators that are
+// available in a given environment.  The file TBD.TBD is the OperatorSetProto
+// that describes the ONNX standard operators.
+//
+
+// An OperatorProto represents the immutable specification of the signature
+// and semantics of an operator.
+//
+// Operators are declared as part of an OperatorSet, which also defines the
+// domain name for the set.
+//
+// Operators are uniquely identified by a three part identifier
+//   (domain, op_type, since_version)
+// where
+//   *domain* is the domain of an operator set that
+//      contains this operator specification.
+//
+//   *op_type* is the name of the operator as referenced by a
+//      NodeProto.op_type
+//
+//   *since_version* is the version of the operator set that
+//      this operator was initially declared in.
+//
+message OperatorProto {
+  // The name of the operator within a domain.
+  // This field MUST be present in this version of the IR.
+  optional string op_type = 1;
+
+  // The version of the operator set that first introduced this
+  // operator. This value MUST be the same value as the
+  // opset_version of the operator set that first published this operator.
+  // Subsequent versions of the operator set MUST NOT alter the signature
+  // or semantics of the operator once published as STABLE.
+  // This field MUST be present in this version of the IR.
+  optional int64 since_version = 2;
+
+  // This field indicates whether the syntax, semantics, or presence
+  // of this operator is in an experimental or stable stage. Once an
+  // operator is published as STABLE, it's syntax and semantics MUST NOT
+  // change in subsequent versions of the operator set.
+  // When an operator is published as EXPERIMENTAL, the syntax and semantics
+  // of the operator MAY change across operator set versions.
+  // Operators "become" stable by deprecating the experimental version and
+  // introducing a new stable operator with the same op_type.
+  optional OperatorStatus status = 3;
+
+  // Eventually we will declare the signature of the operator here
+
+  // A human-readable documentation for this operator. Markdown is allowed.
+  optional string doc_string = 10;
+}
+
+// An OperatorSetProto represents an immutable set of immutable operator
+// specifications.
+//
+// The domain of the set (OperatorSetProto.domain) is a reverse-DNS name
+// that disambiguates operator sets defined by independent entities.
+//
+// The version of the set (opset_version) is a monotonically increasing
+// integer that indicates changes to the membership of the operator set.
+//
+//
+// Operator sets are uniquely identified by a two part identifier (domain, opset_version)
+//
+// Like ModelProto, OperatorSetProto is intended as a top-level file/wire format,
+// and thus has the standard format headers in addition to the operator set information.
+//
+message OperatorSetProto {
+  // All OperatorSetProtos start with a distinguished byte sequence to disambiguate
+  // protobuf files containing OperatorSets from other content.
+  // This field MUST be "ONNXOPSET"
+  // This field MUST be present in this version of the IR
+  optional string magic = 1;
+
+  // All OperatorSetProtos indicate the version of the IR syntax and semantics
+  // they adhere to. It is always IR_VERSION.
+  // This field MUST be present in this version of the IR
+  optional int64 ir_version = 2;
+
+  // The prerelease component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  optional string ir_version_prerelease = 3;
+
+  // The build metadata component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  optional string ir_build_metadata = 7;
+
+  // Domain name of the operator set, in reverse DNS form (e.g., com.acme.dnnops).
+  optional string domain = 4;
+
+  // The version of the set of operators. This is a simple int value
+  // that is monotonically increasing as new versions of the operator set
+  // are published. All operators in this set MUST have since_version
+  // <= opset_version.
+  optional int64 opset_version = 5;
+
+  // A human-readable documentation for this set of operators. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // The operators specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos in operator
+  repeated OperatorProto operator = 8;
+
+  // The functions specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos/FunctionProtos in operator/functions
+  repeated FunctionProto functions = 9;
+}
+
diff --git a/onnx/onnx-operators.proto b/onnx/onnx-operators.proto
new file mode 100644
index 0000000..aaee975
--- /dev/null
+++ b/onnx/onnx-operators.proto
@@ -0,0 +1,136 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// Copyright (c) ONNX Project Contributors.
+// Licensed under the Apache-2.0 license.
+
+syntax = "proto2";
+
+package onnx;
+import "onnx/onnx.proto";
+
+//
+// This file contains the proto definitions for OperatorSetProto and
+// OperatorProto.  OperatorSetProtos are used to describe a versioned
+// set of operators that can be used by a ModelProto.
+//
+// Like ModelProto, OperatorSetProto is defined as a top-level file/wire
+// format, however their usage is different.
+//
+// ModelProto files are used to describe executable graphs that can be
+// executed directly by a framework, runtime, or engine.
+//
+// OperatorSetProto files are used to describe a set of operators that are
+// available in a given environment.  The file TBD.TBD is the OperatorSetProto
+// that describes the ONNX standard operators.
+//
+
+// An OperatorProto represents the immutable specification of the signature
+// and semantics of an operator.
+//
+// Operators are declared as part of an OperatorSet, which also defines the
+// domain name for the set.
+//
+// Operators are uniquely identified by a three part identifier
+//   (domain, op_type, since_version)
+// where
+//   *domain* is the domain of an operator set that
+//      contains this operator specification.
+//
+//   *op_type* is the name of the operator as referenced by a
+//      NodeProto.op_type
+//
+//   *since_version* is the version of the operator set that
+//      this operator was initially declared in.
+//
+message OperatorProto {
+  // The name of the operator within a domain.
+  // This field MUST be present in this version of the IR.
+  optional string op_type = 1;
+
+  // The version of the operator set that first introduced this
+  // operator. This value MUST be the same value as the
+  // opset_version of the operator set that first published this operator.
+  // Subsequent versions of the operator set MUST NOT alter the signature
+  // or semantics of the operator once published as STABLE.
+  // This field MUST be present in this version of the IR.
+  optional int64 since_version = 2;
+
+  // This field indicates whether the syntax, semantics, or presence
+  // of this operator is in an experimental or stable stage. Once an
+  // operator is published as STABLE, it's syntax and semantics MUST NOT
+  // change in subsequent versions of the operator set.
+  // When an operator is published as EXPERIMENTAL, the syntax and semantics
+  // of the operator MAY change across operator set versions.
+  // Operators "become" stable by deprecating the experimental version and
+  // introducing a new stable operator with the same op_type.
+  optional OperatorStatus status = 3;
+
+  // Eventually we will declare the signature of the operator here
+
+  // A human-readable documentation for this operator. Markdown is allowed.
+  optional string doc_string = 10;
+}
+
+// An OperatorSetProto represents an immutable set of immutable operator
+// specifications.
+//
+// The domain of the set (OperatorSetProto.domain) is a reverse-DNS name
+// that disambiguates operator sets defined by independent entities.
+//
+// The version of the set (opset_version) is a monotonically increasing
+// integer that indicates changes to the membership of the operator set.
+//
+//
+// Operator sets are uniquely identified by a two part identifier (domain, opset_version)
+//
+// Like ModelProto, OperatorSetProto is intended as a top-level file/wire format,
+// and thus has the standard format headers in addition to the operator set information.
+//
+message OperatorSetProto {
+  // All OperatorSetProtos start with a distinguished byte sequence to disambiguate
+  // protobuf files containing OperatorSets from other content.
+  // This field MUST be "ONNXOPSET"
+  // This field MUST be present in this version of the IR
+  optional string magic = 1;
+
+  // All OperatorSetProtos indicate the version of the IR syntax and semantics
+  // they adhere to. It is always IR_VERSION.
+  // This field MUST be present in this version of the IR
+  optional int64 ir_version = 2;
+
+  // The prerelease component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  optional string ir_version_prerelease = 3;
+
+  // The build metadata component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  optional string ir_build_metadata = 7;
+
+  // Domain name of the operator set, in reverse DNS form (e.g., com.acme.dnnops).
+  optional string domain = 4;
+
+  // The version of the set of operators. This is a simple int value
+  // that is monotonically increasing as new versions of the operator set
+  // are published. All operators in this set MUST have since_version
+  // <= opset_version.
+  optional int64 opset_version = 5;
+
+  // A human-readable documentation for this set of operators. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // The operators specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos in operator
+  repeated OperatorProto operator = 8;
+
+  // The functions specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos/FunctionProtos in operator/functions
+  repeated FunctionProto functions = 9;
+}
+
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx-operators.proto3 b/onnx/onnx-operators.proto3
new file mode 100644
index 0000000..257d1c6
--- /dev/null
+++ b/onnx/onnx-operators.proto3
@@ -0,0 +1,136 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// Copyright (c) ONNX Project Contributors.
+// Licensed under the Apache-2.0 license.
+
+syntax = "proto3";
+
+package onnx;
+import "onnx/onnx.proto3";
+
+//
+// This file contains the proto definitions for OperatorSetProto and
+// OperatorProto.  OperatorSetProtos are used to describe a versioned
+// set of operators that can be used by a ModelProto.
+//
+// Like ModelProto, OperatorSetProto is defined as a top-level file/wire
+// format, however their usage is different.
+//
+// ModelProto files are used to describe executable graphs that can be
+// executed directly by a framework, runtime, or engine.
+//
+// OperatorSetProto files are used to describe a set of operators that are
+// available in a given environment.  The file TBD.TBD is the OperatorSetProto
+// that describes the ONNX standard operators.
+//
+
+// An OperatorProto represents the immutable specification of the signature
+// and semantics of an operator.
+//
+// Operators are declared as part of an OperatorSet, which also defines the
+// domain name for the set.
+//
+// Operators are uniquely identified by a three part identifier
+//   (domain, op_type, since_version)
+// where
+//   *domain* is the domain of an operator set that
+//      contains this operator specification.
+//
+//   *op_type* is the name of the operator as referenced by a
+//      NodeProto.op_type
+//
+//   *since_version* is the version of the operator set that
+//      this operator was initially declared in.
+//
+message OperatorProto {
+  // The name of the operator within a domain.
+  // This field MUST be present in this version of the IR.
+  string op_type = 1;
+
+  // The version of the operator set that first introduced this
+  // operator. This value MUST be the same value as the
+  // opset_version of the operator set that first published this operator.
+  // Subsequent versions of the operator set MUST NOT alter the signature
+  // or semantics of the operator once published as STABLE.
+  // This field MUST be present in this version of the IR.
+  int64 since_version = 2;
+
+  // This field indicates whether the syntax, semantics, or presence
+  // of this operator is in an experimental or stable stage. Once an
+  // operator is published as STABLE, it's syntax and semantics MUST NOT
+  // change in subsequent versions of the operator set.
+  // When an operator is published as EXPERIMENTAL, the syntax and semantics
+  // of the operator MAY change across operator set versions.
+  // Operators "become" stable by deprecating the experimental version and
+  // introducing a new stable operator with the same op_type.
+  OperatorStatus status = 3;
+
+  // Eventually we will declare the signature of the operator here
+
+  // A human-readable documentation for this operator. Markdown is allowed.
+  string doc_string = 10;
+}
+
+// An OperatorSetProto represents an immutable set of immutable operator
+// specifications.
+//
+// The domain of the set (OperatorSetProto.domain) is a reverse-DNS name
+// that disambiguates operator sets defined by independent entities.
+//
+// The version of the set (opset_version) is a monotonically increasing
+// integer that indicates changes to the membership of the operator set.
+//
+//
+// Operator sets are uniquely identified by a two part identifier (domain, opset_version)
+//
+// Like ModelProto, OperatorSetProto is intended as a top-level file/wire format,
+// and thus has the standard format headers in addition to the operator set information.
+//
+message OperatorSetProto {
+  // All OperatorSetProtos start with a distinguished byte sequence to disambiguate
+  // protobuf files containing OperatorSets from other content.
+  // This field MUST be "ONNXOPSET"
+  // This field MUST be present in this version of the IR
+  string magic = 1;
+
+  // All OperatorSetProtos indicate the version of the IR syntax and semantics
+  // they adhere to. It is always IR_VERSION.
+  // This field MUST be present in this version of the IR
+  int64 ir_version = 2;
+
+  // The prerelease component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  string ir_version_prerelease = 3;
+
+  // The build metadata component of the SemVer of the IR.
+  // This field MAY be absent in this version of the IR
+  string ir_build_metadata = 7;
+
+  // Domain name of the operator set, in reverse DNS form (e.g., com.acme.dnnops).
+  string domain = 4;
+
+  // The version of the set of operators. This is a simple int value
+  // that is monotonically increasing as new versions of the operator set
+  // are published. All operators in this set MUST have since_version
+  // <= opset_version.
+  int64 opset_version = 5;
+
+  // A human-readable documentation for this set of operators. Markdown is allowed.
+  string doc_string = 6;
+
+  // The operators specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos in operator
+  repeated OperatorProto operator = 8;
+
+  // The functions specified by this operator set.
+  // The (name, version) MUST be unique across all OperatorProtos/FunctionProtos in operator/functions
+  repeated FunctionProto functions = 9;
+}
+
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx-operators_pb.h b/onnx/onnx-operators_pb.h
new file mode 100644
index 0000000..7c4a4ee
--- /dev/null
+++ b/onnx/onnx-operators_pb.h
@@ -0,0 +1,12 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "onnx/onnx_pb.h"
+#ifdef ONNX_ML
+#include "onnx/onnx-operators-ml.pb.h"
+#else
+#include "onnx/onnx-operators.pb.h"
+#endif
diff --git a/onnx/onnx.in.proto b/onnx/onnx.in.proto
new file mode 100644
index 0000000..fb03b0f
--- /dev/null
+++ b/onnx/onnx.in.proto
@@ -0,0 +1,1013 @@
+// SPDX-License-Identifier: Apache-2.0
+
+
+syntax = "proto2";
+
+package {PACKAGE_NAME};
+
+// Overview
+//
+// ONNX is an open specification that is comprised of the following components:
+//
+// 1)  A definition of an extensible computation graph model.
+// 2)  Definitions of standard data types.
+// 3)  Definitions of built-in operators.
+//
+// This document describes the syntax of models and their computation graphs,
+// as well as the standard data types. Together, they are referred to as the ONNX
+// Intermediate Representation, or 'IR' for short.
+//
+// The normative semantic specification of the ONNX IR is found in docs/IR.md.
+// Definitions of the built-in neural network operators may be found in docs/Operators.md.
+// #if ONNX-ML
+// Definitions of the built-in classical machine learning operators may be found in
+// docs/Operators-ml.md.
+// #endif
+
+// Notes
+//
+// Protobuf compatibility
+//
+// To simplify framework compatibility, ONNX is defined using the subset of protobuf
+// that is compatible with both protobuf v2 and v3. This means that we do not use any
+// protobuf features that are only available in one of the two versions.
+//
+// Here are the most notable contortions we have to carry out to work around
+// these limitations:
+//
+//   - No 'map' (added protobuf 3.0). We instead represent mappings as lists
+//     of key-value pairs, where order does not matter and duplicates
+//     are not allowed.
+
+
+// Versioning
+//
+// ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md
+//
+// To be compatible with both proto2 and proto3, we will use a version number
+// that is not defined by the default value but an explicit enum number.
+enum Version {
+  // proto3 requires the first enum value to be zero.
+  // We add this just to appease the compiler.
+  _START_VERSION = 0;
+  // The version field is always serialized and we will use it to store the
+  // version that the  graph is generated from. This helps us set up version
+  // control.
+  // For the IR, we are using simple numbers starting with 0x00000001,
+  // which was the version we published on Oct 10, 2017.
+  IR_VERSION_2017_10_10 = 0x0000000000000001;
+
+  // IR_VERSION 2 published on Oct 30, 2017
+  // - Added type discriminator to AttributeProto to support proto3 users
+  IR_VERSION_2017_10_30 = 0x0000000000000002;
+
+  // IR VERSION 3 published on Nov 3, 2017
+  // - For operator versioning:
+  //    - Added new message OperatorSetIdProto
+  //    - Added opset_import in ModelProto
+  // - For vendor extensions, added domain in NodeProto
+  IR_VERSION_2017_11_3 = 0x0000000000000003;
+
+  // IR VERSION 4 published on Jan 22, 2019
+  // - Relax constraint that initializers should be a subset of graph inputs
+  // - Add type BFLOAT16
+  IR_VERSION_2019_1_22 = 0x0000000000000004;
+
+  // IR VERSION 5 published on March 18, 2019
+  // - Add message TensorAnnotation.
+  // - Add quantization annotation in GraphProto to map tensor with its scale and zero point quantization parameters.
+  IR_VERSION_2019_3_18 = 0x0000000000000005;
+
+  // IR VERSION 6 published on Sep 19, 2019
+  // - Add support for sparse tensor constants stored in model.
+  //   - Add message SparseTensorProto
+  //   - Add sparse initializers
+  IR_VERSION_2019_9_19 = 0x0000000000000006;
+
+  // IR VERSION 7 published on May 8, 2020
+  // - Add support to allow function body graph to rely on multiple external operator sets.
+  // - Add a list to promote inference graph's initializers to global and
+  //   mutable variables. Global variables are visible in all graphs of the
+  //   stored models.
+  // - Add message TrainingInfoProto to store initialization
+  //   method and training algorithm. The execution of TrainingInfoProto
+  //   can modify the values of mutable variables.
+  // - Implicitly add inference graph into each TrainingInfoProto's algorithm.
+  IR_VERSION_2020_5_8 = 0x0000000000000007;
+
+  // IR VERSION 8 published on July 30, 2021
+  // Introduce TypeProto.SparseTensor
+  // Introduce TypeProto.Optional
+  // Added a list of FunctionProtos local to the model
+  // Deprecated since_version and operator status from FunctionProto
+  IR_VERSION_2021_7_30 = 0x0000000000000008;
+
+  // IR VERSION 9 published on May 5, 2023
+  // Added AttributeProto to FunctionProto so that default attribute values can be set.
+  // Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ.
+  IR_VERSION_2023_5_5 = 0x0000000000000009;
+
+  // IR VERSION 10 published on March 25, 2024
+  // Added UINT4, INT4, overload field for functions and metadata_props on multiple proto definitions.
+  IR_VERSION_2024_3_25 = 0x000000000000000A;
+
+  // IR VERSION 11 published on May 12, 2025
+  // Added FLOAT4E2M1, multi-device protobuf classes.
+  IR_VERSION_2025_05_12 = 0x000000000000000B;
+
+  // IR VERSION 12 published on August 26, 2025
+  // Added FLOAT8E8M0.
+  IR_VERSION_2025_08_26 = 0x000000000000000C;
+
+  // IR VERSION 13 published on November 6, 2025
+  // Added UINT2, INT2.
+  IR_VERSION = 0x000000000000000D;
+}
+
+// Attributes
+//
+// A named attribute containing either singular float, integer, string, graph,
+// and tensor values, or repeated float, integer, string, graph, and tensor values.
+// An AttributeProto MUST contain the name field, and *only one* of the
+// following content fields, effectively enforcing a C/C++ union equivalent.
+message AttributeProto {
+  reserved 12, 16 to 19;
+  reserved "v";
+
+  // Note: this enum is structurally identical to the OpSchema::AttrType
+  // enum defined in schema.h.  If you rev one, you likely need to rev the other.
+  enum AttributeType {
+    UNDEFINED = 0;
+    FLOAT = 1;
+    INT = 2;
+    STRING = 3;
+    TENSOR = 4;
+    GRAPH = 5;
+    SPARSE_TENSOR = 11;
+    TYPE_PROTO = 13;
+
+    FLOATS = 6;
+    INTS = 7;
+    STRINGS = 8;
+    TENSORS = 9;
+    GRAPHS = 10;
+    SPARSE_TENSORS = 12;
+    TYPE_PROTOS = 14;
+  }
+
+  // The name field MUST be present for this version of the IR.
+  optional string name = 1;           // namespace Attribute
+
+  // if ref_attr_name is not empty, ref_attr_name is the attribute name in parent function.
+  // In this case, this AttributeProto does not contain data, and it's a reference of attribute
+  // in parent scope.
+  // NOTE: This should ONLY be used in function (sub-graph). It's invalid to be used in main graph.
+  optional string ref_attr_name = 21;
+
+  // A human-readable documentation for this attribute. Markdown is allowed.
+  optional string doc_string = 13;
+
+  // The type field MUST be present for this version of the IR.
+  // For 0.0.1 versions of the IR, this field was not defined, and
+  // implementations needed to use has_field heuristics to determine
+  // which value field was in use.  For IR_VERSION 0.0.2 or later, this
+  // field MUST be set and match the f|i|s|t|... field in use.  This
+  // change was made to accommodate proto3 implementations.
+  optional AttributeType type = 20;   // discriminator that indicates which field below is in use
+
+  // Exactly ONE of the following fields must be present for this version of the IR
+  optional float f = 2;               // float
+  optional int64 i = 3;               // int
+  optional bytes s = 4;               // UTF-8 string
+  optional TensorProto t = 5;         // tensor value
+  optional GraphProto g = 6;          // graph
+  optional SparseTensorProto sparse_tensor = 22;  // sparse tensor value
+  // Do not use field below, it's deprecated.
+  // optional ValueProto v = 12;         // value - subsumes everything but graph
+  optional TypeProto tp = 14;          // type proto
+
+  repeated float floats = 7;          // list of floats
+  repeated int64 ints = 8;            // list of ints
+  repeated bytes strings = 9;         // list of UTF-8 strings
+  repeated TensorProto tensors = 10;  // list of tensors
+  repeated GraphProto graphs = 11;    // list of graph
+  repeated SparseTensorProto sparse_tensors = 23; // list of sparse tensors
+  repeated TypeProto type_protos = 15;// list of type protos
+}
+
+// Defines information on value, including the name, the type, and
+// the shape of the value.
+message ValueInfoProto {
+  // This field MUST be present in this version of the IR.
+  optional string name = 1;     // namespace Value
+  // This field MUST be present in this version of the IR for
+  // inputs and outputs of the top-level graph.
+  optional TypeProto type = 2;
+  // A human-readable documentation for this value. Markdown is allowed.
+  optional string doc_string = 3;
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 4;
+}
+
+// Nodes
+//
+// Computation graphs are made up of a DAG of nodes, which represent what is
+// commonly called a "layer" or "pipeline stage" in machine learning frameworks.
+//
+// For example, it can be a node of type "Conv" that takes in an image, a filter
+// tensor and a bias tensor, and produces the convolved output.
+message NodeProto {
+  repeated string input = 1;    // namespace Value
+  repeated string output = 2;   // namespace Value
+
+  // An optional identifier for this node in a graph.
+  // This field MAY be absent in this version of the IR.
+  optional string name = 3;     // namespace Node
+
+  // The symbolic identifier of the Operator to execute.
+  optional string op_type = 4;  // namespace Operator
+  // The domain of the OperatorSet that specifies the operator named by op_type.
+  optional string domain = 7;   // namespace Domain
+  // Overload identifier, used only to map this to a model-local function.
+  optional string overload = 8;
+
+  // Additional named attributes.
+  repeated AttributeProto attribute = 5;
+
+  // A human-readable documentation for this node. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 9;
+
+  // Configuration of multi-device annotations.
+  repeated NodeDeviceConfigurationProto device_configurations = 10;
+}
+
+// IntIntListEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message IntIntListEntryProto {
+  optional int64 key = 1;
+  repeated int64 value = 2;
+};
+
+// Multi-device configuration proto for NodeProto.
+message NodeDeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // ID of the configuration. MUST match the name of a DeviceConfigurationProto.
+    optional string configuration_id = 1;
+    // Sharding spec for the node.
+    repeated ShardingSpecProto sharding_spec = 2;
+    // Pipeline stage of this node.
+    optional int32 pipeline_stage = 3;
+}
+
+// ShardingSpecProto: This describes the sharding spec for a specific
+// input or output tensor of a node.
+message ShardingSpecProto {
+  // This field MUST be present for this version of the IR.
+  // Identifies the input or output of the node that is being sharded.
+  // Required to match a name specified in the node's input or output list of ValueInfoProtos.
+  // It is called `logical tensor` in subsequent descriptions.
+  optional string tensor_name = 1;
+
+  // The following is the list of devices across which the logical
+  // tensor is sharded or replicated.
+  repeated int64 device = 2;
+
+  // Each element v in above field devices may represent either a
+  // device or a set of devices (when we want the same shard/tensor
+  // to be replicated across a subset of devices), as indicated by
+  // the following optional map. If the map contains an entry for v,
+  // then v represents a device group, and the map indicates the set
+  // of devices in that group.
+  repeated IntIntListEntryProto index_to_device_group_map = 3;
+
+  // The following is the sharded-shape of the tensor, consisting of
+  // the sharding-spec for each axis of the tensor.
+  repeated ShardedDimProto sharded_dim = 4;
+}
+
+// ShardedDimProto: This describes the sharding spec for a single
+// axis of a sharded tensor.
+message ShardedDimProto {
+  // This field MUST be present for this version of the IR.
+  // The axis this sharding corresponds to. Must be in the range of
+  // [-r, r - 1], where r is the rank of the tensor. Negative axis values means
+  // counting from the back.
+  optional int64 axis = 1;
+
+  // Describes how the tensor on the provided axis is sharded.
+  // The common-case is described by a single instance of SimpleShardedDimProto.
+  // Multiple instances can be used to handle cases where a sharded
+  // tensor is reshaped, fusing multiple axes into one.
+  repeated SimpleShardedDimProto simple_sharding = 2;
+}
+
+// SimpleShardedDimProto: Indicates that N blocks are divided into M shards.
+// N is allowed to be symbolic where M is required to be a constant.
+message SimpleShardedDimProto {
+    // Dimension value to be sharded.
+    oneof dim {
+        int64 dim_value = 1;
+        string dim_param = 2;
+    }
+
+    // This field MUST be present for this version of the IR.
+    // Number of shards to split dim into.
+    optional int64 num_shards = 3;
+}
+
+// Training information
+// TrainingInfoProto stores information for training a model.
+// In particular, this defines two functionalities: an initialization-step
+// and a training-algorithm-step. Initialization resets the model
+// back to its original state as if no training has been performed.
+// Training algorithm improves the model based on input data.
+//
+// The semantics of the initialization-step is that the initializers
+// in ModelProto.graph and in TrainingInfoProto.algorithm are first
+// initialized as specified by the initializers in the graph, and then
+// updated by the "initialization_binding" in every instance in
+// ModelProto.training_info.
+//
+// The field "algorithm" defines a computation graph which represents a
+// training algorithm's step. After the execution of a
+// TrainingInfoProto.algorithm, the initializers specified by "update_binding"
+// may be immediately updated. If the targeted training algorithm contains
+// consecutive update steps (such as block coordinate descent methods),
+// the user needs to create a TrainingInfoProto for each step.
+message TrainingInfoProto {
+  // This field describes a graph to compute the initial tensors
+  // upon starting the training process. Initialization graph has no input
+  // and can have multiple outputs. Usually, trainable tensors in neural
+  // networks are randomly initialized. To achieve that, for each tensor,
+  // the user can put a random number operator such as RandomNormal or
+  // RandomUniform in TrainingInfoProto.initialization.node and assign its
+  // random output to the specific tensor using "initialization_binding".
+  // This graph can also set the initializers in "algorithm" in the same
+  // TrainingInfoProto; a use case is resetting the number of training
+  // iteration to zero.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Thus, no initializer would be changed by default.
+  optional GraphProto initialization = 1;
+
+  // This field represents a training algorithm step. Given required inputs,
+  // it computes outputs to update initializers in its own or inference graph's
+  // initializer lists. In general, this field contains loss node, gradient node,
+  // optimizer node, increment of iteration count.
+  //
+  // An execution of the training algorithm step is performed by executing the
+  // graph obtained by combining the inference graph (namely "ModelProto.graph")
+  // and the "algorithm" graph. That is, the actual
+  // input/initializer/output/node/value_info/sparse_initializer list of
+  // the training graph is the concatenation of
+  // "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer"
+  // and "algorithm.input/initializer/output/node/value_info/sparse_initializer"
+  // in that order. This combined graph must satisfy the normal ONNX conditions.
+  // Now, let's provide a visualization of graph combination for clarity.
+  // Let the inference graph (i.e., "ModelProto.graph") be
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d
+  // and the "algorithm" graph be
+  //    tensor_d -> Add -> tensor_e
+  // The combination process results
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add -> tensor_e
+  //
+  // Notice that an input of a node in the "algorithm" graph may reference the
+  // output of a node in the inference graph (but not the other way round). Also, inference
+  // node cannot reference inputs of "algorithm". With these restrictions, inference graph
+  // can always be run independently without training information.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Evaluating the default training step never
+  // update any initializers.
+  optional GraphProto algorithm = 2;
+
+  // This field specifies the bindings from the outputs of "initialization" to
+  // some initializers in "ModelProto.graph.initializer" and
+  // the "algorithm.initializer" in the same TrainingInfoProto.
+  // See "update_binding" below for details.
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "initialization".
+  repeated StringStringEntryProto initialization_binding = 3;
+
+  // Gradient-based training is usually an iterative procedure. In one gradient
+  // descent iteration, we apply
+  //
+  // x = x - r * g
+  //
+  // where "x" is the optimized tensor, "r" stands for learning rate, and "g" is
+  // gradient of "x" with respect to a chosen loss. To avoid adding assignments
+  // into the training graph, we split the update equation into
+  //
+  // y = x - r * g
+  // x = y
+  //
+  // The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To
+  // tell that "y" should be assigned to "x", the field "update_binding" may
+  // contain a key-value pair of strings, "x" (key of StringStringEntryProto)
+  // and "y" (value of StringStringEntryProto).
+  // For a neural network with multiple trainable (mutable) tensors, there can
+  // be multiple key-value pairs in "update_binding".
+  //
+  // The initializers appears as keys in "update_binding" are considered
+  // mutable variables. This implies some behaviors
+  // as described below.
+  //
+  //  1. We have only unique keys in all "update_binding"s so that two
+  //     variables may not have the same name. This ensures that one
+  //     variable is assigned up to once.
+  //  2. The keys must appear in names of "ModelProto.graph.initializer" or
+  //     "TrainingInfoProto.algorithm.initializer".
+  //  3. The values must be output names of "algorithm" or "ModelProto.graph.output".
+  //  4. Mutable variables are initialized to the value specified by the
+  //     corresponding initializer, and then potentially updated by
+  //     "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s.
+  //
+  // This field usually contains names of trainable tensors
+  // (in ModelProto.graph), optimizer states such as momentums in advanced
+  // stochastic gradient methods (in TrainingInfoProto.graph),
+  // and number of training iterations (in TrainingInfoProto.graph).
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "algorithm".
+  repeated StringStringEntryProto update_binding = 4;
+}
+
+// Models
+//
+// ModelProto is a top-level file/container format for bundling a ML model and
+// associating its computation graph with metadata.
+//
+// The semantics of the model are described by the associated GraphProto's.
+message ModelProto {
+  // The version of the IR this model targets. See Version enum above.
+  // This field MUST be present.
+  optional int64 ir_version = 1;
+
+  // The OperatorSets this model relies on.
+  // All ModelProtos MUST have at least one entry that
+  // specifies which version of the ONNX OperatorSet is
+  // being imported.
+  //
+  // All nodes in the ModelProto's graph will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets.
+  repeated OperatorSetIdProto opset_import = 8;
+
+  // The name of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  optional string producer_name = 2;
+
+  // The version of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  optional string producer_version = 3;
+
+  // Domain name of the model.
+  // We use reverse domain names as name space indicators. For example:
+  // `com.facebook.fair` or `com.microsoft.cognitiveservices`
+  //
+  // Together with `model_version` and GraphProto.name, this forms the unique identity of
+  // the graph.
+  optional string domain = 4;
+
+  // The version of the graph encoded. See Version enum below.
+  optional int64 model_version = 5;
+
+  // A human-readable documentation for this model. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // The parameterized graph that is evaluated to execute the model.
+  optional GraphProto graph = 7;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+
+  // Training-specific information. Sequentially executing all stored
+  // `TrainingInfoProto.algorithm`s and assigning their outputs following
+  // the corresponding `TrainingInfoProto.update_binding`s is one training
+  // iteration. Similarly, to initialize the model
+  // (as if training hasn't happened), the user should sequentially execute
+  // all stored `TrainingInfoProto.initialization`s and assigns their outputs
+  // using `TrainingInfoProto.initialization_binding`s.
+  //
+  // If this field is empty, the training behavior of the model is undefined.
+  repeated TrainingInfoProto training_info = 20;
+
+  // A list of function protos local to the model.
+  //
+  // The (domain, name, overload) tuple must be unique across the function protos in this list.
+  // In case of any conflicts the behavior (whether the model local functions are given higher priority,
+  // or standard operator sets are given higher priority or this is treated as error) is defined by
+  // the runtimes.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto and other model local FunctionProtos.
+  // Example, if same operator set say 'A' is imported by a FunctionProto and ModelProto
+  // or by 2 FunctionProtos then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same for every node in the function body.
+  //
+  // One FunctionProto can reference other FunctionProto in the model, however, recursive reference
+  // is not allowed.
+  repeated FunctionProto functions = 25;
+
+  // Describes different target configurations for a multi-device use case.
+  // A model MAY describe multiple multi-device configurations for execution.
+  repeated DeviceConfigurationProto configuration = 26;
+};
+
+// DeviceConfigurationProto describes a multi-device configuration for a model.
+message DeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // Name of the configuration.
+    optional string name = 1;
+    // This field MUST be present for this version of the IR.
+    // Number of devices inside this configuration.
+    optional int32 num_devices = 2;
+    // Optional names of the devices. MUST be length of num_devices if provided.
+    repeated string device = 3;
+}
+
+// StringStringEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message StringStringEntryProto {
+  optional string key = 1;
+  optional string value = 2;
+};
+
+message TensorAnnotation {
+  optional string tensor_name = 1;
+  // <key, value> pairs to annotate tensor specified by <tensor_name> above.
+  // The keys used in the mapping below must be pre-defined in ONNX spec.
+  // For example, for 8-bit linear quantization case, 'SCALE_TENSOR', 'ZERO_POINT_TENSOR' will be pre-defined as
+  // quantization parameter keys.
+  repeated StringStringEntryProto quant_parameter_tensor_names = 2;
+}
+
+
+
+// Graphs
+//
+// A graph defines the computational logic of a model and is comprised of a parameterized
+// list of nodes that form a directed acyclic graph based on their inputs and outputs.
+// This is the equivalent of the "network" or "graph" in many deep learning
+// frameworks.
+message GraphProto {
+  // The nodes in the graph, sorted topologically.
+  repeated NodeProto node = 1;
+
+  // The name of the graph.
+  optional string name = 2;   // namespace Graph
+
+  // A list of named tensor values, used to specify constant inputs of the graph.
+  // Each initializer (both TensorProto as well SparseTensorProto) MUST have a name.
+  // The name MUST be unique across both initializer and sparse_initializer,
+  // but the name MAY also appear in the input list.
+  repeated TensorProto initializer = 5;
+
+  // Initializers (see above) stored in sparse format.
+  repeated SparseTensorProto sparse_initializer = 15;
+
+  // A human-readable documentation for this graph. Markdown is allowed.
+  optional string doc_string = 10;
+
+  // The inputs and outputs of the graph.
+  repeated ValueInfoProto input = 11;
+  repeated ValueInfoProto output = 12;
+
+  // Information for the values in the graph. The ValueInfoProto.name's
+  // must be distinct. It is optional for a value to appear in value_info list.
+  repeated ValueInfoProto value_info = 13;
+
+  // This field carries information to indicate the mapping among a tensor and its
+  // quantization parameter tensors. For example:
+  // For tensor 'a', it may have {'SCALE_TENSOR', 'a_scale'} and {'ZERO_POINT_TENSOR', 'a_zero_point'} annotated,
+  // which means, tensor 'a_scale' and tensor 'a_zero_point' are scale and zero point of tensor 'a' in the model.
+  repeated TensorAnnotation quantization_annotation = 14;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+
+  reserved 3, 4, 6 to 9;
+  reserved "ir_version", "producer_version", "producer_tag", "domain";
+}
+
+// Tensors
+//
+// A serialized tensor value.
+message TensorProto {
+  enum DataType {
+    UNDEFINED = 0;
+    // Basic types.
+    FLOAT = 1;   // float
+    UINT8 = 2;   // uint8_t
+    INT8 = 3;    // int8_t
+    UINT16 = 4;  // uint16_t
+    INT16 = 5;   // int16_t
+    INT32 = 6;   // int32_t
+    INT64 = 7;   // int64_t
+    STRING = 8;  // string
+    BOOL = 9;    // bool
+
+    // IEEE754 half-precision floating-point format (16 bits wide).
+    // This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
+    FLOAT16 = 10;
+
+    DOUBLE = 11;
+    UINT32 = 12;
+    UINT64 = 13;
+    COMPLEX64 = 14;     // complex with float32 real and imaginary components
+    COMPLEX128 = 15;    // complex with float64 real and imaginary components
+
+    // Non-IEEE floating-point format based on IEEE754 single-precision
+    // floating-point number truncated to 16 bits.
+    // This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
+    BFLOAT16 = 16;
+
+    // Non-IEEE floating-point format based on papers
+    // FP8 Formats for Deep Learning, https://arxiv.org/abs/2209.05433,
+    // 8-bit Numerical Formats For Deep Neural Networks, https://arxiv.org/pdf/2206.02915.pdf.
+    // Operators supported FP8 are Cast, CastLike, QuantizeLinear, DequantizeLinear.
+    // The computation usually happens inside a block quantize / dequantize
+    // fused by the runtime.
+    FLOAT8E4M3FN = 17;    // float 8, mostly used for coefficients, supports nan, not inf
+    FLOAT8E4M3FNUZ = 18;  // float 8, mostly used for coefficients, supports nan, not inf, no negative zero
+    FLOAT8E5M2 = 19;      // follows IEEE 754, supports nan, inf, mostly used for gradients
+    FLOAT8E5M2FNUZ = 20;  // follows IEEE 754, supports nan, not inf, mostly used for gradients, no negative zero
+
+    // 4-bit integer data types
+    UINT4 = 21;  // Unsigned integer in range [0, 15]
+    INT4 = 22;   // Signed integer in range [-8, 7], using two's-complement representation
+
+    // 4-bit floating point data types
+    FLOAT4E2M1 = 23;
+
+    // E8M0 type used as the scale for microscaling (MX) formats:
+    // https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
+    FLOAT8E8M0 = 24;
+
+    // 2-bit integer data type
+    UINT2 = 25; // Unsigned integer in range [0, 3]
+    INT2 = 26;  // Signed integer in range [-2, 1], using two's complement representation
+
+    // Future extensions go here.
+  }
+
+  // The shape of the tensor.
+  repeated int64 dims = 1;
+
+  // The data type of the tensor.
+  // This field MUST have a valid TensorProto.DataType value
+  optional int32 data_type = 2;
+
+  // For very large tensors, we may want to store them in chunks, in which
+  // case the following fields will specify the segment that is stored in
+  // the current TensorProto.
+  message Segment {
+    optional int64 begin = 1;
+    optional int64 end = 2;
+  }
+  optional Segment segment = 3;
+
+  // Tensor content must be organized in row-major order.
+  //
+  // Depending on the data_type field, exactly one of the fields below with
+  // name ending in _data is used to store the elements of the tensor.
+
+  // For float and complex64 values
+  // Complex64 tensors are encoded as a single array of floats,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
+  repeated float float_data = 4 [packed = true];
+
+  // For int32, uint8, int8, uint16, int16, uint4, int4, uint2, int2, bool, (b)float16, float8, and float4:
+  // - (b)float16 and float8 values MUST be converted bit-wise into an unsigned integer
+  //   representation before being written to the buffer.
+  // - Each pair of uint4, int4, and float4 values MUST be packed as two 4-bit elements into a single byte.
+  //   The first element is stored in the 4 least significant bits (LSB),
+  //   and the second element is stored in the 4 most significant bits (MSB).
+  // - Each group of four uint2, int2 values MUST be packed as four 2-bit elements into a single byte.
+  //   The elements are packed from LSB to MSB, with the first element in bits 0-1, second element in bits 2-3,
+  //   third element in bits 4-5, and fourth element in bits 6-7.
+  //
+  // Consequently:
+  // - For data types with a bit-width of 8 or greater, each `int32_data` stores one element.
+  // - For 4-bit data types, each `int32_data` stores two elements.
+  // - For 2-bit data types, each `int32_data` stores four elements.
+  //
+  // When this field is present, the data_type field MUST be
+  // INT32, INT16, INT8, INT4, INT2, UINT16, UINT8, UINT4, UINT2, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ, FLOAT8E8M0, FLOAT4E2M1
+  repeated int32 int32_data = 5 [packed = true];
+
+  // For strings.
+  // Each element of string_data is a UTF-8 encoded Unicode
+  // string. No trailing null, no leading BOM. The protobuf "string"
+  // scalar type is not used to match ML community conventions.
+  // When this field is present, the data_type field MUST be STRING
+  repeated bytes string_data = 6;
+
+  // For int64.
+  // When this field is present, the data_type field MUST be INT64
+  repeated int64 int64_data = 7 [packed = true];
+
+  // Optionally, a name for the tensor.
+  optional string name = 8; // namespace Value
+
+  // A human-readable documentation for this tensor. Markdown is allowed.
+  optional string doc_string = 12;
+
+  // Serializations can either use one of the fields above, or use this
+  // raw bytes field. The only exception is the string case, where one is
+  // required to store the content in the repeated bytes string_data field.
+  //
+  // When this raw_data field is used to store tensor value, elements MUST
+  // be stored in as fixed-width, little-endian order.
+  // Floating-point data types MUST be stored in IEEE 754 format.
+  // Complex64 elements must be written as two consecutive FLOAT values, real component first.
+  // Complex128 elements must be written as two consecutive DOUBLE values, real component first.
+  // Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
+  // uint4 and int4 values must be packed to 4bitx2, the first element is stored in the 4 LSB and the second element is stored in the 4 MSB.
+  // uint2 and int2 values must be packed to 2bitx4, with elements packed from LSB to MSB in a single byte as: x0 | (x1 << 2) | (x2 << 4) | (x3 << 6)
+  // where x0, x1, x2, x3 are consecutive elements.
+  //
+  // Note: the advantage of specific field rather than the raw_data field is
+  // that in some cases (e.g. int data), protobuf does a better packing via
+  // variable length storage, and may lead to smaller binary footprint.
+  // When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
+  optional bytes raw_data = 9;
+
+  // Data can be stored inside the protobuf file using type-specific fields or raw_data.
+  // Alternatively, raw bytes data can be stored in an external file, using the external_data field.
+  // external_data stores key-value pairs describing data location. Recognized keys are:
+  // - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
+  //                           protobuf model was stored
+  // - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
+  //                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
+  // - "length" (optional) - number of bytes containing data. Integer stored as string.
+  // - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
+  repeated StringStringEntryProto external_data = 13;
+
+  // Location of the data for this tensor. MUST be one of:
+  // - DEFAULT - data stored inside the protobuf message. Data is stored in raw_data (if set) otherwise in type-specified field.
+  // - EXTERNAL - data stored in an external location as described by external_data field.
+  enum DataLocation {
+    DEFAULT = 0;
+    EXTERNAL = 1;
+  }
+
+  // If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
+  optional DataLocation data_location = 14;
+
+  // For double
+  // Complex128 tensors are encoded as a single array of doubles,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
+  repeated double double_data = 10 [packed = true];
+
+  // For uint64 and uint32 values
+  // When this field is present, the data_type field MUST be
+  // UINT32 or UINT64
+  repeated uint64 uint64_data = 11 [packed = true];
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+}
+
+// A serialized sparse-tensor value
+message SparseTensorProto {
+  // The sequence of non-default values are encoded as a tensor of shape [NNZ].
+  // The default-value is zero for numeric tensors, and empty-string for string tensors.
+  // values must have a non-empty name present which serves as a name for SparseTensorProto
+  // when used in sparse_initializer list.
+  optional TensorProto values = 1;
+
+  // The indices of the non-default values, which may be stored in one of two formats.
+  // (a) Indices can be a tensor of shape [NNZ, rank] with the [i,j]-th value
+  // corresponding to the j-th index of the i-th value (in the values tensor).
+  // (b) Indices can be a tensor of shape [NNZ], in which case the i-th value
+  // must be the linearized-index of the i-th value (in the values tensor).
+  // The linearized-index can be converted into an index tuple (k_1,...,k_rank)
+  // using the shape provided below.
+  // The indices must appear in ascending order without duplication.
+  // In the first format, the ordering is lexicographic-ordering:
+  // e.g., index-value [1,4] must appear before [2,1]
+  optional TensorProto indices = 2;
+
+  // The shape of the underlying dense-tensor: [dim_1, dim_2, ... dim_rank]
+  repeated int64 dims = 3;
+}
+
+// Defines a tensor shape. A dimension can be either an integer value
+// or a symbolic variable. A symbolic variable represents an unknown
+// dimension.
+message TensorShapeProto {
+  message Dimension {
+    oneof value {
+      int64 dim_value = 1;
+      string dim_param = 2;   // namespace Shape
+    };
+    // Standard denotation can optionally be used to denote tensor
+    // dimensions with standard semantic descriptions to ensure
+    // that operations are applied to the correct axis of a tensor.
+    // Refer to https://github.com/onnx/onnx/blob/main/docs/DimensionDenotation.md#denotation-definition
+    // for pre-defined dimension denotations.
+    optional string denotation = 3;
+  };
+  repeated Dimension dim = 1;
+}
+
+// Types
+//
+// The standard ONNX data types.
+message TypeProto {
+
+  message Tensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    optional int32 elem_type = 1;
+    optional TensorShapeProto shape = 2;
+  }
+
+  // repeated T
+  message Sequence {
+    // The type and optional shape of each element of the sequence.
+    // This field MUST be present for this version of the IR.
+    optional TypeProto elem_type = 1;
+  };
+
+  // map<K,V>
+  message Map {
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    // This field MUST refer to an integral type ([U]INT{8|16|32|64}) or STRING
+    optional int32 key_type = 1;
+    // This field MUST be present for this version of the IR.
+    optional TypeProto value_type = 2;
+  };
+
+  // wrapper for Tensor, Sequence, or Map
+  message Optional {
+    // The type and optional shape of the element wrapped.
+    // This field MUST be present for this version of the IR.
+    // Possible values correspond to OptionalProto.DataType enum
+    optional TypeProto elem_type = 1;
+  };
+
+
+  message SparseTensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    optional int32 elem_type = 1;
+    optional TensorShapeProto shape = 2;
+  }
+
+// #if ONNX-ML
+
+  message Opaque {
+    // When missing, the domain is the same as the model's.
+    optional string domain = 1;
+    // The name is optional but significant when provided.
+    optional string name = 2;
+    // parameters that help defining the type
+    // DEPRECATED do not use.
+    // repeated TypeProto parameters = 3;
+  }
+
+// #endif
+
+  oneof value {
+    // The type of a tensor.
+    Tensor tensor_type = 1;
+
+    // NOTE:  DNN-only implementations of ONNX MAY elect to not support non-tensor values
+    //        as input and output to graphs and nodes. These types are needed to naturally
+    //        support classical ML operators.  DNN operators SHOULD restrict their input
+    //        and output types to tensors.
+
+    // The type of a sequence.
+    Sequence sequence_type = 4;
+
+    // The type of a map.
+    Map map_type = 5;
+
+    // The type of an optional.
+    Optional optional_type = 9;
+
+
+    // Type of the sparse tensor
+    SparseTensor sparse_tensor_type = 8;
+
+// #if ONNX-ML
+
+    Opaque opaque_type = 7;
+
+// #endif
+  }
+
+  // An optional denotation can be used to denote the whole
+  // type with a standard semantic description as to what is
+  // stored inside. Refer to https://github.com/onnx/onnx/blob/main/docs/TypeDenotation.md#type-denotation-definition
+  // for pre-defined type denotations.
+  optional string denotation = 6;
+}
+
+// Operator Sets
+//
+// OperatorSets are uniquely identified by a (domain, opset_version) pair.
+message OperatorSetIdProto {
+  // The domain of the operator set being identified.
+  // The empty string ("") or absence of this field implies the operator
+  // set that is defined as part of the ONNX specification.
+  // This field MUST be present in this version of the IR when referring to any other operator set.
+  optional string domain = 1;
+
+  // The version of the operator set being identified.
+  // This field MUST be present in this version of the IR.
+  optional int64 version = 2;
+}
+
+// Operator/function status.
+enum OperatorStatus {
+    EXPERIMENTAL = 0;
+    STABLE = 1;
+}
+
+message FunctionProto {
+  // The name of the function, similar to op_type in NodeProto.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  optional string name = 1;
+
+  // Deprecated since IR Version 8
+  // optional int64 since_version = 2;
+  reserved 2;
+  reserved "since_version";
+
+  // Deprecated since IR Version 8
+  // optional OperatorStatus status = 3;
+  reserved 3;
+  reserved "status";
+
+  // The inputs and outputs of the function.
+  repeated string input = 4;
+  repeated string output = 5;
+
+  // The attribute parameters of the function.
+  // It is for function parameters without default values.
+  repeated string attribute = 6;
+
+  // The attribute protos of the function.
+  // It is for function attributes with default values.
+  // A function attribute shall be represented either as
+  // a string attribute or an AttributeProto, not both.
+  repeated AttributeProto attribute_proto = 11;
+
+  // The nodes in the function.
+  repeated NodeProto node = 7;
+  // A human-readable documentation for this function. Markdown is allowed.
+  optional string doc_string = 8;
+
+  // The OperatorSets this function body (graph) relies on.
+  //
+  // All nodes in the function body (graph) will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets. This means at most one version can be relied
+  // for one domain.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto. Example, if same operator set say 'A' is imported by FunctionProto
+  // and ModelProto then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same.
+
+  repeated OperatorSetIdProto opset_import = 9;
+
+  // The domain which this function belongs to.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  optional string domain = 10;
+
+  // The overload identifier of the function.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  optional string overload = 13;
+
+  // Information for the values in the function. The ValueInfoProto.name's
+  // must be distinct and refer to names in the function (including inputs,
+  // outputs, and intermediate values). It is optional for a value to appear
+  // in value_info list.
+  repeated ValueInfoProto value_info = 12;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+}
diff --git a/onnx/onnx.proto b/onnx/onnx.proto
new file mode 100644
index 0000000..d1f5dcd
--- /dev/null
+++ b/onnx/onnx.proto
@@ -0,0 +1,1000 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// SPDX-License-Identifier: Apache-2.0
+
+
+syntax = "proto2";
+
+package onnx;
+
+// Overview
+//
+// ONNX is an open specification that is comprised of the following components:
+//
+// 1)  A definition of an extensible computation graph model.
+// 2)  Definitions of standard data types.
+// 3)  Definitions of built-in operators.
+//
+// This document describes the syntax of models and their computation graphs,
+// as well as the standard data types. Together, they are referred to as the ONNX
+// Intermediate Representation, or 'IR' for short.
+//
+// The normative semantic specification of the ONNX IR is found in docs/IR.md.
+// Definitions of the built-in neural network operators may be found in docs/Operators.md.
+
+// Notes
+//
+// Protobuf compatibility
+//
+// To simplify framework compatibility, ONNX is defined using the subset of protobuf
+// that is compatible with both protobuf v2 and v3. This means that we do not use any
+// protobuf features that are only available in one of the two versions.
+//
+// Here are the most notable contortions we have to carry out to work around
+// these limitations:
+//
+//   - No 'map' (added protobuf 3.0). We instead represent mappings as lists
+//     of key-value pairs, where order does not matter and duplicates
+//     are not allowed.
+
+
+// Versioning
+//
+// ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md
+//
+// To be compatible with both proto2 and proto3, we will use a version number
+// that is not defined by the default value but an explicit enum number.
+enum Version {
+  // proto3 requires the first enum value to be zero.
+  // We add this just to appease the compiler.
+  _START_VERSION = 0;
+  // The version field is always serialized and we will use it to store the
+  // version that the  graph is generated from. This helps us set up version
+  // control.
+  // For the IR, we are using simple numbers starting with 0x00000001,
+  // which was the version we published on Oct 10, 2017.
+  IR_VERSION_2017_10_10 = 0x0000000000000001;
+
+  // IR_VERSION 2 published on Oct 30, 2017
+  // - Added type discriminator to AttributeProto to support proto3 users
+  IR_VERSION_2017_10_30 = 0x0000000000000002;
+
+  // IR VERSION 3 published on Nov 3, 2017
+  // - For operator versioning:
+  //    - Added new message OperatorSetIdProto
+  //    - Added opset_import in ModelProto
+  // - For vendor extensions, added domain in NodeProto
+  IR_VERSION_2017_11_3 = 0x0000000000000003;
+
+  // IR VERSION 4 published on Jan 22, 2019
+  // - Relax constraint that initializers should be a subset of graph inputs
+  // - Add type BFLOAT16
+  IR_VERSION_2019_1_22 = 0x0000000000000004;
+
+  // IR VERSION 5 published on March 18, 2019
+  // - Add message TensorAnnotation.
+  // - Add quantization annotation in GraphProto to map tensor with its scale and zero point quantization parameters.
+  IR_VERSION_2019_3_18 = 0x0000000000000005;
+
+  // IR VERSION 6 published on Sep 19, 2019
+  // - Add support for sparse tensor constants stored in model.
+  //   - Add message SparseTensorProto
+  //   - Add sparse initializers
+  IR_VERSION_2019_9_19 = 0x0000000000000006;
+
+  // IR VERSION 7 published on May 8, 2020
+  // - Add support to allow function body graph to rely on multiple external operator sets.
+  // - Add a list to promote inference graph's initializers to global and
+  //   mutable variables. Global variables are visible in all graphs of the
+  //   stored models.
+  // - Add message TrainingInfoProto to store initialization
+  //   method and training algorithm. The execution of TrainingInfoProto
+  //   can modify the values of mutable variables.
+  // - Implicitly add inference graph into each TrainingInfoProto's algorithm.
+  IR_VERSION_2020_5_8 = 0x0000000000000007;
+
+  // IR VERSION 8 published on July 30, 2021
+  // Introduce TypeProto.SparseTensor
+  // Introduce TypeProto.Optional
+  // Added a list of FunctionProtos local to the model
+  // Deprecated since_version and operator status from FunctionProto
+  IR_VERSION_2021_7_30 = 0x0000000000000008;
+
+  // IR VERSION 9 published on May 5, 2023
+  // Added AttributeProto to FunctionProto so that default attribute values can be set.
+  // Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ.
+  IR_VERSION_2023_5_5 = 0x0000000000000009;
+
+  // IR VERSION 10 published on March 25, 2024
+  // Added UINT4, INT4, overload field for functions and metadata_props on multiple proto definitions.
+  IR_VERSION_2024_3_25 = 0x000000000000000A;
+
+  // IR VERSION 11 published on May 12, 2025
+  // Added FLOAT4E2M1, multi-device protobuf classes.
+  IR_VERSION_2025_05_12 = 0x000000000000000B;
+
+  // IR VERSION 12 published on August 26, 2025
+  // Added FLOAT8E8M0.
+  IR_VERSION_2025_08_26 = 0x000000000000000C;
+
+  // IR VERSION 13 published on November 6, 2025
+  // Added UINT2, INT2.
+  IR_VERSION = 0x000000000000000D;
+}
+
+// Attributes
+//
+// A named attribute containing either singular float, integer, string, graph,
+// and tensor values, or repeated float, integer, string, graph, and tensor values.
+// An AttributeProto MUST contain the name field, and *only one* of the
+// following content fields, effectively enforcing a C/C++ union equivalent.
+message AttributeProto {
+  reserved 12, 16 to 19;
+  reserved "v";
+
+  // Note: this enum is structurally identical to the OpSchema::AttrType
+  // enum defined in schema.h.  If you rev one, you likely need to rev the other.
+  enum AttributeType {
+    UNDEFINED = 0;
+    FLOAT = 1;
+    INT = 2;
+    STRING = 3;
+    TENSOR = 4;
+    GRAPH = 5;
+    SPARSE_TENSOR = 11;
+    TYPE_PROTO = 13;
+
+    FLOATS = 6;
+    INTS = 7;
+    STRINGS = 8;
+    TENSORS = 9;
+    GRAPHS = 10;
+    SPARSE_TENSORS = 12;
+    TYPE_PROTOS = 14;
+  }
+
+  // The name field MUST be present for this version of the IR.
+  optional string name = 1;           // namespace Attribute
+
+  // if ref_attr_name is not empty, ref_attr_name is the attribute name in parent function.
+  // In this case, this AttributeProto does not contain data, and it's a reference of attribute
+  // in parent scope.
+  // NOTE: This should ONLY be used in function (sub-graph). It's invalid to be used in main graph.
+  optional string ref_attr_name = 21;
+
+  // A human-readable documentation for this attribute. Markdown is allowed.
+  optional string doc_string = 13;
+
+  // The type field MUST be present for this version of the IR.
+  // For 0.0.1 versions of the IR, this field was not defined, and
+  // implementations needed to use has_field heuristics to determine
+  // which value field was in use.  For IR_VERSION 0.0.2 or later, this
+  // field MUST be set and match the f|i|s|t|... field in use.  This
+  // change was made to accommodate proto3 implementations.
+  optional AttributeType type = 20;   // discriminator that indicates which field below is in use
+
+  // Exactly ONE of the following fields must be present for this version of the IR
+  optional float f = 2;               // float
+  optional int64 i = 3;               // int
+  optional bytes s = 4;               // UTF-8 string
+  optional TensorProto t = 5;         // tensor value
+  optional GraphProto g = 6;          // graph
+  optional SparseTensorProto sparse_tensor = 22;  // sparse tensor value
+  // Do not use field below, it's deprecated.
+  // optional ValueProto v = 12;         // value - subsumes everything but graph
+  optional TypeProto tp = 14;          // type proto
+
+  repeated float floats = 7;          // list of floats
+  repeated int64 ints = 8;            // list of ints
+  repeated bytes strings = 9;         // list of UTF-8 strings
+  repeated TensorProto tensors = 10;  // list of tensors
+  repeated GraphProto graphs = 11;    // list of graph
+  repeated SparseTensorProto sparse_tensors = 23; // list of sparse tensors
+  repeated TypeProto type_protos = 15;// list of type protos
+}
+
+// Defines information on value, including the name, the type, and
+// the shape of the value.
+message ValueInfoProto {
+  // This field MUST be present in this version of the IR.
+  optional string name = 1;     // namespace Value
+  // This field MUST be present in this version of the IR for
+  // inputs and outputs of the top-level graph.
+  optional TypeProto type = 2;
+  // A human-readable documentation for this value. Markdown is allowed.
+  optional string doc_string = 3;
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 4;
+}
+
+// Nodes
+//
+// Computation graphs are made up of a DAG of nodes, which represent what is
+// commonly called a "layer" or "pipeline stage" in machine learning frameworks.
+//
+// For example, it can be a node of type "Conv" that takes in an image, a filter
+// tensor and a bias tensor, and produces the convolved output.
+message NodeProto {
+  repeated string input = 1;    // namespace Value
+  repeated string output = 2;   // namespace Value
+
+  // An optional identifier for this node in a graph.
+  // This field MAY be absent in this version of the IR.
+  optional string name = 3;     // namespace Node
+
+  // The symbolic identifier of the Operator to execute.
+  optional string op_type = 4;  // namespace Operator
+  // The domain of the OperatorSet that specifies the operator named by op_type.
+  optional string domain = 7;   // namespace Domain
+  // Overload identifier, used only to map this to a model-local function.
+  optional string overload = 8;
+
+  // Additional named attributes.
+  repeated AttributeProto attribute = 5;
+
+  // A human-readable documentation for this node. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 9;
+
+  // Configuration of multi-device annotations.
+  repeated NodeDeviceConfigurationProto device_configurations = 10;
+}
+
+// IntIntListEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message IntIntListEntryProto {
+  optional int64 key = 1;
+  repeated int64 value = 2;
+};
+
+// Multi-device configuration proto for NodeProto.
+message NodeDeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // ID of the configuration. MUST match the name of a DeviceConfigurationProto.
+    optional string configuration_id = 1;
+    // Sharding spec for the node.
+    repeated ShardingSpecProto sharding_spec = 2;
+    // Pipeline stage of this node.
+    optional int32 pipeline_stage = 3;
+}
+
+// ShardingSpecProto: This describes the sharding spec for a specific
+// input or output tensor of a node.
+message ShardingSpecProto {
+  // This field MUST be present for this version of the IR.
+  // Identifies the input or output of the node that is being sharded.
+  // Required to match a name specified in the node's input or output list of ValueInfoProtos.
+  // It is called `logical tensor` in subsequent descriptions.
+  optional string tensor_name = 1;
+
+  // The following is the list of devices across which the logical
+  // tensor is sharded or replicated.
+  repeated int64 device = 2;
+
+  // Each element v in above field devices may represent either a
+  // device or a set of devices (when we want the same shard/tensor
+  // to be replicated across a subset of devices), as indicated by
+  // the following optional map. If the map contains an entry for v,
+  // then v represents a device group, and the map indicates the set
+  // of devices in that group.
+  repeated IntIntListEntryProto index_to_device_group_map = 3;
+
+  // The following is the sharded-shape of the tensor, consisting of
+  // the sharding-spec for each axis of the tensor.
+  repeated ShardedDimProto sharded_dim = 4;
+}
+
+// ShardedDimProto: This describes the sharding spec for a single
+// axis of a sharded tensor.
+message ShardedDimProto {
+  // This field MUST be present for this version of the IR.
+  // The axis this sharding corresponds to. Must be in the range of
+  // [-r, r - 1], where r is the rank of the tensor. Negative axis values means
+  // counting from the back.
+  optional int64 axis = 1;
+
+  // Describes how the tensor on the provided axis is sharded.
+  // The common-case is described by a single instance of SimpleShardedDimProto.
+  // Multiple instances can be used to handle cases where a sharded
+  // tensor is reshaped, fusing multiple axes into one.
+  repeated SimpleShardedDimProto simple_sharding = 2;
+}
+
+// SimpleShardedDimProto: Indicates that N blocks are divided into M shards.
+// N is allowed to be symbolic where M is required to be a constant.
+message SimpleShardedDimProto {
+    // Dimension value to be sharded.
+    oneof dim {
+        int64 dim_value = 1;
+        string dim_param = 2;
+    }
+
+    // This field MUST be present for this version of the IR.
+    // Number of shards to split dim into.
+    optional int64 num_shards = 3;
+}
+
+// Training information
+// TrainingInfoProto stores information for training a model.
+// In particular, this defines two functionalities: an initialization-step
+// and a training-algorithm-step. Initialization resets the model
+// back to its original state as if no training has been performed.
+// Training algorithm improves the model based on input data.
+//
+// The semantics of the initialization-step is that the initializers
+// in ModelProto.graph and in TrainingInfoProto.algorithm are first
+// initialized as specified by the initializers in the graph, and then
+// updated by the "initialization_binding" in every instance in
+// ModelProto.training_info.
+//
+// The field "algorithm" defines a computation graph which represents a
+// training algorithm's step. After the execution of a
+// TrainingInfoProto.algorithm, the initializers specified by "update_binding"
+// may be immediately updated. If the targeted training algorithm contains
+// consecutive update steps (such as block coordinate descent methods),
+// the user needs to create a TrainingInfoProto for each step.
+message TrainingInfoProto {
+  // This field describes a graph to compute the initial tensors
+  // upon starting the training process. Initialization graph has no input
+  // and can have multiple outputs. Usually, trainable tensors in neural
+  // networks are randomly initialized. To achieve that, for each tensor,
+  // the user can put a random number operator such as RandomNormal or
+  // RandomUniform in TrainingInfoProto.initialization.node and assign its
+  // random output to the specific tensor using "initialization_binding".
+  // This graph can also set the initializers in "algorithm" in the same
+  // TrainingInfoProto; a use case is resetting the number of training
+  // iteration to zero.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Thus, no initializer would be changed by default.
+  optional GraphProto initialization = 1;
+
+  // This field represents a training algorithm step. Given required inputs,
+  // it computes outputs to update initializers in its own or inference graph's
+  // initializer lists. In general, this field contains loss node, gradient node,
+  // optimizer node, increment of iteration count.
+  //
+  // An execution of the training algorithm step is performed by executing the
+  // graph obtained by combining the inference graph (namely "ModelProto.graph")
+  // and the "algorithm" graph. That is, the actual
+  // input/initializer/output/node/value_info/sparse_initializer list of
+  // the training graph is the concatenation of
+  // "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer"
+  // and "algorithm.input/initializer/output/node/value_info/sparse_initializer"
+  // in that order. This combined graph must satisfy the normal ONNX conditions.
+  // Now, let's provide a visualization of graph combination for clarity.
+  // Let the inference graph (i.e., "ModelProto.graph") be
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d
+  // and the "algorithm" graph be
+  //    tensor_d -> Add -> tensor_e
+  // The combination process results
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add -> tensor_e
+  //
+  // Notice that an input of a node in the "algorithm" graph may reference the
+  // output of a node in the inference graph (but not the other way round). Also, inference
+  // node cannot reference inputs of "algorithm". With these restrictions, inference graph
+  // can always be run independently without training information.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Evaluating the default training step never
+  // update any initializers.
+  optional GraphProto algorithm = 2;
+
+  // This field specifies the bindings from the outputs of "initialization" to
+  // some initializers in "ModelProto.graph.initializer" and
+  // the "algorithm.initializer" in the same TrainingInfoProto.
+  // See "update_binding" below for details.
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "initialization".
+  repeated StringStringEntryProto initialization_binding = 3;
+
+  // Gradient-based training is usually an iterative procedure. In one gradient
+  // descent iteration, we apply
+  //
+  // x = x - r * g
+  //
+  // where "x" is the optimized tensor, "r" stands for learning rate, and "g" is
+  // gradient of "x" with respect to a chosen loss. To avoid adding assignments
+  // into the training graph, we split the update equation into
+  //
+  // y = x - r * g
+  // x = y
+  //
+  // The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To
+  // tell that "y" should be assigned to "x", the field "update_binding" may
+  // contain a key-value pair of strings, "x" (key of StringStringEntryProto)
+  // and "y" (value of StringStringEntryProto).
+  // For a neural network with multiple trainable (mutable) tensors, there can
+  // be multiple key-value pairs in "update_binding".
+  //
+  // The initializers appears as keys in "update_binding" are considered
+  // mutable variables. This implies some behaviors
+  // as described below.
+  //
+  //  1. We have only unique keys in all "update_binding"s so that two
+  //     variables may not have the same name. This ensures that one
+  //     variable is assigned up to once.
+  //  2. The keys must appear in names of "ModelProto.graph.initializer" or
+  //     "TrainingInfoProto.algorithm.initializer".
+  //  3. The values must be output names of "algorithm" or "ModelProto.graph.output".
+  //  4. Mutable variables are initialized to the value specified by the
+  //     corresponding initializer, and then potentially updated by
+  //     "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s.
+  //
+  // This field usually contains names of trainable tensors
+  // (in ModelProto.graph), optimizer states such as momentums in advanced
+  // stochastic gradient methods (in TrainingInfoProto.graph),
+  // and number of training iterations (in TrainingInfoProto.graph).
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "algorithm".
+  repeated StringStringEntryProto update_binding = 4;
+}
+
+// Models
+//
+// ModelProto is a top-level file/container format for bundling a ML model and
+// associating its computation graph with metadata.
+//
+// The semantics of the model are described by the associated GraphProto's.
+message ModelProto {
+  // The version of the IR this model targets. See Version enum above.
+  // This field MUST be present.
+  optional int64 ir_version = 1;
+
+  // The OperatorSets this model relies on.
+  // All ModelProtos MUST have at least one entry that
+  // specifies which version of the ONNX OperatorSet is
+  // being imported.
+  //
+  // All nodes in the ModelProto's graph will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets.
+  repeated OperatorSetIdProto opset_import = 8;
+
+  // The name of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  optional string producer_name = 2;
+
+  // The version of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  optional string producer_version = 3;
+
+  // Domain name of the model.
+  // We use reverse domain names as name space indicators. For example:
+  // `com.facebook.fair` or `com.microsoft.cognitiveservices`
+  //
+  // Together with `model_version` and GraphProto.name, this forms the unique identity of
+  // the graph.
+  optional string domain = 4;
+
+  // The version of the graph encoded. See Version enum below.
+  optional int64 model_version = 5;
+
+  // A human-readable documentation for this model. Markdown is allowed.
+  optional string doc_string = 6;
+
+  // The parameterized graph that is evaluated to execute the model.
+  optional GraphProto graph = 7;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+
+  // Training-specific information. Sequentially executing all stored
+  // `TrainingInfoProto.algorithm`s and assigning their outputs following
+  // the corresponding `TrainingInfoProto.update_binding`s is one training
+  // iteration. Similarly, to initialize the model
+  // (as if training hasn't happened), the user should sequentially execute
+  // all stored `TrainingInfoProto.initialization`s and assigns their outputs
+  // using `TrainingInfoProto.initialization_binding`s.
+  //
+  // If this field is empty, the training behavior of the model is undefined.
+  repeated TrainingInfoProto training_info = 20;
+
+  // A list of function protos local to the model.
+  //
+  // The (domain, name, overload) tuple must be unique across the function protos in this list.
+  // In case of any conflicts the behavior (whether the model local functions are given higher priority,
+  // or standard operator sets are given higher priority or this is treated as error) is defined by
+  // the runtimes.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto and other model local FunctionProtos.
+  // Example, if same operator set say 'A' is imported by a FunctionProto and ModelProto
+  // or by 2 FunctionProtos then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same for every node in the function body.
+  //
+  // One FunctionProto can reference other FunctionProto in the model, however, recursive reference
+  // is not allowed.
+  repeated FunctionProto functions = 25;
+
+  // Describes different target configurations for a multi-device use case.
+  // A model MAY describe multiple multi-device configurations for execution.
+  repeated DeviceConfigurationProto configuration = 26;
+};
+
+// DeviceConfigurationProto describes a multi-device configuration for a model.
+message DeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // Name of the configuration.
+    optional string name = 1;
+    // This field MUST be present for this version of the IR.
+    // Number of devices inside this configuration.
+    optional int32 num_devices = 2;
+    // Optional names of the devices. MUST be length of num_devices if provided.
+    repeated string device = 3;
+}
+
+// StringStringEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message StringStringEntryProto {
+  optional string key = 1;
+  optional string value = 2;
+};
+
+message TensorAnnotation {
+  optional string tensor_name = 1;
+  // <key, value> pairs to annotate tensor specified by <tensor_name> above.
+  // The keys used in the mapping below must be pre-defined in ONNX spec.
+  // For example, for 8-bit linear quantization case, 'SCALE_TENSOR', 'ZERO_POINT_TENSOR' will be pre-defined as
+  // quantization parameter keys.
+  repeated StringStringEntryProto quant_parameter_tensor_names = 2;
+}
+
+
+
+// Graphs
+//
+// A graph defines the computational logic of a model and is comprised of a parameterized
+// list of nodes that form a directed acyclic graph based on their inputs and outputs.
+// This is the equivalent of the "network" or "graph" in many deep learning
+// frameworks.
+message GraphProto {
+  // The nodes in the graph, sorted topologically.
+  repeated NodeProto node = 1;
+
+  // The name of the graph.
+  optional string name = 2;   // namespace Graph
+
+  // A list of named tensor values, used to specify constant inputs of the graph.
+  // Each initializer (both TensorProto as well SparseTensorProto) MUST have a name.
+  // The name MUST be unique across both initializer and sparse_initializer,
+  // but the name MAY also appear in the input list.
+  repeated TensorProto initializer = 5;
+
+  // Initializers (see above) stored in sparse format.
+  repeated SparseTensorProto sparse_initializer = 15;
+
+  // A human-readable documentation for this graph. Markdown is allowed.
+  optional string doc_string = 10;
+
+  // The inputs and outputs of the graph.
+  repeated ValueInfoProto input = 11;
+  repeated ValueInfoProto output = 12;
+
+  // Information for the values in the graph. The ValueInfoProto.name's
+  // must be distinct. It is optional for a value to appear in value_info list.
+  repeated ValueInfoProto value_info = 13;
+
+  // This field carries information to indicate the mapping among a tensor and its
+  // quantization parameter tensors. For example:
+  // For tensor 'a', it may have {'SCALE_TENSOR', 'a_scale'} and {'ZERO_POINT_TENSOR', 'a_zero_point'} annotated,
+  // which means, tensor 'a_scale' and tensor 'a_zero_point' are scale and zero point of tensor 'a' in the model.
+  repeated TensorAnnotation quantization_annotation = 14;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+
+  reserved 3, 4, 6 to 9;
+  reserved "ir_version", "producer_version", "producer_tag", "domain";
+}
+
+// Tensors
+//
+// A serialized tensor value.
+message TensorProto {
+  enum DataType {
+    UNDEFINED = 0;
+    // Basic types.
+    FLOAT = 1;   // float
+    UINT8 = 2;   // uint8_t
+    INT8 = 3;    // int8_t
+    UINT16 = 4;  // uint16_t
+    INT16 = 5;   // int16_t
+    INT32 = 6;   // int32_t
+    INT64 = 7;   // int64_t
+    STRING = 8;  // string
+    BOOL = 9;    // bool
+
+    // IEEE754 half-precision floating-point format (16 bits wide).
+    // This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
+    FLOAT16 = 10;
+
+    DOUBLE = 11;
+    UINT32 = 12;
+    UINT64 = 13;
+    COMPLEX64 = 14;     // complex with float32 real and imaginary components
+    COMPLEX128 = 15;    // complex with float64 real and imaginary components
+
+    // Non-IEEE floating-point format based on IEEE754 single-precision
+    // floating-point number truncated to 16 bits.
+    // This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
+    BFLOAT16 = 16;
+
+    // Non-IEEE floating-point format based on papers
+    // FP8 Formats for Deep Learning, https://arxiv.org/abs/2209.05433,
+    // 8-bit Numerical Formats For Deep Neural Networks, https://arxiv.org/pdf/2206.02915.pdf.
+    // Operators supported FP8 are Cast, CastLike, QuantizeLinear, DequantizeLinear.
+    // The computation usually happens inside a block quantize / dequantize
+    // fused by the runtime.
+    FLOAT8E4M3FN = 17;    // float 8, mostly used for coefficients, supports nan, not inf
+    FLOAT8E4M3FNUZ = 18;  // float 8, mostly used for coefficients, supports nan, not inf, no negative zero
+    FLOAT8E5M2 = 19;      // follows IEEE 754, supports nan, inf, mostly used for gradients
+    FLOAT8E5M2FNUZ = 20;  // follows IEEE 754, supports nan, not inf, mostly used for gradients, no negative zero
+
+    // 4-bit integer data types
+    UINT4 = 21;  // Unsigned integer in range [0, 15]
+    INT4 = 22;   // Signed integer in range [-8, 7], using two's-complement representation
+
+    // 4-bit floating point data types
+    FLOAT4E2M1 = 23;
+
+    // E8M0 type used as the scale for microscaling (MX) formats:
+    // https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
+    FLOAT8E8M0 = 24;
+
+    // 2-bit integer data type
+    UINT2 = 25; // Unsigned integer in range [0, 3]
+    INT2 = 26;  // Signed integer in range [-2, 1], using two's complement representation
+
+    // Future extensions go here.
+  }
+
+  // The shape of the tensor.
+  repeated int64 dims = 1;
+
+  // The data type of the tensor.
+  // This field MUST have a valid TensorProto.DataType value
+  optional int32 data_type = 2;
+
+  // For very large tensors, we may want to store them in chunks, in which
+  // case the following fields will specify the segment that is stored in
+  // the current TensorProto.
+  message Segment {
+    optional int64 begin = 1;
+    optional int64 end = 2;
+  }
+  optional Segment segment = 3;
+
+  // Tensor content must be organized in row-major order.
+  //
+  // Depending on the data_type field, exactly one of the fields below with
+  // name ending in _data is used to store the elements of the tensor.
+
+  // For float and complex64 values
+  // Complex64 tensors are encoded as a single array of floats,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
+  repeated float float_data = 4 [packed = true];
+
+  // For int32, uint8, int8, uint16, int16, uint4, int4, uint2, int2, bool, (b)float16, float8, and float4:
+  // - (b)float16 and float8 values MUST be converted bit-wise into an unsigned integer
+  //   representation before being written to the buffer.
+  // - Each pair of uint4, int4, and float4 values MUST be packed as two 4-bit elements into a single byte.
+  //   The first element is stored in the 4 least significant bits (LSB),
+  //   and the second element is stored in the 4 most significant bits (MSB).
+  // - Each group of four uint2, int2 values MUST be packed as four 2-bit elements into a single byte.
+  //   The elements are packed from LSB to MSB, with the first element in bits 0-1, second element in bits 2-3,
+  //   third element in bits 4-5, and fourth element in bits 6-7.
+  //
+  // Consequently:
+  // - For data types with a bit-width of 8 or greater, each `int32_data` stores one element.
+  // - For 4-bit data types, each `int32_data` stores two elements.
+  // - For 2-bit data types, each `int32_data` stores four elements.
+  //
+  // When this field is present, the data_type field MUST be
+  // INT32, INT16, INT8, INT4, INT2, UINT16, UINT8, UINT4, UINT2, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ, FLOAT8E8M0, FLOAT4E2M1
+  repeated int32 int32_data = 5 [packed = true];
+
+  // For strings.
+  // Each element of string_data is a UTF-8 encoded Unicode
+  // string. No trailing null, no leading BOM. The protobuf "string"
+  // scalar type is not used to match ML community conventions.
+  // When this field is present, the data_type field MUST be STRING
+  repeated bytes string_data = 6;
+
+  // For int64.
+  // When this field is present, the data_type field MUST be INT64
+  repeated int64 int64_data = 7 [packed = true];
+
+  // Optionally, a name for the tensor.
+  optional string name = 8; // namespace Value
+
+  // A human-readable documentation for this tensor. Markdown is allowed.
+  optional string doc_string = 12;
+
+  // Serializations can either use one of the fields above, or use this
+  // raw bytes field. The only exception is the string case, where one is
+  // required to store the content in the repeated bytes string_data field.
+  //
+  // When this raw_data field is used to store tensor value, elements MUST
+  // be stored in as fixed-width, little-endian order.
+  // Floating-point data types MUST be stored in IEEE 754 format.
+  // Complex64 elements must be written as two consecutive FLOAT values, real component first.
+  // Complex128 elements must be written as two consecutive DOUBLE values, real component first.
+  // Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
+  // uint4 and int4 values must be packed to 4bitx2, the first element is stored in the 4 LSB and the second element is stored in the 4 MSB.
+  // uint2 and int2 values must be packed to 2bitx4, with elements packed from LSB to MSB in a single byte as: x0 | (x1 << 2) | (x2 << 4) | (x3 << 6)
+  // where x0, x1, x2, x3 are consecutive elements.
+  //
+  // Note: the advantage of specific field rather than the raw_data field is
+  // that in some cases (e.g. int data), protobuf does a better packing via
+  // variable length storage, and may lead to smaller binary footprint.
+  // When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
+  optional bytes raw_data = 9;
+
+  // Data can be stored inside the protobuf file using type-specific fields or raw_data.
+  // Alternatively, raw bytes data can be stored in an external file, using the external_data field.
+  // external_data stores key-value pairs describing data location. Recognized keys are:
+  // - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
+  //                           protobuf model was stored
+  // - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
+  //                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
+  // - "length" (optional) - number of bytes containing data. Integer stored as string.
+  // - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
+  repeated StringStringEntryProto external_data = 13;
+
+  // Location of the data for this tensor. MUST be one of:
+  // - DEFAULT - data stored inside the protobuf message. Data is stored in raw_data (if set) otherwise in type-specified field.
+  // - EXTERNAL - data stored in an external location as described by external_data field.
+  enum DataLocation {
+    DEFAULT = 0;
+    EXTERNAL = 1;
+  }
+
+  // If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
+  optional DataLocation data_location = 14;
+
+  // For double
+  // Complex128 tensors are encoded as a single array of doubles,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
+  repeated double double_data = 10 [packed = true];
+
+  // For uint64 and uint32 values
+  // When this field is present, the data_type field MUST be
+  // UINT32 or UINT64
+  repeated uint64 uint64_data = 11 [packed = true];
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+}
+
+// A serialized sparse-tensor value
+message SparseTensorProto {
+  // The sequence of non-default values are encoded as a tensor of shape [NNZ].
+  // The default-value is zero for numeric tensors, and empty-string for string tensors.
+  // values must have a non-empty name present which serves as a name for SparseTensorProto
+  // when used in sparse_initializer list.
+  optional TensorProto values = 1;
+
+  // The indices of the non-default values, which may be stored in one of two formats.
+  // (a) Indices can be a tensor of shape [NNZ, rank] with the [i,j]-th value
+  // corresponding to the j-th index of the i-th value (in the values tensor).
+  // (b) Indices can be a tensor of shape [NNZ], in which case the i-th value
+  // must be the linearized-index of the i-th value (in the values tensor).
+  // The linearized-index can be converted into an index tuple (k_1,...,k_rank)
+  // using the shape provided below.
+  // The indices must appear in ascending order without duplication.
+  // In the first format, the ordering is lexicographic-ordering:
+  // e.g., index-value [1,4] must appear before [2,1]
+  optional TensorProto indices = 2;
+
+  // The shape of the underlying dense-tensor: [dim_1, dim_2, ... dim_rank]
+  repeated int64 dims = 3;
+}
+
+// Defines a tensor shape. A dimension can be either an integer value
+// or a symbolic variable. A symbolic variable represents an unknown
+// dimension.
+message TensorShapeProto {
+  message Dimension {
+    oneof value {
+      int64 dim_value = 1;
+      string dim_param = 2;   // namespace Shape
+    };
+    // Standard denotation can optionally be used to denote tensor
+    // dimensions with standard semantic descriptions to ensure
+    // that operations are applied to the correct axis of a tensor.
+    // Refer to https://github.com/onnx/onnx/blob/main/docs/DimensionDenotation.md#denotation-definition
+    // for pre-defined dimension denotations.
+    optional string denotation = 3;
+  };
+  repeated Dimension dim = 1;
+}
+
+// Types
+//
+// The standard ONNX data types.
+message TypeProto {
+
+  message Tensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    optional int32 elem_type = 1;
+    optional TensorShapeProto shape = 2;
+  }
+
+  // repeated T
+  message Sequence {
+    // The type and optional shape of each element of the sequence.
+    // This field MUST be present for this version of the IR.
+    optional TypeProto elem_type = 1;
+  };
+
+  // map<K,V>
+  message Map {
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    // This field MUST refer to an integral type ([U]INT{8|16|32|64}) or STRING
+    optional int32 key_type = 1;
+    // This field MUST be present for this version of the IR.
+    optional TypeProto value_type = 2;
+  };
+
+  // wrapper for Tensor, Sequence, or Map
+  message Optional {
+    // The type and optional shape of the element wrapped.
+    // This field MUST be present for this version of the IR.
+    // Possible values correspond to OptionalProto.DataType enum
+    optional TypeProto elem_type = 1;
+  };
+
+
+  message SparseTensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    optional int32 elem_type = 1;
+    optional TensorShapeProto shape = 2;
+  }
+
+
+  oneof value {
+    // The type of a tensor.
+    Tensor tensor_type = 1;
+
+    // NOTE:  DNN-only implementations of ONNX MAY elect to not support non-tensor values
+    //        as input and output to graphs and nodes. These types are needed to naturally
+    //        support classical ML operators.  DNN operators SHOULD restrict their input
+    //        and output types to tensors.
+
+    // The type of a sequence.
+    Sequence sequence_type = 4;
+
+    // The type of a map.
+    Map map_type = 5;
+
+    // The type of an optional.
+    Optional optional_type = 9;
+
+
+    // Type of the sparse tensor
+    SparseTensor sparse_tensor_type = 8;
+
+  }
+
+  // An optional denotation can be used to denote the whole
+  // type with a standard semantic description as to what is
+  // stored inside. Refer to https://github.com/onnx/onnx/blob/main/docs/TypeDenotation.md#type-denotation-definition
+  // for pre-defined type denotations.
+  optional string denotation = 6;
+}
+
+// Operator Sets
+//
+// OperatorSets are uniquely identified by a (domain, opset_version) pair.
+message OperatorSetIdProto {
+  // The domain of the operator set being identified.
+  // The empty string ("") or absence of this field implies the operator
+  // set that is defined as part of the ONNX specification.
+  // This field MUST be present in this version of the IR when referring to any other operator set.
+  optional string domain = 1;
+
+  // The version of the operator set being identified.
+  // This field MUST be present in this version of the IR.
+  optional int64 version = 2;
+}
+
+// Operator/function status.
+enum OperatorStatus {
+    EXPERIMENTAL = 0;
+    STABLE = 1;
+}
+
+message FunctionProto {
+  // The name of the function, similar to op_type in NodeProto.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  optional string name = 1;
+
+  // Deprecated since IR Version 8
+  // optional int64 since_version = 2;
+  reserved 2;
+  reserved "since_version";
+
+  // Deprecated since IR Version 8
+  // optional OperatorStatus status = 3;
+  reserved 3;
+  reserved "status";
+
+  // The inputs and outputs of the function.
+  repeated string input = 4;
+  repeated string output = 5;
+
+  // The attribute parameters of the function.
+  // It is for function parameters without default values.
+  repeated string attribute = 6;
+
+  // The attribute protos of the function.
+  // It is for function attributes with default values.
+  // A function attribute shall be represented either as
+  // a string attribute or an AttributeProto, not both.
+  repeated AttributeProto attribute_proto = 11;
+
+  // The nodes in the function.
+  repeated NodeProto node = 7;
+  // A human-readable documentation for this function. Markdown is allowed.
+  optional string doc_string = 8;
+
+  // The OperatorSets this function body (graph) relies on.
+  //
+  // All nodes in the function body (graph) will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets. This means at most one version can be relied
+  // for one domain.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto. Example, if same operator set say 'A' is imported by FunctionProto
+  // and ModelProto then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same.
+
+  repeated OperatorSetIdProto opset_import = 9;
+
+  // The domain which this function belongs to.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  optional string domain = 10;
+
+  // The overload identifier of the function.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  optional string overload = 13;
+
+  // Information for the values in the function. The ValueInfoProto.name's
+  // must be distinct and refer to names in the function (including inputs,
+  // outputs, and intermediate values). It is optional for a value to appear
+  // in value_info list.
+  repeated ValueInfoProto value_info = 12;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+}
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx.proto3 b/onnx/onnx.proto3
new file mode 100644
index 0000000..f89195f
--- /dev/null
+++ b/onnx/onnx.proto3
@@ -0,0 +1,1000 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+
+// SPDX-License-Identifier: Apache-2.0
+
+
+syntax = "proto3";
+
+package onnx;
+
+// Overview
+//
+// ONNX is an open specification that is comprised of the following components:
+//
+// 1)  A definition of an extensible computation graph model.
+// 2)  Definitions of standard data types.
+// 3)  Definitions of built-in operators.
+//
+// This document describes the syntax of models and their computation graphs,
+// as well as the standard data types. Together, they are referred to as the ONNX
+// Intermediate Representation, or 'IR' for short.
+//
+// The normative semantic specification of the ONNX IR is found in docs/IR.md.
+// Definitions of the built-in neural network operators may be found in docs/Operators.md.
+
+// Notes
+//
+// Protobuf compatibility
+//
+// To simplify framework compatibility, ONNX is defined using the subset of protobuf
+// that is compatible with both protobuf v2 and v3. This means that we do not use any
+// protobuf features that are only available in one of the two versions.
+//
+// Here are the most notable contortions we have to carry out to work around
+// these limitations:
+//
+//   - No 'map' (added protobuf 3.0). We instead represent mappings as lists
+//     of key-value pairs, where order does not matter and duplicates
+//     are not allowed.
+
+
+// Versioning
+//
+// ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md
+//
+// To be compatible with both proto2 and proto3, we will use a version number
+// that is not defined by the default value but an explicit enum number.
+enum Version {
+  // proto3 requires the first enum value to be zero.
+  // We add this just to appease the compiler.
+  _START_VERSION = 0;
+  // The version field is always serialized and we will use it to store the
+  // version that the  graph is generated from. This helps us set up version
+  // control.
+  // For the IR, we are using simple numbers starting with 0x00000001,
+  // which was the version we published on Oct 10, 2017.
+  IR_VERSION_2017_10_10 = 0x0000000000000001;
+
+  // IR_VERSION 2 published on Oct 30, 2017
+  // - Added type discriminator to AttributeProto to support proto3 users
+  IR_VERSION_2017_10_30 = 0x0000000000000002;
+
+  // IR VERSION 3 published on Nov 3, 2017
+  // - For operator versioning:
+  //    - Added new message OperatorSetIdProto
+  //    - Added opset_import in ModelProto
+  // - For vendor extensions, added domain in NodeProto
+  IR_VERSION_2017_11_3 = 0x0000000000000003;
+
+  // IR VERSION 4 published on Jan 22, 2019
+  // - Relax constraint that initializers should be a subset of graph inputs
+  // - Add type BFLOAT16
+  IR_VERSION_2019_1_22 = 0x0000000000000004;
+
+  // IR VERSION 5 published on March 18, 2019
+  // - Add message TensorAnnotation.
+  // - Add quantization annotation in GraphProto to map tensor with its scale and zero point quantization parameters.
+  IR_VERSION_2019_3_18 = 0x0000000000000005;
+
+  // IR VERSION 6 published on Sep 19, 2019
+  // - Add support for sparse tensor constants stored in model.
+  //   - Add message SparseTensorProto
+  //   - Add sparse initializers
+  IR_VERSION_2019_9_19 = 0x0000000000000006;
+
+  // IR VERSION 7 published on May 8, 2020
+  // - Add support to allow function body graph to rely on multiple external operator sets.
+  // - Add a list to promote inference graph's initializers to global and
+  //   mutable variables. Global variables are visible in all graphs of the
+  //   stored models.
+  // - Add message TrainingInfoProto to store initialization
+  //   method and training algorithm. The execution of TrainingInfoProto
+  //   can modify the values of mutable variables.
+  // - Implicitly add inference graph into each TrainingInfoProto's algorithm.
+  IR_VERSION_2020_5_8 = 0x0000000000000007;
+
+  // IR VERSION 8 published on July 30, 2021
+  // Introduce TypeProto.SparseTensor
+  // Introduce TypeProto.Optional
+  // Added a list of FunctionProtos local to the model
+  // Deprecated since_version and operator status from FunctionProto
+  IR_VERSION_2021_7_30 = 0x0000000000000008;
+
+  // IR VERSION 9 published on May 5, 2023
+  // Added AttributeProto to FunctionProto so that default attribute values can be set.
+  // Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ.
+  IR_VERSION_2023_5_5 = 0x0000000000000009;
+
+  // IR VERSION 10 published on March 25, 2024
+  // Added UINT4, INT4, overload field for functions and metadata_props on multiple proto definitions.
+  IR_VERSION_2024_3_25 = 0x000000000000000A;
+
+  // IR VERSION 11 published on May 12, 2025
+  // Added FLOAT4E2M1, multi-device protobuf classes.
+  IR_VERSION_2025_05_12 = 0x000000000000000B;
+
+  // IR VERSION 12 published on August 26, 2025
+  // Added FLOAT8E8M0.
+  IR_VERSION_2025_08_26 = 0x000000000000000C;
+
+  // IR VERSION 13 published on November 6, 2025
+  // Added UINT2, INT2.
+  IR_VERSION = 0x000000000000000D;
+}
+
+// Attributes
+//
+// A named attribute containing either singular float, integer, string, graph,
+// and tensor values, or repeated float, integer, string, graph, and tensor values.
+// An AttributeProto MUST contain the name field, and *only one* of the
+// following content fields, effectively enforcing a C/C++ union equivalent.
+message AttributeProto {
+  reserved 12, 16 to 19;
+  reserved "v";
+
+  // Note: this enum is structurally identical to the OpSchema::AttrType
+  // enum defined in schema.h.  If you rev one, you likely need to rev the other.
+  enum AttributeType {
+    UNDEFINED = 0;
+    FLOAT = 1;
+    INT = 2;
+    STRING = 3;
+    TENSOR = 4;
+    GRAPH = 5;
+    SPARSE_TENSOR = 11;
+    TYPE_PROTO = 13;
+
+    FLOATS = 6;
+    INTS = 7;
+    STRINGS = 8;
+    TENSORS = 9;
+    GRAPHS = 10;
+    SPARSE_TENSORS = 12;
+    TYPE_PROTOS = 14;
+  }
+
+  // The name field MUST be present for this version of the IR.
+  string name = 1;           // namespace Attribute
+
+  // if ref_attr_name is not empty, ref_attr_name is the attribute name in parent function.
+  // In this case, this AttributeProto does not contain data, and it's a reference of attribute
+  // in parent scope.
+  // NOTE: This should ONLY be used in function (sub-graph). It's invalid to be used in main graph.
+  string ref_attr_name = 21;
+
+  // A human-readable documentation for this attribute. Markdown is allowed.
+  string doc_string = 13;
+
+  // The type field MUST be present for this version of the IR.
+  // For 0.0.1 versions of the IR, this field was not defined, and
+  // implementations needed to use has_field heuristics to determine
+  // which value field was in use.  For IR_VERSION 0.0.2 or later, this
+  // field MUST be set and match the f|i|s|t|... field in use.  This
+  // change was made to accommodate proto3 implementations.
+  AttributeType type = 20;   // discriminator that indicates which field below is in use
+
+  // Exactly ONE of the following fields must be present for this version of the IR
+  float f = 2;               // float
+  int64 i = 3;               // int
+  bytes s = 4;               // UTF-8 string
+  TensorProto t = 5;         // tensor value
+  GraphProto g = 6;          // graph
+  SparseTensorProto sparse_tensor = 22;  // sparse tensor value
+  // Do not use field below, it's deprecated.
+  // optional ValueProto v = 12;         // value - subsumes everything but graph
+  TypeProto tp = 14;          // type proto
+
+  repeated float floats = 7;          // list of floats
+  repeated int64 ints = 8;            // list of ints
+  repeated bytes strings = 9;         // list of UTF-8 strings
+  repeated TensorProto tensors = 10;  // list of tensors
+  repeated GraphProto graphs = 11;    // list of graph
+  repeated SparseTensorProto sparse_tensors = 23; // list of sparse tensors
+  repeated TypeProto type_protos = 15;// list of type protos
+}
+
+// Defines information on value, including the name, the type, and
+// the shape of the value.
+message ValueInfoProto {
+  // This field MUST be present in this version of the IR.
+  string name = 1;     // namespace Value
+  // This field MUST be present in this version of the IR for
+  // inputs and outputs of the top-level graph.
+  TypeProto type = 2;
+  // A human-readable documentation for this value. Markdown is allowed.
+  string doc_string = 3;
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 4;
+}
+
+// Nodes
+//
+// Computation graphs are made up of a DAG of nodes, which represent what is
+// commonly called a "layer" or "pipeline stage" in machine learning frameworks.
+//
+// For example, it can be a node of type "Conv" that takes in an image, a filter
+// tensor and a bias tensor, and produces the convolved output.
+message NodeProto {
+  repeated string input = 1;    // namespace Value
+  repeated string output = 2;   // namespace Value
+
+  // An optional identifier for this node in a graph.
+  // This field MAY be absent in this version of the IR.
+  string name = 3;     // namespace Node
+
+  // The symbolic identifier of the Operator to execute.
+  string op_type = 4;  // namespace Operator
+  // The domain of the OperatorSet that specifies the operator named by op_type.
+  string domain = 7;   // namespace Domain
+  // Overload identifier, used only to map this to a model-local function.
+  string overload = 8;
+
+  // Additional named attributes.
+  repeated AttributeProto attribute = 5;
+
+  // A human-readable documentation for this node. Markdown is allowed.
+  string doc_string = 6;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 9;
+
+  // Configuration of multi-device annotations.
+  repeated NodeDeviceConfigurationProto device_configurations = 10;
+}
+
+// IntIntListEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message IntIntListEntryProto {
+  int64 key = 1;
+  repeated int64 value = 2;
+};
+
+// Multi-device configuration proto for NodeProto.
+message NodeDeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // ID of the configuration. MUST match the name of a DeviceConfigurationProto.
+    string configuration_id = 1;
+    // Sharding spec for the node.
+    repeated ShardingSpecProto sharding_spec = 2;
+    // Pipeline stage of this node.
+    int32 pipeline_stage = 3;
+}
+
+// ShardingSpecProto: This describes the sharding spec for a specific
+// input or output tensor of a node.
+message ShardingSpecProto {
+  // This field MUST be present for this version of the IR.
+  // Identifies the input or output of the node that is being sharded.
+  // Required to match a name specified in the node's input or output list of ValueInfoProtos.
+  // It is called `logical tensor` in subsequent descriptions.
+  string tensor_name = 1;
+
+  // The following is the list of devices across which the logical
+  // tensor is sharded or replicated.
+  repeated int64 device = 2;
+
+  // Each element v in above field devices may represent either a
+  // device or a set of devices (when we want the same shard/tensor
+  // to be replicated across a subset of devices), as indicated by
+  // the following optional map. If the map contains an entry for v,
+  // then v represents a device group, and the map indicates the set
+  // of devices in that group.
+  repeated IntIntListEntryProto index_to_device_group_map = 3;
+
+  // The following is the sharded-shape of the tensor, consisting of
+  // the sharding-spec for each axis of the tensor.
+  repeated ShardedDimProto sharded_dim = 4;
+}
+
+// ShardedDimProto: This describes the sharding spec for a single
+// axis of a sharded tensor.
+message ShardedDimProto {
+  // This field MUST be present for this version of the IR.
+  // The axis this sharding corresponds to. Must be in the range of
+  // [-r, r - 1], where r is the rank of the tensor. Negative axis values means
+  // counting from the back.
+  int64 axis = 1;
+
+  // Describes how the tensor on the provided axis is sharded.
+  // The common-case is described by a single instance of SimpleShardedDimProto.
+  // Multiple instances can be used to handle cases where a sharded
+  // tensor is reshaped, fusing multiple axes into one.
+  repeated SimpleShardedDimProto simple_sharding = 2;
+}
+
+// SimpleShardedDimProto: Indicates that N blocks are divided into M shards.
+// N is allowed to be symbolic where M is required to be a constant.
+message SimpleShardedDimProto {
+    // Dimension value to be sharded.
+    oneof dim {
+        int64 dim_value = 1;
+        string dim_param = 2;
+    }
+
+    // This field MUST be present for this version of the IR.
+    // Number of shards to split dim into.
+    int64 num_shards = 3;
+}
+
+// Training information
+// TrainingInfoProto stores information for training a model.
+// In particular, this defines two functionalities: an initialization-step
+// and a training-algorithm-step. Initialization resets the model
+// back to its original state as if no training has been performed.
+// Training algorithm improves the model based on input data.
+//
+// The semantics of the initialization-step is that the initializers
+// in ModelProto.graph and in TrainingInfoProto.algorithm are first
+// initialized as specified by the initializers in the graph, and then
+// updated by the "initialization_binding" in every instance in
+// ModelProto.training_info.
+//
+// The field "algorithm" defines a computation graph which represents a
+// training algorithm's step. After the execution of a
+// TrainingInfoProto.algorithm, the initializers specified by "update_binding"
+// may be immediately updated. If the targeted training algorithm contains
+// consecutive update steps (such as block coordinate descent methods),
+// the user needs to create a TrainingInfoProto for each step.
+message TrainingInfoProto {
+  // This field describes a graph to compute the initial tensors
+  // upon starting the training process. Initialization graph has no input
+  // and can have multiple outputs. Usually, trainable tensors in neural
+  // networks are randomly initialized. To achieve that, for each tensor,
+  // the user can put a random number operator such as RandomNormal or
+  // RandomUniform in TrainingInfoProto.initialization.node and assign its
+  // random output to the specific tensor using "initialization_binding".
+  // This graph can also set the initializers in "algorithm" in the same
+  // TrainingInfoProto; a use case is resetting the number of training
+  // iteration to zero.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Thus, no initializer would be changed by default.
+  GraphProto initialization = 1;
+
+  // This field represents a training algorithm step. Given required inputs,
+  // it computes outputs to update initializers in its own or inference graph's
+  // initializer lists. In general, this field contains loss node, gradient node,
+  // optimizer node, increment of iteration count.
+  //
+  // An execution of the training algorithm step is performed by executing the
+  // graph obtained by combining the inference graph (namely "ModelProto.graph")
+  // and the "algorithm" graph. That is, the actual
+  // input/initializer/output/node/value_info/sparse_initializer list of
+  // the training graph is the concatenation of
+  // "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer"
+  // and "algorithm.input/initializer/output/node/value_info/sparse_initializer"
+  // in that order. This combined graph must satisfy the normal ONNX conditions.
+  // Now, let's provide a visualization of graph combination for clarity.
+  // Let the inference graph (i.e., "ModelProto.graph") be
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d
+  // and the "algorithm" graph be
+  //    tensor_d -> Add -> tensor_e
+  // The combination process results
+  //    tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add -> tensor_e
+  //
+  // Notice that an input of a node in the "algorithm" graph may reference the
+  // output of a node in the inference graph (but not the other way round). Also, inference
+  // node cannot reference inputs of "algorithm". With these restrictions, inference graph
+  // can always be run independently without training information.
+  //
+  // By default, this field is an empty graph and its evaluation does not
+  // produce any output. Evaluating the default training step never
+  // update any initializers.
+  GraphProto algorithm = 2;
+
+  // This field specifies the bindings from the outputs of "initialization" to
+  // some initializers in "ModelProto.graph.initializer" and
+  // the "algorithm.initializer" in the same TrainingInfoProto.
+  // See "update_binding" below for details.
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "initialization".
+  repeated StringStringEntryProto initialization_binding = 3;
+
+  // Gradient-based training is usually an iterative procedure. In one gradient
+  // descent iteration, we apply
+  //
+  // x = x - r * g
+  //
+  // where "x" is the optimized tensor, "r" stands for learning rate, and "g" is
+  // gradient of "x" with respect to a chosen loss. To avoid adding assignments
+  // into the training graph, we split the update equation into
+  //
+  // y = x - r * g
+  // x = y
+  //
+  // The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To
+  // tell that "y" should be assigned to "x", the field "update_binding" may
+  // contain a key-value pair of strings, "x" (key of StringStringEntryProto)
+  // and "y" (value of StringStringEntryProto).
+  // For a neural network with multiple trainable (mutable) tensors, there can
+  // be multiple key-value pairs in "update_binding".
+  //
+  // The initializers appears as keys in "update_binding" are considered
+  // mutable variables. This implies some behaviors
+  // as described below.
+  //
+  //  1. We have only unique keys in all "update_binding"s so that two
+  //     variables may not have the same name. This ensures that one
+  //     variable is assigned up to once.
+  //  2. The keys must appear in names of "ModelProto.graph.initializer" or
+  //     "TrainingInfoProto.algorithm.initializer".
+  //  3. The values must be output names of "algorithm" or "ModelProto.graph.output".
+  //  4. Mutable variables are initialized to the value specified by the
+  //     corresponding initializer, and then potentially updated by
+  //     "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s.
+  //
+  // This field usually contains names of trainable tensors
+  // (in ModelProto.graph), optimizer states such as momentums in advanced
+  // stochastic gradient methods (in TrainingInfoProto.graph),
+  // and number of training iterations (in TrainingInfoProto.graph).
+  //
+  // By default, this field is empty and no initializer would be changed
+  // by the execution of "algorithm".
+  repeated StringStringEntryProto update_binding = 4;
+}
+
+// Models
+//
+// ModelProto is a top-level file/container format for bundling a ML model and
+// associating its computation graph with metadata.
+//
+// The semantics of the model are described by the associated GraphProto's.
+message ModelProto {
+  // The version of the IR this model targets. See Version enum above.
+  // This field MUST be present.
+  int64 ir_version = 1;
+
+  // The OperatorSets this model relies on.
+  // All ModelProtos MUST have at least one entry that
+  // specifies which version of the ONNX OperatorSet is
+  // being imported.
+  //
+  // All nodes in the ModelProto's graph will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets.
+  repeated OperatorSetIdProto opset_import = 8;
+
+  // The name of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  string producer_name = 2;
+
+  // The version of the framework or tool used to generate this model.
+  // This field SHOULD be present to indicate which implementation/tool/framework
+  // emitted the model.
+  string producer_version = 3;
+
+  // Domain name of the model.
+  // We use reverse domain names as name space indicators. For example:
+  // `com.facebook.fair` or `com.microsoft.cognitiveservices`
+  //
+  // Together with `model_version` and GraphProto.name, this forms the unique identity of
+  // the graph.
+  string domain = 4;
+
+  // The version of the graph encoded. See Version enum below.
+  int64 model_version = 5;
+
+  // A human-readable documentation for this model. Markdown is allowed.
+  string doc_string = 6;
+
+  // The parameterized graph that is evaluated to execute the model.
+  GraphProto graph = 7;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+
+  // Training-specific information. Sequentially executing all stored
+  // `TrainingInfoProto.algorithm`s and assigning their outputs following
+  // the corresponding `TrainingInfoProto.update_binding`s is one training
+  // iteration. Similarly, to initialize the model
+  // (as if training hasn't happened), the user should sequentially execute
+  // all stored `TrainingInfoProto.initialization`s and assigns their outputs
+  // using `TrainingInfoProto.initialization_binding`s.
+  //
+  // If this field is empty, the training behavior of the model is undefined.
+  repeated TrainingInfoProto training_info = 20;
+
+  // A list of function protos local to the model.
+  //
+  // The (domain, name, overload) tuple must be unique across the function protos in this list.
+  // In case of any conflicts the behavior (whether the model local functions are given higher priority,
+  // or standard operator sets are given higher priority or this is treated as error) is defined by
+  // the runtimes.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto and other model local FunctionProtos.
+  // Example, if same operator set say 'A' is imported by a FunctionProto and ModelProto
+  // or by 2 FunctionProtos then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same for every node in the function body.
+  //
+  // One FunctionProto can reference other FunctionProto in the model, however, recursive reference
+  // is not allowed.
+  repeated FunctionProto functions = 25;
+
+  // Describes different target configurations for a multi-device use case.
+  // A model MAY describe multiple multi-device configurations for execution.
+  repeated DeviceConfigurationProto configuration = 26;
+};
+
+// DeviceConfigurationProto describes a multi-device configuration for a model.
+message DeviceConfigurationProto {
+    // This field MUST be present for this version of the IR.
+    // Name of the configuration.
+    string name = 1;
+    // This field MUST be present for this version of the IR.
+    // Number of devices inside this configuration.
+    int32 num_devices = 2;
+    // Optional names of the devices. MUST be length of num_devices if provided.
+    repeated string device = 3;
+}
+
+// StringStringEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+message StringStringEntryProto {
+  string key = 1;
+  string value = 2;
+};
+
+message TensorAnnotation {
+  string tensor_name = 1;
+  // <key, value> pairs to annotate tensor specified by <tensor_name> above.
+  // The keys used in the mapping below must be pre-defined in ONNX spec.
+  // For example, for 8-bit linear quantization case, 'SCALE_TENSOR', 'ZERO_POINT_TENSOR' will be pre-defined as
+  // quantization parameter keys.
+  repeated StringStringEntryProto quant_parameter_tensor_names = 2;
+}
+
+
+
+// Graphs
+//
+// A graph defines the computational logic of a model and is comprised of a parameterized
+// list of nodes that form a directed acyclic graph based on their inputs and outputs.
+// This is the equivalent of the "network" or "graph" in many deep learning
+// frameworks.
+message GraphProto {
+  // The nodes in the graph, sorted topologically.
+  repeated NodeProto node = 1;
+
+  // The name of the graph.
+  string name = 2;   // namespace Graph
+
+  // A list of named tensor values, used to specify constant inputs of the graph.
+  // Each initializer (both TensorProto as well SparseTensorProto) MUST have a name.
+  // The name MUST be unique across both initializer and sparse_initializer,
+  // but the name MAY also appear in the input list.
+  repeated TensorProto initializer = 5;
+
+  // Initializers (see above) stored in sparse format.
+  repeated SparseTensorProto sparse_initializer = 15;
+
+  // A human-readable documentation for this graph. Markdown is allowed.
+  string doc_string = 10;
+
+  // The inputs and outputs of the graph.
+  repeated ValueInfoProto input = 11;
+  repeated ValueInfoProto output = 12;
+
+  // Information for the values in the graph. The ValueInfoProto.name's
+  // must be distinct. It is optional for a value to appear in value_info list.
+  repeated ValueInfoProto value_info = 13;
+
+  // This field carries information to indicate the mapping among a tensor and its
+  // quantization parameter tensors. For example:
+  // For tensor 'a', it may have {'SCALE_TENSOR', 'a_scale'} and {'ZERO_POINT_TENSOR', 'a_zero_point'} annotated,
+  // which means, tensor 'a_scale' and tensor 'a_zero_point' are scale and zero point of tensor 'a' in the model.
+  repeated TensorAnnotation quantization_annotation = 14;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+
+  reserved 3, 4, 6 to 9;
+  reserved "ir_version", "producer_version", "producer_tag", "domain";
+}
+
+// Tensors
+//
+// A serialized tensor value.
+message TensorProto {
+  enum DataType {
+    UNDEFINED = 0;
+    // Basic types.
+    FLOAT = 1;   // float
+    UINT8 = 2;   // uint8_t
+    INT8 = 3;    // int8_t
+    UINT16 = 4;  // uint16_t
+    INT16 = 5;   // int16_t
+    INT32 = 6;   // int32_t
+    INT64 = 7;   // int64_t
+    STRING = 8;  // string
+    BOOL = 9;    // bool
+
+    // IEEE754 half-precision floating-point format (16 bits wide).
+    // This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
+    FLOAT16 = 10;
+
+    DOUBLE = 11;
+    UINT32 = 12;
+    UINT64 = 13;
+    COMPLEX64 = 14;     // complex with float32 real and imaginary components
+    COMPLEX128 = 15;    // complex with float64 real and imaginary components
+
+    // Non-IEEE floating-point format based on IEEE754 single-precision
+    // floating-point number truncated to 16 bits.
+    // This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
+    BFLOAT16 = 16;
+
+    // Non-IEEE floating-point format based on papers
+    // FP8 Formats for Deep Learning, https://arxiv.org/abs/2209.05433,
+    // 8-bit Numerical Formats For Deep Neural Networks, https://arxiv.org/pdf/2206.02915.pdf.
+    // Operators supported FP8 are Cast, CastLike, QuantizeLinear, DequantizeLinear.
+    // The computation usually happens inside a block quantize / dequantize
+    // fused by the runtime.
+    FLOAT8E4M3FN = 17;    // float 8, mostly used for coefficients, supports nan, not inf
+    FLOAT8E4M3FNUZ = 18;  // float 8, mostly used for coefficients, supports nan, not inf, no negative zero
+    FLOAT8E5M2 = 19;      // follows IEEE 754, supports nan, inf, mostly used for gradients
+    FLOAT8E5M2FNUZ = 20;  // follows IEEE 754, supports nan, not inf, mostly used for gradients, no negative zero
+
+    // 4-bit integer data types
+    UINT4 = 21;  // Unsigned integer in range [0, 15]
+    INT4 = 22;   // Signed integer in range [-8, 7], using two's-complement representation
+
+    // 4-bit floating point data types
+    FLOAT4E2M1 = 23;
+
+    // E8M0 type used as the scale for microscaling (MX) formats:
+    // https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
+    FLOAT8E8M0 = 24;
+
+    // 2-bit integer data type
+    UINT2 = 25; // Unsigned integer in range [0, 3]
+    INT2 = 26;  // Signed integer in range [-2, 1], using two's complement representation
+
+    // Future extensions go here.
+  }
+
+  // The shape of the tensor.
+  repeated int64 dims = 1;
+
+  // The data type of the tensor.
+  // This field MUST have a valid TensorProto.DataType value
+  int32 data_type = 2;
+
+  // For very large tensors, we may want to store them in chunks, in which
+  // case the following fields will specify the segment that is stored in
+  // the current TensorProto.
+  message Segment {
+    int64 begin = 1;
+    int64 end = 2;
+  }
+  Segment segment = 3;
+
+  // Tensor content must be organized in row-major order.
+  //
+  // Depending on the data_type field, exactly one of the fields below with
+  // name ending in _data is used to store the elements of the tensor.
+
+  // For float and complex64 values
+  // Complex64 tensors are encoded as a single array of floats,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
+  repeated float float_data = 4 [packed = true];
+
+  // For int32, uint8, int8, uint16, int16, uint4, int4, uint2, int2, bool, (b)float16, float8, and float4:
+  // - (b)float16 and float8 values MUST be converted bit-wise into an unsigned integer
+  //   representation before being written to the buffer.
+  // - Each pair of uint4, int4, and float4 values MUST be packed as two 4-bit elements into a single byte.
+  //   The first element is stored in the 4 least significant bits (LSB),
+  //   and the second element is stored in the 4 most significant bits (MSB).
+  // - Each group of four uint2, int2 values MUST be packed as four 2-bit elements into a single byte.
+  //   The elements are packed from LSB to MSB, with the first element in bits 0-1, second element in bits 2-3,
+  //   third element in bits 4-5, and fourth element in bits 6-7.
+  //
+  // Consequently:
+  // - For data types with a bit-width of 8 or greater, each `int32_data` stores one element.
+  // - For 4-bit data types, each `int32_data` stores two elements.
+  // - For 2-bit data types, each `int32_data` stores four elements.
+  //
+  // When this field is present, the data_type field MUST be
+  // INT32, INT16, INT8, INT4, INT2, UINT16, UINT8, UINT4, UINT2, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ, FLOAT8E8M0, FLOAT4E2M1
+  repeated int32 int32_data = 5 [packed = true];
+
+  // For strings.
+  // Each element of string_data is a UTF-8 encoded Unicode
+  // string. No trailing null, no leading BOM. The protobuf "string"
+  // scalar type is not used to match ML community conventions.
+  // When this field is present, the data_type field MUST be STRING
+  repeated bytes string_data = 6;
+
+  // For int64.
+  // When this field is present, the data_type field MUST be INT64
+  repeated int64 int64_data = 7 [packed = true];
+
+  // Optionally, a name for the tensor.
+  string name = 8; // namespace Value
+
+  // A human-readable documentation for this tensor. Markdown is allowed.
+  string doc_string = 12;
+
+  // Serializations can either use one of the fields above, or use this
+  // raw bytes field. The only exception is the string case, where one is
+  // required to store the content in the repeated bytes string_data field.
+  //
+  // When this raw_data field is used to store tensor value, elements MUST
+  // be stored in as fixed-width, little-endian order.
+  // Floating-point data types MUST be stored in IEEE 754 format.
+  // Complex64 elements must be written as two consecutive FLOAT values, real component first.
+  // Complex128 elements must be written as two consecutive DOUBLE values, real component first.
+  // Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
+  // uint4 and int4 values must be packed to 4bitx2, the first element is stored in the 4 LSB and the second element is stored in the 4 MSB.
+  // uint2 and int2 values must be packed to 2bitx4, with elements packed from LSB to MSB in a single byte as: x0 | (x1 << 2) | (x2 << 4) | (x3 << 6)
+  // where x0, x1, x2, x3 are consecutive elements.
+  //
+  // Note: the advantage of specific field rather than the raw_data field is
+  // that in some cases (e.g. int data), protobuf does a better packing via
+  // variable length storage, and may lead to smaller binary footprint.
+  // When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
+  bytes raw_data = 9;
+
+  // Data can be stored inside the protobuf file using type-specific fields or raw_data.
+  // Alternatively, raw bytes data can be stored in an external file, using the external_data field.
+  // external_data stores key-value pairs describing data location. Recognized keys are:
+  // - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
+  //                           protobuf model was stored
+  // - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
+  //                         Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
+  // - "length" (optional) - number of bytes containing data. Integer stored as string.
+  // - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
+  repeated StringStringEntryProto external_data = 13;
+
+  // Location of the data for this tensor. MUST be one of:
+  // - DEFAULT - data stored inside the protobuf message. Data is stored in raw_data (if set) otherwise in type-specified field.
+  // - EXTERNAL - data stored in an external location as described by external_data field.
+  enum DataLocation {
+    DEFAULT = 0;
+    EXTERNAL = 1;
+  }
+
+  // If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
+  DataLocation data_location = 14;
+
+  // For double
+  // Complex128 tensors are encoded as a single array of doubles,
+  // with the real components appearing in odd numbered positions,
+  // and the corresponding imaginary component appearing in the
+  // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+  // is encoded as [1.0, 2.0 ,3.0 ,4.0]
+  // When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
+  repeated double double_data = 10 [packed = true];
+
+  // For uint64 and uint32 values
+  // When this field is present, the data_type field MUST be
+  // UINT32 or UINT64
+  repeated uint64 uint64_data = 11 [packed = true];
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 16;
+}
+
+// A serialized sparse-tensor value
+message SparseTensorProto {
+  // The sequence of non-default values are encoded as a tensor of shape [NNZ].
+  // The default-value is zero for numeric tensors, and empty-string for string tensors.
+  // values must have a non-empty name present which serves as a name for SparseTensorProto
+  // when used in sparse_initializer list.
+  TensorProto values = 1;
+
+  // The indices of the non-default values, which may be stored in one of two formats.
+  // (a) Indices can be a tensor of shape [NNZ, rank] with the [i,j]-th value
+  // corresponding to the j-th index of the i-th value (in the values tensor).
+  // (b) Indices can be a tensor of shape [NNZ], in which case the i-th value
+  // must be the linearized-index of the i-th value (in the values tensor).
+  // The linearized-index can be converted into an index tuple (k_1,...,k_rank)
+  // using the shape provided below.
+  // The indices must appear in ascending order without duplication.
+  // In the first format, the ordering is lexicographic-ordering:
+  // e.g., index-value [1,4] must appear before [2,1]
+  TensorProto indices = 2;
+
+  // The shape of the underlying dense-tensor: [dim_1, dim_2, ... dim_rank]
+  repeated int64 dims = 3;
+}
+
+// Defines a tensor shape. A dimension can be either an integer value
+// or a symbolic variable. A symbolic variable represents an unknown
+// dimension.
+message TensorShapeProto {
+  message Dimension {
+    oneof value {
+      int64 dim_value = 1;
+      string dim_param = 2;   // namespace Shape
+    };
+    // Standard denotation can optionally be used to denote tensor
+    // dimensions with standard semantic descriptions to ensure
+    // that operations are applied to the correct axis of a tensor.
+    // Refer to https://github.com/onnx/onnx/blob/main/docs/DimensionDenotation.md#denotation-definition
+    // for pre-defined dimension denotations.
+    string denotation = 3;
+  };
+  repeated Dimension dim = 1;
+}
+
+// Types
+//
+// The standard ONNX data types.
+message TypeProto {
+
+  message Tensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    int32 elem_type = 1;
+    TensorShapeProto shape = 2;
+  }
+
+  // repeated T
+  message Sequence {
+    // The type and optional shape of each element of the sequence.
+    // This field MUST be present for this version of the IR.
+    TypeProto elem_type = 1;
+  };
+
+  // map<K,V>
+  message Map {
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    // This field MUST refer to an integral type ([U]INT{8|16|32|64}) or STRING
+    int32 key_type = 1;
+    // This field MUST be present for this version of the IR.
+    TypeProto value_type = 2;
+  };
+
+  // wrapper for Tensor, Sequence, or Map
+  message Optional {
+    // The type and optional shape of the element wrapped.
+    // This field MUST be present for this version of the IR.
+    // Possible values correspond to OptionalProto.DataType enum
+    TypeProto elem_type = 1;
+  };
+
+
+  message SparseTensor {
+    // This field MUST NOT have the value of UNDEFINED
+    // This field MUST have a valid TensorProto.DataType value
+    // This field MUST be present for this version of the IR.
+    int32 elem_type = 1;
+    TensorShapeProto shape = 2;
+  }
+
+
+  oneof value {
+    // The type of a tensor.
+    Tensor tensor_type = 1;
+
+    // NOTE:  DNN-only implementations of ONNX MAY elect to not support non-tensor values
+    //        as input and output to graphs and nodes. These types are needed to naturally
+    //        support classical ML operators.  DNN operators SHOULD restrict their input
+    //        and output types to tensors.
+
+    // The type of a sequence.
+    Sequence sequence_type = 4;
+
+    // The type of a map.
+    Map map_type = 5;
+
+    // The type of an optional.
+    Optional optional_type = 9;
+
+
+    // Type of the sparse tensor
+    SparseTensor sparse_tensor_type = 8;
+
+  }
+
+  // An optional denotation can be used to denote the whole
+  // type with a standard semantic description as to what is
+  // stored inside. Refer to https://github.com/onnx/onnx/blob/main/docs/TypeDenotation.md#type-denotation-definition
+  // for pre-defined type denotations.
+  string denotation = 6;
+}
+
+// Operator Sets
+//
+// OperatorSets are uniquely identified by a (domain, opset_version) pair.
+message OperatorSetIdProto {
+  // The domain of the operator set being identified.
+  // The empty string ("") or absence of this field implies the operator
+  // set that is defined as part of the ONNX specification.
+  // This field MUST be present in this version of the IR when referring to any other operator set.
+  string domain = 1;
+
+  // The version of the operator set being identified.
+  // This field MUST be present in this version of the IR.
+  int64 version = 2;
+}
+
+// Operator/function status.
+enum OperatorStatus {
+    EXPERIMENTAL = 0;
+    STABLE = 1;
+}
+
+message FunctionProto {
+  // The name of the function, similar to op_type in NodeProto.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  string name = 1;
+
+  // Deprecated since IR Version 8
+  // optional int64 since_version = 2;
+  reserved 2;
+  reserved "since_version";
+
+  // Deprecated since IR Version 8
+  // optional OperatorStatus status = 3;
+  reserved 3;
+  reserved "status";
+
+  // The inputs and outputs of the function.
+  repeated string input = 4;
+  repeated string output = 5;
+
+  // The attribute parameters of the function.
+  // It is for function parameters without default values.
+  repeated string attribute = 6;
+
+  // The attribute protos of the function.
+  // It is for function attributes with default values.
+  // A function attribute shall be represented either as
+  // a string attribute or an AttributeProto, not both.
+  repeated AttributeProto attribute_proto = 11;
+
+  // The nodes in the function.
+  repeated NodeProto node = 7;
+  // A human-readable documentation for this function. Markdown is allowed.
+  string doc_string = 8;
+
+  // The OperatorSets this function body (graph) relies on.
+  //
+  // All nodes in the function body (graph) will bind against the operator
+  // with the same-domain/same-op_type operator with the HIGHEST version
+  // in the referenced operator sets. This means at most one version can be relied
+  // for one domain.
+  //
+  // The operator sets imported by FunctionProto should be compatible with the ones
+  // imported by ModelProto. Example, if same operator set say 'A' is imported by FunctionProto
+  // and ModelProto then versions for the operator set may be different but,
+  // the operator schema returned for op_type, domain, version combination
+  // for both the versions should be same.
+
+  repeated OperatorSetIdProto opset_import = 9;
+
+  // The domain which this function belongs to.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  string domain = 10;
+
+  // The overload identifier of the function.
+  // This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+  string overload = 13;
+
+  // Information for the values in the function. The ValueInfoProto.name's
+  // must be distinct and refer to names in the function (including inputs,
+  // outputs, and intermediate values). It is optional for a value to appear
+  // in value_info list.
+  repeated ValueInfoProto value_info = 12;
+
+  // Named metadata values; keys should be distinct.
+  repeated StringStringEntryProto metadata_props = 14;
+}
+
+// For using protobuf-lite
+option optimize_for = LITE_RUNTIME;
+
diff --git a/onnx/onnx_cpp2py_export/__init__.pyi b/onnx/onnx_cpp2py_export/__init__.pyi
new file mode 100644
index 0000000..5f7c483
--- /dev/null
+++ b/onnx/onnx_cpp2py_export/__init__.pyi
@@ -0,0 +1,5 @@
+# This is __init__.pyi, not __init__.py
+# This directory is only considered for typing information, not for actual
+# module implementations.
+
+ONNX_ML: bool = ...
diff --git a/onnx/onnx_cpp2py_export/checker.pyi b/onnx/onnx_cpp2py_export/checker.pyi
new file mode 100644
index 0000000..a40d521
--- /dev/null
+++ b/onnx/onnx_cpp2py_export/checker.pyi
@@ -0,0 +1,48 @@
+class CheckerContext:
+    ir_version: int = ...
+    opset_imports: dict[str, int] = ...
+
+class LexicalScopeContext:
+    ir_version: int = ...
+    opset_imports: dict[str, int] = ...
+
+class ValidationError(Exception): ...
+
+def check_value_info(bytes: bytes, checker_context: CheckerContext) -> None: ...  # noqa: A002
+def check_tensor(bytes: bytes, checker_context: CheckerContext) -> None: ...  # noqa: A002
+def check_sparse_tensor(bytes: bytes, checker_context: CheckerContext) -> None: ...  # noqa: A002
+def check_attribute(
+    bytes: bytes,  # noqa: A002
+    checker_context: CheckerContext,
+    lexical_scope_context: LexicalScopeContext,
+) -> None: ...
+def check_node(
+    bytes: bytes,  # noqa: A002
+    checker_context: CheckerContext,
+    lexical_scope_context: LexicalScopeContext,
+) -> None: ...
+def check_function(
+    bytes: bytes,  # noqa: A002
+    checker_context: CheckerContext,
+    lexical_scope_context: LexicalScopeContext,
+) -> None: ...
+def check_graph(
+    bytes: bytes,  # noqa: A002
+    checker_context: CheckerContext,
+    lexical_scope_context: LexicalScopeContext,
+) -> None: ...
+def check_model(
+    bytes: bytes,  # noqa: A002
+    full_check: bool,
+    skip_opset_compatibility_check: bool,
+    check_custom_domain: bool,
+) -> None: ...
+def check_model_path(
+    path: str,
+    full_check: bool,
+    skip_opset_compatibility_check: bool,
+    check_custom_domain: bool,
+) -> None: ...
+def _open_external_data(
+    base_dir: str, location: str, tensor_name: str, read_only: bool
+) -> int: ...
diff --git a/onnx/onnx_cpp2py_export/defs.pyi b/onnx/onnx_cpp2py_export/defs.pyi
new file mode 100644
index 0000000..f2c69b8
--- /dev/null
+++ b/onnx/onnx_cpp2py_export/defs.pyi
@@ -0,0 +1,214 @@
+"""Submodule containing all the ONNX schema definitions."""
+
+from collections.abc import Callable, Sequence
+from typing import overload
+
+from onnx import AttributeProto, FunctionProto
+from onnx.shape_inference import InferenceContext
+
+class SchemaError(Exception): ...
+
+class OpSchema:
+    def __init__(
+        self,
+        name: str,
+        domain: str,
+        since_version: int,
+        doc: str = "",
+        *,
+        inputs: Sequence[OpSchema.FormalParameter] = (),
+        outputs: Sequence[OpSchema.FormalParameter] = (),
+        type_constraints: Sequence[tuple[str, Sequence[str], str]] = (),
+        attributes: Sequence[OpSchema.Attribute] = (),
+    ) -> None: ...
+    @property
+    def file(self) -> str: ...
+    @property
+    def line(self) -> int: ...
+    @property
+    def support_level(self) -> SupportType: ...
+    @property
+    def doc(self) -> str | None: ...
+    @property
+    def since_version(self) -> int: ...
+    @property
+    def deprecated(self) -> bool: ...
+    @property
+    def domain(self) -> str: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def min_input(self) -> int: ...
+    @property
+    def max_input(self) -> int: ...
+    @property
+    def min_output(self) -> int: ...
+    @property
+    def max_output(self) -> int: ...
+    @property
+    def attributes(self) -> dict[str, Attribute]: ...
+    @property
+    def inputs(self) -> Sequence[FormalParameter]: ...
+    @property
+    def outputs(self) -> Sequence[FormalParameter]: ...
+    @property
+    def type_constraints(self) -> Sequence[TypeConstraintParam]: ...
+    @property
+    def has_type_and_shape_inference_function(self) -> bool: ...
+    @property
+    def has_data_propagation_function(self) -> bool: ...
+    @staticmethod
+    def is_infinite(v: int) -> bool: ...
+    def consumed(self, schema: OpSchema, i: int) -> tuple[UseType, int]: ...
+    def _infer_node_outputs(
+        self,
+        node_proto: bytes,
+        value_types: dict[str, bytes],
+        input_data: dict[str, bytes],
+        input_sparse_data: dict[str, bytes],
+    ) -> dict[str, bytes]: ...
+    @property
+    def function_body(self) -> FunctionProto: ...
+    def set_type_and_shape_inference_function(
+        self, func: Callable[[InferenceContext], None]
+    ) -> None: ...
+    def get_type_and_shape_inference_function(
+        self,
+    ) -> Callable[[InferenceContext], None]: ...
+
+    class TypeConstraintParam:
+        def __init__(
+            self,
+            type_param_str: str,
+            allowed_type_strs: Sequence[str],
+            description: str = "",
+        ) -> None:
+            """Type constraint parameter.
+
+            Args:
+                type_param_str: Type parameter string, for example, "T", "T1", etc.
+                allowed_type_strs: Allowed type strings for this type parameter. E.g. ["tensor(float)"].
+                description: Type parameter description.
+            """
+        @property
+        def type_param_str(self) -> str: ...
+        @property
+        def description(self) -> str: ...
+        @property
+        def allowed_type_strs(self) -> Sequence[str]: ...
+
+    class FormalParameterOption:
+        Single: OpSchema.FormalParameterOption = ...
+        Optional: OpSchema.FormalParameterOption = ...
+        Variadic: OpSchema.FormalParameterOption = ...
+
+    class DifferentiationCategory:
+        Unknown: OpSchema.DifferentiationCategory = ...
+        Differentiable: OpSchema.DifferentiationCategory = ...
+        NonDifferentiable: OpSchema.DifferentiationCategory = ...
+
+    class NodeDeterminism:
+        Deterministic: OpSchema.NodeDeterminism = ...
+        NonDeterministic: OpSchema.NodeDeterminism = ...
+        Unknown: OpSchema.NodeDeterminism = ...
+
+    class FormalParameter:
+        def __init__(
+            self,
+            name: str,
+            type_str: str,
+            description: str = "",
+            *,
+            param_option: OpSchema.FormalParameterOption = OpSchema.FormalParameterOption.Single,  # noqa: F821
+            is_homogeneous: bool = True,
+            min_arity: int = 1,
+            differentiation_category: OpSchema.DifferentiationCategory = OpSchema.DifferentiationCategory.Unknown,  # noqa: F821
+        ) -> None: ...
+        @property
+        def name(self) -> str: ...
+        @property
+        def types(self) -> set[str]: ...
+        @property
+        def type_str(self) -> str: ...
+        @property
+        def description(self) -> str: ...
+        @property
+        def option(self) -> OpSchema.FormalParameterOption: ...
+        @property
+        def is_homogeneous(self) -> bool: ...
+        @property
+        def min_arity(self) -> int: ...
+        @property
+        def differentiation_category(self) -> OpSchema.DifferentiationCategory: ...
+
+    class AttrType:
+        FLOAT: OpSchema.AttrType = ...
+        INT: OpSchema.AttrType = ...
+        STRING: OpSchema.AttrType = ...
+        TENSOR: OpSchema.AttrType = ...
+        GRAPH: OpSchema.AttrType = ...
+        SPARSE_TENSOR: OpSchema.AttrType = ...
+        TYPE_PROTO: OpSchema.AttrType = ...
+        FLOATS: OpSchema.AttrType = ...
+        INTS: OpSchema.AttrType = ...
+        STRINGS: OpSchema.AttrType = ...
+        TENSORS: OpSchema.AttrType = ...
+        GRAPHS: OpSchema.AttrType = ...
+        SPARSE_TENSORS: OpSchema.AttrType = ...
+        TYPE_PROTOS: OpSchema.AttrType = ...
+
+    class Attribute:
+        @overload
+        def __init__(
+            self,
+            name: str,
+            type: OpSchema.AttrType,
+            description: str = "",
+            *,
+            required: bool = True,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            name: str,
+            default_value: AttributeProto,
+            description: str = "",
+        ) -> None: ...
+        @property
+        def name(self) -> str: ...
+        @property
+        def description(self) -> str: ...
+        @property
+        def type(self) -> OpSchema.AttrType: ...
+        @property
+        def default_value(self) -> AttributeProto: ...
+        @property
+        def required(self) -> bool: ...
+
+    class SupportType(int):
+        COMMON: OpSchema.SupportType = ...
+        EXPERIMENTAL: OpSchema.SupportType = ...
+
+    class UseType:
+        DEFAULT: OpSchema.UseType = ...
+        CONSUME_ALLOWED: OpSchema.UseType = ...
+        CONSUME_ENFORCED: OpSchema.UseType = ...
+
+@overload
+def has_schema(op_type: str, domain: str = "") -> bool: ...
+@overload
+def has_schema(op_type: str, max_inclusive_version: int, domain: str = "") -> bool: ...
+def schema_version_map() -> dict[str, tuple[int, int]]: ...
+@overload
+def get_schema(
+    op_type: str, max_inclusive_version: int, domain: str = ""
+) -> OpSchema: ...
+@overload
+def get_schema(op_type: str, domain: str = "") -> OpSchema: ...
+def get_all_schemas() -> Sequence[OpSchema]: ...
+def get_all_schemas_with_history() -> Sequence[OpSchema]: ...
+def set_domain_to_version(
+    domain: str, min_version: int, max_version: int, last_release_version: int = -1
+) -> None: ...
+def register_schema(schema: OpSchema) -> None: ...
+def deregister_schema(op_type: str, version: int, domain: str) -> None: ...
diff --git a/onnx/onnx_cpp2py_export/inliner.pyi b/onnx/onnx_cpp2py_export/inliner.pyi
new file mode 100644
index 0000000..280fab0
--- /dev/null
+++ b/onnx/onnx_cpp2py_export/inliner.pyi
@@ -0,0 +1,26 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+def inline_local_functions(model: bytes, convert_version: bool) -> bytes:
+    """Inlines calls to model-local function in input model and returns it.
+    Both input and output are serialized ModelProtos.
+    """
+
+def inline_selected_functions(
+    model: bytes, function_ids: list[tuple[str, str]], exclude: bool
+) -> bytes:
+    """Inlines calls to selected model-local functions in input model and returns it.
+    Inlines all functions specified in function_ids, unless exclude is true, in which
+    case it inlines all functions except those specified in function_ids.
+    Both input and output are serialized ModelProtos.
+    """
+
+def inline_selected_functions2(
+    model: bytes, function_ids: list[tuple[str, str]], exclude: bool
+) -> bytes:
+    """Inlines calls to selected model-local + schema functions in input model and returns it.
+    Inlines all functions specified in function_ids, unless exclude is true, in which
+    case it inlines all functions except those specified in function_ids.
+    Both input and output are serialized ModelProtos.
+    """
diff --git a/onnx/onnx_cpp2py_export/parser.pyi b/onnx/onnx_cpp2py_export/parser.pyi
new file mode 100644
index 0000000..ea8f5ec
--- /dev/null
+++ b/onnx/onnx_cpp2py_export/parser.pyi
@@ -0,0 +1,27 @@
+def parse_model(model: str) -> tuple[bool, bytes, bytes]:
+    """Returns (success-flag, error-message, serialized-proto).
+
+    If success-flag is true, then serialized-proto contains the parsed ModelProto.
+    Otherwise, error-message contains a string describing the parse error.
+    """
+
+def parse_graph(graph: str) -> tuple[bool, bytes, bytes]:
+    """Returns (success-flag, error-message, serialized-proto).
+
+    If success-flag is true, then serialized-proto contains the parsed GraphProto.
+    Otherwise, error-message contains a string describing the parse error.
+    """
+
+def parse_function(function: str) -> tuple[bool, bytes, bytes]:
+    """Returns (success-flag, error-message, serialized-proto).
+
+    If success-flag is true, then serialized-proto contains the parsed FunctionProto.
+    Otherwise, error-message contains a string describing the parse error.
+    """
+
+def parse_node(node: str) -> tuple[bool, bytes, bytes]:
+    """Returns (success-flag, error-message, serialized-proto).
+
+    If success-flag is true, then serialized-proto contains the parsed NodeProto.
+    Otherwise, error-message contains a string describing the parse error.
+    """
diff --git a/onnx/onnx_cpp2py_export/printer.pyi b/onnx/onnx_cpp2py_export/printer.pyi
new file mode 100644
index 0000000..5ca4df0
--- /dev/null
+++ b/onnx/onnx_cpp2py_export/printer.pyi
@@ -0,0 +1,4 @@
+def function_to_text(serialized_function_proto: bytes) -> str: ...
+def graph_to_text(serialized_graph_proto: bytes) -> str: ...
+def model_to_text(serialized_model_proto: bytes) -> str: ...
+def node_to_text(serialized_node_proto: bytes) -> str: ...
diff --git a/onnx/onnx_cpp2py_export/shape_inference.pyi b/onnx/onnx_cpp2py_export/shape_inference.pyi
new file mode 100644
index 0000000..1aa4685
--- /dev/null
+++ b/onnx/onnx_cpp2py_export/shape_inference.pyi
@@ -0,0 +1,45 @@
+from onnx.onnx_pb import (
+    AttributeProto,
+    SparseTensorProto,
+    TensorProto,
+    TensorShapeProto,
+    TypeProto,
+)
+
+class InferenceError(Exception): ...
+
+class GraphInferencer:
+    def do_inferencing(
+        self, input_types: list[TypeProto], input_data: list[TensorProto | None]
+    ) -> list[TypeProto]: ...
+
+class InferenceContext:
+    def get_attribute(self, name: str) -> AttributeProto: ...
+    def get_num_inputs(self) -> int: ...
+    def get_input_type(self, idx: int) -> TypeProto: ...
+    def has_input(self, idx: int) -> bool: ...
+    def get_input_data(self, idx: int) -> TensorProto: ...
+    def get_num_outputs(self) -> int: ...
+    def get_output_type(self, idx: int) -> TypeProto: ...
+    def set_output_type(self, idx: int, type_proto: TypeProto) -> bool: ...
+    def has_output(self, idx: int) -> bool: ...
+    def get_graph_attribute_inferencer(self, attr_name: str) -> GraphInferencer: ...
+    def get_input_sparse_data(self, idx: int) -> SparseTensorProto: ...
+    def get_symbolic_input(self, idx: int) -> TensorShapeProto: ...
+    def get_display_name(self) -> str: ...
+
+def infer_shapes(
+    b: bytes, check_type: bool, strict_mode: bool, data_prop: bool
+) -> bytes: ...
+def infer_shapes_path(
+    model_path: str,
+    output_path: str,
+    check_type: bool,
+    strict_mode: bool,
+    data_prop: bool,
+) -> None: ...
+def infer_function_output_types(
+    b: bytes,
+    input_types: list[bytes],
+    attributes: list[bytes],
+) -> list[bytes]: ...
diff --git a/onnx/onnx_cpp2py_export/version_converter.pyi b/onnx/onnx_cpp2py_export/version_converter.pyi
new file mode 100644
index 0000000..dd6ae25
--- /dev/null
+++ b/onnx/onnx_cpp2py_export/version_converter.pyi
@@ -0,0 +1,4 @@
+class ConvertError(Exception): ...
+
+# Where the first bytes are a serialized ModelProto
+def convert_version(bytes: bytes, target: int) -> bytes: ...  # noqa: A002
diff --git a/onnx/onnx_pb.h b/onnx/onnx_pb.h
new file mode 100644
index 0000000..624cf04
--- /dev/null
+++ b/onnx/onnx_pb.h
@@ -0,0 +1,56 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ONNX_ONNX_PB_H_
+#define ONNX_ONNX_PB_H_
+
+// Defines ONNX_EXPORT and ONNX_IMPORT. On Windows, this corresponds to
+// different declarations (dllexport and dllimport). On Linux/Mac, it just
+// resolves to the same "default visibility" setting.
+#ifdef _MSC_VER
+#if defined(ONNX_BUILD_SHARED_LIBS) || defined(ONNX_BUILD_MAIN_LIB)
+#define ONNX_EXPORT __declspec(dllexport)
+#define ONNX_IMPORT __declspec(dllimport)
+#else
+#define ONNX_EXPORT
+#define ONNX_IMPORT
+#endif
+#else
+#ifdef __GNUC__
+#define ONNX_EXPORT __attribute__((__visibility__("default")))
+#else
+#define ONNX_EXPORT
+#endif
+#define ONNX_IMPORT ONNX_EXPORT
+#endif
+
+// ONNX_API is a macro that, depends on whether you are building the
+// main ONNX library or not, resolves to either ONNX_EXPORT or
+// ONNX_IMPORT.
+//
+// This is used in e.g. ONNX's protobuf files: when building the main library,
+// it is defined as ONNX_EXPORT to fix a Windows global-variable-in-dll
+// issue, and for anyone dependent on ONNX it will be defined as
+// ONNX_IMPORT. ONNX_BUILD_MAIN_LIB can also be set when being built
+// statically if ONNX is being linked into a shared library that wants
+// to export the ONNX APIs and classes.
+//
+// More details on Windows dllimport / dllexport can be found at
+// https://msdn.microsoft.com/en-us/library/3y1sfaz2.aspx
+//
+// This solution is similar to
+// https://github.com/pytorch/pytorch/blob/master/caffe2/core/common.h
+#if defined(ONNX_BUILD_SHARED_LIBS) || defined(ONNX_BUILD_MAIN_LIB)
+#define ONNX_API ONNX_EXPORT
+#else
+#define ONNX_API ONNX_IMPORT
+#endif
+
+#ifdef ONNX_ML
+#include "onnx/onnx-ml.pb.h"
+#else
+#include "onnx/onnx.pb.h"
+#endif
+
+#endif // ONNX_ONNX_PB_H_
diff --git a/onnx/parser.py b/onnx/parser.py
new file mode 100644
index 0000000..1160d58
--- /dev/null
+++ b/onnx/parser.py
@@ -0,0 +1,73 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import onnx
+import onnx.onnx_cpp2py_export.parser as C  # noqa: N812
+
+
+class ParseError(Exception):
+    pass
+
+
+def parse_model(model_text: str) -> onnx.ModelProto:
+    """Parse a string to build a ModelProto.
+
+    Arguments:
+        model_text (string): formatted string
+    Returns:
+        ModelProto
+    """
+    (success, msg, model_proto_str) = C.parse_model(model_text)
+    if success:
+        return onnx.load_from_string(model_proto_str)
+    raise ParseError(msg)
+
+
+def parse_graph(graph_text: str) -> onnx.GraphProto:
+    """Parse a string to build a GraphProto.
+
+    Arguments:
+        graph_text (string): formatted string
+    Returns:
+        GraphProto
+    """
+    (success, msg, graph_proto_str) = C.parse_graph(graph_text)
+    if success:
+        graph_proto = onnx.GraphProto()
+        graph_proto.ParseFromString(graph_proto_str)
+        return graph_proto
+    raise ParseError(msg)
+
+
+def parse_function(function_text: str) -> onnx.FunctionProto:
+    """Parse a string to build a FunctionProto.
+
+    Arguments:
+        function_text (string): formatted string
+    Returns:
+        FunctionProto
+    """
+    (success, msg, function_proto_str) = C.parse_function(function_text)
+    if success:
+        function_proto = onnx.FunctionProto()
+        function_proto.ParseFromString(function_proto_str)
+        return function_proto
+    raise ParseError(msg)
+
+
+def parse_node(node_text: str) -> onnx.NodeProto:
+    """Parse a string to build a NodeProto.
+
+    Arguments:
+        node_text: formatted string
+    Returns:
+        NodeProto
+    """
+    (success, msg, node_proto_str) = C.parse_node(node_text)
+    if success:
+        node_proto = onnx.NodeProto()
+        node_proto.ParseFromString(node_proto_str)
+        return node_proto
+    raise ParseError(msg)
diff --git a/onnx/printer.py b/onnx/printer.py
new file mode 100644
index 0000000..bd938d8
--- /dev/null
+++ b/onnx/printer.py
@@ -0,0 +1,21 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import onnx
+import onnx.onnx_cpp2py_export.printer as C  # noqa: N812
+
+
+def to_text(
+    proto: onnx.ModelProto | onnx.FunctionProto | onnx.GraphProto | onnx.NodeProto,
+) -> str:
+    if isinstance(proto, onnx.ModelProto):
+        return C.model_to_text(proto.SerializeToString())
+    if isinstance(proto, onnx.FunctionProto):
+        return C.function_to_text(proto.SerializeToString())
+    if isinstance(proto, onnx.GraphProto):
+        return C.graph_to_text(proto.SerializeToString())
+    if isinstance(proto, onnx.NodeProto):
+        return C.node_to_text(proto.SerializeToString())
+    raise TypeError("Unsupported argument type.")
diff --git a/onnx/proto_utils.h b/onnx/proto_utils.h
new file mode 100644
index 0000000..9287b3d
--- /dev/null
+++ b/onnx/proto_utils.h
@@ -0,0 +1,75 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+
+#include <string>
+#include <vector>
+
+#include "onnx/onnx_pb.h"
+
+#ifdef ONNX_USE_LITE_PROTO
+#include <google/protobuf/message_lite.h>
+#else // ONNX_USE_LITE_PROTO
+#include <google/protobuf/message.h>
+#endif // !ONNX_USE_LITE_PROTO
+
+namespace ONNX_NAMESPACE {
+
+#ifdef ONNX_USE_LITE_PROTO
+inline std::string ProtoDebugString(const ::google::protobuf::MessageLite& proto) {
+  // Since the MessageLite interface does not support reflection, there is very
+  // little information that this and similar methods can provide.
+  // But when using lite proto this is the best we can provide.
+  return proto.ShortDebugString();
+}
+#else
+inline std::string ProtoDebugString(const ::google::protobuf::Message& proto) {
+  return proto.ShortDebugString();
+}
+#endif
+
+template <typename Proto>
+bool ParseProtoFromBytes(Proto* proto, const char* buffer, size_t length) {
+  // Reject inputs larger than the 2 GB proto limit before casting to int.
+  // ArrayInputStream takes an int size, so passing a truncated value would
+  // silently parse fewer bytes than requested.
+  constexpr int total_bytes_limit = (2048LL << 20) - 1;
+  if (length > static_cast<size_t>(total_bytes_limit)) {
+    return false;
+  }
+  ::google::protobuf::io::ArrayInputStream input_stream(buffer, static_cast<int>(length));
+  ::google::protobuf::io::CodedInputStream coded_stream(&input_stream);
+#if GOOGLE_PROTOBUF_VERSION >= 3011000
+  // Only take one parameter since protobuf 3.11
+  coded_stream.SetTotalBytesLimit(total_bytes_limit);
+#else
+  // Total bytes hard limit / warning limit are set to 2GB and 512MB respectively.
+  coded_stream.SetTotalBytesLimit(total_bytes_limit, 512LL << 20);
+#endif
+
+  return proto->ParseFromCodedStream(&coded_stream);
+}
+
+template <typename T>
+inline std::vector<T> RetrieveValues(const AttributeProto& attr);
+template <>
+inline std::vector<int64_t> RetrieveValues(const AttributeProto& attr) {
+  return {attr.ints().begin(), attr.ints().end()};
+}
+
+template <>
+inline std::vector<std::string> RetrieveValues(const AttributeProto& attr) {
+  return {attr.strings().begin(), attr.strings().end()};
+}
+
+template <>
+inline std::vector<float> RetrieveValues(const AttributeProto& attr) {
+  return {attr.floats().begin(), attr.floats().end()};
+}
+
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/py.typed b/onnx/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/onnx/py_utils.h b/onnx/py_utils.h
new file mode 100644
index 0000000..950c416
--- /dev/null
+++ b/onnx/py_utils.h
@@ -0,0 +1,22 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <nanobind/nanobind.h>
+
+#include "onnx/proto_utils.h"
+
+namespace ONNX_NAMESPACE {
+namespace nb = nanobind;
+
+template <typename Proto>
+bool ParseProtoFromPyBytes(Proto* proto, const nb::bytes& bytes) {
+  // Get the buffer from Python bytes object
+  const auto* buffer = static_cast<const char*>(bytes.data());
+  size_t length = bytes.size();
+
+  return ParseProtoFromBytes(proto, buffer, length);
+}
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/reference/README.md b/onnx/reference/README.md
new file mode 100644
index 0000000..6c2525e
--- /dev/null
+++ b/onnx/reference/README.md
@@ -0,0 +1,43 @@
+<!--
+Copyright (c) ONNX Project Contributors
+
+SPDX-License-Identifier: Apache-2.0
+-->
+
+# ReferenceEvaluator
+
+This is a first attempt to provide an implementation for all operators
+defined by onnx. This is a pure python implementation.
+Mismatches may remain between the official specification and the implementation here.
+In the case of such a mismatch, the official spec overrides this implementation.
+The class can use any implementation available in folder
+[ops](https://github.com/onnx/onnx/tree/main/onnx/reference/ops).
+It covers most of the tests defined in
+[onnx/backend/test/case](https://github.com/onnx/onnx/tree/main/onnx/backend/test/case)
+and reported on [ONNX Backend Scoreboard](http://onnx.ai/backend-scoreboard/).
+
+The class `ReferenceEvaluator` is used as follows:
+
+```python
+import numpy as np
+from onnx.reference import ReferenceEvaluator
+
+X = np.array(...)
+sess = ReferenceEvaluator("model.onnx")
+results = sess.run(None, {"X": X})
+print(results[0])
+```
+
+In addition to the implementation of every operator, it can be used
+to display intermediate results and help debugging a model.
+
+```python
+
+import numpy as np
+from onnx.reference import ReferenceEvaluator
+
+X = np.array(...)
+sess = ReferenceEvaluator("model.onnx", verbose=1)
+results = sess.run(None, {"X": X})
+print(results[0])
+```
diff --git a/onnx/reference/__init__.py b/onnx/reference/__init__.py
new file mode 100644
index 0000000..d700155
--- /dev/null
+++ b/onnx/reference/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = ["ReferenceEvaluator"]
+
+from onnx.reference.reference_evaluator import ReferenceEvaluator
diff --git a/onnx/reference/op_run.py b/onnx/reference/op_run.py
new file mode 100644
index 0000000..58b1700
--- /dev/null
+++ b/onnx/reference/op_run.py
@@ -0,0 +1,682 @@
+# SPDX-License-Identifier: Apache-2.0
+
+
+from __future__ import annotations
+
+import abc
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+import onnx
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+class RuntimeTypeError(RuntimeError):
+    """Raised when a type of a variable is unexpected."""
+
+
+class RuntimeContextError(RuntimeError):
+    """Raised when the context is missing but an context dependent implementation is defined for an operator."""
+
+
+class RuntimeImplementationError(NotImplementedError):
+    """Raised when no implementation was found for an operator."""
+
+
+class DefaultNone:
+    """Default value for parameters when the parameter is not set but the operator has a default behavior for it."""
+
+
+class RefAttrName:
+    """Implements a link between a parameter of a function and an attribute in node.
+
+    Args:
+        name: name of the input
+    """
+
+    def __init__(self, name: str):
+        self.name = name
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.name!r})"
+
+
+def _build_schemas() -> dict[str, onnx.defs.OpSchema]:
+    res: dict[str, onnx.defs.OpSchema] = {}
+    for schema in onnx.defs.onnx.defs.get_all_schemas_with_history():
+        # Multiple version can coexist. The last one is kept.
+        if schema.name in res:
+            if schema.domain != res[schema.name].domain:
+                raise NotImplementedError(
+                    f"This function assumes every operator has a unique name {schema.name!r} "
+                    f"even across multiple domains {schema.domain!r} and {res[schema.name].domain!r}."
+                )
+            if schema.since_version > res[schema.name].since_version:
+                # We keep the most recent one.
+                res[schema.name] = schema
+        else:
+            res[schema.name] = schema
+        res[schema.name + "_" + str(schema.since_version)] = schema
+    return res
+
+
+_schemas = _build_schemas()
+
+
+class OnnxType:
+    def __init__(self, type_proto: onnx.TypeProto):
+        if not isinstance(type_proto, onnx.TypeProto):
+            raise TypeError(
+                f"type_proto {type(type_proto)} must be of type onnx.TypeProto."
+            )
+        self.type_proto = type_proto
+
+    def __repr__(self) -> str:
+        return f"OnnxType({self.type_proto!r})"
+
+
+class SparseTensor:
+    """Simple representation of a sparse tensor.
+    It is based on numpy but does not require scipy.
+    """
+
+    def __init__(
+        self, values: np.ndarray, indices: np.ndarray, shape: tuple[int]
+    ) -> None:
+        self.values = values
+        self.indices = indices
+        self.shape = shape
+
+    @property
+    def dtype(self) -> Any:
+        return self.values.dtype
+
+
+def to_sparse_tensor(att: onnx.AttributeProto) -> SparseTensor:
+    """Hosts a sparse tensor."""
+    shape = tuple(d for d in att.dims)  # type: ignore[attr-defined]
+    return SparseTensor(
+        onnx.numpy_helper.to_array(att.values),  # type: ignore[attr-defined]
+        onnx.numpy_helper.to_array(att.indices),  # type: ignore[attr-defined]
+        shape,
+    )
+
+
+def _attribute_conversion_function(attr_type: onnx.AttributeProto.AttributeType):
+    return {
+        onnx.AttributeProto.FLOAT: lambda att: np.float32(att.f),
+        onnx.AttributeProto.FLOATS: lambda att: [np.float32(f) for f in att.floats],
+        onnx.AttributeProto.GRAPH: lambda att: Graph(att.g),
+        onnx.AttributeProto.GRAPHS: lambda att: [Graph(g) for g in att.graphs],
+        onnx.AttributeProto.INT: lambda att: int(att.i),
+        onnx.AttributeProto.INTS: lambda att: [int(i) for i in att.ints],
+        onnx.AttributeProto.SPARSE_TENSOR: lambda att: to_sparse_tensor(
+            att.sparse_tensor
+        ),
+        onnx.AttributeProto.SPARSE_TENSORS: lambda att: [
+            to_sparse_tensor(t) for t in att.sparse_tensors
+        ],
+        onnx.AttributeProto.STRING: lambda att: att.s.decode("utf-8"),
+        onnx.AttributeProto.STRINGS: lambda att: [
+            s.decode("utf-8") for s in att.strings
+        ],
+        onnx.AttributeProto.TENSOR: lambda att: onnx.numpy_helper.to_array(att.t),
+        onnx.AttributeProto.TENSORS: lambda att: [
+            onnx.numpy_helper.to_array(t) for t in att.tensors
+        ],
+        onnx.AttributeProto.TYPE_PROTO: lambda att: OnnxType(att.tp),
+        onnx.AttributeProto.TYPE_PROTOS: lambda att: [
+            OnnxType(t) for t in att.type_protos
+        ],
+    }[attr_type]  # type: ignore[index]
+
+
+class Graph:
+    __slots__ = ("g",)
+
+    def __init__(self, g: onnx.GraphProto) -> None:
+        self.g = g
+
+
+class OpRun(abc.ABC):
+    """Ancestor to all operators in this subfolder.
+
+    Args:
+        onnx_node: `onnx` node
+        run_params: additional parameters such as `verbose`, `opsets`
+            (it can be more than one if the operator has a subgraph),
+            `log` for a logging function
+        schema: operator schema
+    """
+
+    op_domain = ""
+
+    def __init__(
+        self, onnx_node: onnx.NodeProto, run_params: dict[str, Any], schema: Any = None
+    ):
+        if not isinstance(run_params, dict):
+            raise TypeError(f"run_params must be a dictionary not {type(run_params)}.")
+        for att in ["opsets", "new_ops"]:
+            if att not in run_params:
+                raise RuntimeError(
+                    f"Attribute {att!r} must be in run_params, only "
+                    f"{sorted(run_params)} was found."
+                )
+        if "log" not in run_params:
+            raise KeyError("run_params must contains key 'log'.")
+        self.onnx_node = onnx_node
+        self.run_params = run_params
+        if schema is None:
+            if hasattr(self.__class__, "op_schema"):
+                self._schema = self.__class__.op_schema
+            elif self.__class__.__name__ in _schemas:
+                self._schema = _schemas[self.__class__.__name__]
+            elif onnx_node.op_type in _schemas:
+                self._schema = _schemas[onnx_node.op_type]
+            else:
+                self._schema = None
+        else:
+            self._schema = schema
+        self.has_subgraph = False
+        self._load_attributes()
+
+    def _log(self, pattern, *args):
+        self.run_params["log"](pattern, *args)
+
+    def _extract_attribute_value(
+        self, att: onnx.AttributeProto, ref_att: onnx.AttributeProto | None = None
+    ) -> Any:
+        """Converts an attribute value into a python value."""
+        if att.type == onnx.AttributeProto.GRAPH:
+            new_ops = self.run_params.get("new_ops", None)
+            if "existing_functions" in self.run_params:
+                functions = list(self.run_params["existing_functions"].values())
+            else:
+                functions = None
+            evaluator_cls = self.run_params.get("evaluator_cls", None)
+            assert evaluator_cls is not None, (
+                f"evaluator_cls must be specified to evaluate att={att}"
+            )
+            return evaluator_cls(
+                att.g,
+                opsets=self.run_params["opsets"],
+                verbose=max(0, self.run_params.get("verbose", 0) - 2),
+                new_ops=None if new_ops is None else list(new_ops.values()),
+                functions=functions,
+            )
+
+        conversion_function = _attribute_conversion_function(att.type)  # type: ignore[arg-type]
+        if conversion_function is not None:
+            return conversion_function(att)
+
+        if ref_att is None:
+            raise AttributeError(
+                f"Unable to convert attribute {att.name!r} type {att.type!r} "
+                f"from node type {self.onnx_node.op_type!r}, "
+                f"domain {self.onnx_node.domain!r}\n{att}."
+            )
+
+        raise AttributeError(
+            f"Unable to convert default value for {ref_att.name!r} type {att.type!r} "
+            f"from node type {self.onnx_node.op_type!r}, "
+            f"domain {self.onnx_node.domain!r}\n{att}\n{ref_att}."
+        )
+
+    @staticmethod
+    def _evaluate_subgraph(context, value, attributes):
+        return value.run(None, context or {}, attributes=attributes)
+
+    def _load_attributes(self) -> None:
+        """Checks and loads attributes."""
+        self.has_linked_attribute = False
+        added_attributes = []
+        for att in self.onnx_node.attribute:
+            name = att.name
+            if att.ref_attr_name:
+                value = RefAttrName(att.ref_attr_name)
+                self.has_linked_attribute = True
+            else:
+                value = self._extract_attribute_value(att)
+            setattr(self, name, value)
+            added_attributes.append(name)
+            if att.type == onnx.AttributeProto.GRAPH:
+                self.has_subgraph = True
+                self.has_linked_attribute |= value.has_linked_attribute  # type: ignore[attr-defined]
+                setattr(
+                    self,
+                    f"_run_{att.name}",
+                    lambda context, value=value, attributes=None: (
+                        OpRun._evaluate_subgraph(context, value, attributes)
+                    ),
+                )
+
+        if self._schema and self.onnx_node.op_type != "Constant":
+            for k, v in self._schema.attributes.items():
+                if not hasattr(self, k):
+                    if getattr(v, "required", True):
+                        raise RuntimeError(
+                            f"Attribute {k!r} is expected based on ONNX specifications "
+                            f"for node {self.onnx_node.op_type!r}."
+                        )
+                    if hasattr(v, "default_value"):
+                        if v.default_value.type == 0 or (
+                            v.default_value.type == 4  # noqa: PLR2004
+                            and v.default_value.t.data_type == 0
+                        ):
+                            # default value is undefined, it depends on the inputs
+                            value = None  # type: ignore[assignment]
+                        else:
+                            value = self._extract_attribute_value(v.default_value, v)
+                        setattr(self, k, value)
+                        added_attributes.append(k)
+        self.attributes_names_ = set(added_attributes)
+
+    @staticmethod
+    def implicit_inputs(graph: onnx.GraphProto) -> list[str]:
+        """Returns all variables not registered as inputs and not produced by
+        an node inside the graph. This inputs are part of the context
+        existing in the graph calling this one.
+        """
+        if not isinstance(graph, onnx.GraphProto):
+            raise TypeError(f"Unexpected type {type(graph)!r}.")
+        local = set()
+        known = set()
+        for init in graph.initializer:
+            known.add(init.name)
+        for sparse_init in graph.sparse_initializer:
+            known.add(sparse_init.name)  # type: ignore[attr-defined]
+        for inp in graph.input:
+            known.add(inp.name)
+        for node in graph.node:
+            for o in node.output:
+                known.add(o)
+            for i in node.input:
+                if i not in known:
+                    local.add(i)
+        return list(local)
+
+    @property
+    def input(self) -> Sequence[str]:
+        """Returns node attribute `input`."""
+        return self.onnx_node.input
+
+    @property
+    def output(self) -> Sequence[str]:
+        """Returns node attribute `output`."""
+        return self.onnx_node.output
+
+    @property
+    def op_type(self) -> str:
+        """Returns node attribute `op_type`."""
+        return self.onnx_node.op_type
+
+    @property
+    def domain(self) -> str:
+        """Returns node attribute `domain`."""
+        return self.onnx_node.domain
+
+    def need_context(self) -> bool:
+        """Tells the runtime if this node needs the context
+        (all the results produced so far) as it may silently access
+        one of them (operator Scan, If, Loop).
+        The default answer is `False`.
+        """
+        return False
+
+    def __str__(self) -> str:
+        atts = [self.__class__.__name__ + "(", f"    op_type={self.onnx_node.op_type}"]
+        for k, v in sorted(self.__dict__.items()):
+            if k in {"desc", "onnx_node"}:
+                continue
+            if "a" <= k[0] <= "z" and k[-1] != "_":
+                atts.append(f"    {k}={v},")
+        atts.append(")")
+        return "\n".join(atts)
+
+    @abc.abstractmethod
+    def _run(self, *args, **kwargs):
+        """Should be overwritten.
+
+        Args:
+            *args: operator inputs
+            **kwargs: optional inputs and overridden attributes, an
+                attribute may be overridden if it belongs to a function,
+                in this case, the same instance of OpRun can be called
+                with different values of the same attribute.
+
+        Returns:
+            outputs
+        """
+        raise NotImplementedError(
+            f"Method '_run' must be overwritten for operator {self.__class__.__name__!r}."
+        )
+
+    def _check_and_fix_outputs(self, res: tuple[Any, ...]) -> tuple[Any, ...]:
+        """Checks the output are from the expected type."""
+        if not isinstance(res, tuple):
+            raise TypeError(
+                f"Method '_run' of class {self.__class__.__name__!r} does not return a tuple but '{type(res)}'."
+            )
+        if not res:
+            raise ValueError(
+                f"Method '_run' of class {self.__class__.__name__!r} does not return any result."
+            )
+        if any(isinstance(t, tuple) for t in res):
+            dtypes = [type(t) for t in res]
+            raise TypeError(
+                f"One of the results returned by method '_run' of class {self.__class__.__name__!r} "
+                f"is a tuple, this is no ONNX corresponding type (Map, List, Tensor, SparseTensor). "
+                f"All returned types: {dtypes!r}."
+            )
+        res = tuple((np.array(x) if np.isscalar(x) else x) for x in res)
+        if any(
+            not (isinstance(t, (np.ndarray, list, dict)) or hasattr(t, "todense"))
+            for t in res
+        ):
+            dtypes = [type(t) for t in res]
+            raise TypeError(
+                f"One of the results returned by method '_run' of class {self.__class__.__name__!r} "
+                f"has an unexpected type, this is no ONNX corresponding type (Map, List, Tensor, SparseTensor). "
+                f"All returned types: {dtypes!r}."
+            )
+        return res
+
+    def run(self, *args, linked_attributes=None, context=None):
+        """Calls method ``_run``, catches exceptions,
+        displays a longer error message.
+
+        Args:
+            *args: inputs
+            linked_attributes: used if this has an attribute linked to
+                the attribute of the function it belongs to
+            context: if this node is part of the subgraph, `context` is
+                a dictionary with the values this node may use
+
+        Returns:
+            tuple of results
+        """
+        if self.need_context():
+            if context is None:
+                raise RuntimeError(
+                    f"This node if type {type(self)} needs context to be filled."
+                )
+        elif context is not None:
+            raise RuntimeError(
+                f"This node if type {type(self)} does not need any contextbut one is given."
+            )
+        if self.has_linked_attribute and linked_attributes is None:
+            raise ValueError(
+                f"This node {type(self)} has linked attributes but None are given in parameter 'linked_attributes'."
+            )
+        if not self.has_linked_attribute and linked_attributes is not None:
+            raise ValueError(
+                f"This node {type(self)} has no linked attribute but some are given in parameter "
+                f"'linked_attributes' {set(linked_attributes)}."
+            )
+        overridden_attributes = {}
+        if self.has_linked_attribute:
+            if linked_attributes is None:
+                raise AttributeError(
+                    f"One attribute is linked but no linked value is provided, "
+                    f"in class {type(self)}."
+                )
+            for att in self.attributes_names_:
+                v = getattr(self, att)
+                if isinstance(v, RefAttrName):
+                    if v.name not in linked_attributes:
+                        raise ValueError(
+                            f"Unable to find a value for linked attribute {att!r} in {linked_attributes!r} "
+                            f"in node {type(self)}."
+                        )
+                    overridden_attributes[att] = linked_attributes[v.name]
+
+        self._log("-- begin %s.run(%d inputs)", self.__class__.__name__, len(args))
+        kwargs = {}
+        for att in self.attributes_names_:
+            if att in overridden_attributes:
+                continue
+            if not hasattr(self, att):
+                raise NameError(
+                    f"Attribute {att!r} is missing in operator {self.__class__.__name__!r}."
+                )
+            kwargs[att] = getattr(self, att)
+        if self.has_subgraph:
+            if self.has_linked_attribute and not linked_attributes:
+                raise RuntimeError(
+                    f"A subgraph has linked attribute but none was given to {type(self)}."
+                )
+            kwargs["attributes"] = linked_attributes
+        if context is not None:
+            kwargs["context"] = context
+        try:
+            if overridden_attributes:
+                res = self._run(*args, **overridden_attributes, **kwargs)
+            else:
+                res = self._run(*args, **kwargs)
+        except (TypeError, AttributeError) as e:
+            raise TypeError(
+                f"Issues with types {[type(_) for _ in args]} and attributes "
+                f"{sorted(kwargs)} and linked attributes={sorted(overridden_attributes)} "
+                f"(operator {self.__class__.__name__!r})."
+            ) from e
+        self._log(
+            "-- done %s.run -> %d outputs",
+            self.__class__.__name__,
+            len(res) if res is not None else 0,
+        )
+        return self._check_and_fix_outputs(res)
+
+    @classmethod
+    def infer_name(cls):
+        name = cls.__name__
+        if "_" not in name:
+            return name, onnx.defs.onnx_opset_version()
+        name, vers = name.rsplit("_", 1)
+        try:
+            i_vers = int(vers)
+        except ValueError:
+            return cls.__name__, onnx.defs.onnx_opset_version()
+        return name, i_vers
+
+    @classmethod
+    def make_node(
+        cls,
+        n_inputs: int | None = None,
+        n_outputs: int | None = None,
+        **kwargs: Any,
+    ) -> onnx.NodeProto:
+        """Creates an ONNX node for this class based on the given information.
+
+        Args:
+            n_inputs: number of inputs (default is defined by the
+                operator schema)
+            n_outputs: number of outputs (default is defined by the
+                operator schema)
+            verbose: verbosity
+            **kwargs: node attributes
+
+        Returns:
+            NodeProto
+
+        Method :meth:`eval <onnx.reference.op_run.OpRun.eval>` creates an onnx node
+        returned by method :meth:`make_node <onnx.reference.op_run.OpRun.make_node>`.
+
+        .. exec_code::
+
+            import numpy as np
+            from onnx.reference.ops._op_list import Celu
+
+            onnx_node = Celu.make_node(alpha=0.5)
+            print(onnx_node)
+        """
+        op_type, opset = cls.infer_name()
+        domain = cls.op_domain
+        schema = None
+        if n_inputs is None:
+            if schema is None:
+                schema = onnx.defs.get_schema(op_type, opset, domain)
+            n_inputs = schema.min_input
+        if n_outputs is None:
+            if schema is None:
+                schema = onnx.defs.get_schema(op_type, opset, domain)
+            n_outputs = schema.min_output
+
+        names_in = [f"x{i}" for i in range(n_inputs)]
+        names_out = [f"y{i}" for i in range(n_outputs)]
+        return onnx.helper.make_node(op_type, names_in, names_out, **kwargs)
+
+    @classmethod
+    def create(
+        cls,
+        n_inputs: int | None = None,
+        n_outputs: int | None = None,
+        verbose: int = 0,
+        **kwargs: Any,
+    ) -> Any:
+        """Instantiates this class based on the given information.
+
+        Args:
+            n_inputs: number of inputs (default is defined by the
+                operator schema)
+            n_outputs: number of outputs (default is defined by the
+                operator schema)
+            verbose: verbosity
+            **kwargs: node attributes
+
+        Returns:
+            NodeProto
+        """
+
+        def log_function(pattern: str, *args: Any) -> None:
+            if verbose > 1:
+                print(pattern % tuple(args))  # noqa: T201
+
+        node = cls.make_node(n_inputs, n_outputs, **kwargs)
+        run_params = {
+            "verbose": verbose,
+            "log": log_function,
+            "new_ops": None,
+            "opsets": {"": onnx.defs.onnx_opset_version()},
+        }
+        return cls(node, run_params)
+
+    @classmethod
+    def eval(
+        cls,
+        *args: list[Any],
+        n_outputs: int | None = None,
+        verbose: int = 0,
+        **kwargs: Any,
+    ) -> Any:
+        """Evaluates this operator.
+
+        Args:
+            *args: inputs
+            n_outputs: number of outputs (default is defined by the
+                operator schema)
+            verbose: verbosity
+            **kwargs: node attributes
+
+        Returns:
+            NodeProto
+        """
+        inst = cls.create(len(args), n_outputs=n_outputs, verbose=verbose, **kwargs)
+        res = inst.run(*args)
+        if len(res) == 1:
+            return res[0]
+        return res
+
+
+class OpRunExpand(OpRun):
+    """Class any operator to avoid must inherit from."""
+
+    def __new__(cls, *args, **kwargs):  # noqa: ARG004
+        raise RuntimeError(
+            f"The reference implementation must not use this node ({cls})."
+        )
+
+    def _run(self, *inputs, **kwargs):  # noqa: ARG002
+        raise RuntimeError(
+            f"The reference implementation must not use this node ({type(self)})."
+        )
+
+
+class OpFunction(OpRun):
+    """Runs a custom function."""
+
+    def __init__(
+        self,
+        onnx_node: onnx.NodeProto,
+        run_params: dict[str, Any] | None,
+        impl: Any = None,
+        attributes: dict[str, Any] | None = None,
+    ) -> None:
+        if impl is None:
+            raise RuntimeError(
+                f"impl cannot be None for node type {onnx_node.op_type!r} "
+                f"from domain {onnx_node.domain!r}."
+            )
+        OpRun.__init__(self, onnx_node, run_params)  # type: ignore[arg-type]
+        self.impl_ = impl
+        # The function implementation is the same whenever the function is called
+        # but the attributes may be different at every call.
+        self.attributes_ = {
+            name: getattr(self, name)
+            for name in getattr(self.impl_, "attributes_", attributes)  # type: ignore[union-attr]
+        }
+
+    def _run(self, *inputs, **kwargs):
+        return self._run_impl(self.impl_, *inputs, **kwargs)
+
+    def _run_impl(self, impl, *inputs, **kwargs):
+        if len(impl.input_names) != len(inputs):
+            raise RuntimeError(
+                f"Mismatch lengths between the number of inputs {len(inputs)} "
+                f"and the expected number of inputs {len(impl.input_names)} "
+                f"for node {self.op_type!r} from domain {self.domain!r}."
+            )
+        feeds = dict(zip(impl.input_names, inputs, strict=False))
+        attributes = self.attributes_.copy()
+        attributes.update(kwargs)
+        results = impl.run(None, feeds, attributes=attributes)
+        if len(impl.output_names) != len(results):
+            raise RuntimeError(
+                f"Mismatch lengths between the number of outputs {len(results)} "
+                f"and the expected number of outputs {len(impl.output_names)} "
+                f"for node {self.op_type!r} from domain {self.domain!r}."
+            )
+        return tuple(results)
+
+
+class OpFunctionContextDependant(OpFunction):
+    """The function can be instantiated but only at execution time.
+    An instance of OpFunction is created everytime to node is executed.
+    This is needed when the schema of an operator defines a context dependent function.
+    """
+
+    def __init__(
+        self,
+        onnx_node: onnx.NodeProto,
+        run_params: dict[str, Any] | None,
+        parent: Any = None,
+    ):
+        OpFunction.__init__(self, onnx_node, run_params, impl=self, attributes={})
+        self.parent = parent
+        version = parent.opsets[onnx_node.domain]
+        self.schema_ = onnx.defs.get_schema(
+            onnx_node.op_type, version, onnx_node.domain
+        )
+
+    def _run(self, *inputs, **kwargs):
+        # Input types are known. They are used to properly
+        # created the body for this operator.
+        types = []
+        for t in inputs:
+            dtype = onnx.helper.np_dtype_to_tensor_dtype(t.dtype)
+            types.append(onnx.helper.make_tensor_type_proto(dtype, t.shape))  # type: ignore[arg-type]
+        cl = self.parent._load_impl(self.onnx_node, types)
+        inst = cl(self.onnx_node, self.run_params)
+        return self._run_impl(inst.impl_, *inputs, **kwargs)
diff --git a/onnx/reference/ops/__init__.py b/onnx/reference/ops/__init__.py
new file mode 100644
index 0000000..3aaeed3
--- /dev/null
+++ b/onnx/reference/ops/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = ["load_op"]
+
+from onnx.reference.ops._op_list import load_op
diff --git a/onnx/reference/ops/_helpers.py b/onnx/reference/ops/_helpers.py
new file mode 100644
index 0000000..17dfb86
--- /dev/null
+++ b/onnx/reference/ops/_helpers.py
@@ -0,0 +1,67 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+from onnx.reference.op_run import OpRun
+
+
+def _split_class_name(name):
+    if "_" in name:
+        prefix, vers = name.rsplit("_", maxsplit=1)
+        try:
+            v = int(vers)
+        except ValueError:
+            return name, None
+        return prefix, v
+    return name, None
+
+
+def build_registered_operators_any_domain(
+    module_context: dict[str, Any],
+) -> dict[str, dict[int | None, type[OpRun]]]:
+    reg_ops: dict[str, dict[int | None, type[OpRun]]] = {}
+    for class_name, class_type in module_context.items():
+        if class_name.startswith("_") or class_name in {
+            "Any",
+            "Dict",
+            "List",
+            "TOptional",
+            "Union",
+            "annotations",
+            "cl",
+            "class_name",
+            "get_schema",
+            "module_context",
+            "textwrap",
+        }:
+            continue
+        if isinstance(class_type, type(build_registered_operators_any_domain)):
+            continue
+        issub: bool = False
+        try:
+            issub = issubclass(class_type, OpRun)
+        except TypeError as e:
+            raise TypeError(
+                f"Unexpected variable type {class_type!r} and class_name={class_name!r}."
+            ) from e
+        if issub:
+            op_type, op_version = _split_class_name(class_name)
+            if op_type not in reg_ops:
+                reg_ops[op_type] = {}
+            reg_ops[op_type][op_version] = class_type
+    if not reg_ops:
+        raise RuntimeError(
+            "No registered operator. This error happens when no implementation "
+            "of type 'OpRun' was detected. It may be due to an error during installation. Please try reinstalling onnx."
+        )
+    # Set default implementation to the latest one.
+    for impl in reg_ops.values():
+        if None in impl:
+            # default already exists
+            continue
+        max_version = max(impl)  # type: ignore[type-var]
+        impl[None] = impl[max_version]
+    return reg_ops
diff --git a/onnx/reference/ops/_op.py b/onnx/reference/ops/_op.py
new file mode 100644
index 0000000..39cb07d
--- /dev/null
+++ b/onnx/reference/ops/_op.py
@@ -0,0 +1,182 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun, RuntimeTypeError
+
+if TYPE_CHECKING:
+    from onnx.onnx_pb import NodeProto
+
+
+class OpRunUnary(OpRun):
+    """Ancestor to all unary operators in this subfolder.
+
+    Checks that input and output types are the same.
+    """
+
+    def run(self, x):
+        """Calls method ``_run``, catches exceptions, displays a longer error message.
+
+        Supports only unary operators.
+        """
+        self._log("-- begin %s.run(1 input)", self.__class__.__name__)
+        try:
+            res = self._run(x)
+        except TypeError as e:
+            raise TypeError(
+                f"Issues with types {', '.join(str(type(_)) for _ in [x])} "
+                f"(unary operator {self.__class__.__name__!r})."
+            ) from e
+        self._log("-- done %s.run -> %d outputs", self.__class__.__name__, len(res))
+        return self._check_and_fix_outputs(res)
+
+
+class OpRunUnaryNum(OpRunUnary):
+    """Ancestor to all unary and numerical operators in this subfolder.
+
+    Checks that input and output types are the same.
+    """
+
+    def run(self, x):
+        """Calls method ``OpRunUnary.run``.
+
+        Catches exceptions, displays a longer error message.
+        Checks that the result is not empty.
+        """
+        res = OpRunUnary.run(self, x)
+        if len(res) == 0 or res[0] is None:
+            return res
+        if not isinstance(res[0], list) and res[0].dtype != x.dtype:
+            raise RuntimeTypeError(
+                f"Output type mismatch: input '{x.dtype}' != output '{res[0].dtype}' "
+                f"(operator {self.__class__.__name__!r})."
+            )
+        return self._check_and_fix_outputs(res)
+
+
+class OpRunBinary(OpRun):
+    """Ancestor to all binary operators in this subfolder.
+
+    Checks that input and output types are the same.
+    """
+
+    def run(self, x, y):
+        """Calls method ``_run``, catches exceptions, displays a longer error message.
+
+        Supports only binary operators.
+        """
+        self._log("-- begin %s.run(2 inputs)", self.__class__.__name__)
+        if x is None or y is None:
+            raise RuntimeError(
+                f"x and y have different dtype: {type(x)} != {type(y)} ({type(self)})"
+            )
+        if x.dtype != y.dtype:
+            raise RuntimeTypeError(
+                f"Input type mismatch: {x.dtype} != {y.dtype} "
+                f"(operator '{self.__class__.__name__!r}', "
+                f"shapes {x.shape}, {y.shape})."
+            )
+        try:
+            res = self._run(x, y)
+        except (TypeError, ValueError) as e:
+            raise TypeError(
+                f"Issues with types {', '.join(str(type(_)) for _ in [x, y])} "
+                f"(binary operator {self.__class__.__name__!r})."
+            ) from e
+        self._log("-- done %s.run -> %d outputs", self.__class__.__name__, len(res))
+        return self._check_and_fix_outputs(res)
+
+
+class OpRunBinaryComparison(OpRunBinary):
+    """Ancestor to all binary operators in this subfolder comparing tensors."""
+
+
+class OpRunBinaryNum(OpRunBinary):
+    """Ancestor to all binary operators in this subfolder.
+
+    Checks that input oud output types are the same.
+    """
+
+    def run(self, x, y):
+        """Calls method ``OpRunBinary.run``, catches exceptions, displays a longer error message."""
+        res = OpRunBinary.run(self, x, y)
+        if res[0].dtype != x.dtype:
+            raise RuntimeTypeError(
+                f"Output type mismatch: {x.dtype} != {res[0].dtype} or {y.dtype} "
+                f"(operator {self.__class__.__name__!r})"
+                f" type(x)={type(x)} type(y)={type(y)}"
+            )
+        return self._check_and_fix_outputs(res)
+
+
+class OpRunBinaryNumpy(OpRunBinaryNum):
+    """*numpy_fct* is a binary numpy function which
+    takes two matrices.
+    """
+
+    def __init__(
+        self, numpy_fct: Any, onnx_node: NodeProto, run_params: dict[str, Any]
+    ):
+        OpRunBinaryNum.__init__(self, onnx_node, run_params)
+        self.numpy_fct = numpy_fct
+
+    def _run(self, a, b):
+        res = (self.numpy_fct(a, b),)
+        return self._check_and_fix_outputs(res)
+
+
+class OpRunReduceNumpy(OpRun):
+    """Implements the reduce logic.
+    It must have a parameter *axes*.
+    """
+
+    def __init__(self, onnx_node: NodeProto, run_params: dict[str, Any]):
+        OpRun.__init__(self, onnx_node, run_params)
+        if hasattr(self, "axes"):
+            if isinstance(self.axes, np.ndarray):
+                if len(self.axes.shape) == 0 or self.axes.shape[0] == 0:
+                    self.axes = None
+                else:
+                    self.axes = tuple(self.axes)
+            elif self.axes in [[], ()]:
+                self.axes = None
+            elif isinstance(self.axes, list):
+                self.axes = tuple(self.axes)
+
+    def is_axes_empty(self, axes):
+        return axes is None or axes.shape == (0,)
+
+    def handle_axes(self, axes, noop_with_empty_axes=False):  # noqa: PLR0911
+        if isinstance(axes, tuple):
+            if len(axes) == 0 and not noop_with_empty_axes:
+                return None
+            return axes
+        if axes is None:
+            if noop_with_empty_axes:
+                return ()
+            return None
+        if isinstance(axes, (int, tuple)):
+            return axes
+        if not isinstance(axes, np.ndarray):
+            raise TypeError(f"axes must be an array, not {type(axes)}.")
+        if len(axes.shape) == 0:
+            return int(axes)
+        # np.array of shape (0,)
+        if 0 in axes.shape:
+            if noop_with_empty_axes:
+                return ()
+            return None
+        return tuple(axes.ravel().tolist())
+
+    def output_shape(self, data, axes, keepdims):
+        return np.sum(data, axis=axes, keepdims=keepdims).shape
+
+    def reduce_constant(self, data, const_val, axes, keepdims):
+        """Special case reduction where the output value is a constant."""
+        output_shape = self.output_shape(data, axes, keepdims)
+        return (np.full(output_shape, const_val, dtype=data.dtype),)
diff --git a/onnx/reference/ops/_op_common_indices.py b/onnx/reference/ops/_op_common_indices.py
new file mode 100644
index 0000000..4524b37
--- /dev/null
+++ b/onnx/reference/ops/_op_common_indices.py
@@ -0,0 +1,37 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+
+def _get_indices(i, shape):
+    res = np.empty((len(shape),), dtype=np.int64)
+    k = len(shape) - 1
+    while k > 0:
+        m = i % shape[k]
+        res[k] = m
+        i -= m
+        i /= shape[k]
+        k -= 1
+    res[0] = i
+    return res
+
+
+def _is_out(ind, shape):
+    for i, s in zip(ind, shape, strict=True):
+        if i < 0:
+            return True
+        if i >= s:
+            return True
+    return False
+
+
+def _get_index(indices, shape):
+    ind = 0
+    mul = 1
+    for pos, sh in zip(reversed(indices), reversed(shape), strict=True):
+        ind += pos * mul
+        mul *= sh
+    return ind
diff --git a/onnx/reference/ops/_op_common_pool.py b/onnx/reference/ops/_op_common_pool.py
new file mode 100644
index 0000000..0b30747
--- /dev/null
+++ b/onnx/reference/ops/_op_common_pool.py
@@ -0,0 +1,301 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import itertools
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops._op_common_indices import _get_index, _get_indices
+
+
+def _get_pad_shape(
+    auto_pad: str,
+    input_spatial_shape: tuple[int],
+    kernel_spatial_shape: tuple[int],
+    strides_spatial: tuple[int],
+    output_spatial_shape: tuple[int],
+) -> tuple[int]:
+    pad_shape = [0] * len(input_spatial_shape)
+    if auto_pad in ("SAME_UPPER", "SAME_LOWER"):
+        for i in range(len(input_spatial_shape)):
+            pad_shape[i] = (
+                (output_spatial_shape[i] - 1) * strides_spatial[i]
+                + kernel_spatial_shape[i]
+                - input_spatial_shape[i]
+            )
+    elif auto_pad == "VALID":
+        pass
+    if len(pad_shape) == 0:
+        raise RuntimeError(
+            f"Unable to compute pad shape, auto_pad={auto_pad!r}, "
+            f"input_spatial_shape={input_spatial_shape!r}, "
+            f"kernel_spatial_shape={kernel_spatial_shape!r}, "
+            f"strides_spatial={strides_spatial!r}."
+        )
+    return tuple(pad_shape)
+
+
+def _get_output_shape_no_ceil(
+    auto_pad: str,
+    input_spatial_shape: tuple[int],
+    kernel_spatial_shape: tuple[int],
+    strides_spatial: tuple[int],
+) -> tuple[int]:
+    out_shape = [0] * len(input_spatial_shape)
+    if auto_pad in ("SAME_UPPER", "SAME_LOWER"):
+        for i in range(len(input_spatial_shape)):
+            out_shape[i] = int(
+                np.ceil(float(input_spatial_shape[i]) / float(strides_spatial[i]))
+            )
+    elif auto_pad == "VALID":
+        for i in range(len(input_spatial_shape)):
+            out_shape[i] = int(
+                np.ceil(
+                    float(input_spatial_shape[i] - (kernel_spatial_shape[i] - 1))
+                    / float(strides_spatial[i])
+                )
+            )
+    return tuple(out_shape)
+
+
+def _get_output_shape(
+    auto_pad: str,
+    input_spatial_shape: tuple[int],
+    kernel_spatial_shape: tuple[int],
+    strides_spatial: tuple[int],
+    pad_shape: tuple[int] | None = None,
+    ceil_mode: int | None = 0,
+) -> tuple[int]:
+    if not ceil_mode:
+        out_shape = _get_output_shape_no_ceil(
+            auto_pad, input_spatial_shape, kernel_spatial_shape, strides_spatial
+        )
+    else:
+        round_fct = np.ceil if ceil_mode else np.floor
+        out_shape = [0] * len(input_spatial_shape)
+        if auto_pad in ("SAME_UPPER", "SAME_LOWER"):
+            for i in range(len(input_spatial_shape)):
+                out_shape[i] = int(
+                    round_fct(float(input_spatial_shape[i]) / float(strides_spatial[i]))
+                )
+        elif auto_pad == "VALID":
+            if pad_shape is None:
+                raise ValueError(  # pragma: no cogitver
+                    "pad_shape cannot be None if auto_pad is "
+                    "'VALID' and ceil_mode is 1."
+                )
+            for i in range(len(input_spatial_shape)):
+                out_shape[i] = int(
+                    round_fct(
+                        float(
+                            input_spatial_shape[i]
+                            + pad_shape[i]
+                            - kernel_spatial_shape[i]
+                        )
+                        / float(strides_spatial[i])
+                        + 1
+                    )
+                )
+    if len(out_shape) == 0:
+        raise RuntimeError(
+            f"Unable to compute output shape, auto_pad={auto_pad!r}, "
+            f"input_spatial_shape={input_spatial_shape!r}, "
+            f"kernel_spatial_shape={kernel_spatial_shape!r}, "
+            f"strides_spatial={strides_spatial!r}, ceil_mode={ceil_mode!r}."
+        )
+    if min(out_shape) <= 0:
+        raise RuntimeError(
+            f"output shape cannot be null or negative, out_shape={out_shape!r}, "
+            f"auto_pad={auto_pad!r}, input_spatial_shape={input_spatial_shape!r}, "
+            f"kernel_spatial_shape={kernel_spatial_shape!r}, "
+            f"strides_spatial={strides_spatial!r}, ceil_mode={ceil_mode!r}."
+        )
+    return tuple(out_shape)
+
+
+def _pool(
+    padded: np.ndarray,
+    x_shape: tuple[int],
+    kernel_shape: tuple[int],
+    strides_shape: tuple[int],
+    out_shape: tuple[int],
+    pad_shape: tuple[int],
+    pooling_type: str,
+    count_include_pad: int | None = 0,
+    ceil_mode: int | None = 0,
+    indices: bool = False,
+    pads: np.ndarray | None = None,
+) -> np.ndarray:
+    if pooling_type == "AVG":
+        fpool = np.average
+    elif pooling_type == "MAX":
+        fpool = np.max
+    else:
+        raise NotImplementedError(
+            f"Pooling type {pooling_type!r} does not support. Should be AVG, MAX."
+        )
+    spatial_size = len(x_shape) - 2
+    y = np.zeros([x_shape[0], x_shape[1], *list(out_shape)])
+    if indices:
+        z = np.full(y.shape, fill_value=-1, dtype=np.int64)
+    round_fct = np.ceil if ceil_mode else np.floor
+
+    def loop_range():
+        return [
+            range(
+                int(
+                    round_fct(
+                        float(x_shape[i + 2] + pad_shape[i] - kernel_shape[i])
+                        / float(strides_shape[i])
+                        + 1
+                    )
+                )
+            )
+            for i in range(spatial_size)
+        ]
+
+    for shape in itertools.product(range(x_shape[0]), range(x_shape[1]), *loop_range()):
+        window = padded[shape[0], shape[1]]
+        listi = [
+            range(
+                strides_shape[i] * shape[i + 2],
+                strides_shape[i] * shape[i + 2] + kernel_shape[i],
+            )
+            for i in range(spatial_size)
+        ]
+        listi2 = list(itertools.product(*listi))
+        values = []
+        for i in listi2:
+            try:
+                values.append(window[i])
+            except IndexError:  # noqa: PERF203
+                continue
+        window_vals = np.array(values)
+
+        if count_include_pad == 1 and pooling_type == "AVG":
+            y[shape] = fpool(window_vals)
+        else:
+            no_nan = window_vals[np.where(~np.isnan(window_vals))]
+            y[shape] = fpool(no_nan)
+            if indices:
+                try:
+                    window_vals_min = np.nan_to_num(window_vals, nan=no_nan.min())
+                except TypeError:
+                    # argument nan was introduced in numpy 1.17
+                    window_vals_min = window_vals.copy()
+                    window_vals_min[np.isnan(window_vals_min)] = no_nan.min()
+                arg = np.argmax(window_vals_min)
+                coordinates = _get_indices(arg, out_shape)
+                delta = shape[2:] - pads[:, 0]
+                coordinates += delta
+                new_arg = _get_index(coordinates, x_shape[2:])
+                z[shape] = new_arg
+    if indices:
+        return y.astype(padded.dtype), z
+    return y.astype(padded.dtype)
+
+
+class CommonPool(OpRun):
+    def _run(
+        self,
+        pooling_type,
+        count_include_pad,
+        x,
+        auto_pad=None,
+        ceil_mode=None,
+        dilations=None,
+        kernel_shape=None,
+        pads=None,
+        storage_order=None,  # noqa: ARG002
+        strides=None,
+    ):
+        if pooling_type == "MAX" and dilations is None:
+            dilations = [1 for s in kernel_shape]
+        if pads is None:
+            pads = [0 for s in kernel_shape] * 2
+
+        if strides is None or len(strides) == 0:
+            strides = [1] * (len(x.shape) - 2)
+        kernel_shape = list(kernel_shape)
+        auto_pad = "VALID" if auto_pad == "NOTSET" else auto_pad
+
+        if pads is None or len(pads) == 0:
+            pad_shape = [0] * (len(x.shape) - 2)
+            x_shape = x.shape[2:]
+            padded = x
+        elif len(pads) == 4:
+            pad_top, pad_bottom, pad_left, pad_right = pads
+            pad_shape = [pad_top + pad_bottom, pad_left + pad_right]
+            x_shape = np.array(x.shape[2:]) + np.array(pad_shape)
+            const = np.nan if count_include_pad == 0 else 0
+            padded = np.pad(
+                x,
+                ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+                mode="constant",
+                constant_values=const,
+            )
+        else:
+            pad_shape = pads
+            x_shape = x.shape[2:]
+            padded = x
+
+        if auto_pad in ("SAME_LOWER", "SAME_UPPER"):
+            const = np.nan if count_include_pad == 0 else 0
+            out_shape = _get_output_shape(
+                auto_pad,
+                x_shape,
+                kernel_shape,
+                strides,
+                pad_shape,
+                ceil_mode,
+            )
+            pad_shape = _get_pad_shape(
+                auto_pad, x_shape, kernel_shape, strides, out_shape
+            )
+            if auto_pad == "SAME_LOWER":
+                pad_bottom = pad_shape[0] // 2
+                pad_top = pad_shape[0] - pad_bottom
+                pad_right = pad_shape[1] // 2
+                pad_left = pad_shape[1] - pad_right
+            else:
+                pad_top = pad_shape[0] // 2
+                pad_bottom = pad_shape[0] - pad_top
+                pad_left = pad_shape[1] // 2
+                pad_right = pad_shape[1] - pad_left
+            padded = np.pad(
+                padded,
+                ((0, 0), (0, 0), (pad_top, pad_bottom), (pad_left, pad_right)),
+                mode="constant",
+                constant_values=const,
+            )
+        else:
+            out_shape = _get_output_shape(
+                auto_pad,
+                x_shape,
+                kernel_shape,
+                strides,
+                pad_shape,
+                ceil_mode,
+            )
+
+        n_dims = len(pads) // 2
+        new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
+        res = _pool(
+            padded,
+            x.shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            pad_shape,
+            pooling_type,
+            count_include_pad=count_include_pad,
+            ceil_mode=ceil_mode,
+            indices=len(self.output) > 1,
+            pads=new_pads,
+        )
+        if isinstance(res, tuple):
+            return res
+        return (res,)
diff --git a/onnx/reference/ops/_op_common_random.py b/onnx/reference/ops/_op_common_random.py
new file mode 100644
index 0000000..c7b011e
--- /dev/null
+++ b/onnx/reference/ops/_op_common_random.py
@@ -0,0 +1,55 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.helper import tensor_dtype_to_np_dtype
+from onnx.reference.op_run import OpRun
+
+
+class _CommonRandom(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        if hasattr(self, "shape") and len(self.shape) == 0:
+            raise ValueError(  # pragma: no cover
+                f"shape cannot be empty for operator {self.__class__.__name__}."
+            )
+
+    @staticmethod
+    def numpy_type(dtype):
+        return tensor_dtype_to_np_dtype(dtype)
+
+    @staticmethod
+    def _dtype(*data, dtype=None, dtype_first=False):
+        numpy_type = _CommonRandom.numpy_type(dtype)
+        if dtype_first and numpy_type is not None:
+            if dtype != 0:
+                return numpy_type
+            if data:
+                return data[0].dtype
+            raise RuntimeError(
+                f"dtype cannot be None for a random operator {_CommonRandom.__name__!r}, "
+                f"numpy_type={numpy_type}, len(data)={len(data)}."
+            )
+        res = None
+        if not data:
+            res = numpy_type
+        elif numpy_type is not None:
+            res = numpy_type
+        elif hasattr(data[0], "dtype"):
+            res = data[0].dtype
+        if res is None:
+            raise RuntimeError(
+                f"dtype cannot be None, numpy_type={numpy_type}, type(data[0])={type(data[0])}."
+            )
+        return res
+
+    @staticmethod
+    def _get_state(seed):
+        if seed is None or np.isnan(seed):
+            state = np.random.RandomState()
+        else:
+            state = np.random.RandomState(seed=int(seed))
+        return state
diff --git a/onnx/reference/ops/_op_common_window.py b/onnx/reference/ops/_op_common_window.py
new file mode 100644
index 0000000..80158ae
--- /dev/null
+++ b/onnx/reference/ops/_op_common_window.py
@@ -0,0 +1,26 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.helper import tensor_dtype_to_np_dtype
+from onnx.reference.op_run import OpRun
+
+
+class _CommonWindow(OpRun):
+    @staticmethod
+    def _begin(size, periodic, output_datatype):
+        dtype = tensor_dtype_to_np_dtype(output_datatype)
+        if periodic == 1:
+            N_1 = size
+        else:
+            N_1 = size - 1
+        ni = np.arange(size, dtype=dtype)
+        return ni, N_1
+
+    @staticmethod
+    def _end(size: int, res: np.ndarray, output_datatype: int) -> tuple[np.ndarray]:  # noqa: ARG004
+        dtype = tensor_dtype_to_np_dtype(output_datatype)
+        return (res.astype(dtype),)
diff --git a/onnx/reference/ops/_op_list.py b/onnx/reference/ops/_op_list.py
new file mode 100644
index 0000000..1f70bd4
--- /dev/null
+++ b/onnx/reference/ops/_op_list.py
@@ -0,0 +1,627 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+"""Every class imported in this module defines an implementation of
+an operator of the main domain. Any class name uses `_` to specify a
+version defined in a specific opset. The class name without `_`
+defines the current implementation. If an operator has no class
+with `_`, it means the implementation is valid for every opset.
+The operator may have been updated to support more types but that
+did not change the implementation.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "load_op",
+    "Abs",
+    "Acos",
+    "Acosh",
+    "Add",
+    "AffineGrid",
+    "And",
+    "ArgMax_1",
+    "ArgMax_12",
+    "ArgMin_1",
+    "ArgMin_12",
+    "Asin",
+    "Asinh",
+    "Atan",
+    "Atanh",
+    "Attention",
+    "AttributeHasValue",
+    "AveragePool_1",
+    "AveragePool_7",
+    "AveragePool_11",
+    "AveragePool_19",
+    "BatchNormalization_6",
+    "BatchNormalization_9",
+    "BatchNormalization_14",
+    "Bernoulli",
+    "BitCast",
+    "BitShift",
+    "BitwiseAnd",
+    "BitwiseNot",
+    "BitwiseOr",
+    "BitwiseXor",
+    "BlackmanWindow",
+    "Cast_1",
+    "Cast_19",
+    "Cast_24",
+    "CastLike_15",
+    "CastLike_19",
+    "CausalConvWithState",
+    "Ceil",
+    "Celu",
+    "CenterCropPad",
+    "Clip_6",
+    "Clip_11",
+    "Col2Im",
+    "Compress",
+    "Concat",
+    "ConcatFromSequence",
+    "Constant_1",
+    "Constant_9",
+    "Constant_11",
+    "Constant_12",
+    "ConstantOfShape",
+    "Conv",
+    "ConvInteger",
+    "ConvTranspose",
+    "Cos",
+    "Cosh",
+    "CumProd",
+    "CumSum",
+    "DeformConv",
+    "DepthToSpace",
+    "DequantizeLinear_19",
+    "DequantizeLinear_21",
+    "DequantizeLinear_23",
+    "DequantizeLinear_25",
+    "Det",
+    "DFT_17",
+    "DFT_20",
+    "Div",
+    "Dropout_7",
+    "Dropout_12",
+    "DynamicQuantizeLinear",
+    "Einsum",
+    "Elu",
+    "Equal",
+    "Erf",
+    "Exp",
+    "Expand",
+    "EyeLike",
+    "Flatten",
+    "Floor",
+    "Gather",
+    "GatherElements",
+    "GatherND",
+    "Gemm_6",
+    "Gemm_7",
+    "GlobalAveragePool",
+    "GlobalMaxPool",
+    "Greater",
+    "GreaterOrEqual",
+    "GridSample",
+    "GRU",
+    "HammingWindow",
+    "HannWindow",
+    "HardSigmoid",
+    "Hardmax",
+    "Identity",
+    "If",
+    "ImageDecoder",
+    "InstanceNormalization",
+    "IsInf",
+    "IsNaN",
+    "LayerNormalization",
+    "LeakyRelu",
+    "Less",
+    "LessOrEqual",
+    "LinearAttention",
+    "Log",
+    "LogSoftmax",
+    "Loop",
+    "LpNormalization",
+    "LpPool",
+    "LRN",
+    "LSTM",
+    "MatMul",
+    "MatMulInteger",
+    "Max",
+    "MaxPool",
+    "MaxUnpool",
+    "Mean",
+    "MelWeightMatrix",
+    "Min",
+    "Mod",
+    "Mul",
+    "Neg",
+    "NegativeLogLikelihoodLoss",
+    "NonMaxSuppression",
+    "NonZero",
+    "Not",
+    "OneHot",
+    "Optional",
+    "OptionalGetElement",
+    "OptionalHasElement",
+    "Or",
+    "Pad_1",
+    "Pad_2",
+    "Pad_11",
+    "Pad_18",
+    "Pow",
+    "PRelu",
+    "QLinearConv",
+    "QLinearMatMul",
+    "QuantizeLinear_10",
+    "QuantizeLinear_19",
+    "QuantizeLinear_21",
+    "QuantizeLinear_23",
+    "QuantizeLinear_25",
+    "RandomNormal",
+    "RandomNormalLike",
+    "RandomUniform",
+    "RandomUniformLike",
+    "Range",
+    "Reciprocal",
+    "ReduceL1_1",
+    "ReduceL1_18",
+    "ReduceL2_1",
+    "ReduceL2_18",
+    "ReduceLogSum_1",
+    "ReduceLogSum_18",
+    "ReduceLogSumExp_1",
+    "ReduceLogSumExp_18",
+    "ReduceMax_1",
+    "ReduceMax_18",
+    "ReduceMean_1",
+    "ReduceMean_18",
+    "ReduceMin_1",
+    "ReduceMin_18",
+    "ReduceProd_1",
+    "ReduceProd_18",
+    "ReduceSum_1",
+    "ReduceSum_13",
+    "ReduceSumSquare_1",
+    "ReduceSumSquare_18",
+    "RegexFullMatch",
+    "Relu",
+    "Reshape_5",
+    "Reshape_14",
+    "Resize",
+    "ReverseSequence",
+    "RMSNormalization",
+    "RNN_7",
+    "RNN_14",
+    "RoiAlign",
+    "RotaryEmbedding",
+    "Round",
+    "Scan",
+    "ScatterElements",
+    "ScatterND",
+    "Selu",
+    "SequenceAt",
+    "SequenceConstruct",
+    "SequenceEmpty",
+    "SequenceErase",
+    "SequenceInsert",
+    "SequenceLength",
+    "SequenceMap",
+    "Shape_1",
+    "Shape_15",
+    "Shrink",
+    "Sigmoid",
+    "Sign",
+    "Sin",
+    "Sinh",
+    "Size",
+    "Slice_1",
+    "Slice_10",
+    "Softmax",
+    "SoftmaxCrossEntropyLoss",
+    "Softplus",
+    "Softsign",
+    "Swish",
+    "SpaceToDepth",
+    "Split_2",
+    "Split_11",
+    "Split_13",
+    "Split_18",
+    "SplitToSequence",
+    "Sqrt",
+    "Squeeze_1",
+    "Squeeze_11",
+    "Squeeze_13",
+    "STFT",
+    "StringConcat",
+    "StringNormalizer",
+    "StringSplit",
+    "Sub",
+    "Sum",
+    "Tan",
+    "Tanh",
+    "TensorScatter",
+    "TfIdfVectorizer",
+    "ThresholdedRelu",
+    "Tile",
+    "TopK_1",
+    "TopK_10",
+    "TopK_11",
+    "Transpose",
+    "Trilu",
+    "Unique",
+    "Unsqueeze_1",
+    "Unsqueeze_11",
+    "Unsqueeze_13",
+    "Upsample",
+    "Where",
+    "Xor",
+]
+
+import textwrap
+from typing import Any
+
+from onnx import FunctionProto, NodeProto, TypeProto
+from onnx.defs import get_schema, onnx_opset_version
+from onnx.onnx_cpp2py_export.defs import SchemaError
+from onnx.reference.op_run import (
+    OpFunction,
+    OpRun,
+    RuntimeContextError,
+    RuntimeImplementationError,
+)
+from onnx.reference.ops._helpers import build_registered_operators_any_domain
+from onnx.reference.ops.op_abs import Abs
+from onnx.reference.ops.op_acos import Acos
+from onnx.reference.ops.op_acosh import Acosh
+from onnx.reference.ops.op_add import Add
+from onnx.reference.ops.op_affine_grid import AffineGrid
+from onnx.reference.ops.op_and import And
+from onnx.reference.ops.op_argmax import ArgMax_1, ArgMax_12
+from onnx.reference.ops.op_argmin import ArgMin_1, ArgMin_12
+from onnx.reference.ops.op_asin import Asin
+from onnx.reference.ops.op_asinh import Asinh
+from onnx.reference.ops.op_atan import Atan
+from onnx.reference.ops.op_atanh import Atanh
+from onnx.reference.ops.op_attention import Attention
+from onnx.reference.ops.op_attribute_has_value import AttributeHasValue
+from onnx.reference.ops.op_average_pool import (
+    AveragePool_1,
+    AveragePool_7,
+    AveragePool_11,
+    AveragePool_19,
+)
+from onnx.reference.ops.op_batch_normalization import (
+    BatchNormalization_6,
+    BatchNormalization_9,
+    BatchNormalization_14,
+)
+from onnx.reference.ops.op_bernoulli import Bernoulli
+from onnx.reference.ops.op_bitcast import BitCast
+from onnx.reference.ops.op_bitshift import BitShift
+from onnx.reference.ops.op_bitwise_and import BitwiseAnd
+from onnx.reference.ops.op_bitwise_not import BitwiseNot
+from onnx.reference.ops.op_bitwise_or import BitwiseOr
+from onnx.reference.ops.op_bitwise_xor import BitwiseXor
+from onnx.reference.ops.op_blackman_window import BlackmanWindow
+from onnx.reference.ops.op_cast import Cast_1, Cast_19, Cast_24
+from onnx.reference.ops.op_cast_like import CastLike_15, CastLike_19
+from onnx.reference.ops.op_causal_conv_with_state import CausalConvWithState
+from onnx.reference.ops.op_ceil import Ceil
+from onnx.reference.ops.op_celu import Celu
+from onnx.reference.ops.op_center_crop_pad import CenterCropPad
+from onnx.reference.ops.op_clip import Clip_6, Clip_11
+from onnx.reference.ops.op_col2im import Col2Im
+from onnx.reference.ops.op_compress import Compress
+from onnx.reference.ops.op_concat import Concat
+from onnx.reference.ops.op_concat_from_sequence import ConcatFromSequence
+from onnx.reference.ops.op_constant import (
+    Constant_1,
+    Constant_9,
+    Constant_11,
+    Constant_12,
+)
+from onnx.reference.ops.op_constant_of_shape import ConstantOfShape
+from onnx.reference.ops.op_conv import Conv
+from onnx.reference.ops.op_conv_integer import ConvInteger
+from onnx.reference.ops.op_conv_transpose import ConvTranspose
+from onnx.reference.ops.op_cos import Cos
+from onnx.reference.ops.op_cosh import Cosh
+from onnx.reference.ops.op_cum_prod import CumProd
+from onnx.reference.ops.op_cum_sum import CumSum
+from onnx.reference.ops.op_deform_conv import DeformConv
+from onnx.reference.ops.op_depth_to_space import DepthToSpace
+from onnx.reference.ops.op_dequantize_linear import (
+    DequantizeLinear_19,
+    DequantizeLinear_21,
+    DequantizeLinear_23,
+    DequantizeLinear_25,
+)
+from onnx.reference.ops.op_det import Det
+from onnx.reference.ops.op_dft import DFT_17, DFT_20
+from onnx.reference.ops.op_div import Div
+from onnx.reference.ops.op_dropout import Dropout_7, Dropout_12
+from onnx.reference.ops.op_dynamic_quantize_linear import DynamicQuantizeLinear
+from onnx.reference.ops.op_einsum import Einsum
+from onnx.reference.ops.op_elu import Elu
+from onnx.reference.ops.op_equal import Equal
+from onnx.reference.ops.op_erf import Erf
+from onnx.reference.ops.op_exp import Exp
+from onnx.reference.ops.op_expand import Expand
+from onnx.reference.ops.op_eyelike import EyeLike
+from onnx.reference.ops.op_flatten import Flatten
+from onnx.reference.ops.op_floor import Floor
+from onnx.reference.ops.op_gather import Gather
+from onnx.reference.ops.op_gather_elements import GatherElements
+from onnx.reference.ops.op_gathernd import GatherND
+from onnx.reference.ops.op_gemm import Gemm_6, Gemm_7
+from onnx.reference.ops.op_global_average_pool import GlobalAveragePool
+from onnx.reference.ops.op_global_max_pool import GlobalMaxPool
+from onnx.reference.ops.op_greater import Greater
+from onnx.reference.ops.op_greater_or_equal import GreaterOrEqual
+from onnx.reference.ops.op_grid_sample import GridSample
+from onnx.reference.ops.op_gru import GRU
+from onnx.reference.ops.op_hamming_window import HammingWindow
+from onnx.reference.ops.op_hann_window import HannWindow
+from onnx.reference.ops.op_hard_sigmoid import HardSigmoid
+from onnx.reference.ops.op_hardmax import Hardmax
+from onnx.reference.ops.op_identity import Identity
+from onnx.reference.ops.op_if import If
+from onnx.reference.ops.op_image_decoder import ImageDecoder
+from onnx.reference.ops.op_instance_normalization import InstanceNormalization
+from onnx.reference.ops.op_isinf import IsInf
+from onnx.reference.ops.op_isnan import IsNaN
+from onnx.reference.ops.op_layer_normalization import LayerNormalization
+from onnx.reference.ops.op_leaky_relu import LeakyRelu
+from onnx.reference.ops.op_less import Less
+from onnx.reference.ops.op_less_or_equal import LessOrEqual
+from onnx.reference.ops.op_linear_attention import LinearAttention
+from onnx.reference.ops.op_log import Log
+from onnx.reference.ops.op_log_softmax import LogSoftmax
+from onnx.reference.ops.op_loop import Loop
+from onnx.reference.ops.op_lp_normalization import LpNormalization
+from onnx.reference.ops.op_lp_pool import LpPool
+from onnx.reference.ops.op_lrn import LRN
+from onnx.reference.ops.op_lstm import LSTM
+from onnx.reference.ops.op_matmul import MatMul
+from onnx.reference.ops.op_matmul_integer import MatMulInteger
+from onnx.reference.ops.op_max import Max
+from onnx.reference.ops.op_max_pool import MaxPool
+from onnx.reference.ops.op_max_unpool import MaxUnpool
+from onnx.reference.ops.op_mean import Mean
+from onnx.reference.ops.op_mel_weight_matrix import MelWeightMatrix
+from onnx.reference.ops.op_min import Min
+from onnx.reference.ops.op_mod import Mod
+from onnx.reference.ops.op_mul import Mul
+from onnx.reference.ops.op_neg import Neg
+from onnx.reference.ops.op_negative_log_likelihood_loss import NegativeLogLikelihoodLoss
+from onnx.reference.ops.op_non_max_suppression import NonMaxSuppression
+from onnx.reference.ops.op_non_zero import NonZero
+from onnx.reference.ops.op_not import Not
+from onnx.reference.ops.op_one_hot import OneHot
+from onnx.reference.ops.op_optional import Optional
+from onnx.reference.ops.op_optional_get_element import OptionalGetElement
+from onnx.reference.ops.op_optional_has_element import OptionalHasElement
+from onnx.reference.ops.op_or import Or
+from onnx.reference.ops.op_pad import Pad_1, Pad_2, Pad_11, Pad_18
+from onnx.reference.ops.op_pow import Pow
+from onnx.reference.ops.op_prelu import PRelu
+from onnx.reference.ops.op_qlinear_conv import QLinearConv
+from onnx.reference.ops.op_qlinear_matmul import QLinearMatMul
+from onnx.reference.ops.op_quantize_linear import (
+    QuantizeLinear_10,
+    QuantizeLinear_19,
+    QuantizeLinear_21,
+    QuantizeLinear_23,
+    QuantizeLinear_25,
+)
+from onnx.reference.ops.op_random_normal import RandomNormal
+from onnx.reference.ops.op_random_normal_like import RandomNormalLike
+from onnx.reference.ops.op_random_uniform import RandomUniform
+from onnx.reference.ops.op_random_uniform_like import RandomUniformLike
+from onnx.reference.ops.op_range import Range
+from onnx.reference.ops.op_reciprocal import Reciprocal
+from onnx.reference.ops.op_reduce_l1 import ReduceL1_1, ReduceL1_18
+from onnx.reference.ops.op_reduce_l2 import ReduceL2_1, ReduceL2_18
+from onnx.reference.ops.op_reduce_log_sum import ReduceLogSum_1, ReduceLogSum_18
+from onnx.reference.ops.op_reduce_log_sum_exp import (
+    ReduceLogSumExp_1,
+    ReduceLogSumExp_18,
+)
+from onnx.reference.ops.op_reduce_max import ReduceMax_1, ReduceMax_18
+from onnx.reference.ops.op_reduce_mean import ReduceMean_1, ReduceMean_18
+from onnx.reference.ops.op_reduce_min import ReduceMin_1, ReduceMin_18
+from onnx.reference.ops.op_reduce_prod import ReduceProd_1, ReduceProd_18
+from onnx.reference.ops.op_reduce_sum import ReduceSum_1, ReduceSum_13
+from onnx.reference.ops.op_reduce_sum_square import (
+    ReduceSumSquare_1,
+    ReduceSumSquare_18,
+)
+from onnx.reference.ops.op_regex_full_match import RegexFullMatch
+from onnx.reference.ops.op_relu import Relu
+from onnx.reference.ops.op_reshape import Reshape_5, Reshape_14
+from onnx.reference.ops.op_resize import Resize
+from onnx.reference.ops.op_reverse_sequence import ReverseSequence
+from onnx.reference.ops.op_rms_normalization import RMSNormalization
+from onnx.reference.ops.op_rnn import RNN_7, RNN_14
+from onnx.reference.ops.op_roi_align import RoiAlign
+from onnx.reference.ops.op_rotary_embedding import RotaryEmbedding
+from onnx.reference.ops.op_round import Round
+from onnx.reference.ops.op_scan import Scan
+from onnx.reference.ops.op_scatter_elements import ScatterElements
+from onnx.reference.ops.op_scatternd import ScatterND
+from onnx.reference.ops.op_selu import Selu
+from onnx.reference.ops.op_sequence_at import SequenceAt
+from onnx.reference.ops.op_sequence_construct import SequenceConstruct
+from onnx.reference.ops.op_sequence_empty import SequenceEmpty
+from onnx.reference.ops.op_sequence_erase import SequenceErase
+from onnx.reference.ops.op_sequence_insert import SequenceInsert
+from onnx.reference.ops.op_sequence_length import SequenceLength
+from onnx.reference.ops.op_sequence_map import SequenceMap
+from onnx.reference.ops.op_shape import Shape_1, Shape_15
+from onnx.reference.ops.op_shrink import Shrink
+from onnx.reference.ops.op_sigmoid import Sigmoid
+from onnx.reference.ops.op_sign import Sign
+from onnx.reference.ops.op_sin import Sin
+from onnx.reference.ops.op_sinh import Sinh
+from onnx.reference.ops.op_size import Size
+from onnx.reference.ops.op_slice import Slice_1, Slice_10
+from onnx.reference.ops.op_softmax import Softmax
+from onnx.reference.ops.op_softmax_cross_entropy_loss import SoftmaxCrossEntropyLoss
+from onnx.reference.ops.op_softplus import Softplus
+from onnx.reference.ops.op_softsign import Softsign
+from onnx.reference.ops.op_space_to_depth import SpaceToDepth
+from onnx.reference.ops.op_split import Split_2, Split_11, Split_13, Split_18
+from onnx.reference.ops.op_split_to_sequence import SplitToSequence
+from onnx.reference.ops.op_sqrt import Sqrt
+from onnx.reference.ops.op_squeeze import Squeeze_1, Squeeze_11, Squeeze_13
+from onnx.reference.ops.op_stft import STFT
+from onnx.reference.ops.op_string_concat import StringConcat
+from onnx.reference.ops.op_string_normalizer import StringNormalizer
+from onnx.reference.ops.op_string_split import StringSplit
+from onnx.reference.ops.op_sub import Sub
+from onnx.reference.ops.op_sum import Sum
+from onnx.reference.ops.op_swish import Swish
+from onnx.reference.ops.op_tan import Tan
+from onnx.reference.ops.op_tanh import Tanh
+from onnx.reference.ops.op_tensor_scatter import TensorScatter
+from onnx.reference.ops.op_tfidf_vectorizer import TfIdfVectorizer
+from onnx.reference.ops.op_thresholded_relu import ThresholdedRelu
+from onnx.reference.ops.op_tile import Tile
+from onnx.reference.ops.op_topk import TopK_1, TopK_10, TopK_11
+from onnx.reference.ops.op_transpose import Transpose
+from onnx.reference.ops.op_trilu import Trilu
+from onnx.reference.ops.op_unique import Unique
+from onnx.reference.ops.op_unsqueeze import Unsqueeze_1, Unsqueeze_11, Unsqueeze_13
+from onnx.reference.ops.op_upsample import Upsample
+from onnx.reference.ops.op_where import Where
+from onnx.reference.ops.op_xor import Xor
+
+
+def _build_registered_operators() -> dict[str, dict[int | None, type[OpRun]]]:
+    return build_registered_operators_any_domain(globals().copy())
+
+
+def load_op(
+    domain: str,
+    op_type: str,
+    version: None | int = None,
+    custom: Any = None,
+    node: None | NodeProto = None,
+    input_types: None | list[TypeProto] = None,
+    expand: bool = False,
+    evaluator_cls: type | None = None,
+) -> Any:
+    """Loads the implemented for a specified operator.
+
+    Args:
+        domain: domain
+        op_type: operator type
+        version: requested version
+        custom: custom implementation (like a function)
+        node: used if no implementation was found and the operator
+            defines a function which is context dependent
+        input_types: used if no implementation was found and the
+            operator defines a function which is context dependent
+        expand: use the function implemented in the schema instead of
+            its reference implementation
+        evaluator_cls: evaluator to use
+
+    Returns:
+        class
+    """
+    global _registered_operators  # noqa: PLW0603
+    schema = None
+    if _registered_operators is None:
+        _registered_operators = _build_registered_operators()  # type: ignore[assignment]
+    assert _registered_operators is not None
+    if custom is not None:
+        return lambda *args: OpFunction(*args, impl=custom)
+    if version is None:
+        version = onnx_opset_version()
+    if domain != "":
+        raise ValueError(f"Domain must be '' not {domain!r}.")
+    if op_type in _registered_operators and not expand:
+        found = True
+    else:
+        # maybe the operator can be replaced by a function
+        try:
+            schema = get_schema(op_type, version, domain)
+        except SchemaError:
+            raise NotImplementedError(
+                f"No registered schema for operator {op_type!r} "
+                f"and domain {domain!r}. Did you recompile the sources after updating the repository?"
+            ) from None
+        if schema.has_function:
+            body = schema.function_body
+            assert evaluator_cls is not None, (
+                f"evaluator_cls must be specified to implement operator {op_type!r} from domain {domain!r}"
+            )
+            sess = evaluator_cls(body)
+            return lambda *args, sess=sess: OpFunction(*args, impl=sess)
+        if schema.has_context_dependent_function:
+            if node is None or input_types is None:
+                raise RuntimeContextError(
+                    f"No registered implementation for operator {op_type!r} "
+                    f"and domain {domain!r}, the operator has a context dependent function. "
+                    f"but argument node or input_types is not defined (input_types={input_types})."
+                )
+            body = schema.get_context_dependent_function(
+                node.SerializeToString(), [it.SerializeToString() for it in input_types]
+            )
+            proto = FunctionProto()
+            proto.ParseFromString(body)
+            assert evaluator_cls is not None, (
+                f"evaluator_cls must be specified to evaluate function {proto.name!r}"
+            )
+            sess = evaluator_cls(proto)
+            return lambda *args, sess=sess: OpFunction(*args, impl=sess)
+        found = False
+    if not found:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        has_function = schema.has_function if schema else None
+        has_context_dependent_function = (
+            schema.has_context_dependent_function if schema else None
+        )
+        raise RuntimeImplementationError(
+            f"No registered implementation for operator {op_type!r} "
+            f"and domain {domain!r}, schema.has_function is {has_function}, "
+            f"schema.has_context_dependent_function is {has_context_dependent_function}. "
+            f"You may either add one or skip the test in "
+            f"'test_backend_reference.py'. Available implementations:\n{available}"
+        )
+    impl = _registered_operators[op_type]
+    if None not in impl:
+        raise RuntimeError(
+            f"No default implementation for operator {op_type!r} "
+            f"and domain {domain!r}, found "
+            f"{', '.join(map(str, impl))}."
+        )
+    if version is None or len(impl) == 1:
+        cl = impl[None]
+    else:
+        best = -1
+        for v in impl:
+            if v is None:
+                continue
+            if best < v <= version:
+                best = v
+        if best == -1:
+            raise RuntimeError(
+                f"No implementation for operator {op_type!r} "
+                f"domain {domain!r} and version {version!r}, found "
+                f"{', '.join(map(str, impl))}."
+            )
+        cl = impl[best]
+    if cl is None:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        raise ValueError(
+            f"Not registered implementation for operator {op_type!r}, "
+            f"domain {domain!r}, and {version!r} in\n{available}"
+        )
+    return cl
+
+
+_registered_operators: dict[str, dict[int | None, OpRun]] | None = None
diff --git a/onnx/reference/ops/_quant_utils.py b/onnx/reference/ops/_quant_utils.py
new file mode 100644
index 0000000..9b1fc39
--- /dev/null
+++ b/onnx/reference/ops/_quant_utils.py
@@ -0,0 +1,56 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+
+def reshape_input(
+    value: np.ndarray,
+    shape: tuple[int, ...],
+    axis: int,
+    block_size: int | None = None,
+) -> np.ndarray:
+    """Reshape/Replicate scale/zero-point to be broadcastable to shape.
+
+    Args:
+        value: the array to be reshaped/replicated
+        shape: the target shape
+        axis: quantization axis, applicable for per-axis and blocked quantization
+        block_size: size of quantization block, applicable only for blocked quantization
+
+    Returns:
+        value array after reshape/replicate according to quantization mode.
+    """
+    if len(value.shape) == 0:
+        return value
+    if len(value.shape) > 0 and value.size == 1:
+        return value[0]
+    if not block_size:
+        assert len(value.shape) == 1
+        dims = [1] * len(shape)
+        try:
+            dims[axis] = value.size
+            return value.reshape(tuple(dims))
+        except IndexError as e:
+            raise IndexError(
+                f"axis is out of boundary, axis={axis}, "
+                f"value.shape={value.shape}, shape={shape}."
+            ) from e
+
+    if block_size <= 0:
+        raise ValueError("block_size must be a positive integer.")
+
+    # repeat scale to get element-wise scale
+    value = np.repeat(value, repeats=block_size, axis=axis)
+    if (
+        shape[axis] != value.shape[axis]
+    ):  # block_size does not divide x, handle the remainder block
+        value = value.take(indices=range(shape[axis]), axis=axis)
+    if value.shape != shape:
+        raise ValueError(
+            "Invalid shapes for Blocked Quantization. Input 2 shape should identical to Input 1 shape, except for one dimension, in which blocking is performed"
+        )
+    assert np.broadcast_shapes(shape, value.shape) == shape
+    return value
diff --git a/onnx/reference/ops/aionnx_preview/__init__.py b/onnx/reference/ops/aionnx_preview/__init__.py
new file mode 100644
index 0000000..64c9d12
--- /dev/null
+++ b/onnx/reference/ops/aionnx_preview/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = ["load_op"]
+
+from onnx.reference.ops.aionnx_preview._op_list import load_op
diff --git a/onnx/reference/ops/aionnx_preview/_op_list.py b/onnx/reference/ops/aionnx_preview/_op_list.py
new file mode 100644
index 0000000..0e1971f
--- /dev/null
+++ b/onnx/reference/ops/aionnx_preview/_op_list.py
@@ -0,0 +1,85 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = [
+    "load_op",
+    "FlexAttention",
+]
+
+import textwrap
+from typing import Any
+
+from onnx.reference.op_run import OpFunction, OpRun
+from onnx.reference.ops._helpers import build_registered_operators_any_domain
+from onnx.reference.ops.aionnx_preview.op_flex_attention import FlexAttention
+
+
+def _build_registered_operators() -> dict[str, dict[int | None, type[OpRun]]]:
+    return build_registered_operators_any_domain(globals().copy())
+
+
+def load_op(
+    domain: str,
+    op_type: str,
+    version: None | int,
+    custom: Any = None,
+) -> Any:
+    """Loads the implemented for a specified operator.
+
+    Args:
+        domain: domain
+        op_type: operator type
+        version: requested version
+        custom: custom implementation (like a function)
+
+    Returns:
+        class
+    """
+    global _registered_operators  # noqa: PLW0603
+    if _registered_operators is None:
+        _registered_operators = _build_registered_operators()
+    if custom is not None:
+        return lambda *args: OpFunction(*args, impl=custom)
+    if domain != "ai.onnx.preview":
+        raise ValueError(f"Domain must be 'ai.onnx.preview' not {domain!r}.")
+    if op_type not in _registered_operators:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        raise NotImplementedError(
+            f"No registered implementation for operator {op_type!r} "
+            f"and domain {domain!r} in\n{available}"
+        )
+    impl = _registered_operators[op_type]
+    if None not in impl:
+        raise RuntimeError(
+            f"No default implementation for operator {op_type!r} "
+            f"and domain {domain!r}, found "
+            f"{', '.join(map(str, impl))}."
+        )
+    if version is None or len(impl) == 1:
+        cl = impl[None]
+    else:
+        best = -1
+        for v in impl:
+            if v is None:
+                continue
+            if best < v <= version:
+                best = v
+        if best == -1:
+            raise RuntimeError(
+                f"No implementation for operator {op_type!r} "
+                f"domain {domain!r} and version {version!r}, found "
+                f"{', '.join(map(str, impl))}."
+            )
+        cl = impl[best]
+    if cl is None:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        raise ValueError(
+            f"Not registered implementation for operator {op_type!r}, "
+            f"domain {domain!r}, and {version!r} in\n{available}"
+        )
+    return cl
+
+
+_registered_operators: dict[str, dict[int | None, type[OpRun]]] | None = None
diff --git a/onnx/reference/ops/aionnx_preview/op_flex_attention.py b/onnx/reference/ops/aionnx_preview/op_flex_attention.py
new file mode 100644
index 0000000..4054e16
--- /dev/null
+++ b/onnx/reference/ops/aionnx_preview/op_flex_attention.py
@@ -0,0 +1,160 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import ml_dtypes
+import numpy as np
+
+from onnx import TensorProto
+from onnx.reference.op_run import OpRun
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+# Mapping from TensorProto data type to numpy dtype for softmax_precision.
+_SOFTMAX_PRECISION_TO_NP_DTYPE: dict[int, np.dtype] = {
+    int(TensorProto.FLOAT): np.dtype("float32"),
+    int(TensorProto.FLOAT16): np.dtype("float16"),
+    int(TensorProto.BFLOAT16): np.dtype(ml_dtypes.bfloat16),
+    int(TensorProto.DOUBLE): np.dtype("float64"),
+}
+
+
+def _call_mod_graph(
+    evaluator: Any,
+    positional_inputs: Sequence[np.ndarray],
+    *,
+    attributes: dict[str, Any] | None = None,
+) -> np.ndarray:
+    input_names = list(evaluator.input_names)
+    if len(input_names) != len(positional_inputs):
+        raise RuntimeError(
+            f"Graph attribute expects {len(input_names)} inputs "
+            f"but got {len(positional_inputs)}."
+        )
+    feeds = dict(zip(input_names, positional_inputs, strict=False))
+    outs = evaluator.run(None, feeds, attributes=attributes)
+    if not isinstance(outs, list) or len(outs) != 1:
+        raise RuntimeError("Graph attribute must produce exactly 1 output.")
+    return outs[0]
+
+
+def _get_softmax_dtype(
+    input_dtype: np.dtype,
+    softmax_precision: int | None = None,
+) -> np.dtype:
+    """Determine the numpy dtype for softmax computation.
+
+    Priority:
+      1. Use explicit softmax_precision if provided.
+      2. Promote float16 to float32 for numerical stability.
+      3. Use input dtype as-is for float32/float64.
+    """
+    if softmax_precision is not None:
+        if softmax_precision not in _SOFTMAX_PRECISION_TO_NP_DTYPE:
+            raise ValueError(
+                f"Unsupported softmax_precision value: {softmax_precision}"
+            )
+        return _SOFTMAX_PRECISION_TO_NP_DTYPE[softmax_precision]
+    if input_dtype in (np.float16, ml_dtypes.bfloat16):
+        return np.dtype("float32")
+    return np.dtype("float32") if input_dtype.itemsize < 4 else input_dtype
+
+
+def _compute_flex_attention(
+    Q: np.ndarray,
+    K: np.ndarray,
+    V: np.ndarray,
+    scale: float | None = None,
+    score_mod: Any = None,
+    prob_mod: Any = None,
+    softmax_precision: int | None = None,
+) -> tuple[np.ndarray,]:
+    if len(Q.shape) != 4 or len(K.shape) != 4 or len(V.shape) != 4:
+        raise RuntimeError(
+            f"FlexAttention requires rank-4 inputs but got "
+            f"Q: {Q.shape!r}, K: {K.shape!r}, V: {V.shape!r}."
+        )
+
+    _B, Hq, _L, E = Q.shape
+
+    # Calculate scaling factor if not provided (default: 1/sqrt(head_size))
+    if scale is None:
+        scale = 1.0 / np.sqrt(E)
+    _Bk, Hkv, S, Ek = K.shape
+    _Bv, _Hkv2, Sv, _Ev = V.shape
+    if Hkv != _Hkv2:
+        raise RuntimeError("Key and value must share the same head dimension.")
+    if Sv != S:
+        raise RuntimeError("Key and value must share the same sequence length.")
+    if Ek != E:
+        raise RuntimeError("Query and key must share the same embedding dimension.")
+
+    # Handle GQA repeat if number of query heads differs from key/value heads.
+    if Hq != Hkv:
+        if Hkv <= 0 or (Hq % Hkv) != 0:
+            raise RuntimeError(
+                "q_num_heads must be a multiple of kv_num_heads when they differ."
+            )
+        repeat = Hq // Hkv
+        K_aligned = np.repeat(K, repeats=repeat, axis=1)
+        V_aligned = np.repeat(V, repeats=repeat, axis=1)
+    else:
+        K_aligned = K
+        V_aligned = V
+
+    # Pre-scale Q and K with sqrt(scale).
+    # Scale factor is computed in float32 then cast to input type.
+    sqrt_scale = np.array(np.sqrt(np.float32(scale)), dtype=Q.dtype)
+    scores = np.matmul(Q * sqrt_scale, np.swapaxes(K_aligned * sqrt_scale, -1, -2))
+
+    # Cast to softmax computation dtype.
+    compute_dtype = _get_softmax_dtype(Q.dtype, softmax_precision)
+    scores = scores.astype(compute_dtype)
+
+    if score_mod is not None:
+        scores_out = _call_mod_graph(score_mod, [scores])
+        scores = np.asarray(scores_out, dtype=compute_dtype)
+
+    # Softmax over kv dimension
+    scores_max = np.max(scores, axis=-1, keepdims=True)
+    exp_scores = np.exp(scores - scores_max)
+    probs = exp_scores / np.sum(exp_scores, axis=-1, keepdims=True)
+
+    if prob_mod is not None:
+        probs_out = _call_mod_graph(prob_mod, [probs])
+        probs = np.asarray(probs_out, dtype=compute_dtype)
+
+    # Final MatMul: Prob @ V in softmax precision, cast back to input type.
+    V_f = V_aligned.astype(compute_dtype)
+    out = np.matmul(probs, V_f)
+
+    return (out.astype(V.dtype),)
+
+
+class FlexAttention(OpRun):
+    op_domain = "ai.onnx.preview"
+
+    def _run(
+        self,
+        Q: np.ndarray,
+        K: np.ndarray,
+        V: np.ndarray,
+        scale: float | None = None,
+        score_mod: Any = None,
+        prob_mod: Any = None,
+        softmax_precision: int | None = None,
+        **_: Any,
+    ) -> tuple[np.ndarray]:
+        return _compute_flex_attention(
+            Q,
+            K,
+            V,
+            scale=scale,
+            score_mod=score_mod,
+            prob_mod=prob_mod,
+            softmax_precision=softmax_precision,
+        )
diff --git a/onnx/reference/ops/aionnx_preview_training/__init__.py b/onnx/reference/ops/aionnx_preview_training/__init__.py
new file mode 100644
index 0000000..8466d34
--- /dev/null
+++ b/onnx/reference/ops/aionnx_preview_training/__init__.py
@@ -0,0 +1,9 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = ["load_op", "OpRunTraining"]
+
+from onnx.reference.ops.aionnx_preview_training._op_list import load_op
+from onnx.reference.ops.aionnx_preview_training._op_run_training import OpRunTraining
diff --git a/onnx/reference/ops/aionnx_preview_training/_op_list.py b/onnx/reference/ops/aionnx_preview_training/_op_list.py
new file mode 100644
index 0000000..8af1af9
--- /dev/null
+++ b/onnx/reference/ops/aionnx_preview_training/_op_list.py
@@ -0,0 +1,89 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = [
+    "load_op",
+    "Adagrad",
+    "Adam",
+    "Momentum",
+]
+
+import textwrap
+from typing import Any
+
+from onnx.reference.op_run import OpFunction, OpRun
+from onnx.reference.ops._helpers import build_registered_operators_any_domain
+from onnx.reference.ops.aionnx_preview_training.op_adagrad import Adagrad
+from onnx.reference.ops.aionnx_preview_training.op_adam import Adam
+from onnx.reference.ops.aionnx_preview_training.op_momentum import Momentum
+
+
+def _build_registered_operators() -> dict[str, dict[int | None, type[OpRun]]]:
+    return build_registered_operators_any_domain(globals().copy())
+
+
+def load_op(
+    domain: str,
+    op_type: str,
+    version: None | int,
+    custom: Any = None,
+) -> Any:
+    """Loads the implemented for a specified operator.
+
+    Args:
+        domain: domain
+        op_type: operator type
+        version: requested version
+        custom: custom implementation (like a function)
+
+    Returns:
+        class
+    """
+    global _registered_operators  # noqa: PLW0603
+    if _registered_operators is None:
+        _registered_operators = _build_registered_operators()
+    if custom is not None:
+        return lambda *args: OpFunction(*args, impl=custom)
+    if domain != "ai.onnx.preview.training":
+        raise ValueError(f"Domain must be '' not {domain!r}.")
+    if op_type not in _registered_operators:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        raise NotImplementedError(
+            f"No registered implementation for operator {op_type!r} "
+            f"and domain {domain!r} in\n{available}"
+        )
+    impl = _registered_operators[op_type]
+    if None not in impl:
+        raise RuntimeError(
+            f"No default implementation for operator {op_type!r} "
+            f"and domain {domain!r}, found "
+            f"{', '.join(map(str, impl))}."
+        )
+    if version is None or len(impl) == 1:
+        cl = impl[None]
+    else:
+        best = -1
+        for v in impl:
+            if v is None:
+                continue
+            if best < v <= version:
+                best = v
+        if best == -1:
+            raise RuntimeError(
+                f"No implementation for operator {op_type!r} "
+                f"domain {domain!r} and version {version!r}, found "
+                f"{', '.join(map(str, impl))}."
+            )
+        cl = impl[best]
+    if cl is None:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        raise ValueError(
+            f"Not registered implementation for operator {op_type!r}, "
+            f"domain {domain!r}, and {version!r} in\n{available}"
+        )
+    return cl
+
+
+_registered_operators: dict[str, dict[int | None, type[OpRun]]] | None = None
diff --git a/onnx/reference/ops/aionnx_preview_training/_op_run_training.py b/onnx/reference/ops/aionnx_preview_training/_op_run_training.py
new file mode 100644
index 0000000..8d99167
--- /dev/null
+++ b/onnx/reference/ops/aionnx_preview_training/_op_run_training.py
@@ -0,0 +1,10 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class OpRunTraining(OpRun):
+    op_domain = "ai.onnx.preview.training"
diff --git a/onnx/reference/ops/aionnx_preview_training/op_adagrad.py b/onnx/reference/ops/aionnx_preview_training/op_adagrad.py
new file mode 100644
index 0000000..4e58b9c
--- /dev/null
+++ b/onnx/reference/ops/aionnx_preview_training/op_adagrad.py
@@ -0,0 +1,64 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnx_preview_training._op_run_training import OpRunTraining
+
+
+def _apply_adagrad(r, t, x, g, h, norm_coefficient, epsilon, decay_factor):
+    # Compute adjusted learning-rate.
+    r_ = r / (1 + t * decay_factor)
+    # Add gradient of regularization term.
+    g_regularized = norm_coefficient * x + g
+    # Update squared accumulated gradient.
+    h_new = h + g_regularized * g_regularized
+    # Compute ADAGRAD's gradient scaling factors
+    h_sqrt = np.sqrt(h_new) + epsilon
+    # Apply ADAGRAD update rule.
+    x_new = x - r_ * g_regularized / h_sqrt
+    return (x_new.astype(x.dtype), h_new.astype(h.dtype))
+
+
+class Adagrad(OpRunTraining):
+    def _run(self, *data, decay_factor=None, epsilon=None, norm_coefficient=None):
+        if len(data) == 5:
+            return self._run1(
+                *data,
+                decay_factor=decay_factor,
+                epsilon=epsilon,
+                norm_coefficient=norm_coefficient,
+            )
+        n = (len(data) - 2) // 3
+        xs = []
+        hs = []
+        for i in range(n):
+            a, b = self._run1(
+                *data[:2],
+                data[2 + i],
+                data[2 + n + i],
+                data[2 + n * 2 + i],
+                decay_factor=decay_factor,
+                epsilon=epsilon,
+                norm_coefficient=norm_coefficient,
+            )
+            xs.append(a)
+            hs.append(b)
+        return tuple(xs + hs)
+
+    def _run1(
+        self, r, t, x, g, h, decay_factor=None, epsilon=None, norm_coefficient=None
+    ):
+        x_new, h_new = _apply_adagrad(
+            r,
+            t,
+            x,
+            g,
+            h,
+            norm_coefficient,
+            epsilon,
+            decay_factor,
+        )
+        return x_new, h_new
diff --git a/onnx/reference/ops/aionnx_preview_training/op_adam.py b/onnx/reference/ops/aionnx_preview_training/op_adam.py
new file mode 100644
index 0000000..9ea949e
--- /dev/null
+++ b/onnx/reference/ops/aionnx_preview_training/op_adam.py
@@ -0,0 +1,105 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnx_preview_training._op_run_training import OpRunTraining
+
+
+def _apply_adam(
+    r, t, x, g, v, h, norm_coefficient, norm_coefficient_post, alpha, beta, epsilon
+):
+    # Add gradient of regularization term.
+    g_regularized = norm_coefficient * x + g
+    # Update momentum.
+    v_new = alpha * v + (1 - alpha) * g_regularized
+    # Update second-order momentum.
+    h_new = beta * h + (1 - beta) * (g_regularized * g_regularized)
+    # Compute element-wise square root.
+    h_sqrt = np.sqrt(h_new) + epsilon
+    # Adjust learning rate.
+    r_adjusted = None
+    if t > 0:
+        # Consider bias correction on momentums.
+        r_adjusted = r * np.sqrt(1 - beta**t) / (1 - alpha**t)
+    else:
+        # No bias correction on momentums.
+        r_adjusted = r
+    # Apply Adam update rule.
+    x_new = x - r_adjusted * (v_new / h_sqrt)
+    # It's possible to apply regularization in the end.
+    x_final = (1 - norm_coefficient_post) * x_new
+    return x_final, v_new, h_new
+
+
+class Adam(OpRunTraining):
+    def _run(
+        self,
+        *data,
+        alpha=None,
+        beta=None,
+        epsilon=None,
+        norm_coefficient=None,
+        norm_coefficient_post=None,
+    ):
+        if len(data) == 6:
+            return self._run1(
+                *data,
+                alpha=alpha,
+                beta=beta,
+                epsilon=epsilon,
+                norm_coefficient=norm_coefficient,
+                norm_coefficient_post=norm_coefficient_post,
+            )
+        n = (len(data) - 2) // 4
+        xs = []
+        vs = []
+        hs = []
+        for i in range(n):
+            a, b, c = self._run1(
+                *data[:2],
+                data[2 + i],
+                data[2 + n + i],
+                data[2 + n * 2 + i],
+                data[2 + n * 3 + i],
+                alpha=alpha,
+                beta=beta,
+                epsilon=epsilon,
+                norm_coefficient=norm_coefficient,
+                norm_coefficient_post=norm_coefficient_post,
+            )
+            xs.append(a.astype(np.float32))
+            vs.append(b.astype(np.float32))
+            hs.append(c.astype(np.float32))
+        return tuple(xs + vs + hs)
+
+    def _run1(
+        self,
+        r,
+        t,
+        x,
+        g,
+        v,
+        h,
+        alpha=None,
+        beta=None,
+        epsilon=None,
+        norm_coefficient=None,
+        norm_coefficient_post=None,
+    ):
+        x_new, v_new, h_new = _apply_adam(
+            r,
+            t,
+            x,
+            g,
+            v,
+            h,
+            norm_coefficient,
+            norm_coefficient_post,
+            alpha,
+            beta,
+            epsilon,
+        )
+        return x_new, v_new, h_new
diff --git a/onnx/reference/ops/aionnx_preview_training/op_momentum.py b/onnx/reference/ops/aionnx_preview_training/op_momentum.py
new file mode 100644
index 0000000..e9289e0
--- /dev/null
+++ b/onnx/reference/ops/aionnx_preview_training/op_momentum.py
@@ -0,0 +1,82 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops.aionnx_preview_training._op_run_training import OpRunTraining
+
+
+def _apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta):
+    # Add gradient of regularization term.
+    g_regularized = norm_coefficient * x + g
+    # Coefficient of gradient should be 1 at the first iteration.
+    beta_adjusted = beta if t > 0 else 1
+    # Update momentum.
+    v_new = alpha * v + beta_adjusted * g_regularized
+    # Apply SG with momentum update rule.
+    x_new = x - r * v_new
+    return x_new, v_new
+
+
+def _apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta):
+    # Add gradient of regularization term.
+    g_regularized = norm_coefficient * x + g
+    # Coefficient of gradient should be 1 at the first iteration.
+    beta_adjusted = beta if t > 0 else 1
+    # Update momentum.
+    v_new = alpha * v + beta_adjusted * g_regularized
+    # Apply Nesterov with momentum update rule.
+    x_new = x - r * (g_regularized + alpha * v_new)
+    return x_new, v_new
+
+
+class Momentum(OpRunTraining):
+    def _run(self, *data, alpha=None, beta=None, mode=None, norm_coefficient=None):
+        if len(data) == 5:
+            r, t, x, g, v = data
+            return self._run1(
+                r,
+                t,
+                x,
+                g,
+                v,
+                norm_coefficient=norm_coefficient,
+                alpha=alpha,
+                beta=beta,
+                mode=mode,
+            )
+        n = (len(data) - 2) // 3
+        xs = []
+        vs = []
+        for i in range(n):
+            a, b = self._run1(
+                *data[:2],
+                data[2 + i],
+                data[2 + n + i],
+                data[2 + n * 2 + i],
+                norm_coefficient=norm_coefficient,
+                alpha=alpha,
+                beta=beta,
+                mode=mode,
+            )
+            xs.append(a)
+            vs.append(b)
+        return tuple(xs + vs)
+
+    def _run1(
+        self,
+        r,
+        t,
+        x,
+        g,
+        v,
+        mode="standard",
+        norm_coefficient=None,
+        alpha=None,
+        beta=None,
+    ):
+        if mode == "standard":
+            x_new, v_new = _apply_momentum(r, t, x, g, v, norm_coefficient, alpha, beta)
+        else:
+            x_new, v_new = _apply_nesterov(r, t, x, g, v, norm_coefficient, alpha, beta)
+        return x_new, v_new
diff --git a/onnx/reference/ops/aionnxml/__init__.py b/onnx/reference/ops/aionnxml/__init__.py
new file mode 100644
index 0000000..c36a434
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/__init__.py
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = ["load_op"]
+
+from onnx.reference.ops.aionnxml._op_list import load_op
diff --git a/onnx/reference/ops/aionnxml/_common_classifier.py b/onnx/reference/ops/aionnxml/_common_classifier.py
new file mode 100644
index 0000000..03b5661
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/_common_classifier.py
@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+
+def compute_logistic(val: float) -> float:
+    v = 1.0 / (1.0 + np.exp(-np.abs(val)))
+    return (1.0 - v) if val < 0 else v
+
+
+logistic = np.vectorize(compute_logistic)
+
+
+def compute_softmax_zero(values: np.ndarray) -> np.ndarray:
+    """The function modifies the input inplace."""
+    v_max = values.max()
+    exp_neg_v_max = np.exp(-v_max)
+    s = 0
+    for i, v in enumerate(values):
+        if v > 0.0000001 or v < -0.0000001:
+            values[i] = np.exp(v - v_max)
+        else:
+            values[i] *= exp_neg_v_max
+        s += values[i]
+    if s == 0:
+        values[:] = 0.5
+    else:
+        values[:] /= s
+    return values
+
+
+def softmax_zero(values: np.ndarray) -> np.ndarray:
+    """Modifications in place."""
+    if len(values.shape) == 1:
+        compute_softmax_zero(values)
+        return values
+    for row in values:
+        compute_softmax_zero(row)
+    return values
+
+
+def softmax(values: np.ndarray) -> np.ndarray:
+    """Modifications in place."""
+    if len(values.shape) == 2:
+        v_max = values.max(axis=1, keepdims=1)
+        values -= v_max
+        np.exp(values, out=values)
+        s = values.sum(axis=1, keepdims=1)
+        values /= s
+        return values
+    v_max = values.max()
+    values[:] = np.exp(values - v_max)
+    this_sum = values.sum()
+    values /= this_sum
+    return values
+
+
+def erf_inv(x: float) -> float:
+    sgn = -1.0 if x < 0 else 1.0
+    x = (1.0 - x) * (1 + x)
+    if x == 0:
+        return 0
+    log = np.log(x)
+    v = 2.0 / (np.pi * 0.147) + 0.5 * log
+    v2 = 1.0 / 0.147 * log
+    v3 = -v + np.sqrt(v * v - v2)
+    return sgn * np.sqrt(v3)
+
+
+def compute_probit(val: float) -> float:
+    return 1.41421356 * erf_inv(val * 2 - 1)
+
+
+probit = np.vectorize(compute_probit)
+
+
+def expit(x: np.ndarray) -> np.ndarray:
+    return (1.0 / (1.0 + np.exp(-x))).astype(x.dtype)
diff --git a/onnx/reference/ops/aionnxml/_op_list.py b/onnx/reference/ops/aionnxml/_op_list.py
new file mode 100644
index 0000000..fe15c28
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/_op_list.py
@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Operator ZipMap is not implemented. Its use should
+# be discouraged. It is just a different way to output
+# probabilities not consumed by any operator.
+from __future__ import annotations
+
+__all__ = [
+    "load_op",
+    "ArrayFeatureExtractor",
+    "Binarizer",
+    "DictVectorizer",
+    "FeatureVectorizer",
+    "Imputer",
+    "LabelEncoder",
+    "LinearClassifier",
+    "LinearRegressor",
+    "Normalizer",
+    "OneHotEncoder",
+    "Scaler",
+    "SVMClassifier",
+    "SVMRegressor",
+    "TreeEnsemble",
+    "TreeEnsembleClassifier",
+    "TreeEnsembleRegressor",
+    "OpRunAiOnnxMl",
+]
+
+import textwrap
+from typing import Any
+
+from onnx.reference.op_run import OpFunction, OpRun
+from onnx.reference.ops._helpers import build_registered_operators_any_domain
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+from onnx.reference.ops.aionnxml.op_array_feature_extractor import ArrayFeatureExtractor
+from onnx.reference.ops.aionnxml.op_binarizer import Binarizer
+from onnx.reference.ops.aionnxml.op_dict_vectorizer import DictVectorizer
+from onnx.reference.ops.aionnxml.op_feature_vectorizer import FeatureVectorizer
+from onnx.reference.ops.aionnxml.op_imputer import Imputer
+from onnx.reference.ops.aionnxml.op_label_encoder import LabelEncoder
+from onnx.reference.ops.aionnxml.op_linear_classifier import LinearClassifier
+from onnx.reference.ops.aionnxml.op_linear_regressor import LinearRegressor
+from onnx.reference.ops.aionnxml.op_normalizer import Normalizer
+from onnx.reference.ops.aionnxml.op_one_hot_encoder import OneHotEncoder
+from onnx.reference.ops.aionnxml.op_scaler import Scaler
+from onnx.reference.ops.aionnxml.op_svm_classifier import SVMClassifier
+from onnx.reference.ops.aionnxml.op_svm_regressor import SVMRegressor
+from onnx.reference.ops.aionnxml.op_tree_ensemble import TreeEnsemble
+from onnx.reference.ops.aionnxml.op_tree_ensemble_classifier import (
+    TreeEnsembleClassifier,
+)
+from onnx.reference.ops.aionnxml.op_tree_ensemble_regressor import TreeEnsembleRegressor
+
+
+def _build_registered_operators() -> dict[str, dict[int | None, type[OpRun]]]:
+    return build_registered_operators_any_domain(globals().copy())
+
+
+def load_op(
+    domain: str,
+    op_type: str,
+    version: None | int,
+    custom: Any = None,
+) -> Any:
+    """Loads the implemented for a specified operator.
+
+    Args:
+        domain: domain
+        op_type: operator type
+        version: requested version
+        custom: custom implementation (like a function)
+
+    Returns:
+        class
+    """
+    global _registered_operators  # noqa: PLW0603
+    if _registered_operators is None:
+        _registered_operators = _build_registered_operators()
+    if custom is not None:
+        return lambda *args: OpFunction(*args, impl=custom)
+    if domain != "ai.onnx.ml":
+        raise ValueError(f"Domain must be '' not {domain!r}.")
+    if op_type not in _registered_operators:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        raise NotImplementedError(
+            f"No registered implementation for operator {op_type!r} "
+            f"and domain {domain!r} in\n{available}"
+        )
+    impl = _registered_operators[op_type]
+    if None not in impl:
+        raise RuntimeError(
+            f"No default implementation for operator {op_type!r} "
+            f"and domain {domain!r}, found "
+            f"{', '.join(map(str, impl))}."
+        )
+    if version is None or len(impl) == 1:
+        cl = impl[None]
+    else:
+        best = -1
+        for v in impl:
+            if v is None:
+                continue
+            if best < v <= version:
+                best = v
+        if best == -1:
+            raise RuntimeError(
+                f"No implementation for operator {op_type!r} "
+                f"domain {domain!r} and version {version!r}, found "
+                f"{', '.join(map(str, impl))}."
+            )
+        cl = impl[best]
+    if cl is None:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        raise ValueError(
+            f"Not registered implementation for operator {op_type!r}, "
+            f"domain {domain!r}, and {version!r} in\n{available}"
+        )
+    return cl
+
+
+_registered_operators: dict[str, dict[int | None, type[OpRun]]] | None = None
diff --git a/onnx/reference/ops/aionnxml/_op_run_aionnxml.py b/onnx/reference/ops/aionnxml/_op_run_aionnxml.py
new file mode 100644
index 0000000..d440135
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/_op_run_aionnxml.py
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class OpRunAiOnnxMl(OpRun):
+    op_domain = "ai.onnx.ml"
diff --git a/onnx/reference/ops/aionnxml/op_array_feature_extractor.py b/onnx/reference/ops/aionnxml/op_array_feature_extractor.py
new file mode 100644
index 0000000..b1d4378
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_array_feature_extractor.py
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+def _array_feature_extractor(data, indices):
+    """Implementation of operator *ArrayFeatureExtractor*."""
+    if len(indices.shape) == 2 and indices.shape[0] == 1:
+        index = indices.ravel().tolist()
+        add = len(index)
+    elif len(indices.shape) == 1:
+        index = indices.tolist()
+        add = len(index)
+    else:
+        add = 1
+        for s in indices.shape:
+            add *= s
+        index = indices.ravel().tolist()
+    if len(data.shape) == 1:
+        new_shape = (1, add)
+    else:
+        new_shape = [*data.shape[:-1], add]
+    try:
+        tem = data[..., index]
+    except IndexError as e:
+        raise RuntimeError(f"data.shape={data.shape}, indices={indices}") from e
+    return tem.reshape(new_shape)
+
+
+class ArrayFeatureExtractor(OpRunAiOnnxMl):
+    def _run(self, data, indices):
+        """Runtime for operator *ArrayFeatureExtractor*.
+
+        Warning:
+            ONNX specifications may be imprecise in some cases.
+            When the input data is a vector (one dimension),
+            the output has still two like a matrix with one row.
+            The implementation follows what onnxruntime does in
+            `array_feature_extractor.cc
+            <https://github.com/microsoft/onnxruntime/blob/main/
+            onnxruntime/core/providers/cpu/ml/array_feature_extractor.cc#L84>`_.
+        """
+        res = _array_feature_extractor(data, indices)
+        return (res,)
diff --git a/onnx/reference/ops/aionnxml/op_binarizer.py b/onnx/reference/ops/aionnxml/op_binarizer.py
new file mode 100644
index 0000000..861769c
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_binarizer.py
@@ -0,0 +1,15 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+def compute_binarizer(x, threshold=None):
+    return ((x > threshold).astype(x.dtype),)
+
+
+class Binarizer(OpRunAiOnnxMl):
+    def _run(self, x, threshold=None):
+        return compute_binarizer(x, threshold)
diff --git a/onnx/reference/ops/aionnxml/op_dict_vectorizer.py b/onnx/reference/ops/aionnxml/op_dict_vectorizer.py
new file mode 100644
index 0000000..72a6ea4
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_dict_vectorizer.py
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class DictVectorizer(OpRunAiOnnxMl):
+    def _run(self, x, int64_vocabulary=None, string_vocabulary=None):
+        if isinstance(x, (np.ndarray, list)):
+            if int64_vocabulary is None and string_vocabulary is None:
+                raise ValueError(
+                    "int64_vocabulary or string_vocabulary must be provided."
+                )
+            if int64_vocabulary is not None:
+                dict_labels = {v: i for i, v in enumerate(int64_vocabulary)}
+            else:
+                assert string_vocabulary is not None
+                dict_labels = {v: i for i, v in enumerate(string_vocabulary)}
+
+            values_list = []
+            rows_list = []
+            cols_list = []
+            for i, row in enumerate(x):
+                for k, v in row.items():
+                    values_list.append(v)
+                    rows_list.append(i)
+                    cols_list.append(dict_labels[k])
+            values = np.array(values_list)
+            rows = np.array(rows_list)
+            cols = np.array(cols_list)
+
+            res = np.zeros((len(x), len(dict_labels)), dtype=values.dtype)
+            for r, c, v in zip(rows, cols, values, strict=False):
+                res[r, c] = v
+            return (res,)
+
+        if isinstance(x, dict):
+            keys = int64_vocabulary or string_vocabulary
+            assert keys is not None
+            result = [x.get(k, 0) for k in keys]
+            return (np.array(result),)
+
+        raise TypeError(f"x must be iterable not {type(x)}.")
diff --git a/onnx/reference/ops/aionnxml/op_feature_vectorizer.py b/onnx/reference/ops/aionnxml/op_feature_vectorizer.py
new file mode 100644
index 0000000..fdbff53
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_feature_vectorizer.py
@@ -0,0 +1,31 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class FeatureVectorizer(OpRunAiOnnxMl):
+    def _preprocess(self, a, cut):
+        if len(a.shape) == 1:
+            a = a.reshape((-1, 1))
+        if len(a.shape) != 2:
+            raise ValueError(f"Every input must have 1 or 2 dimensions not {a.shape}.")
+        if cut < a.shape[1]:
+            return a[:, :cut]
+        if cut > a.shape[1]:
+            b = np.zeros((a.shape[0], cut), dtype=a.dtype)
+            b[:, : a.shape[1]] = a
+            return b
+        return a
+
+    def _run(self, *args, inputdimensions=None):
+        args = [
+            self._preprocess(a, axis)
+            for a, axis in zip(args, inputdimensions, strict=False)
+        ]
+        res = np.concatenate(args, axis=1)
+        return (res,)
diff --git a/onnx/reference/ops/aionnxml/op_imputer.py b/onnx/reference/ops/aionnxml/op_imputer.py
new file mode 100644
index 0000000..231d131
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_imputer.py
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class Imputer(OpRunAiOnnxMl):
+    def _run(
+        self,
+        x,
+        imputed_value_floats=None,
+        imputed_value_int64s=None,
+        replaced_value_float=None,
+        replaced_value_int64=None,
+    ):
+        if imputed_value_floats is not None and len(imputed_value_floats) > 0:
+            values = imputed_value_floats
+            replace = replaced_value_float
+        elif imputed_value_int64s is not None and len(imputed_value_int64s) > 0:
+            values = imputed_value_int64s
+            replace = replaced_value_int64
+        else:
+            raise ValueError("Missing are not defined.")
+
+        if isinstance(values, list):
+            values = np.array(values)
+        if len(x.shape) != 2:
+            raise TypeError(f"x must be a matrix but shape is {x.shape}")
+        if values.shape[0] not in (x.shape[1], 1):
+            raise TypeError(  # pragma: no cover
+                f"Dimension mismatch {values.shape[0]} != {x.shape[1]}"
+            )
+        x = x.copy()
+        if np.isnan(replace):
+            for i in range(x.shape[1]):
+                val = values[min(i, values.shape[0] - 1)]
+                x[np.isnan(x[:, i]), i] = val
+        else:
+            for i in range(x.shape[1]):
+                val = values[min(i, values.shape[0] - 1)]
+                x[x[:, i] == replace, i] = val
+
+        return (x,)
diff --git a/onnx/reference/ops/aionnxml/op_label_encoder.py b/onnx/reference/ops/aionnxml/op_label_encoder.py
new file mode 100644
index 0000000..de6a7dc
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_label_encoder.py
@@ -0,0 +1,50 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class LabelEncoder(OpRunAiOnnxMl):
+    def _run(
+        self,
+        x,
+        default_float=None,
+        default_int64=None,
+        default_string=None,
+        default_tensor=None,
+        keys_floats=None,
+        keys_int64s=None,
+        keys_strings=None,
+        values_floats=None,
+        values_int64s=None,
+        values_strings=None,
+        keys_tensor=None,
+        values_tensor=None,
+    ):
+        keys = keys_floats or keys_int64s or keys_strings or keys_tensor
+        values = values_floats or values_int64s or values_strings or values_tensor
+        classes = dict(zip(keys, values, strict=False))
+
+        if values is values_tensor:
+            defval = default_tensor.item()
+            otype = default_tensor.dtype
+        elif values is values_floats:
+            defval = default_float
+            otype = np.float32
+        elif values is values_int64s:
+            defval = default_int64
+            otype = np.int64
+        elif values is values_strings:
+            defval = default_string
+            otype = np.str_
+            if not isinstance(defval, str):
+                defval = ""
+        lookup_func = np.vectorize(lambda x: classes.get(x, defval), otypes=[otype])
+        output = lookup_func(x)
+        if output.dtype == object:
+            output = output.astype(np.str_)
+        return (output,)
diff --git a/onnx/reference/ops/aionnxml/op_linear_classifier.py b/onnx/reference/ops/aionnxml/op_linear_classifier.py
new file mode 100644
index 0000000..ebe32ba
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_linear_classifier.py
@@ -0,0 +1,98 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._common_classifier import (
+    compute_probit,
+    compute_softmax_zero,
+    expit,
+)
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class LinearClassifier(OpRunAiOnnxMl):
+    @staticmethod
+    def _post_process_predicted_label(label, scores, classlabels_ints_string):
+        """Replaces int64 predicted labels by the corresponding
+        strings.
+        """
+        if classlabels_ints_string is not None:
+            label = np.array([classlabels_ints_string[i] for i in label])
+        return label, scores
+
+    def _run(
+        self,
+        x,
+        classlabels_ints=None,
+        classlabels_strings=None,
+        coefficients=None,
+        intercepts=None,
+        multi_class=None,  # noqa: ARG002
+        post_transform=None,
+    ):
+        # multi_class is unused
+        dtype = x.dtype
+        if dtype != np.float64:
+            x = x.astype(np.float32)
+        coefficients = np.array(coefficients).astype(x.dtype)
+        intercepts = np.array(intercepts).astype(x.dtype)
+        coefficients = coefficients.reshape((-1, x.shape[1])).T
+        scores = np.dot(x, coefficients)
+        if intercepts is not None:
+            scores += intercepts
+
+        n_classes = max(len(classlabels_ints or []), len(classlabels_strings or []))
+        if coefficients.shape[1] == 1 and n_classes == 2:
+            new_scores = np.empty((scores.shape[0], 2), dtype=np.float32)
+            new_scores[:, 0] = -scores[:, 0]
+            new_scores[:, 1] = scores[:, 0]
+            scores = new_scores
+
+        if post_transform == "NONE":
+            pass
+        elif post_transform == "LOGISTIC":
+            scores = expit(scores)
+        elif post_transform == "SOFTMAX":
+            np.subtract(
+                scores,
+                scores.max(axis=1, keepdims=1),
+                out=scores,
+            )
+            scores = np.exp(scores)
+            scores = np.divide(scores, scores.sum(axis=1, keepdims=1))
+        elif post_transform == "SOFTMAX_ZERO":
+            for i in range(scores.shape[0]):
+                scores[i, :] = compute_softmax_zero(scores[i, :])
+        elif post_transform == "PROBIT":
+            for i in range(scores.shape[0]):
+                for j in range(scores.shape[1]):
+                    scores[i, j] = compute_probit(scores[i, j])
+        else:
+            raise NotImplementedError("Unknown post_transform: '{post_transform}'.")
+
+        if scores.shape[1] > 1:
+            labels = np.argmax(scores, axis=1)
+            if classlabels_ints is not None:
+                labels = np.array([classlabels_ints[i] for i in labels], dtype=np.int64)
+            elif classlabels_strings is not None:
+                labels = np.array([classlabels_strings[i] for i in labels])
+        else:
+            threshold = 0 if post_transform == "NONE" else 0.5
+            if classlabels_ints is not None:
+                labels = (
+                    np.where(scores >= threshold, classlabels_ints[0], 0)
+                    .astype(np.int64)
+                    .ravel()
+                )
+            elif classlabels_strings is not None:
+                labels = (
+                    np.where(scores >= threshold, classlabels_strings[0], "")
+                    .astype(np.int64)
+                    .ravel()
+                )
+            else:
+                labels = (scores >= threshold).astype(np.int64).ravel()
+        return (labels, scores)
diff --git a/onnx/reference/ops/aionnxml/op_linear_regressor.py b/onnx/reference/ops/aionnxml/op_linear_regressor.py
new file mode 100644
index 0000000..73b3ecf
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_linear_regressor.py
@@ -0,0 +1,26 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class LinearRegressor(OpRunAiOnnxMl):
+    def _run(
+        self, x, coefficients=None, intercepts=None, targets=1, post_transform=None
+    ):
+        coefficients = np.array(coefficients).astype(x.dtype)
+        intercepts = np.array(intercepts).astype(x.dtype)
+        n = coefficients.shape[0] // targets
+        coefficients = coefficients.reshape(targets, n).T
+        score = np.dot(x, coefficients)
+        if intercepts is not None:
+            score += intercepts
+        if post_transform == "NONE":
+            return (score,)
+        raise NotImplementedError(
+            f"post_transform: {post_transform!r} is not implemented."
+        )
diff --git a/onnx/reference/ops/aionnxml/op_normalizer.py b/onnx/reference/ops/aionnxml/op_normalizer.py
new file mode 100644
index 0000000..35c1dda
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_normalizer.py
@@ -0,0 +1,41 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class Normalizer(OpRunAiOnnxMl):
+    @staticmethod
+    def norm_max(x):
+        """Max normalization"""
+        div = np.abs(x).max(axis=1).reshape((x.shape[0], -1))
+        return x / np.maximum(div, 1e-30)
+
+    @staticmethod
+    def norm_l1(x):
+        """L1 normalization"""
+        div = np.abs(x).sum(axis=1).reshape((x.shape[0], -1))
+        return x / np.maximum(div, 1e-30)
+
+    @staticmethod
+    def norm_l2(x):
+        """L2 normalization"""
+        xn = np.square(x).sum(axis=1)
+        np.sqrt(xn, out=xn)
+        norm = np.maximum(xn.reshape((x.shape[0], -1)), 1e-30)
+        return x / norm
+
+    def _run(self, x, norm=None):
+        if norm == "MAX":
+            _norm = Normalizer.norm_max
+        elif norm == "L1":
+            _norm = Normalizer.norm_l1
+        elif norm == "L2":
+            _norm = Normalizer.norm_l2
+        else:
+            raise ValueError(f"Unexpected value for norm='{norm}'.")
+        return (_norm(x),)
diff --git a/onnx/reference/ops/aionnxml/op_one_hot_encoder.py b/onnx/reference/ops/aionnxml/op_one_hot_encoder.py
new file mode 100644
index 0000000..3b6ea51
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_one_hot_encoder.py
@@ -0,0 +1,53 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class OneHotEncoder(OpRunAiOnnxMl):
+    def _run(self, x, cats_int64s=None, cats_strings=None, zeros=None):
+        if cats_int64s is not None and len(cats_int64s) > 0:
+            classes = {v: i for i, v in enumerate(cats_int64s)}
+        elif len(cats_strings) > 0:
+            classes = {v: i for i, v in enumerate(cats_strings)}
+        else:
+            raise RuntimeError("No encoding was defined.")
+
+        shape = x.shape
+        new_shape = (*shape, len(classes))
+        res = np.zeros(new_shape, dtype=np.float32)
+        if len(x.shape) == 1:
+            for i, v in enumerate(x):
+                j = classes.get(v, -1)
+                if j >= 0:
+                    res[i, j] = 1.0
+        elif len(x.shape) == 2:
+            for a, row in enumerate(x):
+                for i, v in enumerate(row):
+                    j = classes.get(v, -1)
+                    if j >= 0:
+                        res[a, i, j] = 1.0
+        else:
+            raise RuntimeError(f"This operator is not implemented shape {x.shape}.")
+
+        if not zeros:
+            red = res.sum(axis=len(res.shape) - 1)
+            if np.min(red) == 0:
+                rows = []
+                for i, val in enumerate(red):
+                    if val == 0:
+                        rows.append({"row": i, "value": x[i]})
+                        if len(rows) > 5:
+                            break
+                msg = "\n".join(str(_) for _ in rows)
+                raise RuntimeError(
+                    f"One observation did not have any defined category.\n"
+                    f"classes: {classes}\nfirst rows:\n"
+                    f"{msg}\nres:\n{res[:5]}\nx:\n{x[:5]}"
+                )
+
+        return (res,)
diff --git a/onnx/reference/ops/aionnxml/op_scaler.py b/onnx/reference/ops/aionnxml/op_scaler.py
new file mode 100644
index 0000000..e674892
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_scaler.py
@@ -0,0 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+
+class Scaler(OpRunAiOnnxMl):
+    def _run(self, x, offset=None, scale=None):
+        dx = x - offset
+        return ((dx * scale).astype(x.dtype),)
diff --git a/onnx/reference/ops/aionnxml/op_svm_classifier.py b/onnx/reference/ops/aionnxml/op_svm_classifier.py
new file mode 100644
index 0000000..3590a7f
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_svm_classifier.py
@@ -0,0 +1,333 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._common_classifier import (
+    compute_logistic,
+    compute_probit,
+    compute_softmax_zero,
+    logistic,
+    softmax,
+    softmax_zero,
+)
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+from onnx.reference.ops.aionnxml.op_svm_helper import SVMCommon
+
+
+def multiclass_probability(k, R):
+    max_iter = max(100, k)
+    Q = np.empty((k, k), dtype=R.dtype)
+    Qp = np.empty((k,), dtype=R.dtype)
+    P = np.empty((k,), dtype=R.dtype)
+    eps = 0.005 / k
+
+    for t in range(k):
+        P[t] = 1.0 / k
+        Q[t, t] = (R[:t, t] ** 2).sum()
+        Q[t, :t] = Q[:t, t]
+
+        Q[t, t] += (R[t + 1 :, t] ** 2).sum()
+        Q[t, t + 1 :] = -R[t + 1 :, t] @ R[t, t + 1 :]
+
+    for _ in range(max_iter):
+        # stopping condition, recalculate QP,pQP for numerical accuracy
+        Qp[:] = Q @ P
+        pQp = (P * Qp).sum()
+
+        max_error = 0
+        for t in range(k):
+            error = np.abs(Qp[t] - pQp)
+            max_error = max(error, max_error)
+        if max_error < eps:
+            break
+
+        for t in range(k):
+            diff = (-Qp[t] + pQp) / Q[t, t]
+            P[t] += diff
+            pQp = (pQp + diff * (diff * Q[t, t] + 2 * Qp[t])) / (1 + diff) ** 2
+            P /= 1 + diff
+            Qp[:] = (Qp + diff * Q[t, :]) / (1 + diff)
+
+    return P
+
+
+def sigmoid_probability(score, proba, probb):
+    # ref: https://github.com/arnaudsj/libsvm/blob/eaaefac5ebd32d0e07902e1ae740e038eaaf0826/svm.cpp#L1818
+    val = score * proba + probb
+    return 1 - compute_logistic(val)
+
+
+def write_scores(n_classes, scores, post_transform, add_second_class):  # noqa: PLR0911
+    if n_classes >= 2:
+        if post_transform == "PROBIT":
+            res = [compute_probit(score) for score in scores]
+            return np.array(res, dtype=scores.dtype)
+        if post_transform == "LOGISTIC":
+            return logistic(scores)
+        if post_transform == "SOFTMAX":
+            return softmax(scores)
+        if post_transform == "SOFTMAX_ZERO":
+            return compute_softmax_zero(scores)
+        return scores
+    if n_classes == 1:
+        if post_transform == "PROBIT":
+            return np.array([compute_probit(scores[0])], dtype=scores.dtype)
+        if add_second_class in (0, 1):
+            return np.array([1 - scores[0], scores[0]], dtype=scores.dtype)
+        if add_second_class in (2, 3):
+            if post_transform == "LOGISTIC":
+                return np.array(
+                    [logistic(-scores[0]), logistic(scores[0])], dtype=scores.dtype
+                )
+            if post_transform == "SOFTMAX":
+                return softmax(np.array([-scores[0], scores[0]], dtype=scores.dtype))
+            if post_transform == "SOFTMAX_ZERO":
+                return softmax_zero(
+                    np.array([-scores[0], scores[0]], dtype=scores.dtype)
+                )
+            if post_transform == "PROBIT":
+                raise RuntimeError(
+                    f"post_transform={post_transform!r} not applicable here."
+                )
+            return np.array([-scores[0], scores[0]], dtype=scores.dtype)
+        return np.array([scores[0]], dtype=scores.dtype)
+    raise NotImplementedError(f"n_classes={n_classes} not supported.")
+
+
+def set_score_svm(
+    max_weight,
+    maxclass,
+    has_proba,
+    weights_are_all_positive_,
+    classlabels,
+    posclass,
+    negclass,
+):
+    write_additional_scores = -1
+    if len(classlabels) == 2:
+        write_additional_scores = 2
+        if not has_proba:
+            if weights_are_all_positive_ and max_weight >= 0.5:
+                return classlabels[1], write_additional_scores
+            if max_weight > 0 and not weights_are_all_positive_:
+                return classlabels[maxclass], write_additional_scores
+        return classlabels[maxclass], write_additional_scores
+    if max_weight > 0:
+        return posclass, write_additional_scores
+    return negclass, write_additional_scores
+
+
+class SVMClassifier(OpRunAiOnnxMl):
+    def _run_linear(self, X, coefs, class_count_, kernel_type_):
+        scores = []
+        for j in range(class_count_):
+            d = self._svm.kernel_dot(X, coefs[j], kernel_type_)
+            score = self._svm.atts.rho[0] + d
+            scores.append(score)
+        return np.array(scores, dtype=X.dtype)
+
+    def _run_svm(
+        self, X, sv, vector_count_, kernel_type_, class_count_, starting_vector_, coefs
+    ):
+        evals = 0
+
+        kernels_list = [
+            self._svm.kernel_dot(X, sv[j], kernel_type_) for j in range(vector_count_)
+        ]
+        kernels = np.array(kernels_list)
+
+        votes = np.zeros((class_count_,), dtype=X.dtype)
+        scores = []
+        for i in range(class_count_):
+            si_i = starting_vector_[i]
+            class_i_sc = self._svm.atts.vectors_per_class[i]
+
+            for j in range(i + 1, class_count_):
+                si_j = starting_vector_[j]
+                class_j_sc = self._svm.atts.vectors_per_class[j]
+
+                s1 = np.dot(
+                    coefs[j - 1, si_i : si_i + class_i_sc],
+                    kernels[si_i : si_i + class_i_sc],
+                )
+                s2 = np.dot(
+                    coefs[i, si_j : si_j + class_j_sc],
+                    kernels[si_j : si_j + class_j_sc],
+                )
+
+                s = self._svm.atts.rho[evals] + s1 + s2
+                scores.append(s)
+                if s > 0:
+                    votes[i] += 1
+                else:
+                    votes[j] += 1
+                evals += 1
+        return votes, np.array(scores, dtype=X.dtype)
+
+    def _probabilities(self, scores, class_count_):
+        probsp2 = np.zeros((class_count_, class_count_), dtype=scores.dtype)
+
+        index = 0
+        for i in range(class_count_):
+            for j in range(i + 1, class_count_):
+                val1 = sigmoid_probability(
+                    scores[index],
+                    self._svm.atts.prob_a[index],
+                    self._svm.atts.prob_b[index],
+                )
+                val2 = max(val1, 1.0e-7)
+                val2 = min(val2, (1 - 1.0e-7))
+                probsp2[i, j] = val2
+                probsp2[j, i] = 1 - val2
+                index += 1
+        return multiclass_probability(class_count_, probsp2)
+
+    def _compute_final_scores(
+        self, votes, scores, weights_are_all_positive_, has_proba, classlabels_ints
+    ):
+        max_weight = 0
+        if votes is not None and len(votes) > 0:
+            max_class = np.argmax(votes)
+            max_weight = votes[max_class]
+        else:
+            max_class = np.argmax(scores)
+            max_weight = scores[max_class]
+
+        write_additional_scores = -1
+        if self._svm.atts.rho.size == 1:
+            label, write_additional_scores = set_score_svm(
+                max_weight,
+                max_class,
+                has_proba,
+                weights_are_all_positive_,
+                classlabels_ints,
+                1,
+                0,
+            )
+        elif classlabels_ints is not None and len(classlabels_ints) > 0:
+            label = classlabels_ints[max_class]
+        else:
+            label = max_class
+
+        new_scores = write_scores(
+            scores.size,
+            scores,
+            self._svm.atts.post_transform,
+            write_additional_scores,
+        )
+        return label, new_scores
+
+    def _run(
+        self,
+        X,
+        classlabels_ints=None,
+        classlabels_strings=None,
+        coefficients=None,
+        kernel_params=None,
+        kernel_type=None,
+        post_transform=None,
+        prob_a=None,
+        prob_b=None,
+        rho=None,
+        support_vectors=None,
+        vectors_per_class=None,
+    ):
+        svm = SVMCommon(
+            coefficients=coefficients,
+            kernel_params=kernel_params,
+            kernel_type=kernel_type,
+            post_transform=post_transform,
+            prob_a=prob_a,
+            prob_b=prob_b,
+            rho=rho,
+            support_vectors=support_vectors,
+            vectors_per_class=vectors_per_class,
+        )
+        # unused unless for debugging purposes
+        self._svm = svm
+
+        vector_count_ = 0
+        class_count_ = max(len(classlabels_ints or classlabels_strings or []), 1)
+        starting_vector_ = []
+        if svm.atts.vectors_per_class is not None:
+            for vc in svm.atts.vectors_per_class:
+                starting_vector_.append(vector_count_)
+                vector_count_ += vc
+
+        if vector_count_ > 0:
+            # length of each support vector
+            mode = "SVM_SVC"
+            sv = svm.atts.support_vectors.reshape((vector_count_, -1))
+            kernel_type_ = svm.atts.kernel_type
+            coefs = svm.atts.coefficients.reshape((-1, vector_count_))
+        else:
+            # liblinear mode
+            mode = "SVM_LINEAR"
+            kernel_type_ = "LINEAR"
+            coefs = svm.atts.coefficients.reshape((class_count_, -1))
+
+        weights_are_all_positive_ = min(svm.atts.coefficients) >= 0
+
+        # SVM part
+        if vector_count_ == 0 and mode == "SVM_LINEAR":
+            res = np.empty((X.shape[0], class_count_), dtype=X.dtype)
+            for n in range(X.shape[0]):
+                scores = self._run_linear(X[n], coefs, class_count_, kernel_type_)
+                res[n, :] = scores
+            votes = None
+        else:
+            res = np.empty(
+                (X.shape[0], class_count_ * (class_count_ - 1) // 2), dtype=X.dtype
+            )
+            votes = np.empty((X.shape[0], class_count_), dtype=X.dtype)
+            for n in range(X.shape[0]):
+                vote, scores = self._run_svm(
+                    X[n],
+                    sv,
+                    vector_count_,
+                    kernel_type_,
+                    class_count_,
+                    starting_vector_,
+                    coefs,
+                )
+                res[n, :] = scores
+                votes[n, :] = vote
+
+        # proba
+        if (
+            svm.atts.prob_a is not None
+            and len(svm.atts.prob_a) > 0
+            and mode == "SVM_SVC"
+        ):
+            scores = np.empty((res.shape[0], class_count_), dtype=X.dtype)
+            for n in range(scores.shape[0]):
+                s = self._probabilities(res[n], class_count_)
+                scores[n, :] = s
+            has_proba = True
+        else:
+            scores = res
+            has_proba = False
+
+        # finalization
+        final_scores = None
+        labels = []
+        for n in range(scores.shape[0]):
+            label, new_scores = self._compute_final_scores(
+                None if votes is None else votes[n],
+                scores[n],
+                weights_are_all_positive_,
+                has_proba,
+                classlabels_ints,
+            )
+            if final_scores is None:
+                final_scores = np.empty((X.shape[0], new_scores.size), dtype=X.dtype)
+            final_scores[n, :] = new_scores
+            labels.append(label)
+
+        # labels
+        if classlabels_strings is not None and len(classlabels_strings) > 0:
+            return (np.array([classlabels_strings[i] for i in labels]), final_scores)
+        return (np.array(labels, dtype=np.int64), final_scores)
diff --git a/onnx/reference/ops/aionnxml/op_svm_helper.py b/onnx/reference/ops/aionnxml/op_svm_helper.py
new file mode 100644
index 0000000..0035032
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_svm_helper.py
@@ -0,0 +1,97 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+
+class SVMAttributes:
+    def __init__(self):
+        self._names = []
+
+    def add(self, name: str, value: Any) -> None:
+        if isinstance(value, list) and name != "kernel_params":
+            if name == "vectors_per_class":
+                value = np.array(value, dtype=np.int64)
+            else:
+                value = np.array(value, dtype=np.float32)
+        setattr(self, name, value)
+
+    def __str__(self) -> str:
+        rows = ["Attributes"]
+        for name in self._names:
+            rows.append(f"  {name}={getattr(self, name)}")  # noqa: PERF401
+        return "\n".join(rows)
+
+
+class SVMCommon:
+    """Base class for SVM."""
+
+    def __init__(self, **kwargs):
+        self.atts = SVMAttributes()
+
+        for name, value in kwargs.items():
+            self.atts.add(name, value)
+
+        if self.atts.kernel_params:
+            self.gamma_ = self.atts.kernel_params[0]
+            self.coef0_ = self.atts.kernel_params[1]
+            self.degree_ = int(self.atts.kernel_params[2])
+        else:
+            self.gamma_ = 0.0
+            self.coef0_ = 0.0
+            self.degree_ = 0
+
+    def __str__(self) -> str:
+        rows = ["TreeEnsemble", f"root_index={self.root_index}", str(self.atts)]
+        return "\n".join(rows)
+
+    def kernel_dot(self, pA: np.ndarray, pB: np.ndarray, kernel: str) -> np.ndarray:
+        k = kernel.lower()
+        if k == "poly":
+            s = np.dot(pA, pB)
+            s = s * self.gamma_ + self.coef0_
+            return s**self.degree_
+        if k == "sigmoid":
+            s = np.dot(pA, pB)
+            s = s * self.gamma_ + self.coef0_
+            return np.tanh(s)
+        if k == "rbf":
+            diff = pA - pB
+            s = (diff * diff).sum()
+            return np.exp(-self.gamma_ * s)
+        if k == "linear":
+            return np.dot(pA, pB)
+        raise ValueError(f"Unexpected kernel={kernel!r}.")
+
+    def run_reg(self, X: np.ndarray) -> np.ndarray:
+        if self.atts.n_supports > 0:
+            # length of each support vector
+            mode_ = "SVM_SVC"
+            kernel_type_ = self.atts.kernel_type
+            sv = self.atts.support_vectors.reshape((self.atts.n_supports, -1))
+        else:
+            mode_ = "SVM_LINEAR"
+            kernel_type_ = "LINEAR"
+
+        z = np.empty((X.shape[0], 1), dtype=X.dtype)
+        for n in range(X.shape[0]):
+            s = 0.0
+
+            if mode_ == "SVM_SVC":
+                for j in range(self.atts.n_supports):
+                    d = self.kernel_dot(X[n], sv[j], kernel_type_)
+                    s += self.atts.coefficients[j] * d
+                s += self.atts.rho[0]
+            elif mode_ == "SVM_LINEAR":
+                s = self.kernel_dot(X[n], self.atts.coefficients, kernel_type_)
+                s += self.atts.rho[0]
+
+            if self.atts.one_class:
+                z[n, 0] = 1 if s > 0 else -1
+            else:
+                z[n, 0] = s
+        return z
diff --git a/onnx/reference/ops/aionnxml/op_svm_regressor.py b/onnx/reference/ops/aionnxml/op_svm_regressor.py
new file mode 100644
index 0000000..daa1b5c
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_svm_regressor.py
@@ -0,0 +1,43 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+from onnx.reference.ops.aionnxml.op_svm_helper import SVMCommon
+
+
+class SVMRegressor(OpRunAiOnnxMl):
+    """The class only implements `POST_TRANSFORM="NONE"`."""
+
+    def _run(
+        self,
+        X,
+        coefficients=None,
+        kernel_params=None,
+        kernel_type=None,
+        n_targets=None,
+        n_supports=None,
+        one_class=None,
+        post_transform=None,
+        rho=None,
+        support_vectors=None,
+    ):
+        svm = SVMCommon(
+            coefficients=coefficients,
+            kernel_params=kernel_params,
+            kernel_type=kernel_type,
+            n_targets=n_targets,
+            n_supports=n_supports,
+            one_class=one_class,
+            post_transform=post_transform,
+            rho=rho,
+            support_vectors=support_vectors,
+        )
+        # adding an attribute for debugging purpose
+        self._svm = svm
+        res = svm.run_reg(X)
+
+        if post_transform in (None, "NONE"):
+            return (res,)
+        raise NotImplementedError(f"post_transform={post_transform!r} not implemented.")
diff --git a/onnx/reference/ops/aionnxml/op_tree_ensemble.py b/onnx/reference/ops/aionnxml/op_tree_ensemble.py
new file mode 100644
index 0000000..d888ccf
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_tree_ensemble.py
@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class AggregationFunction(IntEnum):
+    AVERAGE = 0
+    SUM = 1
+    MIN = 2
+    MAX = 3
+
+
+class PostTransform(IntEnum):
+    NONE = 0
+    SOFTMAX = 1
+    LOGISTIC = 2
+    SOFTMAX_ZERO = 3
+    PROBIT = 4
+
+
+class Mode(IntEnum):
+    LEQ = 0
+    LT = 1
+    GTE = 2
+    GT = 3
+    EQ = 4
+    NEQ = 5
+    MEMBER = 6
+
+
+class Leaf:
+    def __init__(self, weight: float, target_id: int) -> None:
+        self.weight = weight
+        self.target_id = target_id
+
+    # Produce the weight and target index
+    def predict(self, x: np.ndarray) -> np.ndarray:  # noqa: ARG002
+        return np.array([self.weight, self.target_id])
+
+    def _print(self, prefix: list, indent: int = 0) -> None:
+        prefix.append(
+            " " * indent + f"Leaf WEIGHT: {self.weight}, TARGET: {self.target_id}\n"
+        )
+
+    def __repr__(self) -> str:
+        prefix = []
+        self._print(prefix)
+        return "".join(prefix)
+
+
+class Node:
+    compare: Callable[[float, float | set[float]], bool]
+    true_branch: Node | Leaf
+    false_branch: Node | Leaf
+    feature: int
+
+    def __init__(
+        self,
+        mode: Mode,
+        value: float | set[float],
+        feature: int,
+        missing_tracks_true: bool,
+    ) -> None:
+        if mode == Mode.LEQ:
+            self.compare = lambda x: (
+                x[feature].item() <= value
+                or (missing_tracks_true and np.isnan(x[feature].item()))
+            )
+        elif mode == Mode.LT:
+            self.compare = lambda x: (
+                x[feature].item() < value
+                or (missing_tracks_true and np.isnan(x[feature].item()))
+            )
+        elif mode == Mode.GTE:
+            self.compare = lambda x: (
+                x[feature].item() >= value
+                or (missing_tracks_true and np.isnan(x[feature].item()))
+            )
+        elif mode == Mode.GT:
+            self.compare = lambda x: (
+                x[feature].item() > value
+                or (missing_tracks_true and np.isnan(x[feature].item()))
+            )
+        elif mode == Mode.EQ:
+            self.compare = lambda x: (
+                x[feature].item() == value
+                or (missing_tracks_true and np.isnan(x[feature].item()))
+            )
+        elif mode == Mode.NEQ:
+            self.compare = lambda x: (
+                x[feature].item() != value
+                or (missing_tracks_true and np.isnan(x[feature].item()))
+            )
+        elif mode == Mode.MEMBER:
+            self.compare = lambda x: (
+                x[feature].item() in value
+                or (missing_tracks_true and np.isnan(x[feature].item()))
+            )
+        self.mode = mode
+        self.value = value
+        self.feature = feature
+
+    def predict(self, x: np.ndarray) -> float:
+        if self.compare(x):
+            return self.true_branch.predict(x)
+        return self.false_branch.predict(x)
+
+    def _print(self, prefix: list, indent: int = 0) -> None:
+        prefix.append(
+            " " * indent
+            + f"Node CMP: {self.mode}, SPLIT: {self.value}, FEATURE: {self.feature}\n"
+        )
+        self.true_branch._print(prefix, indent + 1)
+        self.false_branch._print(prefix, indent + 1)
+
+    def __repr__(self) -> str:
+        prefix = []
+        self._print(prefix)
+        return "".join(prefix)
+
+
+class TreeEnsemble(OpRunAiOnnxMl):
+    def _run(
+        self,
+        X,
+        nodes_splits,
+        nodes_featureids,
+        nodes_modes,
+        nodes_truenodeids,
+        nodes_falsenodeids,
+        nodes_trueleafs,
+        nodes_falseleafs,
+        leaf_targetids,
+        leaf_weights,
+        tree_roots,
+        post_transform=PostTransform.NONE,  # noqa: ARG002
+        aggregate_function=AggregationFunction.SUM,
+        nodes_hitrates=None,  # noqa: ARG002
+        nodes_missing_value_tracks_true=None,
+        membership_values=None,
+        n_targets=None,
+    ):
+        if membership_values is None:
+            # assert that no set membership ever appears
+            if any(mode == Mode.MEMBER for mode in nodes_modes):
+                raise ValueError(
+                    "Cannot have set membership node without specifying set members"
+                )
+        elif np.isnan(membership_values).sum() != sum(
+            int(mode == Mode.MEMBER) for mode in nodes_modes
+        ):
+            raise ValueError(
+                "Must specify membership values for all set membership nodes"
+            )
+
+        # Build each tree in the ensemble. Note that the tree structure is implicitly defined by following the true and false indices in
+        # `nodes_truenodeids` and `nodes_falsenodeids` to the leaves of each tree.
+        set_membership_iter = (
+            iter(membership_values) if membership_values is not None else None
+        )
+
+        def build_node(current_node_index, is_leaf) -> Node | Leaf:
+            if is_leaf:
+                return Leaf(
+                    leaf_weights[current_node_index], leaf_targetids[current_node_index]
+                )
+
+            if nodes_modes[current_node_index] == Mode.MEMBER:
+                # parse next sequence of set members
+                set_members = set()
+                while (set_member := next(set_membership_iter)) and not np.isnan(
+                    set_member
+                ):
+                    set_members.add(set_member)
+                node = Node(
+                    nodes_modes[current_node_index],
+                    set_members,
+                    nodes_featureids[current_node_index],
+                    (
+                        nodes_missing_value_tracks_true[current_node_index]
+                        if nodes_missing_value_tracks_true is not None
+                        else False
+                    ),
+                )
+            else:
+                node = Node(
+                    nodes_modes[current_node_index],
+                    nodes_splits[current_node_index],
+                    nodes_featureids[current_node_index],
+                    (
+                        nodes_missing_value_tracks_true[current_node_index]
+                        if nodes_missing_value_tracks_true is not None
+                        else False
+                    ),
+                )
+
+            # recurse true and false branches
+            node.true_branch = build_node(
+                nodes_truenodeids[current_node_index],
+                nodes_trueleafs[current_node_index],
+            )
+            node.false_branch = build_node(
+                nodes_falsenodeids[current_node_index],
+                nodes_falseleafs[current_node_index],
+            )
+            return node
+
+        trees = []
+        for root_index in tree_roots:
+            # degenerate case (tree == leaf)
+            is_leaf = (
+                nodes_trueleafs[root_index]
+                and nodes_falseleafs[root_index]
+                and nodes_truenodeids[root_index] == nodes_falsenodeids[root_index]
+            )
+            trees.append(build_node(root_index, is_leaf))
+
+        # predict each sample through tree
+        raw_values = [
+            np.apply_along_axis(tree.predict, axis=1, arr=X) for tree in trees
+        ]
+        weights, target_ids = zip(
+            *[np.split(x, 2, axis=1) for x in raw_values], strict=False
+        )
+        weights = np.concatenate(weights, axis=1)
+        target_ids = np.concatenate(target_ids, axis=1).astype(np.int64)
+        if aggregate_function in (
+            AggregationFunction.SUM,
+            AggregationFunction.AVERAGE,
+        ):
+            result = np.zeros((len(X), n_targets), dtype=X.dtype)
+        elif aggregate_function == AggregationFunction.MIN:
+            result = np.full((len(X), n_targets), np.finfo(X.dtype).max)
+        elif aggregate_function == AggregationFunction.MAX:
+            result = np.full((len(X), n_targets), np.finfo(X.dtype).min)
+        else:
+            raise NotImplementedError(
+                f"aggregate_transform={aggregate_function!r} not supported yet."
+            )
+        for batch_num, (w, t) in enumerate(zip(weights, target_ids, strict=False)):
+            weight = w.reshape(-1)
+            target_id = t.reshape(-1)
+            if aggregate_function == AggregationFunction.SUM:
+                for value, tid in zip(weight, target_id, strict=False):
+                    result[batch_num, tid] += value
+            elif aggregate_function == AggregationFunction.AVERAGE:
+                for value, tid in zip(weight, target_id, strict=False):
+                    result[batch_num, tid] += value / len(trees)
+            elif aggregate_function == AggregationFunction.MIN:
+                for value, tid in zip(weight, target_id, strict=False):
+                    result[batch_num, tid] = min(result[batch_num, tid], value)
+            elif aggregate_function == AggregationFunction.MAX:
+                for value, tid in zip(weight, target_id, strict=False):
+                    result[batch_num, tid] = max(result[batch_num, tid], value)
+            else:
+                raise NotImplementedError(
+                    f"aggregate_transform={aggregate_function!r} not supported yet."
+                )
+
+        return (result,)
diff --git a/onnx/reference/ops/aionnxml/op_tree_ensemble_classifier.py b/onnx/reference/ops/aionnxml/op_tree_ensemble_classifier.py
new file mode 100644
index 0000000..3747855
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_tree_ensemble_classifier.py
@@ -0,0 +1,132 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._common_classifier import (
+    logistic,
+    probit,
+    softmax,
+    softmax_zero,
+)
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+from onnx.reference.ops.aionnxml.op_tree_ensemble_helper import TreeEnsemble
+
+
+class TreeEnsembleClassifier(OpRunAiOnnxMl):
+    def _run(
+        self,
+        X,
+        base_values=None,
+        base_values_as_tensor=None,
+        class_ids=None,
+        class_nodeids=None,
+        class_treeids=None,
+        class_weights=None,
+        class_weights_as_tensor=None,
+        classlabels_int64s=None,
+        classlabels_strings=None,
+        nodes_falsenodeids=None,
+        nodes_featureids=None,
+        nodes_hitrates=None,
+        nodes_hitrates_as_tensor=None,
+        nodes_missing_value_tracks_true=None,
+        nodes_modes=None,
+        nodes_nodeids=None,
+        nodes_treeids=None,
+        nodes_truenodeids=None,
+        nodes_values=None,
+        nodes_values_as_tensor=None,
+        post_transform=None,
+    ):
+        nmv = nodes_missing_value_tracks_true
+        tr = TreeEnsemble(
+            base_values=base_values,
+            base_values_as_tensor=base_values_as_tensor,
+            nodes_falsenodeids=nodes_falsenodeids,
+            nodes_featureids=nodes_featureids,
+            nodes_hitrates=nodes_hitrates,
+            nodes_hitrates_as_tensor=nodes_hitrates_as_tensor,
+            nodes_missing_value_tracks_true=nmv,
+            nodes_modes=nodes_modes,
+            nodes_nodeids=nodes_nodeids,
+            nodes_treeids=nodes_treeids,
+            nodes_truenodeids=nodes_truenodeids,
+            nodes_values=nodes_values,
+            nodes_values_as_tensor=nodes_values_as_tensor,
+            class_weights=class_weights,
+            class_weights_as_tensor=class_weights_as_tensor,
+        )
+        # unused unless for debugging purposes
+        self._tree = tr
+        if X.dtype not in (np.float32, np.float64):
+            X = X.astype(np.float32)
+        leaves_index = tr.leave_index_tree(X)
+        n_classes = max(len(classlabels_int64s or []), len(classlabels_strings or []))
+        res = np.empty((leaves_index.shape[0], n_classes), dtype=np.float32)
+        if tr.atts.base_values is None:
+            res[:, :] = 0
+        else:
+            res[:, :] = np.array(tr.atts.base_values).reshape((1, -1))
+
+        class_index = {}
+        for i, (tid, nid) in enumerate(zip(class_treeids, class_nodeids, strict=False)):
+            if (tid, nid) not in class_index:
+                class_index[tid, nid] = []
+            class_index[tid, nid].append(i)
+        for i in range(res.shape[0]):
+            indices = leaves_index[i]
+            t_index = [class_index[nodes_treeids[i], nodes_nodeids[i]] for i in indices]
+            for its in t_index:
+                for it in its:
+                    res[i, class_ids[it]] += tr.atts.class_weights[it]
+
+        # post_transform
+        binary = len(set(class_ids)) == 1
+        classes = classlabels_int64s or classlabels_strings
+        post_function = {
+            None: lambda x: x,
+            "NONE": lambda x: x,
+            "LOGISTIC": logistic,
+            "SOFTMAX": softmax,
+            "SOFTMAX_ZERO": softmax_zero,
+            "PROBIT": probit,
+        }
+        if binary:
+            if res.shape[1] == len(classes) == 1:
+                new_res = np.zeros((res.shape[0], 2), res.dtype)
+                new_res[:, 1] = res[:, 0]
+                res = new_res
+            else:
+                res[:, 1] = res[:, 0]
+            if post_transform in (None, "NONE", "PROBIT"):
+                res[:, 0] = 1 - res[:, 1]
+            else:
+                res[:, 0] = -res[:, 1]
+        new_scores = post_function[post_transform](res)
+        labels = np.argmax(new_scores, axis=1)
+
+        # labels
+        if classlabels_int64s is not None:
+            if len(classlabels_int64s) == 1:
+                if classlabels_int64s[0] == 1:
+                    d = {1: 1}
+                    labels = np.array([d.get(i, 0) for i in labels], dtype=np.int64)
+                else:
+                    raise NotImplementedError(
+                        f"classlabels_int64s={classlabels_int64s}, not supported."
+                    )
+            else:
+                labels = np.array(
+                    [classlabels_int64s[i] for i in labels], dtype=np.int64
+                )
+        elif classlabels_strings is not None:
+            if len(classlabels_strings) == 1:
+                raise NotImplementedError(
+                    f"classlabels_strings={classlabels_strings}, not supported."
+                )
+            labels = np.array([classlabels_strings[i] for i in labels])
+
+        return labels, new_scores
diff --git a/onnx/reference/ops/aionnxml/op_tree_ensemble_helper.py b/onnx/reference/ops/aionnxml/op_tree_ensemble_helper.py
new file mode 100644
index 0000000..9a412b6
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_tree_ensemble_helper.py
@@ -0,0 +1,103 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+
+class TreeEnsembleAttributes:
+    def __init__(self):
+        self._names = []
+
+    def add(self, name, value):
+        if not name.endswith("_as_tensor"):
+            self._names.append(name)
+        if isinstance(value, list):
+            if name in {
+                "base_values",
+                "class_weights",
+                "nodes_values",
+                "nodes_hitrates",
+            }:
+                value = np.array(value, dtype=np.float32)
+            elif name.endswith("as_tensor"):
+                value = np.array(value)
+        setattr(self, name, value)
+
+    def __str__(self):
+        rows = ["Attributes"]
+        for name in self._names:
+            if name.endswith("_as_tensor"):
+                name = name.replace("_as_tensor", "")  # noqa: PLW2901
+            rows.append(f"  {name}={getattr(self, name)}")
+        return "\n".join(rows)
+
+
+class TreeEnsemble:
+    def __init__(self, **kwargs):
+        self.atts = TreeEnsembleAttributes()
+
+        for name, value in kwargs.items():
+            self.atts.add(name, value)
+
+        self.tree_ids = sorted(set(self.atts.nodes_treeids))
+        self.root_index = {tid: len(self.atts.nodes_treeids) for tid in self.tree_ids}
+        for index, tree_id in enumerate(self.atts.nodes_treeids):
+            self.root_index[tree_id] = min(self.root_index[tree_id], index)
+        self.node_index = {
+            (tid, nid): i
+            for i, (tid, nid) in enumerate(
+                zip(self.atts.nodes_treeids, self.atts.nodes_nodeids, strict=False)
+            )
+        }
+
+    def __str__(self) -> str:
+        rows = ["TreeEnsemble", f"root_index={self.root_index}", str(self.atts)]
+        return "\n".join(rows)
+
+    def leaf_index_tree(self, X: np.ndarray, tree_id: int) -> int:
+        """Computes the leaf index for one tree."""
+        index = self.root_index[tree_id]
+        while self.atts.nodes_modes[index] != "LEAF":
+            x = X[self.atts.nodes_featureids[index]]
+            if np.isnan(x):
+                r = self.atts.nodes_missing_value_tracks_true[index] >= 1
+            else:
+                rule = self.atts.nodes_modes[index]
+                th = self.atts.nodes_values[index]
+                if rule == "BRANCH_LEQ":
+                    r = x <= th
+                elif rule == "BRANCH_LT":
+                    r = x < th
+                elif rule == "BRANCH_GTE":
+                    r = x >= th
+                elif rule == "BRANCH_GT":
+                    r = x > th
+                elif rule == "BRANCH_EQ":
+                    r = x == th
+                elif rule == "BRANCH_NEQ":
+                    r = x != th
+                else:
+                    raise ValueError(
+                        f"Unexpected rule {rule!r} for node index {index}."
+                    )
+            nid = (
+                self.atts.nodes_truenodeids[index]
+                if r
+                else self.atts.nodes_falsenodeids[index]
+            )
+            index = self.node_index[tree_id, nid]
+        return index
+
+    def leave_index_tree(self, X: np.ndarray) -> np.ndarray:
+        """Computes the leaf index for all trees."""
+        if len(X.shape) == 1:
+            X = X.reshape((1, -1))
+        outputs = []
+        for row in X:
+            outs = []
+            for tree_id in self.tree_ids:
+                outs.append(self.leaf_index_tree(row, tree_id))  # noqa: PERF401
+            outputs.append(outs)
+        return np.array(outputs)
diff --git a/onnx/reference/ops/aionnxml/op_tree_ensemble_regressor.py b/onnx/reference/ops/aionnxml/op_tree_ensemble_regressor.py
new file mode 100644
index 0000000..eb9ca2c
--- /dev/null
+++ b/onnx/reference/ops/aionnxml/op_tree_ensemble_regressor.py
@@ -0,0 +1,109 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.aionnxml._op_run_aionnxml import OpRunAiOnnxMl
+from onnx.reference.ops.aionnxml.op_tree_ensemble_helper import TreeEnsemble
+
+
+class TreeEnsembleRegressor(OpRunAiOnnxMl):
+    """`nodes_hitrates` and `nodes_hitrates_as_tensor` are not used."""
+
+    def _run(
+        self,
+        X,
+        aggregate_function=None,
+        base_values=None,
+        base_values_as_tensor=None,
+        n_targets=None,
+        nodes_falsenodeids=None,
+        nodes_featureids=None,
+        nodes_hitrates=None,
+        nodes_hitrates_as_tensor=None,
+        nodes_missing_value_tracks_true=None,
+        nodes_modes=None,
+        nodes_nodeids=None,
+        nodes_treeids=None,
+        nodes_truenodeids=None,
+        nodes_values=None,
+        nodes_values_as_tensor=None,
+        post_transform=None,
+        target_ids=None,
+        target_nodeids=None,
+        target_treeids=None,
+        target_weights=None,
+        target_weights_as_tensor=None,
+    ):
+        nmv = nodes_missing_value_tracks_true
+        tr = TreeEnsemble(
+            base_values=base_values,
+            base_values_as_tensor=base_values_as_tensor,
+            nodes_falsenodeids=nodes_falsenodeids,
+            nodes_featureids=nodes_featureids,
+            nodes_hitrates=nodes_hitrates,
+            nodes_hitrates_as_tensor=nodes_hitrates_as_tensor,
+            nodes_missing_value_tracks_true=nmv,
+            nodes_modes=nodes_modes,
+            nodes_nodeids=nodes_nodeids,
+            nodes_treeids=nodes_treeids,
+            nodes_truenodeids=nodes_truenodeids,
+            nodes_values=nodes_values,
+            nodes_values_as_tensor=nodes_values_as_tensor,
+            target_weights=target_weights,
+            target_weights_as_tensor=target_weights_as_tensor,
+        )
+        # unused unless for debugging purposes
+        self._tree = tr
+        leaves_index = tr.leave_index_tree(X)
+        res = np.zeros((leaves_index.shape[0], n_targets), dtype=X.dtype)
+        n_trees = len(set(tr.atts.nodes_treeids))
+
+        target_index = {}
+        for i, (tid, nid) in enumerate(
+            zip(target_treeids, target_nodeids, strict=False)
+        ):
+            if (tid, nid) not in target_index:
+                target_index[tid, nid] = []
+            target_index[tid, nid].append(i)
+        for i in range(res.shape[0]):
+            indices = leaves_index[i]
+            t_index = [
+                target_index[nodes_treeids[i], nodes_nodeids[i]] for i in indices
+            ]
+            if aggregate_function in ("SUM", "AVERAGE"):
+                for its in t_index:
+                    for it in its:
+                        res[i, target_ids[it]] += tr.atts.target_weights[it]
+            elif aggregate_function == "MIN":
+                res[i, :] = np.finfo(res.dtype).max
+                for its in t_index:
+                    for it in its:
+                        res[i, target_ids[it]] = min(
+                            res[i, target_ids[it]],
+                            tr.atts.target_weights[it],
+                        )
+            elif aggregate_function == "MAX":
+                res[i, :] = np.finfo(res.dtype).min
+                for its in t_index:
+                    for it in its:
+                        res[i, target_ids[it]] = max(
+                            res[i, target_ids[it]],
+                            tr.atts.target_weights[it],
+                        )
+            else:
+                raise NotImplementedError(
+                    f"aggregate_transform={aggregate_function!r} not supported yet."
+                )
+        if aggregate_function == "AVERAGE":
+            res /= n_trees
+
+        # Convention is to add base_values after aggregate function
+        if base_values is not None:
+            res[:, :] += np.array(base_values).reshape((1, -1))
+
+        if post_transform in (None, "NONE"):
+            return (res,)
+        raise NotImplementedError(f"post_transform={post_transform!r} not implemented.")
diff --git a/onnx/reference/ops/experimental/__init__.py b/onnx/reference/ops/experimental/__init__.py
new file mode 100644
index 0000000..2192830
--- /dev/null
+++ b/onnx/reference/ops/experimental/__init__.py
@@ -0,0 +1,8 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+__all__ = ["load_op"]
+
+from onnx.reference.ops.experimental._op_list import load_op
diff --git a/onnx/reference/ops/experimental/_op_list.py b/onnx/reference/ops/experimental/_op_list.py
new file mode 100644
index 0000000..9f228bd
--- /dev/null
+++ b/onnx/reference/ops/experimental/_op_list.py
@@ -0,0 +1,72 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import textwrap
+from typing import Any
+
+from onnx.reference.op_run import OpFunction, OpRun
+from onnx.reference.ops._helpers import build_registered_operators_any_domain
+from onnx.reference.ops.experimental.op_im2col import Im2Col  # noqa: F401
+
+
+def _build_registered_operators() -> dict[str, dict[int | None, type[OpRun]]]:
+    return build_registered_operators_any_domain(globals().copy())
+
+
+def load_op(
+    domain: str,
+    op_type: str,
+    version: None | int,
+    custom: Any = None,
+) -> Any:
+    """Loads the implemented for a specified operator.
+
+    Args:
+        domain: domain
+        op_type: operator type
+        version: requested version
+        custom: custom implementation (like a function)
+
+    Returns:
+        class
+    """
+    global _registered_operators  # noqa: PLW0603
+    if _registered_operators is None:
+        _registered_operators = _build_registered_operators()
+    if custom is not None:
+        return lambda *args: OpFunction(*args, impl=custom)
+    if domain != "experimental":
+        raise ValueError(f"Domain must be '' not {domain!r}.")
+    if op_type not in _registered_operators:
+        available = "\n".join(textwrap.wrap(", ".join(sorted(_registered_operators))))
+        raise NotImplementedError(
+            f"No registered implementation for operator {op_type!r} "
+            f"and domain {domain!r} in\n{available}"
+        )
+    impl = _registered_operators[op_type]
+    if None not in impl:
+        raise RuntimeError(
+            f"No default implementation for operator {op_type!r} "
+            f"and domain {domain!r}, found "
+            f"{', '.join(map(str, impl))}."
+        )
+    if version is None or len(impl) == 1:
+        return impl[None]
+    best = -1
+    for v in impl:
+        if v is None:
+            continue
+        if best < v <= version:
+            best = v
+    if best == -1:
+        raise RuntimeError(
+            f"No implementation for operator {op_type!r} "
+            f"domain {domain!r} and version {version!r}, found "
+            f"{', '.join(map(str, impl))}."
+        )
+    return impl[best]
+
+
+_registered_operators: dict[str, dict[int | None, type[OpRun]]] | None = None
diff --git a/onnx/reference/ops/experimental/_op_run_experimental.py b/onnx/reference/ops/experimental/_op_run_experimental.py
new file mode 100644
index 0000000..c6dd4d7
--- /dev/null
+++ b/onnx/reference/ops/experimental/_op_run_experimental.py
@@ -0,0 +1,10 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class OpRunExperimental(OpRun):
+    op_domain = "experimental"
diff --git a/onnx/reference/ops/experimental/op_im2col.py b/onnx/reference/ops/experimental/op_im2col.py
new file mode 100644
index 0000000..9846ca8
--- /dev/null
+++ b/onnx/reference/ops/experimental/op_im2col.py
@@ -0,0 +1,35 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops.experimental._op_run_experimental import OpRunExperimental
+from onnx.reference.ops_optimized.op_conv_optimized import im2col_fast
+
+
+class Im2Col(OpRunExperimental):
+    def _run(self, img, kernel_shape, dilations=None, pads=None, strides=None):
+        if dilations is None:
+            dilations = [1 for s in img.shape[2:]]
+        if pads is None:
+            pads = [0 for s in img.shape[2:]] * 2
+        if strides is None:
+            strides = [1 for s in img.shape[2:]]
+
+        if min(dilations) == max(dilations) == 1:
+            return (im2col_fast(img, tuple(kernel_shape[2:]), pads, strides)[0],)
+
+        if dilations[0] != 1 or min(dilations) != max(dilations):
+            # Let's compute the dilated kernel.
+            nd = len(dilations)
+            new_kernel_shape = []
+            new_shape = list(kernel_shape)
+            for i, d in enumerate(dilations):
+                di = len(kernel_shape) - nd + i
+                new_shape.append(kernel_shape[di] + (kernel_shape[di] - 1) * (d - 1))
+                new_kernel_shape.append(
+                    kernel_shape[i] + (kernel_shape[i] - 1) * (d - 1)
+                )
+            kernel_shape = new_kernel_shape
+
+        return (im2col_fast(img, tuple(kernel_shape[2:]), pads, strides),)
diff --git a/onnx/reference/ops/op_abs.py b/onnx/reference/ops/op_abs.py
new file mode 100644
index 0000000..0945a90
--- /dev/null
+++ b/onnx/reference/ops/op_abs.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Abs(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.absolute(x),)
diff --git a/onnx/reference/ops/op_acos.py b/onnx/reference/ops/op_acos.py
new file mode 100644
index 0000000..a7ce8cb
--- /dev/null
+++ b/onnx/reference/ops/op_acos.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Acos(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.arccos(x),)
diff --git a/onnx/reference/ops/op_acosh.py b/onnx/reference/ops/op_acosh.py
new file mode 100644
index 0000000..1d6bb8f
--- /dev/null
+++ b/onnx/reference/ops/op_acosh.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Acosh(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.arccosh(x),)
diff --git a/onnx/reference/ops/op_add.py b/onnx/reference/ops/op_add.py
new file mode 100644
index 0000000..f9a2a26
--- /dev/null
+++ b/onnx/reference/ops/op_add.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryNumpy
+
+
+class Add(OpRunBinaryNumpy):
+    def __init__(self, onnx_node, run_params):
+        OpRunBinaryNumpy.__init__(self, np.add, onnx_node, run_params)
diff --git a/onnx/reference/ops/op_affine_grid.py b/onnx/reference/ops/op_affine_grid.py
new file mode 100644
index 0000000..45877f7
--- /dev/null
+++ b/onnx/reference/ops/op_affine_grid.py
@@ -0,0 +1,90 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def construct_original_grid(data_size, align_corners):
+    is_2d = len(data_size) == 2
+    size_zeros = np.zeros(data_size)
+    original_grid = [np.ones(data_size)]
+    for dim, dim_size in enumerate(data_size):
+        if align_corners == 1:
+            step = 2.0 / (dim_size - 1)
+            start = -1
+            stop = 1 + 0.0001
+            a = np.arange(start, stop, step)
+        else:
+            step = 2.0 / dim_size
+            start = -1 + step / 2
+            stop = 1
+            a = np.arange(start, stop, step)
+        if dim == 0:
+            if is_2d:
+                y = np.reshape(a, (dim_size, 1)) + size_zeros
+                original_grid = [y, *original_grid]
+            else:
+                z = np.reshape(a, (dim_size, 1, 1)) + size_zeros
+                original_grid = [z, *original_grid]
+        elif dim == 1:
+            if is_2d:
+                x = np.reshape(a, (1, dim_size)) + size_zeros
+                original_grid = [x, *original_grid]
+            else:
+                y = np.reshape(a, (1, dim_size, 1)) + size_zeros
+                original_grid = [y, *original_grid]
+        else:
+            x = np.reshape(a, (1, dim_size)) + size_zeros
+            original_grid = [x, *original_grid]
+    return np.stack(original_grid, axis=2 if is_2d else 3)
+
+
+def apply_affine_transform(theta_n, original_grid_homo):
+    # theta_n: (N, 2, 3) for 2D, (N, 3, 4) for 3D
+    # original_grid_homo: (H, W, 3) for 2D, (D, H, W, 4) for 3D
+    assert theta_n.ndim == 3, (
+        "theta_n shall have shape of (N, 2, 3) for 2D, (N, 3, 4) for 3D"
+    )
+    if original_grid_homo.ndim == 3:
+        N, dim_2d, dim_homo = theta_n.shape
+        assert dim_2d == 2 and dim_homo == 3
+        H, W, dim_homo = original_grid_homo.shape
+        assert dim_homo == 3
+        # reshape to [H * W, dim_homo] and then transpose to [dim_homo, H * W]
+        original_grid_transposed = np.transpose(
+            np.reshape(original_grid_homo, (H * W, dim_homo))
+        )
+        grid_n = np.matmul(
+            theta_n, original_grid_transposed
+        )  # shape (N, dim_2d, H * W)
+        # transpose to (N, H * W, dim_2d) and then reshape to (N, H, W, dim_2d)
+        grid = np.reshape(np.transpose(grid_n, (0, 2, 1)), (N, H, W, dim_2d))
+        return grid.astype(np.float32)
+    assert original_grid_homo.ndim == 4
+    N, dim_3d, dim_homo = theta_n.shape
+    assert dim_3d == 3 and dim_homo == 4
+    D, H, W, dim_homo = original_grid_homo.shape
+    assert dim_homo == 4
+    # reshape to [D * H * W, dim_homo] and then transpose to [dim_homo, D * H * W]
+    original_grid_transposed = np.transpose(
+        np.reshape(original_grid_homo, (D * H * W, dim_homo))
+    )
+    grid_n = np.matmul(
+        theta_n, original_grid_transposed
+    )  # shape (N, dim_3d, D * H * W)
+    # transpose to (N, D * H * W, dim_3d) and then reshape to (N, D, H, W, dim_3d)
+    grid = np.reshape(np.transpose(grid_n, (0, 2, 1)), (N, D, H, W, dim_3d))
+    return grid.astype(np.float32)
+
+
+class AffineGrid(OpRun):
+    def _run(self, theta, size, align_corners=None):
+        align_corners = align_corners or self.align_corners
+        _, _, *data_size = size
+        original_grid = construct_original_grid(data_size, align_corners)
+        grid = apply_affine_transform(theta, original_grid)
+        return (grid,)
diff --git a/onnx/reference/ops/op_and.py b/onnx/reference/ops/op_and.py
new file mode 100644
index 0000000..e51624b
--- /dev/null
+++ b/onnx/reference/ops/op_and.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinary
+
+
+class And(OpRunBinary):
+    def _run(self, x, y):
+        return (np.logical_and(x, y),)
diff --git a/onnx/reference/ops/op_argmax.py b/onnx/reference/ops/op_argmax.py
new file mode 100644
index 0000000..7636482
--- /dev/null
+++ b/onnx/reference/ops/op_argmax.py
@@ -0,0 +1,42 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _argmax(data, axis=0, keepdims=True):
+    result = np.argmax(data, axis=axis)
+    if keepdims and len(result.shape) < len(data.shape):
+        result = np.expand_dims(result, axis)
+    return result.astype(np.int64)
+
+
+def _argmax_use_numpy_select_last_index(data, axis=0, keepdims=True):
+    data = np.flip(data, axis)
+    result = np.argmax(data, axis=axis)
+    result = data.shape[axis] - result - 1
+    if keepdims:
+        result = np.expand_dims(result, axis)
+    return result.astype(np.int64)
+
+
+class _ArgMax(OpRun):
+    def _run(self, data, axis=None, keepdims=None):
+        return (_argmax(data, axis=axis, keepdims=keepdims),)
+
+
+class ArgMax_1(_ArgMax):
+    pass
+
+
+class ArgMax_12(_ArgMax):
+    def _run(self, data, axis=None, keepdims=None, select_last_index=None):
+        if select_last_index == 0:
+            return _ArgMax._run(self, data, axis=axis, keepdims=keepdims)
+        return (
+            _argmax_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims),
+        )
diff --git a/onnx/reference/ops/op_argmin.py b/onnx/reference/ops/op_argmin.py
new file mode 100644
index 0000000..b660b48
--- /dev/null
+++ b/onnx/reference/ops/op_argmin.py
@@ -0,0 +1,42 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _argmin(data, axis=0, keepdims=True):
+    result = np.argmin(data, axis=axis)
+    if keepdims and len(result.shape) < len(data.shape):
+        result = np.expand_dims(result, axis)
+    return result.astype(np.int64)
+
+
+def _argmin_use_numpy_select_last_index(data, axis=0, keepdims=True):
+    data = np.flip(data, axis)
+    result = np.argmin(data, axis=axis)
+    result = data.shape[axis] - result - 1
+    if keepdims:
+        result = np.expand_dims(result, axis)
+    return result.astype(np.int64)
+
+
+class _ArgMin(OpRun):
+    def _run(self, data, axis=None, keepdims=None):
+        return (_argmin(data, axis=axis, keepdims=keepdims),)
+
+
+class ArgMin_1(_ArgMin):
+    pass
+
+
+class ArgMin_12(_ArgMin):
+    def _run(self, data, axis=None, keepdims=None, select_last_index=None):
+        if select_last_index == 0:
+            return _ArgMin._run(self, data, axis=axis, keepdims=keepdims)
+        return (
+            _argmin_use_numpy_select_last_index(data, axis=axis, keepdims=keepdims),
+        )
diff --git a/onnx/reference/ops/op_asin.py b/onnx/reference/ops/op_asin.py
new file mode 100644
index 0000000..b998119
--- /dev/null
+++ b/onnx/reference/ops/op_asin.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Asin(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.arcsin(x),)
diff --git a/onnx/reference/ops/op_asinh.py b/onnx/reference/ops/op_asinh.py
new file mode 100644
index 0000000..3fedb93
--- /dev/null
+++ b/onnx/reference/ops/op_asinh.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Asinh(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.arcsinh(x),)
diff --git a/onnx/reference/ops/op_atan.py b/onnx/reference/ops/op_atan.py
new file mode 100644
index 0000000..69117b6
--- /dev/null
+++ b/onnx/reference/ops/op_atan.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Atan(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.arctan(x),)
diff --git a/onnx/reference/ops/op_atanh.py b/onnx/reference/ops/op_atanh.py
new file mode 100644
index 0000000..e74ec02
--- /dev/null
+++ b/onnx/reference/ops/op_atanh.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Atanh(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.arctanh(x),)
diff --git a/onnx/reference/ops/op_attention.py b/onnx/reference/ops/op_attention.py
new file mode 100644
index 0000000..48e988e
--- /dev/null
+++ b/onnx/reference/ops/op_attention.py
@@ -0,0 +1,336 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.reference.op_run import OpRun
+
+
+def _softmax(x: np.ndarray, axis: int = -1) -> np.ndarray:
+    x_max = np.max(x, axis=axis, keepdims=True)
+    # A fully-masked row is all `-inf`, so `x_max` is `-inf` and the naive
+    # `exp(x - x_max)` evaluates `exp(-inf - (-inf)) = NaN`. Such a row has no
+    # attendable key; by convention it softmaxes to all-zero probabilities.
+    # Detect those rows on `x_max` and return 0 for them directly (instead of
+    # computing NaN and overwriting it), so `_softmax` never emits a NaN/warning
+    # and the all-`-inf` case is independently unit-testable.
+    row_all_masked = np.isneginf(x_max)
+    safe_max = np.where(row_all_masked, 0, x_max)
+    tmp = np.exp(x - safe_max)
+    s = np.sum(tmp, axis=axis, keepdims=True)
+    s = np.where(s == 0, 1, s)  # avoid 0/0 for fully-masked rows (kept at 0)
+    return tmp / s
+
+
+def _softcap(X, softcap):
+    if softcap > 0:
+        Y = X / softcap
+        Y = np.tanh(Y)
+        return Y * softcap
+    return X
+
+
+def _apply_causal(base, offset):
+    """Adds an offset-aligned (bottom-right) causal bias to `base`.
+
+    A query at in-block index ``i`` attends key ``j`` iff ``j <= i + offset``;
+    attended positions contribute ``0`` and masked positions ``-inf`` (a softmax
+    then maps ``-inf`` to 0 and 0 to 1). This is the select-not-multiply form that
+    mirrors the function body's ``Where(allowed, 0, -inf)`` in ``utils.cc``, so the
+    reference and the ``_expanded`` graph agree bit-for-bit.
+
+    ``offset`` is either:
+
+    * a scalar -- the same causal frontier for every batch. Used for the internal
+      cache (``offset = past_key.shape[2]``) and the no-cache case (``offset = 0``,
+      i.e. ordinary top-left causal). The result keeps the 2-D ``(q, kv)`` shape of
+      ``base``.
+    * a 1-D per-batch array of shape ``(batch,)`` -- the external/static cache,
+      where ``offset[b] = nonpad_kv_seqlen[b] - q_len``. The result is promoted to
+      ``(batch, 1, q, kv)`` so the downstream padding-mask block is a no-op reshape.
+
+    Note: ``offset`` is intentionally not clamped to ``>= 0``. A negative offset
+    (the over-long-query / out-of-contract regime) fully masks the affected rows,
+    which the caller's fully-masked-row guard then zeroes -- matching the spec's
+    fully-masked ``Y = 0`` / mode-3 ``= 0`` behavior. Clamping would change that
+    result, so it is deliberately omitted.
+    """
+    q_sequence_length, kv_sequence_length = base.shape[-2:]
+    i_idx = np.arange(q_sequence_length).reshape(q_sequence_length, 1)  # (q, 1)
+    j_idx = np.arange(kv_sequence_length).reshape(1, kv_sequence_length)  # (1, kv)
+    per_batch = np.ndim(offset) > 0
+    if per_batch:
+        offsets = np.reshape(offset, (-1, 1, 1))  # (batch, 1, 1)
+        allowed = j_idx <= (i_idx + offsets)  # (batch, q, kv)
+    else:
+        allowed = j_idx <= (i_idx + int(offset))  # (q, kv)
+    causal = np.where(allowed, base.dtype.type(0), base.dtype.type(-np.inf))
+    if per_batch:
+        # Promote base to (batch, 1, q, kv) and add the per-batch causal bias.
+        return base.reshape((1,) * (4 - base.ndim) + base.shape) + causal.reshape(
+            causal.shape[0], 1, q_sequence_length, kv_sequence_length
+        )
+    return base + causal
+
+
+def _compute_attention(
+    Q: np.ndarray,
+    K: np.ndarray,
+    V: np.ndarray,
+    attn_mask: np.ndarray | None = None,
+    past_key: np.ndarray | None = None,
+    past_value: np.ndarray | None = None,
+    nonpad_kv_seqlen: np.ndarray | None = None,
+    scale=None,
+    is_causal=False,
+    q_num_heads=None,
+    kv_num_heads=None,
+    softmax_precision=None,
+    softcap=None,
+    qk_matmul_output_mode=None,
+) -> np.ndarray:
+    assert len(Q.shape) == len(K.shape) == len(V.shape)
+    # Set input tensors (Q, K, V) to the correct shape if input shape is 3D
+    # NewShapeQ (batch_size, q_num_heads, q_sequence_length, head_size)
+    # NewShapeK  (batch_size, kv_num_heads, kv_sequence_length, head_size)
+    # NewShapeV (value) has shape (batch_size, kv_num_heads, kv_sequence_length, v_head_size)
+    input_shape_len = len(Q.shape)
+    batch_size = Q.shape[0]
+    if len(Q.shape) == 3:
+        hidden_size_q = Q.shape[2]
+        hidden_size_k = K.shape[2]
+        hidden_size_v = V.shape[2]
+        assert q_num_heads is not None and kv_num_heads is not None
+
+        head_size_q = int(hidden_size_q / q_num_heads)
+        # First reshape to [batch_size, q_sequence_length, q_num_heads, head_size]
+        intermediate_shape_q = [batch_size, Q.shape[1], q_num_heads, head_size_q]
+        Q = np.reshape(Q, intermediate_shape_q)
+        # Then transpose to [batch_size, q_num_heads, q_sequence_length, head_size]
+        Q = np.transpose(Q, (0, 2, 1, 3))
+
+        head_size_k = int(hidden_size_k / kv_num_heads)
+        # First reshape to [batch_size, kv_sequence_length, kv_num_heads, head_size]
+        intermediate_shape_k = [batch_size, K.shape[1], kv_num_heads, head_size_k]
+        K = np.reshape(K, intermediate_shape_k)
+        # Then transpose to [batch_size, kv_num_heads, kv_sequence_length, head_size]
+        K = np.transpose(K, (0, 2, 1, 3))
+
+        head_size_v = int(hidden_size_v / kv_num_heads)
+        # First reshape to [batch_size, kv_sequence_length, kv_num_heads, head_size]
+        intermediate_shape_v = [batch_size, V.shape[1], kv_num_heads, head_size_v]
+        V = np.reshape(V, intermediate_shape_v)
+        # Then transpose to [batch_size, kv_num_heads, kv_sequence_length, head_size]
+        V = np.transpose(V, (0, 2, 1, 3))
+    assert len(Q.shape) == 4 and len(K.shape) == 4 and len(V.shape) == 4
+
+    # Calculate Scaling Factor if not provided
+    if scale is None:
+        q_head_size = Q.shape[3]
+        scale = 1 / np.sqrt(q_head_size)
+    scale = np.sqrt(scale)
+
+    # Update key and value cache
+    if past_key is not None:
+        present_key = np.concatenate((past_key, K), axis=2)
+    else:
+        present_key = K
+    if past_value is not None:
+        present_value = np.concatenate((past_value, V), axis=2)
+    else:
+        present_value = V
+    K = present_key
+    V = present_value
+
+    # Create attn_bias
+    q_sequence_length = Q.shape[2]
+    kv_sequence_length = K.shape[2]
+    attn_bias = np.zeros((q_sequence_length, kv_sequence_length), dtype=Q.dtype)
+
+    # The attn_mask can be less than kv_sequence_length, we need to pad it with -inf or 0
+    if attn_mask is not None:
+        pad_width = kv_sequence_length - attn_mask.shape[-1]
+        if pad_width > 0:
+            pad_shape = [(0, 0)] * (attn_mask.ndim - 1) + [(0, pad_width)]
+            pad_value = False if attn_mask.dtype == np.bool_ else -np.inf
+            attn_mask = np.pad(
+                attn_mask, pad_shape, mode="constant", constant_values=pad_value
+            )
+
+    # First case: If is_causal is provided.
+    # Causal masking is bottom-right / offset-aligned: a query at in-block index i attends
+    # key j iff  j <= i + offset, where offset is the number of valid keys that precede this
+    # query block. offset is derived per batch from the cache representation:
+    #   * past_key present (internal cache):   offset = past_key.shape[2]   (same for all b)
+    #   * nonpad_kv_seqlen present, no past_key (external/static cache):
+    #                                          offset[b] = nonpad_kv_seqlen[b] - q_len
+    #   * neither:                             offset = 0  (no-cache case)
+    if is_causal:
+        if attn_mask is not None and attn_mask.dtype == np.bool_:
+            # Convert the boolean mask to an additive bias with select-not-multiply:
+            # True (attend) -> 0, False (mask) -> -inf. The previous
+            # (1 - attn_mask) * -inf form computes 0 * -inf = NaN at allowed cells.
+            # This matches the function body's Where(attn_mask, ScalarZero, FloatNegInf)
+            # in AttentionAppendFunctionCausalMask (utils.cc) so the reference and
+            # _expanded agree exactly.
+            attn_mask = np.where(attn_mask, Q.dtype.type(0), Q.dtype.type(-np.inf))
+        base = (
+            np.zeros((q_sequence_length, kv_sequence_length), dtype=Q.dtype)
+            if attn_mask is None
+            else attn_mask.copy()
+        )
+        if past_key is None and nonpad_kv_seqlen is not None:
+            # External/static cache: per-batch bottom-right frontier
+            #   j <= i + (nonpad_kv_seqlen[b] - q_len).
+            offset = nonpad_kv_seqlen.reshape(-1) - q_sequence_length  # (batch,)
+            attn_bias = _apply_causal(base, offset)
+        else:
+            # Internal cache (past_key) or no cache: scalar offset -- bit-identical path.
+            offset = past_key.shape[2] if past_key is not None else 0
+            attn_bias = _apply_causal(base, offset)
+    elif attn_mask is not None:
+        if attn_mask.dtype == np.bool_:
+            attn_mask = (1 - attn_mask).astype(Q.dtype)
+            attn_mask[attn_mask == 1] = -np.inf
+        attn_bias = attn_bias + attn_mask
+
+    if nonpad_kv_seqlen is not None:
+        attn_bias = attn_bias.reshape(
+            (1,) * (4 - attn_bias.ndim) + attn_bias.shape
+        )  # broadcast to 4D
+        padding_mask = np.arange(kv_sequence_length) < nonpad_kv_seqlen[:, np.newaxis]
+        padding_mask = padding_mask.reshape(batch_size, 1, 1, kv_sequence_length)
+        padding_mask = np.where(padding_mask, 0, -np.inf)
+        attn_bias += padding_mask
+
+    # Group Query Attention is applied if the following are satisfied
+    # 1) q_num_heads != kv_num_heads
+    # 2) q_num_heads % kv_num_heads == 0
+    # 3) kv_num_heads == k_num_heads == v_num_heads
+    if q_num_heads is None:
+        q_num_heads = Q.shape[1]
+    if kv_num_heads is None:
+        k_num_heads = K.shape[1]
+        v_num_heads = K.shape[1]
+    else:
+        k_num_heads = kv_num_heads
+        v_num_heads = kv_num_heads
+    if (
+        (q_num_heads != k_num_heads)
+        and (q_num_heads % k_num_heads == 0)
+        and (k_num_heads == v_num_heads)
+    ):
+        seq_reps = q_num_heads // k_num_heads
+        # Interleave-repeat each KV head: [h0, h0, h1, h1, ...]
+        K = np.repeat(K, repeats=seq_reps, axis=1)
+        V = np.repeat(V, repeats=seq_reps, axis=1)
+
+    # The following pattern is applied
+    #      Q          K          V
+    #      |          |          |
+    #     Q*scale    K*scale     |
+    #      |          |          |
+    #      |       Transpose     |
+    #      |          |          |
+    #      ---MatMul---          |
+    #            |               |
+    #  softcap (if provided)     |
+    #            |               |
+    # at_mask---Add              |
+    #            |               |
+    #         Softmax            |
+    #            |               |
+    #            -----MatMul------
+    #                    |
+    #                    Y
+    k_transpose = np.transpose(K, (0, 1, 3, 2))
+    qk_matmul_output = np.matmul(Q * scale, k_transpose * scale)
+
+    # Apply softcap before mask/bias addition.
+    # Softcap must be applied before mask so that -inf mask values remain -inf
+    # (yielding zero probability in softmax). If softcap were applied after mask,
+    # -inf would be mapped to -softcap (finite), leaking probability to masked positions.
+    if softcap is not None:
+        qk_matmul_output = _softcap(qk_matmul_output, softcap)
+
+    qk_with_bias = qk_matmul_output + attn_bias
+    if qk_matmul_output_mode == 1 and softcap is not None:
+        pass  # qk_matmul_output already holds the softcapped-only value
+    elif qk_matmul_output_mode == 2:
+        qk_matmul_output = qk_with_bias.copy()
+
+    if softmax_precision is not None:
+        qk_with_bias = qk_with_bias.astype(
+            onnx.helper.tensor_dtype_to_np_dtype(softmax_precision)
+        )
+    # `_softmax` is warning-free for an all-`-inf` (fully-masked) row: it returns
+    # 0 instead of computing `exp(-inf - (-inf)) = NaN`. The fully-masked-row
+    # semantics, however, are decided on the additive bias below (not on the
+    # logits), so masking stays correct even when a masked row's raw QK score is
+    # non-`-inf` (e.g. `+inf + (-inf) = NaN`).
+    qk_softmax = _softmax(qk_with_bias)
+
+    # Fully-masked-row guard: a query row whose additive bias is entirely -inf
+    # (every key disallowed by the combined causal + attn_mask constraints) has no
+    # attendable key. Decide this on the additive bias -- not the (possibly NaN)
+    # logits -- and zero those rows with select-not-multiply (NaN * 0 = NaN) BEFORE
+    # the P @ V contraction so 0 @ V = 0. The guard runs before the mode-3 capture
+    # so the exposed qk_matmul_output row is also zeroed, consistent with Y, and
+    # mirrors the function body's bias-based guard for primary == _expanded parity.
+    row_all_masked = np.isneginf(
+        np.max(attn_bias, axis=-1, keepdims=True)
+    )  # (..., q, 1)
+    qk_softmax = np.where(row_all_masked, 0, qk_softmax)
+
+    if qk_matmul_output_mode == 3:
+        # Mode 3 exposes the post-softmax probabilities; a fully-masked row is
+        # zeroed by the guard above, consistent with the primary output Y (both
+        # are 0). This matches the function body (Identity of the guarded softmax),
+        # preserving primary == _expanded parity for the qk_matmul_output output.
+        qk_matmul_output = qk_softmax
+    qk_matmul_output = qk_matmul_output.astype(Q.dtype)
+
+    output = np.matmul(qk_softmax, V).astype(Q.dtype)
+    if input_shape_len == 3:
+        output = np.transpose(output, (0, 2, 1, 3))
+        output = np.reshape(output, (output.shape[0], output.shape[1], -1))
+    return output, present_key, present_value, qk_matmul_output
+
+
+class Attention(OpRun):
+    def _run(
+        self,
+        Q: np.ndarray,
+        K: np.ndarray,
+        V: np.ndarray,
+        attn_mask: np.ndarray | None = None,
+        past_key: np.ndarray | None = None,
+        past_value: np.ndarray | None = None,
+        nonpad_kv_seqlen: np.ndarray | None = None,
+        scale=None,
+        is_causal=False,
+        q_num_heads=None,
+        kv_num_heads=None,
+        softmax_precision=None,
+        softcap=None,
+        qk_matmul_output_mode=None,
+    ) -> np.ndarray:
+        return _compute_attention(
+            Q,
+            K,
+            V,
+            attn_mask=attn_mask,
+            past_key=past_key,
+            past_value=past_value,
+            nonpad_kv_seqlen=nonpad_kv_seqlen,
+            scale=scale,
+            is_causal=is_causal,
+            q_num_heads=q_num_heads,
+            kv_num_heads=kv_num_heads,
+            softmax_precision=softmax_precision,
+            softcap=softcap,
+            qk_matmul_output_mode=qk_matmul_output_mode,
+        )
diff --git a/onnx/reference/ops/op_attribute_has_value.py b/onnx/reference/ops/op_attribute_has_value.py
new file mode 100644
index 0000000..19811d9
--- /dev/null
+++ b/onnx/reference/ops/op_attribute_has_value.py
@@ -0,0 +1,33 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class AttributeHasValue(OpRun):
+    def _run(
+        self,
+        value_float=None,  # noqa: ARG002
+        value_floats=None,  # noqa: ARG002
+        value_graph=None,  # noqa: ARG002
+        value_graphs=None,  # noqa: ARG002
+        value_int=None,  # noqa: ARG002
+        value_ints=None,  # noqa: ARG002
+        value_sparse_tensor=None,  # noqa: ARG002
+        value_sparse_tensors=None,  # noqa: ARG002
+        value_string=None,  # noqa: ARG002
+        value_strings=None,  # noqa: ARG002
+        value_tensor=None,  # noqa: ARG002
+        value_tensors=None,  # noqa: ARG002
+        value_type_proto=None,  # noqa: ARG002
+        value_type_protos=None,  # noqa: ARG002
+    ):
+        # TODO: support overridden attributes.
+        for att in self.onnx_node.attribute:
+            if att.name.startswith("value_"):
+                return (np.array([True]),)
+        return (np.array([False]),)
diff --git a/onnx/reference/ops/op_average_pool.py b/onnx/reference/ops/op_average_pool.py
new file mode 100644
index 0000000..27c9982
--- /dev/null
+++ b/onnx/reference/ops/op_average_pool.py
@@ -0,0 +1,107 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops.op_pool_common import CommonPool
+
+
+class AveragePool_1(CommonPool):
+    def _run(
+        self,
+        x,
+        auto_pad=None,
+        ceil_mode=None,
+        kernel_shape=None,
+        pads=None,
+        strides=None,
+        count_include_pad=None,
+    ):
+        return CommonPool._run(
+            self,
+            "AVG",
+            count_include_pad,
+            x,
+            auto_pad=auto_pad,
+            ceil_mode=ceil_mode,
+            dilations=None,
+            kernel_shape=kernel_shape,
+            pads=pads,
+            strides=strides,
+        )
+
+
+class AveragePool_7(CommonPool):
+    def _run(
+        self,
+        x,
+        auto_pad=None,
+        ceil_mode=None,
+        kernel_shape=None,
+        pads=None,
+        strides=None,
+        count_include_pad=None,
+    ):
+        return CommonPool._run(
+            self,
+            "AVG",
+            count_include_pad,
+            x,
+            auto_pad=auto_pad,
+            ceil_mode=ceil_mode,
+            dilations=None,
+            kernel_shape=kernel_shape,
+            pads=pads,
+            strides=strides,
+        )
+
+
+class AveragePool_11(CommonPool):
+    def _run(
+        self,
+        x,
+        auto_pad=None,
+        ceil_mode=None,
+        kernel_shape=None,
+        pads=None,
+        strides=None,
+        count_include_pad=None,
+    ):
+        return CommonPool._run(
+            self,
+            "AVG",
+            count_include_pad,
+            x,
+            auto_pad=auto_pad,
+            ceil_mode=ceil_mode,
+            dilations=None,
+            kernel_shape=kernel_shape,
+            pads=pads,
+            strides=strides,
+        )
+
+
+class AveragePool_19(CommonPool):
+    def _run(
+        self,
+        x,
+        auto_pad=None,
+        ceil_mode=None,
+        dilations=None,
+        kernel_shape=None,
+        pads=None,
+        strides=None,
+        count_include_pad=None,
+    ):
+        return CommonPool._run(
+            self,
+            "AVG",
+            count_include_pad,
+            x,
+            auto_pad=auto_pad,
+            ceil_mode=ceil_mode,
+            dilations=dilations,
+            kernel_shape=kernel_shape,
+            pads=pads,
+            strides=strides,
+        )
diff --git a/onnx/reference/ops/op_batch_normalization.py b/onnx/reference/ops/op_batch_normalization.py
new file mode 100644
index 0000000..d38f644
--- /dev/null
+++ b/onnx/reference/ops/op_batch_normalization.py
@@ -0,0 +1,101 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _batchnorm_test_mode(
+    x: np.ndarray,
+    s: np.ndarray,
+    bias: np.ndarray,
+    mean: np.ndarray,
+    var: np.ndarray,
+    epsilon: float = 1e-5,
+) -> np.ndarray:
+    dims_x = len(x.shape)
+    dim_ones = (1,) * (dims_x - 2)
+    s = s.reshape(-1, *dim_ones)
+    bias = bias.reshape(-1, *dim_ones)
+    mean = mean.reshape(-1, *dim_ones)
+    var = var.reshape(-1, *dim_ones)
+    y = s * (x - mean) / np.sqrt(var + epsilon) + bias
+    return y.astype(x.dtype)
+
+
+def _batchnorm_training_mode(
+    x: np.ndarray,
+    s: np.ndarray,
+    bias: np.ndarray,
+    mean: np.ndarray,
+    var: np.ndarray,
+    momentum: float = 0.9,
+    epsilon: float = 1e-5,
+) -> np.ndarray:
+    axis = tuple(np.delete(np.arange(len(x.shape)), 1))
+    saved_mean = x.mean(axis=axis)
+    saved_var = x.var(axis=axis)
+    output_mean = mean * momentum + saved_mean * (1 - momentum)
+    output_var = var * momentum + saved_var * (1 - momentum)
+    y = _batchnorm_test_mode(x, s, bias, saved_mean, saved_var, epsilon=epsilon)
+    return (
+        y.astype(x.dtype),
+        saved_mean.astype(x.dtype),
+        saved_var.astype(x.dtype),
+        output_mean.astype(x.dtype),
+        output_var.astype(x.dtype),
+    )
+
+
+class BatchNormalization_6(OpRun):
+    def _run(
+        self,
+        x,
+        scale,
+        bias,
+        mean,
+        var,
+        epsilon=None,
+        is_test=None,
+        momentum=None,
+        spatial=None,  # noqa: ARG002
+    ):
+        if is_test:
+            res = _batchnorm_test_mode(x, scale, bias, mean, var, epsilon=epsilon)
+        else:
+            res = _batchnorm_training_mode(
+                x, scale, bias, mean, var, epsilon=epsilon, momentum=momentum
+            )
+        return (res,)
+
+
+class BatchNormalization_9(OpRun):
+    def _run(self, x, scale, bias, mean, var, epsilon=None, momentum=None):
+        if momentum is None:
+            res = _batchnorm_test_mode(x, scale, bias, mean, var, epsilon=epsilon)
+            return (res,)
+        axis = tuple(np.delete(np.arange(len(x.shape)), 1))
+        saved_mean = x.mean(axis=axis)
+        saved_var = x.var(axis=axis)
+        output_mean = mean * momentum + saved_mean * (1 - momentum)
+        output_var = var * momentum + saved_var * (1 - momentum)
+        res = _batchnorm_test_mode(
+            x, scale, bias, output_mean, output_var, epsilon=epsilon
+        )
+        return (res,)
+
+
+class BatchNormalization_14(OpRun):
+    def _run(
+        self, x, scale, bias, mean, var, epsilon=None, momentum=None, training_mode=None
+    ):
+        if training_mode == 0:
+            res = _batchnorm_test_mode(x, scale, bias, mean, var, epsilon=epsilon)
+            return (res,)
+        res, __, _, output_mean, output_var = _batchnorm_training_mode(
+            x, scale, bias, mean, var, momentum, epsilon
+        )
+        return res, output_mean, output_var
diff --git a/onnx/reference/ops/op_bernoulli.py b/onnx/reference/ops/op_bernoulli.py
new file mode 100644
index 0000000..c3d9a21
--- /dev/null
+++ b/onnx/reference/ops/op_bernoulli.py
@@ -0,0 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.helper import np_dtype_to_tensor_dtype
+from onnx.reference.ops._op_common_random import _CommonRandom
+
+
+class Bernoulli(_CommonRandom):
+    def _run(self, x, dtype=None, seed=None):
+        if dtype is None:
+            dtype = np_dtype_to_tensor_dtype(x.dtype)
+        dtype = self._dtype(x, dtype=dtype, dtype_first=True)
+        state = self._get_state(seed)
+        res = state.binomial(1, p=x).astype(dtype)
+        return (res.astype(dtype),)
diff --git a/onnx/reference/ops/op_bitcast.py b/onnx/reference/ops/op_bitcast.py
new file mode 100644
index 0000000..18c1a0b
--- /dev/null
+++ b/onnx/reference/ops/op_bitcast.py
@@ -0,0 +1,29 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.reference.op_run import OpRun
+
+
+class BitCast(OpRun):
+    def _run(self, x, to: int):  # type: ignore[override]
+        if to == onnx.TensorProto.STRING:
+            raise ValueError("BitCast to STRING is not supported")
+        if x.dtype == np.str_:
+            raise ValueError("BitCast from STRING is not supported")
+
+        target_dtype = onnx.helper.tensor_dtype_to_np_dtype(to)
+
+        if x.dtype.itemsize != np.dtype(target_dtype).itemsize:
+            raise ValueError(
+                f"BitCast requires input and output types to have the same "
+                f"bit-width, but got {x.dtype} ({x.dtype.itemsize * 8} bits) "
+                f"and {target_dtype} ({np.dtype(target_dtype).itemsize * 8} bits)"
+            )
+
+        result = x.view(target_dtype)
+        return (result,)
diff --git a/onnx/reference/ops/op_bitshift.py b/onnx/reference/ops/op_bitshift.py
new file mode 100644
index 0000000..d262d0b
--- /dev/null
+++ b/onnx/reference/ops/op_bitshift.py
@@ -0,0 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryNumpy
+
+
+class BitShift(OpRunBinaryNumpy):
+    def __init__(self, onnx_node, run_params):
+        OpRunBinaryNumpy.__init__(self, np.right_shift, onnx_node, run_params)
+        if self.direction not in ("LEFT", "RIGHT"):
+            raise ValueError(f"Unexpected value for direction ({self.direction!r}).")
+        if self.direction == "LEFT":
+            self.numpy_fct = np.left_shift
diff --git a/onnx/reference/ops/op_bitwise_and.py b/onnx/reference/ops/op_bitwise_and.py
new file mode 100644
index 0000000..585dd67
--- /dev/null
+++ b/onnx/reference/ops/op_bitwise_and.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinary
+
+
+class BitwiseAnd(OpRunBinary):
+    def _run(self, x, y):
+        return (np.bitwise_and(x, y),)
diff --git a/onnx/reference/ops/op_bitwise_not.py b/onnx/reference/ops/op_bitwise_not.py
new file mode 100644
index 0000000..fc81969
--- /dev/null
+++ b/onnx/reference/ops/op_bitwise_not.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnary
+
+
+class BitwiseNot(OpRunUnary):
+    def _run(self, X):
+        return (np.bitwise_not(X),)
diff --git a/onnx/reference/ops/op_bitwise_or.py b/onnx/reference/ops/op_bitwise_or.py
new file mode 100644
index 0000000..1168839
--- /dev/null
+++ b/onnx/reference/ops/op_bitwise_or.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinary
+
+
+class BitwiseOr(OpRunBinary):
+    def _run(self, x, y):
+        return (np.bitwise_or(x, y),)
diff --git a/onnx/reference/ops/op_bitwise_xor.py b/onnx/reference/ops/op_bitwise_xor.py
new file mode 100644
index 0000000..91d442f
--- /dev/null
+++ b/onnx/reference/ops/op_bitwise_xor.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinary
+
+
+class BitwiseXor(OpRunBinary):
+    def _run(self, x, y):
+        return (np.bitwise_xor(x, y),)
diff --git a/onnx/reference/ops/op_blackman_window.py b/onnx/reference/ops/op_blackman_window.py
new file mode 100644
index 0000000..f75ca2c
--- /dev/null
+++ b/onnx/reference/ops/op_blackman_window.py
@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op_common_window import _CommonWindow
+
+
+class BlackmanWindow(_CommonWindow):
+    r"""Blankman windowing function.
+
+    Returns :math:`\\omega_n = 0.42 - 0.5 \\cos \\left( \\frac{2\\pi n}{N-1} \\right) + 0.08 \\cos \\left( \\frac{4\\pi n}{N-1} \\right)`
+    where *N* is the window length.
+
+    See `blackman_window <https://pytorch.org/docs/stable/generated/torch.blackman_window.html>`_
+    """
+
+    def _run(self, size, output_datatype=None, periodic=None):
+        ni, N_1 = np.arange(size), size
+        if periodic == 0:
+            N_1 = N_1 - 1
+        alpha = 0.42
+        beta = 0.08
+        pi = np.pi
+        y = np.cos((ni * (pi * 2)) / N_1) * (-0.5)
+        y += np.cos((ni * (pi * 4)) / N_1) * beta
+        y += alpha
+        return self._end(size, y, output_datatype)
diff --git a/onnx/reference/ops/op_cast.py b/onnx/reference/ops/op_cast.py
new file mode 100644
index 0000000..67aeaa6
--- /dev/null
+++ b/onnx/reference/ops/op_cast.py
@@ -0,0 +1,54 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx.reference.op_run import OpRun
+
+
+def cast_to(
+    x: np.ndarray, to: onnx.TensorProto.DataType, saturate: bool, round_mode: str = "up"
+):
+    if to == onnx.TensorProto.STRING:
+        return x.astype(np.str_)
+
+    dtype = onnx.helper.tensor_dtype_to_np_dtype(to)
+    if (
+        to
+        in {
+            onnx.TensorProto.FLOAT8E4M3FN,
+            onnx.TensorProto.FLOAT8E4M3FNUZ,
+            onnx.TensorProto.FLOAT8E5M2,
+            onnx.TensorProto.FLOAT8E5M2FNUZ,
+        }
+        and saturate
+    ):
+        return onnx.numpy_helper.saturate_cast(x, dtype)
+
+    if to == onnx.TensorProto.FLOAT8E8M0:
+        return onnx.numpy_helper.to_float8e8m0(x, saturate, round_mode).astype(dtype)
+
+    return x.astype(dtype)
+
+
+class Cast_1(OpRun):
+    def _run(self, x, to=None):
+        return (cast_to(x, to, saturate=True, round_mode="up"),)
+
+
+class Cast_19(OpRun):
+    def _run(self, x, to=None, saturate=None):
+        return (cast_to(x, to, saturate, round_mode="up"),)
+
+
+class Cast_24(OpRun):
+    def _run(self, x, to=None, saturate=None, round_mode=None):
+        return (cast_to(x, to, saturate, round_mode),)
+
+
+class Cast_25(OpRun):
+    def _run(self, x, to=None, saturate=None, round_mode=None):
+        return (cast_to(x, to, saturate, round_mode),)
diff --git a/onnx/reference/ops/op_cast_like.py b/onnx/reference/ops/op_cast_like.py
new file mode 100644
index 0000000..2f56a25
--- /dev/null
+++ b/onnx/reference/ops/op_cast_like.py
@@ -0,0 +1,27 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.helper import np_dtype_to_tensor_dtype
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops.op_cast import cast_to
+
+
+def _cast_like(x, y, saturate: bool):
+    return (cast_to(x, np_dtype_to_tensor_dtype(y.dtype), saturate),)
+
+
+class CastLike_15(OpRun):
+    def _run(self, x, y):
+        return _cast_like(x, y, True)
+
+
+class CastLike_19(OpRun):
+    def _run(self, x, y, saturate=False):
+        return _cast_like(x, y, saturate)
+
+
+class CastLike_25(OpRun):
+    def _run(self, x, y, saturate=False):
+        return _cast_like(x, y, saturate)
diff --git a/onnx/reference/ops/op_causal_conv_with_state.py b/onnx/reference/ops/op_causal_conv_with_state.py
new file mode 100644
index 0000000..eee1dfe
--- /dev/null
+++ b/onnx/reference/ops/op_causal_conv_with_state.py
@@ -0,0 +1,71 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops.op_conv import _conv_implementation
+
+
+class CausalConvWithState(OpRun):
+    def _run(
+        self,
+        input,
+        weight,
+        bias=None,
+        past_state=None,
+        activation=None,
+    ):
+        if activation is None:
+            activation = "none"
+        if activation not in ("none", "silu", "swish"):
+            raise ValueError(
+                f"Unsupported activation '{activation}'. "
+                "Expected one of: 'none', 'silu', 'swish'."
+            )
+
+        if input.ndim != 3:
+            raise ValueError(
+                f"input must be rank 3 (batch_size, channels, length), got shape {input.shape}."
+            )
+        if weight.ndim != 3:
+            raise ValueError(
+                f"weight must be rank 3 (channels, 1, k), got shape {weight.shape}."
+            )
+
+        batch_size, channels, _ = input.shape
+        k = weight.shape[2]
+
+        # Step 1: build the left-padded input (B, C, L + k - 1).
+        if past_state is None:
+            pad = np.zeros((batch_size, channels, k - 1), dtype=input.dtype)
+        else:
+            pad = past_state
+        padded = np.concatenate([pad, input], axis=2)
+
+        # Step 2: depthwise Conv1d (group = channels, valid padding).
+        conv_out = _conv_implementation(
+            padded,
+            weight,
+            bias,
+            "NOTSET",
+            [1],
+            channels,
+            [k],
+            [0, 0],
+            [1],
+        ).astype(input.dtype)
+
+        # Step 3: optional fused SiLU/Swish activation.
+        if activation in ("silu", "swish"):
+            sigmoid = 1.0 / (1.0 + np.exp(-conv_out.astype(np.float32)))
+            output = (conv_out.astype(np.float32) * sigmoid).astype(input.dtype)
+        else:
+            output = conv_out
+
+        # Step 4: present_state = last (k - 1) positions of the padded input.
+        present_state = padded[:, :, padded.shape[2] - (k - 1) :]
+
+        return (output, present_state)
diff --git a/onnx/reference/ops/op_ceil.py b/onnx/reference/ops/op_ceil.py
new file mode 100644
index 0000000..4e59029
--- /dev/null
+++ b/onnx/reference/ops/op_ceil.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Ceil(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.ceil(x),)
diff --git a/onnx/reference/ops/op_celu.py b/onnx/reference/ops/op_celu.py
new file mode 100644
index 0000000..c8b501a
--- /dev/null
+++ b/onnx/reference/ops/op_celu.py
@@ -0,0 +1,19 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _vcelu1(x: np.ndarray, alpha: float = 1.0) -> np.ndarray:
+    positive_input = np.maximum(0, x)
+    negative_input = np.minimum(0, alpha * (np.exp(x / alpha) - 1))
+    return positive_input + negative_input
+
+
+class Celu(OpRun):
+    def _run(self, x, alpha=None):
+        return (_vcelu1(x, alpha).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_center_crop_pad.py b/onnx/reference/ops/op_center_crop_pad.py
new file mode 100644
index 0000000..6638a16
--- /dev/null
+++ b/onnx/reference/ops/op_center_crop_pad.py
@@ -0,0 +1,50 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class CenterCropPad(OpRun):
+    def _run(self, input_data, shape, axes=None):
+        axes = axes or self.axes
+        input_rank = len(input_data.shape)
+        if axes is None:
+            axes = list(range(input_rank))
+        else:
+            axes = [axis if axis >= 0 else axis + input_rank for axis in axes]
+        pad_slices = [slice(0, s) for s in input_data.shape]
+        crop_slices = [slice(0, s) for s in input_data.shape]
+        new_shape = list(input_data.shape)
+        for a, sh in zip(axes, shape, strict=False):
+            dim = input_data.shape[a]
+            if sh == dim:
+                pass
+            elif sh < dim:
+                new_shape[a] = sh
+                d = dim - sh
+                if d % 2 == 0:
+                    d //= 2
+                    sl = slice(d, dim - d)
+                else:
+                    d //= 2
+                    sl = slice(d, dim - d - 1)
+                crop_slices[a] = sl
+            else:  # sh > dim
+                new_shape[a] = sh
+                d = sh - dim
+                if d % 2 == 0:
+                    d //= 2
+                    sl = slice(d, sh - d)
+                else:
+                    d //= 2
+                    sl = slice(d, sh - d - 1)
+                pad_slices[a] = sl
+
+        res = np.zeros(tuple(new_shape), dtype=input_data.dtype)
+        cropped = input_data[tuple(crop_slices)]
+        res[tuple(pad_slices)] = cropped
+        return (res,)
diff --git a/onnx/reference/ops/op_clip.py b/onnx/reference/ops/op_clip.py
new file mode 100644
index 0000000..6553c7f
--- /dev/null
+++ b/onnx/reference/ops/op_clip.py
@@ -0,0 +1,25 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Clip_6(OpRun):
+    def _run(self, data, min=None, max=None):  # type: ignore[override]  # noqa: A002
+        amin = min
+        amax = max
+        res = data if amin is amax is None else np.clip(data, amin, amax)
+        return (res,) if res.dtype == data.dtype else (res.astype(data.dtype),)
+
+
+class Clip_11(OpRun):
+    def _run(self, data, *minmax):
+        le = len(minmax)
+        amin = minmax[0] if le > 0 else None
+        amax = minmax[1] if le > 1 else None
+        res = data if amin is amax is None else np.clip(data, amin, amax)
+        return (res,) if res.dtype == data.dtype else (res.astype(data.dtype),)
diff --git a/onnx/reference/ops/op_col2im.py b/onnx/reference/ops/op_col2im.py
new file mode 100644
index 0000000..8733552
--- /dev/null
+++ b/onnx/reference/ops/op_col2im.py
@@ -0,0 +1,213 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops._op_common_indices import _get_indices, _is_out
+
+
+def _col2im_shape_check_2d(X, output_shape, kernel_shape, dilations, pads, strides):
+    output_height, output_width = output_shape
+    kernel_height, kernel_width = kernel_shape
+    dilation_height, dilation_width = dilations
+    stride_height, stride_width = strides
+
+    ndim = len(X.shape)
+    if not (
+        (ndim == 2 and X.shape[0] != 0 and X.shape[1] != 0)
+        or (ndim == 3 and X.shape[1] != 0 and X.shape[2] != 0)
+    ):
+        raise ValueError(
+            "Expected 2D or 3D (batch mode) tensor for input with possibly 0 batch size and non-zero dimensions for input."
+        )
+
+    batch_dim = 0 if len(X.shape) == 3 else -1
+    n_input_plane = X.shape[batch_dim + 1]
+
+    if n_input_plane % (kernel_width * kernel_height) != 0:
+        raise ValueError(
+            f"Expected size of input's dimension 1 to be divisible by the "
+            f"product of kernel_size, but got input.size(1)={n_input_plane} "
+            f"and kernel_size={kernel_shape}."
+        )
+
+    input_length = X.shape[batch_dim + 2]
+    n_blocks_height = (
+        output_height + pads[0, :].sum() - dilation_height * (kernel_height - 1) - 1
+    ) // stride_height + 1
+    n_blocks_width = (
+        output_width + pads[1, :].sum() - dilation_width * (kernel_width - 1) - 1
+    ) // stride_width + 1
+
+    if input_length != (n_blocks_height * n_blocks_width):
+        raise ValueError(
+            f"Given batch_dim={batch_dim}, n_input_plane={n_input_plane}, X.shape={X.shape}, "
+            f"output_shape={output_shape}, kernel_shape={kernel_shape}, "
+            f"dilations={dilations}, pads={pads}, strides={strides}, "
+            f"expected size of input's dimension 2 to match the calculated number of ",
+            f"sliding blocks {n_blocks_height} * {n_blocks_width} = {n_blocks_height * n_blocks_width}, "
+            f"but got input.size(2)={input_length}.",
+        )
+
+    if not (n_blocks_height >= 1 and n_blocks_width >= 1):
+        raise ValueError(
+            f"Given batch_dim={batch_dim}, n_input_plane={n_input_plane}, X.shape={X.shape}, "
+            f"output_shape={output_shape}, kernel_shape={kernel_shape}, "
+            f"dilations={dilations}, pads={pads}, strides={strides}, "
+            f"calculated shape of the array of sliding blocks as ({n_blocks_height}, {n_blocks_width}), "
+            f"which is too small (non-positive)."
+        )
+
+
+def _col2im_naive_implementation_2d(
+    res, image_shape, kernel_shape, dilations, pads, strides
+):
+    # source: https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/im2col.h
+
+    n_dims = len(pads) // 2
+    new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
+    _col2im_shape_check_2d(res, image_shape, kernel_shape, dilations, new_pads, strides)
+
+    data_col = res.ravel()
+    data_im = np.zeros(image_shape, dtype=res.dtype).flatten()
+
+    kernel_h, kernel_w = kernel_shape
+    channels_col = kernel_h * kernel_w
+    stride_h, stride_w = strides
+    dilation_h, dilation_w = dilations
+    pad_h, pad_w = new_pads[:, 0]
+    height, width = image_shape
+    output_height, output_width = image_shape
+
+    height_col = (
+        output_height + new_pads[0, :].sum() - (dilation_h * (kernel_h - 1) + 1)
+    ) // stride_h + 1
+    width_col = (
+        output_width + new_pads[1, :].sum() - (dilation_w * (kernel_w - 1) + 1)
+    ) // stride_w + 1
+
+    for c_col in range(channels_col):
+        w_offset = c_col % kernel_w
+        h_offset = (c_col // kernel_w) % kernel_h
+        c_im = c_col // (kernel_h * kernel_w)
+
+        for h_col in range(height_col):
+            h_im = h_col * stride_h - pad_h + h_offset * dilation_h
+            for w_col in range(width_col):
+                w_im = w_col * stride_w - pad_w + w_offset * dilation_w
+                if 0 <= h_im < height and 0 <= w_im < width:
+                    i_im = (c_im * height + h_im) * width + w_im
+                    i_col = (c_col * height_col + h_col) * width_col + w_col
+                    if 0 <= i_col < data_col.shape[0]:
+                        data_im[i_im] += data_col[i_col]
+
+    return data_im.reshape(image_shape)
+
+
+def _col2im_shape_check(X, output_shape, kernel_shape, dilations, pads, strides):
+    n_input_plane = X.shape[0]
+
+    kernel_size = np.prod(kernel_shape)
+
+    if n_input_plane % kernel_size != 0:
+        raise ValueError(
+            f"Expected size of input's dimension 1 to be divisible by the "
+            f"product of kernel_size={kernel_size}, "
+            f"but got input.size(1)={n_input_plane} "
+            f"and kernel_shape={kernel_shape}, X.shape={X.shape}, output_shape={output_shape}."
+        )
+
+    input_length = X.shape[1]
+    n_dims = len(output_shape)
+    n_blocks = []
+    for i in range(n_dims):
+        n_block = (
+            output_shape[i]
+            + pads[i, :].sum()
+            - dilations[i] * (kernel_shape[i] - 1)
+            - 1
+        ) // strides[i] + 1
+        n_blocks.append(n_block)
+
+    block_size = np.prod(n_blocks)
+    if input_length != block_size:
+        raise ValueError(
+            f"Given n_input_plane={n_input_plane}, X.shape={X.shape}, "
+            f"output_shape={output_shape}, kernel_shape={kernel_shape}, "
+            f"dilations={dilations}, pads={pads}, strides={strides}, "
+            f"expected size of input's dimension 2 to match the calculated number of "
+            f"sliding blocks {n_blocks} = {block_size}, "
+            f"but got input.size(2)={input_length}.",
+        )
+
+
+def col2im_naive_implementation(
+    data, image_shape, kernel_shape, dilations, pads, strides
+):
+    """Naive implementation for `col2im`."""
+    n_dims = len(pads) // 2
+    new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
+    _col2im_shape_check(data, image_shape, kernel_shape, dilations, new_pads, strides)
+
+    data_col = data
+    data_im = np.zeros(image_shape, dtype=data.dtype)
+
+    dim_col = []
+    for i in range(n_dims):
+        col = (
+            image_shape[i]
+            + new_pads[i, :].sum()
+            - (dilations[i] * (kernel_shape[i] - 1) + 1)
+        ) // strides[i] + 1
+        dim_col.append(col)
+
+    kernel_size = np.prod(kernel_shape)
+    col_size = np.prod(dim_col)
+    for c_col in range(kernel_size):
+        offset = _get_indices(c_col, kernel_shape)
+
+        for col in range(col_size):
+            ind_col = _get_indices(col, dim_col)
+            ind_im = []
+            for i in range(n_dims):
+                ind = (
+                    ind_col[i] * strides[i] - new_pads[i, 0] + offset[i] * dilations[i]
+                )
+                ind_im.append(ind)
+
+            if not _is_out(ind_im, data_im.shape):
+                data_im[tuple(ind_im)] += data_col[c_col, col]
+
+    return data_im
+
+
+class Col2Im(OpRun):
+    def _run(
+        self, data, image_shape, block_shape, dilations=None, pads=None, strides=None
+    ):
+        if dilations is None:
+            dilations = [1 for s in image_shape]
+        if pads is None:
+            pads = [0 for s in image_shape] * 2
+        if strides is None:
+            strides = [1 for s in image_shape]
+
+        bl = np.prod(block_shape, dtype=np.int64)
+        C = data.shape[1] // bl
+        data = data.reshape((*data.shape[:1], C, bl, *data.shape[2:]))
+
+        ks = tuple(block_shape)
+        res = None
+        for n in range(data.shape[0]):
+            for c in range(data.shape[1]):
+                out = col2im_naive_implementation(
+                    data[n, c, ...], image_shape, ks, dilations, pads, strides
+                )
+                if res is None:
+                    new_shape = data.shape[:2] + out.shape
+                    res = np.empty(new_shape, dtype=data.dtype)
+                res[n, c, ...] = out
+        return (res,)
diff --git a/onnx/reference/ops/op_compress.py b/onnx/reference/ops/op_compress.py
new file mode 100644
index 0000000..a1a88f4
--- /dev/null
+++ b/onnx/reference/ops/op_compress.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Compress(OpRun):
+    def _run(self, x, condition, axis=None):
+        return (np.compress(condition, x, axis=axis),)
diff --git a/onnx/reference/ops/op_concat.py b/onnx/reference/ops/op_concat.py
new file mode 100644
index 0000000..2576a25
--- /dev/null
+++ b/onnx/reference/ops/op_concat.py
@@ -0,0 +1,22 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Concat(OpRun):
+    def _preprocess(self, a: np.ndarray, axis: int) -> np.ndarray:
+        if len(a.shape) == 0:
+            raise RuntimeError(f"Concat: one input has an empty shape: {a!r}.")
+        if axis >= len(a.shape):
+            new_shape = a.shape + (1,) * (axis + 1 - len(a.shape))
+            return a.reshape(new_shape)
+        return a
+
+    def _run(self, *args, axis=None):
+        targs = tuple(self._preprocess(a, axis) for a in args)
+        return (np.concatenate(targs, axis),)
diff --git a/onnx/reference/ops/op_concat_from_sequence.py b/onnx/reference/ops/op_concat_from_sequence.py
new file mode 100644
index 0000000..b5242b3
--- /dev/null
+++ b/onnx/reference/ops/op_concat_from_sequence.py
@@ -0,0 +1,31 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _concat_from_sequence(seq: list[Any], axis: int, new_axis: int = 0) -> np.ndarray:
+    if new_axis == 1:
+        if axis == -1:
+            seq2 = [s[..., np.newaxis] for s in seq]
+            res = np.concatenate(seq2, axis=-1)
+        else:
+            seq2 = [np.expand_dims(s, axis) for s in seq]
+            res = np.concatenate(seq2, axis=axis)
+    else:
+        res = np.concatenate(seq, axis=axis)
+    return res
+
+
+class ConcatFromSequence(OpRun):
+    def _run(self, seq, axis=None, new_axis=None):
+        if seq is None:
+            raise RuntimeError("A sequence cannot be null.")
+        res = _concat_from_sequence(seq, axis, new_axis=new_axis)
+        return (res,)
diff --git a/onnx/reference/ops/op_constant.py b/onnx/reference/ops/op_constant.py
new file mode 100644
index 0000000..2a3d31b
--- /dev/null
+++ b/onnx/reference/ops/op_constant.py
@@ -0,0 +1,119 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun, RefAttrName
+
+
+def _check_dtype(val):
+    dtype = val.dtype
+    if not isinstance(dtype, np.dtype):
+        raise TypeError(
+            f"Type ({dtype}, {type(dtype)}) is not a numpy type (operator 'Constant')"
+        )
+
+
+class ConstantCommon(OpRun):
+    def _check(self, cst):
+        if isinstance(cst, tuple):
+            raise TypeError(f"Unexpected type {type(cst)} for a constant.")
+        return cst
+
+
+class Constant_1(ConstantCommon):
+    def __init__(self, onnx_node, run_params):
+        ConstantCommon.__init__(self, onnx_node, run_params)
+        self.cst = self.value
+        _check_dtype(self.cst)
+
+    def _run(self, **overridden_attributes):
+        if overridden_attributes and (
+            len(overridden_attributes) > 1
+            or "value" not in overridden_attributes
+            or id(overridden_attributes["value"]) != id(self.value)
+        ):
+            raise RuntimeError(
+                "Function attributes are not implemented for opset <= 11. Use opset > 12."
+            )
+        return (self._check(self.cst),)
+
+
+class Constant_9(Constant_1):
+    def __init__(self, onnx_node, run_params):
+        Constant_1.__init__(self, onnx_node, run_params)
+
+
+class Constant_11(ConstantCommon):
+    def __init__(self, onnx_node, run_params):
+        ConstantCommon.__init__(self, onnx_node, run_params)
+        if getattr(self, "sparse_value", None) is None:
+            self.cst = self.value
+        else:
+            self.cst = self.sparse_value
+        _check_dtype(self.cst)
+
+    def _run(self, **overridden_attributes):
+        if overridden_attributes and (
+            len(overridden_attributes) > 1
+            or "value" not in overridden_attributes
+            or id(overridden_attributes["value"]) != id(self.value)
+        ):
+            raise RuntimeError(
+                "Function attributes are not implemented for opset <= 11. Use opset > 12."
+            )
+        return (self._check(self.cst),)
+
+
+class Constant_12(ConstantCommon):
+    def __init__(self, onnx_node, run_params):
+        ConstantCommon.__init__(self, onnx_node, run_params)
+        if hasattr(self, "sparse_value") and self.sparse_value is not None:
+            self.cst_name = "sparse_value"
+            self.cst = self.sparse_value
+            self.cst_convert = lambda v: v
+        elif hasattr(self, "value") and self.value is not None:
+            self.cst_name = "value"
+            self.cst = self.value
+            self.cst_convert = lambda v: v
+        else:
+            for attr, np_dtype in {
+                "value_float": np.float32,
+                "value_floats": np.float32,
+                "value_int": np.int64,
+                "value_ints": np.int64,
+                "value_string": np.str_,
+                "value_strings": np.str_,
+            }.items():
+                if hasattr(self, attr) and getattr(self, attr) is not None:
+                    self.cst_name = attr
+                    v = getattr(self, attr)
+                    self.cst = (
+                        v if isinstance(v, RefAttrName) else np.array(v, dtype=np_dtype)
+                    )
+                    self.cst_convert = lambda v, np_dtype=np_dtype: np.array(
+                        v, dtype=np_dtype
+                    )
+                    break
+        if not hasattr(self, "cst_name"):
+            raise AttributeError(
+                f"No constant is defined for operator 'Constant', outputs are {onnx_node.output}."
+            )
+
+    def _run(self, **overridden_attributes):
+        if self.has_linked_attribute:
+            if overridden_attributes is None:
+                raise RuntimeError(
+                    f"Attributes are empty, cannot retrieve value for {self.cst!r}."
+                )
+            if self.cst_name not in overridden_attributes:
+                raise RuntimeError(
+                    f"Cannot find attribute {self.cst_name!r} in {list(overridden_attributes)!r}."
+                )
+            value = overridden_attributes[self.cst_name]
+            if isinstance(value, np.ndarray):
+                return (value,)
+            return (self.cst_convert(value),)
+        return (self._check(self.cst),)
diff --git a/onnx/reference/ops/op_constant_of_shape.py b/onnx/reference/ops/op_constant_of_shape.py
new file mode 100644
index 0000000..0c93641
--- /dev/null
+++ b/onnx/reference/ops/op_constant_of_shape.py
@@ -0,0 +1,29 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class ConstantOfShape(OpRun):
+    def _run(self, data, value: np.array | None = None):
+        if self.value is None:
+            value = np.array(0, dtype=np.float32)
+        else:
+            if self.value.size != 1:
+                raise ValueError(
+                    f"Operator ConstantOfShape ({self.onnx_node.name!r}) expects a single element tensor as value, but the size of 'value' is {len(self.value)}."
+                )
+            value = self.value.flat[0]
+
+        try:
+            res = np.full(tuple(data), value)
+        except TypeError as e:
+            raise RuntimeError(
+                f"Unable to create a constant of shape {data!r} with value {value!r} "
+                f"(raw value={self.value!r})."
+            ) from e
+        return (res,)
diff --git a/onnx/reference/ops/op_conv.py b/onnx/reference/ops/op_conv.py
new file mode 100644
index 0000000..b73cff2
--- /dev/null
+++ b/onnx/reference/ops/op_conv.py
@@ -0,0 +1,316 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _conv_implementation(
+    X, W, B, auto_pad, dilations, group, kernel_shape, pads, strides
+):
+    if dilations is None:
+        dilations = [1 for s in X.shape[2:]]
+    if kernel_shape is None:
+        kernel_shape = W.shape[2:]
+    if pads is None:
+        pads = [0 for s in X.shape[2:]] * 2
+    if strides is None:
+        strides = [1 for s in X.shape[2:]]
+
+    if X.shape[1] != W.shape[1] * group or W.shape[0] % group != 0:
+        raise ValueError(
+            f"Shape inconsistencies, X.shape={X.shape}, W.shape={W.shape}, group={group}, "
+            f"W should be {(W.shape[0], X.shape[1] // group, np.prod(W.shape[1:]) // X.shape[1] * group)}."
+        )
+    if group > 1:
+        res = []
+        td = 0
+        mg = W.shape[0] // group
+        dw = W.shape[1]
+
+        for b in range(X.shape[0]):
+            for g in range(group):
+                gx = X[b : b + 1, g * dw : (g + 1) * dw]
+                gw = W[g * mg : (g + 1) * mg]
+                try:
+                    cv = _conv_implementation(
+                        gx,
+                        gw,
+                        None,
+                        auto_pad,
+                        dilations,
+                        1,
+                        kernel_shape,
+                        pads,
+                        strides,
+                    )
+                except (ValueError, RuntimeError) as e:
+                    raise ValueError(
+                        f"Shape inconsistencies, X.shape={X.shape}, W.shape={W.shape}, group={g}/{group}, "
+                        f"gx.shape={gx.shape}, gw.shape={gw.shape}, auto_pad={auto_pad}, "
+                        f"dilations={dilations}, kernel_shape={kernel_shape}, pads={pads}, "
+                        f"strides={strides}."
+                    ) from e
+                if b == 0:
+                    td += cv.shape[1]
+                res.append((b, cv))
+
+        new_shape = [X.shape[0], *list(res[0][1].shape[1:])]
+        new_shape[1] = td
+        final = np.zeros(tuple(new_shape), dtype=res[0][1].dtype)
+        p = 0
+        for b, cv in res:
+            final[b : b + 1, p : p + cv.shape[1]] = cv
+            p += cv.shape[1]
+            if p >= final.shape[1]:
+                p = 0
+        if B is not None:
+            new_shape = [1 for s in final.shape]
+            new_shape[1] = B.shape[0]
+            b = B.reshape(tuple(new_shape))
+            final += b
+        return final
+
+    if dilations[0] != 1 or min(dilations) != max(dilations):
+        # Let's compute the dilated kernel.
+        nd = len(dilations)
+        new_kernel_shape = []
+        new_shape = list(W.shape[:-nd])
+        for i, d in enumerate(dilations):
+            di = len(W.shape) - nd + i
+            new_shape.append(W.shape[di] + (W.shape[di] - 1) * (d - 1))
+            new_kernel_shape.append(kernel_shape[i] + (kernel_shape[i] - 1) * (d - 1))
+        new_w = np.zeros(tuple(new_shape), dtype=W.dtype)
+        indices = [slice(0, new_w.shape[0]), slice(0, new_w.shape[1])]
+        for i, d in enumerate(dilations):
+            di = len(W.shape) - nd + i
+            indices.append(slice(0, new_w.shape[di], d))
+        new_w[tuple(indices)] = W
+        W = new_w
+        kernel_shape = new_kernel_shape
+
+    if auto_pad in {"SAME_LOWER", "SAME_UPPER", "VALID"}:
+        head = []
+        tail = []
+        for i in range(len(X.shape) - 2):
+            d = X.shape[i]
+            target_size = (d + strides[i] - 1) // strides[i]
+            pad_needed = (target_size - 1) * strides[i] + kernel_shape[i] - d
+            if auto_pad == "SAME_LOWER":
+                pad_head = (pad_needed + 1) // 2
+            else:
+                pad_head = pad_needed // 2
+            pad_tail = pad_needed - pad_head
+            head.append(pad_head)
+            tail.append(pad_tail)
+        pads = head + tail
+
+    if len(X.shape) == 3:
+        sN, sC, sH = X.shape
+        # M, C_group, kH, kW = W.shape
+        (kh,) = kernel_shape
+        (sth,) = strides
+
+        h_out = int(((sH - kh + pads[0] + pads[1]) / sth) + 1)
+
+        h0 = pads[0]
+        oh = -1 * (kh % 2)
+        bh = -h0
+        eh = h_out * sth
+        res = np.zeros((X.shape[0], W.shape[0], h_out))  # type: ignore[assignment]
+        if B is not None:
+            res[:, :, :] += B.reshape((1, -1, 1))
+
+        for n in range(sN):
+            for nw in range(W.shape[0]):
+                for c in range(sC):
+                    w = W[nw : nw + 1, c : c + 1]
+                    for io in range(bh, eh, sth):
+                        hr = (io - bh) // sth
+                        if hr >= h_out:
+                            continue
+                        i = io + kh % 2
+                        ih1, ih2 = max(0, i + oh), min(i + oh + kh, sH)
+                        img = X[n : n + 1, c : c + 1, ih1:ih2]
+                        if img.shape != w.shape:
+                            jh1, jh2 = max(-oh - i, 0), min(kh, kh + sH - (i + oh + kh))
+                            w_ = w[:1, :1, jh1:jh2]
+                            if img.shape != w_.shape:
+                                raise RuntimeError(
+                                    f"Unexpected shape {img.shape} != {w_.shape}, oh={oh}, "
+                                    f"i={i}, kh={kh}, sH={sH}, sth={sth}."
+                                )
+                            s = np.dot(img.reshape((1, -1)), w_.reshape((-1, 1)))[
+                                0, 0
+                            ]  # (img * w_).sum()
+                        else:
+                            s = np.dot(img.reshape((1, -1)), w.reshape((-1, 1)))[
+                                0, 0
+                            ]  # (img * w).sum()
+                        res[n, nw, hr] += s
+
+        return res
+
+    if len(X.shape) == 4:
+        sN, sC, sH, sW = X.shape
+        # M, C_group, kH, kW = W.shape
+        kh, kw = kernel_shape
+        sth, stw = strides
+
+        h_out = int(((sH - kh + pads[0] + pads[2]) / sth) + 1)
+        w_out = int(((sW - kw + pads[1] + pads[3]) / stw) + 1)
+
+        h0, w0 = pads[0], pads[1]
+        oh, ow = -1 * (kh % 2), -1 * (kw % 2)
+        bh, bw = -h0, -w0
+        eh, ew = h_out * sth, w_out * stw
+        res = np.zeros((X.shape[0], W.shape[0], h_out, w_out))  # type: ignore[assignment]
+        if B is not None:
+            res[:, :, :, :] = B.reshape((1, -1, 1, 1))
+
+        for n in range(sN):
+            for nw in range(W.shape[0]):
+                for c in range(sC):
+                    w = W[nw : nw + 1, c : c + 1]
+                    for io in range(bh, eh, sth):
+                        hr = (io - bh) // sth
+                        if hr >= h_out:
+                            continue
+                        i = io + kh % 2
+                        ih1, ih2 = max(0, i + oh), min(i + oh + kh, sH)
+                        for jo in range(bw, ew, stw):
+                            wr = (jo - bw) // stw
+                            if wr >= w_out:
+                                continue
+                            j = jo + kw % 2
+                            iw1, iw2 = max(0, j + ow), min(j + ow + kw, sW)
+                            img = X[n : n + 1, c : c + 1, ih1:ih2, iw1:iw2]
+                            if img.shape != w.shape:
+                                jh1, jh2 = (
+                                    max(-oh - i, 0),
+                                    min(kh, kh + sH - (i + oh + kh)),
+                                )
+                                jw1, jw2 = (
+                                    max(-ow - j, 0),
+                                    min(kw, kw + sW - (j + ow + kw)),
+                                )
+                                w_ = w[:1, :1, jh1:jh2, jw1:jw2]
+                                if img.shape != w_.shape:
+                                    raise RuntimeError(
+                                        f"Unexpected shape {img.shape} != {w_.shape}, oh={oh}, ow={ow}, "
+                                        f"i={i}, j={j}, kh={kh}, kw={kw}, sH={sH}, sW={sW}, sth={sth}, stw={stw}."
+                                    )
+                                s = np.dot(img.reshape((1, -1)), w_.reshape((-1, 1)))[
+                                    0, 0
+                                ]  # (img * w_).sum()
+                            else:
+                                s = np.dot(img.reshape((1, -1)), w.reshape((-1, 1)))[
+                                    0, 0
+                                ]  # (img * w).sum()
+                            res[n, nw, hr, wr] += s
+
+        return res
+
+    if len(X.shape) == 5:
+        sN, sC, sH, sW, sZ = X.shape
+        kh, kw, kz = kernel_shape
+        sth, stw, stz = strides
+
+        h_out = int(((sH - kh + pads[0] + pads[3]) / sth) + 1)
+        w_out = int(((sW - kw + pads[1] + pads[4]) / stw) + 1)
+        z_out = int(((sZ - kz + pads[2] + pads[5]) / stz) + 1)
+
+        h0, w0, z0 = pads[0], pads[1], pads[2]
+        oh, ow, oz = -1 * (kh % 2), -1 * (kw % 2), -1 * (kz % 2)
+        bh, bw, bz = -h0, -w0, -z0
+        eh, ew, ez = h_out * sth, w_out * stw, z_out * stz
+        res = np.zeros((X.shape[0], W.shape[0], h_out, w_out, z_out))  # type: ignore[assignment]
+        if B is not None:
+            res[:, :, :, :, :] = B.reshape((1, -1, 1, 1, 1))
+
+        for n in range(sN):
+            for nw in range(W.shape[0]):
+                for c in range(sC):
+                    w = W[nw : nw + 1, c : c + 1]
+                    for io in range(bh, eh, sth):
+                        hr = (io - bh) // sth
+                        if hr >= h_out:
+                            continue
+                        i = io + kh % 2
+                        ih1, ih2 = max(0, i + oh), min(i + oh + kh, sH)
+                        for jo in range(bw, ew, stw):
+                            wr = (jo - bw) // stw
+                            if wr >= w_out:
+                                continue
+                            j = jo + kw % 2
+                            iw1, iw2 = max(0, j + ow), min(j + ow + kw, sW)
+                            for zo in range(bz, ez, stz):
+                                zr = (zo - bz) // stz
+                                if zr >= z_out:
+                                    continue
+                                z = zo + kz % 2
+                                iz1, iz2 = max(0, z + oz), min(z + oz + kz, sZ)
+                                img = X[n : n + 1, c : c + 1, ih1:ih2, iw1:iw2, iz1:iz2]
+                                if img.shape != w.shape:
+                                    jh1, jh2 = (
+                                        max(-oh - i, 0),
+                                        min(kh, kh + sH - (i + oh + kh)),
+                                    )
+                                    jw1, jw2 = (
+                                        max(-ow - j, 0),
+                                        min(kw, kw + sW - (j + ow + kw)),
+                                    )
+                                    jz1, jz2 = (
+                                        max(-oz - z, 0),
+                                        min(kz, kz + sZ - (z + oz + kz)),
+                                    )
+                                    w_ = w[:1, :1, jh1:jh2, jw1:jw2, jz1:jz2]
+                                    if img.shape != w_.shape:
+                                        raise RuntimeError(
+                                            f"Unexpected shape {img.shape} != {w_.shape}, oh={oh}, ow={ow}, oz={oz}, "
+                                            f"i={i}, j={j}, z={z}, kh={kh}, kw={kw}, kz={kz}, "
+                                            f"sH={sH}, sW={sW}, sZ={sZ}, sth={sth}, stw={stw}, stz={stz}."
+                                        )
+                                    s = np.dot(
+                                        img.reshape((1, -1)), w_.reshape((-1, 1))
+                                    )[0, 0]  # (img * w_).sum()
+                                else:
+                                    s = np.dot(
+                                        img.reshape((1, -1)), w.reshape((-1, 1))
+                                    )[0, 0]  # (img * w).sum()
+                                res[n, nw, hr, wr, zr] += s
+
+        return res
+
+    raise RuntimeError(
+        f"The convolution for X.shape={X.shape}, W.shape={W.shape}, "
+        f"kernel_shape={kernel_shape} is not implemented yet."
+    )
+
+
+class Conv(OpRun):
+    def _run(
+        self,
+        X,
+        W,
+        B=None,
+        auto_pad=None,
+        dilations=None,
+        group=None,
+        kernel_shape=None,
+        pads=None,
+        strides=None,
+    ):
+        if len(X.shape) < 3:
+            raise ValueError(
+                f"X must have at least 3 dimensions but its shape is {X.shape}."
+            )
+        return (
+            # _conv_implementation(
+            _conv_implementation(
+                X, W, B, auto_pad, dilations, group, kernel_shape, pads, strides
+            ).astype(X.dtype),
+        )
diff --git a/onnx/reference/ops/op_conv_integer.py b/onnx/reference/ops/op_conv_integer.py
new file mode 100644
index 0000000..9475e87
--- /dev/null
+++ b/onnx/reference/ops/op_conv_integer.py
@@ -0,0 +1,52 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops.op_conv import _conv_implementation
+
+
+class ConvInteger(OpRun):
+    def _run(
+        self,
+        X,
+        W,
+        x_zero_point=None,
+        w_zero_point=None,
+        auto_pad=None,
+        dilations=None,
+        group=None,
+        kernel_shape=None,
+        pads=None,
+        strides=None,
+    ):
+        if len(X.shape) < 3:
+            raise ValueError(
+                f"X must have at least 3 dimensions but its shape is {X.shape}."
+            )
+        auto_pad = auto_pad or self.auto_pad
+        dilations = dilations or self.dilations
+        group = group or self.group
+        kernel_shape = kernel_shape or self.kernel_shape
+        pads = pads or self.pads
+        strides = strides or self.strides
+
+        X = X.astype(np.int32)
+        if x_zero_point is not None:
+            X -= x_zero_point
+        W = W.astype(np.int32)
+        if w_zero_point is not None:
+            W -= (
+                w_zero_point
+                if w_zero_point.ndim == 0
+                else np.expand_dims(w_zero_point, (1, 2, 3))
+            )
+
+        return (
+            _conv_implementation(
+                X, W, None, auto_pad, dilations, group, kernel_shape, pads, strides
+            ).astype(np.int32),
+        )
diff --git a/onnx/reference/ops/op_conv_transpose.py b/onnx/reference/ops/op_conv_transpose.py
new file mode 100644
index 0000000..1acd482
--- /dev/null
+++ b/onnx/reference/ops/op_conv_transpose.py
@@ -0,0 +1,139 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops.op_col2im import col2im_naive_implementation
+
+
+class ConvTranspose(OpRun):
+    def _run(
+        self,
+        X,
+        W,
+        B=None,
+        auto_pad=None,
+        dilations=None,
+        group=None,
+        kernel_shape=None,
+        output_padding=None,
+        output_shape=None,
+        pads=None,
+        strides=None,
+    ):
+        if dilations is None:
+            dilations = [1 for s in X.shape[2:]]
+        if kernel_shape is None:
+            kernel_shape = W.shape[2:]
+        if output_padding is None:
+            output_padding = [0 for s in X.shape[2:]] * 2
+        if strides is None:
+            strides = [1 for s in X.shape[2:]]
+        if pads is None and auto_pad not in {"SAME_UPPER", "SAME_LOWER"}:
+            pads = [0 for i in range(2 * len(strides))]
+        if pads is None:
+            if output_shape is None:
+                output_shape = [
+                    X.shape[i + 2] * strides[i] for i in range(len(strides))
+                ]
+            total_padding = [
+                strides[i] * (X.shape[i + 2] - 1)
+                + output_padding[i]
+                + ((kernel_shape[i] - 1) * dilations[i] + 1)
+                - output_shape[i]
+                for i in range(len(output_shape))
+            ]
+            pads_1 = []
+            pads_2 = []
+            for i in range(len(output_shape)):
+                if auto_pad == "SAME_UPPER":
+                    pads_1.append(total_padding[i] // 2)
+                    pads_2.append(total_padding[i] - (total_padding[i] // 2))
+                else:
+                    pads_1.append(total_padding[i] - (total_padding[i] // 2))
+                    pads_2.append(total_padding[i] // 2)
+            pads = pads_1 + pads_2
+            n_dims = len(pads) // 2
+        else:
+            n_dims = len(X.shape) - 2
+            new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
+            if output_shape is None:
+                output_shape = [
+                    strides[i] * (X.shape[i + 2] - 1)
+                    + output_padding[i]
+                    + ((kernel_shape[i] - 1) * dilations[i] + 1)
+                    - new_pads[i, :].sum()
+                    for i in range(n_dims)
+                ]
+
+        kernel_shape = W.shape[2:]
+        kernel_size = np.prod(kernel_shape)
+        num_output_channels = W.shape[1] * group
+        kernel_dim = num_output_channels // group * kernel_size
+
+        C = X.shape[1]  # num_inputs_channels
+        m = kernel_dim  # kernel_dim
+        n = np.prod(X.shape[2:])  # input_image_size
+        k = C // group
+        w_reshaped = W.reshape((group, k, m))
+        final = None
+
+        # N x C x H x W = X.shape
+        # C x M/group x k1 x k2 = W.shape
+        if group == 1:
+            for image_id in range(X.shape[0]):
+                w_t = w_reshaped[0].T
+                gemm = np.matmul(w_t, X[image_id].reshape((k, n)))
+                gemmc = gemm.reshape((num_output_channels, -1, gemm.shape[-1]))
+                for c in range(num_output_channels):
+                    res = col2im_naive_implementation(
+                        gemmc[c], output_shape, kernel_shape, dilations, pads, strides
+                    )
+                    if final is None:
+                        final = np.empty(
+                            (*X.shape[:1], num_output_channels, *res.shape),
+                            dtype=X.dtype,
+                        )
+                    if B is not None:
+                        res += B[c]
+                    final[image_id, c, ...] = res[...]
+        else:
+            final = np.zeros((X.shape[0], num_output_channels, *output_shape))
+            output_array = []
+
+            for group_id in range(group):
+                group_X = X[:, group_id * C // group : (group_id + 1) * C // group, ...]
+                group_W = W[
+                    group_id * num_output_channels // group : (group_id + 1)
+                    * num_output_channels
+                    // group,
+                    ...,
+                ]
+
+                group_output = self._run(
+                    group_X,
+                    group_W,
+                    B=B,
+                    auto_pad=auto_pad,
+                    dilations=dilations,
+                    group=1,
+                    kernel_shape=kernel_shape,
+                    output_padding=output_padding,
+                    output_shape=output_shape,
+                    pads=pads,
+                    strides=strides,
+                )
+                group_output = np.array(group_output[0])
+                output_array.append(group_output)
+
+            for image_id in range(X.shape[0]):
+                for group_id in range(group):
+                    group_output = output_array[group_id]
+                    final[image_id, group_id : (group_id + 1), ...] = group_output[
+                        image_id, ...
+                    ]
+
+        return (final.astype(X.dtype),)  # type: ignore[union-attr]
diff --git a/onnx/reference/ops/op_cos.py b/onnx/reference/ops/op_cos.py
new file mode 100644
index 0000000..d32a18d
--- /dev/null
+++ b/onnx/reference/ops/op_cos.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Cos(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.cos(x),)
diff --git a/onnx/reference/ops/op_cosh.py b/onnx/reference/ops/op_cosh.py
new file mode 100644
index 0000000..0143b46
--- /dev/null
+++ b/onnx/reference/ops/op_cosh.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Cosh(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.cosh(x),)
diff --git a/onnx/reference/ops/op_cum_prod.py b/onnx/reference/ops/op_cum_prod.py
new file mode 100644
index 0000000..e57794d
--- /dev/null
+++ b/onnx/reference/ops/op_cum_prod.py
@@ -0,0 +1,31 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class CumProd(OpRun):
+    def _run(self, x, axis, exclusive=None, reverse=None):
+        axis = np.asarray(axis)
+        if axis.ndim != 0:
+            raise ValueError(f"Axis must be a rank-0 tensor, got `{axis.ndim}`.")
+        if reverse:
+            rev_indices = [slice(0, s) for s in x.shape]
+            rev_indices[axis] = slice(None, None, -1)
+            x = x[tuple(rev_indices)]
+        if exclusive:
+            indices_c = [slice(0, s) for s in x.shape]
+            indices_d = [slice(0, s) for s in x.shape]
+            indices_c[axis] = slice(0, -1)
+            indices_d[axis] = slice(1, x.shape[axis])
+            res = np.ones(x.shape, dtype=x.dtype)
+            np.cumprod(x[tuple(indices_c)], axis=axis, out=res[tuple(indices_d)])
+        else:
+            res = np.cumprod(x, axis=axis, dtype=x.dtype)
+        if reverse:
+            res = res[tuple(rev_indices)]
+        return (res,)
diff --git a/onnx/reference/ops/op_cum_sum.py b/onnx/reference/ops/op_cum_sum.py
new file mode 100644
index 0000000..de1e47c
--- /dev/null
+++ b/onnx/reference/ops/op_cum_sum.py
@@ -0,0 +1,31 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class CumSum(OpRun):
+    def _run(self, x, axis, exclusive=None, reverse=None):
+        axis = np.asarray(axis)
+        if axis.ndim != 0:
+            raise ValueError(f"Axis must be a rank-0 tensor, got `{axis.ndim}`.")
+        if reverse:
+            rev_indices = [slice(0, s) for s in x.shape]
+            rev_indices[axis] = slice(None, None, -1)
+            x = x[tuple(rev_indices)]
+        if exclusive:
+            indices_c = [slice(0, s) for s in x.shape]
+            indices_d = [slice(0, s) for s in x.shape]
+            indices_c[axis] = slice(0, -1)
+            indices_d[axis] = slice(1, x.shape[axis])
+            res = np.zeros(x.shape, dtype=x.dtype)
+            np.cumsum(x[tuple(indices_c)], axis=axis, out=res[tuple(indices_d)])
+        else:
+            res = np.cumsum(x, axis=axis, dtype=x.dtype)
+        if reverse:
+            res = res[tuple(rev_indices)]
+        return (res,)
diff --git a/onnx/reference/ops/op_deform_conv.py b/onnx/reference/ops/op_deform_conv.py
new file mode 100644
index 0000000..e29ba25
--- /dev/null
+++ b/onnx/reference/ops/op_deform_conv.py
@@ -0,0 +1,181 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops import op_grid_sample
+
+
+def _deform_conv_implementation(
+    X, W, offset, B, mask, dilations, group, kernel_shape, offset_group, pads, strides
+):
+    if dilations is None:
+        dilations = [1 for s in X.shape[2:]]
+    if kernel_shape is None:
+        kernel_shape = W.shape[2:]
+    if pads is None:
+        pads = [0 for s in X.shape[2:]] * 2
+    if strides is None:
+        strides = [1 for s in X.shape[2:]]
+    if group is None:
+        group = 1
+    if offset_group is None:
+        offset_group = 1
+
+    n, ic = X.shape[:2]
+    oc = W.shape[0]
+    output_shape = offset.shape[2:]
+
+    if ic != W.shape[1] * group or oc % group != 0:
+        raise ValueError(
+            f"Shape inconsistencies, X.shape={X.shape}, W.shape={W.shape}, group={group}."
+        )
+    ics_per_group, ocs_per_group = W.shape[1], oc // group
+
+    if ic % offset_group != 0:
+        raise ValueError("Number of input channels must be divisible by offset_group.")
+    ics_per_offset_group = ic // offset_group
+
+    if (
+        offset_group * np.prod(kernel_shape, dtype=np.int64) * len(kernel_shape)
+        != offset.shape[1]
+    ):
+        raise ValueError(
+            f"Offset shape {offset.shape} is inconsistent with offset_group {offset_group} "
+            f"and kernel shape {kernel_shape}."
+        )
+    offset = offset.reshape(
+        (n, offset_group, *kernel_shape, len(kernel_shape), *output_shape)
+    )
+
+    if mask is None:
+        mask = np.ones(
+            (n, offset_group * np.prod(kernel_shape, dtype=np.int64), *output_shape)
+        )
+    mask = mask.reshape((n, offset_group, *kernel_shape, *output_shape))
+
+    if len(X.shape) == 4:
+        ih, iw = X.shape[2:]
+        oh, ow = offset.shape[-2:]
+        kh, kw = kernel_shape
+        sth, stw = strides
+        dh, dw = dilations
+        kh_new, kw_new = (kh - 1) * dh + 1, (kw - 1) * dw + 1
+
+        if oh != int(((ih - kh_new + pads[0] + pads[2]) / sth) + 1) or ow != int(
+            ((iw - kw_new + pads[1] + pads[3]) / stw) + 1
+        ):
+            raise RuntimeError(
+                "Padding, dilation, stride, and kernel shape incompatible with output shape."
+            )
+
+        bh, bw = -pads[0], -pads[1]
+
+        res = np.zeros((n, oc, oh, ow), dtype=X.dtype)
+        if B is not None:
+            res[:, :, :, :] = B.reshape((1, -1, 1, 1))
+
+        # Calculate coordinates of sampling points within kernel
+        kernel_pos_w, kernel_pos_h = np.meshgrid(
+            np.arange(0, kw_new, dw), np.arange(0, kh_new, dh)
+        )
+        kernel_pos_wrt_first_elem = np.stack(
+            (kernel_pos_h, kernel_pos_w), axis=2
+        )  # shape (kH, kW, 2)
+
+        for batch_idx in range(n):
+            for oc_idx in range(oc):
+                for ic_idx in range(ic):
+                    # Group convolution logic
+                    if ic_idx // ics_per_group != oc_idx // ocs_per_group:
+                        # Input channel and output channel don't belong to same group
+                        continue
+
+                    # Offset group logic
+                    offset_group_idx = ic_idx // ics_per_offset_group
+
+                    for i in range(oh):
+                        h_coord = bh + sth * i
+                        for j in range(ow):
+                            w_coord = bw + stw * j
+                            # (h_coord, w_coord) is coord of top left elem of kernel
+
+                            kernel = np.copy(kernel_pos_wrt_first_elem).astype(float)
+                            kernel[:, :, 0] += (
+                                h_coord
+                                + offset[batch_idx, offset_group_idx, :, :, 0, i, j]
+                            )
+                            kernel[:, :, 1] += (
+                                w_coord
+                                + offset[batch_idx, offset_group_idx, :, :, 1, i, j]
+                            )
+
+                            # GridSample expects normalized grid coordinates
+                            kernel[:, :, 0] = kernel[:, :, 0] / (ih - 1) * 2 - 1
+                            kernel[:, :, 1] = kernel[:, :, 1] / (iw - 1) * 2 - 1
+
+                            kernel = np.expand_dims(kernel, 0)  # add batch dimension
+                            kernel = np.flip(
+                                kernel, 3
+                            )  # spatial GridSample expects (x, y) input
+                            grid_sample_output = op_grid_sample.GridSample.eval(
+                                X[batch_idx : batch_idx + 1, ic_idx : ic_idx + 1],
+                                kernel,
+                                align_corners=1,
+                            )
+
+                            conv_value = np.multiply(
+                                grid_sample_output,
+                                W[oc_idx, ic_idx % ics_per_group, :, :],
+                            )
+                            conv_value = np.multiply(
+                                conv_value,
+                                mask[batch_idx, offset_group_idx, :, :, i, j],
+                            )
+                            res[batch_idx, oc_idx, i, j] += np.sum(conv_value)
+
+        return res
+
+    raise RuntimeError(
+        f"The convolution for X.shape={X.shape}, W.shape={W.shape}, "
+        f"kernel_shape={kernel_shape} is not implemented yet."
+    )
+
+
+class DeformConv(OpRun):
+    def _run(
+        self,
+        X,
+        W,
+        offset,
+        B=None,
+        mask=None,
+        dilations=None,
+        group=None,
+        kernel_shape=None,
+        offset_group=None,
+        pads=None,
+        strides=None,
+    ):
+        if len(X.shape) < 3:
+            raise ValueError(
+                f"X must have at least 3 dimensions but its shape is {X.shape}."
+            )
+        return (
+            _deform_conv_implementation(
+                X,
+                W,
+                offset,
+                B,
+                mask,
+                dilations,
+                group,
+                kernel_shape,
+                offset_group,
+                pads,
+                strides,
+            ),
+        )
diff --git a/onnx/reference/ops/op_depth_to_space.py b/onnx/reference/ops/op_depth_to_space.py
new file mode 100644
index 0000000..bac5c95
--- /dev/null
+++ b/onnx/reference/ops/op_depth_to_space.py
@@ -0,0 +1,46 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class DepthToSpace(OpRun):
+    def _run(self, data, blocksize=None, mode=None):
+        if len(data.shape) != 4:
+            raise RuntimeError(f"Unexpected shape {data.shape!r}.")
+        b, c, h, w = data.shape
+        if mode == "DCR":
+            tmpshape = (
+                b,
+                blocksize,
+                blocksize,
+                c // (blocksize * blocksize),
+                h,
+                w,
+            )
+            reshaped = data.reshape(tmpshape)
+            transposed = np.transpose(reshaped, [0, 3, 4, 1, 5, 2])
+        else:
+            # assert mode == "CRD"
+            tmpshape = (
+                b,
+                c // (blocksize * blocksize),
+                blocksize,
+                blocksize,
+                h,
+                w,
+            )
+            reshaped = data.reshape(tmpshape)
+            transposed = np.transpose(reshaped, [0, 1, 4, 2, 5, 3])
+        finalshape = (
+            b,
+            c // (blocksize * blocksize),
+            h * blocksize,
+            w * blocksize,
+        )
+        y = np.reshape(transposed, finalshape)
+        return (y,)
diff --git a/onnx/reference/ops/op_dequantize_linear.py b/onnx/reference/ops/op_dequantize_linear.py
new file mode 100644
index 0000000..0f1072e
--- /dev/null
+++ b/onnx/reference/ops/op_dequantize_linear.py
@@ -0,0 +1,91 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx import TensorProto
+from onnx.helper import np_dtype_to_tensor_dtype, tensor_dtype_to_np_dtype
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops._quant_utils import reshape_input as _reshape_input
+
+
+class _CommonDequantizeLinear(OpRun):
+    def _run(
+        self,
+        x: np.ndarray,
+        x_scale: np.ndarray,
+        x_zero_point: np.ndarray | None = None,
+        axis: int = 1,
+        block_size: int = 0,
+        output_dtype: int | None = None,
+    ):
+        x_type = np_dtype_to_tensor_dtype(x.dtype)
+        fp8_type = x_type in {
+            TensorProto.FLOAT8E4M3FN,
+            TensorProto.FLOAT8E4M3FNUZ,
+            TensorProto.FLOAT8E5M2,
+            TensorProto.FLOAT8E5M2FNUZ,
+        }
+        if (
+            x_zero_point is not None
+            and not fp8_type
+            and x_type != TensorProto.FLOAT4E2M1
+        ):
+            zero_type = np_dtype_to_tensor_dtype(x_zero_point.dtype)
+            if x_type != zero_type:
+                raise ValueError(
+                    f"Type mismatch {x_type} != {zero_type} in DequantizeLinear."
+                )
+
+            dx = x.astype(np.float32) - _reshape_input(
+                x_zero_point, x.shape, axis, block_size
+            )
+        else:
+            if fp8_type and x_zero_point is not None:
+                u_x_zero_point = x_zero_point.astype(np.uint8)
+                umi = u_x_zero_point.min()
+                uma = u_x_zero_point.max()
+                if umi != uma or umi != np.uint8(0):
+                    raise ValueError(
+                        "x_zero_point is not null but should be zero for float8 types."
+                    )
+            dx = x.astype(np.float32)
+        y = dx * _reshape_input(x_scale, x.shape, axis, block_size)
+        return (
+            y.astype(
+                tensor_dtype_to_np_dtype(output_dtype)
+                if output_dtype
+                else x_scale.dtype
+            ),
+        )
+
+
+class DequantizeLinear_19(_CommonDequantizeLinear):
+    def _run(self, x, x_scale, x_zero_point=None, axis: int = 1):
+        if len(x_scale.shape) > 1:
+            raise ValueError("Input 2 must be a vector or a number.")
+        return super()._run(x, x_scale, x_zero_point, axis)
+
+
+class DequantizeLinear_21(_CommonDequantizeLinear):
+    def _run(self, *args, axis: int = 1, block_size: int = 0):
+        # args: x, y_scale, zero_point
+        return super()._run(*args, axis=axis, block_size=block_size)
+
+
+class DequantizeLinear_23(_CommonDequantizeLinear):
+    def _run(self, *args, axis: int = 1, block_size: int = 0, output_dtype=None):
+        # args: x, y_scale, zero_point
+        return super()._run(
+            *args, axis=axis, block_size=block_size, output_dtype=output_dtype
+        )
+
+
+class DequantizeLinear_25(_CommonDequantizeLinear):
+    def _run(self, *args, axis: int = 1, block_size: int = 0, output_dtype=None):
+        # args: x, y_scale, zero_point
+        return super()._run(
+            *args, axis=axis, block_size=block_size, output_dtype=output_dtype
+        )
diff --git a/onnx/reference/ops/op_det.py b/onnx/reference/ops/op_det.py
new file mode 100644
index 0000000..b76649d
--- /dev/null
+++ b/onnx/reference/ops/op_det.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Det(OpRun):
+    def _run(self, x):
+        return (np.array(np.linalg.det(x)),)
diff --git a/onnx/reference/ops/op_dft.py b/onnx/reference/ops/op_dft.py
new file mode 100644
index 0000000..ed3e568
--- /dev/null
+++ b/onnx/reference/ops/op_dft.py
@@ -0,0 +1,146 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _fft(x: np.ndarray, fft_length: int, axis: int) -> np.ndarray:
+    """Compute the FFT return the real representation of the complex result."""
+    transformed = np.fft.fft(x, n=fft_length, axis=axis)
+    real_frequencies = np.real(transformed)
+    imaginary_frequencies = np.imag(transformed)
+    return np.concatenate(
+        (real_frequencies[..., np.newaxis], imaginary_frequencies[..., np.newaxis]),
+        axis=-1,
+    )
+
+
+def _cfft(
+    x: np.ndarray,
+    fft_length: int,
+    axis: int,
+    onesided: bool,
+    normalize: bool,
+) -> np.ndarray:
+    if x.shape[-1] == 1:
+        # The input contains only the real part
+        signal = x
+    else:
+        # The input is a real representation of a complex signal
+        slices = [slice(0, x) for x in x.shape]
+        slices[-1] = slice(0, x.shape[-1], 2)
+        real = x[tuple(slices)]
+        slices[-1] = slice(1, x.shape[-1], 2)
+        imag = x[tuple(slices)]
+        signal = real + 1j * imag
+
+    complex_signals = np.squeeze(signal, -1)
+    result = _fft(complex_signals, fft_length, axis=axis)
+    # Post process the result based on arguments
+    if onesided:
+        slices = [slice(0, a) for a in result.shape]
+        slices[axis] = slice(0, result.shape[axis] // 2 + 1)
+        result = result[tuple(slices)]
+    if normalize:
+        result /= fft_length
+    return result
+
+
+def _ifft(x: np.ndarray, fft_length: int, axis: int) -> np.ndarray:
+    """Standard IFFT: complex input -> complex output."""
+    signals = np.fft.ifft(x, n=fft_length, axis=axis)
+    real_signals = np.real(signals)
+    imaginary_signals = np.imag(signals)
+    return np.concatenate(
+        (real_signals[..., np.newaxis], imaginary_signals[..., np.newaxis]),
+        axis=-1,
+    )
+
+
+def _irfft(x: np.ndarray, fft_length: int, axis: int) -> np.ndarray:
+    """IRFFT: one-sided complex input -> full real output."""
+    signals = np.fft.irfft(x, n=fft_length, axis=axis)
+    # Return real-valued output with last dimension = 1
+    return signals[..., np.newaxis]
+
+
+def _cifft(
+    x: np.ndarray, fft_length: int, axis: int, onesided: bool = False
+) -> np.ndarray:
+    """Complex IFFT wrapper that handles both standard IFFT and IRFFT."""
+    # Extract complex values from input
+    if x.shape[-1] == 1:
+        # Real input (shouldn't happen for IFFT, but handle it)
+        frequencies = np.squeeze(x, -1)
+    else:
+        # Complex input: interleaved real/imaginary
+        slices = [slice(0, dim) for dim in x.shape]
+        slices[-1] = slice(0, x.shape[-1], 2)
+        real = x[tuple(slices)]
+        slices[-1] = slice(1, x.shape[-1], 2)
+        imag = x[tuple(slices)]
+        frequencies = np.squeeze(real, -1) + 1j * np.squeeze(imag, -1)
+
+    if onesided:
+        # IRFFT: one-sided complex input -> full real output
+        return _irfft(frequencies, fft_length, axis=axis)
+    # Standard IFFT: full complex input -> full complex output
+    return _ifft(frequencies, fft_length, axis=axis)
+
+
+class DFT_17(OpRun):
+    def _run(
+        self,
+        x: np.ndarray,
+        dft_length: int | None = None,
+        axis: int = 1,
+        inverse: bool = False,
+        onesided: bool = False,
+    ) -> tuple[np.ndarray]:
+        # Convert to positive axis
+        axis = axis % len(x.shape)
+
+        # Set default dft_length based on operation type
+        if dft_length is None:
+            if inverse and onesided:
+                # IRFFT: input is one-sided, default to even length
+                dft_length = 2 * (x.shape[axis] - 1)
+            else:
+                dft_length = x.shape[axis]
+
+        if inverse:
+            result = _cifft(x, dft_length, axis=axis, onesided=onesided)
+        else:
+            result = _cfft(x, dft_length, axis=axis, onesided=onesided, normalize=False)
+        return (result.astype(x.dtype),)
+
+
+class DFT_20(OpRun):
+    def _run(
+        self,
+        x: np.ndarray,
+        dft_length: int | None = None,
+        axis: int = -2,
+        inverse: bool = False,
+        onesided: bool = False,
+    ) -> tuple[np.ndarray]:
+        # Convert to positive axis
+        axis = axis % len(x.shape)
+
+        # Set default dft_length based on operation type
+        if dft_length is None:
+            if inverse and onesided:
+                # IRFFT: input is one-sided, default to even length
+                dft_length = 2 * (x.shape[axis] - 1)
+            else:
+                dft_length = x.shape[axis]
+
+        if inverse:
+            result = _cifft(x, dft_length, axis=axis, onesided=onesided)
+        else:
+            result = _cfft(x, dft_length, axis=axis, onesided=onesided, normalize=False)
+        return (result.astype(x.dtype),)
diff --git a/onnx/reference/ops/op_div.py b/onnx/reference/ops/op_div.py
new file mode 100644
index 0000000..bfe96d7
--- /dev/null
+++ b/onnx/reference/ops/op_div.py
@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryNumpy
+
+
+class Div(OpRunBinaryNumpy):
+    def __init__(self, onnx_node, run_params):
+        def func(x, y):
+            if issubclass(x.dtype.type, np.integer):
+                assert issubclass(y.dtype.type, np.integer)
+                # Truncate toward zero for integer division (C++-style).
+                # Keep integer math to avoid precision loss for large values.
+                q = np.floor_divide(x, y)
+                r = np.remainder(x, y)
+                needs_adjust = (r != 0) & ((x < 0) ^ (y < 0))
+                return q + needs_adjust.astype(q.dtype)
+            return np.divide(x, y)
+
+        OpRunBinaryNumpy.__init__(self, func, onnx_node, run_params)
+
+    def _run(self, a, b):
+        res = OpRunBinaryNumpy._run(self, a, b)
+        if res[0].dtype != a.dtype:
+            return (res[0].astype(a.dtype),)
+        return res
diff --git a/onnx/reference/ops/op_dropout.py b/onnx/reference/ops/op_dropout.py
new file mode 100644
index 0000000..66284e5
--- /dev/null
+++ b/onnx/reference/ops/op_dropout.py
@@ -0,0 +1,66 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+from numpy.random import RandomState
+
+from onnx.reference.op_run import OpRun
+
+
+def _dropout(
+    X: np.ndarray,
+    drop_probability: float = 0.5,
+    seed: int | None = None,
+    training_mode: bool = False,
+    return_mask: bool = False,
+) -> tuple[np.ndarray]:
+    if drop_probability == 0 or not training_mode:
+        if return_mask:
+            return X, np.ones(X.shape, dtype=bool)
+        return (X,)
+
+    rnd = RandomState(seed)
+    mask = rnd.uniform(0, 1.0, X.shape) >= drop_probability
+    scale = 1.0 / (1.0 - drop_probability)
+    return (mask * X * scale, mask.astype(bool)) if return_mask else (mask * X * scale,)
+
+
+class DropoutBase(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        self.n_outputs = len(onnx_node.output)
+
+    def _private_run(
+        self,
+        X: np.ndarray,
+        seed: int | None = None,
+        ratio: float = 0.5,
+        training_mode: bool = False,
+    ) -> tuple[np.ndarray]:
+        return _dropout(
+            X,
+            ratio,
+            seed=seed,
+            return_mask=self.n_outputs == 2,
+            training_mode=training_mode,
+        )
+
+
+class Dropout_7(DropoutBase):
+    def _run(self, X, ratio=None):
+        return self._private_run(X, ratio)
+
+
+class Dropout_12(DropoutBase):
+    def _run(self, *inputs, seed=None):
+        X = inputs[0]
+        ratio = 0.5 if len(inputs) <= 1 else inputs[1]
+        training_mode = False if len(inputs) <= 2 else inputs[2]
+        return self._private_run(
+            X,
+            seed=seed,
+            ratio=ratio,
+            training_mode=training_mode,
+        )
diff --git a/onnx/reference/ops/op_dynamic_quantize_linear.py b/onnx/reference/ops/op_dynamic_quantize_linear.py
new file mode 100644
index 0000000..2d072f7
--- /dev/null
+++ b/onnx/reference/ops/op_dynamic_quantize_linear.py
@@ -0,0 +1,32 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class DynamicQuantizeLinear(OpRun):
+    def _run(self, x):
+        # args: x, y_scale, zero_point
+        dtype, qmin, qmax = np.uint8, 0, 255
+        maxx = np.float32(np.maximum(0, np.max(x)))
+        minx = np.float32(np.minimum(0, np.min(x)))
+        y_scale = np.float32(1.0 if maxx == minx else (maxx - minx)) / np.float32(
+            qmax - qmin
+        )
+
+        # scale = max == min ? 1.0f : (max - min) / float(qmax - qmin);
+
+        initial_zero_point = np.float32(qmin) - minx / y_scale
+        zp = max(qmin, min(qmax, initial_zero_point))
+        zpi = np.rint(zp)
+
+        y = np.clip(np.rint(x / y_scale) + zpi, qmin, qmax)
+        return (
+            y.astype(dtype),
+            np.array(y_scale.astype(x.dtype)),
+            np.array(zpi.astype(dtype)),
+        )
diff --git a/onnx/reference/ops/op_einsum.py b/onnx/reference/ops/op_einsum.py
new file mode 100644
index 0000000..15f908b
--- /dev/null
+++ b/onnx/reference/ops/op_einsum.py
@@ -0,0 +1,21 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Einsum(OpRun):
+    def _run(self, *args, equation=None):
+        if not isinstance(equation, str):
+            raise TypeError(f"equation must be string but is {type(equation)!r}.")
+        equation = equation.strip()
+        if not equation:
+            raise TypeError("equation is empty.")
+        try:
+            return (np.einsum(equation, *args, optimize=True),)
+        except TypeError:
+            return (np.einsum(equation, *args),)
diff --git a/onnx/reference/ops/op_elu.py b/onnx/reference/ops/op_elu.py
new file mode 100644
index 0000000..8c6d8cb
--- /dev/null
+++ b/onnx/reference/ops/op_elu.py
@@ -0,0 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Elu(OpRunUnaryNum):
+    def _run(self, x, alpha=None):
+        alpha = alpha or self.alpha
+        return (np.where(x > 0, x, alpha * (np.exp(x) - 1)).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_equal.py b/onnx/reference/ops/op_equal.py
new file mode 100644
index 0000000..f1afbe7
--- /dev/null
+++ b/onnx/reference/ops/op_equal.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryComparison
+
+
+class Equal(OpRunBinaryComparison):
+    def _run(self, a, b):
+        return (np.equal(a, b),)
diff --git a/onnx/reference/ops/op_erf.py b/onnx/reference/ops/op_erf.py
new file mode 100644
index 0000000..fc41ec5
--- /dev/null
+++ b/onnx/reference/ops/op_erf.py
@@ -0,0 +1,19 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from math import erf
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Erf(OpRunUnaryNum):
+    def __init__(self, onnx_node, run_params):
+        OpRunUnaryNum.__init__(self, onnx_node, run_params)
+        self._erf = np.vectorize(erf, otypes=["f"])
+
+    def _run(self, x):
+        return (self._erf(x).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_exp.py b/onnx/reference/ops/op_exp.py
new file mode 100644
index 0000000..6ed1854
--- /dev/null
+++ b/onnx/reference/ops/op_exp.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Exp(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.exp(x).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_expand.py b/onnx/reference/ops/op_expand.py
new file mode 100644
index 0000000..3008b2e
--- /dev/null
+++ b/onnx/reference/ops/op_expand.py
@@ -0,0 +1,18 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def common_reference_implementation(data: np.ndarray, shape: np.ndarray) -> np.ndarray:
+    ones = np.ones(shape, dtype=data.dtype)
+    return data * ones
+
+
+class Expand(OpRun):
+    def _run(self, data, shape):
+        return (common_reference_implementation(data, shape),)
diff --git a/onnx/reference/ops/op_eyelike.py b/onnx/reference/ops/op_eyelike.py
new file mode 100644
index 0000000..97ebca7
--- /dev/null
+++ b/onnx/reference/ops/op_eyelike.py
@@ -0,0 +1,31 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.helper import tensor_dtype_to_np_dtype
+from onnx.onnx_pb import TensorProto
+from onnx.reference.op_run import OpRun
+
+
+class EyeLike(OpRun):
+    def _run(self, data, *args, dtype=None, k=None):  # noqa: ARG002
+        if dtype is None:
+            if data is None:
+                _dtype = np.float32
+            else:
+                _dtype = data.dtype
+        elif dtype == TensorProto.STRING:
+            _dtype = np.str_  # type: ignore[assignment]
+        else:
+            _dtype = tensor_dtype_to_np_dtype(dtype)  # type: ignore[assignment]
+        shape = data.shape
+        if len(shape) == 1:
+            sh = (shape[0], shape[0])
+        elif len(shape) == 2:
+            sh = shape
+        else:
+            raise RuntimeError(f"EyeLike only accept 1D or 2D tensors not {shape!r}.")
+        return (np.eye(*sh, k=k, dtype=_dtype),)
diff --git a/onnx/reference/ops/op_flatten.py b/onnx/reference/ops/op_flatten.py
new file mode 100644
index 0000000..40392bf
--- /dev/null
+++ b/onnx/reference/ops/op_flatten.py
@@ -0,0 +1,16 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnary
+
+
+class Flatten(OpRunUnary):
+    def _run(self, x, axis=None):
+        i = axis or self.axis
+        shape = x.shape
+        new_shape = (1, -1) if i == 0 else (np.prod(shape[:i]).astype(int), -1)
+        return (x.reshape(new_shape),)
diff --git a/onnx/reference/ops/op_floor.py b/onnx/reference/ops/op_floor.py
new file mode 100644
index 0000000..f43e9b6
--- /dev/null
+++ b/onnx/reference/ops/op_floor.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Floor(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.floor(x),)
diff --git a/onnx/reference/ops/op_gather.py b/onnx/reference/ops/op_gather.py
new file mode 100644
index 0000000..8a4b4f2
--- /dev/null
+++ b/onnx/reference/ops/op_gather.py
@@ -0,0 +1,23 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Gather(OpRun):
+    def _run(self, x, indices, axis=None):
+        if not x.flags["C_CONTIGUOUS"]:
+            x = np.ascontiguousarray(x)
+        if not indices.flags["C_CONTIGUOUS"]:
+            indices = indices.ascontiguousarray()
+        if indices.size == 0:
+            return (np.empty((0,), dtype=x.dtype),)
+        try:
+            return (np.take(x, indices, axis=axis),)
+        except TypeError:
+            # distribution x86 requires int32.
+            return (np.take(x, indices.astype(int), axis=axis),)
diff --git a/onnx/reference/ops/op_gather_elements.py b/onnx/reference/ops/op_gather_elements.py
new file mode 100644
index 0000000..c2c0222
--- /dev/null
+++ b/onnx/reference/ops/op_gather_elements.py
@@ -0,0 +1,47 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def gather_numpy_2(self: np.ndarray, index: np.ndarray) -> np.ndarray:
+    res = []
+    for a, b in zip(self, index, strict=True):
+        res.append(a[b[0]])
+    return np.array(res, dtype=self.dtype).reshape(index.shape)
+
+
+def gather_numpy(self: np.ndarray, dim: int, index: np.ndarray) -> np.ndarray:
+    idx_xsection_shape = index.shape[:dim] + index.shape[dim + 1 :]
+    self_xsection_shape = self.shape[:dim] + self.shape[dim + 1 :]
+    if idx_xsection_shape != self_xsection_shape:
+        raise ValueError(
+            f"Except for dimension {dim!r}, all dimensions of "
+            f"index and self should be the same size."
+        )
+    data_swapped = np.swapaxes(self, 0, dim)
+    index_swapped = np.swapaxes(index, 0, dim)
+
+    try:
+        gathered = np.choose(index_swapped, data_swapped, mode="wrap")
+    except ValueError:
+        if len(index_swapped.shape) == 2 and len(data_swapped.shape) == 2:
+            return gather_numpy_2(self, index)
+        raise  # pragma: no cover
+
+    return np.swapaxes(gathered, 0, dim)
+
+
+class GatherElements(OpRun):
+    def _run(self, data, indices, axis=None):
+        if indices.size == 0:
+            return (np.empty((0,), dtype=data.dtype),)
+        try:
+            return (gather_numpy(data, axis, indices),)
+        except TypeError:
+            # distribution x86 requires int32.
+            return (gather_numpy(data, axis, indices.astype(int)),)
diff --git a/onnx/reference/ops/op_gathernd.py b/onnx/reference/ops/op_gathernd.py
new file mode 100644
index 0000000..ab3cb82
--- /dev/null
+++ b/onnx/reference/ops/op_gathernd.py
@@ -0,0 +1,58 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _gather_nd_impl(
+    data: np.ndarray, indices: np.ndarray, batch_dims: int
+) -> tuple[np.ndarray]:
+    # Note the data rank - will be reused multiple times later
+    data_rank = len(data.shape)
+
+    # The list of data/indice shape of batch_dims.
+    batch_dims_shape = []
+
+    # The number of elements in the batch_dims for data/indice array.
+    batch_dims_size = 1
+
+    # Check the shape of indice and data are identical for batch dims.
+    for i in range(batch_dims):
+        batch_dims_shape.append(indices.shape[i])
+        batch_dims_size *= indices.shape[i]
+
+    # Compute output of the op as below.
+    # Compute shape of output array.
+    output_shape = (
+        batch_dims_shape + list(indices.shape)[batch_dims:-1]
+        if (indices.shape[-1] == data_rank - batch_dims)
+        else batch_dims_shape
+        + list(indices.shape)[batch_dims:-1]
+        + list(data.shape)[batch_dims + indices.shape[-1] :]
+    )
+
+    # Placeholder for output data.
+    output_data_buffer = []
+
+    # Flatten 'indices' to 2D array.
+    reshaped_indices = indices.reshape(batch_dims_size, -1, indices.shape[-1])
+
+    # Flatten 'data' to array of shape
+    # (batch_dim_size, data.shape[batch_dimes:]).
+    reshaped_data = data.reshape((batch_dims_size, *data.shape[batch_dims:]))
+
+    # Gather each scalar value from 'data'.
+    for batch_dim in range(reshaped_indices.shape[0]):
+        for outer_dim in range(reshaped_indices.shape[1]):
+            gather_index = tuple(reshaped_indices[batch_dim][outer_dim])
+            output_data_buffer.append(reshaped_data[(batch_dim, *gather_index)])
+    return (np.asarray(output_data_buffer, dtype=data.dtype).reshape(output_shape),)
+
+
+class GatherND(OpRun):
+    def _run(self, data, indices, batch_dims=None):
+        return _gather_nd_impl(data, indices, batch_dims)
diff --git a/onnx/reference/ops/op_gemm.py b/onnx/reference/ops/op_gemm.py
new file mode 100644
index 0000000..f9513c9
--- /dev/null
+++ b/onnx/reference/ops/op_gemm.py
@@ -0,0 +1,77 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _gemm00(a, b, c, alpha, beta):
+    o = np.dot(a, b) * alpha
+    if c is not None and beta != 0:
+        o += c * beta
+    return o
+
+
+def _gemm01(a, b, c, alpha, beta):
+    o = np.dot(a, b.T) * alpha
+    if c is not None and beta != 0:
+        o += c * beta
+    return o
+
+
+def _gemm10(a, b, c, alpha, beta):
+    o = np.dot(a.T, b) * alpha
+    if c is not None and beta != 0:
+        o += c * beta
+    return o
+
+
+def _gemm11(a, b, c, alpha, beta):
+    o = np.dot(a.T, b.T) * alpha
+    if c is not None and beta != 0:
+        o += c * beta
+    return o
+
+
+class Gemm_6(OpRun):
+    def _run(
+        self,
+        a,
+        b,
+        c=None,
+        alpha=None,
+        beta=None,
+        transA=None,
+        transB=None,
+        broadcast=None,
+    ):
+        if broadcast == 0:
+            if transA:
+                _meth = _gemm11 if transB else _gemm10
+            else:
+                _meth = _gemm01 if transB else _gemm00
+            res = _meth(a, b, None, alpha, beta)
+            if c is None:
+                return (res.astype(a.dtype),)
+            if c.shape != res.shape:
+                raise ValueError(
+                    f"Unable to add shape {c.shape} to shape {res.shape} without broadcast."
+                )
+            return (res + c,)
+        if transA:
+            _meth = _gemm11 if transB else _gemm10
+        else:
+            _meth = _gemm01 if transB else _gemm00
+        return (_meth(a, b, c, alpha, beta).astype(a.dtype),)
+
+
+class Gemm_7(OpRun):
+    def _run(self, a, b, c=None, alpha=None, beta=None, transA=None, transB=None):
+        if transA:
+            _meth = _gemm11 if transB else _gemm10
+        else:
+            _meth = _gemm01 if transB else _gemm00
+        return (_meth(a, b, c, alpha, beta).astype(a.dtype),)
diff --git a/onnx/reference/ops/op_global_average_pool.py b/onnx/reference/ops/op_global_average_pool.py
new file mode 100644
index 0000000..487a6dd
--- /dev/null
+++ b/onnx/reference/ops/op_global_average_pool.py
@@ -0,0 +1,21 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _global_average_pool(x: np.ndarray) -> np.ndarray:
+    axis = tuple(range(2, np.ndim(x)))
+    y = np.average(x, axis=axis)
+    for _ in axis:
+        y = np.expand_dims(y, -1)
+    return y
+
+
+class GlobalAveragePool(OpRun):
+    def _run(self, x):
+        return (_global_average_pool(x).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_global_max_pool.py b/onnx/reference/ops/op_global_max_pool.py
new file mode 100644
index 0000000..7553c5b
--- /dev/null
+++ b/onnx/reference/ops/op_global_max_pool.py
@@ -0,0 +1,22 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _global_max_pool(x: np.ndarray) -> np.ndarray:
+    spatial_shape = np.ndim(x) - 2
+    y = x.max(axis=tuple(range(spatial_shape, spatial_shape + 2)))
+    for _ in range(spatial_shape):
+        y = np.expand_dims(y, -1)
+    return y
+
+
+class GlobalMaxPool(OpRun):
+    def _run(self, x):
+        res = _global_max_pool(x)
+        return (res,)
diff --git a/onnx/reference/ops/op_greater.py b/onnx/reference/ops/op_greater.py
new file mode 100644
index 0000000..f2d23d4
--- /dev/null
+++ b/onnx/reference/ops/op_greater.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryComparison
+
+
+class Greater(OpRunBinaryComparison):
+    def _run(self, a, b):
+        return (np.greater(a, b),)
diff --git a/onnx/reference/ops/op_greater_or_equal.py b/onnx/reference/ops/op_greater_or_equal.py
new file mode 100644
index 0000000..c2d0657
--- /dev/null
+++ b/onnx/reference/ops/op_greater_or_equal.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryComparison
+
+
+class GreaterOrEqual(OpRunBinaryComparison):
+    def _run(self, a, b):
+        return (np.greater_equal(a, b),)
diff --git a/onnx/reference/ops/op_grid_sample.py b/onnx/reference/ops/op_grid_sample.py
new file mode 100644
index 0000000..40c1072
--- /dev/null
+++ b/onnx/reference/ops/op_grid_sample.py
@@ -0,0 +1,365 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numbers
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops.op_resize import _get_all_coords
+
+
+class GridSample(OpRun):
+    # https://github.com/pytorch/pytorch/blob/v2.0.0/aten/src/ATen/native/GridSampler.h#L26
+    def _gs_denormalize(self, n, length: int, align_corners: bool):
+        # n is the normalized coordinate (float)
+        # x is the unormalized coordinate (float)
+        if align_corners:
+            # Align to corners
+            # x_min = 0
+            # x_max = d-1
+            # Linear mapping from [x_min, x_max] to [-1, 1]
+            # Solving linear equation n = ax + b
+            # a = 2/(d-1)
+            # b = -1
+            # n = 2/(d-1) x - 1
+            # n(d-1) = 2x - (d-1)
+            # x = (n+1)(d-1) / 2
+            x = (n + 1) / 2.0 * (length - 1)
+        else:
+            # Not align to corners
+            # x_min = -0.5
+            # x_max = d-0.5
+            # Linear mapping from [x_min, x_max] to [-1, 1]
+            # Solving linear equation n = ax + b
+            # a = 2/d
+            # b = 1/d - 1
+            # n = 2/d x + 1/d - 1
+            # nd = 2x + 1 - d
+            # x = (nd + d - 1) / 2
+            # x = ((n + 1) d - 1) / 2
+            x = ((n + 1) * length - 1) / 2.0
+        return x
+
+    def _gs_denormalize_coordinates(self, n, dims, align_corners: bool):
+        x = np.zeros(len(n), dtype=np.float32)
+        for i, (v, dim) in enumerate(zip(n, dims, strict=False)):
+            x[i] = self._gs_denormalize(n=v, length=dim, align_corners=align_corners)
+        return x
+
+    def _gs_reflect(self, x, x_min, x_max):
+        """Reflect by the near border till within the borders
+        Use float for borders to avoid potential issues with integer T
+        """
+        fx = x
+        rng = x_max - x_min
+        if fx < x_min:
+            dx = x_min - fx
+            n = int(dx / rng)
+            r = dx - n * rng
+            if n % 2 == 0:
+                fx = x_min + r
+            else:
+                fx = x_max - r
+        elif fx > x_max:
+            dx = fx - x_max
+            n = int(dx / rng)
+            r = dx - n * rng
+            if n % 2 == 0:
+                fx = x_max - r
+            else:
+                fx = x_min + r
+        return fx
+
+    def _gs_get_cubic_coeffs(self, x, coeffs):
+        """Calculate cubic convolution interpolation coefficients
+        ROBERT G. KEYS https://ieeexplore.ieee.org/document/1163711
+        Use float to avoid potential issues with integer.
+        """
+        cubic_alpha = -0.75
+        x = abs(x)
+        coeffs[0] = (
+            (cubic_alpha * (x + 1) - 5 * cubic_alpha) * (x + 1) + 8 * cubic_alpha
+        ) * (x + 1) - 4 * cubic_alpha
+        coeffs[1] = ((cubic_alpha + 2) * x - (cubic_alpha + 3)) * x * x + 1
+        coeffs[2] = ((cubic_alpha + 2) * (1 - x) - (cubic_alpha + 3)) * (1 - x) * (
+            1 - x
+        ) + 1
+        coeffs[3] = (
+            (cubic_alpha * (2 - x) - 5 * cubic_alpha) * (2 - x) + 8 * cubic_alpha
+        ) * (2 - x) - 4 * cubic_alpha
+
+    def _gs_get_linear_coeffs(self, x, coeffs):
+        x = abs(x)
+        coeffs[0] = 1 - x
+        coeffs[1] = x
+
+    def _gs_bicubic_interpolate(self, p, x, y):
+        v = np.empty((4,), dtype=p.dtype)
+        coeffs = np.empty((4,), dtype=p.dtype)
+        self._gs_get_cubic_coeffs(x, coeffs)
+        for i in range(4):
+            v[i] = coeffs @ p[i, :]
+        self._gs_get_cubic_coeffs(y, coeffs)
+        return coeffs @ v
+
+    def _gs_cubic_interpolation_1d_with_x(self, data, x, border, padding_mode):
+        v = np.empty((4,), dtype=data.dtype)
+        coeffs = np.empty((4,), dtype=data.dtype)
+        x_0 = int(np.floor(x))
+        x_1 = x_0 + 1
+        x_2 = x_0 + 2
+        x_minus_1 = x_0 - 1
+        self._gs_get_cubic_coeffs(x - x_0, coeffs)
+        v[0] = self._pixel_at_array(
+            array=data, i=x_minus_1, border=border, padding_mode=padding_mode
+        )
+        v[1] = self._pixel_at_array(
+            array=data, i=x_0, border=border, padding_mode=padding_mode
+        )
+        v[2] = self._pixel_at_array(
+            array=data, i=x_1, border=border, padding_mode=padding_mode
+        )
+        v[3] = self._pixel_at_array(
+            array=data, i=x_2, border=border, padding_mode=padding_mode
+        )
+
+        return coeffs @ v
+
+    def _gs_linear_interpolation_1d_with_x(self, data, x, border, padding_mode):
+        v = np.empty((2,), dtype=data.dtype)
+        coeffs = np.empty((2,), dtype=data.dtype)
+        x_0 = int(np.floor(x))
+        x_1 = x_0 + 1
+        self._gs_get_linear_coeffs(x - x_0, coeffs)
+        v[0] = self._pixel_at_array(
+            array=data, i=x_0, border=border, padding_mode=padding_mode
+        )
+        v[1] = self._pixel_at_array(
+            array=data, i=x_1, border=border, padding_mode=padding_mode
+        )
+
+        return coeffs @ v
+
+    def _gs_linear_interpolation_nd_with_x(self, data, x, border, padding_mode):
+        num_dims = data.ndim
+        assert num_dims == len(x) == int(len(border) / 2)
+        if num_dims == 1:
+            return self._gs_linear_interpolation_1d_with_x(
+                data=data, x=x[0], border=border, padding_mode=padding_mode
+            )
+
+        res1d = []
+        for i in range(data.shape[0]):
+            r = self._gs_linear_interpolation_nd_with_x(
+                data=data[i],
+                x=x[1:],
+                border=list(border[1:num_dims])
+                + list(border[1 + num_dims : 2 * num_dims]),
+                padding_mode=padding_mode,
+            )
+            res1d.append(r)
+        res1d = np.array(res1d)
+
+        return self._gs_linear_interpolation_1d_with_x(
+            data=res1d,
+            x=x[0],
+            border=[border[0], border[num_dims]],
+            padding_mode=padding_mode,
+        )
+
+    def _gs_cubic_interpolation_nd_with_x(self, data, x, border, padding_mode):
+        num_dims = data.ndim
+        assert num_dims == len(x) == int(len(border) / 2)
+        if num_dims == 1:
+            return self._gs_cubic_interpolation_1d_with_x(
+                data=data, x=x[0], border=border, padding_mode=padding_mode
+            )
+
+        res1d = []
+        for i in range(data.shape[0]):
+            r = self._gs_cubic_interpolation_nd_with_x(
+                data=data[i],
+                x=x[1:],
+                border=list(border[1:num_dims])
+                + list(border[1 + num_dims : 2 * num_dims]),
+                padding_mode=padding_mode,
+            )
+            res1d.append(r)
+        res1d = np.array(res1d)
+
+        return self._gs_cubic_interpolation_1d_with_x(
+            data=res1d,
+            x=x[0],
+            border=[border[0], border[num_dims]],
+            padding_mode=padding_mode,
+        )
+
+    def _clamp(self, val, lo, hi):
+        if val < lo:
+            return lo
+        if val > hi:
+            return hi
+        return val
+
+    def _pixel_at_ndarray(self, ndarray, x: list, border, padding_mode):
+        # boarder: [x_1_min, x_2_min, ..., x_1_max, x_2_max, ...]
+        num_dims = ndarray.ndim
+        assert num_dims == len(x) == int(len(border) / 2)
+        if num_dims == 1:
+            return self._pixel_at_array(
+                array=ndarray, i=x[0], border=border, padding_mode=padding_mode
+            )
+        i = x[0]
+        d = ndarray.shape[0]
+        if padding_mode == "zeros":
+            if i >= 0 and i < d:
+                ndarray = ndarray[i]
+            else:
+                # Trick
+                i = 0
+                ndarray = np.zeros_like(ndarray[i])
+        elif padding_mode == "border":
+            i = self._clamp(i, 0, d - 1)
+            ndarray = ndarray[i]
+        else:  # padding_mode == "reflection"
+            i = int(self._gs_reflect(i, border[0], border[num_dims]))
+            ndarray = ndarray[i]
+
+        return self._pixel_at_ndarray(
+            ndarray=ndarray,
+            x=x[1:],
+            border=list(border[1:num_dims]) + list(border[1 + num_dims : 2 * num_dims]),
+            padding_mode=padding_mode,
+        )
+
+    def _pixel_at_array(self, array, i: int, border, padding_mode):
+        assert array.ndim == 1
+        d = array.shape[0]
+        if padding_mode == "zeros":
+            if i >= 0 and i < d:
+                pixel = array[i]
+            else:
+                pixel = 0
+        elif padding_mode == "border":
+            i = self._clamp(i, 0, d - 1)
+            pixel = array[i]
+        else:  # padding_mode == "reflection"
+            i = int(self._gs_reflect(i, border[0], border[1]))
+            pixel = array[i]
+        return pixel
+
+    def _prepare_border(self, dims, align_corners: bool):
+        # boarder: [x_1_min, x_2_min, ..., x_1_max, x_2_max, ...]
+        num_dims = len(dims)
+        borders = np.zeros(num_dims * 2)
+        for i in range(num_dims):
+            # min
+            borders[i] = -0.5
+            # max
+            borders[i + num_dims] = dims[i] - 0.5
+            if align_corners:
+                # min
+                borders[i] = 0.0
+                # max
+                borders[i + num_dims] = dims[i] - 1.0
+
+        return borders
+
+    def _cpp_std_round(self, x):
+        # https://en.cppreference.com/w/cpp/numeric/math/round
+        def round_single_value(v):
+            if v >= 0.0:
+                return np.floor(v + 0.5)
+            return np.ceil(v - 0.5)
+
+        if isinstance(x, numbers.Number):
+            return round_single_value(x)
+        assert x.ndim == 1
+        x_rounded = np.zeros_like(x)
+        for i in range(x.shape[0]):
+            x_rounded[i] = round_single_value(x[i])
+        return x_rounded.astype(np.int32)
+
+    def _run(self, X, grid, mode=None, padding_mode=None, align_corners=None):
+        # This implementation supports GridSample arbitrary dimensions.
+
+        mode = mode or self.mode
+        padding_mode = padding_mode or self.padding_mode
+        align_corners = align_corners or self.align_corners
+
+        x_dims = X.shape
+        grid_dims = grid.shape
+        N = x_dims[0]
+        C = x_dims[1]
+        y_dims = (N, C, *grid_dims[1:-1])
+
+        if np.prod(y_dims) == 0:
+            return np.array([], dtype=X.dtype)
+
+        Y = np.empty(y_dims, dtype=X.dtype)
+
+        for n in range(N):
+            grid_data = grid[n]
+
+            for c in range(C):
+                # Because the indices in the grid_data are always in the "reverse" dimensional order.
+                # To interpolate for certain positions, we either have to transpose the X_data or
+                # reverse the indices.
+                # In this implementation, we took the latter approach.
+                X_data = X[n, c]
+
+                num_dims = len(x_dims[2:])
+                dims = x_dims[2:]
+
+                # Prepare borders.
+                border = self._prepare_border(dims, align_corners=align_corners)
+
+                for ox in _get_all_coords(Y[n, c]):
+                    # normalized coordinates.
+                    nx = grid_data[tuple(ox)]
+                    nx = nx[::-1]
+                    # denormalized coordinates.
+                    x = self._gs_denormalize_coordinates(
+                        n=nx, dims=dims, align_corners=align_corners
+                    )
+                    if mode == "nearest":
+                        # PyTorch round the index to nearest even.
+                        # https://github.com/pytorch/pytorch/pull/97000
+                        x = np.rint(x)
+                    # https://github.com/pytorch/pytorch/blob/v2.0.0/aten/src/ATen/native/GridSampler.h#L142
+                    for i, v in enumerate(x):
+                        x_min = border[i]
+                        x_max = border[i + num_dims]
+                        if v < x_min or v > x_max:
+                            if padding_mode == "border":
+                                x[i] = self._clamp(v, 0, dims[i] - 1)
+                            elif padding_mode == "reflection":
+                                x[i] = self._gs_reflect(v, x_min, x_max)
+
+                    if mode == "nearest":
+                        x = x.astype(np.int32)
+                        Y[n][c][tuple(ox)] = self._pixel_at_ndarray(
+                            ndarray=X_data,
+                            x=x,
+                            border=border,
+                            padding_mode=padding_mode,
+                        )
+
+                    elif mode == "linear":
+                        Y[n][c][tuple(ox)] = self._gs_linear_interpolation_nd_with_x(
+                            data=X_data, x=x, border=border, padding_mode=padding_mode
+                        )
+
+                    elif mode == "cubic":
+                        Y[n][c][tuple(ox)] = self._gs_cubic_interpolation_nd_with_x(
+                            data=X_data, x=x, border=border, padding_mode=padding_mode
+                        )
+                    else:
+                        raise RuntimeError(
+                            "GridSample interpolation only supports nearest, linear, and cubic modes."
+                        )
+
+        return (Y.astype(X.dtype),)
diff --git a/onnx/reference/ops/op_gru.py b/onnx/reference/ops/op_gru.py
new file mode 100644
index 0000000..a0325a9
--- /dev/null
+++ b/onnx/reference/ops/op_gru.py
@@ -0,0 +1,132 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class CommonGRU(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        self.n_outputs = len(onnx_node.output)
+        self.number_of_gates = 3
+
+    def f(self, x):
+        return 1 / (1 + np.exp(-x))
+
+    def g(self, x):
+        return np.tanh(x)
+
+    def _step(self, X, R, B, W, H_0, num_directions):
+        seq_length = X.shape[0]
+        hidden_size = H_0.shape[-1]
+        batch_size = X.shape[1]
+
+        Y = np.empty([seq_length, num_directions, batch_size, hidden_size])
+        h_list = []
+
+        [w_z, w_r, w_h] = np.split(W, 3)
+        [r_z, r_r, r_h] = np.split(R, 3)
+        [w_bz, w_br, w_bh, r_bz, r_br, r_bh] = np.split(B, 6)
+        gates_w = np.transpose(np.concatenate((w_z, w_r)))
+        gates_r = np.transpose(np.concatenate((r_z, r_r)))
+        gates_b = np.add(np.concatenate((w_bz, w_br)), np.concatenate((r_bz, r_br)))
+
+        H_t = H_0
+        for x in np.split(X, X.shape[0], axis=0):
+            gates = np.dot(x, gates_w) + np.dot(H_t, gates_r) + gates_b
+            z, r = np.split(gates, 2, -1)
+            z = self.f(z)
+            r = self.f(r)
+            h_default = self.g(
+                np.dot(x, np.transpose(w_h))
+                + np.dot(r * H_t, np.transpose(r_h))
+                + w_bh
+                + r_bh
+            )
+            h_linear = self.g(
+                np.dot(x, np.transpose(w_h))
+                + r * (np.dot(H_t, np.transpose(r_h)) + r_bh)
+                + w_bh
+            )
+            h = h_linear if self.linear_before_reset else h_default
+            H = (1 - z) * h + z * H_t
+            h_list.append(H)
+            H_t = H
+
+        concatenated = np.concatenate(h_list)
+        if num_directions == 1:
+            Y[:, 0, :, :] = concatenated
+
+        if self.layout == 0:
+            Y_h = Y[-1]
+        else:
+            Y = np.transpose(Y, [2, 0, 1, 3])
+            Y_h = Y[:, :, -1, :]
+
+        return Y, Y_h
+
+    def _run(
+        self,
+        X,
+        W,
+        R,
+        B=None,
+        sequence_lens=None,
+        initial_h=None,
+        activation_alpha=None,  # noqa: ARG002
+        activation_beta=None,  # noqa: ARG002
+        activations=None,  # noqa: ARG002
+        clip=None,  # noqa: ARG002
+        direction=None,  # noqa: ARG002
+        hidden_size=None,
+        layout=None,
+        linear_before_reset=None,  # noqa: ARG002
+    ):
+        # TODO: support overridden attributes.
+        num_directions = W.shape[0]
+
+        if num_directions == 1:
+            R = np.squeeze(R, axis=0)
+            W = np.squeeze(W, axis=0)
+            if B is not None:
+                B = np.squeeze(B, axis=0)
+            if sequence_lens is not None:
+                sequence_lens = np.squeeze(sequence_lens, axis=0)
+            if initial_h is not None:
+                initial_h = np.squeeze(initial_h, axis=0)
+
+            hidden_size = R.shape[-1]
+            batch_size = X.shape[1]
+
+            X = X if layout == 0 else np.swapaxes(X, 0, 1)
+            b = (
+                B
+                if B is not None
+                else np.zeros(2 * self.number_of_gates * hidden_size, dtype=X.dtype)
+            )
+            h_0 = (
+                initial_h
+                if initial_h is not None
+                else np.zeros((batch_size, hidden_size), dtype=X.dtype)
+            )
+
+            B = b
+            H_0 = h_0
+        else:
+            raise NotImplementedError(
+                f"Unsupported value {num_directions} for num_directions and operator "
+                f"{self.__class__.__name__!r}."
+            )
+
+        Y, Y_h = self._step(X, R, B, W, H_0, num_directions=num_directions)
+        Y = Y.astype(X.dtype)
+        return (Y,) if self.n_outputs == 1 else (Y, Y_h.astype(X.dtype))
+
+
+class GRU(CommonGRU):
+    def __init__(self, onnx_node, run_params):
+        CommonGRU.__init__(self, onnx_node, run_params)
diff --git a/onnx/reference/ops/op_hamming_window.py b/onnx/reference/ops/op_hamming_window.py
new file mode 100644
index 0000000..0eeb583
--- /dev/null
+++ b/onnx/reference/ops/op_hamming_window.py
@@ -0,0 +1,23 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op_common_window import _CommonWindow
+
+
+class HammingWindow(_CommonWindow):
+    r"""Returns :math:`\\omega_n = \\alpha - \\beta \\cos \\left( \\frac{\\pi n}{N-1} \\right)` where *N* is the window length.
+
+    See `hamming_window <https://pytorch.org/docs/stable/generated/torch.hamming_window.html>`_.
+    `alpha=0.54, beta=0.46`
+    """
+
+    def _run(self, size, output_datatype=None, periodic=None):
+        ni, N_1 = self._begin(size, periodic, output_datatype)
+        alpha = 25.0 / 46.0
+        beta = 1 - alpha
+        res = alpha - np.cos(ni * np.pi * 2 / N_1) * beta
+        return self._end(size, res, output_datatype)
diff --git a/onnx/reference/ops/op_hann_window.py b/onnx/reference/ops/op_hann_window.py
new file mode 100644
index 0000000..d7d6046
--- /dev/null
+++ b/onnx/reference/ops/op_hann_window.py
@@ -0,0 +1,20 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op_common_window import _CommonWindow
+
+
+class HannWindow(_CommonWindow):
+    r"""Returns :math:`\\omega_n = \\sin^2\\left( \\frac{\\pi n}{N-1} \\right)` where *N* is the window length.
+
+    See `hann_window <https://pytorch.org/docs/stable/generated/torch.hann_window.html>`_
+    """
+
+    def _run(self, size, output_datatype=None, periodic=None):
+        ni, N_1 = self._begin(size, periodic, output_datatype)
+        res = np.sin(ni * np.pi / N_1) ** 2
+        return self._end(size, res, output_datatype)
diff --git a/onnx/reference/ops/op_hard_sigmoid.py b/onnx/reference/ops/op_hard_sigmoid.py
new file mode 100644
index 0000000..5cf06b6
--- /dev/null
+++ b/onnx/reference/ops/op_hard_sigmoid.py
@@ -0,0 +1,16 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class HardSigmoid(OpRunUnaryNum):
+    def _run(self, x, alpha=None, beta=None):
+        alpha = alpha or self.alpha
+        beta = beta or self.beta
+        y = np.maximum(0, np.minimum(1, x * alpha + beta)).astype(x.dtype)
+        return (y,)
diff --git a/onnx/reference/ops/op_hardmax.py b/onnx/reference/ops/op_hardmax.py
new file mode 100644
index 0000000..a19e9d7
--- /dev/null
+++ b/onnx/reference/ops/op_hardmax.py
@@ -0,0 +1,24 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Hardmax(OpRunUnaryNum):
+    def _run(self, x, axis=None):
+        axis = axis or self.axis
+        if x.size == 0:
+            return (x,)
+        x_argmax = np.argmax(x, axis=axis)
+        y = np.zeros_like(x)
+        np.put_along_axis(
+            y,
+            np.expand_dims(x_argmax, axis=axis),
+            1,
+            axis=axis,
+        )
+        return (y,)
diff --git a/onnx/reference/ops/op_identity.py b/onnx/reference/ops/op_identity.py
new file mode 100644
index 0000000..bffe298
--- /dev/null
+++ b/onnx/reference/ops/op_identity.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class Identity(OpRun):
+    def _run(self, a):
+        if a is None:
+            return (None,)
+        return (a.copy(),)
diff --git a/onnx/reference/ops/op_if.py b/onnx/reference/ops/op_if.py
new file mode 100644
index 0000000..38f73fb
--- /dev/null
+++ b/onnx/reference/ops/op_if.py
@@ -0,0 +1,72 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from onnx.reference.op_run import OpRun
+
+if TYPE_CHECKING:
+    import numpy as np
+
+
+class If(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        if "opsets" not in self.run_params:
+            raise KeyError("run_params must contains key 'opsets'.")
+        if "verbose" not in run_params:
+            raise KeyError("run_params must contains key 'verbose'.")
+        if "existing_functions" not in self.run_params:
+            raise KeyError("run_params must contains key 'existing_functions'.")
+
+    def need_context(self) -> bool:
+        """Tells the runtime if this node needs the context
+        (all the results produced so far) as it may silently access
+        one of them (operator Loop).
+        The default answer is `False`.
+        """
+        return True
+
+    def _run(
+        self,
+        cond: np.ndarray | np.bool_,
+        context=None,
+        else_branch=None,  # noqa: ARG002
+        then_branch=None,  # noqa: ARG002
+        attributes=None,
+    ):
+        if cond.size != 1:
+            raise ValueError(
+                f"Operator If ({self.onnx_node.name!r}) expects a single element as condition, but the size of 'cond' is {len(cond)}."
+            )
+        cond_ = cond.item()
+        if cond_:
+            self._log("  -- then> {%r}", context)
+            outputs = self._run_then_branch(context, attributes=attributes)
+            self._log("  -- then<")
+            final = tuple(outputs)
+            branch = "then"
+        else:
+            self._log("  -- else> {%r}", context)
+            outputs = self._run_else_branch(context, attributes=attributes)
+            self._log("  -- else<")
+            final = tuple(outputs)
+            branch = "else"
+
+        if not final:
+            raise RuntimeError(
+                f"Operator If ({self.onnx_node.name!r}) does not have any output."
+            )
+        for i, f in enumerate(final):
+            if f is None:
+                br = self.then_branch if branch == "then" else self.else_branch
+                names = br.output_names
+                inits = [i.name for i in br.obj.graph.initializer]
+                raise RuntimeError(
+                    f"Output {i!r} (branch={branch!r}, name={names[i]!r}) is None, "
+                    f"available inputs={sorted(context)}, initializers={inits}."
+                )
+        return self._check_and_fix_outputs(final)
diff --git a/onnx/reference/ops/op_image_decoder.py b/onnx/reference/ops/op_image_decoder.py
new file mode 100644
index 0000000..a86f50d
--- /dev/null
+++ b/onnx/reference/ops/op_image_decoder.py
@@ -0,0 +1,33 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import io
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class ImageDecoder(OpRun):
+    def _run(self, encoded: np.ndarray, pixel_format="RGB") -> tuple[np.ndarray]:
+        try:
+            import PIL.Image  # noqa: PLC0415
+        except ImportError as e:
+            raise ImportError(
+                "Pillow must be installed to use the reference implementation of the ImageDecoder operator"
+            ) from e
+        img = PIL.Image.open(io.BytesIO(encoded.tobytes()))
+        if pixel_format == "BGR":
+            decoded = np.array(img)[:, :, ::-1]
+        elif pixel_format == "RGB":
+            decoded = np.array(img)
+        elif pixel_format == "Grayscale":
+            img = img.convert("L")
+            decoded = np.array(img)
+            decoded = np.expand_dims(decoded, axis=2)  # (H, W) to (H, W, 1)
+        else:
+            raise ValueError(f"pixel_format={pixel_format!r} is not supported.")
+        return (decoded,)
diff --git a/onnx/reference/ops/op_instance_normalization.py b/onnx/reference/ops/op_instance_normalization.py
new file mode 100644
index 0000000..b240c07
--- /dev/null
+++ b/onnx/reference/ops/op_instance_normalization.py
@@ -0,0 +1,21 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class InstanceNormalization(OpRun):
+    def _run(self, x, s, bias, epsilon=None):
+        dims_x = len(x.shape)
+        axis = tuple(range(2, dims_x))
+        mean = np.mean(x, axis=axis, keepdims=True)
+        var = np.var(x, axis=axis, keepdims=True)
+        dim_ones = (1,) * (dims_x - 2)
+        s = s.reshape(-1, *dim_ones)
+        bias = bias.reshape(-1, *dim_ones)
+        y = s * (x - mean) / np.sqrt(var + epsilon) + bias
+        return (y.astype(x.dtype),)
diff --git a/onnx/reference/ops/op_isinf.py b/onnx/reference/ops/op_isinf.py
new file mode 100644
index 0000000..f7a4444
--- /dev/null
+++ b/onnx/reference/ops/op_isinf.py
@@ -0,0 +1,20 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class IsInf(OpRun):
+    def _run(self, data, detect_negative=None, detect_positive=None):
+        if detect_negative:
+            if detect_positive:
+                return (np.isinf(data),)
+            return (np.isneginf(data),)
+        if detect_positive:
+            return (np.isposinf(data),)
+        res = np.full(data.shape, dtype=np.bool_, fill_value=False)
+        return (res,)
diff --git a/onnx/reference/ops/op_isnan.py b/onnx/reference/ops/op_isnan.py
new file mode 100644
index 0000000..824a560
--- /dev/null
+++ b/onnx/reference/ops/op_isnan.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnary
+
+
+class IsNaN(OpRunUnary):
+    def _run(self, data):
+        return (np.isnan(data),)
diff --git a/onnx/reference/ops/op_layer_normalization.py b/onnx/reference/ops/op_layer_normalization.py
new file mode 100644
index 0000000..be1a1ee
--- /dev/null
+++ b/onnx/reference/ops/op_layer_normalization.py
@@ -0,0 +1,73 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _layer_normalization(
+    X: np.ndarray,
+    W: np.ndarray,
+    B: np.ndarray,
+    axis: int = -1,
+    epsilon: float = 1e-5,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    X_shape = X.shape
+    X_rank = len(X_shape)
+    if axis < 0:
+        # If axis = -1 and rank of X is 4,
+        # the axis is changed to -1 + 4 = 3,
+        # which means the last axis.
+        axis = axis + X_rank
+    unsqueezed_rank = X_rank - axis
+    reduction_shape = X_shape[0:axis] + (1,) * unsqueezed_rank
+
+    # Parameter used to convert N-D tensor layer
+    # normalization to equivalent 2-D matrix operations.
+    row_number = 1
+    col_number = 1
+    for i in range(X_rank):
+        if i < axis:
+            row_number *= X_shape[i]
+        else:
+            col_number *= X_shape[i]
+
+    # After reshaping input tensor X into a matrix,
+    # layer normalization is equivalent to conducting
+    # standardization on each column vector (s.t. each
+    # column has zero mean and unit variance).
+    x_mat = np.reshape(X, (row_number, col_number))
+    # This computes mean for every x_mat's column.
+    x_mean = np.sum(x_mat, axis=1, keepdims=True) / col_number
+    x_diff = x_mat - x_mean
+    x_squared_diff = x_diff * x_diff
+    # This computes variance for every x_mat's column.
+    variance = np.sum(x_squared_diff, axis=1, keepdims=True) / col_number
+    variance_eps = variance + epsilon
+    std_dev = np.sqrt(variance_eps)
+    inv_std_dev = np.reciprocal(std_dev)
+    # Standardization step. y_mat is zero-mean and unit-variance.
+    y_mat = x_diff * inv_std_dev
+    # Apply affine transform on normalization outcome.
+    # W is linear coefficient while B is bias.
+    Y = np.reshape(y_mat, X_shape) * W
+    if B is not None:
+        Y = Y + B
+    # Matrix-level operations' outputs should be reshaped
+    # to compensate the initial tensor-to-matrix reshape.
+    X_mean = np.reshape(x_mean, reduction_shape)
+    X_inv_std_dev = np.reshape(inv_std_dev, reduction_shape)
+
+    return (Y.astype(X.dtype), X_mean.astype(X.dtype), X_inv_std_dev.astype(X.dtype))
+
+
+class LayerNormalization(OpRun):
+    def _run(self, X, Scale, B=None, axis=None, epsilon=None, stash_type=None):
+        if stash_type != 1:
+            raise NotImplementedError(
+                f"LayerNormalization not implemented for stash_type={stash_type} != 1."
+            )
+        return _layer_normalization(X, Scale, B, axis=axis, epsilon=epsilon)
diff --git a/onnx/reference/ops/op_leaky_relu.py b/onnx/reference/ops/op_leaky_relu.py
new file mode 100644
index 0000000..e263f17
--- /dev/null
+++ b/onnx/reference/ops/op_leaky_relu.py
@@ -0,0 +1,23 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+if TYPE_CHECKING:
+    import numpy as np
+
+
+def _leaky_relu(x: np.ndarray, alpha: float) -> np.ndarray:
+    sign = (x > 0).astype(x.dtype)
+    sign -= ((sign - 1) * alpha).astype(x.dtype)
+    return x * sign
+
+
+class LeakyRelu(OpRunUnaryNum):
+    def _run(self, x, alpha=None):
+        alpha = alpha or self.alpha
+        return (_leaky_relu(x, alpha).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_less.py b/onnx/reference/ops/op_less.py
new file mode 100644
index 0000000..a44f541
--- /dev/null
+++ b/onnx/reference/ops/op_less.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryComparison
+
+
+class Less(OpRunBinaryComparison):
+    def _run(self, a, b):
+        return (np.less(a, b),)
diff --git a/onnx/reference/ops/op_less_or_equal.py b/onnx/reference/ops/op_less_or_equal.py
new file mode 100644
index 0000000..dcb2465
--- /dev/null
+++ b/onnx/reference/ops/op_less_or_equal.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryComparison
+
+
+class LessOrEqual(OpRunBinaryComparison):
+    def _run(self, a, b):
+        return (np.less_equal(a, b),)
diff --git a/onnx/reference/ops/op_linear_attention.py b/onnx/reference/ops/op_linear_attention.py
new file mode 100644
index 0000000..0858c13
--- /dev/null
+++ b/onnx/reference/ops/op_linear_attention.py
@@ -0,0 +1,181 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _unpack_3d_to_4d(x: np.ndarray, num_heads: int) -> np.ndarray:
+    """Reshape (B, T, H*D) -> (B, H, T, D)."""
+    b, t, hd = x.shape
+    if hd % num_heads != 0:
+        raise ValueError(
+            f"Last dim {hd} not divisible by num_heads {num_heads} for shape {x.shape}."
+        )
+    d = hd // num_heads
+    return x.reshape(b, t, num_heads, d).transpose(0, 2, 1, 3)
+
+
+class LinearAttention(OpRun):
+    def _run(
+        self,
+        query,
+        key,
+        value,
+        past_state=None,
+        decay=None,
+        beta=None,
+        chunk_size=None,  # noqa: ARG002 — tuning hint, no effect on output
+        kv_num_heads=None,
+        q_num_heads=None,
+        scale=None,
+        update_rule=None,
+    ):
+        # --- Step 1: defaults and validation ---
+        if update_rule is None:
+            update_rule = "gated_delta"
+        if update_rule not in ("linear", "gated", "delta", "gated_delta"):
+            raise ValueError(
+                f"Unsupported update_rule '{update_rule}'. "
+                "Expected one of: 'linear', 'gated', 'delta', 'gated_delta'."
+            )
+        if q_num_heads is None or kv_num_heads is None:
+            raise ValueError("q_num_heads and kv_num_heads are required attributes.")
+        if q_num_heads <= 0 or kv_num_heads <= 0 or q_num_heads % kv_num_heads != 0:
+            raise ValueError(
+                f"q_num_heads ({q_num_heads}) must be a positive multiple of "
+                f"kv_num_heads ({kv_num_heads})."
+            )
+
+        gating = update_rule in ("gated", "gated_delta")
+        delta_correction = update_rule in ("delta", "gated_delta")
+
+        if gating and decay is None:
+            raise ValueError(f"update_rule '{update_rule}' requires decay input.")
+        if not gating and decay is not None:
+            raise ValueError(f"update_rule '{update_rule}' forbids decay input.")
+        if delta_correction and beta is None:
+            raise ValueError(f"update_rule '{update_rule}' requires beta input.")
+        if not delta_correction and beta is not None:
+            raise ValueError(f"update_rule '{update_rule}' forbids beta input.")
+
+        for name, arr in (("query", query), ("key", key), ("value", value)):
+            if arr.ndim != 3:
+                raise ValueError(
+                    f"{name} must be rank 3 (B, T, H*D), got shape {arr.shape}."
+                )
+
+        # --- Step 2: unpack Q/K/V to 4D (B, H, T, D) ---
+        out_dtype = query.dtype
+        b, t, _ = query.shape
+        d_k = query.shape[-1] // q_num_heads
+        d_v = value.shape[-1] // kv_num_heads
+        group_size = q_num_heads // kv_num_heads
+
+        q4 = _unpack_3d_to_4d(query, q_num_heads).astype(np.float32)
+        k4 = _unpack_3d_to_4d(key, kv_num_heads).astype(np.float32)
+        v4 = _unpack_3d_to_4d(value, kv_num_heads).astype(np.float32)
+
+        # --- Step 3: unpack decay (broadcastable to (B, H_kv, T, d_k)) ---
+        if decay is not None:
+            if decay.ndim != 3:
+                raise ValueError(f"decay must be rank 3, got shape {decay.shape}.")
+            decay_last = decay.shape[-1]
+            if decay_last == kv_num_heads:
+                # Per-head scalar: (B, T, H_kv) -> (B, H_kv, T, 1)
+                decay4 = decay.reshape(b, t, kv_num_heads, 1).transpose(0, 2, 1, 3)
+            elif decay_last == kv_num_heads * d_k:
+                # Per-key-dim: (B, T, H_kv*d_k) -> (B, H_kv, T, d_k)
+                decay4 = _unpack_3d_to_4d(decay, kv_num_heads)
+            else:
+                raise ValueError(
+                    f"decay last dim {decay_last} must equal kv_num_heads "
+                    f"({kv_num_heads}) or kv_num_heads*d_k ({kv_num_heads * d_k})."
+                )
+            decay4 = decay4.astype(np.float32)
+
+        # --- Step 4: unpack beta (broadcastable to (B, H_kv, T, 1)) ---
+        if beta is not None:
+            if beta.ndim != 3:
+                raise ValueError(f"beta must be rank 3, got shape {beta.shape}.")
+            beta_last = beta.shape[-1]
+            if beta_last not in (kv_num_heads, 1):
+                raise ValueError(
+                    f"beta last dim {beta_last} must be kv_num_heads "
+                    f"({kv_num_heads}) or 1."
+                )
+            # (B, T, H_kv_or_1) -> (B, H_kv_or_1, T, 1)
+            beta4 = beta.reshape(b, t, beta_last, 1).transpose(0, 2, 1, 3)
+            beta4 = beta4.astype(np.float32)
+
+        # --- Step 5: initialize state in float32 ---
+        # TODO(review): The proposal allows S != T (e.g., float32 state with
+        # float16/bfloat16 activations). We accumulate internally in float32
+        # regardless, then cast `present_state` back to `past_state.dtype` (or
+        # `query.dtype` when `past_state` is omitted, since there is no S
+        # anchor in that case). A cleaner contract would propagate S
+        # explicitly — possibly via a new attribute or by inferring S from a
+        # zero-shape sentinel — once the spec resolves how S is signalled
+        # when past_state is absent. Mirrors the same TODO in the C++
+        # function-body builder in onnx/defs/nn/defs.cc.
+        if past_state is not None:
+            if past_state.shape != (b, kv_num_heads, d_k, d_v):
+                raise ValueError(
+                    f"past_state shape {past_state.shape} does not match "
+                    f"({b}, {kv_num_heads}, {d_k}, {d_v})."
+                )
+            state_in_dtype = past_state.dtype
+            state = past_state.astype(np.float32).copy()
+        else:
+            state_in_dtype = out_dtype
+            state = np.zeros((b, kv_num_heads, d_k, d_v), dtype=np.float32)
+
+        # --- Step 6: scale ---
+        if scale is None or scale == 0.0:
+            scale_val = 1.0 / np.sqrt(d_k)
+        else:
+            scale_val = float(scale)
+
+        # --- Step 7+8: recurrence with GQA expansion at read time ---
+        outputs = np.zeros((b, q_num_heads, t, d_v), dtype=np.float32)
+        for i in range(t):
+            q_t = q4[:, :, i, :]  # (B, H_q, d_k)
+            k_t = k4[:, :, i, :]  # (B, H_kv, d_k)
+            v_t = v4[:, :, i, :]  # (B, H_kv, d_v)
+
+            # Decay: state *= exp(g_t)
+            if gating:
+                g_t = decay4[:, :, i, :]  # (B, H_kv, 1) or (B, H_kv, d_k)
+                state = state * np.exp(g_t)[..., None]  # broadcast over d_v
+
+            # Delta correction: v_t <- beta_t * (v_t - S^T @ k_t)
+            if delta_correction:
+                # retrieved[b, h, m] = sum_d state[b, h, d, m] * k_t[b, h, d]
+                retrieved = np.einsum("bhdm,bhd->bhm", state, k_t)
+                v_t = beta4[:, :, i, :] * (v_t - retrieved)
+
+            # Write: state += k_t ⊗ v_t  (outer product over last dims)
+            state = state + k_t[..., :, None] * v_t[..., None, :]
+
+            # Read with GQA: replicate KV-head state across query heads.
+            if group_size == 1:
+                state_for_read = state
+            else:
+                # (B, H_kv, d_k, d_v) -> (B, H_q, d_k, d_v) by interleave-repeat
+                state_for_read = np.repeat(state, group_size, axis=1)
+            # o_t[b, h, m] = scale * sum_d q_t[b, h, d] * state_for_read[b, h, d, m]
+            outputs[:, :, i, :] = scale_val * np.einsum(
+                "bhd,bhdm->bhm", q_t, state_for_read
+            )
+
+        # --- Step 9: repack output (B, H_q, T, d_v) -> (B, T, H_q*d_v) ---
+        output = outputs.transpose(0, 2, 1, 3).reshape(b, t, q_num_heads * d_v)
+        output = output.astype(out_dtype)
+
+        # --- Step 10: present_state in same dtype as past_state (or query) ---
+        present_state = state.astype(state_in_dtype)
+
+        return (output, present_state)
diff --git a/onnx/reference/ops/op_log.py b/onnx/reference/ops/op_log.py
new file mode 100644
index 0000000..f900c14
--- /dev/null
+++ b/onnx/reference/ops/op_log.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Log(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.log(x).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_log_softmax.py b/onnx/reference/ops/op_log_softmax.py
new file mode 100644
index 0000000..0303eff
--- /dev/null
+++ b/onnx/reference/ops/op_log_softmax.py
@@ -0,0 +1,15 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.op_softmax import Softmax
+
+
+class LogSoftmax(Softmax):
+    def _run(self, X):
+        Y = Softmax._run(self, X)[0]
+        np.log(Y, out=Y)
+        return (Y,)
diff --git a/onnx/reference/ops/op_loop.py b/onnx/reference/ops/op_loop.py
new file mode 100644
index 0000000..bcd7c7e
--- /dev/null
+++ b/onnx/reference/ops/op_loop.py
@@ -0,0 +1,86 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Loop(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        if "opsets" not in self.run_params:
+            raise KeyError("run_params must contains key 'opsets'.")
+        if "verbose" not in run_params:
+            raise KeyError("run_params must contains key 'verbose'.")
+        self.output_index = {n: i for i, n in enumerate(self.body.output_names)}
+        self.N = len(self.body.input_names) - 2
+        self.K = len(self.body.output_names) - self.N - 1
+
+    def need_context(self) -> bool:
+        """The operator Loop needs to know all results produced
+        so far as the loop may silently access one of them.
+        Some information are not always referred in the list of inputs
+        (kind of static variables).
+        """
+        return True
+
+    def _run(self, M, cond, *args, context=None, body=None, attributes=None):
+        if args:
+            v_initial = args[0]
+            args = args[1:]
+        else:
+            v_initial = None
+        if M is not None and not hasattr(M, "dtype"):
+            raise TypeError(f"M must be empty or an array but its type is {type(M)}.")
+        body = self.body
+        loop_inputs = body.input_names
+        inputs = dict.fromkeys(loop_inputs)
+        if v_initial is not None:
+            inputs[loop_inputs[2]] = v_initial
+        cond_name = body.output_names[0]
+        if args:
+            begin = len(loop_inputs) - len(args)
+            all_inputs = loop_inputs[begin:]
+            for name, val in zip(all_inputs, args, strict=False):
+                inputs[name] = val
+        if context is not None:
+            for a in context:
+                inputs[a] = context[a]
+
+        k_carried_away = [[] for i in range(self.K)]
+        it = 0
+        while cond and (M is None or it < M):
+            self._log("  -- loop> {%r}", context)
+            if len(body.input_names) > 0 and body.input_names[0] is not None:
+                inputs[body.input_names[0]] = np.array(
+                    it, dtype=None if M is None else M.dtype
+                )
+            if len(body.input_names) > 1 and body.input_names[1] is not None:
+                inputs[body.input_names[1]] = cond
+            outputs = self._run_body(inputs, attributes=attributes)
+            if self.K > 0:
+                for k in range(self.K):
+                    k_carried_away[k].append(outputs[-self.K + k])
+            index_cond = self.output_index[cond_name]
+            cond = outputs[index_cond]
+            if cond is None:
+                raise RuntimeError(
+                    f"Condition {cond_name!r} returned by the subgraph cannot be None."
+                )
+            for i, o in zip(body.input_names[2:], body.output_names[1:], strict=False):
+                inputs[i] = outputs[self.output_index[o]]
+            it += 1
+            self._log("  -- loop<")
+
+        if it == 0:
+            outputs = [inputs[i] for i in body.input_names[2:]]
+        else:
+            outputs = outputs[1 : 1 + self.N]
+        outputs.extend([np.vstack(x) for x in k_carried_away])
+        while len(outputs) < len(self.onnx_node.output):
+            outputs.append(np.empty(shape=()))
+        res = tuple(outputs)
+        return self._check_and_fix_outputs(res)
diff --git a/onnx/reference/ops/op_lp_normalization.py b/onnx/reference/ops/op_lp_normalization.py
new file mode 100644
index 0000000..e45532a
--- /dev/null
+++ b/onnx/reference/ops/op_lp_normalization.py
@@ -0,0 +1,19 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class LpNormalization(OpRunUnaryNum):
+    def _run(self, x, axis=None, p=None):
+        axis = axis or self.axis
+        p = p or self.p
+        norm = np.power(np.power(x, p).sum(axis=axis), 1.0 / p)
+        norm = np.expand_dims(norm, axis)
+        # When norm is 0, return 0 instead of NaN (0/0 = 0)
+        result = np.where(norm == 0, 0, x / norm)
+        return (result.astype(x.dtype),)
diff --git a/onnx/reference/ops/op_lp_pool.py b/onnx/reference/ops/op_lp_pool.py
new file mode 100644
index 0000000..390abad
--- /dev/null
+++ b/onnx/reference/ops/op_lp_pool.py
@@ -0,0 +1,43 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops.op_pool_common import CommonPool
+
+
+class LpPool(CommonPool):
+    def _run(
+        self,
+        x,
+        auto_pad=None,
+        ceil_mode=None,
+        dilations=None,
+        kernel_shape=None,
+        p=2,
+        pads=None,
+        strides=None,
+        count_include_pad=None,
+    ):
+        # utilize AvgPool the same fashion Pytorch does. Note that there is a difference in computation.
+        # it needs another PR to address.
+        # https://github.com/pytorch/pytorch/blob/f58ba553b78db7f88477f9ba8c9333bd1590e30a/torch/nn/functional.py#L1015
+        power_average = CommonPool._run(
+            self,
+            "AVG",
+            count_include_pad,
+            np.power(np.absolute(x), p),
+            auto_pad=auto_pad,
+            ceil_mode=ceil_mode,
+            dilations=dilations,
+            kernel_shape=kernel_shape,
+            pads=pads,
+            strides=strides,
+        )
+
+        kernel_element_count = np.prod(kernel_shape, dtype=np.int64)
+        return (
+            np.power(kernel_element_count * power_average[0], 1.0 / p).astype(x.dtype),
+        )
diff --git a/onnx/reference/ops/op_lrn.py b/onnx/reference/ops/op_lrn.py
new file mode 100644
index 0000000..11dce65
--- /dev/null
+++ b/onnx/reference/ops/op_lrn.py
@@ -0,0 +1,28 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class LRN(OpRun):
+    def _run(self, x, alpha=None, beta=None, bias=None, size=None):
+        if len(x.shape) != 4:
+            raise RuntimeError(
+                f"LRN only applies on 4D tensors but shape is {x.shape!r}."
+            )
+        square_sum = np.zeros(x.shape).astype(x.dtype)
+        minc = x.shape[1]
+        c1 = math.floor((size - 1) / 2)
+        c2 = math.ceil((size - 1) / 2) + 1
+        for c in range(x.shape[0]):
+            begin = max(0, c - c1)
+            end = min(minc, c + c2)
+            square_sum[:, c, :, :] = np.sum(x[:, begin:end, :, :] ** 2, axis=1)
+        y = x / ((bias + (alpha / size) * square_sum) ** beta)
+        return (y.astype(x.dtype),)
diff --git a/onnx/reference/ops/op_lstm.py b/onnx/reference/ops/op_lstm.py
new file mode 100644
index 0000000..1b0519d
--- /dev/null
+++ b/onnx/reference/ops/op_lstm.py
@@ -0,0 +1,155 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class CommonLSTM(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        self.n_outputs = len(onnx_node.output)
+        self.n_gates = 3
+
+    def f(self, x: np.ndarray) -> np.ndarray:
+        return 1 / (1 + np.exp(-x))
+
+    def g(self, x: np.ndarray) -> np.ndarray:
+        return np.tanh(x)
+
+    def h(self, x: np.ndarray) -> np.ndarray:
+        return np.tanh(x)
+
+    def _step(
+        self,
+        X: np.ndarray,
+        R: np.ndarray,
+        B: np.ndarray,
+        W: np.ndarray,
+        H_0: np.ndarray,
+        C_0: np.ndarray,
+        P: np.ndarray,
+        num_directions: int,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        seq_length = X.shape[0]
+        hidden_size = H_0.shape[-1]
+        batch_size = X.shape[1]
+
+        Y = np.empty([seq_length, num_directions, batch_size, hidden_size])
+        h_list = []
+
+        [p_i, p_o, p_f] = np.split(P, 3)
+        H_t = H_0
+        C_t = C_0
+        for x in np.split(X, X.shape[0], axis=0):
+            gates = (
+                np.dot(x, np.transpose(W))
+                + np.dot(H_t, np.transpose(R))
+                + np.add(*np.split(B, 2))
+            )
+            i, o, f, c = np.split(gates, 4, -1)
+            i = self.f(i + p_i * C_t)
+            f = self.f(f + p_f * C_t)
+            c = self.g(c)
+            C = f * C_t + i * c
+            o = self.f(o + p_o * C)
+            H = o * self.h(C)
+            h_list.append(H)
+            H_t = H
+            C_t = C
+
+        concatenated = np.concatenate(h_list)
+        if num_directions == 1:
+            Y[:, 0, :, :] = concatenated
+
+        if self.layout == 0:
+            Y_h = Y[-1]
+        else:
+            Y = np.transpose(Y, [2, 0, 1, 3])
+            Y_h = Y[:, :, -1, :]
+
+        return Y, Y_h
+
+    def _run(
+        self,
+        X,
+        W,
+        R,
+        B=None,
+        sequence_lens=None,
+        initial_h=None,
+        initial_c=None,
+        P=None,
+        activation_alpha=None,  # noqa: ARG002
+        activation_beta=None,  # noqa: ARG002
+        activations=None,  # noqa: ARG002
+        clip=None,  # noqa: ARG002
+        direction=None,  # noqa: ARG002
+        hidden_size=None,
+        input_forget=None,  # noqa: ARG002
+        layout=None,  # noqa: ARG002
+    ):
+        # TODO: support overridden attributes.
+        n_gates = 4
+        number_of_peepholes = 3
+
+        num_directions = W.shape[0]
+
+        if num_directions == 1:
+            R = np.squeeze(R, axis=0)
+            W = np.squeeze(W, axis=0)
+            if B is not None and len(B.shape) > 0 and B.shape[0] == 1:
+                B = np.squeeze(B, axis=0)
+            if (
+                sequence_lens is not None
+                and len(sequence_lens.shape) > 0
+                and sequence_lens.shape[0] == 1
+            ):
+                sequence_lens = np.squeeze(sequence_lens, axis=0)
+            if (
+                initial_h is not None
+                and len(initial_h.shape) > 0
+                and initial_h.shape[0] == 1
+            ):
+                initial_h = np.squeeze(initial_h, axis=0)
+            if (
+                initial_c is not None
+                and len(initial_c.shape) > 0
+                and initial_c.shape[0] == 1
+            ):
+                initial_c = np.squeeze(initial_c, axis=0)
+            if P is not None and len(P.shape) > 0 and P.shape[0] == 1:
+                P = np.squeeze(P, axis=0)
+
+            hidden_size = R.shape[-1]
+            batch_size = X.shape[1]
+
+            if self.layout != 0:
+                X = np.swapaxes(X, 0, 1)
+            if B is None:
+                B = np.zeros(2 * n_gates * hidden_size, dtype=np.float32)
+            if P is None:
+                P = np.zeros(number_of_peepholes * hidden_size, dtype=np.float32)
+            if initial_h is None:
+                initial_h = np.zeros((batch_size, hidden_size), dtype=np.float32)
+            if initial_c is None:
+                initial_c = np.zeros((batch_size, hidden_size), dtype=np.float32)
+        else:
+            raise NotImplementedError(  # pragma: no cover
+                f"Unsupported value {num_directions!r} for num_directions "
+                f"and operator {self.__class__.__name__!r}."
+            )
+
+        Y, Y_h = self._step(
+            X, R, B, W, initial_h, initial_c, P, num_directions=num_directions
+        )
+        Y = Y.astype(X.dtype)
+        return (Y,) if self.n_outputs == 1 else (Y, Y_h.astype(X.dtype))
+
+
+class LSTM(CommonLSTM):
+    def __init__(self, onnx_node, run_params):
+        CommonLSTM.__init__(self, onnx_node, run_params)
diff --git a/onnx/reference/ops/op_matmul.py b/onnx/reference/ops/op_matmul.py
new file mode 100644
index 0000000..6b03ecd
--- /dev/null
+++ b/onnx/reference/ops/op_matmul.py
@@ -0,0 +1,25 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryNum
+
+
+def numpy_matmul(a, b):
+    """Implements a matmul product. See :func:`np.matmul`.
+    Handles sparse matrices.
+    """
+    try:
+        if len(a.shape) <= 2 and len(b.shape) <= 2:
+            return np.dot(a, b)
+        return np.matmul(a, b)
+    except ValueError as e:
+        raise ValueError(f"Unable to multiply shapes {a.shape!r}, {b.shape!r}.") from e
+
+
+class MatMul(OpRunBinaryNum):
+    def _run(self, a, b):
+        return (numpy_matmul(a, b),)
diff --git a/onnx/reference/ops/op_matmul_integer.py b/onnx/reference/ops/op_matmul_integer.py
new file mode 100644
index 0000000..dd1da91
--- /dev/null
+++ b/onnx/reference/ops/op_matmul_integer.py
@@ -0,0 +1,19 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class MatMulInteger(OpRun):
+    def _run(self, A, B, a_zero_point=None, b_zero_point=None):
+        A32 = A.astype(np.int32)
+        if a_zero_point is not None:
+            A32 -= a_zero_point
+        B32 = B.astype(np.int32)
+        if b_zero_point is not None:
+            B32 -= b_zero_point
+        return (A32 @ B32,)
diff --git a/onnx/reference/ops/op_max.py b/onnx/reference/ops/op_max.py
new file mode 100644
index 0000000..b7ed857
--- /dev/null
+++ b/onnx/reference/ops/op_max.py
@@ -0,0 +1,25 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryNumpy
+
+
+class Max(OpRunBinaryNumpy):
+    def __init__(self, onnx_node, run_params):
+        OpRunBinaryNumpy.__init__(self, np.maximum, onnx_node, run_params)
+
+    def run(self, *data):
+        if len(data) == 2:
+            return OpRunBinaryNumpy.run(self, *data)
+        if len(data) == 1:
+            return (data[0].copy(),)
+        if len(data) > 2:
+            a = data[0]
+            for i in range(1, len(data)):
+                a = np.maximum(a, data[i])
+            return (a,)
+        raise RuntimeError("Unexpected turn of events.")
diff --git a/onnx/reference/ops/op_max_pool.py b/onnx/reference/ops/op_max_pool.py
new file mode 100644
index 0000000..b570d4f
--- /dev/null
+++ b/onnx/reference/ops/op_max_pool.py
@@ -0,0 +1,413 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op_common_pool import CommonPool
+
+
+class MaxPool(CommonPool):
+    def _run(
+        self,
+        x,
+        auto_pad=None,
+        ceil_mode=None,
+        dilations=None,
+        kernel_shape=None,
+        pads=None,
+        storage_order=None,
+        strides=None,
+    ):
+        if (
+            dilations is not None
+            and (min(dilations) != max(dilations) or min(dilations) != 1)
+        ) or (
+            strides is not None and (min(strides) != max(strides) or min(strides) != 1)
+        ):
+            return self._max_pool(
+                x,
+                auto_pad=auto_pad,
+                ceil_mode=ceil_mode,
+                dilations=dilations,
+                kernel_shape=kernel_shape,
+                pads=pads,
+                storage_order=storage_order,
+                strides=strides,
+            )
+
+        return CommonPool._run(
+            self,
+            "MAX",
+            0,
+            x,
+            auto_pad=auto_pad,
+            ceil_mode=ceil_mode,
+            dilations=dilations,
+            kernel_shape=kernel_shape,
+            pads=pads,
+            storage_order=storage_order,
+            strides=strides,
+        )
+
+    def _max_pool(
+        self,
+        x,
+        auto_pad,
+        ceil_mode,
+        dilations,
+        kernel_shape,
+        pads,
+        storage_order,
+        strides,
+    ):
+        if pads is None:
+            pads = [0 for i in range(len(kernel_shape) * 2)]
+        if strides is None:
+            strides = [1 for i in range(len(kernel_shape))]
+        if dilations is None:
+            dilations = [1 for i in range(len(kernel_shape))]
+
+        n_dims = len(kernel_shape)
+        new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
+
+        input_spatial_shape = x.shape[2:]
+        output_spatial_shape = [0 for s in input_spatial_shape]
+        if ceil_mode:
+            for i in range(len(input_spatial_shape)):
+                output_spatial_shape[i] = int(
+                    np.ceil(
+                        (
+                            input_spatial_shape[i]
+                            + new_pads[i].sum()
+                            - ((kernel_shape[i] - 1) * dilations[i] + 1)
+                        )
+                        / strides[i]
+                        + 1
+                    )
+                )
+                need_to_reduce_out_size_in_ceil_mode = (
+                    output_spatial_shape[i] - 1
+                ) * strides[i] >= input_spatial_shape[i] + new_pads[i][0]
+                if need_to_reduce_out_size_in_ceil_mode:
+                    output_spatial_shape[i] -= 1
+        else:
+            for i in range(len(input_spatial_shape)):
+                output_spatial_shape[i] = int(
+                    np.floor(
+                        (
+                            input_spatial_shape[i]
+                            + new_pads[i].sum()
+                            - ((kernel_shape[i] - 1) * dilations[i] + 1)
+                        )
+                        / strides[i]
+                        + 1
+                    )
+                )
+
+        if auto_pad and auto_pad != "NOTSET":
+            # Deprecated attribute
+            if auto_pad in ("SAME_UPPER", "SAME_LOWER"):
+                for i in range(len(input_spatial_shape)):
+                    if auto_pad == "SAME_UPPER":
+                        output_spatial_shape[i] = int(
+                            np.ceil(input_spatial_shape[i] / strides[i])
+                        )
+                    else:
+                        output_spatial_shape[i] = int(
+                            np.floor(input_spatial_shape[i] / strides[i])
+                        )
+                    pad_i = (
+                        (output_spatial_shape[i] - 1) * strides[i]
+                        + ((kernel_shape[i] - 1) * dilations[i] + 1)
+                        - input_spatial_shape[i]
+                    )
+                    new_pads[i, 0] = pad_i // 2
+                    new_pads[i, 1] = pad_i - new_pads[i, 0]
+            else:
+                for i in range(len(input_spatial_shape)):
+                    output_spatial_shape[i] = int(
+                        np.ceil(
+                            (
+                                input_spatial_shape[i]
+                                - ((kernel_shape[i] - 1) * dilations[i] + 1)
+                                + 1
+                            )
+                            / strides[i]
+                        )
+                    )
+
+        if len(input_spatial_shape) == 1:
+            return self._max_pool_1d(
+                x,
+                auto_pad,
+                ceil_mode,
+                dilations,
+                kernel_shape,
+                new_pads,
+                storage_order,
+                strides,
+                output_spatial_shape,
+            )
+
+        if len(input_spatial_shape) == 2:
+            return self._max_pool_2d(
+                x,
+                auto_pad,
+                ceil_mode,
+                dilations,
+                kernel_shape,
+                new_pads,
+                storage_order,
+                strides,
+                output_spatial_shape,
+            )
+
+        if len(input_spatial_shape) == 3:
+            return self._max_pool_3d(
+                x,
+                auto_pad,
+                ceil_mode,
+                dilations,
+                kernel_shape,
+                new_pads,
+                storage_order,
+                strides,
+                output_spatial_shape,
+            )
+
+        raise RuntimeError(f"Not implemented yet for shape {x.shape}.")
+
+    def _max_pool_1d(
+        self,
+        x,
+        auto_pad,  # noqa: ARG002
+        ceil_mode,  # noqa: ARG002
+        dilations,
+        kernel_shape,
+        new_pads,
+        storage_order,  # noqa: ARG002
+        strides,
+        output_spatial_shape,
+    ):
+        global_pooling = False
+        y_dims = x.shape[:2] + tuple(output_spatial_shape)
+        y = np.zeros(y_dims, dtype=x.dtype)
+        indices = np.full(y_dims, dtype=np.int64, fill_value=-1)
+        x_dims = x.shape
+        channels = x_dims[1]
+        height = x_dims[2]
+        pooled_height = y_dims[2]
+        total_channels = x_dims[0] * channels
+        stride_h = 1 if global_pooling else strides[0]
+
+        x_step = height
+        y_step = pooled_height
+        dilation_h = dilations[0]
+
+        X_data = x.ravel()
+        Y_data = y.ravel()
+        I_data = indices.ravel()
+
+        def iteration(c):
+            x_d = c * x_step
+            y_d = c * y_step
+            i_d = c * y_step
+            for ph in range(pooled_height):
+                hstart = ph * stride_h - new_pads[0, 0]
+                hend = hstart + kernel_shape[0] * dilation_h
+                Yh = None
+                h_index = -1
+                for h in range(hstart, hend, dilation_h):
+                    if h < 0 or h >= height:
+                        continue
+                    if Yh is None or X_data[x_d + h] > Yh:
+                        Yh = X_data[x_d + h]
+                        h_index = h
+                Y_data[y_d + ph] = Yh
+                I_data[i_d + ph] = c * x_step + h_index
+
+        for c in range(total_channels):
+            iteration(c)
+
+        if len(self.output) == 1:
+            return (Y_data.reshape(y_dims),)
+        return (Y_data.reshape(y_dims), I_data.reshape(y_dims))
+
+    def _max_pool_2d(
+        self,
+        x,
+        auto_pad,  # noqa: ARG002
+        ceil_mode,  # noqa: ARG002
+        dilations,
+        kernel_shape,
+        new_pads,
+        storage_order,
+        strides,
+        output_spatial_shape,
+    ):
+        global_pooling = False
+        y_dims = x.shape[:2] + tuple(output_spatial_shape)
+        y = np.zeros(y_dims, dtype=x.dtype)
+        indices = np.full(y_dims, dtype=np.int64, fill_value=-1)
+        x_dims = x.shape
+        channels = x_dims[1]
+        height = x_dims[2]
+        width = x_dims[3] if len(kernel_shape) > 1 else 1
+        pooled_height = y_dims[2]
+        pooled_width = y_dims[3] if len(kernel_shape) > 1 else 1
+        total_channels = x_dims[0] * channels
+        stride_h = 1 if global_pooling else strides[0]
+        stride_w = 1 if global_pooling else strides[1]
+
+        x_step = height * width
+        y_step = pooled_height * pooled_width
+        dilation_h = dilations[0]
+        dilation_w = dilations[1]
+
+        X_data = x.ravel()
+        Y_data = y.ravel()
+        I_data = indices.ravel()
+
+        def iteration(c):
+            x_d = c * x_step  # X_data
+            y_d = c * y_step  # Y_data
+            for ph in range(pooled_height):
+                hstart = ph * stride_h - new_pads[0, 0]
+                hend = hstart + kernel_shape[0] * dilation_h
+                for pw in range(pooled_width):
+                    wstart = pw * stride_w - new_pads[1, 0]
+                    wend = wstart + kernel_shape[1] * dilation_w
+                    pool_index = ph * pooled_width + pw
+                    Yh = None
+                    h_index = -1
+                    w_index = -1
+                    for h in range(hstart, hend, dilation_h):
+                        if h < 0 or h >= height:
+                            continue
+                        for w in range(wstart, wend, dilation_w):
+                            if w < 0 or w >= width:
+                                continue
+                            input_index = h * width + w
+                            if input_index < 0 or input_index > X_data.shape[0]:
+                                continue
+                            if Yh is None or X_data[x_d + input_index] > Yh:
+                                Yh = X_data[x_d + input_index]
+                                h_index = h
+                                w_index = w
+                    if Yh is None:
+                        continue
+                    Y_data[y_d + pool_index] = Yh
+                    I_data[y_d + pool_index] = (
+                        c * x_step + h_index * width + w_index
+                        if storage_order == 0
+                        else c * x_step + h_index + w_index * height
+                    )
+
+        for c in range(total_channels):
+            iteration(c)
+
+        if len(self.output) == 1:
+            return (Y_data.reshape(y_dims),)
+        return (Y_data.reshape(y_dims), I_data.reshape(y_dims))
+
+    def _max_pool_3d(
+        self,
+        x,
+        auto_pad,  # noqa: ARG002
+        ceil_mode,  # noqa: ARG002
+        dilations,
+        kernel_shape,
+        new_pads,
+        storage_order,
+        strides,
+        output_spatial_shape,
+    ):
+        global_pooling = False
+        y_dims = x.shape[:2] + tuple(output_spatial_shape)
+        y = np.zeros(y_dims, dtype=x.dtype)
+        indices = np.full(y_dims, dtype=np.int64, fill_value=-1)
+        x_dims = x.shape
+        channels = x_dims[1]
+        height = x_dims[2]
+        width = x_dims[3] if len(kernel_shape) > 1 else 1
+        depth = x_dims[4] if len(kernel_shape) > 2 else 1
+        pooled_height = y_dims[2]
+        pooled_width = y_dims[3] if len(kernel_shape) > 1 else 1
+        pooled_depth = y_dims[4] if len(kernel_shape) > 2 else 1
+        total_channels = x_dims[0] * channels
+        stride_h = 1 if global_pooling else strides[0]
+        stride_w = 1 if global_pooling else strides[1]
+        stride_d = 1 if global_pooling else strides[2]
+
+        x_step = height * width * depth
+        y_step = pooled_height * pooled_width * pooled_depth
+        dilation_h = dilations[0]
+        dilation_w = dilations[1]
+        dilation_d = dilations[2]
+
+        X_data = x.ravel()
+        Y_data = y.ravel()
+        I_data = indices.ravel()
+
+        def iteration(c):
+            x_d = c * x_step
+            y_d = c * y_step
+            i_d = c * y_step
+
+            for ph in range(pooled_height):
+                hstart = ph * stride_h - new_pads[0, 0]
+                hend = hstart + kernel_shape[0] * dilation_h
+                for pw in range(pooled_width):
+                    wstart = pw * stride_w - new_pads[1, 0]
+                    wend = wstart + kernel_shape[1] * dilation_w
+                    for pd in range(pooled_depth):
+                        dstart = pd * stride_d - new_pads[2, 0]
+                        dend = dstart + kernel_shape[2] * dilation_d
+                        pool_index = (
+                            ph * pooled_width * pooled_depth + pw * pooled_depth + pd
+                        )
+                        Yh = None
+                        h_index = -1
+                        w_index = -1
+                        d_index = -1
+                        for h in range(hstart, hend, dilation_h):
+                            if h < 0 or h >= height:
+                                continue
+                            for w in range(wstart, wend, dilation_w):
+                                if w < 0 or w >= width:
+                                    continue
+                                for d in range(dstart, dend, dilation_d):
+                                    if d < 0 or d >= depth:
+                                        continue
+                                    input_index = h * width * depth + w * depth + d
+                                    if Yh is None or X_data[x_d + input_index] > Yh:
+                                        Yh = X_data[x_d + input_index]
+                                        h_index = h
+                                        w_index = w
+                                        d_index = d
+
+                        Y_data[y_d + pool_index] = Yh
+                        I_data[i_d + pool_index] = (
+                            (
+                                c * x_step
+                                + h_index * width * depth
+                                + w_index * depth
+                                + d_index
+                            )
+                            if storage_order == 0
+                            else (
+                                c * x_step
+                                + h_index
+                                + w_index * height
+                                + d_index * height * width
+                            )
+                        )
+
+        for c in range(total_channels):
+            iteration(c)
+
+        if len(self.output) == 1:
+            return (Y_data.reshape(y_dims),)
+        return (Y_data.reshape(y_dims), I_data.reshape(y_dims))
diff --git a/onnx/reference/ops/op_max_unpool.py b/onnx/reference/ops/op_max_unpool.py
new file mode 100644
index 0000000..b42f7fe
--- /dev/null
+++ b/onnx/reference/ops/op_max_unpool.py
@@ -0,0 +1,58 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class MaxUnpool(OpRun):
+    def _run(
+        self, X, indices, output_shape=None, kernel_shape=None, pads=None, strides=None
+    ):
+        pooling_dims = len(X.shape) - 2
+        if pooling_dims > 3:
+            raise NotImplementedError(
+                f"Unsupported pooling size {pooling_dims} for operator MaxUnpool."
+            )
+        kernel_shape = kernel_shape or self.kernel_shape
+        pads = pads or self.pads
+        strides = strides or self.strides
+
+        if strides is None:
+            strides = [1 for d in kernel_shape]
+        if pads is None:
+            pads = [0 for d in range(len(kernel_shape) * 2)]
+
+        inferred_shape = np.empty((len(X.shape),), dtype=np.int64)
+        inferred_shape[0] = X.shape[0]
+        inferred_shape[1] = X.shape[1]
+
+        for dim in range(len(kernel_shape)):
+            inferred_shape[dim + 2] = (
+                (X.shape[dim + 2] - 1) * strides[dim]
+                - (pads[dim] + pads[len(kernel_shape) + dim])
+                + kernel_shape[dim]
+            )
+
+        if output_shape is None:
+            shape = inferred_shape
+        else:
+            shape = output_shape
+
+        total_elements = np.prod(X.shape)
+        Y = np.zeros((np.prod(inferred_shape),), dtype=X.dtype)
+
+        I_data = indices.flatten()
+        X_data = X.flatten()
+
+        for cur_elem in range(total_elements):
+            Y[I_data[cur_elem]] = X_data[cur_elem]
+
+        Y = Y.reshape(tuple(inferred_shape))
+        res = np.zeros(shape, dtype=Y.dtype)
+        slices = tuple(slice(0, i) for i in inferred_shape)
+        res[slices] = Y
+        return (res,)
diff --git a/onnx/reference/ops/op_mean.py b/onnx/reference/ops/op_mean.py
new file mode 100644
index 0000000..d8b888a
--- /dev/null
+++ b/onnx/reference/ops/op_mean.py
@@ -0,0 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class Mean(OpRun):
+    def _run(self, *args):
+        res = args[0].copy()
+        for m in args[1:]:
+            res += m
+        return ((res / len(args)).astype(args[0].dtype),)
diff --git a/onnx/reference/ops/op_mel_weight_matrix.py b/onnx/reference/ops/op_mel_weight_matrix.py
new file mode 100644
index 0000000..1a1749c
--- /dev/null
+++ b/onnx/reference/ops/op_mel_weight_matrix.py
@@ -0,0 +1,61 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.helper import tensor_dtype_to_np_dtype
+from onnx.reference.op_run import OpRun
+
+
+class MelWeightMatrix(OpRun):
+    def _run(
+        self,
+        num_mel_bins,
+        dft_length,
+        sample_rate,
+        lower_edge_hertz,
+        upper_edge_hertz,
+        output_datatype=None,
+    ):
+        num_spectrogram_bins = dft_length // 2 + 1
+        frequency_bins = np.arange(0, num_mel_bins + 2)
+
+        low_frequency_mel = 2595 * np.log10(1 + lower_edge_hertz / 700)
+        high_frequency_mel = 2595 * np.log10(1 + upper_edge_hertz / 700)
+        mel_step = (high_frequency_mel - low_frequency_mel) / frequency_bins.shape[0]
+
+        frequency_bins = frequency_bins * mel_step + low_frequency_mel
+        frequency_bins = 700 * (np.power(10, (frequency_bins / 2595)) - 1)
+        frequency_bins = ((dft_length + 1) * frequency_bins) // sample_rate
+        frequency_bins = frequency_bins.astype(int)
+
+        output = np.zeros((num_spectrogram_bins, num_mel_bins))
+        output.flags.writeable = True
+
+        for i in range(num_mel_bins):
+            lower_frequency_value = frequency_bins[i]  # left
+            center_frequency_point = frequency_bins[i + 1]  # center
+            higher_frequency_point = frequency_bins[i + 2]  # right
+            low_to_center = center_frequency_point - lower_frequency_value
+            if low_to_center == 0:
+                output[center_frequency_point, i] = 1
+            else:
+                for j in range(lower_frequency_value, center_frequency_point + 1):
+                    output[j, i] = float(j - lower_frequency_value) / float(
+                        low_to_center
+                    )
+            center_to_high = higher_frequency_point - center_frequency_point
+            if center_to_high > 0:
+                for j in range(center_frequency_point, higher_frequency_point):
+                    output[j, i] = float(higher_frequency_point - j) / float(
+                        center_to_high
+                    )
+
+        if output_datatype is None:
+            output = output.astype(np.float32)
+        else:
+            dtype = tensor_dtype_to_np_dtype(output_datatype)
+            output = output.astype(dtype)
+        return (output,)
diff --git a/onnx/reference/ops/op_min.py b/onnx/reference/ops/op_min.py
new file mode 100644
index 0000000..e3adcc7
--- /dev/null
+++ b/onnx/reference/ops/op_min.py
@@ -0,0 +1,25 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryNumpy
+
+
+class Min(OpRunBinaryNumpy):
+    def __init__(self, onnx_node, run_params):
+        OpRunBinaryNumpy.__init__(self, np.minimum, onnx_node, run_params)
+
+    def run(self, *data):
+        if len(data) == 2:
+            return OpRunBinaryNumpy.run(self, *data)
+        if len(data) == 1:
+            return (data[0].copy(),)
+        if len(data) > 2:
+            a = data[0]
+            for i in range(1, len(data)):
+                a = np.minimum(a, data[i])
+            return (a,)
+        raise RuntimeError("Unexpected turn of events.")
diff --git a/onnx/reference/ops/op_mod.py b/onnx/reference/ops/op_mod.py
new file mode 100644
index 0000000..6f1cdad
--- /dev/null
+++ b/onnx/reference/ops/op_mod.py
@@ -0,0 +1,18 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Mod(OpRun):
+    def _run(self, a, b, fmod=None):
+        fmod = fmod or self.fmod
+        if fmod == 1:
+            return (np.fmod(a, b),)
+        if a.dtype in (np.float16, np.float32, np.float64):
+            return (np.nan_to_num(np.fmod(a, b)),)
+        return (np.nan_to_num(np.mod(a, b)),)
diff --git a/onnx/reference/ops/op_mul.py b/onnx/reference/ops/op_mul.py
new file mode 100644
index 0000000..5e343ca
--- /dev/null
+++ b/onnx/reference/ops/op_mul.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryNumpy
+
+
+class Mul(OpRunBinaryNumpy):
+    def __init__(self, onnx_node, run_params):
+        OpRunBinaryNumpy.__init__(self, np.multiply, onnx_node, run_params)
diff --git a/onnx/reference/ops/op_neg.py b/onnx/reference/ops/op_neg.py
new file mode 100644
index 0000000..6ec5400
--- /dev/null
+++ b/onnx/reference/ops/op_neg.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Neg(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.negative(x),)
diff --git a/onnx/reference/ops/op_negative_log_likelihood_loss.py b/onnx/reference/ops/op_negative_log_likelihood_loss.py
new file mode 100644
index 0000000..b0367e1
--- /dev/null
+++ b/onnx/reference/ops/op_negative_log_likelihood_loss.py
@@ -0,0 +1,84 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _compute_negative_log_likelihood_loss(
+    x, target, weight=None, reduction="mean", ignore_index=None
+):
+    input_shape = x.shape
+    if len(input_shape) == 1:
+        raise RuntimeError(f"Unsupported shape {input_shape!r}.")
+
+    target_shape = target.shape
+    N = input_shape[0]
+    C = input_shape[1]
+
+    # initialize the positional weights when required
+    gather_weight = None
+    if weight is not None:
+        # setting mode='clip' to deal with ignore_index > C or < 0 cases.
+        # when the target value is > C or < 0, it doesn't matter which value we are
+        # taking in gather_weight, since it will be set to 0 in the following if-block
+        # use np.int32 to make it compatible with x86 machines
+        gather_weight = np.take(weight, np.array(target, dtype=np.int32), mode="clip")
+        # set `ignore_index`'s loss weight to 0.
+        # The loss tensor will be multiplied by this weight tensor,
+        # so `ignore_index`'s loss value will be eliminated.
+        if ignore_index is not None:
+            gather_weight = np.where(target == ignore_index, 0, gather_weight).astype(
+                dtype=x.dtype
+            )
+    elif ignore_index != -1:
+        gather_weight = np.where(target == ignore_index, 0, 1).astype(dtype=x.dtype)
+
+    # if input is 4-d and above, make it 3-d
+    if len(input_shape) != 3:
+        x = x.reshape((N, C, -1))
+        target = target.reshape((N, -1))
+
+    # Get a dimension from the reshaped input.
+    # If the original input shape is [N, C, H, W],
+    # the D here should be H * W because we reshape
+    # [N, C, H, W] to [N, C, H * W].
+    D = x.shape[2]
+    neg_gather_element_input = np.zeros((N, D), dtype=x.dtype)
+    for i in range(N):
+        for d in range(D):
+            if target[i][d] != ignore_index:
+                neg_gather_element_input[i][d] = -x[i][target[i][d]][d]
+
+    loss = neg_gather_element_input
+
+    # if the input was 4-d or above reshape to the right shape
+    if len(input_shape) != 3:
+        loss = loss.reshape(target_shape)
+
+    # apply the weights when required
+    if gather_weight is not None:
+        loss = gather_weight * loss
+        if reduction == "mean":
+            loss = loss.sum() / gather_weight.sum()
+            return (loss,)
+
+    if reduction == "mean":
+        loss = np.mean(loss)
+    elif reduction == "sum":
+        loss = np.sum(loss)
+    return (loss.astype(x.dtype),)
+
+
+class NegativeLogLikelihoodLoss(OpRun):
+    def _run(self, x, target, weight=None, ignore_index=None, reduction=None):
+        return _compute_negative_log_likelihood_loss(
+            x,
+            target,
+            weight=weight,
+            reduction=reduction,
+            ignore_index=ignore_index,
+        )
diff --git a/onnx/reference/ops/op_non_max_suppression.py b/onnx/reference/ops/op_non_max_suppression.py
new file mode 100644
index 0000000..26922b1
--- /dev/null
+++ b/onnx/reference/ops/op_non_max_suppression.py
@@ -0,0 +1,271 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import dataclasses
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+@dataclasses.dataclass
+class PrepareContext:
+    boxes_data_: np.ndarray | None = None
+    boxes_size_: int = 0
+    scores_data_: np.ndarray | None = None
+    scores_size_: int = 0
+    max_output_boxes_per_class_: np.ndarray | None = None
+    score_threshold_: np.ndarray | None = None
+    iou_threshold_: np.ndarray | None = None
+    num_batches_: int = 0
+    num_classes_: int = 0
+    num_boxes_: int = 0
+
+
+class SelectedIndex:
+    __slots__ = ("batch_index_", "box_index_", "class_index_")
+
+    def __init__(
+        self, batch_index: int = 0, class_index: int = 0, box_index: int = 0
+    ) -> None:
+        self.batch_index_ = batch_index
+        self.class_index_ = class_index
+        self.box_index_ = box_index
+
+
+def max_min(lhs: float, rhs: float) -> tuple[float, float]:
+    if lhs >= rhs:
+        return rhs, lhs
+    return lhs, rhs
+
+
+def suppress_by_iou(  # noqa: PLR0911
+    boxes_data: np.ndarray,
+    box_index1: int,
+    box_index2: int,
+    center_point_box: int,
+    iou_threshold: float,
+) -> bool:
+    box1 = boxes_data[box_index1]
+    box2 = boxes_data[box_index2]
+    # center_point_box_ only support 0 or 1
+    if center_point_box == 0:
+        # boxes data format [y1, x1, y2, x2]
+        x1_min, x1_max = max_min(box1[1], box1[3])
+        x2_min, x2_max = max_min(box2[1], box2[3])
+
+        intersection_x_min = max(x1_min, x2_min)
+        intersection_x_max = min(x1_max, x2_max)
+        if intersection_x_max <= intersection_x_min:
+            return False
+
+        y1_min, y1_max = max_min(box1[0], box1[2])
+        y2_min, y2_max = max_min(box2[0], box2[2])
+        intersection_y_min = max(y1_min, y2_min)
+        intersection_y_max = min(y1_max, y2_max)
+        if intersection_y_max <= intersection_y_min:
+            return False
+    else:
+        # 1 == center_point_box_ => boxes data format [x_center, y_center, width, height]
+        box1_width_half = box1[2] / 2
+        box1_height_half = box1[3] / 2
+        box2_width_half = box2[2] / 2
+        box2_height_half = box2[3] / 2
+
+        x1_min = box1[0] - box1_width_half
+        x1_max = box1[0] + box1_width_half
+        x2_min = box2[0] - box2_width_half
+        x2_max = box2[0] + box2_width_half
+
+        intersection_x_min = max(x1_min, x2_min)
+        intersection_x_max = min(x1_max, x2_max)
+        if intersection_x_max <= intersection_x_min:
+            return False
+
+        y1_min = box1[1] - box1_height_half
+        y1_max = box1[1] + box1_height_half
+        y2_min = box2[1] - box2_height_half
+        y2_max = box2[1] + box2_height_half
+
+        intersection_y_min = max(y1_min, y2_min)
+        intersection_y_max = min(y1_max, y2_max)
+        if intersection_y_max <= intersection_y_min:
+            return False
+
+    intersection_area = (intersection_x_max - intersection_x_min) * (
+        intersection_y_max - intersection_y_min
+    )
+    if intersection_area <= 0:
+        return False
+
+    area1 = (x1_max - x1_min) * (y1_max - y1_min)
+    area2 = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = area1 + area2 - intersection_area
+
+    if area1 <= 0 or area2 <= 0 or union_area <= 0:
+        return False
+
+    intersection_over_union = intersection_area / union_area
+    return intersection_over_union > iou_threshold
+
+
+class BoxInfo:
+    def __init__(self, score: float = 0, idx: int = -1):
+        self.score_ = score
+        self.idx_ = idx
+
+    def __lt__(self, rhs) -> bool:
+        return self.score_ < rhs.score_ or (
+            self.score_ == rhs.score_ and self.idx_ > rhs.idx_
+        )
+
+    def __repr__(self) -> str:
+        return f"BoxInfo({self.score_}, {self.idx_})"
+
+
+class NonMaxSuppression(OpRun):
+    def get_thresholds_from_inputs(
+        self,
+        pc: PrepareContext,
+        max_output_boxes_per_class: int,
+        iou_threshold: float,
+        score_threshold: float,
+    ) -> tuple[int, float, float]:
+        if pc.max_output_boxes_per_class_ is not None:
+            max_output_boxes_per_class = max(pc.max_output_boxes_per_class_[0], 0)
+
+        if pc.iou_threshold_ is not None:
+            iou_threshold = pc.iou_threshold_[0]
+
+        if pc.score_threshold_ is not None:
+            score_threshold = pc.score_threshold_[0]
+
+        return max_output_boxes_per_class, iou_threshold, score_threshold
+
+    def prepare_compute(
+        self,
+        pc: PrepareContext,
+        boxes_tensor: np.ndarray,  # float
+        scores_tensor: np.ndarray,  # float
+        max_output_boxes_per_class_tensor: np.ndarray,  # int
+        iou_threshold_tensor: np.ndarray,  # float
+        score_threshold_tensor: np.ndarray,  # float
+    ):
+        pc.boxes_data_ = boxes_tensor
+        pc.scores_data_ = scores_tensor
+
+        if max_output_boxes_per_class_tensor.size != 0:
+            pc.max_output_boxes_per_class_ = max_output_boxes_per_class_tensor
+        if iou_threshold_tensor.size != 0:
+            pc.iou_threshold_ = iou_threshold_tensor
+        if score_threshold_tensor is not None and score_threshold_tensor.size != 0:
+            pc.score_threshold_ = score_threshold_tensor
+
+        pc.boxes_size_ = boxes_tensor.size
+        pc.scores_size_ = scores_tensor.size
+
+        boxes_dims = boxes_tensor.shape
+        scores_dims = scores_tensor.shape
+
+        pc.num_batches_ = boxes_dims[0]
+        pc.num_classes_ = scores_dims[1]
+        pc.num_boxes_ = boxes_dims[1]
+
+    def _run(
+        self,
+        boxes,
+        scores,
+        max_output_boxes_per_class=None,
+        iou_threshold=None,
+        score_threshold=None,
+        center_point_box=None,
+    ):
+        pc = PrepareContext()
+        self.prepare_compute(
+            pc,
+            boxes,
+            scores,
+            max_output_boxes_per_class,
+            iou_threshold,
+            score_threshold,
+        )
+
+        (
+            max_output_boxes_per_class,
+            iou_threshold,
+            score_threshold,
+        ) = self.get_thresholds_from_inputs(pc, 0, 0, 0)
+
+        if max_output_boxes_per_class.size == 0:
+            return (np.empty((0,), dtype=np.int64),)
+
+        boxes_data = pc.boxes_data_
+        scores_data = pc.scores_data_
+
+        selected_indices = []
+        # std::vector<BoxInfo> selected_boxes_inside_class;
+        # selected_boxes_inside_class.reserve(
+        #    std::min<size_t>(static_cast<size_t>(max_output_boxes_per_class), pc.num_boxes_));
+
+        for batch_index in range(pc.num_batches_):
+            for class_index in range(pc.num_classes_):
+                box_score_offset = (batch_index, class_index)
+                batch_boxes = boxes_data[batch_index]
+                # std::vector<BoxInfo> candidate_boxes;
+                # candidate_boxes.reserve(pc.num_boxes_);
+
+                # Filter by score_threshold_
+                candidate_boxes = []
+                class_scores = scores_data[box_score_offset]
+                if pc.score_threshold_ is not None:
+                    for box_index in range(pc.num_boxes_):
+                        if class_scores[box_index] > score_threshold:
+                            candidate_boxes.append(  # noqa: PERF401
+                                BoxInfo(class_scores[box_index], box_index)
+                            )
+                else:
+                    for box_index in range(pc.num_boxes_):
+                        candidate_boxes.append(  # noqa: PERF401
+                            BoxInfo(class_scores[box_index], box_index)
+                        )
+
+                sorted_boxes = sorted(candidate_boxes)
+
+                selected_boxes_inside_class = []
+                # Get the next box with top score, filter by iou_threshold.
+                while (
+                    len(sorted_boxes) > 0
+                    and len(selected_boxes_inside_class) < max_output_boxes_per_class
+                ):
+                    next_top_score = sorted_boxes[-1]
+
+                    selected = True
+                    # Check with existing selected boxes for this class,
+                    # suppress if exceed the IOU (Intersection Over Union) threshold.
+                    for selected_index in selected_boxes_inside_class:
+                        if suppress_by_iou(
+                            batch_boxes,
+                            next_top_score.idx_,
+                            selected_index.idx_,
+                            center_point_box,
+                            iou_threshold,
+                        ):
+                            selected = False
+                            break
+
+                    if selected:
+                        selected_boxes_inside_class.append(next_top_score)
+                        selected_indices.append(
+                            SelectedIndex(batch_index, class_index, next_top_score.idx_)
+                        )
+
+                    sorted_boxes.pop()
+
+        result = np.empty((len(selected_indices), 3), dtype=np.int64)
+        for i in range(result.shape[0]):
+            result[i, 0] = selected_indices[i].batch_index_
+            result[i, 1] = selected_indices[i].class_index_
+            result[i, 2] = selected_indices[i].box_index_
+        return (result,)
diff --git a/onnx/reference/ops/op_non_zero.py b/onnx/reference/ops/op_non_zero.py
new file mode 100644
index 0000000..855b0e5
--- /dev/null
+++ b/onnx/reference/ops/op_non_zero.py
@@ -0,0 +1,15 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class NonZero(OpRun):
+    def _run(self, x):
+        # Specify np.int64 for Windows x86 machines
+        res = np.vstack(np.nonzero(x)).astype(np.int64)
+        return (res,)
diff --git a/onnx/reference/ops/op_not.py b/onnx/reference/ops/op_not.py
new file mode 100644
index 0000000..3ca7e70
--- /dev/null
+++ b/onnx/reference/ops/op_not.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnary
+
+
+class Not(OpRunUnary):
+    def _run(self, x):
+        return (np.logical_not(x),)
diff --git a/onnx/reference/ops/op_one_hot.py b/onnx/reference/ops/op_one_hot.py
new file mode 100644
index 0000000..b518e8c
--- /dev/null
+++ b/onnx/reference/ops/op_one_hot.py
@@ -0,0 +1,32 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _one_hot(indices, depth, axis=-1, dtype=np.float32):
+    values = np.asarray(indices)
+    rank = len(values.shape)
+    depth_range = np.arange(depth)
+    if axis < 0:
+        axis += rank + 1
+    ls = values.shape[0:axis]
+    rs = values.shape[axis:rank]
+    new_shape = (1,) * len(ls) + depth_range.shape + (1,) * len(rs)
+    targets = np.reshape(depth_range, new_shape)
+    # Wrap negative in-range indices; leave out-of-range ones unmatched (all off_value).
+    values = np.where(values < 0, values + depth, values)
+    values = np.reshape(values, (*ls, 1, *rs))
+    return np.asarray(targets == values, dtype=dtype)
+
+
+class OneHot(OpRun):
+    def _run(self, indices, depth, values, axis=None):
+        off_value, on_value = values
+        y = _one_hot(indices, depth, axis=axis, dtype=values.dtype)
+        y = y * (on_value - off_value) + off_value
+        return (y,)
diff --git a/onnx/reference/ops/op_optional.py b/onnx/reference/ops/op_optional.py
new file mode 100644
index 0000000..d98b301
--- /dev/null
+++ b/onnx/reference/ops/op_optional.py
@@ -0,0 +1,18 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.helper import tensor_dtype_to_np_dtype
+from onnx.reference.op_run import OpRun
+
+
+class Optional(OpRun):
+    def _run(self, x=None, type=None):  # type: ignore[override]  # noqa: A002
+        if x is not None and type is not None:
+            dt = tensor_dtype_to_np_dtype(type)
+            if dt != x.dtype:
+                raise TypeError(
+                    f"Input dtype {x.dtype} ({dt}) and parameter type_proto {type} disagree"
+                )
+        return ([x],)
diff --git a/onnx/reference/ops/op_optional_get_element.py b/onnx/reference/ops/op_optional_get_element.py
new file mode 100644
index 0000000..b759d09
--- /dev/null
+++ b/onnx/reference/ops/op_optional_get_element.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class OptionalGetElement(OpRun):
+    def _run(self, x):
+        if x is None:
+            raise ValueError("The requested optional input has no value.")
+        return (x,)
diff --git a/onnx/reference/ops/op_optional_has_element.py b/onnx/reference/ops/op_optional_has_element.py
new file mode 100644
index 0000000..e68dd40
--- /dev/null
+++ b/onnx/reference/ops/op_optional_has_element.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class OptionalHasElement(OpRun):
+    def _run(self, x=None):
+        return (np.array(x is not None),)
diff --git a/onnx/reference/ops/op_or.py b/onnx/reference/ops/op_or.py
new file mode 100644
index 0000000..171d702
--- /dev/null
+++ b/onnx/reference/ops/op_or.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinary
+
+
+class Or(OpRunBinary):
+    def _run(self, x, y):
+        return (np.logical_or(x, y),)
diff --git a/onnx/reference/ops/op_pad.py b/onnx/reference/ops/op_pad.py
new file mode 100644
index 0000000..a726370
--- /dev/null
+++ b/onnx/reference/ops/op_pad.py
@@ -0,0 +1,65 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _pad_impl(data, raw_pads, mode, constant_values=0.0, axes=None):
+    input_rank = data.ndim
+    if axes is None:
+        axes = list(range(input_rank))
+    else:
+        axes = [axis if axis >= 0 else axis + input_rank for axis in axes]
+    num_axes = len(axes)
+    if num_axes * 2 != len(raw_pads):
+        raise RuntimeError(
+            "The number of elements in raw_pads should be 2 times the number of axes"
+        )
+
+    pad_width = [(0, 0)] * input_rank
+    for i, axis in enumerate(axes):
+        pad_begin = raw_pads[i]
+        pad_end = raw_pads[num_axes + i]
+        pad_width[axis] = (pad_begin, pad_end)
+
+    if mode == "constant":
+        return np.pad(
+            data, pad_width=pad_width, mode=mode, constant_values=constant_values
+        ).astype(data.dtype)
+    return np.pad(data, pad_width=pad_width, mode=mode).astype(data.dtype)
+
+
+class Pad_1(OpRun):
+    def _run(self, data, paddings=None, mode=None, value=None):
+        if value is None:
+            value = 0
+        return (_pad_impl(data, paddings, mode=mode, constant_values=value),)
+
+
+class Pad_2(OpRun):
+    def _run(self, data, pads=None, mode=None, value=None):
+        if value is None:
+            value = 0
+        return (_pad_impl(data, pads, mode=mode, constant_values=value),)
+
+
+class Pad_11(OpRun):
+    def _run(self, data, pads, constant_value=None, mode=None):
+        if constant_value is None:
+            constant_value = 0
+        return (
+            _pad_impl(data, pads, mode=mode, constant_values=constant_value, axes=None),
+        )
+
+
+class Pad_18(OpRun):
+    def _run(self, data, pads, constant_value=None, axes=None, mode=None):
+        if constant_value is None:
+            constant_value = 0
+        return (
+            _pad_impl(data, pads, mode=mode, constant_values=constant_value, axes=axes),
+        )
diff --git a/onnx/reference/ops/op_pool_common.py b/onnx/reference/ops/op_pool_common.py
new file mode 100644
index 0000000..2f201ba
--- /dev/null
+++ b/onnx/reference/ops/op_pool_common.py
@@ -0,0 +1,345 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import itertools
+import math
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def get_pad_shape(
+    auto_pad: str,
+    input_spatial_shape: Sequence[int],
+    kernel_spatial_shape: Sequence[int],
+    strides_spatial: Sequence[int],
+    output_spatial_shape: Sequence[int],
+) -> Sequence[int]:
+    spatial_dims = len(input_spatial_shape)
+    pad_shape = [0] * spatial_dims
+    strides_spatial = strides_spatial or [1] * spatial_dims
+    if auto_pad in ("SAME_UPPER", "SAME_LOWER"):
+        for i in range(spatial_dims):
+            pad_shape[i] = (
+                (output_spatial_shape[i] - 1) * strides_spatial[i]
+                + kernel_spatial_shape[i]
+                - input_spatial_shape[i]
+            )
+    elif auto_pad == "VALID":
+        pass
+
+    return pad_shape
+
+
+def get_pad_with_auto_pad(auto_pad: str, pad_shape: Sequence[int]) -> Sequence[int]:
+    spatial_dims = len(pad_shape)
+    if auto_pad == "SAME_UPPER":
+        pads = [pad_shape[i] // 2 for i in range(spatial_dims)] + [
+            pad_shape[i] - pad_shape[i] // 2 for i in range(spatial_dims)
+        ]
+    elif auto_pad == "SAME_LOWER":
+        pads = [pad_shape[i] - pad_shape[i] // 2 for i in range(spatial_dims)] + [
+            pad_shape[i] // 2 for i in range(spatial_dims)
+        ]
+    else:
+        pads = [0] * spatial_dims * 2  # no padding
+    return pads
+
+
+def get_output_shape_explicit_padding(
+    pads: Sequence[int] | None,
+    input_spatial_shape: Sequence[int],
+    kernel_spatial_shape: Sequence[int],
+    strides_spatial: Sequence[int],
+    dilations: Sequence[int] | None = None,
+    ceil_mode: bool = False,
+) -> tuple[Sequence[int], Sequence[int]]:
+    """Compute output shape according to:
+    https://pytorch.org/docs/stable/generated/torch.nn.MaxPool1d.html?highlight=max+pool#torch.nn.MaxPool1d
+    Pads are used to calculate output shape. Use output shape in turn to calculate the actual pads
+    that are used to pad the input tensor so that computation in pool() will not cause out of bound error.
+    Here is the detail. Thinking kernel as a sliding window, its size:
+    sw = dilation * (kernel - 1) + 1
+    l_out = (l_in + pad[0] + pad[1] - sw) / stride + 1 # (ceiled if ceil_mode is True)
+    l_in_required = (l_out - 1) * stride + sw
+
+    l_in_required is used to for computation in pool() which may be larger than padded l_in, because of ceiling.
+    as an example, l_in = 3, kernel = 2, stride = 2, dilation = 1, pad = [0, 0], then
+    sw = dilation * (kernel - 1) + 1 = 1 * (2 - 1) + 1 = 2
+    l_out = ceil((l_in + pad[0] + pad[1] - sw) / stride + 1) = ceil((3 + 0 + 0 - 1 * (2 - 1) - 1) / 2 + 1) = 2
+    l_in_required = (l_out - 1) * stride + sw = (2 - 1) * 2 + 2 = 4
+    l_in_required (= 4) is not equal to l_in (= 3), so we need to pad the input tensor to l_in_required to make sure that
+    the sliding window does not go out-of-bound w.r.t. input tensor. Otherwise pool() will fail.
+    """
+    output_spatial_shape = [0] * len(input_spatial_shape)
+    pads = pads or [0] * len(input_spatial_shape) * 2
+    strides_spatial = strides_spatial or [1] * len(input_spatial_shape)
+    dims = len(input_spatial_shape)
+    if dilations is None:
+        dilations = np.ones([dims], dtype=np.int64)
+
+    for dim in range(dims):
+        dim_size = (
+            input_spatial_shape[dim]
+            + pads[dim]
+            + pads[dims + dim]
+            - dilations[dim] * (kernel_spatial_shape[dim] - 1)
+            - 1
+        ) / strides_spatial[dim] + 1
+
+        if ceil_mode:
+            output_spatial_shape[dim] = int(np.ceil(dim_size))
+            # NOTE: ensure that the last pooling starts inside the image
+            if (output_spatial_shape[dim] - 1) * strides_spatial[
+                dim
+            ] >= input_spatial_shape[dim] + pads[dim]:
+                output_spatial_shape[dim] -= 1
+        else:
+            output_spatial_shape[dim] = int(np.floor(dim_size))
+
+    pads_spatial_shape_new = pads[:]
+    for dim in range(dims):
+        sliding_window_size = (kernel_spatial_shape[dim] - 1) * dilations[dim] + 1
+        actual_padded_input_size = (output_spatial_shape[dim] - 1) * strides_spatial[
+            dim
+        ] + sliding_window_size
+        extra_pad = (
+            actual_padded_input_size
+            - input_spatial_shape[dim]
+            - pads[dim]
+            - pads[dims + dim]
+        )
+        if extra_pad > 0:
+            pads_spatial_shape_new[dim] += extra_pad // 2
+            pads_spatial_shape_new[dims + dim] += extra_pad - extra_pad // 2
+
+    return output_spatial_shape, pads_spatial_shape_new
+
+
+def get_output_shape_auto_pad(
+    auto_pad: str,
+    input_spatial_shape: Sequence[int],
+    kernel_spatial_shape: Sequence[int],
+    strides_spatial: Sequence[int],
+) -> Sequence[int]:
+    """https://www.tensorflow.org/api_docs/python/tf/keras/layers/AveragePooling2D
+    output_shape = math.floor((input_shape - 1) / strides) + 1  (SAME)
+    output_shape = math.floor((input_shape - pool_size) / strides) + 1 (VALID)
+    IMPORTANT: this function assumes ceil_mode is False. In tenforflow, ceil_mode is always False.
+    However, ONNX spec allow ceil_mode to be True because ORT does handle the case.
+    """
+    strides_spatial = strides_spatial or [1] * len(input_spatial_shape)
+    out_shape = [0] * len(input_spatial_shape)
+    for i in range(len(input_spatial_shape)):
+        if auto_pad in ("SAME_UPPER", "SAME_LOWER"):
+            out_shape[i] = (
+                math.floor((input_spatial_shape[i] - 1) / strides_spatial[i]) + 1
+            )
+        elif auto_pad == "VALID":
+            out_shape[i] = (
+                math.floor(
+                    (input_spatial_shape[i] - kernel_spatial_shape[i])
+                    / strides_spatial[i]
+                )
+                + 1
+            )
+        # if auto_pad is NOTSET, explicit padding should be used
+        else:
+            raise ValueError(
+                "auto_pad can only be NOTSET, SAME_UPPER, SAME_LOWER, or VALID"
+            )
+    # pads = get_pad_shape(auto_pad, input_spatial_shape, kernel_shape, strides_spatial, out_shape)
+
+    return out_shape
+
+
+def pool(
+    padded: np.ndarray,
+    x_shape: Sequence[int],
+    kernel: Sequence[int],
+    strides: Sequence[int],
+    out_shape: Sequence[int],
+    pooling_type: str,
+    pads_required: Sequence[int] | None = None,
+    pads: Sequence[int] | None = None,
+    dilations: Sequence[int] | None = None,
+    count_include_pad: int = 0,
+    p: int = 1,
+) -> np.ndarray:
+    """This function is used to calculate the pooling result of a padded tensor
+    padded: the padded tensor
+    x_shape: the shape of the original tensor in [N, C, *spatial_shape]
+    kernel: the pooling kernel
+    strides: the strides
+    out_shape: the shape of the output tensor
+    pooling_type: the pooling type, can be "AVG", "LPPOOL", or "MAX"
+    pads_required: the required padding to make sure the sliding window does not go out-of-bound
+    pads: the padding in an order of head_pad_1, head_pad_2, ..., tail_pad_1, tail_pad_2, ...
+    dilations: the dilation
+    count_include_pad: whether to include the padding in the calculation of average and lp pooling
+    p: the p value for lp pooling
+    """
+    spatial_size = len(x_shape) - 2
+    y = np.zeros([x_shape[0], x_shape[1], *list(out_shape)], dtype=padded.dtype)
+    if dilations is None:
+        dilations = np.ones([spatial_size], dtype=np.int64)
+    if pads_required is None:
+        pads_required = np.zeros([spatial_size * 2], dtype=np.int64)
+    elif len(pads_required) == 1:
+        pads_required = pads_required * spatial_size * 2
+    if pads is None:
+        pads = np.zeros([spatial_size * 2], dtype=np.int64)
+    elif len(pads) == 1:
+        pads = pads * spatial_size * 2
+    strides = strides or [1] * spatial_size
+
+    # Iterate all the possible sliding windows
+    for shape in itertools.product(
+        range(x_shape[0]),  # e.g. dim=0: [0]
+        range(x_shape[1]),  # e.g. dim=1: [0, 1]
+        *[
+            range(
+                int(
+                    (
+                        x_shape[i + 2]
+                        + pads_required[i]
+                        + pads_required[i + spatial_size]
+                        - (1 + (kernel[i] - 1) * dilations[i])
+                    )
+                    / strides[i]
+                    + 1
+                )
+            )
+            for i in range(spatial_size)
+        ],
+    ):
+        window = padded[shape[0], shape[1]]
+        window_vals = np.array(
+            [
+                window[i]
+                for i in list(
+                    itertools.product(
+                        *[
+                            [
+                                pixel
+                                for pixel in range(
+                                    strides[i] * shape[i + 2],
+                                    strides[i] * shape[i + 2]
+                                    + (1 + (kernel[i] - 1) * dilations[i]),
+                                    dilations[i],
+                                )
+                                if pixel
+                                < x_shape[i + 2] + pads[i] + pads[spatial_size + i]
+                            ]
+                            for i in range(spatial_size)
+                        ]
+                    )
+                )
+            ]
+        )
+
+        if pooling_type == "AVG":
+            f = np.average
+        elif pooling_type == "MAX":
+            f = np.max
+        elif pooling_type == "LPPOOL":
+
+            def lp_pool(x: np.array, p: int = p) -> float:
+                return np.sum(np.abs(x) ** p) ** (1.0 / p)
+
+            f = lp_pool
+        else:
+            raise NotImplementedError(
+                f"Pooling type {pooling_type} does not support. Should be AVG, MAX"
+            )
+
+        if count_include_pad == 1 and (pooling_type in {"AVG", "LPPOOL"}):
+            y[shape] = f(window_vals)
+        else:
+            y[shape] = f(window_vals[np.where(~np.isnan(window_vals))])
+    return y.astype(padded.dtype)
+
+
+class CommonPool(OpRun):
+    def _run(
+        self,
+        pooling_type,
+        count_include_pad,
+        x,
+        auto_pad=None,
+        ceil_mode=None,
+        dilations=None,
+        kernel_shape=None,
+        pads=None,
+        strides=None,
+        p=None,
+    ):
+        x_shape = np.shape(x)
+        padding_value = np.nan if pooling_type == "MAX" or count_include_pad == 0 else 0
+
+        if auto_pad in ["SAME_UPPER", "SAME_LOWER", "VALID"]:
+            assert ceil_mode is None or ceil_mode == 0, (
+                "ceil_mode is not supported with auto_pad"
+            )
+            out_shape = get_output_shape_auto_pad(
+                auto_pad, x.shape[2:], kernel_shape, strides
+            )
+            pads_shape = get_pad_shape(
+                auto_pad, x_shape[2:], kernel_shape, strides, out_shape
+            )
+            pads = get_pad_with_auto_pad(auto_pad, pads_shape)
+            n_dims = len(pads) // 2
+            pads_np = [(pads[i], pads[i + n_dims]) for i in range(n_dims)]
+            padded = np.pad(
+                x,
+                ((0, 0), (0, 0), *pads_np),
+                mode="constant",
+                constant_values=padding_value,
+            )
+            y = pool(
+                padded,
+                x_shape,
+                kernel_shape,
+                strides,
+                out_shape,
+                pooling_type,
+                pads,
+                pads,
+                dilations,
+                count_include_pad,
+                p,
+            )
+            return (y,)
+        out_shape, extra_pads = get_output_shape_explicit_padding(
+            pads, x_shape[2:], kernel_shape, strides, dilations, ceil_mode
+        )
+        # convert pads from [x1_begin, x2_begin,...,x1_end, x2_end,...] to [(x1_begin, x1_end), (x2_begin, x2_end),...]
+        n_dims = len(extra_pads) // 2
+        pads_np = [(extra_pads[i], extra_pads[i + n_dims]) for i in range(n_dims)]
+        padded = np.pad(
+            x,
+            ((0, 0), (0, 0), *pads_np),
+            mode="constant",
+            constant_values=padding_value,
+        )
+        y = pool(
+            padded,
+            x_shape,
+            kernel_shape,
+            strides,
+            out_shape,
+            pooling_type,
+            extra_pads,
+            pads,
+            dilations,
+            count_include_pad,
+            p,
+        )
+        return (y,)
diff --git a/onnx/reference/ops/op_pow.py b/onnx/reference/ops/op_pow.py
new file mode 100644
index 0000000..6670dde
--- /dev/null
+++ b/onnx/reference/ops/op_pow.py
@@ -0,0 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from warnings import catch_warnings, simplefilter
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Pow(OpRun):
+    def _run(self, a, b):
+        with catch_warnings():
+            simplefilter("ignore")
+            return (np.power(a, b).astype(a.dtype),)
diff --git a/onnx/reference/ops/op_prelu.py b/onnx/reference/ops/op_prelu.py
new file mode 100644
index 0000000..bdc7085
--- /dev/null
+++ b/onnx/reference/ops/op_prelu.py
@@ -0,0 +1,34 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class PRelu(OpRun):
+    def _run(self, x, slope):
+        try:
+            return (np.where(x > 0, x, x * slope).astype(x.dtype),)
+        except ValueError:
+            # Broadcast did not work according to numpy.
+            # The logic is then the following, if slope has d elements,
+            # the following code is looking for d in x.shape. If it is found
+            # only once, x * slope is broadcasted on any other dimension.
+            # Otherwise, it raises e.
+            if len(slope.shape) == 1:
+                dim = slope.shape[0]
+                new_shape = []
+                n = 0
+                for d in x.shape:
+                    if d == dim:
+                        new_shape.append(d)
+                        n += 1
+                    else:
+                        new_shape.append(1)
+                if n == 1:
+                    xs = x * slope.reshape(tuple(new_shape))
+                    return (np.where(x > 0, x, xs).astype(x.dtype),)
+            raise
diff --git a/onnx/reference/ops/op_qlinear_conv.py b/onnx/reference/ops/op_qlinear_conv.py
new file mode 100644
index 0000000..811ec4b
--- /dev/null
+++ b/onnx/reference/ops/op_qlinear_conv.py
@@ -0,0 +1,78 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops.op_conv import _conv_implementation
+
+
+class QLinearConv(OpRun):
+    def _run(
+        self,
+        x,
+        x_scale,
+        x_zero_point,
+        w,
+        w_scale,
+        w_zero_point,
+        y_scale,
+        y_zero_point,
+        B=None,
+        auto_pad=None,
+        dilations=None,
+        group=None,
+        kernel_shape=None,
+        pads=None,
+        strides=None,
+    ):
+        auto_pad = auto_pad or self.auto_pad
+        dilations = dilations or self.dilations
+        group = group or self.group
+        kernel_shape = kernel_shape or self.kernel_shape
+        pads = pads or self.pads
+        strides = strides or self.strides
+
+        X = x.astype(np.int32)
+        if x_zero_point is not None:
+            X -= x_zero_point
+        W = w.astype(np.int32)
+        if w_zero_point is not None:
+            if len(w_zero_point.shape) == 1 and w_zero_point.shape[0] == W.shape[0]:
+                missing = (w_zero_point.shape[0],) + (1,) * (len(W.shape) - 1)
+                W -= w_zero_point.reshape(missing)
+            else:
+                W -= w_zero_point
+
+        res = _conv_implementation(
+            X, W, B, auto_pad, dilations, group, kernel_shape, pads, strides
+        ).astype(np.int32)
+
+        # w_scale could be a scalar or a 1-D tensor. A 1-D tensor means a per
+        # output channel quantization.
+        if np.size(w_scale) > 1:
+            if np.ndim(w_scale) != 1:
+                raise ValueError(
+                    f"w_scale must be a scalar or a 1-D tensor. Got shape {np.shape(w_scale)}."
+                )
+            if np.size(w_scale) != np.shape(w)[0]:
+                raise ValueError(
+                    f"w_scale elements must match output channels: {np.size(w_scale)} != {np.shape(w)[0]}"
+                )
+            w_scale = np.expand_dims(w_scale, (0, 2, 3))
+
+        R = res * (x_scale * w_scale / y_scale)
+        if y_zero_point is not None:
+            R += y_zero_point
+            if y_zero_point.dtype == np.int8:
+                R = np.clip(R, -128, 127)
+            else:
+                R = np.clip(R, 0, 255)
+            return (np.round(R).astype(y_zero_point.dtype),)
+        if x.dtype == np.int8:
+            R = np.clip(R, -128, 127)
+        else:
+            R = np.clip(R, 0, 255)
+        return (np.round(R).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_qlinear_matmul.py b/onnx/reference/ops/op_qlinear_matmul.py
new file mode 100644
index 0000000..cdaaa32
--- /dev/null
+++ b/onnx/reference/ops/op_qlinear_matmul.py
@@ -0,0 +1,29 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class QLinearMatMul(OpRun):
+    def _run(
+        self, a, a_scale, a_zero_point, b, b_scale, b_zero_point, y_scale, y_zero_point
+    ):
+        A = a.astype(np.int32)
+        if a_zero_point is not None:
+            A -= a_zero_point.astype(np.int32)
+        B = b.astype(np.int32)
+        if b_zero_point is not None:
+            B -= b_zero_point.astype(np.int32)
+        C = np.matmul(A, B)
+        D = C * (a_scale * b_scale / y_scale)
+        if y_zero_point is not None:
+            D += y_zero_point
+            dtype = y_zero_point.dtype
+        else:
+            dtype = a.dtype
+        qmin, qmax = np.iinfo(dtype).min, np.iinfo(dtype).max
+        return (np.clip(np.rint(D), qmin, qmax).astype(dtype),)
diff --git a/onnx/reference/ops/op_quantize_linear.py b/onnx/reference/ops/op_quantize_linear.py
new file mode 100644
index 0000000..df6c3c3
--- /dev/null
+++ b/onnx/reference/ops/op_quantize_linear.py
@@ -0,0 +1,191 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+
+
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx import TensorProto
+from onnx.helper import (
+    np_dtype_to_tensor_dtype,
+    tensor_dtype_to_np_dtype,
+)
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops._quant_utils import reshape_input as _reshape_input
+
+_QUANT_TYPES = {
+    TensorProto.UINT8,
+    TensorProto.INT8,
+    TensorProto.UINT16,
+    TensorProto.INT16,
+    TensorProto.INT2,
+    TensorProto.UINT2,
+    TensorProto.UINT4,
+    TensorProto.INT4,
+    TensorProto.FLOAT8E4M3FN,
+    TensorProto.FLOAT8E4M3FNUZ,
+    TensorProto.FLOAT8E5M2,
+    TensorProto.FLOAT8E5M2FNUZ,
+    TensorProto.FLOAT4E2M1,
+}
+
+_QUANT_INTEGER_RANGES = {
+    TensorProto.UINT8: (0, 255),
+    TensorProto.INT8: (-128, 127),
+    TensorProto.UINT16: (0, 65535),
+    TensorProto.INT16: (-32768, 32767),
+    TensorProto.UINT4: (0, 15),
+    TensorProto.INT4: (-8, 7),
+    TensorProto.UINT2: (0, 3),
+    TensorProto.INT2: (-2, 1),
+}
+
+
+class _CommonQuantizeLinear(OpRun):
+    def _run(
+        self,
+        x: np.ndarray,
+        y_scale: np.ndarray,
+        zero_point: np.ndarray | None = None,
+        axis: int = 1,
+        saturate: bool = True,
+        block_size: int | None = None,
+        output_dtype: TensorProto.DataType | None = None,
+        precision: int | None = None,
+    ) -> tuple[np.ndarray]:
+        y_scale = _reshape_input(y_scale, x.shape, axis, block_size)
+
+        # Determine output data type
+        tensor_type = output_dtype
+        if zero_point is not None:
+            zero_point_type = np_dtype_to_tensor_dtype(zero_point.dtype)
+            if output_dtype and output_dtype != zero_point_type:
+                raise ValueError(
+                    f"Mismatched output data-types: output_dtype={output_dtype}, zero_point type={zero_point_type}"
+                )
+            tensor_type = zero_point_type
+        tensor_type = tensor_type or TensorProto.UINT8
+
+        if tensor_type not in _QUANT_TYPES:
+            raise ValueError(
+                f"Unexpected type: output_dtype={tensor_type} is not a supported quantized type."
+            )
+
+        # Compute
+        zero_point = (
+            _reshape_input(zero_point, x.shape, axis, block_size)
+            if zero_point is not None
+            else 0
+        )
+        if precision:
+            precision_np = tensor_dtype_to_np_dtype(precision)
+            x = x.astype(precision_np) / y_scale.astype(precision_np)
+        else:
+            x = x / y_scale
+
+        if tensor_type in _QUANT_INTEGER_RANGES:
+            xi = np.rint(x).astype(np.int32)
+            xi += zero_point
+            dtype = tensor_dtype_to_np_dtype(tensor_type)
+            quant_range = _QUANT_INTEGER_RANGES[tensor_type]
+            return (np.clip(xi, quant_range[0], quant_range[1]).astype(dtype),)
+
+        if tensor_type in {
+            TensorProto.FLOAT8E4M3FN,
+            TensorProto.FLOAT8E4M3FNUZ,
+            TensorProto.FLOAT8E5M2,
+            TensorProto.FLOAT8E5M2FNUZ,
+        }:
+            if saturate:
+                return (
+                    onnx.numpy_helper.saturate_cast(
+                        x, dtype=tensor_dtype_to_np_dtype(tensor_type)
+                    ),
+                )
+            return (x.astype(tensor_dtype_to_np_dtype(tensor_type)),)
+
+        if tensor_type == TensorProto.FLOAT4E2M1:
+            x += zero_point
+            return (x.astype(tensor_dtype_to_np_dtype(tensor_type)),)
+
+        raise ValueError(
+            f"Unexpected type: output_dtype={tensor_type} is not a supported quantized type."
+        )
+
+
+class QuantizeLinear_10(_CommonQuantizeLinear):
+    def _run(self, x, y_scale, zero_point=None, axis: int = 1):
+        if len(y_scale.shape) > 1:
+            raise ValueError("Input 2 must be a vector or a number.")
+        return super()._run(x, y_scale, zero_point, axis=axis)
+
+
+class QuantizeLinear_19(_CommonQuantizeLinear):
+    def _run(self, x, y_scale, zero_point=None, axis: int = 1, saturate: bool = True):
+        if len(y_scale.shape) > 1:
+            raise ValueError("Input 2 must be a vector or a number.")
+        return super()._run(x, y_scale, zero_point, axis=axis, saturate=saturate)
+
+
+class QuantizeLinear_21(_CommonQuantizeLinear):
+    def _run(
+        self,
+        *args,
+        axis: int = 1,
+        saturate: bool = True,
+        block_size: int = 0,
+        output_dtype=None,
+    ):
+        # args: x, y_scale, zero_point
+        return super()._run(
+            *args,
+            axis=axis,
+            saturate=saturate,
+            block_size=block_size,
+            output_dtype=output_dtype,
+        )
+
+
+class QuantizeLinear_23(_CommonQuantizeLinear):
+    def _run(
+        self,
+        *args,
+        axis: int = 1,
+        saturate: bool = True,
+        block_size: int = 0,
+        output_dtype=None,
+        precision=None,
+    ):
+        # args: x, y_scale, zero_point
+        return super()._run(
+            *args,
+            axis=axis,
+            saturate=saturate,
+            block_size=block_size,
+            output_dtype=output_dtype,
+            precision=precision,
+        )
+
+
+class QuantizeLinear_25(_CommonQuantizeLinear):
+    def _run(
+        self,
+        *args,
+        axis: int = 1,
+        saturate: bool = True,
+        block_size: int = 0,
+        output_dtype=None,
+        precision=None,
+    ):
+        # args: x, y_scale, zero_point
+        return super()._run(
+            *args,
+            axis=axis,
+            saturate=saturate,
+            block_size=block_size,
+            output_dtype=output_dtype,
+            precision=precision,
+        )
diff --git a/onnx/reference/ops/op_random_normal.py b/onnx/reference/ops/op_random_normal.py
new file mode 100644
index 0000000..7fd8dba
--- /dev/null
+++ b/onnx/reference/ops/op_random_normal.py
@@ -0,0 +1,16 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops._op_common_random import _CommonRandom
+
+
+class RandomNormal(_CommonRandom):
+    def _run(self, dtype=None, mean=None, scale=None, seed=None, shape=None):
+        state = self._get_state(seed)
+        numpy_type = self.numpy_type(dtype)
+        res = state.randn(*shape).astype(numpy_type)
+        res *= scale
+        res += mean
+        return (res.astype(numpy_type),)
diff --git a/onnx/reference/ops/op_random_normal_like.py b/onnx/reference/ops/op_random_normal_like.py
new file mode 100644
index 0000000..4e133e4
--- /dev/null
+++ b/onnx/reference/ops/op_random_normal_like.py
@@ -0,0 +1,19 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.helper import np_dtype_to_tensor_dtype
+from onnx.reference.ops._op_common_random import _CommonRandom
+
+
+class RandomNormalLike(_CommonRandom):
+    def _run(self, x, dtype=None, mean=None, scale=None, seed=None):
+        if dtype is None:
+            dtype = np_dtype_to_tensor_dtype(x.dtype)
+        dtype = self._dtype(x, dtype=dtype)
+        state = self._get_state(seed)
+        res = state.randn(*x.shape).astype(dtype)
+        res *= scale
+        res += mean
+        return (res.astype(dtype),)
diff --git a/onnx/reference/ops/op_random_uniform.py b/onnx/reference/ops/op_random_uniform.py
new file mode 100644
index 0000000..be6a74b
--- /dev/null
+++ b/onnx/reference/ops/op_random_uniform.py
@@ -0,0 +1,16 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops._op_common_random import _CommonRandom
+
+
+class RandomUniform(_CommonRandom):
+    def _run(self, dtype=None, high=None, low=None, seed=None, shape=None):
+        dtype = self._dtype(dtype=dtype)
+        state = self._get_state(seed)
+        res = state.rand(*shape).astype(dtype)
+        res *= high - low
+        res += low
+        return (res.astype(dtype),)
diff --git a/onnx/reference/ops/op_random_uniform_like.py b/onnx/reference/ops/op_random_uniform_like.py
new file mode 100644
index 0000000..2b5fe25
--- /dev/null
+++ b/onnx/reference/ops/op_random_uniform_like.py
@@ -0,0 +1,19 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.helper import np_dtype_to_tensor_dtype
+from onnx.reference.ops._op_common_random import _CommonRandom
+
+
+class RandomUniformLike(_CommonRandom):
+    def _run(self, x, dtype=None, high=None, low=None, seed=None):
+        if dtype is None:
+            dtype = np_dtype_to_tensor_dtype(x.dtype)
+        dtype = self._dtype(x, dtype=dtype)
+        state = self._get_state(seed)
+        res = state.rand(*x.shape).astype(dtype)
+        res *= high - low
+        res += low
+        return (res.astype(dtype),)
diff --git a/onnx/reference/ops/op_range.py b/onnx/reference/ops/op_range.py
new file mode 100644
index 0000000..5f08375
--- /dev/null
+++ b/onnx/reference/ops/op_range.py
@@ -0,0 +1,39 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import ml_dtypes
+import numpy as np
+
+from onnx import TensorProto
+from onnx.reference.op_run import OpRun
+
+_STASH_TYPE_TO_DTYPE: dict[int, np.dtype] = {
+    int(TensorProto.FLOAT): np.dtype(np.float32),
+    int(TensorProto.DOUBLE): np.dtype(np.float64),
+}
+
+_LOW_PRECISION_DTYPES = (np.dtype(np.float16), np.dtype(ml_dtypes.bfloat16))
+
+
+class Range(OpRun):
+    def _run(self, starts, ends, steps, stash_type=None):  # type: ignore[override]
+        dtype = starts.dtype
+        end_val = ends.item() if isinstance(ends, np.ndarray) else ends
+        step_val = steps.item() if isinstance(steps, np.ndarray) else steps
+        if stash_type is not None and dtype in _LOW_PRECISION_DTYPES:
+            compute_dtype = _STASH_TYPE_TO_DTYPE.get(int(stash_type))
+            if compute_dtype is None:
+                raise ValueError(
+                    f"Unsupported stash_type {stash_type} for Range; expected FLOAT (1) or DOUBLE (11)"
+                )
+            return (
+                np.arange(
+                    starts.astype(compute_dtype).item(),
+                    float(end_val),
+                    float(step_val),
+                    dtype=compute_dtype,
+                ).astype(dtype),
+            )
+        return (np.arange(starts.item(), end_val, step_val).astype(dtype),)
diff --git a/onnx/reference/ops/op_reciprocal.py b/onnx/reference/ops/op_reciprocal.py
new file mode 100644
index 0000000..c3d4663
--- /dev/null
+++ b/onnx/reference/ops/op_reciprocal.py
@@ -0,0 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Reciprocal(OpRunUnaryNum):
+    def _run(self, x):
+        with np.errstate(divide="ignore"):
+            return (np.reciprocal(x).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_reduce_l1.py b/onnx/reference/ops/op_reduce_l1.py
new file mode 100644
index 0000000..f75b46d
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_l1.py
@@ -0,0 +1,34 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+class ReduceL1_1(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=None):
+        axes = tuple(axes) if axes is not None else None
+        res = np.sum(np.abs(data), axis=axes, keepdims=keepdims).astype(
+            dtype=data.dtype
+        )
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
+
+
+class ReduceL1_18(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        keepdims = keepdims != 0
+        res = np.sum(np.abs(data), axis=axes, keepdims=keepdims).astype(
+            dtype=data.dtype
+        )
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
diff --git a/onnx/reference/ops/op_reduce_l2.py b/onnx/reference/ops/op_reduce_l2.py
new file mode 100644
index 0000000..70c6367
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_l2.py
@@ -0,0 +1,34 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+class ReduceL2_1(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=None):
+        axes = tuple(axes) if axes is not None else None
+        res = np.sqrt(np.sum(np.square(data), axis=axes, keepdims=keepdims)).astype(
+            dtype=data.dtype
+        )
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
+
+
+class ReduceL2_18(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        keepdims = keepdims != 0
+        res = np.sqrt(np.sum(np.square(data), axis=axes, keepdims=keepdims)).astype(
+            dtype=data.dtype
+        )
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
diff --git a/onnx/reference/ops/op_reduce_log_sum.py b/onnx/reference/ops/op_reduce_log_sum.py
new file mode 100644
index 0000000..5c34be9
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_log_sum.py
@@ -0,0 +1,34 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+class ReduceLogSum_1(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=True):
+        tax = tuple(axes) if axes is not None else None
+        if data.size == 0:
+            return self.reduce_constant(data, -np.inf, tax, keepdims)
+        res = np.sum(data, axis=tax, keepdims=keepdims)  # type: ignore[arg-type]
+        if len(res.shape) > 0:
+            return (np.log(res, out=res),)
+        return (np.log(res),)
+
+
+class ReduceLogSum_18(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        keepdims = keepdims != 0
+
+        if data.size == 0:
+            return self.reduce_constant(data, -np.inf, axes, keepdims)
+
+        res = np.sum(data, axis=axes, keepdims=keepdims)
+        if len(res.shape) > 0:
+            return (np.log(res, out=res),)
+        return (np.log(res),)
diff --git a/onnx/reference/ops/op_reduce_log_sum_exp.py b/onnx/reference/ops/op_reduce_log_sum_exp.py
new file mode 100644
index 0000000..5040953
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_log_sum_exp.py
@@ -0,0 +1,43 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+def compute_log_sum_exp(data, axes, keepdims):
+    data_max = data.copy()
+    ind = np.isinf(data_max)
+    data_max[ind] = -np.inf
+    mx = data_max.max(axis=axes, keepdims=True)
+    sub = np.subtract(data, mx)
+    exp = np.exp(sub, out=sub)
+    mxs = np.sum(exp, axis=axes, keepdims=True, dtype=data.dtype)
+    res = np.log(mxs) + mx
+    if not keepdims:
+        res = np.squeeze(res, axis=axes)
+    return (res,)
+
+
+class ReduceLogSumExp_1(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=None):
+        tax = tuple(axes) if axes is not None else None
+
+        if data.size == 0:
+            return self.reduce_constant(data, -np.inf, tax, keepdims)
+        return compute_log_sum_exp(data, tax, keepdims)
+
+
+class ReduceLogSumExp_18(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        keepdims = keepdims != 0
+
+        if data.size == 0:
+            return self.reduce_constant(data, -np.inf, axes, keepdims)
+
+        return compute_log_sum_exp(data, axes, keepdims)
diff --git a/onnx/reference/ops/op_reduce_max.py b/onnx/reference/ops/op_reduce_max.py
new file mode 100644
index 0000000..4e90da8
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_max.py
@@ -0,0 +1,46 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+class ReduceMax_1(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=None):
+        axes = tuple(axes) if axes is not None else None
+        if data.size == 0:
+            minvalue = (
+                np.iinfo(data.dtype).min
+                if np.issubdtype(data.dtype, np.integer)
+                else -np.inf
+            )
+            return self.reduce_constant(data, minvalue, axes, keepdims)
+
+        res = np.maximum.reduce(data, axis=axes, keepdims=keepdims == 1)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
+
+
+class ReduceMax_18(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims: int = 1, noop_with_empty_axes: int = 0):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        keepdims = keepdims != 0
+        if data.size == 0:
+            minvalue = (
+                np.iinfo(data.dtype).min
+                if np.issubdtype(data.dtype, np.integer)
+                else -np.inf
+            )
+            return self.reduce_constant(data, minvalue, axes, keepdims)
+
+        res = np.maximum.reduce(data, axis=axes, keepdims=keepdims)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
diff --git a/onnx/reference/ops/op_reduce_mean.py b/onnx/reference/ops/op_reduce_mean.py
new file mode 100644
index 0000000..d3e7fed
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_mean.py
@@ -0,0 +1,35 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+class ReduceMean_1(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=None):
+        axes = tuple(axes) if axes is not None else None
+        res = np.mean(data, axis=axes, keepdims=keepdims, dtype=data.dtype)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
+
+
+class ReduceMean_18(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        keepdims = keepdims != 0
+        try:
+            res = np.mean(data, axis=axes, keepdims=keepdims, dtype=data.dtype)
+            if keepdims == 0 and not isinstance(res, np.ndarray):
+                # The runtime must return a numpy array of a single float.
+                res = np.array(res)
+        except TypeError as e:
+            raise TypeError(
+                f"Unable to reduce shape {data.shape!r} with axes={axes!r} and keepdims={keepdims}."
+            ) from e
+        return (res,)
diff --git a/onnx/reference/ops/op_reduce_min.py b/onnx/reference/ops/op_reduce_min.py
new file mode 100644
index 0000000..adedaf0
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_min.py
@@ -0,0 +1,50 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+class ReduceMin_1(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=None):
+        axes = tuple(axes) if axes is not None else None
+        if data.size == 0:
+            maxvalue = (
+                np.iinfo(data.dtype).max
+                if np.issubdtype(data.dtype, np.integer)
+                else np.inf
+            )
+            return self.reduce_constant(data, maxvalue, axes, keepdims)
+
+        res = np.minimum.reduce(data, axis=axes, keepdims=keepdims == 1)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
+
+
+class ReduceMin_11(ReduceMin_1):
+    pass
+
+
+class ReduceMin_18(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims: int = 1, noop_with_empty_axes: int = 0):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        keepdims = keepdims != 0
+        if data.size == 0:
+            maxvalue = (
+                np.iinfo(data.dtype).max
+                if np.issubdtype(data.dtype, np.integer)
+                else np.inf
+            )
+            return self.reduce_constant(data, maxvalue, axes, keepdims)
+
+        res = np.minimum.reduce(data, axis=axes, keepdims=keepdims)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
diff --git a/onnx/reference/ops/op_reduce_prod.py b/onnx/reference/ops/op_reduce_prod.py
new file mode 100644
index 0000000..8542504
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_prod.py
@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+class ReduceProd_1(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=None):
+        axes = tuple(axes) if axes is not None else None
+        res = np.prod(data, axis=axes, keepdims=keepdims, dtype=data.dtype)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
+
+
+class ReduceProd_18(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        keepdims = keepdims != 0
+        res = np.prod(data, axis=axes, keepdims=keepdims, dtype=data.dtype)
+        if not keepdims and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
diff --git a/onnx/reference/ops/op_reduce_sum.py b/onnx/reference/ops/op_reduce_sum.py
new file mode 100644
index 0000000..750b7b8
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_sum.py
@@ -0,0 +1,35 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+class ReduceSum_1(OpRunReduceNumpy):
+    def _run(self, x, axes=None, keepdims=None):
+        axes = tuple(axes) if axes is not None else None
+        res = np.sum(x, axis=axes, keepdims=keepdims, dtype=x.dtype)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
+
+
+class ReduceSum_13(OpRunReduceNumpy):
+    def _run(self, x, axes=None, keepdims=None, noop_with_empty_axes=None):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        try:
+            res = np.sum(x, axis=axes, keepdims=keepdims, dtype=x.dtype)
+            if keepdims == 0 and not isinstance(res, np.ndarray):
+                # The runtime must return a numpy array of a single float.
+                res = np.array(res)
+        except TypeError as e:
+            raise TypeError(
+                f"Unable to reduce shape {x.shape!r} with axes={axes!r} and keepdims={keepdims}."
+            ) from e
+        else:
+            return (res,)
diff --git a/onnx/reference/ops/op_reduce_sum_square.py b/onnx/reference/ops/op_reduce_sum_square.py
new file mode 100644
index 0000000..3cc4923
--- /dev/null
+++ b/onnx/reference/ops/op_reduce_sum_square.py
@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunReduceNumpy
+
+
+class ReduceSumSquare_1(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=None):
+        axes = tuple(axes) if axes is not None else None
+        res = np.sum(np.square(data), axis=axes, keepdims=keepdims)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
+
+
+class ReduceSumSquare_18(OpRunReduceNumpy):
+    def _run(self, data, axes=None, keepdims=1, noop_with_empty_axes=0):
+        axes = self.handle_axes(axes, noop_with_empty_axes)
+
+        keepdims = keepdims != 0
+        res = np.sum(np.square(data), axis=axes, keepdims=keepdims)
+        if keepdims == 0 and not isinstance(res, np.ndarray):
+            # The runtime must return a numpy array of a single float.
+            res = np.array(res)
+        return (res,)
diff --git a/onnx/reference/ops/op_regex_full_match.py b/onnx/reference/ops/op_regex_full_match.py
new file mode 100644
index 0000000..5359023
--- /dev/null
+++ b/onnx/reference/ops/op_regex_full_match.py
@@ -0,0 +1,36 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import re
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+_acceptable_str_dtypes = ("U", "O")
+
+
+class RegexFullMatch(OpRun):
+    def _run(self, x, pattern=None):
+        # Note: The ONNX specification states that the pattern MUST
+        # follow the re2 syntax. Python's own re package appears to
+        # cover a superset of re2's functionality, albeit definitive
+        # sources are difficult to find. Since the Python bindings to
+        # re2 appear unmaintained, this operator is implemented using
+        # the re module for the time being. This may change if
+        # discrepancies surface in the future.
+
+        # As per onnx/mapping.py, object numpy dtype corresponds to TensorProto.STRING
+        if x.dtype.kind not in _acceptable_str_dtypes:
+            raise TypeError(f"Input must be string tensor, received dtype {x.dtype}")
+        try:
+            regex = re.compile(pattern)
+        except re.error as e:
+            raise ValueError(f"Invalid regex pattern {pattern!r}") from e
+
+        fullmatch_func = np.vectorize(
+            lambda x: regex.fullmatch(x) is not None, otypes=[np.bool_]
+        )
+        return (fullmatch_func(x),)
diff --git a/onnx/reference/ops/op_relu.py b/onnx/reference/ops/op_relu.py
new file mode 100644
index 0000000..3498b60
--- /dev/null
+++ b/onnx/reference/ops/op_relu.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Relu(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.maximum(x, 0).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_reshape.py b/onnx/reference/ops/op_reshape.py
new file mode 100644
index 0000000..e47d96b
--- /dev/null
+++ b/onnx/reference/ops/op_reshape.py
@@ -0,0 +1,38 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def reshape_reference_implementation(
+    data: np.ndarray, shape: np.ndarray, allowzero: int = 0
+) -> np.ndarray:
+    # replace zeros with corresponding dim size
+    # we need to do this because np.reshape doesn't support 0 by default unless 'allowzero' is set
+    new_shape = np.copy(shape)
+    if allowzero == 0:
+        zeros_index = np.where(shape == 0)
+        new_shape[zeros_index] = np.array(data.shape)[zeros_index]
+    return np.reshape(data, new_shape)
+
+
+class CommonReshape(OpRun):
+    def _run(self, data, shape):
+        return (reshape_reference_implementation(data, shape, 0),)
+
+
+class Reshape_5(CommonReshape):
+    pass
+
+
+class Reshape_14(CommonReshape):
+    def _run(self, data, shape, allowzero=None):
+        if allowzero is None:
+            allowzero = getattr(self, "allowzero", 0) == 1
+        else:
+            allowzero = allowzero == 1
+        return (reshape_reference_implementation(data, shape, allowzero),)
diff --git a/onnx/reference/ops/op_resize.py b/onnx/reference/ops/op_resize.py
new file mode 100644
index 0000000..b67b7d6
--- /dev/null
+++ b/onnx/reference/ops/op_resize.py
@@ -0,0 +1,665 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+import onnx
+from onnx.reference.op_run import OpRun
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def _cartesian(arrays: list[np.ndarray], out: np.ndarray | None = None) -> np.ndarray:
+    """From https://stackoverflow.com/a/1235363
+    Generate a cartesian product of input arrays.
+    Parameters
+    ----------
+    arrays : list of array-like
+        1-D arrays to form the cartesian product of.
+    out : ndarray
+        Array to place the cartesian product in.
+
+    Returns:
+    -------
+    out : ndarray
+        2-D array of shape (M, len(arrays)) containing cartesian products
+        formed of input arrays.
+
+    Examples:
+    --------
+    >>> cartesian(([1, 2, 3], [4, 5], [6, 7]))
+    array([[1, 4, 6],
+           [1, 4, 7],
+           [1, 5, 6],
+           [1, 5, 7],
+           [2, 4, 6],
+           [2, 4, 7],
+           [2, 5, 6],
+           [2, 5, 7],
+           [3, 4, 6],
+           [3, 4, 7],
+           [3, 5, 6],
+           [3, 5, 7]])
+    """
+    arrays = [np.asarray(x) for x in arrays]
+    dtype = arrays[0].dtype
+
+    n = np.prod([x.size for x in arrays])
+    if out is None:
+        out = np.zeros([n, len(arrays)], dtype=dtype)
+
+    m = n // arrays[0].size
+    out[:, 0] = np.repeat(arrays[0], m)
+    if arrays[1:]:
+        _cartesian(arrays[1:], out=out[0:m, 1:])
+        for j in range(1, arrays[0].size):
+            out[j * m : (j + 1) * m, 1:] = out[0:m, 1:]
+    return out
+
+
+def _nearest_coeffs(
+    ratio: float | int | np.ndarray, mode: str = "round_prefer_floor"
+) -> np.ndarray:
+    if isinstance(ratio, int) or ratio.is_integer():
+        return np.array([0, 1])
+    if mode == "round_prefer_floor":
+        return np.array([ratio <= 0.5, ratio > 0.5])
+    if mode == "round_prefer_ceil":
+        return np.array([ratio < 0.5, ratio >= 0.5])
+    if mode == "floor":
+        return np.array([1, 0])
+    if mode == "ceil":
+        return np.array([0, 1])
+    raise ValueError(f"Unexpected value {mode!r}.")
+
+
+def _cubic_coeffs(
+    ratio: float, scale: float | None = None, A: float = -0.75
+) -> np.ndarray:
+    del scale  # Unused
+    coeffs = [
+        ((A * (ratio + 1) - 5 * A) * (ratio + 1) + 8 * A) * (ratio + 1) - 4 * A,
+        ((A + 2) * ratio - (A + 3)) * ratio * ratio + 1,
+        ((A + 2) * (1 - ratio) - (A + 3)) * (1 - ratio) * (1 - ratio) + 1,
+        ((A * ((1 - ratio) + 1) - 5 * A) * ((1 - ratio) + 1) + 8 * A)
+        * ((1 - ratio) + 1)
+        - 4 * A,
+    ]
+    return np.array(coeffs)
+
+
+def _cubic_coeffs_antialias(ratio: float, scale: float, A: float = -0.75) -> np.ndarray:
+    # Antialias is applied when downsampling
+    scale = min(scale, 1.0)
+
+    def compute_coeff(x: float) -> float:
+        x = abs(x)
+        x_2 = x * x
+        x_3 = x * x_2
+        if x <= 1:
+            return (A + 2) * x_3 - (A + 3) * x_2 + 1
+        if x < 2:
+            return A * x_3 - 5 * A * x_2 + 8 * A * x - 4 * A
+        return 0.0
+
+    i_start = int(np.floor(-2 / scale) + 1)
+    i_end = 2 - i_start
+    args = [scale * (i - ratio) for i in range(i_start, i_end)]
+    coeffs = [compute_coeff(x) for x in args]
+    return np.array(coeffs) / sum(coeffs)
+
+
+def _linear_coeffs(ratio: float, scale: float | None = None) -> np.ndarray:
+    del scale  # unused
+    return np.array([1 - ratio, ratio])
+
+
+def _linear_coeffs_antialias(ratio: float, scale: float) -> np.ndarray:
+    # Antialias is applied when downsampling
+    scale = min(scale, 1.0)
+
+    start = int(np.floor(-1 / scale) + 1)
+    footprint = 2 - 2 * start
+    args = (np.arange(start, start + footprint) - ratio) * scale
+    coeffs = np.clip(1 - np.abs(args), 0, 1)
+    return np.array(coeffs) / sum(coeffs)  # type: ignore[no-any-return]
+
+
+def _get_neighbor_idxes(x: float, n: int, limit: int) -> np.ndarray:
+    """Return the n nearest indexes to x among `[0, limit)`,
+    prefer the indexes smaller than x.
+    As a result, the ratio must be in `(0, 1]`.
+
+    Examples::
+
+        get_neighbor_idxes(4, 2, 10) == [3, 4]
+        get_neighbor_idxes(4, 3, 10) == [3, 4, 5]
+        get_neighbor_idxes(4.4, 3, 10) == [3, 4, 5]
+        get_neighbor_idxes(4.5, 3, 10) == [3, 4, 5]
+        get_neighbor_idxes(4.6, 3, 10) == [4, 5, 6]
+        get_neighbor_idxes(4.4, 1, 10) == [4]
+        get_neighbor_idxes(4.6, 1, 10) == [5]
+
+    Args:
+        x: float.
+        n: the number of the wanted indexes.
+        limit: the maximum value of index.
+
+    Returns:
+        An np.array containing n nearest indexes in ascending order
+    """
+    idxes = sorted(range(limit), key=lambda idx: (abs(x - idx), idx))[:n]
+    idxes = sorted(idxes)
+    return np.array(idxes)
+
+
+def _get_neighbor(x: float, n: int, data: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """Pad `data` in 'edge' mode, and get n nearest elements in the padded array and their indexes in the original array.
+
+    Args:
+        x: Center index (in the unpadded coordinate system) of the found
+            nearest elements.
+        n: The number of neighbors.
+        data: The array.
+
+    Returns:
+        A tuple containing the indexes of neighbor elements (the index
+        can be smaller than 0 or higher than len(data)) and the value of
+        these elements.
+    """
+    pad_width = np.ceil(n / 2).astype(int)
+    padded = np.pad(data, pad_width, mode="edge")
+    x += pad_width
+
+    idxes = _get_neighbor_idxes(x, n, len(padded))
+    ret = padded[idxes]
+    return idxes - pad_width, ret
+
+
+def _interpolate_1d_with_x(
+    data: np.ndarray,
+    scale_factor: float,
+    output_width_int: int,
+    x: float,
+    get_coeffs: Callable[[float, float], np.ndarray],
+    roi: np.ndarray | None = None,
+    extrapolation_value: float = 0.0,
+    coordinate_transformation_mode: str = "half_pixel",
+    exclude_outside: bool = False,
+) -> np.ndarray:
+    input_width = len(data)
+    output_width = scale_factor * input_width
+    if coordinate_transformation_mode == "align_corners":
+        if output_width == 1:
+            x_ori = 0.0
+        else:
+            x_ori = x * (input_width - 1) / (output_width - 1)
+    elif coordinate_transformation_mode == "asymmetric":
+        x_ori = x / scale_factor
+    elif coordinate_transformation_mode == "tf_crop_and_resize":
+        if roi is None:
+            raise ValueError("roi cannot be None.")
+        if output_width == 1:
+            x_ori = (roi[1] - roi[0]) * (input_width - 1) / 2
+        else:
+            x_ori = x * (roi[1] - roi[0]) * (input_width - 1) / (output_width - 1)
+        x_ori += roi[0] * (input_width - 1)
+        # Return extrapolation_value directly as what TF CropAndResize does
+        if x_ori < 0 or x_ori > input_width - 1:
+            return np.array(extrapolation_value)
+    elif coordinate_transformation_mode == "pytorch_half_pixel":
+        if output_width == 1:
+            x_ori = -0.5
+        else:
+            x_ori = (x + 0.5) / scale_factor - 0.5
+    elif coordinate_transformation_mode == "half_pixel":
+        x_ori = (x + 0.5) / scale_factor - 0.5
+    elif coordinate_transformation_mode == "half_pixel_symmetric":
+        # Maps the center of the implicit ROI to the center of the output canvas.
+        # The difference with `half_pixel` will be only relevant
+        # when output_width_int != output_width
+        adjustment = output_width_int / output_width
+        center = input_width / 2
+        offset = center * (1 - adjustment)
+        x_ori = offset + (x + 0.5) / scale_factor - 0.5
+    else:
+        raise ValueError(
+            f"Invalid coordinate_transformation_mode: {coordinate_transformation_mode!r}."
+        )
+    x_ori_int = np.floor(x_ori).astype(int).item()
+
+    # ratio must be in (0, 1] since we prefer the pixel on the left of `x_ori`
+    if x_ori.is_integer():
+        ratio = 1
+    else:
+        ratio = x_ori - x_ori_int
+
+    coeffs = get_coeffs(ratio, scale_factor)
+    n = len(coeffs)
+
+    idxes, points = _get_neighbor(x_ori, n, data)
+
+    if exclude_outside:
+        for i, idx in enumerate(idxes):
+            if idx < 0 or idx >= input_width:
+                coeffs[i] = 0
+        coeffs /= sum(coeffs)
+
+    return np.dot(coeffs, points).item()  # type: ignore[no-any-return]
+
+
+def _interpolate_nd_with_x(
+    data: np.ndarray,
+    n: int,
+    scale_factors: list[float],
+    output_size: list[int],
+    x: list[float],
+    get_coeffs: Callable[[float, float], np.ndarray],
+    roi: np.ndarray | None = None,
+    exclude_outside: bool = False,
+    **kwargs: Any,
+) -> np.ndarray:
+    if n == 1:
+        return _interpolate_1d_with_x(
+            data,
+            scale_factors[0],
+            output_size[0],
+            x[0],
+            get_coeffs,
+            roi=roi,
+            exclude_outside=exclude_outside,
+            **kwargs,
+        )
+    res1d = []
+    for i in range(data.shape[0]):
+        r = _interpolate_nd_with_x(
+            data[i],
+            n - 1,
+            scale_factors[1:],
+            output_size[1:],
+            x[1:],
+            get_coeffs,
+            roi=None if roi is None else np.concatenate([roi[1:n], roi[n + 1 :]]),
+            exclude_outside=exclude_outside,
+            **kwargs,
+        )
+        res1d.append(r)
+
+    return _interpolate_1d_with_x(
+        res1d,  # type: ignore[arg-type]  # FIXME
+        scale_factors[0],
+        output_size[0],
+        x[0],
+        get_coeffs,
+        roi=None if roi is None else [roi[0], roi[n]],  # type: ignore[arg-type]  # FIXME
+        exclude_outside=exclude_outside,
+        **kwargs,
+    )
+
+
+def _get_all_coords(data: np.ndarray) -> np.ndarray:
+    # FIXME: Fix input type
+    return _cartesian(
+        [list(range(data.shape[i])) for i in range(len(data.shape))]  # type: ignore[arg-type,misc]
+    )
+
+
+def _compute_x_ori(
+    coordinate_transformation_mode: str,
+    y: np.ndarray,
+    scale_factor: float,
+    input_width: int,
+    output_width: float,
+    output_width_int: int,
+    roi: np.ndarray | list[float] | None,
+) -> tuple[np.ndarray, np.ndarray | None]:
+    """Map output indices ``y`` to source coordinates per the chosen mode.
+
+    Returns ``(x_ori, is_extrapolated)``. ``is_extrapolated`` is ``None`` for
+    every mode except ``tf_crop_and_resize``, where it flags output positions
+    whose source coordinate falls outside the input range.
+    """
+    is_extrapolated: np.ndarray | None = None
+    if coordinate_transformation_mode == "align_corners":
+        x_ori = (
+            np.zeros(output_width_int, dtype=np.float64)
+            if output_width == 1
+            else y * (input_width - 1) / (output_width - 1)
+        )
+    elif coordinate_transformation_mode == "asymmetric":
+        x_ori = y / scale_factor
+    elif coordinate_transformation_mode == "tf_crop_and_resize":
+        if roi is None:
+            raise ValueError("roi cannot be None.")
+        if output_width == 1:
+            x_ori = np.full(
+                output_width_int,
+                (roi[1] - roi[0]) * (input_width - 1) / 2,
+                dtype=np.float64,
+            )
+        else:
+            x_ori = y * (roi[1] - roi[0]) * (input_width - 1) / (output_width - 1)
+        x_ori = x_ori + roi[0] * (input_width - 1)
+        is_extrapolated = (x_ori < 0) | (x_ori > input_width - 1)
+    elif coordinate_transformation_mode == "pytorch_half_pixel":
+        x_ori = (
+            np.full(output_width_int, -0.5, dtype=np.float64)
+            if output_width == 1
+            else (y + 0.5) / scale_factor - 0.5
+        )
+    elif coordinate_transformation_mode == "half_pixel":
+        x_ori = (y + 0.5) / scale_factor - 0.5
+    elif coordinate_transformation_mode == "half_pixel_symmetric":
+        adjustment = output_width_int / output_width
+        center = input_width / 2
+        offset = center * (1 - adjustment)
+        x_ori = offset + (y + 0.5) / scale_factor - 0.5
+    else:
+        raise ValueError(
+            f"Invalid coordinate_transformation_mode: {coordinate_transformation_mode!r}."
+        )
+    return x_ori, is_extrapolated
+
+
+def _interpolate_1d_along_axis(
+    data: np.ndarray,
+    axis: int,
+    scale_factor: float,
+    output_width_int: int,
+    get_coeffs: Callable[[float, float], np.ndarray],
+    roi: np.ndarray | list[float] | None = None,
+    extrapolation_value: float = 0.0,
+    coordinate_transformation_mode: str = "half_pixel",
+    exclude_outside: bool = False,
+) -> np.ndarray:
+    """Vectorized 1-D resize along a single axis.
+
+    Computes the same result as calling :func:`_interpolate_1d_with_x` for
+    every output coordinate along ``axis``, but in a single batched numpy
+    operation. Resize interpolation is separable along axes, so resizing an
+    N-D tensor reduces to applying this routine once per axis.
+    """
+    if output_width_int == 0:
+        # Zero-sized output along this axis — nothing to interpolate, but
+        # downstream code indexes ratios[0] / coeffs[0], so bail out early.
+        empty_shape = list(data.shape)
+        empty_shape[axis] = 0
+        return np.empty(empty_shape, dtype=data.dtype)
+
+    input_width = data.shape[axis]
+    output_width = scale_factor * input_width
+    y = np.arange(output_width_int, dtype=np.float64)
+
+    x_ori, is_extrapolated = _compute_x_ori(
+        coordinate_transformation_mode,
+        y,
+        scale_factor,
+        input_width,
+        output_width,
+        output_width_int,
+        roi,
+    )
+
+    x_ori_int = np.floor(x_ori).astype(np.int64)
+    # Match the scalar code: prefer the pixel on the left of x_ori by
+    # forcing ratio = 1 when x_ori is an exact integer.
+    integer_mask = x_ori == x_ori_int
+    ratios = np.where(integer_mask, 1.0, x_ori - x_ori_int)
+
+    # Kernel size is fixed per axis: for non-antialias modes it doesn't
+    # depend on ratio at all, and for antialias modes it depends only on
+    # scale. Compute coefficients per output position.
+    sample_coeffs = np.asarray(get_coeffs(float(ratios[0]), scale_factor))
+    n = len(sample_coeffs)
+    coeffs = np.empty((output_width_int, n), dtype=np.float64)
+    coeffs[0] = sample_coeffs
+    for i in range(1, output_width_int):
+        coeffs[i] = get_coeffs(float(ratios[i]), scale_factor)
+
+    # Replicate _get_neighbor_idxes semantics: take the n indices closest to
+    # x_ori (in padded-edge coordinates) with ties broken by smaller index.
+    pad_width = int(np.ceil(n / 2))
+    x_padded = x_ori + pad_width
+    p_padded = np.floor(x_padded).astype(np.int64)
+    frac = x_padded - p_padded
+
+    if n % 2 == 0:
+        # Even kernel: window centers are half-integers. At an integer
+        # x_padded, the tie between p-0.5 and p+0.5 goes to the smaller
+        # center (p-0.5), so the window starts at p - n/2.
+        offset_from_p = np.where(frac == 0, -(n // 2), -(n // 2) + 1)
+    else:
+        # Odd kernel: window centered on the nearest integer. Ties
+        # (frac == 0.5) go to the smaller center.
+        base = -((n - 1) // 2)
+        offset_from_p = np.where(frac <= 0.5, base, base + 1)
+
+    start_padded = p_padded + offset_from_p
+    neighbor_idxes = start_padded[:, None] + np.arange(n)[None, :] - pad_width
+
+    if exclude_outside:
+        outside_mask = (neighbor_idxes < 0) | (neighbor_idxes >= input_width)
+        coeffs = np.where(outside_mask, 0.0, coeffs)
+        coeff_sum = coeffs.sum(axis=-1, keepdims=True)
+        # Guard against rows where every coefficient is zero.
+        coeff_sum = np.where(coeff_sum == 0, 1.0, coeff_sum)
+        coeffs = coeffs / coeff_sum
+
+    # Edge-padding is equivalent to clamping indices into the valid range.
+    # intp cast: np.take rejects int64 indices on 32-bit platforms.
+    clamped = np.clip(neighbor_idxes, 0, input_width - 1).astype(np.intp)
+    gathered = np.take(data, clamped, axis=axis)
+
+    coeff_shape = (1,) * axis + coeffs.shape + (1,) * (data.ndim - axis - 1)
+    weighted = gathered * coeffs.reshape(coeff_shape)
+    result = weighted.sum(axis=axis + 1)
+
+    if is_extrapolated is not None and is_extrapolated.any():
+        mask_shape = (1,) * axis + (output_width_int,) + (1,) * (data.ndim - axis - 1)
+        mask = is_extrapolated.reshape(mask_shape)
+        result = np.where(mask, extrapolation_value, result)
+
+    return result  # type: ignore[no-any-return]
+
+
+def _interpolate_nd(
+    data: np.ndarray,
+    get_coeffs: Callable[[float, float], np.ndarray],
+    output_size: list[int] | None = None,
+    scale_factors: list[float] | None = None,
+    axes: list[int] | None = None,
+    roi: np.ndarray | None = None,
+    keep_aspect_ratio_policy: str | None = "stretch",
+    exclude_outside: bool = False,
+    **kwargs: Any,
+) -> np.ndarray:
+    if output_size is None and scale_factors is None:
+        raise ValueError("output_size is None and scale_factors is None.")
+
+    # roi is only meaningful for tf_crop_and_resize; for other modes it may
+    # arrive as an empty tensor. Normalize to None so downstream indexing
+    # (roi[axis], roi[axis + r]) doesn't fault on an empty array.
+    if roi is not None and np.asarray(roi).size == 0:
+        roi = None
+
+    r = len(data.shape)
+    if axes is not None:
+        if scale_factors is not None:
+            new_scale_factors = [1.0] * r
+            for i, d in enumerate(axes):
+                new_scale_factors[d] = scale_factors[i]
+            scale_factors = new_scale_factors
+
+        if output_size is not None:
+            new_output_size = [data.shape[i] for i in range(r)]
+            for i, d in enumerate(axes):
+                new_output_size[d] = output_size[i]
+            output_size = new_output_size
+
+        if roi is not None:
+            new_roi = ([0.0] * r) + ([1.0] * r)
+            naxes = len(axes)
+            for i, d in enumerate(axes):
+                new_roi[d] = roi[i]
+                new_roi[r + d] = roi[naxes + i]
+            roi = new_roi  # type: ignore[assignment]  # FIXME
+    else:
+        axes = list(range(r))
+
+    if output_size is not None:
+        scale_factors = [output_size[i] / data.shape[i] for i in range(r)]
+        if keep_aspect_ratio_policy != "stretch":
+            if keep_aspect_ratio_policy == "not_larger":
+                scale = np.array(scale_factors)[axes].min()
+            elif keep_aspect_ratio_policy == "not_smaller":
+                scale = np.array(scale_factors)[axes].max()
+            else:
+                raise ValueError(
+                    f"Invalid keep_aspect_ratio_policy={keep_aspect_ratio_policy!r}"
+                )
+
+            scale_factors = [scale if i in axes else 1.0 for i in range(r)]
+
+            def round_half_up(x: float) -> int:
+                return int(x + 0.5)
+
+            output_size = [
+                round_half_up(scale * data.shape[i]) if i in axes else data.shape[i]
+                for i in range(r)
+            ]
+
+    else:
+        output_size = (scale_factors * np.array(data.shape)).astype(int)  # type: ignore[union-attr]
+
+    if scale_factors is None:
+        raise ValueError("scale_factors is None.")
+    if output_size is None:
+        raise ValueError("output_size is None.")
+
+    # Separable interpolation: resize one axis at a time. This avoids the
+    # O(prod(output_shape)) scan of the old implementation, which called the
+    # recursive _interpolate_nd_with_x once per output element.
+    result = data if data.dtype == np.float64 else data.astype(np.float64)
+    for axis in axes:
+        axis_scale = float(scale_factors[axis])
+        axis_output = int(output_size[axis])
+        if (
+            math.isclose(axis_scale, 1.0)
+            and axis_output == result.shape[axis]
+            and (
+                roi is None
+                or (
+                    math.isclose(float(roi[axis]), 0.0)
+                    and math.isclose(float(roi[axis + r]), 1.0)
+                )
+            )
+        ):
+            # Identity along this axis — skip to avoid unnecessary work.
+            continue
+        axis_roi = None if roi is None else [roi[axis], roi[axis + r]]
+        result = _interpolate_1d_along_axis(
+            result,
+            axis,
+            axis_scale,
+            axis_output,
+            get_coeffs,
+            roi=axis_roi,
+            exclude_outside=exclude_outside,
+            **kwargs,
+        )
+    return result
+
+
+class Resize(OpRun):
+    def _run(
+        self,
+        X,
+        roi,
+        scales=None,
+        sizes=None,
+        antialias=None,
+        axes=None,
+        coordinate_transformation_mode=None,
+        cubic_coeff_a=None,
+        exclude_outside=None,
+        extrapolation_value=None,
+        keep_aspect_ratio_policy=None,
+        mode: str | None = None,
+        nearest_mode=None,
+    ):
+        if mode == "nearest":
+            if antialias:
+                raise RuntimeError(
+                    f"antilias={antialias!r} is not supported for mode={mode!r}."
+                )
+            if nearest_mode is not None:
+
+                def fct(x, scale_factor):
+                    del scale_factor  # unused
+                    return _nearest_coeffs(x, mode=nearest_mode)
+
+            else:
+                fct = _nearest_coeffs
+        elif mode == "cubic":
+            fct_ = _cubic_coeffs_antialias if antialias else _cubic_coeffs
+
+            def fct(x, scale):
+                return fct_(x, scale, A=cubic_coeff_a)
+
+        elif mode == "linear":
+            fct = _linear_coeffs_antialias if antialias else _linear_coeffs
+        else:
+            raise ValueError(f"Unexpected value {mode!r} for mode.")
+
+        if axes is None:
+            output = onnx.numpy_helper.saturate_cast(
+                _interpolate_nd(
+                    X,
+                    fct,
+                    scale_factors=scales,
+                    output_size=sizes,
+                    roi=roi,
+                    keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+                    exclude_outside=exclude_outside,
+                    coordinate_transformation_mode=coordinate_transformation_mode,
+                    extrapolation_value=extrapolation_value,
+                ),
+                X.dtype,
+            )
+            return (output,)
+
+        # axes is not None
+        not_axes = [a for a in range(len(X.shape)) if a not in axes]
+        perm = tuple(not_axes + axes)
+        permuted = np.transpose(X, perm)
+        new_shape = (-1, *tuple(X.shape[a] for a in axes))
+        reshaped = permuted.reshape(new_shape)
+        res = None
+        for i in range(reshaped.shape[0]):
+            output = _interpolate_nd(
+                reshaped[i],
+                fct,
+                scale_factors=scales,
+                output_size=sizes,
+                roi=roi,
+                keep_aspect_ratio_policy=keep_aspect_ratio_policy,
+                exclude_outside=exclude_outside,
+                coordinate_transformation_mode=coordinate_transformation_mode,
+                extrapolation_value=extrapolation_value,
+            )
+            if res is None:
+                res = np.empty((reshaped.shape[0], *output.shape), dtype=X.dtype)
+            res[i] = onnx.numpy_helper.saturate_cast(output, X.dtype)
+
+        res_reshaped = res.reshape(tuple(X.shape[a] for a in not_axes) + res[0].shape)
+        new_perm = list(perm)
+        for i, a in enumerate(perm):
+            new_perm[a] = i
+        final = np.transpose(res_reshaped, tuple(new_perm))
+        return (final,)
diff --git a/onnx/reference/ops/op_reverse_sequence.py b/onnx/reference/ops/op_reverse_sequence.py
new file mode 100644
index 0000000..3601cfd
--- /dev/null
+++ b/onnx/reference/ops/op_reverse_sequence.py
@@ -0,0 +1,20 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class ReverseSequence(OpRun):
+    def _run(self, data, sequence_lens, batch_axis=None, time_axis=None):
+        index = [slice(0, s) for s in data.shape]
+        index_data = [slice(0, s) for s in data.shape]
+        result = data.copy()
+        for i, sl in enumerate(sequence_lens):
+            index[batch_axis] = i
+            index[time_axis] = slice(0, sl)
+            index_data[batch_axis] = i
+            index_data[time_axis] = slice(sl - 1, None, -1)
+            result[tuple(index)] = data[tuple(index_data)]
+        return (result,)
diff --git a/onnx/reference/ops/op_rms_normalization.py b/onnx/reference/ops/op_rms_normalization.py
new file mode 100644
index 0000000..7025038
--- /dev/null
+++ b/onnx/reference/ops/op_rms_normalization.py
@@ -0,0 +1,49 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _rms_normalization(
+    X: np.ndarray,
+    W: np.ndarray,
+    axis: int = -1,
+    epsilon: float = 1e-5,
+) -> np.ndarray:
+    shape = X.shape
+    rank = len(shape)
+    if axis < 0:
+        # If axis = -1 and rank of X is 4,
+        # the axis is changed to -1 + 4 = 3,
+        # which means the last axis.
+        axis = axis + rank
+
+    # This computes RMS for every x_mat's column.
+    x_squared = np.power(X, 2)
+    x_squared_mean = np.mean(
+        x_squared, axis=tuple(range(axis, len(shape))), keepdims=True
+    )
+    # epsilon adjustment to avoid divide-by-zero.
+    rmseps = x_squared_mean + epsilon
+    rms = np.sqrt(rmseps)
+    rms_reciprocal = np.reciprocal(rms)
+
+    y_mat = X * rms_reciprocal
+    # W is linear coefficient.
+    Y = y_mat * W
+
+    return Y.astype(X.dtype)
+
+
+class RMSNormalization(OpRun):
+    def _run(self, X, Scale, axis=None, epsilon=None, stash_type=None):
+        if stash_type != 1:
+            raise NotImplementedError(
+                f"RMSNormalization not implemented for stash_type={stash_type} != 1."
+            )
+        res = _rms_normalization(X, Scale, axis=axis, epsilon=epsilon)
+        return (res,)
diff --git a/onnx/reference/ops/op_rnn.py b/onnx/reference/ops/op_rnn.py
new file mode 100644
index 0000000..6121005
--- /dev/null
+++ b/onnx/reference/ops/op_rnn.py
@@ -0,0 +1,155 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class CommonRNN(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+
+        if self.direction in ("forward", "reverse"):
+            self.num_directions = 1
+        elif self.direction == "bidirectional":
+            self.num_directions = 2
+        else:
+            raise RuntimeError(f"Unknown direction {self.direction!r}.")
+
+        if (
+            self.activation_alpha is not None
+            and len(self.activation_alpha) != self.num_directions
+        ):
+            raise RuntimeError(
+                f"activation_alpha must have the same size as num_directions={self.num_directions}."
+            )
+        if (
+            self.activation_beta is not None
+            and len(self.activation_beta) != self.num_directions
+        ):
+            raise RuntimeError(
+                f"activation_beta must have the same size as num_directions={self.num_directions}."
+            )
+
+        self.f1 = self.choose_act(
+            self.activations[0],
+            (
+                self.activation_alpha[0]
+                if self.activation_alpha is not None and len(self.activation_alpha) > 0
+                else None
+            ),
+            (
+                self.activation_beta[0]
+                if self.activation_beta is not None and len(self.activation_beta) > 0
+                else None
+            ),
+        )
+        if len(self.activations) > 1:
+            self.f2 = self.choose_act(
+                self.activations[1],
+                (
+                    self.activation_alpha[1]
+                    if self.activation_alpha is not None
+                    and len(self.activation_alpha) > 1
+                    else None
+                ),
+                (
+                    self.activation_beta[1]
+                    if self.activation_beta is not None
+                    and len(self.activation_beta) > 1
+                    else None
+                ),
+            )
+        self.n_outputs = len(onnx_node.output)
+
+    def choose_act(self, name, alpha, beta):
+        if name in ("Tanh", "tanh"):
+            return self._f_tanh
+        if name in ("Affine", "affine"):
+            return lambda x: x * alpha + beta
+        raise RuntimeError(f"Unknown activation function {name!r}.")
+
+    def _f_tanh(self, x):
+        return np.tanh(x)
+
+    def _step(self, X, R, B, W, H_0):
+        h_list = []
+        H_t = H_0
+        for x in np.split(X, X.shape[0], axis=0):
+            H = self.f1(
+                np.dot(x, np.transpose(W))
+                + np.dot(H_t, np.transpose(R))
+                + np.add(*np.split(B, 2))
+            )
+            h_list.append(H)
+            H_t = H
+        concatenated = np.concatenate(h_list)
+        if self.num_directions == 1:
+            output = np.expand_dims(concatenated, 1)
+        return output, h_list[-1]
+
+    def _run(
+        self,
+        X,
+        W,
+        R,
+        B=None,
+        sequence_lens=None,
+        initial_h=None,
+        activation_alpha=None,  # noqa: ARG002
+        activation_beta=None,  # noqa: ARG002
+        activations=None,  # noqa: ARG002
+        clip=None,  # noqa: ARG002
+        direction=None,  # noqa: ARG002
+        hidden_size=None,
+        layout=None,
+    ):
+        # TODO: support overridden attributes.
+        self.num_directions = W.shape[0]
+
+        if self.num_directions == 1:
+            R = np.squeeze(R, axis=0)
+            W = np.squeeze(W, axis=0)
+            if B is not None:
+                B = np.squeeze(B, axis=0)
+            if sequence_lens is not None:
+                sequence_lens = np.squeeze(sequence_lens, axis=0)
+            if initial_h is not None:
+                initial_h = np.squeeze(initial_h, axis=0)
+
+            hidden_size = R.shape[-1]
+            batch_size = X.shape[1]
+
+            X = X if layout == 0 else np.swapaxes(X, 0, 1)
+            b = B if B is not None else np.zeros(2 * hidden_size, dtype=X.dtype)
+            h_0 = (
+                initial_h
+                if initial_h is not None
+                else np.zeros((batch_size, hidden_size), dtype=X.dtype)
+            )
+
+            B = b
+            H_0 = h_0
+        else:
+            raise NotImplementedError(
+                f"Unsupported value {self.num_directions} for num_directions and operator {self.__class__.__name__!r}."
+            )
+
+        Y, Y_h = self._step(X, R, B, W, H_0)
+        if layout == 1:
+            Y = np.transpose(Y, [2, 0, 1, 3])
+            Y_h = Y[:, :, -1, :]
+
+        Y = Y.astype(X.dtype)
+        return (Y,) if self.n_outputs == 1 else (Y, Y_h)
+
+
+class RNN_7(CommonRNN):
+    pass
+
+
+class RNN_14(CommonRNN):
+    pass
diff --git a/onnx/reference/ops/op_roi_align.py b/onnx/reference/ops/op_roi_align.py
new file mode 100644
index 0000000..341d7cc
--- /dev/null
+++ b/onnx/reference/ops/op_roi_align.py
@@ -0,0 +1,296 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class PreCalc:
+    def __init__(self, pos1=0, pos2=0, pos3=0, pos4=0, w1=0, w2=0, w3=0, w4=0):
+        self.pos1 = pos1
+        self.pos2 = pos2
+        self.pos3 = pos3
+        self.pos4 = pos4
+        self.w1 = w1
+        self.w2 = w2
+        self.w3 = w3
+        self.w4 = w4
+
+    def __repr__(self) -> str:
+        return f"PreCalc({self.pos1},{self.pos2},{self.pos3},{self.pos4},{self.w1},{self.w2},{self.w3},{self.w4})"
+
+
+class RoiAlign(OpRun):
+    @staticmethod
+    def pre_calc_for_bilinear_interpolate(
+        height: int,
+        width: int,
+        pooled_height: int,
+        pooled_width: int,
+        iy_upper: int,
+        ix_upper: int,
+        roi_start_h,
+        roi_start_w,
+        bin_size_h,
+        bin_size_w,
+        roi_bin_grid_h: int,
+        roi_bin_grid_w: int,
+        pre_calc,
+    ):
+        pre_calc_index = 0
+        for ph in range(pooled_height):
+            for pw in range(pooled_width):
+                for iy in range(iy_upper):
+                    yy = (
+                        roi_start_h
+                        + ph * bin_size_h
+                        + (iy + 0.5) * bin_size_h / roi_bin_grid_h
+                    )
+                    for ix in range(ix_upper):
+                        xx = (
+                            roi_start_w
+                            + pw * bin_size_w
+                            + (ix + 0.5) * bin_size_w / roi_bin_grid_w
+                        )
+
+                        x = xx
+                        y = yy
+                        # deal with: inverse elements are out of feature map boundary
+                        if y < -1.0 or y > height or x < -1.0 or x > width:
+                            pc = pre_calc[pre_calc_index]
+                            pc.pos1 = 0
+                            pc.pos2 = 0
+                            pc.pos3 = 0
+                            pc.pos4 = 0
+                            pc.w1 = 0
+                            pc.w2 = 0
+                            pc.w3 = 0
+                            pc.w4 = 0
+                            pre_calc_index += 1
+                            continue
+
+                        y = max(y, 0)
+                        x = max(x, 0)
+
+                        y_low = int(y)
+                        x_low = int(x)
+
+                        if y_low >= height - 1:
+                            y_high = y_low = height - 1
+                            y = y_low
+                        else:
+                            y_high = y_low + 1
+
+                        if x_low >= width - 1:
+                            x_high = x_low = width - 1
+                            x = x_low
+                        else:
+                            x_high = x_low + 1
+
+                        ly = y - y_low
+                        lx = x - x_low
+                        hy = 1.0 - ly
+                        hx = 1.0 - lx
+                        w1 = hy * hx
+                        w2 = hy * lx
+                        w3 = ly * hx
+                        w4 = ly * lx
+
+                        # save weights and indices
+                        pc = PreCalc()
+                        pc.pos1 = y_low * width + x_low
+                        pc.pos2 = y_low * width + x_high
+                        pc.pos3 = y_high * width + x_low
+                        pc.pos4 = y_high * width + x_high
+                        pc.w1 = w1
+                        pc.w2 = w2
+                        pc.w3 = w3
+                        pc.w4 = w4
+                        pre_calc[pre_calc_index] = pc
+
+                        pre_calc_index += 1
+
+    @staticmethod
+    def roi_align_forward(
+        output_shape: tuple[int, int, int, int],
+        bottom_data,
+        spatial_scale,
+        height: int,
+        width: int,
+        sampling_ratio,
+        bottom_rois,
+        num_roi_cols: int,
+        top_data,
+        mode,
+        half_pixel: bool,
+        batch_indices_ptr,
+    ):
+        n_rois = output_shape[0]
+        channels = output_shape[1]
+        pooled_height = output_shape[2]
+        pooled_width = output_shape[3]
+
+        # 100 is a random chosen value, need be tuned
+        for n in range(n_rois):
+            index_n = n * channels * pooled_width * pooled_height
+
+            # bottom_rois
+            offset_bottom_rois = n * num_roi_cols
+            roi_batch_ind = batch_indices_ptr[n]
+
+            # Do not using rounding; this implementation detail is critical.
+            offset = 0.5 if half_pixel else 0.0
+            roi_start_w = bottom_rois[offset_bottom_rois + 0] * spatial_scale - offset
+            roi_start_h = bottom_rois[offset_bottom_rois + 1] * spatial_scale - offset
+            roi_end_w = bottom_rois[offset_bottom_rois + 2] * spatial_scale - offset
+            roi_end_h = bottom_rois[offset_bottom_rois + 3] * spatial_scale - offset
+
+            roi_width = roi_end_w - roi_start_w
+            roi_height = roi_end_h - roi_start_h
+            if not half_pixel:
+                # Force malformed ROIs to be 1x1
+                roi_width = max(roi_width, 1.0)
+                roi_height = max(roi_height, 1.0)
+
+            bin_size_h = roi_height / pooled_height
+            bin_size_w = roi_width / pooled_width
+
+            # We use roi_bin_grid to sample the grid and mimic integral
+            roi_bin_grid_h = (
+                int(sampling_ratio)
+                if sampling_ratio > 0
+                else int(np.ceil(roi_height / pooled_height))
+            )
+            roi_bin_grid_w = (
+                int(sampling_ratio)
+                if sampling_ratio > 0
+                else int(np.ceil(roi_width / pooled_width))
+            )
+
+            # We do average (integral) pooling inside a bin
+            count = int(max(roi_bin_grid_h * roi_bin_grid_w, 1))
+
+            # we want to precalculate indices and weights shared by all channels,
+            # this is the key point of optimization
+            pre_calc = [
+                PreCalc()
+                for i in range(
+                    roi_bin_grid_h * roi_bin_grid_w * pooled_width * pooled_height
+                )
+            ]
+            RoiAlign.pre_calc_for_bilinear_interpolate(
+                height,
+                width,
+                pooled_height,
+                pooled_width,
+                roi_bin_grid_h,
+                roi_bin_grid_w,
+                roi_start_h,
+                roi_start_w,
+                bin_size_h,
+                bin_size_w,
+                roi_bin_grid_h,
+                roi_bin_grid_w,
+                pre_calc,
+            )
+
+            for c in range(channels):
+                index_n_c = index_n + c * pooled_width * pooled_height
+                # bottom_data
+                offset_bottom_data = int(
+                    (roi_batch_ind * channels + c) * height * width
+                )
+                pre_calc_index = 0
+
+                for ph in range(pooled_height):
+                    for pw in range(pooled_width):
+                        index = index_n_c + ph * pooled_width + pw
+
+                        output_val = 0.0
+                        if mode == "avg":  # avg pooling
+                            for _iy in range(roi_bin_grid_h):
+                                for _ix in range(roi_bin_grid_w):
+                                    pc = pre_calc[pre_calc_index]
+                                    output_val += (
+                                        pc.w1
+                                        * bottom_data[offset_bottom_data + pc.pos1]
+                                        + pc.w2
+                                        * bottom_data[offset_bottom_data + pc.pos2]
+                                        + pc.w3
+                                        * bottom_data[offset_bottom_data + pc.pos3]
+                                        + pc.w4
+                                        * bottom_data[offset_bottom_data + pc.pos4]
+                                    )
+
+                                    pre_calc_index += 1
+                            output_val /= count
+                        else:  # max pooling
+                            max_flag = False
+                            for _iy in range(roi_bin_grid_h):
+                                for _ix in range(roi_bin_grid_w):
+                                    pc = pre_calc[pre_calc_index]
+                                    val = max(
+                                        pc.w1
+                                        * bottom_data[offset_bottom_data + pc.pos1],
+                                        pc.w2
+                                        * bottom_data[offset_bottom_data + pc.pos2],
+                                        pc.w3
+                                        * bottom_data[offset_bottom_data + pc.pos3],
+                                        pc.w4
+                                        * bottom_data[offset_bottom_data + pc.pos4],
+                                    )
+                                    if not max_flag:
+                                        output_val = val
+                                        max_flag = True
+                                    else:
+                                        output_val = max(output_val, val)
+                                    pre_calc_index += 1
+
+                        top_data[index] = output_val
+
+    def _run(
+        self,
+        X,
+        rois,
+        batch_indices,
+        coordinate_transformation_mode=None,
+        mode=None,
+        output_height=None,
+        output_width=None,
+        sampling_ratio=None,
+        spatial_scale=None,
+    ):
+        coordinate_transformation_mode = (
+            coordinate_transformation_mode or self.coordinate_transformation_mode
+        )
+        mode = mode or self.mode
+        output_height = output_height or self.output_height
+        output_width = output_width or self.output_width
+        sampling_ratio = sampling_ratio or self.sampling_ratio
+        spatial_scale = spatial_scale or self.spatial_scale
+
+        num_channels = X.shape[1]
+        num_rois = batch_indices.shape[0]
+        num_roi_cols = rois.shape[1]
+
+        y_dims = (num_rois, num_channels, output_height, output_width)
+        Y = np.empty(y_dims, dtype=X.dtype).flatten()
+
+        self.roi_align_forward(
+            y_dims,
+            X.flatten(),
+            spatial_scale,
+            X.shape[2],  # height, 3
+            X.shape[3],  # width, 4
+            sampling_ratio,
+            rois.flatten(),
+            num_roi_cols,
+            Y,
+            mode.lower(),
+            coordinate_transformation_mode.lower() == "half_pixel",
+            batch_indices.flatten(),
+        )
+        return (Y.reshape(y_dims).astype(X.dtype),)
diff --git a/onnx/reference/ops/op_rotary_embedding.py b/onnx/reference/ops/op_rotary_embedding.py
new file mode 100644
index 0000000..14b2ad4
--- /dev/null
+++ b/onnx/reference/ops/op_rotary_embedding.py
@@ -0,0 +1,119 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def rotary_embedding(
+    input: np.ndarray,
+    cos_cache: np.ndarray,
+    sin_cache: np.ndarray,
+    position_ids: np.ndarray | None = None,
+    interleaved=None,
+    rotary_embedding_dim=None,
+    num_heads=None,
+) -> np.ndarray:
+    original_input_shape = input.shape
+    # First ensure input to be processed has shape [batch_size, seq_len, num_heads, head_size]
+    if len(input.shape) == 4:
+        input = np.transpose(input, (0, 2, 1, 3))
+    batch_size = input.shape[0]
+    sequence_length = input.shape[1]
+    if len(input.shape) == 3:
+        hidden_size = input.shape[2]
+        assert num_heads != 0
+        head_size = int(hidden_size / num_heads)
+        new_shape = [batch_size, sequence_length, num_heads, head_size]
+        input = np.reshape(input, new_shape)
+    assert len(input.shape) == 4
+    head_size = input.shape[3]
+
+    # Fully or partially perform rotation on input based on rotary_embedding_dim attribute
+    if rotary_embedding_dim is None or rotary_embedding_dim == 0:
+        # If rotary_embedding_dim not provided, perform full rotation by using head_size
+        rotary_embedding_dim = head_size
+    x_rotate = input[:, :, :, :rotary_embedding_dim]
+    x_not_rotate = input[:, :, :, rotary_embedding_dim:]
+    rotary_embedding_dim_half = int(rotary_embedding_dim / 2)
+
+    # Retrieve sin and cos caches using position ids
+    if position_ids is not None:
+        cos_cache = cos_cache[
+            position_ids
+        ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+        sin_cache = sin_cache[
+            position_ids
+        ]  # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+
+    # Shape: [batch_size, sequence_length, rotary_embedding_dim/2]
+    if cos_cache.shape[-1] != rotary_embedding_dim_half:
+        raise ValueError(
+            f"Last dimension of cos cache ({cos_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+        )
+    if sin_cache.shape[-1] != rotary_embedding_dim_half:
+        raise ValueError(
+            f"Last dimension of sin cache ({sin_cache.shape[-1]}) does not match rotary_embedding_dim/2 ({rotary_embedding_dim_half})."
+        )
+
+    cos_cache = np.expand_dims(
+        cos_cache, axis=2
+    )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
+    sin_cache = np.expand_dims(
+        sin_cache, axis=2
+    )  # Shape: [batch_size, sequence_length, 1, rotary_embedding_dim/2]
+
+    # Either divide the input in halves or interleave (based on interleaved attribute)
+    if interleaved:
+        x1 = x_rotate[:, :, :, 0::2]
+        x2 = x_rotate[:, :, :, 1::2]
+    else:
+        x1, x2 = np.split(x_rotate, 2, axis=-1)
+
+    # Calculate real and imaginary values
+    real = (cos_cache * x1) - (sin_cache * x2)
+    imag = (sin_cache * x1) + (cos_cache * x2)
+
+    # Inserted rotated embeddings back to the original input
+    if interleaved:
+        # x_rotate[:, :, :, 0::2] = real
+        # x_rotate[:, :, :, 1::2] = imag
+        real = np.expand_dims(real, axis=-1)
+        imag = np.expand_dims(imag, axis=-1)
+        x_rotate_concat = np.concatenate((real, imag), axis=-1)
+        x_rotate = np.reshape(x_rotate_concat, x_rotate.shape)
+    else:
+        x_rotate = np.concatenate((real, imag), axis=-1)
+    output = np.concatenate((x_rotate, x_not_rotate), axis=-1)
+    if len(original_input_shape) == 3:
+        output = np.reshape(output, original_input_shape)
+    else:
+        output = np.transpose(output, (0, 2, 1, 3))
+    return output
+
+
+class RotaryEmbedding(OpRun):
+    def _run(
+        self,
+        input: np.ndarray,
+        cos_cache: np.ndarray,
+        sin_cache: np.ndarray,
+        position_ids: np.ndarray | None = None,
+        interleaved=None,
+        rotary_embedding_dim=None,
+        num_heads=None,
+    ) -> np.ndarray:
+        return (
+            rotary_embedding(
+                input,
+                cos_cache,
+                sin_cache,
+                position_ids=position_ids,
+                interleaved=interleaved,
+                rotary_embedding_dim=rotary_embedding_dim,
+                num_heads=num_heads,
+            ),
+        )
diff --git a/onnx/reference/ops/op_round.py b/onnx/reference/ops/op_round.py
new file mode 100644
index 0000000..21b3fa3
--- /dev/null
+++ b/onnx/reference/ops/op_round.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Round(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.round(x).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_scan.py b/onnx/reference/ops/op_scan.py
new file mode 100644
index 0000000..630f6ce
--- /dev/null
+++ b/onnx/reference/ops/op_scan.py
@@ -0,0 +1,181 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Scan(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        if not hasattr(self.body, "run"):
+            raise RuntimeError(
+                f"Parameter 'body' must have a method 'run', type {type(self.body)}."
+            )
+        if self.num_scan_inputs <= 0:
+            raise RuntimeError(
+                f"Scan requires num_scan_inputs > 0, got {self.num_scan_inputs}."
+            )
+        self.input_directions_ = [
+            (
+                0
+                if self.scan_input_directions is None
+                or i >= len(self.scan_input_directions)
+                else self.scan_input_directions[i]
+            )
+            for i in range(self.num_scan_inputs)
+        ]
+        if self.input_directions_:
+            max_dir_in = max(self.input_directions_)
+            if max_dir_in != 0:
+                raise RuntimeError(
+                    "Scan is not implemented for other output input_direction than 0."
+                )
+        self.input_axes_ = [
+            (
+                0
+                if self.scan_input_axes is None or i >= len(self.scan_input_axes)
+                else self.scan_input_axes[i]
+            )
+            for i in range(self.num_scan_inputs)
+        ]
+        if self.input_axes_:
+            max_axe_in = max(self.input_axes_)
+            if max_axe_in != 0:
+                raise RuntimeError(
+                    "Scan is not implemented for other input axes than 0."
+                )
+        self.input_names = self.body.input_names
+        self.output_names = self.body.output_names
+
+    def need_context(self) -> bool:
+        """Scan body subgraphs may reference names from the enclosing graph
+        (lexical capture, per the ONNX spec). Request the outer-scope
+        context so those names resolve at body-evaluation time.
+        """
+        return True
+
+    def _common_run_shape(self, *args):
+        num_loop_state_vars = len(args) - self.num_scan_inputs
+        num_scan_outputs = len(self.output_names) - num_loop_state_vars
+
+        output_directions = [
+            (
+                0
+                if self.scan_output_directions is None
+                or i >= len(self.scan_output_directions)
+                else self.scan_output_directions[i]
+            )
+            for i in range(num_scan_outputs)
+        ]
+        max_dir_out = max(output_directions) if output_directions else 0
+        if max_dir_out != 0:
+            raise RuntimeError(
+                "Scan is not implemented for other output output_direction than 0."
+            )
+        output_axes = [
+            (
+                0
+                if self.scan_output_axes is None or i >= len(self.scan_output_axes)
+                else self.scan_output_axes[i]
+            )
+            for i in range(num_scan_outputs)
+        ]
+        max_axe_out = max(output_axes) if output_axes else 0
+        if max_axe_out != 0:
+            raise RuntimeError("Scan is not implemented for other output axes than 0.")
+
+        state_names_in = self.input_names[:num_loop_state_vars]
+        state_names_out = self.output_names[: len(state_names_in)]
+        scan_names_in = self.input_names[num_loop_state_vars:]
+        scan_names_out = self.output_names[num_loop_state_vars:]
+        scan_values = args[num_loop_state_vars:]
+
+        states = list(args[:num_loop_state_vars])
+
+        return (
+            num_loop_state_vars,
+            num_scan_outputs,
+            output_directions,
+            max_dir_out,
+            output_axes,
+            max_axe_out,
+            state_names_in,
+            state_names_out,
+            scan_names_in,
+            scan_names_out,
+            scan_values,
+            states,
+        )
+
+    def _run(  # type: ignore[override]
+        self,
+        *args,
+        context=None,
+        body=None,  # noqa: ARG002
+        num_scan_inputs=None,  # noqa: ARG002
+        scan_input_axes=None,  # noqa: ARG002
+        scan_input_directions=None,  # noqa: ARG002
+        scan_output_axes=None,  # noqa: ARG002
+        scan_output_directions=None,  # noqa: ARG002
+        attributes=None,  # noqa: ARG002
+    ):
+        # TODO: support overridden attributes.
+        (
+            num_loop_state_vars,
+            _num_scan_outputs,
+            _output_directions,
+            _max_dir_out,
+            _output_axes,
+            _max_axe_out,
+            state_names_in,
+            state_names_out,
+            scan_names_in,
+            scan_names_out,
+            scan_values,
+            states,
+        ) = self._common_run_shape(*args)
+
+        max_iter = args[num_loop_state_vars].shape[self.input_axes_[0]]
+        results = [[] for _ in scan_names_out]
+
+        for it in range(max_iter):
+            # Seed with outer-scope values first; per-iteration state and
+            # scan-slice inputs (added below) shadow any same-named outer
+            # values, matching ONNX's lexical-capture semantics.
+            inputs: dict = {}
+            if context is not None:
+                inputs.update(context)
+            inputs.update(dict(zip(state_names_in, states, strict=False)))
+            inputs.update(
+                {
+                    name: value[it]
+                    for name, value in zip(scan_names_in, scan_values, strict=False)
+                }
+            )
+
+            try:
+                outputs_list = self._run_body(inputs)
+            except TypeError as e:
+                raise TypeError(
+                    f"Unable to call 'run' for type '{type(self.body)}'."
+                ) from e
+
+            outputs = dict(zip(self.output_names, outputs_list, strict=False))
+            states = [outputs[name] for name in state_names_out]
+            for i, name in enumerate(scan_names_out):
+                results[i].append(np.expand_dims(outputs[name], axis=0))
+
+        if max_iter == 0 and results:
+            # Zero-trip Scan with scan outputs is not supported: the per-iteration
+            # element shape/dtype cannot be reliably inferred without executing
+            # the body. Treat as an error rather than guessing.
+            raise RuntimeError(
+                "Scan with zero scan-input length and scan outputs is not supported."
+            )
+        for res in results:
+            states.append(np.concatenate(res, axis=0))
+        return self._check_and_fix_outputs(tuple(states))
diff --git a/onnx/reference/ops/op_scatter_elements.py b/onnx/reference/ops/op_scatter_elements.py
new file mode 100644
index 0000000..e13986b
--- /dev/null
+++ b/onnx/reference/ops/op_scatter_elements.py
@@ -0,0 +1,119 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def scatter_elements(data, indices, updates, axis=0, reduction=None):
+    """Scatter elements.
+
+    ::
+        for 3-dim and axis=0
+            output[indices[i][j][k]][j][k] = updates[i][j][k]
+        for axis 1
+            output[i][indices[i][j][k]][k] = updates[i][j][k]
+        and so on.
+    """
+    if reduction == "add":
+
+        def f(x, y):
+            return x + y
+
+    elif reduction == "mul":
+
+        def f(x, y):
+            return x * y
+
+    elif reduction == "min":
+
+        def f(x, y):
+            return min(x, y)
+
+    elif reduction == "max":
+
+        def f(x, y):
+            return max(x, y)
+
+    else:
+
+        def f(x, y):  # noqa: ARG001
+            return y
+
+    if axis < 0:
+        axis = data.ndim + axis
+
+    if len(data.shape) == 1 and axis == 0:
+        scattered = np.copy(data)
+        for pos, up in zip(indices, updates, strict=True):
+            scattered[pos] = f(scattered[pos], up)
+        return scattered
+
+    if len(indices.shape) == 2:
+        scattered = np.copy(data)
+        if axis == 0:
+            for i in range(indices.shape[0]):
+                for j in range(indices.shape[1]):
+                    scattered[indices[i, j], j] = f(
+                        scattered[indices[i, j], j], updates[i, j]
+                    )
+        else:
+            for i in range(indices.shape[0]):
+                for j in range(indices.shape[1]):
+                    scattered[i, indices[i, j]] = f(
+                        scattered[i, indices[i, j]], updates[i, j]
+                    )
+        return scattered
+
+    if len(indices.shape) == 3:
+        scattered = np.copy(data)
+        if axis == 0:
+            for i in range(indices.shape[0]):
+                for j in range(indices.shape[1]):
+                    for k in range(indices.shape[2]):
+                        scattered[indices[i, j, k], j, k] = f(
+                            scattered[indices[i, j, k], j, k], updates[i, j, k]
+                        )
+        elif axis == 1:
+            for i in range(indices.shape[0]):
+                for j in range(indices.shape[1]):
+                    for k in range(indices.shape[2]):
+                        scattered[i, indices[i, j, k], k] = f(
+                            scattered[i, indices[i, j, k], k], updates[i, j, k]
+                        )
+        elif axis == 2:
+            for i in range(indices.shape[0]):
+                for j in range(indices.shape[1]):
+                    for k in range(indices.shape[2]):
+                        scattered[i, j, indices[i, j, k]] = f(
+                            scattered[i, j, indices[i, j, k]], updates[i, j, k]
+                        )
+        return scattered
+
+    if len(indices.shape) == 4:
+        scattered = np.copy(data)
+        for a in range(indices.shape[0]):
+            for i in range(indices.shape[1]):
+                for j in range(indices.shape[2]):
+                    for k in range(indices.shape[3]):
+                        index = [a, i, j, k]
+                        index[axis] = indices[a, i, j, k]
+                        tuple_index = tuple(index)
+                        scattered[tuple_index] = f(
+                            scattered[tuple_index],
+                            updates[a, i, j, k],
+                        )
+        return scattered
+
+    raise NotImplementedError(
+        f"ScatterND is not implement for indices.shape={indices.shape} and axis={axis}."
+    )
+
+
+class ScatterElements(OpRun):
+    def _run(self, data, indices, updates, axis=None, reduction=None):
+        res = scatter_elements(data, indices, updates, axis=axis, reduction=reduction)
+        return (res,)
diff --git a/onnx/reference/ops/op_scatternd.py b/onnx/reference/ops/op_scatternd.py
new file mode 100644
index 0000000..453ac6a
--- /dev/null
+++ b/onnx/reference/ops/op_scatternd.py
@@ -0,0 +1,34 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _scatter_nd_impl(data, indices, updates, reduction=None):
+    output = np.copy(data)
+    for i in np.ndindex(indices.shape[:-1]):
+        if reduction == "add":
+            output[tuple(indices[i])] += updates[i]
+        elif reduction == "mul":
+            output[tuple(indices[i])] *= updates[i]
+        elif reduction == "max":
+            output[tuple(indices[i])] = np.maximum(
+                output[tuple(indices[i])], updates[i]
+            )
+        elif reduction == "min":
+            output[tuple(indices[i])] = np.minimum(
+                output[tuple(indices[i])], updates[i]
+            )
+        else:
+            output[tuple(indices[i])] = updates[i]
+    return output
+
+
+class ScatterND(OpRun):
+    def _run(self, data, indices, updates, reduction=None):
+        y = _scatter_nd_impl(data, indices, updates, reduction=reduction)
+        return (y,)
diff --git a/onnx/reference/ops/op_selu.py b/onnx/reference/ops/op_selu.py
new file mode 100644
index 0000000..cba6f73
--- /dev/null
+++ b/onnx/reference/ops/op_selu.py
@@ -0,0 +1,15 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Selu(OpRun):
+    def _run(self, x, alpha=None, gamma=None):
+        return (
+            (np.where(x > 0, x, np.exp(x) * alpha - alpha) * gamma).astype(x.dtype),
+        )
diff --git a/onnx/reference/ops/op_sequence_at.py b/onnx/reference/ops/op_sequence_at.py
new file mode 100644
index 0000000..43fd72b
--- /dev/null
+++ b/onnx/reference/ops/op_sequence_at.py
@@ -0,0 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class SequenceAt(OpRun):
+    def _run(self, seq, index):
+        return (seq[index],)
diff --git a/onnx/reference/ops/op_sequence_construct.py b/onnx/reference/ops/op_sequence_construct.py
new file mode 100644
index 0000000..a2460dc
--- /dev/null
+++ b/onnx/reference/ops/op_sequence_construct.py
@@ -0,0 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class SequenceConstruct(OpRun):
+    def _run(self, *data):
+        return (list(data),)
diff --git a/onnx/reference/ops/op_sequence_empty.py b/onnx/reference/ops/op_sequence_empty.py
new file mode 100644
index 0000000..eb5f1c4
--- /dev/null
+++ b/onnx/reference/ops/op_sequence_empty.py
@@ -0,0 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class SequenceEmpty(OpRun):
+    def _run(self, dtype=None):  # type: ignore[override]  # noqa: ARG002
+        return ([],)
diff --git a/onnx/reference/ops/op_sequence_erase.py b/onnx/reference/ops/op_sequence_erase.py
new file mode 100644
index 0000000..0633f52
--- /dev/null
+++ b/onnx/reference/ops/op_sequence_erase.py
@@ -0,0 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class SequenceErase(OpRun):
+    def _run(self, S, ind=None):
+        if ind is None:
+            ind = -1
+        else:
+            ind = int(ind)
+        S2 = S.copy()
+        del S2[ind]
+        return (S2,)
diff --git a/onnx/reference/ops/op_sequence_insert.py b/onnx/reference/ops/op_sequence_insert.py
new file mode 100644
index 0000000..179bcbc
--- /dev/null
+++ b/onnx/reference/ops/op_sequence_insert.py
@@ -0,0 +1,52 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def sequence_insert_reference_implementation(
+    sequence: list[Any] | np.ndarray,
+    tensor: np.ndarray,
+    position: np.ndarray | None = None,
+) -> list[Any]:
+    # make a copy of input sequence
+    seq: list[Any] = []
+    if sequence is not None and (
+        not isinstance(sequence, np.ndarray) or len(sequence.shape) > 0
+    ):
+        try:
+            seq.extend(sequence)
+        except TypeError as e:
+            raise TypeError(
+                f"Unable to iterate on type {type(sequence)}: {sequence}."
+            ) from e
+    if position is not None:
+        # In these cases, insert_position will be between [-len(sequence), len(sequence)]
+        # The position argument will be in the format np.array([pos_index])
+        insert_position = (position[0] + len(seq)) % len(seq)
+        seq.insert(insert_position, tensor)
+    else:
+        # Default position of insertion is at the end of the sequence.
+        seq.append(tensor)
+    return seq
+
+
+class SequenceInsert(OpRun):
+    def _run(self, S, T, ind=None):
+        if ind is None:
+            res = sequence_insert_reference_implementation(S, T)
+        elif isinstance(ind, int):
+            res = sequence_insert_reference_implementation(S, T, [ind])  # type: ignore[arg-type]
+        elif len(ind.shape) > 0:
+            res = sequence_insert_reference_implementation(S, T, ind)
+        elif len(ind.shape) == 0:
+            res = sequence_insert_reference_implementation(S, T, [int(ind)])  # type: ignore[arg-type]
+        else:
+            res = sequence_insert_reference_implementation(S, T)
+        return (res,)
diff --git a/onnx/reference/ops/op_sequence_length.py b/onnx/reference/ops/op_sequence_length.py
new file mode 100644
index 0000000..3e5f8f9
--- /dev/null
+++ b/onnx/reference/ops/op_sequence_length.py
@@ -0,0 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class SequenceLength(OpRun):
+    def _run(self, input_sequence):
+        if not isinstance(input_sequence, list):
+            raise TypeError(
+                f"input_sequence must be a list not {type(input_sequence)}."
+            )
+        return (np.array(len(input_sequence), dtype=np.int64),)
diff --git a/onnx/reference/ops/op_sequence_map.py b/onnx/reference/ops/op_sequence_map.py
new file mode 100644
index 0000000..96c3736
--- /dev/null
+++ b/onnx/reference/ops/op_sequence_map.py
@@ -0,0 +1,33 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class SequenceMap(OpRun):
+    def _run(self, input_sequence, *additional_inputs, body=None, attributes=None):
+        if len(additional_inputs) == 1 and isinstance(additional_inputs[0], list):
+            res = None
+            for obj1, obj2 in zip(input_sequence, additional_inputs[0], strict=False):
+                feeds = {body.input_names[0]: obj1, body.input_names[1]: obj2}
+                r = body.run(None, feeds)
+                if res is None:
+                    res = [[i] for i in r]
+                else:
+                    for s, i in zip(res, r, strict=False):
+                        s.append(i)
+            return tuple(res)
+
+        feeds = dict(zip(body.input_names[1:], additional_inputs, strict=False))
+        res = None
+        for obj in input_sequence:
+            feeds[body.input_names[0]] = obj
+            r = body.run(None, feeds, attributes=attributes)
+            if res is None:
+                res = [[i] for i in r]
+            else:
+                for s, i in zip(res, r, strict=False):
+                    s.append(i)
+        return tuple(res)
diff --git a/onnx/reference/ops/op_shape.py b/onnx/reference/ops/op_shape.py
new file mode 100644
index 0000000..58e26c3
--- /dev/null
+++ b/onnx/reference/ops/op_shape.py
@@ -0,0 +1,35 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Shape_1(OpRun):
+    def _run(self, data):
+        return (np.array(data.shape, dtype=np.int64),)
+
+
+class Shape_15(Shape_1):
+    @staticmethod
+    def _interval(n: int, start: int | None, end: int | None) -> tuple[int, int] | None:
+        if start == 0:
+            if end is None or np.isnan(end):
+                return None
+            if end < 0:
+                return (0, n + end)
+            return (0, end)
+        if end is None or np.isnan(end):
+            return (start, n)
+        if end < 0:
+            return (start, n + end)
+        return (start, end)
+
+    def _run(self, data, end=None, start=None):
+        ab = self._interval(len(data.shape), start=start, end=end)
+        if ab is None:
+            return (np.array(data.shape, dtype=np.int64),)
+        return (np.array(data.shape[ab[0] : ab[1]], dtype=np.int64),)
diff --git a/onnx/reference/ops/op_shrink.py b/onnx/reference/ops/op_shrink.py
new file mode 100644
index 0000000..da65a0c
--- /dev/null
+++ b/onnx/reference/ops/op_shrink.py
@@ -0,0 +1,19 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Shrink(OpRun):
+    def _run(self, x, bias=None, lambd=None):
+        return (
+            np.where(
+                x < -lambd,
+                x + bias,
+                np.where(x > lambd, x - bias, 0),
+            ).astype(x.dtype),
+        )
diff --git a/onnx/reference/ops/op_sigmoid.py b/onnx/reference/ops/op_sigmoid.py
new file mode 100644
index 0000000..bacd128
--- /dev/null
+++ b/onnx/reference/ops/op_sigmoid.py
@@ -0,0 +1,27 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+def sigmoid(x: np.ndarray) -> np.ndarray:
+    """Numerically stable sigmoid implementation that supports scalars and nd-arrays."""
+    pos_mask = x > 0
+    exp_x = np.exp(x)
+    return np.where(
+        pos_mask,
+        1.0 / (1.0 + np.exp(-x)),
+        exp_x / (1.0 + exp_x),
+    )
+
+
+class Sigmoid(OpRunUnaryNum):
+    def __init__(self, onnx_node, run_params):
+        OpRunUnaryNum.__init__(self, onnx_node, run_params)
+
+    def _run(self, X):
+        return (sigmoid(X).astype(X.dtype),)
diff --git a/onnx/reference/ops/op_sign.py b/onnx/reference/ops/op_sign.py
new file mode 100644
index 0000000..b90d262
--- /dev/null
+++ b/onnx/reference/ops/op_sign.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Sign(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.sign(x),)
diff --git a/onnx/reference/ops/op_sin.py b/onnx/reference/ops/op_sin.py
new file mode 100644
index 0000000..be05e33
--- /dev/null
+++ b/onnx/reference/ops/op_sin.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Sin(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.sin(x),)
diff --git a/onnx/reference/ops/op_sinh.py b/onnx/reference/ops/op_sinh.py
new file mode 100644
index 0000000..2daf196
--- /dev/null
+++ b/onnx/reference/ops/op_sinh.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Sinh(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.sinh(x),)
diff --git a/onnx/reference/ops/op_size.py b/onnx/reference/ops/op_size.py
new file mode 100644
index 0000000..68de150
--- /dev/null
+++ b/onnx/reference/ops/op_size.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Size(OpRun):
+    def _run(self, data):
+        return (np.array(data.size, dtype=np.int64),)
diff --git a/onnx/reference/ops/op_slice.py b/onnx/reference/ops/op_slice.py
new file mode 100644
index 0000000..6dd47a3
--- /dev/null
+++ b/onnx/reference/ops/op_slice.py
@@ -0,0 +1,75 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRun
+
+
+def _slice(
+    data: np.ndarray,
+    starts: np.ndarray,
+    ends: np.ndarray,
+    axes: np.ndarray | None = None,
+    steps: np.ndarray | None = None,
+) -> np.ndarray:
+    if isinstance(starts, list):
+        starts = np.array(starts)
+    if isinstance(ends, list):
+        ends = np.array(ends)
+    if isinstance(axes, list):
+        axes = np.array(axes)
+    if isinstance(steps, list):
+        steps = np.array(steps)
+    if len(starts.shape) == 0:
+        starts = np.array([starts])
+    if len(ends.shape) == 0:
+        ends = np.array([ends])
+    if axes is None:
+        if steps is None:
+            slices = [slice(s, e) for s, e in zip(starts, ends, strict=False)]
+        else:
+            slices = [
+                slice(s, e, d) for s, e, d in zip(starts, ends, steps, strict=False)
+            ]
+    else:  # noqa: PLR5501
+        if steps is None:
+            slices = [slice(0, a) for a in data.shape]
+            for s, e, a in zip(starts, ends, axes, strict=False):
+                slices[a] = slice(s, e)
+        else:
+            slices = [slice(0, a) for a in data.shape]
+            for s, e, a, d in zip(starts, ends, axes, steps, strict=False):
+                slices[a] = slice(s, e, d)
+    try:
+        return data[tuple(slices)]
+    except TypeError as e:  # pragma: no cover
+        raise TypeError(
+            f"Unable to extract slice {slices!r} for shape {data.shape!r}."
+        ) from e
+
+
+class SliceCommon(OpRun):
+    def _run(self, data, starts, ends, axes=None, steps=None):
+        res = _slice(data, starts, ends, axes, steps)
+        return (res,)
+
+
+class Slice_10(SliceCommon):
+    def __init__(self, onnx_node, run_params):
+        SliceCommon.__init__(self, onnx_node, run_params)
+
+
+class Slice_1(SliceCommon):
+    def __init__(self, onnx_node, run_params):
+        SliceCommon.__init__(self, onnx_node, run_params)
+        for f in ["starts", "ends", "steps", "axes"]:
+            if not hasattr(self, f):
+                continue
+            if getattr(self, f) is not None and len(getattr(self, f)) == 0:
+                setattr(self, f, None)
+
+    def _run(self, data, axes=None, ends=None, starts=None):
+        return SliceCommon._run(self, data, starts, ends, axes)
diff --git a/onnx/reference/ops/op_softmax.py b/onnx/reference/ops/op_softmax.py
new file mode 100644
index 0000000..acc11e5
--- /dev/null
+++ b/onnx/reference/ops/op_softmax.py
@@ -0,0 +1,19 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Softmax(OpRunUnaryNum):
+    def _run(self, X, axis=None):
+        if X.size == 0:
+            return (X,)
+        axis = axis or self.axis
+        tmp = X - X.max(axis=axis, keepdims=1)
+        Y = np.exp(tmp)
+        Y /= Y.sum(axis=axis, keepdims=1)
+        return (Y.astype(X.dtype),)
diff --git a/onnx/reference/ops/op_softmax_cross_entropy_loss.py b/onnx/reference/ops/op_softmax_cross_entropy_loss.py
new file mode 100644
index 0000000..c4ac711
--- /dev/null
+++ b/onnx/reference/ops/op_softmax_cross_entropy_loss.py
@@ -0,0 +1,94 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def softmaxcrossentropy(
+    x, target, weight=None, reduction="mean", ignore_index=None, get_log_prob=None
+):
+    input_shape = x.shape
+    if len(input_shape) == 1:
+        raise RuntimeError(f"Unsupported shape {input_shape!r}.")
+
+    target_shape = target.shape
+    N = input_shape[0]
+    C = input_shape[1]
+
+    # compute log_softmax
+    max_x = np.max(x, axis=1, keepdims=True)
+    exp_x = np.exp(x - max_x)
+    p = exp_x / np.sum(exp_x, axis=1, keepdims=True)
+    inp = np.log(p)
+    log_prob = None
+    if get_log_prob is True:
+        log_prob = np.copy(inp)
+
+    # initialize the positional weights when required
+    gather_weight = None
+    if weight is not None:
+        gather_weight = np.take(weight, np.array(target, dtype=np.int32), mode="clip")
+        if ignore_index is not None:
+            gather_weight = np.where(target == ignore_index, 0, gather_weight).astype(
+                dtype=x.dtype
+            )
+    elif ignore_index is not None:
+        gather_weight = np.where(target == ignore_index, 0, 1).astype(dtype=x.dtype)
+
+    # if input is 4-d and above, make it 3-d
+    if len(input_shape) != 3:
+        inp = inp.reshape((N, C, -1))
+        target = target.reshape((N, -1))
+
+    # Get a dimension from the reshaped input.
+    # If the original input shape is [N, C, H, W],
+    # the D here should be H * W because we reshape
+    # [N, C, H, W] to [N, C, H * W].
+    D = inp.shape[2]
+    neg_gather_element_input = np.zeros((N, D), dtype=x.dtype)
+    for i in range(N):
+        for d in range(D):
+            if target[i, d] != ignore_index:
+                neg_gather_element_input[i, d] = -inp[i, target[i, d], d]
+
+    loss = neg_gather_element_input
+
+    # if the input was 4-d or above reshape to the right shape
+    if len(input_shape) != 3:
+        loss = loss.reshape(target_shape)
+
+    # apply the weights when required
+    if gather_weight is not None:
+        loss = gather_weight * loss
+        if reduction == "mean":
+            loss = loss.sum() / gather_weight.sum()
+            if get_log_prob is True:
+                return loss, log_prob
+            return (loss,)
+
+    if reduction == "mean":
+        loss = np.mean(loss)
+    elif reduction == "sum":
+        loss = np.sum(loss)
+
+    loss = loss.astype(x.dtype)
+    if get_log_prob is True:
+        return loss, log_prob.astype(x.dtype)  # type: ignore[union-attr]
+    return (loss,)
+
+
+class SoftmaxCrossEntropyLoss(OpRun):
+    def _run(self, x, target, weight=None, ignore_index=None, reduction=None):
+        n_outputs = len(self.onnx_node.output)
+        return softmaxcrossentropy(
+            x,
+            target,
+            weight=weight,
+            reduction=reduction,
+            ignore_index=ignore_index,
+            get_log_prob=n_outputs == 2,
+        )
diff --git a/onnx/reference/ops/op_softplus.py b/onnx/reference/ops/op_softplus.py
new file mode 100644
index 0000000..bcd7bc1
--- /dev/null
+++ b/onnx/reference/ops/op_softplus.py
@@ -0,0 +1,16 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Softplus(OpRunUnaryNum):
+    def _run(self, X):
+        tmp = np.asarray(np.exp(X), dtype=X.dtype)
+        tmp += 1
+        np.log(tmp, out=tmp)
+        return (tmp,)
diff --git a/onnx/reference/ops/op_softsign.py b/onnx/reference/ops/op_softsign.py
new file mode 100644
index 0000000..4dd93ab
--- /dev/null
+++ b/onnx/reference/ops/op_softsign.py
@@ -0,0 +1,16 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Softsign(OpRunUnaryNum):
+    def _run(self, X):
+        tmp = np.abs(X)
+        tmp += 1
+        np.divide(X, tmp, out=tmp)
+        return (tmp,)
diff --git a/onnx/reference/ops/op_space_to_depth.py b/onnx/reference/ops/op_space_to_depth.py
new file mode 100644
index 0000000..2818714
--- /dev/null
+++ b/onnx/reference/ops/op_space_to_depth.py
@@ -0,0 +1,33 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class SpaceToDepth(OpRun):
+    def _run(self, data, blocksize=None):
+        if len(data.shape) != 4:
+            raise RuntimeError(f"Unexpected shape {data.shape!r}.")
+        b, C, H, W = data.shape
+        tmpshape = (
+            b,
+            C,
+            H // blocksize,
+            blocksize,
+            W // blocksize,
+            blocksize,
+        )
+        reshaped = np.reshape(data, tmpshape)
+        transposed = np.transpose(reshaped, [0, 3, 5, 1, 2, 4])
+        finalshape = (
+            b,
+            C * blocksize * blocksize,
+            H // blocksize,
+            W // blocksize,
+        )
+        y = np.reshape(transposed, finalshape).astype(data.dtype)
+        return (y,)
diff --git a/onnx/reference/ops/op_split.py b/onnx/reference/ops/op_split.py
new file mode 100644
index 0000000..3f7b0a0
--- /dev/null
+++ b/onnx/reference/ops/op_split.py
@@ -0,0 +1,51 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class CommonSplit(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        self.n_outputs = len(onnx_node.output)
+
+    def common_run(self, mat, split, axis, num_outputs):
+        n_outputs = num_outputs or self.n_outputs
+        if split is None:
+            if mat.shape[axis] % n_outputs == 0:
+                div = mat.shape[axis] // n_outputs
+                split = [div] * n_outputs
+            else:
+                div = mat.shape[axis] // n_outputs + 1
+                split = [div] * n_outputs
+                split[-1] += mat.shape[axis] - sum(split)
+
+        sli = [slice(0, s) for s in mat.shape]
+        res = []
+        pos = 0
+        for spl in split:
+            sli[axis] = slice(pos, pos + spl)
+            pos += spl
+            res.append(mat[tuple(sli)])
+        return tuple(res)
+
+
+class Split_2(CommonSplit):
+    def _run(self, mat, axis=None, split=None):
+        return self.common_run(mat, split, axis=axis, num_outputs=None)
+
+
+class Split_11(Split_2):
+    pass
+
+
+class Split_13(CommonSplit):
+    def _run(self, mat, split=None, axis=None):
+        return self.common_run(mat, split, axis=axis, num_outputs=None)
+
+
+class Split_18(CommonSplit):
+    def _run(self, mat, split=None, axis=None, num_outputs=None):
+        return self.common_run(mat, split, axis=axis, num_outputs=num_outputs)
diff --git a/onnx/reference/ops/op_split_to_sequence.py b/onnx/reference/ops/op_split_to_sequence.py
new file mode 100644
index 0000000..d879168
--- /dev/null
+++ b/onnx/reference/ops/op_split_to_sequence.py
@@ -0,0 +1,54 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from onnx.reference.op_run import OpRun
+
+if TYPE_CHECKING:
+    import numpy as np
+
+
+class SplitToSequence(OpRun):
+    def common_run(
+        self, mat: np.ndarray, split: np.ndarray | None, axis: int
+    ) -> list[np.ndarray]:
+        if split is None:
+            split_length = [1 for _ in range(mat.shape[axis])]
+        elif len(split.shape) == 0:
+            # A scalar
+            dim = mat.shape[axis]
+            length = int(split)
+            n = dim // int(length)
+            split_length = [length] * n
+            left = dim - length * n
+            if left > 0:
+                split_length.append(left)
+        else:
+            split_length = list(split)
+
+        sli = [slice(0, s) for s in mat.shape]
+        res = []
+        pos = 0
+        for spl in split_length:
+            sli[axis] = slice(pos, pos + spl)
+            pos += spl
+            res.append(mat[tuple(sli)])
+        return res
+
+    def _run(
+        self,
+        mat: np.ndarray,
+        split: np.ndarray | None = None,
+        axis: int = 0,
+        keepdims: int = 1,
+    ) -> tuple[np.ndarray]:
+        res = self.common_run(mat, split, axis=axis)
+        if split is None and not keepdims:
+            for i, res_i in enumerate(res):
+                shape = list(res_i.shape)
+                del shape[axis]
+                res[i] = res_i.reshape(tuple(shape))
+        return (res,)
diff --git a/onnx/reference/ops/op_sqrt.py b/onnx/reference/ops/op_sqrt.py
new file mode 100644
index 0000000..9abb0ca
--- /dev/null
+++ b/onnx/reference/ops/op_sqrt.py
@@ -0,0 +1,17 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from warnings import catch_warnings, simplefilter
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Sqrt(OpRunUnaryNum):
+    def _run(self, x):
+        with catch_warnings():
+            simplefilter("ignore")
+            return (np.sqrt(x).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_squeeze.py b/onnx/reference/ops/op_squeeze.py
new file mode 100644
index 0000000..70e9044
--- /dev/null
+++ b/onnx/reference/ops/op_squeeze.py
@@ -0,0 +1,45 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Squeeze_1(OpRun):
+    def _run(self, data, axes=None):
+        if isinstance(axes, np.ndarray):
+            axes = tuple(axes)
+        elif axes in [[], ()]:
+            axes = None
+        elif isinstance(axes, list):
+            axes = tuple(axes)
+        if isinstance(axes, (tuple, list)):
+            sq = data
+            for a in reversed(axes):
+                sq = np.squeeze(sq, axis=a)
+        else:
+            sq = np.squeeze(data, axis=axes)
+        return (sq,)
+
+
+class Squeeze_11(Squeeze_1):
+    pass
+
+
+class Squeeze_13(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        self.axes = None
+
+    def _run(self, data, axes=None):
+        if axes is not None:
+            if hasattr(axes, "__iter__"):
+                sq = np.squeeze(data, axis=tuple(axes))
+            else:
+                sq = np.squeeze(data, axis=axes)
+        else:
+            sq = np.squeeze(data)
+        return (sq,)
diff --git a/onnx/reference/ops/op_stft.py b/onnx/reference/ops/op_stft.py
new file mode 100644
index 0000000..0fc5221
--- /dev/null
+++ b/onnx/reference/ops/op_stft.py
@@ -0,0 +1,167 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+from onnx.reference.ops.op_concat_from_sequence import _concat_from_sequence
+from onnx.reference.ops.op_dft import _cfft as _dft
+from onnx.reference.ops.op_slice import _slice
+
+
+def _concat(*args, axis=0):
+    return np.concatenate(args, axis=axis)
+
+
+def _unsqueeze(a, axis):
+    try:
+        return np.expand_dims(a, axis=axis)
+    except TypeError:
+        # numpy 1.18 supports axes as a tuple
+        if len(axis) == 1:
+            return np.expand_dims(a, axis=tuple(axis)[0])
+        for x in reversed(axis):
+            a = np.expand_dims(a, axis=x)
+        return a
+
+
+def _stft(x, fft_length: int, hop_length, n_frames, window, onesided=False):
+    """Applies one dimensional FFT with window weights.
+
+    torch defines the number of frames as:
+    `n_frames = 1 + (len - n_fft) // hop_length`.
+    """
+    last_axis = len(x.shape) - 1  # op.Sub(op.Shape(op.Shape(x)), one)
+    axis = [-2]
+    axis2 = [-3]
+    window_size = window.shape[0]
+
+    # building frames
+    seq = []
+    for fs in range(n_frames):
+        begin = fs * hop_length
+        end = begin + window_size
+        sliced_x = _slice(x, np.array([begin]), np.array([end]), axis)
+
+        # sliced_x may be smaller
+        new_dim = sliced_x.shape[-2:-1]
+        missing = (window_size - new_dim[0],)
+        new_shape = sliced_x.shape[:-2] + missing + sliced_x.shape[-1:]
+        cst = np.zeros(new_shape, dtype=x.dtype)
+        pad_sliced_x = _concat(sliced_x, cst, axis=-2)
+
+        # same size
+        un_sliced_x = _unsqueeze(pad_sliced_x, axis2)
+        seq.append(un_sliced_x)
+
+    # concatenation
+    new_x = _concat_from_sequence(seq, axis=-3, new_axis=0)
+
+    # calling weighted dft with weights=window
+    shape_x = new_x.shape
+    shape_x_short = shape_x[:-2]
+    shape_x_short_one = tuple(1 for _ in shape_x_short)
+    window_shape = (*shape_x_short_one, window_size, 1)
+    weights = np.reshape(window, window_shape)
+    weighted_new_x = new_x * weights
+
+    return _dft(
+        weighted_new_x, fft_length, last_axis, onesided=onesided, normalize=False
+    )
+
+
+def _istft(x, fft_length: int, hop_length, window, onesided=False):
+    """Reverses of `stft`."""
+    zero = [0]
+    one = [1]
+    two = [2]
+    axisf = [-2]
+    n_frames = x.shape[-2]
+    expected_signal_len = fft_length + hop_length * (n_frames - 1)
+
+    # building frames
+    seqr = []
+    seqi = []
+    seqc = []
+    for fs in range(n_frames):
+        begin = fs
+        end = fs + 1
+        frame_x = np.squeeze(
+            _slice(x, np.array([begin]), np.array([end]), axisf),
+            axis=axisf[0],
+        )
+
+        # ifft
+        ift = _dft(frame_x, fft_length, axis=-1, onesided=onesided, normalize=True)
+        n_dims = len(ift.shape)
+
+        # real part
+        n_dims_1 = n_dims - 1
+        sliced = _slice(ift, np.array(zero), np.array(one), [n_dims_1])
+        ytmp = np.squeeze(sliced, axis=n_dims_1)
+        ctmp = np.full(ytmp.shape, fill_value=1, dtype=x.dtype) * window
+
+        shape_begin = ytmp.shape[:-1]
+        n_left = fs * hop_length
+        size = ytmp.shape[-1]
+        n_right = expected_signal_len - (n_left + size)
+
+        left_shape = (*shape_begin, n_left)
+        right_shape = (*shape_begin, n_right)
+        right = np.zeros(right_shape, dtype=x.dtype)
+        left = np.zeros(left_shape, dtype=x.dtype)
+
+        y = _concat(left, ytmp, right, axis=-1)
+        yc = _concat(left, ctmp, right, axis=-1)
+
+        # imaginary part
+        sliced = _slice(ift, np.array(one), np.array(two), [n_dims_1])
+        itmp = np.squeeze(sliced, axis=n_dims_1)
+        yi = _concat(left, itmp, right, axis=-1)
+
+        # append
+        seqr.append(_unsqueeze(y, axis=-1))
+        seqi.append(_unsqueeze(yi, axis=-1))
+        seqc.append(_unsqueeze(yc, axis=-1))
+
+    # concatenation
+    redr = _concat_from_sequence(seqr, axis=-1, new_axis=0)
+    redi = _concat_from_sequence(seqi, axis=-1, new_axis=0)
+    redc = _concat_from_sequence(seqc, axis=-1, new_axis=0)
+
+    # unweight
+    resr = redr.sum(axis=-1, keepdims=0)
+    resi = redi.sum(axis=-1, keepdims=0)
+    resc = redc.sum(axis=-1, keepdims=0)
+    rr = resr / resc
+    ri = resi / resc
+
+    # Make complex
+    rr0 = np.expand_dims(rr, axis=0)
+    ri0 = np.expand_dims(ri, axis=0)
+    conc = _concat(rr0, ri0, axis=0)
+
+    # rotation, bring first dimension to the last position
+    result_shape = conc.shape
+    reshaped_result = conc.reshape((2, -1))
+    transposed = np.transpose(reshaped_result, (1, 0))
+    other_dimensions = result_shape[1:]
+    final_shape = _concat(other_dimensions, two, axis=0)
+    return transposed.reshape(final_shape)
+
+
+class STFT(OpRun):
+    def _run(self, x, frame_step, window=None, frame_length=None, onesided=None):
+        if frame_length is None:
+            if window is None:
+                frame_length = x.shape[-2]
+            else:
+                frame_length = window.shape[0]
+        hop_length = frame_step
+        if window is None:
+            window = np.ones((frame_length,), dtype=x.dtype)
+        n_frames = 1 + (x.shape[-2] - frame_length) // frame_step
+        res = _stft(x, frame_length, hop_length, n_frames, window, onesided=onesided)
+        return (res.astype(x.dtype),)
diff --git a/onnx/reference/ops/op_string_concat.py b/onnx/reference/ops/op_string_concat.py
new file mode 100644
index 0000000..2f0ac0f
--- /dev/null
+++ b/onnx/reference/ops/op_string_concat.py
@@ -0,0 +1,23 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+_acceptable_str_dtypes = ("U", "O")
+
+
+class StringConcat(OpRun):
+    def _run(self, x, y):
+        if (
+            x.dtype.kind not in _acceptable_str_dtypes
+            or y.dtype.kind not in _acceptable_str_dtypes
+        ):
+            raise TypeError(
+                f"Inputs must be string tensors, received dtype {x.dtype} and {y.dtype}"
+            )
+        # As per onnx/mapping.py, object numpy dtype corresponds to TensorProto.STRING
+        return (np.char.add(x.astype(np.str_), y.astype(np.str_)).astype(object),)
diff --git a/onnx/reference/ops/op_string_normalizer.py b/onnx/reference/ops/op_string_normalizer.py
new file mode 100644
index 0000000..23798f2
--- /dev/null
+++ b/onnx/reference/ops/op_string_normalizer.py
@@ -0,0 +1,149 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import locale as pylocale
+import unicodedata
+import warnings
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun, RuntimeTypeError
+
+
+class StringNormalizer(OpRun):
+    """The operator is not really threadsafe as python cannot
+    play with two locales at the same time. stop words
+    should not be implemented here as the tokenization
+    usually happens after this steps.
+    """
+
+    def _run(
+        self,
+        x,
+        case_change_action=None,
+        is_case_sensitive=None,
+        locale=None,
+        stopwords=None,
+    ):
+        slocale = locale
+        if stopwords is None:
+            raw_stops = set()
+            stops = set()
+        else:
+            raw_stops = set(stopwords)
+            if case_change_action == "LOWER":
+                stops = {w.lower() for w in stopwords}
+            elif case_change_action == "UPPER":
+                stops = {w.upper() for w in stopwords}
+            else:
+                stops = set(stopwords)
+        res = np.empty(x.shape, dtype=x.dtype)
+        if len(x.shape) == 2:
+            for i in range(x.shape[1]):
+                self._run_column(
+                    x[:, i],
+                    res[:, i],
+                    slocale=slocale,
+                    stops=stops,
+                    raw_stops=raw_stops,
+                    is_case_sensitive=is_case_sensitive,
+                    case_change_action=case_change_action,
+                )
+        elif len(x.shape) == 1:
+            self._run_column(
+                x,
+                res,
+                slocale=slocale,
+                stops=stops,
+                raw_stops=raw_stops,
+                is_case_sensitive=is_case_sensitive,
+                case_change_action=case_change_action,
+            )
+        else:
+            raise RuntimeTypeError("x must be a matrix or a vector.")
+        if len(res.shape) == 2 and res.shape[0] == 1:
+            res = np.array([[w for w in res.tolist()[0] if len(w) > 0]])
+            if res.shape[1] == 0:
+                res = np.array([[""]])
+        elif len(res.shape) == 1:
+            res = np.array([w for w in res.tolist() if len(w) > 0])
+            if len(res) == 0:
+                res = np.array([""])
+        return (res,)
+
+    @staticmethod
+    def _run_column(
+        cin,
+        cout,
+        slocale=None,
+        stops=None,
+        raw_stops=None,
+        is_case_sensitive=None,
+        case_change_action=None,
+    ):
+        if pylocale.getlocale() != slocale:
+            try:
+                pylocale.setlocale(pylocale.LC_ALL, slocale)
+            except pylocale.Error as e:
+                warnings.warn(
+                    f"Unknown local setting {slocale!r} (current: {pylocale.getlocale()!r}) - {e!r}.",
+                    stacklevel=1,
+                )
+        cout[:] = cin[:]
+
+        for i in range(cin.shape[0]):
+            if isinstance(cout[i], float):
+                # nan
+                cout[i] = ""
+            else:
+                cout[i] = StringNormalizer.strip_accents_unicode(cout[i])
+
+        if is_case_sensitive and len(stops) > 0:
+            for i in range(cin.shape[0]):
+                cout[i] = StringNormalizer._remove_stopwords(cout[i], raw_stops)
+
+        if case_change_action == "LOWER":
+            for i in range(cin.shape[0]):
+                cout[i] = cout[i].lower()
+        elif case_change_action == "UPPER":
+            for i in range(cin.shape[0]):
+                cout[i] = cout[i].upper()
+        elif case_change_action != "NONE":
+            raise RuntimeError(
+                f"Unknown option for case_change_action: {case_change_action!r}."
+            )
+
+        if not is_case_sensitive and len(stops) > 0:
+            for i in range(cin.shape[0]):
+                cout[i] = StringNormalizer._remove_stopwords(cout[i], stops)
+
+        return cout
+
+    @staticmethod
+    def _remove_stopwords(text, stops):
+        spl = text.split(" ")
+        return " ".join(filter(lambda s: s not in stops, spl))
+
+    @staticmethod
+    def strip_accents_unicode(s):
+        """Transforms accentuated unicode symbols into their simple counterpart.
+        Source: `sklearn/feature_extraction/text.py
+        <https://github.com/scikit-learn/scikit-learn/blob/main/sklearn/
+        feature_extraction/text.py#L115>`_.
+
+        Args:
+            s: string The string to strip
+
+        Returns:
+            the cleaned string
+        """
+        try:
+            # If `s` is ASCII-compatible, then it does not contain any accented
+            # characters and we can avoid an expensive list comprehension
+            s.encode("ASCII", errors="strict")
+            return s  # noqa: TRY300
+        except UnicodeEncodeError:
+            normalized = unicodedata.normalize("NFKD", s)
+            return "".join([c for c in normalized if not unicodedata.combining(c)])
diff --git a/onnx/reference/ops/op_string_split.py b/onnx/reference/ops/op_string_split.py
new file mode 100644
index 0000000..b7d6a09
--- /dev/null
+++ b/onnx/reference/ops/op_string_split.py
@@ -0,0 +1,46 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+_acceptable_str_dtypes = ("U", "O")
+
+
+def pad_empty_string(
+    split_lists: list | np.ndarray, padding_requirement: list | int
+) -> list:
+    if isinstance(split_lists, list):
+        assert isinstance(padding_requirement, int)
+        return split_lists + ["" for _ in range(padding_requirement)]
+    if isinstance(split_lists, np.ndarray):
+        assert isinstance(padding_requirement, list)
+        return list(map(pad_empty_string, split_lists, padding_requirement))
+    raise TypeError(f"Invalid array type '{type(split_lists)}'")
+
+
+def split_with_padding(x, separator=None, maxsplit=None):
+    split_lists = np.char.split(x.astype(np.str_), separator, maxsplit)
+    # Find the maximum length after splitting
+    num_splits = np.vectorize(len, otypes=[np.int64])(split_lists)
+    padding_requirement = (np.max(num_splits, initial=0) - num_splits).tolist()
+    # Add padding to lists that are shorter than the maximum length
+    split_lists_padded = np.array(
+        pad_empty_string(split_lists, padding_requirement), dtype=object
+    )
+    if x.size == 0:
+        split_lists_padded = split_lists_padded.reshape(*x.shape, 0)
+    return split_lists_padded, num_splits
+
+
+class StringSplit(OpRun):
+    def _run(self, x, delimiter=None, maxsplit=None):
+        if delimiter == "":
+            delimiter = None
+
+        if x.dtype.kind not in _acceptable_str_dtypes:
+            raise TypeError(f"Inputs must be string tensors, received dtype {x.dtype}")
+        return split_with_padding(x, delimiter, maxsplit)
diff --git a/onnx/reference/ops/op_sub.py b/onnx/reference/ops/op_sub.py
new file mode 100644
index 0000000..874c804
--- /dev/null
+++ b/onnx/reference/ops/op_sub.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinaryNumpy
+
+
+class Sub(OpRunBinaryNumpy):
+    def __init__(self, onnx_node, run_params):
+        OpRunBinaryNumpy.__init__(self, np.subtract, onnx_node, run_params)
diff --git a/onnx/reference/ops/op_sum.py b/onnx/reference/ops/op_sum.py
new file mode 100644
index 0000000..7380b6e
--- /dev/null
+++ b/onnx/reference/ops/op_sum.py
@@ -0,0 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.op_run import OpRun
+
+
+class Sum(OpRun):
+    def _run(self, *args):
+        return (sum(args).astype(args[0].dtype),)
diff --git a/onnx/reference/ops/op_swish.py b/onnx/reference/ops/op_swish.py
new file mode 100644
index 0000000..94ec498
--- /dev/null
+++ b/onnx/reference/ops/op_swish.py
@@ -0,0 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Swish(OpRunUnaryNum):
+    def _run(self, x, alpha=None):
+        alpha = self.alpha if alpha is None else alpha
+        return (x * (1 / (1 + np.exp(-alpha * x))).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_tan.py b/onnx/reference/ops/op_tan.py
new file mode 100644
index 0000000..ed9ce10
--- /dev/null
+++ b/onnx/reference/ops/op_tan.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Tan(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.tan(x),)
diff --git a/onnx/reference/ops/op_tanh.py b/onnx/reference/ops/op_tanh.py
new file mode 100644
index 0000000..8c4b32e
--- /dev/null
+++ b/onnx/reference/ops/op_tanh.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Tanh(OpRunUnaryNum):
+    def _run(self, x):
+        return (np.tanh(x),)
diff --git a/onnx/reference/ops/op_tensor_scatter.py b/onnx/reference/ops/op_tensor_scatter.py
new file mode 100644
index 0000000..10c2f86
--- /dev/null
+++ b/onnx/reference/ops/op_tensor_scatter.py
@@ -0,0 +1,50 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class TensorScatter(OpRun):
+    def _run(self, past_cache, update, write_indices=None, mode="linear", axis=-2):
+        if mode not in {"linear", "circular"}:
+            raise ValueError(f"Unsupported mode: {mode}")
+
+        if write_indices is None:
+            write_indices = np.zeros((past_cache.shape[0],), dtype=np.int64)
+
+        input_shape = past_cache.shape
+        update_shape = update.shape
+        axis = axis % len(input_shape)
+
+        for i in range(len(input_shape)):
+            if i != axis:
+                if input_shape[i] != update_shape[i]:
+                    raise ValueError(
+                        f"Input shape {input_shape} and update shape {update_shape} are not compatible in dimension {i}"
+                    )
+            if i == axis:
+                if input_shape[i] < update_shape[i]:
+                    raise ValueError(
+                        f"Input shape {input_shape} and update shape {update_shape} are not compatible in axis dimension"
+                    )
+
+        max_sequence_length = input_shape[axis]
+        sequence_length = update_shape[axis]
+        present_cache = np.copy(past_cache)
+
+        for prefix_idx in np.ndindex(input_shape[:axis]):
+            batch_idx = prefix_idx[0]
+            for sequence_idx in range(sequence_length):
+                cache_idx = (*prefix_idx, write_indices[batch_idx] + sequence_idx)
+                if mode == "circular":
+                    cache_idx = tuple(
+                        np.mod(np.asarray(cache_idx), max_sequence_length)
+                    )
+                update_idx = (*prefix_idx, sequence_idx)
+                present_cache[cache_idx] = update[update_idx]
+
+        return (present_cache.reshape(input_shape),)
diff --git a/onnx/reference/ops/op_tfidf_vectorizer.py b/onnx/reference/ops/op_tfidf_vectorizer.py
new file mode 100644
index 0000000..a741e89
--- /dev/null
+++ b/onnx/reference/ops/op_tfidf_vectorizer.py
@@ -0,0 +1,380 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import collections
+from enum import IntEnum
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class IntMap(collections.UserDict):
+    def __init__(self):
+        super().__init__()
+        self.added_keys = []
+
+    def emplace(self, key, value):
+        if not isinstance(key, (int, str)):
+            raise TypeError(f"key must be a int or str not {type(key)}.")
+        if not isinstance(value, NgramPart):
+            raise TypeError(f"value must be a NGramPart not {type(value)}.")
+        if key not in self:
+            self.added_keys.append(key)
+            self.data[key] = value
+        return self.data[key]
+
+    def __repr__(self):
+        vals = {k: repr(v) for k, v in self.items()}
+        rows = ["{"]
+        for k, v in sorted(vals.items()):
+            if "\n" in v:
+                vs = v.split("\n")
+                for i, line in enumerate(vs):
+                    if i == 0:
+                        if line == "{":
+                            rows.append(f"  {k}={line}")
+                        else:
+                            rows.append(f"  {k}={line},")
+                    elif i == len(vs) - 1:
+                        rows.append(f"  {line}")
+                    else:
+                        rows.append(f"    {line}")
+            else:
+                rows.append(f"  {k}={v},")
+        rows.append("}")
+        return "\n".join(rows)
+
+    @property
+    def first_key(self):
+        if len(self) == 0:
+            raise ValueError("IntMap is empty.")
+        return self.added_keys[0]
+
+
+class NgramPart:
+    def __init__(self, nid: int):
+        self.id_ = nid  # 0 - means no entry, search for a bigger N
+        self._leaves_ = None
+
+    def init(self):
+        self._leaves_ = IntMap()
+
+    def __repr__(self):
+        if self.empty():
+            return f"NgramPart({self.id_})"
+        return f"NgramPart({self.id_}, {self.leaves_!r})"
+
+    def empty(self):
+        return self._leaves_ is None
+
+    def has_leaves(self):
+        return self._leaves_ is not None and len(self._leaves_) > 0
+
+    @property
+    def leaves_(self):
+        if self._leaves_ is None:
+            raise RuntimeError("NgramPart was not initialized.")
+        return self._leaves_
+
+    def find(self, key):
+        if not self.has_leaves():
+            return None
+        if key in self._leaves_:
+            return key
+        return None
+
+    def emplace(self, key, value):
+        return self.leaves_.emplace(key, value)
+
+    def __getitem__(self, key):
+        return self._leaves_[key]
+
+
+class WeightingCriteria(IntEnum):
+    NONE = 0
+    TF = 1
+    IDF = 2
+    TFIDF = 3
+
+
+def populate_grams(
+    els,
+    els_index,
+    n_ngrams: int,
+    ngram_size: int,
+    ngram_id: int,
+    c,  # : ForwardIter ,  # Map
+):
+    for _ngrams in range(n_ngrams, 0, -1):
+        n = 1
+        m = c
+        while els_index < len(els):
+            p = m.emplace(els[els_index], NgramPart(0))
+            if n == ngram_size:
+                p.id_ = ngram_id
+                ngram_id += 1
+                els_index += 1
+                break
+            if p.empty():
+                p.init()
+            m = p.leaves_
+            n += 1
+            els_index += 1
+    return ngram_id
+
+
+class TfIdfVectorizer(OpRun):
+    def __init__(self, onnx_node, run_params):
+        OpRun.__init__(self, onnx_node, run_params)
+        mode = self.mode
+
+        if mode == "TF":
+            self.weighting_criteria_ = WeightingCriteria.TF
+        elif mode == "IDF":
+            self.weighting_criteria_ = WeightingCriteria.IDF
+        elif mode == "TFIDF":
+            self.weighting_criteria_ = WeightingCriteria.TFIDF
+
+        self.min_gram_length_ = self.min_gram_length
+        self.max_gram_length_ = self.max_gram_length
+        self.max_skip_count_ = self.max_skip_count
+        self.ngram_counts_ = self.ngram_counts
+        self.max_gram_length_ = self.max_gram_length
+        self.ngram_indexes_ = self.ngram_indexes
+        self.output_size_ = max(self.ngram_indexes_) + 1
+        self.weights_ = self.weights
+        self.pool_int64s_ = self.pool_int64s
+        self.pool_strings_ = self.pool_strings
+
+        self.int64_map_ = NgramPart(-10)
+        self.int64_map_.init()
+
+        total_items = len(self.pool_int64s_ or self.pool_strings_)
+        ngram_id = 1  # start with 1, 0 - means no n-gram
+        # Load into dictionary only required gram sizes
+        ngram_size = 1
+        for i in range(len(self.ngram_counts_)):
+            start_idx = self.ngram_counts_[i]
+            end_idx = (
+                self.ngram_counts_[i + 1]
+                if (i + 1) < len(self.ngram_counts_)
+                else total_items
+            )
+            items = end_idx - start_idx
+            if items > 0:
+                ngrams = items // ngram_size
+                if (
+                    ngram_size >= self.min_gram_length_
+                    and ngram_size <= self.max_gram_length_
+                ):
+                    ngram_id = populate_grams(
+                        self.pool_int64s_ or self.pool_strings_,
+                        start_idx,
+                        ngrams,
+                        ngram_size,
+                        ngram_id,
+                        self.int64_map_,
+                    )
+                else:
+                    ngram_id += ngrams
+            ngram_size += 1
+
+    def increment_count(
+        self, ngram_id: int, row_num: int, frequencies: list[int]
+    ) -> None:
+        ngram_id -= 1
+        # assert(ngram_id < ngram_indexes_.size());
+        output_idx = row_num * self.output_size_ + self.ngram_indexes_[ngram_id]
+        # assert(static_cast<size_t>(output_idx) < frequencies.size());
+        frequencies[output_idx] += 1
+
+    def output_result(self, B: int, frequencies: list[int]) -> np.ndarray:
+        l_output_dims: list[int] = []
+        if B == 0:
+            l_output_dims.append(self.output_size_)
+            B = 1
+        else:
+            l_output_dims.append(B)
+            l_output_dims.append(self.output_size_)
+        output_dims = tuple(l_output_dims)
+
+        row_size = self.output_size_
+
+        total_dims = np.prod(output_dims)
+        Y = np.empty((total_dims,), dtype=np.float32)
+
+        w = self.weights_
+        if self.weighting_criteria_ == WeightingCriteria.TF:
+            for i, f in enumerate(frequencies):
+                Y[i] = f
+        elif self.weighting_criteria_ == WeightingCriteria.IDF:
+            if len(w) > 0:
+                p = 0
+                for _batch in range(B):
+                    for i in range(row_size):
+                        Y[p] = w[i] if frequencies[p] > 0 else 0
+                        p += 1
+            else:
+                for p, f in enumerate(frequencies):
+                    Y[p] = 1 if f > 0 else 0
+        elif self.weighting_criteria_ == WeightingCriteria.TFIDF:
+            if len(w) > 0:
+                p = 0
+                for _batch in range(B):
+                    for i in range(row_size):
+                        Y[p] = w[i] * frequencies[p]
+                        p += 1
+            else:
+                for p, f in enumerate(frequencies):
+                    Y[p] = f
+        else:
+            raise RuntimeError("Unexpected weighting_criteria.")
+        return Y.reshape(output_dims)
+
+    def compute_impl(
+        self,
+        X: np.ndarray,
+        row_num: int,
+        row_size: int,
+        frequencies: list[int],
+        max_gram_length=None,
+        max_skip_count=None,
+        min_gram_length=None,
+        mode=None,  # noqa: ARG002
+        ngram_counts=None,  # noqa: ARG002
+        ngram_indexes=None,  # noqa: ARG002
+        pool_int64s=None,  # noqa: ARG002
+        pool_strings=None,  # noqa: ARG002
+        weights=None,  # noqa: ARG002
+    ) -> None:
+        if len(X.shape) > 1:
+            X_flat = X[row_num]
+        else:
+            X_flat = X
+        row_begin = 0
+        row_end = row_begin + row_size
+
+        max_skip_distance = max_skip_count + 1
+        start_ngram_size = min_gram_length
+
+        for skip_distance in range(1, max_skip_distance + 1):
+            ngram_start = row_begin
+            ngram_row_end = row_end
+
+            while ngram_start < ngram_row_end:
+                # We went far enough so no n-grams of any size can be gathered
+                at_least_this = ngram_start + skip_distance * (start_ngram_size - 1)
+                if at_least_this >= ngram_row_end:
+                    break
+
+                ngram_item = ngram_start
+                int_map = self.int64_map_
+                ngram_size = 1
+                while (
+                    int_map.has_leaves()
+                    and ngram_size <= max_gram_length
+                    and ngram_item < ngram_row_end
+                ):
+                    val = X_flat[ngram_item]
+                    hit = int_map.find(val)
+                    if hit is None:
+                        break
+                    hit = int_map[val].id_
+                    if ngram_size >= start_ngram_size and hit != 0:
+                        self.increment_count(hit, row_num, frequencies)
+                    int_map = int_map[val]
+                    ngram_size += 1
+                    ngram_item += skip_distance
+
+                ngram_start += 1
+
+            # We count UniGrams only once since they are not affected by skip_distance
+            if start_ngram_size == 1:
+                start_ngram_size += 1
+                if start_ngram_size > max_gram_length:
+                    break
+
+    def _run(
+        self,
+        X,
+        max_gram_length=None,
+        max_skip_count=None,
+        min_gram_length=None,
+        mode=None,
+        ngram_counts=None,
+        ngram_indexes=None,
+        pool_int64s=None,
+        pool_strings=None,
+        weights=None,
+    ):
+        # weights should be identical to self.weights as well as
+        # pool_strings, pool_int64s, ngram_indexes, ngram_counts, mode.
+        # This means none of those attributes can be used in one function.
+
+        total_items = np.prod(X.shape)
+
+        num_rows = 0
+        B = 0
+        C = 0
+        input_dims = X.shape
+        if len(input_dims) == 0:
+            num_rows = 1
+            C = 1
+            if total_items != 1:
+                raise ValueError(f"Unexpected total of items {total_items}.")
+        elif len(input_dims) == 1:
+            num_rows = 1
+            C = input_dims[0]
+        elif len(input_dims) == 2:
+            B = input_dims[0]
+            C = input_dims[1]
+            num_rows = B
+            if B < 1:
+                raise ValueError(
+                    f"Input shape must have either [C] or [B,C] dimensions with B > 0, B={B}, C={C}."
+                )
+        else:
+            raise ValueError(
+                f"Input shape must have either [C] or [B,C] dimensions with B > 0, B={B}, C={C}."
+            )
+
+        if num_rows * C != total_items:
+            raise ValueError(
+                f"Unexpected total of items, num_rows * C = {num_rows * C} != total_items = {total_items}."
+            )
+        # Frequency holder allocate [B..output_size_] and init all to zero
+        frequencies = np.zeros((num_rows * self.output_size_,), dtype=np.int64)
+
+        if total_items == 0 or self.int64_map_.empty():
+            # TfidfVectorizer may receive an empty input when it follows a Tokenizer
+            # (for example for a string containing only stopwords).
+            # TfidfVectorizer returns a zero tensor of shape
+            # {b_dim, output_size} when b_dim is the number of received observations
+            # and output_size the is the maximum value in ngram_indexes attribute plus 1.
+            return (self.output_result(B, frequencies),)  # type: ignore[arg-type]
+
+        def fn(row_num):
+            self.compute_impl(
+                X,
+                row_num,
+                C,
+                frequencies,  # type: ignore[arg-type]
+                max_gram_length=max_gram_length,
+                max_skip_count=max_skip_count,
+                min_gram_length=min_gram_length,
+                mode=mode,
+                ngram_counts=ngram_counts,
+                ngram_indexes=ngram_indexes,
+                pool_int64s=pool_int64s,
+                pool_strings=pool_strings,
+                weights=weights,
+            )
+
+        # can be parallelized.
+        for i in range(num_rows):
+            fn(i)
+
+        return (self.output_result(B, frequencies),)  # type: ignore[arg-type]
diff --git a/onnx/reference/ops/op_thresholded_relu.py b/onnx/reference/ops/op_thresholded_relu.py
new file mode 100644
index 0000000..bf49b44
--- /dev/null
+++ b/onnx/reference/ops/op_thresholded_relu.py
@@ -0,0 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class ThresholdedRelu(OpRunUnaryNum):
+    def _run(self, x, alpha=None):
+        alpha = alpha or self.alpha
+        return (np.where(x > alpha, x, 0).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_tile.py b/onnx/reference/ops/op_tile.py
new file mode 100644
index 0000000..caa7b93
--- /dev/null
+++ b/onnx/reference/ops/op_tile.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Tile(OpRun):
+    def _run(self, x, repeats):
+        return (np.tile(x, repeats),)
diff --git a/onnx/reference/ops/op_topk.py b/onnx/reference/ops/op_topk.py
new file mode 100644
index 0000000..d601bb8
--- /dev/null
+++ b/onnx/reference/ops/op_topk.py
@@ -0,0 +1,111 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def topk_sorted_implementation(X, k, axis, largest):
+    """See function `_kneighbors_reduce_func
+    <https://github.com/scikit-learn/scikit-learn/blob/main/
+    sklearn/neighbors/_base.py#L304>`_.
+    """
+    if isinstance(k, np.ndarray):
+        if k.size != 1:
+            raise RuntimeError(f"k must be an integer not {k!r}.")
+        k = k[0]
+    # This conversion is needed for distribution x86.
+    k = int(k)
+    # Used to tiebreak
+    ind_axis = np.indices(X.shape)[axis]
+    if largest:
+        ind_axis = -ind_axis
+    sorted_indices = np.lexsort((ind_axis, X), axis=axis)
+    sorted_values = np.take_along_axis(X, sorted_indices, axis=axis)
+    if largest:
+        sorted_indices = np.flip(sorted_indices, axis=axis)
+        sorted_values = np.flip(sorted_values, axis=axis)
+    ark = np.arange(k)
+    topk_sorted_indices = np.take(sorted_indices, ark, axis=axis)
+    topk_sorted_values = np.take(sorted_values, ark, axis=axis)
+    return topk_sorted_values, topk_sorted_indices
+
+
+class _CommonTopK(OpRun):
+    def _common_run(self, data, ink, axis, largest=1):
+        """Runtime for operator *TopK*.
+        The implementation is not the most efficient
+        as it sorts everything then extracts the top *k*
+        values.
+
+        .. warning::
+            ONNX specifications may be imprecise in case of negative value
+            for axis. The implementation follows what `onnxruntime`
+            does in `top_k.cc
+            <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
+        """
+        k = ink[0]
+        axis = axis if axis >= 0 else (axis + len(data.shape))
+        sort, sorti = topk_sorted_implementation(data, k, axis, largest)
+        return (sort, sorti.astype(np.int64))
+
+
+class TopK_1(_CommonTopK):
+    def _run(self, data, k=None, axis=None):
+        """Runtime for operator *TopK*.
+        The implementation is not the most efficient
+        as it sorts everything then extracts the top *k*
+        values.
+
+        .. warning::
+            ONNX specifications may be imprecise in case of negative value
+            for axis. The implementation follows what `onnxruntime`
+            does in `top_k.cc
+            <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
+        """
+        return _CommonTopK._common_run(self, data, [k], axis=axis)
+
+
+class TopK_10(_CommonTopK):
+    def _run(self, data, ink, axis=None):
+        """Runtime for operator *TopK*.
+        The implementation is not the most efficient
+        as it sorts everything then extracts the top *k*
+        values.
+
+        .. warning::
+            ONNX specifications may be imprecise in case of negative value
+            for axis. The implementation follows what `onnxruntime`
+            does in `top_k.cc
+            <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
+        """
+        return _CommonTopK._common_run(self, data, ink, axis=axis)
+
+
+class TopK_11(_CommonTopK):
+    def _run(
+        self,
+        data,
+        ink,
+        axis=None,
+        largest=None,
+        sorted=None,  # noqa: A002
+    ):
+        """Runtime for operator *TopK*.
+
+        The implementation is not the most efficient
+        as it sorts everything then extracts the top *k*
+        values.
+
+        .. warning::
+            ONNX specifications may be imprecise in case of negative value
+            for axis. The implementation follows what `onnxruntime`
+            does in `top_k.cc
+            <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
+        """
+        if sorted not in (True, 1):
+            raise RuntimeError("TopK does not implement anything for sorted=0.")
+        return _CommonTopK._common_run(self, data, ink, axis=axis, largest=largest)
diff --git a/onnx/reference/ops/op_transpose.py b/onnx/reference/ops/op_transpose.py
new file mode 100644
index 0000000..d342483
--- /dev/null
+++ b/onnx/reference/ops/op_transpose.py
@@ -0,0 +1,20 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Transpose(OpRun):
+    def _run(self, data, perm=None):
+        perm_ = None if (perm is None or len(perm) == 0) else perm
+        if perm_ is None:
+            return (np.transpose(data),)
+        if len(perm_) != len(data.shape):
+            raise RuntimeError(
+                f"Inconsistent permutation {perm_!r} with shape {data.shape!r}."
+            )
+        return (np.transpose(data, axes=perm_),)
diff --git a/onnx/reference/ops/op_trilu.py b/onnx/reference/ops/op_trilu.py
new file mode 100644
index 0000000..ff048d4
--- /dev/null
+++ b/onnx/reference/ops/op_trilu.py
@@ -0,0 +1,16 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Trilu(OpRun):
+    def _run(self, x, k=None, upper=None):
+        k = 0 if k is None else k.item()
+        if upper:
+            return (np.triu(x, k),)
+        return (np.tril(x, k).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_unique.py b/onnx/reference/ops/op_unique.py
new file mode 100644
index 0000000..5fa816a
--- /dev/null
+++ b/onnx/reference/ops/op_unique.py
@@ -0,0 +1,51 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _specify_int64(indices, inverse_indices, counts):
+    return (
+        np.array(indices, dtype=np.int64),
+        np.array(inverse_indices, dtype=np.int64),
+        np.array(counts, dtype=np.int64),
+    )
+
+
+class Unique(OpRun):
+    def _run(self, x, axis=None, sorted=None):  # type: ignore[override]  # noqa: A002
+        if axis is None or np.isnan(axis):
+            y, indices, inverse_indices, counts = np.unique(x, True, True, True)
+        else:
+            y, indices, inverse_indices, counts = np.unique(
+                x, True, True, True, axis=axis
+            )
+        if len(self.onnx_node.output) == 1:
+            return (y,)
+
+        if not sorted:
+            argsorted_indices = np.argsort(indices)
+            inverse_indices_map = dict(
+                zip(argsorted_indices, np.arange(len(argsorted_indices)), strict=True)
+            )
+            indices = indices[argsorted_indices]
+            y = np.take(x, indices, axis=0)
+            inverse_indices = np.asarray(
+                [inverse_indices_map[i] for i in inverse_indices], dtype=np.int64
+            )
+            counts = counts[argsorted_indices]
+
+        indices, inverse_indices, counts = _specify_int64(
+            indices, inverse_indices, counts
+        )
+        # numpy 2.0 has a different behavior than numpy 1.x.
+        inverse_indices = inverse_indices.reshape(-1)
+        if len(self.onnx_node.output) == 2:
+            return (y, indices)
+        if len(self.onnx_node.output) == 3:
+            return (y, indices, inverse_indices)
+        return (y, indices, inverse_indices, counts)
diff --git a/onnx/reference/ops/op_unsqueeze.py b/onnx/reference/ops/op_unsqueeze.py
new file mode 100644
index 0000000..a5a927e
--- /dev/null
+++ b/onnx/reference/ops/op_unsqueeze.py
@@ -0,0 +1,52 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Unsqueeze_1(OpRun):
+    def _run(self, data, axes=None):
+        if isinstance(axes, np.ndarray):
+            axes = tuple(axes)
+        elif axes in ([], ()):
+            axes = None
+        elif isinstance(axes, list):
+            axes = tuple(axes)
+        if isinstance(axes, (tuple, list)):
+            sq = data
+            for a in axes:
+                sq = np.expand_dims(sq, axis=a)
+        else:
+            raise TypeError("axes cannot be None for operator Unsqueeze (Unsqueeze_1).")
+        return (sq,)
+
+
+class Unsqueeze_11(Unsqueeze_1):
+    pass
+
+
+class Unsqueeze_13(OpRun):
+    def _run(self, data, axes=None):
+        if axes is not None:
+            if hasattr(axes, "__iter__") and len(axes.shape) > 0:
+                try:
+                    sq = np.expand_dims(data, axis=tuple(axes))
+                except TypeError:
+                    # numpy 1.18 supports axes as a tuple
+                    if len(axes) == 1:
+                        sq = np.expand_dims(data, axis=tuple(axes)[0])
+                    else:
+                        sq = data
+                        for a in reversed(axes):
+                            sq = np.expand_dims(sq, axis=a)
+            else:
+                sq = np.expand_dims(data, axis=axes)
+        else:
+            raise RuntimeError(
+                "axes cannot be None for operator Unsqueeze (Unsqueeze_13)."
+            )
+        return (sq,)
diff --git a/onnx/reference/ops/op_upsample.py b/onnx/reference/ops/op_upsample.py
new file mode 100644
index 0000000..31a43b0
--- /dev/null
+++ b/onnx/reference/ops/op_upsample.py
@@ -0,0 +1,20 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Upsample(OpRun):
+    def _run(self, x, scale, mode=None):
+        if mode == "nearest" and scale.astype(np.int64).tolist() == scale.tolist():
+            r = x
+            for axis, s in enumerate(scale):
+                if s == 1:
+                    continue
+                r = np.repeat(r, int(s), axis=axis)
+            return (r,)
+        raise RuntimeError(f"Not implemented for mode={mode!r} and scale={scale!r}.")
diff --git a/onnx/reference/ops/op_where.py b/onnx/reference/ops/op_where.py
new file mode 100644
index 0000000..44bc031
--- /dev/null
+++ b/onnx/reference/ops/op_where.py
@@ -0,0 +1,21 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+class Where(OpRun):
+    def _run(self, condition, x, y):
+        if (
+            x.dtype not in (y.dtype, object)
+            and x.dtype.type is not np.str_
+            and y.dtype.type is not np.str_
+        ):
+            raise RuntimeError(
+                f"x and y should share the same dtype {x.dtype} != {y.dtype}"
+            )
+        return (np.where(condition, x, y).astype(x.dtype),)
diff --git a/onnx/reference/ops/op_xor.py b/onnx/reference/ops/op_xor.py
new file mode 100644
index 0000000..18b8654
--- /dev/null
+++ b/onnx/reference/ops/op_xor.py
@@ -0,0 +1,13 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunBinary
+
+
+class Xor(OpRunBinary):
+    def _run(self, x, y):
+        return (np.logical_xor(x, y),)
diff --git a/onnx/reference/ops_optimized/__init__.py b/onnx/reference/ops_optimized/__init__.py
new file mode 100644
index 0000000..2778485
--- /dev/null
+++ b/onnx/reference/ops_optimized/__init__.py
@@ -0,0 +1,10 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from onnx.reference.ops_optimized.op_conv_optimized import Conv
+
+optimized_operators = [Conv]
+
+__all__ = ["Conv", "optimized_operators"]
diff --git a/onnx/reference/ops_optimized/op_conv_optimized.py b/onnx/reference/ops_optimized/op_conv_optimized.py
new file mode 100644
index 0000000..6640df6
--- /dev/null
+++ b/onnx/reference/ops_optimized/op_conv_optimized.py
@@ -0,0 +1,189 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
+
+
+def _make_ind(dim, shape):
+    m = np.empty(shape, dtype=np.int64)
+    ind = [slice(0, shape[i]) for i in range(len(shape))]
+    new_shape = [1] * len(shape)
+    new_shape[dim] = shape[dim]
+    first = np.arange(shape[dim]).reshape(new_shape)
+    m[tuple(ind)] = first
+    return m
+
+
+def im2col_fast(X, kernel_shape, pads, strides):
+    n_dims = len(kernel_shape)
+    m, n_C = X.shape[:2]
+
+    kernel_size = np.prod(kernel_shape)
+    shape_out = []
+    for i, dim in enumerate(kernel_shape):
+        dx = X.shape[2 + i]
+        shape_out.append((dx + pads[i] + pads[i + n_dims] - dim) // strides[i] + 1)
+
+    indices = []
+    for i in range(len(shape_out)):
+        kind = _make_ind(i, kernel_shape)
+        iind = _make_ind(i, shape_out) * strides[i]
+        index = np.tile(kind.ravel(), n_C).reshape(-1, 1) + iind.reshape(1, -1)
+        indices.append(index)
+
+    d = np.repeat(np.arange(n_C), kernel_size).reshape(-1, 1)
+
+    nc = [(0, 0)] * 2
+    padding = [(pads[i], pads[i + n_dims]) for i in range(n_dims)]
+    X_padded = np.pad(X, tuple(nc) + tuple(padding), mode="constant")
+
+    getitem = (slice(0, m), d, *indices)
+    cols = X_padded[getitem]
+    conc_cols = np.concatenate(cols, axis=-1)
+    return conc_cols, tuple(shape_out)
+
+
+def _conv_implementation_im2col(
+    X, W, B, auto_pad, dilations, group, kernel_shape, pads, strides
+):
+    if dilations is None:
+        dilations = [1 for s in X.shape[2:]]
+    if kernel_shape is None:
+        kernel_shape = W.shape[2:]
+    if pads is None:
+        pads = [0 for s in X.shape[2:]] * 2
+    if strides is None:
+        strides = [1 for s in X.shape[2:]]
+    kernel_shape = tuple(kernel_shape)
+
+    if X.shape[1] != W.shape[1] * group or W.shape[0] % group != 0:
+        raise ValueError(
+            f"Shape inconsistencies, X.shape={X.shape}, W.shape={W.shape}, group={group}, "
+            f"W should be {(W.shape[0], X.shape[1] // group, np.prod(W.shape[1:]) // X.shape[1] * group)}."
+        )
+    if group > 1:
+        res = []
+        td = 0
+        mg = W.shape[0] // group
+        dw = W.shape[1]
+
+        for b in range(X.shape[0]):
+            for g in range(group):
+                gx = X[b : b + 1, g * dw : (g + 1) * dw]
+                gw = W[g * mg : (g + 1) * mg]
+                try:
+                    cv = _conv_implementation_im2col(
+                        gx,
+                        gw,
+                        None,
+                        auto_pad,
+                        dilations,
+                        1,
+                        kernel_shape,
+                        pads,
+                        strides,
+                    )
+                except (ValueError, RuntimeError) as e:
+                    raise ValueError(
+                        f"Shape inconsistencies, X.shape={X.shape}, W.shape={W.shape}, group={g}/{group}, "
+                        f"gx.shape={gx.shape}, gw.shape={gw.shape}, auto_pad={auto_pad}, "
+                        f"dilations={dilations}, kernel_shape={kernel_shape}, pads={pads}, "
+                        f"strides={strides}."
+                    ) from e
+                if b == 0:
+                    td += cv.shape[1]
+                res.append((b, cv))
+
+        new_shape = [X.shape[0], *list(res[0][1].shape[1:])]
+        new_shape[1] = td
+        final = np.zeros(tuple(new_shape), dtype=res[0][1].dtype)
+        p = 0
+        for b, cv in res:
+            final[b : b + 1, p : p + cv.shape[1]] = cv
+            p += cv.shape[1]
+            if p >= final.shape[1]:
+                p = 0
+        if B is not None:
+            new_shape = [1 for s in final.shape]
+            new_shape[1] = B.shape[0]
+            b = B.reshape(tuple(new_shape))
+            final += b
+        return final
+
+    if dilations[0] != 1 or min(dilations) != max(dilations):
+        # Let's compute the dilated kernel.
+        nd = len(dilations)
+        new_kernel_shape = []
+        new_shape = list(W.shape[:-nd])
+        for i, d in enumerate(dilations):
+            di = len(W.shape) - nd + i
+            new_shape.append(W.shape[di] + (W.shape[di] - 1) * (d - 1))
+            new_kernel_shape.append(kernel_shape[i] + (kernel_shape[i] - 1) * (d - 1))
+        new_w = np.zeros(tuple(new_shape), dtype=W.dtype)
+        indices = [slice(0, new_w.shape[0]), slice(0, new_w.shape[1])]
+        for i, d in enumerate(dilations):
+            di = len(W.shape) - nd + i
+            indices.append(slice(0, new_w.shape[di], d))
+        new_w[tuple(indices)] = W
+        W = new_w
+        kernel_shape = new_kernel_shape
+
+    if auto_pad in {"SAME_LOWER", "SAME_UPPER", "VALID"}:
+        head = []
+        tail = []
+        for i in range(len(X.shape) - 2):
+            d = X.shape[i]
+            target_size = (d + strides[i] - 1) // strides[i]
+            pad_needed = (target_size - 1) * strides[i] + kernel_shape[i] - d
+            if auto_pad == "SAME_LOWER":
+                pad_head = (pad_needed + 1) // 2
+            else:
+                pad_head = pad_needed // 2
+            pad_tail = pad_needed - pad_head
+            head.append(pad_head)
+            tail.append(pad_tail)
+        pads = head + tail
+
+    c2, out_shape = im2col_fast(X, kernel_shape, pads, strides)
+    w_reshaped = W.reshape((-1, c2.shape[0]))
+    mul = w_reshaped @ c2
+    mul = mul.reshape((W.shape[0], X.shape[0], *out_shape))
+    perm = (1, 0, *tuple(np.arange(len(X.shape) - 2) + 2))
+    mul = mul.transpose(perm)
+
+    if B is not None:
+        if B.size == 1:
+            return mul + B
+        new_shape = [1] * len(mul.shape)
+        new_shape[1] = -1
+        mul += B.reshape(tuple(new_shape))
+    return mul
+
+
+class Conv(OpRun):
+    def _run(
+        self,
+        X,
+        W,
+        B=None,
+        auto_pad=None,
+        dilations=None,
+        group=None,
+        kernel_shape=None,
+        pads=None,
+        strides=None,
+    ):
+        if len(X.shape) < 3:  # noqa: PLR2004
+            raise ValueError(
+                f"X must have at least 3 dimensions but its shape is {X.shape}."
+            )
+        return (
+            # _conv_implementation(
+            _conv_implementation_im2col(
+                X, W, B, auto_pad, dilations, group, kernel_shape, pads, strides
+            ).astype(X.dtype),
+        )
diff --git a/onnx/reference/reference_evaluator.py b/onnx/reference/reference_evaluator.py
new file mode 100644
index 0000000..97aadc7
--- /dev/null
+++ b/onnx/reference/reference_evaluator.py
@@ -0,0 +1,617 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from io import BytesIO
+from typing import Any
+
+import numpy as np
+
+import onnx
+import onnx.model_container
+from onnx.onnx_pb import (
+    FunctionProto,
+    GraphProto,
+    ModelProto,
+    NodeProto,
+    TensorProto,
+    TypeProto,
+)
+from onnx.reference import op_run
+from onnx.reference.ops_optimized import optimized_operators
+
+
+class ReferenceEvaluator:
+    r"""Computes the outputs of an ONNX proto (`ModelProto`, `FunctionProto`, `GraphProto`, `NodeProto`).
+
+    This is a pure python implementation of ONNX specifications.
+    Mismatches may remain between the official specifications and the implementation here.
+    In the case of such a mismatch, the official spec overrides this implementation.
+
+    Args:
+        proto: :class:`onnx.ModelProto`, :class:`onnx.GraphProto`,
+            :class:`onnx.FunctionProto`, :class:`onnx.NodeProto`,
+            filename or bytes
+        verbose: display intermediate results on the standard output
+            during the execution
+        opsets: if *proto* is an instance of *GraphProto*, opsets must
+            be defined by a dictionary of
+        functions: known onnx functions
+        new_ops: this runtime can be used to test the implementations of
+            new operators, *new_ops* is a list of classes derived from
+            :class:`OpRun <onnx.reference.op_run.OpRun>`, every class
+            must define the static attribute `domain`, there may be
+            multiple implementations for the same operator, the first
+            one in the list is used.
+        optimized: some operators have two implementations, a naive one
+            corresponding to definition of the mathematical definition
+            of the operator, another one more efficient. This is the
+            case for operator Conv. The naive version is ten times
+            slower than the optimized one using a decomposition into
+            *Conv = im2col + Gemm*. If True, all optimized kernels are
+            added in `new_ops` and are used instead of the inner
+            implementation if list *new_ops* does not already contain
+            one.
+
+    The class maps every node to its associated implementation.
+    When a subgraph of a function is met,
+    it uses this class to execute the subgraph or the function.
+    Next example shows how to run `ReferenceEvaluator` with an onnx model
+    stored in file `model.onnx`.
+
+    ::
+
+        import numpy as np
+        from onnx.reference import ReferenceEvaluator
+
+        X = np.array(...)
+        sess = ReferenceEvaluator("model.onnx")
+        results = sess.run(None, {"X": X})
+        print(results[0])  # display the first result
+
+    Parameter *verbose* may be used to show intermediate results.
+
+    ::
+
+        import numpy as np
+        from onnx.reference import ReferenceEvaluator
+
+        X = np.array(...)
+        sess = ReferenceEvaluator("model.onnx", verbose=1)
+        results = sess.run(None, {"X": X})
+        print(results[0])  # display the first result
+
+    The class can use any implementation available in folder
+    `ops <https://github.com/onnx/onnx/tree/main/onnx/reference/ops>`_.
+    Adding an implementation requires two changes. The first one is
+    the implementation itself. Any existing node can be used as a template.
+    The second is one line in file `_op_list.py
+    <https://github.com/onnx/onnx/tree/main/onnx/reference/ops/_op_list.py>`_
+    to import the file and let the reference evaluator know it exists.
+
+    This class can also be used to test an implementation of
+    a custom operator. Let's assume this new operator
+    is `InvAlpha` from domain `custom`. The implementation
+    must take place in a class inheriting from
+    :class:`OpRun <onnx.reference.op_run.OpRun>`.
+    It must also define attribute `op_domain`.
+    Here is an example which computes :math:`\\frac{1}{X + \\alpha}`.
+
+    .. exec_code::
+
+        from onnx.reference.op_run import OpRun
+
+        class InvAlpha(OpRun):
+
+            op_domain = "custom"
+
+            def _run(self, x, alpha=None):
+                # None must be the default value, it is automatically
+                # replaced by class OpRun with either the default value
+                # specified in the NodeProto or an attribute value defined
+                # in a `FunctionProto`.
+                return (1 / (x + alpha),)
+
+    `alpha` is an attribute. It can be defined by the onnx node or
+    be defined by the function using this node. It is safe to assume
+    that attributes are known at the same time as the input.
+    Class `ReferenceEvaluator` must know about this new implementation
+    and this can be done by specified argument *new_ops*.
+
+    ::
+
+        sess = ReferenceEvaluator(onnx_model, new_ops=[InvAlpha])
+        got = sess.run(None, {"X": x})[0]
+
+    A specific node can be simply evaluated.
+
+    .. exec_code::
+
+        import numpy as np
+        from onnx.reference.ops._op_list import Celu
+
+        x = np.array([[0, 1], [-1, 2]], dtype=np.float32)
+        y = Celu.eval(x, alpha=0.5)
+        print(y)
+
+    This can also be expressed as:
+
+    .. exec_code::
+
+        import numpy as np
+        from onnx.reference.ops import load_op
+
+        Celu = load_op("", "Celu")  # domain is ""
+        x = np.array([[0, 1], [-1, 2]], dtype=np.float32)
+        y = Celu.eval(x, alpha=0.5)
+        print(y)
+
+    It is possible to overwrite an existing operator.
+    The class name must be the same. The domain does not have
+    to be specified for the default domain. However, by default,
+    class `OpRun` will load the most recent for this operator.
+    It can be explicitly specified by adding static attribute
+    `op_schema` of type :class:`OpSchema
+    <onnx.onnx_cpp2py_export.defs.OpSchema>`.
+
+    ::
+
+        from onnx.reference.op_run.op_conv import Conv as _Conv
+
+        class Conv(_Conv):
+
+            op_schema = instance_of_OpSchema()
+
+            def _run(self, ...):
+                ...
+
+        An operator may be different in a later opset. In that case,
+        a new implementation needs to be registered. `Pad_11`, `Pad_18`.
+        `Pad_11` is the implementation chose for opset in [11, 17].
+        `Pad_18` is selected for any greater opset. Both classes must be
+        imported into file `_op_list.py` to register their existence to the
+        runtime.
+
+        An operator may have a reference implementation such as `CastLike`
+        and still be defined as a function. By default, the reference implementation
+        is used. This behavior can be changed by adding a class to the list
+        of overwritten operators. It must inherit from :class:`OpRunExpand`.
+
+        ::
+
+            from onnx.reference.op_run import OpRunExpand
+
+            class CastLike(OpRunExpand):
+                op_domain = ""
+
+            ref = ReferenceEvaluator(model, new_ops=[CastLike])
+            # ...
+
+            This mechanism is used in unit test to check the function
+            implementation a schema may define.
+    """
+
+    def __init__(
+        self,
+        proto: Any,
+        opsets: dict[str, int] | None = None,
+        functions: list[ReferenceEvaluator | FunctionProto] | None = None,
+        verbose: int = 0,
+        new_ops: list[type[op_run.OpRun]] | None = None,
+        optimized: bool = True,
+    ) -> None:
+        if optimized:
+            if new_ops is None:
+                new_ops = optimized_operators.copy()
+            else:
+                set_new_ops = set(new_ops)
+                for op in optimized_operators:
+                    if op not in set_new_ops:
+                        new_ops.append(op)
+        self.output_types_ = None
+        self.input_types_ = None
+
+        if isinstance(proto, onnx.model_container.ModelContainer):
+            self.container_: onnx.model_container.ModelContainer | None = proto
+            proto = self.container_.model_proto
+        else:
+            self.container_ = None
+
+        if isinstance(proto, str):
+            with open(proto, "rb") as f:
+                proto = onnx.load(f)
+        elif isinstance(proto, bytes):
+            proto = onnx.load(BytesIO(proto))
+        self.proto_ = proto
+        self.functions_: dict[tuple[str, str], ReferenceEvaluator] = {}
+        self.attributes_: list[str] = []
+        if isinstance(proto, ModelProto):
+            self.onnx_graph_ = proto.graph
+            self.opsets_ = {d.domain: d.version for d in proto.opset_import}
+            if opsets is not None:
+                raise ValueError("opsets must be None if proto is ModelProto.")
+            if functions is not None:
+                raise ValueError("functions must be None if proto is ModelProto.")
+            functions = proto.functions  # type: ignore[assignment]
+        elif isinstance(proto, GraphProto):
+            self.onnx_graph_ = proto
+            if not isinstance(opsets, dict):
+                raise TypeError("opsets must be a dictionary if proto is GraphProto.")
+            self.opsets_ = opsets
+        elif isinstance(proto, FunctionProto):
+            self.onnx_graph_ = None
+            self.opsets_ = {d.domain: d.version for d in proto.opset_import}
+            if opsets is not None:
+                raise ValueError("opsets must be None if proto is FunctionProto.")
+            self.attributes_ = list(proto.attribute)
+        elif isinstance(proto, NodeProto):
+            self.onnx_graph_ = None
+            self.opsets_ = {
+                proto.domain: 1
+                if proto.domain != ""
+                else onnx.defs.onnx_opset_version()
+            }
+        else:
+            raise TypeError(f"Unexpected type {type(proto)} for proto.")
+        if self.onnx_graph_:
+            self.input_names_ = [i.name for i in self.onnx_graph_.input]
+            self.input_types_ = [i.type for i in self.onnx_graph_.input]
+            self.output_names_ = [o.name for o in self.onnx_graph_.output]
+            self.output_types_ = [i.type for i in self.onnx_graph_.output]
+            self.inits_ = list(self.onnx_graph_.initializer) + list(
+                self.onnx_graph_.sparse_initializer
+            )
+            self.nodes_ = self.onnx_graph_.node
+            all_types = {i.name: i.type for i in self.onnx_graph_.input}
+            if hasattr(self.proto_, "value_info"):
+                for shape_type in self.proto_.value_info:
+                    all_types[shape_type.name] = shape_type.type
+            self.all_types_ = all_types
+        else:
+            self.input_names_ = list(proto.input)
+            self.output_names_ = list(proto.output)
+            self.inits_ = []
+            if isinstance(proto, NodeProto):
+                self.nodes_ = [proto]  # type: ignore[assignment]
+            else:
+                self.nodes_ = proto.node
+        if functions is not None:
+            for f in functions:
+                if isinstance(f, FunctionProto):
+                    self.functions_[f.domain, f.name] = self.__class__(
+                        f, verbose=verbose, functions=list(self.functions_.values())
+                    )
+                elif isinstance(f, ReferenceEvaluator):
+                    onx = f.proto_
+                    self.functions_[onx.domain, onx.name] = f
+                else:
+                    raise TypeError(f"Unexpected type {type(f)!r} for a function.")
+        self.verbose = verbose
+        self.new_ops_: dict[tuple[str, str], type[op_run.OpRun]] = {}
+        if new_ops is not None:
+            for cl in new_ops:
+                if not hasattr(cl, "op_domain"):
+                    raise AttributeError(
+                        f"Class {cl} must define attribute 'op_domain'."
+                    )
+                if not issubclass(cl, op_run.OpRun):
+                    raise TypeError(f"Class {cl} must inherit from OpRun (in new_ops).")
+                key = cl.op_domain, cl.__name__
+                if key in self.new_ops_:
+                    # Already an implementation, the first one is used.
+                    continue
+                self.new_ops_[key] = cl
+        self._init()
+
+    def retrieve_external_data(self, initializer: TensorProto) -> np.ndarray:
+        """Returns a tensor saved as external."""
+        info = onnx.external_data_helper.ExternalDataInfo(initializer)
+        location = info.location
+        if self.container_ and self.container_.is_in_memory_external_initializer(
+            location
+        ):
+            # It comes from a large container.
+            return self.container_[location]
+        # Otherwise, the data is on disk.
+        if self.container_ is not None:
+            raise RuntimeError(
+                "ReferenceEvaluator assumes a LargeContainer was loaded with its external tensor."
+            )
+        raise RuntimeError(
+            "An instance of LargeContainer should be created before using ReferenceEvaluator."
+        )
+
+    def _log_arg(self, a: Any) -> Any:  # noqa: PLR0911
+        if isinstance(a, (str, int, float)):
+            return a
+        if isinstance(a, np.ndarray):
+            if self.verbose < 4:  # noqa: PLR2004
+                if a.size == 0:
+                    return f"{a.dtype}:{a.shape} (empty)"
+                return f"{a.dtype}:{a.shape} in [{a.min()}, {a.max()}]"
+            elements = a.ravel().tolist()
+            if len(elements) > 5:  # noqa: PLR2004
+                elements = elements[:5]
+                return f"{a.dtype}:{a.shape}:{','.join(map(str, elements))}..."
+            return f"{a.dtype}:{a.shape}:{elements}"
+        if hasattr(a, "append"):
+            return ", ".join(map(self._log_arg, a))
+        return a
+
+    def _log(self, level: int, pattern: str, *args: list[Any]) -> None:
+        if level < self.verbose:
+            new_args = [self._log_arg(a) for a in args]
+            print(pattern % tuple(new_args))  # noqa: T201
+
+    @property
+    def input_names(self):
+        """Returns the input names."""
+        return self.input_names_
+
+    @property
+    def input_types(self):
+        """Returns the input types if any specified."""
+        return self.input_types_
+
+    @property
+    def output_names(self):
+        """Returns the output names."""
+        return self.output_names_
+
+    @property
+    def output_types(self):
+        """Returns the output types."""
+        return self.output_types_
+
+    @property
+    def opsets(self):
+        """Returns the opsets."""
+        return self.opsets_
+
+    @property
+    def has_linked_attribute(self):
+        """Checks if the graph has a linked attribute (= an attribute whose value is defined
+        by a function attribute.
+        """
+        return any(node.has_linked_attribute for node in self.rt_nodes_)
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}({', '.join(self.input_names)}) -> {', '.join(self.output_names)}"
+
+    def get_result_types(self, name: str, exc: bool = True) -> Any:
+        if self.all_types_ is None:
+            raise RuntimeError(
+                f"Unable to return type for name {name!r}. Run shape_inference first."
+            )
+        if name not in self.all_types_:
+            if exc:
+                raise RuntimeError(
+                    f"Unable to return type for name {name!r}, it was not found in {sorted(self.all_types_)}."
+                )
+            return None
+        return self.all_types_[name]
+
+    def _init(self) -> None:
+        """Loads the implementation for every node in the graph."""
+        self.rt_inits_ = {}
+        self.rt_nodes_ = []
+        for init in self.inits_:
+            self.rt_inits_[init.name] = (
+                self.retrieve_external_data(init)
+                if onnx.external_data_helper.uses_external_data(init)
+                else onnx.numpy_helper.to_array(init)
+            )
+        run_params = {
+            "log": lambda pattern, *args: self._log(10, pattern, *args),
+            "opsets": self.opsets,
+            "verbose": self.verbose,
+            "new_ops": self.new_ops_,
+            "existing_functions": self.functions_.copy(),
+            "evaluator_cls": self.__class__,
+        }
+        if self.input_types_:
+            all_types = {i.name: i.type for i in self.onnx_graph_.input}
+            if hasattr(self.proto_, "value_info"):
+                for shape_type in self.proto_.value_info:
+                    all_types[shape_type.name] = shape_type.type
+            self.all_types_ = all_types
+        else:
+            self.all_types_ = None
+
+        for node in self.nodes_:
+            try:
+                cl = self._load_impl(node)
+            except op_run.RuntimeContextError as e:
+                # A node has a context dependent implementation.
+                # Shape inference must be run to get the input types.
+                if self.all_types_:
+                    it = [self.get_result_types(i, exc=False) for i in node.input]
+                    if None in it:
+                        # One input does not exist. It must be done while executing the graph.
+                        def cl(*args, parent=self):
+                            return op_run.OpFunctionContextDependant(
+                                *args, parent=parent
+                            )
+                    else:
+                        cl = self._load_impl(node, it)
+                else:
+                    raise op_run.RuntimeContextError(
+                        f"No implementation was found for node type {node.op_type!r} from domain {node.domain!r}. "
+                        f"If this node has a context dependent implementation, you should run function infer_shapes "
+                        f"before calling ReferenceEvaluator."
+                    ) from e
+            try:
+                inst = cl(node, run_params)
+            except TypeError as e:
+                raise TypeError(
+                    f"Unable to instantiate class {cl!r} with "
+                    f"run_params={run_params} and node={node}."
+                ) from e
+            self.rt_nodes_.append(inst)
+
+    def _load_impl(  # noqa: PLR0911
+        self, node: NodeProto, input_types: TypeProto | None = None
+    ) -> Any:
+        """Loads the implementation for a specified runtime."""
+        if node.domain not in self.opsets:
+            raise RuntimeError(
+                f"Domain {node.domain!r} (node type: {node.op_type!r}) "
+                f"is not specified. Known opsets: {self.opsets!r}."
+            )
+        version = self.opsets[node.domain]
+        key = node.domain, node.op_type
+        expand = False
+        if key in self.new_ops_:
+            # This operator has a custom implementation.
+            # This mechanism can be used to implement a custom onnx node
+            # or to overwrite an existing one.
+            cl = self.new_ops_[key]
+            if not issubclass(cl, op_run.OpRunExpand):
+                return cl
+            # It must be replaced by its implementation defined in its schema.
+            expand = True
+
+        if node.domain == "":
+            from onnx.reference.ops import load_op  # noqa: PLC0415
+
+            try:
+                return load_op(
+                    node.domain,
+                    node.op_type,
+                    version,
+                    expand=expand,
+                    evaluator_cls=self.__class__,
+                )
+            except op_run.RuntimeContextError:
+                if input_types is None:
+                    raise
+                return load_op(
+                    node.domain,
+                    node.op_type,
+                    version,
+                    node=node,
+                    input_types=input_types,
+                    expand=expand,
+                    evaluator_cls=self.__class__,
+                )
+
+        if expand:
+            raise NotImplementedError(
+                f"Expanding an operator with its function definition "
+                f"is only implemented for the main opset. Remove operator "
+                f"{node.domain},{node.op_type} from the list of inlined operator."
+            )
+        if node.domain == "ai.onnx.preview":
+            from onnx.reference.ops.aionnx_preview import (  # noqa: PLC0415
+                load_op as load_op_pt,
+            )
+
+            return load_op_pt(node.domain, node.op_type, version)
+
+        if node.domain == "ai.onnx.preview.training":
+            from onnx.reference.ops.aionnx_preview_training import (  # noqa: PLC0415
+                load_op as load_op_pt,
+            )
+
+            return load_op_pt(node.domain, node.op_type, version)
+
+        if node.domain == "experimental":
+            from onnx.reference.ops.experimental import (  # noqa: PLC0415
+                load_op as load_op_exp,
+            )
+
+            return load_op_exp(node.domain, node.op_type, version)
+
+        if node.domain == "ai.onnx.ml":
+            from onnx.reference.ops.aionnxml import (  # noqa: PLC0415
+                load_op as load_op_ml,
+            )
+
+            return load_op_ml(node.domain, node.op_type, version)
+
+        # It has to be a function.
+        if key in self.functions_:
+            from onnx.reference.ops import load_op  # noqa: PLC0415
+
+            impl = self.functions_[key]
+            return load_op(
+                node.domain,
+                node.op_type,
+                version,
+                custom=impl,
+                evaluator_cls=self.__class__,
+            )
+        raise NotImplementedError(
+            f"Node type {node.op_type!r} from domain {node.domain!r} "
+            f"is unknown, known functions: {sorted(self.functions_)}."
+        )
+
+    def run(
+        self,
+        output_names,
+        feed_inputs: dict[str, Any],
+        attributes: dict[str, Any] | None = None,
+        intermediate: bool = False,
+    ) -> dict[str, Any] | list[Any]:
+        """Executes the onnx model.
+
+        Args:
+            output_names: requested outputs by names, None for all
+            feed_inputs: dictionary `{ input name: input value }`
+            attributes: attributes value if the instance runs a
+                FunctionProto
+            intermediate: if True, the function returns all the results,
+                final ones and intermediates one in a same dictionary,
+                if False, only the final results are returned in a list
+
+        Returns:
+            list of requested outputs if intermediate is False,
+            named results in a dictionary otherwise
+        """
+        if output_names is None:
+            output_names = self.output_names
+        if isinstance(self.proto_, FunctionProto) and attributes is None:
+            raise TypeError
+
+        # step 1: inputs and initializers
+        results = {"": None}  # optional input
+        results.update(self.rt_inits_)  # type: ignore[arg-type]
+        results.update(feed_inputs)
+        for k, v in self.rt_inits_.items():
+            self._log(2, " +C %s: %s", k, v)  # type: ignore[arg-type]
+        for k, v in feed_inputs.items():
+            self._log(2, " +I %s: %s", k, v)  # type: ignore[arg-type]
+
+        # step 2: execute nodes
+        for node in self.rt_nodes_:
+            self._log(1, "%s(%s) -> %s", node.op_type, node.input, node.output)
+            for i in node.input:
+                if i not in results:
+                    raise RuntimeError(
+                        f"Unable to find input {i!r} in known results {sorted(results)}, "
+                        f"self.rt_inits_ has {sorted(self.rt_inits_)}, "
+                        f"feed_inputs has {sorted(feed_inputs)}."
+                    )
+            inputs = [results[i] for i in node.input]
+            linked_attributes = {}
+            if node.has_linked_attribute and attributes:
+                linked_attributes["linked_attributes"] = attributes
+            if node.need_context():
+                outputs = node.run(*inputs, context=results, **linked_attributes)
+            else:
+                outputs = node.run(*inputs, **linked_attributes)
+            for name, value in zip(node.output, outputs, strict=False):
+                self._log(2, " + %s: %s", name, value)  # type: ignore[arg-type]
+                results[name] = value
+
+        # return the results
+        if intermediate:
+            return results
+
+        for name in output_names:
+            if name not in results:
+                raise RuntimeError(
+                    f"Unable to find output name {name!r} in {sorted(results)}, proto is\n{self.proto_}"
+                )
+        return [results[name] for name in output_names]
diff --git a/onnx/serialization.py b/onnx/serialization.py
new file mode 100644
index 0000000..a3b64f6
--- /dev/null
+++ b/onnx/serialization.py
@@ -0,0 +1,212 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import warnings
+
+__all__ = [
+    "registry",
+]
+
+import typing
+from typing import Any, Protocol, TypeVar
+
+import google.protobuf.json_format
+import google.protobuf.message
+import google.protobuf.text_format
+
+import onnx
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Collection
+
+_Proto = TypeVar("_Proto", bound=google.protobuf.message.Message)
+# Encoding used for serializing and deserializing text files
+_ENCODING = "utf-8"
+
+
+class ProtoSerializer(Protocol):
+    """A serializer-deserializer to and from in-memory Protocol Buffers representations."""
+
+    # Format supported by the serializer. E.g. "protobuf"
+    supported_format: str
+    # File extensions supported by the serializer. E.g. frozenset({".onnx", ".pb"})
+    # Be careful to include the dot in the file extension.
+    file_extensions: Collection[str]
+
+    # NOTE: The methods defined are serialize_proto and deserialize_proto and not the
+    # more generic serialize and deserialize to leave space for future protocols
+    # that are defined to serialize/deserialize the ONNX in memory IR.
+    # This way a class can implement both protocols.
+
+    def serialize_proto(self, proto: _Proto) -> Any:
+        """Serialize a in-memory proto to a serialized data type."""
+
+    def deserialize_proto(self, serialized: Any, proto: _Proto) -> _Proto:
+        """Parse a serialized data type into a in-memory proto."""
+
+
+class _Registry:
+    def __init__(self) -> None:
+        self._serializers: dict[str, ProtoSerializer] = {}
+        # A mapping from file extension to format
+        self._extension_to_format: dict[str, str] = {}
+
+    def register(self, serializer: ProtoSerializer) -> None:
+        self._serializers[serializer.supported_format] = serializer
+        self._extension_to_format.update(
+            dict.fromkeys(serializer.file_extensions, serializer.supported_format)
+        )
+
+    def get(self, fmt: str) -> ProtoSerializer:
+        """Get a serializer for a format.
+
+        Args:
+            fmt: The format to get a serializer for.
+
+        Returns:
+            ProtoSerializer: The serializer for the format.
+
+        Raises:
+            ValueError: If the format is not supported.
+        """
+        try:
+            return self._serializers[fmt]
+        except KeyError:
+            raise ValueError(
+                f"Unsupported format: '{fmt}'. Supported formats are: {self._serializers.keys()}"
+            ) from None
+
+    def get_format_from_file_extension(self, file_extension: str) -> str | None:
+        """Get the corresponding format from a file extension.
+
+        Args:
+            file_extension: The file extension to get a format for.
+
+        Returns:
+            The format for the file extension, or None if not found.
+        """
+        return self._extension_to_format.get(file_extension)
+
+
+class _ProtobufSerializer(ProtoSerializer):
+    """Serialize and deserialize protobuf message."""
+
+    supported_format = "protobuf"
+    file_extensions = frozenset({".onnx", ".pb"})
+
+    def serialize_proto(self, proto: _Proto) -> bytes:
+        if hasattr(proto, "SerializeToString") and callable(proto.SerializeToString):
+            try:
+                result = proto.SerializeToString()
+            except ValueError as e:
+                if proto.ByteSize() > onnx.checker.MAXIMUM_PROTOBUF:
+                    raise ValueError(
+                        "The proto size is larger than the 2 GB limit. "
+                        "Please use save_as_external_data to save tensors separately from the model file."
+                    ) from e
+                raise
+            return result
+        raise TypeError(
+            f"No SerializeToString method is detected.\ntype is {type(proto)}"
+        )
+
+    def deserialize_proto(self, serialized: bytes, proto: _Proto) -> _Proto:
+        if not isinstance(serialized, bytes):
+            raise TypeError(
+                f"Parameter 'serialized' must be bytes, but got type: {type(serialized)}"
+            )
+        decoded = typing.cast("int | None", proto.ParseFromString(serialized))
+        if decoded is not None and decoded != len(serialized):
+            raise google.protobuf.message.DecodeError(
+                f"Protobuf decoding consumed too few bytes: {decoded} out of {len(serialized)}"
+            )
+        return proto
+
+
+class _TextProtoSerializer(ProtoSerializer):
+    """Serialize and deserialize text proto."""
+
+    supported_format = "textproto"
+    file_extensions = frozenset({".txtpb", ".textproto", ".prototxt", ".pbtxt"})
+
+    def serialize_proto(self, proto: _Proto) -> bytes:
+        textproto = google.protobuf.text_format.MessageToString(proto)
+        return textproto.encode(_ENCODING)
+
+    def deserialize_proto(self, serialized: bytes | str, proto: _Proto) -> _Proto:
+        if not isinstance(serialized, (bytes, str)):
+            raise TypeError(
+                f"Parameter 'serialized' must be bytes or str, but got type: {type(serialized)}"
+            )
+        if isinstance(serialized, bytes):
+            serialized = serialized.decode(_ENCODING)
+        assert isinstance(serialized, str)
+        return google.protobuf.text_format.Parse(serialized, proto)
+
+
+class _JsonSerializer(ProtoSerializer):
+    """Serialize and deserialize JSON."""
+
+    supported_format = "json"
+    file_extensions = frozenset({".json", ".onnxjson"})
+
+    def serialize_proto(self, proto: _Proto) -> bytes:
+        json_message = google.protobuf.json_format.MessageToJson(
+            proto, preserving_proto_field_name=True
+        )
+        return json_message.encode(_ENCODING)
+
+    def deserialize_proto(self, serialized: bytes | str, proto: _Proto) -> _Proto:
+        if not isinstance(serialized, (bytes, str)):
+            raise TypeError(
+                f"Parameter 'serialized' must be bytes or str, but got type: {type(serialized)}"
+            )
+        if isinstance(serialized, bytes):
+            serialized = serialized.decode(_ENCODING)
+        assert isinstance(serialized, str)
+        return google.protobuf.json_format.Parse(serialized, proto)
+
+
+class _TextualSerializer(ProtoSerializer):
+    """Serialize and deserialize the ONNX textual representation."""
+
+    supported_format = "onnxtxt"
+    file_extensions = frozenset({".onnxtxt", ".onnxtext"})
+
+    def serialize_proto(self, proto: _Proto) -> bytes:
+        text = onnx.printer.to_text(proto)  # type: ignore[arg-type]
+        return text.encode(_ENCODING)
+
+    def deserialize_proto(self, serialized: bytes | str, proto: _Proto) -> _Proto:
+        warnings.warn(
+            "The onnxtxt format is experimental. Please report any errors to the ONNX GitHub repository.",
+            stacklevel=2,
+        )
+        if not isinstance(serialized, (bytes, str)):
+            raise TypeError(
+                f"Parameter 'serialized' must be bytes or str, but got type: {type(serialized)}"
+            )
+        if isinstance(serialized, bytes):
+            text = serialized.decode(_ENCODING)
+        else:
+            text = serialized
+        if isinstance(proto, onnx.ModelProto):
+            return onnx.parser.parse_model(text)  # type: ignore[return-value]
+        if isinstance(proto, onnx.GraphProto):
+            return onnx.parser.parse_graph(text)  # type: ignore[return-value]
+        if isinstance(proto, onnx.FunctionProto):
+            return onnx.parser.parse_function(text)  # type: ignore[return-value]
+        if isinstance(proto, onnx.NodeProto):
+            return onnx.parser.parse_node(text)  # type: ignore[return-value]
+        raise ValueError(f"Unsupported proto type: {type(proto)}")
+
+
+# Register default serializers
+registry = _Registry()
+registry.register(_ProtobufSerializer())
+registry.register(_TextProtoSerializer())
+registry.register(_JsonSerializer())
+registry.register(_TextualSerializer())
diff --git a/onnx/shape_inference.py b/onnx/shape_inference.py
new file mode 100644
index 0000000..bb83299
--- /dev/null
+++ b/onnx/shape_inference.py
@@ -0,0 +1,181 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""onnx shape inference. Shape inference is not guaranteed to be
+complete.
+
+"""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+import onnx
+import onnx.onnx_cpp2py_export.shape_inference as C  # noqa: N812
+from onnx.onnx_pb import (
+    IR_VERSION,
+    AttributeProto,
+    FunctionProto,
+    ModelProto,
+    TypeProto,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+GraphInferencer = C.GraphInferencer
+InferenceContext = C.InferenceContext
+
+
+def infer_shapes(
+    model: ModelProto | bytes,
+    check_type: bool = False,
+    strict_mode: bool = False,
+    data_prop: bool = False,
+) -> ModelProto:
+    """Apply shape inference to the provided ModelProto.
+
+    Inferred shapes are added to the value_info field of the graph.
+
+    If the inferred values conflict with values already provided in the
+    graph, that means that the provided values are invalid (or there is a
+    bug in shape inference), and the result is unspecified.
+
+    Arguments:
+        model: ModelProto.
+        check_type: Checks the type-equality for input and output.
+        strict_mode: Stricter shape inference, it will throw errors if any;
+            Otherwise, simply stop if any error.
+        data_prop: Enables data propagation for limited operators to perform shape computation.
+
+    Returns:
+        (ModelProto) model with inferred shape information
+    """
+    if isinstance(model, (ModelProto, bytes)):
+        model_str = model if isinstance(model, bytes) else model.SerializeToString()
+        inferred_model_str = C.infer_shapes(
+            model_str, check_type, strict_mode, data_prop
+        )
+        return onnx.load_from_string(inferred_model_str)
+    if isinstance(model, (str, os.PathLike)):
+        raise TypeError(
+            "infer_shapes only accepts ModelProto or bytes,"
+            " For Model paths (str or os.PathLike), use infer_shapes_path()."
+        )
+
+    raise TypeError(
+        f"infer_shapes only accepts ModelProto or bytes, incorrect type: {type(model)}"
+    )
+
+
+def infer_shapes_path(
+    model_path: str | os.PathLike,
+    output_path: str | os.PathLike = "",
+    check_type: bool = False,
+    strict_mode: bool = False,
+    data_prop: bool = False,
+) -> None:
+    """Take model path for shape_inference.
+
+    This function is the same as :func:`infer_shape` but supports >2GB models.
+    The function outputs the inferred model to the `output_path`. The original model path
+    is used if not specified.
+    """
+    if isinstance(model_path, ModelProto):
+        raise TypeError(
+            "infer_shapes_path only accepts model Path (String),"
+            "you can use infer_shapes for the ModelProto."
+        )
+    try:
+        model_path = os.fspath(model_path)
+    except TypeError as exp:
+        raise TypeError(
+            "infer_shapes_path only accepts model path as a string or PathLike, "
+            f"incorrect model path type: {type(model_path)}"
+        ) from exp
+    try:
+        output_path = os.fspath(output_path)
+    except TypeError as exp:
+        raise TypeError(
+            "infer_shapes_path only accepts output path as a string or PathLike, "
+            f"incorrect output path type: {type(output_path)}"
+        ) from exp
+
+    if output_path == "":
+        output_path = model_path
+    C.infer_shapes_path(model_path, output_path, check_type, strict_mode, data_prop)
+
+
+def infer_node_outputs(
+    schema: onnx.defs.OpSchema,
+    node: onnx.NodeProto,
+    input_types: dict[str, onnx.TypeProto],
+    input_data: dict[str, onnx.TensorProto] | None = None,
+    input_sparse_data: dict[str, onnx.SparseTensorProto] | None = None,
+    opset_imports: list[onnx.OperatorSetIdProto] | None = None,
+    ir_version: int = IR_VERSION,
+) -> dict[str, onnx.TypeProto]:
+    if input_data is None:
+        input_data = {}
+    if input_sparse_data is None:
+        input_sparse_data = {}
+    if opset_imports is None:
+        passed_opset_imports = {}
+    else:
+        passed_opset_imports = {opset.domain: opset.version for opset in opset_imports}
+
+    # catch KeyError if node's input does not exist in input_types
+    passed_input_types = {
+        key: input_types[key].SerializeToString() for key in node.input if key != ""
+    }
+    # input_types will also be used as outer_scope_value_types so do not filter by node's input here
+    for key, value in input_types.items():
+        if key not in passed_input_types:
+            passed_input_types[key] = value.SerializeToString()
+    passed_input_data = {
+        key: input_data[key].SerializeToString()
+        for key in node.input
+        if key in input_data
+    }
+    passed_sparse_input_data = {
+        key: input_sparse_data[key].SerializeToString()
+        for key in node.input
+        if key in input_sparse_data
+    }
+
+    outputs = schema._infer_node_outputs(
+        node.SerializeToString(),
+        passed_input_types,
+        passed_input_data,
+        passed_sparse_input_data,
+        passed_opset_imports,
+        ir_version,
+    )  # type: ignore[call-arg]
+    return {key: onnx.TypeProto.FromString(out) for key, out in outputs.items()}
+
+
+def infer_function_output_types(
+    function: FunctionProto,
+    input_types: Sequence[TypeProto],
+    attributes: Sequence[AttributeProto],
+) -> list[TypeProto]:
+    """Apply type-and-shape-inference to given function body, with given input types
+    and given input attribute values.
+    """
+    result = C.infer_function_output_types(
+        function.SerializeToString(),
+        [x.SerializeToString() for x in input_types],
+        [x.SerializeToString() for x in attributes],
+    )
+
+    def to_type_proto(x) -> TypeProto:
+        type_proto = onnx.TypeProto()
+        type_proto.ParseFromString(x)
+        return type_proto
+
+    return [to_type_proto(x) for x in result]
+
+
+InferenceError = C.InferenceError
diff --git a/onnx/shape_inference/CMakeLists.txt b/onnx/shape_inference/CMakeLists.txt
new file mode 100644
index 0000000..8938c98
--- /dev/null
+++ b/onnx/shape_inference/CMakeLists.txt
@@ -0,0 +1,8 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    attribute_binder.h
+    implementation.cc
+    implementation.h
+)
diff --git a/onnx/shape_inference/attribute_binder.h b/onnx/shape_inference/attribute_binder.h
new file mode 100644
index 0000000..0da2790
--- /dev/null
+++ b/onnx/shape_inference/attribute_binder.h
@@ -0,0 +1,69 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+#include "onnx/common/visitor.h"
+
+namespace ONNX_NAMESPACE {
+namespace internal { // internal/private API
+
+using AttributeMap = std::unordered_map<std::string, const AttributeProto*>;
+
+// Class for binding formal attribute-parameters (in a node or graph) to their values.
+
+class AttributeBinder : public MutableVisitor {
+ public:
+  explicit AttributeBinder(const AttributeMap& attr_map) : attr_map_(attr_map) {}
+
+  // Binding a formal attribute-parameter to a value may, as a special case, also
+  // remove the attribute from the list of attributes of a node (when the attribute
+  // has no specified value). Hence, we need to do the processing at a Node level
+  // rather than an attribute level.
+  void VisitNode(NodeProto& node) override {
+    auto& attributes = *node.mutable_attribute();
+    for (auto attr_iter = attributes.begin(); attr_iter != attributes.end();) {
+      auto& attr = *attr_iter;
+      if (!attr.ref_attr_name().empty()) {
+        // Attribute-references must be replaced by the corresponding attribute-value in the call-node
+        // if the call-node contains the attribute. Otherwise, this attribute must be removed.
+        auto it = attr_map_.find(attr.ref_attr_name());
+        if (it != attr_map_.end()) {
+          const AttributeProto* replacement = it->second;
+          // Copy value of attribute, but retain original name:
+          std::string name = attr.name();
+          attr = *replacement;
+          attr.set_name(name);
+          ++attr_iter;
+        } else {
+          attr_iter = attributes.erase(attr_iter);
+        }
+      } else {
+        // For regular attributes, we process subgraphs, if present, recursively.
+        VisitAttribute(attr);
+        ++attr_iter;
+      }
+    }
+  }
+
+  // Updates a FunctionProto by replacing all attribute-references with the corresponding
+  // attribute-values in the call-node, if present. Otherwise, the attribute is removed.
+  static void BindAttributes(const NodeProto& callnode, FunctionProto& callee) {
+    AttributeMap map;
+    for (const auto& attr : callnode.attribute()) {
+      map[attr.name()] = &attr;
+    }
+    AttributeBinder attr_binder(map);
+    attr_binder.VisitFunction(callee);
+  }
+
+ private:
+  const AttributeMap& attr_map_;
+};
+
+} // namespace internal
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/shape_inference/implementation.cc b/onnx/shape_inference/implementation.cc
new file mode 100644
index 0000000..3175617
--- /dev/null
+++ b/onnx/shape_inference/implementation.cc
@@ -0,0 +1,1169 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/shape_inference/implementation.h"
+
+#include <algorithm>
+#include <fstream>
+#include <list>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "onnx/checker.h"
+#include "onnx/common/common.h"
+#include "onnx/common/file_utils.h"
+#include "onnx/common/proto_util.h"
+#include "onnx/common/scoped_resource.h"
+#include "onnx/defs/data_type_utils.h"
+#include "onnx/shape_inference/attribute_binder.h"
+
+namespace ONNX_NAMESPACE {
+namespace shape_inference {
+namespace {
+
+std::string GetValueCaseString(const TypeProto& type) {
+  switch (type.value_case()) {
+    case TypeProto::ValueCase::kTensorType:
+      return "tensor_type";
+    case TypeProto::ValueCase::kSequenceType:
+      return "sequence_type";
+    case TypeProto::ValueCase::kMapType:
+      return "map_type";
+    case TypeProto::ValueCase::kOptionalType:
+      return "optional_type";
+#ifdef ONNX_ML
+    case TypeProto::ValueCase::kOpaqueType:
+      return "opaque_type";
+#endif
+    case TypeProto::ValueCase::kSparseTensorType:
+      return "sparse_tensor_type";
+    case TypeProto::ValueCase::VALUE_NOT_SET:
+      return "NOT_SET";
+  }
+  return ONNX_NAMESPACE::to_string(type.value_case());
+}
+
+std::string GetElemTypeString(const TypeProto_Tensor& type) {
+#ifndef ONNX_USE_LITE_PROTO
+  std::string type_str = TensorProto::DataType_Name(static_cast<TensorProto_DataType>(type.elem_type()));
+  if (!type_str.empty()) {
+    return type_str;
+  }
+#endif
+  return ONNX_NAMESPACE::to_string(type.elem_type());
+}
+
+std::string GetElemTypeString(const TypeProto_SparseTensor& type) {
+#ifndef ONNX_USE_LITE_PROTO
+  std::string type_str = TensorProto::DataType_Name(static_cast<TensorProto_DataType>(type.elem_type()));
+  if (!type_str.empty()) {
+    return type_str;
+  }
+#endif
+  return ONNX_NAMESPACE::to_string(type.elem_type());
+}
+
+inline bool IsOnnxDomainOp(const NodeProto& node, const std::string& op_type) {
+  return (IsOnnxDomain(node.domain()) && (node.op_type() == op_type));
+}
+
+} // namespace
+
+template <class T>
+static void CheckTensorShapesAndTypes(const T& inferred_type, const T& existing_type) {
+  if (inferred_type.elem_type() != TensorProto::UNDEFINED && existing_type.elem_type() != TensorProto::UNDEFINED &&
+      existing_type.elem_type() != inferred_type.elem_type()) {
+    std::stringstream ss;
+    ss << "Inferred elem type differs from existing elem type: (" << GetElemTypeString(inferred_type) << ") vs ("
+       << GetElemTypeString(existing_type) << ")";
+    fail_type_inference(ss.str());
+  }
+
+  if (!inferred_type.has_shape() || !existing_type.has_shape()) {
+    return;
+  }
+
+  if (inferred_type.shape().dim_size() != existing_type.shape().dim_size()) {
+    std::stringstream ss;
+    ss << "Inferred shape and existing shape differ in rank: (" << inferred_type.shape().dim_size() << ") vs ("
+       << existing_type.shape().dim_size() << ")";
+    fail_shape_inference(ss.str());
+  }
+
+  for (int i = 0; i < inferred_type.shape().dim_size(); ++i) {
+    const auto& inferred_dim = inferred_type.shape().dim(i);
+    const auto& existing_dim = existing_type.shape().dim(i);
+    if (inferred_dim.has_dim_value() && existing_dim.has_dim_value() &&
+        inferred_dim.dim_value() != existing_dim.dim_value()) {
+      std::stringstream ss;
+      ss << "Inferred shape and existing shape differ in dimension " << i << ": (" << inferred_dim.dim_value()
+         << ") vs (" << existing_dim.dim_value() << ")";
+      fail_shape_inference(ss.str());
+    }
+  }
+}
+
+void checkShapesAndTypes(const TypeProto& inferred_type, const TypeProto& existing_type) {
+  const auto inferred_value_case = inferred_type.value_case();
+  const auto existing_value_case = existing_type.value_case();
+  if (inferred_value_case == TypeProto::ValueCase::VALUE_NOT_SET ||
+      existing_value_case == TypeProto::ValueCase::VALUE_NOT_SET) {
+    // nothing to check; will assign inferredType to undefined existingType
+    return;
+  }
+  if (inferred_value_case != existing_value_case) {
+    fail_type_inference(
+        "type case mismatch. existing=",
+        GetValueCaseString(existing_type),
+        " inferred=",
+        GetValueCaseString(inferred_type));
+  }
+
+  if (inferred_value_case == TypeProto::kTensorType && existing_value_case == TypeProto::kTensorType) {
+    CheckTensorShapesAndTypes(inferred_type.tensor_type(), existing_type.tensor_type());
+  } else if (
+      inferred_value_case == TypeProto::kSparseTensorType && existing_value_case == TypeProto::kSparseTensorType) {
+    CheckTensorShapesAndTypes(inferred_type.sparse_tensor_type(), existing_type.sparse_tensor_type());
+  } else if (inferred_value_case == TypeProto::kSequenceType && existing_value_case == TypeProto::kSequenceType) {
+    checkShapesAndTypes(inferred_type.sequence_type().elem_type(), existing_type.sequence_type().elem_type());
+  } else if (inferred_value_case == TypeProto::kOptionalType && existing_value_case == TypeProto::kOptionalType) {
+    checkShapesAndTypes(inferred_type.optional_type().elem_type(), existing_type.optional_type().elem_type());
+  } else if (
+      inferred_value_case == TypeProto::TypeProto::kMapType && existing_value_case == TypeProto::TypeProto::kMapType) {
+    if (inferred_type.map_type().key_type() != existing_type.map_type().key_type()) {
+      fail_type_inference(
+          "key type mismatch from MapProto. existing=",
+          Utils::DataTypeUtils::ToDataTypeString(existing_type.map_type().key_type()),
+          " inferred=",
+          Utils::DataTypeUtils::ToDataTypeString(inferred_type.map_type().key_type()));
+    }
+    checkShapesAndTypes(inferred_type.map_type().value_type(), existing_type.map_type().value_type());
+  } else {
+    fail_type_inference("type case unsupported. existing=", existing_value_case, " inferred=", inferred_value_case);
+  }
+}
+
+void mergeShapesAndTypes(const TypeProto_Tensor& inferred_type, TypeProto_Tensor* existing_type) {
+  if (existing_type->elem_type() == TensorProto::UNDEFINED) {
+    existing_type->set_elem_type(inferred_type.elem_type());
+  }
+
+  if (!inferred_type.has_shape()) {
+    return;
+  }
+
+  if (!existing_type->has_shape()) {
+    *existing_type->mutable_shape() = inferred_type.shape();
+    return;
+  }
+
+  for (int i = 0; i < inferred_type.shape().dim_size(); ++i) {
+    const auto& inferred_dim = inferred_type.shape().dim(i);
+    auto* existing_dim = existing_type->mutable_shape()->mutable_dim(i);
+    if ((!existing_dim->has_dim_value() && !existing_dim->has_dim_param()) || inferred_dim.has_dim_value()) {
+      *existing_dim = inferred_dim;
+    }
+  }
+}
+
+void mergeShapesAndTypes(const TypeProto_SparseTensor& inferred_type, TypeProto_SparseTensor* existing_type) {
+  if (existing_type->elem_type() == TensorProto::UNDEFINED) {
+    existing_type->set_elem_type(inferred_type.elem_type());
+  }
+
+  if (!inferred_type.has_shape()) {
+    return;
+  }
+
+  if (!existing_type->has_shape()) {
+    *existing_type->mutable_shape() = inferred_type.shape();
+    return;
+  }
+
+  for (int i = 0; i < inferred_type.shape().dim_size(); ++i) {
+    const auto& inferred_dim = inferred_type.shape().dim(i);
+    auto* existing_dim = existing_type->mutable_shape()->mutable_dim(i);
+    if ((!existing_dim->has_dim_value() && !existing_dim->has_dim_param()) || inferred_dim.has_dim_value()) {
+      *existing_dim = inferred_dim;
+    }
+  }
+}
+
+void mergeShapesAndTypes(const TypeProto& inferred_type, TypeProto* existing_type) {
+  // Check before merge
+  checkShapesAndTypes(inferred_type, *existing_type);
+  const auto inferred_val_case = inferred_type.value_case();
+  if (inferred_val_case == TypeProto::kTensorType) {
+    mergeShapesAndTypes(inferred_type.tensor_type(), existing_type->mutable_tensor_type());
+  } else if (inferred_val_case == TypeProto::kSparseTensorType) {
+    mergeShapesAndTypes(inferred_type.sparse_tensor_type(), existing_type->mutable_sparse_tensor_type());
+  } else if (inferred_val_case == TypeProto::kSequenceType) {
+    mergeShapesAndTypes(
+        inferred_type.sequence_type().elem_type(), existing_type->mutable_sequence_type()->mutable_elem_type());
+  } else if (inferred_val_case == TypeProto::kOptionalType) {
+    mergeShapesAndTypes(
+        inferred_type.optional_type().elem_type(), existing_type->mutable_optional_type()->mutable_elem_type());
+  } else if (inferred_val_case == TypeProto::kMapType) {
+    if (existing_type->map_type().key_type() == TensorProto::UNDEFINED) {
+      existing_type->mutable_map_type()->set_key_type(inferred_type.map_type().key_type());
+    }
+    mergeShapesAndTypes(inferred_type.map_type().value_type(), existing_type->mutable_map_type()->mutable_value_type());
+  }
+}
+
+// TypeProto_Tensor or TypeProto_SparseTensor
+template <typename TensorTypeProto>
+static void GenerateSymbolicShape(TensorTypeProto* inferred_type, SymbolTable& symbol_table) {
+  if (!inferred_type->has_shape()) {
+    return;
+  }
+  for (int i = 0; i < inferred_type->shape().dim_size(); ++i) {
+    // set a symbol if it doesn't have dim_value and dim_param
+    auto dim = inferred_type->mutable_shape()->mutable_dim(i);
+    if (!dim->has_dim_value() && !dim->has_dim_param()) {
+      dim->set_dim_param(symbol_table.createNew());
+    }
+  }
+}
+
+void MaterializeSymbolicShape(TypeProto* inferred_type, SymbolTable& symbol_table) {
+  const auto inferred_val_case = inferred_type->value_case();
+  if (inferred_val_case == TypeProto::ValueCase::VALUE_NOT_SET) {
+    return;
+  }
+
+  if (inferred_val_case == TypeProto::kTensorType) {
+    GenerateSymbolicShape(inferred_type->mutable_tensor_type(), symbol_table);
+  } else if (inferred_val_case == TypeProto::kSparseTensorType) {
+    GenerateSymbolicShape(inferred_type->mutable_sparse_tensor_type(), symbol_table);
+  } else if (inferred_val_case == TypeProto::kSequenceType) {
+    MaterializeSymbolicShape(inferred_type->mutable_sequence_type()->mutable_elem_type(), symbol_table);
+  } else if (inferred_val_case == TypeProto::kOptionalType) {
+    MaterializeSymbolicShape(inferred_type->mutable_optional_type()->mutable_elem_type(), symbol_table);
+  } else if (inferred_val_case == TypeProto::kMapType) {
+    MaterializeSymbolicShape(inferred_type->mutable_map_type()->mutable_value_type(), symbol_table);
+  } else {
+    fail_shape_inference("type case unsupported for symbolic shape inference. inferred=", inferred_val_case);
+  }
+}
+
+static std::string GetFunctionIdentifier(const FunctionProto& function) {
+  // Note: Models with IR version < 10 do not have the overload attribute.
+  // However, that will be mapped to an empty identifier.
+  const std::string& overload = function.overload();
+  if (overload.empty()) {
+    return function.domain() + ":" + function.name();
+  }
+  return function.domain() + ":" + function.name() + ":" + overload;
+}
+
+static std::string GetFunctionIdentifier(const NodeProto& node) {
+  // Note: Models with IR version < 10 do not have the overload attribute.
+  // However, that will be mapped to an empty identifier.
+  const std::string& overload = node.overload();
+  if (overload.empty()) {
+    return node.domain() + ":" + node.op_type();
+  }
+  return node.domain() + ":" + node.op_type() + ":" + overload;
+}
+
+namespace {
+// Either ModelProto or FunctionProto
+template <class T>
+std::unordered_map<std::string, int> GetOpsetImportsFromProto(const T& proto) {
+  std::unordered_map<std::string, int> opset_imports;
+  for (const auto& opset_import : proto.opset_import()) {
+    opset_imports[opset_import.domain()] = static_cast<int>(opset_import.version());
+  }
+  return opset_imports;
+}
+
+// InferredTypes: abstracts the differences between FunctionProto and GraphProto
+// for inference. For GraphProto, inferred types are stored in the GraphProto
+// but FunctionProto does not have a place to store inferred types. So, we
+// use a temporary vector (for the duration of inference) to store these.
+class InferredTypes {
+ public:
+  explicit InferredTypes(GraphProto* graph = nullptr) : graph_ptr(graph) {}
+
+  TypeProto* Add(const std::string& var_name, const TypeProto& type) {
+    if (graph_ptr != nullptr) {
+      auto* p = graph_ptr->add_value_info();
+      p->set_name(var_name);
+      *p->mutable_type() = type;
+      return p->mutable_type();
+    } else {
+      types.emplace_back(std::make_unique<TypeProto>(type));
+      return types.back().get();
+    }
+  }
+
+  ~InferredTypes() = default;
+
+ private:
+  std::vector<std::unique_ptr<TypeProto>> types;
+  GraphProto* graph_ptr;
+  ONNX_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(InferredTypes);
+};
+
+// Initialize a DataValueMap for a called function from the DataValueMap of the caller
+void BindValuesOnCall(
+    const DataValueMap& caller_map,
+    const NodeProto& caller,
+    DataValueMap& callee_map,
+    const FunctionProto& callee) {
+  auto num_inputs = std::min(caller.input_size(), callee.input_size());
+  for (int i = 0; i < num_inputs; ++i) {
+    const std::string& actual = caller.input(i);
+    const std::string& formal = callee.input(i);
+    if (!actual.empty()) {
+      auto it = caller_map.find(actual);
+      if (it != caller_map.end()) {
+        callee_map[formal] = it->second;
+      }
+    }
+  }
+}
+
+// Update a DataValueMap for a calling function from the DataValueMap of the callee
+void BindValuesOnReturn(
+    const DataValueMap& callee_map,
+    const FunctionProto& callee,
+    DataValueMap& caller_map,
+    const NodeProto& caller) {
+  auto num_outputs = std::min(caller.output_size(), callee.output_size());
+  for (int i = 0; i < num_outputs; ++i) {
+    const std::string& actual = caller.output(i);
+    const std::string& formal = callee.output(i);
+    if (!actual.empty()) {
+      auto it = callee_map.find(formal);
+      if (it != callee_map.end()) {
+        caller_map[actual] = it->second;
+      }
+    }
+  }
+}
+
+class ShapeInferenceImplBase {
+ public:
+  void UpdateType(const std::string& name, TypeProto* inferred_type) {
+    if (inferred_type->value_case() == TypeProto::ValueCase::VALUE_NOT_SET) {
+      return;
+    }
+
+    if (symbol_table) {
+      MaterializeSymbolicShape(inferred_type, *symbol_table);
+    }
+
+    // Find any pre-existing type and shape info. If there is such,
+    // then check for compatibility with the inferred
+    // information. Otherwise, initialize it in an empty state.
+    auto iter = value_types_by_name.find(name);
+    if (iter != value_types_by_name.end()) {
+      mergeShapesAndTypes(*inferred_type, iter->second);
+    } else {
+      value_types_by_name[name] = inferred_types.Add(name, *inferred_type);
+      // For undefined output type, update both value_info and output for now
+      // Update existing output with undefined type: assign inferred type to it
+      iter = undefined_value_types_by_name.find(name);
+      if (iter != undefined_value_types_by_name.end()) {
+        *iter->second = *inferred_type;
+      }
+    }
+  }
+
+  void UpdateType(ValueInfoProto& valueInfo) {
+    if (valueInfo.has_type()) {
+      value_types_by_name[valueInfo.name()] = valueInfo.mutable_type();
+    } else {
+      undefined_value_types_by_name[valueInfo.name()] = valueInfo.mutable_type();
+    }
+  }
+
+  template <typename T>
+  void AddTemporaryConstant(const std::string& name, const T& vector, bool scalar = false) {
+    auto tensor = ToTensor(vector);
+    if (!scalar) {
+      tensor.add_dims(vector.size());
+    }
+    input_data_by_name_holder[name] = tensor;
+    input_data_by_name[name] = &input_data_by_name_holder[name];
+  }
+
+  void ProcessConstant(const NodeProto& n) {
+    if (IsOnnxDomainOp(n, "Constant") && n.output().size() == 1) {
+      const std::string& output_name = n.output(0);
+      for (const auto& attr : n.attribute()) {
+        if (attr.name() == "value") {
+          if (attr.type() == AttributeProto::TENSOR && attr.has_t()) {
+            if (reuse_constant_tensors) {
+              input_data_by_name[output_name] = &attr.t();
+            } else {
+              input_data_by_name_holder[output_name] = attr.t();
+              input_data_by_name[output_name] = &input_data_by_name_holder[output_name];
+            }
+          } else if (attr.type() == AttributeProto::SPARSE_TENSOR && attr.has_sparse_tensor()) {
+            if (reuse_constant_tensors) {
+              input_sparse_data_by_name[output_name] = &attr.sparse_tensor();
+            }
+          }
+        } else {
+          switch (attr.type()) {
+            case AttributeProto::INTS: {
+              std::vector<int64_t> ints{attr.ints().begin(), attr.ints().end()};
+              AddTemporaryConstant(output_name, ints);
+              break;
+            }
+            case AttributeProto::INT: {
+              std::vector<int64_t> ints({attr.i()});
+              AddTemporaryConstant(output_name, ints, true);
+              break;
+            }
+            case AttributeProto::FLOATS: {
+              std::vector<float> floats{attr.floats().begin(), attr.floats().end()};
+              AddTemporaryConstant(output_name, floats);
+              break;
+            }
+            case AttributeProto::FLOAT: {
+              std::vector<float> floats({attr.f()});
+              AddTemporaryConstant(output_name, floats, true);
+              break;
+            }
+            default:
+              break;
+          }
+        }
+      }
+    }
+  }
+
+  void ProcessCall(const NodeProto& caller, const FunctionProto& callee, InferenceContext& ctx);
+
+  void Process(NodeProto& n) {
+    // Resolve domain for node
+    auto dit = opset_imports.find(n.domain());
+    if (dit == opset_imports.end()) {
+      // Both "" (ONNX_DOMAIN) and "ai.onnx" (AI_ONNX_DOMAIN) refer to the default ONNX domain
+      if (n.domain() == ONNX_DOMAIN) {
+        dit = opset_imports.find(AI_ONNX_DOMAIN);
+      }
+      if (dit == opset_imports.end()) {
+        fail_type_inference(
+            "Cannot infer type and shape for node name ",
+            n.name(),
+            ". No opset import for domain ",
+            n.domain(),
+            " optype ",
+            n.op_type());
+      }
+    }
+    auto domain_version = dit->second;
+    const auto* const schema = schema_registry->GetSchema(n.op_type(), domain_version, n.domain());
+    InferenceContextImpl ctx(
+        n,
+        value_types_by_name,
+        input_data_by_name,
+        input_sparse_data_by_name,
+        options,
+        generated_shape_data_by_name,
+        &graph_inference_context);
+
+    ONNX_TRY {
+      if (schema) {
+        if (schema->has_type_and_shape_inference_function()) {
+          schema->GetTypeAndShapeInferenceFunction()(ctx);
+        } else if (schema->HasFunction()) {
+          ProcessCall(n, *(schema->GetFunction()), ctx);
+        } // else: rely on schema->CheckInputOutputType() down below.
+        // check type-constraints specified via type variables
+        if (options.check_type) {
+          schema->CheckInputOutputType(ctx);
+        }
+      } else if (!model_local_functions_map.empty()) {
+        auto iter = model_local_functions_map.find(GetFunctionIdentifier(n));
+        if (iter != model_local_functions_map.end()) {
+          ProcessCall(n, *(iter->second), ctx);
+        } else {
+          has_unsupported_op = true;
+          return;
+        }
+      } else {
+        has_unsupported_op = true;
+        return;
+      }
+      for (int i = 0; i < n.output_size(); ++i) {
+        // skip type and shape propagation for missing optional outputs.
+        if (!n.output(i).empty())
+          UpdateType(n.output(i), ctx.getOutputType(i));
+      }
+      // Constant values are tracked to improve inference/checking for subsequent nodes.
+      ProcessConstant(n);
+      // If data-propagation is enabled, partial-evaluation (aka data-propagation) is performed
+      // to improve inference/checking for subsequent nodes.
+      if (options.enable_data_propagation && schema && schema->has_data_propagation_function()) {
+        if (generated_shape_data_by_name == nullptr) {
+          fail_shape_inference(
+              "Container for generated shape data cannot be nullptr when enable_data_propagation option is set.");
+        }
+        DataPropagationContextImpl data_propagation_ctx(
+            n, value_types_by_name, input_data_by_name, *generated_shape_data_by_name);
+        schema->GetDataPropagationFunction()(data_propagation_ctx);
+      }
+    }
+    ONNX_CATCH(const ONNX_NAMESPACE::InferenceError& ex) {
+      ONNX_HANDLE_EXCEPTION([&]() {
+        // Note: The following special handling is to accommodate custom-ops. Ideally, custom-ops
+        // should be registered with a schema in the schema registry, allowing inference to handle
+        // them. As things stand, this special handling is somewhat fragile and is not fully
+        // general either. Eg., a custom-op suppresses error-messages for subsequent nodes, but
+        // this does not work across graphs. If special handling is required, a user-option may
+        // be a better way to do it. The fragility comes from the fact that the types of the
+        // returned-values of the custom-op are unknown, and subsequent node-level inference
+        // may fail because of this.
+        if (!has_unsupported_op) {
+          inference_errors.push_back(GetErrorWithNodeInfo(n, ex));
+        }
+      });
+    }
+    ONNX_CATCH(const std::runtime_error& err) {
+      // TODO(ONNX): Fix this. Unclear if this should be remapped to a shape inference error.
+      // Need to rationalize the different types of exceptions that can be thrown.
+      // See: https://github.com/onnx/onnx/pull/5519
+      ONNX_HANDLE_EXCEPTION([&]() { fail_shape_inference(GetErrorWithNodeInfo(n, err)); });
+    }
+  }
+
+  // TypeProto_Tensor or TypeProto_SparseTensor
+  template <typename T>
+  void ProcessInitializer(
+      const std::string& name,
+      const T& tensorValue,
+      TypeProto& initializer_type,
+      std::unordered_map<std::string, const T*>& map) {
+    map[name] = &tensorValue;
+    auto iter = value_types_by_name.find(name);
+    // If it already exists in input, check input and initializer is sync
+    // use shape info from input (input has priority over initializer)
+    if (iter != value_types_by_name.end()) {
+      checkShapesAndTypes(initializer_type, *iter->second);
+      // CheckTensorShapesAndTypes(*initializer_tensor_type, *iter->second->mutable_tensor_type());
+    } else if (ir_version >= 4) {
+      // Support IR>=4: some tensors can only exist in initializer and not in input
+      // So shape_inference should make use of initializer shapes
+      // Store initializer shape info in value_info as well
+      initializer_type_list.push_back(std::move(initializer_type));
+      value_types_by_name[name] = &initializer_type_list.back();
+    }
+  }
+
+  void Process(GraphProto& graph) {
+    if (symbol_table) {
+      TraverseGraphsToAddExistingSymbols(graph, *symbol_table);
+    }
+    for (auto& vi : *graph.mutable_value_info()) {
+      UpdateType(vi);
+    }
+    for (auto& vi : *graph.mutable_input()) {
+      UpdateType(vi);
+    }
+    for (auto& vi : *graph.mutable_output()) {
+      UpdateType(vi);
+    }
+    for (const auto& tp : graph.initializer()) {
+      TypeProto initializer_type;
+      TypeProto_Tensor* initializer_tensor_type = initializer_type.mutable_tensor_type();
+      initializer_tensor_type->set_elem_type(tp.data_type());
+      // set the shape according to the initializer shape info
+      auto* shape = initializer_tensor_type->mutable_shape();
+      for (int i = 0; i < tp.dims_size(); ++i) {
+        shape->add_dim()->set_dim_value(tp.dims(i));
+      }
+      ProcessInitializer(tp.name(), tp, initializer_type, input_data_by_name);
+    }
+    for (const auto& tp : graph.sparse_initializer()) {
+      TypeProto initializer_type;
+      auto* initializer_sparse_tensor_type = initializer_type.mutable_sparse_tensor_type();
+      initializer_sparse_tensor_type->set_elem_type(tp.values().data_type());
+      // set the shape according to the initializer shape info
+      auto* shape = initializer_sparse_tensor_type->mutable_shape();
+      for (int i = 0; i < tp.dims_size(); ++i) {
+        shape->add_dim()->set_dim_value(tp.dims(i));
+      }
+      ProcessInitializer(tp.values().name(), tp, initializer_type, input_sparse_data_by_name);
+    }
+    for (auto& n : *graph.mutable_node()) {
+      Process(n);
+    }
+  }
+
+  void Process(const NodeProto& n, internal::AttributeBinder& attribute_binder) {
+    NodeProto copy_n(n);
+    attribute_binder.VisitNode(copy_n);
+    Process(copy_n);
+  }
+
+  void Process(const FunctionProto& func_proto, InferenceContext& ctx) {
+    // Ensure Constant node tensor-attributes are copied
+    bool old_reuse_constant_tensors = reuse_constant_tensors;
+    reuse_constant_tensors = false;
+
+    // Get a temporary tensor-shape map
+    const int num_actual_inputs = static_cast<int>(ctx.getNumInputs());
+    const auto num_func_inputs = func_proto.input_size();
+    std::vector<TypeProto> types_cache(num_func_inputs);
+    for (int i = 0; i < num_func_inputs; ++i) {
+      const auto& parameter_name = func_proto.input().Get(i);
+      const auto* const type_ptr = (i < num_actual_inputs) ? ctx.getInputType(i) : nullptr;
+      // nullptr is valid, and indicates a missing optional input
+      if (type_ptr != nullptr) {
+        // Use a temporary copy of original type.
+        // TODO(ONNX): investigate whether we can eliminate use of temporary copy
+        types_cache[i] = *type_ptr;
+        value_types_by_name[parameter_name] = &types_cache[i];
+      } else {
+        value_types_by_name[parameter_name] = nullptr;
+      }
+    }
+
+    // Create a temporary initializer value map
+    for (int i = 0; i < num_actual_inputs && i < num_func_inputs; ++i) {
+      const TypeProto* type = ctx.getInputType(i);
+      if (type != nullptr) {
+        if (type->value_case() == TypeProto::kTensorType && ctx.getInputData(i) != nullptr) {
+          input_data_by_name[func_proto.input().Get(i)] = ctx.getInputData(i);
+        } else if (type->value_case() == TypeProto::kSparseTensorType && ctx.getInputSparseData(i) != nullptr) {
+          input_sparse_data_by_name[func_proto.input().Get(i)] = ctx.getInputSparseData(i);
+        }
+      }
+    }
+
+    std::unordered_map<std::string, const AttributeProto*> attr_map;
+    for (const auto& attr : func_proto.attribute()) {
+      if (ctx.getAttribute(attr) != nullptr) {
+        attr_map[attr] = ctx.getAttribute(attr);
+      }
+    }
+
+    for (const auto& default_value : func_proto.attribute_proto()) {
+      const std::string& name = default_value.name();
+      const AttributeProto* value = ctx.getAttribute(name);
+      attr_map[name] = (value != nullptr) ? value : &default_value;
+    }
+
+    internal::AttributeBinder attribute_binder(attr_map);
+    for (const auto& n : func_proto.node()) {
+      Process(n, attribute_binder);
+    }
+
+    for (int i = 0; i < func_proto.output_size(); ++i) {
+      const std::string& output_name = func_proto.output().Get(i);
+      // Skip if no type inferred for the tensor
+      auto iter = value_types_by_name.find(output_name);
+      if (iter != value_types_by_name.cend()) {
+        // Copy the type info to ctx
+        // to pass back to main graph
+        auto* type_proto = ctx.getOutputType(i);
+        type_proto->CopyFrom(*(iter->second));
+      }
+    }
+
+    reuse_constant_tensors = old_reuse_constant_tensors;
+  }
+
+ public:
+  ShapeInferenceImplBase(
+      GraphProto* graph, // nullptr for FunctionProto inference
+      const std::unordered_map<std::string, TypeProto*>& outer_scope_value_types_by_name_in,
+      const std::unordered_map<std::string, int>& opset_imports_in,
+      const ShapeInferenceOptions& options_in,
+      SymbolTable* symbol_table_in,
+      const ModelLocalFunctionsMap& model_local_functions_map_in,
+      const ISchemaRegistry* schema_registry_in = OpSchemaRegistry::Instance(),
+      DataValueMap* generated_shape_data_by_name_in = nullptr,
+      const int64_t ir_version_in = IR_VERSION,
+      std::shared_ptr<std::unordered_set<const FunctionProto*>> active_functions_in = nullptr)
+      : inferred_types(graph),
+        value_types_by_name(outer_scope_value_types_by_name_in),
+        opset_imports(opset_imports_in),
+        options(options_in),
+        symbol_table(symbol_table_in),
+        model_local_functions_map(model_local_functions_map_in),
+        schema_registry(schema_registry_in),
+        generated_shape_data_by_name(generated_shape_data_by_name_in),
+        ir_version(ir_version_in),
+        active_functions(
+            active_functions_in ? std::move(active_functions_in)
+                                : std::make_shared<std::unordered_set<const FunctionProto*>>()),
+        graph_inference_context{
+            value_types_by_name,
+            opset_imports,
+            symbol_table,
+            model_local_functions_map,
+            schema_registry,
+            generated_shape_data_by_name,
+            ir_version} {
+    if (options.enable_data_propagation && generated_shape_data_by_name == nullptr) {
+      fail_shape_inference(
+          "Container for generated shape data cannot be nullptr when enable_data_propagation option is set.");
+    }
+  }
+
+  void FinalizeShapeInference() {
+    const auto& errors = getErrors();
+    // Throw shape inference error if any. Error mode right now only supports 0 and 1.
+    // When set to 0, any node level shape inference errors are not thrown. This is to support backward compatibility
+    // with 1.7 and earlier releases. When set to 1 it will throw all exceptions.
+    // TODO(ONNX): Add a more granular way for exception handling.
+    if (!errors.empty() && options.error_mode > 0) {
+      std::string full_errors = "Inference error(s): ";
+      for (const std::string& error : inference_errors) {
+        full_errors += error + "\n";
+      }
+      fail_shape_inference(full_errors);
+    }
+  }
+
+  const std::vector<std::string>& getErrors() const {
+    return inference_errors;
+  }
+
+ private:
+  InferredTypes inferred_types;
+  std::unordered_map<std::string, TypeProto*> value_types_by_name;
+  const std::unordered_map<std::string, int>& opset_imports;
+
+  const ShapeInferenceOptions& options;
+  SymbolTable* symbol_table;
+  const ModelLocalFunctionsMap& model_local_functions_map;
+  const ISchemaRegistry* schema_registry;
+  DataValueMap* generated_shape_data_by_name;
+  int64_t ir_version;
+  std::shared_ptr<std::unordered_set<const FunctionProto*>> active_functions;
+  GraphInferenceContext graph_inference_context;
+
+  std::unordered_map<std::string, TypeProto*> undefined_value_types_by_name;
+  std::unordered_map<std::string, const TensorProto*> input_data_by_name;
+  std::unordered_map<std::string, TensorProto> input_data_by_name_holder;
+  std::unordered_map<std::string, const SparseTensorProto*> input_sparse_data_by_name;
+
+  bool has_unsupported_op = false;
+
+  std::vector<std::string> inference_errors;
+
+  std::list<TypeProto> initializer_type_list;
+
+  // reuse_constant_tensors: controls whether we need to copy tensors occurring as attributes
+  // in Constant nodes. We avoid it for inference for graphs, but must make a copy for functions.
+  bool reuse_constant_tensors = true;
+};
+
+void InferShapesImpl(
+    GraphProto* g,
+    const std::unordered_map<std::string, TypeProto*>& outer_scope_value_types_by_name,
+    const std::unordered_map<std::string, int>& opset_imports,
+    const ShapeInferenceOptions& options,
+    SymbolTable* symbol_table,
+    const ModelLocalFunctionsMap& model_local_functions_map,
+    const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
+    DataValueMap* generated_shape_data_by_name = nullptr,
+    const int64_t ir_version = IR_VERSION // default the latest one
+) {
+  DataValueMap empty;
+  if (generated_shape_data_by_name == nullptr) {
+    generated_shape_data_by_name = &empty;
+  }
+  ShapeInferenceImplBase base(
+      g,
+      outer_scope_value_types_by_name,
+      opset_imports,
+      options,
+      symbol_table,
+      model_local_functions_map,
+      schema_registry,
+      generated_shape_data_by_name,
+      ir_version);
+  base.Process(*g);
+  base.FinalizeShapeInference();
+}
+
+} // namespace
+
+void InferShapes(
+    GraphProto* g,
+    const std::unordered_map<std::string, int>& opset_imports,
+    const ISchemaRegistry* schema_registry,
+    const ShapeInferenceOptions& options,
+    const std::unordered_map<std::string, const FunctionProto*>& model_local_functions) {
+  SymbolTableImpl symbol_table;
+  InferShapesImpl(
+      g,
+      std::unordered_map<std::string, TypeProto*>(0),
+      opset_imports,
+      options,
+      &symbol_table,
+      model_local_functions,
+      schema_registry);
+}
+
+void InferShapes(
+    ModelProto& m,
+    const ISchemaRegistry* schema_registry,
+    const ShapeInferenceOptions& options,
+    DataValueMap* generated_shape_data_by_name) {
+  auto opset_imports = GetOpsetImportsFromProto(m);
+  SymbolTableImpl symbol_table;
+  ModelLocalFunctionsMap model_local_functions_by_id;
+  for (const auto& function_proto : m.functions()) {
+    model_local_functions_by_id.insert({GetFunctionIdentifier(function_proto), &function_proto});
+  }
+  checker::check_function_call_cycles(m);
+  InferShapesImpl(
+      m.mutable_graph(),
+      std::unordered_map<std::string, TypeProto*>(0),
+      opset_imports,
+      options,
+      &symbol_table,
+      model_local_functions_by_id,
+      schema_registry,
+      generated_shape_data_by_name,
+      m.ir_version());
+}
+
+void InferShapes(
+    const std::string& model_path,
+    const std::string& save_path,
+    const ISchemaRegistry* schema_registry,
+    const ShapeInferenceOptions& options,
+    DataValueMap* generated_shape_data_by_name) {
+  ModelProto model;
+  LoadProtoFromPath(model_path, model);
+  InferShapes(model, schema_registry, options, generated_shape_data_by_name);
+  // Save the inferred model to the original model path
+  // Use SerializeToString instead of SerializeToOstream due to LITE_PROTO
+  std::fstream output(save_path, std::ios::out | std::ios::trunc | std::ios::binary);
+  std::string model_string;
+  ONNX_TRY {
+    model.SerializeToString(&model_string);
+    output << model_string;
+  }
+  ONNX_CATCH(...) {
+    fail_check("Unable to save inferred model to the target path:", save_path);
+  }
+}
+
+static void InferShapeForFunctionNodeInternal(
+    const FunctionProto& func_proto,
+    const std::unordered_map<std::string, int>& func_opset_imports,
+    const ISchemaRegistry* schema_registry,
+    InferenceContext& ctx,
+    const ShapeInferenceOptions& options,
+    const std::unordered_map<std::string, const FunctionProto*>& model_local_functions_map,
+    SymbolTable* symbol_table,
+    DataValueMap* generated_shape_data_by_name,
+    std::shared_ptr<std::unordered_set<const FunctionProto*>> active_functions) {
+  ShapeInferenceImplBase base(
+      nullptr, // no graph
+      {}, // outer_scope_value_types_by_name
+      func_opset_imports,
+      options,
+      symbol_table,
+      model_local_functions_map,
+      schema_registry,
+      generated_shape_data_by_name,
+      IR_VERSION,
+      std::move(active_functions));
+  base.Process(func_proto, ctx);
+  base.FinalizeShapeInference();
+}
+
+void ShapeInferenceImplBase::ProcessCall(const NodeProto& caller, const FunctionProto& callee, InferenceContext& ctx) {
+  if (!active_functions->insert(&callee).second) {
+    fail_shape_inference(
+        "Cycle detected in model-local function references: function '",
+        GetFunctionImplId(callee),
+        "' is already being expanded in the current call chain.");
+  }
+  ScopeExit guard([&]() noexcept { active_functions->erase(&callee); });
+
+  DataValueMap callee_value_map;
+  if (generated_shape_data_by_name != nullptr) {
+    BindValuesOnCall(*generated_shape_data_by_name, caller, callee_value_map, callee);
+  }
+  InferShapeForFunctionNodeInternal(
+      callee,
+      GetOpsetImportsFromProto(callee),
+      schema_registry,
+      ctx,
+      options,
+      model_local_functions_map,
+      symbol_table,
+      &callee_value_map,
+      active_functions);
+  if (generated_shape_data_by_name != nullptr) {
+    BindValuesOnReturn(callee_value_map, callee, *generated_shape_data_by_name, caller);
+  }
+}
+
+void InferShapeForFunctionNode(
+    const FunctionProto& func_proto,
+    const std::unordered_map<std::string, int>& func_opset_imports,
+    const ISchemaRegistry* schema_registry,
+    InferenceContext& ctx,
+    const ShapeInferenceOptions& options,
+    const std::unordered_map<std::string, const FunctionProto*>& model_local_functions_map,
+    SymbolTable* symbol_table,
+    DataValueMap* generated_shape_data_by_name) {
+  InferShapeForFunctionNodeInternal(
+      func_proto,
+      func_opset_imports,
+      schema_registry,
+      ctx,
+      options,
+      model_local_functions_map,
+      symbol_table,
+      generated_shape_data_by_name,
+      nullptr);
+}
+
+void InferShapeForFunctionNode(
+    const FunctionProto& function_proto,
+    const ISchemaRegistry* schema_registry,
+    InferenceContext& ctx,
+    const ShapeInferenceOptions& options,
+    const std::unordered_map<std::string, const FunctionProto*>& model_local_functions_map,
+    SymbolTable* symbol_table,
+    DataValueMap* generated_shape_data_by_name) {
+  auto opset_imports = GetOpsetImportsFromProto(function_proto);
+  InferShapeForFunctionNodeInternal(
+      function_proto,
+      opset_imports,
+      schema_registry,
+      ctx,
+      options,
+      model_local_functions_map,
+      symbol_table,
+      generated_shape_data_by_name,
+      nullptr);
+}
+
+namespace {
+
+struct FunctionInferenceContext : public InferenceContext {
+  FunctionInferenceContext(
+      const FunctionProto& func_proto,
+      const std::vector<TypeProto>& input_types,
+      const std::vector<AttributeProto>& attributes,
+      const ShapeInferenceOptions& options)
+      : input_types_(input_types), options_(options), func_proto_(&func_proto) {
+    for (const auto& attr : attributes) {
+      attributesByName_[attr.name()] = &attr;
+    }
+    auto num_outputs = func_proto.output_size();
+    for (int i = 0; i < num_outputs; i++) {
+      output_types_.emplace_back();
+    }
+  }
+
+  const AttributeProto* getAttribute(const std::string& name) const override {
+    auto iter = attributesByName_.find(name);
+    if (iter == attributesByName_.end()) {
+      return nullptr;
+    } else {
+      return iter->second;
+    }
+  }
+  size_t getNumInputs() const override {
+    return input_types_.size();
+  }
+
+  size_t getNumOutputs() const override {
+    return output_types_.size();
+  }
+
+  const TypeProto* getInputType(size_t index) const override {
+    // We should return nullptr for missing optional parameters.
+    // An uninitialized TypeProto() is used for missing optional parameters, and
+    // is mapped to a nullptr here.
+    if (index >= input_types_.size())
+      return nullptr;
+    if (input_types_[index].value_case() == TypeProto::ValueCase::VALUE_NOT_SET)
+      return nullptr;
+    return &input_types_[index];
+  }
+
+  TypeProto* getOutputType(size_t index) override {
+    return (index < output_types_.size()) ? &output_types_[index] : nullptr;
+  }
+
+  // This method is unused for function-type-inference.
+  GraphInferencer* getGraphAttributeInferencer(const std::string& attribute_name [[maybe_unused]]) override {
+    return nullptr;
+  }
+
+  // This inference doesn't take advantage of statically known input values.
+  const TensorProto* getInputData(size_t index [[maybe_unused]]) const override {
+    return nullptr;
+  }
+
+  // This inference doesn't take advantage of statically known input values.
+  const SparseTensorProto* getInputSparseData(size_t index [[maybe_unused]]) const override {
+    return nullptr;
+  }
+
+  // This inference doesn't take advantage of data-propagation.
+  const TensorShapeProto* getSymbolicInput(size_t index [[maybe_unused]]) const override {
+    return nullptr;
+  }
+
+  std::vector<TypeProto> popOutputTypes() {
+    return std::move(output_types_);
+  }
+
+  std::string getDisplayName() const override {
+    if (func_proto_ == nullptr)
+      return "";
+    if (func_proto_->domain().empty()) {
+      if (func_proto_->name().empty())
+        return "";
+      return MakeString("function ", func_proto_->name());
+    }
+    if (func_proto_->name().empty())
+      return MakeString("function [", func_proto_->domain(), "]");
+    return MakeString("function ", func_proto_->name(), "[", func_proto_->domain(), "]");
+  }
+
+ private:
+  const std::vector<TypeProto>& input_types_;
+  std::vector<TypeProto> output_types_;
+  std::unordered_map<std::string, const AttributeProto*> attributesByName_;
+  ShapeInferenceOptions options_;
+  const FunctionProto* func_proto_;
+};
+
+} // namespace
+
+std::vector<TypeProto> InferFunctionOutputTypes(
+    const FunctionProto& function_proto,
+    const std::vector<TypeProto>& input_types,
+    const std::vector<AttributeProto>& attributes) {
+  // TODO(ONNX): if it is desirable for infer_function_output_types to provide check_type, strict_mode, data_prop,
+  // we can add them to the Python API. For now we just assume the default options.
+  ShapeInferenceOptions options{true, 1, false};
+  FunctionInferenceContext ctx(function_proto, input_types, attributes, options);
+  auto opset_imports = GetOpsetImportsFromProto(function_proto);
+  ShapeInferenceImplBase base(
+      nullptr, // no graph
+      {}, // outer_scope_value_types_by_name
+      opset_imports,
+      options,
+      /*symbol_table*/ nullptr,
+      /*model_local_functions_map*/ {},
+      /*schema_registry*/ OpSchemaRegistry::Instance(),
+      /*generated_shape_data_by_name*/ nullptr);
+  base.Process(function_proto, ctx);
+  base.FinalizeShapeInference();
+  return ctx.popOutputTypes();
+}
+
+std::vector<const TypeProto*> GraphInferencerImpl::doInferencing(
+    const std::vector<const TypeProto*>& input_types,
+    const std::vector<const TensorProto*>& input_data) {
+  SymbolTable* symbol_table = context_->symbol_table;
+  int num_inputs = static_cast<int>(input_types.size());
+  std::unordered_set<std::string> initializer_name_set;
+  for (const auto& tp : g_->initializer()) {
+    initializer_name_set.insert(tp.name());
+  }
+
+  if (context_->ir_version >= 4) {
+    if (g_->input_size() != num_inputs) {
+      fail_shape_inference("Graph has ", g_->input_size(), " inputs but ", num_inputs, " were provided");
+    }
+    for (int i = 0; i < g_->input_size(); ++i) {
+      if (initializer_name_set.count(g_->input(i).name()) > 0) {
+        fail_shape_inference(
+            "Cannot use the same name as both a subgraph initializer and subgraph input: ", g_->input(i).name());
+      }
+    }
+  } else {
+    // IR < 4 requires all initializers to be optional inputs
+    // So the number of graph input can be larger than the number of node input
+    if (num_inputs > g_->input_size()) {
+      fail_shape_inference(
+          "Graph has ",
+          g_->input_size(),
+          " inputs but ",
+          num_inputs,
+          " were provided.",
+          "The number of graph input cannot be smaller than the number of node input");
+    } else if (num_inputs < g_->input_size()) {
+      for (int i = 0; i < g_->input_size(); ++i) {
+        if (i < num_inputs && initializer_name_set.count(g_->input(i).name()) > 0) {
+          fail_shape_inference("Graph initializer names must appear after the actual inputs: ", g_->input(i).name());
+        } else if (i >= num_inputs && initializer_name_set.count(g_->input(i).name()) == 0) {
+          // Further check whether the additional input is in initializers
+          fail_shape_inference("Cannot find missing input: ", g_->input(i).name(), "in initializers. ");
+        }
+      }
+    }
+  }
+
+  for (int i = 0, end = num_inputs; i < end; ++i) {
+    const TypeProto* inferred_input = input_types[i];
+
+    if (!inferred_input)
+      continue;
+
+    TypeProto* graph_input = g_->mutable_input(i)->mutable_type();
+    // Even if graphInput doesn't have defined type, it will assign inferredType to it
+    mergeShapesAndTypes(*inferred_input, graph_input);
+
+    if (symbol_table) {
+      MaterializeSymbolicShape(graph_input, *symbol_table);
+    }
+  }
+
+  // future: pass inputData into InferShapes either directly, or indirectly by
+  // updating initializers that match subgraph inputs.
+  (void)input_data;
+  InferShapesImpl(
+      g_,
+      *context_->outer_scope_value_types_by_name, // never null
+      context_->opset_imports,
+      options_,
+      symbol_table,
+      context_->model_local_functions,
+      context_->schema_registry,
+      context_->generated_shape_data_by_name);
+
+  std::vector<const TypeProto*> graph_output_types;
+  graph_output_types.reserve(g_->output().size());
+  for (const ValueInfoProto& output : g_->output()) {
+    graph_output_types.push_back(&output.type());
+  }
+
+  return graph_output_types;
+}
+
+std::string GetErrorWithNodeInfo(const NodeProto& n, const std::runtime_error& err) {
+  std::string op_name = n.has_name() ? (", node name: " + n.name()) : "";
+  return "(op_type:" + n.op_type() + op_name + "): " + err.what();
+}
+
+void TraverseGraphsToAddExistingSymbols(const GraphProto& g, SymbolTable& symbol_table) {
+  symbol_table.addFromGraph(g);
+  for (const auto& n : g.node()) {
+    for (const auto& attr : n.attribute()) {
+      if (attr.has_g()) {
+        TraverseGraphsToAddExistingSymbols(attr.g(), symbol_table);
+      }
+    }
+  }
+}
+
+} // namespace shape_inference
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/shape_inference/implementation.h b/onnx/shape_inference/implementation.h
new file mode 100644
index 0000000..578be5f
--- /dev/null
+++ b/onnx/shape_inference/implementation.h
@@ -0,0 +1,538 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "onnx/defs/schema.h"
+#include "onnx/defs/tensor_proto_util.h"
+#include "onnx/string_utils.h"
+
+namespace ONNX_NAMESPACE {
+namespace shape_inference {
+
+using ModelLocalFunctionsMap = std::unordered_map<std::string, const FunctionProto*>;
+
+// We reuse TensorShapeProto to propagate statically known (partial) information about
+// the values of tensors. It is intended for tensors used to store shape information
+// (the return values of ops like Shape and input values of ops like Reshape/Expand).
+
+// A DataValueMap is used to store the statically known (partial) values of variables.
+using DataValueMap = std::unordered_map<std::string, TensorShapeProto>;
+
+class SymbolTableImpl : public SymbolTable {
+ public:
+  SymbolTableImpl() = default;
+
+  void addFromGraph(const GraphProto& g) override {
+    AddExistingSymbolicDims(g.input());
+    AddExistingSymbolicDims(g.output());
+    AddExistingSymbolicDims(g.value_info());
+  }
+  // Creates a new unique symbol with the given prefix and adds it to the SymbolTable
+  // Returns the newly created symbol
+  std::string createNew(const std::string& symbol_prefix) override {
+    std::string newSymbol;
+    do {
+      newSymbol = symbol_prefix + std::to_string(index_++);
+    } while (existing_symbols.count(newSymbol) > 0);
+    existing_symbols.insert(newSymbol);
+    return newSymbol;
+  }
+
+ private:
+  unsigned int index_{0};
+  std::unordered_set<std::string> existing_symbols;
+
+  // TypeProto_Tensor or TypeProto_SparseTensor
+  template <typename TensorTypeProto>
+  void AddExistingSymbolicDims(const TensorTypeProto& tensorType) {
+    if (tensorType.has_shape()) {
+      for (int i = 0; i < tensorType.shape().dim_size(); ++i) {
+        if (tensorType.shape().dim(i).has_dim_param()) {
+          existing_symbols.insert(tensorType.shape().dim(i).dim_param());
+        }
+      }
+    }
+  }
+
+  void AddExistingSymbolicDims(const TypeProto& typeProto) {
+    const auto val_case = typeProto.value_case();
+    switch (val_case) {
+      case TypeProto::kTensorType:
+        AddExistingSymbolicDims(typeProto.tensor_type());
+        break;
+      case TypeProto::kSparseTensorType:
+        AddExistingSymbolicDims(typeProto.sparse_tensor_type());
+        break;
+      case TypeProto::kSequenceType:
+        AddExistingSymbolicDims(typeProto.sequence_type().elem_type());
+        break;
+      case TypeProto::kOptionalType:
+        AddExistingSymbolicDims(typeProto.optional_type().elem_type());
+        break;
+      case TypeProto::kMapType:
+        AddExistingSymbolicDims(typeProto.map_type().value_type());
+        break;
+      default:
+        break;
+    }
+  }
+
+  void AddExistingSymbolicDims(const google::protobuf::RepeatedPtrField<ValueInfoProto>& protos) {
+    for (const auto& proto : protos) {
+      AddExistingSymbolicDims(proto.type());
+    }
+  }
+};
+
+struct GraphInferenceContext {
+  GraphInferenceContext(
+      const std::unordered_map<std::string, TypeProto*>& outer_scope_value_types_by_name_in,
+      std::unordered_map<std::string, int> opset_imports_in,
+      SymbolTable* symbol_table_in = nullptr,
+      const ModelLocalFunctionsMap& model_local_functions_in = {},
+      const ISchemaRegistry* schema_registry_in = OpSchemaRegistry::Instance(),
+      DataValueMap* generated_shape_data_by_name_in = nullptr,
+      const int64_t ir_version_in = IR_VERSION)
+      : outer_scope_value_types_by_name{&outer_scope_value_types_by_name_in},
+        opset_imports{std::move(opset_imports_in)},
+        symbol_table{symbol_table_in},
+        model_local_functions{model_local_functions_in},
+        schema_registry{schema_registry_in},
+        generated_shape_data_by_name{generated_shape_data_by_name_in},
+        ir_version{ir_version_in} {}
+
+  const std::unordered_map<std::string, TypeProto*>* outer_scope_value_types_by_name;
+  const std::unordered_map<std::string, int> opset_imports;
+  SymbolTable* symbol_table;
+  const ModelLocalFunctionsMap& model_local_functions;
+  const ISchemaRegistry* schema_registry;
+  DataValueMap* generated_shape_data_by_name;
+  const int64_t ir_version;
+};
+
+class GraphInferencerImpl : public GraphInferencer {
+ public:
+  GraphInferencerImpl(GraphProto& g, GraphInferenceContext& context) : g_{&g}, context_{&context} {}
+  GraphInferencerImpl(GraphProto& g, GraphInferenceContext& context, const ShapeInferenceOptions& options)
+      : g_{&g}, context_{&context}, options_(options) {}
+
+  std::vector<const TypeProto*> doInferencing(
+      const std::vector<const TypeProto*>& input_types,
+      const std::vector<const TensorProto*>& input_data) override;
+
+ private:
+  GraphProto* g_;
+  GraphInferenceContext* context_;
+  ShapeInferenceOptions options_;
+};
+
+struct InferenceContextImpl : public InferenceContext {
+  InferenceContextImpl(
+      NodeProto& n,
+      const std::unordered_map<std::string, TypeProto*>& valueTypesByName,
+      const std::unordered_map<std::string, const TensorProto*>& inputDataByName,
+      const std::unordered_map<std::string, const SparseTensorProto*>& inputSparseDataByName,
+      const ShapeInferenceOptions& options,
+      DataValueMap* generatedShapeData = nullptr,
+      GraphInferenceContext* graphInferenceContext = nullptr)
+      : graphInferenceContext_{graphInferenceContext}, options_(options), node_(&n) {
+    for (auto& attr : *n.mutable_attribute()) {
+      attributesByName_[attr.name()] = &attr;
+      if (attr.has_g()) {
+        // need a mutable GraphProto to run inferencing on this attribute
+        graphProtoAttributesByName_[attr.name()] = attr.mutable_g();
+      }
+    }
+
+    for (const auto& input : n.input()) {
+      auto valueTypesIter = valueTypesByName.find(input);
+      if (valueTypesIter != valueTypesByName.end()) {
+        allInputTypes_.push_back(valueTypesIter->second);
+      } else {
+        allInputTypes_.push_back(nullptr);
+      }
+
+      // input data can be in 1 of the 3 containers
+      // inputDataByName - this is when input is TensorProto
+      // inputSparseDataByName - this is when input is SparseTensorProto
+      // generatedShapeData - this is when input was generated as part of partial data propagation
+      const auto inputDataIter = inputDataByName.find(input);
+      if (inputDataIter != inputDataByName.cend()) {
+        allInputData_.push_back(inputDataIter->second);
+        allInputSparseData_.push_back(nullptr);
+        allShapeInputData_.push_back(nullptr);
+      } else {
+        allInputData_.push_back(nullptr);
+        const auto inputSparseDataIter = inputSparseDataByName.find(input);
+        if (inputSparseDataIter != inputSparseDataByName.cend()) {
+          allInputSparseData_.push_back(inputSparseDataIter->second);
+          allShapeInputData_.push_back(nullptr);
+        } else {
+          allInputSparseData_.push_back(nullptr);
+          if (generatedShapeData != nullptr) {
+            const auto inputShapeDataIter = generatedShapeData->find(input);
+            if (inputShapeDataIter != generatedShapeData->cend()) {
+              allShapeInputData_.push_back(&inputShapeDataIter->second);
+            } else {
+              allShapeInputData_.push_back(nullptr);
+            }
+          } else {
+            allShapeInputData_.push_back(nullptr);
+          }
+        }
+      }
+    }
+
+    allOutputTypes_.resize(n.output_size());
+  }
+
+  const AttributeProto* getAttribute(const std::string& name) const override {
+    auto iter = attributesByName_.find(name);
+    if (iter == attributesByName_.end()) {
+      return nullptr;
+    } else {
+      return iter->second;
+    }
+  }
+
+  size_t getNumInputs() const override {
+    return allInputTypes_.size();
+  }
+
+  const TypeProto* getInputType(size_t index) const override {
+    if (index >= allInputTypes_.size()) {
+      ONNX_THROW("Input " + ONNX_NAMESPACE::to_string(index) + " is out of bounds.");
+    }
+    return allInputTypes_[index];
+  }
+
+  const TensorProto* getInputData(size_t index) const override {
+    if (index >= allInputData_.size()) {
+      ONNX_THROW("Input " + ONNX_NAMESPACE::to_string(index) + " is out of bounds.");
+    }
+    return allInputData_[index];
+  }
+
+  const TensorShapeProto* getSymbolicInput(size_t index) const override {
+    if (index >= allShapeInputData_.size()) {
+      ONNX_THROW("Input " + ONNX_NAMESPACE::to_string(index) + " is out of bounds.");
+    }
+
+    return allShapeInputData_[index];
+  }
+
+  const SparseTensorProto* getInputSparseData(size_t index) const override {
+    if (index >= allInputSparseData_.size()) {
+      ONNX_THROW("Input " + ONNX_NAMESPACE::to_string(index) + " is out of bounds.");
+    }
+    return allInputSparseData_[index];
+  }
+
+  size_t getNumOutputs() const override {
+    return allOutputTypes_.size();
+  }
+
+  TypeProto* getOutputType(size_t index) override {
+    if (index >= allOutputTypes_.size()) {
+      ONNX_THROW("Output " + ONNX_NAMESPACE::to_string(index) + " is out of bounds.");
+    }
+    return &allOutputTypes_[index];
+  }
+
+  GraphInferencer* getGraphAttributeInferencer(const std::string& attr_name) override {
+    if (!graphInferenceContext_) {
+      fail_type_inference("GraphProto attribute inferencing is not enabled in this InferenceContextImpl instance.");
+    }
+
+    GraphInferencer* inferencer = nullptr;
+
+    auto entry = graphAttributeInferencers_.find(attr_name);
+    if (entry == graphAttributeInferencers_.cend()) {
+      // create GraphInferencer instance
+      auto attrNameToGraphProto = graphProtoAttributesByName_.find(attr_name);
+      if (attrNameToGraphProto == graphProtoAttributesByName_.cend()) {
+        fail_type_inference("Attribute ", attr_name, " does not contain a graph.");
+      }
+
+      auto new_inferencer =
+          std::make_unique<GraphInferencerImpl>(*attrNameToGraphProto->second, *graphInferenceContext_, options_);
+      inferencer = new_inferencer.get();
+      graphAttributeInferencers_.emplace(attr_name, std::move(new_inferencer));
+    } else {
+      inferencer = entry->second.get();
+    }
+
+    return inferencer;
+  }
+
+  std::string getDisplayName() const override {
+    if (node_ == nullptr)
+      return "";
+    if (node_->domain().empty()) {
+      if (node_->name().empty())
+        return MakeString("node ", node_->op_type());
+      return MakeString("node ", node_->op_type(), " (", node_->name(), ")");
+    }
+    if (node_->name().empty())
+      return MakeString("node ", node_->op_type(), "[", node_->domain(), "]");
+    return MakeString("node ", node_->op_type(), "[", node_->domain(), "]", " (", node_->name(), ")");
+  }
+
+  std::vector<const TensorProto*> allInputData_;
+  std::vector<const SparseTensorProto*> allInputSparseData_;
+  std::vector<const TensorShapeProto*> allShapeInputData_;
+  std::unordered_map<std::string, const AttributeProto*> attributesByName_;
+  std::unordered_map<std::string, GraphProto*> graphProtoAttributesByName_;
+  std::vector<const TypeProto*> allInputTypes_;
+  std::vector<TypeProto> allOutputTypes_;
+  GraphInferenceContext* graphInferenceContext_;
+
+  // mutable as internal cache of GraphInferencer instances
+  mutable std::unordered_map<std::string, std::unique_ptr<GraphInferencer>> graphAttributeInferencers_;
+  ShapeInferenceOptions options_;
+  NodeProto* node_;
+};
+
+struct DataPropagationContextImpl : public DataPropagationContext {
+  DataPropagationContextImpl(
+      NodeProto& n,
+      const std::unordered_map<std::string, TypeProto*>& valueTypesByName,
+      const std::unordered_map<std::string, const TensorProto*>& inputDataByName,
+      DataValueMap& generatedShapeData)
+      : generatedShapeData_(generatedShapeData) {
+    size_t input_idx = 0;
+
+    for (auto& attr : *n.mutable_attribute()) {
+      attributesByName_[attr.name()] = &attr;
+    }
+
+    for (const auto& input : n.input()) {
+      inputIndexToNameMap_.insert({input_idx++, input});
+
+      auto valueTypesIter = valueTypesByName.find(input);
+      if (valueTypesIter != valueTypesByName.end()) {
+        allInputTypes_.push_back(valueTypesIter->second);
+      } else {
+        allInputTypes_.push_back(nullptr);
+      }
+
+      const auto inputDataIter = inputDataByName.find(input);
+      if (inputDataIter != inputDataByName.cend()) {
+        allInputData_.push_back(inputDataIter->second);
+      } else {
+        allInputData_.push_back(nullptr);
+      }
+    }
+
+    size_t output_idx = 0;
+    for (const auto& output : n.output()) {
+      outputIndexToNameMap_.insert({output_idx++, output});
+    }
+
+    allOutputTypes_.resize(n.output_size());
+  }
+
+  const AttributeProto* getAttribute(const std::string& name) const override {
+    auto iter = attributesByName_.find(name);
+    if (iter == attributesByName_.end()) {
+      return nullptr;
+    } else {
+      return iter->second;
+    }
+  }
+
+  size_t getNumInputs() const override {
+    return allInputTypes_.size();
+  }
+
+  const TypeProto* getInputType(size_t index) const override {
+    if (index >= allInputTypes_.size()) {
+      ONNX_THROW("Input " + ONNX_NAMESPACE::to_string(index) + " is out of bounds.");
+    }
+    return allInputTypes_[index];
+  }
+
+  size_t getNumOutputs() const override {
+    return allOutputTypes_.size();
+  }
+
+  const TypeProto* getOutputType(size_t index) const override {
+    if (index >= allOutputTypes_.size()) {
+      ONNX_THROW("Output " + ONNX_NAMESPACE::to_string(index) + " is out of bounds.");
+    }
+    return &allOutputTypes_[index];
+  }
+
+  // Convert integer vector into TensorShapeProto
+  template <typename INTEGER>
+  void vectorToTensorShapeProto(const std::vector<INTEGER>& input_vals, TensorShapeProto& converted_tsp) const {
+    for (unsigned int i = 0; i < input_vals.size(); ++i) {
+      converted_tsp.mutable_dim()->Add()->set_dim_value(input_vals[i]);
+    }
+  }
+
+  const TensorShapeProto* getInputData(size_t index) override {
+    if (index >= allInputData_.size()) {
+      ONNX_THROW("Input " + ONNX_NAMESPACE::to_string(index) + " is out of bounds.");
+    }
+    const std::string input_name = inputIndexToNameMap_.at(index);
+    // Gets it from previous data propagation
+    auto iter = generatedShapeData_.find(input_name);
+    if (iter != generatedShapeData_.end()) {
+      return &iter->second;
+    }
+    // Otherwise, gets it from initializer if it exists
+    const auto* input_data = allInputData_[index];
+    // Only scalar (0D tensor) or 1D tensor can be converted for now
+    // TODO(ONNX): It should support tensors with more dimension on demand
+    if (input_data != nullptr && (input_data->dims_size() == 0 || input_data->dims_size() == 1)) {
+      TensorShapeProto tsp;
+
+      if (input_data->data_type() == TensorProto_DataType_INT64) {
+        vectorToTensorShapeProto(ParseData<int64_t>(input_data), tsp);
+      } else if (input_data->data_type() == TensorProto_DataType_INT32) {
+        vectorToTensorShapeProto(ParseData<int32_t>(input_data), tsp);
+      } else {
+        // Only supports integer type to form a shape
+        return nullptr;
+      }
+
+      // Adds this TensorShapeProto from initializer into generatedShapeData
+      // for future use
+      auto [it, inserted] = generatedShapeData_.insert({input_name, std::move(tsp)});
+      if (inserted) {
+        return &(it->second);
+      }
+    }
+
+    // If X has a known rank N, then X's value can be represented as an array
+    // of N unknown values (represented as a TensorShapeProto).
+    const TypeProto* type = getInputType(index);
+    if ((type != nullptr) && (type->has_tensor_type())) {
+      const auto& tensor_type = type->tensor_type();
+      if (tensor_type.has_shape()) {
+        const TensorShapeProto& shape = tensor_type.shape();
+        if ((shape.dim_size() == 1) && (shape.dim(0).has_dim_value())) {
+          TensorShapeProto tsp;
+          int64_t dim_value = shape.dim(0).dim_value();
+          for (int64_t i = 0; i < dim_value; ++i) {
+            tsp.add_dim();
+          }
+          auto [it, inserted] = generatedShapeData_.insert({input_name, std::move(tsp)});
+          if (inserted) {
+            return &(it->second);
+          }
+        }
+      }
+    }
+    return nullptr;
+  }
+
+  void addOutputData(size_t index, TensorShapeProto&& tsp) override {
+    if (index >= outputIndexToNameMap_.size()) {
+      ONNX_THROW("Input " + ONNX_NAMESPACE::to_string(index) + " is out of bounds.");
+    }
+    auto [_, inserted] = generatedShapeData_.insert({outputIndexToNameMap_.at(index), std::move(tsp)});
+    if (!inserted) {
+      fail_shape_inference("Data for input  " + ONNX_NAMESPACE::to_string(index) + " already exists.");
+    }
+  }
+
+  std::vector<const TensorProto*> allInputData_;
+  std::unordered_map<size_t, std::string> inputIndexToNameMap_;
+  std::unordered_map<size_t, std::string> outputIndexToNameMap_;
+  std::vector<const TypeProto*> allInputTypes_;
+  std::vector<TypeProto> allOutputTypes_;
+  DataValueMap& generatedShapeData_;
+  std::unordered_map<std::string, const AttributeProto*> attributesByName_;
+};
+
+void checkShapesAndTypes(const TypeProto& inferred_type, const TypeProto& existing_type);
+
+void MaterializeSymbolicShape(TypeProto* inferred_type, SymbolTable& symbol_table);
+
+void mergeShapesAndTypes(const TypeProto_Tensor& inferred_type, TypeProto_Tensor* existing_type);
+
+void mergeShapesAndTypes(const TypeProto_SparseTensor& inferred_type, TypeProto_SparseTensor* existing_type);
+
+void mergeShapesAndTypes(const TypeProto& inferred_type, TypeProto* existing_type);
+
+///
+/// ModelLocalFunctionsMap is a map of function id -> model local function proto
+/// All the ONNX helper utilities expect the function id == <function_proto.domain>:<function_proto.name>
+///
+ONNX_API void InferShapes(
+    GraphProto* g,
+    const std::unordered_map<std::string, int>& opset_imports,
+    const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
+    const ModelLocalFunctionsMap& in_model_functions = {});
+
+ONNX_API void InferShapes(
+    ModelProto& m,
+    const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
+    DataValueMap* generated_shape_data_by_name = nullptr);
+
+ONNX_API void InferShapes(
+    const std::string& model_path,
+    const std::string& save_path = "",
+    const ISchemaRegistry* schema_registry = OpSchemaRegistry::Instance(),
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
+    DataValueMap* generated_shape_data_by_name = nullptr);
+
+///
+/// ModelLocalFunctionsMap is a map of function id -> model local function proto
+/// All the ONNX helper utilities expect the function id == <function_proto.domain>:<function_proto.name>
+///
+void InferShapeForFunctionNode(
+    const FunctionProto& func,
+    const ISchemaRegistry* schema_registry,
+    InferenceContext& ctx,
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
+    const ModelLocalFunctionsMap& model_local_functions_map = {},
+    SymbolTable* symbol_table = nullptr,
+    DataValueMap* generated_shape_data_by_name = nullptr);
+
+///
+/// ModelLocalFunctionsMap is a map of function id -> model local function proto
+/// All the ONNX helper utilities expect the function id == <function_proto.domain>:<function_proto.name>
+///
+void InferShapeForFunctionNode(
+    const FunctionProto& func_proto,
+    const std::unordered_map<std::string, int>& func_opset_imports,
+    const ISchemaRegistry* schema_registry,
+    InferenceContext& ctx,
+    const ShapeInferenceOptions& options = ShapeInferenceOptions(),
+    const ModelLocalFunctionsMap& model_local_functions_map = {},
+    SymbolTable* symbol_table = nullptr,
+    DataValueMap* generated_shape_data_by_name = nullptr);
+
+///
+/// Apply type-and-shape-inference based checks to a Function body.
+/// Returns the inferred types of the outputs of the function.
+/// Inference depends on the types of the inputs of the function as well as
+/// the attribute values supplied.
+/// A TypeProto with value_case() == TypeProto::ValueCase::VALUE_NOT_SET is used
+/// for missing optional parameters.
+///
+std::vector<TypeProto> InferFunctionOutputTypes(
+    const FunctionProto& function_proto,
+    const std::vector<TypeProto>& input_types,
+    const std::vector<AttributeProto>& attributes);
+
+std::string GetErrorWithNodeInfo(const NodeProto& n, const std::runtime_error& err);
+
+void TraverseGraphsToAddExistingSymbols(const GraphProto& g, SymbolTable& symbol_table);
+
+} // namespace shape_inference
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/string_utils.h b/onnx/string_utils.h
new file mode 100644
index 0000000..caed95a
--- /dev/null
+++ b/onnx/string_utils.h
@@ -0,0 +1,43 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <sstream>
+#include <string>
+
+namespace ONNX_NAMESPACE {
+
+using std::stoi;
+using std::to_string;
+
+inline void MakeStringInternal(std::stringstream& /*ss*/) {}
+
+template <typename T>
+inline void MakeStringInternal(std::stringstream& ss, const T& t) {
+  ss << t;
+}
+
+template <typename T, typename... Args>
+inline void MakeStringInternal(std::stringstream& ss, const T& t, const Args&... args) {
+  MakeStringInternal(ss, t);
+  MakeStringInternal(ss, args...);
+}
+
+template <typename... Args>
+std::string MakeString(const Args&... args) {
+  std::stringstream ss;
+  MakeStringInternal(ss, args...);
+  return std::string(ss.str());
+}
+
+// Specializations for already-a-string types.
+template <>
+inline std::string MakeString(const std::string& str) {
+  return str;
+}
+inline std::string MakeString(const char* c_str) {
+  return std::string(c_str);
+}
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/basic_test.py b/onnx/test/basic_test.py
new file mode 100644
index 0000000..f509c07
--- /dev/null
+++ b/onnx/test/basic_test.py
@@ -0,0 +1,293 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import io
+import os
+import pathlib
+import tempfile
+
+import google.protobuf.message
+import google.protobuf.text_format
+import pytest
+
+import onnx
+from onnx import serialization
+
+
+def _simple_model() -> onnx.ModelProto:
+    model = onnx.ModelProto()
+    model.ir_version = onnx.IR_VERSION
+    model.producer_name = "onnx-test"
+    model.graph.name = "test"
+    return model
+
+
+def _simple_tensor() -> onnx.TensorProto:
+    return onnx.helper.make_tensor(
+        name="test-tensor",
+        data_type=onnx.TensorProto.FLOAT,
+        dims=(2, 3, 4),
+        vals=[x + 0.5 for x in range(24)],
+    )
+
+
+@pytest.mark.parametrize("format", ["protobuf", "textproto", "json", "onnxtxt"])
+class TestIO:
+    def test_load_model_when_input_is_bytes(self, format) -> None:  # noqa: A002
+        proto = _simple_model()
+        proto_string = serialization.registry.get(format).serialize_proto(proto)
+        loaded_proto = onnx.load_model_from_string(proto_string, format=format)
+        assert proto == loaded_proto
+
+    def test_save_and_load_model_when_input_has_read_function(self, format) -> None:  # noqa: A002
+        proto = _simple_model()
+        # When the proto is a bytes representation provided to `save_model`,
+        # it should always be a serialized binary protobuf representation. Aka. format="protobuf"
+        # The saved file format is specified by the `format` argument.
+        proto_string = serialization.registry.get("protobuf").serialize_proto(proto)
+        f = io.BytesIO()
+        onnx.save_model(proto_string, f, format=format)
+        loaded_proto = onnx.load_model(io.BytesIO(f.getvalue()), format=format)
+        assert proto == loaded_proto
+
+    @pytest.mark.parametrize("path_type", [str, pathlib.Path])
+    def test_save_and_load_model_when_input_is_file_path(
+        self,
+        tmp_path,
+        format,  # noqa: A002
+        path_type,
+    ) -> None:
+        proto = _simple_model()
+        model_path = path_type(tmp_path / "model.onnx")
+        onnx.save_model(proto, model_path, format=format)
+        loaded_proto = onnx.load_model(model_path, format=format)
+        assert proto == loaded_proto
+
+
+@pytest.mark.parametrize(
+    "format",
+    [
+        "protobuf",
+        "textproto",
+        "json",
+        # The onnxtxt format does not support saving/loading tensors yet
+    ],
+)
+class TestIOTensor:
+    """Test loading and saving of TensorProto."""
+
+    def test_load_tensor_when_input_is_bytes(self, format) -> None:  # noqa: A002
+        proto = _simple_tensor()
+        proto_string = serialization.registry.get(format).serialize_proto(proto)
+        loaded_proto = onnx.load_tensor_from_string(proto_string, format=format)
+        assert proto == loaded_proto
+
+    def test_save_and_load_tensor_when_input_has_read_function(self, format) -> None:  # noqa: A002
+        # Test if input has a read function
+        proto = _simple_tensor()
+        f = io.BytesIO()
+        onnx.save_tensor(proto, f, format=format)
+        loaded_proto = onnx.load_tensor(io.BytesIO(f.getvalue()), format=format)
+        assert proto == loaded_proto
+
+    @pytest.mark.parametrize("path_type", [str, pathlib.Path])
+    def test_save_and_load_tensor_when_input_is_file_path(
+        self,
+        format,  # noqa: A002
+        tmp_path,
+        path_type,
+    ) -> None:
+        # Test if input is a file name
+        proto = _simple_tensor()
+        model_path = path_type(tmp_path / "model.onnx")
+        onnx.save_tensor(proto, model_path, format=format)
+        loaded_proto = onnx.load_tensor(model_path, format=format)
+        assert proto == loaded_proto
+
+
+class TestSaveAndLoadFileExtensions:
+    def test_save_model_picks_correct_format_from_extension(self) -> None:
+        proto = _simple_model()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            model_path = os.path.join(temp_dir, "model.textproto")
+            # No format is specified, so the extension should be used to determine the format
+            onnx.save_model(proto, model_path)
+            loaded_proto = onnx.load_model(model_path, format="textproto")
+            assert proto == loaded_proto
+
+    def test_load_model_picks_correct_format_from_extension(self) -> None:
+        proto = _simple_model()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            model_path = os.path.join(temp_dir, "model.textproto")
+            onnx.save_model(proto, model_path, format="textproto")
+            # No format is specified, so the extension should be used to determine the format
+            loaded_proto = onnx.load_model(model_path)
+            assert proto == loaded_proto
+
+    def test_save_model_uses_format_when_it_is_specified(self) -> None:
+        proto = _simple_model()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            model_path = os.path.join(temp_dir, "model.textproto")
+            # `format` is specified. It should take precedence over the extension
+            onnx.save_model(proto, model_path, format="protobuf")
+            loaded_proto = onnx.load_model(model_path, format="protobuf")
+            assert proto == loaded_proto
+            with pytest.raises(google.protobuf.text_format.ParseError):
+                # Loading it as textproto (by file extension) should fail
+                onnx.load_model(model_path)
+
+    def test_load_model_uses_format_when_it_is_specified(self) -> None:
+        proto = _simple_model()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            model_path = os.path.join(temp_dir, "model.protobuf")
+            onnx.save_model(proto, model_path)
+            with pytest.raises(google.protobuf.text_format.ParseError):
+                # `format` is specified. It should take precedence over the extension
+                # Loading it as textproto should fail
+                onnx.load_model(model_path, format="textproto")
+
+            loaded_proto = onnx.load_model(model_path, format="protobuf")
+            assert proto == loaded_proto
+
+    def test_load_and_save_model_to_path_without_specifying_extension_succeeds(
+        self,
+    ) -> None:
+        proto = _simple_model()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # No extension is specified
+            model_path = os.path.join(temp_dir, "model")
+            onnx.save_model(proto, model_path, format="textproto")
+            with pytest.raises(google.protobuf.message.DecodeError):
+                # `format` is not specified. load_model should assume protobuf
+                # and fail to load it
+                onnx.load_model(model_path)
+
+            loaded_proto = onnx.load_model(model_path, format="textproto")
+            assert proto == loaded_proto
+
+    def test_load_and_save_model_without_specifying_extension_or_format_defaults_to_protobuf(
+        self,
+    ) -> None:
+        proto = _simple_model()
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # No extension is specified
+            model_path = os.path.join(temp_dir, "model")
+            onnx.save_model(proto, model_path)
+            with pytest.raises(google.protobuf.text_format.ParseError):
+                # The model is saved as protobuf, so loading it as textproto should fail
+                onnx.load_model(model_path, format="textproto")
+
+            loaded_proto = onnx.load_model(model_path)
+            assert proto == loaded_proto
+            loaded_proto_as_explicitly_protobuf = onnx.load_model(
+                model_path, format="protobuf"
+            )
+            assert proto == loaded_proto_as_explicitly_protobuf
+
+
+class TestBasicFunctions:
+    def test_protos_exist(self) -> None:
+        # The proto classes should exist
+        _ = onnx.AttributeProto
+        _ = onnx.NodeProto
+        _ = onnx.GraphProto
+        _ = onnx.ModelProto
+
+    def test_version_exists(self) -> None:
+        model = onnx.ModelProto()
+        # When we create it, graph should not have a version string.
+        assert not model.HasField("ir_version")
+        # We should touch the version so it is annotated with the current
+        # ir version of the running ONNX
+        model.ir_version = onnx.IR_VERSION
+        model_string = model.SerializeToString()
+        model.ParseFromString(model_string)
+        assert model.HasField("ir_version")
+        # Check if the version is correct.
+        assert model.ir_version == onnx.IR_VERSION
+
+    def test_model_and_graph_repr(self) -> None:
+        # Check if the __repr__ methods work without error
+        model = _simple_model()
+        model_repr = repr(model)
+        assert (
+            model_repr
+            == "ModelProto(ir_version=13, producer_name='onnx-test', graph=GraphProto('test'))"
+        )
+
+        text_model = """
+           <
+             ir_version: 10,
+             opset_import: [ "" : 19]
+           >
+           agraph (float[N] X) => (float[N] C)
+           <
+             float[1] weight = {1}
+           >
+           {
+              C = Cast<to=1>(X)
+           }
+        """
+        model = onnx.parser.parse_model(text_model)
+        model_repr = repr(model)
+        assert (
+            model_repr
+            == "ModelProto(ir_version=10, opset_import={'': 19}, graph=GraphProto('agraph', input=<1 inputs>, output=<1 outputs>, initializer=<1 initializers>, node=<1 nodes>))"
+        )
+
+        graph_repr = repr(model.graph)
+        assert (
+            graph_repr
+            == "GraphProto('agraph', input=<1 inputs>, output=<1 outputs>, initializer=<1 initializers>, node=<1 nodes>)"
+        )
+
+    def test_function_repr(self) -> None:
+        text = """
+            <
+            ir_version: 9,
+            opset_import: [ "" : 15, "custom_domain" : 1],
+            producer_name: "FunctionProtoTest",
+            producer_version: "1.0",
+            model_version: 1,
+            doc_string: "A test model for model local functions."
+          >
+         agraph (float[N] x) => (float[N] out)
+         {
+            out = custom_domain.Selu<alpha=2.0, gamma=3.0>(x)
+         }
+         <
+         domain: "custom_domain",
+         opset_import: [ "" : 15],
+         doc_string: "Test function proto"
+         >
+           Selu
+           <alpha: float=1.67326319217681884765625, gamma: float=1.05070102214813232421875>
+           (X) => (C)
+           {
+               constant_alpha = Constant<value_float: float=@alpha>()
+               constant_gamma = Constant<value_float: float=@gamma>()
+               alpha_x = CastLike(constant_alpha, X)
+               gamma_x = CastLike(constant_gamma, X)
+               exp_x = Exp(X)
+               alpha_x_exp_x = Mul(alpha_x, exp_x)
+               alpha_x_exp_x_ = Sub(alpha_x_exp_x, alpha_x)
+               neg = Mul(gamma_x, alpha_x_exp_x_)
+               pos = Mul(gamma_x, X)
+               _zero = Constant<value_float=0.0>()
+               zero = CastLike(_zero, X)
+               less_eq = LessOrEqual(X, zero)
+               C = Where(less_eq, neg, pos)
+           }
+        """
+        model = onnx.parser.parse_model(text)
+        assert (
+            repr(model)
+            == "ModelProto(ir_version=9, opset_import={'': 15, 'custom_domain': 1}, producer_name='FunctionProtoTest', producer_version='1.0', graph=GraphProto('agraph', input=<1 inputs>, output=<1 outputs>, node=<1 nodes>), functions=<1 functions>)"
+        )
+        function_repr = repr(model.functions[0])
+        assert (
+            function_repr
+            == "FunctionProto('Selu', domain='custom_domain', opset_import={'': 15}, input=<1 inputs>, output=<1 outputs>, node=<13 nodes>)"
+        )
diff --git a/onnx/test/checker_test.py b/onnx/test/checker_test.py
new file mode 100644
index 0000000..7d1e588
--- /dev/null
+++ b/onnx/test/checker_test.py
@@ -0,0 +1,1538 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+import tempfile
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pytest
+
+import onnx.defs
+import onnx.parser
+from onnx import (
+    GraphProto,
+    SparseTensorProto,
+    TensorProto,
+    checker,
+    helper,
+    numpy_helper,
+    shape_inference,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+class TestChecker:
+    @property
+    def _sample_float_tensor(self) -> TensorProto:
+        np_array = np.random.randn(2, 3).astype(np.float32)
+        return helper.make_tensor(
+            name="test",
+            data_type=TensorProto.FLOAT,
+            dims=(2, 3),
+            vals=np_array.reshape(6).tolist(),
+        )
+
+    def make_sparse(
+        self,
+        shape: Sequence[int],
+        values: Sequence[int],
+        indices_shape: Sequence[int],
+        indices: Sequence[int],
+        name: str = "spval",
+    ) -> SparseTensorProto:
+        sparse = SparseTensorProto()
+        sparse.dims.extend(shape)
+        nnz = len(values)
+
+        sparse.values.CopyFrom(
+            helper.make_tensor(name, TensorProto.INT64, (nnz,), values)
+        )
+        sparse.indices.CopyFrom(
+            helper.make_tensor("spind", TensorProto.INT64, indices_shape, indices)
+        )
+        return sparse
+
+    def test_check_node(self) -> None:
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+
+        checker.check_node(node)
+
+    def test_check_node_input_marked_optional(self) -> None:
+        # GivenTensorFill's input is marked optional, hence it is used in this test.
+        node = helper.make_node("GivenTensorFill", [], ["Y"], name="test")
+        checker.check_node(node)
+
+        # Explicitly pass the empty string as optional
+        node = helper.make_node("GivenTensorFill", [""], ["Y"], name="test")
+        checker.check_node(node)
+
+        # Input of RELU is not optional
+        node = helper.make_node("Relu", [""], ["Y"], name="test")
+        with pytest.raises(checker.ValidationError):
+            checker.check_node(node)
+
+    def test_check_function_nested(self) -> None:
+        func_domain = "local"
+        func_nested_opset_imports = [
+            helper.make_opsetid("", 14),
+            helper.make_opsetid(func_domain, 1),
+        ]
+        # nested identity/add function
+        func_nested_identity_add_name = "func_nested_identity_add"
+        func_nested_identity_add_inputs = ["a", "b"]
+        func_nested_identity_add_outputs = ["c"]
+        func_nested_identity_add_nodes = [
+            helper.make_node("func_identity", ["a"], ["a1"], domain=func_domain),
+            helper.make_node("func_identity", ["b"], ["b1"], domain=func_domain),
+            helper.make_node("func_add", ["a1", "b1"], ["c"], domain=func_domain),
+        ]
+        func_nested_identity_add = helper.make_function(
+            func_domain,
+            func_nested_identity_add_name,
+            func_nested_identity_add_inputs,
+            func_nested_identity_add_outputs,
+            func_nested_identity_add_nodes,
+            func_nested_opset_imports,
+        )
+        checker.check_function(func_nested_identity_add)
+
+    def test_check_graph_ir_version_3(self) -> None:
+        ctx = checker.C.CheckerContext()
+        ctx.ir_version = 3
+        ctx.opset_imports = {"": onnx.defs.onnx_opset_version()}
+
+        lex_ctx = checker.C.LexicalScopeContext()
+
+        def check_ir_version_3(g: GraphProto) -> None:
+            checker.check_graph(g, ctx, lex_ctx)
+
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        check_ir_version_3(graph)
+
+        graph.initializer.extend([self._sample_float_tensor])
+
+        graph.initializer[0].name = "no-exist"
+
+        with pytest.raises(checker.ValidationError):
+            check_ir_version_3(graph)
+
+        graph.initializer[0].name = "X"
+        check_ir_version_3(graph)
+
+    def test_check_graph(self) -> None:
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        checker.check_graph(graph)
+
+        graph.initializer.extend([self._sample_float_tensor])
+
+        graph.initializer[0].name = "no-exist"
+        checker.check_graph(graph)
+
+        graph.initializer[0].name = "X"
+        checker.check_graph(graph)
+
+    def test_check_graph_types(self) -> None:
+        # This is for https://github.com/onnx/onnx/issues/3849.
+        # It confirms that type checking is performed
+        # when checker.check_model is called with full_check=True
+
+        node_div = helper.make_node("Div", ["X", "Y"], ["Z"], name="test_div")
+        node_identity = helper.make_node("Identity", ["Z"], ["W"], name="test_identity")
+
+        graph = helper.make_graph(
+            [node_div, node_identity],
+            "test",
+            [
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2]),
+                # intentionally use a BOOL type which is not supported by the Div op.
+                helper.make_tensor_value_info("Y", TensorProto.BOOL, [1, 2]),
+            ],
+            [helper.make_tensor_value_info("W", TensorProto.FLOAT, [1, 2])],
+        )
+
+        model = helper.make_model(graph, producer_name="test")
+
+        with pytest.raises(shape_inference.InferenceError):
+            checker.check_model(model, True)
+
+        checker.check_graph(graph)
+
+        graph = helper.make_graph(
+            [node_div, node_identity],
+            "test",
+            [
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2]),
+                # intentionally use a Int32 type which is in conflict with Div's other input X.
+                helper.make_tensor_value_info("Y", TensorProto.INT32, [1, 2]),
+            ],
+            [helper.make_tensor_value_info("W", TensorProto.FLOAT, [1, 2])],
+        )
+
+        model = helper.make_model(graph, producer_name="test")
+
+        with pytest.raises(shape_inference.InferenceError):
+            checker.check_model(model, True)
+
+        checker.check_graph(graph)
+
+    def test_check_graph_empty_initializer_name(self) -> None:
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        checker.check_graph(graph)
+
+        # Supply no name for the initializer
+        graph.initializer.extend([self._sample_float_tensor])
+        graph.initializer[0].name = ""
+        with pytest.raises(checker.ValidationError):
+            checker.check_graph(graph)
+
+    def test_check_graph_empty_sparse_initializer_name(self) -> None:
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        checker.check_graph(graph)
+
+        # Supply no name for the sparse_initializer
+        sparse = self.make_sparse([100], [13, 17, 19], [3], [9, 27, 81], "")
+        graph.sparse_initializer.extend([sparse])
+        with pytest.raises(checker.ValidationError):
+            checker.check_graph(graph)
+
+    def test_check_graph_duplicate_init_names(self) -> None:
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        checker.check_graph(graph)
+
+        graph.initializer.extend([self._sample_float_tensor])
+        graph.initializer[0].name = "X"
+
+        # Add sparse initializer with the same name as above
+        sparse = self.make_sparse([100], [13, 17, 19], [3], [9, 27, 81], "X")
+        graph.sparse_initializer.extend([sparse])
+        with pytest.raises(checker.ValidationError):
+            checker.check_graph(graph)
+
+    def test_check_graph_optional_input(self) -> None:
+        # GivenTensorFill's input is marked optional, hence it is used in this test.
+        node = helper.make_node("GivenTensorFill", [""], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        checker.check_graph(graph)
+
+    def test_check_graph_ssa(self) -> None:
+        relu1 = helper.make_node("Relu", ["X"], ["Z"], name="relu1")
+        relu2 = helper.make_node("Relu", ["Y"], ["Z"], name="relu2")
+
+        graph = helper.make_graph(
+            [relu1, relu2],
+            "test",
+            inputs=[
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2]),
+                helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2]),
+            ],
+            outputs=[helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1, 2])],
+        )
+        with pytest.raises(checker.ValidationError):
+            checker.check_graph(graph)
+
+    def test_check_graph_topologically_sorted(self) -> None:
+        n1 = helper.make_node("Scale", ["X"], ["Y"], scale=2.0, name="n1")
+        n2 = helper.make_node("Scale", ["Y"], ["Z"], scale=3.0, name="n2")
+
+        graph = helper.make_graph(
+            [n2, n1],
+            "test",
+            inputs=[helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            outputs=[helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1, 2])],
+        )
+        with pytest.raises(checker.ValidationError):
+            checker.check_graph(graph)
+
+    def test_check_model(self) -> None:
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        model = helper.make_model(graph, producer_name="test")
+
+        checker.check_model(model)
+
+    def test_check_serialized_model(self) -> None:
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        model = helper.make_model(graph, producer_name="test")
+
+        checker.check_model(model.SerializeToString())
+
+    def test_check_model_protobuf_size_boundary(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        model = helper.make_model(graph, producer_name="test")
+        serialized = model.SerializeToString()
+
+        monkeypatch.setattr(checker, "MAXIMUM_PROTOBUF", len(serialized))
+        checker.check_model(serialized)
+
+    def test_check_model_protobuf_size_over_limit_raises(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        node = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        model = helper.make_model(graph, producer_name="test")
+        serialized = model.SerializeToString()
+
+        monkeypatch.setattr(checker, "MAXIMUM_PROTOBUF", len(serialized) - 1)
+        with pytest.raises(ValueError):
+            checker.check_model(serialized)
+
+    def test_check_old_model(self) -> None:
+        node = helper.make_node("Pad", ["X"], ["Y"], paddings=(0, 0, 0, 0))
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        onnx_id = helper.make_opsetid("", 1)
+        model = helper.make_model(graph, producer_name="test", opset_imports=[onnx_id])
+
+        checker.check_model(model)
+
+    def test_check_tensor(self) -> None:
+        tensor = self._sample_float_tensor
+        checker.check_tensor(tensor)
+
+        input_np = np.random.randn(2, 3).astype(np.float32)
+
+        tensor.raw_data = onnx.numpy_helper.tobytes_little_endian(input_np)
+        with pytest.raises(checker.ValidationError):
+            checker.check_tensor(tensor)
+
+    def test_check_string_tensor(self) -> None:
+        tensor = TensorProto()
+        tensor.data_type = TensorProto.STRING
+        tensor.dims.append(1)
+        tensor.string_data.append(b"Test")
+        checker.check_tensor(tensor)
+
+        del tensor.string_data[:]
+        tensor.raw_data = b"Test"
+        # string data should not be stored in raw_data field
+        with pytest.raises(checker.ValidationError):
+            checker.check_tensor(tensor)
+
+    def test_check_tensor_mismatched_field(self) -> None:
+        tensor = self._sample_float_tensor
+        tensor.data_type = TensorProto.INT32
+        with pytest.raises(checker.ValidationError):
+            checker.check_tensor(tensor)
+
+    def test_nested_graph(self) -> None:
+        n1 = helper.make_node("Scale", ["X"], ["Y"], scale=2.0, name="n1")
+        n2 = helper.make_node("Scale", ["Y"], ["Z"], scale=3.0, name="n2")
+
+        graph = helper.make_graph(
+            [n1, n2],
+            "nested",
+            inputs=[],
+            outputs=[helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1, 2])],
+        )
+
+        i1 = helper.make_node(
+            "If", ["cond"], ["Z"], then_branch=graph, else_branch=graph
+        )
+
+        graph = helper.make_graph(
+            [i1],
+            "test",
+            inputs=[
+                helper.make_tensor_value_info("cond", TensorProto.BOOL, [1]),
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2]),
+            ],
+            outputs=[helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1, 2])],
+        )
+
+        checker.check_graph(graph)
+
+    def test_nested_graph_without_subgraph_input_shape(self) -> None:
+        n1 = helper.make_node("Scale", ["X"], ["Y"], scale=2.0, name="n1")
+        n2 = helper.make_node("Scale", ["Y"], ["Z"], scale=3.0, name="n2")
+
+        input_x = onnx.ValueInfoProto()
+        input_x.name = "X"
+        graph = helper.make_graph(
+            [n1, n2],
+            "nested",
+            inputs=[],
+            outputs=[helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1, 2])],
+        )
+
+        i1 = helper.make_node(
+            "If", ["cond"], ["Z"], then_branch=graph, else_branch=graph
+        )
+
+        graph = helper.make_graph(
+            [i1],
+            "test",
+            inputs=[
+                helper.make_tensor_value_info("cond", TensorProto.BOOL, [1]),
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2]),
+            ],
+            outputs=[helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1, 2])],
+        )
+
+        checker.check_graph(graph)
+
+    @property
+    def _sample_0_elem_tensor(self) -> TensorProto:
+        np_array = np.random.randn(0, 3).astype(np.float32)
+        return helper.make_tensor(
+            name="test",
+            data_type=TensorProto.FLOAT,
+            dims=(0, 3),
+            vals=np_array.reshape(0).tolist(),
+        )
+
+    def test_check_tensor_zero_elem(self) -> None:
+        tensor = self._sample_0_elem_tensor
+        checker.check_tensor(tensor)
+
+    def test_check_removed_experimental_op(self) -> None:
+        node = helper.make_node("ConstantFill", [], ["Y"], name="test", shape=[1, 2])
+        checker.check_node(node)
+
+    def test_skip_schema_check_on_non_standard_domain(self) -> None:
+        node = helper.make_node(
+            "NonExistOp", ["X"], ["Y"], name="test", domain="test.domain"
+        )
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        onnx_id = helper.make_opsetid("test.domain", 1)
+        model = helper.make_model(graph, producer_name="test", opset_imports=[onnx_id])
+        checker.check_model(model)
+
+    def test_check_sparse_tensor(self) -> None:
+        sparse = self.make_sparse([100], [13, 17, 19], [3], [9, 27, 81])
+        checker.check_sparse_tensor(sparse)
+
+    def test_check_sparse_tensor_invalid_index(self) -> None:
+        # index value 181 is out-of-range
+        sparse = self.make_sparse([100], [13, 17, 19], [3], [9, 27, 181])
+        with pytest.raises(checker.ValidationError):
+            checker.check_sparse_tensor(sparse)
+
+    def test_check_sparse_tensor_unordered(self) -> None:
+        # index values are not in sorted order
+        sparse = self.make_sparse([100], [13, 17, 19], [3], [27, 9, 81])
+        with pytest.raises(checker.ValidationError):
+            checker.check_sparse_tensor(sparse)
+
+    def test_check_sparse_tensor_coo_format(self) -> None:
+        sparse = self.make_sparse([10, 10], [13, 17, 19], [3, 2], [0, 9, 2, 7, 8, 1])
+        checker.check_sparse_tensor(sparse)
+
+    def test_check_sparse_tensor_coo_format_invalid_index(self) -> None:
+        sparse = self.make_sparse([10, 10], [13, 17, 19], [3, 2], [0, 9, 0, 27, 8, 1])
+        with pytest.raises(checker.ValidationError):
+            checker.check_sparse_tensor(sparse)
+
+    def test_check_sparse_tensor_coo_format_invalid_shape(self) -> None:
+        sparse = self.make_sparse([10, 10], [13, 17, 19], [2, 3], [0, 9, 2, 7, 8, 1])
+        with pytest.raises(checker.ValidationError):
+            checker.check_sparse_tensor(sparse)
+
+    def test_check_sparse_tensor_coo_format_invalid_dim2(self) -> None:
+        sparse = self.make_sparse([10, 10], [13, 17, 19], [3, 1], [0, 1, 2])
+        with pytest.raises(checker.ValidationError):
+            checker.check_sparse_tensor(sparse)
+
+    def test_check_sparse_matmul(self) -> None:
+        M = 5
+        N = 10
+        # Create ValueInfoProto for input X of shape [N]
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [N])
+        # Create a [M,N] sparse-matrix constant C
+        sparse_tensor = self.make_sparse([M, N], [2, 3, 1], [3], [3, 11, 37])
+        node1 = helper.make_node("Constant", [], ["C"], sparse_value=sparse_tensor)
+        # Create ValueInfoProto for output Y of shape [M]
+        Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [M])
+        # Compute Y = C X
+        node2 = helper.make_node("MatMul", ["C", "X"], ["Y"])
+        # create graph
+        graph = helper.make_graph([node1, node2], "sparse_matmul", [X], [Y])
+        # check graph
+        checker.check_graph(graph)
+
+    def test_check_model_unsupported_input_type(self) -> None:
+        N = 10
+        X = helper.make_tensor_value_info("X", TensorProto.BOOL, [N])
+        Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [N])
+        Z = helper.make_tensor_value_info("Z", TensorProto.FLOAT, [N])
+        onnx_id = helper.make_opsetid("", 6)
+        node = helper.make_node("Add", ["X", "Y"], ["Z"])
+        graph = helper.make_graph([node], "test_add_input", [X, Y], [Z])
+        model = helper.make_model(graph, producer_name="test", opset_imports=[onnx_id])
+        with pytest.raises(shape_inference.InferenceError):
+            checker.check_model(model, True)
+
+    def test_check_model_inconsistent_type(self) -> None:
+        N = 10
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [N])
+        Y = helper.make_tensor_value_info("Y", TensorProto.INT32, [N])
+        Z = helper.make_tensor_value_info("Z", TensorProto.FLOAT, [N])
+        onnx_id = helper.make_opsetid("", 6)
+        node = helper.make_node("Add", ["X", "Y"], ["Z"])
+        graph = helper.make_graph([node], "test_add_input", [X, Y], [Z])
+        model = helper.make_model(graph, producer_name="test", opset_imports=[onnx_id])
+        with pytest.raises(shape_inference.InferenceError):
+            checker.check_model(model, True)
+
+    def test_check_model_unsupported_output_type(self) -> None:
+        N = 10
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [N])
+        Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [N])
+        Z = helper.make_tensor_value_info("Z", TensorProto.BOOL, [N])
+        onnx_id = helper.make_opsetid("", 6)
+        node = helper.make_node("Add", ["X", "Y"], ["Z"])
+        graph = helper.make_graph([node], "test_add_input", [X, Y], [Z])
+        model = helper.make_model(graph, producer_name="test", opset_imports=[onnx_id])
+        with pytest.raises(shape_inference.InferenceError):
+            checker.check_model(model, True)
+
+    def test_loop_with_same_initializer_input_below_ir4(self) -> None:
+        # This is for testing IR<4: tensors must exist both in initializer and input
+        # shape_inference should allow different number of graph input and node input for Loop
+        # Comes from a tf2onnx model
+
+        model = helper.make_model(
+            opset_imports=[helper.make_operatorsetid("", 8)],
+            ir_version=3,
+            graph=helper.make_graph(
+                name="test-loop",
+                inputs=[
+                    helper.make_tensor_value_info(
+                        "input_0", TensorProto.INT32, shape=[1]
+                    ),
+                    helper.make_tensor_value_info(
+                        "while_maximum_iterations_0", TensorProto.INT64, shape=[]
+                    ),
+                    helper.make_tensor_value_info(
+                        "const_fold_opt__18", TensorProto.INT64, shape=[1]
+                    ),
+                    helper.make_tensor_value_info(
+                        "const_fold_opt__17", TensorProto.FLOAT, shape=[]
+                    ),
+                    helper.make_tensor_value_info(
+                        "Const_0", TensorProto.INT32, shape=[1]
+                    ),
+                ],
+                outputs=[
+                    helper.make_tensor_value_info(
+                        "output_0", TensorProto.INT32, shape=[1]
+                    )
+                ],
+                initializer=[
+                    numpy_helper.from_array(
+                        np.array(9223372036854775807, dtype=np.int64),
+                        name="while_maximum_iterations_0",
+                    ),
+                    numpy_helper.from_array(
+                        np.array([-1], dtype=np.int64), name="const_fold_opt__18"
+                    ),
+                    numpy_helper.from_array(
+                        np.array(10.0, dtype=np.float32), name="const_fold_opt__17"
+                    ),
+                    numpy_helper.from_array(
+                        np.array([1], dtype=np.int32), name="Const_0"
+                    ),
+                ],
+                nodes=[
+                    helper.make_node(
+                        "Cast",
+                        inputs=["input_0"],
+                        outputs=["while_cond_158_while_Less__13_0"],
+                        name="while_cond_158_while_Less__13",
+                        domain="",
+                        to=TensorProto.FLOAT,
+                    ),
+                    helper.make_node(
+                        "Less",
+                        inputs=[
+                            "while_cond_158_while_Less__13_0",
+                            "const_fold_opt__17",
+                        ],
+                        outputs=["while_cond_158_while_Less_0"],
+                        name="while_cond_158_while_Less",
+                        domain="",
+                    ),
+                    helper.make_node(
+                        "Squeeze",
+                        inputs=["while_cond_158_while_Less_0"],
+                        outputs=["while_cond_158_while_Squeeze_0"],
+                        name="while_cond_158_while_Squeeze",
+                        domain="",
+                    ),
+                    helper.make_node(
+                        "Loop",
+                        inputs=[
+                            "while_maximum_iterations_0",
+                            "while_cond_158_while_Squeeze_0",
+                            "input_0",
+                            "Const_0",
+                        ],
+                        outputs=["while_loop_0", "while_loop_1"],
+                        name="while_loop",
+                        body=helper.make_graph(
+                            name="while_body",
+                            inputs=[
+                                helper.make_tensor_value_info(
+                                    "while_while_loop_counter_0",
+                                    TensorProto.INT64,
+                                    shape=[],
+                                ),
+                                helper.make_tensor_value_info(
+                                    "cond__15_0", TensorProto.BOOL, shape=[]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_placeholder_0", TensorProto.INT32, shape=[1]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_add_const_0_0", TensorProto.INT32, shape=[1]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "const_fold_opt__19", TensorProto.FLOAT, shape=[]
+                                ),
+                            ],
+                            outputs=[
+                                helper.make_tensor_value_info(
+                                    "cond___while_Identity_graph_outputs_Identity__3_0",
+                                    TensorProto.BOOL,
+                                    shape=[],
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_Identity_2_0", TensorProto.INT32, shape=[1]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_add_const_0_0", TensorProto.INT32, shape=[1]
+                                ),
+                            ],
+                            initializer=[
+                                numpy_helper.from_array(
+                                    np.array(10.0, dtype=np.float32),
+                                    name="const_fold_opt__19",
+                                )
+                            ],
+                            nodes=[
+                                helper.make_node(
+                                    "Add",
+                                    inputs=[
+                                        "while_placeholder_0",
+                                        "while_add_const_0_0",
+                                    ],
+                                    outputs=["while_Identity_2_0"],
+                                    name="while_Add",
+                                ),
+                                helper.make_node(
+                                    "Cast",
+                                    inputs=["while_Identity_2_0"],
+                                    outputs=["cond___while_Less__13_0"],
+                                    name="cond___while_Less__13",
+                                    domain="",
+                                    to=TensorProto.FLOAT,
+                                ),
+                                helper.make_node(
+                                    "Less",
+                                    inputs=[
+                                        "cond___while_Less__13_0",
+                                        "const_fold_opt__19",
+                                    ],
+                                    outputs=["cond___while_Less_0"],
+                                    name="cond___while_Less",
+                                    domain="",
+                                ),
+                                helper.make_node(
+                                    "Squeeze",
+                                    inputs=["cond___while_Less_0"],
+                                    outputs=[
+                                        "cond___while_Identity_graph_outputs_Identity__3_0"
+                                    ],
+                                    name="cond___while_Squeeze",
+                                    domain="",
+                                ),
+                            ],
+                        ),
+                    ),
+                    helper.make_node(
+                        "Unsqueeze",
+                        inputs=["while_loop_0"],
+                        outputs=["Reshape_tensor_0"],
+                        name="Reshape_tensor",
+                        axes=[0],
+                    ),
+                    helper.make_node(
+                        "Reshape",
+                        inputs=["Reshape_tensor_0", "const_fold_opt__18"],
+                        outputs=["output_0"],
+                        name="Reshape",
+                    ),
+                ],
+            ),
+        )
+        # Should not throw an error
+        checker.check_model(model, full_check=True)
+
+    def test_loop_with_different_initializer_input_below_ir4(self) -> None:
+        # This is for testing IR<4: tensors must exist both in initializer and input
+        # Testing an optional input which does not exist in initializers
+        # Checker should throw an error said the missing input is not in initializers
+
+        model = helper.make_model(
+            opset_imports=[helper.make_operatorsetid("", 8)],
+            ir_version=3,
+            graph=helper.make_graph(
+                name="test-loop",
+                inputs=[
+                    helper.make_tensor_value_info(
+                        "input_0", TensorProto.INT32, shape=[1]
+                    ),
+                    helper.make_tensor_value_info(
+                        "while_maximum_iterations_0", TensorProto.INT64, shape=[]
+                    ),
+                    helper.make_tensor_value_info(
+                        "const_fold_opt__18", TensorProto.INT64, shape=[1]
+                    ),
+                    helper.make_tensor_value_info(
+                        "const_fold_opt__17", TensorProto.FLOAT, shape=[]
+                    ),
+                    helper.make_tensor_value_info(
+                        "Const_0", TensorProto.INT32, shape=[1]
+                    ),
+                ],
+                outputs=[
+                    helper.make_tensor_value_info(
+                        "output_0", TensorProto.INT32, shape=[1]
+                    )
+                ],
+                initializer=[
+                    numpy_helper.from_array(
+                        np.array(9223372036854775807, dtype=np.int64),
+                        name="while_maximum_iterations_0",
+                    ),
+                    numpy_helper.from_array(
+                        np.array([-1], dtype=np.int64), name="const_fold_opt__18"
+                    ),
+                    numpy_helper.from_array(
+                        np.array(10.0, dtype=np.float32), name="const_fold_opt__17"
+                    ),
+                    numpy_helper.from_array(
+                        np.array([1], dtype=np.int32), name="Const_0"
+                    ),
+                ],
+                nodes=[
+                    helper.make_node(
+                        "Cast",
+                        inputs=["input_0"],
+                        outputs=["while_cond_158_while_Less__13_0"],
+                        name="while_cond_158_while_Less__13",
+                        domain="",
+                        to=TensorProto.FLOAT,
+                    ),
+                    helper.make_node(
+                        "Less",
+                        inputs=[
+                            "while_cond_158_while_Less__13_0",
+                            "const_fold_opt__17",
+                        ],
+                        outputs=["while_cond_158_while_Less_0"],
+                        name="while_cond_158_while_Less",
+                        domain="",
+                    ),
+                    helper.make_node(
+                        "Squeeze",
+                        inputs=["while_cond_158_while_Less_0"],
+                        outputs=["while_cond_158_while_Squeeze_0"],
+                        name="while_cond_158_while_Squeeze",
+                        domain="",
+                    ),
+                    helper.make_node(
+                        "Loop",
+                        inputs=[
+                            "while_maximum_iterations_0",
+                            "while_cond_158_while_Squeeze_0",
+                            "input_0",
+                            "Const_0",
+                        ],
+                        outputs=["while_loop_0", "while_loop_1"],
+                        name="while_loop",
+                        body=helper.make_graph(
+                            name="while_body",
+                            inputs=[
+                                helper.make_tensor_value_info(
+                                    "while_while_loop_counter_0",
+                                    TensorProto.INT64,
+                                    shape=[],
+                                ),
+                                helper.make_tensor_value_info(
+                                    "cond__15_0", TensorProto.BOOL, shape=[]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_placeholder_0", TensorProto.INT32, shape=[1]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_add_const_0_0", TensorProto.INT32, shape=[1]
+                                ),
+                                # The following input cannot be found in initializer and checker should throw an error
+                                helper.make_tensor_value_info(
+                                    "const_fold_opt__18", TensorProto.FLOAT, shape=[]
+                                ),
+                            ],
+                            outputs=[
+                                helper.make_tensor_value_info(
+                                    "cond___while_Less__13_0",
+                                    TensorProto.BOOL,
+                                    shape=[],
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_Identity_2_0", TensorProto.INT32, shape=[1]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_add_const_0_0", TensorProto.INT32, shape=[1]
+                                ),
+                            ],
+                            initializer=[],
+                            nodes=[
+                                helper.make_node(
+                                    "Add",
+                                    inputs=[
+                                        "while_placeholder_0",
+                                        "while_add_const_0_0",
+                                    ],
+                                    outputs=["while_Identity_2_0"],
+                                    name="while_Add",
+                                ),
+                                helper.make_node(
+                                    "Cast",
+                                    inputs=["while_Identity_2_0"],
+                                    outputs=["cond___while_Less__13_0"],
+                                    name="cond___while_Less__13",
+                                    domain="",
+                                    to=TensorProto.BOOL,
+                                ),
+                            ],
+                        ),
+                    ),
+                    helper.make_node(
+                        "Unsqueeze",
+                        inputs=["while_loop_0"],
+                        outputs=["Reshape_tensor_0"],
+                        name="Reshape_tensor",
+                        axes=[0],
+                    ),
+                    helper.make_node(
+                        "Reshape",
+                        inputs=["Reshape_tensor_0", "const_fold_opt__18"],
+                        outputs=["output_0"],
+                        name="Reshape",
+                    ),
+                ],
+            ),
+        )
+        with pytest.raises(shape_inference.InferenceError):
+            checker.check_model(model, True)
+
+    def test_loop_with_same_initializer_input_above_ir4(self) -> None:
+        # This is for testing IR>=4:
+        # Cannot use the same name as both a subgraph initializer and subgraph input
+
+        model = helper.make_model(
+            opset_imports=[helper.make_operatorsetid("", 11)],
+            ir_version=6,
+            graph=helper.make_graph(
+                name="test-loop",
+                inputs=[
+                    helper.make_tensor_value_info(
+                        "input_0", TensorProto.INT32, shape=[1]
+                    ),
+                    helper.make_tensor_value_info(
+                        "while_maximum_iterations_0", TensorProto.INT64, shape=[]
+                    ),
+                    helper.make_tensor_value_info(
+                        "const_fold_opt__18", TensorProto.INT64, shape=[1]
+                    ),
+                    helper.make_tensor_value_info(
+                        "const_fold_opt__17", TensorProto.FLOAT, shape=[]
+                    ),
+                    helper.make_tensor_value_info(
+                        "Const_0", TensorProto.INT32, shape=[1]
+                    ),
+                ],
+                outputs=[
+                    helper.make_tensor_value_info(
+                        "output_0", TensorProto.INT32, shape=[1]
+                    )
+                ],
+                initializer=[
+                    numpy_helper.from_array(
+                        np.array(9223372036854775807, dtype=np.int64),
+                        name="while_maximum_iterations_0",
+                    ),
+                    numpy_helper.from_array(
+                        np.array([-1], dtype=np.int64), name="const_fold_opt__18"
+                    ),
+                    numpy_helper.from_array(
+                        np.array(10.0, dtype=np.float32), name="const_fold_opt__17"
+                    ),
+                    numpy_helper.from_array(
+                        np.array([1], dtype=np.int32), name="Const_0"
+                    ),
+                ],
+                nodes=[
+                    helper.make_node(
+                        "Cast",
+                        inputs=["input_0"],
+                        outputs=["while_cond_158_while_Less__13_0"],
+                        name="while_cond_158_while_Less__13",
+                        domain="",
+                        to=TensorProto.FLOAT,
+                    ),
+                    helper.make_node(
+                        "Less",
+                        inputs=[
+                            "while_cond_158_while_Less__13_0",
+                            "const_fold_opt__17",
+                        ],
+                        outputs=["while_cond_158_while_Less_0"],
+                        name="while_cond_158_while_Less",
+                        domain="",
+                    ),
+                    helper.make_node(
+                        "Squeeze",
+                        inputs=["while_cond_158_while_Less_0"],
+                        outputs=["while_cond_158_while_Squeeze_0"],
+                        name="while_cond_158_while_Squeeze",
+                        domain="",
+                    ),
+                    helper.make_node(
+                        "Loop",
+                        inputs=[
+                            "while_maximum_iterations_0",
+                            "while_cond_158_while_Squeeze_0",
+                            "input_0",
+                            "Const_0",
+                        ],
+                        outputs=["while_loop_0", "while_loop_1"],
+                        name="while_loop",
+                        body=helper.make_graph(
+                            name="while_body",
+                            inputs=[
+                                helper.make_tensor_value_info(
+                                    "while_while_loop_counter_0",
+                                    TensorProto.INT64,
+                                    shape=[],
+                                ),
+                                helper.make_tensor_value_info(
+                                    "cond__15_0", TensorProto.BOOL, shape=[]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_placeholder_0", TensorProto.INT32, shape=[1]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_add_const_0_0", TensorProto.INT32, shape=[1]
+                                ),
+                            ],
+                            outputs=[
+                                helper.make_tensor_value_info(
+                                    "cond___while_Identity_graph_outputs_Identity__3_0",
+                                    TensorProto.BOOL,
+                                    shape=[],
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_Identity_2_0", TensorProto.INT32, shape=[1]
+                                ),
+                                helper.make_tensor_value_info(
+                                    "while_add_const_0_0", TensorProto.INT32, shape=[1]
+                                ),
+                            ],
+                            # Cannot use the same name as both a subgraph initializer and subgraph input: while_while_loop_counter_0
+                            initializer=[
+                                numpy_helper.from_array(
+                                    np.array(10, dtype=np.int64),
+                                    name="while_while_loop_counter_0",
+                                )
+                            ],
+                            nodes=[
+                                helper.make_node(
+                                    "Add",
+                                    inputs=[
+                                        "while_placeholder_0",
+                                        "while_add_const_0_0",
+                                    ],
+                                    outputs=["while_Identity_2_0"],
+                                    name="while_Add",
+                                ),
+                                helper.make_node(
+                                    "Cast",
+                                    inputs=["while_Identity_2_0"],
+                                    outputs=["cond___while_Less__13_0"],
+                                    name="cond___while_Less__13",
+                                    domain="",
+                                    to=TensorProto.FLOAT,
+                                ),
+                                helper.make_node(
+                                    "Less",
+                                    inputs=[
+                                        "cond___while_Less__13_0",
+                                        "while_while_loop_counter_0",
+                                    ],
+                                    outputs=["cond___while_Less_0"],
+                                    name="cond___while_Less",
+                                    domain="",
+                                ),
+                                helper.make_node(
+                                    "Squeeze",
+                                    inputs=["cond___while_Less_0"],
+                                    outputs=[
+                                        "cond___while_Identity_graph_outputs_Identity__3_0"
+                                    ],
+                                    name="cond___while_Squeeze",
+                                    domain="",
+                                ),
+                            ],
+                        ),
+                    ),
+                    helper.make_node(
+                        "Unsqueeze",
+                        inputs=["while_loop_0"],
+                        outputs=["Reshape_tensor_0"],
+                        name="Reshape_tensor",
+                        axes=[0],
+                    ),
+                    helper.make_node(
+                        "Reshape",
+                        inputs=["Reshape_tensor_0", "const_fold_opt__18"],
+                        outputs=["output_0"],
+                        name="Reshape",
+                    ),
+                ],
+            ),
+        )
+        with pytest.raises(shape_inference.InferenceError):
+            checker.check_model(model, True)
+
+    def test_empty_list_attribute(self):
+        model = onnx.parser.parse_model(
+            """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17]
+            >
+            agraph (float[N] x) => (int64[M] y)
+            {
+                y = Constant <value_ints: ints = []>()
+            }
+        """
+        )
+        # Should not throw an error
+        checker.check_model(model, full_check=True)
+        model = onnx.parser.parse_model(
+            """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17]
+            >
+            agraph (float[N] x) => (float[M] y)
+            {
+                y = Constant <value_floats: floats = []>()
+            }
+        """
+        )
+        # Should not throw an error
+        checker.check_model(model, full_check=True)
+
+    def test_check_model_supports_unicode_path(self):
+        input_tensor = helper.make_tensor_value_info(
+            "input", onnx.TensorProto.FLOAT, [1]
+        )
+        output_tensor = helper.make_tensor_value_info(
+            "output", onnx.TensorProto.FLOAT, [1]
+        )
+        node = helper.make_node("Identity", ["input"], ["output"])
+        graph = helper.make_graph([node], "test", [input_tensor], [output_tensor])
+        model = helper.make_model(graph, producer_name="test")
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            unicode_model_path = os.path.join(temp_dir, "模型モデル모델✨.onnx")
+            onnx.save(model, unicode_model_path)
+            checker.check_model(unicode_model_path, full_check=True)
+
+    def test_graph_output_is_defined(self):
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[N] x) => (float[N] y, float[N] z)
+            {
+                y = Add(x, x)
+            }
+            # Error: z is not defined
+        """
+        )
+        with pytest.raises(checker.ValidationError):
+            checker.check_model(model)
+
+    def test_graph_output_is_defined_within_sub_graph(self):
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[N] x, bool cond) => (float[N] y)
+            {
+                sum = Add (x, x)
+                prod = Mul (x, x)
+                y = If (cond) <
+                    then_branch = then_graph () => (sum) {},
+                    else_branch = else_graph () => (prod) {}
+                >
+            }
+            # Error: sum/prod are accessible inside if-then-else branches, but cannot
+            # be used as outputs of the then/else branch implicitly.
+            # An explicit "Identity(sum)" must be used to return sum as output.
+        """
+        )
+        with pytest.raises(checker.ValidationError):
+            checker.check_model(model)
+
+    def test_check_model_rejects_self_recursive_function(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) {
+                Y = local.foo (X)
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) { y = local.foo (x) }
+        """
+        )
+        with pytest.raises(checker.ValidationError):
+            checker.check_model(model)
+
+    def test_check_model_rejects_indirect_cycle(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) {
+                Y = local.foo (X)
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) { y = local.bar (x) }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            bar (x) => (y) { y = local.foo (x) }
+        """
+        )
+        with pytest.raises(checker.ValidationError):
+            checker.check_model(model)
+
+    def test_check_model_rejects_self_recursion_in_subgraph(self) -> None:
+        # Cycle reachable only through an If-branch subgraph nested in the function body.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) {
+                Y = local.foo (X)
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) {
+                cond = Constant <value = bool {1}> ()
+                y = If (cond) <
+                    then_branch = g_then () => (yt) { yt = local.foo (x) },
+                    else_branch = g_else () => (ye) { ye = Identity (x) }
+                >
+            }
+        """
+        )
+        with pytest.raises(
+            checker.ValidationError,
+            match="Cycle detected in model-local function references",
+        ):
+            checker.check_model(model)
+
+    def test_check_model_rejects_mutual_recursion_in_subgraph(self) -> None:
+        # Mutual A<->B cycle where each edge lives inside an If-branch subgraph.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) {
+                Y = local.foo (X)
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) {
+                cond = Constant <value = bool {1}> ()
+                y = If (cond) <
+                    then_branch = foo_then () => (yt) { yt = local.bar (x) },
+                    else_branch = foo_else () => (ye) { ye = Identity (x) }
+                >
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            bar (x) => (y) {
+                cond = Constant <value = bool {1}> ()
+                y = If (cond) <
+                    then_branch = bar_then () => (yt) { yt = local.foo (x) },
+                    else_branch = bar_else () => (ye) { ye = Identity (x) }
+                >
+            }
+        """
+        )
+        with pytest.raises(
+            checker.ValidationError,
+            match="Cycle detected in model-local function references",
+        ):
+            checker.check_model(model)
+
+    def test_check_model_rejects_indirect_cycle_through_subgraph(self) -> None:
+        # Three-function indirect cycle foo -> foo2 -> foo3 -> foo where every call
+        # edge lives inside an If-branch subgraph, so the cycle is only discoverable
+        # through the recursive subgraph descent (not the top-level function bodies).
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) {
+                Y = local.foo (X)
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) {
+                cond = Constant <value = bool {1}> ()
+                y = If (cond) <
+                    then_branch = foo_then () => (yt) { yt = local.foo2 (x) },
+                    else_branch = foo_else () => (ye) { ye = Identity (x) }
+                >
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo2 (x) => (y) {
+                cond = Constant <value = bool {1}> ()
+                y = If (cond) <
+                    then_branch = foo2_then () => (yt) { yt = local.foo3 (x) },
+                    else_branch = foo2_else () => (ye) { ye = Identity (x) }
+                >
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo3 (x) => (y) {
+                cond = Constant <value = bool {1}> ()
+                y = If (cond) <
+                    then_branch = foo3_then () => (yt) { yt = local.foo (x) },
+                    else_branch = foo3_else () => (ye) { ye = Identity (x) }
+                >
+            }
+        """
+        )
+        with pytest.raises(
+            checker.ValidationError,
+            match="Cycle detected in model-local function references",
+        ):
+            checker.check_model(model)
+
+    def test_check_model_rejects_cycle_in_loop_body(self) -> None:
+        # Cycle edge hidden inside a Loop body subgraph rather than an If branch.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) {
+                Y = local.foo (X)
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) {
+                trip = Constant <value = int64 {1}> ()
+                cond = Constant <value = bool {1}> ()
+                y = Loop (trip, cond, x) <
+                    body = loop_body (iter, keep, x_in) => (keep_out, x_out) {
+                        keep_out = Identity (keep)
+                        x_out = local.foo (x_in)
+                    }
+                >
+            }
+        """
+        )
+        with pytest.raises(
+            checker.ValidationError,
+            match="Cycle detected in model-local function references",
+        ):
+            checker.check_model(model)
+
+    def test_check_model_rejects_cycle_in_scan_body(self) -> None:
+        # Cycle edge hidden inside a Scan body subgraph, mirroring the Loop-body case.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) {
+                Y = local.foo (X)
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) {
+                y = Scan (x) <
+                    num_scan_inputs = 1,
+                    body = scan_body (x_in) => (x_out) {
+                        x_out = local.foo (x_in)
+                    }
+                >
+            }
+        """
+        )
+        with pytest.raises(
+            checker.ValidationError,
+            match="Cycle detected in model-local function references",
+        ):
+            checker.check_model(model)
+
+    def test_check_model_rejects_deeply_nested_cycle(self) -> None:
+        # Cycle reachable only through If -> Loop -> self, exercising arbitrary-depth descent.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) {
+                Y = local.foo (X)
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) {
+                cond = Constant <value = bool {1}> ()
+                y = If (cond) <
+                    then_branch = g_then () => (yt) {
+                        trip = Constant <value = int64 {1}> ()
+                        loop_cond = Constant <value = bool {1}> ()
+                        yt = Loop (trip, loop_cond, x) <
+                            body = loop_body (iter, keep, x_in) => (keep_out, x_out) {
+                                keep_out = Identity (keep)
+                                x_out = local.foo (x_in)
+                            }
+                        >
+                    },
+                    else_branch = g_else () => (ye) { ye = Identity (x) }
+                >
+            }
+        """
+        )
+        with pytest.raises(
+            checker.ValidationError,
+            match="Cycle detected in model-local function references",
+        ):
+            checker.check_model(model)
+
+    def test_check_model_accepts_noncyclic_call_from_subgraph(self) -> None:
+        # A function whose subgraph calls a DIFFERENT non-cyclic local function must pass.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) {
+                Y = local.foo (X)
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) {
+                cond = Constant <value = bool {1}> ()
+                y = If (cond) <
+                    then_branch = g_then () => (yt) { yt = local.bar (x) },
+                    else_branch = g_else () => (ye) { ye = Identity (x) }
+                >
+            }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            bar (x) => (y) { y = Identity (x) }
+        """
+        )
+        checker.check_model(model)
+
+    def test_check_tensor_invalid_dims(self) -> None:
+        """Reject tensors with overflowing or negative dimensions."""
+        # Overflow: 2^62 * 2^62 exceeds int64
+        tensor = TensorProto()
+        tensor.data_type = TensorProto.FLOAT
+        tensor.dims.extend([2**62, 2**62])
+        tensor.name = "t"
+        tensor.raw_data = b"\x00"
+        with pytest.raises(checker.ValidationError):
+            checker.check_tensor(tensor)
+        # Negative dim
+        tensor2 = TensorProto()
+        tensor2.data_type = TensorProto.FLOAT
+        tensor2.dims.extend([-1, 4])
+        tensor2.name = "t"
+        tensor2.raw_data = b"\x00" * 16
+        with pytest.raises(checker.ValidationError):
+            checker.check_tensor(tensor2)
+        # Zero dim: empty tensors are valid and must be accepted.
+        tensor3 = TensorProto()
+        tensor3.data_type = TensorProto.FLOAT
+        tensor3.dims.extend([0])
+        tensor3.name = "t"
+        checker.check_tensor(tensor3)
+
+    def test_check_tensor_packed_subbyte_raw_data(self) -> None:
+        """Reject packed sub-byte tensors whose raw_data payload is too small."""
+        # 4-bit types (INT4, UINT4, FLOAT4E2M1): 2 elements per byte.
+        # 10 elements need ceil(10/2) = 5 bytes; 4 bytes is too small.
+        for dtype in (TensorProto.INT4, TensorProto.UINT4, TensorProto.FLOAT4E2M1):
+            tensor = TensorProto()
+            tensor.data_type = dtype
+            tensor.dims.extend([10])
+            tensor.name = "t"
+            tensor.raw_data = b"\x00" * 4  # 1 byte too short
+            with pytest.raises(checker.ValidationError):
+                checker.check_tensor(tensor)
+            # Exactly enough bytes must pass.
+            tensor2 = TensorProto()
+            tensor2.data_type = dtype
+            tensor2.dims.extend([10])
+            tensor2.name = "t"
+            tensor2.raw_data = b"\x00" * 5  # ceil(10/2) = 5 bytes
+            checker.check_tensor(tensor2)
+
+        # 2-bit types (INT2, UINT2): 4 elements per byte.
+        # 10 elements need ceil(10/4) = 3 bytes; 2 bytes is too small.
+        for dtype in (TensorProto.INT2, TensorProto.UINT2):
+            tensor = TensorProto()
+            tensor.data_type = dtype
+            tensor.dims.extend([10])
+            tensor.name = "t"
+            tensor.raw_data = b"\x00" * 2  # 1 byte too short
+            with pytest.raises(checker.ValidationError):
+                checker.check_tensor(tensor)
+            # Exactly enough bytes must pass.
+            tensor2 = TensorProto()
+            tensor2.data_type = dtype
+            tensor2.dims.extend([10])
+            tensor2.name = "t"
+            tensor2.raw_data = b"\x00" * 3  # ceil(10/4) = 3 bytes
+            checker.check_tensor(tensor2)
+
+    def test_check_tensor_packed_subbyte_int32_data(self) -> None:
+        """Reject packed sub-byte tensors whose int32_data payload is too small."""
+        # 4-bit types: 8 elements per int32.
+        # 10 elements need ceil(10/8) = 2 int32 values; 1 is too small.
+        for dtype in (TensorProto.INT4, TensorProto.UINT4, TensorProto.FLOAT4E2M1):
+            tensor = TensorProto()
+            tensor.data_type = dtype
+            tensor.dims.extend([10])
+            tensor.name = "t"
+            tensor.int32_data.extend([0])  # 1 int32, need 2
+            with pytest.raises(checker.ValidationError):
+                checker.check_tensor(tensor)
+            # Exactly enough int32 values must pass.
+            tensor2 = TensorProto()
+            tensor2.data_type = dtype
+            tensor2.dims.extend([10])
+            tensor2.name = "t"
+            tensor2.int32_data.extend([0, 0])  # ceil(10/8) = 2
+            checker.check_tensor(tensor2)
+
+        # 2-bit types: 16 elements per int32.
+        # 20 elements need ceil(20/16) = 2 int32 values; 1 is too small.
+        for dtype in (TensorProto.INT2, TensorProto.UINT2):
+            tensor = TensorProto()
+            tensor.data_type = dtype
+            tensor.dims.extend([20])
+            tensor.name = "t"
+            tensor.int32_data.extend([0])  # 1 int32, need 2
+            with pytest.raises(checker.ValidationError):
+                checker.check_tensor(tensor)
+            # Exactly enough int32 values must pass.
+            tensor2 = TensorProto()
+            tensor2.data_type = dtype
+            tensor2.dims.extend([20])
+            tensor2.name = "t"
+            tensor2.int32_data.extend([0, 0])  # ceil(20/16) = 2
+            checker.check_tensor(tensor2)
+
+    def test_check_tensor_packed_subbyte_zero_elems(self) -> None:
+        """Zero-element packed tensors with empty payload must be valid."""
+        for dtype in (
+            TensorProto.INT4,
+            TensorProto.UINT4,
+            TensorProto.FLOAT4E2M1,
+            TensorProto.INT2,
+            TensorProto.UINT2,
+        ):
+            tensor = TensorProto()
+            tensor.data_type = dtype
+            tensor.dims.extend([0])
+            tensor.name = "t"
+            checker.check_tensor(tensor)
+
+    def test_convtranspose_input_channels_must_be_divisible_by_group(self):
+        node = helper.make_node("ConvTranspose", ["X", "W"], ["Y"], group=3)
+        graph = helper.make_graph(
+            [node],
+            "test",
+            [
+                helper.make_tensor_value_info(
+                    "X", TensorProto.FLOAT, ["N", 32, 14, 14]
+                ),
+                helper.make_tensor_value_info("W", TensorProto.FLOAT, [32, 64, 3, 3]),
+            ],
+            [
+                helper.make_tensor_value_info(
+                    "Y", TensorProto.FLOAT, ["N", None, None, None]
+                )
+            ],
+        )
+        model = helper.make_model(
+            graph, opset_imports=[helper.make_opsetid("", 17)], ir_version=7
+        )
+
+        with pytest.raises(
+            shape_inference.InferenceError,
+            match=r"Input channels C must be divisible by group for ConvTranspose",
+        ):
+            checker.check_model(model, full_check=True)
diff --git a/onnx/test/cmake/CMakeLists.txt b/onnx/test/cmake/CMakeLists.txt
new file mode 100644
index 0000000..c8012f7
--- /dev/null
+++ b/onnx/test/cmake/CMakeLists.txt
@@ -0,0 +1,9 @@
+# This minimal CMake file is used to test finding and linking ONNX from a main project
+cmake_minimum_required(VERSION 3.26)
+project(onnx_test LANGUAGES CXX)
+
+find_package(ONNX REQUIRED CONFIG)
+
+add_executable(main main.cc)
+find_package(Protobuf REQUIRED)
+target_link_libraries(main ONNX::onnx protobuf::libprotobuf)
diff --git a/onnx/test/cmake/main.cc b/onnx/test/cmake/main.cc
new file mode 100644
index 0000000..a9b8d52
--- /dev/null
+++ b/onnx/test/cmake/main.cc
@@ -0,0 +1,29 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <onnx/defs/schema.h>
+#include <onnx/onnx_pb.h>
+
+#include <cstdio>
+#include <string>
+int main() {
+  puts("Link ONNX successfully!");
+
+  auto all_tensor_types = ONNX_NAMESPACE::OpSchema::all_tensor_types_ir9();
+
+  // Test ONNX_OPERATOR_SCHEMA macro, which is borrowed from onnxruntime
+  ONNX_OPERATOR_SCHEMA(MemcpyToHost)
+      .Input(0, "X", "input", "T")
+      .Output(0, "Y", "output", "T")
+      .TypeConstraint(
+          "T",
+          all_tensor_types,
+          "Constrain to all fixed size tensor and sequence types. If the dtype attribute is not provided this must be a valid output type.")
+      .TypeAndShapeInferenceFunction(ONNX_NAMESPACE::propagateShapeAndTypeFromFirstInput)
+      .SetDoc(R"DOC(
+Internal copy node
+)DOC");
+
+  return 0;
+}
diff --git a/onnx/test/compose_test.py b/onnx/test/compose_test.py
new file mode 100644
index 0000000..3023dc2
--- /dev/null
+++ b/onnx/test/compose_test.py
@@ -0,0 +1,1122 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pytest
+
+from onnx import (
+    FunctionProto,
+    GraphProto,
+    ModelProto,
+    NodeProto,
+    SparseTensorProto,
+    TensorProto,
+    ValueInfoProto,
+    checker,
+    compose,
+    helper,
+    parser,
+    version_converter,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+
+def _load_model(m_def: str) -> ModelProto:
+    """Parses a model from a string representation, including checking the model for correctness"""
+    m = parser.parse_model(m_def)
+    checker.check_model(m)
+    return m
+
+
+def _prefixed(prefix: str, s: str) -> str:
+    """Prefixes a string (if not empty)"""
+    return prefix + s if len(s) > 0 else s
+
+
+def _get_shape(value_info: ValueInfoProto) -> list[int]:
+    """Returns a list of integers representing the shape of the provided ValueInfoProto"""
+    return [
+        value_info.type.tensor_type.shape.dim[d].dim_value
+        for d in range(len(value_info.type.tensor_type.shape.dim))
+    ]
+
+
+def _make_sparse_tensor(name: str) -> SparseTensorProto:
+    dense_shape = [3, 3]
+    linear_indices = [2, 3, 5]
+    sparse_values = [1.7, 0.4, 0.9]
+    values_tensor = helper.make_tensor(
+        name=name + "_values",
+        data_type=TensorProto.FLOAT,
+        dims=[len(sparse_values)],
+        vals=np.array(sparse_values).astype(np.float32),
+        raw=False,
+    )
+
+    indices_tensor = helper.make_tensor(
+        name=name + "_idx",
+        data_type=TensorProto.INT64,
+        dims=[len(linear_indices)],
+        vals=np.array(linear_indices).astype(np.int64),
+        raw=False,
+    )
+    return helper.make_sparse_tensor(values_tensor, indices_tensor, dense_shape)
+
+
+M1_DEF = """
+    <
+        ir_version: 7,
+        opset_import: [ "": 10, "com.microsoft": 1]
+    >
+    agraph (float[N, M] A0, float[N, M] A1, float[N, M] _A) => (float[N, M] B00, float[N, M] B10, float[N, M] B20)
+    {
+        B00 = Add(A0, A1)
+        B10 = Sub(A0, A1)
+        B20 = Mul(A0, A1)
+    }
+    """
+
+M2_DEF = """
+    <
+        ir_version: 7,
+        opset_import: [ "": 10, "com.microsoft": 1]
+    >
+    agraph (float[N, M] B01, float[N, M] B11, float[N, M] B21) => (float[N, M] D0)
+    {
+        C0 = Add(B01, B11)
+        C1 = Sub(B11, B21)
+        D0 = Mul(C0, C1)
+    }
+    """
+
+
+class TestComposeFunctions:
+    def _test_merge_models(
+        self,
+        m1def: str,
+        m2def: str,
+        io_map: list[tuple[str, str]],
+        check_expectations: Callable[[GraphProto, GraphProto, GraphProto], None],
+        inputs: list[str] | None = None,
+        outputs: list[str] | None = None,
+        prefix1: str | None = None,
+        prefix2: str | None = None,
+    ) -> None:
+        m1, m2 = _load_model(m1def), _load_model(m2def)
+        g3 = compose.merge_graphs(
+            m1.graph,
+            m2.graph,
+            io_map=io_map,
+            inputs=inputs,
+            outputs=outputs,
+            prefix1=prefix1,
+            prefix2=prefix2,
+        )
+        checker.check_graph(g3)
+        check_expectations(m1.graph, m2.graph, g3)
+        m3 = compose.merge_models(
+            m1,
+            m2,
+            io_map=io_map,
+            inputs=inputs,
+            outputs=outputs,
+            prefix1=prefix1,
+            prefix2=prefix2,
+        )
+        checker.check_model(m3)
+        check_expectations(m1.graph, m2.graph, m3.graph)
+
+    def test_case_connect_all_no_name_collision(self) -> None:
+        """Tests a simple scenario where two models without overlapping names are merged by
+        connecting all the outputs in the first models to all the inputs in the second model
+        """
+
+        def check_expectations(g1: GraphProto, g2: GraphProto, g3: GraphProto) -> None:
+            assert g3.input == g1.input
+            assert g3.output == g2.output
+            assert [item.op_type for item in g3.node] == [
+                "Add",
+                "Sub",
+                "Mul",
+                "Add",
+                "Sub",
+                "Mul",
+            ]
+
+        io_map = [("B00", "B01"), ("B10", "B11"), ("B20", "B21")]
+        self._test_merge_models(M1_DEF, M2_DEF, io_map, check_expectations)
+
+    def test_case_connect_same_output_twice(self) -> None:
+        """Tests a scenario where we merge two models by connecting a single output in the first model
+        to all the inputs in the second
+        """
+
+        def check_expectations(g1: GraphProto, g2: GraphProto, g3: GraphProto) -> None:
+            del g2  # Unused
+            assert g3.input == g1.input
+            assert [elem.name for elem in g3.output] == ["B10", "B20", "D0"]
+            assert [item.op_type for item in g3.node] == [
+                "Add",
+                "Sub",
+                "Mul",
+                "Add",
+                "Sub",
+                "Mul",
+            ]
+
+        io_map = [("B00", "B01"), ("B00", "B11"), ("B00", "B21")]
+        self._test_merge_models(M1_DEF, M2_DEF, io_map, check_expectations)
+
+    def test_case_connect_same_output_drop_outputs(self) -> None:
+        """Tests a scenario where we merge two models by connecting a single output in the first model
+        to all the inputs in the second, while dropping the rest of the outputs in the first model
+        """
+
+        def check_expectations(g1: GraphProto, g2: GraphProto, g3: GraphProto) -> None:
+            del g2  # Unused
+            assert g3.input == g1.input
+            assert [elem.name for elem in g3.output] == ["D0"]
+            assert [item.op_type for item in g3.node] == ["Add", "Add", "Sub", "Mul"]
+
+        io_map = [("B00", "B01"), ("B00", "B11"), ("B00", "B21")]
+        outputs = ["D0"]
+        self._test_merge_models(
+            M1_DEF, M2_DEF, io_map, check_expectations, outputs=outputs
+        )
+
+    def test_case_connect_same_input_output_name(self) -> None:
+        """Tests a scenario where we merge two models, where the inputs/outputs connected
+        are named exactly the same
+        """
+        m1_def = """
+            <
+                ir_version: 7,
+                opset_import: [ "": 10]
+            >
+            agraph (float[N, M] A) => (float[N, M] B)
+            {
+                B = Add(A, A)
+            }
+            """
+        m2_def = """
+            <
+                ir_version: 7,
+                opset_import: [ "": 10]
+            >
+            agraph (float[N, M] B) => (float[N, M] C)
+            {
+                C = Add(B, B)
+            }
+            """
+        io_map = [("B", "B")]
+
+        def check_expectations(g1: GraphProto, g2: GraphProto, g3: GraphProto) -> None:
+            del g1, g2  # Unused
+
+            assert [elem.name for elem in g3.input] == ["A"]
+            assert [elem.name for elem in g3.output] == ["C"]
+
+        self._test_merge_models(m1_def, m2_def, io_map, check_expectations)
+
+    def test_case_drop_inputs_outputs(self) -> None:
+        """Tests a scenario where we merge two models, not including some of the inputs/outputs"""
+        m1_def = """
+            <
+                ir_version: 7,
+                opset_import: [ "": 10]
+            >
+            agraph (float[N] A0, float[N] B0) => (float[N] A1, float[N] B1)
+            {
+                A1 = Add(A0, A0)
+                B1 = Sub(B0, B0)
+            }
+            """
+        m2_def = """
+            <
+                ir_version: 7,
+                opset_import: [ "": 10]
+            >
+            agraph (float[N] A2, float[N] B2) => (float[N] A3, float[N] B3)
+            {
+                A3 = Add(A2, A2)
+                B3 = Sub(B2, B2)
+            }
+            """
+        io_map = [("A1", "B2")]
+
+        def check_expectations(g1: GraphProto, g2: GraphProto, g3: GraphProto) -> None:
+            del g1, g2  # Unused
+
+            assert [elem.name for elem in g3.input] == ["A0"]
+            assert [elem.name for elem in g3.output] == ["B3"]
+            assert [elem.op_type for elem in g3.node] == ["Add", "Sub"]
+
+        inputs = ["A0"]
+        outputs = ["B3"]
+        self._test_merge_models(
+            m1_def, m2_def, io_map, check_expectations, inputs=inputs, outputs=outputs
+        )
+
+    def test_case_name_collision_prefix(self) -> None:
+        """Tests a scenario where we merge two models that have name collisions, but they
+        are avoided by prefixing the models model.
+        """
+        m1_def = """
+            <
+                ir_version: 7,
+                opset_import: [ "": 10]
+            >
+            agraph (float[N] A, float[N] B) => (float[N] C)
+            {
+                C = Add(A, B)
+            }
+            """
+        io_map = [("C", "A")]
+
+        def check_expectations(g1: GraphProto, g2: GraphProto, g3: GraphProto) -> None:
+            del g1, g2  # Unused
+
+            assert [elem.name for elem in g3.input] == ["m1/A", "m1/B", "m2/B"]
+            assert [elem.name for elem in g3.output] == ["m2/C"]
+            assert [elem.op_type for elem in g3.node] == ["Add", "Add"]
+
+        self._test_merge_models(
+            m1_def, m1_def, io_map, check_expectations, prefix1="m1/", prefix2="m2/"
+        )
+
+    def test_case_connect_partially_no_name_collision(self) -> None:
+        """Tests a scenario where two models without overlapping names are merged by
+        connecting some outputs from the first model to some inputs in the second.
+        The remaining inputs/outputs should be present in the combined model
+        """
+
+        def check_expectations(g1: GraphProto, g2: GraphProto, g4: GraphProto) -> None:
+            del g1, g2  # Unused
+
+            # B20 <-> B21 not connected. They should still be present
+            # in the inputs and outputs of the combined graph
+            assert [elem.name for elem in g4.input] == ["A0", "A1", "_A", "B21"]
+            assert [elem.name for elem in g4.output] == ["B20", "D0"]
+
+        io_map = [("B00", "B01"), ("B10", "B11")]
+        self._test_merge_models(M1_DEF, M2_DEF, io_map, check_expectations)
+
+    def test_merge_models_with_metadata_props(self) -> None:
+        m1 = _load_model(M1_DEF)
+        helper.set_model_props(m1, {"p1": "v1", "p2": "v2"})
+
+        m2 = _load_model(M2_DEF)
+        helper.set_model_props(m2, {"p3": "v3", "p4": "v4"})
+
+        io_map = [("B00", "B01")]
+        m3 = compose.merge_models(m1, m2, io_map=io_map)
+        assert len(m3.metadata_props) == 4
+
+        # Overlap, but same value
+        helper.set_model_props(m2, {"p1": "v1", "p4": "v4"})
+        m3 = compose.merge_models(m1, m2, io_map=io_map)
+        assert len(m3.metadata_props) == 3
+
+        # Same keys but not same value. Error
+        helper.set_model_props(m2, {"p1": "v5", "p4": "v4"})
+        with pytest.raises(ValueError):
+            compose.merge_models(m1, m2, io_map=io_map)
+
+    def test_error_wrong_input_output_name(self) -> None:
+        """Tests that providing a non existing output/input name in the io_map argument produces an error."""
+        m1, m2 = _load_model(M1_DEF), _load_model(M2_DEF)
+
+        with pytest.raises(ValueError):
+            compose.merge_models(
+                m1,
+                m2,
+                io_map=[("wrong_outname", "B01"), ("B10", "B11"), ("B20", "B21")],
+            )
+
+        # Wrong output name
+        with pytest.raises(ValueError):
+            compose.merge_models(
+                m1,
+                m2,
+                io_map=[("B00", "wrong_input"), ("B10", "B11"), ("B20", "B21")],
+            )
+
+    def test_error_ir_version_mismatch(self) -> None:
+        m1 = _load_model(
+            """
+    <
+        ir_version: 7,
+        opset_import: [ "": 13]
+    >
+    agraph (float[N, M] X0) => (float[N, M] Y0)
+    {
+        Y0 = Add(X0, X0)
+    }
+    """
+        )
+
+        m2 = _load_model(
+            """
+    <
+        ir_version: 6,
+        opset_import: [ "": 13]
+    >
+    agraph (float[N, M] X1) => (float[N, M] Y1)
+    {
+        Y1 = Add(X1, X1)
+    }
+    """
+        )
+        # Wrong IR version name
+        with pytest.raises(ValueError):
+            compose.merge_models(m1, m2, io_map=[("Y0", "X1")])
+
+    def test_error_opset_import_mismatch(self) -> None:
+        """Tests that providing models with different operator set imported produces an error."""
+        m1, m2 = _load_model(M1_DEF), _load_model(M2_DEF)
+        m1 = helper.make_model(
+            m1.graph, producer_name="test", opset_imports=[helper.make_opsetid("", 10)]
+        )
+        m2 = helper.make_model(
+            m2.graph, producer_name="test", opset_imports=[helper.make_opsetid("", 15)]
+        )
+
+        io_map = [("B00", "B01"), ("B10", "B11"), ("B20", "B21")]
+        with pytest.raises(ValueError):
+            compose.merge_models(m1, m2, io_map)
+
+        # Converting to the same Operator set version, should work
+        m1 = version_converter.convert_version(m1, 15)
+        m3 = compose.merge_models(m1, m2, io_map=io_map)
+        checker.check_model(m3)
+
+    def test_add_prefix_to_inputs_outputs(self) -> None:
+        """Tests prefixing inputs and outputs nodes."""
+        input_graph = """
+            <
+                ir_version: 6,
+                opset_import: [ "": 13]
+            >
+            agraph (float[N, 128] X, float[128, 10] W, float[10] B) => (float[N, 10] C)
+            {
+                T = MatMul(X, W)
+                S = Add(T, B)
+                C = Softmax(S)
+            }
+            """
+        input_model = _load_model(input_graph)
+        prefix = "pre_"
+        prefixed_model = compose.add_prefix(
+            model=input_model,
+            prefix=prefix,
+            rename_inputs=True,
+            rename_outputs=True,
+            rename_edges=True,
+        )
+
+        checker.check_graph(prefixed_model.graph)
+
+        for i in prefixed_model.graph.input:
+            assert i.name.startswith(prefix)
+        for o in prefixed_model.graph.output:
+            assert o.name.startswith(prefix)
+
+    def test_add_prefix_wo_inputs_outputs(self) -> None:
+        """Tests prefixing input and output nodes, when renaming of inputs/outputs is deactivated."""
+        input_graph = """
+            <
+                ir_version: 6,
+                opset_import: [ "": 13]
+            >
+            agraph (float[2,2] A) => (float[2,2] B)
+            {
+            B = Identity(A)
+            }
+            """
+        input_model = _load_model(input_graph)
+        prefix = "pre_"
+        prefixed_model = compose.add_prefix(
+            model=input_model,
+            prefix=prefix,
+            rename_inputs=False,
+            rename_outputs=False,
+            rename_edges=True,
+        )
+
+        checker.check_graph(prefixed_model.graph)
+        assert input_model.graph.input == prefixed_model.graph.input
+        assert input_model.graph.output == prefixed_model.graph.output
+
+    def test_add_prefix_with_loose_inputs_outputs(self) -> None:
+        """Tests prefixing of graphs with loose inputs."""
+        input_graph = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 13 ]
+            >
+            agraph (bool b, float[128] X, float[128] Y, bool unused_input) => (float[128] Z)
+            {
+            Z = If (b) <
+                then_branch = g1 () => (float[128] z_then) { z_then = Add(X, X) },
+                else_branch = g2 () => (float[128] z_else) { z_else = Sub(Y, Y) }
+                >
+            }
+            """
+        input_model = _load_model(input_graph)
+        prefix = "pre_"
+        prefixed_model = compose.add_prefix(
+            model=input_model,
+            prefix=prefix,
+            rename_inputs=True,
+            rename_outputs=True,
+            rename_edges=True,
+        )
+        checker.check_graph(prefixed_model.graph)
+
+        # Check if all inputs are prefixed even if input is not connected to node. e.g., 'unused_input'.
+        for i in prefixed_model.graph.input:
+            assert i.name.startswith(prefix)
+
+        for graph_output in prefixed_model.graph.output:
+            assert graph_output.name.startswith(prefix)
+
+    def _test_add_prefix(
+        self,
+        rename_nodes: bool = False,
+        rename_edges: bool = False,
+        rename_inputs: bool = False,
+        rename_outputs: bool = False,
+        rename_initializers: bool = False,
+        rename_value_infos: bool = False,
+        inplace: bool = False,
+    ) -> None:
+        m1 = _load_model(M1_DEF)
+
+        prefix = "pre/"
+
+        if inplace:
+            m2 = ModelProto()
+            m2.CopyFrom(m1)
+            compose.add_prefix(
+                m2,
+                prefix,
+                rename_nodes=rename_nodes,
+                rename_edges=rename_edges,
+                rename_inputs=rename_inputs,
+                rename_outputs=rename_outputs,
+                rename_initializers=rename_initializers,
+                rename_value_infos=rename_value_infos,
+                inplace=True,
+            )
+        else:
+            m2 = compose.add_prefix(
+                m1,
+                prefix,
+                rename_nodes=rename_nodes,
+                rename_edges=rename_edges,
+                rename_inputs=rename_inputs,
+                rename_outputs=rename_outputs,
+                rename_initializers=rename_initializers,
+                rename_value_infos=rename_value_infos,
+            )
+        g_in = m1.graph
+        g_out = m2.graph
+
+        if (
+            rename_edges
+            or rename_inputs
+            or rename_outputs
+            or rename_initializers
+            or rename_value_infos
+        ):
+            name_mapping = {}
+
+            # Rename inputs/outputs/edges. Propagate name changes from and to edges
+            if rename_edges:
+                for n in g_in.node:
+                    for e in n.input:
+                        name_mapping[e] = _prefixed(prefix, e)
+                    for e in n.output:
+                        name_mapping[e] = _prefixed(prefix, e)
+            if rename_inputs:
+                for elem in g_in.input:
+                    name_mapping[elem.name] = _prefixed(prefix, elem.name)
+            if rename_outputs:
+                for elem in g_in.output:
+                    name_mapping[elem.name] = _prefixed(prefix, elem.name)
+
+            if rename_initializers:
+                for init in g_in.initializer:
+                    name_mapping[init.name] = _prefixed(prefix, init.name)
+                for sparse_init in g_in.sparse_initializer:
+                    name_mapping[sparse_init.values.name] = _prefixed(
+                        prefix, sparse_init.values.name
+                    )
+                    name_mapping[sparse_init.indices.name] = _prefixed(
+                        prefix, sparse_init.indices.name
+                    )
+
+            if rename_value_infos:
+                for value_info in g_in.output:
+                    name_mapping[value_info.name] = _prefixed(prefix, value_info.name)
+
+            for n1, n0 in zip(g_out.node, g_in.node, strict=True):
+                for e1, e0 in zip(n1.input, n0.input, strict=True):
+                    assert name_mapping.get(e0, e0) == e1
+                for e1, e0 in zip(n1.output, n0.output, strict=True):
+                    assert name_mapping.get(e0, e0) == e1
+            for i1, i0 in zip(g_out.input, g_in.input, strict=True):
+                assert name_mapping.get(i0.name, i0.name) == i1.name
+            for o1, o0 in zip(g_out.output, g_in.output, strict=True):
+                assert name_mapping.get(o0.name, o0.name) == o1.name
+
+            for init1, init0 in zip(g_out.initializer, g_in.initializer, strict=True):
+                assert name_mapping.get(init0.name, init0.name) == init1.name
+
+            for sparse_init1, sparse_init0 in zip(
+                g_out.sparse_initializer, g_in.sparse_initializer, strict=True
+            ):
+                assert (
+                    name_mapping.get(sparse_init0.values.name, sparse_init0.values.name)
+                    == sparse_init1.values.name
+                )
+                assert (
+                    name_mapping.get(
+                        sparse_init0.indices.name, sparse_init0.indices.name
+                    )
+                    == sparse_init1.indices.name
+                )
+
+            for vi1, vi0 in zip(g_out.value_info, g_in.value_info, strict=True):
+                assert name_mapping.get(vi0.name, vi0.name) == vi1.name
+
+            if rename_nodes:
+                for n1, n0 in zip(g_out.node, g_in.node, strict=True):
+                    assert _prefixed(prefix, n0.name) == n1.name
+
+    def test_add_prefix_nodes(self) -> None:
+        """Tests renaming nodes only"""
+        self._test_add_prefix(rename_nodes=True)
+
+    def test_add_prefix_edges(self) -> None:
+        """Tests prefixing nodes edges. This will also rename inputs/outputs, since the names are shared"""
+        self._test_add_prefix(
+            rename_edges=True, rename_inputs=True, rename_outputs=True
+        )
+
+    def test_add_prefix_inputs(self) -> None:
+        """Tests prefixing graph inputs only. Relevant node edges should be renamed as well"""
+        self._test_add_prefix(rename_inputs=True)
+
+    def test_add_prefix_outputs(self) -> None:
+        """Tests prefixing graph outputs only. Relevant node edges should be renamed as well"""
+        self._test_add_prefix(rename_outputs=True)
+
+    def test_add_prefix_attribute_subgraph(self) -> None:
+        """Tests prefixing attribute's subgraph. Relevant subgraph should be renamed as well"""
+        C = helper.make_tensor_value_info("C", TensorProto.BOOL, [1])
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, 1])
+        Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None, 1])
+        Z = helper.make_tensor_value_info("Z", TensorProto.FLOAT, [None, 1])
+        Out = helper.make_tensor_value_info("Out", TensorProto.FLOAT, [None, 1])
+
+        XY = helper.make_node("Mul", inputs=["X", "Y"], outputs=["XY"])
+        add = helper.make_node("Add", inputs=["XY", "Z"], outputs=["Out"])
+        sub = helper.make_node("Sub", inputs=["XY", "Z"], outputs=["Out"])
+
+        cond = helper.make_node(
+            "If",
+            inputs=["C"],
+            outputs=["Out"],
+            then_branch=helper.make_graph(
+                nodes=[add], name="then", inputs=[], outputs=[Out]
+            ),
+            else_branch=helper.make_graph(
+                nodes=[sub], name="else", inputs=[], outputs=[Out]
+            ),
+        )
+        graph = helper.make_graph(
+            nodes=[XY, cond], name="graph", inputs=[C, X, Y, Z], outputs=[Out]
+        )
+        prefix = "prefix."
+        prefixed_graph = compose.add_prefix_graph(graph, prefix)
+        checker.check_graph(prefixed_graph)
+        for n1, n0 in zip(prefixed_graph.node, graph.node, strict=True):
+            assert _prefixed(prefix, n0.name) == n1.name
+            for attribute1, attribute0 in zip(n1.attribute, n0.attribute, strict=True):
+                if attribute1.g:
+                    for subgraph_n1, subgraph_n0 in zip(
+                        attribute1.g.node, attribute0.g.node, strict=True
+                    ):
+                        for input_n1, input_n0 in zip(
+                            subgraph_n1.input, subgraph_n0.input, strict=True
+                        ):
+                            assert _prefixed(prefix, input_n0) == input_n1
+                        for output_n1, output_n0 in zip(
+                            subgraph_n1.output, subgraph_n0.output, strict=True
+                        ):
+                            assert _prefixed(prefix, output_n0) == output_n1
+
+    def test_add_prefix_attribute_multiple_subgraphs(self) -> None:
+        """Tests prefixing attribute's repeated graphs field."""
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [1])
+        Out = helper.make_tensor_value_info("Out", TensorProto.FLOAT, [1])
+
+        g1 = helper.make_graph(
+            [helper.make_node("Identity", ["X"], ["Out"], name="id1")],
+            "g1",
+            [X],
+            [Out],
+        )
+        g2 = helper.make_graph(
+            [helper.make_node("Identity", ["X"], ["Out"], name="id2")],
+            "g2",
+            [X],
+            [Out],
+        )
+        node = helper.make_node(
+            "CustomOp",
+            ["X"],
+            ["Out"],
+            name="custom",
+            bodies=[g1, g2],
+        )
+        graph = helper.make_graph([node], "graph", [X], [Out])
+
+        prefix = "pfx."
+        prefixed = compose.add_prefix_graph(graph, prefix)
+        assert prefixed.node[0].name == _prefixed(prefix, "custom")
+
+        # Verify both subgraphs in the repeated graphs field are prefixed
+        pfx_graphs = prefixed.node[0].attribute[0].graphs
+        assert len(pfx_graphs) == 2
+        for name in ("id1", "id2"):
+            assert any(
+                n.name == _prefixed(prefix, name) for g in pfx_graphs for n in g.node
+            )
+
+    def test_add_prefix_all(self) -> None:
+        """Tests prefixing all names in the graph"""
+        self._test_add_prefix(True, True, True, True, True, True)
+
+    def test_add_prefix_inplace(self) -> None:
+        """Tests prefixing inplace"""
+        self._test_add_prefix(inplace=True)
+
+    def test_expand_out_dim(self) -> None:
+        """Tests expanding output dimensions. The resulting graph should have the same output names,
+        but with one more dimension at the specified index.
+        """
+        m1 = _load_model(M1_DEF)
+
+        def _check_model(m1: ModelProto, m2: ModelProto, dim_idx: int) -> None:
+            for out_g2, out_g1 in zip(m2.graph.output, m1.graph.output, strict=True):
+                assert out_g2.name == out_g1.name
+                assert (
+                    out_g2.type.tensor_type.elem_type
+                    == out_g1.type.tensor_type.elem_type
+                )
+                expected_out_shape = _get_shape(out_g1)
+                expected_out_shape.insert(dim_idx, 1)
+                assert _get_shape(out_g2) == expected_out_shape
+
+        for dim_idx in [0, 2, -1, -3]:
+            m2 = compose.expand_out_dim(m1, dim_idx)
+            _check_model(m1, m2, dim_idx)
+
+        # Test inplace
+        m2 = ModelProto()
+        m2.CopyFrom(m1)
+        dim_idx = 0
+        compose.expand_out_dim(m2, dim_idx, inplace=True)
+        _check_model(m1, m2, dim_idx)
+
+    def _test_overlapping_names(
+        self,
+        inputs0: Sequence[str] = ("i0", "i1"),
+        inputs1: Sequence[str] = ("i2", "i3"),
+        outputs0: Sequence[str] = ("o0", "o1"),
+        outputs1: Sequence[str] = ("o2", "o3"),
+        value_info0: Sequence[str] = ("v0", "v1"),
+        value_info1: Sequence[str] = ("v2", "v3"),
+        initializer0: Sequence[str] = ("init0", "init1"),
+        initializer1: Sequence[str] = ("init2", "init3"),
+        sparse_initializer0: Sequence[str] = ("sparse_init0", "sparse_init1"),
+        sparse_initializer1: Sequence[str] = ("sparse_init2", "sparse_init3"),
+    ) -> None:
+        n0 = [
+            helper.make_node("Identity", inputs=[inputs0[i]], outputs=[outputs0[i]])
+            for i in range(len(inputs0))
+        ]
+        i0 = [
+            helper.make_tensor_value_info(inputs0[i], TensorProto.FLOAT, [])
+            for i in range(len(inputs0))
+        ]
+        o0 = [
+            helper.make_tensor_value_info(outputs0[i], TensorProto.FLOAT, [])
+            for i in range(len(outputs0))
+        ]
+        vi0 = [
+            helper.make_tensor_value_info(value_info0[i], TensorProto.FLOAT, [])
+            for i in range(len(value_info0))
+        ]
+        init0 = [
+            helper.make_tensor(
+                name=initializer0[i], data_type=TensorProto.INT64, dims=(), vals=[1]
+            )
+            for i in range(len(initializer0))
+        ]
+
+        sparse_init0 = [
+            _make_sparse_tensor(sparse_initializer0[i])
+            for i in range(len(sparse_initializer0))
+        ]
+
+        n1 = [
+            helper.make_node("Identity", inputs=[inputs1[i]], outputs=[outputs1[i]])
+            for i in range(len(inputs1))
+        ]
+        i1 = [
+            helper.make_tensor_value_info(inputs1[i], TensorProto.FLOAT, [])
+            for i in range(len(inputs1))
+        ]
+        o1 = [
+            helper.make_tensor_value_info(outputs1[i], TensorProto.FLOAT, [])
+            for i in range(len(outputs1))
+        ]
+        vi1 = [
+            helper.make_tensor_value_info(value_info1[i], TensorProto.FLOAT, [])
+            for i in range(len(value_info1))
+        ]
+        init1 = [
+            helper.make_tensor(
+                name=initializer1[i], data_type=TensorProto.INT64, dims=(), vals=[1]
+            )
+            for i in range(len(initializer1))
+        ]
+        sparse_init1 = [
+            _make_sparse_tensor(sparse_initializer1[i])
+            for i in range(len(sparse_initializer1))
+        ]
+
+        ops = [helper.make_opsetid("", 10)]
+        m0 = helper.make_model(
+            helper.make_graph(
+                nodes=n0,
+                name="g0",
+                inputs=i0,
+                outputs=o0,
+                value_info=vi0,
+                initializer=init0,
+                sparse_initializer=sparse_init0,
+            ),
+            producer_name="test",
+            opset_imports=ops,
+        )
+        m1 = helper.make_model(
+            helper.make_graph(
+                nodes=n1,
+                name="g1",
+                inputs=i1,
+                outputs=o1,
+                value_info=vi1,
+                initializer=init1,
+                sparse_initializer=sparse_init1,
+            ),
+            producer_name="test",
+            opset_imports=ops,
+        )
+
+        overlap = compose.check_overlapping_names(m0.graph, m1.graph)
+        i = 0
+
+        overlapping_inputs = list(set(inputs0) & set(inputs1))
+        overlapping_outputs = list(set(outputs0) & set(outputs1))
+        overlapping_edges = list(set(overlapping_inputs + overlapping_outputs))
+        if overlapping_edges:
+            assert overlap[i] == ("edge", overlapping_edges)
+            i += 1
+
+        overlapping_vis = list(set(value_info0) & set(value_info1))
+        if overlapping_vis:
+            assert overlap[i] == ("value_info", overlapping_vis)
+            i += 1
+
+        overlapping_init = list(set(initializer0) & set(initializer1))
+        if overlapping_init:
+            assert overlap[i] == ("initializer", overlapping_init)
+            i += 1
+
+        overlapping_sparse_init = list(
+            set(sparse_initializer0) & set(sparse_initializer1)
+        )
+        if overlapping_sparse_init:
+            expected_overlap = []
+            for overlapping_name in overlapping_sparse_init:
+                expected_overlap.append(overlapping_name + "_values")
+                expected_overlap.append(overlapping_name + "_idx")
+            assert overlap[i] == ("sparse_initializer", expected_overlap)
+            i += 1
+
+        m0_new = compose.add_prefix(m0, prefix="g0/")
+        overlap = compose.check_overlapping_names(m0_new.graph, m1.graph)
+        assert len(overlap) == 0
+
+    def test_overlapping_input_names(self) -> None:
+        """Tests error checking when the name of the inputs overlaps"""
+        self._test_overlapping_names(inputs0=["i0", "i1"], inputs1=["i1", "i2"])
+
+    def test_overlapping_output_names(self) -> None:
+        """Tests error checking when the name of the output overlaps"""
+        self._test_overlapping_names(outputs0=["o0", "o1"], outputs1=["o1", "o2"])
+
+    def test_overlapping_value_info_names(self) -> None:
+        """Tests error checking when the name of value_info entries overlaps"""
+        self._test_overlapping_names(
+            value_info0=["vi0", "vi1"], value_info1=["vi1", "vi2"]
+        )
+
+    def test_overlapping_initializer_names(self) -> None:
+        """Tests error checking when the name of initializer entries overlaps"""
+        self._test_overlapping_names(
+            initializer0=["init0", "init1"], initializer1=["init1", "init2"]
+        )
+
+    def test_overlapping_sparse_initializer_names(self) -> None:
+        """Tests error checking when the name of sparse_initializer entries overlaps"""
+        self._test_overlapping_names(
+            sparse_initializer0=["sparse_init0", "sparse_init1"],
+            sparse_initializer1=["sparse_init1", "sparse_init2"],
+        )
+
+    def test_overlapping_function_names(self) -> None:
+        """Tests error checking when the name of local function entries overlaps"""
+        ops = [helper.make_opsetid("", 10), helper.make_opsetid("local", 10)]
+
+        def _make_function(
+            domain: str,
+            fname: str,
+            inputs: list[str],
+            outputs: list[str],
+            nodes: list[NodeProto],
+        ) -> FunctionProto:
+            f = FunctionProto()
+            f.domain = domain
+            f.name = fname
+            f.input.extend(inputs)
+            f.output.extend(outputs)
+            f.node.extend(nodes)
+            f.opset_import.extend(ops)
+            return f
+
+        ops = [helper.make_opsetid("", 10), helper.make_opsetid("local", 10)]
+
+        g = GraphProto()
+        g.input.extend(
+            [
+                helper.make_tensor_value_info("x0", TensorProto.FLOAT, []),
+                helper.make_tensor_value_info("x1", TensorProto.FLOAT, []),
+            ]
+        )
+        g.output.extend(
+            [
+                helper.make_tensor_value_info("y", TensorProto.FLOAT, []),
+            ]
+        )
+        g.node.extend(
+            [helper.make_node("f1", domain="local", inputs=["x0", "x1"], outputs=["y"])]
+        )
+
+        g1 = GraphProto()
+        g1.CopyFrom(g)
+        g1.name = "g1"
+        m1 = helper.make_model(g1, producer_name="test", opset_imports=ops)
+        m1.functions.extend(
+            [
+                _make_function(
+                    "local",
+                    "f1",
+                    ["x0", "x1"],
+                    ["y"],
+                    [helper.make_node("Add", inputs=["x0", "x1"], outputs=["y"])],
+                )
+            ]
+        )
+        checker.check_model(m1)
+
+        g2 = GraphProto()
+        g2.CopyFrom(g)
+        g2.name = "g2"
+        m2 = helper.make_model(g2, producer_name="test", opset_imports=ops)
+        m2.functions.extend(
+            [
+                _make_function(
+                    "local",
+                    "f1",
+                    ["x0", "x1"],
+                    ["y"],
+                    [helper.make_node("Mul", inputs=["x0", "x1"], outputs=["y"])],
+                )
+            ]
+        )
+        checker.check_model(m2)
+
+        m = compose.merge_models(
+            m1, m2, io_map=[("y", "x0"), ("y", "x1")], prefix1="m1/", prefix2="m2/"
+        )
+        checker.check_model(m)
+
+        nodes = [n.op_type for n in m.graph.node]
+        assert nodes == ["m1/f1", "m2/f1"]
+
+        functions = [f.name for f in m.functions]
+        assert functions == ["m1/f1", "m2/f1"]
+
+        g3 = GraphProto()
+        g3.CopyFrom(g)
+        g3.name = "g3"
+        g3.node[0].op_type = "f2"
+        m3 = helper.make_model(g3, producer_name="test", opset_imports=ops)
+        m3.functions.extend(
+            [
+                _make_function(
+                    "local",
+                    "f1",
+                    ["x0", "x1"],
+                    ["y"],
+                    [
+                        helper.make_node("Add", inputs=["x0", "x1"], outputs=["y0"]),
+                        helper.make_node("Mul", inputs=["x0", "x1"], outputs=["y1"]),
+                        helper.make_node("Add", inputs=["y0", "y1"], outputs=["y"]),
+                    ],
+                ),
+                _make_function(
+                    "local",
+                    "f2",
+                    ["x0", "x1"],
+                    ["y"],
+                    [
+                        helper.make_node(
+                            "f1", domain="local", inputs=["x0", "x1"], outputs=["y0"]
+                        ),
+                        helper.make_node("Mul", inputs=["x0", "x1"], outputs=["y1"]),
+                        helper.make_node("Add", inputs=["y0", "y1"], outputs=["y"]),
+                    ],
+                ),
+            ]
+        )
+        checker.check_model(m3)
+
+        m = compose.merge_models(
+            m1, m3, io_map=[("y", "x0"), ("y", "x1")], prefix1="m1/", prefix2="m3/"
+        )
+        checker.check_model(m)
+
+        nodes = [n.op_type for n in m.graph.node]
+        assert nodes == ["m1/f1", "m3/f2"]
+
+        functions = [f.name for f in m.functions]
+        assert functions == ["m1/f1", "m3/f1", "m3/f2"]
+
+        assert [n.op_type for n in m.functions[0].node] == ["Add"]
+        assert [n.op_type for n in m.functions[1].node] == ["Add", "Mul", "Add"]
+        assert [n.op_type for n in m.functions[2].node] == ["m3/f1", "Mul", "Add"]
+
+    def test_merge_drop_unnecessary_initializers_and_value_info(self) -> None:
+        """Tests automatic removal of initializers when merging graphs"""
+        ops = [helper.make_opsetid("", 10)]
+
+        g = GraphProto()
+        g.input.extend([helper.make_tensor_value_info("x", TensorProto.FLOAT, [])])
+        g.output.extend([helper.make_tensor_value_info("y", TensorProto.FLOAT, [])])
+        g.node.extend([helper.make_node("Identity", inputs=["x"], outputs=["y"])])
+
+        g1 = GraphProto()
+        g1.CopyFrom(g)
+        g1.name = "g1"
+        m1 = helper.make_model(g1, producer_name="test", opset_imports=ops)
+        checker.check_model(m1)
+
+        g2 = GraphProto()
+        g2.CopyFrom(g)
+        g2.name = "g2"
+        g2.initializer.extend(
+            [
+                helper.make_tensor(
+                    name="x", data_type=TensorProto.FLOAT, dims=(), vals=[0]
+                )
+            ]
+        )
+        m2 = helper.make_model(g2, producer_name="test", opset_imports=ops)
+        checker.check_model(m2)
+
+        g3 = GraphProto()
+        g3.CopyFrom(g)
+        g3.name = "g3"
+        g3.sparse_initializer.extend([_make_sparse_tensor("x")])
+        m3 = helper.make_model(g3, producer_name="test", opset_imports=ops)
+        checker.check_model(m3)
+
+        g4 = GraphProto()
+        g4.CopyFrom(g)
+        g4.name = "g3"
+        g4.value_info.extend(
+            [helper.make_tensor_value_info("x", TensorProto.FLOAT, [])]
+        )
+        m4 = helper.make_model(g4, producer_name="test", opset_imports=ops)
+        checker.check_model(m4)
+
+        # Initializer 'x' from m1 is removed, because there is no longer an input with that name
+        out_m1 = compose.merge_models(m1, m2, prefix1="m1/", io_map=[("y", "x")])
+        assert len(out_m1.graph.initializer) == 0
+
+        # Sparse initializer 'x' from m1 is removed, because there is no longer an input with that name
+        out_m2 = compose.merge_models(m1, m3, prefix1="m1/", io_map=[("y", "x")])
+        assert len(out_m2.graph.initializer) == 0
+
+        # Value info 'x' from m1 is removed, because there is no longer an input with that name
+        out_m3 = compose.merge_models(m1, m4, prefix1="m1/", io_map=[("y", "x")])
+        value_info_names = {vi.name for vi in out_m3.graph.value_info}
+        assert "x" not in value_info_names
+        assert {"m1/y"} == value_info_names
+
+    def test_merge_preserves_mapped_output_value_info(self) -> None:
+        """Mapped outputs should keep their type info as value_info in merged graph."""
+        m1_def = """
+            <
+                ir_version: 7,
+                opset_import: [ "": 10]
+            >
+            g1 (float[N, 32] X) => (float[N, 32] Y)
+            {
+                Y = Identity(X)
+            }
+            """
+        m2_def = """
+            <
+                ir_version: 7,
+                opset_import: [ "": 10]
+            >
+            g2 (float[N, 32] X) => (float[N, 32] Z)
+            {
+                Z = Relu(X)
+            }
+            """
+        m1 = _load_model(m1_def)
+        m2 = _load_model(m2_def)
+        merged = compose.merge_models(m1, m2, io_map=[("Y", "X")])
+        output_names = {o.name for o in merged.graph.output}
+        value_info_by_name = {vi.name: vi for vi in merged.graph.value_info}
+
+        assert "Y" not in output_names
+        assert "Y" in value_info_by_name
+        assert (
+            m1.graph.output[0].SerializeToString()
+            == value_info_by_name["Y"].SerializeToString()
+        )
diff --git a/onnx/test/cpp/checker_test.cc b/onnx/test/cpp/checker_test.cc
new file mode 100644
index 0000000..82da1ab
--- /dev/null
+++ b/onnx/test/cpp/checker_test.cc
@@ -0,0 +1,186 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <filesystem>
+#include <fstream>
+#include <string>
+
+#ifdef _WIN32
+#include <io.h>
+#endif
+
+#include "gtest/gtest.h"
+#include "onnx/checker.h"
+#include "onnx/common/path.h"
+#include "onnx/common/scoped_resource.h"
+
+namespace fs = std::filesystem;
+
+using ONNX_NAMESPACE::ScopedFd;
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+TEST(CHECKER, ValidDataLocationTest) {
+#ifndef ONNX_NO_EXCEPTIONS
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::resolve_external_data_location("localfolder", "..", "tensor_name"),
+      ONNX_NAMESPACE::checker::ValidationError);
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::resolve_external_data_location("localfolder", "/usr/any", "tensor_name"),
+      ONNX_NAMESPACE::checker::ValidationError);
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::resolve_external_data_location("localfolder", "./sub/example", "tensor_name"),
+      ONNX_NAMESPACE::checker::ValidationError);
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::resolve_external_data_location("localfolder", "sub/example", "tensor_name"),
+      ONNX_NAMESPACE::checker::ValidationError);
+#endif
+}
+
+TEST(CHECKER, ValidDataLocationSymLinkTest) {
+#if !defined(ONNX_NO_EXCEPTIONS) && !defined(_WIN32)
+  // Use a temp directory as the base_dir (simulating the model directory).
+  // We pass a relative filename as the location so that the absolute-path
+  // rejection (checker.cc line 986) is NOT triggered, and the is_symlink()
+  // check (checker.cc line 1016) is actually exercised.
+  fs::path modelDir = fs::temp_directory_path() / "onnx_symlink_checker_test";
+  fs::remove_all(modelDir);
+  fs::create_directories(modelDir);
+
+  // Create a regular target file so the symlink has a valid target.
+  fs::path target = modelDir / "target.data";
+  {
+    std::ofstream ofs(target);
+    ofs << "test data";
+  }
+
+  // Create a symlink pointing to the target file.
+  fs::path link = modelDir / "link.data";
+  fs::create_symlink(target, link);
+
+  // Pass relative filename "link.data" — the checker resolves it to
+  // modelDir/link.data and should reject it because it is a symlink.
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::resolve_external_data_location(modelDir.string(), "link.data", "tensor_name"),
+      ONNX_NAMESPACE::checker::ValidationError);
+
+  fs::remove_all(modelDir);
+#endif
+}
+
+TEST(CHECKER, ValidDataLocationParentDirSymLinkTest) {
+#if !defined(ONNX_NO_EXCEPTIONS) && !defined(_WIN32)
+  // Test that symlinks in parent directory components are detected.
+  // A location like "symlink_subdir/real_file.data" where symlink_subdir
+  // is a symlink to an outside directory should be rejected by the
+  // canonical path containment check in checker.cc.
+  fs::path modelDir = fs::temp_directory_path() / "onnx_parent_symlink_test";
+  fs::remove_all(modelDir);
+  fs::create_directories(modelDir);
+
+  // Create a target directory outside the model directory.
+  fs::path outsideDir = fs::temp_directory_path() / "onnx_outside_target";
+  fs::remove_all(outsideDir);
+  fs::create_directories(outsideDir);
+
+  // Create a real file in the outside directory.
+  fs::path targetFile = outsideDir / "secret.data";
+  {
+    std::ofstream ofs(targetFile);
+    ofs << "sensitive data";
+  }
+
+  // Create a directory symlink inside modelDir pointing outside.
+  fs::path symlinkSubdir = modelDir / "subdir";
+  fs::create_directory_symlink(outsideDir, symlinkSubdir);
+
+  // "subdir/secret.data" is a relative path where "subdir" is a symlink.
+  // The canonical path resolves outside modelDir, so this should be rejected.
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::resolve_external_data_location(modelDir.string(), "subdir/secret.data", "tensor_name"),
+      ONNX_NAMESPACE::checker::ValidationError);
+
+  fs::remove_all(modelDir);
+  fs::remove_all(outsideDir);
+#endif
+}
+
+TEST(CHECKER, OpenExternalDataTest) {
+#ifndef ONNX_NO_EXCEPTIONS
+  // Use a UTF-8 directory name (raw bytes for C++20 char8_t compat).
+  fs::path dir = fs::temp_directory_path() / utf8_to_path("\xe6\xa8\xa1\xe5\x9e\x8b_onnx_open_test");
+  fs::remove_all(dir);
+  fs::create_directories(dir);
+  std::string dir_utf8 = path_to_utf8(dir);
+
+  // Read existing file (UTF-8 filename)
+  std::string utf8_file = "\xe3\x83\x86\xe3\x83\xb3\xe3\x82\xbd\xe3\x83\xab.bin";
+  {
+    std::ofstream ofs(dir / utf8_to_path(utf8_file), std::ios::binary);
+    ofs << "data";
+  }
+  auto raw = ONNX_NAMESPACE::checker::open_external_data(dir_utf8, utf8_file, "t", true);
+  ASSERT_GE(raw, 0);
+  {
+    ScopedFd fd(static_cast<int>(raw));
+    ASSERT_GE(fd.get(), 0);
+    char buf[4];
+#ifdef _WIN32
+    EXPECT_EQ(_read(fd.get(), buf, 4), 4);
+#else
+    EXPECT_EQ(read(fd.get(), buf, 4), 4);
+#endif
+    EXPECT_EQ(std::string(buf, 4), "data");
+  } // fd closed by ScopedFd
+
+  // Write creates new file
+  raw = ONNX_NAMESPACE::checker::open_external_data(dir_utf8, "new.bin", "t", false);
+  ASSERT_GE(raw, 0);
+  {
+    ScopedFd fd(static_cast<int>(raw));
+    ASSERT_GE(fd.get(), 0);
+  } // fd closed by ScopedFd
+  EXPECT_TRUE(fs::exists(dir / "new.bin"));
+
+  // Reject invalid locations
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::open_external_data(dir_utf8, "missing.bin", "t", true),
+      ONNX_NAMESPACE::checker::ValidationError);
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::open_external_data(dir_utf8, "/etc/passwd", "t", true),
+      ONNX_NAMESPACE::checker::ValidationError);
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::open_external_data(dir_utf8, "../escape", "t", true),
+      ONNX_NAMESPACE::checker::ValidationError);
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::open_external_data(dir_utf8, ".", "t", false), ONNX_NAMESPACE::checker::ValidationError);
+  // UTF-8 traversal
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::open_external_data(
+          dir_utf8, "../\xe3\x83\x86\xe3\x83\xb3\xe3\x82\xbd\xe3\x83\xab.bin", "t", true),
+      ONNX_NAMESPACE::checker::ValidationError);
+
+#ifndef _WIN32
+  // Symlink to outside directory
+  fs::path outside = fs::temp_directory_path() / "onnx_open_ext_outside";
+  fs::remove_all(outside);
+  fs::create_directories(outside);
+  {
+    std::ofstream ofs(outside / "secret.data", std::ios::binary);
+    ofs << "secret";
+  }
+  fs::create_symlink(outside / "secret.data", dir / "link.data");
+  EXPECT_THROW(
+      ONNX_NAMESPACE::checker::open_external_data(dir_utf8, "link.data", "t", true),
+      ONNX_NAMESPACE::checker::ValidationError);
+  fs::remove_all(outside);
+#endif
+
+  fs::remove_all(dir);
+#endif
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/data_propagation_test.cc b/onnx/test/cpp/data_propagation_test.cc
new file mode 100644
index 0000000..72bdd1b
--- /dev/null
+++ b/onnx/test/cpp/data_propagation_test.cc
@@ -0,0 +1,412 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+#include <unordered_map>
+
+#include "gtest/gtest.h"
+#include "onnx/defs/parser.h"
+#include "onnx/defs/schema.h"
+#include "onnx/shape_inference/implementation.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+static bool CompareShape(
+    const TensorShapeProto& inferredShape,
+    const TensorShapeProto& expectedShape,
+    bool checkSameParam = false) {
+  EXPECT_EQ(inferredShape.dim_size(), expectedShape.dim_size())
+      << "Dim size for inferred and expected shape is different.";
+
+  for (int i = 0; i < inferredShape.dim_size(); i++) {
+    EXPECT_TRUE(
+        (inferredShape.dim(i).has_dim_value() == expectedShape.dim(i).has_dim_value()) &&
+        (inferredShape.dim(i).has_dim_param() == expectedShape.dim(i).has_dim_param()))
+        << "Inferred and expected dim values are different.";
+
+    EXPECT_TRUE(
+        inferredShape.dim(i).has_dim_value() ? inferredShape.dim(i).dim_value() == expectedShape.dim(i).dim_value()
+            : checkSameParam                 ? inferredShape.dim(i).dim_param() == expectedShape.dim(i).dim_param()
+                                             : true)
+        << "Inferred and expected dims are different.";
+  }
+
+  return true;
+}
+
+static TensorShapeProto RunDataPropagation(const char* graphCode, int domainVersion = 15) {
+  // Parses the graph from graphCode
+  GraphProto graph;
+  OnnxParser parser(graphCode);
+  auto status = parser.Parse(graph);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+  EXPECT_TRUE(parser.EndOfInput()) << "Extra unparsed input unexpected.";
+
+  // Constructs name to TypeProto map from value_info, input, output
+  std::unordered_map<std::string, TypeProto*> valueTypesByName;
+  for (auto& vi : *graph.mutable_value_info()) {
+    if (vi.has_type()) {
+      valueTypesByName[vi.name()] = vi.mutable_type();
+    }
+  }
+  for (auto& vi : *graph.mutable_input()) {
+    if (vi.has_type()) {
+      valueTypesByName[vi.name()] = vi.mutable_type();
+    }
+  }
+  for (auto& vi : *graph.mutable_output()) {
+    if (vi.has_type()) {
+      valueTypesByName[vi.name()] = vi.mutable_type();
+    }
+  }
+
+  // Constructs name to TensorProto map from initializer
+  std::unordered_map<std::string, const TensorProto*> inputDataByName;
+  for (const auto& tp : graph.initializer()) {
+    inputDataByName[tp.name()] = &tp;
+  }
+  // Collects data from constant nodes
+  for (const auto& n : graph.node()) {
+    if (n.op_type() != "Constant" || n.output().size() != 1) {
+      continue;
+    }
+    for (const auto& attr : n.attribute()) {
+      if (attr.name() == "value") {
+        if (attr.type() == AttributeProto::TENSOR && attr.has_t()) {
+          inputDataByName[n.output(0)] = &attr.t();
+        }
+      }
+    }
+  }
+
+  // Runs data propagation on each node
+  std::unordered_map<std::string, TensorShapeProto> generatedShapeDataByName;
+  auto* schemaRegistry = OpSchemaRegistry::Instance();
+  TensorShapeProto inferredShape;
+  for (auto n : graph.node()) {
+    // No need to run data propagation on Constant
+    if (n.op_type() == "Constant") {
+      continue;
+    }
+    shape_inference::DataPropagationContextImpl dataPropagationCtx(
+        n, valueTypesByName, inputDataByName, generatedShapeDataByName);
+    const auto* const schema = schemaRegistry->GetSchema(n.op_type(), domainVersion, n.domain());
+    EXPECT_TRUE(schema->has_data_propagation_function());
+    schema->GetDataPropagationFunction()(dataPropagationCtx);
+  }
+
+  // Assuming the graph being tested only has 1 output.
+  // If this ever changes then fixes are required here.
+  const auto inputShapeDataIter = generatedShapeDataByName.find(graph.output(0).name());
+  EXPECT_TRUE(inputShapeDataIter != generatedShapeDataByName.cend());
+
+  inferredShape.CopyFrom(inputShapeDataIter->second);
+
+  // Returns the partial shape data for output
+  return inferredShape;
+}
+
+TEST(DataPropagationImplTest, ShapeTest) {
+  const char* code = R"ONNX(
+agraph (int32[7,4,1] x) => (int32[3] y)
+{
+    xs = Shape(x)
+    y = Cast<to = 7>(xs)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(7);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(4);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(1);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, SymbolicShapeTest) {
+  const char* code = R"ONNX(
+agraph (int32[N,3,256,256] x) => (int32[4] y)
+{
+    xs = Shape(x)
+    y = Cast<to = 7>(xs)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_param("N");
+  expected_tsp.mutable_dim()->Add()->set_dim_value(3);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(256);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(256);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp, true));
+}
+
+TEST(DataPropagationImplTest, CastTest) {
+  const char* code = R"ONNX(
+agraph (int32[2,5] x) => (int32[2] y)
+{
+    xs = Shape(x)
+    y = Cast<to = 7>(xs)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(2);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(5);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, SqueezeTest) {
+  const char* code = R"ONNX(
+agraph (int32[2,5] x) => (int32[2] z)
+{
+    xs = Shape(x)
+    y = Squeeze(xs)
+    z = Cast<to = 7>(y)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(2);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(5);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, UnsqueezeTest) {
+  const char* code = R"ONNX(
+agraph (int32[2,5] x) => (int32[1,2] w)
+{
+    xs = Shape(x)
+    axis = Constant<value = int64[1] {1}>()
+    z = Unsqueeze(xs, axis)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(2);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(5);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, SizeTest) {
+  const char* code = R"ONNX(
+agraph (int64[1] x) => (int32[1] w)
+<int64[3] init = {2,3,5}>
+{
+    z = Size(init)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(3);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, AddTest) {
+  const char* code = R"ONNX(
+agraph (int32[2,4,5] x, int32[2,4,5] y) => (int32[3] w)
+{
+    xs = Shape(x)
+    ys = Shape(y)
+    z = Add(xs, ys)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(4);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(8);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(10);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, AddSymbolicShapeTest) {
+  const char* code = R"ONNX(
+agraph (int32[2,4,5] x, int32[2,4,M] y) => (int32[3] w)
+{
+    xs = Shape(x)
+    ys = Shape(y)
+    z = Add(xs, ys)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  // Add({2,4,5}, {2,4,M}) = {4,8,?}
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(4);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(8);
+  // Not computable so do not set value or param
+  expected_tsp.mutable_dim()->Add();
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, SubTest) {
+  const char* code = R"ONNX(
+agraph (int32[10,11,6] x, int32[5] y) => (int32[3] w)
+{
+    xs = Shape(x)
+    ys = Shape(y)
+    z = Sub(xs, ys)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(5);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(6);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(1);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, MulTest) {
+  const char* code = R"ONNX(
+agraph (int32[2] x, int32[5,1,7] y) => (int32[3] w)
+{
+    xs = Shape(x)
+    ys = Shape(y)
+    z = Mul(xs, ys)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(10);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(2);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(14);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, ConcatTest) {
+  const char* code = R"ONNX(
+agraph (int32[1,2] x, int32[3,4] y) => (int32[4] w)
+{
+    xs = Shape(x)
+    ys = Shape(y)
+    z = Concat<axis = 0>(xs, ys)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(1);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(2);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(3);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(4);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, DynamicConcatTest) {
+  const char* code = R"ONNX(
+agraph (float[32, 1024] x, int64[2] dynamic_shape) => (int64[4] z)
+{
+    xs = Shape(x)   # [32, 1024]
+    z = Concat<axis = 0>(xs, dynamic_shape)  # [32, 1024, ?, ?]
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(32);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(1024);
+  expected_tsp.mutable_dim()->Add();
+  expected_tsp.mutable_dim()->Add();
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, GatherTest) {
+  const char* code = R"ONNX(
+agraph (int32[1,2,3,4,5,6] x) => (int32[3] w)
+{
+    xs = Shape(x)
+    indices = Constant<value = int64[3] {0,3,5}>()
+    z = Gather<axis = 0>(xs, indices)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(1);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(4);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(6);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, GatherNegativeIndicesTest) {
+  const char* code = R"ONNX(
+agraph (int32[1,2,3,4,5,6] x) => (int32[2] w)
+{
+    xs = Shape(x)
+    indices = Constant<value = int64[2] {-2,-1}>()
+    z = Gather<axis = 0>(xs, indices)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(5);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(6);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, SliceTest) {
+  const char* code = R"ONNX(
+agraph (int32[1,2,3,4,5,6,7,8] x) => (int32[2] w)
+{
+    xs = Shape(x)
+    starts = Constant<value = int64[1] {1}>()
+    ends = Constant<value = int64[1] {7}>()
+    axes = Constant<value = int64[1] {0}>()
+    steps = Constant<value = int64[1] {3}>()
+    z = Slice(xs, starts, ends, axes, steps)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(2);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(5);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, SliceDefaultAxesAndStepTest) {
+  const char* code = R"ONNX(
+agraph (int32[1,2,3,4,5,6,7,8] x) => (int32[3] w)
+{
+    xs = Shape(x)
+    starts = Constant<value = int64[1] {2}>()
+    ends = Constant<value = int64[1] {5}>()
+    z = Slice(xs, starts, ends)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(3);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(4);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(5);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+TEST(DataPropagationImplTest, SliceNegativeStartEndStepTest) {
+  const char* code = R"ONNX(
+agraph (int32[1,2,3,4,5,6,7,8] x) => (int32[3] w)
+{
+    xs = Shape(x)
+    starts = Constant<value = int64[1] {-3}>()
+    ends = Constant<value = int64[1] {-7}>()
+    axes = Constant<value = int64[1] {0}>()
+    steps = Constant<value = int64[1] {-2}>()
+    z = Slice(xs, starts, ends, axes, steps)
+    w = Cast<to = 7>(z)
+}
+)ONNX";
+  TensorShapeProto expected_tsp;
+  expected_tsp.mutable_dim()->Add()->set_dim_value(6);
+  expected_tsp.mutable_dim()->Add()->set_dim_value(4);
+  const auto propagated_tsp = RunDataPropagation(code);
+  EXPECT_TRUE(CompareShape(propagated_tsp, expected_tsp));
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/function_context_test.cc b/onnx/test/cpp/function_context_test.cc
new file mode 100644
index 0000000..795d532
--- /dev/null
+++ b/onnx/test/cpp/function_context_test.cc
@@ -0,0 +1,281 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "onnx/checker.h"
+#include "onnx/common/constants.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+// Utilities. TODO: Turn them into reusable ONNX utilities for use by
+
+static TensorProto ToTensor(double value, TensorProto_DataType elem_type) {
+  TensorProto t;
+  t.set_data_type(elem_type);
+  switch (elem_type) {
+    case TensorProto_DataType::TensorProto_DataType_FLOAT:
+      t.add_float_data(static_cast<float>(value));
+      break;
+    case TensorProto_DataType::TensorProto_DataType_DOUBLE:
+      t.add_double_data(value);
+      break;
+    // case TensorProto_DataType::TensorProto_DataType_FLOAT16:
+    //   t.add_int32_data(onnxruntime::math::floatToHalf((float)value));
+    //   break;
+    default:
+      assert(false);
+  }
+
+  return t;
+}
+
+static void BuildNodes(FunctionProto& functionProto, const std::vector<FunctionBodyHelper::NodeDef>& node_defs) {
+  for (const auto& node : node_defs) {
+    auto* np = functionProto.add_node();
+
+    np->set_op_type(node.op_type);
+    for (const auto& inp : node.inputs) {
+      np->add_input(inp);
+    }
+    for (const auto& o : node.outputs) {
+      np->add_output(o);
+    }
+    for (const auto& attr : node.attributes) {
+      *(np->add_attribute()) = attr.proto;
+    }
+  }
+}
+
+static bool BuildFunctionProto(
+    FunctionProto& functionProto,
+    const OpSchema& schema,
+    const std::vector<FunctionBodyHelper::NodeDef>& node_defs) {
+  BuildNodes(functionProto, node_defs);
+  schema.BuildFunction(functionProto);
+  return true;
+}
+
+// A monomorphic context-dependent function test-case.
+static bool
+BuildFloatFunctionBody(const FunctionBodyBuildContext& /*ctx*/, const OpSchema& schema, FunctionProto& functionProto) {
+  // Create a scalar-tensor constant 2.0 of float type:
+  auto two_as_tensor = ToTensor(2.0, TensorProto_DataType::TensorProto_DataType_FLOAT);
+
+  std::vector<FunctionBodyHelper::NodeDef> body{
+      // nodes: {outputs, op, inputs, attributes}
+      {{"Two"}, "Constant", {}, {{"value", two_as_tensor}}},
+      {{"Y"}, "Mul", {"X", "Two"}}};
+
+  return BuildFunctionProto(functionProto, schema, body);
+}
+
+static void RegisterCustomFuncFloatSchema() {
+  ONNX_NAMESPACE::OpSchema schema;
+  schema.SetName("CustomFuncFloat")
+      .SetDomain(ONNX_DOMAIN)
+      .SinceVersion(12)
+      .SetDoc("This operator returns an output tensor that is twice the input tensor.")
+      .Input(0, "X", "Input tensor", "T", OpSchema::Single)
+      .Output(0, "Y", "Output tensor", "T", OpSchema::Single)
+      .TypeConstraint("T", {"tensor(float)"}, "Type of the input and output values")
+      .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+      .SetContextDependentFunctionBodyBuilder(BuildFloatFunctionBody);
+  ONNX_NAMESPACE::OpSchemaRegistry::OpSchemaRegisterOnce unused(schema);
+  (void)unused;
+}
+
+// Test for Context dependent function without type context
+TEST(FunctionAPITest, ContextDependentFunctionTest) {
+  RegisterCustomFuncFloatSchema();
+
+  const auto* const schema = OpSchemaRegistry::Schema("CustomFuncFloat", 12, ONNX_DOMAIN);
+  EXPECT_TRUE(schema);
+  EXPECT_FALSE(schema->HasFunction());
+  EXPECT_TRUE(schema->HasContextDependentFunction());
+
+  NodeProto nodeProto;
+  nodeProto.set_op_type("CustomFuncFloat");
+  nodeProto.add_input("X");
+  nodeProto.add_output("Y");
+
+  FunctionBodyBuildContextImpl ctx(nodeProto);
+  FunctionProto fnProto;
+  EXPECT_TRUE(schema->BuildContextDependentFunction(ctx, fnProto));
+  EXPECT_EQ(fnProto.node_size(), 2);
+
+  checker::LexicalScopeContext lexicalScope;
+  checker::CheckerContext checkerCtx;
+  std::unordered_map<std::string, int> opset_imports({{ONNX_DOMAIN, 12}});
+  checkerCtx.set_opset_imports(opset_imports);
+  checkerCtx.set_ir_version(7);
+  checker::check_function(fnProto, checkerCtx, lexicalScope);
+}
+
+// A polymorphic context-dependent function test-case.
+
+static bool
+BuildFunctionBody(const FunctionBodyBuildContext& ctx, const OpSchema& schema, FunctionProto& functionProto) {
+  // Create a scalar-tensor constant 2.0 of input-type:
+  const auto* const tp = ctx.getInputType(0);
+  if ((tp == nullptr) || (!tp->has_tensor_type()))
+    return false;
+  auto elem_type = static_cast<TensorProto_DataType>(tp->tensor_type().elem_type());
+  auto two_as_tensor = ToTensor(2.0, elem_type);
+
+  std::vector<FunctionBodyHelper::NodeDef> body{
+      // nodes: {outputs, op, inputs, attributes}
+      {{"Two"}, "Constant", {}, {{"value", two_as_tensor}}},
+      {{"Y"}, "Mul", {"X", "Two"}}};
+
+  return BuildFunctionProto(functionProto, schema, body);
+}
+
+static void RegisterCustomFunctionSchema() {
+  ONNX_NAMESPACE::OpSchema schema;
+  schema.SetName("CustomFunction")
+      .SetDomain(ONNX_DOMAIN)
+      .SinceVersion(12)
+      .SetDoc("This operator returns an output tensor that is twice the input tensor.")
+      .Input(0, "X", "Input tensor", "T", OpSchema::Single)
+      .Output(0, "Y", "Output tensor", "T", OpSchema::Single)
+      .TypeConstraint("T", {"tensor(float)", "tensor(double)"}, "Type of the input and output values")
+      .SetNodeDeterminism(OpSchema::NodeDeterminism::Deterministic)
+      .SetContextDependentFunctionBodyBuilder(BuildFunctionBody);
+  ONNX_NAMESPACE::OpSchemaRegistry::OpSchemaRegisterOnce unused(schema);
+  (void)unused;
+}
+
+TEST(FunctionAPITest, VersionedFunctionBodyTest) {
+  // This test illustrate issues of ONNX function ops.
+  // It is over simplified in that only one primary op (Sub) is used in function body.
+  // ONNX opset     1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18
+  // MySub:            2                    9                               // MySub function op is created at opset 2.
+  //                                                                        // Its semantic is updated at opset 7
+  // Body Ideal:       2           6  7     9          13 14    16          // Ideally function body shall be provided
+  //                                                                        // each time there is any version bump of
+  //                                                                        // used primary ops. It will be more
+  //                                                                        // frequent
+  //                                                                        // if more primary ops are used.
+  // Body Real:        2                    9                   16          // In real life, we seldom add function body
+  //                                                                        // due to primary op update
+  // Sub:           1              6  7                13 14                // Version bumps of Sub
+  // Model:            y  y  y  y  n  n  n  y  y  y  y n  n  n  y  y  y     // Model can(y)/cannot(n) used
+  // with opset import version.
+  ONNX_NAMESPACE::OpSchema schema_ver2;
+  schema_ver2.SetName("MySub")
+      .SetDomain(ONNX_DOMAIN)
+      .SinceVersion(2)
+      .SetDoc("Z = Sub (X, Y)")
+      .Input(0, "X", "Input tensor X", "T", OpSchema::Single)
+      .Input(1, "Y", "Input tensor Y", "T", OpSchema::Single)
+      .Output(0, "Z", "Output tensor Z", "T", OpSchema::Single)
+      .TypeConstraint("T", {"tensor(float)", "tensor(double)"}, "Type of the input and output values")
+      .FunctionBody(
+          R"ONNX(
+        {
+          Z = Sub (X, Y)
+        }
+        )ONNX",
+          2);
+
+  ONNX_NAMESPACE::OpSchema schema_ver9;
+  schema_ver9.SetName("MySub")
+      .SetDomain(ONNX_DOMAIN)
+      .SinceVersion(9)
+      .SetDoc("Z = Sub (X, Y)")
+      .Input(0, "X", "Input tensor X", "T", OpSchema::Single)
+      .Input(1, "Y", "Input tensor Y", "T", OpSchema::Single)
+      .Output(0, "Z", "Output tensor Z", "T", OpSchema::Single)
+      .TypeConstraint("T", {"tensor(float)", "tensor(double)"}, "Type of the input and output values")
+      .FunctionBody(
+          R"ONNX(
+        {
+          Z = Sub (X, Y)
+        }
+        )ONNX",
+          9)
+      .FunctionBody(
+          R"ONNX(
+        {
+          Z = Sub (X, Y)
+        }
+        )ONNX",
+          16);
+
+  ONNX_NAMESPACE::OpSchemaRegistry::OpSchemaRegisterOnce unused2(schema_ver2);
+  (void)unused2;
+  ONNX_NAMESPACE::OpSchemaRegistry::OpSchemaRegisterOnce unused9(schema_ver9);
+  (void)unused9;
+
+  const auto* const schema2 = OpSchemaRegistry::Schema("MySub", 2, ONNX_DOMAIN);
+  EXPECT_TRUE(schema2);
+  for (int model_opset_import = 2; model_opset_import < 9; model_opset_import++) {
+    ONNX_TRY {
+      bool validate = true;
+      const FunctionProto* function = schema2->GetFunction(model_opset_import, validate);
+      if (model_opset_import >= 6) { // function body should be updated at opset 6 where Sub is updated
+        ASSERT_TRUE(function == nullptr);
+      } else {
+        ASSERT_TRUE(function);
+      }
+    }
+    ONNX_CATCH(const std::runtime_error&) {
+      ONNX_HANDLE_EXCEPTION(
+          [&]() { ASSERT_TRUE(model_opset_import == 6 || model_opset_import == 7 || model_opset_import == 8); });
+    }
+  }
+
+  const auto* const schema9 = OpSchemaRegistry::Schema("MySub", 9, ONNX_DOMAIN);
+  EXPECT_TRUE(schema9);
+  for (int model_opset_import = 9; model_opset_import < 10; model_opset_import++) {
+    ONNX_TRY {
+      const FunctionProto* function = schema9->GetFunction(model_opset_import);
+      ASSERT_TRUE(function);
+    }
+    ONNX_CATCH(const std::runtime_error&) {
+      ONNX_HANDLE_EXCEPTION(
+          [&]() { ASSERT_TRUE(model_opset_import == 13 || model_opset_import == 14 || model_opset_import == 15); });
+    }
+  }
+}
+
+TEST(FunctionAPITest, TypeContextTest) {
+  RegisterCustomFunctionSchema();
+
+  const auto* const schema = OpSchemaRegistry::Schema("CustomFunction", 12, ONNX_DOMAIN);
+  EXPECT_TRUE(schema);
+  EXPECT_FALSE(schema->HasFunction());
+  EXPECT_TRUE(schema->HasContextDependentFunction());
+
+  NodeProto nodeProto;
+  nodeProto.set_op_type("CustomFunction");
+  nodeProto.add_input("X");
+  nodeProto.add_output("Y");
+
+  TypeProto floatTypeProto;
+  floatTypeProto.mutable_tensor_type()->set_elem_type(TensorProto_DataType::TensorProto_DataType_FLOAT);
+
+  FunctionBodyBuildContextImpl ctx(nodeProto, {floatTypeProto});
+  FunctionProto fnProto;
+  EXPECT_TRUE(schema->BuildContextDependentFunction(ctx, fnProto));
+  EXPECT_EQ(fnProto.node_size(), 2);
+
+  checker::LexicalScopeContext lexicalScope;
+  checker::CheckerContext checkerCtx;
+  std::unordered_map<std::string, int> opset_imports({{ONNX_DOMAIN, 12}});
+  checkerCtx.set_opset_imports(opset_imports);
+  checkerCtx.set_ir_version(7);
+  checker::check_function(fnProto, checkerCtx, lexicalScope);
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/function_get_test.cc b/onnx/test/cpp/function_get_test.cc
new file mode 100644
index 0000000..2a257bd
--- /dev/null
+++ b/onnx/test/cpp/function_get_test.cc
@@ -0,0 +1,47 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <iostream>
+
+#include "gtest/gtest.h"
+#include "onnx/common/constants.h"
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+TEST(FunctionAPITest, GetFunctionOpWithVersion) {
+  const auto* const schema = OpSchemaRegistry::Schema("MeanVarianceNormalization", 9, "");
+  EXPECT_TRUE(schema);
+  EXPECT_TRUE(schema->HasFunction());
+  const auto* const func = schema->GetFunction();
+  EXPECT_EQ(func->name(), "MeanVarianceNormalization");
+}
+
+TEST(FunctionAPITest, GetMeanVarianceNormalizationFunctionWithVersion) {
+  {
+    const auto* const schema = OpSchemaRegistry::Schema("MeanVarianceNormalization", 13, "");
+    EXPECT_TRUE(schema);
+    EXPECT_TRUE(schema->HasFunction());
+    const auto* const func = schema->GetFunction();
+    EXPECT_EQ(func->name(), "MeanVarianceNormalization");
+  }
+  {
+    const auto* const schema = OpSchemaRegistry::Schema("MeanVarianceNormalization", 17, "");
+    EXPECT_TRUE(schema);
+    EXPECT_TRUE(schema->HasFunction());
+    const auto* const func = schema->GetFunction();
+    EXPECT_EQ(func->name(), "MeanVarianceNormalization");
+  }
+  {
+    const auto* const schema = OpSchemaRegistry::Schema("MeanVarianceNormalization", 18, "");
+    EXPECT_TRUE(schema);
+    EXPECT_TRUE(schema->HasFunction());
+    const auto* const func = schema->GetFunction();
+    EXPECT_EQ(func->name(), "MeanVarianceNormalization");
+  }
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/function_verify_test.cc b/onnx/test/cpp/function_verify_test.cc
new file mode 100644
index 0000000..15b7ece
--- /dev/null
+++ b/onnx/test/cpp/function_verify_test.cc
@@ -0,0 +1,568 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <algorithm>
+#include <iostream>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "onnx/checker.h"
+#include "onnx/common/constants.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/parser.h"
+#include "onnx/defs/printer.h"
+#include "onnx/defs/schema.h"
+#include "onnx/shape_inference/implementation.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+using TENSOR_TYPES_MAP = std::unordered_map<std::string, std::vector<std::string>>;
+
+static void GetFunctionProtoOpsetImport(
+    const OpSchema& op,
+    const FunctionProto* function_proto,
+    std::unordered_map<std::string, int>& op_set) {
+  if (function_proto->opset_import_size() > 0) {
+    for (const auto& opset_import : function_proto->opset_import()) {
+      op_set.insert({opset_import.domain(), opset_import.version()});
+    }
+  } else {
+    op_set.insert({op.domain(), op.since_version()});
+  }
+}
+
+static void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* function_proto, int& counter) {
+  // This is a simple partial type-checker for a function-body.
+  // TODO(ONNX): Revisit to make the type-checker more complete.
+  TENSOR_TYPES_MAP tc_map;
+  std::set<std::string> primitive_types(OpSchema::all_tensor_types().begin(), OpSchema::all_tensor_types().end());
+  for (const auto& input : function_op.inputs()) {
+    const std::string& name = input.GetName();
+    auto& tvec = tc_map[name];
+    for (const auto& t : input.GetTypes()) {
+      tvec.emplace_back(*t);
+    }
+  }
+
+  for (const auto& output : function_op.outputs()) {
+    const std::string& name = output.GetName();
+    auto& tvec = tc_map[name];
+    for (const auto& t : output.GetTypes()) {
+      tvec.emplace_back(*t);
+    }
+  }
+
+  std::unordered_map<std::string, int> op_set;
+  GetFunctionProtoOpsetImport(function_op, function_proto, op_set);
+
+  for (const auto& node : function_proto->node()) {
+    const std::string& op_type = node.op_type();
+    std::unordered_map<std::string, int>::const_iterator it = op_set.find(node.domain());
+    if (it == op_set.end()) {
+      fail_check(
+          "Op " + op_type + " of domain " + node.domain() + " used in " + function_op.Name() +
+          " function body does not has a opset import.");
+    }
+
+    int opset_version = it->second;
+    const OpSchema* schema = OpSchemaRegistry::Schema(op_type, opset_version, node.domain());
+
+    // Check that the types of actual inputs, if known, are legal as per schema
+    // of called op:
+    auto num_formal_inputs = static_cast<size_t>(schema->inputs().size());
+    auto num_actual_inputs = static_cast<size_t>(node.input_size());
+
+    for (size_t i = 0; i < num_actual_inputs; ++i) {
+      const auto& actual_param_name = node.input(static_cast<int>(i));
+      auto iter = tc_map.find(actual_param_name);
+      if (iter != tc_map.end()) {
+        // if i >= num_formal_inputs, it is a variadic parameter corresponding
+        // to the last formal parameter.
+        auto formal_i = std::min(i, num_formal_inputs - 1);
+        const auto& types = schema->inputs().at(formal_i).GetTypes();
+        std::unordered_set<std::string> allowed_types;
+        for (const auto& s : types) {
+          allowed_types.insert(*s);
+        }
+        for (auto& actual_type : iter->second) {
+          if (allowed_types.find(actual_type) == allowed_types.end()) {
+            fail_check(
+                "Input type ",
+                actual_type,
+                " of parameter ",
+                actual_param_name + " of function ",
+                function_op.Name(),
+                " is not allowed by operator ",
+                op_type);
+          }
+        }
+      }
+    }
+
+    // No simple check exists for outputs: we need to integrate type inference
+    // to identify the possible output types and verify that they are included
+    // in the function-schema.
+  }
+
+  ++counter;
+}
+
+// Testing the function-definitions provided for function-ops in ONNX schema registry.
+// We type-check the function-definition for all possible input-typings, as permitted
+// by the op-schema. Since the type-checking is dependent on attribute-values, we specify
+// the attribute-values for which we want to do the testing down below.
+
+// The set of attribute-values (for testing a function) is represented using a vector.
+using AttributeValues = std::vector<AttributeProto>;
+
+namespace {
+
+// FunctionOpAttributeMap: Used to implement a map from OpSchema to a set of AttributeValues
+// (implemented as a vector). The testing will be done for each attribute-values specified.
+
+struct FunctionOpAttributeMap {
+  std::unordered_map<std::string, std::vector<AttributeValues>> map;
+
+  std::string key(const std::string& domain, const std::string& opname, int opset_version) const {
+    return domain + ":" + opname + ":" + std::to_string(opset_version);
+  }
+
+  void addTestCase(const std::string& opname, int opset_version, std::initializer_list<const char*> attributes) {
+    auto& schema_test_cases = map[key("", opname, opset_version)];
+    schema_test_cases.emplace_back();
+    auto& test_case = schema_test_cases.back();
+    for (const auto* const attr_text : attributes) {
+      test_case.emplace_back();
+      OnnxParser::Parse(test_case.back(), attr_text);
+    }
+  }
+
+  FunctionOpAttributeMap() {
+    addTestCase("Elu", 6, {"alpha = 1.0"});
+    addTestCase("LeakyRelu", 16, {"alpha = 0.1"});
+    addTestCase("HardSigmoid", 6, {"alpha = 0.2", "beta=0.5"});
+    addTestCase("Selu", 6, {"alpha = 1.6", "gamma=1.05"});
+    addTestCase("ReduceL1", 18, {}); // Use default-value for attributes
+    addTestCase("ReduceL1", 18, {"keepdims = 0"});
+    addTestCase("ReduceL1", 18, {"noop_with_empty_axes = 1"});
+    addTestCase("ReduceL2", 18, {});
+    addTestCase("ReduceL2", 18, {"noop_with_empty_axes = 1", "keepdims = 0"});
+    addTestCase("ReduceSumSquare", 18, {});
+    addTestCase("ReduceLogSumExp", 18, {});
+    addTestCase("ThresholdedRelu", 10, {"alpha = 0.9"});
+    addTestCase("HannWindow", 17, {"output_datatype = 1", "periodic = 1"});
+    addTestCase("HammingWindow", 17, {"output_datatype = 1", "periodic = 1"});
+    addTestCase("BlackmanWindow", 17, {"output_datatype = 1", "periodic = 1"});
+    addTestCase("MeanValueNormalization", 13, {});
+    addTestCase("AffineGrid", 20, {"align_corners = 0"});
+    addTestCase("AffineGrid", 20, {"align_corners = 1"});
+
+    // The following test-cases fails, correctly so: Some clarification/changes required
+    // to handle unsigned integers or similar issues:
+    // addTestCase("Shrink", 9, {"bias = 0.0", "lambd = 0.5"});
+    // addTestCase("ReduceLogSum", 18, {});
+    // addTestCase("Range", 11, {});
+
+    // The following test-case fails because the checker doesn't support handling of
+    // default-values of attributes of function-ops
+    // addTestCase("ThresholdedRelu", 10, {});
+  }
+
+  const std::vector<AttributeValues>& getTestCases(const OpSchema& schema) {
+    auto key_value = key(schema.domain(), schema.Name(), schema.SinceVersion());
+    auto it = map.find(key_value);
+    if (it != map.end())
+      return it->second;
+    if (schema.attributes().empty()) {
+      // Test with no-attributes
+      map[key_value].emplace_back();
+    }
+    return map[key_value];
+  }
+
+  static FunctionOpAttributeMap& instance() {
+    static FunctionOpAttributeMap _instance;
+    return _instance;
+  }
+};
+
+struct FunctionTypeChecker {
+  const OpSchema& schema;
+  const FunctionProto& function_proto;
+  const std::vector<AttributeValues>* attribute_cases;
+
+  FunctionTypeChecker(const OpSchema& op_schema, const FunctionProto& proto)
+      : schema(op_schema),
+        function_proto(proto),
+        attribute_cases(&FunctionOpAttributeMap::instance().getTestCases(op_schema)) {}
+
+  // Binds each type-variable in schema to a type-value
+  std::unordered_map<std::string, DataType> typeVarBindings;
+
+  std::vector<std::string> errors;
+
+  void recordError(const std::string& error, const AttributeValues& attrs) {
+    std::ostringstream ostr;
+    ostr << "Type checking failed for instantiation " << schema.Name() << ":" << schema.SinceVersion() << " {";
+    for (auto& pair : typeVarBindings) {
+      ostr << pair.first << " = " << *pair.second << ", ";
+    }
+    for (const auto& attr : attrs) {
+      ostr << attr << ", ";
+    }
+    ostr << "}\n" << error << "\n";
+    errors.push_back(ostr.str());
+  }
+
+  void recordSuccess(const AttributeValues& attrs) {
+    std::cout << "Type checking succeeded for instantiation " << schema.Name() << ":" << schema.SinceVersion() << " {";
+    for (auto& pair : typeVarBindings) {
+      std::cout << pair.first << " = " << *pair.second << ", ";
+    }
+    for (const auto& attr : attrs) {
+      std::cout << attr << ", ";
+    }
+    std::cout << "}\n";
+  }
+
+  // forTypeVar: This is used to iterate through all possible bindings of type-values
+  // to all type-variables used in the op schema, and invoke the type-checker for
+  // each possible instantiation.
+  void forTypeVar(size_t i) {
+    const auto& typeConstraintVector = schema.typeConstraintParams();
+    if (i < typeConstraintVector.size()) {
+      std::string typeVar = typeConstraintVector[i].type_param_str;
+      const auto& values = schema.typeConstraintMap().at(typeVar).first;
+      for (const auto* const typeValue : values) {
+        typeVarBindings[typeVar] = typeValue;
+        // Now, process remaining type-variables
+        forTypeVar(i + 1);
+      }
+    } else {
+      // Generated a complete instantiation of type-values to all type-variables.
+      // Now, check for this instantiation.
+      typeCheckBinding();
+    }
+  }
+
+  // typeCheckBinding: Type-check the function-body for the current type-instantiation
+  void typeCheckBinding() {
+    std::vector<TypeProto> input_types;
+    for (const auto& input : schema.inputs()) {
+      DataType datatype = (1 == input.GetTypes().size())
+          ?
+          // Select the single possible type
+          (*(input.GetTypes().begin()))
+          :
+          // Select the type bound to the type-var in current instantiation
+          typeVarBindings[input.GetTypeStr()];
+      input_types.push_back(Utils::DataTypeUtils::ToTypeProto(datatype));
+    }
+
+    for (const auto& attribute_vals : *attribute_cases) {
+      ONNX_TRY {
+        shape_inference::InferFunctionOutputTypes(function_proto, input_types, attribute_vals);
+      }
+      ONNX_CATCH(ONNX_NAMESPACE::InferenceError & e) {
+        ONNX_HANDLE_EXCEPTION(([&]() { recordError(e.what(), attribute_vals); }));
+      }
+    }
+  }
+
+  std::string checkAll() {
+    if (!attribute_cases->empty())
+      forTypeVar(0);
+    std::string all_errors;
+    for (const std::string& error : errors)
+      all_errors += error;
+    return all_errors;
+  }
+};
+
+} // namespace
+
+static void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int& counter) {
+  // Verify function proto is valid
+  if (!function_proto) {
+    fail_check("Cannot get function body for op '", op.Name(), "'");
+  }
+  checker::CheckerContext ctx;
+  std::unordered_map<std::string, int> op_set;
+  GetFunctionProtoOpsetImport(op, function_proto, op_set);
+  auto version_range = OpSchemaRegistry::DomainToVersionRange::Instance().Map().at(op.domain());
+  if (op.since_version() > version_range.second || op.since_version() < version_range.first) {
+    fail_check("Invalid function version in function op '", op.Name(), "'");
+  }
+
+  ctx.set_opset_imports(op_set);
+  ctx.set_is_main_graph(false);
+  checker::LexicalScopeContext lex_ctx;
+  ONNX_TRY {
+    checker::check_function(*function_proto, ctx, lex_ctx);
+  }
+  ONNX_CATCH(checker::ValidationError & ex) {
+    ONNX_HANDLE_EXCEPTION([&]() { fail_check(ex.what()); });
+  }
+
+  // Verify function op has compatible Type constraints defined in
+  // op and function body.
+  VerifyTypeConstraint(op, function_proto, counter);
+
+  FunctionTypeChecker type_checker(op, *function_proto);
+  auto type_errors = type_checker.checkAll();
+  auto success = (type_errors.empty());
+  ASSERT_TRUE(success) << type_errors;
+}
+
+// Verify registered ops with function body has compatible
+// definition on TypeConstraints between ops and function body
+TEST(FunctionVerification, VerifyFunctionOps) {
+  const std::vector<OpSchema> schemas = OpSchemaRegistry::get_all_schemas();
+  int function_counter = 0, verified_counter = 0;
+  for (const auto& s : schemas) {
+    if (!s.HasFunction())
+      continue;
+    // Skip test for functions with known errors that need to be fixed:
+    // Range currently permits int16 parameters, but the operator Sub, called
+    // from the body of Range does not yet support int16 parameter.
+    if (s.Name() == "Range")
+      continue;
+    ONNX_TRY {
+      ++function_counter;
+      std::vector<int> function_versions = s.function_opset_versions();
+      for (int function_version : function_versions) {
+        const auto* const function_body = s.GetFunction(function_version);
+        VerifyFunction(s, function_body, verified_counter);
+      }
+    }
+    ONNX_CATCH(const ONNX_NAMESPACE::checker::ValidationError& e) {
+      ONNX_HANDLE_EXCEPTION([&]() { FAIL() << e.what(); });
+    }
+  }
+  std::cerr << "[          ] Verified " << verified_counter << "/" << function_counter << " Functions." << '\n';
+}
+
+// Verify that FunctionExpandHelper obtains missing default attributes
+// from schema and adds them to ops in expanded subgraph.
+TEST(FunctionVerification, VerifyFunctionExpandHelper) {
+  GraphProto graph;
+  NodeProto* new_node = graph.add_node();
+  new_node->set_op_type("MeanVarianceNormalization");
+
+  const auto* const schema = OpSchemaRegistry::Schema("MeanVarianceNormalization", 9, "");
+  const FunctionProto* func = schema->GetFunction();
+  const auto default_axes_attribute = schema->attributes().at("axes").default_value;
+
+  FunctionExpandHelper(*new_node, *func, graph);
+
+  for (const auto& node : graph.node()) {
+    if (node.op_type() == "ReduceMean") {
+      const auto& attr = node.attribute(0);
+      EXPECT_EQ(attr.name(), "axes");
+      EXPECT_EQ(attr.ints().size(), default_axes_attribute.ints().size());
+
+      for (int i = 0; i < default_axes_attribute.ints().size(); ++i) {
+        EXPECT_EQ(attr.ints(i), default_axes_attribute.ints(i));
+      }
+      return;
+    }
+  }
+  FAIL() << "During expanding MeanVarianceNormalization function, "
+         << "the default attribute `axes` has not been assigned to ReduceMean op.";
+}
+
+static void RegisterFunctionSchema() {
+  ONNX_NAMESPACE::OpSchema function_schema;
+  function_schema.SetName("DynamicQuantizeLinear_Fake")
+      .SetDomain(AI_ONNX_ML_DOMAIN)
+      .SinceVersion(2)
+      .SetDoc("Test Op")
+      .Input(0, "x", "Input tensor", "T1")
+      .Output(0, "y", "Quantized output tensor", "T2")
+      .Output(
+          1, "y_scale", "Output scale. It's a scalar, which means a per-tensor/layer quantization.", "tensor(float)")
+      .Output(2, "y_zero_point", "Output zero point. It's a scalar, which means a per-tensor/layer quantization.", "T2")
+      .TypeConstraint("T1", {"tensor(float)"}, "Constrain 'x' to float tensor.")
+      .TypeConstraint("T2", {"tensor(uint8)"}, "Constrain 'y_zero_point' and 'y' to 8-bit unsigned integer tensor.")
+      .FunctionBody(
+          FunctionBodyHelper::BuildNodes(
+              {// nodes: {outputs, op, inputs, attributes}
+               FunctionBodyHelper::Const<float>("Q_Min", 0.f),
+               FunctionBodyHelper::Const<float>("Q_Max", 255.f),
+               {{"X_Min"}, "ReduceMin", {"x"}, {MakeAttribute("keepdims", static_cast<int64_t>(0))}},
+               {{"X_Min_Adjusted"}, "Min", {"X_Min", "Q_Min"}},
+               {{"X_Max"}, "ReduceMax", {"x"}, {MakeAttribute("keepdims", static_cast<int64_t>(0))}},
+               {{"X_Max_Adjusted"}, "Max", {"X_Max", "Q_Min"}},
+               {{"X_Range"}, "Sub", {"X_Max_Adjusted", "X_Min_Adjusted"}},
+               {{"Scale"}, "Div", {"X_Range", "Q_Max"}},
+               {{"Min_Scaled"}, "Div", {"X_Min_Adjusted", "Scale"}},
+               {{"Initial_ZeroPoint_FP"}, "Sub", {"Q_Min", "Min_Scaled"}},
+               {{"Clipped_ZeroPoint_FP"}, "Clip", {"Initial_ZeroPoint_FP", "Q_Min", "Q_Max"}},
+               {{"Rounded_ZeroPoint_FP"}, "Round", {"Clipped_ZeroPoint_FP"}},
+               {{"Zeropoint"}, "Cast", {"Rounded_ZeroPoint_FP"}, {MakeAttribute("to", static_cast<int64_t>(2))}},
+               {{"y_scale"}, "Identity", {"Scale"}},
+               {{"y_zero_point"}, "Identity", {"Zeropoint"}},
+               {{"y"}, "QuantizeLinear", {"x", "Scale", "Zeropoint"}}}),
+          []() {
+            std::vector<OperatorSetIdProto> operator_sets(2);
+            auto& onnx_opset = operator_sets[0];
+            onnx_opset.set_domain("");
+            onnx_opset.set_version(13);
+
+            auto& test_opset = operator_sets[1];
+            test_opset.set_domain(AI_ONNX_ML_DOMAIN);
+            test_opset.set_version(2);
+
+            return operator_sets;
+          }());
+  ONNX_NAMESPACE::OpSchemaRegistry::OpSchemaRegisterOnce unused(function_schema);
+  (void)unused;
+}
+
+TEST(FunctionVerification, VerifyFunctionBodyWithMultipleDomains) {
+  RegisterFunctionSchema();
+
+  const auto* const schema = OpSchemaRegistry::Schema("DynamicQuantizeLinear_Fake", 2, AI_ONNX_ML_DOMAIN);
+  EXPECT_TRUE(schema);
+  EXPECT_TRUE(schema->HasFunction());
+  EXPECT_FALSE(schema->HasContextDependentFunction());
+
+  const FunctionProto* fnProto = schema->GetFunction();
+  EXPECT_EQ(fnProto->node_size(), 16);
+
+  checker::LexicalScopeContext lexicalScope;
+  checker::CheckerContext checkerCtx;
+  std::unordered_map<std::string, int> opset_imports({{AI_ONNX_ML_DOMAIN, 2}, {"", 13}});
+  checkerCtx.set_opset_imports(opset_imports);
+  checkerCtx.set_ir_version(7);
+  checker::check_function(*fnProto, checkerCtx, lexicalScope);
+}
+
+TEST(FunctionVerification, VerifyModelLocalFunctions) {
+  const char* code = R"ONNX(
+<
+  ir_version: 8,
+  opset_import: [ "" : 13, "custom_domain_1" : 1, "custom_domain_2" : 1],
+  producer_name: "FunctionProtoTest",
+  producer_version: "1.0",
+  model_version: 1,
+  doc_string: "A test model for model local functions."
+>
+agraph (float[N] x) => (uint8[N] out)
+{
+    o1, o2 = custom_domain_1.bar(x)
+    o3 = Add(o1, o2)
+    o4 = custom_domain_2.foo(o3)
+    out = Identity(o4)
+}
+
+<
+  domain: "custom_domain_1",
+  opset_import: [ "" : 13],
+  doc_string: "Test function proto"
+>
+bar (x) => (o1, o2) {
+      o1 = Identity (x)
+      o2 = Identity (o1)
+}
+
+<
+  domain: "custom_domain_2",
+  opset_import: [ "" : 13],
+  doc_string: "Test function proto"
+>
+foo (x) => (y) {
+      Q_Min = Constant <value = float[1] {0.0}> ()
+      Q_Max = Constant <value = float[1] {255.0}> ()
+      X_Min = ReduceMin <keepdims = 0> (x)
+      X_Max = ReduceMax <keepdims = 0> (x)
+      X_Range = Sub (X_Max, X_Min)
+      Scale = Div (X_Range, Q_Max)
+      ZeroPoint_FP = Sub (Q_Min, Scale)
+      Zeropoint = Cast <to = 2> (ZeroPoint_FP)
+      y = QuantizeLinear (x, Scale, Zeropoint)
+}
+)ONNX";
+
+  ModelProto model;
+  auto status = OnnxParser::Parse(model, code);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+  checker::check_model(model);
+
+  ShapeInferenceOptions options{true, 1, true};
+  ONNX_NAMESPACE::shape_inference::InferShapes(model, OpSchemaRegistry::Instance(), options);
+}
+
+TEST(FunctionVerification, VerifyNestedModelLocalFunctions) {
+  const char* code = R"ONNX(
+<
+  ir_version: 8,
+  opset_import: [ "" : 13, "custom_domain_1" : 1, "custom_domain_2" : 1],
+  producer_name: "FunctionProtoTest",
+  producer_version: "1.0",
+  model_version: 1,
+  doc_string: "A test model for model local functions."
+>
+agraph (float[N] x) => (uint8[N] out)
+{
+    o1, o2 = custom_domain_1.bar(x)
+    o3 = Add(o1, o2)
+    o4 = custom_domain_2.foo(o3)
+    out = Identity(o4)
+}
+
+<
+  domain: "custom_domain_1",
+  opset_import: [ "" : 13],
+  doc_string: "Test function proto"
+>
+bar (x) => (o1, o2) {
+      o1 = Identity (x)
+      o2 = Identity (o1)
+}
+
+<
+  domain: "custom_domain_2",
+  opset_import: [ "" : 13, "custom_domain_3" : 1],
+  doc_string: "Test function proto"
+>
+foo (x) => (o4) {
+      o1 = custom_domain_3.foo (x)
+      o4 = Identity (o1)
+}
+
+<
+  domain: "custom_domain_3",
+  opset_import: [ "" : 13],
+  doc_string: "Test function proto"
+>
+foo (x) => (y) {
+      Q_Min = Constant <value = float[1] {0.0}> ()
+      Q_Max = Constant <value = float[1] {255.0}> ()
+      X_Min = ReduceMin <keepdims = 0> (x)
+      X_Max = ReduceMax <keepdims = 0> (x)
+      X_Range = Sub (X_Max, X_Min)
+      Scale = Div (X_Range, Q_Max)
+      ZeroPoint_FP = Sub (Q_Min, Scale)
+      Zeropoint = Cast <to = 2> (ZeroPoint_FP)
+      y = QuantizeLinear (x, Scale, Zeropoint)
+}
+)ONNX";
+
+  ModelProto model;
+  auto status = OnnxParser::Parse(model, code);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+
+  checker::check_model(model);
+
+  ShapeInferenceOptions options{true, 1, true};
+  ONNX_NAMESPACE::shape_inference::InferShapes(model, OpSchemaRegistry::Instance(), options);
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/inliner_test.cc b/onnx/test/cpp/inliner_test.cc
new file mode 100644
index 0000000..167a5cd
--- /dev/null
+++ b/onnx/test/cpp/inliner_test.cc
@@ -0,0 +1,502 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <string>
+#include <utility>
+
+#include "gtest/gtest.h"
+#include "onnx/checker.h"
+#include "onnx/defs/function.h"
+#include "onnx/defs/parser.h"
+#include "onnx/defs/schema.h"
+#include "onnx/inliner/inliner.h"
+#include "onnx/shape_inference/implementation.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+static void InlineFunctions(
+    ModelProto& model,
+    const char* input,
+    const inliner::FunctionIdSet* to_inline = nullptr,
+    const ISchemaRegistry* schema_registry = nullptr) {
+  OnnxParser parser(input);
+  auto status = parser.Parse(model);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+  EXPECT_TRUE(parser.EndOfInput()) << "Extra unparsed input unexpected.";
+
+  checker::check_model(model, false, true);
+  shape_inference::InferShapes(model);
+
+  // std::cout << "Before inlining:\n" << ProtoToString(model) << "\n";
+  if (schema_registry != nullptr)
+    inliner::InlineSelectedFunctions(model, *to_inline, schema_registry);
+  else if (to_inline != nullptr)
+    inliner::InlineSelectedFunctions(model, *to_inline);
+  else
+    inliner::InlineLocalFunctions(model, true);
+  // std::cout << "After inlining:\n" << ProtoToString(model) << "\n";
+
+  // The following will ensure basic safety checks hold after inlining, including
+  // absence of duplicate names (multiple assignments to same name).
+  checker::check_model(model, true, true);
+}
+
+TEST(FunctionInliner, BasicTest) {
+  const char* code = R"ONNX(
+<
+  ir_version: 8,
+  opset_import: [ "" : 10, "local" : 1 ]
+>
+agraph (float[N, 128] X, float[128,10] W, float[10] B) => (float[N, 10] C)
+{
+  T = local.foo (X, W, B)
+  C = local.square(T)
+}
+
+<
+  opset_import: [ "" : 10 ],
+  domain: "local",
+  doc_string: "Function foo."
+>
+foo (x, w, b) => (c) {
+  T = MatMul(x, w)
+  S = Add(T, b)
+  c = Softmax(S)
+}
+
+<
+  opset_import: [ "" : 10 ],
+  domain: "local",
+  doc_string: "Function square."
+>
+square (x) => (y) {
+  y = Mul (x, x)
+}
+)ONNX";
+
+  ModelProto model;
+  InlineFunctions(model, code);
+  auto num_nodes = model.graph().node_size();
+  ASSERT_EQ(num_nodes, 4);
+  auto num_functions = model.functions_size();
+  ASSERT_EQ(num_functions, 0);
+}
+
+// Test that inlining processes subgraphs.
+TEST(FunctionInliner, SubgraphTest) {
+  const char* code = R"ONNX(
+<
+  ir_version: 8,
+  opset_import: [ "" : 10, "local" : 1 ]
+>
+agraph (bool cond, float[N] X) => (float[N] Y)
+{
+  Y = If (cond) <
+    then_branch = then_graph () => (y) {
+        y = local.square (X)
+    },
+    else_branch = else_graph () => (y) {
+        y = local.square (X)
+    }
+  >
+}
+
+<
+  opset_import: [ "" : 10 ],
+  domain: "local",
+  doc_string: "Function square."
+>
+square (x) => (y) {
+  y = Mul (x, x)
+}
+)ONNX";
+
+  ModelProto model;
+  InlineFunctions(model, code);
+  const auto& if_node = model.graph().node(0);
+  const auto& graph1 = if_node.attribute(0).g();
+  ASSERT_EQ(graph1.node(0).op_type(), "Mul");
+  const auto& graph2 = if_node.attribute(1).g();
+  ASSERT_EQ(graph2.node(0).op_type(), "Mul");
+  auto num_functions = model.functions_size();
+  ASSERT_EQ(num_functions, 0);
+}
+
+TEST(FunctionInliner, Nested) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+agraph (float[N] X) => (float[N] Y)
+{
+  Y = local.foo (X)
+}
+
+<opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+foo (x) => (y) {
+  temp = Add(x, x)
+  y = local.bar(temp)
+}
+
+<opset_import: [ "" : 17 ], domain: "local">
+bar (x) => (y) {
+  y = Mul (x, x)
+}
+)ONNX";
+
+  ModelProto model;
+  InlineFunctions(model, code);
+  auto num_nodes = model.graph().node_size();
+  ASSERT_EQ(num_nodes, 2);
+  auto num_functions = model.functions_size();
+  ASSERT_EQ(num_functions, 0);
+}
+
+TEST(FunctionInliner, Renaming) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+agraph (float[N] X) => (float[N] Y)
+{
+  temp = local.foo (X)
+  temp__1 = Mul (temp, temp)
+  Y = Abs (temp__1)
+}
+
+<opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+foo (x) => (y) {
+  temp = Add(x, x)
+  y = Neg (temp)
+}
+)ONNX";
+
+  ModelProto model;
+  // Check that renaming handles accidental collision of names: when "temp" in "foo" is
+  // inlined, it will be renamed into something distinct from "temp" and "temp__1" as
+  // both these names occur in the main graph.
+  InlineFunctions(model, code);
+}
+
+TEST(FunctionInliner, ValueInfoPropagation) {
+  const char* code = R"ONNX(
+<ir_version: 10, opset_import: [ "" : 17, "local" : 1 ]>
+agraph (float[N] X) => (float[N] Y)
+{
+  result = local.foo (X)
+  Y = Abs (result)
+}
+
+<opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+foo (x) => (y)
+<float[N] temp> {
+  temp = Add(x, x)
+  y = Neg (temp)
+}
+)ONNX";
+
+  ModelProto model;
+  InlineFunctions(model, code);
+  // Check that valueinfo is propagated from function to main graph.
+  const auto& graph = model.graph();
+  const auto& temp_new_name = graph.node(0).output(0);
+  const auto& valueinfos = graph.value_info();
+  for (const auto& valueinfo : valueinfos) {
+    if (valueinfo.name() == temp_new_name) {
+      ASSERT_TRUE(valueinfo.has_type());
+      ASSERT_TRUE(valueinfo.type().has_tensor_type());
+      ASSERT_TRUE(valueinfo.type().tensor_type().has_shape());
+      ASSERT_EQ(valueinfo.type().tensor_type().shape().dim_size(), 1);
+      return;
+    }
+  }
+  ASSERT_TRUE(false) << "ValueInfo not found";
+}
+
+TEST(FunctionInliner, TwoCallsToSameFunction) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+agraph (float[N] X) => (float[N] Y)
+{
+  temp = local.foo (X)
+  Y = local.foo (temp)
+}
+
+<opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+foo (x) => (y) {
+  temp = Add(x, x)
+  y = Neg (temp)
+}
+)ONNX";
+
+  ModelProto model;
+  // The call below will check that multiple assignments to same name does not happen
+  // after inlining two calls to same function.
+  InlineFunctions(model, code);
+}
+
+TEST(FunctionInliner, OpsetMismatch) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+agraph (float[N] X) => (float[N] Y)
+{
+  temp = local.foo (X)
+  Y = local.bar (temp)
+}
+
+<opset_import: [ "" : 18], domain: "local">
+foo (x) => (y) {
+  y = Add(x, x)
+}
+
+<opset_import: [ "" : 17], domain: "local">
+bar (x) => (y) {
+  y = Add(x, x)
+}
+)ONNX";
+
+  ModelProto model;
+  InlineFunctions(model, code);
+
+  // The first node's call, to foo, must be inlined.
+  const auto& first_node = model.graph().node(0);
+  // Check that it is a call to Add
+  ASSERT_EQ(first_node.op_type(), "Add");
+
+  // The second node's call, to bar, must be inlined.
+  const auto& second_node = model.graph().node(1);
+  // Check that it is a call to Add
+  ASSERT_EQ(second_node.op_type(), "Add");
+
+  ASSERT_EQ(model.functions_size(), 0);
+}
+
+TEST(FunctionInliner, SelectiveInlining) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+agraph (float[N] X) => (float[N] Y)
+{
+  temp = local.foo (X)
+  Y = local.bar (temp)
+}
+
+<opset_import: [ "" : 17], domain: "local">
+foo (x) => (y) {
+  y = Add(x, x)
+}
+
+<opset_import: [ "" : 17, "local" : 1], domain: "local">
+bar (x) => (y) {
+  y = local.foo(x)
+}
+)ONNX";
+
+  ModelProto model;
+  inliner::FunctionIdVector to_inline = {{"local", "foo"}};
+  auto to_inline_set = inliner::FunctionIdSet::Create(std::move(to_inline));
+  InlineFunctions(model, code, to_inline_set.get());
+
+  // The first node's call, to foo, must be inlined.
+  const auto& first_node = model.graph().node(0);
+  // Check that it is a call to Add
+  ASSERT_EQ(first_node.op_type(), "Add");
+
+  // The second node's call, to bar, must not be inlined.
+  const auto& second_node = model.graph().node(1);
+  // Check that it is a call to bar
+  ASSERT_EQ(second_node.op_type(), "bar");
+
+  // foo will be removed, bar will remain, in model.functions()
+  ASSERT_EQ(model.functions_size(), 1);
+
+  const auto& bar_node = model.functions(0).node(0);
+  // Check that it is a call to Add, due to inlining
+  // the call to foo in bar.
+  ASSERT_EQ(bar_node.op_type(), "Add");
+}
+
+TEST(FunctionInliner, VersionConversion) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: [ "" : 18, "local" : 1 ]>
+agraph (float[N,M] X) => (float[N,M] Y)
+{
+  Y = local.foo (X)
+}
+
+<opset_import: [ "" : 17], domain: "local">
+foo (x) => (y) {
+  y = ReduceLogSum <axes = [0]> (x)
+}
+)ONNX";
+
+  ModelProto model;
+  InlineFunctions(model, code);
+  // Inlining ReduceLogSum (version 17) should convert it to ReduceLogSum (version 18)
+  // by promoting axes from attribute to input.
+  const auto& node = model.graph().node(1);
+  ASSERT_EQ(node.op_type(), "ReduceLogSum");
+  ASSERT_EQ(node.input_size(), 2);
+  ASSERT_EQ(node.attribute_size(), 0);
+}
+
+TEST(FunctionInliner, NestedVersionConversion) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: [ "" : 18, "local" : 1 ]>
+agraph (float[N,M] X) => (float[N,M] Y)
+{
+  Y = local.foo (X)
+}
+
+<opset_import: [ "" : 17, "local" : 1], domain: "local">
+foo (x) => (y) {
+  t = ReduceLogSum <axes = [0]> (x)
+  y = local.bar (t)
+}
+
+<opset_import: [ "" : 17], domain: "local">
+bar (x) => (y) {
+  y = ReduceLogSum <axes = [1]> (x)
+}
+)ONNX";
+
+  ModelProto model;
+  InlineFunctions(model, code);
+  // Inlining ReduceLogSum (version 17) should convert it to ReduceLogSum (version 18)
+  // by promoting axes from attribute to input, with a preceding Constant node for
+  // the axes value.
+  // Check that both ReduceLogSum nodes have been converted.
+  ASSERT_EQ(model.graph().node_size(), 4);
+  ASSERT_EQ(model.graph().node(0).op_type(), "Constant");
+  const auto& node = model.graph().node(1);
+  ASSERT_EQ(node.op_type(), "ReduceLogSum");
+  ASSERT_EQ(node.input_size(), 2);
+  ASSERT_EQ(node.attribute_size(), 0);
+  ASSERT_EQ(model.graph().node(2).op_type(), "Constant");
+  auto node2 = model.graph().node(3);
+  ASSERT_EQ(node2.op_type(), "ReduceLogSum");
+  ASSERT_EQ(node2.input_size(), 2);
+  ASSERT_EQ(node2.attribute_size(), 0);
+}
+
+TEST(SchemaFunctionInliner, BasicTest) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: ["" : 18]>
+agraph (float[N, 128] X) => (float[N, 128] Y)
+{
+  Y = Softmax (X)
+}
+)ONNX";
+
+  ModelProto model;
+  inliner::FunctionIdVector to_inline = {{"", "Softmax"}};
+  auto to_inline_set = inliner::FunctionIdSet::Create(std::move(to_inline));
+  InlineFunctions(model, code, to_inline_set.get(), OpSchemaRegistry::Instance());
+  auto num_nodes = model.graph().node_size();
+  ASSERT_GT(num_nodes, 1);
+}
+
+static bool ContainsOp(const ModelProto& model, const char* op_type) {
+  for (const auto& node : model.graph().node()) {
+    if (node.op_type() == op_type) {
+      return true;
+    }
+  }
+  return false;
+}
+
+TEST(SchemaFunctionInliner, NestedTest) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: ["" : 18]>
+agraph (float[N, C] X, int32[N] expected) => (float Y)
+{
+  Y, log_prob = SoftmaxCrossEntropyLoss (X, expected)
+}
+)ONNX";
+
+  ModelProto model;
+  inliner::FunctionIdVector to_inline = {{"", "SoftmaxCrossEntropyLoss"}};
+  auto to_inline_set = inliner::FunctionIdSet::Create(std::move(to_inline));
+  InlineFunctions(model, code, to_inline_set.get(), OpSchemaRegistry::Instance());
+  auto num_nodes = model.graph().node_size();
+  ASSERT_GT(num_nodes, 1);
+  // Nested call to LogSoftmax should not be inlined.
+  ASSERT_TRUE(ContainsOp(model, "LogSoftmax"));
+
+  inliner::FunctionIdVector to_inline2 = {{"", "SoftmaxCrossEntropyLoss"}, {"", "LogSoftmax"}};
+  to_inline_set = inliner::FunctionIdSet::Create(std::move(to_inline2));
+  InlineFunctions(model, code, to_inline_set.get(), OpSchemaRegistry::Instance());
+  num_nodes = model.graph().node_size();
+  ASSERT_GT(num_nodes, 1);
+  // Nested call to LogSoftmax should be inlined.
+  ASSERT_FALSE(ContainsOp(model, "LogSoftmax"));
+}
+
+TEST(FunctionBuilder, AddInlinedCallBasic) {
+  // Test the AddInlinedCall functionality
+  GraphProto graph;
+
+  // Create a simple graph using parser for better readability
+  const char* graph_text = R"ONNX(
+test_graph (float x) => (float y)
+<float const_val = {2.0}>
+{
+    y = Add(x, const_val)
+}
+)ONNX";
+
+  auto status = OnnxParser::Parse(graph, graph_text);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+
+  // Create a function and use AddInlinedCall
+  FunctionProto function;
+  FunctionBuilder builder(function);
+
+  builder.AddInlinedCall({"result"}, graph, {"input_x"}, "test");
+
+  // Verify the function has the expected structure
+  ASSERT_EQ(function.node_size(), 2); // One Constant node + one Add node
+
+  // Check the first node is a Constant
+  ASSERT_EQ(function.node(0).op_type(), "Constant");
+  ASSERT_EQ(function.node(0).output_size(), 1);
+  ASSERT_TRUE(function.node(0).output(0).find("test") != std::string::npos);
+
+  // Check the second node is an Add
+  ASSERT_EQ(function.node(1).op_type(), "Add");
+  ASSERT_EQ(function.node(1).input_size(), 2);
+  ASSERT_EQ(function.node(1).output_size(), 1);
+  ASSERT_EQ(function.node(1).input(0), "input_x"); // Should be renamed to actual input
+  ASSERT_EQ(function.node(1).output(0), "result"); // Should be renamed to actual output
+}
+
+TEST(Renamer, BasicFunctionality) {
+  // Test the Renamer class functionality
+  GraphProto graph;
+
+  // Add input to graph
+  auto* input = graph.add_input();
+  input->set_name("input");
+
+  // Create a Renamer instance
+  inliner::Renamer renamer("test", graph);
+
+  // Test binding names
+  renamer.BindName("formal_input", "actual_input");
+
+  // Test creating unique names and binding
+  std::string unique_name = renamer.BindToUniqueName("temp");
+  ASSERT_TRUE(unique_name.find("test") != std::string::npos);
+
+  // Test renaming a node
+  NodeProto node;
+  node.set_op_type("Add");
+  node.add_input("formal_input");
+  node.add_output("temp_output");
+
+  renamer.RenameNode(node);
+
+  // Verify renaming worked correctly
+  ASSERT_EQ(node.input(0), "actual_input"); // Should be bound to actual name
+  ASSERT_TRUE(node.output(0).find("test") != std::string::npos); // Should have prefix
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/ir_test.cc b/onnx/test/cpp/ir_test.cc
new file mode 100644
index 0000000..94d9d64
--- /dev/null
+++ b/onnx/test/cpp/ir_test.cc
@@ -0,0 +1,72 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <memory>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "onnx/common/ir.h"
+#include "onnx/common/ir_pb_converter.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+static bool IsValidIdentifier(const std::string& name) {
+  if (name.empty()) {
+    return false;
+  }
+  if (!isalpha(name[0]) && name[0] != '_') {
+    return false;
+  }
+  for (size_t i = 1; i < name.size(); ++i) {
+    if (!isalnum(name[i]) && name[i] != '_') {
+      return false;
+    }
+  }
+  return true;
+}
+
+TEST(IR, ValidIdentifierTest) {
+  Graph* g = new Graph(); // NOLINT(cppcoreguidelines-owning-memory)
+  g->setName("test");
+  Value* x = g->addInput();
+  x->setUniqueName("x");
+  x->setElemType(ONNX_NAMESPACE::TensorProto_DataType_FLOAT);
+  x->setSizes({Dimension("M"), Dimension("N")});
+  Node* node1 = g->create(kNeg, 1);
+  node1->addInput(x);
+  g->appendNode(node1);
+  Value* temp1 = node1->outputs()[0];
+  Node* node2 = g->create(kNeg, 1);
+  node2->addInput(temp1);
+  g->appendNode(node2);
+  Value* y = node2->outputs()[0];
+  g->registerOutput(y);
+
+  ModelProto model;
+  ExportModelProto(&model, std::shared_ptr<Graph>(g));
+
+  for (const auto& node : model.graph().node()) {
+    for (const auto& name : node.output()) {
+      EXPECT_TRUE(IsValidIdentifier(name));
+    }
+  }
+}
+
+// Regression test: Tensor::elem_num() and size_from_dim() must use 64-bit
+// arithmetic. Previously, std::accumulate used `1` (int) as the initial value,
+// causing 32-bit multiplication that silently overflowed for tensors whose
+// element count exceeded INT_MAX (~2.1B). Fixed by using int64_t{1}.
+TEST(Tensor, ElemNumLargeTensorNoOverflow) {
+  Tensor t;
+  // 50000 * 50000 = 2,500,000,000 which exceeds INT32_MAX (2,147,483,647)
+  t.sizes() = {50000, 50000};
+  const int64_t expected = static_cast<int64_t>(50000) * 50000;
+  EXPECT_EQ(t.elem_num(), expected);
+  EXPECT_EQ(t.size_from_dim(0), expected);
+  EXPECT_EQ(t.size_from_dim(1), int64_t{50000});
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/op_reg_test.cc b/onnx/test/cpp/op_reg_test.cc
new file mode 100644
index 0000000..e41417a
--- /dev/null
+++ b/onnx/test/cpp/op_reg_test.cc
@@ -0,0 +1,24 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "gtest/gtest.h"
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+TEST(OpRegistrationTest, GemmOp) {
+  const auto* const opSchema = OpSchemaRegistry::Schema("Gemm");
+  EXPECT_TRUE(nullptr != opSchema);
+  size_t input_size = opSchema->inputs().size();
+  EXPECT_EQ(input_size, 3);
+  EXPECT_EQ(opSchema->inputs()[0].GetTypes(), opSchema->outputs()[0].GetTypes());
+  size_t attr_size = opSchema->attributes().size();
+  EXPECT_EQ(attr_size, 4);
+  EXPECT_NE(opSchema->attributes().count("alpha"), 0);
+  EXPECT_EQ(opSchema->attributes().at("alpha").type, AttributeProto_AttributeType_FLOAT);
+  EXPECT_NE(opSchema->attributes().count("beta"), 0);
+  EXPECT_EQ(opSchema->attributes().at("beta").type, AttributeProto_AttributeType_FLOAT);
+}
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/parser_test.cc b/onnx/test/cpp/parser_test.cc
new file mode 100644
index 0000000..bbcda11
--- /dev/null
+++ b/onnx/test/cpp/parser_test.cc
@@ -0,0 +1,858 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <clocale>
+#include <cmath>
+#include <string>
+#include <string_view>
+
+#include "gtest/gtest.h"
+#include "onnx/checker.h"
+#include "onnx/defs/parser.h"
+#include "onnx/defs/printer.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+template <typename T>
+static void Parse(T& parsedData, std::string_view input) {
+  OnnxParser parser(input);
+  auto status = parser.Parse(parsedData);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+  EXPECT_TRUE(parser.EndOfInput()) << "Extra unparsed input unexpected.";
+  // Extra checks for printer:
+  // Check we can convert data back to text form.
+  std::string text1 = ProtoToString(parsedData);
+  // Check that we can round-trip between the two representations.
+  // We cannot expect equality between text1 and input due to white-space and syntactic sugar,
+  // so, we convert it once more, and check for equality.
+  T temp;
+  // Pass a string_view to exercise the std::string_view overload explicitly.
+  status = OnnxParser::Parse(temp, std::string_view(text1));
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+  std::string text2 = ProtoToString(temp);
+  EXPECT_EQ(text1, text2);
+}
+
+template <typename T>
+static void ExpectParseFailure(T& parsedData, std::string_view input) {
+  auto status = OnnxParser::Parse(parsedData, input);
+  EXPECT_FALSE(status.IsOK());
+}
+
+static void CheckModel(std::string_view code) {
+  ModelProto model;
+  Parse(model, code);
+
+  checker::check_model(model);
+}
+
+TEST(ParserTest, EscapeStringLiteral) {
+  OnnxParser parser(R"(
+    "123\"56\\89"
+  )");
+
+  std::string s;
+  auto status = parser.ParserBase::Parse(s);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+  EXPECT_TRUE(parser.EndOfInput()) << "Extra unparsed input unexpected.";
+  EXPECT_EQ(s, std::string("123\"56\\89"));
+}
+
+TEST(ParserTest, NonNulTerminatedStringView) {
+  // The view is just "inf"; the backing buffer continues with a digit. A buffer
+  // over-read past the view would see '9' and reject the valid float literal.
+  std::string backing = "inf9";
+  std::string_view view(backing.data(), 3);
+  OnnxParser parser(view);
+  float val = 0.0f;
+  auto status = parser.ParserBase::Parse(val);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+  EXPECT_TRUE(std::isinf(val));
+  EXPECT_TRUE(parser.EndOfInput()) << "Extra unparsed input unexpected.";
+}
+
+TEST(ParserTest, TypeTest) {
+  TypeProto type;
+
+  // 1-dimensional tensor type with symbolic dimension:
+  Parse(type, "float[N]");
+  EXPECT_TRUE(type.has_tensor_type());
+  int float_type = static_cast<int>(TensorProto_DataType::TensorProto_DataType_FLOAT);
+  int int32_type = static_cast<int>(TensorProto_DataType::TensorProto_DataType_INT32);
+  EXPECT_EQ(type.tensor_type().elem_type(), float_type);
+  EXPECT_TRUE(type.tensor_type().has_shape());
+  EXPECT_EQ(type.tensor_type().shape().dim_size(), 1);
+  EXPECT_EQ(type.tensor_type().shape().dim(0).dim_param(), "N");
+
+  // scalar type:
+  Parse(type, "float");
+  EXPECT_TRUE(type.has_tensor_type());
+  EXPECT_EQ(type.tensor_type().elem_type(), float_type);
+  EXPECT_TRUE(type.tensor_type().has_shape());
+  EXPECT_EQ(type.tensor_type().shape().dim_size(), 0);
+
+  // tensor type with unknown rank:
+  Parse(type, "float[]");
+  EXPECT_TRUE(type.has_tensor_type());
+  EXPECT_EQ(type.tensor_type().elem_type(), float_type);
+  EXPECT_FALSE(type.tensor_type().has_shape());
+
+  // 3-dimensional tensor
+  Parse(type, "float[N,M,K]");
+  EXPECT_EQ(type.tensor_type().shape().dim_size(), 3);
+
+  // Unspecified dimension (neither symbolic nor constant)
+  Parse(type, "float[N,?,K]");
+  EXPECT_FALSE(type.tensor_type().shape().dim(1).has_dim_param());
+  EXPECT_FALSE(type.tensor_type().shape().dim(1).has_dim_value());
+
+  // sequence type:
+  Parse(type, "seq(float[])");
+  EXPECT_TRUE(type.has_sequence_type());
+  const auto& elttype = type.sequence_type().elem_type();
+  EXPECT_TRUE(elttype.has_tensor_type());
+  EXPECT_EQ(elttype.tensor_type().elem_type(), float_type);
+  EXPECT_FALSE(elttype.tensor_type().has_shape());
+
+  // optional type:
+  Parse(type, "optional(float)");
+  EXPECT_TRUE(type.has_optional_type());
+  const auto& optelttype = type.optional_type().elem_type();
+  EXPECT_TRUE(optelttype.has_tensor_type());
+  EXPECT_EQ(optelttype.tensor_type().elem_type(), float_type);
+  EXPECT_TRUE(optelttype.tensor_type().has_shape());
+
+  // optional type:
+  Parse(type, "sparse_tensor(float[1000])");
+  EXPECT_TRUE(type.has_sparse_tensor_type());
+  EXPECT_EQ(type.sparse_tensor_type().elem_type(), float_type);
+  EXPECT_EQ(type.sparse_tensor_type().shape().dim_size(), 1);
+
+  // map type:
+  Parse(type, "map(int32, float[N])");
+  EXPECT_TRUE(type.has_map_type());
+  EXPECT_EQ(type.map_type().key_type(), int32_type);
+  const auto& valtype = type.map_type().value_type();
+  EXPECT_TRUE(valtype.has_tensor_type());
+  EXPECT_EQ(valtype.tensor_type().elem_type(), float_type);
+  EXPECT_EQ(valtype.tensor_type().shape().dim_size(), 1);
+
+  // Quoted string as symbolic dimension (non-identifier dim_param):
+  Parse(type, R"(float["M + N"])");
+  EXPECT_TRUE(type.has_tensor_type());
+  EXPECT_EQ(type.tensor_type().shape().dim_size(), 1);
+  EXPECT_EQ(type.tensor_type().shape().dim(0).dim_param(), "M + N");
+}
+
+TEST(ParserTest, TensorProtoTest) {
+  TensorProto tensorProto;
+
+  // Concrete tensor-type with numeric dimensions expected:
+  ExpectParseFailure(tensorProto, "int32[] {1, 2, 3, 4, 5}");
+
+  // Symbolic dimensions are not allowed.
+  ExpectParseFailure(tensorProto, "int32[N] {1, 2, 3, 4, 5}");
+
+  Parse(tensorProto, "int32[5] {1, 2, 3, 4, 5}");
+
+  Parse(tensorProto, "int32[5] T {1, 2, 3, 4, 5}");
+  EXPECT_EQ(tensorProto.name(), "T");
+
+  Parse(tensorProto, "float[5] {1, 2.0, 3.1, 4, 5.5}");
+
+  Parse(tensorProto, "float[5] {1e1, 2.0e-1, 3.1E-1, 4E+1, 5.5e-10}");
+
+  Parse(tensorProto, R"(string[2] { "Hello", "World" })");
+
+  // String literals with escape character
+  Parse(tensorProto, R"(
+    string[2] { "Use a \"quoted\" word", "Use a backslash \\ like this." }
+  )");
+}
+
+TEST(ParserTest, AttributeTest) {
+  AttributeProto attr;
+
+  Parse(attr, "x = 2");
+  EXPECT_EQ(attr.name(), "x");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_INT);
+  EXPECT_EQ(attr.i(), 2);
+
+  Parse(attr, "x = 0.625");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_FLOAT);
+  EXPECT_FLOAT_EQ(attr.f(), 0.625);
+
+  Parse(attr, "x : float = 2");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_FLOAT);
+  EXPECT_TRUE(attr.has_f());
+  EXPECT_FALSE(attr.has_i());
+  EXPECT_FLOAT_EQ(attr.f(), 2.0);
+
+  Parse(attr, "x = [2, 4, 6]");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_INTS);
+  EXPECT_EQ(attr.ints_size(), 3);
+
+  Parse(attr, "x = [0.125, 0.625]");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_FLOATS);
+  EXPECT_EQ(attr.floats_size(), 2);
+
+  Parse(attr, "x = float[3] {2.1, 4.1, 6.1}");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_TENSOR);
+
+  Parse(attr, "x = \"astring\"");
+  EXPECT_EQ(attr.name(), "x");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_STRING);
+  EXPECT_EQ(attr.s(), "astring");
+
+  Parse(attr, R"(x = ["abc", "def"])");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_STRINGS);
+
+  Parse(attr, "x : ints = @xyz");
+  EXPECT_EQ(attr.ref_attr_name(), "xyz");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_INTS);
+
+  Parse(attr, "x : ints = []");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_INTS);
+  EXPECT_EQ(attr.ints_size(), 0);
+
+  Parse(attr, R"ONNX(
+    body = somegraph (float[N] y, float[N] z) => (float[N] w)
+      {
+        x = foo(y, z)
+        w = bar(x, y)
+      }
+)ONNX");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_GRAPH);
+  EXPECT_EQ(attr.g().node_size(), 2);
+
+  Parse(attr, "type = float[3]");
+  EXPECT_EQ(attr.type(), AttributeProto_AttributeType::AttributeProto_AttributeType_TYPE_PROTO);
+  EXPECT_TRUE(attr.tp().has_tensor_type());
+  int float_type = static_cast<int>(TensorProto_DataType::TensorProto_DataType_FLOAT);
+  EXPECT_EQ(attr.tp().tensor_type().elem_type(), float_type);
+}
+
+TEST(ParserTest, AttrListTest) {
+  const char* code = R"ONNX(
+<
+    x = 2,
+    w = 3
+>
+)ONNX";
+
+  AttrList attributes;
+  Parse(attributes, code);
+  EXPECT_EQ(attributes.size(), 2);
+  EXPECT_EQ(attributes.Get(0).name(), "x");
+  EXPECT_EQ(attributes.Get(1).name(), "w");
+}
+
+TEST(ParserTest, DomainOpCallTest) {
+  const char* code = "x = somedomain.foo(y, z)";
+  NodeProto n;
+  Parse(n, code);
+}
+
+TEST(ParserTest, OptionalInputTest) {
+  const char* code = "x = SomeOp(y, , z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 3);
+  EXPECT_EQ(n.input(0), "y");
+  EXPECT_EQ(n.input(1), "");
+  EXPECT_EQ(n.input(2), "z");
+}
+
+TEST(ParserTest, LeadingOptionalInputTest) {
+  const char* code = "x = SomeOp( , z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 2);
+  EXPECT_EQ(n.input(0), "");
+  EXPECT_EQ(n.input(1), "z");
+}
+
+TEST(ParserTest, LeadingOptionalInputTest2) {
+  const char* code = "x = SomeOp(\"\" , z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 2);
+  EXPECT_EQ(n.input(0), "");
+  EXPECT_EQ(n.input(1), "z");
+}
+
+TEST(ParserTest, OptionalInputTest2) {
+  const char* code = "x = SomeOp(y, \"\", z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 3);
+  EXPECT_EQ(n.input(0), "y");
+  EXPECT_EQ(n.input(1), "");
+  EXPECT_EQ(n.input(2), "z");
+}
+
+TEST(ParserTest, NodeTest) {
+  const char* code = "x = foo(y, z)";
+  NodeProto n;
+  Parse(n, code);
+
+  EXPECT_EQ(n.input_size(), 2);
+  EXPECT_EQ(n.input(0), "y");
+  EXPECT_EQ(n.input(1), "z");
+  EXPECT_EQ(n.output_size(), 1);
+  EXPECT_EQ(n.output(0), "x");
+  EXPECT_EQ(n.op_type(), "foo");
+
+  NodeList nl;
+  Parse(nl, R"ONNX(
+      {
+       sub_result = Sub(limit, start)
+       sub_result_casted = Cast<to = 1>(sub_result)
+       delta_casted = Cast<to = 1>(delta)
+       div_result = Div(sub_result_casted, delta_casted)
+       ceil_result = Ceil(div_result)
+       ceil_result_relu = Relu(ceil_result)
+       ceil_result_relu_int = Cast<to = 7>(ceil_result_relu)
+       ceil_result_relu_bool = Cast<to = 9>(ceil_result_relu)
+       variadic_output, output = Loop (ceil_result_relu_int, ceil_result_relu_bool, start)
+       }
+       )ONNX");
+}
+
+TEST(ParserTest, NodeLabelTest) {
+  const char* code = "[node1] x = foo(y, z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.name(), "node1");
+
+  NodeList nl;
+  Parse(nl, R"ONNX( {
+     [node1] x = foo(y, z)
+     [node2] w = bar(x, y)
+     s = foobar(x, w)
+  } )ONNX");
+  EXPECT_EQ(nl.Get(0).name(), "node1");
+  EXPECT_EQ(nl.Get(1).name(), "node2");
+  EXPECT_FALSE(nl.Get(2).has_name());
+}
+
+TEST(ParserTest, QualifiedOpNameTest) {
+  const char* code = "x = com.example.foo(y, z)";
+  NodeProto n;
+  Parse(n, code);
+
+  EXPECT_EQ(n.domain(), "com.example");
+  EXPECT_EQ(n.op_type(), "foo");
+}
+
+TEST(ParserTest, NodeListTest) {
+  const char* code = R"ONNX(
+{
+    x = foo(y, z)
+    w = bar(x, y)
+}
+)ONNX";
+
+  GraphProto graph;
+  Parse(*graph.mutable_node(), code);
+
+  EXPECT_EQ(graph.node_size(), 2);
+  EXPECT_EQ(graph.node(0).op_type(), "foo");
+  EXPECT_EQ(graph.node(1).op_type(), "bar");
+}
+
+TEST(ParserTest, NodeAttrTest1) {
+  const char* code = "x = foo <a = 100, b = 200.5, c = \"astring\"> (y, z)";
+  NodeProto n;
+  Parse(n, code);
+
+  EXPECT_EQ(n.attribute_size(), 3);
+  EXPECT_EQ(n.attribute(0).name(), "a");
+  EXPECT_EQ(n.attribute(1).name(), "b");
+  EXPECT_EQ(n.attribute(2).name(), "c");
+}
+
+TEST(ParserTest, NodeAttrTest2) {
+  const char* code = R"(x = foo <d = [5, 10], e = [0.55, 0.66], f = ["str1", "str2"]> (y, z))";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.attribute_size(), 3);
+}
+
+TEST(ParserTest, GraphTest) {
+  const char* code = R"ONNX(
+agraph (float[N] y, float[N] z) => (float[N] w)
+<float[2] w1 = {1.0, 2.0}, float[3] w2 = {4.0, 5.0, 6.0}, float[N] x>
+{
+    # This is a comment.
+    x = foo(y, z, w1) # More comments.
+    w = bar(x, y, w2)
+}
+)ONNX";
+
+  GraphProto graph;
+  Parse(graph, code);
+
+  EXPECT_EQ(graph.name(), "agraph");
+  EXPECT_EQ(graph.input_size(), 2);
+  EXPECT_EQ(graph.output_size(), 1);
+  EXPECT_EQ(graph.node_size(), 2);
+  EXPECT_EQ(graph.initializer_size(), 2);
+  EXPECT_EQ(graph.value_info_size(), 1);
+}
+
+TEST(ParserTest, GraphPartialTypeTest) {
+  const char* code = R"ONNX(
+agraph (float[N] y, z) => (float[N] w)
+{
+    x = foo(y, z)
+    w = bar(x, y)
+}
+)ONNX";
+
+  GraphProto graph;
+  Parse(graph, code);
+
+  EXPECT_EQ(graph.name(), "agraph");
+  EXPECT_EQ(graph.input_size(), 2);
+  EXPECT_EQ(graph.output_size(), 1);
+}
+
+TEST(ParserTest, FunctionTest) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+f (y, z) => (w)
+{
+    x = Add(y, z)
+    w = Mul(x, y)
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+
+  EXPECT_EQ(fp.name(), "f");
+  EXPECT_EQ(fp.input_size(), 2);
+  EXPECT_EQ(fp.output_size(), 1);
+  EXPECT_EQ(fp.node_size(), 2);
+  EXPECT_EQ(fp.attribute_size(), 0);
+  EXPECT_EQ(fp.opset_import_size(), 1);
+}
+
+TEST(ParserTest, FunctionValueInfoTest) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+f (float[N] y, float[N] z) => (float[N] w)
+{
+    x = Add(y, z)
+    w = Mul(x, y)
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+
+  EXPECT_EQ(fp.input_size(), 2);
+  EXPECT_EQ(fp.output_size(), 1);
+  ASSERT_EQ(fp.value_info_size(), 3);
+  EXPECT_EQ(fp.value_info(0).name(), "y");
+  EXPECT_EQ(fp.value_info(1).name(), "z");
+  EXPECT_EQ(fp.value_info(2).name(), "w");
+}
+
+TEST(ParserTest, FunctionValueInfoTest2) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+f (float[N] y, float[N] z) => (float[N] w)
+<float[N] x>
+{
+    x = Add(y, z)
+    w = Mul(x, y)
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+
+  EXPECT_EQ(fp.input_size(), 2);
+  EXPECT_EQ(fp.value_info_size(), 4);
+  ASSERT_EQ(fp.output_size(), 1);
+  EXPECT_EQ(fp.value_info(0).name(), "y");
+  EXPECT_EQ(fp.value_info(1).name(), "z");
+  EXPECT_EQ(fp.value_info(2).name(), "w");
+  EXPECT_EQ(fp.value_info(3).name(), "x");
+}
+
+TEST(ParserTest, FunctionValueInfoTest3) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+f (float[N] y, z) => (float[N] w)
+<float[N] x, float[N] t>
+{
+    x = Add(y, z)
+    t = Add(x, x)
+    w = Mul(t, y)
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+
+  EXPECT_EQ(fp.input_size(), 2);
+  ASSERT_EQ(fp.value_info_size(), 4);
+  EXPECT_EQ(fp.output_size(), 1);
+  EXPECT_EQ(fp.value_info(0).name(), "y");
+  EXPECT_EQ(fp.value_info(1).name(), "w");
+  EXPECT_EQ(fp.value_info(2).name(), "x");
+  EXPECT_EQ(fp.value_info(3).name(), "t");
+}
+
+TEST(ParserTest, InitializerTest) {
+  const char* code = R"ONNX(
+agraph (float y = {1.0}, float[N] z) => (float[N] w)
+<float[2] w1 = {1.0, 2.0}, float[3] w2 = {4.0, 5.0, 6.0}, float[N] x>
+{
+    x = foo(y, z, w1)
+    w = bar(x, y, w2)
+}
+)ONNX";
+
+  GraphProto graph;
+  Parse(graph, code);
+
+  EXPECT_EQ(graph.input_size(), 2);
+  EXPECT_EQ(graph.output_size(), 1);
+  EXPECT_EQ(graph.initializer_size(), 3); // y, w1, w2
+  EXPECT_EQ(graph.value_info_size(), 1); // x
+}
+
+TEST(ParserTest, IfNodeTest) {
+  const char* code = R"ONNX(
+z = If (b) <
+    then_branch = g1 () => (float[N] z_then)
+      {
+        z_then = foo(y)
+      },
+    else_branch = g2 () => (float[N] z_else)
+      {
+        z_else = bar(x)
+      }
+    >
+)ONNX";
+
+  NodeProto node;
+  Parse(node, code);
+  EXPECT_EQ(node.input_size(), 1);
+  EXPECT_EQ(node.output_size(), 1);
+  EXPECT_EQ(node.attribute_size(), 2);
+}
+
+TEST(ParserTest, ModelTest) {
+  const char* code = R"ONNX(
+<
+  ir_version: 7,
+  opset_import: [ "ai.onnx.ml" : 10 ],
+  producer_name: "ParserTest",
+  producer_version: "1.0",
+  domain: "ai.onnx.ml",
+  model_version: 1,
+  doc_string: "A parser test case model.",
+  metadata_props: [ "somekey" : "somevalue", "key2" : "value2" ]
+>
+agraph (float[N] y, float[N] z) => (float[N] w)
+{
+    x = foo(y, z)
+    w = bar(x, y)
+}
+)ONNX";
+
+  ModelProto model;
+  Parse(model, code);
+
+  EXPECT_EQ(model.graph().input_size(), 2);
+  EXPECT_EQ(model.graph().output_size(), 1);
+  EXPECT_EQ(model.graph().node_size(), 2);
+}
+
+TEST(ParserTest, ModelCheckTest) {
+  const char* code = R"ONNX(
+<
+  ir_version: 7,
+  opset_import: [ "" : 10 ]
+>
+agraph (float[N, 128] X, float[128,10] W, float[10] B) => (float[N] C)
+{
+    T = MatMul(X, W)
+    S = Add(T, B)
+    C = Softmax(S)
+}
+)ONNX";
+
+  CheckModel(code);
+}
+
+TEST(ParserTest, IfModelTest) {
+  const char* code = R"ONNX(
+<
+  ir_version: 7,
+  opset_import: [ "" : 13 ]
+>
+iftest (bool b, float[128] X, float[128] Y) => (float[128] Z)
+{
+  Z = If (b) <
+      then_branch = g1 () => (float[128] z_then) { z_then = Identity(X) },
+      else_branch = g2 () => (float[128] z_else) { z_else = Identity(Y) }
+      >
+}
+)ONNX";
+
+  CheckModel(code);
+}
+
+TEST(ParserTest, FunModelTest) {
+  const char* code = R"ONNX(
+<
+  ir_version: 8,
+  opset_import: [ "" : 10, "local" : 1 ]
+>
+agraph (float[N, 128] X, float[128,10] W, float[10] B) => (float[N] C)
+{
+  T = local.foo (X, W, B)
+  C = local.square(T)
+}
+
+<
+  opset_import: [ "" : 10 ],
+  domain: "local",
+  doc_string: "Function foo."
+>
+foo (x, w, b) => (c) {
+  T = MatMul(x, w)
+  S = Add(T, b)
+  c = Softmax(S)
+}
+
+<
+  opset_import: [ "" : 10 ],
+  domain: "local",
+  doc_string: "Function square."
+>
+square (x) => (y) {
+  y = Mul (x, x)
+}
+)ONNX";
+
+  CheckModel(code);
+
+  const char* code_function_with_attributes = R"ONNX(
+<
+  ir_version: 9,
+  opset_import: [ "" : 15, "custom_domain" : 1]
+>
+agraph (float[N] x) => (float[N] out)
+{
+  out = custom_domain.foo<alpha=2.0, gamma=3.0>(x)
+}
+
+<
+domain: "custom_domain",
+opset_import: [ "" : 15],
+doc_string: "function foo"
+>
+  foo
+  <alpha: float=4.0, gamma>
+  (X) => (C)
+  {
+      constant_alpha = Constant<value_float: float=@alpha>()
+      constant_gamma = Constant<value_float: float=@gamma>()
+      constant_alpha_x = Mul(constant_alpha, X)
+      C = Add(constant_alpha_x, constant_gamma)
+  }
+)ONNX";
+
+  CheckModel(code_function_with_attributes);
+}
+
+TEST(ParserTest, TypesModelTest1) {
+  const char* code = R"ONNX(
+    <
+    ir_version: 8,
+    opset_import: [ "" : 18 ]
+    >
+    agraph (seq(float[N]) seqX) => (float[M, N] X)
+    {
+        X = ConcatFromSequence < axis = 0, new_axis = 1 >(seqX)
+    }
+)ONNX";
+  CheckModel(code);
+}
+
+TEST(ParserTest, TypesModelTest2) {
+  const char* code = R"ONNX(
+    <
+    ir_version: 8,
+    opset_import: [ "" : 18 ]
+    >
+    agraph (float[N] tensorX, seq(float[N]) seqX, map(int32, float[N]) mapX, optional(float[N]) optionalX, sparse_tensor(float[N]) sparseX) => (float[N] X)
+    {
+        X = Identity (tensorX)
+    }
+)ONNX";
+  CheckModel(code);
+}
+
+TEST(ParserTest, ExternalDataTest) {
+  const char* code = R"ONNX(
+agraph (float y = {1.0}, float[N] z) => (w) <
+    float[3, 2] m1 = ["location": "weight_1.bin", "offset": "17"],
+    float[2, 1] m2 = {1.0, 2.0}
+>
+{
+    x = Add(y, z)
+    m = Mul(m1, m1)
+}
+)ONNX";
+
+  GraphProto graph;
+  Parse(graph, code);
+
+  EXPECT_EQ(graph.input_size(), 2);
+  EXPECT_EQ(graph.output_size(), 1);
+  EXPECT_EQ(graph.initializer_size(), 3); // m1, m2
+  EXPECT_EQ(graph.value_info_size(), 0); // x
+  EXPECT_EQ(graph.initializer().Get(1).data_location(), TensorProto_DataLocation::TensorProto_DataLocation_EXTERNAL);
+  EXPECT_EQ(graph.initializer().Get(1).external_data().Get(0).key(), "location");
+  EXPECT_EQ(graph.initializer().Get(1).external_data().Get(0).value(), "weight_1.bin");
+  EXPECT_EQ(graph.initializer().Get(1).external_data().Get(1).key(), "offset");
+  EXPECT_EQ(graph.initializer().Get(1).external_data().Get(1).value(), "17");
+}
+
+TEST(ParserTest, QuotedIdentifiersTest) {
+  const char* code = R"ONNX(
+"a graph name" (float[N, 128] "input/X", float[128,10] "input W", float[10] B) => (float[N] C)
+{
+    "some/temp" = MatMul("input/X", "input W")
+    S = Add("some/temp", B)
+    C = Softmax(S)
+}
+)ONNX";
+
+  GraphProto graph;
+  Parse(graph, code);
+
+  EXPECT_EQ(graph.name(), "a graph name");
+  EXPECT_EQ(graph.input_size(), 3);
+  EXPECT_EQ(graph.output_size(), 1);
+  EXPECT_EQ(graph.node_size(), 3);
+  EXPECT_EQ(graph.node(0).input(0), "input/X");
+  EXPECT_EQ(graph.node(0).input(1), "input W");
+  EXPECT_EQ(graph.node(0).output(0), "some/temp");
+}
+
+TEST(ParserTest, QuotedIdentifierTest2) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+"a function name" (float[N] "#y", "$z") => (float[N] "!w")
+<float[N] "/layer/x", float[N] t>
+{
+    "/layer/x" = Add("#y", "$z")
+    t = Add("/layer/x", "/layer/x")
+    "!w" = Mul(t, "#y")
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+}
+
+// Test that float parsing works correctly under a locale that uses comma as decimal separator.
+// This is a regression test for https://github.com/onnx/onnx/issues/8111
+namespace {
+// RAII helper to restore locale on scope exit, ensuring no locale leaks to other tests.
+class LocaleGuard {
+ public:
+  LocaleGuard() {
+    const char* loc = std::setlocale(LC_NUMERIC, nullptr);
+    saved_ = loc ? loc : "C";
+  }
+  ~LocaleGuard() {
+    std::setlocale(LC_NUMERIC, saved_.c_str());
+  }
+  LocaleGuard(const LocaleGuard&) = delete;
+  LocaleGuard& operator=(const LocaleGuard&) = delete;
+
+ private:
+  std::string saved_;
+};
+} // namespace
+
+TEST(ParserTest, LocaleIndependentFloatParsing) {
+  LocaleGuard locale_guard; // Restores locale on any exit path
+
+  // Try to set a locale with comma decimal separator.
+  // Different platforms have different locale names.
+  const char* locale_candidates[] = {
+      "de_DE.UTF-8", // Linux/macOS
+      "German_Germany.1252", // Windows
+      "fr_FR.UTF-8", // Linux/macOS alternative
+      "French_France.1252", // Windows alternative
+  };
+
+  bool locale_set = false;
+  for (const auto* candidate : locale_candidates) {
+    if (std::setlocale(LC_NUMERIC, candidate) != nullptr) {
+      locale_set = true;
+      break;
+    }
+  }
+
+  if (!locale_set) {
+    GTEST_SKIP() << "No locale with comma decimal separator available on this system";
+  }
+
+  // Parse a model with float literals under the comma-decimal locale.
+  const char* code = R"ONNX(
+    <ir_version: 7, opset_import: ["" : 13]>
+    agraph (float[1, 5] X) => (float[1, 5] Y) {
+        Y = LeakyRelu <alpha = 0.123> (X)
+    }
+  )ONNX";
+
+  ModelProto model;
+  OnnxParser parser(code);
+  auto status = parser.Parse(model);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+
+  // Verify the float attribute was parsed correctly (not truncated at the decimal point).
+  ASSERT_EQ(model.graph().node_size(), 1);
+  const auto& node = model.graph().node(0);
+  ASSERT_EQ(node.attribute_size(), 1);
+  EXPECT_EQ(node.attribute(0).name(), "alpha");
+  float alpha = node.attribute(0).f();
+  EXPECT_NEAR(alpha, 0.123f, 1e-6f) << "Float attribute misparsed under non-US locale";
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/schema_registration_test.cc b/onnx/test/cpp/schema_registration_test.cc
new file mode 100644
index 0000000..3202e65
--- /dev/null
+++ b/onnx/test/cpp/schema_registration_test.cc
@@ -0,0 +1,269 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "gtest/gtest.h"
+#include "onnx/defs/operator_sets.h"
+#include "onnx/defs/schema.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+TEST(SchemaRegistrationTest, DisabledOnnxStaticRegistrationAPICall) {
+#ifdef __ONNX_DISABLE_STATIC_REGISTRATION
+  EXPECT_TRUE(IsOnnxStaticRegistrationDisabled());
+#else
+  EXPECT_FALSE(IsOnnxStaticRegistrationDisabled());
+#endif
+}
+
+// Schema of all versions are registered by default
+// Further schema manipulation expects to be error-free
+TEST(SchemaRegistrationTest, RegisterAllByDefaultAndManipulateSchema) {
+#ifndef __ONNX_DISABLE_STATIC_REGISTRATION
+
+  // Expects all opset registered by default
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 0);
+
+  // Should find schema for all versions
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 1));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 6));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 7));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 13));
+
+  // Clear all opset schema registration
+  DeregisterOnnxOperatorSetSchema();
+
+  // Should not find any opset
+  EXPECT_EQ(nullptr, OpSchemaRegistry::Schema("Add"));
+
+  // Register all opset versions
+  RegisterOnnxOperatorSetSchema();
+
+  // Should find all opset
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add"));
+#endif
+}
+
+// By default ONNX registers all opset versions and selective schema loading cannot be tested
+// So these tests are run only when static registration is disabled
+TEST(SchemaRegistrationTest, RegisterAndDeregisterAllOpsetSchemaVersion) {
+#ifdef __ONNX_DISABLE_STATIC_REGISTRATION
+
+  // Clear all opset schema registration
+  DeregisterOnnxOperatorSetSchema();
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), -1);
+
+  // Should not find schema for any op
+  EXPECT_EQ(nullptr, OpSchemaRegistry::Schema("Acos"));
+  EXPECT_EQ(nullptr, OpSchemaRegistry::Schema("Add"));
+  EXPECT_EQ(nullptr, OpSchemaRegistry::Schema("Trilu"));
+
+  // Register all opset versions
+  RegisterOnnxOperatorSetSchema(0);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 0);
+
+  // Should find schema for all ops. Available versions are:
+  // Acos-7
+  // Add-1,6,7,13,14
+  // Trilu-14
+  auto schema = OpSchemaRegistry::Schema("Acos", 7);
+  EXPECT_NE(nullptr, schema);
+  EXPECT_EQ(schema->SinceVersion(), 7);
+
+  schema = OpSchemaRegistry::Schema("Add", 14);
+  EXPECT_NE(nullptr, schema);
+  EXPECT_EQ(schema->SinceVersion(), 14);
+
+  schema = OpSchemaRegistry::Schema("Trilu");
+  EXPECT_NE(nullptr, schema);
+  EXPECT_EQ(schema->SinceVersion(), 14);
+
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 1));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 6));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 7));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 13));
+
+  // Clear all opset schema registration
+  DeregisterOnnxOperatorSetSchema();
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), -1);
+
+  // Should not find schema for any op
+  EXPECT_EQ(nullptr, OpSchemaRegistry::Schema("Acos"));
+  EXPECT_EQ(nullptr, OpSchemaRegistry::Schema("Add"));
+  EXPECT_EQ(nullptr, OpSchemaRegistry::Schema("Trilu"));
+#endif
+}
+
+TEST(SchemaRegistrationTest, RegisterSpecifiedOpsetSchemaVersion) {
+#ifdef __ONNX_DISABLE_STATIC_REGISTRATION
+  DeregisterOnnxOperatorSetSchema();
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), -1);
+  RegisterOnnxOperatorSetSchema(13);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 13);
+
+  auto opSchema = OpSchemaRegistry::Schema("Add");
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 13);
+
+  // Should not find opset 12
+  opSchema = OpSchemaRegistry::Schema("Add", 12);
+  EXPECT_EQ(nullptr, opSchema);
+
+  // Should not find opset 14
+  opSchema = OpSchemaRegistry::Schema("Trilu");
+  EXPECT_EQ(nullptr, opSchema);
+
+  // Acos-7 is the latest Acos before specified 13
+  opSchema = OpSchemaRegistry::Schema("Acos", 13);
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 7);
+#endif
+}
+
+// Register opset-11, then opset-14
+// Expects Reg(11, 14) == Reg(11) U Reg(14)
+TEST(SchemaRegistrationTest, RegisterMultipleOpsetSchemaVersions_UpgradeVersion) {
+#ifdef __ONNX_DISABLE_STATIC_REGISTRATION
+  DeregisterOnnxOperatorSetSchema();
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), -1);
+
+  // Register opset 11
+  RegisterOnnxOperatorSetSchema(11);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 11);
+  // Register opset 14
+  // Do not fail on duplicate schema registration request
+  RegisterOnnxOperatorSetSchema(14, false);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 14);
+
+  // Acos-7 is the latest before/at opset 11 and 14
+  auto opSchema = OpSchemaRegistry::Schema("Acos");
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 7);
+
+  // Add-7 is the latest before/at opset 11
+  // Add-14 is the latest before/at opset 14
+  // Should find both Add-7,14
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 7));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 14));
+
+  // Should find the max version 14
+  opSchema = OpSchemaRegistry::Schema("Add");
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 14);
+
+  // Should find Add-7 as the max version <=13
+  opSchema = OpSchemaRegistry::Schema("Add", 13);
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 7);
+
+  // Should find opset 14
+  opSchema = OpSchemaRegistry::Schema("Trilu");
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 14);
+#endif
+}
+
+// Register opset-14, then opset-11
+// Expects Reg(14, 11) == Reg(11) U Reg(14)
+TEST(SchemaRegistrationTest, RegisterMultipleOpsetSchemaVersions_DowngradeVersion) {
+#ifdef __ONNX_DISABLE_STATIC_REGISTRATION
+  DeregisterOnnxOperatorSetSchema();
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), -1);
+
+  // Register opset 14
+  RegisterOnnxOperatorSetSchema(14);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 14);
+  // Register opset 11
+  // Do not fail on duplicate schema registration request
+  RegisterOnnxOperatorSetSchema(11, false);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 11);
+
+  // Acos-7 is the latest before/at opset 11 and 14
+  auto opSchema = OpSchemaRegistry::Schema("Acos");
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 7);
+
+  // Add-7 is the latest before/at opset 11
+  // Add-14 is the latest before/at opset 14
+  // Should find both Add-7,14
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 7));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 14));
+
+  // Should find the max version 14
+  opSchema = OpSchemaRegistry::Schema("Add");
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 14);
+
+  // Should find Add-7 as the max version <=13
+  opSchema = OpSchemaRegistry::Schema("Add", 13);
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 7);
+
+  // Should find opset 14
+  opSchema = OpSchemaRegistry::Schema("Trilu");
+  EXPECT_NE(nullptr, opSchema);
+  EXPECT_EQ(opSchema->SinceVersion(), 14);
+#endif
+}
+
+// Register opset-11, then all versions
+// Expects no error
+TEST(SchemaRegistrationTest, RegisterSpecificThenAllVersion) {
+#ifdef __ONNX_DISABLE_STATIC_REGISTRATION
+  DeregisterOnnxOperatorSetSchema();
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), -1);
+
+  // Register opset 11
+  RegisterOnnxOperatorSetSchema(11);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 11);
+
+  // Register all opset versions
+  // Do not fail on duplicate schema registration request
+  RegisterOnnxOperatorSetSchema(0, false);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 0);
+
+  // Should find schema for all ops
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Acos"));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add"));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Trilu"));
+
+  // Should find schema for all versions
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 1));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 6));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 7));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 13));
+#endif
+}
+
+// Register all versions, then opset 11
+// Expects no error
+TEST(SchemaRegistrationTest, RegisterAllThenSpecificVersion) {
+#ifdef __ONNX_DISABLE_STATIC_REGISTRATION
+  DeregisterOnnxOperatorSetSchema();
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), -1);
+
+  // Register all opset versions
+  RegisterOnnxOperatorSetSchema(0);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 0);
+
+  // Register opset 11
+  // Do not fail on duplicate schema registration request
+  RegisterOnnxOperatorSetSchema(11, false);
+  EXPECT_EQ(OpSchemaRegistry::Instance()->GetLoadedSchemaVersion(), 11);
+
+  // Should find schema for all ops
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Acos"));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add"));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Trilu"));
+
+  // Should find schema for all versions
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 1));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 6));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 7));
+  EXPECT_NE(nullptr, OpSchemaRegistry::Schema("Add", 13));
+#endif
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/shape_inference_test.cc b/onnx/test/cpp/shape_inference_test.cc
new file mode 100644
index 0000000..ff68f5e
--- /dev/null
+++ b/onnx/test/cpp/shape_inference_test.cc
@@ -0,0 +1,660 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <iostream>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "onnx/defs/parser.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/shape_inference.h"
+#include "onnx/shape_inference/implementation.h"
+
+namespace ONNX_NAMESPACE {
+// onnx/defs/controlflow/old.cc
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void ScanInferenceFunction_opset8(InferenceContext& ctx);
+// onnx/defs/controlflow/defs.cc
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+void ScanInferenceFunction(InferenceContext& ctx);
+
+namespace Test {
+
+template <class Type>
+static void CreateDims(Type& proto, int num_dims) {
+  auto mutable_shape = proto.mutable_shape();
+  mutable_shape->clear_dim();
+
+  for (int i = 0; i < num_dims; ++i)
+    mutable_shape->add_dim();
+}
+
+template <class Type>
+static void SetDimValues(Type& proto, const std::vector<int>& values) {
+  auto mutable_shape = proto.mutable_shape();
+  EXPECT_EQ(static_cast<size_t>(mutable_shape->dim_size()), values.size());
+
+  int idx = 0;
+  for (auto value : values) {
+    auto mutable_dim = mutable_shape->mutable_dim(idx++);
+    if (value != -1)
+      mutable_dim->set_dim_value(value);
+  }
+}
+
+template <class Type>
+static void SetDimParams(Type& proto, const std::vector<const std::string*>& values) {
+  auto mutable_shape = proto.mutable_shape();
+  EXPECT_EQ(static_cast<size_t>(mutable_shape->dim_size()), values.size());
+
+  int idx = 0;
+  for (const auto* const value : values) {
+    auto mutable_dim = mutable_shape->mutable_dim(idx++);
+    if (value)
+      mutable_dim->set_dim_param(*value);
+  }
+}
+
+template <class Type>
+static void Dump(const Type& t) {
+  auto& s_shape = t.shape();
+  auto num_dims = s_shape.dim_size();
+  std::cout << num_dims << " dims. ";
+  for (int i = 0; i < num_dims; ++i) {
+    const auto& x = s_shape.dim(0);
+    auto y = x.has_dim_value();
+    auto z = x.has_dim_param();
+
+    std::cout << "Dim " << i << " Value:" << (y ? ONNX_NAMESPACE::to_string(x.dim_value()) : "<unset>")
+              << ", Param:" << (z ? x.dim_param() : "<unset>") << "\n";
+  }
+}
+
+TEST(ShapeInferenceTest, mergeShapeInfo_HasShape) {
+  // source has shape, target doesn't
+  {
+    TypeProto_Tensor source;
+    TypeProto_Tensor target;
+
+    CreateDims(source, 1);
+    SetDimValues(source, {1});
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_TRUE(shape.dim_size() == 1 && shape.dim(0).dim_value() == 1);
+  }
+
+  // source has no shape, target does
+  {
+    TypeProto_Tensor source;
+    TypeProto_Tensor target;
+
+    CreateDims(target, 1);
+    SetDimValues(target, {1});
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_EQ(shape.dim_size() == 1 && shape.dim(0).dim_value(), 1);
+  }
+  // source has shape, target doesn't
+  {
+    TypeProto_SparseTensor source;
+    TypeProto_SparseTensor target;
+
+    CreateDims(source, 1);
+    SetDimValues(source, {1});
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_EQ(shape.dim_size() == 1 && shape.dim(0).dim_value(), 1);
+  }
+
+  // source has no shape, target does
+  {
+    TypeProto_SparseTensor source;
+    TypeProto_SparseTensor target;
+
+    CreateDims(target, 1);
+    SetDimValues(target, {1});
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_TRUE(shape.dim_size() == 1 && shape.dim(0).dim_value() == 1);
+  }
+}
+TEST(ShapeInferenceTest, mergeShapeInfo_PreferValueOverParam) {
+  std::string param = "A";
+
+  // source has value, target has param. prefer value
+  {
+    TypeProto_Tensor source;
+    TypeProto_Tensor target;
+
+    CreateDims(source, 1);
+    SetDimValues(source, {1});
+
+    CreateDims(target, 1);
+    SetDimParams(target, {&param});
+
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_TRUE(shape.dim_size() == 1 && shape.dim(0).dim_value() == 1);
+  }
+
+  // source has param, target has value.
+  {
+    TypeProto_Tensor source;
+    TypeProto_Tensor target;
+
+    CreateDims(source, 1);
+    SetDimParams(source, {&param});
+
+    CreateDims(target, 1);
+    SetDimValues(target, {1});
+
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_EQ(shape.dim_size() == 1 && shape.dim(0).dim_value(), 1);
+  }
+}
+
+TEST(ShapeInferenceTest, mergeShapeInfo_CombineShapes) {
+  // merge from both sides, preferring real value over -1
+  {
+    TypeProto_Tensor source;
+    TypeProto_Tensor target;
+
+    CreateDims(source, 2);
+    SetDimValues(source, {-1, 2});
+
+    CreateDims(target, 2);
+    SetDimValues(target, {1, -1});
+
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_TRUE(shape.dim(0).dim_value() == 1 && shape.dim(1).dim_value() == 2);
+  }
+
+  {
+    TypeProto_SparseTensor source;
+    TypeProto_SparseTensor target;
+
+    CreateDims(source, 2);
+    SetDimValues(source, {-1, 2});
+
+    CreateDims(target, 2);
+    SetDimValues(target, {1, -1});
+
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_TRUE(shape.dim(0).dim_value() == 1 && shape.dim(1).dim_value() == 2);
+  }
+
+  // prefer value over param,
+  {
+    TypeProto_Tensor source;
+    TypeProto_Tensor target;
+
+    CreateDims(source, 2);
+    SetDimValues(source, {-1, 2});
+
+    CreateDims(target, 2);
+    SetDimValues(target, {1, 0});
+    // replace second dim with a param. the value from the source should be
+    // preferred
+    const std::string param = "A";
+    target.mutable_shape()->mutable_dim(1)->set_dim_param(param);
+
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_TRUE(shape.dim(0).dim_value() == 1 && shape.dim(1).dim_value() == 2);
+  }
+  {
+    TypeProto_SparseTensor source;
+    TypeProto_SparseTensor target;
+
+    CreateDims(source, 2);
+    SetDimValues(source, {-1, 2});
+
+    CreateDims(target, 2);
+    SetDimValues(target, {1, 0});
+    // replace second dim with a param. the value from the source should be
+    // preferred
+    const std::string param = "A";
+    target.mutable_shape()->mutable_dim(1)->set_dim_param(param);
+
+    mergeInShapeInfo(source, target);
+
+    Dump(target);
+    const auto& shape = target.shape();
+    EXPECT_TRUE(shape.dim(0).dim_value() == 1 && shape.dim(1).dim_value() == 2);
+  }
+}
+
+TEST(ShapeInferenceTest, mergeShapeInfo_Mismatches) {
+#ifndef ONNX_NO_EXCEPTIONS
+  // mismatched num dims
+  {
+    TypeProto_Tensor source;
+    TypeProto_Tensor target;
+
+    CreateDims(source, 2);
+    SetDimValues(source, {-1, 2});
+
+    CreateDims(target, 3);
+    SetDimValues(target, {1, -1, 1});
+
+    EXPECT_THROW(mergeInShapeInfo(source, target), ONNX_NAMESPACE::InferenceError);
+  }
+
+  {
+    TypeProto_SparseTensor source;
+    TypeProto_SparseTensor target;
+
+    CreateDims(source, 2);
+    SetDimValues(source, {-1, 2});
+
+    CreateDims(target, 3);
+    SetDimValues(target, {1, -1, 1});
+
+    EXPECT_THROW(mergeInShapeInfo(source, target), ONNX_NAMESPACE::InferenceError);
+  }
+
+  // mismatched dim values
+  {
+    TypeProto_Tensor source;
+    TypeProto_Tensor target;
+
+    CreateDims(source, 2);
+    SetDimValues(source, {2, 2});
+
+    CreateDims(target, 2);
+    SetDimValues(target, {2, 1});
+
+    EXPECT_THROW(mergeInShapeInfo(source, target), ONNX_NAMESPACE::InferenceError);
+  }
+
+  {
+    TypeProto_SparseTensor source;
+    TypeProto_SparseTensor target;
+
+    CreateDims(source, 2);
+    SetDimValues(source, {2, 2});
+
+    CreateDims(target, 2);
+    SetDimValues(target, {2, 1});
+
+    EXPECT_THROW(mergeInShapeInfo(source, target), ONNX_NAMESPACE::InferenceError);
+  }
+#endif
+  // mismatched param value. prefer target
+  {
+    TypeProto_Tensor source;
+    TypeProto_Tensor target;
+    const std::string param_a = "A";
+    const std::string param_b = "B";
+
+    CreateDims(source, 1);
+    SetDimParams(source, {&param_a});
+
+    CreateDims(target, 1);
+    SetDimParams(target, {&param_b});
+
+    mergeInShapeInfo(source, target);
+
+    const auto& shape = target.shape();
+    EXPECT_EQ(shape.dim(0).dim_param(), "B");
+  }
+  {
+    TypeProto_SparseTensor source;
+    TypeProto_SparseTensor target;
+    const std::string param_a = "A";
+    const std::string param_b = "B";
+
+    CreateDims(source, 1);
+    SetDimParams(source, {&param_a});
+
+    CreateDims(target, 1);
+    SetDimParams(target, {&param_b});
+
+    mergeInShapeInfo(source, target);
+
+    const auto& shape = target.shape();
+    EXPECT_EQ(shape.dim(0).dim_param(), "B");
+  }
+}
+
+// Check subgraph inferencing via GraphInferencer using a Scan
+static void doInferencingTest(bool use_scan_opset8) {
+  OpSchemaRegistry::Instance();
+  GraphProto subgraph;
+
+  // simple tensor without shape info
+  TypeProto simple_tensor_no_shape;
+  auto* tensor_type = simple_tensor_no_shape.mutable_tensor_type();
+  tensor_type->set_elem_type(TensorProto_DataType_FLOAT);
+
+  // simple tensor with shape info
+  TypeProto simple_tensor = simple_tensor_no_shape;
+  simple_tensor.mutable_tensor_type()->mutable_shape()->add_dim()->set_dim_value(2);
+
+  // setup simple graph that can be used with Scan containing two Identity
+  // nodes. one for the loop state variable. one for the scan output.
+  {
+    NodeProto loop_state_identity;
+    loop_state_identity.set_name("loop_state_identity");
+    loop_state_identity.set_domain(ONNX_DOMAIN);
+    loop_state_identity.set_op_type("Identity");
+    loop_state_identity.set_doc_string("loop state identity");
+    loop_state_identity.add_input("loop_state_in");
+    loop_state_identity.add_output("loop_state_out");
+
+    *subgraph.add_node() = loop_state_identity;
+
+    NodeProto scan_in_out_identity;
+    scan_in_out_identity.set_name("scan_in_out_identity");
+    scan_in_out_identity.set_domain(ONNX_DOMAIN);
+    scan_in_out_identity.set_op_type("Identity");
+    scan_in_out_identity.set_doc_string("scan identity");
+    scan_in_out_identity.add_input("scan_in");
+    scan_in_out_identity.add_output("scan_out");
+    *subgraph.add_node() = scan_in_out_identity;
+
+    ValueInfoProto loop_state_in;
+    loop_state_in.set_name("loop_state_in");
+    *loop_state_in.mutable_type() = simple_tensor;
+    *subgraph.add_input() = loop_state_in;
+
+    ValueInfoProto scan_in;
+    scan_in.set_name("scan_in");
+    *scan_in.mutable_type() = simple_tensor;
+    *subgraph.add_input() = scan_in;
+
+    ValueInfoProto loop_state_out = loop_state_in;
+    loop_state_out.set_name("loop_state_out");
+    *loop_state_out.mutable_type() = simple_tensor_no_shape;
+    *subgraph.add_output() = loop_state_out;
+
+    ValueInfoProto scan_state_out = scan_in;
+    scan_state_out.set_name("scan_out");
+    *scan_state_out.mutable_type() = simple_tensor_no_shape;
+    *subgraph.add_output() = scan_state_out;
+  }
+
+  std::unordered_map<std::string, int> opset_imports;
+  opset_imports[ONNX_DOMAIN] = 8; // Scan is v8
+
+  const std::unordered_map<std::string, TypeProto*> outer_scope_value_types;
+  shape_inference::SymbolTableImpl symbolTable;
+  symbolTable.addFromGraph(subgraph);
+  shape_inference::GraphInferenceContext graphInfCtx(outer_scope_value_types, opset_imports, &symbolTable);
+  shape_inference::GraphInferencerImpl graphInferencer(subgraph, graphInfCtx);
+
+  // loop_state_in and scan_in are the two inputs.
+  // order in subgraphInputTypes matches their order as graph inputs.
+  std::vector<const TypeProto*> subgraphInputTypes = {&simple_tensor, &simple_tensor};
+
+  std::vector<const TensorProto*> subgraphInputData = {};
+  ShapeInferenceOptions options{false, 0, false};
+  auto output = graphInferencer.doInferencing(subgraphInputTypes, subgraphInputData);
+
+  // check the subgraph outputs had their shape inferred when we called
+  // doInferencing directly
+  EXPECT_EQ(output.size(), 2);
+
+  auto checkType = [](const TypeProto& type, const TypeProto_Tensor& expect) {
+    auto checkDims = [](const TensorShapeProto& l, const TensorShapeProto& r) {
+      EXPECT_EQ(l.dim_size(), r.dim_size());
+
+      for (int i = 0, end = l.dim_size(); i < end; ++i) {
+        // if (l.dim().Get(i).dim_value() != r.dim().Get(i).dim_value())
+        //  break;
+        EXPECT_EQ(l.dim().Get(i).dim_value(), r.dim().Get(i).dim_value());
+      }
+    };
+
+    EXPECT_TRUE(type.has_tensor_type());
+    EXPECT_EQ(type.tensor_type().elem_type(), expect.elem_type());
+    checkDims(type.tensor_type().shape(), expect.shape());
+  };
+
+  checkType(*output[0], simple_tensor.tensor_type());
+  checkType(*output[1], simple_tensor.tensor_type());
+
+  // setup Scan node to test subgraph inferencing works as expected when called
+  // from the operators type/shape inferencing function
+  NodeProto scan;
+  {
+    AttributeProto num_scan_inputs;
+    num_scan_inputs.set_name("num_scan_inputs");
+    num_scan_inputs.set_i(1);
+
+    AttributeProto body;
+    body.set_name("body");
+    *body.mutable_g() = subgraph;
+
+    *scan.add_attribute() = num_scan_inputs;
+    *scan.add_attribute() = body;
+
+    scan.set_name("Scan");
+    scan.set_domain(ONNX_DOMAIN);
+    scan.set_doc_string("Scan node");
+    scan.set_op_type("Scan");
+    if (use_scan_opset8)
+      scan.add_input(""); // optional sequence lens
+    scan.add_input("loop_state_start");
+    scan.add_input("scan_op_in");
+    scan.add_output("loop_state_final");
+    scan.add_output("scan_op_out");
+  }
+
+  TypeProto loop_state_in_tensor = simple_tensor_no_shape;
+  auto* shape = loop_state_in_tensor.mutable_tensor_type()->mutable_shape();
+  if (use_scan_opset8)
+    shape->add_dim()->set_dim_value(1); // batch size
+  shape->add_dim()->set_dim_value(2); // input size. must match subgraph
+
+  TypeProto loop_state_out_tensor = loop_state_in_tensor; // should be unchanged
+
+  TypeProto scan_in_tensor = simple_tensor_no_shape;
+  shape = scan_in_tensor.mutable_tensor_type()->mutable_shape();
+  if (use_scan_opset8)
+    shape->add_dim()->set_dim_value(1); // batch size
+  shape->add_dim()->set_dim_value(1); // sequence length
+  shape->add_dim()->set_dim_value(2); // input size. must match subgraph
+
+  TypeProto scan_out_tensor = scan_in_tensor; // should be unchanged
+
+  std::unordered_map<std::string, TypeProto*> valueTypesByName;
+  valueTypesByName["loop_state_start"] = &loop_state_in_tensor;
+  valueTypesByName["scan_op_in"] = &scan_in_tensor;
+
+  shape_inference::InferenceContextImpl ctx(scan, valueTypesByName, {}, {}, options, {}, &graphInfCtx);
+  if (use_scan_opset8)
+    ScanInferenceFunction_opset8(ctx);
+  else
+    ScanInferenceFunction(ctx);
+
+  EXPECT_EQ(ctx.getNumOutputs(), 2);
+  checkType(*ctx.getOutputType(0), loop_state_out_tensor.tensor_type());
+  checkType(*ctx.getOutputType(1), scan_out_tensor.tensor_type());
+}
+
+// Check subgraph inferencing via GraphInferencer using a Scan (from opset 8)
+TEST(GraphInferencerImplTest, Scan8_BasicTest) {
+  doInferencingTest(true);
+}
+
+// Check subgraph inferencing via GraphInferencer using a Scan (from opset 9)
+TEST(GraphInferencerImplTest, Scan9_BasicTest) {
+  doInferencingTest(false);
+}
+
+static void ParseAndInfer(ModelProto& model, const char* modelStr) {
+  OnnxParser parser(modelStr);
+  auto status = parser.Parse(model);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+  EXPECT_TRUE(parser.EndOfInput()) << "Extra unparsed input unexpected.";
+
+  ShapeInferenceOptions options{true, 1, true};
+  ONNX_NAMESPACE::shape_inference::InferShapes(model, ONNX_NAMESPACE::OpSchemaRegistry::Instance(), options);
+}
+
+static void RunReshapeShapeInfTest(const char* modelStr, TensorShapeProto& expectedShape) {
+  ModelProto model;
+  ParseAndInfer(model, modelStr);
+
+  const auto inferredShape = model.graph().output(0).type().tensor_type().shape();
+  EXPECT_EQ(inferredShape.dim_size(), expectedShape.dim_size());
+
+  for (int i = 0; i < inferredShape.dim_size(); i++) {
+    EXPECT_TRUE(
+        (inferredShape.dim(i).has_dim_value() && expectedShape.dim(i).has_dim_value()) ||
+        (inferredShape.dim(i).has_dim_param() && expectedShape.dim(i).has_dim_param()));
+
+    EXPECT_TRUE(
+        inferredShape.dim(i).has_dim_value() ? inferredShape.dim(i).dim_value() == expectedShape.dim(i).dim_value()
+                                             : inferredShape.dim(i).dim_param() == expectedShape.dim(i).dim_param());
+  }
+}
+TEST(ShapeInferenceTest, ReshapeTestWithShapeAsSymInput) {
+  const char* modelStr = R"ONNX(
+<
+  ir_version: 8,
+  opset_import: [ "" : 15],
+  producer_name: "DataPropagationTest",
+  producer_version: "1.0",
+  model_version: 1,
+  doc_string: "A test model for data propagation."
+>
+agraph (float[batch_size, 256, 768, 3] x, float[batch_size, 196608] m) => (float[?, ?, ?] z)
+{
+    y = Shape<start = 0, end = 3>(x)
+    z = Reshape(m, y)
+}
+)ONNX";
+
+  TensorShapeProto expectedShape;
+  expectedShape.mutable_dim()->Add()->set_dim_param("batch_size");
+  expectedShape.mutable_dim()->Add()->set_dim_value(256);
+  expectedShape.mutable_dim()->Add()->set_dim_value(768);
+
+  RunReshapeShapeInfTest(modelStr, expectedShape);
+}
+
+TEST(ShapeInferenceTest, ReshapeTestWithShapeAsInitializer) {
+  const char* modelStr = R"ONNX(
+<
+  ir_version: 8,
+  opset_import: [ "" : 15],
+  producer_name: "DataPropagationTest",
+  producer_version: "1.0",
+  model_version: 1,
+  doc_string: "A test model for data propagation."
+>
+agraph (float[1, 196608] m) => (float[?, ?, ?] z)
+<int64[3] shape = {1, 768, 256}>
+{
+    z = Reshape(m, shape)
+}
+)ONNX";
+
+  TensorShapeProto expectedShape;
+  expectedShape.mutable_dim()->Add()->set_dim_value(1);
+  expectedShape.mutable_dim()->Add()->set_dim_value(768);
+  expectedShape.mutable_dim()->Add()->set_dim_value(256);
+
+  RunReshapeShapeInfTest(modelStr, expectedShape);
+}
+
+TEST(ShapeInferenceTest, ReshapeTestWithShapeAsInitializer1) {
+  const char* modelStr = R"ONNX(
+<
+  ir_version: 8,
+  opset_import: [ "" : 15],
+  producer_name: "DataPropagationTest",
+  producer_version: "1.0",
+  model_version: 1,
+  doc_string: "A test model for data propagation."
+>
+agraph (float[1, 196608] m) => (float[?, ?, ?] z)
+<int64[3] shape = {1, -1, 256}>
+{
+    z = Reshape(m, shape)
+}
+)ONNX";
+
+  TensorShapeProto expectedShape;
+  expectedShape.mutable_dim()->Add()->set_dim_value(1);
+  expectedShape.mutable_dim()->Add()->set_dim_value(768);
+  expectedShape.mutable_dim()->Add()->set_dim_value(256);
+
+  RunReshapeShapeInfTest(modelStr, expectedShape);
+}
+
+TEST(ShapeInferenceTest, CheckShapesAndTypesTest) {
+#ifndef ONNX_NO_EXCEPTIONS
+  // Tensor element types mismatch should cause an exception.
+  TypeProto tensor_infer;
+  auto* tensor_infer_type = tensor_infer.mutable_tensor_type();
+  tensor_infer_type->set_elem_type(TensorProto_DataType_FLOAT);
+
+  TypeProto tensor_exist;
+  auto* tensor_exist_type = tensor_exist.mutable_tensor_type();
+  tensor_exist_type->set_elem_type(TensorProto_DataType_UINT8);
+
+  EXPECT_THROW(shape_inference::checkShapesAndTypes(tensor_infer, tensor_exist), ONNX_NAMESPACE::InferenceError);
+#endif
+}
+
+TEST(ShapeInferenceTest, CustomOpTest) {
+  const char* modelStr = R"ONNX(
+<ir_version: 8,  opset_import: ["" : 15, "custom.domain" : 1]>
+agraph (float[256, 768, 3] x) => (z1, z2)
+{
+    z1 = custom.domain.CustomOp (x)
+    # Inference cannot determine the type/shape of z1
+    z2 = Abs(x)
+    # Inference SHOULD determine the type/shape of z2 (same as that of x)
+}
+)ONNX";
+
+  ModelProto model;
+  ParseAndInfer(model, modelStr);
+
+  const auto& z1_value_info = model.graph().output(0);
+  // Check no inferred type for z1 (It's a quirk of the implementation that it
+  // has a dummy TypeProto, but it should have no values filled in.)
+  ASSERT_TRUE(z1_value_info.has_type());
+  ASSERT_FALSE(z1_value_info.type().has_tensor_type());
+
+  // Check inferred type for z2:
+  const auto& z2_value_info = model.graph().output(1);
+  ASSERT_TRUE(z2_value_info.has_type());
+  ASSERT_TRUE(z2_value_info.type().has_tensor_type());
+  EXPECT_EQ(z2_value_info.type().tensor_type().elem_type(), TensorProto_DataType_FLOAT);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim_size(), 3);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim(0).dim_value(), 256);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim(1).dim_value(), 768);
+  EXPECT_EQ(z2_value_info.type().tensor_type().shape().dim(2).dim_value(), 3);
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/tensor_test.cc b/onnx/test/cpp/tensor_test.cc
new file mode 100644
index 0000000..b76c0fb
--- /dev/null
+++ b/onnx/test/cpp/tensor_test.cc
@@ -0,0 +1,47 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <cstdint>
+#include <limits>
+
+#include "gtest/gtest.h"
+#include "onnx/common/assertions.h"
+#include "onnx/common/tensor.h"
+
+namespace ONNX_NAMESPACE {
+namespace Test {
+
+constexpr int64_t kLargeDim = int64_t{1} << 62;
+
+TEST(TensorTest, ElemNumScalar) {
+  Tensor t;
+  EXPECT_EQ(t.elem_num(), 1);
+}
+
+TEST(TensorTest, ElemNumZeroDim) {
+  Tensor t;
+  t.sizes() = {0, 3};
+  EXPECT_EQ(t.elem_num(), 0);
+}
+
+TEST(TensorTest, ElemNumOverflowThrows) {
+  Tensor t;
+  t.sizes() = {kLargeDim, kLargeDim};
+  EXPECT_THROW(t.elem_num(), tensor_error);
+}
+
+TEST(TensorTest, ElemNumNegativeDimThrows) {
+  Tensor t;
+  t.sizes() = {-1, 4};
+  EXPECT_THROW(t.elem_num(), tensor_error);
+}
+
+TEST(TensorTest, SizeFromDimOverflowThrows) {
+  Tensor t;
+  t.sizes() = {2, kLargeDim, kLargeDim};
+  EXPECT_THROW(t.size_from_dim(1), tensor_error);
+}
+
+} // namespace Test
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/test/cpp/test_main.cc b/onnx/test/cpp/test_main.cc
new file mode 100644
index 0000000..6b5c06d
--- /dev/null
+++ b/onnx/test/cpp/test_main.cc
@@ -0,0 +1,13 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include <iostream>
+
+#include "gtest/gtest.h"
+
+int main(int argc, char** argv) {
+  std::cout << "Running main() from test_main.cc" << '\n';
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/onnx/test/cpp/type_builders_test.cc b/onnx/test/cpp/type_builders_test.cc
new file mode 100644
index 0000000..618edb5
--- /dev/null
+++ b/onnx/test/cpp/type_builders_test.cc
@@ -0,0 +1,53 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "gtest/gtest.h"
+#include "onnx/defs/schema.h"
+#include "onnx/defs/type_builders.h"
+
+namespace ONNX_NAMESPACE::Test {
+
+namespace t = ONNX_NAMESPACE::types;
+
+TEST(TypeBuildersTest, Factories) {
+  EXPECT_EQ(t::Tensor(TensorProto::FLOAT), t::Float);
+  EXPECT_EQ(t::SparseTensor(TensorProto::FLOAT), "sparse_tensor(float)");
+  EXPECT_EQ(t::Sequence(t::Float), "seq(tensor(float))");
+  EXPECT_EQ(t::Optional(t::Sequence(t::Double)), "optional(seq(tensor(double)))");
+}
+
+TEST(TypeBuildersTest, MapConvention) {
+  // Space after the comma; bare-scalar value form for ai.onnx.ml schemas.
+  EXPECT_EQ(t::Map<TensorProto::INT64>(t::Float), "map(int64, tensor(float))");
+  EXPECT_EQ(t::Map<TensorProto::INT64>("float"), "map(int64, float)");
+}
+
+// Invalid map keys are rejected at compile time via static_assert; uncomment to
+// verify it fails to compile:
+//   t::Map<TensorProto::FLOAT>(t::Int64);
+//   t::Map<TensorProto::BOOL>(t::Int64);
+
+TEST(TypeBuildersTest, VectorHelpers) {
+  EXPECT_EQ(
+      t::Tensors({TensorProto::FLOAT, TensorProto::INT64}),
+      (std::vector<std::string>{"tensor(float)", "tensor(int64)"}));
+  EXPECT_EQ(t::SparseTensors({TensorProto::FLOAT}), (std::vector<std::string>{"sparse_tensor(float)"}));
+  EXPECT_EQ(
+      t::Sequence(std::vector<std::string>{t::Float, t::Int64}),
+      (std::vector<std::string>{"seq(tensor(float))", "seq(tensor(int64))"}));
+  EXPECT_EQ(t::Optional(std::vector<std::string>{t::Bool}), (std::vector<std::string>{"optional(tensor(bool))"}));
+  EXPECT_EQ(t::Concat(std::vector<std::string>{"a", "b"}, {"c"}), (std::vector<std::string>{"a", "b", "c"}));
+}
+
+TEST(TypeBuildersTest, DropsIntoOpSchema) {
+  OpSchema schema;
+  schema.TypeConstraint("T", {t::Float, t::Sequence(t::Float), t::Optional(t::Int64)}, "test");
+  const auto& tcp = schema.typeConstraintParams().front();
+  ASSERT_EQ(tcp.allowed_type_strs.size(), 3u);
+  EXPECT_EQ(tcp.allowed_type_strs[0], "tensor(float)");
+  EXPECT_EQ(tcp.allowed_type_strs[1], "seq(tensor(float))");
+  EXPECT_EQ(tcp.allowed_type_strs[2], "optional(tensor(int64))");
+}
+
+} // namespace ONNX_NAMESPACE::Test
diff --git a/onnx/test/cpp/utf8_conversion_test.cc b/onnx/test/cpp/utf8_conversion_test.cc
new file mode 100644
index 0000000..ee2cedf
--- /dev/null
+++ b/onnx/test/cpp/utf8_conversion_test.cc
@@ -0,0 +1,27 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef _WIN32
+#include <string>
+
+#include "gtest/gtest.h"
+#include "onnx/common/path.h"
+namespace ONNX_NAMESPACE::Test {
+
+TEST(UTF8Test, WideStringConversion) {
+  std::string utf8_str(u8"世界，你好！");
+  EXPECT_EQ(ONNX_NAMESPACE::wstring_to_utf8str(ONNX_NAMESPACE::utf8str_to_wstring(utf8_str)), utf8_str);
+}
+
+#ifndef ONNX_NO_EXCEPTIONS
+TEST(UTF8Test, InvalidUtf8Rejected) {
+  // Raw wchar_t bytes are not valid UTF-8 — must be rejected (fail-closed).
+  std::string utf8_str(u8"世界，你好！");
+  auto wstr = ONNX_NAMESPACE::utf8str_to_wstring(utf8_str);
+  std::string raw_bytes(reinterpret_cast<const char*>(wstr.c_str()), sizeof(std::wstring::value_type) * wstr.size());
+  EXPECT_THROW(ONNX_NAMESPACE::utf8str_to_wstring(raw_bytes), ONNX_NAMESPACE::checker::ValidationError);
+}
+#endif
+} // namespace ONNX_NAMESPACE::Test
+#endif
diff --git a/onnx/test/data_propagation_test.py b/onnx/test/data_propagation_test.py
new file mode 100644
index 0000000..fc500d0
--- /dev/null
+++ b/onnx/test/data_propagation_test.py
@@ -0,0 +1,245 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from shape_inference_test import TestShapeInferenceHelper
+
+import onnx.parser
+from onnx import TensorProto
+from onnx.helper import make_node, make_tensor, make_tensor_value_info
+
+
+class TestDataPropagation(TestShapeInferenceHelper):
+    def test_expand_symbolic_input(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.INT32, (3, 1, 2)), ("y", TensorProto.INT32, (1, 4, 2))],
+            [
+                make_node("Shape", ["y"], ["shape"]),
+                make_node("Expand", ["x", "shape"], ["z"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("z", TensorProto.INT32, (3, 4, 2)),
+            ],
+            data_prop=True,
+        )
+
+    def test_constantofshape_with_symbolic_shape(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5))],
+            [
+                make_node("Shape", ["x"], ["shape"]),
+                make_node(
+                    "ConstantOfShape",
+                    ["shape"],
+                    ["y"],
+                    value=make_tensor("value", TensorProto.INT32, (1,), (2,)),
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("y", TensorProto.INT32, (3, 4, 5)),
+            ],
+            data_prop=True,
+        )
+
+    def test_model_data_propagation(self) -> None:
+        """Infer the shape of z by propagating the value of xshape."""
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 18]>
+            agraph (float[4, 1, 16] x, float[1, 8, 16] y) => () {
+                xshape = Shape (x)
+                z = Expand (y, xshape)
+            }
+        """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("xshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (4, 8, 16)),
+            ],
+            data_prop=True,
+        )
+
+    def test_data_prop_via_function(self) -> None:
+        """Test value-propagation through function calls.
+        Underlying core example is same as previous test_model_data_propagation.
+        """
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 18, "local" : 1 ]>
+            agraph (float[4, 1, 16] x, float[1, 8, 16] y) => () {
+                xshape = local.GetShape (x)
+                z = Expand (y, xshape)
+            }
+            <domain: "local", opset_import: [ "" : 18 ]>
+            GetShape (x) => (shapeval) {
+                shapeval = Shape(x)
+            }
+        """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("xshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (4, 8, 16)),
+            ],
+            data_prop=True,
+        )
+
+    def test_multiple_calls_to_function(self) -> None:
+        """Test value-propagation handles multiple calls to same function correctly.
+        Underlying core example is same as previous test_model_data_propagation.
+        """
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 18, "local" : 1 ]>
+            agraph (float[4, 1, 16] x, float[1, 8, 16] y) => () {
+                yshape = local.GetShape (y)
+                xshape = local.GetShape (x)
+                z = Expand (y, xshape)
+                w = Expand (y, yshape)
+            }
+            <domain: "local", opset_import: [ "" : 18 ]>
+            GetShape (x) => (shapeval) {
+                shapeval = Shape(x)
+            }
+        """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("yshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("xshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (4, 8, 16)),
+                make_tensor_value_info("w", TensorProto.FLOAT, (1, 8, 16)),
+            ],
+            data_prop=True,
+        )
+
+    def test_shape_arithmetic(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("y", TensorProto.FLOAT, (1, 2, 3))],
+            [
+                make_node("Shape", ["x"], ["xshape"]),
+                make_node("Shape", ["y"], ["yshape"]),
+                make_node("Add", ["xshape", "yshape"], ["zshape"]),
+                make_node(
+                    "ConstantOfShape",
+                    ["zshape"],
+                    ["z"],
+                    value=make_tensor("value", TensorProto.INT32, (1,), (2,)),
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("xshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("yshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("zshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("z", TensorProto.INT32, (4, 6, 8)),
+            ],
+            data_prop=True,
+        )
+
+    def test_shape_arithmetic_with_broadcast(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("y", TensorProto.FLOAT, (3,))],
+            [
+                make_node("Shape", ["x"], ["xshape"]),
+                make_node("Shape", ["y"], ["yshape"]),
+                make_node("Add", ["xshape", "yshape"], ["zshape"]),
+                make_node(
+                    "ConstantOfShape",
+                    ["zshape"],
+                    ["z"],
+                    value=make_tensor("value", TensorProto.INT32, (1,), (2,)),
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("xshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("yshape", TensorProto.INT64, (1,)),
+                make_tensor_value_info("zshape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("z", TensorProto.INT32, (6, 7, 8)),
+            ],
+            data_prop=True,
+        )
+
+    def test_shape_arithmetic_with_zero_broadcast(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ()), ("y", TensorProto.FLOAT, (3,))],
+            [
+                make_node("Shape", ["x"], ["xshape"]),
+                make_node("Shape", ["y"], ["yshape"]),
+                make_node("Add", ["xshape", "yshape"], ["zshape"]),
+                make_node(
+                    "ConstantOfShape",
+                    ["zshape"],
+                    ["z"],
+                    value=make_tensor("value", TensorProto.INT32, (1,), (2,)),
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("xshape", TensorProto.INT64, (0,)),
+                make_tensor_value_info("yshape", TensorProto.INT64, (1,)),
+                make_tensor_value_info("zshape", TensorProto.INT64, (0,)),
+                make_tensor_value_info("z", TensorProto.INT32, ()),
+            ],
+            data_prop=True,
+        )
+
+    def test_empty_tensor(self) -> None:
+        """Test that a Concat with an empty tensor as input is handled correctly by data-propagation."""
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[256] y) => (float[N] z)
+            <float[0] x = {}>
+            {
+                z = Concat <axis=0> (x, y)
+            }
+        """
+        )
+        inferred_model = onnx.shape_inference.infer_shapes(model, True, True, True)
+        output = inferred_model.graph.output[0]
+        assert output.type.tensor_type.shape.dim[0].dim_value == 256
+
+    def test_empty_tensor_negative_axis(self) -> None:
+        """Test that a Concat with an empty tensor as input is handled correctly by data-propagation.
+        This time with a negative axis.
+        """
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[256] y) => (float[N] z)
+            <float[0] x = {}>
+            {
+                z = Concat <axis=-1> (x, y)
+            }
+        """
+        )
+        inferred_model = onnx.shape_inference.infer_shapes(model, True, True, True)
+        output = inferred_model.graph.output[0]
+        assert output.type.tensor_type.shape.dim[0].dim_value == 256
diff --git a/onnx/test/function_inference_test.py b/onnx/test/function_inference_test.py
new file mode 100644
index 0000000..29fbfc1
--- /dev/null
+++ b/onnx/test/function_inference_test.py
@@ -0,0 +1,119 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pytest
+from shape_inference_test import TestShapeInferenceHelper
+
+import onnx
+import onnx.helper
+import onnx.parser
+import onnx.shape_inference
+from onnx import AttributeProto, TypeProto
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+float_type_ = onnx.helper.make_tensor_type_proto(1, None)
+uint8_type_ = onnx.helper.make_tensor_type_proto(2, None)
+int8_type_ = onnx.helper.make_tensor_type_proto(3, None)
+int32_type_ = onnx.helper.make_tensor_type_proto(6, None)
+float16_type_ = onnx.helper.make_tensor_type_proto(10, None)
+no_type_ = TypeProto()
+
+
+class TestFunctionInference(TestShapeInferenceHelper):
+    def _check(
+        self,
+        function_text: str,
+        input_types: Sequence[TypeProto],
+        attributes: Sequence[AttributeProto],
+        expected_output_types: Sequence[TypeProto],
+    ):
+        function = onnx.parser.parse_function(function_text)
+        result = onnx.shape_inference.infer_function_output_types(
+            function, input_types, attributes
+        )
+        assert len(expected_output_types) == len(result)
+        for expected, actual in zip(expected_output_types, result, strict=True):
+            self._compare_value_infos(expected, actual)
+
+    def _check_fails(
+        self,
+        function_text: str,
+        input_types: Sequence[TypeProto],
+        attributes: Sequence[AttributeProto],
+    ):
+        function = onnx.parser.parse_function(function_text)
+
+        def invoke_inference():
+            onnx.shape_inference.infer_function_output_types(
+                function, input_types, attributes
+            )
+
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            invoke_inference()
+
+    def test_fi_basic(self):
+        code = """
+            <opset_import: [ "" : 18 ], domain: "local">
+            f (y, z) => (w) {
+                x = Add(y, z)
+                w = Mul(x, y)
+            }
+        """
+        self._check(code, [float_type_, float_type_], [], [float_type_])
+        self._check(code, [int32_type_, int32_type_], [], [int32_type_])
+        self._check_fails(code, [float_type_, int32_type_], [])
+
+    def test_fi_attribute(self):
+        code = """
+            <opset_import: [ "" : 18 ], domain: "local">
+            CastTo <dtype> (x) => (y) {
+                y = Cast <to : int = @dtype> (x)
+            }
+        """
+        dtype_6 = onnx.helper.make_attribute("dtype", 6)
+        self._check(code, [float_type_], [dtype_6], [int32_type_])
+
+        dtype_10 = onnx.helper.make_attribute("dtype", 10)
+        self._check(code, [float_type_], [dtype_10], [float16_type_])
+
+    def test_fi_optional_input(self):
+        code = """
+            <opset_import: [ "" : 18 ], domain: "local">
+            DoReduce (x, axes) => (y) {
+                y = ReduceMax (x, axes)
+            }
+        """
+        # We can omit the type for a missing trailing optional parameter
+        self._check(code, [float_type_], [], [float_type_])
+        # Or, we can pass in a default-value of TypeProto() for a missing optional parameter
+        self._check(code, [float_type_, no_type_], [], [float_type_])
+
+        code = """
+            <opset_import: [ "" : 18 ], domain: "local">
+            Quantize (x, scale, zero_point) => (y) {
+                y = QuantizeLinear (x, scale, zero_point)
+            }
+        """
+        # If the optional third parameter is specified, it determines the output type.
+        self._check(code, [float_type_, float_type_, int8_type_], [], [int8_type_])
+        self._check(code, [float_type_, float_type_, uint8_type_], [], [uint8_type_])
+        # If the optional third parameter is omitted, the output type is uint8 (default).
+        self._check(code, [float_type_, float_type_, no_type_], [], [uint8_type_])
+
+        code = """
+            <opset_import: [ "" : 18 ], domain: "local">
+            DoClip (x, min, max) => (y) {
+                y = Clip (x, min, max)
+            }
+        """
+        # A test-case with a non-trailing missing optional parameter
+        self._check(code, [float_type_, no_type_, float_type_], [], [float_type_])
+
+        # A failing test-case with a non-trailing missing optional parameter
+        self._check_fails(code, [float_type_, no_type_, int8_type_], [])
diff --git a/onnx/test/function_test.py b/onnx/test/function_test.py
new file mode 100644
index 0000000..c6b47a3
--- /dev/null
+++ b/onnx/test/function_test.py
@@ -0,0 +1,221 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Copyright (c) ONNX Project Contributors
+from __future__ import annotations
+
+import onnx
+from onnx import checker, utils
+
+
+class TestFunction:
+    def _verify_function_set(self, extracted_model, function_set, func_domain):
+        checker.check_model(extracted_model)
+        assert len(extracted_model.functions) == len(function_set)
+        for function in function_set:
+            assert (
+                next(
+                    (
+                        f
+                        for f in extracted_model.functions
+                        if f.name == function and f.domain == func_domain
+                    ),
+                    None,
+                )
+                is not None
+            )
+
+    def test_extract_model_with_local_function(self) -> None:
+        r"""#   1. build a model with graph below. extract models with output combinations
+        #   2. validate extracted models' local functions
+        #
+        # model graph:
+        #      i0                    i1                 i2
+        #      |   __________________|__________________/_________
+        #      |  |                  |             |   /          |
+        #      |  |                  |             |  /           |
+        #   func_add        func_identity          add         identity
+        #    |  ___\___________\____________________|_________    |
+        #    | |    \           \                   |  _______|___|
+        #    | |     \           \                  | |       |   |
+        #    add     function_nested_identity_add   add     function_nested_identity_add
+        #     |                 |                    |              |
+        #     |                 |                    |              |
+        #   o_func_add      o_all_func0           o_no_func     o_all_func1
+        #
+        # where function_nested_identity_add is a function that is defined with functions:
+        #       a               b
+        #       |               |
+        #   func_identity   func_identity
+        #             \       /
+        #             func_add
+        #                |
+        #                c
+        #
+        """
+        # function common
+        func_domain = "local"
+        func_opset_imports = [onnx.helper.make_opsetid("", 14)]
+        func_nested_opset_imports = [
+            onnx.helper.make_opsetid("", 14),
+            onnx.helper.make_opsetid(func_domain, 1),
+        ]
+
+        # add function
+        func_add_name = "func_add"
+        func_add_inputs = ["a", "b"]
+        func_add_outputs = ["c"]
+        func_add_nodes = [onnx.helper.make_node("Add", ["a", "b"], ["c"])]
+        func_add = onnx.helper.make_function(
+            func_domain,
+            func_add_name,
+            func_add_inputs,
+            func_add_outputs,
+            func_add_nodes,
+            func_opset_imports,
+        )
+
+        # identity function
+        func_identity_name = "func_identity"
+        func_identity_inputs = ["a"]
+        func_identity_outputs = ["b"]
+        func_identity_nodes = [onnx.helper.make_node("Identity", ["a"], ["b"])]
+        func_identity = onnx.helper.make_function(
+            func_domain,
+            func_identity_name,
+            func_identity_inputs,
+            func_identity_outputs,
+            func_identity_nodes,
+            func_opset_imports,
+        )
+
+        # nested identity/add function
+        func_nested_identity_add_name = "func_nested_identity_add"
+        func_nested_identity_add_inputs = ["a", "b"]
+        func_nested_identity_add_outputs = ["c"]
+        func_nested_identity_add_nodes = [
+            onnx.helper.make_node("func_identity", ["a"], ["a1"], domain=func_domain),
+            onnx.helper.make_node("func_identity", ["b"], ["b1"], domain=func_domain),
+            onnx.helper.make_node("func_add", ["a1", "b1"], ["c"], domain=func_domain),
+        ]
+        func_nested_identity_add = onnx.helper.make_function(
+            func_domain,
+            func_nested_identity_add_name,
+            func_nested_identity_add_inputs,
+            func_nested_identity_add_outputs,
+            func_nested_identity_add_nodes,
+            func_nested_opset_imports,
+        )
+
+        # create graph nodes
+        node_func_add = onnx.helper.make_node(
+            func_add_name, ["i0", "i1"], ["t0"], domain=func_domain
+        )
+        node_add0 = onnx.helper.make_node("Add", ["i1", "i2"], ["t2"])
+        node_add1 = onnx.helper.make_node("Add", ["t0", "t2"], ["o_func_add"])
+        node_func_identity = onnx.helper.make_node(
+            func_identity_name, ["i1"], ["t1"], domain=func_domain
+        )
+        node_identity = onnx.helper.make_node("Identity", ["i1"], ["t3"])
+        node_add2 = onnx.helper.make_node("Add", ["t3", "t2"], ["o_no_func"])
+        node_func_nested0 = onnx.helper.make_node(
+            func_nested_identity_add_name,
+            ["t0", "t1"],
+            ["o_all_func0"],
+            domain=func_domain,
+        )
+        node_func_nested1 = onnx.helper.make_node(
+            func_nested_identity_add_name,
+            ["t3", "t2"],
+            ["o_all_func1"],
+            domain=func_domain,
+        )
+
+        graph_name = "graph_with_imbedded_functions"
+        ir_version = 8
+        opset_imports = [
+            onnx.helper.make_opsetid("", 14),
+            onnx.helper.make_opsetid("local", 1),
+        ]
+        tensor_type_proto = onnx.helper.make_tensor_type_proto(elem_type=2, shape=[5])
+
+        graph = onnx.helper.make_graph(
+            [
+                node_func_add,
+                node_add0,
+                node_add1,
+                node_func_identity,
+                node_identity,
+                node_func_nested0,
+                node_func_nested1,
+                node_add2,
+            ],
+            graph_name,
+            [
+                onnx.helper.make_value_info(name="i0", type_proto=tensor_type_proto),
+                onnx.helper.make_value_info(name="i1", type_proto=tensor_type_proto),
+                onnx.helper.make_value_info(name="i2", type_proto=tensor_type_proto),
+            ],
+            [
+                onnx.helper.make_value_info(
+                    name="o_no_func", type_proto=tensor_type_proto
+                ),
+                onnx.helper.make_value_info(
+                    name="o_func_add", type_proto=tensor_type_proto
+                ),
+                onnx.helper.make_value_info(
+                    name="o_all_func0", type_proto=tensor_type_proto
+                ),
+                onnx.helper.make_value_info(
+                    name="o_all_func1", type_proto=tensor_type_proto
+                ),
+            ],
+        )
+
+        meta = {
+            "ir_version": ir_version,
+            "opset_imports": opset_imports,
+            "producer_name": "test_extract_model_with_local_function",
+            "functions": [func_identity, func_add, func_nested_identity_add],
+        }
+        model = onnx.helper.make_model(graph, **meta)
+
+        checker.check_model(model)
+        extracted_with_no_function = utils.Extractor(model).extract_model(
+            ["i0", "i1", "i2"], ["o_no_func"]
+        )
+        self._verify_function_set(extracted_with_no_function, {}, func_domain)
+
+        extracted_with_add_function = utils.Extractor(model).extract_model(
+            ["i0", "i1", "i2"], ["o_func_add"]
+        )
+        self._verify_function_set(
+            extracted_with_add_function, {func_add_name}, func_domain
+        )
+
+        extracted_with_o_all_function0 = utils.Extractor(model).extract_model(
+            ["i0", "i1", "i2"], ["o_all_func0"]
+        )
+        self._verify_function_set(
+            extracted_with_o_all_function0,
+            {func_add_name, func_identity_name, func_nested_identity_add_name},
+            func_domain,
+        )
+
+        extracted_with_o_all_function1 = utils.Extractor(model).extract_model(
+            ["i0", "i1", "i2"], ["o_all_func1"]
+        )
+        self._verify_function_set(
+            extracted_with_o_all_function1,
+            {func_add_name, func_identity_name, func_nested_identity_add_name},
+            func_domain,
+        )
+
+        extracted_with_o_all_function2 = utils.Extractor(model).extract_model(
+            ["i0", "i1", "i2"],
+            ["o_no_func", "o_func_add", "o_all_func0", "o_all_func1"],
+        )
+        self._verify_function_set(
+            extracted_with_o_all_function2,
+            {func_add_name, func_identity_name, func_nested_identity_add_name},
+            func_domain,
+        )
diff --git a/onnx/test/helper_test.py b/onnx/test/helper_test.py
new file mode 100644
index 0000000..77ac939
--- /dev/null
+++ b/onnx/test/helper_test.py
@@ -0,0 +1,1172 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import math
+import random
+from typing import Any
+
+import ml_dtypes
+import numpy as np
+import pytest
+
+from onnx import (
+    AttributeProto,
+    GraphProto,
+    ModelProto,
+    OptionalProto,
+    SequenceProto,
+    SparseTensorProto,
+    TensorProto,
+    TypeProto,
+    checker,
+    defs,
+    helper,
+    numpy_helper,
+)
+from onnx.numpy_helper import _pack_2bitx4 as _pack_2bit
+from onnx.numpy_helper import _pack_4bitx2 as _pack_4bit
+
+
+class TestHelperAttributeFunctions:
+    def test_attr_float(self) -> None:
+        # float
+        attr = helper.make_attribute("float", 1.0)
+        assert attr.name == "float"
+        assert attr.f == 1.0
+        checker.check_attribute(attr)
+        # float with scientific
+        attr = helper.make_attribute("float", 1e10)
+        assert attr.name == "float"
+        assert attr.f == 1e10
+        checker.check_attribute(attr)
+
+    def test_attr_int(self) -> None:
+        # integer
+        attr = helper.make_attribute("int", 3)
+        assert attr.name == "int"
+        assert attr.i == 3
+        checker.check_attribute(attr)
+        # long integer
+        attr = helper.make_attribute("int", 5)
+        assert attr.name == "int"
+        assert attr.i == 5
+        checker.check_attribute(attr)
+        # octinteger
+        attr = helper.make_attribute("int", 0o1701)
+        assert attr.name == "int"
+        assert attr.i == 0o1701
+        checker.check_attribute(attr)
+        # hexinteger
+        attr = helper.make_attribute("int", 0x1701)
+        assert attr.name == "int"
+        assert attr.i == 0x1701
+        checker.check_attribute(attr)
+
+    def test_attr_doc_string(self) -> None:
+        attr = helper.make_attribute("a", "value")
+        assert attr.name == "a"
+        assert attr.doc_string == ""
+        attr = helper.make_attribute("a", "value", "doc")
+        assert attr.name == "a"
+        assert attr.doc_string == "doc"
+
+    def test_make_attribute_ref(self) -> None:
+        attr = helper.make_attribute_ref(
+            "alpha", AttributeProto.FLOAT, ref_attr_name="parent_alpha"
+        )
+        assert attr.name == "alpha"
+        assert attr.type == AttributeProto.FLOAT
+        assert attr.ref_attr_name == "parent_alpha"
+        # A reference attribute carries no data; it is resolved from the parent
+        # function's attribute at instantiation time.
+        with pytest.raises(ValueError):
+            helper.get_attribute_value(attr)
+
+    def test_make_attribute_ref_doc_string(self) -> None:
+        attr = helper.make_attribute_ref(
+            "alpha",
+            AttributeProto.FLOAT,
+            doc_string="doc",
+            ref_attr_name="parent_alpha",
+        )
+        assert attr.ref_attr_name == "parent_alpha"
+        assert attr.doc_string == "doc"
+
+    def test_make_attribute_ref_doc_string_positional(self) -> None:
+        attr = helper.make_attribute_ref("alpha", AttributeProto.FLOAT, "doc")
+        assert attr.ref_attr_name == "alpha"
+        assert attr.doc_string == "doc"
+
+    def test_make_attribute_ref_requires_ref_attr_name(self) -> None:
+        with pytest.raises(ValueError):
+            helper.make_attribute_ref("alpha", AttributeProto.FLOAT, ref_attr_name="")
+
+    def test_attr_string(self) -> None:
+        # bytes
+        attr = helper.make_attribute("str", b"test")
+        assert attr.name == "str"
+        assert attr.s == b"test"
+        checker.check_attribute(attr)
+        # unspecified
+        attr = helper.make_attribute("str", "test")
+        assert attr.name == "str"
+        assert attr.s == b"test"
+        checker.check_attribute(attr)
+        # unicode
+        attr = helper.make_attribute("str", "test")
+        assert attr.name == "str"
+        assert attr.s == b"test"
+        checker.check_attribute(attr)
+        # empty str
+        attr = helper.make_attribute("str", "")
+        assert attr.name == "str"
+        assert helper.get_attribute_value(attr) == b""
+        checker.check_attribute(attr)
+
+    def test_attr_repeated_float(self) -> None:
+        attr = helper.make_attribute("floats", [1.0, 2.0])
+        assert attr.name == "floats"
+        assert list(attr.floats) == [1.0, 2.0]
+        checker.check_attribute(attr)
+
+    def test_attr_repeated_int(self) -> None:
+        attr = helper.make_attribute("ints", [1, 2])
+        assert attr.name == "ints"
+        assert list(attr.ints) == [1, 2]
+        checker.check_attribute(attr)
+
+    def test_attr_repeated_mixed_floats_and_ints(self) -> None:
+        attr = helper.make_attribute("mixed", [1, 2, 3.0, 4.5])
+        assert attr.name == "mixed"
+        assert list(attr.floats) == [1.0, 2.0, 3.0, 4.5]
+        checker.check_attribute(attr)
+
+    def test_attr_repeated_str(self) -> None:
+        attr = helper.make_attribute("strings", ["str1", "str2"])
+        assert attr.name == "strings"
+        assert list(attr.strings) == [b"str1", b"str2"]
+        checker.check_attribute(attr)
+
+    def test_attr_repeated_tensor_proto(self) -> None:
+        tensors = [
+            helper.make_tensor(
+                name="a", data_type=TensorProto.FLOAT, dims=(1,), vals=np.ones(1)
+            ),
+            helper.make_tensor(
+                name="b", data_type=TensorProto.FLOAT, dims=(1,), vals=np.ones(1)
+            ),
+        ]
+        attr = helper.make_attribute("tensors", tensors)
+        assert attr.name == "tensors"
+        assert list(attr.tensors) == tensors
+        checker.check_attribute(attr)
+
+    @staticmethod
+    def _make_sparse_tensor() -> SparseTensorProto:
+        values_tensor = helper.make_tensor(
+            name="sparse_values",
+            data_type=TensorProto.FLOAT,
+            dims=[3],
+            vals=np.array(
+                [1.764052391052246, 0.40015721321105957, 0.978738009929657],
+                dtype=np.float32,
+            ),
+            raw=False,
+        )
+        indices_tensor = helper.make_tensor(
+            name="indices",
+            data_type=TensorProto.INT64,
+            dims=[3],
+            vals=np.array([2, 3, 5], dtype=np.int64),
+            raw=False,
+        )
+        return helper.make_sparse_tensor(values_tensor, indices_tensor, [3, 3])
+
+    def test_attr_sparse_tensor_proto(self) -> None:
+        sparse_tensor = self._make_sparse_tensor()
+        attr = helper.make_attribute("sparse_attr", sparse_tensor)
+        assert attr.name == "sparse_attr"
+        checker.check_sparse_tensor(helper.get_attribute_value(attr))
+        checker.check_attribute(attr)
+
+    def test_attr_sparse_tensor_repeated_protos(self) -> None:
+        sparse_tensor = self._make_sparse_tensor()
+        attr = helper.make_attribute("sparse_attrs", [sparse_tensor, sparse_tensor])
+        assert attr.name == "sparse_attrs"
+        checker.check_attribute(attr)
+        for s in helper.get_attribute_value(attr):
+            checker.check_sparse_tensor(s)
+
+    def test_printable_attribute_sparse_tensor(self) -> None:
+        sparse_tensor = self._make_sparse_tensor()
+
+        attr = helper.make_attribute("st", sparse_tensor)
+        assert "<Sparse Tensor>" in helper.printable_attribute(attr)
+
+        attr = helper.make_attribute("sts", [sparse_tensor, sparse_tensor])
+        assert "[<Sparse Tensor>, ...]" in helper.printable_attribute(attr)
+
+    def test_attr_repeated_graph_proto(self) -> None:
+        graphs = [GraphProto(), GraphProto()]
+        graphs[0].name = "a"
+        graphs[1].name = "b"
+        attr = helper.make_attribute("graphs", graphs)
+        assert attr.name == "graphs"
+        assert list(attr.graphs) == graphs
+        checker.check_attribute(attr)
+
+    def test_attr_type_proto(self) -> None:
+        # type_proto
+        type_proto = TypeProto()
+        attr = helper.make_attribute("type_proto", type_proto)
+        assert attr.name == "type_proto"
+        assert attr.tp == type_proto
+        assert attr.type == AttributeProto.TYPE_PROTO
+        # type_protos
+        types = [TypeProto(), TypeProto()]
+        attr = helper.make_attribute("type_protos", types)
+
+        assert attr.name == "type_protos"
+        assert list(attr.type_protos) == types
+        assert attr.type == AttributeProto.TYPE_PROTOS
+
+    def test_attr_empty_list(self) -> None:
+        attr = helper.make_attribute("empty", [], attr_type=AttributeProto.STRINGS)
+        assert attr.type == AttributeProto.STRINGS
+        assert len(attr.strings) == 0
+        with pytest.raises(ValueError):
+            helper.make_attribute("empty", [])
+
+    def test_attr_mismatch(self) -> None:
+        with pytest.raises(TypeError, match="Inferred attribute type 'FLOAT'"):
+            helper.make_attribute("test", 6.4, attr_type=AttributeProto.STRING)
+
+    def test_is_attr_legal(self) -> None:
+        # no name, no field
+        attr = AttributeProto()
+        with pytest.raises(checker.ValidationError):
+            checker.check_attribute(attr)
+        # name, but no field
+        attr = AttributeProto()
+        attr.name = "test"
+        with pytest.raises(checker.ValidationError):
+            checker.check_attribute(attr)
+        # name, with two fields
+        attr = AttributeProto()
+        attr.name = "test"
+        attr.f = 1.0
+        attr.i = 2
+        with pytest.raises(checker.ValidationError):
+            checker.check_attribute(attr)
+
+    def test_is_attr_legal_verbose(self) -> None:
+        def _set(
+            attr: AttributeProto,
+            type_: AttributeProto.AttributeType,
+            var: str,
+            value: Any,
+        ) -> None:
+            setattr(attr, var, value)
+            attr.type = type_
+
+        def _extend(
+            attr: AttributeProto,
+            type_: AttributeProto.AttributeType,
+            var: list[Any],
+            value: Any,
+        ) -> None:
+            var.extend(value)
+            attr.type = type_
+
+        SET_ATTR = [
+            (lambda attr: _set(attr, AttributeProto.FLOAT, "f", 1.0)),
+            (lambda attr: _set(attr, AttributeProto.INT, "i", 1)),
+            (lambda attr: _set(attr, AttributeProto.STRING, "s", b"str")),
+            (
+                lambda attr: _extend(
+                    attr, AttributeProto.FLOATS, attr.floats, [1.0, 2.0]
+                )
+            ),
+            (lambda attr: _extend(attr, AttributeProto.INTS, attr.ints, [1, 2])),
+            (
+                lambda attr: _extend(
+                    attr, AttributeProto.STRINGS, attr.strings, [b"a", b"b"]
+                )
+            ),
+        ]
+        # Randomly set one field, and the result should be legal.
+        for _i in range(100):
+            attr = AttributeProto()
+            attr.name = "test"
+            random.choice(SET_ATTR)(attr)
+            checker.check_attribute(attr)
+        # Randomly set two fields, and then ensure helper function catches it.
+        for _i in range(100):
+            attr = AttributeProto()
+            attr.name = "test"
+            for func in random.sample(SET_ATTR, 2):
+                func(attr)
+            with pytest.raises(checker.ValidationError):
+                checker.check_attribute(attr)
+
+
+class TestHelperNodeFunctions:
+    def test_node_no_arg(self) -> None:
+        assert defs.has("Relu")
+        node_def = helper.make_node("Relu", ["X"], ["Y"], name="test")
+        assert node_def.op_type == "Relu"
+        assert node_def.name == "test"
+        assert list(node_def.input) == ["X"]
+        assert list(node_def.output) == ["Y"]
+
+    def test_attr_doc_string(self) -> None:
+        node_def = helper.make_node("Relu", ["X"], ["Y"], name="test", doc_string="doc")
+        assert node_def.doc_string == "doc"
+
+    def test_node_with_arg(self) -> None:
+        assert defs.has("Relu")
+        # Note: Relu actually does not need an arg, but let's
+        # test it.
+        node_def = helper.make_node("Relu", ["X"], ["Y"], arg_value=1)
+        assert node_def.op_type == "Relu"
+        assert list(node_def.input) == ["X"]
+        assert list(node_def.output) == ["Y"]
+        assert len(node_def.attribute) == 1
+        assert node_def.attribute[0] == helper.make_attribute("arg_value", 1)
+
+    def test_node_domain(self) -> None:
+        node_def = helper.make_node(
+            "Relu", ["X"], ["Y"], name="test", doc_string="doc", domain="test.domain"
+        )
+        assert node_def.domain == "test.domain"
+
+    def test_graph(self) -> None:
+        node_def1 = helper.make_node("Relu", ["X"], ["Y"])
+        node_def2 = helper.make_node("Add", ["X", "Y"], ["Z"])
+        value_info = [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])]
+        graph = helper.make_graph(
+            [node_def1, node_def2],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1, 2])],
+            doc_string=None,
+            value_info=value_info,
+        )
+        assert graph.name == "test"
+        assert len(graph.node) == 2
+        assert graph.node[0] == node_def1
+        assert graph.node[1] == node_def2
+        assert graph.doc_string == ""
+        assert graph.value_info[0] == value_info[0]
+
+    def test_graph_docstring(self) -> None:
+        graph = helper.make_graph([], "my graph", [], [], None, "my docs")
+        assert graph.name == "my graph"
+        assert graph.doc_string == "my docs"
+
+    def test_model(self) -> None:
+        node_def = helper.make_node("Relu", ["X"], ["Y"])
+        graph_def = helper.make_graph(
+            [node_def],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1, 2])],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1, 2])],
+        )
+        with pytest.raises(AttributeError):
+            helper.make_model(graph_def, xxx=1)
+        model_def = helper.make_model(graph_def, producer_name="test")
+        assert model_def.producer_name == "test"
+
+    def test_model_docstring(self) -> None:
+        graph = helper.make_graph([], "my graph", [], [])
+        model_def = helper.make_model(graph, doc_string="test")
+        # models may have their own documentation, but don't have a name
+        # their name is the domain-qualified name of the underlying graph.
+        assert not hasattr(model_def, "name")
+        assert model_def.doc_string == "test"
+
+    def test_model_metadata_props(self) -> None:
+        graph = helper.make_graph([], "my graph", [], [])
+        model_def = helper.make_model(graph, doc_string="test")
+        helper.set_model_props(
+            model_def, {"Title": "my graph", "Keywords": "test;graph"}
+        )
+        checker.check_model(model_def)
+        helper.set_model_props(
+            model_def, {"Title": "my graph", "Keywords": "test;graph"}
+        )
+        checker.check_model(model_def)  # helper replaces, so no dupe
+
+        dupe = model_def.metadata_props.add()
+        dupe.key = "Title"
+        dupe.value = "Other"
+        with pytest.raises(checker.ValidationError):
+            checker.check_model(model_def)
+
+    def test_model_irversion(self) -> None:
+        def mk_model(opset_versions: list[tuple[str, int]]) -> ModelProto:
+            graph = helper.make_graph([], "my graph", [], [])
+            return helper.make_model_gen_version(
+                graph,
+                opset_imports=[helper.make_opsetid(*pair) for pair in opset_versions],
+            )
+
+        def test(opset_versions: list[tuple[str, int]], ir_version: int) -> None:
+            model = mk_model(opset_versions)
+            assert model.ir_version == ir_version
+
+        # opset version 9 requires minimum ir_version 4
+        test([("", 9)], 4)
+        test([("", 10)], 5)
+        test([("", 11)], 6)
+        test([("", 12)], 7)
+        test([("", 13)], 7)
+        test([("", 14)], 7)
+        test([("", 15)], 8)
+        test([("", 16)], 8)
+        test([("", 17)], 8)
+        test([("", 18)], 8)
+        test([("", 19)], 9)
+        test([("", 20)], 9)
+        test([("", 21)], 10)
+        test([("", 22)], 10)
+        test([("", 23)], 11)
+        test([("", 24)], 12)
+        test([("", 25)], 13)
+        test([("", 26)], 13)
+        # standard opset can be referred to using empty-string or "ai.onnx"
+        test([("ai.onnx", 9)], 4)
+        test([("ai.onnx.ml", 2)], 6)
+        test([("ai.onnx.ml", 3)], 8)
+        test([("ai.onnx.ml", 4)], 9)
+        test([("ai.onnx.ml", 5)], 10)
+        test([("ai.onnx.training", 1)], 7)
+        # helper should pick *max* IR version required from all opsets specified.
+        test([("", 10), ("ai.onnx.ml", 2)], 6)
+        with pytest.raises(ValueError):
+            mk_model([("", 100)])
+
+
+class TestHelperTensorFunctions:
+    def test_make_string_tensor(self) -> None:
+        string_list = [s.encode("utf-8") for s in ["Amy", "Billy", "Cindy", "David"]]
+        tensor = helper.make_tensor(
+            name="test",
+            data_type=TensorProto.STRING,
+            dims=(2, 2),
+            vals=string_list,
+            raw=False,
+        )
+        assert string_list == list(tensor.string_data)
+
+    def test_make_bfloat16_tensor(self) -> None:
+        # numpy doesn't support bf16, so we have to compute the correct result manually
+        np_array = np.array(
+            [
+                [1.0, 2.0],
+                [3.0, 4.0],
+                [0.099853515625, 0.099365234375],
+                [0.0998535081744, 0.1],
+                [np.nan, np.inf],
+            ],
+            dtype=np.float32,
+        )
+
+        tensor = helper.make_tensor(
+            name="test",
+            data_type=TensorProto.BFLOAT16,
+            dims=np_array.shape,
+            vals=np_array,
+        )
+        assert tensor.name == "test"
+        np.testing.assert_equal(
+            numpy_helper.to_array(tensor).view(np.uint16),
+            np_array.astype(ml_dtypes.bfloat16).view(np.uint16),
+        )
+
+    def test_make_float8e4m3fn_tensor(self) -> None:
+        y = helper.make_tensor(
+            "zero_point", TensorProto.FLOAT8E4M3FN, [5], [0, 0.5, 1, 50000, 10.1]
+        )
+        ynp = numpy_helper.to_array(y)
+        expected = np.array([0, 0.5, 1, 448, 10], dtype=ml_dtypes.float8_e4m3fn)
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
+
+    def test_make_float8e4m3fnuz_tensor(self) -> None:
+        y = helper.make_tensor(
+            "zero_point",
+            TensorProto.FLOAT8E4M3FNUZ,
+            [7],
+            [0, 0.5, 1, 50000, 10.1, -0.00001, 0.00001],
+        )
+        ynp = numpy_helper.to_array(y)
+        expected = np.array([0, 0.5, 1, 240, 10, 0, 0], dtype=ml_dtypes.float8_e4m3fnuz)
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
+
+    def test_make_float8e5m2_tensor(self) -> None:
+        y = helper.make_tensor(
+            "zero_point", TensorProto.FLOAT8E5M2, [5], [0, 0.5, 1, 50000, 96]
+        )
+        ynp = numpy_helper.to_array(y)
+        expected = np.array([0, 0.5, 1, 49152, 96], dtype=ml_dtypes.float8_e5m2)
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
+
+    def test_make_float8e5m2fnuz_tensor(self) -> None:
+        y = helper.make_tensor(
+            "zero_point",
+            TensorProto.FLOAT8E5M2FNUZ,
+            [7],
+            [0, 0.5, 1, 50000, 96, -0.0000001, 0.0000001],
+        )
+        ynp = numpy_helper.to_array(y)
+        expected = np.array(
+            [0, 0.5, 1, 49152, 96, 0, 0], dtype=ml_dtypes.float8_e5m2fnuz
+        )
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
+
+    def test_make_bfloat16_tensor_raw(self) -> None:
+        array = np.array(
+            [
+                [1.0, 2.0],
+                [3.0, 4.0],
+                [0.099853515625, 0.099365234375],
+                [0.0998535081744, 0.1],
+                [np.nan, np.inf],
+            ],
+            dtype=ml_dtypes.bfloat16,
+        ).view(np.uint16)
+
+        tensor = helper.make_tensor(
+            name="test",
+            data_type=TensorProto.BFLOAT16,
+            dims=array.shape,
+            vals=numpy_helper.tobytes_little_endian(array),
+            raw=True,
+        )
+        np.testing.assert_allclose(numpy_helper.to_array(tensor).view(np.uint16), array)
+
+    def test_make_float8e4m3fn_tensor_raw(self) -> None:
+        expected = np.array([0, 0.5, 1, 448, 10], dtype=ml_dtypes.float8_e4m3fn)
+        packed_values = expected.tobytes()
+        y = helper.make_tensor(
+            name="test",
+            data_type=TensorProto.FLOAT8E4M3FN,
+            dims=list(expected.shape),
+            vals=packed_values,
+            raw=True,
+        )
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
+
+    def test_make_float8e4m3fnuz_tensor_raw(self) -> None:
+        expected = np.array([0, 0.5, 1, 240, 10], dtype=np.float32)
+        f8 = expected.astype(ml_dtypes.float8_e4m3fnuz)
+        packed_values = f8.tobytes()
+        y = helper.make_tensor(
+            name="test",
+            data_type=TensorProto.FLOAT8E4M3FNUZ,
+            dims=list(expected.shape),
+            vals=packed_values,
+            raw=True,
+        )
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(
+            ynp.view(np.uint8),
+            expected.astype(ml_dtypes.float8_e4m3fnuz).view(np.uint8),
+        )
+
+    def test_make_float8e5m2_tensor_raw(self) -> None:
+        expected = np.array([0, 0.5, 1, 49152, 10], dtype=ml_dtypes.float8_e5m2)
+        packed_values = expected.tobytes()
+        y = helper.make_tensor(
+            name="test",
+            data_type=TensorProto.FLOAT8E5M2,
+            dims=list(expected.shape),
+            vals=packed_values,
+            raw=True,
+        )
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
+
+    def test_make_float8e5m2fnuz_tensor_raw(self) -> None:
+        expected = np.array([0, 0.5, 1, 49152, 10], dtype=ml_dtypes.float8_e5m2fnuz)
+        packed_values = expected.tobytes()
+        y = helper.make_tensor(
+            name="test",
+            data_type=TensorProto.FLOAT8E5M2FNUZ,
+            dims=list(expected.shape),
+            vals=packed_values,
+            raw=True,
+        )
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp.view(np.uint8), expected.view(np.uint8))
+
+    def test_make_float8e8m0_tensor(self) -> None:
+        y = helper.make_tensor(
+            "scale",
+            TensorProto.FLOAT8E8M0,
+            [7],
+            [0, 0.124, 1.0, 1.5, 2.0, 2.1, np.finfo(np.float32).max],
+        )
+        ynp = numpy_helper.to_array(y)
+        expected = np.array([0, 124, 127, 128, 128, 129, 254], dtype=np.uint8)
+        np.testing.assert_equal(ynp.view(np.uint8), expected)
+
+    def test_make_float8e8m0_tensor_raw(self) -> None:
+        e8m0_raw = np.array([120, 124, 127, 128, 129, 140], dtype=np.uint8)
+        packed_values = e8m0_raw.tobytes()
+        y = helper.make_tensor(
+            name="test",
+            data_type=TensorProto.FLOAT8E8M0,
+            dims=list(e8m0_raw.shape),
+            vals=packed_values,
+            raw=True,
+        )
+        ynp = numpy_helper.to_array(y)
+        expected = np.array(
+            [0.0078125, 0.125, 1.0, 2.0, 4.0, 8192], dtype=ml_dtypes.float8_e8m0fnu
+        )
+        np.testing.assert_equal(
+            ynp.view(np.uint8),
+            expected.view(np.uint8),
+        )
+
+    @pytest.mark.parametrize("dtype", (TensorProto.UINT4, TensorProto.INT4))
+    @pytest.mark.parametrize("dims", ((5, 4, 6), (4, 6, 5), (3, 3), (1,), (2**10,)))
+    def test_make_4bit_tensor(self, dtype, dims) -> None:
+        type_range = {
+            TensorProto.UINT4: (0, 15),
+            TensorProto.INT4: (-8, 7),
+        }
+        data = np.random.randint(
+            type_range[dtype][0], high=type_range[dtype][1] + 1, size=dims
+        )
+        y = helper.make_tensor("y", dtype, data.shape, data)
+
+        # Check the expected size of int32_data in bytes
+        expected_data_size = math.ceil(np.prod(data.shape) / 2.0)
+        actual_data_size = len(bytes(y.int32_data))
+        np.testing.assert_equal(actual_data_size, expected_data_size)
+
+        # Check the expected data values.
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp, data)
+
+    @pytest.mark.parametrize(
+        "dims",
+        ((5, 4, 6), (4, 6, 5), (3, 3), (1,), (2**10,)),
+    )
+    def test_4bit_tensor_size(self, dims) -> None:
+        # A bug caused negative int4 values to inflate tensor size.
+        # So, test negative values here.
+        num_elems = np.prod(dims)
+        data = np.array([-4] * num_elems, dtype=np.int8).reshape(dims)
+        y = helper.make_tensor("y", TensorProto.INT4, data.shape, data)
+
+        # Check the expected size of int32_data in bytes
+        expected_data_size = math.ceil(num_elems / 2.0)
+        actual_data_size = len(bytes(y.int32_data))
+        np.testing.assert_equal(actual_data_size, expected_data_size)
+
+    @pytest.mark.parametrize("dtype", (TensorProto.UINT4, TensorProto.INT4))
+    @pytest.mark.parametrize("dims", ((5, 4, 6), (4, 6, 5), (3, 3), (1,)))
+    def test_make_4bit_raw_tensor(self, dtype, dims) -> None:
+        data = np.random.randint(0, high=16, size=dims, dtype=np.uint8)
+        packed_data = _pack_4bit(data)
+
+        y = helper.make_tensor(
+            "packed_int4", dtype, dims, packed_data.tobytes(), raw=True
+        )
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp.view(np.uint8), data)
+
+    def test_make_float4e2m1_raw_tensor(self) -> None:
+        data = np.array([0, 0.5, 1, 240, 10, -2], dtype=ml_dtypes.float4_e2m1fn)
+        expected = data.view(np.uint8)
+        packed_data = _pack_4bit(expected)
+        y = helper.make_tensor(
+            "packed_fp4e2m1",
+            TensorProto.FLOAT4E2M1,
+            data.shape,
+            packed_data.tobytes(),
+            raw=True,
+        )
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp.view(np.uint8), expected)
+
+    @pytest.mark.parametrize("dtype", (TensorProto.UINT2, TensorProto.INT2))
+    @pytest.mark.parametrize("dims", ((5, 4, 6), (4, 6, 5), (3, 3), (1,), (2**10,)))
+    def test_make_2bit_tensor(self, dtype, dims) -> None:
+        type_range = {
+            TensorProto.UINT2: (0, 3),
+            TensorProto.INT2: (-2, 1),
+        }
+        data = np.random.randint(
+            type_range[dtype][0], high=type_range[dtype][1] + 1, size=dims
+        )
+        y = helper.make_tensor("y", dtype, data.shape, data)
+
+        # Check the expected size of int32_data in bytes
+        expected_data_size = math.ceil(np.prod(data.shape) / 4.0)
+        actual_data_size = len(bytes(y.int32_data))
+        np.testing.assert_equal(actual_data_size, expected_data_size)
+
+        # Check the expected data values.
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp, data)
+
+    @pytest.mark.parametrize(
+        "dims",
+        ((5, 4, 6), (4, 6, 5), (3, 3), (1,), (2**10,)),
+    )
+    def test_2bit_tensor_size(self, dims) -> None:
+        # A bug caused negative int2 values to inflate tensor size.
+        # So, test negative values here.
+        num_elems = np.prod(dims)
+        data = np.array([-2] * num_elems, dtype=np.int8).reshape(dims)
+        y = helper.make_tensor("y", TensorProto.INT2, data.shape, data)
+
+        # Check the expected size of int32_data in bytes
+        expected_data_size = math.ceil(num_elems / 4.0)
+        actual_data_size = len(bytes(y.int32_data))
+        np.testing.assert_equal(actual_data_size, expected_data_size)
+
+    @pytest.mark.parametrize("dtype", (TensorProto.UINT2, TensorProto.INT2))
+    @pytest.mark.parametrize("dims", ((5, 4, 6), (4, 6, 5), (3, 3), (1,)))
+    def test_make_2bit_raw_tensor(self, dtype, dims) -> None:
+        data = np.random.randint(0, high=4, size=dims, dtype=np.uint8)
+        packed_data = _pack_2bit(data)
+
+        y = helper.make_tensor(
+            "packed_int2", dtype, dims, packed_data.tobytes(), raw=True
+        )
+        ynp = numpy_helper.to_array(y)
+        np.testing.assert_equal(ynp.view(np.uint8), data)
+
+    def test_make_float4e2m1_tensor(self) -> None:
+        y = helper.make_tensor(
+            "zero_point",
+            TensorProto.FLOAT4E2M1,
+            [7],
+            [0, 0.5, 1, 50000, -0.6, -100, -5],
+        )
+        ynp = numpy_helper.to_array(y)
+        expected = np.array(
+            [0, 0.5, 1, 6, -0.5, -6, -4], dtype=ml_dtypes.float4_e2m1fn
+        ).view(np.uint8)
+        np.testing.assert_equal(ynp.view(np.uint8), expected)
+
+    def test_make_sparse_tensor(self) -> None:
+        values = [1.1, 2.2, 3.3, 4.4, 5.5]
+        values_tensor = helper.make_tensor(
+            name="test", data_type=TensorProto.FLOAT, dims=(5,), vals=values
+        )
+        indices = [1, 3, 5, 7, 9]
+        indices_tensor = helper.make_tensor(
+            name="test_indices", data_type=TensorProto.INT64, dims=(5,), vals=indices
+        )
+        dense_shape = [10]
+        sparse = helper.make_sparse_tensor(values_tensor, indices_tensor, dense_shape)
+        assert sparse.values == values_tensor
+        assert sparse.indices == indices_tensor
+        assert sparse.dims == dense_shape
+
+    def test_make_tensor_value_info(self) -> None:
+        vi = helper.make_tensor_value_info("X", TensorProto.FLOAT, (2, 4))
+        checker.check_value_info(vi)
+
+        # scalar value
+        vi = helper.make_tensor_value_info("Y", TensorProto.FLOAT, ())
+        checker.check_value_info(vi)
+
+    def test_make_sparse_tensor_value_info(self) -> None:
+        vi = helper.make_sparse_tensor_value_info("X", TensorProto.FLOAT, (2, 3))
+        checker.check_value_info(vi)
+
+        # scalar value
+        vi = helper.make_sparse_tensor_value_info("Y", TensorProto.FLOAT, ())
+        checker.check_value_info(vi)
+
+    def test_make_tensor_mismatched_dims_raises_error(self) -> None:
+        with pytest.raises(
+            ValueError, match=r"Number of values (.*) does not match tensor dimensions"
+        ):
+            helper.make_tensor(
+                name="mismatch_test",
+                data_type=TensorProto.FLOAT,
+                dims=(2, 2),  # Expects 4 elements
+                vals=[1.0, 2.0, 3.0],  # Only 3 elements provided
+                raw=False,
+            )
+
+    def test_make_tensor_too_many_values_raises_error(self) -> None:
+        with pytest.raises(ValueError):
+            helper.make_tensor(
+                name="too_many_test",
+                data_type=TensorProto.FLOAT,
+                dims=(2,),
+                vals=[1.0, 2.0, 3.0],
+                raw=False,
+            )
+
+    def test_make_tensor_scalar_dims(self) -> None:
+        tensor = helper.make_tensor(
+            name="scalar_test",
+            data_type=TensorProto.FLOAT,
+            dims=(),
+            vals=[42.0],
+            raw=False,
+        )
+        assert tensor.dims == []
+        assert tensor.float_data == [42.0]
+
+    def test_make_tensor_zero_dims(self) -> None:
+        tensor = helper.make_tensor(
+            name="zero_dim_test",
+            data_type=TensorProto.FLOAT,
+            dims=(0,),
+            vals=[],
+            raw=False,
+        )
+        assert tensor.dims == [0]
+        assert len(tensor.float_data) == 0
+
+    def test_make_tensor_mismatched_dims_int4(self) -> None:
+        with pytest.raises(ValueError):
+            helper.make_tensor(
+                name="mismatch_int4",
+                data_type=TensorProto.INT4,
+                dims=(2,),
+                vals=[1],  # Expects 2
+                raw=False,
+            )
+
+    def test_make_tensor_mismatched_dims_complex(self) -> None:
+        with pytest.raises(ValueError):
+            helper.make_tensor(
+                name="mismatch_complex",
+                data_type=TensorProto.COMPLEX64,
+                dims=(2,),
+                vals=[1.0 + 2.0j],  # Expects 2
+                raw=False,
+            )
+
+
+class TestHelperOptionalAndSequenceFunctions:
+    def test_make_optional(self) -> None:
+        values = [1.1, 2.2, 3.3, 4.4, 5.5]
+        values_tensor = helper.make_tensor(
+            name="test", data_type=TensorProto.FLOAT, dims=(5,), vals=values
+        )
+        optional = helper.make_optional(
+            name="test", elem_type=OptionalProto.TENSOR, value=values_tensor
+        )
+        assert optional.name == "test"
+        assert optional.elem_type == OptionalProto.TENSOR
+        assert optional.tensor_value == values_tensor
+
+        # Test Sequence
+        values_sequence = helper.make_sequence(
+            name="test",
+            elem_type=SequenceProto.TENSOR,
+            values=[values_tensor, values_tensor],
+        )
+        optional = helper.make_optional(
+            name="test", elem_type=OptionalProto.SEQUENCE, value=values_sequence
+        )
+        assert optional.name == "test"
+        assert optional.elem_type == OptionalProto.SEQUENCE
+        assert optional.sequence_value == values_sequence
+
+        # Test None
+        optional_none = helper.make_optional(
+            name="test", elem_type=OptionalProto.UNDEFINED, value=None
+        )
+        assert optional_none.name == "test"
+        assert optional_none.elem_type == OptionalProto.UNDEFINED
+        assert not optional_none.HasField("tensor_value")
+
+    def test_make_optional_value_info(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(elem_type=2, shape=[5])
+        tensor_val_into = helper.make_value_info(
+            name="test", type_proto=tensor_type_proto
+        )
+        optional_type_proto = helper.make_optional_type_proto(tensor_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="test", type_proto=optional_type_proto
+        )
+
+        assert optional_val_info.name == "test"
+        assert optional_val_info.type.optional_type
+        assert optional_val_info.type.optional_type.elem_type == tensor_val_into.type
+
+        # Test Sequence
+        sequence_type_proto = helper.make_sequence_type_proto(tensor_type_proto)
+        optional_type_proto = helper.make_optional_type_proto(sequence_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="test", type_proto=optional_type_proto
+        )
+
+        assert optional_val_info.name == "test"
+        assert optional_val_info.type.optional_type
+        sequence_value_info = helper.make_value_info(
+            name="test", type_proto=tensor_type_proto
+        )
+        assert (
+            optional_val_info.type.optional_type.elem_type.sequence_type.elem_type
+            == sequence_value_info.type
+        )
+
+    def test_make_sequence_value_info(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(elem_type=2, shape=None)
+        sequence_type_proto = helper.make_sequence_type_proto(tensor_type_proto)
+        sequence_val_info = helper.make_value_info(
+            name="test", type_proto=sequence_type_proto
+        )
+        sequence_val_info_prim = helper.make_tensor_sequence_value_info(
+            name="test", elem_type=2, shape=None
+        )
+
+        assert sequence_val_info == sequence_val_info_prim
+
+
+class TestPrintableGraph:
+    def test_initializer_with_matching_graph_input(self) -> None:
+        add = helper.make_node("Add", ["X", "Y_Initializer"], ["Z"])
+        value_info = [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1])]
+
+        graph = helper.make_graph(
+            [add],
+            "test",
+            [
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, [1]),
+                helper.make_tensor_value_info("Y_Initializer", TensorProto.FLOAT, [1]),
+            ],  # inputs
+            [helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1])],  # outputs
+            [
+                helper.make_tensor("Y_Initializer", TensorProto.FLOAT, [1], [1])
+            ],  # initializers
+            doc_string=None,
+            value_info=value_info,
+        )
+
+        graph_str = helper.printable_graph(graph)
+        assert (
+            """) optional inputs with matching initializers (
+  %Y_Initializer[FLOAT, 1]"""
+            in graph_str
+        ), graph_str
+
+    def test_initializer_no_matching_graph_input(self) -> None:
+        add = helper.make_node("Add", ["X", "Y_Initializer"], ["Z"])
+        value_info = [helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1])]
+
+        graph = helper.make_graph(
+            [add],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [1])],  # inputs
+            [helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1])],  # outputs
+            [
+                helper.make_tensor("Y_Initializer", TensorProto.FLOAT, [1], [1])
+            ],  # initializers
+            doc_string=None,
+            value_info=value_info,
+        )
+
+        graph_str = helper.printable_graph(graph)
+        assert (
+            """) initializers (
+  %Y_Initializer[FLOAT, 1]"""
+            in graph_str
+        ), graph_str
+
+    def test_unknown_dimensions(self) -> None:
+        graph = helper.make_graph(
+            [helper.make_node("Add", ["X", "Y_Initializer"], ["Z"])],
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, [None])],  # inputs
+            [helper.make_tensor_value_info("Z", TensorProto.FLOAT, [None])],  # outputs
+            [
+                helper.make_tensor("Y_Initializer", TensorProto.FLOAT, [1], [1])
+            ],  # initializers
+            doc_string=None,
+        )
+        model = helper.make_model(graph)
+        checker.check_model(model)
+
+        graph_str = helper.printable_graph(graph)
+        assert "X[FLOAT, ?]" in graph_str
+
+
+@pytest.mark.parametrize(
+    "tensor_dtype",
+    [t for t in helper.get_all_tensor_dtypes() if t != TensorProto.STRING],
+    ids=helper.tensor_dtype_to_string,
+)
+def test_make_tensor_vals(tensor_dtype: int) -> None:
+    np_type = helper.tensor_dtype_to_np_dtype(tensor_dtype)
+    if tensor_dtype in {
+        TensorProto.UINT8,
+        TensorProto.UINT16,
+        TensorProto.UINT32,
+        TensorProto.UINT64,
+    }:
+        # Avoid "RuntimeWarning: invalid value encountered in cast" when using
+        # astype() for negative floats.
+        np_array = numpy_helper.create_random_int((2, 3), np_type)
+    else:
+        np_array = np.random.randn(2, 3)
+    np_array = np_array.astype(np_type)
+    tensor = helper.make_tensor(
+        name="test", data_type=tensor_dtype, dims=np_array.shape, vals=np_array
+    )
+    roundtrip_array = numpy_helper.to_array(tensor)
+    if tensor_dtype in {
+        TensorProto.FLOAT8E5M2FNUZ,
+        TensorProto.FLOAT8E5M2,
+        TensorProto.FLOAT8E4M3FNUZ,
+        TensorProto.FLOAT8E4M3FN,
+        TensorProto.BFLOAT16,
+        TensorProto.FLOAT8E8M0,
+    }:
+        # There is a bug in ml_dtypes that causes equality checks to fail for these dtypes
+        # See https://github.com/jax-ml/ml_dtypes/issues/301
+        assert roundtrip_array.shape == np_array.shape
+        assert roundtrip_array.dtype == np_array.dtype
+        assert roundtrip_array.tobytes() == np_array.tobytes()
+    else:
+        np.testing.assert_equal(np_array, roundtrip_array)
+
+
+@pytest.mark.parametrize(
+    "tensor_dtype",
+    [t for t in helper.get_all_tensor_dtypes() if t != TensorProto.STRING],
+    ids=helper.tensor_dtype_to_string,
+)
+@pytest.mark.parametrize(
+    "vals_as_bytes",
+    [True, False],
+    ids=["vals_as_bytes", "vals_as_nparray"],
+)
+def test_make_tensor_raw(tensor_dtype: int, vals_as_bytes: bool) -> None:
+    np_type = helper.tensor_dtype_to_np_dtype(tensor_dtype)
+    if tensor_dtype in {
+        TensorProto.UINT8,
+        TensorProto.UINT16,
+        TensorProto.UINT32,
+        TensorProto.UINT64,
+    }:
+        # Avoid "RuntimeWarning: invalid value encountered in cast" when using
+        # astype() for negative floats.
+        np_array = numpy_helper.create_random_int((2, 3), np_type)
+    else:
+        np_array = np.random.randn(2, 3)
+    np_array = np_array.astype(np_type)
+
+    if vals_as_bytes:
+        np_array_intermediate = np_array
+
+        if tensor_dtype in {
+            TensorProto.FLOAT4E2M1,
+            TensorProto.INT4,
+            TensorProto.UINT4,
+        }:
+            np_array_intermediate = _pack_4bit(np_array)
+        if tensor_dtype in {
+            TensorProto.INT2,
+            TensorProto.UINT2,
+        }:
+            np_array_intermediate = _pack_2bit(np_array)
+
+        vals = numpy_helper.tobytes_little_endian(np_array_intermediate)
+    else:
+        vals = np_array
+
+    tensor = helper.make_tensor(
+        name="test",
+        data_type=tensor_dtype,
+        dims=np_array.shape,
+        vals=vals,
+        raw=True,
+    )
+    roundtrip_array = numpy_helper.to_array(tensor)
+    if tensor_dtype in {
+        TensorProto.FLOAT8E5M2FNUZ,
+        TensorProto.FLOAT8E5M2,
+        TensorProto.FLOAT8E4M3FNUZ,
+        TensorProto.FLOAT8E4M3FN,
+        TensorProto.BFLOAT16,
+        TensorProto.FLOAT8E8M0,
+    }:
+        # There is a bug in ml_dtypes that causes equality checks to fail for these dtypes
+        # See https://github.com/jax-ml/ml_dtypes/issues/301
+        assert roundtrip_array.shape == np_array.shape
+        assert roundtrip_array.dtype == np_array.dtype
+        assert roundtrip_array.tobytes() == np_array.tobytes()
+    else:
+        np.testing.assert_equal(np_array, roundtrip_array)
+
+
+class TestHelperMappingFunctions:
+    # TODO (#4554): remove these tests about catching warnings after the deprecation period
+    # Test these new functions should not raise any deprecation warnings
+    @pytest.mark.filterwarnings("error::DeprecationWarning")
+    def test_tensor_dtype_to_np_dtype_not_throw_warning(self) -> None:
+        _ = helper.tensor_dtype_to_np_dtype(TensorProto.FLOAT)
+
+    @pytest.mark.filterwarnings("error::DeprecationWarning")
+    def test_tensor_dtype_to_storage_tensor_dtype_not_throw_warning(self) -> None:
+        _ = helper.tensor_dtype_to_storage_tensor_dtype(TensorProto.FLOAT)
+
+    @pytest.mark.filterwarnings("error::DeprecationWarning")
+    def test_tensor_dtype_to_field_not_throw_warning(self) -> None:
+        _ = helper.tensor_dtype_to_field(TensorProto.FLOAT)
+
+    @pytest.mark.filterwarnings("error::DeprecationWarning")
+    def test_np_dtype_to_tensor_dtype_not_throw_warning(self) -> None:
+        _ = helper.np_dtype_to_tensor_dtype(np.dtype("float32"))
+
+    def test_tensor_dtype_to_np_dtype_bfloat16(self) -> None:
+        assert (
+            helper.tensor_dtype_to_np_dtype(TensorProto.BFLOAT16) == ml_dtypes.bfloat16
+        )
+
+    def test_tensor_dtype_to_storage_tensor_dtype_bfloat16(self) -> None:
+        assert (
+            helper.tensor_dtype_to_storage_tensor_dtype(TensorProto.BFLOAT16)
+            == TensorProto.INT32
+        )
+
+    def test_tensor_dtype_to_field_bfloat16(self) -> None:
+        assert helper.tensor_dtype_to_field(TensorProto.BFLOAT16) == "int32_data"
+
+
+class TestAttrTypeToStr:
+    @pytest.mark.parametrize(
+        "attr_type, expected_str",
+        [
+            (AttributeProto.AttributeType.FLOAT, "FLOAT"),
+            (AttributeProto.AttributeType.INT, "INT"),
+            (AttributeProto.AttributeType.STRING, "STRING"),
+            (AttributeProto.AttributeType.TENSOR, "TENSOR"),
+            (AttributeProto.AttributeType.GRAPH, "GRAPH"),
+            (AttributeProto.AttributeType.SPARSE_TENSOR, "SPARSE_TENSOR"),
+            (AttributeProto.AttributeType.TYPE_PROTO, "TYPE_PROTO"),
+            (AttributeProto.AttributeType.FLOATS, "FLOATS"),
+            (AttributeProto.AttributeType.INTS, "INTS"),
+            (AttributeProto.AttributeType.STRINGS, "STRINGS"),
+            (AttributeProto.AttributeType.TENSORS, "TENSORS"),
+            (AttributeProto.AttributeType.GRAPHS, "GRAPHS"),
+            (AttributeProto.AttributeType.SPARSE_TENSORS, "SPARSE_TENSORS"),
+            (AttributeProto.AttributeType.TYPE_PROTOS, "TYPE_PROTOS"),
+        ],
+    )
+    def test_attr_type_to_str(self, attr_type, expected_str):
+        result = helper._attr_type_to_str(attr_type)
+        assert result == expected_str
+
+    def test_attr_type_to_str_undefined(self):
+        result = helper._attr_type_to_str(9999)
+        assert result == "UNDEFINED"
diff --git a/onnx/test/inference_function_test.py b/onnx/test/inference_function_test.py
new file mode 100644
index 0000000..ae26360
--- /dev/null
+++ b/onnx/test/inference_function_test.py
@@ -0,0 +1,298 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Copyright (c) ONNX Project Contributors
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import onnx
+from onnx import TensorProto, TypeProto
+from onnx.checker import ValidationError
+from onnx.defs import OpSchema, get_all_schemas_with_history, get_schema
+from onnx.helper import (
+    make_graph,
+    make_node,
+    make_opsetid,
+    make_tensor_type_proto,
+    make_tensor_value_info,
+)
+from onnx.numpy_helper import from_array
+from onnx.shape_inference import InferenceError, infer_node_outputs
+
+ADD_SCHEMA = max(
+    (s for s in get_all_schemas_with_history() if s.name == "Add" and s.domain == ""),
+    key=lambda s: s.since_version,
+)
+RESHAPE_SCHEMA = max(
+    (
+        s
+        for s in get_all_schemas_with_history()
+        if s.name == "Reshape" and s.domain == ""
+    ),
+    key=lambda s: s.since_version,
+)
+CLIP_SCHEMA = max(
+    (s for s in get_all_schemas_with_history() if s.name == "Clip" and s.domain == ""),
+    key=lambda s: s.since_version,
+)
+
+
+def _to_tensor_types(
+    tensor_types: dict[str, tuple[int, tuple[int | str | None, ...]]],
+) -> dict[str, TypeProto]:
+    return {key: make_tensor_type_proto(*value) for key, value in tensor_types.items()}
+
+
+def _run_case(
+    schema: OpSchema,
+    input_names: list[str],
+    output_names: list[str],
+    input_types: dict[str, TypeProto],
+    input_data: dict[str, np.ndarray] | None = None,
+) -> dict[str, TypeProto]:
+    if input_data is None:
+        input_data = {}
+    return infer_node_outputs(
+        schema,
+        make_node(schema.name, input_names, output_names, domain=schema.domain),
+        input_types,
+        {key: from_array(arr) for key, arr in input_data.items()},
+    )
+
+
+class TestInferenceFunctionCall:
+    def test_add_inference(self) -> None:
+        cases = [
+            (
+                {"A": (TensorProto.FLOAT, ()), "B": (TensorProto.FLOAT, ())},
+                {"C": (TensorProto.FLOAT, ())},
+            ),
+            (
+                {
+                    "A": (TensorProto.FLOAT, (None, 2)),
+                    "B": (TensorProto.FLOAT, (2,)),
+                },
+                {"C": (TensorProto.FLOAT, (None, 2))},
+            ),
+            (
+                {
+                    "A": (TensorProto.FLOAT, (None, 2)),
+                    "B": (TensorProto.FLOAT, (1, 2)),
+                },
+                {"C": (TensorProto.FLOAT, (None, 2))},
+            ),
+            (
+                {
+                    "A": (TensorProto.DOUBLE, ("n", "m")),
+                    "B": (TensorProto.DOUBLE, (1, "n", "m")),
+                },
+                {"C": (TensorProto.DOUBLE, (1, "n", "m"))},
+            ),
+            (
+                {
+                    "A": (TensorProto.FLOAT, ("x", 2)),
+                    "B": (TensorProto.FLOAT, ("y", 2)),
+                },
+                {"C": (TensorProto.FLOAT, (None, 2))},
+            ),
+        ]
+        for ins, outs in cases:
+            assert _run_case(
+                ADD_SCHEMA,
+                ["A", "B"],
+                ["C"],
+                _to_tensor_types(ins),
+            ) == _to_tensor_types(outs)
+
+    def test_clip_inference_with_optional_input(self) -> None:
+        # Test case where the second input is optional
+        input_names = ["X", "", "max"]
+        output_names = ["Y"]
+        input_types = _to_tensor_types(
+            {"X": (TensorProto.FLOAT, (3, 4)), "max": (TensorProto.FLOAT, ())}
+        )
+        expected_output_types = _to_tensor_types({"Y": (TensorProto.FLOAT, (3, 4))})
+        assert (
+            _run_case(CLIP_SCHEMA, input_names, output_names, input_types)
+            == expected_output_types
+        )
+
+    def test_add_inference_raises_errors(self) -> None:
+        with pytest.raises(ValidationError):
+            _run_case(
+                ADD_SCHEMA,
+                ["A"],
+                ["C"],
+                _to_tensor_types({"A": (TensorProto.FLOAT, (3, 4))}),
+            )
+        with pytest.raises(ValidationError):
+            _run_case(
+                ADD_SCHEMA,
+                ["A", "B"],
+                ["C"],
+                _to_tensor_types({"A": (TensorProto.FLOAT, (3, 4)), "B": (2, (3, 4))}),
+            )
+        with pytest.raises(InferenceError):
+            _run_case(
+                ADD_SCHEMA,
+                ["A", "B"],
+                ["C"],
+                _to_tensor_types(
+                    {
+                        "A": (TensorProto.FLOAT, (2, 4)),
+                        "B": (TensorProto.FLOAT, (3, 4)),
+                    }
+                ),
+            )
+        with pytest.raises(KeyError):
+            _run_case(
+                ADD_SCHEMA,
+                ["A", "B"],
+                ["C"],
+                _to_tensor_types({"A": (TensorProto.FLOAT, (3, 4))}),
+            )
+
+    def test_reshape_inference(self) -> None:
+        assert _run_case(
+            RESHAPE_SCHEMA,
+            ["x", "t"],
+            ["y"],
+            _to_tensor_types(
+                {
+                    "x": (TensorProto.FLOAT, (5, 4)),
+                    "t": (TensorProto.INT64, (3,)),
+                }
+            ),
+            {"t": np.array([2, 2, 5], dtype=np.int64)},
+        ) == _to_tensor_types({"y": (TensorProto.FLOAT, (2, 2, 5))})
+
+    def test_scan_inference_with_subgraph(self) -> None:
+        seq_len = "sequence"
+        input_size = 2
+        loop_state_size = 3
+
+        input_value_infos = [
+            make_tensor_value_info("loop_state_in", TensorProto.UNDEFINED, None),
+            make_tensor_value_info("input", TensorProto.UNDEFINED, None),
+            make_tensor_value_info("outer", TensorProto.UNDEFINED, None),
+        ]
+        output_value_infos = [
+            make_tensor_value_info("loop_state_out", TensorProto.UNDEFINED, None),
+            make_tensor_value_info("output", TensorProto.FLOAT, (seq_len, input_size)),
+        ]
+
+        subgraph = make_graph(
+            [
+                make_node("Identity", ["loop_state_in"], ["loop_state_out"]),
+                make_node("Add", ["input", "outer"], ["output"]),
+            ],
+            "subgraph",
+            input_value_infos,
+            output_value_infos,
+        )
+
+        assert infer_node_outputs(
+            get_schema("Scan", 9),
+            make_node(
+                "Scan",
+                ["loop_state_orig", "scan_input", "scan_outer"],
+                ["loop_state_final", "scan_output"],
+                num_scan_inputs=1,
+                body=subgraph,
+            ),
+            _to_tensor_types(
+                {
+                    "loop_state_orig": (TensorProto.FLOAT, (loop_state_size,)),
+                    "scan_input": (TensorProto.FLOAT, (seq_len, input_size)),
+                    "scan_outer": (TensorProto.FLOAT, (input_size,)),
+                }
+            ),
+            # Same as default value in Scan-9
+            opset_imports=[make_opsetid("", 9)],
+            ir_version=4,
+        ) == _to_tensor_types(
+            {
+                "loop_state_final": (TensorProto.FLOAT, (loop_state_size,)),
+                "scan_output": (TensorProto.FLOAT, (seq_len, input_size)),
+            }
+        )
+
+    def test_inference_with_conflow(self) -> None:
+        model_script = """
+        <
+            ir_version: 8,
+            opset_import: ["" : 18, "onnxscript.atenlib" : 1],
+            producer_name: "pytorch",
+            producer_version: "2.1.0"
+        >
+        torch_jit (float input_0) => (float reault, int64 index)
+        {
+            reault, index = onnxscript.atenlib.aten_min_dim <dim = 0, keepdim = 1> (input_0)
+        }
+        <
+            domain: "onnxscript.atenlib",
+            opset_import: ["" : 18]
+        >
+        aten_min_dim <dim>(self) => (result_7, indices_6)
+        {
+            tmp = Shape (self)
+            tmp_0 = Size (tmp)
+            tmp_1 = Constant <value = int64 tmp_1 {0}> ()
+            tmp_1_cast = CastLike (tmp_1, tmp_0)
+            tmp_2 = Equal (tmp_0, tmp_1_cast)
+            cond = Not (tmp_2)
+            indices_6, result_7 = If (cond) <
+                then_branch = thenGraph_4 () => ( indices,  result) {
+                    dim = Constant <value_int: int = @dim> ()
+                    tmp_3 = Constant <value_ints = [-1]> ()
+                    dims = Reshape (dim, tmp_3)
+                    result = ReduceMin <keepdims: int = @keepdim> (self, dims)
+                    indices = ArgMin <axis: int = @dim, keepdims: int = @keepdim> (self)
+                }, else_branch = elseGraph_4 () => ( indices_4,  result_5) {
+                    indices_4 = Constant <value_int = 0> ()
+                    result_5 = Identity (self)
+                }
+            >
+        }
+        """
+        model = onnx.parser.parse_model(model_script)
+        onnx.shape_inference.infer_shapes(model, strict_mode=False)
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(model, strict_mode=True)
+
+    def test_inference_with_attribute(self) -> None:
+        model_script = """
+        <
+            ir_version: 8,
+            opset_import: ["" : 18, "custom" : 1],
+            producer_name: "",
+            producer_version: "1.0"
+        >
+        MeanVarianceNormalization (float[N] x) => (float[M] y)
+        {
+            y = custom.custom_mvn <axes = [0]> (x)
+        }
+        <
+            domain: "custom",
+            opset_import: ["" : 18]
+        >
+        custom_mvn <axes>(X) => (Y)
+        {
+          Exponent = Constant <value = float {2.0}>()
+          Epsilon = Constant <value = float {1e-9}>()
+          axes = Constant <value_ints: ints = @axes>()
+          X_RM = ReduceMean (X, axes)
+          EX_squared = Pow (X_RM, Exponent)
+          X_squared = Pow (X, Exponent)
+          E_Xsquared = ReduceMean (X_squared, axes)
+          Variance = Sub (E_Xsquared, EX_squared)
+          STD = Sqrt (Variance)
+          X_variance = Sub (X, X_RM)
+          Processed_STD = Add (STD, Epsilon)
+          Y = Div (X_variance, Processed_STD)
+        }
+        """
+        model = onnx.parser.parse_model(model_script)
+        # onnx.shape_inference.infer_shapes(model, strict_mode=False)
+        onnx.shape_inference.infer_shapes(model, strict_mode=True)
diff --git a/onnx/test/inliner_test.py b/onnx/test/inliner_test.py
new file mode 100644
index 0000000..aecc3e4
--- /dev/null
+++ b/onnx/test/inliner_test.py
@@ -0,0 +1,140 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import pytest
+
+from onnx import checker, inliner, parser
+
+
+class TestInliner:
+    def test_basic(self):
+        model = parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y)
+            {
+                Y = local.foo (X)
+            }
+
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) {
+                temp = Add(x, x)
+                y = local.bar(temp)
+            }
+
+            <opset_import: [ "" : 17 ], domain: "local">
+            bar (x) => (y) {
+                y = Mul (x, x)
+            }
+        """
+        )
+        inlined = inliner.inline_local_functions(model)
+        inlined_nodes = inlined.graph.node
+        # function-call should be replaced by Add, followed by Mul
+        assert len(inlined_nodes) == 2
+        assert inlined_nodes[0].op_type == "Add"
+        assert inlined_nodes[1].op_type == "Mul"
+
+    def test_selective_inlining(self):
+        model = parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y)
+            {
+                T = local.square (X)
+                Y = local.double_and_square (T)
+            }
+
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            double_and_square (x) => (y) {
+                double = Add(x, x)
+                y = local.square(double)
+            }
+
+            <opset_import: [ "" : 17 ], domain: "local">
+            square (x) => (y) {
+                y = Mul (x, x)
+            }
+        """
+        )
+        inlined = inliner.inline_selected_functions(
+            model, [("local", "square")], exclude=False
+        )
+        inlined_nodes = inlined.graph.node
+        # function-call to square should be replaced by Add, but not the one to double_and_square
+        assert len(inlined_nodes) == 2
+        assert inlined_nodes[0].op_type == "Mul"
+        assert inlined_nodes[1].op_type == "double_and_square"
+
+        # check call to square inside double_and_square was inlined:
+        function_nodes = inlined.functions[0].node
+        assert len(function_nodes) == 2
+        assert function_nodes[0].op_type == "Add"
+        assert function_nodes[1].op_type == "Mul"
+
+    def test_selective_exclusion(self):
+        model = parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y)
+            {
+                T = local.square (X)
+                Y = local.double_and_square (T)
+            }
+
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            double_and_square (x) => (y) {
+                double = Add(x, x)
+                y = local.square(double)
+            }
+
+            <opset_import: [ "" : 17 ], domain: "local">
+            square (x) => (y) {
+                y = Mul (x, x)
+            }
+        """
+        )
+        inlined = inliner.inline_selected_functions(
+            model, [("local", "double_and_square")], exclude=True
+        )
+        inlined_nodes = inlined.graph.node
+        # function-call to square should be replaced by Add, but not the one to double_and_square
+        assert len(inlined_nodes) == 2
+        assert inlined_nodes[0].op_type == "Mul"
+        assert inlined_nodes[1].op_type == "double_and_square"
+
+        # check call to square inside double_and_square was inlined:
+        function_nodes = inlined.functions[0].node
+        assert len(function_nodes) == 2
+        assert function_nodes[0].op_type == "Add"
+        assert function_nodes[1].op_type == "Mul"
+
+    def test_inline_rejects_cyclic_function(self):
+        model = parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) { Y = local.foo (X) }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) { y = local.foo (x) }
+        """
+        )
+        with pytest.raises(checker.ValidationError):
+            inliner.inline_local_functions(model)
+
+    def test_schema_function_inlining(self):
+        model = parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 20]>
+            agraph (float[N] X) => (float[N] Y)
+            {
+                Y = Softsign (X)
+            }
+        """
+        )
+        inlined = inliner.inline_selected_functions(
+            model, [], exclude=True, inline_schema_functions=True
+        )
+        inlined_nodes = inlined.graph.node
+        assert "Abs" in [n.op_type for n in inlined_nodes]
diff --git a/onnx/test/model_container_refeval_test.py b/onnx/test/model_container_refeval_test.py
new file mode 100644
index 0000000..577b981
--- /dev/null
+++ b/onnx/test/model_container_refeval_test.py
@@ -0,0 +1,136 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+import tempfile
+
+import numpy as np
+import numpy.testing as npt
+import pytest
+
+import onnx
+import onnx.helper
+import onnx.model_container
+import onnx.numpy_helper
+import onnx.reference
+
+
+def _linear_regression():
+    X = onnx.helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+    Y = onnx.helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+    graph = onnx.helper.make_graph(
+        [
+            onnx.helper.make_node("MatMul", ["X", "A"], ["XA"]),
+            onnx.helper.make_node("MatMul", ["XA", "B"], ["XB"]),
+            onnx.helper.make_node("MatMul", ["XB", "C"], ["Y"]),
+        ],
+        "mm",
+        [X],
+        [Y],
+        [
+            onnx.numpy_helper.from_array(
+                np.arange(9).astype(np.float32).reshape((-1, 3)), name="A"
+            ),
+            onnx.numpy_helper.from_array(
+                (np.arange(9) * 100).astype(np.float32).reshape((-1, 3)),
+                name="B",
+            ),
+            onnx.numpy_helper.from_array(
+                (np.arange(9) + 10).astype(np.float32).reshape((-1, 3)),
+                name="C",
+            ),
+        ],
+    )
+    onnx_model = onnx.helper.make_model(graph)
+    onnx.checker.check_model(onnx_model)
+    return onnx_model
+
+
+def _large_linear_regression():
+    X = onnx.helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+    Y = onnx.helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+    graph = onnx.helper.make_graph(
+        [
+            onnx.helper.make_node("MatMul", ["X", "A"], ["XA"]),
+            onnx.helper.make_node("MatMul", ["XA", "B"], ["XB"]),
+            onnx.helper.make_node("MatMul", ["XB", "C"], ["Y"]),
+        ],
+        "mm",
+        [X],
+        [Y],
+        [
+            onnx.model_container.make_large_tensor_proto(
+                "#loc0", "A", onnx.TensorProto.FLOAT, (3, 3)
+            ),
+            onnx.numpy_helper.from_array(
+                np.arange(9).astype(np.float32).reshape((-1, 3)), name="B"
+            ),
+            onnx.model_container.make_large_tensor_proto(
+                "#loc1", "C", onnx.TensorProto.FLOAT, (3, 3)
+            ),
+        ],
+    )
+    onnx_model = onnx.helper.make_model(graph)
+    large_model = onnx.model_container.make_large_model(
+        onnx_model.graph,
+        {
+            "#loc0": (np.arange(9) * 100).astype(np.float32).reshape((-1, 3)),
+            "#loc1": (np.arange(9) + 10).astype(np.float32).reshape((-1, 3)),
+        },
+    )
+    large_model.check_model()
+    return large_model
+
+
+class TestLargeOnnxReferenceEvaluator:
+    def common_check_reference_evaluator(self, container):
+        X = np.arange(9).astype(np.float32).reshape((-1, 3))
+        ref = onnx.reference.ReferenceEvaluator(container)
+        got = ref.run(None, {"X": X})
+        expected = np.array(
+            [
+                [945000, 1015200, 1085400],
+                [2905200, 3121200, 3337200],
+                [4865400, 5227200, 5589000],
+            ],
+            dtype=np.float32,
+        )
+        npt.assert_allclose(got[0], expected)
+
+    def test_large_onnx_no_large_initializer(self):
+        model_proto = _linear_regression()
+        large_model = onnx.model_container.make_large_model(model_proto.graph)
+        self.common_check_reference_evaluator(large_model)
+        with pytest.raises(ValueError):
+            large_model["#anymissingkey"]
+
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            large_model.save(filename)
+            copy = onnx.model_container.ModelContainer()
+            copy.load(filename)
+            self.common_check_reference_evaluator(copy)
+
+    def test_large_one_weight_file(self):
+        large_model = _large_linear_regression()
+        self.common_check_reference_evaluator(large_model)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            large_model.save(filename, True)
+            copy = onnx.model_container.ModelContainer()
+            copy.load(filename)
+            loaded_model = onnx.load_model(filename, load_external_data=True)
+            self.common_check_reference_evaluator(loaded_model)
+
+    def test_large_multi_files(self):
+        large_model = _large_linear_regression()
+        self.common_check_reference_evaluator(large_model)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            large_model.save(filename, False)
+            copy = onnx.load_model(filename)
+            self.common_check_reference_evaluator(copy)
+            loaded_model = onnx.load_model(filename, load_external_data=True)
+            self.common_check_reference_evaluator(loaded_model)
diff --git a/onnx/test/model_container_test.py b/onnx/test/model_container_test.py
new file mode 100644
index 0000000..5107873
--- /dev/null
+++ b/onnx/test/model_container_test.py
@@ -0,0 +1,133 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+import tempfile
+
+import numpy as np
+import pytest
+
+import onnx
+import onnx.external_data_helper as ext_data
+import onnx.helper
+import onnx.model_container
+import onnx.numpy_helper
+
+
+def _linear_regression():
+    X = onnx.helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+    Y = onnx.helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+    graph = onnx.helper.make_graph(
+        [
+            onnx.helper.make_node("MatMul", ["X", "A"], ["XA"]),
+            onnx.helper.make_node("MatMul", ["XA", "B"], ["XB"]),
+            onnx.helper.make_node("MatMul", ["XB", "C"], ["Y"]),
+        ],
+        "mm",
+        [X],
+        [Y],
+        [
+            onnx.numpy_helper.from_array(
+                np.arange(9).astype(np.float32).reshape((-1, 3)), name="A"
+            ),
+            onnx.numpy_helper.from_array(
+                (np.arange(9) * 10).astype(np.float32).reshape((-1, 3)),
+                name="B",
+            ),
+            onnx.numpy_helper.from_array(
+                (np.arange(9) * 10).astype(np.float32).reshape((-1, 3)),
+                name="C",
+            ),
+        ],
+    )
+    onnx_model = onnx.helper.make_model(graph)
+    onnx.checker.check_model(onnx_model)
+    return onnx_model
+
+
+def _large_linear_regression():
+    X = onnx.helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+    Y = onnx.helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+    graph = onnx.helper.make_graph(
+        [
+            onnx.helper.make_node("MatMul", ["X", "A"], ["XA"]),
+            onnx.helper.make_node("MatMul", ["XA", "B"], ["XB"]),
+            onnx.helper.make_node("MatMul", ["XB", "C"], ["Y"]),
+        ],
+        "mm",
+        [X],
+        [Y],
+        [
+            onnx.model_container.make_large_tensor_proto(
+                "#loc0", "A", onnx.TensorProto.FLOAT, (3, 3)
+            ),
+            onnx.numpy_helper.from_array(
+                np.arange(9).astype(np.float32).reshape((-1, 3)), name="B"
+            ),
+            onnx.model_container.make_large_tensor_proto(
+                "#loc1", "C", onnx.TensorProto.FLOAT, (3, 3)
+            ),
+        ],
+    )
+    onnx_model = onnx.helper.make_model(graph)
+    large_model = onnx.model_container.make_large_model(
+        onnx_model.graph,
+        {
+            "#loc0": (np.arange(9) * 100).astype(np.float32).reshape((-1, 3)),
+            "#loc1": (np.arange(9) + 10).astype(np.float32).reshape((-1, 3)),
+        },
+    )
+    large_model.check_model()
+    return large_model
+
+
+class TestLargeOnnx:
+    def test_large_onnx_no_large_initializer(self):
+        model_proto = _linear_regression()
+        assert isinstance(model_proto, onnx.ModelProto)
+        large_model = onnx.model_container.make_large_model(model_proto.graph)
+        assert isinstance(large_model, onnx.model_container.ModelContainer)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            large_model.save(filename)
+            copy = onnx.model_container.ModelContainer()
+            with pytest.raises(RuntimeError):
+                assert copy.model_proto
+            copy.load(filename)
+            assert copy.model_proto is not None
+            onnx.checker.check_model(copy.model_proto)
+
+    def test_large_one_weight_file(self):
+        large_model = _large_linear_regression()
+        assert isinstance(large_model, onnx.model_container.ModelContainer)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            saved_proto = large_model.save(filename, True)
+            assert isinstance(saved_proto, onnx.ModelProto)
+            copy = onnx.model_container.ModelContainer()
+            copy.load(filename)
+            copy.check_model()
+            loaded_model = onnx.load_model(filename, load_external_data=True)
+            onnx.checker.check_model(loaded_model)
+
+    def test_large_multi_files(self):
+        large_model = _large_linear_regression()
+        assert isinstance(large_model, onnx.model_container.ModelContainer)
+        with tempfile.TemporaryDirectory() as temp:
+            filename = os.path.join(temp, "model.onnx")
+            saved_proto = large_model.save(filename, False)
+            assert isinstance(saved_proto, onnx.ModelProto)
+            copy = onnx.load_model(filename)
+            onnx.checker.check_model(copy)
+            for tensor in ext_data._get_all_tensors(copy):
+                if ext_data.uses_external_data(tensor):
+                    tested = 0
+                    for ext in tensor.external_data:
+                        if ext.key == "location":
+                            assert os.path.exists(ext.value)
+                            tested += 1
+                    assert tested == 1
+            loaded_model = onnx.load_model(filename, load_external_data=True)
+            onnx.checker.check_model(loaded_model)
diff --git a/onnx/test/model_inference_test.py b/onnx/test/model_inference_test.py
new file mode 100644
index 0000000..2b33745
--- /dev/null
+++ b/onnx/test/model_inference_test.py
@@ -0,0 +1,272 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import typing
+
+import pytest
+
+import onnx
+import onnx.parser
+import onnx.shape_inference
+
+
+class TestModelInference:
+    def _check(self, model_text: str, *expected: int):
+        """Check that the model inference infers the expected types for outputs.
+        Restricted to the simple case of tensor types, so expected types specify
+        only the element type (ints corresponding to onnx.TensorProto.DataType).
+        """
+        model = onnx.parser.parse_model(model_text)
+        inferred = onnx.shape_inference.infer_shapes(model)
+        outputs = inferred.graph.output
+        for output, expected_elem_type in zip(outputs, expected, strict=False):
+            inferred_type = output.type
+            assert inferred_type.HasField("tensor_type")
+            tensor_type = inferred_type.tensor_type
+            assert tensor_type.HasField("elem_type")
+            elem_type = tensor_type.elem_type
+            assert elem_type == expected_elem_type
+
+    def _check_inference_error(self, model_text: str):
+        """Check that the model inference raises an InferenceError."""
+        model = onnx.parser.parse_model(model_text)
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(model, True, True)
+
+    def test_unknown_op(self):
+        """Test that model inference handles unknown ops.
+        This special treatment is to support custom ops.
+        See comments in shape inference code for details.
+        """
+        model = """
+            <ir_version: 7, opset_import: [ "" : 17]>
+            agraph (float[N] x) => (y)
+            {
+                y = SomeUnknownOp (x)
+            }
+        """
+        # No output types are inferred for unknown ops.
+        # But ensure that the inference does not fail.
+        self._check(model)
+
+    def test_mi_basic(self):
+        """Test that model inference infers model output type."""
+        model = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17]
+            >
+            agraph (float[N] x) => (y)
+            {
+                y = Cast<to=6> (x)
+            }
+        """
+        self._check(model, onnx.TensorProto.INT32)
+
+    def test_mi_function(self):
+        """Test use of functions."""
+        model = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17, "local" : 1]
+            >
+            agraph (float[N] x) => (y)
+            {
+                y = local.cast(x)
+            }
+            <
+                opset_import: [ "" : 17 ],
+                domain: "local"
+            >
+            cast (x) => (y)
+            {
+                y = Cast<to=6> (x)
+            }
+        """
+        self._check(model, onnx.TensorProto.INT32)
+
+    def test_mi_function_attr(self):
+        """Test use of functions with attribute parameters."""
+        model = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17, "local" : 1]
+            >
+            agraph (float[N] x) => (y)
+            {
+                y = local.cast<target=6>(x)
+            }
+            <
+                opset_import: [ "" : 17 ],
+                domain: "local"
+            >
+            cast<target>(x) => (y)
+            {
+                y = Cast<to:int = @target> (x)
+            }
+        """
+        self._check(model, onnx.TensorProto.INT32)
+
+    def test_mi_function_subgraph_attr(self):
+        """Test use of function attributes within subgraphs."""
+        model = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17, "local" : 1]
+            >
+            agraph (float[N] x, bool flag) => (y)
+            {
+                y = local.cast<target=6>(x, flag)
+            }
+            <
+                opset_import: [ "" : 17 ],
+                domain: "local"
+            >
+            cast<target>(x, flag) => (y)
+            {
+                y = If (flag) <
+                    then_branch = g1 () => (z_then) { z_then = Cast<to:int = @target> (x) },
+                    else_branch = g2 () => (z_else) { z_else = Cast<to:int = @target> (x) }
+                    >
+            }
+        """
+        self._check(model, onnx.TensorProto.INT32)
+
+    def test_mi_function_multiple_calls(self):
+        """Test use of multiple invocation of functions."""
+        model = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17, "local" : 1]
+            >
+            agraph (float[N] x, bool flag) => (y, z)
+            {
+                y = local.cast<target=6>(x, flag)
+                z = local.cast<target=7>(x, flag)
+            }
+            <
+                opset_import: [ "" : 17 ],
+                domain: "local"
+            >
+            cast<target>(x, flag) => (y)
+            {
+                y = If (flag) <
+                    then_branch = g1 () => (z_then) { z_then = Cast<to:int = @target> (x) },
+                    else_branch = g2 () => (z_else) { z_else = Cast<to:int = @target> (x) }
+                    >
+            }
+        """
+        self._check(model, onnx.TensorProto.INT32, onnx.TensorProto.INT64)
+
+    def _check_shape(self, model_text: str, *expected: typing.Sequence[int]):
+        """Check that the model inference infers the expected shapes for outputs.
+        Restricted to the simple case of tensor type outputs with completely
+        known shapes.
+        """
+        model = onnx.parser.parse_model(model_text)
+        inferred = onnx.shape_inference.infer_shapes(model, True, True, True)
+        outputs = inferred.graph.output
+        for output, expected_shape in zip(outputs, expected, strict=True):
+            inferred_type = output.type
+            assert inferred_type.HasField("tensor_type")
+            tensor_type = inferred_type.tensor_type
+            assert tensor_type.HasField("shape")
+            inferred_shape = tensor_type.shape
+            assert len(inferred_shape.dim) == len(expected_shape)
+            for inferred_dim, expected_dim in zip(
+                inferred_shape.dim, expected_shape, strict=True
+            ):
+                assert inferred_dim.HasField("dim_value")
+                assert inferred_dim.dim_value == expected_dim
+
+    def test_mi_constant(self):
+        model = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17]
+            >
+            mymodel (float[4, 8, 16] x) => (y) {
+                shape = Constant<value_ints=[8,4,16]>()
+                y = Reshape(x, shape)
+            }
+            """
+        self._check_shape(model, [8, 4, 16])
+
+    def test_mi_constant_2(self):
+        model = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17]
+            >
+            mymodel (float[4, 8, 16] x) => (y) {
+                shape = Constant<value_ints=[4,2,8]>()
+                two = Constant<value_int=2>()
+                shape2 = Mul(shape, two)
+                y = Reshape(x, shape2)
+            }
+            """
+        self._check_shape(model, [8, 4, 16])
+
+    def test_mi_constant_in_function(self):
+        model = """
+            <
+                ir_version: 7,
+                opset_import: [ "" : 17, "local" : 1]
+            >
+            main (float x) => (y, z) {
+                y, z = local.expand(x)
+            }
+            <
+                opset_import: [ "" : 17 ],
+                domain: "local"
+            >
+            expand (x) => (y, z) {
+                shape1 = Constant<value = int64[2] {4,4}>()
+                shape2 = Constant<value = int64[3] {8,8,8}>()
+                z = Expand (x, shape2)
+                y = Expand (x, shape1)
+            }
+            """
+        self._check_shape(model, [4, 4], [8, 8, 8])
+
+    def test_mi_function_default_attr(self):
+        """Test use of default values of function attributes."""
+        model = """
+            <ir_version: 7, opset_import: [ "" : 17, "local" : 1]>
+            agraph (float[N] x) => (y, z)
+            {
+                y = local.cast <target=6> (x) # casts to INT32 type (encoding value 6)
+                z = local.cast (x)  # uses default-attribute value of 1 (FLOAT type)
+            }
+
+            <opset_import: [ "" : 17 ], domain: "local">
+            cast <target: int = 1> (x) => (y)
+            {
+                y = Cast <to:int = @target> (x)
+            }
+        """
+        self._check(model, onnx.TensorProto.INT32, onnx.TensorProto.FLOAT)
+
+    def test_mi_overloaded_function(self):
+        """Test use of functions."""
+        model = """
+            <ir_version: 10, opset_import: [ "" : 17, "local" : 1]>
+            agraph (float[N] x) => (y, z)
+            {
+                y = local.cast:to_int32 (x)
+                z = local.cast:to_int64 (x)
+            }
+            <opset_import: [ "" : 17 ], domain: "local", overload: "to_int32">
+            cast (x) => (y)
+            {
+                y = Cast<to=6> (x)
+            }
+            <opset_import: [ "" : 17 ], domain: "local", overload: "to_int64">
+            cast (x) => (y)
+            {
+                y = Cast<to=7> (x)
+            }
+        """
+        self._check(model, onnx.TensorProto.INT32, onnx.TensorProto.INT64)
diff --git a/onnx/test/node_shape_inference_test.py b/onnx/test/node_shape_inference_test.py
new file mode 100644
index 0000000..e5425bf
--- /dev/null
+++ b/onnx/test/node_shape_inference_test.py
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+
+# Copyright (c) ONNX Project Contributors
+from __future__ import annotations
+
+import pytest
+
+import onnx.helper
+import onnx.shape_inference
+
+
+class TestNodeInference:
+    @pytest.mark.parametrize("op_type", ["GreaterOrEqual", "LessOrEqual"])
+    def test_comparison_op(self, op_type):
+        node = onnx.helper.make_node(op_type, ["x", "y"], ["z"])
+        schema = onnx.defs.get_schema(node.op_type, 23, "")
+        xtype = onnx.helper.make_tensor_type_proto(onnx.TensorProto.INT32, [1, 10])
+        ytype = onnx.helper.make_tensor_type_proto(onnx.TensorProto.INT32, [10, 1])
+        result = onnx.shape_inference.infer_node_outputs(
+            schema, node, {"x": xtype, "y": ytype}
+        )
+        assert list(result.keys()) == ["z"]
+        assert result["z"].tensor_type.elem_type == onnx.TensorProto.BOOL
+        assert [dim.dim_value for dim in result["z"].tensor_type.shape.dim] == [10, 10]
diff --git a/onnx/test/numpy_helper_test.py b/onnx/test/numpy_helper_test.py
new file mode 100644
index 0000000..d2f0acb
--- /dev/null
+++ b/onnx/test/numpy_helper_test.py
@@ -0,0 +1,324 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import onnx
+import onnx.reference
+from onnx import helper, numpy_helper
+
+
+class TestNumpyHelper:
+    def _test_numpy_helper_float_type(self, dtype: np.number) -> None:
+        a = np.random.rand(13, 37).astype(dtype)
+        tensor_def = numpy_helper.from_array(a, "test")
+        assert tensor_def.name == "test"
+        a_recover = numpy_helper.to_array(tensor_def)
+        np.testing.assert_equal(a, a_recover)
+
+    def _test_numpy_helper_int_type(self, dtype: np.number) -> None:
+        a = np.random.randint(
+            np.iinfo(dtype).min, np.iinfo(dtype).max, dtype=dtype, size=(13, 37)
+        )
+        tensor_def = numpy_helper.from_array(a, "test")
+        assert tensor_def.name == "test"
+        a_recover = numpy_helper.to_array(tensor_def)
+        np.testing.assert_equal(a, a_recover)
+
+    def test_float(self) -> None:
+        self._test_numpy_helper_float_type(np.float32)
+
+    def test_uint8(self) -> None:
+        self._test_numpy_helper_int_type(np.uint8)
+
+    def test_int8(self) -> None:
+        self._test_numpy_helper_int_type(np.int8)
+
+    def test_uint16(self) -> None:
+        self._test_numpy_helper_int_type(np.uint16)
+
+    def test_int16(self) -> None:
+        self._test_numpy_helper_int_type(np.int16)
+
+    def test_int32(self) -> None:
+        self._test_numpy_helper_int_type(np.int32)
+
+    def test_int64(self) -> None:
+        self._test_numpy_helper_int_type(np.int64)
+
+    def test_string(self) -> None:
+        a = np.array(["Amy", "Billy", "Cindy", "David"]).astype(object)
+        tensor_def = numpy_helper.from_array(a, "test")
+        assert tensor_def.name == "test"
+        a_recover = numpy_helper.to_array(tensor_def)
+        np.testing.assert_equal(a, a_recover)
+
+    def test_bool(self) -> None:
+        a = np.random.randint(2, size=(13, 37)).astype(bool)
+        tensor_def = numpy_helper.from_array(a, "test")
+        assert tensor_def.name == "test"
+        a_recover = numpy_helper.to_array(tensor_def)
+        np.testing.assert_equal(a, a_recover)
+
+    def test_float16(self) -> None:
+        self._test_numpy_helper_float_type(np.float16)
+
+    def test_complex64(self) -> None:
+        self._test_numpy_helper_float_type(np.complex64)
+
+    def test_complex128(self) -> None:
+        self._test_numpy_helper_float_type(np.complex128)
+
+    def test_from_dict_values_are_np_arrays_of_float(self):
+        map_proto = numpy_helper.from_dict({0: np.array(0.1), 1: np.array(0.9)})
+        assert isinstance(map_proto, onnx.MapProto)
+        assert numpy_helper.to_array(map_proto.values.tensor_values[0]) == np.array(0.1)
+        assert numpy_helper.to_array(map_proto.values.tensor_values[1]) == np.array(0.9)
+
+    def test_from_dict_values_are_np_arrays_of_int(self):
+        map_proto = numpy_helper.from_dict({0: np.array(1), 1: np.array(9)})
+        assert isinstance(map_proto, onnx.MapProto)
+        assert numpy_helper.to_array(map_proto.values.tensor_values[0]) == np.array(1)
+        assert numpy_helper.to_array(map_proto.values.tensor_values[1]) == np.array(9)
+
+    def test_from_dict_values_are_np_arrays_of_ints(self):
+        zero_array = np.array([1, 2])
+        one_array = np.array([9, 10])
+        map_proto = numpy_helper.from_dict({0: zero_array, 1: one_array})
+        assert isinstance(map_proto, onnx.MapProto)
+
+        out_tensor = numpy_helper.to_array(map_proto.values.tensor_values[0])
+        assert out_tensor[0] == zero_array[0]
+        assert out_tensor[1] == zero_array[1]
+
+        out_tensor = numpy_helper.to_array(map_proto.values.tensor_values[1])
+        assert out_tensor[0] == one_array[0]
+        assert out_tensor[1] == one_array[1]
+
+    def test_from_dict_differing_key_types(self):
+        with pytest.raises(TypeError):
+            # Differing key types should raise a TypeError
+            numpy_helper.from_dict({0: np.array(0.1), 1.1: np.array(0.9)})
+
+    def test_from_dict_differing_value_types(self):
+        with pytest.raises(TypeError):
+            # Differing value types should raise a TypeError
+            numpy_helper.from_dict({0: np.array(1), 1: np.array(0.9)})
+
+    def _to_array_from_array(self, value: int, check_dtype: bool = True):
+        onnx_model = helper.make_model(
+            helper.make_graph(
+                [helper.make_node("Cast", ["X"], ["Y"], to=value)],
+                "test",
+                [helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [4])],
+                [helper.make_tensor_value_info("Y", value, [4])],
+            )
+        )
+        ref = onnx.reference.ReferenceEvaluator(onnx_model)
+        if "UINT" in onnx.TensorProto.DataType.Name(value):
+            start = ref.run(None, {"X": np.array([0, 1, 2, 3], dtype=np.float32)})
+        else:
+            start = ref.run(None, {"X": np.array([0, 1, -2, 3], dtype=np.float32)})
+        tp = numpy_helper.from_array(start[0], name="check")
+        assert tp.data_type == value
+        back = numpy_helper.to_array(tp)
+        assert start[0].shape == back.shape
+        if check_dtype:
+            assert start[0].dtype == back.dtype
+        again = numpy_helper.from_array(back, name="check")
+        assert tp.data_type == again.data_type
+        assert tp.name == again.name
+        assert len(tp.raw_data) == len(again.raw_data)
+        assert list(tp.raw_data) == list(again.raw_data)
+        assert tp.raw_data == again.raw_data
+        assert tuple(tp.dims) == tuple(again.dims)
+        assert tp.SerializeToString() == again.SerializeToString()
+        assert tp.data_type == helper.np_dtype_to_tensor_dtype(back.dtype)
+
+    @pytest.mark.parametrize(
+        "data_type",
+        [
+            onnx.TensorProto.FLOAT,
+            onnx.TensorProto.UINT8,
+            onnx.TensorProto.INT8,
+            onnx.TensorProto.UINT16,
+            onnx.TensorProto.INT16,
+            onnx.TensorProto.INT32,
+            onnx.TensorProto.INT64,
+            onnx.TensorProto.BOOL,
+            onnx.TensorProto.FLOAT16,
+            onnx.TensorProto.DOUBLE,
+            onnx.TensorProto.UINT32,
+            onnx.TensorProto.UINT64,
+            onnx.TensorProto.COMPLEX64,
+            onnx.TensorProto.COMPLEX128,
+            onnx.TensorProto.BFLOAT16,
+            onnx.TensorProto.FLOAT8E4M3FN,
+            onnx.TensorProto.FLOAT8E4M3FNUZ,
+            onnx.TensorProto.FLOAT8E5M2,
+            onnx.TensorProto.FLOAT8E5M2FNUZ,
+            onnx.TensorProto.FLOAT8E8M0,
+            onnx.TensorProto.UINT4,
+            onnx.TensorProto.INT4,
+            onnx.TensorProto.UINT2,
+            onnx.TensorProto.INT2,
+            onnx.TensorProto.FLOAT4E2M1,
+        ],
+    )
+    def test_to_array_from_array(self, data_type: onnx.TensorProto.DataType):
+        self._to_array_from_array(data_type)
+
+    def test_to_array_from_array_string(self):
+        self._to_array_from_array(onnx.TensorProto.STRING, False)
+
+    def test_to_float8e8m0_round_modes(self) -> None:
+        # Inputs in [1.0, 2.0): 1.125 has only mantissa bit 20 set, 1.25 only
+        # bit 21, 1.375 bits 20+21, 1.5 bit 22, 1.75 bits 21+22.
+        x = np.array([1.0, 1.125, 1.25, 1.375, 1.5, 1.75], dtype=np.float32)
+
+        # "up": any non-zero mantissa rounds up to the next power of 2.
+        # Regression: a previous mask of 0x4FFFFF missed bits 20 and 21,
+        # so 1.125 / 1.25 / 1.375 were not rounded up.
+        np.testing.assert_array_equal(
+            numpy_helper.to_float8e8m0(x, round_mode="up").view(np.uint8),
+            [127, 128, 128, 128, 128, 128],
+        )
+        # "down" truncates: every value in [1.0, 2.0) keeps exponent 127.
+        np.testing.assert_array_equal(
+            numpy_helper.to_float8e8m0(x, round_mode="down").view(np.uint8),
+            [127, 127, 127, 127, 127, 127],
+        )
+        # "nearest" rounds at bit 22 (i.e., at 1.5), independent of bits 0-21.
+        np.testing.assert_array_equal(
+            numpy_helper.to_float8e8m0(x, round_mode="nearest").view(np.uint8),
+            [127, 127, 127, 127, 128, 128],
+        )
+        # Unknown round_mode is a programming error.
+        with pytest.raises(ValueError):
+            numpy_helper.to_float8e8m0(
+                np.array([1.0], dtype=np.float32), round_mode="bogus"
+            )
+
+    def test_to_float8e8m0_extreme_values(self) -> None:
+        # NaN/Inf inputs (exponent byte 0xFF) survive every mode/saturate combo.
+        special = np.array([np.nan, np.inf, -np.inf], dtype=np.float32)
+        for mode in ("up", "down", "nearest"):
+            for saturate in (True, False):
+                out = numpy_helper.to_float8e8m0(
+                    special, saturate=saturate, round_mode=mode
+                )
+                np.testing.assert_array_equal(
+                    out.view(np.uint8),
+                    [0xFF, 0xFF, 0xFF],
+                    err_msg=f"mode={mode}, saturate={saturate}",
+                )
+
+        # 1.5 * 2**127 has exponent 0xFE with a non-zero mantissa. Under
+        # round_mode="up", saturate=True caps at 0xFE; saturate=False lets
+        # the exponent roll into 0xFF (the NaN slot).
+        near_max = np.array([1.5 * 2.0**127], dtype=np.float32)
+        assert (
+            numpy_helper.to_float8e8m0(near_max, saturate=True, round_mode="up").view(
+                np.uint8
+            )[0]
+            == 0xFE
+        )
+        assert (
+            numpy_helper.to_float8e8m0(near_max, saturate=False, round_mode="up").view(
+                np.uint8
+            )[0]
+            == 0xFF
+        )
+
+    def test_from_array_object_invalid_type(self) -> None:
+        a = np.array([42], dtype=object)
+        with pytest.raises(NotImplementedError, match="int"):
+            numpy_helper.from_array(a)
+
+    def test_from_list_explicit_dtype(self) -> None:
+        # Verify explicit dtype is honored, not auto-detected
+        seq = numpy_helper.from_list([], dtype=onnx.SequenceProto.MAP)
+        assert seq.elem_type == onnx.SequenceProto.MAP
+        # Without dtype, empty list defaults to TENSOR
+        seq2 = numpy_helper.from_list([])
+        assert seq2.elem_type == onnx.SequenceProto.TENSOR
+
+    def test_to_dict_mismatched_lengths(self) -> None:
+        # Build a valid map then add an extra key to create a mismatch
+        m = numpy_helper.from_dict({1: np.array(1.0), 2: np.array(2.0)})
+        m.keys.append(3)
+        with pytest.raises(IndexError, match="not the same"):
+            numpy_helper.to_dict(m)
+
+    def test_from_dict_empty(self) -> None:
+        with pytest.raises(ValueError):
+            numpy_helper.from_dict({})
+
+    def test_from_dict_unsupported_key_type(self) -> None:
+        with pytest.raises(TypeError, match="Unsupported map key type"):
+            numpy_helper.from_dict({1.5: np.array(1), 2.5: np.array(2)})
+
+    @pytest.mark.parametrize(
+        "data_type",
+        [
+            onnx.TensorProto.UINT4,
+            onnx.TensorProto.INT4,
+            onnx.TensorProto.FLOAT4E2M1,
+        ],
+    )
+    def test_to_array_4bit_payload_too_small_raw_data(self, data_type: int) -> None:
+        tensor = onnx.TensorProto()
+        tensor.data_type = data_type
+        tensor.dims.extend([1000])
+        tensor.raw_data = b"\x00"  # encodes 2 elements, not 1000
+        with pytest.raises(ValueError):
+            numpy_helper.to_array(tensor)
+
+    @pytest.mark.parametrize(
+        "data_type",
+        [
+            onnx.TensorProto.UINT4,
+            onnx.TensorProto.INT4,
+            onnx.TensorProto.FLOAT4E2M1,
+        ],
+    )
+    def test_to_array_4bit_payload_too_small_int32_data(self, data_type: int) -> None:
+        tensor = onnx.TensorProto()
+        tensor.data_type = data_type
+        tensor.dims.extend([1000])
+        tensor.int32_data.append(0)  # encodes 8 elements, not 1000
+        with pytest.raises(ValueError):
+            numpy_helper.to_array(tensor)
+
+    @pytest.mark.parametrize(
+        "data_type",
+        [
+            onnx.TensorProto.UINT2,
+            onnx.TensorProto.INT2,
+        ],
+    )
+    def test_to_array_2bit_payload_too_small_raw_data(self, data_type: int) -> None:
+        tensor = onnx.TensorProto()
+        tensor.data_type = data_type
+        tensor.dims.extend([1000])
+        tensor.raw_data = b"\x00"  # encodes 4 elements, not 1000
+        with pytest.raises(ValueError):
+            numpy_helper.to_array(tensor)
+
+    @pytest.mark.parametrize(
+        "data_type",
+        [
+            onnx.TensorProto.UINT2,
+            onnx.TensorProto.INT2,
+        ],
+    )
+    def test_to_array_2bit_payload_too_small_int32_data(self, data_type: int) -> None:
+        tensor = onnx.TensorProto()
+        tensor.data_type = data_type
+        tensor.dims.extend([1000])
+        tensor.int32_data.append(0)  # encodes 16 elements, not 1000
+        with pytest.raises(ValueError):
+            numpy_helper.to_array(tensor)
diff --git a/onnx/test/parser_test.py b/onnx/test/parser_test.py
new file mode 100644
index 0000000..29f53c8
--- /dev/null
+++ b/onnx/test/parser_test.py
@@ -0,0 +1,410 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import locale
+import platform
+
+import pytest
+
+import onnx
+from onnx import GraphProto, OperatorSetIdProto, TensorProto, checker
+
+
+class TestBasicFunctions:
+    def check_graph(self, graph: GraphProto) -> None:
+        assert len(graph.node) == 3
+        assert graph.node[0].op_type == "MatMul"
+        assert graph.node[1].op_type == "Add"
+        assert graph.node[2].op_type == "Softmax"
+
+    def test_parse_graph(self) -> None:
+        input = """
+           agraph (float[N, 128] X, float[128,10] W, float[10] B) => (float[N] C)
+           {
+              T = MatMul(X, W)
+              S = Add(T, B)
+              C = Softmax(S)
+           }
+           """
+        graph = onnx.parser.parse_graph(input)
+        self.check_graph(graph)
+
+    def test_parse_model(self) -> None:
+        input = """
+           <
+             ir_version: 7,
+             opset_import: [ "" : 10, "com.microsoft": 1]
+           >
+           agraph (float[N, 128] X, float[128,10] W, float[10] B) => (float[N] C)
+           {
+              T = MatMul(X, W)
+              S = Add(T, B)
+              C = Softmax(S)
+           }
+           """
+        model = onnx.parser.parse_model(input)
+        assert model.ir_version == 7
+        assert len(model.opset_import) == 2
+        self.check_graph(model.graph)
+
+    def test_parse_graph_error(self) -> None:
+        input = """
+           agraph (float[N, 128] X, float[128,10] W, float[10] B) => (float[N] C)
+           {
+              T = MatMul[X, W]
+              S = Add(T, B)
+              C = Softmax(S)
+           }
+           """
+        with pytest.raises(onnx.parser.ParseError):
+            onnx.parser.parse_graph(input)
+
+    def test_parse_model_error(self) -> None:
+        input = """
+           <
+             ir_version: 7,
+             opset_import: [ "" : 10   "com.microsoft": 1]
+           >
+           agraph (float[N, 128] X, float[128,10] W, float[10] B) => (float[N] C)
+           {
+              T = MatMul(X, W)
+              S = Add(T, B)
+              C = Softmax(S)
+           }
+           """
+        with pytest.raises(onnx.parser.ParseError):
+            onnx.parser.parse_model(input)
+
+    def test_parse_function_with_attributes(self) -> None:
+        input = """
+            <
+            ir_version: 9,
+            opset_import: [ "" : 15, "custom_domain" : 1],
+            producer_name: "FunctionProtoTest",
+            producer_version: "1.0",
+            model_version: 1,
+            doc_string: "A test model for model local functions."
+          >
+         agraph (float[N] x) => (float[N] out)
+         {
+            out = custom_domain.Selu<alpha=2.0, gamma=3.0>(x)
+         }
+         <
+         domain: "custom_domain",
+         opset_import: [ "" : 15],
+         doc_string: "Test function proto"
+         >
+           Selu
+           <alpha: float=1.67326319217681884765625, gamma: float=1.05070102214813232421875>
+           (X) => (C)
+           {
+               constant_alpha = Constant<value_float: float=@alpha>()
+               constant_gamma = Constant<value_float: float=@gamma>()
+               alpha_x = CastLike(constant_alpha, X)
+               gamma_x = CastLike(constant_gamma, X)
+               exp_x = Exp(X)
+               alpha_x_exp_x = Mul(alpha_x, exp_x)
+               alpha_x_exp_x_ = Sub(alpha_x_exp_x, alpha_x)
+               neg = Mul(gamma_x, alpha_x_exp_x_)
+               pos = Mul(gamma_x, X)
+               _zero = Constant<value_float=0.0>()
+               zero = CastLike(_zero, X)
+               less_eq = LessOrEqual(X, zero)
+               C = Where(less_eq, neg, pos)
+           }
+        """
+
+        model = onnx.parser.parse_model(input)
+        checker.check_model(model)
+
+    @pytest.mark.parametrize(
+        "graph_text, expected_attribute",
+        [
+            (
+                "agraph (float[N] x) => (float[N] out) { out = custom_domain.Selu(x) }",
+                {},
+            ),
+            (
+                "agraph (float[N] x) => (float[N] out) { out = custom_domain.Selu<alpha=2.0>(x) }",
+                {"alpha": 2.0},
+            ),
+            (
+                "agraph (float[N] x) => (float[N] out) { out = custom_domain.Selu<gamma=3.0>(x) }",
+                {"gamma": 3.0},
+            ),
+            (
+                "agraph (float[N] x) => (float[N] out) { out = custom_domain.Selu<alpha=2.0, gamma=3.0>(x) }",
+                {"alpha": 2.0, "gamma": 3.0},
+            ),
+        ],
+    )
+    def test_composite_parse_function_with_attributes(
+        self, graph_text: str, expected_attribute: dict
+    ) -> None:
+        default_alpha = 1.67326319217681884765625
+        default_gamma = 1.05070102214813232421875
+
+        def expect_custom_node_attribute(node, attributes):
+            for key in attributes:
+                match_attr = [attr for attr in node.attribute if attr.name == key]
+                assert len(match_attr) == 1
+                assert match_attr[0].f == attributes[key]
+
+        def expect_model_function_attribute(model):
+            assert len(model.functions[0].attribute_proto) == 2
+            attr_proto_alpha = [
+                attr_proto
+                for attr_proto in model.functions[0].attribute_proto
+                if attr_proto.name == "alpha"
+            ]
+            assert len(attr_proto_alpha) == 1 and attr_proto_alpha[0].f == default_alpha
+            attr_proto_gamma = [
+                attr_proto
+                for attr_proto in model.functions[0].attribute_proto
+                if attr_proto.name == "gamma"
+            ]
+            assert len(attr_proto_gamma) == 1 and attr_proto_gamma[0].f == default_gamma
+
+        function_text = f"""
+         <
+         domain: "custom_domain",
+         opset_import: [ "" : 15],
+         doc_string: "Test function proto"
+         >
+           Selu
+           <alpha: float={default_alpha}, gamma: float={default_gamma}>
+           (X) => (C)
+           {{
+               constant_alpha = Constant<value_float: float=@alpha>()
+               constant_gamma = Constant<value_float: float=@gamma>()
+               alpha_x = CastLike(constant_alpha, X)
+               gamma_x = CastLike(constant_gamma, X)
+               exp_x = Exp(X)
+               alpha_x_exp_x = Mul(alpha_x, exp_x)
+               alpha_x_exp_x_ = Sub(alpha_x_exp_x, alpha_x)
+               neg = Mul(gamma_x, alpha_x_exp_x_)
+               pos = Mul(gamma_x, X)
+               _zero = Constant<value_float=0.0>()
+               zero = CastLike(_zero, X)
+               less_eq = LessOrEqual(X, zero)
+               C = Where(less_eq, neg, pos)
+           }}
+        """
+
+        functions = [onnx.parser.parse_function(function_text)]
+        graph = onnx.parser.parse_graph(graph_text)
+        opset_imports = [
+            OperatorSetIdProto(domain="", version=15),
+            OperatorSetIdProto(domain="custom_domain", version=1),
+        ]
+
+        model = onnx.helper.make_model(
+            graph, functions=functions, opset_imports=opset_imports
+        )
+        checker.check_model(model)
+
+        expect_model_function_attribute(model)
+        expect_custom_node_attribute(model.graph.node[0], expected_attribute)
+
+    def test_parse_node(self):
+        node = onnx.parser.parse_node(
+            "out1, out2 = SomeDomain.SomeOp <attr1 = 1> (in1, in2)"
+        )
+        assert list(node.input) == ["in1", "in2"]
+        assert list(node.output) == ["out1", "out2"]
+        assert len(node.attribute) == 1
+        attr_val = onnx.helper.get_node_attr_value(node, "attr1")
+        assert attr_val == 1
+        assert node.domain == "SomeDomain"
+        assert node.op_type == "SomeOp"
+
+    def test_parse_float_attribute_from_int_literal(self):
+        model = onnx.parser.parse_model(
+            """
+            <
+              ir_version: 9,
+              opset_import: [ "" : 18, "custom_domain" : 1]
+            >
+            agraph (float[N] x) => (float[N] out)
+            {
+              out = custom_domain.Foo<ord: float = 2>(x)
+            }
+            """
+        )
+        attr = model.graph.node[0].attribute[0]
+        assert attr.type == onnx.AttributeProto.FLOAT
+        assert attr.HasField("f")
+        assert not attr.HasField("i")
+        assert attr.f == 2.0
+
+    def test_missing_identifier(self):
+        node = onnx.parser.parse_node("= SomeOp ()")
+        assert list(node.input) == []
+        assert list(node.output) == []
+        node = onnx.parser.parse_node(", = SomeOp (,)")
+        assert list(node.input) == [""]
+        assert list(node.output) == [""]
+        node = onnx.parser.parse_node("x, = SomeOp (y,)")
+        assert list(node.input) == ["y"]
+        assert list(node.output) == ["x"]
+        node = onnx.parser.parse_node(",x = SomeOp (,y)")
+        assert list(node.input) == ["", "y"]
+        assert list(node.output) == ["", "x"]
+
+    def test_quoted_empty_identifier(self):
+        node = onnx.parser.parse_node('"" = SomeOp ("")')
+        assert list(node.input) == [""]
+        assert list(node.output) == [""]
+        node = onnx.parser.parse_node('"",x = SomeOp ("",y)')
+        assert list(node.input) == ["", "y"]
+        assert list(node.output) == ["", "x"]
+
+    def test_quoted_string_symbolic_dim(self):
+        # Test parsing a quoted string as a symbolic dimension (non-identifier dim_param)
+        graph = onnx.parser.parse_graph(
+            'agraph (float["M + N"] x) => (float["M + N"] y) { y = Identity(x) }'
+        )
+        assert graph.input[0].type.tensor_type.shape.dim[0].dim_param == "M + N"
+        assert graph.output[0].type.tensor_type.shape.dim[0].dim_param == "M + N"
+
+    @pytest.mark.parametrize(
+        "test_literal, expect_exception",
+        [
+            ("not_a_good_float", True),
+            ("inf1", True),
+            ("-inf1", True),
+            ("nan0", True),
+            ("-nan0", True),
+            ("naninf", True),
+            ("inf", False),
+            ("-inf", False),
+            ("infinity", False),
+            ("-infinity", False),
+            ("nan", False),
+            ("-NaN", False),
+        ],
+    )
+    def test_parse_various_float_values(self, test_literal, expect_exception):
+        model_text = f"""
+        <
+        ir_version: 8,
+        opset_import: ["" : 18, "this" : 1],
+        producer_name: "FunctionProtoTest",
+        producer_version: "1.0"
+        >
+        _func () => ()
+        {{
+        tmp = Constant <value_float = {test_literal}>()
+        }}
+        """
+        if expect_exception:
+            with pytest.raises(onnx.parser.ParseError):
+                onnx.parser.parse_model(model_text)
+        else:
+            model = onnx.parser.parse_model(model_text)
+            assert model.ir_version == 8
+            assert model.producer_name == "FunctionProtoTest"
+            assert model.producer_version == "1.0"
+            assert len(model.graph.node) == 1
+            assert len(model.graph.node[0].attribute) == 1
+            assert model.graph.node[0].attribute[0].name == "value_float"
+            assert model.graph.node[0].attribute[0].type == onnx.AttributeProto.FLOAT
+            assert str(model.graph.node[0].attribute[0].f) == str(float(test_literal))
+
+    @pytest.mark.parametrize(
+        "name, itype",
+        [
+            ("bfloat16", TensorProto.BFLOAT16),
+            ("bool", TensorProto.BOOL),
+            ("complex64", TensorProto.COMPLEX64),
+            ("complex128", TensorProto.COMPLEX128),
+            ("double", TensorProto.DOUBLE),
+            ("float16", TensorProto.FLOAT16),
+            ("float", TensorProto.FLOAT),
+            ("float8e4m3fn", TensorProto.FLOAT8E4M3FN),
+            ("float8e4m3fnuz", TensorProto.FLOAT8E4M3FNUZ),
+            ("float8e5m2", TensorProto.FLOAT8E5M2),
+            ("float8e5m2fnuz", TensorProto.FLOAT8E5M2FNUZ),
+            ("int2", TensorProto.INT2),
+            ("int4", TensorProto.INT4),
+            ("int8", TensorProto.INT8),
+            ("int16", TensorProto.INT16),
+            ("int32", TensorProto.INT32),
+            ("int64", TensorProto.INT64),
+            ("string", TensorProto.STRING),
+            ("uint2", TensorProto.UINT2),
+            ("uint4", TensorProto.UINT4),
+            ("uint8", TensorProto.UINT8),
+            ("uint16", TensorProto.UINT16),
+            ("uint32", TensorProto.UINT32),
+            ("uint64", TensorProto.UINT64),
+            ("float4e2m1", TensorProto.FLOAT4E2M1),
+        ],
+    )
+    def test_parse_graph_types(self, name, itype) -> None:
+        w = '{"0"}' if itype == TensorProto.STRING else "{0}"
+        text_graph = f"""
+           <
+             ir_version: 10,
+             opset_import: [ "" : 19]
+           >
+           agraph (float[N] X) => ({name}[N] C)
+           <
+             {name}[1] weight = {w}
+           >
+           {{
+              C = Cast<to={itype}>(X)
+           }}
+           """
+        graph = onnx.parser.parse_model(text_graph)
+        assert len(graph.graph.node) == 1
+
+    def test_locale_independent_float_parsing(self) -> None:
+        """Regression test: float parsing must work under non-US locales.
+
+        See https://github.com/onnx/onnx/issues/8111
+        """
+        original_locale = locale.setlocale(locale.LC_NUMERIC, None)
+
+        def restore_locale() -> None:
+            locale.setlocale(locale.LC_NUMERIC, original_locale)
+
+        # Try to set a locale with comma as decimal separator.
+        # Use platform-appropriate locale names.
+        is_windows = platform.system() == "Windows"
+        candidates = (
+            ("German_Germany.1252", "French_France.1252")
+            if is_windows
+            else ("de_DE.UTF-8", "fr_FR.UTF-8")
+        )
+        locale_set = False
+        for candidate in candidates:
+            try:
+                locale.setlocale(locale.LC_NUMERIC, candidate)
+                locale_set = True
+                break
+            except locale.Error:
+                continue
+
+        if not locale_set:
+            restore_locale()
+            pytest.skip("No locale with comma decimal separator available")
+
+        try:
+            model_text = """
+            <ir_version: 7, opset_import: ["" : 13]>
+            agraph (float[1, 5] X) => (float[1, 5] Y) {
+                Y = LeakyRelu <alpha = 0.123> (X)
+            }
+            """
+            model = onnx.parser.parse_model(model_text)
+            node = model.graph.node[0]
+            assert node.attribute[0].name == "alpha"
+            alpha = node.attribute[0].f
+            assert alpha == pytest.approx(0.123, abs=1e-5), (
+                "Float attribute misparsed under non-US locale"
+            )
+        finally:
+            restore_locale()
diff --git a/onnx/test/printer_test.py b/onnx/test/printer_test.py
new file mode 100644
index 0000000..7c582e7
--- /dev/null
+++ b/onnx/test/printer_test.py
@@ -0,0 +1,68 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import pytest
+
+import onnx
+from onnx import parser, printer
+
+
+class TestBasicFunctions:
+    def check_graph(self, graph: onnx.GraphProto) -> None:
+        assert len(graph.node) == 3
+        assert graph.node[0].op_type == "MatMul"
+        assert graph.node[1].op_type == "Add"
+        assert graph.node[2].op_type == "Softmax"
+
+    def test_parse_graph(self) -> None:
+        text0 = """
+           agraph (float[N, 128] X, float[128,10] W, float[10] B) => (float[N] C)
+           {
+              T = MatMul(X, W)
+              S = Add(T, B)
+              C = Softmax(S)
+           }
+           """
+        graph1 = parser.parse_graph(text0)
+        text1 = printer.to_text(graph1)
+        graph2 = parser.parse_graph(text1)
+        text2 = printer.to_text(graph2)
+        # Note that text0 and text1 should be semantically-equivalent, but may differ
+        # in white-space and other syntactic sugar. However, we expect text1 and text2
+        # to be identical.
+        assert text1 == text2
+        self.check_graph(graph2)
+
+    def test_quoted_string_symbolic_dim_roundtrip(self) -> None:
+        # Test that non-identifier dim_params are printed as quoted strings and
+        # can be parsed back (round-trip).
+        text0 = 'agraph (float["M + N"] x) => (float["M + N"] y) { y = Identity(x) }'
+        graph1 = parser.parse_graph(text0)
+        text1 = printer.to_text(graph1)
+        graph2 = parser.parse_graph(text1)
+        text2 = printer.to_text(graph2)
+        assert text1 == text2
+        # Verify that "M + N" is preserved as a quoted string in the printed output
+        assert '"M + N"' in text1
+
+    def test_parse_node_roundtrip(self) -> None:
+        # Regression test for #7944: parse_node accepts NodeProto text but
+        # printer.to_text(NodeProto) raised TypeError because NodeProto was
+        # not handled in the dispatch.
+        text0 = "C = Softmax(S)"
+        node1 = parser.parse_node(text0)
+        text1 = printer.to_text(node1)
+        node2 = parser.parse_node(text1)
+        text2 = printer.to_text(node2)
+        assert text1 == text2
+        assert node2.op_type == "Softmax"
+        assert list(node2.output) == ["C"]
+        assert list(node2.input) == ["S"]
+
+    def test_to_text_unsupported_type_raises(self) -> None:
+        # to_text dispatches on proto type and raises TypeError for unsupported
+        # arguments. Use a proto type outside the supported set.
+        with pytest.raises(TypeError):
+            printer.to_text(onnx.AttributeProto())
diff --git a/onnx/test/reference_evaluator_ml_test.py b/onnx/test/reference_evaluator_ml_test.py
new file mode 100644
index 0000000..dd2e2ed
--- /dev/null
+++ b/onnx/test/reference_evaluator_ml_test.py
@@ -0,0 +1,2353 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# mypy: ignore-errors
+from __future__ import annotations
+
+import importlib
+import itertools
+import os
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+import onnx
+from onnx import ONNX_ML, TensorProto, TypeProto, ValueInfoProto
+from onnx.helper import (
+    make_graph,
+    make_model_gen_version,
+    make_node,
+    make_opsetid,
+    make_tensor,
+    make_tensor_value_info,
+)
+from onnx.reference import ReferenceEvaluator
+from onnx.reference.ops.aionnxml.op_tree_ensemble import (
+    AggregationFunction,
+    Mode,
+    PostTransform,
+)
+
+# TODO (https://github.com/microsoft/onnxruntime/issues/14932): Get max supported version from onnxruntime directly
+# For now, bump the version in CIs whenever there is a new onnxruntime release
+ORT_MAX_IR_SUPPORTED_VERSION = int(os.getenv("ORT_MAX_IR_SUPPORTED_VERSION", "8"))
+ORT_MAX_ONNX_OPSET_SUPPORTED_VERSION = int(
+    os.getenv("ORT_MAX_ONNX_OPSET_SUPPORTED_VERSION", "18")
+)
+ORT_MAX_ML_OPSET_SUPPORTED_VERSION = int(
+    os.getenv("ORT_MAX_ML_OPSET_SUPPORTED_VERSION", "3")
+)
+
+TARGET_OPSET = onnx.defs.onnx_opset_version() - 2
+TARGET_OPSET_ML = onnx.defs.onnx_ml_opset_version()
+OPSETS = [make_opsetid("", TARGET_OPSET), make_opsetid("ai.onnx.ml", TARGET_OPSET_ML)]
+
+
+def has_onnxruntime():
+    return importlib.util.find_spec("onnxruntime") is not None
+
+
+class TestReferenceEvaluatorAiOnnxMl:
+    @staticmethod
+    def _check_ort(model, feeds, atol=0, rtol=0, equal=False, rev=False):
+        if not has_onnxruntime():
+            pytest.skip("onnxruntime not installed")
+
+        from onnxruntime import InferenceSession  # noqa: PLC0415
+
+        onnx_domain_opset = ORT_MAX_ONNX_OPSET_SUPPORTED_VERSION
+        ml_domain_opset = ORT_MAX_ML_OPSET_SUPPORTED_VERSION
+        for opset in model.opset_import:
+            if opset.domain in ("", "ai.onnx"):
+                onnx_domain_opset = opset.version
+                break
+        for opset in model.opset_import:
+            if opset.domain == "ai.onnx.ml":
+                ml_domain_opset = opset.version
+                break
+        # The new IR or opset version is not supported by onnxruntime yet
+        if (
+            model.ir_version > ORT_MAX_IR_SUPPORTED_VERSION
+            or onnx_domain_opset > ORT_MAX_ONNX_OPSET_SUPPORTED_VERSION
+            or ml_domain_opset > ORT_MAX_ML_OPSET_SUPPORTED_VERSION
+        ):
+            return
+
+        ort = InferenceSession(
+            model.SerializeToString(), providers=["CPUExecutionProvider"]
+        )
+        sess = ReferenceEvaluator(model)
+        expected = ort.run(None, feeds)
+        got = sess.run(None, feeds)
+        if len(expected) != len(got):
+            raise AssertionError(
+                f"onnxruntime returns a different number of output "
+                f"{len(expected)} != {len(sess)} (ReferenceEvaluator)."
+            )
+        look = (
+            zip(reversed(expected), reversed(got), strict=True)
+            if rev
+            else zip(expected, got, strict=True)
+        )
+        for i, (e, g) in enumerate(look):
+            if e.shape != g.shape:
+                raise AssertionError(
+                    f"Unexpected shape {g.shape} for output {i} "
+                    f"(expecting {e.shape})\n{e!r}\n---\n{g!r}."
+                )
+            if equal:
+                if e.tolist() != g.tolist():
+                    raise AssertionError(
+                        f"Discrepancies for output {i}"
+                        f"\nexpected=\n{e}\n!=\nresults=\n{g}"
+                    )
+            else:
+                assert_allclose(
+                    actual=g,
+                    desired=e,
+                    atol=atol,
+                    rtol=rtol,
+                    err_msg=f"Discrepancies for output {i} expected[0]={e.ravel()[0]}.",
+                )
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_binarizer(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node("Binarizer", ["X"], ["Y"], threshold=5.5, domain="ai.onnx.ml")
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.arange(12).reshape((3, 4)).astype(np.float32)
+        expected = np.array(
+            [[0, 0, 0, 0], [0, 0, 1, 1], [1, 1, 1, 1]], dtype=np.float32
+        )
+        self._check_ort(model, {"X": x})
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(got, expected)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_scaler(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node(
+            "Scaler", ["X"], ["Y"], scale=[0.5], offset=[-4.5], domain="ai.onnx.ml"
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.arange(12).reshape((3, 4)).astype(np.float32)
+        expected = np.array(
+            [
+                [2.25, 2.75, 3.25, 3.75],
+                [4.25, 4.75, 5.25, 5.75],
+                [6.25, 6.75, 7.25, 7.75],
+            ],
+            dtype=np.float32,
+        )
+        self._check_ort(model, {"X": x})
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(got, expected)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_array_feature_extractor(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        A = make_tensor_value_info("A", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node(
+            "ArrayFeatureExtractor", ["X", "A"], ["Y"], domain="ai.onnx.ml"
+        )
+        graph = make_graph([node1], "ml", [X, A], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.arange(12).reshape((3, 4)).astype(np.float32)
+
+        expected = np.array([[0, 4, 8]], dtype=np.float32).T
+        feeds = {"X": x, "A": np.array([0], dtype=np.int64)}
+        self._check_ort(model, feeds)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, feeds)[0]
+        assert_allclose(got, expected)
+
+        expected = np.array([[0, 4, 8], [1, 5, 9]], dtype=np.float32).T
+        feeds = {"X": x, "A": np.array([0, 1], dtype=np.int64)}
+        self._check_ort(model, feeds)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, feeds)[0]
+        assert_allclose(got, expected)
+
+        expected = np.array(
+            [[0, 4, 8], [1, 5, 9], [0, 4, 8], [1, 5, 9], [0, 4, 8], [1, 5, 9]],
+            dtype=np.float32,
+        ).T
+        feeds = {"X": x, "A": np.array([0, 1, 0, 1, 0, 1], dtype=np.int64)}
+        self._check_ort(model, feeds)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, feeds)[0]
+        assert_allclose(got, expected)
+
+    @pytest.mark.parametrize(
+        "norm, compute",
+        [
+            ("MAX", lambda x: x / x.max(axis=1, keepdims=1)),
+            ("L1", lambda x: x / np.abs(x).sum(axis=1, keepdims=1)),
+            ("L2", lambda x: x / (x**2).sum(axis=1, keepdims=1) ** 0.5),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_normalizer(self, norm, compute):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        x = np.arange(12).reshape((3, 4)).astype(np.float32)
+
+        node1 = make_node("Normalizer", ["X"], ["Y"], norm=norm, domain="ai.onnx.ml")
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+
+        feeds = {"X": x}
+        expected = compute(x)
+        self._check_ort(model, feeds, atol=1e-6)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, feeds)[0]
+        assert_allclose(got, expected, atol=1e-6)
+
+    @pytest.mark.parametrize(
+        "inputdimensions, expected_value",
+        [
+            ((1,), np.array([[0], [3], [6]], dtype=np.float32)),
+            ((2,), np.array([[0, 1], [3, 4], [6, 7]], dtype=np.float32)),
+            (
+                (4,),
+                np.array([[0, 1, 2, 0], [3, 4, 5, 0], [6, 7, 8, 0]], dtype=np.float32),
+            ),
+            ((1, 1), np.array([[0, 0.5], [3, 3.5], [6, 6.5]], dtype=np.float32)),
+            ((0, 1), np.array([[0.5], [3.5], [6.5]], dtype=np.float32)),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_feature_vectorizer(self, inputdimensions, expected_value):
+        X = [
+            make_tensor_value_info("X0", TensorProto.FLOAT, [None, None]),
+            make_tensor_value_info("X1", TensorProto.FLOAT, [None, None]),
+        ]
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        x = [
+            np.arange(9).reshape((3, 3)).astype(np.float32),
+            np.arange(9).reshape((3, 3)).astype(np.float32) + 0.5,
+        ]
+        att = (
+            list(inputdimensions)
+            if isinstance(inputdimensions, tuple)
+            else inputdimensions
+        )
+        node1 = make_node(
+            "FeatureVectorizer",
+            [f"X{i}" for i in range(len(att))],
+            ["Y"],
+            inputdimensions=att,
+            domain="ai.onnx.ml",
+        )
+        graph = make_graph([node1], "ml", X[: len(att)], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+
+        feeds = {f"X{i}": v for i, v in enumerate(x[: len(att)])}
+        self._check_ort(model, feeds, atol=1e-6)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, feeds)[0]
+        assert_allclose(got, expected_value, atol=1e-6)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_imputer_float(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node(
+            "Imputer",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            imputed_value_floats=np.array([0], dtype=np.float32),
+            replaced_value_float=np.nan,
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.array([[0, 1, np.nan, 3]], dtype=np.float32).T
+        expected = np.array([[0, 1, 0, 3]], dtype=np.float32).T
+        self._check_ort(model, {"X": x})
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(got, expected)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_imputer_float_2d(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node(
+            "Imputer",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            imputed_value_floats=np.array([0, 0.1], dtype=np.float32),
+            replaced_value_float=np.nan,
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.array([[0, 1, np.nan, 3], [0, 1, np.nan, 3]], dtype=np.float32).T
+        expected = np.array([[0, 1, 0, 3], [0, 1, 0.1, 3]], dtype=np.float32).T
+        self._check_ort(model, {"X": x})
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(got, expected)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_imputer_int(self):
+        X = make_tensor_value_info("X", TensorProto.INT64, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.INT64, [None, None])
+        node1 = make_node(
+            "Imputer",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            imputed_value_int64s=np.array([0], dtype=np.int64),
+            replaced_value_int64=-1,
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.array([[0, 1, -1, 3]], dtype=np.int64).T
+        expected = np.array([[0, 1, 0, 3]], dtype=np.int64).T
+        self._check_ort(model, {"X": x})
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(got, expected)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_label_encoder_float_int(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.INT64, [None, None])
+        node1 = make_node(
+            "LabelEncoder",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            default_int64=-5,
+            keys_floats=[4.0, 1.0, 2.0, 3.0],
+            values_int64s=[0, 1, 2, 3],
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.array([[0, 1, np.nan, 3, 4]], dtype=np.float32).T
+        expected = np.array([[-5, 1, -5, 3, 0]], dtype=np.int64).T
+        self._check_ort(model, {"X": x})
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(got, expected)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_label_encoder_int_string(self):
+        X = make_tensor_value_info("X", TensorProto.INT64, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.STRING, [None, None])
+        node1 = make_node(
+            "LabelEncoder",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            default_string="NONE",
+            keys_int64s=[1, 2, 3, 4],
+            values_strings=["a", "b", "cc", "ddd"],
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.array([[0, 1, 3, 4]], dtype=np.int64).T
+        expected = np.array([["NONE"], ["a"], ["cc"], ["ddd"]])
+        self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert expected.tolist() == got.tolist()
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_label_encoder_int_string_tensor_attributes(self):
+        X = make_tensor_value_info("X", TensorProto.INT64, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.STRING, [None, None])
+        node = make_node(
+            "LabelEncoder",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            keys_tensor=make_tensor(
+                "keys_tensor", TensorProto.INT64, [4], [1, 2, 3, 4]
+            ),
+            values_tensor=make_tensor(
+                "values_tensor", TensorProto.STRING, [4], ["a", "b", "cc", "ddd"]
+            ),
+            default_tensor=make_tensor(
+                "default_tensor", TensorProto.STRING, [], ["NONE"]
+            ),
+        )
+        graph = make_graph([node], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.array([[0, 1, 3, 4]], dtype=np.int64).T
+        expected = np.array([["NONE"], ["a"], ["cc"], ["ddd"]])
+        self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert expected.tolist() == got.tolist()
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_dict_vectorizer(self):
+        value_type = TypeProto()
+        value_type.tensor_type.elem_type = TensorProto.INT64
+        onnx_type = TypeProto()
+        onnx_type.map_type.key_type = TensorProto.STRING
+        onnx_type.map_type.value_type.CopyFrom(value_type)
+        value_info = ValueInfoProto()
+        value_info.name = "X"
+        value_info.type.CopyFrom(onnx_type)
+
+        X = value_info
+        Y = make_tensor_value_info("Y", TensorProto.INT64, [None, None])
+        node1 = make_node(
+            "DictVectorizer",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            string_vocabulary=["a", "c", "b", "z"],
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = {"a": np.array(4, dtype=np.int64), "c": np.array(8, dtype=np.int64)}
+        expected = np.array([4, 8, 0, 0], dtype=np.int64)
+        # Unexpected input data type. Actual: ((map(string,tensor(float)))) , expected: ((map(string,tensor(int64))))
+        # self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert expected.tolist() == got.tolist()
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_one_hot_encoder_int(self):
+        X = make_tensor_value_info("X", TensorProto.INT64, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None])
+        node1 = make_node(
+            "OneHotEncoder",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            zeros=1,
+            cats_int64s=[1, 2, 3],
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.array([[5, 1, 3], [2, 1, 3]], dtype=np.int64)
+        expected = np.array(
+            [[[0, 0, 0], [1, 0, 0], [0, 0, 1]], [[0, 1, 0], [1, 0, 0], [0, 0, 1]]],
+            dtype=np.float32,
+        )
+        self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert expected.tolist() == got.tolist()
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_one_hot_encoder_string(self):
+        X = make_tensor_value_info("X", TensorProto.STRING, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None])
+        node1 = make_node(
+            "OneHotEncoder",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            zeros=1,
+            cats_strings=["c1", "c2", "c3"],
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.array([["c5", "c1", "c3"], ["c2", "c1", "c3"]])
+        expected = np.array(
+            [[[0, 0, 0], [1, 0, 0], [0, 0, 1]], [[0, 1, 0], [1, 0, 0], [0, 0, 1]]],
+            dtype=np.float32,
+        )
+        self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert expected.tolist() == got.tolist()
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_one_hot_encoder_zeros(self):
+        X = make_tensor_value_info("X", TensorProto.INT64, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None])
+        node1 = make_node(
+            "OneHotEncoder",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            zeros=0,
+            cats_int64s=[1, 2, 3],
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.array([[2, 1, 3], [2, 1, 3]], dtype=np.int64)
+        expected = np.array(
+            [[[0, 1, 0], [1, 0, 0], [0, 0, 1]], [[0, 1, 0], [1, 0, 0], [0, 0, 1]]],
+            dtype=np.float32,
+        )
+        self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})[0]
+        assert expected.tolist() == got.tolist()
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_linear_regressor(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node(
+            "LinearRegressor",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            coefficients=[0.3, -0.77],
+            intercepts=[0.5],
+            post_transform="NONE",
+            targets=1,
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.arange(6).reshape((-1, 2)).astype(np.float32)
+        expected = np.array([[-0.27], [-1.21], [-2.15]], dtype=np.float32)
+        self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[0], expected, atol=1e-6)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_linear_regressor_2(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node(
+            "LinearRegressor",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            coefficients=[0.3, -0.77, 0.3, -0.77],
+            intercepts=[0.5, 0.7],
+            post_transform="NONE",
+            targets=2,
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.arange(6).reshape((-1, 2)).astype(np.float32)
+        expected = np.array(
+            [[-0.27, -0.07], [-1.21, -1.01], [-2.15, -1.95]], dtype=np.float32
+        )
+        self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[0], expected, atol=1e-6)
+
+    @pytest.mark.parametrize(
+        "post", ["SOFTMAX", "NONE", "LOGISTIC", "SOFTMAX_ZERO", "PROBIT"]
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_linear_classifier_multi(self, post):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        In = make_tensor_value_info("I", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        expected_post = {
+            "NONE": [
+                np.array([0, 2, 2], dtype=np.int64),
+                np.array(
+                    [[2.41, -2.12, 0.59], [0.67, -1.14, 1.35], [-1.07, -0.16, 2.11]],
+                    dtype=np.float32,
+                ),
+            ],
+            "LOGISTIC": [
+                np.array([0, 2, 2], dtype=np.int64),
+                np.array(
+                    [
+                        [0.917587, 0.107168, 0.643365],
+                        [0.661503, 0.24232, 0.79413],
+                        [0.255403, 0.460085, 0.891871],
+                    ],
+                    dtype=np.float32,
+                ),
+            ],
+            "SOFTMAX": [
+                np.array([0, 2, 2], dtype=np.int64),
+                np.array(
+                    [
+                        [0.852656, 0.009192, 0.138152],
+                        [0.318722, 0.05216, 0.629118],
+                        [0.036323, 0.090237, 0.87344],
+                    ],
+                    dtype=np.float32,
+                ),
+            ],
+            "SOFTMAX_ZERO": [
+                np.array([0, 2, 2], dtype=np.int64),
+                np.array(
+                    [
+                        [0.852656, 0.009192, 0.138152],
+                        [0.318722, 0.05216, 0.629118],
+                        [0.036323, 0.090237, 0.87344],
+                    ],
+                    dtype=np.float32,
+                ),
+            ],
+            "PROBIT": [
+                np.array([1, 1, 1], dtype=np.int64),
+                np.array(
+                    [
+                        [-0.527324, -0.445471, -1.080504],
+                        [-0.067731, 0.316014, -0.310748],
+                        [0.377252, 1.405167, 0.295001],
+                    ],
+                    dtype=np.float32,
+                ),
+            ],
+        }
+        if post == "PROBIT":
+            coefficients = [0.058, 0.029, 0.09, 0.058, 0.029, 0.09]
+            intercepts = [0.27, 0.27, 0.05]
+        else:
+            coefficients = [-0.58, -0.29, -0.09, 0.58, 0.29, 0.09]
+            intercepts = [2.7, -2.7, 0.5]
+        node1 = make_node(
+            "LinearClassifier",
+            ["X"],
+            ["I", "Y"],
+            domain="ai.onnx.ml",
+            classlabels_ints=[0, 1, 2],
+            coefficients=coefficients,
+            intercepts=intercepts,
+            multi_class=0,
+            post_transform=post,
+        )
+        graph = make_graph([node1], "ml", [X], [In, Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        x = np.arange(6).reshape((-1, 2)).astype(np.float32)
+        self._check_ort(model, {"X": x}, rev=True, atol=1e-4)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        expected = expected_post[post]
+        assert_allclose(got[1], expected[1], atol=1e-4)
+        assert_allclose(got[0], expected[0])
+
+    @pytest.mark.parametrize("post", ["SOFTMAX", "NONE", "LOGISTIC", "SOFTMAX_ZERO"])
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_linear_classifier_binary(self, post):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        In = make_tensor_value_info("I", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        expected_post = {
+            "NONE": [
+                np.array([1, 1], dtype=np.int64),
+                np.array([[-9.53, 9.53], [-6.65, 6.65]], dtype=np.float32),
+            ],
+            "LOGISTIC": [
+                np.array([1, 1], dtype=np.int64),
+                np.array(
+                    [[7.263436e-05, 9.999274e-01], [1.292350e-03, 9.987077e-01]],
+                    dtype=np.float32,
+                ),
+            ],
+            "SOFTMAX": [
+                np.array([1, 1], dtype=np.int64),
+                np.array(
+                    [[5.276517e-09, 1.000000e00], [1.674492e-06, 9.999983e-01]],
+                    dtype=np.float32,
+                ),
+            ],
+            "SOFTMAX_ZERO": [
+                np.array([1, 1], dtype=np.int64),
+                np.array(
+                    [[5.276517e-09, 1.000000e00], [1.674492e-06, 9.999983e-01]],
+                    dtype=np.float32,
+                ),
+            ],
+        }
+        x = np.arange(6).reshape((-1, 3)).astype(np.float32)
+        expected = expected_post[post]
+        node1 = make_node(
+            "LinearClassifier",
+            ["X"],
+            ["I", "Y"],
+            domain="ai.onnx.ml",
+            classlabels_ints=[0, 1],
+            coefficients=[-0.58, -0.29, -0.09],
+            intercepts=[10.0],
+            multi_class=0,
+            post_transform=post,
+        )
+        graph = make_graph([node1], "ml", [X], [In, Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        # onnxruntime answer seems odd.
+        # self._check_ort(model, {"X": x}, rev=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[1], expected[1], atol=1e-6)
+        assert_allclose(got[0], expected[0])
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                (
+                    np.array([1, 0], dtype=np.int64),
+                    np.array([[2.23], [-0.65]], dtype=np.float32),
+                ),
+            ),
+            (
+                "LOGISTIC",
+                (
+                    np.array([1, 0], dtype=np.int64),
+                    np.array([[0.902911], [0.34299]], dtype=np.float32),
+                ),
+            ),
+            (
+                "SOFTMAX",
+                (
+                    np.array([1, 1], dtype=np.int64),
+                    np.array([[1.0], [1.0]], dtype=np.float32),
+                ),
+            ),
+            (
+                "SOFTMAX_ZERO",
+                (
+                    np.array([1, 1], dtype=np.int64),
+                    np.array([[1.0], [1.0]], dtype=np.float32),
+                ),
+            ),
+        ],
+    )
+    def test_linear_classifier_unary(self, post, expected):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        In = make_tensor_value_info("I", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        x = np.arange(6).reshape((-1, 3)).astype(np.float32)
+        node1 = make_node(
+            "LinearClassifier",
+            ["X"],
+            ["I", "Y"],
+            domain="ai.onnx.ml",
+            classlabels_ints=[1],
+            coefficients=[-0.58, -0.29, -0.09],
+            intercepts=[2.7],
+            multi_class=0,
+            post_transform=post,
+        )
+        graph = make_graph([node1], "ml", [X], [In, Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        # onnxruntime answer seems odd.
+        # self._check_ort(model, {"X": x}, rev=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[1], expected[1], atol=1e-6)
+        assert_allclose(got[0], expected[0])
+
+    @staticmethod
+    def _get_test_tree_ensemble_opset_latest(
+        aggregate_function,
+        rule=Mode.LEQ,
+        unique_targets=False,
+        input_type=TensorProto.FLOAT,
+    ):
+        X = make_tensor_value_info("X", input_type, [None, None])
+        Y = make_tensor_value_info("Y", input_type, [None, None])
+        if unique_targets:
+            weights = [
+                1.0,
+                10.0,
+                100.0,
+                1000.0,
+                10000.0,
+                100000.0,
+            ]
+        else:
+            weights = [
+                0.07692307978868484,
+                0.5,
+                0.5,
+                0.0,
+                0.2857142984867096,
+                0.5,
+            ]
+        node = make_node(
+            "TreeEnsemble",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            n_targets=1,
+            aggregate_function=aggregate_function,
+            membership_values=None,
+            nodes_missing_value_tracks_true=None,
+            nodes_hitrates=None,
+            post_transform=0,
+            tree_roots=[0, 2],
+            nodes_splits=make_tensor(
+                "node_splits",
+                input_type,
+                (4,),
+                [
+                    0.26645058393478394,
+                    0.6214364767074585,
+                    -0.5592705607414246,
+                    -0.7208403944969177,
+                ],
+            ),
+            nodes_featureids=[0, 2, 0, 0],
+            nodes_modes=make_tensor(
+                "nodes_modes",
+                TensorProto.UINT8,
+                (4,),
+                [rule] * 4,
+            ),
+            nodes_truenodeids=[1, 0, 3, 4],
+            nodes_trueleafs=[0, 1, 1, 1],
+            nodes_falsenodeids=[2, 1, 3, 5],
+            nodes_falseleafs=[1, 1, 0, 1],
+            leaf_targetids=[0, 0, 0, 0, 0, 0],
+            leaf_weights=make_tensor(
+                "leaf_weights", input_type, (len(weights),), weights
+            ),
+        )
+        graph = make_graph([node], "ml", [X], [Y])
+        return make_model_gen_version(graph, opset_imports=OPSETS)
+
+    @staticmethod
+    def _get_test_tree_ensemble_regressor(
+        aggregate_function, rule="BRANCH_LEQ", unique_targets=False, base_values=None
+    ):
+        opsets = [make_opsetid("", TARGET_OPSET), make_opsetid("ai.onnx.ml", 3)]
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        if unique_targets:
+            targets = [
+                1.0,
+                10.0,
+                100.0,
+                1000.0,
+                10000.0,
+                100000.0,
+            ]
+        else:
+            targets = [
+                0.07692307978868484,
+                0.5,
+                0.5,
+                0.0,
+                0.2857142984867096,
+                0.5,
+            ]
+        node1 = make_node(
+            "TreeEnsembleRegressor",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            n_targets=1,
+            aggregate_function=aggregate_function,
+            base_values=base_values,
+            nodes_falsenodeids=[4, 3, 0, 0, 0, 2, 0, 4, 0, 0],
+            nodes_featureids=[0, 2, 0, 0, 0, 0, 0, 2, 0, 0],
+            nodes_hitrates=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            nodes_missing_value_tracks_true=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            nodes_modes=[
+                rule,
+                rule,
+                "LEAF",
+                "LEAF",
+                "LEAF",
+                rule,
+                "LEAF",
+                rule,
+                "LEAF",
+                "LEAF",
+            ],
+            nodes_nodeids=[0, 1, 2, 3, 4, 0, 1, 2, 3, 4],
+            nodes_treeids=[0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
+            nodes_truenodeids=[1, 2, 0, 0, 0, 1, 0, 3, 0, 0],
+            nodes_values=[
+                0.26645058393478394,
+                0.6214364767074585,
+                0.0,
+                0.0,
+                0.0,
+                -0.7208403944969177,
+                0.0,
+                -0.5592705607414246,
+                0.0,
+                0.0,
+            ],
+            post_transform="NONE",
+            target_ids=[0, 0, 0, 0, 0, 0],
+            target_nodeids=[2, 3, 4, 1, 3, 4],
+            target_treeids=[0, 0, 0, 1, 1, 1],
+            target_weights=targets,
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=opsets)
+        onnx.checker.check_model(model)
+        return model
+
+    @pytest.mark.parametrize(
+        "aggregate_function, expected_result, opset5",
+        tuple(
+            itertools.chain.from_iterable(
+                (
+                    (
+                        AggregationFunction.SUM if opset5 else "SUM",
+                        np.array(
+                            [[0.576923], [0.576923], [0.576923]], dtype=np.float32
+                        ),
+                        opset5,
+                    ),
+                    (
+                        AggregationFunction.AVERAGE if opset5 else "AVERAGE",
+                        np.array(
+                            [[0.288462], [0.288462], [0.288462]], dtype=np.float32
+                        ),
+                        opset5,
+                    ),
+                    (
+                        AggregationFunction.MIN if opset5 else "MIN",
+                        np.array(
+                            [[0.076923], [0.076923], [0.076923]], dtype=np.float32
+                        ),
+                        opset5,
+                    ),
+                    (
+                        AggregationFunction.MAX if opset5 else "MAX",
+                        np.array([[0.5], [0.5], [0.5]], dtype=np.float32),
+                        opset5,
+                    ),
+                )
+                for opset5 in [True, False]
+            )
+        ),
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_tree_ensemble_regressor_aggregation_functions(
+        self, aggregate_function, expected_result, opset5
+    ):
+        x = np.arange(9).reshape((-1, 3)).astype(np.float32) / 10 - 0.5
+        model_factory = (
+            self._get_test_tree_ensemble_opset_latest
+            if opset5
+            else self._get_test_tree_ensemble_regressor
+        )
+        model_proto = model_factory(
+            aggregate_function,
+        )
+        sess = ReferenceEvaluator(model_proto)
+        (actual,) = sess.run(None, {"X": x})
+        assert_allclose(actual, expected_result, atol=1e-6)
+
+    @pytest.mark.parametrize(
+        "rule, expected, opset5",
+        tuple(
+            itertools.chain.from_iterable(
+                (
+                    (
+                        Mode.LEQ if opset5 else "BRANCH_LEQ",
+                        np.array(
+                            [[0.576923], [0.576923], [0.576923]], dtype=np.float32
+                        ),
+                        opset5,
+                    ),
+                    (
+                        Mode.GT if opset5 else "BRANCH_GT",
+                        np.array([[0.5], [0.5], [0.5]], dtype=np.float32),
+                        opset5,
+                    ),
+                    (
+                        Mode.LT if opset5 else "BRANCH_LT",
+                        np.array(
+                            [[0.576923], [0.576923], [0.576923]], dtype=np.float32
+                        ),
+                        opset5,
+                    ),
+                    (
+                        Mode.GTE if opset5 else "BRANCH_GTE",
+                        np.array([[0.5], [0.5], [0.5]], dtype=np.float32),
+                        opset5,
+                    ),
+                    (
+                        Mode.EQ if opset5 else "BRANCH_EQ",
+                        np.array([[1.0], [1.0], [1.0]], dtype=np.float32),
+                        opset5,
+                    ),
+                    (
+                        Mode.NEQ if opset5 else "BRANCH_NEQ",
+                        np.array(
+                            [[0.076923], [0.076923], [0.076923]], dtype=np.float32
+                        ),
+                        opset5,
+                    ),
+                )
+                for opset5 in [True, False]
+            )
+        ),
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_tree_ensemble_regressor_rule(self, rule, expected, opset5):
+        x = np.arange(9).reshape((-1, 3)).astype(np.float32) / 10 - 0.5
+        model_factory = (
+            self._get_test_tree_ensemble_opset_latest
+            if opset5
+            else self._get_test_tree_ensemble_regressor
+        )
+        aggregate_function = AggregationFunction.SUM if opset5 else "SUM"
+
+        model_proto = model_factory(aggregate_function, rule)
+        sess = ReferenceEvaluator(model_proto)
+        (actual,) = sess.run(None, {"X": x})
+        assert_allclose(actual, expected, atol=1e-6)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_tree_ensemble_regressor_2_targets_opset3(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        opsets = [make_opsetid("", TARGET_OPSET), make_opsetid("ai.onnx.ml", 3)]
+        node1 = make_node(
+            "TreeEnsembleRegressor",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            n_targets=2,
+            nodes_falsenodeids=[4, 3, 0, 0, 6, 0, 0, 4, 3, 0, 0, 6, 0, 0],
+            nodes_featureids=[0, 2, 0, 0, 2, 0, 0, 0, 1, 0, 0, 2, 0, 0],
+            nodes_hitrates=[
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+            ],
+            nodes_missing_value_tracks_true=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            nodes_modes=[
+                "BRANCH_LEQ",
+                "BRANCH_LEQ",
+                "LEAF",
+                "LEAF",
+                "BRANCH_LEQ",
+                "LEAF",
+                "LEAF",
+                "BRANCH_LEQ",
+                "BRANCH_LEQ",
+                "LEAF",
+                "LEAF",
+                "BRANCH_LEQ",
+                "LEAF",
+                "LEAF",
+            ],
+            nodes_nodeids=[0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6],
+            nodes_treeids=[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
+            nodes_truenodeids=[1, 2, 0, 0, 5, 0, 0, 1, 2, 0, 0, 5, 0, 0],
+            nodes_values=[
+                -0.3367232382297516,
+                1.5326381921768188,
+                0.0,
+                0.0,
+                -0.24646544456481934,
+                0.0,
+                0.0,
+                -0.3367232382297516,
+                0.6671845316886902,
+                0.0,
+                0.0,
+                -0.24646544456481934,
+                0.0,
+                0.0,
+            ],
+            post_transform="NONE",
+            target_ids=[0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
+            target_nodeids=[2, 2, 3, 3, 5, 5, 6, 6, 2, 2, 3, 3, 5, 5, 6, 6],
+            target_treeids=[0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
+            target_weights=[
+                0.0,
+                2.5,
+                0.5,
+                3.0,
+                0.15000000596046448,
+                2.6500000953674316,
+                0.5,
+                3.0,
+                0.02777777798473835,
+                2.527777671813965,
+                0.5,
+                3.0,
+                0.20000000298023224,
+                2.700000047683716,
+                0.5,
+                3.0,
+            ],
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=opsets)
+        onnx.checker.check_model(model)
+        x = np.arange(9).reshape((-1, 3)).astype(np.float32) / 10 - 0.5
+        expected = np.array(
+            [[0.027778, 5.027778], [1.0, 6.0], [1.0, 6.0]], dtype=np.float32
+        )
+        self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[0], expected, atol=1e-6)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_tree_ensemble_regressor_missing_opset3(self):
+        x = np.arange(9).reshape((-1, 3)).astype(np.float32) / 10 - 0.5
+        x[2, 0] = 5
+        x[1, :] = np.nan
+        expected = np.array([[100001.0], [100100.0], [100100.0]], dtype=np.float32)
+        model = self._get_test_tree_ensemble_regressor("SUM", unique_targets=True)
+        self._check_ort(model, {"X": x}, equal=True)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[0], expected, atol=1e-6)
+        assert "op_type=TreeEnsembleRegressor" in str(sess.rt_nodes_[0])
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    @pytest.mark.parametrize("input_type", [TensorProto.FLOAT, TensorProto.DOUBLE])
+    def test_tree_ensemble_missing_opset5(self, input_type):
+        model = self._get_test_tree_ensemble_opset_latest(
+            AggregationFunction.SUM, Mode.LEQ, True, input_type
+        )
+        np_dtype = onnx.helper.tensor_dtype_to_np_dtype(input_type)
+        x = np.arange(9).reshape((-1, 3)).astype(np_dtype) / 10 - 0.5
+        x[2, 0] = 5
+        x[1, :] = np.nan
+        expected = np.array([[100001.0], [100100.0], [100100.0]], dtype=np_dtype)
+        session = ReferenceEvaluator(model)
+        (actual,) = session.run(None, {"X": x})
+        assert_allclose(actual, expected, atol=1e-6)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_tree_ensemble_regressor_missing_opset5_float16(self):
+        model = self._get_test_tree_ensemble_opset_latest(
+            AggregationFunction.SUM, Mode.LEQ, False, TensorProto.FLOAT16
+        )
+        np_dtype = np.float16
+        x = np.arange(9).reshape((-1, 3)).astype(np_dtype) / 10 - 0.5
+        x[2, 0] = 5
+        x[1, :] = np.nan
+        expected = np.array([[0.577], [1.0], [1.0]], dtype=np_dtype)
+        session = ReferenceEvaluator(model)
+        (actual,) = session.run(None, {"X": x})
+        assert_allclose(actual, expected, atol=1e-6)
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_single_tree_ensemble(self):
+        X = make_tensor_value_info("X", TensorProto.DOUBLE, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.DOUBLE, [None, None])
+        node = make_node(
+            "TreeEnsemble",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            n_targets=2,
+            membership_values=None,
+            nodes_missing_value_tracks_true=None,
+            nodes_hitrates=None,
+            aggregate_function=1,
+            post_transform=PostTransform.NONE,
+            tree_roots=[0],
+            nodes_modes=make_tensor(
+                "nodes_modes",
+                TensorProto.UINT8,
+                (3,),
+                [Mode.LEQ] * 3,
+            ),
+            nodes_featureids=[0, 0, 0],
+            nodes_splits=make_tensor(
+                "nodes_splits",
+                TensorProto.DOUBLE,
+                (3,),
+                np.array([3.14, 1.2, 4.2], dtype=np.float64),
+            ),
+            nodes_truenodeids=[1, 0, 1],
+            nodes_trueleafs=[0, 1, 1],
+            nodes_falsenodeids=[2, 2, 3],
+            nodes_falseleafs=[0, 1, 1],
+            leaf_targetids=[0, 1, 0, 1],
+            leaf_weights=make_tensor(
+                "leaf_weights",
+                TensorProto.DOUBLE,
+                (4,),
+                np.array([5.23, 12.12, -12.23, 7.21], dtype=np.float64),
+            ),
+        )
+        graph = make_graph([node], "ml", [X], [Y])
+        model = make_model_gen_version(
+            graph,
+            opset_imports=[
+                make_opsetid("", TARGET_OPSET),
+                make_opsetid("ai.onnx.ml", 5),
+            ],
+        )
+        onnx.checker.check_model(model)
+        session = ReferenceEvaluator(model)
+        (output,) = session.run(
+            None,
+            {
+                "X": np.array([1.2, 3.4, -0.12, 1.66, 4.14, 1.77], np.float64).reshape(
+                    3, 2
+                )
+            },
+        )
+        np.testing.assert_equal(
+            output, np.array([[5.23, 0], [5.23, 0], [0, 12.12]], dtype=np.float64)
+        )
+
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_tree_ensemble_regressor_set_membership_opset5(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node = make_node(
+            "TreeEnsemble",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            n_targets=4,
+            aggregate_function=AggregationFunction.SUM,
+            membership_values=make_tensor(
+                "membership_values",
+                TensorProto.FLOAT,
+                (8,),
+                [1.2, 3.7, 8, 9, np.nan, 12, 7, np.nan],
+            ),
+            nodes_missing_value_tracks_true=None,
+            nodes_hitrates=None,
+            post_transform=PostTransform.NONE,
+            tree_roots=[0],
+            nodes_modes=make_tensor(
+                "nodes_modes",
+                TensorProto.UINT8,
+                (3,),
+                [Mode.LEQ, Mode.MEMBER, Mode.MEMBER],
+            ),
+            nodes_featureids=[0, 0, 0],
+            nodes_splits=make_tensor(
+                "nodes_splits",
+                TensorProto.FLOAT,
+                (3,),
+                np.array([11, 232344.0, np.nan], dtype=np.float32),
+            ),
+            nodes_trueleafs=[0, 1, 1],
+            nodes_truenodeids=[1, 0, 1],
+            nodes_falseleafs=[1, 0, 1],
+            nodes_falsenodeids=[2, 2, 3],
+            leaf_targetids=[0, 1, 2, 3],
+            leaf_weights=make_tensor(
+                "leaf_weights", TensorProto.FLOAT, (4,), [1, 10, 1000, 100]
+            ),
+        )
+        graph = make_graph([node], "ml", [X], [Y])
+        model = make_model_gen_version(
+            graph,
+            opset_imports=OPSETS,
+        )
+        onnx.checker.check_model(model)
+        session = ReferenceEvaluator(model)
+        X = np.array([1.2, 3.4, -0.12, np.nan, 12, 7], np.float32).reshape(-1, 1)
+        expected = np.array(
+            [
+                [1, 0, 0, 0],
+                [0, 0, 0, 100],
+                [0, 0, 0, 100],
+                [0, 0, 1000, 0],
+                [0, 0, 1000, 0],
+                [0, 10, 0, 0],
+            ],
+            dtype=np.float32,
+        )
+        (output,) = session.run(None, {"X": X})
+        np.testing.assert_equal(output, expected)
+
+    @staticmethod
+    def _get_test_svm_regressor(kernel_type, kernel_params):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node(
+            "SVMRegressor",
+            ["X"],
+            ["Y"],
+            domain="ai.onnx.ml",
+            coefficients=[
+                1.0,
+                -1.0,
+                0.8386201858520508,
+                -0.8386201858520508,
+                0.4470679759979248,
+                -1.0,
+                0.5529320240020752,
+            ],
+            kernel_params=kernel_params,
+            kernel_type=kernel_type,
+            n_supports=7,
+            post_transform="NONE",
+            rho=[0.5460880398750305],
+            support_vectors=[
+                -0.12850627303123474,
+                0.08915442228317261,
+                0.06881910562515259,
+                -0.07938569784164429,
+                -0.22557435929775238,
+                -0.26520243287086487,
+                0.9246066212654114,
+                -0.025557516142725945,
+                -0.5900523662567139,
+                0.9735698699951172,
+                -1.3385062217712402,
+                0.3393094539642334,
+                0.9432410001754761,
+                -0.5228781700134277,
+                0.5557093620300293,
+                0.4191802740097046,
+                0.43368014693260193,
+                -1.0569839477539062,
+                2.3318440914154053,
+                0.06202844902873039,
+                -0.9502395987510681,
+            ],
+        )
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        return model
+
+    @pytest.mark.parametrize(
+        "kernel, params, expected",
+        [
+            (
+                "LINEAR",
+                [0.42438405752182007, 0.0, 3.0],
+                np.array([[-0.468206], [0.227487], [0.92318]], dtype=np.float32),
+            ),
+            (
+                "POLY",
+                [0.3426632285118103, 0.0, 3.0],
+                np.array([[0.527084], [0.543578], [0.546506]], dtype=np.float32),
+            ),
+            (
+                "RBF",
+                [0.30286383628845215, 0.0, 3.0],
+                np.array([[0.295655], [0.477876], [0.695292]], dtype=np.float32),
+            ),
+            (
+                "SIGMOID",
+                [0.30682486295700073, 0.0, 3.0],
+                np.array([[0.239304], [0.448929], [0.661689]], dtype=np.float32),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_svm_regressor(self, kernel, params, expected):
+        x = np.arange(9).reshape((-1, 3)).astype(np.float32) / 10 - 0.5
+
+        model = self._get_test_svm_regressor(kernel, params)
+        self._check_ort(model, {"X": x}, atol=1e-6)
+        sess = ReferenceEvaluator(model)
+        (got,) = sess.run(None, {"X": x})
+        assert_allclose(got, expected, atol=1e-6)
+
+    @staticmethod
+    def _get_test_tree_ensemble_classifier_binary(post_transform):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        In = make_tensor_value_info("I", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node(
+            "TreeEnsembleClassifier",
+            ["X"],
+            ["I", "Y"],
+            domain="ai.onnx.ml",
+            class_ids=[0, 0, 0, 0, 0, 0, 0],
+            class_nodeids=[2, 3, 5, 6, 1, 3, 4],
+            class_treeids=[0, 0, 0, 0, 1, 1, 1],
+            class_weights=[
+                0.0,
+                0.1764705926179886,
+                0.0,
+                0.5,
+                0.0,
+                0.0,
+                0.4285714328289032,
+            ],
+            classlabels_int64s=[0, 1],
+            nodes_falsenodeids=[4, 3, 0, 0, 6, 0, 0, 2, 0, 4, 0, 0],
+            nodes_featureids=[2, 2, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0],
+            nodes_hitrates=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            nodes_missing_value_tracks_true=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            nodes_modes=[
+                "BRANCH_LEQ",
+                "BRANCH_LEQ",
+                "LEAF",
+                "LEAF",
+                "BRANCH_LEQ",
+                "LEAF",
+                "LEAF",
+                "BRANCH_LEQ",
+                "LEAF",
+                "BRANCH_LEQ",
+                "LEAF",
+                "LEAF",
+            ],
+            nodes_nodeids=[0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4],
+            nodes_treeids=[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
+            nodes_truenodeids=[1, 2, 0, 0, 5, 0, 0, 1, 0, 3, 0, 0],
+            nodes_values=[
+                0.6874135732650757,
+                -0.3654803931713104,
+                0.0,
+                0.0,
+                -1.926770806312561,
+                0.0,
+                0.0,
+                -0.3654803931713104,
+                0.0,
+                -2.0783839225769043,
+                0.0,
+                0.0,
+            ],
+            post_transform=post_transform,
+        )
+        graph = make_graph([node1], "ml", [X], [In, Y])
+        model = make_model_gen_version(
+            graph,
+            opset_imports=[
+                make_opsetid("", TARGET_OPSET),
+                make_opsetid("ai.onnx.ml", 3),
+            ],
+        )
+        onnx.checker.check_model(model)
+        return model
+
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [[1.0, 0.0], [0.394958, 0.605042], [0.394958, 0.605042]],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "LOGISTIC",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [[0.5, 0.5], [0.353191, 0.646809], [0.353191, 0.646809]],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [[0.5, 0.5], [0.229686, 0.770314], [0.229686, 0.770314]],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX_ZERO",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [[0.5, 0.5], [0.229686, 0.770314], [0.229686, 0.770314]],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "PROBIT",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [[0.0, 0.0], [-0.266426, 0.266426], [-0.266426, 0.266426]],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_tree_ensemble_classifier_binary(self, post, expected):
+        x = (np.arange(9).reshape((-1, 3)) - 5).astype(np.float32) / 5
+        model = self._get_test_tree_ensemble_classifier_binary(post)
+        if post == "NONE":
+            self._check_ort(model, {"X": x})
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[1], expected[1], atol=1e-6)
+        assert_allclose(got[0], expected[0])
+
+    @staticmethod
+    def _get_test_tree_ensemble_classifier_multi(post_transform):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        In = make_tensor_value_info("I", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node(
+            "TreeEnsembleClassifier",
+            ["X"],
+            ["I", "Y"],
+            domain="ai.onnx.ml",
+            class_ids=[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2],
+            class_nodeids=[2, 2, 2, 3, 3, 3, 4, 4, 4, 1, 1, 1, 3, 3, 3, 4, 4, 4],
+            class_treeids=[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+            class_weights=[
+                0.46666666865348816,
+                0.0,
+                0.03333333507180214,
+                0.20000000298023224,
+                0.23999999463558197,
+                0.05999999865889549,
+                0.0,
+                0.5,
+                0.0,
+                0.5,
+                0.0,
+                0.0,
+                0.44999998807907104,
+                0.0,
+                0.05000000074505806,
+                0.10294117778539658,
+                0.19117647409439087,
+                0.20588235557079315,
+            ],
+            classlabels_int64s=[0, 1, 2],
+            nodes_falsenodeids=[4, 3, 0, 0, 0, 2, 0, 4, 0, 0],
+            nodes_featureids=[1, 0, 0, 0, 0, 1, 0, 0, 0, 0],
+            nodes_hitrates=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+            nodes_missing_value_tracks_true=[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            nodes_modes=[
+                "BRANCH_LEQ",
+                "BRANCH_LEQ",
+                "LEAF",
+                "LEAF",
+                "LEAF",
+                "BRANCH_LEQ",
+                "LEAF",
+                "BRANCH_LEQ",
+                "LEAF",
+                "LEAF",
+            ],
+            nodes_nodeids=[0, 1, 2, 3, 4, 0, 1, 2, 3, 4],
+            nodes_treeids=[0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
+            nodes_truenodeids=[1, 2, 0, 0, 0, 1, 0, 3, 0, 0],
+            nodes_values=[
+                1.2495747804641724,
+                -0.3050493597984314,
+                0.0,
+                0.0,
+                0.0,
+                -1.6830512285232544,
+                0.0,
+                -0.6751254796981812,
+                0.0,
+                0.0,
+            ],
+            post_transform=post_transform,
+        )
+        graph = make_graph([node1], "ml", [X], [In, Y])
+        model = make_model_gen_version(
+            graph,
+            opset_imports=[
+                make_opsetid("", TARGET_OPSET),
+                make_opsetid("ai.onnx.ml", 3),
+            ],
+        )
+        onnx.checker.check_model(model)
+        return model
+
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                (
+                    np.array([0, 0, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.916667, 0.0, 0.083333],
+                            [0.569608, 0.191176, 0.239216],
+                            [0.302941, 0.431176, 0.265882],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "LOGISTIC",
+                (
+                    np.array([0, 0, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.714362, 0.5, 0.520821],
+                            [0.638673, 0.547649, 0.55952],
+                            [0.575161, 0.606155, 0.566082],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX",
+                (
+                    np.array([0, 0, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.545123, 0.217967, 0.23691],
+                            [0.416047, 0.284965, 0.298988],
+                            [0.322535, 0.366664, 0.310801],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX_ZERO",
+                (
+                    np.array([0, 0, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.697059, 0.0, 0.302941],
+                            [0.416047, 0.284965, 0.298988],
+                            [0.322535, 0.366664, 0.310801],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "PROBIT",
+                (
+                    np.array([0, 0, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [1.383104, 0, -1.383105],
+                            [0.175378, -0.873713, -0.708922],
+                            [-0.516003, -0.173382, -0.625385],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_tree_ensemble_classifier_multi(self, post, expected):
+        x = (np.arange(9).reshape((-1, 3)) - 5).astype(np.float32) / 5
+        model = self._get_test_tree_ensemble_classifier_multi(post)
+        if post != "PROBIT":
+            self._check_ort(model, {"X": x}, atol=1e-5)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[1], expected[1], atol=1e-6)
+        assert_allclose(got[0], expected[0])
+
+    @staticmethod
+    def _get_test_svm_classifier_binary(post_transform, probability=True, linear=False):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        In = make_tensor_value_info("I", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        if linear:
+            kwargs = {
+                "classlabels_ints": [0, 1, 2, 3],
+                "coefficients": [
+                    -1.55181212e-01,
+                    2.42698956e-01,
+                    7.01893432e-03,
+                    4.07614474e-01,
+                    -3.24927823e-02,
+                    2.79897536e-04,
+                    -1.95771302e-01,
+                    -3.52437368e-01,
+                    -2.15973096e-02,
+                    -4.38190277e-01,
+                    4.56869105e-02,
+                    -1.29375499e-02,
+                ],
+                "kernel_params": [0.001, 0.0, 3.0],
+                "kernel_type": "LINEAR",
+                "prob_a": [-5.139118194580078],
+                "prob_b": [0.06399919837713242],
+                "rho": [-0.07489691, -0.1764396, -0.21167431, -0.51619097],
+                "post_transform": post_transform,
+            }
+        else:
+            kwargs = {
+                "classlabels_ints": [0, 1],
+                "coefficients": [1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0],
+                "kernel_params": [0.3824487328529358, 0.0, 3.0],
+                "kernel_type": "RBF",
+                "prob_a": [-5.139118194580078],
+                "prob_b": [0.06399919837713242],
+                "rho": [0.16708599030971527],
+                "support_vectors": [
+                    0.19125767052173615,
+                    -1.062204122543335,
+                    0.5006636381149292,
+                    -0.5892484784126282,
+                    -0.3196830451488495,
+                    0.0984845906496048,
+                    0.24746321141719818,
+                    -1.1535362005233765,
+                    0.4109955430030823,
+                    -0.5937694907188416,
+                    -1.3183348178863525,
+                    -1.6423596143722534,
+                    0.558641254901886,
+                    -0.9218668341636658,
+                    0.6264089345932007,
+                    -0.16060839593410492,
+                    -0.6365169882774353,
+                    0.8335472345352173,
+                    0.7539799213409424,
+                    -0.3970031440258026,
+                    -0.1780400276184082,
+                    -0.616622805595398,
+                    0.49261474609375,
+                    0.4470972716808319,
+                ],
+                "vectors_per_class": [4, 4],
+                "post_transform": post_transform,
+            }
+
+        if not probability:
+            del kwargs["prob_a"]
+            del kwargs["prob_b"]
+        node1 = make_node(
+            "SVMClassifier", ["X"], ["I", "Y"], domain="ai.onnx.ml", **kwargs
+        )
+        graph = make_graph([node1], "ml", [X], [In, Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        return model
+
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.993287, 0.006713],
+                            [0.469401, 0.530599],
+                            [0.014997, 0.985003],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "LOGISTIC",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.729737, 0.501678],
+                            [0.615242, 0.629623],
+                            [0.503749, 0.7281],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.728411, 0.271589],
+                            [0.484705, 0.515295],
+                            [0.274879, 0.725121],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX_ZERO",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.728411, 0.271589],
+                            [0.484705, 0.515295],
+                            [0.274879, 0.725121],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "PROBIT",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [2.469393, -2.469391],
+                            [-0.076776, 0.076776],
+                            [-2.16853, 2.16853],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_svm_classifier_binary(self, post, expected):
+        x = (np.arange(9).reshape((-1, 3)) - 5).astype(np.float32) / 5
+        model = self._get_test_svm_classifier_binary(post)
+        self._check_ort(model, {"X": x}, rev=True, atol=1e-5)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[1], expected[1], atol=1e-5)
+        assert_allclose(got[0], expected[0])
+
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [-0.986073, 0.986073],
+                            [0.011387, -0.011387],
+                            [0.801808, -0.801808],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "LOGISTIC",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.271688, 0.728312],
+                            [0.502847, 0.497153],
+                            [0.690361, 0.309639],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.122158, 0.877842],
+                            [0.505693, 0.494307],
+                            [0.832523, 0.167477],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX_ZERO",
+                (
+                    np.array([0, 1, 1], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.122158, 0.877842],
+                            [0.505693, 0.494307],
+                            [0.832523, 0.167477],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_svm_classifier_binary_noprob(self, post, expected):
+        x = (np.arange(9).reshape((-1, 3)) - 5).astype(np.float32) / 5
+        model = self._get_test_svm_classifier_binary(post, probability=False)
+        if post not in {"LOGISTIC", "SOFTMAX", "SOFTMAX_ZERO", "PROBIT"}:
+            self._check_ort(model, {"X": x}, rev=True, atol=1e-5)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[1], expected[1], atol=1e-6)
+        assert_allclose(got[0], expected[0])
+
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [-0.118086, -0.456685, 0.415783, 0.334506],
+                            [-0.061364, -0.231444, 0.073899, 0.091242],
+                            [-0.004642, -0.006203, -0.267985, -0.152023],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "LOGISTIC",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.470513, 0.387773, 0.602474, 0.582855],
+                            [0.484664, 0.442396, 0.518466, 0.522795],
+                            [0.498839, 0.498449, 0.433402, 0.462067],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.200374, 0.14282, 0.341741, 0.315065],
+                            [0.240772, 0.203115, 0.275645, 0.280467],
+                            [0.275491, 0.275061, 0.211709, 0.237739],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX_ZERO",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.200374, 0.14282, 0.341741, 0.315065],
+                            [0.240772, 0.203115, 0.275645, 0.280467],
+                            [0.275491, 0.275061, 0.211709, 0.237739],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "PROBIT",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [np.nan, np.nan, -0.212698, -0.427529],
+                            [np.nan, np.nan, -1.447414, -1.333286],
+                            [np.nan, np.nan, np.nan, np.nan],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_svm_classifier_noprob_linear(self, post, expected):
+        x = (np.arange(9).reshape((-1, 3)) - 5).astype(np.float32) / 5
+        model = self._get_test_svm_classifier_binary(
+            post, probability=False, linear=True
+        )
+        self._check_ort(model, {"X": x}, rev=True, atol=1e-5)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[1], expected[1], atol=1e-6)
+        assert_allclose(got[0], expected[0])
+
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [-0.118086, -0.456685, 0.415783, 0.334506],
+                            [-0.061364, -0.231444, 0.073899, 0.091242],
+                            [-0.004642, -0.006203, -0.267985, -0.152023],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "LOGISTIC",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.470513, 0.387773, 0.602474, 0.582855],
+                            [0.484664, 0.442396, 0.518466, 0.522795],
+                            [0.498839, 0.498449, 0.433402, 0.462067],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.200374, 0.14282, 0.341741, 0.315065],
+                            [0.240772, 0.203115, 0.275645, 0.280467],
+                            [0.275491, 0.275061, 0.211709, 0.237739],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX_ZERO",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.200374, 0.14282, 0.341741, 0.315065],
+                            [0.240772, 0.203115, 0.275645, 0.280467],
+                            [0.275491, 0.275061, 0.211709, 0.237739],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "PROBIT",
+                (
+                    np.array([2, 3, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [np.nan, np.nan, -0.212698, -0.427529],
+                            [np.nan, np.nan, -1.447414, -1.333286],
+                            [np.nan, np.nan, np.nan, np.nan],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_svm_classifier_linear(self, post, expected):
+        # prob_a, prob_b are not used in this case.
+        x = (np.arange(9).reshape((-1, 3)) - 5).astype(np.float32) / 5
+        model = self._get_test_svm_classifier_binary(
+            post, probability=True, linear=True
+        )
+        self._check_ort(model, {"X": x}, rev=True, atol=1e-5)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[1], expected[1], atol=1e-6)
+        assert_allclose(got[0], expected[0])
+
+    @staticmethod
+    def _get_test_svm_classifier_linear_sv(post_transform, probability=True):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        In = make_tensor_value_info("I", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        kwargs = {
+            "classlabels_ints": [0, 1],
+            "coefficients": [
+                0.766398549079895,
+                0.0871576070785522,
+                0.110420741140842,
+                -0.963976919651031,
+            ],
+            "support_vectors": [
+                4.80000019073486,
+                3.40000009536743,
+                1.89999997615814,
+                5.0,
+                3.0,
+                1.60000002384186,
+                4.5,
+                2.29999995231628,
+                1.29999995231628,
+                5.09999990463257,
+                2.5,
+                3.0,
+            ],
+            "kernel_params": [0.122462183237076, 0.0, 3.0],
+            "kernel_type": "LINEAR",
+            "prob_a": [-5.139118194580078],
+            "prob_b": [0.06399919837713242],
+            "rho": [2.23510527610779],
+            "post_transform": post_transform,
+            "vectors_per_class": [3, 1],
+        }
+
+        if not probability:
+            del kwargs["prob_a"]
+            del kwargs["prob_b"]
+        node1 = make_node(
+            "SVMClassifier", ["X"], ["I", "Y"], domain="ai.onnx.ml", **kwargs
+        )
+        graph = make_graph([node1], "ml", [X], [In, Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        return model
+
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                (
+                    np.array([0, 0, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [-2.662655, 2.662655],
+                            [-2.21481, 2.21481],
+                            [-1.766964, 1.766964],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "LOGISTIC",
+                (
+                    np.array([0, 0, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.065213, 0.934787],
+                            [0.098428, 0.901572],
+                            [0.14592, 0.85408],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX",
+                (
+                    np.array([0, 0, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.004843, 0.995157],
+                            [0.011779, 0.988221],
+                            [0.028362, 0.971638],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+            (
+                "SOFTMAX_ZERO",
+                (
+                    np.array([0, 0, 0], dtype=np.int64),
+                    np.array(
+                        [
+                            [0.004843, 0.995157],
+                            [0.011779, 0.988221],
+                            [0.028362, 0.971638],
+                        ],
+                        dtype=np.float32,
+                    ),
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_svm_classifier_binary_noprob_linear_sv(self, post, expected):
+        x = (np.arange(9).reshape((-1, 3)) - 5).astype(np.float32) / 5
+
+        model = self._get_test_svm_classifier_linear_sv(post, probability=False)
+        if post not in {"LOGISTIC", "SOFTMAX", "SOFTMAX_ZERO"}:
+            self._check_ort(model, {"X": x}, rev=True, atol=1e-5)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"X": x})
+        assert_allclose(got[1], expected[1], atol=1e-6)
+        assert_allclose(got[0], expected[0])
+
+    @staticmethod
+    def _get_test_svm_regressor_linear(post_transform, one_class=0):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        kwargs = {
+            "coefficients": [0.28290501, -0.0266512, 0.01674867],
+            "kernel_params": [0.001, 0.0, 3.0],
+            "kernel_type": "LINEAR",
+            "rho": [1.24032312],
+            "post_transform": post_transform,
+            "n_supports": 0,
+            "one_class": one_class,
+        }
+
+        node1 = make_node("SVMRegressor", ["X"], ["Y"], domain="ai.onnx.ml", **kwargs)
+        graph = make_graph([node1], "ml", [X], [Y])
+        model = make_model_gen_version(graph, opset_imports=OPSETS)
+        onnx.checker.check_model(model)
+        return model
+
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                np.array(
+                    [[0.96869], [1.132491], [1.296293]],
+                    dtype=np.float32,
+                ),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_svm_regressor_linear(self, post, expected):
+        x = (np.arange(9).reshape((-1, 3)) - 5).astype(np.float32) / 5
+        model = self._get_test_svm_regressor_linear(post)
+        self._check_ort(model, {"X": x}, rev=True, atol=1e-5)
+        sess = ReferenceEvaluator(model)
+        (got,) = sess.run(None, {"X": x})
+        assert_allclose(got, expected, atol=1e-6)
+
+    @pytest.mark.parametrize(
+        "post, expected",
+        [
+            (
+                "NONE",
+                np.array(
+                    [[1.0], [1.0], [1.0]],
+                    dtype=np.float32,
+                ),
+            )
+        ],
+    )
+    @pytest.mark.skipif(not ONNX_ML, reason="onnx not compiled with ai.onnx.ml")
+    def test_svm_regressor_linear_one_class(self, post, expected):
+        x = (np.arange(9).reshape((-1, 3)) - 5).astype(np.float32) / 5
+        model = self._get_test_svm_regressor_linear(post, one_class=1)
+        self._check_ort(model, {"X": x}, rev=True, atol=1e-5)
+        sess = ReferenceEvaluator(model)
+        (got,) = sess.run(None, {"X": x})
+        assert_allclose(got, expected, atol=1e-6)
+
+    def test_onnxrt_tfidf_vectorizer_ints(self):
+        inputi = np.array([[1, 1, 3, 3, 3, 7], [8, 6, 7, 5, 6, 8]]).astype(np.int64)
+        output = np.array(
+            [[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, 1.0]]
+        ).astype(np.float32)
+
+        ngram_counts = np.array([0, 4]).astype(np.int64)
+        ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+        pool_int64s = np.array([2, 3, 5, 4, 5, 6, 7, 8, 6, 7]).astype(  # unigrams
+            np.int64
+        )  # bigrams
+
+        model = make_model_gen_version(
+            make_graph(
+                [
+                    make_node(
+                        "TfIdfVectorizer",
+                        ["tokens"],
+                        ["out"],
+                        mode="TF",
+                        min_gram_length=2,
+                        max_gram_length=2,
+                        max_skip_count=0,
+                        ngram_counts=ngram_counts,
+                        ngram_indexes=ngram_indexes,
+                        pool_int64s=pool_int64s,
+                    )
+                ],
+                "tfidf",
+                [make_tensor_value_info("tokens", TensorProto.INT64, [None, None])],
+                [make_tensor_value_info("out", TensorProto.FLOAT, [None, None])],
+            ),
+            opset_imports=OPSETS,
+        )
+
+        oinf = ReferenceEvaluator(model)
+        res = oinf.run(None, {"tokens": inputi})
+        assert output.tolist() == res[0].tolist()
+
+    def test_onnxrt_tfidf_vectorizer_strings(self):
+        inputi = np.array(
+            [["i1", "i1", "i3", "i3", "i3", "i7"], ["i8", "i6", "i7", "i5", "i6", "i8"]]
+        )
+        output = np.array(
+            [[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, 1.0]]
+        ).astype(np.float32)
+
+        ngram_counts = np.array([0, 4]).astype(np.int64)
+        ngram_indexes = np.array([0, 1, 2, 3, 4, 5, 6]).astype(np.int64)
+        pool_strings = np.array(
+            ["i2", "i3", "i5", "i4", "i5", "i6", "i7", "i8", "i6", "i7"]
+        )
+
+        model = make_model_gen_version(
+            make_graph(
+                [
+                    make_node(
+                        "TfIdfVectorizer",
+                        ["tokens"],
+                        ["out"],
+                        mode="TF",
+                        min_gram_length=2,
+                        max_gram_length=2,
+                        max_skip_count=0,
+                        ngram_counts=ngram_counts,
+                        ngram_indexes=ngram_indexes,
+                        pool_strings=pool_strings,
+                    )
+                ],
+                "tfidf",
+                [make_tensor_value_info("tokens", TensorProto.STRING, [None, None])],
+                [make_tensor_value_info("out", TensorProto.FLOAT, [None, None])],
+            ),
+            opset_imports=OPSETS,
+        )
+
+        oinf = ReferenceEvaluator(model)
+        res = oinf.run(None, {"tokens": inputi})
+        assert output.tolist() == res[0].tolist()
diff --git a/onnx/test/reference_evaluator_model_test.py b/onnx/test/reference_evaluator_model_test.py
new file mode 100644
index 0000000..d951078
--- /dev/null
+++ b/onnx/test/reference_evaluator_model_test.py
@@ -0,0 +1,124 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# mypy: ignore-errors
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+import onnx.helper as oh
+import onnx.numpy_helper as onh
+import onnx.reference as orf
+
+
+def create_model():
+    """The following model is equivalent to the following function.
+
+    .. code-block:: python
+
+        from onnx import TensorProto
+        from onnx.helper import make_tensor
+
+        from onnxscript import script
+        from onnxscript.onnx_opset import opset15 as op
+        from onnxscript.onnx_types import FLOAT
+
+        @script()
+        def loop_range_cond_only(A: FLOAT["N"]) -> FLOAT["N"]:
+            T = A
+            cond = op.Constant(value=make_tensor("true",onnx.TensorProto.BOOL, [1], [1]))
+            while cond:
+                T = T + A
+                cond = op.ReduceSum(T) > -10
+            return T
+
+        model = loop_range_cond_only.to_model_proto()
+    """
+    opset_imports = [
+        oh.make_opsetid("", 15),
+    ]
+    inputs = []
+    outputs = []
+    nodes = []
+    initializers = []
+    sparse_initializers = []
+    functions = []
+    inputs.append(oh.make_tensor_value_info("A", onnx.TensorProto.FLOAT, shape=("N",)))
+    nodes.append(
+        oh.make_node(
+            "Constant",
+            [],
+            ["cond"],
+            value=onh.from_array(np.array([True], dtype=np.bool_), name="value"),
+        )
+    )
+    nodes.append(
+        oh.make_node(
+            "Constant",
+            [],
+            ["true"],
+            value=onh.from_array(np.array(True, dtype=np.bool_), name="value"),
+        )
+    )
+
+    def _make_local_graph_body():
+        inputs = []
+        outputs = []
+        nodes = []
+        initializers = []
+        sparse_initializers = []
+        inputs.append(
+            oh.make_tensor_value_info("infinite_loop", onnx.TensorProto.INT64, shape=[])
+        )
+        inputs.append(
+            oh.make_tensor_value_info("cond", onnx.TensorProto.BOOL, shape=[])
+        )
+        inputs.append(oh.make_tensor_value_info("T", onnx.TensorProto.UNDEFINED, []))
+        nodes.append(oh.make_node("Add", ["T", "A"], ["T_0"]))
+        nodes.append(oh.make_node("ReduceSum", ["T_0"], ["tmp"]))
+        nodes.append(
+            oh.make_node(
+                "Constant",
+                [],
+                ["int64_m10"],
+                value=onh.from_array(np.array(-10, dtype=np.int64), name="value"),
+            )
+        )
+        nodes.append(oh.make_node("CastLike", ["int64_m10", "tmp"], ["int64_m10_cast"]))
+        nodes.append(oh.make_node("Greater", ["tmp", "int64_m10_cast"], ["cond_1"]))
+        nodes.append(oh.make_node("Identity", ["cond_1"], ["cond_out"]))
+        outputs.append(
+            oh.make_tensor_value_info("cond_out", onnx.TensorProto.BOOL, shape=[])
+        )
+        outputs.append(oh.make_tensor_value_info("T_0", onnx.TensorProto.UNDEFINED, []))
+        return oh.make_graph(
+            nodes,
+            "loop_body",
+            inputs,
+            outputs,
+            initializers,
+            sparse_initializer=sparse_initializers,
+        )
+
+    body = _make_local_graph_body()
+    nodes.append(oh.make_node("Loop", ["", "true", "A"], ["T_2"], body=body))
+    outputs.append(
+        oh.make_tensor_value_info("T_2", onnx.TensorProto.FLOAT, shape=("N",))
+    )
+    graph = oh.make_graph(
+        nodes,
+        "loop_range_cond_only",
+        inputs,
+        outputs,
+        initializers,
+        sparse_initializer=sparse_initializers,
+    )
+    return oh.make_model(graph, functions=functions, opset_imports=opset_imports)
+
+
+class TestReferenceEvaluatorModel:
+    def test_loop_fft(self):
+        model = create_model()
+        session = orf.ReferenceEvaluator(model)
+        session.run(None, {"A": -np.arange(10).astype(np.float32)})
diff --git a/onnx/test/reference_evaluator_test.py b/onnx/test/reference_evaluator_test.py
new file mode 100644
index 0000000..e68f6af
--- /dev/null
+++ b/onnx/test/reference_evaluator_test.py
@@ -0,0 +1,6512 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+# mypy: ignore-errors
+
+"""You can run a specific test by using the following syntax.
+
+::
+
+    python onnx/test/reference_evaluator_test.py TestReferenceEvaluator.test_function_attribute_nested_graph
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import math
+import warnings
+from os import getenv
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+import ml_dtypes
+import numpy as np
+import pytest
+import version_utils
+from numpy.testing import assert_allclose
+
+import onnx
+from onnx import (
+    AttributeProto,
+    FunctionProto,
+    ModelProto,
+    TensorProto,
+    checker,
+    parser,
+)
+from onnx.backend.test.case.node.roialign import get_roi_align_input_values
+from onnx.checker import check_model
+from onnx.defs import onnx_opset_version
+from onnx.helper import (
+    make_function,
+    make_graph,
+    make_model,
+    make_model_gen_version,
+    make_node,
+    make_operatorsetid,
+    make_opsetid,
+    make_sequence_type_proto,
+    make_tensor,
+    make_tensor_sequence_value_info,
+    make_tensor_value_info,
+    make_value_info,
+)
+from onnx.numpy_helper import from_array
+from onnx.reference import ReferenceEvaluator
+from onnx.reference.op_run import OpRun, OpRunExpand
+from onnx.reference.ops import load_op
+from onnx.reference.ops._op_common_indices import _get_indices, _is_out
+from onnx.reference.ops._op_list import Cast_19, Celu
+from onnx.reference.ops.aionnx_preview_training._op_list import Adam
+from onnx.reference.ops.op_attention import _apply_causal, _softmax
+from onnx.reference.ops.op_celu import _vcelu1
+from onnx.reference.ops.op_col2im import (
+    _col2im_naive_implementation_2d,
+    col2im_naive_implementation,
+)
+from onnx.reference.ops.op_conv import Conv, _conv_implementation
+from onnx.reference.ops_optimized import Conv as ConvOptimized
+from onnx.reference.ops_optimized.op_conv_optimized import _conv_implementation_im2col
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+# TODO (https://github.com/microsoft/onnxruntime/issues/14932): Get max supported version from onnxruntime directly
+# For now, bump the version in CIs whenever there is a new onnxruntime release
+ORT_MAX_IR_SUPPORTED_VERSION = int(getenv("ORT_MAX_IR_SUPPORTED_VERSION", "8"))
+ORT_MAX_ONNX_OPSET_SUPPORTED_VERSION = int(
+    getenv("ORT_MAX_ONNX_OPSET_SUPPORTED_VERSION", "18")
+)
+
+
+skip_if_no_onnxruntime = pytest.mark.skipif(
+    importlib.util.find_spec("onnxruntime") is None, reason="onnxruntime not installed"
+)
+skip_if_no_torch = pytest.mark.skipif(
+    importlib.util.find_spec("torch") is None, reason="torch not installed"
+)
+skip_if_no_torchvision = pytest.mark.skipif(
+    importlib.util.find_spec("torchvision") is None, reason="torchvision not installed"
+)
+
+
+def make_sequence_value_info(name, elem_type, shape):
+    if isinstance(elem_type, int):
+        return make_tensor_sequence_value_info(name, elem_type, shape)
+    s_type = make_sequence_type_proto(elem_type)
+    return make_value_info(name, s_type, shape)
+
+
+def run_ort_inference(onnx_model):
+    import onnxruntime as ort  # noqa: PLC0415
+
+    onnx_domain_opset = ORT_MAX_ONNX_OPSET_SUPPORTED_VERSION
+    for opset in onnx_model.opset_import:
+        if opset.domain in ("", "ai.onnx"):
+            onnx_domain_opset = opset.version
+            break
+    # The new IR or opset version is not supported by onnxruntime yet
+    if (
+        onnx_model.ir_version > ORT_MAX_IR_SUPPORTED_VERSION
+        or onnx_domain_opset > ORT_MAX_ONNX_OPSET_SUPPORTED_VERSION
+    ):
+        return None
+
+    return ort.InferenceSession(
+        onnx_model.SerializeToString(), providers=["CPUExecutionProvider"]
+    )
+
+
+def im2col_naive_implementation(data, kernel_shape, dilations, pads, strides):
+    """Naive implementation for `im2col`.
+
+    Args:
+        data: image (float)
+        kernel_shape: kernel shape
+        dilations: dilations
+        pads: pads
+        strides: strides
+
+    Returns:
+        result
+    """
+    if not isinstance(kernel_shape, tuple):
+        raise TypeError(f"Unexpected type {type(kernel_shape)!r} for kernel_shape.")
+    if len(data.shape) != len(kernel_shape):
+        raise ValueError(f"Shape mismatch {data.shape!r} and {kernel_shape!r}.")
+    n_dims = len(pads) // 2
+    new_pads = np.array([(pads[i], pads[i + n_dims]) for i in range(n_dims)])
+    list_output_shape = list(data.shape + kernel_shape)
+    for d in range(n_dims):
+        kd = kernel_shape[d] + (kernel_shape[d] - 1) * (dilations[d] - 1)
+        nd = int(
+            ((list_output_shape[d] - kd + new_pads[d][0] + new_pads[d][1]) / strides[d])
+            + 1
+        )
+        list_output_shape[d] = nd
+    output_shape = tuple(list_output_shape)
+
+    res = np.zeros(output_shape, dtype=data.dtype)
+    kernel_size = np.prod(kernel_shape)
+    res_size = np.prod(res.shape[:-n_dims])
+    for i in range(res_size):
+        i_res = _get_indices(i, res.shape[:-n_dims])
+        t_res = tuple(i_res)
+        for j in range(kernel_size):
+            i_kernel = _get_indices(j, kernel_shape)
+            t_kernel = tuple(i_kernel)
+
+            i_img = i_res * strides - new_pads[:, 0] + i_kernel * dilations
+            t_img = tuple(i_img)
+            if _is_out(t_img, data.shape):
+                res[t_res + t_kernel] = 0
+            else:
+                res[t_res + t_kernel] = data[tuple(t_img)]
+    return res
+
+
+def im2col(
+    img: np.ndarray,
+    kernel_shape: tuple[int, ...],
+    dilations: Sequence[int],
+    pads: Sequence[int],
+    strides: Sequence[int],
+) -> np.ndarray:
+    res = None
+    for n in range(img.shape[0]):
+        for c in range(img.shape[1]):
+            out = im2col_naive_implementation(
+                img[n, c, ...], kernel_shape, dilations, pads, strides
+            )
+            if res is None:
+                new_shape = img.shape[:2] + out.shape
+                res = np.empty(new_shape, dtype=img.dtype)
+            res[n, c, ...] = out
+    new_shape = (*res.shape[: -len(kernel_shape)], -1)
+    return res.reshape(new_shape)
+
+
+class TestReferenceEvaluator:
+    m2_def = """
+        <
+            ir_version: 7,
+            opset_import: [ "": 10, "com.microsoft": 1]
+        >
+        agraph (float[N, M] B01, float[N, M] B11, float[N, M] B21) => (float[N, M] D0)
+        {
+            C0 = Add(B01, B11)
+            C1 = Sub(B11, B21)
+            D0 = Mul(C0, C1)
+        }
+        """
+
+    @staticmethod
+    def _load_model(m_def: str) -> ModelProto:
+        """Parses a model from a string representation, including checking
+        the model for correctness
+        """
+        m = parser.parse_model(m_def)
+        checker.check_model(m)
+        return m
+
+    @staticmethod
+    def _linear_regression(clip=False, opset=None, min_value=-1.0, max_value=1.0):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        A = make_tensor_value_info("A", TensorProto.FLOAT, [None, None])
+        B = make_tensor_value_info("B", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("MatMul", ["X", "A"], ["XA"])
+        if clip:
+            node2 = make_node("Add", ["XA", "B"], ["Y_clip"])
+            if opset is not None and opset < 11:
+                if min_value:
+                    if max_value:
+                        node3 = make_node(
+                            "Clip", ["Y_clip"], ["Y"], min=min_value, max=max_value
+                        )
+                    else:
+                        node3 = make_node("Clip", ["Y_clip"], ["Y"], min=min_value)
+                elif max_value:
+                    node3 = make_node("Clip", ["Y_clip"], ["Y"], max=max_value)
+                else:
+                    node3 = make_node("Clip", ["Y_clip"], ["Y"])
+                graph = make_graph([node1, node2, node3], "lr", [X, A, B], [Y])
+            else:
+                mi = (
+                    from_array(np.array([min_value], dtype=np.float32), name="mi")
+                    if min_value
+                    else None
+                )
+                ma = (
+                    from_array(np.array([max_value], dtype=np.float32), name="ma")
+                    if max_value
+                    else None
+                )
+                inputs = ["Y_clip", "mi" if mi else "", "ma" if ma else ""]
+                node3 = make_node("Clip", inputs, ["Y"])
+                initializer = [_ for _ in [mi, ma] if _]
+                graph = make_graph(
+                    [node1, node2, node3], "lr", [X, A, B], [Y], initializer=initializer
+                )
+
+            def f(x, a, b):  # noqa: ARG001
+                return np.clip(a @ a + b, min_value, max_value)
+
+        else:
+            node2 = make_node("Add", ["XA", "B"], ["Y"])
+            graph = make_graph([node1, node2], "lr", [X, A, B], [Y])
+            f = lambda x, a, b: a @ a + b  # noqa: ARG005, E731
+        if opset is None:
+            onnx_model = make_model(graph)
+        else:
+            onnx_model = make_model(graph, opset_imports=[make_opsetid("", opset)])
+        try:
+            check_model(onnx_model)
+        except Exception as e:
+            raise AssertionError(f"checker fails for\n{onnx_model}") from e
+        return onnx_model, f
+
+    def test_reference_evaluator_exceptions(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        with pytest.raises(TypeError):
+            ReferenceEvaluator(X)
+
+    def test_reference_evaluator_no_attribute(self):
+        m = TestReferenceEvaluator._load_model(TestReferenceEvaluator.m2_def)
+        checker.check_model(m)
+        sess = ReferenceEvaluator(m)
+        assert sess.input_names == ["B01", "B11", "B21"]
+        assert sess.output_names == ["D0"]
+        assert sess.opsets == {"": 10, "com.microsoft": 1}
+        x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+        y = np.array([[4, 5], [6, 7]], dtype=np.float32)
+        z = np.array([[-4, -5], [-6, -7]], dtype=np.float32)
+        res = sess.run(None, {"B01": x, "B11": y, "B21": z})[0]
+        expected = (x + y) * (y - z)
+        assert_allclose(res, expected)
+
+    def test_reference_evaluator_no_attribute_intermediate(self):
+        m = TestReferenceEvaluator._load_model(TestReferenceEvaluator.m2_def)
+        checker.check_model(m)
+        sess = ReferenceEvaluator(m)
+        assert sess.input_names == ["B01", "B11", "B21"]
+        assert sess.output_names == ["D0"]
+        assert sess.opsets == {"": 10, "com.microsoft": 1}
+        x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+        y = np.array([[4, 5], [6, 7]], dtype=np.float32)
+        z = np.array([[-4, -5], [-6, -7]], dtype=np.float32)
+        res = sess.run(None, {"B01": x, "B11": y, "B21": z}, intermediate=True)
+        assert isinstance(res, dict)
+        expected = (x + y) * (y - z)
+        assert_allclose(res["D0"], expected)
+
+    def test_reference_evaluator_no_attribute_bytes(self):
+        m = TestReferenceEvaluator._load_model(TestReferenceEvaluator.m2_def)
+        checker.check_model(m)
+        sess = ReferenceEvaluator(m.SerializeToString())
+        assert sess.input_names == ["B01", "B11", "B21"]
+        assert sess.output_names == ["D0"]
+        assert sess.opsets == {"": 10, "com.microsoft": 1}
+        x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+        y = np.array([[4, 5], [6, 7]], dtype=np.float32)
+        z = np.array([[-4, -5], [-6, -7]], dtype=np.float32)
+        res = sess.run(None, {"B01": x, "B11": y, "B21": z})[0]
+        expected = (x + y) * (y - z)
+        assert_allclose(res, expected)
+
+    @pytest.mark.parametrize(
+        "level, expected",
+        [
+            (
+                2,
+                "Add(B01, B11) -> C0\nSub(B11, B21) -> C1\nMul(C0, C1) -> D0\n",
+            ),
+            (
+                3,
+                dedent(
+                    """
+                     +I B01: float32:(2, 2) in [0.0, 3.0]
+                     +I B11: float32:(2, 2) in [4.0, 7.0]
+                     +I B21: float32:(2, 2) in [-7.0, -4.0]
+                    Add(B01, B11) -> C0
+                     + C0: float32:(2, 2) in [4.0, 10.0]
+                    Sub(B11, B21) -> C1
+                     + C1: float32:(2, 2) in [8.0, 14.0]
+                    Mul(C0, C1) -> D0
+                     + D0: float32:(2, 2) in [32.0, 140.0]
+                    """
+                ).lstrip("\n"),
+            ),
+            (
+                4,
+                dedent(
+                    """
+                 +I B01: float32:(2, 2):[0.0, 1.0, 2.0, 3.0]
+                 +I B11: float32:(2, 2):[4.0, 5.0, 6.0, 7.0]
+                 +I B21: float32:(2, 2):[-4.0, -5.0, -6.0, -7.0]
+                Add(B01, B11) -> C0
+                 + C0: float32:(2, 2):[4.0, 6.0, 8.0, 10.0]
+                Sub(B11, B21) -> C1
+                 + C1: float32:(2, 2):[8.0, 10.0, 12.0, 14.0]
+                Mul(C0, C1) -> D0
+                 + D0: float32:(2, 2):[32.0, 60.0, 96.0, 140.0]
+                """
+                ).lstrip("\n"),
+            ),
+            (
+                15,
+                dedent(
+                    """
+                 +I B01: float32:(2, 2):[0.0, 1.0, 2.0, 3.0]
+                 +I B11: float32:(2, 2):[4.0, 5.0, 6.0, 7.0]
+                 +I B21: float32:(2, 2):[-4.0, -5.0, -6.0, -7.0]
+                Add(B01, B11) -> C0
+                -- begin Add.run(2 inputs)
+                -- done Add.run -> 1 outputs
+                 + C0: float32:(2, 2):[4.0, 6.0, 8.0, 10.0]
+                Sub(B11, B21) -> C1
+                -- begin Sub.run(2 inputs)
+                -- done Sub.run -> 1 outputs
+                 + C1: float32:(2, 2):[8.0, 10.0, 12.0, 14.0]
+                Mul(C0, C1) -> D0
+                -- begin Mul.run(2 inputs)
+                -- done Mul.run -> 1 outputs
+                 + D0: float32:(2, 2):[32.0, 60.0, 96.0, 140.0]
+                """
+                ).lstrip("\n"),
+            ),
+        ],
+    )
+    def test_reference_evaluator_no_attribute_verbose(
+        self, level, expected, capsys: pytest.CaptureFixture
+    ):
+        m = TestReferenceEvaluator._load_model(TestReferenceEvaluator.m2_def)
+        x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+        y = np.array([[4, 5], [6, 7]], dtype=np.float32)
+        z = np.array([[-4, -5], [-6, -7]], dtype=np.float32)
+
+        sess = ReferenceEvaluator(m, verbose=level)
+        sess.run(None, {"B01": x, "B11": y, "B21": z})
+        out, _err = capsys.readouterr()
+        assert expected == out
+
+    @pytest.mark.parametrize("level", [2, 3, 4, 15])
+    def test_reference_evaluator_empty_array_verbose(
+        self, level, capsys: pytest.CaptureFixture
+    ):
+        input_tensor = make_tensor_value_info("input", TensorProto.FLOAT, [None, 3])
+        output_tensor = make_tensor_value_info("output", TensorProto.FLOAT, [None, 3])
+
+        node = make_node("Identity", ["input"], ["output"])
+        graph = make_graph([node], "test_empty_array", [input_tensor], [output_tensor])
+        model = make_model(graph)
+
+        sess = ReferenceEvaluator(model, verbose=level)
+
+        empty_input = np.array([], dtype=np.float32).reshape(0, 3)
+
+        (result,) = sess.run(None, {"input": empty_input})
+
+        expected = empty_input
+        assert_allclose(result, expected)
+        assert result.shape == (0, 3)
+
+        out, _err = capsys.readouterr()
+        assert "Identity" in out
+
+    def test_reference_evaluator_lr(self):
+        lr, f = TestReferenceEvaluator._linear_regression()
+        x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+        a = np.array([1, 1], dtype=np.float32)
+        b = np.array([11], dtype=np.float32)
+        expected = f(x, a, b)
+        sess = ReferenceEvaluator(lr)
+        got = sess.run(None, {"X": a, "A": a, "B": b})[0]
+        assert_allclose(got, expected)
+
+    @pytest.mark.parametrize("kwargs", [{}, {"min_value": None}, {"max_value": None}])
+    def test_reference_evaluator_lr_clip(self, kwargs):
+        lr, f = TestReferenceEvaluator._linear_regression(clip=True, **kwargs)
+        x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+        a = np.array([1, 1], dtype=np.float32)
+        b = np.array([11], dtype=np.float32)
+        expected = f(x, a, b)
+        sess = ReferenceEvaluator(lr)
+        last_node = sess.rt_nodes_[-1]
+        assert last_node.__class__.__name__ == "Clip_11"
+        (got,) = sess.run(None, {"X": a, "A": a, "B": b})
+        assert_allclose(got, expected)
+
+    @pytest.mark.parametrize(
+        "kwargs, min_expected, max_expected",
+        [
+            ({}, -1, 1),
+            ({"min_value": None}, -3.4028234663852886e38, 1),
+            ({"max_value": None}, -1, 3.4028234663852886e38),
+        ],
+    )
+    def test_reference_evaluator_lr_clip_6(self, kwargs, min_expected, max_expected):
+        # FIXME: This test reads as if it is a test for the
+        # implementation details of the TestReferenceEvaluator.
+        lr, f = TestReferenceEvaluator._linear_regression(clip=True, opset=10, **kwargs)
+        x = np.array([[0, 1], [2, 3]], dtype=np.float32)
+        a = np.array([1, 1], dtype=np.float32)
+        b = np.array([11], dtype=np.float32)
+        expected = f(x, a, b)
+        sess = ReferenceEvaluator(lr)
+        last_node = sess.rt_nodes_[-1]
+        assert last_node.__class__.__name__ == "Clip_6"
+        assert last_node.min == min_expected
+        assert last_node.max == max_expected
+        (got,) = sess.run(None, {"X": a, "A": a, "B": b})
+        assert_allclose(got, expected)
+
+    def test_nested_local_functions(self):
+        m = parser.parse_model(
+            """
+            <
+              ir_version: 8,
+              opset_import: [ "" : 14, "local" : 1],
+              producer_name: "test",
+              producer_version: "1.0",
+              model_version: 1,
+              doc_string: "Test preprocessing model"
+            >
+            agraph (uint8[H, W, C] x) => (uint8[H, W, C] x_processed)
+            {
+                x_processed = local.func(x)
+            }
+
+            <
+              opset_import: [ "" : 14 ],
+              domain: "local",
+              doc_string: "function 1"
+            >
+            f1 (x) => (y) {
+                y = Identity(x)
+            }
+
+            <
+              opset_import: [ "" : 14 ],
+              domain: "local",
+              doc_string: "function 2"
+            >
+            f2 (x) => (y) {
+                y = Identity(x)
+            }
+
+            <
+              opset_import: [ "" : 14, "local" : 1 ],
+              domain: "local",
+              doc_string: "Preprocessing function."
+            >
+            func (x) => (y) {
+                x1 = local.f1(x)
+                y = local.f2(x1)
+            }
+        """
+        )
+
+        sess = ReferenceEvaluator(m)
+        x = np.array([0, 1, 3], dtype=np.uint8).reshape((1, 1, 3))
+        result = sess.run(None, {"x": x})[0]
+        expected = x
+        assert_allclose(result, expected)
+
+    def test_reduce_sum_11(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("ReduceSum", ["X"], ["Y"], axes=[1], keepdims=1)
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 11)])
+        check_model(onnx_model)
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32)
+        expected = x.sum(axis=1, keepdims=1)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(got, expected)
+
+    def test_reduce_sum_square_11(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("ReduceSumSquare", ["X"], ["Y"], axes=[1], keepdims=1)
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 11)])
+        check_model(onnx_model)
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32)
+        expected = (x * x).sum(axis=1, keepdims=1)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(got, expected)
+
+    def test_reduce_sum_13(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        A = make_tensor_value_info("A", TensorProto.INT64, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("ReduceSum", ["X", "A"], ["Y"], keepdims=1)
+        graph = make_graph([node1], "rs", [X, A], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 13)])
+        check_model(onnx_model)
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32)
+        a = np.array([1], dtype=np.int64)
+        expected = x.sum(axis=1, keepdims=1)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x, "A": a})[0]
+        assert_allclose(got, expected)
+
+    def test_reduce_sum_attribute(self):
+        opset = onnx_opset_version()
+        new_domain = "custom"
+        opset_imports = [make_opsetid("", opset), make_opsetid(new_domain, 1)]
+
+        node = make_node("ReduceSum", ["X", "axis"], ["Y"])
+        att = AttributeProto()
+        att.name = "keepdims"
+        att.ref_attr_name = "keepdims"
+        att.type = AttributeProto.INT
+        node.attribute.append(att)
+
+        my_reduce_sum = make_function(
+            new_domain,
+            "MyReduceSum",
+            ["X", "axis"],
+            ["Y"],
+            [node],
+            opset_imports,
+            ["keepdims"],
+        )
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        axis = make_tensor_value_info("axis", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+
+        graph = make_graph(
+            [
+                make_node(
+                    "MyReduceSum",
+                    ["X", "axis"],
+                    ["Y"],
+                    domain=new_domain,
+                    keepdims=1,
+                ),
+            ],
+            "example",
+            [X, axis],
+            [Y],
+        )
+
+        onnx_model = make_model(
+            graph, opset_imports=opset_imports, functions=[my_reduce_sum]
+        )
+        sess = ReferenceEvaluator(onnx_model)
+        x = np.arange(6).reshape((3, 2)).astype(np.float32)
+        a = np.array([-1], dtype=np.int64)
+        result = sess.run(None, {"X": x, "axis": a})[0]
+        expected = x.sum(axis=-1, keepdims=1)
+        assert_allclose(result, expected)
+
+    def test_reduce_sum_square_18(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        A = make_tensor_value_info("A", TensorProto.INT64, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("ReduceSumSquare", ["X", "A"], ["Y"], keepdims=1)
+        graph = make_graph([node1], "rs", [X, A], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        check_model(onnx_model)
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32)
+        a = np.array([1], dtype=np.int64)
+        expected = (x * x).sum(axis=1, keepdims=1)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x, "A": a})[0]
+        assert_allclose(got, expected)
+
+    def test_reduce_sum_13_empty_axes(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        A = make_tensor_value_info("A", TensorProto.INT64, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("ReduceSum", ["X", "A"], ["Y"], keepdims=1)
+        graph = make_graph([node1], "rs", [X, A], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 13)])
+        check_model(onnx_model)
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32)
+        a = np.array([], dtype=np.int64)
+        expected = x.sum(keepdims=1)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x, "A": a})[0]
+        assert_allclose(got, expected)
+
+    def test_reduce_sum_square_18_empty_axes(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        A = make_tensor_value_info("A", TensorProto.INT64, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("ReduceSumSquare", ["X", "A"], ["Y"], keepdims=1)
+        graph = make_graph([node1], "rs", [X, A], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        check_model(onnx_model)
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32)
+        a = np.array([], dtype=np.int64)
+        expected = (x * x).sum(keepdims=1)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x, "A": a})[0]
+        assert_allclose(got, expected)
+
+    def test_reduce_sum_13_empty_axes_noop(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("ReduceSum", ["X"], ["Y"], keepdims=1, noop_with_empty_axes=1)
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 13)])
+        check_model(onnx_model)
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(x, got)
+
+    def test_reduce_sum_square_18_empty_axes_noop(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node(
+            "ReduceSumSquare", ["X"], ["Y"], keepdims=1, noop_with_empty_axes=1
+        )
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        check_model(onnx_model)
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(x * x, got)
+
+    def test_greater(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        Z = make_tensor_value_info("Z", TensorProto.FLOAT, [None])
+        node1 = make_node("Greater", ["X", "Y"], ["Z"])
+        graph = make_graph([node1], "g", [X, Y], [Z])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 13)])
+        check_model(onnx_model)
+        x = np.arange(4).reshape((2, 2)).astype(np.float32)
+        y = np.array([2], dtype=np.float32)
+        expected = x > y
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x, "Y": y})[0]
+        assert_allclose(got, expected)
+
+    def test_node_proto(self):
+        node1 = make_node("Greater", ["X", "Y"], ["Z"])
+        x = np.arange(4).reshape((2, 2)).astype(np.float32)
+        y = np.array([2], dtype=np.float32)
+        expected = x > y
+        sess = ReferenceEvaluator(node1)
+        got = sess.run(None, {"X": x, "Y": y})[0]
+        assert_allclose(got, expected)
+
+    def test_greater_or_equal(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        Z = make_tensor_value_info("Z", TensorProto.FLOAT, [None])
+        node1 = make_node("GreaterOrEqual", ["X", "Y"], ["Z"])
+        graph = make_graph([node1], "g", [X, Y], [Z])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 13)])
+        check_model(onnx_model)
+        x = np.arange(4).reshape((2, 2)).astype(np.float32)
+        y = np.array([2], dtype=np.float32)
+        expected = x >= y
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x, "Y": y})[0]
+        assert_allclose(got, expected)
+
+    def test_if(self):
+        C = make_tensor_value_info("C", TensorProto.FLOAT, [None])
+        bthen = make_node(
+            "Constant",
+            [],
+            ["C"],
+            value_floats=from_array(np.array([1], dtype=np.float32)),
+        )
+        bthen_body = make_graph([bthen], "gthen", [], [C])
+
+        C = make_tensor_value_info("C", TensorProto.FLOAT, [None])
+        belse = make_node(
+            "Constant",
+            [],
+            ["C"],
+            value_floats=from_array(np.array([0], dtype=np.float32)),
+        )
+        belse_body = make_graph([belse], "gelse", [], [C])
+
+        zero = from_array(np.array([0], dtype=np.float32), name="zero")
+        greater = make_node("Greater", ["X", "zero"], ["G"])
+        node_if = make_node(
+            "If",
+            ["G"],
+            ["Z"],
+            then_branch=bthen_body,
+            else_branch=belse_body,
+        )
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Z = make_tensor_value_info("Z", TensorProto.FLOAT, [None])
+        graph = make_graph([greater, node_if], "g", [X], [Z], initializer=[zero])
+        model_def = make_model(graph)
+
+        sess = ReferenceEvaluator(model_def)
+        assert str(sess) == "ReferenceEvaluator(X) -> Z"
+
+        x = np.array([1], dtype=np.float32)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(np.array([1], dtype=np.float32), got)
+
+        x = np.array([-1], dtype=np.float32)
+        got = sess.run(None, {"X": x})[0]
+        assert_allclose(np.array([0], dtype=np.float32), got)
+
+    def test_if_function(self):
+        then_out = make_tensor_value_info("then_out", TensorProto.FLOAT, [5])
+        else_out = make_tensor_value_info("else_out", TensorProto.FLOAT, [5])
+
+        x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+        y = np.array([5, 4, 3, 2, 1]).astype(np.float32)
+
+        then_const_node = make_node(
+            "Constant", inputs=[], outputs=["then_out"], value=from_array(x)
+        )
+        else_const_node = make_node(
+            "Constant", inputs=[], outputs=["else_out"], value=from_array(y)
+        )
+        then_body = make_graph([then_const_node], "then_body", [], [then_out])
+        else_body = make_graph([else_const_node], "else_body", [], [else_out])
+        if_node = make_node(
+            "If",
+            inputs=["f_cond"],
+            outputs=["f_res"],
+            then_branch=then_body,
+            else_branch=else_body,
+        )
+
+        f = FunctionProto()
+        f.domain = "custom"
+        f.name = "fn"
+        f.input.extend(["f_cond"])
+        f.output.extend(["f_res"])
+        f.node.extend([if_node])
+        opset = onnx_opset_version()
+        f.opset_import.extend([make_opsetid("", opset)])
+
+        graph = make_graph(
+            nodes=[make_node("fn", domain="custom", inputs=["cond"], outputs=["res"])],
+            name="graph",
+            inputs=[make_tensor_value_info("cond", TensorProto.BOOL, [])],
+            outputs=[make_tensor_value_info("res", TensorProto.FLOAT, [5])],
+        )
+
+        m = make_model(
+            graph,
+            producer_name="test",
+            opset_imports=[make_opsetid("", opset), make_opsetid("custom", 1)],
+        )
+        m.functions.extend([f])
+
+        sess = ReferenceEvaluator(m)
+        result = sess.run(None, {"cond": np.array(True)})
+        expected = np.array([1, 2, 3, 4, 5], dtype=np.float32)
+        assert_allclose(result[0], expected)
+
+    def test_function_attribute(self):
+        opset = onnx_opset_version()
+        new_domain = "custom"
+        opset_imports = [make_opsetid("", opset), make_opsetid(new_domain, 1)]
+        cst = make_node("Constant", [], ["B"])
+
+        att = AttributeProto()
+        att.name = "value"
+        att.ref_attr_name = "bias"
+        att.type = AttributeProto.TENSOR
+        cst.attribute.append(att)
+
+        node1 = make_node("MatMul", ["X", "A"], ["XA"])
+        node2 = make_node("Add", ["XA", "B"], ["Y"])
+
+        linear_regression = make_function(
+            new_domain,
+            "LinearRegression",
+            ["X", "A"],
+            ["Y"],
+            [cst, node1, node2],
+            opset_imports,
+            ["bias"],
+        )
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        A = make_tensor_value_info("A", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+
+        graph = make_graph(
+            [
+                make_node(
+                    "LinearRegression",
+                    ["X", "A"],
+                    ["Y1"],
+                    domain=new_domain,
+                    bias=make_tensor("former_B", TensorProto.FLOAT, [1], [0.67]),
+                ),
+                make_node("Abs", ["Y1"], ["Y"]),
+            ],
+            "example",
+            [X, A],
+            [Y],
+        )
+
+        onnx_model = make_model(
+            graph, opset_imports=opset_imports, functions=[linear_regression]
+        )
+        sess = ReferenceEvaluator(onnx_model)
+        x = np.arange(6).reshape((3, 2)).astype(np.float32)
+        a = np.array([1, -1], dtype=np.float32)
+        result = sess.run(None, {"X": x, "A": a})[0]
+        expected = np.abs(x @ a + 0.67)
+        assert_allclose(result, expected)
+
+    def test_function_attribute_nested_graph(self):
+        opset = onnx_opset_version()
+        new_domain = "custom"
+        opset_imports = [make_opsetid("", opset), make_opsetid(new_domain, 1)]
+
+        cst1 = make_node("Constant", [], ["B1"])
+        att = AttributeProto()
+        att.name = "value"
+        att.ref_attr_name = "bias1"
+        att.type = AttributeProto.TENSOR
+        cst1.attribute.append(att)
+
+        cst2 = make_node("Constant", [], ["B2"])
+        att = AttributeProto()
+        att.name = "value"
+        att.ref_attr_name = "bias2"
+        att.type = AttributeProto.TENSOR
+        cst2.attribute.append(att)
+
+        then_out = make_tensor_value_info("B1", TensorProto.FLOAT, [None])
+        else_out = make_tensor_value_info("B2", TensorProto.FLOAT, [None])
+        then_body = make_graph([cst1], "then_body", [], [then_out])
+        else_body = make_graph([cst2], "else_body", [], [else_out])
+
+        zero = make_node(
+            "Constant",
+            inputs=[],
+            outputs=["zero"],
+            value=from_array(np.array([0], dtype=np.float32)),
+        )
+        mini = make_node("ReduceMin", ["X"], ["Xmin"])
+        f_cond = make_node("Greater", ["Xmin", "zero"], ["f_cond"])
+        if_node = make_node(
+            "If",
+            inputs=["f_cond"],
+            outputs=["B"],
+            then_branch=then_body,
+            else_branch=else_body,
+        )
+
+        node1 = make_node("MatMul", ["X", "A"], ["XA"])
+        node2 = make_node("Add", ["XA", "B"], ["Y"])
+
+        linear_regression = make_function(
+            new_domain,
+            "LinearRegression",
+            ["X", "A"],
+            ["Y"],
+            [zero, mini, f_cond, if_node, node1, node2],
+            opset_imports,
+            ["bias1", "bias2"],
+        )
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        A = make_tensor_value_info("A", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+
+        graph = make_graph(
+            [
+                make_node(
+                    "LinearRegression",
+                    ["X", "A"],
+                    ["Y1"],
+                    domain=new_domain,
+                    bias1=make_tensor("former_B1", TensorProto.FLOAT, [1], [0.67]),
+                    bias2=make_tensor("former_B2", TensorProto.FLOAT, [1], [777]),
+                ),
+                make_node("Abs", ["Y1"], ["Y"]),
+            ],
+            "example",
+            [X, A],
+            [Y],
+        )
+
+        onnx_model = make_model(
+            graph, opset_imports=opset_imports, functions=[linear_regression]
+        )
+        check_model(onnx_model)
+        sess = ReferenceEvaluator(onnx_model)
+
+        assert sess.rt_nodes_[0].__class__.__name__ == "OpFunction"
+        assert sess.rt_nodes_[0].impl_.__class__.__name__ == "ReferenceEvaluator"
+        fct = sess.rt_nodes_[0].impl_
+        checked = False
+        for node in fct.rt_nodes_:
+            if node.__class__.__name__.startswith("If"):
+                if not node.has_linked_attribute:
+                    raise AssertionError(
+                        f"Nested node {type(node)} declares no linked attribute "
+                        f"but a subgraph does."
+                    )
+                checked = True
+        if not checked:
+            raise AssertionError(
+                "No node 'If' was found, has_linked_attribute could not be checked."
+            )
+
+        x = np.arange(6).reshape((3, 2)).astype(np.float32)
+        a = np.array([1, -1], dtype=np.float32)
+
+        result = sess.run(None, {"X": x + 1, "A": a})[0]
+        expected = np.abs(x @ a + 0.67)
+        assert_allclose(result, expected)
+
+        result = sess.run(None, {"X": x - 10, "A": a})[0]
+        expected = np.abs(x @ a + 777)
+        assert_allclose(result, expected)
+
+    def test_function_attribute_nested_nested_graph(self):
+        opset = onnx_opset_version()
+        new_domain = "custom"
+        opset_imports = [make_opsetid("", opset), make_opsetid(new_domain, 1)]
+
+        # first If
+        cst1 = make_node("Constant", [], ["B1"])
+        att = AttributeProto()
+        att.name = "value"
+        att.ref_attr_name = "bias1"
+        att.type = AttributeProto.TENSOR
+        cst1.attribute.append(att)
+
+        cst2 = make_node("Constant", [], ["B2"])
+        att = AttributeProto()
+        att.name = "value"
+        att.ref_attr_name = "bias2"
+        att.type = AttributeProto.TENSOR
+        cst2.attribute.append(att)
+
+        then_out = make_tensor_value_info("B1", TensorProto.FLOAT, [None])
+        else_out = make_tensor_value_info("B2", TensorProto.FLOAT, [None])
+        then_body1 = make_graph([cst1], "then_body", [], [then_out])
+        else_body1 = make_graph([cst2], "else_body", [], [else_out])
+
+        # sub graph 2
+        c100 = make_node(
+            "Constant",
+            inputs=[],
+            outputs=["c100"],
+            value=from_array(np.array([100], dtype=np.float32)),
+        )
+        f_cond = make_node("Greater", ["Xmin", "c100"], ["f_cond_100"])
+        if_node = make_node(
+            "If",
+            inputs=["f_cond_100"],
+            outputs=["B4"],
+            then_branch=then_body1,
+            else_branch=else_body1,
+        )
+
+        # second If
+        cst3 = make_node("Constant", [], ["B3"])
+        att = AttributeProto()
+        att.name = "value"
+        att.ref_attr_name = "bias3"
+        att.type = AttributeProto.TENSOR
+        cst3.attribute.append(att)
+
+        then_out = make_tensor_value_info("B3", TensorProto.FLOAT, [None])
+        then_body2 = make_graph([cst3], "then_body", [], [then_out])
+        else_out = make_tensor_value_info("B4", TensorProto.FLOAT, [None])
+        else_body2 = make_graph([c100, f_cond, if_node], "else_body", [], [else_out])
+
+        # function
+        zero = make_node(
+            "Constant",
+            inputs=[],
+            outputs=["zero"],
+            value=from_array(np.array([0], dtype=np.float32)),
+        )
+        mini = make_node("ReduceMin", ["X"], ["Xmin"])
+        f_cond = make_node("Less", ["Xmin", "zero"], ["f_cond_zero"])
+        if_node = make_node(
+            "If",
+            inputs=["f_cond_zero"],
+            outputs=["B"],
+            then_branch=then_body2,
+            else_branch=else_body2,
+        )
+        node1 = make_node("MatMul", ["X", "A"], ["XA"])
+        node2 = make_node("Add", ["XA", "B"], ["Y"])
+
+        linear_regression = make_function(
+            new_domain,
+            "LinearRegression",
+            ["X", "A"],
+            ["Y"],
+            [zero, mini, f_cond, if_node, node1, node2],
+            opset_imports,
+            ["bias1", "bias2", "bias3"],
+        )
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        A = make_tensor_value_info("A", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+
+        graph = make_graph(
+            [
+                make_node(
+                    "LinearRegression",
+                    ["X", "A"],
+                    ["Y1"],
+                    domain=new_domain,
+                    bias1=make_tensor("former_B1", TensorProto.FLOAT, [1], [0.67]),
+                    bias2=make_tensor("former_B2", TensorProto.FLOAT, [1], [777]),
+                    bias3=make_tensor("former_B3", TensorProto.FLOAT, [1], [-888]),
+                ),
+                make_node("Abs", ["Y1"], ["Y"]),
+            ],
+            "example",
+            [X, A],
+            [Y],
+        )
+        onnx_model = make_model(
+            graph, opset_imports=opset_imports, functions=[linear_regression]
+        )
+        check_model(onnx_model)
+        sess = ReferenceEvaluator(onnx_model)
+
+        x = np.arange(6).reshape((3, 2)).astype(np.float32)
+        a = np.array([1, -1], dtype=np.float32)
+
+        result = sess.run(None, {"X": x + 1, "A": a})[0]
+        expected = np.abs(x @ a + 777)
+        assert_allclose(result, expected)
+
+        result = sess.run(None, {"X": x - 10, "A": a})[0]
+        expected = np.abs(x @ a - 888)
+        assert_allclose(result, expected)
+
+        result = sess.run(None, {"X": x + 1000, "A": a})[0]
+        expected = np.abs(x @ a + 0.67)
+        assert_allclose(result, expected)
+
+    def test_custom_node(self):
+        class _InvAlpha:
+            op_domain = "custom"
+
+            def __init__(self, onnx_node, run_params):
+                self.onnx_node = onnx_node
+                self.run_params = run_params
+
+            def _run(self, x):
+                return (1 / (x + self.alpha),)
+
+        class InvAlpha2(OpRun):
+            def _run(self, x):
+                return (1 / (x + self.alpha),)
+
+        class InvAlpha(OpRun):
+            op_domain = "custom"
+
+            def _run(self, x, alpha=None):
+                alpha = alpha or self.alpha
+                return (1 / (x + alpha),)
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("InvAlpha", ["X"], ["Y"], alpha=0.5, domain="custom")
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("custom", 1)])
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32) + 1
+        with pytest.raises(NotImplementedError):
+            ReferenceEvaluator(onnx_model)
+
+        node1 = make_node("_InvAlpha", ["X"], ["Y"], alpha=0.5, domain="custom")
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("custom", 1)])
+        with pytest.raises(TypeError):
+            ReferenceEvaluator(onnx_model, new_ops=[_InvAlpha])
+
+        node1 = make_node("InvAlpha2", ["X"], ["Y"], alpha=0.5, domain="custom")
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("custom", 1)])
+        with pytest.raises(NotImplementedError):
+            ReferenceEvaluator(onnx_model, new_ops=[InvAlpha2])
+
+        node1 = make_node("InvAlpha", ["X"], ["Y"], alpha=0.5, domain="custom")
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("custom", 1)])
+        sess = ReferenceEvaluator(onnx_model, new_ops=[InvAlpha, InvAlpha])
+        got = sess.run(None, {"X": x})[0]
+        expected = 1 / (x + 0.5)
+        assert_allclose(got, expected)
+
+    def test_custom_no_output_tuple(self):
+        class InvAlpha(OpRun):
+            op_domain = "custom"
+
+            def _run(self, x, alpha=None):
+                alpha = alpha or self.alpha
+                return 1 / (x + alpha)
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("InvAlpha", ["X"], ["Y"], alpha=0.5, domain="custom")
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("custom", 1)])
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32) + 1
+        ref = ReferenceEvaluator(onnx_model, new_ops=[InvAlpha])
+        with pytest.raises(TypeError):
+            ref.run(None, {"X": x})
+
+    def test_custom_empty_output(self):
+        class InvAlpha(OpRun):
+            op_domain = "custom"
+
+            def _run(self, x, alpha=None):
+                del x, alpha
+                return ()
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("InvAlpha", ["X"], ["Y"], alpha=0.5, domain="custom")
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("custom", 1)])
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32) + 1
+        ref = ReferenceEvaluator(onnx_model, new_ops=[InvAlpha])
+        with pytest.raises(ValueError):
+            ref.run(None, {"X": x})
+
+    def test_custom_tuple_tuple(self):
+        class InvAlpha(OpRun):
+            op_domain = "custom"
+
+            def _run(self, x, alpha=None):
+                alpha = alpha or self.alpha
+                res = tuple([tuple([1 / (x + alpha)])])  # noqa: C409
+                assert isinstance(res, tuple)
+                assert isinstance(res[0], tuple)
+                return res
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("InvAlpha", ["X"], ["Y"], alpha=0.5, domain="custom")
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("custom", 1)])
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32) + 1
+        ref = ReferenceEvaluator(onnx_model, new_ops=[InvAlpha])
+        with pytest.raises(TypeError):
+            ref.run(None, {"X": x})
+
+    def test_custom_tuple_unexpected_type(self):
+        class CustomType:
+            pass
+
+        class InvAlpha(OpRun):
+            op_domain = "custom"
+
+            def _run(self, x, alpha=None):
+                del x, alpha
+                res = (CustomType(),)
+                assert isinstance(res, tuple)
+                assert isinstance(res[0], CustomType)
+                return res
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("InvAlpha", ["X"], ["Y"], alpha=0.5, domain="custom")
+        graph = make_graph([node1], "rs", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("custom", 1)])
+        x = np.arange(60).reshape((3, 4, 5)).astype(np.float32) + 1
+        ref = ReferenceEvaluator(onnx_model, new_ops=[InvAlpha])
+        with pytest.raises(TypeError):
+            ref.run(None, {"X": x})
+
+    def test_loop(self):
+        # Given a tensor x of values [x1, ..., xN],
+        # Return a sequence of tensors of
+        #   [[x1], [x1, x2], ..., [x1, ..., xN]]
+
+        cond_in = make_tensor_value_info("cond_in", TensorProto.BOOL, [])
+        cond_out = make_tensor_value_info("cond_out", TensorProto.BOOL, [])
+        iter_count = make_tensor_value_info("iter_count", TensorProto.INT64, [])
+        seq_in = make_tensor_sequence_value_info("seq_in", TensorProto.FLOAT, None)
+        seq_out = make_tensor_sequence_value_info("seq_out", TensorProto.FLOAT, None)
+
+        x = np.array([1, 2, 3, 4, 5]).astype(np.float32)
+
+        x_const_node = make_node(
+            "Constant",
+            inputs=[],
+            outputs=["x"],
+            value=make_tensor(
+                name="const_tensor_x",
+                data_type=TensorProto.FLOAT,
+                dims=x.shape,
+                vals=x.flatten().astype(float),
+            ),
+        )
+
+        one_const_node = make_node(
+            "Constant",
+            inputs=[],
+            outputs=["one"],
+            value=make_tensor(
+                name="const_tensor_one",
+                data_type=TensorProto.INT64,
+                dims=(),
+                vals=[1],
+            ),
+        )
+
+        zero_const_node = make_node(
+            "Constant",
+            inputs=[],
+            outputs=["slice_start"],
+            value=make_tensor(
+                name="const_tensor_zero",
+                data_type=TensorProto.INT64,
+                dims=(1,),
+                vals=[0],
+            ),
+        )
+
+        axes_node = make_node(
+            "Constant",
+            inputs=[],
+            outputs=["axes"],
+            value=make_tensor(
+                name="const_tensor_axes",
+                data_type=TensorProto.INT64,
+                dims=(),
+                vals=[0],
+            ),
+        )
+
+        add_node = make_node("Add", inputs=["iter_count", "one"], outputs=["end"])
+
+        end_unsqueeze_node = make_node(
+            "Unsqueeze", inputs=["end", "axes"], outputs=["slice_end"]
+        )
+
+        slice_node = make_node(
+            "Slice", inputs=["x", "slice_start", "slice_end"], outputs=["slice_out"]
+        )
+
+        insert_node = make_node(
+            "SequenceInsert", inputs=["seq_in", "slice_out"], outputs=["seq_out"]
+        )
+
+        identity_node = make_node("Identity", inputs=["cond_in"], outputs=["cond_out"])
+
+        loop_body = make_graph(
+            [
+                identity_node,
+                x_const_node,
+                one_const_node,
+                zero_const_node,
+                add_node,
+                axes_node,
+                end_unsqueeze_node,
+                slice_node,
+                insert_node,
+            ],
+            "loop_body",
+            [iter_count, cond_in, seq_in],
+            [cond_out, seq_out],
+        )
+
+        node = make_node(
+            "Loop",
+            inputs=["trip_count", "cond", "seq_empty"],
+            outputs=["seq_res"],
+            body=loop_body,
+        )
+        node_concat = make_node(
+            "ConcatFromSequence",
+            inputs=["seq_res"],
+            outputs=["res"],
+            axis=0,
+            new_axis=0,
+        )
+
+        trip_count = np.array(5).astype(np.int64)
+        seq_empty = []  # type: List[Any]
+        # seq_res = [x[:int(i)] for i in x]
+        cond = np.array(1).astype(np.bool_)
+
+        model_def = make_model(
+            graph=make_graph(
+                name="loop_test",
+                inputs=[
+                    make_tensor_value_info(
+                        "trip_count", TensorProto.INT64, trip_count.shape
+                    ),
+                    make_tensor_value_info("cond", TensorProto.BOOL, cond.shape),
+                    make_sequence_value_info("seq_empty", TensorProto.FLOAT, []),
+                ],
+                outputs=[make_tensor_value_info("res", TensorProto.FLOAT, None)],
+                nodes=[node, node_concat],
+            )
+        )
+
+        expected = np.array(
+            [1.0, 1.0, 2.0, 1.0, 2.0, 3.0, 1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0, 5.0],
+            dtype=np.float32,
+        )
+        oinf = ReferenceEvaluator(model_def)
+        inputs = {"trip_count": trip_count, "cond": cond, "seq_empty": seq_empty}
+        got = oinf.run(None, inputs)
+        assert_allclose(got[0], expected)
+
+    def test_onnxt_runtime_bernoulli(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("Bernoulli", ["X"], ["Y"], seed=0.0)
+        graph = make_graph([node1], "g", [X], [Y])
+        onnx_model = make_model(graph)
+        check_model(onnx_model)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": np.zeros((2, 4), dtype=np.float32) + 0.5})[0]
+        assert got.shape == (2, 4)
+        assert got.dtype == np.float32
+        assert got.min() > -1e-5
+        assert got.max() < 1 + 1e-5
+
+    def test_onnxt_runtime_random_uniform(self):
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("RandomUniform", [], ["Y"], seed=0.0, shape=[2, 4])
+        graph = make_graph([node1], "g", [], [Y])
+        onnx_model = make_model(graph)
+        check_model(onnx_model)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {})[0]
+        assert got.shape == (2, 4)
+        assert got.dtype == np.float32
+        assert got.min() > 0
+        assert got.max() < 1
+
+    def test_onnxt_runtime_random_uniform_like(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("RandomUniformLike", ["X"], ["Y"], seed=0.0)
+        graph = make_graph([node1], "g", [X], [Y])
+        onnx_model = make_model(graph)
+        check_model(onnx_model)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": np.zeros((2, 4), dtype=np.float32)})[0]
+        assert got.shape == (2, 4)
+        assert got.dtype == np.float32
+        assert got.min() > 0
+        assert got.max() < 1
+
+    def test_onnxt_runtime_random_normal(self):
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("RandomNormal", [], ["Y"], seed=0.0, shape=[2, 4])
+        graph = make_graph([node1], "g", [], [Y])
+        onnx_model = make_model(graph)
+        check_model(onnx_model)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {})[0]
+        assert got.shape == (2, 4)
+        assert got.dtype == np.float32
+
+    def test_onnxt_runtime_random_normal_like(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = make_node("RandomNormalLike", ["X"], ["Y"], seed=0.0)
+        graph = make_graph([node1], "g", [X], [Y])
+        onnx_model = make_model(graph)
+        check_model(onnx_model)
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": np.zeros((2, 4), dtype=np.float32)})[0]
+        assert got.shape == (2, 4)
+        assert got.dtype == np.float32
+
+    def test_eval_celu(self):
+        inst = Celu.create(alpha=0.5)
+        assert inst.alpha == 0.5
+        x = np.array([[0, 1], [-1, 2]], dtype=np.float32)
+        y = Celu.eval(x, alpha=0.5)
+        expected = _vcelu1(x, alpha=0.5)
+        assert_allclose(y, expected)
+
+    def test_eval_cast(self):
+        x = np.array([[0, 1], [-1, 2]], dtype=np.float32)
+        y = Cast_19.eval(x, to=TensorProto.FLOAT8E4M3FN)
+        dy = Cast_19.eval(y, to=TensorProto.FLOAT)
+        expected = x
+        assert_allclose(dy, expected)
+
+    def test_eval_celu_load_op(self):
+        celu = load_op("", "Celu")
+        assert celu.op_domain == ""
+        inst = celu.create(alpha=0.5)
+        assert inst.alpha == 0.5
+        x = np.array([[0, 1], [-1, 2]], dtype=np.float32)
+        y = celu.eval(x, alpha=0.5)
+        expected = _vcelu1(x, alpha=0.5)
+        assert_allclose(y, expected)
+
+    def test_create_adam(self):
+        inst = Adam.create(alpha=0.5)
+        assert inst.alpha == 0.5
+
+    @skip_if_no_onnxruntime
+    def test_conv(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+        B = make_tensor_value_info("B", TensorProto.FLOAT, [None, None, None, None])
+        W = make_tensor_value_info("W", TensorProto.FLOAT, [None, None, None, None])
+        node = make_node(
+            "Conv",
+            ["X", "W", "B"],
+            ["Y"],
+            pads=[1, 1, 1, 1],
+            dilations=[1, 1],
+            strides=[2, 2],
+        )
+        graph = make_graph([node], "g", [X, W, B], [Y])
+        onnx_model = make_model_gen_version(graph, opset_imports=[make_opsetid("", 16)])
+        sess1 = run_ort_inference(onnx_model)
+        if sess1 is None:
+            return
+        sess2 = ReferenceEvaluator(onnx_model, optimized=False)
+        assert isinstance(sess2.rt_nodes_[0], Conv)
+        sess3 = ReferenceEvaluator(onnx_model, new_ops=[ConvOptimized], optimized=False)
+        assert isinstance(sess3.rt_nodes_[0], ConvOptimized)
+        sess4 = ReferenceEvaluator(onnx_model, optimized=True)
+        assert isinstance(sess4.rt_nodes_[0], ConvOptimized)
+
+        sH, sW = 5, 6
+        for i in range(sH):
+            for j in range(sW):
+                X = np.zeros((1, 1, sH, sW), dtype=np.float32)
+                X[0, 0, i, j] = 1.0
+                W = np.zeros((1, 1, 3, 3), dtype=np.float32)
+                W[0, 0, :, :] = np.minimum(2 ** np.arange(9).reshape((3, -1)), 256)
+
+                B = np.array([[[[0]]]], dtype=np.float32)
+                expected = sess1.run(None, {"X": X, "W": W, "B": B})[0]
+                got = sess2.run(None, {"X": X, "W": W, "B": B})[0]
+                assert_allclose(got, expected)
+                got3 = sess3.run(None, {"X": X, "W": W, "B": B})[0]
+                assert_allclose(got3, expected)
+                got4 = sess4.run(None, {"X": X, "W": W, "B": B})[0]
+                assert_allclose(got4, expected)
+
+    @skip_if_no_onnxruntime
+    def test_qlinearconv(self):
+        x = make_tensor_value_info("x", TensorProto.UINT8, [None, None, None, None])
+        w = make_tensor_value_info("w", TensorProto.UINT8, [None, None, None, None])
+        y = make_tensor_value_info("y", TensorProto.UINT8, [None, None, None, None])
+        x_scale = make_tensor_value_info("x_scale", TensorProto.FLOAT, [None])
+        w_scale = make_tensor_value_info("w_scale", TensorProto.FLOAT, [None])
+        y_scale = make_tensor_value_info("y_scale", TensorProto.FLOAT, [None])
+        x_zero_point = make_tensor_value_info("x_zero_point", TensorProto.UINT8, [None])
+        w_zero_point = make_tensor_value_info("w_zero_point", TensorProto.UINT8, [None])
+        y_zero_point = make_tensor_value_info("y_zero_point", TensorProto.UINT8, [None])
+
+        node = make_node(
+            "QLinearConv",
+            [
+                "x",
+                "x_scale",
+                "x_zero_point",
+                "w",
+                "w_scale",
+                "w_zero_point",
+                "y_scale",
+                "y_zero_point",
+            ],
+            ["y"],
+        )
+        graph = make_graph(
+            [node],
+            "g",
+            [x, x_scale, x_zero_point, w, w_scale, w_zero_point, y_scale, y_zero_point],
+            [y],
+        )
+        onnx_model = make_model_gen_version(graph, opset_imports=[make_opsetid("", 16)])
+
+        sess1 = run_ort_inference(onnx_model)
+        if sess1 is None:
+            return
+        sess2 = ReferenceEvaluator(onnx_model)
+
+        sH, sW = 3, 3
+        for i in range(sH):
+            for j in range(sW):
+                x = np.zeros((1, 1, sH, sW), dtype=np.uint8)
+                x[0, 0, i, j] = 1.0
+                #######
+                # 1x1 #
+                #######
+                w = np.zeros((1, 1, 1, 1), dtype=np.uint8)
+                w[0, 0, :, :] = 1
+                feeds = {
+                    "x": x,
+                    "x_scale": np.array([1], dtype=np.float32),
+                    "x_zero_point": np.array([0], dtype=np.uint8),
+                    "w": w,
+                    "w_scale": np.array([1], dtype=np.float32),
+                    "w_zero_point": np.array([0], dtype=np.uint8),
+                    "y_scale": np.array([1], dtype=np.float32),
+                    "y_zero_point": np.array([0], np.uint8),
+                }
+                expected = sess1.run(None, feeds)[0]
+                got = sess2.run(None, feeds)[0]
+                assert_allclose(got, expected)
+
+                #######
+                # 3x3 #
+                #######
+                w = np.zeros((1, 1, 3, 3), dtype=np.uint8)
+                w[0, 0, :, :] = np.minimum(2 ** np.arange(9).reshape((3, -1)), 128)
+                feeds = {
+                    "x": x,
+                    "x_scale": np.array([1], dtype=np.float32),
+                    "x_zero_point": np.array([0], dtype=np.uint8),
+                    "w": w,
+                    "w_scale": np.array([1], dtype=np.float32),
+                    "w_zero_point": np.array([0], dtype=np.uint8),
+                    "y_scale": np.array([1], dtype=np.float32),
+                    "y_zero_point": np.array([0], np.uint8),
+                }
+                expected = sess1.run(None, feeds)[0]
+                got = sess2.run(None, feeds)[0]
+                assert_allclose(got, expected)
+
+                #######
+                # 1x1 #
+                #######
+                w = np.zeros((1, 1, 1, 1), dtype=np.uint8)
+                w[0, 0, :, :] = 0
+                feeds = {
+                    "x": x,
+                    "x_scale": np.array([0.00369204697], dtype=np.float32),
+                    "x_zero_point": np.array([132], dtype=np.uint8),
+                    "w": w,
+                    "w_scale": np.array([100.001727945750], dtype=np.float32),
+                    "w_zero_point": np.array([255], dtype=np.uint8),
+                    "y_scale": np.array([0.00162681262], dtype=np.float32),
+                    "y_zero_point": np.array([132], np.uint8),
+                }
+                expected = sess1.run(None, feeds)[0]
+                got = sess2.run(None, feeds)[0]
+                assert_allclose(got, expected)
+
+    @pytest.fixture
+    def qlinearconv_w_scale_vector_session(self) -> ReferenceEvaluator:
+        x = make_tensor_value_info("x", TensorProto.UINT8, [None, None, None, None])
+        w = make_tensor_value_info("w", TensorProto.UINT8, [None, None, None, None])
+        y = make_tensor_value_info("y", TensorProto.UINT8, [None, None, None, None])
+        x_scale = make_tensor_value_info("x_scale", TensorProto.FLOAT, [None])
+        w_scale = make_tensor_value_info("w_scale", TensorProto.FLOAT, [None])
+        y_scale = make_tensor_value_info("y_scale", TensorProto.FLOAT, [None])
+        x_zero_point = make_tensor_value_info("x_zero_point", TensorProto.UINT8, [None])
+        w_zero_point = make_tensor_value_info("w_zero_point", TensorProto.UINT8, [None])
+        y_zero_point = make_tensor_value_info("y_zero_point", TensorProto.UINT8, [None])
+
+        node = make_node(
+            "QLinearConv",
+            [
+                "x",
+                "x_scale",
+                "x_zero_point",
+                "w",
+                "w_scale",
+                "w_zero_point",
+                "y_scale",
+                "y_zero_point",
+            ],
+            ["y"],
+        )
+        graph = make_graph(
+            [node],
+            "g",
+            [x, x_scale, x_zero_point, w, w_scale, w_zero_point, y_scale, y_zero_point],
+            [y],
+        )
+        onnx_model = make_model_gen_version(graph, opset_imports=[make_opsetid("", 16)])
+        return ReferenceEvaluator(onnx_model)
+
+    def test_qlinearconv_w_scale_vector_single_channel(
+        self, qlinearconv_w_scale_vector_session: ReferenceEvaluator
+    ):
+        x = np.array(
+            [
+                [255, 174, 162, 25, 203, 168, 58],
+                [15, 59, 237, 95, 129, 0, 64],
+                [56, 242, 153, 221, 168, 12, 166],
+                [232, 178, 186, 195, 237, 162, 237],
+                [188, 39, 124, 77, 80, 102, 43],
+                [127, 230, 21, 83, 41, 40, 134],
+                [255, 154, 92, 141, 42, 148, 247],
+            ],
+            dtype=np.uint8,
+        ).reshape((1, 1, 7, 7))
+        x_scale = np.array([0.00369204697], dtype=np.float32)
+        x_zero_point = np.array([132], dtype=np.uint8)
+        w = np.array([0], dtype=np.uint8).reshape((1, 1, 1, 1))
+        w_scale = np.array([0.00172794575], dtype=np.float32)
+        w_zero_point = np.array([255], dtype=np.uint8)
+        y_scale = np.array([0.00162681262], dtype=np.float32)
+        y_zero_point = np.array([123], dtype=np.uint8)
+
+        feeds = {
+            "x": x,
+            "x_scale": x_scale,
+            "x_zero_point": x_zero_point,
+            "w": w,
+            "w_scale": w_scale,
+            "w_zero_point": w_zero_point,
+            "y_scale": y_scale,
+            "y_zero_point": y_zero_point,
+        }
+        expected = [
+            [
+                [
+                    [0, 81, 93, 230, 52, 87, 197],
+                    [240, 196, 18, 160, 126, 255, 191],
+                    [199, 13, 102, 34, 87, 243, 89],
+                    [23, 77, 69, 60, 18, 93, 18],
+                    [67, 216, 131, 178, 175, 153, 212],
+                    [128, 25, 234, 172, 214, 215, 121],
+                    [0, 101, 163, 114, 213, 107, 8],
+                ]
+            ]
+        ]
+
+        (got,) = qlinearconv_w_scale_vector_session.run(None, feeds)
+        assert_allclose(got, expected)
+
+    def test_qlinearconv_w_scale_vector_multiple_output_channels(
+        self, qlinearconv_w_scale_vector_session: ReferenceEvaluator
+    ):
+        x = np.array(
+            [
+                [255, 174, 162, 25, 203, 168, 58],
+                [15, 59, 237, 95, 129, 0, 64],
+                [56, 242, 153, 221, 168, 12, 166],
+                [232, 178, 186, 195, 237, 162, 237],
+                [188, 39, 124, 77, 80, 102, 43],
+                [127, 230, 21, 83, 41, 40, 134],
+                [255, 154, 92, 141, 42, 148, 247],
+            ],
+            dtype=np.uint8,
+        ).reshape((1, 1, 7, 7))
+        x_scale = np.array([0.00390625], dtype=np.float32)
+        x_zero_point = np.array([0], dtype=np.uint8)
+        w = np.full([2, 1, 3, 3], 128, dtype=np.uint8)
+        w[0, 0, 1, 2] = 200
+        w[1, 0, 1, 0] = 2
+        w_scale = np.array([0.00390625, 0.001953125], dtype=np.float32)
+        w_zero_point = np.array([128, 128], dtype=np.uint8)
+        y_scale = np.array([0.00162681262], dtype=np.float32)
+        y_zero_point = np.array([123], dtype=np.uint8)
+
+        feeds = {
+            "x": x,
+            "x_scale": x_scale,
+            "x_zero_point": x_zero_point,
+            "w": w,
+            "w_scale": w_scale,
+            "w_zero_point": w_zero_point,
+            "y_scale": y_scale,
+            "y_zero_point": y_zero_point,
+        }
+        expected = [
+            [
+                [
+                    [255, 187, 210, 123, 166],
+                    [226, 255, 236, 131, 235],
+                    [249, 255, 255, 232, 255],
+                    [207, 175, 177, 192, 152],
+                    [137, 179, 151, 150, 213],
+                ],
+                [
+                    [114, 88, 0, 67, 47],
+                    [90, 0, 33, 0, 24],
+                    [0, 18, 13, 8, 0],
+                    [12, 100, 50, 77, 76],
+                    [48, 0, 111, 74, 99],
+                ],
+            ]
+        ]
+
+        got = qlinearconv_w_scale_vector_session.run(None, feeds)[0]
+        assert_allclose(got, expected)
+
+    def test_qlinearconv_w_scale_vector_fails_with_w_scale_2D(
+        self, qlinearconv_w_scale_vector_session: ReferenceEvaluator
+    ):
+        x = np.zeros((1, 1, 7, 7), dtype=np.uint8)
+        x_scale = np.array([0.00390625], dtype=np.float32)
+        x_zero_point = np.array([0], dtype=np.uint8)
+        w = np.full([2, 1, 3, 3], 128, dtype=np.uint8)
+        w_scale = np.array([[0.00390625, 0.001953125], [1, 1]], dtype=np.float32)
+        w_zero_point = np.array([128, 128], dtype=np.uint8)
+        y_scale = np.array([0.00162681262], dtype=np.float32)
+        y_zero_point = np.array([123], dtype=np.uint8)
+
+        feeds = {
+            "x": x,
+            "x_scale": x_scale,
+            "x_zero_point": x_zero_point,
+            "w": w,
+            "w_scale": w_scale,
+            "w_zero_point": w_zero_point,
+            "y_scale": y_scale,
+            "y_zero_point": y_zero_point,
+        }
+        with pytest.raises(
+            ValueError, match="w_scale must be a scalar or a 1-D tensor"
+        ):
+            qlinearconv_w_scale_vector_session.run(None, feeds)
+
+    def test_qlinearconv_w_scale_vector_fails_with_w_scale_wrong_length(
+        self, qlinearconv_w_scale_vector_session: ReferenceEvaluator
+    ):
+        x = np.zeros((1, 1, 7, 7), dtype=np.uint8)
+        x_scale = np.array([0.00390625], dtype=np.float32)
+        x_zero_point = np.array([0], dtype=np.uint8)
+        w = np.full([2, 1, 3, 3], 128, dtype=np.uint8)
+        w_scale = np.array([0.00390625, 0.001953125, 1], dtype=np.float32)
+        w_zero_point = np.array([128, 128], dtype=np.uint8)
+        y_scale = np.array([0.00162681262], dtype=np.float32)
+        y_zero_point = np.array([123], dtype=np.uint8)
+
+        feeds = {
+            "x": x,
+            "x_scale": x_scale,
+            "x_zero_point": x_zero_point,
+            "w": w,
+            "w_scale": w_scale,
+            "w_zero_point": w_zero_point,
+            "y_scale": y_scale,
+            "y_zero_point": y_zero_point,
+        }
+        with pytest.raises(
+            ValueError, match="w_scale elements must match output channels"
+        ):
+            qlinearconv_w_scale_vector_session.run(None, feeds)
+
+    def _run_qlinear_int8(self, op_type, feeds, operand_shapes, output_shape, opset):
+        """Build and run a single-node int8 QLinear{Conv,MatMul} graph.
+
+        ``feeds`` supplies the eight quantized inputs in operator order
+        (a/x, a_scale, a_zero_point, b/w, b_scale, b_zero_point, y_scale,
+        y_zero_point); the operands and output are int8, the scales float.
+        """
+        if op_type == "QLinearConv":
+            names = [
+                "x",
+                "x_scale",
+                "x_zero_point",
+                "w",
+                "w_scale",
+                "w_zero_point",
+                "y_scale",
+                "y_zero_point",
+            ]
+        elif op_type == "QLinearMatMul":
+            names = [
+                "a",
+                "a_scale",
+                "a_zero_point",
+                "b",
+                "b_scale",
+                "b_zero_point",
+                "y_scale",
+                "y_zero_point",
+            ]
+        else:
+            raise ValueError(f"Unsupported op_type: {op_type!r}")
+        if set(names) != set(feeds):
+            raise ValueError(f"feeds must contain exactly these keys: {names}")
+        a_shape, b_shape = operand_shapes
+        i8, flt = TensorProto.INT8, TensorProto.FLOAT
+        graph = make_graph(
+            [make_node(op_type, names, ["y"])],
+            "g",
+            [
+                make_tensor_value_info(names[0], i8, a_shape),
+                make_tensor_value_info(names[1], flt, [1]),
+                make_tensor_value_info(names[2], i8, [1]),
+                make_tensor_value_info(names[3], i8, b_shape),
+                make_tensor_value_info(names[4], flt, [1]),
+                make_tensor_value_info(names[5], i8, [1]),
+                make_tensor_value_info(names[6], flt, [1]),
+                make_tensor_value_info(names[7], i8, [1]),
+            ],
+            [make_tensor_value_info("y", i8, output_shape)],
+        )
+        onnx_model = make_model_gen_version(
+            graph, opset_imports=[make_opsetid("", opset)]
+        )
+        return ReferenceEvaluator(onnx_model).run(None, feeds)[0]
+
+    def test_qlinearconv_int8(self):
+        # Self-contained int8 QLinearConv (no onnxruntime needed): a negative
+        # zero point and negative output exercise the signed int8 path that the
+        # uint8 tests above never reach.
+        feeds = {
+            "x": np.array([[[[10, 20], [30, 40]]]], dtype=np.int8),
+            "x_scale": np.array([0.1], dtype=np.float32),
+            "x_zero_point": np.array([5], dtype=np.int8),
+            "w": np.array([[[[1, 1], [1, 1]]]], dtype=np.int8),
+            "w_scale": np.array([1.0], dtype=np.float32),
+            "w_zero_point": np.array([0], dtype=np.int8),
+            "y_scale": np.array([1.0], dtype=np.float32),
+            "y_zero_point": np.array([-10], dtype=np.int8),
+        }
+        # dequantize(x) = (x - 5) * 0.1 = [[0.5, 1.5], [2.5, 3.5]]; dequantize(w) = 1.0
+        # valid conv (2x2 input, 2x2 kernel) = 0.5 + 1.5 + 2.5 + 3.5 = 8.0
+        # quantize(8.0, scale=1, zero_point=-10) = round(8.0) + (-10) = -2
+        got = self._run_qlinear_int8(
+            "QLinearConv", feeds, ([1, 1, 2, 2], [1, 1, 2, 2]), [1, 1, 1, 1], opset=16
+        )
+        np.testing.assert_array_equal(np.array([[[[-2]]]], dtype=np.int8), got)
+
+    def common_test_im2col(self, kernel_shape, pads, strides, dilations):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None])
+        Y1 = make_tensor_value_info("Y1", TensorProto.FLOAT, [None, None, None, None])
+        Y2 = make_tensor_value_info("Y2", TensorProto.FLOAT, [None, None, None, None])
+        W = make_tensor_value_info("W", TensorProto.FLOAT, [None, None, None, None])
+        node = make_node(
+            "Conv", ["X", "W"], ["Y1"], pads=pads, strides=strides, dilations=dilations
+        )
+        node_shape = make_node("Shape", ["W"], ["shape"])
+        node_im = make_node(
+            "Im2Col",
+            ["X", "shape"],
+            ["xim"],
+            pads=pads,
+            strides=strides,
+            dilations=dilations,
+            domain="experimental",
+        )
+        node_flat = make_node("Flatten", ["W"], ["wflat"])
+        node_gem = make_node("MatMul", ["wflat", "xim"], ["Y2"])
+        graph = make_graph(
+            [node, node_shape, node_im, node_flat, node_gem],
+            "g",
+            [X, W],
+            [Y1, Y2],
+        )
+        onnx_model = make_model(
+            graph, opset_imports=[make_opsetid("", 16), make_opsetid("experimental", 1)]
+        )
+        graph_conv = make_graph([node], "g", [X, W], [Y1])
+        onnx_model_conv = make_model_gen_version(
+            graph_conv, opset_imports=[make_opsetid("", 16)]
+        )
+        sess = ReferenceEvaluator(onnx_model)
+
+        try:
+            sess_conv = run_ort_inference(onnx_model_conv)
+            if sess_conv is None:
+                return
+        except ImportError:
+            sess_conv = None
+
+        sH, sW = 7, 7
+        nker = np.prod(kernel_shape)
+        for i in range(sH):
+            for j in range(sW):
+                X = np.zeros((1, 1, sH, sW), dtype=np.float32)
+                X[0, 0, i, j] = 1.0
+                W = np.zeros(
+                    (1, 1, *kernel_shape),
+                    dtype=np.float32,
+                )
+                W[0, 0, :, :] = np.minimum(
+                    2 ** np.arange(nker).reshape((kernel_shape[0], -1)), 256
+                )
+
+                got = sess.run(None, {"X": X, "W": W})
+                if sess_conv is not None:
+                    ort_res = sess_conv.run(None, {"X": X, "W": W})[0]
+                    assert_allclose(got[1].ravel(), ort_res.ravel())
+                try:
+                    assert_allclose(got[0].ravel(), got[1].ravel())
+                except AssertionError as e:
+                    raise AssertionError(
+                        f"Discrepancies: pads={pads}, dilations={dilations}, strides={strides}, "
+                        f"kernel_shape={kernel_shape}"
+                        f"\n{got[0]}\n!=\n{got[1]}"
+                    ) from e
+
+    def test_im2col_1x1(self):
+        self.common_test_im2col(
+            (1, 1), pads=[1, 1, 1, 2], strides=[1, 1], dilations=[1, 1]
+        )
+
+    def test_im2col_2x2(self):
+        self.common_test_im2col(
+            (2, 2), pads=[1, 1, 1, 2], strides=[1, 1], dilations=[1, 1]
+        )
+
+    def test_im2col_3x3(self):
+        self.common_test_im2col(
+            (3, 3), pads=[1, 1, 1, 2], strides=[1, 1], dilations=[1, 1]
+        )
+
+    def test_im2col_3x3_pads(self):
+        self.common_test_im2col(
+            (3, 3), pads=[0, 1, 2, 3], strides=[1, 1], dilations=[1, 1]
+        )
+
+    def test_im2col_3x3_strides(self):
+        self.common_test_im2col(
+            (3, 3), pads=[0, 1, 1, 1], strides=[1, 2], dilations=[1, 1]
+        )
+
+    def test_im2col_5x5(self):
+        self.common_test_im2col(
+            (5, 5), pads=[1, 1, 1, 2], strides=[1, 1], dilations=[1, 1]
+        )
+
+    @skip_if_no_torch
+    def test_col2im(self):
+        import torch  # noqa: PLC0415
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None])
+        IS = make_tensor_value_info("I", TensorProto.INT64, [None])
+        BS = make_tensor_value_info("B", TensorProto.INT64, [None])
+        node = make_node(
+            "Col2Im",
+            ["X", "I", "B"],
+            ["Y"],
+            pads=[0, 0, 0, 0],
+            strides=[1, 1],
+            dilations=[1, 1],
+        )
+        graph = make_graph([node], "g", [X, IS, BS], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+        sess = ReferenceEvaluator(onnx_model)
+
+        X = np.array(
+            [
+                [
+                    [1.0, 6.0, 11.0, 16.0, 21.0],
+                    [2.0, 7.0, 12.0, 17.0, 22.0],
+                    [3.0, 8.0, 13.0, 18.0, 23.0],
+                    [4.0, 9.0, 14.0, 19.0, 24.0],
+                    [5.0, 0.0, 15.0, 20.0, 25.0],
+                ]
+            ]
+        ).astype(np.float32)
+        image_shape = np.array([5, 5]).astype(np.int64)
+        block_shape = np.array([1, 5]).astype(np.int64)
+
+        fold = torch.nn.Fold(output_size=tuple(image_shape), kernel_size=block_shape)
+
+        got = sess.run(None, {"X": X, "B": block_shape, "I": image_shape})
+        output = fold(torch.from_numpy(X)).numpy()
+        assert_allclose(output, got[0])
+
+    def common_test_col2im(
+        self, size, image_shape, block_shape, pads, strides, dilations
+    ):
+        import torch  # noqa: PLC0415
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None])
+        IS = make_tensor_value_info("I", TensorProto.INT64, [None])
+        BS = make_tensor_value_info("B", TensorProto.INT64, [None])
+        node = make_node(
+            "Col2Im",
+            ["X", "I", "B"],
+            ["Y"],
+            pads=pads,
+            strides=strides,
+            dilations=dilations,
+        )
+        graph = make_graph([node], "g", [X, IS, BS], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+        sess = ReferenceEvaluator(onnx_model)
+
+        fold = torch.nn.Fold(
+            output_size=tuple(image_shape),
+            kernel_size=tuple(block_shape),
+            dilation=tuple(dilations),
+            padding=min(pads),
+            stride=tuple(strides),
+        )
+
+        nker = np.prod(block_shape)
+        for i in range(nker):
+            for j in range(size):
+                X = np.zeros((1, nker, size), dtype=np.float32)
+                X[0, i, j] = 1.0
+                i_shape = np.array(image_shape, dtype=np.int64)
+                b_shape = np.array(block_shape, dtype=np.int64)
+
+                output = fold(torch.from_numpy(X)).numpy()
+                got = sess.run(None, {"X": X, "B": b_shape, "I": i_shape})
+                assert_allclose(output, got[0])
+
+    @skip_if_no_torch
+    def test_col2im_2x3(self):
+        self.common_test_col2im(
+            10, (6, 4), (2, 3), pads=[0, 0, 0, 0], strides=[1, 1], dilations=[1, 1]
+        )
+
+    @skip_if_no_torch
+    def test_col2im_2x3_pads(self):
+        self.common_test_col2im(
+            28, (6, 4), (2, 3), pads=[1, 1, 1, 1], strides=[1, 1], dilations=[1, 1]
+        )
+
+    def test_col2im_2d(self):
+        data = np.zeros([6, 28], dtype=np.float32)
+        data[0][0] = 1.0
+        image_shape, kernel_shape, dilations, pads, stride = (
+            np.array([6, 4]),
+            (2, 3),
+            np.array([1, 1]),
+            np.array([1, 1, 1, 1]),
+            np.array([1, 1]),
+        )
+        r1 = _col2im_naive_implementation_2d(
+            data, image_shape, kernel_shape, dilations, pads, stride
+        )
+        r2 = col2im_naive_implementation(
+            data, image_shape, kernel_shape, dilations, pads, stride
+        )
+        assert_allclose(r1, r2)
+
+    def test_conv_im2col_group4(self):
+        # model 1
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [2, 4, 6, 6])
+        W = make_tensor_value_info("W", TensorProto.FLOAT, [4, 1, 3, 3])
+        B = make_tensor_value_info("B", TensorProto.FLOAT, [4])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [2, 4, 6, 6])
+
+        node = make_node(
+            "Conv",
+            ["X", "W", "B"],
+            ["Y"],
+            group=4,
+            dilations=[1, 1],
+            kernel_shape=[3, 3],
+            pads=[1, 1, 1, 1],
+            strides=[1, 1],
+        )
+        graph = make_graph([node], "g", [X, W, B], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+
+        feeds = {
+            "X": np.arange(2 * 4 * 6 * 6).reshape((2, 4, 6, 6)).astype(np.float32),
+            "W": np.array(
+                [
+                    [
+                        [
+                            [
+                                -0.026239916682243347,
+                                0.07565222680568695,
+                                -0.03209298849105835,
+                            ],
+                            [
+                                -0.08708783239126205,
+                                0.0961190015077591,
+                                0.13418219983577728,
+                            ],
+                            [
+                                0.1598859578371048,
+                                0.03840477764606476,
+                                -0.13170936703681946,
+                            ],
+                        ]
+                    ],
+                    [
+                        [
+                            [
+                                -0.0689004510641098,
+                                0.1408083587884903,
+                                -0.03717087209224701,
+                            ],
+                            [
+                                0.030967697501182556,
+                                0.0263785719871521,
+                                -0.0899493545293808,
+                            ],
+                            [
+                                0.07828782498836517,
+                                -0.06266771256923676,
+                                0.10750330984592438,
+                            ],
+                        ]
+                    ],
+                    [
+                        [
+                            [
+                                0.020227551460266113,
+                                -0.04353883117437363,
+                                -0.10938453674316406,
+                            ],
+                            [
+                                -0.14101561903953552,
+                                -0.03393106162548065,
+                                0.12139306962490082,
+                            ],
+                            [
+                                0.02838282287120819,
+                                0.13864465057849884,
+                                -0.06065710633993149,
+                            ],
+                        ]
+                    ],
+                    [
+                        [
+                            [
+                                -0.06511610746383667,
+                                -0.05987360328435898,
+                                -0.008047685027122498,
+                            ],
+                            [
+                                0.07340313494205475,
+                                0.0326494425535202,
+                                0.012516498565673828,
+                            ],
+                            [
+                                0.13260947167873383,
+                                -0.022225692868232727,
+                                -0.11167611926794052,
+                            ],
+                        ]
+                    ],
+                ],
+                dtype=np.float32,
+            ),
+            "B": np.array(
+                [
+                    -0.1457933485507965,
+                    -0.07481209933757782,
+                    -0.05890338122844696,
+                    -0.11964251846075058,
+                ],
+                dtype=np.float32,
+            ),
+        }
+        feeds["B"][:] = 0
+
+        # model 2
+        X = feeds["X"]
+        W = feeds["W"]
+        B = feeds["B"]
+        Y = np.empty((2, 4, 6, 6), dtype=X.dtype)
+        for b in range(X.shape[0]):
+            for g in range(4):
+                x = X[b : b + 1, g : g + 1]
+                w = W[g]
+                c2 = im2col(x, (3, 3), [1, 1], [1, 1, 1, 1], [1, 1])
+                mul = np.matmul(c2, w.flatten())
+                mul = mul + B[g]
+                Y[b, g, :, :] = mul
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+
+        assert_allclose(Y, got1[0], atol=1e-5)
+
+    def test_conv_strides(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [1, 3, 6, 6])
+        W = make_tensor_value_info("W", TensorProto.FLOAT, [2, 3, 3, 3])
+        B = make_tensor_value_info("B", TensorProto.FLOAT, [2])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+
+        node = make_node(
+            "Conv",
+            ["X", "W", "B"],
+            ["Y"],
+            group=1,
+            dilations=[1, 1],
+            kernel_shape=[3, 3],
+            pads=[1, 1, 1, 1],
+            strides=[2, 2],
+        )
+        graph = make_graph([node], "g", [X, W, B], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+
+        feeds = {
+            "X": np.arange(1 * 3 * 6 * 6).reshape((1, 3, 6, 6)).astype(np.float32) + 1,
+            "W": np.zeros((2, 3, 3, 3), dtype=np.float32),
+            "B": np.zeros((2,), dtype=np.float32),
+        }
+        feeds["W"][0, 0, 0, 1] = 1
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        expected = np.array(
+            [
+                [
+                    [[0.0, 0.0, 0.0], [7.0, 9.0, 11.0], [19.0, 21.0, 23.0]],
+                    [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]],
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        assert_allclose(got1[0], expected)
+
+    def test_max_pool_2d_1(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+
+        node = make_node(
+            "MaxPool",
+            ["X"],
+            ["Y"],
+            kernel_shape=[3, 3],
+            pads=[1, 1, 1, 1],
+            strides=[2, 2],
+        )
+        graph = make_graph([node], "g", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+
+        feeds = {"X": np.arange(49)[::-1].reshape((1, 1, 7, 7)).astype(np.float32)}
+        expected = np.array(
+            [
+                [
+                    [
+                        [48.0, 47.0, 45.0, 43.0],
+                        [41.0, 40.0, 38.0, 36.0],
+                        [27.0, 26.0, 24.0, 22.0],
+                        [13.0, 12.0, 10.0, 8.0],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        assert_allclose(got1[0], expected)
+
+    def test_max_pool_2d_2(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+
+        node = make_node(
+            "MaxPool",
+            ["X"],
+            ["Y"],
+            kernel_shape=[3, 3],
+            pads=[1, 1, 1, 1],
+            strides=[2, 2],
+        )
+        graph = make_graph([node], "g", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+
+        feeds = {
+            "X": np.array(
+                [
+                    [
+                        [
+                            [683, 358, 726, 578, 650, 946, 200],
+                            [679, 260, 264, 5, 240, 255, 582],
+                            [322, 66, 687, 632, 852, 698, 428],
+                            [111, 452, 627, 332, 751, 842, 685],
+                            [472, 52, 956, 81, 807, 827, 360],
+                            [972, 574, 81, 799, 646, 499, 486],
+                            [892, 758, 75, 833, 972, 415, 736],
+                        ]
+                    ]
+                ],
+                dtype=np.float32,
+            )
+        }
+        expected = np.array(
+            [
+                [
+                    [
+                        [683.0, 726.0, 946.0, 946.0],
+                        [679.0, 687.0, 852.0, 842.0],
+                        [972.0, 956.0, 842.0, 842.0],
+                        [972.0, 833.0, 972.0, 736.0],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        assert_allclose(got1[0], expected)
+
+    def test_scatter_elements(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Ind = make_tensor_value_info("I", TensorProto.INT64, [None, None])
+        U = make_tensor_value_info("U", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+
+        node = make_node(
+            "ScatterElements",
+            ["X", "I", "U"],
+            ["Y"],
+            axis=1,
+            reduction="min",
+        )
+        graph = make_graph([node], "g", [X, Ind, U], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+        feeds = {
+            "X": np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32),
+            "I": np.array([[1, 1]]),
+            "U": np.array([[1.1, 2.1]], dtype=np.float32),
+        }
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        expected = np.array([[1.0, 1.1, 3.0, 4.0, 5.0]], dtype=np.float32)
+        assert_allclose(got1[0], expected)
+
+    def test_scatternd(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Ind = make_tensor_value_info("I", TensorProto.INT64, [None, None])
+        U = make_tensor_value_info("U", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+
+        node = make_node(
+            "ScatterND",
+            ["X", "I", "U"],
+            ["Y"],
+        )
+        graph = make_graph([node], "g", [X, Ind, U], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+        feeds = {
+            "X": np.array([[1.0, 2.0]], dtype=np.float32),
+            "I": np.array([[0, 0]]),
+            "U": np.array([3.0], dtype=np.float32),
+        }
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        expected = np.array([[3.0, 2.0]], dtype=np.float32)
+        assert_allclose(got1[0], expected)
+
+    def test_conv_transpose_2d(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None])
+        W = make_tensor_value_info("W", TensorProto.FLOAT, [None, None, None, None])
+        B = make_tensor_value_info("B", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+
+        node = make_node(
+            "ConvTranspose",
+            ["X", "W", "B"],
+            ["Y"],
+            dilations=[1, 1],
+            kernel_shape=[3, 3],
+            output_padding=[0, 0],
+            pads=[1, 1, 1, 1],
+            strides=[1, 1],
+        )
+        graph = make_graph([node], "g", [X, W, B], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+        feeds = {
+            "X": np.arange(1 * 3 * 5 * 4).reshape((1, 3, 5, 4)).astype(np.float32),
+            "W": np.arange(3 * 1 * 3 * 3).reshape((3, 1, 3, 3)).astype(np.float32),
+            "B": np.array([0, 0, 0, 0], dtype=np.float32),
+        }
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        expected = np.array(
+            [
+                [
+                    [
+                        [4371, 6855, 7062, 4929],
+                        [7524, 11781, 12132, 8451],
+                        [8424, 13185, 13536, 9423],
+                        [9324, 14589, 14940, 10395],
+                        [7197, 11229, 11490, 7971],
+                    ],
+                ]
+            ],
+            dtype=np.float32,
+        )
+        assert_allclose(got1[0], expected)
+
+        feeds["X"] *= 0
+        feeds["X"][0, 0, 0, 0] = 1
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        expected = np.array(
+            [
+                [
+                    [
+                        [4, 5, 0, 0],
+                        [7, 8, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                    ]
+                ]
+            ],
+            dtype=np.float32,
+        )
+        assert_allclose(got1[0], expected)
+
+    def test_conv_transpose_2d_upper(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None])
+        W = make_tensor_value_info("W", TensorProto.FLOAT, [None, None, None, None])
+        B = make_tensor_value_info("B", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+
+        node = make_node(
+            "ConvTranspose",
+            ["X", "W", "B"],
+            ["Y"],
+            auto_pad="SAME_UPPER",
+            strides=[2, 2],
+            # output_shape=[6, 6],
+        )
+        graph = make_graph([node], "g", [X, W, B], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 16)])
+        feeds = {
+            "X": np.arange(1 * 1 * 3 * 3).reshape((1, 1, 3, 3)).astype(np.float32),
+            "W": np.arange(1 * 2 * 3 * 3).reshape((1, 2, 3, 3)).astype(np.float32),
+            "B": np.array([0, 0, 0, 0], dtype=np.float32),
+        }
+
+        expected = np.array(
+            [
+                [
+                    [
+                        [0, 0, 0, 1, 2, 2],
+                        [0, 0, 3, 4, 11, 8],
+                        [0, 3, 12, 11, 28, 19],
+                        [9, 12, 27, 16, 35, 20],
+                        [18, 27, 60, 35, 76, 43],
+                        [18, 24, 51, 28, 59, 32],
+                    ],
+                    [
+                        [0, 0, 9, 10, 29, 20],
+                        [0, 0, 12, 13, 38, 26],
+                        [27, 30, 84, 56, 136, 82],
+                        [36, 39, 90, 52, 116, 65],
+                        [99, 108, 240, 134, 292, 160],
+                        [72, 78, 168, 91, 194, 104],
+                    ],
+                ]
+            ],
+            dtype=np.float32,
+        )
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        assert_allclose(got1[0], expected)
+
+    def test_stft(self):
+        signal = make_tensor_value_info("signal", TensorProto.FLOAT, [None, None, None])
+        frame_step = make_tensor_value_info("frame_step", TensorProto.INT64, [None])
+        frame_length = make_tensor_value_info("frame_length", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+
+        node = make_node(
+            "STFT",
+            ["signal", "frame_step", "", "frame_length"],
+            ["Y"],
+        )
+        graph = make_graph([node], "g", [signal, frame_step, frame_length], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 17)])
+        feeds = {
+            "signal": np.arange(128).reshape((1, 128, 1)).astype(np.float32),
+            "frame_step": np.array(8, dtype=np.int64),
+            "frame_length": np.array(16, dtype=np.int64),
+        }
+
+        signal = feeds["signal"]
+        frame_length = int(feeds["frame_length"])
+        frame_step = int(feeds["frame_step"])
+        onesided_length = (frame_length // 2) + 1
+        nstfts = ((feeds["signal"].shape[1] - frame_length) // frame_step) + 1
+        # [batch_size][frames][frame_length][2]
+        expected = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32)
+        for i in range(nstfts):
+            start = i * frame_step
+            stop = i * frame_step + frame_length
+            complex_out = np.fft.fft(signal[0, start:stop, 0])
+            c_out = complex_out[0:onesided_length]
+            expected[0, i] = np.stack((c_out.real, c_out.imag), axis=1)
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        assert_allclose(got1[0], expected)
+
+    def test_stft_with_window(self):
+        signal = make_tensor_value_info("signal", TensorProto.FLOAT, [None, None, None])
+        frame_step = make_tensor_value_info("frame_step", TensorProto.INT64, [None])
+        window = make_tensor_value_info("window", TensorProto.FLOAT, [None])
+        frame_length = make_tensor_value_info("frame_length", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+
+        node = make_node(
+            "STFT",
+            ["signal", "frame_step", "window", "frame_length"],
+            ["Y"],
+        )
+        graph = make_graph([node], "g", [signal, frame_step, window, frame_length], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 17)])
+        feeds = {
+            "signal": np.arange(128).reshape((1, 128, 1)).astype(np.float32),
+            "frame_step": np.array(8, dtype=np.int64),
+            "window": 0.5
+            + 0.5 * np.cos(2 * np.pi * np.arange(0, 16, 1, dtype=np.float32) / 16),
+            "frame_length": np.array(16, dtype=np.int64),
+        }
+
+        signal = feeds["signal"]
+        frame_length = int(feeds["frame_length"])
+        window = feeds["window"]
+        frame_step = int(feeds["frame_step"])
+        onesided_length = (frame_length // 2) + 1
+        nstfts = 1 + (signal.shape[1] - window.shape[0]) // 8
+        # [batch_size][frames][frame_length][2]
+        expected = np.empty([1, nstfts, onesided_length, 2], dtype=np.float32)
+        for i in range(nstfts):
+            start = i * frame_step
+            stop = i * frame_step + frame_length
+            complex_out = np.fft.fft(signal[0, start:stop, 0] * window)[
+                0:onesided_length
+            ]
+            c_out = complex_out[0:onesided_length]
+            expected[0, i] = np.stack((c_out.real, c_out.imag), axis=1)
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        assert_allclose(got1[0], expected)
+
+    def get_roi_align_model(self, mode):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None])
+        rois = make_tensor_value_info("rois", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+        IS = make_tensor_value_info("I", TensorProto.INT64, [None])
+        node = make_node(
+            "RoiAlign",
+            ["X", "rois", "I"],
+            ["Y"],
+            output_height=5,
+            output_width=5,
+            sampling_ratio=2,
+            spatial_scale=1.0,
+            coordinate_transformation_mode="output_half_pixel",
+            mode=mode,
+        )
+        graph = make_graph([node], "g", [X, rois, IS], [Y])
+        return make_model_gen_version(graph, opset_imports=[make_opsetid("", 17)])
+
+    def common_test_roi_align(self, mode):
+        onnx_model = self.get_roi_align_model(mode)
+        X, batch_indices, rois = get_roi_align_input_values()
+        feeds = {"X": X, "rois": rois, "I": batch_indices}
+        sess = run_ort_inference(onnx_model)
+        if sess is None:
+            return
+        expected = sess.run(None, feeds)
+        ref = ReferenceEvaluator(onnx_model)
+        got = ref.run(None, feeds)
+        assert_allclose(got[0], expected[0], atol=1e-5)
+
+    @pytest.mark.parametrize("mode", ["avg", "max"])
+    @skip_if_no_onnxruntime
+    def test_roi_align(self, mode):
+        self.common_test_roi_align(mode)
+
+    def common_test_roi_align_torch(self, mode):
+        import torch  # noqa: PLC0415
+        from torchvision.ops import RoIAlign  # noqa: PLC0415
+
+        onnx_model = self.get_roi_align_model(mode)
+        sess = ReferenceEvaluator(onnx_model)
+        X, batch_indices, rois = get_roi_align_input_values()
+        got = sess.run(None, {"X": X, "rois": rois, "I": batch_indices})
+
+        a = RoIAlign((5, 5), spatial_scale=1.0, sampling_ratio=2)
+        expected = a(torch.from_numpy(X), [torch.from_numpy(rois)])
+        assert_allclose(got[0], expected, atol=1e-5)
+
+    @skip_if_no_torch
+    @skip_if_no_torchvision
+    def test_roi_align_torch(self):
+        self.common_test_roi_align_torch("avg")
+
+    def test_split(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y1 = make_tensor_value_info("Y1", TensorProto.FLOAT, [None])
+        Y2 = make_tensor_value_info("Y2", TensorProto.FLOAT, [None])
+        Y3 = make_tensor_value_info("Y3", TensorProto.FLOAT, [None])
+        Y4 = make_tensor_value_info("Y4", TensorProto.FLOAT, [None])
+
+        node = make_node("Split", ["X"], ["Y1", "Y2", "Y3", "Y4"], num_outputs=4)
+        graph = make_graph([node], "g", [X], [Y1, Y2, Y3, Y4])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        feeds = {"X": np.arange(10).astype(np.float32)}
+
+        expected = [
+            np.array([0, 1, 2], dtype=np.float32),
+            np.array([3, 4, 5], dtype=np.float32),
+            np.array([6, 7, 8], dtype=np.float32),
+            np.array([9], dtype=np.float32),
+        ]
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        for i in range(4):
+            np.testing.assert_equal(got1[i], expected[i])
+
+    def test_split_2(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y1 = make_tensor_value_info("Y1", TensorProto.FLOAT, [None])
+        Y2 = make_tensor_value_info("Y2", TensorProto.FLOAT, [None])
+        Y3 = make_tensor_value_info("Y3", TensorProto.FLOAT, [None])
+        Y4 = make_tensor_value_info("Y4", TensorProto.FLOAT, [None])
+
+        node = make_node("Split", ["X", "split"], ["Y1", "Y2", "Y3", "Y4"])
+        graph = make_graph([node], "g", [X], [Y1, Y2, Y3, Y4])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        feeds = {
+            "X": np.arange(10).astype(np.float32),
+            "split": np.array([3, 3, 2, 2], dtype=np.int64),
+        }
+
+        expected = [
+            np.array([0, 1, 2], dtype=np.float32),
+            np.array([3, 4, 5], dtype=np.float32),
+            np.array([6, 7], dtype=np.float32),
+            np.array([8, 9], dtype=np.float32),
+        ]
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        for i in range(4):
+            assert_allclose(got1[i], expected[i])
+
+    def test_split_num_outputs_4(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y1 = make_tensor_value_info("Y1", TensorProto.FLOAT, [None])
+        Y2 = make_tensor_value_info("Y2", TensorProto.FLOAT, [None])
+        Y3 = make_tensor_value_info("Y3", TensorProto.FLOAT, [None])
+        Y4 = make_tensor_value_info("Y4", TensorProto.FLOAT, [None])
+
+        node = make_node("Split", ["X"], ["Y1", "Y2", "Y3", "Y4"], num_outputs=4)
+        graph = make_graph([node], "g", [X], [Y1, Y2, Y3, Y4])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+
+        # case 1
+        feeds = {"X": np.arange(10).astype(np.float32)}
+        expected = [
+            np.array([0, 1, 2], dtype=np.float32),
+            np.array([3, 4, 5], dtype=np.float32),
+            np.array([6, 7, 8], dtype=np.float32),
+            np.array([9], dtype=np.float32),
+        ]
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        for i in range(4):
+            assert_allclose(got1[i], expected[i])
+
+        # case 2
+        feeds = {"X": np.arange(9).astype(np.float32)}
+        expected = [
+            np.array([0, 1, 2], dtype=np.float32),
+            np.array([3, 4, 5], dtype=np.float32),
+            np.array([6, 7, 8], dtype=np.float32),
+            np.array([], dtype=np.float32),
+        ]
+
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        for i in range(4):
+            assert_allclose(got1[i], expected[i])
+
+    def test_argmin(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.INT64, [None])
+        node = make_node("ArgMin", ["X"], ["Y"], axis=1)
+        graph = make_graph([node], "g", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        feeds = {"X": np.arange(12).reshape((3, 4)).astype(np.float32)}
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        expected = np.array([0, 0, 0], dtype=np.int64).reshape((-1, 1))
+        assert got1[0].tolist() == expected.tolist()
+
+    def test_argmax(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.INT64, [None])
+        node = make_node("ArgMax", ["X"], ["Y"], axis=1)
+        graph = make_graph([node], "g", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        feeds = {"X": np.arange(12).reshape((3, 4)).astype(np.float32)}
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        expected = np.array([3, 3, 3], dtype=np.int64).reshape((-1, 1))
+        assert got1[0].tolist() == expected.tolist()
+
+    def test_slice_squeeze(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        starts = make_tensor_value_info("starts", TensorProto.INT64, [None])
+        ends = make_tensor_value_info("ends", TensorProto.INT64, [None])
+        axes = make_tensor_value_info("axes", TensorProto.INT64, [None])
+        Y = make_tensor_value_info("Y", TensorProto.INT64, [None])
+        nodes = [
+            make_node("Slice", ["X", "starts", "ends", "axes"], ["T"]),
+            make_node("Squeeze", ["T", "axes"], ["Y"]),
+        ]
+        graph = make_graph(nodes, "g", [X, starts, ends, axes], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        feeds = {
+            "X": np.array([[0]], dtype=np.int64),
+            "starts": np.array([0], dtype=np.int64),
+            "ends": np.array([1], dtype=np.int64),
+            "axes": np.array([0], dtype=np.int64),
+        }
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        expected = np.array([0], dtype=np.int64)
+        assert got1[0].tolist() == expected.tolist()
+
+    def test_slice_squeeze_6(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.INT64, [None])
+        nodes = [
+            make_node("Slice", ["X"], ["T"], axes=[0], starts=[0], ends=[1]),
+            make_node("Squeeze", ["T"], ["Y"], axes=[0]),
+        ]
+        graph = make_graph(nodes, "g", [X], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 6)])
+        feeds = {"X": np.array([[0]], dtype=np.int64)}
+        ref1 = ReferenceEvaluator(onnx_model)
+        got1 = ref1.run(None, feeds)
+        expected = np.array([0], dtype=np.int64)
+        assert got1[0].tolist() == expected.tolist()
+
+    def test_onnxrt_reduce_mean(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None])
+        node1 = make_node("ReduceMean", ["X"], ["Y"])
+        graph = make_graph([node1], "g", [X], [Y])
+
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 17)])
+        check_model(onnx_model)
+        sess = ReferenceEvaluator(onnx_model)
+        cls = sess.rt_nodes_[0]
+        assert cls.__class__.__name__ == "ReduceMean_1"
+        got = sess.run(None, {"X": np.ones((2, 4), dtype=np.float32)})[0]
+        assert got.shape == (1, 1)
+        assert got[0, 0] == 1
+
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        check_model(onnx_model)
+        sess = ReferenceEvaluator(onnx_model)
+        cls = sess.rt_nodes_[0]
+        assert cls.__class__.__name__ == "ReduceMean_18"
+        got = sess.run(None, {"X": np.ones((2, 4), dtype=np.float32)})[0]
+        assert got.shape == (1, 1)
+        assert got[0, 0] == 1
+
+    @staticmethod
+    def _cdist_model(opset, reduce_op="ReduceSumSquare"):
+        # subgraph
+        initializers = []
+
+        inputs = [
+            make_tensor_value_info("next_in", TensorProto.FLOAT, [None, 4]),
+            make_tensor_value_info("next", TensorProto.FLOAT, [None]),
+        ]
+
+        outputs = [
+            make_tensor_value_info("next_out", TensorProto.FLOAT, [None, None]),
+            make_tensor_value_info("scan_out", TensorProto.FLOAT, [None]),
+        ]
+
+        if opset >= 18:
+            initializers.append(
+                from_array(np.array([1], dtype=np.int64), name="axis_red")
+            )
+            node_reduce = make_node(
+                reduce_op,
+                ["cdistdf_17_C0", "axis_red"],
+                ["cdistdf_17_reduced0"],
+                name="cdistdf_17_ReduceSumSquare",
+                keepdims=0,
+            )
+        else:
+            node_reduce = make_node(
+                reduce_op,
+                ["cdistdf_17_C0"],
+                ["cdistdf_17_reduced0"],
+                name="cdistdf_17_ReduceSumSquare",
+                axes=[1],
+                keepdims=0,
+            )
+
+        nodes = [
+            make_node("Identity", ["next_in"], ["next_out"], name="cdistd_17_Identity"),
+            make_node(
+                "Sub", ["next_in", "next"], ["cdistdf_17_C0"], name="cdistdf_17_Sub"
+            ),
+            node_reduce,
+            make_node(
+                "Identity",
+                ["cdistdf_17_reduced0"],
+                ["scan_out"],
+                name="cdistdf_17_Identity",
+            ),
+        ]
+        graph = make_graph(nodes, "OnnxIdentity", inputs, outputs, initializers)
+
+        # main graph
+        initializers = []
+
+        list_value = [
+            1.1394007205963135,
+            -0.6848101019859314,
+            -1.234825849533081,
+            0.4023416340351105,
+            0.17742614448070526,
+            0.46278226375579834,
+            -0.4017809331417084,
+            -1.630198359489441,
+            -0.5096521973609924,
+            0.7774903774261475,
+            -0.4380742907524109,
+            -1.2527953386306763,
+            -1.0485529899597168,
+            1.950775384902954,
+            -1.420017957687378,
+            -1.7062702178955078,
+            1.8675580024719238,
+            -0.15135720372200012,
+            -0.9772778749465942,
+            0.9500884413719177,
+            -2.5529897212982178,
+            -0.7421650290489197,
+            0.653618574142456,
+            0.8644362092018127,
+            1.5327792167663574,
+            0.37816253304481506,
+            1.4693588018417358,
+            0.154947429895401,
+            -0.6724604368209839,
+            -1.7262825965881348,
+            -0.35955315828323364,
+            -0.8131462931632996,
+            -0.8707971572875977,
+            0.056165341287851334,
+            -0.5788496732711792,
+            -0.3115525245666504,
+            1.2302906513214111,
+            -0.302302747964859,
+            1.202379822731018,
+            -0.38732680678367615,
+            2.269754648208618,
+            -0.18718385696411133,
+            -1.4543657302856445,
+            0.04575851559638977,
+            -0.9072983860969543,
+            0.12898291647434235,
+            0.05194539576768875,
+            0.7290905714035034,
+            1.4940791130065918,
+            -0.8540957570075989,
+            -0.2051582634449005,
+            0.3130677044391632,
+            1.764052391052246,
+            2.2408931255340576,
+            0.40015721321105957,
+            0.978738009929657,
+            0.06651721894741058,
+            -0.3627411723136902,
+            0.30247190594673157,
+            -0.6343221068382263,
+            -0.5108051300048828,
+            0.4283318817615509,
+            -1.18063223361969,
+            -0.02818222902715206,
+            -1.6138978004455566,
+            0.38690251111984253,
+            -0.21274028718471527,
+            -0.8954665660858154,
+            0.7610377073287964,
+            0.3336743414402008,
+            0.12167501449584961,
+            0.44386324286460876,
+            -0.10321885347366333,
+            1.4542734622955322,
+            0.4105985164642334,
+            0.14404356479644775,
+            -0.8877857327461243,
+            0.15634897351264954,
+            -1.980796456336975,
+            -0.34791216254234314,
+        ]
+        initializers.append(
+            from_array(
+                np.array(list_value, dtype=np.float32).reshape((20, 4)),
+                name="Sc_Scancst",
+            )
+        )
+        initializers.append(
+            from_array(np.array([2], dtype=np.int64), name="To_TopKcst")
+        )
+
+        inputs = [make_tensor_value_info("input", TensorProto.FLOAT, [None, 4])]
+        outputs = [
+            make_tensor_value_info("values", TensorProto.FLOAT, [None, 2]),
+            make_tensor_value_info("indices", TensorProto.INT64, [None, 2]),
+        ]
+
+        # nodes
+
+        nodes = [
+            make_node(
+                "Scan",
+                ["input", "Sc_Scancst"],
+                ["UU032UU", "UU033UU"],
+                name="Sc_Scan",
+                body=graph,
+                num_scan_inputs=1,
+            ),
+            make_node(
+                "Transpose",
+                ["UU033UU"],
+                ["Tr_transposed0"],
+                name="Tr_Transpose",
+                perm=[1, 0],
+            ),
+            make_node("Sqrt", ["Tr_transposed0"], ["Sq_Y0"], name="Sq_Sqrt"),
+            make_node(
+                "TopK",
+                ["Sq_Y0", "To_TopKcst"],
+                ["values", "indices"],
+                name="To_TopK",
+                largest=0,
+                sorted=1,
+            ),
+        ]
+
+        graph = make_graph(nodes, "dummy", inputs, outputs, initializers)
+
+        # model
+        return make_model(graph, opset_imports=[make_opsetid("", opset)])
+
+    @pytest.mark.parametrize("opset", [17, 18])
+    @pytest.mark.parametrize(
+        "reduce_op_expected",
+        [
+            (
+                "ReduceMin",
+                [
+                    np.array(
+                        [[np.nan, np.nan], [14.422706, 18.80527]], dtype=np.float32
+                    ),
+                    np.array([[2, 15], [10, 4]], dtype=np.int64),
+                ],
+            ),
+            (
+                "ReduceL1",
+                [
+                    np.array(
+                        [[2.2367053, 2.3516612], [4.076292, 4.2970634]],
+                        dtype=np.float32,
+                    ),
+                    np.array([[18, 6], [13, 6]], dtype=np.int64),
+                ],
+            ),
+            (
+                "ReduceL2",
+                [
+                    np.array(
+                        [[1.80155, 1.8169948], [2.9928076, 3.1205883]],
+                        dtype=np.float32,
+                    ),
+                    np.array([[11, 18], [13, 6]], dtype=np.int64),
+                ],
+            ),
+            (
+                "ReduceLogSum",
+                [
+                    np.array(
+                        [[0.9497848, 1.1872643], [1.6764175, 1.70759]],
+                        dtype=np.float32,
+                    ),
+                    np.array([[6, 18], [13, 6]], dtype=np.int64),
+                ],
+            ),
+            (
+                "ReduceLogSumExp",
+                [
+                    np.array(
+                        [[1.6005973, 1.7445935], [2.5616229, 2.6539795]],
+                        dtype=np.float32,
+                    ),
+                    np.array([[13, 6], [13, 6]], dtype=np.int64),
+                ],
+            ),
+            (
+                "ReduceMax",
+                [
+                    np.array(
+                        [[1.4217108, 1.5069536], [2.453826, 2.5041783]],
+                        dtype=np.float32,
+                    ),
+                    np.array([[13, 11], [13, 11]], dtype=np.int64),
+                ],
+            ),
+            (
+                "ReduceMean",
+                [
+                    np.array(
+                        [[0.39247903, 0.78497636], [2.038146, 2.1485317]],
+                        dtype=np.float32,
+                    ),
+                    np.array([[13, 6], [13, 6]], dtype=np.int64),
+                ],
+            ),
+            (
+                "ReduceSumSquare",
+                [
+                    np.array(
+                        [[3.2455828, 3.3014696], [8.956896, 9.7380705]],
+                        dtype=np.float32,
+                    ),
+                    np.array([[11, 18], [13, 6]], dtype=np.int64),
+                ],
+            ),
+            (
+                "ReduceProd",
+                [
+                    np.array(
+                        [[np.nan, np.nan], [14.422706, 18.80527]], dtype=np.float32
+                    ),
+                    np.array([[2, 15], [13, 6]], dtype=np.int64),
+                ],
+            ),
+        ],
+    )
+    def test_op_reduce(self, reduce_op_expected, opset: int):
+        reduce_op, expected = reduce_op_expected
+        X = np.arange(8).reshape((-1, 4)).astype(np.float32)
+
+        results = {}
+
+        model = self._cdist_model(opset, reduce_op)
+        sess = ReferenceEvaluator(model)
+        got = sess.run(None, {"input": X})
+        results["ref", opset] = got
+
+        cl = [
+            n
+            for n in sess.rt_nodes_[0].body.rt_nodes_
+            if n.__class__.__name__.startswith(reduce_op)
+        ]
+        schema = cl[0]._schema
+        new_cl = type(reduce_op, (cl[0].__class__,), {"op_schema": schema})
+        sess = ReferenceEvaluator(model, new_ops=[new_cl])
+        got = sess.run(None, {"input": X})
+        results["ref_cl", opset] = got
+
+        baseline = "constant"
+        for k, v in results.items():
+            for a, b in zip(reversed(expected), reversed(v), strict=True):
+                if a.shape != b.shape:
+                    raise AssertionError(
+                        f"Shape mismatch for {reduce_op!r}, {baseline}:{a.shape} != {k}:{b.shape}."
+                    )
+                diff = np.abs(a - b).max()
+                if diff > 1e-6:
+                    raise AssertionError(
+                        f"Discrepancies (max={diff}) for {reduce_op!r}, {baseline} != {k}\n{a}\n!=\n{b}"
+                    )
+
+    @pytest.mark.parametrize("opset", [13, 17, 18])
+    def test_mvn(self, opset: int, ref_opset: int = 13):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None, None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None, None])
+        nodes = [
+            make_node("MeanVarianceNormalization", ["X"], ["Y"]),
+        ]
+        graph = make_graph(nodes, "g", [X], [Y])
+        x = np.random.rand(3, 3, 3, 1).astype(np.float32)
+
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", opset)])
+        ref = ReferenceEvaluator(onnx_model)
+        got = ref.run(None, {"X": x})[0]
+
+        ref_onnx_model = make_model(graph, opset_imports=[make_opsetid("", ref_opset)])
+        ref_expected = ReferenceEvaluator(ref_onnx_model)
+        expected = ref_expected.run(None, {"X": x})[0]
+
+        assert got.shape == expected.shape
+        assert_allclose(got, expected)
+
+    def test_concat_in_a_function(self):
+        def create_model():
+            nodes = []
+            inputs = []
+            outputs = []
+            functions = []
+
+            opsets = {"": onnx_opset_version(), "custom_domain": 1}
+            nodes_fct = []
+            node = make_node("Concat", ["x:0", "x:1"], ["r__0"], axis=0, domain="")
+            nodes_fct.append(node)
+
+            opset_imports_fct = [
+                make_opsetid(domain, 1 if version is None else version)
+                for domain, version in opsets.items()
+            ]
+            fct = make_function(
+                "custom_domain",
+                "concat_2",
+                ["x:0", "x:1"],
+                ["r__0"],
+                nodes_fct,
+                opset_imports_fct,
+            )
+            functions.append(fct)
+
+            inputs.append(make_tensor_value_info("I__0", TensorProto.DOUBLE, []))
+            inputs.append(make_tensor_value_info("I__1", TensorProto.DOUBLE, []))
+            inputs.append(make_tensor_value_info("I__2", TensorProto.DOUBLE, []))
+            outputs.append(make_tensor_value_info("r__4", TensorProto.DOUBLE, []))
+
+            node = make_node(
+                "concat_2", ["I__0", "I__1"], ["r__3"], axis=0, domain="custom_domain"
+            )
+            nodes.append(node)
+            node = make_node(
+                "concat_2", ["I__2", "r__3"], ["r__4"], axis=0, domain="custom_domain"
+            )
+            nodes.append(node)
+            opset_imports = [
+                make_opsetid(domain, 1 if version is None else version)
+                for domain, version in opsets.items()
+            ]
+
+            graph = make_graph(nodes, "numpyx", inputs, outputs)
+
+            return make_model(graph, opset_imports=opset_imports, functions=functions)
+
+        onnx_model = create_model()
+        x1 = np.array([[-5, 6], [15, 3]], dtype=np.float64)
+        x2 = np.array([[1, 2]], dtype=np.float64)
+        x3 = np.array([[-1, -2]], dtype=np.float64)
+        z = np.vstack([x1, x2, x3])
+        ref = ReferenceEvaluator(onnx_model)
+        feeds = {"I__2": x1, "I__0": x2, "I__1": x3}
+        got = ref.run(None, feeds)
+        assert_allclose(z, got[0])
+
+    def test_cast_float_to_string(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.STRING, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["Y"], to=TensorProto.STRING),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([1.152512, -0.152612, 0.0, np.nan])
+        got = ref.run(None, {"X": data})[0]
+        assert (
+            got == np.array([1.152512, -0.152612, 0.0, np.nan]).astype(np.str_)
+        ).all()
+
+    def test_cast_float_to_string_and_back(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["Z"], to=TensorProto.STRING),
+                    make_node("Cast", ["Z"], ["Y"], to=TensorProto.FLOAT),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([1.152512, -0.152612, 0.0, np.nan])
+        got = ref.run(None, {"X": data})[0]
+        assert_allclose(got, np.array([1.152512, -0.152612, 0.0, np.nan]))
+
+    def test_split_to_sequence(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, None)
+        Y = make_tensor_value_info("Y", TensorProto.INT64, None)
+        Z = make_tensor_value_info("Z", TensorProto.UNDEFINED, None)
+        nodes = [make_node("SplitToSequence", ["X", "Y"], ["Z"], axis=2)]
+        model = make_model(make_graph(nodes, "g", [X, Y], [Z]))
+        ref = ReferenceEvaluator(model)
+        data = np.arange(18).reshape((1, 3, 6)).astype(np.float32)
+        indices = np.array(2, dtype=np.int64)
+        got = ref.run(None, {"X": data, "Y": indices})
+        expected = [
+            [
+                np.array([[[0.0, 1.0], [6.0, 7.0], [12.0, 13.0]]], dtype=np.float32),
+                np.array([[[2.0, 3.0], [8.0, 9.0], [14.0, 15.0]]], dtype=np.float32),
+                np.array([[[4.0, 5.0], [10.0, 11.0], [16.0, 17.0]]], dtype=np.float32),
+            ]
+        ]
+        assert len(expected[0]) == len(got[0])
+        for a, b in zip(expected[0], got[0], strict=True):
+            assert_allclose(a, b)
+
+    def test_split_to_sequence_1d(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, None)
+        Y = make_tensor_value_info("Y", TensorProto.INT64, None)
+        Z = make_tensor_value_info("Z", TensorProto.UNDEFINED, None)
+        nodes = [make_node("SplitToSequence", ["X", "Y"], ["Z"], axis=2)]
+        model = make_model(make_graph(nodes, "g", [X, Y], [Z]))
+        ref = ReferenceEvaluator(model)
+        data = np.arange(18).reshape((1, 3, 6)).astype(np.float32)
+        indices = np.array([2, 2, 2], dtype=np.int64)
+        got = ref.run(None, {"X": data, "Y": indices})
+        expected = [
+            [
+                np.array([[[0.0, 1.0], [6.0, 7.0], [12.0, 13.0]]], dtype=np.float32),
+                np.array([[[2.0, 3.0], [8.0, 9.0], [14.0, 15.0]]], dtype=np.float32),
+                np.array([[[4.0, 5.0], [10.0, 11.0], [16.0, 17.0]]], dtype=np.float32),
+            ]
+        ]
+        assert len(expected[0]) == len(got[0])
+        for a, b in zip(expected[0], got[0], strict=True):
+            assert_allclose(a, b)
+
+    def test_split_to_sequence_nokeepdims_noinput(self):
+        # keepdims is ignored in that case
+        X = make_tensor_value_info("X", TensorProto.FLOAT, None)
+        Z = make_tensor_value_info("Z", TensorProto.UNDEFINED, None)
+        nodes = [make_node("SplitToSequence", ["X"], ["Z"], axis=2, keepdims=0)]
+        model = make_model(make_graph(nodes, "g", [X], [Z]))
+        ref = ReferenceEvaluator(model)
+        data = np.arange(18).reshape((1, 3, 6)).astype(np.float32)
+        got = ref.run(None, {"X": data})
+        expected = [[data[:, :, i] for i in range(data.shape[2])]]
+        assert len(expected[0]) == len(got[0])
+        for a, b in zip(expected[0], got[0], strict=True):
+            assert_allclose(a, b)
+
+    def test_cast_float8(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        F1 = make_tensor_value_info("F1", TensorProto.FLOAT, [None])
+        F2 = make_tensor_value_info("F2", TensorProto.FLOAT, [None])
+        F3 = make_tensor_value_info("F3", TensorProto.FLOAT, [None])
+        F4 = make_tensor_value_info("F4", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["f81"], to=TensorProto.FLOAT8E4M3FN),
+                    make_node("Cast", ["X"], ["f82"], to=TensorProto.FLOAT8E5M2),
+                    make_node(
+                        "Constant",
+                        [],
+                        ["C1"],
+                        value=make_tensor(
+                            "C1", TensorProto.FLOAT8E4M3FN, [5], [0, 1, 2, 5e-2, 200]
+                        ),
+                    ),
+                    make_node(
+                        "Constant",
+                        [],
+                        ["C2"],
+                        value=make_tensor(
+                            "C2", TensorProto.FLOAT8E5M2, [5], [0, 1, 2, 5e-2, 200]
+                        ),
+                    ),
+                    make_node("Cast", ["f81"], ["F1"], to=TensorProto.FLOAT),
+                    make_node("Cast", ["f82"], ["F2"], to=TensorProto.FLOAT),
+                    make_node("Cast", ["C1"], ["F3"], to=TensorProto.FLOAT),
+                    make_node("Cast", ["C2"], ["F4"], to=TensorProto.FLOAT),
+                ],
+                "g",
+                [X],
+                [F1, F2, F3, F4],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([0, 1, 2, 5e-2, 200], dtype=np.float32)
+        expected1 = onnx.numpy_helper.saturate_cast(
+            data, ml_dtypes.float8_e4m3fn
+        ).astype(np.float32)
+        expected2 = onnx.numpy_helper.saturate_cast(data, ml_dtypes.float8_e5m2).astype(
+            np.float32
+        )
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected1)
+        assert_allclose(got[1], expected2)
+        assert_allclose(got[2], expected1)
+        assert_allclose(got[3], expected2)
+
+    @pytest.mark.skipif(
+        version_utils.numpy_older_than("2.0"),
+        reason="assert_allclose does not support ml_dtypes in numpy < 2.0",
+    )
+    def test_cast_like_float8(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["f8"], to=TensorProto.FLOAT8E4M3FNUZ),
+                    make_node("CastLike", ["X", "f8"], ["f32"], saturate=0),
+                    make_node("Cast", ["f32"], ["Y"], to=TensorProto.FLOAT),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        data = np.array([0, 1e7], dtype=np.float32)
+        expected = data.astype(ml_dtypes.float8_e4m3fnuz)
+        ref = ReferenceEvaluator(model)
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected)
+
+        # Forces ReferenceEvaluator to not use the associated implementation for CastLike
+        # but its implementation as a function instead.
+        class CastLike(OpRunExpand):
+            op_domain = ""
+
+        ref = ReferenceEvaluator(model, new_ops=[CastLike])
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected)
+
+    def test_cast_float8_output(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        F1 = make_tensor_value_info("F1", TensorProto.FLOAT8E4M3FN, [None])
+        F2 = make_tensor_value_info("F2", TensorProto.FLOAT8E5M2, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["F1"], to=TensorProto.FLOAT8E4M3FN),
+                    make_node("Cast", ["X"], ["F2"], to=TensorProto.FLOAT8E5M2),
+                ],
+                "g",
+                [X],
+                [F1, F2],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([0, 1, 2, 5e-2, 200], dtype=np.float32)
+        expected1 = onnx.numpy_helper.saturate_cast(data, ml_dtypes.float8_e4m3fn)
+        expected2 = onnx.numpy_helper.saturate_cast(data, ml_dtypes.float8_e5m2)
+        got = ref.run(None, {"X": data})
+        assert got[0].tolist() == expected1.tolist()
+        assert got[1].tolist() == expected2.tolist()
+
+    @pytest.mark.parametrize(
+        "to, expected",
+        [
+            (
+                TensorProto.FLOAT8E4M3FN,
+                np.array(
+                    [
+                        0.40625,
+                        352.0,
+                        416.0,
+                        320.0,
+                        320.0,
+                        256.0,
+                        -256.0,
+                        -96.0,
+                        0.0,
+                        0.009765625,
+                        416.0,
+                        448.0,
+                        448.0,
+                        448.0,
+                        -448.0,
+                        np.nan,
+                    ],
+                    dtype=np.float32,
+                ),
+            ),
+            (
+                TensorProto.FLOAT8E4M3FNUZ,
+                np.array(
+                    [
+                        0.40625,
+                        240.0,
+                        240.0,
+                        240.0,
+                        240.0,
+                        240.0,
+                        -240.0,
+                        -96.0,
+                        0.0,
+                        0.009765625,
+                        240.0,
+                        240.0,
+                        240.0,
+                        240.0,
+                        -240.0,
+                        np.nan,
+                    ],
+                    dtype=np.float32,
+                ),
+            ),
+            (
+                TensorProto.FLOAT8E5M2,
+                np.array(
+                    [
+                        0.4375,
+                        384.0,
+                        384.0,
+                        320.0,
+                        320.0,
+                        256.0,
+                        -256.0,
+                        -96.0,
+                        0.0001068115234375,
+                        0.009765625,
+                        384.0,
+                        448.0,
+                        57344.0,
+                        57344.0,
+                        -57344.0,
+                        np.nan,
+                    ],
+                    dtype=np.float32,
+                ),
+            ),
+            (
+                TensorProto.FLOAT8E5M2FNUZ,
+                np.array(
+                    [
+                        4.3750000e-01,
+                        3.8400000e02,
+                        3.8400000e02,
+                        3.2000000e02,
+                        3.2000000e02,
+                        2.5600000e02,
+                        -2.5600000e02,
+                        -9.6000000e01,
+                        1.0681152e-04,
+                        9.7656250e-03,
+                        3.8400000e02,
+                        4.4800000e02,
+                        5.7344000e04,
+                        5.7344000e04,
+                        -5.7344000e04,
+                        np.nan,
+                    ],
+                    dtype=np.float32,
+                ),
+            ),
+        ],
+    )
+    def test_float8_4_types(self, to, expected):
+        x = np.array(
+            [
+                0.4068359375,
+                352,
+                416,
+                336,
+                304,
+                272,
+                -248,
+                -100,
+                1e-4,
+                1e-2,
+                416,
+                432,
+                1e5,
+                np.inf,
+                -np.inf,
+                np.nan,
+            ],
+            dtype=np.float32,
+        )
+
+        def model_cast_cast(to):
+            X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+            Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+            node1 = make_node("Cast", ["X"], ["T"], to=to)
+            node2 = make_node("Cast", ["T"], ["Y"], to=TensorProto.FLOAT)
+            graph = make_graph([node1, node2], "lr", [X], [Y])
+            onnx_model = make_model(graph)
+            check_model(onnx_model)
+            return onnx_model
+
+        onnx_model = model_cast_cast(to)
+        ref = ReferenceEvaluator(onnx_model)
+        (y,) = ref.run(None, {"X": x})
+        assert_allclose(y, expected)
+        assert y.shape == expected.shape
+        assert y.dtype == expected.dtype
+
+    def test_cast_bfloat16_output(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.BFLOAT16, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["Y"], to=TensorProto.BFLOAT16),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([0, 1, 2, 1e5, 200], dtype=np.float32)
+        expected = data.astype(ml_dtypes.bfloat16)
+        got = ref.run(None, {"X": data})
+        np.testing.assert_array_equal(got[0], expected)
+
+    def test_quantize_linear_e4m3(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node(
+                        "Constant",
+                        [],
+                        ["scale"],
+                        value=make_tensor("scale", TensorProto.FLOAT, [1], [2.0]),
+                    ),
+                    make_node(
+                        "Constant",
+                        [],
+                        ["zero"],
+                        value=make_tensor("zero", TensorProto.FLOAT8E4M3FN, [1], [0.0]),
+                    ),
+                    make_node("QuantizeLinear", ["X", "scale", "zero"], ["T"]),
+                    make_node("DequantizeLinear", ["T", "scale"], ["Y"], axis=0),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([0, 1, 2, 1e5, 200], dtype=np.float32)
+        expected = np.array([0, 1, 2, 896, 192], dtype=np.float32)
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected)
+
+    def test_quantize_linear_e4m3_initializer(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("QuantizeLinear", ["X", "scale", "zero"], ["T"]),
+                    make_node("DequantizeLinear", ["T", "scale"], ["Y"], axis=0),
+                ],
+                "g",
+                [X],
+                [Y],
+                [
+                    make_tensor("scale", TensorProto.FLOAT, [1], [2.0]),
+                    make_tensor("zero", TensorProto.FLOAT8E4M3FN, [1], [0.0]),
+                ],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([0, 1, 2, 1e5, 200], dtype=np.float32)
+        expected = np.array([0, 1, 2, 896, 192], dtype=np.float32)
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected)
+
+    def test_quantize_linear_e5m2(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node(
+                        "Constant",
+                        [],
+                        ["scale"],
+                        value=make_tensor("scale", TensorProto.FLOAT, [1], [2.0]),
+                    ),
+                    make_node(
+                        "Constant",
+                        [],
+                        ["zero"],
+                        value=make_tensor("zero", TensorProto.FLOAT8E5M2, [1], [0.0]),
+                    ),
+                    make_node("QuantizeLinear", ["X", "scale", "zero"], ["T"]),
+                    make_node("DequantizeLinear", ["T", "scale"], ["Y"], axis=0),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([0, 1, 2, 1e5, 200], dtype=np.float32)
+        expected = np.array([0, 1, 2, 98304, 192], dtype=np.float32)
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected)
+
+    def test_quantize_linear_uint16(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.UINT16, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("QuantizeLinear", ["X", "scale", "zero"], ["Y"]),
+                ],
+                "g",
+                [X],
+                [Y],
+                [
+                    make_tensor("scale", TensorProto.FLOAT, [1], [2.0]),
+                    make_tensor("zero", TensorProto.UINT16, [1], [32767]),
+                ],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array(
+            [
+                # rounding half to even
+                0.0,
+                -128.0,
+                3.0,
+                -3.0,
+                # round < .5
+                2.9,
+                -2.9,
+                # round > .5
+                3.1,
+                -3.1,
+                # critical point
+                65536.0,
+                -65534.0,
+                # saturate case
+                70000.0,
+                -70000.0,
+            ],
+            dtype=np.float32,
+        )
+        expected = np.array(
+            [
+                32767,
+                32703,
+                32769,
+                32765,
+                32768,
+                32766,
+                32769,
+                32765,
+                65535,
+                0,
+                65535,
+                0,
+            ],
+            dtype=np.uint16,
+        )
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected)
+
+    def test_quantize_linear_int16(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.INT16, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("QuantizeLinear", ["X", "scale", "zero"], ["Y"]),
+                ],
+                "g",
+                [X],
+                [Y],
+                [
+                    make_tensor("scale", TensorProto.FLOAT, [1], [2.0]),
+                    make_tensor("zero", TensorProto.INT16, [1], [256]),
+                ],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array(
+            [
+                # rounding half to even
+                0.0,
+                -514.0,
+                3.0,
+                -3.0,
+                # round < .5
+                2.9,
+                -2.9,
+                # round > .5
+                3.1,
+                -3.1,
+                # critical point
+                65022.0,
+                -66046.0,
+                65023.0,
+                -66047.0,
+                65024.0,
+                -66048.0,
+                # saturate case
+                70000.0,
+                -70000.0,
+            ],
+            dtype=np.float32,
+        )
+        expected = np.array(
+            [
+                256,
+                -1,
+                258,
+                254,
+                257,
+                255,
+                258,
+                254,
+                32767,
+                -32767,
+                32767,
+                -32768,
+                32767,
+                -32768,
+                32767,
+                -32768,
+            ],
+            dtype=np.int16,
+        )
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected)
+
+    def test_dequantize_linear_uint16(self):
+        X = make_tensor_value_info("X", TensorProto.UINT16, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node(
+                        "DequantizeLinear", ["X", "scale", "zero"], ["Y"], axis=0
+                    ),
+                ],
+                "g",
+                [X],
+                [Y],
+                [
+                    make_tensor("scale", TensorProto.FLOAT, [1], [2.0]),
+                    make_tensor("zero", TensorProto.UINT16, [1], [32767]),
+                ],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([30000, 31000, 32768, 33000], dtype=np.uint16)
+        expected = np.array([-5534.0, -3534.0, 2.0, 466.0], dtype=np.float32)
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected)
+
+    def test_dequantize_linear_int16(self):
+        X = make_tensor_value_info("X", TensorProto.INT16, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node(
+                        "DequantizeLinear", ["X", "scale", "zero"], ["Y"], axis=0
+                    ),
+                ],
+                "g",
+                [X],
+                [Y],
+                [
+                    make_tensor("scale", TensorProto.FLOAT, [1], [2.0]),
+                    make_tensor("zero", TensorProto.INT16, [1], [-1024]),
+                ],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array([-300, -30, -1025, 1270], dtype=np.int16)
+        expected = np.array([1448.0, 1988.0, -2.0, 4588.0], dtype=np.float32)
+        got = ref.run(None, {"X": data})
+        assert_allclose(got[0], expected)
+
+    @pytest.mark.parametrize(
+        "x, scale, zero_point, axis, block_size, expected",
+        [
+            (
+                4 * np.arange(12).reshape(3, 4),
+                np.arange(1, 7).reshape(3, 2),
+                np.zeros((3, 2)),
+                1,
+                2,
+                [[0, 4, 4, 6], [5, 7, 6, 7], [6, 7, 7, 7]],
+            ),
+            (
+                4 * np.arange(12).reshape(3, 4),
+                np.arange(1, 7).reshape(3, 2),
+                np.ones((3, 2)),
+                1,
+                2,
+                [[1, 5, 5, 7], [6, 8, 7, 8], [7, 8, 8, 8]],
+            ),
+            (
+                np.arange(24).reshape(3, 8),
+                [[0.25, 0.5, 1], [0.25, 0.5, 1], [0.25, 0.5, 1]],
+                np.zeros((3, 3)),
+                1,
+                3,
+                [
+                    [0, 4, 8, 6, 8, 10, 6, 7],
+                    [32, 36, 40, 22, 24, 26, 14, 15],
+                    [64, 68, 72, 38, 40, 42, 22, 23],
+                ],
+            ),
+            (
+                np.arange(6),
+                [0.25, 0.5],
+                [-1, -2],
+                0,
+                3,
+                [-1, 3, 7, 4, 6, 8],
+            ),
+            (
+                np.ones((9, 12)),
+                np.ones((3, 4)),
+                np.zeros((3, 4)),
+                0,
+                3,
+                None,  # Blocked quantization is defined for 1-D blocks only
+            ),
+            (
+                np.ones((3, 4, 5, 6)),
+                np.ones((3, 4)),
+                np.zeros((3, 4)),
+                2,
+                2,
+                None,  # Scale and ZP must have the same rank as the input
+            ),
+        ],
+    )
+    def test_blocked_quantize_linear(
+        self, x, scale, zero_point, axis, block_size, expected
+    ):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.INT8, [None])
+
+        scale_data = np.array(scale, dtype=np.float32)
+        zp_data = np.array(zero_point, dtype=np.int8)
+        model = make_model(
+            make_graph(
+                [
+                    make_node(
+                        "QuantizeLinear",
+                        ["X", "scale", "zero"],
+                        ["Y"],
+                        axis=axis,
+                        block_size=block_size,
+                    ),
+                ],
+                "g",
+                [X],
+                [Y],
+                [
+                    make_tensor(
+                        "scale", TensorProto.FLOAT, scale_data.shape, scale_data
+                    ),
+                    make_tensor("zero", TensorProto.INT8, scale_data.shape, zp_data),
+                ],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+
+        data = np.array(x, dtype=np.float32)
+
+        if expected is not None:
+            expected = np.array(expected, dtype=np.int8)
+            got = ref.run(None, {"X": data})
+            assert_allclose(got[0], expected)
+        else:
+            with pytest.raises(ValueError):
+                ref.run(None, {"X": data})
+
+    @pytest.mark.parametrize(
+        "x, scale, zero_point, axis, block_size, expected",
+        [
+            (
+                np.arange(12).reshape(3, 4),
+                np.arange(1, 7).reshape(3, 2),
+                np.zeros((3, 2)),
+                1,
+                2,
+                [[0, 1, 4, 6], [12, 15, 24, 28], [40, 45, 60, 66]],
+            ),
+            (
+                np.arange(12).reshape(3, 4),
+                np.arange(1, 7).reshape(3, 2),
+                np.ones((3, 2)),
+                1,
+                2,
+                [[-1, 0, 2, 4], [9, 12, 20, 24], [35, 40, 54, 60]],
+            ),
+            (
+                np.dstack([np.arange(4).reshape(2, 2)] * 4),
+                np.dstack([np.array([[1, 1], [2, 3]]), np.array([[4, 5], [6, 7]])]),
+                np.zeros((2, 2, 2)),
+                2,
+                2,
+                [[[0, 0, 0, 0], [1, 1, 5, 5]], [[4, 4, 12, 12], [9, 9, 21, 21]]],
+            ),
+            (
+                np.arange(24).reshape(3, 8),
+                [[2, 1, 3], [2, 1, 3], [2, 1, 3]],
+                np.zeros((3, 3)),
+                1,
+                3,
+                [
+                    [0, 2, 4, 3, 4, 5, 18, 21],
+                    [16, 18, 20, 11, 12, 13, 42, 45],
+                    [32, 34, 36, 19, 20, 21, 66, 69],
+                ],
+            ),
+            (
+                np.arange(
+                    6,
+                ),
+                [2, 3],
+                [1, 2],
+                0,
+                3,
+                [-2, 0, 2, 3, 6, 9],
+            ),
+            (
+                np.ones((9, 12)),
+                np.ones((3, 4)),
+                np.zeros((3, 4)),
+                0,
+                3,
+                None,  # Blocked quantization is defined for 1-D blocks only
+            ),
+            (
+                np.ones((3, 4, 5, 6)),
+                np.ones((3, 4)),
+                np.zeros((3, 4)),
+                2,
+                2,
+                None,  # Scale and ZP must have the same rank as the input
+            ),
+        ],
+    )
+    def test_blocked_dequantize_linear(
+        self, x, scale, zero_point, axis, block_size, expected
+    ):
+        X = make_tensor_value_info("X", TensorProto.INT8, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+
+        scale_data = np.array(scale, dtype=np.float32)
+        zp_data = np.array(zero_point, dtype=np.int8)
+        model = make_model(
+            make_graph(
+                [
+                    make_node(
+                        "DequantizeLinear",
+                        ["X", "scale", "zero"],
+                        ["Y"],
+                        axis=axis,
+                        block_size=block_size,
+                    ),
+                ],
+                "g",
+                [X],
+                [Y],
+                [
+                    make_tensor(
+                        "scale", TensorProto.FLOAT, scale_data.shape, scale_data
+                    ),
+                    make_tensor("zero", TensorProto.INT8, scale_data.shape, zp_data),
+                ],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array(x, dtype=np.int8)
+
+        if expected is not None:
+            expected = np.array(expected, dtype=np.float32)
+            got = ref.run(None, {"X": data})
+            assert_allclose(got[0], expected)
+        else:
+            with pytest.raises(ValueError):
+                ref.run(None, {"X": data})
+
+    def test_lrn(self):
+        def _expected(x, alpha, beta, bias, size):
+            square_sum = np.zeros((5, 5, 5, 5)).astype(np.float32)
+            for n, c, h, w in np.ndindex(x.shape):
+                square_sum[n, c, h, w] = sum(
+                    x[
+                        n,
+                        max(0, c - math.floor((size - 1) / 2)) : min(
+                            5, c + math.ceil((size - 1) / 2) + 1
+                        ),
+                        h,
+                        w,
+                    ]
+                    ** 2
+                )
+            return x / ((bias + (alpha / size) * square_sum) ** beta)
+
+        # keepdims is ignored in that case
+        alpha = 0.0002
+        beta = 0.5
+        bias = 2.0
+        size = 3
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [5, 5, 50, 50])
+        Z = make_tensor_value_info("Z", TensorProto.UNDEFINED, None)
+        nodes = [
+            make_node("LRN", ["X"], ["Z"], alpha=alpha, beta=beta, bias=bias, size=size)
+        ]
+        model = make_model(make_graph(nodes, "g", [X], [Z]))
+        ref = ReferenceEvaluator(model)
+        data = np.random.rand(5, 5, 5, 5).astype(np.float32)
+        got = ref.run(None, {"X": data})
+        expected = _expected(data, alpha, beta, bias, size)
+        assert len(got[0]) == len(expected)
+
+    def test_conv_im2col_1d(self):
+        feeds = {
+            "X": np.arange(1 * 1 * 11).reshape((1, 1, 11)).astype(np.float32) + 1,
+            "W": np.arange(3).reshape((1, 1, 3)).astype(np.float32),
+            "B": np.zeros((1,), dtype=np.float32),
+        }
+        kwargs = dict(
+            group=1,
+            dilations=[1],
+            kernel_shape=[3],
+            pads=[1, 1],
+            strides=[1],
+            auto_pad="NOTSET",
+        )
+        expected = _conv_implementation(**feeds, **kwargs)
+        got = _conv_implementation_im2col(**feeds, **kwargs)
+        assert_allclose(got, expected)
+
+    def test_conv_im2col_1d_pad0(self):
+        feeds = {
+            "X": np.arange(2 * 4 * 3).reshape((2, 4, -1)).astype(np.float32) + 1,
+            "W": np.arange(2 * 4 * 3).reshape((-1, 4, 3)).astype(np.float32),
+            "B": np.zeros((1,), dtype=np.float32),
+        }
+        kwargs = dict(
+            group=1,
+            dilations=[1],
+            kernel_shape=[3],
+            pads=[0, 0],
+            strides=[1],
+            auto_pad="NOTSET",
+        )
+        expected = _conv_implementation(**feeds, **kwargs)
+        got = _conv_implementation_im2col(**feeds, **kwargs)
+        assert_allclose(got, expected)
+
+    def test_conv_im2col_2d(self):
+        feeds = {
+            "X": np.arange(1 * 1 * 11 * 23).reshape((1, 1, 11, 23)).astype(np.float32)
+            + 1,
+            "W": np.arange(9).reshape((1, 1, 3, 3)).astype(np.float32),
+            "B": np.zeros((1,), dtype=np.float32),
+        }
+        kwargs = dict(
+            group=1,
+            dilations=[1, 1],
+            kernel_shape=[3, 3],
+            pads=[1, 1, 1, 1],
+            strides=[1, 1],
+            auto_pad="NOTSET",
+        )
+        expected = _conv_implementation(**feeds, **kwargs)
+        got = _conv_implementation_im2col(**feeds, **kwargs)
+        assert_allclose(got, expected)
+
+    def test_conv_im2col_2d_pad0(self):
+        feeds = {
+            "X": np.arange(2 * 3 * 5 * 2).reshape((2, 3, 5, -1)).astype(np.float32) + 1,
+            "W": 2
+            ** np.arange(3 * 3 * 1 * 2).reshape((-1, 3, 1, 2)).astype(np.float32),
+            "B": np.zeros((1,), dtype=np.float32),
+        }
+        kwargs = dict(
+            group=1,
+            dilations=[1, 1],
+            kernel_shape=[1, 2],
+            pads=[0, 0, 0, 0],
+            strides=[1, 1],
+            auto_pad="NOTSET",
+        )
+        expected = _conv_implementation(**feeds, **kwargs)
+        got = _conv_implementation_im2col(**feeds, **kwargs)
+        assert_allclose(got, expected)
+
+    def test_conv_im2col_2d_autopad(self):
+        feeds = {
+            "X": np.arange(5 * 5).reshape((1, 1, 5, -1)).astype(np.float32) + 1,
+            "W": 2 ** np.arange(3 * 3).reshape((1, 1, 3, 3)).astype(np.float32),
+            "B": np.zeros((1,), dtype=np.float32),
+        }
+        kwargs = dict(
+            group=1,
+            dilations=[1, 1],
+            kernel_shape=[3, 3],
+            strides=[2, 2],
+            pads=None,
+            auto_pad="SAME_LOWER",
+        )
+        expected = _conv_implementation(**feeds, **kwargs)
+        got = _conv_implementation_im2col(**feeds, **kwargs)
+        assert_allclose(got, expected)
+
+    def test_conv_im2col_3d(self):
+        feeds = {
+            "X": np.arange(1 * 1 * 11 * 5 * 13)
+            .reshape((1, 1, 11, 5, 13))
+            .astype(np.float32)
+            + 1,
+            "W": np.arange(27).reshape((1, 1, 3, 3, 3)).astype(np.float32),
+            "B": np.zeros((1,), dtype=np.float32),
+        }
+        kwargs = dict(
+            group=1,
+            dilations=[1, 1, 1],
+            kernel_shape=[3, 3, 3],
+            pads=[1, 1, 1, 1, 1, 1],
+            strides=[1, 1, 1],
+            auto_pad="NOTSET",
+        )
+        expected = _conv_implementation(**feeds, **kwargs)
+        got = _conv_implementation_im2col(**feeds, **kwargs)
+        assert_allclose(got, expected)
+
+    def test_conv_im2col_2d_strides(self):
+        feeds = {
+            "X": np.arange(1 * 3 * 6 * 6).reshape((1, 3, 6, 6)).astype(np.float32) + 1,
+            "W": np.arange(2 * 3 * 3 * 3).reshape((2, 3, 3, 3)).astype(np.float32),
+            "B": np.zeros((2,), dtype=np.float32),
+        }
+        kwargs = dict(
+            group=1,
+            dilations=[1, 1],
+            kernel_shape=[3, 3],
+            pads=[1, 1, 1, 1],
+            strides=[2, 2],
+            auto_pad="NOTSET",
+        )
+        expected = _conv_implementation(**feeds, **kwargs)
+        got = _conv_implementation_im2col(**feeds, **kwargs)
+        assert_allclose(got, expected)
+
+    def test_conv_im2col_2d_dilations(self):
+        feeds = {
+            "X": np.arange(1 * 3 * 6 * 6).reshape((1, 3, 6, 6)).astype(np.float32) + 1,
+            "W": np.arange(2 * 3 * 3 * 3).reshape((2, 3, 3, 3)).astype(np.float32),
+            "B": np.zeros((2,), dtype=np.float32),
+        }
+        kwargs = dict(
+            group=1,
+            dilations=[2, 1],
+            kernel_shape=[3, 3],
+            pads=[1, 1, 1, 1],
+            strides=[2, 2],
+            auto_pad="NOTSET",
+        )
+        expected = _conv_implementation(**feeds, **kwargs)
+        got = _conv_implementation_im2col(**feeds, **kwargs)
+        assert_allclose(got, expected)
+
+    @pytest.mark.parametrize(
+        "op",
+        [
+            "ReduceSum",
+            "ReduceL1",
+            "ReduceL2",
+            "ReduceMin",
+            "ReduceMax",
+            "ReduceProd",
+            "ReduceSumSquare",
+        ],
+    )
+    def test_reduce_op_no_axis(self, op):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, None)
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, None)
+        data = np.arange(6).reshape((1, 3, 2)).astype(np.float32)
+        nodes = [make_node(op, ["X"], ["Y"], keepdims=0)]
+        model = make_model(make_graph(nodes, "g", [X], [Y]))
+        ref = ReferenceEvaluator(model)
+        got = ref.run(None, {"X": data})
+        r = got[0]
+        assert isinstance(r, np.ndarray)
+        assert r.shape == ()
+
+    @pytest.mark.parametrize("dim", [1, 2, 3, 4, 5, 6])
+    def test_pad(self, dim):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, None)
+        P = make_tensor_value_info("P", TensorProto.INT64, None)
+        V = make_tensor_value_info("V", TensorProto.FLOAT, None)
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, None)
+        value = np.array([-5], dtype=np.float32)
+
+        node = make_node("Pad", inputs=["X", "P", "V"], outputs=["Y"], mode="constant")
+        model = make_model(make_graph([node], "g", [X, P, V], [Y]))
+        ref = ReferenceEvaluator(model)
+        x = np.array([1], dtype=np.float32).reshape((1,) * dim)
+
+        p = np.array([1, 1] * dim, dtype=np.int64)
+        got = ref.run(None, {"X": x, "P": p, "V": value})[0]
+        assert got.shape == (3,) * dim
+        assert got.dtype == np.float32
+
+        p = np.repeat([7, 3], dim).astype(np.int64)
+        got = ref.run(None, {"X": x, "P": p, "V": value})[0]
+        assert got.shape == (11,) * dim
+        assert got.dtype == np.float32
+
+    def test_constant_of_shape(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, None)
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, None)
+
+        nodes = [
+            make_node("Shape", inputs=["X"], outputs=["shape"]),
+            make_node(
+                "ConstantOfShape",
+                inputs=["shape"],
+                outputs=["Y"],
+                value=make_tensor("value", TensorProto.UINT16, [1], [1]),
+            ),
+        ]
+        model = make_model(make_graph(nodes, "g", [X], [Y]))
+        ref = ReferenceEvaluator(model)
+        x = np.array(1, dtype=np.float32)
+        got = ref.run(None, {"X": x})[0]
+        assert got.shape == ()
+        assert got.dtype == np.uint16
+        assert_allclose(np.array(1, dtype=np.uint16), got)
+
+    def test_constant_of_shape_castlike(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, None)
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, None)
+
+        nodes = [
+            make_node(
+                "Constant",
+                [],
+                ["like"],
+                value=make_tensor("c", TensorProto.UINT16, [1], [2]),
+            ),
+            make_node("Shape", inputs=["X"], outputs=["shape"]),
+            make_node(
+                "ConstantOfShape",
+                inputs=["shape"],
+                outputs=["cst"],
+                value=make_tensor("value", TensorProto.INT64, [1], [1]),
+            ),
+            make_node("CastLike", ["cst", "like"], ["Y"]),
+        ]
+        model = make_model(make_graph(nodes, "g", [X], [Y]))
+        ref = ReferenceEvaluator(model)
+        x = np.array(1, dtype=np.float32)
+        got = ref.run(None, {"X": x})[0]
+        assert got.shape == ()
+        assert got.dtype == np.uint16
+        assert_allclose(np.array(1, dtype=np.uint16), got)
+
+    def test_dynamic_quantize_linear(self):
+        feeds = {
+            "X": np.array(
+                [
+                    [
+                        -7.80749545e-02,
+                        -3.80597055e-01,
+                        1.33831516e-01,
+                        -8.20474699e-02,
+                        7.56645501e-02,
+                        5.65112457e-02,
+                        2.56818235e-01,
+                        9.42316353e-02,
+                        1.88027292e-01,
+                        1.44878656e-01,
+                        1.34825557e-01,
+                        -2.04576910e-01,
+                        1.68852255e-01,
+                        6.23253360e-02,
+                        4.30482924e-01,
+                        -5.50433956e-02,
+                        9.10681635e-02,
+                        1.55332625e-01,
+                        -4.53630984e-02,
+                        3.99910688e-01,
+                        -1.28678545e-01,
+                        3.77916731e-02,
+                        1.29872710e-01,
+                        -1.12420328e-01,
+                        -2.97306702e-02,
+                        2.20508516e-01,
+                        -5.88933006e-03,
+                        4.81076002e-01,
+                        -1.18835129e-01,
+                        -4.45004404e-02,
+                        -7.53675848e-02,
+                        1.41112670e-01,
+                        1.97793499e-01,
+                        -7.71476865e-01,
+                        8.64694864e-02,
+                        1.73293594e-02,
+                        1.28247693e-01,
+                        7.58144110e-02,
+                        -2.71435380e-01,
+                        1.75212905e-01,
+                        -2.47283235e-01,
+                        -3.02810557e-02,
+                        8.45039487e-02,
+                        6.02229357e-01,
+                        -1.04913145e-01,
+                        -2.46705681e-01,
+                        2.92073280e-01,
+                        -3.88464853e-02,
+                        4.26557302e-01,
+                        -3.71325493e-01,
+                        -3.11283618e-01,
+                        7.85303488e-02,
+                        3.18069518e-01,
+                        -1.51467413e-01,
+                        -1.02828763e-01,
+                        9.29131880e-02,
+                        2.55233884e-01,
+                        5.00160515e-01,
+                        -1.49993747e-01,
+                        4.29408073e-01,
+                        -1.91787735e-01,
+                        3.16187665e-02,
+                        -1.84284449e-02,
+                        -1.62873864e-01,
+                        -2.73632705e-01,
+                        2.84725696e-01,
+                        -2.87029266e-01,
+                        -7.15534389e-02,
+                        2.24836454e-01,
+                        -1.70527741e-01,
+                        -2.65601039e-01,
+                        -2.68008932e-03,
+                        1.44260898e-01,
+                        7.80707747e-02,
+                        2.73875445e-02,
+                        -1.18391573e-01,
+                        -6.44972250e-02,
+                        -5.22445887e-03,
+                        -2.96754301e-01,
+                        1.05800219e-01,
+                        2.62558222e-01,
+                        3.62841524e-02,
+                        9.44730639e-03,
+                        1.75837606e-01,
+                        2.69956529e-01,
+                        3.02758247e-01,
+                        -1.13724738e-01,
+                        2.98936248e-01,
+                        8.54668319e-02,
+                        -6.74555600e-01,
+                        4.38643873e-01,
+                        1.27896462e-02,
+                        9.20789093e-02,
+                        1.93946883e-01,
+                        1.97548166e-01,
+                        2.82558739e-01,
+                        -2.48879120e-01,
+                        -3.93428057e-01,
+                        6.45540953e-02,
+                        -9.66283306e-03,
+                    ],
+                    [
+                        -2.42438495e-01,
+                        -3.58334243e-01,
+                        1.22619808e-01,
+                        -1.21529415e-01,
+                        -5.23974374e-02,
+                        -6.74922541e-02,
+                        1.09727375e-01,
+                        -3.56835872e-03,
+                        1.51029706e-01,
+                        1.18043356e-01,
+                        8.16475376e-02,
+                        -2.36466587e-01,
+                        9.44180191e-02,
+                        5.61679937e-02,
+                        3.67988586e-01,
+                        1.29441261e-01,
+                        1.15772486e-01,
+                        5.30351102e-02,
+                        -1.04345076e-01,
+                        1.29062623e-01,
+                        -2.17205048e-01,
+                        2.58089490e-02,
+                        2.18848974e-01,
+                        -8.36039707e-02,
+                        5.43577969e-03,
+                        7.87076280e-02,
+                        1.19966723e-01,
+                        2.81631678e-01,
+                        -3.58020402e-02,
+                        -9.65647772e-02,
+                        3.17915753e-02,
+                        2.49396205e-01,
+                        2.23600790e-01,
+                        -3.82718384e-01,
+                        1.16506606e-01,
+                        -3.19400802e-02,
+                        1.60812005e-01,
+                        9.81735960e-02,
+                        -1.99046463e-01,
+                        8.81427377e-02,
+                        -1.65171087e-01,
+                        -1.10251531e-01,
+                        1.15387037e-01,
+                        3.19312930e-01,
+                        -1.14400804e-01,
+                        -2.02447772e-01,
+                        2.33669549e-01,
+                        9.20853689e-02,
+                        3.91551465e-01,
+                        -3.58036369e-01,
+                        -2.35071778e-01,
+                        -5.00670634e-02,
+                        1.65313914e-01,
+                        -1.60922945e-01,
+                        -1.95520848e-01,
+                        1.82456985e-01,
+                        3.80704433e-01,
+                        4.19890225e-01,
+                        -2.98131555e-02,
+                        3.66110623e-01,
+                        -2.81170905e-01,
+                        -1.23942450e-01,
+                        9.58625227e-02,
+                        -5.90450205e-02,
+                        -1.56236291e-01,
+                        2.11865619e-01,
+                        -1.75286919e-01,
+                        -8.36539492e-02,
+                        1.29381597e-01,
+                        -1.66115880e-01,
+                        -1.66922957e-01,
+                        1.65688396e-01,
+                        8.41224194e-02,
+                        1.67839468e-01,
+                        -4.03967649e-02,
+                        -8.34071711e-02,
+                        -5.65301552e-02,
+                        1.67074010e-01,
+                        -3.19734544e-01,
+                        7.71123618e-02,
+                        5.57036921e-02,
+                        1.20709330e-01,
+                        -6.63790107e-02,
+                        1.36002287e-01,
+                        3.42324018e-01,
+                        3.42968374e-01,
+                        -1.42380476e-01,
+                        2.89662749e-01,
+                        1.82179566e-02,
+                        -4.96056974e-01,
+                        2.64364302e-01,
+                        7.38918930e-02,
+                        1.11150607e-01,
+                        -5.95749579e-02,
+                        1.18562862e-01,
+                        6.90007359e-02,
+                        -2.08283514e-01,
+                        -1.70682222e-01,
+                        7.82715827e-02,
+                        1.35489792e-01,
+                    ],
+                    [
+                        -6.35757595e-02,
+                        -3.20629895e-01,
+                        9.38569903e-02,
+                        -1.15190029e-01,
+                        1.03646070e-02,
+                        -4.31734361e-02,
+                        2.31717676e-01,
+                        4.01005745e-02,
+                        1.18915148e-01,
+                        2.10071519e-01,
+                        -2.99234912e-02,
+                        -2.93135524e-01,
+                        -2.39588290e-01,
+                        6.71441257e-02,
+                        3.15238893e-01,
+                        -5.08778207e-02,
+                        1.16147280e-01,
+                        -6.72954097e-02,
+                        -1.63787514e-01,
+                        1.60288364e-01,
+                        -2.30847582e-01,
+                        -2.22037435e-01,
+                        4.50191796e-02,
+                        -1.09636143e-01,
+                        -6.00997508e-02,
+                        2.14693844e-01,
+                        -8.51289369e-03,
+                        3.88416052e-01,
+                        -1.18085533e-01,
+                        -8.57385695e-02,
+                        -1.18666515e-02,
+                        3.29741478e-01,
+                        2.03779504e-01,
+                        -1.69492334e-01,
+                        1.94324687e-01,
+                        4.16374728e-02,
+                        6.83876276e-02,
+                        -1.85160581e-02,
+                        -3.73600274e-02,
+                        7.14804307e-02,
+                        -3.01446438e-01,
+                        1.74035393e-02,
+                        3.35123807e-01,
+                        4.17102218e-01,
+                        -1.58562332e-01,
+                        -2.54483074e-02,
+                        1.99573949e-01,
+                        7.95029774e-02,
+                        4.82958555e-01,
+                        -4.58213627e-01,
+                        -2.67229170e-01,
+                        1.27542794e-01,
+                        4.47799414e-02,
+                        -1.68686539e-01,
+                        -8.92183557e-02,
+                        9.79782715e-02,
+                        2.77656261e-02,
+                        2.96871901e-01,
+                        6.29860088e-02,
+                        1.77246213e-01,
+                        -3.15523535e-01,
+                        -1.74582571e-01,
+                        1.25724282e-02,
+                        -4.54988703e-02,
+                        -1.29154682e-01,
+                        2.13568255e-01,
+                        -1.40891463e-01,
+                        -2.66211092e-01,
+                        2.62144595e-01,
+                        -1.42889306e-01,
+                        -6.67349845e-02,
+                        1.63380653e-02,
+                        -1.92995071e-02,
+                        1.14811368e-01,
+                        1.43584609e-01,
+                        -2.65347548e-02,
+                        9.32592154e-02,
+                        2.23325342e-01,
+                        -1.87100068e-01,
+                        5.71197420e-02,
+                        2.71253467e-01,
+                        1.02890521e-01,
+                        -3.04941833e-03,
+                        1.10537663e-01,
+                        2.75728375e-01,
+                        2.11693868e-01,
+                        -1.80009842e-01,
+                        2.99300496e-02,
+                        1.77923322e-01,
+                        -4.53491032e-01,
+                        1.94149211e-01,
+                        2.47100577e-01,
+                        -9.95091349e-03,
+                        1.99301094e-01,
+                        2.06564650e-01,
+                        -1.99648179e-02,
+                        -1.89629450e-01,
+                        1.61689930e-02,
+                        1.04817756e-01,
+                        2.06400946e-01,
+                    ],
+                    [
+                        -3.86251360e-02,
+                        -3.07115853e-01,
+                        3.74236181e-02,
+                        -1.71237886e-01,
+                        -2.77359486e-02,
+                        -4.08068746e-02,
+                        6.91853091e-02,
+                        2.65322998e-03,
+                        1.23958819e-01,
+                        2.20951259e-01,
+                        8.36500078e-02,
+                        -3.14413190e-01,
+                        1.34745941e-01,
+                        -8.25274512e-02,
+                        3.36270213e-01,
+                        -2.49634441e-02,
+                        -1.06189884e-02,
+                        7.18819201e-02,
+                        -1.73392966e-01,
+                        2.98084319e-01,
+                        -1.25626653e-01,
+                        -2.17043106e-02,
+                        2.87982523e-01,
+                        -3.41932476e-03,
+                        -6.89984411e-02,
+                        -7.14176893e-03,
+                        4.49542440e-02,
+                        5.16424477e-01,
+                        -1.02622584e-01,
+                        2.02640779e-02,
+                        2.30106711e-02,
+                        1.93037808e-01,
+                        2.03393996e-01,
+                        -4.34632808e-01,
+                        5.74068353e-02,
+                        9.66466218e-02,
+                        -7.19890296e-02,
+                        4.23505977e-02,
+                        -1.60067812e-01,
+                        3.88947129e-02,
+                        -3.32329512e-01,
+                        1.91072702e-01,
+                        3.79437394e-02,
+                        4.33839470e-01,
+                        -1.29231960e-01,
+                        -1.46881789e-01,
+                        2.47269243e-01,
+                        2.86379829e-02,
+                        2.92926908e-01,
+                        -2.97341049e-01,
+                        -3.40239167e-01,
+                        1.52589783e-01,
+                        8.81168991e-02,
+                        1.40633471e-02,
+                        -8.83188471e-02,
+                        2.48367310e-01,
+                        3.41982782e-01,
+                        3.18781316e-01,
+                        -1.15148552e-01,
+                        2.54325420e-01,
+                        -1.82771236e-01,
+                        5.33889830e-02,
+                        2.12034155e-02,
+                        -9.78844613e-02,
+                        -1.61611915e-01,
+                        3.54084134e-01,
+                        -1.25332132e-01,
+                        -2.07989410e-01,
+                        2.35610008e-02,
+                        -1.35993093e-01,
+                        -1.97377697e-01,
+                        -1.21356212e-02,
+                        7.86775351e-03,
+                        4.71337497e-01,
+                        9.49376822e-03,
+                        4.25345525e-02,
+                        1.14162050e-01,
+                        6.27847165e-02,
+                        -2.31957644e-01,
+                        -8.33211765e-02,
+                        2.02719584e-01,
+                        -4.64919358e-02,
+                        7.57966787e-02,
+                        1.01521172e-01,
+                        3.16580981e-01,
+                        1.49488643e-01,
+                        -1.20770879e-01,
+                        2.56563038e-01,
+                        1.66572407e-01,
+                        -6.11343801e-01,
+                        2.09183827e-01,
+                        6.66101649e-02,
+                        1.77328646e-01,
+                        1.77777156e-01,
+                        2.03266457e-01,
+                        1.37545317e-01,
+                        -1.38004154e-01,
+                        -2.57656008e-01,
+                        1.83920860e-01,
+                        2.87696868e-02,
+                    ],
+                    [
+                        5.14136627e-04,
+                        -2.88997203e-01,
+                        -3.34554128e-02,
+                        -6.80408552e-02,
+                        -4.61972654e-02,
+                        1.75428241e-01,
+                        1.86710209e-01,
+                        -1.51355267e-01,
+                        1.28381401e-01,
+                        2.87129283e-01,
+                        5.22154570e-03,
+                        -3.53413224e-01,
+                        -3.87947261e-02,
+                        5.81918843e-02,
+                        3.17016482e-01,
+                        -2.51671404e-01,
+                        7.01867491e-02,
+                        -4.92945537e-02,
+                        -2.73323953e-01,
+                        1.27938241e-01,
+                        -4.11552131e-01,
+                        -2.23789401e-02,
+                        1.95418939e-01,
+                        -3.25946212e-01,
+                        4.60528135e-02,
+                        1.86884090e-01,
+                        6.98191971e-02,
+                        2.95638293e-01,
+                        -1.80322871e-01,
+                        -2.98620313e-02,
+                        2.11789399e-01,
+                        3.15145910e-01,
+                        3.11763227e-01,
+                        -5.78147054e-01,
+                        6.43244758e-02,
+                        -3.14367823e-02,
+                        1.86190963e-01,
+                        1.71108633e-01,
+                        -6.29745722e-02,
+                        7.48428777e-02,
+                        -4.58003521e-01,
+                        -3.01471800e-01,
+                        2.17973694e-01,
+                        5.73273778e-01,
+                        -1.01379365e-01,
+                        -2.46951967e-01,
+                        1.58989042e-01,
+                        -1.79126799e-01,
+                        5.24153829e-01,
+                        -4.64852840e-01,
+                        -2.94867605e-01,
+                        1.83558539e-01,
+                        2.50552952e-01,
+                        -8.56962949e-02,
+                        -2.57554710e-01,
+                        2.30709136e-01,
+                        3.53280157e-01,
+                        3.20184112e-01,
+                        2.99184099e-02,
+                        3.09098989e-01,
+                        -2.02217728e-01,
+                        -9.29201543e-02,
+                        -1.20569356e-02,
+                        -1.37087986e-01,
+                        -2.16524690e-01,
+                        1.39787242e-01,
+                        -1.27902150e-01,
+                        -2.64347821e-01,
+                        9.29943919e-02,
+                        -1.57217175e-01,
+                        -3.86638314e-01,
+                        7.90465698e-02,
+                        4.07211930e-02,
+                        -3.07695866e-02,
+                        1.27393469e-01,
+                        -1.18648581e-01,
+                        -7.21216127e-02,
+                        -3.71141285e-02,
+                        -3.37082207e-01,
+                        -6.23112544e-02,
+                        3.52166295e-01,
+                        1.51260465e-01,
+                        5.03427610e-02,
+                        1.90433189e-01,
+                        5.21304548e-01,
+                        3.85341585e-01,
+                        -1.26457050e-01,
+                        1.54961571e-01,
+                        5.29025272e-02,
+                        -5.06486952e-01,
+                        2.28533953e-01,
+                        1.78438187e-01,
+                        -4.14765030e-02,
+                        2.01903239e-01,
+                        -3.89365852e-02,
+                        8.84043872e-02,
+                        -1.55351788e-01,
+                        -9.06582028e-02,
+                        9.95599255e-02,
+                        -4.79989760e-02,
+                    ],
+                ],
+                dtype=np.float32,
+            )
+        }
+
+        expected = [
+            np.array(
+                [
+                    [
+                        129,
+                        72,
+                        168,
+                        128,
+                        157,
+                        153,
+                        191,
+                        160,
+                        178,
+                        170,
+                        168,
+                        105,
+                        174,
+                        155,
+                        223,
+                        133,
+                        160,
+                        172,
+                        135,
+                        217,
+                        119,
+                        150,
+                        167,
+                        122,
+                        137,
+                        184,
+                        142,
+                        232,
+                        121,
+                        135,
+                        129,
+                        169,
+                        180,
+                        0,
+                        159,
+                        146,
+                        167,
+                        157,
+                        93,
+                        176,
+                        97,
+                        137,
+                        159,
+                        255,
+                        124,
+                        97,
+                        197,
+                        136,
+                        222,
+                        74,
+                        85,
+                        158,
+                        202,
+                        115,
+                        124,
+                        160,
+                        190,
+                        236,
+                        115,
+                        223,
+                        107,
+                        149,
+                        140,
+                        113,
+                        92,
+                        196,
+                        90,
+                        130,
+                        185,
+                        111,
+                        94,
+                        143,
+                        170,
+                        157,
+                        148,
+                        121,
+                        131,
+                        142,
+                        88,
+                        163,
+                        192,
+                        150,
+                        145,
+                        176,
+                        193,
+                        199,
+                        122,
+                        198,
+                        159,
+                        18,
+                        224,
+                        145,
+                        160,
+                        179,
+                        180,
+                        195,
+                        97,
+                        70,
+                        155,
+                        141,
+                    ],
+                    [
+                        98,
+                        76,
+                        166,
+                        120,
+                        133,
+                        130,
+                        163,
+                        142,
+                        171,
+                        165,
+                        158,
+                        99,
+                        161,
+                        153,
+                        211,
+                        167,
+                        164,
+                        153,
+                        124,
+                        167,
+                        103,
+                        148,
+                        184,
+                        127,
+                        144,
+                        158,
+                        165,
+                        195,
+                        136,
+                        125,
+                        149,
+                        189,
+                        185,
+                        72,
+                        165,
+                        137,
+                        173,
+                        161,
+                        106,
+                        159,
+                        112,
+                        123,
+                        164,
+                        202,
+                        122,
+                        105,
+                        186,
+                        160,
+                        216,
+                        77,
+                        99,
+                        134,
+                        174,
+                        113,
+                        107,
+                        177,
+                        214,
+                        221,
+                        137,
+                        211,
+                        91,
+                        120,
+                        161,
+                        132,
+                        114,
+                        182,
+                        110,
+                        127,
+                        167,
+                        112,
+                        112,
+                        174,
+                        159,
+                        174,
+                        136,
+                        128,
+                        133,
+                        174,
+                        84,
+                        157,
+                        153,
+                        165,
+                        131,
+                        168,
+                        207,
+                        207,
+                        117,
+                        197,
+                        146,
+                        51,
+                        192,
+                        157,
+                        164,
+                        132,
+                        165,
+                        156,
+                        104,
+                        111,
+                        158,
+                        168,
+                    ],
+                    [
+                        131,
+                        83,
+                        160,
+                        122,
+                        145,
+                        135,
+                        186,
+                        150,
+                        165,
+                        182,
+                        137,
+                        89,
+                        99,
+                        155,
+                        202,
+                        134,
+                        165,
+                        131,
+                        113,
+                        173,
+                        100,
+                        102,
+                        151,
+                        123,
+                        132,
+                        183,
+                        141,
+                        215,
+                        121,
+                        127,
+                        141,
+                        204,
+                        181,
+                        112,
+                        179,
+                        151,
+                        156,
+                        140,
+                        136,
+                        156,
+                        87,
+                        146,
+                        205,
+                        220,
+                        114,
+                        138,
+                        180,
+                        158,
+                        233,
+                        58,
+                        93,
+                        167,
+                        151,
+                        112,
+                        126,
+                        161,
+                        148,
+                        198,
+                        155,
+                        176,
+                        84,
+                        111,
+                        145,
+                        135,
+                        119,
+                        183,
+                        117,
+                        94,
+                        192,
+                        116,
+                        131,
+                        146,
+                        139,
+                        164,
+                        170,
+                        138,
+                        160,
+                        184,
+                        108,
+                        154,
+                        193,
+                        162,
+                        142,
+                        164,
+                        194,
+                        182,
+                        110,
+                        149,
+                        176,
+                        59,
+                        179,
+                        189,
+                        141,
+                        180,
+                        181,
+                        139,
+                        108,
+                        146,
+                        162,
+                        181,
+                    ],
+                    [
+                        136,
+                        86,
+                        150,
+                        111,
+                        138,
+                        135,
+                        156,
+                        143,
+                        166,
+                        184,
+                        159,
+                        85,
+                        168,
+                        128,
+                        205,
+                        138,
+                        141,
+                        156,
+                        111,
+                        198,
+                        120,
+                        139,
+                        196,
+                        142,
+                        130,
+                        142,
+                        151,
+                        239,
+                        124,
+                        147,
+                        147,
+                        179,
+                        181,
+                        62,
+                        154,
+                        161,
+                        130,
+                        151,
+                        113,
+                        150,
+                        81,
+                        178,
+                        150,
+                        224,
+                        119,
+                        116,
+                        189,
+                        148,
+                        197,
+                        88,
+                        80,
+                        171,
+                        159,
+                        146,
+                        127,
+                        189,
+                        206,
+                        202,
+                        122,
+                        190,
+                        109,
+                        153,
+                        147,
+                        125,
+                        113,
+                        209,
+                        120,
+                        104,
+                        147,
+                        118,
+                        106,
+                        141,
+                        144,
+                        230,
+                        145,
+                        151,
+                        164,
+                        155,
+                        100,
+                        128,
+                        181,
+                        134,
+                        157,
+                        162,
+                        202,
+                        171,
+                        121,
+                        191,
+                        174,
+                        30,
+                        182,
+                        155,
+                        176,
+                        176,
+                        181,
+                        169,
+                        117,
+                        95,
+                        177,
+                        148,
+                    ],
+                    [
+                        143,
+                        89,
+                        137,
+                        130,
+                        134,
+                        176,
+                        178,
+                        115,
+                        167,
+                        196,
+                        144,
+                        77,
+                        136,
+                        154,
+                        202,
+                        96,
+                        156,
+                        134,
+                        92,
+                        167,
+                        67,
+                        139,
+                        179,
+                        82,
+                        152,
+                        178,
+                        156,
+                        198,
+                        110,
+                        137,
+                        182,
+                        202,
+                        201,
+                        36,
+                        155,
+                        137,
+                        178,
+                        175,
+                        131,
+                        157,
+                        58,
+                        87,
+                        183,
+                        249,
+                        124,
+                        97,
+                        173,
+                        110,
+                        240,
+                        57,
+                        88,
+                        177,
+                        190,
+                        127,
+                        95,
+                        186,
+                        209,
+                        202,
+                        149,
+                        200,
+                        105,
+                        126,
+                        141,
+                        118,
+                        103,
+                        169,
+                        119,
+                        94,
+                        160,
+                        114,
+                        71,
+                        158,
+                        151,
+                        137,
+                        167,
+                        121,
+                        130,
+                        136,
+                        80,
+                        131,
+                        208,
+                        171,
+                        152,
+                        178,
+                        240,
+                        215,
+                        120,
+                        172,
+                        153,
+                        49,
+                        185,
+                        176,
+                        135,
+                        180,
+                        136,
+                        159,
+                        114,
+                        126,
+                        161,
+                        134,
+                    ],
+                ],
+                dtype=np.uint8,
+            ),
+            np.array(0.005387083161622286, dtype=np.float32),
+            np.array(143, dtype=np.uint8),
+        ]
+
+        X = make_tensor_value_info("X", TensorProto.FLOAT, None)
+        Y = make_tensor_value_info("Y", TensorProto.UINT8, None)
+        Scale = make_tensor_value_info("scale", TensorProto.FLOAT, None)
+        Zp = make_tensor_value_info("zp", TensorProto.UINT8, None)
+
+        nodes = [
+            make_node(
+                "DynamicQuantizeLinear",
+                ["X"],
+                ["Y", "scale", "zp"],
+            ),
+        ]
+        model = make_model(
+            make_graph(nodes, "g", [X], [Y, Scale, Zp]),
+            opset_imports=[make_opsetid("", onnx_opset_version() - 1)],
+        )
+        ref = ReferenceEvaluator(model)
+        got = ref.run(None, feeds)
+        assert len(got) == 3
+        for i in range(2, -1, -1):
+            assert_allclose(got[i], expected[i])
+
+    @pytest.mark.parametrize(
+        "a, b, expected, expected_shape",
+        [
+            (["abc", "def"], [".com", ".net"], ["abc.com", "def.net"], (2,)),
+            (["cat", "dog", "snake"], ["s"], ["cats", "dogs", "snakes"], (3,)),
+            ("cat", "s", "cats", ()),
+            (["a", "ß", "y"], ["a", "ß", "y"], ["aa", "ßß", "yy"], (3,)),
+        ],
+    )
+    def test_string_concat(self, a, b, expected, expected_shape):
+        A = make_tensor_value_info("A", TensorProto.STRING, None)
+        B = make_tensor_value_info("B", TensorProto.STRING, None)
+        Y = make_tensor_value_info("Y", TensorProto.STRING, None)
+        node = make_node("StringConcat", inputs=["A", "B"], outputs=["Y"])
+        model = make_model(make_graph([node], "g", [A, B], [Y]))
+        ref = ReferenceEvaluator(model)
+        result, *_ = ref.run(None, {"A": np.array(a), "B": np.array(b)})
+        np.testing.assert_array_equal(result, expected)
+        assert result.dtype.kind in {"O", "U"}
+        assert result.shape == expected_shape
+
+    @pytest.mark.parametrize(
+        "x, delimiter, maxsplit, expected_split, expected_num_splits",
+        [
+            (
+                ["1,2,3", "4,5,6"],
+                ",",
+                None,
+                [["1", "2", "3"], ["4", "5", "6"]],
+                [3, 3],
+            ),
+            (
+                ["1,", "4,6", ""],
+                ",",
+                None,
+                [["1", ""], ["4", "6"], ["", ""]],
+                [2, 2, 1],
+            ),
+            (
+                ["1", "4,6", "4,5,6"],
+                ",",
+                1,
+                [["1", ""], ["4", "6"], ["4", "5,6"]],
+                [1, 2, 2],
+            ),
+            (
+                [["1,", "4,6", "4,5,6"], ["1,", "4,6", "4,5,6"]],
+                ",",
+                None,
+                [
+                    [["1", "", ""], ["4", "6", ""], ["4", "5", "6"]],
+                    [["1", "", ""], ["4", "6", ""], ["4", "5", "6"]],
+                ],
+                [[2, 2, 3], [2, 2, 3]],
+            ),
+            (
+                ["hello world !", "  hello   world !", " hello world   ! "],
+                None,
+                None,
+                [
+                    ["hello", "world", "!"],
+                    ["hello", "world", "!"],
+                    ["hello", "world", "!"],
+                ],
+                [3, 3, 3],
+            ),
+            (
+                ["hello world !", "  hello   world !", " hello world   ! "],
+                "",
+                None,
+                [
+                    ["hello", "world", "!"],
+                    ["hello", "world", "!"],
+                    ["hello", "world", "!"],
+                ],
+                [3, 3, 3],
+            ),
+            (
+                ["o-n-n--x-", "o-n----nx"],
+                "-",
+                None,
+                [["o", "n", "n", "", "x", ""], ["o", "n", "", "", "", "nx"]],
+                [6, 6],
+            ),
+            (
+                [],
+                " ",
+                2,
+                np.array([]).reshape((0, 0)),
+                [],
+            ),
+        ],
+    )
+    def test_string_split(
+        self,
+        x,
+        delimiter,
+        maxsplit,
+        expected_split,
+        expected_num_splits,
+    ):
+        X = make_tensor_value_info("X", TensorProto.STRING, (None))
+        Splits = make_tensor_value_info("Splits", TensorProto.STRING, (None))
+        MaxSplits = make_tensor_value_info("MaxSplits", TensorProto.INT32, (None))
+        node = make_node(
+            "StringSplit",
+            inputs=["X"],
+            outputs=["Splits", "MaxSplits"],
+            delimiter=delimiter,
+            maxsplit=maxsplit,
+        )
+        model = make_model(make_graph([node], "g", [X], [Splits, MaxSplits]))
+        ref = ReferenceEvaluator(model)
+        x = np.array(x, dtype=object)
+        result, num_splits, *_ = ref.run(None, {"X": x})
+        np.testing.assert_array_equal(result, np.array(expected_split, dtype=object))
+        np.testing.assert_array_equal(
+            num_splits, np.array(expected_num_splits, dtype=np.int64)
+        )
+
+    def test_qlinearmatmul_int8(self):
+        a = (np.array([[208, 236, 0, 238], [3, 214, 255, 29]]) - 127).astype(np.int8)
+        b = (
+            np.array([[152, 51, 244], [60, 26, 255], [0, 127, 246], [127, 254, 247]])
+            - 127
+        ).astype(np.int8)
+        feeds = {
+            "a": a,
+            "a_scale": np.array([0.0066], dtype=np.float32),
+            "a_zero_point": np.array([113 - 127], dtype=np.int8),
+            "b": b,
+            "b_scale": np.array([0.00705], dtype=np.float32),
+            "b_zero_point": np.array([114 - 127], dtype=np.int8),
+            "y_scale": np.array([0.0107], dtype=np.float32),
+            "y_zero_point": np.array([118 - 127], dtype=np.int8),
+        }
+        got = self._run_qlinear_int8(
+            "QLinearMatMul", feeds, ([2, 4], [4, 3]), [2, 3], opset=20
+        )
+        np.testing.assert_array_equal(
+            np.array([[41, -12, -9], [1, -75, -128]], dtype=np.int8), got
+        )
+
+    @pytest.mark.parametrize(
+        "dtype, tensor_type, a_values, b_values, y_scale_value, expected_values",
+        [
+            (np.uint8, TensorProto.UINT8, [[100]], [[100]], 0.2, [[255]]),
+            (np.int8, TensorProto.INT8, [[-100]], [[100]], 0.5, [[-128]]),
+        ],
+    )
+    def test_qlinearmatmul_saturates_output(
+        self, dtype, tensor_type, a_values, b_values, y_scale_value, expected_values
+    ):
+        node = make_node(
+            "QLinearMatMul",
+            inputs=[
+                "a",
+                "a_scale",
+                "a_zero_point",
+                "b",
+                "b_scale",
+                "b_zero_point",
+                "y_scale",
+                "y_zero_point",
+            ],
+            outputs=["y"],
+        )
+        graph = make_graph(
+            [node],
+            "g",
+            [
+                make_tensor_value_info("a", tensor_type, [1, 1]),
+                make_tensor_value_info("a_scale", TensorProto.FLOAT, [1]),
+                make_tensor_value_info("a_zero_point", tensor_type, [1]),
+                make_tensor_value_info("b", tensor_type, [1, 1]),
+                make_tensor_value_info("b_scale", TensorProto.FLOAT, [1]),
+                make_tensor_value_info("b_zero_point", tensor_type, [1]),
+                make_tensor_value_info("y_scale", TensorProto.FLOAT, [1]),
+                make_tensor_value_info("y_zero_point", tensor_type, [1]),
+            ],
+            [make_tensor_value_info("y", tensor_type, [1, 1])],
+        )
+        onnx_model = make_model(
+            graph, opset_imports=[make_opsetid("", 20)], ir_version=9
+        )
+        sess = ReferenceEvaluator(onnx_model)
+
+        zero_point = np.array([0], dtype=dtype)
+        got = sess.run(
+            None,
+            {
+                "a": np.array(a_values, dtype=dtype),
+                "a_scale": np.array([1.0], dtype=np.float32),
+                "a_zero_point": zero_point,
+                "b": np.array(b_values, dtype=dtype),
+                "b_scale": np.array([1.0], dtype=np.float32),
+                "b_zero_point": zero_point,
+                "y_scale": np.array([y_scale_value], dtype=np.float32),
+                "y_zero_point": zero_point,
+            },
+        )
+
+        np.testing.assert_array_equal(np.array(expected_values, dtype=dtype), got[0])
+
+    @pytest.mark.parametrize(
+        "x, pattern, expected, expected_shape",
+        [
+            (
+                ["www.google.com", "www.facebook.com", "www.bbc.co.uk"],
+                r"www\.[\w.-]+\.\bcom\b",
+                [True, True, False],
+                (3,),
+            ),
+            (
+                [["Onnx", "tensorflow", "Numpy"], ["Pytorch", "Cython", "numba"]],
+                r"^[A-Z][a-z]*$",
+                [[True, False, True], [True, True, False]],
+                (2, 3),
+            ),
+            (
+                [
+                    "account@gmail.com",
+                    "account@hotmail.com",
+                    "not email",
+                    "account2@yahoo.com",
+                ],
+                r"(\W|^)[\w.\-]{0,25}@(yahoo|gmail)\.com(\W|$)",
+                [True, False, False, True],
+                (4,),
+            ),
+        ],
+    )
+    def test_regex_full_match(self, x, pattern, expected, expected_shape):
+        X = make_tensor_value_info("X", TensorProto.STRING, None)
+        Y = make_tensor_value_info("Y", TensorProto.BOOL, None)
+        node = make_node("RegexFullMatch", inputs=["X"], outputs=["Y"], pattern=pattern)
+        model = make_model(make_graph([node], "g", [X], [Y]))
+        ref = ReferenceEvaluator(model)
+        result, *_ = ref.run(None, {"X": np.array(x)})
+        np.testing.assert_array_equal(result, expected)
+        assert result.dtype.kind == "b"
+        assert result.shape == expected_shape
+
+    def test_regex_invalid_pattern(self):
+        X = make_tensor_value_info("X", TensorProto.STRING, None)
+        Y = make_tensor_value_info("Y", TensorProto.BOOL, None)
+        node = make_node("RegexFullMatch", inputs=["X"], outputs=["Y"], pattern="x)")
+        model = make_model(make_graph([node], "g", [X], [Y]))
+        ref = ReferenceEvaluator(model)
+        with pytest.raises(ValueError):
+            ref.run(None, {"X": np.array(["x"])})
+
+    @pytest.mark.parametrize(
+        "qtype, data, expected",
+        [
+            (
+                TensorProto.UINT2,
+                [-1, 0, 1.5, 2, 3.3, 10, 20, 40],
+                [0, 0, 2, 2, 4, 6, 6, 6],
+            ),
+            (TensorProto.UINT2, [-1, 0, 1.5, 2, 3.3, 10, 40], [0, 0, 2, 2, 4, 6, 6]),
+            (TensorProto.UINT2, [0], [0]),
+            (
+                TensorProto.INT2,
+                [-20, -14.5, 0, 1.5, 2, 3.3, 10, 20],
+                [-4, -4, 0, 2, 2, 2, 2, 2],
+            ),
+            (
+                TensorProto.INT2,
+                [-20, -14.5, 0, 1.5, 2, 3.3, 10],
+                [-4, -4, 0, 2, 2, 2, 2],
+            ),
+            (TensorProto.INT2, [0], [0]),
+        ],
+    )
+    def test_quantize_linear_int2(self, qtype, data, expected):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node(
+                        "Constant",
+                        [],
+                        ["scale"],
+                        value=make_tensor("scale", TensorProto.FLOAT, [1], [2.0]),
+                    ),
+                    make_node(
+                        "Constant",
+                        [],
+                        ["zero"],
+                        value=make_tensor("zero", qtype, [1], [0]),
+                    ),
+                    make_node("QuantizeLinear", ["X", "scale", "zero"], ["T"]),
+                    make_node("DequantizeLinear", ["T", "scale"], ["Y"], axis=0),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        got = ref.run(None, {"X": np.asarray(data)})
+        assert_allclose(got[0], expected)
+
+    @pytest.mark.parametrize("cast_from", (TensorProto.FLOAT, TensorProto.FLOAT16))
+    @pytest.mark.parametrize("cast_to", (TensorProto.UINT2, TensorProto.INT2))
+    def test_cast_int2_output(self, cast_from, cast_to):
+        X = make_tensor_value_info("X", cast_from, [None])
+        Y = make_tensor_value_info("Y", cast_to, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["Y"], to=cast_to),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array(
+            [0, 1, 2.4, 2.6, 4, 10],
+            dtype=onnx.helper.tensor_dtype_to_np_dtype(cast_from),
+        )
+        expected = data.astype(onnx.helper.tensor_dtype_to_np_dtype(cast_to))
+        got = ref.run(None, {"X": data})
+        assert got[0].tolist() == expected.tolist()
+
+    @pytest.mark.parametrize("cast_from", (TensorProto.UINT2, TensorProto.INT2))
+    @pytest.mark.parametrize("cast_to", (TensorProto.FLOAT, TensorProto.FLOAT16))
+    def test_cast_int2_input(
+        self, cast_from: TensorProto.DataType, cast_to: TensorProto.DataType
+    ):
+        X = make_tensor_value_info("X", cast_from, [None])
+        Y = make_tensor_value_info("Y", cast_to, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["Y"], to=TensorProto.FLOAT),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array(range(2), dtype=np.float32)
+        expected = data.astype(onnx.helper.tensor_dtype_to_np_dtype(cast_from))
+        got = ref.run(None, {"X": data})
+        np.testing.assert_array_equal(got[0], expected)
+
+    @pytest.mark.parametrize(
+        "qtype, data, expected",
+        [
+            (
+                TensorProto.UINT4,
+                [-1, 0, 1.5, 2, 3.3, 10, 20, 40],
+                [0, 0, 2, 2, 4, 10, 20, 30],
+            ),
+            (TensorProto.UINT4, [-1, 0, 1.5, 2, 3.3, 10, 40], [0, 0, 2, 2, 4, 10, 30]),
+            (TensorProto.UINT4, [0], [0]),
+            (
+                TensorProto.INT4,
+                [-20, -14.5, 0, 1.5, 2, 3.3, 10, 20],
+                [-16, -14, 0, 2, 2, 4, 10, 14],
+            ),
+            (
+                TensorProto.INT4,
+                [-20, -14.5, 0, 1.5, 2, 3.3, 10],
+                [-16, -14, 0, 2, 2, 4, 10],
+            ),
+            (TensorProto.INT4, [0], [0]),
+        ],
+    )
+    def test_quantize_linear_int4(self, qtype, data, expected):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node(
+                        "Constant",
+                        [],
+                        ["scale"],
+                        value=make_tensor("scale", TensorProto.FLOAT, [1], [2.0]),
+                    ),
+                    make_node(
+                        "Constant",
+                        [],
+                        ["zero"],
+                        value=make_tensor("zero", qtype, [1], [0]),
+                    ),
+                    make_node("QuantizeLinear", ["X", "scale", "zero"], ["T"]),
+                    make_node("DequantizeLinear", ["T", "scale"], ["Y"], axis=0),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        got = ref.run(None, {"X": np.asarray(data)})
+        assert_allclose(got[0], expected)
+
+    @pytest.mark.parametrize("cast_from", (TensorProto.FLOAT, TensorProto.FLOAT16))
+    @pytest.mark.parametrize("cast_to", (TensorProto.UINT4, TensorProto.INT4))
+    def test_cast_int4_output(self, cast_from, cast_to):
+        X = make_tensor_value_info("X", cast_from, [None])
+        Y = make_tensor_value_info("Y", cast_to, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["Y"], to=cast_to),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array(
+            [0, 1, 2.4, 2.6, 4, 10],
+            dtype=onnx.helper.tensor_dtype_to_np_dtype(cast_from),
+        )
+        expected = data.astype(onnx.helper.tensor_dtype_to_np_dtype(cast_to))
+        got = ref.run(None, {"X": data})
+        assert got[0].tolist() == expected.tolist()
+
+    @pytest.mark.parametrize("cast_from", (TensorProto.UINT4, TensorProto.INT4))
+    @pytest.mark.parametrize("cast_to", (TensorProto.FLOAT, TensorProto.FLOAT16))
+    def test_cast_int4_input(
+        self, cast_from: TensorProto.DataType, cast_to: TensorProto.DataType
+    ):
+        X = make_tensor_value_info("X", cast_from, [None])
+        Y = make_tensor_value_info("Y", cast_to, [None])
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["Y"], to=TensorProto.FLOAT),
+                ],
+                "g",
+                [X],
+                [Y],
+            )
+        )
+        ref = ReferenceEvaluator(model)
+        data = np.array(range(7), dtype=np.float32)
+        expected = data.astype(onnx.helper.tensor_dtype_to_np_dtype(cast_from))
+        got = ref.run(None, {"X": data})
+        np.testing.assert_array_equal(got[0], expected)
+
+    def test_a_function_calling_a_function_once(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, ["N"])
+        output = make_tensor_value_info("output", TensorProto.FLOAT, ["N"])
+        Z = make_tensor_value_info("output", TensorProto.FLOAT, ["N"])
+
+        func_def_add = make_function(
+            "this",
+            "fctadd",
+            ["input2"],
+            ["output"],
+            [
+                make_node("Constant", [], ["one"], value_floats=[1.0], name="CC0"),
+                make_node("Add", ["input2", "one"], ["output"], name="A1"),
+            ],
+            opset_imports=[make_operatorsetid("", 15)],
+        )
+
+        func_def = make_function(
+            "this",
+            "fct",
+            ["input"],
+            ["output"],
+            [
+                make_node("Constant", [], ["one"], value_floats=[1.0], name="CC"),
+                make_node("Greater", ["input", "one"], ["cond"]),
+                make_node(
+                    "If",
+                    ["cond"],
+                    ["output"],
+                    then_branch=make_graph(
+                        [make_node("fctadd", ["input"], ["output"], domain="this")],
+                        "gthen",
+                        [],
+                        [output],
+                    ),
+                    else_branch=make_graph(
+                        [make_node("Add", ["input", "one"], ["output"], domain="")],
+                        "gelse",
+                        [],
+                        [output],
+                    ),
+                    name=":IF",
+                ),
+            ],
+            opset_imports=[
+                make_operatorsetid("", 15),
+                make_operatorsetid("this", 1),
+            ],
+        )
+
+        model_def = make_model(
+            make_graph(
+                [
+                    make_node("fct", ["X"], ["output"], domain="this"),
+                ],
+                "test",
+                [X],
+                [Z],
+            ),
+            ir_version=7,
+            opset_imports=[
+                make_operatorsetid("", 15),
+                make_operatorsetid("this", 1),
+            ],
+            functions=[func_def_add, func_def],
+        )
+
+        feeds = {"X": np.array([-5], dtype=np.float32)}
+        oinf = ReferenceEvaluator(model_def)
+        expected = oinf.run(None, feeds)
+
+        # inlining does not work here
+        # inlined = inline_local_functions(model_def)
+        # oinf = ReferenceEvaluator(inlined)
+        # goti = oinf.run(None, feeds)
+        # self.assertEqual(expected[0].tolist(), goti[0].tolist())
+        np.testing.assert_equal(np.array([-4], dtype=np.float32), expected[0])
+
+    def test_a_function_calling_a_function_double(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, ["N"])
+        output = make_tensor_value_info("output", TensorProto.FLOAT, ["N"])
+        Z = make_tensor_value_info("output", TensorProto.FLOAT, ["N"])
+
+        func_def_add = make_function(
+            "this",
+            "fctadd",
+            ["input2"],
+            ["output"],
+            [
+                make_node("Constant", [], ["one"], value_floats=[1.0], name="CC0"),
+                make_node("Add", ["input2", "one"], ["output"], name="A1"),
+            ],
+            opset_imports=[make_operatorsetid("", 15)],
+        )
+
+        func_def = make_function(
+            "this",
+            "fct",
+            ["input"],
+            ["output"],
+            [
+                make_node("Constant", [], ["one"], value_floats=[1.0], name="CC"),
+                make_node("Greater", ["input", "one"], ["cond"]),
+                make_node(
+                    "If",
+                    ["cond"],
+                    ["output"],
+                    then_branch=make_graph(
+                        [make_node("fctadd", ["input"], ["output"], domain="this")],
+                        "gthen",
+                        [],
+                        [output],
+                    ),
+                    else_branch=make_graph(
+                        [make_node("Add", ["input", "one"], ["output"], domain="")],
+                        "gelse",
+                        [],
+                        [output],
+                    ),
+                    name=":IF",
+                ),
+            ],
+            opset_imports=[
+                make_operatorsetid("", 15),
+                make_operatorsetid("this", 1),
+            ],
+        )
+
+        model_def = make_model(
+            make_graph(
+                [
+                    make_node("fct", ["X"], ["ztmp"], domain="this"),
+                    make_node("fct", ["ztmp"], ["output"], domain="this"),
+                ],
+                "test",
+                [X],
+                [Z],
+            ),
+            ir_version=7,
+            opset_imports=[
+                make_operatorsetid("", 15),
+                make_operatorsetid("this", 1),
+            ],
+            functions=[func_def_add, func_def],
+        )
+
+        feeds = {"X": np.array([-5], dtype=np.float32)}
+        oinf = ReferenceEvaluator(model_def)
+        expected = oinf.run(None, feeds)
+
+        # inlining does not work here
+        # inlined = inline_local_functions(model_def)
+        # oinf = ReferenceEvaluator(inlined)
+        # goti = oinf.run(None, feeds)
+        # self.assertEqual(expected[0].tolist(), goti[0].tolist())
+        np.testing.assert_equal(np.array([-3], dtype=np.float32), expected[0])
+
+    def test_overload_reference_implementation(self):
+        X = make_tensor_value_info("X", TensorProto.FLOAT, ["N"])
+        output = make_tensor_value_info("output", TensorProto.FLOAT, ["N"])
+        Z = make_tensor_value_info("output", TensorProto.FLOAT, ["N"])
+
+        func_def_add = make_function(
+            "this",
+            "fctadd",
+            ["input2"],
+            ["output"],
+            [
+                make_node("Constant", [], ["one"], value_floats=[1.0], name="CC0"),
+                make_node("Add", ["input2", "one"], ["output"], name="A1"),
+            ],
+            opset_imports=[make_operatorsetid("", 15)],
+        )
+
+        func_def = make_function(
+            "this",
+            "fct",
+            ["input"],
+            ["output"],
+            [
+                make_node("Constant", [], ["one"], value_floats=[1.0], name="CC"),
+                make_node("Greater", ["input", "one"], ["cond"]),
+                make_node(
+                    "If",
+                    ["cond"],
+                    ["output"],
+                    then_branch=make_graph(
+                        [make_node("fctadd", ["input"], ["output"], domain="this")],
+                        "gthen",
+                        [],
+                        [output],
+                    ),
+                    else_branch=make_graph(
+                        [make_node("Add", ["input", "one"], ["output"], domain="")],
+                        "gelse",
+                        [],
+                        [output],
+                    ),
+                    name=":IF",
+                ),
+            ],
+            opset_imports=[
+                make_operatorsetid("", 15),
+                make_operatorsetid("this", 1),
+            ],
+        )
+
+        model_def = make_model(
+            make_graph(
+                [
+                    make_node("fct", ["X"], ["ztmp"], domain="this"),
+                    make_node("fct", ["ztmp"], ["output"], domain="this"),
+                ],
+                "test",
+                [X],
+                [Z],
+            ),
+            ir_version=7,
+            opset_imports=[
+                make_operatorsetid("", 15),
+                make_operatorsetid("this", 1),
+            ],
+            functions=[func_def_add, func_def],
+        )
+
+        class MyReferenceEvaluator(ReferenceEvaluator):
+            pass
+
+        oinf = MyReferenceEvaluator(model_def)
+        for v in oinf.functions_.values():
+            assert isinstance(v, MyReferenceEvaluator)
+
+    @pytest.mark.parametrize(
+        "stype, atol",
+        [
+            ("FLOAT8E4M3FN", 0.23),
+            ("FLOAT8E4M3FNUZ", 0.23),
+            ("FLOAT8E5M2", 0.85),
+            ("FLOAT8E5M2FNUZ", 0.85),
+            ("DOUBLE", 0),
+            ("FLOAT", 0),
+            ("FLOAT16", 2e-3),
+            ("BFLOAT16", 2e-2),
+        ],
+    )
+    def test_add_custom_dtype(self, stype: str, atol: float):
+        itype = getattr(TensorProto, stype)
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["Xc"], to=itype),
+                    make_node("Cast", ["Y"], ["Yc"], to=itype),
+                    make_node("Add", ["Xc", "Yc"], ["Zc"]),
+                    make_node("Cast", ["Zc"], ["Z"], to=TensorProto.FLOAT),
+                ],
+                "nd",
+                [
+                    make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]),
+                    make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None]),
+                ],
+                [make_tensor_value_info("Z", TensorProto.FLOAT, [None, None, None])],
+            ),
+            opset_imports=[make_opsetid("", 18)],
+            ir_version=9,
+        )
+
+        ref = ReferenceEvaluator(model, verbose=0)
+
+        x = (np.arange(18) / 6).reshape((2, 3, 3)).astype(np.float32)
+        y = (np.arange(18) / 9).reshape((2, 3, 3)).astype(np.float32)
+        feeds = dict(X=x, Y=y)
+        expected = x + y
+        got = ref.run(None, feeds)[0]
+        assert_allclose(got, expected, atol=atol)
+
+    @pytest.mark.parametrize(
+        "stype",
+        [
+            "DOUBLE",
+            "FLOAT",
+            "FLOAT16",
+            "BFLOAT16",
+            "FLOAT8E4M3FN",
+            "FLOAT8E4M3FNUZ",
+            "FLOAT8E5M2",
+            "FLOAT8E5M2FNUZ",
+            "INT4",
+            "UINT4",
+            "INT2",
+            "UINT2",
+        ],
+    )
+    def test_cmp_custom_dtype(self, stype):
+        itype = getattr(TensorProto, stype)
+        model = make_model(
+            make_graph(
+                [
+                    make_node("Cast", ["X"], ["Xc"], to=itype),
+                    make_node("Cast", ["Y"], ["Yc"], to=itype),
+                    make_node("GreaterOrEqual", ["Xc", "Yc"], ["Zc"]),
+                    make_node("Cast", ["Zc"], ["Z"], to=TensorProto.BOOL),
+                ],
+                "nd",
+                [
+                    make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None]),
+                    make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None]),
+                ],
+                [make_tensor_value_info("Z", TensorProto.FLOAT, [None, None, None])],
+            ),
+            opset_imports=[make_opsetid("", 18)],
+            ir_version=9,
+        )
+
+        ref = ReferenceEvaluator(model)
+
+        x = (np.arange(18) / 18).reshape((2, 3, 3)).astype(np.float32)
+        y = ((np.arange(18) - 9) / 18).reshape((2, 3, 3)).astype(np.float32)
+        feeds = dict(X=x, Y=y)
+        expected = x >= y
+        got = ref.run(None, feeds)[0]
+        np.testing.assert_equal(got, expected)
+
+    def test_scatter_elements_4d(self):
+        model = make_model(
+            make_graph(
+                [
+                    make_node(
+                        "ScatterElements",
+                        ["data", "indices", "updates"],
+                        ["Z"],
+                        axis=3,
+                        reduction="add",
+                    )
+                ],
+                "name",
+                [
+                    make_tensor_value_info("data", TensorProto.FLOAT, None),
+                    make_tensor_value_info("indices", TensorProto.INT64, None),
+                    make_tensor_value_info("updates", TensorProto.FLOAT, None),
+                ],
+                [make_tensor_value_info("Z", TensorProto.FLOAT, None)],
+            ),
+            opset_imports=[make_opsetid("", 18)],
+        )
+        data = np.zeros(2**4, dtype=np.float32).reshape((2, 2, 2, 2))
+        indices = np.array([[[[0]]]], dtype=np.int64)
+        updates = np.array([[[[1]]]], dtype=np.float32)
+        y = np.array(
+            [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=np.float32
+        ).reshape((2, 2, 2, 2))
+        ref = ReferenceEvaluator(model)
+        got = ref.run(None, {"data": data, "indices": indices, "updates": updates})
+        assert_allclose(got[0], y)
+
+    def test_sequence_axis(self):
+        model = self._load_model(
+            """
+        <
+            ir_version: 8,
+            opset_import: [ "" : 21 ]
+        >
+        preprocess (seq(float[X, Y]) images) => (float[N, 5, 5] preprocessed)
+        {
+            seq = SequenceMap<
+                body=preprocess_single(float[X, Y] image) => (float[5, 5] resized)
+                {
+                    size = Constant<value=int64[2] {5, 5}>()
+
+                    resized = Resize<
+                        mode=\"linear\",
+                        axes=[0, 1]
+                    >(image, , , size)
+                }
+            >(images)
+            preprocessed = ConcatFromSequence<axis=0, new_axis=1>(seq)
+        }
+        """
+        )
+        evaluator = ReferenceEvaluator(model)
+        imageIn = np.zeros((10, 10), dtype=np.dtype("float32"))
+        output = evaluator.run(["preprocessed"], {"images": [imageIn]})[0]
+        assert output.shape == (1, 5, 5)
+
+    def test_convert_ml_dtypes(self):
+        model = make_model(
+            make_graph(
+                [make_node("LeakyRelu", ["X"], ["Y"], alpha=1.5)],
+                "name",
+                [make_tensor_value_info("X", TensorProto.DOUBLE, None)],
+                [make_tensor_value_info("Y", TensorProto.DOUBLE, None)],
+            ),
+            opset_imports=[make_opsetid("", 18)],
+        )
+        x = np.random.randn(3, 4).astype(np.float64)
+        ref = ReferenceEvaluator(model)
+        got = ref.run(None, {"X": x})
+        assert x.dtype == got[0].dtype
+
+    def test_apply_causal(self):
+        m = np.ones((3, 3), dtype=np.float16)
+        m = _apply_causal(m, 0)
+        assert m.dtype == np.float16
+        assert_allclose(
+            np.array(
+                [[1, -np.inf, -np.inf], [1, 1, -np.inf], [1, 1, 1]], dtype=m.dtype
+            ),
+            m,
+        )
+
+        m = np.zeros((3, 4), dtype=np.float16)
+        m = _apply_causal(m, 1)
+        assert m.dtype == np.float16
+        assert_allclose(
+            np.array(
+                [[0, 0, -np.inf, -np.inf], [0, 0, 0, -np.inf], [0, 0, 0, 0]],
+                dtype=m.dtype,
+            ),
+            m,
+        )
+
+    def test_softmax_fully_masked_row_returns_zero(self):
+        # A fully-masked row (all `-inf`) must softmax to all-zeros without
+        # producing NaN or emitting a NumPy warning.
+        x = np.array([[0.0, 1.0, 2.0], [-np.inf, -np.inf, -np.inf]], dtype=np.float64)
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            got = _softmax(x)
+        assert not np.isnan(got).any()
+        assert_allclose(got[1], np.zeros(3, dtype=np.float64))
+        # Unmasked rows still produce a valid probability distribution.
+        assert_allclose(got[0].sum(), 1.0)
+        assert_allclose(got[0], _softmax(x[:1])[0])
+
+    def test_center_crop_pad_no_change_when_shape_equals_dim(self):
+        """Test CenterCropPad when target shape equals current dimension.
+
+        Validates the fix where comparison should be 'if sh == dim' not 'if sh == a'.
+        Uses input (5, 5, 1) with target [1, 1, 1] to test axis 2 where dim=1, sh=1, a=2.
+        """
+        X = make_tensor_value_info("X", TensorProto.FLOAT, [None, None, None])
+        shape = make_tensor_value_info("shape", TensorProto.INT64, [3])
+        Y = make_tensor_value_info("Y", TensorProto.FLOAT, [None, None, None])
+        node = make_node("CenterCropPad", ["X", "shape"], ["Y"])
+        graph = make_graph([node], "g", [X, shape], [Y])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 18)])
+        check_model(onnx_model)
+
+        x = np.arange(25).reshape((5, 5, 1)).astype(np.float32)
+        target_shape = np.array([1, 1, 1], dtype=np.int64)
+        expected = x[2:3, 2:3, :]
+
+        sess = ReferenceEvaluator(onnx_model)
+        got = sess.run(None, {"X": x, "shape": target_shape})[0]
+
+        assert_allclose(got, expected)
+        assert got.shape == (1, 1, 1)
+
+    def test_scan_zero_scan_outputs(self):
+        # Regression test: a Scan node with K=0 scan outputs (only loop-state
+        # variables threaded through, no per-iteration accumulated outputs) is
+        # spec-legal and must not crash the reference evaluator with
+        # `ValueError: max() arg is an empty sequence` from _common_run_shape.
+        # Body: takes (state, scan_in_elt) -> (state + scan_in_elt). N=1, K=0.
+        body_state_in = make_tensor_value_info("s_in", TensorProto.FLOAT, [2])
+        body_scan_in = make_tensor_value_info("x_in", TensorProto.FLOAT, [2])
+        body_state_out = make_tensor_value_info("s_out", TensorProto.FLOAT, [2])
+        body = make_graph(
+            [make_node("Add", ["s_in", "x_in"], ["s_out"])],
+            "scan_body",
+            [body_state_in, body_scan_in],
+            [body_state_out],
+        )
+
+        init_state = make_tensor_value_info("init_state", TensorProto.FLOAT, [2])
+        scan_input = make_tensor_value_info("scan_input", TensorProto.FLOAT, [3, 2])
+        final_state = make_tensor_value_info("final_state", TensorProto.FLOAT, [2])
+        scan_node = make_node(
+            "Scan",
+            ["init_state", "scan_input"],
+            ["final_state"],
+            num_scan_inputs=1,
+            body=body,
+        )
+        graph = make_graph([scan_node], "g", [init_state, scan_input], [final_state])
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 21)])
+        check_model(onnx_model)
+
+        sess = ReferenceEvaluator(onnx_model)
+        init = np.zeros(2, dtype=np.float32)
+        xs = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
+        (got,) = sess.run(None, {"init_state": init, "scan_input": xs})
+
+        assert_allclose(got, xs.sum(axis=0))
+
+    def test_scan_max_iter_zero(self):
+        # Zero-length scan input (max_iter == 0) combined with scan outputs is
+        # an unsupported edge case in the reference implementation: the
+        # per-iteration element shape/dtype cannot be reliably synthesized
+        # without executing the body. The runtime must raise rather than
+        # silently produce a guess.
+        body = make_graph(
+            [
+                make_node("Add", ["s_in", "x_in"], ["s_out"]),
+                make_node("Identity", ["s_out"], ["scan_out"]),
+            ],
+            "scan_body",
+            [
+                make_tensor_value_info("s_in", TensorProto.FLOAT, [2]),
+                make_tensor_value_info("x_in", TensorProto.FLOAT, [2]),
+            ],
+            [
+                make_tensor_value_info("s_out", TensorProto.FLOAT, [2]),
+                make_tensor_value_info("scan_out", TensorProto.FLOAT, [2]),
+            ],
+        )
+        graph = make_graph(
+            [
+                make_node(
+                    "Scan",
+                    ["init", "xs"],
+                    ["final", "ys"],
+                    num_scan_inputs=1,
+                    body=body,
+                )
+            ],
+            "g",
+            [
+                make_tensor_value_info("init", TensorProto.FLOAT, [2]),
+                make_tensor_value_info("xs", TensorProto.FLOAT, [None, 2]),
+            ],
+            [
+                make_tensor_value_info("final", TensorProto.FLOAT, [2]),
+                make_tensor_value_info("ys", TensorProto.FLOAT, [None, 2]),
+            ],
+        )
+        onnx_model = make_model(graph, opset_imports=[make_opsetid("", 21)])
+        check_model(onnx_model)
+
+        sess = ReferenceEvaluator(onnx_model)
+        init = np.zeros(2, dtype=np.float32)
+        xs = np.zeros((0, 2), dtype=np.float32)
+        with pytest.raises(RuntimeError, match="zero scan-input length"):
+            sess.run(None, {"init": init, "xs": xs})
+
+    def test_scan_k_neq_m(self):
+        # Regression test for the original `num_scan_outputs = len(args) - N`
+        # bug, which incorrectly forced K == M. Here M=1 scan input but K=2
+        # scan outputs, so the body has N + K = 1 + 2 = 3 outputs (N=1
+        # loop-state var, K=2 scan outputs).
+        onnx_model = parser.parse_model(
+            """
+            <ir_version: 10, opset_import: [ "": 21 ]>
+            g (float[2] init, float[3, 2] xs)
+                => (float[2] final, float[3, 2] ys_a, float[3, 2] ys_b)
+            {
+                final, ys_a, ys_b = Scan <
+                    num_scan_inputs = 1,
+                    body = scan_body (float[2] s_in, float[2] x_in)
+                        => (float[2] s_out, float[2] scan_out_a, float[2] scan_out_b)
+                    {
+                        s_out = Add(s_in, x_in)
+                        scan_out_a = Identity(s_out)
+                        scan_out_b = Mul(x_in, x_in)
+                    }
+                > (init, xs)
+            }
+            """
+        )
+        check_model(onnx_model)
+
+        sess = ReferenceEvaluator(onnx_model)
+        init = np.zeros(2, dtype=np.float32)
+        xs = np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32)
+        final, ys_a, ys_b = sess.run(None, {"init": init, "xs": xs})
+
+        assert_allclose(final, xs.sum(axis=0))
+        assert_allclose(ys_a, np.cumsum(xs, axis=0))
+        assert_allclose(ys_b, xs * xs)
+
+    def test_scan_body_captures_outer_initializer(self):
+        # Regression test for Scan.need_context() / context plumbing.
+        # The body references `bias`, which is *not* a body input but an
+        # initializer in the enclosing graph. Without lexical-capture
+        # support the body would fail to resolve the name.
+        onnx_model = parser.parse_model(
+            """
+            <ir_version: 10, opset_import: [ "": 21 ]>
+            g (float[2] init, float[3, 2] xs) => (float[2] final)
+                <float[2] bias = {10, 100}>
+            {
+                final = Scan <
+                    num_scan_inputs = 1,
+                    body = scan_body (float[2] s_in, float[2] x_in)
+                        => (float[2] s_out)
+                    {
+                        s_out = Add(s_in, bias)
+                    }
+                > (init, xs)
+            }
+            """
+        )
+        check_model(onnx_model)
+
+        sess = ReferenceEvaluator(onnx_model)
+        init = np.zeros(2, dtype=np.float32)
+        # xs is unused by the body except to drive the iteration count (3).
+        xs = np.zeros((3, 2), dtype=np.float32)
+        (final,) = sess.run(None, {"init": init, "xs": xs})
+
+        # Each of the 3 iterations adds `bias` to the running state.
+        assert_allclose(final, np.array([30, 300], dtype=np.float32))
+
+    def test_causal_conv_with_state_silu_fp16_function_body(self):
+        # Regression test: the CausalConvWithState function body must upcast
+        # Sigmoid/Mul to float32 for the SiLU activation, matching the
+        # Python reference implementation. Without the upcast, the
+        # function-body expansion diverges from the registered op in fp16.
+        B, C, L, k = 2, 4, 8, 4
+        input_vi = make_tensor_value_info("input", TensorProto.FLOAT16, [B, C, L])
+        weight_vi = make_tensor_value_info("weight", TensorProto.FLOAT16, [C, 1, k])
+        bias_vi = make_tensor_value_info("bias", TensorProto.FLOAT16, [C])
+        past_vi = make_tensor_value_info(
+            "past_state", TensorProto.FLOAT16, [B, C, k - 1]
+        )
+        output_vi = make_tensor_value_info("output", TensorProto.FLOAT16, [B, C, L])
+        present_vi = make_tensor_value_info(
+            "present_state", TensorProto.FLOAT16, [B, C, k - 1]
+        )
+        node = make_node(
+            "CausalConvWithState",
+            ["input", "weight", "bias", "past_state"],
+            ["output", "present_state"],
+            activation="silu",
+        )
+        model = make_model(
+            make_graph(
+                [node],
+                "g",
+                [input_vi, weight_vi, bias_vi, past_vi],
+                [output_vi, present_vi],
+            ),
+            opset_imports=[make_opsetid("", 27)],
+        )
+        check_model(model)
+
+        rng = np.random.default_rng(0)
+        input_ = rng.standard_normal((B, C, L)).astype(np.float16)
+        weight = rng.standard_normal((C, 1, k)).astype(np.float16)
+        bias = rng.standard_normal((C,)).astype(np.float16)
+        past_state = rng.standard_normal((B, C, k - 1)).astype(np.float16)
+        feeds = {
+            "input": input_,
+            "weight": weight,
+            "bias": bias,
+            "past_state": past_state,
+        }
+
+        # Baseline: registered Python reference (upcasts SiLU to float32).
+        ref = ReferenceEvaluator(model)
+        expected_output, expected_state = ref.run(None, feeds)
+
+        # Force expansion via the schema's context-dependent function body.
+        class CausalConvWithState(OpRunExpand):
+            op_domain = ""
+
+        ref_expand = ReferenceEvaluator(model, new_ops=[CausalConvWithState])
+        got_output, got_state = ref_expand.run(None, feeds)
+
+        assert_allclose(got_state, expected_state)
+        assert_allclose(got_output, expected_output)
diff --git a/onnx/test/schema_test.py b/onnx/test/schema_test.py
new file mode 100644
index 0000000..4cfe570
--- /dev/null
+++ b/onnx/test/schema_test.py
@@ -0,0 +1,563 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import contextlib
+from typing import TYPE_CHECKING
+
+import pytest
+
+import onnx
+from onnx import defs
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+class TestSchema:
+    def test_get_schema(self) -> None:
+        relu_schema = defs.get_schema("Relu")
+        assert (
+            relu_schema.node_determinism == defs.OpSchema.NodeDeterminism.Deterministic
+        )
+
+    def test_typecheck(self) -> None:
+        defs.get_schema("Conv")
+
+    def test_attr_default_value(self) -> None:
+        v = defs.get_schema("BatchNormalization").attributes["epsilon"].default_value
+        assert type(v) is onnx.AttributeProto
+        assert v.type == onnx.AttributeProto.FLOAT
+
+    def test_function_body(self) -> None:
+        selu_schema = defs.get_schema("Selu")
+        assert type(selu_schema.function_body) is onnx.FunctionProto
+        assert (
+            selu_schema.node_determinism == defs.OpSchema.NodeDeterminism.Deterministic
+        )
+
+    def test_node_determinism(self) -> None:
+        rand_schema = defs.get_schema("RandomNormalLike")
+        assert (
+            rand_schema.node_determinism
+            == defs.OpSchema.NodeDeterminism.NonDeterministic
+        )
+        assert rand_schema.non_deterministic
+        bn_schema = defs.get_schema("BatchNormalization")
+        assert bn_schema.node_determinism == defs.OpSchema.NodeDeterminism.Deterministic
+        assert not bn_schema.non_deterministic
+        cast_like_schema = defs.get_schema("CastLike")
+        assert (
+            cast_like_schema.node_determinism
+            == defs.OpSchema.NodeDeterminism.Deterministic
+        )
+        assert not cast_like_schema.non_deterministic
+        if_schema = defs.get_schema("If")
+        assert (
+            if_schema.node_determinism == defs.OpSchema.NodeDeterminism.NonDeterministic
+        )
+        assert if_schema.non_deterministic
+
+    def test_celu_type_constraints(self) -> None:
+        def allowed(schema):
+            return next(
+                set(t.allowed_type_strs)
+                for t in schema.type_constraints
+                if t.type_param_str == "T"
+            )
+
+        celu28 = defs.get_schema("Celu", 28)
+        assert allowed(celu28) == {
+            "tensor(bfloat16)",
+            "tensor(float16)",
+            "tensor(float)",
+            "tensor(double)",
+        }
+        assert celu28.has_function
+        assert allowed(defs.get_schema("Celu", 12)) == {"tensor(float)"}
+
+    def test_range_supported_types(self) -> None:
+        """Test Range operator supports all expected numeric types."""
+        range_schema = defs.get_schema("Range")
+
+        supported_types = set()
+        for constraint in range_schema.type_constraints:
+            if constraint.type_param_str == "T":
+                supported_types.update(constraint.allowed_type_strs)
+
+        expected_types = {
+            "tensor(float16)",
+            "tensor(bfloat16)",
+            "tensor(float)",
+            "tensor(double)",
+            "tensor(int16)",
+            "tensor(int32)",
+            "tensor(int64)",
+        }
+
+        for expected_type in expected_types:
+            assert expected_type in supported_types, (
+                f"Range should support {expected_type}"
+            )
+
+        # Verify no unexpected types are supported (regression check)
+        allowed_type_families = {
+            "float16",
+            "bfloat16",
+            "float",
+            "double",
+            "int16",
+            "int32",
+            "int64",
+        }
+
+        for supported_type in supported_types:
+            if supported_type.startswith("tensor(") and supported_type.endswith(")"):
+                base_type = supported_type[7:-1]
+                assert base_type in allowed_type_families, (
+                    f"Unexpected type {supported_type} supported by Range"
+                )
+
+    def test_range_type_consistency(self) -> None:
+        """Test Range operator type constraints are consistent."""
+        range_schema = defs.get_schema("Range")
+
+        # All inputs should use the same type constraint "T"
+        expected_input_names = ["start", "limit", "delta"]
+        assert len(range_schema.inputs) == len(expected_input_names)
+
+        for i, expected_name in enumerate(expected_input_names):
+            input_param = range_schema.inputs[i]
+            assert input_param.name == expected_name
+            assert input_param.type_str == "T", (
+                f"Input '{expected_name}' should use type constraint 'T'"
+            )
+
+        assert len(range_schema.outputs) == 1
+        output_param = range_schema.outputs[0]
+        assert output_param.name == "output"
+        assert output_param.type_str == "T", "Output should use type constraint 'T'"
+
+        type_constraints = [
+            c for c in range_schema.type_constraints if c.type_param_str == "T"
+        ]
+        assert len(type_constraints) == 1, (
+            "Range should have exactly one type constraint 'T'"
+        )
+
+    def test_range_numeric_types_only(self) -> None:
+        """Test Range operator only supports appropriate numeric types."""
+        range_schema = defs.get_schema("Range")
+
+        supported_types = set()
+        for constraint in range_schema.type_constraints:
+            if constraint.type_param_str == "T":
+                supported_types.update(constraint.allowed_type_strs)
+
+        unsupported_types = {
+            "tensor(bool)",
+            "tensor(string)",
+            "tensor(uint8)",
+            "tensor(uint16)",
+            "tensor(uint32)",
+            "tensor(uint64)",
+            "tensor(int8)",
+        }
+
+        for unsupported_type in unsupported_types:
+            assert unsupported_type not in supported_types, (
+                f"Range should not support {unsupported_type}"
+            )
+
+        # All supported types should be appropriate for arithmetic operations
+        for supported_type in supported_types:
+            assert supported_type.startswith("tensor("), (
+                f"All Range types should be tensors, got {supported_type}"
+            )
+
+            base_type = supported_type[7:-1]
+            assert base_type in [
+                "float16",
+                "bfloat16",
+                "float",
+                "double",
+                "int16",
+                "int32",
+                "int64",
+            ], f"Range type {base_type} should be a supported numeric type"
+
+
+class TestOpSchema:
+    def test_init(self):
+        # Test that the constructor creates an OpSchema object
+        schema = defs.OpSchema("test_op", "test_domain", 1)
+        assert isinstance(schema, defs.OpSchema)
+        assert schema.node_determinism == defs.OpSchema.NodeDeterminism.Deterministic
+
+    def test_init_with_inputs(self) -> None:
+        op_schema = defs.OpSchema(
+            "test_op",
+            "test_domain",
+            1,
+            inputs=[defs.OpSchema.FormalParameter("input1", "T")],
+            type_constraints=[("T", ["tensor(int64)"], "")],
+        )
+        assert op_schema.name == "test_op"
+        assert op_schema.domain == "test_domain"
+        assert op_schema.since_version == 1
+        assert len(op_schema.inputs) == 1
+        assert op_schema.inputs[0].name == "input1"
+        assert op_schema.inputs[0].type_str == "T"
+        assert len(op_schema.type_constraints) == 1
+        assert op_schema.type_constraints[0].type_param_str == "T"
+        assert op_schema.type_constraints[0].allowed_type_strs == ["tensor(int64)"]
+
+    def test_init_creates_multi_input_output_schema(self) -> None:
+        op_schema = defs.OpSchema(
+            "test_op",
+            "test_domain",
+            1,
+            inputs=[
+                defs.OpSchema.FormalParameter("input1", "T"),
+                defs.OpSchema.FormalParameter("input2", "T"),
+            ],
+            outputs=[
+                defs.OpSchema.FormalParameter("output1", "T"),
+                defs.OpSchema.FormalParameter("output2", "T"),
+            ],
+            type_constraints=[("T", ["tensor(int64)"], "")],
+            attributes=[
+                defs.OpSchema.Attribute(
+                    "attr1", defs.OpSchema.AttrType.INTS, "attr1 description"
+                )
+            ],
+        )
+        assert len(op_schema.inputs) == 2
+        assert op_schema.inputs[0].name == "input1"
+        assert op_schema.inputs[0].type_str == "T"
+        assert op_schema.inputs[1].name == "input2"
+        assert op_schema.inputs[1].type_str == "T"
+        assert len(op_schema.outputs) == 2
+        assert op_schema.outputs[0].name == "output1"
+        assert op_schema.outputs[0].type_str == "T"
+        assert op_schema.outputs[1].name == "output2"
+        assert op_schema.outputs[1].type_str == "T"
+        assert len(op_schema.type_constraints) == 1
+        assert op_schema.type_constraints[0].type_param_str == "T"
+        assert op_schema.type_constraints[0].allowed_type_strs == ["tensor(int64)"]
+        assert len(op_schema.attributes) == 1
+        assert op_schema.attributes["attr1"].name == "attr1"
+        assert op_schema.attributes["attr1"].type == defs.OpSchema.AttrType.INTS
+        assert op_schema.attributes["attr1"].description == "attr1 description"
+
+    def test_init_without_optional_arguments(self) -> None:
+        op_schema = defs.OpSchema("test_op", "test_domain", 1)
+        assert op_schema.name == "test_op"
+        assert op_schema.domain == "test_domain"
+        assert op_schema.since_version == 1
+        assert len(op_schema.inputs) == 0
+        assert len(op_schema.outputs) == 0
+        assert len(op_schema.type_constraints) == 0
+
+    def test_name(self):
+        # Test that the name parameter is required and is a string
+        with pytest.raises(TypeError):
+            defs.OpSchema(domain="test_domain", since_version=1)
+        with pytest.raises(TypeError):
+            defs.OpSchema(123, "test_domain", 1)
+
+        schema = defs.OpSchema("test_op", "test_domain", 1)
+        assert schema.name == "test_op"
+
+    def test_domain(self):
+        # Test that the domain parameter is required and is a string
+        with pytest.raises(TypeError):
+            defs.OpSchema(name="test_op", since_version=1)
+        with pytest.raises(TypeError):
+            defs.OpSchema("test_op", 123, 1)
+
+        schema = defs.OpSchema("test_op", "test_domain", 1)
+        assert schema.domain == "test_domain"
+
+    def test_since_version(self):
+        # Test that the since_version parameter is required and is an integer
+        with pytest.raises(TypeError):
+            defs.OpSchema("test_op", "test_domain")
+
+        schema = defs.OpSchema("test_op", "test_domain", 1)
+        assert schema.since_version == 1
+
+    def test_doc(self):
+        schema = defs.OpSchema("test_op", "test_domain", 1, doc="test_doc")
+        assert schema.doc == "test_doc"
+
+    def test_inputs(self):
+        # Test that the inputs parameter is optional and is a sequence of FormalParameter tuples
+        inputs = [
+            defs.OpSchema.FormalParameter(
+                name="input1", type_str="T", description="The first input."
+            )
+        ]
+        schema = defs.OpSchema(
+            "test_op",
+            "test_domain",
+            1,
+            inputs=inputs,
+            type_constraints=[("T", ["tensor(int64)"], "")],
+        )
+
+        assert len(schema.inputs) == 1
+        assert schema.inputs[0].name == "input1"
+        assert schema.inputs[0].type_str == "T"
+        assert schema.inputs[0].description == "The first input."
+
+    def test_outputs(self):
+        # Test that the outputs parameter is optional and is a sequence of FormalParameter tuples
+        outputs = [
+            defs.OpSchema.FormalParameter(
+                name="output1", type_str="T", description="The first output."
+            )
+        ]
+
+        schema = defs.OpSchema(
+            "test_op",
+            "test_domain",
+            1,
+            outputs=outputs,
+            type_constraints=[("T", ["tensor(int64)"], "")],
+        )
+        assert len(schema.outputs) == 1
+        assert schema.outputs[0].name == "output1"
+        assert schema.outputs[0].type_str == "T"
+        assert schema.outputs[0].description == "The first output."
+
+
+class TestFormalParameter:
+    def test_init(self):
+        name = "input1"
+        type_str = "tensor(float)"
+        description = "The first input."
+        param_option = defs.OpSchema.FormalParameterOption.Single
+        is_homogeneous = True
+        min_arity = 1
+        differentiation_category = defs.OpSchema.DifferentiationCategory.Unknown
+        formal_parameter = defs.OpSchema.FormalParameter(
+            name,
+            type_str,
+            description,
+            param_option=param_option,
+            is_homogeneous=is_homogeneous,
+            min_arity=min_arity,
+            differentiation_category=differentiation_category,
+        )
+
+        assert formal_parameter.name == name
+        assert formal_parameter.type_str == type_str
+        assert isinstance(formal_parameter.types, set)
+        assert formal_parameter.description == description
+        assert formal_parameter.option == param_option
+        assert formal_parameter.is_homogeneous == is_homogeneous
+        assert formal_parameter.min_arity == min_arity
+        assert formal_parameter.differentiation_category == differentiation_category
+
+
+class TestTypeConstraintParam:
+    @pytest.mark.parametrize(
+        "allowed_types",
+        [
+            pytest.param(["tensor(float)"], id="list_single"),
+            pytest.param(["tensor(float)", "tensor(int64)"], id="list_multiple"),
+            pytest.param(("tensor(float)", "tensor(int64)"), id="tuple_multiple"),
+        ],
+    )
+    def test_init(self, allowed_types: Sequence[str]) -> None:
+        type_param_str = "T"
+        description = "Test description"
+        type_constraint = defs.OpSchema.TypeConstraintParam(
+            type_param_str, allowed_types, description
+        )
+        assert type_constraint.description == description
+        assert type_constraint.allowed_type_strs == list(allowed_types)
+        assert type_constraint.type_param_str == type_param_str
+
+
+class TestAttribute:
+    def test_init(self):
+        name = "test_attr"
+        type_ = defs.OpSchema.AttrType.STRINGS
+        description = "Test attribute"
+        attribute = defs.OpSchema.Attribute(name, type_, description)
+
+        assert attribute.name == name
+        assert attribute.type == type_
+        assert attribute.description == description
+
+    def test_init_with_default_value(self):
+        default_value = (
+            defs.get_schema("BatchNormalization").attributes["epsilon"].default_value
+        )
+        assert isinstance(default_value, onnx.AttributeProto)
+        attribute = defs.OpSchema.Attribute("attr1", default_value, "attr1 description")
+        assert default_value == attribute.default_value
+        assert attribute.name == "attr1"
+        assert attribute.description == "attr1 description"
+
+
+@pytest.mark.parametrize(
+    ("op_type", "op_version", "op_domain", "trap_op_version"),
+    [
+        # register to exist domain
+        ("CustomOp", 5, "", [1, 2, 6, 7]),
+        # register to new domain
+        ("CustomOp", 5, "test", [1, 2, 6, 7]),
+    ],
+)
+class TestOpSchemaRegister:
+    op_type: str
+    op_version: int
+    op_domain: str
+    # register some fake schema to check behavior
+    trap_op_version: list[int]
+
+    @pytest.fixture(autouse=True)
+    def _register_schema(self, op_type, op_version, op_domain, trap_op_version):
+        self.op_type = op_type
+        self.op_version = op_version
+        self.op_domain = op_domain
+        self.trap_op_version = trap_op_version
+        # Ensure the schema is unregistered
+        assert not onnx.defs.has(self.op_type, self.op_domain)
+        yield
+        # Clean up the registered schema
+        for version in [*self.trap_op_version, self.op_version]:
+            with contextlib.suppress(onnx.defs.SchemaError):
+                onnx.defs.deregister_schema(self.op_type, version, self.op_domain)
+
+    def test_register_multi_schema(self):
+        for version in [*self.trap_op_version, self.op_version]:
+            op_schema = defs.OpSchema(
+                self.op_type,
+                self.op_domain,
+                version,
+            )
+            onnx.defs.register_schema(op_schema)
+            assert onnx.defs.has(self.op_type, version, self.op_domain)
+        for version in [*self.trap_op_version, self.op_version]:
+            # Also make sure the `op_schema` is accessible after register
+            registered_op = onnx.defs.get_schema(
+                op_schema.name, version, op_schema.domain
+            )
+            op_schema = defs.OpSchema(
+                self.op_type,
+                self.op_domain,
+                version,
+            )
+            assert str(registered_op) == str(op_schema)
+
+    def test_using_the_specified_version_in_onnx_check(self):
+        input = f"""
+            <
+                ir_version: 7,
+                opset_import: [
+                    "{self.op_domain}" : {self.op_version}
+                ]
+            >
+            agraph (float[N, 128] X, int32 Y) => (float[N] Z)
+            {{
+                Z = {self.op_domain}.{self.op_type}<attr1=[1,2]>(X, Y)
+            }}
+           """
+        model = onnx.parser.parse_model(input)
+        op_schema = defs.OpSchema(
+            self.op_type,
+            self.op_domain,
+            self.op_version,
+            inputs=[
+                defs.OpSchema.FormalParameter("input1", "T"),
+                defs.OpSchema.FormalParameter("input2", "int32"),
+            ],
+            outputs=[
+                defs.OpSchema.FormalParameter("output1", "T"),
+            ],
+            type_constraints=[("T", ["tensor(float)"], "")],
+            attributes=[
+                defs.OpSchema.Attribute(
+                    "attr1", defs.OpSchema.AttrType.INTS, "attr1 description"
+                )
+            ],
+        )
+        with pytest.raises(onnx.checker.ValidationError):
+            onnx.checker.check_model(model, check_custom_domain=True)
+        onnx.defs.register_schema(op_schema)
+        # The fake schema will raise check exception if selected in checker
+        for version in self.trap_op_version:
+            onnx.defs.register_schema(
+                defs.OpSchema(
+                    self.op_type,
+                    self.op_domain,
+                    version,
+                    outputs=[
+                        defs.OpSchema.FormalParameter("output1", "int32"),
+                    ],
+                )
+            )
+        onnx.checker.check_model(model, check_custom_domain=True)
+
+    def test_register_schema_raises_error_when_registering_a_schema_twice(self):
+        op_schema = defs.OpSchema(
+            self.op_type,
+            self.op_domain,
+            self.op_version,
+        )
+        onnx.defs.register_schema(op_schema)
+        with pytest.raises(onnx.defs.SchemaError):
+            onnx.defs.register_schema(op_schema)
+
+    def test_deregister_the_specified_schema(self):
+        for version in [*self.trap_op_version, self.op_version]:
+            op_schema = defs.OpSchema(
+                self.op_type,
+                self.op_domain,
+                version,
+            )
+            onnx.defs.register_schema(op_schema)
+            assert onnx.defs.has(op_schema.name, version, op_schema.domain)
+        onnx.defs.deregister_schema(op_schema.name, self.op_version, op_schema.domain)
+        for version in self.trap_op_version:
+            assert onnx.defs.has(op_schema.name, version, op_schema.domain)
+        # Maybe has lesser op version in trap list
+        if onnx.defs.has(op_schema.name, self.op_version, op_schema.domain):
+            schema = onnx.defs.get_schema(
+                op_schema.name, self.op_version, op_schema.domain
+            )
+            assert schema.since_version < self.op_version
+
+    def test_deregister_schema_raises_error_when_opschema_does_not_exist(self):
+        with pytest.raises(onnx.defs.SchemaError):
+            onnx.defs.deregister_schema(self.op_type, self.op_version, self.op_domain)
+
+    def test_legacy_schema_accessible_after_deregister(self):
+        op_schema = defs.OpSchema(
+            self.op_type,
+            self.op_domain,
+            self.op_version,
+        )
+        onnx.defs.register_schema(op_schema)
+        schema_a = onnx.defs.get_schema(
+            op_schema.name, op_schema.since_version, op_schema.domain
+        )
+        schema_b = onnx.defs.get_schema(op_schema.name, op_schema.domain)
+
+        def filter_schema(schemas):
+            return [op for op in schemas if op.name == op_schema.name]
+
+        schema_c = filter_schema(onnx.defs.get_all_schemas())
+        schema_d = filter_schema(onnx.defs.get_all_schemas_with_history())
+        assert len(schema_c) == 1
+        assert len(schema_d) == 1
+        # Avoid memory residue and access storage as much as possible
+        assert str(schema_a) == str(op_schema)
+        assert str(schema_b) == str(op_schema)
+        assert str(schema_c[0]) == str(op_schema)
+        assert str(schema_d[0]) == str(op_schema)
diff --git a/onnx/test/serialization_test.py b/onnx/test/serialization_test.py
new file mode 100644
index 0000000..9482953
--- /dev/null
+++ b/onnx/test/serialization_test.py
@@ -0,0 +1,98 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+import tempfile
+
+import pytest
+
+import onnx
+
+_TEST_MODEL = """\
+<
+    ir_version: 8,
+    opset_import: ["" : 17, "local" : 1]
+>
+agraph (float[N] X) => (float[N] Y) {
+    Y = local.foo (X)
+}
+
+<opset_import: ["" : 17, "local" : 1], domain: "local">
+foo (x) => (y) {
+    temp = Add(x, x)
+    y = local.bar(temp)
+}
+
+<opset_import: ["" : 17], domain: "local">
+bar (x) => (y) {
+    y = Mul (x, x)
+}"""
+
+
+class _OnnxTestTextualSerializer(onnx.serialization.ProtoSerializer):
+    """Serialize and deserialize the ONNX textual representation."""
+
+    supported_format = "onnxtext"
+    file_extensions = frozenset({".onnxtext"})
+
+    def serialize_proto(self, proto) -> bytes:
+        text = onnx.printer.to_text(proto)
+        return text.encode("utf-8")
+
+    def deserialize_proto(self, serialized: bytes, proto):
+        text = serialized.decode("utf-8")
+        if isinstance(proto, onnx.ModelProto):
+            return onnx.parser.parse_model(text)
+        if isinstance(proto, onnx.GraphProto):
+            return onnx.parser.parse_graph(text)
+        if isinstance(proto, onnx.FunctionProto):
+            return onnx.parser.parse_function(text)
+        if isinstance(proto, onnx.NodeProto):
+            return onnx.parser.parse_node(text)
+        raise ValueError(f"Unsupported proto type: {type(proto)}")
+
+
+class TestRegistry:
+    @pytest.fixture(autouse=True)
+    def register_serializer(self):
+        self.serializer = _OnnxTestTextualSerializer()
+        # FIXME: There is no API to unregister
+        onnx.serialization.registry.register(self.serializer)
+
+    def test_get_returns_the_registered_instance(self) -> None:
+        serializer = onnx.serialization.registry.get("onnxtext")
+        assert serializer is self.serializer
+
+    def test_get_raises_for_unsupported_format(self) -> None:
+        with pytest.raises(ValueError):
+            onnx.serialization.registry.get("unsupported")
+
+    def test_onnx_save_load_model_uses_the_custom_serializer(self) -> None:
+        model = onnx.parser.parse_model(_TEST_MODEL)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            model_path = os.path.join(tmpdir, "model.onnx")
+            onnx.save_model(model, model_path, format="onnxtext")
+
+            # Check the file content
+            with open(model_path, encoding="utf-8") as f:
+                content = f.read()
+                assert content == onnx.printer.to_text(model)
+
+            loaded_model = onnx.load_model(model_path, format="onnxtext")
+
+            assert model.SerializeToString(
+                deterministic=True
+            ) == loaded_model.SerializeToString(deterministic=True)
+
+
+class TestCustomSerializer:
+    def test_serialize_deserialize_model(self) -> None:
+        serializer = _OnnxTestTextualSerializer()
+        model = onnx.parser.parse_model(_TEST_MODEL)
+        serialized = serializer.serialize_proto(model)
+        deserialized = serializer.deserialize_proto(serialized, onnx.ModelProto())
+        assert model.SerializeToString(
+            deterministic=True
+        ) == deserialized.SerializeToString(deterministic=True)
diff --git a/onnx/test/shape_inference_test.py b/onnx/test/shape_inference_test.py
new file mode 100644
index 0000000..c63bc87
--- /dev/null
+++ b/onnx/test/shape_inference_test.py
@@ -0,0 +1,13184 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import contextlib
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import pytest
+from google.protobuf import text_format
+
+import onnx.shape_inference
+from onnx import (
+    ONNX_ML,
+    GraphProto,
+    ModelProto,
+    NodeProto,
+    OperatorSetIdProto,
+    SparseTensorProto,
+    TensorProto,
+    TensorShapeProto,
+    TypeProto,
+    ValueInfoProto,
+    checker,
+    defs,
+    helper,
+    numpy_helper,
+)
+from onnx.defs import (
+    AI_ONNX_PREVIEW_DOMAIN,
+    AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+    ONNX_DOMAIN,
+    ONNX_ML_DOMAIN,
+    OpSchema,
+    SchemaError,
+)
+from onnx.helper import (
+    make_empty_tensor_value_info,
+    make_graph,
+    make_model,
+    make_node,
+    make_opsetid,
+    make_tensor,
+    make_tensor_sequence_value_info,
+    make_tensor_value_info,
+)
+from onnx.parser import parse_graph
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def get_available_versions(schema: OpSchema) -> set[int]:
+    versions: set[int] = set()
+    for version in range(schema.since_version, 0, -1):
+        try:
+            versions.add(
+                defs.get_schema(schema.name, version, schema.domain).since_version
+            )
+        except SchemaError:  # noqa: PERF203
+            break
+    return versions
+
+
+ALL_OP_VERSIONS: dict[str, tuple[str, frozenset[int]]] = {
+    schema.name: (schema.domain, frozenset(get_available_versions(schema)))
+    for schema in defs.get_all_schemas()
+}
+
+
+def all_versions_for(op_name: str) -> list[int]:
+    domain, versions_set = ALL_OP_VERSIONS[op_name]
+    if not versions_set:
+        raise ValueError(f"No versions available for operator {op_name}")
+    versions = sorted(versions_set)
+    return [
+        version
+        for version in versions
+        # FIXME(#5289): Reshape errors in self._make_graph when version <= 5.
+        # Issue reference: https://github.com/onnx/onnx/issues/5289.
+        if version > 5 or domain != ONNX_DOMAIN
+    ]
+
+
+class TestShapeInferenceHelper:
+    def _make_graph(
+        self,
+        seed_values: Sequence[str | tuple[str, TensorProto.DataType, Any]],
+        nodes: list[NodeProto],
+        value_info: list[ValueInfoProto],
+        initializer: Sequence[TensorProto] | None = None,
+    ) -> GraphProto:
+        if initializer is None:
+            initializer = []
+        names_in_initializer = {x.name for x in initializer}
+        input_value_infos = []
+        # If the starting values are not also initializers,
+        # introduce the starting values as the output of reshape,
+        # so that the sizes are guaranteed to be unknown
+        for seed_value in seed_values:
+            if isinstance(seed_value, tuple):
+                seed_name, proto_type = seed_value[:2]
+                seed_value_info = make_tensor_value_info(*seed_value)
+            else:
+                seed_name, proto_type = seed_value, TensorProto.UNDEFINED
+                seed_value_info = make_empty_tensor_value_info(seed_value)
+            if seed_name in names_in_initializer:
+                input_value_infos.append(seed_value_info)
+            else:
+                value_info.append(seed_value_info)
+                input_value_infos.append(
+                    make_tensor_value_info("SEED_" + seed_name, proto_type, ())
+                )
+                input_value_infos.append(
+                    make_tensor_value_info(
+                        "UNKNOWN_SHAPE_" + seed_name, TensorProto.INT64, (None,)
+                    )
+                )
+                nodes[:0] = [
+                    make_node(
+                        "Reshape",
+                        ["SEED_" + seed_name, "UNKNOWN_SHAPE_" + seed_name],
+                        [seed_name],
+                    )
+                ]
+        return helper.make_graph(
+            nodes,
+            "test",
+            input_value_infos,
+            [],
+            initializer=initializer,
+            value_info=value_info,
+        )
+
+    def _inferred(
+        self, graph_or_model: GraphProto | ModelProto, **kwargs: Any
+    ) -> ModelProto:
+        data_prop = kwargs.pop("data_prop", False)
+        if isinstance(graph_or_model, GraphProto):
+            kwargs["producer_name"] = "onnx-test"
+            orig_model = helper.make_model(graph_or_model, **kwargs)
+        else:
+            orig_model = graph_or_model
+        inferred_model = onnx.shape_inference.infer_shapes(
+            orig_model, strict_mode=True, data_prop=data_prop
+        )
+        checker.check_model(inferred_model)
+        return inferred_model
+
+    def _assert_inferred(
+        self,
+        graph_or_model: GraphProto | ModelProto,
+        inferred_value_infos: list[ValueInfoProto],
+        **kwargs: Any,
+    ) -> None:
+        graph = (
+            graph_or_model
+            if isinstance(graph_or_model, GraphProto)
+            else graph_or_model.graph
+        )
+        # "inferred_value_infos" specifies the expected delta produced by type/shape inference.
+        # The types/shapes specified in inferred_value_infos should be inferred by the inference implementation,
+        # while for names not in inferred_value_infos, the original type/shape in input model should be preserved.
+        names_in_inferred_value_infos = {x.name for x in inferred_value_infos}
+        # The types/shapes can be recorded in graph.output and/or graph.value_info.
+        # For the input model, if a name is specified in both, verify the two records
+        # agree (symmetric to the check applied to the inferred model below), to avoid
+        # masking inconsistent test inputs.
+        expected: dict[str, ValueInfoProto] = {}
+        for x in [*graph.value_info, *graph.output]:
+            if x.name in names_in_inferred_value_infos:
+                continue
+            if x.name in expected:
+                self._compare_value_infos(expected[x.name].type, x.type)
+            else:
+                expected[x.name] = x
+        expected.update({x.name: x for x in inferred_value_infos})
+        inferred_model = self._inferred(graph_or_model, **kwargs)
+        inferred_graph = inferred_model.graph
+        # Inferred type info may be recorded either in value_info (intermediate
+        # values, and outputs that were untyped in the input model) or directly on
+        # the graph outputs (outputs that were already typed). Merge both by name.
+        # An untyped graph output is recorded in BOTH value_info and output; when a
+        # name appears in both, verify that the two records agree.
+        inferred: dict[str, ValueInfoProto] = {}
+        for x in [*inferred_graph.value_info, *inferred_graph.output]:
+            if x.name in inferred:
+                self._compare_value_infos(inferred[x.name].type, x.type)
+            else:
+                inferred[x.name] = x
+        assert expected.keys() == inferred.keys(), (
+            f"\nExpected value infos for: {sorted(expected)}"
+            f"\nInferred value infos for: {sorted(inferred)}\n"
+        )
+        for name, expected_vi in expected.items():
+            self._compare_value_infos(expected_vi.type, inferred[name].type)
+
+    def _compare_value_infos(
+        self, vi_type: TypeProto, inferred_vi_type: TypeProto
+    ) -> None:
+        if vi_type.HasField("tensor_type"):
+            assert inferred_vi_type.HasField("tensor_type")
+            assert vi_type.tensor_type.HasField("elem_type")
+            assert inferred_vi_type.tensor_type.HasField("elem_type")
+            assert (
+                vi_type.tensor_type.elem_type == inferred_vi_type.tensor_type.elem_type
+            )
+            assert vi_type.tensor_type.HasField(
+                "shape"
+            ) == inferred_vi_type.tensor_type.HasField("shape")
+            if vi_type.tensor_type.HasField("shape"):
+                assert len(vi_type.tensor_type.shape.dim) == len(
+                    inferred_vi_type.tensor_type.shape.dim
+                )
+                for dim_i, dim in enumerate(vi_type.tensor_type.shape.dim):
+                    inferred_dim = inferred_vi_type.tensor_type.shape.dim[dim_i]
+                    # if it is a symbolic shape, make sure the inferred symbol has generated (dim_param)
+                    if dim.dim_param:
+                        assert dim.dim_param == inferred_dim.dim_param, (
+                            f"\n{vi_type}\n{inferred_vi_type}\n"
+                        )
+                    else:
+                        assert dim.dim_value == inferred_dim.dim_value, (
+                            f"\n{vi_type}\n{inferred_vi_type}\n"
+                        )
+        elif vi_type.HasField("sequence_type"):
+            assert inferred_vi_type.HasField("sequence_type")
+            vi = vi_type.sequence_type.elem_type
+            inferred_vi = inferred_vi_type.sequence_type.elem_type
+            self._compare_value_infos(vi, inferred_vi)
+        elif vi_type.HasField("optional_type"):
+            assert inferred_vi_type.HasField("optional_type")
+            vi = vi_type.optional_type.elem_type
+            inferred_vi = inferred_vi_type.optional_type.elem_type
+            self._compare_value_infos(vi, inferred_vi)
+        elif vi_type.HasField("map_type"):
+            assert inferred_vi_type.HasField("map_type")
+            assert vi_type.map_type.key_type == vi_type.map_type.key_type
+            self._compare_value_infos(
+                vi_type.map_type.value_type, inferred_vi_type.map_type.value_type
+            )
+        elif vi_type == onnx.TypeProto():
+            assert inferred_vi_type == onnx.TypeProto()
+        else:
+            raise NotImplementedError(
+                "Unrecognized value info type in _compare_value_infos: ", str(vi_type)
+            )
+
+    def skipIf(self, condition, reason):
+        if condition:
+            pytest.skip(reason)
+
+
+class TestShapeInference(TestShapeInferenceHelper):
+    def test_empty_graph(self) -> None:
+        graph = self._make_graph(["y"], [], [])
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def _identity_prop(self, op: str, **kwargs: Any) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (30, 4, 5))],
+            [make_node(op, "x", "y", **kwargs)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (30, 4, 5))]
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Transpose"))
+    def test_transpose(self, version) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 3, 4))],
+            [make_node("Transpose", ["X"], ["Y"], perm=[1, 0, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (3, 2, 4))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Transpose"))
+    def test_transpose_preexisting(self, version) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 3, 4))],
+            [make_node("Transpose", ["X"], ["Y"], perm=[1, 0, 2])],
+            [make_tensor_value_info("Y", TensorProto.FLOAT, None)],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (3, 2, 4))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Transpose"))
+    def test_transpose_scalar(self, version) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, ())],
+            [make_node("Transpose", ["X"], ["Y"])],
+            [],
+        )
+
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, ())],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Transpose"))
+    def test_transpose_partial(self, version) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 3, 4))],
+            [make_node("Transpose", ["X"], ["Y"], perm=[1, 0, 2])],
+            [make_tensor_value_info("Y", TensorProto.UNDEFINED, (3, "a", "b"))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (3, 2, 4))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    def test_transpose_preexisting_incorrect_shape(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 3, 4))],
+            [make_node("Transpose", ["X"], ["Y"], perm=[1, 0, 2])],
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 5, 5))],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_transpose_preexisting_incorrect_type(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 3, 4))],
+            [make_node("Transpose", ["X"], ["Y"], perm=[1, 0, 2])],
+            [make_tensor_value_info("Y", TensorProto.STRING, (3, 2, 4))],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_transpose_incorrect_repeated_perm(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 3, 4))],
+            [make_node("Transpose", ["X"], ["Y"], perm=[1, 0, 1])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def _make_matmul_test_all_dims_known(
+        self, version, shape1: Sequence[int], shape2: Sequence[int]
+    ) -> None:
+        expected_out_shape = np.matmul(
+            np.arange(np.prod(shape1)).reshape(shape1),
+            np.arange(np.prod(shape2)).reshape(shape2),
+        ).shape
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, shape1), ("y", TensorProto.FLOAT, shape2)],
+            [make_node("MatMul", ["x", "y"], ["z"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.FLOAT, expected_out_shape)],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("MatMul"))
+    def test_matmul_all_dims_known(self, version) -> None:
+        self._make_matmul_test_all_dims_known(version, (2,), (2,))
+
+        self._make_matmul_test_all_dims_known(version, (4, 2), (2, 4))
+        self._make_matmul_test_all_dims_known(version, (5, 2), (2, 4))
+        self._make_matmul_test_all_dims_known(version, (5, 2), (2, 1))
+        self._make_matmul_test_all_dims_known(version, (1, 2), (2, 3))
+        self._make_matmul_test_all_dims_known(version, (2,), (2, 3))
+        self._make_matmul_test_all_dims_known(version, (4, 2), (2,))
+        self._make_matmul_test_all_dims_known(version, (1, 4, 2), (3, 2, 3))
+        self._make_matmul_test_all_dims_known(version, (3, 4, 2), (3, 2, 3))
+        self._make_matmul_test_all_dims_known(version, (5, 1, 4, 2), (1, 3, 2, 3))
+        self._make_matmul_test_all_dims_known(version, (4, 2), (3, 2, 3))
+
+    def _make_matmul_test_allow_unknown(
+        self, version, shape1: Any, shape2: Any, expected_out_shape: Any
+    ) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, shape1), ("y", TensorProto.FLOAT, shape2)],
+            [make_node("MatMul", ["x", "y"], ["z"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.FLOAT, expected_out_shape)],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("MatMul"))
+    def test_matmul_allow_unknown(self, version) -> None:
+        self._make_matmul_test_allow_unknown(version, (None,), (None,), ())
+        self._make_matmul_test_allow_unknown(version, (3,), (None,), ())
+        self._make_matmul_test_allow_unknown(version, (2,), (2, "a"), ("a",))
+        self._make_matmul_test_allow_unknown(version, (4, 2), (2, "a"), (4, "a"))
+        self._make_matmul_test_allow_unknown(version, (4, None), (2, "a"), (4, "a"))
+        self._make_matmul_test_allow_unknown(version, (4, None), (None, "a"), (4, "a"))
+        self._make_matmul_test_allow_unknown(
+            version, (1, 4, 2), ("a", 2, 5), ("a", 4, 5)
+        )
+        self._make_matmul_test_allow_unknown(
+            version, (1, 3, 4, 2), ("a", 2, 5), (1, 3, 4, 5)
+        )
+        self._make_matmul_test_allow_unknown(version, (3,), None, None)
+        self._make_matmul_test_allow_unknown(version, None, None, None)
+
+    @pytest.mark.parametrize("version", all_versions_for("Cast"))
+    def test_cast(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))],
+            [make_node("Cast", ["x"], ["y"], to=TensorProto.UINT8)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, (2, 4, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.xfail(reason="Issue #5960")
+    def test_cast_to_complex(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))],
+            [make_node("Cast", ["x"], ["y"], to=TensorProto.COMPLEX128)],
+            [],
+        )
+
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    @pytest.mark.parametrize("version", all_versions_for("CastLike"))
+    def test_cast_like(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3)), ("t", TensorProto.FLOAT16, ("N",))],
+            [make_node("CastLike", ["x", "t"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT16, (2, 4, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("BitCast"))
+    def test_bitcast_same_size(self, version) -> None:
+        # Test bitcast between types of same size (float32 -> int32)
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))],
+            [make_node("BitCast", ["x"], ["y"], to=TensorProto.INT32)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("BitCast"))
+    def test_bitcast_scalar(self, version) -> None:
+        # Test bitcast with scalar input (same size)
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ())],
+            [make_node("BitCast", ["x"], ["y"], to=TensorProto.INT32)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, ())],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("BitCast"))
+    def test_bitcast_1d(self, version) -> None:
+        # Test bitcast with 1D tensor (float32 -> uint32, same size)
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (8,))],
+            [make_node("BitCast", ["x"], ["y"], to=TensorProto.UINT32)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT32, (8,))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("BitCast"))
+    def test_bitcast_double_to_int64(self, version) -> None:
+        # Test bitcast between 64-bit types (double -> int64)
+        graph = self._make_graph(
+            [("x", TensorProto.DOUBLE, (3, 5))],
+            [make_node("BitCast", ["x"], ["y"], to=TensorProto.INT64)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (3, 5))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("BitCast"))
+    def test_bitcast_int8_to_uint8(self, version) -> None:
+        # Test bitcast between 8-bit types (int8 -> uint8)
+        graph = self._make_graph(
+            [("x", TensorProto.INT8, (4, 6))],
+            [make_node("BitCast", ["x"], ["y"], to=TensorProto.UINT8)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, (4, 6))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("BitCast"))
+    def test_bitcast_float16_to_int16(self, version) -> None:
+        # Test bitcast between 16-bit types (float16 -> int16)
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT16, (2, 3))],
+            [make_node("BitCast", ["x"], ["y"], to=TensorProto.INT16)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT16, (2, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Col2Im"))
+    def test_col2im(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (1, 5, 5)),
+                ("output_shape", TensorProto.INT64, (2,)),
+                ("kernel_shape", TensorProto.INT64, (2,)),
+            ],
+            [
+                make_node(
+                    "Col2Im", ["input", "output_shape", "kernel_shape"], ["output"]
+                )
+            ],
+            [],
+            initializer=[
+                make_tensor("output_shape", TensorProto.INT64, (2,), (5, 5)),
+                make_tensor("kernel_shape", TensorProto.INT64, (2,), (1, 5)),
+            ],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("output", TensorProto.FLOAT, (1, 1, 5, 5))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Col2Im"))
+    def test_col2im_strides(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (1, 9, 4)),
+                ("output_shape", TensorProto.INT64, (2,)),
+                ("kernel_shape", TensorProto.INT64, (2,)),
+            ],
+            [
+                make_node(
+                    "Col2Im",
+                    ["input", "output_shape", "kernel_shape"],
+                    ["output"],
+                    strides=[2, 2],
+                )
+            ],
+            [],
+            initializer=[
+                make_tensor("output_shape", TensorProto.INT64, (2,), (5, 5)),
+                make_tensor("kernel_shape", TensorProto.INT64, (2,), (3, 3)),
+            ],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("output", TensorProto.FLOAT, (1, 1, 5, 5))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Col2Im"))
+    def test_col2im_pads(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (1, 5, 15)),
+                ("output_shape", TensorProto.INT64, (2,)),
+                ("kernel_shape", TensorProto.INT64, (2,)),
+            ],
+            [
+                make_node(
+                    "Col2Im",
+                    ["input", "output_shape", "kernel_shape"],
+                    ["output"],
+                    pads=[0, 1, 0, 1],
+                )
+            ],
+            [],
+            initializer=[
+                make_tensor("output_shape", TensorProto.INT64, (2,), (5, 5)),
+                make_tensor("kernel_shape", TensorProto.INT64, (2,), (1, 5)),
+            ],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("output", TensorProto.FLOAT, (1, 1, 5, 5))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Col2Im"))
+    def test_col2im_dilations(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (1, 4, 5)),
+                ("output_shape", TensorProto.INT64, (2,)),
+                ("kernel_shape", TensorProto.INT64, (2,)),
+            ],
+            [
+                make_node(
+                    "Col2Im",
+                    ["input", "output_shape", "kernel_shape"],
+                    ["output"],
+                    dilations=[1, 5],
+                )
+            ],
+            [],
+            initializer=[
+                make_tensor("output_shape", TensorProto.INT64, (2,), (6, 6)),
+                make_tensor("kernel_shape", TensorProto.INT64, (2,), (2, 2)),
+            ],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("output", TensorProto.FLOAT, (1, 1, 6, 6))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Col2Im"))
+    def test_col2im_5d(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (1, 10, 12)),
+                ("output_shape", TensorProto.INT64, (3,)),
+                ("kernel_shape", TensorProto.INT64, (3,)),
+            ],
+            [
+                make_node(
+                    "Col2Im", ["input", "output_shape", "kernel_shape"], ["output"]
+                )
+            ],
+            [],
+            initializer=[
+                make_tensor("output_shape", TensorProto.INT64, (3,), (3, 4, 5)),
+                make_tensor("kernel_shape", TensorProto.INT64, (3,), (1, 1, 5)),
+            ],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("output", TensorProto.FLOAT, (1, 2, 3, 4, 5))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Concat"))
+    def test_concat(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3)), ("y", TensorProto.FLOAT, (7, 4, 3))],
+            [make_node("Concat", ["x", "y"], ["z"], axis=0)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.FLOAT, (9, 4, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    def test_concat_missing_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (2, 4, 3)),
+                "y",
+                ("z", TensorProto.FLOAT, (None, None, None)),
+            ],
+            [make_node("Concat", ["x", "y", "z"], ["out"], axis=0)],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    @pytest.mark.parametrize("version", all_versions_for("Concat"))
+    def test_concat_3d_axis_2(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 2, 2)), ("y", TensorProto.FLOAT, (2, 2, 2))],
+            [make_node("Concat", ["x", "y"], ["z"], axis=2)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.FLOAT, (2, 2, 4))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Concat"))
+    def test_concat_param(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ("a", 2)), ("y", TensorProto.FLOAT, ("a", 3))],
+            [make_node("Concat", ["x", "y"], ["z"], axis=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.FLOAT, ("a", 5))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Concat"))
+    def test_concat_param_single_input(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ("a", 2))],
+            [make_node("Concat", ["x"], ["z"], axis=0)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.FLOAT, ("a", 2))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Reshape"))
+    def test_reshape_dynamic_shape_known_rank(self, version) -> None:
+        self.skipIf(version < 14, "Rank inference is added from Version 14")
+        graph = self._make_graph(
+            [("x", TensorProto.UINT8, (2, 4, 3)), ("shape", TensorProto.INT64, (2,))],
+            [make_node("Reshape", ["x", "shape"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, (None, None))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Reshape"))
+    def test_reshape_dynamic_shape_symbolic(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.UINT8, (2, 4, 3)), ("shape", TensorProto.INT64, ("M",))],
+            [make_node("Reshape", ["x", "shape"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, None)],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Reshape"))
+    def test_reshape_dynamic_unknown_shape(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.UINT8, (2, 4, 3)), ("shape", TensorProto.INT64, None)],
+            [make_node("Reshape", ["x", "shape"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, None)],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Reshape"))
+    def test_reshape_static_shape(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.UINT8, (2, 4, 3)), ("shape", TensorProto.INT64, (2,))],
+            [make_node("Reshape", ["x", "shape"], ["y"])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (2,), (3, 8))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, (3, 8))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Reshape"))
+    def test_reshape_static_shape_inferred(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.UINT8, (2, 4, 3)), ("shape", TensorProto.INT64, (3,))],
+            [make_node("Reshape", ["x", "shape"], ["y"])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (3,), (0, 3, -1))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, (2, 3, 4))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Reshape"))
+    def test_reshape_static_shape_zero(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.UINT8, (1, 1, 1)), ("shape", TensorProto.INT64, (3,))],
+            [make_node("Reshape", ["x", "shape"], ["y"])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (3,), (0, 1, 1))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, (1, 1, 1))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Reshape"))
+    def test_reshape_static_shape_allowzero(self, version) -> None:
+        self.skipIf(version < 14, "allowzero is added from Version 14")
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (1, 0, 0)),
+                ("shape", TensorProto.INT64, (3,)),
+            ],
+            [make_node("Reshape", ["x", "shape"], ["y"], allowzero=1)],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (3,), (0, 1, 1))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, (0, 1, 1))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Reshape"))
+    def test_reshape_static_shape_constant(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.UINT8, (2, 4, 3))],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["shape"],
+                    value=make_tensor("shape", TensorProto.INT64, (2,), (3, 8)),
+                ),
+                make_node("Reshape", ["x", "shape"], ["y"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, (2,)),
+                make_tensor_value_info("y", TensorProto.UINT8, (3, 8)),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Upsample"))
+    def test_upsample(self, version) -> None:
+        if version == 7:
+            graph = self._make_graph(
+                [("x", TensorProto.INT32, (2, 4, 3, 5))],
+                [make_node("Upsample", ["x"], ["y"], scales=[1.0, 1.1, 1.3, 1.9])],
+                [],
+            )
+            self._assert_inferred(
+                graph,
+                [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 3, 9))],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+        else:
+            graph = self._make_graph(
+                [
+                    ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                    ("scales", TensorProto.FLOAT, (4,)),
+                ],
+                [make_node("Upsample", ["x", "scales"], ["y"])],
+                [],
+                initializer=[
+                    make_tensor("scales", TensorProto.FLOAT, (4,), (1.0, 1.1, 1.3, 1.9))
+                ],
+            )
+
+            def call_inference():
+                self._assert_inferred(
+                    graph,
+                    [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 3, 9))],
+                    opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+                )
+
+            if version == 9:
+                call_inference()
+            else:
+                # Upsample is deprecated since Version 10.
+                with pytest.raises(
+                    onnx.checker.ValidationError, match="Upsample is deprecated"
+                ):
+                    call_inference()
+
+    @pytest.mark.parametrize("version", all_versions_for("Upsample"))
+    def test_upsample_raw_data(self, version) -> None:
+        if version == 7:
+            graph = self._make_graph(
+                [("x", TensorProto.INT32, (1, 3, 4, 5))],
+                [make_node("Upsample", ["x"], ["y"], scales=[2.0, 1.1, 2.3, 1.9])],
+                [],
+            )
+            self._assert_inferred(
+                graph,
+                [make_tensor_value_info("y", TensorProto.INT32, (2, 3, 9, 9))],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+        else:
+            graph = self._make_graph(
+                [
+                    ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                    ("scales", TensorProto.FLOAT, (4,)),
+                ],
+                [make_node("Upsample", ["x", "scales"], ["y"])],
+                [],
+                initializer=[
+                    make_tensor(
+                        "scales",
+                        TensorProto.FLOAT,
+                        (4,),
+                        vals=np.array([1.0, 1.1, 1.3, 1.9], dtype="<f4").tobytes(),
+                        raw=True,
+                    )
+                ],
+            )  # Feed raw bytes (force little endian ordering like onnx standard) for test purpose
+
+            def call_inference():
+                self._assert_inferred(
+                    graph,
+                    [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 3, 9))],
+                    opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+                )
+
+            if version == 9:
+                call_inference()
+            else:
+                # Upsample is deprecated since Version 10.
+                with pytest.raises(
+                    onnx.checker.ValidationError, match="Upsample is deprecated"
+                ):
+                    call_inference()
+
+    @pytest.mark.parametrize("version", all_versions_for("Expand"))
+    def test_expand(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.INT32, (3, 1)), ("shape", TensorProto.INT64, (3,))],
+            [make_node("Expand", ["x", "shape"], ["y"])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (3,), (2, 1, 6))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 3, 6))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Expand"))
+    def test_expand_scalar_input(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.INT32, ()), ("shape", TensorProto.INT64, (2,))],
+            [make_node("Expand", ["x", "shape"], ["y"])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (2,), (4, 8))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (4, 8))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Expand"))
+    def test_expand_raw_data(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.INT32, (3, 1)), ("shape", TensorProto.INT64, (2,))],
+            [make_node("Expand", ["x", "shape"], ["y"])],
+            [],
+            initializer=[
+                make_tensor(
+                    "shape",
+                    TensorProto.INT64,
+                    (2,),
+                    vals=np.array([3, 4], dtype="<i8").tobytes(),
+                    raw=True,
+                )
+            ],
+        )  # Feed raw bytes (force little endian ordering like onnx standard) for test purpose
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (3, 4))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Expand"))
+    def test_expand_dynamic_shape(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (1, 2, None)),
+                ("shape", TensorProto.INT64, (3,)),
+            ],
+            [make_node("Expand", ["x", "shape"], ["y"])],
+            [],
+            initializer=[],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (None, 2, None))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Expand"))
+    def test_expand_symbolic_shape(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (1, 2, None)),
+                ("shape", TensorProto.INT64, ("unk__0",)),
+            ],
+            [make_node("Expand", ["x", "shape"], ["y"])],
+            [],
+            initializer=[],
+        )
+        # if giving a symbolic shape, Expand should not infer any shape or rank inference
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, None)],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_size(self, version) -> None:
+        if version == 10:
+            graph = self._make_graph(
+                [
+                    ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                    ("scales", TensorProto.FLOAT, (4,)),
+                ],
+                [make_node("Resize", ["x", "scales"], ["y"])],
+                [],
+                initializer=[
+                    make_tensor("scales", TensorProto.FLOAT, (4,), (1.0, 1.1, 1.3, 1.9))
+                ],
+            )
+            self._assert_inferred(
+                graph,
+                [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 3, 9))],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+        elif version == 11:
+            graph = self._make_graph(
+                [
+                    ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                    ("roi", TensorProto.FLOAT, (8,)),
+                    ("scales", TensorProto.FLOAT, (4,)),
+                    ("sizes", TensorProto.INT64, (4,)),
+                ],
+                [make_node("Resize", ["x", "roi", "scales", "sizes"], ["y"])],
+                [],
+                initializer=[
+                    make_tensor("sizes", TensorProto.INT64, (4,), (3, 5, 6, 7))
+                ],
+            )
+            self._assert_inferred(
+                graph,
+                [make_tensor_value_info("y", TensorProto.INT32, (3, 5, 6, 7))],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+        else:
+            graph = self._make_graph(
+                [
+                    ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                    ("roi", TensorProto.FLOAT, (8,)),
+                    ("sizes", TensorProto.INT64, (4,)),
+                ],
+                [make_node("Resize", ["x", "roi", "", "sizes"], ["y"])],
+                [],
+                initializer=[
+                    make_tensor("sizes", TensorProto.INT64, (4,), (3, 5, 6, 7))
+                ],
+            )
+            self._assert_inferred(
+                graph,
+                [make_tensor_value_info("y", TensorProto.INT32, (3, 5, 6, 7))],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("RMSNormalization"))
+    def test_rms_normalization(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, ("N", "C", "H", "W")),
+                ("scale", TensorProto.FLOAT, ("H", "W")),
+            ],
+            [make_node("RMSNormalization", ["X", "scale"], ["y"], axis=2)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, ("N", "C", "H", "W"))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_size_axes_2_3(self, version) -> None:
+        self.skipIf(version < 18, "axes is from Version 18")
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                ("roi", TensorProto.FLOAT, (4,)),
+                ("sizes", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Resize", ["x", "roi", "", "sizes"], ["y"], axes=(2, 3))],
+            [],
+            initializer=[make_tensor("sizes", TensorProto.INT64, (2,), (6, 7))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 6, 7))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_size_axes_3_2(self, version) -> None:
+        self.skipIf(version < 18, "axes is from Version 18")
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                ("roi", TensorProto.FLOAT, (4,)),
+                ("sizes", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Resize", ["x", "roi", "", "sizes"], ["y"], axes=(3, 2))],
+            [],
+            initializer=[make_tensor("sizes", TensorProto.INT64, (2,), (6, 7))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 7, 6))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_size_not_larger(self, version) -> None:
+        self.skipIf(
+            version < 18,
+            "keep_aspect_ratio_policy is from Version 18",
+        )
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (3, 5)),
+                ("roi", TensorProto.FLOAT, (4,)),
+                ("sizes", TensorProto.INT64, (2,)),
+            ],
+            [
+                make_node(
+                    "Resize",
+                    ["x", "roi", "", "sizes"],
+                    ["y"],
+                    keep_aspect_ratio_policy="not_larger",
+                )
+            ],
+            [],
+            initializer=[make_tensor("sizes", TensorProto.INT64, (2,), (6, 6))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (4, 6))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_size_axes_2_3_not_larger(self, version) -> None:
+        self.skipIf(
+            version < 18,
+            "axes & keep_aspect_ratio_policy are from Version 18",
+        )
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                ("roi", TensorProto.FLOAT, (4,)),
+                ("sizes", TensorProto.INT64, (2,)),
+            ],
+            [
+                make_node(
+                    "Resize",
+                    ["x", "roi", "", "sizes"],
+                    ["y"],
+                    axes=(2, 3),
+                    keep_aspect_ratio_policy="not_larger",
+                )
+            ],
+            [],
+            initializer=[make_tensor("sizes", TensorProto.INT64, (2,), (6, 6))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 4, 6))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_size_not_smaller(self, version) -> None:
+        self.skipIf(
+            version < 18,
+            "keep_aspect_ratio_policy is from Version 18",
+        )
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (3, 5)),
+                ("roi", TensorProto.FLOAT, (4,)),
+                ("sizes", TensorProto.INT64, (2,)),
+            ],
+            [
+                make_node(
+                    "Resize",
+                    ["x", "roi", "", "sizes"],
+                    ["y"],
+                    keep_aspect_ratio_policy="not_smaller",
+                )
+            ],
+            [],
+            initializer=[make_tensor("sizes", TensorProto.INT64, (2,), (6, 6))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (6, 10))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_size_axes_2_3_not_smaller(self, version) -> None:
+        self.skipIf(
+            version < 18,
+            "axes & keep_aspect_ratio_policy are from Version 18",
+        )
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                ("roi", TensorProto.FLOAT, (4,)),
+                ("sizes", TensorProto.INT64, (2,)),
+            ],
+            [
+                make_node(
+                    "Resize",
+                    ["x", "roi", "", "sizes"],
+                    ["y"],
+                    axes=(2, 3),
+                    keep_aspect_ratio_policy="not_smaller",
+                )
+            ],
+            [],
+            initializer=[make_tensor("sizes", TensorProto.INT64, (2,), (6, 6))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 6, 10))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    def _check_keep_aspect_ratio_precision(
+        self,
+        version: int,
+        policy: str,
+        dims: tuple[int, ...],
+        sizes: tuple[int, ...],
+        expected: tuple[int, ...],
+    ) -> None:
+        # Shared body for KeepAspectRatioHelper precision regression tests.
+        # Builds a Resize graph using the sizes-input path with the given
+        # keep_aspect_ratio_policy and asserts the inferred output shape.
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, dims),
+                ("roi", TensorProto.FLOAT, (2 * len(dims),)),
+                ("sizes", TensorProto.INT64, (len(sizes),)),
+            ],
+            [
+                make_node(
+                    "Resize",
+                    ["x", "roi", "", "sizes"],
+                    ["y"],
+                    keep_aspect_ratio_policy=policy,
+                )
+            ],
+            [],
+            initializer=[make_tensor("sizes", TensorProto.INT64, (len(sizes),), sizes)],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, expected)],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_keep_aspect_ratio_precision_not_larger(self, version) -> None:
+        # Regression: KeepAspectRatioHelper computed `sizes_data[i] /
+        # static_cast<float>(dim_value)` and `roundf(scale * dim_value)`.
+        # With float32, 2**24 + 1 = 16_777_217 is unrepresentable, so a 1:1
+        # request collapses the inferred dim to 16_777_216.
+        self.skipIf(version < 18, "keep_aspect_ratio_policy is from Version 18")
+        self._check_keep_aspect_ratio_precision(
+            version,
+            "not_larger",
+            dims=(16777217, 16777217),
+            sizes=(16777217, 16777217),
+            expected=(16777217, 16777217),
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_keep_aspect_ratio_precision_not_smaller(self, version) -> None:
+        # Same float32 mantissa boundary, NOT_SMALLER policy path.
+        self.skipIf(version < 18, "keep_aspect_ratio_policy is from Version 18")
+        self._check_keep_aspect_ratio_precision(
+            version,
+            "not_smaller",
+            dims=(16777217, 16777217),
+            sizes=(16777217, 16777217),
+            expected=(16777217, 16777217),
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_keep_aspect_ratio_precision_non_unit_scale(self, version) -> None:
+        # Non-unit scale path: dim 16_777_217 scaled by 2 should produce
+        # 33_554_434. With float32 the result collapses to 33_554_432.
+        self.skipIf(version < 18, "keep_aspect_ratio_policy is from Version 18")
+        self._check_keep_aspect_ratio_precision(
+            version,
+            "not_larger",
+            dims=(16777217,),
+            sizes=(33554434,),
+            expected=(33554434,),
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_scale(self, version) -> None:
+        self.skipIf(version < 11, "roi input is from Version 11")
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                ("roi", TensorProto.FLOAT, (8,)),
+                ("scales", TensorProto.FLOAT, (4,)),
+            ],
+            [make_node("Resize", ["x", "roi", "scales"], ["y"])],
+            [],
+            initializer=[
+                make_tensor("scales", TensorProto.FLOAT, (4,), (1.0, 1.1, 1.3, 1.9))
+            ],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 3, 9))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_scale_axes_2_3(self, version) -> None:
+        self.skipIf(version < 18, "axes is from Version 18")
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                ("roi", TensorProto.FLOAT, (8,)),
+                ("scales", TensorProto.FLOAT, (2,)),
+            ],
+            [make_node("Resize", ["x", "roi", "scales"], ["y"], axes=(2, 3))],
+            [],
+            initializer=[make_tensor("scales", TensorProto.FLOAT, (2,), (1.3, 1.9))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 3, 9))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_scale_axes_3_2(self, version) -> None:
+        self.skipIf(version < 18, "axes is from Version 18")
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (2, 4, 3, 5)),
+                ("roi", TensorProto.FLOAT, (8,)),
+                ("scales", TensorProto.FLOAT, (2,)),
+            ],
+            [make_node("Resize", ["x", "roi", "scales"], ["y"], axes=(3, 2))],
+            [],
+            initializer=[make_tensor("scales", TensorProto.FLOAT, (2,), (1.9, 1.3))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 4, 3, 9))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_scale_raw_data(self, version) -> None:
+        self.skipIf(version < 11, "roi input is from Version 11")
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (1, 3, 4, 5)),
+                ("roi", TensorProto.FLOAT, (8,)),
+                ("scales", TensorProto.FLOAT, (4,)),
+            ],
+            [make_node("Resize", ["x", "roi", "scales"], ["y"])],
+            [],
+            initializer=[
+                make_tensor(
+                    "scales",
+                    TensorProto.FLOAT,
+                    (4,),
+                    vals=np.array([2.0, 1.1, 2.3, 1.9], dtype="<f4").tobytes(),
+                    raw=True,
+                )
+            ],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 3, 9, 9))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    def _check_resize_scale_precision(
+        self,
+        version: int,
+        scales: tuple[float, ...],
+        expected_last_dim: int,
+    ) -> None:
+        # Shared body for #4919 regression tests. Builds a Resize graph whose
+        # last input dim is 16_777_217 (= 2**24 + 1, the smallest int that
+        # float32 cannot represent) and asserts the inferred output last dim.
+        if version >= 11:
+            inputs = [
+                ("x", TensorProto.INT32, (1, 1, 1, 16777217)),
+                ("roi", TensorProto.FLOAT, (8,)),
+                ("scales", TensorProto.FLOAT, (4,)),
+            ]
+            node = make_node("Resize", ["x", "roi", "scales"], ["y"])
+        else:
+            inputs = [
+                ("x", TensorProto.INT32, (1, 1, 1, 16777217)),
+                ("scales", TensorProto.FLOAT, (4,)),
+            ]
+            node = make_node("Resize", ["x", "scales"], ["y"])
+        graph = self._make_graph(
+            inputs,
+            [node],
+            [],
+            initializer=[make_tensor("scales", TensorProto.FLOAT, (4,), scales)],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "y", TensorProto.INT32, (1, 1, 1, expected_last_dim)
+                )
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_scale_precision_large_dim(self, version) -> None:
+        # Regression for #4919, current-version helper
+        for scale in [1, 2]:
+            self._check_resize_scale_precision(
+                version, (1.0, 1.0, 1.0, float(scale)), 16777217 * scale
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_scale_and_size_but_one_is_empty(self, version) -> None:
+        self.skipIf(version < 11, "roi input is from Version 11")
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (1, 3, 4, 5)),
+                ("roi", TensorProto.FLOAT, (8,)),
+                ("scales", TensorProto.FLOAT, (4,)),
+                ("sizes", TensorProto.INT64, (0,)),
+            ],
+            [make_node("Resize", ["x", "roi", "scales", "sizes"], ["y"])],
+            [],
+            initializer=[
+                make_tensor(
+                    "scales",
+                    TensorProto.FLOAT,
+                    (4,),
+                    vals=np.array([2.0, 1.1, 2.3, 1.9], dtype="<f4").tobytes(),
+                    raw=True,
+                ),
+                make_tensor(
+                    "sizes",
+                    TensorProto.INT64,
+                    (0,),
+                    vals=np.array([], dtype="<i8").tobytes(),
+                    raw=True,
+                ),
+            ],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 3, 9, 9))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Resize"))
+    def test_resize_opset11_scales_is_empty(self, version) -> None:
+        self.skipIf(version != 11, "This test only works for Version 11")
+        # "scales" input in Resize in opset11 is not optional. It must be an empty tensor
+        # if sizes is needed. Shape inference for Resize shall handle this case.
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT32, (1, 3, 4, 5)),
+                ("roi", TensorProto.FLOAT, (8,)),
+                ("scales", TensorProto.FLOAT, (0,)),
+                ("sizes", TensorProto.INT64, (4,)),
+            ],
+            [make_node("Resize", ["x", "roi", "scales", "sizes"], ["y"])],
+            [],
+            initializer=[
+                make_tensor(
+                    "sizes",
+                    TensorProto.INT64,
+                    (4,),
+                    vals=np.array(
+                        [2, 6, 8, 10], dtype="<i8"
+                    ).tobytes(),  # double in all dimensions
+                    raw=True,
+                ),
+            ],
+        )
+
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT32, (2, 6, 8, 10))],
+            opset_imports=[helper.make_opsetid("", version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Shape"))
+    def test_shape(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))],
+            [make_node("Shape", ["x"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (3,))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Shape"))
+    def test_shape_start_1(self, version) -> None:
+        self.skipIf(version < 15, "start and end are from Version 15")
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))],
+            [make_node("Shape", ["x"], ["y"], start=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (2,))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Shape"))
+    def test_shape_end_1(self, version) -> None:
+        self.skipIf(version < 15, "start and end are from Version 15")
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))],
+            [make_node("Shape", ["x"], ["y"], end=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (1,))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Shape"))
+    def test_shape_negative_start(self, version) -> None:
+        self.skipIf(version < 15, "start and end are from Version 15")
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))],
+            [make_node("Shape", ["x"], ["y"], start=-1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (1,))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Shape"))
+    def test_shape_clip1(self, version) -> None:
+        self.skipIf(version < 15, "start and end are from Version 15")
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))],
+            [make_node("Shape", ["x"], ["y"], start=-5)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (3,))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Shape"))
+    def test_shape_clip2(self, version) -> None:
+        self.skipIf(version < 15, "start and end are from Version 15")
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))],
+            [make_node("Shape", ["x"], ["y"], end=10)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (3,))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Size"))
+    def test_size(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4, 3))], [make_node("Size", ["x"], ["y"])], []
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, ())],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Gather"))
+    def test_gather(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 3)), ("i", TensorProto.INT64, (2,))],
+            [make_node("Gather", ["x", "i"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (2, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Gather"))
+    def test_gather_axis1(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 3, 5)), ("i", TensorProto.INT64, (1, 2))],
+            [make_node("Gather", ["x", "i"], ["y"], axis=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (4, 1, 2, 5))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Gather"))
+    def test_gather_into_scalar(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3,)), ("i", TensorProto.INT64, ())],
+            [make_node("Gather", ["x", "i"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, ())],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("GatherElements"))
+    def test_gather_elements(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 2)), ("i", TensorProto.INT64, (2, 2))],
+            [make_node("GatherElements", ["x", "i"], ["y"], axis=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (2, 2))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("GatherElements"))
+    def test_gather_elements_axis0(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("i", TensorProto.INT64, (2, 3))],
+            [make_node("GatherElements", ["x", "i"], ["y"], axis=0)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (2, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Scatter"))
+    def test_scatter(self, version) -> None:
+        if version >= 11:
+            # Scatter is deprecated in domain_version of 11.
+            with pytest.raises(
+                onnx.checker.ValidationError, match="Scatter is deprecated"
+            ):
+                self._test_scatter(version)
+        else:
+            self._test_scatter(version)
+
+    def _test_scatter(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 3)),
+                ("i", TensorProto.INT64, (2, 3)),
+                ("u", TensorProto.FLOAT, (2, 3)),
+            ],
+            [make_node("Scatter", ["x", "i", "u"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (3, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Scatter"))
+    def test_scatter_axis1(self, version) -> None:
+        if version >= 11:
+            # Scatter is deprecated in domain_version of 11.
+            with pytest.raises(
+                onnx.checker.ValidationError, match="Scatter is deprecated"
+            ):
+                self._test_scatter_axis1(version)
+        else:
+            self._test_scatter_axis1(version)
+
+    def _test_scatter_axis1(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 5)),
+                ("i", TensorProto.INT64, (1, 2)),
+                ("u", TensorProto.FLOAT, (1, 2)),
+            ],
+            [make_node("Scatter", ["x", "i", "u"], ["y"], axis=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (1, 5))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("ScatterElements"))
+    def test_scatter_elements(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 3)),
+                ("i", TensorProto.INT64, (2, 3)),
+                ("u", TensorProto.FLOAT, (2, 3)),
+            ],
+            [make_node("ScatterElements", ["x", "i", "u"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (3, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("ScatterElements"))
+    def test_scatter_elements_axis1(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 5)),
+                ("i", TensorProto.INT64, (1, 2)),
+                ("u", TensorProto.FLOAT, (1, 2)),
+            ],
+            [make_node("ScatterElements", ["x", "i", "u"], ["y"], axis=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (1, 5))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("ScatterND"))
+    def test_scatternd(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (4, 5, 6)),
+                ("indices", TensorProto.INT64, (3, 3, 2)),
+                ("updates", TensorProto.FLOAT, (3, 3, 6)),
+            ],
+            [make_node("ScatterND", ["x", "indices", "updates"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (4, 5, 6))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("ScatterND"))
+    def test_scatternd_noshape(self, version) -> None:
+        # The shape of 'x_reshaped' cannot be inferred, since it is the output of a dynamic reshape.
+        # Thus the shape of 'y' is also None.
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (4, 5, 6)),
+                ("indices", TensorProto.INT64, (3, 3, 2)),
+                ("updates", TensorProto.FLOAT, (3, 3, 6)),
+                ("shape", TensorProto.INT64, ("M",)),
+            ],
+            [
+                make_node("Reshape", ["x", "shape"], ["x_reshaped"]),
+                make_node("ScatterND", ["x_reshaped", "indices", "updates"], ["y"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("x_reshaped", TensorProto.FLOAT, None),
+                make_tensor_value_info("y", TensorProto.FLOAT, None),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    def test_tensor_scatter(self) -> None:
+        graph = self._make_graph(
+            [
+                ("past_cache", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("update", TensorProto.FLOAT, (2, 8, 10, 64)),
+                ("write_indices", TensorProto.INT64, (2,)),
+            ],
+            [
+                make_node(
+                    "TensorScatter",
+                    ["past_cache", "update", "write_indices"],
+                    ["present_cache"],
+                    axis=2,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "present_cache", TensorProto.FLOAT, (2, 8, 128, 64)
+                )
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 24)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Squeeze"))
+    def test_squeeze(self, version) -> None:
+        if version == 11:
+            graph = self._make_graph(
+                [("x", TensorProto.FLOAT, (1, 3, 1, 1, 2, 1))],
+                [make_node("Squeeze", "x", "y", axes=[0, 2, 3, 5])],
+                [],
+            )
+            self._assert_inferred(
+                graph,
+                [make_tensor_value_info("y", TensorProto.FLOAT, (3, 2))],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+        else:
+            graph = self._make_graph(
+                [
+                    ("x", TensorProto.FLOAT, (1, 3, 1, 1, 2, 1)),
+                    ("axes", TensorProto.INT64, (4,)),
+                ],
+                [make_node("Squeeze", ["x", "axes"], "y")],
+                [],
+                initializer=[
+                    make_tensor("axes", TensorProto.INT64, (4,), (0, 2, 3, 5))
+                ],
+            )
+            self._assert_inferred(
+                graph,
+                [make_tensor_value_info("y", TensorProto.FLOAT, (3, 2))],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("StringConcat"))
+    def test_stringconcat(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.STRING, (2, 3, 4)),
+                ("y", TensorProto.STRING, (2, 3, 4)),
+            ],
+            [make_node("StringConcat", ["x", "y"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.STRING, (2, 3, 4))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("StringConcat"))
+    def test_stringconcat_broadcasting(self, version) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.STRING, (2, 3, 4)),
+                ("y", TensorProto.STRING, (1, 3, 1)),
+            ],
+            [make_node("StringConcat", ["x", "y"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.STRING, (2, 3, 4))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("RegexFullMatch"))
+    def test_regex_full_match(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.STRING, (2, 4, 3, 9))],
+            [make_node("RegexFullMatch", ["x"], ["y"], pattern=r"^[A-Z][a-z]*$")],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.BOOL, (2, 4, 3, 9))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("RegexFullMatch"))
+    def test_regex_full_match_empty_shape(self, version) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.STRING, ())],
+            [make_node("RegexFullMatch", ["x"], ["y"], pattern=r"^[A-Z][a-z]*$")],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.BOOL, ())],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    def test_squeeze_no_axes_opset11(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 3, 1, 1, 2, 1)),
+            ],
+            [make_node("Squeeze", ["x"], "y")],
+            [],
+        )
+        operatorsetid = OperatorSetIdProto()
+        operatorsetid.domain = ""
+        operatorsetid.version = 11
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3, 2))]
+        )
+
+    def test_squeeze_no_axes_dynamic_input_opset11(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 3, 1, None, 2, 1)),
+            ],
+            [make_node("Squeeze", ["x"], "y")],
+            [],
+        )
+        operatorsetid = OperatorSetIdProto()
+        operatorsetid.domain = ""
+        operatorsetid.version = 11
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, None)],
+            opset_imports=[operatorsetid],
+        )
+
+    def test_unsqueeze_regular(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 2)), ("axes", TensorProto.INT64, (4,))],
+            [make_node("Unsqueeze", ["x", "axes"], "y")],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (4,), (0, 1, 3, 5))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, 1, 3, 1, 2, 1))]
+        )
+
+    def test_unsqueeze_unsorted_axes(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("axes", TensorProto.INT64, (2,))],
+            [make_node("Unsqueeze", ["x", "axes"], "y")],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (2,), (4, 0))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, 3, 4, 5, 1))]
+        )
+
+    def test_unsqueeze_negative_axes(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("axes", TensorProto.INT64, (2,))],
+            [make_node("Unsqueeze", ["x", "axes"], "y")],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (2,), (0, -1))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, 3, 4, 5, 1))]
+        )
+
+    def test_unsqueeze_scalar(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ()), ("axes", TensorProto.INT64, ())],
+            [make_node("Unsqueeze", ["x", "axes"], "y")],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (), (-1,))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1,))]
+        )
+
+    def test_slice_without_input_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 2, "a")),
+                ("starts", TensorProto.INT64, (1,)),
+                ("ends", TensorProto.INT64, (1,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (None, None, None))]
+        )
+
+    def test_slice_with_input_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 2)),
+                ("starts", TensorProto.INT64, (2,)),
+                ("ends", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends"], ["y"])],
+            [],
+            initializer=[
+                make_tensor(
+                    "starts",
+                    TensorProto.INT64,
+                    (2,),
+                    vals=np.array([1, 0], dtype="<i8").tobytes(),
+                    raw=True,
+                ),  # Feed raw bytes (force little endian ordering like onnx standard) for test purpose
+                make_tensor("ends", TensorProto.INT64, (2,), (2, 2)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, 2))]
+        )
+
+    def test_slice_with_input_shape_containing_dim_params(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, "a", 1)),
+                ("starts", TensorProto.INT64, (3,)),
+                ("ends", TensorProto.INT64, (3,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends"], ["y"])],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (3,), (0, 0, 0)),
+                make_tensor("ends", TensorProto.INT64, (3,), (1, 1, 1)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, None, 1))]
+        )
+
+    def test_slice_with_input_shape_steps(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (5, 6, 7)),
+                ("starts", TensorProto.INT64, (3,)),
+                ("ends", TensorProto.INT64, (3,)),
+                ("axes", TensorProto.INT64, (None)),
+                ("steps", TensorProto.INT64, (3,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes", "steps"], ["y"])],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (3,), (1, 0, 0)),
+                make_tensor("ends", TensorProto.INT64, (3,), (2, 6, 6)),
+                make_tensor("steps", TensorProto.INT64, (3,), (1, 4, 3)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, 2, 2))]
+        )
+
+    def test_slice_with_input_shape_axes(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 6, 2)),
+                ("starts", TensorProto.INT64, (2,)),
+                ("ends", TensorProto.INT64, (2,)),
+                ("axes", TensorProto.INT64, (2,)),
+                ("steps", TensorProto.INT64, (None)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes", "steps"], ["y"])],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (2,), (1, 0)),
+                make_tensor("ends", TensorProto.INT64, (2,), (2, 2)),
+                make_tensor("axes", TensorProto.INT64, (2,), (0, 2)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, 6, 2))]
+        )
+
+    def test_slice_unsorted_axes(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 2)),
+                ("starts", TensorProto.INT64, (2,)),
+                ("ends", TensorProto.INT64, (2,)),
+                ("axes", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes"], "y")],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (2,), (1, 0)),
+                make_tensor("ends", TensorProto.INT64, (2,), (2, 2)),
+                make_tensor("axes", TensorProto.INT64, (2,), (1, 0)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (2, 1))]
+        )  # can handle unsorted axes
+
+    def test_slice_giant_number(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 2)),
+                ("starts", TensorProto.INT64, (2,)),
+                ("ends", TensorProto.INT64, (2,)),
+                ("axes", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes"], "y")],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (2,), (1, 0)),
+                make_tensor("ends", TensorProto.INT64, (2,), (200, 22000)),
+                make_tensor("axes", TensorProto.INT64, (2,), (0, 1)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (2, 2))]
+        )
+
+    def test_slice_giant_step(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 2)),
+                ("starts", TensorProto.INT64, (2,)),
+                ("ends", TensorProto.INT64, (2,)),
+                ("axes", TensorProto.INT64, (2,)),
+                ("steps", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes", "steps"], "y")],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (2,), (1, 0)),
+                make_tensor("ends", TensorProto.INT64, (2,), (200, 200)),
+                make_tensor("axes", TensorProto.INT64, (2,), (0, 1)),
+                make_tensor("steps", TensorProto.INT64, (2,), (1, 200)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (2, 1))]
+        )
+
+    def test_slice_negative_end(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 2)),
+                ("starts", TensorProto.INT64, (2,)),
+                ("ends", TensorProto.INT64, (2,)),
+                ("axes", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes"], "y")],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (2,), (1, 0)),
+                make_tensor(
+                    "ends", TensorProto.INT64, (2,), (200, -1)
+                ),  # negative end means begin from end of a dimension (here end = 2 - 1 = 1)
+                make_tensor("axes", TensorProto.INT64, (2,), (0, 1)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (2, 1))]
+        )
+
+    def test_slice_negative_start(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 2)),
+                ("starts", TensorProto.INT64, (2,)),
+                ("ends", TensorProto.INT64, (2,)),
+                ("axes", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes"], "y")],
+            [],
+            initializer=[
+                make_tensor(
+                    "starts", TensorProto.INT64, (2,), (1, -2)
+                ),  # negative start means begin from end of a dimension (here end = 2 - 2 = 0)
+                make_tensor("ends", TensorProto.INT64, (2,), (200, 3)),
+                make_tensor("axes", TensorProto.INT64, (2,), (0, 1)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (2, 2))]
+        )
+
+    def test_slice_negative_step(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 4)),
+                ("starts", TensorProto.INT64, (2,)),
+                ("ends", TensorProto.INT64, (2,)),
+                ("axes", TensorProto.INT64, (2,)),
+                ("steps", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes", "steps"], "y")],
+            [],
+            initializer=[
+                make_tensor(
+                    "starts", TensorProto.INT64, (2,), (1, 4)
+                ),  # 4 will be clamped to 3 since we are negative stepping
+                make_tensor("ends", TensorProto.INT64, (2,), (200, 0)),
+                make_tensor("axes", TensorProto.INT64, (2,), (0, 1)),
+                make_tensor("steps", TensorProto.INT64, (2,), (1, -1)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (2, 3))]
+        )
+
+    def test_slice_variable_copy(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ("a", 2)),
+                ("starts", TensorProto.INT64, (1,)),
+                ("ends", TensorProto.INT64, (1,)),
+                ("axes", TensorProto.INT64, (1,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes"], "y")],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (1,), (1,)),
+                make_tensor("ends", TensorProto.INT64, (1,), (200,)),
+                make_tensor("axes", TensorProto.INT64, (1,), (1,)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, ("a", 1))]
+        )
+
+    def test_slice_variable_input_types(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.DOUBLE, (3, 2)),
+                ("starts", TensorProto.INT32, (2,)),
+                ("ends", TensorProto.INT32, (2,)),
+                ("axes", TensorProto.INT32, (2,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes"], "y")],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT32, (2,), (1, 0)),
+                make_tensor("ends", TensorProto.INT32, (2,), (200, 22000)),
+                make_tensor("axes", TensorProto.INT32, (2,), (0, 1)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.DOUBLE, (2, 2))]
+        )
+
+    def test_slice_empty_dim_positive_step(self) -> None:
+        """Slice on empty dimension with positive step should produce dim_value=0."""
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (0, 6)),
+                ("starts", TensorProto.INT64, (1,)),
+                ("ends", TensorProto.INT64, (1,)),
+                ("axes", TensorProto.INT64, (1,)),
+                ("steps", TensorProto.INT64, (1,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes", "steps"], "y")],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (1,), (0,)),
+                make_tensor("ends", TensorProto.INT64, (1,), (0,)),
+                make_tensor("axes", TensorProto.INT64, (1,), (0,)),
+                make_tensor("steps", TensorProto.INT64, (1,), (1,)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (0, 6))]
+        )
+
+    def test_slice_empty_dim_negative_step(self) -> None:
+        """Regression test for issue #7735: std::clamp UB on empty dim with step=-1."""
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (0, 6)),
+                ("starts", TensorProto.INT64, (1,)),
+                ("ends", TensorProto.INT64, (1,)),
+                ("axes", TensorProto.INT64, (1,)),
+                ("steps", TensorProto.INT64, (1,)),
+            ],
+            [make_node("Slice", ["x", "starts", "ends", "axes", "steps"], "y")],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (1,), (1,)),
+                make_tensor("ends", TensorProto.INT64, (1,), (0,)),
+                make_tensor("axes", TensorProto.INT64, (1,), (0,)),
+                make_tensor("steps", TensorProto.INT64, (1,), (-1,)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (0, 6))]
+        )
+
+    def test_slice_scalar_shape_output(self) -> None:
+        """Shape(scalar) produces 0-length output; Slice on it should not crash."""
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ()),
+                ("starts", TensorProto.INT64, (1,)),
+                ("ends", TensorProto.INT64, (1,)),
+                ("axes", TensorProto.INT64, (1,)),
+                ("steps", TensorProto.INT64, (1,)),
+            ],
+            [
+                make_node("Shape", ["x"], ["shape"]),
+                make_node("Slice", ["shape", "starts", "ends", "axes", "steps"], ["y"]),
+            ],
+            [],
+            initializer=[
+                make_tensor("starts", TensorProto.INT64, (1,), (0,)),
+                make_tensor("ends", TensorProto.INT64, (1,), (0,)),
+                make_tensor("axes", TensorProto.INT64, (1,), (0,)),
+                make_tensor("steps", TensorProto.INT64, (1,), (1,)),
+            ],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, (0,)),
+                make_tensor_value_info("y", TensorProto.INT64, (0,)),
+            ],
+        )
+
+    def test_conv(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 4, 5, 6, 7)),
+                ("y", TensorProto.FLOAT, (5, 4, 2, 4, 3)),
+            ],
+            [
+                make_node(
+                    "Conv",
+                    ["x", "y"],
+                    "z",
+                    pads=[0, 1, 1, 0, 0, 1],
+                    dilations=[1, 2, 2],
+                    strides=[1, 1, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 5, 4, 1, 3))]
+        )
+
+    def test_conv_1d_simple(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 5)),
+                ("y", TensorProto.FLOAT, (50, 4, 2)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", dilations=[1])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 50, 4))]
+        )
+
+    def test_conv_dilations(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 8, 8, 8)),
+                ("y", TensorProto.FLOAT, (50, 4, 3, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", dilations=[1, 2, 3])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 50, 6, 4, 2))]
+        )
+
+    def test_conv_strides(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 8, 8, 8)),
+                ("y", TensorProto.FLOAT, (50, 4, 3, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", strides=[1, 2, 3])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 50, 6, 3, 2))]
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("Conv"))
+    def test_conv_zero_strides(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 5, 5)),
+                ("y", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", strides=[0, 1])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("Conv"))
+    def test_conv_negative_strides(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 5, 5)),
+                ("y", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", strides=[-1, 1])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    def test_conv_pads(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 7, 6, 4)),
+                ("y", TensorProto.FLOAT, (50, 4, 3, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", pads=[1, 1, 2, 0, 1, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 50, 6, 6, 6))]
+        )
+
+    def test_conv_auto_pad(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 7, 6, 4)),
+                ("y", TensorProto.FLOAT, (50, 4, 4, 3, 2)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", auto_pad="SAME_UPPER")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 50, 7, 6, 4))]
+        )
+
+    def test_conv_auto_pads(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 7, 6, 4)),
+                ("y", TensorProto.FLOAT, (50, 4, 4, 3, 2)),
+            ],
+            [
+                make_node(
+                    "Conv", ["x", "y"], "z", auto_pad="SAME_UPPER", strides=[2, 2, 1]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 50, 4, 3, 4))]
+        )
+
+    def test_conv_auto_pad_dilation(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 65, 64, 63)),
+                ("y", TensorProto.FLOAT, (50, 4, 4, 3, 2)),
+            ],
+            [
+                make_node(
+                    "Conv", ["x", "y"], "z", auto_pad="SAME_UPPER", dilations=[2, 3, 4]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.FLOAT, (30, 50, 65, 64, 63))],
+        )
+
+    def test_conv_group(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 8, 8, 8)),
+                ("y", TensorProto.FLOAT, (4, 1, 8, 8, 8)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", group=4)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 4, 1, 1, 1))]
+        )
+
+    def test_conv_only_one_pos(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 5)),
+                ("y", TensorProto.FLOAT, (50, 4, 5)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", strides=[2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 50, 1))]
+        )
+
+    def test_conv_partial_missing_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, None, 6, 4)),
+                ("y", TensorProto.FLOAT, (50, 4, 3, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", pads=[1, 1, 2, 0, 1, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.FLOAT, (30, 50, None, 6, 6))],
+        )
+
+    def test_conv_partial_missing_weight_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 7, 6, 4)),
+                ("y", TensorProto.FLOAT, (50, 4, None, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", pads=[1, 1, 2, 0, 1, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, None)]
+        )
+
+    @pytest.mark.parametrize(
+        "version",
+        [
+            # opset 1-10 -> Conv-1 -> convPoolShapeInference_opset1_to_11
+            10,
+            # opset 11-21 -> Conv-11 -> convPoolShapeInference_opset19
+            19,
+            # opset 22+ -> Conv-22 -> convPoolShapeInference
+            defs.get_schema("Conv").since_version,
+        ],
+    )
+    def test_conv_weight_more_spatial_dims_than_input_raises(
+        self, version: int
+    ) -> None:
+        # Weight has more spatial dims than input and no explicit kernel_shape
+        # attribute, so kernel_shape is derived from the weight. This must fail
+        # rather than reading past the end of the dilations vector.
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 4, 8, 8)),
+                ("w", TensorProto.FLOAT, (5, 4, 3, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "w"], "z")],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError, match="weight tensor"):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize(
+        "version",
+        [
+            # opset 1-10 -> Conv-1 -> convPoolShapeInference_opset1_to_11
+            10,
+            # opset 11-21 -> Conv-11 -> convPoolShapeInference_opset19
+            19,
+            # opset 22+ -> Conv-22 -> convPoolShapeInference
+            defs.get_schema("Conv").since_version,
+        ],
+    )
+    def test_conv_weight_fewer_spatial_dims_than_input_raises(
+        self, version: int
+    ) -> None:
+        # Weight has fewer spatial dims than input and no explicit kernel_shape
+        # attribute, so kernel_shape is derived from the weight. This must fail
+        # rather than silently inferring an inconsistent shape.
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 4, 8, 8, 8)),
+                ("w", TensorProto.FLOAT, (5, 4, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "w"], "z")],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError, match="weight tensor"):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("Conv"))
+    def test_conv_zero_dilations(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 5, 5)),
+                ("y", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", dilations=[0, 1])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("Conv"))
+    def test_conv_negative_dilations(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 5, 5)),
+                ("y", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", dilations=[-1, 1])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("Conv"))
+    def test_conv_negative_pads(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 5, 5)),
+                ("y", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", pads=[-1, 0, 0, 0])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("Conv"))
+    def test_conv_input_too_few_dims(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1)),
+                ("y", TensorProto.FLOAT, (1, 1, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z")],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("Conv"))
+    def test_conv_zero_kernel_shape(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 5, 5)),
+                ("y", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", kernel_shape=[0, 3])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("Conv"))
+    def test_conv_negative_kernel_shape(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 5, 5)),
+                ("y", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("Conv", ["x", "y"], "z", kernel_shape=[-1, 3])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("MaxPool"))
+    def test_maxpool_zero_kernel_shape(self, version: int) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (1, 1, 5, 5))],
+            [make_node("MaxPool", ["X"], ["Y"], kernel_shape=[0, 3])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("MaxPool"))
+    def test_maxpool_negative_dilations(self, version: int) -> None:
+        if version < 10:
+            pytest.skip("dilations not supported before MaxPool-10")
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (1, 1, 5, 5))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[3, 3],
+                    dilations=[-1, 1],
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("MaxPool"))
+    def test_maxpool_negative_pads(self, version: int) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (1, 1, 5, 5))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[3, 3],
+                    pads=[-1, 0, 0, 0],
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("ConvTranspose"))
+    def test_conv_transpose_weight_spatial_rank_mismatch(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 4, 4)),
+                ("w", TensorProto.FLOAT, (1, 1, 3, 3, 3)),
+            ],
+            [make_node("ConvTranspose", ["x", "w"], "z")],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("ConvTranspose"))
+    def test_conv_transpose_negative_dilations(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 4, 4)),
+                ("w", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("ConvTranspose", ["x", "w"], "z", dilations=[-1, 1])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("ConvTranspose"))
+    def test_conv_transpose_zero_strides(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 4, 4)),
+                ("w", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("ConvTranspose", ["x", "w"], "z", strides=[0, 1])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("ConvTranspose"))
+    def test_conv_transpose_negative_pads(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 4, 4)),
+                ("w", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("ConvTranspose", ["x", "w"], "z", pads=[-1, 0, 0, 0])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("ConvTranspose"))
+    def test_conv_transpose_negative_output_padding(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 4, 4)),
+                ("w", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose",
+                    ["x", "w"],
+                    "z",
+                    strides=[2, 2],
+                    output_padding=[-1, 0],
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("ConvTranspose"))
+    def test_conv_transpose_negative_output_shape(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 4, 4)),
+                ("w", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose",
+                    ["x", "w"],
+                    "z",
+                    output_shape=[-1, 6],
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("ConvTranspose"))
+    def test_conv_transpose_zero_kernel_shape(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 4, 4)),
+                ("w", TensorProto.FLOAT, (1, 1, 3, 3)),
+            ],
+            [make_node("ConvTranspose", ["x", "w"], "z", kernel_shape=[0, 3])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    def test_attention_4d(self) -> None:
+        graph = self._make_graph(
+            [
+                (
+                    "Q",
+                    TensorProto.FLOAT,
+                    ("B", "q_num_heads", "q_seq_length", "head_size"),
+                ),
+                (
+                    "K",
+                    TensorProto.FLOAT,
+                    ("B", "kv_num_heads", "kv_seq_len", "head_size"),
+                ),
+                (
+                    "V",
+                    TensorProto.FLOAT,
+                    ("B", "kv_num_heads", "kv_seq_len", "v_head_size"),
+                ),
+            ],
+            [
+                make_node(
+                    "Attention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "Y",
+                    TensorProto.FLOAT,
+                    ("B", "q_num_heads", "q_seq_length", "v_head_size"),
+                )
+            ],
+        )
+
+    def test_linear_attention_basic_mha(self) -> None:
+        # update_rule="linear" with no optional inputs: baseline shape/dtype plumbing.
+        # H_q == H_kv == 4, d_k == d_v == 16. Output is 3D packed; state is 4D.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,64] Q, float[2,4,64] K, float[2,4,64] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="linear"
+                > (Q, K, V)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 4, 64)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, (2, 4, 16, 16)
+                ),
+            ],
+        )
+
+    def test_linear_attention_gated_delta(self) -> None:
+        # Default update_rule with both decay (per-keydim) and beta required.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,64] Q, float[2,4,64] K, float[2,4,64] V,
+               float[2,4,64] decay, float[2,4,4] beta)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="gated_delta"
+                > (Q, K, V, "", decay, beta)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 4, 64)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, (2, 4, 16, 16)
+                ),
+            ],
+        )
+
+    def test_linear_attention_gqa(self) -> None:
+        # H_q=8, H_kv=2 (4 query heads share each KV head). Output last dim must
+        # be H_q * d_v while present_state's H dim must be H_kv. This is the
+        # highest-risk regression for confusing q vs kv head counts.
+        # Q: 8 * 16 = 128. K, V: 2 * 16 = 32.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,128] Q, float[2,4,32] K, float[2,4,32] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=8, kv_num_heads=2, update_rule="linear"
+                > (Q, K, V)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 4, 128)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, (2, 2, 16, 16)
+                ),
+            ],
+        )
+
+    def test_linear_attention_mqa(self) -> None:
+        # Multi-query attention: kv_num_heads == 1.
+        # Q: 4 * 16 = 64. K, V: 1 * 16 = 16.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,64] Q, float[2,4,16] K, float[2,4,16] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=1, update_rule="linear"
+                > (Q, K, V)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 4, 64)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, (2, 1, 16, 16)
+                ),
+            ],
+        )
+
+    def test_linear_attention_with_past_state(self) -> None:
+        # past_state has dtype S (FLOAT16) different from T (FLOAT). present_state
+        # must inherit dtype from past_state, not from query.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,1,64] Q, float[2,1,64] K, float[2,1,64] V,
+               float16[2,4,16,16] past_state,
+               float[2,1,64] decay, float[2,1,4] beta)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="gated_delta"
+                > (Q, K, V, past_state, decay, beta)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 1, 64)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT16, (2, 4, 16, 16)
+                ),
+            ],
+        )
+
+    def test_linear_attention_per_head_decay(self) -> None:
+        # update_rule="gated" with per-head scalar decay shape (B, T, H_kv).
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,3,16] Q, float[2,3,16] K, float[2,3,16] V,
+               float[2,3,2] decay)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=2, kv_num_heads=2, update_rule="gated"
+                > (Q, K, V, "", decay)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 16)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, (2, 2, 8, 8)
+                ),
+            ],
+        )
+
+    def test_linear_attention_per_keydim_decay(self) -> None:
+        # update_rule="gated" with per-key-dimension decay shape (B, T, H_kv * d_k).
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,3,16] Q, float[2,3,16] K, float[2,3,16] V,
+               float[2,3,16] decay)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=2, kv_num_heads=2, update_rule="gated"
+                > (Q, K, V, "", decay)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 16)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, (2, 2, 8, 8)
+                ),
+            ],
+        )
+
+    def test_linear_attention_dynamic_T(self) -> None:
+        # Symbolic batch and sequence-length dims must propagate to output and state.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[B,T,64] Q, float[B,T,64] K, float[B,T,64] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="linear"
+                > (Q, K, V)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, ("B", "T", 64)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, ("B", 4, 16, 16)
+                ),
+            ],
+        )
+
+    def test_linear_attention_unknown_value_last_dim(self) -> None:
+        # value's last dim is symbolic: output last dim and state's d_v are unknown,
+        # but rank stays 3/4 and known dims (B, T, H_kv, d_k) are still computed.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,64] Q, float[2,4,64] K, float[2,4,VLast] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="linear"
+                > (Q, K, V)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 4, None)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, (2, 4, 16, None)
+                ),
+            ],
+        )
+
+    def test_linear_attention_unknown_qkv_with_past_state(self) -> None:
+        # Q/K/V have no shapes; only past_state has a shape. Dim unification
+        # propagates B, d_k, d_v from past_state into both output and
+        # present_state (only T remains unknown for output). Uses _make_graph
+        # because shapeless graph inputs are rejected by the model checker;
+        # _make_graph wraps them behind a Reshape so the shape-erasure happens
+        # inside the graph.
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, None),
+                ("K", TensorProto.FLOAT, None),
+                ("V", TensorProto.FLOAT, None),
+                ("past_state", TensorProto.FLOAT, (2, 4, 16, 16)),
+            ],
+            [
+                make_node(
+                    "LinearAttention",
+                    ["Q", "K", "V", "past_state"],
+                    ["output", "present_state"],
+                    q_num_heads=4,
+                    kv_num_heads=4,
+                    update_rule="linear",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, None, 64)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, (2, 4, 16, 16)
+                ),
+            ],
+        )
+
+    def test_linear_attention_query_rank_not_3(self) -> None:
+        # Query given as rank-4 (internal layout leaked to op boundary).
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,4,16] Q, float[2,4,64] K, float[2,4,64] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="linear"
+                > (Q, K, V)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_past_state_rank_not_4(self) -> None:
+        # past_state must be rank 4.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,1,64] Q, float[2,1,64] K, float[2,1,64] V,
+               float[2,4,16] past_state)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="linear"
+                > (Q, K, V, past_state)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_decay_rank_not_3(self) -> None:
+        # decay must be rank 3 (3D packed).
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,3,16] Q, float[2,3,16] K, float[2,3,16] V,
+               float[2,3] decay)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=2, kv_num_heads=2, update_rule="gated"
+                > (Q, K, V, "", decay)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_gqa_indivisible(self) -> None:
+        # q_num_heads must be a positive multiple of kv_num_heads.
+        # Q: 6 * 16 = 96. K, V: 4 * 16 = 64.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,96] Q, float[2,4,64] K, float[2,4,64] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=6, kv_num_heads=4, update_rule="linear"
+                > (Q, K, V)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_gated_delta_missing_decay(self) -> None:
+        # gated_delta requires decay; only beta provided.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,64] Q, float[2,4,64] K, float[2,4,64] V,
+               float[2,4,4] beta)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="gated_delta"
+                > (Q, K, V, "", "", beta)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_gated_delta_missing_beta(self) -> None:
+        # gated_delta requires beta; only decay provided.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,64] Q, float[2,4,64] K, float[2,4,64] V,
+               float[2,4,64] decay)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="gated_delta"
+                > (Q, K, V, "", decay)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_linear_with_decay(self) -> None:
+        # update_rule="linear" forbids decay.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,64] Q, float[2,4,64] K, float[2,4,64] V,
+               float[2,4,64] decay)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="linear"
+                > (Q, K, V, "", decay)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_linear_with_beta(self) -> None:
+        # update_rule="linear" forbids beta.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,64] Q, float[2,4,64] K, float[2,4,64] V,
+               float[2,4,4] beta)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="linear"
+                > (Q, K, V, "", "", beta)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_unknown_update_rule(self) -> None:
+        # Only "linear", "gated", "delta", and "gated_delta" are accepted.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,64] Q, float[2,4,64] K, float[2,4,64] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="forza inter"
+                > (Q, K, V)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_q_num_heads_zero(self) -> None:
+        # Non-positive head counts must be rejected explicitly, not silently
+        # skipped by the GQA divisibility check (0 % anything == 0).
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,3,16] Q, float[2,3,16] K, float[2,3,16] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=0, kv_num_heads=2, update_rule="linear"
+                > (Q, K, V)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_qpack_indivisible(self) -> None:
+        # Packed query last dim must be divisible by q_num_heads so the
+        # function body can reshape (B, T, H_q * d_k) to (B, T, H_q, d_k).
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,3,15] Q, float[2,3,16] K, float[2,3,16] V)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=2, kv_num_heads=2, update_rule="linear"
+                > (Q, K, V)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_decay_last_dim_wrong(self) -> None:
+        # With H_kv=4 and d_k=16, decay last dim must be 4 (per-head) or 64
+        # (per-key-dim). 7 is neither and must be rejected.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,3,64] Q, float[2,3,64] K, float[2,3,64] V,
+               float[2,3,7] decay)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="gated"
+                > (Q, K, V, "", decay)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_linear_attention_beta_last_dim_wrong(self) -> None:
+        # With H_kv=4, beta last dim must be 1 (broadcast) or 4 (per-head).
+        # 3 is neither and must be rejected.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,3,64] Q, float[2,3,64] K, float[2,3,64] V,
+               float[2,3,4] decay, float[2,3,3] beta)
+                => (output, present_state)
+            {
+                output, present_state = LinearAttention <
+                    q_num_heads=4, kv_num_heads=4, update_rule="gated_delta"
+                > (Q, K, V, "", decay, beta)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_causal_conv_with_state_static(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,8] input, float[4,1,4] weight)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState (input, weight)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 4, 8)),
+                make_tensor_value_info("present_state", TensorProto.FLOAT, (2, 4, 3)),
+            ],
+        )
+
+    def test_causal_conv_with_state_dynamic_length(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[B,C,L] input, float[C,1,4] weight)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState (input, weight)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, ("B", "C", "L")),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, ("B", "C", 3)
+                ),
+            ],
+        )
+
+    def test_causal_conv_with_state_dynamic_kernel(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,8] input, float[4,1,k] weight)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState (input, weight)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 4, 8)),
+                make_tensor_value_info(
+                    "present_state", TensorProto.FLOAT, (2, 4, None)
+                ),
+            ],
+        )
+
+    def test_causal_conv_with_state_input_rank2_fails(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4] input, float[4,1,4] weight)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState (input, weight)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_causal_conv_with_state_kernel_zero_fails(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,8] input, float[4,1,0] weight)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState (input, weight)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_causal_conv_with_state_weight_rank2_fails(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,8] input, float[4,4] weight)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState (input, weight)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_causal_conv_with_state_kernel_size_one(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,8] input, float[4,1,1] weight)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState (input, weight)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 4, 8)),
+                make_tensor_value_info("present_state", TensorProto.FLOAT, (2, 4, 0)),
+            ],
+        )
+
+    def test_causal_conv_with_state_fp16_type_propagation(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float16[2,4,8] input, float16[4,1,4] weight)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState (input, weight)
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT16, (2, 4, 8)),
+                make_tensor_value_info("present_state", TensorProto.FLOAT16, (2, 4, 3)),
+            ],
+        )
+
+    def test_causal_conv_with_state_all_optional_inputs(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,8] input, float[4,1,4] weight,
+               float[4] bias, float[2,4,3] past_state)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState (
+                    input, weight, bias, past_state
+                )
+            }
+            """
+        )
+        self._assert_inferred(
+            model,
+            [
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 4, 8)),
+                make_tensor_value_info("present_state", TensorProto.FLOAT, (2, 4, 3)),
+            ],
+        )
+
+    def test_causal_conv_with_state_unknown_activation_fails(self) -> None:
+        # Only "none", "silu", and "swish" are accepted; anything else must be
+        # rejected by shape inference rather than silently inlined as Identity.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 10, opset_import: ["" : 27]>
+            g (float[2,4,8] input, float[4,1,4] weight)
+                => (output, present_state)
+            {
+                output, present_state = CausalConvWithState <activation = "forza inter"> (input, weight)
+            }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(model)
+
+    def test_flex_attention_basic(self) -> None:
+        """Test FlexAttention basic shape inference with symbolic dimensions."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, ("B", "Hq", "L", "Dqk")),
+                ("K", TensorProto.FLOAT, ("B", "Hkv", "S", "Dqk")),
+                ("V", TensorProto.FLOAT, ("B", "Hkv", "S", "Dv")),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, ("B", "Hq", "L", "Dv"))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_concrete_dims(self) -> None:
+        """Test FlexAttention shape inference with concrete dimensions."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT, (2, 8, 256, 64)),
+                ("V", TensorProto.FLOAT, (2, 8, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 8, 128, 64))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_different_v_head_size(self) -> None:
+        """Test FlexAttention with different head sizes for Q/K vs V."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT, (2, 8, 256, 64)),
+                ("V", TensorProto.FLOAT, (2, 8, 256, 128)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 8, 128, 128))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_gqa_enabled(self) -> None:
+        """Test FlexAttention with Grouped Query Attention."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT, (2, 2, 256, 64)),
+                ("V", TensorProto.FLOAT, (2, 2, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 8, 128, 64))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_float16(self) -> None:
+        """Test FlexAttention shape inference with FLOAT16 type."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT16, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT16, (2, 8, 256, 64)),
+                ("V", TensorProto.FLOAT16, (2, 8, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT16, (2, 8, 128, 64))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_bfloat16(self) -> None:
+        """Test FlexAttention shape inference with BFLOAT16 type."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.BFLOAT16, (2, 8, 128, 64)),
+                ("K", TensorProto.BFLOAT16, (2, 8, 256, 64)),
+                ("V", TensorProto.BFLOAT16, (2, 8, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.BFLOAT16, (2, 8, 128, 64))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_double(self) -> None:
+        """Test FlexAttention shape inference with DOUBLE type."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.DOUBLE, (2, 8, 128, 64)),
+                ("K", TensorProto.DOUBLE, (2, 8, 256, 64)),
+                ("V", TensorProto.DOUBLE, (2, 8, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.DOUBLE, (2, 8, 128, 64))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_with_scale(self) -> None:
+        """Test FlexAttention with explicit scale attribute."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT, (2, 8, 256, 64)),
+                ("V", TensorProto.FLOAT, (2, 8, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    scale=0.125,
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 8, 128, 64))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_with_score_mod(self) -> None:
+        """Test FlexAttention with score_mod subgraph."""
+        # The whole graph (including the score_mod subgraph) is expressed in one parse_graph call.
+        graph = parse_graph("""
+            agraph (float[2,8,128,64] Q, float[2,8,256,64] K, float[2,8,256,64] V) => (Y)
+            {
+                Y = ai.onnx.preview.FlexAttention (Q, K, V) <
+                    score_mod = score_mod (float[B,Hq,L,S] scores) => (float[B,Hq,L,S] scores_out) {
+                        scores_out = Identity(scores)
+                    }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 8, 128, 64))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_with_prob_mod(self) -> None:
+        """Test FlexAttention with prob_mod subgraph."""
+        # The whole graph (including the prob_mod subgraph) is expressed in one parse_graph call.
+        graph = parse_graph("""
+            agraph (float[2,8,128,64] Q, float[2,8,256,64] K, float[2,8,256,64] V) => (Y)
+            {
+                Y = ai.onnx.preview.FlexAttention (Q, K, V) <
+                    prob_mod = prob_mod (float[B,Hq,L,S] probs) => (float[B,Hq,L,S] probs_out) {
+                        probs_out = Identity(probs)
+                    }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 8, 128, 64))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_with_all_modifiers(self) -> None:
+        """Test FlexAttention with all modifier subgraphs."""
+        # The whole graph (including the score_mod and prob_mod subgraphs) is expressed in one parse_graph call.
+        graph = parse_graph("""
+            agraph (float[2,8,128,64] Q, float[2,8,256,64] K, float[2,8,256,64] V) => (Y)
+            {
+                Y = ai.onnx.preview.FlexAttention (Q, K, V) <
+                    score_mod = score_mod (float[B,Hq,L,S] scores) => (float[B,Hq,L,S] scores_out) {
+                        scores_out = Identity(scores)
+                    },
+                    prob_mod = prob_mod (float[B,Hq,L,S] probs) => (float[B,Hq,L,S] probs_out) {
+                        probs_out = Identity(probs)
+                    }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 8, 128, 64))],
+            opset_imports=[
+                make_opsetid(ONNX_DOMAIN, 21),
+                make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+            ],
+        )
+
+    def test_flex_attention_rank_not_4_fails(self) -> None:
+        """Test FlexAttention fails when input rank is not 4."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 64)),  # rank 3 instead of 4
+                ("K", TensorProto.FLOAT, (2, 8, 256, 64)),
+                ("V", TensorProto.FLOAT, (2, 8, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[
+                    make_opsetid(ONNX_DOMAIN, 21),
+                    make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+                ],
+            )
+
+    def test_flex_attention_mismatched_elem_type_fails(self) -> None:
+        """Test FlexAttention fails when Q, K, V have different element types."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT16, (2, 8, 256, 64)),  # different type
+                ("V", TensorProto.FLOAT, (2, 8, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[
+                    make_opsetid(ONNX_DOMAIN, 21),
+                    make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+                ],
+            )
+
+    def test_flex_attention_gqa_not_divisible_fails(self) -> None:
+        """Test FlexAttention fails when Hq is not divisible by Hkv."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT, (2, 3, 256, 64)),  # 8 % 3 != 0
+                ("V", TensorProto.FLOAT, (2, 3, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[
+                    make_opsetid(ONNX_DOMAIN, 21),
+                    make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+                ],
+            )
+
+    def test_flex_attention_mismatched_kv_seq_len_fails(self) -> None:
+        """Test FlexAttention fails when K and V have different sequence lengths."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT, (2, 8, 256, 64)),
+                ("V", TensorProto.FLOAT, (2, 8, 512, 64)),  # S_v=512 != S_k=256
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[
+                    make_opsetid(ONNX_DOMAIN, 21),
+                    make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+                ],
+            )
+
+    def test_flex_attention_mismatched_kv_heads_fails(self) -> None:
+        """Test FlexAttention fails when K and V have different head counts."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT, (2, 8, 256, 64)),
+                ("V", TensorProto.FLOAT, (2, 4, 256, 64)),  # H_v=4 != H_k=8
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[
+                    make_opsetid(ONNX_DOMAIN, 21),
+                    make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+                ],
+            )
+
+    def test_flex_attention_mismatched_qk_head_size_fails(self) -> None:
+        """Test FlexAttention fails when Q and K have different head sizes."""
+        graph = self._make_graph(
+            [
+                ("Q", TensorProto.FLOAT, (2, 8, 128, 64)),
+                ("K", TensorProto.FLOAT, (2, 8, 256, 128)),  # Dqk=128 != 64
+                ("V", TensorProto.FLOAT, (2, 8, 256, 64)),
+            ],
+            [
+                make_node(
+                    "FlexAttention",
+                    ["Q", "K", "V"],
+                    ["Y"],
+                    domain=AI_ONNX_PREVIEW_DOMAIN,
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[
+                    make_opsetid(ONNX_DOMAIN, 21),
+                    make_opsetid(AI_ONNX_PREVIEW_DOMAIN, 1),
+                ],
+            )
+
+    def test_average_pool_auto_pads(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (30, 4, 7, 6, 4))],
+            [
+                make_node(
+                    "AveragePool",
+                    ["x"],
+                    "z",
+                    auto_pad="SAME_UPPER",
+                    kernel_shape=[4, 3, 2],
+                    strides=[2, 2, 1],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 4, 4, 3, 4))]
+        )
+
+    def test_average_pool_with_dilations(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "AveragePool", ["X"], ["Y"], kernel_shape=[2, 2], dilations=[2, 2]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 2, 2))]
+        )
+
+    def test_average_pool_with_same_upper_padding_and_stride_and_dilation(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "AveragePool",
+                    ["X"],
+                    ["Y"],
+                    auto_pad="SAME_UPPER",
+                    kernel_shape=[2, 2],
+                    strides=[2, 2],
+                    dilations=[2, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 2, 2))]
+        )
+
+    def test_relu(self) -> None:
+        self._identity_prop("Relu")
+
+    def test_identity(self) -> None:
+        self._identity_prop("Identity")
+
+    def test_identity_sequence(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 4)),
+                ("input3", TensorProto.FLOAT, (2, 5, 4)),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("Identity", ["in_sequence"], ["output_sequence"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, None, 4)
+                ),
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (2, None, 4)
+                ),
+            ],
+        )
+
+    def test_identity_optional(self) -> None:
+        graph = self._make_graph(
+            [("in_tensor", TensorProto.FLOAT, (2, 3, 4))],
+            [
+                make_node("Optional", ["in_tensor"], ["in_optional"]),
+                make_node("Identity", ["in_optional"], ["output_optional"]),
+            ],
+            [],
+        )
+        tensor_type_proto = helper.make_tensor_type_proto(TensorProto.FLOAT, (2, 3, 4))
+        optional_type_proto = helper.make_optional_type_proto(tensor_type_proto)
+        self._assert_inferred(
+            graph,
+            [
+                helper.make_value_info("in_optional", optional_type_proto),
+                helper.make_value_info("output_optional", optional_type_proto),
+            ],
+        )
+
+    def test_identity_optional_sequence(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 4)),
+                ("input3", TensorProto.FLOAT, (2, 5, 4)),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("Optional", ["in_sequence"], ["in_optional"]),
+                make_node("Identity", ["in_optional"], ["output_optional"]),
+            ],
+            [],
+        )
+        tensor_type_proto = helper.make_tensor_type_proto(
+            TensorProto.FLOAT, (2, None, 4)
+        )
+        sequence_type_proto = helper.make_sequence_type_proto(tensor_type_proto)
+        optional_type_proto = helper.make_optional_type_proto(sequence_type_proto)
+        self._assert_inferred(
+            graph,
+            [
+                helper.make_value_info("in_sequence", sequence_type_proto),
+                helper.make_value_info("in_optional", optional_type_proto),
+                helper.make_value_info("output_optional", optional_type_proto),
+            ],
+        )
+
+    def test_add(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 5)),
+                ("y", TensorProto.FLOAT, (30, 4, 5)),
+            ],
+            [make_node("Add", ["x", "y"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 4, 5))]
+        )
+
+    def test_pow(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 5)),
+                ("y", TensorProto.FLOAT, (30, 4, 5)),
+            ],
+            [make_node("Pow", ["x", "y"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (30, 4, 5))]
+        )
+
+    def test_bitshift(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT32, (2, 3, 1)),
+                ("y", TensorProto.UINT32, (2, 3, 1)),
+            ],
+            [make_node("BitShift", ["x", "y"], "z", direction="RIGHT")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.UINT32, (2, 3, 1))]
+        )
+
+    def test_bitshift_broadcast_to_first(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.UINT32, (16, 4, 1)), ("y", TensorProto.UINT32, (1,))],
+            [make_node("BitShift", ["x", "y"], "z", direction="RIGHT")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.UINT32, (16, 4, 1))]
+        )
+
+    def test_bitshift_broadcast_to_second(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.UINT32, (1,)), ("y", TensorProto.UINT32, (2, 3, 1))],
+            [make_node("BitShift", ["x", "y"], "z", direction="RIGHT")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.UINT32, (2, 3, 1))]
+        )
+
+    def test_sum_single(self) -> None:
+        self._identity_prop("Sum")
+
+    def test_sum_multi(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 4, 5)),
+                ("y", TensorProto.FLOAT, (30, 4, 5)),
+                ("z", TensorProto.FLOAT, (30, 4, 5)),
+            ],
+            [make_node("Sum", ["x", "y", "z"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (30, 4, 5))]
+        )
+
+    def test_sum_multi_broadcasting(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (30, 1, 5)),
+                ("y", TensorProto.FLOAT, ("a", 4, 1)),
+                ("z", TensorProto.FLOAT, (4, "b")),
+            ],
+            [make_node("Sum", ["x", "y", "z"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (30, 4, 5))]
+        )
+
+    def test_sum_broadcasting_param(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ("a", 1, 5)),
+                ("y", TensorProto.FLOAT, ("a", 4, 1)),
+            ],
+            [make_node("Sum", ["x", "y"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, ("a", 4, 5))]
+        )
+
+    def test_random_normal(self) -> None:
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "RandomNormal",
+                    [],
+                    ["out"],
+                    dtype=TensorProto.DOUBLE,
+                    shape=(3, 4, 5),
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.DOUBLE, (3, 4, 5))]
+        )
+
+    def test_random_normal_like(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 3, 4))],
+            [make_node("RandomNormalLike", ["X"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (2, 3, 4))]
+        )
+
+    def test_random_normal_like_with_dtype(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 3, 4))],
+            [
+                make_node(
+                    "RandomNormalLike",
+                    ["X"],
+                    ["out"],
+                    dtype=TensorProto.DOUBLE,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.DOUBLE, (2, 3, 4))]
+        )
+
+    def test_bernoulli(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4))],
+            [make_node("Bernoulli", ["x"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (3, 4))]
+        )
+
+    def test_bernoulli_with_dtype(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 4))],
+            [
+                make_node(
+                    "Bernoulli",
+                    ["x"],
+                    ["out"],
+                    dtype=TensorProto.DOUBLE,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.DOUBLE, (2, 3, 4))]
+        )
+
+    def _logical_binary_op(self, op: str, input_type: TensorProto.DataType) -> None:
+        graph = self._make_graph(
+            [("x", input_type, (30, 4, 5)), ("y", input_type, (30, 4, 5))],
+            [make_node(op, ["x", "y"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.BOOL, (30, 4, 5))]
+        )
+
+    def _logical_binary_op_with_broadcasting(
+        self, op: str, input_type: TensorProto.DataType
+    ) -> None:
+        graph = self._make_graph(
+            [("x", input_type, (1, 5)), ("y", input_type, (30, 4, 5))],
+            [make_node(op, ["x", "y"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.BOOL, (30, 4, 5))]
+        )
+
+    def test_logical_and(self) -> None:
+        self._logical_binary_op("And", TensorProto.BOOL)
+        self._logical_binary_op_with_broadcasting("And", TensorProto.BOOL)
+
+    def test_logical_or(self) -> None:
+        self._logical_binary_op("Or", TensorProto.BOOL)
+        self._logical_binary_op_with_broadcasting("Or", TensorProto.BOOL)
+
+    def test_logical_xor(self) -> None:
+        self._logical_binary_op("Xor", TensorProto.BOOL)
+        self._logical_binary_op_with_broadcasting("Xor", TensorProto.BOOL)
+
+    def test_greater(self) -> None:
+        self._logical_binary_op("Greater", TensorProto.BOOL)
+        self._logical_binary_op_with_broadcasting("Greater", TensorProto.BOOL)
+
+    def test_less(self) -> None:
+        self._logical_binary_op("Less", TensorProto.BOOL)
+        self._logical_binary_op_with_broadcasting("Less", TensorProto.BOOL)
+
+    def test_equal(self) -> None:
+        self._logical_binary_op("Equal", TensorProto.BOOL)
+        self._logical_binary_op_with_broadcasting("Equal", TensorProto.BOOL)
+
+    def test_equal_string(self) -> None:
+        self._logical_binary_op("Equal", TensorProto.STRING)
+        self._logical_binary_op_with_broadcasting("Equal", TensorProto.STRING)
+
+    def test_logical_not(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.BOOL, (30, 4, 5))], [make_node("Not", ["x"], "z")], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.BOOL, (30, 4, 5))]
+        )
+
+    def test_less_or_equal(self) -> None:
+        self._logical_binary_op("LessOrEqual", TensorProto.BOOL)
+        self._logical_binary_op_with_broadcasting("LessOrEqual", TensorProto.BOOL)
+
+    def test_greater_or_equal(self) -> None:
+        self._logical_binary_op("GreaterOrEqual", TensorProto.BOOL)
+        self._logical_binary_op_with_broadcasting("GreaterOrEqual", TensorProto.BOOL)
+
+    def test_flatten(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 4, 5))],
+            [make_node("Flatten", ["x"], ["z"], axis=2)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (6, 20))]
+        )
+
+    def test_flatten_default_axis(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 4, 5))],
+            [make_node("Flatten", ["x"], ["z"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 60))]
+        )
+
+    def test_flatten_zero_axis(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 4, 5))],
+            [make_node("Flatten", ["x"], ["z"], axis=0)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (1, 120))]
+        )
+
+    def test_flatten_unknown_dim(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, "N", 4, 5))],
+            [make_node("Flatten", ["x"], ["z"], axis=2)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (None, 20))]
+        )
+
+    def test_space_to_depth(self) -> None:
+        b = 10
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 100, 100))],
+            [make_node("SpaceToDepth", ["x"], ["z"], blocksize=b)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 300, 10, 10))]
+        )
+
+    def test_space_to_depth_unknown_dim(self) -> None:
+        b = 10
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, "N", 100, 100))],
+            [make_node("SpaceToDepth", ["x"], ["z"], blocksize=b)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, None, 10, 10))]
+        )
+
+    def test_depth_to_space(self) -> None:
+        b = 10
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 300, 10, 10))],
+            [make_node("DepthToSpace", ["x"], ["z"], blocksize=b, mode="DCR")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 3, 100, 100))]
+        )
+
+    def _rnn_forward(
+        self, seqlen: int, batchsize: int, inpsize: int, hiddensize: int
+    ) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (seqlen, batchsize, inpsize)),
+                ("w", TensorProto.FLOAT, (1, hiddensize, inpsize)),
+                ("r", TensorProto.FLOAT, (1, hiddensize, hiddensize)),
+            ],
+            [
+                make_node(
+                    "RNN", ["x", "w", "r"], ["all", "last"], hidden_size=hiddensize
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "all", TensorProto.FLOAT, (seqlen, 1, batchsize, hiddensize)
+                ),
+                make_tensor_value_info(
+                    "last", TensorProto.FLOAT, (1, batchsize, hiddensize)
+                ),
+            ],
+        )
+
+    def test_rnn_forward(self) -> None:
+        self._rnn_forward(64, 32, 10, 4)
+
+    def _rnn_bidirectional(
+        self, seqlen: int, batchsize: int, inpsize: int, hiddensize: int
+    ) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (seqlen, batchsize, inpsize)),
+                ("w", TensorProto.FLOAT, (2, hiddensize, inpsize)),
+                ("r", TensorProto.FLOAT, (2, hiddensize, hiddensize)),
+            ],
+            [
+                make_node(
+                    "RNN",
+                    ["x", "w", "r"],
+                    ["all", "last"],
+                    hidden_size=hiddensize,
+                    direction="bidirectional",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "all", TensorProto.FLOAT, (seqlen, 2, batchsize, hiddensize)
+                ),
+                make_tensor_value_info(
+                    "last", TensorProto.FLOAT, (2, batchsize, hiddensize)
+                ),
+            ],
+        )
+
+    def test_rnn_layout(self) -> None:
+        self._rnn_layout(64, 32, 10, 4)
+        self._rnn_layout(64, 32, 10, 4, "bidirectional")
+
+    def _rnn_layout(
+        self,
+        seqlen: int,
+        batchsize: int,
+        inpsize: int,
+        hiddensize: int,
+        direction: str = "forward",
+    ) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (batchsize, seqlen, inpsize)),
+                ("w", TensorProto.FLOAT, (1, hiddensize, inpsize)),
+                ("r", TensorProto.FLOAT, (1, hiddensize, hiddensize)),
+            ],
+            [
+                make_node(
+                    "RNN",
+                    ["x", "w", "r"],
+                    ["all", "last"],
+                    hidden_size=hiddensize,
+                    layout=1,
+                    direction=direction,
+                )
+            ],
+            [],
+        )
+        if direction == "bidirectional":
+            num_directions = 2
+        else:
+            num_directions = 1
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "all",
+                    TensorProto.FLOAT,
+                    (batchsize, seqlen, num_directions, hiddensize),
+                ),
+                make_tensor_value_info(
+                    "last", TensorProto.FLOAT, (batchsize, num_directions, hiddensize)
+                ),
+            ],
+        )
+
+    def test_rnn_bidirectional(self) -> None:
+        self._rnn_bidirectional(64, 32, 10, 4)
+
+    def _lstm_forward(
+        self, seqlen: int, batchsize: int, inpsize: int, hiddensize: int
+    ) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (seqlen, batchsize, inpsize)),
+                ("w", TensorProto.FLOAT, (1, 4 * hiddensize, inpsize)),
+                ("r", TensorProto.FLOAT, (1, 4 * hiddensize, hiddensize)),
+            ],
+            [
+                make_node(
+                    "LSTM",
+                    ["x", "w", "r"],
+                    ["all", "hidden", "last"],
+                    hidden_size=hiddensize,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "all", TensorProto.FLOAT, (seqlen, 1, batchsize, hiddensize)
+                ),
+                make_tensor_value_info(
+                    "hidden", TensorProto.FLOAT, (1, batchsize, hiddensize)
+                ),
+                make_tensor_value_info(
+                    "last", TensorProto.FLOAT, (1, batchsize, hiddensize)
+                ),
+            ],
+        )
+
+    def test_lstm_forward(self) -> None:
+        self._lstm_forward(64, 32, 10, 4)
+
+    def test_rnn_opset1_to_6_invalid_input_rank(self) -> None:
+        # RNNShapeInference_opset1_to_6 must reject non-rank-3 input X and raise
+        # InferenceError rather than accessing dim(0)/dim(1) out-of-bounds.
+        for op, w_shape, r_shape in [
+            ("RNN", (1, 4, 5), (1, 4, 4)),
+            ("GRU", (1, 12, 5), (1, 12, 4)),
+            ("LSTM", (1, 16, 5), (1, 16, 4)),
+        ]:
+            graph = helper.make_graph(
+                [make_node(op, ["x", "w", "r"], [], hidden_size=4)],
+                "test",
+                [
+                    make_tensor_value_info("x", TensorProto.FLOAT, (4, 5)),
+                    make_tensor_value_info("w", TensorProto.FLOAT, w_shape),
+                    make_tensor_value_info("r", TensorProto.FLOAT, r_shape),
+                ],
+                [],
+            )
+            with pytest.raises(onnx.shape_inference.InferenceError):
+                self._inferred(
+                    graph, opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 6)]
+                )
+
+    def test_topk_default_axis(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5, 10))],
+            [make_node("TopK", ["x", "k"], ["y", "z"])],
+            [],
+            initializer=[make_tensor("k", TensorProto.INT64, (1,), (2,))],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (3, 4, 5, 2)),
+                make_tensor_value_info("z", TensorProto.INT64, (3, 4, 5, 2)),
+            ],
+        )
+
+    def test_topk(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5, 10))],
+            [make_node("TopK", ["x", "k"], ["y", "z"], axis=2)],
+            [],
+            initializer=[make_tensor("k", TensorProto.INT64, (1,), (2,))],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (3, 4, 2, 10)),
+                make_tensor_value_info("z", TensorProto.INT64, (3, 4, 2, 10)),
+            ],
+        )
+
+    def test_topk_raw_data(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5, 10))],
+            [make_node("TopK", ["x", "k"], ["y", "z"], axis=2)],
+            [],
+            initializer=[
+                make_tensor(
+                    "k",
+                    TensorProto.INT64,
+                    (1,),
+                    vals=np.array([3], dtype="<i8").tobytes(),
+                    raw=True,
+                )
+            ],
+        )  # Feed raw bytes (force little endian ordering like onnx standard) for test purpose
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (3, 4, 3, 10)),
+                make_tensor_value_info("z", TensorProto.INT64, (3, 4, 3, 10)),
+            ],
+        )
+
+    def test_topk_missing_k_value_output_rank_check(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5, 10)), ("k", TensorProto.INT64, (1,))],
+            [make_node("TopK", ["x", "k"], ["y", "z"], axis=2)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "y", TensorProto.FLOAT, (None, None, None, None)
+                ),
+                make_tensor_value_info(
+                    "z", TensorProto.INT64, (None, None, None, None)
+                ),
+            ],
+        )
+
+    def test_gemm(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (7, 5)),
+                ("y", TensorProto.FLOAT, (5, 11)),
+                ("z", TensorProto.FLOAT, None),
+            ],
+            [make_node("Gemm", ["x", "y", "z"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (7, 11))]
+        )
+
+    def test_gemm_transA(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (5, 7)),
+                ("y", TensorProto.FLOAT, (5, 11)),
+                ("z", TensorProto.FLOAT, None),
+            ],
+            [make_node("Gemm", ["x", "y", "z"], ["out"], transA=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (7, 11))]
+        )
+
+    def test_gemm_transB(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (7, 5)),
+                ("y", TensorProto.FLOAT, (11, 5)),
+                ("z", TensorProto.FLOAT, None),
+            ],
+            [make_node("Gemm", ["x", "y", "z"], ["out"], transB=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (7, 11))]
+        )
+
+    def test_gemm_transA_and_transB(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (5, 7)),
+                ("y", TensorProto.FLOAT, (11, 5)),
+                ("z", TensorProto.FLOAT, None),
+            ],
+            [make_node("Gemm", ["x", "y", "z"], ["out"], transA=1, transB=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (7, 11))]
+        )
+
+    def test_gemm_no_bias(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (13, 7)), ("y", TensorProto.FLOAT, (7, 17))],
+            [make_node("Gemm", ["x", "y"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (13, 17))]
+        )
+
+    def test_reduce_op_shape_2_axis_opset13(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11))],
+            [make_node("ReduceL1", "x", "y", axes=(1, 2), keepdims=0)],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (2,), (1, 2))],
+        )
+        operatorsetid = OperatorSetIdProto()
+        operatorsetid.domain = ""
+        operatorsetid.version = 13
+
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (24,))],
+            opset_imports=[operatorsetid],
+        )
+
+    def test_reduce_op_shape_2_axis_opset18(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11)), ("axes", TensorProto.INT64, (2,))],
+            [make_node("ReduceL1", ["x", "axes"], "y", keepdims=0)],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (2,), (1, 2))],
+        )
+        operatorsetid = OperatorSetIdProto()
+        operatorsetid.domain = ""
+        operatorsetid.version = 18
+
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (24,))],
+            opset_imports=[operatorsetid],
+        )
+
+    def test_reduce_op_empty_set_opset13(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 0, 11))],
+            [make_node("ReduceL1", "x", "y", axes=(1,), keepdims=1)],
+            [],
+            initializer=[],
+        )
+        operatorsetid = OperatorSetIdProto(domain="", version=13)
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (24, 1, 11))],
+            opset_imports=[operatorsetid],
+        )
+
+    def test_reduce_op_empty_set_opset18(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 0, 11)), ("axes", TensorProto.INT64, (1,))],
+            [make_node("ReduceL1", ["x", "axes"], "y", keepdims=1)],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (1,), (1,))],
+        )
+        operatorsetid = OperatorSetIdProto(domain="", version=18)
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (24, 1, 11))],
+            opset_imports=[operatorsetid],
+        )
+
+    def test_reduce_op_shape_keep_dims_opset13(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11))],
+            [make_node("ReduceL1", "x", "y", axes=(1, 2), keepdims=1)],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (2,), (1, 2))],
+        )
+        operatorsetid = OperatorSetIdProto()
+        operatorsetid.domain = ""
+        operatorsetid.version = 13
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (24, 1, 1))],
+            opset_imports=[operatorsetid],
+        )
+
+    def test_reduce_op_shape_keep_dims_opset18(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11)), ("axes", TensorProto.INT64, (2,))],
+            [make_node("ReduceL1", ["x", "axes"], "y", keepdims=1)],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (2,), (1, 2))],
+        )
+        operatorsetid = OperatorSetIdProto()
+        operatorsetid.domain = ""
+        operatorsetid.version = 18
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (24, 1, 1))],
+            opset_imports=[operatorsetid],
+        )
+
+    def test_reduce_op_shape_default_value(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11))],
+            [make_node("ReduceL1", "x", "y")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, 1, 1))]
+        )
+
+    def test_reduce_op_shape_no_axes_do_not_keep_dims(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11))],
+            [make_node("ReduceL1", "x", "y", keepdims=0)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, ())]
+        )
+
+    def test_reduce_op_shape_negative_axis(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11)), ("axes", TensorProto.INT64, (2,))],
+            [make_node("ReduceL1", ["x", "axes"], "y")],
+            [],
+            initializer=[make_tensor("axes", TensorProto.INT64, (2,), (-1, -2))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (24, 1, 1))]
+        )
+
+    def test_argmax_shape(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11))],
+            [make_node("ArgMax", "x", "y", axis=1, keepdims=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, (24, 1, 11))]
+        )
+
+    def test_argmax_shape_keepdims(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11))],
+            [make_node("ArgMax", "x", "y", axis=0, keepdims=0)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, (4, 11))]
+        )
+
+    def test_argmax_shape_default_value(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11))], [make_node("ArgMax", "x", "y")], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, (1, 4, 11))]
+        )
+
+    def test_argmax_shape_negative_axis(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (24, 4, 11))],
+            [make_node("ArgMax", "x", "y", axis=-2)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, (24, 1, 11))]
+        )
+
+    def test_dropout(self) -> None:
+        graph = self._make_graph(
+            [
+                (
+                    "data",
+                    TensorProto.FLOAT,
+                    (
+                        3,
+                        4,
+                        5,
+                    ),
+                ),
+                ("ratio", TensorProto.FLOAT, ()),
+            ],
+            [make_node("Dropout", ["data", "ratio"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "out",
+                    TensorProto.FLOAT,
+                    (
+                        3,
+                        4,
+                        5,
+                    ),
+                )
+            ],
+        )
+
+    def test_LRN(self) -> None:
+        self._identity_prop("LRN", alpha=0.5, beta=0.5, size=1)
+
+    def test_batch_norm(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 4, 5, 6, 7)),
+                ("scale", TensorProto.FLOAT, (4,)),
+                ("b", TensorProto.FLOAT, (4,)),
+                ("mean", TensorProto.FLOAT, (4,)),
+                ("var", TensorProto.FLOAT, (4,)),
+            ],
+            [
+                make_node(
+                    "BatchNormalization", ["x", "scale", "b", "mean", "var"], ["out"]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (3, 4, 5, 6, 7))]
+        )
+
+    def test_batch_norm_rank1(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (128,)),  # 1-dimensional permitted
+                ("scale", TensorProto.FLOAT, (1,)),
+                ("b", TensorProto.FLOAT, (1,)),
+                ("mean", TensorProto.FLOAT, (1,)),
+                ("var", TensorProto.FLOAT, (1,)),
+            ],
+            [
+                make_node(
+                    "BatchNormalization", ["x", "scale", "b", "mean", "var"], ["out"]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (128,))]
+        )
+
+    def test_batch_norm_invalid(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (128,)),
+                ("scale", TensorProto.FLOAT, (1, 2)),  # invalid rank
+                ("b", TensorProto.FLOAT, (1,)),
+                ("mean", TensorProto.FLOAT, (1,)),
+                ("var", TensorProto.FLOAT, (1,)),
+            ],
+            [
+                make_node(
+                    "BatchNormalization", ["x", "scale", "b", "mean", "var"], ["out"]
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_split_negative_axis(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4))],
+            [make_node("Split", ["x"], ["y", "z"], axis=-1, num_outputs=2)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (2, 2)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (2, 2)),
+            ],
+        )
+
+    def test_split_with_split_attribute(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 4)), ("split", TensorProto.INT64, (2,))],
+            [make_node("Split", ["x", "split"], ["y", "z"], axis=1)],
+            [],
+            initializer=[make_tensor("split", TensorProto.INT64, (2,), (3, 1))],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (2, 3)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (2, 1)),
+            ],
+        )
+
+    def test_split_with_split_attribute_unknown_split_dim(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (2, "a", "b")),
+                ("split", TensorProto.INT64, (2,)),
+            ],
+            [make_node("Split", ["x", "split"], ["y", "z"], axis=1)],
+            [],
+            initializer=[make_tensor("split", TensorProto.INT64, (2,), (3, 1))],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (2, None, "b")),
+                make_tensor_value_info("z", TensorProto.FLOAT, (2, None, "b")),
+            ],
+        )
+
+    def test_split_from_GLU(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (5, 6, 7))],
+            [make_node("Split", ["x"], ["y", "z"], axis=1, num_outputs=2)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (5, 3, 7)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (5, 3, 7)),
+            ],
+        )
+
+    def test_split_uneven_split_2d(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (8, 2))],
+            [make_node("Split", ["x"], ["y", "z", "a"], axis=0, num_outputs=3)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (3, 2)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (3, 2)),
+                make_tensor_value_info("a", TensorProto.FLOAT, (2, 2)),
+            ],
+        )
+
+    def test_split_uneven_split_3d(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 7, 3))],
+            [make_node("Split", ["x"], ["y", "z", "a"], axis=1, num_outputs=3)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (2, 3, 3)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (2, 3, 3)),
+                make_tensor_value_info("a", TensorProto.FLOAT, (2, 1, 3)),
+            ],
+        )
+
+    def test_GLU_partial(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (5, 6, 7))],
+            [
+                make_node("Split", ["x"], ["y", "z"], axis=1, num_outputs=2),
+                make_node("Sigmoid", ["z"], ["a"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (5, 3, 7)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (5, 3, 7)),
+                make_tensor_value_info("a", TensorProto.FLOAT, (5, 3, 7)),
+            ],
+        )
+
+    def test_GLU(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (5, 6, 7))],
+            [
+                make_node("Split", ["x"], ["y", "z"], axis=1, num_outputs=2),
+                make_node("Sigmoid", ["z"], ["a"]),
+                make_node("Mul", ["y", "a"], ["b"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.FLOAT, (5, 3, 7)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (5, 3, 7)),
+                make_tensor_value_info("a", TensorProto.FLOAT, (5, 3, 7)),
+                make_tensor_value_info("b", TensorProto.FLOAT, (5, 3, 7)),
+            ],
+        )
+
+    def test_softmax_2d(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5))], [make_node("Softmax", ["x"], "z")], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (4, 5))]
+        )
+
+    def test_softmax_3d(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5, 6))],
+            [make_node("Softmax", ["x"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (4, 5, 6))]
+        )
+
+    def test_softmax_scalar_invalid(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ())], [make_node("Softmax", ["x"], "z")], []
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_hardmax_2d(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5))], [make_node("Hardmax", ["x"], "z")], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (4, 5))]
+        )
+
+    def test_hardmax_3d(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5, 6))],
+            [make_node("Hardmax", ["x"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (4, 5, 6))]
+        )
+
+    def test_hardmax_scalar_invalid(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ())], [make_node("Hardmax", ["x"], "z")], []
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_logsoftmax_2d(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5))],
+            [make_node("LogSoftmax", ["x"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (4, 5))]
+        )
+
+    def test_logsoftmax_3d(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5, 6))],
+            [make_node("LogSoftmax", ["x"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (4, 5, 6))]
+        )
+
+    def test_logsoftmax_scalar_invalid(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ())], [make_node("LogSoftmax", ["x"], "z")], []
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_logsoftmax_3d_negative_axis(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5, 6))],
+            [make_node("LogSoftmax", ["x"], "z", axis=-1)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (4, 5, 6))]
+        )
+
+    def test_maxpool(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("MaxPool", ["X"], ["Y"], kernel_shape=[2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3))]
+        )
+
+    def test_maxpool_with_indices(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("MaxPool", ["X"], ["Y", "Z"], kernel_shape=[2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3)),
+                make_tensor_value_info("Z", TensorProto.INT64, (5, 3, 3, 3)),
+            ],
+        )
+
+    def test_maxpool_3D(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4, 4))],
+            [make_node("MaxPool", ["X"], ["Y"], kernel_shape=[2, 2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3, 3))]
+        )
+
+    def test_maxpool_with_padding(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "MaxPool", ["X"], ["Y"], kernel_shape=[2, 2], pads=[1, 1, 2, 2]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 6, 6))]
+        )
+
+    def test_maxpool_with_padding_and_stride(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[2, 2],
+                    pads=[1, 1, 2, 2],
+                    strides=[2, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3))]
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("MaxPool"))
+    def test_maxpool_zero_strides(self, version: int) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[2, 2],
+                    strides=[0, 2],
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("MaxPool"))
+    def test_maxpool_negative_strides(self, version: int) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[2, 2],
+                    strides=[-1, 2],
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    def test_maxpool_with_floor_mode(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (32, 288, 35, 35))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[2, 2],
+                    strides=[2, 2],
+                    ceil_mode=False,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (32, 288, 17, 17))]
+        )
+
+    def test_maxpool_with_ceil_mode(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (32, 288, 35, 35))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[2, 2],
+                    strides=[2, 2],
+                    ceil_mode=True,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (32, 288, 18, 18))]
+        )
+
+    def test_maxpool_ceil(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (1, 1, 4, 4))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[3, 3],
+                    strides=[2, 2],
+                    ceil_mode=True,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (1, 1, 2, 2))]
+        )
+
+    def test_maxpool_with_dilations(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("MaxPool", ["X"], ["Y"], kernel_shape=[2, 2], dilations=[2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 2, 2))]
+        )
+
+    def test_maxpool_with_same_upper_padding_and_stride(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    auto_pad="SAME_UPPER",
+                    kernel_shape=[2, 2],
+                    strides=[2, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 2, 2))]
+        )
+
+    def test_maxpool_with_same_upper_padding_and_stride_and_dilation(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    auto_pad="SAME_UPPER",
+                    kernel_shape=[2, 2],
+                    strides=[2, 2],
+                    dilations=[2, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 2, 2))]
+        )
+
+    def test_maxpool_with_same_upper_padding_and_stride_one(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    auto_pad="SAME_UPPER",
+                    kernel_shape=[2, 2],
+                    strides=[1, 1],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 4, 4))]
+        )
+
+    def test_maxpool_with_same_lower_padding_and_stride(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 9, 9))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    auto_pad="SAME_LOWER",
+                    kernel_shape=[2, 2],
+                    strides=[2, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 5, 5))]
+        )
+
+    def test_maxpool_with_same_lower_padding_and_stride_and_dilation(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 9, 9))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    auto_pad="SAME_LOWER",
+                    kernel_shape=[2, 2],
+                    strides=[2, 2],
+                    dilations=[2, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 5, 5))]
+        )
+
+    def test_maxpool_with_same_lower_padding_and_big_stride(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "MaxPool",
+                    ["X"],
+                    ["Y"],
+                    auto_pad="SAME_LOWER",
+                    kernel_shape=[2, 2],
+                    strides=[4, 4],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 1, 1))]
+        )
+
+    def test_averagepool(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("AveragePool", ["X"], ["Y"], kernel_shape=[2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3))]
+        )
+
+    def test_averagepool_3D(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4, 4))],
+            [make_node("AveragePool", ["X"], ["Y"], kernel_shape=[2, 2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3, 3))]
+        )
+
+    def test_averagepool_with_padding(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "AveragePool", ["X"], ["Y"], kernel_shape=[2, 2], pads=[1, 1, 2, 2]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 6, 6))]
+        )
+
+    def test_averagepool_with_padding_and_stride(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "AveragePool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[2, 2],
+                    pads=[1, 1, 2, 2],
+                    strides=[2, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3))]
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("AveragePool"))
+    def test_averagepool_zero_strides(self, version: int) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "AveragePool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[2, 2],
+                    strides=[2, 0],
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    @pytest.mark.parametrize("version", all_versions_for("AveragePool"))
+    def test_averagepool_negative_strides(self, version: int) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "AveragePool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[2, 2],
+                    strides=[2, -1],
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    def test_averagepool_ceil(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (1, 1, 4, 4))],
+            [
+                make_node(
+                    "AveragePool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[3, 3],
+                    strides=[2, 2],
+                    ceil_mode=True,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (1, 1, 2, 2))]
+        )
+
+    def test_lppool(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("LpPool", ["X"], ["Y"], kernel_shape=[2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3))]
+        )
+
+    def test_lppool_3D(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4, 4))],
+            [make_node("LpPool", ["X"], ["Y"], kernel_shape=[2, 2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3, 3))]
+        )
+
+    def test_lppool_with_padding(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("LpPool", ["X"], ["Y"], kernel_shape=[2, 2], pads=[1, 1, 2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 6, 6))]
+        )
+
+    def test_lppool_with_padding_and_stride(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "LpPool",
+                    ["X"],
+                    ["Y"],
+                    kernel_shape=[2, 2],
+                    pads=[1, 1, 2, 2],
+                    strides=[2, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 3, 3))]
+        )
+
+    def test_lppool_with_dilations(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("LpPool", ["X"], ["Y"], kernel_shape=[2, 2], dilations=[2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 2, 2))]
+        )
+
+    def test_lppool_with_same_upper_padding_and_stride_and_dilation(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [
+                make_node(
+                    "LpPool",
+                    ["X"],
+                    ["Y"],
+                    auto_pad="SAME_UPPER",
+                    kernel_shape=[2, 2],
+                    strides=[2, 2],
+                    dilations=[2, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 2, 2))]
+        )
+
+    def test_roipool(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (5, 3, 4, 4)),
+                ("rois", TensorProto.INT64, (2, 5)),
+            ],
+            [make_node("MaxRoiPool", ["X", "rois"], ["Y"], pooled_shape=[2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 3, 2, 2))]
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("MaxRoiPool"))
+    def test_roipool_negative_pooled_shape(self, version: int) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (5, 3, 4, 4)),
+                ("rois", TensorProto.INT64, (2, 5)),
+            ],
+            [make_node("MaxRoiPool", ["X", "rois"], ["Y"], pooled_shape=[-1, 2])],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    def test_lp_norm(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5, 6, 7))],
+            [make_node("LpNormalization", ["x"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (3, 4, 5, 6, 7))]
+        )
+
+    def test_instance_norm(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 4, 5, 6, 7)),
+                ("scale", TensorProto.FLOAT, (4,)),
+                ("b", TensorProto.FLOAT, (4,)),
+            ],
+            [make_node("InstanceNormalization", ["x", "scale", "b"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (3, 4, 5, 6, 7))]
+        )
+
+    def test_global_maxpool(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("GlobalMaxPool", ["X"], ["Y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 1, 1))]
+        )
+
+    def test_global_averagepool(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("GlobalAveragePool", ["X"], ["Y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 1, 1))]
+        )
+
+    def test_global_lppool(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (5, 3, 4, 4))],
+            [make_node("GlobalLpPool", ["X"], ["Y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (5, 3, 1, 1))]
+        )
+
+    def test_conv_transpose(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (48, 32, 3, 3)),
+            ],
+            [make_node("ConvTranspose", ["X", "W"], "Y", strides=[2, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 32, 33, 33))]
+        )
+
+    def test_conv_transpose_with_pads(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (48, 32, 3, 3)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose", ["X", "W"], "Y", strides=[2, 2], pads=[1, 1, 2, 2]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 32, 30, 30))]
+        )
+
+    def test_conv_transpose_with_output_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (48, 32, 3, 3)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose",
+                    ["X", "W"],
+                    "Y",
+                    strides=[2, 2],
+                    pads=[1, 1, 2, 2],
+                    output_shape=[36, 36],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 32, 36, 36))]
+        )
+
+    def test_conv_transpose_with_kernel_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (48, 32, None, None)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose",
+                    ["X", "W"],
+                    "Y",
+                    kernel_shape=[3, 3],
+                    strides=[2, 2],
+                    pads=[1, 1, 2, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 32, 30, 30))]
+        )
+
+    def test_conv_transpose_with_dilations(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (48, 32, 3, 3)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose",
+                    ["X", "W"],
+                    "Y",
+                    strides=[2, 2],
+                    pads=[1, 1, 2, 2],
+                    dilations=[3, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 32, 34, 34))]
+        )
+
+    def test_conv_transpose_with_group(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (48, 32, 3, 3)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose",
+                    ["X", "W"],
+                    "Y",
+                    strides=[2, 2],
+                    pads=[1, 1, 2, 2],
+                    group=2,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 64, 30, 30))]
+        )
+
+    def test_conv_transpose_with_group_and_output_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (48, 32, 3, 3)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose",
+                    ["X", "W"],
+                    "Y",
+                    strides=[2, 2],
+                    pads=[1, 1, 2, 2],
+                    group=2,
+                    output_shape=[36, 36],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 64, 36, 36))]
+        )
+
+    def test_conv_transpose_with_pads_and_auto_pads(self) -> None:
+        # This test should fail because pads cannot be used simultaneously with auto_pad
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (1, 1, 2, 2)),
+                ("W", TensorProto.FLOAT, (1, 1, 3, 3)),
+                ("B", TensorProto.FLOAT, (1,)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose",
+                    ["X", "W", "B"],
+                    "Y",
+                    auto_pad="SAME_UPPER",
+                    strides=[1, 1],
+                    pads=[0, 1, 1, 0],
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(
+                helper.make_model(graph),
+                strict_mode=True,
+            )
+
+    def test_conv_transpose_auto_pads(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (48, 32, 3, 3)),
+            ],
+            [
+                make_node(
+                    "ConvTranspose",
+                    ["X", "W"],
+                    "Y",
+                    auto_pad="SAME_UPPER",
+                    strides=[2, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 32, 32, 32))]
+        )
+
+    def test_mvn_function_output_shape(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (25, 48, 16, 16))],
+            [make_node("MeanVarianceNormalization", "X", "Y", axes=[0, 2, 3])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 48, 16, 16))]
+        )
+
+    def test_scan(self) -> None:
+        # The whole graph (including the Scan body subgraph) is expressed in one parse_graph call;
+        # the Scan outputs are left untyped so that shape inference must compute their type/shape.
+        # The leading "" input is the (unused) optional sequence_lens input of opset-8 Scan.
+        # Test-input alteration: the body placeholders (loop_state_in/input/loop_state_out/output) were declared
+        # with an explicit UNDEFINED element type in the original make_graph version; the parser leaves them
+        # untyped, which shape inference fills identically.
+        graph = parse_graph("""
+            agraph (float[1, 3] loop_state_orig, float[1, sequence, 2] scan_input)
+                => (loop_state_final, scan_output)
+            {
+                loop_state_final, scan_output = Scan ("", loop_state_orig, scan_input) <
+                    num_scan_inputs = 1,
+                    body = subgraph (loop_state_in, input) => (loop_state_out, output) {
+                        loop_state_out = Identity(loop_state_in)
+                        output = Identity(input)
+                    }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("loop_state_final", TensorProto.FLOAT, (1, 3)),
+                make_tensor_value_info(
+                    "scan_output", TensorProto.FLOAT, (1, "sequence", 2)
+                ),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 8)],
+        )
+
+    @pytest.mark.parametrize(
+        "model_text",
+        [
+            pytest.param(
+                """
+                <ir_version: 10, opset_import: ["" : 21]>
+                agraph (float[2] in0, float[3, 2] in1) => (out) {
+                    out = Scan <num_scan_inputs = 9, body = b (float a, float x) => (float c) {
+                        c = Add(a, x)
+                    }> (in0, in1)
+                }
+                """,
+                id="opset21",
+            ),
+            pytest.param(
+                """
+                <ir_version: 8, opset_import: ["" : 9]>
+                agraph (float[2] in0, float[3, 2] in1) => (out) {
+                    out = Scan <num_scan_inputs = 9, body = b (float a, float x) => (float c) {
+                        c = Add(a, x)
+                    }> (in0, in1)
+                }
+                """,
+                id="opset9",
+            ),
+            pytest.param(
+                """
+                <ir_version: 8, opset_import: ["" : 8]>
+                agraph (float[1, 3] ls, float[1, 2, 2] si) => (out) {
+                    out = Scan <num_scan_inputs = 9, body = b (float a, float x) => (float c) {
+                        c = Add(a, x)
+                    }> ("", ls, si)
+                }
+                """,
+                id="opset8",
+            ),
+        ],
+    )
+    def test_scan_num_scan_inputs_out_of_range(self, model_text: str) -> None:
+        # num_scan_inputs > input count must raise, not underflow (opsets 8, 9, 21).
+        model = onnx.parser.parse_model(model_text)
+        with pytest.raises(
+            onnx.shape_inference.InferenceError, match="num_scan_inputs"
+        ):
+            self._inferred(model)
+
+    @pytest.mark.parametrize(
+        ("opset", "ir_version"),
+        [(21, 10), (9, 8)],
+        ids=["opset21", "opset9"],
+    )
+    def test_scan_loop_state_vars_exceed_outputs(
+        self, opset: int, ir_version: int
+    ) -> None:
+        # More loop state vars than outputs must raise, not underflow (opsets 9, 21).
+        model = onnx.parser.parse_model(
+            f"""
+            <ir_version: {ir_version}, opset_import: ["" : {opset}]>
+            agraph (float[2] in0, float[2] in1, float[3, 2] in2) => (out) {{
+                out = Scan <num_scan_inputs = 1, body = b (float a, float s0, float s1) => (float c) {{
+                    c = Identity(a)
+                }}> (in0, in1, in2)
+            }}
+            """
+        )
+        with pytest.raises(
+            onnx.shape_inference.InferenceError, match="loop state variables"
+        ):
+            self._inferred(model)
+
+    def test_scan_opset9(self) -> None:
+        # The whole graph (including the Scan body subgraph) is expressed in one parse_graph call;
+        # the Scan outputs are left untyped so that shape inference must compute their type/shape.
+        # Test-input alteration: the body placeholders (loop_state_in/input/loop_state_out/output) were declared
+        # with an explicit UNDEFINED element type in the original make_graph version; the parser leaves them
+        # untyped, which shape inference fills identically.
+        graph = parse_graph("""
+            agraph (float[3] loop_state_orig, float[sequence, 2] scan_input)
+                => (loop_state_final, scan_output)
+            {
+                loop_state_final, scan_output = Scan (loop_state_orig, scan_input) <
+                    num_scan_inputs = 1,
+                    body = subgraph (loop_state_in, input) => (loop_state_out, output) {
+                        loop_state_out = Identity(loop_state_in)
+                        output = Identity(input)
+                    }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("loop_state_final", TensorProto.FLOAT, (3,)),
+                make_tensor_value_info(
+                    "scan_output", TensorProto.FLOAT, ("sequence", 2)
+                ),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 9)],
+        )
+
+    def test_scan_opset9_axes(self) -> None:
+        # The whole graph (including the Scan body subgraph) is expressed in one parse_graph call;
+        # the Scan outputs are left untyped so that shape inference must compute their type/shape.
+        # Test-input alteration: the body placeholders (loop_state_in/input/loop_state_out/output) were declared
+        # with an explicit UNDEFINED element type in the original make_graph version; the parser leaves them
+        # untyped, which shape inference fills identically.
+        graph = parse_graph("""
+            agraph (float[3] loop_state_orig, float[axis0, sequence, 2] scan_input)
+                => (loop_state_final, scan_output)
+            {
+                loop_state_final, scan_output = Scan (loop_state_orig, scan_input) <
+                    num_scan_inputs = 1, scan_input_axes = [1],
+                    body = subgraph (loop_state_in, input) => (loop_state_out, output) {
+                        loop_state_out = Identity(loop_state_in)
+                        output = Identity(input)
+                    }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("loop_state_final", TensorProto.FLOAT, (3,)),
+                make_tensor_value_info(
+                    "scan_output", TensorProto.FLOAT, ("sequence", "axis0", 2)
+                ),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 9)],
+        )
+
+    def test_scan_opset9_output_axes(self) -> None:
+        # Test-input alteration: the body placeholders (loop_state_in/input/loop_state_out/output) were declared
+        # with an explicit UNDEFINED element type in the original make_graph version; the new version leaves them
+        # untyped, which shape inference fills identically.
+        graph = parse_graph("""
+            agraph (float[3] loop_state_orig, float[axis0, sequence, 2] scan_input)
+                => (loop_state_final, scan_output)
+            {
+                loop_state_final, scan_output = Scan (loop_state_orig, scan_input) <
+                    num_scan_inputs = 1, scan_input_axes = [1], scan_output_axes = [1],
+                    body = subgraph (loop_state_in, input) => (loop_state_out, output) {
+                        loop_state_out = Identity(loop_state_in)
+                        output = Identity(input)
+                    }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("loop_state_final", TensorProto.FLOAT, (3,)),
+                make_tensor_value_info(
+                    "scan_output", TensorProto.FLOAT, ("axis0", "sequence", 2)
+                ),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 9)],
+        )
+
+    def test_scan_opset9_negative_axes(self) -> None:
+        # Test-input alteration: the body placeholders (loop_state_in/input/loop_state_out/output) were declared
+        # with an explicit UNDEFINED element type in the original make_graph version; the new version leaves them
+        # untyped, which shape inference fills identically.
+        graph = parse_graph("""
+            agraph (float[3] loop_state_orig, float[axis0, sequence, 2] scan_input)
+                => (loop_state_final, scan_output)
+            {
+                loop_state_final, scan_output = Scan (loop_state_orig, scan_input) <
+                    num_scan_inputs = 1, scan_input_axes = [-2], scan_output_axes = [-2],
+                    body = subgraph (loop_state_in, input) => (loop_state_out, output) {
+                        loop_state_out = Identity(loop_state_in)
+                        output = Identity(input)
+                    }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("loop_state_final", TensorProto.FLOAT, (3,)),
+                make_tensor_value_info(
+                    "scan_output", TensorProto.FLOAT, ("axis0", "sequence", 2)
+                ),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 9)],
+        )
+
+    def test_if_ver1(self) -> None:
+        # Create a simple If node where the 'then' subgraph adds to the current value, and the 'else' subgraph
+        # subtracts.
+        # Test-input alteration: the branch outputs (then_output/else_output) were declared with an explicit
+        # UNDEFINED element type in the original make_graph version; the parser leaves them untyped, which
+        # shape inference fills identically.
+        graph = parse_graph("""
+            agraph (bool[1] cond, float[1] current_value, float[1] add_value, float[1] sub_value) => (if_output)
+            {
+                if_output = If (cond) <
+                    then_branch = then_subgraph () => (then_output) { then_output = Add(current_value, add_value) },
+                    else_branch = else_subgraph () => (else_output) { else_output = Sub(current_value, sub_value) }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("if_output", TensorProto.FLOAT, (1,))],
+            opset_imports=[make_opsetid(ONNX_DOMAIN, 10)],
+        )
+
+    def test_if(self) -> None:
+        # Create a simple If node where the 'then' subgraph adds to the current value, and the 'else' subgraph
+        # subtracts.
+        # Test-input alteration: the branch outputs (then_output/else_output) were declared with an explicit
+        # UNDEFINED element type in the original make_graph version; the new version leaves them untyped, which
+        # shape inference fills identically.
+        graph = parse_graph("""
+            agraph (bool[1] cond, float[1] current_value, float[1] add_value, float[1] sub_value) => (if_output)
+            {
+                if_output = If (cond) <
+                    then_branch = then_subgraph () => (then_output) { then_output = Add(current_value, add_value) },
+                    else_branch = else_subgraph () => (else_output) { else_output = Sub(current_value, sub_value) }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph, [make_tensor_value_info("if_output", TensorProto.FLOAT, (1,))]
+        )
+
+    def test_if_with_different_shapes_in_then_else_branches(self) -> None:
+        # Create a simple If node where the 'then' subgraph adds to the current value, and the 'else' subgraph
+        # subtracts. The then/else branches produce different shapes ((1,) vs (5,)), so inference merges them
+        # to an unknown dimension.
+        # Test-input alteration: the branch outputs were declared as UNDEFINED with shapes (1,)/(5,) in the
+        # original make_graph version; the new version leaves them untyped, dropping those (redundant) declared
+        # shapes -- shape inference computes the merged shape (None,) either way.
+        graph = parse_graph("""
+            agraph (bool[1] cond, float[1] current_value, float[1] add_value, float[5] sub_value) => (if_output)
+            {
+                if_output = If (cond) <
+                    then_branch = then_subgraph () => (then_output) { then_output = Add(current_value, add_value) },
+                    else_branch = else_subgraph () => (else_output) { else_output = Sub(current_value, sub_value) }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph, [make_tensor_value_info("if_output", TensorProto.FLOAT, (None,))]
+        )
+
+    def test_if_no_shape_in_then_branch(self) -> None:
+        # The branches reference X/axes from the enclosing scope. if_output's inferred type has unknown rank (no
+        # shape field), so it is kept as an intermediate value (checked via value_info) rather than a graph
+        # output: the checker requires graph inputs/outputs to carry a shape (i.e. a known rank), while
+        # value_info entries have no such requirement.
+        graph = parse_graph("""
+            agraph (bool[1] cond, float[4,8,16] X, int64[1] axes) => ()
+            {
+                if_output = If (cond) <
+                    then_branch = then_graph () => (then_output) { then_output = ReduceSum <keepdims=0> (X, axes) },
+                    else_branch = else_graph () => (else_output) { else_output = ReduceSum <keepdims=0> (X) }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph, [make_tensor_value_info("if_output", TensorProto.FLOAT, None)]
+        )
+
+    def test_if_no_shape_in_else_branch(self) -> None:
+        # The branches reference X/axes from the enclosing scope.
+        graph = parse_graph("""
+            agraph (bool[1] cond, float[4,8,16] X, int64[1] axes) => ()
+            {
+                if_output = If (cond) <
+                    then_branch = then_graph () => (then_output) { then_output = ReduceSum <keepdims=0> (X) },
+                    else_branch = else_graph () => (else_output) { else_output = ReduceSum <keepdims=0> (X, axes) }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph, [make_tensor_value_info("if_output", TensorProto.FLOAT, None)]
+        )
+
+    def test_if_with_different_optional_shapes_in_then_else_branches(self) -> None:
+        # Each branch wraps an outer-scope tensor (then_tensor_value FLOAT[1] / else_tensor_value FLOAT[5]) with Optional; the
+        # branch outputs are left untyped so shape inference must compute them, and the If-merge yields
+        # optional<FLOAT[None]> (shapes 1 and 5 differ).
+        #
+        # NOTE (test-input alteration): the original make_graph version pre-declared each branch output as
+        # optional<tensor(UNDEFINED)[1]> / optional<tensor(UNDEFINED)[5]>. Those pre-declared types are
+        # overwritten by shape inference (Optional re-derives the type from the wrapped tensor), so leaving the
+        # branch outputs untyped produces an identical inferred result; the subgraph output protos differ
+        # slightly from the pre-conversion version.
+        graph = parse_graph("""
+            agraph (bool[1] cond, float[1] then_tensor_value, float[5] else_tensor_value) => ()
+            {
+                if_output = If (cond) <
+                    then_branch = then_subgraph () => (then_optional_output) {
+                        then_optional_output = Optional(then_tensor_value)
+                    },
+                    else_branch = else_subgraph () => (else_optional_output) {
+                        else_optional_output = Optional(else_tensor_value)
+                    }
+                >
+            }
+        """)
+
+        output_tensor_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.FLOAT, shape=(None,)
+        )
+        output_optional_type_proto = helper.make_optional_type_proto(
+            output_tensor_proto
+        )
+        output_optional_vi = helper.make_value_info(
+            "if_output", output_optional_type_proto
+        )
+        self._assert_inferred(graph, [output_optional_vi])
+
+    def test_maxunpool_shape_without_output_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("xT", TensorProto.FLOAT, (1, 1, 2, 2)),
+                ("xI", TensorProto.FLOAT, (1, 1, 2, 2)),
+            ],
+            [
+                make_node(
+                    "MaxUnpool", ["xT", "xI"], "Y", kernel_shape=[2, 2], strides=[2, 2]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (1, 1, 4, 4))]
+        )
+
+    def test_maxunpool_shape_with_output_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("xT", TensorProto.FLOAT, (1, 1, 2, 2)),
+                ("xI", TensorProto.FLOAT, (1, 1, 2, 2)),
+                ("output_shape", TensorProto.FLOAT, (4,)),
+            ],
+            [
+                make_node(
+                    "MaxUnpool",
+                    ["xT", "xI", "output_shape"],
+                    "Y",
+                    kernel_shape=[2, 2],
+                    strides=[2, 2],
+                )
+            ],
+            [make_tensor_value_info("Y", TensorProto.FLOAT, None)],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, None)]
+        )
+
+    def test_maxunpool_rank0_indices_raises(self) -> None:
+        graph = self._make_graph(
+            [
+                ("xT", TensorProto.FLOAT, (1, 1, 2, 2)),
+                ("xI", TensorProto.INT64, ()),
+            ],
+            [
+                make_node(
+                    "MaxUnpool", ["xT", "xI"], "Y", kernel_shape=[2, 2], strides=[2, 2]
+                )
+            ],
+            [],
+            initializer=[
+                make_tensor("xI", TensorProto.INT64, (), [0]),
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_conv_transpose_rank0_weight_raises(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, ()),
+            ],
+            [make_node("ConvTranspose", ["X", "W"], "Y", strides=[2, 2])],
+            [],
+            initializer=[
+                make_tensor("W", TensorProto.FLOAT, (), [0.0]),
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_conv_transpose_rank1_weight_raises(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (9,)),
+            ],
+            [make_node("ConvTranspose", ["X", "W"], "Y", strides=[2, 2])],
+            [],
+            initializer=[
+                make_tensor("W", TensorProto.FLOAT, (9,), list(range(9))),
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_conv_transpose_rank2_weight_raises(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, (48, 32)),
+            ],
+            [make_node("ConvTranspose", ["X", "W"], "Y", strides=[2, 2])],
+            [],
+            initializer=[
+                make_tensor("W", TensorProto.FLOAT, (48, 32), list(range(48 * 32))),
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_conv_transpose_rank2_input_raises(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48)),
+                ("W", TensorProto.FLOAT, (48, 32, 3, 3)),
+            ],
+            [make_node("ConvTranspose", ["X", "W"], "Y", strides=[2, 2])],
+            [],
+            initializer=[
+                make_tensor("X", TensorProto.FLOAT, (25, 48), list(range(25 * 48))),
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_conv_transpose_rank0_weight_raises_opset11(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, ()),
+            ],
+            [make_node("ConvTranspose", ["X", "W"], "Y", strides=[2, 2])],
+            [],
+            initializer=[
+                make_tensor("W", TensorProto.FLOAT, (), [0.0]),
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 11)],
+            )
+
+    def test_conv_transpose_rank0_weight_raises_opset1(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, (25, 48, 16, 16)),
+                ("W", TensorProto.FLOAT, ()),
+            ],
+            [make_node("ConvTranspose", ["X", "W"], "Y", strides=[2, 2])],
+            [],
+            initializer=[
+                make_tensor("W", TensorProto.FLOAT, (), [0.0]),
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 1)],
+            )
+
+    def test_maxunpool_rank0_indices_raises_opset9(self) -> None:
+        graph = self._make_graph(
+            [
+                ("xT", TensorProto.FLOAT, (1, 1, 2, 2)),
+                ("xI", TensorProto.INT64, ()),
+            ],
+            [
+                make_node(
+                    "MaxUnpool", ["xT", "xI"], "Y", kernel_shape=[2, 2], strides=[2, 2]
+                )
+            ],
+            [],
+            initializer=[
+                make_tensor("xI", TensorProto.INT64, (), [0]),
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 9)],
+            )
+
+    def test_maxunpool_rank0_indices_raises_opset11(self) -> None:
+        graph = self._make_graph(
+            [
+                ("xT", TensorProto.FLOAT, (1, 1, 2, 2)),
+                ("xI", TensorProto.INT64, ()),
+            ],
+            [
+                make_node(
+                    "MaxUnpool", ["xT", "xI"], "Y", kernel_shape=[2, 2], strides=[2, 2]
+                )
+            ],
+            [],
+            initializer=[
+                make_tensor("xI", TensorProto.INT64, (), [0]),
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 11)],
+            )
+
+    def test_onehot_without_axis(self) -> None:
+        graph = self._make_graph(
+            [
+                ("indices", TensorProto.INT64, (2, 2)),
+                ("depth", TensorProto.INT64, ()),
+                ("values", TensorProto.FLOAT, (2,)),
+            ],
+            [make_node("OneHot", ["indices", "depth", "values"], "Y")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 2, None))]
+        )
+
+    def test_onehot_with_axis(self) -> None:
+        graph = self._make_graph(
+            [
+                ("indices", TensorProto.INT64, (2, 3, 5)),
+                ("depth", TensorProto.INT64, (1,)),
+                ("values", TensorProto.FLOAT, (2,)),
+            ],
+            [make_node("OneHot", ["indices", "depth", "values"], "Y", axis=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (2, None, 3, 5))]
+        )
+
+    def test_onehot_without_axis_2(self) -> None:
+        graph = self._make_graph(
+            [
+                ("indices", TensorProto.INT64, (2, 2)),
+                ("depth", TensorProto.INT64, ()),
+                ("values", TensorProto.FLOAT, (2,)),
+            ],
+            [make_node("OneHot", ["indices", "depth", "values"], "Y")],
+            [],
+            initializer=[make_tensor("depth", TensorProto.INT64, (), (256,))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 2, 256))]
+        )
+
+    def test_onehot_with_axis_2(self) -> None:
+        graph = self._make_graph(
+            [
+                ("indices", TensorProto.INT64, (2, 3, 5)),
+                ("depth", TensorProto.INT64, (1,)),
+                ("values", TensorProto.FLOAT, (2,)),
+            ],
+            [make_node("OneHot", ["indices", "depth", "values"], "Y", axis=1)],
+            [],
+            initializer=[make_tensor("depth", TensorProto.INT64, (1,), (256,))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (2, 256, 3, 5))]
+        )
+
+    def test_loop(self) -> None:
+        # The body's cond_in and loop_state_in are left untyped (their types are supplied by Loop), and the
+        # body references outer_scope_input from the enclosing graph. loop_state_final's rank may change
+        # between iterations, so its inferred type has unknown rank (no shape field); it is kept as an
+        # intermediate value (checked via value_info) rather than a graph output, since the checker requires
+        # graph inputs/outputs to carry a shape (i.e. a known rank). loop_output is declared as an untyped
+        # graph output so that shape inference must compute its type/shape.
+        #
+        # NOTE (test-input alteration): the original make_graph version declared cond_in/loop_state_in with an
+        # explicit UNDEFINED element type (type field present, elem_type 0, no shape); the parser instead emits
+        # no type field at all. Both are accepted by Loop shape inference and yield identical inferred results,
+        # but the body input protos differ slightly from the pre-conversion version.
+        graph = parse_graph("""
+            agraph (
+                int64[1] max_trip_count, float[1] cond_orig, float[2] loop_state_orig, float[3] outer_scope_input
+            ) => (loop_output)
+            {
+                loop_state_final, loop_output = Loop (max_trip_count, cond_orig, loop_state_orig) <
+                    body = subgraph (int64[1] iter_num_in, cond_in, loop_state_in)
+                        => (cond_out, loop_state_out, float[3] output) {
+                        cond_out = Identity(cond_in)
+                        loop_state_out = Identity(loop_state_in)
+                        output = Identity(outer_scope_input)
+                    }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "loop_state_final", TensorProto.FLOAT, None
+                ),  # shape may change between iterations
+                make_tensor_value_info("loop_output", TensorProto.FLOAT, (None, 3)),
+            ],
+        )
+
+    def test_loop_no_state(self) -> None:
+        # The body's cond_in is left untyped (its type is supplied by Loop), and the body references
+        # outer_scope_input from the enclosing graph. The Loop output is left untyped so that shape
+        # inference must compute its type/shape.
+        # Test-input alteration: cond_in/cond_out were declared with an explicit UNDEFINED element type in the
+        # original make_graph version; the parser leaves them untyped, which shape inference fills identically.
+        graph = parse_graph("""
+            agraph (int64[1] max_trip_count, float[1] cond_orig, float[3] outer_scope_input)
+                => (loop_output)
+            {
+                loop_output = Loop (max_trip_count, cond_orig) <
+                    body = subgraph (int64[1] iter_num_in, cond_in) => (cond_out, float[3] output) {
+                        cond_out = Identity(cond_in)
+                        output = Identity(outer_scope_input)
+                    }
+                >
+            }
+        """)
+
+        self._assert_inferred(
+            graph, [make_tensor_value_info("loop_output", TensorProto.FLOAT, (None, 3))]
+        )
+
+    def test_loop_with_constant_trip_count_and_early_exit(self) -> None:
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: ["" : 13]>
+            test () => ()
+               <int64 max_trip_count = {5}, bool cond_orig = {1}, float[3] outer_scope_input = {1, 2, 3}>
+            {
+               loop_output = Loop (max_trip_count, cond_orig) <body: graph = subgraph (int64 iter_num_in, bool cond_in) => (bool cond_out, float[3] output) {
+                  cond_out = Constant <value: tensor = bool cond_out_value {0}> ()
+                  output = Identity (outer_scope_input)
+               }>
+            }
+            """
+        )
+        inferred_model = self._inferred(model, data_prop=True)
+        loop_output = next(
+            value_info
+            for value_info in inferred_model.graph.value_info
+            if value_info.name == "loop_output"
+        )
+        first_dim = loop_output.type.tensor_type.shape.dim[0]
+        assert not (first_dim.HasField("dim_value") and first_dim.dim_value == 5)
+        assert loop_output.type.tensor_type.shape.dim[1].dim_value == 3
+
+    def test_constantofshape_with_input_shape(self) -> None:
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["shape"],
+                    value=make_tensor("shape", TensorProto.INT64, (3,), (3, 4, 5)),
+                ),
+                make_node(
+                    "ConstantOfShape",
+                    ["shape"],
+                    ["y"],
+                    value=make_tensor("value", TensorProto.INT32, (1,), (2,)),
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, (3,)),
+                make_tensor_value_info("y", TensorProto.INT32, (3, 4, 5)),
+            ],
+        )
+
+    def test_constantofshape_without_input_shape(self) -> None:
+        graph = self._make_graph(
+            [("shape", TensorProto.INT64, (3,))],
+            [
+                make_node(
+                    "ConstantOfShape",
+                    ["shape"],
+                    ["y"],
+                    value=make_tensor("value", TensorProto.UINT8, (1,), (2,)),
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, (None, None, None))]
+        )
+
+    def test_constantofshape_without_input_shape_scalar(self) -> None:
+        graph = self._make_graph(
+            [("shape", TensorProto.INT64, (0,))],
+            [
+                make_node(
+                    "ConstantOfShape",
+                    ["shape"],
+                    ["y"],
+                    value=make_tensor("value", TensorProto.UINT8, (1,), (2,)),
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, ())]
+        )
+
+    def test_constantofshape_with_shape_zero(self) -> None:
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["shape"],
+                    value=make_tensor("shape", TensorProto.INT64, (1,), (0,)),
+                ),
+                make_node(
+                    "ConstantOfShape",
+                    ["shape"],
+                    ["y"],
+                    value=make_tensor("value", TensorProto.INT32, (1,), (2,)),
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, (1,)),
+                make_tensor_value_info("y", TensorProto.INT32, (0,)),
+            ],
+        )
+
+    def test_convinteger(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (3, 4, 5, 6, 7)),
+                ("y", TensorProto.UINT8, (5, 4, 2, 4, 3)),
+            ],
+            [
+                make_node(
+                    "ConvInteger",
+                    ["x", "y"],
+                    "z",
+                    pads=[0, 1, 1, 0, 0, 1],
+                    dilations=[1, 2, 2],
+                    strides=[1, 1, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.INT32, (3, 5, 4, 1, 3))]
+        )
+
+    def test_convinetger_dilations(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (30, 4, 8, 8, 8)),
+                ("y", TensorProto.INT8, (50, 4, 3, 3, 3)),
+                ("x_zero_point", TensorProto.UINT8, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "ConvInteger",
+                    ["x", "y", "x_zero_point", "y_zero_point"],
+                    "z",
+                    dilations=[1, 2, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.INT32, (30, 50, 6, 4, 2))]
+        )
+
+    def test_convinteger_strides(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT8, (30, 4, 8, 8, 8)),
+                ("y", TensorProto.INT8, (50, 4, 3, 3, 3)),
+                ("x_zero_point", TensorProto.UINT8, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "ConvInteger",
+                    ["x", "y", "x_zero_point", "y_zero_point"],
+                    "z",
+                    strides=[1, 2, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.INT32, (30, 50, 6, 3, 2))]
+        )
+
+    def test_convineteger_pads(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (30, 4, 7, 6, 4)),
+                ("y", TensorProto.INT8, (50, 4, 3, 3, 3)),
+            ],
+            [make_node("ConvInteger", ["x", "y"], "z", pads=[1, 1, 2, 0, 1, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.INT32, (30, 50, 6, 6, 6))]
+        )
+
+    def test_convineteger_group(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT8, (30, 4, 8, 8, 8)),
+                ("y", TensorProto.INT8, (4, 1, 8, 8, 8)),
+            ],
+            [make_node("ConvInteger", ["x", "y"], "z", group=4)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.INT32, (30, 4, 1, 1, 1))]
+        )
+
+    def test_convineteger_partial_missing_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (30, 4, None, 6, 4)),
+                ("y", TensorProto.UINT8, (50, 4, 3, 3, 3)),
+                ("x_zero_point", TensorProto.UINT8, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "ConvInteger",
+                    ["x", "y", "x_zero_point", "y_zero_point"],
+                    "z",
+                    pads=[1, 1, 2, 0, 1, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.INT32, (30, 50, None, 6, 6))],
+        )
+
+    def test_convineteger_partial_missing_weight_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (30, 4, 7, 6, 4)),
+                ("y", TensorProto.UINT8, (50, 4, None, 3, 3)),
+            ],
+            [make_node("ConvInteger", ["x", "y"], "z", pads=[1, 1, 2, 0, 1, 2])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.INT32, None)]
+        )
+
+    def test_qlinearconv(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (3, 4, 5, 6, 7)),
+                ("x_scale", TensorProto.FLOAT, ()),
+                ("x_zero_point", TensorProto.UINT8, ()),
+                ("w", TensorProto.UINT8, (5, 4, 2, 4, 3)),
+                ("w_scale", TensorProto.FLOAT, ()),
+                ("w_zero_point", TensorProto.UINT8, ()),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "QLinearConv",
+                    [
+                        "x",
+                        "x_scale",
+                        "x_zero_point",
+                        "w",
+                        "w_scale",
+                        "w_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    "y",
+                    pads=[0, 1, 1, 0, 0, 1],
+                    dilations=[1, 2, 2],
+                    strides=[1, 1, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, (3, 5, 4, 1, 3))]
+        )
+
+    def test_qlinearconv_dilations(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (30, 4, 8, 8, 8)),
+                ("x_scale", TensorProto.FLOAT, ()),
+                ("x_zero_point", TensorProto.UINT8, ()),
+                ("w", TensorProto.UINT8, (50, 4, 3, 3, 3)),
+                ("w_scale", TensorProto.FLOAT, ()),
+                ("w_zero_point", TensorProto.UINT8, ()),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "QLinearConv",
+                    [
+                        "x",
+                        "x_scale",
+                        "x_zero_point",
+                        "w",
+                        "w_scale",
+                        "w_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    "y",
+                    dilations=[1, 2, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, (30, 50, 6, 4, 2))]
+        )
+
+    def test_qlinearconv_strides(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT8, (30, 4, 8, 8, 8)),
+                ("x_scale", TensorProto.FLOAT, ()),
+                ("x_zero_point", TensorProto.INT8, ()),
+                ("w", TensorProto.INT8, (50, 4, 3, 3, 3)),
+                ("w_scale", TensorProto.FLOAT, ()),
+                ("w_zero_point", TensorProto.INT8, ()),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.INT8, ()),
+            ],
+            [
+                make_node(
+                    "QLinearConv",
+                    [
+                        "x",
+                        "x_scale",
+                        "x_zero_point",
+                        "w",
+                        "w_scale",
+                        "w_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    "y",
+                    strides=[1, 2, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT8, (30, 50, 6, 3, 2))]
+        )
+
+    def test_qlinearconv_pads(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (30, 4, 7, 6, 4)),
+                ("x_scale", TensorProto.FLOAT, ()),
+                ("x_zero_point", TensorProto.UINT8, ()),
+                ("w", TensorProto.INT8, (50, 4, 3, 3, 3)),
+                ("w_scale", TensorProto.FLOAT, ()),
+                ("w_zero_point", TensorProto.INT8, ()),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "QLinearConv",
+                    [
+                        "x",
+                        "x_scale",
+                        "x_zero_point",
+                        "w",
+                        "w_scale",
+                        "w_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    "y",
+                    pads=[1, 1, 2, 0, 1, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, (30, 50, 6, 6, 6))]
+        )
+
+    def test_qlinearconv_group(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT8, (30, 4, 8, 8, 8)),
+                ("x_scale", TensorProto.FLOAT, ()),
+                ("x_zero_point", TensorProto.INT8, ()),
+                ("w", TensorProto.INT8, (4, 1, 8, 8, 8)),
+                ("w_scale", TensorProto.FLOAT, ()),
+                ("w_zero_point", TensorProto.INT8, ()),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.INT8, ()),
+            ],
+            [
+                make_node(
+                    "QLinearConv",
+                    [
+                        "x",
+                        "x_scale",
+                        "x_zero_point",
+                        "w",
+                        "w_scale",
+                        "w_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    "y",
+                    group=4,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT8, (30, 4, 1, 1, 1))]
+        )
+
+    def test_qlinearconv_partial_missing_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (30, 4, None, 6, 4)),
+                ("x_scale", TensorProto.FLOAT, ()),
+                ("x_zero_point", TensorProto.UINT8, ()),
+                ("w", TensorProto.UINT8, (50, 4, 3, 3, 3)),
+                ("w_scale", TensorProto.FLOAT, ()),
+                ("w_zero_point", TensorProto.UINT8, ()),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "QLinearConv",
+                    [
+                        "x",
+                        "x_scale",
+                        "x_zero_point",
+                        "w",
+                        "w_scale",
+                        "w_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    "y",
+                    pads=[1, 1, 2, 0, 1, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.UINT8, (30, 50, None, 6, 6))],
+        )
+
+    def test_qlinearconv_partial_missing_weight_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (30, 4, 7, 6, 4)),
+                ("x_scale", TensorProto.FLOAT, ()),
+                ("x_zero_point", TensorProto.UINT8, ()),
+                ("w", TensorProto.UINT8, (50, 4, None, 3, 3)),
+                ("w_scale", TensorProto.FLOAT, ()),
+                ("w_zero_point", TensorProto.UINT8, ()),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "QLinearConv",
+                    [
+                        "x",
+                        "x_scale",
+                        "x_zero_point",
+                        "w",
+                        "w_scale",
+                        "w_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    "y",
+                    pads=[1, 1, 2, 0, 1, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, None)]
+        )
+
+    def _make_qlinearmatmul_test(
+        self, shape1: Sequence[int], shape2: Sequence[int]
+    ) -> None:
+        expected_out_shape = np.matmul(
+            np.arange(np.prod(shape1)).reshape(shape1),
+            np.arange(np.prod(shape2)).reshape(shape2),
+        ).shape
+        graph = self._make_graph(
+            [
+                ("a", TensorProto.UINT8, shape1),
+                ("a_scale", TensorProto.FLOAT, ()),
+                ("a_zero_point", TensorProto.UINT8, ()),
+                ("b", TensorProto.UINT8, shape2),
+                ("b_scale", TensorProto.FLOAT, ()),
+                ("b_zero_point", TensorProto.UINT8, ()),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "QLinearMatMul",
+                    [
+                        "a",
+                        "a_scale",
+                        "a_zero_point",
+                        "b",
+                        "b_scale",
+                        "b_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    ["y"],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, expected_out_shape)]
+        )
+
+    def test_qlinearmatmul(self) -> None:
+        self._make_qlinearmatmul_test((3,), (3,))
+        self._make_qlinearmatmul_test((4, 2), (2, 4))
+        self._make_qlinearmatmul_test((2,), (2, 3))
+        self._make_qlinearmatmul_test((4, 2), (2,))
+        self._make_qlinearmatmul_test((5, 1, 4, 2), (1, 3, 2, 3))
+        self._make_qlinearmatmul_test((4, 2), (3, 2, 3))
+
+    def _make_qlinearmatmul_test_allow_unknown(
+        self, shape1: Any, shape2: Any, expected_out_shape: Any
+    ) -> None:
+        graph = self._make_graph(
+            [
+                ("a", TensorProto.UINT8, shape1),
+                ("a_scale", TensorProto.FLOAT, ()),
+                ("a_zero_point", TensorProto.UINT8, ()),
+                ("b", TensorProto.UINT8, shape2),
+                ("b_scale", TensorProto.FLOAT, ()),
+                ("b_zero_point", TensorProto.UINT8, ()),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "QLinearMatMul",
+                    [
+                        "a",
+                        "a_scale",
+                        "a_zero_point",
+                        "b",
+                        "b_scale",
+                        "b_zero_point",
+                        "y_scale",
+                        "y_zero_point",
+                    ],
+                    ["y"],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, expected_out_shape)]
+        )
+
+    def test_qlinearmatmul_allow_unknown(self) -> None:
+        self._make_qlinearmatmul_test_allow_unknown((None,), (None,), ())
+        self._make_qlinearmatmul_test_allow_unknown((3,), (None,), ())
+        self._make_qlinearmatmul_test_allow_unknown((2,), (2, "a"), ("a",))
+        self._make_qlinearmatmul_test_allow_unknown((4, 2), (2, "a"), (4, "a"))
+        self._make_qlinearmatmul_test_allow_unknown((4, None), (2, "a"), (4, "a"))
+        self._make_qlinearmatmul_test_allow_unknown((4, None), (None, "a"), (4, "a"))
+        self._make_qlinearmatmul_test_allow_unknown((1, 4, 2), ("a", 2, 5), ("a", 4, 5))
+        self._make_qlinearmatmul_test_allow_unknown(
+            (1, 3, 4, 2), ("a", 2, 5), (1, 3, 4, 5)
+        )
+        self._make_qlinearmatmul_test_allow_unknown(None, ("a", 2, 5), None)
+        self._make_qlinearmatmul_test_allow_unknown(None, None, None)
+
+    def _make_matmulinteger_test(
+        self, shape1: Sequence[int], shape2: Sequence[int]
+    ) -> None:
+        expected_out_shape = np.matmul(
+            np.arange(np.prod(shape1)).reshape(shape1),
+            np.arange(np.prod(shape2)).reshape(shape2),
+        ).shape
+        graph = self._make_graph(
+            [
+                ("A", TensorProto.UINT8, shape1),
+                ("B", TensorProto.UINT8, shape2),
+                ("a_zero_point", TensorProto.UINT8, ()),
+                ("b_zero_point", TensorProto.UINT8, ()),
+            ],
+            [
+                make_node(
+                    "MatMulInteger", ["A", "B", "a_zero_point", "b_zero_point"], ["Y"]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.INT32, expected_out_shape)]
+        )
+
+    def test_matmulinteger(self) -> None:
+        self._make_matmulinteger_test((2,), (2,))
+        self._make_matmulinteger_test((1, 2), (2, 3))
+        self._make_matmulinteger_test((2,), (2, 3))
+        self._make_matmulinteger_test((4, 2), (2,))
+        self._make_matmulinteger_test((5, 1, 4, 2), (1, 3, 2, 3))
+        self._make_matmulinteger_test((4, 2), (3, 2, 3))
+
+    @pytest.mark.parametrize(
+        "elem_type",
+        [onnx.TensorProto.FLOAT, onnx.TensorProto.FLOAT16, onnx.TensorProto.BFLOAT16],
+    )
+    def test_quantizelinear(self, elem_type) -> None:
+        graph = self._make_graph(
+            [
+                ("x", elem_type, (30, 4, 5)),
+                ("y_scale", elem_type, ()),
+                ("y_zero_point", TensorProto.UINT8, ()),
+            ],
+            [make_node("QuantizeLinear", ["x", "y_scale", "y_zero_point"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, (30, 4, 5))]
+        )
+
+    def test_quantizelinear_default_zp(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (30, 4, 5)), ("y_scale", TensorProto.FLOAT, ())],
+            [make_node("QuantizeLinear", ["x", "y_scale"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, (30, 4, 5))]
+        )
+
+    def test_quantizelinear_optional_input(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (30, 4, 5)), ("y_scale", TensorProto.FLOAT, ())],
+            [make_node("QuantizeLinear", ["x", "y_scale", ""], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, (30, 4, 5))]
+        )
+
+    def test_quantizelinear_output_dtype(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("y_scale", TensorProto.FLOAT, ())],
+            [
+                make_node(
+                    "QuantizeLinear",
+                    ["x", "y_scale"],
+                    ["y"],
+                    output_dtype=TensorProto.UINT4,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT4, (3, 4, 5))]
+        )
+
+    def test_quantizelinear_zp_output_dtype(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 4, 5)),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.UINT16, ()),
+            ],
+            [
+                make_node(
+                    "QuantizeLinear",
+                    ["x", "y_scale", "y_zero_point"],
+                    ["y"],
+                    output_dtype=TensorProto.UINT16,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT16, (3, 4, 5))]
+        )
+
+    def test_quantizelinear_zp_output_dtype_conflicted(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 4, 5)),
+                ("y_scale", TensorProto.FLOAT, ()),
+                ("y_zero_point", TensorProto.UINT16, ()),
+            ],
+            [
+                make_node(
+                    "QuantizeLinear",
+                    ["x", "y_scale", "y_zero_point"],
+                    ["y"],
+                    output_dtype=TensorProto.INT4,
+                )
+            ],
+            [],
+        )
+
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+            )
+
+    @pytest.mark.xfail(reason="Issue #5960")
+    def test_quantizelinear_invalid_output_dtype(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("y_scale", TensorProto.FLOAT, ())],
+            [
+                make_node(
+                    "QuantizeLinear",
+                    ["x", "y_scale"],
+                    ["y"],
+                    output_dtype=TensorProto.FLOAT16,
+                )
+            ],
+            [],
+        )
+
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+            )
+
+    @pytest.mark.parametrize(
+        "elem_type",
+        [onnx.TensorProto.FLOAT, onnx.TensorProto.FLOAT16, onnx.TensorProto.BFLOAT16],
+    )
+    def test_dequantizelinear(self, elem_type) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.UINT8, (30, 4, 5)),
+                ("x_scale", elem_type, ()),
+                ("x_zero_point", TensorProto.UINT8, ()),
+            ],
+            [make_node("DequantizeLinear", ["x", "x_scale", "x_zero_point"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", elem_type, (30, 4, 5))]
+        )
+
+    def test_dynamicquantizelinear(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (30, 4, 5))],
+            [
+                make_node(
+                    "DynamicQuantizeLinear", ["x"], ["y", "y_scale", "y_zero_point"]
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.UINT8, (30, 4, 5)),
+                make_tensor_value_info("y_scale", TensorProto.FLOAT, ()),
+                make_tensor_value_info("y_zero_point", TensorProto.UINT8, ()),
+            ],
+        )
+
+    def test_reversesequence(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (4, 5, 6)),
+                ("sequence_lens", TensorProto.INT64, (5,)),
+            ],
+            [make_node("ReverseSequence", ["x", "sequence_lens"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (4, 5, 6))]
+        )
+
+    def test_unique_without_axis(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 4, 2))],
+            [make_node("Unique", ["X"], ["Y", "indices", "inverse_indices", "counts"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("Y", TensorProto.FLOAT, (None,)),
+                make_tensor_value_info("indices", TensorProto.INT64, (None,)),
+                make_tensor_value_info("inverse_indices", TensorProto.INT64, (None,)),
+                make_tensor_value_info("counts", TensorProto.INT64, (None,)),
+            ],
+        )
+
+    def test_unique_with_axis(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (2, 4, 2))],
+            [
+                make_node(
+                    "Unique",
+                    ["X"],
+                    ["Y", "indices", "inverse_indices", "counts"],
+                    axis=1,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("Y", TensorProto.FLOAT, (2, None, 2)),
+                make_tensor_value_info("indices", TensorProto.INT64, (None,)),
+                make_tensor_value_info("inverse_indices", TensorProto.INT64, (None,)),
+                make_tensor_value_info("counts", TensorProto.INT64, (None,)),
+            ],
+        )
+
+    def test_det(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (3, 3))], [make_node("Det", ["X"], ["Y"])], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, ())]
+        )
+
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (4, 5, 6, 7, 7))],
+            [make_node("Det", ["X"], ["Y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (4, 5, 6))]
+        )
+
+    def test_tile(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5, 6)), ("repeats", TensorProto.INT64, (3,))],
+            [make_node("Tile", ["x", "repeats"], ["y"])],
+            [],
+            initializer=[make_tensor("repeats", TensorProto.INT64, (3,), (1, 2, 3))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (4, 10, 18))]
+        )
+
+    def test_tile_raw_input_data(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5, 6)), ("repeats", TensorProto.INT64, (3,))],
+            [make_node("Tile", ["x", "repeats"], ["y"])],
+            [],
+            initializer=[
+                make_tensor(
+                    "repeats",
+                    TensorProto.INT64,
+                    (3,),
+                    vals=np.array([1, 2, 3], dtype="<i8").tobytes(),
+                    raw=True,
+                )
+            ],
+        )  # Feed raw bytes (force little endian ordering like onnx standard) for test purpose
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (4, 10, 18))]
+        )
+
+    def test_tile_rank_inference(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5, 6)), ("repeats", TensorProto.INT64, (3,))],
+            [make_node("Tile", ["x", "repeats"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (None, None, None))]
+        )
+
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_linearclassifier_1D_input(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (5,))],
+            [
+                make_node(
+                    "LinearClassifier",
+                    ["x"],
+                    ["y", "z"],
+                    domain=ONNX_ML_DOMAIN,
+                    coefficients=[0.0008, -0.0008],
+                    intercepts=[2.0, 2.0],
+                    classlabels_ints=[1, 2],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.INT64, (1,)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (1, 2)),
+            ],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 1),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_linearclassifier_2D_input(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5))],
+            [
+                make_node(
+                    "LinearClassifier",
+                    ["x"],
+                    ["y", "z"],
+                    domain=ONNX_ML_DOMAIN,
+                    coefficients=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
+                    intercepts=[2.0, 2.0, 3.0],
+                    classlabels_ints=[1, 2, 3],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.INT64, (4,)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (4, 3)),
+            ],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 1),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+    def test_roialign_symbolic(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ("N", "C", "H", "W")),
+                ("rois", TensorProto.FLOAT, ("num_rois", 4)),
+                ("batch_indices", TensorProto.INT64, ("num_rois",)),
+            ],
+            [
+                make_node(
+                    "RoiAlign",
+                    ["x", "rois", "batch_indices"],
+                    ["y"],
+                    output_height=10,
+                    output_width=5,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, ("num_rois", "C", 10, 5))],
+        )
+
+    def test_roialign_symbolic_defaults(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ("N", "C", "H", "W")),
+                ("rois", TensorProto.FLOAT, ("num_rois", 4)),
+                ("batch_indices", TensorProto.INT64, ("num_rois",)),
+            ],
+            [make_node("RoiAlign", ["x", "rois", "batch_indices"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, ("num_rois", "C", 1, 1))],
+        )
+
+    def test_roialign_num_rois(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ("N", "C", "H", "W")),
+                ("rois", TensorProto.FLOAT, ("num_rois", 4)),
+                ("batch_indices", TensorProto.INT64, (15,)),
+            ],
+            [make_node("RoiAlign", ["x", "rois", "batch_indices"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (15, "C", 1, 1))]
+        )
+
+    def test_rotaryembedding_4d(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, ("B", "num_heads", "seq_len", "head_size")),
+                ("cos_cache", TensorProto.FLOAT, ("max_seq_len", "head_size_div_2")),
+                ("sin_cache", TensorProto.FLOAT, ("max_seq_len", "head_size_div_2")),
+                ("position_ids", TensorProto.INT64, ("B", "seq_len")),
+            ],
+            [
+                make_node(
+                    "RotaryEmbedding",
+                    ["X", "cos_cache", "sin_cache", "position_ids"],
+                    ["Y"],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "Y", TensorProto.FLOAT, ("B", "num_heads", "seq_len", "head_size")
+                )
+            ],
+        )
+
+    def test_rotaryembedding_3d(self) -> None:
+        graph = self._make_graph(
+            [
+                ("X", TensorProto.FLOAT, ("B", "seq_len", "hidden_size")),
+                ("cos_cache", TensorProto.FLOAT, ("max_seq_len", "head_size_div_2")),
+                ("sin_cache", TensorProto.FLOAT, ("max_seq_len", "head_size_div_2")),
+                ("position_ids", TensorProto.INT64, ("B", "seq_len")),
+            ],
+            [
+                make_node(
+                    "RotaryEmbedding",
+                    ["X", "cos_cache", "sin_cache", "position_ids"],
+                    ["Y"],
+                    num_heads=4,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "Y", TensorProto.FLOAT, ("B", "seq_len", "hidden_size")
+                )
+            ],
+        )
+
+    @pytest.mark.parametrize(
+        "version",
+        all_versions_for("LabelEncoder") if ONNX_ML else [],
+    )
+    def test_label_encoder_string_int64(self, version) -> None:
+        self.skipIf(
+            version < 2, "keys_* attributes were introduced in ai.onnx.ml opset 2"
+        )
+        string_list = ["A", "m", "y"]
+        float_list = [94.17, 36.00, -99.0]
+        int64_list = [12, 28, 86]
+        graph = self._make_graph(
+            [("x", TensorProto.STRING, (6, 1))],
+            [
+                make_node(
+                    "LabelEncoder",
+                    ["x"],
+                    ["y"],
+                    domain=ONNX_ML_DOMAIN,
+                    keys_strings=string_list,
+                    values_int64s=int64_list,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (6, 1))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, version),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+        graph = self._make_graph(
+            [("x", TensorProto.INT64, (2, 3))],
+            [
+                make_node(
+                    "LabelEncoder",
+                    ["x"],
+                    ["y"],
+                    domain=ONNX_ML_DOMAIN,
+                    keys_int64s=int64_list,
+                    values_strings=string_list,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.STRING, (2, 3))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, version),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2,))],
+            [
+                make_node(
+                    "LabelEncoder",
+                    ["x"],
+                    ["y"],
+                    domain=ONNX_ML_DOMAIN,
+                    keys_floats=float_list,
+                    values_int64s=int64_list,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (2,))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, version),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+        graph = self._make_graph(
+            [("x", TensorProto.INT64, (8,))],
+            [
+                make_node(
+                    "LabelEncoder",
+                    ["x"],
+                    ["y"],
+                    domain=ONNX_ML_DOMAIN,
+                    keys_int64s=int64_list,
+                    values_floats=float_list,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (8,))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, version),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ())],
+            [
+                make_node(
+                    "LabelEncoder",
+                    ["x"],
+                    ["y"],
+                    domain=ONNX_ML_DOMAIN,
+                    keys_floats=float_list,
+                    values_strings=string_list,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.STRING, ())],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, version),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+        graph = self._make_graph(
+            [("x", TensorProto.STRING, (1, 2))],
+            [
+                make_node(
+                    "LabelEncoder",
+                    ["x"],
+                    ["y"],
+                    domain=ONNX_ML_DOMAIN,
+                    keys_strings=string_list,
+                    values_floats=float_list,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (1, 2))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, version),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+    @pytest.mark.parametrize(
+        "version", all_versions_for("LabelEncoder") if ONNX_ML else []
+    )
+    def test_label_encoder_tensor_attributes(self, version) -> None:
+        self.skipIf(
+            version < 4, "tensor attributes were introduced in ai.onnx.ml opset 4"
+        )
+        key_tensor = make_tensor(
+            "keys_tensor", TensorProto.STRING, [4], ["a", "b", "cc", "ddd"]
+        )
+        values_tensor = make_tensor(
+            "values_tensor", TensorProto.INT64, [4], [1, 2, 3, 4]
+        )
+        graph = self._make_graph(
+            [("x", TensorProto.STRING, ("M", None, 3, 12))],
+            [
+                make_node(
+                    "LabelEncoder",
+                    ["x"],
+                    ["y"],
+                    domain=ONNX_ML_DOMAIN,
+                    keys_tensor=key_tensor,
+                    values_tensor=values_tensor,
+                    default_tensor=make_tensor(
+                        "default_tensor", TensorProto.INT64, [1], [0]
+                    ),
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, ("M", None, 3, 12))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, version),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+    @pytest.mark.parametrize(
+        "version", all_versions_for("LabelEncoder") if ONNX_ML else []
+    )
+    def test_label_encoder_tensor_attributes_invalid_configurations(
+        self, version
+    ) -> None:
+        self.skipIf(version < 4, "tensor attributes introduced in ai.onnx.ml opset 4")
+        key_tensor = make_tensor(
+            "keys_tensor", TensorProto.STRING, [4], ["a", "b", "cc", "ddd"]
+        )
+        values_tensor = make_tensor(
+            "values_tensor", TensorProto.INT64, [4], [1, 2, 3, 4]
+        )
+
+        opset_imports = [
+            make_opsetid(ONNX_ML_DOMAIN, version),
+            make_opsetid(ONNX_DOMAIN, 11),
+        ]
+
+        # default_tensor should be INT64, same type as values_tensor
+        graph = self._make_graph(
+            [("x", TensorProto.STRING, ("M", None, 3, 12))],
+            [
+                make_node(
+                    "LabelEncoder",
+                    ["x"],
+                    ["y"],
+                    domain=ONNX_ML_DOMAIN,
+                    keys_tensor=key_tensor,
+                    values_tensor=values_tensor,
+                    default_tensor=make_tensor(
+                        "default_tensor", TensorProto.INT32, [1], [0]
+                    ),
+                )
+            ],
+            [],
+        )
+
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=opset_imports,
+            )
+
+        # default_tensor should be a singleton of shape (1,)
+        graph = self._make_graph(
+            [("x", TensorProto.STRING, ("M", None, 3, 12))],
+            [
+                make_node(
+                    "LabelEncoder",
+                    ["x"],
+                    ["y"],
+                    domain=ONNX_ML_DOMAIN,
+                    keys_tensor=key_tensor,
+                    values_strings=["a", "b", "cc", "ddd"],
+                    default_tensor=make_tensor(
+                        "default_tensor", TensorProto.STRING, [1, 2], ["a", "b"]
+                    ),
+                )
+            ],
+            [],
+        )
+
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=opset_imports,
+            )
+
+    def make_sparse(
+        self,
+        shape: Sequence[int],
+        values: Sequence[int],
+        indices_shape: Sequence[int],
+        indices: Sequence[int],
+    ) -> SparseTensorProto:
+        sparse = SparseTensorProto()
+        sparse.dims.extend(shape)
+        nnz = len(values)
+        sparse.values.CopyFrom(
+            helper.make_tensor("spval", TensorProto.INT64, (nnz,), values)
+        )
+        sparse.indices.CopyFrom(
+            helper.make_tensor("spind", TensorProto.INT64, indices_shape, indices)
+        )
+        return sparse
+
+    def test_constant_sparse(self) -> None:
+        y_shape = [100]
+        y_value = self.make_sparse(y_shape, [13, 17, 19], [3], [9, 27, 81])
+        graph = self._make_graph(
+            [], [make_node("Constant", [], ["y"], sparse_value=y_value)], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, y_shape)]
+        )
+
+    def test_constant_value_int(self) -> None:
+        graph = self._make_graph(
+            [], [make_node("Constant", [], ["y"], value_int=42)], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, [])]
+        )
+
+    def test_constant_value_ints(self) -> None:
+        value_ints = [1, 2, 3]
+        graph = self._make_graph(
+            [], [make_node("Constant", [], ["y"], value_ints=value_ints)], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, [len(value_ints)])]
+        )
+
+    def test_constant_value_float(self) -> None:
+        graph = self._make_graph(
+            [], [make_node("Constant", [], ["y"], value_float=1.42)], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, [])]
+        )
+
+    def test_constant_value_floats(self) -> None:
+        value_floats = [1.0, 1.1, 1.2]
+        graph = self._make_graph(
+            [], [make_node("Constant", [], ["y"], value_floats=value_floats)], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, [len(value_floats)])]
+        )
+
+    def test_constant_value_string(self) -> None:
+        graph = self._make_graph(
+            [], [make_node("Constant", [], ["y"], value_string="String value")], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.STRING, [])]
+        )
+
+    def test_constant_value_strings(self) -> None:
+        value_strings = ["o", "n", "n", "x"]
+        graph = self._make_graph(
+            [], [make_node("Constant", [], ["y"], value_strings=value_strings)], []
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.STRING, [len(value_strings)])],
+        )
+
+    def test_range(self) -> None:
+        graph = self._make_graph(
+            [
+                ("start", TensorProto.FLOAT, ()),
+                ("limit", TensorProto.FLOAT, ()),
+                ("delta", TensorProto.FLOAT, ()),
+            ],
+            [make_node("Range", ["start", "limit", "delta"], ["output"])],
+            [],
+            initializer=[
+                make_tensor("start", TensorProto.FLOAT, (), (1,)),
+                make_tensor("limit", TensorProto.FLOAT, (), (5,)),
+                make_tensor("delta", TensorProto.FLOAT, (), (2,)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("output", TensorProto.FLOAT, (2,))]
+        )
+
+    def test_range_initializer_invalid(self) -> None:
+        # Create a TensorProto with incorrect data type for `delta`.
+        # This should lead to an error when ParseData is called during shape inferencing
+        # as the expected float data is missing.
+        bad_tensor = TensorProto()
+        bad_tensor.name = "delta"
+        bad_tensor.data_type = TensorProto.FLOAT
+        bad_tensor.int64_data.extend([2])  # incorrect data type
+
+        graph = self._make_graph(
+            [
+                ("start", TensorProto.FLOAT, ()),
+                ("limit", TensorProto.FLOAT, ()),
+                ("delta", TensorProto.FLOAT, ()),
+            ],
+            [make_node("Range", ["start", "limit", "delta"], ["output"])],
+            [],
+            initializer=[
+                make_tensor("start", TensorProto.FLOAT, (), (1,)),
+                make_tensor("limit", TensorProto.FLOAT, (), (5,)),
+                bad_tensor,
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_range_initializer_invalid_rawdata(self) -> None:
+        # Create a TensorProto with empty raw data for `delta`.
+        # This should lead to an error when ParseData is called during shape inferencing
+        # as the expected raw data is missing.
+        bad_tensor = make_tensor(
+            "delta",
+            TensorProto.FLOAT,
+            (),
+            vals=np.array([1.0], dtype="<f4").tobytes(),
+            raw=True,
+        )
+        bad_tensor.raw_data = b""  # Clear raw data to simulate missing data
+
+        graph = self._make_graph(
+            [
+                ("start", TensorProto.FLOAT, ()),
+                ("limit", TensorProto.FLOAT, ()),
+                ("delta", TensorProto.FLOAT, ()),
+            ],
+            [make_node("Range", ["start", "limit", "delta"], ["output"])],
+            [],
+            initializer=[
+                make_tensor("start", TensorProto.FLOAT, (), (1,)),
+                make_tensor("limit", TensorProto.FLOAT, (), (5,)),
+                bad_tensor,
+            ],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_range_rank_inference(self) -> None:
+        graph = self._make_graph(
+            [
+                ("start", TensorProto.INT32, ()),
+                ("limit", TensorProto.INT32, ()),
+                ("delta", TensorProto.INT32, ()),
+            ],
+            [make_node("Range", ["start", "limit", "delta"], ["output"])],
+            [],
+            initializer=[
+                make_tensor("start", TensorProto.INT32, (), (1,)),
+                make_tensor("limit", TensorProto.INT32, (), (5,)),
+            ],
+        )  # Missing 'delta' initializer
+        self._assert_inferred(
+            graph, [make_tensor_value_info("output", TensorProto.INT32, (None,))]
+        )
+
+    def test_range_float16(self) -> None:
+        graph = self._make_graph(
+            [
+                ("start", TensorProto.FLOAT16, ()),
+                ("limit", TensorProto.FLOAT16, ()),
+                ("delta", TensorProto.FLOAT16, ()),
+            ],
+            [make_node("Range", ["start", "limit", "delta"], ["output"])],
+            [],
+            initializer=[
+                make_tensor("start", TensorProto.FLOAT16, (), (1,)),
+                make_tensor("limit", TensorProto.FLOAT16, (), (5,)),
+                make_tensor("delta", TensorProto.FLOAT16, (), (2,)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("output", TensorProto.FLOAT16, (None,))]
+        )
+
+    def test_range_bfloat16(self) -> None:
+        graph = self._make_graph(
+            [
+                ("start", TensorProto.BFLOAT16, ()),
+                ("limit", TensorProto.BFLOAT16, ()),
+                ("delta", TensorProto.BFLOAT16, ()),
+            ],
+            [make_node("Range", ["start", "limit", "delta"], ["output"])],
+            [],
+            initializer=[
+                make_tensor("start", TensorProto.BFLOAT16, (), (1,)),
+                make_tensor("limit", TensorProto.BFLOAT16, (), (5,)),
+                make_tensor("delta", TensorProto.BFLOAT16, (), (2,)),
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("output", TensorProto.BFLOAT16, (None,))]
+        )
+
+    def test_range_float16_rank_inference(self) -> None:
+        graph = self._make_graph(
+            [
+                ("start", TensorProto.FLOAT16, ()),
+                ("limit", TensorProto.FLOAT16, ()),
+                ("delta", TensorProto.FLOAT16, ()),
+            ],
+            [make_node("Range", ["start", "limit", "delta"], ["output"])],
+            [],
+            initializer=[
+                make_tensor("start", TensorProto.FLOAT16, (), (1,)),
+                make_tensor("limit", TensorProto.FLOAT16, (), (5,)),
+            ],
+        )  # Missing 'delta' initializer
+        self._assert_inferred(
+            graph, [make_tensor_value_info("output", TensorProto.FLOAT16, (None,))]
+        )
+
+    def test_range_bfloat16_rank_inference(self) -> None:
+        graph = self._make_graph(
+            [
+                ("start", TensorProto.BFLOAT16, ()),
+                ("limit", TensorProto.BFLOAT16, ()),
+                ("delta", TensorProto.BFLOAT16, ()),
+            ],
+            [make_node("Range", ["start", "limit", "delta"], ["output"])],
+            [],
+            initializer=[
+                make_tensor("start", TensorProto.BFLOAT16, (), (1,)),
+                make_tensor("limit", TensorProto.BFLOAT16, (), (5,)),
+            ],
+        )  # Missing 'delta' initializer
+        self._assert_inferred(
+            graph, [make_tensor_value_info("output", TensorProto.BFLOAT16, (None,))]
+        )
+
+    def test_gathernd(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (4, 5, 6)), ("indices", TensorProto.INT64, (2,))],
+            [make_node("GatherND", ["x", "indices"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (6,))]
+        )
+
+    def test_gathernd_batchdim_1(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (2, 2, 2)),
+                ("indices", TensorProto.INT64, (2, 1)),
+            ],
+            [make_node("GatherND", ["x", "indices"], ["y"], batch_dims=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (2, 2))]
+        )
+
+    def test_cumprod(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 2)), ("axis", TensorProto.FLOAT, (1,))],
+            [make_node("CumProd", ["x", "axis"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 2))]
+        )
+
+    def test_cumsum(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3)), ("axis", TensorProto.FLOAT, (1,))],
+            [make_node("CumSum", ["x", "axis"], "z")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 3))]
+        )
+
+    def test_nonmaxsuppression(self) -> None:
+        graph = self._make_graph(
+            [
+                ("boxes", TensorProto.FLOAT, (1, 3, 4)),
+                ("scores", TensorProto.FLOAT, (1, 5, 3)),
+            ],
+            [make_node("NonMaxSuppression", ["boxes", "scores"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, (None, 3))]
+        )
+
+    def test_sequence_empty(self) -> None:
+        graph = self._make_graph([], [make_node("SequenceEmpty", [], ["output"])], [])
+        self._assert_inferred(
+            graph, [make_tensor_sequence_value_info("output", TensorProto.FLOAT, None)]
+        )
+
+    def test_sequence_construct(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 4)),
+                ("input3", TensorProto.FLOAT, (2, 3, 4)),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct",
+                    ["input1", "input2", "input3"],
+                    ["output_sequence"],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (2, 3, 4)
+                )
+            ],
+        )
+
+    def test_sequence_construct_one_input(self) -> None:
+        graph = self._make_graph(
+            [("input1", TensorProto.FLOAT, (2, 3, 4))],
+            [make_node("SequenceConstruct", ["input1"], ["output_sequence"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (2, 3, 4)
+                )
+            ],
+        )
+
+    def test_sequence_construct_diff_rank(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3)),
+                ("input3", TensorProto.FLOAT, (2, 3)),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct",
+                    ["input1", "input2", "input3"],
+                    ["output_sequence"],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, None
+                )
+            ],
+        )
+
+    def test_sequence_construct_diff_dim_size(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 5)),
+                ("input3", TensorProto.FLOAT, (2, 3, 6)),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct",
+                    ["input1", "input2", "input3"],
+                    ["output_sequence"],
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (2, 3, None)
+                )
+            ],
+        )
+
+    def test_sequence_insert(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 4)),
+                ("input3", TensorProto.FLOAT, (2, 3, 4)),
+                ("input4", TensorProto.FLOAT, (2, 3, 4)),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node(
+                    "SequenceInsert", ["in_sequence", "input4"], ["output_sequence"]
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, 3, 4)
+                ),
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (2, 3, 4)
+                ),
+            ],
+        )
+
+    def test_sequence_insert_diff_rank(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 4)),
+                ("input3", TensorProto.FLOAT, (2, 3, 4)),
+                ("input4", TensorProto.FLOAT, (2, 3)),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node(
+                    "SequenceInsert", ["in_sequence", "input4"], ["output_sequence"]
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, 3, 4)
+                ),
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, None
+                ),
+            ],
+        )
+
+    def test_sequence_insert_diff_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 4)),
+                ("input3", TensorProto.FLOAT, (2, 5, 4)),
+                ("input4", TensorProto.FLOAT, (2, 5, 2)),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node(
+                    "SequenceInsert", ["in_sequence", "input4"], ["output_sequence"]
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, None, 4)
+                ),
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (2, None, None)
+                ),
+            ],
+        )
+
+    def test_sequence_at(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 4)),
+                ("input3", TensorProto.FLOAT, (2, 3, 4)),
+                ("ind", TensorProto.INT64, ()),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("SequenceAt", ["in_sequence", "ind"], ["output"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, 3, 4)
+                ),
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 4)),
+            ],
+        )
+
+    def test_sequence_at_unknown_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3)),
+                ("input3", TensorProto.FLOAT, (2, 3, 4)),
+                ("ind", TensorProto.INT64, ()),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("SequenceAt", ["in_sequence", "ind"], ["output"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info("in_sequence", TensorProto.FLOAT, None),
+                make_tensor_value_info("output", TensorProto.FLOAT, None),
+            ],
+        )
+
+    def test_sequence_at_unknown_dim_size(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 5)),
+                ("input3", TensorProto.FLOAT, (2, 3, 4)),
+                ("ind", TensorProto.INT64, ()),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("SequenceAt", ["in_sequence", "ind"], ["output"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, 3, None)
+                ),
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, None)),
+            ],
+        )
+
+    def test_sequence_erase(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, 4)),
+                ("input2", TensorProto.FLOAT, (2, 3, 4)),
+                ("input3", TensorProto.FLOAT, (2, 3, 4)),
+                ("ind", TensorProto.INT64, ()),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("SequenceErase", ["in_sequence", "ind"], ["output_sequence"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, 3, 4)
+                ),
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (2, 3, 4)
+                ),
+            ],
+        )
+
+    def test_sequence_erase_diff_dim_size(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, "x")),
+                ("input2", TensorProto.FLOAT, (2, 3, "x")),
+                ("input3", TensorProto.FLOAT, (2, 5, "x")),
+                ("ind", TensorProto.INT64, ()),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("SequenceErase", ["in_sequence", "ind"], ["output_sequence"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, None, "x")
+                ),
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (2, None, "x")
+                ),
+            ],
+        )
+
+    def test_sequence_length(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, "x")),
+                ("input2", TensorProto.FLOAT, (2, 3, "x")),
+                ("input3", TensorProto.FLOAT, (2, 3, "x")),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("SequenceLength", ["in_sequence"], ["len"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, 3, "x")
+                ),
+                make_tensor_value_info("len", TensorProto.INT64, ()),
+            ],
+        )
+
+    def test_split_to_sequence(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (6, 4)), ("split", TensorProto.INT32, (2,))],
+            [make_node("SplitToSequence", ["input", "split"], ["output_sequence"])],
+            [],
+            initializer=[make_tensor("split", TensorProto.INT32, (2,), (3, 3))],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (3, 4)
+                )
+            ],
+        )
+
+    def test_split_to_sequence_scalar(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (6, 4)), ("split", TensorProto.INT32, ())],
+            [make_node("SplitToSequence", ["input", "split"], ["output_sequence"])],
+            [],
+            initializer=[make_tensor("split", TensorProto.INT32, (), (2,))],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (2, 4)
+                )
+            ],
+        )
+
+    def test_split_to_sequence_keepdims(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (6, 4))],
+            [make_node("SplitToSequence", ["input"], ["output_sequence"], keepdims=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (1, 4)
+                )
+            ],
+        )
+
+    def test_split_to_sequence_not_keepdims(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (6, 4))],
+            [make_node("SplitToSequence", ["input"], ["output_sequence"], keepdims=0)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (4,)
+                )
+            ],
+        )
+
+    def test_split_to_sequence_ignore_keepdims(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (6, 4)), ("split", TensorProto.INT32, (2,))],
+            [
+                make_node(
+                    "SplitToSequence",
+                    ["input", "split"],
+                    ["output_sequence"],
+                    keepdims=0,
+                )
+            ],
+            [],
+            initializer=[make_tensor("split", TensorProto.INT32, (2,), (3, 3))],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (3, 4)
+                )
+            ],
+        )
+
+    def test_split_to_sequence_axis(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (6, 4))],
+            [make_node("SplitToSequence", ["input"], ["output_sequence"], axis=1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (6, 1)
+                )
+            ],
+        )
+
+    def test_split_to_sequence_neg_axis(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (6, 4))],
+            [make_node("SplitToSequence", ["input"], ["output_sequence"], axis=-2)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (1, 4)
+                )
+            ],
+        )
+
+    def test_split_to_sequence_split_sizes(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (6, 4)), ("split", TensorProto.INT32, (3,))],
+            [make_node("SplitToSequence", ["input", "split"], ["output_sequence"])],
+            [],
+            initializer=[make_tensor("split", TensorProto.INT32, (3,), (2, 1, 3))],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (None, 4)
+                )
+            ],
+        )
+
+    def test_split_to_sequence_non_divisible(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (6, 4)), ("split", TensorProto.INT32, ())],
+            [make_node("SplitToSequence", ["input", "split"], ["output_sequence"])],
+            [],
+            initializer=[make_tensor("split", TensorProto.INT32, (), (4,))],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "output_sequence", TensorProto.FLOAT, (None, 4)
+                )
+            ],
+        )
+
+    def test_concat_from_sequence(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, "x")),
+                ("input2", TensorProto.FLOAT, (2, 3, "x")),
+                ("input3", TensorProto.FLOAT, (2, 3, "x")),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("ConcatFromSequence", ["in_sequence"], ["out"], axis=0),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, 3, "x")
+                ),
+                make_tensor_value_info("out", TensorProto.FLOAT, (None, 3, "x")),
+            ],
+        )
+
+    def test_concat_from_sequence_unknown_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, "x")),
+                ("input2", TensorProto.FLOAT, (2, 3)),
+                ("input3", TensorProto.FLOAT, (2, 3, "x")),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("ConcatFromSequence", ["in_sequence"], ["out"], axis=0),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info("in_sequence", TensorProto.FLOAT, None),
+                make_tensor_value_info("out", TensorProto.FLOAT, None),
+            ],
+        )
+
+    def test_concat_from_sequence_unknown_dim_size(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, "x")),
+                ("input2", TensorProto.FLOAT, (2, 4, "x")),
+                ("input3", TensorProto.FLOAT, (2, 3, "x")),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("ConcatFromSequence", ["in_sequence"], ["out"], axis=0),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, None, "x")
+                ),
+                make_tensor_value_info("out", TensorProto.FLOAT, (None, None, "x")),
+            ],
+        )
+
+    def test_concat_from_sequence_axis(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, "x")),
+                ("input2", TensorProto.FLOAT, (2, 4, "x")),
+                ("input3", TensorProto.FLOAT, (2, 3, "x")),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("ConcatFromSequence", ["in_sequence"], ["out"], axis=2),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, None, "x")
+                ),
+                make_tensor_value_info("out", TensorProto.FLOAT, (2, None, None)),
+            ],
+        )
+
+    def test_concat_from_sequence_neg_axis(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, "x")),
+                ("input2", TensorProto.FLOAT, (2, 4, "x")),
+                ("input3", TensorProto.FLOAT, (2, 3, "x")),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node("ConcatFromSequence", ["in_sequence"], ["out"], axis=-3),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, None, "x")
+                ),
+                make_tensor_value_info("out", TensorProto.FLOAT, (None, None, "x")),
+            ],
+        )
+
+    def test_concat_from_sequence_new_axis(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, "x")),
+                ("input2", TensorProto.FLOAT, (2, 3, "x")),
+                ("input3", TensorProto.FLOAT, (2, 3, "x")),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node(
+                    "ConcatFromSequence", ["in_sequence"], ["out"], axis=2, new_axis=1
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, 3, "x")
+                ),
+                make_tensor_value_info("out", TensorProto.FLOAT, (2, 3, None, "x")),
+            ],
+        )
+
+    def test_concat_from_sequence_neg_new_axis(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input1", TensorProto.FLOAT, (2, 3, "x")),
+                ("input2", TensorProto.FLOAT, (2, 3, "x")),
+                ("input3", TensorProto.FLOAT, (2, 3, "x")),
+            ],
+            [
+                make_node(
+                    "SequenceConstruct", ["input1", "input2", "input3"], ["in_sequence"]
+                ),
+                make_node(
+                    "ConcatFromSequence", ["in_sequence"], ["out"], axis=-1, new_axis=1
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (2, 3, "x")
+                ),
+                make_tensor_value_info("out", TensorProto.FLOAT, (2, 3, "x", None)),
+            ],
+        )
+
+    def test_adagrad(self) -> None:
+        graph = self._make_graph(
+            [
+                ("R", TensorProto.FLOAT, ()),  # scalar's shape is ()
+                ("T", TensorProto.INT64, ()),  # scalar's shape is ()
+                ("X", TensorProto.FLOAT, (1, 2)),
+                ("G", TensorProto.FLOAT, (1, 2)),
+                ("H", TensorProto.FLOAT, (1, 2)),
+            ],
+            [
+                make_node(
+                    "Adagrad",
+                    ["R", "T", "X", "G", "H"],
+                    ["X_new", "H_new"],
+                    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+                )
+            ],
+            [],
+        )
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("X_new", TensorProto.FLOAT, (1, 2)),
+                make_tensor_value_info("H_new", TensorProto.FLOAT, (1, 2)),
+            ],
+            opset_imports=[
+                helper.make_opsetid(ONNX_DOMAIN, 12),
+                helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+            ],
+        )
+
+    def test_adagrad_multiple(self) -> None:
+        graph = self._make_graph(
+            [
+                ("R", TensorProto.FLOAT, ()),  # scalar's shape is ()
+                ("T", TensorProto.INT64, ()),  # scalar's shape is ()
+                ("X1", TensorProto.FLOAT, (1, 2)),
+                ("X2", TensorProto.FLOAT, (3, 4)),
+                ("G1", TensorProto.FLOAT, (1, 2)),
+                ("G2", TensorProto.FLOAT, (3, 4)),
+                ("H1", TensorProto.FLOAT, (1, 2)),
+                ("H2", TensorProto.FLOAT, (3, 4)),
+            ],
+            [
+                make_node(
+                    "Adagrad",
+                    ["R", "T", "X1", "X2", "G1", "G2", "H1", "H2"],
+                    ["X1_new", "X2_new", "H1_new", "H2_new"],
+                    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+                )
+            ],
+            [],
+        )
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("X1_new", TensorProto.FLOAT, (1, 2)),
+                make_tensor_value_info("X2_new", TensorProto.FLOAT, (3, 4)),
+                make_tensor_value_info("H1_new", TensorProto.FLOAT, (1, 2)),
+                make_tensor_value_info("H2_new", TensorProto.FLOAT, (3, 4)),
+            ],
+            opset_imports=[
+                helper.make_opsetid(ONNX_DOMAIN, 12),
+                helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+            ],
+        )
+
+    def test_momentum(self) -> None:
+        graph = self._make_graph(
+            [
+                ("R", TensorProto.FLOAT, ()),  # scalar's shape is ()
+                ("T", TensorProto.INT64, ()),  # scalar's shape is ()
+                ("X", TensorProto.FLOAT, (1, 2)),
+                ("G", TensorProto.FLOAT, (1, 2)),
+                ("V", TensorProto.FLOAT, (1, 2)),
+            ],
+            [
+                make_node(
+                    "Momentum",
+                    ["R", "T", "X", "G", "V"],
+                    ["X_new", "V_new"],
+                    alpha=0.9,
+                    beta=1.0,
+                    norm_coefficient=0.02,
+                    mode="standard",
+                    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("X_new", TensorProto.FLOAT, (1, 2)),
+                make_tensor_value_info("V_new", TensorProto.FLOAT, (1, 2)),
+            ],
+            opset_imports=[
+                helper.make_opsetid(ONNX_DOMAIN, 12),
+                helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+            ],
+        )
+
+    def test_momentum_multiple(self) -> None:
+        graph = self._make_graph(
+            [
+                ("R", TensorProto.FLOAT, ()),  # scalar's shape is ()
+                ("T", TensorProto.INT64, ()),  # scalar's shape is ()
+                ("X1", TensorProto.FLOAT, (1, 2)),
+                ("X2", TensorProto.FLOAT, (3, 4)),
+                ("G1", TensorProto.FLOAT, (1, 2)),
+                ("G2", TensorProto.FLOAT, (3, 4)),
+                ("V1", TensorProto.FLOAT, (1, 2)),
+                ("V2", TensorProto.FLOAT, (3, 4)),
+            ],
+            [
+                make_node(
+                    "Momentum",
+                    ["R", "T", "X1", "X2", "G1", "G2", "V1", "V2"],
+                    ["X1_new", "X2_new", "V1_new", "V2_new"],
+                    alpha=0.9,
+                    beta=1.0,
+                    norm_coefficient=0.02,
+                    mode="nesterov",
+                    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+                )
+            ],
+            [],
+        )
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("X1_new", TensorProto.FLOAT, (1, 2)),
+                make_tensor_value_info("X2_new", TensorProto.FLOAT, (3, 4)),
+                make_tensor_value_info("V1_new", TensorProto.FLOAT, (1, 2)),
+                make_tensor_value_info("V2_new", TensorProto.FLOAT, (3, 4)),
+            ],
+            opset_imports=[
+                helper.make_opsetid(ONNX_DOMAIN, 12),
+                helper.make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+            ],
+        )
+
+    def test_adam(self) -> None:
+        graph = self._make_graph(
+            [
+                ("R", TensorProto.FLOAT, ()),  # scalar's shape is ()
+                ("T", TensorProto.INT64, ()),  # scalar's shape is ()
+                ("X", TensorProto.FLOAT, (1, 2)),
+                ("G", TensorProto.FLOAT, (1, 2)),
+                ("V", TensorProto.FLOAT, (1, 2)),
+                ("H", TensorProto.FLOAT, (1, 2)),
+            ],
+            [
+                make_node(
+                    "Adam",
+                    ["R", "T", "X", "G", "V", "H"],
+                    ["X_new", "V_new", "H_new"],
+                    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+                    alpha=0.9,
+                    beta=1.0,
+                    norm_coefficient=0.02,
+                )
+            ],
+            [],
+        )
+
+        infos = [
+            make_tensor_value_info("X_new", TensorProto.FLOAT, (1, 2)),
+            make_tensor_value_info("V_new", TensorProto.FLOAT, (1, 2)),
+            make_tensor_value_info("H_new", TensorProto.FLOAT, (1, 2)),
+        ]
+
+        self._assert_inferred(
+            graph,
+            infos,
+            opset_imports=[
+                make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+                make_opsetid(ONNX_DOMAIN, 12),
+            ],
+        )
+
+    def test_adam_multiple(self) -> None:
+        graph = self._make_graph(
+            [
+                ("R", TensorProto.FLOAT, ()),  # scalar's shape is ()
+                ("T", TensorProto.INT64, ()),  # scalar's shape is ()
+                ("X1", TensorProto.FLOAT, (1, 2)),
+                ("X2", TensorProto.FLOAT, (3, 4)),
+                ("G1", TensorProto.FLOAT, (1, 2)),
+                ("G2", TensorProto.FLOAT, (3, 4)),
+                ("V1", TensorProto.FLOAT, (1, 2)),
+                ("V2", TensorProto.FLOAT, (3, 4)),
+                ("H1", TensorProto.FLOAT, (1, 2)),
+                ("H2", TensorProto.FLOAT, (3, 4)),
+            ],
+            [
+                make_node(
+                    "Adam",
+                    ["R", "T", "X1", "X2", "G1", "G2", "V1", "V2", "H1", "H2"],
+                    ["X1_new", "X2_new", "V1_new", "V2_new", "H1_new", "H2_new"],
+                    domain=AI_ONNX_PREVIEW_TRAINING_DOMAIN,
+                    alpha=0.9,
+                    beta=1.0,
+                    norm_coefficient=0.02,
+                )
+            ],
+            [],
+        )
+
+        infos = [
+            make_tensor_value_info("X1_new", TensorProto.FLOAT, (1, 2)),
+            make_tensor_value_info("X2_new", TensorProto.FLOAT, (3, 4)),
+            make_tensor_value_info("V1_new", TensorProto.FLOAT, (1, 2)),
+            make_tensor_value_info("V2_new", TensorProto.FLOAT, (3, 4)),
+            make_tensor_value_info("H1_new", TensorProto.FLOAT, (1, 2)),
+            make_tensor_value_info("H2_new", TensorProto.FLOAT, (3, 4)),
+        ]
+
+        self._assert_inferred(
+            graph,
+            infos,
+            opset_imports=[
+                make_opsetid(AI_ONNX_PREVIEW_TRAINING_DOMAIN, 1),
+                make_opsetid(ONNX_DOMAIN, 12),
+            ],
+        )
+
+    def test_pad_opset10(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (1, None, 2))],
+            [make_node("Pad", "x", "y", pads=[1, 3, 1, 1, 0, 1])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (3, None, 4))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 10)],
+        )
+
+    def test_constant_pad_2d_opset10(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 4, 4))],
+            [
+                make_node(
+                    "Pad",
+                    "x",
+                    "y",
+                    pads=[0, 0, 3, 1, 0, 0, 4, 2],
+                    mode="constant",
+                    value=2.0,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (2, 3, 11, 7))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 10)],
+        )
+
+    def test_pad(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (1, None, 2)), ("pads", TensorProto.INT64, (6,))],
+            [make_node("Pad", ["x", "pads"], "y")],
+            [],
+            initializer=[
+                make_tensor(
+                    "pads",
+                    TensorProto.INT64,
+                    (6,),
+                    (
+                        1,
+                        3,
+                        1,
+                        1,
+                        0,
+                        1,
+                    ),
+                )
+            ],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3, None, 4))]
+        )
+
+    def test_gatherelements_basic(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (6,)), ("indices", TensorProto.INT64, (2,))],
+            [make_node("GatherElements", ["x", "indices"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (2,))]
+        )
+
+    def test_gatherelements_indices_missing_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (6,)),
+                ("indices", TensorProto.INT64, None),
+            ],
+            [make_node("GatherElements", ["x", "indices"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, None)]
+        )
+
+    def test_einsum_transpose(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4))],
+            [make_node("Einsum", ["x"], ["y"], equation="ij->ji")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (4, 3))]
+        )
+
+    def test_einsum_dot(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (1,)), ("y", TensorProto.FLOAT, (1,))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="i,i->")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, ())]
+        )
+
+    def test_einsum_scalar(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ()), ("y", TensorProto.FLOAT, ())],
+            [make_node("Einsum", ["x", "y"], ["z"], equation=",->")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, ())]
+        )
+
+    def test_einsum_scalar_invalid_equation(self) -> None:
+        # Test that scalar inputs with incompatible equations fail gracefully
+        # instead of causing segfaults (issue #6981)
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ())],
+            [make_node("Einsum", ["x"], ["y"], equation="i->i")],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_einsum_outer_prod(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 5)), ("y", TensorProto.FLOAT, (7, 9))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,ab->ijab")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 5, 7, 9))]
+        )
+
+    def test_einsum_sum_along_dim(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4))],
+            [make_node("Einsum", ["x"], ["y"], equation="i j->i ")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3,))]
+        )
+
+    def test_einsum_ellipsis(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 4))],
+            [make_node("Einsum", ["x"], ["y"], equation="... ii ->... i")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3, 4))]
+        )
+
+    def test_einsum_ellipsis_2(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 4)), ("y", TensorProto.FLOAT, (2, 4, 5))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="...ij,...jk->...ik")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 3, 5))]
+        )
+
+    def test_einsum_ellipsis_3(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 4)), ("y", TensorProto.FLOAT, (2, 4, 5))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="...ij,...jk")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 3, 5))]
+        )
+
+    def test_einsum_ellipsis_broadcast(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (1, 3, 4)), ("y", TensorProto.FLOAT, (32, 4, 5))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="...ij,...jk->...ik")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (32, 3, 5))]
+        )
+
+    def test_einsum_contraction(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (5, 6, 7, 8)),
+                ("y", TensorProto.FLOAT, (8, 9, 10)),
+            ],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="abcd,dfg->abcfg")],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("z", TensorProto.FLOAT, (5, 6, 7, 9, 10))],
+        )
+
+    def test_einsum_contraction_2(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("y", TensorProto.FLOAT, (3, 5))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ijk,ik->jk")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (4, 5))]
+        )
+
+    def test_einsum_batch_matmul(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (5, 2, 3)), ("y", TensorProto.FLOAT, (5, 3, 4))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="bij , b jk-> bik")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (5, 2, 4))]
+        )
+
+    def test_einsum_left_hand_eqn(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3)), ("y", TensorProto.FLOAT, (3, 4))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,kl")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 3, 3, 4))]
+        )
+
+    def test_einsum_incorrect_num_inputs(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (2, 3)),
+                ("y", TensorProto.FLOAT, (2, 3)),
+                ("z", TensorProto.FLOAT, (2, 3)),
+            ],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="i,...j, k, l-> i")],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_einsum_view_A1(self) -> None:  # returns a view of A1
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3,))],
+            [make_node("Einsum", ["x"], ["y"], equation="i")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3,))]
+        )
+
+    def test_einsum_sum_A1(self) -> None:  # sums the values of A1
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3,))],
+            [make_node("Einsum", ["x"], ["y"], equation="i->")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, ())]
+        )
+
+    def test_einsum_element_wise_multiplication_A1_B1(
+        self,
+    ) -> None:  # element-wise multiplication of A1 and B1
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3,)), ("y", TensorProto.FLOAT, (3,))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="i,i->i")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3,))]
+        )
+
+    def test_einsum_inner_product_A1_B1(self) -> None:  # inner product of A1 and B1
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3,)), ("y", TensorProto.FLOAT, (3,))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="i,i->")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, ())]
+        )
+
+    def test_einsum_outer_product_A1_B1(self) -> None:  # outer product of A1 and B1
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3,)), ("y", TensorProto.FLOAT, (3,))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="i,j->ij")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_view_A2(self) -> None:  # returns a view of A2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x"], ["y"], equation="ij->ij")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_view_A2_2(self) -> None:  # returns a view of A2, another case
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x"], ["y"], equation="ij")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_transpose_A2(self) -> None:  # view transpose of A2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x"], ["y"], equation="ji")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_transpose_A2_to_ij(self) -> None:  # view transpose of A2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x"], ["y"], equation="ji->ij")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_diag_A2(self) -> None:  # view main diagonal of A2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x"], ["y"], equation="ii->i")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3,))]
+        )
+
+    def test_einsum_trace_A2(self) -> None:  # sums main diagonal of A2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x"], ["y"], equation="ii->")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, ())]
+        )
+
+    def test_einsum_sum_A2(self) -> None:  # sums the values of A2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x"], ["y"], equation="ij->")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, ())]
+        )
+
+    def test_einsum_sum_columns_A2(
+        self,
+    ) -> None:  # sum down the columns of A2 (across rows)
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x"], ["y"], equation="ij->j")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3,))]
+        )
+
+    def test_einsum_sum_rows_A2(self) -> None:  # sum horizontally along the rows of A2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x"], ["y"], equation="ij->i")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3,))]
+        )
+
+    def test_einsum_element_wise_multiplication_A2_B2(
+        self,
+    ) -> None:  # element-wise multiplication of A2 and B2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,ij->ij")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_element_wise_multiplication_A2_B2_transpose(
+        self,
+    ) -> None:  # element-wise multiplication of A2 and B2.T
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,ji->ij")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_matrix_multiplication_A2_B2(
+        self,
+    ) -> None:  # matrix multiplication of A2 and B2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,jk")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_matrix_multiplication_A2_B2_to_ik(
+        self,
+    ) -> None:  # matrix multiplication of A2 and B2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,jk->ik")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_matrix_multiplication_A3_B3(
+        self,
+    ) -> None:  # matrix multiplication of A3 and B3 (a stack of 2D matrices)
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 3)), ("y", TensorProto.FLOAT, (2, 3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="bij,bjk->bik")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 3, 3))]
+        )
+
+    def test_einsum_matrix_multiplication_A3_B3_transpose(
+        self,
+    ) -> None:  # matrix multiplication of A3 and B3 (a stack of 2D matrices)
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3, 3)), ("y", TensorProto.FLOAT, (2, 3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="bij,bkj->bik")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 3, 3))]
+        )
+
+    def test_einsum_inner_product_A2_B2(self) -> None:  # inner product of A2 and B2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,kj->ik")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_row_multiplication_A2_B2(
+        self,
+    ) -> None:  # each row of A2 multiplied by B2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,kj->ikj")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 3, 3))]
+        )
+
+    def test_einsum_value_multiplication_A2_B2(
+        self,
+    ) -> None:  # each value of A2 multiplied by B2
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,kl->ijkl")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 3, 3, 3))]
+        )
+
+    def test_einsum_scalar_times_array(self) -> None:  # Scalar times array
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ()), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation=",ij->ij")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3, 3))]
+        )
+
+    def test_einsum_matrix_vector_A2_B1(self) -> None:  # Matrix and vector.
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3,))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ij,j->i")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3,))]
+        )
+
+    def test_einsum_diag_multiplication_A2_B2(
+        self,
+    ) -> None:  # diagonals multiplied by each other
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ii,ii->i")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (3,))]
+        )
+
+    def test_einsum_diag_dot_product_A2_B2(self) -> None:  # dot product of diagonals
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 3)), ("y", TensorProto.FLOAT, (3, 3))],
+            [make_node("Einsum", ["x", "y"], ["z"], equation="ii,ii->")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, ())]
+        )
+
+    def test_negative_log_likelihood_shape_is_NCdd(self) -> None:
+        N, C = 3, 4
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (N, C)), ("target", TensorProto.INT64, (N,))],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target"],
+                    ["loss"],
+                    reduction="none",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("loss", TensorProto.FLOAT, (N,))]
+        )
+
+    def test_negative_log_likelihood_shape_is_NC_with_weight(self) -> None:
+        N, C = 3, 4
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (N, C)),
+                ("target", TensorProto.INT64, (N,)),
+                ("weight", TensorProto.FLOAT, (C,)),
+            ],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target", "weight"],
+                    ["loss"],
+                    reduction="none",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("loss", TensorProto.FLOAT, (N,))]
+        )
+
+    def test_negative_log_likelihood_shape_is_NC_reduction_mean(self) -> None:
+        N, C = 3, 4
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, (N, C)), ("target", TensorProto.INT64, (N,))],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target"],
+                    ["loss"],
+                    reduction="mean",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("loss", TensorProto.FLOAT, ())]
+        )
+
+    def test_negative_log_likelihood_shape_is_NC_with_weight_reduction_mean(
+        self,
+    ) -> None:
+        N, C = 3, 4
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (N, C)),
+                ("target", TensorProto.INT64, (N,)),
+                ("weight", TensorProto.FLOAT, (C,)),
+            ],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target", "weight"],
+                    ["loss"],
+                    reduction="mean",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("loss", TensorProto.FLOAT, ())]
+        )
+
+    def test_negative_log_likelihood_shape_is_NCd1d2(self) -> None:
+        N, C, d1, d2 = 3, 4, 5, 6
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (N, C, d1, d2)),
+                ("target", TensorProto.INT64, (N, d1, d2)),
+            ],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target"],
+                    ["loss"],
+                    reduction="none",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("loss", TensorProto.FLOAT, (N, d1, d2))]
+        )
+
+    def test_negative_log_likelihood_shape_is_NCd1d2_with_weight(self) -> None:
+        N, C, d1, d2 = 3, 4, 5, 6
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (N, C, d1, d2)),
+                ("target", TensorProto.INT64, (N, d1, d2)),
+                ("weight", TensorProto.FLOAT, (C,)),
+            ],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target", "weight"],
+                    ["loss"],
+                    reduction="none",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("loss", TensorProto.FLOAT, (N, d1, d2))]
+        )
+
+    def test_negative_log_likelihood_shape_is_NCd1d2_reduction_sum(self) -> None:
+        N, C, d1, d2 = 3, 4, 5, 6
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (N, C, d1, d2)),
+                ("target", TensorProto.INT64, (N, d1, d2)),
+            ],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target"],
+                    ["loss"],
+                    reduction="sum",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("loss", TensorProto.FLOAT, ())]
+        )
+
+    def test_negative_log_likelihood_shape_is_NCd1d2_with_weight_reduction_mean(
+        self,
+    ) -> None:
+        N, C, d1, d2 = 3, 4, 5, 6
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (N, C, d1, d2)),
+                ("target", TensorProto.INT64, (N, d1, d2)),
+                ("weight", TensorProto.FLOAT, (C,)),
+            ],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target", "weight"],
+                    ["loss"],
+                    reduction="mean",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("loss", TensorProto.FLOAT, ())]
+        )
+
+    def test_negative_log_likelihood_input_target_shape_mismatch(self) -> None:
+        N, C, d1, d2 = 3, 4, 5, 6
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (N, d1, d2)),
+                ("target", TensorProto.INT64, (N, d1 + 1, d2)),
+                ("weight", TensorProto.FLOAT, (C,)),
+                ("loss", TensorProto.FLOAT, ()),
+            ],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target", "weight"],
+                    ["loss"],
+                    reduction="mean",
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(graph)
+
+    def test_negative_log_likelihood_input_weight_shape_mismatch(self) -> None:
+        N, C, d1, d2 = 3, 4, 5, 6
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.FLOAT, (N, C, d1, d2)),
+                ("target", TensorProto.INT64, (N, d1, d2)),
+                ("weight", TensorProto.FLOAT, (C + 1,)),
+                ("loss", TensorProto.FLOAT, (N, d1, d2)),
+            ],
+            [
+                make_node(
+                    "NegativeLogLikelihoodLoss",
+                    ["input", "target", "weight"],
+                    ["loss"],
+                    reduction="none",
+                )
+            ],
+            [],
+        )
+        with pytest.raises(
+            (checker.ValidationError, onnx.shape_inference.InferenceError)
+        ):
+            self._inferred(
+                graph,
+            )
+
+    def test_softmax_cross_entropy_none(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3)), ("y", TensorProto.FLOAT, (2,))],
+            [make_node("SoftmaxCrossEntropyLoss", ["x", "y"], ["z"], reduction="none")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2,))]
+        )
+
+    def test_softmax_cross_entropy_mean(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (2, 3)), ("y", TensorProto.FLOAT, (2,))],
+            [make_node("SoftmaxCrossEntropyLoss", ["x", "y"], ["z"], reduction="mean")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, ())]
+        )
+
+    def test_softmax_cross_entropy_none_NCD1D2(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (2, 3, 5, 8)),
+                ("y", TensorProto.FLOAT, (2, 5, 8)),
+            ],
+            [make_node("SoftmaxCrossEntropyLoss", ["x", "y"], ["z"], reduction="none")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, (2, 5, 8))]
+        )
+
+    def test_softmax_cross_entropy_mean_NCD1D2(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (2, 3, 4, 5)),
+                ("y", TensorProto.FLOAT, (2, 4, 5)),
+            ],
+            [make_node("SoftmaxCrossEntropyLoss", ["x", "y"], ["z"], reduction="mean")],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("z", TensorProto.FLOAT, ())]
+        )
+
+    def test_celu_function_output_shape(self) -> None:
+        graph = self._make_graph(
+            [("X", TensorProto.FLOAT, (25, 48, 16, 16))],
+            [make_node("Celu", ["X"], ["Y"], alpha=2.0)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("Y", TensorProto.FLOAT, (25, 48, 16, 16))]
+        )
+
+    def test_celu_float16_and_bfloat16(self) -> None:
+        for elem_type in (TensorProto.FLOAT16, TensorProto.BFLOAT16):
+            graph = self._make_graph(
+                [("X", elem_type, (3, 4))],
+                [make_node("Celu", ["X"], ["Y"], alpha=2.0)],
+                [],
+            )
+            self._assert_inferred(
+                graph, [make_tensor_value_info("Y", elem_type, (3, 4))]
+            )
+
+    def prepare_input_initializer_tensors(self, initializer_shape, input_shape):
+        nodes = [make_node("Add", ["x", "y"], "z")]
+        if initializer_shape is None:
+            initializer = []
+        else:
+            size = 1
+            for d in initializer_shape:
+                size = size * d
+            vals = [0.0 for i in range(size)]
+            initializer = [
+                make_tensor("x", TensorProto.FLOAT, initializer_shape, vals),
+                make_tensor("y", TensorProto.FLOAT, initializer_shape, vals),
+            ]
+        if input_shape is None:
+            inputs = []
+        else:
+            inputs = [
+                helper.make_tensor_value_info("x", TensorProto.FLOAT, input_shape),
+                helper.make_tensor_value_info("y", TensorProto.FLOAT, input_shape),
+            ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            inputs=inputs,
+            outputs=[],
+            initializer=initializer,
+            value_info=[],
+        )
+        return helper.make_model(graph)
+
+    def test_infer_with_initializer_without_input_above_ir4(self) -> None:
+        # This is for testing IR>=4: some tensors can only exist in initializer and not in input
+        # So shape_inference should make use of initializer shapes
+        initializer_shape = (8, 7)
+        original_model = self.prepare_input_initializer_tensors(initializer_shape, None)
+        inferred_model = onnx.shape_inference.infer_shapes(
+            original_model, strict_mode=True
+        )
+
+        # If shape inference fails, it will throw IndexError
+        z_tenor = inferred_model.graph.value_info.pop()
+        z_shape = (
+            z_tenor.type.tensor_type.shape.dim[0].dim_value,
+            z_tenor.type.tensor_type.shape.dim[1].dim_value,
+        )
+        assert z_shape == initializer_shape
+
+    def test_infer_with_initializer_without_input_below_ir4(self) -> None:
+        # This is for testing IR<4: tensors must exist both in initializer and input
+        # So shape_inference should not make use of initializer shapes
+        # Use (None, None) as empty input
+        initializer_shape = (8, 7)
+        input_shape = (None, None)
+        original_model = self.prepare_input_initializer_tensors(
+            initializer_shape, input_shape
+        )
+        original_model.ir_version = 3  # test ir_version < 4
+
+        inferred_model = onnx.shape_inference.infer_shapes(
+            original_model, strict_mode=True
+        )
+        z_tenor = inferred_model.graph.value_info.pop()
+        z_shape = (
+            z_tenor.type.tensor_type.shape.dim[0].dim_value,
+            z_tenor.type.tensor_type.shape.dim[1].dim_value,
+        )
+        # If the input is not updated by the initializer, the output shape will keep empty (0, 0)
+        assert z_shape == (0, 0)
+
+    def test_infer_initializer_input_mismatch(self) -> None:
+        # Catch error if initializer and input mismatch
+        initializer_shape = (8, 7)
+        input_shape = (4, 3)
+        original_model = self.prepare_input_initializer_tensors(
+            initializer_shape, input_shape
+        )
+        # Inferred shape and existing shape differ in dimension 0
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(
+                original_model,
+                strict_mode=True,
+            )
+
+    def test_infer_initializer_input_consistency_all_none(self) -> None:
+        initializer_shape = (8, 7)
+        input_shape = (None, None)  # acceptable
+        original_model = self.prepare_input_initializer_tensors(
+            initializer_shape, input_shape
+        )
+
+        onnx.shape_inference.infer_shapes(original_model, strict_mode=True)
+
+    def test_infer_initializer_input_consistency_single_none(self) -> None:
+        initializer_shape = (8, 7)
+        input_shape = (None, 7)  # acceptable
+        original_model = self.prepare_input_initializer_tensors(
+            initializer_shape, input_shape
+        )
+
+        onnx.shape_inference.infer_shapes(original_model, strict_mode=True)
+
+    def test_infer_initializer_input_consistency_different_rank(self) -> None:
+        initializer_shape = (8, 7, 9)
+        input_shape = (None, 7)  # acceptable
+        original_model = self.prepare_input_initializer_tensors(
+            initializer_shape, input_shape
+        )
+        # Inferred shape and existing shape differ in rank: (3) vs (2)
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(
+                original_model,
+                strict_mode=True,
+            )
+
+    def test_infer_initializer_input_consistency_all_none_serialized(self) -> None:
+        # Reuse test_infer_initializer_input_consistency_all_none test case and check with
+        # Serialized model
+        initializer_shape = (8, 7)
+        input_shape = (None, None)  # acceptable
+        original_model = self.prepare_input_initializer_tensors(
+            initializer_shape, input_shape
+        )
+
+        onnx.shape_inference.infer_shapes(
+            original_model.SerializeToString(), strict_mode=True
+        )
+
+    def test_trilu_upper(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("k", TensorProto.INT64, ())],
+            [make_node("Trilu", ["x", "k"], ["y"])],
+            [],
+            initializer=[make_tensor("k", TensorProto.INT64, (), (2,))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3, 4, 5))]
+        )
+
+    def test_trilu_lower(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3, 4, 5)), ("k", TensorProto.INT64, ())],
+            [make_node("Trilu", ["x", "k"], ["y"], upper=0)],
+            [],
+            initializer=[make_tensor("k", TensorProto.INT64, (), (10,))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (3, 4, 5))]
+        )
+
+    def test_trilu_upper_zero(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.INT64, (0, 5)), ("k", TensorProto.INT64, ())],
+            [make_node("Trilu", ["x", "k"], ["y"], upper=1)],
+            [],
+            initializer=[make_tensor("k", TensorProto.INT64, (), (5,))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, (0, 5))]
+        )
+
+    def test_trilu_lower_one(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.INT32, (3, 1, 5))],
+            [make_node("Trilu", ["x"], ["y"], upper=0)],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT32, (3, 1, 5))]
+        )
+
+    def test_batch_norm_train(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 4, 5, 6, 7)),
+                ("scale", TensorProto.FLOAT, (4,)),
+                ("b", TensorProto.FLOAT, (4,)),
+                ("input_mean", TensorProto.FLOAT, (4,)),
+                ("input_var", TensorProto.FLOAT, (4,)),
+            ],
+            [
+                make_node(
+                    "BatchNormalization",
+                    ["x", "scale", "b", "input_mean", "input_var"],
+                    ["out", "output_mean", "output_var"],
+                    training_mode=1,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("out", TensorProto.FLOAT, (3, 4, 5, 6, 7)),
+                make_tensor_value_info("output_mean", TensorProto.FLOAT, (4,)),
+                make_tensor_value_info("output_var", TensorProto.FLOAT, (4,)),
+            ],
+        )
+
+    def test_batch_norm_train_dim_param(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, "C", 5, 6, 7)),
+                ("scale", TensorProto.FLOAT, ("C",)),
+                ("b", TensorProto.FLOAT, ("C",)),
+                ("input_mean", TensorProto.FLOAT, ("C",)),
+                ("input_var", TensorProto.FLOAT, ("C",)),
+            ],
+            [
+                make_node(
+                    "BatchNormalization",
+                    ["x", "scale", "b", "input_mean", "input_var"],
+                    ["out", "output_mean", "output_var"],
+                    training_mode=1,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("out", TensorProto.FLOAT, (3, "C", 5, 6, 7)),
+                make_tensor_value_info("output_mean", TensorProto.FLOAT, ("C",)),
+                make_tensor_value_info("output_var", TensorProto.FLOAT, ("C",)),
+            ],
+        )
+
+    def test_batch_norm_train_with_diff_type(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT16, (3, 4, 5, 6, 7)),
+                ("scale", TensorProto.FLOAT16, (4,)),
+                ("b", TensorProto.FLOAT16, (4,)),
+                ("input_mean", TensorProto.FLOAT, (4,)),
+                ("input_var", TensorProto.FLOAT, (4,)),
+            ],
+            [
+                make_node(
+                    "BatchNormalization",
+                    ["x", "scale", "b", "input_mean", "input_var"],
+                    ["out", "output_mean", "output_var"],
+                    training_mode=1,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("out", TensorProto.FLOAT16, (3, 4, 5, 6, 7)),
+                make_tensor_value_info("output_mean", TensorProto.FLOAT, (4,)),
+                make_tensor_value_info("output_var", TensorProto.FLOAT, (4,)),
+            ],
+        )
+
+    def test_batch_norm_test(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 4, 5, 6, 7)),
+                ("scale", TensorProto.FLOAT, (4,)),
+                ("b", TensorProto.FLOAT, (4,)),
+                ("input_mean", TensorProto.FLOAT, (4,)),
+                ("input_var", TensorProto.FLOAT, (4,)),
+            ],
+            [
+                make_node(
+                    "BatchNormalization",
+                    ["x", "scale", "b", "input_mean", "input_var"],
+                    ["out"],
+                    training_mode=0,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.FLOAT, (3, 4, 5, 6, 7))]
+        )
+
+    def test_batch_norm_test_no_dim(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (3, 4, None, None, None)),
+                ("scale", TensorProto.FLOAT, (4,)),
+                ("b", TensorProto.FLOAT, (4,)),
+                ("input_mean", TensorProto.FLOAT, (None,)),
+                ("input_var", TensorProto.FLOAT, (4,)),
+            ],
+            [
+                make_node(
+                    "BatchNormalization",
+                    ["x", "scale", "b", "input_mean", "input_var"],
+                    ["out"],
+                    training_mode=0,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "out", TensorProto.FLOAT, (3, 4, None, None, None)
+                )
+            ],
+        )
+
+    def test_batch_norm_train_no_shape(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, None),
+                ("scale", TensorProto.FLOAT, None),
+                ("b", TensorProto.FLOAT, None),
+                ("input_mean", TensorProto.FLOAT, ("C",)),
+                ("input_var", TensorProto.FLOAT, ("C",)),
+            ],
+            [
+                make_node(
+                    "BatchNormalization",
+                    ["x", "scale", "b", "input_mean", "input_var"],
+                    ["out", "running_mean", "running_var"],
+                    training_mode=1,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("out", TensorProto.FLOAT, None),
+                make_tensor_value_info("running_mean", TensorProto.FLOAT, ("C",)),
+                make_tensor_value_info("running_var", TensorProto.FLOAT, ("C",)),
+            ],
+        )
+
+    def test_nonzero(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (None,))],
+            [make_node("NonZero", ["x"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.INT64, (1, None))]
+        )
+
+    def test_nonzero_no_shape(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, None)], [make_node("NonZero", ["x"], ["out"])], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.INT64, (None, None))]
+        )
+
+    def test_nonzero_existing_dim_param(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, (3,))],
+            [make_node("NonZero", ["x"], ["y"])],
+            [make_tensor_value_info("y", TensorProto.INT64, (None, "NZ"))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.INT64, (1, "NZ"))]
+        )
+
+    def test_nonzero_scalar(self) -> None:
+        graph = self._make_graph(
+            [("x", TensorProto.FLOAT, ())], [make_node("NonZero", ["x"], ["out"])], []
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.INT64, (0, None))]
+        )
+
+    def test_optional_construct_empty_tensor(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.FLOAT, shape=[1, 2, 3]
+        )
+        optional_type_proto = helper.make_optional_type_proto(tensor_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="output", type_proto=optional_type_proto
+        )
+        graph = self._make_graph(
+            [], [make_node("Optional", [], ["output"], type=tensor_type_proto)], []
+        )
+        self._assert_inferred(graph, [optional_val_info])
+
+    def test_optional_construct_empty_sequence(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.INT32, shape=[1, 2, 3]
+        )
+        sequence_type_proto = helper.make_sequence_type_proto(tensor_type_proto)
+        optional_type_proto = helper.make_optional_type_proto(sequence_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="output_sequence", type_proto=optional_type_proto
+        )
+        graph = self._make_graph(
+            [],
+            [make_node("Optional", [], ["output_sequence"], type=sequence_type_proto)],
+            [],
+        )
+        self._assert_inferred(graph, [optional_val_info])
+
+    def test_optional_construct_tensor(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.FLOAT, shape=[2, 3, 4]
+        )
+        optional_type_proto = helper.make_optional_type_proto(tensor_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="output", type_proto=optional_type_proto
+        )
+        graph = self._make_graph(
+            [("input1", TensorProto.FLOAT, (2, 3, 4))],
+            [make_node("Optional", ["input1"], ["output"])],
+            [],
+        )
+        self._assert_inferred(graph, [optional_val_info])
+
+    def test_optional_construct_sequence(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.INT64, shape=[2, 3, 0]
+        )
+        sequence_type_proto = helper.make_sequence_type_proto(tensor_type_proto)
+        sequence_val_info = helper.make_value_info(
+            name="input_sequence", type_proto=sequence_type_proto
+        )
+        optional_type_proto = helper.make_optional_type_proto(sequence_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="output_sequence", type_proto=optional_type_proto
+        )
+        graph = self._make_graph(
+            [("input1", TensorProto.INT64, (2, 3, 0))],
+            [
+                make_node("SequenceConstruct", ["input1"], ["input_sequence"]),
+                make_node("Optional", ["input_sequence"], ["output_sequence"]),
+            ],
+            [],
+        )
+        self._assert_inferred(graph, [sequence_val_info, optional_val_info])
+
+    def test_optional_tensor_has_element(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.FLOAT, shape=[2, 3, 4]
+        )
+        optional_type_proto = helper.make_optional_type_proto(tensor_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="sequence", type_proto=optional_type_proto
+        )
+        graph = self._make_graph(
+            [("input1", TensorProto.FLOAT, (2, 3, 4))],
+            [
+                make_node("Optional", ["input1"], ["sequence"]),
+                make_node("OptionalHasElement", ["sequence"], ["output"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [optional_val_info, make_tensor_value_info("output", TensorProto.BOOL, ())],
+        )
+
+    def test_optional_sequence_has_element(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.FLOAT, shape=[0, 3, 4]
+        )
+        sequence_type_proto = helper.make_sequence_type_proto(tensor_type_proto)
+        sequence_val_info = helper.make_value_info(
+            name="sequence", type_proto=sequence_type_proto
+        )
+        optional_type_proto = helper.make_optional_type_proto(sequence_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="optional", type_proto=optional_type_proto
+        )
+        graph = self._make_graph(
+            [("input1", TensorProto.FLOAT, (0, 3, 4))],
+            [
+                make_node("SequenceConstruct", ["input1"], ["sequence"]),
+                make_node("Optional", ["sequence"], ["optional"]),
+                make_node("OptionalHasElement", ["optional"], ["output"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                sequence_val_info,
+                optional_val_info,
+                make_tensor_value_info("output", TensorProto.BOOL, ()),
+            ],
+        )
+
+    def test_tensor_get_element(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.DOUBLE, shape=[2, 1, 4]
+        )
+        output_tensor_val_info = helper.make_value_info(
+            name="output", type_proto=tensor_type_proto
+        )
+        graph = self._make_graph(
+            [("input", TensorProto.DOUBLE, (2, 1, 4))],
+            [
+                make_node("OptionalGetElement", ["input"], ["output"]),
+            ],
+            [],
+        )
+        self._assert_inferred(graph, [output_tensor_val_info])
+
+    @pytest.mark.parametrize("version", all_versions_for("StringSplit"))
+    def test_string_split_basic(self, version) -> None:
+        substrings = make_tensor_value_info(
+            "substrings",
+            TensorProto.STRING,
+            (2, None),
+        )
+        length = make_tensor_value_info("length", TensorProto.INT64, (2,))
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.STRING, (2,)),
+            ],
+            [make_node("StringSplit", ["x"], ["substrings", "length"])],
+            [substrings, length],
+        )
+        self._assert_inferred(
+            graph,
+            [substrings, length],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("StringSplit"))
+    def test_string_split_symbolic(self, version) -> None:
+        substrings = make_tensor_value_info(
+            "substrings",
+            TensorProto.STRING,
+            ("A", None),
+        )
+        length = make_tensor_value_info("length", TensorProto.INT64, ("A",))
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.STRING, ("A",)),
+            ],
+            [make_node("StringSplit", ["x"], ["substrings", "length"])],
+            [substrings, length],
+        )
+        self._assert_inferred(
+            graph,
+            [substrings, length],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("StringSplit"))
+    def test_string_split_nested(self, version) -> None:
+        substrings = make_tensor_value_info(
+            "substrings", TensorProto.STRING, (2, 4, 3, None)
+        )
+        length = make_tensor_value_info("length", TensorProto.INT64, (2, 4, 3))
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.STRING, (2, 4, 3)),
+            ],
+            [make_node("StringSplit", ["x"], ["substrings", "length"], maxsplit=2)],
+            [substrings, length],
+        )
+        self._assert_inferred(
+            graph,
+            [substrings, length],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("StringSplit"))
+    def test_string_split_zero_dimensional_input(self, version) -> None:
+        substrings = make_tensor_value_info("substrings", TensorProto.STRING, (None,))
+        length = make_tensor_value_info("length", TensorProto.INT64, ())
+
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.STRING, ()),
+            ],
+            [make_node("StringSplit", ["x"], ["substrings", "length"], maxsplit=2)],
+            [substrings, length],
+        )
+        self._assert_inferred(
+            graph,
+            [substrings, length],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("StringSplit"))
+    def test_string_split_empty_input(self, version) -> None:
+        substrings = make_tensor_value_info(
+            "substrings", TensorProto.STRING, ("M", 3, 0, None)
+        )
+        length = make_tensor_value_info("length", TensorProto.INT64, ("M", 3, 0))
+
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.STRING, ("M", 3, 0)),
+            ],
+            [make_node("StringSplit", ["x"], ["substrings", "length"], maxsplit=2)],
+            [substrings, length],
+        )
+        self._assert_inferred(
+            graph,
+            [substrings, length],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    def test_optional_tensor_get_element(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.DOUBLE, shape=[2, 1, 4]
+        )
+        tensor_val_into = helper.make_value_info(
+            name="output", type_proto=tensor_type_proto
+        )
+        optional_type_proto = helper.make_optional_type_proto(tensor_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="optional", type_proto=optional_type_proto
+        )
+        graph = self._make_graph(
+            [("input1", TensorProto.DOUBLE, (2, 1, 4))],
+            [
+                make_node("Optional", ["input1"], ["optional"]),
+                make_node("OptionalGetElement", ["optional"], ["output"]),
+            ],
+            [],
+        )
+        self._assert_inferred(graph, [optional_val_info, tensor_val_into])
+
+    def test_optional_sequence_get_element(self) -> None:
+        tensor_type_proto = helper.make_tensor_type_proto(
+            elem_type=TensorProto.INT32, shape=[2, 0, 4]
+        )
+        sequence_type_proto = helper.make_sequence_type_proto(tensor_type_proto)
+        sequence_val_into = helper.make_value_info(
+            name="sequence", type_proto=sequence_type_proto
+        )
+        optional_type_proto = helper.make_optional_type_proto(sequence_type_proto)
+        optional_val_info = helper.make_value_info(
+            name="optional", type_proto=optional_type_proto
+        )
+        output_val_into = helper.make_value_info(
+            name="output", type_proto=sequence_type_proto
+        )
+        graph = self._make_graph(
+            [("input1", TensorProto.INT32, (2, 0, 4))],
+            [
+                make_node("SequenceConstruct", ["input1"], ["sequence"]),
+                make_node("Optional", ["sequence"], ["optional"]),
+                make_node("OptionalGetElement", ["optional"], ["output"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [optional_val_info, sequence_val_into, output_val_into]
+        )
+
+    def test_where_bfloat(self) -> None:
+        graph = self._make_graph(
+            [
+                ("cond", TensorProto.BOOL, (10,)),
+                ("x", TensorProto.BFLOAT16, (10,)),
+                ("y", TensorProto.BFLOAT16, (10,)),
+            ],
+            [make_node("Where", ["cond", "x", "y"], ["out"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("out", TensorProto.BFLOAT16, (10,))]
+        )
+
+    def test_parse_data_with_unsupported_tensor_type(self) -> None:
+        model = helper.make_model(
+            graph=helper.make_graph(
+                name="graph_with_unsupported_type",
+                inputs=[],
+                outputs=[
+                    helper.make_tensor_value_info("y", TensorProto.FLOAT, shape=None)
+                ],
+                nodes=[make_node("ConstantOfShape", ["x"], ["y"])],
+                # ConstantOfShape only accepts np.int64 instead of np.int32
+                initializer=[
+                    numpy_helper.from_array(np.array([4, 3], dtype=np.int32), name="x")
+                ],
+            )
+        )
+        # Strict shape inference should catch this invalid type error (int32 is not supported)
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(
+                model,
+                strict_mode=True,
+            )
+        # Even nornmal shape inference should not produce any invalid shape due to wrong type for ParseData
+        inferred_model = onnx.shape_inference.infer_shapes(model)
+        assert not inferred_model.graph.output[0].type.tensor_type.HasField("shape")
+
+    def test_parse_data_with_undefined_tensor_type(self) -> None:
+        model = helper.make_model(
+            graph=helper.make_graph(
+                name="graph_with_undefined_type",
+                inputs=[],
+                outputs=[
+                    helper.make_tensor_value_info("y", TensorProto.FLOAT, shape=None)
+                ],
+                nodes=[make_node("ConstantOfShape", ["x"], ["y"])],
+                initializer=[
+                    numpy_helper.from_array(np.array([4, 3], dtype=np.int64), name="x")
+                ],
+            )
+        )
+        # Hardcode the tensor type as UNDEFINED to test catching undefined type error
+        model.graph.initializer[0].data_type = TensorProto.UNDEFINED
+        # Strict shape inference should catch this undefined type error
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(
+                model,
+                strict_mode=True,
+            )
+        # Even nornmal shape inference should not produce any invalid shape due to undefined type for ParseData
+        inferred_model = onnx.shape_inference.infer_shapes(model)
+        assert not inferred_model.graph.output[0].type.tensor_type.HasField("shape")
+
+        graph = self._make_graph(
+            [("x", TensorProto.UINT8, (1, 0, 0)), ("shape", TensorProto.INT64, (3,))],
+            [make_node("Reshape", ["x", "shape"], ["y"], allowzero=1)],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (3,), (0, 1, 1))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.UINT8, (0, 1, 1))]
+        )
+
+    def test_affinegrid_2d(self) -> None:
+        N, C, H, W = 2, 3, 4, 5
+        graph = self._make_graph(
+            [
+                ("theta", TensorProto.FLOAT, (N, 2, 3)),
+                ("size", TensorProto.INT64, (4,)),
+            ],
+            [
+                make_node(
+                    "AffineGrid",
+                    ["theta", "size"],
+                    ["grid"],
+                    align_corners=1,
+                )
+            ],
+            [],
+            initializer=[make_tensor("size", TensorProto.INT64, (4,), (N, C, H, W))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("grid", TensorProto.FLOAT, (N, H, W, 2))]
+        )
+
+    def test_affinegrid_3d(self) -> None:
+        N, C, D, H, W = 2, 3, 4, 5, 6
+        graph = self._make_graph(
+            [
+                ("theta", TensorProto.FLOAT, (N, 3, 4)),
+                ("size", TensorProto.INT64, (5,)),
+            ],
+            [
+                make_node(
+                    "AffineGrid",
+                    ["theta", "size"],
+                    ["grid"],
+                )
+            ],
+            [],
+            initializer=[make_tensor("size", TensorProto.INT64, (5,), (N, C, D, H, W))],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("grid", TensorProto.FLOAT, (N, D, H, W, 3))]
+        )
+
+    def test_gridsample_2d(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 3, 3)),
+                ("grid", TensorProto.INT64, (1, 3, 3, 2)),
+            ],
+            [
+                make_node(
+                    "GridSample",
+                    ["x", "grid"],
+                    ["y"],
+                    mode="nearest",
+                    padding_mode="border",
+                    align_corners=1,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, 1, 3, 3))]
+        )
+
+    def test_gridsample_3d(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, (1, 1, 3, 3, 3)),
+                ("grid", TensorProto.INT64, (1, 3, 2, 3, 3)),
+            ],
+            [
+                make_node(
+                    "GridSample",
+                    ["x", "grid"],
+                    ["y"],
+                    mode="nearest",
+                    padding_mode="border",
+                    align_corners=1,
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("y", TensorProto.FLOAT, (1, 1, 3, 2, 3))]
+        )
+
+    def test_gridsample_2d_defaults(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ("N", "C", "H", "W")),
+                ("grid", TensorProto.FLOAT, ("N", "H_out", "W_out", 2)),
+            ],
+            [make_node("GridSample", ["x", "grid"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "y", TensorProto.FLOAT, ("N", "C", "H_out", "W_out")
+                )
+            ],
+        )
+
+    def test_gridsample_3d_defaults(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ("N", "C", "D", "H", "W")),
+                ("grid", TensorProto.FLOAT, ("N", "D_out", "H_out", "W_out", 3)),
+            ],
+            [make_node("GridSample", ["x", "grid"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "y", TensorProto.FLOAT, ("N", "C", "D_out", "H_out", "W_out")
+                )
+            ],
+        )
+
+    def test_gridsample_2d_no_dim(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ("N", "C", None, None)),
+                ("grid", TensorProto.FLOAT, ("N", None, None, 2)),
+            ],
+            [
+                make_node(
+                    "GridSample",
+                    ["x", "grid"],
+                    ["y"],
+                    mode="linear",
+                    padding_mode="border",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, ("N", "C", None, None))],
+        )
+
+    def test_gridsample_3d_no_dim(self) -> None:
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.FLOAT, ("N", "C", None, None, None)),
+                ("grid", TensorProto.FLOAT, ("N", None, None, None, 3)),
+            ],
+            [
+                make_node(
+                    "GridSample",
+                    ["x", "grid"],
+                    ["y"],
+                    mode="linear",
+                    padding_mode="border",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(
+                    "y", TensorProto.FLOAT, ("N", "C", None, None, None)
+                )
+            ],
+        )
+
+    def test_sequence_map_identity_known_dims(self):
+        graph = parse_graph("""
+            agraph (float[220,220,3] input1, float[220,220,3] input2, float[220,220,3] input3)
+                => (out_sequence)
+            {
+                in_sequence = SequenceConstruct(input1, input2, input3)
+                out_sequence = SequenceMap (in_sequence) <
+                    body = body_graph (float[220,220,3] input) => (float[220,220,3] output) {
+                        output = Identity(input)
+                    }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (220, 220, 3)
+                ),
+                make_tensor_sequence_value_info(
+                    "out_sequence", TensorProto.FLOAT, (220, 220, 3)
+                ),
+            ],
+        )
+
+    def test_sequence_map_identity_unknown_dims(self):
+        graph = parse_graph("""
+            agraph (float[200,300,3] input1, float[100,200,3] input2, float[5,1,3] input3)
+                => (out_sequence)
+            {
+                in_sequence = SequenceConstruct(input1, input2, input3)
+                out_sequence = SequenceMap (in_sequence) <
+                    body = body_graph (float[H,W,3] input) => (float[H,W,3] output) {
+                        output = Identity(input)
+                    }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (None, None, 3)
+                ),
+                make_tensor_sequence_value_info(
+                    "out_sequence", TensorProto.FLOAT, (None, None, 3)
+                ),
+            ],
+        )
+
+    def test_sequence_map_slice_outs_known_dims(self):
+        # The body's y1/y2 outputs are declared with concrete shapes; SequenceMap propagates those
+        # element shapes into the output sequences.
+        graph = parse_graph("""
+            agraph (float[220,310,3] input1, float[110,210,3] input2, float[90,110,3] input3)
+                => (out_sequence1, out_sequence2)
+            {
+                in_sequence = SequenceConstruct(input1, input2, input3)
+                out_sequence1, out_sequence2 = SequenceMap (in_sequence) <
+                    body = body_graph (float[H,W,3] x) => (float[10,20,3] y1, float[30,40,3] y2)
+                    <
+                        int64[2] axes = {0,1},
+                        int64[2] starts1 = {0,0}, int64[2] ends1 = {10,20},
+                        int64[2] starts2 = {0,0}, int64[2] ends2 = {30,40}
+                    >
+                    {
+                        y1 = Slice(x, starts1, ends1, axes)
+                        y2 = Slice(x, starts2, ends2, axes)
+                    }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (None, None, 3)
+                ),
+                make_tensor_sequence_value_info(
+                    "out_sequence1", TensorProto.FLOAT, (10, 20, 3)
+                ),
+                make_tensor_sequence_value_info(
+                    "out_sequence2", TensorProto.FLOAT, (30, 40, 3)
+                ),
+            ],
+        )
+
+    def test_sequence_map_slice_outs_unknown_dims(self):
+        graph = parse_graph("""
+            agraph (float[220,310,3] input1, float[110,210,3] input2, float[90,110,3] input3)
+                => (out_sequence1, out_sequence2)
+            {
+                in_sequence = SequenceConstruct(input1, input2, input3)
+                out_sequence1, out_sequence2 = SequenceMap (in_sequence) <
+                    body = body_graph (float[H,W,3] x) => (float[H1,W1,3] y1, float[H2,W2,3] y2)
+                    <
+                        int64[2] axes = {0,1},
+                        int64[2] starts1 = {0,0}, int64[2] ends1 = {10,20},
+                        int64[2] starts2 = {0,0}, int64[2] ends2 = {30,40}
+                    >
+                    {
+                        y1 = Slice(x, starts1, ends1, axes)
+                        y2 = Slice(x, starts2, ends2, axes)
+                    }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (None, None, 3)
+                ),
+                make_tensor_sequence_value_info(
+                    "out_sequence1", TensorProto.FLOAT, (None, None, 3)
+                ),
+                make_tensor_sequence_value_info(
+                    "out_sequence2", TensorProto.FLOAT, (None, None, 3)
+                ),
+            ],
+        )
+
+    def test_sequence_map_different_tensor_type(self):
+        graph = parse_graph("""
+            agraph (float[220,310,3] input1, float[110,210,3] input2, float[90,110,3] input3)
+                => (shapes)
+            {
+                in_sequence = SequenceConstruct(input1, input2, input3)
+                shapes = SequenceMap (in_sequence) <
+                    body = body_graph (float[H,W,C] x) => (int64[3] shape) {
+                        shape = Shape(x)
+                    }
+                >
+            }
+        """)
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_sequence_value_info(
+                    "in_sequence", TensorProto.FLOAT, (None, None, 3)
+                ),
+                make_tensor_sequence_value_info("shapes", TensorProto.INT64, (3,)),
+            ],
+        )
+
+    def test_hammingwindow(self):
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["shape"],
+                    value=make_tensor("shape", TensorProto.INT64, (), (10,)),
+                ),
+                make_node("HammingWindow", ["shape"], ["y"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, ()),
+                make_tensor_value_info("y", TensorProto.FLOAT, (10,)),
+            ],
+        )
+
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["shape"],
+                    value=make_tensor("shape", TensorProto.INT64, (), (10,)),
+                ),
+                make_node("HammingWindow", ["shape"], ["y"], periodic=0),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, ()),
+                make_tensor_value_info("y", TensorProto.FLOAT, (10,)),
+            ],
+        )
+
+    def test_hannwindow(self):
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["shape"],
+                    value=make_tensor("shape", TensorProto.INT64, (), (10,)),
+                ),
+                make_node("HannWindow", ["shape"], ["y"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, ()),
+                make_tensor_value_info("y", TensorProto.FLOAT, (10,)),
+            ],
+        )
+
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["shape"],
+                    value=make_tensor("shape", TensorProto.INT64, (), (10,)),
+                ),
+                make_node("HannWindow", ["shape"], ["y"], periodic=0),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, ()),
+                make_tensor_value_info("y", TensorProto.FLOAT, (10,)),
+            ],
+        )
+
+    def test_blackmanwindow(self):
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["shape"],
+                    value=make_tensor("shape", TensorProto.INT64, (), (10,)),
+                ),
+                make_node("BlackmanWindow", ["shape"], ["y"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, ()),
+                make_tensor_value_info("y", TensorProto.FLOAT, (10,)),
+            ],
+        )
+
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["shape"],
+                    value=make_tensor("shape", TensorProto.INT64, (), (10,)),
+                ),
+                make_node("BlackmanWindow", ["shape"], ["y"], periodic=0),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("shape", TensorProto.INT64, ()),
+                make_tensor_value_info("y", TensorProto.FLOAT, (10,)),
+            ],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("DFT"))
+    @pytest.mark.parametrize(
+        "input_shape, axis, onesided, inverse, expected_shape",
+        [
+            ((2, 5, 1), None, None, None, (2, 5, 2)),
+            ((3, 5, 10, 1), 0, 0, 0, (3, 5, 10, 2)),
+            ((3, 5, 10, 1), 1, 0, 0, (3, 5, 10, 2)),
+            ((3, 5, 10, 1), 2, 0, 0, (3, 5, 10, 2)),
+            ((3, 5, 10, 1), -2, 0, 0, (3, 5, 10, 2)),
+            ((3, 5, 10, 1), 0, 1, 0, (2, 5, 10, 2)),
+            ((3, 5, 10, 1), 1, 1, 0, (3, 3, 10, 2)),
+            ((3, 5, 10, 1), 2, 1, 0, (3, 5, 6, 2)),
+            ((3, 5, 10, 1), -2, 1, 0, (3, 5, 6, 2)),
+            ((2, 5, 2), None, None, None, (2, 5, 2)),
+            ((2, 5, 1), 1, None, 1, (2, 5, 2)),
+            ((2, 5, 2), 1, None, 1, (2, 5, 2)),
+            ((2, 5, 10, 2), 0, 1, 1, (2, 5, 10, 1)),
+            ((3, 3, 10, 2), 1, 1, 1, (3, 4, 10, 1)),
+            ((3, 5, 6, 2), 2, 1, 1, (3, 5, 10, 1)),
+            ((3, 5, 6, 2), -2, 1, 1, (3, 5, 10, 1)),
+        ],
+    )
+    def test_dft(
+        self,
+        version: int,
+        input_shape: tuple[int],
+        axis: int | None,
+        onesided: int | None,
+        inverse: int | None,
+        expected_shape: tuple[int],
+    ) -> None:
+        # Build the attributes for different opset versions
+        attributes = {}
+        if onesided is not None:
+            attributes["onesided"] = onesided
+        if inverse is not None:
+            attributes["inverse"] = inverse
+
+        if version < 20:
+            if axis is not None:
+                attributes["axis"] = axis
+            nodes = [make_node("DFT", ["input", ""], ["output"], **attributes)]
+            value_infos = []
+        else:
+            assert version >= 20
+            if axis is not None:
+                nodes = [
+                    make_node(
+                        "Constant",
+                        [],
+                        ["axis"],
+                        value=make_tensor("axis", TensorProto.INT64, (), (axis,)),
+                    ),
+                    make_node("DFT", ["input", "", "axis"], ["output"], **attributes),
+                ]
+                value_infos = [make_tensor_value_info("axis", TensorProto.INT64, ())]
+            else:
+                nodes = [
+                    make_node("DFT", ["input", "", ""], ["output"], **attributes),
+                ]
+                value_infos = []
+
+        # Construct the graph
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        input_shape,
+                        np.ones(input_shape, dtype=np.float32).flatten(),
+                    ),
+                ),
+                *nodes,
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("input", TensorProto.FLOAT, input_shape),
+                *value_infos,
+                make_tensor_value_info("output", TensorProto.FLOAT, expected_shape),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("version", all_versions_for("DFT"))
+    @pytest.mark.parametrize(
+        "input_shape, axis, onesided, inverse, expected_shape",
+        [
+            ((2, 5, 1), None, None, None, (2, 42, 2)),
+            ((3, 5, 10, 1), 0, 0, 0, (42, 5, 10, 2)),
+            ((3, 5, 10, 1), 1, 0, 0, (3, 42, 10, 2)),
+            ((3, 5, 10, 1), 2, 0, 0, (3, 5, 42, 2)),
+            ((3, 5, 10, 1), -2, 0, 0, (3, 5, 42, 2)),
+            ((3, 5, 10, 1), 0, 1, 0, (22, 5, 10, 2)),
+            ((3, 5, 10, 1), 1, 1, 0, (3, 22, 10, 2)),
+            ((3, 5, 10, 1), 2, 1, 0, (3, 5, 22, 2)),
+            ((3, 5, 10, 1), -2, 1, 0, (3, 5, 22, 2)),
+            ((2, 5, 2), None, None, None, (2, 42, 2)),
+            ((2, 5, 1), 1, None, 1, (2, 42, 2)),
+            ((2, 5, 2), 1, None, 1, (2, 42, 2)),
+            ((2, 5, 10, 2), 0, 1, 1, (42, 5, 10, 1)),
+            ((3, 3, 10, 2), 1, 1, 1, (3, 42, 10, 1)),
+            ((3, 5, 6, 2), 2, 1, 1, (3, 5, 42, 1)),
+            ((3, 5, 6, 2), -2, 1, 1, (3, 5, 42, 1)),
+        ],
+    )
+    def test_dft_dft_length(
+        self,
+        version: int,
+        input_shape: tuple[int],
+        axis: int | None,
+        onesided: int | None,
+        inverse: int | None,
+        expected_shape: tuple[int],
+    ) -> None:
+        # Build the attributes for different opset versions
+        attributes = {}
+        if onesided is not None:
+            attributes["onesided"] = onesided
+        if inverse is not None:
+            attributes["inverse"] = inverse
+
+        dft_length = 42
+
+        if version < 20:
+            if axis is not None:
+                attributes["axis"] = axis
+            nodes = [
+                make_node(
+                    "Constant",
+                    [],
+                    ["dft_length"],
+                    value=make_tensor(
+                        "dft_length", TensorProto.INT64, (), (dft_length,)
+                    ),
+                ),
+                make_node("DFT", ["input", "dft_length"], ["output"], **attributes),
+            ]
+            value_infos = [make_tensor_value_info("dft_length", TensorProto.INT64, ())]
+        else:
+            assert version >= 20
+            if axis is not None:
+                nodes = [
+                    make_node(
+                        "Constant",
+                        [],
+                        ["axis"],
+                        value=make_tensor("axis", TensorProto.INT64, (), (axis,)),
+                    ),
+                    make_node(
+                        "Constant",
+                        [],
+                        ["dft_length"],
+                        value=make_tensor(
+                            "dft_length", TensorProto.INT64, (), (dft_length,)
+                        ),
+                    ),
+                    make_node(
+                        "DFT",
+                        ["input", "dft_length", "axis"],
+                        ["output"],
+                        **attributes,
+                    ),
+                ]
+                value_infos = [
+                    make_tensor_value_info("dft_length", TensorProto.INT64, ()),
+                    make_tensor_value_info("axis", TensorProto.INT64, ()),
+                ]
+            else:
+                nodes = [
+                    make_node(
+                        "Constant",
+                        [],
+                        ["dft_length"],
+                        value=make_tensor(
+                            "dft_length", TensorProto.INT64, (), (dft_length,)
+                        ),
+                    ),
+                    make_node(
+                        "DFT",
+                        ["input", "dft_length", ""],
+                        ["output"],
+                        **attributes,
+                    ),
+                ]
+                value_infos = [
+                    make_tensor_value_info("dft_length", TensorProto.INT64, ())
+                ]
+
+        # Construct the graph
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        input_shape,
+                        np.ones(input_shape, dtype=np.float32).flatten(),
+                    ),
+                ),
+                *nodes,
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("input", TensorProto.FLOAT, input_shape),
+                *value_infos,
+                make_tensor_value_info("output", TensorProto.FLOAT, expected_shape),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+        )
+
+    @pytest.mark.parametrize("axis", [3, -1, 4, -5])
+    def test_dft_invalid_axis_opset17(self, axis: int) -> None:
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        (2, 5, 5, 2),
+                        np.ones((2, 5, 5, 2), dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node("DFT", ["input", ""], ["output"], onesided=1, axis=axis),
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._assert_inferred(
+                graph,
+                [
+                    make_tensor_value_info("input", TensorProto.FLOAT, (2, 5, 5, 2)),
+                    make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 5, 2)),
+                ],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 17)],
+            )
+
+    @pytest.mark.parametrize("axis", [3, -1, 4, -5])
+    def test_dft_invalid_axis_opset20(self, axis: int) -> None:
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        (2, 5, 5, 2),
+                        np.ones((2, 5, 5, 2), dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["axis"],
+                    value=make_tensor("axis", TensorProto.INT64, (), (axis,)),
+                ),
+                make_node("DFT", ["input", "", "axis"], ["output"]),
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._assert_inferred(
+                graph,
+                [
+                    make_tensor_value_info("input", TensorProto.FLOAT, (2, 5, 5, 2)),
+                    make_tensor_value_info("axis", TensorProto.INT64, ()),
+                    make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 5, 2)),
+                ],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 20)],
+            )
+
+    def test_dft_rfft_invalid_complex_input_opset17(self) -> None:
+        """Test that RFFT (onesided=1, inverse=0) rejects complex input"""
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        (2, 5, 2),  # Complex input (last dim = 2)
+                        np.ones((2, 5, 2), dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node("DFT", ["input", ""], ["output"], onesided=1, axis=1),
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._assert_inferred(
+                graph,
+                [
+                    make_tensor_value_info("input", TensorProto.FLOAT, (2, 5, 2)),
+                    make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 2)),
+                ],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 17)],
+            )
+
+    def test_dft_rfft_invalid_complex_input_opset20(self) -> None:
+        """Test that RFFT (onesided=1, inverse=0) rejects complex input"""
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        (2, 5, 2),  # Complex input (last dim = 2)
+                        np.ones((2, 5, 2), dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["axis"],
+                    value=make_tensor("axis", TensorProto.INT64, (), (1,)),
+                ),
+                make_node("DFT", ["input", "", "axis"], ["output"], onesided=1),
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._assert_inferred(
+                graph,
+                [
+                    make_tensor_value_info("input", TensorProto.FLOAT, (2, 5, 2)),
+                    make_tensor_value_info("axis", TensorProto.INT64, ()),
+                    make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 2)),
+                ],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 20)],
+            )
+
+    def test_dft_irfft_invalid_real_input_opset17(self) -> None:
+        """Test that IRFFT (onesided=1, inverse=1) rejects real input"""
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        (2, 5, 1),  # Real input (last dim = 1)
+                        np.ones((2, 5, 1), dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node(
+                    "DFT", ["input", ""], ["output"], onesided=1, inverse=1, axis=1
+                ),
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._assert_inferred(
+                graph,
+                [
+                    make_tensor_value_info("input", TensorProto.FLOAT, (2, 5, 1)),
+                    make_tensor_value_info("output", TensorProto.FLOAT, (2, 8, 1)),
+                ],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 17)],
+            )
+
+    def test_dft_irfft_invalid_real_input_opset20(self) -> None:
+        """Test that IRFFT (onesided=1, inverse=1) rejects real input"""
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        (2, 5, 1),  # Real input (last dim = 1)
+                        np.ones((2, 5, 1), dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["axis"],
+                    value=make_tensor("axis", TensorProto.INT64, (), (1,)),
+                ),
+                make_node(
+                    "DFT", ["input", "", "axis"], ["output"], onesided=1, inverse=1
+                ),
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._assert_inferred(
+                graph,
+                [
+                    make_tensor_value_info("input", TensorProto.FLOAT, (2, 5, 1)),
+                    make_tensor_value_info("axis", TensorProto.INT64, ()),
+                    make_tensor_value_info("output", TensorProto.FLOAT, (2, 8, 1)),
+                ],
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 20)],
+            )
+
+    @pytest.mark.parametrize("shape", [(2, 5, 5, 1), (2, 5, 5, 2)])
+    def test_dft_dynamic_axis_opset20(self, shape: tuple[int, ...]) -> None:
+        graph = self._make_graph(
+            [("axis", TensorProto.INT64, ())],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        shape,
+                        np.ones(shape, dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node("DFT", ["input", "", "axis"], ["output"]),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("input", TensorProto.FLOAT, shape),
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 5, 5, 2)),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 20)],
+        )
+
+    @pytest.mark.parametrize("shape", [(2, 5, 5, 1)])
+    def test_dft_dynamic_axis_onesided_dft_length_opset20(
+        self, shape: tuple[int, ...]
+    ) -> None:
+        graph = self._make_graph(
+            [("axis", TensorProto.INT64, ())],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        shape,
+                        np.ones(shape, dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["dft_length"],
+                    value=make_tensor(
+                        "dft_length",
+                        TensorProto.INT64,
+                        (),
+                        np.array([42], dtype=np.int64),
+                    ),
+                ),
+                make_node(
+                    "DFT", ["input", "dft_length", "axis"], ["output"], onesided=1
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("input", TensorProto.FLOAT, shape),
+                make_tensor_value_info("dft_length", TensorProto.INT64, ()),
+                make_tensor_value_info(
+                    "output", TensorProto.FLOAT, (None, None, None, 2)
+                ),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 20)],
+        )
+
+    @pytest.mark.parametrize("shape", [(2, 5, 5, 1)])
+    def test_dft_dynamic_axis_onesided_opset20(self, shape: tuple[int, ...]) -> None:
+        graph = self._make_graph(
+            [("axis", TensorProto.INT64, ())],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        shape,
+                        np.ones(shape, dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node("DFT", ["input", "", "axis"], ["output"], onesided=1),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("input", TensorProto.FLOAT, shape),
+                make_tensor_value_info(
+                    "output", TensorProto.FLOAT, (None, None, None, 2)
+                ),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 20)],
+        )
+
+    def test_dft_onesided_default_axis_opset17(self) -> None:
+        # Opset 17 sets default axis to be 1.
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        (2, 5, 5, 1),
+                        np.ones((2, 5, 5, 1), dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node("DFT", ["input", ""], ["output"], onesided=1),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("input", TensorProto.FLOAT, (2, 5, 5, 1)),
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 5, 2)),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 17)],
+        )
+
+    def test_dft_onesided_default_axis_opset20(self) -> None:
+        # Opset 20 sets default axis to be -2.
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["input"],
+                    value=make_tensor(
+                        "input",
+                        TensorProto.FLOAT,
+                        (2, 5, 5, 1),
+                        np.ones((2, 5, 5, 1), dtype=np.float32).flatten(),
+                    ),
+                ),
+                make_node("DFT", ["input", "", ""], ["output"], onesided=1),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("input", TensorProto.FLOAT, (2, 5, 5, 1)),
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 5, 3, 2)),
+            ],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 20)],
+        )
+
+    def test_stft_reals(self):
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["signal"],
+                    value=make_tensor(
+                        "signal",
+                        TensorProto.FLOAT,
+                        (2, 10, 1),
+                        (0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3),
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["frame_step"],
+                    value=make_tensor("frame_step", TensorProto.INT64, (), (2,)),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["window"],
+                    value=make_tensor(
+                        "window", TensorProto.INT64, (5,), (1, 2, 3, 4, 5)
+                    ),
+                ),
+                make_node("STFT", ["signal", "frame_step", "window"], ["output"]),
+            ],
+            [],
+        )
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("signal", TensorProto.FLOAT, (2, 10, 1)),
+                make_tensor_value_info("frame_step", TensorProto.INT64, ()),
+                make_tensor_value_info("window", TensorProto.INT64, (5,)),
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 5, 2)),
+            ],
+        )
+
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["signal"],
+                    value=make_tensor(
+                        "signal",
+                        TensorProto.FLOAT,
+                        (2, 10, 1),
+                        (0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3),
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["frame_step"],
+                    value=make_tensor("frame_step", TensorProto.INT64, (), (2,)),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["window"],
+                    value=make_tensor(
+                        "window", TensorProto.INT64, (5,), (1, 2, 3, 4, 5)
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["frame_length"],
+                    value=make_tensor("frame_length", TensorProto.INT64, (), (5,)),
+                ),
+                make_node("STFT", ["signal", "frame_step", "window"], ["output"]),
+            ],
+            [],
+        )
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("signal", TensorProto.FLOAT, (2, 10, 1)),
+                make_tensor_value_info("frame_step", TensorProto.INT64, ()),
+                make_tensor_value_info("window", TensorProto.INT64, (5,)),
+                make_tensor_value_info("frame_length", TensorProto.INT64, ()),
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 5, 2)),
+            ],
+        )
+
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["signal"],
+                    value=make_tensor(
+                        "signal",
+                        TensorProto.FLOAT,
+                        (2, 10, 1),
+                        (0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3),
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["frame_step"],
+                    value=make_tensor("frame_step", TensorProto.INT64, (), (2,)),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["frame_length"],
+                    value=make_tensor("frame_length", TensorProto.INT64, (), (5,)),
+                ),
+                make_node(
+                    "STFT", ["signal", "frame_step", "", "frame_length"], ["output"]
+                ),
+            ],
+            [],
+        )
+
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("signal", TensorProto.FLOAT, (2, 10, 1)),
+                make_tensor_value_info("frame_step", TensorProto.INT64, ()),
+                make_tensor_value_info("frame_length", TensorProto.INT64, ()),
+                make_tensor_value_info("output", TensorProto.FLOAT, (2, 3, 5, 2)),
+            ],
+        )
+
+    def test_melweightmatrix(self):
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["num_mel_bins"],
+                    value=make_tensor("num_mel_bins", TensorProto.INT64, (), (10,)),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["dft_length"],
+                    value=make_tensor("dft_length", TensorProto.INT64, (), (128,)),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["sample_rate"],
+                    value=make_tensor("sample_rate", TensorProto.INT64, (), (10,)),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["lower_edge_hertz"],
+                    value=make_tensor(
+                        "lower_edge_hertz", TensorProto.FLOAT, (), (10.0,)
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["upper_edge_hertz"],
+                    value=make_tensor(
+                        "upper_edge_hertz", TensorProto.FLOAT, (), (100.0,)
+                    ),
+                ),
+                make_node(
+                    "MelWeightMatrix",
+                    [
+                        "num_mel_bins",
+                        "dft_length",
+                        "sample_rate",
+                        "lower_edge_hertz",
+                        "upper_edge_hertz",
+                    ],
+                    ["output"],
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("num_mel_bins", TensorProto.INT64, ()),
+                make_tensor_value_info("dft_length", TensorProto.INT64, ()),
+                make_tensor_value_info("sample_rate", TensorProto.INT64, ()),
+                make_tensor_value_info("lower_edge_hertz", TensorProto.FLOAT, ()),
+                make_tensor_value_info("upper_edge_hertz", TensorProto.FLOAT, ()),
+                make_tensor_value_info("output", TensorProto.FLOAT, (65, 10)),
+            ],
+        )
+
+    def test_melweightmatrix_with_output_datatype(self):
+        graph = self._make_graph(
+            [],
+            [
+                make_node(
+                    "Constant",
+                    [],
+                    ["num_mel_bins"],
+                    value=make_tensor("num_mel_bins", TensorProto.INT64, (), (10,)),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["dft_length"],
+                    value=make_tensor("dft_length", TensorProto.INT64, (), (128,)),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["sample_rate"],
+                    value=make_tensor("sample_rate", TensorProto.INT64, (), (10,)),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["lower_edge_hertz"],
+                    value=make_tensor(
+                        "lower_edge_hertz", TensorProto.FLOAT, (), (10.0,)
+                    ),
+                ),
+                make_node(
+                    "Constant",
+                    [],
+                    ["upper_edge_hertz"],
+                    value=make_tensor(
+                        "upper_edge_hertz", TensorProto.FLOAT, (), (100.0,)
+                    ),
+                ),
+                make_node(
+                    "MelWeightMatrix",
+                    [
+                        "num_mel_bins",
+                        "dft_length",
+                        "sample_rate",
+                        "lower_edge_hertz",
+                        "upper_edge_hertz",
+                    ],
+                    ["output"],
+                    output_datatype=TensorProto.DOUBLE,
+                ),
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("num_mel_bins", TensorProto.INT64, ()),
+                make_tensor_value_info("dft_length", TensorProto.INT64, ()),
+                make_tensor_value_info("sample_rate", TensorProto.INT64, ()),
+                make_tensor_value_info("lower_edge_hertz", TensorProto.FLOAT, ()),
+                make_tensor_value_info("upper_edge_hertz", TensorProto.FLOAT, ()),
+                make_tensor_value_info("output", TensorProto.DOUBLE, (65, 10)),
+            ],
+        )
+
+    def test_center_crop_pad_hwc_crop(self):
+        graph = self._make_graph(
+            [
+                ("input_data", TensorProto.FLOAT, (20, 10, 3)),
+                ("shape", TensorProto.INT64, (2,)),
+            ],
+            [make_node("CenterCropPad", ["input_data", "shape"], ["y"], axes=[0, 1])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (2,), (10, 8))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (10, 8, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 18)],
+        )
+
+    def test_center_crop_pad_chw_crop(self):
+        graph = self._make_graph(
+            [
+                ("input_data", TensorProto.FLOAT, (3, 20, 10)),
+                ("shape", TensorProto.INT64, (2,)),
+            ],
+            [make_node("CenterCropPad", ["input_data", "shape"], ["y"], axes=[1, 2])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (2,), (10, 8))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (3, 10, 8))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 18)],
+        )
+
+    def test_center_crop_pad_hwc_croppad(self):
+        graph = self._make_graph(
+            [
+                ("input_data", TensorProto.FLOAT, (10, 10, 3)),
+                ("shape", TensorProto.INT64, (2,)),
+            ],
+            [make_node("CenterCropPad", ["input_data", "shape"], ["y"], axes=[0, 1])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (2,), (20, 8))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (20, 8, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 18)],
+        )
+
+    def test_center_crop_pad_chw_croppad(self):
+        graph = self._make_graph(
+            [
+                ("input_data", TensorProto.FLOAT, (3, 10, 10)),
+                ("shape", TensorProto.INT64, (2,)),
+            ],
+            [make_node("CenterCropPad", ["input_data", "shape"], ["y"], axes=[1, 2])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (2,), (20, 8))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (3, 20, 8))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 18)],
+        )
+
+    def test_center_crop_pad_without_input_shape(self):
+        graph = self._make_graph(
+            [
+                ("input_data", TensorProto.FLOAT, (3, 2)),
+                ("shape", TensorProto.INT64, (2,)),
+            ],
+            [make_node("CenterCropPad", ["input_data", "shape"], ["y"])],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, None)],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 18)],
+        )
+
+    def test_center_crop_pad_with_input_shape_containing_dim_params(
+        self,
+    ):
+        graph = self._make_graph(
+            [
+                ("input_data", TensorProto.FLOAT, (20, "W", 3)),
+                ("shape", TensorProto.INT64, (2,)),
+            ],
+            [make_node("CenterCropPad", ["input_data", "shape"], ["y"], axes=[0, 1])],
+            [],
+            initializer=[make_tensor("shape", TensorProto.INT64, (2,), (10, 8))],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (10, 8, 3))],
+            opset_imports=[helper.make_opsetid(ONNX_DOMAIN, 18)],
+        )
+
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_category_mapper(self) -> None:
+        cat = make_node(
+            "CategoryMapper",
+            ["x"],
+            ["y"],
+            domain=ONNX_ML_DOMAIN,
+            cats_int64s=[1, 2, 3],
+            cats_strings=["1", "2", "3"],
+        )
+        graph_int = self._make_graph(
+            [("x", TensorProto.INT64, (30, 4, 5))],
+            [cat],
+            [],
+        )
+        self._assert_inferred(
+            graph_int,
+            [make_tensor_value_info("y", TensorProto.STRING, (30, 4, 5))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 1),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+        graph_str = self._make_graph(
+            [("x", TensorProto.STRING, (30, 5, 4))],
+            [cat],
+            [],
+        )
+        self._assert_inferred(
+            graph_str,
+            [make_tensor_value_info("y", TensorProto.INT64, (30, 5, 4))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 1),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+    @pytest.mark.parametrize(
+        "cats_int64s, cats_strings",
+        [
+            ([1, 2, 3], ["1", "2"]),
+            ([1, 2, 3], None),
+            (None, ["1", "2", "3"]),
+            (None, None),
+        ],
+    )
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_category_mapper_fails_if_invalid_attributes(
+        self, cats_int64s, cats_strings
+    ) -> None:
+        cat = make_node(
+            "CategoryMapper",
+            ["x"],
+            ["y"],
+            domain=ONNX_ML_DOMAIN,
+            cats_int64s=cats_int64s,
+            cats_strings=cats_strings,
+        )
+        graph = self._make_graph(
+            [("x", TensorProto.INT64, (30, 4, 5))],
+            [cat],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[
+                    make_opsetid(ONNX_ML_DOMAIN, 1),
+                    make_opsetid(ONNX_DOMAIN, 11),
+                ],
+            )
+
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_tree_ensemble_regressor(self) -> None:
+        tree = make_node(
+            "TreeEnsembleRegressor",
+            ["x"],
+            ["y"],
+            domain=ONNX_ML_DOMAIN,
+            n_targets=5,
+        )
+        graph = self._make_graph(
+            [("x", TensorProto.DOUBLE, (30, 3))],
+            [tree],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.FLOAT, (30, 5))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 3),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+    @pytest.mark.parametrize(
+        "dtype", [TensorProto.FLOAT, TensorProto.DOUBLE, TensorProto.FLOAT16]
+    )
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_tree_ensemble(self, dtype) -> None:
+        interior_nodes = 5
+        leaves = 9
+        tree = make_node(
+            "TreeEnsemble",
+            ["x"],
+            ["y"],
+            domain=ONNX_ML_DOMAIN,
+            n_targets=5,
+            nodes_featureids=[0] * interior_nodes,
+            nodes_splits=make_tensor(
+                "nodes_splits",
+                dtype,
+                (interior_nodes,),
+                list(range(interior_nodes)),
+            ),
+            nodes_modes=make_tensor(
+                "nodes_modes",
+                TensorProto.UINT8,
+                (interior_nodes,),
+                [0] * interior_nodes,
+            ),
+            nodes_truenodeids=[0] * interior_nodes,
+            nodes_falsenodeids=[0] * interior_nodes,
+            nodes_trueleafs=[0] * interior_nodes,
+            nodes_falseleafs=[0] * interior_nodes,
+            membership_values=make_tensor(
+                "membership_values",
+                dtype,
+                (7,),
+                [0.0, 0.1, 0.2, np.nan, 0.4, 0.5, 1.0],
+            ),
+            leaf_targetids=[0] * leaves,
+            leaf_weights=make_tensor("leaf_weights", dtype, (leaves,), [1] * leaves),
+            tree_roots=[0],
+        )
+
+        graph = self._make_graph(
+            [("x", dtype, ("Batch Size", "Features"))],
+            [tree],
+            [],
+        )
+
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", dtype, ("Batch Size", 5))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 5),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+    @pytest.mark.parametrize(
+        "nodes_truenodeids, leaf_weights, nodes_splits",
+        [
+            (
+                [0] * 6,
+                make_tensor("leaf_weights", TensorProto.DOUBLE, (9,), [1] * 9),
+                make_tensor("nodes_splits", TensorProto.DOUBLE, (5,), [1] * 5),
+            ),
+            (
+                [0] * 5,
+                make_tensor("leaf_weights", TensorProto.FLOAT, (9,), [1] * 9),
+                make_tensor("nodes_splits", TensorProto.DOUBLE, (5,), [1] * 5),
+            ),
+            (
+                [0] * 5,
+                make_tensor("leaf_weights", TensorProto.DOUBLE, (18,), [1] * 18),
+                make_tensor("nodes_splits", TensorProto.DOUBLE, (5,), [1] * 5),
+            ),
+            (
+                [0] * 5,
+                make_tensor("leaf_weights", TensorProto.DOUBLE, (9,), [1] * 9),
+                make_tensor("nodes_splits", TensorProto.FLOAT, (5,), [1] * 5),
+            ),
+        ],
+    )
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_tree_ensemble_fails_if_invalid_attributes(
+        self,
+        nodes_truenodeids,
+        leaf_weights,
+        nodes_splits,
+    ) -> None:
+        interior_nodes = 5
+        leaves = 9
+        tree = make_node(
+            "TreeEnsemble",
+            ["x"],
+            ["y"],
+            domain=ONNX_ML_DOMAIN,
+            n_targets=5,
+            nodes_featureids=[0] * interior_nodes,
+            nodes_splits=nodes_splits,
+            nodes_modes=make_tensor(
+                "nodes_modes",
+                TensorProto.UINT8,
+                (interior_nodes,),
+                [0] * interior_nodes,
+            ),
+            nodes_truenodeids=nodes_truenodeids,
+            nodes_falsenodeids=[0] * interior_nodes,
+            nodes_trueleafs=[0] * interior_nodes,
+            nodes_falseleafs=[0] * interior_nodes,
+            leaf_targetids=[0] * leaves,
+            leaf_weights=leaf_weights,
+            tree_roots=[0],
+        )
+
+        graph = self._make_graph(
+            [("x", TensorProto.DOUBLE, ("Batch Size", "Features"))],
+            [tree],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[
+                    make_opsetid(ONNX_ML_DOMAIN, 5),
+                    make_opsetid(ONNX_DOMAIN, 11),
+                ],
+            )
+
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_tree_ensemble_classifier(self) -> None:
+        tree = make_node(
+            "TreeEnsembleClassifier",
+            ["x"],
+            ["y", "z"],
+            classlabels_int64s=[0, 1, 2, 3, 4],
+            domain=ONNX_ML_DOMAIN,
+        )
+        graph = self._make_graph(
+            [("x", TensorProto.DOUBLE, (30, 3))],
+            [tree],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info("y", TensorProto.INT64, (30,)),
+                make_tensor_value_info("z", TensorProto.FLOAT, (30, 5)),
+            ],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 3),
+                make_opsetid(ONNX_DOMAIN, 11),
+            ],
+        )
+
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_array_feature_extractor(self) -> None:
+        node = make_node(
+            "ArrayFeatureExtractor",
+            ["x", "y"],
+            ["z"],
+            domain=ONNX_ML_DOMAIN,
+        )
+        for axes_shape, expected in [
+            ((2,), 2),
+            ((), "unk__0"),
+            (("N",), "N"),
+        ]:
+            graph = self._make_graph(
+                [
+                    ("x", TensorProto.INT64, (3, 4, 5)),
+                    ("y", TensorProto.INT64, axes_shape),
+                ],
+                [node],
+                [],
+            )
+            self._assert_inferred(
+                graph,
+                [make_tensor_value_info("z", TensorProto.INT64, (3, 4, expected))],
+                opset_imports=[
+                    make_opsetid(ONNX_ML_DOMAIN, 3),
+                    make_opsetid(ONNX_DOMAIN, 18),
+                ],
+            )
+
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_binarizer(self) -> None:
+        node = make_node(
+            "Binarizer",
+            ["x"],
+            ["y"],
+            domain=ONNX_ML_DOMAIN,
+        )
+        graph = self._make_graph(
+            [
+                ("x", TensorProto.INT64, (3, 4, 5)),
+            ],
+            [node],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("y", TensorProto.INT64, (3, 4, 5))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 3),
+                make_opsetid(ONNX_DOMAIN, 18),
+            ],
+        )
+
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_one_hot_encoder(self) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.INT64, (2, "N", 3))],
+            [
+                make_node(
+                    "OneHotEncoder",
+                    ["input"],
+                    ["output"],
+                    cats_int64s=[1, 2, 3, 4],
+                    domain="ai.onnx.ml",
+                )
+            ],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("output", TensorProto.FLOAT, (2, "N", 3, 4))],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 1),
+                make_opsetid(ONNX_DOMAIN, 18),
+            ],
+        )
+
+    @pytest.mark.parametrize(
+        "cats_int64s, cats_strings",
+        [
+            ([1, 2, 3], ["1", "2", "3"]),
+            (None, None),
+        ],
+    )
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_one_hot_encoder_fails_if_invalid_attributes(
+        self, cats_int64s, cats_strings
+    ) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.INT64, (2, "N", 3))],
+            [
+                make_node(
+                    "OneHotEncoder",
+                    ["input"],
+                    ["output"],
+                    cats_int64s=cats_int64s,
+                    cats_strings=cats_strings,
+                    domain="ai.onnx.ml",
+                )
+            ],
+            [],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[
+                    make_opsetid(ONNX_ML_DOMAIN, 1),
+                    make_opsetid(ONNX_DOMAIN, 11),
+                ],
+            )
+
+    @pytest.mark.parametrize(
+        "attrs, input_type",
+        [
+            ({"classlabels_int64s": [1, 2, 3]}, onnx.TensorProto.INT64),
+            ({"classlabels_strings": ["a", "b", "c"]}, onnx.TensorProto.STRING),
+        ],
+    )
+    @pytest.mark.skipif(
+        not ONNX_ML, reason="ONNX_ML required to test ai.onnx.ml operators"
+    )
+    def test_zip_map(self, attrs, input_type) -> None:
+        graph = self._make_graph(
+            [("input", TensorProto.FLOAT, ("N", 3))],
+            [
+                make_node(
+                    "ZipMap",
+                    ["input"],
+                    ["output"],
+                    **attrs,
+                    domain="ai.onnx.ml",
+                )
+            ],
+            [],
+        )
+        typ = onnx.helper.make_map_type_proto(
+            input_type, onnx.helper.make_tensor_type_proto(TensorProto.FLOAT, ())
+        )
+        self._assert_inferred(
+            graph,
+            [
+                onnx.helper.make_value_info(
+                    "output", onnx.helper.make_sequence_type_proto(typ)
+                )
+            ],
+            opset_imports=[
+                make_opsetid(ONNX_ML_DOMAIN, 1),
+                make_opsetid(ONNX_DOMAIN, 18),
+            ],
+        )
+
+    def test_compress_without_axis(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.INT64, (2, "N", 3, 4)),
+                ("condition", TensorProto.BOOL, (None,)),
+            ],
+            [make_node("Compress", ["input", "condition"], ["output"])],
+            [],
+        )
+        self._assert_inferred(
+            graph, [make_tensor_value_info("output", TensorProto.INT64, (None,))]
+        )
+
+    def test_compress_with_axis(self) -> None:
+        graph = self._make_graph(
+            [
+                ("input", TensorProto.INT64, (2, "N", 3, 4)),
+                ("condition", TensorProto.BOOL, (None,)),
+            ],
+            [make_node("Compress", ["input", "condition"], ["output"], axis=-1)],
+            [],
+        )
+        self._assert_inferred(
+            graph,
+            [make_tensor_value_info("output", TensorProto.INT64, (2, "N", 3, None))],
+        )
+
+    def test_check_type_when_schema_has_empty_io(self):
+        input = """
+            <
+                ir_version: 7,
+                opset_import: ["" : 1]
+            >
+            agraph (X, Y) => (Z)
+            {
+                Z = CustomOp(X, Y)
+            }
+           """
+        model = onnx.parser.parse_model(input)
+
+        op_schema = defs.OpSchema(
+            "CustomOp",
+            "",
+            1,
+            inputs=[],
+            outputs=[],
+        )
+        onnx.defs.register_schema(op_schema)
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(model, True)
+        onnx.defs.deregister_schema(
+            op_schema.name, op_schema.since_version, op_schema.domain
+        )
+
+    def test_issue_layer_normalization_6187(self):
+        modeltxt = """
+        <
+        ir_version: 10,
+        opset_import: ["" : 17]
+        >
+        graph (float in0, float[2,7,8,1,3] in1, float[3,7] in2) => () {
+        out0, out1, out2 = LayerNormalization <epsilon: float = -841.058, stash_type: int = -940> (in0, in1, in2)
+        }
+        """
+        model = onnx.parser.parse_model(modeltxt)
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.checker.check_model(model, full_check=True)
+            onnx.shape_inference.infer_shapes(model)
+
+    def test_issue_conv_6180(self):
+        modeltxt = """
+        <
+        ir_version: 9,
+        opset_import: ["" : 11]
+        >
+        graph (float[7,6,1,5] in0, float in1, float[7,2,3,2,1] in2) => () {
+        out0 = Conv <auto_pad = "NOTSET", group = 1> (in0, in1, in2)
+        }
+        """
+        model = onnx.parser.parse_model(modeltxt)
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.checker.check_model(model, full_check=True)
+            onnx.shape_inference.infer_shapes(model)
+
+    def test_issue_gemm_6185(self):
+        modeltxt = """
+        <
+        ir_version: 10,
+        opset_import: ["" : 6]
+        >
+        graph (double[2,1] in0, double in1, double[2] in2) => () {
+        out0 = Gemm <alpha: float = 1, beta: float = -693.752, broadcast: int = -436, transB: int = 823> (in0, in1, in2)
+        }
+        """
+        model = onnx.parser.parse_model(modeltxt)
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.checker.check_model(model, full_check=True)
+            onnx.shape_inference.infer_shapes(model)
+
+    def test_issue_stft_6186(self):
+        modeltxt = """
+        <
+        ir_version: 10,
+        opset_import: ["" : 17]
+        >
+        graph (float16[3] in0, int32[2] in1, float16[7,8,8,8] in2, int32[8,1,7,2] in3) => () {
+        out0 = STFT (in0, in1, in2, in3)
+        }
+        """
+        model = onnx.parser.parse_model(modeltxt)
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.checker.check_model(model, full_check=True)
+            onnx.shape_inference.infer_shapes(model)
+
+    @pytest.mark.parametrize("version", all_versions_for("ConstantOfShape"))
+    def test_issue_constantofshape_6135(self, version):
+        graph = self._make_graph(
+            [("std.constant", TensorProto.INT64, (1,)), "output"],
+            [
+                make_node(
+                    "ConstantOfShape",
+                    inputs=["std.constant"],
+                    outputs=["output"],
+                    name="invalid_node",
+                )
+            ],
+            [],
+            initializer=[make_tensor("std.constant", TensorProto.FLOAT, (1,), (-10,))],
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            self._inferred(
+                graph,
+                opset_imports=[helper.make_opsetid(ONNX_DOMAIN, version)],
+            )
+
+    def test_protobuf_default(self) -> None:
+        model_text = """
+            ir_version: 8
+            producer_name: "test"
+            graph {
+              node {
+                input: "in"
+                output: "out"
+                op_type: "Flatten"
+                attribute {
+                  name: "axis"
+                  type: INT
+                }
+              }
+              name: "g"
+              input {
+                name: "in"
+                type {
+                  tensor_type {
+                    elem_type: 1
+                    shape {
+                      dim {
+                        dim_value: 2
+                      }
+                      dim {
+                        dim_value: 3
+                      }
+                    }
+                  }
+                }
+              }
+              output {
+                name: "out"
+                type {
+                  tensor_type {
+                    elem_type: 1
+                    shape {
+                      dim {
+                        dim_value: 1
+                      }
+                      dim {
+                        dim_value: 6
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            opset_import {
+              version: 18
+            }
+        """
+        model = text_format.Parse(model_text, onnx.ModelProto())
+        self._assert_inferred(model, [])
+
+    def test_infer_shapes_rejects_cyclic_function(self):
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 17, "local" : 1 ]>
+            agraph (float[N] X) => (float[N] Y) { Y = local.foo (X) }
+            <opset_import: [ "" : 17, "local" : 1 ], domain: "local">
+            foo (x) => (y) { y = local.foo (x) }
+        """
+        )
+        with pytest.raises(onnx.checker.ValidationError):
+            onnx.shape_inference.infer_shapes(model)
+
+    @pytest.mark.parametrize("attrs", ["", "num_scan_inputs = -1, "])
+    def test_scan_invalid_num_scan_inputs_does_not_crash(self, attrs):
+        # Missing attr null-derefs; -1 overflows size_t. Both must raise, not crash.
+        scan_body = (
+            "body = b (float[1] si, float[1] xi) => (float[1] so, float[1] xo) "
+            "{ so = Identity(si) xo = Identity(xi) }"
+        )
+        model = onnx.parser.parse_model(
+            f"""
+            <ir_version: 8, opset_import: [ "" : 9 ]>
+            g (float[1] s, float[3,1] x) => (float[1] so, float[3,1] xo) {{
+                so, xo = Scan <{attrs}{scan_body}> (s, x)
+            }}
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(model, strict_mode=True)
+
+    def test_function_output_count_mismatch_does_not_crash(self):
+        # Function declares 2 outputs; calling node declares 1.
+        # Must raise InferenceError on the second output, not crash.
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 18, "local" : 1 ]>
+            agraph (float[1] X) => (float[1] Y) { Y = local.F (X) }
+            <opset_import: [ "" : 18 ], domain: "local">
+            F (x) => (y1, y2) { y1 = Identity(x) y2 = Identity(x) }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(model, strict_mode=True)
+
+    def test_conv_transpose_undersized_weight_raises(self):
+        # Weight rank < 3 violates ConvTranspose spec (C x M/group x k1...kn).
+        model = onnx.parser.parse_model(
+            """
+            <ir_version: 8, opset_import: [ "" : 11 ]>
+            g (float[1,1,5] X, float[1,3] W) => (float[1,1,?] Y) { Y = ConvTranspose(X, W) }
+            """
+        )
+        with pytest.raises(onnx.shape_inference.InferenceError):
+            onnx.shape_inference.infer_shapes(model, strict_mode=True)
+
+    def test_infer_shapes_pathlike_error(self) -> None:
+        with pytest.raises(
+            TypeError,
+            match=r"For Model paths \(str or os.PathLike\), use infer_shapes_path\(\)\.",
+        ):
+            onnx.shape_inference.infer_shapes(Path("model.onnx"))
+
+
+class TestCustomSchemaShapeInference(TestShapeInferenceHelper):
+    custom_op_type: str = "CustomOp"
+    dummy_graph_op_type: str = "DummyGraph"
+    op_version: int = 1
+    op_domain: str = ""
+
+    @pytest.fixture(autouse=True)
+    def schema_cleanup(self):
+        # Ensure the schema is unregistered
+        assert not onnx.defs.has(self.custom_op_type, self.op_domain)
+        assert not onnx.defs.has(self.dummy_graph_op_type, self.op_domain)
+        yield
+
+        # Clean up the registered schema
+        with contextlib.suppress(onnx.defs.SchemaError):
+            onnx.defs.deregister_schema(
+                self.custom_op_type, self.op_version, self.op_domain
+            )
+            onnx.defs.deregister_schema(
+                self.dummy_graph_op_type, self.op_version, self.op_domain
+            )
+
+    def get_custom_op_schema(self):
+        # CustomOp schema:
+        #   attrs:
+        #       out_len: [L0, L1, ...]
+        #   inputs:
+        #       a[N, La]
+        #       b[N, Lb]
+        #   outputs:
+        #       out0[N, La * Lb, L0]
+        #       out1[N, La * Lb, L1]
+        #       ...
+        schema = OpSchema(
+            self.custom_op_type,
+            self.op_domain,
+            self.op_version,
+            inputs=[
+                defs.OpSchema.FormalParameter("a", "float"),
+                defs.OpSchema.FormalParameter("b", "float"),
+            ],
+            outputs=[
+                defs.OpSchema.FormalParameter(
+                    "out", "float", param_option=OpSchema.FormalParameterOption.Variadic
+                ),
+            ],
+            attributes=[
+                defs.OpSchema.Attribute("out_len", defs.OpSchema.AttrType.INTS)
+            ],
+        )
+
+        def schema_shape_infer_func(ctx: onnx.shape_inference.InferenceContext):
+            def parse_tensor_input(t: TypeProto):
+                assert isinstance(t, TypeProto)
+                return (
+                    t.tensor_type.elem_type,
+                    [
+                        d.dim_value if d.HasField("dim_value") else None
+                        for d in t.tensor_type.shape.dim
+                    ],
+                )
+
+            assert ctx.get_num_inputs() == 2
+            in0 = ctx.get_input_type(0)
+            in1 = ctx.get_input_type(1)
+            in0_type, in0_shape = parse_tensor_input(in0)
+            in1_type, in1_shape = parse_tensor_input(in1)
+            assert in0_type == TensorProto.FLOAT
+            assert in1_type == TensorProto.FLOAT
+            assert len(in0_shape) == 2
+            assert len(in1_shape) == 2
+            assert in0_shape[0] == in1_shape[0]
+            N, La = in0_shape
+            _, Lb = in1_shape
+            attr = ctx.get_attribute("out_len")
+            out_len = attr.ints
+            assert len(out_len) == ctx.get_num_outputs()
+            for i in range(ctx.get_num_outputs()):
+                out = ctx.get_output_type(i)
+                out.tensor_type.elem_type = in0_type
+                out.tensor_type.shape.dim.add().dim_value = N
+                out.tensor_type.shape.dim.add().dim_value = La * Lb
+                out.tensor_type.shape.dim.add().dim_value = out_len[i]
+                ctx.set_output_type(i, out)
+
+        schema.set_type_and_shape_inference_function(schema_shape_infer_func)
+        return schema
+
+    def get_dummy_graph_schema(self):
+        # DummyGraph schema:
+        #   attrs:
+        #       graph: OnnxGraph
+        #   inputs:
+        #       as same as the graph attribute
+        #   outputs:
+        #       as same as the graph attribute
+        schema = OpSchema(
+            self.dummy_graph_op_type,
+            self.op_domain,
+            self.op_version,
+            inputs=[
+                defs.OpSchema.FormalParameter(
+                    "in", "float", param_option=OpSchema.FormalParameterOption.Variadic
+                ),
+            ],
+            outputs=[
+                defs.OpSchema.FormalParameter(
+                    "out", "float", param_option=OpSchema.FormalParameterOption.Variadic
+                ),
+            ],
+            attributes=[defs.OpSchema.Attribute("graph", defs.OpSchema.AttrType.GRAPH)],
+        )
+
+        def schema_shape_infer_func(ctx: onnx.shape_inference.InferenceContext):
+            assert ctx.get_num_inputs() == 2
+            assert ctx.get_attribute("graph") is not None
+            gctx = ctx.get_graph_attribute_inferencer("graph")
+            outputs = gctx.do_inferencing(
+                [ctx.get_input_type(i) for i in range(ctx.get_num_inputs())],
+                [ctx.get_input_data(i) for i in range(ctx.get_num_inputs())],
+            )
+            for idx, out in enumerate(outputs):
+                ctx.set_output_type(idx, out)
+
+        schema.set_type_and_shape_inference_function(schema_shape_infer_func)
+        return schema
+
+    def gen_custom_op_graph(self, N, La, Lb, out_len, mark_output=False):
+        a = make_tensor_value_info("a", TensorProto.FLOAT, (N, La))
+        b = make_tensor_value_info("b", TensorProto.FLOAT, (N, Lb))
+        outs = [
+            make_tensor_value_info(f"out{i}", TensorProto.FLOAT, None)
+            for i in range(len(out_len))
+        ]
+        node = make_node(
+            self.custom_op_type, ["a", "b"], [v.name for v in outs], out_len=out_len
+        )
+        return make_graph(
+            [node], "test", [a, b], outs if mark_output else [], value_info=outs
+        )
+
+    def gen_dummy_graph_graph(self, N, La, Lb, out_len):
+        subgraph = self.gen_custom_op_graph(N, La, Lb, out_len, True)
+        a = make_tensor_value_info("a", TensorProto.FLOAT, (N, La))
+        b = make_tensor_value_info("b", TensorProto.FLOAT, (N, Lb))
+        outs = [
+            make_tensor_value_info(f"out{i}", TensorProto.FLOAT, None)
+            for i in range(len(out_len))
+        ]
+        node = make_node(
+            self.dummy_graph_op_type, ["a", "b"], [v.name for v in outs], graph=subgraph
+        )
+        return make_graph([node], "test", [a, b], [], value_info=outs)
+
+    def shape_infer_once(self, graph, N, La, Lb, out_len):
+        self._assert_inferred(
+            graph,
+            [
+                make_tensor_value_info(f"out{i}", TensorProto.FLOAT, (N, La * Lb, Li))
+                for i, Li in enumerate(out_len)
+            ],
+        )
+
+    def test_custom_schema_shape_inference(self) -> None:
+        # generate graph
+        N = 3
+        La = 32
+        Lb = 64
+        out_len = [1, 2]
+        graph = self.gen_custom_op_graph(N, La, Lb, out_len)
+
+        # shape inference before register
+        with pytest.raises(onnx.checker.ValidationError):
+            self.shape_infer_once(graph, N, La, Lb, out_len)
+
+        # register schema
+        schema = self.get_custom_op_schema()
+        onnx.defs.register_schema(schema)
+
+        # shape inference with registered schema
+        self.shape_infer_once(graph, N, La, Lb, out_len)
+
+        # clean up
+        onnx.defs.deregister_schema(schema.name, schema.since_version, schema.domain)
+
+    def test_dummy_graph_schema_shape_inference(self) -> None:
+        # generate graph
+        N = 3
+        La = 32
+        Lb = 64
+        out_len = [1, 2]
+        graph = self.gen_dummy_graph_graph(N, La, Lb, out_len)
+
+        # shape inference before register
+        with pytest.raises(onnx.checker.ValidationError):
+            self.shape_infer_once(graph, N, La, Lb, out_len)
+
+        # register schema
+        custom_op_schema = self.get_custom_op_schema()
+        dummy_graph_schema = self.get_dummy_graph_schema()
+        onnx.defs.register_schema(custom_op_schema)
+        onnx.defs.register_schema(dummy_graph_schema)
+
+        # shape inference with registered schema
+        self.shape_infer_once(graph, N, La, Lb, out_len)
+
+        # clean up
+        onnx.defs.deregister_schema(
+            custom_op_schema.name,
+            custom_op_schema.since_version,
+            custom_op_schema.domain,
+        )
+        onnx.defs.deregister_schema(
+            dummy_graph_schema.name,
+            dummy_graph_schema.since_version,
+            dummy_graph_schema.domain,
+        )
+
+    def test_invalid_field_in_inference_func(self) -> None:
+        N = 3
+        La = 32
+        Lb = 64
+        out_len = [1]
+        graph = self.gen_custom_op_graph(N, La, Lb, out_len)
+
+        schema = self.get_custom_op_schema()
+        raw_func = schema.get_type_and_shape_inference_function()
+
+        def schema_shape_infer_func(ctx: onnx.shape_inference.InferenceContext):
+            raw_func(ctx)
+            assert ctx.get_attribute("not-exist-attr") is None
+            assert ctx.has_input(0)
+            assert not ctx.has_input(2)
+            with pytest.raises(TypeError):
+                assert not ctx.has_input(-1)
+            assert ctx.has_output(0)
+            assert not ctx.has_output(1)
+            with pytest.raises(TypeError):
+                assert not ctx.has_output(-1)
+            with pytest.raises(onnx.shape_inference.InferenceError):
+                ctx.get_graph_attribute_inferencer("not-exist-attr")
+            assert ctx.get_input_data(0) is None
+            with pytest.raises(RuntimeError):
+                assert ctx.get_input_data(10) is None
+            assert ctx.get_input_sparse_data(0) is None
+            with pytest.raises(RuntimeError):
+                assert ctx.get_input_sparse_data(10) is None
+            assert ctx.get_input_type(0) is not None
+            with pytest.raises(RuntimeError):
+                ctx.get_input_type(10)
+            assert ctx.get_symbolic_input(0) is None
+            with pytest.raises(RuntimeError):
+                ctx.get_symbolic_input(10)
+            assert ctx.get_output_type(0) is not None
+            with pytest.raises(RuntimeError):
+                ctx.get_output_type(10)
+            assert ctx.get_num_inputs() == 2
+            assert ctx.get_num_outputs() == 1
+
+        schema.set_type_and_shape_inference_function(schema_shape_infer_func)
+        onnx.defs.register_schema(schema)
+
+        # shape inference with registered schema
+        self.shape_infer_once(graph, N, La, Lb, out_len)
+
+        # clean up
+        onnx.defs.deregister_schema(schema.name, schema.since_version, schema.domain)
+
+    def test_get_symbolic_input_returns_tensor_shape_proto(self) -> None:
+        # Regression test: when data propagation feeds a symbolic shape into a
+        # node input, ctx.get_symbolic_input(...) must return a TensorShapeProto
+        # (the binding casts TensorShapeProto, which needs a registered caster).
+        op_type = "ReadSymbolicInput"
+        domain = "test.symbolic_input"
+        captured: dict[str, object] = {}
+
+        schema = OpSchema(
+            op_type,
+            domain,
+            1,
+            inputs=[OpSchema.FormalParameter("s", "T")],
+            outputs=[OpSchema.FormalParameter("y", "T")],
+            type_constraints=[("T", ["tensor(int64)"], "")],
+        )
+
+        def infer(ctx: onnx.shape_inference.InferenceContext) -> None:
+            captured["sym"] = ctx.get_symbolic_input(0)
+            ctx.set_output_type(0, ctx.get_input_type(0))
+
+        schema.set_type_and_shape_inference_function(infer)
+        onnx.defs.register_schema(schema)
+        try:
+            graph = make_graph(
+                [
+                    make_node("Shape", ["x"], ["s"]),
+                    make_node(op_type, ["s"], ["y"], domain=domain),
+                ],
+                "g",
+                [make_tensor_value_info("x", TensorProto.FLOAT, [2, 3])],
+                [make_tensor_value_info("y", TensorProto.INT64, None)],
+            )
+            model = make_model(
+                graph,
+                opset_imports=[make_opsetid("", 21), make_opsetid(domain, 1)],
+            )
+            onnx.shape_inference.infer_shapes(model, data_prop=True, strict_mode=True)
+
+            sym = captured["sym"]
+            assert isinstance(sym, TensorShapeProto)
+            assert [d.dim_value for d in sym.dim] == [2, 3]
+        finally:
+            onnx.defs.deregister_schema(op_type, 1, domain)
diff --git a/onnx/test/symbolic_shape_test.py b/onnx/test/symbolic_shape_test.py
new file mode 100644
index 0000000..e7c4c2b
--- /dev/null
+++ b/onnx/test/symbolic_shape_test.py
@@ -0,0 +1,193 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import onnx.shape_inference
+from onnx import ModelProto, TensorProto, TensorShapeProto, ValueInfoProto, helper
+from onnx.helper import make_model, make_tensor_value_info
+
+
+class TestSymbolicShape:
+    def _assert_valueinfo_shape(
+        self, onnx_model: ModelProto, value_infos: list[ValueInfoProto]
+    ) -> None:
+        """Assert onnx_model.value_info should be the same as expected value_infos
+        Instead of exact symbol, use -1 to represent symbolic shape in expected value_infos
+        """
+        for expected_vi in value_infos:
+            shape = self._get_shape_from_name(onnx_model, expected_vi.name)
+            assert shape is not None, f"{onnx_model}"
+            if expected_vi.type.HasField("tensor_type"):
+                expected_shape = expected_vi.type.tensor_type.shape
+            elif expected_vi.type.HasField("sparse_tensor_type"):
+                expected_shape = expected_vi.type.sparse_tensor_type.shape
+            assert len(shape.dim) == len(expected_shape.dim), f"{onnx_model}"
+            for dim_i, dim in enumerate(shape.dim):
+                expected_dim = expected_shape.dim[dim_i]
+                # -1 means it's a symbolic shape
+                if expected_dim.dim_value == -1:
+                    # symbolic dimension must exist
+                    assert dim.dim_param, f"{onnx_model}"
+                else:
+                    assert dim.dim_value == expected_dim.dim_value, f"{onnx_model}"
+
+    def _count_unique_dim_param_number(self, onnx_model: ModelProto) -> int:
+        """Return the total number of unique symbolic shape"""
+        symbol_shape_set = set()
+        inputs = list(onnx_model.graph.input)
+        outputs = list(onnx_model.graph.output)
+        valueinfos = list(onnx_model.graph.value_info)
+        for v in inputs + outputs + valueinfos:
+            for dim in v.type.tensor_type.shape.dim:
+                if dim.dim_param:
+                    symbol_shape_set.add(dim.dim_param)
+        return len(symbol_shape_set)
+
+    def _get_shape_from_name(
+        self, onnx_model: ModelProto, name: str
+    ) -> TensorShapeProto | None:
+        """Get shape from tensor_type or sparse_tensor_type according to given name"""
+        inputs = list(onnx_model.graph.input)
+        outputs = list(onnx_model.graph.output)
+        valueinfos = list(onnx_model.graph.value_info)
+        for v in inputs + outputs + valueinfos:
+            if v.name == name:
+                if v.type.HasField("tensor_type"):
+                    return v.type.tensor_type.shape
+                if v.type.HasField("sparse_tensor_type"):
+                    return v.type.sparse_tensor_type.shape
+        return None
+
+    def test_concat_enable_symbolic(self) -> None:
+        concat = helper.make_node(
+            "Concat", inputs=["A", "B"], outputs=["C"], name="Concat", axis=1
+        )
+        cast = onnx.helper.make_node(
+            "Cast", inputs=["C"], outputs=["output"], to=TensorProto.FLOAT
+        )
+        graph_def = helper.make_graph(
+            name="test_graph",
+            nodes=[concat, cast],
+            inputs=[
+                helper.make_tensor_value_info("A", TensorProto.FLOAT, [2, "A"]),
+                helper.make_tensor_value_info("B", TensorProto.FLOAT, [2, 3]),
+            ],
+            outputs=[
+                helper.make_tensor_value_info("output", TensorProto.FLOAT, [2, None])
+            ],
+        )
+
+        onnx_model = make_model(graph_def)
+        inferred_model = onnx.shape_inference.infer_shapes(onnx_model, strict_mode=True)
+        self._assert_valueinfo_shape(
+            inferred_model, [make_tensor_value_info("C", TensorProto.FLOAT, (2, -1))]
+        )
+        # the symbolic shape of C and output should be the same
+        assert self._get_shape_from_name(
+            inferred_model, "C"
+        ) == self._get_shape_from_name(inferred_model, "output")
+
+    def test_two_symbolic_concat(self) -> None:
+        concat1 = helper.make_node(
+            "Concat", inputs=["A", "B"], outputs=["C"], name="Concat", axis=1
+        )
+        concat2 = helper.make_node(
+            "Concat", inputs=["C", "D"], outputs=["E"], name="Concat", axis=1
+        )
+        cast = onnx.helper.make_node(
+            "Cast", inputs=["E"], outputs=["output"], to=TensorProto.FLOAT
+        )
+        graph_def = helper.make_graph(
+            name="test_graph",
+            nodes=[concat1, concat2, cast],
+            inputs=[
+                helper.make_tensor_value_info("A", TensorProto.FLOAT, [2, "A"]),
+                helper.make_tensor_value_info("B", TensorProto.FLOAT, [2, 3]),
+                helper.make_tensor_value_info("D", TensorProto.FLOAT, [2, "D"]),
+            ],
+            outputs=[
+                helper.make_tensor_value_info("output", TensorProto.FLOAT, [2, None])
+            ],
+        )
+
+        onnx_model = make_model(graph_def)
+        inferred_model = onnx.shape_inference.infer_shapes(onnx_model, strict_mode=True)
+        self._assert_valueinfo_shape(
+            inferred_model,
+            [
+                make_tensor_value_info("C", TensorProto.FLOAT, (2, -1)),
+                make_tensor_value_info("E", TensorProto.FLOAT, (2, -1)),
+            ],
+        )
+        # the symbolic shape of E and output should be the same
+        assert self._get_shape_from_name(
+            inferred_model, "E"
+        ) == self._get_shape_from_name(inferred_model, "output")
+
+    def test_duplicate_symbolic_shape(self) -> None:
+        concat1 = helper.make_node(
+            "Concat", inputs=["A", "B"], outputs=["C"], name="Concat", axis=1
+        )
+        concat2 = helper.make_node(
+            "Concat", inputs=["C", "D"], outputs=["E"], name="Concat", axis=1
+        )
+        cast = onnx.helper.make_node(
+            "Cast", inputs=["E"], outputs=["output"], to=TensorProto.FLOAT
+        )
+        graph_def = helper.make_graph(
+            name="test_graph",
+            nodes=[concat1, concat2, cast],
+            inputs=[
+                helper.make_tensor_value_info("A", TensorProto.FLOAT, [2, "unk__0"]),
+                helper.make_tensor_value_info("B", TensorProto.FLOAT, [2, 3]),
+                helper.make_tensor_value_info("D", TensorProto.FLOAT, [2, "unk__1"]),
+            ],
+            outputs=[
+                helper.make_tensor_value_info(
+                    "output", TensorProto.FLOAT, [2, "unk__0"]
+                )
+            ],
+        )
+
+        onnx_model = make_model(graph_def)
+        original_count = self._count_unique_dim_param_number(onnx_model)
+        inferred_model = onnx.shape_inference.infer_shapes(onnx_model, strict_mode=True)
+        inferred_count = self._count_unique_dim_param_number(inferred_model)
+        # to prevent duplicate so the inferred count will be count + 2
+        # new symbol 'unk__2' and 'unk__3' should be generated
+        # original: {'unk_0', 'unk__1'}
+        # inferred: {'unk_0', 'unk__1', 'unk__2', 'unk__3'}
+        assert inferred_count == original_count + 2, f"{inferred_model}{onnx_model}"
+
+    def test_unknown_shape(self) -> None:
+        concat = helper.make_node(
+            "Concat", inputs=["A", "B"], outputs=["C"], name="Concat", axis=1
+        )
+        cast = onnx.helper.make_node(
+            "Cast", inputs=["C"], outputs=["output"], to=TensorProto.FLOAT
+        )
+        graph_def = helper.make_graph(
+            name="test_graph",
+            nodes=[concat, cast],
+            inputs=[
+                helper.make_tensor_value_info(
+                    "A", TensorProto.FLOAT, [3, None]
+                ),  # unknown shape
+                helper.make_tensor_value_info("B", TensorProto.FLOAT, [3, None]),
+            ],
+            outputs=[
+                helper.make_tensor_value_info("output", TensorProto.FLOAT, [3, None])
+            ],
+        )
+
+        onnx_model = make_model(graph_def)
+        inferred_model = onnx.shape_inference.infer_shapes(onnx_model, strict_mode=True)
+        self._assert_valueinfo_shape(
+            inferred_model, [make_tensor_value_info("C", TensorProto.FLOAT, (3, -1))]
+        )
+        # the symbolic shape of C and output should be the same
+        # ('unk__0', 'unk__1')
+        assert self._get_shape_from_name(
+            inferred_model, "C"
+        ) == self._get_shape_from_name(inferred_model, "output")
diff --git a/onnx/test/test_backend_reference.py b/onnx/test/test_backend_reference.py
new file mode 100644
index 0000000..cc6b654
--- /dev/null
+++ b/onnx/test/test_backend_reference.py
@@ -0,0 +1,184 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+import platform
+import sys
+from typing import Any
+
+import numpy
+import version_utils
+
+import onnx.backend.base
+import onnx.backend.test
+from onnx import ModelProto
+from onnx.backend.base import Device, DeviceType
+from onnx.reference import ReferenceEvaluator
+
+# The following just executes a backend based on ReferenceEvaluator through the backend test
+VERBOSE = int(os.environ.get("VERBOSE", "0"))
+
+
+class ReferenceEvaluatorBackendRep(onnx.backend.base.BackendRep):
+    def __init__(self, session):
+        self._session = session
+
+    def run(self, inputs, **kwargs):  # noqa: ARG002
+        if isinstance(inputs, numpy.ndarray):
+            inputs = [inputs]
+        if isinstance(inputs, list):
+            if len(inputs) == len(self._session.input_names):
+                feeds = dict(zip(self._session.input_names, inputs, strict=True))
+            else:
+                feeds = {}
+                pos_inputs = 0
+                for inp, tshape in zip(
+                    self._session.input_names, self._session.input_types, strict=True
+                ):
+                    shape = tuple(d.dim_value for d in tshape.tensor_type.shape.dim)
+                    if shape == inputs[pos_inputs].shape:
+                        feeds[inp] = inputs[pos_inputs]
+                        pos_inputs += 1
+                        if pos_inputs >= len(inputs):
+                            break
+        elif isinstance(inputs, dict):
+            feeds = inputs
+        else:
+            raise TypeError(f"Unexpected input type {type(inputs)!r}.")
+        return self._session.run(None, feeds)
+
+
+class ReferenceEvaluatorBackend(onnx.backend.base.Backend):
+    @classmethod
+    def is_opset_supported(cls, model):  # noqa: ARG003
+        return True, ""
+
+    @classmethod
+    def supports_device(cls, device: str) -> bool:
+        d = Device(device)
+        return d.type == DeviceType.CPU
+
+    @classmethod
+    def create_inference_session(cls, model):
+        return ReferenceEvaluator(model, verbose=VERBOSE)
+
+    @classmethod
+    def prepare(
+        cls, model: Any, device: str = "CPU", **kwargs: Any
+    ) -> ReferenceEvaluatorBackendRep:
+        if isinstance(model, ReferenceEvaluator):
+            return ReferenceEvaluatorBackendRep(model)
+        if isinstance(model, (str, bytes, ModelProto)):
+            inf = cls.create_inference_session(model)
+            return cls.prepare(inf, device, **kwargs)
+        raise TypeError(f"Unexpected type {type(model)} for model.")
+
+    @classmethod
+    def run_model(cls, model, inputs, device=None, **kwargs):
+        rep = cls.prepare(model, device, **kwargs)
+        return rep.run(inputs, **kwargs)
+
+    @classmethod
+    def run_node(cls, node, inputs, device=None, outputs_info=None, **kwargs):
+        raise NotImplementedError("Unable to run the model node by node.")
+
+
+dft_atol = 1e-3 if sys.platform != "linux" else 1e-6
+backend_test = onnx.backend.test.BackendTest(
+    ReferenceEvaluatorBackend,
+    __name__,
+    test_kwargs={
+        "test_dft": {"atol": dft_atol},
+        "test_dft_axis": {"atol": dft_atol},
+        "test_dft_axis_opset19": {"atol": dft_atol},
+        "test_dft_inverse": {"atol": dft_atol},
+        "test_dft_inverse_opset19": {"atol": dft_atol},
+        "test_dft_opset19": {"atol": dft_atol},
+        # The Celu function body rounds every step to bfloat16, so the expanded
+        # form drifts ~1 bfloat16 ULP from the direct reference.
+        "test_celu_bfloat16_expanded": {"rtol": 1e-2, "atol": 1e-2},
+    },
+)
+
+if platform.architecture()[0] == "32bit":
+    backend_test.exclude("(test_vgg19|test_zfnet|test_bvlc_alexnet)")
+if platform.system() == "Windows":
+    backend_test.exclude("test_sequence_model")
+
+# The following tests are not supported.
+backend_test.exclude(
+    "(test_gradient"
+    "|test_if_opt"
+    "|test_loop16_seq_none"
+    "|test_range_float_type_positive_delta_expanded"
+    "|test_range_float16_type_positive_delta_expanded"
+    "|test_range_bfloat16_type_positive_delta_expanded"
+    "|test_range_int32_type_negative_delta_expanded"
+    "|test_scan_sum)"
+)
+
+# The following tests are about deprecated operators.
+backend_test.exclude("(test_scatter_with_axis|test_scatter_without)")
+
+# The following tests are too slow with the reference implementation (Conv).
+backend_test.exclude(
+    "(test_bvlc_alexnet"
+    "|test_densenet121"
+    "|test_inception_v1"
+    "|test_inception_v2"
+    "|test_resnet50"
+    "|test_shufflenet"
+    "|test_squeezenet"
+    "|test_vgg19"
+    "|test_zfnet512)"
+)
+
+# The following tests cannot pass because they consists in generating random number.
+backend_test.exclude("(test_bernoulli)")
+
+# The following tests fail due to discrepancies (small but still higher than 1e-7).
+backend_test.exclude("test_adam_multiple")  # 1e-2
+
+# Currently Pillow is not supported on Win32 and is required for the reference implementation of RegexFullMatch.
+if sys.platform == "win32":
+    backend_test.exclude(
+        "(test_regex_full_match_basic_cpu"
+        "|test_regex_full_match_email_domain_cpu"
+        "|test_regex_full_match_empty_cpu"
+        "|test_image_decoder_decode_)"
+    )
+
+
+if version_utils.pillow_older_than("10.0"):
+    backend_test.exclude("test_image_decoder_decode_webp_rgb")
+    backend_test.exclude("test_image_decoder_decode_jpeg2k_rgb")
+
+if version_utils.numpy_older_than("2.0"):
+    # assert_allclose does not support ml_dtypes types in numpy < 2.0
+    backend_test.exclude(r"test_cast.*(FLOAT8|BFLOAT16|FLOAT4|INT4)")
+    backend_test.exclude(r"test_quantizelinear_e4m3fn")
+    backend_test.exclude(r"test_quantizelinear_float4e2m1")
+    # float16 is a native NumPy dtype and works with assert_allclose in all NumPy versions;
+    # only bfloat16 (ml_dtypes) requires NumPy >= 2.0.
+    backend_test.exclude(r"test_range_bfloat16_type_positive_delta")
+    backend_test.exclude(r"test_range_bfloat16_type_positive_delta_expanded")
+    # Both the direct and expanded bfloat16 forms use ml_dtypes; the per-test
+    # tolerance for the expanded case applies only on NumPy >= 2.0.
+    backend_test.exclude(r"test_celu_bfloat16_cpu")
+    backend_test.exclude(r"test_celu_bfloat16_expanded_cpu")
+
+# The documentation does not explicitly say that is_causal=1 and attn_mask is not None
+# is not allowed. The expansion (based on the function definition in ONNX)
+# assumes this case never happens and behaves likes is_causal=0 even if it is 1.
+# The reference implementation and the backend tests have a different behavior in that case.
+backend_test.exclude(
+    "(test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded"
+    "|test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded"
+    "|test_attention_4d_attn_mask_4d_causal_expanded"
+    "|test_attention_4d_attn_mask_3d_causal_expanded)"
+)
+
+# import all test cases at global scope to make them visible to python.unittest
+globals().update(backend_test.test_cases)
diff --git a/onnx/test/test_backend_test.py b/onnx/test/test_backend_test.py
new file mode 100644
index 0000000..9a1a0c3
--- /dev/null
+++ b/onnx/test/test_backend_test.py
@@ -0,0 +1,120 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import itertools
+import platform
+from typing import TYPE_CHECKING, Any
+
+import onnx.backend.base
+import onnx.backend.test
+import onnx.shape_inference
+import onnx.version_converter
+from onnx import ModelProto, NodeProto, TensorProto
+from onnx.backend.base import Device, DeviceType
+from onnx.backend.test.runner import BackendIsNotSupposedToImplementIt
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import numpy
+
+# The following just executes the fake backend through the backend test
+# infrastructure. Since we don't have full reference implementation of all ops
+# in ONNX repo, it's impossible to produce the proper results. However, we can
+# run 'checker' (that's what base Backend class does) to verify that all tests
+# fed are actually well-formed ONNX models.
+#
+# If everything is fine, all the tests would be marked as "skipped".
+#
+# We don't enable report in this test because the report collection logic itself
+# fails when models are mal-formed.
+
+
+class DummyBackend(onnx.backend.base.Backend):
+    @classmethod
+    def prepare(
+        cls, model: ModelProto, device: str = "CPU", **kwargs: Any
+    ) -> onnx.backend.base.BackendRep | None:
+        super().prepare(model, device, **kwargs)
+
+        onnx.checker.check_model(model)
+
+        # by default test strict shape inference
+        kwargs = {"check_type": True, "strict_mode": True, **kwargs}
+        model = onnx.shape_inference.infer_shapes(model, **kwargs)
+
+        value_infos = {
+            vi.name: vi
+            for vi in itertools.chain(model.graph.value_info, model.graph.output)
+        }
+
+        if do_enforce_test_coverage_safelist(model):
+            for node in model.graph.node:
+                for i, output in enumerate(node.output):
+                    if node.op_type == "Dropout" and i != 0:
+                        continue
+                    assert output in value_infos
+                    tt = value_infos[output].type.tensor_type
+                    assert tt.elem_type != TensorProto.UNDEFINED
+                    for dim in tt.shape.dim:
+                        assert dim.WhichOneof("value") == "dim_value"
+
+        raise BackendIsNotSupposedToImplementIt(
+            "This is the dummy backend test that doesn't verify the results but does run the checker"
+        )
+
+    @classmethod
+    def run_node(
+        cls,
+        node: NodeProto,
+        inputs: Any,
+        device: str = "CPU",
+        outputs_info: Sequence[tuple[numpy.dtype, tuple[int, ...]]] | None = None,
+        **kwargs: Any,  # noqa: ARG003
+    ) -> tuple[Any, ...] | None:
+        super().run_node(node, inputs, device=device, outputs_info=outputs_info)
+        raise BackendIsNotSupposedToImplementIt(
+            "This is the dummy backend test that doesn't verify the results but does run the checker"
+        )
+
+    @classmethod
+    def supports_device(cls, device: str) -> bool:
+        d = Device(device)
+        return d.type == DeviceType.CPU
+
+
+test_coverage_safelist = {
+    "bvlc_alexnet",
+    "densenet121",
+    "inception_v1",
+    "inception_v2",
+    "resnet50",
+    "shufflenet",
+    "SingleRelu",
+    "squeezenet_old",
+    "vgg19",
+    "zfnet",
+}
+
+
+def do_enforce_test_coverage_safelist(model: ModelProto) -> bool:
+    if model.graph.name not in test_coverage_safelist:
+        return False
+    return all(node.op_type not in {"RNN", "LSTM", "GRU"} for node in model.graph.node)
+
+
+test_kwargs = {
+    # https://github.com/onnx/onnx/issues/5510 (test_mvn fails with test_backend_test.py)
+    "test_mvn": {"strict_mode": False},
+}
+
+backend_test = onnx.backend.test.BackendTest(
+    DummyBackend, __name__, test_kwargs=test_kwargs
+)
+if platform.architecture()[0] == "32bit":
+    backend_test.exclude(r"(test_vgg19|test_zfnet|test_bvlc_alexnet)")
+
+# import all test cases at global scope to make them visible to python.unittest
+globals().update(backend_test.test_cases)
diff --git a/onnx/test/test_external_data.py b/onnx/test/test_external_data.py
new file mode 100644
index 0000000..b4e4c92
--- /dev/null
+++ b/onnx/test/test_external_data.py
@@ -0,0 +1,1289 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+import pathlib
+import shutil
+import uuid
+import warnings
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import pytest
+
+import onnx
+from onnx import (
+    ModelProto,
+    NodeProto,
+    TensorProto,
+    checker,
+    helper,
+    parser,
+    shape_inference,
+)
+from onnx.external_data_helper import (
+    _ALLOWED_EXTERNAL_DATA_KEYS,
+    ExternalDataInfo,
+    convert_model_from_external_data,
+    convert_model_to_external_data,
+    load_external_data_for_model,
+    load_external_data_for_tensor,
+    save_external_data,
+    set_external_data,
+)
+from onnx.numpy_helper import from_array, to_array
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pathlib import Path
+
+
+class TestLoadExternalDataBase:
+    """Base class for testing external data related behaviors.
+
+    Subclasses should be parameterized with a serialization format.
+    """
+
+    serialization_format: str = "protobuf"
+
+    @pytest.fixture(autouse=True)
+    def setup(self, tmp_path: Path):
+        self.temp_dir = str(tmp_path)
+        self.initializer_value = np.arange(6).reshape(3, 2).astype(np.float32) + 512
+        self.attribute_value = np.arange(6).reshape(2, 3).astype(np.float32) + 256
+        self.model_filename = self.create_test_model()
+
+    def get_temp_model_filename(self) -> str:
+        return os.path.join(self.temp_dir, str(uuid.uuid4()) + ".onnx")
+
+    def create_external_data_tensor(
+        self, value: list[Any], tensor_name: str, location: str = ""
+    ) -> TensorProto:
+        tensor = from_array(np.array(value))
+        tensor.name = tensor_name
+        tensor_filename = location or f"{tensor_name}.bin"
+        set_external_data(tensor, location=tensor_filename)
+
+        with open(os.path.join(self.temp_dir, tensor_filename), "wb") as data_file:
+            data_file.write(tensor.raw_data)
+        tensor.ClearField("raw_data")
+        tensor.data_location = onnx.TensorProto.EXTERNAL
+        return tensor
+
+    def create_test_model(self, location: str = "") -> str:
+        constant_node = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["values"],
+            value=self.create_external_data_tensor(
+                self.attribute_value,
+                "attribute_value",
+            ),
+        )
+
+        initializers = [
+            self.create_external_data_tensor(
+                self.initializer_value,
+                "input_value",
+                location,
+            )
+        ]
+        inputs = [
+            helper.make_tensor_value_info(
+                "input_value", onnx.TensorProto.FLOAT, self.initializer_value.shape
+            )
+        ]
+
+        graph = helper.make_graph(
+            [constant_node],
+            "test_graph",
+            inputs=inputs,
+            outputs=[],
+            initializer=initializers,
+        )
+        model = helper.make_model(graph)
+
+        model_filename = os.path.join(self.temp_dir, "model.onnx")
+        onnx.save_model(model, model_filename, self.serialization_format)
+
+        return model_filename
+
+    def test_check_model(self) -> None:
+        if self.serialization_format != "protobuf":
+            pytest.skip(
+                "check_model supports protobuf only as binary when provided as a path"
+            )
+        checker.check_model(self.model_filename)
+
+
+class TestLoadExternalData(TestLoadExternalDataBase):
+    @pytest.fixture(scope="class", params=["protobuf", "textproto"], autouse=True)
+    def override_serialization_format(self, request):
+        # Override the class' `serialization_format`.
+        # This is not idiomatic pytest code which would structure all
+        # these dependencies as explicit fixtures rather than setting
+        # state on `self`. The code is as it is because it was
+        # inherited from an earlier unittest/parameterized setup.
+        self.serialization_format = request.param
+
+    def test_load_external_data(self) -> None:
+        model = onnx.load_model(self.model_filename, self.serialization_format)
+        initializer_tensor = model.graph.initializer[0]
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+
+        attribute_tensor = model.graph.node[0].attribute[0].t
+        np.testing.assert_allclose(to_array(attribute_tensor), self.attribute_value)
+
+    def test_load_external_data_for_model(self) -> None:
+        model = onnx.load_model(
+            self.model_filename, self.serialization_format, load_external_data=False
+        )
+        load_external_data_for_model(model, self.temp_dir)
+        initializer_tensor = model.graph.initializer[0]
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+
+        attribute_tensor = model.graph.node[0].attribute[0].t
+        np.testing.assert_allclose(to_array(attribute_tensor), self.attribute_value)
+
+    def test_save_external_data(self) -> None:
+        model = onnx.load_model(self.model_filename, self.serialization_format)
+
+        temp_dir = os.path.join(self.temp_dir, "save_copy")
+        os.mkdir(temp_dir)
+        new_model_filename = os.path.join(temp_dir, "model.onnx")
+        onnx.save_model(model, new_model_filename, self.serialization_format)
+
+        new_model = onnx.load_model(new_model_filename, self.serialization_format)
+        initializer_tensor = new_model.graph.initializer[0]
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+
+        attribute_tensor = new_model.graph.node[0].attribute[0].t
+        np.testing.assert_allclose(to_array(attribute_tensor), self.attribute_value)
+
+
+class TestLoadExternalDataSingleFile(TestLoadExternalDataBase):
+    @pytest.fixture(scope="class", params=["protobuf", "textproto"], autouse=True)
+    def override_serialization_format(self, request):
+        # Override the class' `serialization_format`.
+        # This is not idiomatic pytest code which would structure all
+        # these dependencies as explicit fixtures rather than setting
+        # state on `self`. The code is as it is because it was
+        # inherited from an earlier unittest/parameterized setup.
+        self.serialization_format = request.param
+
+    def create_external_data_tensors(
+        self, tensors_data: list[tuple[list[Any], Any]]
+    ) -> list[TensorProto]:
+        tensor_filename = "tensors.bin"
+        tensors = []
+
+        with open(os.path.join(self.temp_dir, tensor_filename), "ab") as data_file:
+            for value, tensor_name in tensors_data:
+                tensor = from_array(np.array(value))
+                offset = data_file.tell()
+                if offset % 4096 != 0:
+                    data_file.write(b"\0" * (4096 - offset % 4096))
+                    offset = offset + 4096 - offset % 4096
+
+                data_file.write(tensor.raw_data)
+                set_external_data(
+                    tensor,
+                    location=tensor_filename,
+                    offset=offset,
+                    length=data_file.tell() - offset,
+                )
+                tensor.name = tensor_name
+                tensor.ClearField("raw_data")
+                tensor.data_location = onnx.TensorProto.EXTERNAL
+                tensors.append(tensor)
+
+        return tensors
+
+    def test_load_external_single_file_data(self) -> None:
+        model = onnx.load_model(self.model_filename, self.serialization_format)
+
+        initializer_tensor = model.graph.initializer[0]
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+
+        attribute_tensor = model.graph.node[0].attribute[0].t
+        np.testing.assert_allclose(to_array(attribute_tensor), self.attribute_value)
+
+    def test_save_external_single_file_data(self) -> None:
+        model = onnx.load_model(self.model_filename, self.serialization_format)
+
+        temp_dir = os.path.join(self.temp_dir, "save_copy")
+        os.mkdir(temp_dir)
+        new_model_filename = os.path.join(temp_dir, "model.onnx")
+        onnx.save_model(model, new_model_filename, self.serialization_format)
+
+        new_model = onnx.load_model(new_model_filename, self.serialization_format)
+        initializer_tensor = new_model.graph.initializer[0]
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+
+        attribute_tensor = new_model.graph.node[0].attribute[0].t
+        np.testing.assert_allclose(to_array(attribute_tensor), self.attribute_value)
+
+    @pytest.mark.parametrize("use_absolute_path", (True, False))
+    def test_save_external_invalid_single_file_data_and_check(
+        self, use_absolute_path: bool
+    ) -> None:
+        model = onnx.load_model(self.model_filename, self.serialization_format)
+
+        model_dir = os.path.join(self.temp_dir, "save_copy")
+        os.mkdir(model_dir)
+
+        traversal_external_data_dir = os.path.join(
+            self.temp_dir, "invalid_external_data"
+        )
+        os.mkdir(traversal_external_data_dir)
+
+        if use_absolute_path:
+            traversal_external_data_location = os.path.join(
+                traversal_external_data_dir, "tensors.bin"
+            )
+        else:
+            traversal_external_data_location = "../invalid_external_data/tensors.bin"
+
+        external_data_dir = os.path.join(self.temp_dir, "external_data")
+        os.mkdir(external_data_dir)
+        new_model_filepath = os.path.join(model_dir, "model.onnx")
+
+        def convert_model_to_external_data_no_check(model: ModelProto, location: str):
+            for tensor in model.graph.initializer:
+                if tensor.HasField("raw_data"):
+                    set_external_data(tensor, location)
+
+        convert_model_to_external_data_no_check(
+            model,
+            location=traversal_external_data_location,
+        )
+
+        with pytest.raises(onnx.checker.ValidationError):
+            onnx.save_model(model, new_model_filepath, self.serialization_format)
+
+
+@pytest.mark.parametrize("serialization_format", ["protobuf", "textproto"])
+class TestSaveAllTensorsAsExternalData:
+    @pytest.fixture(autouse=True)
+    def setup(self, tmp_path, serialization_format: str):
+        self.serialization_format = serialization_format
+        self.temp_dir: str = str(tmp_path)
+        self.initializer_value = np.arange(6).reshape(3, 2).astype(np.float32) + 512
+        self.attribute_value = np.arange(6).reshape(2, 3).astype(np.float32) + 256
+        self.model = self.create_test_model_proto()
+
+    def get_temp_model_filename(self):
+        return os.path.join(self.temp_dir, str(uuid.uuid4()) + ".onnx")
+
+    def create_data_tensors(
+        self, tensors_data: list[tuple[list[Any], Any]]
+    ) -> list[TensorProto]:
+        tensors = []
+        for value, tensor_name in tensors_data:
+            tensor = from_array(np.array(value))
+            tensor.name = tensor_name
+            tensors.append(tensor)
+
+        return tensors
+
+    def create_test_model_proto(self) -> ModelProto:
+        tensors = self.create_data_tensors(
+            [
+                (self.attribute_value, "attribute_value"),
+                (self.initializer_value, "input_value"),
+            ]
+        )
+
+        constant_node = onnx.helper.make_node(
+            "Constant", inputs=[], outputs=["values"], value=tensors[0]
+        )
+
+        inputs = [
+            helper.make_tensor_value_info(
+                "input_value", onnx.TensorProto.FLOAT, self.initializer_value.shape
+            )
+        ]
+
+        graph = helper.make_graph(
+            [constant_node],
+            "test_graph",
+            inputs=inputs,
+            outputs=[],
+            initializer=[tensors[1]],
+        )
+        return helper.make_model(graph)
+
+    def test_check_model(self) -> None:
+        if self.serialization_format != "protobuf":
+            pytest.skip("check_model supports protobuf only when provided as a path")
+        checker.check_model(self.model)
+
+    def test_convert_model_to_external_data_with_size_threshold(self) -> None:
+        model_file_path = self.get_temp_model_filename()
+
+        convert_model_to_external_data(self.model, size_threshold=1024)
+        onnx.save_model(self.model, model_file_path, self.serialization_format)
+
+        model = onnx.load_model(model_file_path, self.serialization_format)
+        initializer_tensor = model.graph.initializer[0]
+        assert not initializer_tensor.HasField("data_location")
+
+    def test_convert_model_to_external_data_without_size_threshold(self) -> None:
+        model_file_path = self.get_temp_model_filename()
+        convert_model_to_external_data(self.model, size_threshold=0)
+        onnx.save_model(self.model, model_file_path, self.serialization_format)
+
+        model = onnx.load_model(model_file_path, self.serialization_format)
+        initializer_tensor = model.graph.initializer[0]
+        assert initializer_tensor.HasField("data_location")
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+
+    def test_convert_model_to_external_data_from_one_file_with_location(self) -> None:
+        model_file_path = self.get_temp_model_filename()
+        external_data_file = str(uuid.uuid4())
+
+        convert_model_to_external_data(
+            self.model,
+            size_threshold=0,
+            all_tensors_to_one_file=True,
+            location=external_data_file,
+        )
+        onnx.save_model(self.model, model_file_path, self.serialization_format)
+
+        assert os.path.isfile(os.path.join(self.temp_dir, external_data_file))
+
+        model = onnx.load_model(model_file_path, self.serialization_format)
+
+        # test convert model from external data
+        convert_model_from_external_data(model)
+        model_file_path = self.get_temp_model_filename()
+        onnx.save_model(model, model_file_path, self.serialization_format)
+        model = onnx.load_model(model_file_path, self.serialization_format)
+        initializer_tensor = model.graph.initializer[0]
+        assert not len(initializer_tensor.external_data)
+        assert initializer_tensor.data_location == TensorProto.DEFAULT
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+
+        attribute_tensor = model.graph.node[0].attribute[0].t
+        assert not len(attribute_tensor.external_data)
+        assert attribute_tensor.data_location == TensorProto.DEFAULT
+        np.testing.assert_allclose(to_array(attribute_tensor), self.attribute_value)
+
+    def test_convert_model_to_external_data_from_one_file_without_location_uses_model_name(
+        self,
+    ) -> None:
+        model_file_path = self.get_temp_model_filename()
+
+        convert_model_to_external_data(
+            self.model, size_threshold=0, all_tensors_to_one_file=True
+        )
+        onnx.save_model(self.model, model_file_path, self.serialization_format)
+
+        assert os.path.isfile(model_file_path)
+        assert os.path.isfile(os.path.join(self.temp_dir, model_file_path))
+
+    def test_convert_model_to_external_data_one_file_per_tensor_without_attribute(
+        self,
+    ) -> None:
+        model_file_path = self.get_temp_model_filename()
+
+        convert_model_to_external_data(
+            self.model,
+            size_threshold=0,
+            all_tensors_to_one_file=False,
+            convert_attribute=False,
+        )
+        onnx.save_model(self.model, model_file_path, self.serialization_format)
+
+        assert os.path.isfile(model_file_path)
+        assert os.path.isfile(os.path.join(self.temp_dir, "input_value"))
+        assert not os.path.isfile(os.path.join(self.temp_dir, "attribute_value"))
+
+    def test_convert_model_to_external_data_one_file_per_tensor_with_attribute(
+        self,
+    ) -> None:
+        model_file_path = self.get_temp_model_filename()
+
+        convert_model_to_external_data(
+            self.model,
+            size_threshold=0,
+            all_tensors_to_one_file=False,
+            convert_attribute=True,
+        )
+        onnx.save_model(self.model, model_file_path, self.serialization_format)
+
+        assert os.path.isfile(model_file_path)
+        assert os.path.isfile(os.path.join(self.temp_dir, "input_value"))
+        assert os.path.isfile(os.path.join(self.temp_dir, "attribute_value"))
+
+    def test_convert_model_to_external_data_does_not_convert_attribute_values(
+        self,
+    ) -> None:
+        model_file_path = self.get_temp_model_filename()
+
+        convert_model_to_external_data(
+            self.model,
+            size_threshold=0,
+            convert_attribute=False,
+            all_tensors_to_one_file=False,
+        )
+        onnx.save_model(self.model, model_file_path, self.serialization_format)
+
+        assert os.path.isfile(os.path.join(self.temp_dir, "input_value"))
+        assert not os.path.isfile(os.path.join(self.temp_dir, "attribute_value"))
+
+        model = onnx.load_model(model_file_path, self.serialization_format)
+        initializer_tensor = model.graph.initializer[0]
+        assert initializer_tensor.HasField("data_location")
+
+        attribute_tensor = model.graph.node[0].attribute[0].t
+        assert not attribute_tensor.HasField("data_location")
+
+    def test_convert_model_to_external_data_converts_attribute_values(self) -> None:
+        model_file_path = self.get_temp_model_filename()
+
+        convert_model_to_external_data(
+            self.model, size_threshold=0, convert_attribute=True
+        )
+        onnx.save_model(self.model, model_file_path, self.serialization_format)
+
+        model = onnx.load_model(model_file_path, self.serialization_format)
+
+        initializer_tensor = model.graph.initializer[0]
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+        assert initializer_tensor.HasField("data_location")
+
+        attribute_tensor = model.graph.node[0].attribute[0].t
+        np.testing.assert_allclose(to_array(attribute_tensor), self.attribute_value)
+        assert attribute_tensor.HasField("data_location")
+
+    def test_save_model_does_not_convert_to_external_data_and_saves_the_model(
+        self,
+    ) -> None:
+        model_file_path = self.get_temp_model_filename()
+        onnx.save_model(
+            self.model,
+            model_file_path,
+            self.serialization_format,
+            save_as_external_data=False,
+        )
+        assert os.path.isfile(model_file_path)
+
+        model = onnx.load_model(model_file_path, self.serialization_format)
+        initializer_tensor = model.graph.initializer[0]
+        assert not initializer_tensor.HasField("data_location")
+
+        attribute_tensor = model.graph.node[0].attribute[0].t
+        assert not attribute_tensor.HasField("data_location")
+
+    def test_save_model_does_convert_and_saves_the_model(self) -> None:
+        model_file_path = self.get_temp_model_filename()
+        onnx.save_model(
+            self.model,
+            model_file_path,
+            self.serialization_format,
+            save_as_external_data=True,
+            all_tensors_to_one_file=True,
+            location=None,
+            size_threshold=0,
+            convert_attribute=False,
+        )
+
+        model = onnx.load_model(model_file_path, self.serialization_format)
+
+        initializer_tensor = model.graph.initializer[0]
+        assert initializer_tensor.HasField("data_location")
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+
+        attribute_tensor = model.graph.node[0].attribute[0].t
+        assert not attribute_tensor.HasField("data_location")
+        np.testing.assert_allclose(to_array(attribute_tensor), self.attribute_value)
+
+    def test_save_model_without_loading_external_data(self) -> None:
+        model_file_path = self.get_temp_model_filename()
+        onnx.save_model(
+            self.model,
+            model_file_path,
+            self.serialization_format,
+            save_as_external_data=True,
+            location=None,
+            size_threshold=0,
+            convert_attribute=False,
+        )
+        # Save without load_external_data
+        model = onnx.load_model(
+            model_file_path, self.serialization_format, load_external_data=False
+        )
+        onnx.save_model(
+            model,
+            model_file_path,
+            self.serialization_format,
+            save_as_external_data=True,
+            location=None,
+            size_threshold=0,
+            convert_attribute=False,
+        )
+        # Load the saved model again; Only works if the saved path is under the same directory
+        model = onnx.load_model(model_file_path, self.serialization_format)
+
+        initializer_tensor = model.graph.initializer[0]
+        assert initializer_tensor.HasField("data_location")
+        np.testing.assert_allclose(to_array(initializer_tensor), self.initializer_value)
+
+        attribute_tensor = model.graph.node[0].attribute[0].t
+        assert not attribute_tensor.HasField("data_location")
+        np.testing.assert_allclose(to_array(attribute_tensor), self.attribute_value)
+
+    def test_save_model_with_existing_raw_data_should_override(self) -> None:
+        model_file_path = self.get_temp_model_filename()
+        original_raw_data = self.model.graph.initializer[0].raw_data
+        onnx.save_model(
+            self.model,
+            model_file_path,
+            self.serialization_format,
+            save_as_external_data=True,
+            size_threshold=0,
+        )
+        assert os.path.isfile(model_file_path)
+
+        model = onnx.load_model(
+            model_file_path, self.serialization_format, load_external_data=False
+        )
+        initializer_tensor = model.graph.initializer[0]
+        initializer_tensor.raw_data = b"dummpy_raw_data"
+        # If raw_data and external tensor exist at the same time, override existing raw_data
+        load_external_data_for_tensor(initializer_tensor, self.temp_dir)
+        assert initializer_tensor.raw_data == original_raw_data
+
+
+@pytest.mark.parametrize("serialization_format", ["protobuf", "textproto"])
+class TestExternalDataToArray:
+    @pytest.fixture(autouse=True)
+    def setup(self, tmp_path, serialization_format: str) -> None:
+        self.serialization_format = serialization_format
+        self.temp_dir = str(tmp_path)
+        self._model_file_path: str = os.path.join(self.temp_dir, "model.onnx")
+        self.large_data = np.random.rand(10, 60, 100).astype(np.float32)
+        self.small_data = (200, 300)
+        self.model = self.create_test_model()
+
+    @property
+    def model_file_path(self):
+        return self._model_file_path
+
+    def create_test_model(self) -> ModelProto:
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, self.large_data.shape)
+        input_init = helper.make_tensor(
+            name="X",
+            data_type=TensorProto.FLOAT,
+            dims=self.large_data.shape,
+            vals=onnx.numpy_helper.tobytes_little_endian(self.large_data),
+            raw=True,
+        )
+
+        shape_data = np.array(self.small_data, np.int64)
+        shape_init = helper.make_tensor(
+            name="Shape",
+            data_type=TensorProto.INT64,
+            dims=shape_data.shape,
+            vals=onnx.numpy_helper.tobytes_little_endian(shape_data),
+            raw=True,
+        )
+        C = helper.make_tensor_value_info("C", TensorProto.INT64, self.small_data)
+
+        reshape = onnx.helper.make_node(
+            "Reshape",
+            inputs=["X", "Shape"],
+            outputs=["Y"],
+        )
+        cast = onnx.helper.make_node(
+            "Cast", inputs=["Y"], outputs=["C"], to=TensorProto.INT64
+        )
+
+        graph_def = helper.make_graph(
+            [reshape, cast],
+            "test-model",
+            [X],
+            [C],
+            initializer=[input_init, shape_init],
+        )
+        return helper.make_model(graph_def, producer_name="onnx-example")
+
+    def test_check_model(self) -> None:
+        if self.serialization_format != "protobuf":
+            pytest.skip("check_model supports protobuf only when provided as a path")
+
+        checker.check_model(self.model)
+
+    def test_reshape_inference_with_external_data_fail(self) -> None:
+        onnx.save_model(
+            self.model,
+            self.model_file_path,
+            self.serialization_format,
+            save_as_external_data=True,
+            all_tensors_to_one_file=False,
+            size_threshold=0,
+        )
+        model_without_external_data = onnx.load(
+            self.model_file_path, self.serialization_format, load_external_data=False
+        )
+        # Shape inference of Reshape uses ParseData
+        # ParseData cannot handle external data and should throw the error as follows:
+        # Cannot parse data from external tensors. Please load external data into raw data for tensor: Shape
+        with pytest.raises(shape_inference.InferenceError):
+            shape_inference.infer_shapes(
+                model_without_external_data,
+                strict_mode=True,
+            )
+
+    def test_to_array_with_external_data(self) -> None:
+        onnx.save_model(
+            self.model,
+            self.model_file_path,
+            self.serialization_format,
+            save_as_external_data=True,
+            all_tensors_to_one_file=False,
+            size_threshold=0,
+        )
+        # raw_data of external tensor is not loaded
+        model = onnx.load(
+            self.model_file_path, self.serialization_format, load_external_data=False
+        )
+        # Specify self.temp_dir to load external tensor
+        loaded_large_data = to_array(model.graph.initializer[0], self.temp_dir)
+        np.testing.assert_allclose(loaded_large_data, self.large_data)
+
+    def test_save_model_with_external_data_multiple_times(self) -> None:
+        # Test onnx.save should respectively handle typical tensor and external tensor properly
+        # 1st save: save two tensors which have raw_data
+        # Only w_large will be stored as external tensors since it's larger than 1024
+        onnx.save_model(
+            self.model,
+            self.model_file_path,
+            self.serialization_format,
+            save_as_external_data=True,
+            all_tensors_to_one_file=False,
+            location=None,
+            size_threshold=1024,
+            convert_attribute=True,
+        )
+        model_without_loading_external = onnx.load(
+            self.model_file_path, self.serialization_format, load_external_data=False
+        )
+        large_input_tensor = model_without_loading_external.graph.initializer[0]
+        assert large_input_tensor.HasField("data_location")
+        np.testing.assert_allclose(
+            to_array(large_input_tensor, self.temp_dir), self.large_data
+        )
+
+        small_shape_tensor = model_without_loading_external.graph.initializer[1]
+        assert not small_shape_tensor.HasField("data_location")
+        np.testing.assert_allclose(to_array(small_shape_tensor), self.small_data)
+
+        # 2nd save: one tensor has raw_data (small); one external tensor (large)
+        # Save them both as external tensors this time
+        onnx.save_model(
+            model_without_loading_external,
+            self.model_file_path,
+            self.serialization_format,
+            save_as_external_data=True,
+            all_tensors_to_one_file=False,
+            location=None,
+            size_threshold=0,
+            convert_attribute=True,
+        )
+
+        model_without_loading_external = onnx.load(
+            self.model_file_path, self.serialization_format, load_external_data=False
+        )
+        large_input_tensor = model_without_loading_external.graph.initializer[0]
+        assert large_input_tensor.HasField("data_location")
+        np.testing.assert_allclose(
+            to_array(large_input_tensor, self.temp_dir), self.large_data
+        )
+
+        small_shape_tensor = model_without_loading_external.graph.initializer[1]
+        assert small_shape_tensor.HasField("data_location")
+        np.testing.assert_allclose(
+            to_array(small_shape_tensor, self.temp_dir), self.small_data
+        )
+
+
+class TestNotAllowToLoadExternalDataOutsideModelDirectory(TestLoadExternalDataBase):
+    """Essential test to check that onnx (validate) C++ code will not allow to load external_data outside the model
+    directory.
+    """
+
+    def create_external_data_tensor(
+        self, value: list[Any], tensor_name: str, location: str = ""
+    ) -> TensorProto:
+        tensor = from_array(np.array(value))
+        tensor.name = tensor_name
+        tensor_filename = location or f"{tensor_name}.bin"
+
+        set_external_data(tensor, location=tensor_filename)
+
+        tensor.ClearField("raw_data")
+        tensor.data_location = onnx.TensorProto.EXTERNAL
+        return tensor
+
+    def test_check_model(self) -> None:
+        """We only test the model validation as onnxruntime uses this to load the model."""
+        self.model_filename = self.create_test_model("../../file.bin")
+        with pytest.raises(onnx.checker.ValidationError):
+            checker.check_model(self.model_filename)
+
+    def test_check_model_relative(self) -> None:
+        """More relative path test."""
+        self.model_filename = self.create_test_model("../test/../file.bin")
+        with pytest.raises(onnx.checker.ValidationError):
+            checker.check_model(self.model_filename)
+
+    def test_check_model_absolute(self) -> None:
+        """ONNX checker disallows using absolute path as location in external tensor."""
+        self.model_filename = self.create_test_model("//file.bin")
+        with pytest.raises(onnx.checker.ValidationError):
+            checker.check_model(self.model_filename)
+
+
+@pytest.mark.skipif(os.name != "nt", reason="Skip Windows test")
+class TestNotAllowToLoadExternalDataOutsideModelDirectoryOnWindows(
+    TestNotAllowToLoadExternalDataOutsideModelDirectory
+):
+    """Essential test to check that onnx (validate) C++ code will not allow to load external_data outside the model
+    directory.
+    """
+
+    def test_check_model(self) -> None:
+        """We only test the model validation as onnxruntime uses this to load the model."""
+        self.model_filename = self.create_test_model("..\\..\\file.bin")
+        with pytest.raises(onnx.checker.ValidationError):
+            checker.check_model(self.model_filename)
+
+    def test_check_model_relative(self) -> None:
+        """More relative path test."""
+        self.model_filename = self.create_test_model("..\\test\\..\\file.bin")
+        with pytest.raises(onnx.checker.ValidationError):
+            checker.check_model(self.model_filename)
+
+    def test_check_model_absolute(self) -> None:
+        """ONNX checker disallows using absolute path as location in external tensor."""
+        self.model_filename = self.create_test_model("C:/file.bin")
+        with pytest.raises(onnx.checker.ValidationError):
+            checker.check_model(self.model_filename)
+
+
+class TestSaveAllTensorsAsExternalDataWithPath(TestSaveAllTensorsAsExternalData):
+    def get_temp_model_filename(self) -> pathlib.Path:
+        return pathlib.Path(super().get_temp_model_filename())
+
+
+class TestExternalDataToArrayWithPath(TestExternalDataToArray):
+    @property
+    def model_file_path(self) -> pathlib.Path:
+        return pathlib.Path(self._model_file_path)
+
+
+class TestFunctionsAndSubGraphs:
+    @pytest.fixture(autouse=True)
+    def setup(self, tmp_path) -> None:
+        temp_dir = str(tmp_path)
+        self._model_file_path: str = os.path.join(temp_dir, "model.onnx")
+        array = np.arange(4096).astype(np.float32)
+        self._tensor = from_array(array, "tensor")
+
+    def _check_is_internal(self, tensor: TensorProto) -> None:
+        assert tensor.data_location == TensorProto.DEFAULT
+
+    def _check_is_external(self, tensor: TensorProto) -> None:
+        assert tensor.data_location == TensorProto.EXTERNAL
+
+    def _check(self, model: ModelProto, nodes: Sequence[NodeProto]) -> None:
+        """Check that the tensors in the model are externalized.
+
+        The tensors in the specified sequence of Constant nodes are set to self._tensor,
+        an internal tensor. The model is then converted to external data format.
+        The tensors are then checked to ensure that they are externalized.
+
+        Arguments:
+            model: The model to check.
+            nodes: A sequence of Constant nodes.
+
+        """
+        for node in nodes:
+            assert node.op_type == "Constant"
+            tensor = node.attribute[0].t
+            tensor.CopyFrom(self._tensor)
+            self._check_is_internal(tensor)
+
+        convert_model_to_external_data(model, size_threshold=0, convert_attribute=True)
+
+        for node in nodes:
+            tensor = node.attribute[0].t
+            self._check_is_external(tensor)
+
+    def test_function(self) -> None:
+        model_text = """
+           <ir_version: 7,  opset_import: ["": 15, "local": 1]>
+           agraph (float[N] X) => (float[N] Y)
+            {
+              Y = local.add(X)
+            }
+
+            <opset_import: ["" : 15],  domain: "local">
+            add (float[N] X) => (float[N] Y) {
+              C = Constant <value = float[1] {1.0}> ()
+              Y = Add (X, C)
+           }
+        """
+        model = parser.parse_model(model_text)
+        self._check(model, [model.functions[0].node[0]])
+
+    def test_subgraph(self) -> None:
+        model_text = """
+           <ir_version: 7,  opset_import: ["": 15, "local": 1]>
+           agraph (bool flag, float[N] X) => (float[N] Y)
+            {
+              Y = if (flag) <
+                then_branch = g1 () => (float[N] Y_then) {
+                    B = Constant <value = float[1] {0.0}> ()
+                    Y_then = Add (X, C)
+                },
+                else_branch = g2 () => (float[N] Y_else) {
+                    C = Constant <value = float[1] {1.0}> ()
+                    Y_else = Add (X, C)
+                }
+              >
+            }
+        """
+        model = parser.parse_model(model_text)
+        if_node = model.graph.node[0]
+        constant_nodes = [attr.g.node[0] for attr in if_node.attribute]
+        self._check(model, constant_nodes)
+
+
+def _make_external_data_test_model() -> tuple[ModelProto, np.ndarray]:
+    """Create a simple model with a large initializer suitable for external data tests."""
+    model = parser.parse_model(
+        """
+        <ir_version: 7, opset_import: ["": 17]>
+        agraph (float[100, 100] input) => (float[100, 100] output) {
+            output = Identity(input)
+        }
+        """
+    )
+    array = np.ones((100, 100), dtype=np.float32)
+    model.graph.initializer.append(from_array(array, name="weight"))
+    return model, array
+
+
+@pytest.mark.skipif(
+    os.name == "nt", reason="Symlinks require elevated privileges on Windows"
+)
+class TestSaveExternalDataSymlinkProtection(TestLoadExternalDataBase):
+    """Test that save_external_data rejects symlinks to prevent arbitrary file overwrites."""
+
+    def test_save_rejects_symlink_target(self) -> None:
+        """Saving external data must refuse to follow symlinks."""
+        sensitive_file = os.path.join(self.temp_dir, "sensitive.txt")
+        with open(sensitive_file, "w") as f:
+            f.write("SENSITIVE DATA")
+
+        model, array = _make_external_data_test_model()
+        model_path = os.path.join(self.temp_dir, "model.onnx")
+        ext_data = "data.bin"
+        onnx.save_model(
+            model,
+            model_path,
+            save_as_external_data=True,
+            all_tensors_to_one_file=True,
+            location=ext_data,
+            size_threshold=1024,
+        )
+
+        # Replace external data file with a symlink to the sensitive file
+        ext_data_path = os.path.join(self.temp_dir, ext_data)
+        os.remove(ext_data_path)
+        os.symlink(sensitive_file, ext_data_path)
+
+        loaded_model = onnx.load(model_path, load_external_data=False)
+        loaded_model.graph.initializer[0].raw_data = array.tobytes()
+
+        with pytest.raises(checker.ValidationError):
+            onnx.save_model(
+                loaded_model,
+                model_path,
+                save_as_external_data=True,
+                all_tensors_to_one_file=True,
+                location=ext_data,
+                size_threshold=1024,
+            )
+
+        # Sensitive file must not be modified
+        with open(sensitive_file) as f:
+            assert f.read() == "SENSITIVE DATA"
+
+
+@pytest.mark.skipif(
+    os.name == "nt", reason="Symlinks require elevated privileges on Windows"
+)
+class TestLoadExternalDataSymlinkProtection(TestLoadExternalDataBase):
+    """Test that loading external data rejects symlinks to prevent arbitrary file reads."""
+
+    def test_load_rejects_symlink_external_data(self) -> None:
+        """Loading a model whose external data is a symlink must raise ValidationError."""
+        model, _ = _make_external_data_test_model()
+        model_path = os.path.join(self.temp_dir, "model.onnx")
+        ext_data = "data.bin"
+        onnx.save_model(
+            model,
+            model_path,
+            save_as_external_data=True,
+            all_tensors_to_one_file=True,
+            location=ext_data,
+            size_threshold=1024,
+        )
+
+        # Create a target file and replace external data with a symlink to it
+        target_file = os.path.join(self.temp_dir, "target.txt")
+        with open(target_file, "w") as f:
+            f.write("SENSITIVE DATA")
+
+        ext_data_path = os.path.join(self.temp_dir, ext_data)
+        os.remove(ext_data_path)
+        os.symlink(target_file, ext_data_path)
+
+        # Loading with onnx.load (which loads external data) must fail
+        with pytest.raises(checker.ValidationError):
+            onnx.load(model_path)
+
+    def test_load_external_data_for_model_rejects_symlink(self) -> None:
+        """load_external_data_for_model must reject symlinked external data."""
+        model, _ = _make_external_data_test_model()
+        model_path = os.path.join(self.temp_dir, "model.onnx")
+        ext_data = "data.bin"
+        onnx.save_model(
+            model,
+            model_path,
+            save_as_external_data=True,
+            all_tensors_to_one_file=True,
+            location=ext_data,
+            size_threshold=1024,
+        )
+
+        # Replace external data with a symlink
+        target_file = os.path.join(self.temp_dir, "target.txt")
+        with open(target_file, "w") as f:
+            f.write("SENSITIVE DATA")
+
+        ext_data_path = os.path.join(self.temp_dir, ext_data)
+        os.remove(ext_data_path)
+        os.symlink(target_file, ext_data_path)
+
+        # Load model without external data, then try to load external data explicitly
+        loaded_model = onnx.load(model_path, load_external_data=False)
+        with pytest.raises(checker.ValidationError):
+            load_external_data_for_model(loaded_model, self.temp_dir)
+
+    def test_load_rejects_parent_directory_symlink(self) -> None:
+        """A symlink in the parent directory must be caught by realpath containment."""
+        # Create a "sensitive" directory outside the model directory with a data file
+        sensitive_dir = os.path.join(self.temp_dir, "sensitive")
+        os.makedirs(sensitive_dir)
+        secret_file = os.path.join(sensitive_dir, "secret.bin")
+        with open(secret_file, "wb") as f:
+            f.write(b"SENSITIVE DATA" * 100)
+
+        # Create a model directory with a real subdir for saving
+        model_dir = os.path.join(self.temp_dir, "model_dir")
+        os.makedirs(model_dir)
+        subdir_path = os.path.join(model_dir, "subdir")
+        os.makedirs(subdir_path)
+
+        # Create model with external data location "subdir/secret.bin"
+        model, _ = _make_external_data_test_model()
+        model_path = os.path.join(model_dir, "model.onnx")
+        onnx.save_model(
+            model,
+            model_path,
+            save_as_external_data=True,
+            all_tensors_to_one_file=True,
+            location="subdir/secret.bin",
+            size_threshold=1024,
+        )
+
+        # Replace the real subdir with a symlink to the sensitive directory
+        shutil.rmtree(subdir_path)
+        os.symlink(sensitive_dir, subdir_path)
+
+        # Loading must fail because realpath resolves outside model_dir.
+        loaded_model = onnx.load(model_path, load_external_data=False)
+        with pytest.raises(checker.ValidationError):
+            load_external_data_for_model(loaded_model, model_dir)
+
+
+@pytest.mark.skipif(os.name == "nt", reason="Hardlinks behave differently on Windows")
+class TestLoadExternalDataHardlinkProtection(TestLoadExternalDataBase):
+    """Test that loading external data rejects files with multiple hardlinks."""
+
+    def test_load_rejects_hardlinked_external_data(self) -> None:
+        """Loading a model whose external data has multiple hardlinks must raise ValidationError."""
+        model, _ = _make_external_data_test_model()
+        model_path = os.path.join(self.temp_dir, "model.onnx")
+        ext_data = "data.bin"
+        onnx.save_model(
+            model,
+            model_path,
+            save_as_external_data=True,
+            all_tensors_to_one_file=True,
+            location=ext_data,
+            size_threshold=1024,
+        )
+
+        # Create a hardlink to the external data file
+        ext_data_path = os.path.join(self.temp_dir, ext_data)
+        hardlink_path = os.path.join(self.temp_dir, "hardlink_data.bin")
+        os.link(ext_data_path, hardlink_path)
+
+        # Loading must fail because the external data file has multiple hardlinks.
+        # Either the C++ checker or Python code catches this as ValidationError.
+        with pytest.raises(checker.ValidationError):
+            onnx.load(model_path)
+
+
+class TestSaveExternalDataAbsolutePathValidation(TestLoadExternalDataBase):
+    """Test that save_external_data rejects absolute paths."""
+
+    def test_save_rejects_absolute_path(self) -> None:
+        """Absolute paths must be rejected as external data locations."""
+        array = np.ones((100,), dtype=np.float32)
+        tensor = from_array(array, name="weight")
+        set_external_data(tensor, location="/etc/passwd")
+        with pytest.raises(checker.ValidationError):
+            save_external_data(tensor, self.temp_dir)
+
+
+class TestExternalDataInfoSecurity:
+    """Tests for ExternalDataInfo hardening against attribute injection and bounds.
+
+    Covers all attack vectors from the security advisory: unknown key injection,
+    dunder attribute injection, negative offset/length bypass, and validates
+    that legitimate keys still work correctly.
+    """
+
+    @staticmethod
+    def _make_tensor_with_external_data(
+        entries: dict[str, str],
+        tensor_name: str = "test_tensor",
+    ) -> TensorProto:
+        """Create a TensorProto with given external_data key-value entries."""
+        tensor = TensorProto()
+        tensor.name = tensor_name
+        tensor.data_type = TensorProto.FLOAT
+        tensor.dims.extend([4])
+        tensor.data_location = TensorProto.EXTERNAL
+        for key, value in entries.items():
+            entry = tensor.external_data.add()
+            entry.key = key
+            entry.value = value
+        return tensor
+
+    def test_valid_external_data_accepted(self) -> None:
+        """All valid external_data keys must be accepted and correctly parsed."""
+        tensor = self._make_tensor_with_external_data(
+            {
+                "location": "weights.bin",
+                "offset": "16",
+                "length": "1024",
+                "checksum": "sha256:abc123",
+            }
+        )
+        info = ExternalDataInfo(tensor)
+        assert info.location == "weights.bin"
+        assert info.offset == 16
+        assert isinstance(info.offset, int)
+        assert info.length == 1024
+        assert isinstance(info.length, int)
+        assert info.checksum == "sha256:abc123"
+
+    def test_unknown_key_rejected(self) -> None:
+        """Unknown external_data keys must not be set as object attributes (CWE-915)."""
+        tensor = self._make_tensor_with_external_data(
+            {"location": "weights.bin", "malicious_attr": "evil_value"}
+        )
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            info = ExternalDataInfo(tensor)
+        # Unknown attribute must NOT be set on the object
+        assert not hasattr(info, "malicious_attr"), (
+            "Unknown key 'malicious_attr' should not become an attribute"
+        )
+        # Valid key must still work
+        assert info.location == "weights.bin"
+        # A warning must have been emitted for the unknown key
+        assert any("malicious_attr" in str(w.message) for w in caught), (
+            "Expected warning about unknown key 'malicious_attr'"
+        )
+
+    def test_dunder_key_rejected(self) -> None:
+        """Dunder keys like '__class__' must not be injected via external_data (CWE-915).
+
+        Without the whitelist, setattr(self, '__class__', ...) would corrupt
+        the object type, enabling type confusion attacks.
+        """
+        tensor = self._make_tensor_with_external_data({"location": "weights.bin"})
+        # Add __class__ key via protobuf add() to mimic direct protobuf injection
+        dunder_entry = tensor.external_data.add()
+        dunder_entry.key = "__class__"
+        dunder_entry.value = "builtins.dict"
+
+        original_class = ExternalDataInfo
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            info = ExternalDataInfo(tensor)
+        # Object type must not have been corrupted
+        assert isinstance(info, original_class)
+        assert type(info).__name__ == "ExternalDataInfo"
+        assert info.location == "weights.bin"
+        # A warning must have been emitted for the dunder key
+        assert any("__class__" in str(w.message) for w in caught), (
+            "Expected warning about dunder key '__class__'"
+        )
+
+    def test_negative_offset_rejected(self) -> None:
+        """Negative offset must raise ValueError to prevent seek(-1) attacks."""
+        tensor = self._make_tensor_with_external_data(
+            {"location": "weights.bin", "offset": "-1"}
+        )
+        with pytest.raises(ValueError, match="non-negative"):
+            ExternalDataInfo(tensor)
+
+    def test_negative_length_rejected(self) -> None:
+        """Negative length must raise ValueError to prevent underflow attacks."""
+        tensor = self._make_tensor_with_external_data(
+            {"location": "weights.bin", "length": "-100"}
+        )
+        with pytest.raises(ValueError, match="non-negative"):
+            ExternalDataInfo(tensor)
+
+    def test_zero_offset_and_length_accepted(self) -> None:
+        """Zero values for offset/length should be accepted (edge case for bounds check)."""
+        tensor = self._make_tensor_with_external_data(
+            {"location": "weights.bin", "offset": "0", "length": "0"}
+        )
+        # Should not raise — zero is a valid non-negative value
+        info = ExternalDataInfo(tensor)
+        assert info.location == "weights.bin"
+        assert info.offset == 0
+        assert info.length == 0
+
+    def test_multiple_unknown_keys_all_rejected(self) -> None:
+        """Multiple unknown keys in a single tensor must all be rejected."""
+        tensor = self._make_tensor_with_external_data(
+            {
+                "location": "weights.bin",
+                "evil_one": "a",
+                "evil_two": "b",
+                "__dict__": "c",
+            }
+        )
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            info = ExternalDataInfo(tensor)
+        assert not hasattr(info, "evil_one")
+        assert not hasattr(info, "evil_two")
+        assert info.location == "weights.bin"
+        unknown_key_warnings = [
+            str(w.message)
+            for w in caught
+            if "unknown external data key" in str(w.message).lower()
+        ]
+        assert len(unknown_key_warnings) == 1, (
+            "Expected 1 aggregated warning for unknown keys"
+        )
+        # All unknown keys should be mentioned in the single warning
+        assert "evil_one" in unknown_key_warnings[0]
+        assert "evil_two" in unknown_key_warnings[0]
+        assert "__dict__" in unknown_key_warnings[0]
+
+    def test_allowed_keys_constant_is_frozen(self) -> None:
+        """The whitelist must be a frozenset to prevent runtime mutation."""
+        assert isinstance(_ALLOWED_EXTERNAL_DATA_KEYS, frozenset)
+        assert (
+            frozenset({"location", "offset", "length", "checksum", "basepath"})
+            == _ALLOWED_EXTERNAL_DATA_KEYS
+        )
+
+    def test_non_numeric_offset_raises(self) -> None:
+        """Non-numeric offset string must raise ValueError from int() conversion."""
+        tensor = self._make_tensor_with_external_data(
+            {"location": "weights.bin", "offset": "abc"}
+        )
+        with pytest.raises(ValueError):
+            ExternalDataInfo(tensor)
+
+    def test_non_numeric_length_raises(self) -> None:
+        """Non-numeric length string must raise ValueError from int() conversion."""
+        tensor = self._make_tensor_with_external_data(
+            {"location": "weights.bin", "length": "not_a_number"}
+        )
+        with pytest.raises(ValueError):
+            ExternalDataInfo(tensor)
+
+
+class TestLoadExternalDataFileSizeValidation(TestLoadExternalDataBase):
+    """Tests for defense-in-depth file-size validation in load_external_data_for_tensor."""
+
+    def test_offset_exceeds_file_size_raises(self) -> None:
+        """Offset beyond file size must raise ValueError."""
+        array = np.ones((4,), dtype=np.float32)
+        tensor = from_array(array, name="weight")
+        set_external_data(tensor, location="data.bin")
+
+        data_path = os.path.join(self.temp_dir, "data.bin")
+        with open(data_path, "wb") as f:
+            f.write(tensor.raw_data)
+
+        file_size = os.path.getsize(data_path)
+        # Set offset beyond file size
+        set_external_data(tensor, location="data.bin", offset=file_size + 100)
+        tensor.ClearField("raw_data")
+
+        with pytest.raises(ValueError, match=r"offset.*exceeds file size"):
+            load_external_data_for_tensor(tensor, self.temp_dir)
+
+    def test_length_exceeds_available_data_raises(self) -> None:
+        """Length that overflows available data must raise ValueError."""
+        array = np.ones((4,), dtype=np.float32)
+        tensor = from_array(array, name="weight")
+        set_external_data(tensor, location="data.bin")
+
+        data_path = os.path.join(self.temp_dir, "data.bin")
+        with open(data_path, "wb") as f:
+            f.write(tensor.raw_data)
+
+        file_size = os.path.getsize(data_path)
+        # Set length much larger than file
+        set_external_data(tensor, location="data.bin", length=file_size * 1000)
+        tensor.ClearField("raw_data")
+
+        with pytest.raises(ValueError, match=r"length.*exceeds available data"):
+            load_external_data_for_tensor(tensor, self.temp_dir)
+
+    def test_valid_offset_and_length_load_correctly(self) -> None:
+        """Valid offset+length within file size should load correctly."""
+        array = np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32)
+        tensor = from_array(array, name="weight")
+        raw = tensor.raw_data
+
+        data_path = os.path.join(self.temp_dir, "data.bin")
+        with open(data_path, "wb") as f:
+            f.write(raw)
+
+        set_external_data(tensor, location="data.bin", offset=0, length=len(raw))
+        tensor.ClearField("raw_data")
+
+        load_external_data_for_tensor(tensor, self.temp_dir)
+        assert tensor.raw_data == raw
diff --git a/onnx/test/tools_test.py b/onnx/test/tools_test.py
new file mode 100644
index 0000000..e47bc60
--- /dev/null
+++ b/onnx/test/tools_test.py
@@ -0,0 +1,321 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+from numpy.testing import assert_allclose
+
+import onnx
+from onnx import TensorProto, helper, numpy_helper
+from onnx.defs import onnx_opset_version
+from onnx.reference import ReferenceEvaluator
+from onnx.tools import update_model_dims
+from onnx.tools.replace_constants import replace_initializer_by_constant_of_shape
+
+
+class TestToolsFunctions:
+    def test_update_inputs_outputs_dim(self) -> None:
+        node_def = helper.make_node(
+            "Conv",
+            inputs=["x", "W"],
+            outputs=["y"],
+            kernel_shape=[3, 3],
+            strides=[2, 2],
+        )
+        graph_def = helper.make_graph(
+            [node_def],
+            "test",
+            [
+                helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 1, 5, 5]),
+                helper.make_tensor_value_info("W", TensorProto.FLOAT, [1, 1, 3, 3]),
+            ],
+            [helper.make_tensor_value_info("y", TensorProto.FLOAT, [1, 1, 2, 2])],
+        )
+        model_def = helper.make_model(graph_def, producer_name="test")
+        updated_def = update_model_dims.update_inputs_outputs_dims(
+            model_def,
+            {
+                "x": [1, 1, "x1", -1],
+                "W": [1, 1, 3, 3],
+            },
+            {
+                "y": [1, 1, -1, -1],
+            },
+        )
+        onnx.checker.check_model(updated_def)
+        assert (
+            updated_def.graph.input[0].type.tensor_type.shape.dim[2].dim_param == "x1"
+        )
+        assert (
+            updated_def.graph.input[0].type.tensor_type.shape.dim[3].dim_param == "x_3"
+        )
+        assert (
+            updated_def.graph.output[0].type.tensor_type.shape.dim[2].dim_param == "y_2"
+        )
+        assert (
+            updated_def.graph.output[0].type.tensor_type.shape.dim[3].dim_param == "y_3"
+        )
+
+    def test_replace_initializer(self):
+        dtype = np.float32
+        value = np.random.randn(2, 100).astype(dtype)
+        A = numpy_helper.from_array(value, name="A")
+        value = np.array([1], dtype=dtype)
+        C = numpy_helper.from_array(value, name="C")
+
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node1 = helper.make_node("MatMul", ["X", "A"], ["AX"])
+        node2 = helper.make_node("Sub", ["AX", "C"], ["Y"])
+        graph = helper.make_graph([node1, node2], "lr", [X], [Y], [A, C])
+        model_def = helper.make_model(graph)
+
+        x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
+        oinf1 = ReferenceEvaluator(model_def)
+        y1 = oinf1.run(None, {"X": x})[0]
+        repl = replace_initializer_by_constant_of_shape(model_def)
+        node_types = {n.op_type for n in repl.graph.node}
+        assert "ConstantOfShape" in node_types
+        oinf2 = ReferenceEvaluator(repl)
+        y1[:, :] = 3.5
+        y1[0, :] = 0.5
+        y2 = oinf2.run(None, {"X": x})[0]
+        assert_allclose(y1, y2)
+
+    def test_replace_constant(self):
+        dtype = np.float32
+        value = np.random.randn(2, 100).astype(dtype)
+        A = numpy_helper.from_array(value, name="A")
+        value = np.array([1], dtype=dtype)
+        C = numpy_helper.from_array(value, name="C")
+
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node0 = helper.make_node("Constant", [], ["A"], value=A)
+        node1 = helper.make_node("MatMul", ["X", "A"], ["AX"])
+        node2 = helper.make_node("Sub", ["AX", "C"], ["Y"])
+        graph = helper.make_graph([node0, node1, node2], "lr", [X], [Y], [C])
+        model_def = helper.make_model(graph)
+
+        x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
+        oinf1 = ReferenceEvaluator(model_def)
+        y1 = oinf1.run(None, {"X": x})[0]
+        repl = replace_initializer_by_constant_of_shape(model_def)
+        node_types = {n.op_type for n in repl.graph.node}
+        assert "ConstantOfShape" in node_types
+        oinf2 = ReferenceEvaluator(repl)
+        y1[:, :] = 3.5
+        y1[0, :] = 0.5
+        y2 = oinf2.run(None, {"X": x})[0]
+        assert_allclose(y1, y2)
+
+    def test_replace_range(self):
+        dtype = np.float32
+        value = np.random.randn(2, 100).astype(dtype)
+        A = numpy_helper.from_array(value, name="A")
+        value = np.array([1], dtype=dtype)
+        C = numpy_helper.from_array(value, name="C")
+
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        node0 = helper.make_node("Constant", [], ["A"], value=A)
+        node1 = helper.make_node("MatMul", ["X", "A"], ["AX"])
+        node2 = helper.make_node("Sub", ["AX", "C"], ["Y"])
+        graph = helper.make_graph([node0, node1, node2], "lr", [X], [Y], [C])
+        model_def = helper.make_model(graph)
+
+        x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
+        oinf1 = ReferenceEvaluator(model_def)
+        y1 = oinf1.run(None, {"X": x})[0]
+        repl = replace_initializer_by_constant_of_shape(model_def, use_range=True)
+        node_types = {n.op_type for n in repl.graph.node}
+        assert "Range" in node_types
+        assert "ConstantOfShape" not in node_types
+        oinf2 = ReferenceEvaluator(repl)
+        y2 = oinf2.run(None, {"X": x})[0]
+        assert_allclose(y1.shape, y2.shape)
+
+    def test_replace_constant_function(self):
+        dtype = np.float32
+        value = np.random.randn(2, 100).astype(dtype)
+        A = numpy_helper.from_array(value, name="A")
+        value = np.array([1], dtype=dtype)
+        C = numpy_helper.from_array(value, name="C")
+
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        nodeC = helper.make_node("Constant", [], ["C"], value=C)
+        node0 = helper.make_node("Constant", [], ["A"], value=A)
+        node1 = helper.make_node("MatMul", ["X", "A"], ["AX"])
+        node2 = helper.make_node("Sub", ["AX", "C"], ["Y"])
+        opset_imports = [
+            helper.make_opsetid("", onnx_opset_version()),
+            helper.make_opsetid("custom", 1),
+        ]
+        fct = helper.make_function(
+            "custom",
+            "unittest",
+            ["X"],
+            ["Y"],
+            [nodeC, node0, node1, node2],
+            opset_imports,
+        )
+
+        node = helper.make_node("unittest", ["X"], ["Y"], domain="custom")
+        graph = helper.make_graph([node], "lr", [X], [Y], [C])
+        model_def = helper.make_model(
+            graph, functions=[fct], opset_imports=opset_imports
+        )
+
+        x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
+        oinf1 = ReferenceEvaluator(model_def)
+        y1 = oinf1.run(None, {"X": x})[0]
+        repl = replace_initializer_by_constant_of_shape(model_def)
+        node_types = {n.op_type for n in repl.functions[0].node}
+        assert "ConstantOfShape" in node_types
+        oinf2 = ReferenceEvaluator(repl)
+        y1[:, :] = 3.5
+        y1[0, :] = 0.5
+        y2 = oinf2.run(None, {"X": x})[0]
+        assert_allclose(y1, y2)
+
+    def test_replace_range_function(self):
+        dtype = np.float32
+        value = np.random.randn(2, 100).astype(dtype)
+        A = numpy_helper.from_array(value, name="A")
+        value = np.array([1], dtype=dtype)
+        C = numpy_helper.from_array(value, name="C")
+
+        X = helper.make_tensor_value_info("X", TensorProto.FLOAT, [None, None])
+        Y = helper.make_tensor_value_info("Y", TensorProto.FLOAT, [None])
+        nodeC = helper.make_node("Constant", [], ["C"], value=C)
+        node0 = helper.make_node("Constant", [], ["A"], value=A)
+        node1 = helper.make_node("MatMul", ["X", "A"], ["AX"])
+        node2 = helper.make_node("Sub", ["AX", "C"], ["Y"])
+        opset_imports = [
+            helper.make_opsetid("", onnx_opset_version()),
+            helper.make_opsetid("custom", 1),
+        ]
+        fct = helper.make_function(
+            "custom",
+            "unittest",
+            ["X"],
+            ["Y"],
+            [nodeC, node0, node1, node2],
+            opset_imports,
+        )
+
+        node = helper.make_node("unittest", ["X"], ["Y"], domain="custom")
+        graph = helper.make_graph([node], "lr", [X], [Y], [C])
+        model_def = helper.make_model(
+            graph, functions=[fct], opset_imports=opset_imports
+        )
+
+        x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
+        oinf1 = ReferenceEvaluator(model_def)
+        y1 = oinf1.run(None, {"X": x})[0]
+        repl = replace_initializer_by_constant_of_shape(model_def, use_range=True)
+        node_types = {n.op_type for n in repl.functions[0].node}
+        assert "Range" in node_types
+        assert "ConstantOfShape" not in node_types
+        oinf2 = ReferenceEvaluator(repl)
+        y2 = oinf2.run(None, {"X": x})[0]
+        assert_allclose(y1.shape, y2.shape)
+
+    def test_replace_constant_graph(self):
+        value = np.array([0], dtype=np.float32)
+        zero = numpy_helper.from_array(value, name="zero")
+
+        X = helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+        Y = helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+
+        rsum = helper.make_node("ReduceSum", ["X"], ["rsum"])
+        cond = helper.make_node("Greater", ["rsum", "zero"], ["cond"])
+
+        then_out = helper.make_tensor_value_info(
+            "then_out", onnx.TensorProto.FLOAT, None
+        )
+        then_cst = numpy_helper.from_array(np.array([1] * 129).astype(np.float32))
+
+        then_const_node = helper.make_node(
+            "Constant", inputs=[], outputs=["then_out"], value=then_cst, name="cst1"
+        )
+        then_body = helper.make_graph([then_const_node], "then_body", [], [then_out])
+
+        else_out = helper.make_tensor_value_info(
+            "else_out", onnx.TensorProto.FLOAT, None
+        )
+        else_cst = numpy_helper.from_array(np.array([-1] * 129).astype(np.float32))
+        else_const_node = helper.make_node(
+            "Constant", inputs=[], outputs=["else_out"], value=else_cst, name="cst2"
+        )
+        else_body = helper.make_graph([else_const_node], "else_body", [], [else_out])
+
+        if_node = onnx.helper.make_node(
+            "If", ["cond"], ["Y"], then_branch=then_body, else_branch=else_body
+        )
+        graph = helper.make_graph([rsum, cond, if_node], "if", [X], [Y], [zero])
+        onnx_model = helper.make_model(
+            graph, opset_imports=[helper.make_opsetid("", onnx_opset_version())]
+        )
+        assert "ConstantOfShape" not in str(onnx_model)
+
+        x = np.ones((3, 2), dtype=np.float32)
+        oinf1 = ReferenceEvaluator(onnx_model)
+        y1 = oinf1.run(None, {"X": x})[0]
+        repl = replace_initializer_by_constant_of_shape(onnx_model)
+        assert "ConstantOfShape" in str(repl)
+        oinf2 = ReferenceEvaluator(repl)
+        y2 = oinf2.run(None, {"X": x})[0]
+        y1 = y1.copy()
+        y1[:] = 0.5
+        assert_allclose(y1, y2)
+
+    def test_replace_range_graph(self):
+        value = np.array([0], dtype=np.float32)
+        zero = numpy_helper.from_array(value, name="zero")
+
+        X = helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [None, None])
+        Y = helper.make_tensor_value_info("Y", onnx.TensorProto.FLOAT, [None])
+
+        rsum = helper.make_node("ReduceSum", ["X"], ["rsum"])
+        cond = helper.make_node("Greater", ["rsum", "zero"], ["cond"])
+
+        then_out = helper.make_tensor_value_info(
+            "then_out", onnx.TensorProto.FLOAT, None
+        )
+        then_cst = numpy_helper.from_array(np.array([1] * 129).astype(np.float32))
+
+        then_const_node = helper.make_node(
+            "Constant", inputs=[], outputs=["then_out"], value=then_cst, name="cst1"
+        )
+        then_body = helper.make_graph([then_const_node], "then_body", [], [then_out])
+
+        else_out = helper.make_tensor_value_info(
+            "else_out", onnx.TensorProto.FLOAT, None
+        )
+        else_cst = numpy_helper.from_array(np.array([-1] * 129).astype(np.float32))
+        else_const_node = helper.make_node(
+            "Constant", inputs=[], outputs=["else_out"], value=else_cst, name="cst2"
+        )
+        else_body = helper.make_graph([else_const_node], "else_body", [], [else_out])
+
+        if_node = onnx.helper.make_node(
+            "If", ["cond"], ["Y"], then_branch=then_body, else_branch=else_body
+        )
+        graph = helper.make_graph([rsum, cond, if_node], "if", [X], [Y], [zero])
+        onnx_model = helper.make_model(
+            graph, opset_imports=[helper.make_opsetid("", onnx_opset_version())]
+        )
+        assert "ConstantOfShape" not in str(onnx_model)
+
+        x = np.ones((3, 2), dtype=np.float32)
+        oinf1 = ReferenceEvaluator(onnx_model)
+        y1 = oinf1.run(None, {"X": x})[0]
+        repl = replace_initializer_by_constant_of_shape(onnx_model, use_range=True)
+        assert "ConstantOfShape" not in str(repl)
+        assert "Range" in str(repl)
+        oinf2 = ReferenceEvaluator(repl)
+        y2 = oinf2.run(None, {"X": x})[0]
+        assert_allclose(y1.shape, y2.shape)
diff --git a/onnx/test/training_tool_test.py b/onnx/test/training_tool_test.py
new file mode 100644
index 0000000..6ed0b07
--- /dev/null
+++ b/onnx/test/training_tool_test.py
@@ -0,0 +1,95 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+import onnx
+from onnx import TensorProto, helper, numpy_helper, shape_inference
+
+
+class TestTrainingTool:
+    def test_training_info_proto(self) -> None:
+        # Inference graph.
+        A_shape = [2, 2]
+        A_name = "A"
+        A = np.random.rand(*A_shape).astype(np.float32)
+        A_initializer = numpy_helper.from_array(A, name=A_name)
+        A_value_info = helper.make_tensor_value_info(A_name, TensorProto.FLOAT, A_shape)
+
+        B_shape = [2, 2]
+        B_name = "B"
+        B = np.random.rand(*B_shape).astype(np.float32)
+        B_initializer = numpy_helper.from_array(B, name=B_name)
+        B_value_info = helper.make_tensor_value_info(B_name, TensorProto.FLOAT, B_shape)
+
+        C_shape = [2, 2]
+        C_name = "C"
+        C_value_info = helper.make_tensor_value_info(C_name, TensorProto.FLOAT, C_shape)
+
+        inference_node = helper.make_node(
+            "MatMul", inputs=[A_name, B_name], outputs=[C_name]
+        )
+
+        inference_graph = helper.make_graph(
+            [inference_node],
+            "simple_inference",
+            [A_value_info, B_value_info],
+            [C_value_info],
+            [A_initializer, B_initializer],
+        )
+
+        # Training graph
+        X_shape = [2, 2]
+        X_name = "X"
+        X = np.random.rand(*X_shape).astype(np.float32)
+        X_initializer = numpy_helper.from_array(X, name=X_name)
+        X_value_info = helper.make_tensor_value_info(X_name, TensorProto.FLOAT, X_shape)
+
+        Y_shape = [2, 2]
+        Y_name = "Y"
+        Y_value_info = helper.make_tensor_value_info(Y_name, TensorProto.FLOAT, Y_shape)
+
+        node = helper.make_node(
+            "MatMul",
+            inputs=[X_name, C_name],  # tensor "C" is from inference graph.
+            outputs=[Y_name],
+        )
+
+        training_graph = helper.make_graph(
+            [node], "simple_training", [X_value_info], [Y_value_info], [X_initializer]
+        )
+
+        # Capture assignment of B <--- Y.
+        training_info = helper.make_training_info(
+            training_graph, [(B_name, Y_name)], None, None
+        )
+
+        # Create a model with both inference and training information.
+        model = helper.make_model(inference_graph)
+        # Check if the inference-only part is correct.
+        onnx.checker.check_model(model)
+        # Insert training information.
+        new_training_info = model.training_info.add()
+        new_training_info.CopyFrom(training_info)
+
+        # Generate the actual training graph from training information so that
+        # we can run onnx checker to check if the full training graph is a valid
+        # graph. As defined in spec, full training graph forms by concatenating
+        # corresponding fields.
+        full_training_graph = helper.make_graph(
+            list(model.graph.node) + list(model.training_info[0].algorithm.node),
+            "full_training_graph",
+            list(model.graph.input) + list(model.training_info[0].algorithm.input),
+            list(model.graph.output) + list(model.training_info[0].algorithm.output),
+            list(model.graph.initializer)
+            + list(model.training_info[0].algorithm.initializer),
+        )
+
+        # Wrap full training graph as a ModelProto so that we can run checker.
+        full_training_model = helper.make_model(full_training_graph)
+        full_training_model_with_shapes = shape_inference.infer_shapes(
+            full_training_model
+        )
+        onnx.checker.check_model(full_training_model_with_shapes)
diff --git a/onnx/test/utils_test.py b/onnx/test/utils_test.py
new file mode 100644
index 0000000..be14028
--- /dev/null
+++ b/onnx/test/utils_test.py
@@ -0,0 +1,79 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import io
+import os
+import shutil
+import tarfile
+import tempfile
+
+import pytest
+
+import onnx
+from onnx import TensorProto, helper
+
+
+class TestUtilityFunctions:
+    def test_extract_model(self) -> None:
+        def create_tensor(name):
+            return helper.make_tensor_value_info(name, TensorProto.FLOAT, [1, 2])
+
+        A0 = create_tensor("A0")
+        A1 = create_tensor("A1")
+        B0 = create_tensor("B0")
+        B1 = create_tensor("B1")
+        B2 = create_tensor("B2")
+        C0 = create_tensor("C0")
+        C1 = create_tensor("C1")
+        D0 = create_tensor("D0")
+        L0_0 = helper.make_node("Add", ["A0", "A1"], ["B0"])
+        L0_1 = helper.make_node("Sub", ["A0", "A1"], ["B1"])
+        L0_2 = helper.make_node("Mul", ["A0", "A1"], ["B2"])
+        L1_0 = helper.make_node("Add", ["B0", "B1"], ["C0"])
+        L1_1 = helper.make_node("Sub", ["B1", "B2"], ["C1"])
+        L2_0 = helper.make_node("Mul", ["C0", "C1"], ["D0"])
+
+        g0 = helper.make_graph(
+            [L0_0, L0_1, L0_2, L1_0, L1_1, L2_0], "test", [A0, A1], [D0]
+        )
+        m0 = helper.make_model(g0, producer_name="test")
+        tdir = tempfile.mkdtemp()
+        p0 = os.path.join(tdir, "original.onnx")
+        onnx.save(m0, p0)
+
+        p1 = os.path.join(tdir, "extracted.onnx")
+        input_names = ["B0", "B1", "B2"]
+        output_names = ["C0", "C1"]
+        onnx.utils.extract_model(p0, p1, input_names, output_names)
+
+        m1 = onnx.load(p1)
+        assert m1.producer_name == "onnx.utils.extract_model"
+        assert m1.ir_version == m0.ir_version
+        assert m1.opset_import == m0.opset_import
+        assert len(m1.graph.node) == 2
+        assert len(m1.graph.input) == 3
+        assert len(m1.graph.output) == 2
+        assert m1.graph.input[0] == B0
+        assert m1.graph.input[1] == B1
+        assert m1.graph.input[2] == B2
+        assert m1.graph.output[0] == C0
+        assert m1.graph.output[1] == C1
+        shutil.rmtree(tdir, ignore_errors=True)
+
+    def test_tar_members_filter_rejects_sibling_prefix_escape(self) -> None:
+        with tempfile.TemporaryDirectory() as tdir:
+            base = os.path.join(tdir, "model")
+            os.mkdir(base)
+            tar_path = os.path.join(tdir, "payload.tar")
+
+            with tarfile.open(tar_path, "w") as tar:
+                payload = b"outside extraction root"
+                info = tarfile.TarInfo("../model_evil/pwned.txt")
+                info.size = len(payload)
+                tar.addfile(info, io.BytesIO(payload))
+
+            with tarfile.open(tar_path) as tar:  # noqa: SIM117
+                with pytest.raises(RuntimeError, match="directory traversal"):
+                    onnx.utils._tar_members_filter(tar, base)
diff --git a/onnx/test/version_converter/automatic_conversion_test_base.py b/onnx/test/version_converter/automatic_conversion_test_base.py
new file mode 100644
index 0000000..c912753
--- /dev/null
+++ b/onnx/test/version_converter/automatic_conversion_test_base.py
@@ -0,0 +1,160 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import string
+from typing import TYPE_CHECKING, Any, cast
+
+import pytest
+
+import onnx
+from onnx import TensorProto, ValueInfoProto, helper, shape_inference, version_converter
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+LATEST_OPSET = onnx.defs.onnx_opset_version()
+
+
+class TestAutomaticConversion:
+    def _test_model_conversion(
+        self, to_opset: int, model: str | onnx.ModelProto
+    ) -> None:
+        if isinstance(model, str):
+            model = onnx.parser.parse_model(model)
+        onnx.checker.check_model(model)
+        shape_inference.infer_shapes(model, strict_mode=True)
+
+        converted = version_converter.convert_version(model, to_opset)
+        onnx.checker.check_model(converted)
+        shape_inference.infer_shapes(converted, strict_mode=True)
+
+    def _test_model_conversion_fails(
+        self, to_opset: int, model: str | onnx.ModelProto
+    ) -> None:
+        if isinstance(model, str):
+            model = onnx.parser.parse_model(model)
+        onnx.checker.check_model(model)
+        shape_inference.infer_shapes(model, strict_mode=True)
+
+        with pytest.raises(RuntimeError):
+            version_converter.convert_version(model, to_opset)
+
+    def _test_op_conversion(
+        self,
+        op: str,
+        from_opset: int,
+        input_shapes: Sequence[Sequence[int | None] | str] = ((3, 4, 5),),
+        output_shapes: Sequence[Sequence[int | None]] = ((3, 4, 5),),
+        input_types: Sequence[Any] | None = None,
+        output_types: Sequence[Any] | None = None,
+        initializer: Sequence[Any] = (),
+        attrs: dict[str, Any] | None = None,
+        seq_inputs: Sequence[int] = (),
+        seq_outputs: Sequence[int] = (),
+        optional_inputs: Sequence[int] = (),
+        optional_outputs: Sequence[int] = (),
+        is_upgrade: bool = True,
+    ) -> None:
+        """Test conversion.
+
+        Args:
+            op: A string representing the name of the operator to test.
+            from_opset: An integer representing the lowest opset version to convert.
+            input_shapes: A sequence of tuples or strings representing the shapes of the input tensors.
+                The default value is ((3, 4, 5),).
+            output_shapes: A sequence of tuples representing the shapes of the output tensors.
+                The default value is ((3, 4, 5),).
+            input_types: An optional sequence of types representing the data types of the input tensors.
+            output_types: An optional sequence of types representing the data types of the output tensors.
+            initializer: A sequence of values representing the initial values of the input tensors.
+            attrs: An optional dictionary of attributes for the operator.
+            seq_inputs: A sequence of integers representing the indices of the input tensors that are sequences.
+            seq_outputs: A sequence of integers representing the indices of the output tensors that are sequences.
+            optional_inputs: A sequence of integers representing the indices of the input tensors that are optional.
+            optional_outputs: A sequence of integers representing the indices of the output tensors that are optional.
+            is_upgrade: A boolean value indicating whether to run the version converter from from_opset to
+                the most recent opset version (True) or from the most recent opset version to from_opset (False).
+                The default value is True. In both cases, runs checker and shape inference on the final model.
+        """
+        if attrs is None:
+            attrs = {}
+
+        n_inputs = len(input_shapes)
+        letters = list(string.ascii_lowercase)[:n_inputs]
+        input_names = [
+            letter if shape != "" else ""
+            for (letter, shape) in zip(letters, input_shapes, strict=True)
+        ]
+        if input_types is None:
+            input_types = [TensorProto.FLOAT] * n_inputs
+        is_sequence = [0 if id not in seq_inputs else 1 for id in range(n_inputs)]
+        is_optional = [0 if id not in optional_inputs else 1 for id in range(n_inputs)]
+        # turn empty strings into [0] to ease type analysis, even though those entries
+        # will be ignored
+        input_shapes_cast = cast(
+            "list[list[int]]",
+            [[0] if isinstance(shape, str) else shape for shape in input_shapes],
+        )
+        inputs: list[ValueInfoProto] = []
+        for name, ttype, shape, is_seq, is_opt in zip(
+            input_names,
+            input_types,
+            input_shapes_cast,
+            is_sequence,
+            is_optional,
+            strict=False,
+        ):
+            if name != "":
+                if is_seq:
+                    inputs += [
+                        helper.make_tensor_sequence_value_info(name, ttype, shape)
+                    ]
+                elif is_opt:
+                    type_proto = helper.make_tensor_type_proto(ttype, shape)
+                    optional_type_proto = helper.make_optional_type_proto(type_proto)
+                    inputs += [helper.make_value_info(name, optional_type_proto)]
+                else:
+                    inputs += [helper.make_tensor_value_info(name, ttype, shape)]
+
+        n_outputs = len(output_shapes)
+        output_names = list(string.ascii_lowercase)[n_inputs : n_inputs + n_outputs]
+        if output_types is None:
+            output_types = [TensorProto.FLOAT] * n_outputs
+        is_sequence = [0 if id not in seq_outputs else 1 for id in range(n_outputs)]
+        is_optional = [
+            0 if id not in optional_outputs else 1 for id in range(n_outputs)
+        ]
+        output_shapes_cast = cast(
+            "list[list[int]]",
+            [[0] if isinstance(shape, str) else shape for shape in output_shapes],
+        )
+        outputs: list[ValueInfoProto] = []
+        for name, ttype, shape, is_seq, is_opt in zip(
+            output_names,
+            output_types,
+            output_shapes_cast,
+            is_sequence,
+            is_optional,
+            strict=True,
+        ):
+            if is_seq:
+                outputs += [helper.make_tensor_sequence_value_info(name, ttype, shape)]
+            elif is_opt:
+                type_proto = helper.make_tensor_type_proto(ttype, shape)
+                optional_type_proto = helper.make_optional_type_proto(type_proto)
+                outputs += [helper.make_value_info(name, optional_type_proto)]
+            else:
+                outputs += [helper.make_tensor_value_info(name, ttype, shape)]
+
+        node = helper.make_node(op, input_names, output_names, **attrs)
+        graph = helper.make_graph([node], op, inputs, outputs, initializer)
+        start_opset = from_opset if is_upgrade else LATEST_OPSET
+        end_opset = LATEST_OPSET if is_upgrade else from_opset
+        original = helper.make_model(
+            graph,
+            producer_name="test",
+            opset_imports=[helper.make_opsetid("", start_opset)],
+        )
+        self._test_model_conversion(end_opset, original)
diff --git a/onnx/test/version_converter/automatic_downgrade_test.py b/onnx/test/version_converter/automatic_downgrade_test.py
new file mode 100644
index 0000000..fae2b39
--- /dev/null
+++ b/onnx/test/version_converter/automatic_downgrade_test.py
@@ -0,0 +1,130 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import automatic_conversion_test_base
+import numpy as np
+import pytest
+
+import onnx
+from onnx import helper
+
+#####################################################################################
+# Every test calls _test_op_conversion to downgrade a model from the most recent opset version
+# to a early version and runs checker + shape inference on the downgraded model.
+####################################################################################
+
+
+class TestAutomaticDowngrade(automatic_conversion_test_base.TestAutomaticConversion):
+    def _test_op_downgrade(self, op: str, *args, **kwargs):
+        self._test_op_conversion(op, *args, **kwargs, is_upgrade=False)
+
+    @pytest.mark.parametrize(
+        "op",
+        [
+            "ReduceL1",
+            "ReduceL2",
+            "ReduceLogSum",
+            "ReduceLogSumExp",
+            "ReduceMean",
+            "ReduceMax",
+            "ReduceMin",
+            "ReduceProd",
+            "ReduceSum",
+            "ReduceSumSquare",
+        ],
+    )
+    def test_reduce_ops(self, op) -> None:
+        # TODO: need to add test cases for missing axes input which depends on this pr:
+        # https://github.com/onnx/onnx/pull/5613
+        axes = helper.make_tensor(
+            "b", onnx.TensorProto.INT64, dims=[3], vals=np.array([0, 1, 2])
+        )
+        self._test_op_downgrade(
+            op,
+            from_opset=13,
+            input_shapes=[[3, 4, 5], [3]],
+            output_shapes=[[1, 1, 1]],
+            input_types=[onnx.TensorProto.FLOAT, onnx.TensorProto.INT64],
+            initializer=[axes],
+        )
+
+    def test_dft20_no_axis(self) -> None:
+        self._test_model_conversion(
+            to_opset=19,
+            model="""
+            <ir_version: 9, opset_import: [ "" : 20]>
+            dft_no_axis (float[N, M, 1] x) => (float[N, M, 2] y)
+            {
+                y = DFT (x)
+            }
+        """,
+        )
+
+    def test_dft20_initializer_axis(self) -> None:
+        self._test_model_conversion(
+            to_opset=19,
+            model="""
+            <ir_version: 9, opset_import: [ "" : 20]>
+            dft_no_axis (float[N, M, 1] x, int64 dft_length) => (float[N, K, 2] y)
+            <int64 axis = {1}>
+            {
+                y = DFT (x, dft_length, axis)
+            }
+        """,
+        )
+
+    def test_dft20_constant_axis(self) -> None:
+        self._test_model_conversion(
+            to_opset=19,
+            model="""
+            <ir_version: 9, opset_import: [ "" : 20]>
+            dft_no_axis (float[N, M, 1] x, int64 dft_length) => (float[N, K, 2] y)
+            {
+                axis = Constant <value = int64{1}>()
+                y = DFT (x, dft_length, axis)
+            }
+        """,
+        )
+
+    def test_dft20_unknown_axis(self) -> None:
+        self._test_model_conversion_fails(
+            to_opset=19,
+            model="""
+            <ir_version: 9, opset_import: [ "" : 20]>
+            dft_no_axis (float[N, M, 1] x, int64 dft_length, int64 axis) => (float[P, K, 2] y)
+            {
+                y = DFT (x, dft_length, axis)
+            }
+        """,
+        )
+
+    def test_LinearAttention_downgrade_fails(self) -> None:
+        self._test_model_conversion_fails(
+            to_opset=24,
+            model="""
+            <ir_version: 10, opset_import: [ "" : 27]>
+            linear_attention (float[2, 4, 64] Q, float[2, 4, 64] K, float[2, 4, 64] V)
+                => (float[2, 4, 64] output, float[2, 4, 16, 16] present_state)
+            {
+                output, present_state = LinearAttention <q_num_heads = 4, kv_num_heads = 4, update_rule = "linear"> (Q, K, V)
+            }
+        """,
+        )
+
+    def test_CausalConvWithState_downgrade_fails(self) -> None:
+        # CausalConvWithState was introduced at opset 27; no decomposition
+        # adapter exists for downgrading to opset 24. The version converter
+        # must raise.
+        self._test_model_conversion_fails(
+            to_opset=24,
+            model="""
+            <ir_version: 10, opset_import: [ "" : 27]>
+            causal_conv_with_state (float[2, 4, 8] input, float[4, 1, 4] weight)
+                => (float[2, 4, 8] output, float[2, 4, 3] present_state)
+            {
+                output, present_state = CausalConvWithState (input, weight)
+            }
+        """,
+        )
diff --git a/onnx/test/version_converter/automatic_upgrade_test.py b/onnx/test/version_converter/automatic_upgrade_test.py
new file mode 100644
index 0000000..d1b59a6
--- /dev/null
+++ b/onnx/test/version_converter/automatic_upgrade_test.py
@@ -0,0 +1,2110 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import ClassVar
+
+import automatic_conversion_test_base
+import numpy as np
+
+import onnx
+from onnx import TensorProto, helper
+
+#####################################################################################
+# Every test calls _test_op_conversion to upgrade a model from an initial opset version
+# to the most recent version and runs checker and shape inference on the final upgraded model.
+####################################################################################
+
+
+class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversion):
+    tested_ops: ClassVar[list] = []
+
+    def _test_op_upgrade(self, op, *args, **kwargs):
+        self.tested_ops.append(op)
+        self._test_op_conversion(op, *args, **kwargs, is_upgrade=True)
+
+    def test_Abs(self) -> None:
+        self._test_op_upgrade("Abs", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Acosh(self) -> None:
+        self._test_op_upgrade("Acosh", 9)
+
+    def test_Acos(self) -> None:
+        self._test_op_upgrade("Acos", 7)
+
+    def test_And(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "And",
+            7,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+            [TensorProto.BOOL, TensorProto.BOOL],
+            [TensorProto.BOOL],
+        )
+
+    def test_Asinh(self) -> None:
+        self._test_op_upgrade("Asinh", 9)
+
+    def test_Atanh(self) -> None:
+        self._test_op_upgrade("Atanh", 9)
+
+    def test_Add_1(self) -> None:
+        self._test_op_upgrade(
+            "Add", 1, [[3, 4, 5], [3, 4, 5]], attrs={"consumed_inputs": [0]}
+        )
+
+    def test_Add_2(self) -> None:
+        self._test_op_upgrade(
+            "Add", 1, [[3, 4, 5], [5]], attrs={"consumed_inputs": [0], "broadcast": 1}
+        )
+
+    def test_Add_3(self) -> None:
+        self._test_op_upgrade(
+            "Add",
+            1,
+            [[3, 4, 5], [3]],
+            attrs={"consumed_inputs": [0], "broadcast": 1, "axis": 0},
+        )
+
+    def test_AffineGrid_2D(self) -> None:
+        N, _, H, W = 2, 3, 5, 6
+        self._test_op_upgrade("AffineGrid", 20, [[N, 2, 3], [4]], [[N, H, W, 2]])
+
+    def test_AffineGrid_3D(self) -> None:
+        N, _, D, H, W = 2, 3, 4, 5, 6
+        self._test_op_upgrade("AffineGrid", 20, [[N, 3, 4], [5]], [[N, D, H, W, 3]])
+
+    def test_ArgMax_1(self) -> None:
+        self._test_op_upgrade(
+            "ArgMax", 7, [[2, 3, 4]], [[1, 3, 4]], output_types=[TensorProto.INT64]
+        )
+
+    def test_ArgMax_2(self) -> None:
+        self._test_op_upgrade(
+            "ArgMax",
+            7,
+            [[2, 3, 4]],
+            [[2, 1, 4]],
+            output_types=[TensorProto.INT64],
+            attrs={"axis": 1},
+        )
+
+    def test_ArgMin_1(self) -> None:
+        self._test_op_upgrade(
+            "ArgMin", 7, [[2, 3, 4]], [[1, 3, 4]], output_types=[TensorProto.INT64]
+        )
+
+    def test_ArgMin_2(self) -> None:
+        self._test_op_upgrade(
+            "ArgMin",
+            7,
+            [[2, 3, 4]],
+            [[2, 1, 4]],
+            output_types=[TensorProto.INT64],
+            attrs={"axis": 1},
+        )
+
+    def test_Asin(self) -> None:
+        self._test_op_upgrade("Asin", 7)
+
+    def test_Atan(self) -> None:
+        self._test_op_upgrade("Atan", 7)
+
+    def test_Attention_1(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_2(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 9, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 9, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_3(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 10]],
+            [[2, 3, 4, 10]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_4(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+            attrs={"scale": 2.0},
+        )
+
+    def test_Attention_5(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+            attrs={"is_causal": 1},
+        )
+
+    def test_Attention_6(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8], [4, 6]],
+            [[2, 3, 4, 8]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+            ],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_7(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8], [4, 6]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.BOOL],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Attention_8(self) -> None:
+        self._test_op_upgrade(
+            "Attention",
+            23,
+            [[2, 3, 4, 8], [2, 3, 6, 8], [2, 3, 6, 8]],
+            [[2, 3, 4, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+            attrs={"softcap": 2.0},
+        )
+
+    def test_AveragePool(self) -> None:
+        self._test_op_upgrade(
+            "AveragePool",
+            1,
+            [[1, 1, 5, 5]],
+            [[1, 1, 4, 4]],
+            attrs={"kernel_shape": [2, 2]},
+        )
+
+    def test_Bernoulli(self) -> None:
+        self._test_op_upgrade("Bernoulli", 15)
+
+    def test_BitShift(self) -> None:
+        self._test_op_upgrade(
+            "BitShift",
+            11,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+            [TensorProto.UINT8, TensorProto.UINT8],
+            [TensorProto.UINT8],
+            attrs={"direction": "RIGHT"},
+        )
+
+    def test_BatchNormalization_1(self) -> None:
+        self._test_op_upgrade(
+            "BatchNormalization",
+            1,
+            [[1, 3], [3], [3], [3], [3]],
+            [[1, 3]],
+            attrs={"consumed_inputs": [1, 1], "is_test": 1, "spatial": 1},
+        )
+
+    def test_BatchNormalization_2(self) -> None:
+        self._test_op_upgrade(
+            "BatchNormalization",
+            14,
+            [[1, 3], [3], [3], [3], [3]],
+            [[1, 3], [3], [3]],
+            attrs={"training_mode": 1},
+        )
+
+    def test_Cast(self) -> None:
+        # 5->6 adapter is missing
+        self._test_op_upgrade(
+            "Cast", 6, [[2, 3]], [[2, 3]], [TensorProto.INT64], attrs={"to": 1}
+        )
+
+    def test_Ceil(self) -> None:
+        self._test_op_upgrade("Ceil", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Celu(self) -> None:
+        self._test_op_upgrade("Celu", 12)
+
+    def test_Clip_1(self) -> None:
+        self._test_op_upgrade("Clip", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Clip_2(self) -> None:
+        self._test_op_upgrade("Clip", 1, attrs={"consumed_inputs": [0], "min": -1.4})
+
+    def test_Clip_3(self) -> None:
+        self._test_op_upgrade("Clip", 1, attrs={"consumed_inputs": [0], "max": 2.6})
+
+    def test_Clip_4(self) -> None:
+        self._test_op_upgrade(
+            "Clip", 1, attrs={"consumed_inputs": [0], "min": -1.4, "max": 2.6}
+        )
+
+    def test_Col2Im_4D(self) -> None:
+        self._test_op_upgrade("Col2Im", 18, [[1, 5, 5], [2], [2]], [[1, 1, 5, 5]])
+
+    def test_Col2Im_5D(self) -> None:
+        self._test_op_upgrade("Col2Im", 18, [[1, 10, 12], [3], [3]], [[1, 2, 3, 4, 5]])
+
+    def test_Compress(self) -> None:
+        self._test_op_upgrade(
+            "Compress",
+            9,
+            [[6, 7], [3]],
+            [[3]],
+            [TensorProto.FLOAT, TensorProto.BOOL],
+            [TensorProto.FLOAT],
+        )
+
+    def test_Concat(self) -> None:
+        self._test_op_upgrade("Concat", 1, [[2, 3], [2, 4]], [[2, 7]])
+
+    def test_constant(self) -> None:
+        value = helper.make_tensor(
+            "Value",
+            TensorProto.FLOAT,
+            dims=[3, 4, 5],
+            vals=np.random.rand(3, 4, 5).astype(np.float32),
+            raw=True,
+        )
+        self._test_op_upgrade("Constant", 1, [], attrs={"value": value})
+
+    def test_ConstantOfShape(self) -> None:
+        self._test_op_upgrade("ConstantOfShape", 9, [[3]])
+
+    def test_Conv_1(self) -> None:
+        self._test_op_upgrade(
+            "Conv", 1, [[1, 3, 5, 5], [4, 3, 2, 2], [4]], [[1, 4, 4, 4]]
+        )
+
+    def test_Conv_2(self) -> None:
+        # strided Conv: floor((5 - 2) / 2) + 1 = 2 in each spatial dim
+        self._test_op_upgrade(
+            "Conv",
+            1,
+            [[1, 3, 5, 5], [4, 3, 2, 2], [4]],
+            [[1, 4, 2, 2]],
+            attrs={"strides": [2, 2]},
+        )
+
+    def test_Conv_3(self) -> None:
+        self._test_op_upgrade(
+            "Conv",
+            1,
+            [[1, 3, 5, 5], [4, 1, 2, 2], [4]],
+            [[1, 4, 3, 7]],
+            attrs={
+                "dilations": [1, 2],
+                "group": 3,
+                "pads": [0, 1, 2, 3],
+                "strides": [2, 1],
+            },
+        )
+
+    def test_Convinteger(self) -> None:
+        self._test_op_upgrade(
+            "ConvInteger",
+            10,
+            [[1, 3, 5, 5], [4, 3, 2, 2], [4]],
+            [[1, 4, 4, 4]],
+            [TensorProto.UINT8, TensorProto.UINT8, TensorProto.UINT8],
+            [TensorProto.INT32],
+        )
+
+    def test_ConvTranspose(self) -> None:
+        self._test_op_upgrade(
+            "ConvTranspose", 1, [[1, 1, 5, 5], [1, 1, 3, 3]], [[1, 1, 7, 7]]
+        )
+
+    def test_DeformConv(self) -> None:
+        self._test_op_upgrade(
+            "DeformConv",
+            19,
+            [[1, 1, 3, 3], [1, 1, 2, 2], [1, 8, 2, 2]],
+            [[1, 1, 2, 2]],
+        )
+
+    def test_Cosh(self) -> None:
+        self._test_op_upgrade("Cosh", 9)
+
+    def test_Cos(self) -> None:
+        self._test_op_upgrade("Cos", 7)
+
+    def test_CumProd(self) -> None:
+        self._test_op_upgrade(
+            "CumProd",
+            26,
+            [[3, 4, 5], []],
+            [[3, 4, 5]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+        )
+
+    def test_Cumsum(self) -> None:
+        self._test_op_upgrade(
+            "CumSum",
+            11,
+            [[3, 4, 5], []],
+            [[3, 4, 5]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+        )
+
+    def test_DepthToSpace(self) -> None:
+        self._test_op_upgrade(
+            "DepthToSpace", 1, [[1, 8, 3, 3]], [[1, 2, 6, 6]], attrs={"blocksize": 2}
+        )
+
+    def test_DequantizeLinear(self) -> None:
+        self._test_op_upgrade(
+            "DequantizeLinear",
+            10,
+            [[2, 3], [], []],
+            [[2, 3]],
+            [TensorProto.INT8, TensorProto.FLOAT, TensorProto.INT8],
+        )
+
+    def test_Det_1(self) -> None:
+        self._test_op_upgrade("Det", 11, [[3, 5, 5]], [[3]])
+
+    def test_Det_2(self) -> None:
+        self._test_op_upgrade("Det", 11, [[5, 5]], [[]])
+
+    def test_DynamicQuantizeLinear(self) -> None:
+        self._test_op_upgrade(
+            "DynamicQuantizeLinear",
+            11,
+            [[3, 4, 5]],
+            [[3, 4, 5], [], []],
+            output_types=[TensorProto.UINT8, TensorProto.FLOAT, TensorProto.UINT8],
+        )
+
+    def test_Div(self) -> None:
+        self._test_op_upgrade(
+            "Div", 1, [[3, 4, 5], [3, 1, 5]], attrs={"consumed_inputs": [0]}
+        )
+
+    def test_Dropout(self) -> None:
+        self._test_op_upgrade(
+            "Dropout", 1, attrs={"consumed_inputs": [0], "is_test": 1}
+        )
+
+    def test_Einsum_1(self) -> None:
+        self._test_op_upgrade(
+            "Einsum",
+            12,
+            [[3, 4, 5], [3, 5, 6]],
+            [[3, 4, 6]],
+            attrs={"equation": "bij, bjk -> bik"},
+        )
+
+    def test_Einsum_2(self) -> None:
+        self._test_op_upgrade(
+            "Einsum", 12, [[4, 5]], [[5, 4]], attrs={"equation": "ij->ji"}
+        )
+
+    def test_Elu(self) -> None:
+        self._test_op_upgrade("Elu", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Equal(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "Equal", 7, [[2, 3], [2, 3]], [[2, 3]], output_types=[TensorProto.BOOL]
+        )
+
+    def test_Erf(self) -> None:
+        self._test_op_upgrade("Erf", 9)
+
+    def test_Exp(self) -> None:
+        self._test_op_upgrade("Exp", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Expand(self) -> None:
+        shape = helper.make_tensor(
+            "b", TensorProto.INT64, dims=[4], vals=np.array([5, 2, 6, 4])
+        )
+        self._test_op_upgrade(
+            "Expand",
+            8,
+            [[2, 1, 4], [4]],
+            [[5, 2, 6, 4]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+            initializer=[shape],
+        )
+
+    def test_EyeLike(self) -> None:
+        self._test_op_upgrade("EyeLike", 9, [[4, 5]], [[4, 5]])
+
+    def test_Flatten(self) -> None:
+        self._test_op_upgrade("Flatten", 1, [[3, 4, 5]], [[3, 20]], attrs={"axis": 1})
+
+    def test_Floor(self) -> None:
+        self._test_op_upgrade("Floor", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Gather(self) -> None:
+        self._test_op_upgrade(
+            "Gather",
+            1,
+            [[3, 4, 5], [6, 7]],
+            [[6, 7, 4, 5]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+        )
+
+    def test_GatherElements(self) -> None:
+        self._test_op_upgrade(
+            "GatherElements",
+            11,
+            [[3, 4, 5], [6, 7]],
+            [[6, 7]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+        )
+
+    def test_GatherND(self) -> None:
+        self._test_op_upgrade("GatherND", 11, [[1, 2, 3], [1, 2, 3]], [[1, 2]])
+
+    def test_Gelu_approximate_tanh(self) -> None:
+        self._test_op_upgrade("Gelu", 20, attrs={"approximate": "tanh"})
+
+    def test_Gelu(self) -> None:
+        self._test_op_upgrade("Gelu", 20)
+
+    def test_Gemm(self) -> None:
+        self._test_op_upgrade("Gemm", 1, [[5, 4], [4, 3], [3]], [[5, 3]])
+
+    def test_GlobalAveragePool(self) -> None:
+        self._test_op_upgrade("GlobalAveragePool", 1, [[1, 3, 10, 10]], [[1, 3, 1, 1]])
+
+    def test_GlobalMaxPool(self) -> None:
+        self._test_op_upgrade("GlobalMaxPool", 1, [[1, 3, 10, 10]], [[1, 3, 1, 1]])
+
+    def test_GlobalLpPool(self) -> None:
+        # 1->2 adapter is missing
+        self._test_op_upgrade("GlobalLpPool", 2, [[1, 3, 10, 10]], [[1, 3, 1, 1]])
+
+    def test_Greater(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "Greater", 7, [[2, 3], [2, 3]], [[2, 3]], output_types=[TensorProto.BOOL]
+        )
+
+    def test_GreaterOrEqual(self) -> None:
+        self._test_op_upgrade(
+            "GreaterOrEqual",
+            12,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+            output_types=[TensorProto.BOOL],
+        )
+
+    def test_GridSample(self) -> None:
+        self._test_op_upgrade(
+            "GridSample",
+            16,
+            [[1, 1, 3, 3], [1, 3, 3, 2]],
+            [[1, 1, 3, 3]],
+            input_types=[TensorProto.FLOAT, TensorProto.FLOAT],
+            output_types=[TensorProto.FLOAT],
+            attrs={"mode": "nearest", "padding_mode": "border", "align_corners": 1},
+        )
+
+    def test_GRU_1(self) -> None:
+        # 2->3, 6->7 adapters are missing
+        self._test_op_upgrade(
+            "GRU",
+            7,
+            [[5, 3, 4], [1, 18, 4], [1, 18, 4]],
+            [[5, 1, 3, 6], [1, 3, 6]],
+            attrs={"hidden_size": 6},
+        )
+
+    def test_GRU_2(self) -> None:
+        # 2->3, 6->7 adapters are missing
+        self._test_op_upgrade(
+            "GRU",
+            7,
+            [[5, 3, 4], [2, 18, 4], [2, 18, 4]],
+            [[5, 2, 3, 6], [2, 3, 6]],
+            attrs={"hidden_size": 6, "direction": "bidirectional"},
+        )
+
+    def test_GRU_3(self) -> None:
+        # 2->3, 6->7 adapters are missing
+        self._test_op_upgrade(
+            "GRU",
+            7,
+            [[5, 3, 4], [1, 18, 4], [1, 18, 4], [1, 24], [5], [1, 5, 6]],
+            [[5, 1, 3, 6], [1, 3, 6]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+                TensorProto.FLOAT,
+            ],
+            attrs={"hidden_size": 6},
+        )
+
+    def test_HardSigmoid(self) -> None:
+        self._test_op_upgrade("HardSigmoid", 1, attrs={"consumed_inputs": [0]})
+
+    def test_HardSwish(self) -> None:
+        self._test_op_upgrade("HardSwish", 14)
+
+    def test_Hardmax(self) -> None:
+        self._test_op_upgrade("Hardmax", 1)
+
+    def test_Identity(self) -> None:
+        self._test_op_upgrade("Identity", 1)
+
+    def test_If(self) -> None:
+        sub_output = [
+            helper.make_tensor_value_info("out", TensorProto.FLOAT, [3, 4, 5])
+        ]
+        then_tensor = helper.make_tensor(
+            "Value",
+            TensorProto.FLOAT,
+            dims=[3, 4, 5],
+            vals=np.random.rand(3, 4, 5).astype(np.float32),
+            raw=True,
+        )
+        then_node = helper.make_node("Constant", [], ["out"], value=then_tensor)
+        then_graph = helper.make_graph([then_node], "then_graph", [], sub_output, [])
+        else_tensor = helper.make_tensor(
+            "Value",
+            TensorProto.FLOAT,
+            dims=[3, 4, 5],
+            vals=np.random.rand(3, 4, 5).astype(np.float32),
+            raw=True,
+        )
+        else_node = helper.make_node("Constant", [], ["out"], value=else_tensor)
+        else_graph = helper.make_graph([else_node], "else_graph", [], sub_output, [])
+        self._test_op_upgrade(
+            "If",
+            1,
+            [[0]],
+            [[3, 4, 5]],
+            [TensorProto.BOOL],
+            attrs={"then_branch": then_graph, "else_branch": else_graph},
+        )
+
+    def test_ImageDecoder(self) -> None:
+        self._test_op_upgrade(
+            "ImageDecoder",
+            20,
+            [[None]],
+            [[None, None, 3]],
+            input_types=[TensorProto.UINT8],
+            output_types=[TensorProto.UINT8],
+        )
+
+    def test_InstanceNormalization(self) -> None:
+        self._test_op_upgrade(
+            "InstanceNormalization",
+            1,
+            [[1, 3], [3], [3]],
+            [[1, 3]],
+            attrs={"consumed_inputs": [0]},
+        )
+
+    def test_IsInf(self) -> None:
+        self._test_op_upgrade(
+            "IsInf", 10, [[2, 3]], [[2, 3]], output_types=[TensorProto.BOOL]
+        )
+
+    def test_IsNaN(self) -> None:
+        self._test_op_upgrade(
+            "IsNaN", 9, [[2, 3]], [[2, 3]], output_types=[TensorProto.BOOL]
+        )
+
+    def test_LeakyRelu(self) -> None:
+        self._test_op_upgrade("LeakyRelu", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Less(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "Less", 7, [[2, 3], [2, 3]], [[2, 3]], output_types=[TensorProto.BOOL]
+        )
+
+    def test_LessOrEqual(self) -> None:
+        self._test_op_upgrade(
+            "LessOrEqual",
+            12,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+            output_types=[TensorProto.BOOL],
+        )
+
+    def test_Log(self) -> None:
+        self._test_op_upgrade("Log", 1, attrs={"consumed_inputs": [0]})
+
+    def test_LogSoftmax(self) -> None:
+        self._test_op_upgrade("LogSoftmax", 1)
+
+    def test_Loop_1(self) -> None:
+        iter_count = onnx.helper.make_tensor_value_info(
+            "iter_count", onnx.TensorProto.INT64, []
+        )
+        cond_in = onnx.helper.make_tensor_value_info(
+            "cond_in", onnx.TensorProto.BOOL, []
+        )
+        x_in = onnx.helper.make_tensor_value_info("x_in", onnx.TensorProto.FLOAT, [1])
+        cond_out = onnx.helper.make_tensor_value_info(
+            "cond_out", onnx.TensorProto.BOOL, []
+        )
+        x_out = onnx.helper.make_tensor_value_info("x_out", onnx.TensorProto.FLOAT, [1])
+        x_scan = onnx.helper.make_tensor_value_info(
+            "x_scan", onnx.TensorProto.FLOAT, [1]
+        )
+        const = onnx.helper.make_node(
+            "Constant",
+            inputs=[],
+            outputs=["one"],
+            value=onnx.helper.make_tensor(
+                name="value",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=[1],
+                vals=np.array([1]).astype(np.float32).astype(float),
+            ),
+        )
+        add = onnx.helper.make_node("Add", inputs=["x_in", "one"], outputs=["x_out"])
+        id_1 = onnx.helper.make_node("Identity", inputs=["x_out"], outputs=["x_scan"])
+        id_2 = onnx.helper.make_node(
+            "Identity", inputs=["cond_in"], outputs=["cond_out"]
+        )
+        loop_body = onnx.helper.make_graph(
+            [const, add, id_1, id_2],
+            "loop_body",
+            [iter_count, cond_in, x_in],
+            [cond_out, x_out, x_scan],
+        )
+        self._test_op_upgrade(
+            "Loop",
+            1,
+            [[], "", [1]],
+            [[1], [5, 1]],
+            [TensorProto.INT64, TensorProto.BOOL, TensorProto.FLOAT],
+            attrs={"body": loop_body},
+        )
+
+    def test_Loop_2(self) -> None:
+        iter_count = onnx.helper.make_tensor_value_info(
+            "iter_count", onnx.TensorProto.INT64, []
+        )
+        cond_in = onnx.helper.make_tensor_value_info(
+            "cond_in", onnx.TensorProto.BOOL, []
+        )
+        x_in = onnx.helper.make_tensor_value_info(
+            "x_in", onnx.TensorProto.FLOAT, [2, 1]
+        )
+        cond_out = onnx.helper.make_tensor_value_info(
+            "cond_out", onnx.TensorProto.BOOL, []
+        )
+        x_out = onnx.helper.make_tensor_value_info(
+            "x_out", onnx.TensorProto.FLOAT, [2, 1]
+        )
+        squeeze = onnx.helper.make_node(
+            "Squeeze", inputs=["x_in"], outputs=["squeeze_out"], axes=[1]
+        )
+        unsqueeze = onnx.helper.make_node(
+            "Unsqueeze", inputs=["squeeze_out"], outputs=["x_out"], axes=[1]
+        )
+        identity = onnx.helper.make_node(
+            "Identity", inputs=["cond_in"], outputs=["cond_out"]
+        )
+        loop_body = onnx.helper.make_graph(
+            [squeeze, unsqueeze, identity],
+            "loop_body",
+            [iter_count, cond_in, x_in],
+            [cond_out, x_out],
+        )
+        self._test_op_upgrade(
+            "Loop",
+            12,
+            [[], "", [2, 1]],
+            [[2, 1]],
+            [TensorProto.INT64, TensorProto.BOOL, TensorProto.FLOAT],
+            attrs={"body": loop_body},
+        )
+
+    def test_LpNormalization(self) -> None:
+        self._test_op_upgrade("LpNormalization", 1)
+
+    def test_LpPool(self) -> None:
+        # 1->2 adapter is missing
+        self._test_op_upgrade(
+            "LpPool", 2, [[1, 1, 5, 5]], [[1, 1, 4, 4]], attrs={"kernel_shape": [2, 2]}
+        )
+
+    def test_LRN_1(self) -> None:
+        self._test_op_upgrade("LRN", 1, attrs={"size": 3})
+
+    def test_LRN_2(self) -> None:
+        self._test_op_upgrade(
+            "LRN", 1, [[2, 3, 4, 5]], [[2, 3, 4, 5]], attrs={"size": 3}
+        )
+
+    def test_LSTM_1(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "LSTM",
+            7,
+            [[5, 3, 4], [1, 24, 4], [1, 24, 4]],
+            [[5, 1, 3, 6], [1, 3, 6], [1, 3, 6]],
+            attrs={"hidden_size": 6},
+        )
+
+    def test_LSTM_2(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "LSTM",
+            7,
+            [[5, 3, 4], [2, 24, 4], [2, 24, 4]],
+            [[5, 2, 3, 6], [2, 3, 6], [2, 3, 6]],
+            attrs={"hidden_size": 6, "direction": "bidirectional"},
+        )
+
+    def test_LSTM_3(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "LSTM",
+            7,
+            [
+                [5, 3, 4],
+                [1, 24, 4],
+                [1, 24, 4],
+                [1, 48],
+                [5],
+                [1, 5, 6],
+                [1, 5, 6],
+                [1, 18],
+            ],
+            [[5, 1, 3, 6], [1, 3, 6], [1, 3, 6]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+            ],
+            attrs={"hidden_size": 6},
+        )
+
+    def test_MatMul_1(self) -> None:
+        self._test_op_upgrade("MatMul", 1, [[2, 3], [3, 4]], [[2, 4]])
+
+    def test_MatMul_2(self) -> None:
+        self._test_op_upgrade("MatMul", 1, [[5, 2, 3], [5, 3, 4]], [[5, 2, 4]])
+
+    def test_MatMulInteger_1(self) -> None:
+        self._test_op_upgrade(
+            "MatMulInteger",
+            10,
+            [[2, 3], [3, 4]],
+            [[2, 4]],
+            [TensorProto.INT8, TensorProto.INT8],
+            [TensorProto.INT32],
+        )
+
+    def test_MatMulInteger_2(self) -> None:
+        self._test_op_upgrade(
+            "MatMulInteger",
+            10,
+            [[2, 3], [3, 4], [], []],
+            [[2, 4]],
+            [TensorProto.INT8, TensorProto.INT8, TensorProto.INT8, TensorProto.INT8],
+            [TensorProto.INT32],
+        )
+
+    def test_MatMulInteger_3(self) -> None:
+        self._test_op_upgrade(
+            "MatMulInteger",
+            10,
+            [[2, 3], [3, 4], [2], [4]],
+            [[2, 4]],
+            [TensorProto.INT8, TensorProto.INT8, TensorProto.INT8, TensorProto.INT8],
+            [TensorProto.INT32],
+        )
+
+    def test_Max(self) -> None:
+        self._test_op_upgrade(
+            "Max",
+            1,
+            [[2, 3, 4], [2, 3, 4]],
+            [[2, 3, 4]],
+            attrs={"consumed_inputs": [0]},
+        )
+
+    def test_MaxPool_1(self) -> None:
+        self._test_op_upgrade(
+            "MaxPool", 1, [[1, 1, 5, 5]], [[1, 1, 4, 4]], attrs={"kernel_shape": [2, 2]}
+        )
+
+    def test_MaxPool_2(self) -> None:
+        self._test_op_upgrade(
+            "MaxPool",
+            8,
+            [[1, 1, 5, 5]],
+            [[1, 1, 4, 4], [1, 1, 4, 4]],
+            output_types=[TensorProto.FLOAT, TensorProto.INT64],
+            attrs={"kernel_shape": [2, 2]},
+        )
+
+    def test_MaxRoiPool(self) -> None:
+        self._test_op_upgrade(
+            "MaxRoiPool",
+            1,
+            [[2, 3, 20, 20], [4, 5]],
+            [[4, 3, 3, 3]],
+            attrs={"pooled_shape": [3, 3]},
+        )
+
+    def test_MaxUnpool(self) -> None:
+        self._test_op_upgrade(
+            "MaxUnpool",
+            9,
+            [[1, 1, 5, 5], [1, 1, 5, 5]],
+            [[1, 1, 6, 6]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+            attrs={"kernel_shape": [2, 2]},
+        )
+
+    def test_Mean(self) -> None:
+        self._test_op_upgrade(
+            "Mean",
+            1,
+            [[2, 3, 4], [2, 3, 4]],
+            [[2, 3, 4]],
+            attrs={"consumed_inputs": [0]},
+        )
+
+    def test_MeanVarianceNormalization(self) -> None:
+        self._test_op_upgrade("MeanVarianceNormalization", 9, attrs={"axes": [1, 2]})
+
+    def test_Min(self) -> None:
+        self._test_op_upgrade(
+            "Min",
+            1,
+            [[2, 3, 4], [2, 3, 4]],
+            [[2, 3, 4]],
+            attrs={"consumed_inputs": [0]},
+        )
+
+    def test_Mish(self) -> None:
+        self._test_op_upgrade("Mish", 18)
+
+    def test_Mod_1(self) -> None:
+        self._test_op_upgrade("Mod", 10, [[2, 3], [2, 3]], [[2, 3]])
+
+    def test_Mod_2(self) -> None:
+        self._test_op_upgrade("Mod", 10, [[2, 3], [2, 3]], [[2, 3]], attrs={"fmod": 1})
+
+    def test_Mul(self) -> None:
+        self._test_op_upgrade(
+            "Mul",
+            1,
+            [[2, 3, 4], [2, 1, 4]],
+            [[2, 3, 4]],
+            attrs={"consumed_inputs": [0]},
+        )
+
+    def test_Multinomial(self) -> None:
+        self._test_op_upgrade(
+            "Multinomial",
+            7,
+            [[3, 5]],
+            [[3, 7]],
+            output_types=[TensorProto.INT32],
+            attrs={"sample_size": 7},
+        )
+
+    def test_Neg(self) -> None:
+        self._test_op_upgrade("Neg", 1, attrs={"consumed_inputs": [0]})
+
+    def test_NegativeLogLikelihoodLoss_1(self) -> None:
+        self._test_op_upgrade(
+            "NegativeLogLikelihoodLoss",
+            12,
+            [[3, 4, 5], [3, 5]],
+            [[]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+        )
+
+    def test_NegativeLogLikelihoodLoss_2(self) -> None:
+        self._test_op_upgrade(
+            "NegativeLogLikelihoodLoss",
+            12,
+            [[3, 4, 5], [3, 5], [4]],
+            [[]],
+            [TensorProto.FLOAT, TensorProto.INT64, TensorProto.FLOAT],
+        )
+
+    def test_NonMaxSuppression(self) -> None:
+        self._test_op_upgrade(
+            "NonMaxSuppression",
+            10,
+            [[2, 3, 4], [3, 5, 6]],
+            [[2, 3]],
+            output_types=[TensorProto.INT64],
+        )
+
+    def test_NonZero(self) -> None:
+        self._test_op_upgrade(
+            "NonZero", 9, [[3, 3]], [[2, 4]], output_types=[TensorProto.INT64]
+        )
+
+    def test_Not(self) -> None:
+        self._test_op_upgrade(
+            "Not", 1, [[2, 3]], [[2, 3]], [TensorProto.BOOL], [TensorProto.BOOL]
+        )
+
+    def test_OneHot(self) -> None:
+        self._test_op_upgrade("OneHot", 9, [[3, 4, 5], [], [2]], [[3, 4, 5, 6]])
+
+    def test_Or(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "Or",
+            7,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+            [TensorProto.BOOL, TensorProto.BOOL],
+            [TensorProto.BOOL],
+        )
+
+    def test_Pad(self) -> None:
+        # 1->2 adapter is missing
+        self._test_op_upgrade(
+            "Pad", 2, [[3, 4]], [[5, 8]], attrs={"pads": [1, 2, 1, 2], "value": 1.5}
+        )
+
+    def test_Pow(self) -> None:
+        self._test_op_upgrade("Pow", 1, [[2, 3, 4], [2, 3, 4]], [[2, 3, 4]])
+
+    def test_PRelu(self) -> None:
+        self._test_op_upgrade(
+            "PRelu",
+            1,
+            [[2, 3, 4], [2, 3, 4]],
+            [[2, 3, 4]],
+            attrs={"consumed_inputs": [0]},
+        )
+
+    def test_QLinearConv(self) -> None:
+        self._test_op_upgrade(
+            "QLinearConv",
+            10,
+            [[1, 3, 5, 5], [], [], [4, 3, 2, 2], [], [], [], []],
+            [[1, 4, 4, 4]],
+        )
+
+    def test_QLinearMatMul(self) -> None:
+        self._test_op_upgrade(
+            "QLinearMatMul", 10, [[2, 3], [], [], [3, 4], [], [], [], []], [[2, 4]]
+        )
+
+    def test_QuantizeLinear(self) -> None:
+        self._test_op_upgrade(
+            "QuantizeLinear",
+            10,
+            [[3, 4, 5], [], []],
+            [[3, 4, 5]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.UINT8],
+            [TensorProto.UINT8],
+        )
+
+    def test_RandomNormal(self) -> None:
+        self._test_op_upgrade(
+            "RandomNormal", 1, [], [[3, 4, 5]], attrs={"shape": [3, 4, 5]}
+        )
+
+    def test_RandomNormalLike(self) -> None:
+        like = helper.make_tensor(
+            "a",
+            TensorProto.FLOAT,
+            dims=[3, 4, 5],
+            vals=np.random.rand(3, 4, 5).astype(np.float32),
+            raw=True,
+        )
+        self._test_op_upgrade(
+            "RandomNormalLike", 1, [[3, 4, 5]], [[3, 4, 5]], initializer=[like]
+        )
+
+    def test_RandomUniform(self) -> None:
+        self._test_op_upgrade(
+            "RandomUniform", 1, [], [[3, 4, 5]], attrs={"shape": [3, 4, 5]}
+        )
+
+    def test_RandomUniformLike(self) -> None:
+        like = helper.make_tensor(
+            "a",
+            TensorProto.FLOAT,
+            dims=[3, 4, 5],
+            vals=np.random.rand(3, 4, 5).astype(np.float32),
+            raw=True,
+        )
+        self._test_op_upgrade(
+            "RandomUniformLike", 1, [[3, 4, 5]], [[3, 4, 5]], initializer=[like]
+        )
+
+    def test_Range(self) -> None:
+        start = helper.make_tensor("a", TensorProto.FLOAT, dims=[], vals=np.array([0]))
+        end = helper.make_tensor("b", TensorProto.FLOAT, dims=[], vals=np.array([12]))
+        step = helper.make_tensor("c", TensorProto.FLOAT, dims=[], vals=np.array([2]))
+        self._test_op_upgrade(
+            "Range", 11, [[], [], []], [[6]], initializer=[start, end, step]
+        )
+
+    def test_Reciprocal(self) -> None:
+        self._test_op_upgrade("Reciprocal", 1, attrs={"consumed_inputs": [0]})
+
+    def test_ReduceL1(self) -> None:
+        self._test_op_upgrade("ReduceL1", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_ReduceL2(self) -> None:
+        self._test_op_upgrade("ReduceL2", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_ReduceLogSum(self) -> None:
+        self._test_op_upgrade("ReduceLogSum", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_ReduceLogSumExp(self) -> None:
+        self._test_op_upgrade("ReduceLogSumExp", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_ReduceMean(self) -> None:
+        self._test_op_upgrade("ReduceMean", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_ReduceMax(self) -> None:
+        self._test_op_upgrade("ReduceMax", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_ReduceMin(self) -> None:
+        self._test_op_upgrade("ReduceMin", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_ReduceProd(self) -> None:
+        self._test_op_upgrade("ReduceProd", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_ReduceSum(self) -> None:
+        self._test_op_upgrade("ReduceSum", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_ReduceSumSquare(self) -> None:
+        self._test_op_upgrade("ReduceSumSquare", 1, [[3, 4, 5]], [[1, 1, 1]])
+
+    def test_Relu(self) -> None:
+        self._test_op_upgrade("Relu", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Reshape(self) -> None:
+        self._test_op_upgrade(
+            "Reshape",
+            1,
+            [[3, 4, 5]],
+            [[3, 10, 2]],
+            attrs={"consumed_inputs": [0], "shape": [3, 10, 2]},
+        )
+
+    def test_Resize(self) -> None:
+        self._test_op_upgrade("Resize", 10, [[3, 4, 5], [3]], [[3, 8, 15]])
+
+    def test_ReverseSequence(self) -> None:
+        self._test_op_upgrade(
+            "ReverseSequence",
+            10,
+            [[3, 4, 5], [4]],
+            [[3, 4, 5]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+        )
+
+    def test_RNN_1(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "RNN",
+            7,
+            [[5, 3, 4], [1, 6, 4], [1, 6, 4]],
+            [[5, 1, 3, 6], [1, 3, 6]],
+            attrs={"hidden_size": 6},
+        )
+
+    def test_RNN_2(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "RNN",
+            7,
+            [[5, 3, 4], [2, 6, 4], [2, 6, 4]],
+            [[5, 2, 3, 6], [2, 3, 6]],
+            attrs={"hidden_size": 6, "direction": "bidirectional"},
+        )
+
+    def test_RNN_3(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "RNN",
+            7,
+            [[5, 3, 4], [1, 6, 4], [1, 6, 4], [1, 12], [5], [1, 5, 6]],
+            [[5, 1, 3, 6], [1, 3, 6]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+                TensorProto.FLOAT,
+            ],
+            attrs={"hidden_size": 6},
+        )
+
+    def test_RoiAlign_1(self) -> None:
+        self._test_op_upgrade(
+            "RoiAlign",
+            10,
+            [[2, 3, 20, 20], [10, 4], [10]],
+            [[10, 3, 1, 1]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.INT64],
+        )
+
+    def test_RoiAlign_2(self) -> None:
+        self._test_op_upgrade(
+            "RoiAlign",
+            16,
+            [[2, 3, 20, 20], [10, 4], [10]],
+            [[10, 3, 1, 1]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.INT64],
+            attrs={"coordinate_transformation_mode": "half_pixel"},
+        )
+
+    def test_RotaryEmbedding_1(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 4, 3, 8], [2, 3, 4], [2, 3, 4]],
+            [[2, 4, 3, 8]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_RotaryEmbedding_2(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 4, 3, 8], [50, 4], [50, 4], [2, 3]],
+            [[2, 4, 3, 8]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            [TensorProto.FLOAT],
+        )
+
+    def test_RotaryEmbedding_3(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 3, 32], [50, 4], [50, 4], [2, 3]],
+            [[2, 3, 32]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            [TensorProto.FLOAT],
+            attrs={"num_heads": 4},
+        )
+
+    def test_RotaryEmbedding_4(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 4, 3, 8], [50, 4], [50, 4], [2, 3]],
+            [[2, 4, 3, 8]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            [TensorProto.FLOAT],
+            attrs={"interleaved": 1},
+        )
+
+    def test_RotaryEmbedding_5(self) -> None:
+        self._test_op_upgrade(
+            "RotaryEmbedding",
+            23,
+            [[2, 4, 3, 8], [50, 4], [50, 4], [2, 3]],
+            [[2, 4, 3, 8]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            [TensorProto.FLOAT],
+            attrs={"rotary_embedding_dim": 4},
+        )
+
+    def test_Round(self) -> None:
+        self._test_op_upgrade("Round", 11)
+
+    def test_RMSNormalization(self) -> None:
+        self._test_op_upgrade(
+            "RMSNormalization",
+            23,
+            [[2, 3, 4, 5], [4, 5]],
+            [[2, 3, 4, 5]],
+            input_types=[TensorProto.FLOAT, TensorProto.FLOAT],
+            output_types=[TensorProto.FLOAT],
+            attrs={"axis": 2},
+        )
+
+    def test_Scatter(self) -> None:
+        self._test_op_upgrade(
+            "Scatter",
+            9,
+            [[2, 3], [1, 2], [1, 2]],
+            [[2, 3]],
+            [TensorProto.FLOAT, TensorProto.INT64, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_ScatterElements_1(self) -> None:
+        self._test_op_upgrade(
+            "ScatterElements",
+            11,
+            [[2, 3], [1, 2], [1, 2]],
+            [[2, 3]],
+            [TensorProto.FLOAT, TensorProto.INT64, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_ScatterElements_2(self) -> None:
+        self._test_op_upgrade(
+            "ScatterElements",
+            16,
+            [[2, 3], [1, 2], [1, 2]],
+            [[2, 3]],
+            [TensorProto.FLOAT, TensorProto.INT64, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+            attrs={"reduction": "add"},
+        )
+
+    def test_ScatterND_1(self) -> None:
+        self._test_op_upgrade(
+            "ScatterND",
+            11,
+            [[2, 3], [1, 2], [1, 2]],
+            [[2, 3]],
+            [TensorProto.FLOAT, TensorProto.INT64, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+        )
+
+    def test_ScatterND_2(self) -> None:
+        self._test_op_upgrade(
+            "ScatterND",
+            16,
+            [[2, 3], [1, 2], [1, 2]],
+            [[2, 3]],
+            [TensorProto.FLOAT, TensorProto.INT64, TensorProto.FLOAT],
+            [TensorProto.FLOAT],
+            attrs={"reduction": "mul"},
+        )
+
+    def test_Scan(self) -> None:
+        sum_in = onnx.helper.make_tensor_value_info(
+            "sum_in", onnx.TensorProto.FLOAT, [2]
+        )
+        next_in = onnx.helper.make_tensor_value_info(
+            "next_in", onnx.TensorProto.FLOAT, [2]
+        )
+        sum_out = onnx.helper.make_tensor_value_info(
+            "sum_out", onnx.TensorProto.FLOAT, [2]
+        )
+        scan_out = onnx.helper.make_tensor_value_info(
+            "scan_out", onnx.TensorProto.FLOAT, [2]
+        )
+        add_node = onnx.helper.make_node(
+            "Add", inputs=["sum_in", "next_in"], outputs=["sum_out"]
+        )
+        id_node = onnx.helper.make_node(
+            "Identity", inputs=["sum_out"], outputs=["scan_out"]
+        )
+        body = onnx.helper.make_graph(
+            [add_node, id_node], "scan_body", [sum_in, next_in], [sum_out, scan_out]
+        )
+        self._test_op_upgrade(
+            "Scan",
+            8,
+            ["", [1, 2], [1, 3, 2]],
+            [[1, 2], [1, 3, 2]],
+            attrs={"body": body, "num_scan_inputs": 1},
+        )
+
+    def test_Selu(self) -> None:
+        self._test_op_upgrade("Selu", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Shape(self) -> None:
+        self._test_op_upgrade(
+            "Shape", 1, [[3, 4, 5]], [[3]], output_types=[TensorProto.INT64]
+        )
+
+    def test_Shrink(self) -> None:
+        self._test_op_upgrade("Shrink", 9)
+
+    def test_Sigmoid(self) -> None:
+        self._test_op_upgrade("Sigmoid", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Sign(self) -> None:
+        self._test_op_upgrade("Sign", 9)
+
+    def test_Sinh(self) -> None:
+        self._test_op_upgrade("Sinh", 9)
+
+    def test_Sin(self) -> None:
+        self._test_op_upgrade("Sin", 7)
+
+    def test_Size(self) -> None:
+        self._test_op_upgrade(
+            "Size", 1, [[3, 4, 5]], [[]], output_types=[TensorProto.INT64]
+        )
+
+    def test_Slice(self) -> None:
+        self._test_op_upgrade(
+            "Slice",
+            1,
+            [[3, 4, 5]],
+            [[3, 2, 2]],
+            attrs={"axes": [1, 2], "starts": [0, 1], "ends": [2, 3]},
+        )
+
+    def test_Softmax_0(self) -> None:
+        self._test_op_upgrade("Softmax", 1, attrs={"axis": 0})
+
+    def test_Softmax_1(self) -> None:
+        self._test_op_upgrade("Softmax", 1, attrs={"axis": 1})
+
+    def test_Softmax_2(self) -> None:
+        self._test_op_upgrade("Softmax", 1, attrs={"axis": 2})
+
+    def test_Softmax_3(self) -> None:
+        self._test_op_upgrade("Softmax", 1, attrs={"axis": -1})
+
+    def test_Softmax_4(self) -> None:
+        self._test_op_upgrade("Softmax", 1, attrs={"axis": -2})
+
+    def test_Softmax_5(self) -> None:
+        self._test_op_upgrade("Softmax", 1, attrs={"axis": -3})
+
+    def test_Softplus(self) -> None:
+        self._test_op_upgrade("Softplus", 1)
+
+    def test_Softsign(self) -> None:
+        self._test_op_upgrade("Softsign", 1)
+
+    def test_SoftmaxCrossEntropyLoss(self) -> None:
+        self._test_op_upgrade(
+            "SoftmaxCrossEntropyLoss",
+            12,
+            [[3, 4, 5, 6], [3, 6]],
+            [[]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+        )
+
+    def test_SpaceToDepth(self) -> None:
+        self._test_op_upgrade(
+            "SpaceToDepth", 1, [[1, 3, 8, 8]], [[1, 12, 4, 4]], attrs={"blocksize": 2}
+        )
+
+    def test_Split(self) -> None:
+        # 1->2 adapter is missing
+        self._test_op_upgrade(
+            "Split",
+            2,
+            [[3, 4, 7]],
+            [[3, 4, 2], [3, 4, 1], [3, 4, 4]],
+            attrs={"axis": 2, "split": [2, 1, 4]},
+        )
+
+    def test_Sqrt(self) -> None:
+        self._test_op_upgrade("Sqrt", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Squeeze(self) -> None:
+        self._test_op_upgrade("Squeeze", 1, [[2, 1, 3, 4, 1]], [[2, 3, 4]])
+
+    def test_StringNormalizer(self) -> None:
+        self._test_op_upgrade(
+            "StringNormalizer",
+            10,
+            [[1, 3]],
+            [[1, 3]],
+            [TensorProto.STRING],
+            [TensorProto.STRING],
+            attrs={"case_change_action": "LOWER"},
+        )
+
+    def test_Sub(self) -> None:
+        self._test_op_upgrade(
+            "Sub",
+            1,
+            [[2, 3, 4], [2, 3, 4]],
+            [[2, 3, 4]],
+            attrs={"consumed_inputs": [0]},
+        )
+
+    def test_Sum(self) -> None:
+        self._test_op_upgrade(
+            "Sum",
+            1,
+            [[2, 3, 4], [2, 3, 4]],
+            [[2, 3, 4]],
+            attrs={"consumed_inputs": [0]},
+        )
+
+    def test_Swish(self) -> None:
+        self._test_op_upgrade("Swish", 24, attrs={"alpha": 0.2})
+
+    def test_Tanh(self) -> None:
+        self._test_op_upgrade("Tanh", 1, attrs={"consumed_inputs": [0]})
+
+    def test_Tan(self) -> None:
+        self._test_op_upgrade("Tan", 7)
+
+    def test_TfIdfVectorizer(self) -> None:
+        self._test_op_upgrade(
+            "TfIdfVectorizer",
+            9,
+            [[3]],
+            [[5]],
+            attrs={
+                "max_gram_length": 3,
+                "max_skip_count": 1,
+                "min_gram_length": 2,
+                "mode": "TFIDF",
+                "ngram_counts": [0, 20],
+                "ngram_indexes": [3, 4],
+            },
+        )
+
+    def test_ThresholdedRelu(self) -> None:
+        self._test_op_upgrade("ThresholdedRelu", 10)
+
+    def test_Tile(self) -> None:
+        # 5->6 adapter is missing
+        repeats = helper.make_tensor(
+            "b", TensorProto.INT64, dims=[3], vals=np.array([1, 2, 3])
+        )
+        self._test_op_upgrade(
+            "Tile",
+            6,
+            [[3, 4, 5], [3]],
+            [[3, 8, 15]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+            initializer=[repeats],
+        )
+
+    def test_TopK(self) -> None:
+        self._test_op_upgrade(
+            "TopK",
+            1,
+            [[3, 4, 5]],
+            [[3, 4, 2], [3, 4, 2]],
+            output_types=[TensorProto.FLOAT, TensorProto.INT64],
+            attrs={"k": 2},
+        )
+
+    def test_Transpose(self) -> None:
+        self._test_op_upgrade(
+            "Transpose",
+            1,
+            [[1, 2, 5, 3, 7]],
+            [[1, 7, 5, 2, 3]],
+            attrs={"perm": [0, 4, 2, 1, 3]},
+        )
+
+    def test_Trilu(self) -> None:
+        self._test_op_upgrade("Trilu", 14)
+
+    def test_Unique_1(self) -> None:
+        self._test_op_upgrade("Unique", 11, [[3, 4, 5]], [[None]])
+
+    def test_Unique_2(self) -> None:
+        self._test_op_upgrade(
+            "Unique", 11, [[3, 4, 5]], [[3, None, 5]], attrs={"axis": 1}
+        )
+
+    def test_Unsqueeze(self) -> None:
+        self._test_op_upgrade(
+            "Unsqueeze", 1, [[3, 4, 5]], [[3, 4, 1, 5]], attrs={"axes": [2]}
+        )
+
+    def test_Upsample(self) -> None:
+        self._test_op_upgrade(
+            "Upsample",
+            1,
+            [[1, 3, 4, 5]],
+            [[1, 3, 6, 10]],
+            attrs={"width_scale": 2.0, "height_scale": 1.5},
+        )
+
+    def test_Where(self) -> None:
+        self._test_op_upgrade(
+            "Where",
+            9,
+            [[2, 3], [2, 3], [2, 3]],
+            [[2, 3]],
+            [TensorProto.BOOL, TensorProto.FLOAT, TensorProto.FLOAT],
+        )
+
+    def test_Xor(self) -> None:
+        # 6->7 adapter is missing
+        self._test_op_upgrade(
+            "Xor",
+            7,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+            [TensorProto.BOOL, TensorProto.BOOL],
+            [TensorProto.BOOL],
+        )
+
+    def test_CastLike(self) -> None:
+        self._test_op_upgrade(
+            "CastLike",
+            15,
+            [[2, 3, 4], [2, 1, 4]],
+            [[2, 3, 4]],
+            input_types=[TensorProto.FLOAT, TensorProto.FLOAT16],
+            output_types=[TensorProto.FLOAT16],
+        )
+
+    def test_LayerNormalization(self) -> None:
+        self._test_op_upgrade(
+            "LayerNormalization",
+            17,
+            [[2, 3, 4, 5], [4, 5], [4, 5]],
+            [[2, 3, 4, 5]],
+            input_types=[TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            output_types=[TensorProto.FLOAT],
+            attrs={"axis": 2},
+        )
+
+    def _test_window_function(self, window_function_name: str) -> None:
+        size = helper.make_tensor("a", TensorProto.INT64, dims=[], vals=np.array([10]))
+        self._test_op_upgrade(
+            window_function_name,
+            17,
+            [[]],
+            [[10]],
+            [TensorProto.INT64],
+            initializer=[size],
+        )
+
+    def test_BlackmanWindow(self) -> None:
+        self._test_window_function("BlackmanWindow")
+
+    def test_HannWindow(self) -> None:
+        self._test_window_function("HannWindow")
+
+    def test_HammingWindow(self) -> None:
+        self._test_window_function("HammingWindow")
+
+    def test_DFT(self) -> None:
+        self._test_op_upgrade("DFT", 17, [[2, 16, 1], []], [[2, 16, 2]])
+        self._test_op_upgrade("DFT", 17, [[2, 16, 2], []], [[2, 16, 2]])
+        self._test_op_upgrade(
+            "DFT", 17, [[2, 16, 1], []], [[2, 9, 2]], attrs={"onesided": 1}
+        )
+        self._test_op_upgrade(
+            "DFT", 17, [[2, 16, 1], []], [[2, 16, 2]], attrs={"inverse": 1}
+        )
+        self._test_op_upgrade(
+            "DFT", 17, [[2, 16, 2], []], [[2, 16, 2]], attrs={"inverse": 1}
+        )
+        self._test_op_upgrade(
+            "DFT", 17, [[2, 16, 2], []], [[2, 16, 2]], attrs={"inverse": 1, "axis": 0}
+        )
+
+    def _test_short_time_fourier_transform(self, operator_name: str) -> None:
+        # Real
+        signal = helper.make_tensor(
+            "a",
+            TensorProto.FLOAT,
+            dims=[2, 64],
+            vals=np.random.rand(2, 64).astype(np.float32),
+        )
+        frame_step = helper.make_tensor(
+            "b", TensorProto.INT64, dims=[1], vals=np.array([8])
+        )
+        window = helper.make_tensor(
+            "c", TensorProto.FLOAT, dims=[16], vals=np.ones(16).astype(np.float32)
+        )
+        self._test_op_upgrade(
+            operator_name,
+            17,
+            [[2, 64], [1], [16]],
+            [[2, 7, 16, 2]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            initializer=[signal, frame_step, window],
+        )
+
+        # Real Onesided
+        signal = helper.make_tensor(
+            "a",
+            TensorProto.FLOAT,
+            dims=[2, 64],
+            vals=np.random.rand(2, 64).astype(np.float32),
+        )
+        frame_step = helper.make_tensor(
+            "b", TensorProto.INT64, dims=[1], vals=np.array([8])
+        )
+        window = helper.make_tensor(
+            "c", TensorProto.FLOAT, dims=[16], vals=np.ones(16).astype(np.float32)
+        )
+        self._test_op_upgrade(
+            operator_name,
+            17,
+            [[2, 64], [1], [16]],
+            [[2, 7, 9, 2]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            attrs={"onesided": 1},
+            initializer=[signal, frame_step, window],
+        )
+
+        # Complex
+        signal = helper.make_tensor(
+            "a",
+            TensorProto.FLOAT,
+            dims=[2, 64, 2],
+            vals=np.random.rand(2, 64, 2).astype(np.float32),
+        )
+        frame_step = helper.make_tensor(
+            "b", TensorProto.INT64, dims=[1], vals=np.array([8])
+        )
+        window = helper.make_tensor(
+            "c", TensorProto.FLOAT, dims=[16], vals=np.ones(16).astype(np.float32)
+        )
+        self._test_op_upgrade(
+            operator_name,
+            17,
+            [[2, 64, 2], [1], [16]],
+            [[2, 7, 16, 2]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            initializer=[signal, frame_step, window],
+        )
+
+        # Complex Onesided
+        signal = helper.make_tensor(
+            "a",
+            TensorProto.FLOAT,
+            dims=[2, 64, 2],
+            vals=np.random.rand(2, 64, 2).astype(np.float32),
+        )
+        frame_step = helper.make_tensor(
+            "b", TensorProto.INT64, dims=[1], vals=np.array([8])
+        )
+        window = helper.make_tensor(
+            "c", TensorProto.FLOAT, dims=[16], vals=np.ones(16).astype(np.float32)
+        )
+        frame_length = helper.make_tensor(
+            "e", TensorProto.INT64, dims=[1], vals=np.array([16])
+        )
+        self._test_op_upgrade(
+            operator_name,
+            17,
+            [[2, 64, 2], [1], [16]],
+            [[2, 7, 9, 2]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+                TensorProto.FLOAT,
+                TensorProto.INT64,
+            ],
+            attrs={"onesided": 1},
+            initializer=[signal, frame_step, window, frame_length],
+        )
+
+    def test_STFT(self) -> None:
+        self._test_short_time_fourier_transform("STFT")
+
+    def test_MelWeightMatrix(self) -> None:
+        num_mel_bins = helper.make_tensor(
+            "a", TensorProto.INT64, dims=[], vals=np.array([10])
+        )
+        dft_length = helper.make_tensor(
+            "b", TensorProto.INT64, dims=[], vals=np.array([64])
+        )
+        sample_rate = helper.make_tensor(
+            "c", TensorProto.INT64, dims=[], vals=np.array([0])
+        )
+        lower_edge_hertz = helper.make_tensor(
+            "d", TensorProto.FLOAT, dims=[], vals=np.array([0])
+        )
+        upper_edge_hertz = helper.make_tensor(
+            "e", TensorProto.FLOAT, dims=[], vals=np.array([1])
+        )
+
+        self._test_op_upgrade(
+            "MelWeightMatrix",
+            17,
+            [[], [], [], [], []],
+            [[33, 10]],
+            [
+                TensorProto.INT64,
+                TensorProto.INT64,
+                TensorProto.INT64,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+            ],
+            initializer=[
+                num_mel_bins,
+                dft_length,
+                sample_rate,
+                lower_edge_hertz,
+                upper_edge_hertz,
+            ],
+        )
+
+        num_mel_bins = helper.make_tensor(
+            "a", TensorProto.INT64, dims=[], vals=np.array([20])
+        )
+        dft_length = helper.make_tensor(
+            "b", TensorProto.INT64, dims=[], vals=np.array([31])
+        )
+        sample_rate = helper.make_tensor(
+            "c", TensorProto.INT64, dims=[], vals=np.array([0])
+        )
+        lower_edge_hertz = helper.make_tensor(
+            "d", TensorProto.FLOAT, dims=[], vals=np.array([0])
+        )
+        upper_edge_hertz = helper.make_tensor(
+            "e", TensorProto.FLOAT, dims=[], vals=np.array([1])
+        )
+
+        self._test_op_upgrade(
+            "MelWeightMatrix",
+            17,
+            [[], [], [], [], []],
+            [[16, 20]],
+            [
+                TensorProto.INT64,
+                TensorProto.INT64,
+                TensorProto.INT64,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+            ],
+            initializer=[
+                num_mel_bins,
+                dft_length,
+                sample_rate,
+                lower_edge_hertz,
+                upper_edge_hertz,
+            ],
+        )
+
+    def test_CenterCropPad(self) -> None:
+        input_ = helper.make_tensor(
+            "input",
+            TensorProto.FLOAT,
+            dims=[2, 4],
+            vals=np.array([1, 2, 3, 4, 5, 6, 7, 8]),
+        )
+        shape = helper.make_tensor(
+            "shape", TensorProto.INT64, dims=[2], vals=np.array([3, 3])
+        )
+        self._test_op_upgrade(
+            "CenterCropPad",
+            18,
+            [[], []],
+            [[3, 3]],
+            [TensorProto.FLOAT, TensorProto.INT64],
+            initializer=[input_, shape],
+        )
+
+    def test_BitwiseNot(self) -> None:
+        self._test_op_upgrade(
+            "BitwiseNot",
+            18,
+            [[2, 3]],
+            [[2, 3]],
+            [TensorProto.INT32],
+            [TensorProto.INT32],
+        )
+
+    def test_BitwiseAnd(self) -> None:
+        self._test_op_upgrade(
+            "BitwiseAnd",
+            18,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+            [TensorProto.INT16, TensorProto.INT16],
+            [TensorProto.INT16],
+        )
+
+    def test_BitwiseOr(self) -> None:
+        self._test_op_upgrade(
+            "BitwiseOr",
+            18,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+            [TensorProto.INT16, TensorProto.INT16],
+            [TensorProto.INT16],
+        )
+
+    def test_BitwiseXor(self) -> None:
+        self._test_op_upgrade(
+            "BitwiseXor",
+            18,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+            [TensorProto.INT16, TensorProto.INT16],
+            [TensorProto.INT16],
+        )
+
+    def test_GroupNormalization(self) -> None:
+        self._test_op_upgrade(
+            "GroupNormalization",
+            21,
+            [[3, 4, 2, 2], [4], [4]],
+            [[3, 4, 2, 2]],
+            attrs={"epsilon": 1e-5, "num_groups": 2},
+        )
+
+    def test_StringConcat(self) -> None:
+        self._test_op_upgrade(
+            "StringConcat",
+            20,
+            [[2, 3], [2, 3]],
+            [[2, 3]],
+        )
+
+    def test_RegexFullMatch(self) -> None:
+        self._test_op_upgrade(
+            "RegexFullMatch",
+            20,
+            [[2, 3]],
+            [[2, 3]],
+            [TensorProto.STRING],
+            [TensorProto.BOOL],
+        )
+
+    def test_TensorScatter(self) -> None:
+        self._test_op_upgrade(
+            "TensorScatter",
+            24,
+            [
+                [2, 3, 4, 5],
+                [2, 3, 2, 5],
+                [
+                    2,
+                ],
+            ],
+            [[2, 3, 4, 5]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.INT64],
+            [TensorProto.FLOAT],
+        )
+
+    def test_BitCast(self) -> None:
+        self._test_op_upgrade(
+            "BitCast",
+            26,
+            [[2, 3, 4]],
+            [[2, 3, 4]],
+            [TensorProto.FLOAT],
+            [TensorProto.INT32],
+            attrs={"to": TensorProto.INT32},
+        )
+
+    def test_CausalConvWithState_basic(self) -> None:
+        # input [B=2, C=4, L=8] with kernel size 4: output preserves L,
+        # present_state last dim is kernel_size - 1 = 3.
+        self._test_op_upgrade(
+            "CausalConvWithState",
+            27,
+            [[2, 4, 8], [4, 1, 4]],
+            [[2, 4, 8], [2, 4, 3]],
+            [TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT, TensorProto.FLOAT],
+        )
+
+    def test_CausalConvWithState_with_bias_and_past_state(self) -> None:
+        # Exercises all four inputs (input, weight, bias, past_state).
+        self._test_op_upgrade(
+            "CausalConvWithState",
+            27,
+            [[2, 4, 8], [4, 1, 4], [4], [2, 4, 3]],
+            [[2, 4, 8], [2, 4, 3]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+            ],
+            [TensorProto.FLOAT, TensorProto.FLOAT],
+        )
+
+    def test_CausalConvWithState_kernel_one(self) -> None:
+        # Edge case: kernel_size == 1 -> present_state last dim == 0.
+        self._test_op_upgrade(
+            "CausalConvWithState",
+            27,
+            [[2, 4, 8], [4, 1, 1]],
+            [[2, 4, 8], [2, 4, 0]],
+            [TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT, TensorProto.FLOAT],
+        )
+
+    def test_LinearAttention_basic_mha(self) -> None:
+        # H_q == H_kv == 4, d_k == d_v == 16. update_rule="linear" with no
+        # optional inputs: baseline shape/dtype plumbing on the no-op upgrade.
+        self._test_op_upgrade(
+            "LinearAttention",
+            27,
+            [[2, 4, 64], [2, 4, 64], [2, 4, 64]],
+            [[2, 4, 64], [2, 4, 16, 16]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT, TensorProto.FLOAT],
+            attrs={
+                "q_num_heads": 4,
+                "kv_num_heads": 4,
+                "update_rule": "linear",
+            },
+        )
+
+    def test_LinearAttention_gqa(self) -> None:
+        # Grouped-query: H_q=8, H_kv=2. Output last dim must be H_q * d_v while
+        # present_state's H dim must be H_kv -- highest-risk regression for
+        # confusing q vs kv head counts.
+        self._test_op_upgrade(
+            "LinearAttention",
+            27,
+            [[2, 4, 128], [2, 4, 32], [2, 4, 32]],
+            [[2, 4, 128], [2, 2, 16, 16]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.FLOAT],
+            [TensorProto.FLOAT, TensorProto.FLOAT],
+            attrs={
+                "q_num_heads": 8,
+                "kv_num_heads": 2,
+                "update_rule": "linear",
+            },
+        )
+
+    def test_LinearAttention_gated_delta(self) -> None:
+        # update_rule="gated_delta" with both decay (per-keydim) and beta
+        # required. Exercises the 6-positional-input form with a skipped
+        # optional past_state (input index 3 left empty).
+        self._test_op_upgrade(
+            "LinearAttention",
+            27,
+            [[2, 4, 64], [2, 4, 64], [2, 4, 64], "", [2, 4, 64], [2, 4, 4]],
+            [[2, 4, 64], [2, 4, 16, 16]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+            ],
+            [TensorProto.FLOAT, TensorProto.FLOAT],
+            attrs={
+                "q_num_heads": 4,
+                "kv_num_heads": 4,
+                "update_rule": "gated_delta",
+            },
+        )
+
+    def test_LinearAttention_with_past_state(self) -> None:
+        # past_state has dtype S (FLOAT16) different from T (FLOAT).
+        # present_state must inherit dtype from past_state, not from query.
+        self._test_op_upgrade(
+            "LinearAttention",
+            27,
+            [
+                [2, 1, 64],
+                [2, 1, 64],
+                [2, 1, 64],
+                [2, 4, 16, 16],
+                [2, 1, 64],
+                [2, 1, 4],
+            ],
+            [[2, 1, 64], [2, 4, 16, 16]],
+            [
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT16,
+                TensorProto.FLOAT,
+                TensorProto.FLOAT,
+            ],
+            [TensorProto.FLOAT, TensorProto.FLOAT16],
+            attrs={
+                "q_num_heads": 4,
+                "kv_num_heads": 4,
+                "update_rule": "gated_delta",
+            },
+        )
+
+    def test_ops_tested(self) -> None:
+        # NOTE: This test is order dependent and needs to run last in this class
+        all_schemas = onnx.defs.get_all_schemas()
+        all_op_names = {schema.name for schema in all_schemas if schema.domain == ""}
+        excluded_ops = {
+            # Sequence-based and Optional-based ops disabled because
+            # the version converter doesn't play nicely with sequences
+            "ConcatFromSequence",
+            "SequenceAt",
+            "SequenceConstruct",
+            "SequenceEmpty",
+            "SequenceErase",
+            "SequenceInsert",
+            "SequenceLength",
+            "SequenceMap",
+            "SplitToSequence",
+            "Optional",
+            "OptionalGetElement",
+            "OptionalHasElement",
+            "StringSplit",
+        }
+        expected_tested_ops = all_op_names - excluded_ops
+
+        untested_ops = expected_tested_ops - set(self.tested_ops)
+        assert untested_ops == set()
diff --git a/onnx/test/version_converter_test.py b/onnx/test/version_converter_test.py
new file mode 100644
index 0000000..ad6f52a
--- /dev/null
+++ b/onnx/test/version_converter_test.py
@@ -0,0 +1,3027 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import contextlib
+import os
+import struct
+import tempfile
+
+import numpy as np
+import pytest
+
+import onnx.version_converter
+from onnx import (
+    GraphProto,
+    ModelProto,
+    OperatorSetIdProto,
+    TensorProto,
+    checker,
+    helper,
+    shape_inference,
+)
+
+
+class TestVersionConverter:
+    def _converted(
+        self,
+        graph: GraphProto,
+        initial_version: OperatorSetIdProto,
+        target_version: int,
+    ) -> ModelProto:
+        orig_model = helper.make_model(
+            graph, producer_name="onnx-test", opset_imports=[initial_version]
+        )
+        # print(type(orig_model))
+        converted_model = onnx.version_converter.convert_version(
+            orig_model, target_version
+        )
+        checker.check_model(converted_model)
+        return converted_model
+
+    # Test 1: Backwards Incompatible Conversion: Reshape: 8 -> 2
+    def test_backwards_incompatible(self) -> None:
+        def test() -> None:
+            nodes = [
+                helper.make_node("Add", ["W", "Z"], ["shape"]),
+                helper.make_node("Reshape", ["X", "shape"], ["A"]),
+                helper.make_node("Add", ["A", "W"], ["Y"]),
+            ]
+            graph = helper.make_graph(
+                nodes,
+                "test",
+                [
+                    helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,)),
+                    helper.make_tensor_value_info("W", TensorProto.FLOAT, (1,)),
+                    helper.make_tensor_value_info("Z", TensorProto.FLOAT, (1,)),
+                ],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 8), 2)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    # Test 2: Backwards Compatible Conversion (No Adaptations): Add: 3 -> 2
+    def test_backwards_compatible(self) -> None:
+        nodes = [helper.make_node("Add", ["X1", "X2"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X1", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("X2", TensorProto.FLOAT, (5,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 3), 2)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Add"
+        assert converted_model.opset_import[0].version == 2
+
+    # Test 3: Non-Existent Op Conversion: Cos: 8 -> 6
+    def test_non_existent_op(self) -> None:
+        def test() -> None:
+            nodes = [helper.make_node("Cos", ["X"], ["Y"])]
+            graph = helper.make_graph(
+                nodes,
+                "test",
+                [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,))],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 8), 6)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    # A graph output that nothing produces must raise (ConvertError), not crash.
+    # Regression test for a SEGV in graphProtoToGraph when a top-level
+    # graph output name was absent from the value map.
+    def test_undefined_output(self) -> None:
+        def test() -> None:
+            nodes = [helper.make_node("Identity", ["X"], ["Y"])]
+            # "Z" is listed as a graph output but nothing produces it.
+            graph = helper.make_graph(
+                nodes,
+                "test",
+                [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1,))],
+                [helper.make_tensor_value_info("Z", TensorProto.FLOAT, (1,))],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 13), 14)
+
+        with pytest.raises(onnx.version_converter.ConvertError):
+            test()
+
+    # A node input that nothing produces must raise, not crash.
+    def test_undefined_input(self) -> None:
+        def test() -> None:
+            # "W" is consumed but is neither a graph input nor an initializer.
+            nodes = [helper.make_node("Add", ["X", "W"], ["Y"])]
+            graph = helper.make_graph(
+                nodes,
+                "test",
+                [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1,))],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1,))],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 13), 14)
+
+        with pytest.raises(onnx.version_converter.ConvertError):
+            test()
+
+    # A nested (subgraph) output that resolves to a value captured from the
+    # enclosing scope is handled via a dummy node, not a crash. Exercises the
+    # captured-value path of graphProtoToGraph (nested=True).
+    def test_nested_captured_output(self) -> None:
+        # Each If branch has no nodes and an output ("X") defined only in the
+        # enclosing graph, so the branch import hits the captured-value path.
+        then_branch = helper.make_graph(
+            [],
+            "then",
+            [],
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1,))],
+        )
+        else_branch = helper.make_graph(
+            [],
+            "else",
+            [],
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1,))],
+        )
+        if_node = helper.make_node(
+            "If", ["cond"], ["Y"], then_branch=then_branch, else_branch=else_branch
+        )
+        graph = helper.make_graph(
+            [if_node],
+            "test",
+            [
+                helper.make_tensor_value_info("cond", TensorProto.BOOL, (1,)),
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, (1,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1,))],
+        )
+        orig_model = helper.make_model(
+            graph,
+            producer_name="onnx-test",
+            opset_imports=[helper.make_operatorsetid("", 13)],
+        )
+        converted = onnx.version_converter.convert_version(orig_model, 14)
+        assert [o.name for o in converted.graph.output] == ["Y"]
+
+    # Test Add Adapter: 8 -> 5
+    def test_add_8_5(self) -> None:
+        nodes = [helper.make_node("Add", ["X1", "X2"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X1", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("X2", TensorProto.FLOAT, (1,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 8), 5)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Add"
+        assert converted_model.opset_import[0].version == 5
+
+    # Test Add Adapter: 5 -> 8
+    def test_add_5_8(self) -> None:
+        nodes = [helper.make_node("Add", ["X1", "X2"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X1", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("X2", TensorProto.FLOAT, (1,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 5), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Add"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test Add Adapter: 5 -> 8, requiring insertion of an Unsqueeze node
+    def test_add_5_8_with_unsqueeze(self) -> None:
+        nodes = [helper.make_node("Add", ["X1", "X2"], ["Y"], axis=0, broadcast=1)]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X1", TensorProto.FLOAT, (5, 2)),
+                helper.make_tensor_value_info("X2", TensorProto.FLOAT, (5,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 5), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Unsqueeze"
+        assert converted_model.graph.node[1].op_type == "Add"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test Mul Adapter: 8 -> 5
+    def test_mul_8_5(self) -> None:
+        nodes = [helper.make_node("Mul", ["X1", "X2"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X1", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("X2", TensorProto.FLOAT, (1,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 8), 5)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Mul"
+        assert converted_model.opset_import[0].version == 5
+
+    # Test Mul Adapter: 5 -> 8
+    def test_mul_5_8(self) -> None:
+        nodes = [helper.make_node("Mul", ["X1", "X2"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X1", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("X2", TensorProto.FLOAT, (1,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 5), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Mul"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test Gemm Adapter: 1 -> 8
+    def test_gemm_up(self) -> None:
+        nodes = [helper.make_node("Gemm", ["A", "B", "C"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info(
+                    "A",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                ),
+                helper.make_tensor_value_info(
+                    "B",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                ),
+                helper.make_tensor_value_info(
+                    "C",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                ),
+            ],
+            [
+                helper.make_tensor_value_info(
+                    "Y",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                )
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 1), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Gemm"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test Gemm Adapter: 8 -> 1
+    def test_gemm_down(self) -> None:
+        nodes = [helper.make_node("Gemm", ["A", "B", "C"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info(
+                    "A",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                ),
+                helper.make_tensor_value_info(
+                    "B",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                ),
+                helper.make_tensor_value_info(
+                    "C",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                ),
+            ],
+            [
+                helper.make_tensor_value_info(
+                    "Y",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                )
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 8), 1)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Gemm"
+        assert converted_model.opset_import[0].version == 1
+
+    def test_gemm_7_6_rejects_1d_input(self) -> None:
+        # Regression test: heap-buffer-overflow when B has rank < 2 (advisory)
+        def test() -> None:
+            nodes = [helper.make_node("Gemm", ["A", "B", "C"], ["Y"])]
+            graph = helper.make_graph(
+                nodes,
+                "test_gemm_7_6_rejects_1d_input",
+                [
+                    helper.make_tensor_value_info("A", TensorProto.FLOAT, (4, 3)),
+                    helper.make_tensor_value_info("B", TensorProto.FLOAT, (28,)),
+                    helper.make_tensor_value_info("C", TensorProto.FLOAT, (4,)),
+                ],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, None)],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 7), 6)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    def test_gemm_6_7_rejects_1d_input(self) -> None:
+        # Regression test: heap-buffer-overflow when B has rank < 2 (same pattern, upward)
+        def test() -> None:
+            nodes = [helper.make_node("Gemm", ["A", "B", "C"], ["Y"])]
+            graph = helper.make_graph(
+                nodes,
+                "test_gemm_6_7_rejects_1d_input",
+                [
+                    helper.make_tensor_value_info("A", TensorProto.FLOAT, (4, 3)),
+                    helper.make_tensor_value_info("B", TensorProto.FLOAT, (28,)),
+                    helper.make_tensor_value_info("C", TensorProto.FLOAT, (4,)),
+                ],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, None)],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 6), 7)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    def test_gemm_7_6_rejects_1d_A(self) -> None:
+        # Exercises the A-rank guard (B is valid rank-2, A is rank-1).
+        def test() -> None:
+            nodes = [helper.make_node("Gemm", ["A", "B", "C"], ["Y"])]
+            graph = helper.make_graph(
+                nodes,
+                "test_gemm_7_6_rejects_1d_A",
+                [
+                    helper.make_tensor_value_info("A", TensorProto.FLOAT, (12,)),
+                    helper.make_tensor_value_info("B", TensorProto.FLOAT, (3, 4)),
+                    helper.make_tensor_value_info("C", TensorProto.FLOAT, (4,)),
+                ],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, None)],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 7), 6)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    def test_gemm_6_7_rejects_1d_A(self) -> None:
+        # Exercises the A-rank guard (B is valid rank-2, A is rank-1).
+        def test() -> None:
+            nodes = [helper.make_node("Gemm", ["A", "B", "C"], ["Y"])]
+            graph = helper.make_graph(
+                nodes,
+                "test_gemm_6_7_rejects_1d_A",
+                [
+                    helper.make_tensor_value_info("A", TensorProto.FLOAT, (12,)),
+                    helper.make_tensor_value_info("B", TensorProto.FLOAT, (3, 4)),
+                    helper.make_tensor_value_info("C", TensorProto.FLOAT, (4,)),
+                ],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, None)],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 6), 7)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    # Test Relu Adapter: 5 -> 7
+    def test_relu_5_7(self) -> None:
+        nodes = [helper.make_node("Relu", ["X"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 5), 7)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Relu"
+        assert converted_model.opset_import[0].version == 7
+
+    # Test Relu Adapter: 7 -> 5
+    def test_relu_7_5(self) -> None:
+        nodes = [helper.make_node("Relu", ["X"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 7), 5)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Relu"
+        assert converted_model.opset_import[0].version == 5
+
+    # Test BatchNormalization Adapter: 8 -> 5
+    def test_batch_normalization_8_5(self) -> None:
+        nodes = [
+            helper.make_node(
+                "BatchNormalization", ["X", "scale", "B", "mean", "var"], ["Y"]
+            )
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("scale", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("B", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("mean", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("var", TensorProto.FLOAT, (1,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 8), 5)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "BatchNormalization"
+        assert converted_model.opset_import[0].version == 5
+
+    # Test BatchNormalization Adapter: 5 -> 8
+    def test_batch_normalization_5_8(self) -> None:
+        nodes = [
+            helper.make_node(
+                "BatchNormalization", ["X", "scale", "B", "mean", "var"], ["Y"]
+            )
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("scale", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("B", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("mean", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("var", TensorProto.FLOAT, (1,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 5), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "BatchNormalization"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test Concat Adapter: 3 -> 5
+    def test_concat_3_5(self) -> None:
+        nodes = [helper.make_node("Concat", ["X1", "X2", "X3", "X4", "X5"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X1", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("X2", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("X3", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("X4", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("X5", TensorProto.FLOAT, (1,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 3), 5)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Concat"
+        assert converted_model.opset_import[0].version == 5
+
+    # Test Concat Adapter: 5 -> 3
+    def test_concat_5_3(self) -> None:
+        nodes = [
+            helper.make_node("Concat", ["X1", "X2", "X3", "X4", "X5"], ["Y"], axis=0)
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("X1", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("X2", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("X3", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("X4", TensorProto.FLOAT, (1,)),
+                helper.make_tensor_value_info("X5", TensorProto.FLOAT, (1,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 5), 3)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Concat"
+        assert converted_model.opset_import[0].version == 3
+
+    # Test Reshape Adapter: 6 -> 4
+    def test_reshape_6_4(self) -> None:
+        nodes = [
+            helper.make_node(
+                "Constant",
+                [],
+                ["shape"],
+                value=helper.make_tensor("", TensorProto.INT64, [1], [5]),
+            ),
+            helper.make_node("Reshape", ["X", "shape"], ["Y"]),
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 6), 4)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Reshape"
+        assert converted_model.opset_import[0].version == 4
+
+    # Test Reshape Adapter: 4 -> 6
+    def test_reshape_4_6(self) -> None:
+        nodes = [helper.make_node("Reshape", ["X"], ["Y"], shape=[5])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 4), 6)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Constant"
+        assert converted_model.graph.node[1].op_type == "Reshape"
+        assert converted_model.opset_import[0].version == 6
+
+    # Test Sum Adapter: 7 -> 8
+    def test_sum_7_8(self) -> None:
+        nodes = [
+            helper.make_node(
+                "Sum", ["data_0", "data_1", "data_2", "data_3", "data_4"], ["sum"]
+            )
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("data_0", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_1", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_2", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_3", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_4", TensorProto.FLOAT, (5,)),
+            ],
+            [helper.make_tensor_value_info("sum", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 7), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Sum"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test Sum Adapter: 5 -> 8
+    def test_sum_5_8(self) -> None:
+        nodes = [
+            helper.make_node(
+                "Sum", ["data_0", "data_1", "data_2", "data_3", "data_4"], ["sum"]
+            )
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("data_0", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_1", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_2", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_3", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_4", TensorProto.FLOAT, (5,)),
+            ],
+            [helper.make_tensor_value_info("sum", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 5), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Sum"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test Sum Adapter: 8 -> 5
+    def test_sum_8_5(self) -> None:
+        nodes = [
+            helper.make_node(
+                "Sum", ["data_0", "data_1", "data_2", "data_3", "data_4"], ["sum"]
+            )
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info("data_0", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_1", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_2", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_3", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("data_4", TensorProto.FLOAT, (5,)),
+            ],
+            [helper.make_tensor_value_info("sum", TensorProto.FLOAT, (5,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 8), 5)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Sum"
+        assert converted_model.opset_import[0].version == 5
+
+    # Test AveragePool Adapter: 1 -> 8
+    def test_averagepool_up(self) -> None:
+        nodes = [helper.make_node("AveragePool", ["X"], ["Y"], kernel_shape=[1, 1])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5, 5, 5, 5))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5, 5, 5, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 1), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "AveragePool"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test AveragePool Adapter: 8 -> 1
+    def test_averagepool_down(self) -> None:
+        nodes = [helper.make_node("AveragePool", ["X"], ["Y"], kernel_shape=[1, 1])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5, 5, 5, 5))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5, 5, 5, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 8), 1)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "AveragePool"
+        assert converted_model.opset_import[0].version == 1
+
+    # Test Dropout Adapter: 1 -> 8
+    def test_dropout_up(self) -> None:
+        nodes = [helper.make_node("Dropout", ["data"], ["output"], is_test=1)]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info(
+                    "data",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                )
+            ],
+            [
+                helper.make_tensor_value_info(
+                    "output",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                )
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 1), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Dropout"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test Dropout Adapter: 8 -> 1
+    def test_dropout_down(self) -> None:
+        nodes = [helper.make_node("Dropout", ["data"], ["output"])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [
+                helper.make_tensor_value_info(
+                    "data",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                )
+            ],
+            [
+                helper.make_tensor_value_info(
+                    "output",
+                    TensorProto.FLOAT,
+                    (
+                        5,
+                        5,
+                    ),
+                )
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 8), 1)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Dropout"
+        assert converted_model.opset_import[0].version == 1
+
+    # Test Max Adapter: 7 -> 8
+    def test_max_7_8(self) -> None:
+        from_opset = 7
+        to_opset = 8
+        data_type = TensorProto.FLOAT
+        data_shape = (2, 3, 4)
+
+        nodes = [onnx.helper.make_node("Max", inputs=["X"], outputs=["Y"])]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_max",
+            [onnx.helper.make_tensor_value_info("X", data_type, data_shape)],
+            [onnx.helper.make_tensor_value_info("Y", data_type, data_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Max"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Min Adapter: 7 -> 8
+    def test_min_7_8(self) -> None:
+        from_opset = 7
+        to_opset = 8
+        data_type = TensorProto.FLOAT
+        data_shape = (2, 3, 4)
+
+        nodes = [onnx.helper.make_node("Min", inputs=["X"], outputs=["Y"])]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_min",
+            [onnx.helper.make_tensor_value_info("X", data_type, data_shape)],
+            [onnx.helper.make_tensor_value_info("Y", data_type, data_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Min"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Mean Adapter: 7 -> 8
+    def test_mean_7_8(self) -> None:
+        from_opset = 7
+        to_opset = 8
+        data_type = TensorProto.FLOAT
+        data_shape = (3,)
+
+        nodes = [onnx.helper.make_node("Mean", inputs=["X"], outputs=["Y"])]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_mean",
+            [onnx.helper.make_tensor_value_info("X", data_type, data_shape)],
+            [onnx.helper.make_tensor_value_info("Y", data_type, data_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Mean"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test MaxPool Adapter: 1 -> 8
+    def test_maxpool_up(self) -> None:
+        nodes = [helper.make_node("MaxPool", ["X"], ["Y"], kernel_shape=[1, 1])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5, 5, 5, 5))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5, 5, 5, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 1), 8)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "MaxPool"
+        assert converted_model.opset_import[0].version == 8
+
+    # Test Upsample Adapter: 6 -> 7
+    def test_upsample_6_7(self) -> None:
+        from_opset = 6
+        to_opset = 7
+        data_type = TensorProto.FLOAT
+
+        nodes = [
+            onnx.helper.make_node(
+                "Upsample",
+                inputs=["X"],
+                outputs=["Y"],
+                mode="nearest",
+                width_scale=3.0,
+                height_scale=2.0,
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_upsample_6_7",
+            [onnx.helper.make_tensor_value_info("X", data_type, [1, 1, 2, 2])],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [1, 1, 4, 6])],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert len(converted_model.graph.node) == 1
+        assert converted_model.graph.node[0].op_type == "Upsample"
+        attribute_names = [
+            attr.name for attr in converted_model.graph.node[0].attribute
+        ]
+        assert "scales" in attribute_names
+        assert "width_scale" not in attribute_names
+        assert "height_scale" not in attribute_names
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test MaxPool Adapter: 8 -> 1
+    def test_maxpool_down(self) -> None:
+        nodes = [helper.make_node("MaxPool", ["X"], ["Y"], kernel_shape=[1, 1])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5, 5, 5, 5))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (5, 5, 5, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 8), 1)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "MaxPool"
+        assert converted_model.opset_import[0].version == 1
+
+    # Test BatchNormalization Adapter: 8 -> 9
+    def test_batch_normalization_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        nodes = [
+            helper.make_node(
+                "BatchNormalization",
+                inputs=["x", "s", "bias", "mean", "var"],
+                outputs=["y"],
+            )
+        ]
+
+        input_shape = (1, 2, 1, 3)
+        x = helper.make_tensor_value_info("x", data_type, input_shape)
+        scale = helper.make_tensor_value_info("s", data_type, [input_shape[1]])
+        B = helper.make_tensor_value_info("bias", data_type, [input_shape[1]])
+        mean = helper.make_tensor_value_info("mean", data_type, [input_shape[1]])
+        var = helper.make_tensor_value_info("var", data_type, [input_shape[1]])
+        y = helper.make_tensor_value_info("y", data_type, input_shape)
+
+        graph = helper.make_graph(
+            nodes, "test_batchnormalization_8_9", [x, scale, B, mean, var], [y]
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "BatchNormalization"
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test BatchNormalization Adapter: 9 -> 8
+    def test_batchnormalization_9_8(self) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.FLOAT
+
+        nodes = [
+            onnx.helper.make_node(
+                "BatchNormalization",
+                inputs=["X", "scale", "B", "mean", "var"],
+                outputs=["Y"],
+            )
+        ]
+
+        input_shape = (2, 3, 4, 5)
+        x = onnx.helper.make_tensor_value_info("X", data_type, input_shape)
+        scale = onnx.helper.make_tensor_value_info("scale", data_type, [input_shape[1]])
+        B = onnx.helper.make_tensor_value_info("B", data_type, [input_shape[1]])
+        mean = onnx.helper.make_tensor_value_info("mean", data_type, [input_shape[1]])
+        var = onnx.helper.make_tensor_value_info("var", data_type, [input_shape[1]])
+        y = onnx.helper.make_tensor_value_info("Y", data_type, input_shape)
+
+        graph = onnx.helper.make_graph(
+            nodes, "test_batchnormalization", [x, scale, B, mean, var], [y]
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "BatchNormalization"
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Constant Adapter: 8 -> 9
+    def test_constant_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        output_shape = [2, 3, 4]
+        output_value = np.arange(24)
+
+        nodes = [
+            helper.make_node(
+                "Constant",
+                inputs=[],
+                outputs=["Y"],
+                value=helper.make_tensor("", data_type, output_shape, output_value),
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_constant",
+            [],
+            [onnx.helper.make_tensor_value_info("Y", data_type, output_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Constant"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Constant Adapter: 9 -> 8
+    def test_constant_9_8(self) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.UINT64
+
+        output_shape = [2, 3, 4]
+        output_value = np.arange(24)
+
+        nodes = [
+            helper.make_node(
+                "Constant",
+                inputs=[],
+                outputs=["Y"],
+                value=helper.make_tensor("", data_type, output_shape, output_value),
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_constant",
+            [],
+            [onnx.helper.make_tensor_value_info("Y", data_type, output_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Constant"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Flatten Adapter: 8 -> 9
+    def test_flatten_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        nodes = [onnx.helper.make_node("Flatten", inputs=["X"], outputs=["Y"], axis=1)]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_flatten",
+            [onnx.helper.make_tensor_value_info("X", data_type, [2, 3, 4])],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [2, 12])],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Flatten"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Flatten Adapter: 9 -> 8
+    def test_flatten_9_8(self) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.UINT64
+
+        nodes = [onnx.helper.make_node("Flatten", inputs=["X"], outputs=["Y"], axis=1)]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_flatten",
+            [onnx.helper.make_tensor_value_info("X", data_type, [2, 3, 4])],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [2, 12])],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[1].op_type == "Flatten"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test PRelu Adapter: 8 -> 9
+    def test_prelu_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        nodes = [onnx.helper.make_node("PRelu", inputs=["X", "Slope"], outputs=["Y"])]
+
+        input_shape = [2, 3, 4]
+        graph = helper.make_graph(
+            nodes,
+            "test_prelu",
+            [
+                onnx.helper.make_tensor_value_info("X", data_type, input_shape),
+                onnx.helper.make_tensor_value_info("Slope", data_type, input_shape),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", data_type, input_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "PRelu"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test PRelu Adapter: 9 -> 8
+    def test_prelu_9_8(self) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.UINT64
+
+        nodes = [onnx.helper.make_node("PRelu", inputs=["X", "Slope"], outputs=["Y"])]
+
+        input_shape = [2, 3, 4]
+        graph = helper.make_graph(
+            nodes,
+            "test_prelu",
+            [
+                onnx.helper.make_tensor_value_info("X", data_type, input_shape),
+                onnx.helper.make_tensor_value_info("Slope", data_type, input_shape),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", data_type, input_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[2].op_type == "PRelu"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Greater Adapter: 8 -> 9
+    def test_greater_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        nodes = [onnx.helper.make_node("Greater", inputs=["X1", "X2"], outputs=["Y"])]
+
+        input_shape = [2, 3, 4]
+        graph = helper.make_graph(
+            nodes,
+            "test_greater",
+            [
+                onnx.helper.make_tensor_value_info("X1", data_type, input_shape),
+                onnx.helper.make_tensor_value_info("X2", data_type, input_shape),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", TensorProto.BOOL, input_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Greater"
+        assert (
+            converted_model.graph.output[0].type.tensor_type.elem_type
+            == TensorProto.BOOL
+        )
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Greater Adapter: 9 -> 8
+    def test_greater_9_8(self) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.UINT64
+
+        nodes = [onnx.helper.make_node("Greater", inputs=["X1", "X2"], outputs=["Y"])]
+
+        input_shape = [2, 3, 4]
+        graph = helper.make_graph(
+            nodes,
+            "test_greater",
+            [
+                onnx.helper.make_tensor_value_info("X1", data_type, input_shape),
+                onnx.helper.make_tensor_value_info("X2", data_type, input_shape),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", TensorProto.BOOL, input_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[2].op_type == "Greater"
+        assert (
+            converted_model.graph.output[0].type.tensor_type.elem_type
+            == TensorProto.BOOL
+        )
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Less Adapter: 8 -> 9
+    def test_less_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        nodes = [onnx.helper.make_node("Less", inputs=["X1", "X2"], outputs=["Y"])]
+
+        input_shape = [2, 3, 4]
+        graph = helper.make_graph(
+            nodes,
+            "test_less",
+            [
+                onnx.helper.make_tensor_value_info("X1", data_type, input_shape),
+                onnx.helper.make_tensor_value_info("X2", data_type, input_shape),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", TensorProto.BOOL, input_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Less"
+        assert (
+            converted_model.graph.output[0].type.tensor_type.elem_type
+            == TensorProto.BOOL
+        )
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Less Adapter: 9 -> 8
+    def test_less_9_8(self) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.UINT64
+
+        nodes = [onnx.helper.make_node("Less", inputs=["X1", "X2"], outputs=["Y"])]
+
+        input_shape = [2, 3, 4]
+        graph = helper.make_graph(
+            nodes,
+            "test_less",
+            [
+                onnx.helper.make_tensor_value_info("X1", data_type, input_shape),
+                onnx.helper.make_tensor_value_info("X2", data_type, input_shape),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", TensorProto.BOOL, input_shape)],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[2].op_type == "Less"
+        assert (
+            converted_model.graph.output[0].type.tensor_type.elem_type
+            == TensorProto.BOOL
+        )
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test MatMul Adapter: 8 -> 9
+    def test_matmul_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        nodes = [onnx.helper.make_node("MatMul", inputs=["X1", "X2"], outputs=["Y"])]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_matmul",
+            [
+                onnx.helper.make_tensor_value_info("X1", data_type, [3, 4]),
+                onnx.helper.make_tensor_value_info("X2", data_type, [4, 3]),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [3, 3])],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "MatMul"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test MatMul Adapter: 9 -> 8
+    def test_matmul_9_8(self) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.UINT64
+
+        nodes = [onnx.helper.make_node("MatMul", inputs=["X1", "X2"], outputs=["Y"])]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_matmul",
+            [
+                onnx.helper.make_tensor_value_info("X1", data_type, [3, 4]),
+                onnx.helper.make_tensor_value_info("X2", data_type, [4, 3]),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [3, 3])],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[2].op_type == "MatMul"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Gemm Adapter: 8 -> 9
+    def test_gemm_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        nodes = [
+            onnx.helper.make_node("Gemm", inputs=["X1", "X2", "X3"], outputs=["Y"])
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_gemm",
+            [
+                onnx.helper.make_tensor_value_info("X1", data_type, [3, 4]),
+                onnx.helper.make_tensor_value_info("X2", data_type, [4, 3]),
+                onnx.helper.make_tensor_value_info("X3", data_type, [3, 3]),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [3, 3])],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Gemm"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Gemm Adapter: 9 -> 8
+    def test_gemm_9_8(self) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.UINT64
+
+        nodes = [
+            onnx.helper.make_node("Gemm", inputs=["X1", "X2", "X3"], outputs=["Y"])
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_gemm",
+            [
+                onnx.helper.make_tensor_value_info("X1", data_type, [3, 4]),
+                onnx.helper.make_tensor_value_info("X2", data_type, [4, 3]),
+                onnx.helper.make_tensor_value_info("X3", data_type, [3, 3]),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [3, 3])],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[3].op_type == "Gemm"
+        assert converted_model.graph.output[0].type.tensor_type.elem_type == data_type
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Upsample Adapter: 8 -> 9
+    def test_upsample_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        nodes = [
+            onnx.helper.make_node(
+                "Upsample",
+                inputs=["X"],
+                outputs=["Y"],
+                mode="nearest",
+                scales=[1.0, 1.0, 2.0, 3.0],
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_upsample_8_9",
+            [onnx.helper.make_tensor_value_info("X", data_type, [1, 1, 2, 2])],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [1, 1, 4, 6])],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert len(converted_model.graph.node) == 2
+        assert converted_model.graph.node[0].op_type == "Constant"
+        assert converted_model.graph.node[1].op_type == "Upsample"
+        assert len(converted_model.graph.node[1].attribute) == 1
+        assert converted_model.graph.node[1].attribute[0].name == "mode"
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Helper for Upsample Adapter: 9 -> 8
+    def helper_upsample_with_initializer(self, raw_scale: bool = False) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.FLOAT
+
+        nodes = [
+            onnx.helper.make_node(
+                "Upsample", inputs=["X", "Scales"], outputs=["Y"], mode="nearest"
+            )
+        ]
+
+        scale_value = [1.0, 1.0, 2.0, 3.0]
+        scale_tensor = onnx.helper.make_tensor(
+            "Scales",
+            onnx.TensorProto.FLOAT,
+            [4],
+            bytes(struct.pack("4f", *scale_value)) if raw_scale else scale_value,
+            raw_scale,
+        )
+
+        graph = helper.make_graph(
+            nodes,
+            "test_upsample",
+            [
+                onnx.helper.make_tensor_value_info("X", data_type, [1, 1, 2, 2]),
+                onnx.helper.make_tensor_value_info("Scales", data_type, [4]),
+            ],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [1, 1, 4, 6])],
+            [scale_tensor],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Upsample"
+        assert len(converted_model.graph.initializer) == 0
+        assert len(converted_model.graph.node[0].attribute) == 2
+        assert converted_model.graph.node[0].attribute[1].name == "scales"
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Helper for Upsample Adapter: 9 -> 8
+    def helper_upsample_with_constant(self, raw_scale: bool = False) -> None:
+        from_opset = 9
+        to_opset = 8
+        data_type = TensorProto.FLOAT
+
+        scale_value = [1.0, 1.0, 2.0, 3.0]
+        scale_tensor = onnx.helper.make_tensor(
+            "const_value",
+            onnx.TensorProto.FLOAT,
+            [4],
+            bytes(struct.pack("4f", *scale_value)) if raw_scale else scale_value,
+            raw_scale,
+        )
+        nodes = [
+            onnx.helper.make_node(
+                "Constant", inputs=[], outputs=["Constant_Output"], value=scale_tensor
+            ),
+            onnx.helper.make_node(
+                "Upsample",
+                inputs=["X", "Constant_Output"],
+                outputs=["Y"],
+                mode="nearest",
+            ),
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_upsample",
+            [onnx.helper.make_tensor_value_info("X", data_type, [1, 1, 2, 2])],
+            [onnx.helper.make_tensor_value_info("Y", data_type, [1, 1, 4, 6])],
+            value_info=[
+                onnx.helper.make_tensor_value_info("Constant_Output", data_type, [4])
+            ],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert len(converted_model.graph.node) == 1
+        assert converted_model.graph.node[0].op_type == "Upsample"
+        assert len(converted_model.graph.node[0].attribute) == 2
+        assert converted_model.graph.node[0].attribute[1].name == "scales"
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Upsample Adapter: 9 -> 8
+    def test_upsample_with_constant_node_9_8(self) -> None:
+        self.helper_upsample_with_constant(raw_scale=False)
+
+    # Test Upsample Adapter: 9 -> 8
+    def test_upsample_with_initializer_9_8(self) -> None:
+        self.helper_upsample_with_initializer(raw_scale=False)
+
+    # Test Upsample Adapter: 9 -> 8
+    def test_upsample_with_raw_initializer_9_8(self) -> None:
+        self.helper_upsample_with_initializer(raw_scale=True)
+
+    # Test Upsample Adapter: 9 -> 8
+    def test_upsample_with_raw_constant_node_9_8(self) -> None:
+        self.helper_upsample_with_constant(raw_scale=True)
+
+    # Test Scan Adapter: 8 -> 9
+    def test_scan_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type = TensorProto.FLOAT
+
+        node1 = onnx.helper.make_node(
+            "Add",
+            inputs=["sum_in", "next"],
+            outputs=["sum_out"],
+        )
+        node2 = onnx.helper.make_node(
+            "Identity",
+            inputs=["sum_out"],
+            outputs=["scan_out"],
+        )
+        g = onnx.helper.make_graph(
+            [node1, node2],
+            "scan_body",
+            [
+                onnx.helper.make_tensor_value_info("sum_in", data_type, [2]),
+                onnx.helper.make_tensor_value_info("next", data_type, [2]),
+            ],
+            [
+                onnx.helper.make_tensor_value_info("sum_out", data_type, [2]),
+                onnx.helper.make_tensor_value_info("scan_out", data_type, [2]),
+            ],
+        )
+
+        no_sequence_lens = ""  # optional input, not supplied
+        nodes = [
+            onnx.helper.make_node(
+                "Scan",
+                inputs=[no_sequence_lens, "initial", "x"],
+                outputs=["y", "z"],
+                body=g,
+                num_scan_inputs=1,
+            )
+        ]
+
+        initial = onnx.helper.make_tensor_value_info("initial", data_type, [1, 2])
+        x = onnx.helper.make_tensor_value_info("x", data_type, [1, 3, 2])
+        y = onnx.helper.make_tensor_value_info("y", data_type, [1, 2])
+        z = onnx.helper.make_tensor_value_info("z", data_type, [1, 3, 2])
+
+        graph = onnx.helper.make_graph(nodes, "test_scan_8_9", [initial, x], [y, z])
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Scan"
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Cast Adapter: 8 -> 9
+    def test_cast_8_9(self) -> None:
+        from_opset = 8
+        to_opset = 9
+        data_type_from = TensorProto.FLOAT
+        data_type_to = TensorProto.UINT32
+
+        nodes = [
+            onnx.helper.make_node(
+                "Cast", inputs=["X"], outputs=["Y"], to=TensorProto.UINT32
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_cast",
+            [onnx.helper.make_tensor_value_info("X", data_type_from, [2, 3])],
+            [onnx.helper.make_tensor_value_info("Y", data_type_to, [2, 3])],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "Cast"
+        assert (
+            converted_model.graph.output[0].type.tensor_type.elem_type == data_type_to
+        )
+        assert converted_model.opset_import[0].version == to_opset
+
+    # Test Split Adapter: 13 -> 12
+    def test_split_13_12(self) -> None:
+        nodes = [
+            helper.make_node(
+                "Constant",
+                [],
+                ["split"],
+                value=helper.make_tensor("", TensorProto.INT64, [2], [2, 3]),
+            ),
+            helper.make_node("Split", ["X", "split"], ["Y1", "Y2"]),
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,))],
+            [
+                helper.make_tensor_value_info("Y1", TensorProto.FLOAT, (2,)),
+                helper.make_tensor_value_info("Y2", TensorProto.FLOAT, (3,)),
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 13), 12)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Split"
+        assert converted_model.opset_import[0].version == 12
+
+    def test_split_with_optional_input(self) -> None:
+        nodes = [helper.make_node("Split", ["X"], ["Y1", "Y2"], axis=1)]
+        graph = helper.make_graph(
+            nodes,
+            "test_split_optional_input",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (6,))],
+            [
+                helper.make_tensor_value_info("Y1", TensorProto.FLOAT, (3,)),
+                helper.make_tensor_value_info("Y2", TensorProto.FLOAT, (3,)),
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 12), 18)
+
+        assert converted_model.graph.node[0].op_type == "Split"
+        assert converted_model.opset_import[0].version == 18
+
+        assert len(converted_model.graph.node[0].output) == 2
+
+    # Test Split Adapter: 12 -> 13
+    def test_split_12_13(self) -> None:
+        nodes = [helper.make_node("Split", ["X"], ["Y1", "Y2"], split=[2, 3])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5,))],
+            [
+                helper.make_tensor_value_info("Y1", TensorProto.FLOAT, (2,)),
+                helper.make_tensor_value_info("Y2", TensorProto.FLOAT, (3,)),
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 12), 13)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Constant"
+        assert converted_model.graph.node[1].op_type == "Split"
+        assert converted_model.opset_import[0].version == 13
+
+    # Test Split Adapter: 13 -> 12 with optional split input
+    def test_split_13_12_optional_input(self) -> None:
+        """Test Split 13->12 conversion with optional split input."""
+        nodes = [helper.make_node("Split", ["X"], ["Y1", "Y2"], axis=0)]
+        graph = helper.make_graph(
+            nodes,
+            "test_split_13_12_optional",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (10,))],
+            [
+                helper.make_tensor_value_info("Y1", TensorProto.FLOAT, (5,)),
+                helper.make_tensor_value_info("Y2", TensorProto.FLOAT, (5,)),
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 13), 12)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Split"
+        assert converted_model.opset_import[0].version == 12
+
+    # Test AxesInputToAttribute Adapter: 13 -> 12
+    def test_axes_input_to_attr_13_12(self) -> None:
+        nodes = [
+            helper.make_node(
+                "Constant",
+                [],
+                ["axes"],
+                value=helper.make_tensor("", TensorProto.INT64, [1], [0]),
+            ),
+            helper.make_node("ReduceSum", ["X", "axes"], ["Y"]),
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5, 5))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 13), 12)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "ReduceSum"
+        assert converted_model.opset_import[0].version == 12
+
+    # Test AxesAttributeToInput Adapter: 12 -> 13
+    def test_axes_attr_to_input_12_13(self) -> None:
+        nodes = [helper.make_node("ReduceSum", ["X"], ["Y"], axes=[0])]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5, 5))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 12), 13)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Constant"
+        assert converted_model.opset_import[0].version == 13
+
+    # Test AxesInputToAttribute Adapter: 13 -> 11 with optional axes input
+    def test_squeeze_13_11_optional_axes(self) -> None:
+        """Test Squeeze 13->11 conversion with optional axes input."""
+        nodes = [helper.make_node("Squeeze", ["X"], ["Y"])]
+        graph = helper.make_graph(
+            nodes,
+            "test_squeeze_13_11_optional",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1, 10, 1))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (10,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 13), 11)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Squeeze"
+        assert converted_model.opset_import[0].version == 11
+
+    # Test Reshape Adapter: 4 -> 5 with optional axes input
+    def test_reshape_4_5_optional_shape(self) -> None:
+        """Test Reshape 4->5 conversion - shape in attribute should become input."""
+        nodes = [helper.make_node("Reshape", ["X"], ["Y"], shape=[2, 5])]
+        graph = helper.make_graph(
+            nodes,
+            "test_reshape_4_5",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (10,))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (2, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 4), 5)
+        # Should have added a Constant node for the shape
+        assert converted_model.graph.node[0].op_type == "Constant"
+        assert converted_model.graph.node[1].op_type == "Reshape"
+        assert converted_model.opset_import[0].version == 5
+
+    # Test Resize Adapter: 10 -> 11
+    def test_resize_10_11_bounds_check(self) -> None:
+        """Test Resize 10->11 conversion with proper bounds checking."""
+        nodes = [
+            helper.make_node(
+                "Constant",
+                [],
+                ["scales"],
+                value=helper.make_tensor(
+                    "", TensorProto.FLOAT, [4], [1.0, 1.0, 2.0, 2.0]
+                ),
+            ),
+            helper.make_node("Resize", ["X", "scales"], ["Y"], mode="nearest"),
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test_resize_10_11",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1, 1, 2, 2))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 1, 4, 4))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 10), 11)
+        assert converted_model.opset_import[0].version == 11
+
+    # Test Scatter Adapter: 10 -> 11
+    def test_scatter_10_11_bounds_check(self) -> None:
+        """Test Scatter 10->11 conversion with proper bounds checking."""
+        nodes = [
+            helper.make_node("Scatter", ["data", "indices", "updates"], ["Y"], axis=0)
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test_scatter_10_11",
+            [
+                helper.make_tensor_value_info("data", TensorProto.FLOAT, (3,)),
+                helper.make_tensor_value_info("indices", TensorProto.INT64, (2,)),
+                helper.make_tensor_value_info("updates", TensorProto.FLOAT, (2,)),
+            ],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (3,))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 10), 11)
+        assert converted_model.graph.node[0].op_type == "ScatterElements"
+        assert converted_model.opset_import[0].version == 11
+
+    # Test Slice Adapter: 9 -> 10
+    def test_slice_9_10(self) -> None:
+        nodes = [
+            helper.make_node(
+                "Slice", ["X"], ["Y"], axes=[0, 1], starts=[0, 0], ends=[3, 10]
+            )
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (20, 10, 5))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (3, 10, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 9), 10)
+
+        assert converted_model.graph.node[0].op_type == "Constant"
+        assert converted_model.graph.node[1].op_type == "Constant"
+        assert converted_model.graph.node[2].op_type == "Constant"
+        assert converted_model.graph.node[3].op_type == "Slice"
+        assert converted_model.opset_import[0].version == 10
+        assert len(converted_model.graph.node[3].input) == 4
+        assert len(converted_model.graph.node[3].attribute) == 0
+
+    # Test RNN Adapter: 13 -> 14
+    def test_rnn_13_14(self) -> None:
+        from_opset = 13
+        to_opset = 14
+        data_type = TensorProto.FLOAT
+
+        seq_length = 1
+        batch_size = 2
+        input_size = 3
+        num_directions = 1
+        hidden_size = 5
+
+        nodes = [
+            onnx.helper.make_node(
+                "RNN",
+                inputs=["X", "W", "R"],
+                outputs=["", "Y_h"],
+                hidden_size=hidden_size,
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_rnn",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "X", data_type, [seq_length, batch_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "W", data_type, [num_directions, hidden_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "R", data_type, [num_directions, hidden_size, hidden_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "B", data_type, [num_directions, 2 * hidden_size]
+                ),
+            ],
+            [
+                onnx.helper.make_tensor_value_info(
+                    "Y_h", data_type, [num_directions, batch_size, hidden_size]
+                )
+            ],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "RNN"
+        assert converted_model.opset_import[0].version == to_opset
+        assert len(converted_model.graph.node[0].attribute) == 2
+        assert converted_model.graph.node[0].attribute[1].name == "layout"
+
+    # Test GRU Adapter: 13 -> 14
+    def test_gru_13_14(self) -> None:
+        from_opset = 13
+        to_opset = 14
+        data_type = TensorProto.FLOAT
+
+        seq_length = 1
+        batch_size = 2
+        input_size = 3
+        num_directions = 1
+        hidden_size = 5
+
+        nodes = [
+            onnx.helper.make_node(
+                "GRU",
+                inputs=["X", "W", "R"],
+                outputs=["", "Y_h"],
+                hidden_size=hidden_size,
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_gru",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "X", data_type, [seq_length, batch_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "W", data_type, [num_directions, 3 * hidden_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "R", data_type, [num_directions, 3 * hidden_size, hidden_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "B", data_type, [num_directions, 6 * hidden_size]
+                ),
+            ],
+            [
+                onnx.helper.make_tensor_value_info(
+                    "Y_h", data_type, [num_directions, batch_size, hidden_size]
+                )
+            ],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "GRU"
+        assert converted_model.opset_import[0].version == to_opset
+        assert len(converted_model.graph.node[0].attribute) == 2
+        assert converted_model.graph.node[0].attribute[1].name == "layout"
+
+    # Test LSTM Adapter: 13 -> 14
+    def test_lstm_13_14(self) -> None:
+        from_opset = 13
+        to_opset = 14
+        data_type = TensorProto.FLOAT
+
+        seq_length = 1
+        batch_size = 2
+        input_size = 3
+        num_directions = 1
+        hidden_size = 5
+
+        nodes = [
+            onnx.helper.make_node(
+                "LSTM",
+                inputs=["X", "W", "R"],
+                outputs=["", "Y_h"],
+                hidden_size=hidden_size,
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_lstm",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "X", data_type, [seq_length, batch_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "W", data_type, [num_directions, 4 * hidden_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "R", data_type, [num_directions, 4 * hidden_size, hidden_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "B", data_type, [num_directions, 8 * hidden_size]
+                ),
+            ],
+            [
+                onnx.helper.make_tensor_value_info(
+                    "Y_h", data_type, [num_directions, batch_size, hidden_size]
+                )
+            ],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "LSTM"
+        assert converted_model.opset_import[0].version == to_opset
+        assert len(converted_model.graph.node[0].attribute) == 2
+        assert converted_model.graph.node[0].attribute[1].name == "layout"
+
+    # Test RNN Adapter: 14 -> 13
+    def test_rnn_14_13(self) -> None:
+        from_opset = 14
+        to_opset = 13
+        data_type = TensorProto.FLOAT
+
+        seq_length = 1
+        batch_size = 2
+        input_size = 3
+        num_directions = 1
+        hidden_size = 5
+
+        nodes = [
+            onnx.helper.make_node(
+                "RNN",
+                inputs=["X", "W", "R"],
+                outputs=["", "Y_h"],
+                hidden_size=hidden_size,
+                layout=0,
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_rnn",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "X", data_type, [seq_length, batch_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "W", data_type, [num_directions, hidden_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "R", data_type, [num_directions, hidden_size, hidden_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "B", data_type, [num_directions, 2 * hidden_size]
+                ),
+            ],
+            [
+                onnx.helper.make_tensor_value_info(
+                    "Y_h", data_type, [num_directions, batch_size, hidden_size]
+                )
+            ],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "RNN"
+        assert converted_model.opset_import[0].version == to_opset
+        assert len(converted_model.graph.node[0].attribute) == 1
+
+    # Test GRU Adapter: 14 -> 13
+    def test_gru_14_13(self) -> None:
+        from_opset = 14
+        to_opset = 13
+        data_type = TensorProto.FLOAT
+
+        seq_length = 1
+        batch_size = 2
+        input_size = 3
+        num_directions = 1
+        hidden_size = 5
+
+        nodes = [
+            onnx.helper.make_node(
+                "GRU",
+                inputs=["X", "W", "R"],
+                outputs=["", "Y_h"],
+                hidden_size=hidden_size,
+                layout=0,
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_gru",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "X", data_type, [seq_length, batch_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "W", data_type, [num_directions, 3 * hidden_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "R", data_type, [num_directions, 3 * hidden_size, hidden_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "B", data_type, [num_directions, 6 * hidden_size]
+                ),
+            ],
+            [
+                onnx.helper.make_tensor_value_info(
+                    "Y_h", data_type, [num_directions, batch_size, hidden_size]
+                )
+            ],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "GRU"
+        assert converted_model.opset_import[0].version == to_opset
+        assert len(converted_model.graph.node[0].attribute) == 1
+
+    # Test LSTM Adapter: 14 -> 13
+    def test_lstm_14_13(self) -> None:
+        from_opset = 14
+        to_opset = 13
+        data_type = TensorProto.FLOAT
+
+        seq_length = 1
+        batch_size = 2
+        input_size = 3
+        num_directions = 1
+        hidden_size = 5
+
+        nodes = [
+            onnx.helper.make_node(
+                "LSTM",
+                inputs=["X", "W", "R"],
+                outputs=["", "Y_h"],
+                hidden_size=hidden_size,
+                layout=0,
+            )
+        ]
+
+        graph = helper.make_graph(
+            nodes,
+            "test_lstm",
+            [
+                onnx.helper.make_tensor_value_info(
+                    "X", data_type, [seq_length, batch_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "W", data_type, [num_directions, 4 * hidden_size, input_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "R", data_type, [num_directions, 4 * hidden_size, hidden_size]
+                ),
+                onnx.helper.make_tensor_value_info(
+                    "B", data_type, [num_directions, 8 * hidden_size]
+                ),
+            ],
+            [
+                onnx.helper.make_tensor_value_info(
+                    "Y_h", data_type, [num_directions, batch_size, hidden_size]
+                )
+            ],
+        )
+
+        converted_model = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted_model.graph.node[0].op_type == "LSTM"
+        assert converted_model.opset_import[0].version == to_opset
+        assert len(converted_model.graph.node[0].attribute) == 1
+
+    # Test Pad Adapter: 10 -> 11
+    def test_pad_10_11(self) -> None:
+        pads = (0, 1, 2, 0, 2, 1)
+        nodes = [helper.make_node("Pad", ["X"], ["Y"], pads=pads)]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1, 2, 2))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 5, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 10), 11)
+
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[1].op_type == "Pad"
+        assert converted_model.opset_import[0].version == 11
+
+    def test_pad_with_value_10_11(self) -> None:
+        pads = (0, 1, 2, 0, 2, 1)
+        nodes = [helper.make_node("Pad", ["X"], ["Y"], pads=pads, value=1.0)]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1, 2, 2))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 5, 5))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 10), 11)
+
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[1].op_type == "Pad"
+        assert converted_model.opset_import[0].version == 11
+
+    # Test that subgraphs are converted
+    def test_if_subgraph_10_11(self) -> None:
+        from_opset = 10
+        to_opset = 11
+        data_type = TensorProto.FLOAT
+        data_shape = [2]
+
+        subg1_node = [
+            onnx.helper.make_node(
+                "Clip", inputs=["sub_in"], outputs=["sub_out"], min=2.0, max=3.0
+            )
+        ]
+        subg1_input = [
+            onnx.helper.make_tensor_value_info("sub_in", data_type, data_shape)
+        ]
+        subg1_output = [
+            onnx.helper.make_tensor_value_info("sub_out", data_type, data_shape)
+        ]
+        subg1 = helper.make_graph(subg1_node, "then_g", subg1_input, subg1_output)
+
+        subg2_node = [
+            onnx.helper.make_node(
+                "Clip", inputs=["sub_in"], outputs=["sub_out"], min=2.0, max=3.0
+            )
+        ]
+        subg2_input = [
+            onnx.helper.make_tensor_value_info("sub_in", data_type, data_shape)
+        ]
+        subg2_output = [
+            onnx.helper.make_tensor_value_info("sub_out", data_type, data_shape)
+        ]
+        subg2 = helper.make_graph(subg2_node, "then_g", subg2_input, subg2_output)
+
+        node = [
+            onnx.helper.make_node(
+                "If",
+                inputs=["cond"],
+                outputs=["out"],
+                then_branch=subg1,
+                else_branch=subg2,
+            )
+        ]
+        input = [onnx.helper.make_tensor_value_info("cond", TensorProto.BOOL, [])]
+        output = [onnx.helper.make_tensor_value_info("out", data_type, data_shape)]
+        init = [helper.make_tensor("sub_in", data_type, data_shape, [4.0, 5.0])]
+        graph = helper.make_graph(node, "test_subgraphs", input, output, init)
+
+        converted = self._converted(
+            graph, helper.make_operatorsetid("", from_opset), to_opset
+        )
+
+        assert converted.graph.node[0].op_type == "If"
+        assert converted.opset_import[0].version == to_opset
+        assert converted.graph.node[0].attribute[0].g.node[2].op_type == "Clip"
+        assert len(converted.graph.node[0].attribute[0].g.node[2].attribute) == 0
+        assert converted.graph.node[0].attribute[1].g.node[2].op_type == "Clip"
+        assert len(converted.graph.node[0].attribute[1].g.node[2].attribute) == 0
+
+    # Use initializer as node inputs (instead of graph input)
+    # to test whether IR (version_converter) can handle it
+    def test_initializer_not_in_input_above_ir4(self):  # type: () -> None
+        nodes = [
+            helper.make_node(
+                "BatchNormalization", ["X", "scale", "B", "mean", "var"], ["Y"]
+            )
+        ]
+
+        scale_value = [0.55, 0.72]
+        scale_tensor = onnx.helper.make_tensor(
+            "scale", onnx.TensorProto.FLOAT, [2], scale_value
+        )
+        b_value = [0.60, 0.54]
+        b_tensor = onnx.helper.make_tensor("B", onnx.TensorProto.FLOAT, [2], b_value)
+        mean_value = [0.42, 0.65]
+        mean_tensor = onnx.helper.make_tensor(
+            "mean", onnx.TensorProto.FLOAT, [2], mean_value
+        )
+        var_value = [0.44, 0.89]
+        var_tensor = onnx.helper.make_tensor(
+            "var", onnx.TensorProto.FLOAT, [2], var_value
+        )
+
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1, 2, 2, 3))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 2, 2, 3))],
+            [scale_tensor, b_tensor, mean_tensor, var_tensor],
+        )
+
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 11), 12)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "BatchNormalization"
+        assert converted_model.opset_import[0].version == 12
+
+    def test_softmax_12_13(self) -> None:
+        axis = 0
+        nodes = [helper.make_node("Softmax", ["X"], ["Y"], axis=axis)]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1, 2, 3))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 2, 3))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 11), 13)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Shape"
+        assert converted_model.graph.node[1].op_type == "Flatten"
+        assert converted_model.graph.node[1].attribute[0].name == "axis"
+        assert converted_model.graph.node[1].attribute[0].i == axis
+        assert converted_model.graph.node[2].op_type == "Softmax"
+        assert converted_model.graph.node[2].attribute[0].name == "axis"
+        assert converted_model.graph.node[2].attribute[0].i == -1
+        assert converted_model.graph.node[3].op_type == "Reshape"
+        assert converted_model.opset_import[0].version == 13
+
+    def test_softmax_13_12(self) -> None:
+        axis = -1
+        nodes = [helper.make_node("Softmax", ["X"], ["Y"], axis=axis)]
+        graph = helper.make_graph(
+            nodes,
+            "test",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1, 2, 3))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 2, 3))],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 13), 12)
+        # Assert equality of graph and converted_model
+        assert converted_model.graph.node[0].op_type == "Softmax"
+        assert converted_model.graph.node[0].attribute[0].name == "axis"
+        assert converted_model.graph.node[0].attribute[0].i == 2
+        assert converted_model.opset_import[0].version == 12
+
+    @pytest.mark.parametrize(
+        "op_type, attrs, from_opset, to_opset, output_type, output_shape",
+        [
+            (
+                "Cast",
+                {"to": TensorProto.FLOAT},
+                9,
+                8,
+                TensorProto.FLOAT,
+                (1,),
+            ),
+            (
+                "Softmax",
+                {"axis": 1},
+                12,
+                13,
+                TensorProto.FLOAT,
+                (1,),
+            ),
+            (
+                "Upsample",
+                {"mode": "nearest"},
+                9,
+                10,
+                TensorProto.FLOAT,
+                (1, 1, 2, 2),
+            ),
+        ],
+    )
+    def test_rejects_missing_required_inputs(
+        self,
+        op_type: str,
+        attrs: dict[str, int | str],
+        from_opset: int,
+        to_opset: int,
+        output_type: int,
+        output_shape: tuple[int, ...],
+    ) -> None:
+        def test() -> None:
+            nodes = [helper.make_node(op_type, [], ["Y"], **attrs)]
+            graph = helper.make_graph(
+                nodes,
+                f"test_{op_type.lower()}_{from_opset}_{to_opset}_rejects_missing_input",
+                [],
+                [helper.make_tensor_value_info("Y", output_type, output_shape)],
+            )
+            self._converted(graph, helper.make_operatorsetid("", from_opset), to_opset)
+
+        with pytest.raises((RuntimeError, shape_inference.InferenceError)):
+            test()
+
+    def test_softmax_13_12_rejects_malformed_flatten_input(self) -> None:
+        def test() -> None:
+            nodes = [
+                helper.make_node("Flatten", [], ["F"], axis=1),
+                helper.make_node("Softmax", ["F"], ["Y"], axis=0),
+            ]
+            graph = helper.make_graph(
+                nodes,
+                "test_softmax_13_12_rejects_malformed_flatten_input",
+                [],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1,))],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 13), 12)
+
+        with pytest.raises((RuntimeError, shape_inference.InferenceError)):
+            test()
+
+    @pytest.mark.parametrize(
+        "x_shape, scale_shape, axis, block_size, output_dtype, zero_point_dtype, compatible",
+        [
+            pytest.param(
+                (16, 3), (1,), None, None, None, TensorProto.INT8, True, id="per_tensor"
+            ),
+            pytest.param(
+                (16, 3),
+                (16,),
+                1,
+                None,
+                None,
+                TensorProto.INT8,
+                True,
+                id="per_axis_none_block_shape",
+            ),
+            pytest.param(
+                (16, 3),
+                (16,),
+                1,
+                0,
+                None,
+                TensorProto.INT8,
+                True,
+                id="per_axis_zero_block_shape",
+            ),
+            pytest.param(
+                (16, 3),
+                (1,),
+                1,
+                2,
+                None,
+                TensorProto.INT8,
+                False,
+                id="per_tensor_positive_block_shape",
+            ),
+            pytest.param(
+                (16, 3),
+                (16,),
+                1,
+                2,
+                None,
+                TensorProto.INT8,
+                False,
+                id="per_axis_positive_block_shape",
+            ),
+            pytest.param(
+                (16, 3), (4, 3), 0, 4, None, TensorProto.INT8, False, id="blocked_2d"
+            ),
+            pytest.param(
+                (4, 3, 32),
+                (4, 3, 8),
+                2,
+                4,
+                None,
+                TensorProto.INT8,
+                False,
+                id="blocked_3d",
+            ),
+            pytest.param(
+                (16, 3),
+                (16,),
+                1,
+                None,
+                TensorProto.FLOAT8E4M3FN,
+                None,
+                False,
+                id="per_axis_output_dtype",
+            ),
+            pytest.param(
+                (16, 3),
+                (16,),
+                1,
+                None,
+                None,
+                TensorProto.UINT16,
+                False,
+                id="per_axis_unsupported_type",
+            ),
+        ],
+    )
+    def test_quantize_21_20(
+        self,
+        x_shape: tuple[int, ...],
+        scale_shape: tuple[int, ...],
+        axis: int,
+        block_size: int,
+        output_dtype: int | None,
+        zero_point_dtype: int | None,
+        compatible: bool,
+    ) -> None:
+        def test(
+            input_shape, scale_shape, axis, block_size, output_dtype, zero_point_dtype
+        ) -> None:
+            nodes = [
+                helper.make_node(
+                    "QuantizeLinear",
+                    ["X", "S"],
+                    ["Y"],
+                    axis=axis,
+                    block_size=block_size,
+                    output_dtype=output_dtype,
+                )
+            ]
+            inputs = [
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, input_shape),
+                helper.make_tensor_value_info("S", TensorProto.FLOAT, scale_shape),
+            ]
+            if zero_point_dtype:
+                inputs.append(
+                    helper.make_tensor_value_info("ZP", zero_point_dtype, scale_shape)
+                )
+                nodes[0].input.append("ZP")
+            output_type_ = output_dtype or zero_point_dtype
+            graph = helper.make_graph(
+                nodes,
+                "test",
+                inputs,
+                [helper.make_tensor_value_info("Y", output_type_, input_shape)],
+            )
+            _ = self._converted(graph, helper.make_operatorsetid("", 21), 20)
+
+        context_manager = (
+            contextlib.nullcontext() if compatible else pytest.raises(RuntimeError)
+        )
+        with context_manager:
+            test(x_shape, scale_shape, axis, block_size, output_dtype, zero_point_dtype)
+
+    @pytest.mark.parametrize(
+        "y_shape, scale_shape, axis, block_size, compatible",
+        [
+            pytest.param((16, 3), (1,), None, None, True, id="per_tensor"),
+            pytest.param((16, 3), (16,), 1, None, True, id="per_axis_none_block_shape"),
+            pytest.param((16, 3), (16,), 1, 0, True, id="per_axis_zero_block_shape"),
+            pytest.param(
+                (16, 3), (1,), 1, 2, False, id="per_tensor_positive_block_shape"
+            ),
+            pytest.param(
+                (16, 3), (16,), 1, 2, False, id="per_axis_positive_block_shape"
+            ),
+            pytest.param((16, 3), (4, 3), 0, 4, False, id="blocked_2d"),
+            pytest.param((4, 3, 32), (4, 3, 8), 2, 4, False, id="blocked_3d"),
+        ],
+    )
+    def test_dequantize_21_20(
+        self,
+        y_shape: tuple[int, ...],
+        scale_shape: tuple[int, ...],
+        axis: int,
+        block_size: int,
+        compatible: bool,
+    ) -> None:
+        def test(input_shape, scale_shape, axis, block_size) -> None:
+            nodes = [
+                helper.make_node(
+                    "DequantizeLinear",
+                    ["X", "S", "ZP"],
+                    ["Y"],
+                    axis=axis,
+                    block_size=block_size,
+                )
+            ]
+            graph = helper.make_graph(
+                nodes,
+                "test",
+                [
+                    helper.make_tensor_value_info("X", TensorProto.INT8, input_shape),
+                    helper.make_tensor_value_info("S", TensorProto.FLOAT, scale_shape),
+                    helper.make_tensor_value_info("ZP", TensorProto.INT8, scale_shape),
+                ],
+                [helper.make_tensor_value_info("Y", TensorProto.FLOAT, input_shape)],
+            )
+            _ = self._converted(graph, helper.make_operatorsetid("", 21), 20)
+
+        context_manager = (
+            contextlib.nullcontext() if compatible else pytest.raises(RuntimeError)
+        )
+        with context_manager:
+            test(y_shape, scale_shape, axis, block_size)
+
+    def test_external_data_version_conversion(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create a model with external data
+            shape = (2, 3)
+            random_data = np.random.rand(*shape).astype(np.float32)
+
+            initializer_tensor = onnx.helper.make_tensor(
+                name="initializer_tensor",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=list(shape),
+                vals=random_data,
+                raw=True,
+            )
+            initializer_scalar = onnx.helper.make_tensor(
+                name="initializer_scalar",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=[],
+                vals=[1.0],
+            )
+
+            add_node = onnx.helper.make_node(
+                "Add",
+                inputs=["initializer_tensor", "initializer_scalar"],
+                outputs=["sum_output"],
+            )
+
+            graph_def = onnx.helper.make_graph(
+                name="SimpleAddition",
+                nodes=[add_node],
+                inputs=[],
+                outputs=[
+                    onnx.helper.make_tensor_value_info(
+                        "sum_output", onnx.TensorProto.FLOAT, list(shape)
+                    )
+                ],
+                initializer=[initializer_tensor, initializer_scalar],
+            )
+
+            # Save model to file with external data
+            model_filename = os.path.join(temp_dir, "test_simple_add.onnx")
+            data_filename = "test_simple_add.onnx.data"  # Use relative path
+            opset_imports = [onnx.helper.make_opsetid("", 20)]
+            model_def = onnx.helper.make_model(graph_def, opset_imports=opset_imports)
+            model_def.ir_version = 10
+            onnx.save_model(
+                model_def,
+                model_filename,
+                save_as_external_data=True,
+                all_tensors_to_one_file=True,
+                location=data_filename,
+                size_threshold=0,
+                convert_attribute=False,
+            )
+
+            # Load the model and verify external data
+            converted_model = onnx.version_converter.convert_version(
+                onnx.load(model_filename, load_external_data=False), 21
+            )
+            assert len(converted_model.graph.initializer) == 2
+
+            # Verify the large tensor has external data
+            tensors = {init.name: init for init in converted_model.graph.initializer}
+            assert "initializer_tensor" in tensors
+            large_tensor = tensors["initializer_tensor"]
+            assert large_tensor.data_location == TensorProto.EXTERNAL
+            assert len(large_tensor.external_data) == 3
+
+            # Convert external_data to dictionary for order-independent checking
+            external_data_dict = {ed.key: ed.value for ed in large_tensor.external_data}
+            assert external_data_dict["location"] == data_filename
+            assert external_data_dict["offset"] == "0"
+            assert external_data_dict["length"] == "24"
+
+    # Where 16 -> 15: TypeRestriction rejects bfloat16
+    def test_where_16_15_success(self) -> None:
+        nodes = [helper.make_node("Where", ["cond", "x", "y"], ["out"])]
+        graph = helper.make_graph(
+            nodes,
+            "where",
+            [
+                helper.make_tensor_value_info("cond", TensorProto.BOOL, (2, 3)),
+                helper.make_tensor_value_info("x", TensorProto.FLOAT, (2, 3)),
+                helper.make_tensor_value_info("y", TensorProto.FLOAT, (2, 3)),
+            ],
+            [helper.make_tensor_value_info("out", TensorProto.FLOAT, (2, 3))],
+        )
+        converted = self._converted(graph, helper.make_operatorsetid("", 16), 15)
+        assert converted.opset_import[0].version == 15
+
+    def test_where_bfloat16_16_15_fails(self) -> None:
+        def test() -> None:
+            nodes = [helper.make_node("Where", ["cond", "x", "y"], ["out"])]
+            graph = helper.make_graph(
+                nodes,
+                "where_bf16",
+                [
+                    helper.make_tensor_value_info("cond", TensorProto.BOOL, (2, 3)),
+                    helper.make_tensor_value_info("x", TensorProto.BFLOAT16, (2, 3)),
+                    helper.make_tensor_value_info("y", TensorProto.BFLOAT16, (2, 3)),
+                ],
+                [helper.make_tensor_value_info("out", TensorProto.BFLOAT16, (2, 3))],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 16), 15)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    def _make_scatter_graph(
+        self,
+        op_name: str,
+        dtype: int = TensorProto.FLOAT,
+        reduction: str | None = None,
+    ) -> GraphProto:
+        """Build a graph for ScatterElements or ScatterND with standard test shapes."""
+        scatter_graph_config = {
+            "ScatterElements": ((2, 3), (2, 3), (2, 3), {"axis": 0}),
+            "ScatterND": ((4, 5), (2, 1), (2, 5), {}),
+        }
+        data_s, indices_s, updates_s, attrs = scatter_graph_config[op_name]
+        attrs = dict(attrs)
+        if reduction is not None:
+            attrs["reduction"] = reduction
+        nodes = [
+            helper.make_node(op_name, ["data", "indices", "updates"], ["out"], **attrs)
+        ]
+        return helper.make_graph(
+            nodes,
+            op_name.lower(),
+            [
+                helper.make_tensor_value_info("data", dtype, data_s),
+                helper.make_tensor_value_info("indices", TensorProto.INT64, indices_s),
+                helper.make_tensor_value_info("updates", dtype, updates_s),
+            ],
+            [helper.make_tensor_value_info("out", dtype, data_s)],
+        )
+
+    # Scatter 16 -> 15: TypeRestriction (bfloat16) + RemoveAttribute (reduction)
+    @pytest.mark.parametrize("op_name", ["ScatterElements", "ScatterND"])
+    def test_scatter_16_15_success(self, op_name: str) -> None:
+        graph = self._make_scatter_graph(op_name, TensorProto.FLOAT, "none")
+        converted = self._converted(graph, helper.make_operatorsetid("", 16), 15)
+        assert converted.opset_import[0].version == 15
+
+    @pytest.mark.parametrize("op_name", ["ScatterElements", "ScatterND"])
+    def test_scatter_16_15_bfloat16_fails(self, op_name: str) -> None:
+        def test() -> None:
+            graph = self._make_scatter_graph(op_name, TensorProto.BFLOAT16)
+            self._converted(graph, helper.make_operatorsetid("", 16), 15)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    # Opset 16 added reduction 'add' and 'mul'; 16 -> 15 only allows 'none'
+    @pytest.mark.parametrize(
+        "op_name, reduction",
+        [
+            ("ScatterElements", "add"),
+            ("ScatterElements", "mul"),
+            ("ScatterND", "add"),
+            ("ScatterND", "mul"),
+        ],
+    )
+    def test_scatter_16_15_reduction_add_mul_fails(
+        self, op_name: str, reduction: str
+    ) -> None:
+        def test() -> None:
+            graph = self._make_scatter_graph(op_name, TensorProto.FLOAT, reduction)
+            self._converted(graph, helper.make_operatorsetid("", 16), 15)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    # Scatter 18 -> 17: reject reduction "max" / "min"
+    @pytest.mark.parametrize(
+        "op_name, reduction",
+        [
+            ("ScatterElements", "max"),
+            ("ScatterElements", "min"),
+            ("ScatterND", "max"),
+            ("ScatterND", "min"),
+        ],
+    )
+    def test_scatter_18_17_reduction_max_min_fails(
+        self, op_name: str, reduction: str
+    ) -> None:
+        def test() -> None:
+            graph = self._make_scatter_graph(op_name, TensorProto.FLOAT, reduction)
+            self._converted(graph, helper.make_operatorsetid("", 18), 17)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    @pytest.mark.parametrize(
+        "op_name, reduction",
+        [
+            ("ScatterElements", None),
+            ("ScatterElements", "none"),
+            ("ScatterElements", "add"),
+            ("ScatterElements", "mul"),
+            ("ScatterND", None),
+            ("ScatterND", "none"),
+            ("ScatterND", "add"),
+            ("ScatterND", "mul"),
+        ],
+    )
+    def test_scatter_18_17_allowed_reductions_success(
+        self, op_name: str, reduction: str | None
+    ) -> None:
+        graph = self._make_scatter_graph(op_name, TensorProto.FLOAT, reduction)
+        converted = self._converted(graph, helper.make_operatorsetid("", 18), 17)
+        checker.check_model(converted)
+
+    # raw_data INT64 initializers + dims/raw byte-length mismatch guard.
+
+    def test_split_13_12_raw_data_initializer(self) -> None:
+        split_init = helper.make_tensor(
+            "split", TensorProto.INT64, [2], np.array([1, 3], dtype=np.int64), raw=True
+        )
+        graph = helper.make_graph(
+            [helper.make_node("Split", ["X", "split"], ["Y0", "Y1"], axis=0)],
+            "g",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (4, 2))],
+            [
+                helper.make_tensor_value_info("Y0", TensorProto.FLOAT, (1, 2)),
+                helper.make_tensor_value_info("Y1", TensorProto.FLOAT, (3, 2)),
+            ],
+            initializer=[split_init],
+        )
+        converted = self._converted(graph, helper.make_operatorsetid("", 13), 12)
+        attr = next(a for a in converted.graph.node[0].attribute if a.name == "split")
+        assert list(attr.ints) == [1, 3]
+
+    def test_reshape_5_4_raw_data_initializer(self) -> None:
+        shape_init = helper.make_tensor(
+            "shape", TensorProto.INT64, [2], np.array([2, 5], dtype=np.int64), raw=True
+        )
+        graph = helper.make_graph(
+            [helper.make_node("Reshape", ["X", "shape"], ["Y"])],
+            "g",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (10,))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (2, 5))],
+            initializer=[shape_init],
+        )
+        converted = self._converted(graph, helper.make_operatorsetid("", 5), 4)
+        reshape = next(n for n in converted.graph.node if n.op_type == "Reshape")
+        attr = next(a for a in reshape.attribute if a.name == "shape")
+        assert list(attr.ints) == [2, 5]
+
+    def test_axes_input_to_attr_13_12_raw_data(self) -> None:
+        axes_init = helper.make_tensor(
+            "axes", TensorProto.INT64, [1], np.array([0], dtype=np.int64), raw=True
+        )
+        graph = helper.make_graph(
+            [helper.make_node("ReduceSum", ["X", "axes"], ["Y"])],
+            "g",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (5, 5))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 5))],
+            initializer=[axes_init],
+        )
+        converted = self._converted(graph, helper.make_operatorsetid("", 13), 12)
+        attr = next(a for a in converted.graph.node[0].attribute if a.name == "axes")
+        assert list(attr.ints) == [0]
+
+    def test_dft_20_19_raw_data_axis(self) -> None:
+        axis_init = helper.make_tensor(
+            "axis", TensorProto.INT64, [], np.array([1], dtype=np.int64), raw=True
+        )
+        graph = helper.make_graph(
+            [helper.make_node("DFT", ["X", "", "axis"], ["Y"])],
+            "g",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (1, 8, 2))],
+            [helper.make_tensor_value_info("Y", TensorProto.FLOAT, (1, 8, 2))],
+            initializer=[axis_init],
+        )
+        converted = self._converted(graph, helper.make_operatorsetid("", 20), 19)
+        attr = next(a for a in converted.graph.node[0].attribute if a.name == "axis")
+        assert attr.i == 1
+
+    def test_split_13_12_raw_data_dims_mismatch_rejected(self) -> None:
+        # dims=[2] vs 8-byte raw_data fed via a Constant node; old code OOB-read.
+        split_value = TensorProto(
+            data_type=TensorProto.INT64,
+            dims=[2],
+            raw_data=struct.pack("<q", 1),
+        )
+        graph = helper.make_graph(
+            [
+                helper.make_node("Constant", [], ["split"], value=split_value),
+                helper.make_node("Split", ["X", "split"], ["Y0", "Y1"], axis=0),
+            ],
+            "g",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (4, 2))],
+            [
+                helper.make_tensor_value_info("Y0", TensorProto.FLOAT, (1, 2)),
+                helper.make_tensor_value_info("Y1", TensorProto.FLOAT, (3, 2)),
+            ],
+        )
+        # Bypass checker to exercise the converter guard directly.
+        model = helper.make_model(
+            graph, opset_imports=[helper.make_operatorsetid("", 13)]
+        )
+        with pytest.raises(RuntimeError):
+            onnx.version_converter.convert_version(model, 12)
+
+    def test_split_13_12_raw_data_constant_node(self) -> None:
+        split_value = helper.make_tensor(
+            "", TensorProto.INT64, [2], np.array([1, 3], dtype=np.int64), raw=True
+        )
+        graph = helper.make_graph(
+            [
+                helper.make_node("Constant", [], ["split"], value=split_value),
+                helper.make_node("Split", ["X", "split"], ["Y0", "Y1"], axis=0),
+            ],
+            "g",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (4, 2))],
+            [
+                helper.make_tensor_value_info("Y0", TensorProto.FLOAT, (1, 2)),
+                helper.make_tensor_value_info("Y1", TensorProto.FLOAT, (3, 2)),
+            ],
+        )
+        converted = self._converted(graph, helper.make_operatorsetid("", 13), 12)
+        split = next(n for n in converted.graph.node if n.op_type == "Split")
+        attr = next(a for a in split.attribute if a.name == "split")
+        assert list(attr.ints) == [1, 3]
+
+    # Range 26 -> 27: CompatibleAdapter (forward upgrade, no attribute changes)
+    def test_range_26_27_float_success(self) -> None:
+        nodes = [helper.make_node("Range", ["start", "limit", "delta"], ["output"])]
+        graph = helper.make_graph(
+            nodes,
+            "range_26_27",
+            [
+                helper.make_tensor_value_info("start", TensorProto.FLOAT, []),
+                helper.make_tensor_value_info("limit", TensorProto.FLOAT, []),
+                helper.make_tensor_value_info("delta", TensorProto.FLOAT, []),
+            ],
+            [helper.make_tensor_value_info("output", TensorProto.FLOAT, None)],
+        )
+        converted = self._converted(graph, helper.make_operatorsetid("", 26), 27)
+        assert converted.opset_import[0].version == 27
+
+    # Range 27 -> 26: stash_type attribute must be removed on downgrade
+    def test_range_27_26_stash_type_removed(self) -> None:
+        nodes = [
+            helper.make_node(
+                "Range", ["start", "limit", "delta"], ["output"], stash_type=1
+            )
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "range_27_26",
+            [
+                helper.make_tensor_value_info("start", TensorProto.FLOAT, []),
+                helper.make_tensor_value_info("limit", TensorProto.FLOAT, []),
+                helper.make_tensor_value_info("delta", TensorProto.FLOAT, []),
+            ],
+            [helper.make_tensor_value_info("output", TensorProto.FLOAT, None)],
+        )
+        converted = self._converted(graph, helper.make_operatorsetid("", 27), 26)
+        assert converted.opset_import[0].version == 26
+        range_node = next(n for n in converted.graph.node if n.op_type == "Range")
+        assert not any(a.name == "stash_type" for a in range_node.attribute)
+
+    # Range 27 -> 26: float16 and bfloat16 inputs must be rejected
+    @pytest.mark.parametrize(
+        "dtype",
+        [TensorProto.FLOAT16, TensorProto.BFLOAT16],
+    )
+    def test_range_27_26_low_precision_fails(self, dtype: int) -> None:
+        def test() -> None:
+            nodes = [helper.make_node("Range", ["start", "limit", "delta"], ["output"])]
+            graph = helper.make_graph(
+                nodes,
+                "range_27_26_fp16",
+                [
+                    helper.make_tensor_value_info("start", dtype, []),
+                    helper.make_tensor_value_info("limit", dtype, []),
+                    helper.make_tensor_value_info("delta", dtype, []),
+                ],
+                [helper.make_tensor_value_info("output", dtype, None)],
+            )
+            self._converted(graph, helper.make_operatorsetid("", 27), 26)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    def test_scan_8_9_rejects_no_inputs(self) -> None:
+        # Scan in opset 8 must have at least 1 input; zero inputs is UB (inputs[0] OOB).
+        def test() -> None:
+            nodes = [
+                helper.make_node(
+                    "Scan",
+                    inputs=[],
+                    outputs=["y"],
+                    body=helper.make_graph([], "body", [], []),
+                )
+            ]
+            graph = helper.make_graph(
+                nodes,
+                "test_scan_no_inputs",
+                [],
+                [helper.make_tensor_value_info("y", TensorProto.FLOAT, None)],
+            )
+            model = helper.make_model(
+                graph, opset_imports=[helper.make_operatorsetid("", 8)]
+            )
+            onnx.version_converter.convert_version(model, 9)
+
+        with pytest.raises(RuntimeError):
+            test()
+
+    def test_scan_9_8_with_valid_node(self) -> None:
+        data_type = TensorProto.FLOAT
+        node1 = helper.make_node("Add", inputs=["sum_in", "next"], outputs=["sum_out"])
+        node2 = helper.make_node("Identity", inputs=["sum_out"], outputs=["scan_out"])
+        body = helper.make_graph(
+            [node1, node2],
+            "scan_body",
+            [
+                helper.make_tensor_value_info("sum_in", data_type, [2]),
+                helper.make_tensor_value_info("next", data_type, [2]),
+            ],
+            [
+                helper.make_tensor_value_info("sum_out", data_type, [2]),
+                helper.make_tensor_value_info("scan_out", data_type, [2]),
+            ],
+        )
+        nodes = [
+            helper.make_node(
+                "Scan",
+                inputs=["initial", "x"],
+                outputs=["y", "z"],
+                body=body,
+                num_scan_inputs=1,
+            )
+        ]
+        graph = helper.make_graph(
+            nodes,
+            "test_scan_9_8",
+            [
+                helper.make_tensor_value_info("initial", data_type, [2]),
+                helper.make_tensor_value_info("x", data_type, [3, 2]),
+            ],
+            [
+                helper.make_tensor_value_info("y", data_type, [2]),
+                helper.make_tensor_value_info("z", data_type, [3, 2]),
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 9), 8)
+        assert converted_model.graph.node[0].op_type == "Scan"
+        assert converted_model.opset_import[0].version == 8
+
+    def test_convert_version_ai_onnx_domain_spelling_preserves_custom_domain(
+        self,
+    ) -> None:
+        # convert_graph's default-domain lookup must match "ai.onnx" (not just ""),
+        # and must only increment that entry -- a custom-domain opset_import must
+        # be left untouched.
+        node = helper.make_node("Add", inputs=["X", "Y"], outputs=["Z"])
+        graph = helper.make_graph(
+            [node],
+            "test_default_domain_ai_onnx_spelling",
+            [
+                helper.make_tensor_value_info("X", TensorProto.FLOAT, [1]),
+                helper.make_tensor_value_info("Y", TensorProto.FLOAT, [1]),
+            ],
+            [helper.make_tensor_value_info("Z", TensorProto.FLOAT, [1])],
+        )
+        model = helper.make_model(
+            graph,
+            opset_imports=[
+                helper.make_operatorsetid("ai.onnx", 9),
+                helper.make_operatorsetid("custom.domain", 1),
+            ],
+        )
+        converted_model = onnx.version_converter.convert_version(model, 8)
+        checker.check_model(converted_model)
+
+        opset_by_domain = {
+            opset.domain: opset.version for opset in converted_model.opset_import
+        }
+        assert opset_by_domain["ai.onnx"] == 8
+        assert opset_by_domain["custom.domain"] == 1
+
+    def _celu_converted(self, dtype: int, src: int, dst: int) -> ModelProto:
+        node = helper.make_node("Celu", ["X"], ["Y"], alpha=2.0)
+        graph = helper.make_graph(
+            [node],
+            "celu",
+            [helper.make_tensor_value_info("X", dtype, [3, 4])],
+            [helper.make_tensor_value_info("Y", dtype, [3, 4])],
+        )
+        return self._converted(graph, helper.make_operatorsetid("", src), dst)
+
+    def test_celu_float_27_28_and_28_27(self) -> None:
+        assert (
+            self._celu_converted(TensorProto.FLOAT, 27, 28).opset_import[0].version
+            == 28
+        )
+        assert (
+            self._celu_converted(TensorProto.FLOAT, 28, 27).opset_import[0].version
+            == 27
+        )
+
+    # Celu 28 -> 27: types added in v28 must be rejected
+    @pytest.mark.parametrize(
+        "dtype",
+        [TensorProto.FLOAT16, TensorProto.BFLOAT16, TensorProto.DOUBLE],
+    )
+    def test_celu_28_27_unsupported_type_fails(self, dtype: int) -> None:
+        with pytest.raises(RuntimeError):
+            self._celu_converted(dtype, 28, 27)
diff --git a/onnx/test/version_utils.py b/onnx/test/version_utils.py
new file mode 100644
index 0000000..1ed6145
--- /dev/null
+++ b/onnx/test/version_utils.py
@@ -0,0 +1,20 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from packaging.version import parse as version
+
+
+def numpy_older_than(ver: str) -> bool:
+    """Returns True if the numpy version is older than the given version."""
+    import numpy  # noqa: PLC0415
+
+    return version(numpy.__version__) < version(ver)
+
+
+def pillow_older_than(ver: str) -> bool:
+    """Returns True if the pillow version is older than the given version."""
+    import PIL  # noqa: PLC0415
+
+    return version(PIL.__version__) < version(ver)
diff --git a/onnx/tools/__init__.py b/onnx/tools/__init__.py
new file mode 100644
index 0000000..c974daf
--- /dev/null
+++ b/onnx/tools/__init__.py
@@ -0,0 +1,3 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
diff --git a/onnx/tools/replace_constants.py b/onnx/tools/replace_constants.py
new file mode 100644
index 0000000..cd8d7b4
--- /dev/null
+++ b/onnx/tools/replace_constants.py
@@ -0,0 +1,421 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx import (
+    AttributeProto,
+    FunctionProto,
+    GraphProto,
+    ModelProto,
+    NodeProto,
+    SparseTensorProto,
+    TensorProto,
+)
+from onnx.helper import (
+    make_attribute,
+    make_function,
+    make_graph,
+    make_model,
+    make_node,
+    make_tensor,
+    make_tensor_value_info,
+    set_model_props,
+    tensor_dtype_to_np_dtype,
+)
+from onnx.numpy_helper import from_array
+
+
+def _replace_constant(
+    node: NodeProto, threshold: int, value_constant_of_shape: float
+) -> list[NodeProto]:
+    """Replaces a Constant node with a large tensor (with more than threshold elements) by a sequence of nodes that produces a dummy constant of same shape as original tensor."""
+    if node.op_type != "Constant":
+        raise TypeError(f"Node type must be 'Constant' not {node.op_type!r}.")
+    for att in node.attribute:
+        if att.name == "sparse_value":
+            raise NotImplementedError(
+                f"This feature is not yet implemented for a sparse constant "
+                f"(node name={node.name!r})."
+            )
+        if att.name == "value":
+            value = att.t
+            new_name = f"{value.name}__SHAPE"
+            dims = value.dims
+            size = np.prod(dims, dtype=np.int64)
+            if size <= threshold:
+                return [node]
+            init = from_array(np.array(list(dims), dtype=np.int64), name=new_name)
+            dtype = tensor_dtype_to_np_dtype(value.data_type)
+            node_shape = make_node(
+                "Constant",
+                [],
+                [new_name],
+                value=init,
+            )
+            new_node = make_node(
+                "ConstantOfShape",
+                [new_name],
+                node.output,
+                value=from_array(np.array([value_constant_of_shape], dtype=dtype)),
+            )
+            return [node_shape, new_node]
+        raise NotImplementedError(
+            f"Replacement of constant with attribute {att.name!r}"
+        )
+    return [node]
+
+
+def _replace_constant_of_shape_with_range(
+    onx: GraphProto | FunctionProto,
+) -> GraphProto | FunctionProto:
+    """Replaces all *ConstantOfShape* by node *Range* to avoid constant tensors.
+
+    The function is not recursive. The recursivity is done by
+    *replace_initializer_by_constant_of_shape*.
+    """
+    if isinstance(onx, (GraphProto, FunctionProto)):
+        nodes = list(onx.node)
+    else:
+        raise TypeError(f"Not implemented for type {type(onx)}.")
+
+    existing_names = set()
+    for node in nodes:
+        existing_names |= set(node.input)
+        existing_names |= set(node.output)
+
+    def _find_name(prefix):
+        if prefix not in existing_names:
+            existing_names.add(prefix)
+            return prefix
+        i = 2
+        while True:
+            name = f"{prefix}_{i}"
+            if name not in existing_names:
+                existing_names.add(name)
+                return name
+            i += 1
+
+    cst0 = make_node("Constant", [], [_find_name("zero")], value_int=0)
+    cst1 = make_node("Constant", [], [_find_name("one")], value_int=1)
+    update = {}
+    for inode, node in enumerate(nodes):
+        if node.op_type != "ConstantOfShape":
+            continue
+        shape = node.input[0]
+
+        n = make_node("ReduceProd", [shape], [_find_name(f"{shape}_N")])
+        a = make_node(
+            "Range",
+            [cst0.output[0], n.output[0], cst1.output[0]],
+            [_find_name(f"{shape}_RANGE")],
+        )
+        if len(node.attribute) == 1:
+            to = node.attribute[0].t.data_type
+        else:
+            to = TensorProto.FLOAT
+        ac = make_node("Cast", [a.output[0]], [_find_name(f"{shape}_RANGEf")], to=to)
+        cl = make_node("Cast", [n.output[0]], [_find_name(f"{shape}_Nf")], to=to)
+        d = make_node(
+            "Div", [ac.output[0], cl.output[0]], [_find_name(f"{shape}_FLAT")]
+        )
+        resh = make_node("Reshape", [d.output[0], shape], node.output)
+        update[inode] = [n, a, ac, cl, d, resh]
+
+    for inode, up in sorted(update.items(), reverse=True):
+        nodes[inode : inode + 1] = up
+    nodes.insert(0, cst0)
+    nodes.insert(1, cst1)
+
+    if isinstance(onx, GraphProto):
+        return make_graph(
+            nodes,
+            onx.name,
+            onx.input,
+            onx.output,
+            initializer=onx.initializer,
+            sparse_initializer=onx.sparse_initializer,
+        )
+    if isinstance(onx, FunctionProto):
+        return make_function(
+            onx.domain,
+            onx.name,
+            onx.input,
+            onx.output,
+            nodes,
+            opset_imports=onx.opset_import,
+        )
+    raise TypeError(f"Not implemented for type {type(onx)}.")
+
+
+def _replace_constant_of_shape_value(
+    onx: GraphProto | FunctionProto, value_constant_of_shape: float
+) -> GraphProto | FunctionProto:
+    """Replaces all fill value of all nodes *ConstantOfShape*."""
+    if isinstance(onx, (GraphProto, FunctionProto)):
+        nodes = list(onx.node)
+    else:
+        raise TypeError(f"Not implemented for type {type(onx)}.")
+
+    update = {}
+    for inode, node in enumerate(nodes):
+        if node.op_type != "ConstantOfShape":
+            continue
+        tensor = node.attribute[0].t
+        new_tensor = make_tensor(
+            tensor.name, tensor.data_type, [1], [value_constant_of_shape]
+        )
+        new_node = make_node("ConstantOfShape", node.input, node.output)
+        att = make_attribute(node.attribute[0].name, value=new_tensor)
+        new_node.attribute.append(att)
+        update[inode] = new_node
+
+    for inode, up in update.items():
+        nodes[inode] = up
+
+    if isinstance(onx, GraphProto):
+        return make_graph(
+            nodes,
+            onx.name,
+            onx.input,
+            onx.output,
+            initializer=onx.initializer,
+            sparse_initializer=onx.sparse_initializer,
+        )
+    if isinstance(onx, FunctionProto):
+        return make_function(
+            onx.domain,
+            onx.name,
+            onx.input,
+            onx.output,
+            nodes,
+            opset_imports=onx.opset_import,
+        )
+    raise TypeError(f"Not implemented for type {type(onx)}.")
+
+
+def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
+    onx: FunctionProto | GraphProto | ModelProto,
+    threshold: int = 128,
+    ir_version: int | None = None,
+    use_range: bool = False,
+    value_constant_of_shape: float = 0.5,
+):
+    """Replace initializers or constant node by nodes *ConstantOfShape* to reduce the size.
+
+    This reduce the cost to write a unit test about a specific graph structure.
+
+    Args:
+        onx: ModelProto
+        threshold: every initializer under this threshold is not
+            impacted
+        ir_version: initializer must be specified as input for
+            `ir_version <= 3`, this must be specified if onx is
+            :class:`FunctionProto` or :class:`GraphProto`
+        use_range: if uses operator *Range* instead of *ConstantOfShape*
+            to avoid constant tensors
+        value_constant_of_shape: value to use as a value for all nodes
+            *ConstantOfShape*, a high value may produce nan or inf
+            predictions
+
+    Returns:
+        onx, modified ModelProto
+
+    The function is designed so that the function can be reapplied on a modified model
+    and either replace *ConstantOfShape* with *Range* operators, either replace the fill value
+    for every *ConstantOfShape*.
+    """
+    if isinstance(onx, FunctionProto):
+        modified = False
+        new_nodes: list[NodeProto] = []
+        for node in onx.node:
+            if node.op_type == "Constant":
+                cst_nodes = _replace_constant(node, threshold, value_constant_of_shape)
+                if len(cst_nodes) == 2:  # noqa: PLR2004
+                    modified = True
+                new_nodes.extend(cst_nodes)
+                continue
+            new_nodes.append(node)
+        if modified:
+            new_onx = make_function(
+                onx.domain,
+                onx.name,
+                onx.input,
+                onx.output,
+                new_nodes,
+                opset_imports=onx.opset_import,
+            )
+            if use_range:
+                return _replace_constant_of_shape_with_range(new_onx)
+            if value_constant_of_shape != 1:
+                return _replace_constant_of_shape_value(
+                    new_onx, value_constant_of_shape
+                )
+            return new_onx
+        if use_range:
+            return _replace_constant_of_shape_with_range(onx)
+        if value_constant_of_shape != 1:
+            return _replace_constant_of_shape_value(onx, value_constant_of_shape)
+        return onx
+
+    if isinstance(onx, ModelProto):
+        new_graph = replace_initializer_by_constant_of_shape(
+            onx.graph,
+            ir_version=ir_version or onx.ir_version,
+            threshold=threshold,
+            use_range=use_range,
+            value_constant_of_shape=value_constant_of_shape,
+        )
+        new_functions = [
+            replace_initializer_by_constant_of_shape(
+                f,
+                threshold=threshold,
+                ir_version=ir_version or onx.ir_version,
+                use_range=use_range,
+                value_constant_of_shape=value_constant_of_shape,
+            )
+            for f in onx.functions
+        ]
+        model = make_model(
+            new_graph,
+            functions=new_functions,
+            producer_name=onx.producer_name,
+            producer_version=onx.producer_version,
+            ir_version=ir_version or onx.ir_version,
+            doc_string=onx.doc_string,
+            domain=onx.domain,
+            model_version=onx.model_version,
+        )
+        if len(onx.metadata_props) > 0:  # pragma: no cover
+            values = {p.key: p.value for p in onx.metadata_props}
+            set_model_props(model, values)
+
+        del model.opset_import[:]
+        for oimp in onx.opset_import:
+            op_set = model.opset_import.add()
+            if oimp.domain == "" and oimp.version < 11 and use_range:  # noqa: PLR2004
+                raise RuntimeError(
+                    f"Range was introduced in opset 11 but opset is {oimp.version}."
+                )
+            if oimp.domain == "" and oimp.version < 9:  # noqa: PLR2004
+                raise RuntimeError(
+                    f"ConstantOfShape was introduced in "
+                    f"opset 9 but opset is {oimp.version}."
+                )
+            op_set.domain = oimp.domain
+            op_set.version = oimp.version
+        return model
+
+    if not isinstance(onx, GraphProto):
+        raise TypeError(f"onx should be a GraphProto at this stage not {type(onx)}.")
+
+    n_modifications = 0
+    new_nodes = []
+    removed = set()
+    additional_inputs = []
+
+    new_inits: list[TensorProto] = []
+    for init in onx.initializer:
+        dims = tuple(init.dims)
+        size = np.prod(dims, dtype=np.int64)
+        if size <= threshold:
+            new_inits.append(init)
+            continue
+        n_modifications += 1
+        new_name = f"{init.name}__SHAPE"
+        new_inits.append(
+            from_array(np.array(list(dims), dtype=np.int64), name=new_name)
+        )
+        dtype = tensor_dtype_to_np_dtype(init.data_type)
+        node = make_node(
+            "ConstantOfShape",
+            [new_name],
+            [init.name],
+            value=from_array(np.array([0.5], dtype=dtype)),
+        )
+        new_nodes.append(node)
+        removed.add(init.name)
+        if ir_version is not None and ir_version <= 3:  # noqa: PLR2004
+            additional_inputs.append(
+                make_tensor_value_info(new_name, TensorProto.INT64, [len(dims)])
+            )
+
+    new_sparse_inits: list[SparseTensorProto] = []
+    for sp_init in onx.sparse_initializer:
+        dims = tuple(sp_init.dims)
+        size = np.prod(dims, dtype=np.int64)
+        if size <= threshold:
+            new_sparse_inits.append(sp_init)
+            continue
+        raise NotImplementedError(
+            f"This feature is not yet implemented for a sparse initializer "
+            f"(indices.name={sp_init.indices.name!r}, "
+            f"values.name={sp_init.values.name!r})."
+        )
+
+    for node in onx.node:
+        if node.op_type == "Constant":
+            shape_nodes = _replace_constant(node, threshold, value_constant_of_shape)
+            if len(shape_nodes) == 2:  # noqa: PLR2004
+                n_modifications += 1
+            new_nodes.extend(shape_nodes)
+            continue
+        modified = False
+        atts = []
+        for att in node.attribute:
+            if att.type == AttributeProto.GRAPH and att.HasField("g"):
+                g = replace_initializer_by_constant_of_shape(
+                    att.g,
+                    threshold=threshold,
+                    ir_version=ir_version,
+                    use_range=use_range,
+                    value_constant_of_shape=value_constant_of_shape,
+                )
+                if id(g) != id(att.g):
+                    modified = True
+                    att = make_attribute(att.name, g)  # noqa: PLW2901
+            elif att.type == AttributeProto.GRAPHS:
+                new_graphs = []
+                for sub_g in att.graphs:
+                    new_g = replace_initializer_by_constant_of_shape(
+                        sub_g,
+                        threshold=threshold,
+                        ir_version=ir_version,
+                        use_range=use_range,
+                        value_constant_of_shape=value_constant_of_shape,
+                    )
+                    if id(new_g) != id(sub_g):
+                        modified = True
+                    new_graphs.append(new_g)
+                if modified:
+                    att = make_attribute(att.name, new_graphs)  # noqa: PLW2901
+            atts.append(att)
+        if modified:
+            new_node = make_node(node.op_type, node.input, node.output)
+            new_node.attribute.extend(atts)
+            new_nodes.append(new_node)
+            n_modifications += 1
+        else:
+            new_nodes.append(node)
+
+    if n_modifications > 0:
+        graph = make_graph(
+            new_nodes,
+            onx.name,
+            [i for i in onx.input if i.name not in removed] + additional_inputs,
+            onx.output,
+            initializer=new_inits,
+            sparse_initializer=new_sparse_inits,
+        )
+        if use_range:
+            return _replace_constant_of_shape_with_range(graph)
+        if value_constant_of_shape != 1:
+            return _replace_constant_of_shape_value(graph, value_constant_of_shape)
+        return graph
+    if use_range:
+        return _replace_constant_of_shape_with_range(onx)
+    if value_constant_of_shape != 1:
+        return _replace_constant_of_shape_value(onx, value_constant_of_shape)
+    return onx
diff --git a/onnx/tools/update_model_dims.py b/onnx/tools/update_model_dims.py
new file mode 100644
index 0000000..b8c7c15
--- /dev/null
+++ b/onnx/tools/update_model_dims.py
@@ -0,0 +1,98 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import Any
+
+import onnx.checker
+from onnx import ModelProto, ValueInfoProto
+
+
+def update_inputs_outputs_dims(
+    model: ModelProto,
+    input_dims: dict[str, list[Any]],
+    output_dims: dict[str, list[Any]],
+) -> ModelProto:
+    """This function updates the dimension sizes of the model's inputs and outputs to the values
+    provided in input_dims and output_dims. if the dim value provided is negative, a unique dim_param
+    will be set for that dimension.
+
+    Example. if we have the following shape for inputs and outputs:
+
+    * shape(input_1) = ('b', 3, 'w', 'h')
+    * shape(input_2) = ('b', 4)
+    * shape(output)  = ('b', 'd', 5)
+
+    The parameters can be provided as:
+
+    ::
+
+        input_dims = {
+            "input_1": ['b', 3, 'w', 'h'],
+            "input_2": ['b', 4],
+        }
+        output_dims = {
+            "output": ['b', -1, 5]
+        }
+
+    Putting it together:
+
+    ::
+
+        model = onnx.load('model.onnx')
+        updated_model = update_inputs_outputs_dims(model, input_dims, output_dims)
+        onnx.save(updated_model, 'model.onnx')
+    """
+    dim_param_set: set[str] = set()
+
+    def init_dim_param_set(
+        dim_param_set: set[str], value_infos: list[ValueInfoProto]
+    ) -> None:
+        for info in value_infos:
+            shape = info.type.tensor_type.shape
+            for dim in shape.dim:
+                if dim.HasField("dim_param"):
+                    dim_param_set.add(dim.dim_param)
+
+    init_dim_param_set(dim_param_set, model.graph.input)  # type: ignore[arg-type]
+    init_dim_param_set(dim_param_set, model.graph.output)  # type: ignore[arg-type]
+    init_dim_param_set(dim_param_set, model.graph.value_info)  # type: ignore[arg-type]
+
+    def update_dim(tensor: ValueInfoProto, dim: Any, j: int, name: str) -> None:
+        dim_proto = tensor.type.tensor_type.shape.dim[j]
+        if isinstance(dim, int):
+            if dim >= 0:
+                if dim_proto.HasField("dim_value") and dim_proto.dim_value != dim:
+                    raise ValueError(
+                        f"Unable to set dimension value to {dim} for axis {j} of {name}. Contradicts existing dimension value {dim_proto.dim_value}."
+                    )
+                dim_proto.dim_value = dim
+            else:
+                generated_dim_param = name + "_" + str(j)
+                if generated_dim_param in dim_param_set:
+                    raise ValueError(
+                        f"Unable to generate unique dim_param for axis {j} of {name}. Please manually provide a dim_param value."
+                    )
+                dim_proto.dim_param = generated_dim_param
+        elif isinstance(dim, str):
+            dim_proto.dim_param = dim
+        else:
+            raise TypeError(
+                f"Only int or str is accepted as dimension value, incorrect type: {type(dim)}"
+            )
+
+    for input_ in model.graph.input:
+        input_name = input_.name
+        input_dim_arr = input_dims[input_name]
+        for j, dim in enumerate(input_dim_arr):
+            update_dim(input_, dim, j, input_name)
+
+    for output in model.graph.output:
+        output_name = output.name
+        output_dim_arr = output_dims[output_name]
+        for j, dim in enumerate(output_dim_arr):
+            update_dim(output, dim, j, output_name)
+
+    onnx.checker.check_model(model)
+    return model
diff --git a/onnx/utils.py b/onnx/utils.py
new file mode 100644
index 0000000..397d823
--- /dev/null
+++ b/onnx/utils.py
@@ -0,0 +1,324 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import os
+import tarfile
+from collections import deque
+from typing import TYPE_CHECKING
+
+import onnx.checker
+import onnx.helper
+import onnx.shape_inference
+
+if TYPE_CHECKING:
+    from onnx.onnx_pb import (
+        FunctionProto,
+        ModelProto,
+        NodeProto,
+        TensorProto,
+        ValueInfoProto,
+    )
+
+
+class Extractor:
+    def __init__(self, model: ModelProto) -> None:
+        self.model = model
+        self.graph = self.model.graph
+        self.initializers: dict[str, TensorProto] = self._build_name2obj_dict(
+            self.graph.initializer
+        )
+        self.value_infos: dict[str, ValueInfoProto] = self._build_name2obj_dict(
+            self.graph.value_info
+        )
+        # Add input and output values (not included in the value_info for intermediate values)
+        self.value_infos.update(self._build_name2obj_dict(self.graph.input))
+        self.value_infos.update(self._build_name2obj_dict(self.graph.output))
+        self.outmap: dict[str, int] = self._build_output_dict(self.graph)
+
+    @staticmethod
+    def _build_name2obj_dict(objs) -> dict:
+        return {obj.name: obj for obj in objs}
+
+    @staticmethod
+    def _build_output_dict(graph) -> dict[str, int]:
+        output_to_index: dict[str, int] = {}
+        for index, node in enumerate(graph.node):
+            for output_name in node.output:
+                if output_name == "":
+                    continue
+                assert output_name not in output_to_index  # output_name is unique
+                output_to_index[output_name] = index
+        return output_to_index
+
+    def _collect_new_io(self, io_names_to_extract: list[str]) -> list[ValueInfoProto]:
+        # Validate that all names exist in self.value_infos
+        missing_names = [
+            name for name in io_names_to_extract if name not in self.value_infos
+        ]
+        if missing_names:
+            raise ValueError(
+                f"The following names were not found in value_infos: {', '.join(missing_names)}"
+            )
+        return [self.value_infos[name] for name in io_names_to_extract]
+
+    def _dfs_search_reachable_nodes(
+        self,
+        node_output_name: str,
+        graph_input_names: set[str],
+        reachable: set[int],
+    ) -> None:
+        """Helper function to find nodes which are connected to an output
+
+        Arguments:
+            node_output_name (str): The name of the output
+            graph_input_names (set of string): The names of all inputs of the graph
+            reachable (set of int): The set of indexes to reachable nodes in `nodes`
+        """
+        stack = [node_output_name]
+        while stack:
+            current_output_name = stack.pop()
+            # finish search at inputs
+            if current_output_name in graph_input_names:
+                continue
+            # find nodes connected to this output
+            if current_output_name in self.outmap:
+                index = self.outmap[current_output_name]
+                if index not in reachable:
+                    # add nodes connected to this output to sets
+                    reachable.add(index)
+                    stack += [
+                        input_name
+                        for input_name in self.graph.node[index].input
+                        if input_name != ""
+                    ]
+
+    def _collect_reachable_nodes(
+        self,
+        input_names: list[str],
+        output_names: list[str],
+    ) -> list[NodeProto]:
+        _input_names = set(input_names)
+        reachable: set[int] = set()
+        for name in output_names:
+            self._dfs_search_reachable_nodes(name, _input_names, reachable)
+        # needs to be topologically sorted
+        return [self.graph.node[index] for index in sorted(reachable)]
+
+    def _collect_referred_local_functions(
+        self,
+        nodes: list[NodeProto],
+    ) -> list[FunctionProto]:
+        # a node in a model graph may refer a function.
+        # a function contains nodes, some of which may in turn refer a function.
+        # we need to find functions referred by graph nodes and
+        # by nodes used to define functions.
+        function_map: dict[tuple[str, str], FunctionProto] = {}
+        for function in self.model.functions:
+            function_map[(function.name, function.domain)] = function
+        referred_local_functions: list[FunctionProto] = []
+        queue = deque(nodes)
+        while queue:
+            node = queue.popleft()
+            # check if the node is a function op
+            if (node.op_type, node.domain) in function_map:
+                function = function_map.pop((node.op_type, node.domain))
+                referred_local_functions.append(function)
+                queue.extend(function.node)
+        # needs to be topologically sorted
+        return referred_local_functions
+
+    def _collect_reachable_tensors(
+        self,
+        nodes: list[NodeProto],
+    ) -> tuple[list[TensorProto], list[ValueInfoProto]]:
+        all_tensors_names: set[str] = set()
+        for node in nodes:
+            all_tensors_names.update(node.input)
+            all_tensors_names.update(node.output)
+        initializer = [
+            self.initializers[t] for t in self.initializers if t in all_tensors_names
+        ]
+        value_info = [
+            self.value_infos[t] for t in self.value_infos if t in all_tensors_names
+        ]
+        len_sparse_initializer = len(self.graph.sparse_initializer)
+        if len_sparse_initializer != 0:
+            raise ValueError(
+                f"len_sparse_initializer is {len_sparse_initializer}, it must be 0."
+            )
+        len_quantization_annotation = len(self.graph.quantization_annotation)
+        if len_quantization_annotation != 0:
+            raise ValueError(
+                f"len_quantization_annotation is {len_quantization_annotation}, it must be 0."
+            )
+        return initializer, value_info
+
+    def _make_model(
+        self,
+        nodes: list[NodeProto],
+        inputs: list[ValueInfoProto],
+        outputs: list[ValueInfoProto],
+        initializer: list[TensorProto],
+        value_info: list[ValueInfoProto],
+        local_functions: list[FunctionProto],
+    ) -> ModelProto:
+        name = "Extracted from {" + self.graph.name + "}"
+        graph = onnx.helper.make_graph(
+            nodes, name, inputs, outputs, initializer=initializer, value_info=value_info
+        )
+        meta = {
+            "ir_version": self.model.ir_version,
+            "opset_imports": self.model.opset_import,
+            "producer_name": "onnx.utils.extract_model",
+            "functions": local_functions,
+        }
+        return onnx.helper.make_model(graph, **meta)
+
+    def extract_model(
+        self,
+        input_names: list[str],
+        output_names: list[str],
+    ) -> ModelProto:
+        inputs = self._collect_new_io(input_names)
+        outputs = self._collect_new_io(output_names)
+        nodes = self._collect_reachable_nodes(input_names, output_names)
+        initializer, value_info = self._collect_reachable_tensors(nodes)
+        local_functions = self._collect_referred_local_functions(nodes)
+        return self._make_model(
+            nodes, inputs, outputs, initializer, value_info, local_functions
+        )
+
+
+def extract_model(
+    input_path: str | os.PathLike,
+    output_path: str | os.PathLike,
+    input_names: list[str],
+    output_names: list[str],
+    check_model: bool = True,
+    infer_shapes: bool = True,
+) -> None:
+    """Extracts sub-model from an ONNX model.
+
+    The sub-model is defined by the names of the input and output tensors *exactly*.
+
+    Note: For control-flow operators, e.g. If and Loop, the _boundary of sub-model_,
+    which is defined by the input and output tensors, should not _cut through_ the
+    subgraph that is connected to the _main graph_ as attributes of these operators.
+
+    Note: When the extracted model size is larger than 2GB, the extra data will be saved in "output_path.data".
+
+    Arguments:
+        input_path (str | os.PathLike): The path to original ONNX model.
+        output_path (str | os.PathLike): The path to save the extracted ONNX model.
+        input_names (list of string): The names of the input tensors that to be extracted.
+        output_names (list of string): The names of the output tensors that to be extracted.
+        check_model (bool): Whether to run model checker on the original model and the extracted model.
+        infer_shapes (bool): Whether to infer the shapes of the original model.
+    """
+    if not os.path.exists(input_path):
+        raise ValueError(f"Invalid input model path: {input_path}")
+    if not output_path:
+        raise ValueError("Output model path shall not be empty!")
+    if not input_names:
+        raise ValueError("Input tensor names shall not be empty!")
+    if not output_names:
+        raise ValueError("Output tensor names shall not be empty!")
+
+    if len(input_names) != len(set(input_names)):
+        raise ValueError("Duplicate names found in the input tensor names.")
+    if len(output_names) != len(set(output_names)):
+        raise ValueError("Duplicate names found in the output tensor names.")
+
+    if check_model:
+        onnx.checker.check_model(input_path)
+
+    if infer_shapes and os.path.getsize(input_path) > onnx.checker.MAXIMUM_PROTOBUF:
+        onnx.shape_inference.infer_shapes_path(input_path, output_path)
+        model = onnx.load(output_path)
+    elif infer_shapes:
+        model = onnx.load(input_path, load_external_data=False)
+        model = onnx.shape_inference.infer_shapes(model)
+        base_dir = os.path.dirname(input_path)
+        onnx.load_external_data_for_model(model, base_dir)
+    else:
+        model = onnx.load(input_path)
+
+    e = Extractor(model)
+    extracted = e.extract_model(input_names, output_names)
+
+    if extracted.ByteSize() > onnx.checker.MAXIMUM_PROTOBUF:
+        location = os.path.basename(output_path) + ".data"
+        onnx.save(extracted, output_path, save_as_external_data=True, location=location)
+    else:
+        onnx.save(extracted, output_path)
+
+    if check_model:
+        onnx.checker.check_model(output_path)
+
+
+def _tar_members_filter(
+    tar: tarfile.TarFile, base: str | os.PathLike
+) -> list[tarfile.TarInfo]:
+    """Check that the content of ``tar`` will be extracted safely
+
+    Args:
+        tar: The tarball file
+        base: The directory where the tarball will be extracted
+
+    Returns:
+        list of tarball members
+    """
+    result = []
+    abs_base = os.path.abspath(base)
+    for member in tar:
+        member_path = os.path.join(base, member.name)
+        abs_member = os.path.abspath(member_path)
+        try:
+            is_within_base = os.path.commonpath([abs_base, abs_member]) == abs_base
+        except ValueError:
+            is_within_base = False
+        if not is_within_base:
+            raise RuntimeError(
+                f"The tarball member {member_path} in downloading model contains "
+                f"directory traversal sequence which may contain harmful payload."
+            )
+        if member.issym() or member.islnk():
+            raise RuntimeError(
+                f"The tarball member {member_path} in downloading model contains "
+                f"symbolic links which may contain harmful payload."
+            )
+        result.append(member)
+    return result
+
+
+def _extract_model_safe(
+    model_tar_path: str | os.PathLike, local_model_with_data_dir_path: str | os.PathLike
+) -> None:
+    """Safely extracts a tar file to a specified directory.
+
+    This function ensures that the extraction process mitigates against
+    directory traversal vulnerabilities by validating or sanitizing paths
+    within the tar file. It also provides compatibility for different versions
+    of the tarfile module by checking for the availability of certain attributes
+    or methods before invoking them.
+
+    Args:
+        model_tar_path: The path to the tar file to be extracted.
+        local_model_with_data_dir_path: The directory path where the tar file
+      contents will be extracted to.
+    """
+    with tarfile.open(model_tar_path) as model_with_data_zipped:
+        # Mitigate tarball directory traversal risks
+        if hasattr(tarfile, "data_filter"):
+            model_with_data_zipped.extractall(
+                path=local_model_with_data_dir_path, filter="data"
+            )
+        else:
+            model_with_data_zipped.extractall(  # noqa: S202
+                path=local_model_with_data_dir_path,
+                members=_tar_members_filter(
+                    model_with_data_zipped, local_model_with_data_dir_path
+                ),
+            )
diff --git a/onnx/version.py b/onnx/version.py
new file mode 100644
index 0000000..917b22e
--- /dev/null
+++ b/onnx/version.py
@@ -0,0 +1,24 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Backward-compatibility shim for onnx.version.
+
+This module is deprecated. Use ``onnx.__version__`` instead.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+from onnx import __version__ as version
+
+warnings.warn(
+    "onnx.version is deprecated. Use onnx.__version__ instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+git_version = ""
+
+__all__ = ["version", "git_version"]
diff --git a/onnx/version_converter.py b/onnx/version_converter.py
new file mode 100644
index 0000000..9c8a18d
--- /dev/null
+++ b/onnx/version_converter.py
@@ -0,0 +1,43 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+"""onnx version converter
+
+This enables users to convert their models between different opsets within the
+default domain ("" or "ai.onnx").
+"""
+
+from __future__ import annotations
+
+import onnx
+import onnx.onnx_cpp2py_export.version_converter as C  # noqa: N812
+from onnx import ModelProto
+
+
+def convert_version(model: ModelProto, target_version: int) -> ModelProto:
+    """Convert opset version of the ModelProto.
+
+    Arguments:
+        model: Model.
+        target_version: Target opset version.
+
+    Returns:
+        Converted model.
+
+    Raises:
+        RuntimeError when some necessary conversion is not supported.
+    """
+    if not isinstance(model, ModelProto):
+        raise TypeError(
+            f"VersionConverter only accepts ModelProto as model, incorrect type: {type(model)}"
+        )
+    if not isinstance(target_version, int):
+        raise TypeError(
+            f"VersionConverter only accepts int as target_version, incorrect type: {type(target_version)}"
+        )
+    model_str = model.SerializeToString()
+    converted_model_str = C.convert_version(model_str, target_version)
+    return onnx.load_from_string(converted_model_str)
+
+
+ConvertError = C.ConvertError
diff --git a/onnx/version_converter/BaseConverter.h b/onnx/version_converter/BaseConverter.h
new file mode 100644
index 0000000..af222e7
--- /dev/null
+++ b/onnx/version_converter/BaseConverter.h
@@ -0,0 +1,90 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Version converter interface for ONNX models between different opset versions.
+
+#pragma once
+
+#include <cstdlib>
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+#include "onnx/common/ir.h"
+#include "onnx/defs/schema.h"
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+// TODO(ONNX): Consider creating interface for this class.
+class BaseVersionConverter {
+  // Schema for adapters: {<op_name>:{<from_domain>$<from_version>:{<to_domain>
+  // <to_version>: adapter}}}
+ protected:
+  std::unordered_map<
+      std::string,
+      std::unordered_map<std::string, std::unordered_map<std::string, std::unique_ptr<Adapter>>>>
+      adapters;
+
+  // Map of All Versions of format {op_name: {domain: {version: schema}}}
+  std::unordered_map<std::string, std::unordered_map<std::string, std::map<int64_t, const OpSchema*>>> all_schemas;
+
+ public:
+  BaseVersionConverter() = default;
+
+  virtual ~BaseVersionConverter() = default;
+
+  // adapter_lookup should be called in convert_version when the user would
+  // like to identify the proper registered adapter in the adapters map for
+  // a given Node from a certain version to another. It should only be called
+  // when the user knows that an adapter should exist for the given context.
+  const Adapter& adapter_lookup(const Node* op, const OpSetID& initial_version, const OpSetID& target_version) const {
+    const std::string op_name = op->kind().toString();
+    const std::string initial = initial_version.toString();
+    const std::string target = target_version.toString();
+    // Find appropriate adapter in adapters map for provided initial and target versions
+    // TODO(ONNX): Consider abstracting elements of this that are specific to
+    // DefaultConverter to separate methods here and maintain the procedure in Base Converter
+    const auto op_adapters = adapters.find(op_name);
+    if (op_adapters != adapters.end()) {
+      // If we're adapting downwards, we just want to find the one downwards
+      // adapter implemented for initial_version. If we're adapting upwards, we
+      // want to actually use the SinceVersion value for the given op.
+      const auto target_map = op_adapters->second.find(initial);
+      if (target_map != op_adapters->second.end()) {
+        // Either adapt from SinceVersion or Incompatible Breaking Change
+        const auto adapter_ptr = target_map->second.find(target);
+        if (adapter_ptr != target_map->second.end()) {
+          return *(adapter_ptr->second);
+        } else {
+          ONNX_ASSERTM(false, "No Adapter To Version ", target, " for ", op_name)
+        }
+      } else {
+        ONNX_ASSERTM(false, "No Adapter From Version ", initial, " for ", op_name)
+      }
+    } else {
+      // No adapters exist for the given op
+      ONNX_ASSERTM(false, "No Adapter For ", op_name)
+    }
+  }
+
+  virtual ModelProto
+  convert_version(const ModelProto& mp_in, const OpSetID& initial_version, const OpSetID& target_version) const = 0;
+
+  void registerAdapter(std::unique_ptr<Adapter> a_ptr) {
+    const OpSetID& iv = a_ptr->initial_version();
+    const OpSetID& tv = a_ptr->target_version();
+    adapters[a_ptr->name()][iv.toString()][tv.toString()] = std::move(a_ptr);
+  }
+
+  void registerAdapter(const char* op, int64_t from, int64_t to, const NodeTransformerFunction& transformer) {
+    registerAdapter(std::make_unique<GenericAdapter>(op, from, to, transformer));
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/CMakeLists.txt b/onnx/version_converter/CMakeLists.txt
new file mode 100644
index 0000000..af8f9cb
--- /dev/null
+++ b/onnx/version_converter/CMakeLists.txt
@@ -0,0 +1,12 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    BaseConverter.h
+    convert.cc
+    convert.h
+    helper.cc
+    helper.h
+)
+
+add_subdirectory(adapters)
diff --git a/onnx/version_converter/adapters/Attention_24_23.h b/onnx/version_converter/adapters/Attention_24_23.h
new file mode 100644
index 0000000..6343ff9
--- /dev/null
+++ b/onnx/version_converter/adapters/Attention_24_23.h
@@ -0,0 +1,45 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Attention in default domain from version 24 to 23
+
+#pragma once
+
+#include <cinttypes>
+#include <cstdint>
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Attention_24_23 final : public Adapter {
+ public:
+  explicit Attention_24_23() : Adapter("Attention", OpSetID(24), OpSetID(23)) {}
+
+  void adapt_attention_24_23(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+
+    // Check if nonpad_kv_seqlen input is present (input index 6)
+    if (inputs.size() > 6) {
+      ONNX_ASSERTM(
+          false,
+          name(),
+          " being converted from ",
+          static_cast<int64_t>(initial_version().version()),
+          " to ",
+          static_cast<int64_t>(target_version().version()),
+          " has nonpad_kv_seqlen input, which is not supported in opset 23. This conversion cannot be performed.")
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_attention_24_23(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/CMakeLists.txt b/onnx/version_converter/adapters/CMakeLists.txt
new file mode 100644
index 0000000..d4afa96
--- /dev/null
+++ b/onnx/version_converter/adapters/CMakeLists.txt
@@ -0,0 +1,50 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+
+target_sources(onnx PRIVATE
+    adapter.h
+    Attention_24_23.h
+    axes_attribute_to_input.h
+    axes_input_to_attribute.h
+    axis_attribute_to_input.h
+    axis_input_to_attribute.h
+    batch_normalization_13_14.h
+    broadcast_backward_compatibility.h
+    broadcast_forward_compatibility.h
+    cast_9_8.h
+    clip_10_11.h
+    compatible.h
+    dropout_11_12.h
+    extend_supported_types.h
+    gemm_6_7.h
+    gemm_7_6.h
+    gridsample_19_20.h
+    group_normalization_20_21.h
+    maxpool_8_7.h
+    no_previous_version.h
+    pad_10_11.h
+    q_dq_21_20.h
+    remove_consumed_inputs.h
+    reshape_4_5.h
+    reshape_5_4.h
+    resize_10_11.h
+    scan_8_9.h
+    scan_9_8.h
+    scatter_10_11.h
+    scatter_16_15.h
+    scatter_18_17.h
+    slice_9_10.h
+    softmax_12_13.h
+    softmax_13_12.h
+    split_12_13.h
+    split_13_12.h
+    split_17_18.h
+    sum_8_7.h
+    topk_9_10.h
+    transformers.h
+    type_restriction.h
+    upsample_6_7.h
+    upsample_8_9.h
+    upsample_9_10.h
+    upsample_9_8.h
+)
diff --git a/onnx/version_converter/adapters/adapter.h b/onnx/version_converter/adapters/adapter.h
new file mode 100644
index 0000000..f71910d
--- /dev/null
+++ b/onnx/version_converter/adapters/adapter.h
@@ -0,0 +1,69 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Interface for Op Version Adapters
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "onnx/onnx_pb.h"
+#include "onnx/version_converter/helper.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Adapter {
+ private:
+  std::string name_;
+  OpSetID initial_version_;
+  OpSetID target_version_;
+
+ public:
+  virtual ~Adapter() noexcept = default;
+
+  Adapter(std::string name, OpSetID initial_version, OpSetID target_version)
+      : name_(std::move(name)),
+        initial_version_(std::move(initial_version)),
+        target_version_(std::move(target_version)) {}
+
+  // This will almost always return its own node argument after modifying it in place.
+  // The only exception are adapters for deprecated operators: in this case the input
+  // node must be destroyed and a new one must be created and returned. See e.g.
+  // upsample_9_10.h
+  virtual Node* adapt(std::shared_ptr<Graph> /*graph*/, Node* node) const = 0;
+
+  const std::string& name() const {
+    return name_;
+  }
+
+  const OpSetID& initial_version() const {
+    return initial_version_;
+  }
+
+  const OpSetID& target_version() const {
+    return target_version_;
+  }
+};
+
+using NodeTransformerFunction = std::function<Node*(std::shared_ptr<Graph>, Node* node)>;
+
+class GenericAdapter final : public Adapter {
+ public:
+  GenericAdapter(const char* op, int64_t from, int64_t to, NodeTransformerFunction transformer)
+      : Adapter(op, OpSetID(from), OpSetID(to)), transformer_(std::move(transformer)) {}
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    return transformer_(graph, node);
+  }
+
+ private:
+  NodeTransformerFunction transformer_;
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/axes_attribute_to_input.h b/onnx/version_converter/adapters/axes_attribute_to_input.h
new file mode 100644
index 0000000..caeed3c
--- /dev/null
+++ b/onnx/version_converter/adapters/axes_attribute_to_input.h
@@ -0,0 +1,48 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for all ops that remove consumed_inputs
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class AxesAttributeToInput : public Adapter {
+ public:
+  explicit AxesAttributeToInput(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
+      : Adapter(op_name, initial, target) {}
+
+  void attrToInput(const std::shared_ptr<Graph>& graph, Node* node, const std::vector<int64_t>& axes) const {
+    Tensor t;
+    t.elem_type() = TensorProto_DataType_INT64;
+    t.sizes() = std::vector<int64_t>{static_cast<int64_t>(axes.size())};
+    auto& data = t.int64s();
+    for (auto a : axes) {
+      data.emplace_back(a);
+    }
+
+    Node* constant = graph->create(kConstant);
+    constant->insertBefore(node);
+    constant->t_(kvalue, t);
+    node->addInput(constant->output());
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    if (node->hasAttribute(kaxes)) {
+      attrToInput(graph, node, node->is(kaxes));
+      node->removeAttribute(kaxes);
+    }
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/axes_input_to_attribute.h b/onnx/version_converter/adapters/axes_input_to_attribute.h
new file mode 100644
index 0000000..9c674b6
--- /dev/null
+++ b/onnx/version_converter/adapters/axes_input_to_attribute.h
@@ -0,0 +1,62 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for all ops that remove consumed_inputs
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class AxesInputToAttribute : public Adapter {
+ public:
+  explicit AxesInputToAttribute(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
+      : Adapter(op_name, initial, target) {}
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    // Identify if axes is statically determined; if so, feed as attribute
+    const ArrayRef<Value*>& inputs = node->inputs();
+    // Check if axes input is provided (it's optional)
+    if (inputs.size() <= 1) {
+      // No axes input provided, nothing to convert
+      return node;
+    }
+    // Get axes from initializer or constant operator
+    // Identify whether we have a Constant Op or an Initializer
+    Value* const_val = inputs[1];
+    Node* node_ptr = const_val->node();
+    if (node_ptr->kind() == kConstant) {
+      node->is_(kaxes, ReadInt64Tensor(node_ptr->t(kvalue)));
+      // If Constant node isn't used anywhere else, remove it
+      node->removeInput(1);
+      if (const_val->uses().empty()) {
+        node_ptr->destroy();
+      }
+    } else {
+      // Get Value name, find Initializer with same name
+      for (const auto& initializer : graph->initializers()) {
+        if (initializer.name() == inputs[1]->uniqueName()) {
+          node->is_(kaxes, ReadInt64Tensor(initializer));
+          node->removeInput(1);
+          // Remove initializer
+          if (const_val->uses().empty())
+            graph->eraseInitializerAndInput(const_val);
+          break;
+        }
+      }
+    }
+    ONNX_ASSERTM(node->hasAttribute(kaxes), "No initializer or constant input to node found")
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/axis_attribute_to_input.h b/onnx/version_converter/adapters/axis_attribute_to_input.h
new file mode 100644
index 0000000..a243ee3
--- /dev/null
+++ b/onnx/version_converter/adapters/axis_attribute_to_input.h
@@ -0,0 +1,72 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class AxisAttributeToInput : public Adapter {
+ public:
+  AxisAttributeToInput(
+      const std::string& op_name,
+      const OpSetID& initial,
+      const OpSetID& target,
+      size_t axis_index,
+      int64_t default_axis)
+      : Adapter(op_name, initial, target), axis_index(axis_index), default_axis(default_axis) {}
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    if (node->hasAttribute(kaxis)) {
+      AttrToInput(graph, node, node->i(kaxis), this->axis_index);
+      node->removeAttribute(kaxis);
+      return node;
+    }
+
+    // Fill in the default value for axis
+    AttrToInput(graph, node, default_axis, this->axis_index);
+    return node;
+  }
+
+ private:
+  size_t axis_index;
+  int64_t default_axis;
+
+  void AttrToInput(const std::shared_ptr<Graph>& graph, Node* node, int64_t axis, size_t axis_index) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+
+    // Add the optional inputs if they don't exist
+    for (size_t i = inputs.size(); i < axis_index; ++i) {
+      Node* empty_input = graph->create(kUndefined);
+      empty_input->insertBefore(node);
+      node->addInput(empty_input->output());
+    }
+
+    // Add the axis input
+    Node* constant = CreateAxisInput(graph, node, axis);
+    node->addInput(constant->output());
+  }
+
+  Node* CreateAxisInput(const std::shared_ptr<Graph>& graph, Node* node, int64_t axis) const {
+    Tensor t;
+    t.elem_type() = TensorProto_DataType_INT64;
+    t.sizes() = std::vector<int64_t>{};
+    auto& data = t.int64s();
+    data.emplace_back(axis);
+
+    Node* constant = graph->create(kConstant);
+    constant->insertBefore(node);
+    constant->t_(kvalue, t);
+    return constant;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/axis_input_to_attribute.h b/onnx/version_converter/adapters/axis_input_to_attribute.h
new file mode 100644
index 0000000..124e418
--- /dev/null
+++ b/onnx/version_converter/adapters/axis_input_to_attribute.h
@@ -0,0 +1,90 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+class AxisInputToAttribute : public Adapter {
+ public:
+  explicit AxisInputToAttribute(
+      const std::string& op_name,
+      const OpSetID& initial,
+      const OpSetID& target,
+      size_t axis_index,
+      int64_t default_axis)
+      : Adapter(op_name, initial, target), axis_index(axis_index), default_axis(default_axis) {}
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    if (!HasAxisInput(node)) {
+      node->i_(kaxis, this->default_axis);
+      return EnsureAndReturnNode(node);
+    }
+
+    const ArrayRef<Value*>& inputs = node->inputs();
+    Value* axis_val = inputs[this->axis_index];
+    Node* axis_node = axis_val->node();
+
+    if (axis_node->kind() == kConstant) {
+      HandleConstantNode(node, axis_node, axis_val);
+      return EnsureAndReturnNode(node);
+    }
+
+    if (graph->is_constant_initializer(axis_val)) {
+      HandleInitializerNode(graph, node, axis_val);
+      return EnsureAndReturnNode(node);
+    }
+
+    ONNX_ASSERTM(false, "Axis input must be a constant or initializer for promotion to attribute.")
+  }
+
+ private:
+  size_t axis_index;
+  int64_t default_axis;
+
+  bool HasAxisInput(const Node* node) const {
+    const ArrayRef<const Value*>& inputs = node->inputs();
+    return inputs.size() > this->axis_index && inputs[this->axis_index]->node()->kind() != kUndefined;
+  }
+
+  void HandleConstantNode(Node* node, Node* axis_node, Value* axis_val) const {
+    const std::vector<int64_t> values = ReadInt64Tensor(axis_node->t(kvalue));
+    ONNX_ASSERTM(!values.empty(), "Axis tensor must contain at least one element.")
+    node->i_(kaxis, values[0]);
+    node->removeInput(this->axis_index);
+    if (axis_val->uses().empty()) {
+      axis_node->destroy();
+    }
+  }
+
+  void HandleInitializerNode(const std::shared_ptr<Graph>& graph, Node* node, Value* axis_val) const {
+    const std::string initializer_name = axis_val->uniqueName();
+    for (const auto& initializer : graph->initializers()) {
+      if (initializer.name() == initializer_name) {
+        const std::vector<int64_t> values = ReadInt64Tensor(initializer);
+        ONNX_ASSERTM(!values.empty(), "Axis tensor must contain at least one element.")
+        node->i_(kaxis, values[0]);
+        node->removeInput(this->axis_index);
+        // Remove initializer
+        if (axis_val->uses().empty())
+          graph->eraseInitializer(initializer_name);
+        break;
+      }
+    }
+  }
+
+  Node* EnsureAndReturnNode(Node* node) const {
+    ONNX_ASSERTM(node->hasAttribute(kaxis), "Axis attribute not created. This may be a bug.")
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/batch_normalization_13_14.h b/onnx/version_converter/adapters/batch_normalization_13_14.h
new file mode 100644
index 0000000..ea9350d
--- /dev/null
+++ b/onnx/version_converter/adapters/batch_normalization_13_14.h
@@ -0,0 +1,32 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for BatchNormalization in default domain from version 13 to 14
+
+#pragma once
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class BatchNormalization_13_14 final : public Adapter {
+ public:
+  explicit BatchNormalization_13_14() : Adapter("BatchNormalization", OpSetID(13), OpSetID(14)) {}
+
+  void adapt_batch_normalization_13_14(Node* node) const {
+    ONNX_ASSERTM(
+        node->outputs().size() < 4,
+        "BatchNormalization outputs 4 and 5 are not "
+        "supported in Opset 14.")
+  }
+
+  Node* adapt(std::shared_ptr<Graph> /*unused*/, Node* node) const override {
+    adapt_batch_normalization_13_14(node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/broadcast_backward_compatibility.h b/onnx/version_converter/adapters/broadcast_backward_compatibility.h
new file mode 100644
index 0000000..bc8e450
--- /dev/null
+++ b/onnx/version_converter/adapters/broadcast_backward_compatibility.h
@@ -0,0 +1,61 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for broadcasting ops in default domain from version 7 to 6
+
+#pragma once
+
+#include <cinttypes>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class BroadcastBackwardCompatibility final : public Adapter {
+ public:
+  explicit BroadcastBackwardCompatibility(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
+      : Adapter(op_name, initial, target) {}
+
+  void adapt_broadcast_backward_compatibility(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    // Verify that broadcasts are allowed in limited spec of opset version 6
+    // Multidirectional broadcasting, as defined in Broadcasting.md
+    // MathDocGenerator provides differences
+    // Main change: encode broadcasting commands as explicit attribute
+    const ArrayRef<Value*>& inputs = node->inputs();
+    assertInputsAvailable(inputs, name().c_str(), 2);
+    const std::vector<Dimension>& A_sizes = inputs[0]->sizes();
+    const std::vector<Dimension>& B_sizes = inputs[1]->sizes();
+    // Ensure that first input is larger than or equal to the second
+    // numpy_unibroadcastable here is considered to be equivalent to opset1_broadcastable
+    // This is because backwards conversion does not allow for an axis that is not
+    // suffix matching
+    int req_broadcast = check_numpy_unibroadcastable_and_require_broadcast(A_sizes, B_sizes);
+    ONNX_ASSERTM(
+        req_broadcast != -1,
+        name(),
+        " being converted from ",
+        static_cast<int64_t>(initial_version().version()),
+        " to ",
+        static_cast<int64_t>(target_version().version()),
+        " does not have broadcastable inputs.")
+    if (req_broadcast == 1) {
+      // If conditional is not fulfilled, we have a default broadcast
+      // Add broadcast attribute
+      node->i_(kbroadcast, 1);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_broadcast_backward_compatibility(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/broadcast_forward_compatibility.h b/onnx/version_converter/adapters/broadcast_forward_compatibility.h
new file mode 100644
index 0000000..091caf8
--- /dev/null
+++ b/onnx/version_converter/adapters/broadcast_forward_compatibility.h
@@ -0,0 +1,86 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for broadcasting ops in default domain from version 6 to 7
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class BroadcastForwardCompatibility final : public Adapter {
+ public:
+  explicit BroadcastForwardCompatibility(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
+      : Adapter(op_name, initial, target) {}
+
+  void adapt_broadcast_forward_compatibility(const std::shared_ptr<Graph>& graph, Node* node) const {
+    // Remove axis and broadcast attributes
+    // Assess whether axis requires reshaping
+    if (node->hasAttribute(kbroadcast)) {
+      const ArrayRef<Value*>& inputs = node->inputs();
+      assertInputsAvailable(inputs, name().c_str(), 2);
+      const std::vector<Dimension>& A_sizes = inputs[0]->sizes();
+      const std::vector<Dimension>& B_sizes = inputs[1]->sizes();
+      // Also assert that broadcasting syntax are correct if axis is not present
+      if (node->hasAttribute(kaxis)) {
+        if (node->i(kaxis) != static_cast<int>(A_sizes.size() - B_sizes.size())) {
+          // Add a Reshape node before input B
+          Node* n = graph->create(kUnsqueeze);
+          n->addInput(inputs[1]);
+          std::vector<int64_t> axes;
+          std::vector<Dimension> new_sizes = B_sizes;
+          auto size = A_sizes.size() > B_sizes.size() ? A_sizes.size() - B_sizes.size() : 0;
+          axes.reserve(size);
+          new_sizes.reserve(new_sizes.size() + size);
+          for (size_t i = 0; i < size; i++) {
+            axes.emplace_back(B_sizes.size() + i);
+            new_sizes.emplace_back(1);
+          }
+          if (target_version().version() >= 13) { // Unsqueeze takes 'axes' input
+            Tensor t;
+            t.elem_type() = TensorProto_DataType_INT64;
+            t.sizes() = std::vector<int64_t>{static_cast<int64_t>(axes.size())};
+            auto& data = t.int64s();
+            for (auto a : axes) {
+              data.emplace_back(a);
+            }
+            Node* constant = graph->create(kConstant);
+            constant->insertBefore(node);
+            constant->t_(kvalue, t);
+            node->addInput(constant->output());
+          } else { // Unsqueeze takes 'axes' attribute
+            n->is_(kaxes, std::forward<const std::vector<int64_t>>(axes));
+          }
+          // Move n before node
+          n->insertBefore(node);
+          // Set 2nd input to node to 1st of n and output of n to 2nd input to node
+          n->output()->setSizes(new_sizes);
+          node->replaceInput(1, n->output());
+        }
+      }
+      node->removeAttribute(kbroadcast);
+    }
+    if (node->hasAttribute(kaxis))
+      node->removeAttribute(kaxis);
+    // Assert multi_broadcastable on inputs
+    const ArrayRef<Value*>& inputs = node->inputs();
+    assertInputsAvailable(inputs, name().c_str(), 2);
+    assert_numpy_multibroadcastable(inputs[0]->sizes(), inputs[1]->sizes());
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_broadcast_forward_compatibility(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/cast_9_8.h b/onnx/version_converter/adapters/cast_9_8.h
new file mode 100644
index 0000000..8717d68
--- /dev/null
+++ b/onnx/version_converter/adapters/cast_9_8.h
@@ -0,0 +1,33 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Cast in default domain from version 9 to 8
+
+#pragma once
+
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Cast_9_8 final : public Adapter {
+ public:
+  explicit Cast_9_8() : Adapter("Cast", OpSetID(9), OpSetID(8)) {}
+
+  void adapt_cast_9_8(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    ONNX_ASSERTM(node->inputs().size() >= 1, "Cast node must have at least 1 input")
+    if (node->inputs()[0]->elemType() == TensorProto_DataType_STRING || node->i(kto) == TensorProto_DataType_STRING)
+      ONNX_ASSERTM(false, "Casting From/To STRING data type is not supported")
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_cast_9_8(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/clip_10_11.h b/onnx/version_converter/adapters/clip_10_11.h
new file mode 100644
index 0000000..972ee2c
--- /dev/null
+++ b/onnx/version_converter/adapters/clip_10_11.h
@@ -0,0 +1,56 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Clip in default domain from version 10 to 11
+
+#pragma once
+#include <limits>
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Clip_10_11 final : public Adapter {
+ public:
+  explicit Clip_10_11() : Adapter("Clip", OpSetID(10), OpSetID(11)) {}
+
+  void adapt_clip_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
+    bool has_min = node->hasAttribute(kmin);
+    bool has_max = node->hasAttribute(kmax);
+
+    // Turn min/max attributes into tensor (if present) and add value as input
+    if (has_min) {
+      attrToInput(graph, node, static_cast<float>(node->f(kmin)));
+      node->removeAttribute(kmin);
+    }
+    if (has_max) {
+      if (!has_min) {
+        attrToInput(graph, node, std::numeric_limits<float>::lowest());
+      }
+      attrToInput(graph, node, static_cast<float>(node->f(kmax)));
+      node->removeAttribute(kmax);
+    }
+  }
+
+  void attrToInput(const std::shared_ptr<Graph>& graph, Node* node, float val) const {
+    Tensor t;
+    t.elem_type() = TensorProto_DataType_FLOAT;
+    auto& data = t.floats();
+    data.emplace_back(val);
+    Node* constant = graph->create(kConstant);
+    constant->insertBefore(node);
+    constant->t_(kvalue, t);
+    node->addInput(constant->output());
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_clip_10_11(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/compatible.h b/onnx/version_converter/adapters/compatible.h
new file mode 100644
index 0000000..217c8a2
--- /dev/null
+++ b/onnx/version_converter/adapters/compatible.h
@@ -0,0 +1,28 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter indicating compatibility of op between opsets with separate
+// definitions
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+struct CompatibleAdapter final : public Adapter {
+  explicit CompatibleAdapter(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
+      : Adapter(op_name, initial, target) {}
+
+  Node* adapt(std::shared_ptr<Graph> /*unused*/, Node* node) const override {
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/dropout_11_12.h b/onnx/version_converter/adapters/dropout_11_12.h
new file mode 100644
index 0000000..e3aa1b2
--- /dev/null
+++ b/onnx/version_converter/adapters/dropout_11_12.h
@@ -0,0 +1,47 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Dropout in default domain from version 11 to 12
+
+#pragma once
+
+#include <cmath>
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Dropout_11_12 final : public Adapter {
+ public:
+  explicit Dropout_11_12() : Adapter("Dropout", OpSetID(11), OpSetID(12)) {}
+
+  void adapt_dropout_11_12(const std::shared_ptr<Graph>& graph, Node* node) const {
+    float ratio = NAN;
+    if (node->hasAttribute(kratio)) {
+      ratio = static_cast<float>(node->f(kratio));
+      node->removeAttribute(kratio);
+    } else {
+      ratio = 0.5f;
+    }
+
+    Tensor t_ratio;
+    t_ratio.elem_type() = TensorProto_DataType_FLOAT;
+    auto& data_ratio = t_ratio.floats();
+    data_ratio.emplace_back(ratio);
+    Node* constant = graph->create(kConstant);
+    constant->insertBefore(node);
+    constant->t_(kvalue, t_ratio);
+    node->addInput(constant->output());
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_dropout_11_12(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/extend_supported_types.h b/onnx/version_converter/adapters/extend_supported_types.h
new file mode 100644
index 0000000..bbed522
--- /dev/null
+++ b/onnx/version_converter/adapters/extend_supported_types.h
@@ -0,0 +1,104 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter indicating compatibility of op between opsets with separate
+// definitions
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+struct ExtendSupportedTypes final : public Adapter {
+  explicit ExtendSupportedTypes(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
+      : Adapter(op_name, initial, target) {}
+
+  Node* create_cast_op(
+      const std::shared_ptr<Graph>& graph,
+      ArrayRef<Value*> inputs,
+      const int to_type,
+      const std::vector<Dimension>& output_shape,
+      const std::string& name) const {
+    Node* node = graph->create(kCast, inputs);
+    node->i_(kto, to_type);
+    node->output()->setUniqueName(name);
+    node->output()->setSizes(output_shape);
+    node->output()->setElemType(to_type);
+    return node;
+  }
+
+  void adapt_type_extension(const std::shared_ptr<Graph>& graph, Node* node) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+    const ArrayRef<Value*>& outputs = node->outputs();
+    const std::string original_output_name = node->output()->uniqueName();
+
+    const int input_type = !inputs.empty() ? inputs[0]->elemType() : -1;
+    const int output_type = outputs[0]->elemType();
+
+    const std::unordered_set<int>& supported_version8_types = {
+        TensorProto_DataType::TensorProto_DataType_FLOAT,
+        TensorProto_DataType::TensorProto_DataType_FLOAT16,
+        TensorProto_DataType::TensorProto_DataType_DOUBLE,
+    };
+
+    const std::unordered_set<int>& unsupported_version9_types = {
+        TensorProto_DataType::TensorProto_DataType_COMPLEX128,
+        TensorProto_DataType::TensorProto_DataType_COMPLEX64,
+        TensorProto_DataType::TensorProto_DataType_STRING,
+    };
+
+    ONNX_ASSERTM(
+        unsupported_version9_types.find(input_type) == unsupported_version9_types.end(), "Unsupported Input Type")
+    ONNX_ASSERTM(
+        unsupported_version9_types.find(output_type) == unsupported_version9_types.end(), "Unsupported Output Type")
+
+    bool castInput = (node->kind() != kConstant);
+    bool castOutput = (node->kind() != kGreater && node->kind() != kLess);
+    if (castInput && supported_version8_types.find(input_type) == supported_version8_types.end()) {
+      for (size_t i = 0; i < inputs.size(); i++) {
+        Node* pre_cast = create_cast_op(
+            graph,
+            inputs[i],
+            TensorProto_DataType::TensorProto_DataType_FLOAT,
+            inputs[i]->sizes(),
+            "pre_cast_" + ONNX_NAMESPACE::to_string(i));
+        pre_cast->insertBefore(node);
+        node->replaceInput(i, pre_cast->output());
+      }
+    }
+    if (castOutput && supported_version8_types.find(output_type) == supported_version8_types.end()) {
+      const use_list original_uses(node->output()->uses());
+      node->output()->setElemType(TensorProto_DataType::TensorProto_DataType_FLOAT);
+      node->output()->setUniqueName(original_output_name + "_intermediate_output");
+      Node* post_cast = create_cast_op(graph, outputs[0], output_type, outputs[0]->sizes(), original_output_name);
+
+      post_cast->insertAfter(node);
+
+      for (Use u : original_uses) {
+        u.user->replaceInputWith(node->output(), post_cast->output());
+      }
+
+      for (size_t i = 0; i < graph->outputs().size(); i++) {
+        if (graph->outputs()[i]->uniqueName() == node->output()->uniqueName()) {
+          graph->return_node()->replaceInput(i, post_cast->output());
+        }
+      }
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_type_extension(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/gemm_6_7.h b/onnx/version_converter/adapters/gemm_6_7.h
new file mode 100644
index 0000000..a2e32ef
--- /dev/null
+++ b/onnx/version_converter/adapters/gemm_6_7.h
@@ -0,0 +1,57 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Gemm in default domain from version 6 to 7
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Gemm_6_7 final : public Adapter {
+ public:
+  explicit Gemm_6_7() : Adapter("Gemm", OpSetID(6), OpSetID(7)) {}
+
+  void adapt_gemm_6_7(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+    assertInputsAvailable(inputs, name().c_str(), 3);
+    const auto& A_shape = inputs[0]->sizes();
+    const auto& B_shape = inputs[1]->sizes();
+    // Determine if C is broadcastable
+    const auto& C_shape = inputs[2]->sizes();
+    ONNX_ASSERTM(A_shape.size() == 2, "Gemm input A must have exactly 2 dimensions")
+    ONNX_ASSERTM(B_shape.size() == 2, "Gemm input B must have exactly 2 dimensions")
+    // Create (M, N) to input to numpy_unibroadcastable
+    std::vector<Dimension> MN;
+    if (node->hasAttribute(ktransA) && node->i(ktransA) == 1) {
+      MN.emplace_back(A_shape[1]);
+    } else {
+      MN.emplace_back(A_shape[0]);
+    }
+    if (node->hasAttribute(ktransB) && node->i(ktransB) == 1) {
+      MN.emplace_back(B_shape[0]);
+    } else {
+      MN.emplace_back(B_shape[1]);
+    }
+    ONNX_ASSERTM(
+        check_numpy_unibroadcastable_and_require_broadcast(MN, C_shape) != -1,
+        "Gemm being converted from 6 to 7 does not have "
+        "broadcastable inputs.")
+    if (node->hasAttribute(kbroadcast))
+      node->removeAttribute(kbroadcast);
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_gemm_6_7(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/gemm_7_6.h b/onnx/version_converter/adapters/gemm_7_6.h
new file mode 100644
index 0000000..0c4523f
--- /dev/null
+++ b/onnx/version_converter/adapters/gemm_7_6.h
@@ -0,0 +1,66 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Gemm in default domain from version 7 to 6
+
+#pragma once
+
+#include <cinttypes>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Gemm_7_6 final : public Adapter {
+ public:
+  explicit Gemm_7_6() : Adapter("Gemm", OpSetID(7), OpSetID(6)) {}
+
+  void adapt_gemm_7_6(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+    assertInputsAvailable(inputs, name().c_str(), 3);
+    const auto& A_shape = inputs[0]->sizes();
+    const auto& B_shape = inputs[1]->sizes();
+    // Determine if C is broadcastable
+    const auto& C_shape = inputs[2]->sizes();
+    ONNX_ASSERTM(A_shape.size() == 2, "Gemm input A must have exactly 2 dimensions")
+    ONNX_ASSERTM(B_shape.size() == 2, "Gemm input B must have exactly 2 dimensions")
+    // Create (M, N) to input to numpy_unibroadcastable
+    // TODO(ONNX): Reconcile fact that shapes aren't determined for 1st 2 inputs
+    std::vector<Dimension> MN;
+    if (node->hasAttribute(ktransA) && node->i(ktransA) == 1) {
+      MN.emplace_back(A_shape[1]);
+    } else {
+      MN.emplace_back(A_shape[0]);
+    }
+    if (node->hasAttribute(ktransB) && node->i(ktransB) == 1) {
+      MN.emplace_back(B_shape[0]);
+    } else {
+      MN.emplace_back(B_shape[1]);
+    }
+    int req_broadcast = check_numpy_unibroadcastable_and_require_broadcast(MN, C_shape);
+    ONNX_ASSERTM(
+        req_broadcast != -1,
+        name(),
+        " being converted from ",
+        static_cast<int64_t>(initial_version().version()),
+        " to ",
+        static_cast<int64_t>(target_version().version()),
+        " does not have broadcastable inputs.")
+    if (req_broadcast == 1) {
+      node->i_(kbroadcast, 1);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_gemm_7_6(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/gridsample_19_20.h b/onnx/version_converter/adapters/gridsample_19_20.h
new file mode 100644
index 0000000..18238ef
--- /dev/null
+++ b/onnx/version_converter/adapters/gridsample_19_20.h
@@ -0,0 +1,36 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for GridSample in default domain from version 19 to 20
+
+#pragma once
+
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class GridSample_19_20 final : public Adapter {
+ public:
+  explicit GridSample_19_20() : Adapter("GridSample", OpSetID(19), OpSetID(20)) {}
+
+  void adapt_gridsample_19_20(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    if (node->hasAttribute(kmode) && (node->s(kmode) == "bilinear")) {
+      node->s_(kmode, "linear");
+    }
+    if (node->hasAttribute(kmode) && (node->s(kmode) == "bicubic")) {
+      node->s_(kmode, "cubic");
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_gridsample_19_20(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/group_normalization_20_21.h b/onnx/version_converter/adapters/group_normalization_20_21.h
new file mode 100644
index 0000000..65563c2
--- /dev/null
+++ b/onnx/version_converter/adapters/group_normalization_20_21.h
@@ -0,0 +1,127 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for GroupNormalization in default domain from version 20 to 21
+
+#pragma once
+
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class GroupNormalization_20_21 final : public Adapter {
+ public:
+  explicit GroupNormalization_20_21() : Adapter("GroupNormalization", OpSetID(20), OpSetID(21)) {}
+
+  void transform_input(
+      const std::shared_ptr<Graph>& graph,
+      Node* node,
+      int64_t input_id,
+      Value* reshape0_shape,
+      Value* reshape1_shape,
+      Value* expand_shape) const {
+    Node* reshape0 = graph->create(kReshape);
+    reshape0->addInput(node->inputs()[input_id]);
+    reshape0->addInput(reshape0_shape);
+    reshape0->insertBefore(node);
+
+    Node* expand = graph->create(kExpand);
+    expand->addInput(reshape0->output());
+    expand->addInput(expand_shape);
+    expand->insertBefore(node);
+
+    Node* reshape1 = graph->create(kReshape);
+    reshape1->addInput(expand->output());
+    reshape1->addInput(reshape1_shape);
+    reshape1->insertBefore(node);
+
+    node->replaceInput(input_id, reshape1->output());
+  }
+
+  void adapt_group_normalization_20_21(const std::shared_ptr<Graph>& graph, Node* node) const {
+    ONNX_ASSERTM(node->inputs().size() >= 3, "GroupNormalization node must have at least 3 inputs")
+    // Perform following sequence of ops on scale/bias, effect is similar to numpy.repeat()
+    //
+    //   Shape<start=1,end=2>(input0) -- Div(Shape_out (C), num_groups)
+    //                                                           |
+    // Reshape(input1/2, [-1, 1]) ----------- Expand(Reshape_out, [1, Div_out]) -- Reshape(Expand_out, [-1])
+    //
+    // The helper function transform_input() implements the bottom row of the diagram
+
+    // Get number of channels: C
+    Symbol kShape("Shape");
+    Node* C = graph->create(kShape);
+    C->i_(kstart, 1);
+    C->i_(kend, 2);
+    C->addInput(node->inputs()[0]);
+    C->insertBefore(node);
+
+    // Get number of channels per group
+    Tensor tensor_num_groups;
+    tensor_num_groups.elem_type() = TensorProto_DataType_INT64;
+    int64_t num_groups = node->i(knum_groups);
+    tensor_num_groups.sizes() = {1};
+    tensor_num_groups.int64s() = {num_groups};
+    Node* constant_num_groups = graph->create(kConstant);
+    constant_num_groups->t_(kvalue, tensor_num_groups);
+    constant_num_groups->insertBefore(node);
+
+    Node* div = graph->create(kDiv);
+    div->addInput(C->output());
+    div->addInput(constant_num_groups->output());
+    div->insertBefore(node);
+
+    // Get Expand shape: [1, Div_out]
+    Tensor tensor_one;
+    tensor_one.elem_type() = TensorProto_DataType_INT64;
+    tensor_one.sizes() = {1};
+    tensor_one.int64s() = {1};
+    Node* constant_one = graph->create(kConstant);
+    constant_one->t_(kvalue, tensor_one);
+    constant_one->insertBefore(node);
+    Node* concat = graph->create(kConcat);
+    concat->i_(kaxis, 0);
+    concat->addInput(constant_one->output());
+    concat->addInput(div->output());
+    concat->insertBefore(node);
+
+    // Get shape of first reshape: [-1, 1]
+    Tensor tensor_reshape0_shape;
+    tensor_reshape0_shape.elem_type() = TensorProto_DataType_INT64;
+    tensor_reshape0_shape.sizes() = {2};
+    tensor_reshape0_shape.int64s() = {-1, 1};
+    Node* constant_reshape0_shape = graph->create(kConstant);
+    constant_reshape0_shape->t_(kvalue, tensor_reshape0_shape);
+    constant_reshape0_shape->insertBefore(node);
+
+    // Get shape of last reshape: [-1]
+    Tensor tensor_reshape1_shape;
+    tensor_reshape1_shape.elem_type() = TensorProto_DataType_INT64;
+    tensor_reshape1_shape.sizes() = {1};
+    tensor_reshape1_shape.int64s() = {-1};
+    Node* constant_reshape1_shape = graph->create(kConstant);
+    constant_reshape1_shape->t_(kvalue, tensor_reshape1_shape);
+    constant_reshape1_shape->insertBefore(node);
+
+    // transform scale and bias
+    transform_input(
+        graph, node, 1, constant_reshape0_shape->output(), constant_reshape1_shape->output(), concat->output());
+    transform_input(
+        graph, node, 2, constant_reshape0_shape->output(), constant_reshape1_shape->output(), concat->output());
+
+    // Set stash_type
+    node->i_(kstash_type, node->inputs()[0]->elemType());
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_group_normalization_20_21(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/maxpool_8_7.h b/onnx/version_converter/adapters/maxpool_8_7.h
new file mode 100644
index 0000000..abca32b
--- /dev/null
+++ b/onnx/version_converter/adapters/maxpool_8_7.h
@@ -0,0 +1,34 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for MaxPool in default domain from version 8 to 7
+
+#pragma once
+
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class MaxPool_8_7 final : public Adapter {
+ public:
+  explicit MaxPool_8_7() : Adapter("MaxPool", OpSetID(8), OpSetID(7)) {}
+
+  void adapt_maxpool_8_7(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    const ArrayRef<Value*>& outputs = node->outputs();
+    ONNX_ASSERTM(outputs.size() != 2, "Opset version 7 of MaxPool cannot include Indices output")
+    if (node->hasAttribute(kstorage_order))
+      node->removeAttribute(kstorage_order);
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_maxpool_8_7(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/no_previous_version.h b/onnx/version_converter/adapters/no_previous_version.h
new file mode 100644
index 0000000..ee470ef
--- /dev/null
+++ b/onnx/version_converter/adapters/no_previous_version.h
@@ -0,0 +1,30 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter indicating lack of a previous version of some op before a given
+// opset version.
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class NoPreviousVersionAdapter final : public Adapter {
+ public:
+  explicit NoPreviousVersionAdapter(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
+      : Adapter(op_name, initial, target) {}
+
+  Node* adapt(std::shared_ptr<Graph> /*unused*/, Node* node) const override {
+    ONNX_ASSERTM(false, "No Previous Version of ", name(), " exists")
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/pad_10_11.h b/onnx/version_converter/adapters/pad_10_11.h
new file mode 100644
index 0000000..8e550e3
--- /dev/null
+++ b/onnx/version_converter/adapters/pad_10_11.h
@@ -0,0 +1,56 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Pad in default domain from version 10 to 11
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Pad_10_11 final : public Adapter {
+ public:
+  explicit Pad_10_11() : Adapter("Pad", OpSetID(10), OpSetID(11)) {}
+
+  void adapt_pad_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
+    // Turn pads attribute into input
+    Tensor t_pads;
+    t_pads.elem_type() = TensorProto_DataType_INT64;
+    auto& data_pads = t_pads.int64s();
+    for (int64_t shape : node->is(kpads)) {
+      data_pads.emplace_back(shape);
+    }
+    t_pads.sizes() = std::vector<int64_t>{static_cast<int64_t>(data_pads.size())};
+    Value* v_pads = graph->addInitializerAndCreateValue(t_pads);
+    node->addInput(v_pads);
+    node->removeAttribute(kpads);
+    // Turn value attribute into input
+    if (!node->hasAttribute(kmode) || node->s(kmode) == "constant") {
+      if (!node->hasAttribute(kvalue))
+        node->f_(kvalue, 0.);
+      Tensor t_value;
+      t_value.elem_type() = TensorProto_DataType_FLOAT;
+      auto& data_value = t_value.floats();
+      data_value.emplace_back(static_cast<float>(node->f(kvalue)));
+      Node* constant = graph->create(kConstant);
+      constant->insertBefore(node);
+      constant->t_(kvalue, t_value);
+      node->addInput(constant->output());
+      node->removeAttribute(kvalue);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_pad_10_11(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/q_dq_21_20.h b/onnx/version_converter/adapters/q_dq_21_20.h
new file mode 100644
index 0000000..0e97b38
--- /dev/null
+++ b/onnx/version_converter/adapters/q_dq_21_20.h
@@ -0,0 +1,87 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Cast in default domain from version 9 to 8
+
+#pragma once
+
+#include <cinttypes>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "onnx/common/assertions.h"
+#include "onnx/version_converter/adapters/type_restriction.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+static const std::vector<TensorProto_DataType> q_dq_20_unallowed_types = {
+    TensorProto_DataType_UINT16,
+    TensorProto_DataType_INT16,
+    TensorProto_DataType_UINT4,
+    TensorProto_DataType_INT4};
+
+class QuantizeLinear_21_20 final : public TypeRestriction {
+ public:
+  explicit QuantizeLinear_21_20()
+      : TypeRestriction("QuantizeLinear", OpSetID(21), OpSetID(20), q_dq_20_unallowed_types) {}
+
+  void adapt_quantize_linear_21_20(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    if (node->hasAttribute(kblock_size)) {
+      if ((node->i(kblock_size) != 0)) {
+        ONNX_ASSERTM(
+            false,
+            "Blocked quantization is not supported for Opset Version ",
+            static_cast<int64_t>(target_version().version()),
+            ".")
+      }
+      node->removeAttribute(kblock_size);
+    }
+    if (node->hasAttribute(koutput_dtype)) {
+      if (node->i(koutput_dtype) != TensorProto_DataType_UINT8 && node->inputs().size() < 3) {
+        ONNX_ASSERTM(
+            false,
+            "Attribute output_dtype is not supported for Opset Version ",
+            static_cast<int64_t>(target_version().version()),
+            ", supply a zero-point tensor instead")
+      }
+      node->removeAttribute(koutput_dtype);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_type_restriction(graph, node);
+    adapt_quantize_linear_21_20(graph, node);
+    return node;
+  }
+};
+
+class DequantizeLinear_21_20 final : public TypeRestriction {
+ public:
+  explicit DequantizeLinear_21_20()
+      : TypeRestriction("DequantizeLinear", OpSetID(21), OpSetID(20), q_dq_20_unallowed_types) {}
+
+  void adapt_dequantize_linear_21_20(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    if (node->hasAttribute(kblock_size)) {
+      if ((node->i(kblock_size) != 0)) {
+        ONNX_ASSERTM(
+            false,
+            "Blocked quantization is not supported for Opset Version ",
+            static_cast<int64_t>(target_version().version()),
+            ".")
+      }
+      node->removeAttribute(kblock_size);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_type_restriction(graph, node);
+    adapt_dequantize_linear_21_20(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/range_27_26.h b/onnx/version_converter/adapters/range_27_26.h
new file mode 100644
index 0000000..438b5ce
--- /dev/null
+++ b/onnx/version_converter/adapters/range_27_26.h
@@ -0,0 +1,61 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Range in default domain from version 27 to 26
+
+#pragma once
+
+#include <cinttypes>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Range_27_26 final : public Adapter {
+ public:
+  explicit Range_27_26(const std::vector<TensorProto_DataType>& unallowed_types)
+      : Adapter("Range", OpSetID(27), OpSetID(26)), unallowed_types_(unallowed_types) {}
+
+  Node* adapt(std::shared_ptr<Graph> /*graph*/, Node* node) const override {
+    // Reject FLOAT16/BFLOAT16 inputs or outputs — not supported by Range v11.
+    for (const Value* input : node->inputs()) {
+      ONNX_ASSERTM(
+          std::find(unallowed_types_.begin(), unallowed_types_.end(), input->elemType()) == unallowed_types_.end(),
+          "DataType (",
+          input->elemType(),
+          ") of input of operator '",
+          name(),
+          "' is not supported in Opset Version ",
+          static_cast<int64_t>(target_version().version()),
+          ".");
+    }
+    for (const Value* output : node->outputs()) {
+      ONNX_ASSERTM(
+          std::find(unallowed_types_.begin(), unallowed_types_.end(), output->elemType()) == unallowed_types_.end(),
+          "DataType (",
+          output->elemType(),
+          ") of output of operator '",
+          name(),
+          "' is not supported in Opset Version ",
+          static_cast<int64_t>(target_version().version()),
+          ".");
+    }
+    // Remove stash_type — Range v11 has no such attribute.
+    if (node->hasAttribute(kstash_type)) {
+      node->removeAttribute(kstash_type);
+    }
+    return node;
+  }
+
+ private:
+  std::vector<TensorProto_DataType> unallowed_types_;
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/remove_consumed_inputs.h b/onnx/version_converter/adapters/remove_consumed_inputs.h
new file mode 100644
index 0000000..aaaa5c0
--- /dev/null
+++ b/onnx/version_converter/adapters/remove_consumed_inputs.h
@@ -0,0 +1,30 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for all ops that remove consumed_inputs
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class RemoveConsumedInputs : public Adapter {
+ public:
+  explicit RemoveConsumedInputs(const std::string& op_name, const OpSetID& initial, const OpSetID& target)
+      : Adapter(op_name, initial, target) {}
+
+  Node* adapt(std::shared_ptr<Graph> /*unused*/, Node* node) const override {
+    if (node->hasAttribute(kconsumed_inputs))
+      node->removeAttribute(kconsumed_inputs);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/reshape_4_5.h b/onnx/version_converter/adapters/reshape_4_5.h
new file mode 100644
index 0000000..50a6618
--- /dev/null
+++ b/onnx/version_converter/adapters/reshape_4_5.h
@@ -0,0 +1,49 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Reshape in default domain from version 4 to 5
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/remove_consumed_inputs.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Reshape_4_5 final : public RemoveConsumedInputs {
+ public:
+  explicit Reshape_4_5() : RemoveConsumedInputs("Reshape", OpSetID(4), OpSetID(5)) {}
+
+  void adapt_reshape_4_5(const std::shared_ptr<Graph>& graph, Node* node) const {
+    // Create Input from Attribute - add as Initializer
+    // Create tensor for value attribute
+    Tensor t;
+    t.elem_type() = TensorProto_DataType_INT64;
+    t.sizes() = std::vector<int64_t>{static_cast<int64_t>(node->is(kshape).size())};
+    auto& data = t.int64s();
+    // Turn shapes attribute into tensor
+    for (int64_t shape : node->is(kshape)) {
+      data.emplace_back(shape);
+    }
+    // Add value as input to node
+    Node* constant = graph->create(kConstant);
+    constant->insertBefore(node);
+    constant->t_(kvalue, t);
+    node->addInput(constant->output());
+    // Remove kshape attribute
+    node->removeAttribute(kshape);
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    RemoveConsumedInputs::adapt(graph, node);
+    adapt_reshape_4_5(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/reshape_5_4.h b/onnx/version_converter/adapters/reshape_5_4.h
new file mode 100644
index 0000000..2f823ac
--- /dev/null
+++ b/onnx/version_converter/adapters/reshape_5_4.h
@@ -0,0 +1,65 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Reshape in default domain from version 5 to 4
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Reshape_5_4 final : public Adapter {
+ public:
+  explicit Reshape_5_4() : Adapter("Reshape", OpSetID(5), OpSetID(4)) {}
+
+  void adapt_reshape_5_4(const std::shared_ptr<Graph>& graph, Node* node) const {
+    // Identify if shape is statically determined; if so, feed as attribute
+    const ArrayRef<Value*>& inputs = node->inputs();
+    // Check if shape input is provided (it's optional in some contexts)
+    if (inputs.size() <= 1) {
+      // No shape input provided, nothing to convert
+      return;
+    }
+    // Get shape from initializer or constant operator, not actual shape
+    // Identify whether we have a Constant Op or an Initializer
+    Value* const_val = inputs[1];
+    Node* node_ptr = const_val->node();
+    if (node_ptr->kind() == kConstant) {
+      node->is_(kshape, ReadInt64Tensor(node_ptr->t(kvalue)));
+      // If Constant node isn't used anywhere else, remove it
+      node->removeInput(1);
+      if (const_val->uses().empty()) {
+        node_ptr->destroy();
+      }
+    } else {
+      // Get Value name, find Initializer with same name
+      for (const auto& initializer : graph->initializers()) {
+        if (initializer.name() == inputs[1]->uniqueName()) {
+          node->is_(kshape, ReadInt64Tensor(initializer));
+          node->removeInput(1);
+          // Remove initializer
+          if (const_val->uses().empty())
+            graph->eraseInitializerAndInput(const_val);
+          break;
+        }
+      }
+    }
+    ONNX_ASSERTM(node->hasAttribute(kshape), "No initializer or constant input to Reshape node found")
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_reshape_5_4(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/resize_10_11.h b/onnx/version_converter/adapters/resize_10_11.h
new file mode 100644
index 0000000..1980985
--- /dev/null
+++ b/onnx/version_converter/adapters/resize_10_11.h
@@ -0,0 +1,53 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Resize in default domain from version 10 to 11
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Resize_10_11 final : public Adapter {
+ public:
+  explicit Resize_10_11() : Adapter("Resize", OpSetID(10), OpSetID(11)) {}
+
+  void adapt_resize_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+    ONNX_ASSERTM(inputs.size() >= 2, "Resize in opset 10 needs to have at least 2 inputs.")
+
+    int64_t input_rank = inputs[0]->sizes().size();
+
+    Value* scales_input = inputs[1];
+    node->addInput(scales_input);
+
+    Tensor t;
+    t.sizes() = std::vector<int64_t>{2 * input_rank};
+    t.elem_type() = TensorProto_DataType_FLOAT;
+    auto& data = t.floats();
+
+    for (int i = 0; i < input_rank; i++)
+      data.emplace_back(0.0f);
+    for (int i = 0; i < input_rank; i++)
+      data.emplace_back(1.0f);
+
+    Node* constant = graph->create(kConstant);
+    constant->insertBefore(node);
+    constant->t_(kvalue, t);
+    node->replaceInput(1, constant->output());
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_resize_10_11(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/scan_8_9.h b/onnx/version_converter/adapters/scan_8_9.h
new file mode 100644
index 0000000..d4d17a9
--- /dev/null
+++ b/onnx/version_converter/adapters/scan_8_9.h
@@ -0,0 +1,65 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Scan in default domain from version 8 to 9
+
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+struct Scan_8_9 final : public Adapter {
+  explicit Scan_8_9() : Adapter("Scan", OpSetID(8), OpSetID(9)) {}
+
+  void adapt_scan_8_9(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    const std::vector<Value*> inputs(node->inputs().vec());
+    const std::vector<Value*> outputs(node->outputs().vec());
+
+    // Validate preconditions before mutating the node, so a failed assertion
+    // doesn't leave the graph in a partially-converted state.
+    ONNX_ASSERTM(!inputs.empty(), "Scan node in opset 8 must have at least 1 input")
+    ONNX_ASSERTM(inputs[0]->uniqueName().empty(), "Unsupported conversion to opset 9")
+
+    // Handling Attribute Changes
+
+    Symbol dirs = Symbol("directions");
+    if (node->hasAttribute(dirs)) {
+      std::vector<int64_t> directions(node->is(dirs));
+      node->removeAttribute(dirs);
+      node->is_(Symbol("scan_input_directions"), std::move(directions));
+    }
+
+    // Handling Input and Output Changes
+
+    node->removeAllInputs();
+
+    for (Value* input : inputs) {
+      if (!input->sizes().empty()) {
+        std::vector<Dimension> new_sizes(input->sizes().begin() + 1, input->sizes().end());
+        input->setSizes(new_sizes);
+        node->addInput(input);
+      }
+    }
+
+    for (Value* output : outputs) {
+      if (!output->sizes().empty()) {
+        std::vector<Dimension> new_sizes(output->sizes().begin() + 1, output->sizes().end());
+        output->setSizes(new_sizes);
+      }
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_scan_8_9(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/scan_9_8.h b/onnx/version_converter/adapters/scan_9_8.h
new file mode 100644
index 0000000..3cdd35f
--- /dev/null
+++ b/onnx/version_converter/adapters/scan_9_8.h
@@ -0,0 +1,93 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Scan in default domain from version 9 to 8
+
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+struct Scan_9_8 final : public Adapter {
+  explicit Scan_9_8() : Adapter("Scan", OpSetID(9), OpSetID(8)) {}
+
+  void adapt_scan_9_8(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    ONNX_ASSERTM(node != nullptr, "Scan node is null")
+    ONNX_ASSERTM(node->owningGraph() != nullptr, "Scan node does not belong to a graph")
+    const std::vector<Value*> inputs(node->inputs().vec());
+    const std::vector<Value*> outputs(node->outputs().vec());
+
+    // Handling Attribute Changes
+
+    Symbol input_dirs = Symbol("scan_input_directions");
+    if (node->hasAttribute(input_dirs)) {
+      std::vector<int64_t> scan_input_directions(node->is(input_dirs));
+      node->removeAttribute(input_dirs);
+      node->is_(Symbol("directions"), std::move(scan_input_directions));
+    }
+
+    Symbol output_dirs = Symbol("scan_output_directions");
+    if (node->hasAttribute(output_dirs)) {
+      const std::vector<int64_t> scan_output_directions(node->is(output_dirs));
+      for (int64_t x : scan_output_directions) {
+        ONNX_ASSERTM(x == 0, "Unsupported output direction for Version 8")
+      }
+      node->removeAttribute(output_dirs);
+    }
+
+    Symbol input_axes = Symbol("scan_input_axes");
+    if (node->hasAttribute(input_axes)) {
+      const std::vector<int64_t> scan_input_axes(node->is(input_axes));
+      for (int64_t x : scan_input_axes) {
+        ONNX_ASSERTM(x == 0, "Unsupported input axes for Version 8")
+      }
+      node->removeAttribute(input_axes);
+    }
+
+    Symbol output_axes = Symbol("scan_output_axes");
+    if (node->hasAttribute(output_axes)) {
+      const std::vector<int64_t> scan_output_axes(node->is(output_axes));
+      for (int64_t x : scan_output_axes) {
+        ONNX_ASSERTM(x == 0, "Unsupported output axes for Version 8")
+      }
+      node->removeAttribute(output_axes);
+    }
+
+    // Handling Input and Output Changes
+
+    node->removeAllInputs();
+
+    Value* v = node->owningGraph()->createValue(*node, 0);
+    v->setUniqueName("");
+    v->setElemType(TensorProto_DataType::TensorProto_DataType_INT32);
+    node->addInput(v);
+
+    for (Value* input : inputs) {
+      std::vector<Dimension> new_sizes{Dimension(1)};
+      new_sizes.insert(new_sizes.end(), input->sizes().begin(), input->sizes().end());
+      input->setSizes(new_sizes);
+      node->addInput(input);
+    }
+
+    for (Value* output : outputs) {
+      std::vector<Dimension> new_sizes{Dimension(1)};
+      new_sizes.insert(new_sizes.end(), output->sizes().begin(), output->sizes().end());
+      output->setSizes(new_sizes);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_scan_9_8(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/scatter_10_11.h b/onnx/version_converter/adapters/scatter_10_11.h
new file mode 100644
index 0000000..d9f2684
--- /dev/null
+++ b/onnx/version_converter/adapters/scatter_10_11.h
@@ -0,0 +1,46 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Scatter in default domain from version 10 to 11
+
+#pragma once
+
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Scatter_10_11 final : public Adapter {
+ public:
+  explicit Scatter_10_11() : Adapter("Scatter", OpSetID(10), OpSetID(11)) {}
+
+  Node* adapt_scatter_10_11(const std::shared_ptr<Graph>& graph, Node* node) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+    ONNX_ASSERTM(inputs.size() >= 3, "Scatter in opset 10 needs to have at least 3 inputs.")
+
+    int axis = node->hasAttribute(kaxis) ? static_cast<int>(node->i(kaxis)) : 0;
+
+    // Replace the node with an equivalent ScatterElements node
+    Node* scatter_elements = graph->create(kScatterElements);
+    scatter_elements->i_(kaxis, axis);
+    scatter_elements->addInput(inputs[0]);
+    scatter_elements->addInput(inputs[1]);
+    scatter_elements->addInput(inputs[2]);
+    node->replaceAllUsesWith(scatter_elements);
+
+    scatter_elements->insertBefore(node);
+    node->destroy();
+
+    return scatter_elements;
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    return adapt_scatter_10_11(graph, node);
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/scatter_16_15.h b/onnx/version_converter/adapters/scatter_16_15.h
new file mode 100644
index 0000000..a086671
--- /dev/null
+++ b/onnx/version_converter/adapters/scatter_16_15.h
@@ -0,0 +1,66 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for ScatterElements and ScatterND in default domain from version 16 to 15.
+// Opset 16 added bfloat16 and 'reduction' attribute; downgrading requires type
+// restriction and removal of reduction (only "none" allowed).
+
+#pragma once
+
+#include <algorithm>
+#include <cinttypes>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "onnx/common/interned_strings.h"
+#include "onnx/version_converter/adapters/adapter.h"
+#include "onnx/version_converter/adapters/transformers.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Scatter_16_15 : public Adapter {
+ public:
+  explicit Scatter_16_15(
+      const std::string& op_name,
+      const OpSetID& initial,
+      const OpSetID& target,
+      const std::vector<TensorProto_DataType>& unallowed_types)
+      : Adapter(op_name, initial, target), unallowed_types_(unallowed_types) {}
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_type_restriction(graph, node);
+    RemoveAttribute(Symbol("reduction"), std::string("none"))(graph, node);
+    return node;
+  }
+
+ private:
+  std::vector<TensorProto_DataType> unallowed_types_;
+
+  void adapt_type_restriction(const std::shared_ptr<Graph>& /*unused*/, const Node* node) const {
+    for (const Value* input : node->inputs()) {
+      isUnallowed(input);
+    }
+    for (const Value* output : node->outputs()) {
+      isUnallowed(output);
+    }
+  }
+
+  void isUnallowed(const Value* val) const {
+    ONNX_ASSERTM(
+        std::find(std::begin(unallowed_types_), std::end(unallowed_types_), val->elemType()) ==
+            std::end(unallowed_types_),
+        "DataType (",
+        val->elemType(),
+        ") of Input or Output of operator '",
+        name(),
+        "' is unallowed for Opset Version ",
+        static_cast<int64_t>(target_version().version()),
+        ".")
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/scatter_18_17.h b/onnx/version_converter/adapters/scatter_18_17.h
new file mode 100644
index 0000000..0109945
--- /dev/null
+++ b/onnx/version_converter/adapters/scatter_18_17.h
@@ -0,0 +1,33 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for ScatterElements and ScatterND in default domain from version 18 to 17.
+// Opset 18 added reduction values "max" and "min"; downgrading rejects those.
+
+#pragma once
+
+#include <string>
+
+#include "onnx/common/interned_strings.h"
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Scatter_18_17 : public Adapter {
+ public:
+  explicit Scatter_18_17(const std::string& op_name) : Adapter(op_name, OpSetID(18), OpSetID(17)) {}
+
+  Node* adapt(std::shared_ptr<Graph> /*graph*/, Node* node) const override {
+    if (node->hasAttribute(Symbol("reduction"))) {
+      const std::string& r = node->s(Symbol("reduction"));
+      ONNX_ASSERTM(
+          r != "max" && r != "min", "Scatter reduction 'max' and 'min' are not supported when downgrading to opset 17")
+    }
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/slice_9_10.h b/onnx/version_converter/adapters/slice_9_10.h
new file mode 100644
index 0000000..5a59b38
--- /dev/null
+++ b/onnx/version_converter/adapters/slice_9_10.h
@@ -0,0 +1,54 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Slice in default domain from version 9 to 10
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Slice_9_10 final : public Adapter {
+ public:
+  explicit Slice_9_10() : Adapter("Slice", OpSetID(9), OpSetID(10)) {}
+
+  void attrToInput(const std::shared_ptr<Graph>& graph, Node* node, const std::vector<int64_t>& attr) const {
+    Tensor t;
+    t.elem_type() = TensorProto_DataType_INT64;
+    t.sizes() = std::vector<int64_t>{static_cast<int64_t>(attr.size())};
+    auto& data = t.int64s();
+    for (auto a : attr) {
+      data.emplace_back(a);
+    }
+    Node* constant = graph->create(kConstant);
+    constant->insertBefore(node);
+    constant->t_(kvalue, t);
+    node->addInput(constant->output());
+  }
+
+  void adapt_slice_9_10(const std::shared_ptr<Graph>& graph, Node* node) const {
+    attrToInput(graph, node, node->is(kstarts));
+    node->removeAttribute(kstarts);
+    attrToInput(graph, node, node->is(kends));
+    node->removeAttribute(kends);
+
+    if (node->hasAttribute(kaxes)) {
+      attrToInput(graph, node, node->is(kaxes));
+      node->removeAttribute(kaxes);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_slice_9_10(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/softmax_12_13.h b/onnx/version_converter/adapters/softmax_12_13.h
new file mode 100644
index 0000000..eb83dbf
--- /dev/null
+++ b/onnx/version_converter/adapters/softmax_12_13.h
@@ -0,0 +1,86 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Softmax amd LogSoftmax in default domain from version 12 to 13
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Softmax_12_13 final : public Adapter {
+ public:
+  explicit Softmax_12_13(const std::string& op_name) : Adapter(op_name, OpSetID(12), OpSetID(13)) {}
+
+  void adapt_softmax_12_13(const std::shared_ptr<Graph>& graph, Node* node) const {
+    ONNX_ASSERTM(node->inputs().size() >= 1, "Softmax node must have at least 1 input")
+    int old_axis = node->hasAttribute(kaxis) ? static_cast<int>(node->i(kaxis)) : 1;
+    int input_rank = static_cast<int>(node->inputs()[0]->sizes().size());
+
+    if (old_axis < 0)
+      old_axis = input_rank + old_axis;
+
+    if (old_axis == input_rank - 1) {
+      node->i_(kaxis, -1);
+    } else {
+      //    -- shape ------------------
+      //   /                           |
+      // ----- flatten -- softmax -- reshape
+
+      // get original softmax's input shape
+      Symbol kShape("Shape");
+      Node* shape = graph->create(kShape);
+      shape->addInput(node->inputs()[0]);
+      shape->insertBefore(node);
+
+      // Insert Flatten node before softmax
+      Node* flatten = graph->create(kFlatten);
+      flatten->addInput(node->inputs()[0]);
+      flatten->insertBefore(node);
+      flatten->i_(kaxis, old_axis);
+      node->replaceInput(0, flatten->output());
+
+      // Softmax along the last axis of the flattened 2D tensor
+      node->i_(kaxis, -1);
+
+      // Insert Reshape node after softmax
+      const std::string original_output_name = node->output()->uniqueName();
+      const use_list original_uses(node->output()->uses());
+      node->output()->setUniqueName(original_output_name + "_intermediate");
+      Node* reshape = graph->create(kReshape);
+      reshape->addInput(node->outputs()[0]);
+      reshape->addInput(shape->output());
+      reshape->output()->setUniqueName(original_output_name);
+      reshape->insertAfter(node);
+
+      // Fix outputs & wiring
+      if (!node->output()->sizes().empty()) {
+        reshape->output()->setSizes(node->output()->sizes());
+      }
+      reshape->output()->setElemType(node->output()->elemType());
+      node->output()->wipeSizes();
+      for (Use u : original_uses) {
+        u.user->replaceInputWith(node->output(), reshape->output());
+      }
+      for (size_t i = 0; i < graph->outputs().size(); i++) {
+        if (graph->outputs()[i]->uniqueName() == original_output_name) {
+          graph->return_node()->replaceInput(i, reshape->output());
+        }
+      }
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_softmax_12_13(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/softmax_13_12.h b/onnx/version_converter/adapters/softmax_13_12.h
new file mode 100644
index 0000000..f2c51cc
--- /dev/null
+++ b/onnx/version_converter/adapters/softmax_13_12.h
@@ -0,0 +1,66 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Softmax and LogSoftmax in default domain from version 13 to 12
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Softmax_13_12 final : public Adapter {
+ public:
+  explicit Softmax_13_12(const std::string& op_name) : Adapter(op_name, OpSetID(13), OpSetID(12)) {}
+
+  void adapt_softmax_13_12(const std::shared_ptr<Graph>& graph, Node* node) const {
+    (void)graph; // Suppress unused parameter warning
+    ONNX_ASSERTM(node->inputs().size() >= 1, "Softmax node must have at least 1 input")
+
+    int new_axis = node->hasAttribute(kaxis) ? static_cast<int>(node->i(kaxis)) : -1;
+
+    // Handle Softmax on the last axis (default behavior in opset 13)
+    if (new_axis == -1) {
+      new_axis = static_cast<int>(node->inputs()[0]->sizes().size()) - 1;
+      node->i_(kaxis, new_axis);
+    } else if (new_axis < 0) {
+      // Handle negative axis by converting it to positive
+      int input_rank = static_cast<int>(node->inputs()[0]->sizes().size());
+      new_axis = input_rank + new_axis;
+      node->i_(kaxis, new_axis);
+    }
+
+    // Flatten and Reshape nodes added in opset 13 must be removed
+    // Check for Flatten node before Softmax and Reshape node after Softmax
+    if (node->inputs()[0]->node()->kind() == kFlatten) {
+      Node* flatten = node->inputs()[0]->node();
+      ONNX_ASSERTM(flatten->inputs().size() >= 1, "Flatten node must have at least 1 input")
+      auto* const flatten_input = flatten->inputs()[0];
+      node->replaceInput(0, flatten_input);
+      flatten->destroy();
+    }
+
+    for (Use u : node->output()->uses()) {
+      if (u.user->kind() == kReshape) {
+        Node* reshape = u.user;
+        auto* const reshape_output = reshape->outputs()[0];
+        node->output()->replaceAllUsesWith(reshape_output);
+        reshape->destroy();
+        break;
+      }
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_softmax_13_12(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/split_12_13.h b/onnx/version_converter/adapters/split_12_13.h
new file mode 100644
index 0000000..008de14
--- /dev/null
+++ b/onnx/version_converter/adapters/split_12_13.h
@@ -0,0 +1,45 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for all ops that remove consumed_inputs
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Split_12_13 : public Adapter {
+ public:
+  explicit Split_12_13() : Adapter("Split", OpSetID(12), OpSetID(13)) {}
+
+  void attrToInput(const std::shared_ptr<Graph>& graph, Node* node, const std::vector<int64_t>& axes) const {
+    Tensor t;
+    t.elem_type() = TensorProto_DataType_INT64;
+    t.sizes() = std::vector<int64_t>{static_cast<int64_t>(axes.size())};
+    auto& data = t.int64s();
+    for (auto a : axes) {
+      data.emplace_back(a);
+    }
+    Node* constant = graph->create(kConstant);
+    constant->insertBefore(node);
+    constant->t_(kvalue, t);
+    node->addInput(constant->output());
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    if (node->hasAttribute(ksplit)) {
+      attrToInput(graph, node, node->is(ksplit));
+      node->removeAttribute(ksplit);
+    }
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/split_13_12.h b/onnx/version_converter/adapters/split_13_12.h
new file mode 100644
index 0000000..7b0d270
--- /dev/null
+++ b/onnx/version_converter/adapters/split_13_12.h
@@ -0,0 +1,61 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for all ops that remove consumed_inputs
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Split_13_12 : public Adapter {
+ public:
+  explicit Split_13_12() : Adapter("Split", OpSetID(13), OpSetID(12)) {}
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    // Identify if 'split' is statically determined; if so, feed as attribute
+    const ArrayRef<Value*>& inputs = node->inputs();
+    // Check if split input is provided (it's optional)
+    if (inputs.size() <= 1) {
+      // No split input provided, nothing to convert
+      return node;
+    }
+    // Get 'split' from initializer or constant operator
+    // Identify whether we have a Constant Op or an Initializer
+    Value* const_val = inputs[1];
+    Node* node_ptr = const_val->node();
+    if (node_ptr->kind() == kConstant) {
+      node->is_(ksplit, ReadInt64Tensor(node_ptr->t(kvalue)));
+      // If Constant node isn't used anywhere else, remove it
+      node->removeInput(1);
+      if (const_val->uses().empty()) {
+        node_ptr->destroy();
+      }
+    } else {
+      // Get Value name, find Initializer with same name
+      for (const auto& initializer : graph->initializers()) {
+        if (initializer.name() == inputs[1]->uniqueName()) {
+          node->is_(ksplit, ReadInt64Tensor(initializer));
+          node->removeInput(1);
+          // Remove initializer
+          if (const_val->uses().empty())
+            graph->eraseInitializerAndInput(const_val);
+          break;
+        }
+      }
+    }
+    ONNX_ASSERTM(node->hasAttribute(ksplit), "No initializer or constant input to node found")
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/split_17_18.h b/onnx/version_converter/adapters/split_17_18.h
new file mode 100644
index 0000000..08ea81f
--- /dev/null
+++ b/onnx/version_converter/adapters/split_17_18.h
@@ -0,0 +1,36 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Split in default domain from version 17 to 18
+
+#pragma once
+
+#include <memory>
+
+#include "onnx/version_converter/adapters/adapter.h"
+#include "onnx/version_converter/adapters/transformers.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Split_17_18 : public Adapter {
+ public:
+  explicit Split_17_18() : Adapter("Split", OpSetID(17), OpSetID(18)) {}
+
+  void adapt_split_17_18(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    const auto num_outputs = node->outputs().size();
+    node->i_(knum_outputs, num_outputs);
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    // if node does not have neither 'num_outputs' attribute nor 'split' input
+    if (!node->hasAttribute(knum_outputs) && node->inputs().size() != 2) {
+      adapt_split_17_18(graph, node);
+    }
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/sum_8_7.h b/onnx/version_converter/adapters/sum_8_7.h
new file mode 100644
index 0000000..8dbbea0
--- /dev/null
+++ b/onnx/version_converter/adapters/sum_8_7.h
@@ -0,0 +1,39 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Sum in default domain from version 8 to 7
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Sum_8_7 final : public Adapter {
+ public:
+  explicit Sum_8_7() : Adapter("Sum", OpSetID(8), OpSetID(7)) {}
+
+  void adapt_sum_8_7(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    // Throw an exception if any broadcasting occurs
+    const ArrayRef<Value*>& inputs = node->inputs();
+    // Determine if inputs are of different sizes
+    for (size_t i = 1; i < inputs.size(); i++) {
+      std::vector<Dimension> A_sizes = inputs[i - 1]->sizes();
+      std::vector<Dimension> B_sizes = inputs[i]->sizes();
+      assert_numpy_multibroadcastable(A_sizes, B_sizes);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_sum_8_7(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/topk_9_10.h b/onnx/version_converter/adapters/topk_9_10.h
new file mode 100644
index 0000000..1d1568e
--- /dev/null
+++ b/onnx/version_converter/adapters/topk_9_10.h
@@ -0,0 +1,43 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for TopK in default domain from version 9 to 10
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class TopK_9_10 final : public Adapter {
+ public:
+  explicit TopK_9_10() : Adapter("TopK", OpSetID(9), OpSetID(10)) {}
+
+  void adapt_topk_9_10(const std::shared_ptr<Graph>& graph, Node* node) const {
+    Tensor t;
+    t.elem_type() = TensorProto_DataType_INT64;
+    t.sizes() = std::vector<int64_t>{1};
+    auto& data = t.int64s();
+    data.emplace_back(node->i(kk));
+
+    Node* constant = graph->create(kConstant);
+    constant->insertBefore(node);
+    constant->t_(kvalue, t);
+    node->addInput(constant->output());
+
+    node->removeAttribute(kk);
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_topk_9_10(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/transformers.h b/onnx/version_converter/adapters/transformers.h
new file mode 100644
index 0000000..f1a9adc
--- /dev/null
+++ b/onnx/version_converter/adapters/transformers.h
@@ -0,0 +1,100 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cinttypes>
+#include <string>
+#include <vector>
+
+#include "onnx/common/interned_strings.h"
+#include "onnx/version_converter/adapters/adapter.h"
+
+// Node transformers commonly used in version-adapters:
+
+// Capture context by copying values; the graph is unused by these transformers.
+
+// NOLINTNEXTLINE(bugprone-macro-parentheses)
+#define NODE_TRANSFORMER(node) [=](const std::shared_ptr<Graph>&, Node* node)
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+inline NodeTransformerFunction RemoveAttribute(Symbol attr) {
+  return NODE_TRANSFORMER(node) {
+    if (node->hasAttribute(attr)) {
+      node->removeAttribute(attr);
+    }
+    return node;
+  };
+}
+
+inline NodeTransformerFunction RemoveAttribute(Symbol attr, int64_t value) {
+  return NODE_TRANSFORMER(node) {
+    if (node->hasAttribute(attr)) {
+      ONNX_ASSERTM(node->i(attr) == value, "Attribute ", attr.toString(), " must have value ", value)
+      node->removeAttribute(attr);
+    }
+    return node;
+  };
+}
+
+inline NodeTransformerFunction RemoveAttribute(Symbol attr, const std::string& value) {
+  return NODE_TRANSFORMER(node) {
+    if (node->hasAttribute(attr)) {
+      ONNX_ASSERTM(
+          node->s(attr) == value,
+          "Attribute ",
+          attr.toString(),
+          " must have value ",
+          value,
+          " for this version conversion")
+      node->removeAttribute(attr);
+    }
+    return node;
+  };
+}
+
+inline NodeTransformerFunction RemoveAttributeNotEq(Symbol attr, int64_t value) {
+  return NODE_TRANSFORMER(node) {
+    if (node->hasAttribute(attr)) {
+      ONNX_ASSERTM(node->i(attr) != value, "Attribute ", attr.toString(), " must not have value ", value)
+      node->removeAttribute(attr);
+    }
+    return node;
+  };
+}
+
+inline NodeTransformerFunction SetAttribute(Symbol attr, int64_t value) {
+  return NODE_TRANSFORMER(node) {
+    node->i_(attr, value);
+    return node;
+  };
+}
+
+inline NodeTransformerFunction SetAttribute(Symbol attr, const std::string& value) {
+  return NODE_TRANSFORMER(node) {
+    node->s_(attr, value);
+    return node;
+  };
+}
+
+inline NodeTransformerFunction SetAttribute(Symbol attr, const std::vector<int64_t>& value) {
+  return NODE_TRANSFORMER(node) {
+    node->is_(attr, std::vector<int64_t>(value));
+    return node;
+  };
+}
+
+inline NodeTransformerFunction SetAttributeIfAbsent(Symbol attr, int64_t value) {
+  return NODE_TRANSFORMER(node) {
+    if (!node->hasAttribute(attr)) {
+      node->i_(attr, value);
+    }
+    return node;
+  };
+}
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/type_restriction.h b/onnx/version_converter/adapters/type_restriction.h
new file mode 100644
index 0000000..7a1d015
--- /dev/null
+++ b/onnx/version_converter/adapters/type_restriction.h
@@ -0,0 +1,63 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Add in default domain from version 6 to 5
+
+#pragma once
+
+#include <cinttypes>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class TypeRestriction : public Adapter {
+ public:
+  explicit TypeRestriction(
+      const std::string& op_name,
+      const OpSetID& initial,
+      const OpSetID& target,
+      const std::vector<TensorProto_DataType>& unallowed_types)
+      : Adapter(op_name, initial, target), unallowed_types_(unallowed_types) {}
+
+  void adapt_type_restriction(const std::shared_ptr<Graph>& /*unused*/, const Node* node) const {
+    // Since consumed_inputs is optional, no need to add it (as in batchnorm)
+    // Iterate over all inputs and outputs
+    for (const Value* input : node->inputs()) {
+      isUnallowed(input);
+    }
+    for (const Value* output : node->outputs()) {
+      isUnallowed(output);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_type_restriction(graph, node);
+    return node;
+  }
+
+ private:
+  std::vector<TensorProto_DataType> unallowed_types_;
+
+  void isUnallowed(const Value* val) const {
+    ONNX_ASSERTM(
+        std::find(std::begin(unallowed_types_), std::end(unallowed_types_), val->elemType()) ==
+            std::end(unallowed_types_),
+        "DataType (",
+        val->elemType(),
+        ") of Input or Output of operator '",
+        name(),
+        "' is unallowed for Opset Version ",
+        static_cast<int64_t>(target_version().version()),
+        ".")
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/upsample_6_7.h b/onnx/version_converter/adapters/upsample_6_7.h
new file mode 100644
index 0000000..02a3835
--- /dev/null
+++ b/onnx/version_converter/adapters/upsample_6_7.h
@@ -0,0 +1,48 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Upsample in default domain from version 6 to 7
+
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+struct Upsample_6_7 final : public Adapter {
+  explicit Upsample_6_7() : Adapter("Upsample", OpSetID(6), OpSetID(7)) {}
+
+  void adapt_upsample_6_7(const std::shared_ptr<Graph>& /*unused*/, Node* node) const {
+    Symbol width_scale_symbol = Symbol("width_scale");
+    Symbol height_scale_symbol = Symbol("height_scale");
+    ONNX_ASSERTM(
+        node->hasAttribute(width_scale_symbol) && node->hasAttribute(height_scale_symbol),
+        "Upsample in opset 1 needs to have width_scale and height_scale attributes")
+
+    auto width_scale = node->f(width_scale_symbol);
+    auto height_scale = node->f(height_scale_symbol);
+
+    ONNX_ASSERTM(node->inputs().size() >= 1, "Upsample node must have at least 1 input")
+    auto input_shape = node->inputs()[0]->sizes();
+    ONNX_ASSERTM(input_shape.size() == 4, "Upsample in opset 1 supports only 4D input tensor")
+    std::vector<double> scales = {1.0, 1.0, height_scale, width_scale};
+
+    node->fs_(kscales, std::move(scales));
+    node->removeAttribute(width_scale_symbol);
+    node->removeAttribute(height_scale_symbol);
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_upsample_6_7(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/upsample_8_9.h b/onnx/version_converter/adapters/upsample_8_9.h
new file mode 100644
index 0000000..69d389c
--- /dev/null
+++ b/onnx/version_converter/adapters/upsample_8_9.h
@@ -0,0 +1,48 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Upsample in default domain from version 8 to 9
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+struct Upsample_8_9 final : public Adapter {
+  explicit Upsample_8_9() : Adapter("Upsample", OpSetID(8), OpSetID(9)) {}
+
+  void adapt_upsample_8_9(const std::shared_ptr<Graph>& graph, Node* node) const {
+    Symbol input_dirs = Symbol("scales");
+    int dim = static_cast<int>(node->fs(kscales).size());
+    Tensor t;
+    t.elem_type() = TensorProto_DataType_FLOAT;
+    t.sizes() = std::vector<int64_t>{dim};
+    auto& data = t.floats();
+
+    if (node->hasAttribute(input_dirs)) {
+      for (double scale : node->fs(kscales)) {
+        data.emplace_back(static_cast<float>(scale));
+      }
+
+      Node* constant = graph->create(kConstant);
+      constant->insertBefore(node);
+      constant->t_(kvalue, t);
+      node->addInput(constant->output());
+      node->removeAttribute(kscales);
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_upsample_8_9(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/upsample_9_10.h b/onnx/version_converter/adapters/upsample_9_10.h
new file mode 100644
index 0000000..4ef5d60
--- /dev/null
+++ b/onnx/version_converter/adapters/upsample_9_10.h
@@ -0,0 +1,44 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Upsample in default domain from version 9 to 10
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "onnx/common/ir.h"
+#include "onnx/version_converter/adapters/adapter.h"
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Upsample_9_10 final : public Adapter {
+ public:
+  explicit Upsample_9_10() : Adapter("Upsample", OpSetID(9), OpSetID(10)) {}
+
+  Node* adapt_upsample_9_10(const std::shared_ptr<Graph>& graph, Node* node) const {
+    ONNX_ASSERTM(node->inputs().size() >= 2, "Upsample node must have at least 2 inputs")
+    std::string mode = node->hasAttribute(kmode) ? node->s(kmode) : "nearest";
+
+    // Replace the node with an equivalent Resize node
+    Node* resize = graph->create(kResize);
+    resize->s_(kmode, mode);
+    resize->addInput(node->inputs()[0]);
+    resize->addInput(node->inputs()[1]);
+    node->replaceAllUsesWith(resize);
+
+    resize->insertBefore(node);
+    node->destroy();
+
+    return resize;
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    return adapt_upsample_9_10(graph, node);
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/adapters/upsample_9_8.h b/onnx/version_converter/adapters/upsample_9_8.h
new file mode 100644
index 0000000..8846d2e
--- /dev/null
+++ b/onnx/version_converter/adapters/upsample_9_8.h
@@ -0,0 +1,79 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapter for Upsample in default domain from version 9 to 8
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "onnx/defs/tensor_proto_util.h"
+#include "onnx/defs/tensor_util.h"
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+struct Upsample_9_8 final : public Adapter {
+  explicit Upsample_9_8() : Adapter("Upsample", OpSetID(9), OpSetID(8)) {}
+
+  void adapt_upsample_9_8(const std::shared_ptr<Graph>& graph, Node* node) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+    const std::vector<Tensor>& initializers = graph->initializers();
+
+    ONNX_ASSERTM(inputs.size() == 2, "Upsample in opset 9 needs to have 2 inputs.")
+    // Safe to access inputs[1] after assertion above
+    std::string scale_input_name = inputs[1]->uniqueName();
+
+    for (const auto& initializer : initializers) {
+      if (initializer.name() == inputs[1]->uniqueName()) {
+        std::vector<float> value = ParseData<float>(&initializer);
+        std::vector<double> d_values;
+        d_values.reserve(value.size());
+        for (float j : value) {
+          d_values.push_back(static_cast<double>(j));
+        }
+        node->fs_(kscales, std::move(d_values));
+
+        node->removeInput(1);
+        graph->eraseInitializer(initializer.name());
+        for (size_t j = 0; j < graph->inputs().size(); j++) {
+          if (graph->inputs()[j]->uniqueName() == scale_input_name) {
+            graph->eraseInput(j);
+            break;
+          }
+        }
+        return;
+      }
+    }
+
+    for (Node* op : graph->nodes()) {
+      if (op->kind() == kConstant && !op->outputs().empty() && op->outputs()[0]->uniqueName() == scale_input_name) {
+        std::vector<float> value = ParseData<float>(&op->t(kvalue));
+        std::vector<double> d_values;
+        d_values.reserve(value.size());
+        for (float j : value) {
+          d_values.push_back(static_cast<double>(j));
+        }
+        node->fs_(kscales, std::move(d_values));
+        node->removeInput(1);
+        op->destroy();
+        return;
+      }
+    }
+
+    ONNX_ASSERTM(false, "Unsupported conversion due to unavailable input: scale")
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_upsample_9_8(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/convert.cc b/onnx/version_converter/convert.cc
new file mode 100644
index 0000000..9eea12f
--- /dev/null
+++ b/onnx/version_converter/convert.cc
@@ -0,0 +1,161 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+#include "onnx/version_converter/convert.h"
+
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include "onnx/common/ir_pb_converter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+ModelProto ConvertVersion(const ModelProto& mp_in, int target_version) {
+  // Get initial_opsetid from mp_in
+  OpSetID initial_struct(0);
+  for (const auto& it : mp_in.opset_import()) {
+    if (it.domain().empty() || it.domain() == "ai.onnx") {
+      initial_struct.setVersion(it.version());
+      break;
+    }
+  }
+  OpSetID target_struct = OpSetID(target_version);
+  DefaultVersionConverter v;
+  return v.convert_version(mp_in, initial_struct, target_struct);
+}
+
+void DefaultVersionConverter::convert_graph(
+    const std::shared_ptr<Graph>& g,
+    const OpSetID& initial_version,
+    const OpSetID& target_version) const {
+  assertNonNull(g);
+
+  // TODO(ONNX): Move to Inter-Domain Converter
+  // Get initial model versions
+  // std::vector<OpSetID> initial_versions = g->opset_versions_mutable();
+
+  // No conversion necessary if Model has single, equivalent opset version
+  // if (initial_versions.size() == 1 && initial_versions[0].version ==
+  //    target_version.version && initial_versions[0].domain ==
+  //    target_version.domain) {
+  //  return mp_in;
+  // }
+
+  // Check if versions are valid
+  assertInVersionRange(initial_version.version());
+  assertInVersionRange(target_version.version());
+
+  // Iterate over all versions to target_version for specified
+  int64_t curr_version = initial_version.version();
+  int64_t step = 0;
+  if (target_version.version() > initial_version.version()) {
+    step = 1;
+  } else {
+    step = -1;
+  }
+  // Identify index of the default domain ("" or "ai.onnx") in g.opset_versions.
+  // ImportModelProto preserves domain strings verbatim from the proto, so both
+  // spellings must be matched here (ConvertVersion also accepts both).
+  int domain_index = -1;
+  for (int i = 0; i < static_cast<int>(g->opset_versions_mutable().size()); i++) {
+    const std::string& dom = g->opset_versions_mutable()[i].domain();
+    if (dom.empty() || dom == "ai.onnx") {
+      domain_index = i;
+      break;
+    }
+  }
+  ONNX_ASSERTM(domain_index >= 0, "Graph has no default-domain (\"\" or \"ai.onnx\") opset entry")
+  while (curr_version != target_version.version()) {
+    debug(
+        "curr_version: " + ONNX_NAMESPACE::to_string(curr_version) +
+        ", next_version: " + ONNX_NAMESPACE::to_string(curr_version + step));
+    Node* cur_op = nullptr;
+    graph_node_list_iterator it = g->begin();
+    // Iterate through and call adapter returned by adapter_lookup for ops from
+    // current_version opset. We have to manipulate the iterator explicitly because cur_op
+    // might change when applying the adapter (e.g. for deprecated ops)
+    while (it != g->end()) {
+      cur_op = *it;
+      debug(std::string("Finding schema for ") + std::string(cur_op->kind().toString()));
+      const std::string op_name = cur_op->kind().toString();
+      if (op_name == "ConstantFill") {
+        if (DEBUG) {
+          std::cerr
+              << "Warning: skipping schema search for experimental op 'ConstantFill' and keeping the op as is. "
+                 "Please be advised the converted model may not be working properly if target runtime does not support this "
+                 "experimental op."
+              << '\n';
+        }
+      } else if (!cur_op->domain().empty() && cur_op->domain() != "ai.onnx") {
+        if (DEBUG) {
+          std::cerr << "Warning: opset domain '" << cur_op->domain() << "' is not supported." << '\n';
+        }
+      } else if (op_name != "Undefined" && op_name != "Captured") {
+        const auto schema_it = all_schemas.find(op_name);
+        ONNX_ASSERTM(
+            schema_it != all_schemas.end(),
+            "Op '%s' has no registered schema; cannot convert it from version %lld to %lld.",
+            op_name.c_str(),
+            static_cast<long long>(curr_version),
+            static_cast<long long>(target_version.version()));
+        const auto& op_domain_map = schema_it->second;
+        OpSetID curr_id(curr_version);
+        OpSetID next_id(curr_version + step);
+        if (searchOpDomainMap(op_domain_map, curr_version, step)) {
+          // Op is specifically defined for this domain and version
+          const auto& op_adapter = adapter_lookup(cur_op, curr_id, next_id);
+          // If adapter_lookup returns null, no adapter is present.
+          // Error thrown by adapter_lookup
+          if (DEBUG) {
+            std::cerr << "Applying adapter" << '\n';
+          }
+          // adapt should handle replacing node in graph
+          cur_op = op_adapter.adapt(g, cur_op);
+          it = graph_node_list_iterator(cur_op, kNextDirection);
+        }
+        // Recursively convert any subgraph attributes
+        for (const auto& attr : cur_op->attributeNames()) {
+          if (cur_op->kindOf(attr) == AttributeKind::g) {
+            convert_graph(cur_op->g(attr), curr_id, next_id);
+          }
+        }
+      }
+      ++it;
+    }
+    // Update model version
+    curr_version += step;
+    g->opset_versions_mutable()[static_cast<size_t>(domain_index)].incrementVersion(step);
+  }
+}
+
+ModelProto DefaultVersionConverter::convert_version(
+    const ModelProto& mp_in,
+    const OpSetID& initial_version,
+    const OpSetID& target_version) const {
+  const std::string& initial_domain = initial_version.domain();
+  const std::string& target_domain = target_version.domain();
+  assertDefaultDomain(initial_domain, target_domain);
+
+  for (auto it = mp_in.opset_import().begin(); it != mp_in.opset_import().end(); ++it) {
+    if (it->domain() == initial_version.domain()) {
+      ONNX_ASSERTM(
+          initial_version.version() == it->version(), "initial_version does not reflect current state of model")
+    }
+  }
+
+  std::shared_ptr<Graph> g(ImportModelProto(mp_in));
+
+  convert_graph(g, initial_version, target_version);
+
+  // Export g as ModelProto
+  debug("Finished conversion; returning model");
+  ModelProto mp_out = PrepareOutput(mp_in);
+  ExportModelProto(&mp_out, g);
+  return mp_out;
+}
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/convert.h b/onnx/version_converter/convert.h
new file mode 100644
index 0000000..6ad1e7d
--- /dev/null
+++ b/onnx/version_converter/convert.h
@@ -0,0 +1,998 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Default converter for ONNX models between different opset versions
+// in the default domain ("" or "ai.onnx").
+
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "onnx/version_converter/BaseConverter.h"
+#include "onnx/version_converter/adapters/Attention_24_23.h"
+#include "onnx/version_converter/adapters/axes_attribute_to_input.h"
+#include "onnx/version_converter/adapters/axes_input_to_attribute.h"
+#include "onnx/version_converter/adapters/axis_attribute_to_input.h"
+#include "onnx/version_converter/adapters/axis_input_to_attribute.h"
+#include "onnx/version_converter/adapters/batch_normalization_13_14.h"
+#include "onnx/version_converter/adapters/broadcast_backward_compatibility.h"
+#include "onnx/version_converter/adapters/broadcast_forward_compatibility.h"
+#include "onnx/version_converter/adapters/cast_9_8.h"
+#include "onnx/version_converter/adapters/clip_10_11.h"
+#include "onnx/version_converter/adapters/compatible.h"
+#include "onnx/version_converter/adapters/dropout_11_12.h"
+#include "onnx/version_converter/adapters/extend_supported_types.h"
+#include "onnx/version_converter/adapters/gemm_6_7.h"
+#include "onnx/version_converter/adapters/gemm_7_6.h"
+#include "onnx/version_converter/adapters/gridsample_19_20.h"
+#include "onnx/version_converter/adapters/group_normalization_20_21.h"
+#include "onnx/version_converter/adapters/maxpool_8_7.h"
+#include "onnx/version_converter/adapters/no_previous_version.h"
+#include "onnx/version_converter/adapters/pad_10_11.h"
+#include "onnx/version_converter/adapters/q_dq_21_20.h"
+#include "onnx/version_converter/adapters/range_27_26.h"
+#include "onnx/version_converter/adapters/reshape_4_5.h"
+#include "onnx/version_converter/adapters/reshape_5_4.h"
+#include "onnx/version_converter/adapters/resize_10_11.h"
+#include "onnx/version_converter/adapters/scan_8_9.h"
+#include "onnx/version_converter/adapters/scan_9_8.h"
+#include "onnx/version_converter/adapters/scatter_10_11.h"
+#include "onnx/version_converter/adapters/scatter_16_15.h"
+#include "onnx/version_converter/adapters/scatter_18_17.h"
+#include "onnx/version_converter/adapters/slice_9_10.h"
+#include "onnx/version_converter/adapters/softmax_12_13.h"
+#include "onnx/version_converter/adapters/softmax_13_12.h"
+#include "onnx/version_converter/adapters/split_12_13.h"
+#include "onnx/version_converter/adapters/split_13_12.h"
+#include "onnx/version_converter/adapters/split_17_18.h"
+#include "onnx/version_converter/adapters/sum_8_7.h"
+#include "onnx/version_converter/adapters/topk_9_10.h"
+#include "onnx/version_converter/adapters/transformers.h"
+#include "onnx/version_converter/adapters/type_restriction.h"
+#include "onnx/version_converter/adapters/upsample_6_7.h"
+#include "onnx/version_converter/adapters/upsample_8_9.h"
+#include "onnx/version_converter/adapters/upsample_9_10.h"
+#include "onnx/version_converter/adapters/upsample_9_8.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class DefaultVersionConverter : public BaseVersionConverter {
+ private:
+  bool DEBUG = false;
+
+  std::pair<int, int> version_range;
+
+  bool searchOpDomainMap(
+      const std::unordered_map<std::string, std::map<int64_t, const OpSchema*>>& op_domain_map,
+      int64_t curr_version,
+      int64_t step) const {
+    bool up = step == 1;
+    const auto version_it = op_domain_map.find("");
+    return version_it != op_domain_map.end() &&
+        ((version_it->second.find(curr_version) != version_it->second.end() && !up) ||
+         (version_it->second.find(curr_version + step) != version_it->second.end() && up));
+  }
+
+  void debug(const std::string& str) const {
+    if (DEBUG)
+      std::cerr << str << '\n';
+  }
+
+  void assertInVersionRange(int64_t version) const {
+    ONNX_ASSERTM(
+        version >= version_range.first && version <= version_range.second,
+        "Warning: invalid version (must be between ",
+        version_range.first,
+        " and ",
+        version_range.second,
+        ")")
+  }
+
+  void assertDefaultDomain(const std::string& initial_domain, const std::string& target_domain) const {
+    ONNX_ASSERTM(
+        (initial_domain.empty() || initial_domain == "ai.onnx") &&
+            (target_domain.empty() || target_domain == "ai.onnx"),
+        "Warning: default onnx version converter can only convert "
+        " between default domain opset versions ('' or 'ai.onnx')\n")
+    ONNX_ASSERTM(initial_domain == target_domain, "initial_version and target_version must have the same domains")
+  }
+
+  void convert_graph(const std::shared_ptr<Graph>& g, const OpSetID& initial_version, const OpSetID& target_version)
+      const;
+
+ public:
+  DefaultVersionConverter() {
+    const std::unordered_map<std::string, std::pair<int, int>>& versions_map =
+        OpSchemaRegistry::DomainToVersionRange::Instance().Map();
+    version_range = versions_map.at("");
+    // Register adapters to the version converter
+    const std::vector<OpSchema> all_opschemas = OpSchemaRegistry::get_all_schemas_with_history();
+
+    for (const OpSchema& schema : all_opschemas) {
+      all_schemas[schema.Name()][schema.domain()][schema.since_version()] = &schema;
+    }
+
+    // Iterate through all_schemas to determine NoPreviousVersionAdapters
+    for (auto& [op_name, domain_map] : all_schemas) {
+      const auto default_versions = domain_map.find("");
+      if (default_versions != domain_map.end()) {
+        int64_t min_version = version_range.second;
+        for (auto& [version, _] : default_versions->second) {
+          min_version = std::min(version, min_version);
+        }
+        if (min_version > 1) {
+          registerAdapter(
+              std::make_unique<NoPreviousVersionAdapter>(op_name, OpSetID(min_version), OpSetID(min_version - 1)));
+        }
+      }
+    }
+
+    /******** 1 -> 2 ********/
+    // Missing in this group: GlobalLpPool, LpPool, Pad, Split
+
+    /******** 2 -> 3 ********/
+    // Missing in this group: GRU
+
+    /******** 3 -> 4 ********/
+    registerAdapter("Concat", 3, 4, SetAttributeIfAbsent(kaxis, 1));
+
+    /******** 4 -> 3 ********/
+    std::vector<TensorProto_DataType> concat_unallowed_types = {
+        TensorProto_DataType_INT32,
+        TensorProto_DataType_INT64,
+        TensorProto_DataType_UINT32,
+        TensorProto_DataType_UINT64,
+        TensorProto_DataType_UINT8,
+        TensorProto_DataType_UINT16,
+        TensorProto_DataType_INT8,
+        TensorProto_DataType_INT16,
+        TensorProto_DataType_STRING,
+        TensorProto_DataType_BOOL};
+    registerAdapter(std::make_unique<TypeRestriction>("Concat", OpSetID(4), OpSetID(3), concat_unallowed_types));
+
+    /******** 4 -> 5 ********/
+    registerAdapter(std::make_unique<Reshape_4_5>());
+
+    /******** 5 -> 4 ********/
+    registerAdapter(std::make_unique<Reshape_5_4>());
+
+    /******** 5 -> 6 ********/
+    // Missing in this group: Cast, Tile
+    auto removeConsumedInputs = RemoveAttribute(kconsumed_inputs);
+    registerAdapter("Add", 5, 6, removeConsumedInputs);
+    registerAdapter("Mul", 5, 6, removeConsumedInputs);
+    registerAdapter(std::make_unique<CompatibleAdapter>("Gemm", OpSetID(5), OpSetID(6)));
+    registerAdapter("Relu", 5, 6, removeConsumedInputs);
+    registerAdapter("BatchNormalization", 5, 6, removeConsumedInputs);
+    registerAdapter("Sum", 5, 6, removeConsumedInputs);
+    registerAdapter("Dropout", 5, 6, removeConsumedInputs);
+    registerAdapter("Abs", 5, 6, removeConsumedInputs);
+    registerAdapter("Ceil", 5, 6, removeConsumedInputs);
+    registerAdapter("Clip", 5, 6, removeConsumedInputs);
+    registerAdapter("Div", 5, 6, removeConsumedInputs);
+    registerAdapter("Elu", 5, 6, removeConsumedInputs);
+    registerAdapter("Exp", 5, 6, removeConsumedInputs);
+    registerAdapter("Floor", 5, 6, removeConsumedInputs);
+    registerAdapter("HardSigmoid", 5, 6, removeConsumedInputs);
+    registerAdapter("InstanceNormalization", 5, 6, removeConsumedInputs);
+    registerAdapter("LeakyRelu", 5, 6, removeConsumedInputs);
+    registerAdapter("Log", 5, 6, removeConsumedInputs);
+    registerAdapter("Max", 5, 6, removeConsumedInputs);
+    registerAdapter("Mean", 5, 6, removeConsumedInputs);
+    registerAdapter("Min", 5, 6, removeConsumedInputs);
+    registerAdapter("Neg", 5, 6, removeConsumedInputs);
+    registerAdapter("PRelu", 5, 6, removeConsumedInputs);
+    registerAdapter("Reciprocal", 5, 6, removeConsumedInputs);
+    registerAdapter("Selu", 5, 6, removeConsumedInputs);
+    registerAdapter("Sigmoid", 5, 6, removeConsumedInputs);
+    registerAdapter("Sqrt", 5, 6, removeConsumedInputs);
+    registerAdapter("Sub", 5, 6, removeConsumedInputs);
+    registerAdapter("Tanh", 5, 6, removeConsumedInputs);
+
+    /******** 6 -> 5 ********/
+    std::vector<TensorProto_DataType> broadcast_unallowed_types = {
+        TensorProto_DataType_INT32,
+        TensorProto_DataType_INT64,
+        TensorProto_DataType_UINT32,
+        TensorProto_DataType_UINT64};
+    std::vector<TensorProto_DataType> int_unallowed_types = {
+        TensorProto_DataType_UINT8,
+        TensorProto_DataType_UINT16,
+        TensorProto_DataType_UINT32,
+        TensorProto_DataType_UINT64,
+        TensorProto_DataType_INT8,
+        TensorProto_DataType_INT16,
+        TensorProto_DataType_INT32,
+        TensorProto_DataType_INT64};
+    std::vector<TensorProto_DataType> neg_unallowed_types = {
+        TensorProto_DataType_INT32, TensorProto_DataType_INT8, TensorProto_DataType_UINT16, TensorProto_DataType_INT64};
+    registerAdapter(std::make_unique<TypeRestriction>("Add", OpSetID(6), OpSetID(5), broadcast_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Mul", OpSetID(6), OpSetID(5), broadcast_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Sub", OpSetID(6), OpSetID(5), broadcast_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Div", OpSetID(6), OpSetID(5), broadcast_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Abs", OpSetID(6), OpSetID(5), int_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Neg", OpSetID(6), OpSetID(5), neg_unallowed_types));
+    registerAdapter("BatchNormalization", 6, 5, SetAttribute(kconsumed_inputs, std::vector<int64_t>({0, 0})));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Gemm", OpSetID(6), OpSetID(5)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Relu", OpSetID(6), OpSetID(5)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sum", OpSetID(6), OpSetID(5)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Dropout", OpSetID(6), OpSetID(5)));
+
+    /******** 6 -> 7 ********/
+    // Missing in this group: And, Equal, Greater, GRU, Less, LSTM, Or, RNN, Upsample, Xor
+    registerAdapter(std::make_unique<BroadcastForwardCompatibility>("Add", OpSetID(6), OpSetID(7)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("AveragePool", OpSetID(6), OpSetID(7)));
+    registerAdapter(std::make_unique<BroadcastForwardCompatibility>("Div", OpSetID(6), OpSetID(7)));
+    registerAdapter(std::make_unique<BroadcastForwardCompatibility>("Mul", OpSetID(6), OpSetID(7)));
+    registerAdapter(std::make_unique<BroadcastForwardCompatibility>("Pow", OpSetID(6), OpSetID(7)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("PRelu", OpSetID(6), OpSetID(7)));
+    registerAdapter(std::make_unique<BroadcastForwardCompatibility>("Sub", OpSetID(6), OpSetID(7)));
+    registerAdapter(std::make_unique<Gemm_6_7>());
+    registerAdapter("BatchNormalization", 6, 7, RemoveAttributeNotEq(kis_test, 0));
+    registerAdapter("Dropout", 6, 7, RemoveAttributeNotEq(kis_test, 0));
+    registerAdapter(std::make_unique<Upsample_6_7>());
+
+    /******** 7 -> 6 ********/
+    registerAdapter(std::make_unique<BroadcastBackwardCompatibility>("Add", OpSetID(7), OpSetID(6)));
+    registerAdapter(std::make_unique<BroadcastBackwardCompatibility>("Div", OpSetID(7), OpSetID(6)));
+    registerAdapter(std::make_unique<BroadcastBackwardCompatibility>("Mul", OpSetID(7), OpSetID(6)));
+    registerAdapter(std::make_unique<BroadcastBackwardCompatibility>("Pow", OpSetID(7), OpSetID(6)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("PRelu", OpSetID(7), OpSetID(6)));
+    registerAdapter(std::make_unique<BroadcastBackwardCompatibility>("Sub", OpSetID(7), OpSetID(6)));
+    registerAdapter("BatchNormalization", 7, 6, SetAttribute(kis_test, 1));
+    registerAdapter("Dropout", 7, 6, SetAttribute(kis_test, 1));
+    registerAdapter(std::make_unique<Gemm_7_6>());
+    registerAdapter("AveragePool", 7, 6, RemoveAttribute(kcount_include_pad, 0));
+
+    /******** 7 -> 8 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Max", OpSetID(7), OpSetID(8)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Min", OpSetID(7), OpSetID(8)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Mean", OpSetID(7), OpSetID(8)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sum", OpSetID(7), OpSetID(8)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxPool", OpSetID(7), OpSetID(8)));
+
+    /******** 8 -> 7 ********/
+    registerAdapter(std::make_unique<BroadcastBackwardCompatibility>("Max", OpSetID(8), OpSetID(7)));
+    registerAdapter(std::make_unique<BroadcastBackwardCompatibility>("Min", OpSetID(8), OpSetID(7)));
+    registerAdapter(std::make_unique<BroadcastBackwardCompatibility>("Mean", OpSetID(8), OpSetID(7)));
+    registerAdapter(std::make_unique<Sum_8_7>());
+    registerAdapter(std::make_unique<MaxPool_8_7>());
+
+    /******** 8 -> 9 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(8), OpSetID(9)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(8), OpSetID(9)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MatMul", OpSetID(8), OpSetID(9)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Gemm", OpSetID(8), OpSetID(9)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("PRelu", OpSetID(8), OpSetID(9)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Greater", OpSetID(8), OpSetID(9)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Less", OpSetID(8), OpSetID(9)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(8), OpSetID(9)));
+    registerAdapter("BatchNormalization", 8, 9, RemoveAttribute(kspatial, 1));
+    registerAdapter(std::make_unique<Scan_8_9>());
+    registerAdapter(std::make_unique<Upsample_8_9>());
+
+    /******** 9 -> 8 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("BatchNormalization", OpSetID(9), OpSetID(8)));
+    registerAdapter(std::make_unique<ExtendSupportedTypes>("Flatten", OpSetID(9), OpSetID(8)));
+    registerAdapter(std::make_unique<ExtendSupportedTypes>("Constant", OpSetID(9), OpSetID(8)));
+    registerAdapter(std::make_unique<ExtendSupportedTypes>("MatMul", OpSetID(9), OpSetID(8)));
+    registerAdapter(std::make_unique<ExtendSupportedTypes>("Gemm", OpSetID(9), OpSetID(8)));
+    registerAdapter(std::make_unique<ExtendSupportedTypes>("PRelu", OpSetID(9), OpSetID(8)));
+    registerAdapter(std::make_unique<ExtendSupportedTypes>("Greater", OpSetID(9), OpSetID(8)));
+    registerAdapter(std::make_unique<ExtendSupportedTypes>("Less", OpSetID(9), OpSetID(8)));
+    registerAdapter(std::make_unique<Cast_9_8>());
+    registerAdapter(std::make_unique<Scan_9_8>());
+    registerAdapter(std::make_unique<Upsample_9_8>());
+
+    /******** 9 -> 10 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("AveragePool", OpSetID(9), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxPool", OpSetID(9), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Dropout", OpSetID(9), OpSetID(10)));
+    registerAdapter(std::make_unique<Slice_9_10>());
+    registerAdapter(std::make_unique<TopK_9_10>());
+    registerAdapter(std::make_unique<Upsample_9_10>());
+
+    /******** 10 -> 9 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Dropout", OpSetID(10), OpSetID(9)));
+
+    /******** 10 -> 11 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("ArgMax", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ArgMin", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("AveragePool", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Concat", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Compress", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Conv", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConvTranspose", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DepthToSpace", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Equal", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Gather", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Gemm", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Hardmax", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LogSoftmax", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LpPool", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxPool", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxUnpool", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("NonMaxSuppression", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("OneHot", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceL1", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceL2", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceLogSum", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceLogSumExp", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMax", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMean", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMin", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceProd", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceSum", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceSumSquare", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Softmax", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Slice", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Split", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Squeeze", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("TopK", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(10), OpSetID(11)));
+    registerAdapter(std::make_unique<Clip_10_11>());
+    registerAdapter(std::make_unique<Pad_10_11>());
+    registerAdapter(std::make_unique<Resize_10_11>());
+    registerAdapter(std::make_unique<Scatter_10_11>());
+
+    /******** 11 -> 10 ********/
+    std::vector<TensorProto_DataType> equal_unallowed_types = {
+        TensorProto_DataType_UINT8,
+        TensorProto_DataType_UINT16,
+        TensorProto_DataType_UINT32,
+        TensorProto_DataType_UINT64,
+        TensorProto_DataType_INT8,
+        TensorProto_DataType_INT16,
+        TensorProto_DataType_FLOAT16,
+        TensorProto_DataType_FLOAT,
+        TensorProto_DataType_DOUBLE};
+    registerAdapter(std::make_unique<CompatibleAdapter>("ArgMax", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ArgMin", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("AveragePool", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Concat", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Conv", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConvTranspose", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<TypeRestriction>("Equal", OpSetID(11), OpSetID(10), equal_unallowed_types));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LogSoftmax", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxPool", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceL1", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceL2", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceLogSum", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceLogSumExp", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMax", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMean", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMin", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceProd", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceSum", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceSumSquare", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Softmax", OpSetID(11), OpSetID(10)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(11), OpSetID(10)));
+
+    /******** 11 -> 12 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("ArgMax", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ArgMin", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("BatchNormalization", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Clip", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GatherND", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Min", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Max", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxPool", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pow", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMax", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMin", OpSetID(11), OpSetID(12)));
+    registerAdapter(std::make_unique<Dropout_11_12>());
+
+    /******** 12 -> 11 ********/
+    std::vector<TensorProto_DataType> maxpool_unallowed_types = {TensorProto_DataType_UINT8, TensorProto_DataType_INT8};
+    registerAdapter("ArgMax", 12, 11, RemoveAttribute(kselect_last_index, 0));
+    registerAdapter("ArgMin", 12, 11, RemoveAttribute(kselect_last_index, 0));
+    registerAdapter(std::make_unique<CompatibleAdapter>("BatchNormalization", OpSetID(12), OpSetID(11)));
+    registerAdapter(std::make_unique<TypeRestriction>("Clip", OpSetID(12), OpSetID(11), int_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Min", OpSetID(12), OpSetID(11), int_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Max", OpSetID(12), OpSetID(11), int_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("MaxPool", OpSetID(12), OpSetID(11), maxpool_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("ReduceMax", OpSetID(12), OpSetID(11), maxpool_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("ReduceMin", OpSetID(12), OpSetID(11), maxpool_unallowed_types));
+
+    /******** 12 -> 13 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Abs", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Add", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ArgMin", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ArgMax", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Ceil", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Clip", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Concat", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DepthToSpace", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Div", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Dropout", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Equal", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Erf", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Exp", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Expand", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Floor", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Gather", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GatherElements", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GatherND", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Gemm", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Greater", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Hardmax", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("IsNaN", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Less", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Log", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LRN", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("NegativeLogLikelihoodLoss", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MatMul", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Max", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Mean", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MeanVarianceNormalization", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Min", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Mod", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Mul", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Neg", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("NonZero", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pow", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reciprocal", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceL1", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceL2", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceLogSum", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceLogSumExp", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMean", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMax", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMin", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceProd", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceSumSquare", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Relu", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Resize", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ScatterElements", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ScatterND", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sigmoid", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sign", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Slice", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("SoftmaxCrossEntropyLoss", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("SpaceToDepth", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sqrt", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sub", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sum", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Tanh", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Tile", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Transpose", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceSum", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("Squeeze", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("Unsqueeze", OpSetID(12), OpSetID(13)));
+    registerAdapter(std::make_unique<Split_12_13>());
+    registerAdapter(std::make_unique<Softmax_12_13>("Softmax"));
+    registerAdapter(std::make_unique<Softmax_12_13>("LogSoftmax"));
+
+    /******** 13 -> 12 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(13), OpSetID(12)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceSum", OpSetID(13), OpSetID(12)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("Squeeze", OpSetID(13), OpSetID(12)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("Unsqueeze", OpSetID(13), OpSetID(12)));
+    registerAdapter(std::make_unique<Split_13_12>());
+    registerAdapter(std::make_unique<Softmax_13_12>("Softmax"));
+    registerAdapter(std::make_unique<Softmax_13_12>("LogSoftmax"));
+
+    /******** 13 -> 14 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Add", OpSetID(13), OpSetID(14)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CumSum", OpSetID(13), OpSetID(14)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Div", OpSetID(13), OpSetID(14)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(13), OpSetID(14)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Mul", OpSetID(13), OpSetID(14)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Relu", OpSetID(13), OpSetID(14)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(13), OpSetID(14)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sub", OpSetID(13), OpSetID(14)));
+    registerAdapter("GRU", 13, 14, SetAttribute(klayout, 0));
+    registerAdapter("LSTM", 13, 14, SetAttribute(klayout, 0));
+    registerAdapter("RNN", 13, 14, SetAttribute(klayout, 0));
+    registerAdapter(std::make_unique<BatchNormalization_13_14>());
+
+    /******** 14 -> 13 ********/
+    registerAdapter("GRU", 14, 13, RemoveAttribute(klayout, 0));
+    registerAdapter("LSTM", 14, 13, RemoveAttribute(klayout, 0));
+    registerAdapter("RNN", 14, 13, RemoveAttribute(klayout, 0));
+
+    /******** 14 -> 15 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("BatchNormalization", OpSetID(14), OpSetID(15)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pow", OpSetID(14), OpSetID(15)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(14), OpSetID(15)));
+
+    /******** 15 -> 16 ********/
+    registerAdapter("RoiAlign", 15, 16, SetAttribute(kcoordinate_transformation_mode, "output_half_pixel"));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ScatterElements", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ScatterND", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Where", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LessOrEqual", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GreaterOrEqual", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LeakyRelu", OpSetID(15), OpSetID(16)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("PRelu", OpSetID(15), OpSetID(16)));
+
+    /******** 16 -> 15 ********/
+    const std::vector<TensorProto_DataType> bfloat16_not_allowed = {TensorProto_DataType_BFLOAT16};
+    registerAdapter(std::make_unique<TypeRestriction>("Where", OpSetID(16), OpSetID(15), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<Scatter_16_15>("ScatterElements", OpSetID(16), OpSetID(15), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<Scatter_16_15>("ScatterND", OpSetID(16), OpSetID(15), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(16), OpSetID(15), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("LessOrEqual", OpSetID(16), OpSetID(15), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("GreaterOrEqual", OpSetID(16), OpSetID(15), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("LeakyRelu", OpSetID(16), OpSetID(15), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("PRelu", OpSetID(16), OpSetID(15), bfloat16_not_allowed));
+
+    /******** 17 -> 18 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Resize", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("OptionalGetElement", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("OptionalHasElement", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<Split_17_18>());
+    registerAdapter(std::make_unique<CompatibleAdapter>("ScatterND", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ScatterElements", OpSetID(17), OpSetID(18)));
+    registerAdapter("LpPool", 17, 18, SetAttribute(kceil_mode, 0));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceL1", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceL2", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceLogSum", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceLogSumExp", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceMax", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceMean", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceMin", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceProd", OpSetID(17), OpSetID(18)));
+    registerAdapter(std::make_unique<AxesAttributeToInput>("ReduceSumSquare", OpSetID(17), OpSetID(18)));
+
+    /******** 18 -> 17 ********/
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceL1", OpSetID(18), OpSetID(17)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceL2", OpSetID(18), OpSetID(17)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceLogSum", OpSetID(18), OpSetID(17)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceLogSumExp", OpSetID(18), OpSetID(17)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceMax", OpSetID(18), OpSetID(17)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceMean", OpSetID(18), OpSetID(17)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceMin", OpSetID(18), OpSetID(17)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceProd", OpSetID(18), OpSetID(17)));
+    registerAdapter(std::make_unique<AxesInputToAttribute>("ReduceSumSquare", OpSetID(18), OpSetID(17)));
+    registerAdapter(std::make_unique<Scatter_18_17>("ScatterElements"));
+    registerAdapter(std::make_unique<Scatter_18_17>("ScatterND"));
+
+    /******** 18 -> 19 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Equal", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("AveragePool", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CastLike", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Resize", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(18), OpSetID(19)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(18), OpSetID(19)));
+
+    /******** 19 -> 18 ********/
+    const std::vector<TensorProto_DataType> float8_unallowed_types = {
+        TensorProto_DataType_FLOAT8E4M3FN,
+        TensorProto_DataType_FLOAT8E4M3FNUZ,
+        TensorProto_DataType_FLOAT8E5M2,
+        TensorProto_DataType_FLOAT8E5M2FNUZ};
+    const std::vector<TensorProto_DataType> string_unallowed_types = {TensorProto_DataType_STRING};
+    // Opset 19 introduced float8 support across a number of ops. When downgrading
+    // to 18 we must reject models that actually use those new element types.
+    registerAdapter(std::make_unique<CompatibleAdapter>("AveragePool", OpSetID(19), OpSetID(18)));
+    registerAdapter(std::make_unique<TypeRestriction>("Constant", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Cast", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("CastLike", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("DequantizeLinear", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("QuantizeLinear", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Equal", OpSetID(19), OpSetID(18), string_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Identity", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("If", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Loop", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(19), OpSetID(18)));
+    registerAdapter(std::make_unique<TypeRestriction>("Reshape", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Resize", OpSetID(19), OpSetID(18)));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Shape", OpSetID(19), OpSetID(18), float8_unallowed_types));
+    registerAdapter(std::make_unique<TypeRestriction>("Size", OpSetID(19), OpSetID(18), float8_unallowed_types));
+
+    /******** 19 -> 20 ********/
+    registerAdapter(std::make_unique<AxisAttributeToInput>("DFT", OpSetID(19), OpSetID(20), 2, 1));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConstantOfShape", OpSetID(19), OpSetID(20)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("IsInf", OpSetID(19), OpSetID(20)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("IsNaN", OpSetID(19), OpSetID(20)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMax", OpSetID(19), OpSetID(20)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ReduceMin", OpSetID(19), OpSetID(20)));
+    registerAdapter(std::make_unique<GridSample_19_20>());
+
+    /******** 20 -> 19 ********/
+    const std::vector<TensorProto_DataType> is_nan_13_unallowed_types = {
+        TensorProto_DataType_FLOAT8E4M3FN,
+        TensorProto_DataType_FLOAT8E4M3FNUZ,
+        TensorProto_DataType_FLOAT8E5M2,
+        TensorProto_DataType_FLOAT8E5M2FNUZ};
+    registerAdapter(std::make_unique<TypeRestriction>("IsNaN", OpSetID(20), OpSetID(19), is_nan_13_unallowed_types));
+    const std::vector<TensorProto_DataType> is_inf_10_unallowed_types = {
+        TensorProto_DataType_FLOAT16,
+        TensorProto_DataType_BFLOAT16,
+        TensorProto_DataType_FLOAT8E4M3FN,
+        TensorProto_DataType_FLOAT8E4M3FNUZ,
+        TensorProto_DataType_FLOAT8E5M2,
+        TensorProto_DataType_FLOAT8E5M2FNUZ};
+    registerAdapter(std::make_unique<TypeRestriction>("IsInf", OpSetID(20), OpSetID(19), is_inf_10_unallowed_types));
+    registerAdapter(std::make_unique<AxisInputToAttribute>("DFT", OpSetID(20), OpSetID(19), 2, -2));
+    const std::vector<TensorProto_DataType> reduce_min_max_18_unallowed_types = {TensorProto_DataType_BOOL};
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ReduceMax", OpSetID(20), OpSetID(19), reduce_min_max_18_unallowed_types));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ReduceMin", OpSetID(20), OpSetID(19), reduce_min_max_18_unallowed_types));
+
+    /******** 20 -> 21 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CastLike", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConstantOfShape", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<GroupNormalization_20_21>());
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QLinearMatMul", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Squeeze", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Transpose", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(20), OpSetID(21)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GroupNormalization", OpSetID(20), OpSetID(21)));
+
+    /******** 21 -> 20 ********/
+    const std::vector<TensorProto_DataType> q_dqmm_20_unallowed_types = {
+        TensorProto_DataType_BFLOAT16,
+        TensorProto_DataType_FLOAT16,
+        TensorProto_DataType_UINT4,
+        TensorProto_DataType_INT4};
+    const std::vector<TensorProto_DataType> ir10_types_not_in_ir9 = {
+        TensorProto_DataType_UINT4, TensorProto_DataType_INT4};
+    const std::vector<TensorProto_DataType> ir10_types_not_in_ir4 = {
+        TensorProto_DataType_FLOAT8E4M3FN,
+        TensorProto_DataType_FLOAT8E4M3FNUZ,
+        TensorProto_DataType_FLOAT8E5M2,
+        TensorProto_DataType_FLOAT8E5M2FNUZ,
+        TensorProto_DataType_UINT4,
+        TensorProto_DataType_INT4};
+
+    registerAdapter(std::make_unique<TypeRestriction>("Cast", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("CastLike", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Constant", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ConstantOfShape", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<DequantizeLinear_21_20>());
+    registerAdapter(std::make_unique<TypeRestriction>("Flatten", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
+    registerAdapter(std::make_unique<TypeRestriction>("Identity", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("If", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Loop", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Pad", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("QLinearMatMul", OpSetID(21), OpSetID(20), q_dqmm_20_unallowed_types));
+    registerAdapter(std::make_unique<QuantizeLinear_21_20>());
+    registerAdapter(std::make_unique<TypeRestriction>("Reshape", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Shape", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Size", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
+    registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
+    registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
+
+    /******** 21 -> 22 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("EyeLike", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RandomUniform", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RandomNormal", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RandomUniformLike", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RandomNormalLike", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Multinomial", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Bernoulli", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ThresholdedRelu", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Selu", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Elu", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Mish", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("HardSigmoid", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("HardSwish", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Softsign", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Softplus", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sin", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cos", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Tan", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Asin", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Acos", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Atan", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sinh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cosh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Asinh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Acosh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Atanh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Round", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Det", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("NegativeLogLikelihoodLoss", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("AveragePool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxUnpool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LpPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxRoiPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Conv", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConvTranspose", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DeformConv", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GlobalAveragePool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GlobalMaxPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GlobalLpPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("InstanceNormalization", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LpNormalization", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Dropout", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RoiAlign", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RNN", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GRU", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LSTM", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GridSample", OpSetID(21), OpSetID(22)));
+
+    /******** 22 -> 21 ********/
+    registerAdapter(std::make_unique<TypeRestriction>("EyeLike", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("AveragePool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("MaxPool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("RandomUniform", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("RandomNormal", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("RandomNormalLike", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("RandomUniformLike", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Multinomial", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Bernoulli", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ThresholdedRelu", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Selu", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Elu", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Mish", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("HardSigmoid", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("HardSwish", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Softsign", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Softplus", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Sin", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Cos", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Tan", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Asin", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Acos", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Atan", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Sinh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Cosh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Asinh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Acosh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Atanh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Round", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Det", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("NegativeLogLikelihoodLoss", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("MaxUnpool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("LpPool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("MaxRoiPool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Conv", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("ConvTranspose", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("DeformConv", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("GlobalAveragePool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("GlobalLpPool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("InstanceNormalization", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("LpNormalization", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Dropout", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("RoiAlign", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("RNN", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("GRU", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("LSTM", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("GridSample", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+
+    /******** 22 -> 23 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CastLike", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConstantOfShape", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Squeeze", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Transpose", OpSetID(22), OpSetID(23)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(22), OpSetID(23)));
+
+    /******** 23 -> 22 ********/
+    const std::vector<TensorProto_DataType> ir11_types_not_in_ir10 = {TensorProto_DataType_FLOAT4E2M1};
+    registerAdapter(std::make_unique<TypeRestriction>("Cast", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("CastLike", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Constant", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ConstantOfShape", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("DequantizeLinear", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Flatten", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Identity", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("If", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Loop", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Pad", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("QuantizeLinear", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Reshape", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Shape", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Size", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+    registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(23), OpSetID(22), ir11_types_not_in_ir10));
+
+    /******** 23 -> 24 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Attention", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CastLike", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConstantOfShape", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Squeeze", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Transpose", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(23), OpSetID(24)));
+
+    // TopK and SplitToSequence 23=>24 update adds bfloat16 support
+    registerAdapter(std::make_unique<CompatibleAdapter>("TopK", OpSetID(23), OpSetID(24)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("SplitToSequence", OpSetID(23), OpSetID(24)));
+
+    /******** 24 -> 23 ********/
+    registerAdapter(std::make_unique<Attention_24_23>());
+    const std::vector<TensorProto_DataType> ir12_types_not_in_ir11 = {TensorProto_DataType_FLOAT8E8M0};
+    registerAdapter(std::make_unique<TypeRestriction>("Cast", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("CastLike", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Constant", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ConstantOfShape", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("DequantizeLinear", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Flatten", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Identity", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("If", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Loop", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Pad", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("QuantizeLinear", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Reshape", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Shape", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Size", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+    registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(24), OpSetID(23), ir12_types_not_in_ir11));
+
+    registerAdapter(std::make_unique<TypeRestriction>("TopK", OpSetID(24), OpSetID(23), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("SplitToSequence", OpSetID(24), OpSetID(23), bfloat16_not_allowed));
+
+    /******** 24 -> 25 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cast", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("CastLike", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Constant", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConstantOfShape", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DequantizeLinear", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Flatten", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Identity", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Reshape", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Shape", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Size", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("If", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Loop", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Scan", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Pad", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Squeeze", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Transpose", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Unsqueeze", OpSetID(24), OpSetID(25)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("QuantizeLinear", OpSetID(24), OpSetID(25)));
+
+    /******** 25 -> 24 ********/
+    const std::vector<TensorProto_DataType> ir13_types_not_in_ir12 = {
+        TensorProto_DataType_UINT2, TensorProto_DataType_INT2};
+    registerAdapter(std::make_unique<TypeRestriction>("Cast", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("CastLike", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Constant", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ConstantOfShape", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("DequantizeLinear", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Flatten", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Identity", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Reshape", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Shape", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Size", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("If", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Loop", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Scan", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Pad", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("QuantizeLinear", OpSetID(25), OpSetID(24), ir13_types_not_in_ir12));
+
+    /******** 26 -> 27 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Range", OpSetID(26), OpSetID(27)));
+
+    /******** 27 -> 26 ********/
+    // Range v27 added FLOAT16/BFLOAT16 and stash_type; Range v11 (opset 26) supports neither.
+    const std::vector<TensorProto_DataType> range_27_unallowed_types = {
+        TensorProto_DataType_FLOAT16, TensorProto_DataType_BFLOAT16};
+    registerAdapter(std::make_unique<Range_27_26>(range_27_unallowed_types));
+
+    /******** 27 -> 28 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("Celu", OpSetID(27), OpSetID(28)));
+
+    /******** 28 -> 27 ********/
+    // Celu v28 widened T to all_float_types_ir4(); Celu v12 (opset 27) supports only FLOAT.
+    const std::vector<TensorProto_DataType> celu_28_unallowed_types = {
+        TensorProto_DataType_FLOAT16, TensorProto_DataType_BFLOAT16, TensorProto_DataType_DOUBLE};
+    registerAdapter(std::make_unique<TypeRestriction>("Celu", OpSetID(28), OpSetID(27), celu_28_unallowed_types));
+  }
+
+  ModelProto convert_version(const ModelProto& mp_in, const OpSetID& initial_version, const OpSetID& target_version)
+      const override;
+};
+
+ONNX_API ModelProto ConvertVersion(const ModelProto& mp_in, int target_version);
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/helper.cc b/onnx/version_converter/helper.cc
new file mode 100644
index 0000000..55d5180
--- /dev/null
+++ b/onnx/version_converter/helper.cc
@@ -0,0 +1,83 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Helper Methods for Adapters
+
+#include "onnx/version_converter/helper.h"
+
+#include <cinttypes>
+#include <vector>
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+int check_numpy_unibroadcastable_and_require_broadcast(
+    const std::vector<Dimension>& input1_sizes,
+    const std::vector<Dimension>& input2_sizes) {
+  // Check that input1 is larger
+  if (input1_sizes.size() < input2_sizes.size())
+    return -1;
+  // Check that axis is input1_sizes.size()-input2_sizes.size()
+  bool broadcast = false;
+  auto axis = input1_sizes.size() - input2_sizes.size();
+  for (size_t i = 0; i < input2_sizes.size(); i++) {
+    if (input2_sizes[i].dim != input1_sizes[axis + i].dim && input2_sizes[i].dim != 1)
+      return -1;
+    if (input2_sizes[i].dim != input1_sizes[axis + i].dim)
+      broadcast = true;
+  }
+  // Return true if broadcasting is required
+  if (input1_sizes.size() > input2_sizes.size() || broadcast)
+    return 1;
+  else
+    return 0;
+}
+
+void assert_numpy_multibroadcastable(
+    const std::vector<Dimension>& input1_sizes,
+    const std::vector<Dimension>& input2_sizes) {
+  // Generalize above for multibroadcastable case
+  const std::vector<Dimension>* A_ptr = &input1_sizes;
+  const std::vector<Dimension>* B_ptr = &input2_sizes;
+  int A = 1;
+  int B = 2;
+  if (input1_sizes.size() < input2_sizes.size()) {
+    A_ptr = &input2_sizes;
+    B_ptr = &input1_sizes;
+    A = 2;
+    B = 1;
+  }
+  const std::vector<Dimension>& A_sizes = *A_ptr;
+  const std::vector<Dimension>& B_sizes = *B_ptr;
+  auto axis = A_sizes.size() - B_sizes.size();
+  for (size_t i = 0; i < B_sizes.size(); i++) {
+    ONNX_ASSERTM(
+        B_sizes[i].dim == A_sizes[axis + i].dim || B_sizes[i].dim == 1 || A_sizes[axis + i].dim == 1,
+        "Dimension ",
+        i,
+        " of input ",
+        B,
+        " does not match dimension ",
+        axis + i,
+        " of input ",
+        A,
+        ", and neither's value is 1")
+  }
+}
+
+void assertNotParams(const std::vector<Dimension>& sizes) {
+  for (const Dimension& dim : sizes) {
+    ONNX_ASSERTM(dim.is_int, dim.param, " Dimension is a param instead of an int.")
+  }
+}
+
+void assertInputsAvailable(const ArrayRef<Value*>& inputs, const char* name, uint64_t num_inputs) {
+  ONNX_ASSERTM(
+      inputs.size() == num_inputs, name, " in opset version 6 can only broadcast between ", num_inputs, " inputs")
+  for (size_t i = 0; i < num_inputs; i++) {
+    ONNX_ASSERTM(inputs[i]->has_sizes(), "Shape of input ", i, " is not available.")
+    assertNotParams(inputs[i]->sizes());
+  }
+}
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/onnx/version_converter/helper.h b/onnx/version_converter/helper.h
new file mode 100644
index 0000000..f567c2b
--- /dev/null
+++ b/onnx/version_converter/helper.h
@@ -0,0 +1,50 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Helper Methods for Adapters
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "onnx/common/assertions.h"
+#include "onnx/common/ir.h"
+#include "onnx/defs/tensor_util.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+int check_numpy_unibroadcastable_and_require_broadcast(
+    const std::vector<Dimension>& input1_sizes,
+    const std::vector<Dimension>& input2_sizes);
+
+void assert_numpy_multibroadcastable(
+    const std::vector<Dimension>& input1_sizes,
+    const std::vector<Dimension>& input2_sizes);
+
+void assertNotParams(const std::vector<Dimension>& sizes);
+
+void assertInputsAvailable(const ArrayRef<Value*>& inputs, const char* name, uint64_t num_inputs);
+
+// Decode an INT64 tensor; rejects mismatched element type or dims/raw byte length.
+inline std::vector<int64_t> ReadInt64Tensor(const Tensor& tensor) {
+  ONNX_ASSERTM(
+      tensor.elem_type() == ONNX_NAMESPACE::TensorProto_DataType_INT64,
+      "expected INT64 tensor, got elem_type=",
+      tensor.elem_type())
+  if (tensor.is_raw_data()) {
+    const size_t raw_bytes = tensor.raw().size();
+    // elem_num() returns 1 for scalars, so covers dims=[].
+    ONNX_ASSERTM(
+        raw_bytes == static_cast<size_t>(tensor.elem_num()) * sizeof(int64_t),
+        "INT64 tensor: ",
+        raw_bytes,
+        " raw bytes does not match dims (",
+        tensor.elem_num(),
+        " elements)")
+  }
+  return ParseData<int64_t>(&tensor);
+}
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE
diff --git a/pixi.lock b/pixi.lock
new file mode 100644
index 0000000..0741773
--- /dev/null
+++ b/pixi.lock
@@ -0,0 +1,16948 @@
+version: 7
+platforms:
+- name: linux-64
+  virtual-packages:
+  - __unix=0=0
+  - __linux=4.18
+  - __glibc=2.28
+  - __archspec=0=x86_64
+- name: linux-aarch64
+  virtual-packages:
+  - __unix=0=0
+  - __linux=4.18
+  - __glibc=2.28
+  - __archspec=0=aarch64
+- name: osx-arm64
+  virtual-packages:
+  - __unix=0=0
+  - __osx=13.0
+  - __archspec=0=m1
+- name: win-64
+  virtual-packages:
+  - __win=10.0
+  - __archspec=0=x86_64
+environments:
+  clang-tools:
+    channels:
+    - url: https://conda.anaconda.org/conda-forge/
+    packages:
+      linux-64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.45.1-default_h4852527_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22.1.8-default_cfg_h361ecea_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22-22.1.8-default_h713e2cb_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22.1.8-default_he96069b_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-scan-deps-22.1.8-default_h1381bd0_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-tools-22.1.8-default_h1fde246_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang_impl_linux-64-22.1.8-default_h6d37801_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt22-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h6c227bf_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcompiler-rt-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-22.1.8-h4922eb0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-64-22.1.8-hffcefe0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-64-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.2.0-hcc6f6b0_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      linux-aarch64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils-2.45.1-default_hf1166c9_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45.1-default_h5f4c503_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22.1.8-default_cfg_hf729886_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22-22.1.8-default_h2321676_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22.1.8-default_hceecdc4_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-scan-deps-22.1.8-default_hfec9229_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-tools-22.1.8-default_h8cb1401_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang_impl_linux-aarch64-22.1.8-default_h2e8b6a6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt22-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang-cpp22.1-22.1.8-default_h0cc847a_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang13-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcompiler-rt-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libllvm22-22.1.8-hfd2ba90_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h022381a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h064b767_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h9ba8346_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llvm-openmp-22.1.8-he40846f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-aarch64-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-aarch64-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      osx-arm64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_osx-arm64-22.1.8-h7e67a1e_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-22.1.8-hce30654_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1030.6.3-llvm22_1_hbe26303_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_impl_osx-arm64-1030.6.3-llvm22_1_hb5e89dc_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-22-22.1.8-default_h3bfd001_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-22.1.8-default_cfg_h4d70ba2_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22-22.1.8-default_h954c128_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22.1.8-default_h395fef1_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-scan-deps-22.1.8-default_hdae4f07_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-tools-22.1.8-default_h54ac4d0_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-22.1.8-default_hd222103_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-22.1.8-hce30654_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt22-22.1.8-hd34ed20_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-956.6-llvm22_1_h5b97f1b_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-956.6-llvm22_1_h692d5aa_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp22.1-22.1.8-default_hdca5a3d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang13-22.1.8-default_h3bfd001_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcompiler-rt-22.1.8-hd34ed20_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm22-22.1.8-h89af1be_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsigtool-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.3-h6967ea9_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.3-heed7d32_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-22-22.1.8-hb545844_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-22.1.8-hd34ed20_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.6-h156bc91_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-codesign-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1600.0.11.8-h997e182_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda
+      win-64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_win-64-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22-22.1.8-default_hac490eb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22.1.8-default_nocfg_hbb9487a_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-format-22.1.8-default_hac490eb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-tools-22.1.8-default_hac490eb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/compiler-rt22-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libclang13-22.1.8-default_hf735972_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h692994f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-hbc0d294_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda
+  default:
+    channels:
+    - url: https://conda.anaconda.org/conda-forge/
+    packages:
+      linux-64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ast-serialize-0.6.0-py310hd8a072f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.45.1-default_h4852527_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.45.1-default_h4852527_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22.1.8-default_cfg_h361ecea_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22-22.1.8-default_ha9a2879_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22.1.8-default_h9fcfc6d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang_impl_linux-64-22.1.8-default_h6d37801_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.3.4-hc85cc9f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt22-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-he8ccf15_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.14.3-py314h67df5f8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h0dff253_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-h235f0fe_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h50e9bb6_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-h2185e75_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-hd240bd5_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbde042b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20260107.1-cxx17_h7b12aa8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h6c227bf_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcompiler-rt-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hae6b9f4_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libdate-3.0.4-h5888daf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.33-pthreads_h94d23a6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.33.5-h6eeba95_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.22.0-hd9031aa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-h8f1669f_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.52.1-h280c20c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-22.1.8-h4922eb0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/make-4.4.1-hb9d3cd8_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.4-np2py314h6477eea_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-2.1.0-py314h518bba1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.2-h171cf75_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-24.18.0-h3d65ac4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.5.0-py314h2b28147_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.26.0-py314h112547c_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.3.0-py314hdf18abd_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/prek-0.4.6-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/prettier-3.9.3-h7e4c9f4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-6.33.5-py314h61e7c5f_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h0f05182_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.12.0-py314h0f05182_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.15.20-h6a952e8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/shellcheck-0.11.0-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/typos-1.48.0-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zizmor-1.26.1-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-64-22.1.8-hffcefe0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-64-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-hf649bbc_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h9f08a49_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      linux-aarch64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ast-serialize-0.6.0-py310h8c58d24_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils-2.45.1-default_hf1166c9_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45.1-default_h5f4c503_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.45.1-default_hf1166c9_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-ares-1.34.6-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-compiler-1.11.0-hdceaead_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22.1.8-default_cfg_hf729886_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22-22.1.8-default_ha537bf4_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22.1.8-default_hb626d9f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang_impl_linux-aarch64-22.1.8-default_h2e8b6a6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cmake-4.3.4-hc9d863e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt22-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-gcc-specs-14.3.0-hadff5d6_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.14.3-py314hb76de3f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cxx-compiler-1.11.0-h7b35c40_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc-14.3.0-h2e72a27_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-14.3.0-h398eab4_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-14.3.0-h140ef2e_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx-14.3.0-ha28f942_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-14.3.0-h0d4f5d4_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-14.3.0-h0da240b_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/keyutils-1.6.3-h86ecc28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.22.2-h2fb54aa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lcms2-2.19.1-h9d5b58d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lerc-4.1.0-h52b7260_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20260107.1-cxx17_h6983b43_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.11.0-8_haddc8a3_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlicommon-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlidec-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlienc-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-8_hd72aa62_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang-cpp22.1-22.1.8-default_h0cc847a_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang13-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcompiler-rt-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcurl-8.21.0-h7c59cd8_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdate-3.0.4-h5ad3122_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdeflate-1.25-h1af38f5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libedit-3.1.20250104-pl5321h976ea20_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libev-4.33-h31becfc_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.3-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.3-hdae7a39_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjpeg-turbo-3.1.4.1-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.11.0-8_h88aeb00_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libllvm22-22.1.8-hfd2ba90_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnghttp2-1.68.1-hd3077d7_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.33-pthreads_h9d3fd7e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpng-1.6.58-h1abf092_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.33.5-h306233d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpsl-0.22.0-h504d594_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-14.3.0-hedb4206_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libssh2-1.11.1-h18c354c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuv-1.52.1-h80f16a2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libwebp-base-1.6.0-ha2e29f5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcb-1.17.0-h262b8f6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h79dcc73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h869d058_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llvm-openmp-22.1.8-he40846f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/make-4.4.1-h2a6d0cb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ml_dtypes-0.5.4-np2py314h175d3ba_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-2.1.0-py314h42c854d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ninja-1.13.2-hdc560ac_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/nodejs-24.18.0-h7ca28ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.5.0-py314he1698a1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.26.0-py314ha1c0044_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openjpeg-2.5.4-h5da879a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pillow-11.3.0-py314h033a589_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prek-0.4.6-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prettier-3.9.3-h70496c1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-6.33.5-py314hb844caf_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.2.2-py314h2e8dab5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pthread-stubs-0.4-h86ecc28_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-librt-0.12.0-py314h2e8dab5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rhash-1.4.6-h86ecc28_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.15.20-h88be79b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/shellcheck-0.11.0-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/typos-1.48.0-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxau-1.0.12-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxdmcp-1.1.5-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zizmor-1.26.1-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-aarch64-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-aarch64-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-14.3.0-h25ba3ff_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-14.3.0-h57c8d61_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      osx-arm64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libcxx-headers-19.1.7-h707e725_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sdkroot_env_osx-arm64-26.0-ha3f98da_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ast-serialize-0.6.0-py310h3b8a9b8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1030.6.3-llvm19_1_hd01ab73_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_impl_osx-arm64-1030.6.3-llvm19_1_he8a363d_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1030.6.3-llvm19_1_hd01ab73_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_hf3020a7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22-22.1.8-default_h8e162e0_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22.1.8-default_h8e162e0_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h75f8d18_32.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_hc995acf_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h75f8d18_32.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.3.4-h8cb302d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.14.3-py314h6e9b3f0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-78.3-hef89b57_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-hfd3d5f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-956.6-llvm19_1_he86490a_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-956.6-llvm19_1_ha2625f7_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.1.0-h1eee2c3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20260107.1-cxx17_h2062a1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.11.0-8_h51639a9_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.11.0-8_hb0561ab_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_hf3020a7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp22.1-22.1.8-default_hdca5a3d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.21.0-h1359186_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdate-3.0.4-h286801f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.25-hc11a715_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.3-hdfa99f5_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.1.4.1-h84a0fba_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.11.0-8_hd9741b5_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm22-22.1.8-h89af1be_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.33-openmp_he657e61_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.58-h132b30e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-6.33.5-h2d4b707_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpsl-0.22.0-hb427e8f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsigtool-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.1-h4030677_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.52.1-h1a92334_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.6.0-h07db88b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.3-h5ef1a60_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.3-h5654f7c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/make-4.4.1-hc9fafa5_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.5.4-np2py314hdd732f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-2.1.0-py314h2fbedac_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.2-h49c215f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-24.18.0-h654b19f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.5.0-py314hb79c6fa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.26.0-py314h236feb1_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-11.3.0-py314haf93fec_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prek-0.4.6-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prettier-3.9.3-h57cd9b8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-6.33.5-py314he407d35_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py314ha14b1ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.6-h156bc91_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.12.0-py314ha14b1ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.15.20-h80928e0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/shellcheck-0.11.0-hecfb573_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-codesign-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1600.0.11.8-h997e182_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/typos-1.48.0-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zizmor-1.26.1-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda
+      win-64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_win-64-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ast-serialize-0.6.0-py310ha413424_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/c-compiler-1.11.0-h528c1b4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22-22.1.8-default_hf735972_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22.1.8-default_nocfg_haf066c4_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-format-22.1.8-default_h5ef374e_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.3.4-hdcbee5b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/compiler-rt22-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.14.3-py314h2359020_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.3-h637d24d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h719d79b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/lcms2-2.19.1-hf2c6c5f_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.1.0-hd936e49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20260107.1-cxx17_h0eb2380_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-8_h8455456_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-8_h2a3cdd5_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libclang13-22.1.8-default_hf735972_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.21.0-h51a1c48_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libdate-3.0.4-he0c23c2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libdeflate-1.25-h51727cc_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.3-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.3-hdbac1cb_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.2.0-h8ee18e1_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.2.0-h8ee18e1_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.13.0-default_h049141e_1000.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.1.4.1-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-8_hf9ab0e9_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.58-h7351971_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-6.33.5-h6cf2d3c_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libpsl-0.22.0-hc1744f7_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.1-h8f73337_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.52.1-h6a83c73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libwebp-base-1.6.0-h4d5522a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_10.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxcb-1.17.0-h0e4246c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h3cfd58e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-h8ef44ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/make-4.4.1-h0e40799_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2026.0.0-hac47afa_908.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ml_dtypes-0.5.4-np2py314hb7a55bc_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/mypy-2.1.0-py314h13f4da2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.2-h477610d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/nodejs-24.18.0-h80d1838_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.5.0-py314h02f10f6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.0.0-h57928b3_908.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.26.0-py314h8bd40d1_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openjpeg-2.5.4-h0e57b4f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pillow-11.3.0-py314hb9a687b_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/prek-0.4.6-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/prettier-3.9.3-hc21fffc_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-6.33.5-py314h6a447be_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py314hc5dbbe4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pthread-stubs-0.4-h0e40799_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.12.0-py314hc5dbbe4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ruff-0.15.20-h45713df_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/shellcheck-0.11.0-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2023.0.0-hd3d4ead_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/typos-1.48.0-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxau-1.0.12-hba3369d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxdmcp-1.1.5-hba3369d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zizmor-1.26.1-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda
+  docs:
+    channels:
+    - url: https://conda.anaconda.org/conda-forge/
+    indexes:
+    - https://pypi.org/simple
+    packages:
+      linux-64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.16.1-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ast-serialize-0.6.0-py310hd8a072f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-atk-2.38.0-h0630a04_3.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-core-2.40.3-h0630a04_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/atk-1.0-2.38.0-h04ea711_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.45.1-default_h4852527_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.45.1-default_h4852527_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.2.0-hed03a55_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.2.0-py314h3de4e8d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.4-he90730b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22.1.8-default_cfg_h361ecea_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22-22.1.8-default_ha9a2879_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22.1.8-default_h9fcfc6d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang_impl_linux-64-22.1.8-default_h6d37801_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.3.4-hc85cc9f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt22-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-he8ccf15_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.3-py314h97ea11e_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.14.3-py314h67df5f8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.28-hac629b4_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.4.0-hecca717_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/epoxy-1.5.10-hb03c661_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.18.1-h27c8c51_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.16-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h0dff253_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-h235f0fe_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h50e9bb6_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.44.7-h2b0a6b4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/glib-tools-2.88.2-h8094192_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.15-hecca717_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/graphviz-14.1.2-h8b86629_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gtk3-3.24.52-ha5ea40c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gts-0.7.6-h977cf35_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-h2185e75_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-hd240bd5_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-14.2.1-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/hicolor-icon-theme-0.17-ha770c72_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.5.0-py314h97ea11e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbde042b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20260107.1-cxx17_h7b12aa8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h6c227bf_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcompiler-rt-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h7a8fb5f_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hae6b9f4_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libdate-3.0.4-h5888daf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.127-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-devel-1.7.0-ha4b6fd6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgd-2.3.3-h5fbf134_12.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-devel-1.7.0-ha4b6fd6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.88.2-h0d30a3d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-devel-1.7.0-ha4b6fd6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-14.2.1-h17a8019_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-devel-14.2.1-h17a8019_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libntlm-1.8-hb9d3cd8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.33-pthreads_h94d23a6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.19-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-18.4-hd5a49e9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.33.5-h6eeba95_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.22.0-hd9031aa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libraqm-0.10.5-h6406941_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.62.3-h4c96295_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-h8f1669f_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.52.1-h280c20c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libvulkan-loader-1.4.341.0-h5279c79_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.13.2-hca5e8e5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.43-h711ed8c_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-22.1.8-h4922eb0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/make-4.4.1-hb9d3cd8_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py314h67df5f8_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.11.0-py314hdafbbf9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.11.0-py314had63eae_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.4-np2py314h6477eea_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-2.1.0-py314h518bba1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.2-h171cf75_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-24.18.0-h3d65ac4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.5.0-py314h2b28147_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.26.0-py314h112547c_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openldap-2.6.13-hbde042b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.56.4-hda50119_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.3.0-py314hdf18abd_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.46.4-h54a6638_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/prek-0.4.6-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/prettier-3.9.3-h7e4c9f4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-6.33.5-py314h61e7c5f_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h0f05182_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.11.1-py314h3987850_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.12.0-py314h0f05182_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py314h67df5f8_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.11.1-pl5321h16c4a6b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.15.20-h6a952e8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/shellcheck-0.11.0-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.5.7-py314h5bd0f2a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/typos-1.48.0-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/unicodedata2-17.0.1-py314h5bd0f2a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.25.0-hd6090a7_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-h4f16b4b_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.6-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.48-h280c20c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.6-he73a12e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.13-he1eb515_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.7-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.7-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.2-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.3-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.6-hecca717_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.5-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.7-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xorgproto-2025.1-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zizmor-1.26.1-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/accessible-pygments-0.0.5-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-1.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.6.0-py314h680f03e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.15.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.6.17-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-64-22.1.8-hffcefe0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-64-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.21.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/furo-2025.12.19-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.18-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-2.0.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-hf649bbc_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h9f08a49_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/linkify-it-py-2.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.6.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/myst-parser-5.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pydot-4.0.1-pyhcf101f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-4.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-py-4.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-81.0.0-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-3.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.8.4-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-8.2.3-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-basic-ng-1.0.0b2-pyhd8ed1ab_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-copybutton-0.5.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.5.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.1.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-2.0.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.15.0-h396c80c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/uc-micro-py-2.0.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.7.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - pypi: https://files.pythonhosted.org/packages/b6/2c/6e0aa56de08a48324eae2f0fda32d4ffc769dd72fafc62da55c1f7f14510/sphinx_exec_code-0.18-py3-none-any.whl
+      linux-aarch64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.16.1-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ast-serialize-0.6.0-py310h8c58d24_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/at-spi2-atk-2.38.0-h1f2db35_3.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/at-spi2-core-2.40.3-h1f2db35_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/atk-1.0-2.38.0-hedc4a1f_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils-2.45.1-default_hf1166c9_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45.1-default_h5f4c503_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.45.1-default_hf1166c9_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-1.2.0-hd651790_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-bin-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-python-1.2.0-py314h352cb57_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-ares-1.34.6-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-compiler-1.11.0-hdceaead_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cairo-1.18.4-h0b6afd8_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22.1.8-default_cfg_hf729886_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22-22.1.8-default_ha537bf4_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22.1.8-default_hb626d9f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang_impl_linux-aarch64-22.1.8-default_h2e8b6a6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cmake-4.3.4-hc9d863e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt22-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-gcc-specs-14.3.0-hadff5d6_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/contourpy-1.3.3-py314ha0cc70f_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.14.3-py314hb76de3f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cxx-compiler-1.11.0-h7b35c40_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cyrus-sasl-2.1.28-h6598af7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/double-conversion-3.4.0-hfae3067_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/epoxy-1.5.10-he30d5cf_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/fontconfig-2.18.1-hba86a56_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/freetype-2.14.3-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/fribidi-1.0.16-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc-14.3.0-h2e72a27_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-14.3.0-h398eab4_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-14.3.0-h140ef2e_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gdk-pixbuf-2.44.7-h90308e0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/glib-tools-2.88.2-h7aeb4f4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/graphite2-1.3.15-hfae3067_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/graphviz-14.1.2-h45e821f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gtk3-3.24.52-h75d4e7a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gts-0.7.6-he293c15_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx-14.3.0-ha28f942_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-14.3.0-h0d4f5d4_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-14.3.0-h0da240b_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/harfbuzz-14.2.1-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/hicolor-icon-theme-0.17-h8af1aa0_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/keyutils-1.6.3-h86ecc28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/kiwisolver-1.5.0-py314h4702e76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.22.2-h2fb54aa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lcms2-2.19.1-h9d5b58d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lerc-4.1.0-h52b7260_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20260107.1-cxx17_h6983b43_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.11.0-8_haddc8a3_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlicommon-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlidec-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlienc-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-8_hd72aa62_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang-cpp22.1-22.1.8-default_h0cc847a_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang13-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcompiler-rt-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcups-2.3.3-h4f2b762_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcurl-8.21.0-h7c59cd8_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdate-3.0.4-h5ad3122_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdeflate-1.25-h1af38f5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdrm-2.4.127-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libedit-3.1.20250104-pl5321h976ea20_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libegl-1.7.0-hd24410f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libegl-devel-1.7.0-hd24410f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libev-4.33-h31becfc_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.3-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.3-hdae7a39_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgd-2.3.3-h88aa843_12.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-1.7.0-hd24410f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-devel-1.7.0-hd24410f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.88.2-h96a7f82_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-devel-1.7.0-hd24410f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libharfbuzz-14.2.1-h3a99ef3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libharfbuzz-devel-14.2.1-h3a99ef3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjpeg-turbo-3.1.4.1-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.11.0-8_h88aeb00_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libllvm22-22.1.8-hfd2ba90_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnghttp2-1.68.1-hd3077d7_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libntlm-1.4-hf897c2e_1002.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.33-pthreads_h9d3fd7e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopengl-1.7.0-hd24410f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpciaccess-0.19-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpng-1.6.58-h1abf092_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpq-18.4-hccacd55_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.33.5-h306233d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpsl-0.22.0-h504d594_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libraqm-0.10.5-hd2f8911_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/librsvg-2.62.3-hf685517_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-14.3.0-hedb4206_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libssh2-1.11.1-h18c354c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuv-1.52.1-h80f16a2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libvulkan-loader-1.4.341.0-h8b8848b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libwebp-base-1.6.0-ha2e29f5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcb-1.17.0-h262b8f6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxkbcommon-1.13.2-h3c6a4c8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h79dcc73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h869d058_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxslt-1.1.43-h6700d25_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llvm-openmp-22.1.8-he40846f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/make-4.4.1-h2a6d0cb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py314hb76de3f_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/matplotlib-3.11.0-py314ha42fa4b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/matplotlib-base-3.11.0-py314h99b9003_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ml_dtypes-0.5.4-np2py314h175d3ba_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-2.1.0-py314h42c854d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ninja-1.13.2-hdc560ac_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/nodejs-24.18.0-h7ca28ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.5.0-py314he1698a1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.26.0-py314ha1c0044_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openjpeg-2.5.4-h5da879a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openldap-2.6.13-h2fb54aa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pango-1.56.4-h8547ced_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pcre2-10.47-hf841c20_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pillow-11.3.0-py314h033a589_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pixman-0.46.4-h7ac5ae9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prek-0.4.6-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prettier-3.9.3-h70496c1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-6.33.5-py314hb844caf_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.2.2-py314h2e8dab5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pthread-stubs-0.4-h86ecc28_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pyside6-6.11.1-py314ha37eecc_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-librt-0.12.0-py314h2e8dab5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pyyaml-6.0.3-py314h807365f_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/qhull-2020.2-h70be974_5.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/qt6-main-6.11.1-pl5321heaece2b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rhash-1.4.6-h86ecc28_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.15.20-h88be79b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/shellcheck-0.11.0-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tornado-6.5.7-py314hafb4487_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/typos-1.48.0-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/unicodedata2-17.0.1-py314h51f160d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/wayland-1.25.0-h4f8a99f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-0.4.1-hca56bd8_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-cursor-0.1.6-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-image-0.4.0-h5c728e9_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-keysyms-0.4.1-h5c728e9_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-renderutil-0.3.10-h5c728e9_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-wm-0.4.2-h5c728e9_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xkeyboard-config-2.48-h80f16a2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libice-1.1.2-h86ecc28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libsm-1.2.6-h0808dbd_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libx11-1.8.13-h63a1b12_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxau-1.0.12-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxcomposite-0.4.7-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxcursor-1.2.3-h86ecc28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxdamage-1.1.6-h86ecc28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxdmcp-1.1.5-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxext-1.3.7-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxfixes-6.0.2-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxi-1.8.3-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxinerama-1.1.6-hfae3067_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxrandr-1.5.5-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxrender-0.9.12-h86ecc28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxtst-1.2.5-h57736b2_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxxf86vm-1.1.7-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-xorgproto-2025.1-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/yaml-0.2.5-h80f16a2_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zizmor-1.26.1-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/accessible-pygments-0.0.5-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-1.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.6.0-py314h680f03e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.15.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.6.17-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-aarch64-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-aarch64-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.21.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/furo-2025.12.19-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.18-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-2.0.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-14.3.0-h25ba3ff_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-14.3.0-h57c8d61_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/linkify-it-py-2.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.6.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/myst-parser-5.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pydot-4.0.1-pyhcf101f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-4.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-py-4.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-81.0.0-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-3.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.8.4-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-8.2.3-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-basic-ng-1.0.0b2-pyhd8ed1ab_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-copybutton-0.5.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.5.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.1.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-2.0.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.15.0-h396c80c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/uc-micro-py-2.0.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.7.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - pypi: https://files.pythonhosted.org/packages/b6/2c/6e0aa56de08a48324eae2f0fda32d4ffc769dd72fafc62da55c1f7f14510/sphinx_exec_code-0.18-py3-none-any.whl
+      osx-arm64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/accessible-pygments-0.0.5-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-1.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.6.0-py314h680f03e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.15.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.6.17-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.21.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/furo-2025.12.19-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.18-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-2.0.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libcxx-headers-19.1.7-h707e725_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/linkify-it-py-2.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.6.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/myst-parser-5.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pydot-4.0.1-pyhcf101f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-4.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-py-4.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sdkroot_env_osx-arm64-26.0-ha3f98da_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-81.0.0-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-3.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.8.4-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-8.2.3-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-basic-ng-1.0.0b2-pyhd8ed1ab_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-copybutton-0.5.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.5.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.1.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-2.0.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.15.0-h396c80c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/uc-micro-py-2.0.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.7.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ast-serialize-0.6.0-py310h3b8a9b8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/atk-1.0-2.38.0-hd03087b_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-1.2.0-h7d5ae5b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-bin-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.2.0-py314h3daef5d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.4-he0f2337_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1030.6.3-llvm19_1_hd01ab73_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_impl_osx-arm64-1030.6.3-llvm19_1_he8a363d_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1030.6.3-llvm19_1_hd01ab73_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_hf3020a7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22-22.1.8-default_h8e162e0_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22.1.8-default_h8e162e0_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h75f8d18_32.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_hc995acf_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h75f8d18_32.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.3.4-h8cb302d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.3-py314hf8a3a22_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.14.3-py314h6e9b3f0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/epoxy-1.5.10-hc919400_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.18.1-h2b252f5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.14.3-hce30654_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.16-hc919400_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gdk-pixbuf-2.44.7-h4e57454_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/glib-tools-2.88.2-h246a70f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.15-hf6b4638_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphviz-14.1.2-hec8c438_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gtk3-3.24.52-hc0f3e19_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gts-0.7.6-he42f4ea_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/harfbuzz-14.2.1-hce30654_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/hicolor-icon-theme-0.17-hce30654_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-78.3-hef89b57_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.5.0-py314hf8a3a22_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-hfd3d5f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-956.6-llvm19_1_he86490a_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-956.6-llvm19_1_ha2625f7_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.1.0-h1eee2c3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20260107.1-cxx17_h2062a1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.11.0-8_h51639a9_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.11.0-8_hb0561ab_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_hf3020a7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp22.1-22.1.8-default_hdca5a3d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.21.0-h1359186_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdate-3.0.4-h286801f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.25-hc11a715_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.3-hdfa99f5_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgd-2.3.3-h05bcc79_12.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.88.2-ha08bb59_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-14.2.1-h5a65909_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-devel-14.2.1-h5a65909_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.1.4.1-h84a0fba_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.11.0-8_hd9741b5_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm22-22.1.8-h89af1be_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.33-openmp_he657e61_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.58-h132b30e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-6.33.5-h2d4b707_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpsl-0.22.0-hb427e8f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libraqm-0.10.5-h45af499_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/librsvg-2.62.3-he8aa2a2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsigtool-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.1-h4030677_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.52.1-h1a92334_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.6.0-h07db88b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.3-h5ef1a60_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.3-h5654f7c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/make-4.4.1-hc9fafa5_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py314h6e9b3f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.11.0-py314he55896b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.11.0-py314hf6804ef_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.5.4-np2py314hdd732f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-2.1.0-py314h2fbedac_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.2-h49c215f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-24.18.0-h654b19f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.5.0-py314hb79c6fa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.26.0-py314h236feb1_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pango-1.56.4-hf80efc4_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.47-h30297fc_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-11.3.0-py314haf93fec_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.46.4-h81086ad_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prek-0.4.6-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prettier-3.9.3-h57cd9b8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-6.33.5-py314he407d35_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py314ha14b1ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.6-h156bc91_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.12.0-py314ha14b1ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.3-py314h6e9b3f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.15.20-h80928e0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/shellcheck-0.11.0-hecfb573_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-codesign-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1600.0.11.8-h997e182_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.5.7-py314h6c2aa35_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/typos-1.48.0-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/unicodedata2-17.0.1-py314h6c2aa35_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h925e9cb_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zizmor-1.26.1-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda
+      - pypi: https://files.pythonhosted.org/packages/b6/2c/6e0aa56de08a48324eae2f0fda32d4ffc769dd72fafc62da55c1f7f14510/sphinx_exec_code-0.18-py3-none-any.whl
+      win-64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/accessible-pygments-0.0.5-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-1.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.6.0-py314h680f03e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.15.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.6.17-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_win-64-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.21.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/furo-2025.12.19-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.18-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-2.0.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/linkify-it-py-2.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.6.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/myst-parser-5.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pydot-4.0.1-pyhcf101f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyh09c184e_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-4.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-py-4.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-81.0.0-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-3.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.8.4-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-8.2.3-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-basic-ng-1.0.0b2-pyhd8ed1ab_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-copybutton-0.5.2-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.5.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.1.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-2.0.0-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-2.0.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.15.0-h396c80c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/uc-micro-py-2.0.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.7.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/win_inet_pton-1.1.0-pyh7428d3b_8.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ast-serialize-0.6.0-py310ha413424_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/brotli-1.2.0-h2d644bc_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/brotli-bin-1.2.0-hfd05255_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.2.0-py314he701e3d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/c-compiler-1.11.0-h528c1b4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/cairo-1.18.4-h477c42c_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22-22.1.8-default_hf735972_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22.1.8-default_nocfg_haf066c4_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-format-22.1.8-default_h5ef374e_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.3.4-hdcbee5b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/compiler-rt22-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/contourpy-1.3.3-py314hf309875_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.14.3-py314h2359020_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/double-conversion-3.4.0-hac47afa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.18.1-hd47e2ca_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/freetype-2.14.3-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/fribidi-1.0.16-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/getopt-win32-0.1-h6a83c73_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/glib-2.88.2-h395db07_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/glib-tools-2.88.2-h74ecf4c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/graphite2-1.3.15-hac47afa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/graphviz-14.1.2-h4c50273_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/gts-0.7.6-h6b5321d_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-14.2.1-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.3-h637d24d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/kiwisolver-1.5.0-py314hf309875_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h719d79b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/lcms2-2.19.1-hf2c6c5f_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.1.0-hd936e49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20260107.1-cxx17_h0eb2380_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-8_h8455456_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlicommon-1.2.0-hfd05255_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlidec-1.2.0-hfd05255_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlienc-1.2.0-hfd05255_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-8_h2a3cdd5_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libclang13-22.1.8-default_hf735972_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.21.0-h51a1c48_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libdate-3.0.4-he0c23c2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libdeflate-1.25-h51727cc_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.3-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.3-hdbac1cb_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.2.0-h8ee18e1_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libgd-2.3.3-h4974f7c_12.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.88.2-h7ce1215_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.2.0-h8ee18e1_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libharfbuzz-14.2.1-h03b5201_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libharfbuzz-devel-14.2.1-h03b5201_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.13.0-default_h049141e_1000.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-devel-0.22.5-h5728263_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.1.4.1-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-8_hf9ab0e9_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.58-h7351971_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-6.33.5-h6cf2d3c_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libpsl-0.22.0-hc1744f7_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libraqm-0.10.5-h50d6d30_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.1-h8f73337_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.52.1-h6a83c73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libvulkan-loader-1.4.341.0-h477610d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libwebp-base-1.6.0-h4d5522a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_10.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxcb-1.17.0-h0e4246c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h3cfd58e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-h8ef44ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxslt-1.1.43-h0fbe4c1_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/make-4.4.1-h0e40799_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/markupsafe-3.0.3-py314h2359020_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-3.11.0-py314h86ab7b2_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-base-3.11.0-py314hd0c49b1_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2026.0.0-hac47afa_908.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ml_dtypes-0.5.4-np2py314hb7a55bc_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/mypy-2.1.0-py314h13f4da2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.2-h477610d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/nodejs-24.18.0-h80d1838_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.5.0-py314h02f10f6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.0.0-h57928b3_908.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.26.0-py314h8bd40d1_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openjpeg-2.5.4-h0e57b4f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pango-1.56.4-h13911b6_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.47-hd2b5f0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pillow-11.3.0-py314hb9a687b_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pixman-0.46.4-h5112557_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/prek-0.4.6-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/prettier-3.9.3-hc21fffc_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-6.33.5-py314h6a447be_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py314hc5dbbe4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pthread-stubs-0.4-h0e40799_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pyside6-6.11.1-py314h447aaf0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.12.0-py314hc5dbbe4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.3-py314h2359020_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/qhull-2020.2-hc790b64_5.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/qt6-main-6.11.1-pl5321hfcac499_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ruff-0.15.20-h45713df_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/shellcheck-0.11.0-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2023.0.0-hd3d4ead_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tornado-6.5.7-py314h5a2d7ad_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/typos-1.48.0-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/unicodedata2-17.0.1-py314h5a2d7ad_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libice-1.1.2-h0e40799_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libsm-1.2.6-h0e40799_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libx11-1.8.13-hfa52320_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxau-1.0.12-hba3369d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxdmcp-1.1.5-hba3369d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxext-1.3.7-hba3369d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxpm-3.5.19-hba3369d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxt-1.3.1-h0e40799_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h6a83c73_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zizmor-1.26.1-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zlib-1.3.2-hfd05255_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda
+      - pypi: https://files.pythonhosted.org/packages/b6/2c/6e0aa56de08a48324eae2f0fda32d4ffc769dd72fafc62da55c1f7f14510/sphinx_exec_code-0.18-py3-none-any.whl
+  link-checker:
+    channels:
+    - url: https://conda.anaconda.org/conda-forge/
+    packages:
+      linux-64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/lychee-0.24.2-he64ecbb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      linux-aarch64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lychee-0.24.2-hb434046_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      osx-arm64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lychee-0.24.2-h17e24d4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda
+      win-64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/lychee-0.24.2-hb3eb754_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda
+  lintrunner:
+    channels:
+    - url: https://conda.anaconda.org/conda-forge/
+    indexes:
+    - https://pypi.org/simple
+    packages:
+      linux-64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ast-serialize-0.6.0-py310hd8a072f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.45.1-default_h4852527_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.45.1-default_h4852527_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22.1.8-default_cfg_h361ecea_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22-22.1.8-default_ha9a2879_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22.1.8-default_h9fcfc6d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang_impl_linux-64-22.1.8-default_h6d37801_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.3.4-hc85cc9f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt22-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-he8ccf15_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.14.3-py314h67df5f8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h0dff253_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-h235f0fe_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h50e9bb6_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-h2185e75_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-hd240bd5_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbde042b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20260107.1-cxx17_h7b12aa8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h6c227bf_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcompiler-rt-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hae6b9f4_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libdate-3.0.4-h5888daf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.33-pthreads_h94d23a6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.33.5-h6eeba95_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.22.0-hd9031aa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-h8f1669f_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.52.1-h280c20c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-22.1.8-h4922eb0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/make-4.4.1-hb9d3cd8_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.4-np2py314h6477eea_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-2.1.0-py314h518bba1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.2-h171cf75_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-24.18.0-h3d65ac4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.5.0-py314h2b28147_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.26.0-py314h112547c_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.3.0-py314hdf18abd_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/prek-0.4.6-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/prettier-3.9.3-h7e4c9f4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-6.33.5-py314h61e7c5f_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h0f05182_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.12.0-py314h0f05182_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.15.20-h6a952e8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/shellcheck-0.11.0-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/typos-1.48.0-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zizmor-1.26.1-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-64-22.1.8-hffcefe0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-64-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-hf649bbc_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h9f08a49_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - pypi: https://files.pythonhosted.org/packages/2a/df/bac34bce3e99f3a73ad1e244ecdc40790e85ac4caffff820ebf36e0a892a/lintrunner_adapters-0.14.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/c5/1d/bc26dd9dcb7bb364f25cbfec2da6b28e9cfe849285c9debf8baf94e78e10/lintrunner-0.13.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
+      - pypi: https://files.pythonhosted.org/packages/e6/dd/ca9c996a7e4de9d350d18d2146cb2a8da5cb7b4ea31fef32c75b830ce28f/editorconfig-checker-3.2.1.tar.gz
+      - pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl
+      linux-aarch64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ast-serialize-0.6.0-py310h8c58d24_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils-2.45.1-default_hf1166c9_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45.1-default_h5f4c503_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.45.1-default_hf1166c9_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-ares-1.34.6-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-compiler-1.11.0-hdceaead_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22.1.8-default_cfg_hf729886_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22-22.1.8-default_ha537bf4_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22.1.8-default_hb626d9f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang_impl_linux-aarch64-22.1.8-default_h2e8b6a6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cmake-4.3.4-hc9d863e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt22-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-gcc-specs-14.3.0-hadff5d6_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.14.3-py314hb76de3f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cxx-compiler-1.11.0-h7b35c40_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc-14.3.0-h2e72a27_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-14.3.0-h398eab4_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-14.3.0-h140ef2e_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx-14.3.0-ha28f942_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-14.3.0-h0d4f5d4_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-14.3.0-h0da240b_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/keyutils-1.6.3-h86ecc28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.22.2-h2fb54aa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lcms2-2.19.1-h9d5b58d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lerc-4.1.0-h52b7260_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20260107.1-cxx17_h6983b43_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.11.0-8_haddc8a3_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlicommon-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlidec-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlienc-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-8_hd72aa62_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang-cpp22.1-22.1.8-default_h0cc847a_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang13-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcompiler-rt-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcurl-8.21.0-h7c59cd8_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdate-3.0.4-h5ad3122_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdeflate-1.25-h1af38f5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libedit-3.1.20250104-pl5321h976ea20_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libev-4.33-h31becfc_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.3-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.3-hdae7a39_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjpeg-turbo-3.1.4.1-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.11.0-8_h88aeb00_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libllvm22-22.1.8-hfd2ba90_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnghttp2-1.68.1-hd3077d7_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.33-pthreads_h9d3fd7e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpng-1.6.58-h1abf092_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.33.5-h306233d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpsl-0.22.0-h504d594_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-14.3.0-hedb4206_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libssh2-1.11.1-h18c354c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuv-1.52.1-h80f16a2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libwebp-base-1.6.0-ha2e29f5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcb-1.17.0-h262b8f6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h79dcc73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h869d058_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llvm-openmp-22.1.8-he40846f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/make-4.4.1-h2a6d0cb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ml_dtypes-0.5.4-np2py314h175d3ba_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-2.1.0-py314h42c854d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ninja-1.13.2-hdc560ac_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/nodejs-24.18.0-h7ca28ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.5.0-py314he1698a1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.26.0-py314ha1c0044_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openjpeg-2.5.4-h5da879a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pillow-11.3.0-py314h033a589_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prek-0.4.6-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prettier-3.9.3-h70496c1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-6.33.5-py314hb844caf_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.2.2-py314h2e8dab5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pthread-stubs-0.4-h86ecc28_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-librt-0.12.0-py314h2e8dab5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rhash-1.4.6-h86ecc28_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.15.20-h88be79b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/shellcheck-0.11.0-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/typos-1.48.0-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxau-1.0.12-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxdmcp-1.1.5-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zizmor-1.26.1-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-aarch64-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-aarch64-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-14.3.0-h25ba3ff_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-14.3.0-h57c8d61_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - pypi: https://files.pythonhosted.org/packages/2a/df/bac34bce3e99f3a73ad1e244ecdc40790e85ac4caffff820ebf36e0a892a/lintrunner_adapters-0.14.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/94/62/ea27e6e4152d633d9b68eec400d1bf0c972d3986e88a6f07a2a19f8ec74a/lintrunner-0.13.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl
+      - pypi: https://files.pythonhosted.org/packages/e6/dd/ca9c996a7e4de9d350d18d2146cb2a8da5cb7b4ea31fef32c75b830ce28f/editorconfig-checker-3.2.1.tar.gz
+      - pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl
+      osx-arm64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libcxx-headers-19.1.7-h707e725_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sdkroot_env_osx-arm64-26.0-ha3f98da_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ast-serialize-0.6.0-py310h3b8a9b8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1030.6.3-llvm19_1_hd01ab73_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_impl_osx-arm64-1030.6.3-llvm19_1_he8a363d_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1030.6.3-llvm19_1_hd01ab73_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_hf3020a7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22-22.1.8-default_h8e162e0_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22.1.8-default_h8e162e0_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h75f8d18_32.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_hc995acf_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h75f8d18_32.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.3.4-h8cb302d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.14.3-py314h6e9b3f0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-78.3-hef89b57_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-hfd3d5f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-956.6-llvm19_1_he86490a_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-956.6-llvm19_1_ha2625f7_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.1.0-h1eee2c3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20260107.1-cxx17_h2062a1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.11.0-8_h51639a9_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.11.0-8_hb0561ab_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_hf3020a7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp22.1-22.1.8-default_hdca5a3d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.21.0-h1359186_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdate-3.0.4-h286801f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.25-hc11a715_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.3-hdfa99f5_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.1.4.1-h84a0fba_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.11.0-8_hd9741b5_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm22-22.1.8-h89af1be_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.33-openmp_he657e61_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.58-h132b30e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-6.33.5-h2d4b707_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpsl-0.22.0-hb427e8f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsigtool-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.1-h4030677_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.52.1-h1a92334_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.6.0-h07db88b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.3-h5ef1a60_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.3-h5654f7c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/make-4.4.1-hc9fafa5_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.5.4-np2py314hdd732f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-2.1.0-py314h2fbedac_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.2-h49c215f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-24.18.0-h654b19f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.5.0-py314hb79c6fa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.26.0-py314h236feb1_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-11.3.0-py314haf93fec_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prek-0.4.6-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prettier-3.9.3-h57cd9b8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-6.33.5-py314he407d35_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py314ha14b1ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.6-h156bc91_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.12.0-py314ha14b1ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.15.20-h80928e0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/shellcheck-0.11.0-hecfb573_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-codesign-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1600.0.11.8-h997e182_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/typos-1.48.0-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zizmor-1.26.1-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda
+      - pypi: https://files.pythonhosted.org/packages/1e/c4/2632b200d3a7f9490765b2cf1550510af4a0b9a4c890f522dda721a0536f/lintrunner-0.13.1-py3-none-macosx_11_0_arm64.whl
+      - pypi: https://files.pythonhosted.org/packages/2a/df/bac34bce3e99f3a73ad1e244ecdc40790e85ac4caffff820ebf36e0a892a/lintrunner_adapters-0.14.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/e6/dd/ca9c996a7e4de9d350d18d2146cb2a8da5cb7b4ea31fef32c75b830ce28f/editorconfig-checker-3.2.1.tar.gz
+      - pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl
+      win-64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_win-64-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ast-serialize-0.6.0-py310ha413424_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/c-compiler-1.11.0-h528c1b4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22-22.1.8-default_hf735972_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22.1.8-default_nocfg_haf066c4_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-format-22.1.8-default_h5ef374e_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.3.4-hdcbee5b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/compiler-rt22-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.14.3-py314h2359020_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.3-h637d24d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h719d79b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/lcms2-2.19.1-hf2c6c5f_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.1.0-hd936e49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20260107.1-cxx17_h0eb2380_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-8_h8455456_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-8_h2a3cdd5_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libclang13-22.1.8-default_hf735972_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.21.0-h51a1c48_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libdate-3.0.4-he0c23c2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libdeflate-1.25-h51727cc_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.3-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.3-hdbac1cb_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.2.0-h8ee18e1_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.2.0-h8ee18e1_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.13.0-default_h049141e_1000.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.1.4.1-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-8_hf9ab0e9_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.58-h7351971_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-6.33.5-h6cf2d3c_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libpsl-0.22.0-hc1744f7_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.1-h8f73337_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.52.1-h6a83c73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libwebp-base-1.6.0-h4d5522a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_10.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxcb-1.17.0-h0e4246c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h3cfd58e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-h8ef44ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/make-4.4.1-h0e40799_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2026.0.0-hac47afa_908.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ml_dtypes-0.5.4-np2py314hb7a55bc_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/mypy-2.1.0-py314h13f4da2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.2-h477610d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/nodejs-24.18.0-h80d1838_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.5.0-py314h02f10f6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.0.0-h57928b3_908.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.26.0-py314h8bd40d1_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openjpeg-2.5.4-h0e57b4f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pillow-11.3.0-py314hb9a687b_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/prek-0.4.6-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/prettier-3.9.3-hc21fffc_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-6.33.5-py314h6a447be_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py314hc5dbbe4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pthread-stubs-0.4-h0e40799_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.12.0-py314hc5dbbe4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ruff-0.15.20-h45713df_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/shellcheck-0.11.0-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2023.0.0-hd3d4ead_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/typos-1.48.0-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxau-1.0.12-hba3369d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxdmcp-1.1.5-hba3369d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zizmor-1.26.1-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda
+      - pypi: https://files.pythonhosted.org/packages/2a/df/bac34bce3e99f3a73ad1e244ecdc40790e85ac4caffff820ebf36e0a892a/lintrunner_adapters-0.14.0-py3-none-any.whl
+      - pypi: https://files.pythonhosted.org/packages/8e/d0/1c14e394a4614056b75e7844d7e29c51e3eb5cd5ae8c9756933f45cd9143/lintrunner-0.13.1-py3-none-win_amd64.whl
+      - pypi: https://files.pythonhosted.org/packages/e6/dd/ca9c996a7e4de9d350d18d2146cb2a8da5cb7b4ea31fef32c75b830ce28f/editorconfig-checker-3.2.1.tar.gz
+      - pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl
+  oldies:
+    channels:
+    - url: https://conda.anaconda.org/conda-forge/
+    packages:
+      linux-64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ast-serialize-0.6.0-py310hd8a072f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.45.1-default_h4852527_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.45.1-default_h4852527_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22.1.8-default_cfg_h361ecea_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22-22.1.8-default_ha9a2879_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22.1.8-default_h9fcfc6d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/clang_impl_linux-64-22.1.8-default_h6d37801_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.3.4-hc85cc9f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt22-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-he8ccf15_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.14.3-py310h3406613_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h0dff253_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-h235f0fe_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h50e9bb6_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-h2185e75_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-hd240bd5_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbde042b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20250512.1-cxx17_hba17884_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h6c227bf_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-22.1.8-default_h9692865_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcompiler-rt-22.1.8-hb700be7_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hae6b9f4_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libdate-3.0.4-h5888daf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.33-pthreads_h94d23a6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.31.1-hfb7daa7_5.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.22.0-hd9031aa_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-h8f1669f_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.52.1-h280c20c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-22.1.8-h4922eb0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/make-4.4.1-hb9d3cd8_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.4-np2py310h3d4ba91_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-2.1.0-py310h99dffb4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.2-h171cf75_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-24.18.0-h3d65ac4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.23.2-py310h53a5b5f_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.26.0-py310hddea34e_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.3.0-py310h6557065_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/prek-0.4.6-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/prettier-3.9.3-h7e4c9f4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-6.31.1-py310ha36e12e_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py310h139afa4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.20-h267e890_1_cpython.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.12.0-py310h139afa4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.15.20-h6a952e8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/shellcheck-0.11.0-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/typos-1.48.0-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zizmor-1.26.1-hb17b654_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-64-22.1.8-hffcefe0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-64-22.1.8-ha770c72_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-hf649bbc_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h9f08a49_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh8b19718_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      linux-aarch64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ast-serialize-0.6.0-py310h8c58d24_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils-2.45.1-default_hf1166c9_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45.1-default_h5f4c503_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.45.1-default_hf1166c9_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-ares-1.34.6-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-compiler-1.11.0-hdceaead_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22.1.8-default_cfg_hf729886_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22-22.1.8-default_ha537bf4_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22.1.8-default_hb626d9f_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang_impl_linux-aarch64-22.1.8-default_h2e8b6a6_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cmake-4.3.4-hc9d863e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt22-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-gcc-specs-14.3.0-hadff5d6_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.14.3-py310h3b5aacf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cxx-compiler-1.11.0-h7b35c40_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc-14.3.0-h2e72a27_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-14.3.0-h398eab4_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-14.3.0-h140ef2e_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx-14.3.0-ha28f942_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-14.3.0-h0d4f5d4_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-14.3.0-h0da240b_27.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/keyutils-1.6.3-h86ecc28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.22.2-h2fb54aa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lcms2-2.19.1-h9d5b58d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lerc-4.1.0-h52b7260_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20250512.1-cxx17_h201e9ed_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.11.0-8_haddc8a3_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlicommon-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlidec-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlienc-1.2.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-8_hd72aa62_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang-cpp22.1-22.1.8-default_h0cc847a_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang13-22.1.8-default_hd92691d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcompiler-rt-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcurl-8.21.0-h7c59cd8_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdate-3.0.4-h5ad3122_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdeflate-1.25-h1af38f5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libedit-3.1.20250104-pl5321h976ea20_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libev-4.33-h31becfc_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.3-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.3-hdae7a39_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjpeg-turbo-3.1.4.1-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.11.0-8_h88aeb00_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libllvm22-22.1.8-hfd2ba90_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnghttp2-1.68.1-hd3077d7_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h86ecc28_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.33-pthreads_h9d3fd7e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpng-1.6.58-h1abf092_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.31.1-h61c7711_5.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpsl-0.22.0-h504d594_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-14.3.0-hedb4206_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libssh2-1.11.1-h18c354c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuv-1.52.1-h80f16a2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libwebp-base-1.6.0-ha2e29f5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcb-1.17.0-h262b8f6_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h79dcc73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h869d058_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llvm-openmp-22.1.8-he40846f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/make-4.4.1-h2a6d0cb_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ml_dtypes-0.5.4-np2py310h230c07e_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-2.1.0-py310hec1369a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ninja-1.13.2-hdc560ac_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/nodejs-24.18.0-h7ca28ff_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.23.2-py310he617cf3_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.26.0-py310h9bc1938_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openjpeg-2.5.4-h5da879a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pillow-11.3.0-py310h35255db_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prek-0.4.6-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prettier-3.9.3-h70496c1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-6.31.1-py310h71259a2_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.2.2-py310hef25091_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pthread-stubs-0.4-h86ecc28_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.10.20-h4f76b5d_1_cpython.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-librt-0.12.0-py310hef25091_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rhash-1.4.6-h86ecc28_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.15.20-h88be79b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/shellcheck-0.11.0-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/typos-1.48.0-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxau-1.0.12-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxdmcp-1.1.5-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zizmor-1.26.1-h069e38c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-aarch64-22.1.8-hfefdfc9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-aarch64-22.1.8-h8af1aa0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-14.3.0-h25ba3ff_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-14.3.0-h57c8d61_119.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh8b19718_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      osx-arm64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/libcxx-headers-19.1.7-h707e725_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh8b19718_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/sdkroot_env_osx-arm64-26.0-ha3f98da_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ast-serialize-0.6.0-py310h3b8a9b8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1030.6.3-llvm19_1_hd01ab73_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_impl_osx-arm64-1030.6.3-llvm19_1_he8a363d_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1030.6.3-llvm19_1_hd01ab73_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_hf3020a7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22-22.1.8-default_h8e162e0_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22.1.8-default_h8e162e0_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h75f8d18_32.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_hc995acf_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h75f8d18_32.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.3.4-h8cb302d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.14.3-py310hb46c203_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-78.3-hef89b57_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-hfd3d5f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-956.6-llvm19_1_he86490a_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-956.6-llvm19_1_ha2625f7_4.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.1.0-h1eee2c3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20250512.1-cxx17_hd41c47c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.11.0-8_h51639a9_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.2.0-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.11.0-8_hb0561ab_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_hf3020a7_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp22.1-22.1.8-default_hdca5a3d_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.21.0-h1359186_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdate-3.0.4-h286801f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.25-hc11a715_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.3-hdfa99f5_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.1.4.1-h84a0fba_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.11.0-8_hd9741b5_openblas.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm22-22.1.8-h89af1be_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.33-openmp_he657e61_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.58-h132b30e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-6.31.1-h29102cf_5.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpsl-0.22.0-hb427e8f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsigtool-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.1-h4030677_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.52.1-h1a92334_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.6.0-h07db88b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.3-h5ef1a60_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.3-h5654f7c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/make-4.4.1-hc9fafa5_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.5.4-np2py310h4beac76_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-2.1.0-py310hbc1dcdd_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.2-h49c215f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-24.18.0-h654b19f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.23.2-py310h127c7cf_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.26.0-py310h5553523_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-11.3.0-py310h5de80a5_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prek-0.4.6-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/prettier-3.9.3-h57cd9b8_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-6.31.1-py310hc33aa15_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py310haea493c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.20-hac0b6dc_1_cpython.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.12.0-py310haea493c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.15.20-h80928e0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/shellcheck-0.11.0-hecfb573_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-codesign-0.1.3-h98dc951_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1600.0.11.8-h997e182_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/typos-1.48.0-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hc919400_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zizmor-1.26.1-h6fdd925_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda
+      win-64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_win-64-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh8b19718_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ast-serialize-0.6.0-py310ha413424_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/c-compiler-1.11.0-h528c1b4_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22-22.1.8-default_hf735972_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-22.1.8-default_nocfg_haf066c4_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/clang-format-22.1.8-default_h5ef374e_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.3.4-hdcbee5b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/compiler-rt22-22.1.8-h49e36cd_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.14.3-py310hdb0e946_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.3-h637d24d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h719d79b_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/lcms2-2.19.1-hf2c6c5f_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.1.0-hd936e49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20250512.1-cxx17_habfad5f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-8_h8455456_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-8_h2a3cdd5_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libclang13-22.1.8-default_hf735972_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.21.0-h51a1c48_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libdate-3.0.4-he0c23c2_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libdeflate-1.25-h51727cc_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.3-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.3-hdbac1cb_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.2.0-h8ee18e1_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.2.0-h8ee18e1_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.13.0-default_h049141e_1000.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.1.4.1-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-8_hf9ab0e9_mkl.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.58-h7351971_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-6.31.1-h2ec36af_5.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libpsl-0.22.0-hc1744f7_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.1-h8f73337_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.52.1-h6a83c73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libwebp-base-1.6.0-h4d5522a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_10.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxcb-1.17.0-h0e4246c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h3cfd58e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-h8ef44ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/make-4.4.1-h0e40799_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2026.0.0-hac47afa_908.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ml_dtypes-0.5.4-np2py310h7578f05_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/mypy-2.1.0-py310h3b59f23_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.2-h477610d_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/nodejs-24.18.0-h80d1838_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.23.2-py310h8a5b91a_0.tar.bz2
+      - conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.0.0-h57928b3_908.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.26.0-py310he3e056b_0_cpu.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openjpeg-2.5.4-h0e57b4f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pillow-11.3.0-py310hb3a2f59_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/prek-0.4.6-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/prettier-3.9.3-hc21fffc_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-6.31.1-py310h81b7714_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py310h1637853_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pthread-stubs-0.4-h0e40799_1002.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.10.20-hc20f281_1_cpython.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.12.0-py310h1637853_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ruff-0.15.20-h45713df_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/shellcheck-0.11.0-h57928b3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2023.0.0-hd3d4ead_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/typos-1.48.0-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.51.36231-h84cd919_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxau-1.0.12-hba3369d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxdmcp-1.1.5-hba3369d_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zizmor-1.26.1-h18a1a76_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda
+  reuse:
+    channels:
+    - url: https://conda.anaconda.org/conda-forge/
+    packages:
+      linux-64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libmagic-5.48-h421ea60_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py314h67df5f8_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-26.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/binaryornot-0.6.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/boolean.py-5.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/chardet-7.4.3-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.4.1-pyhc90fa1f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/license-expression-30.4.4-pyhe01879c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-debian-1.1.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-magic-0.4.27-pyhd7f29a5_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/reuse-6.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      linux-aarch64:
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmagic-5.48-h1abf092_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py314hb76de3f_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda
+      - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-26.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/binaryornot-0.6.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/boolean.py-5.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/chardet-7.4.3-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.4.1-pyhc90fa1f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/license-expression-30.4.4-pyhe01879c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-debian-1.1.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-magic-0.4.27-pyhd7f29a5_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/reuse-6.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      osx-arm64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-26.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/binaryornot-0.6.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/boolean.py-5.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/chardet-7.4.3-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.4.1-pyhc90fa1f_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/license-expression-30.4.4-pyhe01879c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-debian-1.1.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-magic-0.4.27-pyhd7f29a5_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/reuse-6.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmagic-5.48-h132b30e_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py314h6e9b3f0_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.6-h156bc91_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda
+      win-64:
+      - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-26.1.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/binaryornot-0.6.0-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/boolean.py-5.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/chardet-7.4.3-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.4.1-pyh6dadd2b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/license-expression-30.4.4-pyhe01879c_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-debian-1.1.1-pyhcf101f3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python-magic-0.4.27-pyhd7f29a5_7.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/reuse-6.2.0-pyhd8ed1ab_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libmagic-5.48-h94ac8d1_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/markupsafe-3.0.3-py314h2359020_1.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.47-hd2b5f0e_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda
+      - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda
+packages:
+- conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda
+  build_number: 20
+  sha256: 1dd3fffd892081df9726d7eb7e0dea6198962ba775bd88842135a4ddb4deb3c9
+  md5: a9f577daf3de00bca7c3c76c0ecbd1de
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgomp >=7.5.0
+  constrains:
+  - openmp_impl <0.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    strong:
+    - _openmp_mutex >=4.5
+  size: 28948
+  timestamp: 1770939786096
+- conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.16.1-hb03c661_0.conda
+  sha256: cf93ca0f1f107e95a35969a4622684e08fcb8cf37f8cf4a1e9e424828386c921
+  md5: 8904e09bda369377b3dd07e2ac828c5d
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: LGPL-2.1-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - alsa-lib >=1.2.16.1,<1.3.0a0
+  size: 592377
+  timestamp: 1781521980743
+- conda: https://conda.anaconda.org/conda-forge/linux-64/ast-serialize-0.6.0-py310hd8a072f_0.conda
+  noarch: python
+  sha256: 98eef90c96e2185254d12e667337077b989e9892167ff2c969e19b9296f42743
+  md5: 530aaeffb462b062bf8e3abb66879cf0
+  depends:
+  - python >=3.10
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - _python_abi3_support 1.*
+  - cpython >=3.10
+  constrains:
+  - __glibc >=2.17
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/ast-serialize?source=compressed-mapping
+  run_exports: {}
+  size: 1120486
+  timestamp: 1782863830347
+- conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-atk-2.38.0-h0630a04_3.tar.bz2
+  sha256: 26ab9386e80bf196e51ebe005da77d57decf6d989b4f34d96130560bc133479c
+  md5: 6b889f174df1e0f816276ae69281af4d
+  depends:
+  - at-spi2-core >=2.40.0,<2.41.0a0
+  - atk-1.0 >=2.36.0
+  - dbus >=1.13.6,<2.0a0
+  - libgcc-ng >=9.3.0
+  - libglib >=2.68.1,<3.0a0
+  license: LGPL-2.1-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - at-spi2-atk >=2.38.0,<3.0a0
+  size: 339899
+  timestamp: 1619122953439
+- conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-core-2.40.3-h0630a04_0.tar.bz2
+  sha256: c4f9b66bd94c40d8f1ce1fad2d8b46534bdefda0c86e3337b28f6c25779f258d
+  md5: 8cb2fc4cd6cc63f1369cfa318f581cc3
+  depends:
+  - dbus >=1.13.6,<2.0a0
+  - libgcc-ng >=9.3.0
+  - libglib >=2.68.3,<3.0a0
+  - xorg-libx11
+  - xorg-libxi
+  - xorg-libxtst
+  license: LGPL-2.1-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - at-spi2-core >=2.40.3,<2.41.0a0
+  size: 658390
+  timestamp: 1625848454791
+- conda: https://conda.anaconda.org/conda-forge/linux-64/atk-1.0-2.38.0-h04ea711_2.conda
+  sha256: df682395d05050cd1222740a42a551281210726a67447e5258968dd55854302e
+  md5: f730d54ba9cd543666d7220c9f7ed563
+  depends:
+  - libgcc-ng >=12
+  - libglib >=2.80.0,<3.0a0
+  - libstdcxx-ng >=12
+  constrains:
+  - atk-1.0 2.38.0
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - atk-1.0 >=2.38.0
+  size: 355900
+  timestamp: 1713896169874
+- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.45.1-default_h4852527_102.conda
+  sha256: 3c7c5580c1720206f28b7fa3d60d17986b3f32465e63009c14c9ae1ea64f926c
+  md5: 212fe5f1067445544c99dc1c847d032c
+  depends:
+  - binutils_impl_linux-64 >=2.45.1,<2.45.2.0a0
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 35436
+  timestamp: 1774197482571
+- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_102.conda
+  sha256: 0a7d405064f53b9d91d92515f1460f7906ee5e8523f3cd8973430e81219f4917
+  md5: 8165352fdce2d2025bf884dc0ee85700
+  depends:
+  - ld_impl_linux-64 2.45.1 default_hbd61a6d_102
+  - sysroot_linux-64
+  - zstd >=1.5.7,<1.6.0a0
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 3661455
+  timestamp: 1774197460085
+- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.45.1-default_h4852527_102.conda
+  sha256: 78a58d523d072b7f8e591b8f8572822e044b31764ed7e8d170392e7bc6d58339
+  md5: 2a307a17309d358c9b42afdd3199ddcc
+  depends:
+  - binutils_impl_linux-64 2.45.1 default_hfdba357_102
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 36304
+  timestamp: 1774197485247
+- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.2.0-hed03a55_1.conda
+  sha256: e511644d691f05eb12ebe1e971fd6dc3ae55a4df5c253b4e1788b789bdf2dfa6
+  md5: 8ccf913aaba749a5496c17629d859ed1
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - brotli-bin 1.2.0 hb03c661_1
+  - libbrotlidec 1.2.0 hb03c661_1
+  - libbrotlienc 1.2.0 hb03c661_1
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlicommon >=1.2.0,<1.3.0a0
+    - libbrotlienc >=1.2.0,<1.3.0a0
+    - libbrotlidec >=1.2.0,<1.3.0a0
+  size: 20103
+  timestamp: 1764017231353
+- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.2.0-hb03c661_1.conda
+  sha256: 64b137f30b83b1dd61db6c946ae7511657eead59fdf74e84ef0ded219605aa94
+  md5: af39b9a8711d4a8d437b52c1d78eb6a1
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libbrotlidec 1.2.0 hb03c661_1
+  - libbrotlienc 1.2.0 hb03c661_1
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 21021
+  timestamp: 1764017221344
+- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.2.0-py314h3de4e8d_1.conda
+  sha256: 3ad3500bff54a781c29f16ce1b288b36606e2189d0b0ef2f67036554f47f12b0
+  md5: 8910d2c46f7e7b519129f486e0fe927a
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - libbrotlicommon 1.2.0 hb03c661_1
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/brotli?source=hash-mapping
+  run_exports: {}
+  size: 367376
+  timestamp: 1764017265553
+- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda
+  sha256: 0b75d45f0bba3e95dc693336fa51f40ea28c980131fec438afb7ce6118ed05f6
+  md5: d2ffd7602c02f2b316fd921d39876885
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: bzip2-1.0.6
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - bzip2 >=1.0.8,<2.0a0
+  size: 260182
+  timestamp: 1771350215188
+- conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda
+  sha256: cc9accf72fa028d31c2a038460787751127317dcfa991f8d1f1babf216bb454e
+  md5: 920bb03579f15389b9e512095ad995b7
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - c-ares >=1.34.6,<2.0a0
+  size: 207882
+  timestamp: 1765214722852
+- conda: https://conda.anaconda.org/conda-forge/linux-64/c-compiler-1.11.0-h4d9bdce_0.conda
+  sha256: 8e7a40f16400d7839c82581410aa05c1f8324a693c9d50079f8c50dc9fb241f0
+  md5: abd85120de1187b0d1ec305c2173c71b
+  depends:
+  - binutils
+  - gcc
+  - gcc_linux-64 14.*
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 6693
+  timestamp: 1753098721814
+- conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.4-he90730b_1.conda
+  sha256: 06525fa0c4e4f56e771a3b986d0fdf0f0fc5a3270830ee47e127a5105bde1b9a
+  md5: bb6c4808bfa69d6f7f6b07e5846ced37
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - fontconfig >=2.15.0,<3.0a0
+  - fonts-conda-ecosystem
+  - icu >=78.1,<79.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libgcc >=14
+  - libglib >=2.86.3,<3.0a0
+  - libpng >=1.6.53,<1.7.0a0
+  - libstdcxx >=14
+  - libxcb >=1.17.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - pixman >=0.46.4,<1.0a0
+  - xorg-libice >=1.1.2,<2.0a0
+  - xorg-libsm >=1.2.6,<2.0a0
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxrender >=0.9.12,<0.10.0a0
+  license: LGPL-2.1-only or MPL-1.1
+  purls: []
+  run_exports:
+    weak:
+    - cairo >=1.18.4,<2.0a0
+  size: 989514
+  timestamp: 1766415934926
+- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22-22.1.8-default_h9692865_3.conda
+  sha256: 09c8ad191c20d536b992b8281a6f21a65dd0e3f25413950e69d1adc50940581c
+  md5: fd6b190b075e9ed7c46816d5934ba37b
+  depends:
+  - compiler-rt22 ==22.1.8
+  - libclang-cpp22.1 ==22.1.8 default_h6c227bf_3
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 941458
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-22.1.8-default_cfg_h361ecea_3.conda
+  sha256: e7bb173247bf3c4a7cab03797607433ef2dfb47553b1471056b81491f7e8e50a
+  md5: 280a7adc7eed3211243b39677cc7a325
+  depends:
+  - clang-22 ==22.1.8 default_h9692865_3
+  - llvm-openmp >=22.1.8
+  - clang_impl_linux-64 ==22.1.8 default_h6d37801_3
+  - binutils
+  - libgcc-devel_linux-64
+  - sysroot_linux-64
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 34135
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22-22.1.8-default_h713e2cb_3.conda
+  sha256: b5307d944220e1ac708db3976ea7d947ab6628fdc7da85278288b87305177292
+  md5: 7e170b31f1e81881690d8db6d7b0ed65
+  depends:
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libclang13 >=22.1.8
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 78566
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22-22.1.8-default_ha9a2879_3.conda
+  sha256: 4a3529c841888427c60997a752e93ca42e4081c29042ed64b72588af1095d026
+  md5: 3ec660deeb0b2dc7d162ad1aa11a284a
+  depends:
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang13 >=22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 78596
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22.1.8-default_h9fcfc6d_3.conda
+  sha256: 1b3393ee596b93f86de9bc269f4c2c8087c4918ae1596d7dfab827cc1d701c29
+  md5: 8de2301f31f582cd21f96f798ef8d541
+  depends:
+  - clang ==22.1.8 default_cfg_h361ecea_3
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - clang-format-22 ==22.1.8 default_ha9a2879_3
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang13 >=22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 36104
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-format-22.1.8-default_he96069b_3.conda
+  sha256: 1724b544e2601c604625585b2393407a7727bb5bd7bccf07bf3227c967e5737f
+  md5: 9d1fd0df7db7942dcbb3168da6192f43
+  depends:
+  - clang ==22.1.8 default_cfg_h361ecea_3
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - clang-format-22 ==22.1.8 default_h713e2cb_3
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang13 >=22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 36062
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-scan-deps-22.1.8-default_h1381bd0_3.conda
+  sha256: a4743c330ca13164f5b4e20de337454f71b2e5a1c9ea45a355bf3c1606b16dff
+  md5: 8f5220117eb3b9cd4012653741f3b309
+  depends:
+  - libclang13 >=22.1.8
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 111256
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/clang-tools-22.1.8-default_h1fde246_3.conda
+  sha256: 1769797d516ddeb2742512e5ff7f33452975043a79f4a06ca76abfea96606e91
+  md5: 183b71e4517bca3c48b574f20a2f2066
+  depends:
+  - clang-format ==22.1.8 default_he96069b_3
+  - libclang13 >=22.1.8
+  - clang-scan-deps ==22.1.8 default_h1381bd0_3
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - libllvm22 >=22.1.8,<22.2.0a0
+  constrains:
+  - clangdev ==22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 11693913
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/clang_impl_linux-64-22.1.8-default_h6d37801_3.conda
+  sha256: eb1c68356c7366343fed23d897e54678da7d3b25836de8f280ae1cd0aa5aa8b5
+  md5: ec1a79ad1f2610ed3aa75bbd9a195eea
+  depends:
+  - clang-22 ==22.1.8 default_h9692865_3
+  - compiler-rt_linux-64
+  - compiler-rt 22.1.8.*
+  - binutils_impl_linux-64
+  - libgcc-devel_linux-64
+  - sysroot_linux-64
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libzlib >=1.3.2,<2.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 34083
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/cmake-4.3.4-hc85cc9f_0.conda
+  sha256: a3369cbf4c8d77a3398c3c2bb1e7d72af26ac9c655e4753964bdb744bf1e5e8c
+  md5: aa9174a98942599973baf4c5639e13b5
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - bzip2 >=1.0.8,<2.0a0
+  - libcurl >=8.20.0,<9.0a0
+  - libexpat >=2.8.1,<3.0a0
+  - libgcc >=14
+  - liblzma >=5.8.3,<6.0a0
+  - libstdcxx >=14
+  - libuv >=1.52.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ncurses >=6.6,<7.0a0
+  - rhash >=1.4.6,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 23168153
+  timestamp: 1781778936323
+- conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt-22.1.8-ha770c72_1.conda
+  sha256: 7ea97a24a9847f7ec91b959c405a9bc5b9c28d4078175dce2d2f8a2014f74969
+  md5: 21124de0100de807100d1a55c9dd118b
+  depends:
+  - compiler-rt22 22.1.8 hb700be7_1
+  - libcompiler-rt 22.1.8 hb700be7_1
+  constrains:
+  - clang 22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 16599
+  timestamp: 1781741197892
+- conda: https://conda.anaconda.org/conda-forge/linux-64/compiler-rt22-22.1.8-hb700be7_1.conda
+  sha256: 34c62d3aa085945afa94930621793bccc18c47ce9657a5ef9423f76cf8e9373e
+  md5: cf8e2c7703b389548c15082694701a17
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - compiler-rt22_linux-64 22.1.8.*
+  - libgcc >=14
+  - libstdcxx >=14
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 115679
+  timestamp: 1781741196856
+- conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-14.3.0-he8ccf15_19.conda
+  sha256: 769357d82d19f59c23888d935d92b67739bdb2acaacaa7bbe7c4fe4ee5346287
+  md5: fd57230e9a97b97bf20dd63aeae6fe61
+  depends:
+  - gcc_impl_linux-64 >=14.3.0,<14.3.1.0a0
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 31751
+  timestamp: 1778268677594
+- conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.3-py314h97ea11e_4.conda
+  sha256: b0314a7f1fb4a294b1a8bcf5481d4a8d9412a9fee23b7e3f93fb10e4d504f2cc
+  md5: 95bede9cdb7a30a4b611223d52a01aa4
+  depends:
+  - numpy >=1.25
+  - python
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/contourpy?source=hash-mapping
+  run_exports: {}
+  size: 324013
+  timestamp: 1769155968691
+- conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.14.3-py310h3406613_0.conda
+  sha256: d5ff485f9134e91657bf894fe6535fbdf54e41b11238c6b37701f5a605bfb66a
+  md5: a53275194d9c40d82ac81e89dccae517
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - python >=3.10,<3.11.0a0
+  - python_abi 3.10.* *_cp310
+  - tomli
+  license: Apache-2.0
+  license_family: APACHE
+  run_exports: {}
+  size: 318490
+  timestamp: 1782178112039
+- conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.14.3-py314h67df5f8_0.conda
+  sha256: 68f6814d548e6b1d8b655371cb34b909f5862d5d80b4b6ccf7231a84ceeb88da
+  md5: e3aecdc8eab8a93c5aad5f113fa91509
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - tomli
+  license: Apache-2.0
+  license_family: APACHE
+  purls:
+  - pkg:pypi/coverage?source=hash-mapping
+  run_exports: {}
+  size: 419228
+  timestamp: 1782178151393
+- conda: https://conda.anaconda.org/conda-forge/linux-64/cxx-compiler-1.11.0-hfcd1e18_0.conda
+  sha256: 3fcc97ae3e89c150401a50a4de58794ffc67b1ed0e1851468fcc376980201e25
+  md5: 5da8c935dca9186673987f79cef0b2a5
+  depends:
+  - c-compiler 1.11.0 h4d9bdce_0
+  - gxx
+  - gxx_linux-64 14.*
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 6635
+  timestamp: 1753098722177
+- conda: https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.28-hac629b4_1.conda
+  sha256: 7684da83306bb69686c0506fb09aa7074e1a55ade50c3a879e4e5df6eebb1009
+  md5: af491aae930edc096b58466c51c4126c
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=13
+  - libntlm >=1.8,<2.0a0
+  - libstdcxx >=13
+  - libxcrypt >=4.4.36
+  - openssl >=3.5.5,<4.0a0
+  license: BSD-3-Clause-Attribution
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - cyrus-sasl >=2.1.28,<3.0a0
+  size: 210103
+  timestamp: 1771943128249
+- conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda
+  sha256: 8bb557af1b2b7983cf56292336a1a1853f26555d9c6cecf1e5b2b96838c9da87
+  md5: ce96f2f470d39bd96ce03945af92e280
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.1,<2.0a0
+  - libglib >=2.86.2,<3.0a0
+  - libexpat >=2.7.3,<3.0a0
+  license: AFL-2.1 OR GPL-2.0-or-later
+  purls: []
+  run_exports:
+    weak:
+    - dbus >=1.16.2,<2.0a0
+  size: 447649
+  timestamp: 1764536047944
+- conda: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.4.0-hecca717_0.conda
+  sha256: 40cdd1b048444d3235069d75f9c8e1f286db567f6278a93b4f024e5642cfaecc
+  md5: dbe3ec0f120af456b3477743ffd99b74
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - double-conversion >=3.4.0,<3.5.0a0
+  size: 71809
+  timestamp: 1765193127016
+- conda: https://conda.anaconda.org/conda-forge/linux-64/epoxy-1.5.10-hb03c661_2.conda
+  sha256: a5b51e491fec22bcc1765f5b2c8fff8a97428e9a5a7ee6730095fb9d091b0747
+  md5: 057083b06ccf1c2778344b6dabace38b
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libdrm >=2.4.125,<2.5.0a0
+  - libegl >=1.7.0,<2.0a0
+  - libegl-devel
+  - libgcc >=14
+  - libgl >=1.7.0,<2.0a0
+  - libgl-devel
+  - libglx >=1.7.0,<2.0a0
+  - libglx-devel
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxdamage >=1.1.6,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxfixes >=6.0.1,<7.0a0
+  - xorg-libxxf86vm >=1.1.6,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - epoxy >=1.5.10,<1.6.0a0
+  size: 411735
+  timestamp: 1758743520805
+- conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.18.1-h27c8c51_0.conda
+  sha256: 2e50bdcebdf70a865b81f2456bbc586386451ec601c60f2b6cd22b8c40a2d384
+  md5: e0e050cfa9fa85fe39632ab11cb7f3e0
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libexpat >=2.8.1,<3.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libgcc >=14
+  - libuuid >=2.42.1,<3.0a0
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - fontconfig >=2.18.1,<3.0a0
+    - fonts-conda-ecosystem
+  size: 281880
+  timestamp: 1780450077431
+- conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_0.conda
+  sha256: c934c385889c7836f034039b43b05ccfa98f53c900db03d8411189892ced090b
+  md5: 8462b5322567212beeb025f3519fb3e2
+  depends:
+  - libfreetype 2.14.3 ha770c72_0
+  - libfreetype6 2.14.3 h73754d4_0
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports:
+    weak:
+    - libfreetype >=2.14.3
+    - libfreetype6 >=2.14.3
+  size: 173839
+  timestamp: 1774298173462
+- conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.16-hb03c661_0.conda
+  sha256: 858283ff33d4c033f4971bf440cebff217d5552a5222ba994c49be990dacd40d
+  md5: f9f81ea472684d75b9dd8d0b328cf655
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - fribidi >=1.0.16,<2.0a0
+  size: 61244
+  timestamp: 1757438574066
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-14.3.0-h0dff253_19.conda
+  sha256: e3f541c4be7296b800a972482b7a5e399614d5e3310d3d083257fbdb4df81ea0
+  md5: 2dd149aa693db92758af3e685ef30439
+  depends:
+  - conda-gcc-specs
+  - gcc_impl_linux-64 14.3.0 h235f0fe_19
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 29459
+  timestamp: 1778268802660
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-14.3.0-h235f0fe_19.conda
+  sha256: 1e2500ca976d4831c953d1c6db7b238d2e6806910b930e3eb631b79ba5c3ba41
+  md5: 99936dc616b7ce97b0468759b8a7c64e
+  depends:
+  - binutils_impl_linux-64 >=2.45
+  - libgcc >=14.3.0
+  - libgcc-devel_linux-64 14.3.0 hf649bbc_119
+  - libgomp >=14.3.0
+  - libsanitizer 14.3.0 h8f1669f_19
+  - libstdcxx >=14.3.0
+  - libstdcxx-devel_linux-64 14.3.0 h9f08a49_119
+  - sysroot_linux-64
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 77667192
+  timestamp: 1778268558509
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-14.3.0-h50e9bb6_27.conda
+  sha256: d7f427d6db94a5eed2a43b186f8dc17cc1fbeb03517442390a36f1cde02548b0
+  md5: 90369fa27fae2f7bf7eaaccc34c793e2
+  depends:
+  - gcc_impl_linux-64 14.3.0.*
+  - binutils_linux-64
+  - sysroot_linux-64
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    strong:
+    - libgcc >=14
+  size: 29324
+  timestamp: 1781279939286
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.44.7-h2b0a6b4_0.conda
+  sha256: 1c22e37f9d7e06e9e0582ee5a55c2ddd19ea75f71f44eb13b56f504ef5c37aa5
+  md5: 5d355db3e937086e22cf4cb5fe19787c
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libglib >=2.88.2,<3.0a0
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  license: LGPL-2.1-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gdk-pixbuf >=2.44.7,<3.0a0
+  size: 581631
+  timestamp: 1782591374199
+- conda: https://conda.anaconda.org/conda-forge/linux-64/glib-tools-2.88.2-h8094192_0.conda
+  sha256: 079757e4e0497d67505b52062668e4cc0d2a86ec065ae2c0c57487a178206061
+  md5: cfe66c21ae651b84a3d25a1dbb641a54
+  depends:
+  - libglib ==2.88.2 h0d30a3d_0
+  - libffi
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports: {}
+  size: 238517
+  timestamp: 1782463895250
+- conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.15-hecca717_0.conda
+  sha256: 885fa7d1d7e2ad9ed0a700ee0d81ceb49de278253082d517959b22d6336eecce
+  md5: cf09e9fc938518e91d0706572cadf17a
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - graphite2 >=1.3.15,<2.0a0
+  size: 100054
+  timestamp: 1780454302233
+- conda: https://conda.anaconda.org/conda-forge/linux-64/graphviz-14.1.2-h8b86629_0.conda
+  sha256: 48d4aae8d2f7dd038b8c2b6a1b68b7bca13fa6b374b78c09fcc0757fa21234a1
+  md5: 341fc61cfe8efa5c72d24db56c776f44
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - adwaita-icon-theme
+  - cairo >=1.18.4,<2.0a0
+  - fonts-conda-ecosystem
+  - gdk-pixbuf >=2.44.4,<3.0a0
+  - gtk3 >=3.24.43,<4.0a0
+  - gts >=0.7.6,<0.8.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libgcc >=14
+  - libgd >=2.3.3,<2.4.0a0
+  - libglib >=2.86.3,<3.0a0
+  - librsvg >=2.60.0,<3.0a0
+  - libstdcxx >=14
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - pango >=1.56.4,<2.0a0
+  license: EPL-1.0
+  license_family: Other
+  purls: []
+  run_exports:
+    weak:
+    - graphviz >=14.1.2,<15.0a0
+  size: 2426455
+  timestamp: 1769427102743
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gtk3-3.24.52-ha5ea40c_0.conda
+  sha256: c6bb4f06331bcb0a566d84e0f0fad7af4b9035a03b13e2d5ecfaf13be57e6e10
+  md5: bcaea22d85999a4f17918acfab877e61
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - at-spi2-atk >=2.38.0,<3.0a0
+  - atk-1.0 >=2.38.0
+  - cairo >=1.18.4,<2.0a0
+  - epoxy >=1.5.10,<1.6.0a0
+  - fontconfig >=2.17.1,<3.0a0
+  - fonts-conda-ecosystem
+  - fribidi >=1.0.16,<2.0a0
+  - gdk-pixbuf >=2.44.5,<3.0a0
+  - glib-tools
+  - harfbuzz >=13.2.1
+  - hicolor-icon-theme
+  - libcups >=2.3.3,<2.4.0a0
+  - libcups >=2.3.3,<3.0a0
+  - libexpat >=2.7.4,<3.0a0
+  - libfreetype >=2.14.2
+  - libfreetype6 >=2.14.2
+  - libgcc >=14
+  - libglib >=2.86.4,<3.0a0
+  - liblzma >=5.8.2,<6.0a0
+  - libxkbcommon >=1.13.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - pango >=1.56.4,<2.0a0
+  - wayland >=1.25.0,<2.0a0
+  - xorg-libx11 >=1.8.13,<2.0a0
+  - xorg-libxcomposite >=0.4.7,<1.0a0
+  - xorg-libxcursor >=1.2.3,<2.0a0
+  - xorg-libxdamage >=1.1.6,<2.0a0
+  - xorg-libxext >=1.3.7,<2.0a0
+  - xorg-libxfixes >=6.0.2,<7.0a0
+  - xorg-libxi >=1.8.2,<2.0a0
+  - xorg-libxinerama >=1.1.6,<1.2.0a0
+  - xorg-libxrandr >=1.5.5,<2.0a0
+  - xorg-libxrender >=0.9.12,<0.10.0a0
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gtk3 >=3.24.52,<4.0a0
+    - adwaita-icon-theme
+  size: 5939083
+  timestamp: 1774288645605
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gts-0.7.6-h977cf35_4.conda
+  sha256: b5cd16262fefb836f69dc26d879b6508d29f8a5c5948a966c47fe99e2e19c99b
+  md5: 4d8df0b0db060d33c9a702ada998a8fe
+  depends:
+  - libgcc-ng >=12
+  - libglib >=2.76.3,<3.0a0
+  - libstdcxx-ng >=12
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gts >=0.7.6,<0.8.0a0
+  size: 318312
+  timestamp: 1686545244763
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-14.3.0-he448592_7.conda
+  sha256: 7acf0ee3039453aa69f16da063136335a3511f9c157e222def8d03c8a56a1e03
+  md5: 91dc0abe7274ac5019deaa6100643265
+  depends:
+  - gcc 14.3.0.*
+  - gxx_impl_linux-64 14.3.0.*
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 30403
+  timestamp: 1759966121169
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-14.3.0-h2185e75_19.conda
+  sha256: a31694c26d6a525d44f81130ebf7b9abe18771b7eaecb2cf93630c0b8b8fb936
+  md5: 8b867d053ed89743eeac52c3a50f112d
+  depends:
+  - gcc_impl_linux-64 14.3.0 h235f0fe_19
+  - libstdcxx-devel_linux-64 14.3.0 h9f08a49_119
+  - sysroot_linux-64
+  - tzdata
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 15235650
+  timestamp: 1778268773535
+- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-14.3.0-hd240bd5_27.conda
+  sha256: cf5a44d14732b79e3c2bc6ebe1dba4f6b9077939f3093c75e36ad340737b5c15
+  md5: 41fae38a424bbc78438cfec6a4fde187
+  depends:
+  - gxx_impl_linux-64 14.3.0.*
+  - gcc_linux-64 ==14.3.0 h50e9bb6_27
+  - binutils_linux-64
+  - sysroot_linux-64
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    strong:
+    - libstdcxx >=14
+    - libgcc >=14
+  size: 27854
+  timestamp: 1781279939286
+- conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-14.2.1-ha770c72_1.conda
+  sha256: 853beec89ff91cbbf630f1d305b69153eb28a3cb78af95ddc1fb4d30e524c6f4
+  md5: 72e956a71241633d8c80aa198fd08784
+  depends:
+  - libharfbuzz-devel 14.2.1 h17a8019_1
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libharfbuzz >=14.2.1
+  size: 11039
+  timestamp: 1782800611635
+- conda: https://conda.anaconda.org/conda-forge/linux-64/hicolor-icon-theme-0.17-ha770c72_3.conda
+  sha256: 6d7e6e1286cb521059fe69696705100a03b006efb914ffe82a2ae97ecbae66b7
+  md5: 129e404c5b001f3ef5581316971e3ea0
+  license: GPL-2.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 17625
+  timestamp: 1771539597968
+- conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda
+  sha256: fbf86c4a59c2ed05bbffb2ba25c7ed94f6185ec30ecb691615d42342baa1a16a
+  md5: c80d8a3b84358cb967fa81e7075fbc8a
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - icu >=78.3,<79.0a0
+  size: 12723451
+  timestamp: 1773822285671
+- conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda
+  sha256: 0960d06048a7185d3542d850986d807c6e37ca2e644342dd0c72feefcf26c2a4
+  md5: b38117a3c920364aff79f870c984b4a3
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - keyutils >=1.6.3,<2.0a0
+  size: 134088
+  timestamp: 1754905959823
+- conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.5.0-py314h97ea11e_0.conda
+  sha256: e3488ea4a336f29e57de8f282bf40c0505cfc482e03004615e694b48e7d9c79f
+  md5: 7397e418cab519b8d789936cf2dde6f6
+  depends:
+  - python
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/kiwisolver?source=hash-mapping
+  run_exports: {}
+  size: 77363
+  timestamp: 1773067048780
+- conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbde042b_1.conda
+  sha256: 9b07046870772f28740e3f6149f09ff222843733087a33c5540b169c6289652d
+  md5: 54157a1c8c0bb70f62dd0b17fba7e7f2
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - keyutils >=1.6.3,<2.0a0
+  - libedit >=3.1.20250104,<3.2.0a0
+  - libedit >=3.1.20250104,<4.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - openssl >=3.5.7,<4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - krb5 >=1.22.2,<1.23.0a0
+  size: 1388990
+  timestamp: 1781859420533
+- conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda
+  sha256: 112b5b9462572d970f4abd2912f76a25ee7db158b1e7260163d91dd8a630db84
+  md5: 8b3ce45e929cd8e8e5f4d18586b56d8b
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - lcms2 >=2.19.1,<3.0a0
+  size: 251971
+  timestamp: 1780211695895
+- conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda
+  sha256: 3d584956604909ff5df353767f3a2a2f60e07d070b328d109f30ac40cd62df6c
+  md5: 18335a698559cdbcd86150a48bf54ba6
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - zstd >=1.5.7,<1.6.0a0
+  constrains:
+  - binutils_impl_linux-64 2.45.1
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 728002
+  timestamp: 1774197446916
+- conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda
+  sha256: f84cb54782f7e9cea95e810ea8fef186e0652d0fa73d3009914fa2c1262594e1
+  md5: a752488c68f2e7c456bcbd8f16eec275
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - lerc >=4.1.0,<5.0a0
+  size: 261513
+  timestamp: 1773113328888
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20250512.1-cxx17_hba17884_0.conda
+  sha256: dcd1429a1782864c452057a6c5bc1860f2b637dc20a2b7e6eacd57395bbceff8
+  md5: 83b160d4da3e1e847bf044997621ed63
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - libstdcxx >=13
+  constrains:
+  - libabseil-static =20250512.1=cxx17*
+  - abseil-cpp =20250512.1
+  license: Apache-2.0
+  license_family: Apache
+  run_exports:
+    weak:
+    - libabseil >=20250512.1,<20250513.0a0
+    - libabseil =*=cxx17*
+  size: 1310612
+  timestamp: 1750194198254
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20260107.1-cxx17_h7b12aa8_0.conda
+  sha256: a7a4481a4d217a3eadea0ec489826a69070fcc3153f00443aa491ed21527d239
+  md5: 6f7b4302263347698fd24565fbf11310
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  constrains:
+  - libabseil-static =20260107.1=cxx17*
+  - abseil-cpp =20260107.1
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libabseil >=20260107.1,<20260108.0a0
+    - libabseil =*=cxx17*
+  size: 1384817
+  timestamp: 1770863194876
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda
+  build_number: 8
+  sha256: b2da6bfd72a1c9cb143ccf64bf5b28790cb4eb58bd1cb978f6537b2322f7d48b
+  md5: 00fc660ab1b2f5ca07e92b4900d10c79
+  depends:
+  - libopenblas >=0.3.33,<0.3.34.0a0
+  - libopenblas >=0.3.33,<1.0a0
+  constrains:
+  - blas 2.308   openblas
+  - mkl <2027
+  - libcblas   3.11.0   8*_openblas
+  - liblapack  3.11.0   8*_openblas
+  - liblapacke 3.11.0   8*_openblas
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libblas >=3.11.0,<4.0a0
+  size: 18804
+  timestamp: 1779859100675
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-hb03c661_1.conda
+  sha256: 318f36bd49ca8ad85e6478bd8506c88d82454cc008c1ac1c6bf00a3c42fa610e
+  md5: 72c8fd1af66bd67bf580645b426513ed
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlicommon >=1.2.0,<1.3.0a0
+  size: 79965
+  timestamp: 1764017188531
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-hb03c661_1.conda
+  sha256: 12fff21d38f98bc446d82baa890e01fd82e3b750378fedc720ff93522ffb752b
+  md5: 366b40a69f0ad6072561c1d09301c886
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libbrotlicommon 1.2.0 hb03c661_1
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlidec >=1.2.0,<1.3.0a0
+  size: 34632
+  timestamp: 1764017199083
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-hb03c661_1.conda
+  sha256: a0c15c79997820bbd3fbc8ecf146f4fe0eca36cc60b62b63ac6cf78857f1dd0d
+  md5: 4ffbb341c8b616aa2494b6afb26a0c5f
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libbrotlicommon 1.2.0 hb03c661_1
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlienc >=1.2.0,<1.3.0a0
+  size: 298378
+  timestamp: 1764017210931
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda
+  build_number: 8
+  sha256: 1a2bc77bb26520255904a3d9b1f40e6bf0bf9d8d3405c7709dd162282820915a
+  md5: 33a413f1095f8325e5c30fde3b0d2445
+  depends:
+  - libblas 3.11.0 8_h4a7cf45_openblas
+  constrains:
+  - blas 2.308   openblas
+  - liblapacke 3.11.0   8*_openblas
+  - liblapack  3.11.0   8*_openblas
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libcblas >=3.11.0,<4.0a0
+  size: 18778
+  timestamp: 1779859107964
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h6c227bf_3.conda
+  sha256: ccb8bd0a8f2d57675b6a60dabb0cc8becb35c2748ac4ec920d7f7625b93c16d8
+  md5: 864e6d29ec7378b89ff5b5c9c629099e
+  depends:
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  size: 24175081
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-22.1.8-default_h9692865_3.conda
+  sha256: b90ed8467a692788477c06bc0359fac52ed5651d801ddef189ba4b7ecf3ce38c
+  md5: 2a913525f4201f1adab2711fcf6f89b3
+  depends:
+  - libclang-cpp22.1 ==22.1.8 default_h6c227bf_3
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libclang13 >=22.1.8
+  size: 14283567
+  timestamp: 1782358841320
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libcompiler-rt-22.1.8-hb700be7_1.conda
+  sha256: da7b61922007ff1cfe015ec5156084f2b12f68f554ea8d737689c1dc898f24c0
+  md5: 03a0d91cd5997faff23727b4390f9bc6
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  constrains:
+  - compiler-rt >=9.0.1
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libcompiler-rt >=22.1.8
+  size: 10100897
+  timestamp: 1781741177454
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h7a8fb5f_6.conda
+  sha256: 205c4f19550f3647832ec44e35e6d93c8c206782bdd620c1d7cf66237580ff9c
+  md5: 49c553b47ff679a6a1e9fc80b9c5a2d4
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.1,<2.0a0
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libcups >=2.3.3,<2.4.0a0
+  size: 4518030
+  timestamp: 1770902209173
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hae6b9f4_2.conda
+  sha256: ba8354084b34fce56d5697982fce4a384c148e972e15c0ab891187617fe7ec29
+  md5: f9c59d277a16ec8f272b2d5dd2ec3335
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=14
+  - libnghttp2 >=1.68.1,<2.0a0
+  - libpsl >=0.22.0,<0.23.0a0
+  - libssh2 >=1.11.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - openssl >=3.5.7,<4.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: curl
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libcurl >=8.21.0,<9.0a0
+  size: 480327
+  timestamp: 1782911787190
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libdate-3.0.4-h5888daf_0.conda
+  sha256: 7d1c9c06b65bd18cc073894bb7134cd5cca4367d46cd6cd51b16cc46249066fc
+  md5: d323dfd0b69f0e6ae913819ca93b1fc2
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - libstdcxx >=13
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 43447
+  timestamp: 1748468957926
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda
+  sha256: aa8e8c4be9a2e81610ddf574e05b64ee131fab5e0e3693210c9d6d2fba32c680
+  md5: 6c77a605a7a689d17d4819c0f8ac9a00
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libdeflate >=1.25,<1.26.0a0
+  size: 73490
+  timestamp: 1761979956660
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.127-hb03c661_0.conda
+  sha256: 7d3187c11b7ae66c5595a8afd5a7ce352a490527fdf6614cab129bc7f2c16ba3
+  md5: d8d16b9b32a3c5df7e5b3350e2cbe058
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libpciaccess >=0.19,<0.20.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libdrm >=2.4.127,<2.5.0a0
+  size: 311505
+  timestamp: 1778975798004
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda
+  sha256: d789471216e7aba3c184cd054ed61ce3f6dac6f87a50ec69291b9297f8c18724
+  md5: c277e0a4d549b03ac1e9d6cbbe3d017b
+  depends:
+  - ncurses
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - ncurses >=6.5,<7.0a0
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libedit >=3.1.20250104,<3.2.0a0
+  size: 134676
+  timestamp: 1738479519902
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_3.conda
+  sha256: 9a25ea93e8272785405a21d30f84e620befb1d545f6dfaae18f06103b5df0443
+  md5: 75e9f795be506c96dd43cb09c7c8d557
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libglvnd 1.7.0 ha4b6fd6_3
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 46500
+  timestamp: 1779728188901
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-devel-1.7.0-ha4b6fd6_3.conda
+  sha256: e4b46919c9bb65930bce238bd2736110ed7b8c30e5cd5394e4e1edb48de54843
+  md5: 5bc6d55503483aabe8a90c5e7f49a2a4
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libegl 1.7.0 ha4b6fd6_3
+  - libgl-devel 1.7.0 ha4b6fd6_3
+  - xorg-libx11
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports:
+    weak:
+    - libegl >=1.7.0,<2.0a0
+  size: 31718
+  timestamp: 1779728222280
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda
+  sha256: 1cd6048169fa0395af74ed5d8f1716e22c19a81a8a36f934c110ca3ad4dd27b4
+  md5: 172bf1cd1ff8629f2b1179945ed45055
+  depends:
+  - libgcc-ng >=12
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libev >=4.33,<4.34.0a0
+  size: 112766
+  timestamp: 1702146165126
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda
+  sha256: 16feffd9ddbbe5b718515d38ee376c685ba95491cd901244e24671d20b952a77
+  md5: b24d3c612f71e7aa74158d92106318b2
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  constrains:
+  - expat 2.8.1.*
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 77856
+  timestamp: 1781203599810
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda
+  sha256: 31f19b6a88ce40ebc0d5a992c131f57d919f73c0b92cd1617a5bec83f6e961e6
+  md5: a360c33a5abe61c07959e449fa1453eb
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libffi >=3.5.2,<3.6.0a0
+  size: 58592
+  timestamp: 1769456073053
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda
+  sha256: 38f014a7129e644636e46064ecd6b1945e729c2140e21d75bb476af39e692db2
+  md5: e289f3d17880e44b633ba911d57a321b
+  depends:
+  - libfreetype6 >=2.14.3
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports: {}
+  size: 8049
+  timestamp: 1774298163029
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda
+  sha256: 16f020f96da79db1863fcdd8f2b8f4f7d52f177dd4c58601e38e9182e91adf1d
+  md5: fb16b4b69e3f1dcfe79d80db8fd0c55d
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libpng >=1.6.55,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - freetype >=2.14.3
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports: {}
+  size: 384575
+  timestamp: 1774298162622
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda
+  sha256: 8e0a3b5e41272e5678499b5dfc4cddb673f9e935de01eb0767ce857001229f46
+  md5: 57736f29cc2b0ec0b6c2952d3f101b6a
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - _openmp_mutex >=4.5
+  constrains:
+  - libgcc-ng ==15.2.0=*_19
+  - libgomp 15.2.0 he0feb66_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 1041084
+  timestamp: 1778269013026
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda
+  sha256: 9dcf54adfaa5e861123c2da4f2f0451a685464ea7e5a41ad91cf67b31d658d98
+  md5: 331ee9b72b9dff570d56b1302c5ab37d
+  depends:
+  - libgcc 15.2.0 he0feb66_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports:
+    strong:
+    - libgcc
+  size: 27694
+  timestamp: 1778269016987
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libgd-2.3.3-h5fbf134_12.conda
+  sha256: 245be793e831170504f36213134f4c24eedaf39e634679809fd5391ad214480b
+  md5: 88c1c66987cd52a712eea89c27104be6
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - fontconfig >=2.15.0,<3.0a0
+  - fonts-conda-ecosystem
+  - icu >=78.1,<79.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libgcc >=14
+  - libjpeg-turbo >=3.1.2,<4.0a0
+  - libpng >=1.6.53,<1.7.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  license: GD
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libgd >=2.3.3,<2.4.0a0
+  size: 177306
+  timestamp: 1766331805898
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda
+  sha256: 561a42758ef25b9ce308c4e2cf56daee4f06138385a17e29a492cd928e00be6f
+  md5: 42bf7eca1a951735fa06c0e3c0d5c8e6
+  depends:
+  - libgfortran5 15.2.0 h68bc16d_19
+  constrains:
+  - libgfortran-ng ==15.2.0=*_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 27655
+  timestamp: 1778269042954
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda
+  sha256: 057978bb69fea29ed715a9b98adf71015c31baecc4aeb2bfc20d4fd5d83579d4
+  md5: 85072b0ad177c966294f129b7c04a2d5
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=15.2.0
+  constrains:
+  - libgfortran 15.2.0
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 2483673
+  timestamp: 1778269025089
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_3.conda
+  sha256: ec353b3076ed8e357ed961d0e9ff6997491cade0e603de5bd18a2e301ac78ebd
+  md5: f25206d7322c0e9648e8b83694d143ab
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libglvnd 1.7.0 ha4b6fd6_3
+  - libglx 1.7.0 ha4b6fd6_3
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 133469
+  timestamp: 1779728207669
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-devel-1.7.0-ha4b6fd6_3.conda
+  sha256: 41d7d864ad1f199bdb06ff6cc3931455c8af62f1d2071a08c6fa08affbcb678f
+  md5: 63e43d278ee5084813fe3c2edf4834ce
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgl 1.7.0 ha4b6fd6_3
+  - libglx-devel 1.7.0 ha4b6fd6_3
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports:
+    weak:
+    - libgl >=1.7.0,<2.0a0
+  size: 115664
+  timestamp: 1779728218325
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.88.2-h0d30a3d_0.conda
+  sha256: 4bee10e62796f01e4fa2b5849135b1cc061337fe9cf5eb9bd79e9664922ae0e4
+  md5: 889febc66cd9e4190f80ef9718fa239b
+  depends:
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libiconv >=1.18,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - libffi >=3.5.2,<3.6.0a0
+  - pcre2 >=10.47,<10.48.0a0
+  constrains:
+  - glib >2.66
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libglib >=2.88.2,<3.0a0
+  size: 4754220
+  timestamp: 1782463895250
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_3.conda
+  sha256: e019ebe4e3f5cdf23e2f5e58ddf7ade27988c53820115b17b98f218ebcc87748
+  md5: eb83f3f8cecc3e9bff9e250817fc69b6
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 133586
+  timestamp: 1779728183422
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_3.conda
+  sha256: 2f74713c9ca408ea84e88a30a9028153e7b553e8bb42e06139eac9a753c27da9
+  md5: ec3c4350aa0261bf7f87b8ca15c8e80e
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libglvnd 1.7.0 ha4b6fd6_3
+  - xorg-libx11 >=1.8.13,<2.0a0
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 76586
+  timestamp: 1779728199059
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-devel-1.7.0-ha4b6fd6_3.conda
+  sha256: a17ae2d4cb2de04a20882ae14ec3cc1958e868a4dec81e3d7eca30115ee50e94
+  md5: 16b6330783ce0d1ae8d22782173b32c9
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libglx 1.7.0 ha4b6fd6_3
+  - xorg-libx11 >=1.8.13,<2.0a0
+  - xorg-xorgproto
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports:
+    weak:
+    - libglx >=1.7.0,<2.0a0
+  size: 27363
+  timestamp: 1779728211402
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda
+  sha256: 5abe4ab9d93f6c9757d654f1969ae2267d4505315c1f2f8fe705fd60af084f1b
+  md5: faac990cb7aedc7f3a2224f2c9b0c26c
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports:
+    strong:
+    - _openmp_mutex >=4.5
+  size: 603817
+  timestamp: 1778268942614
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-14.2.1-h17a8019_1.conda
+  sha256: 821c315f6b5171aa89e735be2ad84e74eb3f898fc7610ee36cfecd95dfa789e8
+  md5: fb4669c3990b94ea32fbb81f433e9aa6
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - cairo >=1.18.4,<2.0a0
+  - graphite2 >=1.3.15,<2.0a0
+  - icu >=78.3,<79.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libgcc >=14
+  - libglib >=2.88.2,<3.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - libstdcxx >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 1297668
+  timestamp: 1782800580119
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-devel-14.2.1-h17a8019_1.conda
+  sha256: 6d8e793042affd18ca1784b7794fab14d16f54f984777ce6ab86bacaa465ab0d
+  md5: 99cf21100441e51272f1cd6fe0632a20
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - cairo >=1.18.4,<2.0a0
+  - freetype
+  - graphite2 >=1.3.15,<2.0a0
+  - icu >=78.3,<79.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libgcc >=14
+  - libglib >=2.88.2,<3.0a0
+  - libharfbuzz 14.2.1 h17a8019_1
+  - libpng >=1.6.58,<1.7.0a0
+  - libstdcxx >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libharfbuzz >=14.2.1
+  size: 1970690
+  timestamp: 1782800603897
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda
+  sha256: c467851a7312765447155e071752d7bf9bf44d610a5687e32706f480aad2833f
+  md5: 915f5995e94f60e9a4826e0b0920ee88
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: LGPL-2.1-only
+  purls: []
+  run_exports:
+    weak:
+    - libiconv >=1.18,<2.0a0
+  size: 790176
+  timestamp: 1754908768807
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda
+  sha256: 10056646c28115b174de81a44e23e3a0a3b95b5347d2e6c45cc6d49d35294256
+  md5: 6178c6f2fb254558238ef4e6c56fb782
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  constrains:
+  - jpeg <0.0.0a
+  license: IJG AND BSD-3-Clause AND Zlib
+  purls: []
+  run_exports:
+    weak:
+    - libjpeg-turbo >=3.1.4.1,<4.0a0
+  size: 633831
+  timestamp: 1775962768273
+- conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda
+  build_number: 8
+  sha256: 168e327d737059553e15cc6ec36d76b9bbb3931c2a7721555fd68b4c9348b247
+  md5: 809be8ba8712c77bc7d44c2d99390dc4
+  depends:
+  - libblas 3.11.0 8_h4a7cf45_openblas
+  constrains:
+  - blas 2.308   openblas
+  - libcblas   3.11.0   8*_openblas
+  - liblapacke 3.11.0   8*_openblas
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - liblapack >=3.11.0,<3.12.0a0
+  size: 18790
+  timestamp: 1779859115086
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda
+  sha256: e9b5f301d6b001a9b8ce782157f56b75c92c4fbc9eba95dc6345c1139251d13b
+  md5: 298bb2483fc7d15396147cf1c1465359
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - libzlib >=1.3.2,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libllvm22 >=22.1.8,<22.2.0a0
+  size: 44320272
+  timestamp: 1781788728739
+- conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda
+  sha256: ec30e52a3c1bf7d0425380a189d209a52baa03f22fb66dd3eb587acaa765bd6d
+  md5: b88d90cad08e6bc8ad540cb310a761fb
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  constrains:
+  - xz 5.8.3.*
+  license: 0BSD
+  purls: []
+  run_exports:
+    weak:
+    - liblzma >=5.8.3,<6.0a0
+  size: 113478
+  timestamp: 1775825492909
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libmagic-5.48-h421ea60_1.conda
+  sha256: c27c09fe89e88000259ad3a83c18cb52804d06a8e25ee51b9bedbcf3584b64ba
+  md5: 797a795edaf1256b329beee28db47d5d
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: BSD-2-Clause-Darwin
+  run_exports:
+    weak:
+    - libmagic >=5.48,<6.0a0
+  size: 473875
+  timestamp: 1781763252336
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda
+  sha256: fe171ed5cf5959993d43ff72de7596e8ac2853e9021dec0344e583734f1e0843
+  md5: 2c21e66f50753a083cbe6b80f38268fa
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 92400
+  timestamp: 1769482286018
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda
+  sha256: 663444d77a42f2265f54fb8b48c5450bfff4388d9c0f8253dd7855f0d993153f
+  md5: 2a45e7f8af083626f009645a6481f12d
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - c-ares >=1.34.6,<2.0a0
+  - libev >=4.33,<4.34.0a0
+  - libev >=4.33,<5.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.1,<2.0a0
+  - openssl >=3.5.5,<4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libnghttp2 >=1.68.1,<2.0a0
+  size: 663344
+  timestamp: 1773854035739
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libnsl-2.0.1-hb9d3cd8_1.conda
+  sha256: 927fe72b054277cde6cb82597d0fcf6baf127dcbce2e0a9d8925a68f1265eef5
+  md5: d864d34357c3b65a4b731f78c0801dc4
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  license: LGPL-2.1-only
+  license_family: GPL
+  run_exports:
+    weak:
+    - libnsl >=2.0.1,<2.1.0a0
+  size: 33731
+  timestamp: 1750274110928
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libntlm-1.8-hb9d3cd8_0.conda
+  sha256: 3b3f19ced060013c2dd99d9d46403be6d319d4601814c772a3472fe2955612b0
+  md5: 7c7927b404672409d9917d49bff5f2d6
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libntlm >=1.8,<2.0a0
+  size: 33418
+  timestamp: 1734670021371
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.33-pthreads_h94d23a6_0.conda
+  sha256: 3d9aa85648e5e18a6d66db98b8c4317cc426721ad7a220aa86330d1ccedc8903
+  md5: 2d3278b721e40468295ca755c3b84070
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libgfortran
+  - libgfortran5 >=14.3.0
+  constrains:
+  - openblas >=0.3.33,<0.3.34.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libopenblas >=0.3.33,<1.0a0
+  size: 5931919
+  timestamp: 1776993658641
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_3.conda
+  sha256: 90777039b48529283df5f16383fc399866024257a8bd93de583f4730db1ab30a
+  md5: c2bd8055a2e2dce7a7f32cfd02101fb6
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libglvnd 1.7.0 ha4b6fd6_3
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 51767
+  timestamp: 1779728204026
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.19-hb03c661_0.conda
+  sha256: f41721636a7c2e51bc2c642e1127955ab9c81145470714fdaac44d4d09e4af41
+  md5: 33082e13b4769b48cfeb648e15bfe3fc
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libpciaccess >=0.19,<0.20.0a0
+  size: 29147
+  timestamp: 1773533027610
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda
+  sha256: 377cfe037f3eeb3b1bf3ad333f724a64d32f315ee1958581fc671891d63d3f89
+  md5: eba48a68a1a2b9d3c0d9511548db85db
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: zlib-acknowledgement
+  purls: []
+  run_exports:
+    weak:
+    - libpng >=1.6.58,<1.7.0a0
+  size: 317729
+  timestamp: 1776315175087
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-18.4-hd5a49e9_1.conda
+  sha256: f7232cb79a31f5a5bcd499aea930b469cde8b96d26db9541022493fd274d2a6e
+  md5: 6c9103e7ea739a3bb3505da49a4708c1
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - icu >=78.3,<79.0a0
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=14
+  - openldap >=2.6.13,<2.7.0a0
+  - openssl >=3.5.7,<4.0a0
+  license: PostgreSQL
+  purls: []
+  run_exports:
+    weak:
+    - libpq >=18.4,<19.0a0
+  size: 2709008
+  timestamp: 1782580447454
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.31.1-hfb7daa7_5.conda
+  sha256: b04322e2128684d4043e256f56b74528b0a0a296ba4a81299056ec04655a0580
+  md5: da31d891434e50d7e7be8adc5832269b
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libabseil * cxx17*
+  - libabseil >=20250512.1,<20250513.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports:
+    weak:
+    - libprotobuf >=6.31.1,<6.31.2.0a0
+  size: 4204474
+  timestamp: 1780003940664
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.33.5-h6eeba95_1.conda
+  sha256: a59aa3f076d5710c618ca8fd12d9cd8211d8b738f6b0e0c98517c0162f23a5de
+  md5: 7a4b11f3dd7374f1991a4088390d07c1
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libabseil * cxx17*
+  - libabseil >=20260107.1,<20260108.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libprotobuf >=6.33.5,<6.33.6.0a0
+  size: 3675765
+  timestamp: 1780003831209
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.22.0-hd9031aa_0.conda
+  sha256: cd11890a2c1f14d0342bfcbd81f97152d61dc71c27c7085efc13705a8f64f7c9
+  md5: e2834a423b3967e7b3b1e901c4a5f42f
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - icu >=78.3,<79.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libpsl >=0.22.0,<0.23.0a0
+  size: 83067
+  timestamp: 1782394772411
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libraqm-0.10.5-h6406941_1.conda
+  sha256: 7c9e562842f193f772ef0ba681f238a2d9e5ef637588b6e46eb30cc6aa1940c8
+  md5: fa63517815747363c41b439ff9301db1
+  depends:
+  - __glibc >=2.28,<3.0.a0
+  - libgcc >=14
+  - libharfbuzz >=14.2.1
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - fribidi >=1.0.16,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libraqm >=0.10.5,<0.11.0a0
+  size: 29441
+  timestamp: 1782807076031
+- conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.62.3-h4c96295_0.conda
+  sha256: 5571bd8239d71961d4e3ce972f865b3ea95a91ce0b53d5749fe2dd24254ddbda
+  md5: 492c8d9b1c564c2e948b6cb4ba0f8261
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - cairo >=1.18.4,<2.0a0
+  - fontconfig >=2.18.0,<3.0a0
+  - fonts-conda-ecosystem
+  - gdk-pixbuf >=2.44.6,<3.0a0
+  - harfbuzz >=14.2.0
+  - libgcc >=14
+  - libglib >=2.88.1,<3.0a0
+  - libxml2-16 >=2.14.6
+  - pango >=1.56.4,<2.0a0
+  constrains:
+  - __glibc >=2.17
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - librsvg >=2.62.3,<3.0a0
+  size: 3476570
+  timestamp: 1780450632624
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-14.3.0-h8f1669f_19.conda
+  sha256: 8766de5423b0a510e2b1bdd1963d0554bdad2119f3e31d8fbd4189af434235ca
+  md5: 007796e5a595bbc7df4a5e1580d72e1a
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14.3.0
+  - libstdcxx >=14.3.0
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports:
+    weak:
+    - libsanitizer 14.3.0
+  size: 7947790
+  timestamp: 1778268494844
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda
+  sha256: 365376f4815e5e80def2b3462a2419708b7c292da0da85278386c2618621fff4
+  md5: 4aed8e657e9ff156bdbe849b4df44389
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: blessing
+  purls: []
+  run_exports:
+    weak:
+    - libsqlite >=3.53.3,<4.0a0
+  size: 962119
+  timestamp: 1782519076616
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda
+  sha256: fa39bfd69228a13e553bd24601332b7cfeb30ca11a3ca50bb028108fe90a7661
+  md5: eecce068c7e4eddeb169591baac20ac4
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - libzlib >=1.3.1,<2.0a0
+  - openssl >=3.5.0,<4.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libssh2 >=1.11.1,<2.0a0
+  size: 304790
+  timestamp: 1745608545575
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda
+  sha256: dff1058c76ec6b8759e41cefa2508162d00e4a5e6721aa68ec3fd10094e702dc
+  md5: 5794b3bdc38177caf969dabd3af08549
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc 15.2.0 he0feb66_19
+  constrains:
+  - libstdcxx-ng ==15.2.0=*_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 5852044
+  timestamp: 1778269036376
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_19.conda
+  sha256: 0672b6b6e1791c92e8eccad58081a99d614fcf82bca5841f9dfa3c3e658f83b9
+  md5: e5ce228e579726c07255dbf90dc62101
+  depends:
+  - libstdcxx 15.2.0 h934c35e_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports:
+    strong:
+    - libstdcxx
+  size: 27776
+  timestamp: 1778269074600
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.1-h9d88235_1.conda
+  sha256: e5f8c38625aa6d567809733ae04bb71c161a42e44a9fa8227abe61fa5c60ebe0
+  md5: cd5a90476766d53e901500df9215e927
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - lerc >=4.0.0,<5.0a0
+  - libdeflate >=1.25,<1.26.0a0
+  - libgcc >=14
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - liblzma >=5.8.1,<6.0a0
+  - libstdcxx >=14
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: HPND
+  purls: []
+  run_exports:
+    weak:
+    - libtiff >=4.7.1,<4.8.0a0
+  size: 435273
+  timestamp: 1762022005702
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda
+  sha256: 9b1bdce27a7e31f7d241aeecff67a1f3101d52a2b1e33ccc2cdf2613072bf81f
+  md5: 01bb81d12c957de066ea7362007df642
+  depends:
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libuuid >=2.42.2,<3.0a0
+  size: 40017
+  timestamp: 1781625522462
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libuv-1.52.1-h280c20c_0.conda
+  sha256: e28e4519223f78b3163599ca89c3f2d80bfb53e907e7fc74e806e60d1efa578b
+  md5: 4e33d49bf4fc853855a3b00643aa5484
+  depends:
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libuv >=1.52.1,<2.0a0
+  size: 419935
+  timestamp: 1779396012261
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libvulkan-loader-1.4.341.0-h5279c79_0.conda
+  sha256: a68280d57dfd29e3d53400409a39d67c4b9515097eba733aa6fe00c880620e2b
+  md5: 31ad065eda3c2d88f8215b1289df9c89
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxrandr >=1.5.5,<2.0a0
+  constrains:
+  - libvulkan-headers 1.4.341.0.*
+  license: Apache-2.0
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libvulkan-loader >=1.4.341.0,<2.0a0
+  size: 199795
+  timestamp: 1770077125520
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda
+  sha256: 3aed21ab28eddffdaf7f804f49be7a7d701e8f0e46c856d801270b470820a37b
+  md5: aea31d2e5b1091feca96fcfe945c3cf9
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  constrains:
+  - libwebp 1.6.0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libwebp-base >=1.6.0,<2.0a0
+  size: 429011
+  timestamp: 1752159441324
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda
+  sha256: 666c0c431b23c6cec6e492840b176dde533d48b7e6fb8883f5071223433776aa
+  md5: 92ed62436b625154323d40d5f2f11dd7
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - pthread-stubs
+  - xorg-libxau >=1.0.11,<2.0a0
+  - xorg-libxdmcp
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxcb >=1.17.0,<2.0a0
+  size: 395888
+  timestamp: 1727278577118
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda
+  sha256: 6ae68e0b86423ef188196fff6207ed0c8195dd84273cb5623b85aa08033a410c
+  md5: 5aa797f8787fe7a17d1b0821485b5adc
+  depends:
+  - libgcc-ng >=12
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libxcrypt >=4.4.36
+  size: 100393
+  timestamp: 1702724383534
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.13.2-hca5e8e5_0.conda
+  sha256: 046f2ff4acebd8729fac03e99c8c307dfb48b6a32894ba8c11576e78f6e76e43
+  md5: dc8b067e22b414172bedd8e3f03f3c95
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libxcb >=1.17.0,<2.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - xkeyboard-config
+  - xorg-libxau >=1.0.12,<2.0a0
+  license: MIT/X11 Derivative
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxkbcommon >=1.13.2,<2.0a0
+  size: 851166
+  timestamp: 1780213397575
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda
+  sha256: 3d44f737c5ae52d5af32682cc1530df433f401f8e58a7533926536244127572a
+  md5: e79d2c2f24b027aa8d5ab1b1ba3061e7
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - icu >=78.3,<79.0a0
+  - libgcc >=14
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - libxml2 2.15.3
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 559775
+  timestamp: 1776376739004
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda
+  sha256: 3bc5551720c58591f6ea1146f7d1539c734ed1c40e7b9f5cb8cb7e900c509aba
+  md5: 995d8c8bad2a3cc8db14675a153dec2b
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - icu >=78.3,<79.0a0
+  - libgcc >=14
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libxml2-16 2.15.3 hca6bf5a_0
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxml2
+    - libxml2-16 >=2.15.3
+  size: 46810
+  timestamp: 1776376751152
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.43-h711ed8c_1.conda
+  sha256: 0694760a3e62bdc659d90a14ae9c6e132b525a7900e59785b18a08bb52a5d7e5
+  md5: 87e6096ec6d542d1c1f8b33245fe8300
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libxml2
+  - libxml2-16 >=2.14.6
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxslt >=1.1.43,<2.0a0
+  size: 245434
+  timestamp: 1757963724977
+- conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda
+  sha256: 55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9
+  md5: d87ff7921124eccd67248aa483c23fec
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  constrains:
+  - zlib 1.3.2 *_2
+  license: Zlib
+  license_family: Other
+  purls: []
+  run_exports:
+    weak:
+    - libzlib >=1.3.2,<2.0a0
+  size: 63629
+  timestamp: 1774072609062
+- conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-22.1.8-h4922eb0_0.conda
+  sha256: a37aba21b85800af1e7c5b04ba76abab96b6e591eedf99dc6e4df83b0fefd7a5
+  md5: 7bbfdc5a6eca997d3b0873a575c3e155
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  constrains:
+  - intel-openmp <0.0a0
+  - openmp 22.1.8|22.1.8.*
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    strong:
+    - llvm-openmp >=22.1.8
+    - _openmp_mutex >=4.5
+    - _openmp_mutex * *_llvm
+  size: 6123597
+  timestamp: 1781736521736
+- conda: https://conda.anaconda.org/conda-forge/linux-64/lychee-0.24.2-he64ecbb_0.conda
+  sha256: 3fd9108a9af3ad8f5124b9dc4ec4c0169e27e6379100374844b6a058ca8e8988
+  md5: 5ef12daae06f2228dcb37c95a8db1881
+  depends:
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - openssl >=3.5.6,<4.0a0
+  constrains:
+  - __glibc >=2.17
+  license: Apache-2.0 OR MIT
+  run_exports: {}
+  size: 5789257
+  timestamp: 1777662729855
+- conda: https://conda.anaconda.org/conda-forge/linux-64/make-4.4.1-hb9d3cd8_2.conda
+  sha256: d652c7bd4d3b6f82b0f6d063b0d8df6f54cc47531092d7ff008e780f3261bdda
+  md5: 33405d2a66b1411db9f7242c8b97c9e7
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  license: GPL-3.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 513088
+  timestamp: 1727801714848
+- conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py314h67df5f8_1.conda
+  sha256: c279be85b59a62d5c52f5dd9a4cd43ebd08933809a8416c22c3131595607d4cf
+  md5: 9a17c4307d23318476d7fbf0fedc0cde
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - jinja2 >=3.0.0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/markupsafe?source=hash-mapping
+  run_exports: {}
+  size: 27424
+  timestamp: 1772445227915
+- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.11.0-py314hdafbbf9_1.conda
+  sha256: bd375b8d5999ebd47d3eecd3ca7d0cb6b13156b83181bb99c9704b758114058d
+  md5: 23f8baa07d5e4f97b86cde417babf32b
+  depends:
+  - matplotlib-base >=3.11.0,<3.11.1.0a0
+  - pyside6 >=6.7.2
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - tornado >=5
+  license: PSF-2.0
+  license_family: PSF
+  purls:
+  - pkg:pypi/matplotlib?source=compressed-mapping
+  run_exports: {}
+  size: 14828
+  timestamp: 1782829552189
+- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.11.0-py314had63eae_1.conda
+  sha256: 666a19f61a40c5936bd0f07965b159ced727256fa7e2a4ff9dd5f0146aad86f1
+  md5: 5866f3034ce42e8d512e7640f43270fd
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - contourpy >=1.0.1
+  - cycler >=0.10
+  - fonttools >=4.22.0
+  - freetype
+  - kiwisolver >=1.3.1
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libgcc >=14
+  - libraqm >=0.10.5,<0.11.0a0
+  - libstdcxx >=14
+  - numpy >=1.23
+  - numpy >=1.25,<3
+  - packaging >=20.0
+  - pillow >=8
+  - pyparsing >=2.3.1
+  - python >=3.14,<3.15.0a0
+  - python-dateutil >=2.7
+  - python_abi 3.14.* *_cp314
+  - qhull >=2020.2,<2020.3.0a0
+  - tk >=8.6.13,<8.7.0a0
+  license: PSF-2.0
+  license_family: PSF
+  purls:
+  - pkg:pypi/matplotlib?source=compressed-mapping
+  run_exports: {}
+  size: 9004007
+  timestamp: 1782829533688
+- conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.4-np2py310h3d4ba91_1.conda
+  sha256: 3dacf9d226b632546e901b81059ebca5b10da9dc323ae5b388db472c5206402a
+  md5: 9d02fb99445f6266cb9b05dace5d5ba8
+  depends:
+  - python
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libstdcxx >=14
+  - python_abi 3.10.* *_cp310
+  - numpy >=1.21,<3
+  license: MPL-2.0 AND Apache-2.0
+  run_exports: {}
+  size: 342598
+  timestamp: 1771362428824
+- conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.4-np2py314h6477eea_1.conda
+  sha256: bf58f5b2d89958e8880cfde4e5e3d86f230485c5f5f1043fc47a56656f9655c6
+  md5: af93de29d470abbe21a6adc2ec58516e
+  depends:
+  - python
+  - __glibc >=2.17,<3.0.a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - python_abi 3.14.* *_cp314
+  - numpy >=1.23,<3
+  license: MPL-2.0 AND Apache-2.0
+  purls:
+  - pkg:pypi/ml-dtypes?source=hash-mapping
+  run_exports: {}
+  size: 345273
+  timestamp: 1771362516002
+- conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-2.1.0-py310h99dffb4_0.conda
+  sha256: 45e9914b84031f7883e0af05b479f69763f4ddc42863f5622136dcd499b35d6c
+  md5: d1b5b89ab1f80a678e26aa6309d7dc53
+  depends:
+  - ast-serialize >=0.3.0,<1.0.0
+  - mypy_extensions >=1.0.0
+  - pathspec >=1.0.0
+  - python
+  - python-librt >=0.11.0
+  - typing_extensions >=4.6.0
+  - psutil >=4.0
+  - tomli >=1.1.0
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - python_abi 3.10.* *_cp310
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 20967481
+  timestamp: 1780315606129
+- conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-2.1.0-py314h518bba1_0.conda
+  sha256: 9fcf9e7343c30fdeab75e8440caa2814798eeff22a6dc5f7a556df8372e1b0ca
+  md5: 5625fce7423d7579e60f9cbcc5738d2b
+  depends:
+  - ast-serialize >=0.3.0,<1.0.0
+  - mypy_extensions >=1.0.0
+  - pathspec >=1.0.0
+  - python
+  - python-librt >=0.11.0
+  - typing_extensions >=4.6.0
+  - psutil >=4.0
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - python_abi 3.14.* *_cp314
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/mypy?source=hash-mapping
+  run_exports: {}
+  size: 22860519
+  timestamp: 1780315602311
+- conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda
+  sha256: fc89f74bbe362fb29fa3c037697a89bec140b346a2469a90f7936d1d7ea4d8a3
+  md5: fc21868a1a5aacc937e7a18747acb8a5
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: X11 AND BSD-3-Clause
+  purls: []
+  run_exports:
+    weak:
+    - ncurses >=6.6,<7.0a0
+  size: 918956
+  timestamp: 1777422145199
+- conda: https://conda.anaconda.org/conda-forge/linux-64/ninja-1.13.2-h171cf75_0.conda
+  sha256: 6f7d59dbec0a7b00bf5d103a4306e8886678b796ff2151b62452d4582b2a53fb
+  md5: b518e9e92493721281a60fa975bddc65
+  depends:
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  license: Apache-2.0
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 186323
+  timestamp: 1763688260928
+- conda: https://conda.anaconda.org/conda-forge/linux-64/nodejs-24.18.0-h3d65ac4_0.conda
+  sha256: d52dd84f72dc024e5792e1d177ba7ef852122808d4de75c4bfb00f72b502c861
+  md5: d7a1d28fe726da6b1200f66ae4e93390
+  depends:
+  - libgcc >=14
+  - __glibc >=2.28,<3.0.a0
+  - libstdcxx >=14
+  - libuv >=1.52.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - libnghttp2 >=1.68.1,<2.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  - libbrotlicommon >=1.2.0,<1.3.0a0
+  - libbrotlienc >=1.2.0,<1.3.0a0
+  - libbrotlidec >=1.2.0,<1.3.0a0
+  - icu >=78.3,<79.0a0
+  - c-ares >=1.34.6,<2.0a0
+  - openssl >=3.5.7,<4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - nodejs >=24.18.0,<25.0a0
+  size: 17970244
+  timestamp: 1782395968194
+- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.23.2-py310h53a5b5f_0.tar.bz2
+  sha256: 6f8942fd7a7e588ec4be4edbdd5bcc1d41eb522dc4b5e4b5640242bb9b5f3d32
+  md5: 8b3cfad14508018915e88612f5a963cd
+  depends:
+  - libblas >=3.9.0,<4.0a0
+  - libcblas >=3.9.0,<4.0a0
+  - libgcc-ng >=12
+  - liblapack >=3.9.0,<4.0a0
+  - libstdcxx-ng >=12
+  - python >=3.10,<3.11.0a0
+  - python_abi 3.10.* *_cp310
+  constrains:
+  - numpy-base <0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports:
+    weak:
+    - numpy >=1.23.2,<2.0a0
+  size: 7410140
+  timestamp: 1660673448016
+- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.5.0-py314h2b28147_0.conda
+  sha256: bbc665584886c90daf3f33cfbf665f279cf91d4bd5323f0432c16d2bf4d525e7
+  md5: bdb21d2b990f9d3aee10fd43aca851fe
+  depends:
+  - python
+  - libgcc >=14
+  - libstdcxx >=14
+  - __glibc >=2.17,<3.0.a0
+  - libcblas >=3.9.0,<4.0a0
+  - libblas >=3.9.0,<4.0a0
+  - python_abi 3.14.* *_cp314
+  - liblapack >=3.9.0,<4.0a0
+  constrains:
+  - numpy-base <0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/numpy?source=compressed-mapping
+  run_exports:
+    weak:
+    - numpy >=1.25,<3
+  size: 9075918
+  timestamp: 1782112541752
+- conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.26.0-py310hddea34e_0_cpu.conda
+  sha256: 2fa35103b3c1b0c90654f36fbd50519bba85913ea89305a7aecffc23d317d626
+  md5: 9edda3f5bd751f3dcddfda5c38a3f8e0
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - numpy >=1.21,<3
+  - packaging
+  - protobuf
+  - python >=3.10,<3.11.0a0
+  - python-flatbuffers
+  - python_abi 3.10.* *_cp310
+  license: MIT AND BSL-1.0
+  run_exports: {}
+  size: 15171373
+  timestamp: 1778966415091
+- conda: https://conda.anaconda.org/conda-forge/linux-64/onnxruntime-1.26.0-py314h112547c_0_cpu.conda
+  sha256: 12bb84f9d5ee9f7d9e3f7b7020840dffeacaefaf9833ca9e1993e7484dd81907
+  md5: 091aef3f785aa68a0b13384ee2445e9d
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - numpy >=1.23,<3
+  - packaging
+  - protobuf
+  - python >=3.14,<3.15.0a0
+  - python-flatbuffers
+  - python_abi 3.14.* *_cp314
+  license: MIT AND BSL-1.0
+  purls:
+  - pkg:pypi/onnxruntime?source=hash-mapping
+  run_exports: {}
+  size: 15616272
+  timestamp: 1778969183434
+- conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda
+  sha256: 3900f9f2dbbf4129cf3ad6acf4e4b6f7101390b53843591c53b00f034343bc4d
+  md5: 11b3379b191f63139e29c0d19dee24cd
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libpng >=1.6.50,<1.7.0a0
+  - libstdcxx >=14
+  - libtiff >=4.7.1,<4.8.0a0
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - openjpeg >=2.5.4,<3.0a0
+  size: 355400
+  timestamp: 1758489294972
+- conda: https://conda.anaconda.org/conda-forge/linux-64/openldap-2.6.13-hbde042b_0.conda
+  sha256: 21c4f6c7f41dc9bec2ea2f9c80440d9a4d45a6f2ac13243e658f10dcf1044146
+  md5: 680608784722880fbfe1745067570b00
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - cyrus-sasl >=2.1.28,<3.0a0
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - openssl >=3.5.6,<4.0a0
+  license: OLDAP-2.8
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - openldap >=2.6.13,<2.7.0a0
+  size: 786149
+  timestamp: 1775741359582
+- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda
+  sha256: d48f5c22b9897c01e4dff3680f1f57ceb02711ab9c62f74339b080419dfad34b
+  md5: 79dd2074b5cd5c5c6b2930514a11e22d
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - ca-certificates
+  - libgcc >=14
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - openssl >=3.6.3,<4.0a0
+  size: 3159683
+  timestamp: 1781069855778
+- conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.56.4-hda50119_1.conda
+  sha256: 315b52bfa6d1a820f4806f6490d472581438a28e21df175290477caec18972b0
+  md5: d53ffc0edc8eabf4253508008493c5bc
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - cairo >=1.18.4,<2.0a0
+  - fontconfig >=2.17.1,<3.0a0
+  - fonts-conda-ecosystem
+  - fribidi >=1.0.16,<2.0a0
+  - harfbuzz >=13.2.1
+  - libexpat >=2.7.4,<3.0a0
+  - libfreetype >=2.14.2
+  - libfreetype6 >=2.14.2
+  - libgcc >=14
+  - libglib >=2.86.4,<3.0a0
+  - libpng >=1.6.55,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - pango >=1.56.4,<2.0a0
+  size: 458036
+  timestamp: 1774281947855
+- conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda
+  sha256: 5e6f7d161356fefd981948bea5139c5aa0436767751a6930cb1ca801ebb113ff
+  md5: 7a3bff861a6583f1889021facefc08b1
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - bzip2 >=1.0.8,<2.0a0
+  - libgcc >=14
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - pcre2 >=10.47,<10.48.0a0
+  size: 1222481
+  timestamp: 1763655398280
+- conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.3.0-py310h6557065_3.conda
+  sha256: 7fe27fd1c5a3d85ea355a609d050e50469382223bbf5a07ca750e30b6aebdc25
+  md5: e169733dc0c743687a852f1c6e989140
+  depends:
+  - python
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libtiff >=4.7.0,<4.8.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libxcb >=1.17.0,<2.0a0
+  - python_abi 3.10.* *_cp310
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - lcms2 >=2.17,<3.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - openjpeg >=2.5.3,<3.0a0
+  - libzlib >=1.3.1,<2.0a0
+  license: HPND
+  run_exports: {}
+  size: 882171
+  timestamp: 1758208668856
+- conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.3.0-py314hdf18abd_3.conda
+  sha256: 73c9b1c2a9e7240abdadbece433142cf098bff7fa6d54ed50ac5702e8f602660
+  md5: bd5ca6f6d5e296555fce072583089954
+  depends:
+  - python
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - lcms2 >=2.17,<3.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - tk >=8.6.13,<8.7.0a0
+  - libxcb >=1.17.0,<2.0a0
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - python_abi 3.14.* *_cp314
+  - libtiff >=4.7.0,<4.8.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - openjpeg >=2.5.3,<3.0a0
+  license: HPND
+  purls:
+  - pkg:pypi/pillow?source=hash-mapping
+  run_exports: {}
+  size: 1070754
+  timestamp: 1758208631023
+- conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.46.4-h54a6638_1.conda
+  sha256: 43d37bc9ca3b257c5dd7bf76a8426addbdec381f6786ff441dc90b1a49143b6a
+  md5: c01af13bdc553d1a8fbfff6e8db075f0
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - pixman >=0.46.4,<1.0a0
+  size: 450960
+  timestamp: 1754665235234
+- conda: https://conda.anaconda.org/conda-forge/linux-64/prek-0.4.6-hb17b654_0.conda
+  sha256: da2d4de20327217f1b83abb8ab72e0daca4413f371492002557f888d7e41af7a
+  md5: 3e624359659d1ce03e7f579ea7a1c38c
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  constrains:
+  - __glibc >=2.17
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 6117199
+  timestamp: 1782881504648
+- conda: https://conda.anaconda.org/conda-forge/linux-64/prettier-3.9.3-h7e4c9f4_0.conda
+  sha256: ec8af57fabe73c269b762eb8d3f45505ef3528c22a4d4d3994a9b2d70c9c57d9
+  md5: 52df3de33d8bed542df618f403fa5b85
+  depends:
+  - nodejs
+  - __glibc >=2.17,<3.0.a0
+  - nodejs >=24.18.0,<25.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 1370893
+  timestamp: 1782740641804
+- conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-6.31.1-py310ha36e12e_2.conda
+  sha256: c9546dc61a66fabab16a7730b80cca083a22593fc889b496b56940fa05ef8be2
+  md5: e89aa169330695f7694c94d9a95d20bc
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libabseil * cxx17*
+  - libabseil >=20250512.1,<20250513.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.1,<2.0a0
+  - python >=3.10,<3.11.0a0
+  - python_abi 3.10.* *_cp310
+  constrains:
+  - libprotobuf 6.31.1
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 405059
+  timestamp: 1760393380060
+- conda: https://conda.anaconda.org/conda-forge/linux-64/protobuf-6.33.5-py314h61e7c5f_2.conda
+  sha256: ceed4e3b1d13b0f200afbf01f7e314111cce85e116b8db512ff940571ba64104
+  md5: 418826d23f3fa6354700b4f31c5b87ba
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libabseil * cxx17*
+  - libabseil >=20260107.1,<20260108.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.1,<2.0a0
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - libprotobuf 6.33.5
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/protobuf?source=hash-mapping
+  run_exports: {}
+  size: 491842
+  timestamp: 1773265994654
+- conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py310h139afa4_0.conda
+  sha256: 3a6d46033ebad3e69ded3f76852b9c378c2cff632f57421b5926c6add1bae475
+  md5: d210342acdb8e3ca6434295497c10b7c
+  depends:
+  - python
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - python_abi 3.10.* *_cp310
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 179015
+  timestamp: 1769678154886
+- conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h0f05182_0.conda
+  sha256: f15574ed6c8c8ed8c15a0c5a00102b1efe8b867c0bd286b498cd98d95bd69ae5
+  md5: 4f225a966cfee267a79c5cb6382bd121
+  depends:
+  - python
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/psutil?source=hash-mapping
+  run_exports: {}
+  size: 231303
+  timestamp: 1769678156552
+- conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda
+  sha256: 9c88f8c64590e9567c6c80823f0328e58d3b1efb0e1c539c0315ceca764e0973
+  md5: b3c17d95b5a10c6e64a21fa17573e70e
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 8252
+  timestamp: 1726802366959
+- conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.11.1-py314h3987850_1.conda
+  sha256: e410d0d4151f418dc75ea2dc38dfb0e7a136090b6874e5ca1c699fa840b4994d
+  md5: 5d2051f0630a568926943fc53c0aaa4c
+  depends:
+  - python
+  - qt6-main 6.11.1.*
+  - libstdcxx >=14
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libvulkan-loader >=1.4.341.0,<2.0a0
+  - libgl >=1.7.0,<2.0a0
+  - libopengl >=1.7.0,<2.0a0
+  - libxslt >=1.1.43,<2.0a0
+  - libegl >=1.7.0,<2.0a0
+  - python_abi 3.14.* *_cp314
+  - qt6-main >=6.11.1,<6.12.0a0
+  - libclang13 >=22.1.5
+  - libxml2
+  - libxml2-16 >=2.14.6
+  license: LGPL-3.0-only
+  license_family: LGPL
+  purls:
+  - pkg:pypi/pyside6?source=compressed-mapping
+  run_exports: {}
+  size: 13821776
+  timestamp: 1778933872780
+- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.20-h267e890_1_cpython.conda
+  build_number: 1
+  sha256: c15d8585b7a52fdb734bd16dbdcae4b81ed59268862d3a2588eb8ed69c8cbc52
+  md5: c5eace1c2d8dae0bb08c094617ea8cc7
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - bzip2 >=1.0.8,<2.0a0
+  - ld_impl_linux-64 >=2.36.1
+  - libexpat >=2.8.1,<3.0a0
+  - libffi >=3.4,<4.0a0
+  - libgcc >=14
+  - liblzma >=5.8.3,<6.0a0
+  - libnsl >=2.0.1,<2.1.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libuuid >=2.42.1,<3.0a0
+  - libxcrypt >=4.4.36
+  - libzlib >=1.3.2,<2.0a0
+  - ncurses >=6.6,<7.0a0
+  - openssl >=3.5.7,<4.0a0
+  - readline >=8.3,<9.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - tzdata
+  constrains:
+  - python_abi 3.10.* *_cp310
+  license: Python-2.0
+  run_exports:
+    weak:
+    - python_abi 3.10.* *_cp310
+    noarch:
+    - python
+  size: 25403213
+  timestamp: 1781149348162
+- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda
+  build_number: 100
+  sha256: 6d28ac2b061179deb434d3d57afa98ffd20ec3c5d44ab8048a1ca33424b22d38
+  md5: 0b9b2f83b5b600e1ac38becde8d0dd44
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - bzip2 >=1.0.8,<2.0a0
+  - ld_impl_linux-64 >=2.36.1
+  - libexpat >=2.8.1,<3.0a0
+  - libffi >=3.5.2,<3.6.0a0
+  - libgcc >=14
+  - liblzma >=5.8.3,<6.0a0
+  - libmpdec >=4.0.0,<5.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libuuid >=2.42.1,<3.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ncurses >=6.6,<7.0a0
+  - openssl >=3.5.7,<4.0a0
+  - python_abi 3.14.* *_cp314
+  - readline >=8.3,<9.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - tzdata
+  - zstd >=1.5.7,<1.6.0a0
+  license: Python-2.0
+  purls: []
+  run_exports:
+    weak:
+    - python_abi 3.14.* *_cp314
+    noarch:
+    - python
+  size: 36717183
+  timestamp: 1781255094700
+  python_site_packages_path: lib/python3.14/site-packages
+- conda: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.12.0-py310h139afa4_0.conda
+  sha256: b32091f5d39e6e30bc06fd0fa379d51213e662caf15ab9b1cb513db3085c8f7b
+  md5: 69cc19928dc2434e2e47c7332637337e
+  depends:
+  - python
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - python_abi 3.10.* *_cp310
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 159617
+  timestamp: 1782847502350
+- conda: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.12.0-py314h0f05182_0.conda
+  sha256: f8b608833cd289c9f06f6b528139e53ea1c509a8eb9d4490d15ad76f59def5c6
+  md5: fbc3f0267d363cf1ecd689389c9bb67e
+  depends:
+  - python
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - python_abi 3.14.* *_cp314
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/librt?source=hash-mapping
+  run_exports: {}
+  size: 159222
+  timestamp: 1782847502106
+- conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py314h67df5f8_1.conda
+  sha256: b318fb070c7a1f89980ef124b80a0b5ccf3928143708a85e0053cde0169c699d
+  md5: 2035f68f96be30dc60a5dfd7452c7941
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - yaml >=0.2.5,<0.3.0a0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pyyaml?source=hash-mapping
+  run_exports: {}
+  size: 202391
+  timestamp: 1770223462836
+- conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda
+  sha256: 776363493bad83308ba30bcb88c2552632581b143e8ee25b1982c8c743e73abc
+  md5: 353823361b1d27eb3960efb076dfcaf6
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc-ng >=12
+  - libstdcxx-ng >=12
+  license: LicenseRef-Qhull
+  purls: []
+  run_exports:
+    weak:
+    - qhull >=2020.2,<2020.3.0a0
+  size: 552937
+  timestamp: 1720813982144
+- conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.11.1-pl5321h16c4a6b_1.conda
+  sha256: aefbc43bde188ff4027d480da99c7fa9e8e6341e9762e065190239cb9b99bb1c
+  md5: 331d660aef48fec733a878dd1f8f4206
+  depends:
+  - libxcb
+  - xcb-util
+  - xcb-util-wm
+  - xcb-util-keysyms
+  - xcb-util-image
+  - xcb-util-renderutil
+  - xcb-util-cursor
+  - libgl-devel
+  - libegl-devel
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - libstdcxx >=14
+  - xcb-util >=0.4.1,<0.5.0a0
+  - xorg-libx11 >=1.8.13,<2.0a0
+  - pcre2 >=10.47,<10.48.0a0
+  - libbrotlicommon >=1.2.0,<1.3.0a0
+  - libbrotlienc >=1.2.0,<1.3.0a0
+  - libbrotlidec >=1.2.0,<1.3.0a0
+  - fontconfig >=2.18.1,<3.0a0
+  - fonts-conda-ecosystem
+  - xorg-libxxf86vm >=1.1.7,<2.0a0
+  - xorg-libxrandr >=1.5.5,<2.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libpq >=18.4,<19.0a0
+  - xorg-libice >=1.1.2,<2.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - wayland >=1.25.0,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - libvulkan-loader >=1.4.341.0,<2.0a0
+  - xorg-libxext >=1.3.7,<2.0a0
+  - xcb-util-keysyms >=0.4.1,<0.5.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - harfbuzz >=14.2.1
+  - xcb-util-cursor >=0.1.6,<0.2.0a0
+  - xorg-libxcursor >=1.2.3,<2.0a0
+  - libcups >=2.3.3,<2.4.0a0
+  - libxcb >=1.17.0,<2.0a0
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - libdrm >=2.4.127,<2.5.0a0
+  - xorg-libxcomposite >=0.4.7,<1.0a0
+  - xcb-util-image >=0.4.0,<0.5.0a0
+  - xcb-util-wm >=0.4.2,<0.5.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  - krb5 >=1.22.2,<1.23.0a0
+  - xcb-util-renderutil >=0.3.10,<0.4.0a0
+  - icu >=78.3,<79.0a0
+  - xorg-libxdamage >=1.1.6,<2.0a0
+  - xorg-libsm >=1.2.6,<2.0a0
+  - alsa-lib >=1.2.16,<1.3.0a0
+  - openssl >=3.5.6,<4.0a0
+  - libglib >=2.88.1,<3.0a0
+  - libgl >=1.7.0,<2.0a0
+  - libxkbcommon >=1.13.2,<2.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - double-conversion >=3.4.0,<3.5.0a0
+  - dbus >=1.16.2,<2.0a0
+  - xorg-libxtst >=1.2.5,<2.0a0
+  - libegl >=1.7.0,<2.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  constrains:
+  - qt ==6.11.1
+  license: LGPL-3.0-only
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - qt6-main >=6.11.1,<7.0a0
+  size: 60185421
+  timestamp: 1780593127053
+- conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda
+  sha256: 12ffde5a6f958e285aa22c191ca01bbd3d6e710aa852e00618fa6ddc59149002
+  md5: d7d95fc8287ea7bf33e0e7116d2b95ec
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - ncurses >=6.5,<7.0a0
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports:
+    weak:
+    - readline >=8.3,<9.0a0
+  size: 345073
+  timestamp: 1765813471974
+- conda: https://conda.anaconda.org/conda-forge/linux-64/rhash-1.4.6-hb9d3cd8_1.conda
+  sha256: d5c73079c1dd2c2a313c3bfd81c73dbd066b7eb08d213778c8bff520091ae894
+  md5: c1c9b02933fdb2cfb791d936c20e887e
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - rhash >=1.4.6,<2.0a0
+  size: 193775
+  timestamp: 1748644872902
+- conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.15.20-h6a952e8_0.conda
+  noarch: python
+  sha256: 4c10593eb248ae3b626ebfc2991bd67df96cb98a51816939188576237c54deee
+  md5: d9b134cef9bc26a9ed9a0fba1eff3356
+  depends:
+  - python
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  constrains:
+  - __glibc >=2.17
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/ruff?source=compressed-mapping
+  run_exports: {}
+  size: 9342178
+  timestamp: 1782428525856
+- conda: https://conda.anaconda.org/conda-forge/linux-64/shellcheck-0.11.0-ha770c72_1.conda
+  sha256: 09335c4ce927c3c47ffbe4f13c18b21cc0bf7b661dba8f7caba699f9e9f26bf3
+  md5: 59f8f9cfb1dc2f62abdca662823e052a
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 2759145
+  timestamp: 1771524222969
+- conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda
+  sha256: cafeec44494f842ffeca27e9c8b0c27ed714f93ac77ddadc6aaf726b5554ebac
+  md5: cffd3bdd58090148f4cfcd831f4b26ab
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libzlib >=1.3.1,<2.0a0
+  constrains:
+  - xorg-libx11 >=1.8.12,<2.0a0
+  license: TCL
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - tk >=8.6.13,<8.7.0a0
+  size: 3301196
+  timestamp: 1769460227866
+- conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.5.7-py314h5bd0f2a_0.conda
+  sha256: bbb7056f7c5fd606df16ed73ee68687050de2c02fd69a3f69a1cb533a7ed2ae8
+  md5: 4a8e5889712641aabdf6695e292857fe
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/tornado?source=hash-mapping
+  run_exports: {}
+  size: 918368
+  timestamp: 1781006801436
+- conda: https://conda.anaconda.org/conda-forge/linux-64/typos-1.48.0-hb17b654_0.conda
+  sha256: b8cd6270cf71afa1ea5abb21c5ea65d9f4f0ec2614d3af3d0d2185011a1ff3b4
+  md5: a66c11d121cd29ee901edb4eb50d1075
+  depends:
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  constrains:
+  - __glibc >=2.17
+  license: MIT OR Apache-2.0
+  purls: []
+  run_exports: {}
+  size: 3366192
+  timestamp: 1782859608728
+- conda: https://conda.anaconda.org/conda-forge/linux-64/unicodedata2-17.0.1-py314h5bd0f2a_0.conda
+  sha256: ff1c1d7c23b91c9b0eb93a3e1380f4e2ac6c37ea2bba4f932a5484e9a55bba30
+  md5: 494fdf358c152f9fdd0673c128c2f3dd
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/unicodedata2?source=hash-mapping
+  run_exports: {}
+  size: 409562
+  timestamp: 1770909102180
+- conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.25.0-hd6090a7_0.conda
+  sha256: ea374d57a8fcda281a0a89af0ee49a2c2e99cc4ac97cf2e2db7064e74e764bdb
+  md5: 996583ea9c796e5b915f7d7580b51ea6
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libexpat >=2.7.4,<3.0a0
+  - libffi >=3.5.2,<3.6.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - wayland >=1.25.0,<2.0a0
+  size: 334139
+  timestamp: 1773959575393
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-h4f16b4b_2.conda
+  sha256: ad8cab7e07e2af268449c2ce855cbb51f43f4664936eff679b1f3862e6e4b01d
+  md5: fdc27cb255a7a2cc73b7919a968b48f0
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - libxcb >=1.17.0,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util >=0.4.1,<0.5.0a0
+  size: 20772
+  timestamp: 1750436796633
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.6-hb03c661_0.conda
+  sha256: c2be9cae786fdb2df7c2387d2db31b285cf90ab3bfabda8fa75a596c3d20fc67
+  md5: 4d1fc190b99912ed557a8236e958c559
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libxcb >=1.13
+  - libxcb >=1.17.0,<2.0a0
+  - xcb-util-image >=0.4.0,<0.5.0a0
+  - xcb-util-renderutil >=0.3.10,<0.4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-cursor >=0.1.6,<0.2.0a0
+  size: 20829
+  timestamp: 1763366954390
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda
+  sha256: 94b12ff8b30260d9de4fd7a28cca12e028e572cbc504fd42aa2646ec4a5bded7
+  md5: a0901183f08b6c7107aab109733a3c91
+  depends:
+  - libgcc-ng >=12
+  - libxcb >=1.16,<2.0.0a0
+  - xcb-util >=0.4.1,<0.5.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-image >=0.4.0,<0.5.0a0
+  size: 24551
+  timestamp: 1718880534789
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda
+  sha256: 546e3ee01e95a4c884b6401284bb22da449a2f4daf508d038fdfa0712fe4cc69
+  md5: ad748ccca349aec3e91743e08b5e2b50
+  depends:
+  - libgcc-ng >=12
+  - libxcb >=1.16,<2.0.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-keysyms >=0.4.1,<0.5.0a0
+  size: 14314
+  timestamp: 1718846569232
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda
+  sha256: 2d401dadc43855971ce008344a4b5bd804aca9487d8ebd83328592217daca3df
+  md5: 0e0cbe0564d03a99afd5fd7b362feecd
+  depends:
+  - libgcc-ng >=12
+  - libxcb >=1.16,<2.0.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-renderutil >=0.3.10,<0.4.0a0
+  size: 16978
+  timestamp: 1718848865819
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda
+  sha256: 31d44f297ad87a1e6510895740325a635dd204556aa7e079194a0034cdd7e66a
+  md5: 608e0ef8256b81d04456e8d211eee3e8
+  depends:
+  - libgcc-ng >=12
+  - libxcb >=1.16,<2.0.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-wm >=0.4.2,<0.5.0a0
+  size: 51689
+  timestamp: 1718844051451
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.48-h280c20c_0.conda
+  sha256: 3b04afd5d1a65d2d27ac2d49a63b01ab8bcd875776779ec63e337370ed38afdc
+  md5: b233b41be0bf210989d57160ed39b394
+  depends:
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  - xorg-libx11 >=1.8.13,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 441670
+  timestamp: 1782027360439
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda
+  sha256: c12396aabb21244c212e488bbdc4abcdef0b7404b15761d9329f5a4a39113c4b
+  md5: fb901ff28063514abb6046c9ec2c4a45
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libice >=1.1.2,<2.0a0
+  size: 58628
+  timestamp: 1734227592886
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.6-he73a12e_0.conda
+  sha256: 277841c43a39f738927145930ff963c5ce4c4dacf66637a3d95d802a64173250
+  md5: 1c74ff8c35dcadf952a16f752ca5aa49
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - libuuid >=2.38.1,<3.0a0
+  - xorg-libice >=1.1.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libsm >=1.2.6,<2.0a0
+  size: 27590
+  timestamp: 1741896361728
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.13-he1eb515_0.conda
+  sha256: 516d4060139dbb4de49a4dcdc6317a9353fb39ebd47789c14e6fe52de0deee42
+  md5: 861fb6ccbc677bb9a9fb2468430b9c6a
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libxcb >=1.17.0,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libx11 >=1.8.13,<2.0a0
+  size: 839652
+  timestamp: 1770819209719
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda
+  sha256: 6bc6ab7a90a5d8ac94c7e300cc10beb0500eeba4b99822768ca2f2ef356f731b
+  md5: b2895afaf55bf96a8c8282a2e47a5de0
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxau >=1.0.12,<2.0a0
+  size: 15321
+  timestamp: 1762976464266
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.7-hb03c661_0.conda
+  sha256: 048c103000af9541c919deef03ae7c5e9c570ffb4024b42ecb58dbde402e373a
+  md5: f2ba4192d38b6cef2bb2c25029071d90
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxfixes >=6.0.2,<7.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxcomposite >=0.4.7,<1.0a0
+  size: 14415
+  timestamp: 1770044404696
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda
+  sha256: 832f538ade441b1eee863c8c91af9e69b356cd3e9e1350fff4fe36cc573fc91a
+  md5: 2ccd714aa2242315acaf0a67faea780b
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - xorg-libx11 >=1.8.10,<2.0a0
+  - xorg-libxfixes >=6.0.1,<7.0a0
+  - xorg-libxrender >=0.9.11,<0.10.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxcursor >=1.2.3,<2.0a0
+  size: 32533
+  timestamp: 1730908305254
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda
+  sha256: 43b9772fd6582bf401846642c4635c47a9b0e36ca08116b3ec3df36ab96e0ec0
+  md5: b5fcc7172d22516e1f965490e65e33a4
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - xorg-libx11 >=1.8.10,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxfixes >=6.0.1,<7.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxdamage >=1.1.6,<2.0a0
+  size: 13217
+  timestamp: 1727891438799
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda
+  sha256: 25d255fb2eef929d21ff660a0c687d38a6d2ccfbcbf0cc6aa738b12af6e9d142
+  md5: 1dafce8548e38671bea82e3f5c6ce22f
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxdmcp >=1.1.5,<2.0a0
+  size: 20591
+  timestamp: 1762976546182
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.7-hb03c661_0.conda
+  sha256: 79c60fc6acfd3d713d6340d3b4e296836a0f8c51602327b32794625826bd052f
+  md5: 34e54f03dfea3e7a2dcf1453a85f1085
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxext >=1.3.7,<2.0a0
+  size: 50326
+  timestamp: 1769445253162
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.2-hb03c661_0.conda
+  sha256: 83c4c99d60b8784a611351220452a0a85b080668188dce5dfa394b723d7b64f4
+  md5: ba231da7fccf9ea1e768caf5c7099b84
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxfixes >=6.0.2,<7.0a0
+  size: 20071
+  timestamp: 1759282564045
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.3-hb03c661_0.conda
+  sha256: 495f99c8eacfa4ae2d8fed2a7f2105777af89acdc204df145d2bbbc380ac631b
+  md5: adba2e334082bb218db806d4c12277c9
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - xorg-libx11 >=1.8.13,<2.0a0
+  - xorg-libxext >=1.3.7,<2.0a0
+  - xorg-libxfixes >=6.0.2,<7.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxi >=1.8.3,<2.0a0
+  size: 47717
+  timestamp: 1779111857071
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.6-hecca717_0.conda
+  sha256: 3a9da41aac6dca9d3ff1b53ee18b9d314de88add76bafad9ca2287a494abcd86
+  md5: 93f5d4b5c17c8540479ad65f206fea51
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxinerama >=1.1.6,<1.2.0a0
+  size: 14818
+  timestamp: 1769432261050
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.5-hb03c661_0.conda
+  sha256: 80ed047a5cb30632c3dc5804c7716131d767089f65877813d4ae855ee5c9d343
+  md5: e192019153591938acf7322b6459d36e
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxrender >=0.9.12,<0.10.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxrandr >=1.5.5,<2.0a0
+  size: 30456
+  timestamp: 1769445263457
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda
+  sha256: 044c7b3153c224c6cedd4484dd91b389d2d7fd9c776ad0f4a34f099b3389f4a1
+  md5: 96d57aba173e878a2089d5638016dc5e
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - xorg-libx11 >=1.8.10,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxrender >=0.9.12,<0.10.0a0
+  size: 33005
+  timestamp: 1734229037766
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda
+  sha256: 752fdaac5d58ed863bbf685bb6f98092fe1a488ea8ebb7ed7b606ccfce08637a
+  md5: 7bbe9a0cc0df0ac5f5a8ad6d6a11af2f
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=13
+  - xorg-libx11 >=1.8.10,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxi >=1.7.10,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxtst >=1.2.5,<2.0a0
+  size: 32808
+  timestamp: 1727964811275
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.7-hb03c661_0.conda
+  sha256: 64db17baaf36fa03ed8fae105e2e671a7383e22df4077486646f7dbf12842c9f
+  md5: 665d152b9c6e78da404086088077c844
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxxf86vm >=1.1.7,<2.0a0
+  size: 18701
+  timestamp: 1769434732453
+- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xorgproto-2025.1-hb03c661_0.conda
+  sha256: 7a8c64938428c2bfd016359f9cb3c44f94acc256c6167dbdade9f2a1f5ca7a36
+  md5: aa8d21be4b461ce612d8f5fb791decae
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 570010
+  timestamp: 1766154256151
+- conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda
+  sha256: 6d9ea2f731e284e9316d95fa61869fe7bbba33df7929f82693c121022810f4ad
+  md5: a77f85f77be52ff59391544bfe73390a
+  depends:
+  - libgcc >=14
+  - __glibc >=2.17,<3.0.a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - yaml >=0.2.5,<0.3.0a0
+  size: 85189
+  timestamp: 1753484064210
+- conda: https://conda.anaconda.org/conda-forge/linux-64/zizmor-1.26.1-hb17b654_0.conda
+  sha256: 85d8192e2e37d41982001847717fa5efb2783ca27ea095cc794bbff229d3c7c9
+  md5: 7b12afe6b053ac52f2eed61027d44cc1
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libgcc >=14
+  constrains:
+  - __glibc >=2.17
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 6965126
+  timestamp: 1782024319891
+- conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda
+  sha256: 68f0206ca6e98fea941e5717cec780ed2873ffabc0e1ed34428c061e2c6268c7
+  md5: 4a13eeac0b5c8e5b8ab496e6c4ddd829
+  depends:
+  - __glibc >=2.17,<3.0.a0
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - zstd >=1.5.7,<1.6.0a0
+  size: 601375
+  timestamp: 1764777111296
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda
+  build_number: 20
+  sha256: a2527b1d81792a0ccd2c05850960df119c2b6d8f5fdec97f2db7d25dc23b1068
+  md5: 468fd3bb9e1f671d36c2cbc677e56f1d
+  depends:
+  - libgomp >=7.5.0
+  constrains:
+  - openmp_impl <0.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    strong:
+    - _openmp_mutex >=4.5
+  size: 28926
+  timestamp: 1770939656741
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/alsa-lib-1.2.16.1-he30d5cf_0.conda
+  sha256: 105e4c19cfa770affcb9a64b9d2451f406914cd09a67664009910869fa01a639
+  md5: 5427b5dcb268bddf1a69c16d1cb77a47
+  depends:
+  - libgcc >=14
+  license: LGPL-2.1-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - alsa-lib >=1.2.16.1,<1.3.0a0
+  size: 621865
+  timestamp: 1781522013595
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ast-serialize-0.6.0-py310h8c58d24_0.conda
+  noarch: python
+  sha256: 91ac2556064043c532770fd54078645e517a822aaf9a97dd8a5141c7bf87a27a
+  md5: 9b34397f5c7da5a4ce1f0178302f461d
+  depends:
+  - python >=3.10
+  - libgcc >=14
+  - _python_abi3_support 1.*
+  - cpython >=3.10
+  constrains:
+  - __glibc >=2.17
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/ast-serialize?source=hash-mapping
+  run_exports: {}
+  size: 1093571
+  timestamp: 1782863867250
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/at-spi2-atk-2.38.0-h1f2db35_3.tar.bz2
+  sha256: c2c2c998d49c061e390537f929e77ce6b023ef22b51a0f55692d6df7327f3358
+  md5: 4ea9d4634f3b054549be5e414291801e
+  depends:
+  - at-spi2-core >=2.40.0,<2.41.0a0
+  - atk-1.0 >=2.36.0
+  - dbus >=1.13.6,<2.0a0
+  - libgcc-ng >=9.3.0
+  - libglib >=2.68.1,<3.0a0
+  license: LGPL-2.1-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - at-spi2-atk >=2.38.0,<3.0a0
+  size: 322172
+  timestamp: 1619123713021
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/at-spi2-core-2.40.3-h1f2db35_0.tar.bz2
+  sha256: cd48de9674a20133e70a643476accc1a63360c921ab49477638364877937a40d
+  md5: a12602a94ee402b57063ef74e82016c0
+  depends:
+  - dbus >=1.13.6,<2.0a0
+  - libgcc-ng >=9.3.0
+  - libglib >=2.68.3,<3.0a0
+  - xorg-libx11
+  - xorg-libxi
+  - xorg-libxtst
+  license: LGPL-2.1-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - at-spi2-core >=2.40.3,<2.41.0a0
+  size: 622407
+  timestamp: 1625848355776
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/atk-1.0-2.38.0-hedc4a1f_2.conda
+  sha256: 69f70048a1a915be7b8ad5d2cbb7bf020baa989b5506e45a676ef4ef5106c4f0
+  md5: 9308557e2328f944bd5809c5630761af
+  depends:
+  - libgcc-ng >=12
+  - libglib >=2.80.0,<3.0a0
+  - libstdcxx-ng >=12
+  constrains:
+  - atk-1.0 2.38.0
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - atk-1.0 >=2.38.0
+  size: 358327
+  timestamp: 1713898303194
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils-2.45.1-default_hf1166c9_102.conda
+  sha256: 63a1bec2fc966476bf7a387a20e8987edd5640d37a40ffb2f6e2217ef82b816b
+  md5: 3a238b9dcf59d03a379712f270867d80
+  depends:
+  - binutils_impl_linux-aarch64 >=2.45.1,<2.45.2.0a0
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 35511
+  timestamp: 1774197558632
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_impl_linux-aarch64-2.45.1-default_h5f4c503_102.conda
+  sha256: 7fd4ddde2f0150d015dfa9f2db5f428bd1570078f270e4bd4f116487a52de169
+  md5: 56a04d796d7e3cdc9f8d2e1278e91bff
+  depends:
+  - ld_impl_linux-aarch64 2.45.1 default_h1979696_102
+  - sysroot_linux-aarch64
+  - zstd >=1.5.7,<1.6.0a0
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 4683754
+  timestamp: 1774197535605
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/binutils_linux-aarch64-2.45.1-default_hf1166c9_102.conda
+  sha256: ad076ff5f3d7734c48ea241a99c16336c278081a5f7a523329d0d5956723c481
+  md5: 68d0661516aed9cab68d2ad6e287941f
+  depends:
+  - binutils_impl_linux-aarch64 2.45.1 default_h5f4c503_102
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 36267
+  timestamp: 1774197561368
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-1.2.0-hd651790_1.conda
+  sha256: 1fdee53dea5baa0b4d7ccd3bc0269e81017032c7cfe8843b6a0622eddf05714b
+  md5: 5c933384d588a06cd8dac78ca2864aab
+  depends:
+  - brotli-bin 1.2.0 he30d5cf_1
+  - libbrotlidec 1.2.0 he30d5cf_1
+  - libbrotlienc 1.2.0 he30d5cf_1
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlicommon >=1.2.0,<1.3.0a0
+    - libbrotlienc >=1.2.0,<1.3.0a0
+    - libbrotlidec >=1.2.0,<1.3.0a0
+  size: 20145
+  timestamp: 1764017310011
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-bin-1.2.0-he30d5cf_1.conda
+  sha256: cffd260d3b1527ff8c1d29f00e10f4e1d4bccbe4d5e605c23af68453cf78d32b
+  md5: b31f6f3a888c3f8f4c5a9dafc2575187
+  depends:
+  - libbrotlidec 1.2.0 he30d5cf_1
+  - libbrotlienc 1.2.0 he30d5cf_1
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 20758
+  timestamp: 1764017301339
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-python-1.2.0-py314h352cb57_1.conda
+  sha256: 5a5b0cdcd7ed89c6a8fb830924967f6314a2b71944bc1ebc2c105781ba97aa75
+  md5: a1b5c571a0923a205d663d8678df4792
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - libbrotlicommon 1.2.0 he30d5cf_1
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/brotli?source=hash-mapping
+  run_exports: {}
+  size: 373193
+  timestamp: 1764017486851
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda
+  sha256: b3495077889dde6bb370938e7db82be545c73e8589696ad0843a32221520ad4c
+  md5: 840d8fc0d7b3209be93080bc20e07f2d
+  depends:
+  - libgcc >=14
+  license: bzip2-1.0.6
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - bzip2 >=1.0.8,<2.0a0
+  size: 192412
+  timestamp: 1771350241232
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-ares-1.34.6-he30d5cf_0.conda
+  sha256: 7ec8a68efe479e2e298558cbc2e79d29430d5c7508254268818c0ae19b206519
+  md5: 1dfbec0d08f112103405756181304c16
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - c-ares >=1.34.6,<2.0a0
+  size: 217215
+  timestamp: 1765214743735
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/c-compiler-1.11.0-hdceaead_0.conda
+  sha256: a16c5078619d60e54f75336ed2bbb4ee0fb6f711de02dd364983748beda31e04
+  md5: 89bc32110bba0dc160bb69427e196dc4
+  depends:
+  - binutils
+  - gcc
+  - gcc_linux-aarch64 14.*
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 6721
+  timestamp: 1753098688332
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cairo-1.18.4-h0b6afd8_1.conda
+  sha256: 675db823f3d6fb6bf747fab3b0170ba99b269a07cf6df1e49fff2f9972be9cd1
+  md5: 043c13ed3a18396994be9b4fab6572ad
+  depends:
+  - fontconfig >=2.15.0,<3.0a0
+  - fonts-conda-ecosystem
+  - icu >=78.1,<79.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libgcc >=14
+  - libglib >=2.86.3,<3.0a0
+  - libpng >=1.6.53,<1.7.0a0
+  - libstdcxx >=14
+  - libxcb >=1.17.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - pixman >=0.46.4,<1.0a0
+  - xorg-libice >=1.1.2,<2.0a0
+  - xorg-libsm >=1.2.6,<2.0a0
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxrender >=0.9.12,<0.10.0a0
+  license: LGPL-2.1-only or MPL-1.1
+  purls: []
+  run_exports:
+    weak:
+    - cairo >=1.18.4,<2.0a0
+  size: 927045
+  timestamp: 1766416003626
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22-22.1.8-default_hd92691d_3.conda
+  sha256: 2b0cee92a84c8d157d6cadc3599b601f3e909a33a8450781057212f26d93c8a5
+  md5: 730fc9f5af147668306ebe1432291222
+  depends:
+  - compiler-rt22 ==22.1.8
+  - libclang-cpp22.1 ==22.1.8 default_h0cc847a_3
+  - libstdcxx >=14
+  - libgcc >=14
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 944069
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-22.1.8-default_cfg_hf729886_3.conda
+  sha256: d61879b24b9dcc8c45faa43508cff0ea3f6401a6b713db3c13b13fd4b4c829b8
+  md5: 063f01ed39ba27f696892cb34d58d06b
+  depends:
+  - clang-22 ==22.1.8 default_hd92691d_3
+  - llvm-openmp >=22.1.8
+  - clang_impl_linux-aarch64 ==22.1.8 default_h2e8b6a6_3
+  - binutils
+  - libgcc-devel_linux-aarch64
+  - sysroot_linux-aarch64
+  - libstdcxx >=14
+  - libgcc >=14
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 34194
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22-22.1.8-default_h2321676_3.conda
+  sha256: 75db664d3f2891c1d6c01fb3f5a8790121b54a69bf83c6aff262ac2202c37f28
+  md5: ee900b2d26bb733366fade99a7c6ae30
+  depends:
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - libclang13 >=22.1.8
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 80000
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22-22.1.8-default_ha537bf4_3.conda
+  sha256: ac0f65723b1235bd3126d5ba014d41dd96409df4fec370c2827f238f32ddec44
+  md5: fcaf38448e9b7f7e99759878e75bec04
+  depends:
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang13 >=22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 79999
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22.1.8-default_hb626d9f_3.conda
+  sha256: 8ef3a20ed699ac36b6ec9236913ecabe97c9403b9906f66c205ab568e42f2b3e
+  md5: 30523fcc32d3de51dfc3ccbed0eda04c
+  depends:
+  - clang ==22.1.8 default_cfg_hf729886_3
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - clang-format-22 ==22.1.8 default_ha537bf4_3
+  - libstdcxx >=14
+  - libgcc >=14
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang13 >=22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 36199
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-format-22.1.8-default_hceecdc4_3.conda
+  sha256: 2e0bb9f3de972c299920ed28575557539a4a35a2c662c0da52d30a7d7f77b7d3
+  md5: 539adc164b502d1717dceb8f03765a0e
+  depends:
+  - clang ==22.1.8 default_cfg_hf729886_3
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - clang-format-22 ==22.1.8 default_h2321676_3
+  - libstdcxx >=14
+  - libgcc >=14
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang13 >=22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 36171
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-scan-deps-22.1.8-default_hfec9229_3.conda
+  sha256: a3fd0bcd61679c14f529c5b7af2207820811bf541b1722b3581b59b53b6235a8
+  md5: e3190af742abc34f5e321bf6b7dc8b08
+  depends:
+  - libclang13 >=22.1.8
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 123971
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang-tools-22.1.8-default_h8cb1401_3.conda
+  sha256: 8cf064fc6e4d805c1bcd7181a9c130c79883786417f21e6021fb3d5c638bf3c4
+  md5: bdc8911049c49dbfcd4e9dc8d52c1eba
+  depends:
+  - clang-format ==22.1.8 default_hceecdc4_3
+  - libclang13 >=22.1.8
+  - clang-scan-deps ==22.1.8 default_hfec9229_3
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libstdcxx >=14
+  - libgcc >=14
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - libllvm22 >=22.1.8,<22.2.0a0
+  constrains:
+  - clangdev ==22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 12337025
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/clang_impl_linux-aarch64-22.1.8-default_h2e8b6a6_3.conda
+  sha256: 65235625f3a22ade61d835a4a6a420bb2c5ec08759c04dd49e268a34ef2ee739
+  md5: 36f3bd697b4e78832daf572d78473a94
+  depends:
+  - clang-22 ==22.1.8 default_hd92691d_3
+  - compiler-rt_linux-aarch64
+  - compiler-rt 22.1.8.*
+  - binutils_impl_linux-aarch64
+  - libgcc-devel_linux-aarch64
+  - sysroot_linux-aarch64
+  - libstdcxx >=14
+  - libgcc >=14
+  - zstd >=1.5.7,<1.6.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 34091
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cmake-4.3.4-hc9d863e_0.conda
+  sha256: a22fab476bf31ff0ec912c3bc04581d626be9899727f2f31e4ea500a778f1f4d
+  md5: 882a06b3db9675d9938f7e8819ab5de6
+  depends:
+  - bzip2 >=1.0.8,<2.0a0
+  - libcurl >=8.20.0,<9.0a0
+  - libexpat >=2.8.1,<3.0a0
+  - libgcc >=14
+  - liblzma >=5.8.3,<6.0a0
+  - libstdcxx >=14
+  - libuv >=1.52.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ncurses >=6.6,<7.0a0
+  - rhash >=1.4.6,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 22323951
+  timestamp: 1781779043508
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt-22.1.8-h8af1aa0_1.conda
+  sha256: d17a99acb650ff3103c9288a3dc9f2197cf19828d91134f9a8309c35bf73339e
+  md5: 557573bb4d894ae6fec576b20cf2025b
+  depends:
+  - compiler-rt22 22.1.8 hfefdfc9_1
+  - libcompiler-rt 22.1.8 hfefdfc9_1
+  constrains:
+  - clang 22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 16614
+  timestamp: 1781741084704
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/compiler-rt22-22.1.8-hfefdfc9_1.conda
+  sha256: 309c8fc29eafb61208feabad41eddac9ddaea2d1610fafee717583f4af7d26be
+  md5: 932b1f33722776fb1fa3aa2c79924abe
+  depends:
+  - compiler-rt22_linux-aarch64 22.1.8.*
+  - libgcc >=14
+  - libstdcxx >=14
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 115443
+  timestamp: 1781741083483
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-gcc-specs-14.3.0-hadff5d6_19.conda
+  sha256: 10c8b60befb95c62662821b381f4bb0fa9b7108bdff9bc0971043d5b7f88cda1
+  md5: a1123d27b812e311753af9b5987cf401
+  depends:
+  - gcc_impl_linux-aarch64 >=14.3.0,<14.3.1.0a0
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 31704
+  timestamp: 1778268711052
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/contourpy-1.3.3-py314ha0cc70f_4.conda
+  sha256: ce3575300f89e6d384cb28f44d11a52862087b3fbd82127300f3ec8b292a553d
+  md5: 015503b3e0c818f2e773665aacada937
+  depends:
+  - numpy >=1.25
+  - python
+  - libstdcxx >=14
+  - libgcc >=14
+  - python 3.14.* *_cp314
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/contourpy?source=hash-mapping
+  run_exports: {}
+  size: 342661
+  timestamp: 1769155977005
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.14.3-py310h3b5aacf_0.conda
+  sha256: 507d37215c5c5e190d4ffd72d5967ed23931806530a2088b1808a613ec7cfb43
+  md5: 00f4b3f6c00d70e259cad81bef33f551
+  depends:
+  - libgcc >=14
+  - python >=3.10,<3.11.0a0
+  - python_abi 3.10.* *_cp310
+  - tomli
+  license: Apache-2.0
+  license_family: APACHE
+  run_exports: {}
+  size: 319673
+  timestamp: 1782179255177
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.14.3-py314hb76de3f_0.conda
+  sha256: 45a28da74fefd3a20010f7bf4dd453dd9ab2001f3f9677d944515a19b56836d1
+  md5: a65f6993498c70892f008a3233d4cfab
+  depends:
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - tomli
+  license: Apache-2.0
+  license_family: APACHE
+  purls:
+  - pkg:pypi/coverage?source=compressed-mapping
+  run_exports: {}
+  size: 419692
+  timestamp: 1782179237581
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cxx-compiler-1.11.0-h7b35c40_0.conda
+  sha256: b87cd33501867d999caa1a57e488e69dc9e08011ec8685586df754302247a7a4
+  md5: 0234c63e6b36b1677fd6c5238ef0a4ec
+  depends:
+  - c-compiler 1.11.0 hdceaead_0
+  - gxx
+  - gxx_linux-aarch64 14.*
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 6705
+  timestamp: 1753098688728
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cyrus-sasl-2.1.28-h6598af7_1.conda
+  sha256: 0606296a3b0cc757229dd97db8c6dc0f77e54f975f89ae63c36fb01e2a2abe61
+  md5: f4fbf4001970e3e58984281a12c99969
+  depends:
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=13
+  - libntlm
+  - libstdcxx >=13
+  - libxcrypt >=4.4.36
+  - openssl >=3.5.5,<4.0a0
+  license: BSD-3-Clause-Attribution
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - cyrus-sasl >=2.1.28,<3.0a0
+  size: 224450
+  timestamp: 1771943147365
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda
+  sha256: 3af801577431af47c0b72a82bb93c654f03072dece0a2a6f92df8a6802f52a22
+  md5: a4b6b82427d15f0489cef0df2d82f926
+  depends:
+  - libstdcxx >=14
+  - libgcc >=14
+  - libglib >=2.86.2,<3.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - libexpat >=2.7.3,<3.0a0
+  license: AFL-2.1 OR GPL-2.0-or-later
+  purls: []
+  run_exports:
+    weak:
+    - dbus >=1.16.2,<2.0a0
+  size: 480416
+  timestamp: 1764536098891
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/double-conversion-3.4.0-hfae3067_0.conda
+  sha256: a636dfd17adc2a859cbdfce97e449e338b02a9f099c6dc0941c9f26bf448cca9
+  md5: 9fd794eaf983eabf975ead524540b4be
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - double-conversion >=3.4.0,<3.5.0a0
+  size: 71905
+  timestamp: 1765194538141
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/epoxy-1.5.10-he30d5cf_2.conda
+  sha256: aa562cdd72d2d15b0f2ee4565c8e34f18b52f7135a3f3b1ce727c202425c3bec
+  md5: 1c50e7c46ccefffe918ac974fa1a6752
+  depends:
+  - libdrm >=2.4.125,<2.5.0a0
+  - libegl >=1.7.0,<2.0a0
+  - libegl-devel
+  - libgcc >=14
+  - libgl >=1.7.0,<2.0a0
+  - libgl-devel
+  - libglx >=1.7.0,<2.0a0
+  - libglx-devel
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxdamage >=1.1.6,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxfixes >=6.0.1,<7.0a0
+  - xorg-libxxf86vm >=1.1.6,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - epoxy >=1.5.10,<1.6.0a0
+  size: 422103
+  timestamp: 1758743388115
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/fontconfig-2.18.1-hba86a56_0.conda
+  sha256: 2ccfd118269d363a5506161c4a0d96da46d2f01beecc74e0540a54b4737d0e45
+  md5: f4d29a0cd77104a683607319a542ac7e
+  depends:
+  - libexpat >=2.8.1,<3.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libgcc >=14
+  - libuuid >=2.42.1,<3.0a0
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - fontconfig >=2.18.1,<3.0a0
+    - fonts-conda-ecosystem
+  size: 290522
+  timestamp: 1780450108132
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/freetype-2.14.3-h8af1aa0_1.conda
+  sha256: 1112c56bc19cbce233b30d9d31ce8eb6fcc100c9baa5145315aaa1e3a25b5178
+  md5: 5e8e88bfb3fbb0df0f9f8bb890721e07
+  depends:
+  - libfreetype 2.14.3 h8af1aa0_1
+  - libfreetype6 2.14.3 hdae7a39_1
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports:
+    weak:
+    - libfreetype >=2.14.3
+    - libfreetype6 >=2.14.3
+  size: 174060
+  timestamp: 1780933507786
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/fribidi-1.0.16-he30d5cf_0.conda
+  sha256: 1bfcd715bcb49a0b22d5d1899a22c6ff884b06f8e141eb746f3949752469a422
+  md5: f3ac54914f7d3e1d68cb8d891765e5f9
+  depends:
+  - libgcc >=14
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - fribidi >=1.0.16,<2.0a0
+  size: 62909
+  timestamp: 1757438620177
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc-14.3.0-h2e72a27_19.conda
+  sha256: 438e0f5a198bc752db3c1693371c20ac50347f0dae56e95d15a6e86f79bb1980
+  md5: 72f889bb53eae093f7276b7ef1911cb2
+  depends:
+  - conda-gcc-specs
+  - gcc_impl_linux-aarch64 14.3.0 h398eab4_19
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 29621
+  timestamp: 1778268825860
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_impl_linux-aarch64-14.3.0-h398eab4_19.conda
+  sha256: 48ad41e482417ecb1b0c608139192ccb35ab09df195df69085b9b9378000287b
+  md5: ad45f72d96f497f6cdfc31c86534c47f
+  depends:
+  - binutils_impl_linux-aarch64 >=2.45
+  - libgcc >=14.3.0
+  - libgcc-devel_linux-aarch64 14.3.0 h25ba3ff_119
+  - libgomp >=14.3.0
+  - libsanitizer 14.3.0 hedb4206_19
+  - libstdcxx >=14.3.0
+  - libstdcxx-devel_linux-aarch64 14.3.0 h57c8d61_119
+  - sysroot_linux-aarch64
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 68567347
+  timestamp: 1778268606528
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gcc_linux-aarch64-14.3.0-h140ef2e_27.conda
+  sha256: 524e287b7c1b3e53bc6ba830968c05bc60437cf0a4778c56a2d09235e357517b
+  md5: 877c135e8aada3eef4aef0bea9102c13
+  depends:
+  - gcc_impl_linux-aarch64 14.3.0.*
+  - binutils_linux-aarch64
+  - sysroot_linux-aarch64
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    strong:
+    - libgcc >=14
+  size: 29091
+  timestamp: 1781279944723
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gdk-pixbuf-2.44.7-h90308e0_0.conda
+  sha256: f406e0b58a51da8648b100316c7b5893e5585256b67eb410126e2357a901f0d2
+  md5: 6b26b46bbc0761e0f256699eab75202d
+  depends:
+  - libgcc >=14
+  - libglib >=2.88.2,<3.0a0
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  license: LGPL-2.1-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gdk-pixbuf >=2.44.7,<3.0a0
+  size: 588681
+  timestamp: 1782593151876
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/glib-tools-2.88.2-h7aeb4f4_0.conda
+  sha256: cbb0679fccff1b87253d24a8aee96bf3908f16c4a1a828c35578ed8e8d516a61
+  md5: c7195d7c970b8bdca5d6b5f6adb66886
+  depends:
+  - libglib ==2.88.2 h96a7f82_0
+  - libffi
+  - libgcc >=14
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports: {}
+  size: 260096
+  timestamp: 1782464048865
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/graphite2-1.3.15-hfae3067_0.conda
+  sha256: 3e529c517a76a1f4497c51eeedeeb927d33f732dcdb48055a020a83eb3e4e95c
+  md5: 4db044857ab1d09b2e8f0013c65387c1
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - graphite2 >=1.3.15,<2.0a0
+  size: 103119
+  timestamp: 1780455096710
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/graphviz-14.1.2-h45e821f_0.conda
+  sha256: 0ac1a90696a3250febdb1d63a3161b9aad5dc136e602f7f17df4894bd153162c
+  md5: 60c3b65c5e60fc70e1b9f0de4d0c2247
+  depends:
+  - adwaita-icon-theme
+  - cairo >=1.18.4,<2.0a0
+  - fonts-conda-ecosystem
+  - gdk-pixbuf >=2.44.4,<3.0a0
+  - gtk3 >=3.24.43,<4.0a0
+  - gts >=0.7.6,<0.8.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libgcc >=14
+  - libgd >=2.3.3,<2.4.0a0
+  - libglib >=2.86.3,<3.0a0
+  - librsvg >=2.60.0,<3.0a0
+  - libstdcxx >=14
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - pango >=1.56.4,<2.0a0
+  license: EPL-1.0
+  license_family: Other
+  purls: []
+  run_exports:
+    weak:
+    - graphviz >=14.1.2,<15.0a0
+  size: 2578234
+  timestamp: 1769427141106
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gtk3-3.24.52-h75d4e7a_0.conda
+  sha256: 5db1347513253a2d200b111717eb452d4b95e9380db48b6dd2c8bb7bb256d754
+  md5: f6a9ed300bcf3217da7f1955f57facec
+  depends:
+  - at-spi2-atk >=2.38.0,<3.0a0
+  - atk-1.0 >=2.38.0
+  - cairo >=1.18.4,<2.0a0
+  - epoxy >=1.5.10,<1.6.0a0
+  - fontconfig >=2.17.1,<3.0a0
+  - fonts-conda-ecosystem
+  - fribidi >=1.0.16,<2.0a0
+  - gdk-pixbuf >=2.44.5,<3.0a0
+  - glib-tools
+  - harfbuzz >=13.2.1
+  - hicolor-icon-theme
+  - libcups >=2.3.3,<2.4.0a0
+  - libcups >=2.3.3,<3.0a0
+  - libexpat >=2.7.4,<3.0a0
+  - libfreetype >=2.14.2
+  - libfreetype6 >=2.14.2
+  - libgcc >=14
+  - libglib >=2.86.4,<3.0a0
+  - liblzma >=5.8.2,<6.0a0
+  - libxkbcommon >=1.13.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - pango >=1.56.4,<2.0a0
+  - wayland >=1.25.0,<2.0a0
+  - xorg-libx11 >=1.8.13,<2.0a0
+  - xorg-libxcomposite >=0.4.7,<1.0a0
+  - xorg-libxcursor >=1.2.3,<2.0a0
+  - xorg-libxdamage >=1.1.6,<2.0a0
+  - xorg-libxext >=1.3.7,<2.0a0
+  - xorg-libxfixes >=6.0.2,<7.0a0
+  - xorg-libxi >=1.8.2,<2.0a0
+  - xorg-libxinerama >=1.1.6,<1.2.0a0
+  - xorg-libxrandr >=1.5.5,<2.0a0
+  - xorg-libxrender >=0.9.12,<0.10.0a0
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gtk3 >=3.24.52,<4.0a0
+    - adwaita-icon-theme
+  size: 6023698
+  timestamp: 1774296668544
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gts-0.7.6-he293c15_4.conda
+  sha256: 1e9cc30d1c746d5a3399a279f5f642a953f37d9f9c82fd4d55b301e9c2a23f7c
+  md5: 2aeaeddbd89e84b60165463225814cfc
+  depends:
+  - libgcc-ng >=12
+  - libglib >=2.76.3,<3.0a0
+  - libstdcxx-ng >=12
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gts >=0.7.6,<0.8.0a0
+  size: 332673
+  timestamp: 1686545222091
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx-14.3.0-ha28f942_7.conda
+  sha256: 7f38940a42d43bf7b969625686b64a11d52348d899d4487ed50673a09e7faece
+  md5: dac1f319c6157797289c174d062f87a1
+  depends:
+  - gcc 14.3.0.*
+  - gxx_impl_linux-aarch64 14.3.0.*
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 30526
+  timestamp: 1759967828504
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_impl_linux-aarch64-14.3.0-h0d4f5d4_19.conda
+  sha256: d83ab2a25d52a2f564c9692aae1ef876a66ca2815f9997812df6babcf37d9e6e
+  md5: e0761ef9f08505f6d1544ab0e202c764
+  depends:
+  - gcc_impl_linux-aarch64 14.3.0 h398eab4_19
+  - libstdcxx-devel_linux-aarch64 14.3.0 h57c8d61_119
+  - sysroot_linux-aarch64
+  - tzdata
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 13722799
+  timestamp: 1778268804579
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/gxx_linux-aarch64-14.3.0-h0da240b_27.conda
+  sha256: 07df85f4ba8a199afb300fc1239aa72d6d425f4a258d4414102caff800ea8093
+  md5: c8776dadbd23bb98b6863b0860047a35
+  depends:
+  - gxx_impl_linux-aarch64 14.3.0.*
+  - gcc_linux-aarch64 ==14.3.0 h140ef2e_27
+  - binutils_linux-aarch64
+  - sysroot_linux-aarch64
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    strong:
+    - libstdcxx >=14
+    - libgcc >=14
+  size: 27646
+  timestamp: 1781279944723
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/harfbuzz-14.2.1-h8af1aa0_1.conda
+  sha256: 57b157674ecee4d16e2873a3624095b4ed1859ce8c574b161e0d9c1723788733
+  md5: 41198d1dd71d97c1507e6bd17edd10c7
+  depends:
+  - libharfbuzz-devel 14.2.1 h3a99ef3_1
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libharfbuzz >=14.2.1
+  size: 11079
+  timestamp: 1782800518091
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/hicolor-icon-theme-0.17-h8af1aa0_3.conda
+  sha256: 9f7fa161b33de5f001dc43f9d6399ba45b3fb1efb141ee2fec6bf05a48420d63
+  md5: af62915a9e4154e16d97f99c64cec14e
+  license: GPL-2.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 17670
+  timestamp: 1771540496764
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-78.3-hcab7f73_0.conda
+  sha256: 49ba6aed2c6b482bb0ba41078057555d29764299bc947b990708617712ef6406
+  md5: 546da38c2fa9efacf203e2ad3f987c59
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - icu >=78.3,<79.0a0
+  size: 12837286
+  timestamp: 1773822650615
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/keyutils-1.6.3-h86ecc28_0.conda
+  sha256: 5ce830ca274b67de11a7075430a72020c1fb7d486161a82839be15c2b84e9988
+  md5: e7df0aab10b9cbb73ab2a467ebfaf8c7
+  depends:
+  - libgcc >=13
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - keyutils >=1.6.3,<2.0a0
+  size: 129048
+  timestamp: 1754906002667
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/kiwisolver-1.5.0-py314h4702e76_0.conda
+  sha256: 06e4be177958444f4f047380656611cbc467e36d1e3318add141397ce4cc24ef
+  md5: cae18ed89f7f6dc0adc0aafe4c47bf3d
+  depends:
+  - python
+  - libstdcxx >=14
+  - libgcc >=14
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/kiwisolver?source=hash-mapping
+  run_exports: {}
+  size: 83264
+  timestamp: 1773067330528
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.22.2-h2fb54aa_1.conda
+  sha256: b644718416a22b5d57c1194ea7207b7f8d33d6a2b42775763782d76cd7457aea
+  md5: 5fd2304064ef6199d1f91ec60ee7b820
+  depends:
+  - keyutils >=1.6.3,<2.0a0
+  - libedit >=3.1.20250104,<3.2.0a0
+  - libedit >=3.1.20250104,<4.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - openssl >=3.5.7,<4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - krb5 >=1.22.2,<1.23.0a0
+  size: 1518484
+  timestamp: 1781859412954
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lcms2-2.19.1-h9d5b58d_1.conda
+  sha256: ed213207bbf11663181941e0931caa9ce748f0544688e8e0fbcf330bca279389
+  md5: 9183fda4be2b4ee5760cdb8e540439c8
+  depends:
+  - libgcc >=14
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - lcms2 >=2.19.1,<3.0a0
+  size: 296564
+  timestamp: 1780211834883
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda
+  sha256: 7abd913d81a9bf00abb699e8987966baa2065f5132e37e815f92d90fc6bba530
+  md5: a21644fc4a83da26452a718dc9468d5f
+  depends:
+  - zstd >=1.5.7,<1.6.0a0
+  constrains:
+  - binutils_impl_linux-aarch64 2.45.1
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 875596
+  timestamp: 1774197520746
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lerc-4.1.0-h52b7260_0.conda
+  sha256: 8957fd460c1c132c8031f65fd5f56ec3807fd71b7cab2c5e2b0937b13404ab36
+  md5: d13423b06447113a90b5b1366d4da171
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - lerc >=4.1.0,<5.0a0
+  size: 240444
+  timestamp: 1773114901155
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20250512.1-cxx17_h201e9ed_0.conda
+  sha256: 28bb0a5f3177bb3b45a89d309b93bef65645671d1c97ae7bbcfa74481bf33f3c
+  md5: 4db30fe7ba05e2ce66595ed646064861
+  depends:
+  - libgcc >=13
+  - libstdcxx >=13
+  constrains:
+  - abseil-cpp =20250512.1
+  - libabseil-static =20250512.1=cxx17*
+  license: Apache-2.0
+  license_family: Apache
+  run_exports:
+    weak:
+    - libabseil >=20250512.1,<20250513.0a0
+    - libabseil =*=cxx17*
+  size: 1327580
+  timestamp: 1750194149128
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libabseil-20260107.1-cxx17_h6983b43_0.conda
+  sha256: 37675140819e10235a8ff342cb09f688f843ac390b64856d8e230700bbd7d5aa
+  md5: 2a19160c13e688710dd200812fc9a6d3
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  constrains:
+  - abseil-cpp =20260107.1
+  - libabseil-static =20260107.1=cxx17*
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libabseil >=20260107.1,<20260108.0a0
+    - libabseil =*=cxx17*
+  size: 1401836
+  timestamp: 1770863223557
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libblas-3.11.0-8_haddc8a3_openblas.conda
+  build_number: 8
+  sha256: c897399c943168c646f659952f73a9154f9122d7e9b151649dbe075dfdcd484b
+  md5: 8b44dad125760faa2b3925f5a6e3112d
+  depends:
+  - libopenblas >=0.3.33,<0.3.34.0a0
+  - libopenblas >=0.3.33,<1.0a0
+  constrains:
+  - libcblas   3.11.0   8*_openblas
+  - liblapack  3.11.0   8*_openblas
+  - mkl <2027
+  - blas 2.308   openblas
+  - liblapacke 3.11.0   8*_openblas
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libblas >=3.11.0,<4.0a0
+  size: 18843
+  timestamp: 1779859042591
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlicommon-1.2.0-he30d5cf_1.conda
+  sha256: 5fa8c163c8d776503aa68cdaf798ff9440c76a0a1c3ea84e0c43dbf1ece8af4d
+  md5: 8ec1d03f3000108899d1799d9964f281
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlicommon >=1.2.0,<1.3.0a0
+  size: 80030
+  timestamp: 1764017273715
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlidec-1.2.0-he30d5cf_1.conda
+  sha256: 494365e8f58799ea95a6e82334ef696e9c2120aecd6626121694b30a15033301
+  md5: 47e5b71b77bb8b47b4ecf9659492977f
+  depends:
+  - libbrotlicommon 1.2.0 he30d5cf_1
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlidec >=1.2.0,<1.3.0a0
+  size: 33166
+  timestamp: 1764017282936
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libbrotlienc-1.2.0-he30d5cf_1.conda
+  sha256: f998c03257b9aa1f7464446af2cf424862f0e54258a2a588309853e45ae771df
+  md5: 6553a5d017fe14859ea8a4e6ea5def8f
+  depends:
+  - libbrotlicommon 1.2.0 he30d5cf_1
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlienc >=1.2.0,<1.3.0a0
+  size: 309304
+  timestamp: 1764017292044
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcblas-3.11.0-8_hd72aa62_openblas.conda
+  build_number: 8
+  sha256: 3ba039f0705022939d90e36c1ed2fcbafd7f5bb77563e3702202ae796b32f4d2
+  md5: 76242b7ad6e43809afa8671dd609b4ed
+  depends:
+  - libblas 3.11.0 8_haddc8a3_openblas
+  constrains:
+  - liblapack  3.11.0   8*_openblas
+  - liblapacke 3.11.0   8*_openblas
+  - blas 2.308   openblas
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libcblas >=3.11.0,<4.0a0
+  size: 18817
+  timestamp: 1779859049133
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang-cpp22.1-22.1.8-default_h0cc847a_3.conda
+  sha256: 16ff2afd00acf94320dcfacc7124bbb67ae542d48e5c5ac74627e8690df10dfa
+  md5: 483b80c996ae6e15317459ebd71d7033
+  depends:
+  - libstdcxx >=14
+  - libgcc >=14
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  size: 24213552
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libclang13-22.1.8-default_hd92691d_3.conda
+  sha256: ef4c63c93751dd2582c4f72d9558faaec68eb26d149406373d5af8e509008c48
+  md5: baa5eb601eacb3cc438aad5b343d9b61
+  depends:
+  - libclang-cpp22.1 ==22.1.8 default_h0cc847a_3
+  - libstdcxx >=14
+  - libgcc >=14
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libclang13 >=22.1.8
+  size: 14311328
+  timestamp: 1782358853037
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcompiler-rt-22.1.8-hfefdfc9_1.conda
+  sha256: d3d6ed65bf42d820278d3dd77645c9544e668bda72bdddc6cf86394f1734470c
+  md5: e179a04425da273f15aa9ebd3929fcce
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  constrains:
+  - compiler-rt >=9.0.1
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libcompiler-rt >=22.1.8
+  size: 7483837
+  timestamp: 1781741072573
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcups-2.3.3-h4f2b762_6.conda
+  sha256: 41b04f995c9f63af8c4065a35931e46cbc2fdd6b9bf7e4c19f90d53cbb2bc8e5
+  md5: 67828c963b17db7dc989fe5d509ef04a
+  depends:
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.1,<2.0a0
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libcups >=2.3.3,<2.4.0a0
+  size: 4553739
+  timestamp: 1770903929794
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libcurl-8.21.0-h7c59cd8_2.conda
+  sha256: 5846fa724f4b8eb23751e347fc8b31775c0a28a7a34d1e44f081651613470512
+  md5: 0a187db240c503afc7eb5bd865c7ff04
+  depends:
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=14
+  - libnghttp2 >=1.68.1,<2.0a0
+  - libpsl >=0.22.0,<0.23.0a0
+  - libssh2 >=1.11.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - openssl >=3.5.7,<4.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: curl
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libcurl >=8.21.0,<9.0a0
+  size: 505957
+  timestamp: 1782911738398
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdate-3.0.4-h5ad3122_0.conda
+  sha256: fdc9f24b76861fe4b96614ada10ca2fe6c66652dab28b6b2e3cd333e16294589
+  md5: 8bc9249730d8919442c076dbe14058de
+  depends:
+  - libgcc >=13
+  - libstdcxx >=13
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 43504
+  timestamp: 1748470075874
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdeflate-1.25-h1af38f5_0.conda
+  sha256: 48814b73bd462da6eed2e697e30c060ae16af21e9fbed30d64feaf0aad9da392
+  md5: a9138815598fe6b91a1d6782ca657b0c
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libdeflate >=1.25,<1.26.0a0
+  size: 71117
+  timestamp: 1761979776756
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libdrm-2.4.127-he30d5cf_0.conda
+  sha256: 2a941ffcd6b09380344c2cb5b198d2743ce4fc30ec9a5c8c83e53368d8015aef
+  md5: 987d35ad350bb552a30f3d314f6c7655
+  depends:
+  - libgcc >=14
+  - libpciaccess >=0.19,<0.20.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libdrm >=2.4.127,<2.5.0a0
+  size: 345283
+  timestamp: 1778975814771
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libedit-3.1.20250104-pl5321h976ea20_0.conda
+  sha256: c0b27546aa3a23d47919226b3a1635fccdb4f24b94e72e206a751b33f46fd8d6
+  md5: fb640d776fc92b682a14e001980825b1
+  depends:
+  - ncurses
+  - libgcc >=13
+  - ncurses >=6.5,<7.0a0
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libedit >=3.1.20250104,<3.2.0a0
+  size: 148125
+  timestamp: 1738479808948
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libegl-1.7.0-hd24410f_3.conda
+  sha256: b987d3874edfcd9c7ddca86c003cb04ae51160a72c173a24cd46ab9eeb8886ab
+  md5: ec017f25e5d01ef9dd81e95ff73ff051
+  depends:
+  - libglvnd 1.7.0 hd24410f_3
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 54600
+  timestamp: 1779728234591
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libegl-devel-1.7.0-hd24410f_3.conda
+  sha256: 2b5ae66aa91215e915df3c520fed85a17231a067339b54f0594d93689b684c86
+  md5: 8ebac3af4a69a9a41c16442a65bf3ac4
+  depends:
+  - libegl 1.7.0 hd24410f_3
+  - libgl-devel 1.7.0 hd24410f_3
+  - xorg-libx11
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports:
+    weak:
+    - libegl >=1.7.0,<2.0a0
+  size: 31552
+  timestamp: 1779728260736
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libev-4.33-h31becfc_2.conda
+  sha256: 973af77e297f1955dd1f69c2cbdc5ab9dfc88388a5576cd152cda178af0fd006
+  md5: a9a13cb143bbaa477b1ebaefbe47a302
+  depends:
+  - libgcc-ng >=12
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libev >=4.33,<4.34.0a0
+  size: 115123
+  timestamp: 1702146237623
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.1-hfae3067_1.conda
+  sha256: 20a5726bc8705d91437c9e6ef83b30da64a1719b869656d20a1ee818333ea5ac
+  md5: fac3b65a605cd253037fdf3daf2de8d9
+  depends:
+  - libgcc >=14
+  constrains:
+  - expat 2.8.1.*
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 77649
+  timestamp: 1781203572523
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda
+  sha256: 3df4c539449aabc3443bbe8c492c01d401eea894603087fca2917aa4e1c2dea9
+  md5: 2f364feefb6a7c00423e80dcb12db62a
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libffi >=3.5.2,<3.6.0a0
+  size: 55952
+  timestamp: 1769456078358
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype-2.14.3-h8af1aa0_1.conda
+  sha256: db75d0fc080992dc67db8e24d7bb2a2f2a0b25bfce8870fa45a82a4b5f6111a2
+  md5: a13e600f9d18488b1fd1257344dbfdaa
+  depends:
+  - libfreetype6 >=2.14.3
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports: {}
+  size: 8381
+  timestamp: 1780933505754
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libfreetype6-2.14.3-hdae7a39_1.conda
+  sha256: 34fe8276befd6c42956c4acd969caeddbdc7ea8e6ed054b8388709b6c3e94ba4
+  md5: 426cc33f8745ce11a73baf73db3954a7
+  depends:
+  - libgcc >=14
+  - libpng >=1.6.58,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - freetype >=2.14.3
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports: {}
+  size: 424236
+  timestamp: 1780933505195
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_19.conda
+  sha256: 4592b096e553f67799ae70d4b6167eeda3ec74587d68c7aecbf4e7b1df136681
+  md5: f35b3f52d0a2ec4ffe3c89ba135cdb9a
+  depends:
+  - _openmp_mutex >=4.5
+  constrains:
+  - libgomp 15.2.0 h8acb6b2_19
+  - libgcc-ng ==15.2.0=*_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 622462
+  timestamp: 1778268755949
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_19.conda
+  sha256: 1137f93f477f56199ded24117430045a0c02cbe8b10031beac3b9ad2138539d3
+  md5: 770cf892e5530f43e63cadc673e85653
+  depends:
+  - libgcc 15.2.0 h8acb6b2_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports:
+    strong:
+    - libgcc
+  size: 27738
+  timestamp: 1778268759211
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgd-2.3.3-h88aa843_12.conda
+  sha256: 8b7dfd29a8ce42d28c47a06dcaa7c21f6dad751b72d2352668d680b6ec951630
+  md5: b4c9083a19a45047173f380624c7e5f3
+  depends:
+  - fontconfig >=2.15.0,<3.0a0
+  - fonts-conda-ecosystem
+  - icu >=78.1,<79.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libgcc >=14
+  - libjpeg-turbo >=3.1.2,<4.0a0
+  - libpng >=1.6.53,<1.7.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  license: GD
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libgd >=2.3.3,<2.4.0a0
+  size: 195554
+  timestamp: 1766331786625
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran-15.2.0-he9431aa_19.conda
+  sha256: e5ad94be72634233510b33ba792a3339921bd468f0b8bc6961ea05eded251d9b
+  md5: c7a5b5decf969ead5ecada83654164cf
+  depends:
+  - libgfortran5 15.2.0 h1b7bec0_19
+  constrains:
+  - libgfortran-ng ==15.2.0=*_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 27728
+  timestamp: 1778268784621
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgfortran5-15.2.0-h1b7bec0_19.conda
+  sha256: af8e9bdcaa77f133a8ee4c1ef57ef564d9c45aa262abf9f5ef9b50eb99d96407
+  md5: 779dbb494de6d3d6477cab52eb34285a
+  depends:
+  - libgcc >=15.2.0
+  constrains:
+  - libgfortran 15.2.0
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 1487244
+  timestamp: 1778268767295
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-1.7.0-hd24410f_3.conda
+  sha256: 05c75a2034bdbca29bab467d02ad770ed5e524e4f0670432258f2d8487c95348
+  md5: 6e893c36f31502dd195d3d58f455fdbd
+  depends:
+  - libglvnd 1.7.0 hd24410f_3
+  - libglx 1.7.0 hd24410f_3
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 148112
+  timestamp: 1779728248678
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgl-devel-1.7.0-hd24410f_3.conda
+  sha256: b7483884e5e8df362f113d7d7694f0a37ecf6409f1acaaa889f312688917c067
+  md5: 3a0adce33b3b8a52c76389db1edfec1b
+  depends:
+  - libgl 1.7.0 hd24410f_3
+  - libglx-devel 1.7.0 hd24410f_3
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports:
+    weak:
+    - libgl >=1.7.0,<2.0a0
+  size: 116084
+  timestamp: 1779728257534
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.88.2-h96a7f82_0.conda
+  sha256: 6a13152a81513117b8d41bf64dea56c731d877bcced5a24fab738e3c0f9ac58c
+  md5: 31d404d8c0755d0f9062a4459f5a1084
+  depends:
+  - libgcc >=14
+  - libffi >=3.5.2,<3.6.0a0
+  - pcre2 >=10.47,<10.48.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - libiconv >=1.18,<2.0a0
+  constrains:
+  - glib >2.66
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libglib >=2.88.2,<3.0a0
+  size: 4943441
+  timestamp: 1782464048865
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglvnd-1.7.0-hd24410f_3.conda
+  sha256: ca124e53765a2b123e0ca6ce809c7caf188bb26e5fe125b69099378276d5e66f
+  md5: a2ad848c0aab2e326c6af08ea20502f4
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 146645
+  timestamp: 1779728228274
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-1.7.0-hd24410f_3.conda
+  sha256: 2698b415b9f7b692cd64e34db623e1a6e54ed54e78b0b4e5d4ea6762791e9118
+  md5: 338faf34b78d053841098c0528699e34
+  depends:
+  - libglvnd 1.7.0 hd24410f_3
+  - xorg-libx11 >=1.8.13,<2.0a0
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 76704
+  timestamp: 1779728242753
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libglx-devel-1.7.0-hd24410f_3.conda
+  sha256: b30433c4f56bec0a7d9d288e0a456ed280183e32f3f4880ada2189fc12804a52
+  md5: 3da9719866b95bddcad86c8aec6a8ba2
+  depends:
+  - libglx 1.7.0 hd24410f_3
+  - xorg-libx11 >=1.8.13,<2.0a0
+  - xorg-xorgproto
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports:
+    weak:
+    - libglx >=1.7.0,<2.0a0
+  size: 27651
+  timestamp: 1779728252006
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_19.conda
+  sha256: 2370ef0ffcbae5bede3c4bf136add4abc257245eb91f724c99bb4a43116c5a83
+  md5: c5e8a379c4a2ec2aea4ba22758c001d9
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports:
+    strong:
+    - _openmp_mutex >=4.5
+  size: 587387
+  timestamp: 1778268674393
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libharfbuzz-14.2.1-h3a99ef3_1.conda
+  sha256: ae1d16dd62f626c4dab1240a49f6b04e14e4f30140e5fb26bb835821dba114b6
+  md5: 655cedd9626545089b9e9ead153cf619
+  depends:
+  - cairo >=1.18.4,<2.0a0
+  - graphite2 >=1.3.15,<2.0a0
+  - icu >=78.3,<79.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libgcc >=14
+  - libglib >=2.88.2,<3.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - libstdcxx >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 1334601
+  timestamp: 1782800489368
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libharfbuzz-devel-14.2.1-h3a99ef3_1.conda
+  sha256: 866b0132df7d080a7b2e3c44e4c79723f007db6c035b1e751612d29db698859b
+  md5: b6762f2c0386ba4606d5b2cba1e41ca8
+  depends:
+  - cairo >=1.18.4,<2.0a0
+  - freetype
+  - graphite2 >=1.3.15,<2.0a0
+  - icu >=78.3,<79.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libgcc >=14
+  - libglib >=2.88.2,<3.0a0
+  - libharfbuzz 14.2.1 h3a99ef3_1
+  - libpng >=1.6.58,<1.7.0a0
+  - libstdcxx >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libharfbuzz >=14.2.1
+  size: 2050496
+  timestamp: 1782800511879
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libiconv-1.18-h90929bb_2.conda
+  sha256: 1473451cd282b48d24515795a595801c9b65b567fe399d7e12d50b2d6cdb04d9
+  md5: 5a86bf847b9b926f3a4f203339748d78
+  depends:
+  - libgcc >=14
+  license: LGPL-2.1-only
+  purls: []
+  run_exports:
+    weak:
+    - libiconv >=1.18,<2.0a0
+  size: 791226
+  timestamp: 1754910975665
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libjpeg-turbo-3.1.4.1-he30d5cf_0.conda
+  sha256: e97ec2af5f09f8f6ea8ecd550055c95ae80fae22015fcfadaa94eafe025c9ccc
+  md5: a85ba48648f6868016f2741fd9170250
+  depends:
+  - libgcc >=14
+  constrains:
+  - jpeg <0.0.0a
+  license: IJG AND BSD-3-Clause AND Zlib
+  purls: []
+  run_exports:
+    weak:
+    - libjpeg-turbo >=3.1.4.1,<4.0a0
+  size: 693143
+  timestamp: 1775962625956
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblapack-3.11.0-8_h88aeb00_openblas.conda
+  build_number: 8
+  sha256: d269a684afa0b2fdb44d6b60167f854f30410cdb5ee49a7275c026f6b10c8d05
+  md5: 3af3f2aa755abc5e91351114ae214f55
+  depends:
+  - libblas 3.11.0 8_haddc8a3_openblas
+  constrains:
+  - libcblas   3.11.0   8*_openblas
+  - liblapacke 3.11.0   8*_openblas
+  - blas 2.308   openblas
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - liblapack >=3.11.0,<3.12.0a0
+  size: 18828
+  timestamp: 1779859055749
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libllvm22-22.1.8-hfd2ba90_1.conda
+  sha256: dc943f1730a27f5fb36682c9852f7196f671c3a9df4a0a7a8f7ba665637c9151
+  md5: 6fc7875f99e39c80dca8fcdc60e6559e
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - libzlib >=1.3.2,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libllvm22 >=22.1.8,<22.2.0a0
+  size: 43302008
+  timestamp: 1781785783993
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda
+  sha256: d61962b9cd54c3554361550203c64d5b65b71e3058a285b66e4b04b9769f0a5c
+  md5: 76298a9e6d71ee6e832a8d0d7373b261
+  depends:
+  - libgcc >=14
+  constrains:
+  - xz 5.8.3.*
+  license: 0BSD
+  purls: []
+  run_exports:
+    weak:
+    - liblzma >=5.8.3,<6.0a0
+  size: 126102
+  timestamp: 1775828008518
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmagic-5.48-h1abf092_1.conda
+  sha256: 2c4b8e2449a0a93d71818785da4b00e8a7e86d7db559fd711a424947507e8c6f
+  md5: 0ca3ce44f5dcb86ea55dce3b811993b1
+  depends:
+  - libgcc >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: BSD-2-Clause-Darwin
+  run_exports:
+    weak:
+    - libmagic >=5.48,<6.0a0
+  size: 483742
+  timestamp: 1781763255220
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda
+  sha256: 57c0dd12d506e84541c4e877898bd2a59cca141df493d34036f18b2751e0a453
+  md5: 7b9813e885482e3ccb1fa212b86d7fd0
+  depends:
+  - libgcc >=14
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 114056
+  timestamp: 1769482343003
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnghttp2-1.68.1-hd3077d7_0.conda
+  sha256: 13782715b9eeebc4ad16d36e84ca569d1495e3516aea3fe546a32caa0a597d82
+  md5: be5f0f007a4500a226ef001115535a3d
+  depends:
+  - c-ares >=1.34.6,<2.0a0
+  - libev >=4.33,<4.34.0a0
+  - libev >=4.33,<5.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.1,<2.0a0
+  - openssl >=3.5.5,<4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libnghttp2 >=1.68.1,<2.0a0
+  size: 726928
+  timestamp: 1773854039807
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libnsl-2.0.1-h86ecc28_1.conda
+  sha256: c0dc4d84198e3eef1f37321299e48e2754ca83fd12e6284754e3cb231357c3a5
+  md5: d5d58b2dc3e57073fe22303f5fed4db7
+  depends:
+  - libgcc >=13
+  license: LGPL-2.1-only
+  license_family: GPL
+  run_exports:
+    weak:
+    - libnsl >=2.0.1,<2.1.0a0
+  size: 34831
+  timestamp: 1750274211000
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libntlm-1.4-hf897c2e_1002.tar.bz2
+  sha256: 0e303d7a8845391bd1634efb65dc9d9b82b5608ebeb32fb77a56d1ed696d2eee
+  md5: 835c7c4137821de5c309f4266a51ba89
+  depends:
+  - libgcc-ng >=9.3.0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports: {}
+  size: 39449
+  timestamp: 1609781865660
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopenblas-0.3.33-pthreads_h9d3fd7e_0.conda
+  sha256: b018ecfb05e75a8eea3f21f6b5c5c2a54b5178bdcf19e2e2df2735740214a8c8
+  md5: 58a66cd95e9692f08abe89f55a6f3f12
+  depends:
+  - libgcc >=14
+  - libgfortran
+  - libgfortran5 >=14.3.0
+  constrains:
+  - openblas >=0.3.33,<0.3.34.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libopenblas >=0.3.33,<1.0a0
+  size: 5121336
+  timestamp: 1776993423004
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libopengl-1.7.0-hd24410f_3.conda
+  sha256: 9b964590b23c0a0357850653e09ab0d3f840ac5d0068ff927a61b5f00d6dbf65
+  md5: 86958137ec1885e2da78804996c99d5f
+  depends:
+  - libglvnd 1.7.0 hd24410f_3
+  license: LicenseRef-libglvnd
+  purls: []
+  run_exports: {}
+  size: 58759
+  timestamp: 1779728245599
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpciaccess-0.19-he30d5cf_0.conda
+  sha256: 5d26d751b7cc4b66e28ed1ae75900956600aaa5c5d874d5a8cf106d3aff834d3
+  md5: 462239e256bc180c9c45dd049ba797ee
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libpciaccess >=0.19,<0.20.0a0
+  size: 30294
+  timestamp: 1773533057559
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpng-1.6.58-h1abf092_0.conda
+  sha256: 483eaa53da40a6a3e558709d9f7b1ca388735364ae21a1ba58cf942514649c92
+  md5: f51503ac45a4888bce71af9027a2ecc9
+  depends:
+  - libgcc >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: zlib-acknowledgement
+  purls: []
+  run_exports:
+    weak:
+    - libpng >=1.6.58,<1.7.0a0
+  size: 341202
+  timestamp: 1776315188425
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpq-18.4-hccacd55_1.conda
+  sha256: 8badce81df7b86fde16ad28dea9d5d65ebe318d6eb48865d10fbd4bd296cd152
+  md5: aa592f45ebe4bb5a4dd228fdf006b617
+  depends:
+  - icu >=78.3,<79.0a0
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=14
+  - openldap >=2.6.13,<2.7.0a0
+  - openssl >=3.5.7,<4.0a0
+  license: PostgreSQL
+  purls: []
+  run_exports:
+    weak:
+    - libpq >=18.4,<19.0a0
+  size: 2911832
+  timestamp: 1782580350945
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.31.1-h61c7711_5.conda
+  sha256: 08f0fd616f4482963e27e0cd7fd0d1913f33a153d3d97028beb8bc2892ff30a7
+  md5: ce4282bd8d1af8a2c70d4d05223b89f7
+  depends:
+  - libabseil * cxx17*
+  - libabseil >=20250512.1,<20250513.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports:
+    weak:
+    - libprotobuf >=6.31.1,<6.31.2.0a0
+  size: 3897821
+  timestamp: 1780003417336
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libprotobuf-6.33.5-h306233d_1.conda
+  sha256: 6a2ccd92be6a7e0256c6eeb2e61328a72d40004f08923733274ca2129dc7f70d
+  md5: 97b7927d982dfc20f8f49ce5174d7466
+  depends:
+  - libabseil * cxx17*
+  - libabseil >=20260107.1,<20260108.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libprotobuf >=6.33.5,<6.33.6.0a0
+  size: 3502676
+  timestamp: 1780003320814
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libpsl-0.22.0-h504d594_0.conda
+  sha256: 8871c428d0c97a75806dec9aee508fe93ce137a3a081866d9c752e5c0f83b091
+  md5: 93b1727d5d61b9d70163dfcf5d9aafb9
+  depends:
+  - icu >=78.3,<79.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libpsl >=0.22.0,<0.23.0a0
+  size: 84305
+  timestamp: 1782394815323
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libraqm-0.10.5-hd2f8911_1.conda
+  sha256: b287b67ba86d625bdaae919bac0a62ca6f5bc61509f034003df3c6b40f584a92
+  md5: bf7fa2b700ba2c7b682aec5db14043c7
+  depends:
+  - libgcc >=14
+  - __glibc >=2.28,<3.0.a0
+  - fribidi >=1.0.16,<2.0a0
+  - libharfbuzz >=14.2.1
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libraqm >=0.10.5,<0.11.0a0
+  size: 29528
+  timestamp: 1782807084739
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/librsvg-2.62.3-hf685517_0.conda
+  sha256: c95ac70755863d8522c1115b54afca86148ea25366b616aa84c993c2ca54b9ce
+  md5: 38209cc04b3e3e5624c534bc703e6939
+  depends:
+  - cairo >=1.18.4,<2.0a0
+  - fontconfig >=2.18.0,<3.0a0
+  - fonts-conda-ecosystem
+  - gdk-pixbuf >=2.44.6,<3.0a0
+  - harfbuzz >=14.2.0
+  - libgcc >=14
+  - libglib >=2.88.1,<3.0a0
+  - libxml2-16 >=2.14.6
+  - pango >=1.56.4,<2.0a0
+  constrains:
+  - __glibc >=2.17
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - librsvg >=2.62.3,<3.0a0
+  size: 3052373
+  timestamp: 1780456154830
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsanitizer-14.3.0-hedb4206_19.conda
+  sha256: d5bfc6472141488dccf7addade6e85574497a0cb3fe8ee10efb308eeffcea874
+  md5: dde53e47246d01641cc9093aa9a66681
+  depends:
+  - libgcc >=14.3.0
+  - libstdcxx >=14.3.0
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports:
+    weak:
+    - libsanitizer 14.3.0
+  size: 7199495
+  timestamp: 1778268550110
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h022381a_0.conda
+  sha256: 26ccc8affb892f2fe7da77beced5232b877f2c5af68ce26c2286eebbf063c096
+  md5: 0c469d05c6cc2977d75020dd2d29aa42
+  depends:
+  - libgcc >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: blessing
+  run_exports:
+    weak:
+    - libsqlite >=3.53.3,<4.0a0
+  size: 963901
+  timestamp: 1782519046518
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.3-h10b116e_0.conda
+  sha256: a835400072fb638fb582ee9fc2271169da84cbcad664d28b852610201116027e
+  md5: 2cd50877f494b34383af22560ced8b04
+  depends:
+  - icu >=78.3,<79.0a0
+  - libgcc >=14
+  - libzlib >=1.3.2,<2.0a0
+  license: blessing
+  purls: []
+  run_exports:
+    weak:
+    - libsqlite >=3.53.3,<4.0a0
+  size: 968420
+  timestamp: 1782519054102
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libssh2-1.11.1-h18c354c_0.conda
+  sha256: 1e289bcce4ee6a5817a19c66e296f3c644dcfa6e562e5c1cba807270798814e7
+  md5: eecc495bcfdd9da8058969656f916cc2
+  depends:
+  - libgcc >=13
+  - libzlib >=1.3.1,<2.0a0
+  - openssl >=3.5.0,<4.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libssh2 >=1.11.1,<2.0a0
+  size: 311396
+  timestamp: 1745609845915
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_19.conda
+  sha256: 1dadc45e599f510dd5f97141dddcdbb9844d9f1430c1f3a38075cf1c58f87b4e
+  md5: 543fbc8d71f2a0baf04cf88ce96cb8bb
+  depends:
+  - libgcc 15.2.0 h8acb6b2_19
+  constrains:
+  - libstdcxx-ng ==15.2.0=*_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 5546559
+  timestamp: 1778268777463
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hdbbeba8_19.conda
+  sha256: 56b5ec297a988961486694f1c598889c3a697d77a0b42b8cea3faaa12e9bd360
+  md5: c82ed61c3ec470c5ec624580e6ba16e4
+  depends:
+  - libstdcxx 15.2.0 hef695bb_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports:
+    strong:
+    - libstdcxx
+  size: 27803
+  timestamp: 1778268813278
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libtiff-4.7.1-hdb009f0_1.conda
+  sha256: 7ff79470db39e803e21b8185bc8f19c460666d5557b1378d1b1e857d929c6b39
+  md5: 8c6fd84f9c87ac00636007c6131e457d
+  depends:
+  - lerc >=4.0.0,<5.0a0
+  - libdeflate >=1.25,<1.26.0a0
+  - libgcc >=14
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - liblzma >=5.8.1,<6.0a0
+  - libstdcxx >=14
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: HPND
+  purls: []
+  run_exports:
+    weak:
+    - libtiff >=4.7.1,<4.8.0a0
+  size: 488407
+  timestamp: 1762022048105
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42.2-h1022ec0_0.conda
+  sha256: 7663489f97c104ae3814db10f384932c74b439f3c1fd4247e4fe3599830c090a
+  md5: 58fa42bc4bc71fc329889497ec15effb
+  depends:
+  - libgcc >=14
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libuuid >=2.42.2,<3.0a0
+  size: 43248
+  timestamp: 1781625528371
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libuv-1.52.1-h80f16a2_0.conda
+  sha256: 3e2ead35f47d01364031f323f1be984018c8f19a3a264f952ddcd043685a1c86
+  md5: ac7bcbd2c77691cd6d1ede8c029e8c8a
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libuv >=1.52.1,<2.0a0
+  size: 456627
+  timestamp: 1779396031450
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libvulkan-loader-1.4.341.0-h8b8848b_0.conda
+  sha256: 92a92589f4f787201bc5091990001f61515fa794fa4f0fb15f0ca50f3cc330cc
+  md5: 06bb91a87fb97ea09398d2e121e00c39
+  depends:
+  - libstdcxx >=14
+  - libgcc >=14
+  - xorg-libxrandr >=1.5.5,<2.0a0
+  - xorg-libx11 >=1.8.12,<2.0a0
+  constrains:
+  - libvulkan-headers 1.4.341.0.*
+  license: Apache-2.0
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libvulkan-loader >=1.4.341.0,<2.0a0
+  size: 217655
+  timestamp: 1770077141862
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libwebp-base-1.6.0-ha2e29f5_0.conda
+  sha256: b03700a1f741554e8e5712f9b06dd67e76f5301292958cd3cb1ac8c6fdd9ed25
+  md5: 24e92d0942c799db387f5c9d7b81f1af
+  depends:
+  - libgcc >=14
+  constrains:
+  - libwebp 1.6.0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libwebp-base >=1.6.0,<2.0a0
+  size: 359496
+  timestamp: 1752160685488
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcb-1.17.0-h262b8f6_0.conda
+  sha256: 461cab3d5650ac6db73a367de5c8eca50363966e862dcf60181d693236b1ae7b
+  md5: cd14ee5cca2464a425b1dbfc24d90db2
+  depends:
+  - libgcc >=13
+  - pthread-stubs
+  - xorg-libxau >=1.0.11,<2.0a0
+  - xorg-libxdmcp
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxcb >=1.17.0,<2.0a0
+  size: 397493
+  timestamp: 1727280745441
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxcrypt-4.4.36-h31becfc_1.conda
+  sha256: 6b46c397644091b8a26a3048636d10b989b1bf266d4be5e9474bf763f828f41f
+  md5: b4df5d7d4b63579d081fd3a4cf99740e
+  depends:
+  - libgcc-ng >=12
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libxcrypt >=4.4.36
+  size: 114269
+  timestamp: 1702724369203
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxkbcommon-1.13.2-h3c6a4c8_0.conda
+  sha256: 8f44670a714a12589bc82ea179e46ba4a19c4458d5cee765ddd4d5224eccd912
+  md5: d6fc9ac66ea61eb662747959d0a68c57
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  - libxcb >=1.17.0,<2.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - xkeyboard-config
+  - xorg-libxau >=1.0.12,<2.0a0
+  license: MIT/X11 Derivative
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxkbcommon >=1.13.2,<2.0a0
+  size: 875994
+  timestamp: 1780213408784
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h064b767_0.conda
+  sha256: 96e9bd642c013ce3407c23b3819204ea8a591567d62b49baa4bafb2f1487326c
+  md5: 876c5457664559cdc67c4ac71e2945cb
+  depends:
+  - libgcc >=14
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - icu <0.0a0
+  - libxml2 2.15.3
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 601420
+  timestamp: 1776376789358
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h79dcc73_0.conda
+  sha256: ad048a9ca1bf2cdfedb2b0c231050da416c44ee1436a3d1a83b51d2e2deaa842
+  md5: 68866231cfe8789e780347f2482df96d
+  depends:
+  - icu >=78.3,<79.0a0
+  - libgcc >=14
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - libxml2 2.15.3
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 601948
+  timestamp: 1776376758674
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h869d058_0.conda
+  sha256: e3af6af9df73bd3c7a8e4e6c8cc38df3699e7f588b0705c257a8601e40acfbdf
+  md5: 2cffef27cb2eb9ed1e315a1e269d4335
+  depends:
+  - icu >=78.3,<79.0a0
+  - libgcc >=14
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libxml2-16 2.15.3 h79dcc73_0
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxml2
+    - libxml2-16 >=2.15.3
+  size: 48101
+  timestamp: 1776376766341
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h9ba8346_0.conda
+  sha256: 74aa3c62e0ec4491343b95ce4ca8812ad2f9bb015369e29cb3b4b9b4302d8cb0
+  md5: 15078261d03e3c3c83a42df605f7f34a
+  depends:
+  - libgcc >=14
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libxml2-16 2.15.3 h064b767_0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - icu <0.0a0
+  license: MIT
+  license_family: MIT
+  run_exports:
+    weak:
+    - libxml2
+    - libxml2-16 >=2.15.3
+  size: 48311
+  timestamp: 1776376798296
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libxslt-1.1.43-h6700d25_1.conda
+  sha256: 8a816572a4650149d28c0b8b44e294380de18787735d00c7cf5fad91dba8e286
+  md5: 0f31501ccd51a40f0a91381080ae7368
+  depends:
+  - libgcc >=14
+  - libxml2
+  - libxml2-16 >=2.14.6
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxslt >=1.1.43,<2.0a0
+  size: 253367
+  timestamp: 1757964660396
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda
+  sha256: eb111e32e5a7313a5bf799c7fb2419051fa2fe7eff74769fac8d5a448b309f7f
+  md5: 502006882cf5461adced436e410046d1
+  constrains:
+  - zlib 1.3.2 *_2
+  license: Zlib
+  license_family: Other
+  purls: []
+  run_exports:
+    weak:
+    - libzlib >=1.3.2,<2.0a0
+  size: 69833
+  timestamp: 1774072605429
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/llvm-openmp-22.1.8-he40846f_0.conda
+  sha256: 30bbb0ce4ae7cebbeb9801af5bbd2a29f8627237a38d08fc5d8d800e79c817aa
+  md5: 2107bb80c5587c116702ce215daddd73
+  constrains:
+  - openmp 22.1.8|22.1.8.*
+  - intel-openmp <0.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    strong:
+    - llvm-openmp >=22.1.8
+    - _openmp_mutex >=4.5
+    - _openmp_mutex * *_llvm
+  size: 5888931
+  timestamp: 1781736538044
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/lychee-0.24.2-hb434046_0.conda
+  sha256: 4f90402af8073c427a2f3171b0133d2c3a7c463746771a085a1a2c65d9527cb6
+  md5: 784313c4c7e7a5999437e7cd93983bbd
+  depends:
+  - libgcc >=14
+  - openssl >=3.5.6,<4.0a0
+  constrains:
+  - __glibc >=2.17
+  license: Apache-2.0 OR MIT
+  run_exports: {}
+  size: 5632958
+  timestamp: 1777662747675
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/make-4.4.1-h2a6d0cb_2.conda
+  sha256: d243aea768e6fa360b7eda598340f43d2a41c9fc169d9f97f505410be68815f8
+  md5: 5983ffb12d09efc45c4a3b74cd890137
+  depends:
+  - libgcc >=13
+  license: GPL-3.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 528318
+  timestamp: 1727801707353
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py314hb76de3f_1.conda
+  sha256: 383c188496d13a55658c06e61e7d4cdff2c9f9d5a0648769fca8250bece7e0ef
+  md5: e5de3c36dd548b35ff2a8aa49208dcb3
+  depends:
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - jinja2 >=3.0.0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/markupsafe?source=hash-mapping
+  run_exports: {}
+  size: 27913
+  timestamp: 1772446407659
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/matplotlib-3.11.0-py314ha42fa4b_1.conda
+  sha256: ad593122795468a83fe01d3ce831faea26e34be6ae3a6c3a0702ccd4194d2dfd
+  md5: 80af8d8643a2e2f5bf47ecd15a2c30a5
+  depends:
+  - matplotlib-base >=3.11.0,<3.11.1.0a0
+  - pyside6 >=6.7.2
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - tornado >=5
+  license: PSF-2.0
+  license_family: PSF
+  purls: []
+  run_exports: {}
+  size: 14957
+  timestamp: 1782829505062
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/matplotlib-base-3.11.0-py314h99b9003_1.conda
+  sha256: 56696ee8bc7dcc4ad5f6c39bdc51c4248f256943c1f8bd2cf5cefcecb77fedf6
+  md5: 4055d95e01cd2e79b66f9d7ed1213ede
+  depends:
+  - contourpy >=1.0.1
+  - cycler >=0.10
+  - fonttools >=4.22.0
+  - freetype
+  - kiwisolver >=1.3.1
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libgcc >=14
+  - libraqm >=0.10.5,<0.11.0a0
+  - libstdcxx >=14
+  - numpy >=1.23
+  - numpy >=1.25,<3
+  - packaging >=20.0
+  - pillow >=8
+  - pyparsing >=2.3.1
+  - python >=3.14,<3.15.0a0
+  - python-dateutil >=2.7
+  - python_abi 3.14.* *_cp314
+  - qhull >=2020.2,<2020.3.0a0
+  - tk >=8.6.13,<8.7.0a0
+  license: PSF-2.0
+  license_family: PSF
+  purls:
+  - pkg:pypi/matplotlib?source=hash-mapping
+  run_exports: {}
+  size: 8911500
+  timestamp: 1782829487715
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ml_dtypes-0.5.4-np2py310h230c07e_1.conda
+  sha256: 4d98653d64ab5c7bab38d477b9e61b7cfadbb69855d7c38e58e55cfd6c59f213
+  md5: 6e071b418e5aa7a63af23a30488fb5cd
+  depends:
+  - python
+  - libstdcxx >=14
+  - libgcc >=14
+  - python 3.10.* *_cpython
+  - numpy >=1.21,<3
+  - python_abi 3.10.* *_cp310
+  license: MPL-2.0 AND Apache-2.0
+  run_exports: {}
+  size: 305019
+  timestamp: 1771362546563
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ml_dtypes-0.5.4-np2py314h175d3ba_1.conda
+  sha256: ede0c956654caf013153069a7ee1e9ce604326714882e6fc1a91be19c5819d84
+  md5: bf8467d8b9b5f67baac7d302fd120501
+  depends:
+  - python
+  - libgcc >=14
+  - libstdcxx >=14
+  - python 3.14.* *_cp314
+  - numpy >=1.23,<3
+  - python_abi 3.14.* *_cp314
+  license: MPL-2.0 AND Apache-2.0
+  purls:
+  - pkg:pypi/ml-dtypes?source=hash-mapping
+  run_exports: {}
+  size: 306998
+  timestamp: 1771362449472
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-2.1.0-py310hec1369a_0.conda
+  sha256: 7d76172b47e1218a043f0d62b3aeb0570beec7a2ce2fe11e2fa2bf4c5bef2919
+  md5: b60e9fa92e322ec90abaf893da586704
+  depends:
+  - ast-serialize >=0.3.0,<1.0.0
+  - mypy_extensions >=1.0.0
+  - pathspec >=1.0.0
+  - python
+  - python-librt >=0.11.0
+  - typing_extensions >=4.6.0
+  - psutil >=4.0
+  - tomli >=1.1.0
+  - libgcc >=14
+  - python_abi 3.10.* *_cp310
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 19823619
+  timestamp: 1780315611372
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-2.1.0-py314h42c854d_0.conda
+  sha256: 69923adfa48018b337e0385bc04faafc6266a50e12f294caef1d5d5f058126a3
+  md5: 85961c6f32c342f6b93bf5232d00d5cc
+  depends:
+  - ast-serialize >=0.3.0,<1.0.0
+  - mypy_extensions >=1.0.0
+  - pathspec >=1.0.0
+  - python
+  - python-librt >=0.11.0
+  - typing_extensions >=4.6.0
+  - psutil >=4.0
+  - libgcc >=14
+  - python_abi 3.14.* *_cp314
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/mypy?source=hash-mapping
+  run_exports: {}
+  size: 21522141
+  timestamp: 1780315613814
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda
+  sha256: 369db85c5cd8d99dde364ce70725d76511d9c8199e5b820c740414091bf5bcca
+  md5: b2a43456aa56fe80c2477a5094899eff
+  depends:
+  - libgcc >=14
+  license: X11 AND BSD-3-Clause
+  purls: []
+  run_exports:
+    weak:
+    - ncurses >=6.6,<7.0a0
+  size: 960036
+  timestamp: 1777422174534
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ninja-1.13.2-hdc560ac_0.conda
+  sha256: 45fbc7c8c44681f5cefba1e5b26ca504a4485b000c5dfaa31cec0b7bc78d0de4
+  md5: 8b5222a41b5d51fb1a5a2c514e770218
+  depends:
+  - libstdcxx >=14
+  - libgcc >=14
+  license: Apache-2.0
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 182666
+  timestamp: 1763688214250
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/nodejs-24.18.0-h7ca28ff_0.conda
+  sha256: 14623b9283bde379b47d55c2f4ee8cc893ee3c1bd02935e7b6316dc7619246a5
+  md5: 4bf9f6d6278e66ef52215e1a95758264
+  depends:
+  - __glibc >=2.28,<3.0.a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libbrotlicommon >=1.2.0,<1.3.0a0
+  - libbrotlienc >=1.2.0,<1.3.0a0
+  - libbrotlidec >=1.2.0,<1.3.0a0
+  - c-ares >=1.34.6,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - libuv >=1.52.1,<2.0a0
+  - icu >=78.3,<79.0a0
+  - openssl >=3.5.7,<4.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libnghttp2 >=1.68.1,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - nodejs >=24.18.0,<25.0a0
+  size: 23515320
+  timestamp: 1782396049457
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-1.23.2-py310he617cf3_0.tar.bz2
+  sha256: 916db7ec40176f385869e48aa1d5089c3d3b6fbf7c31adfacda395fd6527ca4f
+  md5: 104da96e7cf9a5d781c680d4c8d1d526
+  depends:
+  - libblas >=3.9.0,<4.0a0
+  - libcblas >=3.9.0,<4.0a0
+  - libgcc-ng >=12
+  - liblapack >=3.9.0,<4.0a0
+  - libstdcxx-ng >=12
+  - python >=3.10,<3.11.0a0
+  - python >=3.10,<3.11.0a0 *_cpython
+  - python_abi 3.10.* *_cp310
+  constrains:
+  - numpy-base <0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports:
+    weak:
+    - numpy >=1.23.2,<2.0a0
+  size: 6923528
+  timestamp: 1660673457360
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/numpy-2.5.0-py314he1698a1_0.conda
+  sha256: 8677e6bd3a1a95f8ecf2b0f1ca39f30f55b1aa0865b217bb3cb55b29d3e092fa
+  md5: 10165160938f6498096bda3e0ff051ac
+  depends:
+  - python
+  - libstdcxx >=14
+  - libgcc >=14
+  - libcblas >=3.9.0,<4.0a0
+  - libblas >=3.9.0,<4.0a0
+  - python_abi 3.14.* *_cp314
+  - liblapack >=3.9.0,<4.0a0
+  constrains:
+  - numpy-base <0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/numpy?source=hash-mapping
+  run_exports:
+    weak:
+    - numpy >=1.25,<3
+  size: 8158865
+  timestamp: 1782112546539
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.26.0-py310h9bc1938_0_cpu.conda
+  sha256: 094bfff4b15c2cee4ad125382d1757982e4d05b61dc55cb667ee41c90e9e002a
+  md5: 150bc2c81c292eedb6146293bf5f27f2
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  - numpy >=1.21,<3
+  - packaging
+  - protobuf
+  - python >=3.10,<3.11.0a0
+  - python >=3.10,<3.11.0a0 *_cpython
+  - python-flatbuffers
+  - python_abi 3.10.* *_cp310
+  license: MIT AND BSL-1.0
+  run_exports: {}
+  size: 13540523
+  timestamp: 1778968935324
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/onnxruntime-1.26.0-py314ha1c0044_0_cpu.conda
+  sha256: 5a901fc191342a2968ed38641895a83522cbac06e61484157c1a6e35c02c2b5c
+  md5: 6a3528cce9c4192465a13dda33732780
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  - numpy >=1.23,<3
+  - packaging
+  - protobuf
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python-flatbuffers
+  - python_abi 3.14.* *_cp314
+  license: MIT AND BSL-1.0
+  purls:
+  - pkg:pypi/onnxruntime?source=hash-mapping
+  run_exports: {}
+  size: 14094116
+  timestamp: 1778967440104
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openjpeg-2.5.4-h5da879a_0.conda
+  sha256: bd1bc8bdde5e6c5cbac42d462b939694e40b59be6d0698f668515908640c77b8
+  md5: cea962410e327262346d48d01f05936c
+  depends:
+  - libgcc >=14
+  - libpng >=1.6.50,<1.7.0a0
+  - libstdcxx >=14
+  - libtiff >=4.7.1,<4.8.0a0
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - openjpeg >=2.5.4,<3.0a0
+  size: 392636
+  timestamp: 1758489353577
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openldap-2.6.13-h2fb54aa_0.conda
+  sha256: 08fab1d144a9790763f30bd44ac4a2f288703ad668d8c31d339ddea23e981147
+  md5: 67eea19865a3463f75ca0d3a1d096350
+  depends:
+  - cyrus-sasl >=2.1.28,<3.0a0
+  - krb5 >=1.22.2,<1.23.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - openssl >=3.5.6,<4.0a0
+  license: OLDAP-2.8
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - openldap >=2.6.13,<2.7.0a0
+  size: 911524
+  timestamp: 1775741371965
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.3-h546c87b_0.conda
+  sha256: da4a5df42614166b69c2f6d8602fc1425f7aaa699f77c3bafb5c7fe69b3d9fb7
+  md5: fa6260b3e6eababf6ca85a7eb3336383
+  depends:
+  - ca-certificates
+  - libgcc >=14
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - openssl >=3.6.3,<4.0a0
+  size: 3704664
+  timestamp: 1781069675555
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pango-1.56.4-h8547ced_1.conda
+  sha256: d209c8b0d53c441ee0bc0d8fce0fcae8e7e05755e51b13b6b9da02c7aa032f98
+  md5: 3fc7cc25bba3381e77b753578058e3b0
+  depends:
+  - cairo >=1.18.4,<2.0a0
+  - fontconfig >=2.17.1,<3.0a0
+  - fonts-conda-ecosystem
+  - fribidi >=1.0.16,<2.0a0
+  - harfbuzz >=13.2.0
+  - libexpat >=2.7.4,<3.0a0
+  - libfreetype >=2.14.2
+  - libfreetype6 >=2.14.2
+  - libgcc >=14
+  - libglib >=2.86.4,<3.0a0
+  - libpng >=1.6.55,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - pango >=1.56.4,<2.0a0
+  size: 470441
+  timestamp: 1774284032397
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pcre2-10.47-hf841c20_0.conda
+  sha256: 04df2cee95feba440387f33f878e9f655521e69f4be33a0cd637f07d3d81f0f9
+  md5: 1a30c42e32ca0ea216bd0bfe6f842f0b
+  depends:
+  - bzip2 >=1.0.8,<2.0a0
+  - libgcc >=14
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - pcre2 >=10.47,<10.48.0a0
+  size: 1166552
+  timestamp: 1763655534263
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pillow-11.3.0-py310h35255db_3.conda
+  sha256: 52f19d1974609647190ee185b09920c0ca08f8d3ba1df4683804493c5536c2d4
+  md5: 99fa02e3e8fe0e22b1e902f579be02ba
+  depends:
+  - python
+  - libgcc >=14
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libwebp-base >=1.6.0,<2.0a0
+  - libxcb >=1.17.0,<2.0a0
+  - python_abi 3.10.* *_cp310
+  - libzlib >=1.3.1,<2.0a0
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - lcms2 >=2.17,<3.0a0
+  - libtiff >=4.7.0,<4.8.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - openjpeg >=2.5.3,<3.0a0
+  license: HPND
+  run_exports: {}
+  size: 858243
+  timestamp: 1758208960707
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pillow-11.3.0-py314h033a589_3.conda
+  sha256: d5f5eed511d87279a00103c9a0c16c9a3a9938f2b939e333e0355977f7c2999c
+  md5: 194f398f88cf0aff78dcef8ccc717eea
+  depends:
+  - python
+  - libgcc >=14
+  - libwebp-base >=1.6.0,<2.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libtiff >=4.7.0,<4.8.0a0
+  - python_abi 3.14.* *_cp314
+  - libxcb >=1.17.0,<2.0a0
+  - openjpeg >=2.5.3,<3.0a0
+  - lcms2 >=2.17,<3.0a0
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - tk >=8.6.13,<8.7.0a0
+  license: HPND
+  purls:
+  - pkg:pypi/pillow?source=hash-mapping
+  run_exports: {}
+  size: 1045843
+  timestamp: 1758208909932
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pixman-0.46.4-h7ac5ae9_1.conda
+  sha256: e6b0846a998f2263629cfeac7bca73565c35af13251969f45d385db537a514e4
+  md5: 1587081d537bd4ae77d1c0635d465ba5
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - pixman >=0.46.4,<1.0a0
+  size: 357913
+  timestamp: 1754665583353
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prek-0.4.6-h069e38c_0.conda
+  sha256: c8cc778fb81968f33006f68b728d5c0ce06f06fa4c5cf38e65f4fd5b01850214
+  md5: 3b69e2b672838c34ebb3412e039d8ff0
+  depends:
+  - libgcc >=14
+  constrains:
+  - __glibc >=2.17
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 5973762
+  timestamp: 1782881502144
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/prettier-3.9.3-h70496c1_0.conda
+  sha256: c55bdee7f0fc9c965df90c74a0fd7f3a88965e6b6fe4d16c8392928acfc20e4a
+  md5: 81c7aec37580cb95baa4be2c36dc4793
+  depends:
+  - nodejs
+  - nodejs >=24.18.0,<25.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 1372615
+  timestamp: 1782740656817
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-6.31.1-py310h71259a2_2.conda
+  sha256: 9d39997a981812baa1b134ddeee633b33a5519845484579808d5ccc5b0efb5d7
+  md5: 445f25cc8856ef0b7250357e547dd438
+  depends:
+  - libabseil * cxx17*
+  - libabseil >=20250512.1,<20250513.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.1,<2.0a0
+  - python >=3.10,<3.11.0a0
+  - python >=3.10,<3.11.0a0 *_cpython
+  - python_abi 3.10.* *_cp310
+  constrains:
+  - libprotobuf 6.31.1
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 415894
+  timestamp: 1760393426131
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/protobuf-6.33.5-py314hb844caf_2.conda
+  sha256: 2b039350aa8955ddf820ed5ed5424a6853a61beccb224fb2763949beff027832
+  md5: 5f020653948ac980e90be85186df6c87
+  depends:
+  - libabseil * cxx17*
+  - libabseil >=20260107.1,<20260108.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  - libzlib >=1.3.1,<2.0a0
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - libprotobuf 6.33.5
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/protobuf?source=hash-mapping
+  run_exports: {}
+  size: 501138
+  timestamp: 1773266040567
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.2.2-py310hef25091_0.conda
+  sha256: c66b0f7f0e4fdc3b5b7c138246426a4a6b32af3a71bef2605264d488fabc4c45
+  md5: 4f824cd2641bdafd0865edd5a85300d2
+  depends:
+  - python
+  - python 3.10.* *_cpython
+  - libgcc >=14
+  - python_abi 3.10.* *_cp310
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 183737
+  timestamp: 1769678160656
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.2.2-py314h2e8dab5_0.conda
+  sha256: ebef2c2e8f84d6d02baf3317d0c1c7c737f2f0bc8f28a8a2a2f8e606b3dc5514
+  md5: 4d45bdf8795717e336bfa2c6e0e7847d
+  depends:
+  - python
+  - python 3.14.* *_cp314
+  - libgcc >=14
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/psutil?source=hash-mapping
+  run_exports: {}
+  size: 236068
+  timestamp: 1769678155154
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pthread-stubs-0.4-h86ecc28_1002.conda
+  sha256: 977dfb0cb3935d748521dd80262fe7169ab82920afd38ed14b7fee2ea5ec01ba
+  md5: bb5a90c93e3bac3d5690acf76b4a6386
+  depends:
+  - libgcc >=13
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 8342
+  timestamp: 1726803319942
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pyside6-6.11.1-py314ha37eecc_1.conda
+  sha256: 773bb42e09bfe13469b3d1db0dd79821146131210bec9eb1b69e761d0b5e9c26
+  md5: 48e83c1e5552d2bf7f5c8d7d8bd9fc85
+  depends:
+  - python
+  - qt6-main 6.11.1.*
+  - libgcc >=14
+  - libstdcxx >=14
+  - libopengl >=1.7.0,<2.0a0
+  - libxslt >=1.1.43,<2.0a0
+  - libvulkan-loader >=1.4.341.0,<2.0a0
+  - python_abi 3.14.* *_cp314
+  - libegl >=1.7.0,<2.0a0
+  - qt6-main >=6.11.1,<6.12.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - libgl >=1.7.0,<2.0a0
+  - libclang13 >=22.1.5
+  license: LGPL-3.0-only
+  license_family: LGPL
+  purls:
+  - pkg:pypi/pyside6?source=hash-mapping
+  - pkg:pypi/shiboken6?source=hash-mapping
+  run_exports: {}
+  size: 12361659
+  timestamp: 1778933881635
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.10.20-h4f76b5d_1_cpython.conda
+  build_number: 1
+  sha256: 3fcdb0e63dbc797856d843a7bd14687780c3b6d08d616ff0e48bede3deb7e55c
+  md5: c95d6c422c558a87f1ebfd482e965273
+  depends:
+  - bzip2 >=1.0.8,<2.0a0
+  - ld_impl_linux-aarch64 >=2.36.1
+  - libexpat >=2.8.1,<3.0a0
+  - libffi >=3.4,<4.0a0
+  - libgcc >=14
+  - liblzma >=5.8.3,<6.0a0
+  - libnsl >=2.0.1,<2.1.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libuuid >=2.42.1,<3.0a0
+  - libxcrypt >=4.4.36
+  - libzlib >=1.3.2,<2.0a0
+  - ncurses >=6.6,<7.0a0
+  - openssl >=3.5.7,<4.0a0
+  - readline >=8.3,<9.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - tzdata
+  constrains:
+  - python_abi 3.10.* *_cp310
+  license: Python-2.0
+  run_exports:
+    weak:
+    - python_abi 3.10.* *_cp310
+    noarch:
+    - python
+  size: 13263044
+  timestamp: 1781148396487
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.6-hc679e19_100_cp314.conda
+  build_number: 100
+  sha256: dd56fd95db3cb49a69fbe41df80afc8bd5214daa829bcd3930de80f0408ba5eb
+  md5: 416c74941d13d9f2b9e68b1a900f7f50
+  depends:
+  - bzip2 >=1.0.8,<2.0a0
+  - ld_impl_linux-aarch64 >=2.36.1
+  - libexpat >=2.8.1,<3.0a0
+  - libffi >=3.5.2,<3.6.0a0
+  - libgcc >=14
+  - liblzma >=5.8.3,<6.0a0
+  - libmpdec >=4.0.0,<5.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libuuid >=2.42.1,<3.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ncurses >=6.6,<7.0a0
+  - openssl >=3.5.7,<4.0a0
+  - python_abi 3.14.* *_cp314
+  - readline >=8.3,<9.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - tzdata
+  - zstd >=1.5.7,<1.6.0a0
+  license: Python-2.0
+  purls: []
+  run_exports:
+    weak:
+    - python_abi 3.14.* *_cp314
+    noarch:
+    - python
+  size: 34900936
+  timestamp: 1781254861576
+  python_site_packages_path: lib/python3.14/site-packages
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-librt-0.12.0-py310hef25091_0.conda
+  sha256: 36f6a7b471888fd76620b72bc64882b0080ba7dd26d7c08edb8970fe0ef3181b
+  md5: ac732047358972cd794ce24e29280553
+  depends:
+  - python
+  - python 3.10.* *_cpython
+  - libgcc >=14
+  - python_abi 3.10.* *_cp310
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 161075
+  timestamp: 1782847519296
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/python-librt-0.12.0-py314h2e8dab5_0.conda
+  sha256: bbec45b0ccfddbc4eb8aa25db2157fdb97dfe87dd743f5bbd21b221eeb127f86
+  md5: 7b4a9f250e65c79877b39824a41151a9
+  depends:
+  - python
+  - libgcc >=14
+  - python 3.14.* *_cp314
+  - python_abi 3.14.* *_cp314
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/librt?source=hash-mapping
+  run_exports: {}
+  size: 160018
+  timestamp: 1782847517118
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/pyyaml-6.0.3-py314h807365f_1.conda
+  sha256: 496b5e65dfdd0aaaaa5de0dcaaf3bceea00fcb4398acf152f89e567c82ec1046
+  md5: 9ae2c92975118058bd720e9ba2bb7c58
+  depends:
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  - yaml >=0.2.5,<0.3.0a0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pyyaml?source=hash-mapping
+  run_exports: {}
+  size: 195678
+  timestamp: 1770223441816
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/qhull-2020.2-h70be974_5.conda
+  sha256: 49f777bdf3c5e030a8c7b24c58cdfe9486b51d6ae0001841079a3228bdf9fb51
+  md5: bb138086d938e2b64f5f364945793ebf
+  depends:
+  - libgcc-ng >=12
+  - libstdcxx-ng >=12
+  license: LicenseRef-Qhull
+  purls: []
+  run_exports:
+    weak:
+    - qhull >=2020.2,<2020.3.0a0
+  size: 554571
+  timestamp: 1720813941183
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/qt6-main-6.11.1-pl5321heaece2b_1.conda
+  sha256: 2ccded6ae260724733b80c1fb1c627068fd9cc8752ad425a3ea827fd4675ec23
+  md5: bff3e4e7be46f5800da83261c2cec35b
+  depends:
+  - libxcb
+  - xcb-util
+  - xcb-util-wm
+  - xcb-util-keysyms
+  - xcb-util-image
+  - xcb-util-renderutil
+  - xcb-util-cursor
+  - libgl-devel
+  - libegl-devel
+  - libstdcxx >=14
+  - libgcc >=14
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - xorg-libice >=1.1.2,<2.0a0
+  - xorg-libxext >=1.3.7,<2.0a0
+  - xcb-util-renderutil >=0.3.10,<0.4.0a0
+  - krb5 >=1.22.2,<1.23.0a0
+  - openssl >=3.5.6,<4.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  - xcb-util-image >=0.4.0,<0.5.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - xcb-util-cursor >=0.1.6,<0.2.0a0
+  - pcre2 >=10.47,<10.48.0a0
+  - xorg-libxcomposite >=0.4.7,<1.0a0
+  - libdrm >=2.4.127,<2.5.0a0
+  - libcups >=2.3.3,<2.4.0a0
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - xcb-util-keysyms >=0.4.1,<0.5.0a0
+  - xorg-libx11 >=1.8.13,<2.0a0
+  - xorg-libxxf86vm >=1.1.7,<2.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - dbus >=1.16.2,<2.0a0
+  - libxcb >=1.17.0,<2.0a0
+  - libglib >=2.88.1,<3.0a0
+  - libxkbcommon >=1.13.2,<2.0a0
+  - harfbuzz >=14.2.1
+  - libwebp-base >=1.6.0,<2.0a0
+  - xcb-util >=0.4.1,<0.5.0a0
+  - xorg-libxdamage >=1.1.6,<2.0a0
+  - libegl >=1.7.0,<2.0a0
+  - wayland >=1.25.0,<2.0a0
+  - xorg-libxrandr >=1.5.5,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - libbrotlicommon >=1.2.0,<1.3.0a0
+  - libbrotlienc >=1.2.0,<1.3.0a0
+  - libbrotlidec >=1.2.0,<1.3.0a0
+  - icu >=78.3,<79.0a0
+  - libvulkan-loader >=1.4.341.0,<2.0a0
+  - alsa-lib >=1.2.16,<1.3.0a0
+  - xcb-util-wm >=0.4.2,<0.5.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - double-conversion >=3.4.0,<3.5.0a0
+  - xorg-libxcursor >=1.2.3,<2.0a0
+  - libpq >=18.4,<19.0a0
+  - xorg-libxtst >=1.2.5,<2.0a0
+  - xorg-libsm >=1.2.6,<2.0a0
+  - libgl >=1.7.0,<2.0a0
+  - fontconfig >=2.18.1,<3.0a0
+  - fonts-conda-ecosystem
+  constrains:
+  - qt ==6.11.1
+  license: LGPL-3.0-only
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - qt6-main >=6.11.1,<7.0a0
+  size: 63087962
+  timestamp: 1780593135478
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda
+  sha256: fe695f9d215e9a2e3dd0ca7f56435ab4df24f5504b83865e3d295df36e88d216
+  md5: 3d49cad61f829f4f0e0611547a9cda12
+  depends:
+  - libgcc >=14
+  - ncurses >=6.5,<7.0a0
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports:
+    weak:
+    - readline >=8.3,<9.0a0
+  size: 357597
+  timestamp: 1765815673644
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/rhash-1.4.6-h86ecc28_1.conda
+  sha256: 0fe6f40213f2d8af4fcb7388eeb782a4e496c8bab32c189c3a34b37e8004e5a4
+  md5: 745d02c0c22ea2f28fbda2cb5dbec189
+  depends:
+  - libgcc >=13
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - rhash >=1.4.6,<2.0a0
+  size: 207475
+  timestamp: 1748644952027
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.15.20-h88be79b_0.conda
+  noarch: python
+  sha256: 4dcde033d77e17ae8e15669177f8550ef2155ce32443ac3a4f241238f9dab4db
+  md5: 762455b53e3cd6c35c04259cfa2fa499
+  depends:
+  - python
+  - libgcc >=14
+  constrains:
+  - __glibc >=2.17
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/ruff?source=hash-mapping
+  run_exports: {}
+  size: 8974657
+  timestamp: 1782428525763
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/shellcheck-0.11.0-h8af1aa0_1.conda
+  sha256: 0379634fef3b9c4712abc633e7755cd35dc68ed8e210fe235d8357da9000138b
+  md5: eef2decc18891928abbe752b1e91b442
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 7810095
+  timestamp: 1771525123512
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda
+  sha256: e25c314b52764219f842b41aea2c98a059f06437392268f09b03561e4f6e5309
+  md5: 7fc6affb9b01e567d2ef1d05b84aa6ed
+  depends:
+  - libgcc >=14
+  - libzlib >=1.3.1,<2.0a0
+  constrains:
+  - xorg-libx11 >=1.8.12,<2.0a0
+  license: TCL
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - tk >=8.6.13,<8.7.0a0
+  size: 3368666
+  timestamp: 1769464148928
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/tornado-6.5.7-py314hafb4487_0.conda
+  sha256: 7a5157dabdc88f2e16a45f8e342657ceb0d4515b8640c8a4f1c3b3de88dcc92e
+  md5: 82b0cb99192ae48eca75f25102fd5ce0
+  depends:
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/tornado?source=hash-mapping
+  run_exports: {}
+  size: 916897
+  timestamp: 1781007943867
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/typos-1.48.0-h069e38c_0.conda
+  sha256: 3141ffeddc27e9a98298dade1faf6c233701bdff47209f3871d6688188adeed5
+  md5: d2ff6fd5e80452e6b88ecfd5da3f4a73
+  depends:
+  - libgcc >=14
+  constrains:
+  - __glibc >=2.17
+  license: MIT OR Apache-2.0
+  purls: []
+  run_exports: {}
+  size: 3903453
+  timestamp: 1782859635286
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/unicodedata2-17.0.1-py314h51f160d_0.conda
+  sha256: fcc5e4515df19c3c781d3d70f69837c03d1f725d4e166cb3006cf656243f58bf
+  md5: 9479a1d1b844dfeefd287a16515811a0
+  depends:
+  - libgcc >=14
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/unicodedata2?source=hash-mapping
+  run_exports: {}
+  size: 410032
+  timestamp: 1770909146009
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/wayland-1.25.0-h4f8a99f_0.conda
+  sha256: 3cc479df517b0ce110835a1256f91ca568581cb6dfe1c53a0786f0a226039a45
+  md5: 0a7a9548726f98d5869fd4c43e110f0f
+  depends:
+  - libexpat >=2.7.4,<3.0a0
+  - libffi >=3.5.2,<3.6.0a0
+  - libgcc >=14
+  - libstdcxx >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - wayland >=1.25.0,<2.0a0
+  size: 335260
+  timestamp: 1773959583826
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-0.4.1-hca56bd8_2.conda
+  sha256: d874906e236a5edc9309d479599bf2de4d8adca0f23c355b76759d5fb3c4bef8
+  md5: 159ffec8f7fab775669a538f0b29373a
+  depends:
+  - libgcc >=13
+  - libxcb >=1.17.0,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util >=0.4.1,<0.5.0a0
+  size: 21517
+  timestamp: 1750437961489
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-cursor-0.1.6-he30d5cf_0.conda
+  sha256: 2e31eeeac0ad76229a565f1df3a8fb4ea54852a68404a99558adab9c92c0ac4d
+  md5: 8b70063c86f7f9a0b045e78d2d9971f7
+  depends:
+  - libgcc >=14
+  - libxcb >=1.13
+  - libxcb >=1.17.0,<2.0a0
+  - xcb-util-image >=0.4.0,<0.5.0a0
+  - xcb-util-renderutil >=0.3.10,<0.4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-cursor >=0.1.6,<0.2.0a0
+  size: 21639
+  timestamp: 1763367131001
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-image-0.4.0-h5c728e9_2.conda
+  sha256: a43058edc001e8fb97f9b291028a6ca16a8969d9b56a998c7aecea083323ac97
+  md5: b82e5c78dbbfa931980e8bfe83bce913
+  depends:
+  - libgcc-ng >=12
+  - libxcb >=1.16,<2.0.0a0
+  - xcb-util >=0.4.1,<0.5.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-image >=0.4.0,<0.5.0a0
+  size: 24910
+  timestamp: 1718880504308
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-keysyms-0.4.1-h5c728e9_0.conda
+  sha256: 9d92daa7feb0e14f81bf0d4b3f0b6ff1e8cec3ff514df8a0c06c4d49b518c315
+  md5: 57ca8564599ddf8b633c4ea6afee6f3a
+  depends:
+  - libgcc-ng >=12
+  - libxcb >=1.16,<2.0.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-keysyms >=0.4.1,<0.5.0a0
+  size: 14343
+  timestamp: 1718846624153
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-renderutil-0.3.10-h5c728e9_0.conda
+  sha256: 5827f5617c9741599f72bb7f090726f89c6ef91e4bada621895fdc2bbadfb0f1
+  md5: 7beeda4223c5484ef72d89fb66b7e8c1
+  depends:
+  - libgcc-ng >=12
+  - libxcb >=1.16,<2.0.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-renderutil >=0.3.10,<0.4.0a0
+  size: 18139
+  timestamp: 1718849914457
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xcb-util-wm-0.4.2-h5c728e9_0.conda
+  sha256: 3f52cd8783e7d953c54266255fd11886c611c2620545eabc28ec8cf470ae8be7
+  md5: f14dcda6894722e421da2b7dcffb0b78
+  depends:
+  - libgcc-ng >=12
+  - libxcb >=1.16,<2.0.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xcb-util-wm >=0.4.2,<0.5.0a0
+  size: 50772
+  timestamp: 1718845072660
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xkeyboard-config-2.48-h80f16a2_0.conda
+  sha256: 96078068df25ddccc60958be740e6fa99efb1e0fa2dae2f84e775201bf84d70c
+  md5: 3dbc6d9e1f8a8768e7ef9f57585a43ca
+  depends:
+  - libgcc >=14
+  - xorg-libx11 >=1.8.13,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 442725
+  timestamp: 1782027381059
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libice-1.1.2-h86ecc28_0.conda
+  sha256: a2ba1864403c7eb4194dacbfe2777acf3d596feae43aada8d1b478617ce45031
+  md5: c8d8ec3e00cd0fd8a231789b91a7c5b7
+  depends:
+  - libgcc >=13
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libice >=1.1.2,<2.0a0
+  size: 60433
+  timestamp: 1734229908988
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libsm-1.2.6-h0808dbd_0.conda
+  sha256: b86a819cd16f90c01d9d81892155126d01555a20dabd5f3091da59d6309afd0a
+  md5: 2d1409c50882819cb1af2de82e2b7208
+  depends:
+  - libgcc >=13
+  - libuuid >=2.38.1,<3.0a0
+  - xorg-libice >=1.1.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libsm >=1.2.6,<2.0a0
+  size: 28701
+  timestamp: 1741897678254
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libx11-1.8.13-h63a1b12_0.conda
+  sha256: cf886160e2ff580d77f7eb8ec1a77c41c2c5b05343e329bc35f0ddf40b8d92ab
+  md5: 22dd10425ef181e80e130db50675d615
+  depends:
+  - libgcc >=14
+  - libxcb >=1.17.0,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libx11 >=1.8.13,<2.0a0
+  size: 869058
+  timestamp: 1770819244991
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxau-1.0.12-he30d5cf_1.conda
+  sha256: e9f6e931feeb2f40e1fdbafe41d3b665f1ab6cb39c5880a1fcf9f79a3f3c84a5
+  md5: 1c246e1105000c3660558459e2fd6d43
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxau >=1.0.12,<2.0a0
+  size: 16317
+  timestamp: 1762977521691
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxcomposite-0.4.7-he30d5cf_0.conda
+  sha256: 554f986ffa781d3393079926931465e61291d1eb8a56a03ad4a8e54b1ae233f4
+  md5: 9c639c1abdbfe6759c5beb2c1db4bc13
+  depends:
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxfixes >=6.0.2,<7.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxcomposite >=0.4.7,<1.0a0
+  size: 14915
+  timestamp: 1770044415607
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxcursor-1.2.3-h86ecc28_0.conda
+  sha256: c5d3692520762322a9598e7448492309f5ee9d8f3aff72d787cf06e77c42507f
+  md5: f2054759c2203d12d0007005e1f1296d
+  depends:
+  - libgcc >=13
+  - xorg-libx11 >=1.8.9,<2.0a0
+  - xorg-libxfixes >=6.0.1,<7.0a0
+  - xorg-libxrender >=0.9.11,<0.10.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxcursor >=1.2.3,<2.0a0
+  size: 34596
+  timestamp: 1730908388714
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxdamage-1.1.6-h86ecc28_0.conda
+  sha256: 3afaa2f43eb4cb679fc0c3d9d7c50f0f2c80cc5d3df01d5d5fd60655d0bfa9be
+  md5: d5773c4e4d64428d7ddaa01f6f845dc7
+  depends:
+  - libgcc >=13
+  - xorg-libx11 >=1.8.9,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxfixes >=6.0.1,<7.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxdamage >=1.1.6,<2.0a0
+  size: 13794
+  timestamp: 1727891406431
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxdmcp-1.1.5-he30d5cf_1.conda
+  sha256: 128d72f36bcc8d2b4cdbec07507542e437c7d67f677b7d77b71ed9eeac7d6df1
+  md5: bff06dcde4a707339d66d45d96ceb2e2
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxdmcp >=1.1.5,<2.0a0
+  size: 21039
+  timestamp: 1762979038025
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxext-1.3.7-he30d5cf_0.conda
+  sha256: db2188bc0d844d4e9747bac7f6c1d067e390bd769c5ad897c93f1df759dc5dba
+  md5: fb42b683034619915863d68dd9df03a3
+  depends:
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxext >=1.3.7,<2.0a0
+  size: 52409
+  timestamp: 1769446753771
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxfixes-6.0.2-he30d5cf_0.conda
+  sha256: 8cb9c88e25c57e47419e98f04f9ef3154ad96b9f858c88c570c7b91216a64d0e
+  md5: e8b4056544341daf1d415eaeae7a040c
+  depends:
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxfixes >=6.0.2,<7.0a0
+  size: 20704
+  timestamp: 1759284028146
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxi-1.8.3-he30d5cf_0.conda
+  sha256: 0c1c7b39763469cfe0e9c6d0f9a39415321f477710719f4c5d63c61ea270271c
+  md5: f8ad5777ecc217d383a722598dbeb1ac
+  depends:
+  - libgcc >=14
+  - xorg-libx11 >=1.8.13,<2.0a0
+  - xorg-libxext >=1.3.7,<2.0a0
+  - xorg-libxfixes >=6.0.2,<7.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxi >=1.8.3,<2.0a0
+  size: 49292
+  timestamp: 1779113229775
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxinerama-1.1.6-hfae3067_0.conda
+  sha256: 2039990aa8454f19e8f890ff1e8582f12fa475af7e836b184adc17b88a22c9b8
+  md5: a488ab283de297dc0de69796f7467a71
+  depends:
+  - libgcc >=14
+  - libstdcxx >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxinerama >=1.1.6,<1.2.0a0
+  size: 15322
+  timestamp: 1769432283298
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxrandr-1.5.5-he30d5cf_0.conda
+  sha256: 9f5196665a8d72f4f119c40dcc4bafeb0b540b102cc7b8b299c2abf599e7919f
+  md5: 1f64c613f0b8d67e9fb0e165d898fb6b
+  depends:
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxrender >=0.9.12,<0.10.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxrandr >=1.5.5,<2.0a0
+  size: 31122
+  timestamp: 1769445286951
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxrender-0.9.12-h86ecc28_0.conda
+  sha256: ffd77ee860c9635a28cfda46163dcfe9224dc6248c62404c544ae6b564a0be1f
+  md5: ae2c2dd0e2d38d249887727db2af960e
+  depends:
+  - libgcc >=13
+  - xorg-libx11 >=1.8.10,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxrender >=0.9.12,<0.10.0a0
+  size: 33649
+  timestamp: 1734229123157
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxtst-1.2.5-h57736b2_3.conda
+  sha256: 6eaffce5a34fc0a16a21ddeaefb597e792a263b1b0c387c1ce46b0a967d558e1
+  md5: c05698071b5c8e0da82a282085845860
+  depends:
+  - libgcc >=13
+  - xorg-libx11 >=1.8.9,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  - xorg-libxi >=1.7.10,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxtst >=1.2.5,<2.0a0
+  size: 33786
+  timestamp: 1727964907993
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-libxxf86vm-1.1.7-he30d5cf_0.conda
+  sha256: 6f6f2b32754e09c2334e067ba5d2d38715f2432cd9fb41d6f66de0591f8f4f94
+  md5: b15ca02584678f38df6e114c32f93959
+  depends:
+  - libgcc >=14
+  - xorg-libx11 >=1.8.12,<2.0a0
+  - xorg-libxext >=1.3.6,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxxf86vm >=1.1.7,<2.0a0
+  size: 19148
+  timestamp: 1769434729220
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/xorg-xorgproto-2025.1-he30d5cf_0.conda
+  sha256: d8a7593362562f66bab992901df6cdc845c6004d15c1ba2d1e3e39e4e4672384
+  md5: 999d230bcb0329c11d101118ace392d9
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 569539
+  timestamp: 1766155414260
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/yaml-0.2.5-h80f16a2_3.conda
+  sha256: 66265e943f32ce02396ad214e27cb35f5b0490b3bd4f064446390f9d67fa5d88
+  md5: 032d8030e4a24fe1f72c74423a46fb88
+  depends:
+  - libgcc >=14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - yaml >=0.2.5,<0.3.0a0
+  size: 88088
+  timestamp: 1753484092643
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zizmor-1.26.1-h069e38c_0.conda
+  sha256: 7845dfb8a763681e9f14c63a190f11ff46bfa43b95950f2a3690e064519ffd85
+  md5: 63c8c0d72f96a8029d5017c41305018e
+  depends:
+  - libgcc >=14
+  constrains:
+  - __glibc >=2.17
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 6708207
+  timestamp: 1782024337431
+- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda
+  sha256: 569990cf12e46f9df540275146da567d9c618c1e9c7a0bc9d9cfefadaed20b75
+  md5: c3655f82dcea2aa179b291e7099c1fcc
+  depends:
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - zstd >=1.5.7,<1.6.0a0
+  size: 614429
+  timestamp: 1764777145593
+- conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda
+  sha256: a3967b937b9abf0f2a99f3173fa4630293979bd1644709d89580e7c62a544661
+  md5: aaa2a381ccc56eac91d63b6c1240312f
+  depends:
+  - cpython
+  - python-gil
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 8191
+  timestamp: 1744137672556
+- conda: https://conda.anaconda.org/conda-forge/noarch/accessible-pygments-0.0.5-pyhd8ed1ab_1.conda
+  sha256: 1307719f0d8ee694fc923579a39c0621c23fdaa14ccdf9278a5aac5665ac58e9
+  md5: 74ac5069774cdbc53910ec4d631a3999
+  depends:
+  - pygments
+  - python >=3.9
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/accessible-pygments?source=hash-mapping
+  run_exports: {}
+  size: 1326096
+  timestamp: 1734956217254
+- conda: https://conda.anaconda.org/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda
+  sha256: a362b4f5c96a0bf4def96be1a77317e2730af38915eb9bec85e2a92836501ed7
+  md5: b3f0179590f3c0637b7eb5309898f79e
+  depends:
+  - __unix
+  - hicolor-icon-theme
+  - librsvg
+  license: LGPL-3.0-or-later OR CC-BY-SA-3.0
+  license_family: LGPL
+  purls: []
+  run_exports: {}
+  size: 631452
+  timestamp: 1758743294412
+- conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-1.0.0-pyhd8ed1ab_1.conda
+  sha256: 6c4456a138919dae9edd3ac1a74b6fbe5fd66c05675f54df2f8ab8c8d0cc6cea
+  md5: 1fd9696649f65fd6611fcdb4ffec738a
+  depends:
+  - python >=3.10
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/alabaster?source=hash-mapping
+  run_exports: {}
+  size: 18684
+  timestamp: 1733750512696
+- conda: https://conda.anaconda.org/conda-forge/noarch/attrs-26.1.0-pyhcf101f3_0.conda
+  sha256: 1b6124230bb4e571b1b9401537ecff575b7b109cc3a21ee019f65e083b8399ab
+  md5: c6b0543676ecb1fb2d7643941fe375f2
+  depends:
+  - python >=3.10
+  - python
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 64927
+  timestamp: 1773935801332
+- conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda
+  sha256: a14a9ad02101aab25570543a59c5193043b73dc311a25650134ed9e6cb691770
+  md5: f1976ce927373500cc19d3c0b2c85177
+  depends:
+  - python >=3.10
+  - python
+  constrains:
+  - pytz >=2015.7
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/babel?source=hash-mapping
+  run_exports: {}
+  size: 7684321
+  timestamp: 1772555330347
+- conda: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.6.0-py314h680f03e_0.conda
+  noarch: generic
+  sha256: 709cac7434d1c5a8828105036212a2a36022a07d807e89e2e99cac939c2d2526
+  md5: 40d89d8546ad6e139e73ec8f6d56068b
+  depends:
+  - python >=3.14
+  license: BSD-3-Clause AND MIT AND EPL-2.0
+  purls:
+  - pkg:pypi/backports-zstd?source=compressed-mapping
+  run_exports: {}
+  size: 7526
+  timestamp: 1781450817767
+- conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.15.0-pyha770c72_0.conda
+  sha256: aed4b9dcf68ec2a75e5645fed14d77fd884d38d2e52bfa6ef4b278d90cd88781
+  md5: 3b261da3fe9b4168738712832410b022
+  depends:
+  - python >=3.10
+  - soupsieve >=1.2
+  - typing-extensions
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/beautifulsoup4?source=compressed-mapping
+  run_exports: {}
+  size: 92704
+  timestamp: 1780853175566
+- conda: https://conda.anaconda.org/conda-forge/noarch/binaryornot-0.6.0-pyhcf101f3_0.conda
+  sha256: 1513cf9ab5285c823f90214eb8e638c0d065d3fa11120bfb7bb3cff1eb7a98d0
+  md5: 980ed7a17e9279d5c0063d080cf13d0c
+  depends:
+  - python >=3.10
+  - python
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 21898
+  timestamp: 1773003768810
+- conda: https://conda.anaconda.org/conda-forge/noarch/boolean.py-5.0-pyhd8ed1ab_0.conda
+  sha256: 6195e09f7d8a3a5e2fc0dddd6d1e87198e9c3d2a1982ff04624957a6c6466e54
+  md5: 26c3480f80364e9498a48bb5c3e35f85
+  depends:
+  - python >=3.9
+  license: BSD-2-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 29946
+  timestamp: 1743687383956
+- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda
+  sha256: 7f458e4a82514d7bebbfef23d92817794a16aaf1c748a15f04870d4fb49aeab2
+  md5: b9696b2cf00dfeec138c70cee38ed192
+  depends:
+  - __win
+  license: ISC
+  purls: []
+  run_exports: {}
+  size: 129352
+  timestamp: 1781709016515
+- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda
+  sha256: f8e3c730fa14ee3f170493779f06522c4acf89169f43db4f039727709b6419cf
+  md5: a9965dd99f683c5f444428f896635716
+  depends:
+  - __unix
+  license: ISC
+  purls: []
+  run_exports: {}
+  size: 128866
+  timestamp: 1781708962055
+- conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.6.17-pyhd8ed1ab_0.conda
+  sha256: 6c13620e458ba43278379d0cdacc30c497336bddfda81681fd50d114a65c702f
+  md5: c13824fedced67005d3832c152fe9c2f
+  depends:
+  - python >=3.10
+  license: ISC
+  purls:
+  - pkg:pypi/certifi?source=compressed-mapping
+  run_exports: {}
+  size: 133877
+  timestamp: 1781719949728
+- conda: https://conda.anaconda.org/conda-forge/noarch/chardet-7.4.3-pyhcf101f3_0.conda
+  sha256: d307dcdba7498fadeeeed616ad0fc9e1cfd6061f5d83f64fbd20be4968f1bfb9
+  md5: 7dd72a4c857cd652a1e23c13099a15d2
+  depends:
+  - python >=3.10
+  - python
+  license: 0BSD
+  run_exports: {}
+  size: 627453
+  timestamp: 1776140819080
+- conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda
+  sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457
+  md5: a9167b9571f3baa9d448faa2139d1089
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/charset-normalizer?source=hash-mapping
+  run_exports: {}
+  size: 58872
+  timestamp: 1775127203018
+- conda: https://conda.anaconda.org/conda-forge/noarch/click-8.4.1-pyh6dadd2b_0.conda
+  sha256: 5b8e8d8876ace41735f51ca43c43cdc9e1b4fbbae0f415d6b8441fec826d8c47
+  md5: f73f35eedcd8e89d6c4407df15101233
+  depends:
+  - __win
+  - colorama
+  - python >=3.10
+  - python
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 104080
+  timestamp: 1779900586237
+- conda: https://conda.anaconda.org/conda-forge/noarch/click-8.4.1-pyhc90fa1f_0.conda
+  sha256: c253a41cdf898b651a0786cbb76c6d5fc101d0dbbe719f93a124bc4fde5cdd6a
+  md5: 554304a07e581a85891b15e39ea9f268
+  depends:
+  - __unix
+  - python
+  - python >=3.10
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 104999
+  timestamp: 1779900548735
+- conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda
+  sha256: ab29d57dc70786c1269633ba3dff20288b81664d3ff8d21af995742e2bb03287
+  md5: 962b9857ee8e7018c22f2776ffa0b2d7
+  depends:
+  - python >=3.9
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/colorama?source=hash-mapping
+  run_exports: {}
+  size: 27011
+  timestamp: 1733218222191
+- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-64-22.1.8-hffcefe0_1.conda
+  sha256: c6cd0a10b9b161b0b075a8a78083b23a49d87f0e383d2c199ce11a586fc7d779
+  md5: cbf060078c396f1e6bc5f02d9292ae9f
+  constrains:
+  - compiler-rt >=9.0.1
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 49013140
+  timestamp: 1781741112005
+- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_linux-aarch64-22.1.8-hfefdfc9_1.conda
+  sha256: 354848c18b2fc3c08af5e34e853c18fd550a0103638f14714f443dff204c84ad
+  md5: 5dd8f17d763130ad0d061a6f7618aede
+  constrains:
+  - compiler-rt >=9.0.1
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 33853021
+  timestamp: 1781741002491
+- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_osx-arm64-22.1.8-h7e67a1e_1.conda
+  sha256: 0d3cb7b6386265b8a308b1a0a83a0e718e9d78b0e61f7d7a7bb80b47760e35da
+  md5: 3e936f877a0eb8381d30f14810a39acd
+  constrains:
+  - compiler-rt >=9.0.1
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 11005161
+  timestamp: 1781741132641
+- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt22_win-64-22.1.8-h49e36cd_1.conda
+  sha256: 2b6e26faab7760cfbc38c734751fb1a1be504ea7faf6b697e85bb2ce6755da26
+  md5: a74c63cb380a94265b01876cd3326ff9
+  constrains:
+  - compiler-rt >=9.0.1
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 3977602
+  timestamp: 1781741811822
+- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-64-22.1.8-ha770c72_1.conda
+  sha256: 81bb0835e05ef4c60022aa594e16a870bbf39ed4d4180ef87191f56b795cd86c
+  md5: 552e1d9f624f815bf90262e4cb6cf04c
+  depends:
+  - compiler-rt22_linux-64 22.1.8 hffcefe0_1
+  constrains:
+  - clang 22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 16599
+  timestamp: 1781741197576
+- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_linux-aarch64-22.1.8-h8af1aa0_1.conda
+  sha256: 28cf258166a00bd7c92d9853a3716a8bb913c68c086a43810ee2f08b6163decc
+  md5: 8c0bb32e6abee55228fbdb3fa361cc48
+  depends:
+  - compiler-rt22_linux-aarch64 22.1.8 hfefdfc9_1
+  constrains:
+  - clang 22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 16664
+  timestamp: 1781741084375
+- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-19.1.7-he32a8d3_1.conda
+  sha256: 8c32a3db8adf18ed58197e8895ce4f24a83ed63c817512b9a26724753b116f2a
+  md5: 8d99c82e0f5fed6cc36fcf66a11e03f0
+  depends:
+  - clang 19.1.7.*
+  constrains:
+  - compiler-rt 19.1.7
+  - clangxx 19.1.7
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 10490535
+  timestamp: 1757411851093
+- conda: https://conda.anaconda.org/conda-forge/noarch/compiler-rt_osx-arm64-22.1.8-hce30654_1.conda
+  sha256: e8eccc163a8ca1fcd051826d566934d3785413b5a57d658902eb775026af3856
+  md5: d50cec26659fa7e7c285803c77abab9b
+  depends:
+  - compiler-rt22_osx-arm64 22.1.8 h7e67a1e_1
+  constrains:
+  - clang 22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 16698
+  timestamp: 1781741176960
+- conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_1.conda
+  noarch: generic
+  sha256: 705917252b4cdfca93d8df09d40dc9b08074ecbd23b0ca23eb74bca8d1629599
+  md5: bfe34936b4fa9b1fbe25e68a7abbd8eb
+  depends:
+  - python >=3.10,<3.11.0a0
+  - python_abi * *_cp310
+  license: Python-2.0
+  run_exports: {}
+  size: 51458
+  timestamp: 1781148418793
+- conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda
+  noarch: generic
+  sha256: 7a548856ef5307890a8cadfc196655117658f8c24589ce175caa4c1c2ded9d13
+  md5: b28fe35fd43d5f425c0dccbe5b5039fd
+  depends:
+  - python >=3.14,<3.15.0a0
+  - python_abi * *_cp314
+  license: Python-2.0
+  purls: []
+  run_exports: {}
+  size: 49333
+  timestamp: 1781254618863
+- conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda
+  sha256: bb47aec5338695ff8efbddbc669064a3b10fe34ad881fb8ad5d64fbfa6910ed1
+  md5: 4c2a8fef270f6c69591889b93f9f55c1
+  depends:
+  - python >=3.10
+  - python
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/cycler?source=hash-mapping
+  run_exports: {}
+  size: 14778
+  timestamp: 1764466758386
+- conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.21.2-pyhd8ed1ab_1.conda
+  sha256: fa5966bb1718bbf6967a85075e30e4547901410cc7cb7b16daf68942e9a94823
+  md5: 24c1ca34138ee57de72a943237cde4cc
+  depends:
+  - python >=3.9
+  license: CC-PDDC AND BSD-3-Clause AND BSD-2-Clause AND ZPL-2.1
+  purls:
+  - pkg:pypi/docutils?source=hash-mapping
+  run_exports: {}
+  size: 402700
+  timestamp: 1733217860944
+- conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda
+  sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144
+  md5: 8e662bd460bda79b1ea39194e3c4c9ab
+  depends:
+  - python >=3.10
+  - typing_extensions >=4.6.0
+  license: MIT and PSF-2.0
+  purls:
+  - pkg:pypi/exceptiongroup?source=hash-mapping
+  run_exports: {}
+  size: 21333
+  timestamp: 1763918099466
+- conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda
+  sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8
+  md5: a57b4be42619213a94f31d2c69c5dda7
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/execnet?source=hash-mapping
+  run_exports: {}
+  size: 39499
+  timestamp: 1762974150770
+- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2
+  sha256: 58d7f40d2940dd0a8aa28651239adbf5613254df0f75789919c4e6762054403b
+  md5: 0c96522c6bdaed4b1566d11387caaf45
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 397370
+  timestamp: 1566932522327
+- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2
+  sha256: c52a29fdac682c20d252facc50f01e7c2e7ceac52aa9817aaf0bb83f7559ec5c
+  md5: 34893075a5c9e55cdafac56607368fc6
+  license: OFL-1.1
+  license_family: Other
+  purls: []
+  run_exports: {}
+  size: 96530
+  timestamp: 1620479909603
+- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2
+  sha256: 00925c8c055a2275614b4d983e1df637245e19058d79fc7dd1a93b8d9fb4b139
+  md5: 4d59c254e01d9cde7957100457e2d5fb
+  license: OFL-1.1
+  license_family: Other
+  purls: []
+  run_exports: {}
+  size: 700814
+  timestamp: 1620479612257
+- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda
+  sha256: 2821ec1dc454bd8b9a31d0ed22a7ce22422c0aef163c59f49dfdf915d0f0ca14
+  md5: 49023d73832ef61042f6a237cb2687e7
+  license: LicenseRef-Ubuntu-Font-Licence-Version-1.0
+  license_family: Other
+  purls: []
+  run_exports: {}
+  size: 1620504
+  timestamp: 1727511233259
+- conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2
+  sha256: a997f2f1921bb9c9d76e6fa2f6b408b7fa549edd349a77639c9fe7a23ea93e61
+  md5: fee5683a3f04bd15cbd8318b096a27ab
+  depends:
+  - fonts-conda-forge
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 3667
+  timestamp: 1566974674465
+- conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda
+  sha256: 54eea8469786bc2291cc40bca5f46438d3e062a399e8f53f013b6a9f50e98333
+  md5: a7970cd949a077b7cb9696379d338681
+  depends:
+  - font-ttf-ubuntu
+  - font-ttf-inconsolata
+  - font-ttf-dejavu-sans-mono
+  - font-ttf-source-code-pro
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 4059
+  timestamp: 1762351264405
+- conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda
+  sha256: c9752235f1ff7061d834e5e4a3d0adf71ebeeff2b3fad82dab607edce7f70c91
+  md5: 0509ee74d95e5b98eb6fe2a47760e399
+  depends:
+  - brotli
+  - munkres
+  - python >=3.10
+  - unicodedata2 >=15.1.0
+  track_features:
+  - fonttools_no_compile
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/fonttools?source=hash-mapping
+  run_exports: {}
+  size: 846038
+  timestamp: 1778770337113
+- conda: https://conda.anaconda.org/conda-forge/noarch/furo-2025.12.19-pyhd8ed1ab_1.conda
+  sha256: 0b6c349fb314515b6d0bda4973edeab83366e4ebe6d57a435c028193ebe1e6f6
+  md5: a119df8b5f08fe7b185f5923ab8c4c0e
+  depends:
+  - accessible-pygments >=0.0.5
+  - beautifulsoup4
+  - pygments >=2.7
+  - python >=3.10
+  - sphinx >=7.0,<10.0
+  - sphinx-basic-ng
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/furo?source=hash-mapping
+  run_exports: {}
+  size: 83092
+  timestamp: 1772974091117
+- conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda
+  sha256: 84c64443368f84b600bfecc529a1194a3b14c3656ee2e832d15a20e0329b6da3
+  md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9
+  depends:
+  - python >=3.10
+  - hyperframe >=6.1,<7
+  - hpack >=4.1,<5
+  - python
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/h2?source=hash-mapping
+  run_exports: {}
+  size: 95967
+  timestamp: 1756364871835
+- conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.2.0-pyhd8ed1ab_0.conda
+  sha256: fdcea5d7cb314485d3907192ef024c704311548c5b0cbeb390cd1951051e29d2
+  md5: b395909221b9bd1df066e5930e18855b
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/hpack?source=compressed-mapping
+  run_exports: {}
+  size: 32884
+  timestamp: 1782283986153
+- conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda
+  sha256: 77af6f5fe8b62ca07d09ac60127a30d9069fdc3c68d6b256754d0ffb1f7779f8
+  md5: 8e6923fc12f1fe8f8c4e5c9f343256ac
+  depends:
+  - python >=3.9
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/hyperframe?source=hash-mapping
+  run_exports: {}
+  size: 17397
+  timestamp: 1737618427549
+- conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.18-pyhcf101f3_0.conda
+  sha256: c75632ea624aa450a394f570749420c5a2e0997d0216bc29d5d45b0f39df0426
+  md5: 577b04680ae422adb86fc60d7b940659
+  depends:
+  - python >=3.10
+  - python
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/idna?source=compressed-mapping
+  run_exports: {}
+  size: 163869
+  timestamp: 1781620148226
+- conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-2.0.0-pyhd8ed1ab_0.conda
+  sha256: 5a047f9eac290e679b4e6f6f4cbfcc5acdfbf031a4f06824d4ddb590cdbb850b
+  md5: 92617c2ba2847cca7a6ed813b6f4ab79
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/imagesize?source=hash-mapping
+  run_exports: {}
+  size: 15729
+  timestamp: 1773752188889
+- conda: https://conda.anaconda.org/conda-forge/noarch/importlib-resources-7.1.0-pyhd8ed1ab_0.conda
+  sha256: 6a2f86ef0965605d742b5b94229bf8b829258d0a9f640e3651901cc72ef9a0a5
+  md5: e3bffa82b874f8b9a2631bddb3869529
+  depends:
+  - importlib_resources >=7.1.0,<7.1.1.0a0
+  - python >=3.10
+  license: Apache-2.0
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 10354
+  timestamp: 1776068852701
+- conda: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda
+  sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a
+  md5: 0ba6225c279baf7ea9473a62ea0ec9ae
+  depends:
+  - python >=3.10
+  - zipp >=3.1.0
+  constrains:
+  - importlib-resources >=7.1.0,<7.1.1.0a0
+  license: Apache-2.0
+  license_family: APACHE
+  purls:
+  - pkg:pypi/importlib-resources?source=hash-mapping
+  run_exports: {}
+  size: 34809
+  timestamp: 1776068839274
+- conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda
+  sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19
+  md5: 9614359868482abba1bd15ce465e3c42
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/iniconfig?source=hash-mapping
+  run_exports: {}
+  size: 13387
+  timestamp: 1760831448842
+- conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda
+  sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b
+  md5: 04558c96691bed63104678757beb4f8d
+  depends:
+  - markupsafe >=2.0
+  - python >=3.10
+  - python
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/jinja2?source=hash-mapping
+  run_exports: {}
+  size: 120685
+  timestamp: 1764517220861
+- conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda
+  sha256: 41557eeadf641de6aeae49486cef30d02a6912d8da98585d687894afd65b356a
+  md5: 86d9cba083cd041bfbf242a01a7a1999
+  constrains:
+  - sysroot_linux-64 ==2.28
+  license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 1278712
+  timestamp: 1765578681495
+- conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-aarch64-4.18.0-h05a177a_9.conda
+  sha256: 5d224bf4df9bac24e69de41897c53756108c5271a0e5d2d2f66fd4e2fbc1d84b
+  md5: bb3b7cad9005f2cbf9d169fb30263f3e
+  constrains:
+  - sysroot_linux-aarch64 ==2.28
+  license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 1248134
+  timestamp: 1765578613607
+- conda: https://conda.anaconda.org/conda-forge/noarch/libcxx-headers-19.1.7-h707e725_2.conda
+  sha256: 36485e6807e03a4f15a8018ec982457a9de0a1318b4b49a44c5da75849dbe24f
+  md5: de91b5ce46dc7968b6e311f9add055a2
+  depends:
+  - __unix
+  constrains:
+  - libcxx-devel 19.1.7
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 830747
+  timestamp: 1764647922410
+- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-14.3.0-hf649bbc_119.conda
+  sha256: e1815bb11d5abe886979e95889d84310d83d078d36a3567ca67cbf57a3876d88
+  md5: 7d517e32d656a8880d98c0e4fc8ddc2c
+  depends:
+  - __unix
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 3091520
+  timestamp: 1778268364856
+- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.2.0-hcc6f6b0_119.conda
+  sha256: 38a557eba305468ac1f90ac85e50d8defd76141cb0b8a43b2fc1aca71dd5d5f2
+  md5: 683fcb168e1df9a21fa80d5aa2d9330b
+  depends:
+  - __unix
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  run_exports: {}
+  size: 3095909
+  timestamp: 1778268932148
+- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-14.3.0-h25ba3ff_119.conda
+  sha256: e06d098cd33eac577b9c994a47243de5439ca8fd9ff6e790723fbfdc3d61a76c
+  md5: 970ca6cb337de6a7bccfaaa344e9863b
+  depends:
+  - __unix
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 2346647
+  timestamp: 1778268433769
+- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-aarch64-15.2.0-h55c397f_119.conda
+  sha256: fe600a63a39281e6994e27fe79360cd6bd8e576c3ce1af32ce8673b011f46c21
+  md5: 18ad0f0b94071d91fa962a1bf3983a78
+  depends:
+  - __unix
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  run_exports: {}
+  size: 2353893
+  timestamp: 1778268665954
+- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-14.3.0-h9f08a49_119.conda
+  sha256: 1b4263aa5d8c8c659e8e38b66868f42867347e0c8941513ee77269afc00a5186
+  md5: d1a866495b9654ccfef5392b8541dc58
+  depends:
+  - __unix
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 20199810
+  timestamp: 1778268389428
+- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-aarch64-14.3.0-h57c8d61_119.conda
+  sha256: 918ae042d508617da3c06fb55332f1280340eb705a69a0b1d14fa6fddb790145
+  md5: 8c7bc9930a1b7c38557311fbea9a433f
+  depends:
+  - __unix
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 17587589
+  timestamp: 1778268454520
+- conda: https://conda.anaconda.org/conda-forge/noarch/license-expression-30.4.4-pyhe01879c_0.conda
+  sha256: c0fc62fa5c7552b5ec42324fdc6c9fef05eaa239a434c721df074b42e7a52611
+  md5: c9b00d4ac670f5401b9ed080c96eb9f1
+  depends:
+  - boolean.py >=4.0.0
+  - python >=3.9
+  - python
+  license: Apache-2.0
+  license_family: APACHE
+  run_exports: {}
+  size: 120884
+  timestamp: 1753294907822
+- conda: https://conda.anaconda.org/conda-forge/noarch/linkify-it-py-2.1.0-pyhcf101f3_0.conda
+  sha256: 991a82fbb64aba6d10719a017ce354e28df02ea5df1d9c7b0221da573c168d27
+  md5: 1005e1f39083adad2384772e8e384e43
+  depends:
+  - python >=3.10
+  - uc-micro-py
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/linkify-it-py?source=hash-mapping
+  run_exports: {}
+  size: 26062
+  timestamp: 1772476821244
+- conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.2.0-pyhd8ed1ab_0.conda
+  sha256: 0c4c35376fe920714390d46e4b8d31c876d65f18e1655899e0763ec25f2a902f
+  md5: 6d03368f2b2b0a5fb6839df53b2eb5e0
+  depends:
+  - mdurl >=0.1,<1
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/markdown-it-py?source=hash-mapping
+  run_exports: {}
+  size: 69017
+  timestamp: 1778169663339
+- conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.6.1-pyhd8ed1ab_0.conda
+  sha256: 49db23cbfb1c1d414a14d7540195208b994ebd747beba0f15c903f3a0a2dc446
+  md5: ad6821df7a98510117db06e9a833281f
+  depends:
+  - markdown-it-py >=2.0.0,<5.0.0
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/mdit-py-plugins?source=hash-mapping
+  run_exports: {}
+  size: 50460
+  timestamp: 1778692223625
+- conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda
+  sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7
+  md5: 592132998493b3ff25fd7479396e8351
+  depends:
+  - python >=3.9
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/mdurl?source=hash-mapping
+  run_exports: {}
+  size: 14465
+  timestamp: 1733255681319
+- conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda
+  sha256: d09c47c2cf456de5c09fa66d2c3c5035aa1fa228a1983a433c47b876aa16ce90
+  md5: 37293a85a0f4f77bbd9cf7aaefc62609
+  depends:
+  - python >=3.9
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/munkres?source=hash-mapping
+  run_exports: {}
+  size: 15851
+  timestamp: 1749895533014
+- conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda
+  sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1
+  md5: e9c622e0d00fa24a6292279af3ab6d06
+  depends:
+  - python >=3.9
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/mypy-extensions?source=hash-mapping
+  run_exports: {}
+  size: 11766
+  timestamp: 1745776666688
+- conda: https://conda.anaconda.org/conda-forge/noarch/myst-parser-5.1.0-pyhd8ed1ab_0.conda
+  sha256: 94235bc1f769cf35029942ecb2ca796f18e730c1bf5aeef95e72680ebcfacfef
+  md5: 580615e59fc7c07741e4d2ab052cfc8b
+  depends:
+  - docutils >=0.20,<0.23
+  - jinja2
+  - markdown-it-py >=4.2.0,<4.3.0
+  - mdit-py-plugins >=0.6.1,<0.7
+  - python >=3.11
+  - pyyaml
+  - sphinx >=8,<10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/myst-parser?source=compressed-mapping
+  run_exports: {}
+  size: 74888
+  timestamp: 1778696564508
+- conda: https://conda.anaconda.org/conda-forge/noarch/nanobind-2.13.0-pyhd8ed1ab_0.conda
+  sha256: 87d5cbfbb03341a0e20358181c6797020c2f8f7ab8b0b29df14b529dd4b89dff
+  md5: 6e01733bb43e6c914c25ba3fcc49c98e
+  depends:
+  - python >=3.10
+  constrains:
+  - nanobind-abi ==20
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/nanobind?source=compressed-mapping
+  run_exports: {}
+  size: 199855
+  timestamp: 1781788359866
+- conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda
+  sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890
+  md5: 4c06a92e74452cfa53623a81592e8934
+  depends:
+  - python >=3.8
+  - python
+  license: Apache-2.0
+  license_family: APACHE
+  purls:
+  - pkg:pypi/packaging?source=hash-mapping
+  run_exports: {}
+  size: 91574
+  timestamp: 1777103621679
+- conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda
+  sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3
+  md5: 11adc78451c998c0fd162584abfa3559
+  depends:
+  - python >=3.10
+  license: MPL-2.0
+  license_family: MOZILLA
+  purls:
+  - pkg:pypi/pathspec?source=hash-mapping
+  run_exports: {}
+  size: 56559
+  timestamp: 1777271601895
+- conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh145f28c_0.conda
+  sha256: 9e673d3c6003f416df11670a14b026a04e3a45ebec55357987e15b860f138f2a
+  md5: 733cc07ed34162ac50b936464b163366
+  depends:
+  - python >=3.13.0a0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pip?source=compressed-mapping
+  run_exports: {}
+  size: 1202377
+  timestamp: 1780262809860
+- conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.2-pyh8b19718_0.conda
+  sha256: 29b7d75bf81ad11645a8e320b369abdc90a92b93f2a9178e853d9dddf82e5106
+  md5: 511fbc2c63d2c73650ad1755e4d357ba
+  depends:
+  - python >=3.10,<3.13.0a0
+  - setuptools
+  - wheel
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 1203173
+  timestamp: 1780262795392
+- conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda
+  sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e
+  md5: d7585b6550ad04c8c5e21097ada2888e
+  depends:
+  - python >=3.9
+  - python
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pluggy?source=hash-mapping
+  run_exports: {}
+  size: 25877
+  timestamp: 1764896838868
+- conda: https://conda.anaconda.org/conda-forge/noarch/pydot-4.0.1-pyhcf101f3_2.conda
+  sha256: af7213a8ca077895e7e10c8f33d5de3436b8a26828422e8a113cc59c9277a3e2
+  md5: 15f6d0866b0997c5302fc230a566bc72
+  depends:
+  - graphviz >=2.38.0
+  - pyparsing >=3.1.0
+  - python >=3.10
+  - python
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pydot?source=hash-mapping
+  run_exports: {}
+  size: 150656
+  timestamp: 1766345630713
+- conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda
+  sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86
+  md5: 16c18772b340887160c79a6acc022db0
+  depends:
+  - python >=3.10
+  license: BSD-2-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/pygments?source=hash-mapping
+  run_exports: {}
+  size: 893031
+  timestamp: 1774796815820
+- conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda
+  sha256: 417fba4783e528ee732afa82999300859b065dc59927344b4859c64aae7182de
+  md5: 3687cc0b82a8b4c17e1f0eb7e47163d5
+  depends:
+  - python >=3.10
+  - python
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pyparsing?source=hash-mapping
+  run_exports: {}
+  size: 110893
+  timestamp: 1769003998136
+- conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyh09c184e_7.conda
+  sha256: d016e04b0e12063fbee4a2d5fbb9b39a8d191b5a0042f0b8459188aedeabb0ca
+  md5: e2fd202833c4a981ce8a65974fe4abd1
+  depends:
+  - __win
+  - python >=3.9
+  - win_inet_pton
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/pysocks?source=hash-mapping
+  run_exports: {}
+  size: 21784
+  timestamp: 1733217448189
+- conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda
+  sha256: ba3b032fa52709ce0d9fd388f63d330a026754587a2f461117cac9ab73d8d0d8
+  md5: 461219d1a5bd61342293efa2c0c90eac
+  depends:
+  - __unix
+  - python >=3.9
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/pysocks?source=hash-mapping
+  run_exports: {}
+  size: 21085
+  timestamp: 1733217331982
+- conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda
+  sha256: 430051d80765207a7d782b2b188230ba1489d35c6e75fd9903f76cb9fda4af16
+  md5: 64c98a12c4e23eb238bf66bbecafdf3c
+  depends:
+  - colorama
+  - pygments >=2.7.2
+  - python >=3.10
+  - iniconfig >=1.0.1
+  - packaging >=22
+  - pluggy >=1.5,<2
+  - tomli >=1
+  - exceptiongroup >=1
+  - python
+  constrains:
+  - pytest-faulthandler >=2
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pytest?source=compressed-mapping
+  run_exports: {}
+  size: 306724
+  timestamp: 1782127176429
+- conda: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda
+  sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5
+  md5: 67d1790eefa81ed305b89d8e314c7923
+  depends:
+  - coverage >=7.10.6
+  - pluggy >=1.2
+  - pytest >=7
+  - python >=3.10
+  - python
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pytest-cov?source=hash-mapping
+  run_exports: {}
+  size: 29559
+  timestamp: 1774139250481
+- conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda
+  sha256: b7b58a5be090883198411337b99afb6404127809c3d1c9f96e99b59f36177a96
+  md5: 8375cfbda7c57fbceeda18229be10417
+  depends:
+  - execnet >=2.1
+  - pytest >=7.0.0
+  - python >=3.9
+  constrains:
+  - psutil >=3.0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pytest-xdist?source=hash-mapping
+  run_exports: {}
+  size: 39300
+  timestamp: 1751452761594
+- conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda
+  sha256: d6a17ece93bbd5139e02d2bd7dbfa80bee1a4261dced63f65f679121686bf664
+  md5: 5b8d21249ff20967101ffa321cab24e8
+  depends:
+  - python >=3.9
+  - six >=1.5
+  - python
+  license: Apache-2.0
+  license_family: APACHE
+  purls:
+  - pkg:pypi/python-dateutil?source=hash-mapping
+  run_exports: {}
+  size: 233310
+  timestamp: 1751104122689
+- conda: https://conda.anaconda.org/conda-forge/noarch/python-debian-1.1.1-pyhcf101f3_0.conda
+  sha256: d41dd30e86240157a353b7b12051b4c7fb22de8ef601ea365284ae979c4432f2
+  md5: 5dbc9d919a0c6e5e0d31fc4917042e35
+  depends:
+  - python >=3.10
+  - python
+  license: GPL-2.0-or-later
+  license_family: GPL
+  run_exports: {}
+  size: 205255
+  timestamp: 1780840107326
+- conda: https://conda.anaconda.org/conda-forge/noarch/python-flatbuffers-25.9.23-pyh1e1bc0e_0.conda
+  sha256: 1933243d9f839bb7bc6c9b75481b6445f50f8b727eb926086e8a2a347fb0467d
+  md5: 611207751a2c0b5b999b07b78985d7a0
+  depends:
+  - python >=3.10
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/flatbuffers?source=hash-mapping
+  run_exports: {}
+  size: 34827
+  timestamp: 1758880404905
+- conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_1.conda
+  sha256: 84bab2600eb7a94016f33cb580a1a1bbb9fbc2d11460a337d5d014e8151d0bdf
+  md5: 33296afcbf60357874f99aec38ead969
+  depends:
+  - cpython 3.10.20.*
+  - python_abi * *_cp310
+  license: Python-2.0
+  run_exports: {}
+  size: 51430
+  timestamp: 1781148436610
+- conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda
+  sha256: 84c129bdd6abcecac42a948f2670d17fe735d02d3a5a483a9b1f1bc33ba38c28
+  md5: 224f69f177eb5aae6c9a6052846bf609
+  depends:
+  - cpython 3.14.6.*
+  - python_abi * *_cp314
+  license: Python-2.0
+  purls: []
+  run_exports: {}
+  size: 49315
+  timestamp: 1781254664376
+- conda: https://conda.anaconda.org/conda-forge/noarch/python-magic-0.4.27-pyhd7f29a5_7.conda
+  sha256: 4750592002f9092712fe2edab7044f62bd300b80f72df921739ae04b21068cec
+  md5: a23c92c99595cf22b42fa6ee89cbd1d7
+  depends:
+  - libmagic
+  - python >=3.10
+  - python
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 19236
+  timestamp: 1781864718305
+- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda
+  build_number: 8
+  sha256: 7ad76fa396e4bde336872350124c0819032a9e8a0a40590744ff9527b54351c1
+  md5: 05e00f3b21e88bb3d658ac700b2ce58c
+  constrains:
+  - python 3.10.* *_cpython
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 6999
+  timestamp: 1752805924192
+- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda
+  build_number: 8
+  sha256: ad6d2e9ac39751cc0529dd1566a26751a0bf2542adb0c232533d32e176e21db5
+  md5: 0539938c55b6b1a59b560e843ad864a4
+  constrains:
+  - python 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 6989
+  timestamp: 1752805904792
+- conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda
+  sha256: 1715246b19c9f85ee022933b4845f2fc14ac9184981b7b7d9b728bec8e9588da
+  md5: 4a85203c1d80c1059086ae860836ffb9
+  depends:
+  - python >=3.10
+  - certifi >=2023.5.7
+  - charset-normalizer >=2,<4
+  - idna >=2.5,<4
+  - urllib3 >=1.26,<3
+  - python
+  constrains:
+  - chardet >=3.0.2,<8
+  license: Apache-2.0
+  license_family: APACHE
+  purls:
+  - pkg:pypi/requests?source=compressed-mapping
+  run_exports: {}
+  size: 68709
+  timestamp: 1778851103479
+- conda: https://conda.anaconda.org/conda-forge/noarch/reuse-6.2.0-pyhd8ed1ab_0.conda
+  sha256: a38305d0f67ecfe81eda17f8e1c3a60073db7f052552359cd3dd56faf8d6ca19
+  md5: 847eafe76be70b9126d0a6281e9e8cee
+  depends:
+  - attrs >=23.2
+  - binaryornot >=0.4.4
+  - boolean.py >=3.8
+  - chardet >=3.0.2
+  - charset-normalizer >=2.0.5
+  - click >=8.1
+  - jinja2 >=3.0.0
+  - license-expression >=21.6.14
+  - python >=3.10
+  - python-debian >=0.1.48
+  - python-magic >=0.4.12
+  - tomlkit >=0.8
+  license: GPL-3.0-or-later AND Apache-2.0 AND CC0-1.0 AND CC-BY-SA-4.0
+  run_exports: {}
+  size: 130887
+  timestamp: 1761583911756
+- conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-4.1.0-pyhd8ed1ab_0.conda
+  sha256: 30f3c04fcfb64c44d821d392a4a0b8915650dbd900c8befc20ade8fde8ec6aa2
+  md5: 0dc48b4b570931adc8641e55c6c17fe4
+  depends:
+  - python >=3.10
+  license: 0BSD OR CC0-1.0
+  purls:
+  - pkg:pypi/roman-numerals?source=hash-mapping
+  run_exports: {}
+  size: 13814
+  timestamp: 1766003022813
+- conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-py-4.1.0-pyhd8ed1ab_0.conda
+  sha256: ce21b50a412b87b388db9e8dfbf8eb16fc436c23750b29bf612ee1a74dd0beb2
+  md5: 28687768633154993d521aecfa4a56ac
+  depends:
+  - python >=3.10
+  - roman-numerals 4.1.0
+  license: 0BSD OR CC0-1.0
+  purls:
+  - pkg:pypi/roman-numerals-py?source=hash-mapping
+  run_exports: {}
+  size: 11074
+  timestamp: 1766025162370
+- conda: https://conda.anaconda.org/conda-forge/noarch/scikit-build-core-0.12.2-pyh04d0eab_0.conda
+  sha256: 56eec6250bb291c8a34c52217eb2e263e43c77b9b2cfc94e825be727d8d618e6
+  md5: 10bff9a6299a8b4e1eb8a9c70101e87a
+  depends:
+  - python >=3.8
+  - exceptiongroup >=1.0
+  - importlib-resources >=1.3
+  - packaging >=23.2
+  - pathspec >=0.12.0
+  - tomli >=1.2.2
+  - typing_extensions >=4
+  - python
+  license: Apache-2.0
+  license_family: APACHE
+  purls:
+  - pkg:pypi/scikit-build-core?source=hash-mapping
+  run_exports: {}
+  size: 223984
+  timestamp: 1781724892851
+- conda: https://conda.anaconda.org/conda-forge/noarch/sdkroot_env_osx-arm64-26.0-ha3f98da_7.conda
+  sha256: fabfe031ede99898cb2b0b805f6c0d64fcc24ecdb444de3a83002d8135bf4804
+  md5: 5f0ebbfea12d8e5bddff157e271fdb2f
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 4971
+  timestamp: 1771434195389
+- conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-81.0.0-pyh332efcf_0.conda
+  sha256: 6ecf738d5590bf228f09c4ecd1ea91d811f8e0bd9acdef341bc4d6c36beb13a3
+  md5: d629a398d7bf872f9ed7b27ab959de15
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/setuptools?source=hash-mapping
+  run_exports: {}
+  size: 676888
+  timestamp: 1770456470072
+- conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda
+  sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1
+  md5: 8e194e7b992f99a5015edbd4ebd38efd
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/setuptools?source=hash-mapping
+  run_exports: {}
+  size: 639697
+  timestamp: 1773074868565
+- conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda
+  sha256: 458227f759d5e3fcec5d9b7acce54e10c9e1f4f4b7ec978f3bfd54ce4ee9853d
+  md5: 3339e3b65d58accf4ca4fb8748ab16b3
+  depends:
+  - python >=3.9
+  - python
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/six?source=hash-mapping
+  run_exports: {}
+  size: 18455
+  timestamp: 1753199211006
+- conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-3.1.1-pyhd8ed1ab_0.conda
+  sha256: ad89284ea94821c20ff87e64b948e4afc690cf5202d14c009355b0594cf23aea
+  md5: 46b6abe31482f6bca064b965696ae807
+  depends:
+  - python >=3.10
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/snowballstemmer?source=hash-mapping
+  run_exports: {}
+  size: 74456
+  timestamp: 1780468201547
+- conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.8.4-pyhd8ed1ab_0.conda
+  sha256: 2afa5fe9331c09b4c4689ddf6ace8fc16c837eae547c57dab325b844072fdd77
+  md5: 9e21f087f087f805debe877d88e00a14
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/soupsieve?source=compressed-mapping
+  run_exports: {}
+  size: 38802
+  timestamp: 1779635534390
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-8.2.3-pyhd8ed1ab_0.conda
+  sha256: 995f58c662db0197d681fa345522fd9e7ac5f05330d3dff095ab2f102e260ab0
+  md5: f7af826063ed569bb13f7207d6f949b0
+  depends:
+  - alabaster >=0.7.14
+  - babel >=2.13
+  - colorama >=0.4.6
+  - docutils >=0.20,<0.22
+  - imagesize >=1.3
+  - jinja2 >=3.1
+  - packaging >=23.0
+  - pygments >=2.17
+  - python >=3.11
+  - requests >=2.30.0
+  - roman-numerals-py >=1.0.0
+  - snowballstemmer >=2.2
+  - sphinxcontrib-applehelp >=1.0.7
+  - sphinxcontrib-devhelp >=1.0.6
+  - sphinxcontrib-htmlhelp >=2.0.6
+  - sphinxcontrib-jsmath >=1.0.1
+  - sphinxcontrib-qthelp >=1.0.6
+  - sphinxcontrib-serializinghtml >=1.1.9
+  license: BSD-2-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/sphinx?source=hash-mapping
+  run_exports: {}
+  size: 1424416
+  timestamp: 1740956642838
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-basic-ng-1.0.0b2-pyhd8ed1ab_3.conda
+  sha256: 90d900d31afe0bd6f42cf1e529e23e6eac4284b48bc64e5e942f19f5bf8ef0f2
+  md5: a090580065b21d9c56662ebe68f6e7a6
+  depends:
+  - python >=3.9
+  - sphinx >=4.0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/sphinx-basic-ng?source=hash-mapping
+  run_exports: {}
+  size: 20495
+  timestamp: 1737748706101
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-copybutton-0.5.2-pyhd8ed1ab_1.conda
+  sha256: 8cd892e49cb4d00501bc4439fb0c73ca44905f01a65b2b7fa05ba0e8f3924f19
+  md5: bf22cb9c439572760316ce0748af3713
+  depends:
+  - python >=3.9
+  - sphinx >=1.8
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/sphinx-copybutton?source=hash-mapping
+  run_exports: {}
+  size: 17893
+  timestamp: 1734573117732
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-tabs-3.5.0-pyhd8ed1ab_0.conda
+  sha256: 9070e6f3185e8a5fa12c91ac1fcd3b288c6d724be0b589c8b8215ad5cca1e0f5
+  md5: 954d1340349f0d9aa7e9a7efb79c42dc
+  depends:
+  - docutils >=0.18.0
+  - pygments
+  - python >=3.10
+  - sphinx >=7
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/sphinx-tabs?source=hash-mapping
+  run_exports: {}
+  size: 16463
+  timestamp: 1780932961443
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-2.0.0-pyhd8ed1ab_1.conda
+  sha256: d7433a344a9ad32a680b881c81b0034bc61618d12c39dd6e3309abeffa9577ba
+  md5: 16e3f039c0aa6446513e94ab18a8784b
+  depends:
+  - python >=3.9
+  - sphinx >=5
+  license: BSD-2-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/sphinxcontrib-applehelp?source=hash-mapping
+  run_exports: {}
+  size: 29752
+  timestamp: 1733754216334
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-2.0.0-pyhd8ed1ab_1.conda
+  sha256: 55d5076005d20b84b20bee7844e686b7e60eb9f683af04492e598a622b12d53d
+  md5: 910f28a05c178feba832f842155cbfff
+  depends:
+  - python >=3.9
+  - sphinx >=5
+  license: BSD-2-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/sphinxcontrib-devhelp?source=hash-mapping
+  run_exports: {}
+  size: 24536
+  timestamp: 1733754232002
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.1.0-pyhd8ed1ab_1.conda
+  sha256: c1492c0262ccf16694bdcd3bb62aa4627878ea8782d5cd3876614ffeb62b3996
+  md5: e9fb3fe8a5b758b4aff187d434f94f03
+  depends:
+  - python >=3.9
+  - sphinx >=5
+  license: BSD-2-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/sphinxcontrib-htmlhelp?source=hash-mapping
+  run_exports: {}
+  size: 32895
+  timestamp: 1733754385092
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-1.0.1-pyhd8ed1ab_1.conda
+  sha256: 578bef5ec630e5b2b8810d898bbbf79b9ae66d49b7938bcc3efc364e679f2a62
+  md5: fa839b5ff59e192f411ccc7dae6588bb
+  depends:
+  - python >=3.9
+  license: BSD-2-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/sphinxcontrib-jsmath?source=hash-mapping
+  run_exports: {}
+  size: 10462
+  timestamp: 1733753857224
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-2.0.0-pyhd8ed1ab_1.conda
+  sha256: c664fefae4acdb5fae973bdde25836faf451f41d04342b64a358f9a7753c92ca
+  md5: 00534ebcc0375929b45c3039b5ba7636
+  depends:
+  - python >=3.9
+  - sphinx >=5
+  license: BSD-2-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/sphinxcontrib-qthelp?source=hash-mapping
+  run_exports: {}
+  size: 26959
+  timestamp: 1733753505008
+- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-2.0.0-pyhd8ed1ab_0.conda
+  sha256: 20b49741065fd7d3fabf98caf6d19b6436badb06b6d41f66b58f1fc2b52f37a1
+  md5: f77df1fcf9af03b7287342638befca77
+  depends:
+  - python >=3.10
+  - sphinx >=5
+  license: BSD-2-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/sphinxcontrib-serializinghtml?source=compressed-mapping
+  run_exports: {}
+  size: 30640
+  timestamp: 1781260357443
+- conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda
+  sha256: c47299fe37aebb0fcf674b3be588e67e4afb86225be4b0d452c7eb75c086b851
+  md5: 13dc3adbc692664cd3beabd216434749
+  depends:
+  - __glibc >=2.28
+  - kernel-headers_linux-64 4.18.0 he073ed8_9
+  - tzdata
+  license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports:
+    strong:
+    - __glibc >=2.28,<3.0.a0
+  size: 24008591
+  timestamp: 1765578833462
+- conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-aarch64-2.28-h585391f_9.conda
+  sha256: 1bd2db6b2e451247bab103e4a0128cf6c7595dd72cb26d70f7fadd9edd1d1bc3
+  md5: fdf07ab944a222ff28c754914fdb0740
+  depends:
+  - __glibc >=2.28
+  - kernel-headers_linux-aarch64 4.18.0 h05a177a_9
+  - tzdata
+  license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports:
+    strong:
+    - __glibc >=2.28,<3.0.a0
+  size: 23644746
+  timestamp: 1765578629426
+- conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda
+  sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd
+  md5: b5325cf06a000c5b14970462ff5e4d58
+  depends:
+  - python >=3.10
+  - python
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/tomli?source=hash-mapping
+  run_exports: {}
+  size: 21561
+  timestamp: 1774492402955
+- conda: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.15.0-pyha770c72_0.conda
+  sha256: 1cd52f9ccb4854c4d731438afe0e833b6b71edaf5ede661152aa98efb3a7cc70
+  md5: 42ef10a8f7f5d55a2e267c0d5daa6387
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 41169
+  timestamp: 1778423744478
+- conda: https://conda.anaconda.org/conda-forge/noarch/types-futures-3.3.8-pyhcf101f3_3.conda
+  sha256: ff1b83d6d1ca6b885b896a9f5f20c8a553815e8d861972868ceaaae1d9bfebd0
+  md5: c4d63894d2f6efe54e506206e0478d32
+  depends:
+  - python >=3.10
+  - python
+  license: Apache-2.0 AND MIT
+  purls:
+  - pkg:pypi/types-futures?source=hash-mapping
+  run_exports: {}
+  size: 15220
+  timestamp: 1779296586547
+- conda: https://conda.anaconda.org/conda-forge/noarch/types-protobuf-6.32.1.20260221-pyhcf101f3_1.conda
+  sha256: 2552a0f304737d03e6e33d0b876d62cb949b09d259e85577f044a205bfcaaaa9
+  md5: 9e9398fb4aeac7d6ce45cb5e2f86e1f7
+  depends:
+  - python >=3.10
+  - types-futures
+  - python
+  license: Apache-2.0 AND MIT
+  purls:
+  - pkg:pypi/types-protobuf?source=hash-mapping
+  run_exports: {}
+  size: 66231
+  timestamp: 1772028213517
+- conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.15.0-h396c80c_0.conda
+  sha256: 7c2df5721c742c2a47b2c8f960e718c930031663ac1174da67c1ed5999f7938c
+  md5: edd329d7d3a4ab45dcf905899a7a6115
+  depends:
+  - typing_extensions ==4.15.0 pyhcf101f3_0
+  license: PSF-2.0
+  license_family: PSF
+  purls: []
+  run_exports: {}
+  size: 91383
+  timestamp: 1756220668932
+- conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda
+  sha256: 032271135bca55aeb156cee361c81350c6f3fb203f57d024d7e5a1fc9ef18731
+  md5: 0caa1af407ecff61170c9437a808404d
+  depends:
+  - python >=3.10
+  - python
+  license: PSF-2.0
+  license_family: PSF
+  purls:
+  - pkg:pypi/typing-extensions?source=hash-mapping
+  run_exports: {}
+  size: 51692
+  timestamp: 1756220668932
+- conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda
+  sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c
+  md5: ad659d0a2b3e47e38d829aa8cad2d610
+  license: LicenseRef-Public-Domain
+  purls: []
+  run_exports: {}
+  size: 119135
+  timestamp: 1767016325805
+- conda: https://conda.anaconda.org/conda-forge/noarch/uc-micro-py-2.0.0-pyhcf101f3_0.conda
+  sha256: 9e5a0e70e876fca50de075b1cc6641cdc009a16c18f4d52ab03edb777729a1bc
+  md5: 4fdd327852ffefc83173a7c029690d0c
+  depends:
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/uc-micro-py?source=hash-mapping
+  run_exports: {}
+  size: 13378
+  timestamp: 1772479008776
+- conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.7.0-pyhd8ed1ab_0.conda
+  sha256: feff959a816f7988a0893201aa9727bbb7ee1e9cec2c4f0428269b489eb93fb4
+  md5: cbb88288f74dbe6ada1c6c7d0a97223e
+  depends:
+  - backports.zstd >=1.0.0
+  - brotli-python >=1.2.0
+  - h2 >=4,<5
+  - pysocks >=1.5.6,<2.0,!=1.5.7
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/urllib3?source=hash-mapping
+  run_exports: {}
+  size: 103560
+  timestamp: 1778188657149
+- conda: https://conda.anaconda.org/conda-forge/noarch/vswhere-3.1.7-h40126e0_1.conda
+  sha256: b72270395326dc56de9bd6ca82f63791b3c8c9e2b98e25242a9869a4ca821895
+  md5: f622897afff347b715d046178ad745a5
+  depends:
+  - __win
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 238764
+  timestamp: 1745560912727
+- conda: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda
+  sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed
+  md5: d0e3b2f0030cf4fca58bde71d246e94c
+  depends:
+  - packaging >=24.0
+  - python >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/wheel?source=hash-mapping
+  run_exports: {}
+  size: 33491
+  timestamp: 1776878563806
+- conda: https://conda.anaconda.org/conda-forge/noarch/win_inet_pton-1.1.0-pyh7428d3b_8.conda
+  sha256: 93807369ab91f230cf9e6e2a237eaa812492fe00face5b38068735858fba954f
+  md5: 46e441ba871f524e2b067929da3051c2
+  depends:
+  - __win
+  - python >=3.9
+  license: LicenseRef-Public-Domain
+  purls:
+  - pkg:pypi/win-inet-pton?source=hash-mapping
+  run_exports: {}
+  size: 9555
+  timestamp: 1733130678956
+- conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda
+  sha256: 210bd31c22bb88f5e2a167df24c95bb5f152b2ada7502f9b8c49d1f5366db423
+  md5: ba3dcdc8584155c97c648ae9c044b7a3
+  depends:
+  - python >=3.10
+  - python
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/zipp?source=compressed-mapping
+  run_exports: {}
+  size: 24190
+  timestamp: 1779159948016
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda
+  build_number: 7
+  sha256: 7acaa2e0782cad032bdaf756b536874346ac1375745fb250e9bdd6a48a7ab3cd
+  md5: a44032f282e7d2acdeb1c240308052dd
+  depends:
+  - llvm-openmp >=9.0.1
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - _openmp_mutex >=4.5
+  size: 8325
+  timestamp: 1764092507920
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ast-serialize-0.6.0-py310h3b8a9b8_0.conda
+  noarch: python
+  sha256: 0efbe4158ee4d5ff4108ad1b8c677e85eb1a8f3bb48fe2277579860d38e48315
+  md5: 9bc9209a773faadbdca5fe45d9aa9cdc
+  depends:
+  - python >=3.10
+  - __osx >=11.0
+  - _python_abi3_support 1.*
+  - cpython >=3.10
+  constrains:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/ast-serialize?source=compressed-mapping
+  run_exports: {}
+  size: 1077921
+  timestamp: 1782863843092
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/atk-1.0-2.38.0-hd03087b_2.conda
+  sha256: b0747f9b1bc03d1932b4d8c586f39a35ac97e7e72fe6e63f2b2a2472d466f3c1
+  md5: 57301986d02d30d6805fdce6c99074ee
+  depends:
+  - __osx >=11.0
+  - libcxx >=16
+  - libglib >=2.80.0,<3.0a0
+  - libintl >=0.22.5,<1.0a0
+  constrains:
+  - atk-1.0 2.38.0
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - atk-1.0 >=2.38.0
+  size: 347530
+  timestamp: 1713896411580
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-1.2.0-h7d5ae5b_1.conda
+  sha256: 422ac5c91f8ef07017c594d9135b7ae068157393d2a119b1908c7e350938579d
+  md5: 48ece20aa479be6ac9a284772827d00c
+  depends:
+  - __osx >=11.0
+  - brotli-bin 1.2.0 hc919400_1
+  - libbrotlidec 1.2.0 hc919400_1
+  - libbrotlienc 1.2.0 hc919400_1
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlicommon >=1.2.0,<1.3.0a0
+    - libbrotlienc >=1.2.0,<1.3.0a0
+    - libbrotlidec >=1.2.0,<1.3.0a0
+  size: 20237
+  timestamp: 1764018058424
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-bin-1.2.0-hc919400_1.conda
+  sha256: e2d142052a83ff2e8eab3fe68b9079cad80d109696dc063a3f92275802341640
+  md5: 377d015c103ad7f3371be1777f8b584c
+  depends:
+  - __osx >=11.0
+  - libbrotlidec 1.2.0 hc919400_1
+  - libbrotlienc 1.2.0 hc919400_1
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 18628
+  timestamp: 1764018033635
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.2.0-py314h3daef5d_1.conda
+  sha256: 5c2e471fd262fcc3c5a9d5ea4dae5917b885e0e9b02763dbd0f0d9635ed4cb99
+  md5: f9501812fe7c66b6548c7fcaa1c1f252
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - libbrotlicommon 1.2.0 hc919400_1
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/brotli?source=hash-mapping
+  run_exports: {}
+  size: 359854
+  timestamp: 1764018178608
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda
+  sha256: 540fe54be35fac0c17feefbdc3e29725cce05d7367ffedfaaa1bdda234b019df
+  md5: 620b85a3f45526a8bc4d23fd78fc22f0
+  depends:
+  - __osx >=11.0
+  license: bzip2-1.0.6
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - bzip2 >=1.0.8,<2.0a0
+  size: 124834
+  timestamp: 1771350416561
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda
+  sha256: 2995f2aed4e53725e5efbc28199b46bf311c3cab2648fc4f10c2227d6d5fa196
+  md5: bcb3cba70cf1eec964a03b4ba7775f01
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - c-ares >=1.34.6,<2.0a0
+  size: 180327
+  timestamp: 1765215064054
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-compiler-1.11.0-h61f9b84_0.conda
+  sha256: b51bd1551cfdf41500f732b4bd1e4e70fb1e74557165804a648f32fa9c671eec
+  md5: 148516e0c9edf4e9331a4d53ae806a9b
+  depends:
+  - cctools >=949.0.1
+  - clang_osx-arm64 19.*
+  - ld64 >=530
+  - llvm-openmp
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 6697
+  timestamp: 1753098737760
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.4-he0f2337_1.conda
+  sha256: cde9b79ee206fe3ba6ca2dc5906593fb7a1350515f85b2a1135a4ce8ec1539e3
+  md5: 36200ecfbbfbcb82063c87725434161f
+  depends:
+  - __osx >=11.0
+  - fontconfig >=2.15.0,<3.0a0
+  - fonts-conda-ecosystem
+  - icu >=78.1,<79.0a0
+  - libcxx >=19
+  - libexpat >=2.7.3,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libglib >=2.86.3,<3.0a0
+  - libpng >=1.6.53,<1.7.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - pixman >=0.46.4,<1.0a0
+  license: LGPL-2.1-only or MPL-1.1
+  purls: []
+  run_exports:
+    weak:
+    - cairo >=1.18.4,<2.0a0
+  size: 900035
+  timestamp: 1766416416791
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1030.6.3-llvm19_1_hd01ab73_4.conda
+  sha256: 4f408036b5175be0d2c7940250d00dae5ea7a71d194a1ffb35881fb9df6211fc
+  md5: caf7c8e48827c2ad0c402716159fe0a2
+  depends:
+  - cctools_impl_osx-arm64 1030.6.3 llvm19_1_he8a363d_4
+  - ld64 956.6 llvm19_1_he86490a_4
+  - libllvm19 >=19.1.7,<19.2.0a0
+  license: APSL-2.0
+  license_family: Other
+  purls: []
+  run_exports: {}
+  size: 24313
+  timestamp: 1768852906882
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools-1030.6.3-llvm22_1_hbe26303_4.conda
+  sha256: a8d8f9a6ae4c149d2174f8f52c61da079cc793b87e2f76441a43daf7f394631f
+  md5: aea08dd508f71d6ca3cfa4e8694e7953
+  depends:
+  - cctools_impl_osx-arm64 1030.6.3 llvm22_1_hb5e89dc_4
+  - ld64 956.6 llvm22_1_h5b97f1b_4
+  - libllvm22 >=22.1.0,<22.2.0a0
+  license: APSL-2.0
+  license_family: Other
+  run_exports: {}
+  size: 24551
+  timestamp: 1772019751097
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_impl_osx-arm64-1030.6.3-llvm19_1_he8a363d_4.conda
+  sha256: c444442e0c01de92a75b58718a100f2e272649658d4f3dd915bbfc2316b25638
+  md5: 76c651b923e048f3f3e0ecb22c966f70
+  depends:
+  - __osx >=11.0
+  - ld64_osx-arm64 >=956.6,<956.7.0a0
+  - libcxx
+  - libllvm19 >=19.1.7,<19.2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - llvm-tools 19.1.*
+  - sigtool-codesign
+  constrains:
+  - ld64 956.6.*
+  - cctools 1030.6.3.*
+  - clang 19.1.*
+  license: APSL-2.0
+  license_family: Other
+  purls: []
+  run_exports: {}
+  size: 749918
+  timestamp: 1768852866532
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_impl_osx-arm64-1030.6.3-llvm22_1_hb5e89dc_4.conda
+  sha256: 97075a1afeac8a7a4dca258ac10efb70638e3c734cbf5a6328ca1e0718e09c41
+  md5: 97768bb89683757d7e535f9b7dcba39d
+  depends:
+  - __osx >=11.0
+  - ld64_osx-arm64 >=956.6,<956.7.0a0
+  - libcxx
+  - libllvm22 >=22.1.0,<22.2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - llvm-tools 22.1.*
+  - sigtool-codesign
+  constrains:
+  - clang 22.1.*
+  - ld64 956.6.*
+  - cctools 1030.6.3.*
+  license: APSL-2.0
+  license_family: Other
+  run_exports: {}
+  size: 749166
+  timestamp: 1772019681419
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cctools_osx-arm64-1030.6.3-llvm19_1_hd01ab73_4.conda
+  sha256: 684a19ab44f3d32c668cf1f509bbac20b10f7e9990c7449a2739930915cda8b4
+  md5: 0d059c5db9d880ff37b2da53bf06509e
+  depends:
+  - cctools_impl_osx-arm64 1030.6.3 llvm19_1_he8a363d_4
+  - ld64_osx-arm64 956.6 llvm19_1_ha2625f7_4
+  constrains:
+  - cctools 1030.6.3.*
+  license: APSL-2.0
+  license_family: Other
+  purls: []
+  run_exports: {}
+  size: 23429
+  timestamp: 1772019026855
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19-19.1.7-default_hf3020a7_9.conda
+  sha256: a1449c64f455d43153036f54c68cb075a52c1d9f3350a91f4a8936ecf1675c6b
+  md5: 5a77d772c22448f6ab340fbfff55db48
+  depends:
+  - __osx >=11.0
+  - libclang-cpp19.1 19.1.7 default_hf3020a7_9
+  - libcxx >=19.1.7
+  - libllvm19 >=19.1.7,<19.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 763361
+  timestamp: 1776988759708
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-19.1.7-default_hf9bcbb7_9.conda
+  sha256: 8268c23a000cfeee1b83e19c59eb018ec07583905f69bfee01beac8aedd8c4df
+  md5: 20056c993a8c9df01e04a0e165579ec1
+  depends:
+  - cctools
+  - clang-19 19.1.7.* default_*
+  - clang_impl_osx-arm64 19.1.7 default_hc11f16d_9
+  - ld64
+  - ld64_osx-arm64 * llvm19_1_*
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 24962
+  timestamp: 1776989044302
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-22-22.1.8-default_h3bfd001_3.conda
+  sha256: 0089918b32daaa4c1ae0762309f5d5cad6549624a0d1d32de7405ebfc616914a
+  md5: 8d37f4369517317f62385cc0937b7c55
+  depends:
+  - compiler-rt22 ==22.1.8
+  - libclang-cpp22.1 ==22.1.8 default_hdca5a3d_3
+  - libcxx >=22.1.8
+  - __osx >=11.0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 927702
+  timestamp: 1782358827352
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-22.1.8-default_cfg_h4d70ba2_3.conda
+  sha256: ecdc85b0cff23f9b707b08983b30e7b63c81e474ffff41baae9fb519a021847a
+  md5: aee811a35b870553c0f6705f7d88d911
+  depends:
+  - clang-22 ==22.1.8 default_h3bfd001_3
+  - llvm-openmp >=22.1.8
+  - clang_impl_osx-arm64 ==22.1.8 default_hd222103_3
+  - cctools
+  - ld64
+  - ld64_osx-arm64 * llvm22_1_*
+  - llvm-tools ==22.1.8
+  - __osx >=11.0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 32422
+  timestamp: 1782358827352
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22-22.1.8-default_h8e162e0_2.conda
+  sha256: d45446029916b979fa42d247bb83eb4e2a2e94c4d9abdffd9bab8d6ada63b6c0
+  md5: f8abcae1bf064835016924c87602c97d
+  depends:
+  - __osx >=11.0
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libcxx >=22.1.8
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 65219
+  timestamp: 1781851544244
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22-22.1.8-default_h954c128_3.conda
+  sha256: 7a37d03da0781e7d0f1f588dd8ecf1145e2b814969d674cfbae221368686a3f0
+  md5: 601f8416ea32bdf8603167f5800735c5
+  depends:
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libcxx >=22.1.8
+  - __osx >=11.0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang13 >=22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 70814
+  timestamp: 1782358827352
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22.1.8-default_h395fef1_3.conda
+  sha256: d6aaa8cdd92a775cff4df5e9bf0198a979493d8cc6b4dad85f97469ebcf0c2b0
+  md5: f235f1f1202f001e2845f72321d6ab84
+  depends:
+  - clang ==22.1.8 default_cfg_h4d70ba2_3
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - clang-format-22 ==22.1.8 default_h954c128_3
+  - libcxx >=22.1.8
+  - __osx >=11.0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  - libclang13 >=22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 34953
+  timestamp: 1782358827352
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-format-22.1.8-default_h8e162e0_2.conda
+  sha256: 18d87c5916621ad0e2788126dd556c3db0b7c91a34bf68c78e49ab1eacf9e56d
+  md5: 12069a2e59dbe4c2491b4a0351247b29
+  depends:
+  - __osx >=11.0
+  - clang-format-22 22.1.8 default_h8e162e0_2
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libcxx >=22.1.8
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 29612
+  timestamp: 1781851594748
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-scan-deps-22.1.8-default_hdae4f07_3.conda
+  sha256: fa518bf9bc7d17ced1a56b0b80b346cf7220e7ffd624a56aaf54d8e24ac7dd09
+  md5: 3d2d8c4fe5e1e8ce8b3986aa9e6152b7
+  depends:
+  - libclang13 >=22.1.8
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libcxx >=22.1.8
+  - __osx >=11.0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 117305
+  timestamp: 1782358827352
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang-tools-22.1.8-default_h54ac4d0_3.conda
+  sha256: cdf968f0a483a265e711ecb2f02b9b2f603a97adadcf39b83bfa530bf22f255b
+  md5: 270a2a36aa5b4c8ab3fb0089ef79a4a5
+  depends:
+  - clang-format ==22.1.8 default_h395fef1_3
+  - libclang13 >=22.1.8
+  - clang-scan-deps ==22.1.8 default_hdae4f07_3
+  - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  - libcxx >=22.1.8
+  - __osx >=11.0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - libllvm22 >=22.1.8,<22.2.0a0
+  constrains:
+  - clangdev ==22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 7910112
+  timestamp: 1782358827352
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+  sha256: 56db3a98eda7032a0aefe38f146a4b29df9d75d08c71bf7f7d6412effe775dd1
+  md5: 2aec2e39be3b4999bda2a3e5bd4cd2e6
+  depends:
+  - cctools_impl_osx-arm64
+  - clang-19 19.1.7.* default_*
+  - compiler-rt 19.1.7.*
+  - compiler-rt_osx-arm64
+  - ld64_osx-arm64 * llvm19_1_*
+  - llvm-openmp >=19.1.7
+  - llvm-tools 19.1.7.*
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 24905
+  timestamp: 1776989025990
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_impl_osx-arm64-22.1.8-default_hd222103_3.conda
+  sha256: 72dae57849bf56157dc371fbcb53a56496830e3d611703602973b96a4578a98b
+  md5: 78fc1abfa6876f1844935ae3af3bae9d
+  depends:
+  - clang-22 ==22.1.8 default_h3bfd001_3
+  - compiler-rt_osx-arm64
+  - compiler-rt 22.1.8.*
+  - cctools_impl_osx-arm64
+  - ld64_osx-arm64 * llvm22_1_*
+  - __osx >=11.0
+  - libzlib >=1.3.2,<2.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 32235
+  timestamp: 1782358827352
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clang_osx-arm64-19.1.7-h75f8d18_32.conda
+  sha256: 99471b13f8b7d7de1d9302445e0d688f02ab3414aa07ede0685cbac71069ba9c
+  md5: 6335db5834eb69811c46f2c9fa2537e2
+  depends:
+  - cctools_osx-arm64
+  - clang 19.*
+  - clang_impl_osx-arm64 19.1.7.*
+  - sdkroot_env_osx-arm64
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 21196
+  timestamp: 1780546204537
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx-19.1.7-default_hc995acf_9.conda
+  sha256: 88697ecd1e5689e15c12d334bae2bb3900dffd91efd4686cd9eea9e1095ee986
+  md5: 9a1ac8e5124fcc201adb20a103d51cc6
+  depends:
+  - clang 19.1.7 default_hf9bcbb7_9
+  - clangxx_impl_osx-arm64 19.1.7.* default_*
+  - libcxx-devel 19.1.*
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 24924
+  timestamp: 1776989215095
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_impl_osx-arm64-19.1.7-default_hc11f16d_9.conda
+  sha256: 6b5ebc5f369ad5373091edc3d4c4d2e1f39169b7adb080395965646eb8aee7c9
+  md5: 8b7425e84f940861653c919142435bde
+  depends:
+  - clang-19 19.1.7.* default_*
+  - clang_impl_osx-arm64 19.1.7 default_hc11f16d_9
+  - libcxx-devel 19.1.*
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 24861
+  timestamp: 1776989199328
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/clangxx_osx-arm64-19.1.7-h75f8d18_32.conda
+  sha256: e5dee27b18e563251afaba16a4c67fdeb9eb70e838bb41e861fa0ca58247d0ff
+  md5: 5b988168322ccd3a656ddc00b6b30da1
+  depends:
+  - cctools_osx-arm64
+  - clang_osx-arm64 19.1.7 h75f8d18_32
+  - clangxx 19.*
+  - clangxx_impl_osx-arm64 19.1.7.*
+  - sdkroot_env_osx-arm64
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    strong:
+    - libcxx >=19
+  size: 20064
+  timestamp: 1780546209481
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cmake-4.3.4-h8cb302d_0.conda
+  sha256: 8c82c756a3833debe2039ab05ff4214eb0a3316a5e8b5723ac8349379ee7e30b
+  md5: c1e52ab5c9442a41abb82e0e9cce39ce
+  depends:
+  - __osx >=11.0
+  - bzip2 >=1.0.8,<2.0a0
+  - libcurl >=8.20.0,<9.0a0
+  - libcxx >=19
+  - libexpat >=2.8.1,<3.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libuv >=1.52.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ncurses >=6.6,<7.0a0
+  - rhash >=1.4.6,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 18241099
+  timestamp: 1781780578515
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-19.1.7-h855ad52_1.conda
+  sha256: b58a481828aee699db7f28bfcbbe72fb133277ac60831dfe70ee2465541bcb93
+  md5: 39451684370ae65667fa5c11222e43f7
+  depends:
+  - __osx >=11.0
+  - clang 19.1.7.*
+  - compiler-rt_osx-arm64 19.1.7.*
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 97085
+  timestamp: 1757411887557
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt-22.1.8-hce30654_1.conda
+  sha256: eb0c8aee28824932e465960e313ce41486bb17b440d8195526733044006ee4ae
+  md5: 7c0a8e9c95ac40105b4c548d992ca537
+  depends:
+  - compiler-rt22 22.1.8 hd34ed20_1
+  - libcompiler-rt 22.1.8 hd34ed20_1
+  constrains:
+  - clang 22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 16555
+  timestamp: 1781741177869
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/compiler-rt22-22.1.8-hd34ed20_1.conda
+  sha256: b7da9c52cbccfa8c2449a9e404225696f60bce30f5270fd6d7be1c5cfb5dc478
+  md5: 97912eef554a369ab285baefdf843a86
+  depends:
+  - __osx >=11.0
+  - compiler-rt22_osx-arm64 22.1.8.*
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports: {}
+  size: 99905
+  timestamp: 1781741175808
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.3-py314hf8a3a22_4.conda
+  sha256: 754ab72f1c1ae99ef7c57995f59224dc9632cbd6731fe7e6277437fd01d43156
+  md5: cddc851000ce131d757678c2f329eaad
+  depends:
+  - numpy >=1.25
+  - python
+  - python 3.14.* *_cp314
+  - __osx >=11.0
+  - libcxx >=19
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/contourpy?source=hash-mapping
+  run_exports: {}
+  size: 290405
+  timestamp: 1769156069514
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.14.3-py310hb46c203_0.conda
+  sha256: 84955228de7326b188fcfb0a9465c0af10b2da304cbe6c233c2a032b475537c8
+  md5: 7ea8141e34515df14cee891b551d799a
+  depends:
+  - __osx >=11.0
+  - python >=3.10,<3.11.0a0
+  - python >=3.10,<3.11.0a0 *_cpython
+  - python_abi 3.10.* *_cp310
+  - tomli
+  license: Apache-2.0
+  license_family: APACHE
+  run_exports: {}
+  size: 317808
+  timestamp: 1782178475278
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.14.3-py314h6e9b3f0_0.conda
+  sha256: 8de3938e100bbbd775d3b0c6d121c29e7aa2cd0024a9b5ee8023706c0b8f28e6
+  md5: cb60422148fa8d70cbb6fc290e79e21c
+  depends:
+  - __osx >=11.0
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  - tomli
+  license: Apache-2.0
+  license_family: APACHE
+  purls:
+  - pkg:pypi/coverage?source=hash-mapping
+  run_exports: {}
+  size: 417888
+  timestamp: 1782178502982
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cxx-compiler-1.11.0-h88570a1_0.conda
+  sha256: 99800d97a3a2ee9920dfc697b6d4c64e46dc7296c78b1b6c746ff1c24dea5e6c
+  md5: 043afed05ca5a0f2c18252ae4378bdee
+  depends:
+  - c-compiler 1.11.0 h61f9b84_0
+  - clangxx_osx-arm64 19.*
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 6715
+  timestamp: 1753098739952
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/epoxy-1.5.10-hc919400_2.conda
+  sha256: ba685b87529c95a4bf9de140a33d703d57dc46b036e9586ed26890de65c1c0d5
+  md5: 3b87dabebe54c6d66a07b97b53ac5874
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - epoxy >=1.5.10,<1.6.0a0
+  size: 296347
+  timestamp: 1758743805063
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.18.1-h2b252f5_0.conda
+  sha256: 8607d8d0b32f9f6fc61ea8c06b537486b78428a04516658222fa4d1d521af765
+  md5: 9d928e6a62192141fb6540a3125b1345
+  depends:
+  - __osx >=11.0
+  - libexpat >=2.8.1,<3.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libintl >=0.25.1,<1.0a0
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - fontconfig >=2.18.1,<3.0a0
+    - fonts-conda-ecosystem
+  size: 248677
+  timestamp: 1780450500773
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.14.3-hce30654_1.conda
+  sha256: 96b33f1e2a32c602b167f43719e3acf89ec742b4a1e25e99ffd0e6f99b38d277
+  md5: 7bd06ab4ed807154c2d9031eb5ebf025
+  depends:
+  - libfreetype 2.14.3 hce30654_1
+  - libfreetype6 2.14.3 hdfa99f5_1
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports:
+    weak:
+    - libfreetype >=2.14.3
+    - libfreetype6 >=2.14.3
+  size: 173518
+  timestamp: 1780933616544
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.16-hc919400_0.conda
+  sha256: d856dc6744ecfba78c5f7df3378f03a75c911aadac803fa2b41a583667b4b600
+  md5: 04bdce8d93a4ed181d1d726163c2d447
+  depends:
+  - __osx >=11.0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - fribidi >=1.0.16,<2.0a0
+  size: 59391
+  timestamp: 1757438897523
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gdk-pixbuf-2.44.7-h4e57454_0.conda
+  sha256: 69bb2e62a93f6407c9e9ccd4d21fe4d4e5373d64eecd6c5df318144ca4c80953
+  md5: f717a22e13a1499c9552ffff02d22d64
+  depends:
+  - __osx >=11.0
+  - libglib >=2.88.2,<3.0a0
+  - libintl >=0.25.1,<1.0a0
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  license: LGPL-2.1-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gdk-pixbuf >=2.44.7,<3.0a0
+  size: 553902
+  timestamp: 1782591436963
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/glib-tools-2.88.2-h246a70f_0.conda
+  sha256: 6a98eabd4d5bb902c391e9f7c9e655ce61292ff6f1bb0c592da42fd66e6c89f9
+  md5: 973a5ef252899cd0916418c75a864169
+  depends:
+  - libglib ==2.88.2 ha08bb59_0
+  - libffi
+  - __osx >=11.0
+  - libintl >=0.25.1,<1.0a0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports: {}
+  size: 205101
+  timestamp: 1782463971075
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-h7bae524_2.conda
+  sha256: 76e222e072d61c840f64a44e0580c2503562b009090f55aa45053bf1ccb385dd
+  md5: eed7278dfbab727b56f2c0b64330814b
+  depends:
+  - __osx >=11.0
+  - libcxx >=16
+  license: GPL-2.0-or-later OR LGPL-3.0-or-later
+  purls: []
+  run_exports:
+    weak:
+    - gmp >=6.3.0,<7.0a0
+  size: 365188
+  timestamp: 1718981343258
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.15-hf6b4638_0.conda
+  sha256: c0a060d7b7a05669043ef3f68c7a1025c8594e1ab73735afb64c35e8baa41da5
+  md5: 0d576cff278a2e60456d5b2c0a1ffda3
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - graphite2 >=1.3.15,<2.0a0
+  size: 82245
+  timestamp: 1780454628763
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphviz-14.1.2-hec8c438_0.conda
+  sha256: 755c72d469330265f80a615912a3b522aef6f26cbc52763862b6a3c492fbf97c
+  md5: 1f3d859de3ca2bcaa845e92e87d73660
+  depends:
+  - __osx >=11.0
+  - adwaita-icon-theme
+  - cairo >=1.18.4,<2.0a0
+  - fonts-conda-ecosystem
+  - gdk-pixbuf >=2.44.4,<3.0a0
+  - gtk3 >=3.24.43,<4.0a0
+  - gts >=0.7.6,<0.8.0a0
+  - libcxx >=19
+  - libexpat >=2.7.3,<3.0a0
+  - libgd >=2.3.3,<2.4.0a0
+  - libglib >=2.86.3,<3.0a0
+  - librsvg >=2.60.0,<3.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - pango >=1.56.4,<2.0a0
+  license: EPL-1.0
+  license_family: Other
+  purls: []
+  run_exports:
+    weak:
+    - graphviz >=14.1.2,<15.0a0
+  size: 2218284
+  timestamp: 1769427599940
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gtk3-3.24.52-hc0f3e19_0.conda
+  sha256: 26862a9898054b8552e55e609e5ce73c7ef1eb28bbe6fb87f0b9109d73cd09df
+  md5: 5557a2433b1339b8e536c264afea41ef
+  depends:
+  - __osx >=11.0
+  - atk-1.0 >=2.38.0
+  - cairo >=1.18.4,<2.0a0
+  - epoxy >=1.5.10,<1.6.0a0
+  - fribidi >=1.0.16,<2.0a0
+  - gdk-pixbuf >=2.44.5,<3.0a0
+  - glib-tools
+  - harfbuzz >=13.2.1
+  - hicolor-icon-theme
+  - libexpat >=2.7.4,<3.0a0
+  - libfreetype >=2.14.2
+  - libfreetype6 >=2.14.2
+  - libglib >=2.86.4,<3.0a0
+  - libintl >=0.25.1,<1.0a0
+  - liblzma >=5.8.2,<6.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - pango >=1.56.4,<2.0a0
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gtk3 >=3.24.52,<4.0a0
+    - adwaita-icon-theme
+  size: 9385734
+  timestamp: 1774288504338
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gts-0.7.6-he42f4ea_4.conda
+  sha256: e0f8c7bc1b9ea62ded78ffa848e37771eeaaaf55b3146580513c7266862043ba
+  md5: 21b4dd3098f63a74cf2aa9159cbef57d
+  depends:
+  - libcxx >=15.0.7
+  - libglib >=2.76.3,<3.0a0
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gts >=0.7.6,<0.8.0a0
+  size: 304331
+  timestamp: 1686545503242
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/harfbuzz-14.2.1-hce30654_1.conda
+  sha256: 8922ec1cd17f558ca38c513d4880b7fadbfa08b38a563880c8c2ceddfcc1fba2
+  md5: 95896299aa1012c7410629b2ee360f87
+  depends:
+  - libharfbuzz-devel 14.2.1 h5a65909_1
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libharfbuzz >=14.2.1
+  size: 10974
+  timestamp: 1782800588874
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/hicolor-icon-theme-0.17-hce30654_3.conda
+  sha256: 46a4958f2f916c5938f2a6dc0709f78b175ece42f601d79a04e0276d55d25d07
+  md5: cfb39109ac5fa8601eb595d66d5bf156
+  license: GPL-2.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 17616
+  timestamp: 1771539622983
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-78.3-hef89b57_0.conda
+  sha256: 3a7907a17e9937d3a46dfd41cffaf815abad59a569440d1e25177c15fd0684e5
+  md5: f1182c91c0de31a7abd40cedf6a5ebef
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - icu >=78.3,<79.0a0
+  size: 12361647
+  timestamp: 1773822915649
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.5.0-py314hf8a3a22_0.conda
+  sha256: 840de1b0ba2fa646475bc53ba0f723c8a13e66139633a070831b8279deaa7c64
+  md5: eb1465d8a644ef290d18fb86af6e9bc4
+  depends:
+  - python
+  - python 3.14.* *_cp314
+  - libcxx >=19
+  - __osx >=11.0
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/kiwisolver?source=hash-mapping
+  run_exports: {}
+  size: 69284
+  timestamp: 1773067285911
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-hfd3d5f3_1.conda
+  sha256: c740e4a2e7247776a9883158fdab50ae0732c8f67f96d8f1db8ad9da5e0b5222
+  md5: 8780f41b013d19219faef9c82260744b
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  - libedit >=3.1.20250104,<3.2.0a0
+  - libedit >=3.1.20250104,<4.0a0
+  - openssl >=3.5.7,<4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - krb5 >=1.22.2,<1.23.0a0
+  size: 1159780
+  timestamp: 1781859501654
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda
+  sha256: ccb5598fad3694e79bf54f0eb812e3b3c3dd63d1497e631f5978800eadb9bcc4
+  md5: d2f2c7c10e2957647d45589b7701a453
+  depends:
+  - __osx >=11.0
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - lcms2 >=2.19.1,<3.0a0
+  size: 213747
+  timestamp: 1780212240694
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-956.6-llvm19_1_he86490a_4.conda
+  sha256: d6197b4825ece12ab63097bd677294126439a1a6222c7098885aa23464ef280c
+  md5: 22eb76f8d98f4d3b8319d40bda9174de
+  depends:
+  - ld64_osx-arm64 956.6 llvm19_1_ha2625f7_4
+  - libllvm19 >=19.1.7,<19.2.0a0
+  constrains:
+  - cctools_osx-arm64 1030.6.3.*
+  - cctools 1030.6.3.*
+  license: APSL-2.0
+  license_family: Other
+  purls: []
+  run_exports: {}
+  size: 21592
+  timestamp: 1768852886875
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64-956.6-llvm22_1_h5b97f1b_4.conda
+  sha256: 405f08540aedb58fa070b097143b3fe0fcb2b92e3b4aca723780e2f3d754803b
+  md5: 8254e40b35e6c3159de53275801a6ebc
+  depends:
+  - ld64_osx-arm64 956.6 llvm22_1_h692d5aa_4
+  - libllvm22 >=22.1.0,<22.2.0a0
+  constrains:
+  - cctools_osx-arm64 1030.6.3.*
+  - cctools 1030.6.3.*
+  license: APSL-2.0
+  license_family: Other
+  run_exports: {}
+  size: 21907
+  timestamp: 1772019717408
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-956.6-llvm19_1_ha2625f7_4.conda
+  sha256: 4161eec579cea07903ee2fafdde6f8f9991dabd54f3ca6609a1bf75bed3dc788
+  md5: eaf3d06e3a8a10dee7565e8d76ae618d
+  depends:
+  - __osx >=11.0
+  - libcxx
+  - libllvm19 >=19.1.7,<19.2.0a0
+  - sigtool-codesign
+  - tapi >=1600.0.11.8,<1601.0a0
+  constrains:
+  - cctools_impl_osx-arm64 1030.6.3.*
+  - ld64 956.6.*
+  - cctools 1030.6.3.*
+  - clang 19.1.*
+  license: APSL-2.0
+  license_family: Other
+  purls: []
+  run_exports: {}
+  size: 1040464
+  timestamp: 1768852821767
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ld64_osx-arm64-956.6-llvm22_1_h692d5aa_4.conda
+  sha256: e4ae2ef85672c094aa3467d466f932ccdc1dda9bd4adac64f4252cc796149091
+  md5: 4c2255bf859bff6c52ed38960e3bc963
+  depends:
+  - __osx >=11.0
+  - libcxx
+  - libllvm22 >=22.1.0,<22.2.0a0
+  - sigtool-codesign
+  - tapi >=1600.0.11.8,<1601.0a0
+  constrains:
+  - clang 22.1.*
+  - ld64 956.6.*
+  - cctools_impl_osx-arm64 1030.6.3.*
+  - cctools 1030.6.3.*
+  license: APSL-2.0
+  license_family: Other
+  run_exports: {}
+  size: 1038027
+  timestamp: 1772019602406
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.1.0-h1eee2c3_0.conda
+  sha256: 66e5ffd301a44da696f3efc2f25d6d94f42a9adc0db06c44ad753ab844148c51
+  md5: 095e5749868adab9cae42d4b460e5443
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - lerc >=4.1.0,<5.0a0
+  size: 164222
+  timestamp: 1773114244984
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20250512.1-cxx17_hd41c47c_0.conda
+  sha256: 7f0ee9ae7fa2cf7ac92b0acf8047c8bac965389e48be61bf1d463e057af2ea6a
+  md5: 360dbb413ee2c170a0a684a33c4fc6b8
+  depends:
+  - __osx >=11.0
+  - libcxx >=18
+  constrains:
+  - libabseil-static =20250512.1=cxx17*
+  - abseil-cpp =20250512.1
+  license: Apache-2.0
+  license_family: Apache
+  run_exports:
+    weak:
+    - libabseil >=20250512.1,<20250513.0a0
+    - libabseil =*=cxx17*
+  size: 1174081
+  timestamp: 1750194620012
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libabseil-20260107.1-cxx17_h2062a1b_0.conda
+  sha256: 756611fbb8d2957a5b4635d9772bd8432cb6ddac05580a6284cca6fdc9b07fca
+  md5: bb65152e0d7c7178c0f1ee25692c9fd1
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  constrains:
+  - abseil-cpp =20260107.1
+  - libabseil-static =20260107.1=cxx17*
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libabseil >=20260107.1,<20260108.0a0
+    - libabseil =*=cxx17*
+  size: 1229639
+  timestamp: 1770863511331
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.11.0-8_h51639a9_openblas.conda
+  build_number: 8
+  sha256: 8f5ec18ead0619a9cf0f38b49796c22f6fc0f44850c0df2baea0f5277db16e75
+  md5: dbfe729181a32741ae63ecb41eefbac6
+  depends:
+  - libopenblas >=0.3.33,<0.3.34.0a0
+  - libopenblas >=0.3.33,<1.0a0
+  constrains:
+  - blas 2.308   openblas
+  - liblapack  3.11.0   8*_openblas
+  - liblapacke 3.11.0   8*_openblas
+  - libcblas   3.11.0   8*_openblas
+  - mkl <2027
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libblas >=3.11.0,<4.0a0
+  size: 18949
+  timestamp: 1779859141315
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.2.0-hc919400_1.conda
+  sha256: a7cb9e660531cf6fbd4148cff608c85738d0b76f0975c5fc3e7d5e92840b7229
+  md5: 006e7ddd8a110771134fcc4e1e3a6ffa
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlicommon >=1.2.0,<1.3.0a0
+  size: 79443
+  timestamp: 1764017945924
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.2.0-hc919400_1.conda
+  sha256: 2eae444039826db0454b19b52a3390f63bfe24f6b3e63089778dd5a5bf48b6bf
+  md5: 079e88933963f3f149054eec2c487bc2
+  depends:
+  - __osx >=11.0
+  - libbrotlicommon 1.2.0 hc919400_1
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlidec >=1.2.0,<1.3.0a0
+  size: 29452
+  timestamp: 1764017979099
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.2.0-hc919400_1.conda
+  sha256: 01436c32bb41f9cb4bcf07dda647ce4e5deb8307abfc3abdc8da5317db8189d1
+  md5: b2b7c8288ca1a2d71ff97a8e6a1e8883
+  depends:
+  - __osx >=11.0
+  - libbrotlicommon 1.2.0 hc919400_1
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlienc >=1.2.0,<1.3.0a0
+  size: 290754
+  timestamp: 1764018009077
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.11.0-8_hb0561ab_openblas.conda
+  build_number: 8
+  sha256: f93efcd44bc24f97c2478c7474d3baa6801a057974f330e1d06bedc33e4c778f
+  md5: 03a2ef3491da9e5b4d18c03e9f4b3109
+  depends:
+  - libblas 3.11.0 8_h51639a9_openblas
+  constrains:
+  - blas 2.308   openblas
+  - liblapack  3.11.0   8*_openblas
+  - liblapacke 3.11.0   8*_openblas
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libcblas >=3.11.0,<4.0a0
+  size: 18911
+  timestamp: 1779859147634
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp19.1-19.1.7-default_hf3020a7_9.conda
+  sha256: e05c4830a117492996bac1ad55cd7ee3e57f63b46da8a324862efbee9279ab44
+  md5: ddb70ebdcbf3a44bddc2657a51faf490
+  depends:
+  - __osx >=11.0
+  - libcxx >=19.1.7
+  - libllvm19 >=19.1.7,<19.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libclang-cpp19.1 >=19.1.7,<19.2.0a0
+  size: 14064699
+  timestamp: 1776988581784
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp22.1-22.1.8-default_hdca5a3d_3.conda
+  sha256: dcc960219fae62d99281e3767b6b3162b15aa53331ac0233c6d72ed99e5a1fbe
+  md5: 996a036eabb7a8594626fdc1cf758519
+  depends:
+  - libcxx >=22.1.8
+  - __osx >=11.0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libclang-cpp22.1 >=22.1.8,<22.2.0a0
+  size: 15930788
+  timestamp: 1782358827352
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang13-22.1.8-default_h3bfd001_3.conda
+  sha256: 3a77e5fa9899d1c93d38799a487db905d5e3f2d8f842aba76b1ac8dc3d27e39c
+  md5: 2c49f55d9c150ce54e7c0f9d21664b47
+  depends:
+  - libclang-cpp22.1 ==22.1.8 default_hdca5a3d_3
+  - libcxx >=22.1.8
+  - __osx >=11.0
+  - libllvm22 >=22.1.8,<22.2.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports:
+    weak:
+    - libclang13 >=22.1.8
+  size: 9989458
+  timestamp: 1782358827352
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcompiler-rt-22.1.8-hd34ed20_1.conda
+  sha256: e19bef885123e78e93169f2814ff1c41650ee554b0e2b2b79f7398e09803df94
+  md5: 45e4352d41a29e442f79f7708d12b655
+  depends:
+  - __osx >=11.0
+  constrains:
+  - compiler-rt >=9.0.1
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  run_exports:
+    weak:
+    - libcompiler-rt >=22.1.8
+  size: 1376251
+  timestamp: 1781741160097
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.21.0-h1359186_2.conda
+  sha256: b21aec36796a7d9b3c8b634f2d466c1d0a2658b2e57aa4686285cf4c10d5c227
+  md5: dfe89fb0539ad4611998a5c6905692ff
+  depends:
+  - __osx >=11.0
+  - krb5 >=1.22.2,<1.23.0a0
+  - libnghttp2 >=1.68.1,<2.0a0
+  - libpsl >=0.22.0,<0.23.0a0
+  - libssh2 >=1.11.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - openssl >=3.5.7,<4.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: curl
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libcurl >=8.21.0,<9.0a0
+  size: 411467
+  timestamp: 1782911970818
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda
+  sha256: a2e7abab5add9750fab064c024394de48e49f97631c605ad5db5c8ac3fc769ef
+  md5: 89f76a2a21a3ec3ec983b5eb237c4113
+  depends:
+  - __osx >=11.0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 569349
+  timestamp: 1781670209146
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-devel-19.1.7-h6dc3340_2.conda
+  sha256: ec07ebaa226792f4e2bf0f5dba50325632a7474d5f04b951d8291be70af215da
+  md5: 9f7810b7c0a731dbc84d46d6005890ef
+  depends:
+  - libcxx >=19.1.7
+  - libcxx-headers >=19.1.7,<19.1.8.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 23000
+  timestamp: 1764648270121
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdate-3.0.4-h286801f_0.conda
+  sha256: 1503b8f06ba6a173d486b7293d6a58bfca93fc0cde170fae783ff4fcb7181cb3
+  md5: 0468d5873728e5d12b6b5b6329aa1c4c
+  depends:
+  - __osx >=11.0
+  - libcxx >=18
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 43709
+  timestamp: 1748469084454
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.25-hc11a715_0.conda
+  sha256: 5e0b6961be3304a5f027a8c00bd0967fc46ae162cffb7553ff45c70f51b8314c
+  md5: a6130c709305cd9828b4e1bd9ba0000c
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libdeflate >=1.25,<1.26.0a0
+  size: 55420
+  timestamp: 1761980066242
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda
+  sha256: 66aa216a403de0bb0c1340a88d1a06adaff66bae2cfd196731aa24db9859d631
+  md5: 44083d2d2c2025afca315c7a172eab2b
+  depends:
+  - ncurses
+  - __osx >=11.0
+  - ncurses >=6.5,<7.0a0
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libedit >=3.1.20250104,<3.2.0a0
+  size: 107691
+  timestamp: 1738479560845
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda
+  sha256: 95cecb3902fbe0399c3a7e67a5bed1db813e5ab0e22f4023a5e0f722f2cc214f
+  md5: 36d33e440c31857372a72137f78bacf5
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libev >=4.33,<4.34.0a0
+  size: 107458
+  timestamp: 1702146414478
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda
+  sha256: 5af74261101e3c777399c6294b2b5d290e508153268eb2e9ff99c4d69834612f
+  md5: a915151d5d3c5bf039f5ccc8402a436f
+  depends:
+  - __osx >=11.0
+  constrains:
+  - expat 2.8.1.*
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 69362
+  timestamp: 1781203631990
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda
+  sha256: 6686a26466a527585e6a75cc2a242bf4a3d97d6d6c86424a441677917f28bec7
+  md5: 43c04d9cb46ef176bb2a4c77e324d599
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libffi >=3.5.2,<3.6.0a0
+  size: 40979
+  timestamp: 1769456747661
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_1.conda
+  sha256: d5637b01941c0fc8f5cbb1f170c238f4ee153b3c1708b9d50f4f1305438ff051
+  md5: 0582e67cd14cfed773be2f3b1aba08e0
+  depends:
+  - libfreetype6 >=2.14.3
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports: {}
+  size: 8365
+  timestamp: 1780933612390
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.3-hdfa99f5_1.conda
+  sha256: abbfffd8a8c776bb8b59a10c8247fc3aa6b17ba0051e9f6d199dca38479f214f
+  md5: a0bb0678f67c464938d3693fa96f6884
+  depends:
+  - __osx >=11.0
+  - libpng >=1.6.58,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - freetype >=2.14.3
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports: {}
+  size: 338442
+  timestamp: 1780933611662
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda
+  sha256: 06644fa4d34d57c9e48f4d84b1256f9e5f654fdb37f43acc8a58a396952d42b7
+  md5: 644058123986582db33aebd4ae2ca184
+  depends:
+  - _openmp_mutex
+  constrains:
+  - libgcc-ng ==15.2.0=*_19
+  - libgomp 15.2.0 19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 404080
+  timestamp: 1778273064154
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgd-2.3.3-h05bcc79_12.conda
+  sha256: 269edce527e204a80d3d05673301e0207efcd0dbeebc036a118ceb52690d6341
+  md5: fa4a92cfaae9570d89700a292a9ca714
+  depends:
+  - __osx >=11.0
+  - fontconfig >=2.15.0,<3.0a0
+  - fonts-conda-ecosystem
+  - icu >=78.1,<79.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libiconv >=1.18,<2.0a0
+  - libjpeg-turbo >=3.1.2,<4.0a0
+  - libpng >=1.6.53,<1.7.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  license: GD
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libgd >=2.3.3,<2.4.0a0
+  size: 159247
+  timestamp: 1766331953491
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda
+  sha256: d4837b3b9b30af3132d260225e91ab9dde83be04c59513f500cc81050fb37486
+  md5: 1ea03f87cdb1078fbc0e2b2deb63752c
+  depends:
+  - libgfortran5 15.2.0 hdae7583_19
+  constrains:
+  - libgfortran-ng ==15.2.0=*_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 139675
+  timestamp: 1778273280875
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda
+  sha256: d0a68b7a121d115b80c169e24d1265dcc25a3fe58d107df1bbc430797e226d88
+  md5: ba36d8c606a6a53fe0b8c12d47267b3d
+  depends:
+  - libgcc >=15.2.0
+  constrains:
+  - libgfortran 15.2.0
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 599691
+  timestamp: 1778273075448
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.88.2-ha08bb59_0.conda
+  sha256: 68ac66904a284a7dfbb3bdf9225380eaf20750b2d414215e6d7af5caa3ed1a63
+  md5: 03123cafdc96cef79fc8a615f9119b79
+  depends:
+  - __osx >=11.0
+  - pcre2 >=10.47,<10.48.0a0
+  - libiconv >=1.18,<2.0a0
+  - libintl >=0.25.1,<1.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - libffi >=3.5.2,<3.6.0a0
+  constrains:
+  - glib >2.66
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libglib >=2.88.2,<3.0a0
+  size: 4437447
+  timestamp: 1782463971075
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-14.2.1-h5a65909_1.conda
+  sha256: 75860db66af9748572038d1e3a2260eca56ee4b38b9523e042fac8caf4277529
+  md5: e8d6e86663316dfbdec7dac532824516
+  depends:
+  - __osx >=11.0
+  - cairo >=1.18.4,<2.0a0
+  - graphite2 >=1.3.15,<2.0a0
+  - icu >=78.3,<79.0a0
+  - libcxx >=19
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libglib >=2.88.2,<3.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 900474
+  timestamp: 1782800553099
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-devel-14.2.1-h5a65909_1.conda
+  sha256: f3f74f090b6a31fed00d64cbe6bbeed6b2a9b820442714ecb66ada08dec913ea
+  md5: e538f961a3042abf8307c5c5a6d6b09b
+  depends:
+  - __osx >=11.0
+  - cairo >=1.18.4,<2.0a0
+  - freetype
+  - graphite2 >=1.3.15,<2.0a0
+  - icu >=78.3,<79.0a0
+  - libcxx >=19
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libglib >=2.88.2,<3.0a0
+  - libharfbuzz 14.2.1 h5a65909_1
+  - libpng >=1.6.58,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libharfbuzz >=14.2.1
+  size: 1416806
+  timestamp: 1782800583113
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda
+  sha256: de0336e800b2af9a40bdd694b03870ac4a848161b35c8a2325704f123f185f03
+  md5: 4d5a7445f0b25b6a3ddbb56e790f5251
+  depends:
+  - __osx >=11.0
+  license: LGPL-2.1-only
+  purls: []
+  run_exports:
+    weak:
+    - libiconv >=1.18,<2.0a0
+  size: 750379
+  timestamp: 1754909073836
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda
+  sha256: 99d2cebcd8f84961b86784451b010f5f0a795ed1c08f1e7c76fbb3c22abf021a
+  md5: 5103f6a6b210a3912faf8d7db516918c
+  depends:
+  - __osx >=11.0
+  - libiconv >=1.18,<2.0a0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libintl >=0.25.1,<1.0a0
+  size: 90957
+  timestamp: 1751558394144
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.1.4.1-h84a0fba_0.conda
+  sha256: 17e035ae6a520ff6a6bb5dd93a4a7c3895891f4f9743bcb8c6ef607445a31cd0
+  md5: b8a7544c83a67258b0e8592ec6a5d322
+  depends:
+  - __osx >=11.0
+  constrains:
+  - jpeg <0.0.0a
+  license: IJG AND BSD-3-Clause AND Zlib
+  purls: []
+  run_exports:
+    weak:
+    - libjpeg-turbo >=3.1.4.1,<4.0a0
+  size: 555681
+  timestamp: 1775962975624
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.11.0-8_hd9741b5_openblas.conda
+  build_number: 8
+  sha256: 8a076fe82142a00fe85f5a5a5351e286e8064f0100fe13608d19182cd0018c25
+  md5: 85adeb3d469d082dbd9c8c39e36dec57
+  depends:
+  - libblas 3.11.0 8_h51639a9_openblas
+  constrains:
+  - libcblas   3.11.0   8*_openblas
+  - blas 2.308   openblas
+  - liblapacke 3.11.0   8*_openblas
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - liblapack >=3.11.0,<3.12.0a0
+  size: 18925
+  timestamp: 1779859153970
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm19-19.1.7-h8e0c9ce_2.conda
+  sha256: 46f8ff3d86438c0af1bebe0c18261ce5de9878d58b4fe399a3a125670e4f0af5
+  md5: d1d9b233830f6631800acc1e081a9444
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  - libxml2
+  - libxml2-16 >=2.14.5
+  - libzlib >=1.3.1,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libllvm19 >=19.1.7,<19.2.0a0
+  size: 26914852
+  timestamp: 1757353228286
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm22-22.1.8-h89af1be_1.conda
+  sha256: 9c0ece5160e3d8749f43f8dd86777be4cfdb51490fb32f4d8269f8fd9866ce55
+  md5: 5726aa6dda93e10bd614e434e9c9b8fc
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - libzlib >=1.3.2,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libllvm22 >=22.1.8,<22.2.0a0
+  size: 30057877
+  timestamp: 1781783269086
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda
+  sha256: 34878d87275c298f1a732c6806349125cebbf340d24c6c23727268184bba051e
+  md5: b1fd823b5ae54fbec272cea0811bd8a9
+  depends:
+  - __osx >=11.0
+  constrains:
+  - xz 5.8.3.*
+  license: 0BSD
+  purls: []
+  run_exports:
+    weak:
+    - liblzma >=5.8.3,<6.0a0
+  size: 92472
+  timestamp: 1775825802659
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmagic-5.48-h132b30e_1.conda
+  sha256: 2e242813645c2737fe9a7b3c5772f74954a922602c8d1e2dee7da9c0658b12cd
+  md5: 581313aa8da78189ac7bcdb7e31349c7
+  depends:
+  - __osx >=11.0
+  - libzlib >=1.3.2,<2.0a0
+  license: BSD-2-Clause-Darwin
+  run_exports:
+    weak:
+    - libmagic >=5.48,<6.0a0
+  size: 459752
+  timestamp: 1781763249676
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda
+  sha256: 1089c7f15d5b62c622625ec6700732ece83be8b705da8c6607f4dabb0c4bd6d2
+  md5: 57c4be259f5e0b99a5983799a228ae55
+  depends:
+  - __osx >=11.0
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 73690
+  timestamp: 1769482560514
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda
+  sha256: 2bc7bc3978066f2c274ebcbf711850cc9ab92e023e433b9631958a098d11e10a
+  md5: 6ea18834adbc3b33df9bd9fb45eaf95b
+  depends:
+  - __osx >=11.0
+  - c-ares >=1.34.6,<2.0a0
+  - libcxx >=19
+  - libev >=4.33,<4.34.0a0
+  - libev >=4.33,<5.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - openssl >=3.5.5,<4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libnghttp2 >=1.68.1,<2.0a0
+  size: 576526
+  timestamp: 1773854624224
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.33-openmp_he657e61_0.conda
+  sha256: 9dd455b2d172aeedfa2058d324b5b5822b0bc1b7c1f32cd183d7078540d2f6eb
+  md5: 909e41855c29f0d52ae630198cd57135
+  depends:
+  - __osx >=11.0
+  - libgfortran
+  - libgfortran5 >=14.3.0
+  - llvm-openmp >=19.1.7
+  constrains:
+  - openblas >=0.3.33,<0.3.34.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libopenblas >=0.3.33,<1.0a0
+  size: 4304965
+  timestamp: 1776995497368
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.58-h132b30e_0.conda
+  sha256: 66eae34546df1f098a67064970c92aa14ae7a7505091889e00468294d2882c36
+  md5: 2259ae0949dbe20c0665850365109b27
+  depends:
+  - __osx >=11.0
+  - libzlib >=1.3.2,<2.0a0
+  license: zlib-acknowledgement
+  purls: []
+  run_exports:
+    weak:
+    - libpng >=1.6.58,<1.7.0a0
+  size: 289546
+  timestamp: 1776315246750
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-6.31.1-h29102cf_5.conda
+  sha256: c1998dd33ae1229bec55c40a01cdf88bc5839cab2549f9ba21ea84472bba3242
+  md5: 9f05750adae48f79259ee79aa4b02e52
+  depends:
+  - __osx >=11.0
+  - libabseil * cxx17*
+  - libabseil >=20250512.1,<20250513.0a0
+  - libcxx >=19
+  - libzlib >=1.3.2,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports:
+    weak:
+    - libprotobuf >=6.31.1,<6.31.2.0a0
+  size: 3430992
+  timestamp: 1780004171922
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libprotobuf-6.33.5-h2d4b707_1.conda
+  sha256: 416c2244999d678dc9a4d8c3472336f8f754676125605399cf6e43956fa3d18b
+  md5: 300fdae9d7ad150a90755f55b0a8a7a8
+  depends:
+  - __osx >=11.0
+  - libabseil * cxx17*
+  - libabseil >=20260107.1,<20260108.0a0
+  - libcxx >=19
+  - libzlib >=1.3.2,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libprotobuf >=6.33.5,<6.33.6.0a0
+  size: 2768714
+  timestamp: 1780004273744
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpsl-0.22.0-hb427e8f_0.conda
+  sha256: c14b5b584dc349df5ff5f6fa114d522090a0488fcb1599df0881fd53af45010c
+  md5: 39234f5550649043b04b3d73a2017f81
+  depends:
+  - __osx >=11.0
+  - icu >=78.3,<79.0a0
+  - libcxx >=19
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libpsl >=0.22.0,<0.23.0a0
+  size: 80582
+  timestamp: 1782395387897
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libraqm-0.10.5-h45af499_1.conda
+  sha256: 7d88c506b9899d60e57f7456b02f54c7330029f2ad56c6df96357f981aa1bd96
+  md5: fa1a27aaaa10e92be48372fa01573f7c
+  depends:
+  - __osx >=11.0
+  - libharfbuzz >=14.2.1
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - fribidi >=1.0.16,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libraqm >=0.10.5,<0.11.0a0
+  size: 27026
+  timestamp: 1782807229285
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/librsvg-2.62.3-he8aa2a2_0.conda
+  sha256: f5b4fb7b6f13bbfca59613bff2e70b5a398e80727b9d0f814837ffcbc34185e1
+  md5: 6973724fadafe66ac6e4f1c55c191407
+  depends:
+  - __osx >=11.0
+  - cairo >=1.18.4,<2.0a0
+  - fontconfig >=2.18.0,<3.0a0
+  - fonts-conda-ecosystem
+  - gdk-pixbuf >=2.44.6,<3.0a0
+  - harfbuzz >=14.2.0
+  - libglib >=2.88.1,<3.0a0
+  - libxml2-16 >=2.14.6
+  - pango >=1.56.4,<2.0a0
+  constrains:
+  - __osx >=11.0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - librsvg >=2.62.3,<3.0a0
+  size: 2397567
+  timestamp: 1780452232118
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsigtool-0.1.3-h98dc951_0.conda
+  sha256: 421f7bd7caaa945d9cd5d374cc3f01e75637ca7372a32d5e7695c825a48a30d1
+  md5: c08557d00807785decafb932b5be7ef5
+  depends:
+  - __osx >=11.0
+  - openssl >=3.5.4,<4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 36416
+  timestamp: 1767045062496
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda
+  sha256: a73a8acd97a6599fd6e561514db9f101ca7fd984cdc0cfd91ba74c8aa9dbe067
+  md5: 7184d95871a58b8258a8ea124ed5aabc
+  depends:
+  - __osx >=11.0
+  - libzlib >=1.3.2,<2.0a0
+  license: blessing
+  purls: []
+  run_exports:
+    weak:
+    - libsqlite >=3.53.3,<4.0a0
+  size: 924912
+  timestamp: 1782519136322
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda
+  sha256: 8bfe837221390ffc6f111ecca24fa12d4a6325da0c8d131333d63d6c37f27e0a
+  md5: b68e8f66b94b44aaa8de4583d3d4cc40
+  depends:
+  - libzlib >=1.3.1,<2.0a0
+  - openssl >=3.5.0,<4.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libssh2 >=1.11.1,<2.0a0
+  size: 279193
+  timestamp: 1745608793272
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.1-h4030677_1.conda
+  sha256: e9248077b3fa63db94caca42c8dbc6949c6f32f94d1cafad127f9005d9b1507f
+  md5: e2a72ab2fa54ecb6abab2b26cde93500
+  depends:
+  - __osx >=11.0
+  - lerc >=4.0.0,<5.0a0
+  - libcxx >=19
+  - libdeflate >=1.25,<1.26.0a0
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - liblzma >=5.8.1,<6.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: HPND
+  purls: []
+  run_exports:
+    weak:
+    - libtiff >=4.7.1,<4.8.0a0
+  size: 373892
+  timestamp: 1762022345545
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libuv-1.52.1-h1a92334_0.conda
+  sha256: e23176af832f637693ebbb9bbe7d29c0f4cba662dabd001081d2aa6fc9f7f661
+  md5: fa9fef7d9f33724b7c3899c883c25a3e
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libuv >=1.52.1,<2.0a0
+  size: 122732
+  timestamp: 1779396113397
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.6.0-h07db88b_0.conda
+  sha256: a4de3f371bb7ada325e1f27a4ef7bcc81b2b6a330e46fac9c2f78ac0755ea3dd
+  md5: e5e7d467f80da752be17796b87fe6385
+  depends:
+  - __osx >=11.0
+  constrains:
+  - libwebp 1.6.0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libwebp-base >=1.6.0,<2.0a0
+  size: 294974
+  timestamp: 1752159906788
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda
+  sha256: bd3816218924b1e43b275863e21a3e13a5db4a6da74cca8e60bc3c213eb62f71
+  md5: af523aae2eca6dfa1c8eec693f5b9a79
+  depends:
+  - __osx >=11.0
+  - pthread-stubs
+  - xorg-libxau >=1.0.11,<2.0a0
+  - xorg-libxdmcp
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxcb >=1.17.0,<2.0a0
+  size: 323658
+  timestamp: 1727278733917
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.3-h5ef1a60_0.conda
+  sha256: ff75b84cdb9e8d123db2fa694a8ac2c2059516b6cbc98ac21fb68e235d0fd354
+  md5: 19edaa53885fc8205614b03da2482282
+  depends:
+  - __osx >=11.0
+  - icu >=78.3,<79.0a0
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - libxml2 2.15.3
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 466360
+  timestamp: 1776377102261
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.3-h6967ea9_0.conda
+  sha256: 43895a7517c055b8893531290f9dc48bd751eb04be04f14bbce3b6c71b052be6
+  md5: 6c8292c2ee808aeef2406083beaa6da7
+  depends:
+  - __osx >=11.0
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - libxml2 2.15.3
+  - icu <0.0a0
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 465820
+  timestamp: 1776377317454
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.3-h5654f7c_0.conda
+  sha256: 2fe1d8de0854342ae9cabe408b476935f82f5636e153b3b497456264dc8ff3a1
+  md5: 8e037d73747d6fe34e12d7bcac10cf21
+  depends:
+  - __osx >=11.0
+  - icu >=78.3,<79.0a0
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libxml2-16 2.15.3 h5ef1a60_0
+  - libzlib >=1.3.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxml2
+    - libxml2-16 >=2.15.3
+  size: 41102
+  timestamp: 1776377119495
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.3-heed7d32_0.conda
+  sha256: 4d9c117b2dd222cf891710d5f6a570ebb275479979843a1477ac54ed50907b40
+  md5: 0c1fdc80534d8f25fd74722aba81f044
+  depends:
+  - __osx >=11.0
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libxml2-16 2.15.3 h6967ea9_0
+  - libzlib >=1.3.2,<2.0a0
+  constrains:
+  - icu <0.0a0
+  license: MIT
+  license_family: MIT
+  run_exports:
+    weak:
+    - libxml2
+    - libxml2-16 >=2.15.3
+  size: 41663
+  timestamp: 1776377341241
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda
+  sha256: 361415a698514b19a852f5d1123c5da746d4642139904156ddfca7c922d23a05
+  md5: bc5a5721b6439f2f62a84f2548136082
+  depends:
+  - __osx >=11.0
+  constrains:
+  - zlib 1.3.2 *_2
+  license: Zlib
+  license_family: Other
+  purls: []
+  run_exports:
+    weak:
+    - libzlib >=1.3.2,<2.0a0
+  size: 47759
+  timestamp: 1774072956767
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda
+  sha256: ccbaad6bbc88f135ab849bc36af5fa6eda36a9ed18ce6f58e3dde3d11784c156
+  md5: a9c118f6343fb6301b6f3b4e94c4c562
+  depends:
+  - __osx >=11.0
+  constrains:
+  - intel-openmp <0.0a0
+  - openmp 22.1.8|22.1.8.*
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    strong:
+    - llvm-openmp >=22.1.8
+  size: 286313
+  timestamp: 1781736516782
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19-19.1.7-h91fd4e7_2.conda
+  sha256: 73f9506f7c32a448071340e73a0e8461e349082d63ecc4849e3eb2d1efc357dd
+  md5: 8237b150fcd7baf65258eef9a0fc76ef
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  - libllvm19 19.1.7 h8e0c9ce_2
+  - libzlib >=1.3.1,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 16376095
+  timestamp: 1757353442671
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-19.1.7-h855ad52_2.conda
+  sha256: 09750c33b5d694c494cad9eafda56c61a62622264173d760341b49fb001afe82
+  md5: 3e3ac06efc5fdc1aa675ca30bf7d53df
+  depends:
+  - __osx >=11.0
+  - libllvm19 19.1.7 h8e0c9ce_2
+  - llvm-tools-19 19.1.7 h91fd4e7_2
+  constrains:
+  - llvm        19.1.7
+  - llvmdev     19.1.7
+  - clang-tools 19.1.7
+  - clang       19.1.7
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  purls: []
+  run_exports: {}
+  size: 88390
+  timestamp: 1757353535760
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-22-22.1.8-hb545844_1.conda
+  sha256: a5ac8bd2fd67c6e71c991e3172c0ec8430de4ec91506e93c0f1afb56a88ed8e6
+  md5: 67a51d348fcfc95393fd0f7d92e119cf
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  - libllvm22 22.1.8 h89af1be_1
+  - libzlib >=1.3.2,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  run_exports: {}
+  size: 17832371
+  timestamp: 1781783379957
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-tools-22.1.8-hd34ed20_1.conda
+  sha256: f5933c1fee348ece7129a5e07af2c8051984ed3a3d2d5f95e4c5144e23f29f55
+  md5: 3ed593360f7932817da40db4f96f803f
+  depends:
+  - __osx >=11.0
+  - libllvm22 22.1.8 h89af1be_1
+  - llvm-tools-22 22.1.8 hb545844_1
+  constrains:
+  - llvmdev     22.1.8
+  - llvm        22.1.8
+  - clang       22.1.8
+  - clang-tools 22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  run_exports: {}
+  size: 52210
+  timestamp: 1781783441469
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lychee-0.24.2-h17e24d4_0.conda
+  sha256: f8d8397e8aa3077ebaeffdd18f7aaf0fce4188a3dbd08514ed85dc34acee4220
+  md5: 0b13f105d1195e1b388706f8eb7f0a03
+  depends:
+  - __osx >=11.0
+  - openssl >=3.5.6,<4.0a0
+  constrains:
+  - __osx >=11.0
+  license: Apache-2.0 OR MIT
+  run_exports: {}
+  size: 5382476
+  timestamp: 1777662876427
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/make-4.4.1-hc9fafa5_2.conda
+  sha256: 90ca65e788406d9029ae23ad4bd944a8b5353ad5f59bd6ce326f980cde46f37e
+  md5: 9f44ef1fea0a25d6a3491c58f3af8460
+  depends:
+  - __osx >=11.0
+  license: GPL-3.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 274048
+  timestamp: 1727801725384
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py314h6e9b3f0_1.conda
+  sha256: 411153d14ee0d98be6e3751cf5cc0502db17bce2deebebb8779e33d29d0e525f
+  md5: d33c0a15882b70255abdd54711b06a45
+  depends:
+  - __osx >=11.0
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - jinja2 >=3.0.0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/markupsafe?source=hash-mapping
+  run_exports: {}
+  size: 27256
+  timestamp: 1772445397216
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.11.0-py314he55896b_1.conda
+  sha256: 5bf2ba8c93eacbd59f9174b70fb649d697b7ee8bcffeb6b32b65de4e766454bb
+  md5: 11593c3fa1f88016c3ef29f677d0f0e6
+  depends:
+  - matplotlib-base >=3.11.0,<3.11.1.0a0
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - tornado >=5
+  license: PSF-2.0
+  license_family: PSF
+  purls: []
+  run_exports: {}
+  size: 14817
+  timestamp: 1782829699763
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.11.0-py314hf6804ef_1.conda
+  sha256: a55f1d61cb9265187477a90dd9d3b4a82a1d559d291846af5f4719815822fff4
+  md5: 839648f58bc9c220a496ad342adc34d9
+  depends:
+  - __osx >=11.0
+  - contourpy >=1.0.1
+  - cycler >=0.10
+  - fonttools >=4.22.0
+  - freetype
+  - kiwisolver >=1.3.1
+  - libcxx >=19
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libraqm >=0.10.5,<0.11.0a0
+  - numpy >=1.23
+  - numpy >=1.25,<3
+  - packaging >=20.0
+  - pillow >=8
+  - pyparsing >=2.3.1
+  - python >=3.14,<3.15.0a0
+  - python-dateutil >=2.7
+  - python_abi 3.14.* *_cp314
+  - qhull >=2020.2,<2020.3.0a0
+  license: PSF-2.0
+  license_family: PSF
+  purls:
+  - pkg:pypi/matplotlib?source=compressed-mapping
+  run_exports: {}
+  size: 8826632
+  timestamp: 1782829663874
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.5.4-np2py310h4beac76_1.conda
+  sha256: 1255152ef668f3cfc1dc972610f8027c7b373b19412e6f88b9d9b6b0e0dded40
+  md5: 715fad9dfd174fd8cf49d28c3e4742a8
+  depends:
+  - python
+  - python 3.10.* *_cpython
+  - libcxx >=19
+  - __osx >=11.0
+  - python_abi 3.10.* *_cp310
+  - numpy >=1.21,<3
+  license: MPL-2.0 AND Apache-2.0
+  run_exports: {}
+  size: 239947
+  timestamp: 1771362449782
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ml_dtypes-0.5.4-np2py314hdd732f0_1.conda
+  sha256: 8eca1e3f5ee34039302e3695b202b222d2648d111324bd6e7f7972daabbf39cb
+  md5: 9b9a9e1c375f1e26c15db657553ccfc1
+  depends:
+  - python
+  - python 3.14.* *_cp314
+  - __osx >=11.0
+  - libcxx >=19
+  - python_abi 3.14.* *_cp314
+  - numpy >=1.23,<3
+  license: MPL-2.0 AND Apache-2.0
+  purls:
+  - pkg:pypi/ml-dtypes?source=hash-mapping
+  run_exports: {}
+  size: 244117
+  timestamp: 1771362366075
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-2.1.0-py310hbc1dcdd_0.conda
+  sha256: 5ae9a18ba56906d47742061b0ebd138429b88dffddef7c1ad90dac4b59842033
+  md5: 27d80a8a48eb096fb042cd923fa5f945
+  depends:
+  - ast-serialize >=0.3.0,<1.0.0
+  - mypy_extensions >=1.0.0
+  - pathspec >=1.0.0
+  - python
+  - python-librt >=0.11.0
+  - typing_extensions >=4.6.0
+  - psutil >=4.0
+  - tomli >=1.1.0
+  - __osx >=11.0
+  - python_abi 3.10.* *_cp310
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 12466850
+  timestamp: 1780315678327
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-2.1.0-py314h2fbedac_0.conda
+  sha256: d205dc89fa338ca312ed54864ca377e9a52e4273509370c3678503115c95eb05
+  md5: 54f38ddefd5fbd675bc9ff69d7a31fd7
+  depends:
+  - ast-serialize >=0.3.0,<1.0.0
+  - mypy_extensions >=1.0.0
+  - pathspec >=1.0.0
+  - python
+  - python-librt >=0.11.0
+  - typing_extensions >=4.6.0
+  - psutil >=4.0
+  - __osx >=11.0
+  - python_abi 3.14.* *_cp314
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/mypy?source=hash-mapping
+  run_exports: {}
+  size: 13520137
+  timestamp: 1780315680928
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda
+  sha256: 4ea6c620b87bd1d42bb2ccc2c87cd2483fa2d7f9e905b14c223f11ff3f4c455d
+  md5: 343d10ed5b44030a2f67193905aea159
+  depends:
+  - __osx >=11.0
+  license: X11 AND BSD-3-Clause
+  purls: []
+  run_exports:
+    weak:
+    - ncurses >=6.6,<7.0a0
+  size: 805509
+  timestamp: 1777423252320
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ninja-1.13.2-h49c215f_0.conda
+  sha256: 18d33c17b28d4771fc0b91b7b963c9ce31aca0a9af7dc8e9ee7c974bb207192c
+  md5: 175809cc57b2c67f27a0f238bd7f069d
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  license: Apache-2.0
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 164450
+  timestamp: 1763688228613
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/nodejs-24.18.0-h654b19f_0.conda
+  sha256: 1b1fe73937452c1daf691841bd133589dee8fef8d65e866f6c9b473b386efb13
+  md5: 742523eadd11efd5e5ccf78cc3ac95e1
+  depends:
+  - libcxx >=19
+  - __osx >=12.0
+  - libnghttp2 >=1.68.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - icu >=78.3,<79.0a0
+  - c-ares >=1.34.6,<2.0a0
+  - libuv >=1.52.1,<2.0a0
+  - libbrotlicommon >=1.2.0,<1.3.0a0
+  - libbrotlienc >=1.2.0,<1.3.0a0
+  - libbrotlidec >=1.2.0,<1.3.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - openssl >=3.5.7,<4.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - nodejs >=24.18.0,<25.0a0
+  size: 16273271
+  timestamp: 1782396056933
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.23.2-py310h127c7cf_0.tar.bz2
+  sha256: 3de4d7ae79b7b0427729030afa8564099d86ce1c8db9cd867b41ba139aa0604a
+  md5: 700ef810fd7e9ef21f8393e87782b5d4
+  depends:
+  - libblas >=3.9.0,<4.0a0
+  - libcblas >=3.9.0,<4.0a0
+  - libcxx >=13.0.1
+  - liblapack >=3.9.0,<4.0a0
+  - python >=3.10,<3.11.0a0
+  - python >=3.10,<3.11.0a0 *_cpython
+  - python_abi 3.10.* *_cp310
+  constrains:
+  - numpy-base <0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports:
+    weak:
+    - numpy >=1.23.2,<2.0a0
+  size: 6196604
+  timestamp: 1660673767981
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.5.0-py314hb79c6fa_0.conda
+  sha256: dfd260fce05ff833ac121a1b1e4aa22d9c346a781c1e883dd871338cc1d9f8b0
+  md5: 5283d56d01517fa1780c72f2544e8603
+  depends:
+  - python
+  - __osx >=11.0
+  - libcxx >=19
+  - libblas >=3.9.0,<4.0a0
+  - python_abi 3.14.* *_cp314
+  - liblapack >=3.9.0,<4.0a0
+  - libcblas >=3.9.0,<4.0a0
+  constrains:
+  - numpy-base <0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/numpy?source=compressed-mapping
+  run_exports:
+    weak:
+    - numpy >=1.25,<3
+  size: 7123654
+  timestamp: 1782112549976
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.26.0-py310h5553523_0_cpu.conda
+  sha256: 8330a3784c3a87b82e84eee62cf87b1bbdd806b5e51fd9ba4263b23aedd1e531
+  md5: be46dcd506f083fbe7dfe67a806bbc9d
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  - numpy >=1.21,<3
+  - packaging
+  - protobuf
+  - python >=3.10,<3.11.0a0
+  - python-flatbuffers
+  - python_abi 3.10.* *_cp310
+  license: MIT AND BSL-1.0 AND BSD-3-Clause
+  run_exports: {}
+  size: 13277355
+  timestamp: 1778968178765
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/onnxruntime-1.26.0-py314h236feb1_0_cpu.conda
+  sha256: 10d9fca08ebe94ea0b7c6a7f25a89ed571e64f6325cf7b5928146678e82254ed
+  md5: c19e3423d016f4cab06cd33ba41cdf3c
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  - numpy >=1.23,<3
+  - packaging
+  - protobuf
+  - python >=3.14,<3.15.0a0
+  - python-flatbuffers
+  - python_abi 3.14.* *_cp314
+  license: MIT AND BSL-1.0 AND BSD-3-Clause
+  purls:
+  - pkg:pypi/onnxruntime?source=hash-mapping
+  run_exports: {}
+  size: 13716550
+  timestamp: 1778968309795
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda
+  sha256: 60aca8b9f94d06b852b296c276b3cf0efba5a6eb9f25feb8708570d3a74f00e4
+  md5: 4b5d3a91320976eec71678fad1e3569b
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  - libpng >=1.6.55,<1.7.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - openjpeg >=2.5.4,<3.0a0
+  size: 319697
+  timestamp: 1772625397692
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda
+  sha256: b3e3ca895c336d4eb91c5d2f244a312bdb59a0de8cfa0cc4c179225ab2f6bbfb
+  md5: 8187a86242741725bfa74785fe812979
+  depends:
+  - __osx >=11.0
+  - ca-certificates
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - openssl >=3.6.3,<4.0a0
+  size: 3102584
+  timestamp: 1781069820667
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pango-1.56.4-hf80efc4_1.conda
+  sha256: b57c59cf5abb06d407b3a79017b990ca5bfb10c15a10c62fc29e113f2b12d9a9
+  md5: 4b433508ebb295c05dd3d03daf27f7bb
+  depends:
+  - __osx >=11.0
+  - cairo >=1.18.4,<2.0a0
+  - fontconfig >=2.17.1,<3.0a0
+  - fonts-conda-ecosystem
+  - fribidi >=1.0.16,<2.0a0
+  - harfbuzz >=13.2.1
+  - libexpat >=2.7.4,<3.0a0
+  - libfreetype >=2.14.2
+  - libfreetype6 >=2.14.2
+  - libglib >=2.86.4,<3.0a0
+  - libpng >=1.6.55,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - pango >=1.56.4,<2.0a0
+  size: 425743
+  timestamp: 1774282709773
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.47-h30297fc_0.conda
+  sha256: 5e2e443f796f2fd92adf7978286a525fb768c34e12b1ee9ded4000a41b2894ba
+  md5: 9b4190c4055435ca3502070186eba53a
+  depends:
+  - __osx >=11.0
+  - bzip2 >=1.0.8,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - pcre2 >=10.47,<10.48.0a0
+  size: 850231
+  timestamp: 1763655726735
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-11.3.0-py310h5de80a5_3.conda
+  sha256: f81e77e125c7be7a368aa807784bdb8fe15f26c0b3944560e34a5a8c56acf8e0
+  md5: 289f10aa08eeb9a44e62fdc5c9810a7a
+  depends:
+  - python
+  - python 3.10.* *_cpython
+  - __osx >=11.0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libtiff >=4.7.0,<4.8.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - libxcb >=1.17.0,<2.0a0
+  - lcms2 >=2.17,<3.0a0
+  - openjpeg >=2.5.3,<3.0a0
+  - python_abi 3.10.* *_cp310
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - tk >=8.6.13,<8.7.0a0
+  license: HPND
+  run_exports: {}
+  size: 803755
+  timestamp: 1758208741246
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-11.3.0-py314haf93fec_3.conda
+  sha256: 2710552fd2cc5593766ad49735017216d80faf400bcd94f7998d20b192d7b726
+  md5: b5bb052b4334f4fb7aed9a774f902895
+  depends:
+  - python
+  - __osx >=11.0
+  - python 3.14.* *_cp314
+  - libwebp-base >=1.6.0,<2.0a0
+  - lcms2 >=2.17,<3.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - python_abi 3.14.* *_cp314
+  - libtiff >=4.7.0,<4.8.0a0
+  - libxcb >=1.17.0,<2.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - openjpeg >=2.5.3,<3.0a0
+  license: HPND
+  purls:
+  - pkg:pypi/pillow?source=hash-mapping
+  run_exports: {}
+  size: 992074
+  timestamp: 1758208764704
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.46.4-h81086ad_1.conda
+  sha256: 29c9b08a9b8b7810f9d4f159aecfd205fce051633169040005c0b7efad4bc718
+  md5: 17c3d745db6ea72ae2fce17e7338547f
+  depends:
+  - __osx >=11.0
+  - libcxx >=19
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - pixman >=0.46.4,<1.0a0
+  size: 248045
+  timestamp: 1754665282033
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/prek-0.4.6-h6fdd925_0.conda
+  sha256: 8579545fea611d2616495f692f7c183156ba2e2e1ce28fc57b7ae408d4ade4b2
+  md5: 67b07ce6fafdbf6de222fd6eb9e01003
+  depends:
+  - __osx >=11.0
+  constrains:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 5677093
+  timestamp: 1782881654067
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/prettier-3.9.3-h57cd9b8_0.conda
+  sha256: d29fd62828bf3f6bc2373958ba2368f255e1333be4b617e656bca8638da7cdf8
+  md5: 9be48326058aa380b7400617e73d7da6
+  depends:
+  - nodejs
+  - __osx >=11.0
+  - nodejs >=24.18.0,<25.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 1371427
+  timestamp: 1782740695269
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-6.31.1-py310hc33aa15_2.conda
+  sha256: e5d849d90feb7c4d54eda41b7f925202e0a461d6dc3b3bba92efc6bb8a136ee8
+  md5: bd10f0d9ce3b13e32e8a4275c5834119
+  depends:
+  - __osx >=11.0
+  - libabseil * cxx17*
+  - libabseil >=20250512.1,<20250513.0a0
+  - libcxx >=19
+  - libzlib >=1.3.1,<2.0a0
+  - python >=3.10,<3.11.0a0
+  - python >=3.10,<3.11.0a0 *_cpython
+  - python_abi 3.10.* *_cp310
+  constrains:
+  - libprotobuf 6.31.1
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 389400
+  timestamp: 1760394309306
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/protobuf-6.33.5-py314he407d35_2.conda
+  sha256: 1c9dc0ad0ecb8b346b8321c6c6a57cd436a0a852d02e42ce05c1ec12964cb8dd
+  md5: a667bd9984b0d39ec5d6ea5bf7f052c4
+  depends:
+  - __osx >=11.0
+  - libabseil * cxx17*
+  - libabseil >=20260107.1,<20260108.0a0
+  - libcxx >=19
+  - libzlib >=1.3.1,<2.0a0
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - libprotobuf 6.33.5
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/protobuf?source=hash-mapping
+  run_exports: {}
+  size: 473978
+  timestamp: 1773265431848
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py310haea493c_0.conda
+  sha256: f2336814f97e23cec0c6b082afecc2e9ec5941fce19f08d453e8ea53221c82ef
+  md5: 8c73aa05dd807bb9b1cdc0e028ab4f13
+  depends:
+  - python
+  - python 3.10.* *_cpython
+  - __osx >=11.0
+  - python_abi 3.10.* *_cp310
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 192483
+  timestamp: 1769678341407
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py314ha14b1ff_0.conda
+  sha256: e0f31c053eb11803d63860c213b2b1b57db36734f5f84a3833606f7c91fedff9
+  md5: fc4c7ab223873eee32080d51600ce7e7
+  depends:
+  - python
+  - __osx >=11.0
+  - python 3.14.* *_cp314
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/psutil?source=hash-mapping
+  run_exports: {}
+  size: 245502
+  timestamp: 1769678303655
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda
+  sha256: 8ed65e17fbb0ca944bfb8093b60086e3f9dd678c3448b5de212017394c247ee3
+  md5: 415816daf82e0b23a736a069a75e9da7
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 8381
+  timestamp: 1726802424786
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.20-hac0b6dc_1_cpython.conda
+  build_number: 1
+  sha256: 3c9e084162759c4029212b96147a179b0ad8076abfca85f00984d2aaa10c70f9
+  md5: 7f498ade7b9aa9e327ad23931e6c6d4a
+  depends:
+  - __osx >=11.0
+  - bzip2 >=1.0.8,<2.0a0
+  - libexpat >=2.8.1,<3.0a0
+  - libffi >=3.4,<4.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ncurses >=6.6,<7.0a0
+  - openssl >=3.5.7,<4.0a0
+  - readline >=8.3,<9.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - tzdata
+  constrains:
+  - python_abi 3.10.* *_cp310
+  license: Python-2.0
+  run_exports:
+    weak:
+    - python_abi 3.10.* *_cp310
+    noarch:
+    - python
+  size: 12888297
+  timestamp: 1781148720732
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.6-h156bc91_100_cp314.conda
+  build_number: 100
+  sha256: 984081c9fae3a3944c6f2707bbbbc70e8b961f02cdb7c640d9745e2636235632
+  md5: 4841be3d0cf616a860efc6e60af66f8b
+  depends:
+  - __osx >=11.0
+  - bzip2 >=1.0.8,<2.0a0
+  - libexpat >=2.8.1,<3.0a0
+  - libffi >=3.5.2,<3.6.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libmpdec >=4.0.0,<5.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ncurses >=6.6,<7.0a0
+  - openssl >=3.5.7,<4.0a0
+  - python_abi 3.14.* *_cp314
+  - readline >=8.3,<9.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - tzdata
+  - zstd >=1.5.7,<1.6.0a0
+  license: Python-2.0
+  purls: []
+  run_exports:
+    weak:
+    - python_abi 3.14.* *_cp314
+    noarch:
+    - python
+  size: 14059371
+  timestamp: 1781254578985
+  python_site_packages_path: lib/python3.14/site-packages
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.12.0-py310haea493c_0.conda
+  sha256: 2789d473a32a946656d4b5239b21d5be47a1474f3ec9fed77e653099417667e5
+  md5: d8ae58ffcc855f1a11a57a3aeeeba3b5
+  depends:
+  - python
+  - python 3.10.* *_cpython
+  - __osx >=11.0
+  - python_abi 3.10.* *_cp310
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 130878
+  timestamp: 1782847695667
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.12.0-py314ha14b1ff_0.conda
+  sha256: 6f2592ed0cc82de7f942af83f34b5a73598d8898322d572cafbdcaf05f9db423
+  md5: c12ed5b5eb3e12e9ba67483207199411
+  depends:
+  - python
+  - __osx >=11.0
+  - python 3.14.* *_cp314
+  - python_abi 3.14.* *_cp314
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/librt?source=hash-mapping
+  run_exports: {}
+  size: 132436
+  timestamp: 1782847578133
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.3-py314h6e9b3f0_1.conda
+  sha256: 95f385f9606e30137cf0b5295f63855fd22223a4cf024d306cf9098ea1c4a252
+  md5: dcf51e564317816cb8d546891019b3ab
+  depends:
+  - __osx >=11.0
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  - yaml >=0.2.5,<0.3.0a0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pyyaml?source=hash-mapping
+  run_exports: {}
+  size: 189475
+  timestamp: 1770223788648
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda
+  sha256: 873ac689484262a51fd79bc6103c1a1bedbf524924d7f0088fb80703042805e4
+  md5: 6483b1f59526e05d7d894e466b5b6924
+  depends:
+  - __osx >=11.0
+  - libcxx >=16
+  license: LicenseRef-Qhull
+  purls: []
+  run_exports:
+    weak:
+    - qhull >=2020.2,<2020.3.0a0
+  size: 516376
+  timestamp: 1720814307311
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda
+  sha256: a77010528efb4b548ac2a4484eaf7e1c3907f2aec86123ed9c5212ae44502477
+  md5: f8381319127120ce51e081dce4865cf4
+  depends:
+  - __osx >=11.0
+  - ncurses >=6.5,<7.0a0
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports:
+    weak:
+    - readline >=8.3,<9.0a0
+  size: 313930
+  timestamp: 1765813902568
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/rhash-1.4.6-h5505292_1.conda
+  sha256: f4957c05f4fbcd99577de8838ca4b5b1ae4b400a44be647a0159c14f85b9bfc0
+  md5: 029e812c8ae4e0d4cf6ff4f7d8dc9366
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - rhash >=1.4.6,<2.0a0
+  size: 185448
+  timestamp: 1748645057503
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.15.20-h80928e0_0.conda
+  noarch: python
+  sha256: 49c7cb7fa8bc6ad2e3448d3ea48e4e939df69690a984e768261ddc0728e40f7f
+  md5: 60e90a1347592b61888a3f26ad93035c
+  depends:
+  - python
+  - __osx >=11.0
+  constrains:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/ruff?source=compressed-mapping
+  run_exports: {}
+  size: 8539333
+  timestamp: 1782428897543
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/shellcheck-0.11.0-hecfb573_1.conda
+  sha256: 71a76120f2230e941fd943276cc9653986af4f2d47210a3b35ff13e2297c3c77
+  md5: 16c849ba724a6d59132a3b7547e2bd36
+  depends:
+  - gmp >=6.3.0,<7.0a0
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 8246556
+  timestamp: 1771525603348
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/sigtool-codesign-0.1.3-h98dc951_0.conda
+  sha256: f3d006e2441f110160a684744d90921bbedbffa247d7599d7e76b5cd048116dc
+  md5: ade77ad7513177297b1d75e351e136ce
+  depends:
+  - __osx >=11.0
+  - libsigtool 0.1.3 h98dc951_0
+  - openssl >=3.5.4,<4.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 114331
+  timestamp: 1767045086274
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/tapi-1600.0.11.8-h997e182_2.conda
+  sha256: de6893e53664e769c1b1c4103a666d436e3d307c0eb6a09a164e749d116e80f7
+  md5: 555070ad1e18b72de36e9ee7ed3236b3
+  depends:
+  - libcxx >=19.0.0.a0
+  - __osx >=11.0
+  - ncurses >=6.5,<7.0a0
+  license: NCSA
+  purls: []
+  run_exports: {}
+  size: 200192
+  timestamp: 1775657222120
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda
+  sha256: 799cab4b6cde62f91f750149995d149bc9db525ec12595e8a1d91b9317f038b3
+  md5: a9d86bc62f39b94c4661716624eb21b0
+  depends:
+  - __osx >=11.0
+  - libzlib >=1.3.1,<2.0a0
+  license: TCL
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - tk >=8.6.13,<8.7.0a0
+  size: 3127137
+  timestamp: 1769460817696
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.5.7-py314h6c2aa35_0.conda
+  sha256: 1a4f3d940cf239acde2fc61674b7cf80219a7f22a369e92b95b245be2d47caf1
+  md5: cc1d84777343f00f01c08a2d9550f639
+  depends:
+  - __osx >=11.0
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/tornado?source=hash-mapping
+  run_exports: {}
+  size: 915857
+  timestamp: 1781007345425
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/typos-1.48.0-h6fdd925_0.conda
+  sha256: 1d9e347d6ce66bbb0486d97f1799ffde92c068b9b7bbd0f249941c736f5db12b
+  md5: c679568be20dfa9f4bd979d010636be2
+  depends:
+  - __osx >=11.0
+  constrains:
+  - __osx >=11.0
+  license: MIT OR Apache-2.0
+  purls: []
+  run_exports: {}
+  size: 2712152
+  timestamp: 1782859631187
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/unicodedata2-17.0.1-py314h6c2aa35_0.conda
+  sha256: 09bfbee5a2bcf4df06f21a2aa9eb40a7af97864a569beb5ea85fd6baf6e03ce7
+  md5: 4fffb3ba871bb05f34ffb705534dfef5
+  depends:
+  - __osx >=11.0
+  - python >=3.14,<3.15.0a0
+  - python >=3.14,<3.15.0a0 *_cp314
+  - python_abi 3.14.* *_cp314
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/unicodedata2?source=hash-mapping
+  run_exports: {}
+  size: 416130
+  timestamp: 1770909728445
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-hc919400_1.conda
+  sha256: adae11db0f66f86156569415ed79cda75b2dbf4bea48d1577831db701438164f
+  md5: 78b548eed8227a689f93775d5d23ae09
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxau >=1.0.12,<2.0a0
+  size: 14105
+  timestamp: 1762976976084
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hc919400_1.conda
+  sha256: f7fa0de519d8da589995a1fe78ef74556bb8bc4172079ae3a8d20c3c81354906
+  md5: 9d1299ace1924aa8f4e0bc8e71dd0cf7
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxdmcp >=1.1.5,<2.0a0
+  size: 19156
+  timestamp: 1762977035194
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h925e9cb_3.conda
+  sha256: b03433b13d89f5567e828ea9f1a7d5c5d697bf374c28a4168d71e9464f5dafac
+  md5: 78a0fe9e9c50d2c381e8ee47e3ea437d
+  depends:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - yaml >=0.2.5,<0.3.0a0
+  size: 83386
+  timestamp: 1753484079473
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zizmor-1.26.1-h6fdd925_0.conda
+  sha256: 74c822773b26e16f04cbb728b433e0aef1e3805701599e8ef7efc025567068b9
+  md5: 63d017476d41cd928d9aebd7204e70cc
+  depends:
+  - __osx >=11.0
+  constrains:
+  - __osx >=11.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 6385904
+  timestamp: 1782024402677
+- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda
+  sha256: 9485ba49e8f47d2b597dd399e88f4802e100851b27c21d7525625b0b4025a5d9
+  md5: ab136e4c34e97f34fb621d2592a393d8
+  depends:
+  - __osx >=11.0
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - zstd >=1.5.7,<1.6.0a0
+  size: 433413
+  timestamp: 1764777166076
+- conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-20_gnu.conda
+  build_number: 20
+  sha256: 8a1cee28bd0ee7451ada1cd50b64720e57e17ff994fc62dd8329bef570d382e4
+  md5: 1626967b574d1784b578b52eaeb071e7
+  depends:
+  - libgomp >=7.5.0
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  constrains:
+  - openmp_impl <0.0a0
+  - msys2-conda-epoch <0.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    strong:
+    - _openmp_mutex >=4.5
+  size: 52252
+  timestamp: 1770943776666
+- conda: https://conda.anaconda.org/conda-forge/win-64/ast-serialize-0.6.0-py310ha413424_0.conda
+  noarch: python
+  sha256: b01a994de3afb922ec5dc07627cb2daa09b4c4b6983644016f3f8bd7abebfc9f
+  md5: 76c848548ac90971be931212647a2639
+  depends:
+  - python >=3.10
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - _python_abi3_support 1.*
+  - cpython >=3.10
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/ast-serialize?source=compressed-mapping
+  run_exports: {}
+  size: 1075388
+  timestamp: 1782863865593
+- conda: https://conda.anaconda.org/conda-forge/win-64/brotli-1.2.0-h2d644bc_1.conda
+  sha256: a4fffdf1c9b9d3d0d787e20c724cff3a284dfa3773f9ce609c93b1cfd0ce8933
+  md5: bc58fdbced45bb096364de0fba1637af
+  depends:
+  - brotli-bin 1.2.0 hfd05255_1
+  - libbrotlidec 1.2.0 hfd05255_1
+  - libbrotlienc 1.2.0 hfd05255_1
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlicommon >=1.2.0,<1.3.0a0
+    - libbrotlienc >=1.2.0,<1.3.0a0
+    - libbrotlidec >=1.2.0,<1.3.0a0
+  size: 20342
+  timestamp: 1764017988883
+- conda: https://conda.anaconda.org/conda-forge/win-64/brotli-bin-1.2.0-hfd05255_1.conda
+  sha256: e76966232ef9612de33c2087e3c92c2dc42ea5f300050735a3c646f33bce0429
+  md5: 6abd7089eb3f0c790235fe469558d190
+  depends:
+  - libbrotlidec 1.2.0 hfd05255_1
+  - libbrotlienc 1.2.0 hfd05255_1
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 22714
+  timestamp: 1764017952449
+- conda: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.2.0-py314he701e3d_1.conda
+  sha256: 6854ee7675135c57c73a04849c29cbebc2fb6a3a3bfee1f308e64bf23074719b
+  md5: 1302b74b93c44791403cbeee6a0f62a3
+  depends:
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - libbrotlicommon 1.2.0 hfd05255_1
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/brotli?source=hash-mapping
+  run_exports: {}
+  size: 335782
+  timestamp: 1764018443683
+- conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda
+  sha256: 76dfb71df5e8d1c4eded2dbb5ba15bb8fb2e2b0fe42d94145d5eed4c75c35902
+  md5: 4cb8e6b48f67de0b018719cdf1136306
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: bzip2-1.0.6
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - bzip2 >=1.0.8,<2.0a0
+  size: 56115
+  timestamp: 1771350256444
+- conda: https://conda.anaconda.org/conda-forge/win-64/c-compiler-1.11.0-h528c1b4_0.conda
+  sha256: 55e04bd4af61500cb8cae064386be57d18fbfdf676655ff1c97c7e5d146c6e34
+  md5: 6d994ff9ab924ba11c2c07e93afbe485
+  depends:
+  - vs2022_win-64
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 6938
+  timestamp: 1753098808371
+- conda: https://conda.anaconda.org/conda-forge/win-64/cairo-1.18.4-h477c42c_1.conda
+  sha256: 9ee4ad706c5d3e1c6c469785d60e3c2b263eec569be0eac7be33fbaef978bccc
+  md5: 52ea1beba35b69852d210242dd20f97d
+  depends:
+  - fontconfig >=2.15.0,<3.0a0
+  - fonts-conda-ecosystem
+  - icu >=78.1,<79.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libglib >=2.86.3,<3.0a0
+  - libpng >=1.6.53,<1.7.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - pixman >=0.46.4,<1.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: LGPL-2.1-only or MPL-1.1
+  purls: []
+  run_exports:
+    weak:
+    - cairo >=1.18.4,<2.0a0
+  size: 1537783
+  timestamp: 1766416059188
+- conda: https://conda.anaconda.org/conda-forge/win-64/clang-22-22.1.8-default_hac490eb_2.conda
+  sha256: 92defdaa5eb6ccce723a7a714a8eee6b1ec72c3f7962d2df2fd0053d0511c461
+  md5: a5f13b4d9572ac8eb20ac43b97184ef7
+  depends:
+  - compiler-rt22 22.1.8.*
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  run_exports: {}
+  size: 77070410
+  timestamp: 1781848680122
+- conda: https://conda.anaconda.org/conda-forge/win-64/clang-22-22.1.8-default_hf735972_3.conda
+  sha256: ce4984f7b7fa5d89490eaf9b29875147f03b5b7e5db439d4a64830d2ccba5d26
+  md5: b8631a672bf2d36f4825c4e8f46549fe
+  depends:
+  - compiler-rt22 ==22.1.8
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libzlib >=1.3.2,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 88370037
+  timestamp: 1782358781159
+- conda: https://conda.anaconda.org/conda-forge/win-64/clang-22.1.8-default_nocfg_haf066c4_3.conda
+  sha256: 2b061c90f380e745daf80b57184a152fafa7f7d4bb95aef23ad97a4ce5c710ba
+  md5: 9dd27ded16864c055959f4005fec1561
+  depends:
+  - clang-22 ==22.1.8 default_hf735972_3
+  - llvm-openmp >=22.1.8
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libzlib >=1.3.2,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  track_features:
+  - clang-p-0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 131252162
+  timestamp: 1782358781159
+- conda: https://conda.anaconda.org/conda-forge/win-64/clang-22.1.8-default_nocfg_hbb9487a_2.conda
+  sha256: a626a7e6781301a55d29bd2c1d2c78ed94d70a05675e36c109bf0039bad6e8ff
+  md5: fc81fbe066684d91ee9bd2c7db966498
+  depends:
+  - clang-22 22.1.8 default_hac490eb_2
+  - libzlib >=1.3.2,<2.0a0
+  - llvm-openmp >=22.1.8
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  run_exports: {}
+  size: 114419551
+  timestamp: 1781848773142
+- conda: https://conda.anaconda.org/conda-forge/win-64/clang-format-22.1.8-default_h5ef374e_3.conda
+  sha256: c36e5c0a5b5c94fb93fb92c27b01cbbd164f4eef1051dcf4970c04712039242d
+  md5: 4598699c8c461822d0c59a742b4050bb
+  depends:
+  - clang ==22.1.8 default_nocfg_haf066c4_3
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libzlib >=1.3.2,<2.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - zstd >=1.5.7,<1.6.0a0
+  - libclang13 >=22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 1397228
+  timestamp: 1782358781159
+- conda: https://conda.anaconda.org/conda-forge/win-64/clang-format-22.1.8-default_hac490eb_2.conda
+  sha256: e3884322c0460fa2398788a5136c812b2d94e162306613a1220f4007f4e0addd
+  md5: 57f723dfd8eba6b61531b732f177d86a
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  run_exports: {}
+  size: 1262598
+  timestamp: 1781849003358
+- conda: https://conda.anaconda.org/conda-forge/win-64/clang-tools-22.1.8-default_hac490eb_2.conda
+  sha256: 09410e6af2a467e282140b1d60430c0be9945401541b874d05adf3ce6eb32ea2
+  md5: 4d702cd8fe571f3a99327029f0eb096e
+  depends:
+  - clang-format 22.1.8 default_hac490eb_2
+  - libclang13 >=22.1.8
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - zstd >=1.5.7,<1.6.0a0
+  constrains:
+  - clangdev 22.1.8
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: Apache
+  run_exports: {}
+  size: 312203540
+  timestamp: 1781849070978
+- conda: https://conda.anaconda.org/conda-forge/win-64/cmake-4.3.4-hdcbee5b_0.conda
+  sha256: 801d2c3ef0f3c45d21f770111f09530605cee81b731d542b7b9b2b59113f5c8e
+  md5: 8f84cf399e79375aa137b5fc3e44d34c
+  depends:
+  - bzip2 >=1.0.8,<2.0a0
+  - libcurl >=8.20.0,<9.0a0
+  - libexpat >=2.8.1,<3.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libuv >=1.52.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc14_runtime >=14.44.35208
+  - zstd >=1.5.7,<1.6.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 16094559
+  timestamp: 1781780435452
+- conda: https://conda.anaconda.org/conda-forge/win-64/compiler-rt22-22.1.8-h49e36cd_1.conda
+  sha256: 1ec6404811bd76e8b64f9f9462bedb535b8b2faf140bc416638d30e3fe61028f
+  md5: 433cea77bbbc99853e305c4ef6f0a082
+  depends:
+  - compiler-rt22_win-64 22.1.8.*
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 3682146
+  timestamp: 1781741845936
+- conda: https://conda.anaconda.org/conda-forge/win-64/contourpy-1.3.3-py314hf309875_4.conda
+  sha256: f141bcbf8e490b49b2f53f517173d13a64d75e43cfae170e0d931cb0b66f4bce
+  md5: c26934035616f7d578f9da0491aed3d8
+  depends:
+  - numpy >=1.25
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/contourpy?source=hash-mapping
+  run_exports: {}
+  size: 247437
+  timestamp: 1769155978556
+- conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.14.3-py310hdb0e946_0.conda
+  sha256: 920a457a997e0d406ef3ddc523c0f6e71b9ae820f067cb4f8c921d2236a2dd34
+  md5: 1902f106da2e2c74a630106eb46cbac0
+  depends:
+  - python >=3.10,<3.11.0a0
+  - python_abi 3.10.* *_cp310
+  - tomli
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Apache-2.0
+  license_family: APACHE
+  run_exports: {}
+  size: 342590
+  timestamp: 1782178172908
+- conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.14.3-py314h2359020_0.conda
+  sha256: 1879a89f00d90166db5d3eaa455aa329f5a2fbeab5662630548e477047074125
+  md5: 2d2497e3c3b759375810139e7ccc0328
+  depends:
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - tomli
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Apache-2.0
+  license_family: APACHE
+  purls:
+  - pkg:pypi/coverage?source=hash-mapping
+  run_exports: {}
+  size: 443224
+  timestamp: 1782178194098
+- conda: https://conda.anaconda.org/conda-forge/win-64/cxx-compiler-1.11.0-h1c1089f_0.conda
+  sha256: c888f4fe9ec117c1c01bfaa4c722ca475ebbb341c92d1718afa088bb0d710619
+  md5: 4d94d3c01add44dc9d24359edf447507
+  depends:
+  - vs2022_win-64
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 6957
+  timestamp: 1753098809481
+- conda: https://conda.anaconda.org/conda-forge/win-64/double-conversion-3.4.0-hac47afa_0.conda
+  sha256: 09e30a170e0da3e9847d449b594b5e55e6ae2852edd3a3680e05753a5e015605
+  md5: 3d3caf4ccc6415023640af4b1b33060a
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - double-conversion >=3.4.0,<3.5.0a0
+  size: 70943
+  timestamp: 1765193243911
+- conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.18.1-hd47e2ca_0.conda
+  sha256: 9217184c4a8e82101b0e512b059ae3ff67e3913133b9031edad89ab5341284e4
+  md5: abd79bad98c99c1a116154d6de74ea89
+  depends:
+  - libexpat >=2.8.1,<3.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libiconv >=1.18,<2.0a0
+  - libintl >=0.22.5,<1.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - fontconfig >=2.18.1,<3.0a0
+    - fonts-conda-ecosystem
+  size: 202630
+  timestamp: 1780450217840
+- conda: https://conda.anaconda.org/conda-forge/win-64/freetype-2.14.3-h57928b3_1.conda
+  sha256: a0e419e96146159f12344c870dca608d11bca36841f228092b986ffc2e1e0f02
+  md5: e77293b32225b136a8be300f93d0e89f
+  depends:
+  - libfreetype 2.14.3 h57928b3_1
+  - libfreetype6 2.14.3 hdbac1cb_1
+  - zlib
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports:
+    weak:
+    - libfreetype >=2.14.3
+    - libfreetype6 >=2.14.3
+  size: 185584
+  timestamp: 1780934817461
+- conda: https://conda.anaconda.org/conda-forge/win-64/fribidi-1.0.16-hfd05255_0.conda
+  sha256: 15011071ee56c216ffe276c8d734427f1f893f275ef733f728d13f610ed89e6e
+  md5: c27bd87e70f970010c1c6db104b88b18
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - fribidi >=1.0.16,<2.0a0
+  size: 64394
+  timestamp: 1757438741305
+- conda: https://conda.anaconda.org/conda-forge/win-64/getopt-win32-0.1-h6a83c73_3.conda
+  sha256: d04c4a6c11daa72c4a0242602e1d00c03291ef66ca2d7cd0e171088411d57710
+  md5: 49c36fcad2e9af6b91e91f2ce5be8ebd
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  license: LGPL-3.0-only
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - getopt-win32 >=0.1,<0.1.1.0a0
+  size: 26238
+  timestamp: 1750744808182
+- conda: https://conda.anaconda.org/conda-forge/win-64/glib-2.88.2-h395db07_0.conda
+  sha256: b67107959a71dbf9f5c2e95511f18095d9ac6f0001f0de4a1b6e14282162989e
+  md5: 7d203837b88a2255b32dca555d37ca50
+  depends:
+  - python *
+  - packaging
+  - libglib ==2.88.2 h7ce1215_0
+  - glib-tools ==2.88.2 h74ecf4c_0
+  - libintl-devel
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libintl >=0.22.5,<1.0a0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libglib >=2.88.2,<3.0a0
+  size: 75973
+  timestamp: 1782463965040
+- conda: https://conda.anaconda.org/conda-forge/win-64/glib-tools-2.88.2-h74ecf4c_0.conda
+  sha256: c604b6ca42c6271f281b1c0616e0d50bd800f8fc913a91a2753c2551b3b6b16c
+  md5: 63c615f0c525ee64f72e557e583b6257
+  depends:
+  - libglib ==2.88.2 h7ce1215_0
+  - libffi
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libintl >=0.22.5,<1.0a0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports: {}
+  size: 251644
+  timestamp: 1782463965040
+- conda: https://conda.anaconda.org/conda-forge/win-64/graphite2-1.3.15-hac47afa_0.conda
+  sha256: 88b6601f8edae59834b59b521e293ff3b58361dc1603240f5a8328c24e6936ad
+  md5: ff9a9bfe791f56b0227597a7651a6af0
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - graphite2 >=1.3.15,<2.0a0
+  size: 97308
+  timestamp: 1780454389458
+- conda: https://conda.anaconda.org/conda-forge/win-64/graphviz-14.1.2-h4c50273_0.conda
+  sha256: 58f83755509a19501a9efe40c484727ffa61fcfaf6a237870678a79638fa6982
+  md5: afabed4c46b197b89eb974aa038d12db
+  depends:
+  - cairo >=1.18.4,<2.0a0
+  - getopt-win32 >=0.1,<0.1.1.0a0
+  - gts >=0.7.6,<0.8.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libgd >=2.3.3,<2.4.0a0
+  - libglib >=2.86.3,<3.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - pango >=1.56.4,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: EPL-1.0
+  license_family: Other
+  purls: []
+  run_exports:
+    weak:
+    - graphviz >=14.1.2,<15.0a0
+  size: 1223547
+  timestamp: 1769427507016
+- conda: https://conda.anaconda.org/conda-forge/win-64/gts-0.7.6-h6b5321d_4.conda
+  sha256: b79755d2f9fc2113b6949bfc170c067902bc776e2c20da26e746e780f4f5a2d4
+  md5: a41f14768d5e377426ad60c613f2923b
+  depends:
+  - libglib >=2.76.3,<3.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.2,<15
+  - vc14_runtime >=14.29.30139
+  license: LGPL-2.0-or-later
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - gts >=0.7.6,<0.8.0a0
+  size: 188688
+  timestamp: 1686545648050
+- conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-14.2.1-h57928b3_1.conda
+  sha256: c8bf564f2c415b82f056eff98b8967fb75c86821398998f20289397b5acf1ef7
+  md5: e706de885f817f9832c56f1c9ad7ce71
+  depends:
+  - libharfbuzz-devel 14.2.1 h03b5201_1
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libharfbuzz >=14.2.1
+  size: 11542
+  timestamp: 1782801047786
+- conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.3-h637d24d_0.conda
+  sha256: 1bda728d70a619731b278c859eda364146cb5b4b8c739a64da8128353d81d1c4
+  md5: 0097b24800cb696915c3dbd1f5335d3f
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - icu >=78.3,<79.0a0
+  size: 14954024
+  timestamp: 1773822508646
+- conda: https://conda.anaconda.org/conda-forge/win-64/kiwisolver-1.5.0-py314hf309875_0.conda
+  sha256: 37cbc49fd7255532d09fb3bc9cc699554693e632fa90678a9b3d0ed12557d0d7
+  md5: 0508c8dabeab91311e5c59b5e3f6d278
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/kiwisolver?source=hash-mapping
+  run_exports: {}
+  size: 73330
+  timestamp: 1773067062280
+- conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h719d79b_1.conda
+  sha256: c55745796e762ba9e817ab1fc0f21f1a049e202f90fa762df39578f37923f6c2
+  md5: 00335c2c4a98656554771aaf6f1a7400
+  depends:
+  - openssl >=3.5.7,<4.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - krb5 >=1.22.2,<1.23.0a0
+  size: 750320
+  timestamp: 1781859644591
+- conda: https://conda.anaconda.org/conda-forge/win-64/lcms2-2.19.1-hf2c6c5f_1.conda
+  sha256: 5ed63a32639a130564a870becb679fd52dfb816666a61ed3c023917389010480
+  md5: 1df4012c8a2478699d07bc26af66d41e
+  depends:
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - lcms2 >=2.19.1,<3.0a0
+  size: 523194
+  timestamp: 1780211799997
+- conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.1.0-hd936e49_0.conda
+  sha256: 45df58fca800b552b17c3914cc9ab0d55a82c5172d72b5c44a59c710c06c5473
+  md5: 54b231d595bc1ff9bff668dd443ee012
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - lerc >=4.1.0,<5.0a0
+  size: 172395
+  timestamp: 1773113455582
+- conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20250512.1-cxx17_habfad5f_0.conda
+  sha256: 78790771f44e146396d9ae92efbe1022168295afd8d174f653a1fa16f0f0fa32
+  md5: d6a4cd236fc1c69a1cfc9698fb5e391f
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.42.34438
+  constrains:
+  - libabseil-static =20250512.1=cxx17*
+  - abseil-cpp =20250512.1
+  license: Apache-2.0
+  license_family: Apache
+  run_exports:
+    weak:
+    - libabseil >=20250512.1,<20250513.0a0
+    - libabseil =*=cxx17*
+  size: 1615210
+  timestamp: 1750194549591
+- conda: https://conda.anaconda.org/conda-forge/win-64/libabseil-20260107.1-cxx17_h0eb2380_0.conda
+  sha256: 7e7f3754f8afaabd946dc11d7c00fd1dc93f0388a2d226a7abf1bf07deab0e2b
+  md5: 60da39dd5fd93b2a4a0f986f3acc2520
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - libabseil-static =20260107.1=cxx17*
+  - abseil-cpp =20260107.1
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - libabseil >=20260107.1,<20260108.0a0
+    - libabseil =*=cxx17*
+  size: 1884784
+  timestamp: 1770863303486
+- conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-8_h8455456_mkl.conda
+  build_number: 8
+  sha256: 43a87b59e6d4c68d80b2e4de487b1b54d66fe1f9a06636909b5a5ab9eae27269
+  md5: 4a0ce24b1a946ff77ae9eaa7ef015a33
+  depends:
+  - mkl >=2026.0.0,<2027.0a0
+  constrains:
+  - libcblas   3.11.0   8*_mkl
+  - liblapacke 3.11.0   8*_mkl
+  - blas 2.308   mkl
+  - liblapack  3.11.0   8*_mkl
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libblas >=3.11.0,<4.0a0
+  size: 68103
+  timestamp: 1779859688049
+- conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlicommon-1.2.0-hfd05255_1.conda
+  sha256: 5097303c2fc8ebf9f9ea9731520aa5ce4847d0be41764edd7f6dee2100b82986
+  md5: 444b0a45bbd1cb24f82eedb56721b9c4
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlicommon >=1.2.0,<1.3.0a0
+  size: 82042
+  timestamp: 1764017799966
+- conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlidec-1.2.0-hfd05255_1.conda
+  sha256: 3239ce545cf1c32af6fffb7fc7c75cb1ef5b6ea8221c66c85416bb2d46f5cccb
+  md5: 450e3ae947fc46b60f1d8f8f318b40d4
+  depends:
+  - libbrotlicommon 1.2.0 hfd05255_1
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlidec >=1.2.0,<1.3.0a0
+  size: 34449
+  timestamp: 1764017851337
+- conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlienc-1.2.0-hfd05255_1.conda
+  sha256: 3226df6b7df98734440739f75527d585d42ca2bfe912fbe8d1954c512f75341a
+  md5: ccd93cfa8e54fd9df4e83dbe55ff6e8c
+  depends:
+  - libbrotlicommon 1.2.0 hfd05255_1
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libbrotlienc >=1.2.0,<1.3.0a0
+  size: 252903
+  timestamp: 1764017901735
+- conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-8_h2a3cdd5_mkl.conda
+  build_number: 8
+  sha256: 2a5b6555b481df4603e44cba49a6ef727584fd2f3c5235dd4bcb3028fffbdfb5
+  md5: 09f1d8e4d2675d34ad2acb115211d10c
+  depends:
+  - libblas 3.11.0 8_h8455456_mkl
+  constrains:
+  - liblapacke 3.11.0   8*_mkl
+  - blas 2.308   mkl
+  - liblapack  3.11.0   8*_mkl
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libcblas >=3.11.0,<4.0a0
+  size: 68443
+  timestamp: 1779859701498
+- conda: https://conda.anaconda.org/conda-forge/win-64/libclang13-22.1.8-default_hf735972_3.conda
+  sha256: 34a25466769d1233d8f36a78d5f9f40279bae3fc4b70852acbd04b159ac4d183
+  md5: c45c5a60b68368f62415941c1d9f0ab7
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libzlib >=1.3.2,<2.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - zstd >=1.5.7,<1.6.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libclang13 >=22.1.8
+  size: 34917944
+  timestamp: 1782358781159
+- conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.21.0-h51a1c48_2.conda
+  sha256: e9a9231e6c04b82979a6a1a4f90b8a697dc3a42884e709dee8ba5d0355b45296
+  md5: 88c875a8f34785d6f6185ceb646154fa
+  depends:
+  - krb5 >=1.22.2,<1.23.0a0
+  - libpsl >=0.22.0,<0.23.0a0
+  - libssh2 >=1.11.1,<2.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: curl
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libcurl >=8.21.0,<9.0a0
+  size: 404786
+  timestamp: 1782911887650
+- conda: https://conda.anaconda.org/conda-forge/win-64/libdate-3.0.4-he0c23c2_0.conda
+  sha256: 095249e1e993704819253e5154ff6572f079489fa1d906b5bc514d222600251b
+  md5: 647e1b99f6c0d30e6a1af02b7d04ccc4
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.2,<15
+  - vc14_runtime >=14.29.30139
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 43783
+  timestamp: 1748469112346
+- conda: https://conda.anaconda.org/conda-forge/win-64/libdeflate-1.25-h51727cc_0.conda
+  sha256: 834e4881a18b690d5ec36f44852facd38e13afe599e369be62d29bd675f107ee
+  md5: e77030e67343e28b084fabd7db0ce43e
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libdeflate >=1.25,<1.26.0a0
+  size: 156818
+  timestamp: 1761979842440
+- conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda
+  sha256: 1a54d874addda73b6f7164d5f3905821277a1831bcc05edd74b3085391688571
+  md5: ccc490c81ffe14181861beac0e8f3169
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - expat 2.8.1.*
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 71631
+  timestamp: 1781203724164
+- conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda
+  sha256: 59d01f2dfa8b77491b5888a5ab88ff4e1574c9359f7e229da254cdfe27ddc190
+  md5: 720b39f5ec0610457b725eb3f396219a
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libffi >=3.5.2,<3.6.0a0
+  size: 45831
+  timestamp: 1769456418774
+- conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.3-h57928b3_1.conda
+  sha256: 035d0c67bf9f7a16f4a1764f420c120f1a995d071bb265fcc66ef688ef709d7b
+  md5: e45b52fb9a81c9e2708465a706e05952
+  depends:
+  - libfreetype6 >=2.14.3
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports: {}
+  size: 8711
+  timestamp: 1780934891782
+- conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.3-hdbac1cb_1.conda
+  sha256: 0bbd19c9f7c4d0232b31892e6a4d1f82b8d19d1b84d89725f1f491b336447758
+  md5: 4e4d54f9f98383d977ba56ef39ebf46d
+  depends:
+  - libpng >=1.6.58,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - freetype >=2.14.3
+  license: GPL-2.0-only OR FTL
+  purls: []
+  run_exports: {}
+  size: 340411
+  timestamp: 1780934813224
+- conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.2.0-h8ee18e1_19.conda
+  sha256: 80e80ef5e31b00b12539db3c5aaecde60dab91381abfc1060e323d5c3b016dce
+  md5: cc5d690fc1c629038f13c68e88e65f44
+  depends:
+  - _openmp_mutex >=4.5
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  constrains:
+  - msys2-conda-epoch <0.0a0
+  - libgcc-ng ==15.2.0=*_19
+  - libgomp 15.2.0 h8ee18e1_19
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 821854
+  timestamp: 1778273037795
+- conda: https://conda.anaconda.org/conda-forge/win-64/libgd-2.3.3-h4974f7c_12.conda
+  sha256: 9ab562c718bd3fcef5f6189c8e2730c3d9321e05f13749a611630475d41207fc
+  md5: 3a5b40267fcd31f1ba3a24014fe92044
+  depends:
+  - fontconfig >=2.15.0,<3.0a0
+  - fonts-conda-ecosystem
+  - icu >=78.1,<79.0a0
+  - libexpat >=2.7.3,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libjpeg-turbo >=3.1.2,<4.0a0
+  - libpng >=1.6.53,<1.7.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - xorg-libxpm >=3.5.17,<4.0a0
+  license: GD
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libgd >=2.3.3,<2.4.0a0
+  size: 166711
+  timestamp: 1766331770351
+- conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.88.2-h7ce1215_0.conda
+  sha256: 20d4a182b8aa1d71b331579fae281bb3ccb1a199257ce15fadc53786031a7408
+  md5: 5be116480ef34a5646894d7f7cd7ae41
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libintl >=0.22.5,<1.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - libiconv >=1.18,<2.0a0
+  - pcre2 >=10.47,<10.48.0a0
+  - libffi >=3.5.2,<3.6.0a0
+  constrains:
+  - glib >2.66
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libglib >=2.88.2,<3.0a0
+  size: 4518265
+  timestamp: 1782463965040
+- conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.2.0-h8ee18e1_19.conda
+  sha256: 4dc958ced2fc7f42bc675b07e2c9abe3e150875ffdf62ca551d94fc6facf1fd7
+  md5: f1147651e3fdd585e2f442c0c2fc8f2d
+  depends:
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  constrains:
+  - msys2-conda-epoch <0.0a0
+  license: GPL-3.0-only WITH GCC-exception-3.1
+  license_family: GPL
+  purls: []
+  run_exports:
+    strong:
+    - _openmp_mutex >=4.5
+    - libgomp >=15.2.0
+  size: 664640
+  timestamp: 1778272979661
+- conda: https://conda.anaconda.org/conda-forge/win-64/libharfbuzz-14.2.1-h03b5201_1.conda
+  sha256: 634a64cf43f1ce5a4139334bcdbde54d6854ae33d881ae1774377965e21051a5
+  md5: 005469a341088900ca235892d3154c24
+  depends:
+  - cairo >=1.18.4,<2.0a0
+  - graphite2 >=1.3.15,<2.0a0
+  - icu >=78.3,<79.0a0
+  - libexpat >=2.8.1,<3.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libglib >=2.88.2,<3.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 1008194
+  timestamp: 1782801000396
+- conda: https://conda.anaconda.org/conda-forge/win-64/libharfbuzz-devel-14.2.1-h03b5201_1.conda
+  sha256: d04bac65245bf76ae23a18148b941d8215085d38a6d391971966ccda8a996b99
+  md5: de077ebf9cbc0c1da6510fdf1bbc6baa
+  depends:
+  - cairo >=1.18.4,<2.0a0
+  - freetype
+  - glib
+  - graphite2 >=1.3.15,<2.0a0
+  - icu >=78.3,<79.0a0
+  - libexpat >=2.8.1,<3.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libglib >=2.88.2,<3.0a0
+  - libharfbuzz 14.2.1 h03b5201_1
+  - libpng >=1.6.58,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libharfbuzz >=14.2.1
+  size: 321750
+  timestamp: 1782801035822
+- conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.13.0-default_h049141e_1000.conda
+  sha256: 2ee12e37223dfcd0acd050c80a91150c482b6e2899198521e1800dce66662467
+  md5: 6a01c986e30292c715038d2788aa1385
+  depends:
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libhwloc >=2.13.0,<2.13.1.0a0
+  size: 2396128
+  timestamp: 1770954127918
+- conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda
+  sha256: 0dcdb1a5f01863ac4e8ba006a8b0dc1a02d2221ec3319b5915a1863254d7efa7
+  md5: 64571d1dd6cdcfa25d0664a5950fdaa2
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: LGPL-2.1-only
+  purls: []
+  run_exports:
+    weak:
+    - libiconv >=1.18,<2.0a0
+  size: 696926
+  timestamp: 1754909290005
+- conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda
+  sha256: c7e4600f28bcada8ea81456a6530c2329312519efcf0c886030ada38976b0511
+  md5: 2cf0cf76cc15d360dfa2f17fd6cf9772
+  depends:
+  - libiconv >=1.17,<2.0a0
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libintl >=0.22.5,<1.0a0
+  size: 95568
+  timestamp: 1723629479451
+- conda: https://conda.anaconda.org/conda-forge/win-64/libintl-devel-0.22.5-h5728263_3.conda
+  sha256: be1f3c48bc750bca7e68955d57180dfd826d6f9fa7eb32994f6cb61b813f9a6a
+  md5: 7537784e9e35399234d4007f45cdb744
+  depends:
+  - libiconv >=1.17,<2.0a0
+  - libintl 0.22.5 h5728263_3
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - libintl >=0.22.5,<1.0a0
+  size: 40746
+  timestamp: 1723629745649
+- conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.1.4.1-hfd05255_0.conda
+  sha256: 698d57b5b90120270eaa401298319fcb25ea186ae95b340c2f4813ed9171083d
+  md5: 25a127bad5470852b30b239f030ec95b
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - jpeg <0.0.0a
+  license: IJG AND BSD-3-Clause AND Zlib
+  purls: []
+  run_exports:
+    weak:
+    - libjpeg-turbo >=3.1.4.1,<4.0a0
+  size: 842806
+  timestamp: 1775962811457
+- conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-8_hf9ab0e9_mkl.conda
+  build_number: 8
+  sha256: 44999ed04bc0a56de44ee0ac8bd5b3702efd411a8b29491c0e3d3deb8619c94e
+  md5: d584799b920ecae9b75a2b70743a3de7
+  depends:
+  - libblas 3.11.0 8_h8455456_mkl
+  constrains:
+  - libcblas   3.11.0   8*_mkl
+  - liblapacke 3.11.0   8*_mkl
+  - blas 2.308   mkl
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - liblapack >=3.11.0,<3.12.0a0
+  size: 81027
+  timestamp: 1779859714698
+- conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda
+  sha256: d636d1a25234063642f9c531a7bb58d84c1c496411280a36ea000bd122f078f1
+  md5: 8f83619ab1588b98dd99c90b0bfc5c6d
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - xz 5.8.3.*
+  license: 0BSD
+  purls: []
+  run_exports:
+    weak:
+    - liblzma >=5.8.3,<6.0a0
+  size: 106486
+  timestamp: 1775825663227
+- conda: https://conda.anaconda.org/conda-forge/win-64/libmagic-5.48-h94ac8d1_1.conda
+  sha256: b4a66cc3aeac63227e4de130e0035c315567507b64212717fc2e2de51d6ded77
+  md5: 2508fa3f92321e18b6072f264f3e7270
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - pcre2 >=10.47,<10.48.0a0
+  license: BSD-2-Clause-Darwin
+  run_exports:
+    weak:
+    - libmagic >=5.48,<6.0a0
+  size: 487559
+  timestamp: 1781792863553
+- conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda
+  sha256: 40dcd0b9522a6e0af72a9db0ced619176e7cfdb114855c7a64f278e73f8a7514
+  md5: e4a9fc2bba3b022dad998c78856afe47
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 89411
+  timestamp: 1769482314283
+- conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.58-h7351971_0.conda
+  sha256: 218913aeee391460bd0e341b834dbd9c6fa6ae0a4276c0c300266cc99a816a28
+  md5: 52f1280563f3b48b5f75414cd2d15dd1
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libzlib >=1.3.2,<2.0a0
+  license: zlib-acknowledgement
+  purls: []
+  run_exports:
+    weak:
+    - libpng >=1.6.58,<1.7.0a0
+  size: 385227
+  timestamp: 1776315248638
+- conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-6.31.1-h2ec36af_5.conda
+  sha256: f7a0fa886ac988dc78d34898c6b5b92f0e612002837f2f3f61e1a54e30754a06
+  md5: 14ebe738986c601b677b060fbe1df575
+  depends:
+  - libabseil * cxx17*
+  - libabseil >=20250512.1,<20250513.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports:
+    weak:
+    - libprotobuf >=6.31.1,<6.31.2.0a0
+  size: 7799743
+  timestamp: 1780005667741
+- conda: https://conda.anaconda.org/conda-forge/win-64/libprotobuf-6.33.5-h6cf2d3c_1.conda
+  sha256: dce2820ebc4059b4919158814aa6ea2ccd31be699d9e3d74824de8d31ec66864
+  md5: 712686431de276d81eb02d87483f6f10
+  depends:
+  - libabseil * cxx17*
+  - libabseil >=20260107.1,<20260108.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libprotobuf >=6.33.5,<6.33.6.0a0
+  size: 7162612
+  timestamp: 1780005438640
+- conda: https://conda.anaconda.org/conda-forge/win-64/libpsl-0.22.0-hc1744f7_0.conda
+  sha256: b08fa3b66fbd9fea91c8d4cfa34568ea0b1e59636172e33349797fe7ef8a5611
+  md5: 6865b9bb1584e633c436c1196bcc4ed0
+  depends:
+  - icu >=78.3,<79.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libpsl >=0.22.0,<0.23.0a0
+  size: 85552
+  timestamp: 1782394903537
+- conda: https://conda.anaconda.org/conda-forge/win-64/libraqm-0.10.5-h50d6d30_1.conda
+  sha256: 79ca55f7202daa560bffafcf7aef435e48618fe91a5243b8e4a6ed4edfbe63bc
+  md5: e5ab537cdd3462f26be2803209142913
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libharfbuzz >=14.2.1
+  - fribidi >=1.0.16,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libraqm >=0.10.5,<0.11.0a0
+  size: 29296
+  timestamp: 1782807186901
+- conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda
+  sha256: 692dfb73a22c873656d5e393b8f1e2b019a3c8a6486c97cb6900552e64e38c25
+  md5: 051f1b2228e7517a2ef8cca5146c8967
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: blessing
+  purls: []
+  run_exports:
+    weak:
+    - libsqlite >=3.53.3,<4.0a0
+  size: 1315909
+  timestamp: 1782519131898
+- conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda
+  sha256: cbdf93898f2e27cefca5f3fe46519335d1fab25c4ea2a11b11502ff63e602c09
+  md5: 9dce2f112bfd3400f4f432b3d0ac07b2
+  depends:
+  - libzlib >=1.3.1,<2.0a0
+  - openssl >=3.5.0,<4.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.2,<15
+  - vc14_runtime >=14.29.30139
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libssh2 >=1.11.1,<2.0a0
+  size: 292785
+  timestamp: 1745608759342
+- conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.1-h8f73337_1.conda
+  sha256: f1b8cccaaeea38a28b9cd496694b2e3d372bb5be0e9377c9e3d14b330d1cba8a
+  md5: 549845d5133100142452812feb9ba2e8
+  depends:
+  - lerc >=4.0.0,<5.0a0
+  - libdeflate >=1.25,<1.26.0a0
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - liblzma >=5.8.1,<6.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - zstd >=1.5.7,<1.6.0a0
+  license: HPND
+  purls: []
+  run_exports:
+    weak:
+    - libtiff >=4.7.1,<4.8.0a0
+  size: 993166
+  timestamp: 1762022118895
+- conda: https://conda.anaconda.org/conda-forge/win-64/libuv-1.52.1-h6a83c73_0.conda
+  sha256: ca55710ece8736785ffa0fad4d45402dd40992a81a045d69eda5d40bc1a288f9
+  md5: 741d96e586ac833409e5d27cdae08d15
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libuv >=1.52.1,<2.0a0
+  size: 331213
+  timestamp: 1779396042250
+- conda: https://conda.anaconda.org/conda-forge/win-64/libvulkan-loader-1.4.341.0-h477610d_0.conda
+  sha256: 0f0965edca8b255187604fc7712c53fe9064b31a1845a7dfb2b63bf660de84a7
+  md5: 804880b2674119b84277d6c16b01677d
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  constrains:
+  - libvulkan-headers 1.4.341.0.*
+  license: Apache-2.0
+  license_family: APACHE
+  purls: []
+  run_exports:
+    weak:
+    - libvulkan-loader >=1.4.341.0,<2.0a0
+  size: 282251
+  timestamp: 1770077165680
+- conda: https://conda.anaconda.org/conda-forge/win-64/libwebp-base-1.6.0-h4d5522a_0.conda
+  sha256: 7b6316abfea1007e100922760e9b8c820d6fc19df3f42fb5aca684cfacb31843
+  md5: f9bbae5e2537e3b06e0f7310ba76c893
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - libwebp 1.6.0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - libwebp-base >=1.6.0,<2.0a0
+  size: 279176
+  timestamp: 1752159543911
+- conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_10.conda
+  sha256: 0fccf2d17026255b6e10ace1f191d0a2a18f2d65088fd02430be17c701f8ffe0
+  md5: 8a86073cf3b343b87d03f41790d8b4e5
+  depends:
+  - ucrt
+  constrains:
+  - pthreads-win32 <0.0a0
+  - msys2-conda-epoch <0.0a0
+  license: MIT AND BSD-3-Clause-Clear
+  purls: []
+  run_exports: {}
+  size: 36621
+  timestamp: 1759768399557
+- conda: https://conda.anaconda.org/conda-forge/win-64/libxcb-1.17.0-h0e4246c_0.conda
+  sha256: 08dec73df0e161c96765468847298a420933a36bc4f09b50e062df8793290737
+  md5: a69bbf778a462da324489976c84cfc8c
+  depends:
+  - libgcc >=13
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - pthread-stubs
+  - ucrt >=10.0.20348.0
+  - xorg-libxau >=1.0.11,<2.0a0
+  - xorg-libxdmcp
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxcb >=1.17.0,<2.0a0
+  size: 1208687
+  timestamp: 1727279378819
+- conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h3cfd58e_0.conda
+  sha256: 3b61ee3caba702d2ff432fa3920835db963026e5c99c4e6fdca0c6114f59e7ce
+  md5: 9e8dd0d90ed830107b2c36801035b7db
+  depends:
+  - icu >=78.3,<79.0a0
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - libxml2 2.15.3
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 519871
+  timestamp: 1776376969852
+- conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h692994f_0.conda
+  sha256: 8038084c60eda2006d0122d05e3364fe8db0a18935ca6ed0168b5ba5aa33f904
+  md5: f7d6fcda29570e20851b78d92ea2154e
+  depends:
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - libxml2 2.15.3
+  - icu <0.0a0
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 518869
+  timestamp: 1776376971242
+- conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-h8ef44ab_0.conda
+  sha256: a4599c6bbbbdd7db570896e520c557eec8e66d94e839a59d17dc1f24a3d5f82b
+  md5: 95591ca5671d2213f5b2d5aa7818420d
+  depends:
+  - icu >=78.3,<79.0a0
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libxml2-16 2.15.3 h3cfd58e_0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxml2
+    - libxml2-16 >=2.15.3
+  size: 43684
+  timestamp: 1776376992865
+- conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-hbc0d294_0.conda
+  sha256: da68af9d9d28d65a6916db1bef68f8a25c64c4fdcf759f32a2d2f2f143220adf
+  md5: e3b5acbb857a12f5d59e8d174bc536c0
+  depends:
+  - libiconv >=1.18,<2.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libxml2-16 2.15.3 h692994f_0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - icu <0.0a0
+  license: MIT
+  license_family: MIT
+  run_exports:
+    weak:
+    - libxml2
+    - libxml2-16 >=2.15.3
+  size: 43916
+  timestamp: 1776376994334
+- conda: https://conda.anaconda.org/conda-forge/win-64/libxslt-1.1.43-h0fbe4c1_1.conda
+  sha256: 13da38939c2c20e7112d683ab6c9f304bfaf06230a2c6a7cf00359da1a003ec7
+  md5: 46034d9d983edc21e84c0b36f1b4ba61
+  depends:
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - libxslt >=1.1.43,<2.0a0
+  size: 420223
+  timestamp: 1757963935611
+- conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda
+  sha256: 88609816e0cc7452bac637aaf65783e5edf4fee8a9f8e22bdc3a75882c536061
+  md5: dbabbd6234dea34040e631f87676292f
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - zlib 1.3.2 *_2
+  license: Zlib
+  license_family: Other
+  purls: []
+  run_exports:
+    weak:
+    - libzlib >=1.3.2,<2.0a0
+  size: 58347
+  timestamp: 1774072851498
+- conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda
+  sha256: 50c02902bb516eeb56680358f052be38b5bf74b40e78ea4b2a675e84957e7307
+  md5: de3551bf6508d45ca46b714639e52823
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - openmp 22.1.8|22.1.8.*
+  - intel-openmp <0.0a0
+  license: Apache-2.0 WITH LLVM-exception
+  license_family: APACHE
+  purls: []
+  run_exports:
+    strong:
+    - llvm-openmp >=22.1.8
+  size: 348002
+  timestamp: 1781737042070
+- conda: https://conda.anaconda.org/conda-forge/win-64/lychee-0.24.2-hb3eb754_0.conda
+  sha256: 826077733e3c251831d7b7c9cdb27da4b661044363343c5614527a618cd94d40
+  md5: f06076ddc8c0f46c64900f1c8b479325
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - openssl >=3.5.6,<4.0a0
+  license: Apache-2.0 OR MIT
+  run_exports: {}
+  size: 6020917
+  timestamp: 1777662847120
+- conda: https://conda.anaconda.org/conda-forge/win-64/make-4.4.1-h0e40799_2.conda
+  sha256: a810cdca3d5fa50d562cda23c0c1195b45ff5f9b0c41e0d4c8c2dd3c043ff4f2
+  md5: 77ff648ad9fec660f261aa8ab0949f62
+  depends:
+  - libgcc >=13
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - ucrt >=10.0.20348.0
+  license: GPL-3.0-or-later
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 2176937
+  timestamp: 1727802346950
+- conda: https://conda.anaconda.org/conda-forge/win-64/markupsafe-3.0.3-py314h2359020_1.conda
+  sha256: 02805a0f3cd168dbf13afc5e4aed75cc00fe538ce143527a6471485b36f5887c
+  md5: 8de7b40f8b30a8fcaa423c2537fe4199
+  depends:
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - jinja2 >=3.0.0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/markupsafe?source=hash-mapping
+  run_exports: {}
+  size: 30022
+  timestamp: 1772445159549
+- conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-3.11.0-py314h86ab7b2_1.conda
+  sha256: 280067b6b6dd6cef3125c517933ce4bd442a957fffa3ae0ca518379ba04c0fb6
+  md5: 3aef2aea79e121dde8f8432ad8180a77
+  depends:
+  - matplotlib-base >=3.11.0,<3.11.1.0a0
+  - pyside6 >=6.7.2
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - tornado >=5
+  license: PSF-2.0
+  license_family: PSF
+  purls: []
+  run_exports: {}
+  size: 15319
+  timestamp: 1782829747462
+- conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-base-3.11.0-py314hd0c49b1_1.conda
+  sha256: 94bc6fb3f0dc6337ca3b5dcb3d65da3ede1f24ce14d1e597ed83585bffe59dfc
+  md5: 99da493a14f3e26e8069e12281ce504f
+  depends:
+  - contourpy >=1.0.1
+  - cycler >=0.10
+  - fonttools >=4.22.0
+  - freetype
+  - kiwisolver >=1.3.1
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libraqm >=0.10.5,<0.11.0a0
+  - numpy >=1.23
+  - numpy >=1.25,<3
+  - packaging >=20.0
+  - pillow >=8
+  - pyparsing >=2.3.1
+  - python >=3.14,<3.15.0a0
+  - python-dateutil >=2.7
+  - python_abi 3.14.* *_cp314
+  - qhull >=2020.2,<2020.3.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: PSF-2.0
+  license_family: PSF
+  purls:
+  - pkg:pypi/matplotlib?source=compressed-mapping
+  run_exports: {}
+  size: 8747069
+  timestamp: 1782829728451
+- conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2026.0.0-hac47afa_908.conda
+  sha256: f997bfc9bc4d4e14261cdcd1ad195d64a72ee44dca3145d24c1349f8d1311aa5
+  md5: 36ea6e1292e9d5e89374201da79646ef
+  depends:
+  - llvm-openmp >=22.1.5
+  - onemkl-license 2026.0.0 h57928b3_908
+  - tbb >=2023.0.0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: LicenseRef-IntelSimplifiedSoftwareOct2022
+  license_family: Proprietary
+  purls: []
+  run_exports: {}
+  size: 114354729
+  timestamp: 1779293121860
+- conda: https://conda.anaconda.org/conda-forge/win-64/ml_dtypes-0.5.4-np2py310h7578f05_1.conda
+  sha256: c4c5ed1d841a1195dcf8c2337fa872372df0f24ef4c2bc6833a735ebb1a08247
+  md5: d2f4ac87c21f15b82cd2066d57e3188e
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - numpy >=1.21,<3
+  - python_abi 3.10.* *_cp310
+  license: MPL-2.0 AND Apache-2.0
+  run_exports: {}
+  size: 197890
+  timestamp: 1771362323831
+- conda: https://conda.anaconda.org/conda-forge/win-64/ml_dtypes-0.5.4-np2py314hb7a55bc_1.conda
+  sha256: 2cb8eac7bd0af92575214628c081528ae003131d6711e4854e2fc3fb8f6dc11e
+  md5: e2b07dfa101dab343103bb28ed0aba3b
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - python_abi 3.14.* *_cp314
+  - numpy >=1.23,<3
+  license: MPL-2.0 AND Apache-2.0
+  purls:
+  - pkg:pypi/ml-dtypes?source=hash-mapping
+  run_exports: {}
+  size: 202093
+  timestamp: 1771362373159
+- conda: https://conda.anaconda.org/conda-forge/win-64/mypy-2.1.0-py310h3b59f23_0.conda
+  sha256: f8c39c63f4c2353d067d6353956fb49fff62bb2e215f719acb84db4d99ca24f6
+  md5: d81dac90c51f5dee083c7c79aaee7fa4
+  depends:
+  - ast-serialize >=0.3.0,<1.0.0
+  - mypy_extensions >=1.0.0
+  - pathspec >=1.0.0
+  - python
+  - python-librt >=0.11.0
+  - typing_extensions >=4.6.0
+  - psutil >=4.0
+  - tomli >=1.1.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - python_abi 3.10.* *_cp310
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 9623187
+  timestamp: 1780315651863
+- conda: https://conda.anaconda.org/conda-forge/win-64/mypy-2.1.0-py314h13f4da2_0.conda
+  sha256: 8099ce0e8f971f6a393df52c2d5abca56209d47c1d3da020ca4ee0625539b933
+  md5: 26de46b296a732183242a77ac4e6a30f
+  depends:
+  - ast-serialize >=0.3.0,<1.0.0
+  - mypy_extensions >=1.0.0
+  - pathspec >=1.0.0
+  - python
+  - python-librt >=0.11.0
+  - typing_extensions >=4.6.0
+  - psutil >=4.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - python_abi 3.14.* *_cp314
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/mypy?source=hash-mapping
+  run_exports: {}
+  size: 10734309
+  timestamp: 1780315652597
+- conda: https://conda.anaconda.org/conda-forge/win-64/ninja-1.13.2-h477610d_0.conda
+  sha256: e41a945c34a5f0bd2109b73a65486cd93023fa0a9bcba3ef98f9a3da40ba1180
+  md5: 7ecb9f2f112c66f959d2bb7dbdb89b67
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  license: Apache-2.0
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 309417
+  timestamp: 1763688227932
+- conda: https://conda.anaconda.org/conda-forge/win-64/nodejs-24.18.0-h80d1838_0.conda
+  sha256: 2c0661b2f77e1ca912da9038416ed886dd66a4ab47e2105d8e395c5185157dd2
+  md5: 634f517a73580675d03145b7bf802b14
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - nodejs >=24.18.0,<25.0a0
+  size: 30836274
+  timestamp: 1782396052125
+- conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.23.2-py310h8a5b91a_0.tar.bz2
+  sha256: 963198f3cff11e197099f76a2a9633778345d0c85e78cfb74d33bf78290a3b46
+  md5: c0bb52a52c292a1e3c326fe53fd70c1e
+  depends:
+  - libblas >=3.9.0,<4.0a0
+  - libcblas >=3.9.0,<4.0a0
+  - liblapack >=3.9.0,<4.0a0
+  - python >=3.10,<3.11.0a0
+  - python_abi 3.10.* *_cp310
+  - vc >=14.1,<15
+  - vs2015_runtime >=14.16.27033
+  constrains:
+  - numpy-base <0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports:
+    weak:
+    - numpy >=1.23.2,<2.0a0
+  size: 6673925
+  timestamp: 1660674522598
+- conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.5.0-py314h02f10f6_0.conda
+  sha256: 86c3e926fa1d6f27ebe6b9db11ff12e9a3b6e4b0343bf4a9b489dafd9614da3f
+  md5: f92585b1624ecdd117b6d13fd4d691ed
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - liblapack >=3.9.0,<4.0a0
+  - libcblas >=3.9.0,<4.0a0
+  - libblas >=3.9.0,<4.0a0
+  - python_abi 3.14.* *_cp314
+  constrains:
+  - numpy-base <0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/numpy?source=compressed-mapping
+  run_exports:
+    weak:
+    - numpy >=1.25,<3
+  size: 7436159
+  timestamp: 1782112573833
+- conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.0.0-h57928b3_908.conda
+  sha256: 42ad15cbb3bf31830efa04d4b86dd2d5c0dd590c86f98adcd3c8c1f75acf5dd5
+  md5: 9c9303e08b50e09f5c23e1dac99d0936
+  license: LicenseRef-IntelSimplifiedSoftwareOct2022
+  license_family: Proprietary
+  purls: []
+  run_exports: {}
+  size: 41580
+  timestamp: 1779292867015
+- conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.26.0-py310he3e056b_0_cpu.conda
+  sha256: 5aca0559935d6e8e5c97d704df28cd3c35a1731e9ea247e472deecc0fbaabdcb
+  md5: 9a782c608f1f682d8cc0f33048eaec4b
+  depends:
+  - numpy >=1.21,<3
+  - packaging
+  - protobuf
+  - python >=3.10,<3.11.0a0
+  - python-flatbuffers
+  - python_abi 3.10.* *_cp310
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT AND BSL-1.0
+  run_exports: {}
+  size: 5984901
+  timestamp: 1778971621866
+- conda: https://conda.anaconda.org/conda-forge/win-64/onnxruntime-1.26.0-py314h8bd40d1_0_cpu.conda
+  sha256: dbab9f19ca986443a83fc6fb3479467cdf38bb01f3768b9fb2496a3df8638fef
+  md5: f9236416c269a2b4e676cfa78b821235
+  depends:
+  - numpy >=1.23,<3
+  - packaging
+  - protobuf
+  - python >=3.14,<3.15.0a0
+  - python-flatbuffers
+  - python_abi 3.14.* *_cp314
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: MIT AND BSL-1.0
+  purls:
+  - pkg:pypi/onnxruntime?source=hash-mapping
+  run_exports: {}
+  size: 6482753
+  timestamp: 1778970733590
+- conda: https://conda.anaconda.org/conda-forge/win-64/openjpeg-2.5.4-h0e57b4f_0.conda
+  sha256: 24342dee891a49a9ba92e2018ec0bde56cc07fdaec95275f7a55b96f03ea4252
+  md5: e723ab7cc2794c954e1b22fde51c16e4
+  depends:
+  - libpng >=1.6.55,<1.7.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: BSD-2-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - openjpeg >=2.5.4,<3.0a0
+  size: 245594
+  timestamp: 1772624841727
+- conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda
+  sha256: cb6e7ba0d010ee0d3249ce9886de3d7613d26d9965d4c95666fa66b9c4c31001
+  md5: e99f95734a326c0fd4d02bbd995150d4
+  depends:
+  - ca-certificates
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Apache-2.0
+  license_family: Apache
+  purls: []
+  run_exports:
+    weak:
+    - openssl >=3.6.3,<4.0a0
+  size: 9414790
+  timestamp: 1781071745579
+- conda: https://conda.anaconda.org/conda-forge/win-64/pango-1.56.4-h13911b6_1.conda
+  sha256: 3d4e6e541e633f6fd22fc2c1d79ad5ec39503dea3ba04fc3e01d5be904ec7cea
+  md5: 1f1cf3772ba7d4eef989e4679ddf97f7
+  depends:
+  - cairo >=1.18.4,<2.0a0
+  - fontconfig >=2.17.1,<3.0a0
+  - fonts-conda-ecosystem
+  - fribidi >=1.0.16,<2.0a0
+  - harfbuzz >=13.2.1
+  - libexpat >=2.7.4,<3.0a0
+  - libfreetype >=2.14.2
+  - libfreetype6 >=2.14.2
+  - libglib >=2.86.4,<3.0a0
+  - libpng >=1.6.55,<1.7.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.2,<15
+  - vc14_runtime >=14.29.30139
+  license: LGPL-2.1-or-later
+  purls: []
+  run_exports:
+    weak:
+    - pango >=1.56.4,<2.0a0
+  size: 454919
+  timestamp: 1774282149607
+- conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.47-hd2b5f0e_0.conda
+  sha256: 3e9e02174edf02cb4bcdd75668ad7b74b8061791a3bc8bdb8a52ae336761ba3e
+  md5: 77eaf2336f3ae749e712f63e36b0f0a1
+  depends:
+  - bzip2 >=1.0.8,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - pcre2 >=10.47,<10.48.0a0
+  size: 995992
+  timestamp: 1763655708300
+- conda: https://conda.anaconda.org/conda-forge/win-64/pillow-11.3.0-py310hb3a2f59_3.conda
+  sha256: d4825cfe13dc10bb90553c663b86128c8e53bb8c3eda768f7d0d29c3ad878a92
+  md5: a12291a9a7acce46716c518c31ebb298
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - libtiff >=4.7.0,<4.8.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - openjpeg >=2.5.3,<3.0a0
+  - libxcb >=1.17.0,<2.0a0
+  - lcms2 >=2.17,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - python_abi 3.10.* *_cp310
+  license: HPND
+  run_exports: {}
+  size: 786227
+  timestamp: 1758208682963
+- conda: https://conda.anaconda.org/conda-forge/win-64/pillow-11.3.0-py314hb9a687b_3.conda
+  sha256: 3945b8e0b8b878d3833f352536055733f6f167976d8968cc153ab90d51901ad9
+  md5: 57021b2331ee951b33d2342a6af8f5cc
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libtiff >=4.7.0,<4.8.0a0
+  - openjpeg >=2.5.3,<3.0a0
+  - libfreetype >=2.14.1
+  - libfreetype6 >=2.14.1
+  - libjpeg-turbo >=3.1.0,<4.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - libxcb >=1.17.0,<2.0a0
+  - libzlib >=1.3.1,<2.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - lcms2 >=2.17,<3.0a0
+  - python_abi 3.14.* *_cp314
+  license: HPND
+  purls:
+  - pkg:pypi/pillow?source=hash-mapping
+  run_exports: {}
+  size: 972043
+  timestamp: 1758208665046
+- conda: https://conda.anaconda.org/conda-forge/win-64/pixman-0.46.4-h5112557_1.conda
+  sha256: 246fce4706b3f8b247a7d6142ba8d732c95263d3c96e212b9d63d6a4ab4aff35
+  md5: 08c8fa3b419df480d985e304f7884d35
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - pixman >=0.46.4,<1.0a0
+  size: 542795
+  timestamp: 1754665193489
+- conda: https://conda.anaconda.org/conda-forge/win-64/prek-0.4.6-h18a1a76_0.conda
+  sha256: 24777a97522616b6958d35115df49fc25ceac5a596214b5b20a9259f92d66f6b
+  md5: 6f6120cc1254bbde23f1d5d6a6fce5da
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 6537499
+  timestamp: 1782881558490
+- conda: https://conda.anaconda.org/conda-forge/win-64/prettier-3.9.3-hc21fffc_0.conda
+  sha256: 4dc409cfb7d9bb40f7739814b7314c616ee5ad228996e7126d5cfab70815d947
+  md5: eb38604a838e8ce2f8b42ee5633c5ee6
+  depends:
+  - nodejs
+  - vc >=14.5,<15
+  - vc14_runtime >=14.51.36231
+  - ucrt >=10.0.20348.0
+  - nodejs >=24.18.0,<25.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 1372486
+  timestamp: 1782740672849
+- conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-6.31.1-py310h81b7714_2.conda
+  sha256: f5c83f900ae6740b2773b89cf2befebea40363cbe464397cfd33098f7bca9fff
+  md5: ace895b7d8a5cc36111033e1e3129d14
+  depends:
+  - python >=3.10,<3.11.0a0
+  - python_abi 3.10.* *_cp310
+  - ucrt >=10.0.20348.0
+  - vc >=14.2
+  - vc >=14.2,<15
+  - vc14_runtime >=14.29.30139
+  constrains:
+  - libprotobuf 6.31.1
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 408632
+  timestamp: 1760394135407
+- conda: https://conda.anaconda.org/conda-forge/win-64/protobuf-6.33.5-py314h6a447be_2.conda
+  sha256: c9f63ba6600618d805c14fa0a146abfc4fd06f1e400462dd8492125225095954
+  md5: 1ac0ec70143e747ca607074570b732f6
+  depends:
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - ucrt >=10.0.20348.0
+  - vc >=14.3
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - libprotobuf 6.33.5
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/protobuf?source=hash-mapping
+  run_exports: {}
+  size: 498409
+  timestamp: 1773266588160
+- conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py310h1637853_0.conda
+  sha256: 71b14cfddc05c0d8c22e2e15103a29ce404ea346e328c7bca5fd1ad682f7f274
+  md5: 97d88bac43c17c12d0b266f523a37f61
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - python_abi 3.10.* *_cp310
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 196390
+  timestamp: 1769678167722
+- conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py314hc5dbbe4_0.conda
+  sha256: 17c8274ce5a32c9793f73a5a0094bd6188f3a13026a93147655143d4df034214
+  md5: fd539ac231820f64066839251aa9fa48
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - python_abi 3.14.* *_cp314
+  license: BSD-3-Clause
+  license_family: BSD
+  purls:
+  - pkg:pypi/psutil?source=hash-mapping
+  run_exports: {}
+  size: 249950
+  timestamp: 1769678167309
+- conda: https://conda.anaconda.org/conda-forge/win-64/pthread-stubs-0.4-h0e40799_1002.conda
+  sha256: 7e446bafb4d692792310ed022fe284e848c6a868c861655a92435af7368bae7b
+  md5: 3c8f2573569bb816483e5cf57efbbe29
+  depends:
+  - libgcc >=13
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 9389
+  timestamp: 1726802555076
+- conda: https://conda.anaconda.org/conda-forge/win-64/pyside6-6.11.1-py314h447aaf0_1.conda
+  sha256: 070802d5e1e1c1feb24d481efbd90b300fb0ecc1ce4312a3bbcbaae4393c05f9
+  md5: 638be6b8674e7acf7a84132903cf4c8e
+  depends:
+  - python
+  - qt6-main 6.11.1.*
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libxslt >=1.1.43,<2.0a0
+  - libxml2
+  - libxml2-16 >=2.14.6
+  - qt6-main >=6.11.1,<6.12.0a0
+  - python_abi 3.14.* *_cp314
+  - libvulkan-loader >=1.4.341.0,<2.0a0
+  - libclang13 >=22.1.5
+  license: LGPL-3.0-only
+  license_family: LGPL
+  purls:
+  - pkg:pypi/pyside6?source=hash-mapping
+  - pkg:pypi/shiboken6?source=hash-mapping
+  run_exports: {}
+  size: 11579652
+  timestamp: 1778933912020
+- conda: https://conda.anaconda.org/conda-forge/win-64/python-3.10.20-hc20f281_1_cpython.conda
+  build_number: 1
+  sha256: 71e2cdc0f87a0a2c5db7beb82469559bba1ce88a4fafe4e2d169172c2db45d1f
+  md5: 62018eccb570c1fb288b550f804fb940
+  depends:
+  - bzip2 >=1.0.8,<2.0a0
+  - libexpat >=2.8.1,<3.0a0
+  - libffi >=3.4,<4.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - openssl >=3.5.7,<4.0a0
+  - tk >=8.6.13,<8.7.0a0
+  - tzdata
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  constrains:
+  - python_abi 3.10.* *_cp310
+  license: Python-2.0
+  run_exports:
+    weak:
+    - python_abi 3.10.* *_cp310
+    noarch:
+    - python
+  size: 16128204
+  timestamp: 1781148776322
+- conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda
+  build_number: 100
+  sha256: f1acb89cb1a6bec9a94ae9f8e7411839de009cd64d3ac6a6aec4f3d8a481099a
+  md5: 8333e3ca6f8d1ebcd30b678dd53f0a25
+  depends:
+  - bzip2 >=1.0.8,<2.0a0
+  - libexpat >=2.8.1,<3.0a0
+  - libffi >=3.5.2,<3.6.0a0
+  - liblzma >=5.8.3,<6.0a0
+  - libmpdec >=4.0.0,<5.0a0
+  - libsqlite >=3.53.2,<4.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - openssl >=3.5.7,<4.0a0
+  - python_abi 3.14.* *_cp314
+  - tk >=8.6.13,<8.7.0a0
+  - tzdata
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - zstd >=1.5.7,<1.6.0a0
+  license: Python-2.0
+  purls: []
+  run_exports:
+    weak:
+    - python_abi 3.14.* *_cp314
+    noarch:
+    - python
+  size: 18481352
+  timestamp: 1781256034828
+  python_site_packages_path: Lib/site-packages
+- conda: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.12.0-py310h1637853_0.conda
+  sha256: a4c0c37906a1e5b37ec1dfed80e9e407f865cc6d23cd30c9c75c6503fbe9984e
+  md5: 15317a74ee23af8908717fac48326337
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - python_abi 3.10.* *_cp310
+  license: MIT
+  license_family: MIT
+  run_exports: {}
+  size: 108673
+  timestamp: 1782847533506
+- conda: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.12.0-py314hc5dbbe4_0.conda
+  sha256: a616cd44ce431ed145c39bb75136663dbd42b68e4bd72d0e25818046aa5206dd
+  md5: 3a343978b99778a15076cb9f93c439e2
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - python_abi 3.14.* *_cp314
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/librt?source=hash-mapping
+  run_exports: {}
+  size: 106052
+  timestamp: 1782847536215
+- conda: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.3-py314h2359020_1.conda
+  sha256: a2aff34027aa810ff36a190b75002d2ff6f9fbef71ec66e567616ac3a679d997
+  md5: 0cd9b88826d0f8db142071eb830bce56
+  depends:
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - yaml >=0.2.5,<0.3.0a0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/pyyaml?source=hash-mapping
+  run_exports: {}
+  size: 181257
+  timestamp: 1770223460931
+- conda: https://conda.anaconda.org/conda-forge/win-64/qhull-2020.2-hc790b64_5.conda
+  sha256: 887d53486a37bd870da62b8fa2ebe3993f912ad04bd755e7ed7c47ced97cbaa8
+  md5: 854fbdff64b572b5c0b470f334d34c11
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.2,<15
+  - vc14_runtime >=14.29.30139
+  license: LicenseRef-Qhull
+  purls: []
+  run_exports:
+    weak:
+    - qhull >=2020.2,<2020.3.0a0
+  size: 1377020
+  timestamp: 1720814433486
+- conda: https://conda.anaconda.org/conda-forge/win-64/qt6-main-6.11.1-pl5321hfcac499_1.conda
+  sha256: c0f0552a879e18282799431c7d2769b269839ac3b3735082e754df3c6fa0728d
+  md5: a8d735f3faf356a24acf9eea0a940a0f
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - krb5 >=1.22.2,<1.23.0a0
+  - libglib >=2.88.1,<3.0a0
+  - libpng >=1.6.58,<1.7.0a0
+  - double-conversion >=3.4.0,<3.5.0a0
+  - libbrotlicommon >=1.2.0,<1.3.0a0
+  - libbrotlienc >=1.2.0,<1.3.0a0
+  - libbrotlidec >=1.2.0,<1.3.0a0
+  - libwebp-base >=1.6.0,<2.0a0
+  - openssl >=3.5.6,<4.0a0
+  - icu >=78.3,<79.0a0
+  - libjpeg-turbo >=3.1.4.1,<4.0a0
+  - pcre2 >=10.47,<10.48.0a0
+  - libzlib >=1.3.2,<2.0a0
+  - zstd >=1.5.7,<1.6.0a0
+  - libfreetype >=2.14.3
+  - libfreetype6 >=2.14.3
+  - libvulkan-loader >=1.4.341.0,<2.0a0
+  - libtiff >=4.7.1,<4.8.0a0
+  - libsqlite >=3.53.1,<4.0a0
+  - harfbuzz >=14.2.0
+  constrains:
+  - qt ==6.11.1
+  license: LGPL-3.0-only
+  license_family: LGPL
+  purls: []
+  run_exports:
+    weak:
+    - qt6-main >=6.11.1,<7.0a0
+  size: 89576886
+  timestamp: 1780400596481
+- conda: https://conda.anaconda.org/conda-forge/win-64/ruff-0.15.20-h45713df_0.conda
+  noarch: python
+  sha256: 63cc41a9acf4d4bcc2273df322e0cb6d08311e9e7425fffe3bbe01e7c496fbb7
+  md5: 7e18b4c765bf080576d39b177167b3f2
+  depends:
+  - python
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls:
+  - pkg:pypi/ruff?source=hash-mapping
+  run_exports: {}
+  size: 9813687
+  timestamp: 1782428572744
+- conda: https://conda.anaconda.org/conda-forge/win-64/shellcheck-0.11.0-h57928b3_1.conda
+  sha256: 8bbb9dbd770d0fdfc2e6234c0c03ebb5fca5f9ff5718a8e1eb65b3a5d276f5ce
+  md5: 3d6d1997bf67f4e6155366acad439bd0
+  license: GPL-3.0-only
+  license_family: GPL
+  purls: []
+  run_exports: {}
+  size: 2923722
+  timestamp: 1771525244368
+- conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2023.0.0-hd3d4ead_2.conda
+  sha256: 8a4053839b8e997a5965e2dff7d6cf3c77be62d82c0e48c8a04a5ed2d2e73035
+  md5: 8ee01a693aecff5432069eaaf1183c45
+  depends:
+  - libhwloc >=2.13.0,<2.13.1.0a0
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Apache-2.0
+  license_family: APACHE
+  purls: []
+  run_exports: {}
+  size: 156515
+  timestamp: 1778673901757
+- conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda
+  sha256: 0e79810fae28f3b69fe7391b0d43f5474d6bd91d451d5f2bde02f55ae481d5e3
+  md5: 0481bfd9814bf525bd4b3ee4b51494c4
+  depends:
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: TCL
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - tk >=8.6.13,<8.7.0a0
+  size: 3526350
+  timestamp: 1769460339384
+- conda: https://conda.anaconda.org/conda-forge/win-64/tornado-6.5.7-py314h5a2d7ad_0.conda
+  sha256: 6b9f5a195ca148f7c6b9a4a0a026631979b3112c43cd7c1064085ff833dfa4f0
+  md5: b1b9bf11a82e608c5649d7462de94c5f
+  depends:
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/tornado?source=hash-mapping
+  run_exports: {}
+  size: 919275
+  timestamp: 1781006902968
+- conda: https://conda.anaconda.org/conda-forge/win-64/typos-1.48.0-h18a1a76_0.conda
+  sha256: 10f973b1a21082f06ef9c8388bb3b95ff9fc37054b18879c16fa443339e44633
+  md5: 36422364f71f8110de1829127d0e99fc
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  license: MIT OR Apache-2.0
+  purls: []
+  run_exports: {}
+  size: 2919424
+  timestamp: 1782859645300
+- conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda
+  sha256: 3005729dce6f3d3f5ec91dfc49fc75a0095f9cd23bab49efb899657297ac91a5
+  md5: 71b24316859acd00bdb8b38f5e2ce328
+  constrains:
+  - vc14_runtime >=14.29.30037
+  - vs2015_runtime >=14.29.30037
+  license: LicenseRef-MicrosoftWindowsSDK10
+  purls: []
+  run_exports: {}
+  size: 694692
+  timestamp: 1756385147981
+- conda: https://conda.anaconda.org/conda-forge/win-64/unicodedata2-17.0.1-py314h5a2d7ad_0.conda
+  sha256: 9041e463044944460f73f9528f2ec491180f0ffe857e3555aa8160b81050b8d9
+  md5: d6b580a13384df5155c6ca19ee66854e
+  depends:
+  - python >=3.14,<3.15.0a0
+  - python_abi 3.14.* *_cp314
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Apache-2.0
+  license_family: Apache
+  purls:
+  - pkg:pypi/unicodedata2?source=hash-mapping
+  run_exports: {}
+  size: 406126
+  timestamp: 1770909191618
+- conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda
+  sha256: 17693b60cb54f80c60275f003f3bfc1b128af56dbfd65c4fae37c64eeb755ce1
+  md5: 2eacea63f545b97342da520df6854276
+  depends:
+  - vc14_runtime >=14.51.36231
+  track_features:
+  - vc14
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports: {}
+  size: 20362
+  timestamp: 1781320968457
+- conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda
+  sha256: 8153ed849c92e891eacac0f2f8d7ecb79f9b5fd7f7917fbb896f252a60a40390
+  md5: 06a5bf5a1ca16cce0df6eaa91fc42bc2
+  depends:
+  - ucrt >=10.0.20348.0
+  - vcomp14 14.51.36231 h1b9f54f_39
+  constrains:
+  - vs2015_runtime 14.51.36231.* *_39
+  license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime
+  license_family: Proprietary
+  purls: []
+  run_exports: {}
+  size: 737434
+  timestamp: 1781320964561
+- conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda
+  sha256: 07fb14713c4bc62e2533a2e23a363abfb0e65650681fba0ae4c840e2219350f3
+  md5: 8b53a83fda40ec679e4d63fa32fae989
+  depends:
+  - ucrt >=10.0.20348.0
+  constrains:
+  - vs2015_runtime 14.51.36231.* *_39
+  license: LicenseRef-MicrosoftVisualCpp2015-2022Runtime
+  license_family: Proprietary
+  purls: []
+  run_exports:
+    strong:
+    - vcomp14 >=14.51.36231
+  size: 120684
+  timestamp: 1781320948530
+- conda: https://conda.anaconda.org/conda-forge/win-64/vs2015_runtime-14.51.36231-h84cd919_39.conda
+  sha256: 6de6c2cf008fc2dce61060b583f2d8494c83883106952b201381b6b0505f03d7
+  md5: 2ccc63d7b7d066a814ed9f99072832d7
+  depends:
+  - vc14_runtime >=14.51.36231
+  license: BSD-3-Clause
+  license_family: BSD
+  run_exports: {}
+  size: 20355
+  timestamp: 1781320968804
+- conda: https://conda.anaconda.org/conda-forge/win-64/vs2022_win-64-19.44.35207-ha74f236_39.conda
+  sha256: 434b4f517b7119675930d17749bf123558271f3f316b217f7ac759e6d7121e9d
+  md5: 59f1d09ae752b761542975d7b6ad1b89
+  depends:
+  - vswhere
+  constrains:
+  - vs_win-64 2022.14
+  track_features:
+  - vc14
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    strong:
+    - vc >=14.3,<15
+    - vc14_runtime >=14.44.35208
+    - ucrt >=10.0.20348.0
+  size: 24190
+  timestamp: 1781320983107
+- conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libice-1.1.2-h0e40799_0.conda
+  sha256: bf1d34142b1bf9b5a4eed96bcc77bc4364c0e191405fd30d2f9b48a04d783fd3
+  md5: 105cb93a47df9c548e88048dc9cbdbc9
+  depends:
+  - libgcc >=13
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - ucrt >=10.0.20348.0
+  - xorg-libx11 >=1.8.10,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libice >=1.1.2,<2.0a0
+  size: 236306
+  timestamp: 1734228116846
+- conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libsm-1.2.6-h0e40799_0.conda
+  sha256: 065d49b0d1e6873ed1238e962f56cb8204c585cdc5c9bd4ae2bf385cadb5bd65
+  md5: 570c9a6d9b4909e45d49e9a5daa528de
+  depends:
+  - libgcc >=13
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - ucrt >=10.0.20348.0
+  - xorg-libice >=1.1.2,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libsm >=1.2.6,<2.0a0
+  size: 97096
+  timestamp: 1741896840170
+- conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libx11-1.8.13-hfa52320_0.conda
+  sha256: eadb12d4597b577cf9bde82a8a2a502a331bd5bfdd60ce508cea93912478e255
+  md5: 5a823e21e090f8bc43dbfba00cd2f0e2
+  depends:
+  - libgcc >=14
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - libxcb >=1.17.0,<2.0a0
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libx11 >=1.8.13,<2.0a0
+  size: 954604
+  timestamp: 1770819901886
+- conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxau-1.0.12-hba3369d_1.conda
+  sha256: 156a583fa43609507146de1c4926172286d92458c307bb90871579601f6bc568
+  md5: 8436cab9a76015dfe7208d3c9f97c156
+  depends:
+  - libgcc >=14
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxau >=1.0.12,<2.0a0
+  size: 109246
+  timestamp: 1762977105140
+- conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxdmcp-1.1.5-hba3369d_1.conda
+  sha256: 366b8ae202c3b48958f0b8784bbfdc37243d3ee1b1cd4b8e76c10abe41fa258b
+  md5: a7c03e38aa9c0e84d41881b9236eacfb
+  depends:
+  - libgcc >=14
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxdmcp >=1.1.5,<2.0a0
+  size: 70691
+  timestamp: 1762977015220
+- conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxext-1.3.7-hba3369d_0.conda
+  sha256: 5966dff3ea3f805e11b5fb466107d64704eb94f00d28818f6891a3ecd075d08e
+  md5: 74bc8e26c2716e9b1542bef908887b82
+  depends:
+  - libgcc >=14
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - ucrt >=10.0.20348.0
+  - xorg-libx11 >=1.8.12,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxext >=1.3.7,<2.0a0
+  size: 286083
+  timestamp: 1769445495320
+- conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxpm-3.5.19-hba3369d_0.conda
+  sha256: 1d3907533a6e26bb62f109a33107064e2140503a8076de5b28b384ef3e473d27
+  md5: 39d8a6b9a87047c817e5881fc0706684
+  depends:
+  - libgcc >=14
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - ucrt >=10.0.20348.0
+  - xorg-libx11 >=1.8.13,<2.0a0
+  - xorg-libxext >=1.3.7,<2.0a0
+  - xorg-libxt >=1.3.1,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxpm >=3.5.19,<4.0a0
+  size: 237565
+  timestamp: 1776790287445
+- conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxt-1.3.1-h0e40799_0.conda
+  sha256: c940a6b71a1e59450b01ebfb3e21f3bbf0a8e611e5fbfc7982145736b0f20133
+  md5: 31baf0ce8ef19f5617be73aee0527618
+  depends:
+  - libgcc >=13
+  - libwinpthread >=12.0.0.r4.gg4f2fc60ca
+  - ucrt >=10.0.20348.0
+  - xorg-libice >=1.1.1,<2.0a0
+  - xorg-libsm >=1.2.4,<2.0a0
+  - xorg-libx11 >=1.8.10,<2.0a0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - xorg-libxt >=1.3.1,<2.0a0
+  size: 918674
+  timestamp: 1731861024233
+- conda: https://conda.anaconda.org/conda-forge/win-64/yaml-0.2.5-h6a83c73_3.conda
+  sha256: 80ee68c1e7683a35295232ea79bcc87279d31ffeda04a1665efdb43cbd50a309
+  md5: 433699cba6602098ae8957a323da2664
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports:
+    weak:
+    - yaml >=0.2.5,<0.3.0a0
+  size: 63944
+  timestamp: 1753484092156
+- conda: https://conda.anaconda.org/conda-forge/win-64/zizmor-1.26.1-h18a1a76_0.conda
+  sha256: df8d51360a01f7400940f9b7c63b3a97f529bde5ad1b61895fa63045830b546c
+  md5: f0cd2dab902279f226fc267b644c425a
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  license: MIT
+  license_family: MIT
+  purls: []
+  run_exports: {}
+  size: 7212789
+  timestamp: 1782024354755
+- conda: https://conda.anaconda.org/conda-forge/win-64/zlib-1.3.2-hfd05255_2.conda
+  sha256: ef408f85f664a4b9c9dac3cb2e36154d9baa15a88984ea800e11060e0f2394a1
+  md5: 5187ecf958be3c39110fe691cbd6873e
+  depends:
+  - libzlib 1.3.2 hfd05255_2
+  - ucrt >=10.0.20348.0
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  license: Zlib
+  license_family: Other
+  purls: []
+  run_exports:
+    weak:
+    - libzlib >=1.3.2,<2.0a0
+  size: 850351
+  timestamp: 1774072891049
+- conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda
+  sha256: 368d8628424966fd8f9c8018326a9c779e06913dd39e646cf331226acc90e5b2
+  md5: 053b84beec00b71ea8ff7a4f84b55207
+  depends:
+  - vc >=14.3,<15
+  - vc14_runtime >=14.44.35208
+  - ucrt >=10.0.20348.0
+  - libzlib >=1.3.1,<2.0a0
+  license: BSD-3-Clause
+  license_family: BSD
+  purls: []
+  run_exports:
+    weak:
+    - zstd >=1.5.7,<1.6.0a0
+  size: 388453
+  timestamp: 1764777142545
+- pypi: https://files.pythonhosted.org/packages/1e/c4/2632b200d3a7f9490765b2cf1550510af4a0b9a4c890f522dda721a0536f/lintrunner-0.13.1-py3-none-macosx_11_0_arm64.whl
+  name: lintrunner
+  version: 0.13.1
+  sha256: 5f0031ddf61d7328e83ca7fcb4cf0013cf04dfdd4271f67017e4b90087b64b39
+  requires_python: '>=3.6'
+- pypi: https://files.pythonhosted.org/packages/2a/df/bac34bce3e99f3a73ad1e244ecdc40790e85ac4caffff820ebf36e0a892a/lintrunner_adapters-0.14.0-py3-none-any.whl
+  name: lintrunner-adapters
+  version: 0.14.0
+  sha256: e3d5867ba066cb3157a3ef0fa40d7ce1f9a4cf49534a260a64e762ae1541f251
+  requires_dist:
+  - click>=8.1.3
+  - lintrunner>=0.10.0 ; extra == 'dev'
+  - pytest>=7.2.0 ; extra == 'dev'
+  - types-pyyaml>=6.0.12.2 ; extra == 'dev'
+  requires_python: '>=3.9'
+- pypi: https://files.pythonhosted.org/packages/8e/d0/1c14e394a4614056b75e7844d7e29c51e3eb5cd5ae8c9756933f45cd9143/lintrunner-0.13.1-py3-none-win_amd64.whl
+  name: lintrunner
+  version: 0.13.1
+  sha256: 25a6458b4b75cc230b95208298d9b9f18c1eedc2b310010d68ff88a4aff88666
+  requires_python: '>=3.6'
+- pypi: https://files.pythonhosted.org/packages/94/62/ea27e6e4152d633d9b68eec400d1bf0c972d3986e88a6f07a2a19f8ec74a/lintrunner-0.13.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl
+  name: lintrunner
+  version: 0.13.1
+  sha256: 0bd6126d62e7a0ac243da404c568900f5a03670131fd551931b0a1fa835a5baf
+  requires_python: '>=3.6'
+- pypi: https://files.pythonhosted.org/packages/b6/2c/6e0aa56de08a48324eae2f0fda32d4ffc769dd72fafc62da55c1f7f14510/sphinx_exec_code-0.18-py3-none-any.whl
+  name: sphinx-exec-code
+  version: '0.18'
+  sha256: 257c5847adab86f971c9ec20849df84aec4c8ee05aca787915efaac930586656
+  requires_dist:
+  - typing-extensions
+- pypi: https://files.pythonhosted.org/packages/c5/1d/bc26dd9dcb7bb364f25cbfec2da6b28e9cfe849285c9debf8baf94e78e10/lintrunner-0.13.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl
+  name: lintrunner
+  version: 0.13.1
+  sha256: 0ab57a437527cce170cbd6d94756616cf7848ae3d8c79f759339430daebcead8
+  requires_python: '>=3.6'
+- pypi: https://files.pythonhosted.org/packages/e6/dd/ca9c996a7e4de9d350d18d2146cb2a8da5cb7b4ea31fef32c75b830ce28f/editorconfig-checker-3.2.1.tar.gz
+  name: editorconfig-checker
+  version: 3.2.1
+  sha256: 41c884129343f1418118fc160889dc0cba4e66e23b45bc9731f40d73be4ce204
+  requires_python: '>=2.7'
+- pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl
+  name: click
+  version: 8.4.2
+  sha256: e6f9f66136c816745b9d65817da91d61d957fb16e02e4dcd0552553c5a197b76
+  requires_dist:
+  - colorama ; sys_platform == 'win32'
+  requires_python: '>=3.10'
diff --git a/pixi.toml b/pixi.toml
new file mode 100644
index 0000000..568d1cd
--- /dev/null
+++ b/pixi.toml
@@ -0,0 +1,180 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+[workspace]
+authors = ["ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>"]
+channels = ["conda-forge"]
+description = "Open Neural Network Exchange"
+name = "onnx"
+platforms = ["osx-arm64", "linux-64", "linux-aarch64", "win-64"]
+
+[tasks.install]
+# the compilation auto-generates .pyi files for the protobuf files
+# which are not checked into git/found in 'onnx/'. mypy adds the CWD
+# to the search pass meaning that it searches the 'onnx/' folder first
+# for the repecitive .py[i] files. When they are not found there, mypy
+# will complain. The proper fix would be to use to have a 'src' folder
+# structure. Until then, we simply copy the interface files to the
+# source directory after the build.
+cmd = 'export CMAKE_ARGS="$CMAKE_ARGS $CMAKE_EXTRA_ARGS" && pip install --no-deps --ignore-installed --verbose --no-build-isolation --force --editable . && cp .setuptools-cmake-build/onnx/onnx_pb.py .setuptools-cmake-build/onnx/*_pb2.pyi onnx/'
+[tasks.install.env]
+ONNX_ML="1"
+ONNX_BUILD_TESTS="1"
+CMAKE_EXTRA_ARGS="-DONNX_USE_PROTOBUF_SHARED_LIBS=ON -DONNX_HARDENING=ON -DONNX_WERROR=ON"
+
+[tasks.gen-docs]
+cmd = "python onnx/defs/gen_doc.py"
+
+[tasks.gen-operator-coverage]
+cmd = "python onnx/backend/test/stat_coverage.py"
+
+[tasks.gen-proto]
+cmd = "python onnx/gen_proto.py -l && python onnx/gen_proto.py -l --ml"
+
+[tasks.gen-test-data-feature-branch]
+# Generate test data based on what files changed in the current feature branch
+cmd = "python onnx/backend/test/cmd_tools.py generate-data --diff"
+
+[tasks.gen-all]
+depends-on = ["gen-docs", "gen-operator-coverage", "gen-proto", "gen-test-data-feature-branch"]
+
+[tasks.gtest]
+cmd = ".setuptools-cmake-build/onnx_gtests"
+[target.win-64.tasks.gtest]
+# Different path on Windows
+cmd = ".setuptools-cmake-build/Release/onnx_gtests.exe"
+
+[tasks.pytest]
+cmd = "pytest"
+
+[feature.clang-tools.tasks.run-clang-tidy]
+description = "Run clang-tidy on the entire project"
+# Requires `.setuptools-cmake-build/compile_commands.json` which is produced in the build task.
+# The `-extra-arg=-Wno-unknown-warning-option` is needed in cases
+# where the compiler_commands.json file was created by/for gcc
+cmd = [
+  'python',
+  'tools/pretty_clang_tidy.py',
+  'run-clang-tidy',
+  '-p=.setuptools-cmake-build',
+  '-warnings-as-errors="*"',
+  '-extra-arg=-Wno-unknown-warning-option',
+  '-source-filter="{{ pixi.init_cwd }}/onnx"',
+  '-hide-progress',
+  '-quiet',
+  '-use-color',
+]
+
+[feature.lint.tasks.pre-commit-install]
+description = "Install prek hooks"
+cmd = "prek install"
+[feature.lint.tasks.lint]
+description = "Run linters against all files (requires a prior 'install')"
+cmd = "prek run -a"
+
+[feature.lintrunner.tasks.lintrunner-init]
+cmd = "lintrunner init"
+[feature.lintrunner.tasks.lintrunner-run]
+cmd = "lintrunner --all-files"
+
+[feature.docs.tasks.docs-build]
+description = "Build sphinx documentation"
+cmd = "cd docs/docsgen && make html"
+
+[dependencies]
+libdate = ">=3.0.1,<4"
+libprotobuf = "<7"  # libprotobuf>=7 has breaking changes which need a dedicated PR
+make = "*"
+ml_dtypes = ">=0.5.1"
+nanobind = ">=2.8.0"
+ninja = "*"
+packaging = ">=24.1"
+pip = ">=25.0"
+python = ">=3.10"
+scikit-build-core = ">=0.12.1"
+
+[feature.dev.dependencies]
+c-compiler = ">=1.8.0"
+cmake = ">=3.31.5"
+cxx-compiler = ">=1.8.0"
+# follows requirements-dev.txt
+ml_dtypes = ">=0.5.1"
+numpy = ">=1.22.0"
+protobuf = ">=6.31.1"
+pytest = ">=8.3.4"
+pytest-cov = ">=6.0.0"
+pytest-xdist = ">=3.6.1"
+setuptools = ">=75.8.0"
+wheel = ">=0.45.1"
+zizmor = ">=1.24.1,<2"
+onnxruntime = "*"
+
+[feature.reference.dependencies]
+pillow = ">=11.2.1,<12"
+
+[feature.oldies.dependencies]
+protobuf = "==6.31.1"
+python = "3.10.*"
+numpy = "==1.23.2"
+
+[feature.lint.dependencies]
+clang-format = ">=22.1.1"
+mypy = ">=1.19.1"
+prek = ">=0.3.9"
+prettier = ">=3.8.1,<4"
+ruff = ">=0.15.7"
+shellcheck = ">=0.11.0"
+types-protobuf = ">=6.32.1.20260221,<7"
+typos = ">=1.44.0,<2"
+
+[feature.lintrunner.pypi-dependencies]
+lintrunner = ">=0.10.7"
+lintrunner-adapters = ">=0.12.3"
+editorconfig-checker = "==3.2.1"
+
+[feature.clang-tools.dependencies]
+# We want to use a clang-tidy/clang-format version that is possibly
+# newer than the one provided by the default macos cxx-compiler
+# package. We thus install this into a separate environment.
+clang = ">=22"
+clang-tools = "*"
+clang-format = "*"
+python = "*"
+
+[feature.docs.dependencies]
+furo = "*"
+markupsafe = "*"
+matplotlib = "*"
+myst-parser = "*"
+pillow = "*"
+pydot = "*"
+sphinx = "<9"  # Seems to be required by sphinx-tabs?
+sphinx-copybutton = "*"
+sphinx-tabs = "*"
+setuptools = "<82"  # sphinx-tabs needs pkg_resources which was removed in 82
+linkify-it-py = "*"
+[feature.docs.pypi-dependencies]
+sphinx-exec-code = "*"
+
+[feature.link-checker.dependencies]
+lychee = ">=0.23.0"
+[feature.link-checker.tasks.link-checker]
+cmd = "pixi exec lychee --root-dir . ."
+
+[feature.reuse.dependencies]
+python = ">=3.14.5,<3.15"
+reuse = ">=6.2.0,<7"
+[feature.reuse.tasks.reuse]
+cmd = "reuse"
+
+[environments]
+default = ["dev", "lint", "reference"]
+oldies = ["dev", "lint", "reference", "oldies"]
+# Keep a separate docs environment since some of those dependencies
+# may introduce upper bounds
+docs = ["dev", "lint", "reference", "docs"]
+clang-tools = {features=["clang-tools"], no-default-feature=true}
+link-checker = {features=["link-checker"], no-default-feature=true}
+lintrunner = ["dev", "reference", "lint", "lintrunner"]
+reuse = {features=["reuse"], no-default-feature=true}
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..73ebb17
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,282 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+[build-system]
+requires = ["scikit-build-core>=0.11", "protobuf==6.31.1"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "onnx"
+dynamic = ["version"]
+description = "Open Neural Network Exchange"
+readme = "README.md"
+authors = [
+    {name = "ONNX Contributors", email = "onnx-technical-discuss@lists.lfaidata.foundation"},
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+]
+license = "Apache-2.0"
+# scikit-build-core expects dependencies here rather than in a requirements.txt file
+requires-python = ">=3.10"
+dependencies = [
+    "numpy>=1.23.2",
+    "protobuf>=6.31.1",
+    "typing_extensions>=4.7.1",
+    "ml_dtypes>=0.5.4",
+]
+
+[project.optional-dependencies]
+reference = ["Pillow"]
+
+[project.urls]
+Homepage = "https://onnx.ai/"
+Repository = "https://github.com/onnx/onnx"
+
+[project.scripts]
+backend-test-tools = "onnx.backend.test.cmd_tools:main"
+check-model = "onnx.bin.checker:check_model"
+check-node = "onnx.bin.checker:check_node"
+
+[tool.scikit-build]
+# using `.setuptools-cmake-build` for historical reasons.
+build-dir = ".setuptools-cmake-build"
+cmake.version = ">=3.26"
+cmake.build-type = "Release"
+wheel.packages = ["onnx"]
+wheel.exclude = ["**.proto3", "**.md", "**/CMakeLists.txt"]
+wheel.py-api = "cp312"
+sdist.include = [
+    "LICENSE",
+    "README.md",
+    "CMakeLists.txt",
+    "VERSION_NUMBER",
+    "sbom.cdx.json",
+    "cmake/**",
+    "tools/**",
+    "onnx/**",
+    "pyproject.toml",
+]
+sdist.exclude = ["*"]
+
+[tool.scikit-build.metadata.version]
+provider = "scikit_build_core.metadata.regex"
+input = "VERSION_NUMBER"
+regex = '(?P<value>\S+)'
+
+[tool.scikit-build.cmake.define]
+ONNX_BUILD_PYTHON = "ON"
+ONNX_INSTALL = "OFF"
+ONNX_ML = {env = "ONNX_ML", default = "ON"}
+ONNX_NAMESPACE = {env = "ONNX_NAMESPACE", default = "onnx"}
+ONNX_BUILD_TESTS = {env = "ONNX_BUILD_TESTS", default = "OFF"}
+ONNX_VERIFY_PROTO3 = {env = "ONNX_VERIFY_PROTO3", default = "OFF"}
+ONNX_DISABLE_EXCEPTIONS = {env = "ONNX_DISABLE_EXCEPTIONS", default = "OFF"}
+ONNX_DISABLE_STATIC_REGISTRATION = {env = "ONNX_DISABLE_STATIC_REGISTRATION", default = "OFF"}
+ONNX_USE_MSVC_STATIC_RUNTIME = {env = "USE_MSVC_STATIC_RUNTIME", default = "OFF"}
+
+# Disable stable ABI on FreeBSD (not supported)
+[[tool.scikit-build.overrides]]
+if.platform-system = "freebsd"
+wheel.py-api = ""
+
+# Use Debug build type when DEBUG or COVERAGE is set
+[[tool.scikit-build.overrides]]
+if.env.DEBUG = "1"
+cmake.build-type = "Debug"
+
+[[tool.scikit-build.overrides]]
+if.env.COVERAGE = "1"
+cmake.build-type = "Debug"
+cmake.define.ONNX_COVERAGE = "ON"
+
+[tool.cibuildwheel.pyodide]
+build = "cp313-pyodide_wasm32"
+
+[tool.cibuildwheel]
+test-command = "pytest {project}/onnx/test"
+test-requires = ["pytest", "Pillow"]
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+
+[tool.cibuildwheel.macos]
+archs = ["universal2"]
+environment = { MACOSX_DEPLOYMENT_TARGET = "12.0" }
+
+[tool.check-wheel-contents]
+ignore = ["W002"]
+
+[tool.pytest.ini_options]
+addopts = "--tb=short --color=yes"
+testpaths = [
+    "onnx/test",
+    "onnx/examples",
+]
+
+[tool.mypy]
+follow_imports = "silent"
+strict_optional = true
+warn_return_any = true
+warn_no_return = true
+# TODO warn_unused_ignores = true
+warn_redundant_casts = true
+warn_incomplete_stub = true
+# TODO disallow_untyped_calls = true
+check_untyped_defs = true
+# Allow bare generics like np.ndarray
+disallow_any_generics = false
+no_implicit_optional = true
+# TODO disallow_incomplete_defs = true
+# TODO disallow_subclassing_any = true
+warn_unused_configs = true
+show_error_codes = true
+show_column_numbers = true
+ignore_missing_imports = true
+# NOTE: Do not grow the exclude list. Edit .lintrunner.toml instead
+exclude = []
+
+# NOTE: Avoid adding overrides unless for exceptional cases. Prefer inline ignores.
+# If you must ignore error for the whole file, consider adapting the example
+# `# mypy: disable-error-code="misc,arg-type,type-arg"`
+# and put this comment on the top of the file.
+[[tool.mypy.overrides]]
+module = [
+    'onnx.onnx_data_pb',
+    'onnx.onnx_data_pb2',
+    'onnx.onnx_pb',
+    'onnx.onnx_pb2',
+    'onnx.onnx_ml_pb2',
+    'onnx.onnx_operators_pb',
+    'onnx.onnx_operators_ml_pb2',
+]
+ignore_errors = true
+
+[tool.pylint.message_control]
+disable = [
+    "format",
+    "import-error",
+    "invalid-name",
+    "line-too-long",
+    "missing-docstring",
+    "no-name-in-module",
+    "too-few-public-methods",
+    "use-dict-literal",     # Dict literals are sometimes preferable when creating kwargs
+    "useless-return",
+]
+
+[tool.ruff]
+# NOTE: Do not create an exclude list. Edit .lintrunner.toml instead
+target-version = "py310"
+unsafe-fixes = true
+lint.select = [
+    "A", # flake8-builtins
+    "ARG", # flake8-unused-arguments
+    "B", # flake8-bugbear
+    "BLE", # flake8-blind-except
+    "C4", # flake8-comprehensions
+    "C90", # mccabe complexity
+    "D", # pydocstyle
+    "DTZ", # flake8-datetimez
+    "E", # pycodestyle
+    "F", # Pyflakes
+    "FA", # flake8-future-annotations
+    "FLY", # flynt
+    "FURB", # refurb
+    "G", # flake8-logging-format
+    "I", # isort
+    "ISC", # flake8-implicit-str-concat
+    "LOG", # flake8-logging
+    "N", # pep8-naming
+    "NPY", # modern numpy
+    "PERF", # Perflint
+    "PGH", # pygrep-hooks
+    "PIE", # flake8-pie
+    "PL", # pylint
+    "PYI", # flake8-pyi
+    "RSE", # flake8-raise
+    "RUF", # Ruff-specific rules
+    "S", # flake8-bandit
+    "SIM", # flake8-simplify
+    "SLOT", # flake8-slot
+    "T10", # flake8-debugger
+    "T20", # flake8-print
+    "TC", # flake8-type-checking
+    "TID", # Disallow relative imports
+    "TRY", # flake8-try-except-raise
+    "UP", # pyupgrade
+    "W", # pycodestyle
+    "YTT", # flake8-2020
+    "RET", # flake8-return
+]
+# NOTE: Refrain from growing the ignore list unless for exceptional cases.
+# Always include a comment to explain why.
+lint.ignore = [
+    "D1", # D1 is for missing docstrings, which is not yet enforced.
+    "D205", # D205 Too strict. "1 blank line required between summary line and description"
+    "D400",
+    "D415",
+    "E501", # Line length controlled by black
+    "N803", # Argument casing
+    "N806", # Relax: Variable name in function should be lowercase
+    "N999", # Module names
+    "NPY002", # np.random.Generator may not be preferred in all cases
+    "PLR0912", # Too many branches
+    "PLR0913", # Too many arguments to function call
+    "PLR0915", # Too many statements
+    "PYI011", # Allow protobuf enums as defaults to function arguments
+    "PYI021", # Allow docstrings in pyi files
+    "PYI041", # int | float is sometimes more clear than float
+    "RUF015", # next(iter(...)) sometimes obscures the intent when we access the 0th element of a shape
+    "RUF022", # We may want to keep __all__ unsorted for better readability
+    "SIM102", # We don't prefer always combining if branches
+    "SIM108", # We don't always encourage ternary operators
+    "SIM114", # Don't always combine if branches for debugability
+    "SIM116", # Don't use dict lookup to replace if-else
+    "S101", # assert is used extensively in tests and validation
+    "C901", # Complex functions are acceptable alongside PLR0912/PLR0915
+    "TRY003", # Messages can be constructed in the exception
+]
+
+[tool.ruff.lint.flake8-builtins]
+builtins-ignorelist = ["id", "input"]
+
+[tool.ruff.lint.flake8-tidy-imports]
+# Disallow all relative imports.
+ban-relative-imports = "all"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.isort]
+required-imports = ["from __future__ import annotations"]
+
+[tool.ruff.lint.per-file-ignores]
+# NOTE: Refrain from growing the ignore list unless for exceptional cases.
+# Prefer inline ignores with `noqa: xxx`.
+# Eventually this list should become empty.
+"**/*_test*" = ["N802"] # Function casing
+"onnx/backend/test/**" = ["PLR2004", "S", "T20"] # Magic numbers, security, print allowed in tests
+"onnx/backend/test/case/**" = ["N802"] # Function casing
+"onnx/reference/ops/**" = [
+    "N801", # Class casing
+    "PLR2004", # Magic numbers
+]
+"onnx/test/reference_evaluator_test.py" = ["C408"]  # dict(...) -> { ... }
+"onnx/test/**" = ["PLR2004", "S311", "T20"] # Magic numbers, non-crypto random, print allowed in tests
+"onnx/onnx_cpp2py_export/defs.pyi" = ["N802"]
+"onnx/fuzz/**" = [
+    "N802",     # TestOneInput is the required atheris entry-point name
+    "BLE001",   # Broad except is intentional: fuzz harnesses swallow all expected errors
+    "PLR2004",  # Magic numbers are fine in low-level fuzz scaffolding
+    "S112",     # try-except-continue is the correct pattern for per-version fuzzing
+    "PERF203",  # try-except in loop is unavoidable in the version-converter harness
+    "S311",     # Non-crypto random is fine for fuzz input shuffling
+]
+"onnx/gen_proto.py" = ["T20"] # Build script uses print for progress
+"onnx/defs/gen_*.py" = ["T20"] # Code generators use print for output
+"tools/**" = ["T20"] # Build tools use print for progress
+"examples/**" = ["T20"] # Example notebooks use print for output
+"docs/**" = ["T20"] # Doc scripts use print for debugging
diff --git a/renovate.json5 b/renovate.json5
new file mode 100644
index 0000000..8bbfcc8
--- /dev/null
+++ b/renovate.json5
@@ -0,0 +1,105 @@
+// Copyright (c) ONNX Project Contributors
+//
+// SPDX-License-Identifier: Apache-2.0
+
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  // Only enable specific managers to avoid overlap with dependabot
+  // Dependabot handles: pip (Python), github-actions
+  // Renovate handles: nanobind, googletest, and pixi lockfile (lock-file maintenance only -- see
+  // packageRules below; the version pins in pixi.toml are managed manually)
+  "enabledManagers": ["custom.regex", "pixi"],
+  // Disable the Dependency Dashboard issue
+  "dependencyDashboard": false,
+  // Regenerate lock files (pixi.lock) on a schedule to pull in newer versions
+  // permitted by the existing constraints, without editing the manifest.
+  "lockFileMaintenance": {
+    "enabled": true,
+    "schedule": ["on the first day of the month"]
+  },
+  // Wait one week after a release before creating an update PR
+  "minimumReleaseAge": "7 days",
+  // Apply labels to all Renovate PRs:
+  // - "module: dependencies" satisfies the "Require topic/module label" branch-protection check
+  // - "run release CIs" triggers release CI
+  "labels": ["module: dependencies", "run release CIs"],
+  // Add a note to every Renovate PR body explaining the update context
+  "prBodyNotes": [
+    "This PR was automatically created by [Renovate Bot](https://docs.renovatebot.com/) to keep build dependencies up to date.",
+    "Renovate manages dependencies **not** handled by Dependabot: manylinux Docker images, nanobind (via sbom.cdx.json), googletest (release tarball + SHA256), and the Pixi lockfile.",
+    "Please review the linked changelog/release notes before merging. A one-week stabilization period (`minimumReleaseAge`) has already elapsed since the new version was published."
+  ],
+  // Custom managers for dependencies not auto-detected by Renovate
+  "customManagers": [
+    {
+      // Detect manylinux Docker images in GitHub Actions workflows
+      // Example: uses: docker://quay.io/pypa/manylinux_2_28_x86_64:2024.10.10-1
+      "customType": "regex",
+      "fileMatch": ["^\\.github/workflows/release_linux\\.yml$"],
+      "matchStrings": [
+        "uses:\\s*docker://quay\\.io/pypa/(?<depName>manylinux_[^:]+):(?<currentValue>[0-9]{4}\\.[0-9]{2}\\.[0-9]{2}-[0-9]+)"
+      ],
+      "datasourceTemplate": "docker",
+      "depNameTemplate": "quay.io/pypa/{{{depName}}}",
+      "versioningTemplate": "loose"
+    },
+    {
+      // Detect nanobind version in sbom.cdx.json. CMakeLists.txt reads the version and
+      // GIT_REPOSITORY URL from this file via sbom_get_dep() (see cmake/Utils.cmake) rather
+      // than hardcoding them, so this is the only place the pin needs to be bumped.
+      // Example:
+      //   {
+      //     "type": "library",
+      //     "name": "nanobind",
+      //     "version": "2.12.0",
+      //     "bom-ref": "nanobind",
+      //     "purl": "pkg:github/wjakob/nanobind@v2.12.0",
+      // nanobind is fetched via GIT_TAG (git clone), not as a release tarball, so no
+      // hash is recorded here (see the "hashes" field on other sbom.cdx.json entries).
+      // If nanobind switches to publishing release tarballs, this should be migrated to
+      // github-releases with a URL + SHA256 hash (like googletest / protobuf / abseil-cpp).
+      "customType": "regex",
+      "fileMatch": ["^sbom\\.cdx\\.json$"],
+      "matchStrings": [
+        "\"name\":\\s*\"nanobind\",\\s*\"version\":\\s*\"(?<currentValue>[0-9]+\\.[0-9]+\\.[0-9]+)\",\\s*\"bom-ref\":\\s*\"nanobind\",\\s*\"purl\":\\s*\"pkg:github/(?<depName>[^/]+/[^@]+)@v[0-9]+\\.[0-9]+\\.[0-9]+\""
+      ],
+      "autoReplaceStringTemplate": "\"name\": \"nanobind\",\n      \"version\": \"{{{newValue}}}\",\n      \"bom-ref\": \"nanobind\",\n      \"purl\": \"pkg:github/{{{depName}}}@v{{{newValue}}}\"",
+      // github-tags is used because nanobind publishes tags (e.g. v2.12.0) but not GitHub releases
+      "datasourceTemplate": "github-tags"
+    },
+    {
+      // Detect googletest release tarball and SHA256 hash in cmake/external/googletest.cmake
+      // Example:
+      //   URL https://github.com/google/googletest/releases/download/v1.17.0/googletest-1.17.0.tar.gz
+      //   URL_HASH SHA256=65fab701d9829d38cb77c14acdc431d2108bfdbf8979e40eb8ae567edf10b27c
+      "customType": "regex",
+      "fileMatch": ["^cmake/external/googletest\\.cmake$"],
+      "matchStrings": [
+        "URL\\s+https://github\\.com/google/googletest/releases/download/v(?<currentValue>[0-9]+\\.[0-9]+\\.[0-9]+)/googletest-[0-9]+\\.[0-9]+\\.[0-9]+\\.tar\\.gz\\n\\s+URL_HASH\\s+SHA256=(?<currentDigest>[a-f0-9]+)"
+      ],
+      "autoReplaceStringTemplate": "URL https://github.com/google/googletest/releases/download/v{{{newValue}}}/googletest-{{{newValue}}}.tar.gz\n  URL_HASH SHA256={{{newDigest}}}",
+      "depNameTemplate": "google/googletest",
+      "datasourceTemplate": "github-releases",
+      "extractVersionTemplate": "^v(?<version>.*)$"
+    }
+  ],
+  // Package-specific rules for grouping
+  "packageRules": [
+    {
+      // Group manylinux Docker images together in a single PR
+      "matchDatasources": ["docker"],
+      "matchPackageNames": ["quay.io/pypa/manylinux_**"],
+      "groupName": "manylinux docker images"
+    },
+    {
+      // Do not bump the version pins in pixi.toml. Renovate only refreshes
+      // pixi.lock via lockFileMaintenance (configured above); the manifest
+      // constraints are managed manually. We disable every dependency-bump
+      // update type for the pixi manager but leave lockFileMaintenance on
+      // (it is a separate update type, not matched here).
+      "matchManagers": ["pixi"],
+      "matchUpdateTypes": ["major", "minor", "patch", "pin", "digest", "pinDigest"],
+      "enabled": false
+    }
+  ]
+}
diff --git a/requirements-dev.txt b/requirements-dev.txt
new file mode 100644
index 0000000..90001ca
--- /dev/null
+++ b/requirements-dev.txt
@@ -0,0 +1,13 @@
+build
+numpy
+protobuf
+pytest
+pytest-cov
+pytest-xdist
+setuptools
+wheel
+lintrunner>=0.13.1
+lintrunner-adapters>=0.14.0
+# Edit additional linter dependencies in requirements-lintrunner.txt
+# Dependencies for the reference implementation.
+Pillow
diff --git a/requirements-lintrunner.txt b/requirements-lintrunner.txt
new file mode 100644
index 0000000..e38cf19
--- /dev/null
+++ b/requirements-lintrunner.txt
@@ -0,0 +1,11 @@
+# This file is auto updated by dependabot
+lintrunner-adapters>=0.14.0
+# RUFF
+ruff==0.15.19
+# MYPY
+mypy==2.1.0
+types-protobuf==6.32.1.20260221
+# CLANG-FORMAT
+clang-format==22.1.5
+# EDITORCONFIG-CHECKER
+editorconfig-checker==3.6.1
diff --git a/requirements-release_test.txt b/requirements-release_test.txt
new file mode 100644
index 0000000..b31125d
--- /dev/null
+++ b/requirements-release_test.txt
@@ -0,0 +1,13 @@
+abi3audit
+check-wheel-contents
+pytest
+pytest-cov
+pytest-xdist
+# Pin dependency versions for testing
+numpy==2.0.0; python_version >= "3.10" and python_version <= "3.12"
+numpy==2.2.0; python_version == "3.13"
+numpy==2.3.2; python_version >= "3.14"
+protobuf==6.33.6
+
+# Dependencies for the reference implementation
+Pillow
diff --git a/sbom.cdx.json b/sbom.cdx.json
new file mode 100644
index 0000000..8ea324c
--- /dev/null
+++ b/sbom.cdx.json
@@ -0,0 +1,75 @@
+{
+  "$schema": "https://cyclonedx.org/schema/bom-1.7.schema.json",
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.7",
+  "version": 1,
+  "metadata": {
+    "lifecycles": [{"phase": "build"}],
+    "component": {
+      "type": "library",
+      "name": "onnx",
+      "description": "Open Neural Network Exchange — open format for AI/ML models",
+      "purl": "pkg:pypi/onnx",
+      "bom-ref": "onnx"
+    }
+  },
+  "components": [
+    {
+      "type": "library",
+      "name": "abseil-cpp",
+      "version": "20250127.0",
+      "bom-ref": "abseil-cpp",
+      "purl": "pkg:github/abseil/abseil-cpp@v20250127.0",
+      "externalReferences": [
+        {
+          "type": "distribution",
+          "url": "https://github.com/abseil/abseil-cpp/releases/download/20250127.0/abseil-cpp-20250127.0.tar.gz"
+        }
+      ],
+      "hashes": [
+        {"alg": "SHA-256", "content": "16242f394245627e508ec6bb296b433c90f8d914f73b9c026fddb905e27276e8"}
+      ],
+      "licenses": [{"license": {"id": "Apache-2.0"}}]
+    },
+    {
+      "type": "library",
+      "name": "protobuf",
+      "version": "31.1",
+      "bom-ref": "protobuf",
+      "purl": "pkg:github/protocolbuffers/protobuf@v31.1",
+      "externalReferences": [
+        {
+          "type": "distribution",
+          "url": "https://github.com/protocolbuffers/protobuf/releases/download/v31.1/protobuf-31.1.tar.gz"
+        }
+      ],
+      "hashes": [
+        {"alg": "SHA-256", "content": "12bfd76d27b9ac3d65c00966901609e020481b9474ef75c7ff4601ac06fa0b82"}
+      ],
+      "licenses": [{"license": {"id": "BSD-3-Clause"}}]
+    },
+    {
+      "type": "library",
+      "name": "nanobind",
+      "version": "2.13.0",
+      "bom-ref": "nanobind",
+      "purl": "pkg:github/wjakob/nanobind@v2.13.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/wjakob/nanobind.git"
+        }
+      ],
+      "licenses": [{"license": {"id": "BSD-3-Clause"}}]
+    }
+  ],
+  "dependencies": [
+    {
+      "ref": "onnx",
+      "dependsOn": ["abseil-cpp", "protobuf", "nanobind"]
+    },
+    {"ref": "abseil-cpp"},
+    {"ref": "protobuf"},
+    {"ref": "nanobind"}
+  ]
+}
diff --git a/tools/check_namespace.py b/tools/check_namespace.py
new file mode 100644
index 0000000..0cfb3f2
--- /dev/null
+++ b/tools/check_namespace.py
@@ -0,0 +1,30 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+"""Check that C++ files do not hardcode the onnx namespace.
+
+Other libraries that statically link with onnx can hide onnx symbols
+in a private namespace, so the namespace should not be hardcoded.
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def main() -> int:
+    violations = []
+    for path in sys.argv[1:]:
+        with open(path, encoding="utf-8") as f:
+            for line_no, line in enumerate(f, 1):
+                if "namespace onnx" in line or "onnx::" in line:
+                    violations.append(f"{path}:{line_no}: {line.rstrip()}")
+    if violations:
+        print("Hardcoded onnx namespace found:")
+        print("\n".join(violations))
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/gen_coverage_report.py b/tools/gen_coverage_report.py
new file mode 100755
index 0000000..3330147
--- /dev/null
+++ b/tools/gen_coverage_report.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import subprocess
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(os.path.basename(__file__))
+    parser.add_argument(
+        "-r",
+        "--root",
+        default=os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+        help="onnx root directory (default: %(default)s)",
+    )
+    parser.add_argument("-o", "--out", required=True, help="output directory")
+    return parser.parse_args()
+
+
+def _resolve(name: str) -> str:
+    path = shutil.which(name)
+    if path is None:
+        raise FileNotFoundError(f"{name!r} not found on PATH")
+    return path
+
+
+def gen_trace_file(root_dir: str, out_path: str) -> None:
+    lcov = _resolve("lcov")
+    subprocess.run(  # noqa: S603
+        [
+            lcov,
+            "-c",
+            "-d",
+            root_dir,
+            "--no-external",
+            "--path",
+            root_dir,
+            "-o",
+            out_path,
+        ],
+        check=True,
+    )
+
+    subprocess.run(  # noqa: S603
+        [
+            lcov,
+            "-r",
+            out_path,
+            os.path.join(root_dir, ".setuptools-cmake-build", "*"),
+            "-o",
+            out_path,
+        ],
+        check=True,
+    )
+
+
+def gen_html_files(root_dir: str, trace_path: str, out_dir: str) -> None:
+    subprocess.run(  # noqa: S603
+        [
+            _resolve("genhtml"),
+            trace_path,
+            "-p",
+            root_dir,
+            "-o",
+            out_dir,
+        ],
+        check=True,
+    )
+
+
+def main() -> None:
+    args = parse_args()
+
+    root = os.path.abspath(args.root)
+    out = os.path.abspath(args.out)
+    if not os.path.exists(out):
+        os.makedirs(out)
+
+    trace_path = os.path.join(out, "onnx-coverage.info")
+    gen_trace_file(root, trace_path)
+
+    html_dir = os.path.join(out, "html")
+    gen_html_files(root, trace_path, html_dir)
+
+    print(f"Static HTML files have been generated at:\n\t{html_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/pixi-shim.py b/tools/pixi-shim.py
new file mode 100644
index 0000000..5cd7ea4
--- /dev/null
+++ b/tools/pixi-shim.py
@@ -0,0 +1,32 @@
+# Copyright (c) ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Wrapper that runs a command via pixi if available, otherwise directly.
+
+Usage: python tools/pixi-shim.py <command> [args...]
+
+This allows non-pixi users to run pre-commit hooks by having the
+required tools (ruff, mypy, clang-format, shellcheck, reuse, typos) on their PATH.
+
+The 'default' environment is used if Pixi is available.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+import warnings
+
+args = sys.argv[1:]
+
+if shutil.which("pixi"):
+    raise SystemExit(subprocess.call(["pixi", "run", "--", *args]))  # noqa: S603, S607
+
+warnings.warn(
+    "pixi not found. Running tools directly from PATH. "
+    "Install pixi for a fully managed environment: https://pixi.sh",
+    stacklevel=1,
+)
+raise SystemExit(subprocess.call(args))  # noqa: S603
diff --git a/tools/pretty_clang_tidy.py b/tools/pretty_clang_tidy.py
new file mode 100644
index 0000000..ebcd521
--- /dev/null
+++ b/tools/pretty_clang_tidy.py
@@ -0,0 +1,35 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Thin wrapper around run-clang-tidy that filters noisy output."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+
+NOISE = re.compile(
+    r"^\[|^\d+ warnings? generated\.|^Suppressed \d|^Use -header-filter"
+    r"|\[\d+/\d+\] \(\d+/\d+\) Processing file"
+)
+ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def main() -> int:
+    result = subprocess.run(sys.argv[1:], capture_output=True, text=True)  # noqa: S603,PLW1510
+    prev_blank = False
+    for line in (result.stdout + result.stderr).splitlines(keepends=True):
+        if NOISE.match(ANSI_ESCAPE.sub("", line)):
+            continue
+        if line.strip():
+            prev_blank = False
+        else:
+            if prev_blank:
+                continue
+            prev_blank = True
+        sys.stdout.write(line)
+    return result.returncode
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/update_doc.bat b/tools/update_doc.bat
new file mode 100644
index 0000000..5000eef
--- /dev/null
+++ b/tools/update_doc.bat
@@ -0,0 +1,19 @@
+REM Copyright (c) ONNX Project Contributors
+
+:: SPDX-License-Identifier: Apache-2.0
+
+:: Run this script from ONNX root directory under Anaconda.
+set CMAKE_ARGS="-DONNX_USE_PROTOBUF_SHARED_LIBS=ON"
+set ONNX_ML=1
+
+python onnx\gen_proto.py -l
+
+python onnx\gen_proto.py -l --ml
+
+python -m pip install -e . --no-build-isolation
+
+python onnx\backend\test\cmd_tools.py generate-data
+
+python onnx\backend\test\stat_coverage.py
+
+python onnx\defs\gen_doc.py
diff --git a/tools/update_doc.sh b/tools/update_doc.sh
new file mode 100755
index 0000000..45eff73
--- /dev/null
+++ b/tools/update_doc.sh
@@ -0,0 +1,35 @@
+#!/bin/bash
+
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+
+
+# export ONNX_ML=0, # if you need to disable ONNX_ML
+
+python_exist=$(command -v python)
+if [[ -z $python_exist ]]; then
+  echo "No python is found, please set it in your environment."
+  exit 1
+fi
+
+if [[ ! -f "onnx/defs/gen_doc.py" ]]; then
+  echo "Please run this script in the ONNX root folder."
+  exit 1
+fi
+
+set -e
+
+echo -e "===> recompile onnx"
+python -m pip install -e . --no-build-isolation
+
+echo -e "\n===> regenerate test data from node test"
+python onnx/backend/test/cmd_tools.py generate-data
+
+echo -e "\n===> regenerate stats of test data"
+python onnx/backend/test/stat_coverage.py
+
+echo -e "\n===> regenerate the docs"
+python onnx/defs/gen_doc.py
+
+echo -e "\n===> the update is done!"
diff --git a/typos.toml b/typos.toml
new file mode 100644
index 0000000..651c7ff
--- /dev/null
+++ b/typos.toml
@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: ONNX Project Contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+[default.extend-words]
+ND = "ND"
+ONNX = "ONNX"
+"np.arange" = "np.arange"
+CNA = "CNA"  # Cloud Native Association
+writeable = "writeable"
+
+[default]
+extend-ignore-re = [
+  "np\\.arange",
+  # Ignore lines that end with a `typos: ignore` comment
+  "(?Rm)^.*(#|//)\\s*typos:\\s*ignore$",
+  # Ignore lines that end with a `reviewdog:ignore[misspell]` comment
+  "(?Rm)^.*(#|//)\\s*reviewdog:ignore\\[misspell\\]",
+]
+
+# The following sets up some additional ignores for specific files.
+# typos does not offer a good option to configur per-file rules.
+# The following works by glob-matching on the file name which is less
+# precise but seems good enough.
+[type.op_roi_align_py]
+extend-glob = ["op_roi_align.py"]
+extend-words = { iy = "iy" }
+
+[type.group_normalization_20_21_h]
+extend-glob = ["group_normalization_20_21.h"]
+extend-words = { kend = "kend" }
+
+[type.doc_strings_cc]
+extend-glob = ["doc_strings.cc"]
+extend-words = { ot = "ot", iof = "iof"  }
+
+[type.defs_cc]
+extend-glob = ["defs.cc"]
+extend-words = { ot = "ot", iof = "iof"  }
+
+[type.old_cc]
+extend-glob = ["old.cc"]
+extend-words = { ot = "ot", iof = "iof"  }
+
+[type.operators_md]
+extend-glob = ["Operators.md"]
+extend-words = { ot = "ot", iof = "iof" }
+
+[type.op_conv_py]
+extend-glob = ["op_conv.py"]
+extend-words = { iz = "iz" }
+
+[type.changelog_md]
+extend-glob = ["Changelog.md"]
+extend-words = { ot = "ot", iof = "iof"  }
+extend-ignore-re = ["foward\\)"]  # typo in published spec
+
+[type.lint_yml]
+extend-glob = ["lint.yml"]
+extend-ignore-re = ["foward,"]  # typo in published spec